diff --git a/.gitignore b/.gitignore index 39961ebb02..ebf255743a 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,6 @@ __pycache__ .devenv* devenv.local.nix +# Internal planning / research notes +/plans/ + diff --git a/docs/reference/changelog.md b/docs/reference/changelog.md index fcd7f3f0b0..33f77eee00 100644 --- a/docs/reference/changelog.md +++ b/docs/reference/changelog.md @@ -1,6 +1,15 @@ # Changelog All notable changes to this project will be documented in this file. +## [Unreleased] + +### Features + +- (oracle) Add experimental Oracle database support for the built-in Go code + generator: PL/SQL parser (ANTLR grammars-v4), catalog with built-in + functions, and Oracle-to-Go type mapping targeting `github.com/sijms/go-ora/v2`. + Enable with `engine: "oracle"`. + (v1-31-1)= ## [1.31.1](https://github.com/sqlc-dev/sqlc/releases/tag/v1.31.1) Released 2026-04-22 diff --git a/docs/reference/config.md b/docs/reference/config.md index c88d41d963..f2844ed09e 100644 --- a/docs/reference/config.md +++ b/docs/reference/config.md @@ -37,7 +37,8 @@ Each mapping in the `sql` collection has the following keys: - `name`: - An human-friendly identifier for this query set. Optional. - `engine`: - - One of `postgresql`, `mysql` or `sqlite`. + - One of `postgresql`, `mysql`, `sqlite` or `oracle`. The `oracle` engine is + experimental and currently supported only by the built-in Go code generator. - `schema`: - Directory of SQL migrations or path to single SQL file; or a list of paths. - `queries`: diff --git a/docs/reference/language-support.rst b/docs/reference/language-support.rst index 48840e1a3e..78af9f1242 100644 --- a/docs/reference/language-support.rst +++ b/docs/reference/language-support.rst @@ -1,15 +1,15 @@ Database and language support ############################# -========== ======================= ============ ============ =============== -Language Plugin MySQL PostgreSQL SQLite -========== ======================= ============ ============ =============== -Go (built-in) Stable Stable Beta -Go `sqlc-gen-go`_ Stable Stable Beta -Kotlin `sqlc-gen-kotlin`_ Beta Beta Not implemented -Python `sqlc-gen-python`_ Beta Beta Not implemented -TypeScript `sqlc-gen-typescript`_ Beta Beta Not implemented -========== ======================= ============ ============ =============== +========== ======================= ============ ============ =============== =============== +Language Plugin MySQL PostgreSQL SQLite Oracle +========== ======================= ============ ============ =============== =============== +Go (built-in) Stable Stable Beta Experimental +Go `sqlc-gen-go`_ Stable Stable Beta Not implemented +Kotlin `sqlc-gen-kotlin`_ Beta Beta Not implemented Not implemented +Python `sqlc-gen-python`_ Beta Beta Not implemented Not implemented +TypeScript `sqlc-gen-typescript`_ Beta Beta Not implemented Not implemented +========== ======================= ============ ============ =============== =============== Community language support ************************** diff --git a/internal/cmd/parse.go b/internal/cmd/parse.go index aca01511f1..0a07495da1 100644 --- a/internal/cmd/parse.go +++ b/internal/cmd/parse.go @@ -10,6 +10,7 @@ import ( "github.com/sqlc-dev/sqlc/internal/engine/clickhouse" "github.com/sqlc-dev/sqlc/internal/engine/dolphin" + "github.com/sqlc-dev/sqlc/internal/engine/oracle" "github.com/sqlc-dev/sqlc/internal/engine/postgresql" "github.com/sqlc-dev/sqlc/internal/engine/sqlite" "github.com/sqlc-dev/sqlc/internal/sql/ast" @@ -39,7 +40,7 @@ Examples: return err } if dialect == "" { - return fmt.Errorf("--dialect flag is required (postgresql, mysql, sqlite, or clickhouse)") + return fmt.Errorf("--dialect flag is required (postgresql, mysql, sqlite, oracle, or clickhouse)") } // Determine input source @@ -75,11 +76,14 @@ Examples: case "sqlite": parser := sqlite.NewParser() stmts, err = parser.Parse(input) + case "oracle", "plsql": + parser := oracle.NewParser() + stmts, err = parser.Parse(input) case "clickhouse": parser := clickhouse.NewParser() stmts, err = parser.Parse(input) default: - return fmt.Errorf("unsupported dialect: %s (use postgresql, mysql, sqlite, or clickhouse)", dialect) + return fmt.Errorf("unsupported dialect: %s (use postgresql, mysql, sqlite, oracle, or clickhouse)", dialect) } if err != nil { return fmt.Errorf("parse error: %w", err) diff --git a/internal/codegen/golang/go_type.go b/internal/codegen/golang/go_type.go index 21914736d0..6802d351a8 100644 --- a/internal/codegen/golang/go_type.go +++ b/internal/codegen/golang/go_type.go @@ -86,6 +86,8 @@ func goInnerType(req *plugin.GenerateRequest, options *opts.Options, col *plugin return postgresType(req, options, col) case "sqlite": return sqliteType(req, options, col) + case "oracle": + return oracleType(req, options, col) default: return "interface{}" } diff --git a/internal/codegen/golang/oracle_type.go b/internal/codegen/golang/oracle_type.go new file mode 100644 index 0000000000..3bedd4cc20 --- /dev/null +++ b/internal/codegen/golang/oracle_type.go @@ -0,0 +1,156 @@ +package golang + +import ( + "log" + "strings" + + "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" + "github.com/sqlc-dev/sqlc/internal/codegen/sdk" + "github.com/sqlc-dev/sqlc/internal/debug" + "github.com/sqlc-dev/sqlc/internal/plugin" +) + +// oracleType maps an Oracle column type to a Go type. It targets the +// github.com/sijms/go-ora/v2 driver, which implements database/sql, so the +// nullable variants use the standard sql.Null* wrappers (or pointers when +// EmitPointersForNullTypes is set), mirroring the SQLite engine's mapping. +// +// Oracle type semantics (per go-ora): +// - NUMBER with scale 0 -> integer (int64) +// - NUMBER with scale > 0 -> float64 +// sqlc does not track scale in the built-in analyzer, so bare NUMBER maps +// to float64 to avoid silently truncating fractional values; INTEGER/INT and +// the PL/SQL integer types map to int64. +// - VARCHAR2/CHAR/CLOB/etc. -> string +// - DATE/TIMESTAMP* -> time.Time +// - RAW/BLOB/LONG RAW/BFILE -> []byte +// - BINARY_FLOAT/BINARY_DOUBLE -> float64 +func oracleType(req *plugin.GenerateRequest, options *opts.Options, col *plugin.Column) string { + dt := strings.ToLower(sdk.DataType(col.Type)) + notNull := col.NotNull || col.IsArray + emitPointersForNull := options.EmitPointersForNullTypes + + nullableString := func() string { + if notNull { + return "string" + } + if emitPointersForNull { + return "*string" + } + return "sql.NullString" + } + nullableInt64 := func() string { + if notNull { + return "int64" + } + if emitPointersForNull { + return "*int64" + } + return "sql.NullInt64" + } + nullableFloat64 := func() string { + if notNull { + return "float64" + } + if emitPointersForNull { + return "*float64" + } + return "sql.NullFloat64" + } + nullableTime := func() string { + if notNull { + return "time.Time" + } + if emitPointersForNull { + return "*time.Time" + } + return "sql.NullTime" + } + nullableBool := func() string { + if notNull { + return "bool" + } + if emitPointersForNull { + return "*bool" + } + return "sql.NullBool" + } + + switch dt { + + // Integer types. + case "integer", "int", "smallint", + "binary_integer", "pls_integer", "simple_integer", + "natural", "naturaln", "positive", "positiven", "signtype": + return nullableInt64() + + // Fixed / floating point numeric types. + case "number", "numeric", "dec", "decimal", + "float", "real", "double precision", "double", + "binary_float", "binary_double": + return nullableFloat64() + + // Boolean (Oracle 23c native BOOLEAN / PL/SQL BOOLEAN). + case "boolean", "bool": + return nullableBool() + + // Date / time types. + case "date", + "timestamp", + "timestamp_unconstrained", + "timestamp_tz_unconstrained", + "timestamp_ltz_unconstrained": + return nullableTime() + + // Binary types. + case "raw", "long raw", "longraw", "blob", "bfile": + return "[]byte" + + // XML. + case "xmltype": + return nullableString() + + case "any": + return "interface{}" + } + + // Prefix-based matches for parameterized types (e.g. VARCHAR2(100), + // TIMESTAMP(6), TIMESTAMP WITH TIME ZONE, INTERVAL ...). + switch { + case strings.HasPrefix(dt, "varchar2"), + strings.HasPrefix(dt, "nvarchar2"), + strings.HasPrefix(dt, "varchar"), + strings.HasPrefix(dt, "char"), + strings.HasPrefix(dt, "nchar"), + strings.HasPrefix(dt, "character"), + strings.HasPrefix(dt, "clob"), + strings.HasPrefix(dt, "nclob"), + strings.HasPrefix(dt, "long"), + strings.HasPrefix(dt, "string"), + strings.HasPrefix(dt, "rowid"), + strings.HasPrefix(dt, "urowid"): + return nullableString() + + case strings.HasPrefix(dt, "timestamp"): + return nullableTime() + + case strings.HasPrefix(dt, "interval"): + // Oracle INTERVAL types are surfaced as strings by go-ora. + return nullableString() + + case strings.HasPrefix(dt, "number"), + strings.HasPrefix(dt, "numeric"), + strings.HasPrefix(dt, "decimal"), + strings.HasPrefix(dt, "dec"), + strings.HasPrefix(dt, "float"): + return nullableFloat64() + + case strings.HasPrefix(dt, "raw"): + return "[]byte" + } + + if debug.Active { + log.Printf("unknown Oracle type: %s\n", dt) + } + return "interface{}" +} diff --git a/internal/codegen/golang/oracle_type_test.go b/internal/codegen/golang/oracle_type_test.go new file mode 100644 index 0000000000..3ee60098c8 --- /dev/null +++ b/internal/codegen/golang/oracle_type_test.go @@ -0,0 +1,57 @@ +package golang + +import ( + "testing" + + "github.com/sqlc-dev/sqlc/internal/codegen/golang/opts" + "github.com/sqlc-dev/sqlc/internal/plugin" +) + +func TestOracleType(t *testing.T) { + req := &plugin.GenerateRequest{Settings: &plugin.Settings{Engine: "oracle"}} + + cases := []struct { + name string + dataType string + notNull bool + emitPtr bool + want string + }{ + {"number nullable", "number", false, false, "sql.NullFloat64"}, + {"number not null", "number", true, false, "float64"}, + {"number ptr", "number", false, true, "*float64"}, + {"integer not null", "integer", true, false, "int64"}, + {"int nullable", "int", false, false, "sql.NullInt64"}, + {"varchar2 not null", "varchar2", true, false, "string"}, + {"varchar2(100) not null", "varchar2(100)", true, false, "string"}, + {"nvarchar2 nullable", "nvarchar2", false, false, "sql.NullString"}, + {"char not null", "char", true, false, "string"}, + {"clob not null", "clob", true, false, "string"}, + {"date not null", "date", true, false, "time.Time"}, + {"timestamp nullable", "timestamp", false, false, "sql.NullTime"}, + {"timestamp(6) not null", "timestamp(6)", true, false, "time.Time"}, + {"raw", "raw", true, false, "[]byte"}, + {"blob", "blob", true, false, "[]byte"}, + {"binary_double not null", "binary_double", true, false, "float64"}, + {"boolean not null", "boolean", true, false, "bool"}, + {"boolean nullable", "boolean", false, false, "sql.NullBool"}, + {"interval", "interval", true, false, "string"}, + {"rowid", "rowid", true, false, "string"}, + {"unknown", "sdo_geometry_xyz", true, false, "interface{}"}, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + options := &opts.Options{EmitPointersForNullTypes: tc.emitPtr} + col := &plugin.Column{ + Type: &plugin.Identifier{Name: tc.dataType}, + NotNull: tc.notNull, + } + got := oracleType(req, options, col) + if got != tc.want { + t.Errorf("oracleType(%q, notNull=%v, emitPtr=%v) = %q, want %q", + tc.dataType, tc.notNull, tc.emitPtr, got, tc.want) + } + }) + } +} diff --git a/internal/compiler/engine.go b/internal/compiler/engine.go index 64fdf3d5c7..a2e0390905 100644 --- a/internal/compiler/engine.go +++ b/internal/compiler/engine.go @@ -8,6 +8,7 @@ import ( "github.com/sqlc-dev/sqlc/internal/config" "github.com/sqlc-dev/sqlc/internal/dbmanager" "github.com/sqlc-dev/sqlc/internal/engine/dolphin" + "github.com/sqlc-dev/sqlc/internal/engine/oracle" "github.com/sqlc-dev/sqlc/internal/engine/postgresql" pganalyze "github.com/sqlc-dev/sqlc/internal/engine/postgresql/analyzer" "github.com/sqlc-dev/sqlc/internal/engine/sqlite" @@ -82,6 +83,10 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts c.parser = dolphin.NewParser() c.catalog = dolphin.NewCatalog() c.selector = newDefaultSelector() + case config.EngineOracle: + c.parser = oracle.NewParser() + c.catalog = oracle.NewCatalog() + c.selector = newDefaultSelector() case config.EnginePostgreSQL: parser := postgresql.NewParser() c.parser = parser diff --git a/internal/config/config.go b/internal/config/config.go index ff7faedcaa..583ba7439c 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -54,6 +54,7 @@ const ( EngineMySQL Engine = "mysql" EnginePostgreSQL Engine = "postgresql" EngineSQLite Engine = "sqlite" + EngineOracle Engine = "oracle" ) type Config struct { diff --git a/internal/config/v_one.json b/internal/config/v_one.json index d4ea6b6304..1904b7298c 100644 --- a/internal/config/v_one.json +++ b/internal/config/v_one.json @@ -35,7 +35,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "schema": { @@ -200,7 +201,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "nullable": { @@ -320,7 +322,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "nullable": { diff --git a/internal/config/v_two.json b/internal/config/v_two.json index f4cfb875c0..24234d5dee 100644 --- a/internal/config/v_two.json +++ b/internal/config/v_two.json @@ -38,7 +38,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "schema": { @@ -209,7 +210,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "nullable": { @@ -378,7 +380,8 @@ "enum": [ "postgresql", "mysql", - "sqlite" + "sqlite", + "oracle" ] }, "nullable": { diff --git a/internal/endtoend/testdata/oracle_authors/oracle/go/db.go b/internal/endtoend/testdata/oracle_authors/oracle/go/db.go new file mode 100644 index 0000000000..8507927d36 --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/go/db.go @@ -0,0 +1,31 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package authors + +import ( + "context" + "database/sql" +) + +type DBTX interface { + ExecContext(context.Context, string, ...interface{}) (sql.Result, error) + PrepareContext(context.Context, string) (*sql.Stmt, error) + QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error) + QueryRowContext(context.Context, string, ...interface{}) *sql.Row +} + +func New(db DBTX) *Queries { + return &Queries{db: db} +} + +type Queries struct { + db DBTX +} + +func (q *Queries) WithTx(tx *sql.Tx) *Queries { + return &Queries{ + db: tx, + } +} diff --git a/internal/endtoend/testdata/oracle_authors/oracle/go/models.go b/internal/endtoend/testdata/oracle_authors/oracle/go/models.go new file mode 100644 index 0000000000..45104ed076 --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/go/models.go @@ -0,0 +1,15 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 + +package authors + +import ( + "database/sql" +) + +type Author struct { + ID float64 + Name string + Bio sql.NullString +} diff --git a/internal/endtoend/testdata/oracle_authors/oracle/go/query.sql.go b/internal/endtoend/testdata/oracle_authors/oracle/go/query.sql.go new file mode 100644 index 0000000000..8816732346 --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/go/query.sql.go @@ -0,0 +1,74 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: query.sql + +package authors + +import ( + "context" + "database/sql" +) + +const createAuthor = `-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (:1, :2, :3) +` + +type CreateAuthorParams struct { + ID float64 + Name string + Bio sql.NullString +} + +func (q *Queries) CreateAuthor(ctx context.Context, arg CreateAuthorParams) error { + _, err := q.db.ExecContext(ctx, createAuthor, arg.ID, arg.Name, arg.Bio) + return err +} + +const deleteAuthor = `-- name: DeleteAuthor :exec +DELETE FROM authors WHERE id = :1 +` + +func (q *Queries) DeleteAuthor(ctx context.Context, id float64) error { + _, err := q.db.ExecContext(ctx, deleteAuthor, id) + return err +} + +const getAuthor = `-- name: GetAuthor :one +SELECT id, name, bio FROM authors +WHERE id = :1 +` + +func (q *Queries) GetAuthor(ctx context.Context, id float64) (Author, error) { + row := q.db.QueryRowContext(ctx, getAuthor, id) + var i Author + err := row.Scan(&i.ID, &i.Name, &i.Bio) + return i, err +} + +const listAuthors = `-- name: ListAuthors :many +SELECT id, name, bio FROM authors +` + +func (q *Queries) ListAuthors(ctx context.Context) ([]Author, error) { + rows, err := q.db.QueryContext(ctx, listAuthors) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Author + for rows.Next() { + var i Author + if err := rows.Scan(&i.ID, &i.Name, &i.Bio); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} diff --git a/internal/endtoend/testdata/oracle_authors/oracle/query.sql b/internal/endtoend/testdata/oracle_authors/oracle/query.sql new file mode 100644 index 0000000000..381bd398cd --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/query.sql @@ -0,0 +1,12 @@ +-- name: GetAuthor :one +SELECT id, name, bio FROM authors +WHERE id = :1; + +-- name: ListAuthors :many +SELECT id, name, bio FROM authors; + +-- name: CreateAuthor :exec +INSERT INTO authors (id, name, bio) VALUES (:1, :2, :3); + +-- name: DeleteAuthor :exec +DELETE FROM authors WHERE id = :1; diff --git a/internal/endtoend/testdata/oracle_authors/oracle/schema.sql b/internal/endtoend/testdata/oracle_authors/oracle/schema.sql new file mode 100644 index 0000000000..17228ec9eb --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/schema.sql @@ -0,0 +1,5 @@ +CREATE TABLE authors ( + id NUMBER NOT NULL, + name VARCHAR2(100) NOT NULL, + bio CLOB +); diff --git a/internal/endtoend/testdata/oracle_authors/oracle/sqlc.json b/internal/endtoend/testdata/oracle_authors/oracle/sqlc.json new file mode 100644 index 0000000000..b4834e3f3c --- /dev/null +++ b/internal/endtoend/testdata/oracle_authors/oracle/sqlc.json @@ -0,0 +1,12 @@ +{ + "version": "1", + "packages": [ + { + "path": "go", + "name": "authors", + "engine": "oracle", + "schema": "schema.sql", + "queries": "query.sql" + } + ] +} diff --git a/internal/engine/oracle/catalog.go b/internal/engine/oracle/catalog.go new file mode 100644 index 0000000000..d3b7f6e8a2 --- /dev/null +++ b/internal/engine/oracle/catalog.go @@ -0,0 +1,27 @@ +package oracle + +import "github.com/sqlc-dev/sqlc/internal/sql/catalog" + +// defaultSchemaName is the catalog's default schema. Oracle resolves unqualified +// objects against the connected user's schema; sqlc needs a concrete default, so +// we use a neutral name that CREATE TABLE statements without a schema prefix +// resolve into. +const defaultSchemaName = "public" + +// NewCatalog returns a catalog seeded with Oracle's built-in schema, types and +// functions. Schema objects (tables, views) are added by the compiler as it +// walks the parsed DDL. +func NewCatalog() *catalog.Catalog { + return &catalog.Catalog{ + DefaultSchema: defaultSchemaName, + Schemas: []*catalog.Schema{ + defaultSchema(defaultSchemaName), + }, + Extensions: map[string]struct{}{}, + } +} + +// newTestCatalog returns an empty catalog for use in unit tests. +func newTestCatalog() *catalog.Catalog { + return catalog.New(defaultSchemaName) +} diff --git a/internal/engine/oracle/catalog_test.go b/internal/engine/oracle/catalog_test.go new file mode 100644 index 0000000000..38ec9496b6 --- /dev/null +++ b/internal/engine/oracle/catalog_test.go @@ -0,0 +1,81 @@ +package oracle + +import ( + "strings" + "testing" + + "github.com/sqlc-dev/sqlc/internal/sql/ast" + "github.com/sqlc-dev/sqlc/internal/sql/catalog" +) + +func TestNewCatalog(t *testing.T) { + c := NewCatalog() + if c.DefaultSchema != defaultSchemaName { + t.Fatalf("DefaultSchema = %q, want %q", c.DefaultSchema, defaultSchemaName) + } + if len(c.Schemas) != 1 { + t.Fatalf("expected 1 schema, got %d", len(c.Schemas)) + } + if len(c.Schemas[0].Funcs) == 0 { + t.Fatalf("expected built-in functions to be seeded") + } + + // Spot-check a few well-known Oracle functions are present. + want := map[string]bool{"NVL": false, "TO_CHAR": false, "SYSDATE": false, "COUNT": false} + for _, f := range c.Schemas[0].Funcs { + if _, ok := want[f.Name]; ok { + want[f.Name] = true + } + } + for name, found := range want { + if !found { + t.Errorf("expected built-in function %q to be registered", name) + } + } +} + +func TestCatalogBuildCreateTable(t *testing.T) { + p := NewParser() + stmts, err := p.Parse(strings.NewReader(`CREATE TABLE employees (id NUMBER NOT NULL, name VARCHAR2(100))`)) + if err != nil { + t.Fatalf("Parse returned error: %v", err) + } + + c := NewCatalog() + if err := c.Build(stmts); err != nil { + t.Fatalf("catalog.Build returned error: %v", err) + } + + tbl, err := c.GetTable(&ast.TableName{Schema: defaultSchemaName, Name: "employees"}) + if err != nil { + t.Fatalf("GetTable(employees) error: %v", err) + } + if tbl.Rel == nil || tbl.Rel.Name != "employees" { + t.Fatalf("expected table 'employees', got %+v", tbl.Rel) + } + if len(tbl.Columns) != 2 { + t.Fatalf("expected 2 columns, got %d", len(tbl.Columns)) + } + if tbl.Columns[0].Name != "id" { + t.Errorf("col0 name = %q, want id", tbl.Columns[0].Name) + } + if !tbl.Columns[0].IsNotNull { + t.Errorf("col0 (id) should be NOT NULL") + } +} + +func TestIsBuiltinType(t *testing.T) { + for _, name := range []string{"NUMBER", "number", "VarChar2", "clob", "DATE", "TIMESTAMP"} { + if !IsBuiltinType(name) { + t.Errorf("IsBuiltinType(%q) = false, want true", name) + } + } + for _, name := range []string{"jsonb", "geometry", ""} { + if IsBuiltinType(name) { + t.Errorf("IsBuiltinType(%q) = true, want false", name) + } + } +} + +// ensure newTestCatalog is available and functional for future tests. +var _ = func() *catalog.Catalog { return newTestCatalog() } diff --git a/internal/engine/oracle/convert.go b/internal/engine/oracle/convert.go new file mode 100644 index 0000000000..b256e44bba --- /dev/null +++ b/internal/engine/oracle/convert.go @@ -0,0 +1,848 @@ +package oracle + +import ( + "log" + "strconv" + "strings" + + "github.com/antlr4-go/antlr/v4" + + "github.com/sqlc-dev/sqlc/internal/debug" + "github.com/sqlc-dev/sqlc/internal/engine/oracle/parser" + "github.com/sqlc-dev/sqlc/internal/sql/ast" +) + +// cc is the Oracle parse-tree -> shared-AST converter. It mirrors the SQLite +// engine's converter: one convertXxx method per grammar construct, dispatched +// from convert(). Anything not yet handled returns *ast.TODO, which Parse skips. +type cc struct { + paramCount int +} + +type node interface { + GetParser() antlr.Parser +} + +func todo(funcname string, n node) *ast.TODO { + if debug.Active { + log.Printf("oracle.%s: Unknown node type %T\n", funcname, n) + } + return &ast.TODO{} +} + +// newString is a small constructor for ast.String used throughout the converter. +func newString(s string) *ast.String { + return &ast.String{Str: s} +} + +// identifier normalizes an Oracle identifier. Oracle folds unquoted identifiers +// to UPPER case, but sqlc's catalog comparisons are lower-case throughout, so we +// fold to lower case for unquoted identifiers and strip quotes for quoted ones. +func identifier(id string) string { + if len(id) >= 2 && id[0] == '"' && id[len(id)-1] == '"' { + return id[1 : len(id)-1] + } + return strings.ToLower(id) +} + +// convert is the top-level dispatch for a unit_statement. +func (c *cc) convert(n *parser.Unit_statementContext) ast.Node { + if n == nil { + return &ast.TODO{} + } + if ct := n.Create_table(); ct != nil { + if ctx, ok := ct.(*parser.Create_tableContext); ok { + return c.convertCreateTable(ctx) + } + } + if dml := n.Data_manipulation_language_statements(); dml != nil { + if ctx, ok := dml.(*parser.Data_manipulation_language_statementsContext); ok { + return c.convertDML(ctx) + } + } + return todo("convert", n) +} + +func (c *cc) convertDML(n *parser.Data_manipulation_language_statementsContext) ast.Node { + if s := n.Select_statement(); s != nil { + if ctx, ok := s.(*parser.Select_statementContext); ok { + return c.convertSelectStatement(ctx) + } + } + if s := n.Insert_statement(); s != nil { + if ctx, ok := s.(*parser.Insert_statementContext); ok { + return c.convertInsertStatement(ctx) + } + } + if s := n.Update_statement(); s != nil { + if ctx, ok := s.(*parser.Update_statementContext); ok { + return c.convertUpdateStatement(ctx) + } + } + if s := n.Delete_statement(); s != nil { + if ctx, ok := s.(*parser.Delete_statementContext); ok { + return c.convertDeleteStatement(ctx) + } + } + return todo("convertDML", n) +} + +// --------------------------------------------------------------------------- +// CREATE TABLE +// --------------------------------------------------------------------------- + +func (c *cc) convertCreateTable(n *parser.Create_tableContext) ast.Node { + tn := &ast.TableName{} + if sc := n.Schema_name(); sc != nil { + if ctx, ok := sc.(*parser.Schema_nameContext); ok { + tn.Schema = identifier(ctx.GetText()) + } + } + if t := n.Table_name(); t != nil { + tn.Name = identifier(t.GetText()) + } + + stmt := &ast.CreateTableStmt{ + Name: tn, + IfNotExists: n.EXISTS() != nil, + } + + rt := n.Relational_table() + if rt == nil { + return stmt + } + rtc, ok := rt.(*parser.Relational_tableContext) + if !ok { + return stmt + } + for _, iprop := range rtc.AllRelational_property() { + prop, ok := iprop.(*parser.Relational_propertyContext) + if !ok { + continue + } + coldef := prop.Column_definition() + if coldef == nil { + continue + } + cd, ok := coldef.(*parser.Column_definitionContext) + if !ok { + continue + } + col := c.convertColumnDefinition(cd) + if col != nil { + stmt.Cols = append(stmt.Cols, col) + } + } + return stmt +} + +func (c *cc) convertColumnDefinition(n *parser.Column_definitionContext) *ast.ColumnDef { + name := "" + if cn := n.Column_name(); cn != nil { + name = identifier(cn.GetText()) + } + typeName := "any" + if dt := n.Datatype(); dt != nil { + if ctx, ok := dt.(*parser.DatatypeContext); ok { + typeName = normalizeDatatype(ctx) + } + } else if tn := n.Type_name(); tn != nil { + typeName = identifier(tn.GetText()) + } + return &ast.ColumnDef{ + Colname: name, + TypeName: &ast.TypeName{Name: typeName}, + IsNotNull: hasNotNull(n), + } +} + +// normalizeDatatype extracts the base Oracle native type name (lower-cased), +// dropping precision/scale so the catalog can key on the bare type. +func normalizeDatatype(n *parser.DatatypeContext) string { + if nde := n.Native_datatype_element(); nde != nil { + return strings.ToLower(nde.GetText()) + } + if n.INTERVAL() != nil { + return "interval" + } + return strings.ToLower(n.GetText()) +} + +// hasNotNull reports whether any inline constraint on the column is NOT NULL. +func hasNotNull(n *parser.Column_definitionContext) bool { + for _, ic := range n.AllInline_constraint() { + if strings.Contains(strings.ToUpper(ic.GetText()), "NOTNULL") || + strings.Contains(strings.ToUpper(ic.GetText()), "NOT NULL") { + return true + } + // Text has whitespace stripped by GetText(); "NOT NULL" becomes "NOTNULL". + } + return false +} + +// --------------------------------------------------------------------------- +// SELECT +// --------------------------------------------------------------------------- + +func (c *cc) convertSelectStatement(n *parser.Select_statementContext) ast.Node { + only := n.Select_only_statement() + if only == nil { + return todo("convertSelectStatement", n) + } + oc, ok := only.(*parser.Select_only_statementContext) + if !ok { + return todo("convertSelectStatement", n) + } + sub := oc.Subquery() + if sub == nil { + return todo("convertSelectStatement", n) + } + sc, ok := sub.(*parser.SubqueryContext) + if !ok { + return todo("convertSelectStatement", n) + } + basic := sc.Subquery_basic_elements() + if basic == nil { + return todo("convertSelectStatement", n) + } + be, ok := basic.(*parser.Subquery_basic_elementsContext) + if !ok { + return todo("convertSelectStatement", n) + } + qb := be.Query_block() + if qb == nil { + return todo("convertSelectStatement", n) + } + qbc, ok := qb.(*parser.Query_blockContext) + if !ok { + return todo("convertSelectStatement", n) + } + return c.convertQueryBlock(qbc) +} + +func (c *cc) convertQueryBlock(n *parser.Query_blockContext) ast.Node { + stmt := &ast.SelectStmt{ + TargetList: &ast.List{}, + FromClause: &ast.List{}, + DistinctClause: &ast.List{}, + } + + if sl := n.Selected_list(); sl != nil { + if slc, ok := sl.(*parser.Selected_listContext); ok { + stmt.TargetList = c.convertSelectedList(slc) + } + } + + if fc := n.From_clause(); fc != nil { + if fcc, ok := fc.(*parser.From_clauseContext); ok { + stmt.FromClause = c.convertFromClause(fcc) + } + } + + if wc := n.Where_clause(); wc != nil { + if wcc, ok := wc.(*parser.Where_clauseContext); ok { + stmt.WhereClause = c.convertWhereClause(wcc) + } + } + + return stmt +} + +func (c *cc) convertSelectedList(n *parser.Selected_listContext) *ast.List { + list := &ast.List{} + // SELECT * + if n.ASTERISK() != nil { + list.Items = append(list.Items, &ast.ResTarget{ + Val: &ast.ColumnRef{ + Fields: &ast.List{Items: []ast.Node{&ast.A_Star{}}}, + }, + }) + return list + } + for _, iel := range n.AllSelect_list_elements() { + el, ok := iel.(*parser.Select_list_elementsContext) + if !ok { + continue + } + list.Items = append(list.Items, c.convertSelectListElement(el)) + } + return list +} + +func (c *cc) convertSelectListElement(n *parser.Select_list_elementsContext) ast.Node { + // tableview_name.* + if n.ASTERISK() != nil { + cols := &ast.List{} + if tv := n.Tableview_name(); tv != nil { + cols.Items = append(cols.Items, newString(identifier(tv.GetText()))) + } + cols.Items = append(cols.Items, &ast.A_Star{}) + return &ast.ResTarget{ + Val: &ast.ColumnRef{Fields: cols}, + } + } + + rt := &ast.ResTarget{} + if ex := n.Expression(); ex != nil { + if exc, ok := ex.(*parser.ExpressionContext); ok { + rt.Val = c.convertExpression(exc) + } + } + if ca := n.Column_alias(); ca != nil { + if cac, ok := ca.(*parser.Column_aliasContext); ok { + name := columnAlias(cac) + if name != "" { + rt.Name = &name + } + } + } + return rt +} + +func columnAlias(n *parser.Column_aliasContext) string { + if id := n.Identifier(); id != nil { + return identifier(id.GetText()) + } + if qs := n.Quoted_string(); qs != nil { + return strings.Trim(qs.GetText(), "'") + } + return "" +} + +func (c *cc) convertFromClause(n *parser.From_clauseContext) *ast.List { + list := &ast.List{} + trl := n.Table_ref_list() + if trl == nil { + return list + } + trlc, ok := trl.(*parser.Table_ref_listContext) + if !ok { + return list + } + for _, itr := range trlc.AllTable_ref() { + tr, ok := itr.(*parser.Table_refContext) + if !ok { + continue + } + if rv := c.convertTableRef(tr); rv != nil { + list.Items = append(list.Items, rv) + } + } + return list +} + +// convertTableRef handles the simple `table [alias]` case; joins and subqueries +// fall back to a best-effort table name extraction. +func (c *cc) convertTableRef(n *parser.Table_refContext) ast.Node { + aux := n.Table_ref_aux() + if aux == nil { + return nil + } + name, alias := tableRefAuxName(aux) + if name == "" { + return nil + } + rv := &ast.RangeVar{ + Relname: &name, + } + if alias != "" { + rv.Alias = &ast.Alias{Aliasname: &alias} + } + return rv +} + +func tableRefAuxName(aux parser.ITable_ref_auxContext) (string, string) { + auxc, ok := aux.(*parser.Table_ref_auxContext) + if !ok { + return "", "" + } + alias := "" + if ta := auxc.Table_alias(); ta != nil { + alias = identifier(ta.GetText()) + } + internal := auxc.Table_ref_aux_internal() + if internal == nil { + return "", alias + } + // The one/two/three alternatives all expose a Dml_table_expression_clause + // through the labeled context; use text-based extraction as a fallback since + // the labeled subtypes differ. + name := extractTableViewName(internal) + return name, alias +} + +func extractTableViewName(n antlr.ParseTree) string { + // Depth-first search for a Tableview_nameContext. + switch v := n.(type) { + case *parser.Tableview_nameContext: + return identifier(v.GetText()) + } + for i := 0; i < n.GetChildCount(); i++ { + if child, ok := n.GetChild(i).(antlr.ParseTree); ok { + if name := extractTableViewName(child); name != "" { + return name + } + } + } + return "" +} + +func (c *cc) convertWhereClause(n *parser.Where_clauseContext) ast.Node { + cond := n.Condition() + if cond == nil { + return nil + } + condc, ok := cond.(*parser.ConditionContext) + if !ok { + return nil + } + if ex := condc.Expression(); ex != nil { + if exc, ok := ex.(*parser.ExpressionContext); ok { + return c.convertExpression(exc) + } + } + return nil +} + +// --------------------------------------------------------------------------- +// INSERT +// --------------------------------------------------------------------------- + +func (c *cc) convertInsertStatement(n *parser.Insert_statementContext) ast.Node { + single := n.Single_table_insert() + if single == nil { + return todo("convertInsertStatement", n) + } + sc, ok := single.(*parser.Single_table_insertContext) + if !ok { + return todo("convertInsertStatement", n) + } + + stmt := &ast.InsertStmt{ + Cols: &ast.List{}, + ReturningList: &ast.List{}, + } + + if into := sc.Insert_into_clause(); into != nil { + if intoc, ok := into.(*parser.Insert_into_clauseContext); ok { + stmt.Relation = c.insertRelation(intoc) + stmt.Cols = c.insertColumns(intoc) + } + } + + if vals := sc.Values_clause(); vals != nil { + if valsc, ok := vals.(*parser.Values_clauseContext); ok { + stmt.SelectStmt = c.convertValuesClause(valsc) + } + } else if sel := sc.Select_statement(); sel != nil { + if selc, ok := sel.(*parser.Select_statementContext); ok { + stmt.SelectStmt = c.convertSelectStatement(selc) + } + } + + return stmt +} + +func (c *cc) insertRelation(n *parser.Insert_into_clauseContext) *ast.RangeVar { + gtr := n.General_table_ref() + if gtr == nil { + return nil + } + name := extractTableViewName(gtr) + if name == "" { + return nil + } + return &ast.RangeVar{Relname: &name} +} + +func (c *cc) insertColumns(n *parser.Insert_into_clauseContext) *ast.List { + list := &ast.List{} + pcl := n.Paren_column_list() + if pcl == nil { + return list + } + pclc, ok := pcl.(*parser.Paren_column_listContext) + if !ok { + return list + } + cl := pclc.Column_list() + if cl == nil { + return list + } + clc, ok := cl.(*parser.Column_listContext) + if !ok { + return list + } + for _, icn := range clc.AllColumn_name() { + name := identifier(icn.GetText()) + list.Items = append(list.Items, &ast.ResTarget{Name: &name}) + } + return list +} + +func (c *cc) convertValuesClause(n *parser.Values_clauseContext) ast.Node { + sel := &ast.SelectStmt{ + // TargetList/FromClause are initialized (empty) because downstream + // analysis (compiler.paramSearch) dereferences SelectStmt.TargetList.Items + // unconditionally for INSERT ... VALUES. + TargetList: &ast.List{}, + FromClause: &ast.List{}, + ValuesLists: &ast.List{}, + } + exprs := n.Expressions_() + if exprs == nil { + return sel + } + exc, ok := exprs.(*parser.Expressions_Context) + if !ok { + return sel + } + row := &ast.List{} + for _, iex := range exc.AllExpression() { + if e, ok := iex.(*parser.ExpressionContext); ok { + row.Items = append(row.Items, c.convertExpression(e)) + } + } + sel.ValuesLists.Items = append(sel.ValuesLists.Items, row) + return sel +} + +// --------------------------------------------------------------------------- +// UPDATE +// --------------------------------------------------------------------------- + +func (c *cc) convertUpdateStatement(n *parser.Update_statementContext) ast.Node { + stmt := &ast.UpdateStmt{ + Relations: &ast.List{}, + TargetList: &ast.List{}, + ReturningList: &ast.List{}, + FromClause: &ast.List{}, + } + + if gtr := n.General_table_ref(); gtr != nil { + name := extractTableViewName(gtr) + if name != "" { + stmt.Relations.Items = append(stmt.Relations.Items, &ast.RangeVar{Relname: &name}) + } + } + + if usc := n.Update_set_clause(); usc != nil { + if uscc, ok := usc.(*parser.Update_set_clauseContext); ok { + stmt.TargetList = c.convertUpdateSet(uscc) + } + } + + if wc := n.Where_clause(); wc != nil { + if wcc, ok := wc.(*parser.Where_clauseContext); ok { + stmt.WhereClause = c.convertWhereClause(wcc) + } + } + + return stmt +} + +func (c *cc) convertUpdateSet(n *parser.Update_set_clauseContext) *ast.List { + list := &ast.List{} + for _, icb := range n.AllColumn_based_update_set_clause() { + cb, ok := icb.(*parser.Column_based_update_set_clauseContext) + if !ok { + continue + } + cn := cb.Column_name() + if cn == nil { + continue + } + name := identifier(cn.GetText()) + rt := &ast.ResTarget{Name: &name} + if ex := cb.Expression(); ex != nil { + if exc, ok := ex.(*parser.ExpressionContext); ok { + rt.Val = c.convertExpression(exc) + } + } + list.Items = append(list.Items, rt) + } + return list +} + +// --------------------------------------------------------------------------- +// DELETE +// --------------------------------------------------------------------------- + +func (c *cc) convertDeleteStatement(n *parser.Delete_statementContext) ast.Node { + stmt := &ast.DeleteStmt{ + Relations: &ast.List{}, + ReturningList: &ast.List{}, + } + if gtr := n.General_table_ref(); gtr != nil { + name := extractTableViewName(gtr) + if name != "" { + stmt.Relations.Items = append(stmt.Relations.Items, &ast.RangeVar{Relname: &name}) + } + } + if wc := n.Where_clause(); wc != nil { + if wcc, ok := wc.(*parser.Where_clauseContext); ok { + stmt.WhereClause = c.convertWhereClause(wcc) + } + } + return stmt +} + +// --------------------------------------------------------------------------- +// Expressions +// --------------------------------------------------------------------------- + +func (c *cc) convertExpression(n *parser.ExpressionContext) ast.Node { + if le := n.Logical_expression(); le != nil { + if lec, ok := le.(*parser.Logical_expressionContext); ok { + return c.convertLogicalExpression(lec) + } + } + return todo("convertExpression", n) +} + +func (c *cc) convertLogicalExpression(n *parser.Logical_expressionContext) ast.Node { + // AND / OR + subs := n.AllLogical_expression() + if len(subs) == 2 { + var kind ast.BoolExprType + if n.AND() != nil { + kind = ast.BoolExprTypeAnd + } else { + kind = ast.BoolExprTypeOr + } + left := c.convertLogicalExpression(subs[0].(*parser.Logical_expressionContext)) + right := c.convertLogicalExpression(subs[1].(*parser.Logical_expressionContext)) + return &ast.BoolExpr{ + Boolop: kind, + Args: &ast.List{Items: []ast.Node{left, right}}, + } + } + + if ule := n.Unary_logical_expression(); ule != nil { + if ulec, ok := ule.(*parser.Unary_logical_expressionContext); ok { + return c.convertUnaryLogicalExpression(ulec) + } + } + return todo("convertLogicalExpression", n) +} + +func (c *cc) convertUnaryLogicalExpression(n *parser.Unary_logical_expressionContext) ast.Node { + me := n.Multiset_expression() + if me == nil { + return todo("convertUnaryLogicalExpression", n) + } + mec, ok := me.(*parser.Multiset_expressionContext) + if !ok { + return todo("convertUnaryLogicalExpression", n) + } + re := mec.Relational_expression() + if re == nil { + return todo("convertUnaryLogicalExpression", n) + } + rec, ok := re.(*parser.Relational_expressionContext) + if !ok { + return todo("convertUnaryLogicalExpression", n) + } + return c.convertRelationalExpression(rec) +} + +func (c *cc) convertRelationalExpression(n *parser.Relational_expressionContext) ast.Node { + // Binary comparison: relational_expression relational_operator relational_expression + subs := n.AllRelational_expression() + if len(subs) == 2 { + op := "=" + if ro := n.Relational_operator(); ro != nil { + op = relationalOperator(ro.(*parser.Relational_operatorContext)) + } + left := c.convertRelationalExpression(subs[0].(*parser.Relational_expressionContext)) + right := c.convertRelationalExpression(subs[1].(*parser.Relational_expressionContext)) + return &ast.A_Expr{ + Kind: ast.A_Expr_Kind_OP, + Name: &ast.List{Items: []ast.Node{newString(op)}}, + Lexpr: left, + Rexpr: right, + } + } + + if ce := n.Compound_expression(); ce != nil { + if cec, ok := ce.(*parser.Compound_expressionContext); ok { + return c.convertCompoundExpression(cec) + } + } + return todo("convertRelationalExpression", n) +} + +func relationalOperator(n *parser.Relational_operatorContext) string { + switch { + case n.EQUALS_OP() != nil: + return "=" + case n.NOT_EQUAL_OP() != nil: + return "<>" + case n.LESS_THAN_OP() != nil: + return "<" + case n.GREATER_THAN_OP() != nil: + return ">" + default: + return strings.TrimSpace(n.GetText()) + } +} + +func (c *cc) convertCompoundExpression(n *parser.Compound_expressionContext) ast.Node { + // Only handle the plain concatenation path for now. + concs := n.AllConcatenation() + if len(concs) >= 1 { + if cc0, ok := concs[0].(*parser.ConcatenationContext); ok { + return c.convertConcatenation(cc0) + } + } + return todo("convertCompoundExpression", n) +} + +func (c *cc) convertConcatenation(n *parser.ConcatenationContext) ast.Node { + if me := n.Model_expression(); me != nil { + if mec, ok := me.(*parser.Model_expressionContext); ok { + return c.convertModelExpression(mec) + } + } + return todo("convertConcatenation", n) +} + +func (c *cc) convertModelExpression(n *parser.Model_expressionContext) ast.Node { + if ue := n.Unary_expression(); ue != nil { + if uec, ok := ue.(*parser.Unary_expressionContext); ok { + return c.convertUnaryExpression(uec) + } + } + return todo("convertModelExpression", n) +} + +func (c *cc) convertUnaryExpression(n *parser.Unary_expressionContext) ast.Node { + if core := n.Unary_expression_core(); core != nil { + if corec, ok := core.(*parser.Unary_expression_coreContext); ok { + return c.convertUnaryExpressionCore(corec) + } + } + return todo("convertUnaryExpression", n) +} + +func (c *cc) convertUnaryExpressionCore(n *parser.Unary_expression_coreContext) ast.Node { + if a := n.Atom(); a != nil { + if ac, ok := a.(*parser.AtomContext); ok { + return c.convertAtom(ac) + } + } + return todo("convertUnaryExpressionCore", n) +} + +func (c *cc) convertAtom(n *parser.AtomContext) ast.Node { + if bv := n.Bind_variable(); bv != nil { + if bvc, ok := bv.(*parser.Bind_variableContext); ok { + return c.convertBindVariable(bvc) + } + } + if cst := n.Constant(); cst != nil { + if cstc, ok := cst.(*parser.ConstantContext); ok { + return c.convertConstant(cstc) + } + } + if ge := n.General_element(); ge != nil { + if gec, ok := ge.(*parser.General_elementContext); ok { + return c.convertGeneralElement(gec) + } + } + return todo("convertAtom", n) +} + +// convertBindVariable maps Oracle bind variables to sqlc ParamRefs. +// +// :1, :2 ... -> positional, ParamRef.Number = N +// :name -> named; represented like SQLite's @name via A_Expr so the +// downstream named-parameter machinery can pick it up. +func (c *cc) convertBindVariable(n *parser.Bind_variableContext) ast.Node { + loc := n.GetStart().GetStart() + + // Numbered bind spelled as ':' UNSIGNED_INTEGER (two tokens). + if ui := n.UNSIGNED_INTEGER(0); ui != nil { + number, _ := strconv.Atoi(ui.GetText()) + if number == 0 { + c.paramCount++ + number = c.paramCount + } + return &ast.ParamRef{ + Number: number, + Location: loc, + Dollar: true, + } + } + + // BINDVAR is a single token, either ":name" or ":1". The Oracle lexer emits + // ":1" as one BINDVAR token, so distinguish numbered from named here. + if bindvar := n.BINDVAR(0); bindvar != nil { + text := bindvar.GetText() + name := strings.TrimPrefix(text, ":") + if number, err := strconv.Atoi(name); err == nil { + return &ast.ParamRef{ + Number: number, + Location: loc, + Dollar: true, + } + } + return &ast.A_Expr{ + Name: &ast.List{Items: []ast.Node{newString("@")}}, + Rexpr: newString(name), + Location: loc, + } + } + + c.paramCount++ + return &ast.ParamRef{Number: c.paramCount, Location: loc, Dollar: true} +} + +func (c *cc) convertConstant(n *parser.ConstantContext) ast.Node { + loc := n.GetStart().GetStart() + + if num := n.Numeric(); num != nil { + text := num.GetText() + if iv, err := strconv.ParseInt(text, 10, 64); err == nil { + return &ast.A_Const{Val: &ast.Integer{Ival: iv}, Location: loc} + } + return &ast.A_Const{Val: &ast.Float{Str: text}, Location: loc} + } + if qs := n.Quoted_string(0); qs != nil { + return &ast.A_Const{Val: newString(strings.Trim(qs.GetText(), "'")), Location: loc} + } + if n.NULL_() != nil { + return &ast.A_Const{Val: &ast.Null{}, Location: loc} + } + return &ast.A_Const{Val: newString(n.GetText()), Location: loc} +} + +// convertGeneralElement maps `a`, `a.b`, `t.col` into a ColumnRef. +func (c *cc) convertGeneralElement(n *parser.General_elementContext) ast.Node { + fields := &ast.List{} + collectGeneralElementParts(n, fields) + if len(fields.Items) == 0 { + return todo("convertGeneralElement", n) + } + return &ast.ColumnRef{ + Fields: fields, + Location: n.GetStart().GetStart(), + } +} + +func collectGeneralElementParts(n *parser.General_elementContext, out *ast.List) { + if inner := n.General_element(); inner != nil { + if innerc, ok := inner.(*parser.General_elementContext); ok { + collectGeneralElementParts(innerc, out) + } + } + for _, ipart := range n.AllGeneral_element_part() { + pc, ok := ipart.(*parser.General_element_partContext) + if !ok { + continue + } + if id := pc.Id_expression(); id != nil { + out.Items = append(out.Items, newString(identifier(id.GetText()))) + } + } +} diff --git a/internal/engine/oracle/convert_test.go b/internal/engine/oracle/convert_test.go new file mode 100644 index 0000000000..fa883603ea --- /dev/null +++ b/internal/engine/oracle/convert_test.go @@ -0,0 +1,207 @@ +package oracle + +import ( + "strings" + "testing" + + "github.com/sqlc-dev/sqlc/internal/sql/ast" +) + +// parseOne parses a single Oracle statement and returns its inner AST node. +func parseOne(t *testing.T, sql string) ast.Node { + t.Helper() + p := NewParser() + stmts, err := p.Parse(strings.NewReader(sql)) + if err != nil { + t.Fatalf("Parse(%q) returned error: %v", sql, err) + } + if len(stmts) != 1 { + t.Fatalf("Parse(%q) returned %d statements, want 1", sql, len(stmts)) + } + raw := stmts[0].Raw + if raw == nil { + t.Fatalf("Parse(%q) returned a statement with nil Raw", sql) + } + return raw.Stmt +} + +func TestConvertCreateTable(t *testing.T) { + stmt := parseOne(t, `CREATE TABLE employees (id NUMBER NOT NULL, name VARCHAR2(100), bio CLOB)`) + + ct, ok := stmt.(*ast.CreateTableStmt) + if !ok { + t.Fatalf("expected *ast.CreateTableStmt, got %T", stmt) + } + if ct.Name == nil || ct.Name.Name != "employees" { + t.Fatalf("expected table name 'employees', got %+v", ct.Name) + } + if len(ct.Cols) != 3 { + t.Fatalf("expected 3 columns, got %d", len(ct.Cols)) + } + + if ct.Cols[0].Colname != "id" { + t.Errorf("col0 name = %q, want id", ct.Cols[0].Colname) + } + if !ct.Cols[0].IsNotNull { + t.Errorf("col0 (id) should be NOT NULL") + } + if ct.Cols[0].TypeName == nil || ct.Cols[0].TypeName.Name != "number" { + t.Errorf("col0 type = %+v, want number", ct.Cols[0].TypeName) + } + if ct.Cols[1].Colname != "name" { + t.Errorf("col1 name = %q, want name", ct.Cols[1].Colname) + } + if ct.Cols[1].TypeName == nil || ct.Cols[1].TypeName.Name != "varchar2" { + t.Errorf("col1 type = %+v, want varchar2", ct.Cols[1].TypeName) + } + if ct.Cols[2].TypeName == nil || ct.Cols[2].TypeName.Name != "clob" { + t.Errorf("col2 type = %+v, want clob", ct.Cols[2].TypeName) + } +} + +func TestConvertSelect(t *testing.T) { + stmt := parseOne(t, `SELECT id, name FROM employees WHERE id = :1`) + + sel, ok := stmt.(*ast.SelectStmt) + if !ok { + t.Fatalf("expected *ast.SelectStmt, got %T", stmt) + } + if sel.TargetList == nil || len(sel.TargetList.Items) != 2 { + t.Fatalf("expected 2 target columns, got %+v", sel.TargetList) + } + if sel.FromClause == nil || len(sel.FromClause.Items) != 1 { + t.Fatalf("expected 1 FROM item, got %+v", sel.FromClause) + } + rv, ok := sel.FromClause.Items[0].(*ast.RangeVar) + if !ok || rv.Relname == nil || *rv.Relname != "employees" { + t.Fatalf("expected FROM employees RangeVar, got %+v", sel.FromClause.Items[0]) + } + + where, ok := sel.WhereClause.(*ast.A_Expr) + if !ok { + t.Fatalf("expected WHERE to be *ast.A_Expr, got %T", sel.WhereClause) + } + if _, ok := where.Rexpr.(*ast.ParamRef); !ok { + t.Errorf("expected WHERE right side to be *ast.ParamRef, got %T", where.Rexpr) + } +} + +func TestConvertSelectStar(t *testing.T) { + stmt := parseOne(t, `SELECT * FROM employees`) + sel, ok := stmt.(*ast.SelectStmt) + if !ok { + t.Fatalf("expected *ast.SelectStmt, got %T", stmt) + } + if sel.TargetList == nil || len(sel.TargetList.Items) != 1 { + t.Fatalf("expected 1 target (star), got %+v", sel.TargetList) + } + rt, ok := sel.TargetList.Items[0].(*ast.ResTarget) + if !ok { + t.Fatalf("expected *ast.ResTarget, got %T", sel.TargetList.Items[0]) + } + cr, ok := rt.Val.(*ast.ColumnRef) + if !ok || cr.Fields == nil || len(cr.Fields.Items) != 1 { + t.Fatalf("expected star ColumnRef, got %+v", rt.Val) + } + if _, ok := cr.Fields.Items[0].(*ast.A_Star); !ok { + t.Errorf("expected A_Star, got %T", cr.Fields.Items[0]) + } +} + +func TestConvertInsert(t *testing.T) { + stmt := parseOne(t, `INSERT INTO employees (id, name) VALUES (:1, :2)`) + + ins, ok := stmt.(*ast.InsertStmt) + if !ok { + t.Fatalf("expected *ast.InsertStmt, got %T", stmt) + } + if ins.Relation == nil || ins.Relation.Relname == nil || *ins.Relation.Relname != "employees" { + t.Fatalf("expected INSERT INTO employees, got %+v", ins.Relation) + } + if ins.Cols == nil || len(ins.Cols.Items) != 2 { + t.Fatalf("expected 2 insert columns, got %+v", ins.Cols) + } + sel, ok := ins.SelectStmt.(*ast.SelectStmt) + if !ok || sel.ValuesLists == nil || len(sel.ValuesLists.Items) != 1 { + t.Fatalf("expected a VALUES SelectStmt, got %+v", ins.SelectStmt) + } +} + +func TestConvertUpdate(t *testing.T) { + stmt := parseOne(t, `UPDATE employees SET name = :1 WHERE id = :2`) + + upd, ok := stmt.(*ast.UpdateStmt) + if !ok { + t.Fatalf("expected *ast.UpdateStmt, got %T", stmt) + } + if upd.Relations == nil || len(upd.Relations.Items) != 1 { + t.Fatalf("expected 1 relation, got %+v", upd.Relations) + } + if upd.TargetList == nil || len(upd.TargetList.Items) != 1 { + t.Fatalf("expected 1 SET target, got %+v", upd.TargetList) + } + rt, ok := upd.TargetList.Items[0].(*ast.ResTarget) + if !ok || rt.Name == nil || *rt.Name != "name" { + t.Fatalf("expected SET name = ..., got %+v", upd.TargetList.Items[0]) + } + if upd.WhereClause == nil { + t.Errorf("expected a WHERE clause") + } +} + +func TestConvertDelete(t *testing.T) { + stmt := parseOne(t, `DELETE FROM employees WHERE id = :1`) + + del, ok := stmt.(*ast.DeleteStmt) + if !ok { + t.Fatalf("expected *ast.DeleteStmt, got %T", stmt) + } + if del.Relations == nil || len(del.Relations.Items) != 1 { + t.Fatalf("expected 1 relation, got %+v", del.Relations) + } + rv, ok := del.Relations.Items[0].(*ast.RangeVar) + if !ok || rv.Relname == nil || *rv.Relname != "employees" { + t.Fatalf("expected DELETE FROM employees, got %+v", del.Relations.Items[0]) + } + if del.WhereClause == nil { + t.Errorf("expected a WHERE clause") + } +} + +func TestConvertNamedBindVariable(t *testing.T) { + stmt := parseOne(t, `SELECT id FROM employees WHERE name = :emp_name`) + sel := stmt.(*ast.SelectStmt) + where, ok := sel.WhereClause.(*ast.A_Expr) + if !ok { + t.Fatalf("expected WHERE *ast.A_Expr, got %T", sel.WhereClause) + } + // Named bind is represented like SQLite's @name: an A_Expr whose right side + // is the bind name and whose Name is "@". + inner, ok := where.Rexpr.(*ast.A_Expr) + if !ok { + t.Fatalf("expected named-param A_Expr on right side, got %T", where.Rexpr) + } + rname, ok := inner.Rexpr.(*ast.String) + if !ok || rname.Str != "emp_name" { + t.Errorf("expected named param 'emp_name', got %+v", inner.Rexpr) + } +} + +func TestParseMultipleStatements(t *testing.T) { + sql := `CREATE TABLE t (id NUMBER); +SELECT id FROM t;` + p := NewParser() + stmts, err := p.Parse(strings.NewReader(sql)) + if err != nil { + t.Fatalf("Parse returned error: %v", err) + } + if len(stmts) != 2 { + t.Fatalf("expected 2 statements, got %d", len(stmts)) + } + if _, ok := stmts[0].Raw.Stmt.(*ast.CreateTableStmt); !ok { + t.Errorf("stmt0 = %T, want *ast.CreateTableStmt", stmts[0].Raw.Stmt) + } + if _, ok := stmts[1].Raw.Stmt.(*ast.SelectStmt); !ok { + t.Errorf("stmt1 = %T, want *ast.SelectStmt", stmts[1].Raw.Stmt) + } +} diff --git a/internal/engine/oracle/parse.go b/internal/engine/oracle/parse.go new file mode 100644 index 0000000000..ac74e0a5f0 --- /dev/null +++ b/internal/engine/oracle/parse.go @@ -0,0 +1,97 @@ +package oracle + +import ( + "errors" + "fmt" + "io" + + "github.com/antlr4-go/antlr/v4" + + "github.com/sqlc-dev/sqlc/internal/engine/oracle/parser" + "github.com/sqlc-dev/sqlc/internal/source" + "github.com/sqlc-dev/sqlc/internal/sql/ast" +) + +type errorListener struct { + *antlr.DefaultErrorListener + + err string +} + +func (el *errorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol any, line, column int, msg string, e antlr.RecognitionException) { + if el.err == "" { + el.err = fmt.Sprintf("line %d:%d: %s", line, column, msg) + } +} + +// NewParser returns a parser for Oracle SQL / PL-SQL. +func NewParser() *Parser { + return &Parser{} +} + +type Parser struct { +} + +// Parse reads Oracle SQL from r and returns the sqlc shared-AST statements it +// was able to convert. Statements the converter does not yet understand are +// represented as *ast.TODO and skipped, matching the SQLite engine's behaviour +// so the engine can ship incrementally. +func (p *Parser) Parse(r io.Reader) ([]ast.Statement, error) { + blob, err := io.ReadAll(r) + if err != nil { + return nil, err + } + + input := antlr.NewInputStream(string(blob)) + lexer := parser.NewPlSqlLexer(input) + stream := antlr.NewCommonTokenStream(lexer, 0) + pp := parser.NewPlSqlParser(stream) + el := &errorListener{} + pp.RemoveErrorListeners() + pp.AddErrorListener(el) + + tree := pp.Sql_script() + if el.err != "" { + return nil, errors.New(el.err) + } + + script, ok := tree.(*parser.Sql_scriptContext) + if !ok { + return nil, fmt.Errorf("expected *parser.Sql_scriptContext; got %T", tree) + } + + var stmts []ast.Statement + loc := 0 + for _, iunit := range script.AllUnit_statement() { + unit, ok := iunit.(*parser.Unit_statementContext) + if !ok { + continue + } + converter := &cc{} + out := converter.convert(unit) + if _, ok := out.(*ast.TODO); ok { + loc = unit.GetStop().GetStop() + 2 + continue + } + length := (unit.GetStop().GetStop() + 1) - loc + stmts = append(stmts, ast.Statement{ + Raw: &ast.RawStmt{ + Stmt: out, + StmtLocation: loc, + StmtLen: length, + }, + }) + loc = unit.GetStop().GetStop() + 2 + } + return stmts, nil +} + +// CommentSyntax reports the comment styles Oracle SQL supports: -- line comments +// and /* */ block comments. Oracle does not use # comments. +func (p *Parser) CommentSyntax() source.CommentSyntax { + return source.CommentSyntax{ + Dash: true, + Hash: false, + SlashStar: true, + } +} diff --git a/internal/engine/oracle/parser/.gitignore b/internal/engine/oracle/parser/.gitignore new file mode 100644 index 0000000000..c569cd0e36 --- /dev/null +++ b/internal/engine/oracle/parser/.gitignore @@ -0,0 +1,2 @@ + +antlr-4.13.1-complete.jar diff --git a/internal/engine/oracle/parser/Makefile b/internal/engine/oracle/parser/Makefile new file mode 100644 index 0000000000..f8a4db5f10 --- /dev/null +++ b/internal/engine/oracle/parser/Makefile @@ -0,0 +1,28 @@ +# Oracle PL/SQL parser generation. +# +# The grammar (PlSqlLexer.g4, PlSqlParser.g4) is vendored from antlr/grammars-v4 +# (sql/plsql) and has already been transformed for the Go target (embedded `this.` +# actions rewritten to `p.`/`l.` via transformGrammar.py). The hand-written base +# classes plsql_lexer_base.go and plsql_parser_base.go supply the grammar +# `superClass` implementations and are committed. +# +# The generated *.go files are committed, so `go build` needs no Java. Run `make` +# here only to regenerate after updating the grammar. + +plsql_parser.go: PlSqlLexer.g4 PlSqlParser.g4 antlr-4.13.1-complete.jar + java -jar antlr-4.13.1-complete.jar -Dlanguage=Go -package parser PlSqlLexer.g4 PlSqlParser.g4 + +antlr-4.13.1-complete.jar: + curl -fsSL -o antlr-4.13.1-complete.jar https://repo1.maven.org/maven2/org/antlr/antlr4/4.13.1/antlr4-4.13.1-complete.jar + +# Refresh the grammar from antlr/grammars-v4, then re-apply the Go-target transform. +# NOTE: the Go base classes live under sql/plsql/Go in the upstream repo. +.PHONY: fetch-grammar +fetch-grammar: + curl -O https://raw.githubusercontent.com/antlr/grammars-v4/master/sql/plsql/PlSqlLexer.g4 + curl -O https://raw.githubusercontent.com/antlr/grammars-v4/master/sql/plsql/PlSqlParser.g4 + python3 transformGrammar.py || true + +.PHONY: clean +clean: + rm -f *.interp *.tokens *.bak plsql_lexer.go plsql_parser.go plsqlparser_base_listener.go plsqlparser_listener.go diff --git a/internal/engine/oracle/parser/PlSqlLexer.g4 b/internal/engine/oracle/parser/PlSqlLexer.g4 new file mode 100644 index 0000000000..22461725aa --- /dev/null +++ b/internal/engine/oracle/parser/PlSqlLexer.g4 @@ -0,0 +1,2616 @@ +/** + * Oracle(c) PL/SQL 11g Parser + * + * Copyright (c) 2009-2011 Alexandre Porcelli + * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies). + * Copyright (c) 2017 Mark Adams + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// $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'; +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'; +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 - subtoken typecast in , it also incorporates +// Lowercase 'n' is a usual addition to the standard + +NATIONAL_CHAR_STRING_LIT: 'N' '\'' (~('\'' | '\r' | '\n') | '\'' '\'' | NEWLINE)* '\''; + +// Rule #040 - subtoken typecast in +// Lowercase 'b' is a usual addition to the standard + +BIT_STRING_LIT: 'B' ('\'' [01]* '\'')+; + +// Rule #284 - subtoken typecast in +// Lowercase 'x' is a usual addition to the standard +// The '0X' is used in external_table_clause sub-rules + +HEX_STRING_LIT : ('X' | '0X') ('\'' [A-F0-9]* '\'')+; +DOUBLE_PERIOD : '..'; +PERIOD : '.'; + +//{ Rule #238 +// This rule is a bit tricky - it resolves the ambiguity with +// It also incorporates and for the +// Rule #501 was incorporated directly in the token +// See also the rule #617 +/* + : ( + UNSIGNED_INTEGER + ( '.' UNSIGNED_INTEGER + | {$type = UNSIGNED_INTEGER;} + ) ( E ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )? + | '.' UNSIGNED_INTEGER ( E ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )? + ) + (D | F)? + ;*/ + +UNSIGNED_INTEGER : [0-9]+; +APPROXIMATE_NUM_LIT : FLOAT_FRAGMENT ('E' ('+' | '-')? (FLOAT_FRAGMENT | [0-9]+))? ('D' | 'F')?; + +// Rule #--- is a base for Rule #065 , it incorporates +// and a superfluous subtoken typecasting of the "QUOTE" +CHAR_STRING: '\'' (~('\'' | '\r' | '\n') | '\'' '\'' | NEWLINE)* '\''; + +// See https://livesql.oracle.com/apex/livesql/file/content_CIREYU9EA54EOKQ7LAMZKRF6P.html +// TODO: context sensitive string quotes (any characted after quote) +CHAR_STRING_PERL: + 'Q' '\'' ( + QS_ANGLE + | QS_BRACE + | QS_BRACK + | QS_PAREN + | QS_EXCLAM + | QS_SHARP + | QS_QUOTE + | QS_DQUOTE + | QS_TILDA + | QS_SOLIDUS + | QS_RSOLIDUS + ) '\'' -> type(CHAR_STRING) +; +fragment QS_ANGLE : '<' .*? '>'; +fragment QS_BRACE : '{' .*? '}'; +fragment QS_BRACK : '[' .*? ']'; +fragment QS_PAREN : '(' .*? ')'; +fragment QS_EXCLAM : '!' .*? '!'; +fragment QS_SHARP : '#' .*? '#'; +fragment QS_QUOTE : '\'' .*? '\''; +fragment QS_DQUOTE : '"' .*? '"'; +fragment QS_TILDA : '~' .*? '~'; +fragment QS_SOLIDUS : '/' .*? '/'; +fragment QS_RSOLIDUS : '\\' .*? '\\'; + +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); +// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve034.htm#SQPUG054 +REMARK_COMMENT: + 'REM' {p.IsNewlineAtPos(-4)}? 'ARK'? (' ' ~('\r' | '\n')*)? NEWLINE_EOF -> channel(HIDDEN) +; + +// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve032.htm#SQPUG052 +PROMPT_MESSAGE: 'PRO' {p.IsNewlineAtPos(-4)}? 'MPT'? (' ' ~('\r' | '\n')*)? NEWLINE_EOF; + +REGULAR_ID: SIMPLE_LETTER (SIMPLE_LETTER | '$' | '_' | '#' | [0-9])*; + +INQUIRY_DIRECTIVE: '$$' (SIMPLE_LETTER | '_')+; + +SPACES: [ \t\r\n]+ -> 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/internal/engine/oracle/parser/PlSqlLexer.interp b/internal/engine/oracle/parser/PlSqlLexer.interp new file mode 100644 index 0000000000..39f0ccfb41 --- /dev/null +++ b/internal/engine/oracle/parser/PlSqlLexer.interp @@ -0,0 +1,7481 @@ +token literal names: +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' +'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' +'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 +'^' +'~' +'!' +'>' +'<' +':' +';' +'|' +'=' +'[' +']' +'_' +null +null +null +null +null +null +null + +token symbolic names: +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 +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 +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 + +rule names: +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 +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 +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 +QS_ANGLE +QS_BRACE +QS_BRACK +QS_PAREN +QS_EXCLAM +QS_SHARP +QS_QUOTE +QS_DQUOTE +QS_TILDA +QS_SOLIDUS +QS_RSOLIDUS +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 + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 2482, 32452, 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, 2, 2491, 7, 2491, 2, 2492, 7, 2492, 2, 2493, 7, 2493, 2, 2494, 7, 2494, 2, 2495, 7, 2495, 2, 2496, 7, 2496, 2, 2497, 7, 2497, 2, 2498, 7, 2498, 2, 2499, 7, 2499, 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, 541, 1, 541, 1, 541, 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, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 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, 554, 1, 554, 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, 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, 558, 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, 559, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 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, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 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, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 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, 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, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 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, 583, 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, 584, 1, 584, 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, 587, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, 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, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 600, 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, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 604, 1, 604, 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, 605, 1, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 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, 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, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 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, 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, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 631, 1, 631, 1, 631, 1, 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, 632, 1, 633, 1, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 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, 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, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 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, 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, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, 1, 649, 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, 651, 1, 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 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, 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, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 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, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 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, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 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, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 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, 677, 1, 677, 1, 677, 1, 677, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 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, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 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, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 690, 1, 690, 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 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, 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, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 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, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 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, 705, 1, 705, 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, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 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, 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, 714, 1, 714, 1, 715, 1, 715, 1, 715, 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, 717, 1, 717, 1, 717, 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, 718, 1, 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 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, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 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, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 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, 731, 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, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 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, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 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, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 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, 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, 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, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 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, 759, 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, 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, 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, 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, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 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, 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, 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, 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, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 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, 783, 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 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, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 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, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 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, 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, 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 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, 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, 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, 811, 1, 811, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 815, 1, 815, 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 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, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 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, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 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, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 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, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 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, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 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, 862, 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 867, 1, 867, 1, 867, 1, 867, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 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, 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, 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 882, 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, 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, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 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, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 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, 895, 1, 896, 1, 896, 1, 896, 1, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 900, 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 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, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 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, 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, 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, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 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, 926, 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, 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, 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, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 934, 1, 934, 1, 934, 1, 934, 1, 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, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 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, 939, 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, 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, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 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, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 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, 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, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 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, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 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, 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, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 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, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 1, 980, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 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, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 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, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 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, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 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, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1009, 1, 1009, 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 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, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 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, 1017, 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, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 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, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 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, 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, 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, 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, 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, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 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, 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, 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, 1040, 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, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 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, 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, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 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, 1047, 1, 1047, 1, 1047, 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, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 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, 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, 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, 1057, 1, 1057, 1, 1057, 1, 1057, 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, 1059, 1, 1059, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 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, 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, 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, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 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, 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, 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, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 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, 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, 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, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 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, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 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, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1088, 1, 1088, 1, 1088, 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, 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, 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, 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, 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, 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, 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, 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, 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, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 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, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 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, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 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, 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, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 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, 1120, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 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, 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, 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, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 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, 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, 1131, 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, 1131, 1, 1131, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 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, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 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, 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, 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, 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, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 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, 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, 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, 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, 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, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 1171, 1, 1171, 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, 1172, 1, 1172, 1, 1172, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 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, 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, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 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, 1179, 1, 1179, 1, 1179, 1, 1179, 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, 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, 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, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 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, 1185, 1, 1185, 1, 1185, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 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, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 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, 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, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 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, 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, 1198, 1, 1198, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 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, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 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, 1211, 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, 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, 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, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 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, 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, 1219, 1, 1219, 1, 1219, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 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, 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, 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, 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, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1228, 1, 1228, 1, 1228, 1, 1228, 1, 1228, 1, 1228, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 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, 1233, 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, 1236, 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, 1237, 1, 1237, 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, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1243, 1, 1243, 1, 1243, 1, 1243, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1245, 1, 1245, 1, 1245, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 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, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1251, 1, 1251, 1, 1251, 1, 1251, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1254, 1, 1254, 1, 1254, 1, 1254, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1258, 1, 1258, 1, 1258, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 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, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 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, 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, 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, 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, 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, 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, 1277, 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, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 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, 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, 1283, 1, 1283, 1, 1283, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 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, 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, 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, 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, 1289, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 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, 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, 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, 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, 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, 1296, 1, 1297, 1, 1297, 1, 1297, 1, 1297, 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, 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, 1301, 1, 1301, 1, 1301, 1, 1301, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1306, 1, 1306, 1, 1306, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 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, 1316, 1, 1316, 1, 1316, 1, 1316, 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, 1318, 1, 1318, 1, 1318, 1, 1318, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1321, 1, 1321, 1, 1321, 1, 1321, 1, 1321, 1, 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, 1323, 1, 1323, 1, 1323, 1, 1323, 1, 1323, 1, 1323, 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, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1327, 1, 1327, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 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, 1334, 1, 1334, 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, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 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, 1344, 1, 1344, 1, 1344, 1, 1344, 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, 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, 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, 1348, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 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, 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, 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, 1353, 1, 1353, 1, 1353, 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, 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, 1357, 1, 1357, 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, 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, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1360, 1, 1360, 1, 1360, 1, 1360, 1, 1360, 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, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 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, 1367, 1, 1367, 1, 1367, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 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, 5, 1374, 19917, 8, 1374, 10, 1374, 12, 1374, 19920, 9, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1375, 1, 1375, 5, 1375, 19930, 8, 1375, 10, 1375, 12, 1375, 19933, 9, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1376, 1, 1376, 5, 1376, 19944, 8, 1376, 10, 1376, 12, 1376, 19947, 9, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1379, 1, 1379, 5, 1379, 19982, 8, 1379, 10, 1379, 12, 1379, 19985, 9, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1380, 1, 1380, 5, 1380, 19998, 8, 1380, 10, 1380, 12, 1380, 20001, 9, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1381, 1, 1381, 5, 1381, 20013, 8, 1381, 10, 1381, 12, 1381, 20016, 9, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1382, 1, 1382, 5, 1382, 20025, 8, 1382, 10, 1382, 12, 1382, 20028, 9, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1383, 1, 1383, 5, 1383, 20048, 8, 1383, 10, 1383, 12, 1383, 20051, 9, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 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, 1387, 1, 1387, 1, 1387, 1, 1387, 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, 1389, 1, 1389, 1, 1389, 1, 1389, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 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, 1393, 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, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 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, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1399, 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, 1401, 1, 1401, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 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, 1404, 1, 1404, 1, 1404, 1, 1404, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1406, 1, 1406, 1, 1406, 1, 1406, 1, 1406, 1, 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, 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, 1409, 1, 1409, 1, 1409, 1, 1409, 1, 1409, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 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, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 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, 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, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 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, 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, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 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, 1426, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 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, 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, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 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, 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, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 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, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 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, 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, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 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, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 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, 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, 1459, 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, 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, 1465, 1, 1465, 1, 1466, 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, 1468, 1, 1468, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 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, 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, 1482, 1, 1482, 1, 1482, 1, 1482, 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, 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, 1487, 1, 1487, 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, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1492, 1, 1492, 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, 1493, 1, 1494, 1, 1494, 1, 1494, 1, 1494, 1, 1494, 1, 1494, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1497, 1, 1497, 1, 1497, 1, 1497, 1, 1498, 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, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 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, 1501, 1, 1501, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1506, 1, 1506, 1, 1506, 1, 1506, 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, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1510, 1, 1510, 1, 1510, 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, 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, 1513, 1, 1513, 1, 1513, 1, 1513, 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, 1514, 1, 1514, 1, 1514, 1, 1514, 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, 1517, 1, 1517, 1, 1517, 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, 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, 1520, 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, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 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, 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, 1528, 1, 1528, 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, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 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, 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, 1536, 1, 1536, 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, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 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, 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, 1544, 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, 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, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 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, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 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, 1561, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1563, 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, 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, 1567, 1, 1567, 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, 1568, 1, 1568, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 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, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 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, 1574, 1, 1575, 1, 1575, 1, 1575, 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, 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, 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, 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, 1583, 1, 1583, 1, 1583, 1, 1583, 1, 1583, 1, 1583, 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, 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, 1587, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 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, 1590, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1592, 1, 1592, 1, 1592, 1, 1592, 1, 1592, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1596, 1, 1596, 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, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 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, 1602, 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, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1608, 1, 1608, 1, 1608, 1, 1608, 1, 1608, 1, 1608, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 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, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1616, 1, 1616, 1, 1616, 1, 1616, 1, 1616, 1, 1617, 1, 1617, 1, 1617, 1, 1617, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1619, 1, 1619, 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, 1620, 1, 1620, 1, 1620, 1, 1620, 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, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 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, 1636, 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, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 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, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1653, 1, 1653, 1, 1653, 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, 1654, 1, 1654, 1, 1655, 1, 1655, 1, 1655, 1, 1655, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 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, 1659, 1, 1659, 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, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 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, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 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, 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, 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, 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1687, 1, 1687, 1, 1687, 1, 1687, 1, 1687, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 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, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 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, 1699, 1, 1699, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 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, 1702, 1, 1702, 1, 1702, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 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, 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, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 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, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 3, 1722, 23376, 8, 1722, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 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, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 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, 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, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 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, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 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, 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, 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, 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, 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, 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, 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, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 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, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 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, 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, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 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, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 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, 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, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 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, 1809, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 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, 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, 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, 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, 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, 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, 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, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 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, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 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, 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, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 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, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 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, 1843, 1, 1843, 1, 1843, 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, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 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, 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, 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, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 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, 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, 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, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 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, 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, 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, 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, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 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, 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, 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, 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, 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, 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, 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, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 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, 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, 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, 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, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 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, 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, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 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, 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, 1903, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 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, 1907, 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, 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, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 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, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 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, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 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, 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, 1930, 1, 1930, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 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, 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, 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, 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, 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, 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, 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, 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, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 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, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 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, 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, 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, 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, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 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, 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, 1960, 1, 1960, 1, 1960, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1985, 1, 1985, 1, 1985, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 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, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 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, 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, 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, 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, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 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, 2015, 1, 2015, 1, 2015, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2076, 1, 2076, 1, 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, 2077, 1, 2077, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 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, 2081, 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, 2084, 1, 2084, 1, 2084, 1, 2084, 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, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 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, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2094, 1, 2094, 1, 2094, 1, 2094, 1, 2094, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2098, 1, 2098, 1, 2098, 1, 2098, 1, 2098, 1, 2099, 1, 2099, 1, 2099, 1, 2099, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 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, 2109, 1, 2109, 1, 2109, 1, 2109, 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, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 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, 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, 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, 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, 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, 2123, 1, 2123, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 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, 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, 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, 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, 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, 2131, 1, 2131, 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, 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, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 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, 2137, 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, 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, 2141, 1, 2141, 1, 2141, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2146, 1, 2146, 1, 2146, 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, 2147, 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, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 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, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 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, 2156, 1, 2156, 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 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, 2163, 1, 2163, 1, 2163, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2165, 1, 2165, 1, 2165, 1, 2165, 1, 2165, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2167, 1, 2167, 1, 2167, 1, 2167, 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2169, 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, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 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, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2184, 1, 2184, 1, 2184, 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, 2187, 1, 2187, 1, 2187, 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, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 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, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 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, 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, 2193, 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, 2195, 1, 2195, 1, 2195, 1, 2195, 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, 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, 2197, 1, 2197, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 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, 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, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2209, 1, 2209, 1, 2209, 1, 2209, 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, 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, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 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, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 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, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 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, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2229, 1, 2229, 1, 2229, 1, 2229, 1, 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, 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, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2233, 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, 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, 2235, 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, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 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, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 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, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2250, 1, 2250, 1, 2250, 1, 2251, 1, 2251, 1, 2251, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 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, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2261, 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, 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, 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, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 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, 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, 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, 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, 2276, 1, 2276, 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, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2279, 1, 2279, 1, 2279, 1, 2279, 1, 2279, 1, 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, 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, 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, 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, 2286, 1, 2286, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2288, 1, 2288, 1, 2288, 1, 2288, 1, 2288, 1, 2288, 1, 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, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2292, 1, 2292, 1, 2292, 1, 2292, 1, 2292, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2301, 1, 2301, 1, 2301, 1, 2301, 1, 2301, 1, 2301, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 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, 2306, 1, 2306, 1, 2306, 1, 2306, 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, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 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, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 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, 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, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2320, 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, 2322, 1, 2322, 1, 2322, 1, 2322, 1, 2322, 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, 2323, 1, 2323, 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, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 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, 2327, 1, 2327, 1, 2327, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 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, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 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, 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, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 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, 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, 2341, 1, 2341, 1, 2341, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 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, 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, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 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, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 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, 2356, 1, 2356, 1, 2356, 1, 2356, 1, 2356, 1, 2356, 1, 2357, 1, 2357, 1, 2357, 1, 2357, 1, 2357, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 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, 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, 2361, 1, 2361, 1, 2361, 1, 2361, 1, 2362, 1, 2362, 1, 2362, 1, 2362, 1, 2362, 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 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, 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, 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, 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, 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, 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, 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, 2374, 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, 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, 2378, 1, 2378, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 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, 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, 2382, 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, 2382, 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, 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, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2390, 1, 2390, 1, 2390, 1, 2390, 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, 2391, 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, 2393, 1, 2393, 1, 2394, 1, 2394, 1, 2394, 1, 2394, 1, 2394, 1, 2394, 1, 2394, 1, 2394, 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, 2395, 1, 2395, 1, 2395, 1, 2396, 1, 2396, 1, 2396, 1, 2396, 1, 2396, 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, 2399, 1, 2399, 1, 2399, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2401, 1, 2401, 1, 2401, 1, 2401, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2404, 1, 2404, 1, 2404, 1, 2404, 1, 2404, 1, 2405, 1, 2405, 1, 2405, 1, 2405, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2408, 1, 2408, 1, 2408, 1, 2408, 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, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2412, 1, 2412, 1, 2412, 1, 2412, 1, 2412, 1, 2412, 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, 2414, 1, 2414, 1, 2414, 1, 2414, 1, 2414, 1, 2415, 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, 2417, 1, 2417, 1, 2417, 1, 2417, 1, 2417, 1, 2418, 1, 2418, 1, 2418, 1, 2418, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2420, 1, 2420, 1, 2420, 1, 2420, 1, 2420, 1, 2421, 1, 2421, 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, 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, 2424, 1, 2424, 1, 2425, 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, 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, 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, 2430, 1, 2430, 1, 2430, 1, 2430, 1, 2430, 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, 2431, 1, 2431, 1, 2431, 1, 2431, 1, 2431, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2433, 1, 2433, 1, 2433, 1, 2433, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2435, 1, 2435, 1, 2435, 1, 2435, 1, 2435, 1, 2435, 5, 2435, 32038, 8, 2435, 10, 2435, 12, 2435, 32041, 9, 2435, 1, 2435, 1, 2435, 1, 2436, 1, 2436, 1, 2436, 5, 2436, 32048, 8, 2436, 10, 2436, 12, 2436, 32051, 9, 2436, 1, 2436, 4, 2436, 32054, 8, 2436, 11, 2436, 12, 2436, 32055, 1, 2437, 1, 2437, 1, 2437, 3, 2437, 32061, 8, 2437, 1, 2437, 1, 2437, 5, 2437, 32065, 8, 2437, 10, 2437, 12, 2437, 32068, 9, 2437, 1, 2437, 4, 2437, 32071, 8, 2437, 11, 2437, 12, 2437, 32072, 1, 2438, 1, 2438, 1, 2438, 1, 2439, 1, 2439, 1, 2440, 4, 2440, 32081, 8, 2440, 11, 2440, 12, 2440, 32082, 1, 2441, 1, 2441, 1, 2441, 3, 2441, 32088, 8, 2441, 1, 2441, 1, 2441, 4, 2441, 32092, 8, 2441, 11, 2441, 12, 2441, 32093, 3, 2441, 32096, 8, 2441, 3, 2441, 32098, 8, 2441, 1, 2441, 3, 2441, 32101, 8, 2441, 1, 2442, 1, 2442, 1, 2442, 1, 2442, 1, 2442, 5, 2442, 32108, 8, 2442, 10, 2442, 12, 2442, 32111, 9, 2442, 1, 2442, 1, 2442, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 3, 2443, 32128, 8, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2444, 1, 2444, 5, 2444, 32136, 8, 2444, 10, 2444, 12, 2444, 32139, 9, 2444, 1, 2444, 1, 2444, 1, 2445, 1, 2445, 5, 2445, 32145, 8, 2445, 10, 2445, 12, 2445, 32148, 9, 2445, 1, 2445, 1, 2445, 1, 2446, 1, 2446, 5, 2446, 32154, 8, 2446, 10, 2446, 12, 2446, 32157, 9, 2446, 1, 2446, 1, 2446, 1, 2447, 1, 2447, 5, 2447, 32163, 8, 2447, 10, 2447, 12, 2447, 32166, 9, 2447, 1, 2447, 1, 2447, 1, 2448, 1, 2448, 5, 2448, 32172, 8, 2448, 10, 2448, 12, 2448, 32175, 9, 2448, 1, 2448, 1, 2448, 1, 2449, 1, 2449, 5, 2449, 32181, 8, 2449, 10, 2449, 12, 2449, 32184, 9, 2449, 1, 2449, 1, 2449, 1, 2450, 1, 2450, 5, 2450, 32190, 8, 2450, 10, 2450, 12, 2450, 32193, 9, 2450, 1, 2450, 1, 2450, 1, 2451, 1, 2451, 5, 2451, 32199, 8, 2451, 10, 2451, 12, 2451, 32202, 9, 2451, 1, 2451, 1, 2451, 1, 2452, 1, 2452, 5, 2452, 32208, 8, 2452, 10, 2452, 12, 2452, 32211, 9, 2452, 1, 2452, 1, 2452, 1, 2453, 1, 2453, 5, 2453, 32217, 8, 2453, 10, 2453, 12, 2453, 32220, 9, 2453, 1, 2453, 1, 2453, 1, 2454, 1, 2454, 5, 2454, 32226, 8, 2454, 10, 2454, 12, 2454, 32229, 9, 2454, 1, 2454, 1, 2454, 1, 2455, 1, 2455, 1, 2455, 1, 2455, 4, 2455, 32237, 8, 2455, 11, 2455, 12, 2455, 32238, 1, 2455, 1, 2455, 1, 2456, 1, 2456, 1, 2457, 1, 2457, 1, 2458, 1, 2458, 1, 2459, 1, 2459, 1, 2460, 1, 2460, 1, 2460, 1, 2461, 1, 2461, 1, 2462, 1, 2462, 1, 2463, 1, 2463, 1, 2464, 1, 2464, 1, 2465, 1, 2465, 1, 2466, 1, 2466, 1, 2467, 1, 2467, 1, 2468, 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, 2473, 1, 2473, 5, 2473, 32283, 8, 2473, 10, 2473, 12, 2473, 32286, 9, 2473, 1, 2473, 1, 2473, 1, 2473, 1, 2473, 1, 2473, 3, 2473, 32293, 8, 2473, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 3, 2474, 32303, 8, 2474, 1, 2475, 1, 2475, 1, 2476, 1, 2476, 1, 2477, 1, 2477, 1, 2478, 1, 2478, 1, 2479, 1, 2479, 1, 2480, 1, 2480, 1, 2481, 1, 2481, 1, 2482, 1, 2482, 1, 2483, 1, 2483, 1, 2484, 1, 2484, 1, 2485, 1, 2485, 1, 2486, 1, 2486, 1, 2487, 1, 2487, 1, 2487, 1, 2487, 5, 2487, 32333, 8, 2487, 10, 2487, 12, 2487, 32336, 9, 2487, 1, 2487, 1, 2487, 1, 2487, 1, 2487, 1, 2488, 1, 2488, 1, 2488, 1, 2488, 5, 2488, 32346, 8, 2488, 10, 2488, 12, 2488, 32349, 9, 2488, 1, 2488, 1, 2488, 1, 2488, 1, 2488, 1, 2488, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 3, 2489, 32364, 8, 2489, 1, 2489, 1, 2489, 5, 2489, 32368, 8, 2489, 10, 2489, 12, 2489, 32371, 9, 2489, 3, 2489, 32373, 8, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 3, 2490, 32387, 8, 2490, 1, 2490, 1, 2490, 5, 2490, 32391, 8, 2490, 10, 2490, 12, 2490, 32394, 9, 2490, 3, 2490, 32396, 8, 2490, 1, 2490, 1, 2490, 1, 2491, 1, 2491, 1, 2491, 5, 2491, 32403, 8, 2491, 10, 2491, 12, 2491, 32406, 9, 2491, 1, 2492, 1, 2492, 1, 2492, 1, 2492, 1, 2492, 4, 2492, 32413, 8, 2492, 11, 2492, 12, 2492, 32414, 1, 2493, 4, 2493, 32418, 8, 2493, 11, 2493, 12, 2493, 32419, 1, 2493, 1, 2493, 1, 2494, 1, 2494, 3, 2494, 32426, 8, 2494, 1, 2495, 1, 2495, 1, 2496, 1, 2496, 1, 2497, 5, 2497, 32433, 8, 2497, 10, 2497, 12, 2497, 32436, 9, 2497, 1, 2497, 3, 2497, 32439, 8, 2497, 1, 2497, 4, 2497, 32442, 8, 2497, 11, 2497, 12, 2497, 32443, 1, 2498, 3, 2498, 32447, 8, 2498, 1, 2498, 1, 2498, 1, 2499, 1, 2499, 12, 32137, 32146, 32155, 32164, 32173, 32182, 32191, 32200, 32209, 32218, 32227, 32347, 0, 2500, 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, 0, 4889, 0, 4891, 0, 4893, 0, 4895, 0, 4897, 0, 4899, 0, 4901, 0, 4903, 0, 4905, 0, 4907, 0, 4909, 0, 4911, 2444, 4913, 2445, 4915, 2446, 4917, 2447, 4919, 2448, 4921, 2449, 4923, 2450, 4925, 2451, 4927, 2452, 4929, 2453, 4931, 2454, 4933, 2455, 4935, 2456, 4937, 2457, 4939, 2458, 4941, 2459, 4943, 2460, 4945, 2461, 4947, 2462, 4949, 2463, 4951, 2464, 4953, 2465, 4955, 2466, 4957, 2467, 4959, 2468, 4961, 2469, 4963, 2470, 4965, 2471, 4967, 2472, 4969, 2473, 4971, 2474, 4973, 2475, 4975, 2476, 4977, 2477, 4979, 2478, 4981, 2479, 4983, 2480, 4985, 2481, 4987, 2482, 4989, 0, 4991, 0, 4993, 0, 4995, 0, 4997, 0, 4999, 0, 1, 0, 39, 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, 2, 0, 0, 0, 34, 34, 2, 0, 48, 57, 95, 95, 2, 0, 10, 10, 13, 13, 3, 0, 35, 36, 48, 57, 95, 95, 3, 0, 9, 10, 13, 13, 32, 32, 659, 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, 7304, 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, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 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, 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, 69248, 69289, 69296, 69297, 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, 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, 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, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 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, 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, 194560, 195101, 196608, 201546, 201552, 205743, 2, 0, 9, 9, 32, 32, 32513, 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, 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, 0, 4971, 1, 0, 0, 0, 0, 4973, 1, 0, 0, 0, 0, 4975, 1, 0, 0, 0, 0, 4977, 1, 0, 0, 0, 0, 4979, 1, 0, 0, 0, 0, 4981, 1, 0, 0, 0, 0, 4983, 1, 0, 0, 0, 0, 4985, 1, 0, 0, 0, 0, 4987, 1, 0, 0, 0, 1, 5001, 1, 0, 0, 0, 3, 5007, 1, 0, 0, 0, 5, 5011, 1, 0, 0, 0, 7, 5018, 1, 0, 0, 0, 9, 5025, 1, 0, 0, 0, 11, 5034, 1, 0, 0, 0, 13, 5045, 1, 0, 0, 0, 15, 5053, 1, 0, 0, 0, 17, 5057, 1, 0, 0, 0, 19, 5062, 1, 0, 0, 0, 21, 5069, 1, 0, 0, 0, 23, 5076, 1, 0, 0, 0, 25, 5084, 1, 0, 0, 0, 27, 5093, 1, 0, 0, 0, 29, 5100, 1, 0, 0, 0, 31, 5117, 1, 0, 0, 0, 33, 5129, 1, 0, 0, 0, 35, 5145, 1, 0, 0, 0, 37, 5156, 1, 0, 0, 0, 39, 5165, 1, 0, 0, 0, 41, 5179, 1, 0, 0, 0, 43, 5183, 1, 0, 0, 0, 45, 5194, 1, 0, 0, 0, 47, 5204, 1, 0, 0, 0, 49, 5215, 1, 0, 0, 0, 51, 5224, 1, 0, 0, 0, 53, 5230, 1, 0, 0, 0, 55, 5241, 1, 0, 0, 0, 57, 5255, 1, 0, 0, 0, 59, 5264, 1, 0, 0, 0, 61, 5271, 1, 0, 0, 0, 63, 5279, 1, 0, 0, 0, 65, 5294, 1, 0, 0, 0, 67, 5300, 1, 0, 0, 0, 69, 5306, 1, 0, 0, 0, 71, 5316, 1, 0, 0, 0, 73, 5318, 1, 0, 0, 0, 75, 5324, 1, 0, 0, 0, 77, 5328, 1, 0, 0, 0, 79, 5337, 1, 0, 0, 0, 81, 5343, 1, 0, 0, 0, 83, 5352, 1, 0, 0, 0, 85, 5358, 1, 0, 0, 0, 87, 5368, 1, 0, 0, 0, 89, 5375, 1, 0, 0, 0, 91, 5384, 1, 0, 0, 0, 93, 5392, 1, 0, 0, 0, 95, 5401, 1, 0, 0, 0, 97, 5411, 1, 0, 0, 0, 99, 5415, 1, 0, 0, 0, 101, 5425, 1, 0, 0, 0, 103, 5437, 1, 0, 0, 0, 105, 5445, 1, 0, 0, 0, 107, 5457, 1, 0, 0, 0, 109, 5466, 1, 0, 0, 0, 111, 5470, 1, 0, 0, 0, 113, 5480, 1, 0, 0, 0, 115, 5487, 1, 0, 0, 0, 117, 5502, 1, 0, 0, 0, 119, 5516, 1, 0, 0, 0, 121, 5528, 1, 0, 0, 0, 123, 5534, 1, 0, 0, 0, 125, 5556, 1, 0, 0, 0, 127, 5565, 1, 0, 0, 0, 129, 5573, 1, 0, 0, 0, 131, 5582, 1, 0, 0, 0, 133, 5593, 1, 0, 0, 0, 135, 5597, 1, 0, 0, 0, 137, 5603, 1, 0, 0, 0, 139, 5606, 1, 0, 0, 0, 141, 5610, 1, 0, 0, 0, 143, 5616, 1, 0, 0, 0, 145, 5625, 1, 0, 0, 0, 147, 5630, 1, 0, 0, 0, 149, 5635, 1, 0, 0, 0, 151, 5644, 1, 0, 0, 0, 153, 5651, 1, 0, 0, 0, 155, 5661, 1, 0, 0, 0, 157, 5667, 1, 0, 0, 0, 159, 5680, 1, 0, 0, 0, 161, 5686, 1, 0, 0, 0, 163, 5691, 1, 0, 0, 0, 165, 5694, 1, 0, 0, 0, 167, 5704, 1, 0, 0, 0, 169, 5715, 1, 0, 0, 0, 171, 5721, 1, 0, 0, 0, 173, 5735, 1, 0, 0, 0, 175, 5750, 1, 0, 0, 0, 177, 5757, 1, 0, 0, 0, 179, 5771, 1, 0, 0, 0, 181, 5784, 1, 0, 0, 0, 183, 5789, 1, 0, 0, 0, 185, 5800, 1, 0, 0, 0, 187, 5811, 1, 0, 0, 0, 189, 5822, 1, 0, 0, 0, 191, 5832, 1, 0, 0, 0, 193, 5855, 1, 0, 0, 0, 195, 5871, 1, 0, 0, 0, 197, 5884, 1, 0, 0, 0, 199, 5889, 1, 0, 0, 0, 201, 5900, 1, 0, 0, 0, 203, 5912, 1, 0, 0, 0, 205, 5919, 1, 0, 0, 0, 207, 5927, 1, 0, 0, 0, 209, 5937, 1, 0, 0, 0, 211, 5945, 1, 0, 0, 0, 213, 5951, 1, 0, 0, 0, 215, 5961, 1, 0, 0, 0, 217, 5967, 1, 0, 0, 0, 219, 5977, 1, 0, 0, 0, 221, 6005, 1, 0, 0, 0, 223, 6012, 1, 0, 0, 0, 225, 6019, 1, 0, 0, 0, 227, 6025, 1, 0, 0, 0, 229, 6035, 1, 0, 0, 0, 231, 6054, 1, 0, 0, 0, 233, 6061, 1, 0, 0, 0, 235, 6070, 1, 0, 0, 0, 237, 6078, 1, 0, 0, 0, 239, 6084, 1, 0, 0, 0, 241, 6094, 1, 0, 0, 0, 243, 6098, 1, 0, 0, 0, 245, 6106, 1, 0, 0, 0, 247, 6113, 1, 0, 0, 0, 249, 6120, 1, 0, 0, 0, 251, 6134, 1, 0, 0, 0, 253, 6157, 1, 0, 0, 0, 255, 6175, 1, 0, 0, 0, 257, 6188, 1, 0, 0, 0, 259, 6210, 1, 0, 0, 0, 261, 6227, 1, 0, 0, 0, 263, 6242, 1, 0, 0, 0, 265, 6253, 1, 0, 0, 0, 267, 6261, 1, 0, 0, 0, 269, 6272, 1, 0, 0, 0, 271, 6279, 1, 0, 0, 0, 273, 6290, 1, 0, 0, 0, 275, 6297, 1, 0, 0, 0, 277, 6305, 1, 0, 0, 0, 279, 6317, 1, 0, 0, 0, 281, 6322, 1, 0, 0, 0, 283, 6329, 1, 0, 0, 0, 285, 6334, 1, 0, 0, 0, 287, 6340, 1, 0, 0, 0, 289, 6352, 1, 0, 0, 0, 291, 6359, 1, 0, 0, 0, 293, 6369, 1, 0, 0, 0, 295, 6374, 1, 0, 0, 0, 297, 6382, 1, 0, 0, 0, 299, 6387, 1, 0, 0, 0, 301, 6393, 1, 0, 0, 0, 303, 6400, 1, 0, 0, 0, 305, 6408, 1, 0, 0, 0, 307, 6418, 1, 0, 0, 0, 309, 6423, 1, 0, 0, 0, 311, 6430, 1, 0, 0, 0, 313, 6443, 1, 0, 0, 0, 315, 6455, 1, 0, 0, 0, 317, 6461, 1, 0, 0, 0, 319, 6466, 1, 0, 0, 0, 321, 6469, 1, 0, 0, 0, 323, 6492, 1, 0, 0, 0, 325, 6504, 1, 0, 0, 0, 327, 6509, 1, 0, 0, 0, 329, 6515, 1, 0, 0, 0, 331, 6529, 1, 0, 0, 0, 333, 6535, 1, 0, 0, 0, 335, 6544, 1, 0, 0, 0, 337, 6560, 1, 0, 0, 0, 339, 6577, 1, 0, 0, 0, 341, 6585, 1, 0, 0, 0, 343, 6596, 1, 0, 0, 0, 345, 6605, 1, 0, 0, 0, 347, 6610, 1, 0, 0, 0, 349, 6617, 1, 0, 0, 0, 351, 6627, 1, 0, 0, 0, 353, 6636, 1, 0, 0, 0, 355, 6644, 1, 0, 0, 0, 357, 6656, 1, 0, 0, 0, 359, 6664, 1, 0, 0, 0, 361, 6669, 1, 0, 0, 0, 363, 6674, 1, 0, 0, 0, 365, 6689, 1, 0, 0, 0, 367, 6698, 1, 0, 0, 0, 369, 6710, 1, 0, 0, 0, 371, 6715, 1, 0, 0, 0, 373, 6732, 1, 0, 0, 0, 375, 6744, 1, 0, 0, 0, 377, 6750, 1, 0, 0, 0, 379, 6758, 1, 0, 0, 0, 381, 6765, 1, 0, 0, 0, 383, 6780, 1, 0, 0, 0, 385, 6806, 1, 0, 0, 0, 387, 6816, 1, 0, 0, 0, 389, 6827, 1, 0, 0, 0, 391, 6840, 1, 0, 0, 0, 393, 6845, 1, 0, 0, 0, 395, 6853, 1, 0, 0, 0, 397, 6865, 1, 0, 0, 0, 399, 6883, 1, 0, 0, 0, 401, 6889, 1, 0, 0, 0, 403, 6900, 1, 0, 0, 0, 405, 6906, 1, 0, 0, 0, 407, 6913, 1, 0, 0, 0, 409, 6917, 1, 0, 0, 0, 411, 6923, 1, 0, 0, 0, 413, 6929, 1, 0, 0, 0, 415, 6944, 1, 0, 0, 0, 417, 6955, 1, 0, 0, 0, 419, 6962, 1, 0, 0, 0, 421, 6968, 1, 0, 0, 0, 423, 6976, 1, 0, 0, 0, 425, 6982, 1, 0, 0, 0, 427, 6984, 1, 0, 0, 0, 429, 6991, 1, 0, 0, 0, 431, 6996, 1, 0, 0, 0, 433, 7002, 1, 0, 0, 0, 435, 7028, 1, 0, 0, 0, 437, 7034, 1, 0, 0, 0, 439, 7051, 1, 0, 0, 0, 441, 7059, 1, 0, 0, 0, 443, 7075, 1, 0, 0, 0, 445, 7092, 1, 0, 0, 0, 447, 7103, 1, 0, 0, 0, 449, 7114, 1, 0, 0, 0, 451, 7132, 1, 0, 0, 0, 453, 7152, 1, 0, 0, 0, 455, 7164, 1, 0, 0, 0, 457, 7173, 1, 0, 0, 0, 459, 7185, 1, 0, 0, 0, 461, 7192, 1, 0, 0, 0, 463, 7204, 1, 0, 0, 0, 465, 7209, 1, 0, 0, 0, 467, 7217, 1, 0, 0, 0, 469, 7228, 1, 0, 0, 0, 471, 7237, 1, 0, 0, 0, 473, 7259, 1, 0, 0, 0, 475, 7266, 1, 0, 0, 0, 477, 7274, 1, 0, 0, 0, 479, 7287, 1, 0, 0, 0, 481, 7300, 1, 0, 0, 0, 483, 7308, 1, 0, 0, 0, 485, 7315, 1, 0, 0, 0, 487, 7325, 1, 0, 0, 0, 489, 7332, 1, 0, 0, 0, 491, 7344, 1, 0, 0, 0, 493, 7352, 1, 0, 0, 0, 495, 7363, 1, 0, 0, 0, 497, 7377, 1, 0, 0, 0, 499, 7385, 1, 0, 0, 0, 501, 7394, 1, 0, 0, 0, 503, 7405, 1, 0, 0, 0, 505, 7415, 1, 0, 0, 0, 507, 7426, 1, 0, 0, 0, 509, 7434, 1, 0, 0, 0, 511, 7444, 1, 0, 0, 0, 513, 7460, 1, 0, 0, 0, 515, 7469, 1, 0, 0, 0, 517, 7478, 1, 0, 0, 0, 519, 7490, 1, 0, 0, 0, 521, 7498, 1, 0, 0, 0, 523, 7510, 1, 0, 0, 0, 525, 7517, 1, 0, 0, 0, 527, 7528, 1, 0, 0, 0, 529, 7543, 1, 0, 0, 0, 531, 7555, 1, 0, 0, 0, 533, 7565, 1, 0, 0, 0, 535, 7573, 1, 0, 0, 0, 537, 7584, 1, 0, 0, 0, 539, 7599, 1, 0, 0, 0, 541, 7606, 1, 0, 0, 0, 543, 7621, 1, 0, 0, 0, 545, 7644, 1, 0, 0, 0, 547, 7666, 1, 0, 0, 0, 549, 7688, 1, 0, 0, 0, 551, 7709, 1, 0, 0, 0, 553, 7730, 1, 0, 0, 0, 555, 7749, 1, 0, 0, 0, 557, 7767, 1, 0, 0, 0, 559, 7783, 1, 0, 0, 0, 561, 7791, 1, 0, 0, 0, 563, 7804, 1, 0, 0, 0, 565, 7813, 1, 0, 0, 0, 567, 7824, 1, 0, 0, 0, 569, 7833, 1, 0, 0, 0, 571, 7839, 1, 0, 0, 0, 573, 7850, 1, 0, 0, 0, 575, 7862, 1, 0, 0, 0, 577, 7874, 1, 0, 0, 0, 579, 7884, 1, 0, 0, 0, 581, 7895, 1, 0, 0, 0, 583, 7914, 1, 0, 0, 0, 585, 7929, 1, 0, 0, 0, 587, 7943, 1, 0, 0, 0, 589, 7951, 1, 0, 0, 0, 591, 7960, 1, 0, 0, 0, 593, 7968, 1, 0, 0, 0, 595, 7977, 1, 0, 0, 0, 597, 7989, 1, 0, 0, 0, 599, 8003, 1, 0, 0, 0, 601, 8011, 1, 0, 0, 0, 603, 8022, 1, 0, 0, 0, 605, 8029, 1, 0, 0, 0, 607, 8034, 1, 0, 0, 0, 609, 8041, 1, 0, 0, 0, 611, 8048, 1, 0, 0, 0, 613, 8059, 1, 0, 0, 0, 615, 8075, 1, 0, 0, 0, 617, 8087, 1, 0, 0, 0, 619, 8091, 1, 0, 0, 0, 621, 8096, 1, 0, 0, 0, 623, 8101, 1, 0, 0, 0, 625, 8124, 1, 0, 0, 0, 627, 8130, 1, 0, 0, 0, 629, 8138, 1, 0, 0, 0, 631, 8148, 1, 0, 0, 0, 633, 8159, 1, 0, 0, 0, 635, 8171, 1, 0, 0, 0, 637, 8184, 1, 0, 0, 0, 639, 8200, 1, 0, 0, 0, 641, 8206, 1, 0, 0, 0, 643, 8213, 1, 0, 0, 0, 645, 8230, 1, 0, 0, 0, 647, 8253, 1, 0, 0, 0, 649, 8262, 1, 0, 0, 0, 651, 8273, 1, 0, 0, 0, 653, 8282, 1, 0, 0, 0, 655, 8288, 1, 0, 0, 0, 657, 8301, 1, 0, 0, 0, 659, 8311, 1, 0, 0, 0, 661, 8315, 1, 0, 0, 0, 663, 8323, 1, 0, 0, 0, 665, 8328, 1, 0, 0, 0, 667, 8336, 1, 0, 0, 0, 669, 8344, 1, 0, 0, 0, 671, 8355, 1, 0, 0, 0, 673, 8363, 1, 0, 0, 0, 675, 8376, 1, 0, 0, 0, 677, 8391, 1, 0, 0, 0, 679, 8404, 1, 0, 0, 0, 681, 8422, 1, 0, 0, 0, 683, 8435, 1, 0, 0, 0, 685, 8444, 1, 0, 0, 0, 687, 8451, 1, 0, 0, 0, 689, 8472, 1, 0, 0, 0, 691, 8496, 1, 0, 0, 0, 693, 8508, 1, 0, 0, 0, 695, 8511, 1, 0, 0, 0, 697, 8517, 1, 0, 0, 0, 699, 8526, 1, 0, 0, 0, 701, 8535, 1, 0, 0, 0, 703, 8540, 1, 0, 0, 0, 705, 8549, 1, 0, 0, 0, 707, 8559, 1, 0, 0, 0, 709, 8575, 1, 0, 0, 0, 711, 8588, 1, 0, 0, 0, 713, 8598, 1, 0, 0, 0, 715, 8623, 1, 0, 0, 0, 717, 8644, 1, 0, 0, 0, 719, 8653, 1, 0, 0, 0, 721, 8681, 1, 0, 0, 0, 723, 8686, 1, 0, 0, 0, 725, 8697, 1, 0, 0, 0, 727, 8709, 1, 0, 0, 0, 729, 8719, 1, 0, 0, 0, 731, 8723, 1, 0, 0, 0, 733, 8728, 1, 0, 0, 0, 735, 8742, 1, 0, 0, 0, 737, 8746, 1, 0, 0, 0, 739, 8761, 1, 0, 0, 0, 741, 8768, 1, 0, 0, 0, 743, 8779, 1, 0, 0, 0, 745, 8794, 1, 0, 0, 0, 747, 8805, 1, 0, 0, 0, 749, 8820, 1, 0, 0, 0, 751, 8831, 1, 0, 0, 0, 753, 8835, 1, 0, 0, 0, 755, 8846, 1, 0, 0, 0, 757, 8852, 1, 0, 0, 0, 759, 8861, 1, 0, 0, 0, 761, 8865, 1, 0, 0, 0, 763, 8873, 1, 0, 0, 0, 765, 8881, 1, 0, 0, 0, 767, 8891, 1, 0, 0, 0, 769, 8903, 1, 0, 0, 0, 771, 8908, 1, 0, 0, 0, 773, 8918, 1, 0, 0, 0, 775, 8926, 1, 0, 0, 0, 777, 8938, 1, 0, 0, 0, 779, 8946, 1, 0, 0, 0, 781, 8956, 1, 0, 0, 0, 783, 8965, 1, 0, 0, 0, 785, 8983, 1, 0, 0, 0, 787, 9002, 1, 0, 0, 0, 789, 9013, 1, 0, 0, 0, 791, 9022, 1, 0, 0, 0, 793, 9030, 1, 0, 0, 0, 795, 9037, 1, 0, 0, 0, 797, 9045, 1, 0, 0, 0, 799, 9052, 1, 0, 0, 0, 801, 9058, 1, 0, 0, 0, 803, 9067, 1, 0, 0, 0, 805, 9078, 1, 0, 0, 0, 807, 9085, 1, 0, 0, 0, 809, 9095, 1, 0, 0, 0, 811, 9105, 1, 0, 0, 0, 813, 9112, 1, 0, 0, 0, 815, 9124, 1, 0, 0, 0, 817, 9134, 1, 0, 0, 0, 819, 9144, 1, 0, 0, 0, 821, 9150, 1, 0, 0, 0, 823, 9158, 1, 0, 0, 0, 825, 9164, 1, 0, 0, 0, 827, 9181, 1, 0, 0, 0, 829, 9186, 1, 0, 0, 0, 831, 9198, 1, 0, 0, 0, 833, 9206, 1, 0, 0, 0, 835, 9215, 1, 0, 0, 0, 837, 9224, 1, 0, 0, 0, 839, 9235, 1, 0, 0, 0, 841, 9249, 1, 0, 0, 0, 843, 9260, 1, 0, 0, 0, 845, 9270, 1, 0, 0, 0, 847, 9281, 1, 0, 0, 0, 849, 9290, 1, 0, 0, 0, 851, 9302, 1, 0, 0, 0, 853, 9312, 1, 0, 0, 0, 855, 9324, 1, 0, 0, 0, 857, 9336, 1, 0, 0, 0, 859, 9344, 1, 0, 0, 0, 861, 9353, 1, 0, 0, 0, 863, 9382, 1, 0, 0, 0, 865, 9403, 1, 0, 0, 0, 867, 9418, 1, 0, 0, 0, 869, 9431, 1, 0, 0, 0, 871, 9440, 1, 0, 0, 0, 873, 9453, 1, 0, 0, 0, 875, 9461, 1, 0, 0, 0, 877, 9473, 1, 0, 0, 0, 879, 9484, 1, 0, 0, 0, 881, 9489, 1, 0, 0, 0, 883, 9499, 1, 0, 0, 0, 885, 9512, 1, 0, 0, 0, 887, 9518, 1, 0, 0, 0, 889, 9527, 1, 0, 0, 0, 891, 9536, 1, 0, 0, 0, 893, 9550, 1, 0, 0, 0, 895, 9562, 1, 0, 0, 0, 897, 9573, 1, 0, 0, 0, 899, 9577, 1, 0, 0, 0, 901, 9588, 1, 0, 0, 0, 903, 9601, 1, 0, 0, 0, 905, 9613, 1, 0, 0, 0, 907, 9630, 1, 0, 0, 0, 909, 9642, 1, 0, 0, 0, 911, 9651, 1, 0, 0, 0, 913, 9657, 1, 0, 0, 0, 915, 9664, 1, 0, 0, 0, 917, 9669, 1, 0, 0, 0, 919, 9676, 1, 0, 0, 0, 921, 9680, 1, 0, 0, 0, 923, 9686, 1, 0, 0, 0, 925, 9706, 1, 0, 0, 0, 927, 9727, 1, 0, 0, 0, 929, 9745, 1, 0, 0, 0, 931, 9752, 1, 0, 0, 0, 933, 9762, 1, 0, 0, 0, 935, 9775, 1, 0, 0, 0, 937, 9787, 1, 0, 0, 0, 939, 9792, 1, 0, 0, 0, 941, 9803, 1, 0, 0, 0, 943, 9828, 1, 0, 0, 0, 945, 9852, 1, 0, 0, 0, 947, 9857, 1, 0, 0, 0, 949, 9865, 1, 0, 0, 0, 951, 9875, 1, 0, 0, 0, 953, 9878, 1, 0, 0, 0, 955, 9886, 1, 0, 0, 0, 957, 9903, 1, 0, 0, 0, 959, 9928, 1, 0, 0, 0, 961, 9930, 1, 0, 0, 0, 963, 9935, 1, 0, 0, 0, 965, 9947, 1, 0, 0, 0, 967, 9955, 1, 0, 0, 0, 969, 9966, 1, 0, 0, 0, 971, 9975, 1, 0, 0, 0, 973, 9983, 1, 0, 0, 0, 975, 9996, 1, 0, 0, 0, 977, 10011, 1, 0, 0, 0, 979, 10025, 1, 0, 0, 0, 981, 10046, 1, 0, 0, 0, 983, 10051, 1, 0, 0, 0, 985, 10057, 1, 0, 0, 0, 987, 10060, 1, 0, 0, 0, 989, 10069, 1, 0, 0, 0, 991, 10080, 1, 0, 0, 0, 993, 10091, 1, 0, 0, 0, 995, 10097, 1, 0, 0, 0, 997, 10108, 1, 0, 0, 0, 999, 10115, 1, 0, 0, 0, 1001, 10123, 1, 0, 0, 0, 1003, 10143, 1, 0, 0, 0, 1005, 10157, 1, 0, 0, 0, 1007, 10166, 1, 0, 0, 0, 1009, 10175, 1, 0, 0, 0, 1011, 10183, 1, 0, 0, 0, 1013, 10194, 1, 0, 0, 0, 1015, 10216, 1, 0, 0, 0, 1017, 10220, 1, 0, 0, 0, 1019, 10237, 1, 0, 0, 0, 1021, 10244, 1, 0, 0, 0, 1023, 10253, 1, 0, 0, 0, 1025, 10261, 1, 0, 0, 0, 1027, 10269, 1, 0, 0, 0, 1029, 10280, 1, 0, 0, 0, 1031, 10295, 1, 0, 0, 0, 1033, 10301, 1, 0, 0, 0, 1035, 10310, 1, 0, 0, 0, 1037, 10314, 1, 0, 0, 0, 1039, 10329, 1, 0, 0, 0, 1041, 10335, 1, 0, 0, 0, 1043, 10357, 1, 0, 0, 0, 1045, 10364, 1, 0, 0, 0, 1047, 10376, 1, 0, 0, 0, 1049, 10387, 1, 0, 0, 0, 1051, 10394, 1, 0, 0, 0, 1053, 10402, 1, 0, 0, 0, 1055, 10411, 1, 0, 0, 0, 1057, 10416, 1, 0, 0, 0, 1059, 10425, 1, 0, 0, 0, 1061, 10434, 1, 0, 0, 0, 1063, 10445, 1, 0, 0, 0, 1065, 10452, 1, 0, 0, 0, 1067, 10458, 1, 0, 0, 0, 1069, 10465, 1, 0, 0, 0, 1071, 10475, 1, 0, 0, 0, 1073, 10490, 1, 0, 0, 0, 1075, 10501, 1, 0, 0, 0, 1077, 10510, 1, 0, 0, 0, 1079, 10518, 1, 0, 0, 0, 1081, 10528, 1, 0, 0, 0, 1083, 10538, 1, 0, 0, 0, 1085, 10546, 1, 0, 0, 0, 1087, 10553, 1, 0, 0, 0, 1089, 10562, 1, 0, 0, 0, 1091, 10569, 1, 0, 0, 0, 1093, 10580, 1, 0, 0, 0, 1095, 10585, 1, 0, 0, 0, 1097, 10606, 1, 0, 0, 0, 1099, 10619, 1, 0, 0, 0, 1101, 10623, 1, 0, 0, 0, 1103, 10630, 1, 0, 0, 0, 1105, 10638, 1, 0, 0, 0, 1107, 10648, 1, 0, 0, 0, 1109, 10655, 1, 0, 0, 0, 1111, 10671, 1, 0, 0, 0, 1113, 10679, 1, 0, 0, 0, 1115, 10687, 1, 0, 0, 0, 1117, 10694, 1, 0, 0, 0, 1119, 10702, 1, 0, 0, 0, 1121, 10711, 1, 0, 0, 0, 1123, 10722, 1, 0, 0, 0, 1125, 10737, 1, 0, 0, 0, 1127, 10745, 1, 0, 0, 0, 1129, 10758, 1, 0, 0, 0, 1131, 10764, 1, 0, 0, 0, 1133, 10773, 1, 0, 0, 0, 1135, 10778, 1, 0, 0, 0, 1137, 10785, 1, 0, 0, 0, 1139, 10800, 1, 0, 0, 0, 1141, 10807, 1, 0, 0, 0, 1143, 10829, 1, 0, 0, 0, 1145, 10839, 1, 0, 0, 0, 1147, 10848, 1, 0, 0, 0, 1149, 10856, 1, 0, 0, 0, 1151, 10862, 1, 0, 0, 0, 1153, 10869, 1, 0, 0, 0, 1155, 10873, 1, 0, 0, 0, 1157, 10878, 1, 0, 0, 0, 1159, 10888, 1, 0, 0, 0, 1161, 10896, 1, 0, 0, 0, 1163, 10904, 1, 0, 0, 0, 1165, 10920, 1, 0, 0, 0, 1167, 10931, 1, 0, 0, 0, 1169, 10943, 1, 0, 0, 0, 1171, 10957, 1, 0, 0, 0, 1173, 10963, 1, 0, 0, 0, 1175, 10969, 1, 0, 0, 0, 1177, 10976, 1, 0, 0, 0, 1179, 10981, 1, 0, 0, 0, 1181, 10999, 1, 0, 0, 0, 1183, 11009, 1, 0, 0, 0, 1185, 11019, 1, 0, 0, 0, 1187, 11043, 1, 0, 0, 0, 1189, 11050, 1, 0, 0, 0, 1191, 11056, 1, 0, 0, 0, 1193, 11061, 1, 0, 0, 0, 1195, 11068, 1, 0, 0, 0, 1197, 11074, 1, 0, 0, 0, 1199, 11081, 1, 0, 0, 0, 1201, 11092, 1, 0, 0, 0, 1203, 11104, 1, 0, 0, 0, 1205, 11110, 1, 0, 0, 0, 1207, 11126, 1, 0, 0, 0, 1209, 11134, 1, 0, 0, 0, 1211, 11144, 1, 0, 0, 0, 1213, 11156, 1, 0, 0, 0, 1215, 11162, 1, 0, 0, 0, 1217, 11167, 1, 0, 0, 0, 1219, 11172, 1, 0, 0, 0, 1221, 11178, 1, 0, 0, 0, 1223, 11184, 1, 0, 0, 0, 1225, 11191, 1, 0, 0, 0, 1227, 11201, 1, 0, 0, 0, 1229, 11209, 1, 0, 0, 0, 1231, 11216, 1, 0, 0, 0, 1233, 11222, 1, 0, 0, 0, 1235, 11246, 1, 0, 0, 0, 1237, 11254, 1, 0, 0, 0, 1239, 11262, 1, 0, 0, 0, 1241, 11266, 1, 0, 0, 0, 1243, 11273, 1, 0, 0, 0, 1245, 11281, 1, 0, 0, 0, 1247, 11297, 1, 0, 0, 0, 1249, 11306, 1, 0, 0, 0, 1251, 11316, 1, 0, 0, 0, 1253, 11326, 1, 0, 0, 0, 1255, 11332, 1, 0, 0, 0, 1257, 11337, 1, 0, 0, 0, 1259, 11345, 1, 0, 0, 0, 1261, 11350, 1, 0, 0, 0, 1263, 11375, 1, 0, 0, 0, 1265, 11384, 1, 0, 0, 0, 1267, 11394, 1, 0, 0, 0, 1269, 11398, 1, 0, 0, 0, 1271, 11400, 1, 0, 0, 0, 1273, 11428, 1, 0, 0, 0, 1275, 11451, 1, 0, 0, 0, 1277, 11467, 1, 0, 0, 0, 1279, 11480, 1, 0, 0, 0, 1281, 11490, 1, 0, 0, 0, 1283, 11494, 1, 0, 0, 0, 1285, 11501, 1, 0, 0, 0, 1287, 11510, 1, 0, 0, 0, 1289, 11522, 1, 0, 0, 0, 1291, 11543, 1, 0, 0, 0, 1293, 11548, 1, 0, 0, 0, 1295, 11554, 1, 0, 0, 0, 1297, 11563, 1, 0, 0, 0, 1299, 11569, 1, 0, 0, 0, 1301, 11578, 1, 0, 0, 0, 1303, 11587, 1, 0, 0, 0, 1305, 11599, 1, 0, 0, 0, 1307, 11606, 1, 0, 0, 0, 1309, 11617, 1, 0, 0, 0, 1311, 11627, 1, 0, 0, 0, 1313, 11633, 1, 0, 0, 0, 1315, 11649, 1, 0, 0, 0, 1317, 11660, 1, 0, 0, 0, 1319, 11668, 1, 0, 0, 0, 1321, 11673, 1, 0, 0, 0, 1323, 11682, 1, 0, 0, 0, 1325, 11690, 1, 0, 0, 0, 1327, 11697, 1, 0, 0, 0, 1329, 11704, 1, 0, 0, 0, 1331, 11709, 1, 0, 0, 0, 1333, 11714, 1, 0, 0, 0, 1335, 11723, 1, 0, 0, 0, 1337, 11732, 1, 0, 0, 0, 1339, 11739, 1, 0, 0, 0, 1341, 11744, 1, 0, 0, 0, 1343, 11755, 1, 0, 0, 0, 1345, 11768, 1, 0, 0, 0, 1347, 11780, 1, 0, 0, 0, 1349, 11790, 1, 0, 0, 0, 1351, 11795, 1, 0, 0, 0, 1353, 11809, 1, 0, 0, 0, 1355, 11821, 1, 0, 0, 0, 1357, 11825, 1, 0, 0, 0, 1359, 11830, 1, 0, 0, 0, 1361, 11836, 1, 0, 0, 0, 1363, 11841, 1, 0, 0, 0, 1365, 11854, 1, 0, 0, 0, 1367, 11861, 1, 0, 0, 0, 1369, 11863, 1, 0, 0, 0, 1371, 11874, 1, 0, 0, 0, 1373, 11885, 1, 0, 0, 0, 1375, 11894, 1, 0, 0, 0, 1377, 11907, 1, 0, 0, 0, 1379, 11910, 1, 0, 0, 0, 1381, 11920, 1, 0, 0, 0, 1383, 11923, 1, 0, 0, 0, 1385, 11930, 1, 0, 0, 0, 1387, 11953, 1, 0, 0, 0, 1389, 11981, 1, 0, 0, 0, 1391, 12008, 1, 0, 0, 0, 1393, 12028, 1, 0, 0, 0, 1395, 12032, 1, 0, 0, 0, 1397, 12042, 1, 0, 0, 0, 1399, 12049, 1, 0, 0, 0, 1401, 12056, 1, 0, 0, 0, 1403, 12065, 1, 0, 0, 0, 1405, 12087, 1, 0, 0, 0, 1407, 12095, 1, 0, 0, 0, 1409, 12111, 1, 0, 0, 0, 1411, 12121, 1, 0, 0, 0, 1413, 12133, 1, 0, 0, 0, 1415, 12143, 1, 0, 0, 0, 1417, 12148, 1, 0, 0, 0, 1419, 12155, 1, 0, 0, 0, 1421, 12165, 1, 0, 0, 0, 1423, 12179, 1, 0, 0, 0, 1425, 12190, 1, 0, 0, 0, 1427, 12198, 1, 0, 0, 0, 1429, 12206, 1, 0, 0, 0, 1431, 12216, 1, 0, 0, 0, 1433, 12229, 1, 0, 0, 0, 1435, 12235, 1, 0, 0, 0, 1437, 12244, 1, 0, 0, 0, 1439, 12255, 1, 0, 0, 0, 1441, 12266, 1, 0, 0, 0, 1443, 12276, 1, 0, 0, 0, 1445, 12289, 1, 0, 0, 0, 1447, 12303, 1, 0, 0, 0, 1449, 12312, 1, 0, 0, 0, 1451, 12323, 1, 0, 0, 0, 1453, 12339, 1, 0, 0, 0, 1455, 12352, 1, 0, 0, 0, 1457, 12366, 1, 0, 0, 0, 1459, 12375, 1, 0, 0, 0, 1461, 12387, 1, 0, 0, 0, 1463, 12397, 1, 0, 0, 0, 1465, 12408, 1, 0, 0, 0, 1467, 12418, 1, 0, 0, 0, 1469, 12426, 1, 0, 0, 0, 1471, 12435, 1, 0, 0, 0, 1473, 12449, 1, 0, 0, 0, 1475, 12457, 1, 0, 0, 0, 1477, 12460, 1, 0, 0, 0, 1479, 12468, 1, 0, 0, 0, 1481, 12476, 1, 0, 0, 0, 1483, 12488, 1, 0, 0, 0, 1485, 12498, 1, 0, 0, 0, 1487, 12507, 1, 0, 0, 0, 1489, 12514, 1, 0, 0, 0, 1491, 12532, 1, 0, 0, 0, 1493, 12541, 1, 0, 0, 0, 1495, 12560, 1, 0, 0, 0, 1497, 12577, 1, 0, 0, 0, 1499, 12583, 1, 0, 0, 0, 1501, 12589, 1, 0, 0, 0, 1503, 12597, 1, 0, 0, 0, 1505, 12609, 1, 0, 0, 0, 1507, 12629, 1, 0, 0, 0, 1509, 12650, 1, 0, 0, 0, 1511, 12665, 1, 0, 0, 0, 1513, 12672, 1, 0, 0, 0, 1515, 12687, 1, 0, 0, 0, 1517, 12703, 1, 0, 0, 0, 1519, 12712, 1, 0, 0, 0, 1521, 12722, 1, 0, 0, 0, 1523, 12735, 1, 0, 0, 0, 1525, 12745, 1, 0, 0, 0, 1527, 12753, 1, 0, 0, 0, 1529, 12760, 1, 0, 0, 0, 1531, 12767, 1, 0, 0, 0, 1533, 12774, 1, 0, 0, 0, 1535, 12781, 1, 0, 0, 0, 1537, 12787, 1, 0, 0, 0, 1539, 12795, 1, 0, 0, 0, 1541, 12807, 1, 0, 0, 0, 1543, 12820, 1, 0, 0, 0, 1545, 12837, 1, 0, 0, 0, 1547, 12850, 1, 0, 0, 0, 1549, 12862, 1, 0, 0, 0, 1551, 12872, 1, 0, 0, 0, 1553, 12881, 1, 0, 0, 0, 1555, 12885, 1, 0, 0, 0, 1557, 12894, 1, 0, 0, 0, 1559, 12899, 1, 0, 0, 0, 1561, 12910, 1, 0, 0, 0, 1563, 12923, 1, 0, 0, 0, 1565, 12933, 1, 0, 0, 0, 1567, 12943, 1, 0, 0, 0, 1569, 12954, 1, 0, 0, 0, 1571, 12957, 1, 0, 0, 0, 1573, 12965, 1, 0, 0, 0, 1575, 12975, 1, 0, 0, 0, 1577, 12991, 1, 0, 0, 0, 1579, 12997, 1, 0, 0, 0, 1581, 13005, 1, 0, 0, 0, 1583, 13022, 1, 0, 0, 0, 1585, 13027, 1, 0, 0, 0, 1587, 13031, 1, 0, 0, 0, 1589, 13036, 1, 0, 0, 0, 1591, 13050, 1, 0, 0, 0, 1593, 13061, 1, 0, 0, 0, 1595, 13072, 1, 0, 0, 0, 1597, 13085, 1, 0, 0, 0, 1599, 13097, 1, 0, 0, 0, 1601, 13105, 1, 0, 0, 0, 1603, 13110, 1, 0, 0, 0, 1605, 13125, 1, 0, 0, 0, 1607, 13137, 1, 0, 0, 0, 1609, 13147, 1, 0, 0, 0, 1611, 13158, 1, 0, 0, 0, 1613, 13173, 1, 0, 0, 0, 1615, 13184, 1, 0, 0, 0, 1617, 13203, 1, 0, 0, 0, 1619, 13221, 1, 0, 0, 0, 1621, 13236, 1, 0, 0, 0, 1623, 13247, 1, 0, 0, 0, 1625, 13249, 1, 0, 0, 0, 1627, 13265, 1, 0, 0, 0, 1629, 13270, 1, 0, 0, 0, 1631, 13279, 1, 0, 0, 0, 1633, 13283, 1, 0, 0, 0, 1635, 13294, 1, 0, 0, 0, 1637, 13302, 1, 0, 0, 0, 1639, 13307, 1, 0, 0, 0, 1641, 13316, 1, 0, 0, 0, 1643, 13321, 1, 0, 0, 0, 1645, 13327, 1, 0, 0, 0, 1647, 13336, 1, 0, 0, 0, 1649, 13345, 1, 0, 0, 0, 1651, 13350, 1, 0, 0, 0, 1653, 13361, 1, 0, 0, 0, 1655, 13369, 1, 0, 0, 0, 1657, 13376, 1, 0, 0, 0, 1659, 13380, 1, 0, 0, 0, 1661, 13386, 1, 0, 0, 0, 1663, 13412, 1, 0, 0, 0, 1665, 13430, 1, 0, 0, 0, 1667, 13453, 1, 0, 0, 0, 1669, 13461, 1, 0, 0, 0, 1671, 13466, 1, 0, 0, 0, 1673, 13475, 1, 0, 0, 0, 1675, 13488, 1, 0, 0, 0, 1677, 13496, 1, 0, 0, 0, 1679, 13501, 1, 0, 0, 0, 1681, 13509, 1, 0, 0, 0, 1683, 13517, 1, 0, 0, 0, 1685, 13525, 1, 0, 0, 0, 1687, 13533, 1, 0, 0, 0, 1689, 13540, 1, 0, 0, 0, 1691, 13545, 1, 0, 0, 0, 1693, 13551, 1, 0, 0, 0, 1695, 13562, 1, 0, 0, 0, 1697, 13569, 1, 0, 0, 0, 1699, 13577, 1, 0, 0, 0, 1701, 13587, 1, 0, 0, 0, 1703, 13592, 1, 0, 0, 0, 1705, 13601, 1, 0, 0, 0, 1707, 13607, 1, 0, 0, 0, 1709, 13613, 1, 0, 0, 0, 1711, 13619, 1, 0, 0, 0, 1713, 13631, 1, 0, 0, 0, 1715, 13636, 1, 0, 0, 0, 1717, 13642, 1, 0, 0, 0, 1719, 13649, 1, 0, 0, 0, 1721, 13655, 1, 0, 0, 0, 1723, 13660, 1, 0, 0, 0, 1725, 13665, 1, 0, 0, 0, 1727, 13672, 1, 0, 0, 0, 1729, 13676, 1, 0, 0, 0, 1731, 13679, 1, 0, 0, 0, 1733, 13685, 1, 0, 0, 0, 1735, 13690, 1, 0, 0, 0, 1737, 13694, 1, 0, 0, 0, 1739, 13702, 1, 0, 0, 0, 1741, 13709, 1, 0, 0, 0, 1743, 13714, 1, 0, 0, 0, 1745, 13728, 1, 0, 0, 0, 1747, 13734, 1, 0, 0, 0, 1749, 13744, 1, 0, 0, 0, 1751, 13759, 1, 0, 0, 0, 1753, 13768, 1, 0, 0, 0, 1755, 13776, 1, 0, 0, 0, 1757, 13785, 1, 0, 0, 0, 1759, 13792, 1, 0, 0, 0, 1761, 13800, 1, 0, 0, 0, 1763, 13805, 1, 0, 0, 0, 1765, 13813, 1, 0, 0, 0, 1767, 13822, 1, 0, 0, 0, 1769, 13830, 1, 0, 0, 0, 1771, 13838, 1, 0, 0, 0, 1773, 13861, 1, 0, 0, 0, 1775, 13887, 1, 0, 0, 0, 1777, 13891, 1, 0, 0, 0, 1779, 13901, 1, 0, 0, 0, 1781, 13908, 1, 0, 0, 0, 1783, 13914, 1, 0, 0, 0, 1785, 13939, 1, 0, 0, 0, 1787, 13944, 1, 0, 0, 0, 1789, 13949, 1, 0, 0, 0, 1791, 13954, 1, 0, 0, 0, 1793, 13960, 1, 0, 0, 0, 1795, 13964, 1, 0, 0, 0, 1797, 13969, 1, 0, 0, 0, 1799, 13976, 1, 0, 0, 0, 1801, 13982, 1, 0, 0, 0, 1803, 13984, 1, 0, 0, 0, 1805, 13989, 1, 0, 0, 0, 1807, 13998, 1, 0, 0, 0, 1809, 14006, 1, 0, 0, 0, 1811, 14013, 1, 0, 0, 0, 1813, 14024, 1, 0, 0, 0, 1815, 14032, 1, 0, 0, 0, 1817, 14042, 1, 0, 0, 0, 1819, 14049, 1, 0, 0, 0, 1821, 14053, 1, 0, 0, 0, 1823, 14061, 1, 0, 0, 0, 1825, 14066, 1, 0, 0, 0, 1827, 14073, 1, 0, 0, 0, 1829, 14081, 1, 0, 0, 0, 1831, 14089, 1, 0, 0, 0, 1833, 14095, 1, 0, 0, 0, 1835, 14108, 1, 0, 0, 0, 1837, 14124, 1, 0, 0, 0, 1839, 14137, 1, 0, 0, 0, 1841, 14149, 1, 0, 0, 0, 1843, 14161, 1, 0, 0, 0, 1845, 14174, 1, 0, 0, 0, 1847, 14185, 1, 0, 0, 0, 1849, 14194, 1, 0, 0, 0, 1851, 14207, 1, 0, 0, 0, 1853, 14219, 1, 0, 0, 0, 1855, 14233, 1, 0, 0, 0, 1857, 14247, 1, 0, 0, 0, 1859, 14268, 1, 0, 0, 0, 1861, 14276, 1, 0, 0, 0, 1863, 14285, 1, 0, 0, 0, 1865, 14294, 1, 0, 0, 0, 1867, 14302, 1, 0, 0, 0, 1869, 14311, 1, 0, 0, 0, 1871, 14318, 1, 0, 0, 0, 1873, 14325, 1, 0, 0, 0, 1875, 14340, 1, 0, 0, 0, 1877, 14359, 1, 0, 0, 0, 1879, 14371, 1, 0, 0, 0, 1881, 14390, 1, 0, 0, 0, 1883, 14402, 1, 0, 0, 0, 1885, 14409, 1, 0, 0, 0, 1887, 14423, 1, 0, 0, 0, 1889, 14432, 1, 0, 0, 0, 1891, 14447, 1, 0, 0, 0, 1893, 14453, 1, 0, 0, 0, 1895, 14462, 1, 0, 0, 0, 1897, 14471, 1, 0, 0, 0, 1899, 14478, 1, 0, 0, 0, 1901, 14486, 1, 0, 0, 0, 1903, 14496, 1, 0, 0, 0, 1905, 14507, 1, 0, 0, 0, 1907, 14516, 1, 0, 0, 0, 1909, 14524, 1, 0, 0, 0, 1911, 14531, 1, 0, 0, 0, 1913, 14537, 1, 0, 0, 0, 1915, 14548, 1, 0, 0, 0, 1917, 14555, 1, 0, 0, 0, 1919, 14563, 1, 0, 0, 0, 1921, 14572, 1, 0, 0, 0, 1923, 14583, 1, 0, 0, 0, 1925, 14593, 1, 0, 0, 0, 1927, 14600, 1, 0, 0, 0, 1929, 14608, 1, 0, 0, 0, 1931, 14617, 1, 0, 0, 0, 1933, 14626, 1, 0, 0, 0, 1935, 14649, 1, 0, 0, 0, 1937, 14677, 1, 0, 0, 0, 1939, 14700, 1, 0, 0, 0, 1941, 14719, 1, 0, 0, 0, 1943, 14725, 1, 0, 0, 0, 1945, 14734, 1, 0, 0, 0, 1947, 14752, 1, 0, 0, 0, 1949, 14762, 1, 0, 0, 0, 1951, 14777, 1, 0, 0, 0, 1953, 14786, 1, 0, 0, 0, 1955, 14791, 1, 0, 0, 0, 1957, 14804, 1, 0, 0, 0, 1959, 14823, 1, 0, 0, 0, 1961, 14830, 1, 0, 0, 0, 1963, 14834, 1, 0, 0, 0, 1965, 14841, 1, 0, 0, 0, 1967, 14852, 1, 0, 0, 0, 1969, 14860, 1, 0, 0, 0, 1971, 14866, 1, 0, 0, 0, 1973, 14881, 1, 0, 0, 0, 1975, 14888, 1, 0, 0, 0, 1977, 14894, 1, 0, 0, 0, 1979, 14904, 1, 0, 0, 0, 1981, 14915, 1, 0, 0, 0, 1983, 14924, 1, 0, 0, 0, 1985, 14929, 1, 0, 0, 0, 1987, 14946, 1, 0, 0, 0, 1989, 14955, 1, 0, 0, 0, 1991, 14964, 1, 0, 0, 0, 1993, 14970, 1, 0, 0, 0, 1995, 14975, 1, 0, 0, 0, 1997, 14985, 1, 0, 0, 0, 1999, 14989, 1, 0, 0, 0, 2001, 14995, 1, 0, 0, 0, 2003, 15004, 1, 0, 0, 0, 2005, 15027, 1, 0, 0, 0, 2007, 15034, 1, 0, 0, 0, 2009, 15042, 1, 0, 0, 0, 2011, 15051, 1, 0, 0, 0, 2013, 15055, 1, 0, 0, 0, 2015, 15064, 1, 0, 0, 0, 2017, 15070, 1, 0, 0, 0, 2019, 15075, 1, 0, 0, 0, 2021, 15081, 1, 0, 0, 0, 2023, 15088, 1, 0, 0, 0, 2025, 15092, 1, 0, 0, 0, 2027, 15099, 1, 0, 0, 0, 2029, 15124, 1, 0, 0, 0, 2031, 15146, 1, 0, 0, 0, 2033, 15162, 1, 0, 0, 0, 2035, 15184, 1, 0, 0, 0, 2037, 15207, 1, 0, 0, 0, 2039, 15215, 1, 0, 0, 0, 2041, 15221, 1, 0, 0, 0, 2043, 15225, 1, 0, 0, 0, 2045, 15233, 1, 0, 0, 0, 2047, 15242, 1, 0, 0, 0, 2049, 15251, 1, 0, 0, 0, 2051, 15256, 1, 0, 0, 0, 2053, 15262, 1, 0, 0, 0, 2055, 15275, 1, 0, 0, 0, 2057, 15292, 1, 0, 0, 0, 2059, 15307, 1, 0, 0, 0, 2061, 15320, 1, 0, 0, 0, 2063, 15333, 1, 0, 0, 0, 2065, 15350, 1, 0, 0, 0, 2067, 15371, 1, 0, 0, 0, 2069, 15386, 1, 0, 0, 0, 2071, 15403, 1, 0, 0, 0, 2073, 15412, 1, 0, 0, 0, 2075, 15425, 1, 0, 0, 0, 2077, 15441, 1, 0, 0, 0, 2079, 15459, 1, 0, 0, 0, 2081, 15471, 1, 0, 0, 0, 2083, 15488, 1, 0, 0, 0, 2085, 15494, 1, 0, 0, 0, 2087, 15503, 1, 0, 0, 0, 2089, 15516, 1, 0, 0, 0, 2091, 15537, 1, 0, 0, 0, 2093, 15547, 1, 0, 0, 0, 2095, 15567, 1, 0, 0, 0, 2097, 15590, 1, 0, 0, 0, 2099, 15599, 1, 0, 0, 0, 2101, 15607, 1, 0, 0, 0, 2103, 15625, 1, 0, 0, 0, 2105, 15639, 1, 0, 0, 0, 2107, 15649, 1, 0, 0, 0, 2109, 15659, 1, 0, 0, 0, 2111, 15676, 1, 0, 0, 0, 2113, 15691, 1, 0, 0, 0, 2115, 15700, 1, 0, 0, 0, 2117, 15713, 1, 0, 0, 0, 2119, 15721, 1, 0, 0, 0, 2121, 15731, 1, 0, 0, 0, 2123, 15750, 1, 0, 0, 0, 2125, 15779, 1, 0, 0, 0, 2127, 15810, 1, 0, 0, 0, 2129, 15824, 1, 0, 0, 0, 2131, 15834, 1, 0, 0, 0, 2133, 15842, 1, 0, 0, 0, 2135, 15850, 1, 0, 0, 0, 2137, 15863, 1, 0, 0, 0, 2139, 15884, 1, 0, 0, 0, 2141, 15904, 1, 0, 0, 0, 2143, 15918, 1, 0, 0, 0, 2145, 15933, 1, 0, 0, 0, 2147, 15948, 1, 0, 0, 0, 2149, 15959, 1, 0, 0, 0, 2151, 15985, 1, 0, 0, 0, 2153, 16010, 1, 0, 0, 0, 2155, 16035, 1, 0, 0, 0, 2157, 16059, 1, 0, 0, 0, 2159, 16083, 1, 0, 0, 0, 2161, 16090, 1, 0, 0, 0, 2163, 16116, 1, 0, 0, 0, 2165, 16131, 1, 0, 0, 0, 2167, 16145, 1, 0, 0, 0, 2169, 16153, 1, 0, 0, 0, 2171, 16178, 1, 0, 0, 0, 2173, 16193, 1, 0, 0, 0, 2175, 16201, 1, 0, 0, 0, 2177, 16212, 1, 0, 0, 0, 2179, 16226, 1, 0, 0, 0, 2181, 16249, 1, 0, 0, 0, 2183, 16276, 1, 0, 0, 0, 2185, 16292, 1, 0, 0, 0, 2187, 16310, 1, 0, 0, 0, 2189, 16327, 1, 0, 0, 0, 2191, 16351, 1, 0, 0, 0, 2193, 16368, 1, 0, 0, 0, 2195, 16392, 1, 0, 0, 0, 2197, 16402, 1, 0, 0, 0, 2199, 16418, 1, 0, 0, 0, 2201, 16427, 1, 0, 0, 0, 2203, 16435, 1, 0, 0, 0, 2205, 16453, 1, 0, 0, 0, 2207, 16466, 1, 0, 0, 0, 2209, 16474, 1, 0, 0, 0, 2211, 16502, 1, 0, 0, 0, 2213, 16533, 1, 0, 0, 0, 2215, 16549, 1, 0, 0, 0, 2217, 16561, 1, 0, 0, 0, 2219, 16574, 1, 0, 0, 0, 2221, 16583, 1, 0, 0, 0, 2223, 16595, 1, 0, 0, 0, 2225, 16607, 1, 0, 0, 0, 2227, 16627, 1, 0, 0, 0, 2229, 16634, 1, 0, 0, 0, 2231, 16642, 1, 0, 0, 0, 2233, 16650, 1, 0, 0, 0, 2235, 16656, 1, 0, 0, 0, 2237, 16666, 1, 0, 0, 0, 2239, 16676, 1, 0, 0, 0, 2241, 16686, 1, 0, 0, 0, 2243, 16697, 1, 0, 0, 0, 2245, 16706, 1, 0, 0, 0, 2247, 16717, 1, 0, 0, 0, 2249, 16728, 1, 0, 0, 0, 2251, 16746, 1, 0, 0, 0, 2253, 16760, 1, 0, 0, 0, 2255, 16773, 1, 0, 0, 0, 2257, 16784, 1, 0, 0, 0, 2259, 16803, 1, 0, 0, 0, 2261, 16829, 1, 0, 0, 0, 2263, 16841, 1, 0, 0, 0, 2265, 16856, 1, 0, 0, 0, 2267, 16861, 1, 0, 0, 0, 2269, 16870, 1, 0, 0, 0, 2271, 16886, 1, 0, 0, 0, 2273, 16902, 1, 0, 0, 0, 2275, 16905, 1, 0, 0, 0, 2277, 16915, 1, 0, 0, 0, 2279, 16930, 1, 0, 0, 0, 2281, 16938, 1, 0, 0, 0, 2283, 16955, 1, 0, 0, 0, 2285, 16977, 1, 0, 0, 0, 2287, 17000, 1, 0, 0, 0, 2289, 17011, 1, 0, 0, 0, 2291, 17029, 1, 0, 0, 0, 2293, 17046, 1, 0, 0, 0, 2295, 17058, 1, 0, 0, 0, 2297, 17069, 1, 0, 0, 0, 2299, 17087, 1, 0, 0, 0, 2301, 17103, 1, 0, 0, 0, 2303, 17130, 1, 0, 0, 0, 2305, 17142, 1, 0, 0, 0, 2307, 17160, 1, 0, 0, 0, 2309, 17178, 1, 0, 0, 0, 2311, 17201, 1, 0, 0, 0, 2313, 17211, 1, 0, 0, 0, 2315, 17220, 1, 0, 0, 0, 2317, 17236, 1, 0, 0, 0, 2319, 17247, 1, 0, 0, 0, 2321, 17262, 1, 0, 0, 0, 2323, 17275, 1, 0, 0, 0, 2325, 17288, 1, 0, 0, 0, 2327, 17301, 1, 0, 0, 0, 2329, 17323, 1, 0, 0, 0, 2331, 17341, 1, 0, 0, 0, 2333, 17353, 1, 0, 0, 0, 2335, 17377, 1, 0, 0, 0, 2337, 17392, 1, 0, 0, 0, 2339, 17403, 1, 0, 0, 0, 2341, 17410, 1, 0, 0, 0, 2343, 17419, 1, 0, 0, 0, 2345, 17428, 1, 0, 0, 0, 2347, 17440, 1, 0, 0, 0, 2349, 17456, 1, 0, 0, 0, 2351, 17466, 1, 0, 0, 0, 2353, 17477, 1, 0, 0, 0, 2355, 17487, 1, 0, 0, 0, 2357, 17494, 1, 0, 0, 0, 2359, 17515, 1, 0, 0, 0, 2361, 17533, 1, 0, 0, 0, 2363, 17541, 1, 0, 0, 0, 2365, 17555, 1, 0, 0, 0, 2367, 17565, 1, 0, 0, 0, 2369, 17577, 1, 0, 0, 0, 2371, 17594, 1, 0, 0, 0, 2373, 17609, 1, 0, 0, 0, 2375, 17617, 1, 0, 0, 0, 2377, 17624, 1, 0, 0, 0, 2379, 17643, 1, 0, 0, 0, 2381, 17655, 1, 0, 0, 0, 2383, 17678, 1, 0, 0, 0, 2385, 17699, 1, 0, 0, 0, 2387, 17714, 1, 0, 0, 0, 2389, 17723, 1, 0, 0, 0, 2391, 17743, 1, 0, 0, 0, 2393, 17758, 1, 0, 0, 0, 2395, 17778, 1, 0, 0, 0, 2397, 17787, 1, 0, 0, 0, 2399, 17809, 1, 0, 0, 0, 2401, 17823, 1, 0, 0, 0, 2403, 17831, 1, 0, 0, 0, 2405, 17844, 1, 0, 0, 0, 2407, 17851, 1, 0, 0, 0, 2409, 17855, 1, 0, 0, 0, 2411, 17881, 1, 0, 0, 0, 2413, 17891, 1, 0, 0, 0, 2415, 17903, 1, 0, 0, 0, 2417, 17927, 1, 0, 0, 0, 2419, 17956, 1, 0, 0, 0, 2421, 17968, 1, 0, 0, 0, 2423, 17993, 1, 0, 0, 0, 2425, 18006, 1, 0, 0, 0, 2427, 18016, 1, 0, 0, 0, 2429, 18042, 1, 0, 0, 0, 2431, 18053, 1, 0, 0, 0, 2433, 18078, 1, 0, 0, 0, 2435, 18103, 1, 0, 0, 0, 2437, 18123, 1, 0, 0, 0, 2439, 18130, 1, 0, 0, 0, 2441, 18153, 1, 0, 0, 0, 2443, 18172, 1, 0, 0, 0, 2445, 18202, 1, 0, 0, 0, 2447, 18222, 1, 0, 0, 0, 2449, 18243, 1, 0, 0, 0, 2451, 18254, 1, 0, 0, 0, 2453, 18264, 1, 0, 0, 0, 2455, 18271, 1, 0, 0, 0, 2457, 18276, 1, 0, 0, 0, 2459, 18282, 1, 0, 0, 0, 2461, 18289, 1, 0, 0, 0, 2463, 18297, 1, 0, 0, 0, 2465, 18312, 1, 0, 0, 0, 2467, 18328, 1, 0, 0, 0, 2469, 18344, 1, 0, 0, 0, 2471, 18354, 1, 0, 0, 0, 2473, 18359, 1, 0, 0, 0, 2475, 18370, 1, 0, 0, 0, 2477, 18377, 1, 0, 0, 0, 2479, 18384, 1, 0, 0, 0, 2481, 18390, 1, 0, 0, 0, 2483, 18402, 1, 0, 0, 0, 2485, 18413, 1, 0, 0, 0, 2487, 18421, 1, 0, 0, 0, 2489, 18425, 1, 0, 0, 0, 2491, 18432, 1, 0, 0, 0, 2493, 18435, 1, 0, 0, 0, 2495, 18444, 1, 0, 0, 0, 2497, 18448, 1, 0, 0, 0, 2499, 18453, 1, 0, 0, 0, 2501, 18457, 1, 0, 0, 0, 2503, 18471, 1, 0, 0, 0, 2505, 18475, 1, 0, 0, 0, 2507, 18480, 1, 0, 0, 0, 2509, 18485, 1, 0, 0, 0, 2511, 18489, 1, 0, 0, 0, 2513, 18496, 1, 0, 0, 0, 2515, 18506, 1, 0, 0, 0, 2517, 18511, 1, 0, 0, 0, 2519, 18514, 1, 0, 0, 0, 2521, 18521, 1, 0, 0, 0, 2523, 18538, 1, 0, 0, 0, 2525, 18556, 1, 0, 0, 0, 2527, 18563, 1, 0, 0, 0, 2529, 18568, 1, 0, 0, 0, 2531, 18579, 1, 0, 0, 0, 2533, 18588, 1, 0, 0, 0, 2535, 18601, 1, 0, 0, 0, 2537, 18609, 1, 0, 0, 0, 2539, 18618, 1, 0, 0, 0, 2541, 18644, 1, 0, 0, 0, 2543, 18659, 1, 0, 0, 0, 2545, 18666, 1, 0, 0, 0, 2547, 18677, 1, 0, 0, 0, 2549, 18687, 1, 0, 0, 0, 2551, 18698, 1, 0, 0, 0, 2553, 18712, 1, 0, 0, 0, 2555, 18732, 1, 0, 0, 0, 2557, 18747, 1, 0, 0, 0, 2559, 18755, 1, 0, 0, 0, 2561, 18759, 1, 0, 0, 0, 2563, 18771, 1, 0, 0, 0, 2565, 18785, 1, 0, 0, 0, 2567, 18794, 1, 0, 0, 0, 2569, 18811, 1, 0, 0, 0, 2571, 18827, 1, 0, 0, 0, 2573, 18841, 1, 0, 0, 0, 2575, 18856, 1, 0, 0, 0, 2577, 18875, 1, 0, 0, 0, 2579, 18884, 1, 0, 0, 0, 2581, 18904, 1, 0, 0, 0, 2583, 18922, 1, 0, 0, 0, 2585, 18948, 1, 0, 0, 0, 2587, 18969, 1, 0, 0, 0, 2589, 18984, 1, 0, 0, 0, 2591, 18998, 1, 0, 0, 0, 2593, 19009, 1, 0, 0, 0, 2595, 19024, 1, 0, 0, 0, 2597, 19039, 1, 0, 0, 0, 2599, 19054, 1, 0, 0, 0, 2601, 19069, 1, 0, 0, 0, 2603, 19077, 1, 0, 0, 0, 2605, 19096, 1, 0, 0, 0, 2607, 19102, 1, 0, 0, 0, 2609, 19113, 1, 0, 0, 0, 2611, 19123, 1, 0, 0, 0, 2613, 19136, 1, 0, 0, 0, 2615, 19139, 1, 0, 0, 0, 2617, 19153, 1, 0, 0, 0, 2619, 19161, 1, 0, 0, 0, 2621, 19167, 1, 0, 0, 0, 2623, 19186, 1, 0, 0, 0, 2625, 19206, 1, 0, 0, 0, 2627, 19212, 1, 0, 0, 0, 2629, 19225, 1, 0, 0, 0, 2631, 19233, 1, 0, 0, 0, 2633, 19246, 1, 0, 0, 0, 2635, 19258, 1, 0, 0, 0, 2637, 19262, 1, 0, 0, 0, 2639, 19278, 1, 0, 0, 0, 2641, 19287, 1, 0, 0, 0, 2643, 19296, 1, 0, 0, 0, 2645, 19301, 1, 0, 0, 0, 2647, 19310, 1, 0, 0, 0, 2649, 19321, 1, 0, 0, 0, 2651, 19327, 1, 0, 0, 0, 2653, 19337, 1, 0, 0, 0, 2655, 19341, 1, 0, 0, 0, 2657, 19343, 1, 0, 0, 0, 2659, 19351, 1, 0, 0, 0, 2661, 19360, 1, 0, 0, 0, 2663, 19376, 1, 0, 0, 0, 2665, 19391, 1, 0, 0, 0, 2667, 19400, 1, 0, 0, 0, 2669, 19414, 1, 0, 0, 0, 2671, 19425, 1, 0, 0, 0, 2673, 19431, 1, 0, 0, 0, 2675, 19438, 1, 0, 0, 0, 2677, 19456, 1, 0, 0, 0, 2679, 19475, 1, 0, 0, 0, 2681, 19482, 1, 0, 0, 0, 2683, 19490, 1, 0, 0, 0, 2685, 19503, 1, 0, 0, 0, 2687, 19513, 1, 0, 0, 0, 2689, 19521, 1, 0, 0, 0, 2691, 19545, 1, 0, 0, 0, 2693, 19560, 1, 0, 0, 0, 2695, 19575, 1, 0, 0, 0, 2697, 19585, 1, 0, 0, 0, 2699, 19601, 1, 0, 0, 0, 2701, 19612, 1, 0, 0, 0, 2703, 19626, 1, 0, 0, 0, 2705, 19634, 1, 0, 0, 0, 2707, 19654, 1, 0, 0, 0, 2709, 19673, 1, 0, 0, 0, 2711, 19692, 1, 0, 0, 0, 2713, 19701, 1, 0, 0, 0, 2715, 19720, 1, 0, 0, 0, 2717, 19740, 1, 0, 0, 0, 2719, 19763, 1, 0, 0, 0, 2721, 19788, 1, 0, 0, 0, 2723, 19793, 1, 0, 0, 0, 2725, 19799, 1, 0, 0, 0, 2727, 19804, 1, 0, 0, 0, 2729, 19816, 1, 0, 0, 0, 2731, 19822, 1, 0, 0, 0, 2733, 19830, 1, 0, 0, 0, 2735, 19843, 1, 0, 0, 0, 2737, 19854, 1, 0, 0, 0, 2739, 19862, 1, 0, 0, 0, 2741, 19874, 1, 0, 0, 0, 2743, 19887, 1, 0, 0, 0, 2745, 19895, 1, 0, 0, 0, 2747, 19906, 1, 0, 0, 0, 2749, 19914, 1, 0, 0, 0, 2751, 19927, 1, 0, 0, 0, 2753, 19941, 1, 0, 0, 0, 2755, 19957, 1, 0, 0, 0, 2757, 19965, 1, 0, 0, 0, 2759, 19979, 1, 0, 0, 0, 2761, 19995, 1, 0, 0, 0, 2763, 20010, 1, 0, 0, 0, 2765, 20022, 1, 0, 0, 0, 2767, 20045, 1, 0, 0, 0, 2769, 20066, 1, 0, 0, 0, 2771, 20078, 1, 0, 0, 0, 2773, 20085, 1, 0, 0, 0, 2775, 20095, 1, 0, 0, 0, 2777, 20106, 1, 0, 0, 0, 2779, 20114, 1, 0, 0, 0, 2781, 20118, 1, 0, 0, 0, 2783, 20124, 1, 0, 0, 0, 2785, 20133, 1, 0, 0, 0, 2787, 20139, 1, 0, 0, 0, 2789, 20149, 1, 0, 0, 0, 2791, 20154, 1, 0, 0, 0, 2793, 20161, 1, 0, 0, 0, 2795, 20167, 1, 0, 0, 0, 2797, 20175, 1, 0, 0, 0, 2799, 20190, 1, 0, 0, 0, 2801, 20205, 1, 0, 0, 0, 2803, 20210, 1, 0, 0, 0, 2805, 20227, 1, 0, 0, 0, 2807, 20239, 1, 0, 0, 0, 2809, 20253, 1, 0, 0, 0, 2811, 20269, 1, 0, 0, 0, 2813, 20281, 1, 0, 0, 0, 2815, 20302, 1, 0, 0, 0, 2817, 20317, 1, 0, 0, 0, 2819, 20327, 1, 0, 0, 0, 2821, 20332, 1, 0, 0, 0, 2823, 20338, 1, 0, 0, 0, 2825, 20345, 1, 0, 0, 0, 2827, 20354, 1, 0, 0, 0, 2829, 20362, 1, 0, 0, 0, 2831, 20371, 1, 0, 0, 0, 2833, 20379, 1, 0, 0, 0, 2835, 20387, 1, 0, 0, 0, 2837, 20396, 1, 0, 0, 0, 2839, 20406, 1, 0, 0, 0, 2841, 20415, 1, 0, 0, 0, 2843, 20432, 1, 0, 0, 0, 2845, 20461, 1, 0, 0, 0, 2847, 20475, 1, 0, 0, 0, 2849, 20481, 1, 0, 0, 0, 2851, 20501, 1, 0, 0, 0, 2853, 20515, 1, 0, 0, 0, 2855, 20536, 1, 0, 0, 0, 2857, 20546, 1, 0, 0, 0, 2859, 20553, 1, 0, 0, 0, 2861, 20562, 1, 0, 0, 0, 2863, 20575, 1, 0, 0, 0, 2865, 20583, 1, 0, 0, 0, 2867, 20590, 1, 0, 0, 0, 2869, 20599, 1, 0, 0, 0, 2871, 20608, 1, 0, 0, 0, 2873, 20618, 1, 0, 0, 0, 2875, 20628, 1, 0, 0, 0, 2877, 20648, 1, 0, 0, 0, 2879, 20667, 1, 0, 0, 0, 2881, 20675, 1, 0, 0, 0, 2883, 20683, 1, 0, 0, 0, 2885, 20696, 1, 0, 0, 0, 2887, 20707, 1, 0, 0, 0, 2889, 20715, 1, 0, 0, 0, 2891, 20724, 1, 0, 0, 0, 2893, 20737, 1, 0, 0, 0, 2895, 20746, 1, 0, 0, 0, 2897, 20753, 1, 0, 0, 0, 2899, 20762, 1, 0, 0, 0, 2901, 20767, 1, 0, 0, 0, 2903, 20775, 1, 0, 0, 0, 2905, 20791, 1, 0, 0, 0, 2907, 20800, 1, 0, 0, 0, 2909, 20806, 1, 0, 0, 0, 2911, 20814, 1, 0, 0, 0, 2913, 20826, 1, 0, 0, 0, 2915, 20837, 1, 0, 0, 0, 2917, 20847, 1, 0, 0, 0, 2919, 20858, 1, 0, 0, 0, 2921, 20869, 1, 0, 0, 0, 2923, 20879, 1, 0, 0, 0, 2925, 20887, 1, 0, 0, 0, 2927, 20895, 1, 0, 0, 0, 2929, 20903, 1, 0, 0, 0, 2931, 20911, 1, 0, 0, 0, 2933, 20921, 1, 0, 0, 0, 2935, 20930, 1, 0, 0, 0, 2937, 20940, 1, 0, 0, 0, 2939, 20951, 1, 0, 0, 0, 2941, 20960, 1, 0, 0, 0, 2943, 20966, 1, 0, 0, 0, 2945, 20974, 1, 0, 0, 0, 2947, 20981, 1, 0, 0, 0, 2949, 20991, 1, 0, 0, 0, 2951, 20997, 1, 0, 0, 0, 2953, 21007, 1, 0, 0, 0, 2955, 21017, 1, 0, 0, 0, 2957, 21036, 1, 0, 0, 0, 2959, 21047, 1, 0, 0, 0, 2961, 21062, 1, 0, 0, 0, 2963, 21070, 1, 0, 0, 0, 2965, 21079, 1, 0, 0, 0, 2967, 21091, 1, 0, 0, 0, 2969, 21097, 1, 0, 0, 0, 2971, 21108, 1, 0, 0, 0, 2973, 21114, 1, 0, 0, 0, 2975, 21125, 1, 0, 0, 0, 2977, 21133, 1, 0, 0, 0, 2979, 21140, 1, 0, 0, 0, 2981, 21146, 1, 0, 0, 0, 2983, 21157, 1, 0, 0, 0, 2985, 21163, 1, 0, 0, 0, 2987, 21176, 1, 0, 0, 0, 2989, 21183, 1, 0, 0, 0, 2991, 21189, 1, 0, 0, 0, 2993, 21195, 1, 0, 0, 0, 2995, 21203, 1, 0, 0, 0, 2997, 21207, 1, 0, 0, 0, 2999, 21216, 1, 0, 0, 0, 3001, 21226, 1, 0, 0, 0, 3003, 21230, 1, 0, 0, 0, 3005, 21242, 1, 0, 0, 0, 3007, 21249, 1, 0, 0, 0, 3009, 21254, 1, 0, 0, 0, 3011, 21259, 1, 0, 0, 0, 3013, 21265, 1, 0, 0, 0, 3015, 21274, 1, 0, 0, 0, 3017, 21280, 1, 0, 0, 0, 3019, 21285, 1, 0, 0, 0, 3021, 21295, 1, 0, 0, 0, 3023, 21303, 1, 0, 0, 0, 3025, 21310, 1, 0, 0, 0, 3027, 21318, 1, 0, 0, 0, 3029, 21336, 1, 0, 0, 0, 3031, 21348, 1, 0, 0, 0, 3033, 21356, 1, 0, 0, 0, 3035, 21365, 1, 0, 0, 0, 3037, 21376, 1, 0, 0, 0, 3039, 21384, 1, 0, 0, 0, 3041, 21394, 1, 0, 0, 0, 3043, 21403, 1, 0, 0, 0, 3045, 21408, 1, 0, 0, 0, 3047, 21416, 1, 0, 0, 0, 3049, 21427, 1, 0, 0, 0, 3051, 21446, 1, 0, 0, 0, 3053, 21457, 1, 0, 0, 0, 3055, 21467, 1, 0, 0, 0, 3057, 21478, 1, 0, 0, 0, 3059, 21490, 1, 0, 0, 0, 3061, 21494, 1, 0, 0, 0, 3063, 21502, 1, 0, 0, 0, 3065, 21511, 1, 0, 0, 0, 3067, 21524, 1, 0, 0, 0, 3069, 21537, 1, 0, 0, 0, 3071, 21549, 1, 0, 0, 0, 3073, 21564, 1, 0, 0, 0, 3075, 21578, 1, 0, 0, 0, 3077, 21587, 1, 0, 0, 0, 3079, 21597, 1, 0, 0, 0, 3081, 21607, 1, 0, 0, 0, 3083, 21618, 1, 0, 0, 0, 3085, 21633, 1, 0, 0, 0, 3087, 21641, 1, 0, 0, 0, 3089, 21652, 1, 0, 0, 0, 3091, 21661, 1, 0, 0, 0, 3093, 21670, 1, 0, 0, 0, 3095, 21679, 1, 0, 0, 0, 3097, 21687, 1, 0, 0, 0, 3099, 21694, 1, 0, 0, 0, 3101, 21700, 1, 0, 0, 0, 3103, 21711, 1, 0, 0, 0, 3105, 21721, 1, 0, 0, 0, 3107, 21730, 1, 0, 0, 0, 3109, 21735, 1, 0, 0, 0, 3111, 21745, 1, 0, 0, 0, 3113, 21752, 1, 0, 0, 0, 3115, 21766, 1, 0, 0, 0, 3117, 21773, 1, 0, 0, 0, 3119, 21780, 1, 0, 0, 0, 3121, 21787, 1, 0, 0, 0, 3123, 21794, 1, 0, 0, 0, 3125, 21802, 1, 0, 0, 0, 3127, 21814, 1, 0, 0, 0, 3129, 21823, 1, 0, 0, 0, 3131, 21833, 1, 0, 0, 0, 3133, 21839, 1, 0, 0, 0, 3135, 21846, 1, 0, 0, 0, 3137, 21854, 1, 0, 0, 0, 3139, 21863, 1, 0, 0, 0, 3141, 21872, 1, 0, 0, 0, 3143, 21880, 1, 0, 0, 0, 3145, 21888, 1, 0, 0, 0, 3147, 21909, 1, 0, 0, 0, 3149, 21917, 1, 0, 0, 0, 3151, 21939, 1, 0, 0, 0, 3153, 21950, 1, 0, 0, 0, 3155, 21970, 1, 0, 0, 0, 3157, 21979, 1, 0, 0, 0, 3159, 21992, 1, 0, 0, 0, 3161, 21999, 1, 0, 0, 0, 3163, 22009, 1, 0, 0, 0, 3165, 22016, 1, 0, 0, 0, 3167, 22026, 1, 0, 0, 0, 3169, 22046, 1, 0, 0, 0, 3171, 22056, 1, 0, 0, 0, 3173, 22063, 1, 0, 0, 0, 3175, 22069, 1, 0, 0, 0, 3177, 22077, 1, 0, 0, 0, 3179, 22084, 1, 0, 0, 0, 3181, 22101, 1, 0, 0, 0, 3183, 22109, 1, 0, 0, 0, 3185, 22115, 1, 0, 0, 0, 3187, 22120, 1, 0, 0, 0, 3189, 22128, 1, 0, 0, 0, 3191, 22134, 1, 0, 0, 0, 3193, 22143, 1, 0, 0, 0, 3195, 22151, 1, 0, 0, 0, 3197, 22158, 1, 0, 0, 0, 3199, 22174, 1, 0, 0, 0, 3201, 22194, 1, 0, 0, 0, 3203, 22200, 1, 0, 0, 0, 3205, 22212, 1, 0, 0, 0, 3207, 22225, 1, 0, 0, 0, 3209, 22236, 1, 0, 0, 0, 3211, 22243, 1, 0, 0, 0, 3213, 22247, 1, 0, 0, 0, 3215, 22252, 1, 0, 0, 0, 3217, 22257, 1, 0, 0, 0, 3219, 22263, 1, 0, 0, 0, 3221, 22268, 1, 0, 0, 0, 3223, 22274, 1, 0, 0, 0, 3225, 22282, 1, 0, 0, 0, 3227, 22287, 1, 0, 0, 0, 3229, 22294, 1, 0, 0, 0, 3231, 22312, 1, 0, 0, 0, 3233, 22322, 1, 0, 0, 0, 3235, 22327, 1, 0, 0, 0, 3237, 22331, 1, 0, 0, 0, 3239, 22342, 1, 0, 0, 0, 3241, 22348, 1, 0, 0, 0, 3243, 22363, 1, 0, 0, 0, 3245, 22368, 1, 0, 0, 0, 3247, 22378, 1, 0, 0, 0, 3249, 22390, 1, 0, 0, 0, 3251, 22397, 1, 0, 0, 0, 3253, 22411, 1, 0, 0, 0, 3255, 22415, 1, 0, 0, 0, 3257, 22421, 1, 0, 0, 0, 3259, 22427, 1, 0, 0, 0, 3261, 22434, 1, 0, 0, 0, 3263, 22445, 1, 0, 0, 0, 3265, 22458, 1, 0, 0, 0, 3267, 22471, 1, 0, 0, 0, 3269, 22479, 1, 0, 0, 0, 3271, 22486, 1, 0, 0, 0, 3273, 22493, 1, 0, 0, 0, 3275, 22501, 1, 0, 0, 0, 3277, 22508, 1, 0, 0, 0, 3279, 22523, 1, 0, 0, 0, 3281, 22534, 1, 0, 0, 0, 3283, 22543, 1, 0, 0, 0, 3285, 22548, 1, 0, 0, 0, 3287, 22558, 1, 0, 0, 0, 3289, 22567, 1, 0, 0, 0, 3291, 22575, 1, 0, 0, 0, 3293, 22587, 1, 0, 0, 0, 3295, 22594, 1, 0, 0, 0, 3297, 22599, 1, 0, 0, 0, 3299, 22615, 1, 0, 0, 0, 3301, 22624, 1, 0, 0, 0, 3303, 22638, 1, 0, 0, 0, 3305, 22648, 1, 0, 0, 0, 3307, 22657, 1, 0, 0, 0, 3309, 22670, 1, 0, 0, 0, 3311, 22681, 1, 0, 0, 0, 3313, 22685, 1, 0, 0, 0, 3315, 22691, 1, 0, 0, 0, 3317, 22707, 1, 0, 0, 0, 3319, 22720, 1, 0, 0, 0, 3321, 22738, 1, 0, 0, 0, 3323, 22745, 1, 0, 0, 0, 3325, 22757, 1, 0, 0, 0, 3327, 22778, 1, 0, 0, 0, 3329, 22786, 1, 0, 0, 0, 3331, 22795, 1, 0, 0, 0, 3333, 22818, 1, 0, 0, 0, 3335, 22826, 1, 0, 0, 0, 3337, 22844, 1, 0, 0, 0, 3339, 22860, 1, 0, 0, 0, 3341, 22874, 1, 0, 0, 0, 3343, 22878, 1, 0, 0, 0, 3345, 22883, 1, 0, 0, 0, 3347, 22892, 1, 0, 0, 0, 3349, 22904, 1, 0, 0, 0, 3351, 22911, 1, 0, 0, 0, 3353, 22917, 1, 0, 0, 0, 3355, 22928, 1, 0, 0, 0, 3357, 22940, 1, 0, 0, 0, 3359, 22947, 1, 0, 0, 0, 3361, 22953, 1, 0, 0, 0, 3363, 22961, 1, 0, 0, 0, 3365, 22971, 1, 0, 0, 0, 3367, 22976, 1, 0, 0, 0, 3369, 22983, 1, 0, 0, 0, 3371, 22992, 1, 0, 0, 0, 3373, 23001, 1, 0, 0, 0, 3375, 23005, 1, 0, 0, 0, 3377, 23010, 1, 0, 0, 0, 3379, 23027, 1, 0, 0, 0, 3381, 23043, 1, 0, 0, 0, 3383, 23048, 1, 0, 0, 0, 3385, 23057, 1, 0, 0, 0, 3387, 23072, 1, 0, 0, 0, 3389, 23079, 1, 0, 0, 0, 3391, 23086, 1, 0, 0, 0, 3393, 23097, 1, 0, 0, 0, 3395, 23102, 1, 0, 0, 0, 3397, 23106, 1, 0, 0, 0, 3399, 23111, 1, 0, 0, 0, 3401, 23117, 1, 0, 0, 0, 3403, 23136, 1, 0, 0, 0, 3405, 23141, 1, 0, 0, 0, 3407, 23163, 1, 0, 0, 0, 3409, 23185, 1, 0, 0, 0, 3411, 23195, 1, 0, 0, 0, 3413, 23204, 1, 0, 0, 0, 3415, 23213, 1, 0, 0, 0, 3417, 23218, 1, 0, 0, 0, 3419, 23223, 1, 0, 0, 0, 3421, 23231, 1, 0, 0, 0, 3423, 23253, 1, 0, 0, 0, 3425, 23278, 1, 0, 0, 0, 3427, 23285, 1, 0, 0, 0, 3429, 23291, 1, 0, 0, 0, 3431, 23305, 1, 0, 0, 0, 3433, 23312, 1, 0, 0, 0, 3435, 23318, 1, 0, 0, 0, 3437, 23330, 1, 0, 0, 0, 3439, 23338, 1, 0, 0, 0, 3441, 23347, 1, 0, 0, 0, 3443, 23354, 1, 0, 0, 0, 3445, 23375, 1, 0, 0, 0, 3447, 23377, 1, 0, 0, 0, 3449, 23387, 1, 0, 0, 0, 3451, 23397, 1, 0, 0, 0, 3453, 23421, 1, 0, 0, 0, 3455, 23426, 1, 0, 0, 0, 3457, 23432, 1, 0, 0, 0, 3459, 23443, 1, 0, 0, 0, 3461, 23452, 1, 0, 0, 0, 3463, 23466, 1, 0, 0, 0, 3465, 23489, 1, 0, 0, 0, 3467, 23498, 1, 0, 0, 0, 3469, 23506, 1, 0, 0, 0, 3471, 23511, 1, 0, 0, 0, 3473, 23531, 1, 0, 0, 0, 3475, 23537, 1, 0, 0, 0, 3477, 23545, 1, 0, 0, 0, 3479, 23553, 1, 0, 0, 0, 3481, 23566, 1, 0, 0, 0, 3483, 23584, 1, 0, 0, 0, 3485, 23595, 1, 0, 0, 0, 3487, 23605, 1, 0, 0, 0, 3489, 23611, 1, 0, 0, 0, 3491, 23618, 1, 0, 0, 0, 3493, 23629, 1, 0, 0, 0, 3495, 23649, 1, 0, 0, 0, 3497, 23664, 1, 0, 0, 0, 3499, 23677, 1, 0, 0, 0, 3501, 23691, 1, 0, 0, 0, 3503, 23702, 1, 0, 0, 0, 3505, 23716, 1, 0, 0, 0, 3507, 23736, 1, 0, 0, 0, 3509, 23755, 1, 0, 0, 0, 3511, 23775, 1, 0, 0, 0, 3513, 23792, 1, 0, 0, 0, 3515, 23812, 1, 0, 0, 0, 3517, 23827, 1, 0, 0, 0, 3519, 23838, 1, 0, 0, 0, 3521, 23850, 1, 0, 0, 0, 3523, 23855, 1, 0, 0, 0, 3525, 23863, 1, 0, 0, 0, 3527, 23869, 1, 0, 0, 0, 3529, 23877, 1, 0, 0, 0, 3531, 23884, 1, 0, 0, 0, 3533, 23891, 1, 0, 0, 0, 3535, 23898, 1, 0, 0, 0, 3537, 23913, 1, 0, 0, 0, 3539, 23926, 1, 0, 0, 0, 3541, 23932, 1, 0, 0, 0, 3543, 23942, 1, 0, 0, 0, 3545, 23954, 1, 0, 0, 0, 3547, 23971, 1, 0, 0, 0, 3549, 23985, 1, 0, 0, 0, 3551, 23998, 1, 0, 0, 0, 3553, 24009, 1, 0, 0, 0, 3555, 24026, 1, 0, 0, 0, 3557, 24036, 1, 0, 0, 0, 3559, 24043, 1, 0, 0, 0, 3561, 24057, 1, 0, 0, 0, 3563, 24065, 1, 0, 0, 0, 3565, 24073, 1, 0, 0, 0, 3567, 24081, 1, 0, 0, 0, 3569, 24089, 1, 0, 0, 0, 3571, 24097, 1, 0, 0, 0, 3573, 24108, 1, 0, 0, 0, 3575, 24116, 1, 0, 0, 0, 3577, 24124, 1, 0, 0, 0, 3579, 24137, 1, 0, 0, 0, 3581, 24145, 1, 0, 0, 0, 3583, 24162, 1, 0, 0, 0, 3585, 24173, 1, 0, 0, 0, 3587, 24180, 1, 0, 0, 0, 3589, 24192, 1, 0, 0, 0, 3591, 24197, 1, 0, 0, 0, 3593, 24205, 1, 0, 0, 0, 3595, 24209, 1, 0, 0, 0, 3597, 24216, 1, 0, 0, 0, 3599, 24226, 1, 0, 0, 0, 3601, 24233, 1, 0, 0, 0, 3603, 24243, 1, 0, 0, 0, 3605, 24256, 1, 0, 0, 0, 3607, 24276, 1, 0, 0, 0, 3609, 24296, 1, 0, 0, 0, 3611, 24308, 1, 0, 0, 0, 3613, 24316, 1, 0, 0, 0, 3615, 24323, 1, 0, 0, 0, 3617, 24336, 1, 0, 0, 0, 3619, 24342, 1, 0, 0, 0, 3621, 24356, 1, 0, 0, 0, 3623, 24374, 1, 0, 0, 0, 3625, 24392, 1, 0, 0, 0, 3627, 24408, 1, 0, 0, 0, 3629, 24425, 1, 0, 0, 0, 3631, 24442, 1, 0, 0, 0, 3633, 24462, 1, 0, 0, 0, 3635, 24483, 1, 0, 0, 0, 3637, 24504, 1, 0, 0, 0, 3639, 24524, 1, 0, 0, 0, 3641, 24537, 1, 0, 0, 0, 3643, 24553, 1, 0, 0, 0, 3645, 24568, 1, 0, 0, 0, 3647, 24584, 1, 0, 0, 0, 3649, 24598, 1, 0, 0, 0, 3651, 24612, 1, 0, 0, 0, 3653, 24627, 1, 0, 0, 0, 3655, 24646, 1, 0, 0, 0, 3657, 24665, 1, 0, 0, 0, 3659, 24680, 1, 0, 0, 0, 3661, 24694, 1, 0, 0, 0, 3663, 24703, 1, 0, 0, 0, 3665, 24711, 1, 0, 0, 0, 3667, 24717, 1, 0, 0, 0, 3669, 24736, 1, 0, 0, 0, 3671, 24748, 1, 0, 0, 0, 3673, 24762, 1, 0, 0, 0, 3675, 24772, 1, 0, 0, 0, 3677, 24779, 1, 0, 0, 0, 3679, 24794, 1, 0, 0, 0, 3681, 24809, 1, 0, 0, 0, 3683, 24825, 1, 0, 0, 0, 3685, 24836, 1, 0, 0, 0, 3687, 24851, 1, 0, 0, 0, 3689, 24865, 1, 0, 0, 0, 3691, 24877, 1, 0, 0, 0, 3693, 24902, 1, 0, 0, 0, 3695, 24922, 1, 0, 0, 0, 3697, 24933, 1, 0, 0, 0, 3699, 24945, 1, 0, 0, 0, 3701, 24956, 1, 0, 0, 0, 3703, 24968, 1, 0, 0, 0, 3705, 24989, 1, 0, 0, 0, 3707, 25001, 1, 0, 0, 0, 3709, 25016, 1, 0, 0, 0, 3711, 25032, 1, 0, 0, 0, 3713, 25046, 1, 0, 0, 0, 3715, 25064, 1, 0, 0, 0, 3717, 25075, 1, 0, 0, 0, 3719, 25092, 1, 0, 0, 0, 3721, 25110, 1, 0, 0, 0, 3723, 25124, 1, 0, 0, 0, 3725, 25139, 1, 0, 0, 0, 3727, 25155, 1, 0, 0, 0, 3729, 25166, 1, 0, 0, 0, 3731, 25178, 1, 0, 0, 0, 3733, 25194, 1, 0, 0, 0, 3735, 25219, 1, 0, 0, 0, 3737, 25227, 1, 0, 0, 0, 3739, 25242, 1, 0, 0, 0, 3741, 25258, 1, 0, 0, 0, 3743, 25270, 1, 0, 0, 0, 3745, 25282, 1, 0, 0, 0, 3747, 25293, 1, 0, 0, 0, 3749, 25304, 1, 0, 0, 0, 3751, 25329, 1, 0, 0, 0, 3753, 25359, 1, 0, 0, 0, 3755, 25384, 1, 0, 0, 0, 3757, 25412, 1, 0, 0, 0, 3759, 25434, 1, 0, 0, 0, 3761, 25446, 1, 0, 0, 0, 3763, 25465, 1, 0, 0, 0, 3765, 25484, 1, 0, 0, 0, 3767, 25501, 1, 0, 0, 0, 3769, 25521, 1, 0, 0, 0, 3771, 25539, 1, 0, 0, 0, 3773, 25551, 1, 0, 0, 0, 3775, 25562, 1, 0, 0, 0, 3777, 25577, 1, 0, 0, 0, 3779, 25596, 1, 0, 0, 0, 3781, 25607, 1, 0, 0, 0, 3783, 25624, 1, 0, 0, 0, 3785, 25641, 1, 0, 0, 0, 3787, 25652, 1, 0, 0, 0, 3789, 25663, 1, 0, 0, 0, 3791, 25679, 1, 0, 0, 0, 3793, 25694, 1, 0, 0, 0, 3795, 25710, 1, 0, 0, 0, 3797, 25726, 1, 0, 0, 0, 3799, 25741, 1, 0, 0, 0, 3801, 25754, 1, 0, 0, 0, 3803, 25770, 1, 0, 0, 0, 3805, 25784, 1, 0, 0, 0, 3807, 25795, 1, 0, 0, 0, 3809, 25810, 1, 0, 0, 0, 3811, 25823, 1, 0, 0, 0, 3813, 25834, 1, 0, 0, 0, 3815, 25850, 1, 0, 0, 0, 3817, 25862, 1, 0, 0, 0, 3819, 25873, 1, 0, 0, 0, 3821, 25885, 1, 0, 0, 0, 3823, 25903, 1, 0, 0, 0, 3825, 25914, 1, 0, 0, 0, 3827, 25930, 1, 0, 0, 0, 3829, 25945, 1, 0, 0, 0, 3831, 25956, 1, 0, 0, 0, 3833, 25968, 1, 0, 0, 0, 3835, 25981, 1, 0, 0, 0, 3837, 25999, 1, 0, 0, 0, 3839, 26016, 1, 0, 0, 0, 3841, 26030, 1, 0, 0, 0, 3843, 26044, 1, 0, 0, 0, 3845, 26057, 1, 0, 0, 0, 3847, 26071, 1, 0, 0, 0, 3849, 26086, 1, 0, 0, 0, 3851, 26098, 1, 0, 0, 0, 3853, 26109, 1, 0, 0, 0, 3855, 26132, 1, 0, 0, 0, 3857, 26147, 1, 0, 0, 0, 3859, 26162, 1, 0, 0, 0, 3861, 26176, 1, 0, 0, 0, 3863, 26193, 1, 0, 0, 0, 3865, 26208, 1, 0, 0, 0, 3867, 26227, 1, 0, 0, 0, 3869, 26249, 1, 0, 0, 0, 3871, 26269, 1, 0, 0, 0, 3873, 26286, 1, 0, 0, 0, 3875, 26305, 1, 0, 0, 0, 3877, 26325, 1, 0, 0, 0, 3879, 26345, 1, 0, 0, 0, 3881, 26366, 1, 0, 0, 0, 3883, 26383, 1, 0, 0, 0, 3885, 26398, 1, 0, 0, 0, 3887, 26414, 1, 0, 0, 0, 3889, 26428, 1, 0, 0, 0, 3891, 26442, 1, 0, 0, 0, 3893, 26456, 1, 0, 0, 0, 3895, 26471, 1, 0, 0, 0, 3897, 26486, 1, 0, 0, 0, 3899, 26493, 1, 0, 0, 0, 3901, 26506, 1, 0, 0, 0, 3903, 26517, 1, 0, 0, 0, 3905, 26530, 1, 0, 0, 0, 3907, 26545, 1, 0, 0, 0, 3909, 26561, 1, 0, 0, 0, 3911, 26573, 1, 0, 0, 0, 3913, 26588, 1, 0, 0, 0, 3915, 26599, 1, 0, 0, 0, 3917, 26619, 1, 0, 0, 0, 3919, 26639, 1, 0, 0, 0, 3921, 26652, 1, 0, 0, 0, 3923, 26675, 1, 0, 0, 0, 3925, 26696, 1, 0, 0, 0, 3927, 26721, 1, 0, 0, 0, 3929, 26743, 1, 0, 0, 0, 3931, 26767, 1, 0, 0, 0, 3933, 26790, 1, 0, 0, 0, 3935, 26811, 1, 0, 0, 0, 3937, 26833, 1, 0, 0, 0, 3939, 26854, 1, 0, 0, 0, 3941, 26868, 1, 0, 0, 0, 3943, 26882, 1, 0, 0, 0, 3945, 26899, 1, 0, 0, 0, 3947, 26915, 1, 0, 0, 0, 3949, 26930, 1, 0, 0, 0, 3951, 26948, 1, 0, 0, 0, 3953, 26962, 1, 0, 0, 0, 3955, 26981, 1, 0, 0, 0, 3957, 26997, 1, 0, 0, 0, 3959, 27011, 1, 0, 0, 0, 3961, 27025, 1, 0, 0, 0, 3963, 27038, 1, 0, 0, 0, 3965, 27051, 1, 0, 0, 0, 3967, 27070, 1, 0, 0, 0, 3969, 27080, 1, 0, 0, 0, 3971, 27093, 1, 0, 0, 0, 3973, 27106, 1, 0, 0, 0, 3975, 27119, 1, 0, 0, 0, 3977, 27134, 1, 0, 0, 0, 3979, 27145, 1, 0, 0, 0, 3981, 27155, 1, 0, 0, 0, 3983, 27171, 1, 0, 0, 0, 3985, 27186, 1, 0, 0, 0, 3987, 27200, 1, 0, 0, 0, 3989, 27214, 1, 0, 0, 0, 3991, 27228, 1, 0, 0, 0, 3993, 27240, 1, 0, 0, 0, 3995, 27253, 1, 0, 0, 0, 3997, 27266, 1, 0, 0, 0, 3999, 27278, 1, 0, 0, 0, 4001, 27292, 1, 0, 0, 0, 4003, 27306, 1, 0, 0, 0, 4005, 27317, 1, 0, 0, 0, 4007, 27331, 1, 0, 0, 0, 4009, 27349, 1, 0, 0, 0, 4011, 27361, 1, 0, 0, 0, 4013, 27374, 1, 0, 0, 0, 4015, 27390, 1, 0, 0, 0, 4017, 27406, 1, 0, 0, 0, 4019, 27418, 1, 0, 0, 0, 4021, 27435, 1, 0, 0, 0, 4023, 27448, 1, 0, 0, 0, 4025, 27461, 1, 0, 0, 0, 4027, 27474, 1, 0, 0, 0, 4029, 27488, 1, 0, 0, 0, 4031, 27499, 1, 0, 0, 0, 4033, 27516, 1, 0, 0, 0, 4035, 27532, 1, 0, 0, 0, 4037, 27545, 1, 0, 0, 0, 4039, 27560, 1, 0, 0, 0, 4041, 27576, 1, 0, 0, 0, 4043, 27592, 1, 0, 0, 0, 4045, 27604, 1, 0, 0, 0, 4047, 27618, 1, 0, 0, 0, 4049, 27634, 1, 0, 0, 0, 4051, 27650, 1, 0, 0, 0, 4053, 27667, 1, 0, 0, 0, 4055, 27681, 1, 0, 0, 0, 4057, 27695, 1, 0, 0, 0, 4059, 27709, 1, 0, 0, 0, 4061, 27725, 1, 0, 0, 0, 4063, 27739, 1, 0, 0, 0, 4065, 27753, 1, 0, 0, 0, 4067, 27767, 1, 0, 0, 0, 4069, 27781, 1, 0, 0, 0, 4071, 27795, 1, 0, 0, 0, 4073, 27809, 1, 0, 0, 0, 4075, 27824, 1, 0, 0, 0, 4077, 27838, 1, 0, 0, 0, 4079, 27853, 1, 0, 0, 0, 4081, 27868, 1, 0, 0, 0, 4083, 27882, 1, 0, 0, 0, 4085, 27896, 1, 0, 0, 0, 4087, 27910, 1, 0, 0, 0, 4089, 27924, 1, 0, 0, 0, 4091, 27938, 1, 0, 0, 0, 4093, 27952, 1, 0, 0, 0, 4095, 27966, 1, 0, 0, 0, 4097, 27979, 1, 0, 0, 0, 4099, 27993, 1, 0, 0, 0, 4101, 28007, 1, 0, 0, 0, 4103, 28025, 1, 0, 0, 0, 4105, 28039, 1, 0, 0, 0, 4107, 28055, 1, 0, 0, 0, 4109, 28070, 1, 0, 0, 0, 4111, 28082, 1, 0, 0, 0, 4113, 28099, 1, 0, 0, 0, 4115, 28113, 1, 0, 0, 0, 4117, 28129, 1, 0, 0, 0, 4119, 28143, 1, 0, 0, 0, 4121, 28155, 1, 0, 0, 0, 4123, 28168, 1, 0, 0, 0, 4125, 28181, 1, 0, 0, 0, 4127, 28199, 1, 0, 0, 0, 4129, 28216, 1, 0, 0, 0, 4131, 28231, 1, 0, 0, 0, 4133, 28247, 1, 0, 0, 0, 4135, 28261, 1, 0, 0, 0, 4137, 28277, 1, 0, 0, 0, 4139, 28293, 1, 0, 0, 0, 4141, 28308, 1, 0, 0, 0, 4143, 28322, 1, 0, 0, 0, 4145, 28340, 1, 0, 0, 0, 4147, 28352, 1, 0, 0, 0, 4149, 28368, 1, 0, 0, 0, 4151, 28384, 1, 0, 0, 0, 4153, 28401, 1, 0, 0, 0, 4155, 28403, 1, 0, 0, 0, 4157, 28422, 1, 0, 0, 0, 4159, 28436, 1, 0, 0, 0, 4161, 28447, 1, 0, 0, 0, 4163, 28454, 1, 0, 0, 0, 4165, 28466, 1, 0, 0, 0, 4167, 28472, 1, 0, 0, 0, 4169, 28478, 1, 0, 0, 0, 4171, 28482, 1, 0, 0, 0, 4173, 28487, 1, 0, 0, 0, 4175, 28491, 1, 0, 0, 0, 4177, 28511, 1, 0, 0, 0, 4179, 28520, 1, 0, 0, 0, 4181, 28529, 1, 0, 0, 0, 4183, 28544, 1, 0, 0, 0, 4185, 28554, 1, 0, 0, 0, 4187, 28565, 1, 0, 0, 0, 4189, 28576, 1, 0, 0, 0, 4191, 28581, 1, 0, 0, 0, 4193, 28586, 1, 0, 0, 0, 4195, 28595, 1, 0, 0, 0, 4197, 28600, 1, 0, 0, 0, 4199, 28605, 1, 0, 0, 0, 4201, 28609, 1, 0, 0, 0, 4203, 28615, 1, 0, 0, 0, 4205, 28622, 1, 0, 0, 0, 4207, 28630, 1, 0, 0, 0, 4209, 28635, 1, 0, 0, 0, 4211, 28640, 1, 0, 0, 0, 4213, 28648, 1, 0, 0, 0, 4215, 28676, 1, 0, 0, 0, 4217, 28686, 1, 0, 0, 0, 4219, 28713, 1, 0, 0, 0, 4221, 28737, 1, 0, 0, 0, 4223, 28743, 1, 0, 0, 0, 4225, 28748, 1, 0, 0, 0, 4227, 28757, 1, 0, 0, 0, 4229, 28771, 1, 0, 0, 0, 4231, 28785, 1, 0, 0, 0, 4233, 28801, 1, 0, 0, 0, 4235, 28817, 1, 0, 0, 0, 4237, 28833, 1, 0, 0, 0, 4239, 28843, 1, 0, 0, 0, 4241, 28850, 1, 0, 0, 0, 4243, 28858, 1, 0, 0, 0, 4245, 28865, 1, 0, 0, 0, 4247, 28873, 1, 0, 0, 0, 4249, 28882, 1, 0, 0, 0, 4251, 28899, 1, 0, 0, 0, 4253, 28915, 1, 0, 0, 0, 4255, 28923, 1, 0, 0, 0, 4257, 28931, 1, 0, 0, 0, 4259, 28945, 1, 0, 0, 0, 4261, 28952, 1, 0, 0, 0, 4263, 28966, 1, 0, 0, 0, 4265, 28975, 1, 0, 0, 0, 4267, 28984, 1, 0, 0, 0, 4269, 28994, 1, 0, 0, 0, 4271, 29003, 1, 0, 0, 0, 4273, 29018, 1, 0, 0, 0, 4275, 29031, 1, 0, 0, 0, 4277, 29047, 1, 0, 0, 0, 4279, 29055, 1, 0, 0, 0, 4281, 29066, 1, 0, 0, 0, 4283, 29069, 1, 0, 0, 0, 4285, 29083, 1, 0, 0, 0, 4287, 29089, 1, 0, 0, 0, 4289, 29097, 1, 0, 0, 0, 4291, 29106, 1, 0, 0, 0, 4293, 29115, 1, 0, 0, 0, 4295, 29127, 1, 0, 0, 0, 4297, 29137, 1, 0, 0, 0, 4299, 29148, 1, 0, 0, 0, 4301, 29171, 1, 0, 0, 0, 4303, 29184, 1, 0, 0, 0, 4305, 29195, 1, 0, 0, 0, 4307, 29205, 1, 0, 0, 0, 4309, 29217, 1, 0, 0, 0, 4311, 29223, 1, 0, 0, 0, 4313, 29232, 1, 0, 0, 0, 4315, 29240, 1, 0, 0, 0, 4317, 29245, 1, 0, 0, 0, 4319, 29254, 1, 0, 0, 0, 4321, 29260, 1, 0, 0, 0, 4323, 29268, 1, 0, 0, 0, 4325, 29274, 1, 0, 0, 0, 4327, 29281, 1, 0, 0, 0, 4329, 29284, 1, 0, 0, 0, 4331, 29290, 1, 0, 0, 0, 4333, 29295, 1, 0, 0, 0, 4335, 29305, 1, 0, 0, 0, 4337, 29309, 1, 0, 0, 0, 4339, 29313, 1, 0, 0, 0, 4341, 29318, 1, 0, 0, 0, 4343, 29322, 1, 0, 0, 0, 4345, 29326, 1, 0, 0, 0, 4347, 29337, 1, 0, 0, 0, 4349, 29347, 1, 0, 0, 0, 4351, 29355, 1, 0, 0, 0, 4353, 29369, 1, 0, 0, 0, 4355, 29375, 1, 0, 0, 0, 4357, 29380, 1, 0, 0, 0, 4359, 29387, 1, 0, 0, 0, 4361, 29395, 1, 0, 0, 0, 4363, 29401, 1, 0, 0, 0, 4365, 29411, 1, 0, 0, 0, 4367, 29418, 1, 0, 0, 0, 4369, 29425, 1, 0, 0, 0, 4371, 29435, 1, 0, 0, 0, 4373, 29442, 1, 0, 0, 0, 4375, 29449, 1, 0, 0, 0, 4377, 29459, 1, 0, 0, 0, 4379, 29487, 1, 0, 0, 0, 4381, 29517, 1, 0, 0, 0, 4383, 29535, 1, 0, 0, 0, 4385, 29542, 1, 0, 0, 0, 4387, 29551, 1, 0, 0, 0, 4389, 29559, 1, 0, 0, 0, 4391, 29566, 1, 0, 0, 0, 4393, 29578, 1, 0, 0, 0, 4395, 29588, 1, 0, 0, 0, 4397, 29602, 1, 0, 0, 0, 4399, 29615, 1, 0, 0, 0, 4401, 29624, 1, 0, 0, 0, 4403, 29636, 1, 0, 0, 0, 4405, 29642, 1, 0, 0, 0, 4407, 29651, 1, 0, 0, 0, 4409, 29658, 1, 0, 0, 0, 4411, 29668, 1, 0, 0, 0, 4413, 29676, 1, 0, 0, 0, 4415, 29683, 1, 0, 0, 0, 4417, 29693, 1, 0, 0, 0, 4419, 29705, 1, 0, 0, 0, 4421, 29719, 1, 0, 0, 0, 4423, 29727, 1, 0, 0, 0, 4425, 29733, 1, 0, 0, 0, 4427, 29740, 1, 0, 0, 0, 4429, 29747, 1, 0, 0, 0, 4431, 29754, 1, 0, 0, 0, 4433, 29760, 1, 0, 0, 0, 4435, 29769, 1, 0, 0, 0, 4437, 29780, 1, 0, 0, 0, 4439, 29789, 1, 0, 0, 0, 4441, 29810, 1, 0, 0, 0, 4443, 29836, 1, 0, 0, 0, 4445, 29845, 1, 0, 0, 0, 4447, 29867, 1, 0, 0, 0, 4449, 29889, 1, 0, 0, 0, 4451, 29909, 1, 0, 0, 0, 4453, 29919, 1, 0, 0, 0, 4455, 29926, 1, 0, 0, 0, 4457, 29944, 1, 0, 0, 0, 4459, 29965, 1, 0, 0, 0, 4461, 29975, 1, 0, 0, 0, 4463, 29988, 1, 0, 0, 0, 4465, 29996, 1, 0, 0, 0, 4467, 30006, 1, 0, 0, 0, 4469, 30022, 1, 0, 0, 0, 4471, 30028, 1, 0, 0, 0, 4473, 30045, 1, 0, 0, 0, 4475, 30050, 1, 0, 0, 0, 4477, 30059, 1, 0, 0, 0, 4479, 30079, 1, 0, 0, 0, 4481, 30097, 1, 0, 0, 0, 4483, 30101, 1, 0, 0, 0, 4485, 30124, 1, 0, 0, 0, 4487, 30143, 1, 0, 0, 0, 4489, 30159, 1, 0, 0, 0, 4491, 30174, 1, 0, 0, 0, 4493, 30180, 1, 0, 0, 0, 4495, 30188, 1, 0, 0, 0, 4497, 30196, 1, 0, 0, 0, 4499, 30202, 1, 0, 0, 0, 4501, 30207, 1, 0, 0, 0, 4503, 30210, 1, 0, 0, 0, 4505, 30213, 1, 0, 0, 0, 4507, 30222, 1, 0, 0, 0, 4509, 30242, 1, 0, 0, 0, 4511, 30253, 1, 0, 0, 0, 4513, 30268, 1, 0, 0, 0, 4515, 30275, 1, 0, 0, 0, 4517, 30281, 1, 0, 0, 0, 4519, 30290, 1, 0, 0, 0, 4521, 30298, 1, 0, 0, 0, 4523, 30307, 1, 0, 0, 0, 4525, 30316, 1, 0, 0, 0, 4527, 30323, 1, 0, 0, 0, 4529, 30331, 1, 0, 0, 0, 4531, 30339, 1, 0, 0, 0, 4533, 30347, 1, 0, 0, 0, 4535, 30354, 1, 0, 0, 0, 4537, 30363, 1, 0, 0, 0, 4539, 30371, 1, 0, 0, 0, 4541, 30389, 1, 0, 0, 0, 4543, 30401, 1, 0, 0, 0, 4545, 30423, 1, 0, 0, 0, 4547, 30445, 1, 0, 0, 0, 4549, 30462, 1, 0, 0, 0, 4551, 30471, 1, 0, 0, 0, 4553, 30478, 1, 0, 0, 0, 4555, 30489, 1, 0, 0, 0, 4557, 30505, 1, 0, 0, 0, 4559, 30522, 1, 0, 0, 0, 4561, 30541, 1, 0, 0, 0, 4563, 30559, 1, 0, 0, 0, 4565, 30578, 1, 0, 0, 0, 4567, 30587, 1, 0, 0, 0, 4569, 30600, 1, 0, 0, 0, 4571, 30608, 1, 0, 0, 0, 4573, 30613, 1, 0, 0, 0, 4575, 30623, 1, 0, 0, 0, 4577, 30631, 1, 0, 0, 0, 4579, 30642, 1, 0, 0, 0, 4581, 30650, 1, 0, 0, 0, 4583, 30657, 1, 0, 0, 0, 4585, 30663, 1, 0, 0, 0, 4587, 30668, 1, 0, 0, 0, 4589, 30675, 1, 0, 0, 0, 4591, 30683, 1, 0, 0, 0, 4593, 30689, 1, 0, 0, 0, 4595, 30694, 1, 0, 0, 0, 4597, 30705, 1, 0, 0, 0, 4599, 30714, 1, 0, 0, 0, 4601, 30719, 1, 0, 0, 0, 4603, 30725, 1, 0, 0, 0, 4605, 30731, 1, 0, 0, 0, 4607, 30742, 1, 0, 0, 0, 4609, 30755, 1, 0, 0, 0, 4611, 30762, 1, 0, 0, 0, 4613, 30770, 1, 0, 0, 0, 4615, 30781, 1, 0, 0, 0, 4617, 30786, 1, 0, 0, 0, 4619, 30791, 1, 0, 0, 0, 4621, 30800, 1, 0, 0, 0, 4623, 30808, 1, 0, 0, 0, 4625, 30816, 1, 0, 0, 0, 4627, 30822, 1, 0, 0, 0, 4629, 30842, 1, 0, 0, 0, 4631, 30846, 1, 0, 0, 0, 4633, 30858, 1, 0, 0, 0, 4635, 30862, 1, 0, 0, 0, 4637, 30873, 1, 0, 0, 0, 4639, 30880, 1, 0, 0, 0, 4641, 30894, 1, 0, 0, 0, 4643, 30902, 1, 0, 0, 0, 4645, 30911, 1, 0, 0, 0, 4647, 30924, 1, 0, 0, 0, 4649, 30935, 1, 0, 0, 0, 4651, 30945, 1, 0, 0, 0, 4653, 30953, 1, 0, 0, 0, 4655, 30970, 1, 0, 0, 0, 4657, 30981, 1, 0, 0, 0, 4659, 30992, 1, 0, 0, 0, 4661, 31002, 1, 0, 0, 0, 4663, 31012, 1, 0, 0, 0, 4665, 31021, 1, 0, 0, 0, 4667, 31048, 1, 0, 0, 0, 4669, 31065, 1, 0, 0, 0, 4671, 31086, 1, 0, 0, 0, 4673, 31096, 1, 0, 0, 0, 4675, 31107, 1, 0, 0, 0, 4677, 31121, 1, 0, 0, 0, 4679, 31130, 1, 0, 0, 0, 4681, 31139, 1, 0, 0, 0, 4683, 31145, 1, 0, 0, 0, 4685, 31157, 1, 0, 0, 0, 4687, 31166, 1, 0, 0, 0, 4689, 31174, 1, 0, 0, 0, 4691, 31184, 1, 0, 0, 0, 4693, 31197, 1, 0, 0, 0, 4695, 31206, 1, 0, 0, 0, 4697, 31213, 1, 0, 0, 0, 4699, 31230, 1, 0, 0, 0, 4701, 31243, 1, 0, 0, 0, 4703, 31251, 1, 0, 0, 0, 4705, 31255, 1, 0, 0, 0, 4707, 31266, 1, 0, 0, 0, 4709, 31281, 1, 0, 0, 0, 4711, 31284, 1, 0, 0, 0, 4713, 31295, 1, 0, 0, 0, 4715, 31301, 1, 0, 0, 0, 4717, 31306, 1, 0, 0, 0, 4719, 31320, 1, 0, 0, 0, 4721, 31324, 1, 0, 0, 0, 4723, 31349, 1, 0, 0, 0, 4725, 31357, 1, 0, 0, 0, 4727, 31362, 1, 0, 0, 0, 4729, 31368, 1, 0, 0, 0, 4731, 31379, 1, 0, 0, 0, 4733, 31397, 1, 0, 0, 0, 4735, 31413, 1, 0, 0, 0, 4737, 31432, 1, 0, 0, 0, 4739, 31455, 1, 0, 0, 0, 4741, 31470, 1, 0, 0, 0, 4743, 31481, 1, 0, 0, 0, 4745, 31489, 1, 0, 0, 0, 4747, 31499, 1, 0, 0, 0, 4749, 31510, 1, 0, 0, 0, 4751, 31521, 1, 0, 0, 0, 4753, 31530, 1, 0, 0, 0, 4755, 31538, 1, 0, 0, 0, 4757, 31543, 1, 0, 0, 0, 4759, 31553, 1, 0, 0, 0, 4761, 31569, 1, 0, 0, 0, 4763, 31581, 1, 0, 0, 0, 4765, 31593, 1, 0, 0, 0, 4767, 31607, 1, 0, 0, 0, 4769, 31618, 1, 0, 0, 0, 4771, 31626, 1, 0, 0, 0, 4773, 31631, 1, 0, 0, 0, 4775, 31639, 1, 0, 0, 0, 4777, 31644, 1, 0, 0, 0, 4779, 31650, 1, 0, 0, 0, 4781, 31660, 1, 0, 0, 0, 4783, 31670, 1, 0, 0, 0, 4785, 31681, 1, 0, 0, 0, 4787, 31689, 1, 0, 0, 0, 4789, 31702, 1, 0, 0, 0, 4791, 31718, 1, 0, 0, 0, 4793, 31734, 1, 0, 0, 0, 4795, 31739, 1, 0, 0, 0, 4797, 31743, 1, 0, 0, 0, 4799, 31748, 1, 0, 0, 0, 4801, 31755, 1, 0, 0, 0, 4803, 31762, 1, 0, 0, 0, 4805, 31766, 1, 0, 0, 0, 4807, 31775, 1, 0, 0, 0, 4809, 31792, 1, 0, 0, 0, 4811, 31797, 1, 0, 0, 0, 4813, 31801, 1, 0, 0, 0, 4815, 31808, 1, 0, 0, 0, 4817, 31820, 1, 0, 0, 0, 4819, 31824, 1, 0, 0, 0, 4821, 31830, 1, 0, 0, 0, 4823, 31834, 1, 0, 0, 0, 4825, 31850, 1, 0, 0, 0, 4827, 31856, 1, 0, 0, 0, 4829, 31862, 1, 0, 0, 0, 4831, 31873, 1, 0, 0, 0, 4833, 31880, 1, 0, 0, 0, 4835, 31888, 1, 0, 0, 0, 4837, 31893, 1, 0, 0, 0, 4839, 31897, 1, 0, 0, 0, 4841, 31904, 1, 0, 0, 0, 4843, 31909, 1, 0, 0, 0, 4845, 31918, 1, 0, 0, 0, 4847, 31924, 1, 0, 0, 0, 4849, 31933, 1, 0, 0, 0, 4851, 31941, 1, 0, 0, 0, 4853, 31951, 1, 0, 0, 0, 4855, 31963, 1, 0, 0, 0, 4857, 31972, 1, 0, 0, 0, 4859, 31979, 1, 0, 0, 0, 4861, 31986, 1, 0, 0, 0, 4863, 31998, 1, 0, 0, 0, 4865, 32010, 1, 0, 0, 0, 4867, 32017, 1, 0, 0, 0, 4869, 32021, 1, 0, 0, 0, 4871, 32031, 1, 0, 0, 0, 4873, 32044, 1, 0, 0, 0, 4875, 32060, 1, 0, 0, 0, 4877, 32074, 1, 0, 0, 0, 4879, 32077, 1, 0, 0, 0, 4881, 32080, 1, 0, 0, 0, 4883, 32084, 1, 0, 0, 0, 4885, 32102, 1, 0, 0, 0, 4887, 32114, 1, 0, 0, 0, 4889, 32133, 1, 0, 0, 0, 4891, 32142, 1, 0, 0, 0, 4893, 32151, 1, 0, 0, 0, 4895, 32160, 1, 0, 0, 0, 4897, 32169, 1, 0, 0, 0, 4899, 32178, 1, 0, 0, 0, 4901, 32187, 1, 0, 0, 0, 4903, 32196, 1, 0, 0, 0, 4905, 32205, 1, 0, 0, 0, 4907, 32214, 1, 0, 0, 0, 4909, 32223, 1, 0, 0, 0, 4911, 32232, 1, 0, 0, 0, 4913, 32242, 1, 0, 0, 0, 4915, 32244, 1, 0, 0, 0, 4917, 32246, 1, 0, 0, 0, 4919, 32248, 1, 0, 0, 0, 4921, 32250, 1, 0, 0, 0, 4923, 32253, 1, 0, 0, 0, 4925, 32255, 1, 0, 0, 0, 4927, 32257, 1, 0, 0, 0, 4929, 32259, 1, 0, 0, 0, 4931, 32261, 1, 0, 0, 0, 4933, 32263, 1, 0, 0, 0, 4935, 32265, 1, 0, 0, 0, 4937, 32267, 1, 0, 0, 0, 4939, 32270, 1, 0, 0, 0, 4941, 32272, 1, 0, 0, 0, 4943, 32274, 1, 0, 0, 0, 4945, 32276, 1, 0, 0, 0, 4947, 32292, 1, 0, 0, 0, 4949, 32302, 1, 0, 0, 0, 4951, 32304, 1, 0, 0, 0, 4953, 32306, 1, 0, 0, 0, 4955, 32308, 1, 0, 0, 0, 4957, 32310, 1, 0, 0, 0, 4959, 32312, 1, 0, 0, 0, 4961, 32314, 1, 0, 0, 0, 4963, 32316, 1, 0, 0, 0, 4965, 32318, 1, 0, 0, 0, 4967, 32320, 1, 0, 0, 0, 4969, 32322, 1, 0, 0, 0, 4971, 32324, 1, 0, 0, 0, 4973, 32326, 1, 0, 0, 0, 4975, 32328, 1, 0, 0, 0, 4977, 32341, 1, 0, 0, 0, 4979, 32355, 1, 0, 0, 0, 4981, 32378, 1, 0, 0, 0, 4983, 32399, 1, 0, 0, 0, 4985, 32407, 1, 0, 0, 0, 4987, 32417, 1, 0, 0, 0, 4989, 32425, 1, 0, 0, 0, 4991, 32427, 1, 0, 0, 0, 4993, 32429, 1, 0, 0, 0, 4995, 32434, 1, 0, 0, 0, 4997, 32446, 1, 0, 0, 0, 4999, 32450, 1, 0, 0, 0, 5001, 5002, 7, 0, 0, 0, 5002, 5003, 7, 1, 0, 0, 5003, 5004, 7, 2, 0, 0, 5004, 5005, 7, 3, 0, 0, 5005, 5006, 7, 4, 0, 0, 5006, 2, 1, 0, 0, 0, 5007, 5008, 7, 0, 0, 0, 5008, 5009, 7, 1, 0, 0, 5009, 5010, 7, 5, 0, 0, 5010, 4, 1, 0, 0, 0, 5011, 5012, 7, 0, 0, 0, 5012, 5013, 7, 1, 0, 0, 5013, 5014, 7, 5, 0, 0, 5014, 5015, 7, 6, 0, 0, 5015, 5016, 7, 7, 0, 0, 5016, 5017, 7, 4, 0, 0, 5017, 6, 1, 0, 0, 0, 5018, 5019, 7, 0, 0, 0, 5019, 5020, 7, 8, 0, 0, 5020, 5021, 7, 8, 0, 0, 5021, 5022, 7, 6, 0, 0, 5022, 5023, 7, 5, 0, 0, 5023, 5024, 7, 5, 0, 0, 5024, 8, 1, 0, 0, 0, 5025, 5026, 7, 0, 0, 0, 5026, 5027, 7, 8, 0, 0, 5027, 5028, 7, 8, 0, 0, 5028, 5029, 7, 6, 0, 0, 5029, 5030, 7, 5, 0, 0, 5030, 5031, 7, 5, 0, 0, 5031, 5032, 7, 6, 0, 0, 5032, 5033, 7, 9, 0, 0, 5033, 10, 1, 0, 0, 0, 5034, 5035, 7, 0, 0, 0, 5035, 5036, 7, 8, 0, 0, 5036, 5037, 7, 8, 0, 0, 5037, 5038, 7, 6, 0, 0, 5038, 5039, 7, 5, 0, 0, 5039, 5040, 7, 5, 0, 0, 5040, 5041, 7, 10, 0, 0, 5041, 5042, 7, 1, 0, 0, 5042, 5043, 7, 11, 0, 0, 5043, 5044, 7, 6, 0, 0, 5044, 12, 1, 0, 0, 0, 5045, 5046, 7, 0, 0, 0, 5046, 5047, 7, 8, 0, 0, 5047, 5048, 7, 8, 0, 0, 5048, 5049, 7, 2, 0, 0, 5049, 5050, 7, 12, 0, 0, 5050, 5051, 7, 7, 0, 0, 5051, 5052, 7, 4, 0, 0, 5052, 14, 1, 0, 0, 0, 5053, 5054, 7, 0, 0, 0, 5054, 5055, 7, 8, 0, 0, 5055, 5056, 7, 11, 0, 0, 5056, 16, 1, 0, 0, 0, 5057, 5058, 7, 0, 0, 0, 5058, 5059, 7, 8, 0, 0, 5059, 5060, 7, 2, 0, 0, 5060, 5061, 7, 5, 0, 0, 5061, 18, 1, 0, 0, 0, 5062, 5063, 7, 0, 0, 0, 5063, 5064, 7, 8, 0, 0, 5064, 5065, 7, 3, 0, 0, 5065, 5066, 7, 2, 0, 0, 5066, 5067, 7, 5, 0, 0, 5067, 5068, 7, 5, 0, 0, 5068, 20, 1, 0, 0, 0, 5069, 5070, 7, 0, 0, 0, 5070, 5071, 7, 8, 0, 0, 5071, 5072, 7, 4, 0, 0, 5072, 5073, 7, 10, 0, 0, 5073, 5074, 7, 2, 0, 0, 5074, 5075, 7, 7, 0, 0, 5075, 22, 1, 0, 0, 0, 5076, 5077, 7, 0, 0, 0, 5077, 5078, 7, 8, 0, 0, 5078, 5079, 7, 4, 0, 0, 5079, 5080, 7, 10, 0, 0, 5080, 5081, 7, 2, 0, 0, 5081, 5082, 7, 7, 0, 0, 5082, 5083, 7, 5, 0, 0, 5083, 24, 1, 0, 0, 0, 5084, 5085, 7, 0, 0, 0, 5085, 5086, 7, 8, 0, 0, 5086, 5087, 7, 4, 0, 0, 5087, 5088, 7, 10, 0, 0, 5088, 5089, 7, 13, 0, 0, 5089, 5090, 7, 0, 0, 0, 5090, 5091, 7, 4, 0, 0, 5091, 5092, 7, 6, 0, 0, 5092, 26, 1, 0, 0, 0, 5093, 5094, 7, 0, 0, 0, 5094, 5095, 7, 8, 0, 0, 5095, 5096, 7, 4, 0, 0, 5096, 5097, 7, 10, 0, 0, 5097, 5098, 7, 13, 0, 0, 5098, 5099, 7, 6, 0, 0, 5099, 28, 1, 0, 0, 0, 5100, 5101, 7, 0, 0, 0, 5101, 5102, 7, 8, 0, 0, 5102, 5103, 7, 4, 0, 0, 5103, 5104, 7, 10, 0, 0, 5104, 5105, 7, 13, 0, 0, 5105, 5106, 7, 6, 0, 0, 5106, 5107, 5, 95, 0, 0, 5107, 5108, 7, 8, 0, 0, 5108, 5109, 7, 2, 0, 0, 5109, 5110, 7, 14, 0, 0, 5110, 5111, 7, 15, 0, 0, 5111, 5112, 7, 2, 0, 0, 5112, 5113, 7, 7, 0, 0, 5113, 5114, 7, 6, 0, 0, 5114, 5115, 7, 7, 0, 0, 5115, 5116, 7, 4, 0, 0, 5116, 30, 1, 0, 0, 0, 5117, 5118, 7, 0, 0, 0, 5118, 5119, 7, 8, 0, 0, 5119, 5120, 7, 4, 0, 0, 5120, 5121, 7, 10, 0, 0, 5121, 5122, 7, 13, 0, 0, 5122, 5123, 7, 6, 0, 0, 5123, 5124, 5, 95, 0, 0, 5124, 5125, 7, 9, 0, 0, 5125, 5126, 7, 0, 0, 0, 5126, 5127, 7, 4, 0, 0, 5127, 5128, 7, 0, 0, 0, 5128, 32, 1, 0, 0, 0, 5129, 5130, 7, 0, 0, 0, 5130, 5131, 7, 8, 0, 0, 5131, 5132, 7, 4, 0, 0, 5132, 5133, 7, 10, 0, 0, 5133, 5134, 7, 13, 0, 0, 5134, 5135, 7, 6, 0, 0, 5135, 5136, 5, 95, 0, 0, 5136, 5137, 7, 16, 0, 0, 5137, 5138, 7, 12, 0, 0, 5138, 5139, 7, 7, 0, 0, 5139, 5140, 7, 8, 0, 0, 5140, 5141, 7, 4, 0, 0, 5141, 5142, 7, 10, 0, 0, 5142, 5143, 7, 2, 0, 0, 5143, 5144, 7, 7, 0, 0, 5144, 34, 1, 0, 0, 0, 5145, 5146, 7, 0, 0, 0, 5146, 5147, 7, 8, 0, 0, 5147, 5148, 7, 4, 0, 0, 5148, 5149, 7, 10, 0, 0, 5149, 5150, 7, 13, 0, 0, 5150, 5151, 7, 6, 0, 0, 5151, 5152, 5, 95, 0, 0, 5152, 5153, 7, 4, 0, 0, 5153, 5154, 7, 0, 0, 0, 5154, 5155, 7, 17, 0, 0, 5155, 36, 1, 0, 0, 0, 5156, 5157, 7, 0, 0, 0, 5157, 5158, 7, 8, 0, 0, 5158, 5159, 7, 4, 0, 0, 5159, 5160, 7, 10, 0, 0, 5160, 5161, 7, 13, 0, 0, 5161, 5162, 7, 10, 0, 0, 5162, 5163, 7, 4, 0, 0, 5163, 5164, 7, 18, 0, 0, 5164, 38, 1, 0, 0, 0, 5165, 5166, 7, 0, 0, 0, 5166, 5167, 7, 9, 0, 0, 5167, 5168, 7, 0, 0, 0, 5168, 5169, 7, 15, 0, 0, 5169, 5170, 7, 4, 0, 0, 5170, 5171, 7, 10, 0, 0, 5171, 5172, 7, 13, 0, 0, 5172, 5173, 7, 6, 0, 0, 5173, 5174, 5, 95, 0, 0, 5174, 5175, 7, 15, 0, 0, 5175, 5176, 7, 11, 0, 0, 5176, 5177, 7, 0, 0, 0, 5177, 5178, 7, 7, 0, 0, 5178, 40, 1, 0, 0, 0, 5179, 5180, 7, 0, 0, 0, 5180, 5181, 7, 9, 0, 0, 5181, 5182, 7, 9, 0, 0, 5182, 42, 1, 0, 0, 0, 5183, 5184, 7, 0, 0, 0, 5184, 5185, 7, 9, 0, 0, 5185, 5186, 7, 9, 0, 0, 5186, 5187, 5, 95, 0, 0, 5187, 5188, 7, 8, 0, 0, 5188, 5189, 7, 2, 0, 0, 5189, 5190, 7, 11, 0, 0, 5190, 5191, 7, 12, 0, 0, 5191, 5192, 7, 14, 0, 0, 5192, 5193, 7, 7, 0, 0, 5193, 44, 1, 0, 0, 0, 5194, 5195, 7, 0, 0, 0, 5195, 5196, 7, 9, 0, 0, 5196, 5197, 7, 9, 0, 0, 5197, 5198, 5, 95, 0, 0, 5198, 5199, 7, 17, 0, 0, 5199, 5200, 7, 3, 0, 0, 5200, 5201, 7, 2, 0, 0, 5201, 5202, 7, 12, 0, 0, 5202, 5203, 7, 15, 0, 0, 5203, 46, 1, 0, 0, 0, 5204, 5205, 7, 0, 0, 0, 5205, 5206, 7, 9, 0, 0, 5206, 5207, 7, 9, 0, 0, 5207, 5208, 5, 95, 0, 0, 5208, 5209, 7, 14, 0, 0, 5209, 5210, 7, 2, 0, 0, 5210, 5211, 7, 7, 0, 0, 5211, 5212, 7, 4, 0, 0, 5212, 5213, 7, 19, 0, 0, 5213, 5214, 7, 5, 0, 0, 5214, 48, 1, 0, 0, 0, 5215, 5216, 7, 0, 0, 0, 5216, 5217, 7, 9, 0, 0, 5217, 5218, 7, 20, 0, 0, 5218, 5219, 5, 95, 0, 0, 5219, 5220, 7, 9, 0, 0, 5220, 5221, 7, 0, 0, 0, 5221, 5222, 7, 4, 0, 0, 5222, 5223, 7, 6, 0, 0, 5223, 50, 1, 0, 0, 0, 5224, 5225, 7, 0, 0, 0, 5225, 5226, 7, 9, 0, 0, 5226, 5227, 7, 14, 0, 0, 5227, 5228, 7, 10, 0, 0, 5228, 5229, 7, 7, 0, 0, 5229, 52, 1, 0, 0, 0, 5230, 5231, 7, 0, 0, 0, 5231, 5232, 7, 9, 0, 0, 5232, 5233, 7, 14, 0, 0, 5233, 5234, 7, 10, 0, 0, 5234, 5235, 7, 7, 0, 0, 5235, 5236, 7, 10, 0, 0, 5236, 5237, 7, 5, 0, 0, 5237, 5238, 7, 4, 0, 0, 5238, 5239, 7, 6, 0, 0, 5239, 5240, 7, 3, 0, 0, 5240, 54, 1, 0, 0, 0, 5241, 5242, 7, 0, 0, 0, 5242, 5243, 7, 9, 0, 0, 5243, 5244, 7, 14, 0, 0, 5244, 5245, 7, 10, 0, 0, 5245, 5246, 7, 7, 0, 0, 5246, 5247, 7, 10, 0, 0, 5247, 5248, 7, 5, 0, 0, 5248, 5249, 7, 4, 0, 0, 5249, 5250, 7, 3, 0, 0, 5250, 5251, 7, 0, 0, 0, 5251, 5252, 7, 4, 0, 0, 5252, 5253, 7, 2, 0, 0, 5253, 5254, 7, 3, 0, 0, 5254, 56, 1, 0, 0, 0, 5255, 5256, 7, 0, 0, 0, 5256, 5257, 7, 9, 0, 0, 5257, 5258, 7, 13, 0, 0, 5258, 5259, 7, 0, 0, 0, 5259, 5260, 7, 7, 0, 0, 5260, 5261, 7, 8, 0, 0, 5261, 5262, 7, 6, 0, 0, 5262, 5263, 7, 9, 0, 0, 5263, 58, 1, 0, 0, 0, 5264, 5265, 7, 0, 0, 0, 5265, 5266, 7, 9, 0, 0, 5266, 5267, 7, 13, 0, 0, 5267, 5268, 7, 10, 0, 0, 5268, 5269, 7, 5, 0, 0, 5269, 5270, 7, 6, 0, 0, 5270, 60, 1, 0, 0, 0, 5271, 5272, 7, 0, 0, 0, 5272, 5273, 7, 9, 0, 0, 5273, 5274, 7, 13, 0, 0, 5274, 5275, 7, 10, 0, 0, 5275, 5276, 7, 5, 0, 0, 5276, 5277, 7, 2, 0, 0, 5277, 5278, 7, 3, 0, 0, 5278, 62, 1, 0, 0, 0, 5279, 5280, 7, 0, 0, 0, 5280, 5281, 7, 16, 0, 0, 5281, 5282, 7, 9, 0, 0, 5282, 5283, 5, 95, 0, 0, 5283, 5284, 7, 9, 0, 0, 5284, 5285, 7, 10, 0, 0, 5285, 5286, 7, 5, 0, 0, 5286, 5287, 7, 21, 0, 0, 5287, 5288, 7, 5, 0, 0, 5288, 5289, 7, 4, 0, 0, 5289, 5290, 7, 3, 0, 0, 5290, 5291, 7, 10, 0, 0, 5291, 5292, 7, 7, 0, 0, 5292, 5293, 7, 17, 0, 0, 5293, 64, 1, 0, 0, 0, 5294, 5295, 7, 0, 0, 0, 5295, 5296, 7, 16, 0, 0, 5296, 5297, 7, 4, 0, 0, 5297, 5298, 7, 6, 0, 0, 5298, 5299, 7, 3, 0, 0, 5299, 66, 1, 0, 0, 0, 5300, 5301, 7, 0, 0, 0, 5301, 5302, 7, 17, 0, 0, 5302, 5303, 7, 6, 0, 0, 5303, 5304, 7, 7, 0, 0, 5304, 5305, 7, 4, 0, 0, 5305, 68, 1, 0, 0, 0, 5306, 5307, 7, 0, 0, 0, 5307, 5308, 7, 17, 0, 0, 5308, 5309, 7, 17, 0, 0, 5309, 5310, 7, 3, 0, 0, 5310, 5311, 7, 6, 0, 0, 5311, 5312, 7, 17, 0, 0, 5312, 5313, 7, 0, 0, 0, 5313, 5314, 7, 4, 0, 0, 5314, 5315, 7, 6, 0, 0, 5315, 70, 1, 0, 0, 0, 5316, 5317, 7, 0, 0, 0, 5317, 72, 1, 0, 0, 0, 5318, 5319, 7, 0, 0, 0, 5319, 5320, 7, 11, 0, 0, 5320, 5321, 7, 10, 0, 0, 5321, 5322, 7, 0, 0, 0, 5322, 5323, 7, 5, 0, 0, 5323, 74, 1, 0, 0, 0, 5324, 5325, 7, 0, 0, 0, 5325, 5326, 7, 11, 0, 0, 5326, 5327, 7, 11, 0, 0, 5327, 76, 1, 0, 0, 0, 5328, 5329, 7, 0, 0, 0, 5329, 5330, 7, 11, 0, 0, 5330, 5331, 7, 11, 0, 0, 5331, 5332, 7, 2, 0, 0, 5332, 5333, 7, 8, 0, 0, 5333, 5334, 7, 0, 0, 0, 5334, 5335, 7, 4, 0, 0, 5335, 5336, 7, 6, 0, 0, 5336, 78, 1, 0, 0, 0, 5337, 5338, 7, 0, 0, 0, 5338, 5339, 7, 11, 0, 0, 5339, 5340, 7, 11, 0, 0, 5340, 5341, 7, 2, 0, 0, 5341, 5342, 7, 22, 0, 0, 5342, 80, 1, 0, 0, 0, 5343, 5344, 7, 0, 0, 0, 5344, 5345, 7, 11, 0, 0, 5345, 5346, 7, 11, 0, 0, 5346, 5347, 5, 95, 0, 0, 5347, 5348, 7, 3, 0, 0, 5348, 5349, 7, 2, 0, 0, 5349, 5350, 7, 22, 0, 0, 5350, 5351, 7, 5, 0, 0, 5351, 82, 1, 0, 0, 0, 5352, 5353, 7, 0, 0, 0, 5353, 5354, 7, 11, 0, 0, 5354, 5355, 7, 4, 0, 0, 5355, 5356, 7, 6, 0, 0, 5356, 5357, 7, 3, 0, 0, 5357, 84, 1, 0, 0, 0, 5358, 5359, 7, 0, 0, 0, 5359, 5360, 7, 11, 0, 0, 5360, 5361, 7, 4, 0, 0, 5361, 5362, 7, 6, 0, 0, 5362, 5363, 7, 3, 0, 0, 5363, 5364, 7, 7, 0, 0, 5364, 5365, 7, 0, 0, 0, 5365, 5366, 7, 4, 0, 0, 5366, 5367, 7, 6, 0, 0, 5367, 86, 1, 0, 0, 0, 5368, 5369, 7, 0, 0, 0, 5369, 5370, 7, 11, 0, 0, 5370, 5371, 7, 22, 0, 0, 5371, 5372, 7, 0, 0, 0, 5372, 5373, 7, 18, 0, 0, 5373, 5374, 7, 5, 0, 0, 5374, 88, 1, 0, 0, 0, 5375, 5376, 7, 0, 0, 0, 5376, 5377, 7, 7, 0, 0, 5377, 5378, 7, 0, 0, 0, 5378, 5379, 7, 11, 0, 0, 5379, 5380, 7, 18, 0, 0, 5380, 5381, 7, 4, 0, 0, 5381, 5382, 7, 10, 0, 0, 5382, 5383, 7, 8, 0, 0, 5383, 90, 1, 0, 0, 0, 5384, 5385, 7, 0, 0, 0, 5385, 5386, 7, 7, 0, 0, 5386, 5387, 7, 0, 0, 0, 5387, 5388, 7, 11, 0, 0, 5388, 5389, 7, 18, 0, 0, 5389, 5390, 7, 23, 0, 0, 5390, 5391, 7, 6, 0, 0, 5391, 92, 1, 0, 0, 0, 5392, 5393, 7, 0, 0, 0, 5393, 5394, 7, 7, 0, 0, 5394, 5395, 7, 8, 0, 0, 5395, 5396, 7, 6, 0, 0, 5396, 5397, 7, 5, 0, 0, 5397, 5398, 7, 4, 0, 0, 5398, 5399, 7, 2, 0, 0, 5399, 5400, 7, 3, 0, 0, 5400, 94, 1, 0, 0, 0, 5401, 5402, 7, 0, 0, 0, 5402, 5403, 7, 7, 0, 0, 5403, 5404, 7, 8, 0, 0, 5404, 5405, 7, 10, 0, 0, 5405, 5406, 7, 11, 0, 0, 5406, 5407, 7, 11, 0, 0, 5407, 5408, 7, 0, 0, 0, 5408, 5409, 7, 3, 0, 0, 5409, 5410, 7, 18, 0, 0, 5410, 96, 1, 0, 0, 0, 5411, 5412, 7, 0, 0, 0, 5412, 5413, 7, 7, 0, 0, 5413, 5414, 7, 9, 0, 0, 5414, 98, 1, 0, 0, 0, 5415, 5416, 7, 0, 0, 0, 5416, 5417, 7, 7, 0, 0, 5417, 5418, 7, 9, 0, 0, 5418, 5419, 5, 95, 0, 0, 5419, 5420, 7, 6, 0, 0, 5420, 5421, 7, 24, 0, 0, 5421, 5422, 7, 12, 0, 0, 5422, 5423, 7, 0, 0, 0, 5423, 5424, 7, 11, 0, 0, 5424, 100, 1, 0, 0, 0, 5425, 5426, 7, 0, 0, 0, 5426, 5427, 7, 7, 0, 0, 5427, 5428, 7, 7, 0, 0, 5428, 5429, 7, 2, 0, 0, 5429, 5430, 7, 4, 0, 0, 5430, 5431, 7, 0, 0, 0, 5431, 5432, 7, 4, 0, 0, 5432, 5433, 7, 10, 0, 0, 5433, 5434, 7, 2, 0, 0, 5434, 5435, 7, 7, 0, 0, 5435, 5436, 7, 5, 0, 0, 5436, 102, 1, 0, 0, 0, 5437, 5438, 7, 0, 0, 0, 5438, 5439, 7, 7, 0, 0, 5439, 5440, 7, 2, 0, 0, 5440, 5441, 7, 14, 0, 0, 5441, 5442, 7, 0, 0, 0, 5442, 5443, 7, 11, 0, 0, 5443, 5444, 7, 18, 0, 0, 5444, 104, 1, 0, 0, 0, 5445, 5446, 7, 0, 0, 0, 5446, 5447, 7, 7, 0, 0, 5447, 5448, 7, 5, 0, 0, 5448, 5449, 7, 10, 0, 0, 5449, 5450, 5, 95, 0, 0, 5450, 5451, 7, 3, 0, 0, 5451, 5452, 7, 6, 0, 0, 5452, 5453, 7, 0, 0, 0, 5453, 5454, 7, 3, 0, 0, 5454, 5455, 7, 8, 0, 0, 5455, 5456, 7, 19, 0, 0, 5456, 106, 1, 0, 0, 0, 5457, 5458, 7, 0, 0, 0, 5458, 5459, 7, 7, 0, 0, 5459, 5460, 7, 4, 0, 0, 5460, 5461, 7, 10, 0, 0, 5461, 5462, 7, 20, 0, 0, 5462, 5463, 7, 2, 0, 0, 5463, 5464, 7, 10, 0, 0, 5464, 5465, 7, 7, 0, 0, 5465, 108, 1, 0, 0, 0, 5466, 5467, 7, 0, 0, 0, 5467, 5468, 7, 7, 0, 0, 5468, 5469, 7, 18, 0, 0, 5469, 110, 1, 0, 0, 0, 5470, 5471, 7, 0, 0, 0, 5471, 5472, 7, 7, 0, 0, 5472, 5473, 7, 18, 0, 0, 5473, 5474, 7, 5, 0, 0, 5474, 5475, 7, 8, 0, 0, 5475, 5476, 7, 19, 0, 0, 5476, 5477, 7, 6, 0, 0, 5477, 5478, 7, 14, 0, 0, 5478, 5479, 7, 0, 0, 0, 5479, 112, 1, 0, 0, 0, 5480, 5481, 7, 0, 0, 0, 5481, 5482, 7, 15, 0, 0, 5482, 5483, 7, 15, 0, 0, 5483, 5484, 7, 6, 0, 0, 5484, 5485, 7, 7, 0, 0, 5485, 5486, 7, 9, 0, 0, 5486, 114, 1, 0, 0, 0, 5487, 5488, 7, 0, 0, 0, 5488, 5489, 7, 15, 0, 0, 5489, 5490, 7, 15, 0, 0, 5490, 5491, 7, 6, 0, 0, 5491, 5492, 7, 7, 0, 0, 5492, 5493, 7, 9, 0, 0, 5493, 5494, 7, 8, 0, 0, 5494, 5495, 7, 19, 0, 0, 5495, 5496, 7, 10, 0, 0, 5496, 5497, 7, 11, 0, 0, 5497, 5498, 7, 9, 0, 0, 5498, 5499, 7, 25, 0, 0, 5499, 5500, 7, 14, 0, 0, 5500, 5501, 7, 11, 0, 0, 5501, 116, 1, 0, 0, 0, 5502, 5503, 7, 0, 0, 0, 5503, 5504, 7, 15, 0, 0, 5504, 5505, 7, 15, 0, 0, 5505, 5506, 7, 6, 0, 0, 5506, 5507, 7, 7, 0, 0, 5507, 5508, 7, 9, 0, 0, 5508, 5509, 5, 95, 0, 0, 5509, 5510, 7, 13, 0, 0, 5510, 5511, 7, 0, 0, 0, 5511, 5512, 7, 11, 0, 0, 5512, 5513, 7, 12, 0, 0, 5513, 5514, 7, 6, 0, 0, 5514, 5515, 7, 5, 0, 0, 5515, 118, 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, 11, 0, 0, 5520, 5521, 7, 10, 0, 0, 5521, 5522, 7, 8, 0, 0, 5522, 5523, 7, 0, 0, 0, 5523, 5524, 7, 4, 0, 0, 5524, 5525, 7, 10, 0, 0, 5525, 5526, 7, 2, 0, 0, 5526, 5527, 7, 7, 0, 0, 5527, 120, 1, 0, 0, 0, 5528, 5529, 7, 0, 0, 0, 5529, 5530, 7, 15, 0, 0, 5530, 5531, 7, 15, 0, 0, 5531, 5532, 7, 11, 0, 0, 5532, 5533, 7, 18, 0, 0, 5533, 122, 1, 0, 0, 0, 5534, 5535, 7, 0, 0, 0, 5535, 5536, 7, 15, 0, 0, 5536, 5537, 7, 15, 0, 0, 5537, 5538, 7, 3, 0, 0, 5538, 5539, 7, 2, 0, 0, 5539, 5540, 7, 25, 0, 0, 5540, 5541, 5, 95, 0, 0, 5541, 5542, 7, 8, 0, 0, 5542, 5543, 7, 2, 0, 0, 5543, 5544, 7, 12, 0, 0, 5544, 5545, 7, 7, 0, 0, 5545, 5546, 7, 4, 0, 0, 5546, 5547, 5, 95, 0, 0, 5547, 5548, 7, 9, 0, 0, 5548, 5549, 7, 10, 0, 0, 5549, 5550, 7, 5, 0, 0, 5550, 5551, 7, 4, 0, 0, 5551, 5552, 7, 10, 0, 0, 5552, 5553, 7, 7, 0, 0, 5553, 5554, 7, 8, 0, 0, 5554, 5555, 7, 4, 0, 0, 5555, 124, 1, 0, 0, 0, 5556, 5557, 7, 0, 0, 0, 5557, 5558, 7, 3, 0, 0, 5558, 5559, 7, 8, 0, 0, 5559, 5560, 7, 19, 0, 0, 5560, 5561, 7, 10, 0, 0, 5561, 5562, 7, 13, 0, 0, 5562, 5563, 7, 0, 0, 0, 5563, 5564, 7, 11, 0, 0, 5564, 126, 1, 0, 0, 0, 5565, 5566, 7, 0, 0, 0, 5566, 5567, 7, 3, 0, 0, 5567, 5568, 7, 8, 0, 0, 5568, 5569, 7, 19, 0, 0, 5569, 5570, 7, 10, 0, 0, 5570, 5571, 7, 13, 0, 0, 5571, 5572, 7, 6, 0, 0, 5572, 128, 1, 0, 0, 0, 5573, 5574, 7, 0, 0, 0, 5574, 5575, 7, 3, 0, 0, 5575, 5576, 7, 8, 0, 0, 5576, 5577, 7, 19, 0, 0, 5577, 5578, 7, 10, 0, 0, 5578, 5579, 7, 13, 0, 0, 5579, 5580, 7, 6, 0, 0, 5580, 5581, 7, 9, 0, 0, 5581, 130, 1, 0, 0, 0, 5582, 5583, 7, 0, 0, 0, 5583, 5584, 7, 3, 0, 0, 5584, 5585, 7, 8, 0, 0, 5585, 5586, 7, 19, 0, 0, 5586, 5587, 7, 10, 0, 0, 5587, 5588, 7, 13, 0, 0, 5588, 5589, 7, 6, 0, 0, 5589, 5590, 7, 11, 0, 0, 5590, 5591, 7, 2, 0, 0, 5591, 5592, 7, 17, 0, 0, 5592, 132, 1, 0, 0, 0, 5593, 5594, 7, 0, 0, 0, 5594, 5595, 7, 3, 0, 0, 5595, 5596, 7, 6, 0, 0, 5596, 134, 1, 0, 0, 0, 5597, 5598, 7, 0, 0, 0, 5598, 5599, 7, 3, 0, 0, 5599, 5600, 7, 3, 0, 0, 5600, 5601, 7, 0, 0, 0, 5601, 5602, 7, 18, 0, 0, 5602, 136, 1, 0, 0, 0, 5603, 5604, 7, 0, 0, 0, 5604, 5605, 7, 5, 0, 0, 5605, 138, 1, 0, 0, 0, 5606, 5607, 7, 0, 0, 0, 5607, 5608, 7, 5, 0, 0, 5608, 5609, 7, 8, 0, 0, 5609, 140, 1, 0, 0, 0, 5610, 5611, 7, 0, 0, 0, 5611, 5612, 7, 5, 0, 0, 5612, 5613, 7, 8, 0, 0, 5613, 5614, 7, 10, 0, 0, 5614, 5615, 7, 10, 0, 0, 5615, 142, 1, 0, 0, 0, 5616, 5617, 7, 0, 0, 0, 5617, 5618, 7, 5, 0, 0, 5618, 5619, 7, 8, 0, 0, 5619, 5620, 7, 10, 0, 0, 5620, 5621, 7, 10, 0, 0, 5621, 5622, 7, 5, 0, 0, 5622, 5623, 7, 4, 0, 0, 5623, 5624, 7, 3, 0, 0, 5624, 144, 1, 0, 0, 0, 5625, 5626, 7, 0, 0, 0, 5626, 5627, 7, 5, 0, 0, 5627, 5628, 7, 10, 0, 0, 5628, 5629, 7, 7, 0, 0, 5629, 146, 1, 0, 0, 0, 5630, 5631, 7, 0, 0, 0, 5631, 5632, 7, 5, 0, 0, 5632, 5633, 7, 10, 0, 0, 5633, 5634, 7, 5, 0, 0, 5634, 148, 1, 0, 0, 0, 5635, 5636, 7, 0, 0, 0, 5636, 5637, 7, 5, 0, 0, 5637, 5638, 7, 5, 0, 0, 5638, 5639, 7, 6, 0, 0, 5639, 5640, 7, 14, 0, 0, 5640, 5641, 7, 1, 0, 0, 5641, 5642, 7, 11, 0, 0, 5642, 5643, 7, 18, 0, 0, 5643, 150, 1, 0, 0, 0, 5644, 5645, 7, 0, 0, 0, 5645, 5646, 7, 5, 0, 0, 5646, 5647, 7, 5, 0, 0, 5647, 5648, 7, 10, 0, 0, 5648, 5649, 7, 17, 0, 0, 5649, 5650, 7, 7, 0, 0, 5650, 152, 1, 0, 0, 0, 5651, 5652, 7, 0, 0, 0, 5652, 5653, 7, 5, 0, 0, 5653, 5654, 7, 5, 0, 0, 5654, 5655, 7, 2, 0, 0, 5655, 5656, 7, 8, 0, 0, 5656, 5657, 7, 10, 0, 0, 5657, 5658, 7, 0, 0, 0, 5658, 5659, 7, 4, 0, 0, 5659, 5660, 7, 6, 0, 0, 5660, 154, 1, 0, 0, 0, 5661, 5662, 7, 0, 0, 0, 5662, 5663, 7, 5, 0, 0, 5663, 5664, 7, 18, 0, 0, 5664, 5665, 7, 7, 0, 0, 5665, 5666, 7, 8, 0, 0, 5666, 156, 1, 0, 0, 0, 5667, 5668, 7, 0, 0, 0, 5668, 5669, 7, 5, 0, 0, 5669, 5670, 7, 18, 0, 0, 5670, 5671, 7, 7, 0, 0, 5671, 5672, 7, 8, 0, 0, 5672, 5673, 7, 19, 0, 0, 5673, 5674, 7, 3, 0, 0, 5674, 5675, 7, 2, 0, 0, 5675, 5676, 7, 7, 0, 0, 5676, 5677, 7, 2, 0, 0, 5677, 5678, 7, 12, 0, 0, 5678, 5679, 7, 5, 0, 0, 5679, 158, 1, 0, 0, 0, 5680, 5681, 7, 0, 0, 0, 5681, 5682, 7, 4, 0, 0, 5682, 5683, 7, 0, 0, 0, 5683, 5684, 7, 7, 0, 0, 5684, 5685, 5, 50, 0, 0, 5685, 160, 1, 0, 0, 0, 5686, 5687, 7, 0, 0, 0, 5687, 5688, 7, 4, 0, 0, 5688, 5689, 7, 0, 0, 0, 5689, 5690, 7, 7, 0, 0, 5690, 162, 1, 0, 0, 0, 5691, 5692, 7, 0, 0, 0, 5692, 5693, 7, 4, 0, 0, 5693, 164, 1, 0, 0, 0, 5694, 5695, 7, 0, 0, 0, 5695, 5696, 7, 4, 0, 0, 5696, 5697, 7, 4, 0, 0, 5697, 5698, 7, 3, 0, 0, 5698, 5699, 7, 10, 0, 0, 5699, 5700, 7, 1, 0, 0, 5700, 5701, 7, 12, 0, 0, 5701, 5702, 7, 4, 0, 0, 5702, 5703, 7, 6, 0, 0, 5703, 166, 1, 0, 0, 0, 5704, 5705, 7, 0, 0, 0, 5705, 5706, 7, 4, 0, 0, 5706, 5707, 7, 4, 0, 0, 5707, 5708, 7, 3, 0, 0, 5708, 5709, 7, 10, 0, 0, 5709, 5710, 7, 1, 0, 0, 5710, 5711, 7, 12, 0, 0, 5711, 5712, 7, 4, 0, 0, 5712, 5713, 7, 6, 0, 0, 5713, 5714, 7, 5, 0, 0, 5714, 168, 1, 0, 0, 0, 5715, 5716, 7, 0, 0, 0, 5716, 5717, 7, 12, 0, 0, 5717, 5718, 7, 9, 0, 0, 5718, 5719, 7, 10, 0, 0, 5719, 5720, 7, 4, 0, 0, 5720, 170, 1, 0, 0, 0, 5721, 5722, 7, 0, 0, 0, 5722, 5723, 7, 12, 0, 0, 5723, 5724, 7, 4, 0, 0, 5724, 5725, 7, 19, 0, 0, 5725, 5726, 7, 6, 0, 0, 5726, 5727, 7, 7, 0, 0, 5727, 5728, 7, 4, 0, 0, 5728, 5729, 7, 10, 0, 0, 5729, 5730, 7, 8, 0, 0, 5730, 5731, 7, 0, 0, 0, 5731, 5732, 7, 4, 0, 0, 5732, 5733, 7, 6, 0, 0, 5733, 5734, 7, 9, 0, 0, 5734, 172, 1, 0, 0, 0, 5735, 5736, 7, 0, 0, 0, 5736, 5737, 7, 12, 0, 0, 5737, 5738, 7, 4, 0, 0, 5738, 5739, 7, 19, 0, 0, 5739, 5740, 7, 6, 0, 0, 5740, 5741, 7, 7, 0, 0, 5741, 5742, 7, 4, 0, 0, 5742, 5743, 7, 10, 0, 0, 5743, 5744, 7, 8, 0, 0, 5744, 5745, 7, 0, 0, 0, 5745, 5746, 7, 4, 0, 0, 5746, 5747, 7, 10, 0, 0, 5747, 5748, 7, 2, 0, 0, 5748, 5749, 7, 7, 0, 0, 5749, 174, 1, 0, 0, 0, 5750, 5751, 7, 0, 0, 0, 5751, 5752, 7, 12, 0, 0, 5752, 5753, 7, 4, 0, 0, 5753, 5754, 7, 19, 0, 0, 5754, 5755, 7, 10, 0, 0, 5755, 5756, 7, 9, 0, 0, 5756, 176, 1, 0, 0, 0, 5757, 5758, 7, 0, 0, 0, 5758, 5759, 7, 12, 0, 0, 5759, 5760, 7, 4, 0, 0, 5760, 5761, 7, 19, 0, 0, 5761, 5762, 7, 2, 0, 0, 5762, 5763, 7, 3, 0, 0, 5763, 5764, 7, 10, 0, 0, 5764, 5765, 7, 23, 0, 0, 5765, 5766, 7, 0, 0, 0, 5766, 5767, 7, 4, 0, 0, 5767, 5768, 7, 10, 0, 0, 5768, 5769, 7, 2, 0, 0, 5769, 5770, 7, 7, 0, 0, 5770, 178, 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, 0, 0, 0, 5776, 5777, 7, 11, 0, 0, 5777, 5778, 7, 11, 0, 0, 5778, 5779, 7, 2, 0, 0, 5779, 5780, 7, 8, 0, 0, 5780, 5781, 7, 0, 0, 0, 5781, 5782, 7, 4, 0, 0, 5782, 5783, 7, 6, 0, 0, 5783, 180, 1, 0, 0, 0, 5784, 5785, 7, 0, 0, 0, 5785, 5786, 7, 12, 0, 0, 5786, 5787, 7, 4, 0, 0, 5787, 5788, 7, 2, 0, 0, 5788, 182, 1, 0, 0, 0, 5789, 5790, 7, 0, 0, 0, 5790, 5791, 7, 12, 0, 0, 5791, 5792, 7, 4, 0, 0, 5792, 5793, 7, 2, 0, 0, 5793, 5794, 7, 1, 0, 0, 5794, 5795, 7, 0, 0, 0, 5795, 5796, 7, 8, 0, 0, 5796, 5797, 7, 21, 0, 0, 5797, 5798, 7, 12, 0, 0, 5798, 5799, 7, 15, 0, 0, 5799, 184, 1, 0, 0, 0, 5800, 5801, 7, 0, 0, 0, 5801, 5802, 7, 12, 0, 0, 5802, 5803, 7, 4, 0, 0, 5803, 5804, 7, 2, 0, 0, 5804, 5805, 7, 6, 0, 0, 5805, 5806, 7, 25, 0, 0, 5806, 5807, 7, 4, 0, 0, 5807, 5808, 7, 6, 0, 0, 5808, 5809, 7, 7, 0, 0, 5809, 5810, 7, 9, 0, 0, 5810, 186, 1, 0, 0, 0, 5811, 5812, 7, 0, 0, 0, 5812, 5813, 7, 12, 0, 0, 5813, 5814, 7, 4, 0, 0, 5814, 5815, 7, 2, 0, 0, 5815, 5816, 5, 95, 0, 0, 5816, 5817, 7, 11, 0, 0, 5817, 5818, 7, 2, 0, 0, 5818, 5819, 7, 17, 0, 0, 5819, 5820, 7, 10, 0, 0, 5820, 5821, 7, 7, 0, 0, 5821, 188, 1, 0, 0, 0, 5822, 5823, 7, 0, 0, 0, 5823, 5824, 7, 12, 0, 0, 5824, 5825, 7, 4, 0, 0, 5825, 5826, 7, 2, 0, 0, 5826, 5827, 7, 14, 0, 0, 5827, 5828, 7, 0, 0, 0, 5828, 5829, 7, 4, 0, 0, 5829, 5830, 7, 10, 0, 0, 5830, 5831, 7, 8, 0, 0, 5831, 190, 1, 0, 0, 0, 5832, 5833, 7, 0, 0, 0, 5833, 5834, 7, 12, 0, 0, 5834, 5835, 7, 4, 0, 0, 5835, 5836, 7, 2, 0, 0, 5836, 5837, 7, 7, 0, 0, 5837, 5838, 7, 2, 0, 0, 5838, 5839, 7, 14, 0, 0, 5839, 5840, 7, 2, 0, 0, 5840, 5841, 7, 12, 0, 0, 5841, 5842, 7, 5, 0, 0, 5842, 5843, 5, 95, 0, 0, 5843, 5844, 7, 4, 0, 0, 5844, 5845, 7, 3, 0, 0, 5845, 5846, 7, 0, 0, 0, 5846, 5847, 7, 7, 0, 0, 5847, 5848, 7, 5, 0, 0, 5848, 5849, 7, 0, 0, 0, 5849, 5850, 7, 8, 0, 0, 5850, 5851, 7, 4, 0, 0, 5851, 5852, 7, 10, 0, 0, 5852, 5853, 7, 2, 0, 0, 5853, 5854, 7, 7, 0, 0, 5854, 192, 1, 0, 0, 0, 5855, 5856, 7, 0, 0, 0, 5856, 5857, 7, 12, 0, 0, 5857, 5858, 7, 4, 0, 0, 5858, 5859, 7, 2, 0, 0, 5859, 5860, 5, 95, 0, 0, 5860, 5861, 7, 3, 0, 0, 5861, 5862, 7, 6, 0, 0, 5862, 5863, 7, 2, 0, 0, 5863, 5864, 7, 15, 0, 0, 5864, 5865, 7, 4, 0, 0, 5865, 5866, 7, 10, 0, 0, 5866, 5867, 7, 14, 0, 0, 5867, 5868, 7, 10, 0, 0, 5868, 5869, 7, 23, 0, 0, 5869, 5870, 7, 6, 0, 0, 5870, 194, 1, 0, 0, 0, 5871, 5872, 7, 0, 0, 0, 5872, 5873, 7, 13, 0, 0, 5873, 5874, 7, 0, 0, 0, 5874, 5875, 7, 10, 0, 0, 5875, 5876, 7, 11, 0, 0, 5876, 5877, 7, 0, 0, 0, 5877, 5878, 7, 1, 0, 0, 5878, 5879, 7, 10, 0, 0, 5879, 5880, 7, 11, 0, 0, 5880, 5881, 7, 10, 0, 0, 5881, 5882, 7, 4, 0, 0, 5882, 5883, 7, 18, 0, 0, 5883, 196, 1, 0, 0, 0, 5884, 5885, 7, 0, 0, 0, 5885, 5886, 7, 13, 0, 0, 5886, 5887, 7, 3, 0, 0, 5887, 5888, 7, 2, 0, 0, 5888, 198, 1, 0, 0, 0, 5889, 5890, 7, 1, 0, 0, 5890, 5891, 7, 0, 0, 0, 5891, 5892, 7, 8, 0, 0, 5892, 5893, 7, 21, 0, 0, 5893, 5894, 7, 17, 0, 0, 5894, 5895, 7, 3, 0, 0, 5895, 5896, 7, 2, 0, 0, 5896, 5897, 7, 12, 0, 0, 5897, 5898, 7, 7, 0, 0, 5898, 5899, 7, 9, 0, 0, 5899, 200, 1, 0, 0, 0, 5900, 5901, 7, 1, 0, 0, 5901, 5902, 7, 0, 0, 0, 5902, 5903, 7, 8, 0, 0, 5903, 5904, 7, 21, 0, 0, 5904, 5905, 7, 10, 0, 0, 5905, 5906, 7, 7, 0, 0, 5906, 5907, 7, 17, 0, 0, 5907, 5908, 7, 16, 0, 0, 5908, 5909, 7, 10, 0, 0, 5909, 5910, 7, 11, 0, 0, 5910, 5911, 7, 6, 0, 0, 5911, 202, 1, 0, 0, 0, 5912, 5913, 7, 1, 0, 0, 5913, 5914, 7, 0, 0, 0, 5914, 5915, 7, 8, 0, 0, 5915, 5916, 7, 21, 0, 0, 5916, 5917, 7, 12, 0, 0, 5917, 5918, 7, 15, 0, 0, 5918, 204, 1, 0, 0, 0, 5919, 5920, 7, 1, 0, 0, 5920, 5921, 7, 0, 0, 0, 5921, 5922, 7, 8, 0, 0, 5922, 5923, 7, 21, 0, 0, 5923, 5924, 7, 12, 0, 0, 5924, 5925, 7, 15, 0, 0, 5925, 5926, 7, 5, 0, 0, 5926, 206, 1, 0, 0, 0, 5927, 5928, 7, 1, 0, 0, 5928, 5929, 7, 0, 0, 0, 5929, 5930, 7, 8, 0, 0, 5930, 5931, 7, 21, 0, 0, 5931, 5932, 7, 12, 0, 0, 5932, 5933, 7, 15, 0, 0, 5933, 5934, 7, 5, 0, 0, 5934, 5935, 7, 6, 0, 0, 5935, 5936, 7, 4, 0, 0, 5936, 208, 1, 0, 0, 0, 5937, 5938, 7, 1, 0, 0, 5938, 5939, 7, 0, 0, 0, 5939, 5940, 7, 9, 0, 0, 5940, 5941, 7, 16, 0, 0, 5941, 5942, 7, 10, 0, 0, 5942, 5943, 7, 11, 0, 0, 5943, 5944, 7, 6, 0, 0, 5944, 210, 1, 0, 0, 0, 5945, 5946, 7, 1, 0, 0, 5946, 5947, 7, 0, 0, 0, 5947, 5948, 7, 5, 0, 0, 5948, 5949, 7, 10, 0, 0, 5949, 5950, 7, 8, 0, 0, 5950, 212, 1, 0, 0, 0, 5951, 5952, 7, 1, 0, 0, 5952, 5953, 7, 0, 0, 0, 5953, 5954, 7, 5, 0, 0, 5954, 5955, 7, 10, 0, 0, 5955, 5956, 7, 8, 0, 0, 5956, 5957, 7, 16, 0, 0, 5957, 5958, 7, 10, 0, 0, 5958, 5959, 7, 11, 0, 0, 5959, 5960, 7, 6, 0, 0, 5960, 214, 1, 0, 0, 0, 5961, 5962, 7, 1, 0, 0, 5962, 5963, 7, 0, 0, 0, 5963, 5964, 7, 4, 0, 0, 5964, 5965, 7, 8, 0, 0, 5965, 5966, 7, 19, 0, 0, 5966, 216, 1, 0, 0, 0, 5967, 5968, 7, 1, 0, 0, 5968, 5969, 7, 0, 0, 0, 5969, 5970, 7, 4, 0, 0, 5970, 5971, 7, 8, 0, 0, 5971, 5972, 7, 19, 0, 0, 5972, 5973, 7, 5, 0, 0, 5973, 5974, 7, 10, 0, 0, 5974, 5975, 7, 23, 0, 0, 5975, 5976, 7, 6, 0, 0, 5976, 218, 1, 0, 0, 0, 5977, 5978, 7, 1, 0, 0, 5978, 5979, 7, 0, 0, 0, 5979, 5980, 7, 4, 0, 0, 5980, 5981, 7, 8, 0, 0, 5981, 5982, 7, 19, 0, 0, 5982, 5983, 5, 95, 0, 0, 5983, 5984, 7, 4, 0, 0, 5984, 5985, 7, 0, 0, 0, 5985, 5986, 7, 1, 0, 0, 5986, 5987, 7, 11, 0, 0, 5987, 5988, 7, 6, 0, 0, 5988, 5989, 5, 95, 0, 0, 5989, 5990, 7, 0, 0, 0, 5990, 5991, 7, 8, 0, 0, 5991, 5992, 7, 8, 0, 0, 5992, 5993, 7, 6, 0, 0, 5993, 5994, 7, 5, 0, 0, 5994, 5995, 7, 5, 0, 0, 5995, 5996, 5, 95, 0, 0, 5996, 5997, 7, 1, 0, 0, 5997, 5998, 7, 18, 0, 0, 5998, 5999, 5, 95, 0, 0, 5999, 6000, 7, 3, 0, 0, 6000, 6001, 7, 2, 0, 0, 6001, 6002, 7, 22, 0, 0, 6002, 6003, 7, 10, 0, 0, 6003, 6004, 7, 9, 0, 0, 6004, 220, 1, 0, 0, 0, 6005, 6006, 7, 1, 0, 0, 6006, 6007, 7, 6, 0, 0, 6007, 6008, 7, 8, 0, 0, 6008, 6009, 7, 2, 0, 0, 6009, 6010, 7, 14, 0, 0, 6010, 6011, 7, 6, 0, 0, 6011, 222, 1, 0, 0, 0, 6012, 6013, 7, 1, 0, 0, 6013, 6014, 7, 6, 0, 0, 6014, 6015, 7, 16, 0, 0, 6015, 6016, 7, 2, 0, 0, 6016, 6017, 7, 3, 0, 0, 6017, 6018, 7, 6, 0, 0, 6018, 224, 1, 0, 0, 0, 6019, 6020, 7, 1, 0, 0, 6020, 6021, 7, 6, 0, 0, 6021, 6022, 7, 17, 0, 0, 6022, 6023, 7, 10, 0, 0, 6023, 6024, 7, 7, 0, 0, 6024, 226, 1, 0, 0, 0, 6025, 6026, 7, 1, 0, 0, 6026, 6027, 7, 6, 0, 0, 6027, 6028, 7, 17, 0, 0, 6028, 6029, 7, 10, 0, 0, 6029, 6030, 7, 7, 0, 0, 6030, 6031, 7, 7, 0, 0, 6031, 6032, 7, 10, 0, 0, 6032, 6033, 7, 7, 0, 0, 6033, 6034, 7, 17, 0, 0, 6034, 228, 1, 0, 0, 0, 6035, 6036, 7, 1, 0, 0, 6036, 6037, 7, 6, 0, 0, 6037, 6038, 7, 17, 0, 0, 6038, 6039, 7, 10, 0, 0, 6039, 6040, 7, 7, 0, 0, 6040, 6041, 5, 95, 0, 0, 6041, 6042, 7, 2, 0, 0, 6042, 6043, 7, 12, 0, 0, 6043, 6044, 7, 4, 0, 0, 6044, 6045, 7, 11, 0, 0, 6045, 6046, 7, 10, 0, 0, 6046, 6047, 7, 7, 0, 0, 6047, 6048, 7, 6, 0, 0, 6048, 6049, 5, 95, 0, 0, 6049, 6050, 7, 9, 0, 0, 6050, 6051, 7, 0, 0, 0, 6051, 6052, 7, 4, 0, 0, 6052, 6053, 7, 0, 0, 0, 6053, 230, 1, 0, 0, 0, 6054, 6055, 7, 1, 0, 0, 6055, 6056, 7, 6, 0, 0, 6056, 6057, 7, 19, 0, 0, 6057, 6058, 7, 0, 0, 0, 6058, 6059, 7, 11, 0, 0, 6059, 6060, 7, 16, 0, 0, 6060, 232, 1, 0, 0, 0, 6061, 6062, 7, 1, 0, 0, 6062, 6063, 7, 6, 0, 0, 6063, 6064, 7, 24, 0, 0, 6064, 6065, 7, 12, 0, 0, 6065, 6066, 7, 6, 0, 0, 6066, 6067, 7, 0, 0, 0, 6067, 6068, 7, 4, 0, 0, 6068, 6069, 7, 19, 0, 0, 6069, 234, 1, 0, 0, 0, 6070, 6071, 7, 1, 0, 0, 6071, 6072, 7, 6, 0, 0, 6072, 6073, 7, 4, 0, 0, 6073, 6074, 7, 22, 0, 0, 6074, 6075, 7, 6, 0, 0, 6075, 6076, 7, 6, 0, 0, 6076, 6077, 7, 7, 0, 0, 6077, 236, 1, 0, 0, 0, 6078, 6079, 7, 1, 0, 0, 6079, 6080, 7, 16, 0, 0, 6080, 6081, 7, 10, 0, 0, 6081, 6082, 7, 11, 0, 0, 6082, 6083, 7, 6, 0, 0, 6083, 238, 1, 0, 0, 0, 6084, 6085, 7, 1, 0, 0, 6085, 6086, 7, 16, 0, 0, 6086, 6087, 7, 10, 0, 0, 6087, 6088, 7, 11, 0, 0, 6088, 6089, 7, 6, 0, 0, 6089, 6090, 7, 7, 0, 0, 6090, 6091, 7, 0, 0, 0, 6091, 6092, 7, 14, 0, 0, 6092, 6093, 7, 6, 0, 0, 6093, 240, 1, 0, 0, 0, 6094, 6095, 7, 1, 0, 0, 6095, 6096, 7, 10, 0, 0, 6096, 6097, 7, 17, 0, 0, 6097, 242, 1, 0, 0, 0, 6098, 6099, 7, 1, 0, 0, 6099, 6100, 7, 10, 0, 0, 6100, 6101, 7, 17, 0, 0, 6101, 6102, 7, 16, 0, 0, 6102, 6103, 7, 10, 0, 0, 6103, 6104, 7, 11, 0, 0, 6104, 6105, 7, 6, 0, 0, 6105, 244, 1, 0, 0, 0, 6106, 6107, 7, 1, 0, 0, 6107, 6108, 7, 10, 0, 0, 6108, 6109, 7, 17, 0, 0, 6109, 6110, 7, 10, 0, 0, 6110, 6111, 7, 7, 0, 0, 6111, 6112, 7, 4, 0, 0, 6112, 246, 1, 0, 0, 0, 6113, 6114, 7, 1, 0, 0, 6114, 6115, 7, 10, 0, 0, 6115, 6116, 7, 7, 0, 0, 6116, 6117, 7, 0, 0, 0, 6117, 6118, 7, 3, 0, 0, 6118, 6119, 7, 18, 0, 0, 6119, 248, 1, 0, 0, 0, 6120, 6121, 7, 1, 0, 0, 6121, 6122, 7, 10, 0, 0, 6122, 6123, 7, 7, 0, 0, 6123, 6124, 7, 0, 0, 0, 6124, 6125, 7, 3, 0, 0, 6125, 6126, 7, 18, 0, 0, 6126, 6127, 5, 95, 0, 0, 6127, 6128, 7, 9, 0, 0, 6128, 6129, 7, 2, 0, 0, 6129, 6130, 7, 12, 0, 0, 6130, 6131, 7, 1, 0, 0, 6131, 6132, 7, 11, 0, 0, 6132, 6133, 7, 6, 0, 0, 6133, 250, 1, 0, 0, 0, 6134, 6135, 7, 1, 0, 0, 6135, 6136, 7, 10, 0, 0, 6136, 6137, 7, 7, 0, 0, 6137, 6138, 7, 0, 0, 0, 6138, 6139, 7, 3, 0, 0, 6139, 6140, 7, 18, 0, 0, 6140, 6141, 5, 95, 0, 0, 6141, 6142, 7, 9, 0, 0, 6142, 6143, 7, 2, 0, 0, 6143, 6144, 7, 12, 0, 0, 6144, 6145, 7, 1, 0, 0, 6145, 6146, 7, 11, 0, 0, 6146, 6147, 7, 6, 0, 0, 6147, 6148, 5, 95, 0, 0, 6148, 6149, 7, 10, 0, 0, 6149, 6150, 7, 7, 0, 0, 6150, 6151, 7, 16, 0, 0, 6151, 6152, 7, 10, 0, 0, 6152, 6153, 7, 7, 0, 0, 6153, 6154, 7, 10, 0, 0, 6154, 6155, 7, 4, 0, 0, 6155, 6156, 7, 18, 0, 0, 6156, 252, 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, 9, 0, 0, 6165, 6166, 7, 2, 0, 0, 6166, 6167, 7, 12, 0, 0, 6167, 6168, 7, 1, 0, 0, 6168, 6169, 7, 11, 0, 0, 6169, 6170, 7, 6, 0, 0, 6170, 6171, 5, 95, 0, 0, 6171, 6172, 7, 7, 0, 0, 6172, 6173, 7, 0, 0, 0, 6173, 6174, 7, 7, 0, 0, 6174, 254, 1, 0, 0, 0, 6175, 6176, 7, 1, 0, 0, 6176, 6177, 7, 10, 0, 0, 6177, 6178, 7, 7, 0, 0, 6178, 6179, 7, 0, 0, 0, 6179, 6180, 7, 3, 0, 0, 6180, 6181, 7, 18, 0, 0, 6181, 6182, 5, 95, 0, 0, 6182, 6183, 7, 16, 0, 0, 6183, 6184, 7, 11, 0, 0, 6184, 6185, 7, 2, 0, 0, 6185, 6186, 7, 0, 0, 0, 6186, 6187, 7, 4, 0, 0, 6187, 256, 1, 0, 0, 0, 6188, 6189, 7, 1, 0, 0, 6189, 6190, 7, 10, 0, 0, 6190, 6191, 7, 7, 0, 0, 6191, 6192, 7, 0, 0, 0, 6192, 6193, 7, 3, 0, 0, 6193, 6194, 7, 18, 0, 0, 6194, 6195, 5, 95, 0, 0, 6195, 6196, 7, 16, 0, 0, 6196, 6197, 7, 11, 0, 0, 6197, 6198, 7, 2, 0, 0, 6198, 6199, 7, 0, 0, 0, 6199, 6200, 7, 4, 0, 0, 6200, 6201, 5, 95, 0, 0, 6201, 6202, 7, 10, 0, 0, 6202, 6203, 7, 7, 0, 0, 6203, 6204, 7, 16, 0, 0, 6204, 6205, 7, 10, 0, 0, 6205, 6206, 7, 7, 0, 0, 6206, 6207, 7, 10, 0, 0, 6207, 6208, 7, 4, 0, 0, 6208, 6209, 7, 18, 0, 0, 6209, 258, 1, 0, 0, 0, 6210, 6211, 7, 1, 0, 0, 6211, 6212, 7, 10, 0, 0, 6212, 6213, 7, 7, 0, 0, 6213, 6214, 7, 0, 0, 0, 6214, 6215, 7, 3, 0, 0, 6215, 6216, 7, 18, 0, 0, 6216, 6217, 5, 95, 0, 0, 6217, 6218, 7, 16, 0, 0, 6218, 6219, 7, 11, 0, 0, 6219, 6220, 7, 2, 0, 0, 6220, 6221, 7, 0, 0, 0, 6221, 6222, 7, 4, 0, 0, 6222, 6223, 5, 95, 0, 0, 6223, 6224, 7, 7, 0, 0, 6224, 6225, 7, 0, 0, 0, 6225, 6226, 7, 7, 0, 0, 6226, 260, 1, 0, 0, 0, 6227, 6228, 7, 1, 0, 0, 6228, 6229, 7, 10, 0, 0, 6229, 6230, 7, 7, 0, 0, 6230, 6231, 7, 0, 0, 0, 6231, 6232, 7, 3, 0, 0, 6232, 6233, 7, 18, 0, 0, 6233, 6234, 5, 95, 0, 0, 6234, 6235, 7, 10, 0, 0, 6235, 6236, 7, 7, 0, 0, 6236, 6237, 7, 4, 0, 0, 6237, 6238, 7, 6, 0, 0, 6238, 6239, 7, 17, 0, 0, 6239, 6240, 7, 6, 0, 0, 6240, 6241, 7, 3, 0, 0, 6241, 262, 1, 0, 0, 0, 6242, 6243, 7, 1, 0, 0, 6243, 6244, 7, 10, 0, 0, 6244, 6245, 7, 7, 0, 0, 6245, 6246, 7, 9, 0, 0, 6246, 6247, 5, 95, 0, 0, 6247, 6248, 7, 0, 0, 0, 6248, 6249, 7, 22, 0, 0, 6249, 6250, 7, 0, 0, 0, 6250, 6251, 7, 3, 0, 0, 6251, 6252, 7, 6, 0, 0, 6252, 264, 1, 0, 0, 0, 6253, 6254, 7, 1, 0, 0, 6254, 6255, 7, 10, 0, 0, 6255, 6256, 7, 7, 0, 0, 6256, 6257, 7, 9, 0, 0, 6257, 6258, 7, 10, 0, 0, 6258, 6259, 7, 7, 0, 0, 6259, 6260, 7, 17, 0, 0, 6260, 266, 1, 0, 0, 0, 6261, 6262, 7, 1, 0, 0, 6262, 6263, 7, 10, 0, 0, 6263, 6264, 7, 7, 0, 0, 6264, 6265, 5, 95, 0, 0, 6265, 6266, 7, 4, 0, 0, 6266, 6267, 7, 2, 0, 0, 6267, 6268, 5, 95, 0, 0, 6268, 6269, 7, 7, 0, 0, 6269, 6270, 7, 12, 0, 0, 6270, 6271, 7, 14, 0, 0, 6271, 268, 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, 0, 0, 0, 6276, 6277, 7, 7, 0, 0, 6277, 6278, 7, 9, 0, 0, 6278, 270, 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, 5, 95, 0, 0, 6286, 6287, 7, 0, 0, 0, 6287, 6288, 7, 7, 0, 0, 6288, 6289, 7, 9, 0, 0, 6289, 272, 1, 0, 0, 0, 6290, 6291, 7, 1, 0, 0, 6291, 6292, 7, 10, 0, 0, 6292, 6293, 7, 4, 0, 0, 6293, 6294, 7, 14, 0, 0, 6294, 6295, 7, 0, 0, 0, 6295, 6296, 7, 15, 0, 0, 6296, 274, 1, 0, 0, 0, 6297, 6298, 7, 1, 0, 0, 6298, 6299, 7, 10, 0, 0, 6299, 6300, 7, 4, 0, 0, 6300, 6301, 7, 14, 0, 0, 6301, 6302, 7, 0, 0, 0, 6302, 6303, 7, 15, 0, 0, 6303, 6304, 7, 5, 0, 0, 6304, 276, 1, 0, 0, 0, 6305, 6306, 7, 1, 0, 0, 6306, 6307, 7, 10, 0, 0, 6307, 6308, 7, 4, 0, 0, 6308, 6309, 7, 14, 0, 0, 6309, 6310, 7, 0, 0, 0, 6310, 6311, 7, 15, 0, 0, 6311, 6312, 5, 95, 0, 0, 6312, 6313, 7, 4, 0, 0, 6313, 6314, 7, 3, 0, 0, 6314, 6315, 7, 6, 0, 0, 6315, 6316, 7, 6, 0, 0, 6316, 278, 1, 0, 0, 0, 6317, 6318, 7, 1, 0, 0, 6318, 6319, 7, 10, 0, 0, 6319, 6320, 7, 4, 0, 0, 6320, 6321, 7, 5, 0, 0, 6321, 280, 1, 0, 0, 0, 6322, 6323, 7, 1, 0, 0, 6323, 6324, 7, 11, 0, 0, 6324, 6325, 7, 0, 0, 0, 6325, 6326, 7, 7, 0, 0, 6326, 6327, 7, 21, 0, 0, 6327, 6328, 7, 5, 0, 0, 6328, 282, 1, 0, 0, 0, 6329, 6330, 7, 1, 0, 0, 6330, 6331, 7, 11, 0, 0, 6331, 6332, 7, 2, 0, 0, 6332, 6333, 7, 1, 0, 0, 6333, 284, 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, 286, 1, 0, 0, 0, 6340, 6341, 7, 1, 0, 0, 6341, 6342, 7, 11, 0, 0, 6342, 6343, 7, 2, 0, 0, 6343, 6344, 7, 8, 0, 0, 6344, 6345, 7, 21, 0, 0, 6345, 6346, 5, 95, 0, 0, 6346, 6347, 7, 3, 0, 0, 6347, 6348, 7, 0, 0, 0, 6348, 6349, 7, 7, 0, 0, 6349, 6350, 7, 17, 0, 0, 6350, 6351, 7, 6, 0, 0, 6351, 288, 1, 0, 0, 0, 6352, 6353, 7, 1, 0, 0, 6353, 6354, 7, 11, 0, 0, 6354, 6355, 7, 2, 0, 0, 6355, 6356, 7, 8, 0, 0, 6356, 6357, 7, 21, 0, 0, 6357, 6358, 7, 5, 0, 0, 6358, 290, 1, 0, 0, 0, 6359, 6360, 7, 1, 0, 0, 6360, 6361, 7, 11, 0, 0, 6361, 6362, 7, 2, 0, 0, 6362, 6363, 7, 8, 0, 0, 6363, 6364, 7, 21, 0, 0, 6364, 6365, 7, 5, 0, 0, 6365, 6366, 7, 10, 0, 0, 6366, 6367, 7, 23, 0, 0, 6367, 6368, 7, 6, 0, 0, 6368, 292, 1, 0, 0, 0, 6369, 6370, 7, 1, 0, 0, 6370, 6371, 7, 2, 0, 0, 6371, 6372, 7, 9, 0, 0, 6372, 6373, 7, 18, 0, 0, 6373, 294, 1, 0, 0, 0, 6374, 6375, 7, 1, 0, 0, 6375, 6376, 7, 2, 0, 0, 6376, 6377, 7, 2, 0, 0, 6377, 6378, 7, 11, 0, 0, 6378, 6379, 7, 6, 0, 0, 6379, 6380, 7, 0, 0, 0, 6380, 6381, 7, 7, 0, 0, 6381, 296, 1, 0, 0, 0, 6382, 6383, 7, 1, 0, 0, 6383, 6384, 7, 2, 0, 0, 6384, 6385, 7, 4, 0, 0, 6385, 6386, 7, 19, 0, 0, 6386, 298, 1, 0, 0, 0, 6387, 6388, 7, 1, 0, 0, 6388, 6389, 7, 2, 0, 0, 6389, 6390, 7, 12, 0, 0, 6390, 6391, 7, 7, 0, 0, 6391, 6392, 7, 9, 0, 0, 6392, 300, 1, 0, 0, 0, 6393, 6394, 7, 1, 0, 0, 6394, 6395, 7, 3, 0, 0, 6395, 6396, 7, 0, 0, 0, 6396, 6397, 7, 7, 0, 0, 6397, 6398, 7, 8, 0, 0, 6398, 6399, 7, 19, 0, 0, 6399, 302, 1, 0, 0, 0, 6400, 6401, 7, 1, 0, 0, 6401, 6402, 7, 3, 0, 0, 6402, 6403, 7, 6, 0, 0, 6403, 6404, 7, 0, 0, 0, 6404, 6405, 7, 9, 0, 0, 6405, 6406, 7, 4, 0, 0, 6406, 6407, 7, 19, 0, 0, 6407, 304, 1, 0, 0, 0, 6408, 6409, 7, 1, 0, 0, 6409, 6410, 7, 3, 0, 0, 6410, 6411, 7, 2, 0, 0, 6411, 6412, 7, 0, 0, 0, 6412, 6413, 7, 9, 0, 0, 6413, 6414, 7, 8, 0, 0, 6414, 6415, 7, 0, 0, 0, 6415, 6416, 7, 5, 0, 0, 6416, 6417, 7, 4, 0, 0, 6417, 306, 1, 0, 0, 0, 6418, 6419, 7, 1, 0, 0, 6419, 6420, 7, 5, 0, 0, 6420, 6421, 7, 2, 0, 0, 6421, 6422, 7, 7, 0, 0, 6422, 308, 1, 0, 0, 0, 6423, 6424, 7, 1, 0, 0, 6424, 6425, 7, 12, 0, 0, 6425, 6426, 7, 16, 0, 0, 6426, 6427, 7, 16, 0, 0, 6427, 6428, 7, 6, 0, 0, 6428, 6429, 7, 3, 0, 0, 6429, 310, 1, 0, 0, 0, 6430, 6431, 7, 1, 0, 0, 6431, 6432, 7, 12, 0, 0, 6432, 6433, 7, 16, 0, 0, 6433, 6434, 7, 16, 0, 0, 6434, 6435, 7, 6, 0, 0, 6435, 6436, 7, 3, 0, 0, 6436, 6437, 5, 95, 0, 0, 6437, 6438, 7, 8, 0, 0, 6438, 6439, 7, 0, 0, 0, 6439, 6440, 7, 8, 0, 0, 6440, 6441, 7, 19, 0, 0, 6441, 6442, 7, 6, 0, 0, 6442, 312, 1, 0, 0, 0, 6443, 6444, 7, 1, 0, 0, 6444, 6445, 7, 12, 0, 0, 6445, 6446, 7, 16, 0, 0, 6446, 6447, 7, 16, 0, 0, 6447, 6448, 7, 6, 0, 0, 6448, 6449, 7, 3, 0, 0, 6449, 6450, 5, 95, 0, 0, 6450, 6451, 7, 15, 0, 0, 6451, 6452, 7, 2, 0, 0, 6452, 6453, 7, 2, 0, 0, 6453, 6454, 7, 11, 0, 0, 6454, 314, 1, 0, 0, 0, 6455, 6456, 7, 1, 0, 0, 6456, 6457, 7, 12, 0, 0, 6457, 6458, 7, 10, 0, 0, 6458, 6459, 7, 11, 0, 0, 6459, 6460, 7, 9, 0, 0, 6460, 316, 1, 0, 0, 0, 6461, 6462, 7, 1, 0, 0, 6462, 6463, 7, 12, 0, 0, 6463, 6464, 7, 11, 0, 0, 6464, 6465, 7, 21, 0, 0, 6465, 318, 1, 0, 0, 0, 6466, 6467, 7, 1, 0, 0, 6467, 6468, 7, 18, 0, 0, 6468, 320, 1, 0, 0, 0, 6469, 6470, 7, 1, 0, 0, 6470, 6471, 7, 18, 0, 0, 6471, 6472, 7, 15, 0, 0, 6472, 6473, 7, 0, 0, 0, 6473, 6474, 7, 5, 0, 0, 6474, 6475, 7, 5, 0, 0, 6475, 6476, 5, 95, 0, 0, 6476, 6477, 7, 3, 0, 0, 6477, 6478, 7, 6, 0, 0, 6478, 6479, 7, 8, 0, 0, 6479, 6480, 7, 12, 0, 0, 6480, 6481, 7, 3, 0, 0, 6481, 6482, 7, 5, 0, 0, 6482, 6483, 7, 10, 0, 0, 6483, 6484, 7, 13, 0, 0, 6484, 6485, 7, 6, 0, 0, 6485, 6486, 5, 95, 0, 0, 6486, 6487, 7, 8, 0, 0, 6487, 6488, 7, 19, 0, 0, 6488, 6489, 7, 6, 0, 0, 6489, 6490, 7, 8, 0, 0, 6490, 6491, 7, 21, 0, 0, 6491, 322, 1, 0, 0, 0, 6492, 6493, 7, 1, 0, 0, 6493, 6494, 7, 18, 0, 0, 6494, 6495, 7, 15, 0, 0, 6495, 6496, 7, 0, 0, 0, 6496, 6497, 7, 5, 0, 0, 6497, 6498, 7, 5, 0, 0, 6498, 6499, 5, 95, 0, 0, 6499, 6500, 7, 12, 0, 0, 6500, 6501, 7, 20, 0, 0, 6501, 6502, 7, 13, 0, 0, 6502, 6503, 7, 8, 0, 0, 6503, 324, 1, 0, 0, 0, 6504, 6505, 7, 1, 0, 0, 6505, 6506, 7, 18, 0, 0, 6506, 6507, 7, 4, 0, 0, 6507, 6508, 7, 6, 0, 0, 6508, 326, 1, 0, 0, 0, 6509, 6510, 7, 1, 0, 0, 6510, 6511, 7, 18, 0, 0, 6511, 6512, 7, 4, 0, 0, 6512, 6513, 7, 6, 0, 0, 6513, 6514, 7, 5, 0, 0, 6514, 328, 1, 0, 0, 0, 6515, 6516, 7, 1, 0, 0, 6516, 6517, 7, 18, 0, 0, 6517, 6518, 7, 4, 0, 0, 6518, 6519, 7, 6, 0, 0, 6519, 6520, 7, 2, 0, 0, 6520, 6521, 7, 3, 0, 0, 6521, 6522, 7, 9, 0, 0, 6522, 6523, 7, 6, 0, 0, 6523, 6524, 7, 3, 0, 0, 6524, 6525, 7, 14, 0, 0, 6525, 6526, 7, 0, 0, 0, 6526, 6527, 7, 3, 0, 0, 6527, 6528, 7, 21, 0, 0, 6528, 330, 1, 0, 0, 0, 6529, 6530, 7, 8, 0, 0, 6530, 6531, 7, 0, 0, 0, 6531, 6532, 7, 8, 0, 0, 6532, 6533, 7, 19, 0, 0, 6533, 6534, 7, 6, 0, 0, 6534, 332, 1, 0, 0, 0, 6535, 6536, 7, 8, 0, 0, 6536, 6537, 7, 0, 0, 0, 6537, 6538, 7, 8, 0, 0, 6538, 6539, 7, 19, 0, 0, 6539, 6540, 7, 6, 0, 0, 6540, 6541, 5, 95, 0, 0, 6541, 6542, 7, 8, 0, 0, 6542, 6543, 7, 1, 0, 0, 6543, 334, 1, 0, 0, 0, 6544, 6545, 7, 8, 0, 0, 6545, 6546, 7, 0, 0, 0, 6546, 6547, 7, 8, 0, 0, 6547, 6548, 7, 19, 0, 0, 6548, 6549, 7, 6, 0, 0, 6549, 6550, 5, 95, 0, 0, 6550, 6551, 7, 10, 0, 0, 6551, 6552, 7, 7, 0, 0, 6552, 6553, 7, 5, 0, 0, 6553, 6554, 7, 4, 0, 0, 6554, 6555, 7, 0, 0, 0, 6555, 6556, 7, 7, 0, 0, 6556, 6557, 7, 8, 0, 0, 6557, 6558, 7, 6, 0, 0, 6558, 6559, 7, 5, 0, 0, 6559, 336, 1, 0, 0, 0, 6560, 6561, 7, 8, 0, 0, 6561, 6562, 7, 0, 0, 0, 6562, 6563, 7, 8, 0, 0, 6563, 6564, 7, 19, 0, 0, 6564, 6565, 7, 6, 0, 0, 6565, 6566, 5, 95, 0, 0, 6566, 6567, 7, 4, 0, 0, 6567, 6568, 7, 6, 0, 0, 6568, 6569, 7, 14, 0, 0, 6569, 6570, 7, 15, 0, 0, 6570, 6571, 5, 95, 0, 0, 6571, 6572, 7, 4, 0, 0, 6572, 6573, 7, 0, 0, 0, 6573, 6574, 7, 1, 0, 0, 6574, 6575, 7, 11, 0, 0, 6575, 6576, 7, 6, 0, 0, 6576, 338, 1, 0, 0, 0, 6577, 6578, 7, 8, 0, 0, 6578, 6579, 7, 0, 0, 0, 6579, 6580, 7, 8, 0, 0, 6580, 6581, 7, 19, 0, 0, 6581, 6582, 7, 10, 0, 0, 6582, 6583, 7, 7, 0, 0, 6583, 6584, 7, 17, 0, 0, 6584, 340, 1, 0, 0, 0, 6585, 6586, 7, 8, 0, 0, 6586, 6587, 7, 0, 0, 0, 6587, 6588, 7, 11, 0, 0, 6588, 6589, 7, 8, 0, 0, 6589, 6590, 7, 12, 0, 0, 6590, 6591, 7, 11, 0, 0, 6591, 6592, 7, 0, 0, 0, 6592, 6593, 7, 4, 0, 0, 6593, 6594, 7, 6, 0, 0, 6594, 6595, 7, 9, 0, 0, 6595, 342, 1, 0, 0, 0, 6596, 6597, 7, 8, 0, 0, 6597, 6598, 7, 0, 0, 0, 6598, 6599, 7, 11, 0, 0, 6599, 6600, 7, 11, 0, 0, 6600, 6601, 7, 1, 0, 0, 6601, 6602, 7, 0, 0, 0, 6602, 6603, 7, 8, 0, 0, 6603, 6604, 7, 21, 0, 0, 6604, 344, 1, 0, 0, 0, 6605, 6606, 7, 8, 0, 0, 6606, 6607, 7, 0, 0, 0, 6607, 6608, 7, 11, 0, 0, 6608, 6609, 7, 11, 0, 0, 6609, 346, 1, 0, 0, 0, 6610, 6611, 7, 8, 0, 0, 6611, 6612, 7, 0, 0, 0, 6612, 6613, 7, 7, 0, 0, 6613, 6614, 7, 8, 0, 0, 6614, 6615, 7, 6, 0, 0, 6615, 6616, 7, 11, 0, 0, 6616, 348, 1, 0, 0, 0, 6617, 6618, 7, 8, 0, 0, 6618, 6619, 7, 0, 0, 0, 6619, 6620, 7, 7, 0, 0, 6620, 6621, 7, 2, 0, 0, 6621, 6622, 7, 7, 0, 0, 6622, 6623, 7, 10, 0, 0, 6623, 6624, 7, 8, 0, 0, 6624, 6625, 7, 0, 0, 0, 6625, 6626, 7, 11, 0, 0, 6626, 350, 1, 0, 0, 0, 6627, 6628, 7, 8, 0, 0, 6628, 6629, 7, 0, 0, 0, 6629, 6630, 7, 15, 0, 0, 6630, 6631, 7, 0, 0, 0, 6631, 6632, 7, 8, 0, 0, 6632, 6633, 7, 10, 0, 0, 6633, 6634, 7, 4, 0, 0, 6634, 6635, 7, 18, 0, 0, 6635, 352, 1, 0, 0, 0, 6636, 6637, 7, 8, 0, 0, 6637, 6638, 7, 0, 0, 0, 6638, 6639, 7, 15, 0, 0, 6639, 6640, 7, 4, 0, 0, 6640, 6641, 7, 10, 0, 0, 6641, 6642, 7, 2, 0, 0, 6642, 6643, 7, 7, 0, 0, 6643, 354, 1, 0, 0, 0, 6644, 6645, 7, 8, 0, 0, 6645, 6646, 7, 0, 0, 0, 6646, 6647, 7, 3, 0, 0, 6647, 6648, 7, 9, 0, 0, 6648, 6649, 7, 10, 0, 0, 6649, 6650, 7, 7, 0, 0, 6650, 6651, 7, 0, 0, 0, 6651, 6652, 7, 11, 0, 0, 6652, 6653, 7, 10, 0, 0, 6653, 6654, 7, 4, 0, 0, 6654, 6655, 7, 18, 0, 0, 6655, 356, 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, 8, 0, 0, 6660, 6661, 7, 0, 0, 0, 6661, 6662, 7, 9, 0, 0, 6662, 6663, 7, 6, 0, 0, 6663, 358, 1, 0, 0, 0, 6664, 6665, 7, 8, 0, 0, 6665, 6666, 7, 0, 0, 0, 6666, 6667, 7, 5, 0, 0, 6667, 6668, 7, 6, 0, 0, 6668, 360, 1, 0, 0, 0, 6669, 6670, 7, 8, 0, 0, 6670, 6671, 7, 0, 0, 0, 6671, 6672, 7, 5, 0, 0, 6672, 6673, 7, 4, 0, 0, 6673, 362, 1, 0, 0, 0, 6674, 6675, 7, 8, 0, 0, 6675, 6676, 7, 0, 0, 0, 6676, 6677, 7, 5, 0, 0, 6677, 6678, 7, 6, 0, 0, 6678, 6679, 5, 45, 0, 0, 6679, 6680, 7, 5, 0, 0, 6680, 6681, 7, 6, 0, 0, 6681, 6682, 7, 7, 0, 0, 6682, 6683, 7, 5, 0, 0, 6683, 6684, 7, 10, 0, 0, 6684, 6685, 7, 4, 0, 0, 6685, 6686, 7, 10, 0, 0, 6686, 6687, 7, 13, 0, 0, 6687, 6688, 7, 6, 0, 0, 6688, 364, 1, 0, 0, 0, 6689, 6690, 7, 8, 0, 0, 6690, 6691, 7, 0, 0, 0, 6691, 6692, 7, 4, 0, 0, 6692, 6693, 7, 6, 0, 0, 6693, 6694, 7, 17, 0, 0, 6694, 6695, 7, 2, 0, 0, 6695, 6696, 7, 3, 0, 0, 6696, 6697, 7, 18, 0, 0, 6697, 366, 1, 0, 0, 0, 6698, 6699, 7, 8, 0, 0, 6699, 6700, 7, 9, 0, 0, 6700, 6701, 7, 1, 0, 0, 6701, 6702, 5, 36, 0, 0, 6702, 6703, 7, 9, 0, 0, 6703, 6704, 7, 6, 0, 0, 6704, 6705, 7, 16, 0, 0, 6705, 6706, 7, 0, 0, 0, 6706, 6707, 7, 12, 0, 0, 6707, 6708, 7, 11, 0, 0, 6708, 6709, 7, 4, 0, 0, 6709, 368, 1, 0, 0, 0, 6710, 6711, 7, 8, 0, 0, 6711, 6712, 7, 6, 0, 0, 6712, 6713, 7, 10, 0, 0, 6713, 6714, 7, 11, 0, 0, 6714, 370, 1, 0, 0, 0, 6715, 6716, 7, 8, 0, 0, 6716, 6717, 7, 6, 0, 0, 6717, 6718, 7, 11, 0, 0, 6718, 6719, 7, 11, 0, 0, 6719, 6720, 5, 95, 0, 0, 6720, 6721, 7, 16, 0, 0, 6721, 6722, 7, 11, 0, 0, 6722, 6723, 7, 0, 0, 0, 6723, 6724, 7, 5, 0, 0, 6724, 6725, 7, 19, 0, 0, 6725, 6726, 5, 95, 0, 0, 6726, 6727, 7, 8, 0, 0, 6727, 6728, 7, 0, 0, 0, 6728, 6729, 7, 8, 0, 0, 6729, 6730, 7, 19, 0, 0, 6730, 6731, 7, 6, 0, 0, 6731, 372, 1, 0, 0, 0, 6732, 6733, 7, 8, 0, 0, 6733, 6734, 7, 6, 0, 0, 6734, 6735, 7, 3, 0, 0, 6735, 6736, 7, 4, 0, 0, 6736, 6737, 7, 10, 0, 0, 6737, 6738, 7, 16, 0, 0, 6738, 6739, 7, 10, 0, 0, 6739, 6740, 7, 8, 0, 0, 6740, 6741, 7, 0, 0, 0, 6741, 6742, 7, 4, 0, 0, 6742, 6743, 7, 6, 0, 0, 6743, 374, 1, 0, 0, 0, 6744, 6745, 7, 8, 0, 0, 6745, 6746, 7, 16, 0, 0, 6746, 6747, 7, 10, 0, 0, 6747, 6748, 7, 11, 0, 0, 6748, 6749, 7, 6, 0, 0, 6749, 376, 1, 0, 0, 0, 6750, 6751, 7, 8, 0, 0, 6751, 6752, 7, 19, 0, 0, 6752, 6753, 7, 0, 0, 0, 6753, 6754, 7, 10, 0, 0, 6754, 6755, 7, 7, 0, 0, 6755, 6756, 7, 6, 0, 0, 6756, 6757, 7, 9, 0, 0, 6757, 378, 1, 0, 0, 0, 6758, 6759, 7, 8, 0, 0, 6759, 6760, 7, 19, 0, 0, 6760, 6761, 7, 0, 0, 0, 6761, 6762, 7, 7, 0, 0, 6762, 6763, 7, 17, 0, 0, 6763, 6764, 7, 6, 0, 0, 6764, 380, 1, 0, 0, 0, 6765, 6766, 7, 8, 0, 0, 6766, 6767, 7, 19, 0, 0, 6767, 6768, 7, 0, 0, 0, 6768, 6769, 7, 7, 0, 0, 6769, 6770, 7, 17, 0, 0, 6770, 6771, 7, 6, 0, 0, 6771, 6772, 7, 4, 0, 0, 6772, 6773, 7, 3, 0, 0, 6773, 6774, 7, 0, 0, 0, 6774, 6775, 7, 8, 0, 0, 6775, 6776, 7, 21, 0, 0, 6776, 6777, 7, 10, 0, 0, 6777, 6778, 7, 7, 0, 0, 6778, 6779, 7, 17, 0, 0, 6779, 382, 1, 0, 0, 0, 6780, 6781, 7, 8, 0, 0, 6781, 6782, 7, 19, 0, 0, 6782, 6783, 7, 0, 0, 0, 6783, 6784, 7, 7, 0, 0, 6784, 6785, 7, 17, 0, 0, 6785, 6786, 7, 6, 0, 0, 6786, 6787, 5, 95, 0, 0, 6787, 6788, 7, 9, 0, 0, 6788, 6789, 7, 12, 0, 0, 6789, 6790, 7, 15, 0, 0, 6790, 6791, 7, 21, 0, 0, 6791, 6792, 7, 6, 0, 0, 6792, 6793, 7, 18, 0, 0, 6793, 6794, 5, 95, 0, 0, 6794, 6795, 7, 6, 0, 0, 6795, 6796, 7, 3, 0, 0, 6796, 6797, 7, 3, 0, 0, 6797, 6798, 7, 2, 0, 0, 6798, 6799, 7, 3, 0, 0, 6799, 6800, 5, 95, 0, 0, 6800, 6801, 7, 10, 0, 0, 6801, 6802, 7, 7, 0, 0, 6802, 6803, 7, 9, 0, 0, 6803, 6804, 7, 6, 0, 0, 6804, 6805, 7, 25, 0, 0, 6805, 384, 1, 0, 0, 0, 6806, 6807, 7, 8, 0, 0, 6807, 6808, 7, 19, 0, 0, 6808, 6809, 7, 0, 0, 0, 6809, 6810, 7, 3, 0, 0, 6810, 6811, 7, 0, 0, 0, 6811, 6812, 7, 8, 0, 0, 6812, 6813, 7, 4, 0, 0, 6813, 6814, 7, 6, 0, 0, 6814, 6815, 7, 3, 0, 0, 6815, 386, 1, 0, 0, 0, 6816, 6817, 7, 8, 0, 0, 6817, 6818, 7, 19, 0, 0, 6818, 6819, 7, 0, 0, 0, 6819, 6820, 7, 3, 0, 0, 6820, 6821, 7, 0, 0, 0, 6821, 6822, 7, 8, 0, 0, 6822, 6823, 7, 4, 0, 0, 6823, 6824, 7, 6, 0, 0, 6824, 6825, 7, 3, 0, 0, 6825, 6826, 7, 5, 0, 0, 6826, 388, 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, 7, 0, 0, 0, 6832, 6833, 7, 8, 0, 0, 6833, 6834, 7, 4, 0, 0, 6834, 6835, 7, 6, 0, 0, 6835, 6836, 7, 3, 0, 0, 6836, 6837, 7, 5, 0, 0, 6837, 6838, 7, 6, 0, 0, 6838, 6839, 7, 4, 0, 0, 6839, 390, 1, 0, 0, 0, 6840, 6841, 7, 8, 0, 0, 6841, 6842, 7, 19, 0, 0, 6842, 6843, 7, 0, 0, 0, 6843, 6844, 7, 3, 0, 0, 6844, 392, 1, 0, 0, 0, 6845, 6846, 7, 8, 0, 0, 6846, 6847, 7, 19, 0, 0, 6847, 6848, 7, 0, 0, 0, 6848, 6849, 7, 3, 0, 0, 6849, 6850, 5, 95, 0, 0, 6850, 6851, 7, 8, 0, 0, 6851, 6852, 7, 5, 0, 0, 6852, 394, 1, 0, 0, 0, 6853, 6854, 7, 8, 0, 0, 6854, 6855, 7, 19, 0, 0, 6855, 6856, 7, 0, 0, 0, 6856, 6857, 7, 3, 0, 0, 6857, 6858, 7, 4, 0, 0, 6858, 6859, 7, 2, 0, 0, 6859, 6860, 7, 3, 0, 0, 6860, 6861, 7, 2, 0, 0, 6861, 6862, 7, 22, 0, 0, 6862, 6863, 7, 10, 0, 0, 6863, 6864, 7, 9, 0, 0, 6864, 396, 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, 6871, 5, 95, 0, 0, 6871, 6872, 7, 0, 0, 0, 6872, 6873, 7, 8, 0, 0, 6873, 6874, 7, 11, 0, 0, 6874, 6875, 5, 95, 0, 0, 6875, 6876, 7, 3, 0, 0, 6876, 6877, 7, 6, 0, 0, 6877, 6878, 7, 22, 0, 0, 6878, 6879, 7, 3, 0, 0, 6879, 6880, 7, 10, 0, 0, 6880, 6881, 7, 4, 0, 0, 6881, 6882, 7, 6, 0, 0, 6882, 398, 1, 0, 0, 0, 6883, 6884, 7, 8, 0, 0, 6884, 6885, 7, 19, 0, 0, 6885, 6886, 7, 6, 0, 0, 6886, 6887, 7, 8, 0, 0, 6887, 6888, 7, 21, 0, 0, 6888, 400, 1, 0, 0, 0, 6889, 6890, 7, 8, 0, 0, 6890, 6891, 7, 19, 0, 0, 6891, 6892, 7, 6, 0, 0, 6892, 6893, 7, 8, 0, 0, 6893, 6894, 7, 21, 0, 0, 6894, 6895, 7, 15, 0, 0, 6895, 6896, 7, 2, 0, 0, 6896, 6897, 7, 10, 0, 0, 6897, 6898, 7, 7, 0, 0, 6898, 6899, 7, 4, 0, 0, 6899, 402, 1, 0, 0, 0, 6900, 6901, 7, 8, 0, 0, 6901, 6902, 7, 19, 0, 0, 6902, 6903, 7, 10, 0, 0, 6903, 6904, 7, 11, 0, 0, 6904, 6905, 7, 9, 0, 0, 6905, 404, 1, 0, 0, 0, 6906, 6907, 7, 8, 0, 0, 6907, 6908, 7, 19, 0, 0, 6908, 6909, 7, 2, 0, 0, 6909, 6910, 7, 2, 0, 0, 6910, 6911, 7, 5, 0, 0, 6911, 6912, 7, 6, 0, 0, 6912, 406, 1, 0, 0, 0, 6913, 6914, 7, 8, 0, 0, 6914, 6915, 7, 19, 0, 0, 6915, 6916, 7, 3, 0, 0, 6916, 408, 1, 0, 0, 0, 6917, 6918, 7, 8, 0, 0, 6918, 6919, 7, 19, 0, 0, 6919, 6920, 7, 12, 0, 0, 6920, 6921, 7, 7, 0, 0, 6921, 6922, 7, 21, 0, 0, 6922, 410, 1, 0, 0, 0, 6923, 6924, 7, 8, 0, 0, 6924, 6925, 7, 11, 0, 0, 6925, 6926, 7, 0, 0, 0, 6926, 6927, 7, 5, 0, 0, 6927, 6928, 7, 5, 0, 0, 6928, 412, 1, 0, 0, 0, 6929, 6930, 7, 8, 0, 0, 6930, 6931, 7, 11, 0, 0, 6931, 6932, 7, 0, 0, 0, 6932, 6933, 7, 5, 0, 0, 6933, 6934, 7, 5, 0, 0, 6934, 6935, 7, 10, 0, 0, 6935, 6936, 7, 16, 0, 0, 6936, 6937, 7, 10, 0, 0, 6937, 6938, 7, 8, 0, 0, 6938, 6939, 7, 0, 0, 0, 6939, 6940, 7, 4, 0, 0, 6940, 6941, 7, 10, 0, 0, 6941, 6942, 7, 2, 0, 0, 6942, 6943, 7, 7, 0, 0, 6943, 414, 1, 0, 0, 0, 6944, 6945, 7, 8, 0, 0, 6945, 6946, 7, 11, 0, 0, 6946, 6947, 7, 0, 0, 0, 6947, 6948, 7, 5, 0, 0, 6948, 6949, 7, 5, 0, 0, 6949, 6950, 7, 10, 0, 0, 6950, 6951, 7, 16, 0, 0, 6951, 6952, 7, 10, 0, 0, 6952, 6953, 7, 6, 0, 0, 6953, 6954, 7, 3, 0, 0, 6954, 416, 1, 0, 0, 0, 6955, 6956, 7, 8, 0, 0, 6956, 6957, 7, 11, 0, 0, 6957, 6958, 7, 0, 0, 0, 6958, 6959, 7, 12, 0, 0, 6959, 6960, 7, 5, 0, 0, 6960, 6961, 7, 6, 0, 0, 6961, 418, 1, 0, 0, 0, 6962, 6963, 7, 8, 0, 0, 6963, 6964, 7, 11, 0, 0, 6964, 6965, 7, 6, 0, 0, 6965, 6966, 7, 0, 0, 0, 6966, 6967, 7, 7, 0, 0, 6967, 420, 1, 0, 0, 0, 6968, 6969, 7, 8, 0, 0, 6969, 6970, 7, 11, 0, 0, 6970, 6971, 7, 6, 0, 0, 6971, 6972, 7, 0, 0, 0, 6972, 6973, 7, 7, 0, 0, 6973, 6974, 7, 12, 0, 0, 6974, 6975, 7, 15, 0, 0, 6975, 422, 1, 0, 0, 0, 6976, 6977, 7, 8, 0, 0, 6977, 6978, 7, 11, 0, 0, 6978, 6979, 7, 6, 0, 0, 6979, 6980, 7, 0, 0, 0, 6980, 6981, 7, 3, 0, 0, 6981, 424, 1, 0, 0, 0, 6982, 6983, 7, 8, 0, 0, 6983, 426, 1, 0, 0, 0, 6984, 6985, 7, 8, 0, 0, 6985, 6986, 7, 11, 0, 0, 6986, 6987, 7, 10, 0, 0, 6987, 6988, 7, 6, 0, 0, 6988, 6989, 7, 7, 0, 0, 6989, 6990, 7, 4, 0, 0, 6990, 428, 1, 0, 0, 0, 6991, 6992, 7, 8, 0, 0, 6992, 6993, 7, 11, 0, 0, 6993, 6994, 7, 2, 0, 0, 6994, 6995, 7, 1, 0, 0, 6995, 430, 1, 0, 0, 0, 6996, 6997, 7, 8, 0, 0, 6997, 6998, 7, 11, 0, 0, 6998, 6999, 7, 2, 0, 0, 6999, 7000, 7, 7, 0, 0, 7000, 7001, 7, 6, 0, 0, 7001, 432, 1, 0, 0, 0, 7002, 7003, 7, 8, 0, 0, 7003, 7004, 7, 11, 0, 0, 7004, 7005, 7, 2, 0, 0, 7005, 7006, 7, 5, 0, 0, 7006, 7007, 7, 6, 0, 0, 7007, 7008, 5, 95, 0, 0, 7008, 7009, 7, 8, 0, 0, 7009, 7010, 7, 0, 0, 0, 7010, 7011, 7, 8, 0, 0, 7011, 7012, 7, 19, 0, 0, 7012, 7013, 7, 6, 0, 0, 7013, 7014, 7, 9, 0, 0, 7014, 7015, 5, 95, 0, 0, 7015, 7016, 7, 2, 0, 0, 7016, 7017, 7, 15, 0, 0, 7017, 7018, 7, 6, 0, 0, 7018, 7019, 7, 7, 0, 0, 7019, 7020, 5, 95, 0, 0, 7020, 7021, 7, 8, 0, 0, 7021, 7022, 7, 12, 0, 0, 7022, 7023, 7, 3, 0, 0, 7023, 7024, 7, 5, 0, 0, 7024, 7025, 7, 2, 0, 0, 7025, 7026, 7, 3, 0, 0, 7026, 7027, 7, 5, 0, 0, 7027, 434, 1, 0, 0, 0, 7028, 7029, 7, 8, 0, 0, 7029, 7030, 7, 11, 0, 0, 7030, 7031, 7, 2, 0, 0, 7031, 7032, 7, 5, 0, 0, 7032, 7033, 7, 6, 0, 0, 7033, 436, 1, 0, 0, 0, 7034, 7035, 7, 8, 0, 0, 7035, 7036, 7, 11, 0, 0, 7036, 7037, 7, 12, 0, 0, 7037, 7038, 7, 5, 0, 0, 7038, 7039, 7, 4, 0, 0, 7039, 7040, 7, 6, 0, 0, 7040, 7041, 7, 3, 0, 0, 7041, 7042, 5, 95, 0, 0, 7042, 7043, 7, 1, 0, 0, 7043, 7044, 7, 18, 0, 0, 7044, 7045, 5, 95, 0, 0, 7045, 7046, 7, 3, 0, 0, 7046, 7047, 7, 2, 0, 0, 7047, 7048, 7, 22, 0, 0, 7048, 7049, 7, 10, 0, 0, 7049, 7050, 7, 9, 0, 0, 7050, 438, 1, 0, 0, 0, 7051, 7052, 7, 8, 0, 0, 7052, 7053, 7, 11, 0, 0, 7053, 7054, 7, 12, 0, 0, 7054, 7055, 7, 5, 0, 0, 7055, 7056, 7, 4, 0, 0, 7056, 7057, 7, 6, 0, 0, 7057, 7058, 7, 3, 0, 0, 7058, 440, 1, 0, 0, 0, 7059, 7060, 7, 8, 0, 0, 7060, 7061, 7, 11, 0, 0, 7061, 7062, 7, 12, 0, 0, 7062, 7063, 7, 5, 0, 0, 7063, 7064, 7, 4, 0, 0, 7064, 7065, 7, 6, 0, 0, 7065, 7066, 7, 3, 0, 0, 7066, 7067, 5, 95, 0, 0, 7067, 7068, 7, 9, 0, 0, 7068, 7069, 7, 6, 0, 0, 7069, 7070, 7, 4, 0, 0, 7070, 7071, 7, 0, 0, 0, 7071, 7072, 7, 10, 0, 0, 7072, 7073, 7, 11, 0, 0, 7073, 7074, 7, 5, 0, 0, 7074, 442, 1, 0, 0, 0, 7075, 7076, 7, 8, 0, 0, 7076, 7077, 7, 11, 0, 0, 7077, 7078, 7, 12, 0, 0, 7078, 7079, 7, 5, 0, 0, 7079, 7080, 7, 4, 0, 0, 7080, 7081, 7, 6, 0, 0, 7081, 7082, 7, 3, 0, 0, 7082, 7083, 5, 95, 0, 0, 7083, 7084, 7, 9, 0, 0, 7084, 7085, 7, 10, 0, 0, 7085, 7086, 7, 5, 0, 0, 7086, 7087, 7, 4, 0, 0, 7087, 7088, 7, 0, 0, 0, 7088, 7089, 7, 7, 0, 0, 7089, 7090, 7, 8, 0, 0, 7090, 7091, 7, 6, 0, 0, 7091, 444, 1, 0, 0, 0, 7092, 7093, 7, 8, 0, 0, 7093, 7094, 7, 11, 0, 0, 7094, 7095, 7, 12, 0, 0, 7095, 7096, 7, 5, 0, 0, 7096, 7097, 7, 4, 0, 0, 7097, 7098, 7, 6, 0, 0, 7098, 7099, 7, 3, 0, 0, 7099, 7100, 5, 95, 0, 0, 7100, 7101, 7, 10, 0, 0, 7101, 7102, 7, 9, 0, 0, 7102, 446, 1, 0, 0, 0, 7103, 7104, 7, 8, 0, 0, 7104, 7105, 7, 11, 0, 0, 7105, 7106, 7, 12, 0, 0, 7106, 7107, 7, 5, 0, 0, 7107, 7108, 7, 4, 0, 0, 7108, 7109, 7, 6, 0, 0, 7109, 7110, 7, 3, 0, 0, 7110, 7111, 7, 10, 0, 0, 7111, 7112, 7, 7, 0, 0, 7112, 7113, 7, 17, 0, 0, 7113, 448, 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, 7, 10, 0, 0, 7122, 7123, 7, 7, 0, 0, 7123, 7124, 7, 17, 0, 0, 7124, 7125, 5, 95, 0, 0, 7125, 7126, 7, 16, 0, 0, 7126, 7127, 7, 0, 0, 0, 7127, 7128, 7, 8, 0, 0, 7128, 7129, 7, 4, 0, 0, 7129, 7130, 7, 2, 0, 0, 7130, 7131, 7, 3, 0, 0, 7131, 450, 1, 0, 0, 0, 7132, 7133, 7, 8, 0, 0, 7133, 7134, 7, 11, 0, 0, 7134, 7135, 7, 12, 0, 0, 7135, 7136, 7, 5, 0, 0, 7136, 7137, 7, 4, 0, 0, 7137, 7138, 7, 6, 0, 0, 7138, 7139, 7, 3, 0, 0, 7139, 7140, 5, 95, 0, 0, 7140, 7141, 7, 15, 0, 0, 7141, 7142, 7, 3, 0, 0, 7142, 7143, 7, 2, 0, 0, 7143, 7144, 7, 1, 0, 0, 7144, 7145, 7, 0, 0, 0, 7145, 7146, 7, 1, 0, 0, 7146, 7147, 7, 10, 0, 0, 7147, 7148, 7, 11, 0, 0, 7148, 7149, 7, 10, 0, 0, 7149, 7150, 7, 4, 0, 0, 7150, 7151, 7, 18, 0, 0, 7151, 452, 1, 0, 0, 0, 7152, 7153, 7, 8, 0, 0, 7153, 7154, 7, 11, 0, 0, 7154, 7155, 7, 12, 0, 0, 7155, 7156, 7, 5, 0, 0, 7156, 7157, 7, 4, 0, 0, 7157, 7158, 7, 6, 0, 0, 7158, 7159, 7, 3, 0, 0, 7159, 7160, 5, 95, 0, 0, 7160, 7161, 7, 5, 0, 0, 7161, 7162, 7, 6, 0, 0, 7162, 7163, 7, 4, 0, 0, 7163, 454, 1, 0, 0, 0, 7164, 7165, 7, 8, 0, 0, 7165, 7166, 7, 2, 0, 0, 7166, 7167, 7, 0, 0, 0, 7167, 7168, 7, 11, 0, 0, 7168, 7169, 7, 6, 0, 0, 7169, 7170, 7, 5, 0, 0, 7170, 7171, 7, 8, 0, 0, 7171, 7172, 7, 6, 0, 0, 7172, 456, 1, 0, 0, 0, 7173, 7174, 7, 8, 0, 0, 7174, 7175, 7, 2, 0, 0, 7175, 7176, 7, 0, 0, 0, 7176, 7177, 7, 11, 0, 0, 7177, 7178, 7, 6, 0, 0, 7178, 7179, 7, 5, 0, 0, 7179, 7180, 7, 8, 0, 0, 7180, 7181, 7, 6, 0, 0, 7181, 7182, 5, 95, 0, 0, 7182, 7183, 7, 5, 0, 0, 7183, 7184, 7, 24, 0, 0, 7184, 458, 1, 0, 0, 0, 7185, 7186, 7, 8, 0, 0, 7186, 7187, 7, 2, 0, 0, 7187, 7188, 7, 0, 0, 0, 7188, 7189, 7, 3, 0, 0, 7189, 7190, 7, 5, 0, 0, 7190, 7191, 7, 6, 0, 0, 7191, 460, 1, 0, 0, 0, 7192, 7193, 7, 8, 0, 0, 7193, 7194, 7, 2, 0, 0, 7194, 7195, 5, 95, 0, 0, 7195, 7196, 7, 0, 0, 0, 7196, 7197, 7, 12, 0, 0, 7197, 7198, 7, 4, 0, 0, 7198, 7199, 7, 19, 0, 0, 7199, 7200, 5, 95, 0, 0, 7200, 7201, 7, 10, 0, 0, 7201, 7202, 7, 7, 0, 0, 7202, 7203, 7, 9, 0, 0, 7203, 462, 1, 0, 0, 0, 7204, 7205, 7, 8, 0, 0, 7205, 7206, 7, 2, 0, 0, 7206, 7207, 7, 11, 0, 0, 7207, 7208, 7, 9, 0, 0, 7208, 464, 1, 0, 0, 0, 7209, 7210, 7, 8, 0, 0, 7210, 7211, 7, 2, 0, 0, 7211, 7212, 7, 11, 0, 0, 7212, 7213, 7, 11, 0, 0, 7213, 7214, 7, 6, 0, 0, 7214, 7215, 7, 8, 0, 0, 7215, 7216, 7, 4, 0, 0, 7216, 466, 1, 0, 0, 0, 7217, 7218, 7, 8, 0, 0, 7218, 7219, 7, 2, 0, 0, 7219, 7220, 7, 11, 0, 0, 7220, 7221, 7, 11, 0, 0, 7221, 7222, 7, 6, 0, 0, 7222, 7223, 7, 8, 0, 0, 7223, 7224, 7, 4, 0, 0, 7224, 7225, 7, 10, 0, 0, 7225, 7226, 7, 2, 0, 0, 7226, 7227, 7, 7, 0, 0, 7227, 468, 1, 0, 0, 0, 7228, 7229, 7, 8, 0, 0, 7229, 7230, 7, 2, 0, 0, 7230, 7231, 7, 11, 0, 0, 7231, 7232, 7, 12, 0, 0, 7232, 7233, 7, 14, 0, 0, 7233, 7234, 7, 7, 0, 0, 7234, 7235, 7, 0, 0, 0, 7235, 7236, 7, 3, 0, 0, 7236, 470, 1, 0, 0, 0, 7237, 7238, 7, 8, 0, 0, 7238, 7239, 7, 2, 0, 0, 7239, 7240, 7, 11, 0, 0, 7240, 7241, 7, 12, 0, 0, 7241, 7242, 7, 14, 0, 0, 7242, 7243, 7, 7, 0, 0, 7243, 7244, 5, 95, 0, 0, 7244, 7245, 7, 0, 0, 0, 7245, 7246, 7, 12, 0, 0, 7246, 7247, 7, 4, 0, 0, 7247, 7248, 7, 19, 0, 0, 7248, 7249, 5, 95, 0, 0, 7249, 7250, 7, 10, 0, 0, 7250, 7251, 7, 7, 0, 0, 7251, 7252, 7, 9, 0, 0, 7252, 7253, 7, 10, 0, 0, 7253, 7254, 7, 8, 0, 0, 7254, 7255, 7, 0, 0, 0, 7255, 7256, 7, 4, 0, 0, 7256, 7257, 7, 2, 0, 0, 7257, 7258, 7, 3, 0, 0, 7258, 472, 1, 0, 0, 0, 7259, 7260, 7, 8, 0, 0, 7260, 7261, 7, 2, 0, 0, 7261, 7262, 7, 11, 0, 0, 7262, 7263, 7, 12, 0, 0, 7263, 7264, 7, 14, 0, 0, 7264, 7265, 7, 7, 0, 0, 7265, 474, 1, 0, 0, 0, 7266, 7267, 7, 8, 0, 0, 7267, 7268, 7, 2, 0, 0, 7268, 7269, 7, 11, 0, 0, 7269, 7270, 7, 12, 0, 0, 7270, 7271, 7, 14, 0, 0, 7271, 7272, 7, 7, 0, 0, 7272, 7273, 7, 5, 0, 0, 7273, 476, 1, 0, 0, 0, 7274, 7275, 7, 8, 0, 0, 7275, 7276, 7, 2, 0, 0, 7276, 7277, 7, 11, 0, 0, 7277, 7278, 7, 12, 0, 0, 7278, 7279, 7, 14, 0, 0, 7279, 7280, 7, 7, 0, 0, 7280, 7281, 5, 95, 0, 0, 7281, 7282, 7, 5, 0, 0, 7282, 7283, 7, 4, 0, 0, 7283, 7284, 7, 0, 0, 0, 7284, 7285, 7, 4, 0, 0, 7285, 7286, 7, 5, 0, 0, 7286, 478, 1, 0, 0, 0, 7287, 7288, 7, 8, 0, 0, 7288, 7289, 7, 2, 0, 0, 7289, 7290, 7, 11, 0, 0, 7290, 7291, 7, 12, 0, 0, 7291, 7292, 7, 14, 0, 0, 7292, 7293, 7, 7, 0, 0, 7293, 7294, 5, 95, 0, 0, 7294, 7295, 7, 13, 0, 0, 7295, 7296, 7, 0, 0, 0, 7296, 7297, 7, 11, 0, 0, 7297, 7298, 7, 12, 0, 0, 7298, 7299, 7, 6, 0, 0, 7299, 480, 1, 0, 0, 0, 7300, 7301, 7, 8, 0, 0, 7301, 7302, 7, 2, 0, 0, 7302, 7303, 7, 14, 0, 0, 7303, 7304, 7, 14, 0, 0, 7304, 7305, 7, 6, 0, 0, 7305, 7306, 7, 7, 0, 0, 7306, 7307, 7, 4, 0, 0, 7307, 482, 1, 0, 0, 0, 7308, 7309, 7, 8, 0, 0, 7309, 7310, 7, 2, 0, 0, 7310, 7311, 7, 14, 0, 0, 7311, 7312, 7, 14, 0, 0, 7312, 7313, 7, 10, 0, 0, 7313, 7314, 7, 4, 0, 0, 7314, 484, 1, 0, 0, 0, 7315, 7316, 7, 8, 0, 0, 7316, 7317, 7, 2, 0, 0, 7317, 7318, 7, 14, 0, 0, 7318, 7319, 7, 14, 0, 0, 7319, 7320, 7, 10, 0, 0, 7320, 7321, 7, 4, 0, 0, 7321, 7322, 7, 4, 0, 0, 7322, 7323, 7, 6, 0, 0, 7323, 7324, 7, 9, 0, 0, 7324, 486, 1, 0, 0, 0, 7325, 7326, 7, 8, 0, 0, 7326, 7327, 7, 2, 0, 0, 7327, 7328, 7, 14, 0, 0, 7328, 7329, 7, 14, 0, 0, 7329, 7330, 7, 2, 0, 0, 7330, 7331, 7, 7, 0, 0, 7331, 488, 1, 0, 0, 0, 7332, 7333, 7, 8, 0, 0, 7333, 7334, 7, 2, 0, 0, 7334, 7335, 7, 14, 0, 0, 7335, 7336, 7, 14, 0, 0, 7336, 7337, 7, 2, 0, 0, 7337, 7338, 7, 7, 0, 0, 7338, 7339, 5, 95, 0, 0, 7339, 7340, 7, 9, 0, 0, 7340, 7341, 7, 0, 0, 0, 7341, 7342, 7, 4, 0, 0, 7342, 7343, 7, 0, 0, 0, 7343, 490, 1, 0, 0, 0, 7344, 7345, 7, 8, 0, 0, 7345, 7346, 7, 2, 0, 0, 7346, 7347, 7, 14, 0, 0, 7347, 7348, 7, 15, 0, 0, 7348, 7349, 7, 0, 0, 0, 7349, 7350, 7, 8, 0, 0, 7350, 7351, 7, 4, 0, 0, 7351, 492, 1, 0, 0, 0, 7352, 7353, 7, 8, 0, 0, 7353, 7354, 7, 2, 0, 0, 7354, 7355, 7, 14, 0, 0, 7355, 7356, 7, 15, 0, 0, 7356, 7357, 7, 0, 0, 0, 7357, 7358, 7, 4, 0, 0, 7358, 7359, 7, 10, 0, 0, 7359, 7360, 7, 1, 0, 0, 7360, 7361, 7, 11, 0, 0, 7361, 7362, 7, 6, 0, 0, 7362, 494, 1, 0, 0, 0, 7363, 7364, 7, 8, 0, 0, 7364, 7365, 7, 2, 0, 0, 7365, 7366, 7, 14, 0, 0, 7366, 7367, 7, 15, 0, 0, 7367, 7368, 7, 0, 0, 0, 7368, 7369, 7, 4, 0, 0, 7369, 7370, 7, 10, 0, 0, 7370, 7371, 7, 1, 0, 0, 7371, 7372, 7, 10, 0, 0, 7372, 7373, 7, 11, 0, 0, 7373, 7374, 7, 10, 0, 0, 7374, 7375, 7, 4, 0, 0, 7375, 7376, 7, 18, 0, 0, 7376, 496, 1, 0, 0, 0, 7377, 7378, 7, 8, 0, 0, 7378, 7379, 7, 2, 0, 0, 7379, 7380, 7, 14, 0, 0, 7380, 7381, 7, 15, 0, 0, 7381, 7382, 7, 10, 0, 0, 7382, 7383, 7, 11, 0, 0, 7383, 7384, 7, 6, 0, 0, 7384, 498, 1, 0, 0, 0, 7385, 7386, 7, 8, 0, 0, 7386, 7387, 7, 2, 0, 0, 7387, 7388, 7, 14, 0, 0, 7388, 7389, 7, 15, 0, 0, 7389, 7390, 7, 11, 0, 0, 7390, 7391, 7, 6, 0, 0, 7391, 7392, 7, 4, 0, 0, 7392, 7393, 7, 6, 0, 0, 7393, 500, 1, 0, 0, 0, 7394, 7395, 7, 8, 0, 0, 7395, 7396, 7, 2, 0, 0, 7396, 7397, 7, 14, 0, 0, 7397, 7398, 7, 15, 0, 0, 7398, 7399, 7, 11, 0, 0, 7399, 7400, 7, 10, 0, 0, 7400, 7401, 7, 0, 0, 0, 7401, 7402, 7, 7, 0, 0, 7402, 7403, 7, 8, 0, 0, 7403, 7404, 7, 6, 0, 0, 7404, 502, 1, 0, 0, 0, 7405, 7406, 7, 8, 0, 0, 7406, 7407, 7, 2, 0, 0, 7407, 7408, 7, 14, 0, 0, 7408, 7409, 7, 15, 0, 0, 7409, 7410, 7, 2, 0, 0, 7410, 7411, 7, 7, 0, 0, 7411, 7412, 7, 6, 0, 0, 7412, 7413, 7, 7, 0, 0, 7413, 7414, 7, 4, 0, 0, 7414, 504, 1, 0, 0, 0, 7415, 7416, 7, 8, 0, 0, 7416, 7417, 7, 2, 0, 0, 7417, 7418, 7, 14, 0, 0, 7418, 7419, 7, 15, 0, 0, 7419, 7420, 7, 2, 0, 0, 7420, 7421, 7, 7, 0, 0, 7421, 7422, 7, 6, 0, 0, 7422, 7423, 7, 7, 0, 0, 7423, 7424, 7, 4, 0, 0, 7424, 7425, 7, 5, 0, 0, 7425, 506, 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, 6, 0, 0, 7433, 508, 1, 0, 0, 0, 7434, 7435, 7, 8, 0, 0, 7435, 7436, 7, 2, 0, 0, 7436, 7437, 7, 14, 0, 0, 7437, 7438, 7, 15, 0, 0, 7438, 7439, 7, 2, 0, 0, 7439, 7440, 7, 5, 0, 0, 7440, 7441, 7, 10, 0, 0, 7441, 7442, 7, 4, 0, 0, 7442, 7443, 7, 6, 0, 0, 7443, 510, 1, 0, 0, 0, 7444, 7445, 7, 8, 0, 0, 7445, 7446, 7, 2, 0, 0, 7446, 7447, 7, 14, 0, 0, 7447, 7448, 7, 15, 0, 0, 7448, 7449, 7, 2, 0, 0, 7449, 7450, 7, 5, 0, 0, 7450, 7451, 7, 10, 0, 0, 7451, 7452, 7, 4, 0, 0, 7452, 7453, 7, 6, 0, 0, 7453, 7454, 5, 95, 0, 0, 7454, 7455, 7, 11, 0, 0, 7455, 7456, 7, 10, 0, 0, 7456, 7457, 7, 14, 0, 0, 7457, 7458, 7, 10, 0, 0, 7458, 7459, 7, 4, 0, 0, 7459, 512, 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, 2, 0, 0, 7465, 7466, 7, 12, 0, 0, 7466, 7467, 7, 7, 0, 0, 7467, 7468, 7, 9, 0, 0, 7468, 514, 1, 0, 0, 0, 7469, 7470, 7, 8, 0, 0, 7470, 7471, 7, 2, 0, 0, 7471, 7472, 7, 14, 0, 0, 7472, 7473, 7, 15, 0, 0, 7473, 7474, 7, 3, 0, 0, 7474, 7475, 7, 6, 0, 0, 7475, 7476, 7, 5, 0, 0, 7476, 7477, 7, 5, 0, 0, 7477, 516, 1, 0, 0, 0, 7478, 7479, 7, 8, 0, 0, 7479, 7480, 7, 2, 0, 0, 7480, 7481, 7, 14, 0, 0, 7481, 7482, 7, 15, 0, 0, 7482, 7483, 7, 3, 0, 0, 7483, 7484, 7, 6, 0, 0, 7484, 7485, 7, 5, 0, 0, 7485, 7486, 7, 5, 0, 0, 7486, 7487, 7, 10, 0, 0, 7487, 7488, 7, 2, 0, 0, 7488, 7489, 7, 7, 0, 0, 7489, 518, 1, 0, 0, 0, 7490, 7491, 7, 8, 0, 0, 7491, 7492, 7, 2, 0, 0, 7492, 7493, 7, 14, 0, 0, 7493, 7494, 7, 15, 0, 0, 7494, 7495, 7, 12, 0, 0, 7495, 7496, 7, 4, 0, 0, 7496, 7497, 7, 6, 0, 0, 7497, 520, 1, 0, 0, 0, 7498, 7499, 7, 8, 0, 0, 7499, 7500, 7, 2, 0, 0, 7500, 7501, 7, 14, 0, 0, 7501, 7502, 7, 15, 0, 0, 7502, 7503, 7, 12, 0, 0, 7503, 7504, 7, 4, 0, 0, 7504, 7505, 7, 0, 0, 0, 7505, 7506, 7, 4, 0, 0, 7506, 7507, 7, 10, 0, 0, 7507, 7508, 7, 2, 0, 0, 7508, 7509, 7, 7, 0, 0, 7509, 522, 1, 0, 0, 0, 7510, 7511, 7, 8, 0, 0, 7511, 7512, 7, 2, 0, 0, 7512, 7513, 7, 7, 0, 0, 7513, 7514, 7, 8, 0, 0, 7514, 7515, 7, 0, 0, 0, 7515, 7516, 7, 4, 0, 0, 7516, 524, 1, 0, 0, 0, 7517, 7518, 7, 8, 0, 0, 7518, 7519, 7, 2, 0, 0, 7519, 7520, 7, 7, 0, 0, 7520, 7521, 7, 8, 0, 0, 7521, 7522, 7, 12, 0, 0, 7522, 7523, 7, 3, 0, 0, 7523, 7524, 7, 3, 0, 0, 7524, 7525, 7, 6, 0, 0, 7525, 7526, 7, 7, 0, 0, 7526, 7527, 7, 4, 0, 0, 7527, 526, 1, 0, 0, 0, 7528, 7529, 7, 8, 0, 0, 7529, 7530, 7, 2, 0, 0, 7530, 7531, 7, 7, 0, 0, 7531, 7532, 5, 95, 0, 0, 7532, 7533, 7, 9, 0, 0, 7533, 7534, 7, 1, 0, 0, 7534, 7535, 7, 10, 0, 0, 7535, 7536, 7, 9, 0, 0, 7536, 7537, 5, 95, 0, 0, 7537, 7538, 7, 4, 0, 0, 7538, 7539, 7, 2, 0, 0, 7539, 7540, 5, 95, 0, 0, 7540, 7541, 7, 10, 0, 0, 7541, 7542, 7, 9, 0, 0, 7542, 528, 1, 0, 0, 0, 7543, 7544, 7, 8, 0, 0, 7544, 7545, 7, 2, 0, 0, 7545, 7546, 7, 7, 0, 0, 7546, 7547, 7, 9, 0, 0, 7547, 7548, 7, 10, 0, 0, 7548, 7549, 7, 4, 0, 0, 7549, 7550, 7, 10, 0, 0, 7550, 7551, 7, 2, 0, 0, 7551, 7552, 7, 7, 0, 0, 7552, 7553, 7, 0, 0, 0, 7553, 7554, 7, 11, 0, 0, 7554, 530, 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, 9, 0, 0, 7559, 7560, 7, 10, 0, 0, 7560, 7561, 7, 4, 0, 0, 7561, 7562, 7, 10, 0, 0, 7562, 7563, 7, 2, 0, 0, 7563, 7564, 7, 7, 0, 0, 7564, 532, 1, 0, 0, 0, 7565, 7566, 7, 8, 0, 0, 7566, 7567, 7, 2, 0, 0, 7567, 7568, 7, 7, 0, 0, 7568, 7569, 7, 16, 0, 0, 7569, 7570, 7, 10, 0, 0, 7570, 7571, 7, 3, 0, 0, 7571, 7572, 7, 14, 0, 0, 7572, 534, 1, 0, 0, 0, 7573, 7574, 7, 8, 0, 0, 7574, 7575, 7, 2, 0, 0, 7575, 7576, 7, 7, 0, 0, 7576, 7577, 7, 16, 0, 0, 7577, 7578, 7, 2, 0, 0, 7578, 7579, 7, 3, 0, 0, 7579, 7580, 7, 14, 0, 0, 7580, 7581, 7, 10, 0, 0, 7581, 7582, 7, 7, 0, 0, 7582, 7583, 7, 17, 0, 0, 7583, 536, 1, 0, 0, 0, 7584, 7585, 7, 8, 0, 0, 7585, 7586, 7, 2, 0, 0, 7586, 7587, 7, 7, 0, 0, 7587, 7588, 5, 95, 0, 0, 7588, 7589, 7, 17, 0, 0, 7589, 7590, 7, 12, 0, 0, 7590, 7591, 7, 10, 0, 0, 7591, 7592, 7, 9, 0, 0, 7592, 7593, 5, 95, 0, 0, 7593, 7594, 7, 4, 0, 0, 7594, 7595, 7, 2, 0, 0, 7595, 7596, 5, 95, 0, 0, 7596, 7597, 7, 10, 0, 0, 7597, 7598, 7, 9, 0, 0, 7598, 538, 1, 0, 0, 0, 7599, 7600, 7, 8, 0, 0, 7600, 7601, 7, 2, 0, 0, 7601, 7602, 7, 7, 0, 0, 7602, 7603, 5, 95, 0, 0, 7603, 7604, 7, 10, 0, 0, 7604, 7605, 7, 9, 0, 0, 7605, 540, 1, 0, 0, 0, 7606, 7607, 7, 8, 0, 0, 7607, 7608, 7, 2, 0, 0, 7608, 7609, 7, 7, 0, 0, 7609, 7610, 5, 95, 0, 0, 7610, 7611, 7, 7, 0, 0, 7611, 7612, 7, 0, 0, 0, 7612, 7613, 7, 14, 0, 0, 7613, 7614, 7, 6, 0, 0, 7614, 7615, 5, 95, 0, 0, 7615, 7616, 7, 4, 0, 0, 7616, 7617, 7, 2, 0, 0, 7617, 7618, 5, 95, 0, 0, 7618, 7619, 7, 10, 0, 0, 7619, 7620, 7, 9, 0, 0, 7620, 542, 1, 0, 0, 0, 7621, 7622, 7, 8, 0, 0, 7622, 7623, 7, 2, 0, 0, 7623, 7624, 7, 7, 0, 0, 7624, 7625, 7, 7, 0, 0, 7625, 7626, 7, 6, 0, 0, 7626, 7627, 7, 8, 0, 0, 7627, 7628, 7, 4, 0, 0, 7628, 7629, 5, 95, 0, 0, 7629, 7630, 7, 1, 0, 0, 7630, 7631, 7, 18, 0, 0, 7631, 7632, 5, 95, 0, 0, 7632, 7633, 7, 8, 0, 0, 7633, 7634, 7, 1, 0, 0, 7634, 7635, 5, 95, 0, 0, 7635, 7636, 7, 22, 0, 0, 7636, 7637, 7, 19, 0, 0, 7637, 7638, 7, 3, 0, 0, 7638, 7639, 5, 95, 0, 0, 7639, 7640, 7, 2, 0, 0, 7640, 7641, 7, 7, 0, 0, 7641, 7642, 7, 11, 0, 0, 7642, 7643, 7, 18, 0, 0, 7643, 544, 1, 0, 0, 0, 7644, 7645, 7, 8, 0, 0, 7645, 7646, 7, 2, 0, 0, 7646, 7647, 7, 7, 0, 0, 7647, 7648, 7, 7, 0, 0, 7648, 7649, 7, 6, 0, 0, 7649, 7650, 7, 8, 0, 0, 7650, 7651, 7, 4, 0, 0, 7651, 7652, 5, 95, 0, 0, 7652, 7653, 7, 1, 0, 0, 7653, 7654, 7, 18, 0, 0, 7654, 7655, 5, 95, 0, 0, 7655, 7656, 7, 8, 0, 0, 7656, 7657, 7, 2, 0, 0, 7657, 7658, 7, 14, 0, 0, 7658, 7659, 7, 1, 0, 0, 7659, 7660, 7, 10, 0, 0, 7660, 7661, 7, 7, 0, 0, 7661, 7662, 7, 6, 0, 0, 7662, 7663, 5, 95, 0, 0, 7663, 7664, 7, 5, 0, 0, 7664, 7665, 7, 22, 0, 0, 7665, 546, 1, 0, 0, 0, 7666, 7667, 7, 8, 0, 0, 7667, 7668, 7, 2, 0, 0, 7668, 7669, 7, 7, 0, 0, 7669, 7670, 7, 7, 0, 0, 7670, 7671, 7, 6, 0, 0, 7671, 7672, 7, 8, 0, 0, 7672, 7673, 7, 4, 0, 0, 7673, 7674, 5, 95, 0, 0, 7674, 7675, 7, 1, 0, 0, 7675, 7676, 7, 18, 0, 0, 7676, 7677, 5, 95, 0, 0, 7677, 7678, 7, 8, 0, 0, 7678, 7679, 7, 2, 0, 0, 7679, 7680, 7, 5, 0, 0, 7680, 7681, 7, 4, 0, 0, 7681, 7682, 5, 95, 0, 0, 7682, 7683, 7, 1, 0, 0, 7683, 7684, 7, 0, 0, 0, 7684, 7685, 7, 5, 0, 0, 7685, 7686, 7, 6, 0, 0, 7686, 7687, 7, 9, 0, 0, 7687, 548, 1, 0, 0, 0, 7688, 7689, 7, 8, 0, 0, 7689, 7690, 7, 2, 0, 0, 7690, 7691, 7, 7, 0, 0, 7691, 7692, 7, 7, 0, 0, 7692, 7693, 7, 6, 0, 0, 7693, 7694, 7, 8, 0, 0, 7694, 7695, 7, 4, 0, 0, 7695, 7696, 5, 95, 0, 0, 7696, 7697, 7, 1, 0, 0, 7697, 7698, 7, 18, 0, 0, 7698, 7699, 5, 95, 0, 0, 7699, 7700, 7, 6, 0, 0, 7700, 7701, 7, 11, 0, 0, 7701, 7702, 7, 10, 0, 0, 7702, 7703, 7, 14, 0, 0, 7703, 7704, 5, 95, 0, 0, 7704, 7705, 7, 9, 0, 0, 7705, 7706, 7, 12, 0, 0, 7706, 7707, 7, 15, 0, 0, 7707, 7708, 7, 5, 0, 0, 7708, 550, 1, 0, 0, 0, 7709, 7710, 7, 8, 0, 0, 7710, 7711, 7, 2, 0, 0, 7711, 7712, 7, 7, 0, 0, 7712, 7713, 7, 7, 0, 0, 7713, 7714, 7, 6, 0, 0, 7714, 7715, 7, 8, 0, 0, 7715, 7716, 7, 4, 0, 0, 7716, 7717, 5, 95, 0, 0, 7717, 7718, 7, 1, 0, 0, 7718, 7719, 7, 18, 0, 0, 7719, 7720, 5, 95, 0, 0, 7720, 7721, 7, 16, 0, 0, 7721, 7722, 7, 10, 0, 0, 7722, 7723, 7, 11, 0, 0, 7723, 7724, 7, 4, 0, 0, 7724, 7725, 7, 6, 0, 0, 7725, 7726, 7, 3, 0, 0, 7726, 7727, 7, 10, 0, 0, 7727, 7728, 7, 7, 0, 0, 7728, 7729, 7, 17, 0, 0, 7729, 552, 1, 0, 0, 0, 7730, 7731, 7, 8, 0, 0, 7731, 7732, 7, 2, 0, 0, 7732, 7733, 7, 7, 0, 0, 7733, 7734, 7, 7, 0, 0, 7734, 7735, 7, 6, 0, 0, 7735, 7736, 7, 8, 0, 0, 7736, 7737, 7, 4, 0, 0, 7737, 7738, 5, 95, 0, 0, 7738, 7739, 7, 1, 0, 0, 7739, 7740, 7, 18, 0, 0, 7740, 7741, 5, 95, 0, 0, 7741, 7742, 7, 10, 0, 0, 7742, 7743, 7, 5, 0, 0, 7743, 7744, 7, 8, 0, 0, 7744, 7745, 7, 18, 0, 0, 7745, 7746, 7, 8, 0, 0, 7746, 7747, 7, 11, 0, 0, 7747, 7748, 7, 6, 0, 0, 7748, 554, 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, 10, 0, 0, 7761, 7762, 7, 5, 0, 0, 7762, 7763, 7, 11, 0, 0, 7763, 7764, 7, 6, 0, 0, 7764, 7765, 7, 0, 0, 0, 7765, 7766, 7, 16, 0, 0, 7766, 556, 1, 0, 0, 0, 7767, 7768, 7, 8, 0, 0, 7768, 7769, 7, 2, 0, 0, 7769, 7770, 7, 7, 0, 0, 7770, 7771, 7, 7, 0, 0, 7771, 7772, 7, 6, 0, 0, 7772, 7773, 7, 8, 0, 0, 7773, 7774, 7, 4, 0, 0, 7774, 7775, 5, 95, 0, 0, 7775, 7776, 7, 1, 0, 0, 7776, 7777, 7, 18, 0, 0, 7777, 7778, 5, 95, 0, 0, 7778, 7779, 7, 3, 0, 0, 7779, 7780, 7, 2, 0, 0, 7780, 7781, 7, 2, 0, 0, 7781, 7782, 7, 4, 0, 0, 7782, 558, 1, 0, 0, 0, 7783, 7784, 7, 8, 0, 0, 7784, 7785, 7, 2, 0, 0, 7785, 7786, 7, 7, 0, 0, 7786, 7787, 7, 7, 0, 0, 7787, 7788, 7, 6, 0, 0, 7788, 7789, 7, 8, 0, 0, 7789, 7790, 7, 4, 0, 0, 7790, 560, 1, 0, 0, 0, 7791, 7792, 7, 8, 0, 0, 7792, 7793, 7, 2, 0, 0, 7793, 7794, 7, 7, 0, 0, 7794, 7795, 7, 7, 0, 0, 7795, 7796, 7, 6, 0, 0, 7796, 7797, 7, 8, 0, 0, 7797, 7798, 7, 4, 0, 0, 7798, 7799, 5, 95, 0, 0, 7799, 7800, 7, 4, 0, 0, 7800, 7801, 7, 10, 0, 0, 7801, 7802, 7, 14, 0, 0, 7802, 7803, 7, 6, 0, 0, 7803, 562, 1, 0, 0, 0, 7804, 7805, 7, 8, 0, 0, 7805, 7806, 7, 2, 0, 0, 7806, 7807, 7, 7, 0, 0, 7807, 7808, 7, 5, 0, 0, 7808, 7809, 7, 10, 0, 0, 7809, 7810, 7, 9, 0, 0, 7810, 7811, 7, 6, 0, 0, 7811, 7812, 7, 3, 0, 0, 7812, 564, 1, 0, 0, 0, 7813, 7814, 7, 8, 0, 0, 7814, 7815, 7, 2, 0, 0, 7815, 7816, 7, 7, 0, 0, 7816, 7817, 7, 5, 0, 0, 7817, 7818, 7, 10, 0, 0, 7818, 7819, 7, 5, 0, 0, 7819, 7820, 7, 4, 0, 0, 7820, 7821, 7, 6, 0, 0, 7821, 7822, 7, 7, 0, 0, 7822, 7823, 7, 4, 0, 0, 7823, 566, 1, 0, 0, 0, 7824, 7825, 7, 8, 0, 0, 7825, 7826, 7, 2, 0, 0, 7826, 7827, 7, 7, 0, 0, 7827, 7828, 7, 5, 0, 0, 7828, 7829, 7, 4, 0, 0, 7829, 7830, 7, 0, 0, 0, 7830, 7831, 7, 7, 0, 0, 7831, 7832, 7, 4, 0, 0, 7832, 568, 1, 0, 0, 0, 7833, 7834, 7, 8, 0, 0, 7834, 7835, 7, 2, 0, 0, 7835, 7836, 7, 7, 0, 0, 7836, 7837, 7, 5, 0, 0, 7837, 7838, 7, 4, 0, 0, 7838, 570, 1, 0, 0, 0, 7839, 7840, 7, 8, 0, 0, 7840, 7841, 7, 2, 0, 0, 7841, 7842, 7, 7, 0, 0, 7842, 7843, 7, 5, 0, 0, 7843, 7844, 7, 4, 0, 0, 7844, 7845, 7, 3, 0, 0, 7845, 7846, 7, 0, 0, 0, 7846, 7847, 7, 10, 0, 0, 7847, 7848, 7, 7, 0, 0, 7848, 7849, 7, 4, 0, 0, 7849, 572, 1, 0, 0, 0, 7850, 7851, 7, 8, 0, 0, 7851, 7852, 7, 2, 0, 0, 7852, 7853, 7, 7, 0, 0, 7853, 7854, 7, 5, 0, 0, 7854, 7855, 7, 4, 0, 0, 7855, 7856, 7, 3, 0, 0, 7856, 7857, 7, 0, 0, 0, 7857, 7858, 7, 10, 0, 0, 7858, 7859, 7, 7, 0, 0, 7859, 7860, 7, 4, 0, 0, 7860, 7861, 7, 5, 0, 0, 7861, 574, 1, 0, 0, 0, 7862, 7863, 7, 8, 0, 0, 7863, 7864, 7, 2, 0, 0, 7864, 7865, 7, 7, 0, 0, 7865, 7866, 7, 5, 0, 0, 7866, 7867, 7, 4, 0, 0, 7867, 7868, 7, 3, 0, 0, 7868, 7869, 7, 12, 0, 0, 7869, 7870, 7, 8, 0, 0, 7870, 7871, 7, 4, 0, 0, 7871, 7872, 7, 2, 0, 0, 7872, 7873, 7, 3, 0, 0, 7873, 576, 1, 0, 0, 0, 7874, 7875, 7, 8, 0, 0, 7875, 7876, 7, 2, 0, 0, 7876, 7877, 7, 7, 0, 0, 7877, 7878, 7, 4, 0, 0, 7878, 7879, 7, 0, 0, 0, 7879, 7880, 7, 10, 0, 0, 7880, 7881, 7, 7, 0, 0, 7881, 7882, 7, 6, 0, 0, 7882, 7883, 7, 3, 0, 0, 7883, 578, 1, 0, 0, 0, 7884, 7885, 7, 8, 0, 0, 7885, 7886, 7, 2, 0, 0, 7886, 7887, 7, 7, 0, 0, 7887, 7888, 7, 4, 0, 0, 7888, 7889, 7, 0, 0, 0, 7889, 7890, 7, 10, 0, 0, 7890, 7891, 7, 7, 0, 0, 7891, 7892, 7, 6, 0, 0, 7892, 7893, 7, 3, 0, 0, 7893, 7894, 7, 5, 0, 0, 7894, 580, 1, 0, 0, 0, 7895, 7896, 7, 8, 0, 0, 7896, 7897, 7, 2, 0, 0, 7897, 7898, 7, 7, 0, 0, 7898, 7899, 7, 4, 0, 0, 7899, 7900, 7, 0, 0, 0, 7900, 7901, 7, 10, 0, 0, 7901, 7902, 7, 7, 0, 0, 7902, 7903, 7, 6, 0, 0, 7903, 7904, 7, 3, 0, 0, 7904, 7905, 7, 5, 0, 0, 7905, 7906, 5, 95, 0, 0, 7906, 7907, 7, 9, 0, 0, 7907, 7908, 7, 6, 0, 0, 7908, 7909, 7, 16, 0, 0, 7909, 7910, 7, 0, 0, 0, 7910, 7911, 7, 12, 0, 0, 7911, 7912, 7, 11, 0, 0, 7912, 7913, 7, 4, 0, 0, 7913, 582, 1, 0, 0, 0, 7914, 7915, 7, 8, 0, 0, 7915, 7916, 7, 2, 0, 0, 7916, 7917, 7, 7, 0, 0, 7917, 7918, 7, 4, 0, 0, 7918, 7919, 7, 0, 0, 0, 7919, 7920, 7, 10, 0, 0, 7920, 7921, 7, 7, 0, 0, 7921, 7922, 7, 6, 0, 0, 7922, 7923, 7, 3, 0, 0, 7923, 7924, 5, 95, 0, 0, 7924, 7925, 7, 9, 0, 0, 7925, 7926, 7, 0, 0, 0, 7926, 7927, 7, 4, 0, 0, 7927, 7928, 7, 0, 0, 0, 7928, 584, 1, 0, 0, 0, 7929, 7930, 7, 8, 0, 0, 7930, 7931, 7, 2, 0, 0, 7931, 7932, 7, 7, 0, 0, 7932, 7933, 7, 4, 0, 0, 7933, 7934, 7, 0, 0, 0, 7934, 7935, 7, 10, 0, 0, 7935, 7936, 7, 7, 0, 0, 7936, 7937, 7, 6, 0, 0, 7937, 7938, 7, 3, 0, 0, 7938, 7939, 5, 95, 0, 0, 7939, 7940, 7, 14, 0, 0, 7940, 7941, 7, 0, 0, 0, 7941, 7942, 7, 15, 0, 0, 7942, 586, 1, 0, 0, 0, 7943, 7944, 7, 8, 0, 0, 7944, 7945, 7, 2, 0, 0, 7945, 7946, 7, 7, 0, 0, 7946, 7947, 7, 4, 0, 0, 7947, 7948, 7, 6, 0, 0, 7948, 7949, 7, 7, 0, 0, 7949, 7950, 7, 4, 0, 0, 7950, 588, 1, 0, 0, 0, 7951, 7952, 7, 8, 0, 0, 7952, 7953, 7, 2, 0, 0, 7953, 7954, 7, 7, 0, 0, 7954, 7955, 7, 4, 0, 0, 7955, 7956, 7, 6, 0, 0, 7956, 7957, 7, 7, 0, 0, 7957, 7958, 7, 4, 0, 0, 7958, 7959, 7, 5, 0, 0, 7959, 590, 1, 0, 0, 0, 7960, 7961, 7, 8, 0, 0, 7961, 7962, 7, 2, 0, 0, 7962, 7963, 7, 7, 0, 0, 7963, 7964, 7, 4, 0, 0, 7964, 7965, 7, 6, 0, 0, 7965, 7966, 7, 25, 0, 0, 7966, 7967, 7, 4, 0, 0, 7967, 592, 1, 0, 0, 0, 7968, 7969, 7, 8, 0, 0, 7969, 7970, 7, 2, 0, 0, 7970, 7971, 7, 7, 0, 0, 7971, 7972, 7, 4, 0, 0, 7972, 7973, 7, 10, 0, 0, 7973, 7974, 7, 7, 0, 0, 7974, 7975, 7, 12, 0, 0, 7975, 7976, 7, 6, 0, 0, 7976, 594, 1, 0, 0, 0, 7977, 7978, 7, 8, 0, 0, 7978, 7979, 7, 2, 0, 0, 7979, 7980, 7, 7, 0, 0, 7980, 7981, 7, 4, 0, 0, 7981, 7982, 7, 3, 0, 0, 7982, 7983, 7, 2, 0, 0, 7983, 7984, 7, 11, 0, 0, 7984, 7985, 7, 16, 0, 0, 7985, 7986, 7, 10, 0, 0, 7986, 7987, 7, 11, 0, 0, 7987, 7988, 7, 6, 0, 0, 7988, 596, 1, 0, 0, 0, 7989, 7990, 7, 8, 0, 0, 7990, 7991, 7, 2, 0, 0, 7991, 7992, 7, 7, 0, 0, 7992, 7993, 5, 95, 0, 0, 7993, 7994, 7, 12, 0, 0, 7994, 7995, 7, 10, 0, 0, 7995, 7996, 7, 9, 0, 0, 7996, 7997, 5, 95, 0, 0, 7997, 7998, 7, 4, 0, 0, 7998, 7999, 7, 2, 0, 0, 7999, 8000, 5, 95, 0, 0, 8000, 8001, 7, 10, 0, 0, 8001, 8002, 7, 9, 0, 0, 8002, 598, 1, 0, 0, 0, 8003, 8004, 7, 8, 0, 0, 8004, 8005, 7, 2, 0, 0, 8005, 8006, 7, 7, 0, 0, 8006, 8007, 7, 13, 0, 0, 8007, 8008, 7, 6, 0, 0, 8008, 8009, 7, 3, 0, 0, 8009, 8010, 7, 4, 0, 0, 8010, 600, 1, 0, 0, 0, 8011, 8012, 7, 8, 0, 0, 8012, 8013, 7, 2, 0, 0, 8013, 8014, 7, 7, 0, 0, 8014, 8015, 7, 13, 0, 0, 8015, 8016, 7, 6, 0, 0, 8016, 8017, 7, 3, 0, 0, 8017, 8018, 7, 5, 0, 0, 8018, 8019, 7, 10, 0, 0, 8019, 8020, 7, 2, 0, 0, 8020, 8021, 7, 7, 0, 0, 8021, 602, 1, 0, 0, 0, 8022, 8023, 7, 8, 0, 0, 8023, 8024, 7, 2, 0, 0, 8024, 8025, 7, 2, 0, 0, 8025, 8026, 7, 21, 0, 0, 8026, 8027, 7, 10, 0, 0, 8027, 8028, 7, 6, 0, 0, 8028, 604, 1, 0, 0, 0, 8029, 8030, 7, 8, 0, 0, 8030, 8031, 7, 2, 0, 0, 8031, 8032, 7, 15, 0, 0, 8032, 8033, 7, 18, 0, 0, 8033, 606, 1, 0, 0, 0, 8034, 8035, 7, 8, 0, 0, 8035, 8036, 7, 2, 0, 0, 8036, 8037, 7, 3, 0, 0, 8037, 8038, 7, 3, 0, 0, 8038, 8039, 5, 95, 0, 0, 8039, 8040, 7, 21, 0, 0, 8040, 608, 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, 5, 95, 0, 0, 8046, 8047, 7, 5, 0, 0, 8047, 610, 1, 0, 0, 0, 8048, 8049, 7, 8, 0, 0, 8049, 8050, 7, 2, 0, 0, 8050, 8051, 7, 3, 0, 0, 8051, 8052, 7, 3, 0, 0, 8052, 8053, 7, 12, 0, 0, 8053, 8054, 7, 15, 0, 0, 8054, 8055, 7, 4, 0, 0, 8055, 8056, 7, 10, 0, 0, 8056, 8057, 7, 2, 0, 0, 8057, 8058, 7, 7, 0, 0, 8058, 612, 1, 0, 0, 0, 8059, 8060, 7, 8, 0, 0, 8060, 8061, 7, 2, 0, 0, 8061, 8062, 7, 3, 0, 0, 8062, 8063, 7, 3, 0, 0, 8063, 8064, 7, 12, 0, 0, 8064, 8065, 7, 15, 0, 0, 8065, 8066, 7, 4, 0, 0, 8066, 8067, 5, 95, 0, 0, 8067, 8068, 7, 25, 0, 0, 8068, 8069, 7, 10, 0, 0, 8069, 8070, 7, 9, 0, 0, 8070, 8071, 5, 95, 0, 0, 8071, 8072, 7, 0, 0, 0, 8072, 8073, 7, 11, 0, 0, 8073, 8074, 7, 11, 0, 0, 8074, 614, 1, 0, 0, 0, 8075, 8076, 7, 8, 0, 0, 8076, 8077, 7, 2, 0, 0, 8077, 8078, 7, 3, 0, 0, 8078, 8079, 7, 3, 0, 0, 8079, 8080, 7, 12, 0, 0, 8080, 8081, 7, 15, 0, 0, 8081, 8082, 7, 4, 0, 0, 8082, 8083, 5, 95, 0, 0, 8083, 8084, 7, 25, 0, 0, 8084, 8085, 7, 10, 0, 0, 8085, 8086, 7, 9, 0, 0, 8086, 616, 1, 0, 0, 0, 8087, 8088, 7, 8, 0, 0, 8088, 8089, 7, 2, 0, 0, 8089, 8090, 7, 5, 0, 0, 8090, 618, 1, 0, 0, 0, 8091, 8092, 7, 8, 0, 0, 8092, 8093, 7, 2, 0, 0, 8093, 8094, 7, 5, 0, 0, 8094, 8095, 7, 19, 0, 0, 8095, 620, 1, 0, 0, 0, 8096, 8097, 7, 8, 0, 0, 8097, 8098, 7, 2, 0, 0, 8098, 8099, 7, 5, 0, 0, 8099, 8100, 7, 4, 0, 0, 8100, 622, 1, 0, 0, 0, 8101, 8102, 7, 8, 0, 0, 8102, 8103, 7, 2, 0, 0, 8103, 8104, 7, 5, 0, 0, 8104, 8105, 7, 4, 0, 0, 8105, 8106, 5, 95, 0, 0, 8106, 8107, 7, 25, 0, 0, 8107, 8108, 7, 14, 0, 0, 8108, 8109, 7, 11, 0, 0, 8109, 8110, 5, 95, 0, 0, 8110, 8111, 7, 24, 0, 0, 8111, 8112, 7, 12, 0, 0, 8112, 8113, 7, 6, 0, 0, 8113, 8114, 7, 3, 0, 0, 8114, 8115, 7, 18, 0, 0, 8115, 8116, 5, 95, 0, 0, 8116, 8117, 7, 3, 0, 0, 8117, 8118, 7, 6, 0, 0, 8118, 8119, 7, 22, 0, 0, 8119, 8120, 7, 3, 0, 0, 8120, 8121, 7, 10, 0, 0, 8121, 8122, 7, 4, 0, 0, 8122, 8123, 7, 6, 0, 0, 8123, 624, 1, 0, 0, 0, 8124, 8125, 7, 8, 0, 0, 8125, 8126, 7, 2, 0, 0, 8126, 8127, 7, 12, 0, 0, 8127, 8128, 7, 7, 0, 0, 8128, 8129, 7, 4, 0, 0, 8129, 626, 1, 0, 0, 0, 8130, 8131, 7, 8, 0, 0, 8131, 8132, 7, 2, 0, 0, 8132, 8133, 7, 12, 0, 0, 8133, 8134, 7, 7, 0, 0, 8134, 8135, 7, 4, 0, 0, 8135, 8136, 7, 6, 0, 0, 8136, 8137, 7, 9, 0, 0, 8137, 628, 1, 0, 0, 0, 8138, 8139, 7, 8, 0, 0, 8139, 8140, 7, 2, 0, 0, 8140, 8141, 7, 13, 0, 0, 8141, 8142, 7, 0, 0, 0, 8142, 8143, 7, 3, 0, 0, 8143, 8144, 5, 95, 0, 0, 8144, 8145, 7, 15, 0, 0, 8145, 8146, 7, 2, 0, 0, 8146, 8147, 7, 15, 0, 0, 8147, 630, 1, 0, 0, 0, 8148, 8149, 7, 8, 0, 0, 8149, 8150, 7, 2, 0, 0, 8150, 8151, 7, 13, 0, 0, 8151, 8152, 7, 0, 0, 0, 8152, 8153, 7, 3, 0, 0, 8153, 8154, 5, 95, 0, 0, 8154, 8155, 7, 5, 0, 0, 8155, 8156, 7, 0, 0, 0, 8156, 8157, 7, 14, 0, 0, 8157, 8158, 7, 15, 0, 0, 8158, 632, 1, 0, 0, 0, 8159, 8160, 7, 8, 0, 0, 8160, 8161, 7, 15, 0, 0, 8161, 8162, 7, 12, 0, 0, 8162, 8163, 5, 95, 0, 0, 8163, 8164, 7, 8, 0, 0, 8164, 8165, 7, 2, 0, 0, 8165, 8166, 7, 5, 0, 0, 8166, 8167, 7, 4, 0, 0, 8167, 8168, 7, 10, 0, 0, 8168, 8169, 7, 7, 0, 0, 8169, 8170, 7, 17, 0, 0, 8170, 634, 1, 0, 0, 0, 8171, 8172, 7, 8, 0, 0, 8172, 8173, 7, 15, 0, 0, 8173, 8174, 7, 12, 0, 0, 8174, 8175, 5, 95, 0, 0, 8175, 8176, 7, 15, 0, 0, 8176, 8177, 7, 6, 0, 0, 8177, 8178, 7, 3, 0, 0, 8178, 8179, 5, 95, 0, 0, 8179, 8180, 7, 8, 0, 0, 8180, 8181, 7, 0, 0, 0, 8181, 8182, 7, 11, 0, 0, 8182, 8183, 7, 11, 0, 0, 8183, 636, 1, 0, 0, 0, 8184, 8185, 7, 8, 0, 0, 8185, 8186, 7, 15, 0, 0, 8186, 8187, 7, 12, 0, 0, 8187, 8188, 5, 95, 0, 0, 8188, 8189, 7, 15, 0, 0, 8189, 8190, 7, 6, 0, 0, 8190, 8191, 7, 3, 0, 0, 8191, 8192, 5, 95, 0, 0, 8192, 8193, 7, 5, 0, 0, 8193, 8194, 7, 6, 0, 0, 8194, 8195, 7, 5, 0, 0, 8195, 8196, 7, 5, 0, 0, 8196, 8197, 7, 10, 0, 0, 8197, 8198, 7, 2, 0, 0, 8198, 8199, 7, 7, 0, 0, 8199, 638, 1, 0, 0, 0, 8200, 8201, 7, 8, 0, 0, 8201, 8202, 7, 3, 0, 0, 8202, 8203, 7, 0, 0, 0, 8203, 8204, 7, 5, 0, 0, 8204, 8205, 7, 19, 0, 0, 8205, 640, 1, 0, 0, 0, 8206, 8207, 7, 8, 0, 0, 8207, 8208, 7, 3, 0, 0, 8208, 8209, 7, 6, 0, 0, 8209, 8210, 7, 0, 0, 0, 8210, 8211, 7, 4, 0, 0, 8211, 8212, 7, 6, 0, 0, 8212, 642, 1, 0, 0, 0, 8213, 8214, 7, 8, 0, 0, 8214, 8215, 7, 3, 0, 0, 8215, 8216, 7, 6, 0, 0, 8216, 8217, 7, 0, 0, 0, 8217, 8218, 7, 4, 0, 0, 8218, 8219, 7, 6, 0, 0, 8219, 8220, 5, 95, 0, 0, 8220, 8221, 7, 16, 0, 0, 8221, 8222, 7, 10, 0, 0, 8222, 8223, 7, 11, 0, 0, 8223, 8224, 7, 6, 0, 0, 8224, 8225, 5, 95, 0, 0, 8225, 8226, 7, 9, 0, 0, 8226, 8227, 7, 6, 0, 0, 8227, 8228, 7, 5, 0, 0, 8228, 8229, 7, 4, 0, 0, 8229, 644, 1, 0, 0, 0, 8230, 8231, 7, 8, 0, 0, 8231, 8232, 7, 3, 0, 0, 8232, 8233, 7, 6, 0, 0, 8233, 8234, 7, 0, 0, 0, 8234, 8235, 7, 4, 0, 0, 8235, 8236, 7, 6, 0, 0, 8236, 8237, 5, 95, 0, 0, 8237, 8238, 7, 5, 0, 0, 8238, 8239, 7, 4, 0, 0, 8239, 8240, 7, 2, 0, 0, 8240, 8241, 7, 3, 0, 0, 8241, 8242, 7, 6, 0, 0, 8242, 8243, 7, 9, 0, 0, 8243, 8244, 5, 95, 0, 0, 8244, 8245, 7, 2, 0, 0, 8245, 8246, 7, 12, 0, 0, 8246, 8247, 7, 4, 0, 0, 8247, 8248, 7, 11, 0, 0, 8248, 8249, 7, 10, 0, 0, 8249, 8250, 7, 7, 0, 0, 8250, 8251, 7, 6, 0, 0, 8251, 8252, 7, 5, 0, 0, 8252, 646, 1, 0, 0, 0, 8253, 8254, 7, 8, 0, 0, 8254, 8255, 7, 3, 0, 0, 8255, 8256, 7, 6, 0, 0, 8256, 8257, 7, 0, 0, 0, 8257, 8258, 7, 4, 0, 0, 8258, 8259, 7, 10, 0, 0, 8259, 8260, 7, 2, 0, 0, 8260, 8261, 7, 7, 0, 0, 8261, 648, 1, 0, 0, 0, 8262, 8263, 7, 8, 0, 0, 8263, 8264, 7, 3, 0, 0, 8264, 8265, 7, 6, 0, 0, 8265, 8266, 7, 9, 0, 0, 8266, 8267, 7, 6, 0, 0, 8267, 8268, 7, 7, 0, 0, 8268, 8269, 7, 4, 0, 0, 8269, 8270, 7, 10, 0, 0, 8270, 8271, 7, 0, 0, 0, 8271, 8272, 7, 11, 0, 0, 8272, 650, 1, 0, 0, 0, 8273, 8274, 7, 8, 0, 0, 8274, 8275, 7, 3, 0, 0, 8275, 8276, 7, 10, 0, 0, 8276, 8277, 7, 4, 0, 0, 8277, 8278, 7, 10, 0, 0, 8278, 8279, 7, 8, 0, 0, 8279, 8280, 7, 0, 0, 0, 8280, 8281, 7, 11, 0, 0, 8281, 652, 1, 0, 0, 0, 8282, 8283, 7, 8, 0, 0, 8283, 8284, 7, 3, 0, 0, 8284, 8285, 7, 2, 0, 0, 8285, 8286, 7, 5, 0, 0, 8286, 8287, 7, 5, 0, 0, 8287, 654, 1, 0, 0, 0, 8288, 8289, 7, 8, 0, 0, 8289, 8290, 7, 3, 0, 0, 8290, 8291, 7, 2, 0, 0, 8291, 8292, 7, 5, 0, 0, 8292, 8293, 7, 5, 0, 0, 8293, 8294, 7, 6, 0, 0, 8294, 8295, 7, 9, 0, 0, 8295, 8296, 7, 10, 0, 0, 8296, 8297, 7, 4, 0, 0, 8297, 8298, 7, 10, 0, 0, 8298, 8299, 7, 2, 0, 0, 8299, 8300, 7, 7, 0, 0, 8300, 656, 1, 0, 0, 0, 8301, 8302, 7, 8, 0, 0, 8302, 8303, 7, 5, 0, 0, 8303, 8304, 7, 8, 0, 0, 8304, 8305, 7, 2, 0, 0, 8305, 8306, 7, 7, 0, 0, 8306, 8307, 7, 13, 0, 0, 8307, 8308, 7, 6, 0, 0, 8308, 8309, 7, 3, 0, 0, 8309, 8310, 7, 4, 0, 0, 8310, 658, 1, 0, 0, 0, 8311, 8312, 7, 8, 0, 0, 8312, 8313, 7, 5, 0, 0, 8313, 8314, 7, 13, 0, 0, 8314, 660, 1, 0, 0, 0, 8315, 8316, 7, 8, 0, 0, 8316, 8317, 7, 12, 0, 0, 8317, 8318, 7, 1, 0, 0, 8318, 8319, 7, 6, 0, 0, 8319, 8320, 5, 95, 0, 0, 8320, 8321, 7, 0, 0, 0, 8321, 8322, 7, 20, 0, 0, 8322, 662, 1, 0, 0, 0, 8323, 8324, 7, 8, 0, 0, 8324, 8325, 7, 12, 0, 0, 8325, 8326, 7, 1, 0, 0, 8326, 8327, 7, 6, 0, 0, 8327, 664, 1, 0, 0, 0, 8328, 8329, 7, 8, 0, 0, 8329, 8330, 7, 12, 0, 0, 8330, 8331, 7, 1, 0, 0, 8331, 8332, 7, 6, 0, 0, 8332, 8333, 5, 95, 0, 0, 8333, 8334, 7, 17, 0, 0, 8334, 8335, 7, 1, 0, 0, 8335, 666, 1, 0, 0, 0, 8336, 8337, 7, 8, 0, 0, 8337, 8338, 7, 12, 0, 0, 8338, 8339, 7, 1, 0, 0, 8339, 8340, 7, 6, 0, 0, 8340, 8341, 5, 95, 0, 0, 8341, 8342, 7, 5, 0, 0, 8342, 8343, 7, 20, 0, 0, 8343, 668, 1, 0, 0, 0, 8344, 8345, 7, 8, 0, 0, 8345, 8346, 7, 12, 0, 0, 8346, 8347, 7, 14, 0, 0, 8347, 8348, 7, 6, 0, 0, 8348, 8349, 5, 95, 0, 0, 8349, 8350, 7, 9, 0, 0, 8350, 8351, 7, 10, 0, 0, 8351, 8352, 7, 5, 0, 0, 8352, 8353, 7, 4, 0, 0, 8353, 8354, 7, 14, 0, 0, 8354, 670, 1, 0, 0, 0, 8355, 8356, 7, 8, 0, 0, 8356, 8357, 7, 12, 0, 0, 8357, 8358, 7, 3, 0, 0, 8358, 8359, 7, 3, 0, 0, 8359, 8360, 7, 6, 0, 0, 8360, 8361, 7, 7, 0, 0, 8361, 8362, 7, 4, 0, 0, 8362, 672, 1, 0, 0, 0, 8363, 8364, 7, 8, 0, 0, 8364, 8365, 7, 12, 0, 0, 8365, 8366, 7, 3, 0, 0, 8366, 8367, 7, 3, 0, 0, 8367, 8368, 7, 6, 0, 0, 8368, 8369, 7, 7, 0, 0, 8369, 8370, 7, 4, 0, 0, 8370, 8371, 5, 95, 0, 0, 8371, 8372, 7, 9, 0, 0, 8372, 8373, 7, 0, 0, 0, 8373, 8374, 7, 4, 0, 0, 8374, 8375, 7, 6, 0, 0, 8375, 674, 1, 0, 0, 0, 8376, 8377, 7, 8, 0, 0, 8377, 8378, 7, 12, 0, 0, 8378, 8379, 7, 3, 0, 0, 8379, 8380, 7, 3, 0, 0, 8380, 8381, 7, 6, 0, 0, 8381, 8382, 7, 7, 0, 0, 8382, 8383, 7, 4, 0, 0, 8383, 8384, 5, 95, 0, 0, 8384, 8385, 7, 5, 0, 0, 8385, 8386, 7, 8, 0, 0, 8386, 8387, 7, 19, 0, 0, 8387, 8388, 7, 6, 0, 0, 8388, 8389, 7, 14, 0, 0, 8389, 8390, 7, 0, 0, 0, 8390, 676, 1, 0, 0, 0, 8391, 8392, 7, 8, 0, 0, 8392, 8393, 7, 12, 0, 0, 8393, 8394, 7, 3, 0, 0, 8394, 8395, 7, 3, 0, 0, 8395, 8396, 7, 6, 0, 0, 8396, 8397, 7, 7, 0, 0, 8397, 8398, 7, 4, 0, 0, 8398, 8399, 5, 95, 0, 0, 8399, 8400, 7, 4, 0, 0, 8400, 8401, 7, 10, 0, 0, 8401, 8402, 7, 14, 0, 0, 8402, 8403, 7, 6, 0, 0, 8403, 678, 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, 4, 0, 0, 8413, 8414, 7, 10, 0, 0, 8414, 8415, 7, 14, 0, 0, 8415, 8416, 7, 6, 0, 0, 8416, 8417, 7, 5, 0, 0, 8417, 8418, 7, 4, 0, 0, 8418, 8419, 7, 0, 0, 0, 8419, 8420, 7, 14, 0, 0, 8420, 8421, 7, 15, 0, 0, 8421, 680, 1, 0, 0, 0, 8422, 8423, 7, 8, 0, 0, 8423, 8424, 7, 12, 0, 0, 8424, 8425, 7, 3, 0, 0, 8425, 8426, 7, 3, 0, 0, 8426, 8427, 7, 6, 0, 0, 8427, 8428, 7, 7, 0, 0, 8428, 8429, 7, 4, 0, 0, 8429, 8430, 5, 95, 0, 0, 8430, 8431, 7, 12, 0, 0, 8431, 8432, 7, 5, 0, 0, 8432, 8433, 7, 6, 0, 0, 8433, 8434, 7, 3, 0, 0, 8434, 682, 1, 0, 0, 0, 8435, 8436, 7, 8, 0, 0, 8436, 8437, 7, 12, 0, 0, 8437, 8438, 7, 3, 0, 0, 8438, 8439, 7, 3, 0, 0, 8439, 8440, 7, 6, 0, 0, 8440, 8441, 7, 7, 0, 0, 8441, 8442, 7, 4, 0, 0, 8442, 8443, 7, 13, 0, 0, 8443, 684, 1, 0, 0, 0, 8444, 8445, 7, 8, 0, 0, 8445, 8446, 7, 12, 0, 0, 8446, 8447, 7, 3, 0, 0, 8447, 8448, 7, 5, 0, 0, 8448, 8449, 7, 2, 0, 0, 8449, 8450, 7, 3, 0, 0, 8450, 686, 1, 0, 0, 0, 8451, 8452, 7, 8, 0, 0, 8452, 8453, 7, 12, 0, 0, 8453, 8454, 7, 3, 0, 0, 8454, 8455, 7, 5, 0, 0, 8455, 8456, 7, 2, 0, 0, 8456, 8457, 7, 3, 0, 0, 8457, 8458, 5, 95, 0, 0, 8458, 8459, 7, 5, 0, 0, 8459, 8460, 7, 19, 0, 0, 8460, 8461, 7, 0, 0, 0, 8461, 8462, 7, 3, 0, 0, 8462, 8463, 7, 10, 0, 0, 8463, 8464, 7, 7, 0, 0, 8464, 8465, 7, 17, 0, 0, 8465, 8466, 5, 95, 0, 0, 8466, 8467, 7, 6, 0, 0, 8467, 8468, 7, 25, 0, 0, 8468, 8469, 7, 0, 0, 0, 8469, 8470, 7, 8, 0, 0, 8470, 8471, 7, 4, 0, 0, 8471, 688, 1, 0, 0, 0, 8472, 8473, 7, 8, 0, 0, 8473, 8474, 7, 12, 0, 0, 8474, 8475, 7, 3, 0, 0, 8475, 8476, 7, 5, 0, 0, 8476, 8477, 7, 2, 0, 0, 8477, 8478, 7, 3, 0, 0, 8478, 8479, 5, 95, 0, 0, 8479, 8480, 7, 5, 0, 0, 8480, 8481, 7, 15, 0, 0, 8481, 8482, 7, 6, 0, 0, 8482, 8483, 7, 8, 0, 0, 8483, 8484, 7, 10, 0, 0, 8484, 8485, 7, 16, 0, 0, 8485, 8486, 7, 10, 0, 0, 8486, 8487, 7, 8, 0, 0, 8487, 8488, 5, 95, 0, 0, 8488, 8489, 7, 5, 0, 0, 8489, 8490, 7, 6, 0, 0, 8490, 8491, 7, 17, 0, 0, 8491, 8492, 7, 14, 0, 0, 8492, 8493, 7, 6, 0, 0, 8493, 8494, 7, 7, 0, 0, 8494, 8495, 7, 4, 0, 0, 8495, 690, 1, 0, 0, 0, 8496, 8497, 7, 8, 0, 0, 8497, 8498, 7, 12, 0, 0, 8498, 8499, 7, 5, 0, 0, 8499, 8500, 7, 4, 0, 0, 8500, 8501, 7, 2, 0, 0, 8501, 8502, 7, 14, 0, 0, 8502, 8503, 7, 9, 0, 0, 8503, 8504, 7, 0, 0, 0, 8504, 8505, 7, 4, 0, 0, 8505, 8506, 7, 12, 0, 0, 8506, 8507, 7, 14, 0, 0, 8507, 692, 1, 0, 0, 0, 8508, 8509, 7, 8, 0, 0, 8509, 8510, 7, 13, 0, 0, 8510, 694, 1, 0, 0, 0, 8511, 8512, 7, 8, 0, 0, 8512, 8513, 7, 18, 0, 0, 8513, 8514, 7, 8, 0, 0, 8514, 8515, 7, 11, 0, 0, 8515, 8516, 7, 6, 0, 0, 8516, 696, 1, 0, 0, 0, 8517, 8518, 7, 9, 0, 0, 8518, 8519, 7, 0, 0, 0, 8519, 8520, 7, 7, 0, 0, 8520, 8521, 7, 17, 0, 0, 8521, 8522, 7, 11, 0, 0, 8522, 8523, 7, 10, 0, 0, 8523, 8524, 7, 7, 0, 0, 8524, 8525, 7, 17, 0, 0, 8525, 698, 1, 0, 0, 0, 8526, 8527, 7, 9, 0, 0, 8527, 8528, 7, 0, 0, 0, 8528, 8529, 7, 4, 0, 0, 8529, 8530, 7, 0, 0, 0, 8530, 8531, 7, 1, 0, 0, 8531, 8532, 7, 0, 0, 0, 8532, 8533, 7, 5, 0, 0, 8533, 8534, 7, 6, 0, 0, 8534, 700, 1, 0, 0, 0, 8535, 8536, 7, 9, 0, 0, 8536, 8537, 7, 0, 0, 0, 8537, 8538, 7, 4, 0, 0, 8538, 8539, 7, 0, 0, 0, 8539, 702, 1, 0, 0, 0, 8540, 8541, 7, 9, 0, 0, 8541, 8542, 7, 0, 0, 0, 8542, 8543, 7, 4, 0, 0, 8543, 8544, 7, 0, 0, 0, 8544, 8545, 7, 16, 0, 0, 8545, 8546, 7, 10, 0, 0, 8546, 8547, 7, 11, 0, 0, 8547, 8548, 7, 6, 0, 0, 8548, 704, 1, 0, 0, 0, 8549, 8550, 7, 9, 0, 0, 8550, 8551, 7, 0, 0, 0, 8551, 8552, 7, 4, 0, 0, 8552, 8553, 7, 0, 0, 0, 8553, 8554, 7, 16, 0, 0, 8554, 8555, 7, 10, 0, 0, 8555, 8556, 7, 11, 0, 0, 8556, 8557, 7, 6, 0, 0, 8557, 8558, 7, 5, 0, 0, 8558, 706, 1, 0, 0, 0, 8559, 8560, 7, 9, 0, 0, 8560, 8561, 7, 0, 0, 0, 8561, 8562, 7, 4, 0, 0, 8562, 8563, 7, 0, 0, 0, 8563, 8564, 7, 17, 0, 0, 8564, 8565, 7, 12, 0, 0, 8565, 8566, 7, 0, 0, 0, 8566, 8567, 7, 3, 0, 0, 8567, 8568, 7, 9, 0, 0, 8568, 8569, 7, 8, 0, 0, 8569, 8570, 7, 2, 0, 0, 8570, 8571, 7, 7, 0, 0, 8571, 8572, 7, 16, 0, 0, 8572, 8573, 7, 10, 0, 0, 8573, 8574, 7, 17, 0, 0, 8574, 708, 1, 0, 0, 0, 8575, 8576, 7, 9, 0, 0, 8576, 8577, 7, 0, 0, 0, 8577, 8578, 7, 4, 0, 0, 8578, 8579, 7, 0, 0, 0, 8579, 8580, 7, 14, 0, 0, 8580, 8581, 7, 2, 0, 0, 8581, 8582, 7, 13, 0, 0, 8582, 8583, 7, 6, 0, 0, 8583, 8584, 7, 14, 0, 0, 8584, 8585, 7, 6, 0, 0, 8585, 8586, 7, 7, 0, 0, 8586, 8587, 7, 4, 0, 0, 8587, 710, 1, 0, 0, 0, 8588, 8589, 7, 9, 0, 0, 8589, 8590, 7, 0, 0, 0, 8590, 8591, 7, 4, 0, 0, 8591, 8592, 7, 0, 0, 0, 8592, 8593, 7, 2, 0, 0, 8593, 8594, 7, 1, 0, 0, 8594, 8595, 7, 20, 0, 0, 8595, 8596, 7, 7, 0, 0, 8596, 8597, 7, 2, 0, 0, 8597, 712, 1, 0, 0, 0, 8598, 8599, 7, 9, 0, 0, 8599, 8600, 7, 0, 0, 0, 8600, 8601, 7, 4, 0, 0, 8601, 8602, 7, 0, 0, 0, 8602, 8603, 7, 2, 0, 0, 8603, 8604, 7, 1, 0, 0, 8604, 8605, 7, 20, 0, 0, 8605, 8606, 5, 95, 0, 0, 8606, 8607, 7, 4, 0, 0, 8607, 8608, 7, 2, 0, 0, 8608, 8609, 5, 95, 0, 0, 8609, 8610, 7, 14, 0, 0, 8610, 8611, 7, 0, 0, 0, 8611, 8612, 7, 4, 0, 0, 8612, 8613, 5, 95, 0, 0, 8613, 8614, 7, 15, 0, 0, 8614, 8615, 7, 0, 0, 0, 8615, 8616, 7, 3, 0, 0, 8616, 8617, 7, 4, 0, 0, 8617, 8618, 7, 10, 0, 0, 8618, 8619, 7, 4, 0, 0, 8619, 8620, 7, 10, 0, 0, 8620, 8621, 7, 2, 0, 0, 8621, 8622, 7, 7, 0, 0, 8622, 714, 1, 0, 0, 0, 8623, 8624, 7, 9, 0, 0, 8624, 8625, 7, 0, 0, 0, 8625, 8626, 7, 4, 0, 0, 8626, 8627, 7, 0, 0, 0, 8627, 8628, 7, 2, 0, 0, 8628, 8629, 7, 1, 0, 0, 8629, 8630, 7, 20, 0, 0, 8630, 8631, 5, 95, 0, 0, 8631, 8632, 7, 4, 0, 0, 8632, 8633, 7, 2, 0, 0, 8633, 8634, 5, 95, 0, 0, 8634, 8635, 7, 15, 0, 0, 8635, 8636, 7, 0, 0, 0, 8636, 8637, 7, 3, 0, 0, 8637, 8638, 7, 4, 0, 0, 8638, 8639, 7, 10, 0, 0, 8639, 8640, 7, 4, 0, 0, 8640, 8641, 7, 10, 0, 0, 8641, 8642, 7, 2, 0, 0, 8642, 8643, 7, 7, 0, 0, 8643, 716, 1, 0, 0, 0, 8644, 8645, 7, 9, 0, 0, 8645, 8646, 7, 0, 0, 0, 8646, 8647, 7, 4, 0, 0, 8647, 8648, 7, 0, 0, 0, 8648, 8649, 7, 15, 0, 0, 8649, 8650, 7, 12, 0, 0, 8650, 8651, 7, 14, 0, 0, 8651, 8652, 7, 15, 0, 0, 8652, 718, 1, 0, 0, 0, 8653, 8654, 7, 9, 0, 0, 8654, 8655, 7, 0, 0, 0, 8655, 8656, 7, 4, 0, 0, 8656, 8657, 7, 0, 0, 0, 8657, 8658, 5, 95, 0, 0, 8658, 8659, 7, 5, 0, 0, 8659, 8660, 7, 6, 0, 0, 8660, 8661, 7, 8, 0, 0, 8661, 8662, 7, 12, 0, 0, 8662, 8663, 7, 3, 0, 0, 8663, 8664, 7, 10, 0, 0, 8664, 8665, 7, 4, 0, 0, 8665, 8666, 7, 18, 0, 0, 8666, 8667, 5, 95, 0, 0, 8667, 8668, 7, 3, 0, 0, 8668, 8669, 7, 6, 0, 0, 8669, 8670, 7, 22, 0, 0, 8670, 8671, 7, 3, 0, 0, 8671, 8672, 7, 10, 0, 0, 8672, 8673, 7, 4, 0, 0, 8673, 8674, 7, 6, 0, 0, 8674, 8675, 5, 95, 0, 0, 8675, 8676, 7, 11, 0, 0, 8676, 8677, 7, 10, 0, 0, 8677, 8678, 7, 14, 0, 0, 8678, 8679, 7, 10, 0, 0, 8679, 8680, 7, 4, 0, 0, 8680, 720, 1, 0, 0, 0, 8681, 8682, 7, 9, 0, 0, 8682, 8683, 7, 0, 0, 0, 8683, 8684, 7, 4, 0, 0, 8684, 8685, 7, 6, 0, 0, 8685, 722, 1, 0, 0, 0, 8686, 8687, 7, 9, 0, 0, 8687, 8688, 7, 0, 0, 0, 8688, 8689, 7, 4, 0, 0, 8689, 8690, 7, 6, 0, 0, 8690, 8691, 5, 95, 0, 0, 8691, 8692, 7, 8, 0, 0, 8692, 8693, 7, 0, 0, 0, 8693, 8694, 7, 8, 0, 0, 8694, 8695, 7, 19, 0, 0, 8695, 8696, 7, 6, 0, 0, 8696, 724, 1, 0, 0, 0, 8697, 8698, 7, 9, 0, 0, 8698, 8699, 7, 0, 0, 0, 8699, 8700, 7, 4, 0, 0, 8700, 8701, 7, 6, 0, 0, 8701, 8702, 5, 95, 0, 0, 8702, 8703, 7, 16, 0, 0, 8703, 8704, 7, 2, 0, 0, 8704, 8705, 7, 3, 0, 0, 8705, 8706, 7, 14, 0, 0, 8706, 8707, 7, 0, 0, 0, 8707, 8708, 7, 4, 0, 0, 8708, 726, 1, 0, 0, 0, 8709, 8710, 7, 9, 0, 0, 8710, 8711, 7, 0, 0, 0, 8711, 8712, 7, 4, 0, 0, 8712, 8713, 7, 6, 0, 0, 8713, 8714, 5, 95, 0, 0, 8714, 8715, 7, 14, 0, 0, 8715, 8716, 7, 2, 0, 0, 8716, 8717, 7, 9, 0, 0, 8717, 8718, 7, 6, 0, 0, 8718, 728, 1, 0, 0, 0, 8719, 8720, 7, 9, 0, 0, 8720, 8721, 7, 0, 0, 0, 8721, 8722, 7, 18, 0, 0, 8722, 730, 1, 0, 0, 0, 8723, 8724, 7, 9, 0, 0, 8724, 8725, 7, 0, 0, 0, 8725, 8726, 7, 18, 0, 0, 8726, 8727, 7, 5, 0, 0, 8727, 732, 1, 0, 0, 0, 8728, 8729, 7, 9, 0, 0, 8729, 8730, 7, 0, 0, 0, 8730, 8731, 7, 18, 0, 0, 8731, 8732, 5, 95, 0, 0, 8732, 8733, 7, 4, 0, 0, 8733, 8734, 7, 2, 0, 0, 8734, 8735, 5, 95, 0, 0, 8735, 8736, 7, 5, 0, 0, 8736, 8737, 7, 6, 0, 0, 8737, 8738, 7, 8, 0, 0, 8738, 8739, 7, 2, 0, 0, 8739, 8740, 7, 7, 0, 0, 8740, 8741, 7, 9, 0, 0, 8741, 734, 1, 0, 0, 0, 8742, 8743, 7, 9, 0, 0, 8743, 8744, 7, 1, 0, 0, 8744, 8745, 7, 0, 0, 0, 8745, 736, 1, 0, 0, 0, 8746, 8747, 7, 9, 0, 0, 8747, 8748, 7, 1, 0, 0, 8748, 8749, 7, 0, 0, 0, 8749, 8750, 5, 95, 0, 0, 8750, 8751, 7, 3, 0, 0, 8751, 8752, 7, 6, 0, 0, 8752, 8753, 7, 8, 0, 0, 8753, 8754, 7, 18, 0, 0, 8754, 8755, 7, 8, 0, 0, 8755, 8756, 7, 11, 0, 0, 8756, 8757, 7, 6, 0, 0, 8757, 8758, 7, 1, 0, 0, 8758, 8759, 7, 10, 0, 0, 8759, 8760, 7, 7, 0, 0, 8760, 738, 1, 0, 0, 0, 8761, 8762, 7, 9, 0, 0, 8762, 8763, 7, 1, 0, 0, 8763, 8764, 7, 11, 0, 0, 8764, 8765, 7, 10, 0, 0, 8765, 8766, 7, 7, 0, 0, 8766, 8767, 7, 21, 0, 0, 8767, 740, 1, 0, 0, 0, 8768, 8769, 7, 9, 0, 0, 8769, 8770, 7, 1, 0, 0, 8770, 8771, 7, 14, 0, 0, 8771, 8772, 7, 5, 0, 0, 8772, 8773, 5, 95, 0, 0, 8773, 8774, 7, 5, 0, 0, 8774, 8775, 7, 4, 0, 0, 8775, 8776, 7, 0, 0, 0, 8776, 8777, 7, 4, 0, 0, 8777, 8778, 7, 5, 0, 0, 8778, 742, 1, 0, 0, 0, 8779, 8780, 7, 9, 0, 0, 8780, 8781, 7, 1, 0, 0, 8781, 8782, 5, 95, 0, 0, 8782, 8783, 7, 3, 0, 0, 8783, 8784, 7, 2, 0, 0, 8784, 8785, 7, 11, 0, 0, 8785, 8786, 7, 6, 0, 0, 8786, 8787, 5, 95, 0, 0, 8787, 8788, 7, 8, 0, 0, 8788, 8789, 7, 19, 0, 0, 8789, 8790, 7, 0, 0, 0, 8790, 8791, 7, 7, 0, 0, 8791, 8792, 7, 17, 0, 0, 8792, 8793, 7, 6, 0, 0, 8793, 744, 1, 0, 0, 0, 8794, 8795, 7, 9, 0, 0, 8795, 8796, 7, 1, 0, 0, 8796, 8797, 7, 4, 0, 0, 8797, 8798, 7, 10, 0, 0, 8798, 8799, 7, 14, 0, 0, 8799, 8800, 7, 6, 0, 0, 8800, 8801, 7, 23, 0, 0, 8801, 8802, 7, 2, 0, 0, 8802, 8803, 7, 7, 0, 0, 8803, 8804, 7, 6, 0, 0, 8804, 746, 1, 0, 0, 0, 8805, 8806, 7, 9, 0, 0, 8806, 8807, 7, 1, 0, 0, 8807, 8808, 5, 95, 0, 0, 8808, 8809, 7, 12, 0, 0, 8809, 8810, 7, 7, 0, 0, 8810, 8811, 7, 10, 0, 0, 8811, 8812, 7, 24, 0, 0, 8812, 8813, 7, 12, 0, 0, 8813, 8814, 7, 6, 0, 0, 8814, 8815, 5, 95, 0, 0, 8815, 8816, 7, 7, 0, 0, 8816, 8817, 7, 0, 0, 0, 8817, 8818, 7, 14, 0, 0, 8818, 8819, 7, 6, 0, 0, 8819, 748, 1, 0, 0, 0, 8820, 8821, 7, 9, 0, 0, 8821, 8822, 7, 1, 0, 0, 8822, 8823, 5, 95, 0, 0, 8823, 8824, 7, 13, 0, 0, 8824, 8825, 7, 6, 0, 0, 8825, 8826, 7, 3, 0, 0, 8826, 8827, 7, 5, 0, 0, 8827, 8828, 7, 10, 0, 0, 8828, 8829, 7, 2, 0, 0, 8829, 8830, 7, 7, 0, 0, 8830, 750, 1, 0, 0, 0, 8831, 8832, 7, 9, 0, 0, 8832, 8833, 7, 9, 0, 0, 8833, 8834, 7, 11, 0, 0, 8834, 752, 1, 0, 0, 0, 8835, 8836, 7, 9, 0, 0, 8836, 8837, 7, 6, 0, 0, 8837, 8838, 7, 0, 0, 0, 8838, 8839, 7, 11, 0, 0, 8839, 8840, 7, 11, 0, 0, 8840, 8841, 7, 2, 0, 0, 8841, 8842, 7, 8, 0, 0, 8842, 8843, 7, 0, 0, 0, 8843, 8844, 7, 4, 0, 0, 8844, 8845, 7, 6, 0, 0, 8845, 754, 1, 0, 0, 0, 8846, 8847, 7, 9, 0, 0, 8847, 8848, 7, 6, 0, 0, 8848, 8849, 7, 1, 0, 0, 8849, 8850, 7, 12, 0, 0, 8850, 8851, 7, 17, 0, 0, 8851, 756, 1, 0, 0, 0, 8852, 8853, 7, 9, 0, 0, 8853, 8854, 7, 6, 0, 0, 8854, 8855, 7, 1, 0, 0, 8855, 8856, 7, 12, 0, 0, 8856, 8857, 7, 17, 0, 0, 8857, 8858, 7, 17, 0, 0, 8858, 8859, 7, 6, 0, 0, 8859, 8860, 7, 3, 0, 0, 8860, 758, 1, 0, 0, 0, 8861, 8862, 7, 9, 0, 0, 8862, 8863, 7, 6, 0, 0, 8863, 8864, 7, 8, 0, 0, 8864, 760, 1, 0, 0, 0, 8865, 8866, 7, 9, 0, 0, 8866, 8867, 7, 6, 0, 0, 8867, 8868, 7, 8, 0, 0, 8868, 8869, 7, 10, 0, 0, 8869, 8870, 7, 14, 0, 0, 8870, 8871, 7, 0, 0, 0, 8871, 8872, 7, 11, 0, 0, 8872, 762, 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, 11, 0, 0, 8877, 8878, 7, 0, 0, 0, 8878, 8879, 7, 3, 0, 0, 8879, 8880, 7, 6, 0, 0, 8880, 764, 1, 0, 0, 0, 8881, 8882, 7, 9, 0, 0, 8882, 8883, 7, 6, 0, 0, 8883, 8884, 7, 8, 0, 0, 8884, 8885, 7, 2, 0, 0, 8885, 8886, 7, 14, 0, 0, 8886, 8887, 7, 15, 0, 0, 8887, 8888, 7, 2, 0, 0, 8888, 8889, 7, 5, 0, 0, 8889, 8890, 7, 6, 0, 0, 8890, 766, 1, 0, 0, 0, 8891, 8892, 7, 9, 0, 0, 8892, 8893, 7, 6, 0, 0, 8893, 8894, 7, 8, 0, 0, 8894, 8895, 7, 2, 0, 0, 8895, 8896, 7, 3, 0, 0, 8896, 8897, 7, 3, 0, 0, 8897, 8898, 7, 6, 0, 0, 8898, 8899, 7, 11, 0, 0, 8899, 8900, 7, 0, 0, 0, 8900, 8901, 7, 4, 0, 0, 8901, 8902, 7, 6, 0, 0, 8902, 768, 1, 0, 0, 0, 8903, 8904, 7, 9, 0, 0, 8904, 8905, 7, 6, 0, 0, 8905, 8906, 7, 8, 0, 0, 8906, 8907, 7, 3, 0, 0, 8907, 770, 1, 0, 0, 0, 8908, 8909, 7, 9, 0, 0, 8909, 8910, 7, 6, 0, 0, 8910, 8911, 7, 8, 0, 0, 8911, 8912, 7, 3, 0, 0, 8912, 8913, 7, 6, 0, 0, 8913, 8914, 7, 14, 0, 0, 8914, 8915, 7, 6, 0, 0, 8915, 8916, 7, 7, 0, 0, 8916, 8917, 7, 4, 0, 0, 8917, 772, 1, 0, 0, 0, 8918, 8919, 7, 9, 0, 0, 8919, 8920, 7, 6, 0, 0, 8920, 8921, 7, 8, 0, 0, 8921, 8922, 7, 3, 0, 0, 8922, 8923, 7, 18, 0, 0, 8923, 8924, 7, 15, 0, 0, 8924, 8925, 7, 4, 0, 0, 8925, 774, 1, 0, 0, 0, 8926, 8927, 7, 9, 0, 0, 8927, 8928, 7, 6, 0, 0, 8928, 8929, 7, 9, 0, 0, 8929, 8930, 7, 12, 0, 0, 8930, 8931, 7, 15, 0, 0, 8931, 8932, 7, 11, 0, 0, 8932, 8933, 7, 10, 0, 0, 8933, 8934, 7, 8, 0, 0, 8934, 8935, 7, 0, 0, 0, 8935, 8936, 7, 4, 0, 0, 8936, 8937, 7, 6, 0, 0, 8937, 776, 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, 778, 1, 0, 0, 0, 8946, 8947, 7, 9, 0, 0, 8947, 8948, 7, 6, 0, 0, 8948, 8949, 7, 16, 0, 0, 8949, 8950, 7, 0, 0, 0, 8950, 8951, 7, 12, 0, 0, 8951, 8952, 7, 11, 0, 0, 8952, 8953, 7, 4, 0, 0, 8953, 8954, 7, 10, 0, 0, 8954, 8955, 7, 16, 0, 0, 8955, 780, 1, 0, 0, 0, 8956, 8957, 7, 9, 0, 0, 8957, 8958, 7, 6, 0, 0, 8958, 8959, 7, 16, 0, 0, 8959, 8960, 7, 0, 0, 0, 8960, 8961, 7, 12, 0, 0, 8961, 8962, 7, 11, 0, 0, 8962, 8963, 7, 4, 0, 0, 8963, 8964, 7, 5, 0, 0, 8964, 782, 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, 2, 0, 0, 8975, 8976, 7, 11, 0, 0, 8976, 8977, 7, 11, 0, 0, 8977, 8978, 7, 0, 0, 0, 8978, 8979, 7, 4, 0, 0, 8979, 8980, 7, 10, 0, 0, 8980, 8981, 7, 2, 0, 0, 8981, 8982, 7, 7, 0, 0, 8982, 784, 1, 0, 0, 0, 8983, 8984, 7, 9, 0, 0, 8984, 8985, 7, 6, 0, 0, 8985, 8986, 7, 16, 0, 0, 8986, 8987, 7, 0, 0, 0, 8987, 8988, 7, 12, 0, 0, 8988, 8989, 7, 11, 0, 0, 8989, 8990, 7, 4, 0, 0, 8990, 8991, 5, 95, 0, 0, 8991, 8992, 7, 8, 0, 0, 8992, 8993, 7, 3, 0, 0, 8993, 8994, 7, 6, 0, 0, 8994, 8995, 7, 9, 0, 0, 8995, 8996, 7, 6, 0, 0, 8996, 8997, 7, 7, 0, 0, 8997, 8998, 7, 4, 0, 0, 8998, 8999, 7, 10, 0, 0, 8999, 9000, 7, 0, 0, 0, 9000, 9001, 7, 11, 0, 0, 9001, 786, 1, 0, 0, 0, 9002, 9003, 7, 9, 0, 0, 9003, 9004, 7, 6, 0, 0, 9004, 9005, 7, 16, 0, 0, 9005, 9006, 7, 6, 0, 0, 9006, 9007, 7, 3, 0, 0, 9007, 9008, 7, 3, 0, 0, 9008, 9009, 7, 0, 0, 0, 9009, 9010, 7, 1, 0, 0, 9010, 9011, 7, 11, 0, 0, 9011, 9012, 7, 6, 0, 0, 9012, 788, 1, 0, 0, 0, 9013, 9014, 7, 9, 0, 0, 9014, 9015, 7, 6, 0, 0, 9015, 9016, 7, 16, 0, 0, 9016, 9017, 7, 6, 0, 0, 9017, 9018, 7, 3, 0, 0, 9018, 9019, 7, 3, 0, 0, 9019, 9020, 7, 6, 0, 0, 9020, 9021, 7, 9, 0, 0, 9021, 790, 1, 0, 0, 0, 9022, 9023, 7, 9, 0, 0, 9023, 9024, 7, 6, 0, 0, 9024, 9025, 7, 16, 0, 0, 9025, 9026, 7, 10, 0, 0, 9026, 9027, 7, 7, 0, 0, 9027, 9028, 7, 6, 0, 0, 9028, 9029, 7, 9, 0, 0, 9029, 792, 1, 0, 0, 0, 9030, 9031, 7, 9, 0, 0, 9031, 9032, 7, 6, 0, 0, 9032, 9033, 7, 16, 0, 0, 9033, 9034, 7, 10, 0, 0, 9034, 9035, 7, 7, 0, 0, 9035, 9036, 7, 6, 0, 0, 9036, 794, 1, 0, 0, 0, 9037, 9038, 7, 9, 0, 0, 9038, 9039, 7, 6, 0, 0, 9039, 9040, 7, 16, 0, 0, 9040, 9041, 7, 10, 0, 0, 9041, 9042, 7, 7, 0, 0, 9042, 9043, 7, 6, 0, 0, 9043, 9044, 7, 3, 0, 0, 9044, 796, 1, 0, 0, 0, 9045, 9046, 7, 9, 0, 0, 9046, 9047, 7, 6, 0, 0, 9047, 9048, 7, 17, 0, 0, 9048, 9049, 7, 3, 0, 0, 9049, 9050, 7, 6, 0, 0, 9050, 9051, 7, 6, 0, 0, 9051, 798, 1, 0, 0, 0, 9052, 9053, 7, 9, 0, 0, 9053, 9054, 7, 6, 0, 0, 9054, 9055, 7, 11, 0, 0, 9055, 9056, 7, 0, 0, 0, 9056, 9057, 7, 18, 0, 0, 9057, 800, 1, 0, 0, 0, 9058, 9059, 7, 9, 0, 0, 9059, 9060, 7, 6, 0, 0, 9060, 9061, 7, 11, 0, 0, 9061, 9062, 7, 6, 0, 0, 9062, 9063, 7, 17, 0, 0, 9063, 9064, 7, 0, 0, 0, 9064, 9065, 7, 4, 0, 0, 9065, 9066, 7, 6, 0, 0, 9066, 802, 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, 5, 95, 0, 0, 9074, 9075, 7, 0, 0, 0, 9075, 9076, 7, 11, 0, 0, 9076, 9077, 7, 11, 0, 0, 9077, 804, 1, 0, 0, 0, 9078, 9079, 7, 9, 0, 0, 9079, 9080, 7, 6, 0, 0, 9080, 9081, 7, 11, 0, 0, 9081, 9082, 7, 6, 0, 0, 9082, 9083, 7, 4, 0, 0, 9083, 9084, 7, 6, 0, 0, 9084, 806, 1, 0, 0, 0, 9085, 9086, 7, 9, 0, 0, 9086, 9087, 7, 6, 0, 0, 9087, 9088, 7, 11, 0, 0, 9088, 9089, 7, 6, 0, 0, 9089, 9090, 7, 4, 0, 0, 9090, 9091, 7, 6, 0, 0, 9091, 9092, 7, 25, 0, 0, 9092, 9093, 7, 14, 0, 0, 9093, 9094, 7, 11, 0, 0, 9094, 808, 1, 0, 0, 0, 9095, 9096, 7, 9, 0, 0, 9096, 9097, 7, 6, 0, 0, 9097, 9098, 7, 11, 0, 0, 9098, 9099, 7, 10, 0, 0, 9099, 9100, 7, 14, 0, 0, 9100, 9101, 7, 10, 0, 0, 9101, 9102, 7, 4, 0, 0, 9102, 9103, 7, 6, 0, 0, 9103, 9104, 7, 9, 0, 0, 9104, 810, 1, 0, 0, 0, 9105, 9106, 7, 9, 0, 0, 9106, 9107, 7, 6, 0, 0, 9107, 9108, 7, 14, 0, 0, 9108, 9109, 7, 0, 0, 0, 9109, 9110, 7, 7, 0, 0, 9110, 9111, 7, 9, 0, 0, 9111, 812, 1, 0, 0, 0, 9112, 9113, 7, 9, 0, 0, 9113, 9114, 7, 6, 0, 0, 9114, 9115, 7, 7, 0, 0, 9115, 9116, 7, 5, 0, 0, 9116, 9117, 7, 6, 0, 0, 9117, 9118, 5, 95, 0, 0, 9118, 9119, 7, 3, 0, 0, 9119, 9120, 7, 0, 0, 0, 9120, 9121, 7, 7, 0, 0, 9121, 9122, 7, 21, 0, 0, 9122, 9123, 7, 14, 0, 0, 9123, 814, 1, 0, 0, 0, 9124, 9125, 7, 9, 0, 0, 9125, 9126, 7, 6, 0, 0, 9126, 9127, 7, 15, 0, 0, 9127, 9128, 7, 6, 0, 0, 9128, 9129, 7, 7, 0, 0, 9129, 9130, 7, 9, 0, 0, 9130, 9131, 7, 6, 0, 0, 9131, 9132, 7, 7, 0, 0, 9132, 9133, 7, 4, 0, 0, 9133, 816, 1, 0, 0, 0, 9134, 9135, 7, 9, 0, 0, 9135, 9136, 7, 6, 0, 0, 9136, 9137, 7, 15, 0, 0, 9137, 9138, 7, 3, 0, 0, 9138, 9139, 7, 6, 0, 0, 9139, 9140, 7, 8, 0, 0, 9140, 9141, 7, 0, 0, 0, 9141, 9142, 7, 4, 0, 0, 9142, 9143, 7, 6, 0, 0, 9143, 818, 1, 0, 0, 0, 9144, 9145, 7, 9, 0, 0, 9145, 9146, 7, 6, 0, 0, 9146, 9147, 7, 15, 0, 0, 9147, 9148, 7, 4, 0, 0, 9148, 9149, 7, 19, 0, 0, 9149, 820, 1, 0, 0, 0, 9150, 9151, 7, 9, 0, 0, 9151, 9152, 7, 6, 0, 0, 9152, 9153, 7, 24, 0, 0, 9153, 9154, 7, 12, 0, 0, 9154, 9155, 7, 6, 0, 0, 9155, 9156, 7, 12, 0, 0, 9156, 9157, 7, 6, 0, 0, 9157, 822, 1, 0, 0, 0, 9158, 9159, 7, 9, 0, 0, 9159, 9160, 7, 6, 0, 0, 9160, 9161, 7, 3, 0, 0, 9161, 9162, 7, 6, 0, 0, 9162, 9163, 7, 16, 0, 0, 9163, 824, 1, 0, 0, 0, 9164, 9165, 7, 9, 0, 0, 9165, 9166, 7, 6, 0, 0, 9166, 9167, 7, 3, 0, 0, 9167, 9168, 7, 6, 0, 0, 9168, 9169, 7, 16, 0, 0, 9169, 9170, 5, 95, 0, 0, 9170, 9171, 7, 7, 0, 0, 9171, 9172, 7, 2, 0, 0, 9172, 9173, 5, 95, 0, 0, 9173, 9174, 7, 3, 0, 0, 9174, 9175, 7, 6, 0, 0, 9175, 9176, 7, 22, 0, 0, 9176, 9177, 7, 3, 0, 0, 9177, 9178, 7, 10, 0, 0, 9178, 9179, 7, 4, 0, 0, 9179, 9180, 7, 6, 0, 0, 9180, 826, 1, 0, 0, 0, 9181, 9182, 7, 9, 0, 0, 9182, 9183, 7, 6, 0, 0, 9183, 9184, 7, 5, 0, 0, 9184, 9185, 7, 8, 0, 0, 9185, 828, 1, 0, 0, 0, 9186, 9187, 7, 9, 0, 0, 9187, 9188, 7, 6, 0, 0, 9188, 9189, 7, 5, 0, 0, 9189, 9190, 7, 8, 0, 0, 9190, 9191, 7, 3, 0, 0, 9191, 9192, 7, 10, 0, 0, 9192, 9193, 7, 15, 0, 0, 9193, 9194, 7, 4, 0, 0, 9194, 9195, 7, 10, 0, 0, 9195, 9196, 7, 2, 0, 0, 9196, 9197, 7, 7, 0, 0, 9197, 830, 1, 0, 0, 0, 9198, 9199, 7, 9, 0, 0, 9199, 9200, 7, 6, 0, 0, 9200, 9201, 7, 5, 0, 0, 9201, 9202, 7, 4, 0, 0, 9202, 9203, 7, 3, 0, 0, 9203, 9204, 7, 2, 0, 0, 9204, 9205, 7, 18, 0, 0, 9205, 832, 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, 0, 0, 0, 9210, 9211, 7, 8, 0, 0, 9211, 9212, 7, 19, 0, 0, 9212, 9213, 7, 6, 0, 0, 9213, 9214, 7, 9, 0, 0, 9214, 834, 1, 0, 0, 0, 9215, 9216, 7, 9, 0, 0, 9216, 9217, 7, 6, 0, 0, 9217, 9218, 7, 4, 0, 0, 9218, 9219, 7, 6, 0, 0, 9219, 9220, 7, 8, 0, 0, 9220, 9221, 7, 4, 0, 0, 9221, 9222, 7, 6, 0, 0, 9222, 9223, 7, 9, 0, 0, 9223, 836, 1, 0, 0, 0, 9224, 9225, 7, 9, 0, 0, 9225, 9226, 7, 6, 0, 0, 9226, 9227, 7, 4, 0, 0, 9227, 9228, 7, 6, 0, 0, 9228, 9229, 7, 3, 0, 0, 9229, 9230, 7, 14, 0, 0, 9230, 9231, 7, 10, 0, 0, 9231, 9232, 7, 7, 0, 0, 9232, 9233, 7, 6, 0, 0, 9233, 9234, 7, 5, 0, 0, 9234, 838, 1, 0, 0, 0, 9235, 9236, 7, 9, 0, 0, 9236, 9237, 7, 6, 0, 0, 9237, 9238, 7, 4, 0, 0, 9238, 9239, 7, 6, 0, 0, 9239, 9240, 7, 3, 0, 0, 9240, 9241, 7, 14, 0, 0, 9241, 9242, 7, 10, 0, 0, 9242, 9243, 7, 7, 0, 0, 9243, 9244, 7, 10, 0, 0, 9244, 9245, 7, 5, 0, 0, 9245, 9246, 7, 4, 0, 0, 9246, 9247, 7, 10, 0, 0, 9247, 9248, 7, 8, 0, 0, 9248, 840, 1, 0, 0, 0, 9249, 9250, 7, 9, 0, 0, 9250, 9251, 7, 10, 0, 0, 9251, 9252, 7, 8, 0, 0, 9252, 9253, 7, 4, 0, 0, 9253, 9254, 7, 10, 0, 0, 9254, 9255, 7, 2, 0, 0, 9255, 9256, 7, 7, 0, 0, 9256, 9257, 7, 0, 0, 0, 9257, 9258, 7, 3, 0, 0, 9258, 9259, 7, 18, 0, 0, 9259, 842, 1, 0, 0, 0, 9260, 9261, 7, 9, 0, 0, 9261, 9262, 7, 10, 0, 0, 9262, 9263, 7, 14, 0, 0, 9263, 9264, 7, 6, 0, 0, 9264, 9265, 7, 7, 0, 0, 9265, 9266, 7, 5, 0, 0, 9266, 9267, 7, 10, 0, 0, 9267, 9268, 7, 2, 0, 0, 9268, 9269, 7, 7, 0, 0, 9269, 844, 1, 0, 0, 0, 9270, 9271, 7, 9, 0, 0, 9271, 9272, 7, 10, 0, 0, 9272, 9273, 7, 14, 0, 0, 9273, 9274, 7, 6, 0, 0, 9274, 9275, 7, 7, 0, 0, 9275, 9276, 7, 5, 0, 0, 9276, 9277, 7, 10, 0, 0, 9277, 9278, 7, 2, 0, 0, 9278, 9279, 7, 7, 0, 0, 9279, 9280, 7, 5, 0, 0, 9280, 846, 1, 0, 0, 0, 9281, 9282, 7, 9, 0, 0, 9282, 9283, 7, 10, 0, 0, 9283, 9284, 7, 3, 0, 0, 9284, 9285, 7, 6, 0, 0, 9285, 9286, 7, 8, 0, 0, 9286, 9287, 7, 4, 0, 0, 9287, 9288, 7, 10, 0, 0, 9288, 9289, 7, 2, 0, 0, 9289, 848, 1, 0, 0, 0, 9290, 9291, 7, 9, 0, 0, 9291, 9292, 7, 10, 0, 0, 9292, 9293, 7, 3, 0, 0, 9293, 9294, 7, 6, 0, 0, 9294, 9295, 7, 8, 0, 0, 9295, 9296, 7, 4, 0, 0, 9296, 9297, 5, 95, 0, 0, 9297, 9298, 7, 11, 0, 0, 9298, 9299, 7, 2, 0, 0, 9299, 9300, 7, 0, 0, 0, 9300, 9301, 7, 9, 0, 0, 9301, 850, 1, 0, 0, 0, 9302, 9303, 7, 9, 0, 0, 9303, 9304, 7, 10, 0, 0, 9304, 9305, 7, 3, 0, 0, 9305, 9306, 7, 6, 0, 0, 9306, 9307, 7, 8, 0, 0, 9307, 9308, 7, 4, 0, 0, 9308, 9309, 7, 2, 0, 0, 9309, 9310, 7, 3, 0, 0, 9310, 9311, 7, 18, 0, 0, 9311, 852, 1, 0, 0, 0, 9312, 9313, 7, 9, 0, 0, 9313, 9314, 7, 10, 0, 0, 9314, 9315, 7, 3, 0, 0, 9315, 9316, 7, 6, 0, 0, 9316, 9317, 7, 8, 0, 0, 9317, 9318, 7, 4, 0, 0, 9318, 9319, 5, 95, 0, 0, 9319, 9320, 7, 15, 0, 0, 9320, 9321, 7, 0, 0, 0, 9321, 9322, 7, 4, 0, 0, 9322, 9323, 7, 19, 0, 0, 9323, 854, 1, 0, 0, 0, 9324, 9325, 7, 9, 0, 0, 9325, 9326, 7, 10, 0, 0, 9326, 9327, 7, 5, 0, 0, 9327, 9328, 7, 0, 0, 0, 9328, 9329, 7, 1, 0, 0, 9329, 9330, 7, 11, 0, 0, 9330, 9331, 7, 6, 0, 0, 9331, 9332, 5, 95, 0, 0, 9332, 9333, 7, 0, 0, 0, 9333, 9334, 7, 11, 0, 0, 9334, 9335, 7, 11, 0, 0, 9335, 856, 1, 0, 0, 0, 9336, 9337, 7, 9, 0, 0, 9337, 9338, 7, 10, 0, 0, 9338, 9339, 7, 5, 0, 0, 9339, 9340, 7, 0, 0, 0, 9340, 9341, 7, 1, 0, 0, 9341, 9342, 7, 11, 0, 0, 9342, 9343, 7, 6, 0, 0, 9343, 858, 1, 0, 0, 0, 9344, 9345, 7, 9, 0, 0, 9345, 9346, 7, 10, 0, 0, 9346, 9347, 7, 5, 0, 0, 9347, 9348, 7, 0, 0, 0, 9348, 9349, 7, 1, 0, 0, 9349, 9350, 7, 11, 0, 0, 9350, 9351, 7, 6, 0, 0, 9351, 9352, 7, 9, 0, 0, 9352, 860, 1, 0, 0, 0, 9353, 9354, 7, 9, 0, 0, 9354, 9355, 7, 10, 0, 0, 9355, 9356, 7, 5, 0, 0, 9356, 9357, 7, 0, 0, 0, 9357, 9358, 7, 1, 0, 0, 9358, 9359, 7, 11, 0, 0, 9359, 9360, 7, 6, 0, 0, 9360, 9361, 5, 95, 0, 0, 9361, 9362, 7, 9, 0, 0, 9362, 9363, 7, 10, 0, 0, 9363, 9364, 7, 3, 0, 0, 9364, 9365, 7, 6, 0, 0, 9365, 9366, 7, 8, 0, 0, 9366, 9367, 7, 4, 0, 0, 9367, 9368, 7, 2, 0, 0, 9368, 9369, 7, 3, 0, 0, 9369, 9370, 7, 18, 0, 0, 9370, 9371, 5, 95, 0, 0, 9371, 9372, 7, 11, 0, 0, 9372, 9373, 7, 10, 0, 0, 9373, 9374, 7, 7, 0, 0, 9374, 9375, 7, 21, 0, 0, 9375, 9376, 5, 95, 0, 0, 9376, 9377, 7, 8, 0, 0, 9377, 9378, 7, 19, 0, 0, 9378, 9379, 7, 6, 0, 0, 9379, 9380, 7, 8, 0, 0, 9380, 9381, 7, 21, 0, 0, 9381, 862, 1, 0, 0, 0, 9382, 9383, 7, 9, 0, 0, 9383, 9384, 7, 10, 0, 0, 9384, 9385, 7, 5, 0, 0, 9385, 9386, 7, 0, 0, 0, 9386, 9387, 7, 1, 0, 0, 9387, 9388, 7, 11, 0, 0, 9388, 9389, 7, 6, 0, 0, 9389, 9390, 5, 95, 0, 0, 9390, 9391, 7, 15, 0, 0, 9391, 9392, 7, 0, 0, 0, 9392, 9393, 7, 3, 0, 0, 9393, 9394, 7, 0, 0, 0, 9394, 9395, 7, 11, 0, 0, 9395, 9396, 7, 11, 0, 0, 9396, 9397, 7, 6, 0, 0, 9397, 9398, 7, 11, 0, 0, 9398, 9399, 5, 95, 0, 0, 9399, 9400, 7, 9, 0, 0, 9400, 9401, 7, 14, 0, 0, 9401, 9402, 7, 11, 0, 0, 9402, 864, 1, 0, 0, 0, 9403, 9404, 7, 9, 0, 0, 9404, 9405, 7, 10, 0, 0, 9405, 9406, 7, 5, 0, 0, 9406, 9407, 7, 0, 0, 0, 9407, 9408, 7, 1, 0, 0, 9408, 9409, 7, 11, 0, 0, 9409, 9410, 7, 6, 0, 0, 9410, 9411, 5, 95, 0, 0, 9411, 9412, 7, 15, 0, 0, 9412, 9413, 7, 3, 0, 0, 9413, 9414, 7, 6, 0, 0, 9414, 9415, 7, 5, 0, 0, 9415, 9416, 7, 6, 0, 0, 9416, 9417, 7, 4, 0, 0, 9417, 866, 1, 0, 0, 0, 9418, 9419, 7, 9, 0, 0, 9419, 9420, 7, 10, 0, 0, 9420, 9421, 7, 5, 0, 0, 9421, 9422, 7, 0, 0, 0, 9422, 9423, 7, 1, 0, 0, 9423, 9424, 7, 11, 0, 0, 9424, 9425, 7, 6, 0, 0, 9425, 9426, 5, 95, 0, 0, 9426, 9427, 7, 3, 0, 0, 9427, 9428, 7, 15, 0, 0, 9428, 9429, 7, 21, 0, 0, 9429, 9430, 7, 6, 0, 0, 9430, 868, 1, 0, 0, 0, 9431, 9432, 7, 9, 0, 0, 9432, 9433, 7, 10, 0, 0, 9433, 9434, 7, 5, 0, 0, 9434, 9435, 7, 0, 0, 0, 9435, 9436, 7, 11, 0, 0, 9436, 9437, 7, 11, 0, 0, 9437, 9438, 7, 2, 0, 0, 9438, 9439, 7, 22, 0, 0, 9439, 870, 1, 0, 0, 0, 9440, 9441, 7, 9, 0, 0, 9441, 9442, 7, 10, 0, 0, 9442, 9443, 7, 5, 0, 0, 9443, 9444, 7, 0, 0, 0, 9444, 9445, 7, 5, 0, 0, 9445, 9446, 7, 5, 0, 0, 9446, 9447, 7, 2, 0, 0, 9447, 9448, 7, 8, 0, 0, 9448, 9449, 7, 10, 0, 0, 9449, 9450, 7, 0, 0, 0, 9450, 9451, 7, 4, 0, 0, 9451, 9452, 7, 6, 0, 0, 9452, 872, 1, 0, 0, 0, 9453, 9454, 7, 9, 0, 0, 9454, 9455, 7, 10, 0, 0, 9455, 9456, 7, 5, 0, 0, 9456, 9457, 7, 8, 0, 0, 9457, 9458, 7, 0, 0, 0, 9458, 9459, 7, 3, 0, 0, 9459, 9460, 7, 9, 0, 0, 9460, 874, 1, 0, 0, 0, 9461, 9462, 7, 9, 0, 0, 9462, 9463, 7, 10, 0, 0, 9463, 9464, 7, 5, 0, 0, 9464, 9465, 7, 8, 0, 0, 9465, 9466, 7, 0, 0, 0, 9466, 9467, 7, 3, 0, 0, 9467, 9468, 7, 9, 0, 0, 9468, 9469, 7, 16, 0, 0, 9469, 9470, 7, 10, 0, 0, 9470, 9471, 7, 11, 0, 0, 9471, 9472, 7, 6, 0, 0, 9472, 876, 1, 0, 0, 0, 9473, 9474, 7, 9, 0, 0, 9474, 9475, 7, 10, 0, 0, 9475, 9476, 7, 5, 0, 0, 9476, 9477, 7, 8, 0, 0, 9477, 9478, 7, 2, 0, 0, 9478, 9479, 7, 7, 0, 0, 9479, 9480, 7, 7, 0, 0, 9480, 9481, 7, 6, 0, 0, 9481, 9482, 7, 8, 0, 0, 9482, 9483, 7, 4, 0, 0, 9483, 878, 1, 0, 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, 880, 1, 0, 0, 0, 9489, 9490, 7, 9, 0, 0, 9490, 9491, 7, 10, 0, 0, 9491, 9492, 7, 5, 0, 0, 9492, 9493, 7, 21, 0, 0, 9493, 9494, 7, 17, 0, 0, 9494, 9495, 7, 3, 0, 0, 9495, 9496, 7, 2, 0, 0, 9496, 9497, 7, 12, 0, 0, 9497, 9498, 7, 15, 0, 0, 9498, 882, 1, 0, 0, 0, 9499, 9500, 5, 39, 0, 0, 9500, 9501, 5, 43, 0, 0, 9501, 9502, 5, 32, 0, 0, 9502, 9503, 7, 9, 0, 0, 9503, 9504, 7, 10, 0, 0, 9504, 9505, 7, 5, 0, 0, 9505, 9506, 7, 21, 0, 0, 9506, 9507, 7, 17, 0, 0, 9507, 9508, 7, 3, 0, 0, 9508, 9509, 7, 2, 0, 0, 9509, 9510, 7, 12, 0, 0, 9510, 9511, 7, 15, 0, 0, 9511, 884, 1, 0, 0, 0, 9512, 9513, 7, 9, 0, 0, 9513, 9514, 7, 10, 0, 0, 9514, 9515, 7, 5, 0, 0, 9515, 9516, 7, 21, 0, 0, 9516, 9517, 7, 5, 0, 0, 9517, 886, 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, 14, 0, 0, 9522, 9523, 7, 2, 0, 0, 9523, 9524, 7, 12, 0, 0, 9524, 9525, 7, 7, 0, 0, 9525, 9526, 7, 4, 0, 0, 9526, 888, 1, 0, 0, 0, 9527, 9528, 7, 9, 0, 0, 9528, 9529, 7, 10, 0, 0, 9529, 9530, 7, 5, 0, 0, 9530, 9531, 7, 4, 0, 0, 9531, 9532, 7, 10, 0, 0, 9532, 9533, 7, 7, 0, 0, 9533, 9534, 7, 8, 0, 0, 9534, 9535, 7, 4, 0, 0, 9535, 890, 1, 0, 0, 0, 9536, 9537, 7, 9, 0, 0, 9537, 9538, 7, 10, 0, 0, 9538, 9539, 7, 5, 0, 0, 9539, 9540, 7, 4, 0, 0, 9540, 9541, 7, 10, 0, 0, 9541, 9542, 7, 7, 0, 0, 9542, 9543, 7, 17, 0, 0, 9543, 9544, 7, 12, 0, 0, 9544, 9545, 7, 10, 0, 0, 9545, 9546, 7, 5, 0, 0, 9546, 9547, 7, 19, 0, 0, 9547, 9548, 7, 6, 0, 0, 9548, 9549, 7, 9, 0, 0, 9549, 892, 1, 0, 0, 0, 9550, 9551, 7, 9, 0, 0, 9551, 9552, 7, 10, 0, 0, 9552, 9553, 7, 5, 0, 0, 9553, 9554, 7, 4, 0, 0, 9554, 9555, 7, 3, 0, 0, 9555, 9556, 7, 10, 0, 0, 9556, 9557, 7, 1, 0, 0, 9557, 9558, 7, 12, 0, 0, 9558, 9559, 7, 4, 0, 0, 9559, 9560, 7, 6, 0, 0, 9560, 9561, 7, 9, 0, 0, 9561, 894, 1, 0, 0, 0, 9562, 9563, 7, 9, 0, 0, 9563, 9564, 7, 10, 0, 0, 9564, 9565, 7, 5, 0, 0, 9565, 9566, 7, 4, 0, 0, 9566, 9567, 7, 3, 0, 0, 9567, 9568, 7, 10, 0, 0, 9568, 9569, 7, 1, 0, 0, 9569, 9570, 7, 12, 0, 0, 9570, 9571, 7, 4, 0, 0, 9571, 9572, 7, 6, 0, 0, 9572, 896, 1, 0, 0, 0, 9573, 9574, 7, 9, 0, 0, 9574, 9575, 7, 14, 0, 0, 9575, 9576, 7, 11, 0, 0, 9576, 898, 1, 0, 0, 0, 9577, 9578, 7, 9, 0, 0, 9578, 9579, 7, 14, 0, 0, 9579, 9580, 7, 11, 0, 0, 9580, 9581, 5, 95, 0, 0, 9581, 9582, 7, 12, 0, 0, 9582, 9583, 7, 15, 0, 0, 9583, 9584, 7, 9, 0, 0, 9584, 9585, 7, 0, 0, 0, 9585, 9586, 7, 4, 0, 0, 9586, 9587, 7, 6, 0, 0, 9587, 900, 1, 0, 0, 0, 9588, 9589, 7, 9, 0, 0, 9589, 9590, 7, 7, 0, 0, 9590, 9591, 7, 16, 0, 0, 9591, 9592, 7, 5, 0, 0, 9592, 9593, 5, 95, 0, 0, 9593, 9594, 7, 9, 0, 0, 9594, 9595, 7, 10, 0, 0, 9595, 9596, 7, 5, 0, 0, 9596, 9597, 7, 0, 0, 0, 9597, 9598, 7, 1, 0, 0, 9598, 9599, 7, 11, 0, 0, 9599, 9600, 7, 6, 0, 0, 9600, 902, 1, 0, 0, 0, 9601, 9602, 7, 9, 0, 0, 9602, 9603, 7, 7, 0, 0, 9603, 9604, 7, 16, 0, 0, 9604, 9605, 7, 5, 0, 0, 9605, 9606, 5, 95, 0, 0, 9606, 9607, 7, 6, 0, 0, 9607, 9608, 7, 7, 0, 0, 9608, 9609, 7, 0, 0, 0, 9609, 9610, 7, 1, 0, 0, 9610, 9611, 7, 11, 0, 0, 9611, 9612, 7, 6, 0, 0, 9612, 904, 1, 0, 0, 0, 9613, 9614, 7, 9, 0, 0, 9614, 9615, 7, 7, 0, 0, 9615, 9616, 7, 16, 0, 0, 9616, 9617, 7, 5, 0, 0, 9617, 9618, 5, 95, 0, 0, 9618, 9619, 7, 3, 0, 0, 9619, 9620, 7, 6, 0, 0, 9620, 9621, 7, 0, 0, 0, 9621, 9622, 7, 9, 0, 0, 9622, 9623, 7, 1, 0, 0, 9623, 9624, 7, 12, 0, 0, 9624, 9625, 7, 16, 0, 0, 9625, 9626, 7, 16, 0, 0, 9626, 9627, 7, 6, 0, 0, 9627, 9628, 7, 3, 0, 0, 9628, 9629, 7, 5, 0, 0, 9629, 906, 1, 0, 0, 0, 9630, 9631, 7, 9, 0, 0, 9631, 9632, 7, 2, 0, 0, 9632, 9633, 7, 8, 0, 0, 9633, 9634, 7, 16, 0, 0, 9634, 9635, 7, 10, 0, 0, 9635, 9636, 7, 9, 0, 0, 9636, 9637, 7, 6, 0, 0, 9637, 9638, 7, 11, 0, 0, 9638, 9639, 7, 10, 0, 0, 9639, 9640, 7, 4, 0, 0, 9640, 9641, 7, 18, 0, 0, 9641, 908, 1, 0, 0, 0, 9642, 9643, 7, 9, 0, 0, 9643, 9644, 7, 2, 0, 0, 9644, 9645, 7, 8, 0, 0, 9645, 9646, 7, 12, 0, 0, 9646, 9647, 7, 14, 0, 0, 9647, 9648, 7, 6, 0, 0, 9648, 9649, 7, 7, 0, 0, 9649, 9650, 7, 4, 0, 0, 9650, 910, 1, 0, 0, 0, 9651, 9652, 5, 36, 0, 0, 9652, 9653, 7, 6, 0, 0, 9653, 9654, 7, 11, 0, 0, 9654, 9655, 7, 5, 0, 0, 9655, 9656, 7, 6, 0, 0, 9656, 912, 1, 0, 0, 0, 9657, 9658, 5, 36, 0, 0, 9658, 9659, 7, 6, 0, 0, 9659, 9660, 7, 11, 0, 0, 9660, 9661, 7, 5, 0, 0, 9661, 9662, 7, 10, 0, 0, 9662, 9663, 7, 16, 0, 0, 9663, 914, 1, 0, 0, 0, 9664, 9665, 5, 36, 0, 0, 9665, 9666, 7, 6, 0, 0, 9666, 9667, 7, 7, 0, 0, 9667, 9668, 7, 9, 0, 0, 9668, 916, 1, 0, 0, 0, 9669, 9670, 5, 36, 0, 0, 9670, 9671, 7, 6, 0, 0, 9671, 9672, 7, 3, 0, 0, 9672, 9673, 7, 3, 0, 0, 9673, 9674, 7, 2, 0, 0, 9674, 9675, 7, 3, 0, 0, 9675, 918, 1, 0, 0, 0, 9676, 9677, 5, 36, 0, 0, 9677, 9678, 7, 10, 0, 0, 9678, 9679, 7, 16, 0, 0, 9679, 920, 1, 0, 0, 0, 9680, 9681, 5, 36, 0, 0, 9681, 9682, 7, 4, 0, 0, 9682, 9683, 7, 19, 0, 0, 9683, 9684, 7, 6, 0, 0, 9684, 9685, 7, 7, 0, 0, 9685, 922, 1, 0, 0, 0, 9686, 9687, 7, 9, 0, 0, 9687, 9688, 7, 2, 0, 0, 9688, 9689, 7, 14, 0, 0, 9689, 9690, 7, 0, 0, 0, 9690, 9691, 7, 10, 0, 0, 9691, 9692, 7, 7, 0, 0, 9692, 9693, 5, 95, 0, 0, 9693, 9694, 7, 10, 0, 0, 9694, 9695, 7, 7, 0, 0, 9695, 9696, 7, 9, 0, 0, 9696, 9697, 7, 6, 0, 0, 9697, 9698, 7, 25, 0, 0, 9698, 9699, 5, 95, 0, 0, 9699, 9700, 7, 16, 0, 0, 9700, 9701, 7, 10, 0, 0, 9701, 9702, 7, 11, 0, 0, 9702, 9703, 7, 4, 0, 0, 9703, 9704, 7, 6, 0, 0, 9704, 9705, 7, 3, 0, 0, 9705, 924, 1, 0, 0, 0, 9706, 9707, 7, 9, 0, 0, 9707, 9708, 7, 2, 0, 0, 9708, 9709, 7, 14, 0, 0, 9709, 9710, 7, 0, 0, 0, 9710, 9711, 7, 10, 0, 0, 9711, 9712, 7, 7, 0, 0, 9712, 9713, 5, 95, 0, 0, 9713, 9714, 7, 10, 0, 0, 9714, 9715, 7, 7, 0, 0, 9715, 9716, 7, 9, 0, 0, 9716, 9717, 7, 6, 0, 0, 9717, 9718, 7, 25, 0, 0, 9718, 9719, 5, 95, 0, 0, 9719, 9720, 7, 7, 0, 0, 9720, 9721, 7, 2, 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, 926, 1, 0, 0, 0, 9727, 9728, 7, 9, 0, 0, 9728, 9729, 7, 2, 0, 0, 9729, 9730, 7, 14, 0, 0, 9730, 9731, 7, 0, 0, 0, 9731, 9732, 7, 10, 0, 0, 9732, 9733, 7, 7, 0, 0, 9733, 9734, 5, 95, 0, 0, 9734, 9735, 7, 10, 0, 0, 9735, 9736, 7, 7, 0, 0, 9736, 9737, 7, 9, 0, 0, 9737, 9738, 7, 6, 0, 0, 9738, 9739, 7, 25, 0, 0, 9739, 9740, 5, 95, 0, 0, 9740, 9741, 7, 5, 0, 0, 9741, 9742, 7, 2, 0, 0, 9742, 9743, 7, 3, 0, 0, 9743, 9744, 7, 4, 0, 0, 9744, 928, 1, 0, 0, 0, 9745, 9746, 7, 9, 0, 0, 9746, 9747, 7, 2, 0, 0, 9747, 9748, 7, 12, 0, 0, 9748, 9749, 7, 1, 0, 0, 9749, 9750, 7, 11, 0, 0, 9750, 9751, 7, 6, 0, 0, 9751, 930, 1, 0, 0, 0, 9752, 9753, 7, 9, 0, 0, 9753, 9754, 7, 2, 0, 0, 9754, 9755, 7, 22, 0, 0, 9755, 9756, 7, 7, 0, 0, 9756, 9757, 7, 17, 0, 0, 9757, 9758, 7, 3, 0, 0, 9758, 9759, 7, 0, 0, 0, 9759, 9760, 7, 9, 0, 0, 9760, 9761, 7, 6, 0, 0, 9761, 932, 1, 0, 0, 0, 9762, 9763, 7, 9, 0, 0, 9763, 9764, 7, 3, 0, 0, 9764, 9765, 7, 10, 0, 0, 9765, 9766, 7, 13, 0, 0, 9766, 9767, 7, 10, 0, 0, 9767, 9768, 7, 7, 0, 0, 9768, 9769, 7, 17, 0, 0, 9769, 9770, 5, 95, 0, 0, 9770, 9771, 7, 5, 0, 0, 9771, 9772, 7, 10, 0, 0, 9772, 9773, 7, 4, 0, 0, 9773, 9774, 7, 6, 0, 0, 9774, 934, 1, 0, 0, 0, 9775, 9776, 7, 9, 0, 0, 9776, 9777, 7, 3, 0, 0, 9777, 9778, 7, 2, 0, 0, 9778, 9779, 7, 15, 0, 0, 9779, 9780, 5, 95, 0, 0, 9780, 9781, 7, 8, 0, 0, 9781, 9782, 7, 2, 0, 0, 9782, 9783, 7, 11, 0, 0, 9783, 9784, 7, 12, 0, 0, 9784, 9785, 7, 14, 0, 0, 9785, 9786, 7, 7, 0, 0, 9786, 936, 1, 0, 0, 0, 9787, 9788, 7, 9, 0, 0, 9788, 9789, 7, 3, 0, 0, 9789, 9790, 7, 2, 0, 0, 9790, 9791, 7, 15, 0, 0, 9791, 938, 1, 0, 0, 0, 9792, 9793, 7, 9, 0, 0, 9793, 9794, 7, 3, 0, 0, 9794, 9795, 7, 2, 0, 0, 9795, 9796, 7, 15, 0, 0, 9796, 9797, 5, 95, 0, 0, 9797, 9798, 7, 17, 0, 0, 9798, 9799, 7, 3, 0, 0, 9799, 9800, 7, 2, 0, 0, 9800, 9801, 7, 12, 0, 0, 9801, 9802, 7, 15, 0, 0, 9802, 940, 1, 0, 0, 0, 9803, 9804, 7, 9, 0, 0, 9804, 9805, 7, 5, 0, 0, 9805, 9806, 7, 10, 0, 0, 9806, 9807, 7, 7, 0, 0, 9807, 9808, 7, 4, 0, 0, 9808, 9809, 7, 6, 0, 0, 9809, 9810, 7, 3, 0, 0, 9810, 9811, 7, 13, 0, 0, 9811, 9812, 7, 0, 0, 0, 9812, 9813, 7, 11, 0, 0, 9813, 9814, 5, 95, 0, 0, 9814, 9815, 7, 12, 0, 0, 9815, 9816, 7, 7, 0, 0, 9816, 9817, 7, 8, 0, 0, 9817, 9818, 7, 2, 0, 0, 9818, 9819, 7, 7, 0, 0, 9819, 9820, 7, 5, 0, 0, 9820, 9821, 7, 4, 0, 0, 9821, 9822, 7, 3, 0, 0, 9822, 9823, 7, 0, 0, 0, 9823, 9824, 7, 10, 0, 0, 9824, 9825, 7, 7, 0, 0, 9825, 9826, 7, 6, 0, 0, 9826, 9827, 7, 9, 0, 0, 9827, 942, 1, 0, 0, 0, 9828, 9829, 7, 9, 0, 0, 9829, 9830, 7, 5, 0, 0, 9830, 9831, 7, 4, 0, 0, 9831, 9832, 5, 95, 0, 0, 9832, 9833, 7, 12, 0, 0, 9833, 9834, 7, 15, 0, 0, 9834, 9835, 7, 17, 0, 0, 9835, 9836, 7, 3, 0, 0, 9836, 9837, 7, 0, 0, 0, 9837, 9838, 7, 9, 0, 0, 9838, 9839, 7, 6, 0, 0, 9839, 9840, 5, 95, 0, 0, 9840, 9841, 7, 10, 0, 0, 9841, 9842, 7, 7, 0, 0, 9842, 9843, 7, 5, 0, 0, 9843, 9844, 7, 6, 0, 0, 9844, 9845, 7, 3, 0, 0, 9845, 9846, 7, 4, 0, 0, 9846, 9847, 5, 95, 0, 0, 9847, 9848, 7, 8, 0, 0, 9848, 9849, 7, 2, 0, 0, 9849, 9850, 7, 7, 0, 0, 9850, 9851, 7, 13, 0, 0, 9851, 944, 1, 0, 0, 0, 9852, 9853, 7, 9, 0, 0, 9853, 9854, 7, 12, 0, 0, 9854, 9855, 7, 14, 0, 0, 9855, 9856, 7, 15, 0, 0, 9856, 946, 1, 0, 0, 0, 9857, 9858, 7, 9, 0, 0, 9858, 9859, 7, 12, 0, 0, 9859, 9860, 7, 14, 0, 0, 9860, 9861, 7, 15, 0, 0, 9861, 9862, 7, 5, 0, 0, 9862, 9863, 7, 6, 0, 0, 9863, 9864, 7, 4, 0, 0, 9864, 948, 1, 0, 0, 0, 9865, 9866, 7, 9, 0, 0, 9866, 9867, 7, 12, 0, 0, 9867, 9868, 7, 15, 0, 0, 9868, 9869, 7, 11, 0, 0, 9869, 9870, 7, 10, 0, 0, 9870, 9871, 7, 8, 0, 0, 9871, 9872, 7, 0, 0, 0, 9872, 9873, 7, 4, 0, 0, 9873, 9874, 7, 6, 0, 0, 9874, 950, 1, 0, 0, 0, 9875, 9876, 7, 9, 0, 0, 9876, 9877, 7, 13, 0, 0, 9877, 952, 1, 0, 0, 0, 9878, 9879, 7, 9, 0, 0, 9879, 9880, 7, 18, 0, 0, 9880, 9881, 7, 7, 0, 0, 9881, 9882, 7, 0, 0, 0, 9882, 9883, 7, 14, 0, 0, 9883, 9884, 7, 10, 0, 0, 9884, 9885, 7, 8, 0, 0, 9885, 954, 1, 0, 0, 0, 9886, 9887, 7, 9, 0, 0, 9887, 9888, 7, 18, 0, 0, 9888, 9889, 7, 7, 0, 0, 9889, 9890, 7, 0, 0, 0, 9890, 9891, 7, 14, 0, 0, 9891, 9892, 7, 10, 0, 0, 9892, 9893, 7, 8, 0, 0, 9893, 9894, 5, 95, 0, 0, 9894, 9895, 7, 5, 0, 0, 9895, 9896, 7, 0, 0, 0, 9896, 9897, 7, 14, 0, 0, 9897, 9898, 7, 15, 0, 0, 9898, 9899, 7, 11, 0, 0, 9899, 9900, 7, 10, 0, 0, 9900, 9901, 7, 7, 0, 0, 9901, 9902, 7, 17, 0, 0, 9902, 956, 1, 0, 0, 0, 9903, 9904, 7, 9, 0, 0, 9904, 9905, 7, 18, 0, 0, 9905, 9906, 7, 7, 0, 0, 9906, 9907, 7, 0, 0, 0, 9907, 9908, 7, 14, 0, 0, 9908, 9909, 7, 10, 0, 0, 9909, 9910, 7, 8, 0, 0, 9910, 9911, 5, 95, 0, 0, 9911, 9912, 7, 5, 0, 0, 9912, 9913, 7, 0, 0, 0, 9913, 9914, 7, 14, 0, 0, 9914, 9915, 7, 15, 0, 0, 9915, 9916, 7, 11, 0, 0, 9916, 9917, 7, 10, 0, 0, 9917, 9918, 7, 7, 0, 0, 9918, 9919, 7, 17, 0, 0, 9919, 9920, 5, 95, 0, 0, 9920, 9921, 7, 6, 0, 0, 9921, 9922, 7, 5, 0, 0, 9922, 9923, 7, 4, 0, 0, 9923, 9924, 5, 95, 0, 0, 9924, 9925, 7, 8, 0, 0, 9925, 9926, 7, 9, 0, 0, 9926, 9927, 7, 7, 0, 0, 9927, 958, 1, 0, 0, 0, 9928, 9929, 7, 6, 0, 0, 9929, 960, 1, 0, 0, 0, 9930, 9931, 7, 6, 0, 0, 9931, 9932, 7, 0, 0, 0, 9932, 9933, 7, 8, 0, 0, 9933, 9934, 7, 19, 0, 0, 9934, 962, 1, 0, 0, 0, 9935, 9936, 7, 6, 0, 0, 9936, 9937, 7, 9, 0, 0, 9937, 9938, 7, 10, 0, 0, 9938, 9939, 7, 4, 0, 0, 9939, 9940, 7, 10, 0, 0, 9940, 9941, 7, 2, 0, 0, 9941, 9942, 7, 7, 0, 0, 9942, 9943, 7, 0, 0, 0, 9943, 9944, 7, 1, 0, 0, 9944, 9945, 7, 11, 0, 0, 9945, 9946, 7, 6, 0, 0, 9946, 964, 1, 0, 0, 0, 9947, 9948, 7, 6, 0, 0, 9948, 9949, 7, 9, 0, 0, 9949, 9950, 7, 10, 0, 0, 9950, 9951, 7, 4, 0, 0, 9951, 9952, 7, 10, 0, 0, 9952, 9953, 7, 2, 0, 0, 9953, 9954, 7, 7, 0, 0, 9954, 966, 1, 0, 0, 0, 9955, 9956, 7, 6, 0, 0, 9956, 9957, 7, 9, 0, 0, 9957, 9958, 7, 10, 0, 0, 9958, 9959, 7, 4, 0, 0, 9959, 9960, 7, 10, 0, 0, 9960, 9961, 7, 2, 0, 0, 9961, 9962, 7, 7, 0, 0, 9962, 9963, 7, 10, 0, 0, 9963, 9964, 7, 7, 0, 0, 9964, 9965, 7, 17, 0, 0, 9965, 968, 1, 0, 0, 0, 9966, 9967, 7, 6, 0, 0, 9967, 9968, 7, 9, 0, 0, 9968, 9969, 7, 10, 0, 0, 9969, 9970, 7, 4, 0, 0, 9970, 9971, 7, 10, 0, 0, 9971, 9972, 7, 2, 0, 0, 9972, 9973, 7, 7, 0, 0, 9973, 9974, 7, 5, 0, 0, 9974, 970, 1, 0, 0, 0, 9975, 9976, 7, 6, 0, 0, 9976, 9977, 7, 11, 0, 0, 9977, 9978, 7, 6, 0, 0, 9978, 9979, 7, 14, 0, 0, 9979, 9980, 7, 6, 0, 0, 9980, 9981, 7, 7, 0, 0, 9981, 9982, 7, 4, 0, 0, 9982, 972, 1, 0, 0, 0, 9983, 9984, 7, 6, 0, 0, 9984, 9985, 7, 11, 0, 0, 9985, 9986, 7, 10, 0, 0, 9986, 9987, 7, 14, 0, 0, 9987, 9988, 5, 95, 0, 0, 9988, 9989, 7, 17, 0, 0, 9989, 9990, 7, 3, 0, 0, 9990, 9991, 7, 2, 0, 0, 9991, 9992, 7, 12, 0, 0, 9992, 9993, 7, 15, 0, 0, 9993, 9994, 7, 1, 0, 0, 9994, 9995, 7, 18, 0, 0, 9995, 974, 1, 0, 0, 0, 9996, 9997, 7, 6, 0, 0, 9997, 9998, 7, 11, 0, 0, 9998, 9999, 7, 10, 0, 0, 9999, 10000, 7, 14, 0, 0, 10000, 10001, 7, 10, 0, 0, 10001, 10002, 7, 7, 0, 0, 10002, 10003, 7, 0, 0, 0, 10003, 10004, 7, 4, 0, 0, 10004, 10005, 7, 6, 0, 0, 10005, 10006, 5, 95, 0, 0, 10006, 10007, 7, 20, 0, 0, 10007, 10008, 7, 2, 0, 0, 10008, 10009, 7, 10, 0, 0, 10009, 10010, 7, 7, 0, 0, 10010, 976, 1, 0, 0, 0, 10011, 10012, 7, 6, 0, 0, 10012, 10013, 7, 11, 0, 0, 10013, 10014, 7, 10, 0, 0, 10014, 10015, 7, 14, 0, 0, 10015, 10016, 7, 10, 0, 0, 10016, 10017, 7, 7, 0, 0, 10017, 10018, 7, 0, 0, 0, 10018, 10019, 7, 4, 0, 0, 10019, 10020, 7, 6, 0, 0, 10020, 10021, 5, 95, 0, 0, 10021, 10022, 7, 2, 0, 0, 10022, 10023, 7, 1, 0, 0, 10023, 10024, 7, 18, 0, 0, 10024, 978, 1, 0, 0, 0, 10025, 10026, 7, 6, 0, 0, 10026, 10027, 7, 11, 0, 0, 10027, 10028, 7, 10, 0, 0, 10028, 10029, 7, 14, 0, 0, 10029, 10030, 7, 10, 0, 0, 10030, 10031, 7, 7, 0, 0, 10031, 10032, 7, 0, 0, 0, 10032, 10033, 7, 4, 0, 0, 10033, 10034, 7, 6, 0, 0, 10034, 10035, 5, 95, 0, 0, 10035, 10036, 7, 2, 0, 0, 10036, 10037, 7, 12, 0, 0, 10037, 10038, 7, 4, 0, 0, 10038, 10039, 7, 6, 0, 0, 10039, 10040, 7, 3, 0, 0, 10040, 10041, 5, 95, 0, 0, 10041, 10042, 7, 20, 0, 0, 10042, 10043, 7, 2, 0, 0, 10043, 10044, 7, 10, 0, 0, 10044, 10045, 7, 7, 0, 0, 10045, 980, 1, 0, 0, 0, 10046, 10047, 7, 6, 0, 0, 10047, 10048, 7, 11, 0, 0, 10048, 10049, 7, 5, 0, 0, 10049, 10050, 7, 6, 0, 0, 10050, 982, 1, 0, 0, 0, 10051, 10052, 7, 6, 0, 0, 10052, 10053, 7, 11, 0, 0, 10053, 10054, 7, 5, 0, 0, 10054, 10055, 7, 10, 0, 0, 10055, 10056, 7, 16, 0, 0, 10056, 984, 1, 0, 0, 0, 10057, 10058, 7, 6, 0, 0, 10058, 10059, 7, 14, 0, 0, 10059, 986, 1, 0, 0, 0, 10060, 10061, 7, 6, 0, 0, 10061, 10062, 7, 14, 0, 0, 10062, 10063, 7, 1, 0, 0, 10063, 10064, 7, 6, 0, 0, 10064, 10065, 7, 9, 0, 0, 10065, 10066, 7, 9, 0, 0, 10066, 10067, 7, 6, 0, 0, 10067, 10068, 7, 9, 0, 0, 10068, 988, 1, 0, 0, 0, 10069, 10070, 7, 6, 0, 0, 10070, 10071, 7, 14, 0, 0, 10071, 10072, 7, 15, 0, 0, 10072, 10073, 7, 4, 0, 0, 10073, 10074, 7, 18, 0, 0, 10074, 10075, 5, 95, 0, 0, 10075, 10076, 7, 1, 0, 0, 10076, 10077, 7, 11, 0, 0, 10077, 10078, 7, 2, 0, 0, 10078, 10079, 7, 1, 0, 0, 10079, 990, 1, 0, 0, 0, 10080, 10081, 7, 6, 0, 0, 10081, 10082, 7, 14, 0, 0, 10082, 10083, 7, 15, 0, 0, 10083, 10084, 7, 4, 0, 0, 10084, 10085, 7, 18, 0, 0, 10085, 10086, 5, 95, 0, 0, 10086, 10087, 7, 8, 0, 0, 10087, 10088, 7, 11, 0, 0, 10088, 10089, 7, 2, 0, 0, 10089, 10090, 7, 1, 0, 0, 10090, 992, 1, 0, 0, 0, 10091, 10092, 7, 6, 0, 0, 10092, 10093, 7, 14, 0, 0, 10093, 10094, 7, 15, 0, 0, 10094, 10095, 7, 4, 0, 0, 10095, 10096, 7, 18, 0, 0, 10096, 994, 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, 5, 95, 0, 0, 10104, 10105, 7, 0, 0, 0, 10105, 10106, 7, 11, 0, 0, 10106, 10107, 7, 11, 0, 0, 10107, 996, 1, 0, 0, 0, 10108, 10109, 7, 6, 0, 0, 10109, 10110, 7, 7, 0, 0, 10110, 10111, 7, 0, 0, 0, 10111, 10112, 7, 1, 0, 0, 10112, 10113, 7, 11, 0, 0, 10113, 10114, 7, 6, 0, 0, 10114, 998, 1, 0, 0, 0, 10115, 10116, 7, 6, 0, 0, 10116, 10117, 7, 7, 0, 0, 10117, 10118, 7, 0, 0, 0, 10118, 10119, 7, 1, 0, 0, 10119, 10120, 7, 11, 0, 0, 10120, 10121, 7, 6, 0, 0, 10121, 10122, 7, 9, 0, 0, 10122, 1000, 1, 0, 0, 0, 10123, 10124, 7, 6, 0, 0, 10124, 10125, 7, 7, 0, 0, 10125, 10126, 7, 0, 0, 0, 10126, 10127, 7, 1, 0, 0, 10127, 10128, 7, 11, 0, 0, 10128, 10129, 7, 6, 0, 0, 10129, 10130, 5, 95, 0, 0, 10130, 10131, 7, 15, 0, 0, 10131, 10132, 7, 0, 0, 0, 10132, 10133, 7, 3, 0, 0, 10133, 10134, 7, 0, 0, 0, 10134, 10135, 7, 11, 0, 0, 10135, 10136, 7, 11, 0, 0, 10136, 10137, 7, 6, 0, 0, 10137, 10138, 7, 11, 0, 0, 10138, 10139, 5, 95, 0, 0, 10139, 10140, 7, 9, 0, 0, 10140, 10141, 7, 14, 0, 0, 10141, 10142, 7, 11, 0, 0, 10142, 1002, 1, 0, 0, 0, 10143, 10144, 7, 6, 0, 0, 10144, 10145, 7, 7, 0, 0, 10145, 10146, 7, 0, 0, 0, 10146, 10147, 7, 1, 0, 0, 10147, 10148, 7, 11, 0, 0, 10148, 10149, 7, 6, 0, 0, 10149, 10150, 5, 95, 0, 0, 10150, 10151, 7, 15, 0, 0, 10151, 10152, 7, 3, 0, 0, 10152, 10153, 7, 6, 0, 0, 10153, 10154, 7, 5, 0, 0, 10154, 10155, 7, 6, 0, 0, 10155, 10156, 7, 4, 0, 0, 10156, 1004, 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, 11, 0, 0, 10161, 10162, 7, 2, 0, 0, 10162, 10163, 7, 5, 0, 0, 10163, 10164, 7, 6, 0, 0, 10164, 10165, 7, 9, 0, 0, 10165, 1006, 1, 0, 0, 0, 10166, 10167, 7, 6, 0, 0, 10167, 10168, 7, 7, 0, 0, 10168, 10169, 7, 8, 0, 0, 10169, 10170, 7, 2, 0, 0, 10170, 10171, 7, 9, 0, 0, 10171, 10172, 7, 10, 0, 0, 10172, 10173, 7, 7, 0, 0, 10173, 10174, 7, 17, 0, 0, 10174, 1008, 1, 0, 0, 0, 10175, 10176, 7, 6, 0, 0, 10176, 10177, 7, 7, 0, 0, 10177, 10178, 7, 8, 0, 0, 10178, 10179, 7, 3, 0, 0, 10179, 10180, 7, 18, 0, 0, 10180, 10181, 7, 15, 0, 0, 10181, 10182, 7, 4, 0, 0, 10182, 1010, 1, 0, 0, 0, 10183, 10184, 7, 6, 0, 0, 10184, 10185, 7, 7, 0, 0, 10185, 10186, 7, 8, 0, 0, 10186, 10187, 7, 3, 0, 0, 10187, 10188, 7, 18, 0, 0, 10188, 10189, 7, 15, 0, 0, 10189, 10190, 7, 4, 0, 0, 10190, 10191, 7, 10, 0, 0, 10191, 10192, 7, 2, 0, 0, 10192, 10193, 7, 7, 0, 0, 10193, 1012, 1, 0, 0, 0, 10194, 10195, 7, 6, 0, 0, 10195, 10196, 7, 7, 0, 0, 10196, 10197, 7, 8, 0, 0, 10197, 10198, 7, 3, 0, 0, 10198, 10199, 7, 18, 0, 0, 10199, 10200, 7, 15, 0, 0, 10200, 10201, 7, 4, 0, 0, 10201, 10202, 7, 15, 0, 0, 10202, 10203, 7, 0, 0, 0, 10203, 10204, 7, 5, 0, 0, 10204, 10205, 7, 5, 0, 0, 10205, 10206, 7, 22, 0, 0, 10206, 10207, 7, 2, 0, 0, 10207, 10208, 7, 3, 0, 0, 10208, 10209, 7, 9, 0, 0, 10209, 10210, 7, 10, 0, 0, 10210, 10211, 7, 5, 0, 0, 10211, 10212, 7, 7, 0, 0, 10212, 10213, 7, 12, 0, 0, 10213, 10214, 7, 11, 0, 0, 10214, 10215, 7, 11, 0, 0, 10215, 1014, 1, 0, 0, 0, 10216, 10217, 7, 6, 0, 0, 10217, 10218, 7, 7, 0, 0, 10218, 10219, 7, 9, 0, 0, 10219, 1016, 1, 0, 0, 0, 10220, 10221, 7, 6, 0, 0, 10221, 10222, 7, 7, 0, 0, 10222, 10223, 7, 9, 0, 0, 10223, 10224, 5, 95, 0, 0, 10224, 10225, 7, 2, 0, 0, 10225, 10226, 7, 12, 0, 0, 10226, 10227, 7, 4, 0, 0, 10227, 10228, 7, 11, 0, 0, 10228, 10229, 7, 10, 0, 0, 10229, 10230, 7, 7, 0, 0, 10230, 10231, 7, 6, 0, 0, 10231, 10232, 5, 95, 0, 0, 10232, 10233, 7, 9, 0, 0, 10233, 10234, 7, 0, 0, 0, 10234, 10235, 7, 4, 0, 0, 10235, 10236, 7, 0, 0, 0, 10236, 1018, 1, 0, 0, 0, 10237, 10238, 7, 6, 0, 0, 10238, 10239, 7, 7, 0, 0, 10239, 10240, 7, 9, 0, 0, 10240, 10241, 7, 10, 0, 0, 10241, 10242, 7, 0, 0, 0, 10242, 10243, 7, 7, 0, 0, 10243, 1020, 1, 0, 0, 0, 10244, 10245, 7, 6, 0, 0, 10245, 10246, 7, 7, 0, 0, 10246, 10247, 7, 16, 0, 0, 10247, 10248, 7, 2, 0, 0, 10248, 10249, 7, 3, 0, 0, 10249, 10250, 7, 8, 0, 0, 10250, 10251, 7, 6, 0, 0, 10251, 10252, 7, 9, 0, 0, 10252, 1022, 1, 0, 0, 0, 10253, 10254, 7, 6, 0, 0, 10254, 10255, 7, 7, 0, 0, 10255, 10256, 7, 16, 0, 0, 10256, 10257, 7, 2, 0, 0, 10257, 10258, 7, 3, 0, 0, 10258, 10259, 7, 8, 0, 0, 10259, 10260, 7, 6, 0, 0, 10260, 1024, 1, 0, 0, 0, 10261, 10262, 7, 6, 0, 0, 10262, 10263, 7, 7, 0, 0, 10263, 10264, 7, 24, 0, 0, 10264, 10265, 7, 12, 0, 0, 10265, 10266, 7, 6, 0, 0, 10266, 10267, 7, 12, 0, 0, 10267, 10268, 7, 6, 0, 0, 10268, 1026, 1, 0, 0, 0, 10269, 10270, 7, 6, 0, 0, 10270, 10271, 7, 7, 0, 0, 10271, 10272, 7, 4, 0, 0, 10272, 10273, 7, 6, 0, 0, 10273, 10274, 7, 3, 0, 0, 10274, 10275, 7, 15, 0, 0, 10275, 10276, 7, 3, 0, 0, 10276, 10277, 7, 10, 0, 0, 10277, 10278, 7, 5, 0, 0, 10278, 10279, 7, 6, 0, 0, 10279, 1028, 1, 0, 0, 0, 10280, 10281, 7, 6, 0, 0, 10281, 10282, 7, 7, 0, 0, 10282, 10283, 7, 4, 0, 0, 10283, 10284, 7, 10, 0, 0, 10284, 10285, 7, 4, 0, 0, 10285, 10286, 7, 18, 0, 0, 10286, 10287, 7, 6, 0, 0, 10287, 10288, 7, 5, 0, 0, 10288, 10289, 7, 8, 0, 0, 10289, 10290, 7, 0, 0, 0, 10290, 10291, 7, 15, 0, 0, 10291, 10292, 7, 10, 0, 0, 10292, 10293, 7, 7, 0, 0, 10293, 10294, 7, 17, 0, 0, 10294, 1030, 1, 0, 0, 0, 10295, 10296, 7, 6, 0, 0, 10296, 10297, 7, 7, 0, 0, 10297, 10298, 7, 4, 0, 0, 10298, 10299, 7, 3, 0, 0, 10299, 10300, 7, 18, 0, 0, 10300, 1032, 1, 0, 0, 0, 10301, 10302, 7, 6, 0, 0, 10302, 10303, 7, 24, 0, 0, 10303, 10304, 7, 12, 0, 0, 10304, 10305, 7, 10, 0, 0, 10305, 10306, 7, 15, 0, 0, 10306, 10307, 7, 0, 0, 0, 10307, 10308, 7, 3, 0, 0, 10308, 10309, 7, 4, 0, 0, 10309, 1034, 1, 0, 0, 0, 10310, 10311, 7, 6, 0, 0, 10311, 10312, 7, 3, 0, 0, 10312, 10313, 7, 3, 0, 0, 10313, 1036, 1, 0, 0, 0, 10314, 10315, 7, 6, 0, 0, 10315, 10316, 7, 3, 0, 0, 10316, 10317, 7, 3, 0, 0, 10317, 10318, 7, 2, 0, 0, 10318, 10319, 7, 3, 0, 0, 10319, 10320, 5, 95, 0, 0, 10320, 10321, 7, 0, 0, 0, 10321, 10322, 7, 3, 0, 0, 10322, 10323, 7, 17, 0, 0, 10323, 10324, 7, 12, 0, 0, 10324, 10325, 7, 14, 0, 0, 10325, 10326, 7, 6, 0, 0, 10326, 10327, 7, 7, 0, 0, 10327, 10328, 7, 4, 0, 0, 10328, 1038, 1, 0, 0, 0, 10329, 10330, 7, 6, 0, 0, 10330, 10331, 7, 3, 0, 0, 10331, 10332, 7, 3, 0, 0, 10332, 10333, 7, 2, 0, 0, 10333, 10334, 7, 3, 0, 0, 10334, 1040, 1, 0, 0, 0, 10335, 10336, 7, 6, 0, 0, 10336, 10337, 7, 3, 0, 0, 10337, 10338, 7, 3, 0, 0, 10338, 10339, 7, 2, 0, 0, 10339, 10340, 7, 3, 0, 0, 10340, 10341, 5, 95, 0, 0, 10341, 10342, 7, 2, 0, 0, 10342, 10343, 7, 7, 0, 0, 10343, 10344, 5, 95, 0, 0, 10344, 10345, 7, 2, 0, 0, 10345, 10346, 7, 13, 0, 0, 10346, 10347, 7, 6, 0, 0, 10347, 10348, 7, 3, 0, 0, 10348, 10349, 7, 11, 0, 0, 10349, 10350, 7, 0, 0, 0, 10350, 10351, 7, 15, 0, 0, 10351, 10352, 5, 95, 0, 0, 10352, 10353, 7, 4, 0, 0, 10353, 10354, 7, 10, 0, 0, 10354, 10355, 7, 14, 0, 0, 10355, 10356, 7, 6, 0, 0, 10356, 1042, 1, 0, 0, 0, 10357, 10358, 7, 6, 0, 0, 10358, 10359, 7, 3, 0, 0, 10359, 10360, 7, 3, 0, 0, 10360, 10361, 7, 2, 0, 0, 10361, 10362, 7, 3, 0, 0, 10362, 10363, 7, 5, 0, 0, 10363, 1044, 1, 0, 0, 0, 10364, 10365, 7, 6, 0, 0, 10365, 10366, 7, 3, 0, 0, 10366, 10367, 7, 3, 0, 0, 10367, 10368, 7, 2, 0, 0, 10368, 10369, 7, 3, 0, 0, 10369, 10370, 5, 95, 0, 0, 10370, 10371, 7, 10, 0, 0, 10371, 10372, 7, 7, 0, 0, 10372, 10373, 7, 9, 0, 0, 10373, 10374, 7, 6, 0, 0, 10374, 10375, 7, 25, 0, 0, 10375, 1046, 1, 0, 0, 0, 10376, 10377, 7, 6, 0, 0, 10377, 10378, 7, 3, 0, 0, 10378, 10379, 7, 3, 0, 0, 10379, 10380, 7, 2, 0, 0, 10380, 10381, 7, 3, 0, 0, 10381, 10382, 5, 95, 0, 0, 10382, 10383, 7, 8, 0, 0, 10383, 10384, 7, 2, 0, 0, 10384, 10385, 7, 9, 0, 0, 10385, 10386, 7, 6, 0, 0, 10386, 1048, 1, 0, 0, 0, 10387, 10388, 7, 6, 0, 0, 10388, 10389, 7, 5, 0, 0, 10389, 10390, 7, 8, 0, 0, 10390, 10391, 7, 0, 0, 0, 10391, 10392, 7, 15, 0, 0, 10392, 10393, 7, 6, 0, 0, 10393, 1050, 1, 0, 0, 0, 10394, 10395, 7, 6, 0, 0, 10395, 10396, 7, 5, 0, 0, 10396, 10397, 7, 8, 0, 0, 10397, 10398, 7, 0, 0, 0, 10398, 10399, 7, 15, 0, 0, 10399, 10400, 7, 6, 0, 0, 10400, 10401, 7, 9, 0, 0, 10401, 1052, 1, 0, 0, 0, 10402, 10403, 7, 6, 0, 0, 10403, 10404, 7, 5, 0, 0, 10404, 10405, 7, 4, 0, 0, 10405, 10406, 7, 10, 0, 0, 10406, 10407, 7, 14, 0, 0, 10407, 10408, 7, 0, 0, 0, 10408, 10409, 7, 4, 0, 0, 10409, 10410, 7, 6, 0, 0, 10410, 1054, 1, 0, 0, 0, 10411, 10412, 7, 6, 0, 0, 10412, 10413, 7, 13, 0, 0, 10413, 10414, 7, 0, 0, 0, 10414, 10415, 7, 11, 0, 0, 10415, 1056, 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, 7, 0, 0, 10421, 10422, 7, 0, 0, 0, 10422, 10423, 7, 14, 0, 0, 10423, 10424, 7, 6, 0, 0, 10424, 1058, 1, 0, 0, 0, 10425, 10426, 7, 6, 0, 0, 10426, 10427, 7, 13, 0, 0, 10427, 10428, 7, 0, 0, 0, 10428, 10429, 7, 11, 0, 0, 10429, 10430, 7, 12, 0, 0, 10430, 10431, 7, 0, 0, 0, 10431, 10432, 7, 4, 0, 0, 10432, 10433, 7, 6, 0, 0, 10433, 1060, 1, 0, 0, 0, 10434, 10435, 7, 6, 0, 0, 10435, 10436, 7, 13, 0, 0, 10436, 10437, 7, 0, 0, 0, 10437, 10438, 7, 11, 0, 0, 10438, 10439, 7, 12, 0, 0, 10439, 10440, 7, 0, 0, 0, 10440, 10441, 7, 4, 0, 0, 10441, 10442, 7, 10, 0, 0, 10442, 10443, 7, 2, 0, 0, 10443, 10444, 7, 7, 0, 0, 10444, 1062, 1, 0, 0, 0, 10445, 10446, 7, 6, 0, 0, 10446, 10447, 7, 13, 0, 0, 10447, 10448, 7, 6, 0, 0, 10448, 10449, 7, 7, 0, 0, 10449, 10450, 7, 4, 0, 0, 10450, 10451, 7, 5, 0, 0, 10451, 1064, 1, 0, 0, 0, 10452, 10453, 7, 6, 0, 0, 10453, 10454, 7, 13, 0, 0, 10454, 10455, 7, 6, 0, 0, 10455, 10456, 7, 3, 0, 0, 10456, 10457, 7, 18, 0, 0, 10457, 1066, 1, 0, 0, 0, 10458, 10459, 7, 6, 0, 0, 10459, 10460, 7, 25, 0, 0, 10460, 10461, 7, 8, 0, 0, 10461, 10462, 7, 6, 0, 0, 10462, 10463, 7, 15, 0, 0, 10463, 10464, 7, 4, 0, 0, 10464, 1068, 1, 0, 0, 0, 10465, 10466, 7, 6, 0, 0, 10466, 10467, 7, 25, 0, 0, 10467, 10468, 7, 8, 0, 0, 10468, 10469, 7, 6, 0, 0, 10469, 10470, 7, 15, 0, 0, 10470, 10471, 7, 4, 0, 0, 10471, 10472, 7, 10, 0, 0, 10472, 10473, 7, 2, 0, 0, 10473, 10474, 7, 7, 0, 0, 10474, 1070, 1, 0, 0, 0, 10475, 10476, 7, 6, 0, 0, 10476, 10477, 7, 25, 0, 0, 10477, 10478, 7, 8, 0, 0, 10478, 10479, 7, 6, 0, 0, 10479, 10480, 7, 15, 0, 0, 10480, 10481, 7, 4, 0, 0, 10481, 10482, 7, 10, 0, 0, 10482, 10483, 7, 2, 0, 0, 10483, 10484, 7, 7, 0, 0, 10484, 10485, 5, 95, 0, 0, 10485, 10486, 7, 10, 0, 0, 10486, 10487, 7, 7, 0, 0, 10487, 10488, 7, 10, 0, 0, 10488, 10489, 7, 4, 0, 0, 10489, 1072, 1, 0, 0, 0, 10490, 10491, 7, 6, 0, 0, 10491, 10492, 7, 25, 0, 0, 10492, 10493, 7, 8, 0, 0, 10493, 10494, 7, 6, 0, 0, 10494, 10495, 7, 15, 0, 0, 10495, 10496, 7, 4, 0, 0, 10496, 10497, 7, 10, 0, 0, 10497, 10498, 7, 2, 0, 0, 10498, 10499, 7, 7, 0, 0, 10499, 10500, 7, 5, 0, 0, 10500, 1074, 1, 0, 0, 0, 10501, 10502, 7, 6, 0, 0, 10502, 10503, 7, 25, 0, 0, 10503, 10504, 7, 8, 0, 0, 10504, 10505, 7, 19, 0, 0, 10505, 10506, 7, 0, 0, 0, 10506, 10507, 7, 7, 0, 0, 10507, 10508, 7, 17, 0, 0, 10508, 10509, 7, 6, 0, 0, 10509, 1076, 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, 9, 0, 0, 10516, 10517, 7, 6, 0, 0, 10517, 1078, 1, 0, 0, 0, 10518, 10519, 7, 6, 0, 0, 10519, 10520, 7, 25, 0, 0, 10520, 10521, 7, 8, 0, 0, 10521, 10522, 7, 11, 0, 0, 10522, 10523, 7, 12, 0, 0, 10523, 10524, 7, 9, 0, 0, 10524, 10525, 7, 10, 0, 0, 10525, 10526, 7, 7, 0, 0, 10526, 10527, 7, 17, 0, 0, 10527, 1080, 1, 0, 0, 0, 10528, 10529, 7, 6, 0, 0, 10529, 10530, 7, 25, 0, 0, 10530, 10531, 7, 8, 0, 0, 10531, 10532, 7, 11, 0, 0, 10532, 10533, 7, 12, 0, 0, 10533, 10534, 7, 5, 0, 0, 10534, 10535, 7, 10, 0, 0, 10535, 10536, 7, 13, 0, 0, 10536, 10537, 7, 6, 0, 0, 10537, 1082, 1, 0, 0, 0, 10538, 10539, 7, 6, 0, 0, 10539, 10540, 7, 25, 0, 0, 10540, 10541, 7, 6, 0, 0, 10541, 10542, 7, 8, 0, 0, 10542, 10543, 7, 12, 0, 0, 10543, 10544, 7, 4, 0, 0, 10544, 10545, 7, 6, 0, 0, 10545, 1084, 1, 0, 0, 0, 10546, 10547, 7, 6, 0, 0, 10547, 10548, 7, 25, 0, 0, 10548, 10549, 7, 6, 0, 0, 10549, 10550, 7, 14, 0, 0, 10550, 10551, 7, 15, 0, 0, 10551, 10552, 7, 4, 0, 0, 10552, 1086, 1, 0, 0, 0, 10553, 10554, 7, 6, 0, 0, 10554, 10555, 7, 25, 0, 0, 10555, 10556, 7, 10, 0, 0, 10556, 10557, 7, 5, 0, 0, 10557, 10558, 7, 4, 0, 0, 10558, 10559, 7, 10, 0, 0, 10559, 10560, 7, 7, 0, 0, 10560, 10561, 7, 17, 0, 0, 10561, 1088, 1, 0, 0, 0, 10562, 10563, 7, 6, 0, 0, 10563, 10564, 7, 25, 0, 0, 10564, 10565, 7, 10, 0, 0, 10565, 10566, 7, 5, 0, 0, 10566, 10567, 7, 4, 0, 0, 10567, 10568, 7, 5, 0, 0, 10568, 1090, 1, 0, 0, 0, 10569, 10570, 7, 6, 0, 0, 10570, 10571, 7, 25, 0, 0, 10571, 10572, 7, 10, 0, 0, 10572, 10573, 7, 5, 0, 0, 10573, 10574, 7, 4, 0, 0, 10574, 10575, 7, 5, 0, 0, 10575, 10576, 7, 7, 0, 0, 10576, 10577, 7, 2, 0, 0, 10577, 10578, 7, 9, 0, 0, 10578, 10579, 7, 6, 0, 0, 10579, 1092, 1, 0, 0, 0, 10580, 10581, 7, 6, 0, 0, 10581, 10582, 7, 25, 0, 0, 10582, 10583, 7, 10, 0, 0, 10583, 10584, 7, 4, 0, 0, 10584, 1094, 1, 0, 0, 0, 10585, 10586, 7, 6, 0, 0, 10586, 10587, 7, 25, 0, 0, 10587, 10588, 7, 15, 0, 0, 10588, 10589, 7, 0, 0, 0, 10589, 10590, 7, 7, 0, 0, 10590, 10591, 7, 9, 0, 0, 10591, 10592, 5, 95, 0, 0, 10592, 10593, 7, 17, 0, 0, 10593, 10594, 7, 5, 0, 0, 10594, 10595, 7, 6, 0, 0, 10595, 10596, 7, 4, 0, 0, 10596, 10597, 5, 95, 0, 0, 10597, 10598, 7, 4, 0, 0, 10598, 10599, 7, 2, 0, 0, 10599, 10600, 5, 95, 0, 0, 10600, 10601, 7, 12, 0, 0, 10601, 10602, 7, 7, 0, 0, 10602, 10603, 7, 10, 0, 0, 10603, 10604, 7, 2, 0, 0, 10604, 10605, 7, 7, 0, 0, 10605, 1096, 1, 0, 0, 0, 10606, 10607, 7, 6, 0, 0, 10607, 10608, 7, 25, 0, 0, 10608, 10609, 7, 15, 0, 0, 10609, 10610, 7, 0, 0, 0, 10610, 10611, 7, 7, 0, 0, 10611, 10612, 7, 9, 0, 0, 10612, 10613, 5, 95, 0, 0, 10613, 10614, 7, 4, 0, 0, 10614, 10615, 7, 0, 0, 0, 10615, 10616, 7, 1, 0, 0, 10616, 10617, 7, 11, 0, 0, 10617, 10618, 7, 6, 0, 0, 10618, 1098, 1, 0, 0, 0, 10619, 10620, 7, 6, 0, 0, 10620, 10621, 7, 25, 0, 0, 10621, 10622, 7, 15, 0, 0, 10622, 1100, 1, 0, 0, 0, 10623, 10624, 7, 6, 0, 0, 10624, 10625, 7, 25, 0, 0, 10625, 10626, 7, 15, 0, 0, 10626, 10627, 7, 10, 0, 0, 10627, 10628, 7, 3, 0, 0, 10628, 10629, 7, 6, 0, 0, 10629, 1102, 1, 0, 0, 0, 10630, 10631, 7, 6, 0, 0, 10631, 10632, 7, 25, 0, 0, 10632, 10633, 7, 15, 0, 0, 10633, 10634, 7, 11, 0, 0, 10634, 10635, 7, 0, 0, 0, 10635, 10636, 7, 10, 0, 0, 10636, 10637, 7, 7, 0, 0, 10637, 1104, 1, 0, 0, 0, 10638, 10639, 7, 6, 0, 0, 10639, 10640, 7, 25, 0, 0, 10640, 10641, 7, 15, 0, 0, 10641, 10642, 7, 11, 0, 0, 10642, 10643, 7, 2, 0, 0, 10643, 10644, 7, 5, 0, 0, 10644, 10645, 7, 10, 0, 0, 10645, 10646, 7, 2, 0, 0, 10646, 10647, 7, 7, 0, 0, 10647, 1106, 1, 0, 0, 0, 10648, 10649, 7, 6, 0, 0, 10649, 10650, 7, 25, 0, 0, 10650, 10651, 7, 15, 0, 0, 10651, 10652, 7, 2, 0, 0, 10652, 10653, 7, 3, 0, 0, 10653, 10654, 7, 4, 0, 0, 10654, 1108, 1, 0, 0, 0, 10655, 10656, 7, 6, 0, 0, 10656, 10657, 7, 25, 0, 0, 10657, 10658, 7, 15, 0, 0, 10658, 10659, 7, 3, 0, 0, 10659, 10660, 5, 95, 0, 0, 10660, 10661, 7, 8, 0, 0, 10661, 10662, 7, 2, 0, 0, 10662, 10663, 7, 3, 0, 0, 10663, 10664, 7, 3, 0, 0, 10664, 10665, 5, 95, 0, 0, 10665, 10666, 7, 8, 0, 0, 10666, 10667, 7, 19, 0, 0, 10667, 10668, 7, 6, 0, 0, 10668, 10669, 7, 8, 0, 0, 10669, 10670, 7, 21, 0, 0, 10670, 1110, 1, 0, 0, 0, 10671, 10672, 7, 6, 0, 0, 10672, 10673, 7, 25, 0, 0, 10673, 10674, 7, 15, 0, 0, 10674, 10675, 7, 3, 0, 0, 10675, 10676, 7, 6, 0, 0, 10676, 10677, 7, 5, 0, 0, 10677, 10678, 7, 5, 0, 0, 10678, 1112, 1, 0, 0, 0, 10679, 10680, 7, 6, 0, 0, 10680, 10681, 7, 25, 0, 0, 10681, 10682, 7, 4, 0, 0, 10682, 10683, 7, 6, 0, 0, 10683, 10684, 7, 7, 0, 0, 10684, 10685, 7, 9, 0, 0, 10685, 10686, 7, 5, 0, 0, 10686, 1114, 1, 0, 0, 0, 10687, 10688, 7, 6, 0, 0, 10688, 10689, 7, 25, 0, 0, 10689, 10690, 7, 4, 0, 0, 10690, 10691, 7, 6, 0, 0, 10691, 10692, 7, 7, 0, 0, 10692, 10693, 7, 4, 0, 0, 10693, 1116, 1, 0, 0, 0, 10694, 10695, 7, 6, 0, 0, 10695, 10696, 7, 25, 0, 0, 10696, 10697, 7, 4, 0, 0, 10697, 10698, 7, 6, 0, 0, 10698, 10699, 7, 7, 0, 0, 10699, 10700, 7, 4, 0, 0, 10700, 10701, 7, 5, 0, 0, 10701, 1118, 1, 0, 0, 0, 10702, 10703, 7, 6, 0, 0, 10703, 10704, 7, 25, 0, 0, 10704, 10705, 7, 4, 0, 0, 10705, 10706, 7, 6, 0, 0, 10706, 10707, 7, 3, 0, 0, 10707, 10708, 7, 7, 0, 0, 10708, 10709, 7, 0, 0, 0, 10709, 10710, 7, 11, 0, 0, 10710, 1120, 1, 0, 0, 0, 10711, 10712, 7, 6, 0, 0, 10712, 10713, 7, 25, 0, 0, 10713, 10714, 7, 4, 0, 0, 10714, 10715, 7, 6, 0, 0, 10715, 10716, 7, 3, 0, 0, 10716, 10717, 7, 7, 0, 0, 10717, 10718, 7, 0, 0, 0, 10718, 10719, 7, 11, 0, 0, 10719, 10720, 7, 11, 0, 0, 10720, 10721, 7, 18, 0, 0, 10721, 1122, 1, 0, 0, 0, 10722, 10723, 7, 6, 0, 0, 10723, 10724, 7, 25, 0, 0, 10724, 10725, 7, 4, 0, 0, 10725, 10726, 7, 3, 0, 0, 10726, 10727, 7, 0, 0, 0, 10727, 10728, 7, 8, 0, 0, 10728, 10729, 7, 4, 0, 0, 10729, 10730, 7, 8, 0, 0, 10730, 10731, 7, 11, 0, 0, 10731, 10732, 7, 2, 0, 0, 10732, 10733, 7, 1, 0, 0, 10733, 10734, 7, 25, 0, 0, 10734, 10735, 7, 14, 0, 0, 10735, 10736, 7, 11, 0, 0, 10736, 1124, 1, 0, 0, 0, 10737, 10738, 7, 6, 0, 0, 10738, 10739, 7, 25, 0, 0, 10739, 10740, 7, 4, 0, 0, 10740, 10741, 7, 3, 0, 0, 10741, 10742, 7, 0, 0, 0, 10742, 10743, 7, 8, 0, 0, 10743, 10744, 7, 4, 0, 0, 10744, 1126, 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, 10751, 7, 8, 0, 0, 10751, 10752, 7, 4, 0, 0, 10752, 10753, 7, 13, 0, 0, 10753, 10754, 7, 0, 0, 0, 10754, 10755, 7, 11, 0, 0, 10755, 10756, 7, 12, 0, 0, 10756, 10757, 7, 6, 0, 0, 10757, 1128, 1, 0, 0, 0, 10758, 10759, 7, 6, 0, 0, 10759, 10760, 7, 25, 0, 0, 10760, 10761, 7, 4, 0, 0, 10761, 10762, 7, 3, 0, 0, 10762, 10763, 7, 0, 0, 0, 10763, 1130, 1, 0, 0, 0, 10764, 10765, 7, 16, 0, 0, 10765, 10766, 7, 0, 0, 0, 10766, 10767, 7, 8, 0, 0, 10767, 10768, 7, 10, 0, 0, 10768, 10769, 7, 11, 0, 0, 10769, 10770, 7, 10, 0, 0, 10770, 10771, 7, 4, 0, 0, 10771, 10772, 7, 18, 0, 0, 10772, 1132, 1, 0, 0, 0, 10773, 10774, 7, 16, 0, 0, 10774, 10775, 7, 0, 0, 0, 10775, 10776, 7, 8, 0, 0, 10776, 10777, 7, 4, 0, 0, 10777, 1134, 1, 0, 0, 0, 10778, 10779, 7, 16, 0, 0, 10779, 10780, 7, 0, 0, 0, 10780, 10781, 7, 8, 0, 0, 10781, 10782, 7, 4, 0, 0, 10782, 10783, 7, 2, 0, 0, 10783, 10784, 7, 3, 0, 0, 10784, 1136, 1, 0, 0, 0, 10785, 10786, 7, 16, 0, 0, 10786, 10787, 7, 0, 0, 0, 10787, 10788, 7, 8, 0, 0, 10788, 10789, 7, 4, 0, 0, 10789, 10790, 7, 2, 0, 0, 10790, 10791, 7, 3, 0, 0, 10791, 10792, 7, 10, 0, 0, 10792, 10793, 7, 23, 0, 0, 10793, 10794, 7, 6, 0, 0, 10794, 10795, 5, 95, 0, 0, 10795, 10796, 7, 20, 0, 0, 10796, 10797, 7, 2, 0, 0, 10797, 10798, 7, 10, 0, 0, 10798, 10799, 7, 7, 0, 0, 10799, 1138, 1, 0, 0, 0, 10800, 10801, 7, 16, 0, 0, 10801, 10802, 7, 0, 0, 0, 10802, 10803, 7, 10, 0, 0, 10803, 10804, 7, 11, 0, 0, 10804, 10805, 7, 6, 0, 0, 10805, 10806, 7, 9, 0, 0, 10806, 1140, 1, 0, 0, 0, 10807, 10808, 7, 16, 0, 0, 10808, 10809, 7, 0, 0, 0, 10809, 10810, 7, 10, 0, 0, 10810, 10811, 7, 11, 0, 0, 10811, 10812, 7, 6, 0, 0, 10812, 10813, 7, 9, 0, 0, 10813, 10814, 5, 95, 0, 0, 10814, 10815, 7, 11, 0, 0, 10815, 10816, 7, 2, 0, 0, 10816, 10817, 7, 17, 0, 0, 10817, 10818, 7, 10, 0, 0, 10818, 10819, 7, 7, 0, 0, 10819, 10820, 5, 95, 0, 0, 10820, 10821, 7, 0, 0, 0, 10821, 10822, 7, 4, 0, 0, 10822, 10823, 7, 4, 0, 0, 10823, 10824, 7, 6, 0, 0, 10824, 10825, 7, 14, 0, 0, 10825, 10826, 7, 15, 0, 0, 10826, 10827, 7, 4, 0, 0, 10827, 10828, 7, 5, 0, 0, 10828, 1142, 1, 0, 0, 0, 10829, 10830, 7, 16, 0, 0, 10830, 10831, 7, 0, 0, 0, 10831, 10832, 7, 10, 0, 0, 10832, 10833, 7, 11, 0, 0, 10833, 10834, 7, 17, 0, 0, 10834, 10835, 7, 3, 0, 0, 10835, 10836, 7, 2, 0, 0, 10836, 10837, 7, 12, 0, 0, 10837, 10838, 7, 15, 0, 0, 10838, 1144, 1, 0, 0, 0, 10839, 10840, 7, 16, 0, 0, 10840, 10841, 7, 0, 0, 0, 10841, 10842, 7, 10, 0, 0, 10842, 10843, 7, 11, 0, 0, 10843, 10844, 7, 2, 0, 0, 10844, 10845, 7, 13, 0, 0, 10845, 10846, 7, 6, 0, 0, 10846, 10847, 7, 3, 0, 0, 10847, 1146, 1, 0, 0, 0, 10848, 10849, 7, 16, 0, 0, 10849, 10850, 7, 0, 0, 0, 10850, 10851, 7, 10, 0, 0, 10851, 10852, 7, 11, 0, 0, 10852, 10853, 7, 12, 0, 0, 10853, 10854, 7, 3, 0, 0, 10854, 10855, 7, 6, 0, 0, 10855, 1148, 1, 0, 0, 0, 10856, 10857, 7, 16, 0, 0, 10857, 10858, 7, 0, 0, 0, 10858, 10859, 7, 11, 0, 0, 10859, 10860, 7, 5, 0, 0, 10860, 10861, 7, 6, 0, 0, 10861, 1150, 1, 0, 0, 0, 10862, 10863, 7, 16, 0, 0, 10863, 10864, 7, 0, 0, 0, 10864, 10865, 7, 14, 0, 0, 10865, 10866, 7, 10, 0, 0, 10866, 10867, 7, 11, 0, 0, 10867, 10868, 7, 18, 0, 0, 10868, 1152, 1, 0, 0, 0, 10869, 10870, 7, 16, 0, 0, 10870, 10871, 7, 0, 0, 0, 10871, 10872, 7, 3, 0, 0, 10872, 1154, 1, 0, 0, 0, 10873, 10874, 7, 16, 0, 0, 10874, 10875, 7, 0, 0, 0, 10875, 10876, 7, 5, 0, 0, 10876, 10877, 7, 4, 0, 0, 10877, 1156, 1, 0, 0, 0, 10878, 10879, 7, 16, 0, 0, 10879, 10880, 7, 0, 0, 0, 10880, 10881, 7, 5, 0, 0, 10881, 10882, 7, 4, 0, 0, 10882, 10883, 7, 5, 0, 0, 10883, 10884, 7, 4, 0, 0, 10884, 10885, 7, 0, 0, 0, 10885, 10886, 7, 3, 0, 0, 10886, 10887, 7, 4, 0, 0, 10887, 1158, 1, 0, 0, 0, 10888, 10889, 7, 16, 0, 0, 10889, 10890, 7, 1, 0, 0, 10890, 10891, 7, 4, 0, 0, 10891, 10892, 7, 5, 0, 0, 10892, 10893, 7, 8, 0, 0, 10893, 10894, 7, 0, 0, 0, 10894, 10895, 7, 7, 0, 0, 10895, 1160, 1, 0, 0, 0, 10896, 10897, 7, 16, 0, 0, 10897, 10898, 7, 6, 0, 0, 10898, 10899, 7, 0, 0, 0, 10899, 10900, 7, 4, 0, 0, 10900, 10901, 7, 12, 0, 0, 10901, 10902, 7, 3, 0, 0, 10902, 10903, 7, 6, 0, 0, 10903, 1162, 1, 0, 0, 0, 10904, 10905, 7, 16, 0, 0, 10905, 10906, 7, 6, 0, 0, 10906, 10907, 7, 0, 0, 0, 10907, 10908, 7, 4, 0, 0, 10908, 10909, 7, 12, 0, 0, 10909, 10910, 7, 3, 0, 0, 10910, 10911, 7, 6, 0, 0, 10911, 10912, 5, 95, 0, 0, 10912, 10913, 7, 9, 0, 0, 10913, 10914, 7, 6, 0, 0, 10914, 10915, 7, 4, 0, 0, 10915, 10916, 7, 0, 0, 0, 10916, 10917, 7, 10, 0, 0, 10917, 10918, 7, 11, 0, 0, 10918, 10919, 7, 5, 0, 0, 10919, 1164, 1, 0, 0, 0, 10920, 10921, 7, 16, 0, 0, 10921, 10922, 7, 6, 0, 0, 10922, 10923, 7, 0, 0, 0, 10923, 10924, 7, 4, 0, 0, 10924, 10925, 7, 12, 0, 0, 10925, 10926, 7, 3, 0, 0, 10926, 10927, 7, 6, 0, 0, 10927, 10928, 5, 95, 0, 0, 10928, 10929, 7, 10, 0, 0, 10929, 10930, 7, 9, 0, 0, 10930, 1166, 1, 0, 0, 0, 10931, 10932, 7, 16, 0, 0, 10932, 10933, 7, 6, 0, 0, 10933, 10934, 7, 0, 0, 0, 10934, 10935, 7, 4, 0, 0, 10935, 10936, 7, 12, 0, 0, 10936, 10937, 7, 3, 0, 0, 10937, 10938, 7, 6, 0, 0, 10938, 10939, 5, 95, 0, 0, 10939, 10940, 7, 5, 0, 0, 10940, 10941, 7, 6, 0, 0, 10941, 10942, 7, 4, 0, 0, 10942, 1168, 1, 0, 0, 0, 10943, 10944, 7, 16, 0, 0, 10944, 10945, 7, 6, 0, 0, 10945, 10946, 7, 0, 0, 0, 10946, 10947, 7, 4, 0, 0, 10947, 10948, 7, 12, 0, 0, 10948, 10949, 7, 3, 0, 0, 10949, 10950, 7, 6, 0, 0, 10950, 10951, 5, 95, 0, 0, 10951, 10952, 7, 13, 0, 0, 10952, 10953, 7, 0, 0, 0, 10953, 10954, 7, 11, 0, 0, 10954, 10955, 7, 12, 0, 0, 10955, 10956, 7, 6, 0, 0, 10956, 1170, 1, 0, 0, 0, 10957, 10958, 7, 16, 0, 0, 10958, 10959, 7, 6, 0, 0, 10959, 10960, 7, 4, 0, 0, 10960, 10961, 7, 8, 0, 0, 10961, 10962, 7, 19, 0, 0, 10962, 1172, 1, 0, 0, 0, 10963, 10964, 7, 16, 0, 0, 10964, 10965, 7, 10, 0, 0, 10965, 10966, 7, 6, 0, 0, 10966, 10967, 7, 11, 0, 0, 10967, 10968, 7, 9, 0, 0, 10968, 1174, 1, 0, 0, 0, 10969, 10970, 7, 16, 0, 0, 10970, 10971, 7, 10, 0, 0, 10971, 10972, 7, 6, 0, 0, 10972, 10973, 7, 11, 0, 0, 10973, 10974, 7, 9, 0, 0, 10974, 10975, 7, 5, 0, 0, 10975, 1176, 1, 0, 0, 0, 10976, 10977, 7, 16, 0, 0, 10977, 10978, 7, 10, 0, 0, 10978, 10979, 7, 11, 0, 0, 10979, 10980, 7, 6, 0, 0, 10980, 1178, 1, 0, 0, 0, 10981, 10982, 7, 16, 0, 0, 10982, 10983, 7, 10, 0, 0, 10983, 10984, 7, 11, 0, 0, 10984, 10985, 7, 6, 0, 0, 10985, 10986, 5, 95, 0, 0, 10986, 10987, 7, 7, 0, 0, 10987, 10988, 7, 0, 0, 0, 10988, 10989, 7, 14, 0, 0, 10989, 10990, 7, 6, 0, 0, 10990, 10991, 5, 95, 0, 0, 10991, 10992, 7, 8, 0, 0, 10992, 10993, 7, 2, 0, 0, 10993, 10994, 7, 7, 0, 0, 10994, 10995, 7, 13, 0, 0, 10995, 10996, 7, 6, 0, 0, 10996, 10997, 7, 3, 0, 0, 10997, 10998, 7, 4, 0, 0, 10998, 1180, 1, 0, 0, 0, 10999, 11000, 7, 16, 0, 0, 11000, 11001, 7, 10, 0, 0, 11001, 11002, 7, 11, 0, 0, 11002, 11003, 7, 6, 0, 0, 11003, 11004, 7, 17, 0, 0, 11004, 11005, 7, 3, 0, 0, 11005, 11006, 7, 2, 0, 0, 11006, 11007, 7, 12, 0, 0, 11007, 11008, 7, 15, 0, 0, 11008, 1182, 1, 0, 0, 0, 11009, 11010, 7, 16, 0, 0, 11010, 11011, 7, 10, 0, 0, 11011, 11012, 7, 11, 0, 0, 11012, 11013, 7, 6, 0, 0, 11013, 11014, 7, 5, 0, 0, 11014, 11015, 7, 4, 0, 0, 11015, 11016, 7, 2, 0, 0, 11016, 11017, 7, 3, 0, 0, 11017, 11018, 7, 6, 0, 0, 11018, 1184, 1, 0, 0, 0, 11019, 11020, 7, 16, 0, 0, 11020, 11021, 7, 10, 0, 0, 11021, 11022, 7, 11, 0, 0, 11022, 11023, 7, 6, 0, 0, 11023, 11024, 7, 5, 0, 0, 11024, 11025, 7, 18, 0, 0, 11025, 11026, 7, 5, 0, 0, 11026, 11027, 7, 4, 0, 0, 11027, 11028, 7, 6, 0, 0, 11028, 11029, 7, 14, 0, 0, 11029, 11030, 5, 95, 0, 0, 11030, 11031, 7, 11, 0, 0, 11031, 11032, 7, 10, 0, 0, 11032, 11033, 7, 21, 0, 0, 11033, 11034, 7, 6, 0, 0, 11034, 11035, 5, 95, 0, 0, 11035, 11036, 7, 11, 0, 0, 11036, 11037, 7, 2, 0, 0, 11037, 11038, 7, 17, 0, 0, 11038, 11039, 7, 17, 0, 0, 11039, 11040, 7, 10, 0, 0, 11040, 11041, 7, 7, 0, 0, 11041, 11042, 7, 17, 0, 0, 11042, 1186, 1, 0, 0, 0, 11043, 11044, 7, 16, 0, 0, 11044, 11045, 7, 10, 0, 0, 11045, 11046, 7, 11, 0, 0, 11046, 11047, 7, 4, 0, 0, 11047, 11048, 7, 6, 0, 0, 11048, 11049, 7, 3, 0, 0, 11049, 1188, 1, 0, 0, 0, 11050, 11051, 7, 16, 0, 0, 11051, 11052, 7, 10, 0, 0, 11052, 11053, 7, 7, 0, 0, 11053, 11054, 7, 0, 0, 0, 11054, 11055, 7, 11, 0, 0, 11055, 1190, 1, 0, 0, 0, 11056, 11057, 7, 16, 0, 0, 11057, 11058, 7, 10, 0, 0, 11058, 11059, 7, 7, 0, 0, 11059, 11060, 7, 6, 0, 0, 11060, 1192, 1, 0, 0, 0, 11061, 11062, 7, 16, 0, 0, 11062, 11063, 7, 10, 0, 0, 11063, 11064, 7, 7, 0, 0, 11064, 11065, 7, 10, 0, 0, 11065, 11066, 7, 5, 0, 0, 11066, 11067, 7, 19, 0, 0, 11067, 1194, 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, 1196, 1, 0, 0, 0, 11074, 11075, 7, 16, 0, 0, 11075, 11076, 7, 10, 0, 0, 11076, 11077, 7, 3, 0, 0, 11077, 11078, 7, 5, 0, 0, 11078, 11079, 7, 4, 0, 0, 11079, 11080, 7, 14, 0, 0, 11080, 1198, 1, 0, 0, 0, 11081, 11082, 7, 16, 0, 0, 11082, 11083, 7, 10, 0, 0, 11083, 11084, 7, 3, 0, 0, 11084, 11085, 7, 5, 0, 0, 11085, 11086, 7, 4, 0, 0, 11086, 11087, 5, 95, 0, 0, 11087, 11088, 7, 3, 0, 0, 11088, 11089, 7, 2, 0, 0, 11089, 11090, 7, 22, 0, 0, 11090, 11091, 7, 5, 0, 0, 11091, 1200, 1, 0, 0, 0, 11092, 11093, 7, 16, 0, 0, 11093, 11094, 7, 10, 0, 0, 11094, 11095, 7, 3, 0, 0, 11095, 11096, 7, 5, 0, 0, 11096, 11097, 7, 4, 0, 0, 11097, 11098, 5, 95, 0, 0, 11098, 11099, 7, 13, 0, 0, 11099, 11100, 7, 0, 0, 0, 11100, 11101, 7, 11, 0, 0, 11101, 11102, 7, 12, 0, 0, 11102, 11103, 7, 6, 0, 0, 11103, 1202, 1, 0, 0, 0, 11104, 11105, 7, 16, 0, 0, 11105, 11106, 7, 10, 0, 0, 11106, 11107, 7, 25, 0, 0, 11107, 11108, 7, 6, 0, 0, 11108, 11109, 7, 9, 0, 0, 11109, 1204, 1, 0, 0, 0, 11110, 11111, 7, 16, 0, 0, 11111, 11112, 7, 10, 0, 0, 11112, 11113, 7, 25, 0, 0, 11113, 11114, 7, 6, 0, 0, 11114, 11115, 7, 9, 0, 0, 11115, 11116, 5, 95, 0, 0, 11116, 11117, 7, 13, 0, 0, 11117, 11118, 7, 10, 0, 0, 11118, 11119, 7, 6, 0, 0, 11119, 11120, 7, 22, 0, 0, 11120, 11121, 5, 95, 0, 0, 11121, 11122, 7, 9, 0, 0, 11122, 11123, 7, 0, 0, 0, 11123, 11124, 7, 4, 0, 0, 11124, 11125, 7, 0, 0, 0, 11125, 1206, 1, 0, 0, 0, 11126, 11127, 7, 16, 0, 0, 11127, 11128, 7, 11, 0, 0, 11128, 11129, 7, 0, 0, 0, 11129, 11130, 7, 17, 0, 0, 11130, 11131, 7, 17, 0, 0, 11131, 11132, 7, 6, 0, 0, 11132, 11133, 7, 3, 0, 0, 11133, 1208, 1, 0, 0, 0, 11134, 11135, 7, 16, 0, 0, 11135, 11136, 7, 11, 0, 0, 11136, 11137, 7, 0, 0, 0, 11137, 11138, 7, 5, 0, 0, 11138, 11139, 7, 19, 0, 0, 11139, 11140, 7, 1, 0, 0, 11140, 11141, 7, 0, 0, 0, 11141, 11142, 7, 8, 0, 0, 11142, 11143, 7, 21, 0, 0, 11143, 1210, 1, 0, 0, 0, 11144, 11145, 7, 16, 0, 0, 11145, 11146, 7, 11, 0, 0, 11146, 11147, 7, 0, 0, 0, 11147, 11148, 7, 5, 0, 0, 11148, 11149, 7, 19, 0, 0, 11149, 11150, 5, 95, 0, 0, 11150, 11151, 7, 8, 0, 0, 11151, 11152, 7, 0, 0, 0, 11152, 11153, 7, 8, 0, 0, 11153, 11154, 7, 19, 0, 0, 11154, 11155, 7, 6, 0, 0, 11155, 1212, 1, 0, 0, 0, 11156, 11157, 7, 16, 0, 0, 11157, 11158, 7, 11, 0, 0, 11158, 11159, 7, 2, 0, 0, 11159, 11160, 7, 0, 0, 0, 11160, 11161, 7, 4, 0, 0, 11161, 1214, 1, 0, 0, 0, 11162, 11163, 7, 16, 0, 0, 11163, 11164, 7, 11, 0, 0, 11164, 11165, 7, 2, 0, 0, 11165, 11166, 7, 1, 0, 0, 11166, 1216, 1, 0, 0, 0, 11167, 11168, 7, 16, 0, 0, 11168, 11169, 7, 11, 0, 0, 11169, 11170, 7, 6, 0, 0, 11170, 11171, 7, 25, 0, 0, 11171, 1218, 1, 0, 0, 0, 11172, 11173, 7, 16, 0, 0, 11173, 11174, 7, 11, 0, 0, 11174, 11175, 7, 2, 0, 0, 11175, 11176, 7, 2, 0, 0, 11176, 11177, 7, 3, 0, 0, 11177, 1220, 1, 0, 0, 0, 11178, 11179, 7, 16, 0, 0, 11179, 11180, 7, 11, 0, 0, 11180, 11181, 7, 12, 0, 0, 11181, 11182, 7, 5, 0, 0, 11182, 11183, 7, 19, 0, 0, 11183, 1222, 1, 0, 0, 0, 11184, 11185, 7, 16, 0, 0, 11185, 11186, 7, 2, 0, 0, 11186, 11187, 7, 11, 0, 0, 11187, 11188, 7, 9, 0, 0, 11188, 11189, 7, 6, 0, 0, 11189, 11190, 7, 3, 0, 0, 11190, 1224, 1, 0, 0, 0, 11191, 11192, 7, 16, 0, 0, 11192, 11193, 7, 2, 0, 0, 11193, 11194, 7, 11, 0, 0, 11194, 11195, 7, 11, 0, 0, 11195, 11196, 7, 2, 0, 0, 11196, 11197, 7, 22, 0, 0, 11197, 11198, 7, 10, 0, 0, 11198, 11199, 7, 7, 0, 0, 11199, 11200, 7, 17, 0, 0, 11200, 1226, 1, 0, 0, 0, 11201, 11202, 7, 16, 0, 0, 11202, 11203, 7, 2, 0, 0, 11203, 11204, 7, 11, 0, 0, 11204, 11205, 7, 11, 0, 0, 11205, 11206, 7, 2, 0, 0, 11206, 11207, 7, 22, 0, 0, 11207, 11208, 7, 5, 0, 0, 11208, 1228, 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, 0, 0, 0, 11213, 11214, 7, 11, 0, 0, 11214, 11215, 7, 11, 0, 0, 11215, 1230, 1, 0, 0, 0, 11216, 11217, 7, 16, 0, 0, 11217, 11218, 7, 2, 0, 0, 11218, 11219, 7, 3, 0, 0, 11219, 11220, 7, 8, 0, 0, 11220, 11221, 7, 6, 0, 0, 11221, 1232, 1, 0, 0, 0, 11222, 11223, 7, 16, 0, 0, 11223, 11224, 7, 2, 0, 0, 11224, 11225, 7, 3, 0, 0, 11225, 11226, 7, 8, 0, 0, 11226, 11227, 7, 6, 0, 0, 11227, 11228, 5, 95, 0, 0, 11228, 11229, 7, 25, 0, 0, 11229, 11230, 7, 14, 0, 0, 11230, 11231, 7, 11, 0, 0, 11231, 11232, 5, 95, 0, 0, 11232, 11233, 7, 24, 0, 0, 11233, 11234, 7, 12, 0, 0, 11234, 11235, 7, 6, 0, 0, 11235, 11236, 7, 3, 0, 0, 11236, 11237, 7, 18, 0, 0, 11237, 11238, 5, 95, 0, 0, 11238, 11239, 7, 3, 0, 0, 11239, 11240, 7, 6, 0, 0, 11240, 11241, 7, 22, 0, 0, 11241, 11242, 7, 3, 0, 0, 11242, 11243, 7, 10, 0, 0, 11243, 11244, 7, 4, 0, 0, 11244, 11245, 7, 6, 0, 0, 11245, 1234, 1, 0, 0, 0, 11246, 11247, 7, 16, 0, 0, 11247, 11248, 7, 2, 0, 0, 11248, 11249, 7, 3, 0, 0, 11249, 11250, 7, 6, 0, 0, 11250, 11251, 7, 10, 0, 0, 11251, 11252, 7, 17, 0, 0, 11252, 11253, 7, 7, 0, 0, 11253, 1236, 1, 0, 0, 0, 11254, 11255, 7, 16, 0, 0, 11255, 11256, 7, 2, 0, 0, 11256, 11257, 7, 3, 0, 0, 11257, 11258, 7, 6, 0, 0, 11258, 11259, 7, 13, 0, 0, 11259, 11260, 7, 6, 0, 0, 11260, 11261, 7, 3, 0, 0, 11261, 1238, 1, 0, 0, 0, 11262, 11263, 7, 16, 0, 0, 11263, 11264, 7, 2, 0, 0, 11264, 11265, 7, 3, 0, 0, 11265, 1240, 1, 0, 0, 0, 11266, 11267, 7, 16, 0, 0, 11267, 11268, 7, 2, 0, 0, 11268, 11269, 7, 3, 0, 0, 11269, 11270, 7, 14, 0, 0, 11270, 11271, 7, 0, 0, 0, 11271, 11272, 7, 4, 0, 0, 11272, 1242, 1, 0, 0, 0, 11273, 11274, 7, 16, 0, 0, 11274, 11275, 7, 2, 0, 0, 11275, 11276, 7, 3, 0, 0, 11276, 11277, 7, 22, 0, 0, 11277, 11278, 7, 0, 0, 0, 11278, 11279, 7, 3, 0, 0, 11279, 11280, 7, 9, 0, 0, 11280, 1244, 1, 0, 0, 0, 11281, 11282, 7, 16, 0, 0, 11282, 11283, 7, 3, 0, 0, 11283, 11284, 7, 0, 0, 0, 11284, 11285, 7, 17, 0, 0, 11285, 11286, 7, 14, 0, 0, 11286, 11287, 7, 6, 0, 0, 11287, 11288, 7, 7, 0, 0, 11288, 11289, 7, 4, 0, 0, 11289, 11290, 5, 95, 0, 0, 11290, 11291, 7, 7, 0, 0, 11291, 11292, 7, 12, 0, 0, 11292, 11293, 7, 14, 0, 0, 11293, 11294, 7, 1, 0, 0, 11294, 11295, 7, 6, 0, 0, 11295, 11296, 7, 3, 0, 0, 11296, 1246, 1, 0, 0, 0, 11297, 11298, 7, 16, 0, 0, 11298, 11299, 7, 3, 0, 0, 11299, 11300, 7, 6, 0, 0, 11300, 11301, 7, 6, 0, 0, 11301, 11302, 7, 11, 0, 0, 11302, 11303, 7, 10, 0, 0, 11303, 11304, 7, 5, 0, 0, 11304, 11305, 7, 4, 0, 0, 11305, 1248, 1, 0, 0, 0, 11306, 11307, 7, 16, 0, 0, 11307, 11308, 7, 3, 0, 0, 11308, 11309, 7, 6, 0, 0, 11309, 11310, 7, 6, 0, 0, 11310, 11311, 7, 11, 0, 0, 11311, 11312, 7, 10, 0, 0, 11312, 11313, 7, 5, 0, 0, 11313, 11314, 7, 4, 0, 0, 11314, 11315, 7, 5, 0, 0, 11315, 1250, 1, 0, 0, 0, 11316, 11317, 7, 16, 0, 0, 11317, 11318, 7, 3, 0, 0, 11318, 11319, 7, 6, 0, 0, 11319, 11320, 7, 6, 0, 0, 11320, 11321, 7, 15, 0, 0, 11321, 11322, 7, 2, 0, 0, 11322, 11323, 7, 2, 0, 0, 11323, 11324, 7, 11, 0, 0, 11324, 11325, 7, 5, 0, 0, 11325, 1252, 1, 0, 0, 0, 11326, 11327, 7, 16, 0, 0, 11327, 11328, 7, 3, 0, 0, 11328, 11329, 7, 6, 0, 0, 11329, 11330, 7, 5, 0, 0, 11330, 11331, 7, 19, 0, 0, 11331, 1254, 1, 0, 0, 0, 11332, 11333, 7, 16, 0, 0, 11333, 11334, 7, 3, 0, 0, 11334, 11335, 7, 2, 0, 0, 11335, 11336, 7, 14, 0, 0, 11336, 1256, 1, 0, 0, 0, 11337, 11338, 7, 16, 0, 0, 11338, 11339, 7, 3, 0, 0, 11339, 11340, 7, 2, 0, 0, 11340, 11341, 7, 14, 0, 0, 11341, 11342, 5, 95, 0, 0, 11342, 11343, 7, 4, 0, 0, 11343, 11344, 7, 23, 0, 0, 11344, 1258, 1, 0, 0, 0, 11345, 11346, 7, 16, 0, 0, 11346, 11347, 7, 12, 0, 0, 11347, 11348, 7, 11, 0, 0, 11348, 11349, 7, 11, 0, 0, 11349, 1260, 1, 0, 0, 0, 11350, 11351, 7, 16, 0, 0, 11351, 11352, 7, 12, 0, 0, 11352, 11353, 7, 11, 0, 0, 11353, 11354, 7, 11, 0, 0, 11354, 11355, 5, 95, 0, 0, 11355, 11356, 7, 2, 0, 0, 11356, 11357, 7, 12, 0, 0, 11357, 11358, 7, 4, 0, 0, 11358, 11359, 7, 6, 0, 0, 11359, 11360, 7, 3, 0, 0, 11360, 11361, 5, 95, 0, 0, 11361, 11362, 7, 20, 0, 0, 11362, 11363, 7, 2, 0, 0, 11363, 11364, 7, 10, 0, 0, 11364, 11365, 7, 7, 0, 0, 11365, 11366, 5, 95, 0, 0, 11366, 11367, 7, 4, 0, 0, 11367, 11368, 7, 2, 0, 0, 11368, 11369, 5, 95, 0, 0, 11369, 11370, 7, 2, 0, 0, 11370, 11371, 7, 12, 0, 0, 11371, 11372, 7, 4, 0, 0, 11372, 11373, 7, 6, 0, 0, 11373, 11374, 7, 3, 0, 0, 11374, 1262, 1, 0, 0, 0, 11375, 11376, 7, 16, 0, 0, 11376, 11377, 7, 12, 0, 0, 11377, 11378, 7, 7, 0, 0, 11378, 11379, 7, 8, 0, 0, 11379, 11380, 7, 4, 0, 0, 11380, 11381, 7, 10, 0, 0, 11381, 11382, 7, 2, 0, 0, 11382, 11383, 7, 7, 0, 0, 11383, 1264, 1, 0, 0, 0, 11384, 11385, 7, 16, 0, 0, 11385, 11386, 7, 12, 0, 0, 11386, 11387, 7, 7, 0, 0, 11387, 11388, 7, 8, 0, 0, 11388, 11389, 7, 4, 0, 0, 11389, 11390, 7, 10, 0, 0, 11390, 11391, 7, 2, 0, 0, 11391, 11392, 7, 7, 0, 0, 11392, 11393, 7, 5, 0, 0, 11393, 1266, 1, 0, 0, 0, 11394, 11395, 7, 16, 0, 0, 11395, 11396, 7, 4, 0, 0, 11396, 11397, 7, 15, 0, 0, 11397, 1268, 1, 0, 0, 0, 11398, 11399, 7, 17, 0, 0, 11399, 1270, 1, 0, 0, 0, 11400, 11401, 7, 17, 0, 0, 11401, 11402, 7, 0, 0, 0, 11402, 11403, 7, 4, 0, 0, 11403, 11404, 7, 19, 0, 0, 11404, 11405, 7, 6, 0, 0, 11405, 11406, 7, 3, 0, 0, 11406, 11407, 5, 95, 0, 0, 11407, 11408, 7, 2, 0, 0, 11408, 11409, 7, 15, 0, 0, 11409, 11410, 7, 4, 0, 0, 11410, 11411, 7, 10, 0, 0, 11411, 11412, 7, 14, 0, 0, 11412, 11413, 7, 10, 0, 0, 11413, 11414, 7, 23, 0, 0, 11414, 11415, 7, 6, 0, 0, 11415, 11416, 7, 3, 0, 0, 11416, 11417, 5, 95, 0, 0, 11417, 11418, 7, 5, 0, 0, 11418, 11419, 7, 4, 0, 0, 11419, 11420, 7, 0, 0, 0, 11420, 11421, 7, 4, 0, 0, 11421, 11422, 7, 10, 0, 0, 11422, 11423, 7, 5, 0, 0, 11423, 11424, 7, 4, 0, 0, 11424, 11425, 7, 10, 0, 0, 11425, 11426, 7, 8, 0, 0, 11426, 11427, 7, 5, 0, 0, 11427, 1272, 1, 0, 0, 0, 11428, 11429, 7, 17, 0, 0, 11429, 11430, 7, 0, 0, 0, 11430, 11431, 7, 4, 0, 0, 11431, 11432, 7, 19, 0, 0, 11432, 11433, 7, 6, 0, 0, 11433, 11434, 7, 3, 0, 0, 11434, 11435, 5, 95, 0, 0, 11435, 11436, 7, 15, 0, 0, 11436, 11437, 7, 11, 0, 0, 11437, 11438, 7, 0, 0, 0, 11438, 11439, 7, 7, 0, 0, 11439, 11440, 5, 95, 0, 0, 11440, 11441, 7, 5, 0, 0, 11441, 11442, 7, 4, 0, 0, 11442, 11443, 7, 0, 0, 0, 11443, 11444, 7, 4, 0, 0, 11444, 11445, 7, 10, 0, 0, 11445, 11446, 7, 5, 0, 0, 11446, 11447, 7, 4, 0, 0, 11447, 11448, 7, 10, 0, 0, 11448, 11449, 7, 8, 0, 0, 11449, 11450, 7, 5, 0, 0, 11450, 1274, 1, 0, 0, 0, 11451, 11452, 7, 17, 0, 0, 11452, 11453, 7, 1, 0, 0, 11453, 11454, 7, 18, 0, 0, 11454, 11455, 5, 95, 0, 0, 11455, 11456, 7, 8, 0, 0, 11456, 11457, 7, 2, 0, 0, 11457, 11458, 7, 7, 0, 0, 11458, 11459, 7, 8, 0, 0, 11459, 11460, 5, 95, 0, 0, 11460, 11461, 7, 3, 0, 0, 11461, 11462, 7, 2, 0, 0, 11462, 11463, 7, 11, 0, 0, 11463, 11464, 7, 11, 0, 0, 11464, 11465, 7, 12, 0, 0, 11465, 11466, 7, 15, 0, 0, 11466, 1276, 1, 0, 0, 0, 11467, 11468, 7, 17, 0, 0, 11468, 11469, 7, 1, 0, 0, 11469, 11470, 7, 18, 0, 0, 11470, 11471, 5, 95, 0, 0, 11471, 11472, 7, 15, 0, 0, 11472, 11473, 7, 12, 0, 0, 11473, 11474, 7, 5, 0, 0, 11474, 11475, 7, 19, 0, 0, 11475, 11476, 7, 9, 0, 0, 11476, 11477, 7, 2, 0, 0, 11477, 11478, 7, 22, 0, 0, 11478, 11479, 7, 7, 0, 0, 11479, 1278, 1, 0, 0, 0, 11480, 11481, 7, 17, 0, 0, 11481, 11482, 7, 6, 0, 0, 11482, 11483, 7, 7, 0, 0, 11483, 11484, 7, 6, 0, 0, 11484, 11485, 7, 3, 0, 0, 11485, 11486, 7, 0, 0, 0, 11486, 11487, 7, 4, 0, 0, 11487, 11488, 7, 6, 0, 0, 11488, 11489, 7, 9, 0, 0, 11489, 1280, 1, 0, 0, 0, 11490, 11491, 7, 17, 0, 0, 11491, 11492, 7, 6, 0, 0, 11492, 11493, 7, 4, 0, 0, 11493, 1282, 1, 0, 0, 0, 11494, 11495, 7, 17, 0, 0, 11495, 11496, 7, 11, 0, 0, 11496, 11497, 7, 2, 0, 0, 11497, 11498, 7, 1, 0, 0, 11498, 11499, 7, 0, 0, 0, 11499, 11500, 7, 11, 0, 0, 11500, 1284, 1, 0, 0, 0, 11501, 11502, 7, 17, 0, 0, 11502, 11503, 7, 11, 0, 0, 11503, 11504, 7, 2, 0, 0, 11504, 11505, 7, 1, 0, 0, 11505, 11506, 7, 0, 0, 0, 11506, 11507, 7, 11, 0, 0, 11507, 11508, 7, 11, 0, 0, 11508, 11509, 7, 18, 0, 0, 11509, 1286, 1, 0, 0, 0, 11510, 11511, 7, 17, 0, 0, 11511, 11512, 7, 11, 0, 0, 11512, 11513, 7, 2, 0, 0, 11513, 11514, 7, 1, 0, 0, 11514, 11515, 7, 0, 0, 0, 11515, 11516, 7, 11, 0, 0, 11516, 11517, 5, 95, 0, 0, 11517, 11518, 7, 7, 0, 0, 11518, 11519, 7, 0, 0, 0, 11519, 11520, 7, 14, 0, 0, 11520, 11521, 7, 6, 0, 0, 11521, 1288, 1, 0, 0, 0, 11522, 11523, 7, 17, 0, 0, 11523, 11524, 7, 11, 0, 0, 11524, 11525, 7, 2, 0, 0, 11525, 11526, 7, 1, 0, 0, 11526, 11527, 7, 0, 0, 0, 11527, 11528, 7, 11, 0, 0, 11528, 11529, 5, 95, 0, 0, 11529, 11530, 7, 4, 0, 0, 11530, 11531, 7, 2, 0, 0, 11531, 11532, 7, 15, 0, 0, 11532, 11533, 7, 10, 0, 0, 11533, 11534, 7, 8, 0, 0, 11534, 11535, 5, 95, 0, 0, 11535, 11536, 7, 6, 0, 0, 11536, 11537, 7, 7, 0, 0, 11537, 11538, 7, 0, 0, 0, 11538, 11539, 7, 1, 0, 0, 11539, 11540, 7, 11, 0, 0, 11540, 11541, 7, 6, 0, 0, 11541, 11542, 7, 9, 0, 0, 11542, 1290, 1, 0, 0, 0, 11543, 11544, 7, 17, 0, 0, 11544, 11545, 7, 2, 0, 0, 11545, 11546, 7, 4, 0, 0, 11546, 11547, 7, 2, 0, 0, 11547, 1292, 1, 0, 0, 0, 11548, 11549, 7, 17, 0, 0, 11549, 11550, 7, 3, 0, 0, 11550, 11551, 7, 0, 0, 0, 11551, 11552, 7, 7, 0, 0, 11552, 11553, 7, 4, 0, 0, 11553, 1294, 1, 0, 0, 0, 11554, 11555, 7, 17, 0, 0, 11555, 11556, 7, 3, 0, 0, 11556, 11557, 7, 2, 0, 0, 11557, 11558, 7, 12, 0, 0, 11558, 11559, 7, 15, 0, 0, 11559, 11560, 5, 95, 0, 0, 11560, 11561, 7, 1, 0, 0, 11561, 11562, 7, 18, 0, 0, 11562, 1296, 1, 0, 0, 0, 11563, 11564, 7, 17, 0, 0, 11564, 11565, 7, 3, 0, 0, 11565, 11566, 7, 2, 0, 0, 11566, 11567, 7, 12, 0, 0, 11567, 11568, 7, 15, 0, 0, 11568, 1298, 1, 0, 0, 0, 11569, 11570, 7, 17, 0, 0, 11570, 11571, 7, 3, 0, 0, 11571, 11572, 7, 2, 0, 0, 11572, 11573, 7, 12, 0, 0, 11573, 11574, 7, 15, 0, 0, 11574, 11575, 5, 95, 0, 0, 11575, 11576, 7, 10, 0, 0, 11576, 11577, 7, 9, 0, 0, 11577, 1300, 1, 0, 0, 0, 11578, 11579, 7, 17, 0, 0, 11579, 11580, 7, 3, 0, 0, 11580, 11581, 7, 2, 0, 0, 11581, 11582, 7, 12, 0, 0, 11582, 11583, 7, 15, 0, 0, 11583, 11584, 7, 10, 0, 0, 11584, 11585, 7, 7, 0, 0, 11585, 11586, 7, 17, 0, 0, 11586, 1302, 1, 0, 0, 0, 11587, 11588, 7, 17, 0, 0, 11588, 11589, 7, 3, 0, 0, 11589, 11590, 7, 2, 0, 0, 11590, 11591, 7, 12, 0, 0, 11591, 11592, 7, 15, 0, 0, 11592, 11593, 7, 10, 0, 0, 11593, 11594, 7, 7, 0, 0, 11594, 11595, 7, 17, 0, 0, 11595, 11596, 5, 95, 0, 0, 11596, 11597, 7, 10, 0, 0, 11597, 11598, 7, 9, 0, 0, 11598, 1304, 1, 0, 0, 0, 11599, 11600, 7, 17, 0, 0, 11600, 11601, 7, 3, 0, 0, 11601, 11602, 7, 2, 0, 0, 11602, 11603, 7, 12, 0, 0, 11603, 11604, 7, 15, 0, 0, 11604, 11605, 7, 5, 0, 0, 11605, 1306, 1, 0, 0, 0, 11606, 11607, 7, 17, 0, 0, 11607, 11608, 7, 12, 0, 0, 11608, 11609, 7, 0, 0, 0, 11609, 11610, 7, 3, 0, 0, 11610, 11611, 7, 0, 0, 0, 11611, 11612, 7, 7, 0, 0, 11612, 11613, 7, 4, 0, 0, 11613, 11614, 7, 6, 0, 0, 11614, 11615, 7, 6, 0, 0, 11615, 11616, 7, 9, 0, 0, 11616, 1308, 1, 0, 0, 0, 11617, 11618, 7, 17, 0, 0, 11618, 11619, 7, 12, 0, 0, 11619, 11620, 7, 0, 0, 0, 11620, 11621, 7, 3, 0, 0, 11621, 11622, 7, 0, 0, 0, 11622, 11623, 7, 7, 0, 0, 11623, 11624, 7, 4, 0, 0, 11624, 11625, 7, 6, 0, 0, 11625, 11626, 7, 6, 0, 0, 11626, 1310, 1, 0, 0, 0, 11627, 11628, 7, 17, 0, 0, 11628, 11629, 7, 12, 0, 0, 11629, 11630, 7, 0, 0, 0, 11630, 11631, 7, 3, 0, 0, 11631, 11632, 7, 9, 0, 0, 11632, 1312, 1, 0, 0, 0, 11633, 11634, 7, 19, 0, 0, 11634, 11635, 7, 0, 0, 0, 11635, 11636, 7, 9, 0, 0, 11636, 11637, 7, 2, 0, 0, 11637, 11638, 7, 2, 0, 0, 11638, 11639, 7, 15, 0, 0, 11639, 11640, 5, 95, 0, 0, 11640, 11641, 7, 4, 0, 0, 11641, 11642, 7, 3, 0, 0, 11642, 11643, 7, 0, 0, 0, 11643, 11644, 7, 10, 0, 0, 11644, 11645, 7, 11, 0, 0, 11645, 11646, 7, 6, 0, 0, 11646, 11647, 7, 3, 0, 0, 11647, 11648, 7, 5, 0, 0, 11648, 1314, 1, 0, 0, 0, 11649, 11650, 7, 19, 0, 0, 11650, 11651, 7, 0, 0, 0, 11651, 11652, 7, 11, 0, 0, 11652, 11653, 7, 16, 0, 0, 11653, 11654, 5, 95, 0, 0, 11654, 11655, 7, 18, 0, 0, 11655, 11656, 7, 6, 0, 0, 11656, 11657, 7, 0, 0, 0, 11657, 11658, 7, 3, 0, 0, 11658, 11659, 7, 5, 0, 0, 11659, 1316, 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, 5, 95, 0, 0, 11665, 11666, 7, 0, 0, 0, 11666, 11667, 7, 20, 0, 0, 11667, 1318, 1, 0, 0, 0, 11668, 11669, 7, 19, 0, 0, 11669, 11670, 7, 0, 0, 0, 11670, 11671, 7, 5, 0, 0, 11671, 11672, 7, 19, 0, 0, 11672, 1320, 1, 0, 0, 0, 11673, 11674, 7, 19, 0, 0, 11674, 11675, 7, 0, 0, 0, 11675, 11676, 7, 5, 0, 0, 11676, 11677, 7, 19, 0, 0, 11677, 11678, 7, 21, 0, 0, 11678, 11679, 7, 6, 0, 0, 11679, 11680, 7, 18, 0, 0, 11680, 11681, 7, 5, 0, 0, 11681, 1322, 1, 0, 0, 0, 11682, 11683, 7, 19, 0, 0, 11683, 11684, 7, 0, 0, 0, 11684, 11685, 7, 5, 0, 0, 11685, 11686, 7, 19, 0, 0, 11686, 11687, 5, 95, 0, 0, 11687, 11688, 7, 5, 0, 0, 11688, 11689, 7, 20, 0, 0, 11689, 1324, 1, 0, 0, 0, 11690, 11691, 7, 19, 0, 0, 11691, 11692, 7, 0, 0, 0, 11692, 11693, 7, 13, 0, 0, 11693, 11694, 7, 10, 0, 0, 11694, 11695, 7, 7, 0, 0, 11695, 11696, 7, 17, 0, 0, 11696, 1326, 1, 0, 0, 0, 11697, 11698, 7, 19, 0, 0, 11698, 11699, 7, 6, 0, 0, 11699, 11700, 7, 0, 0, 0, 11700, 11701, 7, 9, 0, 0, 11701, 11702, 7, 6, 0, 0, 11702, 11703, 7, 3, 0, 0, 11703, 1328, 1, 0, 0, 0, 11704, 11705, 7, 19, 0, 0, 11705, 11706, 7, 6, 0, 0, 11706, 11707, 7, 0, 0, 0, 11707, 11708, 7, 15, 0, 0, 11708, 1330, 1, 0, 0, 0, 11709, 11710, 7, 19, 0, 0, 11710, 11711, 7, 6, 0, 0, 11711, 11712, 7, 11, 0, 0, 11712, 11713, 7, 15, 0, 0, 11713, 1332, 1, 0, 0, 0, 11714, 11715, 7, 19, 0, 0, 11715, 11716, 7, 6, 0, 0, 11716, 11717, 7, 25, 0, 0, 11717, 11718, 7, 4, 0, 0, 11718, 11719, 7, 2, 0, 0, 11719, 11720, 7, 3, 0, 0, 11720, 11721, 7, 0, 0, 0, 11721, 11722, 7, 22, 0, 0, 11722, 1334, 1, 0, 0, 0, 11723, 11724, 7, 19, 0, 0, 11724, 11725, 7, 6, 0, 0, 11725, 11726, 7, 25, 0, 0, 11726, 11727, 7, 4, 0, 0, 11727, 11728, 7, 2, 0, 0, 11728, 11729, 7, 3, 0, 0, 11729, 11730, 7, 6, 0, 0, 11730, 11731, 7, 16, 0, 0, 11731, 1336, 1, 0, 0, 0, 11732, 11733, 7, 19, 0, 0, 11733, 11734, 7, 10, 0, 0, 11734, 11735, 7, 9, 0, 0, 11735, 11736, 7, 9, 0, 0, 11736, 11737, 7, 6, 0, 0, 11737, 11738, 7, 7, 0, 0, 11738, 1338, 1, 0, 0, 0, 11739, 11740, 7, 19, 0, 0, 11740, 11741, 7, 10, 0, 0, 11741, 11742, 7, 9, 0, 0, 11742, 11743, 7, 6, 0, 0, 11743, 1340, 1, 0, 0, 0, 11744, 11745, 7, 19, 0, 0, 11745, 11746, 7, 10, 0, 0, 11746, 11747, 7, 6, 0, 0, 11747, 11748, 7, 3, 0, 0, 11748, 11749, 5, 95, 0, 0, 11749, 11750, 7, 2, 0, 0, 11750, 11751, 7, 3, 0, 0, 11751, 11752, 7, 9, 0, 0, 11752, 11753, 7, 6, 0, 0, 11753, 11754, 7, 3, 0, 0, 11754, 1342, 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, 8, 0, 0, 11765, 11766, 7, 0, 0, 0, 11766, 11767, 7, 11, 0, 0, 11767, 1344, 1, 0, 0, 0, 11768, 11769, 7, 19, 0, 0, 11769, 11770, 7, 10, 0, 0, 11770, 11771, 7, 6, 0, 0, 11771, 11772, 7, 3, 0, 0, 11772, 11773, 7, 0, 0, 0, 11773, 11774, 7, 3, 0, 0, 11774, 11775, 7, 8, 0, 0, 11775, 11776, 7, 19, 0, 0, 11776, 11777, 7, 10, 0, 0, 11777, 11778, 7, 6, 0, 0, 11778, 11779, 7, 5, 0, 0, 11779, 1346, 1, 0, 0, 0, 11780, 11781, 7, 19, 0, 0, 11781, 11782, 7, 10, 0, 0, 11782, 11783, 7, 6, 0, 0, 11783, 11784, 7, 3, 0, 0, 11784, 11785, 7, 0, 0, 0, 11785, 11786, 7, 3, 0, 0, 11786, 11787, 7, 8, 0, 0, 11787, 11788, 7, 19, 0, 0, 11788, 11789, 7, 18, 0, 0, 11789, 1348, 1, 0, 0, 0, 11790, 11791, 7, 19, 0, 0, 11791, 11792, 7, 10, 0, 0, 11792, 11793, 7, 17, 0, 0, 11793, 11794, 7, 19, 0, 0, 11794, 1350, 1, 0, 0, 0, 11795, 11796, 7, 19, 0, 0, 11796, 11797, 7, 10, 0, 0, 11797, 11798, 7, 7, 0, 0, 11798, 11799, 7, 4, 0, 0, 11799, 11800, 7, 5, 0, 0, 11800, 11801, 7, 6, 0, 0, 11801, 11802, 7, 4, 0, 0, 11802, 11803, 5, 95, 0, 0, 11803, 11804, 7, 1, 0, 0, 11804, 11805, 7, 6, 0, 0, 11805, 11806, 7, 17, 0, 0, 11806, 11807, 7, 10, 0, 0, 11807, 11808, 7, 7, 0, 0, 11808, 1352, 1, 0, 0, 0, 11809, 11810, 7, 19, 0, 0, 11810, 11811, 7, 10, 0, 0, 11811, 11812, 7, 7, 0, 0, 11812, 11813, 7, 4, 0, 0, 11813, 11814, 7, 5, 0, 0, 11814, 11815, 7, 6, 0, 0, 11815, 11816, 7, 4, 0, 0, 11816, 11817, 5, 95, 0, 0, 11817, 11818, 7, 6, 0, 0, 11818, 11819, 7, 7, 0, 0, 11819, 11820, 7, 9, 0, 0, 11820, 1354, 1, 0, 0, 0, 11821, 11822, 7, 19, 0, 0, 11822, 11823, 7, 2, 0, 0, 11823, 11824, 7, 4, 0, 0, 11824, 1356, 1, 0, 0, 0, 11825, 11826, 7, 19, 0, 0, 11826, 11827, 7, 2, 0, 0, 11827, 11828, 7, 12, 0, 0, 11828, 11829, 7, 3, 0, 0, 11829, 1358, 1, 0, 0, 0, 11830, 11831, 7, 19, 0, 0, 11831, 11832, 7, 2, 0, 0, 11832, 11833, 7, 12, 0, 0, 11833, 11834, 7, 3, 0, 0, 11834, 11835, 7, 5, 0, 0, 11835, 1360, 1, 0, 0, 0, 11836, 11837, 7, 19, 0, 0, 11837, 11838, 7, 4, 0, 0, 11838, 11839, 7, 4, 0, 0, 11839, 11840, 7, 15, 0, 0, 11840, 1362, 1, 0, 0, 0, 11841, 11842, 7, 19, 0, 0, 11842, 11843, 7, 22, 0, 0, 11843, 11844, 7, 14, 0, 0, 11844, 11845, 5, 95, 0, 0, 11845, 11846, 7, 1, 0, 0, 11846, 11847, 7, 3, 0, 0, 11847, 11848, 7, 2, 0, 0, 11848, 11849, 7, 21, 0, 0, 11849, 11850, 7, 6, 0, 0, 11850, 11851, 7, 3, 0, 0, 11851, 11852, 7, 6, 0, 0, 11852, 11853, 7, 9, 0, 0, 11853, 1364, 1, 0, 0, 0, 11854, 11855, 7, 19, 0, 0, 11855, 11856, 7, 18, 0, 0, 11856, 11857, 7, 1, 0, 0, 11857, 11858, 7, 3, 0, 0, 11858, 11859, 7, 10, 0, 0, 11859, 11860, 7, 9, 0, 0, 11860, 1366, 1, 0, 0, 0, 11861, 11862, 7, 19, 0, 0, 11862, 1368, 1, 0, 0, 0, 11863, 11864, 7, 10, 0, 0, 11864, 11865, 7, 9, 0, 0, 11865, 11866, 7, 6, 0, 0, 11866, 11867, 7, 7, 0, 0, 11867, 11868, 7, 4, 0, 0, 11868, 11869, 7, 10, 0, 0, 11869, 11870, 7, 16, 0, 0, 11870, 11871, 7, 10, 0, 0, 11871, 11872, 7, 6, 0, 0, 11872, 11873, 7, 9, 0, 0, 11873, 1370, 1, 0, 0, 0, 11874, 11875, 7, 10, 0, 0, 11875, 11876, 7, 9, 0, 0, 11876, 11877, 7, 6, 0, 0, 11877, 11878, 7, 7, 0, 0, 11878, 11879, 7, 4, 0, 0, 11879, 11880, 7, 10, 0, 0, 11880, 11881, 7, 16, 0, 0, 11881, 11882, 7, 10, 0, 0, 11882, 11883, 7, 6, 0, 0, 11883, 11884, 7, 3, 0, 0, 11884, 1372, 1, 0, 0, 0, 11885, 11886, 7, 10, 0, 0, 11886, 11887, 7, 9, 0, 0, 11887, 11888, 7, 6, 0, 0, 11888, 11889, 7, 7, 0, 0, 11889, 11890, 7, 4, 0, 0, 11890, 11891, 7, 10, 0, 0, 11891, 11892, 7, 4, 0, 0, 11892, 11893, 7, 18, 0, 0, 11893, 1374, 1, 0, 0, 0, 11894, 11895, 7, 10, 0, 0, 11895, 11896, 7, 9, 0, 0, 11896, 11897, 7, 17, 0, 0, 11897, 11898, 7, 6, 0, 0, 11898, 11899, 7, 7, 0, 0, 11899, 11900, 7, 6, 0, 0, 11900, 11901, 7, 3, 0, 0, 11901, 11902, 7, 0, 0, 0, 11902, 11903, 7, 4, 0, 0, 11903, 11904, 7, 2, 0, 0, 11904, 11905, 7, 3, 0, 0, 11905, 11906, 7, 5, 0, 0, 11906, 1376, 1, 0, 0, 0, 11907, 11908, 7, 10, 0, 0, 11908, 11909, 7, 9, 0, 0, 11909, 1378, 1, 0, 0, 0, 11910, 11911, 7, 10, 0, 0, 11911, 11912, 7, 9, 0, 0, 11912, 11913, 7, 11, 0, 0, 11913, 11914, 7, 6, 0, 0, 11914, 11915, 5, 95, 0, 0, 11915, 11916, 7, 4, 0, 0, 11916, 11917, 7, 10, 0, 0, 11917, 11918, 7, 14, 0, 0, 11918, 11919, 7, 6, 0, 0, 11919, 1380, 1, 0, 0, 0, 11920, 11921, 7, 10, 0, 0, 11921, 11922, 7, 16, 0, 0, 11922, 1382, 1, 0, 0, 0, 11923, 11924, 7, 10, 0, 0, 11924, 11925, 7, 17, 0, 0, 11925, 11926, 7, 7, 0, 0, 11926, 11927, 7, 2, 0, 0, 11927, 11928, 7, 3, 0, 0, 11928, 11929, 7, 6, 0, 0, 11929, 1384, 1, 0, 0, 0, 11930, 11931, 7, 10, 0, 0, 11931, 11932, 7, 17, 0, 0, 11932, 11933, 7, 7, 0, 0, 11933, 11934, 7, 2, 0, 0, 11934, 11935, 7, 3, 0, 0, 11935, 11936, 7, 6, 0, 0, 11936, 11937, 5, 95, 0, 0, 11937, 11938, 7, 8, 0, 0, 11938, 11939, 7, 19, 0, 0, 11939, 11940, 7, 0, 0, 0, 11940, 11941, 7, 3, 0, 0, 11941, 11942, 7, 5, 0, 0, 11942, 11943, 5, 95, 0, 0, 11943, 11944, 7, 0, 0, 0, 11944, 11945, 7, 16, 0, 0, 11945, 11946, 7, 4, 0, 0, 11946, 11947, 7, 6, 0, 0, 11947, 11948, 7, 3, 0, 0, 11948, 11949, 5, 95, 0, 0, 11949, 11950, 7, 6, 0, 0, 11950, 11951, 7, 2, 0, 0, 11951, 11952, 7, 3, 0, 0, 11952, 1386, 1, 0, 0, 0, 11953, 11954, 7, 10, 0, 0, 11954, 11955, 7, 17, 0, 0, 11955, 11956, 7, 7, 0, 0, 11956, 11957, 7, 2, 0, 0, 11957, 11958, 7, 3, 0, 0, 11958, 11959, 7, 6, 0, 0, 11959, 11960, 5, 95, 0, 0, 11960, 11961, 7, 2, 0, 0, 11961, 11962, 7, 15, 0, 0, 11962, 11963, 7, 4, 0, 0, 11963, 11964, 7, 10, 0, 0, 11964, 11965, 7, 14, 0, 0, 11965, 11966, 5, 95, 0, 0, 11966, 11967, 7, 6, 0, 0, 11967, 11968, 7, 14, 0, 0, 11968, 11969, 7, 1, 0, 0, 11969, 11970, 7, 6, 0, 0, 11970, 11971, 7, 9, 0, 0, 11971, 11972, 7, 9, 0, 0, 11972, 11973, 7, 6, 0, 0, 11973, 11974, 7, 9, 0, 0, 11974, 11975, 5, 95, 0, 0, 11975, 11976, 7, 19, 0, 0, 11976, 11977, 7, 10, 0, 0, 11977, 11978, 7, 7, 0, 0, 11978, 11979, 7, 4, 0, 0, 11979, 11980, 7, 5, 0, 0, 11980, 1388, 1, 0, 0, 0, 11981, 11982, 7, 10, 0, 0, 11982, 11983, 7, 17, 0, 0, 11983, 11984, 7, 7, 0, 0, 11984, 11985, 7, 2, 0, 0, 11985, 11986, 7, 3, 0, 0, 11986, 11987, 7, 6, 0, 0, 11987, 11988, 5, 95, 0, 0, 11988, 11989, 7, 3, 0, 0, 11989, 11990, 7, 2, 0, 0, 11990, 11991, 7, 22, 0, 0, 11991, 11992, 5, 95, 0, 0, 11992, 11993, 7, 2, 0, 0, 11993, 11994, 7, 7, 0, 0, 11994, 11995, 5, 95, 0, 0, 11995, 11996, 7, 9, 0, 0, 11996, 11997, 7, 12, 0, 0, 11997, 11998, 7, 15, 0, 0, 11998, 11999, 7, 21, 0, 0, 11999, 12000, 7, 6, 0, 0, 12000, 12001, 7, 18, 0, 0, 12001, 12002, 5, 95, 0, 0, 12002, 12003, 7, 10, 0, 0, 12003, 12004, 7, 7, 0, 0, 12004, 12005, 7, 9, 0, 0, 12005, 12006, 7, 6, 0, 0, 12006, 12007, 7, 25, 0, 0, 12007, 1390, 1, 0, 0, 0, 12008, 12009, 7, 10, 0, 0, 12009, 12010, 7, 17, 0, 0, 12010, 12011, 7, 7, 0, 0, 12011, 12012, 7, 2, 0, 0, 12012, 12013, 7, 3, 0, 0, 12013, 12014, 7, 6, 0, 0, 12014, 12015, 5, 95, 0, 0, 12015, 12016, 7, 22, 0, 0, 12016, 12017, 7, 19, 0, 0, 12017, 12018, 7, 6, 0, 0, 12018, 12019, 7, 3, 0, 0, 12019, 12020, 7, 6, 0, 0, 12020, 12021, 5, 95, 0, 0, 12021, 12022, 7, 8, 0, 0, 12022, 12023, 7, 11, 0, 0, 12023, 12024, 7, 0, 0, 0, 12024, 12025, 7, 12, 0, 0, 12025, 12026, 7, 5, 0, 0, 12026, 12027, 7, 6, 0, 0, 12027, 1392, 1, 0, 0, 0, 12028, 12029, 7, 10, 0, 0, 12029, 12030, 7, 11, 0, 0, 12030, 12031, 7, 14, 0, 0, 12031, 1394, 1, 0, 0, 0, 12032, 12033, 7, 10, 0, 0, 12033, 12034, 7, 14, 0, 0, 12034, 12035, 7, 14, 0, 0, 12035, 12036, 7, 6, 0, 0, 12036, 12037, 7, 9, 0, 0, 12037, 12038, 7, 10, 0, 0, 12038, 12039, 7, 0, 0, 0, 12039, 12040, 7, 4, 0, 0, 12040, 12041, 7, 6, 0, 0, 12041, 1396, 1, 0, 0, 0, 12042, 12043, 7, 10, 0, 0, 12043, 12044, 7, 14, 0, 0, 12044, 12045, 7, 15, 0, 0, 12045, 12046, 7, 0, 0, 0, 12046, 12047, 7, 8, 0, 0, 12047, 12048, 7, 4, 0, 0, 12048, 1398, 1, 0, 0, 0, 12049, 12050, 7, 10, 0, 0, 12050, 12051, 7, 14, 0, 0, 12051, 12052, 7, 15, 0, 0, 12052, 12053, 7, 2, 0, 0, 12053, 12054, 7, 3, 0, 0, 12054, 12055, 7, 4, 0, 0, 12055, 1400, 1, 0, 0, 0, 12056, 12057, 7, 10, 0, 0, 12057, 12058, 7, 7, 0, 0, 12058, 12059, 7, 0, 0, 0, 12059, 12060, 7, 8, 0, 0, 12060, 12061, 7, 4, 0, 0, 12061, 12062, 7, 10, 0, 0, 12062, 12063, 7, 13, 0, 0, 12063, 12064, 7, 6, 0, 0, 12064, 1402, 1, 0, 0, 0, 12065, 12066, 7, 10, 0, 0, 12066, 12067, 7, 7, 0, 0, 12067, 12068, 7, 0, 0, 0, 12068, 12069, 7, 8, 0, 0, 12069, 12070, 7, 4, 0, 0, 12070, 12071, 7, 10, 0, 0, 12071, 12072, 7, 13, 0, 0, 12072, 12073, 7, 6, 0, 0, 12073, 12074, 5, 95, 0, 0, 12074, 12075, 7, 0, 0, 0, 12075, 12076, 7, 8, 0, 0, 12076, 12077, 7, 8, 0, 0, 12077, 12078, 7, 2, 0, 0, 12078, 12079, 7, 12, 0, 0, 12079, 12080, 7, 7, 0, 0, 12080, 12081, 7, 4, 0, 0, 12081, 12082, 5, 95, 0, 0, 12082, 12083, 7, 4, 0, 0, 12083, 12084, 7, 10, 0, 0, 12084, 12085, 7, 14, 0, 0, 12085, 12086, 7, 6, 0, 0, 12086, 1404, 1, 0, 0, 0, 12087, 12088, 7, 10, 0, 0, 12088, 12089, 7, 7, 0, 0, 12089, 12090, 7, 8, 0, 0, 12090, 12091, 7, 11, 0, 0, 12091, 12092, 7, 12, 0, 0, 12092, 12093, 7, 9, 0, 0, 12093, 12094, 7, 6, 0, 0, 12094, 1406, 1, 0, 0, 0, 12095, 12096, 7, 10, 0, 0, 12096, 12097, 7, 7, 0, 0, 12097, 12098, 7, 8, 0, 0, 12098, 12099, 7, 11, 0, 0, 12099, 12100, 7, 12, 0, 0, 12100, 12101, 7, 9, 0, 0, 12101, 12102, 7, 6, 0, 0, 12102, 12103, 5, 95, 0, 0, 12103, 12104, 7, 13, 0, 0, 12104, 12105, 7, 6, 0, 0, 12105, 12106, 7, 3, 0, 0, 12106, 12107, 7, 5, 0, 0, 12107, 12108, 7, 10, 0, 0, 12108, 12109, 7, 2, 0, 0, 12109, 12110, 7, 7, 0, 0, 12110, 1408, 1, 0, 0, 0, 12111, 12112, 7, 10, 0, 0, 12112, 12113, 7, 7, 0, 0, 12113, 12114, 7, 8, 0, 0, 12114, 12115, 7, 11, 0, 0, 12115, 12116, 7, 12, 0, 0, 12116, 12117, 7, 9, 0, 0, 12117, 12118, 7, 10, 0, 0, 12118, 12119, 7, 7, 0, 0, 12119, 12120, 7, 17, 0, 0, 12120, 1410, 1, 0, 0, 0, 12121, 12122, 7, 10, 0, 0, 12122, 12123, 7, 7, 0, 0, 12123, 12124, 7, 8, 0, 0, 12124, 12125, 7, 3, 0, 0, 12125, 12126, 7, 6, 0, 0, 12126, 12127, 7, 14, 0, 0, 12127, 12128, 7, 6, 0, 0, 12128, 12129, 7, 7, 0, 0, 12129, 12130, 7, 4, 0, 0, 12130, 12131, 7, 0, 0, 0, 12131, 12132, 7, 11, 0, 0, 12132, 1412, 1, 0, 0, 0, 12133, 12134, 7, 10, 0, 0, 12134, 12135, 7, 7, 0, 0, 12135, 12136, 7, 8, 0, 0, 12136, 12137, 7, 3, 0, 0, 12137, 12138, 7, 6, 0, 0, 12138, 12139, 7, 14, 0, 0, 12139, 12140, 7, 6, 0, 0, 12140, 12141, 7, 7, 0, 0, 12141, 12142, 7, 4, 0, 0, 12142, 1414, 1, 0, 0, 0, 12143, 12144, 7, 10, 0, 0, 12144, 12145, 7, 7, 0, 0, 12145, 12146, 7, 8, 0, 0, 12146, 12147, 7, 3, 0, 0, 12147, 1416, 1, 0, 0, 0, 12148, 12149, 7, 10, 0, 0, 12149, 12150, 7, 7, 0, 0, 12150, 12151, 7, 9, 0, 0, 12151, 12152, 7, 6, 0, 0, 12152, 12153, 7, 7, 0, 0, 12153, 12154, 7, 4, 0, 0, 12154, 1418, 1, 0, 0, 0, 12155, 12156, 7, 10, 0, 0, 12156, 12157, 7, 7, 0, 0, 12157, 12158, 7, 9, 0, 0, 12158, 12159, 7, 6, 0, 0, 12159, 12160, 7, 25, 0, 0, 12160, 12161, 5, 95, 0, 0, 12161, 12162, 7, 0, 0, 0, 12162, 12163, 7, 5, 0, 0, 12163, 12164, 7, 8, 0, 0, 12164, 1420, 1, 0, 0, 0, 12165, 12166, 7, 10, 0, 0, 12166, 12167, 7, 7, 0, 0, 12167, 12168, 7, 9, 0, 0, 12168, 12169, 7, 6, 0, 0, 12169, 12170, 7, 25, 0, 0, 12170, 12171, 5, 95, 0, 0, 12171, 12172, 7, 8, 0, 0, 12172, 12173, 7, 2, 0, 0, 12173, 12174, 7, 14, 0, 0, 12174, 12175, 7, 1, 0, 0, 12175, 12176, 7, 10, 0, 0, 12176, 12177, 7, 7, 0, 0, 12177, 12178, 7, 6, 0, 0, 12178, 1422, 1, 0, 0, 0, 12179, 12180, 7, 10, 0, 0, 12180, 12181, 7, 7, 0, 0, 12181, 12182, 7, 9, 0, 0, 12182, 12183, 7, 6, 0, 0, 12183, 12184, 7, 25, 0, 0, 12184, 12185, 5, 95, 0, 0, 12185, 12186, 7, 9, 0, 0, 12186, 12187, 7, 6, 0, 0, 12187, 12188, 7, 5, 0, 0, 12188, 12189, 7, 8, 0, 0, 12189, 1424, 1, 0, 0, 0, 12190, 12191, 7, 10, 0, 0, 12191, 12192, 7, 7, 0, 0, 12192, 12193, 7, 9, 0, 0, 12193, 12194, 7, 6, 0, 0, 12194, 12195, 7, 25, 0, 0, 12195, 12196, 7, 6, 0, 0, 12196, 12197, 7, 9, 0, 0, 12197, 1426, 1, 0, 0, 0, 12198, 12199, 7, 10, 0, 0, 12199, 12200, 7, 7, 0, 0, 12200, 12201, 7, 9, 0, 0, 12201, 12202, 7, 6, 0, 0, 12202, 12203, 7, 25, 0, 0, 12203, 12204, 7, 6, 0, 0, 12204, 12205, 7, 5, 0, 0, 12205, 1428, 1, 0, 0, 0, 12206, 12207, 7, 10, 0, 0, 12207, 12208, 7, 7, 0, 0, 12208, 12209, 7, 9, 0, 0, 12209, 12210, 7, 6, 0, 0, 12210, 12211, 7, 25, 0, 0, 12211, 12212, 5, 95, 0, 0, 12212, 12213, 7, 16, 0, 0, 12213, 12214, 7, 16, 0, 0, 12214, 12215, 7, 5, 0, 0, 12215, 1430, 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, 12222, 5, 95, 0, 0, 12222, 12223, 7, 16, 0, 0, 12223, 12224, 7, 10, 0, 0, 12224, 12225, 7, 11, 0, 0, 12225, 12226, 7, 4, 0, 0, 12226, 12227, 7, 6, 0, 0, 12227, 12228, 7, 3, 0, 0, 12228, 1432, 1, 0, 0, 0, 12229, 12230, 7, 10, 0, 0, 12230, 12231, 7, 7, 0, 0, 12231, 12232, 7, 9, 0, 0, 12232, 12233, 7, 6, 0, 0, 12233, 12234, 7, 25, 0, 0, 12234, 1434, 1, 0, 0, 0, 12235, 12236, 7, 10, 0, 0, 12236, 12237, 7, 7, 0, 0, 12237, 12238, 7, 9, 0, 0, 12238, 12239, 7, 6, 0, 0, 12239, 12240, 7, 25, 0, 0, 12240, 12241, 7, 10, 0, 0, 12241, 12242, 7, 7, 0, 0, 12242, 12243, 7, 17, 0, 0, 12243, 1436, 1, 0, 0, 0, 12244, 12245, 7, 10, 0, 0, 12245, 12246, 7, 7, 0, 0, 12246, 12247, 7, 9, 0, 0, 12247, 12248, 7, 6, 0, 0, 12248, 12249, 7, 25, 0, 0, 12249, 12250, 5, 95, 0, 0, 12250, 12251, 7, 20, 0, 0, 12251, 12252, 7, 2, 0, 0, 12252, 12253, 7, 10, 0, 0, 12253, 12254, 7, 7, 0, 0, 12254, 1438, 1, 0, 0, 0, 12255, 12256, 7, 10, 0, 0, 12256, 12257, 7, 7, 0, 0, 12257, 12258, 7, 9, 0, 0, 12258, 12259, 7, 6, 0, 0, 12259, 12260, 7, 25, 0, 0, 12260, 12261, 5, 95, 0, 0, 12261, 12262, 7, 3, 0, 0, 12262, 12263, 7, 2, 0, 0, 12263, 12264, 7, 22, 0, 0, 12264, 12265, 7, 5, 0, 0, 12265, 1440, 1, 0, 0, 0, 12266, 12267, 7, 10, 0, 0, 12267, 12268, 7, 7, 0, 0, 12268, 12269, 7, 9, 0, 0, 12269, 12270, 7, 6, 0, 0, 12270, 12271, 7, 25, 0, 0, 12271, 12272, 5, 95, 0, 0, 12272, 12273, 7, 3, 0, 0, 12273, 12274, 7, 3, 0, 0, 12274, 12275, 7, 5, 0, 0, 12275, 1442, 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, 0, 0, 0, 12286, 12287, 7, 5, 0, 0, 12287, 12288, 7, 8, 0, 0, 12288, 1444, 1, 0, 0, 0, 12289, 12290, 7, 10, 0, 0, 12290, 12291, 7, 7, 0, 0, 12291, 12292, 7, 9, 0, 0, 12292, 12293, 7, 6, 0, 0, 12293, 12294, 7, 25, 0, 0, 12294, 12295, 5, 95, 0, 0, 12295, 12296, 7, 3, 0, 0, 12296, 12297, 7, 5, 0, 0, 12297, 12298, 5, 95, 0, 0, 12298, 12299, 7, 9, 0, 0, 12299, 12300, 7, 6, 0, 0, 12300, 12301, 7, 5, 0, 0, 12301, 12302, 7, 8, 0, 0, 12302, 1446, 1, 0, 0, 0, 12303, 12304, 7, 10, 0, 0, 12304, 12305, 7, 7, 0, 0, 12305, 12306, 7, 9, 0, 0, 12306, 12307, 7, 6, 0, 0, 12307, 12308, 7, 25, 0, 0, 12308, 12309, 5, 95, 0, 0, 12309, 12310, 7, 3, 0, 0, 12310, 12311, 7, 5, 0, 0, 12311, 1448, 1, 0, 0, 0, 12312, 12313, 7, 10, 0, 0, 12313, 12314, 7, 7, 0, 0, 12314, 12315, 7, 9, 0, 0, 12315, 12316, 7, 6, 0, 0, 12316, 12317, 7, 25, 0, 0, 12317, 12318, 5, 95, 0, 0, 12318, 12319, 7, 5, 0, 0, 12319, 12320, 7, 8, 0, 0, 12320, 12321, 7, 0, 0, 0, 12321, 12322, 7, 7, 0, 0, 12322, 1450, 1, 0, 0, 0, 12323, 12324, 7, 10, 0, 0, 12324, 12325, 7, 7, 0, 0, 12325, 12326, 7, 9, 0, 0, 12326, 12327, 7, 6, 0, 0, 12327, 12328, 7, 25, 0, 0, 12328, 12329, 5, 95, 0, 0, 12329, 12330, 7, 5, 0, 0, 12330, 12331, 7, 21, 0, 0, 12331, 12332, 7, 10, 0, 0, 12332, 12333, 7, 15, 0, 0, 12333, 12334, 5, 95, 0, 0, 12334, 12335, 7, 5, 0, 0, 12335, 12336, 7, 8, 0, 0, 12336, 12337, 7, 0, 0, 0, 12337, 12338, 7, 7, 0, 0, 12338, 1452, 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, 0, 0, 0, 12349, 12350, 7, 5, 0, 0, 12350, 12351, 7, 8, 0, 0, 12351, 1454, 1, 0, 0, 0, 12352, 12353, 7, 10, 0, 0, 12353, 12354, 7, 7, 0, 0, 12354, 12355, 7, 9, 0, 0, 12355, 12356, 7, 6, 0, 0, 12356, 12357, 7, 25, 0, 0, 12357, 12358, 5, 95, 0, 0, 12358, 12359, 7, 5, 0, 0, 12359, 12360, 7, 5, 0, 0, 12360, 12361, 5, 95, 0, 0, 12361, 12362, 7, 9, 0, 0, 12362, 12363, 7, 6, 0, 0, 12363, 12364, 7, 5, 0, 0, 12364, 12365, 7, 8, 0, 0, 12365, 1456, 1, 0, 0, 0, 12366, 12367, 7, 10, 0, 0, 12367, 12368, 7, 7, 0, 0, 12368, 12369, 7, 9, 0, 0, 12369, 12370, 7, 6, 0, 0, 12370, 12371, 7, 25, 0, 0, 12371, 12372, 5, 95, 0, 0, 12372, 12373, 7, 5, 0, 0, 12373, 12374, 7, 5, 0, 0, 12374, 1458, 1, 0, 0, 0, 12375, 12376, 7, 10, 0, 0, 12376, 12377, 7, 7, 0, 0, 12377, 12378, 7, 9, 0, 0, 12378, 12379, 7, 6, 0, 0, 12379, 12380, 7, 25, 0, 0, 12380, 12381, 5, 95, 0, 0, 12381, 12382, 7, 5, 0, 0, 12382, 12383, 7, 4, 0, 0, 12383, 12384, 7, 0, 0, 0, 12384, 12385, 7, 4, 0, 0, 12385, 12386, 7, 5, 0, 0, 12386, 1460, 1, 0, 0, 0, 12387, 12388, 7, 10, 0, 0, 12388, 12389, 7, 7, 0, 0, 12389, 12390, 7, 9, 0, 0, 12390, 12391, 7, 6, 0, 0, 12391, 12392, 7, 25, 0, 0, 12392, 12393, 7, 4, 0, 0, 12393, 12394, 7, 18, 0, 0, 12394, 12395, 7, 15, 0, 0, 12395, 12396, 7, 6, 0, 0, 12396, 1462, 1, 0, 0, 0, 12397, 12398, 7, 10, 0, 0, 12398, 12399, 7, 7, 0, 0, 12399, 12400, 7, 9, 0, 0, 12400, 12401, 7, 6, 0, 0, 12401, 12402, 7, 25, 0, 0, 12402, 12403, 7, 4, 0, 0, 12403, 12404, 7, 18, 0, 0, 12404, 12405, 7, 15, 0, 0, 12405, 12406, 7, 6, 0, 0, 12406, 12407, 7, 5, 0, 0, 12407, 1464, 1, 0, 0, 0, 12408, 12409, 7, 10, 0, 0, 12409, 12410, 7, 7, 0, 0, 12410, 12411, 7, 9, 0, 0, 12411, 12412, 7, 10, 0, 0, 12412, 12413, 7, 8, 0, 0, 12413, 12414, 7, 0, 0, 0, 12414, 12415, 7, 4, 0, 0, 12415, 12416, 7, 2, 0, 0, 12416, 12417, 7, 3, 0, 0, 12417, 1466, 1, 0, 0, 0, 12418, 12419, 7, 10, 0, 0, 12419, 12420, 7, 7, 0, 0, 12420, 12421, 7, 9, 0, 0, 12421, 12422, 7, 10, 0, 0, 12422, 12423, 7, 8, 0, 0, 12423, 12424, 7, 6, 0, 0, 12424, 12425, 7, 5, 0, 0, 12425, 1468, 1, 0, 0, 0, 12426, 12427, 7, 10, 0, 0, 12427, 12428, 7, 7, 0, 0, 12428, 12429, 7, 16, 0, 0, 12429, 12430, 7, 10, 0, 0, 12430, 12431, 7, 7, 0, 0, 12431, 12432, 7, 10, 0, 0, 12432, 12433, 7, 4, 0, 0, 12433, 12434, 7, 6, 0, 0, 12434, 1470, 1, 0, 0, 0, 12435, 12436, 7, 10, 0, 0, 12436, 12437, 7, 7, 0, 0, 12437, 12438, 7, 16, 0, 0, 12438, 12439, 7, 2, 0, 0, 12439, 12440, 7, 3, 0, 0, 12440, 12441, 7, 14, 0, 0, 12441, 12442, 7, 0, 0, 0, 12442, 12443, 7, 4, 0, 0, 12443, 12444, 7, 10, 0, 0, 12444, 12445, 7, 2, 0, 0, 12445, 12446, 7, 7, 0, 0, 12446, 12447, 7, 0, 0, 0, 12447, 12448, 7, 11, 0, 0, 12448, 1472, 1, 0, 0, 0, 12449, 12450, 7, 10, 0, 0, 12450, 12451, 7, 7, 0, 0, 12451, 12452, 7, 19, 0, 0, 12452, 12453, 7, 6, 0, 0, 12453, 12454, 7, 3, 0, 0, 12454, 12455, 7, 10, 0, 0, 12455, 12456, 7, 4, 0, 0, 12456, 1474, 1, 0, 0, 0, 12457, 12458, 7, 10, 0, 0, 12458, 12459, 7, 7, 0, 0, 12459, 1476, 1, 0, 0, 0, 12460, 12461, 7, 10, 0, 0, 12461, 12462, 7, 7, 0, 0, 12462, 12463, 7, 10, 0, 0, 12463, 12464, 7, 4, 0, 0, 12464, 12465, 7, 8, 0, 0, 12465, 12466, 7, 0, 0, 0, 12466, 12467, 7, 15, 0, 0, 12467, 1478, 1, 0, 0, 0, 12468, 12469, 7, 10, 0, 0, 12469, 12470, 7, 7, 0, 0, 12470, 12471, 7, 10, 0, 0, 12471, 12472, 7, 4, 0, 0, 12472, 12473, 7, 10, 0, 0, 12473, 12474, 7, 0, 0, 0, 12474, 12475, 7, 11, 0, 0, 12475, 1480, 1, 0, 0, 0, 12476, 12477, 7, 10, 0, 0, 12477, 12478, 7, 7, 0, 0, 12478, 12479, 7, 10, 0, 0, 12479, 12480, 7, 4, 0, 0, 12480, 12481, 7, 10, 0, 0, 12481, 12482, 7, 0, 0, 0, 12482, 12483, 7, 11, 0, 0, 12483, 12484, 7, 10, 0, 0, 12484, 12485, 7, 23, 0, 0, 12485, 12486, 7, 6, 0, 0, 12486, 12487, 7, 9, 0, 0, 12487, 1482, 1, 0, 0, 0, 12488, 12489, 7, 10, 0, 0, 12489, 12490, 7, 7, 0, 0, 12490, 12491, 7, 10, 0, 0, 12491, 12492, 7, 4, 0, 0, 12492, 12493, 7, 10, 0, 0, 12493, 12494, 7, 0, 0, 0, 12494, 12495, 7, 11, 0, 0, 12495, 12496, 7, 11, 0, 0, 12496, 12497, 7, 18, 0, 0, 12497, 1484, 1, 0, 0, 0, 12498, 12499, 7, 10, 0, 0, 12499, 12500, 7, 7, 0, 0, 12500, 12501, 7, 10, 0, 0, 12501, 12502, 7, 4, 0, 0, 12502, 12503, 7, 3, 0, 0, 12503, 12504, 7, 0, 0, 0, 12504, 12505, 7, 7, 0, 0, 12505, 12506, 7, 5, 0, 0, 12506, 1486, 1, 0, 0, 0, 12507, 12508, 7, 10, 0, 0, 12508, 12509, 7, 7, 0, 0, 12509, 12510, 7, 11, 0, 0, 12510, 12511, 7, 10, 0, 0, 12511, 12512, 7, 7, 0, 0, 12512, 12513, 7, 6, 0, 0, 12513, 1488, 1, 0, 0, 0, 12514, 12515, 7, 10, 0, 0, 12515, 12516, 7, 7, 0, 0, 12516, 12517, 7, 11, 0, 0, 12517, 12518, 7, 10, 0, 0, 12518, 12519, 7, 7, 0, 0, 12519, 12520, 7, 6, 0, 0, 12520, 12521, 5, 95, 0, 0, 12521, 12522, 7, 25, 0, 0, 12522, 12523, 7, 14, 0, 0, 12523, 12524, 7, 11, 0, 0, 12524, 12525, 7, 4, 0, 0, 12525, 12526, 7, 18, 0, 0, 12526, 12527, 7, 15, 0, 0, 12527, 12528, 7, 6, 0, 0, 12528, 12529, 5, 95, 0, 0, 12529, 12530, 7, 7, 0, 0, 12530, 12531, 7, 4, 0, 0, 12531, 1490, 1, 0, 0, 0, 12532, 12533, 7, 10, 0, 0, 12533, 12534, 7, 7, 0, 0, 12534, 12535, 7, 14, 0, 0, 12535, 12536, 7, 6, 0, 0, 12536, 12537, 7, 14, 0, 0, 12537, 12538, 7, 2, 0, 0, 12538, 12539, 7, 3, 0, 0, 12539, 12540, 7, 18, 0, 0, 12540, 1492, 1, 0, 0, 0, 12541, 12542, 7, 10, 0, 0, 12542, 12543, 7, 7, 0, 0, 12543, 12544, 5, 95, 0, 0, 12544, 12545, 7, 14, 0, 0, 12545, 12546, 7, 6, 0, 0, 12546, 12547, 7, 14, 0, 0, 12547, 12548, 7, 2, 0, 0, 12548, 12549, 7, 3, 0, 0, 12549, 12550, 7, 18, 0, 0, 12550, 12551, 5, 95, 0, 0, 12551, 12552, 7, 14, 0, 0, 12552, 12553, 7, 6, 0, 0, 12553, 12554, 7, 4, 0, 0, 12554, 12555, 7, 0, 0, 0, 12555, 12556, 7, 9, 0, 0, 12556, 12557, 7, 0, 0, 0, 12557, 12558, 7, 4, 0, 0, 12558, 12559, 7, 0, 0, 0, 12559, 1494, 1, 0, 0, 0, 12560, 12561, 7, 10, 0, 0, 12561, 12562, 7, 7, 0, 0, 12562, 12563, 7, 14, 0, 0, 12563, 12564, 7, 6, 0, 0, 12564, 12565, 7, 14, 0, 0, 12565, 12566, 7, 2, 0, 0, 12566, 12567, 7, 3, 0, 0, 12567, 12568, 7, 18, 0, 0, 12568, 12569, 5, 95, 0, 0, 12569, 12570, 7, 15, 0, 0, 12570, 12571, 7, 3, 0, 0, 12571, 12572, 7, 12, 0, 0, 12572, 12573, 7, 7, 0, 0, 12573, 12574, 7, 10, 0, 0, 12574, 12575, 7, 7, 0, 0, 12575, 12576, 7, 17, 0, 0, 12576, 1496, 1, 0, 0, 0, 12577, 12578, 7, 10, 0, 0, 12578, 12579, 7, 7, 0, 0, 12579, 12580, 7, 7, 0, 0, 12580, 12581, 7, 6, 0, 0, 12581, 12582, 7, 3, 0, 0, 12582, 1498, 1, 0, 0, 0, 12583, 12584, 7, 10, 0, 0, 12584, 12585, 7, 7, 0, 0, 12585, 12586, 7, 2, 0, 0, 12586, 12587, 7, 12, 0, 0, 12587, 12588, 7, 4, 0, 0, 12588, 1500, 1, 0, 0, 0, 12589, 12590, 7, 10, 0, 0, 12590, 12591, 7, 7, 0, 0, 12591, 12592, 7, 15, 0, 0, 12592, 12593, 7, 11, 0, 0, 12593, 12594, 7, 0, 0, 0, 12594, 12595, 7, 8, 0, 0, 12595, 12596, 7, 6, 0, 0, 12596, 1502, 1, 0, 0, 0, 12597, 12598, 7, 10, 0, 0, 12598, 12599, 7, 7, 0, 0, 12599, 12600, 7, 15, 0, 0, 12600, 12601, 7, 12, 0, 0, 12601, 12602, 7, 4, 0, 0, 12602, 12603, 7, 16, 0, 0, 12603, 12604, 7, 2, 0, 0, 12604, 12605, 7, 3, 0, 0, 12605, 12606, 7, 14, 0, 0, 12606, 12607, 7, 0, 0, 0, 12607, 12608, 7, 4, 0, 0, 12608, 1504, 1, 0, 0, 0, 12609, 12610, 7, 10, 0, 0, 12610, 12611, 7, 7, 0, 0, 12611, 12612, 7, 5, 0, 0, 12612, 12613, 7, 6, 0, 0, 12613, 12614, 7, 3, 0, 0, 12614, 12615, 7, 4, 0, 0, 12615, 12616, 7, 8, 0, 0, 12616, 12617, 7, 19, 0, 0, 12617, 12618, 7, 10, 0, 0, 12618, 12619, 7, 11, 0, 0, 12619, 12620, 7, 9, 0, 0, 12620, 12621, 7, 25, 0, 0, 12621, 12622, 7, 14, 0, 0, 12622, 12623, 7, 11, 0, 0, 12623, 12624, 7, 0, 0, 0, 12624, 12625, 7, 16, 0, 0, 12625, 12626, 7, 4, 0, 0, 12626, 12627, 7, 6, 0, 0, 12627, 12628, 7, 3, 0, 0, 12628, 1506, 1, 0, 0, 0, 12629, 12630, 7, 10, 0, 0, 12630, 12631, 7, 7, 0, 0, 12631, 12632, 7, 5, 0, 0, 12632, 12633, 7, 6, 0, 0, 12633, 12634, 7, 3, 0, 0, 12634, 12635, 7, 4, 0, 0, 12635, 12636, 7, 8, 0, 0, 12636, 12637, 7, 19, 0, 0, 12637, 12638, 7, 10, 0, 0, 12638, 12639, 7, 11, 0, 0, 12639, 12640, 7, 9, 0, 0, 12640, 12641, 7, 25, 0, 0, 12641, 12642, 7, 14, 0, 0, 12642, 12643, 7, 11, 0, 0, 12643, 12644, 7, 1, 0, 0, 12644, 12645, 7, 6, 0, 0, 12645, 12646, 7, 16, 0, 0, 12646, 12647, 7, 2, 0, 0, 12647, 12648, 7, 3, 0, 0, 12648, 12649, 7, 6, 0, 0, 12649, 1508, 1, 0, 0, 0, 12650, 12651, 7, 10, 0, 0, 12651, 12652, 7, 7, 0, 0, 12652, 12653, 7, 5, 0, 0, 12653, 12654, 7, 6, 0, 0, 12654, 12655, 7, 3, 0, 0, 12655, 12656, 7, 4, 0, 0, 12656, 12657, 7, 8, 0, 0, 12657, 12658, 7, 19, 0, 0, 12658, 12659, 7, 10, 0, 0, 12659, 12660, 7, 11, 0, 0, 12660, 12661, 7, 9, 0, 0, 12661, 12662, 7, 25, 0, 0, 12662, 12663, 7, 14, 0, 0, 12663, 12664, 7, 11, 0, 0, 12664, 1510, 1, 0, 0, 0, 12665, 12666, 7, 10, 0, 0, 12666, 12667, 7, 7, 0, 0, 12667, 12668, 7, 5, 0, 0, 12668, 12669, 7, 6, 0, 0, 12669, 12670, 7, 3, 0, 0, 12670, 12671, 7, 4, 0, 0, 12671, 1512, 1, 0, 0, 0, 12672, 12673, 7, 10, 0, 0, 12673, 12674, 7, 7, 0, 0, 12674, 12675, 7, 5, 0, 0, 12675, 12676, 7, 6, 0, 0, 12676, 12677, 7, 3, 0, 0, 12677, 12678, 7, 4, 0, 0, 12678, 12679, 7, 25, 0, 0, 12679, 12680, 7, 14, 0, 0, 12680, 12681, 7, 11, 0, 0, 12681, 12682, 7, 0, 0, 0, 12682, 12683, 7, 16, 0, 0, 12683, 12684, 7, 4, 0, 0, 12684, 12685, 7, 6, 0, 0, 12685, 12686, 7, 3, 0, 0, 12686, 1514, 1, 0, 0, 0, 12687, 12688, 7, 10, 0, 0, 12688, 12689, 7, 7, 0, 0, 12689, 12690, 7, 5, 0, 0, 12690, 12691, 7, 6, 0, 0, 12691, 12692, 7, 3, 0, 0, 12692, 12693, 7, 4, 0, 0, 12693, 12694, 7, 25, 0, 0, 12694, 12695, 7, 14, 0, 0, 12695, 12696, 7, 11, 0, 0, 12696, 12697, 7, 1, 0, 0, 12697, 12698, 7, 6, 0, 0, 12698, 12699, 7, 16, 0, 0, 12699, 12700, 7, 2, 0, 0, 12700, 12701, 7, 3, 0, 0, 12701, 12702, 7, 6, 0, 0, 12702, 1516, 1, 0, 0, 0, 12703, 12704, 7, 10, 0, 0, 12704, 12705, 7, 7, 0, 0, 12705, 12706, 7, 5, 0, 0, 12706, 12707, 7, 4, 0, 0, 12707, 12708, 7, 0, 0, 0, 12708, 12709, 7, 7, 0, 0, 12709, 12710, 7, 8, 0, 0, 12710, 12711, 7, 6, 0, 0, 12711, 1518, 1, 0, 0, 0, 12712, 12713, 7, 10, 0, 0, 12713, 12714, 7, 7, 0, 0, 12714, 12715, 7, 5, 0, 0, 12715, 12716, 7, 4, 0, 0, 12716, 12717, 7, 0, 0, 0, 12717, 12718, 7, 7, 0, 0, 12718, 12719, 7, 8, 0, 0, 12719, 12720, 7, 6, 0, 0, 12720, 12721, 7, 5, 0, 0, 12721, 1520, 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, 10, 0, 0, 12730, 12731, 7, 0, 0, 0, 12731, 12732, 7, 1, 0, 0, 12732, 12733, 7, 11, 0, 0, 12733, 12734, 7, 6, 0, 0, 12734, 1522, 1, 0, 0, 0, 12735, 12736, 7, 10, 0, 0, 12736, 12737, 7, 7, 0, 0, 12737, 12738, 7, 5, 0, 0, 12738, 12739, 7, 4, 0, 0, 12739, 12740, 7, 0, 0, 0, 12740, 12741, 7, 7, 0, 0, 12741, 12742, 7, 4, 0, 0, 12742, 12743, 7, 11, 0, 0, 12743, 12744, 7, 18, 0, 0, 12744, 1524, 1, 0, 0, 0, 12745, 12746, 7, 10, 0, 0, 12746, 12747, 7, 7, 0, 0, 12747, 12748, 7, 5, 0, 0, 12748, 12749, 7, 4, 0, 0, 12749, 12750, 7, 6, 0, 0, 12750, 12751, 7, 0, 0, 0, 12751, 12752, 7, 9, 0, 0, 12752, 1526, 1, 0, 0, 0, 12753, 12754, 7, 10, 0, 0, 12754, 12755, 7, 7, 0, 0, 12755, 12756, 7, 5, 0, 0, 12756, 12757, 7, 4, 0, 0, 12757, 12758, 7, 3, 0, 0, 12758, 12759, 5, 50, 0, 0, 12759, 1528, 1, 0, 0, 0, 12760, 12761, 7, 10, 0, 0, 12761, 12762, 7, 7, 0, 0, 12762, 12763, 7, 5, 0, 0, 12763, 12764, 7, 4, 0, 0, 12764, 12765, 7, 3, 0, 0, 12765, 12766, 5, 52, 0, 0, 12766, 1530, 1, 0, 0, 0, 12767, 12768, 7, 10, 0, 0, 12768, 12769, 7, 7, 0, 0, 12769, 12770, 7, 5, 0, 0, 12770, 12771, 7, 4, 0, 0, 12771, 12772, 7, 3, 0, 0, 12772, 12773, 7, 1, 0, 0, 12773, 1532, 1, 0, 0, 0, 12774, 12775, 7, 10, 0, 0, 12775, 12776, 7, 7, 0, 0, 12776, 12777, 7, 5, 0, 0, 12777, 12778, 7, 4, 0, 0, 12778, 12779, 7, 3, 0, 0, 12779, 12780, 7, 8, 0, 0, 12780, 1534, 1, 0, 0, 0, 12781, 12782, 7, 10, 0, 0, 12782, 12783, 7, 7, 0, 0, 12783, 12784, 7, 5, 0, 0, 12784, 12785, 7, 4, 0, 0, 12785, 12786, 7, 3, 0, 0, 12786, 1536, 1, 0, 0, 0, 12787, 12788, 7, 10, 0, 0, 12788, 12789, 7, 7, 0, 0, 12789, 12790, 7, 4, 0, 0, 12790, 12791, 7, 6, 0, 0, 12791, 12792, 7, 17, 0, 0, 12792, 12793, 7, 6, 0, 0, 12793, 12794, 7, 3, 0, 0, 12794, 1538, 1, 0, 0, 0, 12795, 12796, 7, 10, 0, 0, 12796, 12797, 7, 7, 0, 0, 12797, 12798, 7, 4, 0, 0, 12798, 12799, 7, 6, 0, 0, 12799, 12800, 7, 3, 0, 0, 12800, 12801, 7, 11, 0, 0, 12801, 12802, 7, 6, 0, 0, 12802, 12803, 7, 0, 0, 0, 12803, 12804, 7, 13, 0, 0, 12804, 12805, 7, 6, 0, 0, 12805, 12806, 7, 9, 0, 0, 12806, 1540, 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, 14, 0, 0, 12813, 12814, 7, 6, 0, 0, 12814, 12815, 7, 9, 0, 0, 12815, 12816, 7, 10, 0, 0, 12816, 12817, 7, 0, 0, 0, 12817, 12818, 7, 4, 0, 0, 12818, 12819, 7, 6, 0, 0, 12819, 1542, 1, 0, 0, 0, 12820, 12821, 7, 10, 0, 0, 12821, 12822, 7, 7, 0, 0, 12822, 12823, 7, 4, 0, 0, 12823, 12824, 7, 6, 0, 0, 12824, 12825, 7, 3, 0, 0, 12825, 12826, 7, 7, 0, 0, 12826, 12827, 7, 0, 0, 0, 12827, 12828, 7, 11, 0, 0, 12828, 12829, 5, 95, 0, 0, 12829, 12830, 7, 8, 0, 0, 12830, 12831, 7, 2, 0, 0, 12831, 12832, 7, 7, 0, 0, 12832, 12833, 7, 13, 0, 0, 12833, 12834, 7, 6, 0, 0, 12834, 12835, 7, 3, 0, 0, 12835, 12836, 7, 4, 0, 0, 12836, 1544, 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, 7, 0, 0, 12843, 12844, 7, 0, 0, 0, 12844, 12845, 7, 11, 0, 0, 12845, 12846, 5, 95, 0, 0, 12846, 12847, 7, 12, 0, 0, 12847, 12848, 7, 5, 0, 0, 12848, 12849, 7, 6, 0, 0, 12849, 1546, 1, 0, 0, 0, 12850, 12851, 7, 10, 0, 0, 12851, 12852, 7, 7, 0, 0, 12852, 12853, 7, 4, 0, 0, 12853, 12854, 7, 6, 0, 0, 12854, 12855, 7, 3, 0, 0, 12855, 12856, 7, 15, 0, 0, 12856, 12857, 7, 3, 0, 0, 12857, 12858, 7, 6, 0, 0, 12858, 12859, 7, 4, 0, 0, 12859, 12860, 7, 6, 0, 0, 12860, 12861, 7, 9, 0, 0, 12861, 1548, 1, 0, 0, 0, 12862, 12863, 7, 10, 0, 0, 12863, 12864, 7, 7, 0, 0, 12864, 12865, 7, 4, 0, 0, 12865, 12866, 7, 6, 0, 0, 12866, 12867, 7, 3, 0, 0, 12867, 12868, 7, 5, 0, 0, 12868, 12869, 7, 6, 0, 0, 12869, 12870, 7, 8, 0, 0, 12870, 12871, 7, 4, 0, 0, 12871, 1550, 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, 13, 0, 0, 12878, 12879, 7, 0, 0, 0, 12879, 12880, 7, 11, 0, 0, 12880, 1552, 1, 0, 0, 0, 12881, 12882, 7, 10, 0, 0, 12882, 12883, 7, 7, 0, 0, 12883, 12884, 7, 4, 0, 0, 12884, 1554, 1, 0, 0, 0, 12885, 12886, 7, 10, 0, 0, 12886, 12887, 7, 7, 0, 0, 12887, 12888, 7, 4, 0, 0, 12888, 12889, 7, 6, 0, 0, 12889, 12890, 7, 3, 0, 0, 12890, 12891, 7, 7, 0, 0, 12891, 12892, 7, 0, 0, 0, 12892, 12893, 7, 11, 0, 0, 12893, 1556, 1, 0, 0, 0, 12894, 12895, 7, 10, 0, 0, 12895, 12896, 7, 7, 0, 0, 12896, 12897, 7, 4, 0, 0, 12897, 12898, 7, 2, 0, 0, 12898, 1558, 1, 0, 0, 0, 12899, 12900, 7, 10, 0, 0, 12900, 12901, 7, 7, 0, 0, 12901, 12902, 7, 13, 0, 0, 12902, 12903, 7, 0, 0, 0, 12903, 12904, 7, 11, 0, 0, 12904, 12905, 7, 10, 0, 0, 12905, 12906, 7, 9, 0, 0, 12906, 12907, 7, 0, 0, 0, 12907, 12908, 7, 4, 0, 0, 12908, 12909, 7, 6, 0, 0, 12909, 1560, 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, 0, 0, 0, 12914, 12915, 7, 11, 0, 0, 12915, 12916, 7, 10, 0, 0, 12916, 12917, 7, 9, 0, 0, 12917, 12918, 7, 0, 0, 0, 12918, 12919, 7, 4, 0, 0, 12919, 12920, 7, 10, 0, 0, 12920, 12921, 7, 2, 0, 0, 12921, 12922, 7, 7, 0, 0, 12922, 1562, 1, 0, 0, 0, 12923, 12924, 7, 10, 0, 0, 12924, 12925, 7, 7, 0, 0, 12925, 12926, 7, 13, 0, 0, 12926, 12927, 7, 10, 0, 0, 12927, 12928, 7, 5, 0, 0, 12928, 12929, 7, 10, 0, 0, 12929, 12930, 7, 1, 0, 0, 12930, 12931, 7, 11, 0, 0, 12931, 12932, 7, 6, 0, 0, 12932, 1564, 1, 0, 0, 0, 12933, 12934, 7, 10, 0, 0, 12934, 12935, 7, 7, 0, 0, 12935, 12936, 5, 95, 0, 0, 12936, 12937, 7, 25, 0, 0, 12937, 12938, 7, 24, 0, 0, 12938, 12939, 7, 12, 0, 0, 12939, 12940, 7, 6, 0, 0, 12940, 12941, 7, 3, 0, 0, 12941, 12942, 7, 18, 0, 0, 12942, 1566, 1, 0, 0, 0, 12943, 12944, 7, 10, 0, 0, 12944, 12945, 7, 2, 0, 0, 12945, 12946, 5, 95, 0, 0, 12946, 12947, 7, 2, 0, 0, 12947, 12948, 7, 15, 0, 0, 12948, 12949, 7, 4, 0, 0, 12949, 12950, 7, 10, 0, 0, 12950, 12951, 7, 2, 0, 0, 12951, 12952, 7, 7, 0, 0, 12952, 12953, 7, 5, 0, 0, 12953, 1568, 1, 0, 0, 0, 12954, 12955, 7, 10, 0, 0, 12955, 12956, 7, 5, 0, 0, 12956, 1570, 1, 0, 0, 0, 12957, 12958, 7, 10, 0, 0, 12958, 12959, 7, 5, 0, 0, 12959, 12960, 5, 95, 0, 0, 12960, 12961, 7, 11, 0, 0, 12961, 12962, 7, 6, 0, 0, 12962, 12963, 7, 0, 0, 0, 12963, 12964, 7, 16, 0, 0, 12964, 1572, 1, 0, 0, 0, 12965, 12966, 7, 10, 0, 0, 12966, 12967, 7, 5, 0, 0, 12967, 12968, 7, 2, 0, 0, 12968, 12969, 7, 11, 0, 0, 12969, 12970, 7, 0, 0, 0, 12970, 12971, 7, 4, 0, 0, 12971, 12972, 7, 10, 0, 0, 12972, 12973, 7, 2, 0, 0, 12973, 12974, 7, 7, 0, 0, 12974, 1574, 1, 0, 0, 0, 12975, 12976, 7, 10, 0, 0, 12976, 12977, 7, 5, 0, 0, 12977, 12978, 7, 2, 0, 0, 12978, 12979, 7, 11, 0, 0, 12979, 12980, 7, 0, 0, 0, 12980, 12981, 7, 4, 0, 0, 12981, 12982, 7, 10, 0, 0, 12982, 12983, 7, 2, 0, 0, 12983, 12984, 7, 7, 0, 0, 12984, 12985, 5, 95, 0, 0, 12985, 12986, 7, 11, 0, 0, 12986, 12987, 7, 6, 0, 0, 12987, 12988, 7, 13, 0, 0, 12988, 12989, 7, 6, 0, 0, 12989, 12990, 7, 11, 0, 0, 12990, 1576, 1, 0, 0, 0, 12991, 12992, 7, 10, 0, 0, 12992, 12993, 7, 4, 0, 0, 12993, 12994, 7, 6, 0, 0, 12994, 12995, 7, 14, 0, 0, 12995, 12996, 7, 5, 0, 0, 12996, 1578, 1, 0, 0, 0, 12997, 12998, 7, 10, 0, 0, 12998, 12999, 7, 4, 0, 0, 12999, 13000, 7, 6, 0, 0, 13000, 13001, 7, 3, 0, 0, 13001, 13002, 7, 0, 0, 0, 13002, 13003, 7, 4, 0, 0, 13003, 13004, 7, 6, 0, 0, 13004, 1580, 1, 0, 0, 0, 13005, 13006, 7, 10, 0, 0, 13006, 13007, 7, 4, 0, 0, 13007, 13008, 7, 6, 0, 0, 13008, 13009, 7, 3, 0, 0, 13009, 13010, 7, 0, 0, 0, 13010, 13011, 7, 4, 0, 0, 13011, 13012, 7, 10, 0, 0, 13012, 13013, 7, 2, 0, 0, 13013, 13014, 7, 7, 0, 0, 13014, 13015, 5, 95, 0, 0, 13015, 13016, 7, 7, 0, 0, 13016, 13017, 7, 12, 0, 0, 13017, 13018, 7, 14, 0, 0, 13018, 13019, 7, 1, 0, 0, 13019, 13020, 7, 6, 0, 0, 13020, 13021, 7, 3, 0, 0, 13021, 1582, 1, 0, 0, 0, 13022, 13023, 7, 20, 0, 0, 13023, 13024, 7, 0, 0, 0, 13024, 13025, 7, 13, 0, 0, 13025, 13026, 7, 0, 0, 0, 13026, 1584, 1, 0, 0, 0, 13027, 13028, 7, 20, 0, 0, 13028, 13029, 7, 2, 0, 0, 13029, 13030, 7, 1, 0, 0, 13030, 1586, 1, 0, 0, 0, 13031, 13032, 7, 20, 0, 0, 13032, 13033, 7, 2, 0, 0, 13033, 13034, 7, 10, 0, 0, 13034, 13035, 7, 7, 0, 0, 13035, 1588, 1, 0, 0, 0, 13036, 13037, 7, 20, 0, 0, 13037, 13038, 7, 5, 0, 0, 13038, 13039, 7, 2, 0, 0, 13039, 13040, 7, 7, 0, 0, 13040, 13041, 5, 95, 0, 0, 13041, 13042, 7, 0, 0, 0, 13042, 13043, 7, 3, 0, 0, 13043, 13044, 7, 3, 0, 0, 13044, 13045, 7, 0, 0, 0, 13045, 13046, 7, 18, 0, 0, 13046, 13047, 7, 0, 0, 0, 13047, 13048, 7, 17, 0, 0, 13048, 13049, 7, 17, 0, 0, 13049, 1590, 1, 0, 0, 0, 13050, 13051, 7, 20, 0, 0, 13051, 13052, 7, 5, 0, 0, 13052, 13053, 7, 2, 0, 0, 13053, 13054, 7, 7, 0, 0, 13054, 13055, 5, 95, 0, 0, 13055, 13056, 7, 0, 0, 0, 13056, 13057, 7, 3, 0, 0, 13057, 13058, 7, 3, 0, 0, 13058, 13059, 7, 0, 0, 0, 13059, 13060, 7, 18, 0, 0, 13060, 1592, 1, 0, 0, 0, 13061, 13062, 7, 20, 0, 0, 13062, 13063, 7, 5, 0, 0, 13063, 13064, 7, 2, 0, 0, 13064, 13065, 7, 7, 0, 0, 13065, 13066, 5, 95, 0, 0, 13066, 13067, 7, 6, 0, 0, 13067, 13068, 7, 24, 0, 0, 13068, 13069, 7, 12, 0, 0, 13069, 13070, 7, 0, 0, 0, 13070, 13071, 7, 11, 0, 0, 13071, 1594, 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, 13084, 5, 50, 0, 0, 13084, 1596, 1, 0, 0, 0, 13085, 13086, 7, 20, 0, 0, 13086, 13087, 7, 5, 0, 0, 13087, 13088, 7, 2, 0, 0, 13088, 13089, 7, 7, 0, 0, 13089, 13090, 5, 95, 0, 0, 13090, 13091, 7, 6, 0, 0, 13091, 13092, 7, 25, 0, 0, 13092, 13093, 7, 10, 0, 0, 13093, 13094, 7, 5, 0, 0, 13094, 13095, 7, 4, 0, 0, 13095, 13096, 7, 5, 0, 0, 13096, 1598, 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, 7, 17, 0, 0, 13102, 13103, 7, 6, 0, 0, 13103, 13104, 7, 4, 0, 0, 13104, 1600, 1, 0, 0, 0, 13105, 13106, 7, 20, 0, 0, 13106, 13107, 7, 5, 0, 0, 13107, 13108, 7, 2, 0, 0, 13108, 13109, 7, 7, 0, 0, 13109, 1602, 1, 0, 0, 0, 13110, 13111, 7, 20, 0, 0, 13111, 13112, 7, 5, 0, 0, 13112, 13113, 7, 2, 0, 0, 13113, 13114, 7, 7, 0, 0, 13114, 13115, 5, 95, 0, 0, 13115, 13116, 7, 2, 0, 0, 13116, 13117, 7, 1, 0, 0, 13117, 13118, 7, 20, 0, 0, 13118, 13119, 7, 6, 0, 0, 13119, 13120, 7, 8, 0, 0, 13120, 13121, 7, 4, 0, 0, 13121, 13122, 7, 0, 0, 0, 13122, 13123, 7, 17, 0, 0, 13123, 13124, 7, 17, 0, 0, 13124, 1604, 1, 0, 0, 0, 13125, 13126, 7, 20, 0, 0, 13126, 13127, 7, 5, 0, 0, 13127, 13128, 7, 2, 0, 0, 13128, 13129, 7, 7, 0, 0, 13129, 13130, 5, 95, 0, 0, 13130, 13131, 7, 2, 0, 0, 13131, 13132, 7, 1, 0, 0, 13132, 13133, 7, 20, 0, 0, 13133, 13134, 7, 6, 0, 0, 13134, 13135, 7, 8, 0, 0, 13135, 13136, 7, 4, 0, 0, 13136, 1606, 1, 0, 0, 0, 13137, 13138, 7, 20, 0, 0, 13138, 13139, 7, 5, 0, 0, 13139, 13140, 7, 2, 0, 0, 13140, 13141, 7, 7, 0, 0, 13141, 13142, 7, 15, 0, 0, 13142, 13143, 7, 0, 0, 0, 13143, 13144, 7, 3, 0, 0, 13144, 13145, 7, 5, 0, 0, 13145, 13146, 7, 6, 0, 0, 13146, 1608, 1, 0, 0, 0, 13147, 13148, 7, 20, 0, 0, 13148, 13149, 7, 5, 0, 0, 13149, 13150, 7, 2, 0, 0, 13150, 13151, 7, 7, 0, 0, 13151, 13152, 5, 95, 0, 0, 13152, 13153, 7, 24, 0, 0, 13153, 13154, 7, 12, 0, 0, 13154, 13155, 7, 6, 0, 0, 13155, 13156, 7, 3, 0, 0, 13156, 13157, 7, 18, 0, 0, 13157, 1610, 1, 0, 0, 0, 13158, 13159, 7, 20, 0, 0, 13159, 13160, 7, 5, 0, 0, 13160, 13161, 7, 2, 0, 0, 13161, 13162, 7, 7, 0, 0, 13162, 13163, 5, 95, 0, 0, 13163, 13164, 7, 5, 0, 0, 13164, 13165, 7, 6, 0, 0, 13165, 13166, 7, 3, 0, 0, 13166, 13167, 7, 10, 0, 0, 13167, 13168, 7, 0, 0, 0, 13168, 13169, 7, 11, 0, 0, 13169, 13170, 7, 10, 0, 0, 13170, 13171, 7, 23, 0, 0, 13171, 13172, 7, 6, 0, 0, 13172, 1612, 1, 0, 0, 0, 13173, 13174, 7, 20, 0, 0, 13174, 13175, 7, 5, 0, 0, 13175, 13176, 7, 2, 0, 0, 13176, 13177, 7, 7, 0, 0, 13177, 13178, 5, 95, 0, 0, 13178, 13179, 7, 4, 0, 0, 13179, 13180, 7, 0, 0, 0, 13180, 13181, 7, 1, 0, 0, 13181, 13182, 7, 11, 0, 0, 13182, 13183, 7, 6, 0, 0, 13183, 1614, 1, 0, 0, 0, 13184, 13185, 7, 20, 0, 0, 13185, 13186, 7, 5, 0, 0, 13186, 13187, 7, 2, 0, 0, 13187, 13188, 7, 7, 0, 0, 13188, 13189, 5, 95, 0, 0, 13189, 13190, 7, 4, 0, 0, 13190, 13191, 7, 6, 0, 0, 13191, 13192, 7, 25, 0, 0, 13192, 13193, 7, 4, 0, 0, 13193, 13194, 7, 8, 0, 0, 13194, 13195, 7, 2, 0, 0, 13195, 13196, 7, 7, 0, 0, 13196, 13197, 7, 4, 0, 0, 13197, 13198, 7, 0, 0, 0, 13198, 13199, 7, 10, 0, 0, 13199, 13200, 7, 7, 0, 0, 13200, 13201, 7, 5, 0, 0, 13201, 13202, 5, 50, 0, 0, 13202, 1616, 1, 0, 0, 0, 13203, 13204, 7, 20, 0, 0, 13204, 13205, 7, 5, 0, 0, 13205, 13206, 7, 2, 0, 0, 13206, 13207, 7, 7, 0, 0, 13207, 13208, 5, 95, 0, 0, 13208, 13209, 7, 4, 0, 0, 13209, 13210, 7, 6, 0, 0, 13210, 13211, 7, 25, 0, 0, 13211, 13212, 7, 4, 0, 0, 13212, 13213, 7, 8, 0, 0, 13213, 13214, 7, 2, 0, 0, 13214, 13215, 7, 7, 0, 0, 13215, 13216, 7, 4, 0, 0, 13216, 13217, 7, 0, 0, 0, 13217, 13218, 7, 10, 0, 0, 13218, 13219, 7, 7, 0, 0, 13219, 13220, 7, 5, 0, 0, 13220, 1618, 1, 0, 0, 0, 13221, 13222, 7, 20, 0, 0, 13222, 13223, 7, 5, 0, 0, 13223, 13224, 7, 2, 0, 0, 13224, 13225, 7, 7, 0, 0, 13225, 13226, 5, 95, 0, 0, 13226, 13227, 7, 4, 0, 0, 13227, 13228, 7, 3, 0, 0, 13228, 13229, 7, 0, 0, 0, 13229, 13230, 7, 7, 0, 0, 13230, 13231, 7, 5, 0, 0, 13231, 13232, 7, 16, 0, 0, 13232, 13233, 7, 2, 0, 0, 13233, 13234, 7, 3, 0, 0, 13234, 13235, 7, 14, 0, 0, 13235, 1620, 1, 0, 0, 0, 13236, 13237, 7, 20, 0, 0, 13237, 13238, 7, 5, 0, 0, 13238, 13239, 7, 2, 0, 0, 13239, 13240, 7, 7, 0, 0, 13240, 13241, 5, 95, 0, 0, 13241, 13242, 7, 13, 0, 0, 13242, 13243, 7, 0, 0, 0, 13243, 13244, 7, 11, 0, 0, 13244, 13245, 7, 12, 0, 0, 13245, 13246, 7, 6, 0, 0, 13246, 1622, 1, 0, 0, 0, 13247, 13248, 7, 21, 0, 0, 13248, 1624, 1, 0, 0, 0, 13249, 13250, 7, 21, 0, 0, 13250, 13251, 7, 6, 0, 0, 13251, 13252, 7, 6, 0, 0, 13252, 13253, 7, 15, 0, 0, 13253, 13254, 5, 95, 0, 0, 13254, 13255, 7, 9, 0, 0, 13255, 13256, 7, 12, 0, 0, 13256, 13257, 7, 15, 0, 0, 13257, 13258, 7, 11, 0, 0, 13258, 13259, 7, 10, 0, 0, 13259, 13260, 7, 8, 0, 0, 13260, 13261, 7, 0, 0, 0, 13261, 13262, 7, 4, 0, 0, 13262, 13263, 7, 6, 0, 0, 13263, 13264, 7, 5, 0, 0, 13264, 1626, 1, 0, 0, 0, 13265, 13266, 7, 21, 0, 0, 13266, 13267, 7, 6, 0, 0, 13267, 13268, 7, 6, 0, 0, 13268, 13269, 7, 15, 0, 0, 13269, 1628, 1, 0, 0, 0, 13270, 13271, 7, 21, 0, 0, 13271, 13272, 7, 6, 0, 0, 13272, 13273, 7, 3, 0, 0, 13273, 13274, 7, 1, 0, 0, 13274, 13275, 7, 6, 0, 0, 13275, 13276, 7, 3, 0, 0, 13276, 13277, 7, 2, 0, 0, 13277, 13278, 7, 5, 0, 0, 13278, 1630, 1, 0, 0, 0, 13279, 13280, 7, 21, 0, 0, 13280, 13281, 7, 6, 0, 0, 13281, 13282, 7, 18, 0, 0, 13282, 1632, 1, 0, 0, 0, 13283, 13284, 7, 21, 0, 0, 13284, 13285, 7, 6, 0, 0, 13285, 13286, 7, 18, 0, 0, 13286, 13287, 5, 95, 0, 0, 13287, 13288, 7, 11, 0, 0, 13288, 13289, 7, 6, 0, 0, 13289, 13290, 7, 7, 0, 0, 13290, 13291, 7, 17, 0, 0, 13291, 13292, 7, 4, 0, 0, 13292, 13293, 7, 19, 0, 0, 13293, 1634, 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, 10, 0, 0, 13299, 13300, 7, 23, 0, 0, 13300, 13301, 7, 6, 0, 0, 13301, 1636, 1, 0, 0, 0, 13302, 13303, 7, 21, 0, 0, 13303, 13304, 7, 6, 0, 0, 13304, 13305, 7, 18, 0, 0, 13305, 13306, 7, 5, 0, 0, 13306, 1638, 1, 0, 0, 0, 13307, 13308, 7, 21, 0, 0, 13308, 13309, 7, 6, 0, 0, 13309, 13310, 7, 18, 0, 0, 13310, 13311, 7, 5, 0, 0, 13311, 13312, 7, 4, 0, 0, 13312, 13313, 7, 2, 0, 0, 13313, 13314, 7, 3, 0, 0, 13314, 13315, 7, 6, 0, 0, 13315, 1640, 1, 0, 0, 0, 13316, 13317, 7, 21, 0, 0, 13317, 13318, 7, 10, 0, 0, 13318, 13319, 7, 11, 0, 0, 13319, 13320, 7, 11, 0, 0, 13320, 1642, 1, 0, 0, 0, 13321, 13322, 7, 11, 0, 0, 13322, 13323, 7, 0, 0, 0, 13323, 13324, 7, 1, 0, 0, 13324, 13325, 7, 6, 0, 0, 13325, 13326, 7, 11, 0, 0, 13326, 1644, 1, 0, 0, 0, 13327, 13328, 7, 11, 0, 0, 13328, 13329, 7, 0, 0, 0, 13329, 13330, 7, 7, 0, 0, 13330, 13331, 7, 17, 0, 0, 13331, 13332, 7, 12, 0, 0, 13332, 13333, 7, 0, 0, 0, 13333, 13334, 7, 17, 0, 0, 13334, 13335, 7, 6, 0, 0, 13335, 1646, 1, 0, 0, 0, 13336, 13337, 7, 11, 0, 0, 13337, 13338, 7, 0, 0, 0, 13338, 13339, 7, 5, 0, 0, 13339, 13340, 7, 4, 0, 0, 13340, 13341, 5, 95, 0, 0, 13341, 13342, 7, 9, 0, 0, 13342, 13343, 7, 0, 0, 0, 13343, 13344, 7, 18, 0, 0, 13344, 1648, 1, 0, 0, 0, 13345, 13346, 7, 11, 0, 0, 13346, 13347, 7, 0, 0, 0, 13347, 13348, 7, 5, 0, 0, 13348, 13349, 7, 4, 0, 0, 13349, 1650, 1, 0, 0, 0, 13350, 13351, 7, 11, 0, 0, 13351, 13352, 7, 0, 0, 0, 13352, 13353, 7, 5, 0, 0, 13353, 13354, 7, 4, 0, 0, 13354, 13355, 5, 95, 0, 0, 13355, 13356, 7, 13, 0, 0, 13356, 13357, 7, 0, 0, 0, 13357, 13358, 7, 11, 0, 0, 13358, 13359, 7, 12, 0, 0, 13359, 13360, 7, 6, 0, 0, 13360, 1652, 1, 0, 0, 0, 13361, 13362, 7, 11, 0, 0, 13362, 13363, 7, 0, 0, 0, 13363, 13364, 7, 4, 0, 0, 13364, 13365, 7, 6, 0, 0, 13365, 13366, 7, 3, 0, 0, 13366, 13367, 7, 0, 0, 0, 13367, 13368, 7, 11, 0, 0, 13368, 1654, 1, 0, 0, 0, 13369, 13370, 7, 11, 0, 0, 13370, 13371, 7, 0, 0, 0, 13371, 13372, 7, 4, 0, 0, 13372, 13373, 7, 6, 0, 0, 13373, 13374, 7, 5, 0, 0, 13374, 13375, 7, 4, 0, 0, 13375, 1656, 1, 0, 0, 0, 13376, 13377, 7, 11, 0, 0, 13377, 13378, 7, 0, 0, 0, 13378, 13379, 7, 25, 0, 0, 13379, 1658, 1, 0, 0, 0, 13380, 13381, 7, 11, 0, 0, 13381, 13382, 7, 0, 0, 0, 13382, 13383, 7, 18, 0, 0, 13383, 13384, 7, 6, 0, 0, 13384, 13385, 7, 3, 0, 0, 13385, 1660, 1, 0, 0, 0, 13386, 13387, 7, 11, 0, 0, 13387, 13388, 7, 9, 0, 0, 13388, 13389, 7, 0, 0, 0, 13389, 13390, 7, 15, 0, 0, 13390, 13391, 5, 95, 0, 0, 13391, 13392, 7, 3, 0, 0, 13392, 13393, 7, 6, 0, 0, 13393, 13394, 7, 17, 0, 0, 13394, 13395, 7, 10, 0, 0, 13395, 13396, 7, 5, 0, 0, 13396, 13397, 7, 4, 0, 0, 13397, 13398, 7, 3, 0, 0, 13398, 13399, 7, 0, 0, 0, 13399, 13400, 7, 4, 0, 0, 13400, 13401, 7, 10, 0, 0, 13401, 13402, 7, 2, 0, 0, 13402, 13403, 7, 7, 0, 0, 13403, 13404, 5, 95, 0, 0, 13404, 13405, 7, 6, 0, 0, 13405, 13406, 7, 7, 0, 0, 13406, 13407, 7, 0, 0, 0, 13407, 13408, 7, 1, 0, 0, 13408, 13409, 7, 11, 0, 0, 13409, 13410, 7, 6, 0, 0, 13410, 13411, 7, 9, 0, 0, 13411, 1662, 1, 0, 0, 0, 13412, 13413, 7, 11, 0, 0, 13413, 13414, 7, 9, 0, 0, 13414, 13415, 7, 0, 0, 0, 13415, 13416, 7, 15, 0, 0, 13416, 13417, 5, 95, 0, 0, 13417, 13418, 7, 3, 0, 0, 13418, 13419, 7, 6, 0, 0, 13419, 13420, 7, 17, 0, 0, 13420, 13421, 7, 10, 0, 0, 13421, 13422, 7, 5, 0, 0, 13422, 13423, 7, 4, 0, 0, 13423, 13424, 7, 3, 0, 0, 13424, 13425, 7, 0, 0, 0, 13425, 13426, 7, 4, 0, 0, 13426, 13427, 7, 10, 0, 0, 13427, 13428, 7, 2, 0, 0, 13428, 13429, 7, 7, 0, 0, 13429, 1664, 1, 0, 0, 0, 13430, 13431, 7, 11, 0, 0, 13431, 13432, 7, 9, 0, 0, 13432, 13433, 7, 0, 0, 0, 13433, 13434, 7, 15, 0, 0, 13434, 13435, 5, 95, 0, 0, 13435, 13436, 7, 3, 0, 0, 13436, 13437, 7, 6, 0, 0, 13437, 13438, 7, 17, 0, 0, 13438, 13439, 5, 95, 0, 0, 13439, 13440, 7, 5, 0, 0, 13440, 13441, 7, 18, 0, 0, 13441, 13442, 7, 7, 0, 0, 13442, 13443, 7, 8, 0, 0, 13443, 13444, 5, 95, 0, 0, 13444, 13445, 7, 10, 0, 0, 13445, 13446, 7, 7, 0, 0, 13446, 13447, 7, 4, 0, 0, 13447, 13448, 7, 6, 0, 0, 13448, 13449, 7, 3, 0, 0, 13449, 13450, 7, 13, 0, 0, 13450, 13451, 7, 0, 0, 0, 13451, 13452, 7, 11, 0, 0, 13452, 1666, 1, 0, 0, 0, 13453, 13454, 7, 11, 0, 0, 13454, 13455, 7, 9, 0, 0, 13455, 13456, 7, 3, 0, 0, 13456, 13457, 7, 4, 0, 0, 13457, 13458, 7, 3, 0, 0, 13458, 13459, 7, 10, 0, 0, 13459, 13460, 7, 14, 0, 0, 13460, 1668, 1, 0, 0, 0, 13461, 13462, 7, 11, 0, 0, 13462, 13463, 7, 6, 0, 0, 13463, 13464, 7, 0, 0, 0, 13464, 13465, 7, 16, 0, 0, 13465, 1670, 1, 0, 0, 0, 13466, 13467, 7, 11, 0, 0, 13467, 13468, 7, 6, 0, 0, 13468, 13469, 7, 0, 0, 0, 13469, 13470, 7, 9, 0, 0, 13470, 13471, 5, 95, 0, 0, 13471, 13472, 7, 8, 0, 0, 13472, 13473, 7, 9, 0, 0, 13473, 13474, 7, 1, 0, 0, 13474, 1672, 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, 5, 95, 0, 0, 13480, 13481, 7, 8, 0, 0, 13481, 13482, 7, 9, 0, 0, 13482, 13483, 7, 1, 0, 0, 13483, 13484, 5, 95, 0, 0, 13484, 13485, 7, 12, 0, 0, 13485, 13486, 7, 3, 0, 0, 13486, 13487, 7, 10, 0, 0, 13487, 1674, 1, 0, 0, 0, 13488, 13489, 7, 11, 0, 0, 13489, 13490, 7, 6, 0, 0, 13490, 13491, 7, 0, 0, 0, 13491, 13492, 7, 9, 0, 0, 13492, 13493, 7, 10, 0, 0, 13493, 13494, 7, 7, 0, 0, 13494, 13495, 7, 17, 0, 0, 13495, 1676, 1, 0, 0, 0, 13496, 13497, 7, 11, 0, 0, 13497, 13498, 7, 6, 0, 0, 13498, 13499, 7, 16, 0, 0, 13499, 13500, 7, 4, 0, 0, 13500, 1678, 1, 0, 0, 0, 13501, 13502, 7, 11, 0, 0, 13502, 13503, 7, 6, 0, 0, 13503, 13504, 7, 7, 0, 0, 13504, 13505, 7, 17, 0, 0, 13505, 13506, 7, 4, 0, 0, 13506, 13507, 7, 19, 0, 0, 13507, 13508, 5, 50, 0, 0, 13508, 1680, 1, 0, 0, 0, 13509, 13510, 7, 11, 0, 0, 13510, 13511, 7, 6, 0, 0, 13511, 13512, 7, 7, 0, 0, 13512, 13513, 7, 17, 0, 0, 13513, 13514, 7, 4, 0, 0, 13514, 13515, 7, 19, 0, 0, 13515, 13516, 5, 52, 0, 0, 13516, 1682, 1, 0, 0, 0, 13517, 13518, 7, 11, 0, 0, 13518, 13519, 7, 6, 0, 0, 13519, 13520, 7, 7, 0, 0, 13520, 13521, 7, 17, 0, 0, 13521, 13522, 7, 4, 0, 0, 13522, 13523, 7, 19, 0, 0, 13523, 13524, 7, 1, 0, 0, 13524, 1684, 1, 0, 0, 0, 13525, 13526, 7, 11, 0, 0, 13526, 13527, 7, 6, 0, 0, 13527, 13528, 7, 7, 0, 0, 13528, 13529, 7, 17, 0, 0, 13529, 13530, 7, 4, 0, 0, 13530, 13531, 7, 19, 0, 0, 13531, 13532, 7, 8, 0, 0, 13532, 1686, 1, 0, 0, 0, 13533, 13534, 7, 11, 0, 0, 13534, 13535, 7, 6, 0, 0, 13535, 13536, 7, 7, 0, 0, 13536, 13537, 7, 17, 0, 0, 13537, 13538, 7, 4, 0, 0, 13538, 13539, 7, 19, 0, 0, 13539, 1688, 1, 0, 0, 0, 13540, 13541, 7, 11, 0, 0, 13541, 13542, 7, 6, 0, 0, 13542, 13543, 7, 5, 0, 0, 13543, 13544, 7, 5, 0, 0, 13544, 1690, 1, 0, 0, 0, 13545, 13546, 7, 11, 0, 0, 13546, 13547, 7, 6, 0, 0, 13547, 13548, 7, 13, 0, 0, 13548, 13549, 7, 6, 0, 0, 13549, 13550, 7, 11, 0, 0, 13550, 1692, 1, 0, 0, 0, 13551, 13552, 7, 11, 0, 0, 13552, 13553, 7, 6, 0, 0, 13553, 13554, 7, 13, 0, 0, 13554, 13555, 7, 6, 0, 0, 13555, 13556, 7, 11, 0, 0, 13556, 13557, 5, 95, 0, 0, 13557, 13558, 7, 7, 0, 0, 13558, 13559, 7, 0, 0, 0, 13559, 13560, 7, 14, 0, 0, 13560, 13561, 7, 6, 0, 0, 13561, 1694, 1, 0, 0, 0, 13562, 13563, 7, 11, 0, 0, 13563, 13564, 7, 6, 0, 0, 13564, 13565, 7, 13, 0, 0, 13565, 13566, 7, 6, 0, 0, 13566, 13567, 7, 11, 0, 0, 13567, 13568, 7, 5, 0, 0, 13568, 1696, 1, 0, 0, 0, 13569, 13570, 7, 11, 0, 0, 13570, 13571, 7, 10, 0, 0, 13571, 13572, 7, 1, 0, 0, 13572, 13573, 7, 3, 0, 0, 13573, 13574, 7, 0, 0, 0, 13574, 13575, 7, 3, 0, 0, 13575, 13576, 7, 18, 0, 0, 13576, 1698, 1, 0, 0, 0, 13577, 13578, 7, 11, 0, 0, 13578, 13579, 7, 10, 0, 0, 13579, 13580, 7, 16, 0, 0, 13580, 13581, 7, 6, 0, 0, 13581, 13582, 7, 8, 0, 0, 13582, 13583, 7, 18, 0, 0, 13583, 13584, 7, 8, 0, 0, 13584, 13585, 7, 11, 0, 0, 13585, 13586, 7, 6, 0, 0, 13586, 1700, 1, 0, 0, 0, 13587, 13588, 7, 11, 0, 0, 13588, 13589, 7, 10, 0, 0, 13589, 13590, 7, 16, 0, 0, 13590, 13591, 7, 6, 0, 0, 13591, 1702, 1, 0, 0, 0, 13592, 13593, 7, 11, 0, 0, 13593, 13594, 7, 10, 0, 0, 13594, 13595, 7, 16, 0, 0, 13595, 13596, 7, 6, 0, 0, 13596, 13597, 7, 4, 0, 0, 13597, 13598, 7, 10, 0, 0, 13598, 13599, 7, 14, 0, 0, 13599, 13600, 7, 6, 0, 0, 13600, 1704, 1, 0, 0, 0, 13601, 13602, 7, 11, 0, 0, 13602, 13603, 7, 10, 0, 0, 13603, 13604, 7, 21, 0, 0, 13604, 13605, 7, 6, 0, 0, 13605, 13606, 5, 50, 0, 0, 13606, 1706, 1, 0, 0, 0, 13607, 13608, 7, 11, 0, 0, 13608, 13609, 7, 10, 0, 0, 13609, 13610, 7, 21, 0, 0, 13610, 13611, 7, 6, 0, 0, 13611, 13612, 5, 52, 0, 0, 13612, 1708, 1, 0, 0, 0, 13613, 13614, 7, 11, 0, 0, 13614, 13615, 7, 10, 0, 0, 13615, 13616, 7, 21, 0, 0, 13616, 13617, 7, 6, 0, 0, 13617, 13618, 7, 8, 0, 0, 13618, 1710, 1, 0, 0, 0, 13619, 13620, 7, 11, 0, 0, 13620, 13621, 7, 10, 0, 0, 13621, 13622, 7, 21, 0, 0, 13622, 13623, 7, 6, 0, 0, 13623, 13624, 5, 95, 0, 0, 13624, 13625, 7, 6, 0, 0, 13625, 13626, 7, 25, 0, 0, 13626, 13627, 7, 15, 0, 0, 13627, 13628, 7, 0, 0, 0, 13628, 13629, 7, 7, 0, 0, 13629, 13630, 7, 9, 0, 0, 13630, 1712, 1, 0, 0, 0, 13631, 13632, 7, 11, 0, 0, 13632, 13633, 7, 10, 0, 0, 13633, 13634, 7, 21, 0, 0, 13634, 13635, 7, 6, 0, 0, 13635, 1714, 1, 0, 0, 0, 13636, 13637, 7, 11, 0, 0, 13637, 13638, 7, 10, 0, 0, 13638, 13639, 7, 14, 0, 0, 13639, 13640, 7, 10, 0, 0, 13640, 13641, 7, 4, 0, 0, 13641, 1716, 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, 6, 0, 0, 13646, 13647, 7, 0, 0, 0, 13647, 13648, 7, 3, 0, 0, 13648, 1718, 1, 0, 0, 0, 13649, 13650, 7, 11, 0, 0, 13650, 13651, 7, 10, 0, 0, 13651, 13652, 7, 7, 0, 0, 13652, 13653, 7, 6, 0, 0, 13653, 13654, 7, 5, 0, 0, 13654, 1720, 1, 0, 0, 0, 13655, 13656, 7, 11, 0, 0, 13656, 13657, 7, 10, 0, 0, 13657, 13658, 7, 7, 0, 0, 13658, 13659, 7, 21, 0, 0, 13659, 1722, 1, 0, 0, 0, 13660, 13661, 7, 11, 0, 0, 13661, 13662, 7, 10, 0, 0, 13662, 13663, 7, 5, 0, 0, 13663, 13664, 7, 4, 0, 0, 13664, 1724, 1, 0, 0, 0, 13665, 13666, 7, 11, 0, 0, 13666, 13667, 7, 10, 0, 0, 13667, 13668, 7, 4, 0, 0, 13668, 13669, 7, 4, 0, 0, 13669, 13670, 7, 11, 0, 0, 13670, 13671, 7, 6, 0, 0, 13671, 1726, 1, 0, 0, 0, 13672, 13673, 7, 11, 0, 0, 13673, 13674, 7, 11, 0, 0, 13674, 13675, 7, 5, 0, 0, 13675, 1728, 1, 0, 0, 0, 13676, 13677, 7, 11, 0, 0, 13677, 13678, 7, 7, 0, 0, 13678, 1730, 1, 0, 0, 0, 13679, 13680, 7, 11, 0, 0, 13680, 13681, 7, 7, 0, 0, 13681, 13682, 7, 7, 0, 0, 13682, 13683, 7, 13, 0, 0, 13683, 13684, 7, 11, 0, 0, 13684, 1732, 1, 0, 0, 0, 13685, 13686, 7, 11, 0, 0, 13686, 13687, 7, 2, 0, 0, 13687, 13688, 7, 0, 0, 0, 13688, 13689, 7, 9, 0, 0, 13689, 1734, 1, 0, 0, 0, 13690, 13691, 7, 11, 0, 0, 13691, 13692, 7, 2, 0, 0, 13692, 13693, 7, 1, 0, 0, 13693, 1736, 1, 0, 0, 0, 13694, 13695, 7, 11, 0, 0, 13695, 13696, 7, 2, 0, 0, 13696, 13697, 7, 1, 0, 0, 13697, 13698, 7, 16, 0, 0, 13698, 13699, 7, 10, 0, 0, 13699, 13700, 7, 11, 0, 0, 13700, 13701, 7, 6, 0, 0, 13701, 1738, 1, 0, 0, 0, 13702, 13703, 7, 11, 0, 0, 13703, 13704, 7, 2, 0, 0, 13704, 13705, 7, 1, 0, 0, 13705, 13706, 7, 7, 0, 0, 13706, 13707, 7, 13, 0, 0, 13707, 13708, 7, 11, 0, 0, 13708, 1740, 1, 0, 0, 0, 13709, 13710, 7, 11, 0, 0, 13710, 13711, 7, 2, 0, 0, 13711, 13712, 7, 1, 0, 0, 13712, 13713, 7, 5, 0, 0, 13713, 1742, 1, 0, 0, 0, 13714, 13715, 7, 11, 0, 0, 13715, 13716, 7, 2, 0, 0, 13716, 13717, 7, 8, 0, 0, 13717, 13718, 7, 0, 0, 0, 13718, 13719, 7, 11, 0, 0, 13719, 13720, 5, 95, 0, 0, 13720, 13721, 7, 10, 0, 0, 13721, 13722, 7, 7, 0, 0, 13722, 13723, 7, 9, 0, 0, 13723, 13724, 7, 6, 0, 0, 13724, 13725, 7, 25, 0, 0, 13725, 13726, 7, 6, 0, 0, 13726, 13727, 7, 5, 0, 0, 13727, 1744, 1, 0, 0, 0, 13728, 13729, 7, 11, 0, 0, 13729, 13730, 7, 2, 0, 0, 13730, 13731, 7, 8, 0, 0, 13731, 13732, 7, 0, 0, 0, 13732, 13733, 7, 11, 0, 0, 13733, 1746, 1, 0, 0, 0, 13734, 13735, 7, 11, 0, 0, 13735, 13736, 7, 2, 0, 0, 13736, 13737, 7, 8, 0, 0, 13737, 13738, 7, 0, 0, 0, 13738, 13739, 7, 11, 0, 0, 13739, 13740, 7, 4, 0, 0, 13740, 13741, 7, 10, 0, 0, 13741, 13742, 7, 14, 0, 0, 13742, 13743, 7, 6, 0, 0, 13743, 1748, 1, 0, 0, 0, 13744, 13745, 7, 11, 0, 0, 13745, 13746, 7, 2, 0, 0, 13746, 13747, 7, 8, 0, 0, 13747, 13748, 7, 0, 0, 0, 13748, 13749, 7, 11, 0, 0, 13749, 13750, 7, 4, 0, 0, 13750, 13751, 7, 10, 0, 0, 13751, 13752, 7, 14, 0, 0, 13752, 13753, 7, 6, 0, 0, 13753, 13754, 7, 5, 0, 0, 13754, 13755, 7, 4, 0, 0, 13755, 13756, 7, 0, 0, 0, 13756, 13757, 7, 14, 0, 0, 13757, 13758, 7, 15, 0, 0, 13758, 1750, 1, 0, 0, 0, 13759, 13760, 7, 11, 0, 0, 13760, 13761, 7, 2, 0, 0, 13761, 13762, 7, 8, 0, 0, 13762, 13763, 7, 0, 0, 0, 13763, 13764, 7, 4, 0, 0, 13764, 13765, 7, 10, 0, 0, 13765, 13766, 7, 2, 0, 0, 13766, 13767, 7, 7, 0, 0, 13767, 1752, 1, 0, 0, 0, 13768, 13769, 7, 11, 0, 0, 13769, 13770, 7, 2, 0, 0, 13770, 13771, 7, 8, 0, 0, 13771, 13772, 7, 0, 0, 0, 13772, 13773, 7, 4, 0, 0, 13773, 13774, 7, 2, 0, 0, 13774, 13775, 7, 3, 0, 0, 13775, 1754, 1, 0, 0, 0, 13776, 13777, 7, 11, 0, 0, 13777, 13778, 7, 2, 0, 0, 13778, 13779, 7, 8, 0, 0, 13779, 13780, 7, 21, 0, 0, 13780, 13781, 7, 9, 0, 0, 13781, 13782, 7, 2, 0, 0, 13782, 13783, 7, 22, 0, 0, 13783, 13784, 7, 7, 0, 0, 13784, 1756, 1, 0, 0, 0, 13785, 13786, 7, 11, 0, 0, 13786, 13787, 7, 2, 0, 0, 13787, 13788, 7, 8, 0, 0, 13788, 13789, 7, 21, 0, 0, 13789, 13790, 7, 6, 0, 0, 13790, 13791, 7, 9, 0, 0, 13791, 1758, 1, 0, 0, 0, 13792, 13793, 7, 11, 0, 0, 13793, 13794, 7, 2, 0, 0, 13794, 13795, 7, 8, 0, 0, 13795, 13796, 7, 21, 0, 0, 13796, 13797, 7, 10, 0, 0, 13797, 13798, 7, 7, 0, 0, 13798, 13799, 7, 17, 0, 0, 13799, 1760, 1, 0, 0, 0, 13800, 13801, 7, 11, 0, 0, 13801, 13802, 7, 2, 0, 0, 13802, 13803, 7, 8, 0, 0, 13803, 13804, 7, 21, 0, 0, 13804, 1762, 1, 0, 0, 0, 13805, 13806, 7, 11, 0, 0, 13806, 13807, 7, 2, 0, 0, 13807, 13808, 7, 17, 0, 0, 13808, 13809, 7, 16, 0, 0, 13809, 13810, 7, 10, 0, 0, 13810, 13811, 7, 11, 0, 0, 13811, 13812, 7, 6, 0, 0, 13812, 1764, 1, 0, 0, 0, 13813, 13814, 7, 11, 0, 0, 13814, 13815, 7, 2, 0, 0, 13815, 13816, 7, 17, 0, 0, 13816, 13817, 7, 16, 0, 0, 13817, 13818, 7, 10, 0, 0, 13818, 13819, 7, 11, 0, 0, 13819, 13820, 7, 6, 0, 0, 13820, 13821, 7, 5, 0, 0, 13821, 1766, 1, 0, 0, 0, 13822, 13823, 7, 11, 0, 0, 13823, 13824, 7, 2, 0, 0, 13824, 13825, 7, 17, 0, 0, 13825, 13826, 7, 17, 0, 0, 13826, 13827, 7, 10, 0, 0, 13827, 13828, 7, 7, 0, 0, 13828, 13829, 7, 17, 0, 0, 13829, 1768, 1, 0, 0, 0, 13830, 13831, 7, 11, 0, 0, 13831, 13832, 7, 2, 0, 0, 13832, 13833, 7, 17, 0, 0, 13833, 13834, 7, 10, 0, 0, 13834, 13835, 7, 8, 0, 0, 13835, 13836, 7, 0, 0, 0, 13836, 13837, 7, 11, 0, 0, 13837, 1770, 1, 0, 0, 0, 13838, 13839, 7, 11, 0, 0, 13839, 13840, 7, 2, 0, 0, 13840, 13841, 7, 17, 0, 0, 13841, 13842, 7, 10, 0, 0, 13842, 13843, 7, 8, 0, 0, 13843, 13844, 7, 0, 0, 0, 13844, 13845, 7, 11, 0, 0, 13845, 13846, 5, 95, 0, 0, 13846, 13847, 7, 3, 0, 0, 13847, 13848, 7, 6, 0, 0, 13848, 13849, 7, 0, 0, 0, 13849, 13850, 7, 9, 0, 0, 13850, 13851, 7, 5, 0, 0, 13851, 13852, 5, 95, 0, 0, 13852, 13853, 7, 15, 0, 0, 13853, 13854, 7, 6, 0, 0, 13854, 13855, 7, 3, 0, 0, 13855, 13856, 5, 95, 0, 0, 13856, 13857, 7, 8, 0, 0, 13857, 13858, 7, 0, 0, 0, 13858, 13859, 7, 11, 0, 0, 13859, 13860, 7, 11, 0, 0, 13860, 1772, 1, 0, 0, 0, 13861, 13862, 7, 11, 0, 0, 13862, 13863, 7, 2, 0, 0, 13863, 13864, 7, 17, 0, 0, 13864, 13865, 7, 10, 0, 0, 13865, 13866, 7, 8, 0, 0, 13866, 13867, 7, 0, 0, 0, 13867, 13868, 7, 11, 0, 0, 13868, 13869, 5, 95, 0, 0, 13869, 13870, 7, 3, 0, 0, 13870, 13871, 7, 6, 0, 0, 13871, 13872, 7, 0, 0, 0, 13872, 13873, 7, 9, 0, 0, 13873, 13874, 7, 5, 0, 0, 13874, 13875, 5, 95, 0, 0, 13875, 13876, 7, 15, 0, 0, 13876, 13877, 7, 6, 0, 0, 13877, 13878, 7, 3, 0, 0, 13878, 13879, 5, 95, 0, 0, 13879, 13880, 7, 5, 0, 0, 13880, 13881, 7, 6, 0, 0, 13881, 13882, 7, 5, 0, 0, 13882, 13883, 7, 5, 0, 0, 13883, 13884, 7, 10, 0, 0, 13884, 13885, 7, 2, 0, 0, 13885, 13886, 7, 7, 0, 0, 13886, 1774, 1, 0, 0, 0, 13887, 13888, 7, 11, 0, 0, 13888, 13889, 7, 2, 0, 0, 13889, 13890, 7, 17, 0, 0, 13890, 1776, 1, 0, 0, 0, 13891, 13892, 7, 11, 0, 0, 13892, 13893, 7, 2, 0, 0, 13893, 13894, 7, 17, 0, 0, 13894, 13895, 7, 14, 0, 0, 13895, 13896, 7, 10, 0, 0, 13896, 13897, 7, 7, 0, 0, 13897, 13898, 7, 10, 0, 0, 13898, 13899, 7, 7, 0, 0, 13899, 13900, 7, 17, 0, 0, 13900, 1778, 1, 0, 0, 0, 13901, 13902, 7, 11, 0, 0, 13902, 13903, 7, 2, 0, 0, 13903, 13904, 7, 17, 0, 0, 13904, 13905, 7, 2, 0, 0, 13905, 13906, 7, 16, 0, 0, 13906, 13907, 7, 16, 0, 0, 13907, 1780, 1, 0, 0, 0, 13908, 13909, 7, 11, 0, 0, 13909, 13910, 7, 2, 0, 0, 13910, 13911, 7, 17, 0, 0, 13911, 13912, 7, 2, 0, 0, 13912, 13913, 7, 7, 0, 0, 13913, 1782, 1, 0, 0, 0, 13914, 13915, 7, 11, 0, 0, 13915, 13916, 7, 2, 0, 0, 13916, 13917, 7, 17, 0, 0, 13917, 13918, 5, 95, 0, 0, 13918, 13919, 7, 3, 0, 0, 13919, 13920, 7, 6, 0, 0, 13920, 13921, 7, 0, 0, 0, 13921, 13922, 7, 9, 0, 0, 13922, 13923, 5, 95, 0, 0, 13923, 13924, 7, 2, 0, 0, 13924, 13925, 7, 7, 0, 0, 13925, 13926, 7, 11, 0, 0, 13926, 13927, 7, 18, 0, 0, 13927, 13928, 5, 95, 0, 0, 13928, 13929, 7, 13, 0, 0, 13929, 13930, 7, 10, 0, 0, 13930, 13931, 7, 2, 0, 0, 13931, 13932, 7, 11, 0, 0, 13932, 13933, 7, 0, 0, 0, 13933, 13934, 7, 4, 0, 0, 13934, 13935, 7, 10, 0, 0, 13935, 13936, 7, 2, 0, 0, 13936, 13937, 7, 7, 0, 0, 13937, 13938, 7, 5, 0, 0, 13938, 1784, 1, 0, 0, 0, 13939, 13940, 7, 11, 0, 0, 13940, 13941, 7, 2, 0, 0, 13941, 13942, 7, 7, 0, 0, 13942, 13943, 7, 17, 0, 0, 13943, 1786, 1, 0, 0, 0, 13944, 13945, 7, 11, 0, 0, 13945, 13946, 7, 2, 0, 0, 13946, 13947, 7, 2, 0, 0, 13947, 13948, 7, 15, 0, 0, 13948, 1788, 1, 0, 0, 0, 13949, 13950, 7, 11, 0, 0, 13950, 13951, 7, 2, 0, 0, 13951, 13952, 7, 5, 0, 0, 13952, 13953, 7, 4, 0, 0, 13953, 1790, 1, 0, 0, 0, 13954, 13955, 7, 11, 0, 0, 13955, 13956, 7, 2, 0, 0, 13956, 13957, 7, 22, 0, 0, 13957, 13958, 7, 6, 0, 0, 13958, 13959, 7, 3, 0, 0, 13959, 1792, 1, 0, 0, 0, 13960, 13961, 7, 11, 0, 0, 13961, 13962, 7, 2, 0, 0, 13962, 13963, 7, 22, 0, 0, 13963, 1794, 1, 0, 0, 0, 13964, 13965, 7, 11, 0, 0, 13965, 13966, 7, 15, 0, 0, 13966, 13967, 7, 0, 0, 0, 13967, 13968, 7, 9, 0, 0, 13968, 1796, 1, 0, 0, 0, 13969, 13970, 7, 11, 0, 0, 13970, 13971, 7, 3, 0, 0, 13971, 13972, 7, 4, 0, 0, 13972, 13973, 7, 3, 0, 0, 13973, 13974, 7, 10, 0, 0, 13974, 13975, 7, 14, 0, 0, 13975, 1798, 1, 0, 0, 0, 13976, 13977, 7, 11, 0, 0, 13977, 13978, 7, 4, 0, 0, 13978, 13979, 7, 3, 0, 0, 13979, 13980, 7, 10, 0, 0, 13980, 13981, 7, 14, 0, 0, 13981, 1800, 1, 0, 0, 0, 13982, 13983, 7, 14, 0, 0, 13983, 1802, 1, 0, 0, 0, 13984, 13985, 7, 14, 0, 0, 13985, 13986, 7, 0, 0, 0, 13986, 13987, 7, 10, 0, 0, 13987, 13988, 7, 7, 0, 0, 13988, 1804, 1, 0, 0, 0, 13989, 13990, 7, 14, 0, 0, 13990, 13991, 7, 0, 0, 0, 13991, 13992, 7, 21, 0, 0, 13992, 13993, 7, 6, 0, 0, 13993, 13994, 5, 95, 0, 0, 13994, 13995, 7, 3, 0, 0, 13995, 13996, 7, 6, 0, 0, 13996, 13997, 7, 16, 0, 0, 13997, 1806, 1, 0, 0, 0, 13998, 13999, 7, 14, 0, 0, 13999, 14000, 7, 0, 0, 0, 14000, 14001, 7, 7, 0, 0, 14001, 14002, 7, 0, 0, 0, 14002, 14003, 7, 17, 0, 0, 14003, 14004, 7, 6, 0, 0, 14004, 14005, 7, 9, 0, 0, 14005, 1808, 1, 0, 0, 0, 14006, 14007, 7, 14, 0, 0, 14007, 14008, 7, 0, 0, 0, 14008, 14009, 7, 7, 0, 0, 14009, 14010, 7, 0, 0, 0, 14010, 14011, 7, 17, 0, 0, 14011, 14012, 7, 6, 0, 0, 14012, 1810, 1, 0, 0, 0, 14013, 14014, 7, 14, 0, 0, 14014, 14015, 7, 0, 0, 0, 14015, 14016, 7, 7, 0, 0, 14016, 14017, 7, 0, 0, 0, 14017, 14018, 7, 17, 0, 0, 14018, 14019, 7, 6, 0, 0, 14019, 14020, 7, 14, 0, 0, 14020, 14021, 7, 6, 0, 0, 14021, 14022, 7, 7, 0, 0, 14022, 14023, 7, 4, 0, 0, 14023, 1812, 1, 0, 0, 0, 14024, 14025, 7, 14, 0, 0, 14025, 14026, 7, 0, 0, 0, 14026, 14027, 7, 7, 0, 0, 14027, 14028, 7, 0, 0, 0, 14028, 14029, 7, 17, 0, 0, 14029, 14030, 7, 6, 0, 0, 14030, 14031, 7, 3, 0, 0, 14031, 1814, 1, 0, 0, 0, 14032, 14033, 7, 14, 0, 0, 14033, 14034, 7, 0, 0, 0, 14034, 14035, 7, 7, 0, 0, 14035, 14036, 7, 9, 0, 0, 14036, 14037, 7, 0, 0, 0, 14037, 14038, 7, 4, 0, 0, 14038, 14039, 7, 2, 0, 0, 14039, 14040, 7, 3, 0, 0, 14040, 14041, 7, 18, 0, 0, 14041, 1816, 1, 0, 0, 0, 14042, 14043, 7, 14, 0, 0, 14043, 14044, 7, 0, 0, 0, 14044, 14045, 7, 7, 0, 0, 14045, 14046, 7, 12, 0, 0, 14046, 14047, 7, 0, 0, 0, 14047, 14048, 7, 11, 0, 0, 14048, 1818, 1, 0, 0, 0, 14049, 14050, 7, 14, 0, 0, 14050, 14051, 7, 0, 0, 0, 14051, 14052, 7, 15, 0, 0, 14052, 1820, 1, 0, 0, 0, 14053, 14054, 7, 14, 0, 0, 14054, 14055, 7, 0, 0, 0, 14055, 14056, 7, 15, 0, 0, 14056, 14057, 7, 15, 0, 0, 14057, 14058, 7, 10, 0, 0, 14058, 14059, 7, 7, 0, 0, 14059, 14060, 7, 17, 0, 0, 14060, 1822, 1, 0, 0, 0, 14061, 14062, 7, 14, 0, 0, 14062, 14063, 7, 0, 0, 0, 14063, 14064, 7, 5, 0, 0, 14064, 14065, 7, 21, 0, 0, 14065, 1824, 1, 0, 0, 0, 14066, 14067, 7, 14, 0, 0, 14067, 14068, 7, 0, 0, 0, 14068, 14069, 7, 5, 0, 0, 14069, 14070, 7, 4, 0, 0, 14070, 14071, 7, 6, 0, 0, 14071, 14072, 7, 3, 0, 0, 14072, 1826, 1, 0, 0, 0, 14073, 14074, 7, 14, 0, 0, 14074, 14075, 7, 0, 0, 0, 14075, 14076, 7, 4, 0, 0, 14076, 14077, 7, 8, 0, 0, 14077, 14078, 7, 19, 0, 0, 14078, 14079, 7, 6, 0, 0, 14079, 14080, 7, 9, 0, 0, 14080, 1828, 1, 0, 0, 0, 14081, 14082, 7, 14, 0, 0, 14082, 14083, 7, 0, 0, 0, 14083, 14084, 7, 4, 0, 0, 14084, 14085, 7, 8, 0, 0, 14085, 14086, 7, 19, 0, 0, 14086, 14087, 7, 6, 0, 0, 14087, 14088, 7, 5, 0, 0, 14088, 1830, 1, 0, 0, 0, 14089, 14090, 7, 14, 0, 0, 14090, 14091, 7, 0, 0, 0, 14091, 14092, 7, 4, 0, 0, 14092, 14093, 7, 8, 0, 0, 14093, 14094, 7, 19, 0, 0, 14094, 1832, 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, 7, 0, 0, 14102, 14103, 7, 12, 0, 0, 14103, 14104, 7, 14, 0, 0, 14104, 14105, 7, 1, 0, 0, 14105, 14106, 7, 6, 0, 0, 14106, 14107, 7, 3, 0, 0, 14107, 1834, 1, 0, 0, 0, 14108, 14109, 7, 14, 0, 0, 14109, 14110, 7, 0, 0, 0, 14110, 14111, 7, 4, 0, 0, 14111, 14112, 7, 8, 0, 0, 14112, 14113, 7, 19, 0, 0, 14113, 14114, 5, 95, 0, 0, 14114, 14115, 7, 3, 0, 0, 14115, 14116, 7, 6, 0, 0, 14116, 14117, 7, 8, 0, 0, 14117, 14118, 7, 2, 0, 0, 14118, 14119, 7, 17, 0, 0, 14119, 14120, 7, 7, 0, 0, 14120, 14121, 7, 10, 0, 0, 14121, 14122, 7, 23, 0, 0, 14122, 14123, 7, 6, 0, 0, 14123, 1836, 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, 14136, 7, 9, 0, 0, 14136, 1838, 1, 0, 0, 0, 14137, 14138, 7, 14, 0, 0, 14138, 14139, 7, 0, 0, 0, 14139, 14140, 7, 4, 0, 0, 14140, 14141, 7, 6, 0, 0, 14141, 14142, 7, 3, 0, 0, 14142, 14143, 7, 10, 0, 0, 14143, 14144, 7, 0, 0, 0, 14144, 14145, 7, 11, 0, 0, 14145, 14146, 7, 10, 0, 0, 14146, 14147, 7, 23, 0, 0, 14147, 14148, 7, 6, 0, 0, 14148, 1840, 1, 0, 0, 0, 14149, 14150, 7, 14, 0, 0, 14150, 14151, 7, 0, 0, 0, 14151, 14152, 7, 25, 0, 0, 14152, 14153, 7, 0, 0, 0, 14153, 14154, 7, 3, 0, 0, 14154, 14155, 7, 8, 0, 0, 14155, 14156, 7, 19, 0, 0, 14156, 14157, 7, 11, 0, 0, 14157, 14158, 7, 2, 0, 0, 14158, 14159, 7, 17, 0, 0, 14159, 14160, 7, 5, 0, 0, 14160, 1842, 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, 9, 0, 0, 14165, 14166, 7, 0, 0, 0, 14166, 14167, 7, 4, 0, 0, 14167, 14168, 7, 0, 0, 0, 14168, 14169, 7, 16, 0, 0, 14169, 14170, 7, 10, 0, 0, 14170, 14171, 7, 11, 0, 0, 14171, 14172, 7, 6, 0, 0, 14172, 14173, 7, 5, 0, 0, 14173, 1844, 1, 0, 0, 0, 14174, 14175, 7, 14, 0, 0, 14175, 14176, 7, 0, 0, 0, 14176, 14177, 7, 25, 0, 0, 14177, 14178, 7, 6, 0, 0, 14178, 14179, 7, 25, 0, 0, 14179, 14180, 7, 4, 0, 0, 14180, 14181, 7, 6, 0, 0, 14181, 14182, 7, 7, 0, 0, 14182, 14183, 7, 4, 0, 0, 14183, 14184, 7, 5, 0, 0, 14184, 1846, 1, 0, 0, 0, 14185, 14186, 7, 14, 0, 0, 14186, 14187, 7, 0, 0, 0, 14187, 14188, 7, 25, 0, 0, 14188, 14189, 7, 10, 0, 0, 14189, 14190, 7, 14, 0, 0, 14190, 14191, 7, 10, 0, 0, 14191, 14192, 7, 23, 0, 0, 14192, 14193, 7, 6, 0, 0, 14193, 1848, 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, 10, 0, 0, 14198, 14199, 7, 7, 0, 0, 14199, 14200, 7, 5, 0, 0, 14200, 14201, 7, 4, 0, 0, 14201, 14202, 7, 0, 0, 0, 14202, 14203, 7, 7, 0, 0, 14203, 14204, 7, 8, 0, 0, 14204, 14205, 7, 6, 0, 0, 14205, 14206, 7, 5, 0, 0, 14206, 1850, 1, 0, 0, 0, 14207, 14208, 7, 14, 0, 0, 14208, 14209, 7, 0, 0, 0, 14209, 14210, 7, 25, 0, 0, 14210, 14211, 7, 11, 0, 0, 14211, 14212, 7, 2, 0, 0, 14212, 14213, 7, 17, 0, 0, 14213, 14214, 7, 16, 0, 0, 14214, 14215, 7, 10, 0, 0, 14215, 14216, 7, 11, 0, 0, 14216, 14217, 7, 6, 0, 0, 14217, 14218, 7, 5, 0, 0, 14218, 1852, 1, 0, 0, 0, 14219, 14220, 7, 14, 0, 0, 14220, 14221, 7, 0, 0, 0, 14221, 14222, 7, 25, 0, 0, 14222, 14223, 7, 11, 0, 0, 14223, 14224, 7, 2, 0, 0, 14224, 14225, 7, 17, 0, 0, 14225, 14226, 7, 19, 0, 0, 14226, 14227, 7, 10, 0, 0, 14227, 14228, 7, 5, 0, 0, 14228, 14229, 7, 4, 0, 0, 14229, 14230, 7, 2, 0, 0, 14230, 14231, 7, 3, 0, 0, 14231, 14232, 7, 18, 0, 0, 14232, 1854, 1, 0, 0, 0, 14233, 14234, 7, 14, 0, 0, 14234, 14235, 7, 0, 0, 0, 14235, 14236, 7, 25, 0, 0, 14236, 14237, 7, 11, 0, 0, 14237, 14238, 7, 2, 0, 0, 14238, 14239, 7, 17, 0, 0, 14239, 14240, 7, 14, 0, 0, 14240, 14241, 7, 6, 0, 0, 14241, 14242, 7, 14, 0, 0, 14242, 14243, 7, 1, 0, 0, 14243, 14244, 7, 6, 0, 0, 14244, 14245, 7, 3, 0, 0, 14245, 14246, 7, 5, 0, 0, 14246, 1856, 1, 0, 0, 0, 14247, 14248, 7, 14, 0, 0, 14248, 14249, 7, 0, 0, 0, 14249, 14250, 7, 25, 0, 0, 14250, 14251, 5, 95, 0, 0, 14251, 14252, 7, 5, 0, 0, 14252, 14253, 7, 19, 0, 0, 14253, 14254, 7, 0, 0, 0, 14254, 14255, 7, 3, 0, 0, 14255, 14256, 7, 6, 0, 0, 14256, 14257, 7, 9, 0, 0, 14257, 14258, 5, 95, 0, 0, 14258, 14259, 7, 4, 0, 0, 14259, 14260, 7, 6, 0, 0, 14260, 14261, 7, 14, 0, 0, 14261, 14262, 7, 15, 0, 0, 14262, 14263, 5, 95, 0, 0, 14263, 14264, 7, 5, 0, 0, 14264, 14265, 7, 10, 0, 0, 14265, 14266, 7, 23, 0, 0, 14266, 14267, 7, 6, 0, 0, 14267, 1858, 1, 0, 0, 0, 14268, 14269, 7, 14, 0, 0, 14269, 14270, 7, 0, 0, 0, 14270, 14271, 7, 25, 0, 0, 14271, 14272, 7, 5, 0, 0, 14272, 14273, 7, 10, 0, 0, 14273, 14274, 7, 23, 0, 0, 14274, 14275, 7, 6, 0, 0, 14275, 1860, 1, 0, 0, 0, 14276, 14277, 7, 14, 0, 0, 14277, 14278, 7, 0, 0, 0, 14278, 14279, 7, 25, 0, 0, 14279, 14280, 7, 4, 0, 0, 14280, 14281, 7, 3, 0, 0, 14281, 14282, 7, 0, 0, 0, 14282, 14283, 7, 7, 0, 0, 14283, 14284, 7, 5, 0, 0, 14284, 1862, 1, 0, 0, 0, 14285, 14286, 7, 14, 0, 0, 14286, 14287, 7, 0, 0, 0, 14287, 14288, 7, 25, 0, 0, 14288, 14289, 7, 13, 0, 0, 14289, 14290, 7, 0, 0, 0, 14290, 14291, 7, 11, 0, 0, 14291, 14292, 7, 12, 0, 0, 14292, 14293, 7, 6, 0, 0, 14293, 1864, 1, 0, 0, 0, 14294, 14295, 7, 14, 0, 0, 14295, 14296, 7, 6, 0, 0, 14296, 14297, 7, 0, 0, 0, 14297, 14298, 7, 5, 0, 0, 14298, 14299, 7, 12, 0, 0, 14299, 14300, 7, 3, 0, 0, 14300, 14301, 7, 6, 0, 0, 14301, 1866, 1, 0, 0, 0, 14302, 14303, 7, 14, 0, 0, 14303, 14304, 7, 6, 0, 0, 14304, 14305, 7, 0, 0, 0, 14305, 14306, 7, 5, 0, 0, 14306, 14307, 7, 12, 0, 0, 14307, 14308, 7, 3, 0, 0, 14308, 14309, 7, 6, 0, 0, 14309, 14310, 7, 5, 0, 0, 14310, 1868, 1, 0, 0, 0, 14311, 14312, 7, 14, 0, 0, 14312, 14313, 7, 6, 0, 0, 14313, 14314, 7, 9, 0, 0, 14314, 14315, 7, 10, 0, 0, 14315, 14316, 7, 12, 0, 0, 14316, 14317, 7, 14, 0, 0, 14317, 1870, 1, 0, 0, 0, 14318, 14319, 7, 14, 0, 0, 14319, 14320, 7, 6, 0, 0, 14320, 14321, 7, 14, 0, 0, 14321, 14322, 7, 1, 0, 0, 14322, 14323, 7, 6, 0, 0, 14323, 14324, 7, 3, 0, 0, 14324, 1872, 1, 0, 0, 0, 14325, 14326, 7, 14, 0, 0, 14326, 14327, 7, 6, 0, 0, 14327, 14328, 7, 14, 0, 0, 14328, 14329, 7, 1, 0, 0, 14329, 14330, 7, 6, 0, 0, 14330, 14331, 7, 3, 0, 0, 14331, 14332, 5, 95, 0, 0, 14332, 14333, 7, 8, 0, 0, 14333, 14334, 7, 0, 0, 0, 14334, 14335, 7, 15, 0, 0, 14335, 14336, 7, 4, 0, 0, 14336, 14337, 7, 10, 0, 0, 14337, 14338, 7, 2, 0, 0, 14338, 14339, 7, 7, 0, 0, 14339, 1874, 1, 0, 0, 0, 14340, 14341, 7, 14, 0, 0, 14341, 14342, 7, 6, 0, 0, 14342, 14343, 7, 14, 0, 0, 14343, 14344, 7, 1, 0, 0, 14344, 14345, 7, 6, 0, 0, 14345, 14346, 7, 3, 0, 0, 14346, 14347, 5, 95, 0, 0, 14347, 14348, 7, 9, 0, 0, 14348, 14349, 7, 6, 0, 0, 14349, 14350, 7, 5, 0, 0, 14350, 14351, 7, 8, 0, 0, 14351, 14352, 7, 3, 0, 0, 14352, 14353, 7, 10, 0, 0, 14353, 14354, 7, 15, 0, 0, 14354, 14355, 7, 4, 0, 0, 14355, 14356, 7, 10, 0, 0, 14356, 14357, 7, 2, 0, 0, 14357, 14358, 7, 7, 0, 0, 14358, 1876, 1, 0, 0, 0, 14359, 14360, 7, 14, 0, 0, 14360, 14361, 7, 6, 0, 0, 14361, 14362, 7, 14, 0, 0, 14362, 14363, 7, 1, 0, 0, 14363, 14364, 7, 6, 0, 0, 14364, 14365, 7, 3, 0, 0, 14365, 14366, 5, 95, 0, 0, 14366, 14367, 7, 7, 0, 0, 14367, 14368, 7, 0, 0, 0, 14368, 14369, 7, 14, 0, 0, 14369, 14370, 7, 6, 0, 0, 14370, 1878, 1, 0, 0, 0, 14371, 14372, 7, 14, 0, 0, 14372, 14373, 7, 6, 0, 0, 14373, 14374, 7, 14, 0, 0, 14374, 14375, 7, 1, 0, 0, 14375, 14376, 7, 6, 0, 0, 14376, 14377, 7, 3, 0, 0, 14377, 14378, 5, 95, 0, 0, 14378, 14379, 7, 12, 0, 0, 14379, 14380, 7, 7, 0, 0, 14380, 14381, 7, 10, 0, 0, 14381, 14382, 7, 24, 0, 0, 14382, 14383, 7, 12, 0, 0, 14383, 14384, 7, 6, 0, 0, 14384, 14385, 5, 95, 0, 0, 14385, 14386, 7, 7, 0, 0, 14386, 14387, 7, 0, 0, 0, 14387, 14388, 7, 14, 0, 0, 14388, 14389, 7, 6, 0, 0, 14389, 1880, 1, 0, 0, 0, 14390, 14391, 7, 14, 0, 0, 14391, 14392, 7, 6, 0, 0, 14392, 14393, 7, 14, 0, 0, 14393, 14394, 7, 8, 0, 0, 14394, 14395, 7, 2, 0, 0, 14395, 14396, 7, 14, 0, 0, 14396, 14397, 7, 15, 0, 0, 14397, 14398, 7, 3, 0, 0, 14398, 14399, 7, 6, 0, 0, 14399, 14400, 7, 5, 0, 0, 14400, 14401, 7, 5, 0, 0, 14401, 1882, 1, 0, 0, 0, 14402, 14403, 7, 14, 0, 0, 14403, 14404, 7, 6, 0, 0, 14404, 14405, 7, 14, 0, 0, 14405, 14406, 7, 2, 0, 0, 14406, 14407, 7, 3, 0, 0, 14407, 14408, 7, 18, 0, 0, 14408, 1884, 1, 0, 0, 0, 14409, 14410, 7, 14, 0, 0, 14410, 14411, 7, 6, 0, 0, 14411, 14412, 7, 3, 0, 0, 14412, 14413, 7, 17, 0, 0, 14413, 14414, 7, 6, 0, 0, 14414, 14415, 5, 36, 0, 0, 14415, 14416, 7, 0, 0, 0, 14416, 14417, 7, 8, 0, 0, 14417, 14418, 7, 4, 0, 0, 14418, 14419, 7, 10, 0, 0, 14419, 14420, 7, 2, 0, 0, 14420, 14421, 7, 7, 0, 0, 14421, 14422, 7, 5, 0, 0, 14422, 1886, 1, 0, 0, 0, 14423, 14424, 7, 14, 0, 0, 14424, 14425, 7, 6, 0, 0, 14425, 14426, 7, 3, 0, 0, 14426, 14427, 7, 17, 0, 0, 14427, 14428, 7, 6, 0, 0, 14428, 14429, 5, 95, 0, 0, 14429, 14430, 7, 0, 0, 0, 14430, 14431, 7, 20, 0, 0, 14431, 1888, 1, 0, 0, 0, 14432, 14433, 7, 14, 0, 0, 14433, 14434, 7, 6, 0, 0, 14434, 14435, 7, 3, 0, 0, 14435, 14436, 7, 17, 0, 0, 14436, 14437, 7, 6, 0, 0, 14437, 14438, 5, 95, 0, 0, 14438, 14439, 7, 8, 0, 0, 14439, 14440, 7, 2, 0, 0, 14440, 14441, 7, 7, 0, 0, 14441, 14442, 7, 5, 0, 0, 14442, 14443, 7, 4, 0, 0, 14443, 14444, 5, 95, 0, 0, 14444, 14445, 7, 2, 0, 0, 14445, 14446, 7, 7, 0, 0, 14446, 1890, 1, 0, 0, 0, 14447, 14448, 7, 14, 0, 0, 14448, 14449, 7, 6, 0, 0, 14449, 14450, 7, 3, 0, 0, 14450, 14451, 7, 17, 0, 0, 14451, 14452, 7, 6, 0, 0, 14452, 1892, 1, 0, 0, 0, 14453, 14454, 7, 14, 0, 0, 14454, 14455, 7, 6, 0, 0, 14455, 14456, 7, 3, 0, 0, 14456, 14457, 7, 17, 0, 0, 14457, 14458, 7, 6, 0, 0, 14458, 14459, 5, 95, 0, 0, 14459, 14460, 7, 5, 0, 0, 14460, 14461, 7, 20, 0, 0, 14461, 1894, 1, 0, 0, 0, 14462, 14463, 7, 14, 0, 0, 14463, 14464, 7, 6, 0, 0, 14464, 14465, 7, 4, 0, 0, 14465, 14466, 7, 0, 0, 0, 14466, 14467, 7, 9, 0, 0, 14467, 14468, 7, 0, 0, 0, 14468, 14469, 7, 4, 0, 0, 14469, 14470, 7, 0, 0, 0, 14470, 1896, 1, 0, 0, 0, 14471, 14472, 7, 14, 0, 0, 14472, 14473, 7, 6, 0, 0, 14473, 14474, 7, 4, 0, 0, 14474, 14475, 7, 19, 0, 0, 14475, 14476, 7, 2, 0, 0, 14476, 14477, 7, 9, 0, 0, 14477, 1898, 1, 0, 0, 0, 14478, 14479, 7, 14, 0, 0, 14479, 14480, 7, 10, 0, 0, 14480, 14481, 7, 17, 0, 0, 14481, 14482, 7, 3, 0, 0, 14482, 14483, 7, 0, 0, 0, 14483, 14484, 7, 4, 0, 0, 14484, 14485, 7, 6, 0, 0, 14485, 1900, 1, 0, 0, 0, 14486, 14487, 7, 14, 0, 0, 14487, 14488, 7, 10, 0, 0, 14488, 14489, 7, 17, 0, 0, 14489, 14490, 7, 3, 0, 0, 14490, 14491, 7, 0, 0, 0, 14491, 14492, 7, 4, 0, 0, 14492, 14493, 7, 10, 0, 0, 14493, 14494, 7, 2, 0, 0, 14494, 14495, 7, 7, 0, 0, 14495, 1902, 1, 0, 0, 0, 14496, 14497, 7, 14, 0, 0, 14497, 14498, 7, 10, 0, 0, 14498, 14499, 7, 7, 0, 0, 14499, 14500, 7, 6, 0, 0, 14500, 14501, 7, 25, 0, 0, 14501, 14502, 7, 4, 0, 0, 14502, 14503, 7, 6, 0, 0, 14503, 14504, 7, 7, 0, 0, 14504, 14505, 7, 4, 0, 0, 14505, 14506, 7, 5, 0, 0, 14506, 1904, 1, 0, 0, 0, 14507, 14508, 7, 14, 0, 0, 14508, 14509, 7, 10, 0, 0, 14509, 14510, 7, 7, 0, 0, 14510, 14511, 7, 10, 0, 0, 14511, 14512, 7, 14, 0, 0, 14512, 14513, 7, 10, 0, 0, 14513, 14514, 7, 23, 0, 0, 14514, 14515, 7, 6, 0, 0, 14515, 1906, 1, 0, 0, 0, 14516, 14517, 7, 14, 0, 0, 14517, 14518, 7, 10, 0, 0, 14518, 14519, 7, 7, 0, 0, 14519, 14520, 7, 10, 0, 0, 14520, 14521, 7, 14, 0, 0, 14521, 14522, 7, 12, 0, 0, 14522, 14523, 7, 14, 0, 0, 14523, 1908, 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, 10, 0, 0, 14528, 14529, 7, 7, 0, 0, 14529, 14530, 7, 17, 0, 0, 14530, 1910, 1, 0, 0, 0, 14531, 14532, 7, 14, 0, 0, 14532, 14533, 7, 10, 0, 0, 14533, 14534, 7, 7, 0, 0, 14534, 14535, 7, 12, 0, 0, 14535, 14536, 7, 5, 0, 0, 14536, 1912, 1, 0, 0, 0, 14537, 14538, 7, 14, 0, 0, 14538, 14539, 7, 10, 0, 0, 14539, 14540, 7, 7, 0, 0, 14540, 14541, 7, 12, 0, 0, 14541, 14542, 7, 5, 0, 0, 14542, 14543, 5, 95, 0, 0, 14543, 14544, 7, 7, 0, 0, 14544, 14545, 7, 12, 0, 0, 14545, 14546, 7, 11, 0, 0, 14546, 14547, 7, 11, 0, 0, 14547, 1914, 1, 0, 0, 0, 14548, 14549, 7, 14, 0, 0, 14549, 14550, 7, 10, 0, 0, 14550, 14551, 7, 7, 0, 0, 14551, 14552, 7, 12, 0, 0, 14552, 14553, 7, 4, 0, 0, 14553, 14554, 7, 6, 0, 0, 14554, 1916, 1, 0, 0, 0, 14555, 14556, 7, 14, 0, 0, 14556, 14557, 7, 10, 0, 0, 14557, 14558, 7, 7, 0, 0, 14558, 14559, 7, 12, 0, 0, 14559, 14560, 7, 4, 0, 0, 14560, 14561, 7, 6, 0, 0, 14561, 14562, 7, 5, 0, 0, 14562, 1918, 1, 0, 0, 0, 14563, 14564, 7, 14, 0, 0, 14564, 14565, 7, 10, 0, 0, 14565, 14566, 7, 7, 0, 0, 14566, 14567, 7, 13, 0, 0, 14567, 14568, 7, 0, 0, 0, 14568, 14569, 7, 11, 0, 0, 14569, 14570, 7, 12, 0, 0, 14570, 14571, 7, 6, 0, 0, 14571, 1920, 1, 0, 0, 0, 14572, 14573, 7, 14, 0, 0, 14573, 14574, 7, 10, 0, 0, 14574, 14575, 7, 3, 0, 0, 14575, 14576, 7, 3, 0, 0, 14576, 14577, 7, 2, 0, 0, 14577, 14578, 7, 3, 0, 0, 14578, 14579, 7, 8, 0, 0, 14579, 14580, 7, 2, 0, 0, 14580, 14581, 7, 11, 0, 0, 14581, 14582, 7, 9, 0, 0, 14582, 1922, 1, 0, 0, 0, 14583, 14584, 7, 14, 0, 0, 14584, 14585, 7, 10, 0, 0, 14585, 14586, 7, 3, 0, 0, 14586, 14587, 7, 3, 0, 0, 14587, 14588, 7, 2, 0, 0, 14588, 14589, 7, 3, 0, 0, 14589, 14590, 7, 19, 0, 0, 14590, 14591, 7, 2, 0, 0, 14591, 14592, 7, 4, 0, 0, 14592, 1924, 1, 0, 0, 0, 14593, 14594, 7, 14, 0, 0, 14594, 14595, 7, 10, 0, 0, 14595, 14596, 7, 3, 0, 0, 14596, 14597, 7, 3, 0, 0, 14597, 14598, 7, 2, 0, 0, 14598, 14599, 7, 3, 0, 0, 14599, 1926, 1, 0, 0, 0, 14600, 14601, 7, 14, 0, 0, 14601, 14602, 7, 10, 0, 0, 14602, 14603, 7, 5, 0, 0, 14603, 14604, 7, 5, 0, 0, 14604, 14605, 7, 10, 0, 0, 14605, 14606, 7, 7, 0, 0, 14606, 14607, 7, 17, 0, 0, 14607, 1928, 1, 0, 0, 0, 14608, 14609, 7, 14, 0, 0, 14609, 14610, 7, 10, 0, 0, 14610, 14611, 7, 5, 0, 0, 14611, 14612, 7, 14, 0, 0, 14612, 14613, 7, 0, 0, 0, 14613, 14614, 7, 4, 0, 0, 14614, 14615, 7, 8, 0, 0, 14615, 14616, 7, 19, 0, 0, 14616, 1930, 1, 0, 0, 0, 14617, 14618, 7, 14, 0, 0, 14618, 14619, 7, 11, 0, 0, 14619, 14620, 7, 5, 0, 0, 14620, 14621, 7, 11, 0, 0, 14621, 14622, 7, 0, 0, 0, 14622, 14623, 7, 1, 0, 0, 14623, 14624, 7, 6, 0, 0, 14624, 14625, 7, 11, 0, 0, 14625, 1932, 1, 0, 0, 0, 14626, 14627, 7, 14, 0, 0, 14627, 14628, 7, 2, 0, 0, 14628, 14629, 7, 9, 0, 0, 14629, 14630, 7, 6, 0, 0, 14630, 14631, 7, 11, 0, 0, 14631, 14632, 5, 95, 0, 0, 14632, 14633, 7, 8, 0, 0, 14633, 14634, 7, 2, 0, 0, 14634, 14635, 7, 14, 0, 0, 14635, 14636, 7, 15, 0, 0, 14636, 14637, 7, 10, 0, 0, 14637, 14638, 7, 11, 0, 0, 14638, 14639, 7, 6, 0, 0, 14639, 14640, 5, 95, 0, 0, 14640, 14641, 7, 5, 0, 0, 14641, 14642, 7, 12, 0, 0, 14642, 14643, 7, 1, 0, 0, 14643, 14644, 7, 24, 0, 0, 14644, 14645, 7, 12, 0, 0, 14645, 14646, 7, 6, 0, 0, 14646, 14647, 7, 3, 0, 0, 14647, 14648, 7, 18, 0, 0, 14648, 1934, 1, 0, 0, 0, 14649, 14650, 7, 14, 0, 0, 14650, 14651, 7, 2, 0, 0, 14651, 14652, 7, 9, 0, 0, 14652, 14653, 7, 6, 0, 0, 14653, 14654, 7, 11, 0, 0, 14654, 14655, 5, 95, 0, 0, 14655, 14656, 7, 9, 0, 0, 14656, 14657, 7, 2, 0, 0, 14657, 14658, 7, 7, 0, 0, 14658, 14659, 7, 4, 0, 0, 14659, 14660, 7, 13, 0, 0, 14660, 14661, 7, 6, 0, 0, 14661, 14662, 7, 3, 0, 0, 14662, 14663, 7, 10, 0, 0, 14663, 14664, 7, 16, 0, 0, 14664, 14665, 7, 18, 0, 0, 14665, 14666, 5, 95, 0, 0, 14666, 14667, 7, 12, 0, 0, 14667, 14668, 7, 7, 0, 0, 14668, 14669, 7, 10, 0, 0, 14669, 14670, 7, 24, 0, 0, 14670, 14671, 7, 12, 0, 0, 14671, 14672, 7, 6, 0, 0, 14672, 14673, 7, 7, 0, 0, 14673, 14674, 7, 6, 0, 0, 14674, 14675, 7, 5, 0, 0, 14675, 14676, 7, 5, 0, 0, 14676, 1936, 1, 0, 0, 0, 14677, 14678, 7, 14, 0, 0, 14678, 14679, 7, 2, 0, 0, 14679, 14680, 7, 9, 0, 0, 14680, 14681, 7, 6, 0, 0, 14681, 14682, 7, 11, 0, 0, 14682, 14683, 5, 95, 0, 0, 14683, 14684, 7, 9, 0, 0, 14684, 14685, 7, 18, 0, 0, 14685, 14686, 7, 7, 0, 0, 14686, 14687, 7, 0, 0, 0, 14687, 14688, 7, 14, 0, 0, 14688, 14689, 7, 10, 0, 0, 14689, 14690, 7, 8, 0, 0, 14690, 14691, 5, 95, 0, 0, 14691, 14692, 7, 5, 0, 0, 14692, 14693, 7, 12, 0, 0, 14693, 14694, 7, 1, 0, 0, 14694, 14695, 7, 24, 0, 0, 14695, 14696, 7, 12, 0, 0, 14696, 14697, 7, 6, 0, 0, 14697, 14698, 7, 3, 0, 0, 14698, 14699, 7, 18, 0, 0, 14699, 1938, 1, 0, 0, 0, 14700, 14701, 7, 14, 0, 0, 14701, 14702, 7, 2, 0, 0, 14702, 14703, 7, 9, 0, 0, 14703, 14704, 7, 6, 0, 0, 14704, 14705, 7, 11, 0, 0, 14705, 14706, 5, 95, 0, 0, 14706, 14707, 7, 14, 0, 0, 14707, 14708, 7, 10, 0, 0, 14708, 14709, 7, 7, 0, 0, 14709, 14710, 5, 95, 0, 0, 14710, 14711, 7, 0, 0, 0, 14711, 14712, 7, 7, 0, 0, 14712, 14713, 7, 0, 0, 0, 14713, 14714, 7, 11, 0, 0, 14714, 14715, 7, 18, 0, 0, 14715, 14716, 7, 5, 0, 0, 14716, 14717, 7, 10, 0, 0, 14717, 14718, 7, 5, 0, 0, 14718, 1940, 1, 0, 0, 0, 14719, 14720, 7, 14, 0, 0, 14720, 14721, 7, 2, 0, 0, 14721, 14722, 7, 9, 0, 0, 14722, 14723, 7, 6, 0, 0, 14723, 14724, 7, 11, 0, 0, 14724, 1942, 1, 0, 0, 0, 14725, 14726, 7, 14, 0, 0, 14726, 14727, 7, 2, 0, 0, 14727, 14728, 7, 9, 0, 0, 14728, 14729, 7, 6, 0, 0, 14729, 14730, 7, 11, 0, 0, 14730, 14731, 5, 95, 0, 0, 14731, 14732, 7, 7, 0, 0, 14732, 14733, 7, 1, 0, 0, 14733, 1944, 1, 0, 0, 0, 14734, 14735, 7, 14, 0, 0, 14735, 14736, 7, 2, 0, 0, 14736, 14737, 7, 9, 0, 0, 14737, 14738, 7, 6, 0, 0, 14738, 14739, 7, 11, 0, 0, 14739, 14740, 5, 95, 0, 0, 14740, 14741, 7, 7, 0, 0, 14741, 14742, 7, 2, 0, 0, 14742, 14743, 5, 95, 0, 0, 14743, 14744, 7, 0, 0, 0, 14744, 14745, 7, 7, 0, 0, 14745, 14746, 7, 0, 0, 0, 14746, 14747, 7, 11, 0, 0, 14747, 14748, 7, 18, 0, 0, 14748, 14749, 7, 5, 0, 0, 14749, 14750, 7, 10, 0, 0, 14750, 14751, 7, 5, 0, 0, 14751, 1946, 1, 0, 0, 0, 14752, 14753, 7, 14, 0, 0, 14753, 14754, 7, 2, 0, 0, 14754, 14755, 7, 9, 0, 0, 14755, 14756, 7, 6, 0, 0, 14756, 14757, 7, 11, 0, 0, 14757, 14758, 5, 95, 0, 0, 14758, 14759, 7, 15, 0, 0, 14759, 14760, 7, 1, 0, 0, 14760, 14761, 7, 18, 0, 0, 14761, 1948, 1, 0, 0, 0, 14762, 14763, 7, 14, 0, 0, 14763, 14764, 7, 2, 0, 0, 14764, 14765, 7, 9, 0, 0, 14765, 14766, 7, 6, 0, 0, 14766, 14767, 7, 11, 0, 0, 14767, 14768, 5, 95, 0, 0, 14768, 14769, 7, 15, 0, 0, 14769, 14770, 7, 12, 0, 0, 14770, 14771, 7, 5, 0, 0, 14771, 14772, 7, 19, 0, 0, 14772, 14773, 5, 95, 0, 0, 14773, 14774, 7, 3, 0, 0, 14774, 14775, 7, 6, 0, 0, 14775, 14776, 7, 16, 0, 0, 14776, 1950, 1, 0, 0, 0, 14777, 14778, 7, 14, 0, 0, 14778, 14779, 7, 2, 0, 0, 14779, 14780, 7, 9, 0, 0, 14780, 14781, 7, 6, 0, 0, 14781, 14782, 7, 11, 0, 0, 14782, 14783, 5, 95, 0, 0, 14783, 14784, 7, 5, 0, 0, 14784, 14785, 7, 13, 0, 0, 14785, 1952, 1, 0, 0, 0, 14786, 14787, 7, 14, 0, 0, 14787, 14788, 7, 2, 0, 0, 14788, 14789, 7, 9, 0, 0, 14789, 14790, 7, 6, 0, 0, 14790, 1954, 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, 10, 0, 0, 14797, 14798, 7, 8, 0, 0, 14798, 14799, 7, 0, 0, 0, 14799, 14800, 7, 4, 0, 0, 14800, 14801, 7, 10, 0, 0, 14801, 14802, 7, 2, 0, 0, 14802, 14803, 7, 7, 0, 0, 14803, 1956, 1, 0, 0, 0, 14804, 14805, 7, 14, 0, 0, 14805, 14806, 7, 2, 0, 0, 14806, 14807, 7, 9, 0, 0, 14807, 14808, 7, 10, 0, 0, 14808, 14809, 7, 16, 0, 0, 14809, 14810, 7, 18, 0, 0, 14810, 14811, 5, 95, 0, 0, 14811, 14812, 7, 8, 0, 0, 14812, 14813, 7, 2, 0, 0, 14813, 14814, 7, 11, 0, 0, 14814, 14815, 7, 12, 0, 0, 14815, 14816, 7, 14, 0, 0, 14816, 14817, 7, 7, 0, 0, 14817, 14818, 5, 95, 0, 0, 14818, 14819, 7, 4, 0, 0, 14819, 14820, 7, 18, 0, 0, 14820, 14821, 7, 15, 0, 0, 14821, 14822, 7, 6, 0, 0, 14822, 1958, 1, 0, 0, 0, 14823, 14824, 7, 14, 0, 0, 14824, 14825, 7, 2, 0, 0, 14825, 14826, 7, 9, 0, 0, 14826, 14827, 7, 10, 0, 0, 14827, 14828, 7, 16, 0, 0, 14828, 14829, 7, 18, 0, 0, 14829, 1960, 1, 0, 0, 0, 14830, 14831, 7, 14, 0, 0, 14831, 14832, 7, 2, 0, 0, 14832, 14833, 7, 9, 0, 0, 14833, 1962, 1, 0, 0, 0, 14834, 14835, 7, 14, 0, 0, 14835, 14836, 7, 2, 0, 0, 14836, 14837, 7, 9, 0, 0, 14837, 14838, 7, 12, 0, 0, 14838, 14839, 7, 11, 0, 0, 14839, 14840, 7, 6, 0, 0, 14840, 1964, 1, 0, 0, 0, 14841, 14842, 7, 14, 0, 0, 14842, 14843, 7, 2, 0, 0, 14843, 14844, 7, 7, 0, 0, 14844, 14845, 7, 10, 0, 0, 14845, 14846, 7, 4, 0, 0, 14846, 14847, 7, 2, 0, 0, 14847, 14848, 7, 3, 0, 0, 14848, 14849, 7, 10, 0, 0, 14849, 14850, 7, 7, 0, 0, 14850, 14851, 7, 17, 0, 0, 14851, 1966, 1, 0, 0, 0, 14852, 14853, 7, 14, 0, 0, 14853, 14854, 7, 2, 0, 0, 14854, 14855, 7, 7, 0, 0, 14855, 14856, 7, 10, 0, 0, 14856, 14857, 7, 4, 0, 0, 14857, 14858, 7, 2, 0, 0, 14858, 14859, 7, 3, 0, 0, 14859, 1968, 1, 0, 0, 0, 14860, 14861, 7, 14, 0, 0, 14861, 14862, 7, 2, 0, 0, 14862, 14863, 7, 7, 0, 0, 14863, 14864, 7, 4, 0, 0, 14864, 14865, 7, 19, 0, 0, 14865, 1970, 1, 0, 0, 0, 14866, 14867, 7, 14, 0, 0, 14867, 14868, 7, 2, 0, 0, 14868, 14869, 7, 7, 0, 0, 14869, 14870, 7, 4, 0, 0, 14870, 14871, 7, 19, 0, 0, 14871, 14872, 7, 5, 0, 0, 14872, 14873, 5, 95, 0, 0, 14873, 14874, 7, 1, 0, 0, 14874, 14875, 7, 6, 0, 0, 14875, 14876, 7, 4, 0, 0, 14876, 14877, 7, 22, 0, 0, 14877, 14878, 7, 6, 0, 0, 14878, 14879, 7, 6, 0, 0, 14879, 14880, 7, 7, 0, 0, 14880, 1972, 1, 0, 0, 0, 14881, 14882, 7, 14, 0, 0, 14882, 14883, 7, 2, 0, 0, 14883, 14884, 7, 7, 0, 0, 14884, 14885, 7, 4, 0, 0, 14885, 14886, 7, 19, 0, 0, 14886, 14887, 7, 5, 0, 0, 14887, 1974, 1, 0, 0, 0, 14888, 14889, 7, 14, 0, 0, 14889, 14890, 7, 2, 0, 0, 14890, 14891, 7, 12, 0, 0, 14891, 14892, 7, 7, 0, 0, 14892, 14893, 7, 4, 0, 0, 14893, 1976, 1, 0, 0, 0, 14894, 14895, 7, 14, 0, 0, 14895, 14896, 7, 2, 0, 0, 14896, 14897, 7, 12, 0, 0, 14897, 14898, 7, 7, 0, 0, 14898, 14899, 7, 4, 0, 0, 14899, 14900, 7, 15, 0, 0, 14900, 14901, 7, 0, 0, 0, 14901, 14902, 7, 4, 0, 0, 14902, 14903, 7, 19, 0, 0, 14903, 1978, 1, 0, 0, 0, 14904, 14905, 7, 14, 0, 0, 14905, 14906, 7, 2, 0, 0, 14906, 14907, 7, 12, 0, 0, 14907, 14908, 7, 7, 0, 0, 14908, 14909, 7, 4, 0, 0, 14909, 14910, 7, 15, 0, 0, 14910, 14911, 7, 2, 0, 0, 14911, 14912, 7, 10, 0, 0, 14912, 14913, 7, 7, 0, 0, 14913, 14914, 7, 4, 0, 0, 14914, 1980, 1, 0, 0, 0, 14915, 14916, 7, 14, 0, 0, 14916, 14917, 7, 2, 0, 0, 14917, 14918, 7, 13, 0, 0, 14918, 14919, 7, 6, 0, 0, 14919, 14920, 7, 14, 0, 0, 14920, 14921, 7, 6, 0, 0, 14921, 14922, 7, 7, 0, 0, 14922, 14923, 7, 4, 0, 0, 14923, 1982, 1, 0, 0, 0, 14924, 14925, 7, 14, 0, 0, 14925, 14926, 7, 2, 0, 0, 14926, 14927, 7, 13, 0, 0, 14927, 14928, 7, 6, 0, 0, 14928, 1984, 1, 0, 0, 0, 14929, 14930, 7, 14, 0, 0, 14930, 14931, 7, 12, 0, 0, 14931, 14932, 7, 11, 0, 0, 14932, 14933, 7, 4, 0, 0, 14933, 14934, 7, 10, 0, 0, 14934, 14935, 7, 9, 0, 0, 14935, 14936, 7, 10, 0, 0, 14936, 14937, 7, 14, 0, 0, 14937, 14938, 7, 6, 0, 0, 14938, 14939, 7, 7, 0, 0, 14939, 14940, 7, 5, 0, 0, 14940, 14941, 7, 10, 0, 0, 14941, 14942, 7, 2, 0, 0, 14942, 14943, 7, 7, 0, 0, 14943, 14944, 7, 0, 0, 0, 14944, 14945, 7, 11, 0, 0, 14945, 1986, 1, 0, 0, 0, 14946, 14947, 7, 14, 0, 0, 14947, 14948, 7, 12, 0, 0, 14948, 14949, 7, 11, 0, 0, 14949, 14950, 7, 4, 0, 0, 14950, 14951, 7, 10, 0, 0, 14951, 14952, 7, 5, 0, 0, 14952, 14953, 7, 6, 0, 0, 14953, 14954, 7, 4, 0, 0, 14954, 1988, 1, 0, 0, 0, 14955, 14956, 7, 14, 0, 0, 14956, 14957, 7, 13, 0, 0, 14957, 14958, 5, 95, 0, 0, 14958, 14959, 7, 14, 0, 0, 14959, 14960, 7, 6, 0, 0, 14960, 14961, 7, 3, 0, 0, 14961, 14962, 7, 17, 0, 0, 14962, 14963, 7, 6, 0, 0, 14963, 1990, 1, 0, 0, 0, 14964, 14965, 7, 7, 0, 0, 14965, 14966, 7, 0, 0, 0, 14966, 14967, 7, 14, 0, 0, 14967, 14968, 7, 6, 0, 0, 14968, 14969, 7, 9, 0, 0, 14969, 1992, 1, 0, 0, 0, 14970, 14971, 7, 7, 0, 0, 14971, 14972, 7, 0, 0, 0, 14972, 14973, 7, 14, 0, 0, 14973, 14974, 7, 6, 0, 0, 14974, 1994, 1, 0, 0, 0, 14975, 14976, 7, 7, 0, 0, 14976, 14977, 7, 0, 0, 0, 14977, 14978, 7, 14, 0, 0, 14978, 14979, 7, 6, 0, 0, 14979, 14980, 7, 5, 0, 0, 14980, 14981, 7, 15, 0, 0, 14981, 14982, 7, 0, 0, 0, 14982, 14983, 7, 8, 0, 0, 14983, 14984, 7, 6, 0, 0, 14984, 1996, 1, 0, 0, 0, 14985, 14986, 7, 7, 0, 0, 14986, 14987, 7, 0, 0, 0, 14987, 14988, 7, 7, 0, 0, 14988, 1998, 1, 0, 0, 0, 14989, 14990, 7, 7, 0, 0, 14990, 14991, 7, 0, 0, 0, 14991, 14992, 7, 7, 0, 0, 14992, 14993, 7, 13, 0, 0, 14993, 14994, 7, 11, 0, 0, 14994, 2000, 1, 0, 0, 0, 14995, 14996, 7, 7, 0, 0, 14996, 14997, 7, 0, 0, 0, 14997, 14998, 7, 4, 0, 0, 14998, 14999, 7, 10, 0, 0, 14999, 15000, 7, 2, 0, 0, 15000, 15001, 7, 7, 0, 0, 15001, 15002, 7, 0, 0, 0, 15002, 15003, 7, 11, 0, 0, 15003, 2002, 1, 0, 0, 0, 15004, 15005, 7, 7, 0, 0, 15005, 15006, 7, 0, 0, 0, 15006, 15007, 7, 4, 0, 0, 15007, 15008, 7, 10, 0, 0, 15008, 15009, 7, 13, 0, 0, 15009, 15010, 7, 6, 0, 0, 15010, 15011, 5, 95, 0, 0, 15011, 15012, 7, 16, 0, 0, 15012, 15013, 7, 12, 0, 0, 15013, 15014, 7, 11, 0, 0, 15014, 15015, 7, 11, 0, 0, 15015, 15016, 5, 95, 0, 0, 15016, 15017, 7, 2, 0, 0, 15017, 15018, 7, 12, 0, 0, 15018, 15019, 7, 4, 0, 0, 15019, 15020, 7, 6, 0, 0, 15020, 15021, 7, 3, 0, 0, 15021, 15022, 5, 95, 0, 0, 15022, 15023, 7, 20, 0, 0, 15023, 15024, 7, 2, 0, 0, 15024, 15025, 7, 10, 0, 0, 15025, 15026, 7, 7, 0, 0, 15026, 2004, 1, 0, 0, 0, 15027, 15028, 7, 7, 0, 0, 15028, 15029, 7, 0, 0, 0, 15029, 15030, 7, 4, 0, 0, 15030, 15031, 7, 10, 0, 0, 15031, 15032, 7, 13, 0, 0, 15032, 15033, 7, 6, 0, 0, 15033, 2006, 1, 0, 0, 0, 15034, 15035, 7, 7, 0, 0, 15035, 15036, 7, 0, 0, 0, 15036, 15037, 7, 4, 0, 0, 15037, 15038, 7, 12, 0, 0, 15038, 15039, 7, 3, 0, 0, 15039, 15040, 7, 0, 0, 0, 15040, 15041, 7, 11, 0, 0, 15041, 2008, 1, 0, 0, 0, 15042, 15043, 7, 7, 0, 0, 15043, 15044, 7, 0, 0, 0, 15044, 15045, 7, 4, 0, 0, 15045, 15046, 7, 12, 0, 0, 15046, 15047, 7, 3, 0, 0, 15047, 15048, 7, 0, 0, 0, 15048, 15049, 7, 11, 0, 0, 15049, 15050, 7, 7, 0, 0, 15050, 2010, 1, 0, 0, 0, 15051, 15052, 7, 7, 0, 0, 15052, 15053, 7, 0, 0, 0, 15053, 15054, 7, 13, 0, 0, 15054, 2012, 1, 0, 0, 0, 15055, 15056, 7, 7, 0, 0, 15056, 15057, 7, 8, 0, 0, 15057, 15058, 7, 19, 0, 0, 15058, 15059, 7, 0, 0, 0, 15059, 15060, 7, 3, 0, 0, 15060, 15061, 5, 95, 0, 0, 15061, 15062, 7, 8, 0, 0, 15062, 15063, 7, 5, 0, 0, 15063, 2014, 1, 0, 0, 0, 15064, 15065, 7, 7, 0, 0, 15065, 15066, 7, 8, 0, 0, 15066, 15067, 7, 19, 0, 0, 15067, 15068, 7, 0, 0, 0, 15068, 15069, 7, 3, 0, 0, 15069, 2016, 1, 0, 0, 0, 15070, 15071, 7, 7, 0, 0, 15071, 15072, 7, 8, 0, 0, 15072, 15073, 7, 19, 0, 0, 15073, 15074, 7, 3, 0, 0, 15074, 2018, 1, 0, 0, 0, 15075, 15076, 7, 7, 0, 0, 15076, 15077, 7, 8, 0, 0, 15077, 15078, 7, 11, 0, 0, 15078, 15079, 7, 2, 0, 0, 15079, 15080, 7, 1, 0, 0, 15080, 2020, 1, 0, 0, 0, 15081, 15082, 7, 7, 0, 0, 15082, 15083, 7, 6, 0, 0, 15083, 15084, 7, 6, 0, 0, 15084, 15085, 7, 9, 0, 0, 15085, 15086, 7, 6, 0, 0, 15086, 15087, 7, 9, 0, 0, 15087, 2022, 1, 0, 0, 0, 15088, 15089, 7, 7, 0, 0, 15089, 15090, 7, 6, 0, 0, 15090, 15091, 7, 17, 0, 0, 15091, 2024, 1, 0, 0, 0, 15092, 15093, 7, 7, 0, 0, 15093, 15094, 7, 6, 0, 0, 15094, 15095, 7, 5, 0, 0, 15095, 15096, 7, 4, 0, 0, 15096, 15097, 7, 6, 0, 0, 15097, 15098, 7, 9, 0, 0, 15098, 2026, 1, 0, 0, 0, 15099, 15100, 7, 7, 0, 0, 15100, 15101, 7, 6, 0, 0, 15101, 15102, 7, 5, 0, 0, 15102, 15103, 7, 4, 0, 0, 15103, 15104, 7, 6, 0, 0, 15104, 15105, 7, 9, 0, 0, 15105, 15106, 5, 95, 0, 0, 15106, 15107, 7, 4, 0, 0, 15107, 15108, 7, 0, 0, 0, 15108, 15109, 7, 1, 0, 0, 15109, 15110, 7, 11, 0, 0, 15110, 15111, 7, 6, 0, 0, 15111, 15112, 5, 95, 0, 0, 15112, 15113, 7, 16, 0, 0, 15113, 15114, 7, 0, 0, 0, 15114, 15115, 7, 5, 0, 0, 15115, 15116, 7, 4, 0, 0, 15116, 15117, 5, 95, 0, 0, 15117, 15118, 7, 10, 0, 0, 15118, 15119, 7, 7, 0, 0, 15119, 15120, 7, 5, 0, 0, 15120, 15121, 7, 6, 0, 0, 15121, 15122, 7, 3, 0, 0, 15122, 15123, 7, 4, 0, 0, 15123, 2028, 1, 0, 0, 0, 15124, 15125, 7, 7, 0, 0, 15125, 15126, 7, 6, 0, 0, 15126, 15127, 7, 5, 0, 0, 15127, 15128, 7, 4, 0, 0, 15128, 15129, 7, 6, 0, 0, 15129, 15130, 7, 9, 0, 0, 15130, 15131, 5, 95, 0, 0, 15131, 15132, 7, 4, 0, 0, 15132, 15133, 7, 0, 0, 0, 15133, 15134, 7, 1, 0, 0, 15134, 15135, 7, 11, 0, 0, 15135, 15136, 7, 6, 0, 0, 15136, 15137, 5, 95, 0, 0, 15137, 15138, 7, 17, 0, 0, 15138, 15139, 7, 6, 0, 0, 15139, 15140, 7, 4, 0, 0, 15140, 15141, 5, 95, 0, 0, 15141, 15142, 7, 3, 0, 0, 15142, 15143, 7, 6, 0, 0, 15143, 15144, 7, 16, 0, 0, 15144, 15145, 7, 5, 0, 0, 15145, 2030, 1, 0, 0, 0, 15146, 15147, 7, 7, 0, 0, 15147, 15148, 7, 6, 0, 0, 15148, 15149, 7, 5, 0, 0, 15149, 15150, 7, 4, 0, 0, 15150, 15151, 7, 6, 0, 0, 15151, 15152, 7, 9, 0, 0, 15152, 15153, 5, 95, 0, 0, 15153, 15154, 7, 4, 0, 0, 15154, 15155, 7, 0, 0, 0, 15155, 15156, 7, 1, 0, 0, 15156, 15157, 7, 11, 0, 0, 15157, 15158, 7, 6, 0, 0, 15158, 15159, 5, 95, 0, 0, 15159, 15160, 7, 10, 0, 0, 15160, 15161, 7, 9, 0, 0, 15161, 2032, 1, 0, 0, 0, 15162, 15163, 7, 7, 0, 0, 15163, 15164, 7, 6, 0, 0, 15164, 15165, 7, 5, 0, 0, 15165, 15166, 7, 4, 0, 0, 15166, 15167, 7, 6, 0, 0, 15167, 15168, 7, 9, 0, 0, 15168, 15169, 5, 95, 0, 0, 15169, 15170, 7, 4, 0, 0, 15170, 15171, 7, 0, 0, 0, 15171, 15172, 7, 1, 0, 0, 15172, 15173, 7, 11, 0, 0, 15173, 15174, 7, 6, 0, 0, 15174, 15175, 5, 95, 0, 0, 15175, 15176, 7, 5, 0, 0, 15176, 15177, 7, 6, 0, 0, 15177, 15178, 7, 4, 0, 0, 15178, 15179, 5, 95, 0, 0, 15179, 15180, 7, 3, 0, 0, 15180, 15181, 7, 6, 0, 0, 15181, 15182, 7, 16, 0, 0, 15182, 15183, 7, 5, 0, 0, 15183, 2034, 1, 0, 0, 0, 15184, 15185, 7, 7, 0, 0, 15185, 15186, 7, 6, 0, 0, 15186, 15187, 7, 5, 0, 0, 15187, 15188, 7, 4, 0, 0, 15188, 15189, 7, 6, 0, 0, 15189, 15190, 7, 9, 0, 0, 15190, 15191, 5, 95, 0, 0, 15191, 15192, 7, 4, 0, 0, 15192, 15193, 7, 0, 0, 0, 15193, 15194, 7, 1, 0, 0, 15194, 15195, 7, 11, 0, 0, 15195, 15196, 7, 6, 0, 0, 15196, 15197, 5, 95, 0, 0, 15197, 15198, 7, 5, 0, 0, 15198, 15199, 7, 6, 0, 0, 15199, 15200, 7, 4, 0, 0, 15200, 15201, 5, 95, 0, 0, 15201, 15202, 7, 5, 0, 0, 15202, 15203, 7, 6, 0, 0, 15203, 15204, 7, 4, 0, 0, 15204, 15205, 7, 10, 0, 0, 15205, 15206, 7, 9, 0, 0, 15206, 2036, 1, 0, 0, 0, 15207, 15208, 7, 7, 0, 0, 15208, 15209, 7, 6, 0, 0, 15209, 15210, 7, 4, 0, 0, 15210, 15211, 7, 22, 0, 0, 15211, 15212, 7, 2, 0, 0, 15212, 15213, 7, 3, 0, 0, 15213, 15214, 7, 21, 0, 0, 15214, 2038, 1, 0, 0, 0, 15215, 15216, 7, 7, 0, 0, 15216, 15217, 7, 6, 0, 0, 15217, 15218, 7, 13, 0, 0, 15218, 15219, 7, 6, 0, 0, 15219, 15220, 7, 3, 0, 0, 15220, 2040, 1, 0, 0, 0, 15221, 15222, 7, 7, 0, 0, 15222, 15223, 7, 6, 0, 0, 15223, 15224, 7, 22, 0, 0, 15224, 2042, 1, 0, 0, 0, 15225, 15226, 7, 7, 0, 0, 15226, 15227, 7, 6, 0, 0, 15227, 15228, 7, 22, 0, 0, 15228, 15229, 7, 11, 0, 0, 15229, 15230, 7, 10, 0, 0, 15230, 15231, 7, 7, 0, 0, 15231, 15232, 7, 6, 0, 0, 15232, 2044, 1, 0, 0, 0, 15233, 15234, 7, 7, 0, 0, 15234, 15235, 7, 6, 0, 0, 15235, 15236, 7, 22, 0, 0, 15236, 15237, 5, 95, 0, 0, 15237, 15238, 7, 4, 0, 0, 15238, 15239, 7, 10, 0, 0, 15239, 15240, 7, 14, 0, 0, 15240, 15241, 7, 6, 0, 0, 15241, 2046, 1, 0, 0, 0, 15242, 15243, 7, 7, 0, 0, 15243, 15244, 7, 6, 0, 0, 15244, 15245, 7, 25, 0, 0, 15245, 15246, 7, 4, 0, 0, 15246, 15247, 5, 95, 0, 0, 15247, 15248, 7, 9, 0, 0, 15248, 15249, 7, 0, 0, 0, 15249, 15250, 7, 18, 0, 0, 15250, 2048, 1, 0, 0, 0, 15251, 15252, 7, 7, 0, 0, 15252, 15253, 7, 6, 0, 0, 15253, 15254, 7, 25, 0, 0, 15254, 15255, 7, 4, 0, 0, 15255, 2050, 1, 0, 0, 0, 15256, 15257, 7, 7, 0, 0, 15257, 15258, 7, 11, 0, 0, 15258, 15259, 5, 95, 0, 0, 15259, 15260, 7, 0, 0, 0, 15260, 15261, 7, 20, 0, 0, 15261, 2052, 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, 1, 0, 0, 15267, 15268, 7, 0, 0, 0, 15268, 15269, 7, 4, 0, 0, 15269, 15270, 7, 8, 0, 0, 15270, 15271, 7, 19, 0, 0, 15271, 15272, 7, 10, 0, 0, 15272, 15273, 7, 7, 0, 0, 15273, 15274, 7, 17, 0, 0, 15274, 2054, 1, 0, 0, 0, 15275, 15276, 7, 7, 0, 0, 15276, 15277, 7, 11, 0, 0, 15277, 15278, 7, 20, 0, 0, 15278, 15279, 5, 95, 0, 0, 15279, 15280, 7, 10, 0, 0, 15280, 15281, 7, 7, 0, 0, 15281, 15282, 7, 9, 0, 0, 15282, 15283, 7, 6, 0, 0, 15283, 15284, 7, 25, 0, 0, 15284, 15285, 5, 95, 0, 0, 15285, 15286, 7, 16, 0, 0, 15286, 15287, 7, 10, 0, 0, 15287, 15288, 7, 11, 0, 0, 15288, 15289, 7, 4, 0, 0, 15289, 15290, 7, 6, 0, 0, 15290, 15291, 7, 3, 0, 0, 15291, 2056, 1, 0, 0, 0, 15292, 15293, 7, 7, 0, 0, 15293, 15294, 7, 11, 0, 0, 15294, 15295, 7, 20, 0, 0, 15295, 15296, 5, 95, 0, 0, 15296, 15297, 7, 10, 0, 0, 15297, 15298, 7, 7, 0, 0, 15298, 15299, 7, 9, 0, 0, 15299, 15300, 7, 6, 0, 0, 15300, 15301, 7, 25, 0, 0, 15301, 15302, 5, 95, 0, 0, 15302, 15303, 7, 5, 0, 0, 15303, 15304, 7, 8, 0, 0, 15304, 15305, 7, 0, 0, 0, 15305, 15306, 7, 7, 0, 0, 15306, 2058, 1, 0, 0, 0, 15307, 15308, 7, 7, 0, 0, 15308, 15309, 7, 11, 0, 0, 15309, 15310, 7, 20, 0, 0, 15310, 15311, 5, 95, 0, 0, 15311, 15312, 7, 15, 0, 0, 15312, 15313, 7, 3, 0, 0, 15313, 15314, 7, 6, 0, 0, 15314, 15315, 7, 16, 0, 0, 15315, 15316, 7, 6, 0, 0, 15316, 15317, 7, 4, 0, 0, 15317, 15318, 7, 8, 0, 0, 15318, 15319, 7, 19, 0, 0, 15319, 2060, 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, 0, 0, 0, 15326, 15327, 7, 11, 0, 0, 15327, 15328, 7, 6, 0, 0, 15328, 15329, 7, 7, 0, 0, 15329, 15330, 7, 9, 0, 0, 15330, 15331, 7, 0, 0, 0, 15331, 15332, 7, 3, 0, 0, 15332, 2062, 1, 0, 0, 0, 15333, 15334, 7, 7, 0, 0, 15334, 15335, 7, 11, 0, 0, 15335, 15336, 7, 5, 0, 0, 15336, 15337, 5, 95, 0, 0, 15337, 15338, 7, 8, 0, 0, 15338, 15339, 7, 19, 0, 0, 15339, 15340, 7, 0, 0, 0, 15340, 15341, 7, 3, 0, 0, 15341, 15342, 7, 0, 0, 0, 15342, 15343, 7, 8, 0, 0, 15343, 15344, 7, 4, 0, 0, 15344, 15345, 7, 6, 0, 0, 15345, 15346, 7, 3, 0, 0, 15346, 15347, 7, 5, 0, 0, 15347, 15348, 7, 6, 0, 0, 15348, 15349, 7, 4, 0, 0, 15349, 2064, 1, 0, 0, 0, 15350, 15351, 7, 7, 0, 0, 15351, 15352, 7, 11, 0, 0, 15352, 15353, 7, 5, 0, 0, 15353, 15354, 5, 95, 0, 0, 15354, 15355, 7, 8, 0, 0, 15355, 15356, 7, 19, 0, 0, 15356, 15357, 7, 0, 0, 0, 15357, 15358, 7, 3, 0, 0, 15358, 15359, 7, 5, 0, 0, 15359, 15360, 7, 6, 0, 0, 15360, 15361, 7, 4, 0, 0, 15361, 15362, 5, 95, 0, 0, 15362, 15363, 7, 9, 0, 0, 15363, 15364, 7, 6, 0, 0, 15364, 15365, 7, 8, 0, 0, 15365, 15366, 7, 11, 0, 0, 15366, 15367, 5, 95, 0, 0, 15367, 15368, 7, 11, 0, 0, 15368, 15369, 7, 6, 0, 0, 15369, 15370, 7, 7, 0, 0, 15370, 2066, 1, 0, 0, 0, 15371, 15372, 7, 7, 0, 0, 15372, 15373, 7, 11, 0, 0, 15373, 15374, 7, 5, 0, 0, 15374, 15375, 5, 95, 0, 0, 15375, 15376, 7, 8, 0, 0, 15376, 15377, 7, 19, 0, 0, 15377, 15378, 7, 0, 0, 0, 15378, 15379, 7, 3, 0, 0, 15379, 15380, 7, 5, 0, 0, 15380, 15381, 7, 6, 0, 0, 15381, 15382, 7, 4, 0, 0, 15382, 15383, 5, 95, 0, 0, 15383, 15384, 7, 10, 0, 0, 15384, 15385, 7, 9, 0, 0, 15385, 2068, 1, 0, 0, 0, 15386, 15387, 7, 7, 0, 0, 15387, 15388, 7, 11, 0, 0, 15388, 15389, 7, 5, 0, 0, 15389, 15390, 5, 95, 0, 0, 15390, 15391, 7, 8, 0, 0, 15391, 15392, 7, 19, 0, 0, 15392, 15393, 7, 0, 0, 0, 15393, 15394, 7, 3, 0, 0, 15394, 15395, 7, 5, 0, 0, 15395, 15396, 7, 6, 0, 0, 15396, 15397, 7, 4, 0, 0, 15397, 15398, 5, 95, 0, 0, 15398, 15399, 7, 7, 0, 0, 15399, 15400, 7, 0, 0, 0, 15400, 15401, 7, 14, 0, 0, 15401, 15402, 7, 6, 0, 0, 15402, 2070, 1, 0, 0, 0, 15403, 15404, 7, 7, 0, 0, 15404, 15405, 7, 11, 0, 0, 15405, 15406, 7, 5, 0, 0, 15406, 15407, 5, 95, 0, 0, 15407, 15408, 7, 8, 0, 0, 15408, 15409, 7, 2, 0, 0, 15409, 15410, 7, 14, 0, 0, 15410, 15411, 7, 15, 0, 0, 15411, 2072, 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, 8, 0, 0, 15417, 15418, 7, 12, 0, 0, 15418, 15419, 7, 3, 0, 0, 15419, 15420, 7, 3, 0, 0, 15420, 15421, 7, 6, 0, 0, 15421, 15422, 7, 7, 0, 0, 15422, 15423, 7, 8, 0, 0, 15423, 15424, 7, 18, 0, 0, 15424, 2074, 1, 0, 0, 0, 15425, 15426, 7, 7, 0, 0, 15426, 15427, 7, 11, 0, 0, 15427, 15428, 7, 5, 0, 0, 15428, 15429, 5, 95, 0, 0, 15429, 15430, 7, 9, 0, 0, 15430, 15431, 7, 0, 0, 0, 15431, 15432, 7, 4, 0, 0, 15432, 15433, 7, 6, 0, 0, 15433, 15434, 5, 95, 0, 0, 15434, 15435, 7, 16, 0, 0, 15435, 15436, 7, 2, 0, 0, 15436, 15437, 7, 3, 0, 0, 15437, 15438, 7, 14, 0, 0, 15438, 15439, 7, 0, 0, 0, 15439, 15440, 7, 4, 0, 0, 15440, 2076, 1, 0, 0, 0, 15441, 15442, 7, 7, 0, 0, 15442, 15443, 7, 11, 0, 0, 15443, 15444, 7, 5, 0, 0, 15444, 15445, 5, 95, 0, 0, 15445, 15446, 7, 9, 0, 0, 15446, 15447, 7, 0, 0, 0, 15447, 15448, 7, 4, 0, 0, 15448, 15449, 7, 6, 0, 0, 15449, 15450, 5, 95, 0, 0, 15450, 15451, 7, 11, 0, 0, 15451, 15452, 7, 0, 0, 0, 15452, 15453, 7, 7, 0, 0, 15453, 15454, 7, 17, 0, 0, 15454, 15455, 7, 12, 0, 0, 15455, 15456, 7, 0, 0, 0, 15456, 15457, 7, 17, 0, 0, 15457, 15458, 7, 6, 0, 0, 15458, 2078, 1, 0, 0, 0, 15459, 15460, 7, 7, 0, 0, 15460, 15461, 7, 11, 0, 0, 15461, 15462, 7, 5, 0, 0, 15462, 15463, 5, 95, 0, 0, 15463, 15464, 7, 10, 0, 0, 15464, 15465, 7, 7, 0, 0, 15465, 15466, 7, 10, 0, 0, 15466, 15467, 7, 4, 0, 0, 15467, 15468, 7, 8, 0, 0, 15468, 15469, 7, 0, 0, 0, 15469, 15470, 7, 15, 0, 0, 15470, 2080, 1, 0, 0, 0, 15471, 15472, 7, 7, 0, 0, 15472, 15473, 7, 11, 0, 0, 15473, 15474, 7, 5, 0, 0, 15474, 15475, 5, 95, 0, 0, 15475, 15476, 7, 10, 0, 0, 15476, 15477, 7, 5, 0, 0, 15477, 15478, 7, 2, 0, 0, 15478, 15479, 5, 95, 0, 0, 15479, 15480, 7, 8, 0, 0, 15480, 15481, 7, 12, 0, 0, 15481, 15482, 7, 3, 0, 0, 15482, 15483, 7, 3, 0, 0, 15483, 15484, 7, 6, 0, 0, 15484, 15485, 7, 7, 0, 0, 15485, 15486, 7, 8, 0, 0, 15486, 15487, 7, 18, 0, 0, 15487, 2082, 1, 0, 0, 0, 15488, 15489, 7, 7, 0, 0, 15489, 15490, 7, 11, 0, 0, 15490, 15491, 5, 95, 0, 0, 15491, 15492, 7, 5, 0, 0, 15492, 15493, 7, 20, 0, 0, 15493, 2084, 1, 0, 0, 0, 15494, 15495, 7, 7, 0, 0, 15495, 15496, 7, 11, 0, 0, 15496, 15497, 7, 5, 0, 0, 15497, 15498, 5, 95, 0, 0, 15498, 15499, 7, 11, 0, 0, 15499, 15500, 7, 0, 0, 0, 15500, 15501, 7, 7, 0, 0, 15501, 15502, 7, 17, 0, 0, 15502, 2086, 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, 0, 0, 0, 15509, 15510, 7, 7, 0, 0, 15510, 15511, 7, 17, 0, 0, 15511, 15512, 7, 12, 0, 0, 15512, 15513, 7, 0, 0, 0, 15513, 15514, 7, 17, 0, 0, 15514, 15515, 7, 6, 0, 0, 15515, 2088, 1, 0, 0, 0, 15516, 15517, 7, 7, 0, 0, 15517, 15518, 7, 11, 0, 0, 15518, 15519, 7, 5, 0, 0, 15519, 15520, 5, 95, 0, 0, 15520, 15521, 7, 11, 0, 0, 15521, 15522, 7, 6, 0, 0, 15522, 15523, 7, 7, 0, 0, 15523, 15524, 7, 17, 0, 0, 15524, 15525, 7, 4, 0, 0, 15525, 15526, 7, 19, 0, 0, 15526, 15527, 5, 95, 0, 0, 15527, 15528, 7, 5, 0, 0, 15528, 15529, 7, 6, 0, 0, 15529, 15530, 7, 14, 0, 0, 15530, 15531, 7, 0, 0, 0, 15531, 15532, 7, 7, 0, 0, 15532, 15533, 7, 4, 0, 0, 15533, 15534, 7, 10, 0, 0, 15534, 15535, 7, 8, 0, 0, 15535, 15536, 7, 5, 0, 0, 15536, 2090, 1, 0, 0, 0, 15537, 15538, 7, 7, 0, 0, 15538, 15539, 7, 11, 0, 0, 15539, 15540, 7, 5, 0, 0, 15540, 15541, 5, 95, 0, 0, 15541, 15542, 7, 11, 0, 0, 15542, 15543, 7, 2, 0, 0, 15543, 15544, 7, 22, 0, 0, 15544, 15545, 7, 6, 0, 0, 15545, 15546, 7, 3, 0, 0, 15546, 2092, 1, 0, 0, 0, 15547, 15548, 7, 7, 0, 0, 15548, 15549, 7, 11, 0, 0, 15549, 15550, 7, 5, 0, 0, 15550, 15551, 5, 95, 0, 0, 15551, 15552, 7, 7, 0, 0, 15552, 15553, 7, 8, 0, 0, 15553, 15554, 7, 19, 0, 0, 15554, 15555, 7, 0, 0, 0, 15555, 15556, 7, 3, 0, 0, 15556, 15557, 5, 95, 0, 0, 15557, 15558, 7, 8, 0, 0, 15558, 15559, 7, 2, 0, 0, 15559, 15560, 7, 7, 0, 0, 15560, 15561, 7, 13, 0, 0, 15561, 15562, 5, 95, 0, 0, 15562, 15563, 7, 6, 0, 0, 15563, 15564, 7, 25, 0, 0, 15564, 15565, 7, 8, 0, 0, 15565, 15566, 7, 15, 0, 0, 15566, 2094, 1, 0, 0, 0, 15567, 15568, 7, 7, 0, 0, 15568, 15569, 7, 11, 0, 0, 15569, 15570, 7, 5, 0, 0, 15570, 15571, 5, 95, 0, 0, 15571, 15572, 7, 7, 0, 0, 15572, 15573, 7, 12, 0, 0, 15573, 15574, 7, 14, 0, 0, 15574, 15575, 7, 6, 0, 0, 15575, 15576, 7, 3, 0, 0, 15576, 15577, 7, 10, 0, 0, 15577, 15578, 7, 8, 0, 0, 15578, 15579, 5, 95, 0, 0, 15579, 15580, 7, 8, 0, 0, 15580, 15581, 7, 19, 0, 0, 15581, 15582, 7, 0, 0, 0, 15582, 15583, 7, 3, 0, 0, 15583, 15584, 7, 0, 0, 0, 15584, 15585, 7, 8, 0, 0, 15585, 15586, 7, 4, 0, 0, 15586, 15587, 7, 6, 0, 0, 15587, 15588, 7, 3, 0, 0, 15588, 15589, 7, 5, 0, 0, 15589, 2096, 1, 0, 0, 0, 15590, 15591, 7, 7, 0, 0, 15591, 15592, 7, 11, 0, 0, 15592, 15593, 7, 5, 0, 0, 15593, 15594, 5, 95, 0, 0, 15594, 15595, 7, 5, 0, 0, 15595, 15596, 7, 2, 0, 0, 15596, 15597, 7, 3, 0, 0, 15597, 15598, 7, 4, 0, 0, 15598, 2098, 1, 0, 0, 0, 15599, 15600, 7, 7, 0, 0, 15600, 15601, 7, 11, 0, 0, 15601, 15602, 7, 5, 0, 0, 15602, 15603, 7, 5, 0, 0, 15603, 15604, 7, 2, 0, 0, 15604, 15605, 7, 3, 0, 0, 15605, 15606, 7, 4, 0, 0, 15606, 2100, 1, 0, 0, 0, 15607, 15608, 7, 7, 0, 0, 15608, 15609, 7, 11, 0, 0, 15609, 15610, 7, 5, 0, 0, 15610, 15611, 5, 95, 0, 0, 15611, 15612, 7, 5, 0, 0, 15612, 15613, 7, 15, 0, 0, 15613, 15614, 7, 6, 0, 0, 15614, 15615, 7, 8, 0, 0, 15615, 15616, 7, 10, 0, 0, 15616, 15617, 7, 0, 0, 0, 15617, 15618, 7, 11, 0, 0, 15618, 15619, 5, 95, 0, 0, 15619, 15620, 7, 8, 0, 0, 15620, 15621, 7, 19, 0, 0, 15621, 15622, 7, 0, 0, 0, 15622, 15623, 7, 3, 0, 0, 15623, 15624, 7, 5, 0, 0, 15624, 2102, 1, 0, 0, 0, 15625, 15626, 7, 7, 0, 0, 15626, 15627, 7, 11, 0, 0, 15627, 15628, 7, 5, 0, 0, 15628, 15629, 5, 95, 0, 0, 15629, 15630, 7, 4, 0, 0, 15630, 15631, 7, 6, 0, 0, 15631, 15632, 7, 3, 0, 0, 15632, 15633, 7, 3, 0, 0, 15633, 15634, 7, 10, 0, 0, 15634, 15635, 7, 4, 0, 0, 15635, 15636, 7, 2, 0, 0, 15636, 15637, 7, 3, 0, 0, 15637, 15638, 7, 18, 0, 0, 15638, 2104, 1, 0, 0, 0, 15639, 15640, 7, 7, 0, 0, 15640, 15641, 7, 11, 0, 0, 15641, 15642, 7, 5, 0, 0, 15642, 15643, 5, 95, 0, 0, 15643, 15644, 7, 12, 0, 0, 15644, 15645, 7, 15, 0, 0, 15645, 15646, 7, 15, 0, 0, 15646, 15647, 7, 6, 0, 0, 15647, 15648, 7, 3, 0, 0, 15648, 2106, 1, 0, 0, 0, 15649, 15650, 7, 7, 0, 0, 15650, 15651, 7, 2, 0, 0, 15651, 15652, 5, 95, 0, 0, 15652, 15653, 7, 0, 0, 0, 15653, 15654, 7, 8, 0, 0, 15654, 15655, 7, 8, 0, 0, 15655, 15656, 7, 6, 0, 0, 15656, 15657, 7, 5, 0, 0, 15657, 15658, 7, 5, 0, 0, 15658, 2108, 1, 0, 0, 0, 15659, 15660, 7, 7, 0, 0, 15660, 15661, 7, 2, 0, 0, 15661, 15662, 5, 95, 0, 0, 15662, 15663, 7, 0, 0, 0, 15663, 15664, 7, 9, 0, 0, 15664, 15665, 7, 0, 0, 0, 15665, 15666, 7, 15, 0, 0, 15666, 15667, 7, 4, 0, 0, 15667, 15668, 7, 10, 0, 0, 15668, 15669, 7, 13, 0, 0, 15669, 15670, 7, 6, 0, 0, 15670, 15671, 5, 95, 0, 0, 15671, 15672, 7, 15, 0, 0, 15672, 15673, 7, 11, 0, 0, 15673, 15674, 7, 0, 0, 0, 15674, 15675, 7, 7, 0, 0, 15675, 2110, 1, 0, 0, 0, 15676, 15677, 7, 7, 0, 0, 15677, 15678, 7, 2, 0, 0, 15678, 15679, 5, 95, 0, 0, 15679, 15680, 7, 0, 0, 0, 15680, 15681, 7, 7, 0, 0, 15681, 15682, 7, 5, 0, 0, 15682, 15683, 7, 10, 0, 0, 15683, 15684, 5, 95, 0, 0, 15684, 15685, 7, 3, 0, 0, 15685, 15686, 7, 6, 0, 0, 15686, 15687, 7, 0, 0, 0, 15687, 15688, 7, 3, 0, 0, 15688, 15689, 7, 8, 0, 0, 15689, 15690, 7, 19, 0, 0, 15690, 2112, 1, 0, 0, 0, 15691, 15692, 7, 7, 0, 0, 15692, 15693, 7, 2, 0, 0, 15693, 15694, 7, 0, 0, 0, 15694, 15695, 7, 15, 0, 0, 15695, 15696, 7, 15, 0, 0, 15696, 15697, 7, 6, 0, 0, 15697, 15698, 7, 7, 0, 0, 15698, 15699, 7, 9, 0, 0, 15699, 2114, 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, 3, 0, 0, 15704, 15705, 7, 8, 0, 0, 15705, 15706, 7, 19, 0, 0, 15706, 15707, 7, 10, 0, 0, 15707, 15708, 7, 13, 0, 0, 15708, 15709, 7, 6, 0, 0, 15709, 15710, 7, 11, 0, 0, 15710, 15711, 7, 2, 0, 0, 15711, 15712, 7, 17, 0, 0, 15712, 2116, 1, 0, 0, 0, 15713, 15714, 7, 7, 0, 0, 15714, 15715, 7, 2, 0, 0, 15715, 15716, 7, 0, 0, 0, 15716, 15717, 7, 12, 0, 0, 15717, 15718, 7, 9, 0, 0, 15718, 15719, 7, 10, 0, 0, 15719, 15720, 7, 4, 0, 0, 15720, 2118, 1, 0, 0, 0, 15721, 15722, 7, 7, 0, 0, 15722, 15723, 7, 2, 0, 0, 15723, 15724, 7, 1, 0, 0, 15724, 15725, 7, 0, 0, 0, 15725, 15726, 7, 9, 0, 0, 15726, 15727, 7, 16, 0, 0, 15727, 15728, 7, 10, 0, 0, 15728, 15729, 7, 11, 0, 0, 15729, 15730, 7, 6, 0, 0, 15730, 2120, 1, 0, 0, 0, 15731, 15732, 7, 7, 0, 0, 15732, 15733, 7, 2, 0, 0, 15733, 15734, 5, 95, 0, 0, 15734, 15735, 7, 0, 0, 0, 15735, 15736, 7, 12, 0, 0, 15736, 15737, 7, 4, 0, 0, 15737, 15738, 7, 2, 0, 0, 15738, 15739, 5, 95, 0, 0, 15739, 15740, 7, 3, 0, 0, 15740, 15741, 7, 6, 0, 0, 15741, 15742, 7, 2, 0, 0, 15742, 15743, 7, 15, 0, 0, 15743, 15744, 7, 4, 0, 0, 15744, 15745, 7, 10, 0, 0, 15745, 15746, 7, 14, 0, 0, 15746, 15747, 7, 10, 0, 0, 15747, 15748, 7, 23, 0, 0, 15748, 15749, 7, 6, 0, 0, 15749, 2122, 1, 0, 0, 0, 15750, 15751, 7, 7, 0, 0, 15751, 15752, 7, 2, 0, 0, 15752, 15753, 5, 95, 0, 0, 15753, 15754, 7, 1, 0, 0, 15754, 15755, 7, 0, 0, 0, 15755, 15756, 7, 5, 0, 0, 15756, 15757, 7, 6, 0, 0, 15757, 15758, 7, 4, 0, 0, 15758, 15759, 7, 0, 0, 0, 15759, 15760, 7, 1, 0, 0, 15760, 15761, 7, 11, 0, 0, 15761, 15762, 7, 6, 0, 0, 15762, 15763, 5, 95, 0, 0, 15763, 15764, 7, 14, 0, 0, 15764, 15765, 7, 12, 0, 0, 15765, 15766, 7, 11, 0, 0, 15766, 15767, 7, 4, 0, 0, 15767, 15768, 7, 10, 0, 0, 15768, 15769, 7, 14, 0, 0, 15769, 15770, 7, 13, 0, 0, 15770, 15771, 5, 95, 0, 0, 15771, 15772, 7, 3, 0, 0, 15772, 15773, 7, 6, 0, 0, 15773, 15774, 7, 22, 0, 0, 15774, 15775, 7, 3, 0, 0, 15775, 15776, 7, 10, 0, 0, 15776, 15777, 7, 4, 0, 0, 15777, 15778, 7, 6, 0, 0, 15778, 2124, 1, 0, 0, 0, 15779, 15780, 7, 7, 0, 0, 15780, 15781, 7, 2, 0, 0, 15781, 15782, 5, 95, 0, 0, 15782, 15783, 7, 1, 0, 0, 15783, 15784, 7, 0, 0, 0, 15784, 15785, 7, 4, 0, 0, 15785, 15786, 7, 8, 0, 0, 15786, 15787, 7, 19, 0, 0, 15787, 15788, 5, 95, 0, 0, 15788, 15789, 7, 4, 0, 0, 15789, 15790, 7, 0, 0, 0, 15790, 15791, 7, 1, 0, 0, 15791, 15792, 7, 11, 0, 0, 15792, 15793, 7, 6, 0, 0, 15793, 15794, 5, 95, 0, 0, 15794, 15795, 7, 0, 0, 0, 15795, 15796, 7, 8, 0, 0, 15796, 15797, 7, 8, 0, 0, 15797, 15798, 7, 6, 0, 0, 15798, 15799, 7, 5, 0, 0, 15799, 15800, 7, 5, 0, 0, 15800, 15801, 5, 95, 0, 0, 15801, 15802, 7, 1, 0, 0, 15802, 15803, 7, 18, 0, 0, 15803, 15804, 5, 95, 0, 0, 15804, 15805, 7, 3, 0, 0, 15805, 15806, 7, 2, 0, 0, 15806, 15807, 7, 22, 0, 0, 15807, 15808, 7, 10, 0, 0, 15808, 15809, 7, 9, 0, 0, 15809, 2126, 1, 0, 0, 0, 15810, 15811, 7, 7, 0, 0, 15811, 15812, 7, 2, 0, 0, 15812, 15813, 5, 95, 0, 0, 15813, 15814, 7, 1, 0, 0, 15814, 15815, 7, 10, 0, 0, 15815, 15816, 7, 7, 0, 0, 15816, 15817, 7, 9, 0, 0, 15817, 15818, 5, 95, 0, 0, 15818, 15819, 7, 0, 0, 0, 15819, 15820, 7, 22, 0, 0, 15820, 15821, 7, 0, 0, 0, 15821, 15822, 7, 3, 0, 0, 15822, 15823, 7, 6, 0, 0, 15823, 2128, 1, 0, 0, 0, 15824, 15825, 7, 7, 0, 0, 15825, 15826, 7, 2, 0, 0, 15826, 15827, 5, 95, 0, 0, 15827, 15828, 7, 1, 0, 0, 15828, 15829, 7, 12, 0, 0, 15829, 15830, 7, 16, 0, 0, 15830, 15831, 7, 16, 0, 0, 15831, 15832, 7, 6, 0, 0, 15832, 15833, 7, 3, 0, 0, 15833, 2130, 1, 0, 0, 0, 15834, 15835, 7, 7, 0, 0, 15835, 15836, 7, 2, 0, 0, 15836, 15837, 7, 8, 0, 0, 15837, 15838, 7, 0, 0, 0, 15838, 15839, 7, 8, 0, 0, 15839, 15840, 7, 19, 0, 0, 15840, 15841, 7, 6, 0, 0, 15841, 2132, 1, 0, 0, 0, 15842, 15843, 7, 7, 0, 0, 15843, 15844, 7, 2, 0, 0, 15844, 15845, 7, 8, 0, 0, 15845, 15846, 7, 19, 0, 0, 15846, 15847, 7, 6, 0, 0, 15847, 15848, 7, 8, 0, 0, 15848, 15849, 7, 21, 0, 0, 15849, 2134, 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, 0, 0, 0, 15855, 15856, 7, 3, 0, 0, 15856, 15857, 7, 4, 0, 0, 15857, 15858, 7, 6, 0, 0, 15858, 15859, 7, 5, 0, 0, 15859, 15860, 7, 10, 0, 0, 15860, 15861, 7, 0, 0, 0, 15861, 15862, 7, 7, 0, 0, 15862, 2136, 1, 0, 0, 0, 15863, 15864, 7, 7, 0, 0, 15864, 15865, 7, 2, 0, 0, 15865, 15866, 5, 95, 0, 0, 15866, 15867, 7, 8, 0, 0, 15867, 15868, 7, 19, 0, 0, 15868, 15869, 7, 6, 0, 0, 15869, 15870, 7, 8, 0, 0, 15870, 15871, 7, 21, 0, 0, 15871, 15872, 5, 95, 0, 0, 15872, 15873, 7, 0, 0, 0, 15873, 15874, 7, 8, 0, 0, 15874, 15875, 7, 11, 0, 0, 15875, 15876, 5, 95, 0, 0, 15876, 15877, 7, 3, 0, 0, 15877, 15878, 7, 6, 0, 0, 15878, 15879, 7, 22, 0, 0, 15879, 15880, 7, 3, 0, 0, 15880, 15881, 7, 10, 0, 0, 15881, 15882, 7, 4, 0, 0, 15882, 15883, 7, 6, 0, 0, 15883, 2138, 1, 0, 0, 0, 15884, 15885, 7, 7, 0, 0, 15885, 15886, 7, 2, 0, 0, 15886, 15887, 5, 95, 0, 0, 15887, 15888, 7, 8, 0, 0, 15888, 15889, 7, 11, 0, 0, 15889, 15890, 7, 12, 0, 0, 15890, 15891, 7, 5, 0, 0, 15891, 15892, 7, 4, 0, 0, 15892, 15893, 7, 6, 0, 0, 15893, 15894, 7, 3, 0, 0, 15894, 15895, 5, 95, 0, 0, 15895, 15896, 7, 1, 0, 0, 15896, 15897, 7, 18, 0, 0, 15897, 15898, 5, 95, 0, 0, 15898, 15899, 7, 3, 0, 0, 15899, 15900, 7, 2, 0, 0, 15900, 15901, 7, 22, 0, 0, 15901, 15902, 7, 10, 0, 0, 15902, 15903, 7, 9, 0, 0, 15903, 2140, 1, 0, 0, 0, 15904, 15905, 7, 7, 0, 0, 15905, 15906, 7, 2, 0, 0, 15906, 15907, 5, 95, 0, 0, 15907, 15908, 7, 8, 0, 0, 15908, 15909, 7, 11, 0, 0, 15909, 15910, 7, 12, 0, 0, 15910, 15911, 7, 5, 0, 0, 15911, 15912, 7, 4, 0, 0, 15912, 15913, 7, 6, 0, 0, 15913, 15914, 7, 3, 0, 0, 15914, 15915, 7, 10, 0, 0, 15915, 15916, 7, 7, 0, 0, 15916, 15917, 7, 17, 0, 0, 15917, 2142, 1, 0, 0, 0, 15918, 15919, 7, 7, 0, 0, 15919, 15920, 7, 2, 0, 0, 15920, 15921, 5, 95, 0, 0, 15921, 15922, 7, 8, 0, 0, 15922, 15923, 7, 2, 0, 0, 15923, 15924, 7, 0, 0, 0, 15924, 15925, 7, 11, 0, 0, 15925, 15926, 7, 6, 0, 0, 15926, 15927, 7, 5, 0, 0, 15927, 15928, 7, 8, 0, 0, 15928, 15929, 7, 6, 0, 0, 15929, 15930, 5, 95, 0, 0, 15930, 15931, 7, 5, 0, 0, 15931, 15932, 7, 24, 0, 0, 15932, 2144, 1, 0, 0, 0, 15933, 15934, 7, 7, 0, 0, 15934, 15935, 7, 2, 0, 0, 15935, 15936, 5, 95, 0, 0, 15936, 15937, 7, 8, 0, 0, 15937, 15938, 7, 2, 0, 0, 15938, 15939, 7, 14, 0, 0, 15939, 15940, 7, 14, 0, 0, 15940, 15941, 7, 2, 0, 0, 15941, 15942, 7, 7, 0, 0, 15942, 15943, 5, 95, 0, 0, 15943, 15944, 7, 9, 0, 0, 15944, 15945, 7, 0, 0, 0, 15945, 15946, 7, 4, 0, 0, 15946, 15947, 7, 0, 0, 0, 15947, 2146, 1, 0, 0, 0, 15948, 15949, 7, 7, 0, 0, 15949, 15950, 7, 2, 0, 0, 15950, 15951, 7, 8, 0, 0, 15951, 15952, 7, 2, 0, 0, 15952, 15953, 7, 14, 0, 0, 15953, 15954, 7, 15, 0, 0, 15954, 15955, 7, 3, 0, 0, 15955, 15956, 7, 6, 0, 0, 15956, 15957, 7, 5, 0, 0, 15957, 15958, 7, 5, 0, 0, 15958, 2148, 1, 0, 0, 0, 15959, 15960, 7, 7, 0, 0, 15960, 15961, 7, 2, 0, 0, 15961, 15962, 5, 95, 0, 0, 15962, 15963, 7, 8, 0, 0, 15963, 15964, 7, 2, 0, 0, 15964, 15965, 7, 7, 0, 0, 15965, 15966, 7, 7, 0, 0, 15966, 15967, 7, 6, 0, 0, 15967, 15968, 7, 8, 0, 0, 15968, 15969, 7, 4, 0, 0, 15969, 15970, 5, 95, 0, 0, 15970, 15971, 7, 1, 0, 0, 15971, 15972, 7, 18, 0, 0, 15972, 15973, 5, 95, 0, 0, 15973, 15974, 7, 8, 0, 0, 15974, 15975, 7, 1, 0, 0, 15975, 15976, 5, 95, 0, 0, 15976, 15977, 7, 22, 0, 0, 15977, 15978, 7, 19, 0, 0, 15978, 15979, 7, 3, 0, 0, 15979, 15980, 5, 95, 0, 0, 15980, 15981, 7, 2, 0, 0, 15981, 15982, 7, 7, 0, 0, 15982, 15983, 7, 11, 0, 0, 15983, 15984, 7, 18, 0, 0, 15984, 2150, 1, 0, 0, 0, 15985, 15986, 7, 7, 0, 0, 15986, 15987, 7, 2, 0, 0, 15987, 15988, 5, 95, 0, 0, 15988, 15989, 7, 8, 0, 0, 15989, 15990, 7, 2, 0, 0, 15990, 15991, 7, 7, 0, 0, 15991, 15992, 7, 7, 0, 0, 15992, 15993, 7, 6, 0, 0, 15993, 15994, 7, 8, 0, 0, 15994, 15995, 7, 4, 0, 0, 15995, 15996, 5, 95, 0, 0, 15996, 15997, 7, 1, 0, 0, 15997, 15998, 7, 18, 0, 0, 15998, 15999, 5, 95, 0, 0, 15999, 16000, 7, 8, 0, 0, 16000, 16001, 7, 2, 0, 0, 16001, 16002, 7, 14, 0, 0, 16002, 16003, 7, 1, 0, 0, 16003, 16004, 7, 10, 0, 0, 16004, 16005, 7, 7, 0, 0, 16005, 16006, 7, 6, 0, 0, 16006, 16007, 5, 95, 0, 0, 16007, 16008, 7, 5, 0, 0, 16008, 16009, 7, 22, 0, 0, 16009, 2152, 1, 0, 0, 0, 16010, 16011, 7, 7, 0, 0, 16011, 16012, 7, 2, 0, 0, 16012, 16013, 5, 95, 0, 0, 16013, 16014, 7, 8, 0, 0, 16014, 16015, 7, 2, 0, 0, 16015, 16016, 7, 7, 0, 0, 16016, 16017, 7, 7, 0, 0, 16017, 16018, 7, 6, 0, 0, 16018, 16019, 7, 8, 0, 0, 16019, 16020, 7, 4, 0, 0, 16020, 16021, 5, 95, 0, 0, 16021, 16022, 7, 1, 0, 0, 16022, 16023, 7, 18, 0, 0, 16023, 16024, 5, 95, 0, 0, 16024, 16025, 7, 8, 0, 0, 16025, 16026, 7, 2, 0, 0, 16026, 16027, 7, 5, 0, 0, 16027, 16028, 7, 4, 0, 0, 16028, 16029, 5, 95, 0, 0, 16029, 16030, 7, 1, 0, 0, 16030, 16031, 7, 0, 0, 0, 16031, 16032, 7, 5, 0, 0, 16032, 16033, 7, 6, 0, 0, 16033, 16034, 7, 9, 0, 0, 16034, 2154, 1, 0, 0, 0, 16035, 16036, 7, 7, 0, 0, 16036, 16037, 7, 2, 0, 0, 16037, 16038, 5, 95, 0, 0, 16038, 16039, 7, 8, 0, 0, 16039, 16040, 7, 2, 0, 0, 16040, 16041, 7, 7, 0, 0, 16041, 16042, 7, 7, 0, 0, 16042, 16043, 7, 6, 0, 0, 16043, 16044, 7, 8, 0, 0, 16044, 16045, 7, 4, 0, 0, 16045, 16046, 5, 95, 0, 0, 16046, 16047, 7, 1, 0, 0, 16047, 16048, 7, 18, 0, 0, 16048, 16049, 5, 95, 0, 0, 16049, 16050, 7, 6, 0, 0, 16050, 16051, 7, 11, 0, 0, 16051, 16052, 7, 10, 0, 0, 16052, 16053, 7, 14, 0, 0, 16053, 16054, 5, 95, 0, 0, 16054, 16055, 7, 9, 0, 0, 16055, 16056, 7, 12, 0, 0, 16056, 16057, 7, 15, 0, 0, 16057, 16058, 7, 5, 0, 0, 16058, 2156, 1, 0, 0, 0, 16059, 16060, 7, 7, 0, 0, 16060, 16061, 7, 2, 0, 0, 16061, 16062, 5, 95, 0, 0, 16062, 16063, 7, 8, 0, 0, 16063, 16064, 7, 2, 0, 0, 16064, 16065, 7, 7, 0, 0, 16065, 16066, 7, 7, 0, 0, 16066, 16067, 7, 6, 0, 0, 16067, 16068, 7, 8, 0, 0, 16068, 16069, 7, 4, 0, 0, 16069, 16070, 5, 95, 0, 0, 16070, 16071, 7, 1, 0, 0, 16071, 16072, 7, 18, 0, 0, 16072, 16073, 5, 95, 0, 0, 16073, 16074, 7, 16, 0, 0, 16074, 16075, 7, 10, 0, 0, 16075, 16076, 7, 11, 0, 0, 16076, 16077, 7, 4, 0, 0, 16077, 16078, 7, 6, 0, 0, 16078, 16079, 7, 3, 0, 0, 16079, 16080, 7, 10, 0, 0, 16080, 16081, 7, 7, 0, 0, 16081, 16082, 7, 17, 0, 0, 16082, 2158, 1, 0, 0, 0, 16083, 16084, 7, 7, 0, 0, 16084, 16085, 7, 2, 0, 0, 16085, 16086, 7, 8, 0, 0, 16086, 16087, 7, 2, 0, 0, 16087, 16088, 7, 15, 0, 0, 16088, 16089, 7, 18, 0, 0, 16089, 2160, 1, 0, 0, 0, 16090, 16091, 7, 7, 0, 0, 16091, 16092, 7, 2, 0, 0, 16092, 16093, 5, 95, 0, 0, 16093, 16094, 7, 8, 0, 0, 16094, 16095, 7, 2, 0, 0, 16095, 16096, 7, 5, 0, 0, 16096, 16097, 7, 4, 0, 0, 16097, 16098, 5, 95, 0, 0, 16098, 16099, 7, 25, 0, 0, 16099, 16100, 7, 14, 0, 0, 16100, 16101, 7, 11, 0, 0, 16101, 16102, 5, 95, 0, 0, 16102, 16103, 7, 24, 0, 0, 16103, 16104, 7, 12, 0, 0, 16104, 16105, 7, 6, 0, 0, 16105, 16106, 7, 3, 0, 0, 16106, 16107, 7, 18, 0, 0, 16107, 16108, 5, 95, 0, 0, 16108, 16109, 7, 3, 0, 0, 16109, 16110, 7, 6, 0, 0, 16110, 16111, 7, 22, 0, 0, 16111, 16112, 7, 3, 0, 0, 16112, 16113, 7, 10, 0, 0, 16113, 16114, 7, 4, 0, 0, 16114, 16115, 7, 6, 0, 0, 16115, 2162, 1, 0, 0, 0, 16116, 16117, 7, 7, 0, 0, 16117, 16118, 7, 2, 0, 0, 16118, 16119, 5, 95, 0, 0, 16119, 16120, 7, 8, 0, 0, 16120, 16121, 7, 15, 0, 0, 16121, 16122, 7, 12, 0, 0, 16122, 16123, 5, 95, 0, 0, 16123, 16124, 7, 8, 0, 0, 16124, 16125, 7, 2, 0, 0, 16125, 16126, 7, 5, 0, 0, 16126, 16127, 7, 4, 0, 0, 16127, 16128, 7, 10, 0, 0, 16128, 16129, 7, 7, 0, 0, 16129, 16130, 7, 17, 0, 0, 16130, 2164, 1, 0, 0, 0, 16131, 16132, 7, 7, 0, 0, 16132, 16133, 7, 2, 0, 0, 16133, 16134, 7, 8, 0, 0, 16134, 16135, 7, 15, 0, 0, 16135, 16136, 7, 12, 0, 0, 16136, 16137, 5, 95, 0, 0, 16137, 16138, 7, 8, 0, 0, 16138, 16139, 7, 2, 0, 0, 16139, 16140, 7, 5, 0, 0, 16140, 16141, 7, 4, 0, 0, 16141, 16142, 7, 10, 0, 0, 16142, 16143, 7, 7, 0, 0, 16143, 16144, 7, 17, 0, 0, 16144, 2166, 1, 0, 0, 0, 16145, 16146, 7, 7, 0, 0, 16146, 16147, 7, 2, 0, 0, 16147, 16148, 7, 8, 0, 0, 16148, 16149, 7, 18, 0, 0, 16149, 16150, 7, 8, 0, 0, 16150, 16151, 7, 11, 0, 0, 16151, 16152, 7, 6, 0, 0, 16152, 2168, 1, 0, 0, 0, 16153, 16154, 7, 7, 0, 0, 16154, 16155, 7, 2, 0, 0, 16155, 16156, 5, 95, 0, 0, 16156, 16157, 7, 9, 0, 0, 16157, 16158, 7, 0, 0, 0, 16158, 16159, 7, 4, 0, 0, 16159, 16160, 7, 0, 0, 0, 16160, 16161, 5, 95, 0, 0, 16161, 16162, 7, 5, 0, 0, 16162, 16163, 7, 6, 0, 0, 16163, 16164, 7, 8, 0, 0, 16164, 16165, 7, 12, 0, 0, 16165, 16166, 7, 3, 0, 0, 16166, 16167, 7, 10, 0, 0, 16167, 16168, 7, 4, 0, 0, 16168, 16169, 7, 18, 0, 0, 16169, 16170, 5, 95, 0, 0, 16170, 16171, 7, 3, 0, 0, 16171, 16172, 7, 6, 0, 0, 16172, 16173, 7, 22, 0, 0, 16173, 16174, 7, 3, 0, 0, 16174, 16175, 7, 10, 0, 0, 16175, 16176, 7, 4, 0, 0, 16176, 16177, 7, 6, 0, 0, 16177, 2170, 1, 0, 0, 0, 16178, 16179, 7, 7, 0, 0, 16179, 16180, 7, 2, 0, 0, 16180, 16181, 5, 95, 0, 0, 16181, 16182, 7, 9, 0, 0, 16182, 16183, 7, 6, 0, 0, 16183, 16184, 7, 8, 0, 0, 16184, 16185, 7, 2, 0, 0, 16185, 16186, 7, 3, 0, 0, 16186, 16187, 7, 3, 0, 0, 16187, 16188, 7, 6, 0, 0, 16188, 16189, 7, 11, 0, 0, 16189, 16190, 7, 0, 0, 0, 16190, 16191, 7, 4, 0, 0, 16191, 16192, 7, 6, 0, 0, 16192, 2172, 1, 0, 0, 0, 16193, 16194, 7, 7, 0, 0, 16194, 16195, 7, 2, 0, 0, 16195, 16196, 7, 9, 0, 0, 16196, 16197, 7, 6, 0, 0, 16197, 16198, 7, 11, 0, 0, 16198, 16199, 7, 0, 0, 0, 16199, 16200, 7, 18, 0, 0, 16200, 2174, 1, 0, 0, 0, 16201, 16202, 7, 7, 0, 0, 16202, 16203, 7, 2, 0, 0, 16203, 16204, 7, 9, 0, 0, 16204, 16205, 7, 10, 0, 0, 16205, 16206, 7, 3, 0, 0, 16206, 16207, 7, 6, 0, 0, 16207, 16208, 7, 8, 0, 0, 16208, 16209, 7, 4, 0, 0, 16209, 16210, 7, 10, 0, 0, 16210, 16211, 7, 2, 0, 0, 16211, 2176, 1, 0, 0, 0, 16212, 16213, 7, 7, 0, 0, 16213, 16214, 7, 2, 0, 0, 16214, 16215, 7, 9, 0, 0, 16215, 16216, 7, 10, 0, 0, 16216, 16217, 7, 5, 0, 0, 16217, 16218, 7, 8, 0, 0, 16218, 16219, 7, 0, 0, 0, 16219, 16220, 7, 3, 0, 0, 16220, 16221, 7, 9, 0, 0, 16221, 16222, 7, 16, 0, 0, 16222, 16223, 7, 10, 0, 0, 16223, 16224, 7, 11, 0, 0, 16224, 16225, 7, 6, 0, 0, 16225, 2178, 1, 0, 0, 0, 16226, 16227, 7, 7, 0, 0, 16227, 16228, 7, 2, 0, 0, 16228, 16229, 5, 95, 0, 0, 16229, 16230, 7, 9, 0, 0, 16230, 16231, 7, 2, 0, 0, 16231, 16232, 7, 14, 0, 0, 16232, 16233, 7, 0, 0, 0, 16233, 16234, 7, 10, 0, 0, 16234, 16235, 7, 7, 0, 0, 16235, 16236, 5, 95, 0, 0, 16236, 16237, 7, 10, 0, 0, 16237, 16238, 7, 7, 0, 0, 16238, 16239, 7, 9, 0, 0, 16239, 16240, 7, 6, 0, 0, 16240, 16241, 7, 25, 0, 0, 16241, 16242, 5, 95, 0, 0, 16242, 16243, 7, 16, 0, 0, 16243, 16244, 7, 10, 0, 0, 16244, 16245, 7, 11, 0, 0, 16245, 16246, 7, 4, 0, 0, 16246, 16247, 7, 6, 0, 0, 16247, 16248, 7, 3, 0, 0, 16248, 2180, 1, 0, 0, 0, 16249, 16250, 7, 7, 0, 0, 16250, 16251, 7, 2, 0, 0, 16251, 16252, 5, 95, 0, 0, 16252, 16253, 7, 9, 0, 0, 16253, 16254, 7, 5, 0, 0, 16254, 16255, 7, 4, 0, 0, 16255, 16256, 5, 95, 0, 0, 16256, 16257, 7, 12, 0, 0, 16257, 16258, 7, 15, 0, 0, 16258, 16259, 7, 17, 0, 0, 16259, 16260, 7, 3, 0, 0, 16260, 16261, 7, 0, 0, 0, 16261, 16262, 7, 9, 0, 0, 16262, 16263, 7, 6, 0, 0, 16263, 16264, 5, 95, 0, 0, 16264, 16265, 7, 10, 0, 0, 16265, 16266, 7, 7, 0, 0, 16266, 16267, 7, 5, 0, 0, 16267, 16268, 7, 6, 0, 0, 16268, 16269, 7, 3, 0, 0, 16269, 16270, 7, 4, 0, 0, 16270, 16271, 5, 95, 0, 0, 16271, 16272, 7, 8, 0, 0, 16272, 16273, 7, 2, 0, 0, 16273, 16274, 7, 7, 0, 0, 16274, 16275, 7, 13, 0, 0, 16275, 2182, 1, 0, 0, 0, 16276, 16277, 7, 7, 0, 0, 16277, 16278, 7, 2, 0, 0, 16278, 16279, 5, 95, 0, 0, 16279, 16280, 7, 6, 0, 0, 16280, 16281, 7, 11, 0, 0, 16281, 16282, 7, 10, 0, 0, 16282, 16283, 7, 14, 0, 0, 16283, 16284, 5, 95, 0, 0, 16284, 16285, 7, 17, 0, 0, 16285, 16286, 7, 3, 0, 0, 16286, 16287, 7, 2, 0, 0, 16287, 16288, 7, 12, 0, 0, 16288, 16289, 7, 15, 0, 0, 16289, 16290, 7, 1, 0, 0, 16290, 16291, 7, 18, 0, 0, 16291, 2184, 1, 0, 0, 0, 16292, 16293, 7, 7, 0, 0, 16293, 16294, 7, 2, 0, 0, 16294, 16295, 5, 95, 0, 0, 16295, 16296, 7, 6, 0, 0, 16296, 16297, 7, 11, 0, 0, 16297, 16298, 7, 10, 0, 0, 16298, 16299, 7, 14, 0, 0, 16299, 16300, 7, 10, 0, 0, 16300, 16301, 7, 7, 0, 0, 16301, 16302, 7, 0, 0, 0, 16302, 16303, 7, 4, 0, 0, 16303, 16304, 7, 6, 0, 0, 16304, 16305, 5, 95, 0, 0, 16305, 16306, 7, 20, 0, 0, 16306, 16307, 7, 2, 0, 0, 16307, 16308, 7, 10, 0, 0, 16308, 16309, 7, 7, 0, 0, 16309, 2186, 1, 0, 0, 0, 16310, 16311, 7, 7, 0, 0, 16311, 16312, 7, 2, 0, 0, 16312, 16313, 5, 95, 0, 0, 16313, 16314, 7, 6, 0, 0, 16314, 16315, 7, 11, 0, 0, 16315, 16316, 7, 10, 0, 0, 16316, 16317, 7, 14, 0, 0, 16317, 16318, 7, 10, 0, 0, 16318, 16319, 7, 7, 0, 0, 16319, 16320, 7, 0, 0, 0, 16320, 16321, 7, 4, 0, 0, 16321, 16322, 7, 6, 0, 0, 16322, 16323, 5, 95, 0, 0, 16323, 16324, 7, 2, 0, 0, 16324, 16325, 7, 1, 0, 0, 16325, 16326, 7, 18, 0, 0, 16326, 2188, 1, 0, 0, 0, 16327, 16328, 7, 7, 0, 0, 16328, 16329, 7, 2, 0, 0, 16329, 16330, 5, 95, 0, 0, 16330, 16331, 7, 6, 0, 0, 16331, 16332, 7, 11, 0, 0, 16332, 16333, 7, 10, 0, 0, 16333, 16334, 7, 14, 0, 0, 16334, 16335, 7, 10, 0, 0, 16335, 16336, 7, 7, 0, 0, 16336, 16337, 7, 0, 0, 0, 16337, 16338, 7, 4, 0, 0, 16338, 16339, 7, 6, 0, 0, 16339, 16340, 5, 95, 0, 0, 16340, 16341, 7, 2, 0, 0, 16341, 16342, 7, 12, 0, 0, 16342, 16343, 7, 4, 0, 0, 16343, 16344, 7, 6, 0, 0, 16344, 16345, 7, 3, 0, 0, 16345, 16346, 5, 95, 0, 0, 16346, 16347, 7, 20, 0, 0, 16347, 16348, 7, 2, 0, 0, 16348, 16349, 7, 10, 0, 0, 16349, 16350, 7, 7, 0, 0, 16350, 2190, 1, 0, 0, 0, 16351, 16352, 7, 7, 0, 0, 16352, 16353, 7, 2, 0, 0, 16353, 16354, 7, 6, 0, 0, 16354, 16355, 7, 7, 0, 0, 16355, 16356, 7, 4, 0, 0, 16356, 16357, 7, 10, 0, 0, 16357, 16358, 7, 4, 0, 0, 16358, 16359, 7, 18, 0, 0, 16359, 16360, 7, 6, 0, 0, 16360, 16361, 7, 5, 0, 0, 16361, 16362, 7, 8, 0, 0, 16362, 16363, 7, 0, 0, 0, 16363, 16364, 7, 15, 0, 0, 16364, 16365, 7, 10, 0, 0, 16365, 16366, 7, 7, 0, 0, 16366, 16367, 7, 17, 0, 0, 16367, 2192, 1, 0, 0, 0, 16368, 16369, 7, 7, 0, 0, 16369, 16370, 7, 2, 0, 0, 16370, 16371, 5, 95, 0, 0, 16371, 16372, 7, 6, 0, 0, 16372, 16373, 7, 25, 0, 0, 16373, 16374, 7, 15, 0, 0, 16374, 16375, 7, 0, 0, 0, 16375, 16376, 7, 7, 0, 0, 16376, 16377, 7, 9, 0, 0, 16377, 16378, 5, 95, 0, 0, 16378, 16379, 7, 17, 0, 0, 16379, 16380, 7, 5, 0, 0, 16380, 16381, 7, 6, 0, 0, 16381, 16382, 7, 4, 0, 0, 16382, 16383, 5, 95, 0, 0, 16383, 16384, 7, 4, 0, 0, 16384, 16385, 7, 2, 0, 0, 16385, 16386, 5, 95, 0, 0, 16386, 16387, 7, 12, 0, 0, 16387, 16388, 7, 7, 0, 0, 16388, 16389, 7, 10, 0, 0, 16389, 16390, 7, 2, 0, 0, 16390, 16391, 7, 7, 0, 0, 16391, 2194, 1, 0, 0, 0, 16392, 16393, 7, 7, 0, 0, 16393, 16394, 7, 2, 0, 0, 16394, 16395, 5, 95, 0, 0, 16395, 16396, 7, 6, 0, 0, 16396, 16397, 7, 25, 0, 0, 16397, 16398, 7, 15, 0, 0, 16398, 16399, 7, 0, 0, 0, 16399, 16400, 7, 7, 0, 0, 16400, 16401, 7, 9, 0, 0, 16401, 2196, 1, 0, 0, 0, 16402, 16403, 7, 7, 0, 0, 16403, 16404, 7, 2, 0, 0, 16404, 16405, 5, 95, 0, 0, 16405, 16406, 7, 6, 0, 0, 16406, 16407, 7, 25, 0, 0, 16407, 16408, 7, 15, 0, 0, 16408, 16409, 7, 0, 0, 0, 16409, 16410, 7, 7, 0, 0, 16410, 16411, 7, 9, 0, 0, 16411, 16412, 5, 95, 0, 0, 16412, 16413, 7, 4, 0, 0, 16413, 16414, 7, 0, 0, 0, 16414, 16415, 7, 1, 0, 0, 16415, 16416, 7, 11, 0, 0, 16416, 16417, 7, 6, 0, 0, 16417, 2198, 1, 0, 0, 0, 16418, 16419, 7, 7, 0, 0, 16419, 16420, 7, 2, 0, 0, 16420, 16421, 7, 6, 0, 0, 16421, 16422, 7, 25, 0, 0, 16422, 16423, 7, 4, 0, 0, 16423, 16424, 7, 6, 0, 0, 16424, 16425, 7, 7, 0, 0, 16425, 16426, 7, 9, 0, 0, 16426, 2200, 1, 0, 0, 0, 16427, 16428, 7, 7, 0, 0, 16428, 16429, 7, 2, 0, 0, 16429, 16430, 5, 95, 0, 0, 16430, 16431, 7, 16, 0, 0, 16431, 16432, 7, 0, 0, 0, 16432, 16433, 7, 8, 0, 0, 16433, 16434, 7, 4, 0, 0, 16434, 2202, 1, 0, 0, 0, 16435, 16436, 7, 7, 0, 0, 16436, 16437, 7, 2, 0, 0, 16437, 16438, 5, 95, 0, 0, 16438, 16439, 7, 16, 0, 0, 16439, 16440, 7, 0, 0, 0, 16440, 16441, 7, 8, 0, 0, 16441, 16442, 7, 4, 0, 0, 16442, 16443, 7, 2, 0, 0, 16443, 16444, 7, 3, 0, 0, 16444, 16445, 7, 10, 0, 0, 16445, 16446, 7, 23, 0, 0, 16446, 16447, 7, 6, 0, 0, 16447, 16448, 5, 95, 0, 0, 16448, 16449, 7, 20, 0, 0, 16449, 16450, 7, 2, 0, 0, 16450, 16451, 7, 10, 0, 0, 16451, 16452, 7, 7, 0, 0, 16452, 2204, 1, 0, 0, 0, 16453, 16454, 7, 7, 0, 0, 16454, 16455, 7, 2, 0, 0, 16455, 16456, 5, 95, 0, 0, 16456, 16457, 7, 16, 0, 0, 16457, 16458, 7, 10, 0, 0, 16458, 16459, 7, 11, 0, 0, 16459, 16460, 7, 4, 0, 0, 16460, 16461, 7, 6, 0, 0, 16461, 16462, 7, 3, 0, 0, 16462, 16463, 7, 10, 0, 0, 16463, 16464, 7, 7, 0, 0, 16464, 16465, 7, 17, 0, 0, 16465, 2206, 1, 0, 0, 0, 16466, 16467, 7, 7, 0, 0, 16467, 16468, 7, 2, 0, 0, 16468, 16469, 7, 16, 0, 0, 16469, 16470, 7, 2, 0, 0, 16470, 16471, 7, 3, 0, 0, 16471, 16472, 7, 8, 0, 0, 16472, 16473, 7, 6, 0, 0, 16473, 2208, 1, 0, 0, 0, 16474, 16475, 7, 7, 0, 0, 16475, 16476, 7, 2, 0, 0, 16476, 16477, 5, 95, 0, 0, 16477, 16478, 7, 16, 0, 0, 16478, 16479, 7, 12, 0, 0, 16479, 16480, 7, 11, 0, 0, 16480, 16481, 7, 11, 0, 0, 16481, 16482, 5, 95, 0, 0, 16482, 16483, 7, 2, 0, 0, 16483, 16484, 7, 12, 0, 0, 16484, 16485, 7, 4, 0, 0, 16485, 16486, 7, 6, 0, 0, 16486, 16487, 7, 3, 0, 0, 16487, 16488, 5, 95, 0, 0, 16488, 16489, 7, 20, 0, 0, 16489, 16490, 7, 2, 0, 0, 16490, 16491, 7, 10, 0, 0, 16491, 16492, 7, 7, 0, 0, 16492, 16493, 5, 95, 0, 0, 16493, 16494, 7, 4, 0, 0, 16494, 16495, 7, 2, 0, 0, 16495, 16496, 5, 95, 0, 0, 16496, 16497, 7, 2, 0, 0, 16497, 16498, 7, 12, 0, 0, 16498, 16499, 7, 4, 0, 0, 16499, 16500, 7, 6, 0, 0, 16500, 16501, 7, 3, 0, 0, 16501, 2210, 1, 0, 0, 0, 16502, 16503, 7, 7, 0, 0, 16503, 16504, 7, 2, 0, 0, 16504, 16505, 5, 95, 0, 0, 16505, 16506, 7, 17, 0, 0, 16506, 16507, 7, 0, 0, 0, 16507, 16508, 7, 4, 0, 0, 16508, 16509, 7, 19, 0, 0, 16509, 16510, 7, 6, 0, 0, 16510, 16511, 7, 3, 0, 0, 16511, 16512, 5, 95, 0, 0, 16512, 16513, 7, 2, 0, 0, 16513, 16514, 7, 15, 0, 0, 16514, 16515, 7, 4, 0, 0, 16515, 16516, 7, 10, 0, 0, 16516, 16517, 7, 14, 0, 0, 16517, 16518, 7, 10, 0, 0, 16518, 16519, 7, 23, 0, 0, 16519, 16520, 7, 6, 0, 0, 16520, 16521, 7, 3, 0, 0, 16521, 16522, 5, 95, 0, 0, 16522, 16523, 7, 5, 0, 0, 16523, 16524, 7, 4, 0, 0, 16524, 16525, 7, 0, 0, 0, 16525, 16526, 7, 4, 0, 0, 16526, 16527, 7, 10, 0, 0, 16527, 16528, 7, 5, 0, 0, 16528, 16529, 7, 4, 0, 0, 16529, 16530, 7, 10, 0, 0, 16530, 16531, 7, 8, 0, 0, 16531, 16532, 7, 5, 0, 0, 16532, 2212, 1, 0, 0, 0, 16533, 16534, 7, 7, 0, 0, 16534, 16535, 7, 2, 0, 0, 16535, 16536, 5, 95, 0, 0, 16536, 16537, 7, 17, 0, 0, 16537, 16538, 7, 1, 0, 0, 16538, 16539, 7, 18, 0, 0, 16539, 16540, 5, 95, 0, 0, 16540, 16541, 7, 15, 0, 0, 16541, 16542, 7, 12, 0, 0, 16542, 16543, 7, 5, 0, 0, 16543, 16544, 7, 19, 0, 0, 16544, 16545, 7, 9, 0, 0, 16545, 16546, 7, 2, 0, 0, 16546, 16547, 7, 22, 0, 0, 16547, 16548, 7, 7, 0, 0, 16548, 2214, 1, 0, 0, 0, 16549, 16550, 7, 7, 0, 0, 16550, 16551, 7, 2, 0, 0, 16551, 16552, 7, 17, 0, 0, 16552, 16553, 7, 12, 0, 0, 16553, 16554, 7, 0, 0, 0, 16554, 16555, 7, 3, 0, 0, 16555, 16556, 7, 0, 0, 0, 16556, 16557, 7, 7, 0, 0, 16557, 16558, 7, 4, 0, 0, 16558, 16559, 7, 6, 0, 0, 16559, 16560, 7, 6, 0, 0, 16560, 2216, 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, 16570, 5, 95, 0, 0, 16570, 16571, 7, 16, 0, 0, 16571, 16572, 7, 16, 0, 0, 16572, 16573, 7, 5, 0, 0, 16573, 2218, 1, 0, 0, 0, 16574, 16575, 7, 7, 0, 0, 16575, 16576, 7, 2, 0, 0, 16576, 16577, 5, 95, 0, 0, 16577, 16578, 7, 10, 0, 0, 16578, 16579, 7, 7, 0, 0, 16579, 16580, 7, 9, 0, 0, 16580, 16581, 7, 6, 0, 0, 16581, 16582, 7, 25, 0, 0, 16582, 2220, 1, 0, 0, 0, 16583, 16584, 7, 7, 0, 0, 16584, 16585, 7, 2, 0, 0, 16585, 16586, 5, 95, 0, 0, 16586, 16587, 7, 10, 0, 0, 16587, 16588, 7, 7, 0, 0, 16588, 16589, 7, 9, 0, 0, 16589, 16590, 7, 6, 0, 0, 16590, 16591, 7, 25, 0, 0, 16591, 16592, 5, 95, 0, 0, 16592, 16593, 7, 5, 0, 0, 16593, 16594, 7, 5, 0, 0, 16594, 2222, 1, 0, 0, 0, 16595, 16596, 7, 7, 0, 0, 16596, 16597, 7, 2, 0, 0, 16597, 16598, 5, 95, 0, 0, 16598, 16599, 7, 10, 0, 0, 16599, 16600, 7, 7, 0, 0, 16600, 16601, 7, 14, 0, 0, 16601, 16602, 7, 6, 0, 0, 16602, 16603, 7, 14, 0, 0, 16603, 16604, 7, 2, 0, 0, 16604, 16605, 7, 3, 0, 0, 16605, 16606, 7, 18, 0, 0, 16606, 2224, 1, 0, 0, 0, 16607, 16608, 7, 7, 0, 0, 16608, 16609, 7, 2, 0, 0, 16609, 16610, 5, 95, 0, 0, 16610, 16611, 7, 10, 0, 0, 16611, 16612, 7, 7, 0, 0, 16612, 16613, 7, 14, 0, 0, 16613, 16614, 7, 6, 0, 0, 16614, 16615, 7, 14, 0, 0, 16615, 16616, 7, 2, 0, 0, 16616, 16617, 7, 3, 0, 0, 16617, 16618, 7, 18, 0, 0, 16618, 16619, 5, 95, 0, 0, 16619, 16620, 7, 15, 0, 0, 16620, 16621, 7, 3, 0, 0, 16621, 16622, 7, 12, 0, 0, 16622, 16623, 7, 7, 0, 0, 16623, 16624, 7, 10, 0, 0, 16624, 16625, 7, 7, 0, 0, 16625, 16626, 7, 17, 0, 0, 16626, 2226, 1, 0, 0, 0, 16627, 16628, 7, 7, 0, 0, 16628, 16629, 7, 2, 0, 0, 16629, 16630, 7, 21, 0, 0, 16630, 16631, 7, 6, 0, 0, 16631, 16632, 7, 6, 0, 0, 16632, 16633, 7, 15, 0, 0, 16633, 2228, 1, 0, 0, 0, 16634, 16635, 7, 7, 0, 0, 16635, 16636, 7, 2, 0, 0, 16636, 16637, 5, 95, 0, 0, 16637, 16638, 7, 11, 0, 0, 16638, 16639, 7, 2, 0, 0, 16639, 16640, 7, 0, 0, 0, 16640, 16641, 7, 9, 0, 0, 16641, 2230, 1, 0, 0, 0, 16642, 16643, 7, 7, 0, 0, 16643, 16644, 7, 2, 0, 0, 16644, 16645, 7, 11, 0, 0, 16645, 16646, 7, 2, 0, 0, 16646, 16647, 7, 8, 0, 0, 16647, 16648, 7, 0, 0, 0, 16648, 16649, 7, 11, 0, 0, 16649, 2232, 1, 0, 0, 0, 16650, 16651, 7, 7, 0, 0, 16651, 16652, 7, 2, 0, 0, 16652, 16653, 7, 11, 0, 0, 16653, 16654, 7, 2, 0, 0, 16654, 16655, 7, 17, 0, 0, 16655, 2234, 1, 0, 0, 0, 16656, 16657, 7, 7, 0, 0, 16657, 16658, 7, 2, 0, 0, 16658, 16659, 7, 11, 0, 0, 16659, 16660, 7, 2, 0, 0, 16660, 16661, 7, 17, 0, 0, 16661, 16662, 7, 16, 0, 0, 16662, 16663, 7, 10, 0, 0, 16663, 16664, 7, 11, 0, 0, 16664, 16665, 7, 6, 0, 0, 16665, 2236, 1, 0, 0, 0, 16666, 16667, 7, 7, 0, 0, 16667, 16668, 7, 2, 0, 0, 16668, 16669, 7, 11, 0, 0, 16669, 16670, 7, 2, 0, 0, 16670, 16671, 7, 17, 0, 0, 16671, 16672, 7, 17, 0, 0, 16672, 16673, 7, 10, 0, 0, 16673, 16674, 7, 7, 0, 0, 16674, 16675, 7, 17, 0, 0, 16675, 2238, 1, 0, 0, 0, 16676, 16677, 7, 7, 0, 0, 16677, 16678, 7, 2, 0, 0, 16678, 16679, 7, 14, 0, 0, 16679, 16680, 7, 0, 0, 0, 16680, 16681, 7, 15, 0, 0, 16681, 16682, 7, 15, 0, 0, 16682, 16683, 7, 10, 0, 0, 16683, 16684, 7, 7, 0, 0, 16684, 16685, 7, 17, 0, 0, 16685, 2240, 1, 0, 0, 0, 16686, 16687, 7, 7, 0, 0, 16687, 16688, 7, 2, 0, 0, 16688, 16689, 7, 14, 0, 0, 16689, 16690, 7, 0, 0, 0, 16690, 16691, 7, 25, 0, 0, 16691, 16692, 7, 13, 0, 0, 16692, 16693, 7, 0, 0, 0, 16693, 16694, 7, 11, 0, 0, 16694, 16695, 7, 12, 0, 0, 16695, 16696, 7, 6, 0, 0, 16696, 2242, 1, 0, 0, 0, 16697, 16698, 7, 7, 0, 0, 16698, 16699, 7, 2, 0, 0, 16699, 16700, 5, 95, 0, 0, 16700, 16701, 7, 14, 0, 0, 16701, 16702, 7, 6, 0, 0, 16702, 16703, 7, 3, 0, 0, 16703, 16704, 7, 17, 0, 0, 16704, 16705, 7, 6, 0, 0, 16705, 2244, 1, 0, 0, 0, 16706, 16707, 7, 7, 0, 0, 16707, 16708, 7, 2, 0, 0, 16708, 16709, 7, 14, 0, 0, 16709, 16710, 7, 10, 0, 0, 16710, 16711, 7, 7, 0, 0, 16711, 16712, 7, 10, 0, 0, 16712, 16713, 7, 14, 0, 0, 16713, 16714, 7, 10, 0, 0, 16714, 16715, 7, 23, 0, 0, 16715, 16716, 7, 6, 0, 0, 16716, 2246, 1, 0, 0, 0, 16717, 16718, 7, 7, 0, 0, 16718, 16719, 7, 2, 0, 0, 16719, 16720, 7, 14, 0, 0, 16720, 16721, 7, 10, 0, 0, 16721, 16722, 7, 7, 0, 0, 16722, 16723, 7, 13, 0, 0, 16723, 16724, 7, 0, 0, 0, 16724, 16725, 7, 11, 0, 0, 16725, 16726, 7, 12, 0, 0, 16726, 16727, 7, 6, 0, 0, 16727, 2248, 1, 0, 0, 0, 16728, 16729, 7, 7, 0, 0, 16729, 16730, 7, 2, 0, 0, 16730, 16731, 5, 95, 0, 0, 16731, 16732, 7, 14, 0, 0, 16732, 16733, 7, 2, 0, 0, 16733, 16734, 7, 9, 0, 0, 16734, 16735, 7, 6, 0, 0, 16735, 16736, 7, 11, 0, 0, 16736, 16737, 5, 95, 0, 0, 16737, 16738, 7, 15, 0, 0, 16738, 16739, 7, 12, 0, 0, 16739, 16740, 7, 5, 0, 0, 16740, 16741, 7, 19, 0, 0, 16741, 16742, 5, 95, 0, 0, 16742, 16743, 7, 3, 0, 0, 16743, 16744, 7, 6, 0, 0, 16744, 16745, 7, 16, 0, 0, 16745, 2250, 1, 0, 0, 0, 16746, 16747, 7, 7, 0, 0, 16747, 16748, 7, 2, 0, 0, 16748, 16749, 5, 95, 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, 2252, 1, 0, 0, 0, 16760, 16761, 7, 7, 0, 0, 16761, 16762, 7, 2, 0, 0, 16762, 16763, 7, 14, 0, 0, 16763, 16764, 7, 2, 0, 0, 16764, 16765, 7, 7, 0, 0, 16765, 16766, 7, 10, 0, 0, 16766, 16767, 7, 4, 0, 0, 16767, 16768, 7, 2, 0, 0, 16768, 16769, 7, 3, 0, 0, 16769, 16770, 7, 10, 0, 0, 16770, 16771, 7, 7, 0, 0, 16771, 16772, 7, 17, 0, 0, 16772, 2254, 1, 0, 0, 0, 16773, 16774, 7, 7, 0, 0, 16774, 16775, 7, 2, 0, 0, 16775, 16776, 5, 95, 0, 0, 16776, 16777, 7, 14, 0, 0, 16777, 16778, 7, 2, 0, 0, 16778, 16779, 7, 7, 0, 0, 16779, 16780, 7, 10, 0, 0, 16780, 16781, 7, 4, 0, 0, 16781, 16782, 7, 2, 0, 0, 16782, 16783, 7, 3, 0, 0, 16783, 2256, 1, 0, 0, 0, 16784, 16785, 7, 7, 0, 0, 16785, 16786, 7, 2, 0, 0, 16786, 16787, 5, 95, 0, 0, 16787, 16788, 7, 14, 0, 0, 16788, 16789, 7, 12, 0, 0, 16789, 16790, 7, 11, 0, 0, 16790, 16791, 7, 4, 0, 0, 16791, 16792, 7, 10, 0, 0, 16792, 16793, 7, 14, 0, 0, 16793, 16794, 7, 13, 0, 0, 16794, 16795, 5, 95, 0, 0, 16795, 16796, 7, 3, 0, 0, 16796, 16797, 7, 6, 0, 0, 16797, 16798, 7, 22, 0, 0, 16798, 16799, 7, 3, 0, 0, 16799, 16800, 7, 10, 0, 0, 16800, 16801, 7, 4, 0, 0, 16801, 16802, 7, 6, 0, 0, 16802, 2258, 1, 0, 0, 0, 16803, 16804, 7, 7, 0, 0, 16804, 16805, 7, 2, 0, 0, 16805, 16806, 5, 95, 0, 0, 16806, 16807, 7, 7, 0, 0, 16807, 16808, 7, 0, 0, 0, 16808, 16809, 7, 4, 0, 0, 16809, 16810, 7, 10, 0, 0, 16810, 16811, 7, 13, 0, 0, 16811, 16812, 7, 6, 0, 0, 16812, 16813, 5, 95, 0, 0, 16813, 16814, 7, 16, 0, 0, 16814, 16815, 7, 12, 0, 0, 16815, 16816, 7, 11, 0, 0, 16816, 16817, 7, 11, 0, 0, 16817, 16818, 5, 95, 0, 0, 16818, 16819, 7, 2, 0, 0, 16819, 16820, 7, 12, 0, 0, 16820, 16821, 7, 4, 0, 0, 16821, 16822, 7, 6, 0, 0, 16822, 16823, 7, 3, 0, 0, 16823, 16824, 5, 95, 0, 0, 16824, 16825, 7, 20, 0, 0, 16825, 16826, 7, 2, 0, 0, 16826, 16827, 7, 10, 0, 0, 16827, 16828, 7, 7, 0, 0, 16828, 2260, 1, 0, 0, 0, 16829, 16830, 7, 7, 0, 0, 16830, 16831, 7, 2, 0, 0, 16831, 16832, 7, 7, 0, 0, 16832, 16833, 7, 1, 0, 0, 16833, 16834, 7, 11, 0, 0, 16834, 16835, 7, 2, 0, 0, 16835, 16836, 7, 8, 0, 0, 16836, 16837, 7, 21, 0, 0, 16837, 16838, 7, 10, 0, 0, 16838, 16839, 7, 7, 0, 0, 16839, 16840, 7, 17, 0, 0, 16840, 2262, 1, 0, 0, 0, 16841, 16842, 7, 7, 0, 0, 16842, 16843, 7, 2, 0, 0, 16843, 16844, 7, 7, 0, 0, 16844, 16845, 7, 6, 0, 0, 16845, 16846, 7, 9, 0, 0, 16846, 16847, 7, 10, 0, 0, 16847, 16848, 7, 4, 0, 0, 16848, 16849, 7, 10, 0, 0, 16849, 16850, 7, 2, 0, 0, 16850, 16851, 7, 7, 0, 0, 16851, 16852, 7, 0, 0, 0, 16852, 16853, 7, 1, 0, 0, 16853, 16854, 7, 11, 0, 0, 16854, 16855, 7, 6, 0, 0, 16855, 2264, 1, 0, 0, 0, 16856, 16857, 7, 7, 0, 0, 16857, 16858, 7, 2, 0, 0, 16858, 16859, 7, 7, 0, 0, 16859, 16860, 7, 6, 0, 0, 16860, 2266, 1, 0, 0, 0, 16861, 16862, 7, 7, 0, 0, 16862, 16863, 7, 2, 0, 0, 16863, 16864, 7, 7, 0, 0, 16864, 16865, 7, 12, 0, 0, 16865, 16866, 7, 11, 0, 0, 16866, 16867, 7, 11, 0, 0, 16867, 16868, 7, 10, 0, 0, 16868, 16869, 7, 16, 0, 0, 16869, 2268, 1, 0, 0, 0, 16870, 16871, 7, 7, 0, 0, 16871, 16872, 7, 2, 0, 0, 16872, 16873, 5, 95, 0, 0, 16873, 16874, 7, 7, 0, 0, 16874, 16875, 7, 11, 0, 0, 16875, 16876, 7, 20, 0, 0, 16876, 16877, 5, 95, 0, 0, 16877, 16878, 7, 1, 0, 0, 16878, 16879, 7, 0, 0, 0, 16879, 16880, 7, 4, 0, 0, 16880, 16881, 7, 8, 0, 0, 16881, 16882, 7, 19, 0, 0, 16882, 16883, 7, 10, 0, 0, 16883, 16884, 7, 7, 0, 0, 16884, 16885, 7, 17, 0, 0, 16885, 2270, 1, 0, 0, 0, 16886, 16887, 7, 7, 0, 0, 16887, 16888, 7, 2, 0, 0, 16888, 16889, 5, 95, 0, 0, 16889, 16890, 7, 7, 0, 0, 16890, 16891, 7, 11, 0, 0, 16891, 16892, 7, 20, 0, 0, 16892, 16893, 5, 95, 0, 0, 16893, 16894, 7, 15, 0, 0, 16894, 16895, 7, 3, 0, 0, 16895, 16896, 7, 6, 0, 0, 16896, 16897, 7, 16, 0, 0, 16897, 16898, 7, 6, 0, 0, 16898, 16899, 7, 4, 0, 0, 16899, 16900, 7, 8, 0, 0, 16900, 16901, 7, 19, 0, 0, 16901, 2272, 1, 0, 0, 0, 16902, 16903, 7, 7, 0, 0, 16903, 16904, 7, 2, 0, 0, 16904, 2274, 1, 0, 0, 0, 16905, 16906, 7, 7, 0, 0, 16906, 16907, 7, 2, 0, 0, 16907, 16908, 7, 7, 0, 0, 16908, 16909, 7, 5, 0, 0, 16909, 16910, 7, 8, 0, 0, 16910, 16911, 7, 19, 0, 0, 16911, 16912, 7, 6, 0, 0, 16912, 16913, 7, 14, 0, 0, 16913, 16914, 7, 0, 0, 0, 16914, 2276, 1, 0, 0, 0, 16915, 16916, 7, 7, 0, 0, 16916, 16917, 7, 2, 0, 0, 16917, 16918, 5, 95, 0, 0, 16918, 16919, 7, 2, 0, 0, 16919, 16920, 7, 1, 0, 0, 16920, 16921, 7, 20, 0, 0, 16921, 16922, 7, 6, 0, 0, 16922, 16923, 7, 8, 0, 0, 16923, 16924, 7, 4, 0, 0, 16924, 16925, 5, 95, 0, 0, 16925, 16926, 7, 11, 0, 0, 16926, 16927, 7, 10, 0, 0, 16927, 16928, 7, 7, 0, 0, 16928, 16929, 7, 21, 0, 0, 16929, 2278, 1, 0, 0, 0, 16930, 16931, 7, 7, 0, 0, 16931, 16932, 7, 2, 0, 0, 16932, 16933, 7, 2, 0, 0, 16933, 16934, 7, 3, 0, 0, 16934, 16935, 7, 9, 0, 0, 16935, 16936, 7, 6, 0, 0, 16936, 16937, 7, 3, 0, 0, 16937, 2280, 1, 0, 0, 0, 16938, 16939, 7, 7, 0, 0, 16939, 16940, 7, 2, 0, 0, 16940, 16941, 5, 95, 0, 0, 16941, 16942, 7, 2, 0, 0, 16942, 16943, 7, 3, 0, 0, 16943, 16944, 7, 9, 0, 0, 16944, 16945, 7, 6, 0, 0, 16945, 16946, 7, 3, 0, 0, 16946, 16947, 5, 95, 0, 0, 16947, 16948, 7, 3, 0, 0, 16948, 16949, 7, 2, 0, 0, 16949, 16950, 7, 11, 0, 0, 16950, 16951, 7, 11, 0, 0, 16951, 16952, 7, 12, 0, 0, 16952, 16953, 7, 15, 0, 0, 16953, 16954, 7, 5, 0, 0, 16954, 2282, 1, 0, 0, 0, 16955, 16956, 7, 7, 0, 0, 16956, 16957, 7, 2, 0, 0, 16957, 16958, 5, 95, 0, 0, 16958, 16959, 7, 2, 0, 0, 16959, 16960, 7, 12, 0, 0, 16960, 16961, 7, 4, 0, 0, 16961, 16962, 7, 6, 0, 0, 16962, 16963, 7, 3, 0, 0, 16963, 16964, 5, 95, 0, 0, 16964, 16965, 7, 20, 0, 0, 16965, 16966, 7, 2, 0, 0, 16966, 16967, 7, 10, 0, 0, 16967, 16968, 7, 7, 0, 0, 16968, 16969, 5, 95, 0, 0, 16969, 16970, 7, 4, 0, 0, 16970, 16971, 7, 2, 0, 0, 16971, 16972, 5, 95, 0, 0, 16972, 16973, 7, 0, 0, 0, 16973, 16974, 7, 7, 0, 0, 16974, 16975, 7, 4, 0, 0, 16975, 16976, 7, 10, 0, 0, 16976, 2284, 1, 0, 0, 0, 16977, 16978, 7, 7, 0, 0, 16978, 16979, 7, 2, 0, 0, 16979, 16980, 5, 95, 0, 0, 16980, 16981, 7, 2, 0, 0, 16981, 16982, 7, 12, 0, 0, 16982, 16983, 7, 4, 0, 0, 16983, 16984, 7, 6, 0, 0, 16984, 16985, 7, 3, 0, 0, 16985, 16986, 5, 95, 0, 0, 16986, 16987, 7, 20, 0, 0, 16987, 16988, 7, 2, 0, 0, 16988, 16989, 7, 10, 0, 0, 16989, 16990, 7, 7, 0, 0, 16990, 16991, 5, 95, 0, 0, 16991, 16992, 7, 4, 0, 0, 16992, 16993, 7, 2, 0, 0, 16993, 16994, 5, 95, 0, 0, 16994, 16995, 7, 10, 0, 0, 16995, 16996, 7, 7, 0, 0, 16996, 16997, 7, 7, 0, 0, 16997, 16998, 7, 6, 0, 0, 16998, 16999, 7, 3, 0, 0, 16999, 2286, 1, 0, 0, 0, 17000, 17001, 7, 7, 0, 0, 17001, 17002, 7, 2, 0, 0, 17002, 17003, 7, 2, 0, 0, 17003, 17004, 7, 13, 0, 0, 17004, 17005, 7, 6, 0, 0, 17005, 17006, 7, 3, 0, 0, 17006, 17007, 7, 3, 0, 0, 17007, 17008, 7, 10, 0, 0, 17008, 17009, 7, 9, 0, 0, 17009, 17010, 7, 6, 0, 0, 17010, 2288, 1, 0, 0, 0, 17011, 17012, 7, 7, 0, 0, 17012, 17013, 7, 2, 0, 0, 17013, 17014, 5, 95, 0, 0, 17014, 17015, 7, 15, 0, 0, 17015, 17016, 7, 0, 0, 0, 17016, 17017, 7, 3, 0, 0, 17017, 17018, 7, 0, 0, 0, 17018, 17019, 7, 11, 0, 0, 17019, 17020, 7, 11, 0, 0, 17020, 17021, 7, 6, 0, 0, 17021, 17022, 7, 11, 0, 0, 17022, 17023, 5, 95, 0, 0, 17023, 17024, 7, 10, 0, 0, 17024, 17025, 7, 7, 0, 0, 17025, 17026, 7, 9, 0, 0, 17026, 17027, 7, 6, 0, 0, 17027, 17028, 7, 25, 0, 0, 17028, 2290, 1, 0, 0, 0, 17029, 17030, 7, 7, 0, 0, 17030, 17031, 7, 2, 0, 0, 17031, 17032, 7, 15, 0, 0, 17032, 17033, 7, 0, 0, 0, 17033, 17034, 7, 3, 0, 0, 17034, 17035, 7, 0, 0, 0, 17035, 17036, 7, 11, 0, 0, 17036, 17037, 7, 11, 0, 0, 17037, 17038, 7, 6, 0, 0, 17038, 17039, 7, 11, 0, 0, 17039, 17040, 5, 95, 0, 0, 17040, 17041, 7, 10, 0, 0, 17041, 17042, 7, 7, 0, 0, 17042, 17043, 7, 9, 0, 0, 17043, 17044, 7, 6, 0, 0, 17044, 17045, 7, 25, 0, 0, 17045, 2292, 1, 0, 0, 0, 17046, 17047, 7, 7, 0, 0, 17047, 17048, 7, 2, 0, 0, 17048, 17049, 5, 95, 0, 0, 17049, 17050, 7, 15, 0, 0, 17050, 17051, 7, 0, 0, 0, 17051, 17052, 7, 3, 0, 0, 17052, 17053, 7, 0, 0, 0, 17053, 17054, 7, 11, 0, 0, 17054, 17055, 7, 11, 0, 0, 17055, 17056, 7, 6, 0, 0, 17056, 17057, 7, 11, 0, 0, 17057, 2294, 1, 0, 0, 0, 17058, 17059, 7, 7, 0, 0, 17059, 17060, 7, 2, 0, 0, 17060, 17061, 7, 15, 0, 0, 17061, 17062, 7, 0, 0, 0, 17062, 17063, 7, 3, 0, 0, 17063, 17064, 7, 0, 0, 0, 17064, 17065, 7, 11, 0, 0, 17065, 17066, 7, 11, 0, 0, 17066, 17067, 7, 6, 0, 0, 17067, 17068, 7, 11, 0, 0, 17068, 2296, 1, 0, 0, 0, 17069, 17070, 7, 7, 0, 0, 17070, 17071, 7, 2, 0, 0, 17071, 17072, 5, 95, 0, 0, 17072, 17073, 7, 15, 0, 0, 17073, 17074, 7, 0, 0, 0, 17074, 17075, 7, 3, 0, 0, 17075, 17076, 7, 4, 0, 0, 17076, 17077, 7, 10, 0, 0, 17077, 17078, 7, 0, 0, 0, 17078, 17079, 7, 11, 0, 0, 17079, 17080, 5, 95, 0, 0, 17080, 17081, 7, 8, 0, 0, 17081, 17082, 7, 2, 0, 0, 17082, 17083, 7, 14, 0, 0, 17083, 17084, 7, 14, 0, 0, 17084, 17085, 7, 10, 0, 0, 17085, 17086, 7, 4, 0, 0, 17086, 2298, 1, 0, 0, 0, 17087, 17088, 7, 7, 0, 0, 17088, 17089, 7, 2, 0, 0, 17089, 17090, 5, 95, 0, 0, 17090, 17091, 7, 15, 0, 0, 17091, 17092, 7, 0, 0, 0, 17092, 17093, 7, 3, 0, 0, 17093, 17094, 7, 4, 0, 0, 17094, 17095, 7, 10, 0, 0, 17095, 17096, 7, 0, 0, 0, 17096, 17097, 7, 11, 0, 0, 17097, 17098, 5, 95, 0, 0, 17098, 17099, 7, 20, 0, 0, 17099, 17100, 7, 2, 0, 0, 17100, 17101, 7, 10, 0, 0, 17101, 17102, 7, 7, 0, 0, 17102, 2300, 1, 0, 0, 0, 17103, 17104, 7, 7, 0, 0, 17104, 17105, 7, 2, 0, 0, 17105, 17106, 5, 95, 0, 0, 17106, 17107, 7, 15, 0, 0, 17107, 17108, 7, 0, 0, 0, 17108, 17109, 7, 3, 0, 0, 17109, 17110, 7, 4, 0, 0, 17110, 17111, 7, 10, 0, 0, 17111, 17112, 7, 0, 0, 0, 17112, 17113, 7, 11, 0, 0, 17113, 17114, 5, 95, 0, 0, 17114, 17115, 7, 3, 0, 0, 17115, 17116, 7, 2, 0, 0, 17116, 17117, 7, 11, 0, 0, 17117, 17118, 7, 11, 0, 0, 17118, 17119, 7, 12, 0, 0, 17119, 17120, 7, 15, 0, 0, 17120, 17121, 5, 95, 0, 0, 17121, 17122, 7, 15, 0, 0, 17122, 17123, 7, 12, 0, 0, 17123, 17124, 7, 5, 0, 0, 17124, 17125, 7, 19, 0, 0, 17125, 17126, 7, 9, 0, 0, 17126, 17127, 7, 2, 0, 0, 17127, 17128, 7, 22, 0, 0, 17128, 17129, 7, 7, 0, 0, 17129, 2302, 1, 0, 0, 0, 17130, 17131, 7, 7, 0, 0, 17131, 17132, 7, 2, 0, 0, 17132, 17133, 7, 15, 0, 0, 17133, 17134, 7, 0, 0, 0, 17134, 17135, 7, 3, 0, 0, 17135, 17136, 7, 4, 0, 0, 17136, 17137, 7, 10, 0, 0, 17137, 17138, 7, 4, 0, 0, 17138, 17139, 7, 10, 0, 0, 17139, 17140, 7, 2, 0, 0, 17140, 17141, 7, 7, 0, 0, 17141, 2304, 1, 0, 0, 0, 17142, 17143, 7, 7, 0, 0, 17143, 17144, 7, 2, 0, 0, 17144, 17145, 5, 95, 0, 0, 17145, 17146, 7, 15, 0, 0, 17146, 17147, 7, 11, 0, 0, 17147, 17148, 7, 0, 0, 0, 17148, 17149, 7, 8, 0, 0, 17149, 17150, 7, 6, 0, 0, 17150, 17151, 5, 95, 0, 0, 17151, 17152, 7, 9, 0, 0, 17152, 17153, 7, 10, 0, 0, 17153, 17154, 7, 5, 0, 0, 17154, 17155, 7, 4, 0, 0, 17155, 17156, 7, 10, 0, 0, 17156, 17157, 7, 7, 0, 0, 17157, 17158, 7, 8, 0, 0, 17158, 17159, 7, 4, 0, 0, 17159, 2306, 1, 0, 0, 0, 17160, 17161, 7, 7, 0, 0, 17161, 17162, 7, 2, 0, 0, 17162, 17163, 5, 95, 0, 0, 17163, 17164, 7, 15, 0, 0, 17164, 17165, 7, 11, 0, 0, 17165, 17166, 7, 0, 0, 0, 17166, 17167, 7, 8, 0, 0, 17167, 17168, 7, 6, 0, 0, 17168, 17169, 5, 95, 0, 0, 17169, 17170, 7, 17, 0, 0, 17170, 17171, 7, 3, 0, 0, 17171, 17172, 7, 2, 0, 0, 17172, 17173, 7, 12, 0, 0, 17173, 17174, 7, 15, 0, 0, 17174, 17175, 5, 95, 0, 0, 17175, 17176, 7, 1, 0, 0, 17176, 17177, 7, 18, 0, 0, 17177, 2308, 1, 0, 0, 0, 17178, 17179, 7, 7, 0, 0, 17179, 17180, 7, 2, 0, 0, 17180, 17181, 5, 95, 0, 0, 17181, 17182, 7, 15, 0, 0, 17182, 17183, 7, 24, 0, 0, 17183, 17184, 5, 95, 0, 0, 17184, 17185, 7, 8, 0, 0, 17185, 17186, 7, 2, 0, 0, 17186, 17187, 7, 7, 0, 0, 17187, 17188, 7, 8, 0, 0, 17188, 17189, 7, 12, 0, 0, 17189, 17190, 7, 3, 0, 0, 17190, 17191, 7, 3, 0, 0, 17191, 17192, 7, 6, 0, 0, 17192, 17193, 7, 7, 0, 0, 17193, 17194, 7, 4, 0, 0, 17194, 17195, 5, 95, 0, 0, 17195, 17196, 7, 12, 0, 0, 17196, 17197, 7, 7, 0, 0, 17197, 17198, 7, 10, 0, 0, 17198, 17199, 7, 2, 0, 0, 17199, 17200, 7, 7, 0, 0, 17200, 2310, 1, 0, 0, 0, 17201, 17202, 7, 7, 0, 0, 17202, 17203, 7, 2, 0, 0, 17203, 17204, 5, 95, 0, 0, 17204, 17205, 7, 15, 0, 0, 17205, 17206, 7, 24, 0, 0, 17206, 17207, 5, 95, 0, 0, 17207, 17208, 7, 14, 0, 0, 17208, 17209, 7, 0, 0, 0, 17209, 17210, 7, 15, 0, 0, 17210, 2312, 1, 0, 0, 0, 17211, 17212, 7, 7, 0, 0, 17212, 17213, 7, 2, 0, 0, 17213, 17214, 7, 15, 0, 0, 17214, 17215, 7, 3, 0, 0, 17215, 17216, 7, 2, 0, 0, 17216, 17217, 7, 14, 0, 0, 17217, 17218, 7, 15, 0, 0, 17218, 17219, 7, 4, 0, 0, 17219, 2314, 1, 0, 0, 0, 17220, 17221, 7, 7, 0, 0, 17221, 17222, 7, 2, 0, 0, 17222, 17223, 5, 95, 0, 0, 17223, 17224, 7, 15, 0, 0, 17224, 17225, 7, 24, 0, 0, 17225, 17226, 5, 95, 0, 0, 17226, 17227, 7, 3, 0, 0, 17227, 17228, 7, 6, 0, 0, 17228, 17229, 7, 15, 0, 0, 17229, 17230, 7, 11, 0, 0, 17230, 17231, 7, 10, 0, 0, 17231, 17232, 7, 8, 0, 0, 17232, 17233, 7, 0, 0, 0, 17233, 17234, 7, 4, 0, 0, 17234, 17235, 7, 6, 0, 0, 17235, 2316, 1, 0, 0, 0, 17236, 17237, 7, 7, 0, 0, 17237, 17238, 7, 2, 0, 0, 17238, 17239, 5, 95, 0, 0, 17239, 17240, 7, 15, 0, 0, 17240, 17241, 7, 24, 0, 0, 17241, 17242, 5, 95, 0, 0, 17242, 17243, 7, 5, 0, 0, 17243, 17244, 7, 21, 0, 0, 17244, 17245, 7, 6, 0, 0, 17245, 17246, 7, 22, 0, 0, 17246, 2318, 1, 0, 0, 0, 17247, 17248, 7, 7, 0, 0, 17248, 17249, 7, 2, 0, 0, 17249, 17250, 5, 95, 0, 0, 17250, 17251, 7, 15, 0, 0, 17251, 17252, 7, 3, 0, 0, 17252, 17253, 7, 12, 0, 0, 17253, 17254, 7, 7, 0, 0, 17254, 17255, 7, 6, 0, 0, 17255, 17256, 5, 95, 0, 0, 17256, 17257, 7, 17, 0, 0, 17257, 17258, 7, 5, 0, 0, 17258, 17259, 7, 6, 0, 0, 17259, 17260, 7, 4, 0, 0, 17260, 17261, 7, 5, 0, 0, 17261, 2320, 1, 0, 0, 0, 17262, 17263, 7, 7, 0, 0, 17263, 17264, 7, 2, 0, 0, 17264, 17265, 5, 95, 0, 0, 17265, 17266, 7, 15, 0, 0, 17266, 17267, 7, 12, 0, 0, 17267, 17268, 7, 11, 0, 0, 17268, 17269, 7, 11, 0, 0, 17269, 17270, 5, 95, 0, 0, 17270, 17271, 7, 15, 0, 0, 17271, 17272, 7, 3, 0, 0, 17272, 17273, 7, 6, 0, 0, 17273, 17274, 7, 9, 0, 0, 17274, 2322, 1, 0, 0, 0, 17275, 17276, 7, 7, 0, 0, 17276, 17277, 7, 2, 0, 0, 17277, 17278, 5, 95, 0, 0, 17278, 17279, 7, 15, 0, 0, 17279, 17280, 7, 12, 0, 0, 17280, 17281, 7, 5, 0, 0, 17281, 17282, 7, 19, 0, 0, 17282, 17283, 5, 95, 0, 0, 17283, 17284, 7, 15, 0, 0, 17284, 17285, 7, 3, 0, 0, 17285, 17286, 7, 6, 0, 0, 17286, 17287, 7, 9, 0, 0, 17287, 2324, 1, 0, 0, 0, 17288, 17289, 7, 7, 0, 0, 17289, 17290, 7, 2, 0, 0, 17290, 17291, 5, 95, 0, 0, 17291, 17292, 7, 15, 0, 0, 17292, 17293, 7, 12, 0, 0, 17293, 17294, 7, 5, 0, 0, 17294, 17295, 7, 19, 0, 0, 17295, 17296, 5, 95, 0, 0, 17296, 17297, 7, 5, 0, 0, 17297, 17298, 7, 12, 0, 0, 17298, 17299, 7, 1, 0, 0, 17299, 17300, 7, 24, 0, 0, 17300, 2326, 1, 0, 0, 0, 17301, 17302, 7, 7, 0, 0, 17302, 17303, 7, 2, 0, 0, 17303, 17304, 5, 95, 0, 0, 17304, 17305, 7, 15, 0, 0, 17305, 17306, 7, 25, 0, 0, 17306, 17307, 5, 95, 0, 0, 17307, 17308, 7, 16, 0, 0, 17308, 17309, 7, 0, 0, 0, 17309, 17310, 7, 12, 0, 0, 17310, 17311, 7, 11, 0, 0, 17311, 17312, 7, 4, 0, 0, 17312, 17313, 5, 95, 0, 0, 17313, 17314, 7, 4, 0, 0, 17314, 17315, 7, 2, 0, 0, 17315, 17316, 7, 11, 0, 0, 17316, 17317, 7, 6, 0, 0, 17317, 17318, 7, 3, 0, 0, 17318, 17319, 7, 0, 0, 0, 17319, 17320, 7, 7, 0, 0, 17320, 17321, 7, 8, 0, 0, 17321, 17322, 7, 6, 0, 0, 17322, 2328, 1, 0, 0, 0, 17323, 17324, 7, 7, 0, 0, 17324, 17325, 7, 2, 0, 0, 17325, 17326, 5, 95, 0, 0, 17326, 17327, 7, 15, 0, 0, 17327, 17328, 7, 25, 0, 0, 17328, 17329, 5, 95, 0, 0, 17329, 17330, 7, 20, 0, 0, 17330, 17331, 7, 2, 0, 0, 17331, 17332, 7, 10, 0, 0, 17332, 17333, 7, 7, 0, 0, 17333, 17334, 5, 95, 0, 0, 17334, 17335, 7, 16, 0, 0, 17335, 17336, 7, 10, 0, 0, 17336, 17337, 7, 11, 0, 0, 17337, 17338, 7, 4, 0, 0, 17338, 17339, 7, 6, 0, 0, 17339, 17340, 7, 3, 0, 0, 17340, 2330, 1, 0, 0, 0, 17341, 17342, 7, 7, 0, 0, 17342, 17343, 7, 2, 0, 0, 17343, 17344, 5, 95, 0, 0, 17344, 17345, 7, 24, 0, 0, 17345, 17346, 7, 21, 0, 0, 17346, 17347, 7, 7, 0, 0, 17347, 17348, 5, 95, 0, 0, 17348, 17349, 7, 1, 0, 0, 17349, 17350, 7, 12, 0, 0, 17350, 17351, 7, 16, 0, 0, 17351, 17352, 7, 16, 0, 0, 17352, 2332, 1, 0, 0, 0, 17353, 17354, 7, 7, 0, 0, 17354, 17355, 7, 2, 0, 0, 17355, 17356, 5, 95, 0, 0, 17356, 17357, 7, 24, 0, 0, 17357, 17358, 7, 12, 0, 0, 17358, 17359, 7, 6, 0, 0, 17359, 17360, 7, 3, 0, 0, 17360, 17361, 7, 18, 0, 0, 17361, 17362, 5, 95, 0, 0, 17362, 17363, 7, 4, 0, 0, 17363, 17364, 7, 3, 0, 0, 17364, 17365, 7, 0, 0, 0, 17365, 17366, 7, 7, 0, 0, 17366, 17367, 7, 5, 0, 0, 17367, 17368, 7, 16, 0, 0, 17368, 17369, 7, 2, 0, 0, 17369, 17370, 7, 3, 0, 0, 17370, 17371, 7, 14, 0, 0, 17371, 17372, 7, 0, 0, 0, 17372, 17373, 7, 4, 0, 0, 17373, 17374, 7, 10, 0, 0, 17374, 17375, 7, 2, 0, 0, 17375, 17376, 7, 7, 0, 0, 17376, 2334, 1, 0, 0, 0, 17377, 17378, 7, 7, 0, 0, 17378, 17379, 7, 2, 0, 0, 17379, 17380, 5, 95, 0, 0, 17380, 17381, 7, 3, 0, 0, 17381, 17382, 7, 6, 0, 0, 17382, 17383, 7, 16, 0, 0, 17383, 17384, 5, 95, 0, 0, 17384, 17385, 7, 8, 0, 0, 17385, 17386, 7, 0, 0, 0, 17386, 17387, 7, 5, 0, 0, 17387, 17388, 7, 8, 0, 0, 17388, 17389, 7, 0, 0, 0, 17389, 17390, 7, 9, 0, 0, 17390, 17391, 7, 6, 0, 0, 17391, 2336, 1, 0, 0, 0, 17392, 17393, 7, 7, 0, 0, 17393, 17394, 7, 2, 0, 0, 17394, 17395, 7, 3, 0, 0, 17395, 17396, 7, 6, 0, 0, 17396, 17397, 7, 11, 0, 0, 17397, 17398, 7, 2, 0, 0, 17398, 17399, 7, 8, 0, 0, 17399, 17400, 7, 0, 0, 0, 17400, 17401, 7, 4, 0, 0, 17401, 17402, 7, 6, 0, 0, 17402, 2338, 1, 0, 0, 0, 17403, 17404, 7, 7, 0, 0, 17404, 17405, 7, 2, 0, 0, 17405, 17406, 7, 3, 0, 0, 17406, 17407, 7, 6, 0, 0, 17407, 17408, 7, 11, 0, 0, 17408, 17409, 7, 18, 0, 0, 17409, 2340, 1, 0, 0, 0, 17410, 17411, 7, 7, 0, 0, 17411, 17412, 7, 2, 0, 0, 17412, 17413, 7, 3, 0, 0, 17413, 17414, 7, 6, 0, 0, 17414, 17415, 7, 15, 0, 0, 17415, 17416, 7, 0, 0, 0, 17416, 17417, 7, 10, 0, 0, 17417, 17418, 7, 3, 0, 0, 17418, 2342, 1, 0, 0, 0, 17419, 17420, 7, 7, 0, 0, 17420, 17421, 7, 2, 0, 0, 17421, 17422, 7, 3, 0, 0, 17422, 17423, 7, 6, 0, 0, 17423, 17424, 7, 15, 0, 0, 17424, 17425, 7, 11, 0, 0, 17425, 17426, 7, 0, 0, 0, 17426, 17427, 7, 18, 0, 0, 17427, 2344, 1, 0, 0, 0, 17428, 17429, 7, 7, 0, 0, 17429, 17430, 7, 2, 0, 0, 17430, 17431, 7, 3, 0, 0, 17431, 17432, 7, 6, 0, 0, 17432, 17433, 7, 5, 0, 0, 17433, 17434, 7, 6, 0, 0, 17434, 17435, 7, 4, 0, 0, 17435, 17436, 7, 11, 0, 0, 17436, 17437, 7, 2, 0, 0, 17437, 17438, 7, 17, 0, 0, 17438, 17439, 7, 5, 0, 0, 17439, 2346, 1, 0, 0, 0, 17440, 17441, 7, 7, 0, 0, 17441, 17442, 7, 2, 0, 0, 17442, 17443, 5, 95, 0, 0, 17443, 17444, 7, 3, 0, 0, 17444, 17445, 7, 6, 0, 0, 17445, 17446, 7, 5, 0, 0, 17446, 17447, 7, 12, 0, 0, 17447, 17448, 7, 11, 0, 0, 17448, 17449, 7, 4, 0, 0, 17449, 17450, 5, 95, 0, 0, 17450, 17451, 7, 8, 0, 0, 17451, 17452, 7, 0, 0, 0, 17452, 17453, 7, 8, 0, 0, 17453, 17454, 7, 19, 0, 0, 17454, 17455, 7, 6, 0, 0, 17455, 2348, 1, 0, 0, 0, 17456, 17457, 7, 7, 0, 0, 17457, 17458, 7, 2, 0, 0, 17458, 17459, 7, 3, 0, 0, 17459, 17460, 7, 6, 0, 0, 17460, 17461, 7, 13, 0, 0, 17461, 17462, 7, 6, 0, 0, 17462, 17463, 7, 3, 0, 0, 17463, 17464, 7, 5, 0, 0, 17464, 17465, 7, 6, 0, 0, 17465, 2350, 1, 0, 0, 0, 17466, 17467, 7, 7, 0, 0, 17467, 17468, 7, 2, 0, 0, 17468, 17469, 5, 95, 0, 0, 17469, 17470, 7, 3, 0, 0, 17470, 17471, 7, 6, 0, 0, 17471, 17472, 7, 22, 0, 0, 17472, 17473, 7, 3, 0, 0, 17473, 17474, 7, 10, 0, 0, 17474, 17475, 7, 4, 0, 0, 17475, 17476, 7, 6, 0, 0, 17476, 2352, 1, 0, 0, 0, 17477, 17478, 7, 7, 0, 0, 17478, 17479, 7, 2, 0, 0, 17479, 17480, 7, 3, 0, 0, 17480, 17481, 7, 6, 0, 0, 17481, 17482, 7, 22, 0, 0, 17482, 17483, 7, 3, 0, 0, 17483, 17484, 7, 10, 0, 0, 17484, 17485, 7, 4, 0, 0, 17485, 17486, 7, 6, 0, 0, 17486, 2354, 1, 0, 0, 0, 17487, 17488, 7, 7, 0, 0, 17488, 17489, 7, 2, 0, 0, 17489, 17490, 7, 3, 0, 0, 17490, 17491, 7, 14, 0, 0, 17491, 17492, 7, 0, 0, 0, 17492, 17493, 7, 11, 0, 0, 17493, 2356, 1, 0, 0, 0, 17494, 17495, 7, 7, 0, 0, 17495, 17496, 7, 2, 0, 0, 17496, 17497, 5, 95, 0, 0, 17497, 17498, 7, 3, 0, 0, 17498, 17499, 7, 2, 0, 0, 17499, 17500, 7, 2, 0, 0, 17500, 17501, 7, 4, 0, 0, 17501, 17502, 5, 95, 0, 0, 17502, 17503, 7, 5, 0, 0, 17503, 17504, 7, 22, 0, 0, 17504, 17505, 5, 95, 0, 0, 17505, 17506, 7, 16, 0, 0, 17506, 17507, 7, 2, 0, 0, 17507, 17508, 7, 3, 0, 0, 17508, 17509, 5, 95, 0, 0, 17509, 17510, 7, 11, 0, 0, 17510, 17511, 7, 2, 0, 0, 17511, 17512, 7, 8, 0, 0, 17512, 17513, 7, 0, 0, 0, 17513, 17514, 7, 11, 0, 0, 17514, 2358, 1, 0, 0, 0, 17515, 17516, 7, 7, 0, 0, 17516, 17517, 7, 2, 0, 0, 17517, 17518, 7, 3, 0, 0, 17518, 17519, 7, 2, 0, 0, 17519, 17520, 7, 22, 0, 0, 17520, 17521, 7, 9, 0, 0, 17521, 17522, 7, 6, 0, 0, 17522, 17523, 7, 15, 0, 0, 17523, 17524, 7, 6, 0, 0, 17524, 17525, 7, 7, 0, 0, 17525, 17526, 7, 9, 0, 0, 17526, 17527, 7, 6, 0, 0, 17527, 17528, 7, 7, 0, 0, 17528, 17529, 7, 8, 0, 0, 17529, 17530, 7, 10, 0, 0, 17530, 17531, 7, 6, 0, 0, 17531, 17532, 7, 5, 0, 0, 17532, 2360, 1, 0, 0, 0, 17533, 17534, 7, 7, 0, 0, 17534, 17535, 7, 2, 0, 0, 17535, 17536, 7, 5, 0, 0, 17536, 17537, 7, 8, 0, 0, 17537, 17538, 7, 0, 0, 0, 17538, 17539, 7, 11, 0, 0, 17539, 17540, 7, 6, 0, 0, 17540, 2362, 1, 0, 0, 0, 17541, 17542, 7, 7, 0, 0, 17542, 17543, 7, 2, 0, 0, 17543, 17544, 7, 5, 0, 0, 17544, 17545, 7, 8, 0, 0, 17545, 17546, 7, 19, 0, 0, 17546, 17547, 7, 6, 0, 0, 17547, 17548, 7, 14, 0, 0, 17548, 17549, 7, 0, 0, 0, 17549, 17550, 7, 8, 0, 0, 17550, 17551, 7, 19, 0, 0, 17551, 17552, 7, 6, 0, 0, 17552, 17553, 7, 8, 0, 0, 17553, 17554, 7, 21, 0, 0, 17554, 2364, 1, 0, 0, 0, 17555, 17556, 7, 7, 0, 0, 17556, 17557, 7, 2, 0, 0, 17557, 17558, 7, 5, 0, 0, 17558, 17559, 7, 6, 0, 0, 17559, 17560, 7, 17, 0, 0, 17560, 17561, 7, 14, 0, 0, 17561, 17562, 7, 6, 0, 0, 17562, 17563, 7, 7, 0, 0, 17563, 17564, 7, 4, 0, 0, 17564, 2366, 1, 0, 0, 0, 17565, 17566, 7, 7, 0, 0, 17566, 17567, 7, 2, 0, 0, 17567, 17568, 5, 95, 0, 0, 17568, 17569, 7, 5, 0, 0, 17569, 17570, 7, 6, 0, 0, 17570, 17571, 7, 14, 0, 0, 17571, 17572, 7, 10, 0, 0, 17572, 17573, 7, 20, 0, 0, 17573, 17574, 7, 2, 0, 0, 17574, 17575, 7, 10, 0, 0, 17575, 17576, 7, 7, 0, 0, 17576, 2368, 1, 0, 0, 0, 17577, 17578, 7, 7, 0, 0, 17578, 17579, 7, 2, 0, 0, 17579, 17580, 5, 95, 0, 0, 17580, 17581, 7, 5, 0, 0, 17581, 17582, 7, 6, 0, 0, 17582, 17583, 7, 14, 0, 0, 17583, 17584, 7, 10, 0, 0, 17584, 17585, 5, 95, 0, 0, 17585, 17586, 7, 4, 0, 0, 17586, 17587, 7, 2, 0, 0, 17587, 17588, 5, 95, 0, 0, 17588, 17589, 7, 10, 0, 0, 17589, 17590, 7, 7, 0, 0, 17590, 17591, 7, 7, 0, 0, 17591, 17592, 7, 6, 0, 0, 17592, 17593, 7, 3, 0, 0, 17593, 2370, 1, 0, 0, 0, 17594, 17595, 7, 7, 0, 0, 17595, 17596, 7, 2, 0, 0, 17596, 17597, 5, 95, 0, 0, 17597, 17598, 7, 5, 0, 0, 17598, 17599, 7, 6, 0, 0, 17599, 17600, 7, 4, 0, 0, 17600, 17601, 5, 95, 0, 0, 17601, 17602, 7, 4, 0, 0, 17602, 17603, 7, 2, 0, 0, 17603, 17604, 5, 95, 0, 0, 17604, 17605, 7, 20, 0, 0, 17605, 17606, 7, 2, 0, 0, 17606, 17607, 7, 10, 0, 0, 17607, 17608, 7, 7, 0, 0, 17608, 2372, 1, 0, 0, 0, 17609, 17610, 7, 7, 0, 0, 17610, 17611, 7, 2, 0, 0, 17611, 17612, 7, 5, 0, 0, 17612, 17613, 7, 19, 0, 0, 17613, 17614, 7, 0, 0, 0, 17614, 17615, 7, 3, 0, 0, 17615, 17616, 7, 9, 0, 0, 17616, 2374, 1, 0, 0, 0, 17617, 17618, 7, 7, 0, 0, 17618, 17619, 7, 2, 0, 0, 17619, 17620, 7, 5, 0, 0, 17620, 17621, 7, 2, 0, 0, 17621, 17622, 7, 3, 0, 0, 17622, 17623, 7, 4, 0, 0, 17623, 2376, 1, 0, 0, 0, 17624, 17625, 7, 7, 0, 0, 17625, 17626, 7, 2, 0, 0, 17626, 17627, 5, 95, 0, 0, 17627, 17628, 7, 5, 0, 0, 17628, 17629, 7, 24, 0, 0, 17629, 17630, 7, 11, 0, 0, 17630, 17631, 5, 95, 0, 0, 17631, 17632, 7, 4, 0, 0, 17632, 17633, 7, 3, 0, 0, 17633, 17634, 7, 0, 0, 0, 17634, 17635, 7, 7, 0, 0, 17635, 17636, 7, 5, 0, 0, 17636, 17637, 7, 11, 0, 0, 17637, 17638, 7, 0, 0, 0, 17638, 17639, 7, 4, 0, 0, 17639, 17640, 7, 10, 0, 0, 17640, 17641, 7, 2, 0, 0, 17641, 17642, 7, 7, 0, 0, 17642, 2378, 1, 0, 0, 0, 17643, 17644, 7, 7, 0, 0, 17644, 17645, 7, 2, 0, 0, 17645, 17646, 5, 95, 0, 0, 17646, 17647, 7, 5, 0, 0, 17647, 17648, 7, 24, 0, 0, 17648, 17649, 7, 11, 0, 0, 17649, 17650, 5, 95, 0, 0, 17650, 17651, 7, 4, 0, 0, 17651, 17652, 7, 12, 0, 0, 17652, 17653, 7, 7, 0, 0, 17653, 17654, 7, 6, 0, 0, 17654, 2380, 1, 0, 0, 0, 17655, 17656, 7, 7, 0, 0, 17656, 17657, 7, 2, 0, 0, 17657, 17658, 5, 95, 0, 0, 17658, 17659, 7, 5, 0, 0, 17659, 17660, 7, 4, 0, 0, 17660, 17661, 7, 0, 0, 0, 17661, 17662, 7, 3, 0, 0, 17662, 17663, 5, 95, 0, 0, 17663, 17664, 7, 4, 0, 0, 17664, 17665, 7, 3, 0, 0, 17665, 17666, 7, 0, 0, 0, 17666, 17667, 7, 7, 0, 0, 17667, 17668, 7, 5, 0, 0, 17668, 17669, 7, 16, 0, 0, 17669, 17670, 7, 2, 0, 0, 17670, 17671, 7, 3, 0, 0, 17671, 17672, 7, 14, 0, 0, 17672, 17673, 7, 0, 0, 0, 17673, 17674, 7, 4, 0, 0, 17674, 17675, 7, 10, 0, 0, 17675, 17676, 7, 2, 0, 0, 17676, 17677, 7, 7, 0, 0, 17677, 2382, 1, 0, 0, 0, 17678, 17679, 7, 7, 0, 0, 17679, 17680, 7, 2, 0, 0, 17680, 17681, 5, 95, 0, 0, 17681, 17682, 7, 5, 0, 0, 17682, 17683, 7, 4, 0, 0, 17683, 17684, 7, 0, 0, 0, 17684, 17685, 7, 4, 0, 0, 17685, 17686, 7, 6, 0, 0, 17686, 17687, 7, 14, 0, 0, 17687, 17688, 7, 6, 0, 0, 17688, 17689, 7, 7, 0, 0, 17689, 17690, 7, 4, 0, 0, 17690, 17691, 5, 95, 0, 0, 17691, 17692, 7, 24, 0, 0, 17692, 17693, 7, 12, 0, 0, 17693, 17694, 7, 6, 0, 0, 17694, 17695, 7, 12, 0, 0, 17695, 17696, 7, 10, 0, 0, 17696, 17697, 7, 7, 0, 0, 17697, 17698, 7, 17, 0, 0, 17698, 2384, 1, 0, 0, 0, 17699, 17700, 7, 7, 0, 0, 17700, 17701, 7, 2, 0, 0, 17701, 17702, 5, 95, 0, 0, 17702, 17703, 7, 5, 0, 0, 17703, 17704, 7, 4, 0, 0, 17704, 17705, 7, 0, 0, 0, 17705, 17706, 7, 4, 0, 0, 17706, 17707, 7, 5, 0, 0, 17707, 17708, 5, 95, 0, 0, 17708, 17709, 7, 17, 0, 0, 17709, 17710, 7, 5, 0, 0, 17710, 17711, 7, 6, 0, 0, 17711, 17712, 7, 4, 0, 0, 17712, 17713, 7, 5, 0, 0, 17713, 2386, 1, 0, 0, 0, 17714, 17715, 7, 7, 0, 0, 17715, 17716, 7, 2, 0, 0, 17716, 17717, 7, 5, 0, 0, 17717, 17718, 7, 4, 0, 0, 17718, 17719, 7, 3, 0, 0, 17719, 17720, 7, 10, 0, 0, 17720, 17721, 7, 8, 0, 0, 17721, 17722, 7, 4, 0, 0, 17722, 2388, 1, 0, 0, 0, 17723, 17724, 7, 7, 0, 0, 17724, 17725, 7, 2, 0, 0, 17725, 17726, 5, 95, 0, 0, 17726, 17727, 7, 5, 0, 0, 17727, 17728, 7, 12, 0, 0, 17728, 17729, 7, 1, 0, 0, 17729, 17730, 7, 24, 0, 0, 17730, 17731, 7, 12, 0, 0, 17731, 17732, 7, 6, 0, 0, 17732, 17733, 7, 3, 0, 0, 17733, 17734, 7, 18, 0, 0, 17734, 17735, 5, 95, 0, 0, 17735, 17736, 7, 15, 0, 0, 17736, 17737, 7, 3, 0, 0, 17737, 17738, 7, 12, 0, 0, 17738, 17739, 7, 7, 0, 0, 17739, 17740, 7, 10, 0, 0, 17740, 17741, 7, 7, 0, 0, 17741, 17742, 7, 17, 0, 0, 17742, 2390, 1, 0, 0, 0, 17743, 17744, 7, 7, 0, 0, 17744, 17745, 7, 2, 0, 0, 17745, 17746, 5, 95, 0, 0, 17746, 17747, 7, 5, 0, 0, 17747, 17748, 7, 12, 0, 0, 17748, 17749, 7, 1, 0, 0, 17749, 17750, 7, 5, 0, 0, 17750, 17751, 7, 4, 0, 0, 17751, 17752, 7, 3, 0, 0, 17752, 17753, 7, 1, 0, 0, 17753, 17754, 5, 95, 0, 0, 17754, 17755, 7, 15, 0, 0, 17755, 17756, 7, 0, 0, 0, 17756, 17757, 7, 9, 0, 0, 17757, 2392, 1, 0, 0, 0, 17758, 17759, 7, 7, 0, 0, 17759, 17760, 7, 2, 0, 0, 17760, 17761, 5, 95, 0, 0, 17761, 17762, 7, 5, 0, 0, 17762, 17763, 7, 22, 0, 0, 17763, 17764, 7, 0, 0, 0, 17764, 17765, 7, 15, 0, 0, 17765, 17766, 5, 95, 0, 0, 17766, 17767, 7, 20, 0, 0, 17767, 17768, 7, 2, 0, 0, 17768, 17769, 7, 10, 0, 0, 17769, 17770, 7, 7, 0, 0, 17770, 17771, 5, 95, 0, 0, 17771, 17772, 7, 10, 0, 0, 17772, 17773, 7, 7, 0, 0, 17773, 17774, 7, 15, 0, 0, 17774, 17775, 7, 12, 0, 0, 17775, 17776, 7, 4, 0, 0, 17776, 17777, 7, 5, 0, 0, 17777, 2394, 1, 0, 0, 0, 17778, 17779, 7, 7, 0, 0, 17779, 17780, 7, 2, 0, 0, 17780, 17781, 7, 5, 0, 0, 17781, 17782, 7, 22, 0, 0, 17782, 17783, 7, 10, 0, 0, 17783, 17784, 7, 4, 0, 0, 17784, 17785, 7, 8, 0, 0, 17785, 17786, 7, 19, 0, 0, 17786, 2396, 1, 0, 0, 0, 17787, 17788, 7, 7, 0, 0, 17788, 17789, 7, 2, 0, 0, 17789, 17790, 5, 95, 0, 0, 17790, 17791, 7, 4, 0, 0, 17791, 17792, 7, 0, 0, 0, 17792, 17793, 7, 1, 0, 0, 17793, 17794, 7, 11, 0, 0, 17794, 17795, 7, 6, 0, 0, 17795, 17796, 5, 95, 0, 0, 17796, 17797, 7, 11, 0, 0, 17797, 17798, 7, 2, 0, 0, 17798, 17799, 7, 2, 0, 0, 17799, 17800, 7, 21, 0, 0, 17800, 17801, 7, 12, 0, 0, 17801, 17802, 7, 15, 0, 0, 17802, 17803, 5, 95, 0, 0, 17803, 17804, 7, 1, 0, 0, 17804, 17805, 7, 18, 0, 0, 17805, 17806, 5, 95, 0, 0, 17806, 17807, 7, 7, 0, 0, 17807, 17808, 7, 11, 0, 0, 17808, 2398, 1, 0, 0, 0, 17809, 17810, 7, 7, 0, 0, 17810, 17811, 7, 2, 0, 0, 17811, 17812, 5, 95, 0, 0, 17812, 17813, 7, 4, 0, 0, 17813, 17814, 7, 6, 0, 0, 17814, 17815, 7, 14, 0, 0, 17815, 17816, 7, 15, 0, 0, 17816, 17817, 5, 95, 0, 0, 17817, 17818, 7, 4, 0, 0, 17818, 17819, 7, 0, 0, 0, 17819, 17820, 7, 1, 0, 0, 17820, 17821, 7, 11, 0, 0, 17821, 17822, 7, 6, 0, 0, 17822, 2400, 1, 0, 0, 0, 17823, 17824, 7, 7, 0, 0, 17824, 17825, 7, 2, 0, 0, 17825, 17826, 7, 4, 0, 0, 17826, 17827, 7, 19, 0, 0, 17827, 17828, 7, 10, 0, 0, 17828, 17829, 7, 7, 0, 0, 17829, 17830, 7, 17, 0, 0, 17830, 2402, 1, 0, 0, 0, 17831, 17832, 7, 7, 0, 0, 17832, 17833, 7, 2, 0, 0, 17833, 17834, 7, 4, 0, 0, 17834, 17835, 7, 10, 0, 0, 17835, 17836, 7, 16, 0, 0, 17836, 17837, 7, 10, 0, 0, 17837, 17838, 7, 8, 0, 0, 17838, 17839, 7, 0, 0, 0, 17839, 17840, 7, 4, 0, 0, 17840, 17841, 7, 10, 0, 0, 17841, 17842, 7, 2, 0, 0, 17842, 17843, 7, 7, 0, 0, 17843, 2404, 1, 0, 0, 0, 17844, 17845, 7, 7, 0, 0, 17845, 17846, 7, 2, 0, 0, 17846, 17847, 7, 4, 0, 0, 17847, 17848, 7, 3, 0, 0, 17848, 17849, 7, 10, 0, 0, 17849, 17850, 7, 14, 0, 0, 17850, 2406, 1, 0, 0, 0, 17851, 17852, 7, 7, 0, 0, 17852, 17853, 7, 2, 0, 0, 17853, 17854, 7, 4, 0, 0, 17854, 2408, 1, 0, 0, 0, 17855, 17856, 7, 7, 0, 0, 17856, 17857, 7, 2, 0, 0, 17857, 17858, 5, 95, 0, 0, 17858, 17859, 7, 4, 0, 0, 17859, 17860, 7, 3, 0, 0, 17860, 17861, 7, 0, 0, 0, 17861, 17862, 7, 7, 0, 0, 17862, 17863, 7, 5, 0, 0, 17863, 17864, 7, 16, 0, 0, 17864, 17865, 7, 2, 0, 0, 17865, 17866, 7, 3, 0, 0, 17866, 17867, 7, 14, 0, 0, 17867, 17868, 5, 95, 0, 0, 17868, 17869, 7, 9, 0, 0, 17869, 17870, 7, 10, 0, 0, 17870, 17871, 7, 5, 0, 0, 17871, 17872, 7, 4, 0, 0, 17872, 17873, 7, 10, 0, 0, 17873, 17874, 7, 7, 0, 0, 17874, 17875, 7, 8, 0, 0, 17875, 17876, 7, 4, 0, 0, 17876, 17877, 5, 95, 0, 0, 17877, 17878, 7, 0, 0, 0, 17878, 17879, 7, 17, 0, 0, 17879, 17880, 7, 17, 0, 0, 17880, 2410, 1, 0, 0, 0, 17881, 17882, 7, 7, 0, 0, 17882, 17883, 7, 2, 0, 0, 17883, 17884, 5, 95, 0, 0, 17884, 17885, 7, 12, 0, 0, 17885, 17886, 7, 7, 0, 0, 17886, 17887, 7, 7, 0, 0, 17887, 17888, 7, 6, 0, 0, 17888, 17889, 7, 5, 0, 0, 17889, 17890, 7, 4, 0, 0, 17890, 2412, 1, 0, 0, 0, 17891, 17892, 7, 7, 0, 0, 17892, 17893, 7, 2, 0, 0, 17893, 17894, 5, 95, 0, 0, 17894, 17895, 7, 12, 0, 0, 17895, 17896, 7, 5, 0, 0, 17896, 17897, 7, 6, 0, 0, 17897, 17898, 5, 95, 0, 0, 17898, 17899, 7, 8, 0, 0, 17899, 17900, 7, 12, 0, 0, 17900, 17901, 7, 1, 0, 0, 17901, 17902, 7, 6, 0, 0, 17902, 2414, 1, 0, 0, 0, 17903, 17904, 7, 7, 0, 0, 17904, 17905, 7, 2, 0, 0, 17905, 17906, 5, 95, 0, 0, 17906, 17907, 7, 12, 0, 0, 17907, 17908, 7, 5, 0, 0, 17908, 17909, 7, 6, 0, 0, 17909, 17910, 5, 95, 0, 0, 17910, 17911, 7, 19, 0, 0, 17911, 17912, 7, 0, 0, 0, 17912, 17913, 7, 5, 0, 0, 17913, 17914, 7, 19, 0, 0, 17914, 17915, 5, 95, 0, 0, 17915, 17916, 7, 0, 0, 0, 17916, 17917, 7, 17, 0, 0, 17917, 17918, 7, 17, 0, 0, 17918, 17919, 7, 3, 0, 0, 17919, 17920, 7, 6, 0, 0, 17920, 17921, 7, 17, 0, 0, 17921, 17922, 7, 0, 0, 0, 17922, 17923, 7, 4, 0, 0, 17923, 17924, 7, 10, 0, 0, 17924, 17925, 7, 2, 0, 0, 17925, 17926, 7, 7, 0, 0, 17926, 2416, 1, 0, 0, 0, 17927, 17928, 7, 7, 0, 0, 17928, 17929, 7, 2, 0, 0, 17929, 17930, 5, 95, 0, 0, 17930, 17931, 7, 12, 0, 0, 17931, 17932, 7, 5, 0, 0, 17932, 17933, 7, 6, 0, 0, 17933, 17934, 5, 95, 0, 0, 17934, 17935, 7, 19, 0, 0, 17935, 17936, 7, 0, 0, 0, 17936, 17937, 7, 5, 0, 0, 17937, 17938, 7, 19, 0, 0, 17938, 17939, 5, 95, 0, 0, 17939, 17940, 7, 17, 0, 0, 17940, 17941, 7, 1, 0, 0, 17941, 17942, 7, 18, 0, 0, 17942, 17943, 5, 95, 0, 0, 17943, 17944, 7, 16, 0, 0, 17944, 17945, 7, 2, 0, 0, 17945, 17946, 7, 3, 0, 0, 17946, 17947, 5, 95, 0, 0, 17947, 17948, 7, 15, 0, 0, 17948, 17949, 7, 12, 0, 0, 17949, 17950, 7, 5, 0, 0, 17950, 17951, 7, 19, 0, 0, 17951, 17952, 7, 9, 0, 0, 17952, 17953, 7, 2, 0, 0, 17953, 17954, 7, 22, 0, 0, 17954, 17955, 7, 7, 0, 0, 17955, 2418, 1, 0, 0, 0, 17956, 17957, 7, 7, 0, 0, 17957, 17958, 7, 2, 0, 0, 17958, 17959, 5, 95, 0, 0, 17959, 17960, 7, 12, 0, 0, 17960, 17961, 7, 5, 0, 0, 17961, 17962, 7, 6, 0, 0, 17962, 17963, 5, 95, 0, 0, 17963, 17964, 7, 19, 0, 0, 17964, 17965, 7, 0, 0, 0, 17965, 17966, 7, 5, 0, 0, 17966, 17967, 7, 19, 0, 0, 17967, 2420, 1, 0, 0, 0, 17968, 17969, 7, 7, 0, 0, 17969, 17970, 7, 2, 0, 0, 17970, 17971, 5, 95, 0, 0, 17971, 17972, 7, 12, 0, 0, 17972, 17973, 7, 5, 0, 0, 17973, 17974, 7, 6, 0, 0, 17974, 17975, 5, 95, 0, 0, 17975, 17976, 7, 10, 0, 0, 17976, 17977, 7, 7, 0, 0, 17977, 17978, 7, 13, 0, 0, 17978, 17979, 7, 10, 0, 0, 17979, 17980, 7, 5, 0, 0, 17980, 17981, 7, 10, 0, 0, 17981, 17982, 7, 1, 0, 0, 17982, 17983, 7, 11, 0, 0, 17983, 17984, 7, 6, 0, 0, 17984, 17985, 5, 95, 0, 0, 17985, 17986, 7, 10, 0, 0, 17986, 17987, 7, 7, 0, 0, 17987, 17988, 7, 9, 0, 0, 17988, 17989, 7, 6, 0, 0, 17989, 17990, 7, 25, 0, 0, 17990, 17991, 7, 6, 0, 0, 17991, 17992, 7, 5, 0, 0, 17992, 2422, 1, 0, 0, 0, 17993, 17994, 7, 7, 0, 0, 17994, 17995, 7, 2, 0, 0, 17995, 17996, 5, 95, 0, 0, 17996, 17997, 7, 12, 0, 0, 17997, 17998, 7, 5, 0, 0, 17998, 17999, 7, 6, 0, 0, 17999, 18000, 5, 95, 0, 0, 18000, 18001, 7, 14, 0, 0, 18001, 18002, 7, 6, 0, 0, 18002, 18003, 7, 3, 0, 0, 18003, 18004, 7, 17, 0, 0, 18004, 18005, 7, 6, 0, 0, 18005, 2424, 1, 0, 0, 0, 18006, 18007, 7, 7, 0, 0, 18007, 18008, 7, 2, 0, 0, 18008, 18009, 5, 95, 0, 0, 18009, 18010, 7, 12, 0, 0, 18010, 18011, 7, 5, 0, 0, 18011, 18012, 7, 6, 0, 0, 18012, 18013, 5, 95, 0, 0, 18013, 18014, 7, 7, 0, 0, 18014, 18015, 7, 11, 0, 0, 18015, 2426, 1, 0, 0, 0, 18016, 18017, 7, 7, 0, 0, 18017, 18018, 7, 2, 0, 0, 18018, 18019, 5, 95, 0, 0, 18019, 18020, 7, 12, 0, 0, 18020, 18021, 7, 5, 0, 0, 18021, 18022, 7, 6, 0, 0, 18022, 18023, 5, 95, 0, 0, 18023, 18024, 7, 13, 0, 0, 18024, 18025, 7, 6, 0, 0, 18025, 18026, 7, 8, 0, 0, 18026, 18027, 7, 4, 0, 0, 18027, 18028, 7, 2, 0, 0, 18028, 18029, 7, 3, 0, 0, 18029, 18030, 5, 95, 0, 0, 18030, 18031, 7, 0, 0, 0, 18031, 18032, 7, 17, 0, 0, 18032, 18033, 7, 17, 0, 0, 18033, 18034, 7, 3, 0, 0, 18034, 18035, 7, 6, 0, 0, 18035, 18036, 7, 17, 0, 0, 18036, 18037, 7, 0, 0, 0, 18037, 18038, 7, 4, 0, 0, 18038, 18039, 7, 10, 0, 0, 18039, 18040, 7, 2, 0, 0, 18040, 18041, 7, 7, 0, 0, 18041, 2428, 1, 0, 0, 0, 18042, 18043, 7, 7, 0, 0, 18043, 18044, 7, 2, 0, 0, 18044, 18045, 7, 13, 0, 0, 18045, 18046, 7, 0, 0, 0, 18046, 18047, 7, 11, 0, 0, 18047, 18048, 7, 10, 0, 0, 18048, 18049, 7, 9, 0, 0, 18049, 18050, 7, 0, 0, 0, 18050, 18051, 7, 4, 0, 0, 18051, 18052, 7, 6, 0, 0, 18052, 2430, 1, 0, 0, 0, 18053, 18054, 7, 7, 0, 0, 18054, 18055, 7, 2, 0, 0, 18055, 18056, 5, 95, 0, 0, 18056, 18057, 7, 13, 0, 0, 18057, 18058, 7, 6, 0, 0, 18058, 18059, 7, 8, 0, 0, 18059, 18060, 7, 4, 0, 0, 18060, 18061, 7, 2, 0, 0, 18061, 18062, 7, 3, 0, 0, 18062, 18063, 5, 95, 0, 0, 18063, 18064, 7, 4, 0, 0, 18064, 18065, 7, 3, 0, 0, 18065, 18066, 7, 0, 0, 0, 18066, 18067, 7, 7, 0, 0, 18067, 18068, 7, 5, 0, 0, 18068, 18069, 7, 16, 0, 0, 18069, 18070, 7, 2, 0, 0, 18070, 18071, 7, 3, 0, 0, 18071, 18072, 7, 14, 0, 0, 18072, 18073, 5, 95, 0, 0, 18073, 18074, 7, 9, 0, 0, 18074, 18075, 7, 10, 0, 0, 18075, 18076, 7, 14, 0, 0, 18076, 18077, 7, 5, 0, 0, 18077, 2432, 1, 0, 0, 0, 18078, 18079, 7, 7, 0, 0, 18079, 18080, 7, 2, 0, 0, 18080, 18081, 5, 95, 0, 0, 18081, 18082, 7, 13, 0, 0, 18082, 18083, 7, 6, 0, 0, 18083, 18084, 7, 8, 0, 0, 18084, 18085, 7, 4, 0, 0, 18085, 18086, 7, 2, 0, 0, 18086, 18087, 7, 3, 0, 0, 18087, 18088, 5, 95, 0, 0, 18088, 18089, 7, 4, 0, 0, 18089, 18090, 7, 3, 0, 0, 18090, 18091, 7, 0, 0, 0, 18091, 18092, 7, 7, 0, 0, 18092, 18093, 7, 5, 0, 0, 18093, 18094, 7, 16, 0, 0, 18094, 18095, 7, 2, 0, 0, 18095, 18096, 7, 3, 0, 0, 18096, 18097, 7, 14, 0, 0, 18097, 18098, 5, 95, 0, 0, 18098, 18099, 7, 16, 0, 0, 18099, 18100, 7, 0, 0, 0, 18100, 18101, 7, 8, 0, 0, 18101, 18102, 7, 4, 0, 0, 18102, 2434, 1, 0, 0, 0, 18103, 18104, 7, 7, 0, 0, 18104, 18105, 7, 2, 0, 0, 18105, 18106, 5, 95, 0, 0, 18106, 18107, 7, 13, 0, 0, 18107, 18108, 7, 6, 0, 0, 18108, 18109, 7, 8, 0, 0, 18109, 18110, 7, 4, 0, 0, 18110, 18111, 7, 2, 0, 0, 18111, 18112, 7, 3, 0, 0, 18112, 18113, 5, 95, 0, 0, 18113, 18114, 7, 4, 0, 0, 18114, 18115, 7, 3, 0, 0, 18115, 18116, 7, 0, 0, 0, 18116, 18117, 7, 7, 0, 0, 18117, 18118, 7, 5, 0, 0, 18118, 18119, 7, 16, 0, 0, 18119, 18120, 7, 2, 0, 0, 18120, 18121, 7, 3, 0, 0, 18121, 18122, 7, 14, 0, 0, 18122, 2436, 1, 0, 0, 0, 18123, 18124, 7, 7, 0, 0, 18124, 18125, 7, 2, 0, 0, 18125, 18126, 7, 22, 0, 0, 18126, 18127, 7, 0, 0, 0, 18127, 18128, 7, 10, 0, 0, 18128, 18129, 7, 4, 0, 0, 18129, 2438, 1, 0, 0, 0, 18130, 18131, 7, 7, 0, 0, 18131, 18132, 7, 2, 0, 0, 18132, 18133, 5, 95, 0, 0, 18133, 18134, 7, 25, 0, 0, 18134, 18135, 7, 9, 0, 0, 18135, 18136, 7, 1, 0, 0, 18136, 18137, 5, 95, 0, 0, 18137, 18138, 7, 16, 0, 0, 18138, 18139, 7, 0, 0, 0, 18139, 18140, 7, 5, 0, 0, 18140, 18141, 7, 4, 0, 0, 18141, 18142, 7, 15, 0, 0, 18142, 18143, 7, 0, 0, 0, 18143, 18144, 7, 4, 0, 0, 18144, 18145, 7, 19, 0, 0, 18145, 18146, 5, 95, 0, 0, 18146, 18147, 7, 10, 0, 0, 18147, 18148, 7, 7, 0, 0, 18148, 18149, 7, 5, 0, 0, 18149, 18150, 7, 6, 0, 0, 18150, 18151, 7, 3, 0, 0, 18151, 18152, 7, 4, 0, 0, 18152, 2440, 1, 0, 0, 0, 18153, 18154, 7, 7, 0, 0, 18154, 18155, 7, 2, 0, 0, 18155, 18156, 5, 95, 0, 0, 18156, 18157, 7, 25, 0, 0, 18157, 18158, 7, 14, 0, 0, 18158, 18159, 7, 11, 0, 0, 18159, 18160, 5, 95, 0, 0, 18160, 18161, 7, 9, 0, 0, 18161, 18162, 7, 14, 0, 0, 18162, 18163, 7, 11, 0, 0, 18163, 18164, 5, 95, 0, 0, 18164, 18165, 7, 3, 0, 0, 18165, 18166, 7, 6, 0, 0, 18166, 18167, 7, 22, 0, 0, 18167, 18168, 7, 3, 0, 0, 18168, 18169, 7, 10, 0, 0, 18169, 18170, 7, 4, 0, 0, 18170, 18171, 7, 6, 0, 0, 18171, 2442, 1, 0, 0, 0, 18172, 18173, 7, 7, 0, 0, 18173, 18174, 7, 2, 0, 0, 18174, 18175, 5, 95, 0, 0, 18175, 18176, 7, 25, 0, 0, 18176, 18177, 7, 14, 0, 0, 18177, 18178, 7, 11, 0, 0, 18178, 18179, 7, 10, 0, 0, 18179, 18180, 7, 7, 0, 0, 18180, 18181, 7, 9, 0, 0, 18181, 18182, 7, 6, 0, 0, 18182, 18183, 7, 25, 0, 0, 18183, 18184, 5, 95, 0, 0, 18184, 18185, 7, 3, 0, 0, 18185, 18186, 7, 6, 0, 0, 18186, 18187, 7, 22, 0, 0, 18187, 18188, 7, 3, 0, 0, 18188, 18189, 7, 10, 0, 0, 18189, 18190, 7, 4, 0, 0, 18190, 18191, 7, 6, 0, 0, 18191, 18192, 5, 95, 0, 0, 18192, 18193, 7, 10, 0, 0, 18193, 18194, 7, 7, 0, 0, 18194, 18195, 5, 95, 0, 0, 18195, 18196, 7, 5, 0, 0, 18196, 18197, 7, 6, 0, 0, 18197, 18198, 7, 11, 0, 0, 18198, 18199, 7, 6, 0, 0, 18199, 18200, 7, 8, 0, 0, 18200, 18201, 7, 4, 0, 0, 18201, 2444, 1, 0, 0, 0, 18202, 18203, 7, 7, 0, 0, 18203, 18204, 7, 2, 0, 0, 18204, 18205, 5, 95, 0, 0, 18205, 18206, 7, 25, 0, 0, 18206, 18207, 7, 14, 0, 0, 18207, 18208, 7, 11, 0, 0, 18208, 18209, 7, 10, 0, 0, 18209, 18210, 7, 7, 0, 0, 18210, 18211, 7, 9, 0, 0, 18211, 18212, 7, 6, 0, 0, 18212, 18213, 7, 25, 0, 0, 18213, 18214, 5, 95, 0, 0, 18214, 18215, 7, 3, 0, 0, 18215, 18216, 7, 6, 0, 0, 18216, 18217, 7, 22, 0, 0, 18217, 18218, 7, 3, 0, 0, 18218, 18219, 7, 10, 0, 0, 18219, 18220, 7, 4, 0, 0, 18220, 18221, 7, 6, 0, 0, 18221, 2446, 1, 0, 0, 0, 18222, 18223, 7, 7, 0, 0, 18223, 18224, 7, 2, 0, 0, 18224, 18225, 5, 95, 0, 0, 18225, 18226, 7, 25, 0, 0, 18226, 18227, 7, 14, 0, 0, 18227, 18228, 7, 11, 0, 0, 18228, 18229, 5, 95, 0, 0, 18229, 18230, 7, 24, 0, 0, 18230, 18231, 7, 12, 0, 0, 18231, 18232, 7, 6, 0, 0, 18232, 18233, 7, 3, 0, 0, 18233, 18234, 7, 18, 0, 0, 18234, 18235, 5, 95, 0, 0, 18235, 18236, 7, 3, 0, 0, 18236, 18237, 7, 6, 0, 0, 18237, 18238, 7, 22, 0, 0, 18238, 18239, 7, 3, 0, 0, 18239, 18240, 7, 10, 0, 0, 18240, 18241, 7, 4, 0, 0, 18241, 18242, 7, 6, 0, 0, 18242, 2448, 1, 0, 0, 0, 18243, 18244, 7, 7, 0, 0, 18244, 18245, 7, 2, 0, 0, 18245, 18246, 5, 95, 0, 0, 18246, 18247, 7, 23, 0, 0, 18247, 18248, 7, 2, 0, 0, 18248, 18249, 7, 7, 0, 0, 18249, 18250, 7, 6, 0, 0, 18250, 18251, 7, 14, 0, 0, 18251, 18252, 7, 0, 0, 0, 18252, 18253, 7, 15, 0, 0, 18253, 2450, 1, 0, 0, 0, 18254, 18255, 7, 7, 0, 0, 18255, 18256, 7, 4, 0, 0, 18256, 18257, 7, 19, 0, 0, 18257, 18258, 5, 95, 0, 0, 18258, 18259, 7, 13, 0, 0, 18259, 18260, 7, 0, 0, 0, 18260, 18261, 7, 11, 0, 0, 18261, 18262, 7, 12, 0, 0, 18262, 18263, 7, 6, 0, 0, 18263, 2452, 1, 0, 0, 0, 18264, 18265, 7, 7, 0, 0, 18265, 18266, 7, 12, 0, 0, 18266, 18267, 7, 11, 0, 0, 18267, 18268, 7, 11, 0, 0, 18268, 18269, 7, 10, 0, 0, 18269, 18270, 7, 16, 0, 0, 18270, 2454, 1, 0, 0, 0, 18271, 18272, 7, 7, 0, 0, 18272, 18273, 7, 12, 0, 0, 18273, 18274, 7, 11, 0, 0, 18274, 18275, 7, 11, 0, 0, 18275, 2456, 1, 0, 0, 0, 18276, 18277, 7, 7, 0, 0, 18277, 18278, 7, 12, 0, 0, 18278, 18279, 7, 11, 0, 0, 18279, 18280, 7, 11, 0, 0, 18280, 18281, 7, 5, 0, 0, 18281, 2458, 1, 0, 0, 0, 18282, 18283, 7, 7, 0, 0, 18283, 18284, 7, 12, 0, 0, 18284, 18285, 7, 14, 0, 0, 18285, 18286, 7, 1, 0, 0, 18286, 18287, 7, 6, 0, 0, 18287, 18288, 7, 3, 0, 0, 18288, 2460, 1, 0, 0, 0, 18289, 18290, 7, 7, 0, 0, 18290, 18291, 7, 12, 0, 0, 18291, 18292, 7, 14, 0, 0, 18292, 18293, 7, 6, 0, 0, 18293, 18294, 7, 3, 0, 0, 18294, 18295, 7, 10, 0, 0, 18295, 18296, 7, 8, 0, 0, 18296, 2462, 1, 0, 0, 0, 18297, 18298, 7, 7, 0, 0, 18298, 18299, 7, 12, 0, 0, 18299, 18300, 7, 14, 0, 0, 18300, 18301, 5, 95, 0, 0, 18301, 18302, 7, 10, 0, 0, 18302, 18303, 7, 7, 0, 0, 18303, 18304, 7, 9, 0, 0, 18304, 18305, 7, 6, 0, 0, 18305, 18306, 7, 25, 0, 0, 18306, 18307, 5, 95, 0, 0, 18307, 18308, 7, 21, 0, 0, 18308, 18309, 7, 6, 0, 0, 18309, 18310, 7, 18, 0, 0, 18310, 18311, 7, 5, 0, 0, 18311, 2464, 1, 0, 0, 0, 18312, 18313, 7, 7, 0, 0, 18313, 18314, 7, 12, 0, 0, 18314, 18315, 7, 14, 0, 0, 18315, 18316, 7, 4, 0, 0, 18316, 18317, 7, 2, 0, 0, 18317, 18318, 7, 9, 0, 0, 18318, 18319, 7, 5, 0, 0, 18319, 18320, 7, 10, 0, 0, 18320, 18321, 7, 7, 0, 0, 18321, 18322, 7, 4, 0, 0, 18322, 18323, 7, 6, 0, 0, 18323, 18324, 7, 3, 0, 0, 18324, 18325, 7, 13, 0, 0, 18325, 18326, 7, 0, 0, 0, 18326, 18327, 7, 11, 0, 0, 18327, 2466, 1, 0, 0, 0, 18328, 18329, 7, 7, 0, 0, 18329, 18330, 7, 12, 0, 0, 18330, 18331, 7, 14, 0, 0, 18331, 18332, 7, 4, 0, 0, 18332, 18333, 7, 2, 0, 0, 18333, 18334, 7, 18, 0, 0, 18334, 18335, 7, 14, 0, 0, 18335, 18336, 7, 10, 0, 0, 18336, 18337, 7, 7, 0, 0, 18337, 18338, 7, 4, 0, 0, 18338, 18339, 7, 6, 0, 0, 18339, 18340, 7, 3, 0, 0, 18340, 18341, 7, 13, 0, 0, 18341, 18342, 7, 0, 0, 0, 18342, 18343, 7, 11, 0, 0, 18343, 2468, 1, 0, 0, 0, 18344, 18345, 7, 7, 0, 0, 18345, 18346, 7, 13, 0, 0, 18346, 18347, 7, 0, 0, 0, 18347, 18348, 7, 3, 0, 0, 18348, 18349, 7, 8, 0, 0, 18349, 18350, 7, 19, 0, 0, 18350, 18351, 7, 0, 0, 0, 18351, 18352, 7, 3, 0, 0, 18352, 18353, 5, 50, 0, 0, 18353, 2470, 1, 0, 0, 0, 18354, 18355, 7, 7, 0, 0, 18355, 18356, 7, 13, 0, 0, 18356, 18357, 7, 11, 0, 0, 18357, 18358, 5, 50, 0, 0, 18358, 2472, 1, 0, 0, 0, 18359, 18360, 7, 2, 0, 0, 18360, 18361, 7, 1, 0, 0, 18361, 18362, 7, 20, 0, 0, 18362, 18363, 7, 6, 0, 0, 18363, 18364, 7, 8, 0, 0, 18364, 18365, 7, 4, 0, 0, 18365, 18366, 5, 50, 0, 0, 18366, 18367, 7, 25, 0, 0, 18367, 18368, 7, 14, 0, 0, 18368, 18369, 7, 11, 0, 0, 18369, 2474, 1, 0, 0, 0, 18370, 18371, 7, 2, 0, 0, 18371, 18372, 7, 1, 0, 0, 18372, 18373, 7, 20, 0, 0, 18373, 18374, 7, 6, 0, 0, 18374, 18375, 7, 8, 0, 0, 18375, 18376, 7, 4, 0, 0, 18376, 2476, 1, 0, 0, 0, 18377, 18378, 7, 2, 0, 0, 18378, 18379, 7, 1, 0, 0, 18379, 18380, 7, 20, 0, 0, 18380, 18381, 5, 95, 0, 0, 18381, 18382, 7, 10, 0, 0, 18382, 18383, 7, 9, 0, 0, 18383, 2478, 1, 0, 0, 0, 18384, 18385, 7, 2, 0, 0, 18385, 18386, 7, 1, 0, 0, 18386, 18387, 7, 20, 0, 0, 18387, 18388, 7, 7, 0, 0, 18388, 18389, 7, 2, 0, 0, 18389, 2480, 1, 0, 0, 0, 18390, 18391, 7, 2, 0, 0, 18391, 18392, 7, 1, 0, 0, 18392, 18393, 7, 20, 0, 0, 18393, 18394, 7, 7, 0, 0, 18394, 18395, 7, 2, 0, 0, 18395, 18396, 5, 95, 0, 0, 18396, 18397, 7, 3, 0, 0, 18397, 18398, 7, 6, 0, 0, 18398, 18399, 7, 12, 0, 0, 18399, 18400, 7, 5, 0, 0, 18400, 18401, 7, 6, 0, 0, 18401, 2482, 1, 0, 0, 0, 18402, 18403, 7, 2, 0, 0, 18403, 18404, 7, 8, 0, 0, 18404, 18405, 7, 8, 0, 0, 18405, 18406, 7, 12, 0, 0, 18406, 18407, 7, 3, 0, 0, 18407, 18408, 7, 6, 0, 0, 18408, 18409, 7, 7, 0, 0, 18409, 18410, 7, 8, 0, 0, 18410, 18411, 7, 6, 0, 0, 18411, 18412, 7, 5, 0, 0, 18412, 2484, 1, 0, 0, 0, 18413, 18414, 7, 2, 0, 0, 18414, 18415, 7, 16, 0, 0, 18415, 18416, 7, 16, 0, 0, 18416, 18417, 7, 11, 0, 0, 18417, 18418, 7, 10, 0, 0, 18418, 18419, 7, 7, 0, 0, 18419, 18420, 7, 6, 0, 0, 18420, 2486, 1, 0, 0, 0, 18421, 18422, 7, 2, 0, 0, 18422, 18423, 7, 16, 0, 0, 18423, 18424, 7, 16, 0, 0, 18424, 2488, 1, 0, 0, 0, 18425, 18426, 7, 2, 0, 0, 18426, 18427, 7, 16, 0, 0, 18427, 18428, 7, 16, 0, 0, 18428, 18429, 7, 5, 0, 0, 18429, 18430, 7, 6, 0, 0, 18430, 18431, 7, 4, 0, 0, 18431, 2490, 1, 0, 0, 0, 18432, 18433, 7, 2, 0, 0, 18433, 18434, 7, 16, 0, 0, 18434, 2492, 1, 0, 0, 0, 18435, 18436, 7, 2, 0, 0, 18436, 18437, 7, 10, 0, 0, 18437, 18438, 7, 9, 0, 0, 18438, 18439, 7, 10, 0, 0, 18439, 18440, 7, 7, 0, 0, 18440, 18441, 7, 9, 0, 0, 18441, 18442, 7, 6, 0, 0, 18442, 18443, 7, 25, 0, 0, 18443, 2494, 1, 0, 0, 0, 18444, 18445, 7, 2, 0, 0, 18445, 18446, 7, 10, 0, 0, 18446, 18447, 7, 9, 0, 0, 18447, 2496, 1, 0, 0, 0, 18448, 18449, 7, 2, 0, 0, 18449, 18450, 7, 11, 0, 0, 18450, 18451, 7, 0, 0, 0, 18451, 18452, 7, 15, 0, 0, 18452, 2498, 1, 0, 0, 0, 18453, 18454, 7, 2, 0, 0, 18454, 18455, 7, 11, 0, 0, 18455, 18456, 7, 9, 0, 0, 18456, 2500, 1, 0, 0, 0, 18457, 18458, 7, 2, 0, 0, 18458, 18459, 7, 11, 0, 0, 18459, 18460, 7, 9, 0, 0, 18460, 18461, 5, 95, 0, 0, 18461, 18462, 7, 15, 0, 0, 18462, 18463, 7, 12, 0, 0, 18463, 18464, 7, 5, 0, 0, 18464, 18465, 7, 19, 0, 0, 18465, 18466, 5, 95, 0, 0, 18466, 18467, 7, 15, 0, 0, 18467, 18468, 7, 3, 0, 0, 18468, 18469, 7, 6, 0, 0, 18469, 18470, 7, 9, 0, 0, 18470, 2502, 1, 0, 0, 0, 18471, 18472, 7, 2, 0, 0, 18472, 18473, 7, 11, 0, 0, 18473, 18474, 7, 5, 0, 0, 18474, 2504, 1, 0, 0, 0, 18475, 18476, 7, 2, 0, 0, 18476, 18477, 7, 11, 0, 0, 18477, 18478, 7, 4, 0, 0, 18478, 18479, 7, 15, 0, 0, 18479, 2506, 1, 0, 0, 0, 18480, 18481, 7, 2, 0, 0, 18481, 18482, 7, 14, 0, 0, 18482, 18483, 7, 10, 0, 0, 18483, 18484, 7, 4, 0, 0, 18484, 2508, 1, 0, 0, 0, 18485, 18486, 7, 2, 0, 0, 18486, 18487, 7, 7, 0, 0, 18487, 18488, 7, 6, 0, 0, 18488, 2510, 1, 0, 0, 0, 18489, 18490, 7, 2, 0, 0, 18490, 18491, 7, 7, 0, 0, 18491, 18492, 7, 11, 0, 0, 18492, 18493, 7, 10, 0, 0, 18493, 18494, 7, 7, 0, 0, 18494, 18495, 7, 6, 0, 0, 18495, 2512, 1, 0, 0, 0, 18496, 18497, 7, 2, 0, 0, 18497, 18498, 7, 7, 0, 0, 18498, 18499, 7, 11, 0, 0, 18499, 18500, 7, 10, 0, 0, 18500, 18501, 7, 7, 0, 0, 18501, 18502, 7, 6, 0, 0, 18502, 18503, 7, 11, 0, 0, 18503, 18504, 7, 2, 0, 0, 18504, 18505, 7, 17, 0, 0, 18505, 2514, 1, 0, 0, 0, 18506, 18507, 7, 2, 0, 0, 18507, 18508, 7, 7, 0, 0, 18508, 18509, 7, 11, 0, 0, 18509, 18510, 7, 18, 0, 0, 18510, 2516, 1, 0, 0, 0, 18511, 18512, 7, 2, 0, 0, 18512, 18513, 7, 7, 0, 0, 18513, 2518, 1, 0, 0, 0, 18514, 18515, 7, 2, 0, 0, 18515, 18516, 7, 15, 0, 0, 18516, 18517, 7, 0, 0, 0, 18517, 18518, 7, 24, 0, 0, 18518, 18519, 7, 12, 0, 0, 18519, 18520, 7, 6, 0, 0, 18520, 2520, 1, 0, 0, 0, 18521, 18522, 7, 2, 0, 0, 18522, 18523, 7, 15, 0, 0, 18523, 18524, 7, 0, 0, 0, 18524, 18525, 7, 24, 0, 0, 18525, 18526, 7, 12, 0, 0, 18526, 18527, 7, 6, 0, 0, 18527, 18528, 5, 95, 0, 0, 18528, 18529, 7, 4, 0, 0, 18529, 18530, 7, 3, 0, 0, 18530, 18531, 7, 0, 0, 0, 18531, 18532, 7, 7, 0, 0, 18532, 18533, 7, 5, 0, 0, 18533, 18534, 7, 16, 0, 0, 18534, 18535, 7, 2, 0, 0, 18535, 18536, 7, 3, 0, 0, 18536, 18537, 7, 14, 0, 0, 18537, 2522, 1, 0, 0, 0, 18538, 18539, 7, 2, 0, 0, 18539, 18540, 7, 15, 0, 0, 18540, 18541, 7, 0, 0, 0, 18541, 18542, 7, 24, 0, 0, 18542, 18543, 7, 12, 0, 0, 18543, 18544, 7, 6, 0, 0, 18544, 18545, 5, 95, 0, 0, 18545, 18546, 7, 25, 0, 0, 18546, 18547, 7, 8, 0, 0, 18547, 18548, 7, 0, 0, 0, 18548, 18549, 7, 7, 0, 0, 18549, 18550, 7, 2, 0, 0, 18550, 18551, 7, 7, 0, 0, 18551, 18552, 7, 10, 0, 0, 18552, 18553, 7, 8, 0, 0, 18553, 18554, 7, 0, 0, 0, 18554, 18555, 7, 11, 0, 0, 18555, 2524, 1, 0, 0, 0, 18556, 18557, 7, 2, 0, 0, 18557, 18558, 7, 15, 0, 0, 18558, 18559, 7, 8, 0, 0, 18559, 18560, 7, 2, 0, 0, 18560, 18561, 7, 9, 0, 0, 18561, 18562, 7, 6, 0, 0, 18562, 2526, 1, 0, 0, 0, 18563, 18564, 7, 2, 0, 0, 18564, 18565, 7, 15, 0, 0, 18565, 18566, 7, 6, 0, 0, 18566, 18567, 7, 7, 0, 0, 18567, 2528, 1, 0, 0, 0, 18568, 18569, 7, 2, 0, 0, 18569, 18570, 7, 15, 0, 0, 18570, 18571, 7, 6, 0, 0, 18571, 18572, 7, 3, 0, 0, 18572, 18573, 7, 0, 0, 0, 18573, 18574, 7, 4, 0, 0, 18574, 18575, 7, 10, 0, 0, 18575, 18576, 7, 2, 0, 0, 18576, 18577, 7, 7, 0, 0, 18577, 18578, 7, 5, 0, 0, 18578, 2530, 1, 0, 0, 0, 18579, 18580, 7, 2, 0, 0, 18580, 18581, 7, 15, 0, 0, 18581, 18582, 7, 6, 0, 0, 18582, 18583, 7, 3, 0, 0, 18583, 18584, 7, 0, 0, 0, 18584, 18585, 7, 4, 0, 0, 18585, 18586, 7, 2, 0, 0, 18586, 18587, 7, 3, 0, 0, 18587, 2532, 1, 0, 0, 0, 18588, 18589, 7, 2, 0, 0, 18589, 18590, 7, 15, 0, 0, 18590, 18591, 7, 4, 0, 0, 18591, 18592, 5, 95, 0, 0, 18592, 18593, 7, 6, 0, 0, 18593, 18594, 7, 5, 0, 0, 18594, 18595, 7, 4, 0, 0, 18595, 18596, 7, 10, 0, 0, 18596, 18597, 7, 14, 0, 0, 18597, 18598, 7, 0, 0, 0, 18598, 18599, 7, 4, 0, 0, 18599, 18600, 7, 6, 0, 0, 18600, 2534, 1, 0, 0, 0, 18601, 18602, 7, 2, 0, 0, 18602, 18603, 7, 15, 0, 0, 18603, 18604, 7, 4, 0, 0, 18604, 18605, 7, 10, 0, 0, 18605, 18606, 7, 14, 0, 0, 18606, 18607, 7, 0, 0, 0, 18607, 18608, 7, 11, 0, 0, 18608, 2536, 1, 0, 0, 0, 18609, 18610, 7, 2, 0, 0, 18610, 18611, 7, 15, 0, 0, 18611, 18612, 7, 4, 0, 0, 18612, 18613, 7, 10, 0, 0, 18613, 18614, 7, 14, 0, 0, 18614, 18615, 7, 10, 0, 0, 18615, 18616, 7, 23, 0, 0, 18616, 18617, 7, 6, 0, 0, 18617, 2538, 1, 0, 0, 0, 18618, 18619, 7, 2, 0, 0, 18619, 18620, 7, 15, 0, 0, 18620, 18621, 7, 4, 0, 0, 18621, 18622, 7, 10, 0, 0, 18622, 18623, 7, 14, 0, 0, 18623, 18624, 7, 10, 0, 0, 18624, 18625, 7, 23, 0, 0, 18625, 18626, 7, 6, 0, 0, 18626, 18627, 7, 3, 0, 0, 18627, 18628, 5, 95, 0, 0, 18628, 18629, 7, 16, 0, 0, 18629, 18630, 7, 6, 0, 0, 18630, 18631, 7, 0, 0, 0, 18631, 18632, 7, 4, 0, 0, 18632, 18633, 7, 12, 0, 0, 18633, 18634, 7, 3, 0, 0, 18634, 18635, 7, 6, 0, 0, 18635, 18636, 7, 5, 0, 0, 18636, 18637, 5, 95, 0, 0, 18637, 18638, 7, 6, 0, 0, 18638, 18639, 7, 7, 0, 0, 18639, 18640, 7, 0, 0, 0, 18640, 18641, 7, 1, 0, 0, 18641, 18642, 7, 11, 0, 0, 18642, 18643, 7, 6, 0, 0, 18643, 2540, 1, 0, 0, 0, 18644, 18645, 7, 2, 0, 0, 18645, 18646, 7, 15, 0, 0, 18646, 18647, 7, 4, 0, 0, 18647, 18648, 7, 10, 0, 0, 18648, 18649, 7, 14, 0, 0, 18649, 18650, 7, 10, 0, 0, 18650, 18651, 7, 23, 0, 0, 18651, 18652, 7, 6, 0, 0, 18652, 18653, 7, 3, 0, 0, 18653, 18654, 5, 95, 0, 0, 18654, 18655, 7, 17, 0, 0, 18655, 18656, 7, 2, 0, 0, 18656, 18657, 7, 0, 0, 0, 18657, 18658, 7, 11, 0, 0, 18658, 2542, 1, 0, 0, 0, 18659, 18660, 7, 2, 0, 0, 18660, 18661, 7, 15, 0, 0, 18661, 18662, 7, 4, 0, 0, 18662, 18663, 7, 10, 0, 0, 18663, 18664, 7, 2, 0, 0, 18664, 18665, 7, 7, 0, 0, 18665, 2544, 1, 0, 0, 0, 18666, 18667, 7, 2, 0, 0, 18667, 18668, 7, 15, 0, 0, 18668, 18669, 7, 4, 0, 0, 18669, 18670, 7, 10, 0, 0, 18670, 18671, 7, 2, 0, 0, 18671, 18672, 7, 7, 0, 0, 18672, 18673, 7, 0, 0, 0, 18673, 18674, 7, 11, 0, 0, 18674, 18675, 7, 11, 0, 0, 18675, 18676, 7, 18, 0, 0, 18676, 2546, 1, 0, 0, 0, 18677, 18678, 7, 2, 0, 0, 18678, 18679, 7, 15, 0, 0, 18679, 18680, 7, 4, 0, 0, 18680, 18681, 5, 95, 0, 0, 18681, 18682, 7, 15, 0, 0, 18682, 18683, 7, 0, 0, 0, 18683, 18684, 7, 3, 0, 0, 18684, 18685, 7, 0, 0, 0, 18685, 18686, 7, 14, 0, 0, 18686, 2548, 1, 0, 0, 0, 18687, 18688, 7, 2, 0, 0, 18688, 18689, 7, 3, 0, 0, 18689, 18690, 7, 0, 0, 0, 18690, 18691, 5, 95, 0, 0, 18691, 18692, 7, 1, 0, 0, 18692, 18693, 7, 3, 0, 0, 18693, 18694, 7, 0, 0, 0, 18694, 18695, 7, 7, 0, 0, 18695, 18696, 7, 8, 0, 0, 18696, 18697, 7, 19, 0, 0, 18697, 2550, 1, 0, 0, 0, 18698, 18699, 7, 2, 0, 0, 18699, 18700, 7, 3, 0, 0, 18700, 18701, 7, 0, 0, 0, 18701, 18702, 5, 95, 0, 0, 18702, 18703, 7, 8, 0, 0, 18703, 18704, 7, 19, 0, 0, 18704, 18705, 7, 6, 0, 0, 18705, 18706, 7, 8, 0, 0, 18706, 18707, 7, 21, 0, 0, 18707, 18708, 5, 95, 0, 0, 18708, 18709, 7, 0, 0, 0, 18709, 18710, 7, 8, 0, 0, 18710, 18711, 7, 11, 0, 0, 18711, 2552, 1, 0, 0, 0, 18712, 18713, 7, 2, 0, 0, 18713, 18714, 7, 3, 0, 0, 18714, 18715, 7, 0, 0, 0, 18715, 18716, 5, 95, 0, 0, 18716, 18717, 7, 8, 0, 0, 18717, 18718, 7, 19, 0, 0, 18718, 18719, 7, 6, 0, 0, 18719, 18720, 7, 8, 0, 0, 18720, 18721, 7, 21, 0, 0, 18721, 18722, 5, 95, 0, 0, 18722, 18723, 7, 15, 0, 0, 18723, 18724, 7, 3, 0, 0, 18724, 18725, 7, 10, 0, 0, 18725, 18726, 7, 13, 0, 0, 18726, 18727, 7, 10, 0, 0, 18727, 18728, 7, 11, 0, 0, 18728, 18729, 7, 6, 0, 0, 18729, 18730, 7, 17, 0, 0, 18730, 18731, 7, 6, 0, 0, 18731, 2554, 1, 0, 0, 0, 18732, 18733, 7, 2, 0, 0, 18733, 18734, 7, 3, 0, 0, 18734, 18735, 7, 0, 0, 0, 18735, 18736, 5, 95, 0, 0, 18736, 18737, 7, 8, 0, 0, 18737, 18738, 7, 11, 0, 0, 18738, 18739, 7, 12, 0, 0, 18739, 18740, 7, 5, 0, 0, 18740, 18741, 7, 4, 0, 0, 18741, 18742, 7, 6, 0, 0, 18742, 18743, 7, 3, 0, 0, 18743, 18744, 7, 10, 0, 0, 18744, 18745, 7, 7, 0, 0, 18745, 18746, 7, 17, 0, 0, 18746, 2556, 1, 0, 0, 0, 18747, 18748, 7, 2, 0, 0, 18748, 18749, 7, 3, 0, 0, 18749, 18750, 7, 0, 0, 0, 18750, 18751, 7, 9, 0, 0, 18751, 18752, 7, 0, 0, 0, 18752, 18753, 7, 4, 0, 0, 18753, 18754, 7, 0, 0, 0, 18754, 2558, 1, 0, 0, 0, 18755, 18756, 7, 2, 0, 0, 18756, 18757, 7, 3, 0, 0, 18757, 18758, 7, 8, 0, 0, 18758, 2560, 1, 0, 0, 0, 18759, 18760, 7, 2, 0, 0, 18760, 18761, 7, 3, 0, 0, 18761, 18762, 7, 0, 0, 0, 18762, 18763, 7, 8, 0, 0, 18763, 18764, 7, 11, 0, 0, 18764, 18765, 7, 6, 0, 0, 18765, 18766, 5, 95, 0, 0, 18766, 18767, 7, 9, 0, 0, 18767, 18768, 7, 0, 0, 0, 18768, 18769, 7, 4, 0, 0, 18769, 18770, 7, 6, 0, 0, 18770, 2562, 1, 0, 0, 0, 18771, 18772, 7, 2, 0, 0, 18772, 18773, 7, 3, 0, 0, 18773, 18774, 7, 0, 0, 0, 18774, 18775, 7, 8, 0, 0, 18775, 18776, 7, 11, 0, 0, 18776, 18777, 7, 6, 0, 0, 18777, 18778, 5, 95, 0, 0, 18778, 18779, 7, 7, 0, 0, 18779, 18780, 7, 12, 0, 0, 18780, 18781, 7, 14, 0, 0, 18781, 18782, 7, 1, 0, 0, 18782, 18783, 7, 6, 0, 0, 18783, 18784, 7, 3, 0, 0, 18784, 2564, 1, 0, 0, 0, 18785, 18786, 7, 2, 0, 0, 18786, 18787, 7, 3, 0, 0, 18787, 18788, 7, 0, 0, 0, 18788, 18789, 7, 9, 0, 0, 18789, 18790, 7, 6, 0, 0, 18790, 18791, 7, 1, 0, 0, 18791, 18792, 7, 12, 0, 0, 18792, 18793, 7, 17, 0, 0, 18793, 2566, 1, 0, 0, 0, 18794, 18795, 7, 2, 0, 0, 18795, 18796, 7, 3, 0, 0, 18796, 18797, 7, 0, 0, 0, 18797, 18798, 5, 95, 0, 0, 18798, 18799, 7, 9, 0, 0, 18799, 18800, 7, 5, 0, 0, 18800, 18801, 7, 4, 0, 0, 18801, 18802, 5, 95, 0, 0, 18802, 18803, 7, 0, 0, 0, 18803, 18804, 7, 16, 0, 0, 18804, 18805, 7, 16, 0, 0, 18805, 18806, 7, 6, 0, 0, 18806, 18807, 7, 8, 0, 0, 18807, 18808, 7, 4, 0, 0, 18808, 18809, 7, 6, 0, 0, 18809, 18810, 7, 9, 0, 0, 18810, 2568, 1, 0, 0, 0, 18811, 18812, 7, 2, 0, 0, 18812, 18813, 7, 3, 0, 0, 18813, 18814, 7, 0, 0, 0, 18814, 18815, 5, 95, 0, 0, 18815, 18816, 7, 9, 0, 0, 18816, 18817, 7, 5, 0, 0, 18817, 18818, 7, 4, 0, 0, 18818, 18819, 5, 95, 0, 0, 18819, 18820, 7, 8, 0, 0, 18820, 18821, 7, 2, 0, 0, 18821, 18822, 7, 7, 0, 0, 18822, 18823, 7, 13, 0, 0, 18823, 18824, 7, 6, 0, 0, 18824, 18825, 7, 3, 0, 0, 18825, 18826, 7, 4, 0, 0, 18826, 2570, 1, 0, 0, 0, 18827, 18828, 7, 2, 0, 0, 18828, 18829, 7, 3, 0, 0, 18829, 18830, 7, 0, 0, 0, 18830, 18831, 5, 95, 0, 0, 18831, 18832, 7, 9, 0, 0, 18832, 18833, 7, 5, 0, 0, 18833, 18834, 7, 4, 0, 0, 18834, 18835, 5, 95, 0, 0, 18835, 18836, 7, 6, 0, 0, 18836, 18837, 7, 3, 0, 0, 18837, 18838, 7, 3, 0, 0, 18838, 18839, 7, 2, 0, 0, 18839, 18840, 7, 3, 0, 0, 18840, 2572, 1, 0, 0, 0, 18841, 18842, 7, 2, 0, 0, 18842, 18843, 7, 3, 0, 0, 18843, 18844, 7, 0, 0, 0, 18844, 18845, 5, 95, 0, 0, 18845, 18846, 7, 17, 0, 0, 18846, 18847, 7, 6, 0, 0, 18847, 18848, 7, 4, 0, 0, 18848, 18849, 5, 95, 0, 0, 18849, 18850, 7, 0, 0, 0, 18850, 18851, 7, 8, 0, 0, 18851, 18852, 7, 11, 0, 0, 18852, 18853, 7, 10, 0, 0, 18853, 18854, 7, 9, 0, 0, 18854, 18855, 7, 5, 0, 0, 18855, 2574, 1, 0, 0, 0, 18856, 18857, 7, 2, 0, 0, 18857, 18858, 7, 3, 0, 0, 18858, 18859, 7, 0, 0, 0, 18859, 18860, 5, 95, 0, 0, 18860, 18861, 7, 17, 0, 0, 18861, 18862, 7, 6, 0, 0, 18862, 18863, 7, 4, 0, 0, 18863, 18864, 5, 95, 0, 0, 18864, 18865, 7, 15, 0, 0, 18865, 18866, 7, 3, 0, 0, 18866, 18867, 7, 10, 0, 0, 18867, 18868, 7, 13, 0, 0, 18868, 18869, 7, 10, 0, 0, 18869, 18870, 7, 11, 0, 0, 18870, 18871, 7, 6, 0, 0, 18871, 18872, 7, 17, 0, 0, 18872, 18873, 7, 6, 0, 0, 18873, 18874, 7, 5, 0, 0, 18874, 2576, 1, 0, 0, 0, 18875, 18876, 7, 2, 0, 0, 18876, 18877, 7, 3, 0, 0, 18877, 18878, 7, 0, 0, 0, 18878, 18879, 5, 95, 0, 0, 18879, 18880, 7, 19, 0, 0, 18880, 18881, 7, 0, 0, 0, 18881, 18882, 7, 5, 0, 0, 18882, 18883, 7, 19, 0, 0, 18883, 2578, 1, 0, 0, 0, 18884, 18885, 7, 2, 0, 0, 18885, 18886, 7, 3, 0, 0, 18886, 18887, 7, 0, 0, 0, 18887, 18888, 5, 95, 0, 0, 18888, 18889, 7, 10, 0, 0, 18889, 18890, 7, 7, 0, 0, 18890, 18891, 7, 13, 0, 0, 18891, 18892, 7, 2, 0, 0, 18892, 18893, 7, 21, 0, 0, 18893, 18894, 7, 10, 0, 0, 18894, 18895, 7, 7, 0, 0, 18895, 18896, 7, 17, 0, 0, 18896, 18897, 5, 95, 0, 0, 18897, 18898, 7, 12, 0, 0, 18898, 18899, 7, 5, 0, 0, 18899, 18900, 7, 6, 0, 0, 18900, 18901, 7, 3, 0, 0, 18901, 18902, 7, 10, 0, 0, 18902, 18903, 7, 9, 0, 0, 18903, 2580, 1, 0, 0, 0, 18904, 18905, 7, 2, 0, 0, 18905, 18906, 7, 3, 0, 0, 18906, 18907, 7, 0, 0, 0, 18907, 18908, 5, 95, 0, 0, 18908, 18909, 7, 10, 0, 0, 18909, 18910, 7, 7, 0, 0, 18910, 18911, 7, 13, 0, 0, 18911, 18912, 7, 2, 0, 0, 18912, 18913, 7, 21, 0, 0, 18913, 18914, 7, 10, 0, 0, 18914, 18915, 7, 7, 0, 0, 18915, 18916, 7, 17, 0, 0, 18916, 18917, 5, 95, 0, 0, 18917, 18918, 7, 12, 0, 0, 18918, 18919, 7, 5, 0, 0, 18919, 18920, 7, 6, 0, 0, 18920, 18921, 7, 3, 0, 0, 18921, 2582, 1, 0, 0, 0, 18922, 18923, 7, 2, 0, 0, 18923, 18924, 7, 3, 0, 0, 18924, 18925, 7, 0, 0, 0, 18925, 18926, 5, 95, 0, 0, 18926, 18927, 7, 10, 0, 0, 18927, 18928, 7, 7, 0, 0, 18928, 18929, 7, 13, 0, 0, 18929, 18930, 7, 2, 0, 0, 18930, 18931, 7, 21, 0, 0, 18931, 18932, 7, 10, 0, 0, 18932, 18933, 7, 7, 0, 0, 18933, 18934, 7, 17, 0, 0, 18934, 18935, 5, 95, 0, 0, 18935, 18936, 7, 25, 0, 0, 18936, 18937, 7, 5, 0, 0, 18937, 18938, 5, 95, 0, 0, 18938, 18939, 7, 12, 0, 0, 18939, 18940, 7, 5, 0, 0, 18940, 18941, 7, 6, 0, 0, 18941, 18942, 7, 3, 0, 0, 18942, 18943, 5, 95, 0, 0, 18943, 18944, 7, 17, 0, 0, 18944, 18945, 7, 12, 0, 0, 18945, 18946, 7, 10, 0, 0, 18946, 18947, 7, 9, 0, 0, 18947, 2584, 1, 0, 0, 0, 18948, 18949, 7, 2, 0, 0, 18949, 18950, 7, 3, 0, 0, 18950, 18951, 7, 0, 0, 0, 18951, 18952, 5, 95, 0, 0, 18952, 18953, 7, 10, 0, 0, 18953, 18954, 7, 7, 0, 0, 18954, 18955, 7, 13, 0, 0, 18955, 18956, 7, 2, 0, 0, 18956, 18957, 7, 21, 0, 0, 18957, 18958, 7, 10, 0, 0, 18958, 18959, 7, 7, 0, 0, 18959, 18960, 7, 17, 0, 0, 18960, 18961, 5, 95, 0, 0, 18961, 18962, 7, 25, 0, 0, 18962, 18963, 7, 5, 0, 0, 18963, 18964, 5, 95, 0, 0, 18964, 18965, 7, 12, 0, 0, 18965, 18966, 7, 5, 0, 0, 18966, 18967, 7, 6, 0, 0, 18967, 18968, 7, 3, 0, 0, 18968, 2586, 1, 0, 0, 0, 18969, 18970, 7, 2, 0, 0, 18970, 18971, 7, 3, 0, 0, 18971, 18972, 7, 0, 0, 0, 18972, 18973, 5, 95, 0, 0, 18973, 18974, 7, 3, 0, 0, 18974, 18975, 7, 0, 0, 0, 18975, 18976, 7, 22, 0, 0, 18976, 18977, 7, 8, 0, 0, 18977, 18978, 7, 2, 0, 0, 18978, 18979, 7, 14, 0, 0, 18979, 18980, 7, 15, 0, 0, 18980, 18981, 7, 0, 0, 0, 18981, 18982, 7, 3, 0, 0, 18982, 18983, 7, 6, 0, 0, 18983, 2588, 1, 0, 0, 0, 18984, 18985, 7, 2, 0, 0, 18985, 18986, 7, 3, 0, 0, 18986, 18987, 7, 0, 0, 0, 18987, 18988, 5, 95, 0, 0, 18988, 18989, 7, 3, 0, 0, 18989, 18990, 7, 0, 0, 0, 18990, 18991, 7, 22, 0, 0, 18991, 18992, 7, 8, 0, 0, 18992, 18993, 7, 2, 0, 0, 18993, 18994, 7, 7, 0, 0, 18994, 18995, 7, 8, 0, 0, 18995, 18996, 7, 0, 0, 0, 18996, 18997, 7, 4, 0, 0, 18997, 2590, 1, 0, 0, 0, 18998, 18999, 7, 2, 0, 0, 18999, 19000, 7, 3, 0, 0, 19000, 19001, 7, 0, 0, 0, 19001, 19002, 5, 95, 0, 0, 19002, 19003, 7, 3, 0, 0, 19003, 19004, 7, 2, 0, 0, 19004, 19005, 7, 22, 0, 0, 19005, 19006, 7, 5, 0, 0, 19006, 19007, 7, 8, 0, 0, 19007, 19008, 7, 7, 0, 0, 19008, 2592, 1, 0, 0, 0, 19009, 19010, 7, 2, 0, 0, 19010, 19011, 7, 3, 0, 0, 19011, 19012, 7, 0, 0, 0, 19012, 19013, 5, 95, 0, 0, 19013, 19014, 7, 3, 0, 0, 19014, 19015, 7, 2, 0, 0, 19015, 19016, 7, 22, 0, 0, 19016, 19017, 7, 5, 0, 0, 19017, 19018, 7, 8, 0, 0, 19018, 19019, 7, 7, 0, 0, 19019, 19020, 5, 95, 0, 0, 19020, 19021, 7, 3, 0, 0, 19021, 19022, 7, 0, 0, 0, 19022, 19023, 7, 22, 0, 0, 19023, 2594, 1, 0, 0, 0, 19024, 19025, 7, 2, 0, 0, 19025, 19026, 7, 3, 0, 0, 19026, 19027, 7, 0, 0, 0, 19027, 19028, 5, 95, 0, 0, 19028, 19029, 7, 3, 0, 0, 19029, 19030, 7, 2, 0, 0, 19030, 19031, 7, 22, 0, 0, 19031, 19032, 7, 13, 0, 0, 19032, 19033, 7, 6, 0, 0, 19033, 19034, 7, 3, 0, 0, 19034, 19035, 7, 5, 0, 0, 19035, 19036, 7, 10, 0, 0, 19036, 19037, 7, 2, 0, 0, 19037, 19038, 7, 7, 0, 0, 19038, 2596, 1, 0, 0, 0, 19039, 19040, 7, 2, 0, 0, 19040, 19041, 7, 3, 0, 0, 19041, 19042, 7, 0, 0, 0, 19042, 19043, 5, 95, 0, 0, 19043, 19044, 7, 4, 0, 0, 19044, 19045, 7, 0, 0, 0, 19045, 19046, 7, 1, 0, 0, 19046, 19047, 7, 13, 0, 0, 19047, 19048, 7, 6, 0, 0, 19048, 19049, 7, 3, 0, 0, 19049, 19050, 7, 5, 0, 0, 19050, 19051, 7, 10, 0, 0, 19051, 19052, 7, 2, 0, 0, 19052, 19053, 7, 7, 0, 0, 19053, 2598, 1, 0, 0, 0, 19054, 19055, 7, 2, 0, 0, 19055, 19056, 7, 3, 0, 0, 19056, 19057, 7, 0, 0, 0, 19057, 19058, 5, 95, 0, 0, 19058, 19059, 7, 22, 0, 0, 19059, 19060, 7, 3, 0, 0, 19060, 19061, 7, 10, 0, 0, 19061, 19062, 7, 4, 0, 0, 19062, 19063, 7, 6, 0, 0, 19063, 19064, 5, 95, 0, 0, 19064, 19065, 7, 4, 0, 0, 19065, 19066, 7, 10, 0, 0, 19066, 19067, 7, 14, 0, 0, 19067, 19068, 7, 6, 0, 0, 19068, 2600, 1, 0, 0, 0, 19069, 19070, 7, 2, 0, 0, 19070, 19071, 7, 3, 0, 0, 19071, 19072, 7, 9, 0, 0, 19072, 19073, 7, 6, 0, 0, 19073, 19074, 7, 3, 0, 0, 19074, 19075, 7, 6, 0, 0, 19075, 19076, 7, 9, 0, 0, 19076, 2602, 1, 0, 0, 0, 19077, 19078, 7, 2, 0, 0, 19078, 19079, 7, 3, 0, 0, 19079, 19080, 7, 9, 0, 0, 19080, 19081, 7, 6, 0, 0, 19081, 19082, 7, 3, 0, 0, 19082, 19083, 7, 6, 0, 0, 19083, 19084, 7, 9, 0, 0, 19084, 19085, 5, 95, 0, 0, 19085, 19086, 7, 15, 0, 0, 19086, 19087, 7, 3, 0, 0, 19087, 19088, 7, 6, 0, 0, 19088, 19089, 7, 9, 0, 0, 19089, 19090, 7, 10, 0, 0, 19090, 19091, 7, 8, 0, 0, 19091, 19092, 7, 0, 0, 0, 19092, 19093, 7, 4, 0, 0, 19093, 19094, 7, 6, 0, 0, 19094, 19095, 7, 5, 0, 0, 19095, 2604, 1, 0, 0, 0, 19096, 19097, 7, 2, 0, 0, 19097, 19098, 7, 3, 0, 0, 19098, 19099, 7, 9, 0, 0, 19099, 19100, 7, 6, 0, 0, 19100, 19101, 7, 3, 0, 0, 19101, 2606, 1, 0, 0, 0, 19102, 19103, 7, 2, 0, 0, 19103, 19104, 7, 3, 0, 0, 19104, 19105, 7, 9, 0, 0, 19105, 19106, 7, 10, 0, 0, 19106, 19107, 7, 7, 0, 0, 19107, 19108, 7, 0, 0, 0, 19108, 19109, 7, 11, 0, 0, 19109, 19110, 7, 10, 0, 0, 19110, 19111, 7, 4, 0, 0, 19111, 19112, 7, 18, 0, 0, 19112, 2608, 1, 0, 0, 0, 19113, 19114, 7, 2, 0, 0, 19114, 19115, 7, 3, 0, 0, 19115, 19116, 5, 95, 0, 0, 19116, 19117, 7, 6, 0, 0, 19117, 19118, 7, 25, 0, 0, 19118, 19119, 7, 15, 0, 0, 19119, 19120, 7, 0, 0, 0, 19120, 19121, 7, 7, 0, 0, 19121, 19122, 7, 9, 0, 0, 19122, 2610, 1, 0, 0, 0, 19123, 19124, 7, 2, 0, 0, 19124, 19125, 7, 3, 0, 0, 19125, 19126, 7, 17, 0, 0, 19126, 19127, 7, 0, 0, 0, 19127, 19128, 7, 7, 0, 0, 19128, 19129, 7, 10, 0, 0, 19129, 19130, 7, 23, 0, 0, 19130, 19131, 7, 0, 0, 0, 19131, 19132, 7, 4, 0, 0, 19132, 19133, 7, 10, 0, 0, 19133, 19134, 7, 2, 0, 0, 19134, 19135, 7, 7, 0, 0, 19135, 2612, 1, 0, 0, 0, 19136, 19137, 7, 2, 0, 0, 19137, 19138, 7, 3, 0, 0, 19138, 2614, 1, 0, 0, 0, 19139, 19140, 7, 2, 0, 0, 19140, 19141, 7, 3, 0, 0, 19141, 19142, 5, 95, 0, 0, 19142, 19143, 7, 15, 0, 0, 19143, 19144, 7, 3, 0, 0, 19144, 19145, 7, 6, 0, 0, 19145, 19146, 7, 9, 0, 0, 19146, 19147, 7, 10, 0, 0, 19147, 19148, 7, 8, 0, 0, 19148, 19149, 7, 0, 0, 0, 19149, 19150, 7, 4, 0, 0, 19150, 19151, 7, 6, 0, 0, 19151, 19152, 7, 5, 0, 0, 19152, 2616, 1, 0, 0, 0, 19153, 19154, 7, 2, 0, 0, 19154, 19155, 7, 5, 0, 0, 19155, 19156, 7, 6, 0, 0, 19156, 19157, 7, 3, 0, 0, 19157, 19158, 7, 3, 0, 0, 19158, 19159, 7, 2, 0, 0, 19159, 19160, 7, 3, 0, 0, 19160, 2618, 1, 0, 0, 0, 19161, 19162, 7, 2, 0, 0, 19162, 19163, 7, 4, 0, 0, 19163, 19164, 7, 19, 0, 0, 19164, 19165, 7, 6, 0, 0, 19165, 19166, 7, 3, 0, 0, 19166, 2620, 1, 0, 0, 0, 19167, 19168, 7, 2, 0, 0, 19168, 19169, 7, 12, 0, 0, 19169, 19170, 7, 4, 0, 0, 19170, 19171, 7, 6, 0, 0, 19171, 19172, 7, 3, 0, 0, 19172, 19173, 5, 95, 0, 0, 19173, 19174, 7, 20, 0, 0, 19174, 19175, 7, 2, 0, 0, 19175, 19176, 7, 10, 0, 0, 19176, 19177, 7, 7, 0, 0, 19177, 19178, 5, 95, 0, 0, 19178, 19179, 7, 4, 0, 0, 19179, 19180, 7, 2, 0, 0, 19180, 19181, 5, 95, 0, 0, 19181, 19182, 7, 0, 0, 0, 19182, 19183, 7, 7, 0, 0, 19183, 19184, 7, 4, 0, 0, 19184, 19185, 7, 10, 0, 0, 19185, 2622, 1, 0, 0, 0, 19186, 19187, 7, 2, 0, 0, 19187, 19188, 7, 12, 0, 0, 19188, 19189, 7, 4, 0, 0, 19189, 19190, 7, 6, 0, 0, 19190, 19191, 7, 3, 0, 0, 19191, 19192, 5, 95, 0, 0, 19192, 19193, 7, 20, 0, 0, 19193, 19194, 7, 2, 0, 0, 19194, 19195, 7, 10, 0, 0, 19195, 19196, 7, 7, 0, 0, 19196, 19197, 5, 95, 0, 0, 19197, 19198, 7, 4, 0, 0, 19198, 19199, 7, 2, 0, 0, 19199, 19200, 5, 95, 0, 0, 19200, 19201, 7, 10, 0, 0, 19201, 19202, 7, 7, 0, 0, 19202, 19203, 7, 7, 0, 0, 19203, 19204, 7, 6, 0, 0, 19204, 19205, 7, 3, 0, 0, 19205, 2624, 1, 0, 0, 0, 19206, 19207, 7, 2, 0, 0, 19207, 19208, 7, 12, 0, 0, 19208, 19209, 7, 4, 0, 0, 19209, 19210, 7, 6, 0, 0, 19210, 19211, 7, 3, 0, 0, 19211, 2626, 1, 0, 0, 0, 19212, 19213, 7, 2, 0, 0, 19213, 19214, 7, 12, 0, 0, 19214, 19215, 7, 4, 0, 0, 19215, 19216, 7, 11, 0, 0, 19216, 19217, 7, 10, 0, 0, 19217, 19218, 7, 7, 0, 0, 19218, 19219, 7, 6, 0, 0, 19219, 19220, 5, 95, 0, 0, 19220, 19221, 7, 11, 0, 0, 19221, 19222, 7, 6, 0, 0, 19222, 19223, 7, 0, 0, 0, 19223, 19224, 7, 16, 0, 0, 19224, 2628, 1, 0, 0, 0, 19225, 19226, 7, 2, 0, 0, 19226, 19227, 7, 12, 0, 0, 19227, 19228, 7, 4, 0, 0, 19228, 19229, 7, 11, 0, 0, 19229, 19230, 7, 10, 0, 0, 19230, 19231, 7, 7, 0, 0, 19231, 19232, 7, 6, 0, 0, 19232, 2630, 1, 0, 0, 0, 19233, 19234, 7, 2, 0, 0, 19234, 19235, 7, 12, 0, 0, 19235, 19236, 7, 4, 0, 0, 19236, 19237, 7, 15, 0, 0, 19237, 19238, 7, 12, 0, 0, 19238, 19239, 7, 4, 0, 0, 19239, 19240, 7, 16, 0, 0, 19240, 19241, 7, 2, 0, 0, 19241, 19242, 7, 3, 0, 0, 19242, 19243, 7, 14, 0, 0, 19243, 19244, 7, 0, 0, 0, 19244, 19245, 7, 4, 0, 0, 19245, 2632, 1, 0, 0, 0, 19246, 19247, 7, 2, 0, 0, 19247, 19248, 7, 12, 0, 0, 19248, 19249, 7, 4, 0, 0, 19249, 19250, 5, 95, 0, 0, 19250, 19251, 7, 2, 0, 0, 19251, 19252, 7, 16, 0, 0, 19252, 19253, 5, 95, 0, 0, 19253, 19254, 7, 11, 0, 0, 19254, 19255, 7, 10, 0, 0, 19255, 19256, 7, 7, 0, 0, 19256, 19257, 7, 6, 0, 0, 19257, 2634, 1, 0, 0, 0, 19258, 19259, 7, 2, 0, 0, 19259, 19260, 7, 12, 0, 0, 19260, 19261, 7, 4, 0, 0, 19261, 2636, 1, 0, 0, 0, 19262, 19263, 7, 2, 0, 0, 19263, 19264, 7, 13, 0, 0, 19264, 19265, 7, 6, 0, 0, 19265, 19266, 7, 3, 0, 0, 19266, 19267, 7, 16, 0, 0, 19267, 19268, 7, 11, 0, 0, 19268, 19269, 7, 2, 0, 0, 19269, 19270, 7, 22, 0, 0, 19270, 19271, 5, 95, 0, 0, 19271, 19272, 7, 7, 0, 0, 19272, 19273, 7, 2, 0, 0, 19273, 19274, 7, 14, 0, 0, 19274, 19275, 7, 2, 0, 0, 19275, 19276, 7, 13, 0, 0, 19276, 19277, 7, 6, 0, 0, 19277, 2638, 1, 0, 0, 0, 19278, 19279, 7, 2, 0, 0, 19279, 19280, 7, 13, 0, 0, 19280, 19281, 7, 6, 0, 0, 19281, 19282, 7, 3, 0, 0, 19282, 19283, 7, 16, 0, 0, 19283, 19284, 7, 11, 0, 0, 19284, 19285, 7, 2, 0, 0, 19285, 19286, 7, 22, 0, 0, 19286, 2640, 1, 0, 0, 0, 19287, 19288, 7, 2, 0, 0, 19288, 19289, 7, 13, 0, 0, 19289, 19290, 7, 6, 0, 0, 19290, 19291, 7, 3, 0, 0, 19291, 19292, 7, 11, 0, 0, 19292, 19293, 7, 0, 0, 0, 19293, 19294, 7, 15, 0, 0, 19294, 19295, 7, 5, 0, 0, 19295, 2642, 1, 0, 0, 0, 19296, 19297, 7, 2, 0, 0, 19297, 19298, 7, 13, 0, 0, 19298, 19299, 7, 6, 0, 0, 19299, 19300, 7, 3, 0, 0, 19300, 2644, 1, 0, 0, 0, 19301, 19302, 7, 2, 0, 0, 19302, 19303, 7, 13, 0, 0, 19303, 19304, 7, 6, 0, 0, 19304, 19305, 7, 3, 0, 0, 19305, 19306, 7, 3, 0, 0, 19306, 19307, 7, 10, 0, 0, 19307, 19308, 7, 9, 0, 0, 19308, 19309, 7, 6, 0, 0, 19309, 2646, 1, 0, 0, 0, 19310, 19311, 7, 2, 0, 0, 19311, 19312, 7, 13, 0, 0, 19312, 19313, 7, 6, 0, 0, 19313, 19314, 7, 3, 0, 0, 19314, 19315, 7, 3, 0, 0, 19315, 19316, 7, 10, 0, 0, 19316, 19317, 7, 9, 0, 0, 19317, 19318, 7, 10, 0, 0, 19318, 19319, 7, 7, 0, 0, 19319, 19320, 7, 17, 0, 0, 19320, 2648, 1, 0, 0, 0, 19321, 19322, 7, 2, 0, 0, 19322, 19323, 7, 22, 0, 0, 19323, 19324, 7, 7, 0, 0, 19324, 19325, 7, 6, 0, 0, 19325, 19326, 7, 3, 0, 0, 19326, 2650, 1, 0, 0, 0, 19327, 19328, 7, 2, 0, 0, 19328, 19329, 7, 22, 0, 0, 19329, 19330, 7, 7, 0, 0, 19330, 19331, 7, 6, 0, 0, 19331, 19332, 7, 3, 0, 0, 19332, 19333, 7, 5, 0, 0, 19333, 19334, 7, 19, 0, 0, 19334, 19335, 7, 10, 0, 0, 19335, 19336, 7, 15, 0, 0, 19336, 2652, 1, 0, 0, 0, 19337, 19338, 7, 2, 0, 0, 19338, 19339, 7, 22, 0, 0, 19339, 19340, 7, 7, 0, 0, 19340, 2654, 1, 0, 0, 0, 19341, 19342, 7, 15, 0, 0, 19342, 2656, 1, 0, 0, 0, 19343, 19344, 7, 15, 0, 0, 19344, 19345, 7, 0, 0, 0, 19345, 19346, 7, 8, 0, 0, 19346, 19347, 7, 21, 0, 0, 19347, 19348, 7, 0, 0, 0, 19348, 19349, 7, 17, 0, 0, 19349, 19350, 7, 6, 0, 0, 19350, 2658, 1, 0, 0, 0, 19351, 19352, 7, 15, 0, 0, 19352, 19353, 7, 0, 0, 0, 19353, 19354, 7, 8, 0, 0, 19354, 19355, 7, 21, 0, 0, 19355, 19356, 7, 0, 0, 0, 19356, 19357, 7, 17, 0, 0, 19357, 19358, 7, 6, 0, 0, 19358, 19359, 7, 5, 0, 0, 19359, 2660, 1, 0, 0, 0, 19360, 19361, 7, 15, 0, 0, 19361, 19362, 7, 0, 0, 0, 19362, 19363, 7, 3, 0, 0, 19363, 19364, 7, 0, 0, 0, 19364, 19365, 7, 11, 0, 0, 19365, 19366, 7, 11, 0, 0, 19366, 19367, 7, 6, 0, 0, 19367, 19368, 7, 11, 0, 0, 19368, 19369, 5, 95, 0, 0, 19369, 19370, 7, 6, 0, 0, 19370, 19371, 7, 7, 0, 0, 19371, 19372, 7, 0, 0, 0, 19372, 19373, 7, 1, 0, 0, 19373, 19374, 7, 11, 0, 0, 19374, 19375, 7, 6, 0, 0, 19375, 2662, 1, 0, 0, 0, 19376, 19377, 7, 15, 0, 0, 19377, 19378, 7, 0, 0, 0, 19378, 19379, 7, 3, 0, 0, 19379, 19380, 7, 0, 0, 0, 19380, 19381, 7, 11, 0, 0, 19381, 19382, 7, 11, 0, 0, 19382, 19383, 7, 6, 0, 0, 19383, 19384, 7, 11, 0, 0, 19384, 19385, 5, 95, 0, 0, 19385, 19386, 7, 10, 0, 0, 19386, 19387, 7, 7, 0, 0, 19387, 19388, 7, 9, 0, 0, 19388, 19389, 7, 6, 0, 0, 19389, 19390, 7, 25, 0, 0, 19390, 2664, 1, 0, 0, 0, 19391, 19392, 7, 15, 0, 0, 19392, 19393, 7, 0, 0, 0, 19393, 19394, 7, 3, 0, 0, 19394, 19395, 7, 0, 0, 0, 19395, 19396, 7, 11, 0, 0, 19396, 19397, 7, 11, 0, 0, 19397, 19398, 7, 6, 0, 0, 19398, 19399, 7, 11, 0, 0, 19399, 2666, 1, 0, 0, 0, 19400, 19401, 7, 15, 0, 0, 19401, 19402, 7, 0, 0, 0, 19402, 19403, 7, 3, 0, 0, 19403, 19404, 7, 0, 0, 0, 19404, 19405, 7, 14, 0, 0, 19405, 19406, 7, 6, 0, 0, 19406, 19407, 7, 4, 0, 0, 19407, 19408, 7, 6, 0, 0, 19408, 19409, 7, 3, 0, 0, 19409, 19410, 7, 16, 0, 0, 19410, 19411, 7, 10, 0, 0, 19411, 19412, 7, 11, 0, 0, 19412, 19413, 7, 6, 0, 0, 19413, 2668, 1, 0, 0, 0, 19414, 19415, 7, 15, 0, 0, 19415, 19416, 7, 0, 0, 0, 19416, 19417, 7, 3, 0, 0, 19417, 19418, 7, 0, 0, 0, 19418, 19419, 7, 14, 0, 0, 19419, 19420, 7, 6, 0, 0, 19420, 19421, 7, 4, 0, 0, 19421, 19422, 7, 6, 0, 0, 19422, 19423, 7, 3, 0, 0, 19423, 19424, 7, 5, 0, 0, 19424, 2670, 1, 0, 0, 0, 19425, 19426, 7, 15, 0, 0, 19426, 19427, 7, 0, 0, 0, 19427, 19428, 7, 3, 0, 0, 19428, 19429, 7, 0, 0, 0, 19429, 19430, 7, 14, 0, 0, 19430, 2672, 1, 0, 0, 0, 19431, 19432, 7, 15, 0, 0, 19432, 19433, 7, 0, 0, 0, 19433, 19434, 7, 3, 0, 0, 19434, 19435, 7, 6, 0, 0, 19435, 19436, 7, 7, 0, 0, 19436, 19437, 7, 4, 0, 0, 19437, 2674, 1, 0, 0, 0, 19438, 19439, 7, 15, 0, 0, 19439, 19440, 7, 0, 0, 0, 19440, 19441, 7, 3, 0, 0, 19441, 19442, 7, 6, 0, 0, 19442, 19443, 7, 7, 0, 0, 19443, 19444, 7, 4, 0, 0, 19444, 19445, 5, 95, 0, 0, 19445, 19446, 7, 11, 0, 0, 19446, 19447, 7, 6, 0, 0, 19447, 19448, 7, 13, 0, 0, 19448, 19449, 7, 6, 0, 0, 19449, 19450, 7, 11, 0, 0, 19450, 19451, 5, 95, 0, 0, 19451, 19452, 7, 7, 0, 0, 19452, 19453, 7, 0, 0, 0, 19453, 19454, 7, 14, 0, 0, 19454, 19455, 7, 6, 0, 0, 19455, 2676, 1, 0, 0, 0, 19456, 19457, 7, 15, 0, 0, 19457, 19458, 7, 0, 0, 0, 19458, 19459, 7, 3, 0, 0, 19459, 19460, 7, 6, 0, 0, 19460, 19461, 7, 7, 0, 0, 19461, 19462, 7, 4, 0, 0, 19462, 19463, 5, 95, 0, 0, 19463, 19464, 7, 12, 0, 0, 19464, 19465, 7, 7, 0, 0, 19465, 19466, 7, 10, 0, 0, 19466, 19467, 7, 24, 0, 0, 19467, 19468, 7, 12, 0, 0, 19468, 19469, 7, 6, 0, 0, 19469, 19470, 5, 95, 0, 0, 19470, 19471, 7, 7, 0, 0, 19471, 19472, 7, 0, 0, 0, 19472, 19473, 7, 14, 0, 0, 19473, 19474, 7, 6, 0, 0, 19474, 2678, 1, 0, 0, 0, 19475, 19476, 7, 15, 0, 0, 19476, 19477, 7, 0, 0, 0, 19477, 19478, 7, 3, 0, 0, 19478, 19479, 7, 10, 0, 0, 19479, 19480, 7, 4, 0, 0, 19480, 19481, 7, 18, 0, 0, 19481, 2680, 1, 0, 0, 0, 19482, 19483, 7, 15, 0, 0, 19483, 19484, 7, 0, 0, 0, 19484, 19485, 7, 3, 0, 0, 19485, 19486, 7, 24, 0, 0, 19486, 19487, 7, 12, 0, 0, 19487, 19488, 7, 6, 0, 0, 19488, 19489, 7, 4, 0, 0, 19489, 2682, 1, 0, 0, 0, 19490, 19491, 7, 15, 0, 0, 19491, 19492, 7, 0, 0, 0, 19492, 19493, 7, 3, 0, 0, 19493, 19494, 7, 4, 0, 0, 19494, 19495, 7, 10, 0, 0, 19495, 19496, 7, 0, 0, 0, 19496, 19497, 7, 11, 0, 0, 19497, 19498, 5, 95, 0, 0, 19498, 19499, 7, 20, 0, 0, 19499, 19500, 7, 2, 0, 0, 19500, 19501, 7, 10, 0, 0, 19501, 19502, 7, 7, 0, 0, 19502, 2684, 1, 0, 0, 0, 19503, 19504, 7, 15, 0, 0, 19504, 19505, 7, 0, 0, 0, 19505, 19506, 7, 3, 0, 0, 19506, 19507, 7, 4, 0, 0, 19507, 19508, 7, 10, 0, 0, 19508, 19509, 7, 0, 0, 0, 19509, 19510, 7, 11, 0, 0, 19510, 19511, 7, 11, 0, 0, 19511, 19512, 7, 18, 0, 0, 19512, 2686, 1, 0, 0, 0, 19513, 19514, 7, 15, 0, 0, 19514, 19515, 7, 0, 0, 0, 19515, 19516, 7, 3, 0, 0, 19516, 19517, 7, 4, 0, 0, 19517, 19518, 7, 10, 0, 0, 19518, 19519, 7, 0, 0, 0, 19519, 19520, 7, 11, 0, 0, 19520, 2688, 1, 0, 0, 0, 19521, 19522, 7, 15, 0, 0, 19522, 19523, 7, 0, 0, 0, 19523, 19524, 7, 3, 0, 0, 19524, 19525, 7, 4, 0, 0, 19525, 19526, 7, 10, 0, 0, 19526, 19527, 7, 0, 0, 0, 19527, 19528, 7, 11, 0, 0, 19528, 19529, 5, 95, 0, 0, 19529, 19530, 7, 3, 0, 0, 19530, 19531, 7, 2, 0, 0, 19531, 19532, 7, 11, 0, 0, 19532, 19533, 7, 11, 0, 0, 19533, 19534, 7, 12, 0, 0, 19534, 19535, 7, 15, 0, 0, 19535, 19536, 5, 95, 0, 0, 19536, 19537, 7, 15, 0, 0, 19537, 19538, 7, 12, 0, 0, 19538, 19539, 7, 5, 0, 0, 19539, 19540, 7, 19, 0, 0, 19540, 19541, 7, 9, 0, 0, 19541, 19542, 7, 2, 0, 0, 19542, 19543, 7, 22, 0, 0, 19543, 19544, 7, 7, 0, 0, 19544, 2690, 1, 0, 0, 0, 19545, 19546, 7, 15, 0, 0, 19546, 19547, 7, 0, 0, 0, 19547, 19548, 7, 3, 0, 0, 19548, 19549, 7, 4, 0, 0, 19549, 19550, 7, 10, 0, 0, 19550, 19551, 7, 4, 0, 0, 19551, 19552, 7, 10, 0, 0, 19552, 19553, 7, 2, 0, 0, 19553, 19554, 7, 7, 0, 0, 19554, 19555, 5, 95, 0, 0, 19555, 19556, 7, 19, 0, 0, 19556, 19557, 7, 0, 0, 0, 19557, 19558, 7, 5, 0, 0, 19558, 19559, 7, 19, 0, 0, 19559, 2692, 1, 0, 0, 0, 19560, 19561, 7, 15, 0, 0, 19561, 19562, 7, 0, 0, 0, 19562, 19563, 7, 3, 0, 0, 19563, 19564, 7, 4, 0, 0, 19564, 19565, 7, 10, 0, 0, 19565, 19566, 7, 4, 0, 0, 19566, 19567, 7, 10, 0, 0, 19567, 19568, 7, 2, 0, 0, 19568, 19569, 7, 7, 0, 0, 19569, 19570, 5, 95, 0, 0, 19570, 19571, 7, 11, 0, 0, 19571, 19572, 7, 10, 0, 0, 19572, 19573, 7, 5, 0, 0, 19573, 19574, 7, 4, 0, 0, 19574, 2694, 1, 0, 0, 0, 19575, 19576, 7, 15, 0, 0, 19576, 19577, 7, 0, 0, 0, 19577, 19578, 7, 3, 0, 0, 19578, 19579, 7, 4, 0, 0, 19579, 19580, 7, 10, 0, 0, 19580, 19581, 7, 4, 0, 0, 19581, 19582, 7, 10, 0, 0, 19582, 19583, 7, 2, 0, 0, 19583, 19584, 7, 7, 0, 0, 19584, 2696, 1, 0, 0, 0, 19585, 19586, 7, 15, 0, 0, 19586, 19587, 7, 0, 0, 0, 19587, 19588, 7, 3, 0, 0, 19588, 19589, 7, 4, 0, 0, 19589, 19590, 7, 10, 0, 0, 19590, 19591, 7, 4, 0, 0, 19591, 19592, 7, 10, 0, 0, 19592, 19593, 7, 2, 0, 0, 19593, 19594, 7, 7, 0, 0, 19594, 19595, 5, 95, 0, 0, 19595, 19596, 7, 3, 0, 0, 19596, 19597, 7, 0, 0, 0, 19597, 19598, 7, 7, 0, 0, 19598, 19599, 7, 17, 0, 0, 19599, 19600, 7, 6, 0, 0, 19600, 2698, 1, 0, 0, 0, 19601, 19602, 7, 15, 0, 0, 19602, 19603, 7, 0, 0, 0, 19603, 19604, 7, 3, 0, 0, 19604, 19605, 7, 4, 0, 0, 19605, 19606, 7, 10, 0, 0, 19606, 19607, 7, 4, 0, 0, 19607, 19608, 7, 10, 0, 0, 19608, 19609, 7, 2, 0, 0, 19609, 19610, 7, 7, 0, 0, 19610, 19611, 7, 5, 0, 0, 19611, 2700, 1, 0, 0, 0, 19612, 19613, 7, 15, 0, 0, 19613, 19614, 7, 0, 0, 0, 19614, 19615, 7, 3, 0, 0, 19615, 19616, 7, 4, 0, 0, 19616, 19617, 5, 36, 0, 0, 19617, 19618, 7, 7, 0, 0, 19618, 19619, 7, 12, 0, 0, 19619, 19620, 7, 14, 0, 0, 19620, 19621, 5, 36, 0, 0, 19621, 19622, 7, 10, 0, 0, 19622, 19623, 7, 7, 0, 0, 19623, 19624, 7, 5, 0, 0, 19624, 19625, 7, 4, 0, 0, 19625, 2702, 1, 0, 0, 0, 19626, 19627, 7, 15, 0, 0, 19627, 19628, 7, 0, 0, 0, 19628, 19629, 7, 5, 0, 0, 19629, 19630, 7, 5, 0, 0, 19630, 19631, 7, 10, 0, 0, 19631, 19632, 7, 7, 0, 0, 19632, 19633, 7, 17, 0, 0, 19633, 2704, 1, 0, 0, 0, 19634, 19635, 7, 15, 0, 0, 19635, 19636, 7, 0, 0, 0, 19636, 19637, 7, 5, 0, 0, 19637, 19638, 7, 5, 0, 0, 19638, 19639, 7, 22, 0, 0, 19639, 19640, 7, 2, 0, 0, 19640, 19641, 7, 3, 0, 0, 19641, 19642, 7, 9, 0, 0, 19642, 19643, 5, 95, 0, 0, 19643, 19644, 7, 17, 0, 0, 19644, 19645, 7, 3, 0, 0, 19645, 19646, 7, 0, 0, 0, 19646, 19647, 7, 8, 0, 0, 19647, 19648, 7, 6, 0, 0, 19648, 19649, 5, 95, 0, 0, 19649, 19650, 7, 4, 0, 0, 19650, 19651, 7, 10, 0, 0, 19651, 19652, 7, 14, 0, 0, 19652, 19653, 7, 6, 0, 0, 19653, 2706, 1, 0, 0, 0, 19654, 19655, 7, 15, 0, 0, 19655, 19656, 7, 0, 0, 0, 19656, 19657, 7, 5, 0, 0, 19657, 19658, 7, 5, 0, 0, 19658, 19659, 7, 22, 0, 0, 19659, 19660, 7, 2, 0, 0, 19660, 19661, 7, 3, 0, 0, 19661, 19662, 7, 9, 0, 0, 19662, 19663, 5, 95, 0, 0, 19663, 19664, 7, 11, 0, 0, 19664, 19665, 7, 10, 0, 0, 19665, 19666, 7, 16, 0, 0, 19666, 19667, 7, 6, 0, 0, 19667, 19668, 5, 95, 0, 0, 19668, 19669, 7, 4, 0, 0, 19669, 19670, 7, 10, 0, 0, 19670, 19671, 7, 14, 0, 0, 19671, 19672, 7, 6, 0, 0, 19672, 2708, 1, 0, 0, 0, 19673, 19674, 7, 15, 0, 0, 19674, 19675, 7, 0, 0, 0, 19675, 19676, 7, 5, 0, 0, 19676, 19677, 7, 5, 0, 0, 19677, 19678, 7, 22, 0, 0, 19678, 19679, 7, 2, 0, 0, 19679, 19680, 7, 3, 0, 0, 19680, 19681, 7, 9, 0, 0, 19681, 19682, 5, 95, 0, 0, 19682, 19683, 7, 11, 0, 0, 19683, 19684, 7, 2, 0, 0, 19684, 19685, 7, 8, 0, 0, 19685, 19686, 7, 21, 0, 0, 19686, 19687, 5, 95, 0, 0, 19687, 19688, 7, 4, 0, 0, 19688, 19689, 7, 10, 0, 0, 19689, 19690, 7, 14, 0, 0, 19690, 19691, 7, 6, 0, 0, 19691, 2710, 1, 0, 0, 0, 19692, 19693, 7, 15, 0, 0, 19693, 19694, 7, 0, 0, 0, 19694, 19695, 7, 5, 0, 0, 19695, 19696, 7, 5, 0, 0, 19696, 19697, 7, 22, 0, 0, 19697, 19698, 7, 2, 0, 0, 19698, 19699, 7, 3, 0, 0, 19699, 19700, 7, 9, 0, 0, 19700, 2712, 1, 0, 0, 0, 19701, 19702, 7, 15, 0, 0, 19702, 19703, 7, 0, 0, 0, 19703, 19704, 7, 5, 0, 0, 19704, 19705, 7, 5, 0, 0, 19705, 19706, 7, 22, 0, 0, 19706, 19707, 7, 2, 0, 0, 19707, 19708, 7, 3, 0, 0, 19708, 19709, 7, 9, 0, 0, 19709, 19710, 5, 95, 0, 0, 19710, 19711, 7, 3, 0, 0, 19711, 19712, 7, 6, 0, 0, 19712, 19713, 7, 12, 0, 0, 19713, 19714, 7, 5, 0, 0, 19714, 19715, 7, 6, 0, 0, 19715, 19716, 5, 95, 0, 0, 19716, 19717, 7, 14, 0, 0, 19717, 19718, 7, 0, 0, 0, 19718, 19719, 7, 25, 0, 0, 19719, 2714, 1, 0, 0, 0, 19720, 19721, 7, 15, 0, 0, 19721, 19722, 7, 0, 0, 0, 19722, 19723, 7, 5, 0, 0, 19723, 19724, 7, 5, 0, 0, 19724, 19725, 7, 22, 0, 0, 19725, 19726, 7, 2, 0, 0, 19726, 19727, 7, 3, 0, 0, 19727, 19728, 7, 9, 0, 0, 19728, 19729, 5, 95, 0, 0, 19729, 19730, 7, 3, 0, 0, 19730, 19731, 7, 6, 0, 0, 19731, 19732, 7, 12, 0, 0, 19732, 19733, 7, 5, 0, 0, 19733, 19734, 7, 6, 0, 0, 19734, 19735, 5, 95, 0, 0, 19735, 19736, 7, 4, 0, 0, 19736, 19737, 7, 10, 0, 0, 19737, 19738, 7, 14, 0, 0, 19738, 19739, 7, 6, 0, 0, 19739, 2716, 1, 0, 0, 0, 19740, 19741, 7, 15, 0, 0, 19741, 19742, 7, 0, 0, 0, 19742, 19743, 7, 5, 0, 0, 19743, 19744, 7, 5, 0, 0, 19744, 19745, 7, 22, 0, 0, 19745, 19746, 7, 2, 0, 0, 19746, 19747, 7, 3, 0, 0, 19747, 19748, 7, 9, 0, 0, 19748, 19749, 5, 95, 0, 0, 19749, 19750, 7, 3, 0, 0, 19750, 19751, 7, 2, 0, 0, 19751, 19752, 7, 11, 0, 0, 19752, 19753, 7, 11, 0, 0, 19753, 19754, 7, 2, 0, 0, 19754, 19755, 7, 13, 0, 0, 19755, 19756, 7, 6, 0, 0, 19756, 19757, 7, 3, 0, 0, 19757, 19758, 5, 95, 0, 0, 19758, 19759, 7, 4, 0, 0, 19759, 19760, 7, 10, 0, 0, 19760, 19761, 7, 14, 0, 0, 19761, 19762, 7, 6, 0, 0, 19762, 2718, 1, 0, 0, 0, 19763, 19764, 7, 15, 0, 0, 19764, 19765, 7, 0, 0, 0, 19765, 19766, 7, 5, 0, 0, 19766, 19767, 7, 5, 0, 0, 19767, 19768, 7, 22, 0, 0, 19768, 19769, 7, 2, 0, 0, 19769, 19770, 7, 3, 0, 0, 19770, 19771, 7, 9, 0, 0, 19771, 19772, 5, 95, 0, 0, 19772, 19773, 7, 13, 0, 0, 19773, 19774, 7, 6, 0, 0, 19774, 19775, 7, 3, 0, 0, 19775, 19776, 7, 10, 0, 0, 19776, 19777, 7, 16, 0, 0, 19777, 19778, 7, 18, 0, 0, 19778, 19779, 5, 95, 0, 0, 19779, 19780, 7, 16, 0, 0, 19780, 19781, 7, 12, 0, 0, 19781, 19782, 7, 7, 0, 0, 19782, 19783, 7, 8, 0, 0, 19783, 19784, 7, 4, 0, 0, 19784, 19785, 7, 10, 0, 0, 19785, 19786, 7, 2, 0, 0, 19786, 19787, 7, 7, 0, 0, 19787, 2720, 1, 0, 0, 0, 19788, 19789, 7, 15, 0, 0, 19789, 19790, 7, 0, 0, 0, 19790, 19791, 7, 5, 0, 0, 19791, 19792, 7, 4, 0, 0, 19792, 2722, 1, 0, 0, 0, 19793, 19794, 7, 15, 0, 0, 19794, 19795, 7, 0, 0, 0, 19795, 19796, 7, 4, 0, 0, 19796, 19797, 7, 8, 0, 0, 19797, 19798, 7, 19, 0, 0, 19798, 2724, 1, 0, 0, 0, 19799, 19800, 7, 15, 0, 0, 19800, 19801, 7, 0, 0, 0, 19801, 19802, 7, 4, 0, 0, 19802, 19803, 7, 19, 0, 0, 19803, 2726, 1, 0, 0, 0, 19804, 19805, 7, 15, 0, 0, 19805, 19806, 7, 0, 0, 0, 19806, 19807, 7, 4, 0, 0, 19807, 19808, 7, 19, 0, 0, 19808, 19809, 5, 95, 0, 0, 19809, 19810, 7, 15, 0, 0, 19810, 19811, 7, 3, 0, 0, 19811, 19812, 7, 6, 0, 0, 19812, 19813, 7, 16, 0, 0, 19813, 19814, 7, 10, 0, 0, 19814, 19815, 7, 25, 0, 0, 19815, 2728, 1, 0, 0, 0, 19816, 19817, 7, 15, 0, 0, 19817, 19818, 7, 0, 0, 0, 19818, 19819, 7, 4, 0, 0, 19819, 19820, 7, 19, 0, 0, 19820, 19821, 7, 5, 0, 0, 19821, 2730, 1, 0, 0, 0, 19822, 19823, 7, 15, 0, 0, 19823, 19824, 7, 0, 0, 0, 19824, 19825, 7, 4, 0, 0, 19825, 19826, 7, 4, 0, 0, 19826, 19827, 7, 6, 0, 0, 19827, 19828, 7, 3, 0, 0, 19828, 19829, 7, 7, 0, 0, 19829, 2732, 1, 0, 0, 0, 19830, 19831, 7, 15, 0, 0, 19831, 19832, 7, 1, 0, 0, 19832, 19833, 7, 11, 0, 0, 19833, 19834, 5, 95, 0, 0, 19834, 19835, 7, 19, 0, 0, 19835, 19836, 7, 5, 0, 0, 19836, 19837, 5, 95, 0, 0, 19837, 19838, 7, 1, 0, 0, 19838, 19839, 7, 6, 0, 0, 19839, 19840, 7, 17, 0, 0, 19840, 19841, 7, 10, 0, 0, 19841, 19842, 7, 7, 0, 0, 19842, 2734, 1, 0, 0, 0, 19843, 19844, 7, 15, 0, 0, 19844, 19845, 7, 1, 0, 0, 19845, 19846, 7, 11, 0, 0, 19846, 19847, 5, 95, 0, 0, 19847, 19848, 7, 19, 0, 0, 19848, 19849, 7, 5, 0, 0, 19849, 19850, 5, 95, 0, 0, 19850, 19851, 7, 6, 0, 0, 19851, 19852, 7, 7, 0, 0, 19852, 19853, 7, 9, 0, 0, 19853, 2736, 1, 0, 0, 0, 19854, 19855, 7, 15, 0, 0, 19855, 19856, 7, 8, 0, 0, 19856, 19857, 7, 4, 0, 0, 19857, 19858, 7, 16, 0, 0, 19858, 19859, 7, 3, 0, 0, 19859, 19860, 7, 6, 0, 0, 19860, 19861, 7, 6, 0, 0, 19861, 2738, 1, 0, 0, 0, 19862, 19863, 7, 15, 0, 0, 19863, 19864, 7, 8, 0, 0, 19864, 19865, 7, 4, 0, 0, 19865, 19866, 7, 10, 0, 0, 19866, 19867, 7, 7, 0, 0, 19867, 19868, 7, 8, 0, 0, 19868, 19869, 7, 3, 0, 0, 19869, 19870, 7, 6, 0, 0, 19870, 19871, 7, 0, 0, 0, 19871, 19872, 7, 5, 0, 0, 19872, 19873, 7, 6, 0, 0, 19873, 2740, 1, 0, 0, 0, 19874, 19875, 7, 15, 0, 0, 19875, 19876, 7, 8, 0, 0, 19876, 19877, 7, 4, 0, 0, 19877, 19878, 7, 4, 0, 0, 19878, 19879, 7, 19, 0, 0, 19879, 19880, 7, 3, 0, 0, 19880, 19881, 7, 6, 0, 0, 19881, 19882, 7, 5, 0, 0, 19882, 19883, 7, 19, 0, 0, 19883, 19884, 7, 2, 0, 0, 19884, 19885, 7, 11, 0, 0, 19885, 19886, 7, 9, 0, 0, 19886, 2742, 1, 0, 0, 0, 19887, 19888, 7, 15, 0, 0, 19888, 19889, 7, 8, 0, 0, 19889, 19890, 7, 4, 0, 0, 19890, 19891, 7, 12, 0, 0, 19891, 19892, 7, 5, 0, 0, 19892, 19893, 7, 6, 0, 0, 19893, 19894, 7, 9, 0, 0, 19894, 2744, 1, 0, 0, 0, 19895, 19896, 7, 15, 0, 0, 19896, 19897, 7, 8, 0, 0, 19897, 19898, 7, 4, 0, 0, 19898, 19899, 7, 13, 0, 0, 19899, 19900, 7, 6, 0, 0, 19900, 19901, 7, 3, 0, 0, 19901, 19902, 7, 5, 0, 0, 19902, 19903, 7, 10, 0, 0, 19903, 19904, 7, 2, 0, 0, 19904, 19905, 7, 7, 0, 0, 19905, 2746, 1, 0, 0, 0, 19906, 19907, 7, 15, 0, 0, 19907, 19908, 7, 6, 0, 0, 19908, 19909, 7, 7, 0, 0, 19909, 19910, 7, 9, 0, 0, 19910, 19911, 7, 10, 0, 0, 19911, 19912, 7, 7, 0, 0, 19912, 19913, 7, 17, 0, 0, 19913, 2748, 1, 0, 0, 0, 19914, 19918, 5, 37, 0, 0, 19915, 19917, 3, 4999, 2499, 0, 19916, 19915, 1, 0, 0, 0, 19917, 19920, 1, 0, 0, 0, 19918, 19916, 1, 0, 0, 0, 19918, 19919, 1, 0, 0, 0, 19919, 19921, 1, 0, 0, 0, 19920, 19918, 1, 0, 0, 0, 19921, 19922, 7, 16, 0, 0, 19922, 19923, 7, 2, 0, 0, 19923, 19924, 7, 12, 0, 0, 19924, 19925, 7, 7, 0, 0, 19925, 19926, 7, 9, 0, 0, 19926, 2750, 1, 0, 0, 0, 19927, 19931, 5, 37, 0, 0, 19928, 19930, 3, 4999, 2499, 0, 19929, 19928, 1, 0, 0, 0, 19930, 19933, 1, 0, 0, 0, 19931, 19929, 1, 0, 0, 0, 19931, 19932, 1, 0, 0, 0, 19932, 19934, 1, 0, 0, 0, 19933, 19931, 1, 0, 0, 0, 19934, 19935, 7, 10, 0, 0, 19935, 19936, 7, 5, 0, 0, 19936, 19937, 7, 2, 0, 0, 19937, 19938, 7, 15, 0, 0, 19938, 19939, 7, 6, 0, 0, 19939, 19940, 7, 7, 0, 0, 19940, 2752, 1, 0, 0, 0, 19941, 19945, 5, 37, 0, 0, 19942, 19944, 3, 4999, 2499, 0, 19943, 19942, 1, 0, 0, 0, 19944, 19947, 1, 0, 0, 0, 19945, 19943, 1, 0, 0, 0, 19945, 19946, 1, 0, 0, 0, 19946, 19948, 1, 0, 0, 0, 19947, 19945, 1, 0, 0, 0, 19948, 19949, 7, 7, 0, 0, 19949, 19950, 7, 2, 0, 0, 19950, 19951, 7, 4, 0, 0, 19951, 19952, 7, 16, 0, 0, 19952, 19953, 7, 2, 0, 0, 19953, 19954, 7, 12, 0, 0, 19954, 19955, 7, 7, 0, 0, 19955, 19956, 7, 9, 0, 0, 19956, 2754, 1, 0, 0, 0, 19957, 19958, 7, 15, 0, 0, 19958, 19959, 7, 6, 0, 0, 19959, 19960, 7, 3, 0, 0, 19960, 19961, 7, 8, 0, 0, 19961, 19962, 7, 6, 0, 0, 19962, 19963, 7, 7, 0, 0, 19963, 19964, 7, 4, 0, 0, 19964, 2756, 1, 0, 0, 0, 19965, 19966, 7, 15, 0, 0, 19966, 19967, 7, 6, 0, 0, 19967, 19968, 7, 3, 0, 0, 19968, 19969, 7, 8, 0, 0, 19969, 19970, 7, 6, 0, 0, 19970, 19971, 7, 7, 0, 0, 19971, 19972, 7, 4, 0, 0, 19972, 19973, 5, 95, 0, 0, 19973, 19974, 7, 3, 0, 0, 19974, 19975, 7, 0, 0, 0, 19975, 19976, 7, 7, 0, 0, 19976, 19977, 7, 21, 0, 0, 19977, 19978, 7, 14, 0, 0, 19978, 2758, 1, 0, 0, 0, 19979, 19983, 5, 37, 0, 0, 19980, 19982, 3, 4999, 2499, 0, 19981, 19980, 1, 0, 0, 0, 19982, 19985, 1, 0, 0, 0, 19983, 19981, 1, 0, 0, 0, 19983, 19984, 1, 0, 0, 0, 19984, 19986, 1, 0, 0, 0, 19985, 19983, 1, 0, 0, 0, 19986, 19987, 7, 3, 0, 0, 19987, 19988, 7, 2, 0, 0, 19988, 19989, 7, 22, 0, 0, 19989, 19990, 7, 8, 0, 0, 19990, 19991, 7, 2, 0, 0, 19991, 19992, 7, 12, 0, 0, 19992, 19993, 7, 7, 0, 0, 19993, 19994, 7, 4, 0, 0, 19994, 2760, 1, 0, 0, 0, 19995, 19999, 5, 37, 0, 0, 19996, 19998, 3, 4999, 2499, 0, 19997, 19996, 1, 0, 0, 0, 19998, 20001, 1, 0, 0, 0, 19999, 19997, 1, 0, 0, 0, 19999, 20000, 1, 0, 0, 0, 20000, 20002, 1, 0, 0, 0, 20001, 19999, 1, 0, 0, 0, 20002, 20003, 7, 3, 0, 0, 20003, 20004, 7, 2, 0, 0, 20004, 20005, 7, 22, 0, 0, 20005, 20006, 7, 4, 0, 0, 20006, 20007, 7, 18, 0, 0, 20007, 20008, 7, 15, 0, 0, 20008, 20009, 7, 6, 0, 0, 20009, 2762, 1, 0, 0, 0, 20010, 20014, 5, 37, 0, 0, 20011, 20013, 3, 4999, 2499, 0, 20012, 20011, 1, 0, 0, 0, 20013, 20016, 1, 0, 0, 0, 20014, 20012, 1, 0, 0, 0, 20014, 20015, 1, 0, 0, 0, 20015, 20017, 1, 0, 0, 0, 20016, 20014, 1, 0, 0, 0, 20017, 20018, 7, 4, 0, 0, 20018, 20019, 7, 18, 0, 0, 20019, 20020, 7, 15, 0, 0, 20020, 20021, 7, 6, 0, 0, 20021, 2764, 1, 0, 0, 0, 20022, 20026, 5, 37, 0, 0, 20023, 20025, 3, 4999, 2499, 0, 20024, 20023, 1, 0, 0, 0, 20025, 20028, 1, 0, 0, 0, 20026, 20024, 1, 0, 0, 0, 20026, 20027, 1, 0, 0, 0, 20027, 20029, 1, 0, 0, 0, 20028, 20026, 1, 0, 0, 0, 20029, 20030, 7, 1, 0, 0, 20030, 20031, 7, 12, 0, 0, 20031, 20032, 7, 11, 0, 0, 20032, 20033, 7, 21, 0, 0, 20033, 20034, 5, 95, 0, 0, 20034, 20035, 7, 6, 0, 0, 20035, 20036, 7, 25, 0, 0, 20036, 20037, 7, 8, 0, 0, 20037, 20038, 7, 6, 0, 0, 20038, 20039, 7, 15, 0, 0, 20039, 20040, 7, 4, 0, 0, 20040, 20041, 7, 10, 0, 0, 20041, 20042, 7, 2, 0, 0, 20042, 20043, 7, 7, 0, 0, 20043, 20044, 7, 5, 0, 0, 20044, 2766, 1, 0, 0, 0, 20045, 20049, 5, 37, 0, 0, 20046, 20048, 3, 4999, 2499, 0, 20047, 20046, 1, 0, 0, 0, 20048, 20051, 1, 0, 0, 0, 20049, 20047, 1, 0, 0, 0, 20049, 20050, 1, 0, 0, 0, 20050, 20052, 1, 0, 0, 0, 20051, 20049, 1, 0, 0, 0, 20052, 20053, 7, 1, 0, 0, 20053, 20054, 7, 12, 0, 0, 20054, 20055, 7, 11, 0, 0, 20055, 20056, 7, 21, 0, 0, 20056, 20057, 5, 95, 0, 0, 20057, 20058, 7, 3, 0, 0, 20058, 20059, 7, 2, 0, 0, 20059, 20060, 7, 22, 0, 0, 20060, 20061, 7, 8, 0, 0, 20061, 20062, 7, 2, 0, 0, 20062, 20063, 7, 12, 0, 0, 20063, 20064, 7, 7, 0, 0, 20064, 20065, 7, 4, 0, 0, 20065, 2768, 1, 0, 0, 0, 20066, 20067, 7, 15, 0, 0, 20067, 20068, 7, 6, 0, 0, 20068, 20069, 7, 3, 0, 0, 20069, 20070, 7, 16, 0, 0, 20070, 20071, 7, 2, 0, 0, 20071, 20072, 7, 3, 0, 0, 20072, 20073, 7, 14, 0, 0, 20073, 20074, 7, 0, 0, 0, 20074, 20075, 7, 7, 0, 0, 20075, 20076, 7, 8, 0, 0, 20076, 20077, 7, 6, 0, 0, 20077, 2770, 1, 0, 0, 0, 20078, 20079, 7, 15, 0, 0, 20079, 20080, 7, 6, 0, 0, 20080, 20081, 7, 3, 0, 0, 20081, 20082, 7, 10, 0, 0, 20082, 20083, 7, 2, 0, 0, 20083, 20084, 7, 9, 0, 0, 20084, 2772, 1, 0, 0, 0, 20085, 20086, 7, 15, 0, 0, 20086, 20087, 7, 6, 0, 0, 20087, 20088, 7, 3, 0, 0, 20088, 20089, 7, 14, 0, 0, 20089, 20090, 7, 0, 0, 0, 20090, 20091, 7, 7, 0, 0, 20091, 20092, 7, 6, 0, 0, 20092, 20093, 7, 7, 0, 0, 20093, 20094, 7, 4, 0, 0, 20094, 2774, 1, 0, 0, 0, 20095, 20096, 7, 15, 0, 0, 20096, 20097, 7, 6, 0, 0, 20097, 20098, 7, 3, 0, 0, 20098, 20099, 7, 14, 0, 0, 20099, 20100, 7, 10, 0, 0, 20100, 20101, 7, 5, 0, 0, 20101, 20102, 7, 5, 0, 0, 20102, 20103, 7, 10, 0, 0, 20103, 20104, 7, 2, 0, 0, 20104, 20105, 7, 7, 0, 0, 20105, 2776, 1, 0, 0, 0, 20106, 20107, 7, 15, 0, 0, 20107, 20108, 7, 6, 0, 0, 20108, 20109, 7, 3, 0, 0, 20109, 20110, 7, 14, 0, 0, 20110, 20111, 7, 12, 0, 0, 20111, 20112, 7, 4, 0, 0, 20112, 20113, 7, 6, 0, 0, 20113, 2778, 1, 0, 0, 0, 20114, 20115, 7, 15, 0, 0, 20115, 20116, 7, 6, 0, 0, 20116, 20117, 7, 3, 0, 0, 20117, 2780, 1, 0, 0, 0, 20118, 20119, 7, 15, 0, 0, 20119, 20120, 7, 16, 0, 0, 20120, 20121, 7, 10, 0, 0, 20121, 20122, 7, 11, 0, 0, 20122, 20123, 7, 6, 0, 0, 20123, 2782, 1, 0, 0, 0, 20124, 20125, 7, 15, 0, 0, 20125, 20126, 7, 19, 0, 0, 20126, 20127, 7, 18, 0, 0, 20127, 20128, 7, 5, 0, 0, 20128, 20129, 7, 10, 0, 0, 20129, 20130, 7, 8, 0, 0, 20130, 20131, 7, 0, 0, 0, 20131, 20132, 7, 11, 0, 0, 20132, 2784, 1, 0, 0, 0, 20133, 20134, 7, 15, 0, 0, 20134, 20135, 7, 10, 0, 0, 20135, 20136, 7, 21, 0, 0, 20136, 20137, 7, 6, 0, 0, 20137, 20138, 7, 18, 0, 0, 20138, 2786, 1, 0, 0, 0, 20139, 20140, 7, 15, 0, 0, 20140, 20141, 7, 10, 0, 0, 20141, 20142, 7, 15, 0, 0, 20142, 20143, 7, 6, 0, 0, 20143, 20144, 7, 11, 0, 0, 20144, 20145, 7, 10, 0, 0, 20145, 20146, 7, 7, 0, 0, 20146, 20147, 7, 6, 0, 0, 20147, 20148, 7, 9, 0, 0, 20148, 2788, 1, 0, 0, 0, 20149, 20150, 7, 15, 0, 0, 20150, 20151, 7, 10, 0, 0, 20151, 20152, 7, 15, 0, 0, 20152, 20153, 7, 6, 0, 0, 20153, 2790, 1, 0, 0, 0, 20154, 20155, 7, 15, 0, 0, 20155, 20156, 7, 10, 0, 0, 20156, 20157, 7, 13, 0, 0, 20157, 20158, 5, 95, 0, 0, 20158, 20159, 7, 17, 0, 0, 20159, 20160, 7, 1, 0, 0, 20160, 2792, 1, 0, 0, 0, 20161, 20162, 7, 15, 0, 0, 20162, 20163, 7, 10, 0, 0, 20163, 20164, 7, 13, 0, 0, 20164, 20165, 7, 2, 0, 0, 20165, 20166, 7, 4, 0, 0, 20166, 2794, 1, 0, 0, 0, 20167, 20168, 7, 15, 0, 0, 20168, 20169, 7, 10, 0, 0, 20169, 20170, 7, 13, 0, 0, 20170, 20171, 5, 95, 0, 0, 20171, 20172, 7, 5, 0, 0, 20172, 20173, 7, 5, 0, 0, 20173, 20174, 7, 16, 0, 0, 20174, 2796, 1, 0, 0, 0, 20175, 20176, 7, 15, 0, 0, 20176, 20177, 7, 11, 0, 0, 20177, 20178, 7, 0, 0, 0, 20178, 20179, 7, 8, 0, 0, 20179, 20180, 7, 6, 0, 0, 20180, 20181, 5, 95, 0, 0, 20181, 20182, 7, 9, 0, 0, 20182, 20183, 7, 10, 0, 0, 20183, 20184, 7, 5, 0, 0, 20184, 20185, 7, 4, 0, 0, 20185, 20186, 7, 10, 0, 0, 20186, 20187, 7, 7, 0, 0, 20187, 20188, 7, 8, 0, 0, 20188, 20189, 7, 4, 0, 0, 20189, 2798, 1, 0, 0, 0, 20190, 20191, 7, 15, 0, 0, 20191, 20192, 7, 11, 0, 0, 20192, 20193, 7, 0, 0, 0, 20193, 20194, 7, 8, 0, 0, 20194, 20195, 7, 6, 0, 0, 20195, 20196, 5, 95, 0, 0, 20196, 20197, 7, 17, 0, 0, 20197, 20198, 7, 3, 0, 0, 20198, 20199, 7, 2, 0, 0, 20199, 20200, 7, 12, 0, 0, 20200, 20201, 7, 15, 0, 0, 20201, 20202, 5, 95, 0, 0, 20202, 20203, 7, 1, 0, 0, 20203, 20204, 7, 18, 0, 0, 20204, 2800, 1, 0, 0, 0, 20205, 20206, 7, 15, 0, 0, 20206, 20207, 7, 11, 0, 0, 20207, 20208, 7, 0, 0, 0, 20208, 20209, 7, 7, 0, 0, 20209, 2802, 1, 0, 0, 0, 20210, 20211, 7, 15, 0, 0, 20211, 20212, 7, 11, 0, 0, 20212, 20213, 7, 5, 0, 0, 20213, 20214, 7, 8, 0, 0, 20214, 20215, 7, 2, 0, 0, 20215, 20216, 7, 15, 0, 0, 20216, 20217, 7, 6, 0, 0, 20217, 20218, 5, 95, 0, 0, 20218, 20219, 7, 5, 0, 0, 20219, 20220, 7, 6, 0, 0, 20220, 20221, 7, 4, 0, 0, 20221, 20222, 7, 4, 0, 0, 20222, 20223, 7, 10, 0, 0, 20223, 20224, 7, 7, 0, 0, 20224, 20225, 7, 17, 0, 0, 20225, 20226, 7, 5, 0, 0, 20226, 2804, 1, 0, 0, 0, 20227, 20228, 7, 15, 0, 0, 20228, 20229, 7, 11, 0, 0, 20229, 20230, 7, 5, 0, 0, 20230, 20231, 5, 95, 0, 0, 20231, 20232, 7, 10, 0, 0, 20232, 20233, 7, 7, 0, 0, 20233, 20234, 7, 4, 0, 0, 20234, 20235, 7, 6, 0, 0, 20235, 20236, 7, 17, 0, 0, 20236, 20237, 7, 6, 0, 0, 20237, 20238, 7, 3, 0, 0, 20238, 2806, 1, 0, 0, 0, 20239, 20240, 7, 15, 0, 0, 20240, 20241, 7, 11, 0, 0, 20241, 20242, 7, 5, 0, 0, 20242, 20243, 7, 24, 0, 0, 20243, 20244, 7, 11, 0, 0, 20244, 20245, 5, 95, 0, 0, 20245, 20246, 7, 8, 0, 0, 20246, 20247, 7, 8, 0, 0, 20247, 20248, 7, 16, 0, 0, 20248, 20249, 7, 11, 0, 0, 20249, 20250, 7, 0, 0, 0, 20250, 20251, 7, 17, 0, 0, 20251, 20252, 7, 5, 0, 0, 20252, 2808, 1, 0, 0, 0, 20253, 20254, 7, 15, 0, 0, 20254, 20255, 7, 11, 0, 0, 20255, 20256, 7, 5, 0, 0, 20256, 20257, 7, 24, 0, 0, 20257, 20258, 7, 11, 0, 0, 20258, 20259, 5, 95, 0, 0, 20259, 20260, 7, 8, 0, 0, 20260, 20261, 7, 2, 0, 0, 20261, 20262, 7, 9, 0, 0, 20262, 20263, 7, 6, 0, 0, 20263, 20264, 5, 95, 0, 0, 20264, 20265, 7, 4, 0, 0, 20265, 20266, 7, 18, 0, 0, 20266, 20267, 7, 15, 0, 0, 20267, 20268, 7, 6, 0, 0, 20268, 2810, 1, 0, 0, 0, 20269, 20270, 7, 15, 0, 0, 20270, 20271, 7, 11, 0, 0, 20271, 20272, 7, 5, 0, 0, 20272, 20273, 7, 24, 0, 0, 20273, 20274, 7, 11, 0, 0, 20274, 20275, 5, 95, 0, 0, 20275, 20276, 7, 9, 0, 0, 20276, 20277, 7, 6, 0, 0, 20277, 20278, 7, 1, 0, 0, 20278, 20279, 7, 12, 0, 0, 20279, 20280, 7, 17, 0, 0, 20280, 2812, 1, 0, 0, 0, 20281, 20282, 7, 15, 0, 0, 20282, 20283, 7, 11, 0, 0, 20283, 20284, 7, 5, 0, 0, 20284, 20285, 7, 24, 0, 0, 20285, 20286, 7, 11, 0, 0, 20286, 20287, 5, 95, 0, 0, 20287, 20288, 7, 2, 0, 0, 20288, 20289, 7, 15, 0, 0, 20289, 20290, 7, 4, 0, 0, 20290, 20291, 7, 10, 0, 0, 20291, 20292, 7, 14, 0, 0, 20292, 20293, 7, 10, 0, 0, 20293, 20294, 7, 23, 0, 0, 20294, 20295, 7, 6, 0, 0, 20295, 20296, 5, 95, 0, 0, 20296, 20297, 7, 11, 0, 0, 20297, 20298, 7, 6, 0, 0, 20298, 20299, 7, 13, 0, 0, 20299, 20300, 7, 6, 0, 0, 20300, 20301, 7, 11, 0, 0, 20301, 2814, 1, 0, 0, 0, 20302, 20303, 7, 15, 0, 0, 20303, 20304, 7, 11, 0, 0, 20304, 20305, 7, 5, 0, 0, 20305, 20306, 7, 24, 0, 0, 20306, 20307, 7, 11, 0, 0, 20307, 20308, 5, 95, 0, 0, 20308, 20309, 7, 22, 0, 0, 20309, 20310, 7, 0, 0, 0, 20310, 20311, 7, 3, 0, 0, 20311, 20312, 7, 7, 0, 0, 20312, 20313, 7, 10, 0, 0, 20313, 20314, 7, 7, 0, 0, 20314, 20315, 7, 17, 0, 0, 20315, 20316, 7, 5, 0, 0, 20316, 2816, 1, 0, 0, 0, 20317, 20318, 7, 15, 0, 0, 20318, 20319, 7, 11, 0, 0, 20319, 20320, 7, 12, 0, 0, 20320, 20321, 7, 17, 0, 0, 20321, 20322, 7, 17, 0, 0, 20322, 20323, 7, 0, 0, 0, 20323, 20324, 7, 1, 0, 0, 20324, 20325, 7, 11, 0, 0, 20325, 20326, 7, 6, 0, 0, 20326, 2818, 1, 0, 0, 0, 20327, 20328, 7, 15, 0, 0, 20328, 20329, 7, 14, 0, 0, 20329, 20330, 7, 6, 0, 0, 20330, 20331, 7, 14, 0, 0, 20331, 2820, 1, 0, 0, 0, 20332, 20333, 7, 15, 0, 0, 20333, 20334, 7, 2, 0, 0, 20334, 20335, 7, 10, 0, 0, 20335, 20336, 7, 7, 0, 0, 20336, 20337, 7, 4, 0, 0, 20337, 2822, 1, 0, 0, 0, 20338, 20339, 7, 15, 0, 0, 20339, 20340, 7, 2, 0, 0, 20340, 20341, 7, 11, 0, 0, 20341, 20342, 7, 10, 0, 0, 20342, 20343, 7, 8, 0, 0, 20343, 20344, 7, 18, 0, 0, 20344, 2824, 1, 0, 0, 0, 20345, 20346, 7, 15, 0, 0, 20346, 20347, 7, 2, 0, 0, 20347, 20348, 7, 2, 0, 0, 20348, 20349, 7, 11, 0, 0, 20349, 20350, 5, 95, 0, 0, 20350, 20351, 5, 49, 0, 0, 20351, 20352, 5, 54, 0, 0, 20352, 20353, 7, 21, 0, 0, 20353, 2826, 1, 0, 0, 0, 20354, 20355, 7, 15, 0, 0, 20355, 20356, 7, 2, 0, 0, 20356, 20357, 7, 2, 0, 0, 20357, 20358, 7, 11, 0, 0, 20358, 20359, 5, 95, 0, 0, 20359, 20360, 5, 50, 0, 0, 20360, 20361, 7, 21, 0, 0, 20361, 2828, 1, 0, 0, 0, 20362, 20363, 7, 15, 0, 0, 20363, 20364, 7, 2, 0, 0, 20364, 20365, 7, 2, 0, 0, 20365, 20366, 7, 11, 0, 0, 20366, 20367, 5, 95, 0, 0, 20367, 20368, 5, 51, 0, 0, 20368, 20369, 5, 50, 0, 0, 20369, 20370, 7, 21, 0, 0, 20370, 2830, 1, 0, 0, 0, 20371, 20372, 7, 15, 0, 0, 20372, 20373, 7, 2, 0, 0, 20373, 20374, 7, 2, 0, 0, 20374, 20375, 7, 11, 0, 0, 20375, 20376, 5, 95, 0, 0, 20376, 20377, 5, 52, 0, 0, 20377, 20378, 7, 21, 0, 0, 20378, 2832, 1, 0, 0, 0, 20379, 20380, 7, 15, 0, 0, 20380, 20381, 7, 2, 0, 0, 20381, 20382, 7, 2, 0, 0, 20382, 20383, 7, 11, 0, 0, 20383, 20384, 5, 95, 0, 0, 20384, 20385, 5, 56, 0, 0, 20385, 20386, 7, 21, 0, 0, 20386, 2834, 1, 0, 0, 0, 20387, 20388, 7, 15, 0, 0, 20388, 20389, 7, 2, 0, 0, 20389, 20390, 7, 5, 0, 0, 20390, 20391, 7, 10, 0, 0, 20391, 20392, 7, 4, 0, 0, 20392, 20393, 7, 10, 0, 0, 20393, 20394, 7, 2, 0, 0, 20394, 20395, 7, 7, 0, 0, 20395, 2836, 1, 0, 0, 0, 20396, 20397, 7, 15, 0, 0, 20397, 20398, 7, 2, 0, 0, 20398, 20399, 7, 5, 0, 0, 20399, 20400, 7, 10, 0, 0, 20400, 20401, 7, 4, 0, 0, 20401, 20402, 7, 10, 0, 0, 20402, 20403, 7, 13, 0, 0, 20403, 20404, 7, 6, 0, 0, 20404, 20405, 7, 7, 0, 0, 20405, 2838, 1, 0, 0, 0, 20406, 20407, 7, 15, 0, 0, 20407, 20408, 7, 2, 0, 0, 20408, 20409, 7, 5, 0, 0, 20409, 20410, 7, 10, 0, 0, 20410, 20411, 7, 4, 0, 0, 20411, 20412, 7, 10, 0, 0, 20412, 20413, 7, 13, 0, 0, 20413, 20414, 7, 6, 0, 0, 20414, 2840, 1, 0, 0, 0, 20415, 20416, 7, 15, 0, 0, 20416, 20417, 7, 2, 0, 0, 20417, 20418, 7, 5, 0, 0, 20418, 20419, 7, 4, 0, 0, 20419, 20420, 5, 95, 0, 0, 20420, 20421, 7, 4, 0, 0, 20421, 20422, 7, 3, 0, 0, 20422, 20423, 7, 0, 0, 0, 20423, 20424, 7, 7, 0, 0, 20424, 20425, 7, 5, 0, 0, 20425, 20426, 7, 0, 0, 0, 20426, 20427, 7, 8, 0, 0, 20427, 20428, 7, 4, 0, 0, 20428, 20429, 7, 10, 0, 0, 20429, 20430, 7, 2, 0, 0, 20430, 20431, 7, 7, 0, 0, 20431, 2842, 1, 0, 0, 0, 20432, 20433, 7, 15, 0, 0, 20433, 20434, 7, 2, 0, 0, 20434, 20435, 7, 22, 0, 0, 20435, 20436, 7, 6, 0, 0, 20436, 20437, 7, 3, 0, 0, 20437, 20438, 7, 14, 0, 0, 20438, 20439, 7, 12, 0, 0, 20439, 20440, 7, 11, 0, 0, 20440, 20441, 7, 4, 0, 0, 20441, 20442, 7, 10, 0, 0, 20442, 20443, 7, 5, 0, 0, 20443, 20444, 7, 6, 0, 0, 20444, 20445, 7, 4, 0, 0, 20445, 20446, 5, 95, 0, 0, 20446, 20447, 7, 1, 0, 0, 20447, 20448, 7, 18, 0, 0, 20448, 20449, 5, 95, 0, 0, 20449, 20450, 7, 8, 0, 0, 20450, 20451, 7, 0, 0, 0, 20451, 20452, 7, 3, 0, 0, 20452, 20453, 7, 9, 0, 0, 20453, 20454, 7, 10, 0, 0, 20454, 20455, 7, 7, 0, 0, 20455, 20456, 7, 0, 0, 0, 20456, 20457, 7, 11, 0, 0, 20457, 20458, 7, 10, 0, 0, 20458, 20459, 7, 4, 0, 0, 20459, 20460, 7, 18, 0, 0, 20460, 2844, 1, 0, 0, 0, 20461, 20462, 7, 15, 0, 0, 20462, 20463, 7, 2, 0, 0, 20463, 20464, 7, 22, 0, 0, 20464, 20465, 7, 6, 0, 0, 20465, 20466, 7, 3, 0, 0, 20466, 20467, 7, 14, 0, 0, 20467, 20468, 7, 12, 0, 0, 20468, 20469, 7, 11, 0, 0, 20469, 20470, 7, 4, 0, 0, 20470, 20471, 7, 10, 0, 0, 20471, 20472, 7, 5, 0, 0, 20472, 20473, 7, 6, 0, 0, 20473, 20474, 7, 4, 0, 0, 20474, 2846, 1, 0, 0, 0, 20475, 20476, 7, 15, 0, 0, 20476, 20477, 7, 2, 0, 0, 20477, 20478, 7, 22, 0, 0, 20478, 20479, 7, 6, 0, 0, 20479, 20480, 7, 3, 0, 0, 20480, 2848, 1, 0, 0, 0, 20481, 20482, 7, 15, 0, 0, 20482, 20483, 7, 24, 0, 0, 20483, 20484, 5, 95, 0, 0, 20484, 20485, 7, 8, 0, 0, 20485, 20486, 7, 2, 0, 0, 20486, 20487, 7, 7, 0, 0, 20487, 20488, 7, 8, 0, 0, 20488, 20489, 7, 12, 0, 0, 20489, 20490, 7, 3, 0, 0, 20490, 20491, 7, 3, 0, 0, 20491, 20492, 7, 6, 0, 0, 20492, 20493, 7, 7, 0, 0, 20493, 20494, 7, 4, 0, 0, 20494, 20495, 5, 95, 0, 0, 20495, 20496, 7, 12, 0, 0, 20496, 20497, 7, 7, 0, 0, 20497, 20498, 7, 10, 0, 0, 20498, 20499, 7, 2, 0, 0, 20499, 20500, 7, 7, 0, 0, 20500, 2850, 1, 0, 0, 0, 20501, 20502, 7, 15, 0, 0, 20502, 20503, 7, 24, 0, 0, 20503, 20504, 5, 95, 0, 0, 20504, 20505, 7, 9, 0, 0, 20505, 20506, 7, 10, 0, 0, 20506, 20507, 7, 5, 0, 0, 20507, 20508, 7, 4, 0, 0, 20508, 20509, 7, 3, 0, 0, 20509, 20510, 7, 10, 0, 0, 20510, 20511, 7, 1, 0, 0, 20511, 20512, 7, 12, 0, 0, 20512, 20513, 7, 4, 0, 0, 20513, 20514, 7, 6, 0, 0, 20514, 2852, 1, 0, 0, 0, 20515, 20516, 7, 15, 0, 0, 20516, 20517, 7, 24, 0, 0, 20517, 20518, 5, 95, 0, 0, 20518, 20519, 7, 9, 0, 0, 20519, 20520, 7, 10, 0, 0, 20520, 20521, 7, 5, 0, 0, 20521, 20522, 7, 4, 0, 0, 20522, 20523, 7, 3, 0, 0, 20523, 20524, 7, 10, 0, 0, 20524, 20525, 7, 1, 0, 0, 20525, 20526, 7, 12, 0, 0, 20526, 20527, 7, 4, 0, 0, 20527, 20528, 7, 6, 0, 0, 20528, 20529, 5, 95, 0, 0, 20529, 20530, 7, 22, 0, 0, 20530, 20531, 7, 10, 0, 0, 20531, 20532, 7, 7, 0, 0, 20532, 20533, 7, 9, 0, 0, 20533, 20534, 7, 2, 0, 0, 20534, 20535, 7, 22, 0, 0, 20535, 2854, 1, 0, 0, 0, 20536, 20537, 7, 15, 0, 0, 20537, 20538, 7, 24, 0, 0, 20538, 20539, 5, 95, 0, 0, 20539, 20540, 7, 16, 0, 0, 20540, 20541, 7, 10, 0, 0, 20541, 20542, 7, 11, 0, 0, 20542, 20543, 7, 4, 0, 0, 20543, 20544, 7, 6, 0, 0, 20544, 20545, 7, 3, 0, 0, 20545, 2856, 1, 0, 0, 0, 20546, 20547, 7, 15, 0, 0, 20547, 20548, 7, 24, 0, 0, 20548, 20549, 5, 95, 0, 0, 20549, 20550, 7, 14, 0, 0, 20550, 20551, 7, 0, 0, 0, 20551, 20552, 7, 15, 0, 0, 20552, 2858, 1, 0, 0, 0, 20553, 20554, 7, 15, 0, 0, 20554, 20555, 7, 24, 0, 0, 20555, 20556, 5, 95, 0, 0, 20556, 20557, 7, 7, 0, 0, 20557, 20558, 7, 2, 0, 0, 20558, 20559, 7, 14, 0, 0, 20559, 20560, 7, 0, 0, 0, 20560, 20561, 7, 15, 0, 0, 20561, 2860, 1, 0, 0, 0, 20562, 20563, 7, 15, 0, 0, 20563, 20564, 7, 24, 0, 0, 20564, 20565, 5, 95, 0, 0, 20565, 20566, 7, 3, 0, 0, 20566, 20567, 7, 6, 0, 0, 20567, 20568, 7, 15, 0, 0, 20568, 20569, 7, 11, 0, 0, 20569, 20570, 7, 10, 0, 0, 20570, 20571, 7, 8, 0, 0, 20571, 20572, 7, 0, 0, 0, 20572, 20573, 7, 4, 0, 0, 20573, 20574, 7, 6, 0, 0, 20574, 2862, 1, 0, 0, 0, 20575, 20576, 7, 15, 0, 0, 20576, 20577, 7, 24, 0, 0, 20577, 20578, 5, 95, 0, 0, 20578, 20579, 7, 5, 0, 0, 20579, 20580, 7, 21, 0, 0, 20580, 20581, 7, 6, 0, 0, 20581, 20582, 7, 22, 0, 0, 20582, 2864, 1, 0, 0, 0, 20583, 20584, 7, 15, 0, 0, 20584, 20585, 7, 3, 0, 0, 20585, 20586, 7, 0, 0, 0, 20586, 20587, 7, 17, 0, 0, 20587, 20588, 7, 14, 0, 0, 20588, 20589, 7, 0, 0, 0, 20589, 2866, 1, 0, 0, 0, 20590, 20591, 7, 15, 0, 0, 20591, 20592, 7, 3, 0, 0, 20592, 20593, 7, 6, 0, 0, 20593, 20594, 7, 1, 0, 0, 20594, 20595, 7, 12, 0, 0, 20595, 20596, 7, 10, 0, 0, 20596, 20597, 7, 11, 0, 0, 20597, 20598, 7, 4, 0, 0, 20598, 2868, 1, 0, 0, 0, 20599, 20600, 7, 15, 0, 0, 20600, 20601, 7, 3, 0, 0, 20601, 20602, 7, 6, 0, 0, 20602, 20603, 7, 8, 0, 0, 20603, 20604, 7, 6, 0, 0, 20604, 20605, 7, 9, 0, 0, 20605, 20606, 7, 6, 0, 0, 20606, 20607, 7, 5, 0, 0, 20607, 2870, 1, 0, 0, 0, 20608, 20609, 7, 15, 0, 0, 20609, 20610, 7, 3, 0, 0, 20610, 20611, 7, 6, 0, 0, 20611, 20612, 7, 8, 0, 0, 20612, 20613, 7, 6, 0, 0, 20613, 20614, 7, 9, 0, 0, 20614, 20615, 7, 10, 0, 0, 20615, 20616, 7, 7, 0, 0, 20616, 20617, 7, 17, 0, 0, 20617, 2872, 1, 0, 0, 0, 20618, 20619, 7, 15, 0, 0, 20619, 20620, 7, 3, 0, 0, 20620, 20621, 7, 6, 0, 0, 20621, 20622, 7, 8, 0, 0, 20622, 20623, 7, 10, 0, 0, 20623, 20624, 7, 5, 0, 0, 20624, 20625, 7, 10, 0, 0, 20625, 20626, 7, 2, 0, 0, 20626, 20627, 7, 7, 0, 0, 20627, 2874, 1, 0, 0, 0, 20628, 20629, 7, 15, 0, 0, 20629, 20630, 7, 3, 0, 0, 20630, 20631, 7, 6, 0, 0, 20631, 20632, 7, 8, 0, 0, 20632, 20633, 7, 2, 0, 0, 20633, 20634, 7, 14, 0, 0, 20634, 20635, 7, 15, 0, 0, 20635, 20636, 7, 12, 0, 0, 20636, 20637, 7, 4, 0, 0, 20637, 20638, 7, 6, 0, 0, 20638, 20639, 5, 95, 0, 0, 20639, 20640, 7, 5, 0, 0, 20640, 20641, 7, 12, 0, 0, 20641, 20642, 7, 1, 0, 0, 20642, 20643, 7, 24, 0, 0, 20643, 20644, 7, 12, 0, 0, 20644, 20645, 7, 6, 0, 0, 20645, 20646, 7, 3, 0, 0, 20646, 20647, 7, 18, 0, 0, 20647, 2876, 1, 0, 0, 0, 20648, 20649, 7, 15, 0, 0, 20649, 20650, 7, 3, 0, 0, 20650, 20651, 7, 6, 0, 0, 20651, 20652, 7, 9, 0, 0, 20652, 20653, 7, 10, 0, 0, 20653, 20654, 7, 8, 0, 0, 20654, 20655, 7, 0, 0, 0, 20655, 20656, 7, 4, 0, 0, 20656, 20657, 7, 6, 0, 0, 20657, 20658, 5, 95, 0, 0, 20658, 20659, 7, 3, 0, 0, 20659, 20660, 7, 6, 0, 0, 20660, 20661, 7, 2, 0, 0, 20661, 20662, 7, 3, 0, 0, 20662, 20663, 7, 9, 0, 0, 20663, 20664, 7, 6, 0, 0, 20664, 20665, 7, 3, 0, 0, 20665, 20666, 7, 5, 0, 0, 20666, 2878, 1, 0, 0, 0, 20667, 20668, 7, 15, 0, 0, 20668, 20669, 7, 3, 0, 0, 20669, 20670, 7, 6, 0, 0, 20670, 20671, 7, 11, 0, 0, 20671, 20672, 7, 2, 0, 0, 20672, 20673, 7, 0, 0, 0, 20673, 20674, 7, 9, 0, 0, 20674, 2880, 1, 0, 0, 0, 20675, 20676, 7, 15, 0, 0, 20676, 20677, 7, 3, 0, 0, 20677, 20678, 7, 6, 0, 0, 20678, 20679, 7, 15, 0, 0, 20679, 20680, 7, 0, 0, 0, 20680, 20681, 7, 3, 0, 0, 20681, 20682, 7, 6, 0, 0, 20682, 2882, 1, 0, 0, 0, 20683, 20684, 7, 15, 0, 0, 20684, 20685, 7, 3, 0, 0, 20685, 20686, 7, 6, 0, 0, 20686, 20687, 7, 15, 0, 0, 20687, 20688, 7, 3, 0, 0, 20688, 20689, 7, 2, 0, 0, 20689, 20690, 7, 8, 0, 0, 20690, 20691, 7, 6, 0, 0, 20691, 20692, 7, 5, 0, 0, 20692, 20693, 7, 5, 0, 0, 20693, 20694, 7, 2, 0, 0, 20694, 20695, 7, 3, 0, 0, 20695, 2884, 1, 0, 0, 0, 20696, 20697, 7, 15, 0, 0, 20697, 20698, 7, 3, 0, 0, 20698, 20699, 7, 6, 0, 0, 20699, 20700, 7, 5, 0, 0, 20700, 20701, 7, 6, 0, 0, 20701, 20702, 7, 7, 0, 0, 20702, 20703, 7, 4, 0, 0, 20703, 20704, 7, 7, 0, 0, 20704, 20705, 7, 7, 0, 0, 20705, 20706, 7, 13, 0, 0, 20706, 2886, 1, 0, 0, 0, 20707, 20708, 7, 15, 0, 0, 20708, 20709, 7, 3, 0, 0, 20709, 20710, 7, 6, 0, 0, 20710, 20711, 7, 5, 0, 0, 20711, 20712, 7, 6, 0, 0, 20712, 20713, 7, 7, 0, 0, 20713, 20714, 7, 4, 0, 0, 20714, 2888, 1, 0, 0, 0, 20715, 20716, 7, 15, 0, 0, 20716, 20717, 7, 3, 0, 0, 20717, 20718, 7, 6, 0, 0, 20718, 20719, 7, 5, 0, 0, 20719, 20720, 7, 6, 0, 0, 20720, 20721, 7, 7, 0, 0, 20721, 20722, 7, 4, 0, 0, 20722, 20723, 7, 13, 0, 0, 20723, 2890, 1, 0, 0, 0, 20724, 20725, 7, 15, 0, 0, 20725, 20726, 7, 3, 0, 0, 20726, 20727, 7, 6, 0, 0, 20727, 20728, 7, 5, 0, 0, 20728, 20729, 7, 6, 0, 0, 20729, 20730, 7, 3, 0, 0, 20730, 20731, 7, 13, 0, 0, 20731, 20732, 7, 6, 0, 0, 20732, 20733, 5, 95, 0, 0, 20733, 20734, 7, 2, 0, 0, 20734, 20735, 7, 10, 0, 0, 20735, 20736, 7, 9, 0, 0, 20736, 2892, 1, 0, 0, 0, 20737, 20738, 7, 15, 0, 0, 20738, 20739, 7, 3, 0, 0, 20739, 20740, 7, 6, 0, 0, 20740, 20741, 7, 5, 0, 0, 20741, 20742, 7, 6, 0, 0, 20742, 20743, 7, 3, 0, 0, 20743, 20744, 7, 13, 0, 0, 20744, 20745, 7, 6, 0, 0, 20745, 2894, 1, 0, 0, 0, 20746, 20747, 7, 15, 0, 0, 20747, 20748, 7, 3, 0, 0, 20748, 20749, 7, 6, 0, 0, 20749, 20750, 7, 4, 0, 0, 20750, 20751, 7, 4, 0, 0, 20751, 20752, 7, 18, 0, 0, 20752, 2896, 1, 0, 0, 0, 20753, 20754, 7, 15, 0, 0, 20754, 20755, 7, 3, 0, 0, 20755, 20756, 7, 6, 0, 0, 20756, 20757, 7, 13, 0, 0, 20757, 20758, 7, 10, 0, 0, 20758, 20759, 7, 2, 0, 0, 20759, 20760, 7, 12, 0, 0, 20760, 20761, 7, 5, 0, 0, 20761, 2898, 1, 0, 0, 0, 20762, 20763, 7, 15, 0, 0, 20763, 20764, 7, 3, 0, 0, 20764, 20765, 7, 6, 0, 0, 20765, 20766, 7, 13, 0, 0, 20766, 2900, 1, 0, 0, 0, 20767, 20768, 7, 15, 0, 0, 20768, 20769, 7, 3, 0, 0, 20769, 20770, 7, 10, 0, 0, 20770, 20771, 7, 14, 0, 0, 20771, 20772, 7, 0, 0, 0, 20772, 20773, 7, 3, 0, 0, 20773, 20774, 7, 18, 0, 0, 20774, 2902, 1, 0, 0, 0, 20775, 20776, 7, 15, 0, 0, 20776, 20777, 7, 3, 0, 0, 20777, 20778, 7, 10, 0, 0, 20778, 20779, 7, 7, 0, 0, 20779, 20780, 7, 4, 0, 0, 20780, 20781, 7, 1, 0, 0, 20781, 20782, 7, 11, 0, 0, 20782, 20783, 7, 2, 0, 0, 20783, 20784, 7, 1, 0, 0, 20784, 20785, 7, 4, 0, 0, 20785, 20786, 7, 2, 0, 0, 20786, 20787, 7, 8, 0, 0, 20787, 20788, 7, 11, 0, 0, 20788, 20789, 7, 2, 0, 0, 20789, 20790, 7, 1, 0, 0, 20790, 2904, 1, 0, 0, 0, 20791, 20792, 7, 15, 0, 0, 20792, 20793, 7, 3, 0, 0, 20793, 20794, 7, 10, 0, 0, 20794, 20795, 7, 2, 0, 0, 20795, 20796, 7, 3, 0, 0, 20796, 20797, 7, 10, 0, 0, 20797, 20798, 7, 4, 0, 0, 20798, 20799, 7, 18, 0, 0, 20799, 2906, 1, 0, 0, 0, 20800, 20801, 7, 15, 0, 0, 20801, 20802, 7, 3, 0, 0, 20802, 20803, 7, 10, 0, 0, 20803, 20804, 7, 2, 0, 0, 20804, 20805, 7, 3, 0, 0, 20805, 2908, 1, 0, 0, 0, 20806, 20807, 7, 15, 0, 0, 20807, 20808, 7, 3, 0, 0, 20808, 20809, 7, 10, 0, 0, 20809, 20810, 7, 13, 0, 0, 20810, 20811, 7, 0, 0, 0, 20811, 20812, 7, 4, 0, 0, 20812, 20813, 7, 6, 0, 0, 20813, 2910, 1, 0, 0, 0, 20814, 20815, 7, 15, 0, 0, 20815, 20816, 7, 3, 0, 0, 20816, 20817, 7, 10, 0, 0, 20817, 20818, 7, 13, 0, 0, 20818, 20819, 7, 0, 0, 0, 20819, 20820, 7, 4, 0, 0, 20820, 20821, 7, 6, 0, 0, 20821, 20822, 5, 95, 0, 0, 20822, 20823, 7, 5, 0, 0, 20823, 20824, 7, 17, 0, 0, 20824, 20825, 7, 0, 0, 0, 20825, 2912, 1, 0, 0, 0, 20826, 20827, 7, 15, 0, 0, 20827, 20828, 7, 3, 0, 0, 20828, 20829, 7, 10, 0, 0, 20829, 20830, 7, 13, 0, 0, 20830, 20831, 7, 10, 0, 0, 20831, 20832, 7, 11, 0, 0, 20832, 20833, 7, 6, 0, 0, 20833, 20834, 7, 17, 0, 0, 20834, 20835, 7, 6, 0, 0, 20835, 20836, 7, 9, 0, 0, 20836, 2914, 1, 0, 0, 0, 20837, 20838, 7, 15, 0, 0, 20838, 20839, 7, 3, 0, 0, 20839, 20840, 7, 10, 0, 0, 20840, 20841, 7, 13, 0, 0, 20841, 20842, 7, 10, 0, 0, 20842, 20843, 7, 11, 0, 0, 20843, 20844, 7, 6, 0, 0, 20844, 20845, 7, 17, 0, 0, 20845, 20846, 7, 6, 0, 0, 20846, 2916, 1, 0, 0, 0, 20847, 20848, 7, 15, 0, 0, 20848, 20849, 7, 3, 0, 0, 20849, 20850, 7, 10, 0, 0, 20850, 20851, 7, 13, 0, 0, 20851, 20852, 7, 10, 0, 0, 20852, 20853, 7, 11, 0, 0, 20853, 20854, 7, 6, 0, 0, 20854, 20855, 7, 17, 0, 0, 20855, 20856, 7, 6, 0, 0, 20856, 20857, 7, 5, 0, 0, 20857, 2918, 1, 0, 0, 0, 20858, 20859, 7, 15, 0, 0, 20859, 20860, 7, 3, 0, 0, 20860, 20861, 7, 2, 0, 0, 20861, 20862, 7, 8, 0, 0, 20862, 20863, 7, 6, 0, 0, 20863, 20864, 7, 9, 0, 0, 20864, 20865, 7, 12, 0, 0, 20865, 20866, 7, 3, 0, 0, 20866, 20867, 7, 0, 0, 0, 20867, 20868, 7, 11, 0, 0, 20868, 2920, 1, 0, 0, 0, 20869, 20870, 7, 15, 0, 0, 20870, 20871, 7, 3, 0, 0, 20871, 20872, 7, 2, 0, 0, 20872, 20873, 7, 8, 0, 0, 20873, 20874, 7, 6, 0, 0, 20874, 20875, 7, 9, 0, 0, 20875, 20876, 7, 12, 0, 0, 20876, 20877, 7, 3, 0, 0, 20877, 20878, 7, 6, 0, 0, 20878, 2922, 1, 0, 0, 0, 20879, 20880, 7, 15, 0, 0, 20880, 20881, 7, 3, 0, 0, 20881, 20882, 7, 2, 0, 0, 20882, 20883, 7, 8, 0, 0, 20883, 20884, 7, 6, 0, 0, 20884, 20885, 7, 5, 0, 0, 20885, 20886, 7, 5, 0, 0, 20886, 2924, 1, 0, 0, 0, 20887, 20888, 7, 15, 0, 0, 20888, 20889, 7, 3, 0, 0, 20889, 20890, 7, 2, 0, 0, 20890, 20891, 7, 16, 0, 0, 20891, 20892, 7, 10, 0, 0, 20892, 20893, 7, 11, 0, 0, 20893, 20894, 7, 6, 0, 0, 20894, 2926, 1, 0, 0, 0, 20895, 20896, 7, 15, 0, 0, 20896, 20897, 7, 3, 0, 0, 20897, 20898, 7, 2, 0, 0, 20898, 20899, 7, 17, 0, 0, 20899, 20900, 7, 3, 0, 0, 20900, 20901, 7, 0, 0, 0, 20901, 20902, 7, 14, 0, 0, 20902, 2928, 1, 0, 0, 0, 20903, 20904, 7, 15, 0, 0, 20904, 20905, 7, 3, 0, 0, 20905, 20906, 7, 2, 0, 0, 20906, 20907, 7, 20, 0, 0, 20907, 20908, 7, 6, 0, 0, 20908, 20909, 7, 8, 0, 0, 20909, 20910, 7, 4, 0, 0, 20910, 2930, 1, 0, 0, 0, 20911, 20912, 7, 15, 0, 0, 20912, 20913, 7, 3, 0, 0, 20913, 20914, 7, 2, 0, 0, 20914, 20915, 7, 15, 0, 0, 20915, 20916, 7, 0, 0, 0, 20916, 20917, 7, 17, 0, 0, 20917, 20918, 7, 0, 0, 0, 20918, 20919, 7, 4, 0, 0, 20919, 20920, 7, 6, 0, 0, 20920, 2932, 1, 0, 0, 0, 20921, 20922, 7, 15, 0, 0, 20922, 20923, 7, 3, 0, 0, 20923, 20924, 7, 2, 0, 0, 20924, 20925, 7, 15, 0, 0, 20925, 20926, 7, 6, 0, 0, 20926, 20927, 7, 3, 0, 0, 20927, 20928, 7, 4, 0, 0, 20928, 20929, 7, 18, 0, 0, 20929, 2934, 1, 0, 0, 0, 20930, 20931, 7, 15, 0, 0, 20931, 20932, 7, 3, 0, 0, 20932, 20933, 7, 2, 0, 0, 20933, 20934, 7, 4, 0, 0, 20934, 20935, 7, 6, 0, 0, 20935, 20936, 7, 8, 0, 0, 20936, 20937, 7, 4, 0, 0, 20937, 20938, 7, 6, 0, 0, 20938, 20939, 7, 9, 0, 0, 20939, 2936, 1, 0, 0, 0, 20940, 20941, 7, 15, 0, 0, 20941, 20942, 7, 3, 0, 0, 20942, 20943, 7, 2, 0, 0, 20943, 20944, 7, 4, 0, 0, 20944, 20945, 7, 6, 0, 0, 20945, 20946, 7, 8, 0, 0, 20946, 20947, 7, 4, 0, 0, 20947, 20948, 7, 10, 0, 0, 20948, 20949, 7, 2, 0, 0, 20949, 20950, 7, 7, 0, 0, 20950, 2938, 1, 0, 0, 0, 20951, 20952, 7, 15, 0, 0, 20952, 20953, 7, 3, 0, 0, 20953, 20954, 7, 2, 0, 0, 20954, 20955, 7, 4, 0, 0, 20955, 20956, 7, 2, 0, 0, 20956, 20957, 7, 8, 0, 0, 20957, 20958, 7, 2, 0, 0, 20958, 20959, 7, 11, 0, 0, 20959, 2940, 1, 0, 0, 0, 20960, 20961, 7, 15, 0, 0, 20961, 20962, 7, 3, 0, 0, 20962, 20963, 7, 2, 0, 0, 20963, 20964, 7, 25, 0, 0, 20964, 20965, 7, 18, 0, 0, 20965, 2942, 1, 0, 0, 0, 20966, 20967, 7, 15, 0, 0, 20967, 20968, 7, 3, 0, 0, 20968, 20969, 7, 12, 0, 0, 20969, 20970, 7, 7, 0, 0, 20970, 20971, 7, 10, 0, 0, 20971, 20972, 7, 7, 0, 0, 20972, 20973, 7, 17, 0, 0, 20973, 2944, 1, 0, 0, 0, 20974, 20975, 7, 15, 0, 0, 20975, 20976, 7, 12, 0, 0, 20976, 20977, 7, 1, 0, 0, 20977, 20978, 7, 11, 0, 0, 20978, 20979, 7, 10, 0, 0, 20979, 20980, 7, 8, 0, 0, 20980, 2946, 1, 0, 0, 0, 20981, 20982, 7, 15, 0, 0, 20982, 20983, 7, 12, 0, 0, 20983, 20984, 7, 11, 0, 0, 20984, 20985, 7, 11, 0, 0, 20985, 20986, 5, 95, 0, 0, 20986, 20987, 7, 15, 0, 0, 20987, 20988, 7, 3, 0, 0, 20988, 20989, 7, 6, 0, 0, 20989, 20990, 7, 9, 0, 0, 20990, 2948, 1, 0, 0, 0, 20991, 20992, 7, 15, 0, 0, 20992, 20993, 7, 12, 0, 0, 20993, 20994, 7, 3, 0, 0, 20994, 20995, 7, 17, 0, 0, 20995, 20996, 7, 6, 0, 0, 20996, 2950, 1, 0, 0, 0, 20997, 20998, 7, 15, 0, 0, 20998, 20999, 7, 12, 0, 0, 20999, 21000, 7, 5, 0, 0, 21000, 21001, 7, 19, 0, 0, 21001, 21002, 5, 95, 0, 0, 21002, 21003, 7, 15, 0, 0, 21003, 21004, 7, 3, 0, 0, 21004, 21005, 7, 6, 0, 0, 21005, 21006, 7, 9, 0, 0, 21006, 2952, 1, 0, 0, 0, 21007, 21008, 7, 15, 0, 0, 21008, 21009, 7, 12, 0, 0, 21009, 21010, 7, 5, 0, 0, 21010, 21011, 7, 19, 0, 0, 21011, 21012, 5, 95, 0, 0, 21012, 21013, 7, 5, 0, 0, 21013, 21014, 7, 12, 0, 0, 21014, 21015, 7, 1, 0, 0, 21015, 21016, 7, 24, 0, 0, 21016, 2954, 1, 0, 0, 0, 21017, 21018, 7, 15, 0, 0, 21018, 21019, 7, 25, 0, 0, 21019, 21020, 5, 95, 0, 0, 21020, 21021, 7, 16, 0, 0, 21021, 21022, 7, 0, 0, 0, 21022, 21023, 7, 12, 0, 0, 21023, 21024, 7, 11, 0, 0, 21024, 21025, 7, 4, 0, 0, 21025, 21026, 5, 95, 0, 0, 21026, 21027, 7, 4, 0, 0, 21027, 21028, 7, 2, 0, 0, 21028, 21029, 7, 11, 0, 0, 21029, 21030, 7, 6, 0, 0, 21030, 21031, 7, 3, 0, 0, 21031, 21032, 7, 0, 0, 0, 21032, 21033, 7, 7, 0, 0, 21033, 21034, 7, 8, 0, 0, 21034, 21035, 7, 6, 0, 0, 21035, 2956, 1, 0, 0, 0, 21036, 21037, 7, 15, 0, 0, 21037, 21038, 7, 25, 0, 0, 21038, 21039, 5, 95, 0, 0, 21039, 21040, 7, 17, 0, 0, 21040, 21041, 7, 3, 0, 0, 21041, 21042, 7, 0, 0, 0, 21042, 21043, 7, 7, 0, 0, 21043, 21044, 7, 12, 0, 0, 21044, 21045, 7, 11, 0, 0, 21045, 21046, 7, 6, 0, 0, 21046, 2958, 1, 0, 0, 0, 21047, 21048, 7, 15, 0, 0, 21048, 21049, 7, 25, 0, 0, 21049, 21050, 5, 95, 0, 0, 21050, 21051, 7, 20, 0, 0, 21051, 21052, 7, 2, 0, 0, 21052, 21053, 7, 10, 0, 0, 21053, 21054, 7, 7, 0, 0, 21054, 21055, 5, 95, 0, 0, 21055, 21056, 7, 16, 0, 0, 21056, 21057, 7, 10, 0, 0, 21057, 21058, 7, 11, 0, 0, 21058, 21059, 7, 4, 0, 0, 21059, 21060, 7, 6, 0, 0, 21060, 21061, 7, 3, 0, 0, 21061, 2960, 1, 0, 0, 0, 21062, 21063, 7, 24, 0, 0, 21063, 21064, 7, 1, 0, 0, 21064, 21065, 5, 95, 0, 0, 21065, 21066, 7, 7, 0, 0, 21066, 21067, 7, 0, 0, 0, 21067, 21068, 7, 14, 0, 0, 21068, 21069, 7, 6, 0, 0, 21069, 2962, 1, 0, 0, 0, 21070, 21071, 7, 24, 0, 0, 21071, 21072, 7, 12, 0, 0, 21072, 21073, 7, 0, 0, 0, 21073, 21074, 7, 3, 0, 0, 21074, 21075, 7, 4, 0, 0, 21075, 21076, 7, 6, 0, 0, 21076, 21077, 7, 3, 0, 0, 21077, 21078, 7, 5, 0, 0, 21078, 2964, 1, 0, 0, 0, 21079, 21080, 7, 24, 0, 0, 21080, 21081, 7, 12, 0, 0, 21081, 21082, 7, 6, 0, 0, 21082, 21083, 7, 3, 0, 0, 21083, 21084, 7, 18, 0, 0, 21084, 21085, 5, 95, 0, 0, 21085, 21086, 7, 1, 0, 0, 21086, 21087, 7, 11, 0, 0, 21087, 21088, 7, 2, 0, 0, 21088, 21089, 7, 8, 0, 0, 21089, 21090, 7, 21, 0, 0, 21090, 2966, 1, 0, 0, 0, 21091, 21092, 7, 24, 0, 0, 21092, 21093, 7, 12, 0, 0, 21093, 21094, 7, 6, 0, 0, 21094, 21095, 7, 3, 0, 0, 21095, 21096, 7, 18, 0, 0, 21096, 2968, 1, 0, 0, 0, 21097, 21098, 7, 24, 0, 0, 21098, 21099, 7, 12, 0, 0, 21099, 21100, 7, 6, 0, 0, 21100, 21101, 7, 12, 0, 0, 21101, 21102, 7, 6, 0, 0, 21102, 21103, 5, 95, 0, 0, 21103, 21104, 7, 8, 0, 0, 21104, 21105, 7, 12, 0, 0, 21105, 21106, 7, 3, 0, 0, 21106, 21107, 7, 3, 0, 0, 21107, 2970, 1, 0, 0, 0, 21108, 21109, 7, 24, 0, 0, 21109, 21110, 7, 12, 0, 0, 21110, 21111, 7, 6, 0, 0, 21111, 21112, 7, 12, 0, 0, 21112, 21113, 7, 6, 0, 0, 21113, 2972, 1, 0, 0, 0, 21114, 21115, 7, 24, 0, 0, 21115, 21116, 7, 12, 0, 0, 21116, 21117, 7, 6, 0, 0, 21117, 21118, 7, 12, 0, 0, 21118, 21119, 7, 6, 0, 0, 21119, 21120, 5, 95, 0, 0, 21120, 21121, 7, 3, 0, 0, 21121, 21122, 7, 2, 0, 0, 21122, 21123, 7, 22, 0, 0, 21123, 21124, 7, 15, 0, 0, 21124, 2974, 1, 0, 0, 0, 21125, 21126, 7, 24, 0, 0, 21126, 21127, 7, 12, 0, 0, 21127, 21128, 7, 10, 0, 0, 21128, 21129, 7, 6, 0, 0, 21129, 21130, 7, 5, 0, 0, 21130, 21131, 7, 8, 0, 0, 21131, 21132, 7, 6, 0, 0, 21132, 2976, 1, 0, 0, 0, 21133, 21134, 7, 24, 0, 0, 21134, 21135, 7, 12, 0, 0, 21135, 21136, 7, 2, 0, 0, 21136, 21137, 7, 3, 0, 0, 21137, 21138, 7, 12, 0, 0, 21138, 21139, 7, 14, 0, 0, 21139, 2978, 1, 0, 0, 0, 21140, 21141, 7, 24, 0, 0, 21141, 21142, 7, 12, 0, 0, 21142, 21143, 7, 2, 0, 0, 21143, 21144, 7, 4, 0, 0, 21144, 21145, 7, 0, 0, 0, 21145, 2980, 1, 0, 0, 0, 21146, 21147, 7, 24, 0, 0, 21147, 21148, 7, 12, 0, 0, 21148, 21149, 7, 2, 0, 0, 21149, 21150, 7, 4, 0, 0, 21150, 21151, 7, 0, 0, 0, 21151, 21152, 7, 17, 0, 0, 21152, 21153, 7, 3, 0, 0, 21153, 21154, 7, 2, 0, 0, 21154, 21155, 7, 12, 0, 0, 21155, 21156, 7, 15, 0, 0, 21156, 2982, 1, 0, 0, 0, 21157, 21158, 7, 3, 0, 0, 21158, 21159, 7, 0, 0, 0, 21159, 21160, 7, 10, 0, 0, 21160, 21161, 7, 5, 0, 0, 21161, 21162, 7, 6, 0, 0, 21162, 2984, 1, 0, 0, 0, 21163, 21164, 7, 3, 0, 0, 21164, 21165, 7, 0, 0, 0, 21165, 21166, 7, 7, 0, 0, 21166, 21167, 7, 9, 0, 0, 21167, 21168, 7, 2, 0, 0, 21168, 21169, 7, 14, 0, 0, 21169, 21170, 5, 95, 0, 0, 21170, 21171, 7, 11, 0, 0, 21171, 21172, 7, 2, 0, 0, 21172, 21173, 7, 8, 0, 0, 21173, 21174, 7, 0, 0, 0, 21174, 21175, 7, 11, 0, 0, 21175, 2986, 1, 0, 0, 0, 21176, 21177, 7, 3, 0, 0, 21177, 21178, 7, 0, 0, 0, 21178, 21179, 7, 7, 0, 0, 21179, 21180, 7, 9, 0, 0, 21180, 21181, 7, 2, 0, 0, 21181, 21182, 7, 14, 0, 0, 21182, 2988, 1, 0, 0, 0, 21183, 21184, 7, 3, 0, 0, 21184, 21185, 7, 0, 0, 0, 21185, 21186, 7, 7, 0, 0, 21186, 21187, 7, 17, 0, 0, 21187, 21188, 7, 6, 0, 0, 21188, 2990, 1, 0, 0, 0, 21189, 21190, 7, 3, 0, 0, 21190, 21191, 7, 0, 0, 0, 21191, 21192, 7, 7, 0, 0, 21192, 21193, 7, 21, 0, 0, 21193, 21194, 7, 14, 0, 0, 21194, 2992, 1, 0, 0, 0, 21195, 21196, 7, 3, 0, 0, 21196, 21197, 7, 0, 0, 0, 21197, 21198, 7, 15, 0, 0, 21198, 21199, 7, 10, 0, 0, 21199, 21200, 7, 9, 0, 0, 21200, 21201, 7, 11, 0, 0, 21201, 21202, 7, 18, 0, 0, 21202, 2994, 1, 0, 0, 0, 21203, 21204, 7, 3, 0, 0, 21204, 21205, 7, 0, 0, 0, 21205, 21206, 7, 22, 0, 0, 21206, 2996, 1, 0, 0, 0, 21207, 21208, 7, 3, 0, 0, 21208, 21209, 7, 0, 0, 0, 21209, 21210, 7, 22, 0, 0, 21210, 21211, 7, 4, 0, 0, 21211, 21212, 7, 2, 0, 0, 21212, 21213, 7, 19, 0, 0, 21213, 21214, 7, 6, 0, 0, 21214, 21215, 7, 25, 0, 0, 21215, 2998, 1, 0, 0, 0, 21216, 21217, 7, 3, 0, 0, 21217, 21218, 7, 0, 0, 0, 21218, 21219, 7, 22, 0, 0, 21219, 21220, 7, 4, 0, 0, 21220, 21221, 7, 2, 0, 0, 21221, 21222, 7, 7, 0, 0, 21222, 21223, 7, 19, 0, 0, 21223, 21224, 7, 6, 0, 0, 21224, 21225, 7, 25, 0, 0, 21225, 3000, 1, 0, 0, 0, 21226, 21227, 7, 3, 0, 0, 21227, 21228, 7, 1, 0, 0, 21228, 21229, 7, 0, 0, 0, 21229, 3002, 1, 0, 0, 0, 21230, 21231, 7, 3, 0, 0, 21231, 21232, 7, 1, 0, 0, 21232, 21233, 7, 2, 0, 0, 21233, 21234, 5, 95, 0, 0, 21234, 21235, 7, 2, 0, 0, 21235, 21236, 7, 12, 0, 0, 21236, 21237, 7, 4, 0, 0, 21237, 21238, 7, 11, 0, 0, 21238, 21239, 7, 10, 0, 0, 21239, 21240, 7, 7, 0, 0, 21240, 21241, 7, 6, 0, 0, 21241, 3004, 1, 0, 0, 0, 21242, 21243, 7, 3, 0, 0, 21243, 21244, 7, 8, 0, 0, 21244, 21245, 7, 16, 0, 0, 21245, 21246, 7, 10, 0, 0, 21246, 21247, 7, 11, 0, 0, 21247, 21248, 7, 6, 0, 0, 21248, 3006, 1, 0, 0, 0, 21249, 21250, 7, 3, 0, 0, 21250, 21251, 7, 9, 0, 0, 21251, 21252, 7, 1, 0, 0, 21252, 21253, 7, 0, 0, 0, 21253, 3008, 1, 0, 0, 0, 21254, 21255, 7, 3, 0, 0, 21255, 21256, 7, 6, 0, 0, 21256, 21257, 7, 0, 0, 0, 21257, 21258, 7, 9, 0, 0, 21258, 3010, 1, 0, 0, 0, 21259, 21260, 7, 3, 0, 0, 21260, 21261, 7, 6, 0, 0, 21261, 21262, 7, 0, 0, 0, 21262, 21263, 7, 9, 0, 0, 21263, 21264, 7, 5, 0, 0, 21264, 3012, 1, 0, 0, 0, 21265, 21266, 7, 3, 0, 0, 21266, 21267, 7, 6, 0, 0, 21267, 21268, 7, 0, 0, 0, 21268, 21269, 7, 9, 0, 0, 21269, 21270, 7, 5, 0, 0, 21270, 21271, 7, 10, 0, 0, 21271, 21272, 7, 23, 0, 0, 21272, 21273, 7, 6, 0, 0, 21273, 3014, 1, 0, 0, 0, 21274, 21275, 7, 3, 0, 0, 21275, 21276, 7, 6, 0, 0, 21276, 21277, 7, 0, 0, 0, 21277, 21278, 7, 11, 0, 0, 21278, 21279, 7, 14, 0, 0, 21279, 3016, 1, 0, 0, 0, 21280, 21281, 7, 3, 0, 0, 21281, 21282, 7, 6, 0, 0, 21282, 21283, 7, 0, 0, 0, 21283, 21284, 7, 11, 0, 0, 21284, 3018, 1, 0, 0, 0, 21285, 21286, 7, 3, 0, 0, 21286, 21287, 7, 6, 0, 0, 21287, 21288, 7, 1, 0, 0, 21288, 21289, 7, 0, 0, 0, 21289, 21290, 7, 11, 0, 0, 21290, 21291, 7, 0, 0, 0, 21291, 21292, 7, 7, 0, 0, 21292, 21293, 7, 8, 0, 0, 21293, 21294, 7, 6, 0, 0, 21294, 3020, 1, 0, 0, 0, 21295, 21296, 7, 3, 0, 0, 21296, 21297, 7, 6, 0, 0, 21297, 21298, 7, 1, 0, 0, 21298, 21299, 7, 12, 0, 0, 21299, 21300, 7, 10, 0, 0, 21300, 21301, 7, 11, 0, 0, 21301, 21302, 7, 9, 0, 0, 21302, 3022, 1, 0, 0, 0, 21303, 21304, 7, 3, 0, 0, 21304, 21305, 7, 6, 0, 0, 21305, 21306, 7, 8, 0, 0, 21306, 21307, 7, 2, 0, 0, 21307, 21308, 7, 3, 0, 0, 21308, 21309, 7, 9, 0, 0, 21309, 3024, 1, 0, 0, 0, 21310, 21311, 7, 3, 0, 0, 21311, 21312, 7, 6, 0, 0, 21312, 21313, 7, 8, 0, 0, 21313, 21314, 7, 2, 0, 0, 21314, 21315, 7, 3, 0, 0, 21315, 21316, 7, 9, 0, 0, 21316, 21317, 7, 5, 0, 0, 21317, 3026, 1, 0, 0, 0, 21318, 21319, 7, 3, 0, 0, 21319, 21320, 7, 6, 0, 0, 21320, 21321, 7, 8, 0, 0, 21321, 21322, 7, 2, 0, 0, 21322, 21323, 7, 3, 0, 0, 21323, 21324, 7, 9, 0, 0, 21324, 21325, 7, 5, 0, 0, 21325, 21326, 5, 95, 0, 0, 21326, 21327, 7, 15, 0, 0, 21327, 21328, 7, 6, 0, 0, 21328, 21329, 7, 3, 0, 0, 21329, 21330, 5, 95, 0, 0, 21330, 21331, 7, 1, 0, 0, 21331, 21332, 7, 11, 0, 0, 21332, 21333, 7, 2, 0, 0, 21333, 21334, 7, 8, 0, 0, 21334, 21335, 7, 21, 0, 0, 21335, 3028, 1, 0, 0, 0, 21336, 21337, 7, 3, 0, 0, 21337, 21338, 7, 6, 0, 0, 21338, 21339, 7, 8, 0, 0, 21339, 21340, 7, 2, 0, 0, 21340, 21341, 7, 13, 0, 0, 21341, 21342, 7, 6, 0, 0, 21342, 21343, 7, 3, 0, 0, 21343, 21344, 7, 0, 0, 0, 21344, 21345, 7, 1, 0, 0, 21345, 21346, 7, 11, 0, 0, 21346, 21347, 7, 6, 0, 0, 21347, 3030, 1, 0, 0, 0, 21348, 21349, 7, 3, 0, 0, 21349, 21350, 7, 6, 0, 0, 21350, 21351, 7, 8, 0, 0, 21351, 21352, 7, 2, 0, 0, 21352, 21353, 7, 13, 0, 0, 21353, 21354, 7, 6, 0, 0, 21354, 21355, 7, 3, 0, 0, 21355, 3032, 1, 0, 0, 0, 21356, 21357, 7, 3, 0, 0, 21357, 21358, 7, 6, 0, 0, 21358, 21359, 7, 8, 0, 0, 21359, 21360, 7, 2, 0, 0, 21360, 21361, 7, 13, 0, 0, 21361, 21362, 7, 6, 0, 0, 21362, 21363, 7, 3, 0, 0, 21363, 21364, 7, 18, 0, 0, 21364, 3034, 1, 0, 0, 0, 21365, 21366, 7, 3, 0, 0, 21366, 21367, 7, 6, 0, 0, 21367, 21368, 7, 8, 0, 0, 21368, 21369, 7, 18, 0, 0, 21369, 21370, 7, 8, 0, 0, 21370, 21371, 7, 11, 0, 0, 21371, 21372, 7, 6, 0, 0, 21372, 21373, 7, 1, 0, 0, 21373, 21374, 7, 10, 0, 0, 21374, 21375, 7, 7, 0, 0, 21375, 3036, 1, 0, 0, 0, 21376, 21377, 7, 3, 0, 0, 21377, 21378, 7, 6, 0, 0, 21378, 21379, 7, 8, 0, 0, 21379, 21380, 7, 18, 0, 0, 21380, 21381, 7, 8, 0, 0, 21381, 21382, 7, 11, 0, 0, 21382, 21383, 7, 6, 0, 0, 21383, 3038, 1, 0, 0, 0, 21384, 21385, 7, 3, 0, 0, 21385, 21386, 7, 6, 0, 0, 21386, 21387, 7, 9, 0, 0, 21387, 21388, 7, 0, 0, 0, 21388, 21389, 7, 8, 0, 0, 21389, 21390, 7, 4, 0, 0, 21390, 21391, 7, 10, 0, 0, 21391, 21392, 7, 2, 0, 0, 21392, 21393, 7, 7, 0, 0, 21393, 3040, 1, 0, 0, 0, 21394, 21395, 7, 3, 0, 0, 21395, 21396, 7, 6, 0, 0, 21396, 21397, 7, 9, 0, 0, 21397, 21398, 7, 6, 0, 0, 21398, 21399, 7, 16, 0, 0, 21399, 21400, 7, 10, 0, 0, 21400, 21401, 7, 7, 0, 0, 21401, 21402, 7, 6, 0, 0, 21402, 3042, 1, 0, 0, 0, 21403, 21404, 7, 3, 0, 0, 21404, 21405, 7, 6, 0, 0, 21405, 21406, 7, 9, 0, 0, 21406, 21407, 7, 2, 0, 0, 21407, 3044, 1, 0, 0, 0, 21408, 21409, 7, 3, 0, 0, 21409, 21410, 7, 6, 0, 0, 21410, 21411, 7, 9, 0, 0, 21411, 21412, 7, 12, 0, 0, 21412, 21413, 7, 8, 0, 0, 21413, 21414, 7, 6, 0, 0, 21414, 21415, 7, 9, 0, 0, 21415, 3046, 1, 0, 0, 0, 21416, 21417, 7, 3, 0, 0, 21417, 21418, 7, 6, 0, 0, 21418, 21419, 7, 9, 0, 0, 21419, 21420, 7, 12, 0, 0, 21420, 21421, 7, 7, 0, 0, 21421, 21422, 7, 9, 0, 0, 21422, 21423, 7, 0, 0, 0, 21423, 21424, 7, 7, 0, 0, 21424, 21425, 7, 8, 0, 0, 21425, 21426, 7, 18, 0, 0, 21426, 3048, 1, 0, 0, 0, 21427, 21428, 7, 3, 0, 0, 21428, 21429, 7, 6, 0, 0, 21429, 21430, 7, 16, 0, 0, 21430, 21431, 5, 95, 0, 0, 21431, 21432, 7, 8, 0, 0, 21432, 21433, 7, 0, 0, 0, 21433, 21434, 7, 5, 0, 0, 21434, 21435, 7, 8, 0, 0, 21435, 21436, 7, 0, 0, 0, 21436, 21437, 7, 9, 0, 0, 21437, 21438, 7, 6, 0, 0, 21438, 21439, 5, 95, 0, 0, 21439, 21440, 7, 8, 0, 0, 21440, 21441, 7, 12, 0, 0, 21441, 21442, 7, 3, 0, 0, 21442, 21443, 7, 5, 0, 0, 21443, 21444, 7, 2, 0, 0, 21444, 21445, 7, 3, 0, 0, 21445, 3050, 1, 0, 0, 0, 21446, 21447, 7, 3, 0, 0, 21447, 21448, 7, 6, 0, 0, 21448, 21449, 7, 16, 0, 0, 21449, 21450, 7, 6, 0, 0, 21450, 21451, 7, 3, 0, 0, 21451, 21452, 7, 6, 0, 0, 21452, 21453, 7, 7, 0, 0, 21453, 21454, 7, 8, 0, 0, 21454, 21455, 7, 6, 0, 0, 21455, 21456, 7, 9, 0, 0, 21456, 3052, 1, 0, 0, 0, 21457, 21458, 7, 3, 0, 0, 21458, 21459, 7, 6, 0, 0, 21459, 21460, 7, 16, 0, 0, 21460, 21461, 7, 6, 0, 0, 21461, 21462, 7, 3, 0, 0, 21462, 21463, 7, 6, 0, 0, 21463, 21464, 7, 7, 0, 0, 21464, 21465, 7, 8, 0, 0, 21465, 21466, 7, 6, 0, 0, 21466, 3054, 1, 0, 0, 0, 21467, 21468, 7, 3, 0, 0, 21468, 21469, 7, 6, 0, 0, 21469, 21470, 7, 16, 0, 0, 21470, 21471, 7, 6, 0, 0, 21471, 21472, 7, 3, 0, 0, 21472, 21473, 7, 6, 0, 0, 21473, 21474, 7, 7, 0, 0, 21474, 21475, 7, 8, 0, 0, 21475, 21476, 7, 6, 0, 0, 21476, 21477, 7, 5, 0, 0, 21477, 3056, 1, 0, 0, 0, 21478, 21479, 7, 3, 0, 0, 21479, 21480, 7, 6, 0, 0, 21480, 21481, 7, 16, 0, 0, 21481, 21482, 7, 6, 0, 0, 21482, 21483, 7, 3, 0, 0, 21483, 21484, 7, 6, 0, 0, 21484, 21485, 7, 7, 0, 0, 21485, 21486, 7, 8, 0, 0, 21486, 21487, 7, 10, 0, 0, 21487, 21488, 7, 7, 0, 0, 21488, 21489, 7, 17, 0, 0, 21489, 3058, 1, 0, 0, 0, 21490, 21491, 7, 3, 0, 0, 21491, 21492, 7, 6, 0, 0, 21492, 21493, 7, 16, 0, 0, 21493, 3060, 1, 0, 0, 0, 21494, 21495, 7, 3, 0, 0, 21495, 21496, 7, 6, 0, 0, 21496, 21497, 7, 16, 0, 0, 21497, 21498, 7, 3, 0, 0, 21498, 21499, 7, 6, 0, 0, 21499, 21500, 7, 5, 0, 0, 21500, 21501, 7, 19, 0, 0, 21501, 3062, 1, 0, 0, 0, 21502, 21503, 7, 3, 0, 0, 21503, 21504, 7, 6, 0, 0, 21504, 21505, 7, 16, 0, 0, 21505, 21506, 7, 4, 0, 0, 21506, 21507, 7, 2, 0, 0, 21507, 21508, 7, 19, 0, 0, 21508, 21509, 7, 6, 0, 0, 21509, 21510, 7, 25, 0, 0, 21510, 3064, 1, 0, 0, 0, 21511, 21512, 7, 3, 0, 0, 21512, 21513, 7, 6, 0, 0, 21513, 21514, 7, 17, 0, 0, 21514, 21515, 7, 6, 0, 0, 21515, 21516, 7, 25, 0, 0, 21516, 21517, 7, 15, 0, 0, 21517, 21518, 5, 95, 0, 0, 21518, 21519, 7, 8, 0, 0, 21519, 21520, 7, 2, 0, 0, 21520, 21521, 7, 12, 0, 0, 21521, 21522, 7, 7, 0, 0, 21522, 21523, 7, 4, 0, 0, 21523, 3066, 1, 0, 0, 0, 21524, 21525, 7, 3, 0, 0, 21525, 21526, 7, 6, 0, 0, 21526, 21527, 7, 17, 0, 0, 21527, 21528, 7, 6, 0, 0, 21528, 21529, 7, 25, 0, 0, 21529, 21530, 7, 15, 0, 0, 21530, 21531, 5, 95, 0, 0, 21531, 21532, 7, 10, 0, 0, 21532, 21533, 7, 7, 0, 0, 21533, 21534, 7, 5, 0, 0, 21534, 21535, 7, 4, 0, 0, 21535, 21536, 7, 3, 0, 0, 21536, 3068, 1, 0, 0, 0, 21537, 21538, 7, 3, 0, 0, 21538, 21539, 7, 6, 0, 0, 21539, 21540, 7, 17, 0, 0, 21540, 21541, 7, 6, 0, 0, 21541, 21542, 7, 25, 0, 0, 21542, 21543, 7, 15, 0, 0, 21543, 21544, 5, 95, 0, 0, 21544, 21545, 7, 11, 0, 0, 21545, 21546, 7, 10, 0, 0, 21546, 21547, 7, 21, 0, 0, 21547, 21548, 7, 6, 0, 0, 21548, 3070, 1, 0, 0, 0, 21549, 21550, 7, 3, 0, 0, 21550, 21551, 7, 6, 0, 0, 21551, 21552, 7, 17, 0, 0, 21552, 21553, 7, 6, 0, 0, 21553, 21554, 7, 25, 0, 0, 21554, 21555, 7, 15, 0, 0, 21555, 21556, 5, 95, 0, 0, 21556, 21557, 7, 3, 0, 0, 21557, 21558, 7, 6, 0, 0, 21558, 21559, 7, 15, 0, 0, 21559, 21560, 7, 11, 0, 0, 21560, 21561, 7, 0, 0, 0, 21561, 21562, 7, 8, 0, 0, 21562, 21563, 7, 6, 0, 0, 21563, 3072, 1, 0, 0, 0, 21564, 21565, 7, 3, 0, 0, 21565, 21566, 7, 6, 0, 0, 21566, 21567, 7, 17, 0, 0, 21567, 21568, 7, 6, 0, 0, 21568, 21569, 7, 25, 0, 0, 21569, 21570, 7, 15, 0, 0, 21570, 21571, 5, 95, 0, 0, 21571, 21572, 7, 5, 0, 0, 21572, 21573, 7, 12, 0, 0, 21573, 21574, 7, 1, 0, 0, 21574, 21575, 7, 5, 0, 0, 21575, 21576, 7, 4, 0, 0, 21576, 21577, 7, 3, 0, 0, 21577, 3074, 1, 0, 0, 0, 21578, 21579, 7, 3, 0, 0, 21579, 21580, 7, 6, 0, 0, 21580, 21581, 7, 17, 0, 0, 21581, 21582, 7, 10, 0, 0, 21582, 21583, 7, 5, 0, 0, 21583, 21584, 7, 4, 0, 0, 21584, 21585, 7, 6, 0, 0, 21585, 21586, 7, 3, 0, 0, 21586, 3076, 1, 0, 0, 0, 21587, 21588, 7, 3, 0, 0, 21588, 21589, 7, 6, 0, 0, 21589, 21590, 7, 17, 0, 0, 21590, 21591, 7, 3, 0, 0, 21591, 21592, 5, 95, 0, 0, 21592, 21593, 7, 0, 0, 0, 21593, 21594, 7, 13, 0, 0, 21594, 21595, 7, 17, 0, 0, 21595, 21596, 7, 25, 0, 0, 21596, 3078, 1, 0, 0, 0, 21597, 21598, 7, 3, 0, 0, 21598, 21599, 7, 6, 0, 0, 21599, 21600, 7, 17, 0, 0, 21600, 21601, 7, 3, 0, 0, 21601, 21602, 5, 95, 0, 0, 21602, 21603, 7, 0, 0, 0, 21603, 21604, 7, 13, 0, 0, 21604, 21605, 7, 17, 0, 0, 21605, 21606, 7, 18, 0, 0, 21606, 3080, 1, 0, 0, 0, 21607, 21608, 7, 3, 0, 0, 21608, 21609, 7, 6, 0, 0, 21609, 21610, 7, 17, 0, 0, 21610, 21611, 7, 3, 0, 0, 21611, 21612, 5, 95, 0, 0, 21612, 21613, 7, 8, 0, 0, 21613, 21614, 7, 2, 0, 0, 21614, 21615, 7, 12, 0, 0, 21615, 21616, 7, 7, 0, 0, 21616, 21617, 7, 4, 0, 0, 21617, 3082, 1, 0, 0, 0, 21618, 21619, 7, 3, 0, 0, 21619, 21620, 7, 6, 0, 0, 21620, 21621, 7, 17, 0, 0, 21621, 21622, 7, 3, 0, 0, 21622, 21623, 5, 95, 0, 0, 21623, 21624, 7, 10, 0, 0, 21624, 21625, 7, 7, 0, 0, 21625, 21626, 7, 4, 0, 0, 21626, 21627, 7, 6, 0, 0, 21627, 21628, 7, 3, 0, 0, 21628, 21629, 7, 8, 0, 0, 21629, 21630, 7, 6, 0, 0, 21630, 21631, 7, 15, 0, 0, 21631, 21632, 7, 4, 0, 0, 21632, 3084, 1, 0, 0, 0, 21633, 21634, 7, 3, 0, 0, 21634, 21635, 7, 6, 0, 0, 21635, 21636, 7, 17, 0, 0, 21636, 21637, 7, 3, 0, 0, 21637, 21638, 5, 95, 0, 0, 21638, 21639, 7, 3, 0, 0, 21639, 21640, 5, 50, 0, 0, 21640, 3086, 1, 0, 0, 0, 21641, 21642, 7, 3, 0, 0, 21642, 21643, 7, 6, 0, 0, 21643, 21644, 7, 17, 0, 0, 21644, 21645, 7, 3, 0, 0, 21645, 21646, 5, 95, 0, 0, 21646, 21647, 7, 5, 0, 0, 21647, 21648, 7, 11, 0, 0, 21648, 21649, 7, 2, 0, 0, 21649, 21650, 7, 15, 0, 0, 21650, 21651, 7, 6, 0, 0, 21651, 3088, 1, 0, 0, 0, 21652, 21653, 7, 3, 0, 0, 21653, 21654, 7, 6, 0, 0, 21654, 21655, 7, 17, 0, 0, 21655, 21656, 7, 3, 0, 0, 21656, 21657, 5, 95, 0, 0, 21657, 21658, 7, 5, 0, 0, 21658, 21659, 7, 25, 0, 0, 21659, 21660, 7, 25, 0, 0, 21660, 3090, 1, 0, 0, 0, 21661, 21662, 7, 3, 0, 0, 21662, 21663, 7, 6, 0, 0, 21663, 21664, 7, 17, 0, 0, 21664, 21665, 7, 3, 0, 0, 21665, 21666, 5, 95, 0, 0, 21666, 21667, 7, 5, 0, 0, 21667, 21668, 7, 25, 0, 0, 21668, 21669, 7, 18, 0, 0, 21669, 3092, 1, 0, 0, 0, 21670, 21671, 7, 3, 0, 0, 21671, 21672, 7, 6, 0, 0, 21672, 21673, 7, 17, 0, 0, 21673, 21674, 7, 3, 0, 0, 21674, 21675, 5, 95, 0, 0, 21675, 21676, 7, 5, 0, 0, 21676, 21677, 7, 18, 0, 0, 21677, 21678, 7, 18, 0, 0, 21678, 3094, 1, 0, 0, 0, 21679, 21680, 7, 3, 0, 0, 21680, 21681, 7, 6, 0, 0, 21681, 21682, 7, 17, 0, 0, 21682, 21683, 7, 12, 0, 0, 21683, 21684, 7, 11, 0, 0, 21684, 21685, 7, 0, 0, 0, 21685, 21686, 7, 3, 0, 0, 21686, 3096, 1, 0, 0, 0, 21687, 21688, 7, 3, 0, 0, 21688, 21689, 7, 6, 0, 0, 21689, 21690, 7, 20, 0, 0, 21690, 21691, 7, 6, 0, 0, 21691, 21692, 7, 8, 0, 0, 21692, 21693, 7, 4, 0, 0, 21693, 3098, 1, 0, 0, 0, 21694, 21695, 7, 3, 0, 0, 21695, 21696, 7, 6, 0, 0, 21696, 21697, 7, 21, 0, 0, 21697, 21698, 7, 6, 0, 0, 21698, 21699, 7, 18, 0, 0, 21699, 3100, 1, 0, 0, 0, 21700, 21701, 7, 3, 0, 0, 21701, 21702, 7, 6, 0, 0, 21702, 21703, 7, 11, 0, 0, 21703, 21704, 7, 0, 0, 0, 21704, 21705, 7, 4, 0, 0, 21705, 21706, 7, 10, 0, 0, 21706, 21707, 7, 2, 0, 0, 21707, 21708, 7, 7, 0, 0, 21708, 21709, 7, 0, 0, 0, 21709, 21710, 7, 11, 0, 0, 21710, 3102, 1, 0, 0, 0, 21711, 21712, 7, 3, 0, 0, 21712, 21713, 7, 6, 0, 0, 21713, 21714, 7, 11, 0, 0, 21714, 21715, 7, 10, 0, 0, 21715, 21716, 7, 6, 0, 0, 21716, 21717, 7, 5, 0, 0, 21717, 21718, 5, 95, 0, 0, 21718, 21719, 7, 2, 0, 0, 21719, 21720, 7, 7, 0, 0, 21720, 3104, 1, 0, 0, 0, 21721, 21722, 7, 3, 0, 0, 21722, 21723, 7, 6, 0, 0, 21723, 21724, 7, 11, 0, 0, 21724, 21725, 7, 2, 0, 0, 21725, 21726, 7, 8, 0, 0, 21726, 21727, 7, 0, 0, 0, 21727, 21728, 7, 4, 0, 0, 21728, 21729, 7, 6, 0, 0, 21729, 3106, 1, 0, 0, 0, 21730, 21731, 7, 3, 0, 0, 21731, 21732, 7, 6, 0, 0, 21732, 21733, 7, 11, 0, 0, 21733, 21734, 7, 18, 0, 0, 21734, 3108, 1, 0, 0, 0, 21735, 21736, 7, 3, 0, 0, 21736, 21737, 7, 6, 0, 0, 21737, 21738, 7, 14, 0, 0, 21738, 21739, 7, 0, 0, 0, 21739, 21740, 7, 10, 0, 0, 21740, 21741, 7, 7, 0, 0, 21741, 21742, 7, 9, 0, 0, 21742, 21743, 7, 6, 0, 0, 21743, 21744, 7, 3, 0, 0, 21744, 3110, 1, 0, 0, 0, 21745, 21746, 7, 3, 0, 0, 21746, 21747, 7, 6, 0, 0, 21747, 21748, 7, 14, 0, 0, 21748, 21749, 7, 2, 0, 0, 21749, 21750, 7, 4, 0, 0, 21750, 21751, 7, 6, 0, 0, 21751, 3112, 1, 0, 0, 0, 21752, 21753, 7, 3, 0, 0, 21753, 21754, 7, 6, 0, 0, 21754, 21755, 7, 14, 0, 0, 21755, 21756, 7, 2, 0, 0, 21756, 21757, 7, 4, 0, 0, 21757, 21758, 7, 6, 0, 0, 21758, 21759, 5, 95, 0, 0, 21759, 21760, 7, 14, 0, 0, 21760, 21761, 7, 0, 0, 0, 21761, 21762, 7, 15, 0, 0, 21762, 21763, 7, 15, 0, 0, 21763, 21764, 7, 6, 0, 0, 21764, 21765, 7, 9, 0, 0, 21765, 3114, 1, 0, 0, 0, 21766, 21767, 7, 3, 0, 0, 21767, 21768, 7, 6, 0, 0, 21768, 21769, 7, 14, 0, 0, 21769, 21770, 7, 2, 0, 0, 21770, 21771, 7, 13, 0, 0, 21771, 21772, 7, 6, 0, 0, 21772, 3116, 1, 0, 0, 0, 21773, 21774, 7, 3, 0, 0, 21774, 21775, 7, 6, 0, 0, 21775, 21776, 7, 7, 0, 0, 21776, 21777, 7, 0, 0, 0, 21777, 21778, 7, 14, 0, 0, 21778, 21779, 7, 6, 0, 0, 21779, 3118, 1, 0, 0, 0, 21780, 21781, 7, 3, 0, 0, 21781, 21782, 7, 6, 0, 0, 21782, 21783, 7, 15, 0, 0, 21783, 21784, 7, 0, 0, 0, 21784, 21785, 7, 10, 0, 0, 21785, 21786, 7, 3, 0, 0, 21786, 3120, 1, 0, 0, 0, 21787, 21788, 7, 3, 0, 0, 21788, 21789, 7, 6, 0, 0, 21789, 21790, 7, 15, 0, 0, 21790, 21791, 7, 6, 0, 0, 21791, 21792, 7, 0, 0, 0, 21792, 21793, 7, 4, 0, 0, 21793, 3122, 1, 0, 0, 0, 21794, 21795, 7, 3, 0, 0, 21795, 21796, 7, 6, 0, 0, 21796, 21797, 7, 15, 0, 0, 21797, 21798, 7, 11, 0, 0, 21798, 21799, 7, 0, 0, 0, 21799, 21800, 7, 8, 0, 0, 21800, 21801, 7, 6, 0, 0, 21801, 3124, 1, 0, 0, 0, 21802, 21803, 7, 3, 0, 0, 21803, 21804, 7, 6, 0, 0, 21804, 21805, 7, 15, 0, 0, 21805, 21806, 7, 11, 0, 0, 21806, 21807, 7, 10, 0, 0, 21807, 21808, 7, 8, 0, 0, 21808, 21809, 7, 0, 0, 0, 21809, 21810, 7, 4, 0, 0, 21810, 21811, 7, 10, 0, 0, 21811, 21812, 7, 2, 0, 0, 21812, 21813, 7, 7, 0, 0, 21813, 3126, 1, 0, 0, 0, 21814, 21815, 7, 3, 0, 0, 21815, 21816, 7, 6, 0, 0, 21816, 21817, 7, 24, 0, 0, 21817, 21818, 7, 12, 0, 0, 21818, 21819, 7, 10, 0, 0, 21819, 21820, 7, 3, 0, 0, 21820, 21821, 7, 6, 0, 0, 21821, 21822, 7, 9, 0, 0, 21822, 3128, 1, 0, 0, 0, 21823, 21824, 7, 3, 0, 0, 21824, 21825, 7, 6, 0, 0, 21825, 21826, 7, 5, 0, 0, 21826, 21827, 7, 6, 0, 0, 21827, 21828, 7, 4, 0, 0, 21828, 21829, 7, 11, 0, 0, 21829, 21830, 7, 2, 0, 0, 21830, 21831, 7, 17, 0, 0, 21831, 21832, 7, 5, 0, 0, 21832, 3130, 1, 0, 0, 0, 21833, 21834, 7, 3, 0, 0, 21834, 21835, 7, 6, 0, 0, 21835, 21836, 7, 5, 0, 0, 21836, 21837, 7, 6, 0, 0, 21837, 21838, 7, 4, 0, 0, 21838, 3132, 1, 0, 0, 0, 21839, 21840, 7, 3, 0, 0, 21840, 21841, 7, 6, 0, 0, 21841, 21842, 7, 5, 0, 0, 21842, 21843, 7, 10, 0, 0, 21843, 21844, 7, 23, 0, 0, 21844, 21845, 7, 6, 0, 0, 21845, 3134, 1, 0, 0, 0, 21846, 21847, 7, 3, 0, 0, 21847, 21848, 7, 6, 0, 0, 21848, 21849, 7, 5, 0, 0, 21849, 21850, 7, 2, 0, 0, 21850, 21851, 7, 11, 0, 0, 21851, 21852, 7, 13, 0, 0, 21852, 21853, 7, 6, 0, 0, 21853, 3136, 1, 0, 0, 0, 21854, 21855, 7, 3, 0, 0, 21855, 21856, 7, 6, 0, 0, 21856, 21857, 7, 5, 0, 0, 21857, 21858, 7, 2, 0, 0, 21858, 21859, 7, 11, 0, 0, 21859, 21860, 7, 13, 0, 0, 21860, 21861, 7, 6, 0, 0, 21861, 21862, 7, 3, 0, 0, 21862, 3138, 1, 0, 0, 0, 21863, 21864, 7, 3, 0, 0, 21864, 21865, 7, 6, 0, 0, 21865, 21866, 7, 5, 0, 0, 21866, 21867, 7, 2, 0, 0, 21867, 21868, 7, 12, 0, 0, 21868, 21869, 7, 3, 0, 0, 21869, 21870, 7, 8, 0, 0, 21870, 21871, 7, 6, 0, 0, 21871, 3140, 1, 0, 0, 0, 21872, 21873, 7, 3, 0, 0, 21873, 21874, 7, 6, 0, 0, 21874, 21875, 7, 5, 0, 0, 21875, 21876, 7, 15, 0, 0, 21876, 21877, 7, 6, 0, 0, 21877, 21878, 7, 8, 0, 0, 21878, 21879, 7, 4, 0, 0, 21879, 3142, 1, 0, 0, 0, 21880, 21881, 7, 3, 0, 0, 21881, 21882, 7, 6, 0, 0, 21882, 21883, 7, 5, 0, 0, 21883, 21884, 7, 4, 0, 0, 21884, 21885, 7, 0, 0, 0, 21885, 21886, 7, 3, 0, 0, 21886, 21887, 7, 4, 0, 0, 21887, 3144, 1, 0, 0, 0, 21888, 21889, 7, 3, 0, 0, 21889, 21890, 7, 6, 0, 0, 21890, 21891, 7, 5, 0, 0, 21891, 21892, 7, 4, 0, 0, 21892, 21893, 7, 2, 0, 0, 21893, 21894, 7, 3, 0, 0, 21894, 21895, 7, 6, 0, 0, 21895, 21896, 5, 95, 0, 0, 21896, 21897, 7, 0, 0, 0, 21897, 21898, 7, 5, 0, 0, 21898, 21899, 5, 95, 0, 0, 21899, 21900, 7, 10, 0, 0, 21900, 21901, 7, 7, 0, 0, 21901, 21902, 7, 4, 0, 0, 21902, 21903, 7, 6, 0, 0, 21903, 21904, 7, 3, 0, 0, 21904, 21905, 7, 13, 0, 0, 21905, 21906, 7, 0, 0, 0, 21906, 21907, 7, 11, 0, 0, 21907, 21908, 7, 5, 0, 0, 21908, 3146, 1, 0, 0, 0, 21909, 21910, 7, 3, 0, 0, 21910, 21911, 7, 6, 0, 0, 21911, 21912, 7, 5, 0, 0, 21912, 21913, 7, 4, 0, 0, 21913, 21914, 7, 2, 0, 0, 21914, 21915, 7, 3, 0, 0, 21915, 21916, 7, 6, 0, 0, 21916, 3148, 1, 0, 0, 0, 21917, 21918, 7, 3, 0, 0, 21918, 21919, 7, 6, 0, 0, 21919, 21920, 7, 5, 0, 0, 21920, 21921, 7, 4, 0, 0, 21921, 21922, 7, 3, 0, 0, 21922, 21923, 7, 10, 0, 0, 21923, 21924, 7, 8, 0, 0, 21924, 21925, 7, 4, 0, 0, 21925, 21926, 5, 95, 0, 0, 21926, 21927, 7, 0, 0, 0, 21927, 21928, 7, 11, 0, 0, 21928, 21929, 7, 11, 0, 0, 21929, 21930, 5, 95, 0, 0, 21930, 21931, 7, 3, 0, 0, 21931, 21932, 7, 6, 0, 0, 21932, 21933, 7, 16, 0, 0, 21933, 21934, 5, 95, 0, 0, 21934, 21935, 7, 8, 0, 0, 21935, 21936, 7, 2, 0, 0, 21936, 21937, 7, 7, 0, 0, 21937, 21938, 7, 5, 0, 0, 21938, 3150, 1, 0, 0, 0, 21939, 21940, 7, 3, 0, 0, 21940, 21941, 7, 6, 0, 0, 21941, 21942, 7, 5, 0, 0, 21942, 21943, 7, 4, 0, 0, 21943, 21944, 7, 3, 0, 0, 21944, 21945, 7, 10, 0, 0, 21945, 21946, 7, 8, 0, 0, 21946, 21947, 7, 4, 0, 0, 21947, 21948, 7, 6, 0, 0, 21948, 21949, 7, 9, 0, 0, 21949, 3152, 1, 0, 0, 0, 21950, 21951, 7, 3, 0, 0, 21951, 21952, 7, 6, 0, 0, 21952, 21953, 7, 5, 0, 0, 21953, 21954, 7, 4, 0, 0, 21954, 21955, 7, 3, 0, 0, 21955, 21956, 7, 10, 0, 0, 21956, 21957, 7, 8, 0, 0, 21957, 21958, 7, 4, 0, 0, 21958, 21959, 5, 95, 0, 0, 21959, 21960, 7, 3, 0, 0, 21960, 21961, 7, 6, 0, 0, 21961, 21962, 7, 16, 0, 0, 21962, 21963, 7, 6, 0, 0, 21963, 21964, 7, 3, 0, 0, 21964, 21965, 7, 6, 0, 0, 21965, 21966, 7, 7, 0, 0, 21966, 21967, 7, 8, 0, 0, 21967, 21968, 7, 6, 0, 0, 21968, 21969, 7, 5, 0, 0, 21969, 3154, 1, 0, 0, 0, 21970, 21971, 7, 3, 0, 0, 21971, 21972, 7, 6, 0, 0, 21972, 21973, 7, 5, 0, 0, 21973, 21974, 7, 4, 0, 0, 21974, 21975, 7, 3, 0, 0, 21975, 21976, 7, 10, 0, 0, 21976, 21977, 7, 8, 0, 0, 21977, 21978, 7, 4, 0, 0, 21978, 3156, 1, 0, 0, 0, 21979, 21980, 7, 3, 0, 0, 21980, 21981, 7, 6, 0, 0, 21981, 21982, 7, 5, 0, 0, 21982, 21983, 7, 12, 0, 0, 21983, 21984, 7, 11, 0, 0, 21984, 21985, 7, 4, 0, 0, 21985, 21986, 5, 95, 0, 0, 21986, 21987, 7, 8, 0, 0, 21987, 21988, 7, 0, 0, 0, 21988, 21989, 7, 8, 0, 0, 21989, 21990, 7, 19, 0, 0, 21990, 21991, 7, 6, 0, 0, 21991, 3158, 1, 0, 0, 0, 21992, 21993, 7, 3, 0, 0, 21993, 21994, 7, 6, 0, 0, 21994, 21995, 7, 5, 0, 0, 21995, 21996, 7, 12, 0, 0, 21996, 21997, 7, 11, 0, 0, 21997, 21998, 7, 4, 0, 0, 21998, 3160, 1, 0, 0, 0, 21999, 22000, 7, 3, 0, 0, 22000, 22001, 7, 6, 0, 0, 22001, 22002, 7, 5, 0, 0, 22002, 22003, 7, 12, 0, 0, 22003, 22004, 7, 14, 0, 0, 22004, 22005, 7, 0, 0, 0, 22005, 22006, 7, 1, 0, 0, 22006, 22007, 7, 11, 0, 0, 22007, 22008, 7, 6, 0, 0, 22008, 3162, 1, 0, 0, 0, 22009, 22010, 7, 3, 0, 0, 22010, 22011, 7, 6, 0, 0, 22011, 22012, 7, 5, 0, 0, 22012, 22013, 7, 12, 0, 0, 22013, 22014, 7, 14, 0, 0, 22014, 22015, 7, 6, 0, 0, 22015, 3164, 1, 0, 0, 0, 22016, 22017, 7, 3, 0, 0, 22017, 22018, 7, 6, 0, 0, 22018, 22019, 7, 4, 0, 0, 22019, 22020, 7, 6, 0, 0, 22020, 22021, 7, 7, 0, 0, 22021, 22022, 7, 4, 0, 0, 22022, 22023, 7, 10, 0, 0, 22023, 22024, 7, 2, 0, 0, 22024, 22025, 7, 7, 0, 0, 22025, 3166, 1, 0, 0, 0, 22026, 22027, 7, 3, 0, 0, 22027, 22028, 7, 6, 0, 0, 22028, 22029, 7, 4, 0, 0, 22029, 22030, 7, 3, 0, 0, 22030, 22031, 7, 18, 0, 0, 22031, 22032, 5, 95, 0, 0, 22032, 22033, 7, 2, 0, 0, 22033, 22034, 7, 7, 0, 0, 22034, 22035, 5, 95, 0, 0, 22035, 22036, 7, 3, 0, 0, 22036, 22037, 7, 2, 0, 0, 22037, 22038, 7, 22, 0, 0, 22038, 22039, 5, 95, 0, 0, 22039, 22040, 7, 8, 0, 0, 22040, 22041, 7, 19, 0, 0, 22041, 22042, 7, 0, 0, 0, 22042, 22043, 7, 7, 0, 0, 22043, 22044, 7, 17, 0, 0, 22044, 22045, 7, 6, 0, 0, 22045, 3168, 1, 0, 0, 0, 22046, 22047, 7, 3, 0, 0, 22047, 22048, 7, 6, 0, 0, 22048, 22049, 7, 4, 0, 0, 22049, 22050, 7, 12, 0, 0, 22050, 22051, 7, 3, 0, 0, 22051, 22052, 7, 7, 0, 0, 22052, 22053, 7, 10, 0, 0, 22053, 22054, 7, 7, 0, 0, 22054, 22055, 7, 17, 0, 0, 22055, 3170, 1, 0, 0, 0, 22056, 22057, 7, 3, 0, 0, 22057, 22058, 7, 6, 0, 0, 22058, 22059, 7, 4, 0, 0, 22059, 22060, 7, 12, 0, 0, 22060, 22061, 7, 3, 0, 0, 22061, 22062, 7, 7, 0, 0, 22062, 3172, 1, 0, 0, 0, 22063, 22064, 7, 3, 0, 0, 22064, 22065, 7, 6, 0, 0, 22065, 22066, 7, 12, 0, 0, 22066, 22067, 7, 5, 0, 0, 22067, 22068, 7, 6, 0, 0, 22068, 3174, 1, 0, 0, 0, 22069, 22070, 7, 3, 0, 0, 22070, 22071, 7, 6, 0, 0, 22071, 22072, 7, 13, 0, 0, 22072, 22073, 7, 6, 0, 0, 22073, 22074, 7, 3, 0, 0, 22074, 22075, 7, 5, 0, 0, 22075, 22076, 7, 6, 0, 0, 22076, 3176, 1, 0, 0, 0, 22077, 22078, 7, 3, 0, 0, 22078, 22079, 7, 6, 0, 0, 22079, 22080, 7, 13, 0, 0, 22080, 22081, 7, 2, 0, 0, 22081, 22082, 7, 21, 0, 0, 22082, 22083, 7, 6, 0, 0, 22083, 3178, 1, 0, 0, 0, 22084, 22085, 7, 3, 0, 0, 22085, 22086, 7, 6, 0, 0, 22086, 22087, 7, 22, 0, 0, 22087, 22088, 7, 3, 0, 0, 22088, 22089, 7, 10, 0, 0, 22089, 22090, 7, 4, 0, 0, 22090, 22091, 7, 6, 0, 0, 22091, 22092, 5, 95, 0, 0, 22092, 22093, 7, 2, 0, 0, 22093, 22094, 7, 3, 0, 0, 22094, 22095, 5, 95, 0, 0, 22095, 22096, 7, 6, 0, 0, 22096, 22097, 7, 3, 0, 0, 22097, 22098, 7, 3, 0, 0, 22098, 22099, 7, 2, 0, 0, 22099, 22100, 7, 3, 0, 0, 22100, 3180, 1, 0, 0, 0, 22101, 22102, 7, 3, 0, 0, 22102, 22103, 7, 6, 0, 0, 22103, 22104, 7, 22, 0, 0, 22104, 22105, 7, 3, 0, 0, 22105, 22106, 7, 10, 0, 0, 22106, 22107, 7, 4, 0, 0, 22107, 22108, 7, 6, 0, 0, 22108, 3182, 1, 0, 0, 0, 22109, 22110, 7, 3, 0, 0, 22110, 22111, 7, 10, 0, 0, 22111, 22112, 7, 17, 0, 0, 22112, 22113, 7, 19, 0, 0, 22113, 22114, 7, 4, 0, 0, 22114, 3184, 1, 0, 0, 0, 22115, 22116, 7, 3, 0, 0, 22116, 22117, 7, 2, 0, 0, 22117, 22118, 7, 11, 0, 0, 22118, 22119, 7, 6, 0, 0, 22119, 3186, 1, 0, 0, 0, 22120, 22121, 7, 3, 0, 0, 22121, 22122, 7, 2, 0, 0, 22122, 22123, 7, 11, 0, 0, 22123, 22124, 7, 6, 0, 0, 22124, 22125, 7, 5, 0, 0, 22125, 22126, 7, 6, 0, 0, 22126, 22127, 7, 4, 0, 0, 22127, 3188, 1, 0, 0, 0, 22128, 22129, 7, 3, 0, 0, 22129, 22130, 7, 2, 0, 0, 22130, 22131, 7, 11, 0, 0, 22131, 22132, 7, 6, 0, 0, 22132, 22133, 7, 5, 0, 0, 22133, 3190, 1, 0, 0, 0, 22134, 22135, 7, 3, 0, 0, 22135, 22136, 7, 2, 0, 0, 22136, 22137, 7, 11, 0, 0, 22137, 22138, 7, 11, 0, 0, 22138, 22139, 7, 1, 0, 0, 22139, 22140, 7, 0, 0, 0, 22140, 22141, 7, 8, 0, 0, 22141, 22142, 7, 21, 0, 0, 22142, 3192, 1, 0, 0, 0, 22143, 22144, 7, 3, 0, 0, 22144, 22145, 7, 2, 0, 0, 22145, 22146, 7, 11, 0, 0, 22146, 22147, 7, 11, 0, 0, 22147, 22148, 7, 10, 0, 0, 22148, 22149, 7, 7, 0, 0, 22149, 22150, 7, 17, 0, 0, 22150, 3194, 1, 0, 0, 0, 22151, 22152, 7, 3, 0, 0, 22152, 22153, 7, 2, 0, 0, 22153, 22154, 7, 11, 0, 0, 22154, 22155, 7, 11, 0, 0, 22155, 22156, 7, 12, 0, 0, 22156, 22157, 7, 15, 0, 0, 22157, 3196, 1, 0, 0, 0, 22158, 22159, 7, 3, 0, 0, 22159, 22160, 7, 2, 0, 0, 22160, 22161, 7, 22, 0, 0, 22161, 22162, 7, 9, 0, 0, 22162, 22163, 7, 6, 0, 0, 22163, 22164, 7, 15, 0, 0, 22164, 22165, 7, 6, 0, 0, 22165, 22166, 7, 7, 0, 0, 22166, 22167, 7, 9, 0, 0, 22167, 22168, 7, 6, 0, 0, 22168, 22169, 7, 7, 0, 0, 22169, 22170, 7, 8, 0, 0, 22170, 22171, 7, 10, 0, 0, 22171, 22172, 7, 6, 0, 0, 22172, 22173, 7, 5, 0, 0, 22173, 3198, 1, 0, 0, 0, 22174, 22175, 7, 3, 0, 0, 22175, 22176, 7, 2, 0, 0, 22176, 22177, 7, 22, 0, 0, 22177, 22178, 7, 10, 0, 0, 22178, 22179, 7, 9, 0, 0, 22179, 22180, 5, 95, 0, 0, 22180, 22181, 7, 14, 0, 0, 22181, 22182, 7, 0, 0, 0, 22182, 22183, 7, 15, 0, 0, 22183, 22184, 7, 15, 0, 0, 22184, 22185, 7, 10, 0, 0, 22185, 22186, 7, 7, 0, 0, 22186, 22187, 7, 17, 0, 0, 22187, 22188, 5, 95, 0, 0, 22188, 22189, 7, 4, 0, 0, 22189, 22190, 7, 0, 0, 0, 22190, 22191, 7, 1, 0, 0, 22191, 22192, 7, 11, 0, 0, 22192, 22193, 7, 6, 0, 0, 22193, 3200, 1, 0, 0, 0, 22194, 22195, 7, 3, 0, 0, 22195, 22196, 7, 2, 0, 0, 22196, 22197, 7, 22, 0, 0, 22197, 22198, 7, 10, 0, 0, 22198, 22199, 7, 9, 0, 0, 22199, 3202, 1, 0, 0, 0, 22200, 22201, 7, 3, 0, 0, 22201, 22202, 7, 2, 0, 0, 22202, 22203, 7, 22, 0, 0, 22203, 22204, 7, 10, 0, 0, 22204, 22205, 7, 9, 0, 0, 22205, 22206, 7, 4, 0, 0, 22206, 22207, 7, 2, 0, 0, 22207, 22208, 7, 8, 0, 0, 22208, 22209, 7, 19, 0, 0, 22209, 22210, 7, 0, 0, 0, 22210, 22211, 7, 3, 0, 0, 22211, 3204, 1, 0, 0, 0, 22212, 22213, 7, 3, 0, 0, 22213, 22214, 7, 2, 0, 0, 22214, 22215, 7, 22, 0, 0, 22215, 22216, 7, 10, 0, 0, 22216, 22217, 7, 9, 0, 0, 22217, 22218, 7, 4, 0, 0, 22218, 22219, 7, 2, 0, 0, 22219, 22220, 7, 7, 0, 0, 22220, 22221, 7, 8, 0, 0, 22221, 22222, 7, 19, 0, 0, 22222, 22223, 7, 0, 0, 0, 22223, 22224, 7, 3, 0, 0, 22224, 3206, 1, 0, 0, 0, 22225, 22226, 7, 3, 0, 0, 22226, 22227, 7, 2, 0, 0, 22227, 22228, 7, 22, 0, 0, 22228, 22229, 5, 95, 0, 0, 22229, 22230, 7, 11, 0, 0, 22230, 22231, 7, 6, 0, 0, 22231, 22232, 7, 7, 0, 0, 22232, 22233, 7, 17, 0, 0, 22233, 22234, 7, 4, 0, 0, 22234, 22235, 7, 19, 0, 0, 22235, 3208, 1, 0, 0, 0, 22236, 22237, 7, 3, 0, 0, 22237, 22238, 7, 2, 0, 0, 22238, 22239, 7, 22, 0, 0, 22239, 22240, 7, 7, 0, 0, 22240, 22241, 7, 12, 0, 0, 22241, 22242, 7, 14, 0, 0, 22242, 3210, 1, 0, 0, 0, 22243, 22244, 7, 3, 0, 0, 22244, 22245, 7, 2, 0, 0, 22245, 22246, 7, 22, 0, 0, 22246, 3212, 1, 0, 0, 0, 22247, 22248, 7, 3, 0, 0, 22248, 22249, 7, 2, 0, 0, 22249, 22250, 7, 22, 0, 0, 22250, 22251, 7, 5, 0, 0, 22251, 3214, 1, 0, 0, 0, 22252, 22253, 7, 3, 0, 0, 22253, 22254, 7, 15, 0, 0, 22254, 22255, 7, 0, 0, 0, 22255, 22256, 7, 9, 0, 0, 22256, 3216, 1, 0, 0, 0, 22257, 22258, 7, 3, 0, 0, 22258, 22259, 7, 4, 0, 0, 22259, 22260, 7, 3, 0, 0, 22260, 22261, 7, 10, 0, 0, 22261, 22262, 7, 14, 0, 0, 22262, 3218, 1, 0, 0, 0, 22263, 22264, 7, 3, 0, 0, 22264, 22265, 7, 12, 0, 0, 22265, 22266, 7, 11, 0, 0, 22266, 22267, 7, 6, 0, 0, 22267, 3220, 1, 0, 0, 0, 22268, 22269, 7, 3, 0, 0, 22269, 22270, 7, 12, 0, 0, 22270, 22271, 7, 11, 0, 0, 22271, 22272, 7, 6, 0, 0, 22272, 22273, 7, 5, 0, 0, 22273, 3222, 1, 0, 0, 0, 22274, 22275, 7, 3, 0, 0, 22275, 22276, 7, 12, 0, 0, 22276, 22277, 7, 7, 0, 0, 22277, 22278, 7, 7, 0, 0, 22278, 22279, 7, 10, 0, 0, 22279, 22280, 7, 7, 0, 0, 22280, 22281, 7, 17, 0, 0, 22281, 3224, 1, 0, 0, 0, 22282, 22283, 7, 5, 0, 0, 22283, 22284, 7, 0, 0, 0, 22284, 22285, 7, 11, 0, 0, 22285, 22286, 7, 4, 0, 0, 22286, 3226, 1, 0, 0, 0, 22287, 22288, 7, 5, 0, 0, 22288, 22289, 7, 0, 0, 0, 22289, 22290, 7, 14, 0, 0, 22290, 22291, 7, 15, 0, 0, 22291, 22292, 7, 11, 0, 0, 22292, 22293, 7, 6, 0, 0, 22293, 3228, 1, 0, 0, 0, 22294, 22295, 7, 5, 0, 0, 22295, 22296, 7, 0, 0, 0, 22296, 22297, 7, 13, 0, 0, 22297, 22298, 7, 6, 0, 0, 22298, 22299, 5, 95, 0, 0, 22299, 22300, 7, 0, 0, 0, 22300, 22301, 7, 5, 0, 0, 22301, 22302, 5, 95, 0, 0, 22302, 22303, 7, 10, 0, 0, 22303, 22304, 7, 7, 0, 0, 22304, 22305, 7, 4, 0, 0, 22305, 22306, 7, 6, 0, 0, 22306, 22307, 7, 3, 0, 0, 22307, 22308, 7, 13, 0, 0, 22308, 22309, 7, 0, 0, 0, 22309, 22310, 7, 11, 0, 0, 22310, 22311, 7, 5, 0, 0, 22311, 3230, 1, 0, 0, 0, 22312, 22313, 7, 5, 0, 0, 22313, 22314, 7, 0, 0, 0, 22314, 22315, 7, 13, 0, 0, 22315, 22316, 7, 6, 0, 0, 22316, 22317, 7, 15, 0, 0, 22317, 22318, 7, 2, 0, 0, 22318, 22319, 7, 10, 0, 0, 22319, 22320, 7, 7, 0, 0, 22320, 22321, 7, 4, 0, 0, 22321, 3232, 1, 0, 0, 0, 22322, 22323, 7, 5, 0, 0, 22323, 22324, 7, 0, 0, 0, 22324, 22325, 7, 13, 0, 0, 22325, 22326, 7, 6, 0, 0, 22326, 3234, 1, 0, 0, 0, 22327, 22328, 7, 5, 0, 0, 22328, 22329, 7, 1, 0, 0, 22329, 22330, 5, 52, 0, 0, 22330, 3236, 1, 0, 0, 0, 22331, 22332, 7, 5, 0, 0, 22332, 22333, 7, 8, 0, 0, 22333, 22334, 7, 0, 0, 0, 22334, 22335, 7, 11, 0, 0, 22335, 22336, 7, 6, 0, 0, 22336, 22337, 5, 95, 0, 0, 22337, 22338, 7, 3, 0, 0, 22338, 22339, 7, 2, 0, 0, 22339, 22340, 7, 22, 0, 0, 22340, 22341, 7, 5, 0, 0, 22341, 3238, 1, 0, 0, 0, 22342, 22343, 7, 5, 0, 0, 22343, 22344, 7, 8, 0, 0, 22344, 22345, 7, 0, 0, 0, 22345, 22346, 7, 11, 0, 0, 22346, 22347, 7, 6, 0, 0, 22347, 3240, 1, 0, 0, 0, 22348, 22349, 7, 5, 0, 0, 22349, 22350, 7, 8, 0, 0, 22350, 22351, 7, 0, 0, 0, 22351, 22352, 7, 7, 0, 0, 22352, 22353, 5, 95, 0, 0, 22353, 22354, 7, 10, 0, 0, 22354, 22355, 7, 7, 0, 0, 22355, 22356, 7, 5, 0, 0, 22356, 22357, 7, 4, 0, 0, 22357, 22358, 7, 0, 0, 0, 22358, 22359, 7, 7, 0, 0, 22359, 22360, 7, 8, 0, 0, 22360, 22361, 7, 6, 0, 0, 22361, 22362, 7, 5, 0, 0, 22362, 3242, 1, 0, 0, 0, 22363, 22364, 7, 5, 0, 0, 22364, 22365, 7, 8, 0, 0, 22365, 22366, 7, 0, 0, 0, 22366, 22367, 7, 7, 0, 0, 22367, 3244, 1, 0, 0, 0, 22368, 22369, 7, 5, 0, 0, 22369, 22370, 7, 8, 0, 0, 22370, 22371, 7, 19, 0, 0, 22371, 22372, 7, 6, 0, 0, 22372, 22373, 7, 9, 0, 0, 22373, 22374, 7, 12, 0, 0, 22374, 22375, 7, 11, 0, 0, 22375, 22376, 7, 6, 0, 0, 22376, 22377, 7, 3, 0, 0, 22377, 3246, 1, 0, 0, 0, 22378, 22379, 7, 5, 0, 0, 22379, 22380, 7, 8, 0, 0, 22380, 22381, 7, 19, 0, 0, 22381, 22382, 7, 6, 0, 0, 22382, 22383, 7, 14, 0, 0, 22383, 22384, 7, 0, 0, 0, 22384, 22385, 7, 8, 0, 0, 22385, 22386, 7, 19, 0, 0, 22386, 22387, 7, 6, 0, 0, 22387, 22388, 7, 8, 0, 0, 22388, 22389, 7, 21, 0, 0, 22389, 3248, 1, 0, 0, 0, 22390, 22391, 7, 5, 0, 0, 22391, 22392, 7, 8, 0, 0, 22392, 22393, 7, 19, 0, 0, 22393, 22394, 7, 6, 0, 0, 22394, 22395, 7, 14, 0, 0, 22395, 22396, 7, 0, 0, 0, 22396, 3250, 1, 0, 0, 0, 22397, 22398, 7, 5, 0, 0, 22398, 22399, 7, 8, 0, 0, 22399, 22400, 7, 7, 0, 0, 22400, 22401, 5, 95, 0, 0, 22401, 22402, 7, 0, 0, 0, 22402, 22403, 7, 5, 0, 0, 22403, 22404, 7, 8, 0, 0, 22404, 22405, 7, 6, 0, 0, 22405, 22406, 7, 7, 0, 0, 22406, 22407, 7, 9, 0, 0, 22407, 22408, 7, 10, 0, 0, 22408, 22409, 7, 7, 0, 0, 22409, 22410, 7, 17, 0, 0, 22410, 3252, 1, 0, 0, 0, 22411, 22412, 7, 5, 0, 0, 22412, 22413, 7, 8, 0, 0, 22413, 22414, 7, 7, 0, 0, 22414, 3254, 1, 0, 0, 0, 22415, 22416, 7, 5, 0, 0, 22416, 22417, 7, 8, 0, 0, 22417, 22418, 7, 2, 0, 0, 22418, 22419, 7, 15, 0, 0, 22419, 22420, 7, 6, 0, 0, 22420, 3256, 1, 0, 0, 0, 22421, 22422, 7, 5, 0, 0, 22422, 22423, 7, 8, 0, 0, 22423, 22424, 7, 3, 0, 0, 22424, 22425, 7, 12, 0, 0, 22425, 22426, 7, 1, 0, 0, 22426, 3258, 1, 0, 0, 0, 22427, 22428, 7, 5, 0, 0, 22428, 22429, 7, 9, 0, 0, 22429, 22430, 5, 95, 0, 0, 22430, 22431, 7, 0, 0, 0, 22431, 22432, 7, 11, 0, 0, 22432, 22433, 7, 11, 0, 0, 22433, 3260, 1, 0, 0, 0, 22434, 22435, 7, 5, 0, 0, 22435, 22436, 7, 9, 0, 0, 22436, 22437, 5, 95, 0, 0, 22437, 22438, 7, 10, 0, 0, 22438, 22439, 7, 7, 0, 0, 22439, 22440, 7, 19, 0, 0, 22440, 22441, 7, 10, 0, 0, 22441, 22442, 7, 1, 0, 0, 22442, 22443, 7, 10, 0, 0, 22443, 22444, 7, 4, 0, 0, 22444, 3262, 1, 0, 0, 0, 22445, 22446, 7, 5, 0, 0, 22446, 22447, 7, 9, 0, 0, 22447, 22448, 7, 2, 0, 0, 22448, 22449, 5, 95, 0, 0, 22449, 22450, 7, 17, 0, 0, 22450, 22451, 7, 6, 0, 0, 22451, 22452, 7, 2, 0, 0, 22452, 22453, 7, 14, 0, 0, 22453, 22454, 5, 95, 0, 0, 22454, 22455, 7, 14, 0, 0, 22455, 22456, 7, 1, 0, 0, 22456, 22457, 7, 3, 0, 0, 22457, 3264, 1, 0, 0, 0, 22458, 22459, 7, 5, 0, 0, 22459, 22460, 7, 9, 0, 0, 22460, 22461, 7, 2, 0, 0, 22461, 22462, 5, 95, 0, 0, 22462, 22463, 7, 17, 0, 0, 22463, 22464, 7, 6, 0, 0, 22464, 22465, 7, 2, 0, 0, 22465, 22466, 7, 14, 0, 0, 22466, 22467, 7, 6, 0, 0, 22467, 22468, 7, 4, 0, 0, 22468, 22469, 7, 3, 0, 0, 22469, 22470, 7, 18, 0, 0, 22470, 3266, 1, 0, 0, 0, 22471, 22472, 7, 5, 0, 0, 22472, 22473, 7, 9, 0, 0, 22473, 22474, 5, 95, 0, 0, 22474, 22475, 7, 5, 0, 0, 22475, 22476, 7, 19, 0, 0, 22476, 22477, 7, 2, 0, 0, 22477, 22478, 7, 22, 0, 0, 22478, 3268, 1, 0, 0, 0, 22479, 22480, 7, 5, 0, 0, 22480, 22481, 7, 6, 0, 0, 22481, 22482, 7, 0, 0, 0, 22482, 22483, 7, 3, 0, 0, 22483, 22484, 7, 8, 0, 0, 22484, 22485, 7, 19, 0, 0, 22485, 3270, 1, 0, 0, 0, 22486, 22487, 7, 5, 0, 0, 22487, 22488, 7, 6, 0, 0, 22488, 22489, 7, 8, 0, 0, 22489, 22490, 7, 2, 0, 0, 22490, 22491, 7, 7, 0, 0, 22491, 22492, 7, 9, 0, 0, 22492, 3272, 1, 0, 0, 0, 22493, 22494, 7, 5, 0, 0, 22494, 22495, 7, 6, 0, 0, 22495, 22496, 7, 8, 0, 0, 22496, 22497, 7, 2, 0, 0, 22497, 22498, 7, 7, 0, 0, 22498, 22499, 7, 9, 0, 0, 22499, 22500, 7, 5, 0, 0, 22500, 3274, 1, 0, 0, 0, 22501, 22502, 7, 5, 0, 0, 22502, 22503, 7, 6, 0, 0, 22503, 22504, 7, 8, 0, 0, 22504, 22505, 7, 3, 0, 0, 22505, 22506, 7, 6, 0, 0, 22506, 22507, 7, 4, 0, 0, 22507, 3276, 1, 0, 0, 0, 22508, 22509, 7, 5, 0, 0, 22509, 22510, 7, 6, 0, 0, 22510, 22511, 7, 8, 0, 0, 22511, 22512, 7, 12, 0, 0, 22512, 22513, 7, 3, 0, 0, 22513, 22514, 7, 6, 0, 0, 22514, 22515, 7, 16, 0, 0, 22515, 22516, 7, 10, 0, 0, 22516, 22517, 7, 11, 0, 0, 22517, 22518, 7, 6, 0, 0, 22518, 22519, 5, 95, 0, 0, 22519, 22520, 7, 9, 0, 0, 22520, 22521, 7, 1, 0, 0, 22521, 22522, 7, 0, 0, 0, 22522, 3278, 1, 0, 0, 0, 22523, 22524, 7, 5, 0, 0, 22524, 22525, 7, 6, 0, 0, 22525, 22526, 7, 8, 0, 0, 22526, 22527, 7, 12, 0, 0, 22527, 22528, 7, 3, 0, 0, 22528, 22529, 7, 6, 0, 0, 22529, 22530, 7, 16, 0, 0, 22530, 22531, 7, 10, 0, 0, 22531, 22532, 7, 11, 0, 0, 22532, 22533, 7, 6, 0, 0, 22533, 3280, 1, 0, 0, 0, 22534, 22535, 7, 5, 0, 0, 22535, 22536, 7, 6, 0, 0, 22536, 22537, 7, 8, 0, 0, 22537, 22538, 7, 12, 0, 0, 22538, 22539, 7, 3, 0, 0, 22539, 22540, 7, 10, 0, 0, 22540, 22541, 7, 4, 0, 0, 22541, 22542, 7, 18, 0, 0, 22542, 3282, 1, 0, 0, 0, 22543, 22544, 7, 5, 0, 0, 22544, 22545, 7, 6, 0, 0, 22545, 22546, 7, 6, 0, 0, 22546, 22547, 7, 9, 0, 0, 22547, 3284, 1, 0, 0, 0, 22548, 22549, 7, 5, 0, 0, 22549, 22550, 7, 6, 0, 0, 22550, 22551, 7, 17, 0, 0, 22551, 22552, 5, 95, 0, 0, 22552, 22553, 7, 1, 0, 0, 22553, 22554, 7, 11, 0, 0, 22554, 22555, 7, 2, 0, 0, 22555, 22556, 7, 8, 0, 0, 22556, 22557, 7, 21, 0, 0, 22557, 3286, 1, 0, 0, 0, 22558, 22559, 7, 5, 0, 0, 22559, 22560, 7, 6, 0, 0, 22560, 22561, 7, 17, 0, 0, 22561, 22562, 5, 95, 0, 0, 22562, 22563, 7, 16, 0, 0, 22563, 22564, 7, 10, 0, 0, 22564, 22565, 7, 11, 0, 0, 22565, 22566, 7, 6, 0, 0, 22566, 3288, 1, 0, 0, 0, 22567, 22568, 7, 5, 0, 0, 22568, 22569, 7, 6, 0, 0, 22569, 22570, 7, 17, 0, 0, 22570, 22571, 7, 14, 0, 0, 22571, 22572, 7, 6, 0, 0, 22572, 22573, 7, 7, 0, 0, 22573, 22574, 7, 4, 0, 0, 22574, 3290, 1, 0, 0, 0, 22575, 22576, 7, 5, 0, 0, 22576, 22577, 7, 6, 0, 0, 22577, 22578, 7, 11, 0, 0, 22578, 22579, 7, 6, 0, 0, 22579, 22580, 7, 8, 0, 0, 22580, 22581, 7, 4, 0, 0, 22581, 22582, 7, 10, 0, 0, 22582, 22583, 7, 13, 0, 0, 22583, 22584, 7, 10, 0, 0, 22584, 22585, 7, 4, 0, 0, 22585, 22586, 7, 18, 0, 0, 22586, 3292, 1, 0, 0, 0, 22587, 22588, 7, 5, 0, 0, 22588, 22589, 7, 6, 0, 0, 22589, 22590, 7, 11, 0, 0, 22590, 22591, 7, 6, 0, 0, 22591, 22592, 7, 8, 0, 0, 22592, 22593, 7, 4, 0, 0, 22593, 3294, 1, 0, 0, 0, 22594, 22595, 7, 5, 0, 0, 22595, 22596, 7, 6, 0, 0, 22596, 22597, 7, 11, 0, 0, 22597, 22598, 7, 16, 0, 0, 22598, 3296, 1, 0, 0, 0, 22599, 22600, 7, 5, 0, 0, 22600, 22601, 7, 6, 0, 0, 22601, 22602, 7, 14, 0, 0, 22602, 22603, 7, 10, 0, 0, 22603, 22604, 7, 20, 0, 0, 22604, 22605, 7, 2, 0, 0, 22605, 22606, 7, 10, 0, 0, 22606, 22607, 7, 7, 0, 0, 22607, 22608, 5, 95, 0, 0, 22608, 22609, 7, 9, 0, 0, 22609, 22610, 7, 3, 0, 0, 22610, 22611, 7, 10, 0, 0, 22611, 22612, 7, 13, 0, 0, 22612, 22613, 7, 6, 0, 0, 22613, 22614, 7, 3, 0, 0, 22614, 3298, 1, 0, 0, 0, 22615, 22616, 7, 5, 0, 0, 22616, 22617, 7, 6, 0, 0, 22617, 22618, 7, 14, 0, 0, 22618, 22619, 7, 10, 0, 0, 22619, 22620, 7, 20, 0, 0, 22620, 22621, 7, 2, 0, 0, 22621, 22622, 7, 10, 0, 0, 22622, 22623, 7, 7, 0, 0, 22623, 3300, 1, 0, 0, 0, 22624, 22625, 7, 5, 0, 0, 22625, 22626, 7, 6, 0, 0, 22626, 22627, 7, 14, 0, 0, 22627, 22628, 7, 10, 0, 0, 22628, 22629, 5, 95, 0, 0, 22629, 22630, 7, 4, 0, 0, 22630, 22631, 7, 2, 0, 0, 22631, 22632, 5, 95, 0, 0, 22632, 22633, 7, 10, 0, 0, 22633, 22634, 7, 7, 0, 0, 22634, 22635, 7, 7, 0, 0, 22635, 22636, 7, 6, 0, 0, 22636, 22637, 7, 3, 0, 0, 22637, 3302, 1, 0, 0, 0, 22638, 22639, 7, 5, 0, 0, 22639, 22640, 7, 6, 0, 0, 22640, 22641, 7, 24, 0, 0, 22641, 22642, 7, 12, 0, 0, 22642, 22643, 7, 6, 0, 0, 22643, 22644, 7, 7, 0, 0, 22644, 22645, 7, 8, 0, 0, 22645, 22646, 7, 6, 0, 0, 22646, 22647, 7, 9, 0, 0, 22647, 3304, 1, 0, 0, 0, 22648, 22649, 7, 5, 0, 0, 22649, 22650, 7, 6, 0, 0, 22650, 22651, 7, 24, 0, 0, 22651, 22652, 7, 12, 0, 0, 22652, 22653, 7, 6, 0, 0, 22653, 22654, 7, 7, 0, 0, 22654, 22655, 7, 8, 0, 0, 22655, 22656, 7, 6, 0, 0, 22656, 3306, 1, 0, 0, 0, 22657, 22658, 7, 5, 0, 0, 22658, 22659, 7, 6, 0, 0, 22659, 22660, 7, 24, 0, 0, 22660, 22661, 7, 12, 0, 0, 22661, 22662, 7, 6, 0, 0, 22662, 22663, 7, 7, 0, 0, 22663, 22664, 7, 8, 0, 0, 22664, 22665, 7, 6, 0, 0, 22665, 22666, 7, 16, 0, 0, 22666, 22667, 7, 10, 0, 0, 22667, 22668, 7, 11, 0, 0, 22668, 22669, 7, 6, 0, 0, 22669, 3308, 1, 0, 0, 0, 22670, 22671, 7, 5, 0, 0, 22671, 22672, 7, 6, 0, 0, 22672, 22673, 7, 24, 0, 0, 22673, 22674, 7, 12, 0, 0, 22674, 22675, 7, 6, 0, 0, 22675, 22676, 7, 7, 0, 0, 22676, 22677, 7, 4, 0, 0, 22677, 22678, 7, 10, 0, 0, 22678, 22679, 7, 0, 0, 0, 22679, 22680, 7, 11, 0, 0, 22680, 3310, 1, 0, 0, 0, 22681, 22682, 7, 5, 0, 0, 22682, 22683, 7, 6, 0, 0, 22683, 22684, 7, 24, 0, 0, 22684, 3312, 1, 0, 0, 0, 22685, 22686, 7, 5, 0, 0, 22686, 22687, 7, 6, 0, 0, 22687, 22688, 7, 3, 0, 0, 22688, 22689, 7, 9, 0, 0, 22689, 22690, 7, 6, 0, 0, 22690, 3314, 1, 0, 0, 0, 22691, 22692, 7, 5, 0, 0, 22692, 22693, 7, 6, 0, 0, 22693, 22694, 7, 3, 0, 0, 22694, 22695, 7, 9, 0, 0, 22695, 22696, 7, 6, 0, 0, 22696, 22697, 7, 15, 0, 0, 22697, 22698, 7, 3, 0, 0, 22698, 22699, 7, 2, 0, 0, 22699, 22700, 7, 15, 0, 0, 22700, 22701, 7, 6, 0, 0, 22701, 22702, 7, 3, 0, 0, 22702, 22703, 7, 4, 0, 0, 22703, 22704, 7, 10, 0, 0, 22704, 22705, 7, 6, 0, 0, 22705, 22706, 7, 5, 0, 0, 22706, 3316, 1, 0, 0, 0, 22707, 22708, 7, 5, 0, 0, 22708, 22709, 7, 6, 0, 0, 22709, 22710, 7, 3, 0, 0, 22710, 22711, 7, 10, 0, 0, 22711, 22712, 7, 0, 0, 0, 22712, 22713, 7, 11, 0, 0, 22713, 22714, 7, 10, 0, 0, 22714, 22715, 7, 23, 0, 0, 22715, 22716, 7, 0, 0, 0, 22716, 22717, 7, 1, 0, 0, 22717, 22718, 7, 11, 0, 0, 22718, 22719, 7, 6, 0, 0, 22719, 3318, 1, 0, 0, 0, 22720, 22721, 7, 5, 0, 0, 22721, 22722, 7, 6, 0, 0, 22722, 22723, 7, 3, 0, 0, 22723, 22724, 7, 10, 0, 0, 22724, 22725, 7, 0, 0, 0, 22725, 22726, 7, 11, 0, 0, 22726, 22727, 7, 11, 0, 0, 22727, 22728, 7, 18, 0, 0, 22728, 22729, 5, 95, 0, 0, 22729, 22730, 7, 3, 0, 0, 22730, 22731, 7, 6, 0, 0, 22731, 22732, 7, 12, 0, 0, 22732, 22733, 7, 5, 0, 0, 22733, 22734, 7, 0, 0, 0, 22734, 22735, 7, 1, 0, 0, 22735, 22736, 7, 11, 0, 0, 22736, 22737, 7, 6, 0, 0, 22737, 3320, 1, 0, 0, 0, 22738, 22739, 7, 5, 0, 0, 22739, 22740, 7, 6, 0, 0, 22740, 22741, 7, 3, 0, 0, 22741, 22742, 7, 10, 0, 0, 22742, 22743, 7, 0, 0, 0, 22743, 22744, 7, 11, 0, 0, 22744, 3322, 1, 0, 0, 0, 22745, 22746, 7, 5, 0, 0, 22746, 22747, 7, 6, 0, 0, 22747, 22748, 7, 3, 0, 0, 22748, 22749, 7, 13, 0, 0, 22749, 22750, 7, 6, 0, 0, 22750, 22751, 7, 3, 0, 0, 22751, 22752, 7, 6, 0, 0, 22752, 22753, 7, 3, 0, 0, 22753, 22754, 7, 3, 0, 0, 22754, 22755, 7, 2, 0, 0, 22755, 22756, 7, 3, 0, 0, 22756, 3324, 1, 0, 0, 0, 22757, 22758, 7, 5, 0, 0, 22758, 22759, 7, 6, 0, 0, 22759, 22760, 7, 3, 0, 0, 22760, 22761, 7, 13, 0, 0, 22761, 22762, 7, 10, 0, 0, 22762, 22763, 7, 8, 0, 0, 22763, 22764, 7, 6, 0, 0, 22764, 22765, 5, 95, 0, 0, 22765, 22766, 7, 7, 0, 0, 22766, 22767, 7, 0, 0, 0, 22767, 22768, 7, 14, 0, 0, 22768, 22769, 7, 6, 0, 0, 22769, 22770, 5, 95, 0, 0, 22770, 22771, 7, 8, 0, 0, 22771, 22772, 7, 2, 0, 0, 22772, 22773, 7, 7, 0, 0, 22773, 22774, 7, 13, 0, 0, 22774, 22775, 7, 6, 0, 0, 22775, 22776, 7, 3, 0, 0, 22776, 22777, 7, 4, 0, 0, 22777, 3326, 1, 0, 0, 0, 22778, 22779, 7, 5, 0, 0, 22779, 22780, 7, 6, 0, 0, 22780, 22781, 7, 3, 0, 0, 22781, 22782, 7, 13, 0, 0, 22782, 22783, 7, 10, 0, 0, 22783, 22784, 7, 8, 0, 0, 22784, 22785, 7, 6, 0, 0, 22785, 3328, 1, 0, 0, 0, 22786, 22787, 7, 5, 0, 0, 22787, 22788, 7, 6, 0, 0, 22788, 22789, 7, 3, 0, 0, 22789, 22790, 7, 13, 0, 0, 22790, 22791, 7, 10, 0, 0, 22791, 22792, 7, 8, 0, 0, 22792, 22793, 7, 6, 0, 0, 22793, 22794, 7, 5, 0, 0, 22794, 3330, 1, 0, 0, 0, 22795, 22796, 7, 5, 0, 0, 22796, 22797, 7, 6, 0, 0, 22797, 22798, 7, 5, 0, 0, 22798, 22799, 7, 5, 0, 0, 22799, 22800, 7, 10, 0, 0, 22800, 22801, 7, 2, 0, 0, 22801, 22802, 7, 7, 0, 0, 22802, 22803, 5, 95, 0, 0, 22803, 22804, 7, 8, 0, 0, 22804, 22805, 7, 0, 0, 0, 22805, 22806, 7, 8, 0, 0, 22806, 22807, 7, 19, 0, 0, 22807, 22808, 7, 6, 0, 0, 22808, 22809, 7, 9, 0, 0, 22809, 22810, 5, 95, 0, 0, 22810, 22811, 7, 8, 0, 0, 22811, 22812, 7, 12, 0, 0, 22812, 22813, 7, 3, 0, 0, 22813, 22814, 7, 5, 0, 0, 22814, 22815, 7, 2, 0, 0, 22815, 22816, 7, 3, 0, 0, 22816, 22817, 7, 5, 0, 0, 22817, 3332, 1, 0, 0, 0, 22818, 22819, 7, 5, 0, 0, 22819, 22820, 7, 6, 0, 0, 22820, 22821, 7, 5, 0, 0, 22821, 22822, 7, 5, 0, 0, 22822, 22823, 7, 10, 0, 0, 22823, 22824, 7, 2, 0, 0, 22824, 22825, 7, 7, 0, 0, 22825, 3334, 1, 0, 0, 0, 22826, 22827, 7, 5, 0, 0, 22827, 22828, 7, 6, 0, 0, 22828, 22829, 7, 5, 0, 0, 22829, 22830, 7, 5, 0, 0, 22830, 22831, 7, 10, 0, 0, 22831, 22832, 7, 2, 0, 0, 22832, 22833, 7, 7, 0, 0, 22833, 22834, 7, 5, 0, 0, 22834, 22835, 5, 95, 0, 0, 22835, 22836, 7, 15, 0, 0, 22836, 22837, 7, 6, 0, 0, 22837, 22838, 7, 3, 0, 0, 22838, 22839, 5, 95, 0, 0, 22839, 22840, 7, 12, 0, 0, 22840, 22841, 7, 5, 0, 0, 22841, 22842, 7, 6, 0, 0, 22842, 22843, 7, 3, 0, 0, 22843, 3336, 1, 0, 0, 0, 22844, 22845, 7, 5, 0, 0, 22845, 22846, 7, 6, 0, 0, 22846, 22847, 7, 5, 0, 0, 22847, 22848, 7, 5, 0, 0, 22848, 22849, 7, 10, 0, 0, 22849, 22850, 7, 2, 0, 0, 22850, 22851, 7, 7, 0, 0, 22851, 22852, 7, 4, 0, 0, 22852, 22853, 7, 10, 0, 0, 22853, 22854, 7, 14, 0, 0, 22854, 22855, 7, 6, 0, 0, 22855, 22856, 7, 23, 0, 0, 22856, 22857, 7, 2, 0, 0, 22857, 22858, 7, 7, 0, 0, 22858, 22859, 7, 6, 0, 0, 22859, 3338, 1, 0, 0, 0, 22860, 22861, 7, 5, 0, 0, 22861, 22862, 7, 6, 0, 0, 22862, 22863, 7, 5, 0, 0, 22863, 22864, 7, 5, 0, 0, 22864, 22865, 7, 10, 0, 0, 22865, 22866, 7, 2, 0, 0, 22866, 22867, 7, 7, 0, 0, 22867, 22868, 7, 4, 0, 0, 22868, 22869, 7, 23, 0, 0, 22869, 22870, 7, 7, 0, 0, 22870, 22871, 7, 0, 0, 0, 22871, 22872, 7, 14, 0, 0, 22872, 22873, 7, 6, 0, 0, 22873, 3340, 1, 0, 0, 0, 22874, 22875, 7, 5, 0, 0, 22875, 22876, 7, 6, 0, 0, 22876, 22877, 7, 4, 0, 0, 22877, 3342, 1, 0, 0, 0, 22878, 22879, 7, 5, 0, 0, 22879, 22880, 7, 6, 0, 0, 22880, 22881, 7, 4, 0, 0, 22881, 22882, 7, 5, 0, 0, 22882, 3344, 1, 0, 0, 0, 22883, 22884, 7, 5, 0, 0, 22884, 22885, 7, 6, 0, 0, 22885, 22886, 7, 4, 0, 0, 22886, 22887, 7, 4, 0, 0, 22887, 22888, 7, 10, 0, 0, 22888, 22889, 7, 7, 0, 0, 22889, 22890, 7, 17, 0, 0, 22890, 22891, 7, 5, 0, 0, 22891, 3346, 1, 0, 0, 0, 22892, 22893, 7, 5, 0, 0, 22893, 22894, 7, 6, 0, 0, 22894, 22895, 7, 4, 0, 0, 22895, 22896, 5, 95, 0, 0, 22896, 22897, 7, 4, 0, 0, 22897, 22898, 7, 2, 0, 0, 22898, 22899, 5, 95, 0, 0, 22899, 22900, 7, 20, 0, 0, 22900, 22901, 7, 2, 0, 0, 22901, 22902, 7, 10, 0, 0, 22902, 22903, 7, 7, 0, 0, 22903, 3348, 1, 0, 0, 0, 22904, 22905, 7, 5, 0, 0, 22905, 22906, 7, 6, 0, 0, 22906, 22907, 7, 13, 0, 0, 22907, 22908, 7, 6, 0, 0, 22908, 22909, 7, 3, 0, 0, 22909, 22910, 7, 6, 0, 0, 22910, 3350, 1, 0, 0, 0, 22911, 22912, 7, 5, 0, 0, 22912, 22913, 7, 19, 0, 0, 22913, 22914, 7, 0, 0, 0, 22914, 22915, 7, 3, 0, 0, 22915, 22916, 7, 9, 0, 0, 22916, 3352, 1, 0, 0, 0, 22917, 22918, 7, 5, 0, 0, 22918, 22919, 7, 19, 0, 0, 22919, 22920, 7, 0, 0, 0, 22920, 22921, 7, 3, 0, 0, 22921, 22922, 7, 9, 0, 0, 22922, 22923, 7, 5, 0, 0, 22923, 22924, 7, 15, 0, 0, 22924, 22925, 7, 0, 0, 0, 22925, 22926, 7, 8, 0, 0, 22926, 22927, 7, 6, 0, 0, 22927, 3354, 1, 0, 0, 0, 22928, 22929, 7, 5, 0, 0, 22929, 22930, 7, 19, 0, 0, 22930, 22931, 7, 0, 0, 0, 22931, 22932, 7, 3, 0, 0, 22932, 22933, 7, 6, 0, 0, 22933, 22934, 7, 9, 0, 0, 22934, 22935, 5, 95, 0, 0, 22935, 22936, 7, 15, 0, 0, 22936, 22937, 7, 2, 0, 0, 22937, 22938, 7, 2, 0, 0, 22938, 22939, 7, 11, 0, 0, 22939, 3356, 1, 0, 0, 0, 22940, 22941, 7, 5, 0, 0, 22941, 22942, 7, 19, 0, 0, 22942, 22943, 7, 0, 0, 0, 22943, 22944, 7, 3, 0, 0, 22944, 22945, 7, 6, 0, 0, 22945, 22946, 7, 9, 0, 0, 22946, 3358, 1, 0, 0, 0, 22947, 22948, 7, 5, 0, 0, 22948, 22949, 7, 19, 0, 0, 22949, 22950, 7, 0, 0, 0, 22950, 22951, 7, 3, 0, 0, 22951, 22952, 7, 6, 0, 0, 22952, 3360, 1, 0, 0, 0, 22953, 22954, 7, 5, 0, 0, 22954, 22955, 7, 19, 0, 0, 22955, 22956, 7, 0, 0, 0, 22956, 22957, 7, 3, 0, 0, 22957, 22958, 7, 10, 0, 0, 22958, 22959, 7, 7, 0, 0, 22959, 22960, 7, 17, 0, 0, 22960, 3362, 1, 0, 0, 0, 22961, 22962, 7, 5, 0, 0, 22962, 22963, 7, 19, 0, 0, 22963, 22964, 7, 6, 0, 0, 22964, 22965, 7, 11, 0, 0, 22965, 22966, 7, 16, 0, 0, 22966, 22967, 7, 11, 0, 0, 22967, 22968, 7, 10, 0, 0, 22968, 22969, 7, 16, 0, 0, 22969, 22970, 7, 6, 0, 0, 22970, 3364, 1, 0, 0, 0, 22971, 22972, 7, 5, 0, 0, 22972, 22973, 7, 19, 0, 0, 22973, 22974, 7, 2, 0, 0, 22974, 22975, 7, 22, 0, 0, 22975, 3366, 1, 0, 0, 0, 22976, 22977, 7, 5, 0, 0, 22977, 22978, 7, 19, 0, 0, 22978, 22979, 7, 3, 0, 0, 22979, 22980, 7, 10, 0, 0, 22980, 22981, 7, 7, 0, 0, 22981, 22982, 7, 21, 0, 0, 22982, 3368, 1, 0, 0, 0, 22983, 22984, 7, 5, 0, 0, 22984, 22985, 7, 19, 0, 0, 22985, 22986, 7, 12, 0, 0, 22986, 22987, 7, 4, 0, 0, 22987, 22988, 7, 9, 0, 0, 22988, 22989, 7, 2, 0, 0, 22989, 22990, 7, 22, 0, 0, 22990, 22991, 7, 7, 0, 0, 22991, 3370, 1, 0, 0, 0, 22992, 22993, 7, 5, 0, 0, 22993, 22994, 7, 10, 0, 0, 22994, 22995, 7, 1, 0, 0, 22995, 22996, 7, 11, 0, 0, 22996, 22997, 7, 10, 0, 0, 22997, 22998, 7, 7, 0, 0, 22998, 22999, 7, 17, 0, 0, 22999, 23000, 7, 5, 0, 0, 23000, 3372, 1, 0, 0, 0, 23001, 23002, 7, 5, 0, 0, 23002, 23003, 7, 10, 0, 0, 23003, 23004, 7, 9, 0, 0, 23004, 3374, 1, 0, 0, 0, 23005, 23006, 7, 5, 0, 0, 23006, 23007, 7, 10, 0, 0, 23007, 23008, 7, 4, 0, 0, 23008, 23009, 7, 6, 0, 0, 23009, 3376, 1, 0, 0, 0, 23010, 23011, 7, 5, 0, 0, 23011, 23012, 7, 10, 0, 0, 23012, 23013, 7, 17, 0, 0, 23013, 23014, 7, 7, 0, 0, 23014, 23015, 7, 0, 0, 0, 23015, 23016, 7, 11, 0, 0, 23016, 23017, 5, 95, 0, 0, 23017, 23018, 7, 8, 0, 0, 23018, 23019, 7, 2, 0, 0, 23019, 23020, 7, 14, 0, 0, 23020, 23021, 7, 15, 0, 0, 23021, 23022, 7, 2, 0, 0, 23022, 23023, 7, 7, 0, 0, 23023, 23024, 7, 6, 0, 0, 23024, 23025, 7, 7, 0, 0, 23025, 23026, 7, 4, 0, 0, 23026, 3378, 1, 0, 0, 0, 23027, 23028, 7, 5, 0, 0, 23028, 23029, 7, 10, 0, 0, 23029, 23030, 7, 17, 0, 0, 23030, 23031, 7, 7, 0, 0, 23031, 23032, 7, 0, 0, 0, 23032, 23033, 7, 11, 0, 0, 23033, 23034, 5, 95, 0, 0, 23034, 23035, 7, 16, 0, 0, 23035, 23036, 7, 12, 0, 0, 23036, 23037, 7, 7, 0, 0, 23037, 23038, 7, 8, 0, 0, 23038, 23039, 7, 4, 0, 0, 23039, 23040, 7, 10, 0, 0, 23040, 23041, 7, 2, 0, 0, 23041, 23042, 7, 7, 0, 0, 23042, 3380, 1, 0, 0, 0, 23043, 23044, 7, 5, 0, 0, 23044, 23045, 7, 10, 0, 0, 23045, 23046, 7, 17, 0, 0, 23046, 23047, 7, 7, 0, 0, 23047, 3382, 1, 0, 0, 0, 23048, 23049, 7, 5, 0, 0, 23049, 23050, 7, 10, 0, 0, 23050, 23051, 7, 17, 0, 0, 23051, 23052, 7, 7, 0, 0, 23052, 23053, 7, 4, 0, 0, 23053, 23054, 7, 18, 0, 0, 23054, 23055, 7, 15, 0, 0, 23055, 23056, 7, 6, 0, 0, 23056, 3384, 1, 0, 0, 0, 23057, 23058, 7, 5, 0, 0, 23058, 23059, 7, 10, 0, 0, 23059, 23060, 7, 14, 0, 0, 23060, 23061, 7, 15, 0, 0, 23061, 23062, 7, 11, 0, 0, 23062, 23063, 7, 6, 0, 0, 23063, 23064, 5, 95, 0, 0, 23064, 23065, 7, 10, 0, 0, 23065, 23066, 7, 7, 0, 0, 23066, 23067, 7, 4, 0, 0, 23067, 23068, 7, 6, 0, 0, 23068, 23069, 7, 17, 0, 0, 23069, 23070, 7, 6, 0, 0, 23070, 23071, 7, 3, 0, 0, 23071, 3386, 1, 0, 0, 0, 23072, 23073, 7, 5, 0, 0, 23073, 23074, 7, 10, 0, 0, 23074, 23075, 7, 14, 0, 0, 23075, 23076, 7, 15, 0, 0, 23076, 23077, 7, 11, 0, 0, 23077, 23078, 7, 6, 0, 0, 23078, 3388, 1, 0, 0, 0, 23079, 23080, 7, 5, 0, 0, 23080, 23081, 7, 10, 0, 0, 23081, 23082, 7, 7, 0, 0, 23082, 23083, 7, 17, 0, 0, 23083, 23084, 7, 11, 0, 0, 23084, 23085, 7, 6, 0, 0, 23085, 3390, 1, 0, 0, 0, 23086, 23087, 7, 5, 0, 0, 23087, 23088, 7, 10, 0, 0, 23088, 23089, 7, 7, 0, 0, 23089, 23090, 7, 17, 0, 0, 23090, 23091, 7, 11, 0, 0, 23091, 23092, 7, 6, 0, 0, 23092, 23093, 7, 4, 0, 0, 23093, 23094, 7, 0, 0, 0, 23094, 23095, 7, 5, 0, 0, 23095, 23096, 7, 21, 0, 0, 23096, 3392, 1, 0, 0, 0, 23097, 23098, 7, 5, 0, 0, 23098, 23099, 7, 10, 0, 0, 23099, 23100, 7, 7, 0, 0, 23100, 23101, 7, 19, 0, 0, 23101, 3394, 1, 0, 0, 0, 23102, 23103, 7, 5, 0, 0, 23103, 23104, 7, 10, 0, 0, 23104, 23105, 7, 7, 0, 0, 23105, 3396, 1, 0, 0, 0, 23106, 23107, 7, 5, 0, 0, 23107, 23108, 7, 10, 0, 0, 23108, 23109, 7, 23, 0, 0, 23109, 23110, 7, 6, 0, 0, 23110, 3398, 1, 0, 0, 0, 23111, 23112, 7, 5, 0, 0, 23112, 23113, 7, 10, 0, 0, 23113, 23114, 7, 23, 0, 0, 23114, 23115, 7, 6, 0, 0, 23115, 23116, 7, 5, 0, 0, 23116, 3400, 1, 0, 0, 0, 23117, 23118, 7, 5, 0, 0, 23118, 23119, 7, 21, 0, 0, 23119, 23120, 7, 10, 0, 0, 23120, 23121, 7, 15, 0, 0, 23121, 23122, 5, 95, 0, 0, 23122, 23123, 7, 6, 0, 0, 23123, 23124, 7, 25, 0, 0, 23124, 23125, 7, 4, 0, 0, 23125, 23126, 5, 95, 0, 0, 23126, 23127, 7, 2, 0, 0, 23127, 23128, 7, 15, 0, 0, 23128, 23129, 7, 4, 0, 0, 23129, 23130, 7, 10, 0, 0, 23130, 23131, 7, 14, 0, 0, 23131, 23132, 7, 10, 0, 0, 23132, 23133, 7, 23, 0, 0, 23133, 23134, 7, 6, 0, 0, 23134, 23135, 7, 3, 0, 0, 23135, 3402, 1, 0, 0, 0, 23136, 23137, 7, 5, 0, 0, 23137, 23138, 7, 21, 0, 0, 23138, 23139, 7, 10, 0, 0, 23139, 23140, 7, 15, 0, 0, 23140, 3404, 1, 0, 0, 0, 23141, 23142, 7, 5, 0, 0, 23142, 23143, 7, 21, 0, 0, 23143, 23144, 7, 10, 0, 0, 23144, 23145, 7, 15, 0, 0, 23145, 23146, 5, 95, 0, 0, 23146, 23147, 7, 12, 0, 0, 23147, 23148, 7, 7, 0, 0, 23148, 23149, 7, 24, 0, 0, 23149, 23150, 5, 95, 0, 0, 23150, 23151, 7, 12, 0, 0, 23151, 23152, 7, 7, 0, 0, 23152, 23153, 7, 12, 0, 0, 23153, 23154, 7, 5, 0, 0, 23154, 23155, 7, 0, 0, 0, 23155, 23156, 7, 1, 0, 0, 23156, 23157, 7, 11, 0, 0, 23157, 23158, 7, 6, 0, 0, 23158, 23159, 5, 95, 0, 0, 23159, 23160, 7, 10, 0, 0, 23160, 23161, 7, 9, 0, 0, 23161, 23162, 7, 25, 0, 0, 23162, 3406, 1, 0, 0, 0, 23163, 23164, 7, 5, 0, 0, 23164, 23165, 7, 21, 0, 0, 23165, 23166, 7, 10, 0, 0, 23166, 23167, 7, 15, 0, 0, 23167, 23168, 5, 95, 0, 0, 23168, 23169, 7, 12, 0, 0, 23169, 23170, 7, 7, 0, 0, 23170, 23171, 7, 12, 0, 0, 23171, 23172, 7, 5, 0, 0, 23172, 23173, 7, 0, 0, 0, 23173, 23174, 7, 1, 0, 0, 23174, 23175, 7, 11, 0, 0, 23175, 23176, 7, 6, 0, 0, 23176, 23177, 5, 95, 0, 0, 23177, 23178, 7, 10, 0, 0, 23178, 23179, 7, 7, 0, 0, 23179, 23180, 7, 9, 0, 0, 23180, 23181, 7, 6, 0, 0, 23181, 23182, 7, 25, 0, 0, 23182, 23183, 7, 6, 0, 0, 23183, 23184, 7, 5, 0, 0, 23184, 3408, 1, 0, 0, 0, 23185, 23186, 7, 5, 0, 0, 23186, 23187, 7, 14, 0, 0, 23187, 23188, 7, 0, 0, 0, 23188, 23189, 7, 11, 0, 0, 23189, 23190, 7, 11, 0, 0, 23190, 23191, 7, 16, 0, 0, 23191, 23192, 7, 10, 0, 0, 23192, 23193, 7, 11, 0, 0, 23193, 23194, 7, 6, 0, 0, 23194, 3410, 1, 0, 0, 0, 23195, 23196, 7, 5, 0, 0, 23196, 23197, 7, 14, 0, 0, 23197, 23198, 7, 0, 0, 0, 23198, 23199, 7, 11, 0, 0, 23199, 23200, 7, 11, 0, 0, 23200, 23201, 7, 10, 0, 0, 23201, 23202, 7, 7, 0, 0, 23202, 23203, 7, 4, 0, 0, 23203, 3412, 1, 0, 0, 0, 23204, 23205, 7, 5, 0, 0, 23205, 23206, 7, 7, 0, 0, 23206, 23207, 7, 0, 0, 0, 23207, 23208, 7, 15, 0, 0, 23208, 23209, 7, 5, 0, 0, 23209, 23210, 7, 19, 0, 0, 23210, 23211, 7, 2, 0, 0, 23211, 23212, 7, 4, 0, 0, 23212, 3414, 1, 0, 0, 0, 23213, 23214, 7, 5, 0, 0, 23214, 23215, 7, 2, 0, 0, 23215, 23216, 7, 14, 0, 0, 23216, 23217, 7, 6, 0, 0, 23217, 3416, 1, 0, 0, 0, 23218, 23219, 7, 5, 0, 0, 23219, 23220, 7, 2, 0, 0, 23220, 23221, 7, 3, 0, 0, 23221, 23222, 7, 4, 0, 0, 23222, 3418, 1, 0, 0, 0, 23223, 23224, 7, 5, 0, 0, 23224, 23225, 7, 2, 0, 0, 23225, 23226, 7, 12, 0, 0, 23226, 23227, 7, 7, 0, 0, 23227, 23228, 7, 9, 0, 0, 23228, 23229, 7, 6, 0, 0, 23229, 23230, 7, 25, 0, 0, 23230, 3420, 1, 0, 0, 0, 23231, 23232, 7, 5, 0, 0, 23232, 23233, 7, 2, 0, 0, 23233, 23234, 7, 12, 0, 0, 23234, 23235, 7, 3, 0, 0, 23235, 23236, 7, 8, 0, 0, 23236, 23237, 7, 6, 0, 0, 23237, 23238, 5, 95, 0, 0, 23238, 23239, 7, 16, 0, 0, 23239, 23240, 7, 10, 0, 0, 23240, 23241, 7, 11, 0, 0, 23241, 23242, 7, 6, 0, 0, 23242, 23243, 5, 95, 0, 0, 23243, 23244, 7, 9, 0, 0, 23244, 23245, 7, 10, 0, 0, 23245, 23246, 7, 3, 0, 0, 23246, 23247, 7, 6, 0, 0, 23247, 23248, 7, 8, 0, 0, 23248, 23249, 7, 4, 0, 0, 23249, 23250, 7, 2, 0, 0, 23250, 23251, 7, 3, 0, 0, 23251, 23252, 7, 18, 0, 0, 23252, 3422, 1, 0, 0, 0, 23253, 23254, 7, 5, 0, 0, 23254, 23255, 7, 2, 0, 0, 23255, 23256, 7, 12, 0, 0, 23256, 23257, 7, 3, 0, 0, 23257, 23258, 7, 8, 0, 0, 23258, 23259, 7, 6, 0, 0, 23259, 23260, 5, 95, 0, 0, 23260, 23261, 7, 16, 0, 0, 23261, 23262, 7, 10, 0, 0, 23262, 23263, 7, 11, 0, 0, 23263, 23264, 7, 6, 0, 0, 23264, 23265, 5, 95, 0, 0, 23265, 23266, 7, 7, 0, 0, 23266, 23267, 7, 0, 0, 0, 23267, 23268, 7, 14, 0, 0, 23268, 23269, 7, 6, 0, 0, 23269, 23270, 5, 95, 0, 0, 23270, 23271, 7, 8, 0, 0, 23271, 23272, 7, 2, 0, 0, 23272, 23273, 7, 7, 0, 0, 23273, 23274, 7, 13, 0, 0, 23274, 23275, 7, 6, 0, 0, 23275, 23276, 7, 3, 0, 0, 23276, 23277, 7, 4, 0, 0, 23277, 3424, 1, 0, 0, 0, 23278, 23279, 7, 5, 0, 0, 23279, 23280, 7, 2, 0, 0, 23280, 23281, 7, 12, 0, 0, 23281, 23282, 7, 3, 0, 0, 23282, 23283, 7, 8, 0, 0, 23283, 23284, 7, 6, 0, 0, 23284, 3426, 1, 0, 0, 0, 23285, 23286, 7, 5, 0, 0, 23286, 23287, 7, 15, 0, 0, 23287, 23288, 7, 0, 0, 0, 23288, 23289, 7, 8, 0, 0, 23289, 23290, 7, 6, 0, 0, 23290, 3428, 1, 0, 0, 0, 23291, 23292, 7, 5, 0, 0, 23292, 23293, 7, 15, 0, 0, 23293, 23294, 7, 6, 0, 0, 23294, 23295, 7, 8, 0, 0, 23295, 23296, 7, 10, 0, 0, 23296, 23297, 7, 16, 0, 0, 23297, 23298, 7, 10, 0, 0, 23298, 23299, 7, 8, 0, 0, 23299, 23300, 7, 0, 0, 0, 23300, 23301, 7, 4, 0, 0, 23301, 23302, 7, 10, 0, 0, 23302, 23303, 7, 2, 0, 0, 23303, 23304, 7, 7, 0, 0, 23304, 3430, 1, 0, 0, 0, 23305, 23306, 7, 5, 0, 0, 23306, 23307, 7, 15, 0, 0, 23307, 23308, 7, 16, 0, 0, 23308, 23309, 7, 10, 0, 0, 23309, 23310, 7, 11, 0, 0, 23310, 23311, 7, 6, 0, 0, 23311, 3432, 1, 0, 0, 0, 23312, 23313, 7, 5, 0, 0, 23313, 23314, 7, 15, 0, 0, 23314, 23315, 7, 11, 0, 0, 23315, 23316, 7, 10, 0, 0, 23316, 23317, 7, 4, 0, 0, 23317, 3434, 1, 0, 0, 0, 23318, 23319, 7, 5, 0, 0, 23319, 23320, 7, 15, 0, 0, 23320, 23321, 7, 3, 0, 0, 23321, 23322, 7, 6, 0, 0, 23322, 23323, 7, 0, 0, 0, 23323, 23324, 7, 9, 0, 0, 23324, 23325, 7, 5, 0, 0, 23325, 23326, 7, 19, 0, 0, 23326, 23327, 7, 6, 0, 0, 23327, 23328, 7, 6, 0, 0, 23328, 23329, 7, 4, 0, 0, 23329, 3436, 1, 0, 0, 0, 23330, 23331, 7, 5, 0, 0, 23331, 23332, 7, 24, 0, 0, 23332, 23333, 7, 11, 0, 0, 23333, 23334, 7, 9, 0, 0, 23334, 23335, 7, 0, 0, 0, 23335, 23336, 7, 4, 0, 0, 23336, 23337, 7, 0, 0, 0, 23337, 3438, 1, 0, 0, 0, 23338, 23339, 7, 5, 0, 0, 23339, 23340, 7, 24, 0, 0, 23340, 23341, 7, 11, 0, 0, 23341, 23342, 7, 6, 0, 0, 23342, 23343, 7, 3, 0, 0, 23343, 23344, 7, 3, 0, 0, 23344, 23345, 7, 2, 0, 0, 23345, 23346, 7, 3, 0, 0, 23346, 3440, 1, 0, 0, 0, 23347, 23348, 7, 5, 0, 0, 23348, 23349, 7, 24, 0, 0, 23349, 23350, 7, 11, 0, 0, 23350, 23351, 7, 11, 0, 0, 23351, 23352, 7, 9, 0, 0, 23352, 23353, 7, 3, 0, 0, 23353, 3442, 1, 0, 0, 0, 23354, 23355, 7, 5, 0, 0, 23355, 23356, 7, 24, 0, 0, 23356, 23357, 7, 11, 0, 0, 23357, 3444, 1, 0, 0, 0, 23358, 23359, 7, 16, 0, 0, 23359, 23360, 7, 7, 0, 0, 23360, 23376, 7, 8, 0, 0, 23361, 23362, 7, 15, 0, 0, 23362, 23363, 7, 21, 0, 0, 23363, 23376, 7, 1, 0, 0, 23364, 23365, 7, 15, 0, 0, 23365, 23366, 7, 21, 0, 0, 23366, 23376, 7, 5, 0, 0, 23367, 23368, 7, 15, 0, 0, 23368, 23369, 7, 3, 0, 0, 23369, 23376, 7, 8, 0, 0, 23370, 23371, 7, 4, 0, 0, 23371, 23372, 7, 3, 0, 0, 23372, 23376, 7, 17, 0, 0, 23373, 23374, 7, 13, 0, 0, 23374, 23376, 7, 22, 0, 0, 23375, 23358, 1, 0, 0, 0, 23375, 23361, 1, 0, 0, 0, 23375, 23364, 1, 0, 0, 0, 23375, 23367, 1, 0, 0, 0, 23375, 23370, 1, 0, 0, 0, 23375, 23373, 1, 0, 0, 0, 23376, 3446, 1, 0, 0, 0, 23377, 23378, 7, 5, 0, 0, 23378, 23379, 7, 24, 0, 0, 23379, 23380, 7, 11, 0, 0, 23380, 23381, 5, 95, 0, 0, 23381, 23382, 7, 14, 0, 0, 23382, 23383, 7, 0, 0, 0, 23383, 23384, 7, 8, 0, 0, 23384, 23385, 7, 3, 0, 0, 23385, 23386, 7, 2, 0, 0, 23386, 3448, 1, 0, 0, 0, 23387, 23388, 7, 5, 0, 0, 23388, 23389, 7, 24, 0, 0, 23389, 23390, 7, 11, 0, 0, 23390, 23391, 5, 95, 0, 0, 23391, 23392, 7, 4, 0, 0, 23392, 23393, 7, 3, 0, 0, 23393, 23394, 7, 0, 0, 0, 23394, 23395, 7, 8, 0, 0, 23395, 23396, 7, 6, 0, 0, 23396, 3450, 1, 0, 0, 0, 23397, 23398, 7, 5, 0, 0, 23398, 23399, 7, 24, 0, 0, 23399, 23400, 7, 11, 0, 0, 23400, 23401, 5, 95, 0, 0, 23401, 23402, 7, 4, 0, 0, 23402, 23403, 7, 3, 0, 0, 23403, 23404, 7, 0, 0, 0, 23404, 23405, 7, 7, 0, 0, 23405, 23406, 7, 5, 0, 0, 23406, 23407, 7, 11, 0, 0, 23407, 23408, 7, 0, 0, 0, 23408, 23409, 7, 4, 0, 0, 23409, 23410, 7, 10, 0, 0, 23410, 23411, 7, 2, 0, 0, 23411, 23412, 7, 7, 0, 0, 23412, 23413, 5, 95, 0, 0, 23413, 23414, 7, 15, 0, 0, 23414, 23415, 7, 3, 0, 0, 23415, 23416, 7, 2, 0, 0, 23416, 23417, 7, 16, 0, 0, 23417, 23418, 7, 10, 0, 0, 23418, 23419, 7, 11, 0, 0, 23419, 23420, 7, 6, 0, 0, 23420, 3452, 1, 0, 0, 0, 23421, 23422, 7, 5, 0, 0, 23422, 23423, 7, 24, 0, 0, 23423, 23424, 7, 3, 0, 0, 23424, 23425, 7, 4, 0, 0, 23425, 3454, 1, 0, 0, 0, 23426, 23427, 7, 5, 0, 0, 23427, 23428, 7, 4, 0, 0, 23428, 23429, 7, 0, 0, 0, 23429, 23430, 7, 11, 0, 0, 23430, 23431, 7, 6, 0, 0, 23431, 3456, 1, 0, 0, 0, 23432, 23433, 7, 5, 0, 0, 23433, 23434, 7, 4, 0, 0, 23434, 23435, 7, 0, 0, 0, 23435, 23436, 7, 7, 0, 0, 23436, 23437, 7, 9, 0, 0, 23437, 23438, 7, 0, 0, 0, 23438, 23439, 7, 11, 0, 0, 23439, 23440, 7, 2, 0, 0, 23440, 23441, 7, 7, 0, 0, 23441, 23442, 7, 6, 0, 0, 23442, 3458, 1, 0, 0, 0, 23443, 23444, 7, 5, 0, 0, 23444, 23445, 7, 4, 0, 0, 23445, 23446, 7, 0, 0, 0, 23446, 23447, 7, 7, 0, 0, 23447, 23448, 7, 9, 0, 0, 23448, 23449, 7, 0, 0, 0, 23449, 23450, 7, 3, 0, 0, 23450, 23451, 7, 9, 0, 0, 23451, 3460, 1, 0, 0, 0, 23452, 23453, 7, 5, 0, 0, 23453, 23454, 7, 4, 0, 0, 23454, 23455, 7, 0, 0, 0, 23455, 23456, 7, 7, 0, 0, 23456, 23457, 7, 9, 0, 0, 23457, 23458, 7, 0, 0, 0, 23458, 23459, 7, 3, 0, 0, 23459, 23460, 7, 9, 0, 0, 23460, 23461, 5, 95, 0, 0, 23461, 23462, 7, 19, 0, 0, 23462, 23463, 7, 0, 0, 0, 23463, 23464, 7, 5, 0, 0, 23464, 23465, 7, 19, 0, 0, 23465, 3462, 1, 0, 0, 0, 23466, 23467, 7, 5, 0, 0, 23467, 23468, 7, 4, 0, 0, 23468, 23469, 7, 0, 0, 0, 23469, 23470, 7, 7, 0, 0, 23470, 23471, 7, 9, 0, 0, 23471, 23472, 7, 1, 0, 0, 23472, 23473, 7, 18, 0, 0, 23473, 23474, 5, 95, 0, 0, 23474, 23475, 7, 14, 0, 0, 23475, 23476, 7, 0, 0, 0, 23476, 23477, 7, 25, 0, 0, 23477, 23478, 5, 95, 0, 0, 23478, 23479, 7, 9, 0, 0, 23479, 23480, 7, 0, 0, 0, 23480, 23481, 7, 4, 0, 0, 23481, 23482, 7, 0, 0, 0, 23482, 23483, 5, 95, 0, 0, 23483, 23484, 7, 9, 0, 0, 23484, 23485, 7, 6, 0, 0, 23485, 23486, 7, 11, 0, 0, 23486, 23487, 7, 0, 0, 0, 23487, 23488, 7, 18, 0, 0, 23488, 3464, 1, 0, 0, 0, 23489, 23490, 7, 5, 0, 0, 23490, 23491, 7, 4, 0, 0, 23491, 23492, 7, 0, 0, 0, 23492, 23493, 7, 7, 0, 0, 23493, 23494, 7, 9, 0, 0, 23494, 23495, 7, 1, 0, 0, 23495, 23496, 7, 18, 0, 0, 23496, 23497, 7, 5, 0, 0, 23497, 3466, 1, 0, 0, 0, 23498, 23499, 7, 5, 0, 0, 23499, 23500, 7, 4, 0, 0, 23500, 23501, 7, 0, 0, 0, 23501, 23502, 7, 7, 0, 0, 23502, 23503, 7, 9, 0, 0, 23503, 23504, 7, 1, 0, 0, 23504, 23505, 7, 18, 0, 0, 23505, 3468, 1, 0, 0, 0, 23506, 23507, 7, 5, 0, 0, 23507, 23508, 7, 4, 0, 0, 23508, 23509, 7, 0, 0, 0, 23509, 23510, 7, 3, 0, 0, 23510, 3470, 1, 0, 0, 0, 23511, 23512, 7, 5, 0, 0, 23512, 23513, 7, 4, 0, 0, 23513, 23514, 7, 0, 0, 0, 23514, 23515, 7, 3, 0, 0, 23515, 23516, 5, 95, 0, 0, 23516, 23517, 7, 4, 0, 0, 23517, 23518, 7, 3, 0, 0, 23518, 23519, 7, 0, 0, 0, 23519, 23520, 7, 7, 0, 0, 23520, 23521, 7, 5, 0, 0, 23521, 23522, 7, 16, 0, 0, 23522, 23523, 7, 2, 0, 0, 23523, 23524, 7, 3, 0, 0, 23524, 23525, 7, 14, 0, 0, 23525, 23526, 7, 0, 0, 0, 23526, 23527, 7, 4, 0, 0, 23527, 23528, 7, 10, 0, 0, 23528, 23529, 7, 2, 0, 0, 23529, 23530, 7, 7, 0, 0, 23530, 3472, 1, 0, 0, 0, 23531, 23532, 7, 5, 0, 0, 23532, 23533, 7, 4, 0, 0, 23533, 23534, 7, 0, 0, 0, 23534, 23535, 7, 3, 0, 0, 23535, 23536, 7, 4, 0, 0, 23536, 3474, 1, 0, 0, 0, 23537, 23538, 7, 5, 0, 0, 23538, 23539, 7, 4, 0, 0, 23539, 23540, 7, 0, 0, 0, 23540, 23541, 7, 3, 0, 0, 23541, 23542, 7, 4, 0, 0, 23542, 23543, 7, 2, 0, 0, 23543, 23544, 7, 16, 0, 0, 23544, 3476, 1, 0, 0, 0, 23545, 23546, 7, 5, 0, 0, 23546, 23547, 7, 4, 0, 0, 23547, 23548, 7, 0, 0, 0, 23548, 23549, 7, 3, 0, 0, 23549, 23550, 7, 4, 0, 0, 23550, 23551, 7, 12, 0, 0, 23551, 23552, 7, 15, 0, 0, 23552, 3478, 1, 0, 0, 0, 23553, 23554, 7, 5, 0, 0, 23554, 23555, 7, 4, 0, 0, 23555, 23556, 7, 0, 0, 0, 23556, 23557, 7, 4, 0, 0, 23557, 23558, 7, 6, 0, 0, 23558, 23559, 7, 14, 0, 0, 23559, 23560, 7, 6, 0, 0, 23560, 23561, 7, 7, 0, 0, 23561, 23562, 7, 4, 0, 0, 23562, 23563, 5, 95, 0, 0, 23563, 23564, 7, 10, 0, 0, 23564, 23565, 7, 9, 0, 0, 23565, 3480, 1, 0, 0, 0, 23566, 23567, 7, 5, 0, 0, 23567, 23568, 7, 4, 0, 0, 23568, 23569, 7, 0, 0, 0, 23569, 23570, 7, 4, 0, 0, 23570, 23571, 7, 6, 0, 0, 23571, 23572, 7, 14, 0, 0, 23572, 23573, 7, 6, 0, 0, 23573, 23574, 7, 7, 0, 0, 23574, 23575, 7, 4, 0, 0, 23575, 23576, 5, 95, 0, 0, 23576, 23577, 7, 24, 0, 0, 23577, 23578, 7, 12, 0, 0, 23578, 23579, 7, 6, 0, 0, 23579, 23580, 7, 12, 0, 0, 23580, 23581, 7, 10, 0, 0, 23581, 23582, 7, 7, 0, 0, 23582, 23583, 7, 17, 0, 0, 23583, 3482, 1, 0, 0, 0, 23584, 23585, 7, 5, 0, 0, 23585, 23586, 7, 4, 0, 0, 23586, 23587, 7, 0, 0, 0, 23587, 23588, 7, 4, 0, 0, 23588, 23589, 7, 6, 0, 0, 23589, 23590, 7, 14, 0, 0, 23590, 23591, 7, 6, 0, 0, 23591, 23592, 7, 7, 0, 0, 23592, 23593, 7, 4, 0, 0, 23593, 23594, 7, 5, 0, 0, 23594, 3484, 1, 0, 0, 0, 23595, 23596, 7, 5, 0, 0, 23596, 23597, 7, 4, 0, 0, 23597, 23598, 7, 0, 0, 0, 23598, 23599, 7, 4, 0, 0, 23599, 23600, 7, 6, 0, 0, 23600, 23601, 7, 14, 0, 0, 23601, 23602, 7, 6, 0, 0, 23602, 23603, 7, 7, 0, 0, 23603, 23604, 7, 4, 0, 0, 23604, 3486, 1, 0, 0, 0, 23605, 23606, 7, 5, 0, 0, 23606, 23607, 7, 4, 0, 0, 23607, 23608, 7, 0, 0, 0, 23608, 23609, 7, 4, 0, 0, 23609, 23610, 7, 6, 0, 0, 23610, 3488, 1, 0, 0, 0, 23611, 23612, 7, 5, 0, 0, 23612, 23613, 7, 4, 0, 0, 23613, 23614, 7, 0, 0, 0, 23614, 23615, 7, 4, 0, 0, 23615, 23616, 7, 10, 0, 0, 23616, 23617, 7, 8, 0, 0, 23617, 3490, 1, 0, 0, 0, 23618, 23619, 7, 5, 0, 0, 23619, 23620, 7, 4, 0, 0, 23620, 23621, 7, 0, 0, 0, 23621, 23622, 7, 4, 0, 0, 23622, 23623, 7, 10, 0, 0, 23623, 23624, 7, 5, 0, 0, 23624, 23625, 7, 4, 0, 0, 23625, 23626, 7, 10, 0, 0, 23626, 23627, 7, 8, 0, 0, 23627, 23628, 7, 5, 0, 0, 23628, 3492, 1, 0, 0, 0, 23629, 23630, 7, 5, 0, 0, 23630, 23631, 7, 4, 0, 0, 23631, 23632, 7, 0, 0, 0, 23632, 23633, 7, 4, 0, 0, 23633, 23634, 7, 5, 0, 0, 23634, 23635, 5, 95, 0, 0, 23635, 23636, 7, 1, 0, 0, 23636, 23637, 7, 10, 0, 0, 23637, 23638, 7, 7, 0, 0, 23638, 23639, 7, 2, 0, 0, 23639, 23640, 7, 14, 0, 0, 23640, 23641, 7, 10, 0, 0, 23641, 23642, 7, 0, 0, 0, 23642, 23643, 7, 11, 0, 0, 23643, 23644, 5, 95, 0, 0, 23644, 23645, 7, 4, 0, 0, 23645, 23646, 7, 6, 0, 0, 23646, 23647, 7, 5, 0, 0, 23647, 23648, 7, 4, 0, 0, 23648, 3494, 1, 0, 0, 0, 23649, 23650, 7, 5, 0, 0, 23650, 23651, 7, 4, 0, 0, 23651, 23652, 7, 0, 0, 0, 23652, 23653, 7, 4, 0, 0, 23653, 23654, 7, 5, 0, 0, 23654, 23655, 5, 95, 0, 0, 23655, 23656, 7, 8, 0, 0, 23656, 23657, 7, 3, 0, 0, 23657, 23658, 7, 2, 0, 0, 23658, 23659, 7, 5, 0, 0, 23659, 23660, 7, 5, 0, 0, 23660, 23661, 7, 4, 0, 0, 23661, 23662, 7, 0, 0, 0, 23662, 23663, 7, 1, 0, 0, 23663, 3496, 1, 0, 0, 0, 23664, 23665, 7, 5, 0, 0, 23665, 23666, 7, 4, 0, 0, 23666, 23667, 7, 0, 0, 0, 23667, 23668, 7, 4, 0, 0, 23668, 23669, 7, 5, 0, 0, 23669, 23670, 5, 95, 0, 0, 23670, 23671, 7, 16, 0, 0, 23671, 23672, 5, 95, 0, 0, 23672, 23673, 7, 4, 0, 0, 23673, 23674, 7, 6, 0, 0, 23674, 23675, 7, 5, 0, 0, 23675, 23676, 7, 4, 0, 0, 23676, 3498, 1, 0, 0, 0, 23677, 23678, 7, 5, 0, 0, 23678, 23679, 7, 4, 0, 0, 23679, 23680, 7, 0, 0, 0, 23680, 23681, 7, 4, 0, 0, 23681, 23682, 7, 5, 0, 0, 23682, 23683, 5, 95, 0, 0, 23683, 23684, 7, 21, 0, 0, 23684, 23685, 7, 5, 0, 0, 23685, 23686, 5, 95, 0, 0, 23686, 23687, 7, 4, 0, 0, 23687, 23688, 7, 6, 0, 0, 23688, 23689, 7, 5, 0, 0, 23689, 23690, 7, 4, 0, 0, 23690, 3500, 1, 0, 0, 0, 23691, 23692, 7, 5, 0, 0, 23692, 23693, 7, 4, 0, 0, 23693, 23694, 7, 0, 0, 0, 23694, 23695, 7, 4, 0, 0, 23695, 23696, 7, 5, 0, 0, 23696, 23697, 5, 95, 0, 0, 23697, 23698, 7, 14, 0, 0, 23698, 23699, 7, 2, 0, 0, 23699, 23700, 7, 9, 0, 0, 23700, 23701, 7, 6, 0, 0, 23701, 3502, 1, 0, 0, 0, 23702, 23703, 7, 5, 0, 0, 23703, 23704, 7, 4, 0, 0, 23704, 23705, 7, 0, 0, 0, 23705, 23706, 7, 4, 0, 0, 23706, 23707, 7, 5, 0, 0, 23707, 23708, 5, 95, 0, 0, 23708, 23709, 7, 14, 0, 0, 23709, 23710, 7, 22, 0, 0, 23710, 23711, 5, 95, 0, 0, 23711, 23712, 7, 4, 0, 0, 23712, 23713, 7, 6, 0, 0, 23713, 23714, 7, 5, 0, 0, 23714, 23715, 7, 4, 0, 0, 23715, 3504, 1, 0, 0, 0, 23716, 23717, 7, 5, 0, 0, 23717, 23718, 7, 4, 0, 0, 23718, 23719, 7, 0, 0, 0, 23719, 23720, 7, 4, 0, 0, 23720, 23721, 7, 5, 0, 0, 23721, 23722, 5, 95, 0, 0, 23722, 23723, 7, 2, 0, 0, 23723, 23724, 7, 7, 0, 0, 23724, 23725, 7, 6, 0, 0, 23725, 23726, 5, 95, 0, 0, 23726, 23727, 7, 22, 0, 0, 23727, 23728, 7, 0, 0, 0, 23728, 23729, 7, 18, 0, 0, 23729, 23730, 5, 95, 0, 0, 23730, 23731, 7, 0, 0, 0, 23731, 23732, 7, 7, 0, 0, 23732, 23733, 7, 2, 0, 0, 23733, 23734, 7, 13, 0, 0, 23734, 23735, 7, 0, 0, 0, 23735, 3506, 1, 0, 0, 0, 23736, 23737, 7, 5, 0, 0, 23737, 23738, 7, 4, 0, 0, 23738, 23739, 7, 0, 0, 0, 23739, 23740, 7, 4, 0, 0, 23740, 23741, 7, 5, 0, 0, 23741, 23742, 5, 95, 0, 0, 23742, 23743, 7, 4, 0, 0, 23743, 23744, 5, 95, 0, 0, 23744, 23745, 7, 4, 0, 0, 23745, 23746, 7, 6, 0, 0, 23746, 23747, 7, 5, 0, 0, 23747, 23748, 7, 4, 0, 0, 23748, 23749, 5, 95, 0, 0, 23749, 23750, 7, 10, 0, 0, 23750, 23751, 7, 7, 0, 0, 23751, 23752, 7, 9, 0, 0, 23752, 23753, 7, 6, 0, 0, 23753, 23754, 7, 15, 0, 0, 23754, 3508, 1, 0, 0, 0, 23755, 23756, 7, 5, 0, 0, 23756, 23757, 7, 4, 0, 0, 23757, 23758, 7, 0, 0, 0, 23758, 23759, 7, 4, 0, 0, 23759, 23760, 7, 5, 0, 0, 23760, 23761, 5, 95, 0, 0, 23761, 23762, 7, 4, 0, 0, 23762, 23763, 5, 95, 0, 0, 23763, 23764, 7, 4, 0, 0, 23764, 23765, 7, 6, 0, 0, 23765, 23766, 7, 5, 0, 0, 23766, 23767, 7, 4, 0, 0, 23767, 23768, 5, 95, 0, 0, 23768, 23769, 7, 10, 0, 0, 23769, 23770, 7, 7, 0, 0, 23770, 23771, 7, 9, 0, 0, 23771, 23772, 7, 6, 0, 0, 23772, 23773, 7, 15, 0, 0, 23773, 23774, 7, 12, 0, 0, 23774, 3510, 1, 0, 0, 0, 23775, 23776, 7, 5, 0, 0, 23776, 23777, 7, 4, 0, 0, 23777, 23778, 7, 0, 0, 0, 23778, 23779, 7, 4, 0, 0, 23779, 23780, 7, 5, 0, 0, 23780, 23781, 5, 95, 0, 0, 23781, 23782, 7, 4, 0, 0, 23782, 23783, 5, 95, 0, 0, 23783, 23784, 7, 4, 0, 0, 23784, 23785, 7, 6, 0, 0, 23785, 23786, 7, 5, 0, 0, 23786, 23787, 7, 4, 0, 0, 23787, 23788, 5, 95, 0, 0, 23788, 23789, 7, 2, 0, 0, 23789, 23790, 7, 7, 0, 0, 23790, 23791, 7, 6, 0, 0, 23791, 3512, 1, 0, 0, 0, 23792, 23793, 7, 5, 0, 0, 23793, 23794, 7, 4, 0, 0, 23794, 23795, 7, 0, 0, 0, 23795, 23796, 7, 4, 0, 0, 23796, 23797, 7, 5, 0, 0, 23797, 23798, 5, 95, 0, 0, 23798, 23799, 7, 4, 0, 0, 23799, 23800, 5, 95, 0, 0, 23800, 23801, 7, 4, 0, 0, 23801, 23802, 7, 6, 0, 0, 23802, 23803, 7, 5, 0, 0, 23803, 23804, 7, 4, 0, 0, 23804, 23805, 5, 95, 0, 0, 23805, 23806, 7, 15, 0, 0, 23806, 23807, 7, 0, 0, 0, 23807, 23808, 7, 10, 0, 0, 23808, 23809, 7, 3, 0, 0, 23809, 23810, 7, 6, 0, 0, 23810, 23811, 7, 9, 0, 0, 23811, 3514, 1, 0, 0, 0, 23812, 23813, 7, 5, 0, 0, 23813, 23814, 7, 4, 0, 0, 23814, 23815, 7, 0, 0, 0, 23815, 23816, 7, 4, 0, 0, 23816, 23817, 7, 5, 0, 0, 23817, 23818, 5, 95, 0, 0, 23818, 23819, 7, 22, 0, 0, 23819, 23820, 7, 5, 0, 0, 23820, 23821, 7, 3, 0, 0, 23821, 23822, 5, 95, 0, 0, 23822, 23823, 7, 4, 0, 0, 23823, 23824, 7, 6, 0, 0, 23824, 23825, 7, 5, 0, 0, 23825, 23826, 7, 4, 0, 0, 23826, 3516, 1, 0, 0, 0, 23827, 23828, 7, 5, 0, 0, 23828, 23829, 7, 4, 0, 0, 23829, 23830, 7, 9, 0, 0, 23830, 23831, 7, 9, 0, 0, 23831, 23832, 7, 6, 0, 0, 23832, 23833, 7, 13, 0, 0, 23833, 23834, 5, 95, 0, 0, 23834, 23835, 7, 15, 0, 0, 23835, 23836, 7, 2, 0, 0, 23836, 23837, 7, 15, 0, 0, 23837, 3518, 1, 0, 0, 0, 23838, 23839, 7, 5, 0, 0, 23839, 23840, 7, 4, 0, 0, 23840, 23841, 7, 9, 0, 0, 23841, 23842, 7, 9, 0, 0, 23842, 23843, 7, 6, 0, 0, 23843, 23844, 7, 13, 0, 0, 23844, 23845, 5, 95, 0, 0, 23845, 23846, 7, 5, 0, 0, 23846, 23847, 7, 0, 0, 0, 23847, 23848, 7, 14, 0, 0, 23848, 23849, 7, 15, 0, 0, 23849, 3520, 1, 0, 0, 0, 23850, 23851, 7, 5, 0, 0, 23851, 23852, 7, 4, 0, 0, 23852, 23853, 7, 2, 0, 0, 23853, 23854, 7, 15, 0, 0, 23854, 3522, 1, 0, 0, 0, 23855, 23856, 7, 5, 0, 0, 23856, 23857, 7, 4, 0, 0, 23857, 23858, 7, 2, 0, 0, 23858, 23859, 7, 3, 0, 0, 23859, 23860, 7, 0, 0, 0, 23860, 23861, 7, 17, 0, 0, 23861, 23862, 7, 6, 0, 0, 23862, 3524, 1, 0, 0, 0, 23863, 23864, 7, 5, 0, 0, 23864, 23865, 7, 4, 0, 0, 23865, 23866, 7, 2, 0, 0, 23866, 23867, 7, 3, 0, 0, 23867, 23868, 7, 6, 0, 0, 23868, 3526, 1, 0, 0, 0, 23869, 23870, 7, 5, 0, 0, 23870, 23871, 7, 4, 0, 0, 23871, 23872, 7, 3, 0, 0, 23872, 23873, 7, 6, 0, 0, 23873, 23874, 7, 0, 0, 0, 23874, 23875, 7, 14, 0, 0, 23875, 23876, 7, 5, 0, 0, 23876, 3528, 1, 0, 0, 0, 23877, 23878, 7, 5, 0, 0, 23878, 23879, 7, 4, 0, 0, 23879, 23880, 7, 3, 0, 0, 23880, 23881, 7, 6, 0, 0, 23881, 23882, 7, 0, 0, 0, 23882, 23883, 7, 14, 0, 0, 23883, 3530, 1, 0, 0, 0, 23884, 23885, 7, 5, 0, 0, 23885, 23886, 7, 4, 0, 0, 23886, 23887, 7, 3, 0, 0, 23887, 23888, 7, 10, 0, 0, 23888, 23889, 7, 8, 0, 0, 23889, 23890, 7, 4, 0, 0, 23890, 3532, 1, 0, 0, 0, 23891, 23892, 7, 5, 0, 0, 23892, 23893, 7, 4, 0, 0, 23893, 23894, 7, 3, 0, 0, 23894, 23895, 7, 10, 0, 0, 23895, 23896, 7, 7, 0, 0, 23896, 23897, 7, 17, 0, 0, 23897, 3534, 1, 0, 0, 0, 23898, 23899, 7, 5, 0, 0, 23899, 23900, 7, 4, 0, 0, 23900, 23901, 7, 3, 0, 0, 23901, 23902, 7, 10, 0, 0, 23902, 23903, 7, 15, 0, 0, 23903, 23904, 7, 6, 0, 0, 23904, 23905, 5, 95, 0, 0, 23905, 23906, 7, 8, 0, 0, 23906, 23907, 7, 2, 0, 0, 23907, 23908, 7, 11, 0, 0, 23908, 23909, 7, 12, 0, 0, 23909, 23910, 7, 14, 0, 0, 23910, 23911, 7, 7, 0, 0, 23911, 23912, 7, 5, 0, 0, 23912, 3536, 1, 0, 0, 0, 23913, 23914, 7, 5, 0, 0, 23914, 23915, 7, 4, 0, 0, 23915, 23916, 7, 3, 0, 0, 23916, 23917, 7, 10, 0, 0, 23917, 23918, 7, 15, 0, 0, 23918, 23919, 7, 6, 0, 0, 23919, 23920, 5, 95, 0, 0, 23920, 23921, 7, 22, 0, 0, 23921, 23922, 7, 10, 0, 0, 23922, 23923, 7, 9, 0, 0, 23923, 23924, 7, 4, 0, 0, 23924, 23925, 7, 19, 0, 0, 23925, 3538, 1, 0, 0, 0, 23926, 23927, 7, 5, 0, 0, 23927, 23928, 7, 4, 0, 0, 23928, 23929, 7, 3, 0, 0, 23929, 23930, 7, 10, 0, 0, 23930, 23931, 7, 15, 0, 0, 23931, 3540, 1, 0, 0, 0, 23932, 23933, 7, 5, 0, 0, 23933, 23934, 7, 4, 0, 0, 23934, 23935, 7, 3, 0, 0, 23935, 23936, 7, 12, 0, 0, 23936, 23937, 7, 8, 0, 0, 23937, 23938, 7, 4, 0, 0, 23938, 23939, 7, 12, 0, 0, 23939, 23940, 7, 3, 0, 0, 23940, 23941, 7, 6, 0, 0, 23941, 3542, 1, 0, 0, 0, 23942, 23943, 7, 5, 0, 0, 23943, 23944, 7, 12, 0, 0, 23944, 23945, 7, 1, 0, 0, 23945, 23946, 7, 14, 0, 0, 23946, 23947, 7, 12, 0, 0, 23947, 23948, 7, 11, 0, 0, 23948, 23949, 7, 4, 0, 0, 23949, 23950, 7, 10, 0, 0, 23950, 23951, 7, 5, 0, 0, 23951, 23952, 7, 6, 0, 0, 23952, 23953, 7, 4, 0, 0, 23953, 3544, 1, 0, 0, 0, 23954, 23955, 7, 5, 0, 0, 23955, 23956, 7, 12, 0, 0, 23956, 23957, 7, 1, 0, 0, 23957, 23958, 7, 15, 0, 0, 23958, 23959, 7, 0, 0, 0, 23959, 23960, 7, 3, 0, 0, 23960, 23961, 7, 4, 0, 0, 23961, 23962, 7, 10, 0, 0, 23962, 23963, 7, 4, 0, 0, 23963, 23964, 7, 10, 0, 0, 23964, 23965, 7, 2, 0, 0, 23965, 23966, 7, 7, 0, 0, 23966, 23967, 5, 95, 0, 0, 23967, 23968, 7, 3, 0, 0, 23968, 23969, 7, 6, 0, 0, 23969, 23970, 7, 11, 0, 0, 23970, 3546, 1, 0, 0, 0, 23971, 23972, 7, 5, 0, 0, 23972, 23973, 7, 12, 0, 0, 23973, 23974, 7, 1, 0, 0, 23974, 23975, 7, 15, 0, 0, 23975, 23976, 7, 0, 0, 0, 23976, 23977, 7, 3, 0, 0, 23977, 23978, 7, 4, 0, 0, 23978, 23979, 7, 10, 0, 0, 23979, 23980, 7, 4, 0, 0, 23980, 23981, 7, 10, 0, 0, 23981, 23982, 7, 2, 0, 0, 23982, 23983, 7, 7, 0, 0, 23983, 23984, 7, 5, 0, 0, 23984, 3548, 1, 0, 0, 0, 23985, 23986, 7, 5, 0, 0, 23986, 23987, 7, 12, 0, 0, 23987, 23988, 7, 1, 0, 0, 23988, 23989, 7, 15, 0, 0, 23989, 23990, 7, 0, 0, 0, 23990, 23991, 7, 3, 0, 0, 23991, 23992, 7, 4, 0, 0, 23992, 23993, 7, 10, 0, 0, 23993, 23994, 7, 4, 0, 0, 23994, 23995, 7, 10, 0, 0, 23995, 23996, 7, 2, 0, 0, 23996, 23997, 7, 7, 0, 0, 23997, 3550, 1, 0, 0, 0, 23998, 23999, 7, 5, 0, 0, 23999, 24000, 7, 12, 0, 0, 24000, 24001, 7, 1, 0, 0, 24001, 24002, 7, 24, 0, 0, 24002, 24003, 7, 12, 0, 0, 24003, 24004, 7, 6, 0, 0, 24004, 24005, 7, 3, 0, 0, 24005, 24006, 7, 10, 0, 0, 24006, 24007, 7, 6, 0, 0, 24007, 24008, 7, 5, 0, 0, 24008, 3552, 1, 0, 0, 0, 24009, 24010, 7, 5, 0, 0, 24010, 24011, 7, 12, 0, 0, 24011, 24012, 7, 1, 0, 0, 24012, 24013, 7, 24, 0, 0, 24013, 24014, 7, 12, 0, 0, 24014, 24015, 7, 6, 0, 0, 24015, 24016, 7, 3, 0, 0, 24016, 24017, 7, 18, 0, 0, 24017, 24018, 5, 95, 0, 0, 24018, 24019, 7, 15, 0, 0, 24019, 24020, 7, 3, 0, 0, 24020, 24021, 7, 12, 0, 0, 24021, 24022, 7, 7, 0, 0, 24022, 24023, 7, 10, 0, 0, 24023, 24024, 7, 7, 0, 0, 24024, 24025, 7, 17, 0, 0, 24025, 3554, 1, 0, 0, 0, 24026, 24027, 7, 5, 0, 0, 24027, 24028, 7, 12, 0, 0, 24028, 24029, 7, 1, 0, 0, 24029, 24030, 7, 5, 0, 0, 24030, 24031, 7, 8, 0, 0, 24031, 24032, 7, 3, 0, 0, 24032, 24033, 7, 10, 0, 0, 24033, 24034, 7, 1, 0, 0, 24034, 24035, 7, 6, 0, 0, 24035, 3556, 1, 0, 0, 0, 24036, 24037, 7, 5, 0, 0, 24037, 24038, 7, 12, 0, 0, 24038, 24039, 7, 1, 0, 0, 24039, 24040, 7, 5, 0, 0, 24040, 24041, 7, 6, 0, 0, 24041, 24042, 7, 4, 0, 0, 24042, 3558, 1, 0, 0, 0, 24043, 24044, 7, 5, 0, 0, 24044, 24045, 7, 12, 0, 0, 24045, 24046, 7, 1, 0, 0, 24046, 24047, 7, 5, 0, 0, 24047, 24048, 7, 4, 0, 0, 24048, 24049, 7, 10, 0, 0, 24049, 24050, 7, 4, 0, 0, 24050, 24051, 7, 12, 0, 0, 24051, 24052, 7, 4, 0, 0, 24052, 24053, 7, 0, 0, 0, 24053, 24054, 7, 1, 0, 0, 24054, 24055, 7, 11, 0, 0, 24055, 24056, 7, 6, 0, 0, 24056, 3560, 1, 0, 0, 0, 24057, 24058, 7, 5, 0, 0, 24058, 24059, 7, 12, 0, 0, 24059, 24060, 7, 1, 0, 0, 24060, 24061, 7, 5, 0, 0, 24061, 24062, 7, 4, 0, 0, 24062, 24063, 7, 3, 0, 0, 24063, 24064, 5, 50, 0, 0, 24064, 3562, 1, 0, 0, 0, 24065, 24066, 7, 5, 0, 0, 24066, 24067, 7, 12, 0, 0, 24067, 24068, 7, 1, 0, 0, 24068, 24069, 7, 5, 0, 0, 24069, 24070, 7, 4, 0, 0, 24070, 24071, 7, 3, 0, 0, 24071, 24072, 5, 52, 0, 0, 24072, 3564, 1, 0, 0, 0, 24073, 24074, 7, 5, 0, 0, 24074, 24075, 7, 12, 0, 0, 24075, 24076, 7, 1, 0, 0, 24076, 24077, 7, 5, 0, 0, 24077, 24078, 7, 4, 0, 0, 24078, 24079, 7, 3, 0, 0, 24079, 24080, 7, 1, 0, 0, 24080, 3566, 1, 0, 0, 0, 24081, 24082, 7, 5, 0, 0, 24082, 24083, 7, 12, 0, 0, 24083, 24084, 7, 1, 0, 0, 24084, 24085, 7, 5, 0, 0, 24085, 24086, 7, 4, 0, 0, 24086, 24087, 7, 3, 0, 0, 24087, 24088, 7, 8, 0, 0, 24088, 3568, 1, 0, 0, 0, 24089, 24090, 7, 5, 0, 0, 24090, 24091, 7, 12, 0, 0, 24091, 24092, 7, 1, 0, 0, 24092, 24093, 7, 4, 0, 0, 24093, 24094, 7, 18, 0, 0, 24094, 24095, 7, 15, 0, 0, 24095, 24096, 7, 6, 0, 0, 24096, 3570, 1, 0, 0, 0, 24097, 24098, 7, 5, 0, 0, 24098, 24099, 7, 12, 0, 0, 24099, 24100, 7, 8, 0, 0, 24100, 24101, 7, 8, 0, 0, 24101, 24102, 7, 6, 0, 0, 24102, 24103, 7, 5, 0, 0, 24103, 24104, 7, 5, 0, 0, 24104, 24105, 7, 16, 0, 0, 24105, 24106, 7, 12, 0, 0, 24106, 24107, 7, 11, 0, 0, 24107, 3572, 1, 0, 0, 0, 24108, 24109, 7, 5, 0, 0, 24109, 24110, 7, 12, 0, 0, 24110, 24111, 7, 8, 0, 0, 24111, 24112, 7, 8, 0, 0, 24112, 24113, 7, 6, 0, 0, 24113, 24114, 7, 5, 0, 0, 24114, 24115, 7, 5, 0, 0, 24115, 3574, 1, 0, 0, 0, 24116, 24117, 7, 5, 0, 0, 24117, 24118, 7, 12, 0, 0, 24118, 24119, 7, 14, 0, 0, 24119, 24120, 7, 14, 0, 0, 24120, 24121, 7, 0, 0, 0, 24121, 24122, 7, 3, 0, 0, 24122, 24123, 7, 18, 0, 0, 24123, 3576, 1, 0, 0, 0, 24124, 24125, 7, 5, 0, 0, 24125, 24126, 7, 12, 0, 0, 24126, 24127, 7, 15, 0, 0, 24127, 24128, 7, 15, 0, 0, 24128, 24129, 7, 11, 0, 0, 24129, 24130, 7, 6, 0, 0, 24130, 24131, 7, 14, 0, 0, 24131, 24132, 7, 6, 0, 0, 24132, 24133, 7, 7, 0, 0, 24133, 24134, 7, 4, 0, 0, 24134, 24135, 7, 0, 0, 0, 24135, 24136, 7, 11, 0, 0, 24136, 3578, 1, 0, 0, 0, 24137, 24138, 7, 5, 0, 0, 24138, 24139, 7, 12, 0, 0, 24139, 24140, 7, 5, 0, 0, 24140, 24141, 7, 15, 0, 0, 24141, 24142, 7, 6, 0, 0, 24142, 24143, 7, 7, 0, 0, 24143, 24144, 7, 9, 0, 0, 24144, 3580, 1, 0, 0, 0, 24145, 24146, 7, 5, 0, 0, 24146, 24147, 7, 22, 0, 0, 24147, 24148, 7, 0, 0, 0, 24148, 24149, 7, 15, 0, 0, 24149, 24150, 5, 95, 0, 0, 24150, 24151, 7, 20, 0, 0, 24151, 24152, 7, 2, 0, 0, 24152, 24153, 7, 10, 0, 0, 24153, 24154, 7, 7, 0, 0, 24154, 24155, 5, 95, 0, 0, 24155, 24156, 7, 10, 0, 0, 24156, 24157, 7, 7, 0, 0, 24157, 24158, 7, 15, 0, 0, 24158, 24159, 7, 12, 0, 0, 24159, 24160, 7, 4, 0, 0, 24160, 24161, 7, 5, 0, 0, 24161, 3582, 1, 0, 0, 0, 24162, 24163, 7, 5, 0, 0, 24163, 24164, 7, 22, 0, 0, 24164, 24165, 7, 10, 0, 0, 24165, 24166, 7, 4, 0, 0, 24166, 24167, 7, 8, 0, 0, 24167, 24168, 7, 19, 0, 0, 24168, 24169, 7, 2, 0, 0, 24169, 24170, 7, 13, 0, 0, 24170, 24171, 7, 6, 0, 0, 24171, 24172, 7, 3, 0, 0, 24172, 3584, 1, 0, 0, 0, 24173, 24174, 7, 5, 0, 0, 24174, 24175, 7, 22, 0, 0, 24175, 24176, 7, 10, 0, 0, 24176, 24177, 7, 4, 0, 0, 24177, 24178, 7, 8, 0, 0, 24178, 24179, 7, 19, 0, 0, 24179, 3586, 1, 0, 0, 0, 24180, 24181, 7, 5, 0, 0, 24181, 24182, 7, 18, 0, 0, 24182, 24183, 7, 7, 0, 0, 24183, 24184, 7, 8, 0, 0, 24184, 24185, 7, 19, 0, 0, 24185, 24186, 7, 3, 0, 0, 24186, 24187, 7, 2, 0, 0, 24187, 24188, 7, 7, 0, 0, 24188, 24189, 7, 2, 0, 0, 24189, 24190, 7, 12, 0, 0, 24190, 24191, 7, 5, 0, 0, 24191, 3588, 1, 0, 0, 0, 24192, 24193, 7, 5, 0, 0, 24193, 24194, 7, 18, 0, 0, 24194, 24195, 7, 7, 0, 0, 24195, 24196, 7, 8, 0, 0, 24196, 3590, 1, 0, 0, 0, 24197, 24198, 7, 5, 0, 0, 24198, 24199, 7, 18, 0, 0, 24199, 24200, 7, 7, 0, 0, 24200, 24201, 7, 2, 0, 0, 24201, 24202, 7, 7, 0, 0, 24202, 24203, 7, 18, 0, 0, 24203, 24204, 7, 14, 0, 0, 24204, 3592, 1, 0, 0, 0, 24205, 24206, 7, 5, 0, 0, 24206, 24207, 7, 18, 0, 0, 24207, 24208, 7, 5, 0, 0, 24208, 3594, 1, 0, 0, 0, 24209, 24210, 7, 5, 0, 0, 24210, 24211, 7, 18, 0, 0, 24211, 24212, 7, 5, 0, 0, 24212, 24213, 7, 0, 0, 0, 24213, 24214, 7, 5, 0, 0, 24214, 24215, 7, 14, 0, 0, 24215, 3596, 1, 0, 0, 0, 24216, 24217, 7, 5, 0, 0, 24217, 24218, 7, 18, 0, 0, 24218, 24219, 7, 5, 0, 0, 24219, 24220, 5, 95, 0, 0, 24220, 24221, 7, 0, 0, 0, 24221, 24222, 7, 12, 0, 0, 24222, 24223, 7, 9, 0, 0, 24223, 24224, 7, 10, 0, 0, 24224, 24225, 7, 4, 0, 0, 24225, 3598, 1, 0, 0, 0, 24226, 24227, 7, 5, 0, 0, 24227, 24228, 7, 18, 0, 0, 24228, 24229, 7, 5, 0, 0, 24229, 24230, 7, 0, 0, 0, 24230, 24231, 7, 12, 0, 0, 24231, 24232, 7, 25, 0, 0, 24232, 3600, 1, 0, 0, 0, 24233, 24234, 7, 5, 0, 0, 24234, 24235, 7, 18, 0, 0, 24235, 24236, 7, 5, 0, 0, 24236, 24237, 7, 1, 0, 0, 24237, 24238, 7, 0, 0, 0, 24238, 24239, 7, 8, 0, 0, 24239, 24240, 7, 21, 0, 0, 24240, 24241, 7, 12, 0, 0, 24241, 24242, 7, 15, 0, 0, 24242, 3602, 1, 0, 0, 0, 24243, 24244, 7, 5, 0, 0, 24244, 24245, 7, 18, 0, 0, 24245, 24246, 7, 5, 0, 0, 24246, 24247, 5, 95, 0, 0, 24247, 24248, 7, 8, 0, 0, 24248, 24249, 7, 19, 0, 0, 24249, 24250, 7, 6, 0, 0, 24250, 24251, 7, 8, 0, 0, 24251, 24252, 7, 21, 0, 0, 24252, 24253, 7, 0, 0, 0, 24253, 24254, 7, 8, 0, 0, 24254, 24255, 7, 11, 0, 0, 24255, 3604, 1, 0, 0, 0, 24256, 24257, 7, 5, 0, 0, 24257, 24258, 7, 18, 0, 0, 24258, 24259, 7, 5, 0, 0, 24259, 24260, 5, 95, 0, 0, 24260, 24261, 7, 8, 0, 0, 24261, 24262, 7, 19, 0, 0, 24262, 24263, 7, 6, 0, 0, 24263, 24264, 7, 8, 0, 0, 24264, 24265, 7, 21, 0, 0, 24265, 24266, 5, 95, 0, 0, 24266, 24267, 7, 15, 0, 0, 24267, 24268, 7, 3, 0, 0, 24268, 24269, 7, 10, 0, 0, 24269, 24270, 7, 13, 0, 0, 24270, 24271, 7, 10, 0, 0, 24271, 24272, 7, 11, 0, 0, 24272, 24273, 7, 6, 0, 0, 24273, 24274, 7, 17, 0, 0, 24274, 24275, 7, 6, 0, 0, 24275, 3606, 1, 0, 0, 0, 24276, 24277, 7, 5, 0, 0, 24277, 24278, 7, 18, 0, 0, 24278, 24279, 7, 5, 0, 0, 24279, 24280, 5, 95, 0, 0, 24280, 24281, 7, 8, 0, 0, 24281, 24282, 7, 2, 0, 0, 24282, 24283, 7, 7, 0, 0, 24283, 24284, 7, 7, 0, 0, 24284, 24285, 7, 6, 0, 0, 24285, 24286, 7, 8, 0, 0, 24286, 24287, 7, 4, 0, 0, 24287, 24288, 5, 95, 0, 0, 24288, 24289, 7, 1, 0, 0, 24289, 24290, 7, 18, 0, 0, 24290, 24291, 5, 95, 0, 0, 24291, 24292, 7, 15, 0, 0, 24292, 24293, 7, 0, 0, 0, 24293, 24294, 7, 4, 0, 0, 24294, 24295, 7, 19, 0, 0, 24295, 3608, 1, 0, 0, 0, 24296, 24297, 7, 5, 0, 0, 24297, 24298, 7, 18, 0, 0, 24298, 24299, 7, 5, 0, 0, 24299, 24300, 5, 95, 0, 0, 24300, 24301, 7, 8, 0, 0, 24301, 24302, 7, 2, 0, 0, 24302, 24303, 7, 7, 0, 0, 24303, 24304, 7, 4, 0, 0, 24304, 24305, 7, 6, 0, 0, 24305, 24306, 7, 25, 0, 0, 24306, 24307, 7, 4, 0, 0, 24307, 3610, 1, 0, 0, 0, 24308, 24309, 7, 5, 0, 0, 24309, 24310, 7, 18, 0, 0, 24310, 24311, 7, 5, 0, 0, 24311, 24312, 7, 9, 0, 0, 24312, 24313, 7, 0, 0, 0, 24313, 24314, 7, 4, 0, 0, 24314, 24315, 7, 6, 0, 0, 24315, 3612, 1, 0, 0, 0, 24316, 24317, 7, 5, 0, 0, 24317, 24318, 7, 18, 0, 0, 24318, 24319, 7, 5, 0, 0, 24319, 24320, 7, 9, 0, 0, 24320, 24321, 7, 1, 0, 0, 24321, 24322, 7, 0, 0, 0, 24322, 3614, 1, 0, 0, 0, 24323, 24324, 7, 5, 0, 0, 24324, 24325, 7, 18, 0, 0, 24325, 24326, 7, 5, 0, 0, 24326, 24327, 5, 95, 0, 0, 24327, 24328, 7, 9, 0, 0, 24328, 24329, 7, 1, 0, 0, 24329, 24330, 7, 12, 0, 0, 24330, 24331, 7, 3, 0, 0, 24331, 24332, 7, 10, 0, 0, 24332, 24333, 7, 17, 0, 0, 24333, 24334, 7, 6, 0, 0, 24334, 24335, 7, 7, 0, 0, 24335, 3616, 1, 0, 0, 0, 24336, 24337, 7, 5, 0, 0, 24337, 24338, 7, 18, 0, 0, 24338, 24339, 7, 5, 0, 0, 24339, 24340, 7, 9, 0, 0, 24340, 24341, 7, 17, 0, 0, 24341, 3618, 1, 0, 0, 0, 24342, 24343, 7, 5, 0, 0, 24343, 24344, 7, 18, 0, 0, 24344, 24345, 7, 5, 0, 0, 24345, 24346, 5, 95, 0, 0, 24346, 24347, 7, 9, 0, 0, 24347, 24348, 7, 11, 0, 0, 24348, 24349, 5, 95, 0, 0, 24349, 24350, 7, 8, 0, 0, 24350, 24351, 7, 12, 0, 0, 24351, 24352, 7, 3, 0, 0, 24352, 24353, 7, 5, 0, 0, 24353, 24354, 7, 2, 0, 0, 24354, 24355, 7, 3, 0, 0, 24355, 3620, 1, 0, 0, 0, 24356, 24357, 7, 5, 0, 0, 24357, 24358, 7, 18, 0, 0, 24358, 24359, 7, 5, 0, 0, 24359, 24360, 5, 95, 0, 0, 24360, 24361, 7, 9, 0, 0, 24361, 24362, 7, 14, 0, 0, 24362, 24363, 5, 95, 0, 0, 24363, 24364, 7, 3, 0, 0, 24364, 24365, 7, 25, 0, 0, 24365, 24366, 7, 16, 0, 0, 24366, 24367, 7, 2, 0, 0, 24367, 24368, 7, 3, 0, 0, 24368, 24369, 7, 14, 0, 0, 24369, 24370, 5, 95, 0, 0, 24370, 24371, 7, 8, 0, 0, 24371, 24372, 7, 19, 0, 0, 24372, 24373, 7, 3, 0, 0, 24373, 3622, 1, 0, 0, 0, 24374, 24375, 7, 5, 0, 0, 24375, 24376, 7, 18, 0, 0, 24376, 24377, 7, 5, 0, 0, 24377, 24378, 5, 95, 0, 0, 24378, 24379, 7, 9, 0, 0, 24379, 24380, 7, 14, 0, 0, 24380, 24381, 5, 95, 0, 0, 24381, 24382, 7, 3, 0, 0, 24382, 24383, 7, 25, 0, 0, 24383, 24384, 7, 16, 0, 0, 24384, 24385, 7, 2, 0, 0, 24385, 24386, 7, 3, 0, 0, 24386, 24387, 7, 14, 0, 0, 24387, 24388, 5, 95, 0, 0, 24388, 24389, 7, 7, 0, 0, 24389, 24390, 7, 12, 0, 0, 24390, 24391, 7, 14, 0, 0, 24391, 3624, 1, 0, 0, 0, 24392, 24393, 7, 5, 0, 0, 24393, 24394, 7, 18, 0, 0, 24394, 24395, 7, 5, 0, 0, 24395, 24396, 5, 95, 0, 0, 24396, 24397, 7, 9, 0, 0, 24397, 24398, 7, 2, 0, 0, 24398, 24399, 7, 14, 0, 0, 24399, 24400, 5, 95, 0, 0, 24400, 24401, 7, 8, 0, 0, 24401, 24402, 7, 2, 0, 0, 24402, 24403, 7, 14, 0, 0, 24403, 24404, 7, 15, 0, 0, 24404, 24405, 7, 0, 0, 0, 24405, 24406, 7, 3, 0, 0, 24406, 24407, 7, 6, 0, 0, 24407, 3626, 1, 0, 0, 0, 24408, 24409, 7, 5, 0, 0, 24409, 24410, 7, 18, 0, 0, 24410, 24411, 7, 5, 0, 0, 24411, 24412, 5, 95, 0, 0, 24412, 24413, 7, 9, 0, 0, 24413, 24414, 7, 5, 0, 0, 24414, 24415, 7, 4, 0, 0, 24415, 24416, 5, 95, 0, 0, 24416, 24417, 7, 15, 0, 0, 24417, 24418, 7, 3, 0, 0, 24418, 24419, 7, 10, 0, 0, 24419, 24420, 7, 14, 0, 0, 24420, 24421, 5, 50, 0, 0, 24421, 24422, 7, 5, 0, 0, 24422, 24423, 7, 6, 0, 0, 24423, 24424, 7, 8, 0, 0, 24424, 3628, 1, 0, 0, 0, 24425, 24426, 7, 5, 0, 0, 24426, 24427, 7, 18, 0, 0, 24427, 24428, 7, 5, 0, 0, 24428, 24429, 5, 95, 0, 0, 24429, 24430, 7, 9, 0, 0, 24430, 24431, 7, 5, 0, 0, 24431, 24432, 7, 4, 0, 0, 24432, 24433, 5, 95, 0, 0, 24433, 24434, 7, 5, 0, 0, 24434, 24435, 7, 6, 0, 0, 24435, 24436, 7, 8, 0, 0, 24436, 24437, 5, 50, 0, 0, 24437, 24438, 7, 15, 0, 0, 24438, 24439, 7, 3, 0, 0, 24439, 24440, 7, 10, 0, 0, 24440, 24441, 7, 14, 0, 0, 24441, 3630, 1, 0, 0, 0, 24442, 24443, 7, 5, 0, 0, 24443, 24444, 7, 18, 0, 0, 24444, 24445, 7, 5, 0, 0, 24445, 24446, 5, 95, 0, 0, 24446, 24447, 7, 6, 0, 0, 24447, 24448, 7, 4, 0, 0, 24448, 24449, 5, 95, 0, 0, 24449, 24450, 7, 1, 0, 0, 24450, 24451, 7, 16, 0, 0, 24451, 24452, 7, 10, 0, 0, 24452, 24453, 7, 11, 0, 0, 24453, 24454, 7, 6, 0, 0, 24454, 24455, 5, 95, 0, 0, 24455, 24456, 7, 4, 0, 0, 24456, 24457, 7, 2, 0, 0, 24457, 24458, 5, 95, 0, 0, 24458, 24459, 7, 3, 0, 0, 24459, 24460, 7, 0, 0, 0, 24460, 24461, 7, 22, 0, 0, 24461, 3632, 1, 0, 0, 0, 24462, 24463, 7, 5, 0, 0, 24463, 24464, 7, 18, 0, 0, 24464, 24465, 7, 5, 0, 0, 24465, 24466, 5, 95, 0, 0, 24466, 24467, 7, 6, 0, 0, 24467, 24468, 7, 4, 0, 0, 24468, 24469, 5, 95, 0, 0, 24469, 24470, 7, 1, 0, 0, 24470, 24471, 7, 11, 0, 0, 24471, 24472, 7, 2, 0, 0, 24472, 24473, 7, 1, 0, 0, 24473, 24474, 5, 95, 0, 0, 24474, 24475, 7, 4, 0, 0, 24475, 24476, 7, 2, 0, 0, 24476, 24477, 5, 95, 0, 0, 24477, 24478, 7, 10, 0, 0, 24478, 24479, 7, 14, 0, 0, 24479, 24480, 7, 0, 0, 0, 24480, 24481, 7, 17, 0, 0, 24481, 24482, 7, 6, 0, 0, 24482, 3634, 1, 0, 0, 0, 24483, 24484, 7, 5, 0, 0, 24484, 24485, 7, 18, 0, 0, 24485, 24486, 7, 5, 0, 0, 24486, 24487, 5, 95, 0, 0, 24487, 24488, 7, 6, 0, 0, 24488, 24489, 7, 4, 0, 0, 24489, 24490, 5, 95, 0, 0, 24490, 24491, 7, 10, 0, 0, 24491, 24492, 7, 14, 0, 0, 24492, 24493, 7, 0, 0, 0, 24493, 24494, 7, 17, 0, 0, 24494, 24495, 7, 6, 0, 0, 24495, 24496, 5, 95, 0, 0, 24496, 24497, 7, 4, 0, 0, 24497, 24498, 7, 2, 0, 0, 24498, 24499, 5, 95, 0, 0, 24499, 24500, 7, 1, 0, 0, 24500, 24501, 7, 11, 0, 0, 24501, 24502, 7, 2, 0, 0, 24502, 24503, 7, 1, 0, 0, 24503, 3636, 1, 0, 0, 0, 24504, 24505, 7, 5, 0, 0, 24505, 24506, 7, 18, 0, 0, 24506, 24507, 7, 5, 0, 0, 24507, 24508, 5, 95, 0, 0, 24508, 24509, 7, 6, 0, 0, 24509, 24510, 7, 4, 0, 0, 24510, 24511, 5, 95, 0, 0, 24511, 24512, 7, 3, 0, 0, 24512, 24513, 7, 0, 0, 0, 24513, 24514, 7, 22, 0, 0, 24514, 24515, 5, 95, 0, 0, 24515, 24516, 7, 4, 0, 0, 24516, 24517, 7, 2, 0, 0, 24517, 24518, 5, 95, 0, 0, 24518, 24519, 7, 1, 0, 0, 24519, 24520, 7, 16, 0, 0, 24520, 24521, 7, 10, 0, 0, 24521, 24522, 7, 11, 0, 0, 24522, 24523, 7, 6, 0, 0, 24523, 3638, 1, 0, 0, 0, 24524, 24525, 7, 5, 0, 0, 24525, 24526, 7, 18, 0, 0, 24526, 24527, 7, 5, 0, 0, 24527, 24528, 5, 95, 0, 0, 24528, 24529, 7, 6, 0, 0, 24529, 24530, 7, 25, 0, 0, 24530, 24531, 7, 4, 0, 0, 24531, 24532, 7, 15, 0, 0, 24532, 24533, 7, 9, 0, 0, 24533, 24534, 7, 4, 0, 0, 24534, 24535, 7, 25, 0, 0, 24535, 24536, 7, 4, 0, 0, 24536, 3640, 1, 0, 0, 0, 24537, 24538, 7, 5, 0, 0, 24538, 24539, 7, 18, 0, 0, 24539, 24540, 7, 5, 0, 0, 24540, 24541, 5, 95, 0, 0, 24541, 24542, 7, 6, 0, 0, 24542, 24543, 7, 25, 0, 0, 24543, 24544, 7, 4, 0, 0, 24544, 24545, 7, 3, 0, 0, 24545, 24546, 7, 0, 0, 0, 24546, 24547, 7, 8, 0, 0, 24547, 24548, 7, 4, 0, 0, 24548, 24549, 5, 95, 0, 0, 24549, 24550, 7, 12, 0, 0, 24550, 24551, 7, 4, 0, 0, 24551, 24552, 7, 8, 0, 0, 24552, 3642, 1, 0, 0, 0, 24553, 24554, 7, 5, 0, 0, 24554, 24555, 7, 18, 0, 0, 24555, 24556, 7, 5, 0, 0, 24556, 24557, 5, 95, 0, 0, 24557, 24558, 7, 16, 0, 0, 24558, 24559, 7, 1, 0, 0, 24559, 24560, 7, 4, 0, 0, 24560, 24561, 5, 95, 0, 0, 24561, 24562, 7, 10, 0, 0, 24562, 24563, 7, 7, 0, 0, 24563, 24564, 7, 5, 0, 0, 24564, 24565, 7, 9, 0, 0, 24565, 24566, 7, 6, 0, 0, 24566, 24567, 7, 11, 0, 0, 24567, 3644, 1, 0, 0, 0, 24568, 24569, 7, 5, 0, 0, 24569, 24570, 7, 18, 0, 0, 24570, 24571, 7, 5, 0, 0, 24571, 24572, 5, 95, 0, 0, 24572, 24573, 7, 16, 0, 0, 24573, 24574, 7, 10, 0, 0, 24574, 24575, 7, 11, 0, 0, 24575, 24576, 7, 4, 0, 0, 24576, 24577, 7, 6, 0, 0, 24577, 24578, 7, 3, 0, 0, 24578, 24579, 5, 95, 0, 0, 24579, 24580, 7, 0, 0, 0, 24580, 24581, 7, 8, 0, 0, 24581, 24582, 7, 11, 0, 0, 24582, 24583, 7, 5, 0, 0, 24583, 3646, 1, 0, 0, 0, 24584, 24585, 7, 5, 0, 0, 24585, 24586, 7, 18, 0, 0, 24586, 24587, 7, 5, 0, 0, 24587, 24588, 5, 95, 0, 0, 24588, 24589, 7, 16, 0, 0, 24589, 24590, 7, 7, 0, 0, 24590, 24591, 7, 14, 0, 0, 24591, 24592, 7, 0, 0, 0, 24592, 24593, 7, 4, 0, 0, 24593, 24594, 7, 8, 0, 0, 24594, 24595, 7, 19, 0, 0, 24595, 24596, 7, 6, 0, 0, 24596, 24597, 7, 5, 0, 0, 24597, 3648, 1, 0, 0, 0, 24598, 24599, 7, 5, 0, 0, 24599, 24600, 7, 18, 0, 0, 24600, 24601, 7, 5, 0, 0, 24601, 24602, 5, 95, 0, 0, 24602, 24603, 7, 16, 0, 0, 24603, 24604, 7, 7, 0, 0, 24604, 24605, 7, 3, 0, 0, 24605, 24606, 7, 6, 0, 0, 24606, 24607, 7, 15, 0, 0, 24607, 24608, 7, 11, 0, 0, 24608, 24609, 7, 0, 0, 0, 24609, 24610, 7, 8, 0, 0, 24610, 24611, 7, 6, 0, 0, 24611, 3650, 1, 0, 0, 0, 24612, 24613, 7, 5, 0, 0, 24613, 24614, 7, 18, 0, 0, 24614, 24615, 7, 5, 0, 0, 24615, 24616, 5, 95, 0, 0, 24616, 24617, 7, 17, 0, 0, 24617, 24618, 7, 6, 0, 0, 24618, 24619, 7, 4, 0, 0, 24619, 24620, 5, 95, 0, 0, 24620, 24621, 7, 0, 0, 0, 24621, 24622, 7, 8, 0, 0, 24622, 24623, 7, 11, 0, 0, 24623, 24624, 7, 10, 0, 0, 24624, 24625, 7, 9, 0, 0, 24625, 24626, 7, 5, 0, 0, 24626, 3652, 1, 0, 0, 0, 24627, 24628, 7, 5, 0, 0, 24628, 24629, 7, 18, 0, 0, 24629, 24630, 7, 5, 0, 0, 24630, 24631, 5, 95, 0, 0, 24631, 24632, 7, 17, 0, 0, 24632, 24633, 7, 6, 0, 0, 24633, 24634, 7, 4, 0, 0, 24634, 24635, 5, 95, 0, 0, 24635, 24636, 7, 8, 0, 0, 24636, 24637, 7, 2, 0, 0, 24637, 24638, 7, 11, 0, 0, 24638, 24639, 5, 95, 0, 0, 24639, 24640, 7, 0, 0, 0, 24640, 24641, 7, 8, 0, 0, 24641, 24642, 7, 11, 0, 0, 24642, 24643, 7, 10, 0, 0, 24643, 24644, 7, 9, 0, 0, 24644, 24645, 7, 5, 0, 0, 24645, 3654, 1, 0, 0, 0, 24646, 24647, 7, 5, 0, 0, 24647, 24648, 7, 18, 0, 0, 24648, 24649, 7, 5, 0, 0, 24649, 24650, 5, 95, 0, 0, 24650, 24651, 7, 17, 0, 0, 24651, 24652, 7, 6, 0, 0, 24652, 24653, 7, 4, 0, 0, 24653, 24654, 5, 95, 0, 0, 24654, 24655, 7, 15, 0, 0, 24655, 24656, 7, 3, 0, 0, 24656, 24657, 7, 10, 0, 0, 24657, 24658, 7, 13, 0, 0, 24658, 24659, 7, 10, 0, 0, 24659, 24660, 7, 11, 0, 0, 24660, 24661, 7, 6, 0, 0, 24661, 24662, 7, 17, 0, 0, 24662, 24663, 7, 6, 0, 0, 24663, 24664, 7, 5, 0, 0, 24664, 3656, 1, 0, 0, 0, 24665, 24666, 7, 5, 0, 0, 24666, 24667, 7, 18, 0, 0, 24667, 24668, 7, 5, 0, 0, 24668, 24669, 5, 95, 0, 0, 24669, 24670, 7, 17, 0, 0, 24670, 24671, 7, 6, 0, 0, 24671, 24672, 7, 4, 0, 0, 24672, 24673, 7, 4, 0, 0, 24673, 24674, 7, 2, 0, 0, 24674, 24675, 7, 21, 0, 0, 24675, 24676, 7, 6, 0, 0, 24676, 24677, 7, 7, 0, 0, 24677, 24678, 7, 10, 0, 0, 24678, 24679, 7, 9, 0, 0, 24679, 3658, 1, 0, 0, 0, 24680, 24681, 7, 5, 0, 0, 24681, 24682, 7, 18, 0, 0, 24682, 24683, 7, 5, 0, 0, 24683, 24684, 5, 95, 0, 0, 24684, 24685, 7, 17, 0, 0, 24685, 24686, 7, 6, 0, 0, 24686, 24687, 7, 4, 0, 0, 24687, 24688, 7, 25, 0, 0, 24688, 24689, 7, 4, 0, 0, 24689, 24690, 7, 10, 0, 0, 24690, 24691, 7, 13, 0, 0, 24691, 24692, 7, 0, 0, 0, 24692, 24693, 7, 11, 0, 0, 24693, 3660, 1, 0, 0, 0, 24694, 24695, 7, 5, 0, 0, 24695, 24696, 7, 18, 0, 0, 24696, 24697, 7, 5, 0, 0, 24697, 24698, 5, 95, 0, 0, 24698, 24699, 7, 17, 0, 0, 24699, 24700, 7, 12, 0, 0, 24700, 24701, 7, 10, 0, 0, 24701, 24702, 7, 9, 0, 0, 24702, 3662, 1, 0, 0, 0, 24703, 24704, 7, 5, 0, 0, 24704, 24705, 7, 18, 0, 0, 24705, 24706, 7, 5, 0, 0, 24706, 24707, 7, 17, 0, 0, 24707, 24708, 7, 12, 0, 0, 24708, 24709, 7, 10, 0, 0, 24709, 24710, 7, 9, 0, 0, 24710, 3664, 1, 0, 0, 0, 24711, 24712, 7, 5, 0, 0, 24712, 24713, 7, 18, 0, 0, 24713, 24714, 7, 5, 0, 0, 24714, 24715, 7, 21, 0, 0, 24715, 24716, 7, 14, 0, 0, 24716, 3666, 1, 0, 0, 0, 24717, 24718, 7, 5, 0, 0, 24718, 24719, 7, 18, 0, 0, 24719, 24720, 7, 5, 0, 0, 24720, 24721, 5, 95, 0, 0, 24721, 24722, 7, 14, 0, 0, 24722, 24723, 7, 0, 0, 0, 24723, 24724, 7, 21, 0, 0, 24724, 24725, 7, 6, 0, 0, 24725, 24726, 5, 95, 0, 0, 24726, 24727, 7, 25, 0, 0, 24727, 24728, 7, 14, 0, 0, 24728, 24729, 7, 11, 0, 0, 24729, 24730, 7, 7, 0, 0, 24730, 24731, 7, 2, 0, 0, 24731, 24732, 7, 9, 0, 0, 24732, 24733, 7, 6, 0, 0, 24733, 24734, 7, 10, 0, 0, 24734, 24735, 7, 9, 0, 0, 24735, 3668, 1, 0, 0, 0, 24736, 24737, 7, 5, 0, 0, 24737, 24738, 7, 18, 0, 0, 24738, 24739, 7, 5, 0, 0, 24739, 24740, 5, 95, 0, 0, 24740, 24741, 7, 14, 0, 0, 24741, 24742, 7, 0, 0, 0, 24742, 24743, 7, 21, 0, 0, 24743, 24744, 7, 6, 0, 0, 24744, 24745, 7, 25, 0, 0, 24745, 24746, 7, 14, 0, 0, 24746, 24747, 7, 11, 0, 0, 24747, 3670, 1, 0, 0, 0, 24748, 24749, 7, 5, 0, 0, 24749, 24750, 7, 18, 0, 0, 24750, 24751, 7, 5, 0, 0, 24751, 24752, 5, 95, 0, 0, 24752, 24753, 7, 14, 0, 0, 24753, 24754, 7, 21, 0, 0, 24754, 24755, 7, 25, 0, 0, 24755, 24756, 7, 14, 0, 0, 24756, 24757, 7, 11, 0, 0, 24757, 24758, 7, 0, 0, 0, 24758, 24759, 7, 4, 0, 0, 24759, 24760, 7, 4, 0, 0, 24760, 24761, 7, 3, 0, 0, 24761, 3672, 1, 0, 0, 0, 24762, 24763, 7, 5, 0, 0, 24763, 24764, 7, 18, 0, 0, 24764, 24765, 7, 5, 0, 0, 24765, 24766, 5, 95, 0, 0, 24766, 24767, 7, 14, 0, 0, 24767, 24768, 7, 21, 0, 0, 24768, 24769, 7, 25, 0, 0, 24769, 24770, 7, 4, 0, 0, 24770, 24771, 7, 10, 0, 0, 24771, 3674, 1, 0, 0, 0, 24772, 24773, 7, 5, 0, 0, 24773, 24774, 7, 18, 0, 0, 24774, 24775, 7, 5, 0, 0, 24775, 24776, 7, 2, 0, 0, 24776, 24777, 7, 1, 0, 0, 24777, 24778, 7, 20, 0, 0, 24778, 3676, 1, 0, 0, 0, 24779, 24780, 7, 5, 0, 0, 24780, 24781, 7, 18, 0, 0, 24781, 24782, 7, 5, 0, 0, 24782, 24783, 5, 95, 0, 0, 24783, 24784, 7, 2, 0, 0, 24784, 24785, 7, 15, 0, 0, 24785, 24786, 5, 95, 0, 0, 24786, 24787, 7, 0, 0, 0, 24787, 24788, 7, 9, 0, 0, 24788, 24789, 7, 4, 0, 0, 24789, 24790, 5, 50, 0, 0, 24790, 24791, 7, 1, 0, 0, 24791, 24792, 7, 10, 0, 0, 24792, 24793, 7, 7, 0, 0, 24793, 3678, 1, 0, 0, 0, 24794, 24795, 7, 5, 0, 0, 24795, 24796, 7, 18, 0, 0, 24796, 24797, 7, 5, 0, 0, 24797, 24798, 5, 95, 0, 0, 24798, 24799, 7, 2, 0, 0, 24799, 24800, 7, 15, 0, 0, 24800, 24801, 5, 95, 0, 0, 24801, 24802, 7, 0, 0, 0, 24802, 24803, 7, 9, 0, 0, 24803, 24804, 7, 4, 0, 0, 24804, 24805, 7, 8, 0, 0, 24805, 24806, 7, 2, 0, 0, 24806, 24807, 7, 7, 0, 0, 24807, 24808, 7, 5, 0, 0, 24808, 3680, 1, 0, 0, 0, 24809, 24810, 7, 5, 0, 0, 24810, 24811, 7, 18, 0, 0, 24811, 24812, 7, 5, 0, 0, 24812, 24813, 5, 95, 0, 0, 24813, 24814, 7, 2, 0, 0, 24814, 24815, 7, 15, 0, 0, 24815, 24816, 5, 95, 0, 0, 24816, 24817, 7, 0, 0, 0, 24817, 24818, 7, 11, 0, 0, 24818, 24819, 7, 5, 0, 0, 24819, 24820, 7, 8, 0, 0, 24820, 24821, 7, 3, 0, 0, 24821, 24822, 7, 13, 0, 0, 24822, 24823, 7, 0, 0, 0, 24823, 24824, 7, 11, 0, 0, 24824, 3682, 1, 0, 0, 0, 24825, 24826, 7, 5, 0, 0, 24826, 24827, 7, 18, 0, 0, 24827, 24828, 7, 5, 0, 0, 24828, 24829, 5, 95, 0, 0, 24829, 24830, 7, 2, 0, 0, 24830, 24831, 7, 15, 0, 0, 24831, 24832, 5, 95, 0, 0, 24832, 24833, 7, 0, 0, 0, 24833, 24834, 7, 4, 0, 0, 24834, 24835, 7, 17, 0, 0, 24835, 3684, 1, 0, 0, 0, 24836, 24837, 7, 5, 0, 0, 24837, 24838, 7, 18, 0, 0, 24838, 24839, 7, 5, 0, 0, 24839, 24840, 5, 95, 0, 0, 24840, 24841, 7, 2, 0, 0, 24841, 24842, 7, 15, 0, 0, 24842, 24843, 5, 95, 0, 0, 24843, 24844, 7, 1, 0, 0, 24844, 24845, 7, 10, 0, 0, 24845, 24846, 7, 7, 0, 0, 24846, 24847, 5, 50, 0, 0, 24847, 24848, 7, 0, 0, 0, 24848, 24849, 7, 9, 0, 0, 24849, 24850, 7, 4, 0, 0, 24850, 3686, 1, 0, 0, 0, 24851, 24852, 7, 5, 0, 0, 24852, 24853, 7, 18, 0, 0, 24853, 24854, 7, 5, 0, 0, 24854, 24855, 5, 95, 0, 0, 24855, 24856, 7, 2, 0, 0, 24856, 24857, 7, 15, 0, 0, 24857, 24858, 5, 95, 0, 0, 24858, 24859, 7, 1, 0, 0, 24859, 24860, 7, 10, 0, 0, 24860, 24861, 7, 4, 0, 0, 24861, 24862, 7, 13, 0, 0, 24862, 24863, 7, 6, 0, 0, 24863, 24864, 7, 8, 0, 0, 24864, 3688, 1, 0, 0, 0, 24865, 24866, 7, 5, 0, 0, 24866, 24867, 7, 18, 0, 0, 24867, 24868, 7, 5, 0, 0, 24868, 24869, 5, 95, 0, 0, 24869, 24870, 7, 2, 0, 0, 24870, 24871, 7, 15, 0, 0, 24871, 24872, 5, 95, 0, 0, 24872, 24873, 7, 1, 0, 0, 24873, 24874, 7, 11, 0, 0, 24874, 24875, 5, 50, 0, 0, 24875, 24876, 7, 3, 0, 0, 24876, 3690, 1, 0, 0, 0, 24877, 24878, 7, 5, 0, 0, 24878, 24879, 7, 18, 0, 0, 24879, 24880, 7, 5, 0, 0, 24880, 24881, 5, 95, 0, 0, 24881, 24882, 7, 2, 0, 0, 24882, 24883, 7, 15, 0, 0, 24883, 24884, 5, 95, 0, 0, 24884, 24885, 7, 1, 0, 0, 24885, 24886, 7, 11, 0, 0, 24886, 24887, 7, 2, 0, 0, 24887, 24888, 7, 2, 0, 0, 24888, 24889, 7, 14, 0, 0, 24889, 24890, 5, 95, 0, 0, 24890, 24891, 7, 16, 0, 0, 24891, 24892, 7, 10, 0, 0, 24892, 24893, 7, 11, 0, 0, 24893, 24894, 7, 4, 0, 0, 24894, 24895, 7, 6, 0, 0, 24895, 24896, 7, 3, 0, 0, 24896, 24897, 5, 95, 0, 0, 24897, 24898, 7, 11, 0, 0, 24898, 24899, 7, 10, 0, 0, 24899, 24900, 7, 5, 0, 0, 24900, 24901, 7, 4, 0, 0, 24901, 3692, 1, 0, 0, 0, 24902, 24903, 7, 5, 0, 0, 24903, 24904, 7, 18, 0, 0, 24904, 24905, 7, 5, 0, 0, 24905, 24906, 5, 95, 0, 0, 24906, 24907, 7, 2, 0, 0, 24907, 24908, 7, 15, 0, 0, 24908, 24909, 5, 95, 0, 0, 24909, 24910, 7, 1, 0, 0, 24910, 24911, 7, 11, 0, 0, 24911, 24912, 7, 2, 0, 0, 24912, 24913, 7, 2, 0, 0, 24913, 24914, 7, 14, 0, 0, 24914, 24915, 5, 95, 0, 0, 24915, 24916, 7, 16, 0, 0, 24916, 24917, 7, 10, 0, 0, 24917, 24918, 7, 11, 0, 0, 24918, 24919, 7, 4, 0, 0, 24919, 24920, 7, 6, 0, 0, 24920, 24921, 7, 3, 0, 0, 24921, 3694, 1, 0, 0, 0, 24922, 24923, 7, 5, 0, 0, 24923, 24924, 7, 18, 0, 0, 24924, 24925, 7, 5, 0, 0, 24925, 24926, 5, 95, 0, 0, 24926, 24927, 7, 2, 0, 0, 24927, 24928, 7, 15, 0, 0, 24928, 24929, 5, 95, 0, 0, 24929, 24930, 7, 8, 0, 0, 24930, 24931, 5, 50, 0, 0, 24931, 24932, 7, 8, 0, 0, 24932, 3696, 1, 0, 0, 0, 24933, 24934, 7, 5, 0, 0, 24934, 24935, 7, 18, 0, 0, 24935, 24936, 7, 5, 0, 0, 24936, 24937, 5, 95, 0, 0, 24937, 24938, 7, 2, 0, 0, 24938, 24939, 7, 15, 0, 0, 24939, 24940, 5, 95, 0, 0, 24940, 24941, 7, 8, 0, 0, 24941, 24942, 7, 0, 0, 0, 24942, 24943, 7, 5, 0, 0, 24943, 24944, 7, 4, 0, 0, 24944, 3698, 1, 0, 0, 0, 24945, 24946, 7, 5, 0, 0, 24946, 24947, 7, 18, 0, 0, 24947, 24948, 7, 5, 0, 0, 24948, 24949, 5, 95, 0, 0, 24949, 24950, 7, 2, 0, 0, 24950, 24951, 7, 15, 0, 0, 24951, 24952, 5, 95, 0, 0, 24952, 24953, 7, 8, 0, 0, 24953, 24954, 7, 6, 0, 0, 24954, 24955, 7, 17, 0, 0, 24955, 3700, 1, 0, 0, 0, 24956, 24957, 7, 5, 0, 0, 24957, 24958, 7, 18, 0, 0, 24958, 24959, 7, 5, 0, 0, 24959, 24960, 5, 95, 0, 0, 24960, 24961, 7, 2, 0, 0, 24961, 24962, 7, 15, 0, 0, 24962, 24963, 5, 95, 0, 0, 24963, 24964, 7, 8, 0, 0, 24964, 24965, 7, 11, 0, 0, 24965, 24966, 5, 50, 0, 0, 24966, 24967, 7, 8, 0, 0, 24967, 3702, 1, 0, 0, 0, 24968, 24969, 7, 5, 0, 0, 24969, 24970, 7, 18, 0, 0, 24970, 24971, 7, 5, 0, 0, 24971, 24972, 5, 95, 0, 0, 24972, 24973, 7, 2, 0, 0, 24973, 24974, 7, 15, 0, 0, 24974, 24975, 5, 95, 0, 0, 24975, 24976, 7, 8, 0, 0, 24976, 24977, 7, 2, 0, 0, 24977, 24978, 7, 14, 0, 0, 24978, 24979, 7, 1, 0, 0, 24979, 24980, 7, 10, 0, 0, 24980, 24981, 7, 7, 0, 0, 24981, 24982, 7, 6, 0, 0, 24982, 24983, 7, 9, 0, 0, 24983, 24984, 5, 95, 0, 0, 24984, 24985, 7, 19, 0, 0, 24985, 24986, 7, 0, 0, 0, 24986, 24987, 7, 5, 0, 0, 24987, 24988, 7, 19, 0, 0, 24988, 3704, 1, 0, 0, 0, 24989, 24990, 7, 5, 0, 0, 24990, 24991, 7, 18, 0, 0, 24991, 24992, 7, 5, 0, 0, 24992, 24993, 5, 95, 0, 0, 24993, 24994, 7, 2, 0, 0, 24994, 24995, 7, 15, 0, 0, 24995, 24996, 5, 95, 0, 0, 24996, 24997, 7, 8, 0, 0, 24997, 24998, 7, 2, 0, 0, 24998, 24999, 7, 14, 0, 0, 24999, 25000, 7, 15, 0, 0, 25000, 3706, 1, 0, 0, 0, 25001, 25002, 7, 5, 0, 0, 25002, 25003, 7, 18, 0, 0, 25003, 25004, 7, 5, 0, 0, 25004, 25005, 5, 95, 0, 0, 25005, 25006, 7, 2, 0, 0, 25006, 25007, 7, 15, 0, 0, 25007, 25008, 5, 95, 0, 0, 25008, 25009, 7, 8, 0, 0, 25009, 25010, 7, 2, 0, 0, 25010, 25011, 7, 7, 0, 0, 25011, 25012, 7, 13, 0, 0, 25012, 25013, 7, 6, 0, 0, 25013, 25014, 7, 3, 0, 0, 25014, 25015, 7, 4, 0, 0, 25015, 3708, 1, 0, 0, 0, 25016, 25017, 7, 5, 0, 0, 25017, 25018, 7, 18, 0, 0, 25018, 25019, 7, 5, 0, 0, 25019, 25020, 5, 95, 0, 0, 25020, 25021, 7, 2, 0, 0, 25021, 25022, 7, 15, 0, 0, 25022, 25023, 5, 95, 0, 0, 25023, 25024, 7, 8, 0, 0, 25024, 25025, 7, 2, 0, 0, 25025, 25026, 7, 12, 0, 0, 25026, 25027, 7, 7, 0, 0, 25027, 25028, 7, 4, 0, 0, 25028, 25029, 7, 8, 0, 0, 25029, 25030, 7, 19, 0, 0, 25030, 25031, 7, 17, 0, 0, 25031, 3710, 1, 0, 0, 0, 25032, 25033, 7, 5, 0, 0, 25033, 25034, 7, 18, 0, 0, 25034, 25035, 7, 5, 0, 0, 25035, 25036, 5, 95, 0, 0, 25036, 25037, 7, 2, 0, 0, 25037, 25038, 7, 15, 0, 0, 25038, 25039, 5, 95, 0, 0, 25039, 25040, 7, 8, 0, 0, 25040, 25041, 7, 5, 0, 0, 25041, 25042, 7, 8, 0, 0, 25042, 25043, 7, 2, 0, 0, 25043, 25044, 7, 7, 0, 0, 25044, 25045, 7, 13, 0, 0, 25045, 3712, 1, 0, 0, 0, 25046, 25047, 7, 5, 0, 0, 25047, 25048, 7, 18, 0, 0, 25048, 25049, 7, 5, 0, 0, 25049, 25050, 5, 95, 0, 0, 25050, 25051, 7, 2, 0, 0, 25051, 25052, 7, 15, 0, 0, 25052, 25053, 5, 95, 0, 0, 25053, 25054, 7, 8, 0, 0, 25054, 25055, 7, 5, 0, 0, 25055, 25056, 7, 8, 0, 0, 25056, 25057, 7, 2, 0, 0, 25057, 25058, 7, 7, 0, 0, 25058, 25059, 7, 13, 0, 0, 25059, 25060, 7, 4, 0, 0, 25060, 25061, 7, 6, 0, 0, 25061, 25062, 7, 5, 0, 0, 25062, 25063, 7, 4, 0, 0, 25063, 3714, 1, 0, 0, 0, 25064, 25065, 7, 5, 0, 0, 25065, 25066, 7, 18, 0, 0, 25066, 25067, 7, 5, 0, 0, 25067, 25068, 5, 95, 0, 0, 25068, 25069, 7, 2, 0, 0, 25069, 25070, 7, 15, 0, 0, 25070, 25071, 5, 95, 0, 0, 25071, 25072, 7, 8, 0, 0, 25072, 25073, 7, 5, 0, 0, 25073, 25074, 7, 3, 0, 0, 25074, 3716, 1, 0, 0, 0, 25075, 25076, 7, 5, 0, 0, 25076, 25077, 7, 18, 0, 0, 25077, 25078, 7, 5, 0, 0, 25078, 25079, 5, 95, 0, 0, 25079, 25080, 7, 2, 0, 0, 25080, 25081, 7, 15, 0, 0, 25081, 25082, 5, 95, 0, 0, 25082, 25083, 7, 8, 0, 0, 25083, 25084, 7, 5, 0, 0, 25084, 25085, 7, 25, 0, 0, 25085, 25086, 5, 95, 0, 0, 25086, 25087, 7, 15, 0, 0, 25087, 25088, 7, 0, 0, 0, 25088, 25089, 7, 4, 0, 0, 25089, 25090, 7, 8, 0, 0, 25090, 25091, 7, 19, 0, 0, 25091, 3718, 1, 0, 0, 0, 25092, 25093, 7, 5, 0, 0, 25093, 25094, 7, 18, 0, 0, 25094, 25095, 7, 5, 0, 0, 25095, 25096, 5, 95, 0, 0, 25096, 25097, 7, 2, 0, 0, 25097, 25098, 7, 15, 0, 0, 25098, 25099, 5, 95, 0, 0, 25099, 25100, 7, 8, 0, 0, 25100, 25101, 7, 18, 0, 0, 25101, 25102, 7, 8, 0, 0, 25102, 25103, 7, 11, 0, 0, 25103, 25104, 7, 6, 0, 0, 25104, 25105, 7, 9, 0, 0, 25105, 25106, 5, 95, 0, 0, 25106, 25107, 7, 5, 0, 0, 25107, 25108, 7, 6, 0, 0, 25108, 25109, 7, 24, 0, 0, 25109, 3720, 1, 0, 0, 0, 25110, 25111, 7, 5, 0, 0, 25111, 25112, 7, 18, 0, 0, 25112, 25113, 7, 5, 0, 0, 25113, 25114, 5, 95, 0, 0, 25114, 25115, 7, 2, 0, 0, 25115, 25116, 7, 15, 0, 0, 25116, 25117, 5, 95, 0, 0, 25117, 25118, 7, 9, 0, 0, 25118, 25119, 7, 6, 0, 0, 25119, 25120, 7, 8, 0, 0, 25120, 25121, 7, 2, 0, 0, 25121, 25122, 7, 14, 0, 0, 25122, 25123, 7, 15, 0, 0, 25123, 3722, 1, 0, 0, 0, 25124, 25125, 7, 5, 0, 0, 25125, 25126, 7, 18, 0, 0, 25126, 25127, 7, 5, 0, 0, 25127, 25128, 5, 95, 0, 0, 25128, 25129, 7, 2, 0, 0, 25129, 25130, 7, 15, 0, 0, 25130, 25131, 5, 95, 0, 0, 25131, 25132, 7, 9, 0, 0, 25132, 25133, 7, 6, 0, 0, 25133, 25134, 7, 5, 0, 0, 25134, 25135, 7, 8, 0, 0, 25135, 25136, 7, 6, 0, 0, 25136, 25137, 7, 7, 0, 0, 25137, 25138, 7, 9, 0, 0, 25138, 3724, 1, 0, 0, 0, 25139, 25140, 7, 5, 0, 0, 25140, 25141, 7, 18, 0, 0, 25141, 25142, 7, 5, 0, 0, 25142, 25143, 5, 95, 0, 0, 25143, 25144, 7, 2, 0, 0, 25144, 25145, 7, 15, 0, 0, 25145, 25146, 5, 95, 0, 0, 25146, 25147, 7, 9, 0, 0, 25147, 25148, 7, 10, 0, 0, 25148, 25149, 7, 5, 0, 0, 25149, 25150, 7, 4, 0, 0, 25150, 25151, 7, 10, 0, 0, 25151, 25152, 7, 7, 0, 0, 25152, 25153, 7, 8, 0, 0, 25153, 25154, 7, 4, 0, 0, 25154, 3726, 1, 0, 0, 0, 25155, 25156, 7, 5, 0, 0, 25156, 25157, 7, 18, 0, 0, 25157, 25158, 7, 5, 0, 0, 25158, 25159, 5, 95, 0, 0, 25159, 25160, 7, 2, 0, 0, 25160, 25161, 7, 15, 0, 0, 25161, 25162, 5, 95, 0, 0, 25162, 25163, 7, 9, 0, 0, 25163, 25164, 7, 3, 0, 0, 25164, 25165, 7, 0, 0, 0, 25165, 3728, 1, 0, 0, 0, 25166, 25167, 7, 5, 0, 0, 25167, 25168, 7, 18, 0, 0, 25168, 25169, 7, 5, 0, 0, 25169, 25170, 5, 95, 0, 0, 25170, 25171, 7, 2, 0, 0, 25171, 25172, 7, 15, 0, 0, 25172, 25173, 5, 95, 0, 0, 25173, 25174, 7, 9, 0, 0, 25174, 25175, 7, 12, 0, 0, 25175, 25176, 7, 14, 0, 0, 25176, 25177, 7, 15, 0, 0, 25177, 3730, 1, 0, 0, 0, 25178, 25179, 7, 5, 0, 0, 25179, 25180, 7, 18, 0, 0, 25180, 25181, 7, 5, 0, 0, 25181, 25182, 5, 95, 0, 0, 25182, 25183, 7, 2, 0, 0, 25183, 25184, 7, 15, 0, 0, 25184, 25185, 5, 95, 0, 0, 25185, 25186, 7, 9, 0, 0, 25186, 25187, 7, 13, 0, 0, 25187, 25188, 5, 95, 0, 0, 25188, 25189, 7, 8, 0, 0, 25189, 25190, 7, 19, 0, 0, 25190, 25191, 7, 6, 0, 0, 25191, 25192, 7, 8, 0, 0, 25192, 25193, 7, 21, 0, 0, 25193, 3732, 1, 0, 0, 0, 25194, 25195, 7, 5, 0, 0, 25195, 25196, 7, 18, 0, 0, 25196, 25197, 7, 5, 0, 0, 25197, 25198, 5, 95, 0, 0, 25198, 25199, 7, 2, 0, 0, 25199, 25200, 7, 15, 0, 0, 25200, 25201, 5, 95, 0, 0, 25201, 25202, 7, 6, 0, 0, 25202, 25203, 7, 7, 0, 0, 25203, 25204, 7, 16, 0, 0, 25204, 25205, 7, 2, 0, 0, 25205, 25206, 7, 3, 0, 0, 25206, 25207, 7, 8, 0, 0, 25207, 25208, 7, 6, 0, 0, 25208, 25209, 5, 95, 0, 0, 25209, 25210, 7, 7, 0, 0, 25210, 25211, 7, 2, 0, 0, 25211, 25212, 7, 4, 0, 0, 25212, 25213, 5, 95, 0, 0, 25213, 25214, 7, 7, 0, 0, 25214, 25215, 7, 12, 0, 0, 25215, 25216, 7, 11, 0, 0, 25216, 25217, 7, 11, 0, 0, 25217, 25218, 5, 36, 0, 0, 25218, 3734, 1, 0, 0, 0, 25219, 25220, 7, 5, 0, 0, 25220, 25221, 7, 18, 0, 0, 25221, 25222, 7, 5, 0, 0, 25222, 25223, 7, 2, 0, 0, 25223, 25224, 7, 15, 0, 0, 25224, 25225, 7, 6, 0, 0, 25225, 25226, 7, 3, 0, 0, 25226, 3736, 1, 0, 0, 0, 25227, 25228, 7, 5, 0, 0, 25228, 25229, 7, 18, 0, 0, 25229, 25230, 7, 5, 0, 0, 25230, 25231, 5, 95, 0, 0, 25231, 25232, 7, 2, 0, 0, 25232, 25233, 7, 15, 0, 0, 25233, 25234, 5, 95, 0, 0, 25234, 25235, 7, 6, 0, 0, 25235, 25236, 7, 25, 0, 0, 25236, 25237, 7, 4, 0, 0, 25237, 25238, 7, 3, 0, 0, 25238, 25239, 7, 0, 0, 0, 25239, 25240, 7, 8, 0, 0, 25240, 25241, 7, 4, 0, 0, 25241, 3738, 1, 0, 0, 0, 25242, 25243, 7, 5, 0, 0, 25243, 25244, 7, 18, 0, 0, 25244, 25245, 7, 5, 0, 0, 25245, 25246, 5, 95, 0, 0, 25246, 25247, 7, 2, 0, 0, 25247, 25248, 7, 15, 0, 0, 25248, 25249, 5, 95, 0, 0, 25249, 25250, 7, 17, 0, 0, 25250, 25251, 7, 3, 0, 0, 25251, 25252, 7, 2, 0, 0, 25252, 25253, 7, 12, 0, 0, 25253, 25254, 7, 15, 0, 0, 25254, 25255, 7, 10, 0, 0, 25255, 25256, 7, 7, 0, 0, 25256, 25257, 7, 17, 0, 0, 25257, 3740, 1, 0, 0, 0, 25258, 25259, 7, 5, 0, 0, 25259, 25260, 7, 18, 0, 0, 25260, 25261, 7, 5, 0, 0, 25261, 25262, 5, 95, 0, 0, 25262, 25263, 7, 2, 0, 0, 25263, 25264, 7, 15, 0, 0, 25264, 25265, 5, 95, 0, 0, 25265, 25266, 7, 17, 0, 0, 25266, 25267, 7, 12, 0, 0, 25267, 25268, 7, 10, 0, 0, 25268, 25269, 7, 9, 0, 0, 25269, 3742, 1, 0, 0, 0, 25270, 25271, 7, 5, 0, 0, 25271, 25272, 7, 18, 0, 0, 25272, 25273, 7, 5, 0, 0, 25273, 25274, 5, 95, 0, 0, 25274, 25275, 7, 2, 0, 0, 25275, 25276, 7, 15, 0, 0, 25276, 25277, 5, 95, 0, 0, 25277, 25278, 7, 19, 0, 0, 25278, 25279, 7, 0, 0, 0, 25279, 25280, 7, 5, 0, 0, 25280, 25281, 7, 19, 0, 0, 25281, 3744, 1, 0, 0, 0, 25282, 25283, 7, 5, 0, 0, 25283, 25284, 7, 18, 0, 0, 25284, 25285, 7, 5, 0, 0, 25285, 25286, 5, 95, 0, 0, 25286, 25287, 7, 2, 0, 0, 25287, 25288, 7, 15, 0, 0, 25288, 25289, 5, 95, 0, 0, 25289, 25290, 7, 10, 0, 0, 25290, 25291, 7, 10, 0, 0, 25291, 25292, 7, 25, 0, 0, 25292, 3746, 1, 0, 0, 0, 25293, 25294, 7, 5, 0, 0, 25294, 25295, 7, 18, 0, 0, 25295, 25296, 7, 5, 0, 0, 25296, 25297, 5, 95, 0, 0, 25297, 25298, 7, 2, 0, 0, 25298, 25299, 7, 15, 0, 0, 25299, 25300, 5, 95, 0, 0, 25300, 25301, 7, 10, 0, 0, 25301, 25302, 7, 4, 0, 0, 25302, 25303, 7, 3, 0, 0, 25303, 3748, 1, 0, 0, 0, 25304, 25305, 7, 5, 0, 0, 25305, 25306, 7, 18, 0, 0, 25306, 25307, 7, 5, 0, 0, 25307, 25308, 5, 95, 0, 0, 25308, 25309, 7, 2, 0, 0, 25309, 25310, 7, 15, 0, 0, 25310, 25311, 5, 95, 0, 0, 25311, 25312, 7, 21, 0, 0, 25312, 25313, 7, 6, 0, 0, 25313, 25314, 7, 18, 0, 0, 25314, 25315, 5, 95, 0, 0, 25315, 25316, 7, 13, 0, 0, 25316, 25317, 7, 6, 0, 0, 25317, 25318, 7, 8, 0, 0, 25318, 25319, 7, 4, 0, 0, 25319, 25320, 7, 2, 0, 0, 25320, 25321, 7, 3, 0, 0, 25321, 25322, 5, 95, 0, 0, 25322, 25323, 7, 8, 0, 0, 25323, 25324, 7, 3, 0, 0, 25324, 25325, 7, 6, 0, 0, 25325, 25326, 7, 0, 0, 0, 25326, 25327, 7, 4, 0, 0, 25327, 25328, 7, 6, 0, 0, 25328, 3750, 1, 0, 0, 0, 25329, 25330, 7, 5, 0, 0, 25330, 25331, 7, 18, 0, 0, 25331, 25332, 7, 5, 0, 0, 25332, 25333, 5, 95, 0, 0, 25333, 25334, 7, 2, 0, 0, 25334, 25335, 7, 15, 0, 0, 25335, 25336, 5, 95, 0, 0, 25336, 25337, 7, 21, 0, 0, 25337, 25338, 7, 6, 0, 0, 25338, 25339, 7, 18, 0, 0, 25339, 25340, 5, 95, 0, 0, 25340, 25341, 7, 13, 0, 0, 25341, 25342, 7, 6, 0, 0, 25342, 25343, 7, 8, 0, 0, 25343, 25344, 7, 4, 0, 0, 25344, 25345, 7, 2, 0, 0, 25345, 25346, 7, 3, 0, 0, 25346, 25347, 5, 95, 0, 0, 25347, 25348, 7, 16, 0, 0, 25348, 25349, 7, 10, 0, 0, 25349, 25350, 7, 11, 0, 0, 25350, 25351, 7, 4, 0, 0, 25351, 25352, 7, 6, 0, 0, 25352, 25353, 7, 3, 0, 0, 25353, 25354, 5, 95, 0, 0, 25354, 25355, 7, 11, 0, 0, 25355, 25356, 7, 10, 0, 0, 25356, 25357, 7, 5, 0, 0, 25357, 25358, 7, 4, 0, 0, 25358, 3752, 1, 0, 0, 0, 25359, 25360, 7, 5, 0, 0, 25360, 25361, 7, 18, 0, 0, 25361, 25362, 7, 5, 0, 0, 25362, 25363, 5, 95, 0, 0, 25363, 25364, 7, 2, 0, 0, 25364, 25365, 7, 15, 0, 0, 25365, 25366, 5, 95, 0, 0, 25366, 25367, 7, 21, 0, 0, 25367, 25368, 7, 6, 0, 0, 25368, 25369, 7, 18, 0, 0, 25369, 25370, 5, 95, 0, 0, 25370, 25371, 7, 13, 0, 0, 25371, 25372, 7, 6, 0, 0, 25372, 25373, 7, 8, 0, 0, 25373, 25374, 7, 4, 0, 0, 25374, 25375, 7, 2, 0, 0, 25375, 25376, 7, 3, 0, 0, 25376, 25377, 5, 95, 0, 0, 25377, 25378, 7, 16, 0, 0, 25378, 25379, 7, 10, 0, 0, 25379, 25380, 7, 11, 0, 0, 25380, 25381, 7, 4, 0, 0, 25381, 25382, 7, 6, 0, 0, 25382, 25383, 7, 3, 0, 0, 25383, 3754, 1, 0, 0, 0, 25384, 25385, 7, 5, 0, 0, 25385, 25386, 7, 18, 0, 0, 25386, 25387, 7, 5, 0, 0, 25387, 25388, 5, 95, 0, 0, 25388, 25389, 7, 2, 0, 0, 25389, 25390, 7, 15, 0, 0, 25390, 25391, 5, 95, 0, 0, 25391, 25392, 7, 21, 0, 0, 25392, 25393, 7, 6, 0, 0, 25393, 25394, 7, 18, 0, 0, 25394, 25395, 5, 95, 0, 0, 25395, 25396, 7, 13, 0, 0, 25396, 25397, 7, 6, 0, 0, 25397, 25398, 7, 8, 0, 0, 25398, 25399, 7, 4, 0, 0, 25399, 25400, 7, 2, 0, 0, 25400, 25401, 7, 3, 0, 0, 25401, 25402, 5, 95, 0, 0, 25402, 25403, 7, 5, 0, 0, 25403, 25404, 7, 12, 0, 0, 25404, 25405, 7, 8, 0, 0, 25405, 25406, 7, 8, 0, 0, 25406, 25407, 7, 6, 0, 0, 25407, 25408, 7, 6, 0, 0, 25408, 25409, 7, 9, 0, 0, 25409, 25410, 7, 6, 0, 0, 25410, 25411, 7, 9, 0, 0, 25411, 3756, 1, 0, 0, 0, 25412, 25413, 7, 5, 0, 0, 25413, 25414, 7, 18, 0, 0, 25414, 25415, 7, 5, 0, 0, 25415, 25416, 5, 95, 0, 0, 25416, 25417, 7, 2, 0, 0, 25417, 25418, 7, 15, 0, 0, 25418, 25419, 5, 95, 0, 0, 25419, 25420, 7, 21, 0, 0, 25420, 25421, 7, 6, 0, 0, 25421, 25422, 7, 18, 0, 0, 25422, 25423, 5, 95, 0, 0, 25423, 25424, 7, 13, 0, 0, 25424, 25425, 7, 6, 0, 0, 25425, 25426, 7, 8, 0, 0, 25426, 25427, 7, 4, 0, 0, 25427, 25428, 7, 2, 0, 0, 25428, 25429, 7, 3, 0, 0, 25429, 25430, 5, 95, 0, 0, 25430, 25431, 7, 12, 0, 0, 25431, 25432, 7, 5, 0, 0, 25432, 25433, 7, 6, 0, 0, 25433, 3758, 1, 0, 0, 0, 25434, 25435, 7, 5, 0, 0, 25435, 25436, 7, 18, 0, 0, 25436, 25437, 7, 5, 0, 0, 25437, 25438, 5, 95, 0, 0, 25438, 25439, 7, 2, 0, 0, 25439, 25440, 7, 15, 0, 0, 25440, 25441, 5, 95, 0, 0, 25441, 25442, 7, 11, 0, 0, 25442, 25443, 7, 1, 0, 0, 25443, 25444, 7, 10, 0, 0, 25444, 25445, 7, 9, 0, 0, 25445, 3760, 1, 0, 0, 0, 25446, 25447, 7, 5, 0, 0, 25447, 25448, 7, 18, 0, 0, 25448, 25449, 7, 5, 0, 0, 25449, 25450, 5, 95, 0, 0, 25450, 25451, 7, 2, 0, 0, 25451, 25452, 7, 15, 0, 0, 25452, 25453, 5, 95, 0, 0, 25453, 25454, 7, 11, 0, 0, 25454, 25455, 7, 2, 0, 0, 25455, 25456, 7, 1, 0, 0, 25456, 25457, 7, 11, 0, 0, 25457, 25458, 7, 2, 0, 0, 25458, 25459, 7, 8, 0, 0, 25459, 25460, 5, 50, 0, 0, 25460, 25461, 7, 1, 0, 0, 25461, 25462, 7, 11, 0, 0, 25462, 25463, 7, 2, 0, 0, 25463, 25464, 7, 1, 0, 0, 25464, 3762, 1, 0, 0, 0, 25465, 25466, 7, 5, 0, 0, 25466, 25467, 7, 18, 0, 0, 25467, 25468, 7, 5, 0, 0, 25468, 25469, 5, 95, 0, 0, 25469, 25470, 7, 2, 0, 0, 25470, 25471, 7, 15, 0, 0, 25471, 25472, 5, 95, 0, 0, 25472, 25473, 7, 11, 0, 0, 25473, 25474, 7, 2, 0, 0, 25474, 25475, 7, 1, 0, 0, 25475, 25476, 7, 11, 0, 0, 25476, 25477, 7, 2, 0, 0, 25477, 25478, 7, 8, 0, 0, 25478, 25479, 5, 50, 0, 0, 25479, 25480, 7, 8, 0, 0, 25480, 25481, 7, 11, 0, 0, 25481, 25482, 7, 2, 0, 0, 25482, 25483, 7, 1, 0, 0, 25483, 3764, 1, 0, 0, 0, 25484, 25485, 7, 5, 0, 0, 25485, 25486, 7, 18, 0, 0, 25486, 25487, 7, 5, 0, 0, 25487, 25488, 5, 95, 0, 0, 25488, 25489, 7, 2, 0, 0, 25489, 25490, 7, 15, 0, 0, 25490, 25491, 5, 95, 0, 0, 25491, 25492, 7, 11, 0, 0, 25492, 25493, 7, 2, 0, 0, 25493, 25494, 7, 1, 0, 0, 25494, 25495, 7, 11, 0, 0, 25495, 25496, 7, 2, 0, 0, 25496, 25497, 7, 8, 0, 0, 25497, 25498, 5, 50, 0, 0, 25498, 25499, 7, 10, 0, 0, 25499, 25500, 7, 9, 0, 0, 25500, 3766, 1, 0, 0, 0, 25501, 25502, 7, 5, 0, 0, 25502, 25503, 7, 18, 0, 0, 25503, 25504, 7, 5, 0, 0, 25504, 25505, 5, 95, 0, 0, 25505, 25506, 7, 2, 0, 0, 25506, 25507, 7, 15, 0, 0, 25507, 25508, 5, 95, 0, 0, 25508, 25509, 7, 11, 0, 0, 25509, 25510, 7, 2, 0, 0, 25510, 25511, 7, 1, 0, 0, 25511, 25512, 7, 11, 0, 0, 25512, 25513, 7, 2, 0, 0, 25513, 25514, 7, 8, 0, 0, 25514, 25515, 5, 50, 0, 0, 25515, 25516, 7, 7, 0, 0, 25516, 25517, 7, 8, 0, 0, 25517, 25518, 7, 11, 0, 0, 25518, 25519, 7, 2, 0, 0, 25519, 25520, 7, 1, 0, 0, 25520, 3768, 1, 0, 0, 0, 25521, 25522, 7, 5, 0, 0, 25522, 25523, 7, 18, 0, 0, 25523, 25524, 7, 5, 0, 0, 25524, 25525, 5, 95, 0, 0, 25525, 25526, 7, 2, 0, 0, 25526, 25527, 7, 15, 0, 0, 25527, 25528, 5, 95, 0, 0, 25528, 25529, 7, 11, 0, 0, 25529, 25530, 7, 2, 0, 0, 25530, 25531, 7, 1, 0, 0, 25531, 25532, 7, 11, 0, 0, 25532, 25533, 7, 2, 0, 0, 25533, 25534, 7, 8, 0, 0, 25534, 25535, 5, 50, 0, 0, 25535, 25536, 7, 4, 0, 0, 25536, 25537, 7, 18, 0, 0, 25537, 25538, 7, 15, 0, 0, 25538, 3770, 1, 0, 0, 0, 25539, 25540, 7, 5, 0, 0, 25540, 25541, 7, 18, 0, 0, 25541, 25542, 7, 5, 0, 0, 25542, 25543, 5, 95, 0, 0, 25543, 25544, 7, 2, 0, 0, 25544, 25545, 7, 15, 0, 0, 25545, 25546, 5, 95, 0, 0, 25546, 25547, 7, 11, 0, 0, 25547, 25548, 7, 5, 0, 0, 25548, 25549, 7, 13, 0, 0, 25549, 25550, 7, 10, 0, 0, 25550, 3772, 1, 0, 0, 0, 25551, 25552, 7, 5, 0, 0, 25552, 25553, 7, 18, 0, 0, 25553, 25554, 7, 5, 0, 0, 25554, 25555, 5, 95, 0, 0, 25555, 25556, 7, 2, 0, 0, 25556, 25557, 7, 15, 0, 0, 25557, 25558, 5, 95, 0, 0, 25558, 25559, 7, 11, 0, 0, 25559, 25560, 7, 13, 0, 0, 25560, 25561, 7, 11, 0, 0, 25561, 3774, 1, 0, 0, 0, 25562, 25563, 7, 5, 0, 0, 25563, 25564, 7, 18, 0, 0, 25564, 25565, 7, 5, 0, 0, 25565, 25566, 5, 95, 0, 0, 25566, 25567, 7, 2, 0, 0, 25567, 25568, 7, 15, 0, 0, 25568, 25569, 5, 95, 0, 0, 25569, 25570, 7, 14, 0, 0, 25570, 25571, 7, 0, 0, 0, 25571, 25572, 7, 21, 0, 0, 25572, 25573, 7, 6, 0, 0, 25573, 25574, 7, 2, 0, 0, 25574, 25575, 7, 10, 0, 0, 25575, 25576, 7, 9, 0, 0, 25576, 3776, 1, 0, 0, 0, 25577, 25578, 7, 5, 0, 0, 25578, 25579, 7, 18, 0, 0, 25579, 25580, 7, 5, 0, 0, 25580, 25581, 5, 95, 0, 0, 25581, 25582, 7, 2, 0, 0, 25582, 25583, 7, 15, 0, 0, 25583, 25584, 5, 95, 0, 0, 25584, 25585, 7, 14, 0, 0, 25585, 25586, 7, 0, 0, 0, 25586, 25587, 7, 15, 0, 0, 25587, 25588, 5, 95, 0, 0, 25588, 25589, 7, 7, 0, 0, 25589, 25590, 7, 2, 0, 0, 25590, 25591, 7, 7, 0, 0, 25591, 25592, 7, 7, 0, 0, 25592, 25593, 7, 12, 0, 0, 25593, 25594, 7, 11, 0, 0, 25594, 25595, 7, 11, 0, 0, 25595, 3778, 1, 0, 0, 0, 25596, 25597, 7, 5, 0, 0, 25597, 25598, 7, 18, 0, 0, 25598, 25599, 7, 5, 0, 0, 25599, 25600, 5, 95, 0, 0, 25600, 25601, 7, 2, 0, 0, 25601, 25602, 7, 15, 0, 0, 25602, 25603, 5, 95, 0, 0, 25603, 25604, 7, 14, 0, 0, 25604, 25605, 7, 5, 0, 0, 25605, 25606, 7, 3, 0, 0, 25606, 3780, 1, 0, 0, 0, 25607, 25608, 7, 5, 0, 0, 25608, 25609, 7, 18, 0, 0, 25609, 25610, 7, 5, 0, 0, 25610, 25611, 5, 95, 0, 0, 25611, 25612, 7, 2, 0, 0, 25612, 25613, 7, 15, 0, 0, 25613, 25614, 5, 95, 0, 0, 25614, 25615, 7, 7, 0, 0, 25615, 25616, 7, 10, 0, 0, 25616, 25617, 7, 8, 0, 0, 25617, 25618, 7, 2, 0, 0, 25618, 25619, 7, 14, 0, 0, 25619, 25620, 7, 1, 0, 0, 25620, 25621, 7, 10, 0, 0, 25621, 25622, 7, 7, 0, 0, 25622, 25623, 7, 6, 0, 0, 25623, 3782, 1, 0, 0, 0, 25624, 25625, 7, 5, 0, 0, 25625, 25626, 7, 18, 0, 0, 25626, 25627, 7, 5, 0, 0, 25627, 25628, 5, 95, 0, 0, 25628, 25629, 7, 2, 0, 0, 25629, 25630, 7, 15, 0, 0, 25630, 25631, 5, 95, 0, 0, 25631, 25632, 7, 7, 0, 0, 25632, 25633, 7, 10, 0, 0, 25633, 25634, 7, 6, 0, 0, 25634, 25635, 7, 25, 0, 0, 25635, 25636, 7, 4, 0, 0, 25636, 25637, 7, 3, 0, 0, 25637, 25638, 7, 0, 0, 0, 25638, 25639, 7, 8, 0, 0, 25639, 25640, 7, 4, 0, 0, 25640, 3784, 1, 0, 0, 0, 25641, 25642, 7, 5, 0, 0, 25642, 25643, 7, 18, 0, 0, 25643, 25644, 7, 5, 0, 0, 25644, 25645, 5, 95, 0, 0, 25645, 25646, 7, 2, 0, 0, 25646, 25647, 7, 15, 0, 0, 25647, 25648, 5, 95, 0, 0, 25648, 25649, 7, 7, 0, 0, 25649, 25650, 7, 10, 0, 0, 25650, 25651, 7, 10, 0, 0, 25651, 3786, 1, 0, 0, 0, 25652, 25653, 7, 5, 0, 0, 25653, 25654, 7, 18, 0, 0, 25654, 25655, 7, 5, 0, 0, 25655, 25656, 5, 95, 0, 0, 25656, 25657, 7, 2, 0, 0, 25657, 25658, 7, 15, 0, 0, 25658, 25659, 5, 95, 0, 0, 25659, 25660, 7, 7, 0, 0, 25660, 25661, 7, 10, 0, 0, 25661, 25662, 7, 25, 0, 0, 25662, 3788, 1, 0, 0, 0, 25663, 25664, 7, 5, 0, 0, 25664, 25665, 7, 18, 0, 0, 25665, 25666, 7, 5, 0, 0, 25666, 25667, 5, 95, 0, 0, 25667, 25668, 7, 2, 0, 0, 25668, 25669, 7, 15, 0, 0, 25669, 25670, 5, 95, 0, 0, 25670, 25671, 7, 7, 0, 0, 25671, 25672, 7, 2, 0, 0, 25672, 25673, 7, 6, 0, 0, 25673, 25674, 7, 25, 0, 0, 25674, 25675, 7, 15, 0, 0, 25675, 25676, 7, 0, 0, 0, 25676, 25677, 7, 7, 0, 0, 25677, 25678, 7, 9, 0, 0, 25678, 3790, 1, 0, 0, 0, 25679, 25680, 7, 5, 0, 0, 25680, 25681, 7, 18, 0, 0, 25681, 25682, 7, 5, 0, 0, 25682, 25683, 5, 95, 0, 0, 25683, 25684, 7, 2, 0, 0, 25684, 25685, 7, 15, 0, 0, 25685, 25686, 5, 95, 0, 0, 25686, 25687, 7, 7, 0, 0, 25687, 25688, 7, 4, 0, 0, 25688, 25689, 7, 8, 0, 0, 25689, 25690, 7, 10, 0, 0, 25690, 25691, 7, 14, 0, 0, 25691, 25692, 7, 17, 0, 0, 25692, 25693, 5, 36, 0, 0, 25693, 3792, 1, 0, 0, 0, 25694, 25695, 7, 5, 0, 0, 25695, 25696, 7, 18, 0, 0, 25696, 25697, 7, 5, 0, 0, 25697, 25698, 5, 95, 0, 0, 25698, 25699, 7, 2, 0, 0, 25699, 25700, 7, 15, 0, 0, 25700, 25701, 5, 95, 0, 0, 25701, 25702, 7, 7, 0, 0, 25702, 25703, 7, 12, 0, 0, 25703, 25704, 7, 14, 0, 0, 25704, 25705, 7, 4, 0, 0, 25705, 25706, 7, 2, 0, 0, 25706, 25707, 7, 3, 0, 0, 25707, 25708, 7, 0, 0, 0, 25708, 25709, 7, 22, 0, 0, 25709, 3794, 1, 0, 0, 0, 25710, 25711, 7, 5, 0, 0, 25711, 25712, 7, 18, 0, 0, 25712, 25713, 7, 5, 0, 0, 25713, 25714, 5, 95, 0, 0, 25714, 25715, 7, 2, 0, 0, 25715, 25716, 7, 15, 0, 0, 25716, 25717, 5, 95, 0, 0, 25717, 25718, 7, 2, 0, 0, 25718, 25719, 7, 10, 0, 0, 25719, 25720, 7, 9, 0, 0, 25720, 25721, 7, 13, 0, 0, 25721, 25722, 7, 0, 0, 0, 25722, 25723, 7, 11, 0, 0, 25723, 25724, 7, 12, 0, 0, 25724, 25725, 7, 6, 0, 0, 25725, 3796, 1, 0, 0, 0, 25726, 25727, 7, 5, 0, 0, 25727, 25728, 7, 18, 0, 0, 25728, 25729, 7, 5, 0, 0, 25729, 25730, 5, 95, 0, 0, 25730, 25731, 7, 2, 0, 0, 25731, 25732, 7, 15, 0, 0, 25732, 25733, 5, 95, 0, 0, 25733, 25734, 7, 2, 0, 0, 25734, 25735, 7, 15, 0, 0, 25735, 25736, 7, 7, 0, 0, 25736, 25737, 7, 5, 0, 0, 25737, 25738, 7, 10, 0, 0, 25738, 25739, 7, 23, 0, 0, 25739, 25740, 7, 6, 0, 0, 25740, 3798, 1, 0, 0, 0, 25741, 25742, 7, 5, 0, 0, 25742, 25743, 7, 18, 0, 0, 25743, 25744, 7, 5, 0, 0, 25744, 25745, 5, 95, 0, 0, 25745, 25746, 7, 2, 0, 0, 25746, 25747, 7, 15, 0, 0, 25747, 25748, 5, 95, 0, 0, 25748, 25749, 7, 15, 0, 0, 25749, 25750, 7, 0, 0, 0, 25750, 25751, 7, 3, 0, 0, 25751, 25752, 5, 95, 0, 0, 25752, 25753, 5, 49, 0, 0, 25753, 3800, 1, 0, 0, 0, 25754, 25755, 7, 5, 0, 0, 25755, 25756, 7, 18, 0, 0, 25756, 25757, 7, 5, 0, 0, 25757, 25758, 5, 95, 0, 0, 25758, 25759, 7, 2, 0, 0, 25759, 25760, 7, 15, 0, 0, 25760, 25761, 5, 95, 0, 0, 25761, 25762, 7, 15, 0, 0, 25762, 25763, 7, 0, 0, 0, 25763, 25764, 7, 3, 0, 0, 25764, 25765, 7, 17, 0, 0, 25765, 25766, 7, 10, 0, 0, 25766, 25767, 7, 9, 0, 0, 25767, 25768, 5, 95, 0, 0, 25768, 25769, 5, 49, 0, 0, 25769, 3802, 1, 0, 0, 0, 25770, 25771, 7, 5, 0, 0, 25771, 25772, 7, 18, 0, 0, 25772, 25773, 7, 5, 0, 0, 25773, 25774, 5, 95, 0, 0, 25774, 25775, 7, 2, 0, 0, 25775, 25776, 7, 15, 0, 0, 25776, 25777, 5, 95, 0, 0, 25777, 25778, 7, 15, 0, 0, 25778, 25779, 7, 0, 0, 0, 25779, 25780, 7, 3, 0, 0, 25780, 25781, 7, 17, 0, 0, 25781, 25782, 7, 10, 0, 0, 25782, 25783, 7, 9, 0, 0, 25783, 3804, 1, 0, 0, 0, 25784, 25785, 7, 5, 0, 0, 25785, 25786, 7, 18, 0, 0, 25786, 25787, 7, 5, 0, 0, 25787, 25788, 5, 95, 0, 0, 25788, 25789, 7, 2, 0, 0, 25789, 25790, 7, 15, 0, 0, 25790, 25791, 5, 95, 0, 0, 25791, 25792, 7, 15, 0, 0, 25792, 25793, 7, 0, 0, 0, 25793, 25794, 7, 3, 0, 0, 25794, 3806, 1, 0, 0, 0, 25795, 25796, 7, 5, 0, 0, 25796, 25797, 7, 18, 0, 0, 25797, 25798, 7, 5, 0, 0, 25798, 25799, 5, 95, 0, 0, 25799, 25800, 7, 2, 0, 0, 25800, 25801, 7, 15, 0, 0, 25801, 25802, 5, 95, 0, 0, 25802, 25803, 7, 15, 0, 0, 25803, 25804, 7, 0, 0, 0, 25804, 25805, 7, 3, 0, 0, 25805, 25806, 7, 4, 0, 0, 25806, 25807, 5, 95, 0, 0, 25807, 25808, 7, 10, 0, 0, 25808, 25809, 7, 9, 0, 0, 25809, 3808, 1, 0, 0, 0, 25810, 25811, 7, 5, 0, 0, 25811, 25812, 7, 18, 0, 0, 25812, 25813, 7, 5, 0, 0, 25813, 25814, 5, 95, 0, 0, 25814, 25815, 7, 2, 0, 0, 25815, 25816, 7, 15, 0, 0, 25816, 25817, 5, 95, 0, 0, 25817, 25818, 7, 15, 0, 0, 25818, 25819, 7, 10, 0, 0, 25819, 25820, 7, 13, 0, 0, 25820, 25821, 7, 2, 0, 0, 25821, 25822, 7, 4, 0, 0, 25822, 3810, 1, 0, 0, 0, 25823, 25824, 7, 5, 0, 0, 25824, 25825, 7, 18, 0, 0, 25825, 25826, 7, 5, 0, 0, 25826, 25827, 5, 95, 0, 0, 25827, 25828, 7, 2, 0, 0, 25828, 25829, 7, 15, 0, 0, 25829, 25830, 5, 95, 0, 0, 25830, 25831, 7, 3, 0, 0, 25831, 25832, 5, 50, 0, 0, 25832, 25833, 7, 2, 0, 0, 25833, 3812, 1, 0, 0, 0, 25834, 25835, 7, 5, 0, 0, 25835, 25836, 7, 18, 0, 0, 25836, 25837, 7, 5, 0, 0, 25837, 25838, 5, 95, 0, 0, 25838, 25839, 7, 2, 0, 0, 25839, 25840, 7, 15, 0, 0, 25840, 25841, 5, 95, 0, 0, 25841, 25842, 7, 3, 0, 0, 25842, 25843, 7, 0, 0, 0, 25843, 25844, 7, 22, 0, 0, 25844, 25845, 7, 4, 0, 0, 25845, 25846, 7, 2, 0, 0, 25846, 25847, 7, 7, 0, 0, 25847, 25848, 7, 12, 0, 0, 25848, 25849, 7, 14, 0, 0, 25849, 3814, 1, 0, 0, 0, 25850, 25851, 7, 5, 0, 0, 25851, 25852, 7, 18, 0, 0, 25852, 25853, 7, 5, 0, 0, 25853, 25854, 5, 95, 0, 0, 25854, 25855, 7, 2, 0, 0, 25855, 25856, 7, 15, 0, 0, 25856, 25857, 5, 95, 0, 0, 25857, 25858, 7, 3, 0, 0, 25858, 25859, 7, 9, 0, 0, 25859, 25860, 7, 4, 0, 0, 25860, 25861, 7, 14, 0, 0, 25861, 3816, 1, 0, 0, 0, 25862, 25863, 7, 5, 0, 0, 25863, 25864, 7, 18, 0, 0, 25864, 25865, 7, 5, 0, 0, 25865, 25866, 5, 95, 0, 0, 25866, 25867, 7, 2, 0, 0, 25867, 25868, 7, 15, 0, 0, 25868, 25869, 5, 95, 0, 0, 25869, 25870, 7, 3, 0, 0, 25870, 25871, 7, 6, 0, 0, 25871, 25872, 7, 16, 0, 0, 25872, 3818, 1, 0, 0, 0, 25873, 25874, 7, 5, 0, 0, 25874, 25875, 7, 18, 0, 0, 25875, 25876, 7, 5, 0, 0, 25876, 25877, 5, 95, 0, 0, 25877, 25878, 7, 2, 0, 0, 25878, 25879, 7, 15, 0, 0, 25879, 25880, 5, 95, 0, 0, 25880, 25881, 7, 3, 0, 0, 25881, 25882, 7, 14, 0, 0, 25882, 25883, 7, 4, 0, 0, 25883, 25884, 7, 9, 0, 0, 25884, 3820, 1, 0, 0, 0, 25885, 25886, 7, 5, 0, 0, 25886, 25887, 7, 18, 0, 0, 25887, 25888, 7, 5, 0, 0, 25888, 25889, 5, 95, 0, 0, 25889, 25890, 7, 2, 0, 0, 25890, 25891, 7, 15, 0, 0, 25891, 25892, 5, 95, 0, 0, 25892, 25893, 7, 3, 0, 0, 25893, 25894, 7, 2, 0, 0, 25894, 25895, 7, 22, 0, 0, 25895, 25896, 7, 10, 0, 0, 25896, 25897, 7, 9, 0, 0, 25897, 25898, 7, 4, 0, 0, 25898, 25899, 7, 2, 0, 0, 25899, 25900, 7, 2, 0, 0, 25900, 25901, 7, 1, 0, 0, 25901, 25902, 7, 20, 0, 0, 25902, 3822, 1, 0, 0, 0, 25903, 25904, 7, 5, 0, 0, 25904, 25905, 7, 18, 0, 0, 25905, 25906, 7, 5, 0, 0, 25906, 25907, 5, 95, 0, 0, 25907, 25908, 7, 2, 0, 0, 25908, 25909, 7, 15, 0, 0, 25909, 25910, 5, 95, 0, 0, 25910, 25911, 7, 3, 0, 0, 25911, 25912, 7, 15, 0, 0, 25912, 25913, 7, 1, 0, 0, 25913, 3824, 1, 0, 0, 0, 25914, 25915, 7, 5, 0, 0, 25915, 25916, 7, 18, 0, 0, 25916, 25917, 7, 5, 0, 0, 25917, 25918, 5, 95, 0, 0, 25918, 25919, 7, 2, 0, 0, 25919, 25920, 7, 15, 0, 0, 25920, 25921, 7, 4, 0, 0, 25921, 25922, 7, 11, 0, 0, 25922, 25923, 7, 2, 0, 0, 25923, 25924, 7, 1, 0, 0, 25924, 25925, 7, 15, 0, 0, 25925, 25926, 7, 3, 0, 0, 25926, 25927, 7, 1, 0, 0, 25927, 25928, 7, 5, 0, 0, 25928, 25929, 7, 8, 0, 0, 25929, 3826, 1, 0, 0, 0, 25930, 25931, 7, 5, 0, 0, 25931, 25932, 7, 18, 0, 0, 25932, 25933, 7, 5, 0, 0, 25933, 25934, 5, 95, 0, 0, 25934, 25935, 7, 2, 0, 0, 25935, 25936, 7, 15, 0, 0, 25936, 25937, 5, 95, 0, 0, 25937, 25938, 7, 4, 0, 0, 25938, 25939, 7, 2, 0, 0, 25939, 25940, 7, 5, 0, 0, 25940, 25941, 7, 6, 0, 0, 25941, 25942, 7, 4, 0, 0, 25942, 25943, 7, 10, 0, 0, 25943, 25944, 7, 9, 0, 0, 25944, 3828, 1, 0, 0, 0, 25945, 25946, 7, 5, 0, 0, 25946, 25947, 7, 18, 0, 0, 25947, 25948, 7, 5, 0, 0, 25948, 25949, 5, 95, 0, 0, 25949, 25950, 7, 2, 0, 0, 25950, 25951, 7, 15, 0, 0, 25951, 25952, 5, 95, 0, 0, 25952, 25953, 7, 4, 0, 0, 25953, 25954, 7, 15, 0, 0, 25954, 25955, 7, 3, 0, 0, 25955, 3830, 1, 0, 0, 0, 25956, 25957, 7, 5, 0, 0, 25957, 25958, 7, 18, 0, 0, 25958, 25959, 7, 5, 0, 0, 25959, 25960, 5, 95, 0, 0, 25960, 25961, 7, 2, 0, 0, 25961, 25962, 7, 15, 0, 0, 25962, 25963, 5, 95, 0, 0, 25963, 25964, 7, 4, 0, 0, 25964, 25965, 7, 3, 0, 0, 25965, 25966, 7, 4, 0, 0, 25966, 25967, 7, 1, 0, 0, 25967, 3832, 1, 0, 0, 0, 25968, 25969, 7, 5, 0, 0, 25969, 25970, 7, 18, 0, 0, 25970, 25971, 7, 5, 0, 0, 25971, 25972, 5, 95, 0, 0, 25972, 25973, 7, 2, 0, 0, 25973, 25974, 7, 15, 0, 0, 25974, 25975, 7, 4, 0, 0, 25975, 25976, 7, 25, 0, 0, 25976, 25977, 7, 10, 0, 0, 25977, 25978, 7, 8, 0, 0, 25978, 25979, 7, 14, 0, 0, 25979, 25980, 7, 15, 0, 0, 25980, 3834, 1, 0, 0, 0, 25981, 25982, 7, 5, 0, 0, 25982, 25983, 7, 18, 0, 0, 25983, 25984, 7, 5, 0, 0, 25984, 25985, 5, 95, 0, 0, 25985, 25986, 7, 2, 0, 0, 25986, 25987, 7, 15, 0, 0, 25987, 25988, 7, 4, 0, 0, 25988, 25989, 7, 25, 0, 0, 25989, 25990, 7, 24, 0, 0, 25990, 25991, 7, 8, 0, 0, 25991, 25992, 7, 0, 0, 0, 25992, 25993, 7, 5, 0, 0, 25993, 25994, 7, 4, 0, 0, 25994, 25995, 7, 0, 0, 0, 25995, 25996, 7, 5, 0, 0, 25996, 25997, 7, 7, 0, 0, 25997, 25998, 7, 24, 0, 0, 25998, 3836, 1, 0, 0, 0, 25999, 26000, 7, 5, 0, 0, 26000, 26001, 7, 18, 0, 0, 26001, 26002, 7, 5, 0, 0, 26002, 26003, 5, 95, 0, 0, 26003, 26004, 7, 2, 0, 0, 26004, 26005, 7, 15, 0, 0, 26005, 26006, 5, 95, 0, 0, 26006, 26007, 7, 12, 0, 0, 26007, 26008, 7, 7, 0, 0, 26008, 26009, 7, 9, 0, 0, 26009, 26010, 7, 6, 0, 0, 26010, 26011, 7, 5, 0, 0, 26011, 26012, 7, 8, 0, 0, 26012, 26013, 7, 6, 0, 0, 26013, 26014, 7, 7, 0, 0, 26014, 26015, 7, 9, 0, 0, 26015, 3838, 1, 0, 0, 0, 26016, 26017, 7, 5, 0, 0, 26017, 26018, 7, 18, 0, 0, 26018, 26019, 7, 5, 0, 0, 26019, 26020, 5, 95, 0, 0, 26020, 26021, 7, 2, 0, 0, 26021, 26022, 7, 15, 0, 0, 26022, 26023, 5, 95, 0, 0, 26023, 26024, 7, 13, 0, 0, 26024, 26025, 7, 6, 0, 0, 26025, 26026, 7, 8, 0, 0, 26026, 26027, 7, 0, 0, 0, 26027, 26028, 7, 7, 0, 0, 26028, 26029, 7, 9, 0, 0, 26029, 3840, 1, 0, 0, 0, 26030, 26031, 7, 5, 0, 0, 26031, 26032, 7, 18, 0, 0, 26032, 26033, 7, 5, 0, 0, 26033, 26034, 5, 95, 0, 0, 26034, 26035, 7, 2, 0, 0, 26035, 26036, 7, 15, 0, 0, 26036, 26037, 5, 95, 0, 0, 26037, 26038, 7, 13, 0, 0, 26038, 26039, 7, 6, 0, 0, 26039, 26040, 7, 8, 0, 0, 26040, 26041, 7, 1, 0, 0, 26041, 26042, 7, 10, 0, 0, 26042, 26043, 7, 4, 0, 0, 26043, 3842, 1, 0, 0, 0, 26044, 26045, 7, 5, 0, 0, 26045, 26046, 7, 18, 0, 0, 26046, 26047, 7, 5, 0, 0, 26047, 26048, 5, 95, 0, 0, 26048, 26049, 7, 2, 0, 0, 26049, 26050, 7, 15, 0, 0, 26050, 26051, 5, 95, 0, 0, 26051, 26052, 7, 13, 0, 0, 26052, 26053, 7, 6, 0, 0, 26053, 26054, 7, 8, 0, 0, 26054, 26055, 7, 2, 0, 0, 26055, 26056, 7, 3, 0, 0, 26056, 3844, 1, 0, 0, 0, 26057, 26058, 7, 5, 0, 0, 26058, 26059, 7, 18, 0, 0, 26059, 26060, 7, 5, 0, 0, 26060, 26061, 5, 95, 0, 0, 26061, 26062, 7, 2, 0, 0, 26062, 26063, 7, 15, 0, 0, 26063, 26064, 5, 95, 0, 0, 26064, 26065, 7, 13, 0, 0, 26065, 26066, 7, 6, 0, 0, 26066, 26067, 7, 8, 0, 0, 26067, 26068, 7, 25, 0, 0, 26068, 26069, 7, 2, 0, 0, 26069, 26070, 7, 3, 0, 0, 26070, 3846, 1, 0, 0, 0, 26071, 26072, 7, 5, 0, 0, 26072, 26073, 7, 18, 0, 0, 26073, 26074, 7, 5, 0, 0, 26074, 26075, 5, 95, 0, 0, 26075, 26076, 7, 2, 0, 0, 26076, 26077, 7, 15, 0, 0, 26077, 26078, 5, 95, 0, 0, 26078, 26079, 7, 13, 0, 0, 26079, 26080, 7, 6, 0, 0, 26080, 26081, 7, 3, 0, 0, 26081, 26082, 7, 5, 0, 0, 26082, 26083, 7, 10, 0, 0, 26083, 26084, 7, 2, 0, 0, 26084, 26085, 7, 7, 0, 0, 26085, 3848, 1, 0, 0, 0, 26086, 26087, 7, 5, 0, 0, 26087, 26088, 7, 18, 0, 0, 26088, 26089, 7, 5, 0, 0, 26089, 26090, 5, 95, 0, 0, 26090, 26091, 7, 2, 0, 0, 26091, 26092, 7, 15, 0, 0, 26092, 26093, 5, 95, 0, 0, 26093, 26094, 7, 13, 0, 0, 26094, 26095, 7, 3, 0, 0, 26095, 26096, 7, 6, 0, 0, 26096, 26097, 7, 16, 0, 0, 26097, 3850, 1, 0, 0, 0, 26098, 26099, 7, 5, 0, 0, 26099, 26100, 7, 18, 0, 0, 26100, 26101, 7, 5, 0, 0, 26101, 26102, 5, 95, 0, 0, 26102, 26103, 7, 2, 0, 0, 26103, 26104, 7, 15, 0, 0, 26104, 26105, 5, 95, 0, 0, 26105, 26106, 7, 13, 0, 0, 26106, 26107, 7, 13, 0, 0, 26107, 26108, 7, 9, 0, 0, 26108, 3852, 1, 0, 0, 0, 26109, 26110, 7, 5, 0, 0, 26110, 26111, 7, 18, 0, 0, 26111, 26112, 7, 5, 0, 0, 26112, 26113, 5, 95, 0, 0, 26113, 26114, 7, 2, 0, 0, 26114, 26115, 7, 15, 0, 0, 26115, 26116, 5, 95, 0, 0, 26116, 26117, 7, 25, 0, 0, 26117, 26118, 7, 14, 0, 0, 26118, 26119, 7, 11, 0, 0, 26119, 26120, 7, 8, 0, 0, 26120, 26121, 7, 2, 0, 0, 26121, 26122, 7, 7, 0, 0, 26122, 26123, 7, 5, 0, 0, 26123, 26124, 5, 95, 0, 0, 26124, 26125, 7, 16, 0, 0, 26125, 26126, 7, 2, 0, 0, 26126, 26127, 7, 3, 0, 0, 26127, 26128, 5, 95, 0, 0, 26128, 26129, 7, 8, 0, 0, 26129, 26130, 7, 5, 0, 0, 26130, 26131, 7, 25, 0, 0, 26131, 3854, 1, 0, 0, 0, 26132, 26133, 7, 5, 0, 0, 26133, 26134, 7, 18, 0, 0, 26134, 26135, 7, 5, 0, 0, 26135, 26136, 5, 95, 0, 0, 26136, 26137, 7, 2, 0, 0, 26137, 26138, 7, 15, 0, 0, 26138, 26139, 5, 95, 0, 0, 26139, 26140, 7, 25, 0, 0, 26140, 26141, 7, 15, 0, 0, 26141, 26142, 7, 4, 0, 0, 26142, 26143, 7, 19, 0, 0, 26143, 26144, 7, 0, 0, 0, 26144, 26145, 7, 4, 0, 0, 26145, 26146, 7, 17, 0, 0, 26146, 3856, 1, 0, 0, 0, 26147, 26148, 7, 5, 0, 0, 26148, 26149, 7, 18, 0, 0, 26149, 26150, 7, 5, 0, 0, 26150, 26151, 5, 95, 0, 0, 26151, 26152, 7, 2, 0, 0, 26152, 26153, 7, 15, 0, 0, 26153, 26154, 5, 95, 0, 0, 26154, 26155, 7, 25, 0, 0, 26155, 26156, 7, 15, 0, 0, 26156, 26157, 7, 4, 0, 0, 26157, 26158, 7, 19, 0, 0, 26158, 26159, 7, 10, 0, 0, 26159, 26160, 7, 9, 0, 0, 26160, 26161, 7, 25, 0, 0, 26161, 3858, 1, 0, 0, 0, 26162, 26163, 7, 5, 0, 0, 26163, 26164, 7, 18, 0, 0, 26164, 26165, 7, 5, 0, 0, 26165, 26166, 5, 95, 0, 0, 26166, 26167, 7, 2, 0, 0, 26167, 26168, 7, 15, 0, 0, 26168, 26169, 5, 95, 0, 0, 26169, 26170, 7, 25, 0, 0, 26170, 26171, 7, 15, 0, 0, 26171, 26172, 7, 4, 0, 0, 26172, 26173, 7, 19, 0, 0, 26173, 26174, 7, 2, 0, 0, 26174, 26175, 7, 15, 0, 0, 26175, 3860, 1, 0, 0, 0, 26176, 26177, 7, 5, 0, 0, 26177, 26178, 7, 18, 0, 0, 26178, 26179, 7, 5, 0, 0, 26179, 26180, 5, 95, 0, 0, 26180, 26181, 7, 2, 0, 0, 26181, 26182, 7, 15, 0, 0, 26182, 26183, 5, 95, 0, 0, 26183, 26184, 7, 25, 0, 0, 26184, 26185, 7, 4, 0, 0, 26185, 26186, 7, 25, 0, 0, 26186, 26187, 7, 4, 0, 0, 26187, 26188, 5, 50, 0, 0, 26188, 26189, 7, 5, 0, 0, 26189, 26190, 7, 24, 0, 0, 26190, 26191, 7, 11, 0, 0, 26191, 26192, 7, 4, 0, 0, 26192, 3862, 1, 0, 0, 0, 26193, 26194, 7, 5, 0, 0, 26194, 26195, 7, 18, 0, 0, 26195, 26196, 7, 5, 0, 0, 26196, 26197, 5, 95, 0, 0, 26197, 26198, 7, 2, 0, 0, 26198, 26199, 7, 15, 0, 0, 26199, 26200, 5, 95, 0, 0, 26200, 26201, 7, 23, 0, 0, 26201, 26202, 7, 2, 0, 0, 26202, 26203, 7, 7, 0, 0, 26203, 26204, 7, 6, 0, 0, 26204, 26205, 5, 95, 0, 0, 26205, 26206, 7, 10, 0, 0, 26206, 26207, 7, 9, 0, 0, 26207, 3864, 1, 0, 0, 0, 26208, 26209, 7, 5, 0, 0, 26209, 26210, 7, 18, 0, 0, 26210, 26211, 7, 5, 0, 0, 26211, 26212, 5, 95, 0, 0, 26212, 26213, 7, 2, 0, 0, 26213, 26214, 7, 3, 0, 0, 26214, 26215, 7, 9, 0, 0, 26215, 26216, 7, 6, 0, 0, 26216, 26217, 7, 3, 0, 0, 26217, 26218, 7, 21, 0, 0, 26218, 26219, 7, 6, 0, 0, 26219, 26220, 7, 18, 0, 0, 26220, 26221, 5, 95, 0, 0, 26221, 26222, 7, 9, 0, 0, 26222, 26223, 7, 6, 0, 0, 26223, 26224, 7, 15, 0, 0, 26224, 26225, 7, 4, 0, 0, 26225, 26226, 7, 19, 0, 0, 26226, 3866, 1, 0, 0, 0, 26227, 26228, 7, 5, 0, 0, 26228, 26229, 7, 18, 0, 0, 26229, 26230, 7, 5, 0, 0, 26230, 26231, 5, 95, 0, 0, 26231, 26232, 7, 2, 0, 0, 26232, 26233, 7, 3, 0, 0, 26233, 26234, 7, 9, 0, 0, 26234, 26235, 7, 6, 0, 0, 26235, 26236, 7, 3, 0, 0, 26236, 26237, 7, 21, 0, 0, 26237, 26238, 7, 6, 0, 0, 26238, 26239, 7, 18, 0, 0, 26239, 26240, 5, 95, 0, 0, 26240, 26241, 7, 14, 0, 0, 26241, 26242, 7, 0, 0, 0, 26242, 26243, 7, 25, 0, 0, 26243, 26244, 7, 8, 0, 0, 26244, 26245, 7, 19, 0, 0, 26245, 26246, 7, 10, 0, 0, 26246, 26247, 7, 11, 0, 0, 26247, 26248, 7, 9, 0, 0, 26248, 3868, 1, 0, 0, 0, 26249, 26250, 7, 5, 0, 0, 26250, 26251, 7, 18, 0, 0, 26251, 26252, 7, 5, 0, 0, 26252, 26253, 5, 95, 0, 0, 26253, 26254, 7, 2, 0, 0, 26254, 26255, 7, 3, 0, 0, 26255, 26256, 7, 9, 0, 0, 26256, 26257, 7, 6, 0, 0, 26257, 26258, 7, 3, 0, 0, 26258, 26259, 7, 21, 0, 0, 26259, 26260, 7, 6, 0, 0, 26260, 26261, 7, 18, 0, 0, 26261, 26262, 5, 95, 0, 0, 26262, 26263, 7, 15, 0, 0, 26263, 26264, 7, 0, 0, 0, 26264, 26265, 7, 3, 0, 0, 26265, 26266, 7, 6, 0, 0, 26266, 26267, 7, 7, 0, 0, 26267, 26268, 7, 4, 0, 0, 26268, 3870, 1, 0, 0, 0, 26269, 26270, 7, 5, 0, 0, 26270, 26271, 7, 18, 0, 0, 26271, 26272, 7, 5, 0, 0, 26272, 26273, 5, 95, 0, 0, 26273, 26274, 7, 15, 0, 0, 26274, 26275, 7, 0, 0, 0, 26275, 26276, 7, 3, 0, 0, 26276, 26277, 7, 0, 0, 0, 26277, 26278, 7, 11, 0, 0, 26278, 26279, 7, 11, 0, 0, 26279, 26280, 7, 6, 0, 0, 26280, 26281, 7, 11, 0, 0, 26281, 26282, 5, 95, 0, 0, 26282, 26283, 7, 4, 0, 0, 26283, 26284, 7, 25, 0, 0, 26284, 26285, 7, 7, 0, 0, 26285, 3872, 1, 0, 0, 0, 26286, 26287, 7, 5, 0, 0, 26287, 26288, 7, 18, 0, 0, 26288, 26289, 7, 5, 0, 0, 26289, 26290, 5, 95, 0, 0, 26290, 26291, 7, 15, 0, 0, 26291, 26292, 7, 0, 0, 0, 26292, 26293, 7, 4, 0, 0, 26293, 26294, 7, 19, 0, 0, 26294, 26295, 7, 10, 0, 0, 26295, 26296, 7, 9, 0, 0, 26296, 26297, 5, 95, 0, 0, 26297, 26298, 7, 10, 0, 0, 26298, 26299, 7, 5, 0, 0, 26299, 26300, 5, 95, 0, 0, 26300, 26301, 7, 0, 0, 0, 26301, 26302, 7, 4, 0, 0, 26302, 26303, 7, 4, 0, 0, 26303, 26304, 7, 3, 0, 0, 26304, 3874, 1, 0, 0, 0, 26305, 26306, 7, 5, 0, 0, 26306, 26307, 7, 18, 0, 0, 26307, 26308, 7, 5, 0, 0, 26308, 26309, 5, 95, 0, 0, 26309, 26310, 7, 15, 0, 0, 26310, 26311, 7, 0, 0, 0, 26311, 26312, 7, 4, 0, 0, 26312, 26313, 7, 19, 0, 0, 26313, 26314, 7, 10, 0, 0, 26314, 26315, 7, 9, 0, 0, 26315, 26316, 5, 95, 0, 0, 26316, 26317, 7, 10, 0, 0, 26317, 26318, 7, 5, 0, 0, 26318, 26319, 5, 95, 0, 0, 26319, 26320, 7, 7, 0, 0, 26320, 26321, 7, 14, 0, 0, 26321, 26322, 7, 5, 0, 0, 26322, 26323, 7, 15, 0, 0, 26323, 26324, 7, 8, 0, 0, 26324, 3876, 1, 0, 0, 0, 26325, 26326, 7, 5, 0, 0, 26326, 26327, 7, 18, 0, 0, 26327, 26328, 7, 5, 0, 0, 26328, 26329, 5, 95, 0, 0, 26329, 26330, 7, 15, 0, 0, 26330, 26331, 7, 0, 0, 0, 26331, 26332, 7, 4, 0, 0, 26332, 26333, 7, 19, 0, 0, 26333, 26334, 7, 10, 0, 0, 26334, 26335, 7, 9, 0, 0, 26335, 26336, 5, 95, 0, 0, 26336, 26337, 7, 11, 0, 0, 26337, 26338, 7, 0, 0, 0, 26338, 26339, 7, 5, 0, 0, 26339, 26340, 7, 4, 0, 0, 26340, 26341, 7, 7, 0, 0, 26341, 26342, 7, 0, 0, 0, 26342, 26343, 7, 14, 0, 0, 26343, 26344, 7, 6, 0, 0, 26344, 3878, 1, 0, 0, 0, 26345, 26346, 7, 5, 0, 0, 26346, 26347, 7, 18, 0, 0, 26347, 26348, 7, 5, 0, 0, 26348, 26349, 5, 95, 0, 0, 26349, 26350, 7, 15, 0, 0, 26350, 26351, 7, 0, 0, 0, 26351, 26352, 7, 4, 0, 0, 26352, 26353, 7, 19, 0, 0, 26353, 26354, 7, 10, 0, 0, 26354, 26355, 7, 9, 0, 0, 26355, 26356, 5, 95, 0, 0, 26356, 26357, 7, 11, 0, 0, 26357, 26358, 7, 0, 0, 0, 26358, 26359, 7, 5, 0, 0, 26359, 26360, 7, 4, 0, 0, 26360, 26361, 7, 7, 0, 0, 26361, 26362, 7, 14, 0, 0, 26362, 26363, 7, 5, 0, 0, 26363, 26364, 7, 15, 0, 0, 26364, 26365, 7, 8, 0, 0, 26365, 3880, 1, 0, 0, 0, 26366, 26367, 7, 5, 0, 0, 26367, 26368, 7, 18, 0, 0, 26368, 26369, 7, 5, 0, 0, 26369, 26370, 5, 95, 0, 0, 26370, 26371, 7, 15, 0, 0, 26371, 26372, 7, 0, 0, 0, 26372, 26373, 7, 4, 0, 0, 26373, 26374, 7, 19, 0, 0, 26374, 26375, 5, 95, 0, 0, 26375, 26376, 7, 3, 0, 0, 26376, 26377, 7, 6, 0, 0, 26377, 26378, 7, 13, 0, 0, 26378, 26379, 7, 6, 0, 0, 26379, 26380, 7, 3, 0, 0, 26380, 26381, 7, 5, 0, 0, 26381, 26382, 7, 6, 0, 0, 26382, 3882, 1, 0, 0, 0, 26383, 26384, 7, 5, 0, 0, 26384, 26385, 7, 18, 0, 0, 26385, 26386, 7, 5, 0, 0, 26386, 26387, 5, 95, 0, 0, 26387, 26388, 7, 15, 0, 0, 26388, 26389, 7, 25, 0, 0, 26389, 26390, 7, 24, 0, 0, 26390, 26391, 7, 6, 0, 0, 26391, 26392, 7, 25, 0, 0, 26392, 26393, 7, 4, 0, 0, 26393, 26394, 7, 3, 0, 0, 26394, 26395, 7, 0, 0, 0, 26395, 26396, 7, 8, 0, 0, 26396, 26397, 7, 4, 0, 0, 26397, 3884, 1, 0, 0, 0, 26398, 26399, 7, 5, 0, 0, 26399, 26400, 7, 18, 0, 0, 26400, 26401, 7, 5, 0, 0, 26401, 26402, 5, 95, 0, 0, 26402, 26403, 7, 3, 0, 0, 26403, 26404, 7, 0, 0, 0, 26404, 26405, 7, 22, 0, 0, 26405, 26406, 5, 95, 0, 0, 26406, 26407, 7, 4, 0, 0, 26407, 26408, 7, 2, 0, 0, 26408, 26409, 5, 95, 0, 0, 26409, 26410, 7, 25, 0, 0, 26410, 26411, 7, 5, 0, 0, 26411, 26412, 7, 10, 0, 0, 26412, 26413, 7, 9, 0, 0, 26413, 3886, 1, 0, 0, 0, 26414, 26415, 7, 5, 0, 0, 26415, 26416, 7, 18, 0, 0, 26416, 26417, 7, 5, 0, 0, 26417, 26418, 5, 95, 0, 0, 26418, 26419, 7, 3, 0, 0, 26419, 26420, 7, 10, 0, 0, 26420, 26421, 7, 9, 0, 0, 26421, 26422, 5, 95, 0, 0, 26422, 26423, 7, 2, 0, 0, 26423, 26424, 7, 3, 0, 0, 26424, 26425, 7, 9, 0, 0, 26425, 26426, 7, 6, 0, 0, 26426, 26427, 7, 3, 0, 0, 26427, 3888, 1, 0, 0, 0, 26428, 26429, 7, 5, 0, 0, 26429, 26430, 7, 18, 0, 0, 26430, 26431, 7, 5, 0, 0, 26431, 26432, 5, 95, 0, 0, 26432, 26433, 7, 3, 0, 0, 26433, 26434, 7, 2, 0, 0, 26434, 26435, 7, 22, 0, 0, 26435, 26436, 5, 95, 0, 0, 26436, 26437, 7, 9, 0, 0, 26437, 26438, 7, 6, 0, 0, 26438, 26439, 7, 11, 0, 0, 26439, 26440, 7, 4, 0, 0, 26440, 26441, 7, 0, 0, 0, 26441, 3890, 1, 0, 0, 0, 26442, 26443, 7, 5, 0, 0, 26443, 26444, 7, 18, 0, 0, 26444, 26445, 7, 5, 0, 0, 26445, 26446, 5, 95, 0, 0, 26446, 26447, 7, 5, 0, 0, 26447, 26448, 7, 8, 0, 0, 26448, 26449, 5, 95, 0, 0, 26449, 26450, 5, 50, 0, 0, 26450, 26451, 5, 95, 0, 0, 26451, 26452, 7, 25, 0, 0, 26452, 26453, 7, 14, 0, 0, 26453, 26454, 7, 11, 0, 0, 26454, 26455, 7, 4, 0, 0, 26455, 3892, 1, 0, 0, 0, 26456, 26457, 7, 5, 0, 0, 26457, 26458, 7, 18, 0, 0, 26458, 26459, 7, 5, 0, 0, 26459, 26460, 5, 95, 0, 0, 26460, 26461, 7, 5, 0, 0, 26461, 26462, 7, 18, 0, 0, 26462, 26463, 7, 7, 0, 0, 26463, 26464, 7, 3, 0, 0, 26464, 26465, 7, 8, 0, 0, 26465, 26466, 7, 10, 0, 0, 26466, 26467, 7, 3, 0, 0, 26467, 26468, 7, 6, 0, 0, 26468, 26469, 7, 9, 0, 0, 26469, 26470, 7, 2, 0, 0, 26470, 3894, 1, 0, 0, 0, 26471, 26472, 7, 5, 0, 0, 26472, 26473, 7, 18, 0, 0, 26473, 26474, 7, 5, 0, 0, 26474, 26475, 7, 4, 0, 0, 26475, 26476, 7, 6, 0, 0, 26476, 26477, 7, 14, 0, 0, 26477, 26478, 5, 95, 0, 0, 26478, 26479, 7, 9, 0, 0, 26479, 26480, 7, 6, 0, 0, 26480, 26481, 7, 16, 0, 0, 26481, 26482, 7, 10, 0, 0, 26482, 26483, 7, 7, 0, 0, 26483, 26484, 7, 6, 0, 0, 26484, 26485, 7, 9, 0, 0, 26485, 3896, 1, 0, 0, 0, 26486, 26487, 7, 5, 0, 0, 26487, 26488, 7, 18, 0, 0, 26488, 26489, 7, 5, 0, 0, 26489, 26490, 7, 4, 0, 0, 26490, 26491, 7, 6, 0, 0, 26491, 26492, 7, 14, 0, 0, 26492, 3898, 1, 0, 0, 0, 26493, 26494, 7, 5, 0, 0, 26494, 26495, 7, 18, 0, 0, 26495, 26496, 7, 5, 0, 0, 26496, 26497, 7, 4, 0, 0, 26497, 26498, 7, 10, 0, 0, 26498, 26499, 7, 14, 0, 0, 26499, 26500, 7, 6, 0, 0, 26500, 26501, 7, 5, 0, 0, 26501, 26502, 7, 4, 0, 0, 26502, 26503, 7, 0, 0, 0, 26503, 26504, 7, 14, 0, 0, 26504, 26505, 7, 15, 0, 0, 26505, 3900, 1, 0, 0, 0, 26506, 26507, 7, 5, 0, 0, 26507, 26508, 7, 18, 0, 0, 26508, 26509, 7, 5, 0, 0, 26509, 26510, 5, 95, 0, 0, 26510, 26511, 7, 4, 0, 0, 26511, 26512, 7, 18, 0, 0, 26512, 26513, 7, 15, 0, 0, 26513, 26514, 7, 6, 0, 0, 26514, 26515, 7, 10, 0, 0, 26515, 26516, 7, 9, 0, 0, 26516, 3902, 1, 0, 0, 0, 26517, 26518, 7, 5, 0, 0, 26518, 26519, 7, 18, 0, 0, 26519, 26520, 7, 5, 0, 0, 26520, 26521, 5, 95, 0, 0, 26521, 26522, 7, 12, 0, 0, 26522, 26523, 7, 14, 0, 0, 26523, 26524, 7, 0, 0, 0, 26524, 26525, 7, 21, 0, 0, 26525, 26526, 7, 6, 0, 0, 26526, 26527, 7, 25, 0, 0, 26527, 26528, 7, 14, 0, 0, 26528, 26529, 7, 11, 0, 0, 26529, 3904, 1, 0, 0, 0, 26530, 26531, 7, 5, 0, 0, 26531, 26532, 7, 18, 0, 0, 26532, 26533, 7, 5, 0, 0, 26533, 26534, 5, 95, 0, 0, 26534, 26535, 7, 25, 0, 0, 26535, 26536, 7, 14, 0, 0, 26536, 26537, 7, 11, 0, 0, 26537, 26538, 7, 0, 0, 0, 26538, 26539, 7, 7, 0, 0, 26539, 26540, 7, 0, 0, 0, 26540, 26541, 7, 11, 0, 0, 26541, 26542, 7, 18, 0, 0, 26542, 26543, 7, 23, 0, 0, 26543, 26544, 7, 6, 0, 0, 26544, 3906, 1, 0, 0, 0, 26545, 26546, 7, 5, 0, 0, 26546, 26547, 7, 18, 0, 0, 26547, 26548, 7, 5, 0, 0, 26548, 26549, 5, 95, 0, 0, 26549, 26550, 7, 25, 0, 0, 26550, 26551, 7, 14, 0, 0, 26551, 26552, 7, 11, 0, 0, 26552, 26553, 7, 8, 0, 0, 26553, 26554, 7, 2, 0, 0, 26554, 26555, 7, 7, 0, 0, 26555, 26556, 7, 4, 0, 0, 26556, 26557, 7, 0, 0, 0, 26557, 26558, 7, 10, 0, 0, 26558, 26559, 7, 7, 0, 0, 26559, 26560, 7, 5, 0, 0, 26560, 3908, 1, 0, 0, 0, 26561, 26562, 7, 5, 0, 0, 26562, 26563, 7, 18, 0, 0, 26563, 26564, 7, 5, 0, 0, 26564, 26565, 5, 95, 0, 0, 26565, 26566, 7, 25, 0, 0, 26566, 26567, 7, 14, 0, 0, 26567, 26568, 7, 11, 0, 0, 26568, 26569, 7, 8, 0, 0, 26569, 26570, 7, 2, 0, 0, 26570, 26571, 7, 7, 0, 0, 26571, 26572, 7, 13, 0, 0, 26572, 3910, 1, 0, 0, 0, 26573, 26574, 7, 5, 0, 0, 26574, 26575, 7, 18, 0, 0, 26575, 26576, 7, 5, 0, 0, 26576, 26577, 5, 95, 0, 0, 26577, 26578, 7, 25, 0, 0, 26578, 26579, 7, 14, 0, 0, 26579, 26580, 7, 11, 0, 0, 26580, 26581, 7, 6, 0, 0, 26581, 26582, 7, 25, 0, 0, 26582, 26583, 7, 7, 0, 0, 26583, 26584, 7, 5, 0, 0, 26584, 26585, 7, 12, 0, 0, 26585, 26586, 7, 3, 0, 0, 26586, 26587, 7, 10, 0, 0, 26587, 3912, 1, 0, 0, 0, 26588, 26589, 7, 5, 0, 0, 26589, 26590, 7, 18, 0, 0, 26590, 26591, 7, 5, 0, 0, 26591, 26592, 5, 95, 0, 0, 26592, 26593, 7, 25, 0, 0, 26593, 26594, 7, 14, 0, 0, 26594, 26595, 7, 11, 0, 0, 26595, 26596, 7, 17, 0, 0, 26596, 26597, 7, 6, 0, 0, 26597, 26598, 7, 7, 0, 0, 26598, 3914, 1, 0, 0, 0, 26599, 26600, 7, 5, 0, 0, 26600, 26601, 7, 18, 0, 0, 26601, 26602, 7, 5, 0, 0, 26602, 26603, 5, 95, 0, 0, 26603, 26604, 7, 25, 0, 0, 26604, 26605, 7, 14, 0, 0, 26605, 26606, 7, 11, 0, 0, 26606, 26607, 7, 10, 0, 0, 26607, 26608, 5, 95, 0, 0, 26608, 26609, 7, 11, 0, 0, 26609, 26610, 7, 2, 0, 0, 26610, 26611, 7, 8, 0, 0, 26611, 26612, 5, 95, 0, 0, 26612, 26613, 7, 10, 0, 0, 26613, 26614, 7, 5, 0, 0, 26614, 26615, 7, 7, 0, 0, 26615, 26616, 7, 2, 0, 0, 26616, 26617, 7, 9, 0, 0, 26617, 26618, 7, 6, 0, 0, 26618, 3916, 1, 0, 0, 0, 26619, 26620, 7, 5, 0, 0, 26620, 26621, 7, 18, 0, 0, 26621, 26622, 7, 5, 0, 0, 26622, 26623, 5, 95, 0, 0, 26623, 26624, 7, 25, 0, 0, 26624, 26625, 7, 14, 0, 0, 26625, 26626, 7, 11, 0, 0, 26626, 26627, 7, 10, 0, 0, 26627, 26628, 5, 95, 0, 0, 26628, 26629, 7, 11, 0, 0, 26629, 26630, 7, 2, 0, 0, 26630, 26631, 7, 8, 0, 0, 26631, 26632, 5, 95, 0, 0, 26632, 26633, 7, 10, 0, 0, 26633, 26634, 7, 5, 0, 0, 26634, 26635, 7, 4, 0, 0, 26635, 26636, 7, 6, 0, 0, 26636, 26637, 7, 25, 0, 0, 26637, 26638, 7, 4, 0, 0, 26638, 3918, 1, 0, 0, 0, 26639, 26640, 7, 5, 0, 0, 26640, 26641, 7, 18, 0, 0, 26641, 26642, 7, 5, 0, 0, 26642, 26643, 5, 95, 0, 0, 26643, 26644, 7, 25, 0, 0, 26644, 26645, 7, 14, 0, 0, 26645, 26646, 7, 11, 0, 0, 26646, 26647, 7, 10, 0, 0, 26647, 26648, 7, 7, 0, 0, 26648, 26649, 7, 5, 0, 0, 26649, 26650, 7, 4, 0, 0, 26650, 26651, 7, 3, 0, 0, 26651, 3920, 1, 0, 0, 0, 26652, 26653, 7, 5, 0, 0, 26653, 26654, 7, 18, 0, 0, 26654, 26655, 7, 5, 0, 0, 26655, 26656, 5, 95, 0, 0, 26656, 26657, 7, 25, 0, 0, 26657, 26658, 7, 14, 0, 0, 26658, 26659, 7, 11, 0, 0, 26659, 26660, 7, 11, 0, 0, 26660, 26661, 7, 2, 0, 0, 26661, 26662, 7, 8, 0, 0, 26662, 26663, 7, 0, 0, 0, 26663, 26664, 7, 4, 0, 0, 26664, 26665, 7, 2, 0, 0, 26665, 26666, 7, 3, 0, 0, 26666, 26667, 5, 95, 0, 0, 26667, 26668, 7, 17, 0, 0, 26668, 26669, 7, 6, 0, 0, 26669, 26670, 7, 4, 0, 0, 26670, 26671, 7, 5, 0, 0, 26671, 26672, 7, 13, 0, 0, 26672, 26673, 7, 0, 0, 0, 26673, 26674, 7, 11, 0, 0, 26674, 3922, 1, 0, 0, 0, 26675, 26676, 7, 5, 0, 0, 26676, 26677, 7, 18, 0, 0, 26677, 26678, 7, 5, 0, 0, 26678, 26679, 5, 95, 0, 0, 26679, 26680, 7, 25, 0, 0, 26680, 26681, 7, 14, 0, 0, 26681, 26682, 7, 11, 0, 0, 26682, 26683, 7, 7, 0, 0, 26683, 26684, 7, 2, 0, 0, 26684, 26685, 7, 9, 0, 0, 26685, 26686, 7, 6, 0, 0, 26686, 26687, 7, 10, 0, 0, 26687, 26688, 7, 9, 0, 0, 26688, 26689, 5, 95, 0, 0, 26689, 26690, 7, 17, 0, 0, 26690, 26691, 7, 6, 0, 0, 26691, 26692, 7, 4, 0, 0, 26692, 26693, 7, 8, 0, 0, 26693, 26694, 7, 10, 0, 0, 26694, 26695, 7, 9, 0, 0, 26695, 3924, 1, 0, 0, 0, 26696, 26697, 7, 5, 0, 0, 26697, 26698, 7, 18, 0, 0, 26698, 26699, 7, 5, 0, 0, 26699, 26700, 5, 95, 0, 0, 26700, 26701, 7, 25, 0, 0, 26701, 26702, 7, 14, 0, 0, 26702, 26703, 7, 11, 0, 0, 26703, 26704, 7, 7, 0, 0, 26704, 26705, 7, 2, 0, 0, 26705, 26706, 7, 9, 0, 0, 26706, 26707, 7, 6, 0, 0, 26707, 26708, 7, 10, 0, 0, 26708, 26709, 7, 9, 0, 0, 26709, 26710, 5, 95, 0, 0, 26710, 26711, 7, 17, 0, 0, 26711, 26712, 7, 6, 0, 0, 26712, 26713, 7, 4, 0, 0, 26713, 26714, 7, 11, 0, 0, 26714, 26715, 7, 2, 0, 0, 26715, 26716, 7, 8, 0, 0, 26716, 26717, 7, 0, 0, 0, 26717, 26718, 7, 4, 0, 0, 26718, 26719, 7, 2, 0, 0, 26719, 26720, 7, 3, 0, 0, 26720, 3926, 1, 0, 0, 0, 26721, 26722, 7, 5, 0, 0, 26722, 26723, 7, 18, 0, 0, 26723, 26724, 7, 5, 0, 0, 26724, 26725, 5, 95, 0, 0, 26725, 26726, 7, 25, 0, 0, 26726, 26727, 7, 14, 0, 0, 26727, 26728, 7, 11, 0, 0, 26728, 26729, 7, 7, 0, 0, 26729, 26730, 7, 2, 0, 0, 26730, 26731, 7, 9, 0, 0, 26731, 26732, 7, 6, 0, 0, 26732, 26733, 7, 10, 0, 0, 26733, 26734, 7, 9, 0, 0, 26734, 26735, 5, 95, 0, 0, 26735, 26736, 7, 17, 0, 0, 26736, 26737, 7, 6, 0, 0, 26737, 26738, 7, 4, 0, 0, 26738, 26739, 7, 2, 0, 0, 26739, 26740, 7, 21, 0, 0, 26740, 26741, 7, 6, 0, 0, 26741, 26742, 7, 18, 0, 0, 26742, 3928, 1, 0, 0, 0, 26743, 26744, 7, 5, 0, 0, 26744, 26745, 7, 18, 0, 0, 26745, 26746, 7, 5, 0, 0, 26746, 26747, 5, 95, 0, 0, 26747, 26748, 7, 25, 0, 0, 26748, 26749, 7, 14, 0, 0, 26749, 26750, 7, 11, 0, 0, 26750, 26751, 7, 7, 0, 0, 26751, 26752, 7, 2, 0, 0, 26752, 26753, 7, 9, 0, 0, 26753, 26754, 7, 6, 0, 0, 26754, 26755, 7, 10, 0, 0, 26755, 26756, 7, 9, 0, 0, 26756, 26757, 5, 95, 0, 0, 26757, 26758, 7, 17, 0, 0, 26758, 26759, 7, 6, 0, 0, 26759, 26760, 7, 4, 0, 0, 26760, 26761, 7, 15, 0, 0, 26761, 26762, 7, 0, 0, 0, 26762, 26763, 7, 4, 0, 0, 26763, 26764, 7, 19, 0, 0, 26764, 26765, 7, 10, 0, 0, 26765, 26766, 7, 9, 0, 0, 26766, 3930, 1, 0, 0, 0, 26767, 26768, 7, 5, 0, 0, 26768, 26769, 7, 18, 0, 0, 26769, 26770, 7, 5, 0, 0, 26770, 26771, 5, 95, 0, 0, 26771, 26772, 7, 25, 0, 0, 26772, 26773, 7, 14, 0, 0, 26773, 26774, 7, 11, 0, 0, 26774, 26775, 7, 7, 0, 0, 26775, 26776, 7, 2, 0, 0, 26776, 26777, 7, 9, 0, 0, 26777, 26778, 7, 6, 0, 0, 26778, 26779, 7, 10, 0, 0, 26779, 26780, 7, 9, 0, 0, 26780, 26781, 5, 95, 0, 0, 26781, 26782, 7, 17, 0, 0, 26782, 26783, 7, 6, 0, 0, 26783, 26784, 7, 4, 0, 0, 26784, 26785, 7, 15, 0, 0, 26785, 26786, 7, 4, 0, 0, 26786, 26787, 7, 3, 0, 0, 26787, 26788, 7, 10, 0, 0, 26788, 26789, 7, 9, 0, 0, 26789, 3932, 1, 0, 0, 0, 26790, 26791, 7, 5, 0, 0, 26791, 26792, 7, 18, 0, 0, 26792, 26793, 7, 5, 0, 0, 26793, 26794, 5, 95, 0, 0, 26794, 26795, 7, 25, 0, 0, 26795, 26796, 7, 14, 0, 0, 26796, 26797, 7, 11, 0, 0, 26797, 26798, 7, 7, 0, 0, 26798, 26799, 7, 2, 0, 0, 26799, 26800, 7, 9, 0, 0, 26800, 26801, 7, 6, 0, 0, 26801, 26802, 7, 10, 0, 0, 26802, 26803, 7, 9, 0, 0, 26803, 26804, 5, 95, 0, 0, 26804, 26805, 7, 17, 0, 0, 26805, 26806, 7, 6, 0, 0, 26806, 26807, 7, 4, 0, 0, 26807, 26808, 7, 3, 0, 0, 26808, 26809, 7, 10, 0, 0, 26809, 26810, 7, 9, 0, 0, 26810, 3934, 1, 0, 0, 0, 26811, 26812, 7, 5, 0, 0, 26812, 26813, 7, 18, 0, 0, 26813, 26814, 7, 5, 0, 0, 26814, 26815, 5, 95, 0, 0, 26815, 26816, 7, 25, 0, 0, 26816, 26817, 7, 14, 0, 0, 26817, 26818, 7, 11, 0, 0, 26818, 26819, 7, 7, 0, 0, 26819, 26820, 7, 2, 0, 0, 26820, 26821, 7, 9, 0, 0, 26821, 26822, 7, 6, 0, 0, 26822, 26823, 7, 10, 0, 0, 26823, 26824, 7, 9, 0, 0, 26824, 26825, 5, 95, 0, 0, 26825, 26826, 7, 17, 0, 0, 26826, 26827, 7, 6, 0, 0, 26827, 26828, 7, 4, 0, 0, 26828, 26829, 7, 5, 0, 0, 26829, 26830, 7, 13, 0, 0, 26830, 26831, 7, 0, 0, 0, 26831, 26832, 7, 11, 0, 0, 26832, 3936, 1, 0, 0, 0, 26833, 26834, 7, 5, 0, 0, 26834, 26835, 7, 18, 0, 0, 26835, 26836, 7, 5, 0, 0, 26836, 26837, 5, 95, 0, 0, 26837, 26838, 7, 25, 0, 0, 26838, 26839, 7, 14, 0, 0, 26839, 26840, 7, 11, 0, 0, 26840, 26841, 7, 7, 0, 0, 26841, 26842, 7, 2, 0, 0, 26842, 26843, 7, 9, 0, 0, 26843, 26844, 7, 6, 0, 0, 26844, 26845, 7, 10, 0, 0, 26845, 26846, 7, 9, 0, 0, 26846, 26847, 5, 95, 0, 0, 26847, 26848, 7, 17, 0, 0, 26848, 26849, 7, 6, 0, 0, 26849, 26850, 7, 4, 0, 0, 26850, 26851, 7, 4, 0, 0, 26851, 26852, 7, 10, 0, 0, 26852, 26853, 7, 9, 0, 0, 26853, 3938, 1, 0, 0, 0, 26854, 26855, 7, 5, 0, 0, 26855, 26856, 7, 18, 0, 0, 26856, 26857, 7, 5, 0, 0, 26857, 26858, 5, 95, 0, 0, 26858, 26859, 7, 25, 0, 0, 26859, 26860, 7, 14, 0, 0, 26860, 26861, 7, 11, 0, 0, 26861, 26862, 7, 7, 0, 0, 26862, 26863, 7, 2, 0, 0, 26863, 26864, 7, 9, 0, 0, 26864, 26865, 7, 6, 0, 0, 26865, 26866, 7, 10, 0, 0, 26866, 26867, 7, 9, 0, 0, 26867, 3940, 1, 0, 0, 0, 26868, 26869, 7, 5, 0, 0, 26869, 26870, 7, 18, 0, 0, 26870, 26871, 7, 5, 0, 0, 26871, 26872, 5, 95, 0, 0, 26872, 26873, 7, 25, 0, 0, 26873, 26874, 7, 14, 0, 0, 26874, 26875, 7, 11, 0, 0, 26875, 26876, 7, 4, 0, 0, 26876, 26877, 5, 95, 0, 0, 26877, 26878, 5, 50, 0, 0, 26878, 26879, 5, 95, 0, 0, 26879, 26880, 7, 5, 0, 0, 26880, 26881, 7, 8, 0, 0, 26881, 3942, 1, 0, 0, 0, 26882, 26883, 7, 5, 0, 0, 26883, 26884, 7, 18, 0, 0, 26884, 26885, 7, 5, 0, 0, 26885, 26886, 5, 95, 0, 0, 26886, 26887, 7, 25, 0, 0, 26887, 26888, 7, 14, 0, 0, 26888, 26889, 7, 11, 0, 0, 26889, 26890, 7, 4, 0, 0, 26890, 26891, 7, 3, 0, 0, 26891, 26892, 7, 0, 0, 0, 26892, 26893, 7, 7, 0, 0, 26893, 26894, 7, 5, 0, 0, 26894, 26895, 7, 11, 0, 0, 26895, 26896, 7, 0, 0, 0, 26896, 26897, 7, 4, 0, 0, 26897, 26898, 7, 6, 0, 0, 26898, 3944, 1, 0, 0, 0, 26899, 26900, 7, 5, 0, 0, 26900, 26901, 7, 18, 0, 0, 26901, 26902, 7, 5, 0, 0, 26902, 26903, 5, 95, 0, 0, 26903, 26904, 7, 25, 0, 0, 26904, 26905, 7, 14, 0, 0, 26905, 26906, 7, 11, 0, 0, 26906, 26907, 7, 4, 0, 0, 26907, 26908, 7, 18, 0, 0, 26908, 26909, 7, 15, 0, 0, 26909, 26910, 7, 6, 0, 0, 26910, 26911, 5, 50, 0, 0, 26911, 26912, 7, 5, 0, 0, 26912, 26913, 7, 24, 0, 0, 26913, 26914, 7, 11, 0, 0, 26914, 3946, 1, 0, 0, 0, 26915, 26916, 7, 5, 0, 0, 26916, 26917, 7, 18, 0, 0, 26917, 26918, 7, 5, 0, 0, 26918, 26919, 5, 95, 0, 0, 26919, 26920, 7, 25, 0, 0, 26920, 26921, 7, 24, 0, 0, 26921, 26922, 5, 95, 0, 0, 26922, 26923, 7, 0, 0, 0, 26923, 26924, 7, 5, 0, 0, 26924, 26925, 7, 24, 0, 0, 26925, 26926, 7, 11, 0, 0, 26926, 26927, 7, 8, 0, 0, 26927, 26928, 7, 7, 0, 0, 26928, 26929, 7, 13, 0, 0, 26929, 3948, 1, 0, 0, 0, 26930, 26931, 7, 5, 0, 0, 26931, 26932, 7, 18, 0, 0, 26932, 26933, 7, 5, 0, 0, 26933, 26934, 5, 95, 0, 0, 26934, 26935, 7, 25, 0, 0, 26935, 26936, 7, 24, 0, 0, 26936, 26937, 5, 95, 0, 0, 26937, 26938, 7, 0, 0, 0, 26938, 26939, 7, 4, 0, 0, 26939, 26940, 7, 2, 0, 0, 26940, 26941, 7, 14, 0, 0, 26941, 26942, 7, 8, 0, 0, 26942, 26943, 7, 7, 0, 0, 26943, 26944, 7, 13, 0, 0, 26944, 26945, 7, 8, 0, 0, 26945, 26946, 7, 19, 0, 0, 26946, 26947, 7, 21, 0, 0, 26947, 3950, 1, 0, 0, 0, 26948, 26949, 7, 5, 0, 0, 26949, 26950, 7, 18, 0, 0, 26950, 26951, 7, 5, 0, 0, 26951, 26952, 5, 95, 0, 0, 26952, 26953, 7, 25, 0, 0, 26953, 26954, 7, 24, 0, 0, 26954, 26955, 7, 1, 0, 0, 26955, 26956, 7, 0, 0, 0, 26956, 26957, 7, 5, 0, 0, 26957, 26958, 7, 6, 0, 0, 26958, 26959, 7, 12, 0, 0, 26959, 26960, 7, 3, 0, 0, 26960, 26961, 7, 10, 0, 0, 26961, 3952, 1, 0, 0, 0, 26962, 26963, 7, 5, 0, 0, 26963, 26964, 7, 18, 0, 0, 26964, 26965, 7, 5, 0, 0, 26965, 26966, 5, 95, 0, 0, 26966, 26967, 7, 25, 0, 0, 26967, 26968, 7, 24, 0, 0, 26968, 26969, 7, 8, 0, 0, 26969, 26970, 7, 0, 0, 0, 26970, 26971, 7, 5, 0, 0, 26971, 26972, 7, 4, 0, 0, 26972, 26973, 7, 0, 0, 0, 26973, 26974, 7, 1, 0, 0, 26974, 26975, 7, 11, 0, 0, 26975, 26976, 7, 6, 0, 0, 26976, 26977, 7, 6, 0, 0, 26977, 26978, 7, 3, 0, 0, 26978, 26979, 7, 3, 0, 0, 26979, 26980, 7, 19, 0, 0, 26980, 3954, 1, 0, 0, 0, 26981, 26982, 7, 5, 0, 0, 26982, 26983, 7, 18, 0, 0, 26983, 26984, 7, 5, 0, 0, 26984, 26985, 5, 95, 0, 0, 26985, 26986, 7, 25, 0, 0, 26986, 26987, 7, 24, 0, 0, 26987, 26988, 7, 8, 0, 0, 26988, 26989, 7, 2, 0, 0, 26989, 26990, 7, 9, 0, 0, 26990, 26991, 7, 6, 0, 0, 26991, 26992, 7, 15, 0, 0, 26992, 26993, 5, 50, 0, 0, 26993, 26994, 7, 5, 0, 0, 26994, 26995, 7, 4, 0, 0, 26995, 26996, 7, 3, 0, 0, 26996, 3956, 1, 0, 0, 0, 26997, 26998, 7, 5, 0, 0, 26998, 26999, 7, 18, 0, 0, 26999, 27000, 7, 5, 0, 0, 27000, 27001, 5, 95, 0, 0, 27001, 27002, 7, 25, 0, 0, 27002, 27003, 7, 24, 0, 0, 27003, 27004, 7, 8, 0, 0, 27004, 27005, 7, 2, 0, 0, 27005, 27006, 7, 9, 0, 0, 27006, 27007, 7, 6, 0, 0, 27007, 27008, 7, 15, 0, 0, 27008, 27009, 7, 6, 0, 0, 27009, 27010, 7, 24, 0, 0, 27010, 3958, 1, 0, 0, 0, 27011, 27012, 7, 5, 0, 0, 27012, 27013, 7, 18, 0, 0, 27013, 27014, 7, 5, 0, 0, 27014, 27015, 5, 95, 0, 0, 27015, 27016, 7, 25, 0, 0, 27016, 27017, 7, 24, 0, 0, 27017, 27018, 7, 8, 0, 0, 27018, 27019, 7, 2, 0, 0, 27019, 27020, 7, 7, 0, 0, 27020, 27021, 5, 50, 0, 0, 27021, 27022, 7, 5, 0, 0, 27022, 27023, 7, 6, 0, 0, 27023, 27024, 7, 24, 0, 0, 27024, 3960, 1, 0, 0, 0, 27025, 27026, 7, 5, 0, 0, 27026, 27027, 7, 18, 0, 0, 27027, 27028, 7, 5, 0, 0, 27028, 27029, 5, 95, 0, 0, 27029, 27030, 7, 25, 0, 0, 27030, 27031, 7, 24, 0, 0, 27031, 27032, 7, 8, 0, 0, 27032, 27033, 7, 2, 0, 0, 27033, 27034, 7, 7, 0, 0, 27034, 27035, 7, 8, 0, 0, 27035, 27036, 7, 0, 0, 0, 27036, 27037, 7, 4, 0, 0, 27037, 3962, 1, 0, 0, 0, 27038, 27039, 7, 5, 0, 0, 27039, 27040, 7, 18, 0, 0, 27040, 27041, 7, 5, 0, 0, 27041, 27042, 5, 95, 0, 0, 27042, 27043, 7, 25, 0, 0, 27043, 27044, 7, 24, 0, 0, 27044, 27045, 7, 9, 0, 0, 27045, 27046, 7, 6, 0, 0, 27046, 27047, 7, 11, 0, 0, 27047, 27048, 7, 6, 0, 0, 27048, 27049, 7, 4, 0, 0, 27049, 27050, 7, 6, 0, 0, 27050, 3964, 1, 0, 0, 0, 27051, 27052, 7, 5, 0, 0, 27052, 27053, 7, 18, 0, 0, 27053, 27054, 7, 5, 0, 0, 27054, 27055, 5, 95, 0, 0, 27055, 27056, 7, 25, 0, 0, 27056, 27057, 7, 24, 0, 0, 27057, 27058, 7, 9, 0, 0, 27058, 27059, 7, 16, 0, 0, 27059, 27060, 7, 11, 0, 0, 27060, 27061, 7, 4, 0, 0, 27061, 27062, 7, 8, 0, 0, 27062, 27063, 7, 2, 0, 0, 27063, 27064, 7, 11, 0, 0, 27064, 27065, 7, 0, 0, 0, 27065, 27066, 7, 4, 0, 0, 27066, 27067, 7, 10, 0, 0, 27067, 27068, 7, 2, 0, 0, 27068, 27069, 7, 7, 0, 0, 27069, 3966, 1, 0, 0, 0, 27070, 27071, 7, 5, 0, 0, 27071, 27072, 7, 18, 0, 0, 27072, 27073, 7, 5, 0, 0, 27073, 27074, 5, 95, 0, 0, 27074, 27075, 7, 25, 0, 0, 27075, 27076, 7, 24, 0, 0, 27076, 27077, 7, 9, 0, 0, 27077, 27078, 7, 2, 0, 0, 27078, 27079, 7, 8, 0, 0, 27079, 3968, 1, 0, 0, 0, 27080, 27081, 7, 5, 0, 0, 27081, 27082, 7, 18, 0, 0, 27082, 27083, 7, 5, 0, 0, 27083, 27084, 5, 95, 0, 0, 27084, 27085, 7, 25, 0, 0, 27085, 27086, 7, 24, 0, 0, 27086, 27087, 7, 9, 0, 0, 27087, 27088, 7, 2, 0, 0, 27088, 27089, 7, 8, 0, 0, 27089, 27090, 7, 12, 0, 0, 27090, 27091, 7, 3, 0, 0, 27091, 27092, 7, 10, 0, 0, 27092, 3970, 1, 0, 0, 0, 27093, 27094, 7, 5, 0, 0, 27094, 27095, 7, 18, 0, 0, 27095, 27096, 7, 5, 0, 0, 27096, 27097, 5, 95, 0, 0, 27097, 27098, 7, 25, 0, 0, 27098, 27099, 7, 24, 0, 0, 27099, 27100, 7, 9, 0, 0, 27100, 27101, 7, 12, 0, 0, 27101, 27102, 7, 3, 0, 0, 27102, 27103, 7, 9, 0, 0, 27103, 27104, 7, 10, 0, 0, 27104, 27105, 7, 13, 0, 0, 27105, 3972, 1, 0, 0, 0, 27106, 27107, 7, 5, 0, 0, 27107, 27108, 7, 18, 0, 0, 27108, 27109, 7, 5, 0, 0, 27109, 27110, 5, 95, 0, 0, 27110, 27111, 7, 25, 0, 0, 27111, 27112, 7, 24, 0, 0, 27112, 27113, 7, 6, 0, 0, 27113, 27114, 7, 9, 0, 0, 27114, 27115, 5, 52, 0, 0, 27115, 27116, 7, 12, 0, 0, 27116, 27117, 7, 3, 0, 0, 27117, 27118, 7, 10, 0, 0, 27118, 3974, 1, 0, 0, 0, 27119, 27120, 7, 5, 0, 0, 27120, 27121, 7, 18, 0, 0, 27121, 27122, 7, 5, 0, 0, 27122, 27123, 5, 95, 0, 0, 27123, 27124, 7, 25, 0, 0, 27124, 27125, 7, 24, 0, 0, 27125, 27126, 7, 6, 0, 0, 27126, 27127, 7, 7, 0, 0, 27127, 27128, 7, 9, 0, 0, 27128, 27129, 7, 5, 0, 0, 27129, 27130, 7, 22, 0, 0, 27130, 27131, 7, 10, 0, 0, 27131, 27132, 7, 4, 0, 0, 27132, 27133, 7, 19, 0, 0, 27133, 3976, 1, 0, 0, 0, 27134, 27135, 7, 5, 0, 0, 27135, 27136, 7, 18, 0, 0, 27136, 27137, 7, 5, 0, 0, 27137, 27138, 5, 95, 0, 0, 27138, 27139, 7, 25, 0, 0, 27139, 27140, 7, 24, 0, 0, 27140, 27141, 7, 6, 0, 0, 27141, 27142, 7, 3, 0, 0, 27142, 27143, 7, 3, 0, 0, 27143, 27144, 7, 19, 0, 0, 27144, 3978, 1, 0, 0, 0, 27145, 27146, 7, 5, 0, 0, 27146, 27147, 7, 18, 0, 0, 27147, 27148, 7, 5, 0, 0, 27148, 27149, 5, 95, 0, 0, 27149, 27150, 7, 25, 0, 0, 27150, 27151, 7, 24, 0, 0, 27151, 27152, 7, 6, 0, 0, 27152, 27153, 7, 3, 0, 0, 27153, 27154, 7, 3, 0, 0, 27154, 3980, 1, 0, 0, 0, 27155, 27156, 7, 5, 0, 0, 27156, 27157, 7, 18, 0, 0, 27157, 27158, 7, 5, 0, 0, 27158, 27159, 5, 95, 0, 0, 27159, 27160, 7, 25, 0, 0, 27160, 27161, 7, 24, 0, 0, 27161, 27162, 7, 6, 0, 0, 27162, 27163, 7, 5, 0, 0, 27163, 27164, 7, 19, 0, 0, 27164, 27165, 7, 4, 0, 0, 27165, 27166, 7, 14, 0, 0, 27166, 27167, 7, 11, 0, 0, 27167, 27168, 7, 12, 0, 0, 27168, 27169, 7, 3, 0, 0, 27169, 27170, 7, 10, 0, 0, 27170, 3982, 1, 0, 0, 0, 27171, 27172, 7, 5, 0, 0, 27172, 27173, 7, 18, 0, 0, 27173, 27174, 7, 5, 0, 0, 27174, 27175, 5, 95, 0, 0, 27175, 27176, 7, 25, 0, 0, 27176, 27177, 7, 24, 0, 0, 27177, 27178, 7, 6, 0, 0, 27178, 27179, 7, 25, 0, 0, 27179, 27180, 7, 11, 0, 0, 27180, 27181, 7, 2, 0, 0, 27181, 27182, 7, 1, 0, 0, 27182, 27183, 7, 13, 0, 0, 27183, 27184, 7, 0, 0, 0, 27184, 27185, 7, 11, 0, 0, 27185, 3984, 1, 0, 0, 0, 27186, 27187, 7, 5, 0, 0, 27187, 27188, 7, 18, 0, 0, 27188, 27189, 7, 5, 0, 0, 27189, 27190, 5, 95, 0, 0, 27190, 27191, 7, 25, 0, 0, 27191, 27192, 7, 24, 0, 0, 27192, 27193, 7, 6, 0, 0, 27193, 27194, 7, 25, 0, 0, 27194, 27195, 7, 5, 0, 0, 27195, 27196, 7, 4, 0, 0, 27196, 27197, 7, 22, 0, 0, 27197, 27198, 7, 3, 0, 0, 27198, 27199, 7, 15, 0, 0, 27199, 3986, 1, 0, 0, 0, 27200, 27201, 7, 5, 0, 0, 27201, 27202, 7, 18, 0, 0, 27202, 27203, 7, 5, 0, 0, 27203, 27204, 5, 95, 0, 0, 27204, 27205, 7, 25, 0, 0, 27205, 27206, 7, 24, 0, 0, 27206, 27207, 7, 6, 0, 0, 27207, 27208, 7, 25, 0, 0, 27208, 27209, 7, 4, 0, 0, 27209, 27210, 7, 3, 0, 0, 27210, 27211, 7, 0, 0, 0, 27211, 27212, 7, 8, 0, 0, 27212, 27213, 7, 4, 0, 0, 27213, 3988, 1, 0, 0, 0, 27214, 27215, 7, 5, 0, 0, 27215, 27216, 7, 18, 0, 0, 27216, 27217, 7, 5, 0, 0, 27217, 27218, 5, 95, 0, 0, 27218, 27219, 7, 25, 0, 0, 27219, 27220, 7, 24, 0, 0, 27220, 27221, 7, 6, 0, 0, 27221, 27222, 7, 25, 0, 0, 27222, 27223, 7, 4, 0, 0, 27223, 27224, 7, 3, 0, 0, 27224, 27225, 7, 3, 0, 0, 27225, 27226, 7, 6, 0, 0, 27226, 27227, 7, 16, 0, 0, 27227, 3990, 1, 0, 0, 0, 27228, 27229, 7, 5, 0, 0, 27229, 27230, 7, 18, 0, 0, 27230, 27231, 7, 5, 0, 0, 27231, 27232, 5, 95, 0, 0, 27232, 27233, 7, 25, 0, 0, 27233, 27234, 7, 24, 0, 0, 27234, 27235, 7, 6, 0, 0, 27235, 27236, 7, 25, 0, 0, 27236, 27237, 7, 13, 0, 0, 27237, 27238, 7, 0, 0, 0, 27238, 27239, 7, 11, 0, 0, 27239, 3992, 1, 0, 0, 0, 27240, 27241, 7, 5, 0, 0, 27241, 27242, 7, 18, 0, 0, 27242, 27243, 7, 5, 0, 0, 27243, 27244, 5, 95, 0, 0, 27244, 27245, 7, 25, 0, 0, 27245, 27246, 7, 24, 0, 0, 27246, 27247, 7, 16, 0, 0, 27247, 27248, 7, 1, 0, 0, 27248, 27249, 5, 50, 0, 0, 27249, 27250, 7, 5, 0, 0, 27250, 27251, 7, 4, 0, 0, 27251, 27252, 7, 3, 0, 0, 27252, 3994, 1, 0, 0, 0, 27253, 27254, 7, 5, 0, 0, 27254, 27255, 7, 18, 0, 0, 27255, 27256, 7, 5, 0, 0, 27256, 27257, 5, 95, 0, 0, 27257, 27258, 7, 25, 0, 0, 27258, 27259, 7, 24, 0, 0, 27259, 27260, 7, 16, 0, 0, 27260, 27261, 7, 7, 0, 0, 27261, 27262, 7, 1, 0, 0, 27262, 27263, 7, 2, 0, 0, 27263, 27264, 7, 2, 0, 0, 27264, 27265, 7, 11, 0, 0, 27265, 3996, 1, 0, 0, 0, 27266, 27267, 7, 5, 0, 0, 27267, 27268, 7, 18, 0, 0, 27268, 27269, 7, 5, 0, 0, 27269, 27270, 5, 95, 0, 0, 27270, 27271, 7, 25, 0, 0, 27271, 27272, 7, 24, 0, 0, 27272, 27273, 7, 16, 0, 0, 27273, 27274, 7, 7, 0, 0, 27274, 27275, 7, 8, 0, 0, 27275, 27276, 7, 14, 0, 0, 27276, 27277, 7, 15, 0, 0, 27277, 3998, 1, 0, 0, 0, 27278, 27279, 7, 5, 0, 0, 27279, 27280, 7, 18, 0, 0, 27280, 27281, 7, 5, 0, 0, 27281, 27282, 5, 95, 0, 0, 27282, 27283, 7, 25, 0, 0, 27283, 27284, 7, 24, 0, 0, 27284, 27285, 7, 16, 0, 0, 27285, 27286, 7, 7, 0, 0, 27286, 27287, 7, 9, 0, 0, 27287, 27288, 7, 0, 0, 0, 27288, 27289, 7, 4, 0, 0, 27289, 27290, 7, 10, 0, 0, 27290, 27291, 7, 14, 0, 0, 27291, 4000, 1, 0, 0, 0, 27292, 27293, 7, 5, 0, 0, 27293, 27294, 7, 18, 0, 0, 27294, 27295, 7, 5, 0, 0, 27295, 27296, 5, 95, 0, 0, 27296, 27297, 7, 25, 0, 0, 27297, 27298, 7, 24, 0, 0, 27298, 27299, 7, 16, 0, 0, 27299, 27300, 7, 7, 0, 0, 27300, 27301, 7, 11, 0, 0, 27301, 27302, 7, 7, 0, 0, 27302, 27303, 7, 0, 0, 0, 27303, 27304, 7, 14, 0, 0, 27304, 27305, 7, 6, 0, 0, 27305, 4002, 1, 0, 0, 0, 27306, 27307, 7, 5, 0, 0, 27307, 27308, 7, 18, 0, 0, 27308, 27309, 7, 5, 0, 0, 27309, 27310, 5, 95, 0, 0, 27310, 27311, 7, 25, 0, 0, 27311, 27312, 7, 24, 0, 0, 27312, 27313, 7, 16, 0, 0, 27313, 27314, 7, 7, 0, 0, 27314, 27315, 7, 7, 0, 0, 27315, 27316, 7, 14, 0, 0, 27316, 4004, 1, 0, 0, 0, 27317, 27318, 7, 5, 0, 0, 27318, 27319, 7, 18, 0, 0, 27319, 27320, 7, 5, 0, 0, 27320, 27321, 5, 95, 0, 0, 27321, 27322, 7, 25, 0, 0, 27322, 27323, 7, 24, 0, 0, 27323, 27324, 7, 16, 0, 0, 27324, 27325, 7, 7, 0, 0, 27325, 27326, 7, 7, 0, 0, 27326, 27327, 7, 5, 0, 0, 27327, 27328, 7, 12, 0, 0, 27328, 27329, 7, 3, 0, 0, 27329, 27330, 7, 10, 0, 0, 27330, 4006, 1, 0, 0, 0, 27331, 27332, 7, 5, 0, 0, 27332, 27333, 7, 18, 0, 0, 27333, 27334, 7, 5, 0, 0, 27334, 27335, 5, 95, 0, 0, 27335, 27336, 7, 25, 0, 0, 27336, 27337, 7, 24, 0, 0, 27337, 27338, 7, 16, 0, 0, 27338, 27339, 7, 7, 0, 0, 27339, 27340, 7, 15, 0, 0, 27340, 27341, 7, 3, 0, 0, 27341, 27342, 7, 6, 0, 0, 27342, 27343, 7, 9, 0, 0, 27343, 27344, 7, 4, 0, 0, 27344, 27345, 7, 3, 0, 0, 27345, 27346, 7, 12, 0, 0, 27346, 27347, 7, 4, 0, 0, 27347, 27348, 7, 19, 0, 0, 27348, 4008, 1, 0, 0, 0, 27349, 27350, 7, 5, 0, 0, 27350, 27351, 7, 18, 0, 0, 27351, 27352, 7, 5, 0, 0, 27352, 27353, 5, 95, 0, 0, 27353, 27354, 7, 25, 0, 0, 27354, 27355, 7, 24, 0, 0, 27355, 27356, 7, 16, 0, 0, 27356, 27357, 7, 7, 0, 0, 27357, 27358, 7, 24, 0, 0, 27358, 27359, 7, 7, 0, 0, 27359, 27360, 7, 14, 0, 0, 27360, 4010, 1, 0, 0, 0, 27361, 27362, 7, 5, 0, 0, 27362, 27363, 7, 18, 0, 0, 27363, 27364, 7, 5, 0, 0, 27364, 27365, 5, 95, 0, 0, 27365, 27366, 7, 25, 0, 0, 27366, 27367, 7, 24, 0, 0, 27367, 27368, 7, 16, 0, 0, 27368, 27369, 7, 7, 0, 0, 27369, 27370, 7, 3, 0, 0, 27370, 27371, 7, 2, 0, 0, 27371, 27372, 7, 2, 0, 0, 27372, 27373, 7, 4, 0, 0, 27373, 4012, 1, 0, 0, 0, 27374, 27375, 7, 5, 0, 0, 27375, 27376, 7, 18, 0, 0, 27376, 27377, 7, 5, 0, 0, 27377, 27378, 5, 95, 0, 0, 27378, 27379, 7, 25, 0, 0, 27379, 27380, 7, 24, 0, 0, 27380, 27381, 7, 16, 0, 0, 27381, 27382, 7, 2, 0, 0, 27382, 27383, 7, 3, 0, 0, 27383, 27384, 7, 14, 0, 0, 27384, 27385, 7, 0, 0, 0, 27385, 27386, 7, 4, 0, 0, 27386, 27387, 7, 7, 0, 0, 27387, 27388, 7, 12, 0, 0, 27388, 27389, 7, 14, 0, 0, 27389, 4014, 1, 0, 0, 0, 27390, 27391, 7, 5, 0, 0, 27391, 27392, 7, 18, 0, 0, 27392, 27393, 7, 5, 0, 0, 27393, 27394, 5, 95, 0, 0, 27394, 27395, 7, 25, 0, 0, 27395, 27396, 7, 24, 0, 0, 27396, 27397, 7, 16, 0, 0, 27397, 27398, 7, 4, 0, 0, 27398, 27399, 7, 8, 0, 0, 27399, 27400, 7, 2, 0, 0, 27400, 27401, 7, 7, 0, 0, 27401, 27402, 7, 4, 0, 0, 27402, 27403, 7, 0, 0, 0, 27403, 27404, 7, 10, 0, 0, 27404, 27405, 7, 7, 0, 0, 27405, 4016, 1, 0, 0, 0, 27406, 27407, 7, 5, 0, 0, 27407, 27408, 7, 18, 0, 0, 27408, 27409, 7, 5, 0, 0, 27409, 27410, 5, 95, 0, 0, 27410, 27411, 7, 25, 0, 0, 27411, 27412, 7, 24, 0, 0, 27412, 27413, 7, 16, 0, 0, 27413, 27414, 7, 12, 0, 0, 27414, 27415, 7, 7, 0, 0, 27415, 27416, 7, 8, 0, 0, 27416, 27417, 7, 3, 0, 0, 27417, 4018, 1, 0, 0, 0, 27418, 27419, 7, 5, 0, 0, 27419, 27420, 7, 18, 0, 0, 27420, 27421, 7, 5, 0, 0, 27421, 27422, 5, 95, 0, 0, 27422, 27423, 7, 25, 0, 0, 27423, 27424, 7, 24, 0, 0, 27424, 27425, 7, 17, 0, 0, 27425, 27426, 7, 6, 0, 0, 27426, 27427, 7, 4, 0, 0, 27427, 27428, 7, 8, 0, 0, 27428, 27429, 7, 2, 0, 0, 27429, 27430, 7, 7, 0, 0, 27430, 27431, 7, 4, 0, 0, 27431, 27432, 7, 6, 0, 0, 27432, 27433, 7, 7, 0, 0, 27433, 27434, 7, 4, 0, 0, 27434, 4020, 1, 0, 0, 0, 27435, 27436, 7, 5, 0, 0, 27436, 27437, 7, 18, 0, 0, 27437, 27438, 7, 5, 0, 0, 27438, 27439, 5, 95, 0, 0, 27439, 27440, 7, 25, 0, 0, 27440, 27441, 7, 24, 0, 0, 27441, 27442, 7, 10, 0, 0, 27442, 27443, 7, 7, 0, 0, 27443, 27444, 7, 9, 0, 0, 27444, 27445, 7, 25, 0, 0, 27445, 27446, 7, 2, 0, 0, 27446, 27447, 7, 16, 0, 0, 27447, 4022, 1, 0, 0, 0, 27448, 27449, 7, 5, 0, 0, 27449, 27450, 7, 18, 0, 0, 27450, 27451, 7, 5, 0, 0, 27451, 27452, 5, 95, 0, 0, 27452, 27453, 7, 25, 0, 0, 27453, 27454, 7, 24, 0, 0, 27454, 27455, 7, 10, 0, 0, 27455, 27456, 7, 7, 0, 0, 27456, 27457, 7, 5, 0, 0, 27457, 27458, 7, 6, 0, 0, 27458, 27459, 7, 3, 0, 0, 27459, 27460, 7, 4, 0, 0, 27460, 4024, 1, 0, 0, 0, 27461, 27462, 7, 5, 0, 0, 27462, 27463, 7, 18, 0, 0, 27463, 27464, 7, 5, 0, 0, 27464, 27465, 5, 95, 0, 0, 27465, 27466, 7, 25, 0, 0, 27466, 27467, 7, 24, 0, 0, 27467, 27468, 7, 10, 0, 0, 27468, 27469, 7, 7, 0, 0, 27469, 27470, 7, 5, 0, 0, 27470, 27471, 7, 15, 0, 0, 27471, 27472, 7, 16, 0, 0, 27472, 27473, 7, 25, 0, 0, 27473, 4026, 1, 0, 0, 0, 27474, 27475, 7, 5, 0, 0, 27475, 27476, 7, 18, 0, 0, 27476, 27477, 7, 5, 0, 0, 27477, 27478, 5, 95, 0, 0, 27478, 27479, 7, 25, 0, 0, 27479, 27480, 7, 24, 0, 0, 27480, 27481, 7, 10, 0, 0, 27481, 27482, 7, 3, 0, 0, 27482, 27483, 7, 10, 0, 0, 27483, 27484, 5, 50, 0, 0, 27484, 27485, 7, 12, 0, 0, 27485, 27486, 7, 3, 0, 0, 27486, 27487, 7, 10, 0, 0, 27487, 4028, 1, 0, 0, 0, 27488, 27489, 7, 5, 0, 0, 27489, 27490, 7, 18, 0, 0, 27490, 27491, 7, 5, 0, 0, 27491, 27492, 5, 95, 0, 0, 27492, 27493, 7, 25, 0, 0, 27493, 27494, 7, 24, 0, 0, 27494, 27495, 7, 11, 0, 0, 27495, 27496, 7, 0, 0, 0, 27496, 27497, 7, 7, 0, 0, 27497, 27498, 7, 17, 0, 0, 27498, 4030, 1, 0, 0, 0, 27499, 27500, 7, 5, 0, 0, 27500, 27501, 7, 18, 0, 0, 27501, 27502, 7, 5, 0, 0, 27502, 27503, 5, 95, 0, 0, 27503, 27504, 7, 25, 0, 0, 27504, 27505, 7, 24, 0, 0, 27505, 27506, 7, 11, 0, 0, 27506, 27507, 7, 11, 0, 0, 27507, 27508, 7, 7, 0, 0, 27508, 27509, 7, 14, 0, 0, 27509, 27510, 7, 16, 0, 0, 27510, 27511, 7, 3, 0, 0, 27511, 27512, 7, 14, 0, 0, 27512, 27513, 7, 24, 0, 0, 27513, 27514, 7, 7, 0, 0, 27514, 27515, 7, 14, 0, 0, 27515, 4032, 1, 0, 0, 0, 27516, 27517, 7, 5, 0, 0, 27517, 27518, 7, 18, 0, 0, 27518, 27519, 7, 5, 0, 0, 27519, 27520, 5, 95, 0, 0, 27520, 27521, 7, 25, 0, 0, 27521, 27522, 7, 24, 0, 0, 27522, 27523, 7, 14, 0, 0, 27523, 27524, 7, 21, 0, 0, 27524, 27525, 7, 7, 0, 0, 27525, 27526, 7, 2, 0, 0, 27526, 27527, 7, 9, 0, 0, 27527, 27528, 7, 6, 0, 0, 27528, 27529, 7, 3, 0, 0, 27529, 27530, 7, 6, 0, 0, 27530, 27531, 7, 16, 0, 0, 27531, 4034, 1, 0, 0, 0, 27532, 27533, 7, 5, 0, 0, 27533, 27534, 7, 18, 0, 0, 27534, 27535, 7, 5, 0, 0, 27535, 27536, 5, 95, 0, 0, 27536, 27537, 7, 25, 0, 0, 27537, 27538, 7, 24, 0, 0, 27538, 27539, 7, 7, 0, 0, 27539, 27540, 7, 10, 0, 0, 27540, 27541, 7, 11, 0, 0, 27541, 27542, 7, 11, 0, 0, 27542, 27543, 7, 6, 0, 0, 27543, 27544, 7, 9, 0, 0, 27544, 4036, 1, 0, 0, 0, 27545, 27546, 7, 5, 0, 0, 27546, 27547, 7, 18, 0, 0, 27547, 27548, 7, 5, 0, 0, 27548, 27549, 5, 95, 0, 0, 27549, 27550, 7, 25, 0, 0, 27550, 27551, 7, 24, 0, 0, 27551, 27552, 7, 7, 0, 0, 27552, 27553, 7, 2, 0, 0, 27553, 27554, 7, 9, 0, 0, 27554, 27555, 7, 6, 0, 0, 27555, 27556, 7, 7, 0, 0, 27556, 27557, 7, 0, 0, 0, 27557, 27558, 7, 14, 0, 0, 27558, 27559, 7, 6, 0, 0, 27559, 4038, 1, 0, 0, 0, 27560, 27561, 7, 5, 0, 0, 27561, 27562, 7, 18, 0, 0, 27562, 27563, 7, 5, 0, 0, 27563, 27564, 5, 95, 0, 0, 27564, 27565, 7, 25, 0, 0, 27565, 27566, 7, 24, 0, 0, 27566, 27567, 7, 7, 0, 0, 27567, 27568, 7, 2, 0, 0, 27568, 27569, 7, 3, 0, 0, 27569, 27570, 7, 14, 0, 0, 27570, 27571, 7, 5, 0, 0, 27571, 27572, 7, 15, 0, 0, 27572, 27573, 7, 0, 0, 0, 27573, 27574, 7, 8, 0, 0, 27574, 27575, 7, 6, 0, 0, 27575, 4040, 1, 0, 0, 0, 27576, 27577, 7, 5, 0, 0, 27577, 27578, 7, 18, 0, 0, 27578, 27579, 7, 5, 0, 0, 27579, 27580, 5, 95, 0, 0, 27580, 27581, 7, 25, 0, 0, 27581, 27582, 7, 24, 0, 0, 27582, 27583, 7, 7, 0, 0, 27583, 27584, 7, 2, 0, 0, 27584, 27585, 7, 3, 0, 0, 27585, 27586, 7, 14, 0, 0, 27586, 27587, 7, 12, 0, 0, 27587, 27588, 7, 8, 0, 0, 27588, 27589, 7, 2, 0, 0, 27589, 27590, 7, 9, 0, 0, 27590, 27591, 7, 6, 0, 0, 27591, 4042, 1, 0, 0, 0, 27592, 27593, 7, 5, 0, 0, 27593, 27594, 7, 18, 0, 0, 27594, 27595, 7, 5, 0, 0, 27595, 27596, 5, 95, 0, 0, 27596, 27597, 7, 25, 0, 0, 27597, 27598, 7, 24, 0, 0, 27598, 27599, 5, 95, 0, 0, 27599, 27600, 7, 7, 0, 0, 27600, 27601, 7, 3, 0, 0, 27601, 27602, 7, 7, 0, 0, 27602, 27603, 7, 17, 0, 0, 27603, 4044, 1, 0, 0, 0, 27604, 27605, 7, 5, 0, 0, 27605, 27606, 7, 18, 0, 0, 27606, 27607, 7, 5, 0, 0, 27607, 27608, 5, 95, 0, 0, 27608, 27609, 7, 25, 0, 0, 27609, 27610, 7, 24, 0, 0, 27610, 27611, 7, 7, 0, 0, 27611, 27612, 7, 5, 0, 0, 27612, 27613, 7, 15, 0, 0, 27613, 27614, 5, 52, 0, 0, 27614, 27615, 7, 15, 0, 0, 27615, 27616, 7, 16, 0, 0, 27616, 27617, 7, 25, 0, 0, 27617, 4046, 1, 0, 0, 0, 27618, 27619, 7, 5, 0, 0, 27619, 27620, 7, 18, 0, 0, 27620, 27621, 7, 5, 0, 0, 27621, 27622, 5, 95, 0, 0, 27622, 27623, 7, 25, 0, 0, 27623, 27624, 7, 24, 0, 0, 27624, 27625, 7, 7, 0, 0, 27625, 27626, 7, 5, 0, 0, 27626, 27627, 7, 15, 0, 0, 27627, 27628, 7, 16, 0, 0, 27628, 27629, 7, 3, 0, 0, 27629, 27630, 7, 14, 0, 0, 27630, 27631, 7, 24, 0, 0, 27631, 27632, 7, 7, 0, 0, 27632, 27633, 7, 14, 0, 0, 27633, 4048, 1, 0, 0, 0, 27634, 27635, 7, 5, 0, 0, 27635, 27636, 7, 18, 0, 0, 27636, 27637, 7, 5, 0, 0, 27637, 27638, 5, 95, 0, 0, 27638, 27639, 7, 25, 0, 0, 27639, 27640, 7, 24, 0, 0, 27640, 27641, 7, 15, 0, 0, 27641, 27642, 7, 16, 0, 0, 27642, 27643, 7, 25, 0, 0, 27643, 27644, 7, 16, 0, 0, 27644, 27645, 7, 3, 0, 0, 27645, 27646, 7, 14, 0, 0, 27646, 27647, 7, 24, 0, 0, 27647, 27648, 7, 7, 0, 0, 27648, 27649, 7, 14, 0, 0, 27649, 4050, 1, 0, 0, 0, 27650, 27651, 7, 5, 0, 0, 27651, 27652, 7, 18, 0, 0, 27652, 27653, 7, 5, 0, 0, 27653, 27654, 5, 95, 0, 0, 27654, 27655, 7, 25, 0, 0, 27655, 27656, 7, 24, 0, 0, 27656, 27657, 5, 95, 0, 0, 27657, 27658, 7, 15, 0, 0, 27658, 27659, 7, 21, 0, 0, 27659, 27660, 7, 5, 0, 0, 27660, 27661, 7, 24, 0, 0, 27661, 27662, 7, 11, 0, 0, 27662, 27663, 5, 50, 0, 0, 27663, 27664, 7, 25, 0, 0, 27664, 27665, 7, 14, 0, 0, 27665, 27666, 7, 11, 0, 0, 27666, 4052, 1, 0, 0, 0, 27667, 27668, 7, 5, 0, 0, 27668, 27669, 7, 18, 0, 0, 27669, 27670, 7, 5, 0, 0, 27670, 27671, 5, 95, 0, 0, 27671, 27672, 7, 25, 0, 0, 27672, 27673, 7, 24, 0, 0, 27673, 27674, 7, 15, 0, 0, 27674, 27675, 7, 2, 0, 0, 27675, 27676, 7, 11, 0, 0, 27676, 27677, 7, 18, 0, 0, 27677, 27678, 7, 0, 0, 0, 27678, 27679, 7, 1, 0, 0, 27679, 27680, 7, 5, 0, 0, 27680, 4054, 1, 0, 0, 0, 27681, 27682, 7, 5, 0, 0, 27682, 27683, 7, 18, 0, 0, 27683, 27684, 7, 5, 0, 0, 27684, 27685, 5, 95, 0, 0, 27685, 27686, 7, 25, 0, 0, 27686, 27687, 7, 24, 0, 0, 27687, 27688, 7, 15, 0, 0, 27688, 27689, 7, 2, 0, 0, 27689, 27690, 7, 11, 0, 0, 27690, 27691, 7, 18, 0, 0, 27691, 27692, 7, 0, 0, 0, 27692, 27693, 7, 9, 0, 0, 27693, 27694, 7, 9, 0, 0, 27694, 4056, 1, 0, 0, 0, 27695, 27696, 7, 5, 0, 0, 27696, 27697, 7, 18, 0, 0, 27697, 27698, 7, 5, 0, 0, 27698, 27699, 5, 95, 0, 0, 27699, 27700, 7, 25, 0, 0, 27700, 27701, 7, 24, 0, 0, 27701, 27702, 7, 15, 0, 0, 27702, 27703, 7, 2, 0, 0, 27703, 27704, 7, 11, 0, 0, 27704, 27705, 7, 18, 0, 0, 27705, 27706, 7, 8, 0, 0, 27706, 27707, 7, 6, 0, 0, 27707, 27708, 7, 11, 0, 0, 27708, 4058, 1, 0, 0, 0, 27709, 27710, 7, 5, 0, 0, 27710, 27711, 7, 18, 0, 0, 27711, 27712, 7, 5, 0, 0, 27712, 27713, 5, 95, 0, 0, 27713, 27714, 7, 25, 0, 0, 27714, 27715, 7, 24, 0, 0, 27715, 27716, 7, 15, 0, 0, 27716, 27717, 7, 2, 0, 0, 27717, 27718, 7, 11, 0, 0, 27718, 27719, 7, 18, 0, 0, 27719, 27720, 7, 8, 0, 0, 27720, 27721, 7, 5, 0, 0, 27721, 27722, 7, 4, 0, 0, 27722, 27723, 7, 1, 0, 0, 27723, 27724, 7, 11, 0, 0, 27724, 4060, 1, 0, 0, 0, 27725, 27726, 7, 5, 0, 0, 27726, 27727, 7, 18, 0, 0, 27727, 27728, 7, 5, 0, 0, 27728, 27729, 5, 95, 0, 0, 27729, 27730, 7, 25, 0, 0, 27730, 27731, 7, 24, 0, 0, 27731, 27732, 7, 15, 0, 0, 27732, 27733, 7, 2, 0, 0, 27733, 27734, 7, 11, 0, 0, 27734, 27735, 7, 18, 0, 0, 27735, 27736, 7, 8, 0, 0, 27736, 27737, 7, 5, 0, 0, 27737, 27738, 7, 4, 0, 0, 27738, 4062, 1, 0, 0, 0, 27739, 27740, 7, 5, 0, 0, 27740, 27741, 7, 18, 0, 0, 27741, 27742, 7, 5, 0, 0, 27742, 27743, 5, 95, 0, 0, 27743, 27744, 7, 25, 0, 0, 27744, 27745, 7, 24, 0, 0, 27745, 27746, 7, 15, 0, 0, 27746, 27747, 7, 2, 0, 0, 27747, 27748, 7, 11, 0, 0, 27748, 27749, 7, 18, 0, 0, 27749, 27750, 7, 9, 0, 0, 27750, 27751, 7, 10, 0, 0, 27751, 27752, 7, 13, 0, 0, 27752, 4064, 1, 0, 0, 0, 27753, 27754, 7, 5, 0, 0, 27754, 27755, 7, 18, 0, 0, 27755, 27756, 7, 5, 0, 0, 27756, 27757, 5, 95, 0, 0, 27757, 27758, 7, 25, 0, 0, 27758, 27759, 7, 24, 0, 0, 27759, 27760, 7, 15, 0, 0, 27760, 27761, 7, 2, 0, 0, 27761, 27762, 7, 11, 0, 0, 27762, 27763, 7, 18, 0, 0, 27763, 27764, 7, 16, 0, 0, 27764, 27765, 7, 11, 0, 0, 27765, 27766, 7, 3, 0, 0, 27766, 4066, 1, 0, 0, 0, 27767, 27768, 7, 5, 0, 0, 27768, 27769, 7, 18, 0, 0, 27769, 27770, 7, 5, 0, 0, 27770, 27771, 5, 95, 0, 0, 27771, 27772, 7, 25, 0, 0, 27772, 27773, 7, 24, 0, 0, 27773, 27774, 7, 15, 0, 0, 27774, 27775, 7, 2, 0, 0, 27775, 27776, 7, 11, 0, 0, 27776, 27777, 7, 18, 0, 0, 27777, 27778, 7, 14, 0, 0, 27778, 27779, 7, 2, 0, 0, 27779, 27780, 7, 9, 0, 0, 27780, 4068, 1, 0, 0, 0, 27781, 27782, 7, 5, 0, 0, 27782, 27783, 7, 18, 0, 0, 27783, 27784, 7, 5, 0, 0, 27784, 27785, 5, 95, 0, 0, 27785, 27786, 7, 25, 0, 0, 27786, 27787, 7, 24, 0, 0, 27787, 27788, 7, 15, 0, 0, 27788, 27789, 7, 2, 0, 0, 27789, 27790, 7, 11, 0, 0, 27790, 27791, 7, 18, 0, 0, 27791, 27792, 7, 14, 0, 0, 27792, 27793, 7, 12, 0, 0, 27793, 27794, 7, 11, 0, 0, 27794, 4070, 1, 0, 0, 0, 27795, 27796, 7, 5, 0, 0, 27796, 27797, 7, 18, 0, 0, 27797, 27798, 7, 5, 0, 0, 27798, 27799, 5, 95, 0, 0, 27799, 27800, 7, 25, 0, 0, 27800, 27801, 7, 24, 0, 0, 27801, 27802, 7, 15, 0, 0, 27802, 27803, 7, 2, 0, 0, 27803, 27804, 7, 11, 0, 0, 27804, 27805, 7, 18, 0, 0, 27805, 27806, 7, 3, 0, 0, 27806, 27807, 7, 7, 0, 0, 27807, 27808, 7, 9, 0, 0, 27808, 4072, 1, 0, 0, 0, 27809, 27810, 7, 5, 0, 0, 27810, 27811, 7, 18, 0, 0, 27811, 27812, 7, 5, 0, 0, 27812, 27813, 5, 95, 0, 0, 27813, 27814, 7, 25, 0, 0, 27814, 27815, 7, 24, 0, 0, 27815, 27816, 7, 15, 0, 0, 27816, 27817, 7, 2, 0, 0, 27817, 27818, 7, 11, 0, 0, 27818, 27819, 7, 18, 0, 0, 27819, 27820, 7, 5, 0, 0, 27820, 27821, 7, 24, 0, 0, 27821, 27822, 7, 3, 0, 0, 27822, 27823, 7, 4, 0, 0, 27823, 4074, 1, 0, 0, 0, 27824, 27825, 7, 5, 0, 0, 27825, 27826, 7, 18, 0, 0, 27826, 27827, 7, 5, 0, 0, 27827, 27828, 5, 95, 0, 0, 27828, 27829, 7, 25, 0, 0, 27829, 27830, 7, 24, 0, 0, 27830, 27831, 7, 15, 0, 0, 27831, 27832, 7, 2, 0, 0, 27832, 27833, 7, 11, 0, 0, 27833, 27834, 7, 18, 0, 0, 27834, 27835, 7, 5, 0, 0, 27835, 27836, 7, 12, 0, 0, 27836, 27837, 7, 1, 0, 0, 27837, 4076, 1, 0, 0, 0, 27838, 27839, 7, 5, 0, 0, 27839, 27840, 7, 18, 0, 0, 27840, 27841, 7, 5, 0, 0, 27841, 27842, 5, 95, 0, 0, 27842, 27843, 7, 25, 0, 0, 27843, 27844, 7, 24, 0, 0, 27844, 27845, 7, 15, 0, 0, 27845, 27846, 7, 2, 0, 0, 27846, 27847, 7, 11, 0, 0, 27847, 27848, 7, 18, 0, 0, 27848, 27849, 7, 12, 0, 0, 27849, 27850, 7, 14, 0, 0, 27850, 27851, 7, 12, 0, 0, 27851, 27852, 7, 5, 0, 0, 27852, 4078, 1, 0, 0, 0, 27853, 27854, 7, 5, 0, 0, 27854, 27855, 7, 18, 0, 0, 27855, 27856, 7, 5, 0, 0, 27856, 27857, 5, 95, 0, 0, 27857, 27858, 7, 25, 0, 0, 27858, 27859, 7, 24, 0, 0, 27859, 27860, 7, 15, 0, 0, 27860, 27861, 7, 2, 0, 0, 27861, 27862, 7, 11, 0, 0, 27862, 27863, 7, 18, 0, 0, 27863, 27864, 7, 12, 0, 0, 27864, 27865, 7, 15, 0, 0, 27865, 27866, 7, 11, 0, 0, 27866, 27867, 7, 5, 0, 0, 27867, 4080, 1, 0, 0, 0, 27868, 27869, 7, 5, 0, 0, 27869, 27870, 7, 18, 0, 0, 27870, 27871, 7, 5, 0, 0, 27871, 27872, 5, 95, 0, 0, 27872, 27873, 7, 25, 0, 0, 27873, 27874, 7, 24, 0, 0, 27874, 27875, 7, 15, 0, 0, 27875, 27876, 7, 2, 0, 0, 27876, 27877, 7, 11, 0, 0, 27877, 27878, 7, 18, 0, 0, 27878, 27879, 7, 13, 0, 0, 27879, 27880, 7, 6, 0, 0, 27880, 27881, 7, 24, 0, 0, 27881, 4082, 1, 0, 0, 0, 27882, 27883, 7, 5, 0, 0, 27883, 27884, 7, 18, 0, 0, 27884, 27885, 7, 5, 0, 0, 27885, 27886, 5, 95, 0, 0, 27886, 27887, 7, 25, 0, 0, 27887, 27888, 7, 24, 0, 0, 27888, 27889, 7, 15, 0, 0, 27889, 27890, 7, 2, 0, 0, 27890, 27891, 7, 11, 0, 0, 27891, 27892, 7, 18, 0, 0, 27892, 27893, 7, 13, 0, 0, 27893, 27894, 7, 17, 0, 0, 27894, 27895, 7, 6, 0, 0, 27895, 4084, 1, 0, 0, 0, 27896, 27897, 7, 5, 0, 0, 27897, 27898, 7, 18, 0, 0, 27898, 27899, 7, 5, 0, 0, 27899, 27900, 5, 95, 0, 0, 27900, 27901, 7, 25, 0, 0, 27901, 27902, 7, 24, 0, 0, 27902, 27903, 7, 15, 0, 0, 27903, 27904, 7, 2, 0, 0, 27904, 27905, 7, 11, 0, 0, 27905, 27906, 7, 18, 0, 0, 27906, 27907, 7, 13, 0, 0, 27907, 27908, 7, 17, 0, 0, 27908, 27909, 7, 4, 0, 0, 27909, 4086, 1, 0, 0, 0, 27910, 27911, 7, 5, 0, 0, 27911, 27912, 7, 18, 0, 0, 27912, 27913, 7, 5, 0, 0, 27913, 27914, 5, 95, 0, 0, 27914, 27915, 7, 25, 0, 0, 27915, 27916, 7, 24, 0, 0, 27916, 27917, 7, 15, 0, 0, 27917, 27918, 7, 2, 0, 0, 27918, 27919, 7, 11, 0, 0, 27919, 27920, 7, 18, 0, 0, 27920, 27921, 7, 13, 0, 0, 27921, 27922, 7, 11, 0, 0, 27922, 27923, 7, 6, 0, 0, 27923, 4088, 1, 0, 0, 0, 27924, 27925, 7, 5, 0, 0, 27925, 27926, 7, 18, 0, 0, 27926, 27927, 7, 5, 0, 0, 27927, 27928, 5, 95, 0, 0, 27928, 27929, 7, 25, 0, 0, 27929, 27930, 7, 24, 0, 0, 27930, 27931, 7, 15, 0, 0, 27931, 27932, 7, 2, 0, 0, 27932, 27933, 7, 11, 0, 0, 27933, 27934, 7, 18, 0, 0, 27934, 27935, 7, 13, 0, 0, 27935, 27936, 7, 11, 0, 0, 27936, 27937, 7, 4, 0, 0, 27937, 4090, 1, 0, 0, 0, 27938, 27939, 7, 5, 0, 0, 27939, 27940, 7, 18, 0, 0, 27940, 27941, 7, 5, 0, 0, 27941, 27942, 5, 95, 0, 0, 27942, 27943, 7, 25, 0, 0, 27943, 27944, 7, 24, 0, 0, 27944, 27945, 7, 15, 0, 0, 27945, 27946, 7, 2, 0, 0, 27946, 27947, 7, 11, 0, 0, 27947, 27948, 7, 18, 0, 0, 27948, 27949, 7, 13, 0, 0, 27949, 27950, 7, 7, 0, 0, 27950, 27951, 7, 6, 0, 0, 27951, 4092, 1, 0, 0, 0, 27952, 27953, 7, 5, 0, 0, 27953, 27954, 7, 18, 0, 0, 27954, 27955, 7, 5, 0, 0, 27955, 27956, 5, 95, 0, 0, 27956, 27957, 7, 25, 0, 0, 27957, 27958, 7, 24, 0, 0, 27958, 27959, 7, 3, 0, 0, 27959, 27960, 7, 6, 0, 0, 27960, 27961, 7, 16, 0, 0, 27961, 27962, 5, 50, 0, 0, 27962, 27963, 7, 13, 0, 0, 27963, 27964, 7, 0, 0, 0, 27964, 27965, 7, 11, 0, 0, 27965, 4094, 1, 0, 0, 0, 27966, 27967, 7, 5, 0, 0, 27967, 27968, 7, 18, 0, 0, 27968, 27969, 7, 5, 0, 0, 27969, 27970, 5, 95, 0, 0, 27970, 27971, 7, 25, 0, 0, 27971, 27972, 7, 24, 0, 0, 27972, 27973, 7, 3, 0, 0, 27973, 27974, 7, 6, 0, 0, 27974, 27975, 7, 7, 0, 0, 27975, 27976, 7, 0, 0, 0, 27976, 27977, 7, 14, 0, 0, 27977, 27978, 7, 6, 0, 0, 27978, 4096, 1, 0, 0, 0, 27979, 27980, 7, 5, 0, 0, 27980, 27981, 7, 18, 0, 0, 27981, 27982, 7, 5, 0, 0, 27982, 27983, 5, 95, 0, 0, 27983, 27984, 7, 25, 0, 0, 27984, 27985, 7, 24, 0, 0, 27985, 27986, 7, 3, 0, 0, 27986, 27987, 7, 6, 0, 0, 27987, 27988, 7, 15, 0, 0, 27988, 27989, 7, 11, 0, 0, 27989, 27990, 7, 0, 0, 0, 27990, 27991, 7, 8, 0, 0, 27991, 27992, 7, 6, 0, 0, 27992, 4098, 1, 0, 0, 0, 27993, 27994, 7, 5, 0, 0, 27994, 27995, 7, 18, 0, 0, 27995, 27996, 7, 5, 0, 0, 27996, 27997, 5, 95, 0, 0, 27997, 27998, 7, 25, 0, 0, 27998, 27999, 7, 24, 0, 0, 27999, 28000, 7, 3, 0, 0, 28000, 28001, 7, 6, 0, 0, 28001, 28002, 7, 5, 0, 0, 28002, 28003, 7, 13, 0, 0, 28003, 28004, 7, 12, 0, 0, 28004, 28005, 7, 3, 0, 0, 28005, 28006, 7, 10, 0, 0, 28006, 4100, 1, 0, 0, 0, 28007, 28008, 7, 5, 0, 0, 28008, 28009, 7, 18, 0, 0, 28009, 28010, 7, 5, 0, 0, 28010, 28011, 5, 95, 0, 0, 28011, 28012, 7, 25, 0, 0, 28012, 28013, 7, 24, 0, 0, 28013, 28014, 7, 3, 0, 0, 28014, 28015, 7, 7, 0, 0, 28015, 28016, 7, 9, 0, 0, 28016, 28017, 7, 19, 0, 0, 28017, 28018, 7, 0, 0, 0, 28018, 28019, 7, 11, 0, 0, 28019, 28020, 7, 16, 0, 0, 28020, 28021, 5, 50, 0, 0, 28021, 28022, 7, 6, 0, 0, 28022, 28023, 7, 13, 0, 0, 28023, 28024, 7, 7, 0, 0, 28024, 4102, 1, 0, 0, 0, 28025, 28026, 7, 5, 0, 0, 28026, 28027, 7, 18, 0, 0, 28027, 28028, 7, 5, 0, 0, 28028, 28029, 5, 95, 0, 0, 28029, 28030, 7, 25, 0, 0, 28030, 28031, 7, 24, 0, 0, 28031, 28032, 7, 3, 0, 0, 28032, 28033, 7, 5, 0, 0, 28033, 28034, 7, 11, 0, 0, 28034, 28035, 7, 13, 0, 0, 28035, 28036, 7, 24, 0, 0, 28036, 28037, 7, 7, 0, 0, 28037, 28038, 7, 14, 0, 0, 28038, 4104, 1, 0, 0, 0, 28039, 28040, 7, 5, 0, 0, 28040, 28041, 7, 18, 0, 0, 28041, 28042, 7, 5, 0, 0, 28042, 28043, 5, 95, 0, 0, 28043, 28044, 7, 25, 0, 0, 28044, 28045, 7, 24, 0, 0, 28045, 28046, 7, 3, 0, 0, 28046, 28047, 7, 18, 0, 0, 28047, 28048, 7, 6, 0, 0, 28048, 28049, 7, 7, 0, 0, 28049, 28050, 7, 13, 0, 0, 28050, 28051, 7, 15, 0, 0, 28051, 28052, 7, 17, 0, 0, 28052, 28053, 7, 6, 0, 0, 28053, 28054, 7, 4, 0, 0, 28054, 4106, 1, 0, 0, 0, 28055, 28056, 7, 5, 0, 0, 28056, 28057, 7, 18, 0, 0, 28057, 28058, 7, 5, 0, 0, 28058, 28059, 5, 95, 0, 0, 28059, 28060, 7, 25, 0, 0, 28060, 28061, 7, 24, 0, 0, 28061, 28062, 7, 3, 0, 0, 28062, 28063, 7, 18, 0, 0, 28063, 28064, 7, 13, 0, 0, 28064, 28065, 7, 0, 0, 0, 28065, 28066, 7, 3, 0, 0, 28066, 28067, 7, 17, 0, 0, 28067, 28068, 7, 6, 0, 0, 28068, 28069, 7, 4, 0, 0, 28069, 4108, 1, 0, 0, 0, 28070, 28071, 7, 5, 0, 0, 28071, 28072, 7, 18, 0, 0, 28072, 28073, 7, 5, 0, 0, 28073, 28074, 5, 95, 0, 0, 28074, 28075, 7, 25, 0, 0, 28075, 28076, 7, 24, 0, 0, 28076, 28077, 7, 3, 0, 0, 28077, 28078, 7, 18, 0, 0, 28078, 28079, 7, 22, 0, 0, 28079, 28080, 7, 3, 0, 0, 28080, 28081, 7, 15, 0, 0, 28081, 4110, 1, 0, 0, 0, 28082, 28083, 7, 5, 0, 0, 28083, 28084, 7, 18, 0, 0, 28084, 28085, 7, 5, 0, 0, 28085, 28086, 5, 95, 0, 0, 28086, 28087, 7, 25, 0, 0, 28087, 28088, 7, 24, 0, 0, 28088, 28089, 7, 5, 0, 0, 28089, 28090, 7, 6, 0, 0, 28090, 28091, 7, 24, 0, 0, 28091, 28092, 5, 50, 0, 0, 28092, 28093, 7, 8, 0, 0, 28093, 28094, 7, 2, 0, 0, 28094, 28095, 7, 7, 0, 0, 28095, 28096, 5, 52, 0, 0, 28096, 28097, 7, 25, 0, 0, 28097, 28098, 7, 8, 0, 0, 28098, 4112, 1, 0, 0, 0, 28099, 28100, 7, 5, 0, 0, 28100, 28101, 7, 18, 0, 0, 28101, 28102, 7, 5, 0, 0, 28102, 28103, 5, 95, 0, 0, 28103, 28104, 7, 25, 0, 0, 28104, 28105, 7, 24, 0, 0, 28105, 28106, 7, 5, 0, 0, 28106, 28107, 7, 6, 0, 0, 28107, 28108, 7, 24, 0, 0, 28108, 28109, 5, 50, 0, 0, 28109, 28110, 7, 8, 0, 0, 28110, 28111, 7, 2, 0, 0, 28111, 28112, 7, 7, 0, 0, 28112, 4114, 1, 0, 0, 0, 28113, 28114, 7, 5, 0, 0, 28114, 28115, 7, 18, 0, 0, 28115, 28116, 7, 5, 0, 0, 28116, 28117, 5, 95, 0, 0, 28117, 28118, 7, 25, 0, 0, 28118, 28119, 7, 24, 0, 0, 28119, 28120, 7, 5, 0, 0, 28120, 28121, 7, 6, 0, 0, 28121, 28122, 7, 24, 0, 0, 28122, 28123, 7, 9, 0, 0, 28123, 28124, 7, 6, 0, 0, 28124, 28125, 7, 6, 0, 0, 28125, 28126, 7, 15, 0, 0, 28126, 28127, 7, 6, 0, 0, 28127, 28128, 7, 24, 0, 0, 28128, 4116, 1, 0, 0, 0, 28129, 28130, 7, 5, 0, 0, 28130, 28131, 7, 18, 0, 0, 28131, 28132, 7, 5, 0, 0, 28132, 28133, 5, 95, 0, 0, 28133, 28134, 7, 25, 0, 0, 28134, 28135, 7, 24, 0, 0, 28135, 28136, 7, 5, 0, 0, 28136, 28137, 7, 6, 0, 0, 28137, 28138, 7, 24, 0, 0, 28138, 28139, 7, 10, 0, 0, 28139, 28140, 7, 7, 0, 0, 28140, 28141, 7, 5, 0, 0, 28141, 28142, 7, 1, 0, 0, 28142, 4118, 1, 0, 0, 0, 28143, 28144, 7, 5, 0, 0, 28144, 28145, 7, 18, 0, 0, 28145, 28146, 7, 5, 0, 0, 28146, 28147, 5, 95, 0, 0, 28147, 28148, 7, 25, 0, 0, 28148, 28149, 7, 24, 0, 0, 28149, 28150, 7, 5, 0, 0, 28150, 28151, 7, 6, 0, 0, 28151, 28152, 7, 24, 0, 0, 28152, 28153, 7, 3, 0, 0, 28153, 28154, 7, 14, 0, 0, 28154, 4120, 1, 0, 0, 0, 28155, 28156, 7, 5, 0, 0, 28156, 28157, 7, 18, 0, 0, 28157, 28158, 7, 5, 0, 0, 28158, 28159, 5, 95, 0, 0, 28159, 28160, 7, 25, 0, 0, 28160, 28161, 7, 24, 0, 0, 28161, 28162, 7, 5, 0, 0, 28162, 28163, 7, 6, 0, 0, 28163, 28164, 7, 24, 0, 0, 28164, 28165, 7, 3, 0, 0, 28165, 28166, 7, 13, 0, 0, 28166, 28167, 7, 5, 0, 0, 28167, 4122, 1, 0, 0, 0, 28168, 28169, 7, 5, 0, 0, 28169, 28170, 7, 18, 0, 0, 28170, 28171, 7, 5, 0, 0, 28171, 28172, 5, 95, 0, 0, 28172, 28173, 7, 25, 0, 0, 28173, 28174, 7, 24, 0, 0, 28174, 28175, 7, 5, 0, 0, 28175, 28176, 7, 6, 0, 0, 28176, 28177, 7, 24, 0, 0, 28177, 28178, 7, 5, 0, 0, 28178, 28179, 7, 12, 0, 0, 28179, 28180, 7, 1, 0, 0, 28180, 4124, 1, 0, 0, 0, 28181, 28182, 7, 5, 0, 0, 28182, 28183, 7, 18, 0, 0, 28183, 28184, 7, 5, 0, 0, 28184, 28185, 5, 95, 0, 0, 28185, 28186, 7, 25, 0, 0, 28186, 28187, 7, 24, 0, 0, 28187, 28188, 7, 5, 0, 0, 28188, 28189, 7, 6, 0, 0, 28189, 28190, 7, 24, 0, 0, 28190, 28191, 7, 4, 0, 0, 28191, 28192, 7, 18, 0, 0, 28192, 28193, 7, 15, 0, 0, 28193, 28194, 7, 14, 0, 0, 28194, 28195, 7, 0, 0, 0, 28195, 28196, 7, 4, 0, 0, 28196, 28197, 7, 8, 0, 0, 28197, 28198, 7, 19, 0, 0, 28198, 4126, 1, 0, 0, 0, 28199, 28200, 7, 5, 0, 0, 28200, 28201, 7, 18, 0, 0, 28201, 28202, 7, 5, 0, 0, 28202, 28203, 5, 95, 0, 0, 28203, 28204, 7, 25, 0, 0, 28204, 28205, 7, 24, 0, 0, 28205, 28206, 7, 5, 0, 0, 28206, 28207, 7, 4, 0, 0, 28207, 28208, 7, 0, 0, 0, 28208, 28209, 7, 3, 0, 0, 28209, 28210, 7, 4, 0, 0, 28210, 28211, 7, 5, 0, 0, 28211, 28212, 7, 22, 0, 0, 28212, 28213, 7, 10, 0, 0, 28213, 28214, 7, 4, 0, 0, 28214, 28215, 7, 19, 0, 0, 28215, 4128, 1, 0, 0, 0, 28216, 28217, 7, 5, 0, 0, 28217, 28218, 7, 18, 0, 0, 28218, 28219, 7, 5, 0, 0, 28219, 28220, 5, 95, 0, 0, 28220, 28221, 7, 25, 0, 0, 28221, 28222, 7, 24, 0, 0, 28222, 28223, 7, 5, 0, 0, 28223, 28224, 7, 4, 0, 0, 28224, 28225, 7, 0, 0, 0, 28225, 28226, 7, 4, 0, 0, 28226, 28227, 7, 1, 0, 0, 28227, 28228, 7, 12, 0, 0, 28228, 28229, 7, 3, 0, 0, 28229, 28230, 7, 10, 0, 0, 28230, 4130, 1, 0, 0, 0, 28231, 28232, 7, 5, 0, 0, 28232, 28233, 7, 18, 0, 0, 28233, 28234, 7, 5, 0, 0, 28234, 28235, 5, 95, 0, 0, 28235, 28236, 7, 25, 0, 0, 28236, 28237, 7, 24, 0, 0, 28237, 28238, 7, 5, 0, 0, 28238, 28239, 7, 4, 0, 0, 28239, 28240, 7, 3, 0, 0, 28240, 28241, 5, 50, 0, 0, 28241, 28242, 7, 8, 0, 0, 28242, 28243, 7, 2, 0, 0, 28243, 28244, 7, 9, 0, 0, 28244, 28245, 7, 6, 0, 0, 28245, 28246, 7, 15, 0, 0, 28246, 4132, 1, 0, 0, 0, 28247, 28248, 7, 5, 0, 0, 28248, 28249, 7, 18, 0, 0, 28249, 28250, 7, 5, 0, 0, 28250, 28251, 5, 95, 0, 0, 28251, 28252, 7, 25, 0, 0, 28252, 28253, 7, 24, 0, 0, 28253, 28254, 7, 5, 0, 0, 28254, 28255, 7, 4, 0, 0, 28255, 28256, 7, 3, 0, 0, 28256, 28257, 7, 20, 0, 0, 28257, 28258, 7, 2, 0, 0, 28258, 28259, 7, 10, 0, 0, 28259, 28260, 7, 7, 0, 0, 28260, 4134, 1, 0, 0, 0, 28261, 28262, 7, 5, 0, 0, 28262, 28263, 7, 18, 0, 0, 28263, 28264, 7, 5, 0, 0, 28264, 28265, 5, 95, 0, 0, 28265, 28266, 7, 25, 0, 0, 28266, 28267, 7, 24, 0, 0, 28267, 28268, 7, 5, 0, 0, 28268, 28269, 7, 12, 0, 0, 28269, 28270, 7, 1, 0, 0, 28270, 28271, 7, 5, 0, 0, 28271, 28272, 7, 4, 0, 0, 28272, 28273, 7, 3, 0, 0, 28273, 28274, 7, 0, 0, 0, 28274, 28275, 7, 16, 0, 0, 28275, 28276, 7, 4, 0, 0, 28276, 4136, 1, 0, 0, 0, 28277, 28278, 7, 5, 0, 0, 28278, 28279, 7, 18, 0, 0, 28279, 28280, 7, 5, 0, 0, 28280, 28281, 5, 95, 0, 0, 28281, 28282, 7, 25, 0, 0, 28282, 28283, 7, 24, 0, 0, 28283, 28284, 7, 5, 0, 0, 28284, 28285, 7, 12, 0, 0, 28285, 28286, 7, 1, 0, 0, 28286, 28287, 7, 5, 0, 0, 28287, 28288, 7, 4, 0, 0, 28288, 28289, 7, 3, 0, 0, 28289, 28290, 7, 1, 0, 0, 28290, 28291, 7, 6, 0, 0, 28291, 28292, 7, 16, 0, 0, 28292, 4138, 1, 0, 0, 0, 28293, 28294, 7, 5, 0, 0, 28294, 28295, 7, 18, 0, 0, 28295, 28296, 7, 5, 0, 0, 28296, 28297, 5, 95, 0, 0, 28297, 28298, 7, 25, 0, 0, 28298, 28299, 7, 24, 0, 0, 28299, 28300, 7, 4, 0, 0, 28300, 28301, 7, 2, 0, 0, 28301, 28302, 7, 21, 0, 0, 28302, 28303, 7, 6, 0, 0, 28303, 28304, 7, 7, 0, 0, 28304, 28305, 7, 10, 0, 0, 28305, 28306, 7, 23, 0, 0, 28306, 28307, 7, 6, 0, 0, 28307, 4140, 1, 0, 0, 0, 28308, 28309, 7, 5, 0, 0, 28309, 28310, 7, 18, 0, 0, 28310, 28311, 7, 5, 0, 0, 28311, 28312, 5, 95, 0, 0, 28312, 28313, 7, 25, 0, 0, 28313, 28314, 7, 24, 0, 0, 28314, 28315, 7, 4, 0, 0, 28315, 28316, 7, 3, 0, 0, 28316, 28317, 7, 6, 0, 0, 28317, 28318, 7, 0, 0, 0, 28318, 28319, 7, 4, 0, 0, 28319, 28320, 7, 0, 0, 0, 28320, 28321, 7, 5, 0, 0, 28321, 4142, 1, 0, 0, 0, 28322, 28323, 7, 5, 0, 0, 28323, 28324, 7, 18, 0, 0, 28324, 28325, 7, 5, 0, 0, 28325, 28326, 5, 95, 0, 0, 28326, 28327, 7, 25, 0, 0, 28327, 28328, 7, 24, 0, 0, 28328, 28329, 5, 95, 0, 0, 28329, 28330, 7, 12, 0, 0, 28330, 28331, 7, 15, 0, 0, 28331, 28332, 7, 21, 0, 0, 28332, 28333, 7, 25, 0, 0, 28333, 28334, 7, 14, 0, 0, 28334, 28335, 7, 11, 0, 0, 28335, 28336, 5, 50, 0, 0, 28336, 28337, 7, 5, 0, 0, 28337, 28338, 7, 24, 0, 0, 28338, 28339, 7, 11, 0, 0, 28339, 4144, 1, 0, 0, 0, 28340, 28341, 7, 5, 0, 0, 28341, 28342, 7, 18, 0, 0, 28342, 28343, 7, 5, 0, 0, 28343, 28344, 5, 95, 0, 0, 28344, 28345, 7, 25, 0, 0, 28345, 28346, 7, 24, 0, 0, 28346, 28347, 7, 25, 0, 0, 28347, 28348, 7, 16, 0, 0, 28348, 28349, 7, 2, 0, 0, 28349, 28350, 7, 3, 0, 0, 28350, 28351, 7, 14, 0, 0, 28351, 4146, 1, 0, 0, 0, 28352, 28353, 7, 5, 0, 0, 28353, 28354, 7, 18, 0, 0, 28354, 28355, 7, 5, 0, 0, 28355, 28356, 5, 95, 0, 0, 28356, 28357, 7, 25, 0, 0, 28357, 28358, 7, 5, 0, 0, 28358, 28359, 7, 10, 0, 0, 28359, 28360, 7, 9, 0, 0, 28360, 28361, 5, 95, 0, 0, 28361, 28362, 7, 4, 0, 0, 28362, 28363, 7, 2, 0, 0, 28363, 28364, 5, 95, 0, 0, 28364, 28365, 7, 3, 0, 0, 28365, 28366, 7, 0, 0, 0, 28366, 28367, 7, 22, 0, 0, 28367, 4148, 1, 0, 0, 0, 28368, 28369, 7, 5, 0, 0, 28369, 28370, 7, 18, 0, 0, 28370, 28371, 7, 5, 0, 0, 28371, 28372, 5, 95, 0, 0, 28372, 28373, 7, 23, 0, 0, 28373, 28374, 7, 14, 0, 0, 28374, 28375, 7, 0, 0, 0, 28375, 28376, 7, 15, 0, 0, 28376, 28377, 5, 95, 0, 0, 28377, 28378, 7, 16, 0, 0, 28378, 28379, 7, 10, 0, 0, 28379, 28380, 7, 11, 0, 0, 28380, 28381, 7, 4, 0, 0, 28381, 28382, 7, 6, 0, 0, 28382, 28383, 7, 3, 0, 0, 28383, 4150, 1, 0, 0, 0, 28384, 28385, 7, 5, 0, 0, 28385, 28386, 7, 18, 0, 0, 28386, 28387, 7, 5, 0, 0, 28387, 28388, 5, 95, 0, 0, 28388, 28389, 7, 23, 0, 0, 28389, 28390, 7, 14, 0, 0, 28390, 28391, 7, 0, 0, 0, 28391, 28392, 7, 15, 0, 0, 28392, 28393, 5, 95, 0, 0, 28393, 28394, 7, 3, 0, 0, 28394, 28395, 7, 6, 0, 0, 28395, 28396, 7, 16, 0, 0, 28396, 28397, 7, 3, 0, 0, 28397, 28398, 7, 6, 0, 0, 28398, 28399, 7, 5, 0, 0, 28399, 28400, 7, 19, 0, 0, 28400, 4152, 1, 0, 0, 0, 28401, 28402, 7, 4, 0, 0, 28402, 4154, 1, 0, 0, 0, 28403, 28404, 7, 4, 0, 0, 28404, 28405, 7, 0, 0, 0, 28405, 28406, 7, 1, 0, 0, 28406, 28407, 7, 11, 0, 0, 28407, 28408, 7, 6, 0, 0, 28408, 28409, 5, 95, 0, 0, 28409, 28410, 7, 11, 0, 0, 28410, 28411, 7, 2, 0, 0, 28411, 28412, 7, 2, 0, 0, 28412, 28413, 7, 21, 0, 0, 28413, 28414, 7, 12, 0, 0, 28414, 28415, 7, 15, 0, 0, 28415, 28416, 5, 95, 0, 0, 28416, 28417, 7, 1, 0, 0, 28417, 28418, 7, 18, 0, 0, 28418, 28419, 5, 95, 0, 0, 28419, 28420, 7, 7, 0, 0, 28420, 28421, 7, 11, 0, 0, 28421, 4156, 1, 0, 0, 0, 28422, 28423, 7, 4, 0, 0, 28423, 28424, 7, 0, 0, 0, 28424, 28425, 7, 1, 0, 0, 28425, 28426, 7, 11, 0, 0, 28426, 28427, 7, 6, 0, 0, 28427, 28428, 7, 5, 0, 0, 28428, 28429, 7, 15, 0, 0, 28429, 28430, 7, 0, 0, 0, 28430, 28431, 7, 8, 0, 0, 28431, 28432, 7, 6, 0, 0, 28432, 28433, 5, 95, 0, 0, 28433, 28434, 7, 7, 0, 0, 28434, 28435, 7, 2, 0, 0, 28435, 4158, 1, 0, 0, 0, 28436, 28437, 7, 4, 0, 0, 28437, 28438, 7, 0, 0, 0, 28438, 28439, 7, 1, 0, 0, 28439, 28440, 7, 11, 0, 0, 28440, 28441, 7, 6, 0, 0, 28441, 28442, 7, 5, 0, 0, 28442, 28443, 7, 15, 0, 0, 28443, 28444, 7, 0, 0, 0, 28444, 28445, 7, 8, 0, 0, 28445, 28446, 7, 6, 0, 0, 28446, 4160, 1, 0, 0, 0, 28447, 28448, 7, 4, 0, 0, 28448, 28449, 7, 0, 0, 0, 28449, 28450, 7, 1, 0, 0, 28450, 28451, 7, 11, 0, 0, 28451, 28452, 7, 6, 0, 0, 28452, 28453, 7, 5, 0, 0, 28453, 4162, 1, 0, 0, 0, 28454, 28455, 7, 4, 0, 0, 28455, 28456, 7, 0, 0, 0, 28456, 28457, 7, 1, 0, 0, 28457, 28458, 7, 11, 0, 0, 28458, 28459, 7, 6, 0, 0, 28459, 28460, 5, 95, 0, 0, 28460, 28461, 7, 5, 0, 0, 28461, 28462, 7, 4, 0, 0, 28462, 28463, 7, 0, 0, 0, 28463, 28464, 7, 4, 0, 0, 28464, 28465, 7, 5, 0, 0, 28465, 4164, 1, 0, 0, 0, 28466, 28467, 7, 4, 0, 0, 28467, 28468, 7, 0, 0, 0, 28468, 28469, 7, 1, 0, 0, 28469, 28470, 7, 11, 0, 0, 28470, 28471, 7, 6, 0, 0, 28471, 4166, 1, 0, 0, 0, 28472, 28473, 7, 4, 0, 0, 28473, 28474, 7, 0, 0, 0, 28474, 28475, 7, 1, 0, 0, 28475, 28476, 7, 7, 0, 0, 28476, 28477, 7, 2, 0, 0, 28477, 4168, 1, 0, 0, 0, 28478, 28479, 7, 4, 0, 0, 28479, 28480, 7, 0, 0, 0, 28480, 28481, 7, 17, 0, 0, 28481, 4170, 1, 0, 0, 0, 28482, 28483, 7, 4, 0, 0, 28483, 28484, 7, 0, 0, 0, 28484, 28485, 7, 7, 0, 0, 28485, 28486, 7, 19, 0, 0, 28486, 4172, 1, 0, 0, 0, 28487, 28488, 7, 4, 0, 0, 28488, 28489, 7, 0, 0, 0, 28489, 28490, 7, 7, 0, 0, 28490, 4174, 1, 0, 0, 0, 28491, 28492, 7, 4, 0, 0, 28492, 28493, 7, 1, 0, 0, 28493, 28494, 7, 11, 0, 0, 28494, 28495, 5, 36, 0, 0, 28495, 28496, 7, 2, 0, 0, 28496, 28497, 7, 3, 0, 0, 28497, 28498, 5, 36, 0, 0, 28498, 28499, 7, 10, 0, 0, 28499, 28500, 7, 9, 0, 0, 28500, 28501, 7, 25, 0, 0, 28501, 28502, 5, 36, 0, 0, 28502, 28503, 7, 15, 0, 0, 28503, 28504, 7, 0, 0, 0, 28504, 28505, 7, 3, 0, 0, 28505, 28506, 7, 4, 0, 0, 28506, 28507, 5, 36, 0, 0, 28507, 28508, 7, 7, 0, 0, 28508, 28509, 7, 12, 0, 0, 28509, 28510, 7, 14, 0, 0, 28510, 4176, 1, 0, 0, 0, 28511, 28512, 7, 4, 0, 0, 28512, 28513, 7, 6, 0, 0, 28513, 28514, 7, 14, 0, 0, 28514, 28515, 7, 15, 0, 0, 28515, 28516, 7, 16, 0, 0, 28516, 28517, 7, 10, 0, 0, 28517, 28518, 7, 11, 0, 0, 28518, 28519, 7, 6, 0, 0, 28519, 4178, 1, 0, 0, 0, 28520, 28521, 7, 4, 0, 0, 28521, 28522, 7, 6, 0, 0, 28522, 28523, 7, 14, 0, 0, 28523, 28524, 7, 15, 0, 0, 28524, 28525, 7, 11, 0, 0, 28525, 28526, 7, 0, 0, 0, 28526, 28527, 7, 4, 0, 0, 28527, 28528, 7, 6, 0, 0, 28528, 4180, 1, 0, 0, 0, 28529, 28530, 7, 4, 0, 0, 28530, 28531, 7, 6, 0, 0, 28531, 28532, 7, 14, 0, 0, 28532, 28533, 7, 15, 0, 0, 28533, 28534, 7, 11, 0, 0, 28534, 28535, 7, 0, 0, 0, 28535, 28536, 7, 4, 0, 0, 28536, 28537, 7, 6, 0, 0, 28537, 28538, 5, 95, 0, 0, 28538, 28539, 7, 4, 0, 0, 28539, 28540, 7, 0, 0, 0, 28540, 28541, 7, 1, 0, 0, 28541, 28542, 7, 11, 0, 0, 28542, 28543, 7, 6, 0, 0, 28543, 4182, 1, 0, 0, 0, 28544, 28545, 7, 4, 0, 0, 28545, 28546, 7, 6, 0, 0, 28546, 28547, 7, 14, 0, 0, 28547, 28548, 7, 15, 0, 0, 28548, 28549, 7, 2, 0, 0, 28549, 28550, 7, 3, 0, 0, 28550, 28551, 7, 0, 0, 0, 28551, 28552, 7, 3, 0, 0, 28552, 28553, 7, 18, 0, 0, 28553, 4184, 1, 0, 0, 0, 28554, 28555, 7, 4, 0, 0, 28555, 28556, 7, 6, 0, 0, 28556, 28557, 7, 14, 0, 0, 28557, 28558, 7, 15, 0, 0, 28558, 28559, 5, 95, 0, 0, 28559, 28560, 7, 4, 0, 0, 28560, 28561, 7, 0, 0, 0, 28561, 28562, 7, 1, 0, 0, 28562, 28563, 7, 11, 0, 0, 28563, 28564, 7, 6, 0, 0, 28564, 4186, 1, 0, 0, 0, 28565, 28566, 7, 4, 0, 0, 28566, 28567, 7, 6, 0, 0, 28567, 28568, 7, 3, 0, 0, 28568, 28569, 7, 14, 0, 0, 28569, 28570, 7, 10, 0, 0, 28570, 28571, 7, 7, 0, 0, 28571, 28572, 7, 0, 0, 0, 28572, 28573, 7, 4, 0, 0, 28573, 28574, 7, 6, 0, 0, 28574, 28575, 7, 9, 0, 0, 28575, 4188, 1, 0, 0, 0, 28576, 28577, 7, 4, 0, 0, 28577, 28578, 7, 6, 0, 0, 28578, 28579, 7, 5, 0, 0, 28579, 28580, 7, 4, 0, 0, 28580, 4190, 1, 0, 0, 0, 28581, 28582, 7, 4, 0, 0, 28582, 28583, 7, 6, 0, 0, 28583, 28584, 7, 25, 0, 0, 28584, 28585, 7, 4, 0, 0, 28585, 4192, 1, 0, 0, 0, 28586, 28587, 7, 4, 0, 0, 28587, 28588, 7, 6, 0, 0, 28588, 28589, 7, 25, 0, 0, 28589, 28590, 7, 4, 0, 0, 28590, 28591, 7, 16, 0, 0, 28591, 28592, 7, 10, 0, 0, 28592, 28593, 7, 11, 0, 0, 28593, 28594, 7, 6, 0, 0, 28594, 4194, 1, 0, 0, 0, 28595, 28596, 7, 4, 0, 0, 28596, 28597, 7, 19, 0, 0, 28597, 28598, 7, 0, 0, 0, 28598, 28599, 7, 7, 0, 0, 28599, 4196, 1, 0, 0, 0, 28600, 28601, 7, 4, 0, 0, 28601, 28602, 7, 19, 0, 0, 28602, 28603, 7, 6, 0, 0, 28603, 28604, 7, 7, 0, 0, 28604, 4198, 1, 0, 0, 0, 28605, 28606, 7, 4, 0, 0, 28606, 28607, 7, 19, 0, 0, 28607, 28608, 7, 6, 0, 0, 28608, 4200, 1, 0, 0, 0, 28609, 28610, 7, 4, 0, 0, 28610, 28611, 7, 19, 0, 0, 28611, 28612, 7, 6, 0, 0, 28612, 28613, 7, 5, 0, 0, 28613, 28614, 7, 6, 0, 0, 28614, 4202, 1, 0, 0, 0, 28615, 28616, 7, 4, 0, 0, 28616, 28617, 7, 19, 0, 0, 28617, 28618, 7, 3, 0, 0, 28618, 28619, 7, 6, 0, 0, 28619, 28620, 7, 0, 0, 0, 28620, 28621, 7, 9, 0, 0, 28621, 4204, 1, 0, 0, 0, 28622, 28623, 7, 4, 0, 0, 28623, 28624, 7, 19, 0, 0, 28624, 28625, 7, 3, 0, 0, 28625, 28626, 7, 2, 0, 0, 28626, 28627, 7, 12, 0, 0, 28627, 28628, 7, 17, 0, 0, 28628, 28629, 7, 19, 0, 0, 28629, 4206, 1, 0, 0, 0, 28630, 28631, 7, 4, 0, 0, 28631, 28632, 7, 10, 0, 0, 28632, 28633, 7, 6, 0, 0, 28633, 28634, 7, 3, 0, 0, 28634, 4208, 1, 0, 0, 0, 28635, 28636, 7, 4, 0, 0, 28636, 28637, 7, 10, 0, 0, 28637, 28638, 7, 6, 0, 0, 28638, 28639, 7, 5, 0, 0, 28639, 4210, 1, 0, 0, 0, 28640, 28641, 7, 4, 0, 0, 28641, 28642, 7, 10, 0, 0, 28642, 28643, 7, 14, 0, 0, 28643, 28644, 7, 6, 0, 0, 28644, 28645, 7, 2, 0, 0, 28645, 28646, 7, 12, 0, 0, 28646, 28647, 7, 4, 0, 0, 28647, 4212, 1, 0, 0, 0, 28648, 28649, 7, 4, 0, 0, 28649, 28650, 7, 10, 0, 0, 28650, 28651, 7, 14, 0, 0, 28651, 28652, 7, 6, 0, 0, 28652, 28653, 7, 5, 0, 0, 28653, 28654, 7, 4, 0, 0, 28654, 28655, 7, 0, 0, 0, 28655, 28656, 7, 14, 0, 0, 28656, 28657, 7, 15, 0, 0, 28657, 28658, 5, 95, 0, 0, 28658, 28659, 7, 11, 0, 0, 28659, 28660, 7, 4, 0, 0, 28660, 28661, 7, 23, 0, 0, 28661, 28662, 5, 95, 0, 0, 28662, 28663, 7, 12, 0, 0, 28663, 28664, 7, 7, 0, 0, 28664, 28665, 7, 8, 0, 0, 28665, 28666, 7, 2, 0, 0, 28666, 28667, 7, 7, 0, 0, 28667, 28668, 7, 5, 0, 0, 28668, 28669, 7, 4, 0, 0, 28669, 28670, 7, 3, 0, 0, 28670, 28671, 7, 0, 0, 0, 28671, 28672, 7, 10, 0, 0, 28672, 28673, 7, 7, 0, 0, 28673, 28674, 7, 6, 0, 0, 28674, 28675, 7, 9, 0, 0, 28675, 4214, 1, 0, 0, 0, 28676, 28677, 7, 4, 0, 0, 28677, 28678, 7, 10, 0, 0, 28678, 28679, 7, 14, 0, 0, 28679, 28680, 7, 6, 0, 0, 28680, 28681, 7, 5, 0, 0, 28681, 28682, 7, 4, 0, 0, 28682, 28683, 7, 0, 0, 0, 28683, 28684, 7, 14, 0, 0, 28684, 28685, 7, 15, 0, 0, 28685, 4216, 1, 0, 0, 0, 28686, 28687, 7, 4, 0, 0, 28687, 28688, 7, 10, 0, 0, 28688, 28689, 7, 14, 0, 0, 28689, 28690, 7, 6, 0, 0, 28690, 28691, 7, 5, 0, 0, 28691, 28692, 7, 4, 0, 0, 28692, 28693, 7, 0, 0, 0, 28693, 28694, 7, 14, 0, 0, 28694, 28695, 7, 15, 0, 0, 28695, 28696, 5, 95, 0, 0, 28696, 28697, 7, 4, 0, 0, 28697, 28698, 7, 23, 0, 0, 28698, 28699, 5, 95, 0, 0, 28699, 28700, 7, 12, 0, 0, 28700, 28701, 7, 7, 0, 0, 28701, 28702, 7, 8, 0, 0, 28702, 28703, 7, 2, 0, 0, 28703, 28704, 7, 7, 0, 0, 28704, 28705, 7, 5, 0, 0, 28705, 28706, 7, 4, 0, 0, 28706, 28707, 7, 3, 0, 0, 28707, 28708, 7, 0, 0, 0, 28708, 28709, 7, 10, 0, 0, 28709, 28710, 7, 7, 0, 0, 28710, 28711, 7, 6, 0, 0, 28711, 28712, 7, 9, 0, 0, 28712, 4218, 1, 0, 0, 0, 28713, 28714, 7, 4, 0, 0, 28714, 28715, 7, 10, 0, 0, 28715, 28716, 7, 14, 0, 0, 28716, 28717, 7, 6, 0, 0, 28717, 28718, 7, 5, 0, 0, 28718, 28719, 7, 4, 0, 0, 28719, 28720, 7, 0, 0, 0, 28720, 28721, 7, 14, 0, 0, 28721, 28722, 7, 15, 0, 0, 28722, 28723, 5, 95, 0, 0, 28723, 28724, 7, 12, 0, 0, 28724, 28725, 7, 7, 0, 0, 28725, 28726, 7, 8, 0, 0, 28726, 28727, 7, 2, 0, 0, 28727, 28728, 7, 7, 0, 0, 28728, 28729, 7, 5, 0, 0, 28729, 28730, 7, 4, 0, 0, 28730, 28731, 7, 3, 0, 0, 28731, 28732, 7, 0, 0, 0, 28732, 28733, 7, 10, 0, 0, 28733, 28734, 7, 7, 0, 0, 28734, 28735, 7, 6, 0, 0, 28735, 28736, 7, 9, 0, 0, 28736, 4220, 1, 0, 0, 0, 28737, 28738, 7, 4, 0, 0, 28738, 28739, 7, 10, 0, 0, 28739, 28740, 7, 14, 0, 0, 28740, 28741, 7, 6, 0, 0, 28741, 28742, 7, 5, 0, 0, 28742, 4222, 1, 0, 0, 0, 28743, 28744, 7, 4, 0, 0, 28744, 28745, 7, 10, 0, 0, 28745, 28746, 7, 14, 0, 0, 28746, 28747, 7, 6, 0, 0, 28747, 4224, 1, 0, 0, 0, 28748, 28749, 7, 4, 0, 0, 28749, 28750, 7, 10, 0, 0, 28750, 28751, 7, 14, 0, 0, 28751, 28752, 7, 6, 0, 0, 28752, 28753, 7, 23, 0, 0, 28753, 28754, 7, 2, 0, 0, 28754, 28755, 7, 7, 0, 0, 28755, 28756, 7, 6, 0, 0, 28756, 4226, 1, 0, 0, 0, 28757, 28758, 7, 4, 0, 0, 28758, 28759, 7, 10, 0, 0, 28759, 28760, 7, 14, 0, 0, 28760, 28761, 7, 6, 0, 0, 28761, 28762, 7, 23, 0, 0, 28762, 28763, 7, 2, 0, 0, 28763, 28764, 7, 7, 0, 0, 28764, 28765, 7, 6, 0, 0, 28765, 28766, 5, 95, 0, 0, 28766, 28767, 7, 0, 0, 0, 28767, 28768, 7, 1, 0, 0, 28768, 28769, 7, 1, 0, 0, 28769, 28770, 7, 3, 0, 0, 28770, 4228, 1, 0, 0, 0, 28771, 28772, 7, 4, 0, 0, 28772, 28773, 7, 10, 0, 0, 28773, 28774, 7, 14, 0, 0, 28774, 28775, 7, 6, 0, 0, 28775, 28776, 7, 23, 0, 0, 28776, 28777, 7, 2, 0, 0, 28777, 28778, 7, 7, 0, 0, 28778, 28779, 7, 6, 0, 0, 28779, 28780, 5, 95, 0, 0, 28780, 28781, 7, 19, 0, 0, 28781, 28782, 7, 2, 0, 0, 28782, 28783, 7, 12, 0, 0, 28783, 28784, 7, 3, 0, 0, 28784, 4230, 1, 0, 0, 0, 28785, 28786, 7, 4, 0, 0, 28786, 28787, 7, 10, 0, 0, 28787, 28788, 7, 14, 0, 0, 28788, 28789, 7, 6, 0, 0, 28789, 28790, 7, 23, 0, 0, 28790, 28791, 7, 2, 0, 0, 28791, 28792, 7, 7, 0, 0, 28792, 28793, 7, 6, 0, 0, 28793, 28794, 5, 95, 0, 0, 28794, 28795, 7, 14, 0, 0, 28795, 28796, 7, 10, 0, 0, 28796, 28797, 7, 7, 0, 0, 28797, 28798, 7, 12, 0, 0, 28798, 28799, 7, 4, 0, 0, 28799, 28800, 7, 6, 0, 0, 28800, 4232, 1, 0, 0, 0, 28801, 28802, 7, 4, 0, 0, 28802, 28803, 7, 10, 0, 0, 28803, 28804, 7, 14, 0, 0, 28804, 28805, 7, 6, 0, 0, 28805, 28806, 7, 23, 0, 0, 28806, 28807, 7, 2, 0, 0, 28807, 28808, 7, 7, 0, 0, 28808, 28809, 7, 6, 0, 0, 28809, 28810, 5, 95, 0, 0, 28810, 28811, 7, 2, 0, 0, 28811, 28812, 7, 16, 0, 0, 28812, 28813, 7, 16, 0, 0, 28813, 28814, 7, 5, 0, 0, 28814, 28815, 7, 6, 0, 0, 28815, 28816, 7, 4, 0, 0, 28816, 4234, 1, 0, 0, 0, 28817, 28818, 7, 4, 0, 0, 28818, 28819, 7, 10, 0, 0, 28819, 28820, 7, 14, 0, 0, 28820, 28821, 7, 6, 0, 0, 28821, 28822, 7, 23, 0, 0, 28822, 28823, 7, 2, 0, 0, 28823, 28824, 7, 7, 0, 0, 28824, 28825, 7, 6, 0, 0, 28825, 28826, 5, 95, 0, 0, 28826, 28827, 7, 3, 0, 0, 28827, 28828, 7, 6, 0, 0, 28828, 28829, 7, 17, 0, 0, 28829, 28830, 7, 10, 0, 0, 28830, 28831, 7, 2, 0, 0, 28831, 28832, 7, 7, 0, 0, 28832, 4236, 1, 0, 0, 0, 28833, 28834, 7, 4, 0, 0, 28834, 28835, 7, 10, 0, 0, 28835, 28836, 7, 14, 0, 0, 28836, 28837, 7, 6, 0, 0, 28837, 28838, 5, 95, 0, 0, 28838, 28839, 7, 23, 0, 0, 28839, 28840, 7, 2, 0, 0, 28840, 28841, 7, 7, 0, 0, 28841, 28842, 7, 6, 0, 0, 28842, 4238, 1, 0, 0, 0, 28843, 28844, 7, 4, 0, 0, 28844, 28845, 7, 10, 0, 0, 28845, 28846, 7, 14, 0, 0, 28846, 28847, 7, 10, 0, 0, 28847, 28848, 7, 7, 0, 0, 28848, 28849, 7, 17, 0, 0, 28849, 4240, 1, 0, 0, 0, 28850, 28851, 7, 4, 0, 0, 28851, 28852, 7, 10, 0, 0, 28852, 28853, 7, 7, 0, 0, 28853, 28854, 7, 18, 0, 0, 28854, 28855, 7, 10, 0, 0, 28855, 28856, 7, 7, 0, 0, 28856, 28857, 7, 4, 0, 0, 28857, 4242, 1, 0, 0, 0, 28858, 28859, 7, 4, 0, 0, 28859, 28860, 7, 10, 0, 0, 28860, 28861, 7, 13, 0, 0, 28861, 28862, 5, 95, 0, 0, 28862, 28863, 7, 17, 0, 0, 28863, 28864, 7, 1, 0, 0, 28864, 4244, 1, 0, 0, 0, 28865, 28866, 7, 4, 0, 0, 28866, 28867, 7, 10, 0, 0, 28867, 28868, 7, 13, 0, 0, 28868, 28869, 5, 95, 0, 0, 28869, 28870, 7, 5, 0, 0, 28870, 28871, 7, 5, 0, 0, 28871, 28872, 7, 16, 0, 0, 28872, 4246, 1, 0, 0, 0, 28873, 28874, 7, 4, 0, 0, 28874, 28875, 7, 2, 0, 0, 28875, 28876, 5, 95, 0, 0, 28876, 28877, 7, 0, 0, 0, 28877, 28878, 7, 8, 0, 0, 28878, 28879, 7, 11, 0, 0, 28879, 28880, 7, 10, 0, 0, 28880, 28881, 7, 9, 0, 0, 28881, 4248, 1, 0, 0, 0, 28882, 28883, 7, 4, 0, 0, 28883, 28884, 7, 2, 0, 0, 28884, 28885, 5, 95, 0, 0, 28885, 28886, 7, 1, 0, 0, 28886, 28887, 7, 10, 0, 0, 28887, 28888, 7, 7, 0, 0, 28888, 28889, 7, 0, 0, 0, 28889, 28890, 7, 3, 0, 0, 28890, 28891, 7, 18, 0, 0, 28891, 28892, 5, 95, 0, 0, 28892, 28893, 7, 9, 0, 0, 28893, 28894, 7, 2, 0, 0, 28894, 28895, 7, 12, 0, 0, 28895, 28896, 7, 1, 0, 0, 28896, 28897, 7, 11, 0, 0, 28897, 28898, 7, 6, 0, 0, 28898, 4250, 1, 0, 0, 0, 28899, 28900, 7, 4, 0, 0, 28900, 28901, 7, 2, 0, 0, 28901, 28902, 5, 95, 0, 0, 28902, 28903, 7, 1, 0, 0, 28903, 28904, 7, 10, 0, 0, 28904, 28905, 7, 7, 0, 0, 28905, 28906, 7, 0, 0, 0, 28906, 28907, 7, 3, 0, 0, 28907, 28908, 7, 18, 0, 0, 28908, 28909, 5, 95, 0, 0, 28909, 28910, 7, 16, 0, 0, 28910, 28911, 7, 11, 0, 0, 28911, 28912, 7, 2, 0, 0, 28912, 28913, 7, 0, 0, 0, 28913, 28914, 7, 4, 0, 0, 28914, 4252, 1, 0, 0, 0, 28915, 28916, 7, 4, 0, 0, 28916, 28917, 7, 2, 0, 0, 28917, 28918, 5, 95, 0, 0, 28918, 28919, 7, 1, 0, 0, 28919, 28920, 7, 11, 0, 0, 28920, 28921, 7, 2, 0, 0, 28921, 28922, 7, 1, 0, 0, 28922, 4254, 1, 0, 0, 0, 28923, 28924, 7, 4, 0, 0, 28924, 28925, 7, 2, 0, 0, 28925, 28926, 5, 95, 0, 0, 28926, 28927, 7, 8, 0, 0, 28927, 28928, 7, 11, 0, 0, 28928, 28929, 7, 2, 0, 0, 28929, 28930, 7, 1, 0, 0, 28930, 4256, 1, 0, 0, 0, 28931, 28932, 7, 4, 0, 0, 28932, 28933, 7, 2, 0, 0, 28933, 28934, 5, 95, 0, 0, 28934, 28935, 7, 9, 0, 0, 28935, 28936, 7, 5, 0, 0, 28936, 28937, 7, 10, 0, 0, 28937, 28938, 7, 7, 0, 0, 28938, 28939, 7, 4, 0, 0, 28939, 28940, 7, 6, 0, 0, 28940, 28941, 7, 3, 0, 0, 28941, 28942, 7, 13, 0, 0, 28942, 28943, 7, 0, 0, 0, 28943, 28944, 7, 11, 0, 0, 28944, 4258, 1, 0, 0, 0, 28945, 28946, 7, 4, 0, 0, 28946, 28947, 7, 2, 0, 0, 28947, 28948, 5, 95, 0, 0, 28948, 28949, 7, 11, 0, 0, 28949, 28950, 7, 2, 0, 0, 28950, 28951, 7, 1, 0, 0, 28951, 4260, 1, 0, 0, 0, 28952, 28953, 7, 4, 0, 0, 28953, 28954, 7, 2, 0, 0, 28954, 28955, 5, 95, 0, 0, 28955, 28956, 7, 14, 0, 0, 28956, 28957, 7, 12, 0, 0, 28957, 28958, 7, 11, 0, 0, 28958, 28959, 7, 4, 0, 0, 28959, 28960, 7, 10, 0, 0, 28960, 28961, 5, 95, 0, 0, 28961, 28962, 7, 1, 0, 0, 28962, 28963, 7, 18, 0, 0, 28963, 28964, 7, 4, 0, 0, 28964, 28965, 7, 6, 0, 0, 28965, 4262, 1, 0, 0, 0, 28966, 28967, 7, 4, 0, 0, 28967, 28968, 7, 2, 0, 0, 28968, 28969, 5, 95, 0, 0, 28969, 28970, 7, 7, 0, 0, 28970, 28971, 7, 8, 0, 0, 28971, 28972, 7, 19, 0, 0, 28972, 28973, 7, 0, 0, 0, 28973, 28974, 7, 3, 0, 0, 28974, 4264, 1, 0, 0, 0, 28975, 28976, 7, 4, 0, 0, 28976, 28977, 7, 2, 0, 0, 28977, 28978, 5, 95, 0, 0, 28978, 28979, 7, 7, 0, 0, 28979, 28980, 7, 8, 0, 0, 28980, 28981, 7, 11, 0, 0, 28981, 28982, 7, 2, 0, 0, 28982, 28983, 7, 1, 0, 0, 28983, 4266, 1, 0, 0, 0, 28984, 28985, 7, 4, 0, 0, 28985, 28986, 7, 2, 0, 0, 28986, 28987, 5, 95, 0, 0, 28987, 28988, 7, 7, 0, 0, 28988, 28989, 7, 12, 0, 0, 28989, 28990, 7, 14, 0, 0, 28990, 28991, 7, 1, 0, 0, 28991, 28992, 7, 6, 0, 0, 28992, 28993, 7, 3, 0, 0, 28993, 4268, 1, 0, 0, 0, 28994, 28995, 7, 4, 0, 0, 28995, 28996, 7, 2, 0, 0, 28996, 28997, 7, 15, 0, 0, 28997, 28998, 7, 11, 0, 0, 28998, 28999, 7, 6, 0, 0, 28999, 29000, 7, 13, 0, 0, 29000, 29001, 7, 6, 0, 0, 29001, 29002, 7, 11, 0, 0, 29002, 4270, 1, 0, 0, 0, 29003, 29004, 7, 4, 0, 0, 29004, 29005, 7, 2, 0, 0, 29005, 29006, 5, 95, 0, 0, 29006, 29007, 7, 5, 0, 0, 29007, 29008, 7, 10, 0, 0, 29008, 29009, 7, 7, 0, 0, 29009, 29010, 7, 17, 0, 0, 29010, 29011, 7, 11, 0, 0, 29011, 29012, 7, 6, 0, 0, 29012, 29013, 5, 95, 0, 0, 29013, 29014, 7, 1, 0, 0, 29014, 29015, 7, 18, 0, 0, 29015, 29016, 7, 4, 0, 0, 29016, 29017, 7, 6, 0, 0, 29017, 4272, 1, 0, 0, 0, 29018, 29019, 7, 4, 0, 0, 29019, 29020, 7, 2, 0, 0, 29020, 29021, 5, 95, 0, 0, 29021, 29022, 7, 4, 0, 0, 29022, 29023, 7, 10, 0, 0, 29023, 29024, 7, 14, 0, 0, 29024, 29025, 7, 6, 0, 0, 29025, 29026, 7, 5, 0, 0, 29026, 29027, 7, 4, 0, 0, 29027, 29028, 7, 0, 0, 0, 29028, 29029, 7, 14, 0, 0, 29029, 29030, 7, 15, 0, 0, 29030, 4274, 1, 0, 0, 0, 29031, 29032, 7, 4, 0, 0, 29032, 29033, 7, 2, 0, 0, 29033, 29034, 5, 95, 0, 0, 29034, 29035, 7, 4, 0, 0, 29035, 29036, 7, 10, 0, 0, 29036, 29037, 7, 14, 0, 0, 29037, 29038, 7, 6, 0, 0, 29038, 29039, 7, 5, 0, 0, 29039, 29040, 7, 4, 0, 0, 29040, 29041, 7, 0, 0, 0, 29041, 29042, 7, 14, 0, 0, 29042, 29043, 7, 15, 0, 0, 29043, 29044, 5, 95, 0, 0, 29044, 29045, 7, 4, 0, 0, 29045, 29046, 7, 23, 0, 0, 29046, 4276, 1, 0, 0, 0, 29047, 29048, 7, 4, 0, 0, 29048, 29049, 7, 2, 0, 0, 29049, 29050, 5, 95, 0, 0, 29050, 29051, 7, 4, 0, 0, 29051, 29052, 7, 10, 0, 0, 29052, 29053, 7, 14, 0, 0, 29053, 29054, 7, 6, 0, 0, 29054, 4278, 1, 0, 0, 0, 29055, 29056, 7, 4, 0, 0, 29056, 29057, 7, 2, 0, 0, 29057, 29058, 5, 95, 0, 0, 29058, 29059, 7, 4, 0, 0, 29059, 29060, 7, 10, 0, 0, 29060, 29061, 7, 14, 0, 0, 29061, 29062, 7, 6, 0, 0, 29062, 29063, 5, 95, 0, 0, 29063, 29064, 7, 4, 0, 0, 29064, 29065, 7, 23, 0, 0, 29065, 4280, 1, 0, 0, 0, 29066, 29067, 7, 4, 0, 0, 29067, 29068, 7, 2, 0, 0, 29068, 4282, 1, 0, 0, 0, 29069, 29070, 7, 4, 0, 0, 29070, 29071, 7, 2, 0, 0, 29071, 29072, 5, 95, 0, 0, 29072, 29073, 7, 18, 0, 0, 29073, 29074, 7, 14, 0, 0, 29074, 29075, 7, 10, 0, 0, 29075, 29076, 7, 7, 0, 0, 29076, 29077, 7, 4, 0, 0, 29077, 29078, 7, 6, 0, 0, 29078, 29079, 7, 3, 0, 0, 29079, 29080, 7, 13, 0, 0, 29080, 29081, 7, 0, 0, 0, 29081, 29082, 7, 11, 0, 0, 29082, 4284, 1, 0, 0, 0, 29083, 29084, 7, 4, 0, 0, 29084, 29085, 7, 3, 0, 0, 29085, 29086, 7, 0, 0, 0, 29086, 29087, 7, 8, 0, 0, 29087, 29088, 7, 6, 0, 0, 29088, 4286, 1, 0, 0, 0, 29089, 29090, 7, 4, 0, 0, 29090, 29091, 7, 3, 0, 0, 29091, 29092, 7, 0, 0, 0, 29092, 29093, 7, 8, 0, 0, 29093, 29094, 7, 10, 0, 0, 29094, 29095, 7, 7, 0, 0, 29095, 29096, 7, 17, 0, 0, 29096, 4288, 1, 0, 0, 0, 29097, 29098, 7, 4, 0, 0, 29098, 29099, 7, 3, 0, 0, 29099, 29100, 7, 0, 0, 0, 29100, 29101, 7, 8, 0, 0, 29101, 29102, 7, 21, 0, 0, 29102, 29103, 7, 10, 0, 0, 29103, 29104, 7, 7, 0, 0, 29104, 29105, 7, 17, 0, 0, 29105, 4290, 1, 0, 0, 0, 29106, 29107, 7, 4, 0, 0, 29107, 29108, 7, 3, 0, 0, 29108, 29109, 7, 0, 0, 0, 29109, 29110, 7, 10, 0, 0, 29110, 29111, 7, 11, 0, 0, 29111, 29112, 7, 10, 0, 0, 29112, 29113, 7, 7, 0, 0, 29113, 29114, 7, 17, 0, 0, 29114, 4292, 1, 0, 0, 0, 29115, 29116, 7, 4, 0, 0, 29116, 29117, 7, 3, 0, 0, 29117, 29118, 7, 0, 0, 0, 29118, 29119, 7, 7, 0, 0, 29119, 29120, 7, 5, 0, 0, 29120, 29121, 7, 0, 0, 0, 29121, 29122, 7, 8, 0, 0, 29122, 29123, 7, 4, 0, 0, 29123, 29124, 7, 10, 0, 0, 29124, 29125, 7, 2, 0, 0, 29125, 29126, 7, 7, 0, 0, 29126, 4294, 1, 0, 0, 0, 29127, 29128, 7, 4, 0, 0, 29128, 29129, 7, 3, 0, 0, 29129, 29130, 7, 0, 0, 0, 29130, 29131, 7, 7, 0, 0, 29131, 29132, 7, 5, 0, 0, 29132, 29133, 7, 16, 0, 0, 29133, 29134, 7, 2, 0, 0, 29134, 29135, 7, 3, 0, 0, 29135, 29136, 7, 14, 0, 0, 29136, 4296, 1, 0, 0, 0, 29137, 29138, 7, 4, 0, 0, 29138, 29139, 7, 3, 0, 0, 29139, 29140, 7, 0, 0, 0, 29140, 29141, 7, 7, 0, 0, 29141, 29142, 7, 5, 0, 0, 29142, 29143, 7, 16, 0, 0, 29143, 29144, 7, 2, 0, 0, 29144, 29145, 7, 3, 0, 0, 29145, 29146, 7, 14, 0, 0, 29146, 29147, 7, 5, 0, 0, 29147, 4298, 1, 0, 0, 0, 29148, 29149, 7, 4, 0, 0, 29149, 29150, 7, 3, 0, 0, 29150, 29151, 7, 0, 0, 0, 29151, 29152, 7, 7, 0, 0, 29152, 29153, 7, 5, 0, 0, 29153, 29154, 7, 16, 0, 0, 29154, 29155, 7, 2, 0, 0, 29155, 29156, 7, 3, 0, 0, 29156, 29157, 7, 14, 0, 0, 29157, 29158, 5, 95, 0, 0, 29158, 29159, 7, 9, 0, 0, 29159, 29160, 7, 10, 0, 0, 29160, 29161, 7, 5, 0, 0, 29161, 29162, 7, 4, 0, 0, 29162, 29163, 7, 10, 0, 0, 29163, 29164, 7, 7, 0, 0, 29164, 29165, 7, 8, 0, 0, 29165, 29166, 7, 4, 0, 0, 29166, 29167, 5, 95, 0, 0, 29167, 29168, 7, 0, 0, 0, 29168, 29169, 7, 17, 0, 0, 29169, 29170, 7, 17, 0, 0, 29170, 4300, 1, 0, 0, 0, 29171, 29172, 7, 4, 0, 0, 29172, 29173, 7, 3, 0, 0, 29173, 29174, 7, 0, 0, 0, 29174, 29175, 7, 7, 0, 0, 29175, 29176, 7, 5, 0, 0, 29176, 29177, 7, 10, 0, 0, 29177, 29178, 7, 4, 0, 0, 29178, 29179, 7, 10, 0, 0, 29179, 29180, 7, 2, 0, 0, 29180, 29181, 7, 7, 0, 0, 29181, 29182, 7, 0, 0, 0, 29182, 29183, 7, 11, 0, 0, 29183, 4302, 1, 0, 0, 0, 29184, 29185, 7, 4, 0, 0, 29185, 29186, 7, 3, 0, 0, 29186, 29187, 7, 0, 0, 0, 29187, 29188, 7, 7, 0, 0, 29188, 29189, 7, 5, 0, 0, 29189, 29190, 7, 10, 0, 0, 29190, 29191, 7, 4, 0, 0, 29191, 29192, 7, 10, 0, 0, 29192, 29193, 7, 2, 0, 0, 29193, 29194, 7, 7, 0, 0, 29194, 4304, 1, 0, 0, 0, 29195, 29196, 7, 4, 0, 0, 29196, 29197, 7, 3, 0, 0, 29197, 29198, 7, 0, 0, 0, 29198, 29199, 7, 7, 0, 0, 29199, 29200, 7, 5, 0, 0, 29200, 29201, 7, 11, 0, 0, 29201, 29202, 7, 0, 0, 0, 29202, 29203, 7, 4, 0, 0, 29203, 29204, 7, 6, 0, 0, 29204, 4306, 1, 0, 0, 0, 29205, 29206, 7, 4, 0, 0, 29206, 29207, 7, 3, 0, 0, 29207, 29208, 7, 0, 0, 0, 29208, 29209, 7, 7, 0, 0, 29209, 29210, 7, 5, 0, 0, 29210, 29211, 7, 11, 0, 0, 29211, 29212, 7, 0, 0, 0, 29212, 29213, 7, 4, 0, 0, 29213, 29214, 7, 10, 0, 0, 29214, 29215, 7, 2, 0, 0, 29215, 29216, 7, 7, 0, 0, 29216, 4308, 1, 0, 0, 0, 29217, 29218, 7, 4, 0, 0, 29218, 29219, 7, 3, 0, 0, 29219, 29220, 7, 6, 0, 0, 29220, 29221, 7, 0, 0, 0, 29221, 29222, 7, 4, 0, 0, 29222, 4310, 1, 0, 0, 0, 29223, 29224, 7, 4, 0, 0, 29224, 29225, 7, 3, 0, 0, 29225, 29226, 7, 10, 0, 0, 29226, 29227, 7, 17, 0, 0, 29227, 29228, 7, 17, 0, 0, 29228, 29229, 7, 6, 0, 0, 29229, 29230, 7, 3, 0, 0, 29230, 29231, 7, 5, 0, 0, 29231, 4312, 1, 0, 0, 0, 29232, 29233, 7, 4, 0, 0, 29233, 29234, 7, 3, 0, 0, 29234, 29235, 7, 10, 0, 0, 29235, 29236, 7, 17, 0, 0, 29236, 29237, 7, 17, 0, 0, 29237, 29238, 7, 6, 0, 0, 29238, 29239, 7, 3, 0, 0, 29239, 4314, 1, 0, 0, 0, 29240, 29241, 7, 4, 0, 0, 29241, 29242, 7, 3, 0, 0, 29242, 29243, 7, 12, 0, 0, 29243, 29244, 7, 6, 0, 0, 29244, 4316, 1, 0, 0, 0, 29245, 29246, 7, 4, 0, 0, 29246, 29247, 7, 3, 0, 0, 29247, 29248, 7, 12, 0, 0, 29248, 29249, 7, 7, 0, 0, 29249, 29250, 7, 8, 0, 0, 29250, 29251, 7, 0, 0, 0, 29251, 29252, 7, 4, 0, 0, 29252, 29253, 7, 6, 0, 0, 29253, 4318, 1, 0, 0, 0, 29254, 29255, 7, 4, 0, 0, 29255, 29256, 7, 3, 0, 0, 29256, 29257, 7, 12, 0, 0, 29257, 29258, 7, 7, 0, 0, 29258, 29259, 7, 8, 0, 0, 29259, 4320, 1, 0, 0, 0, 29260, 29261, 7, 4, 0, 0, 29261, 29262, 7, 3, 0, 0, 29262, 29263, 7, 12, 0, 0, 29263, 29264, 7, 5, 0, 0, 29264, 29265, 7, 4, 0, 0, 29265, 29266, 7, 6, 0, 0, 29266, 29267, 7, 9, 0, 0, 29267, 4322, 1, 0, 0, 0, 29268, 29269, 7, 4, 0, 0, 29269, 29270, 7, 3, 0, 0, 29270, 29271, 7, 12, 0, 0, 29271, 29272, 7, 5, 0, 0, 29272, 29273, 7, 4, 0, 0, 29273, 4324, 1, 0, 0, 0, 29274, 29275, 7, 4, 0, 0, 29275, 29276, 7, 12, 0, 0, 29276, 29277, 7, 7, 0, 0, 29277, 29278, 7, 10, 0, 0, 29278, 29279, 7, 7, 0, 0, 29279, 29280, 7, 17, 0, 0, 29280, 4326, 1, 0, 0, 0, 29281, 29282, 7, 4, 0, 0, 29282, 29283, 7, 25, 0, 0, 29283, 4328, 1, 0, 0, 0, 29284, 29285, 7, 4, 0, 0, 29285, 29286, 7, 18, 0, 0, 29286, 29287, 7, 15, 0, 0, 29287, 29288, 7, 6, 0, 0, 29288, 29289, 7, 5, 0, 0, 29289, 4330, 1, 0, 0, 0, 29290, 29291, 7, 4, 0, 0, 29291, 29292, 7, 18, 0, 0, 29292, 29293, 7, 15, 0, 0, 29293, 29294, 7, 6, 0, 0, 29294, 4332, 1, 0, 0, 0, 29295, 29296, 7, 4, 0, 0, 29296, 29297, 7, 23, 0, 0, 29297, 29298, 5, 95, 0, 0, 29298, 29299, 7, 2, 0, 0, 29299, 29300, 7, 16, 0, 0, 29300, 29301, 7, 16, 0, 0, 29301, 29302, 7, 5, 0, 0, 29302, 29303, 7, 6, 0, 0, 29303, 29304, 7, 4, 0, 0, 29304, 4334, 1, 0, 0, 0, 29305, 29306, 7, 12, 0, 0, 29306, 29307, 7, 1, 0, 0, 29307, 29308, 5, 50, 0, 0, 29308, 4336, 1, 0, 0, 0, 29309, 29310, 7, 12, 0, 0, 29310, 29311, 7, 1, 0, 0, 29311, 29312, 7, 0, 0, 0, 29312, 4338, 1, 0, 0, 0, 29313, 29314, 7, 12, 0, 0, 29314, 29315, 7, 8, 0, 0, 29315, 29316, 7, 5, 0, 0, 29316, 29317, 5, 50, 0, 0, 29317, 4340, 1, 0, 0, 0, 29318, 29319, 7, 12, 0, 0, 29319, 29320, 7, 9, 0, 0, 29320, 29321, 7, 16, 0, 0, 29321, 4342, 1, 0, 0, 0, 29322, 29323, 7, 12, 0, 0, 29323, 29324, 7, 10, 0, 0, 29324, 29325, 7, 9, 0, 0, 29325, 4344, 1, 0, 0, 0, 29326, 29327, 7, 12, 0, 0, 29327, 29328, 7, 7, 0, 0, 29328, 29329, 7, 0, 0, 0, 29329, 29330, 7, 3, 0, 0, 29330, 29331, 7, 8, 0, 0, 29331, 29332, 7, 19, 0, 0, 29332, 29333, 7, 10, 0, 0, 29333, 29334, 7, 13, 0, 0, 29334, 29335, 7, 6, 0, 0, 29335, 29336, 7, 9, 0, 0, 29336, 4346, 1, 0, 0, 0, 29337, 29338, 7, 12, 0, 0, 29338, 29339, 7, 7, 0, 0, 29339, 29340, 7, 1, 0, 0, 29340, 29341, 7, 2, 0, 0, 29341, 29342, 7, 12, 0, 0, 29342, 29343, 7, 7, 0, 0, 29343, 29344, 7, 9, 0, 0, 29344, 29345, 7, 6, 0, 0, 29345, 29346, 7, 9, 0, 0, 29346, 4348, 1, 0, 0, 0, 29347, 29348, 7, 12, 0, 0, 29348, 29349, 7, 7, 0, 0, 29349, 29350, 7, 1, 0, 0, 29350, 29351, 7, 2, 0, 0, 29351, 29352, 7, 12, 0, 0, 29352, 29353, 7, 7, 0, 0, 29353, 29354, 7, 9, 0, 0, 29354, 4350, 1, 0, 0, 0, 29355, 29356, 7, 12, 0, 0, 29356, 29357, 7, 7, 0, 0, 29357, 29358, 7, 8, 0, 0, 29358, 29359, 7, 2, 0, 0, 29359, 29360, 7, 7, 0, 0, 29360, 29361, 7, 9, 0, 0, 29361, 29362, 7, 10, 0, 0, 29362, 29363, 7, 4, 0, 0, 29363, 29364, 7, 10, 0, 0, 29364, 29365, 7, 2, 0, 0, 29365, 29366, 7, 7, 0, 0, 29366, 29367, 7, 0, 0, 0, 29367, 29368, 7, 11, 0, 0, 29368, 4352, 1, 0, 0, 0, 29369, 29370, 7, 12, 0, 0, 29370, 29371, 7, 7, 0, 0, 29371, 29372, 7, 9, 0, 0, 29372, 29373, 7, 6, 0, 0, 29373, 29374, 7, 3, 0, 0, 29374, 4354, 1, 0, 0, 0, 29375, 29376, 7, 12, 0, 0, 29376, 29377, 7, 7, 0, 0, 29377, 29378, 7, 9, 0, 0, 29378, 29379, 7, 2, 0, 0, 29379, 4356, 1, 0, 0, 0, 29380, 29381, 7, 12, 0, 0, 29381, 29382, 7, 7, 0, 0, 29382, 29383, 7, 9, 0, 0, 29383, 29384, 7, 3, 0, 0, 29384, 29385, 7, 2, 0, 0, 29385, 29386, 7, 15, 0, 0, 29386, 4358, 1, 0, 0, 0, 29387, 29388, 7, 12, 0, 0, 29388, 29389, 7, 7, 0, 0, 29389, 29390, 7, 10, 0, 0, 29390, 29391, 7, 16, 0, 0, 29391, 29392, 7, 2, 0, 0, 29392, 29393, 7, 3, 0, 0, 29393, 29394, 7, 14, 0, 0, 29394, 4360, 1, 0, 0, 0, 29395, 29396, 7, 12, 0, 0, 29396, 29397, 7, 7, 0, 0, 29397, 29398, 7, 10, 0, 0, 29398, 29399, 7, 2, 0, 0, 29399, 29400, 7, 7, 0, 0, 29400, 4362, 1, 0, 0, 0, 29401, 29402, 7, 12, 0, 0, 29402, 29403, 7, 7, 0, 0, 29403, 29404, 7, 10, 0, 0, 29404, 29405, 7, 2, 0, 0, 29405, 29406, 7, 7, 0, 0, 29406, 29407, 7, 4, 0, 0, 29407, 29408, 7, 18, 0, 0, 29408, 29409, 7, 15, 0, 0, 29409, 29410, 7, 6, 0, 0, 29410, 4364, 1, 0, 0, 0, 29411, 29412, 7, 12, 0, 0, 29412, 29413, 7, 7, 0, 0, 29413, 29414, 7, 10, 0, 0, 29414, 29415, 7, 24, 0, 0, 29415, 29416, 7, 12, 0, 0, 29416, 29417, 7, 6, 0, 0, 29417, 4366, 1, 0, 0, 0, 29418, 29419, 7, 12, 0, 0, 29419, 29420, 7, 7, 0, 0, 29420, 29421, 7, 10, 0, 0, 29421, 29422, 7, 5, 0, 0, 29422, 29423, 7, 4, 0, 0, 29423, 29424, 7, 3, 0, 0, 29424, 4368, 1, 0, 0, 0, 29425, 29426, 7, 12, 0, 0, 29426, 29427, 7, 7, 0, 0, 29427, 29428, 7, 11, 0, 0, 29428, 29429, 7, 10, 0, 0, 29429, 29430, 7, 14, 0, 0, 29430, 29431, 7, 10, 0, 0, 29431, 29432, 7, 4, 0, 0, 29432, 29433, 7, 6, 0, 0, 29433, 29434, 7, 9, 0, 0, 29434, 4370, 1, 0, 0, 0, 29435, 29436, 7, 12, 0, 0, 29436, 29437, 7, 7, 0, 0, 29437, 29438, 7, 11, 0, 0, 29438, 29439, 7, 2, 0, 0, 29439, 29440, 7, 0, 0, 0, 29440, 29441, 7, 9, 0, 0, 29441, 4372, 1, 0, 0, 0, 29442, 29443, 7, 12, 0, 0, 29443, 29444, 7, 7, 0, 0, 29444, 29445, 7, 11, 0, 0, 29445, 29446, 7, 2, 0, 0, 29446, 29447, 7, 8, 0, 0, 29447, 29448, 7, 21, 0, 0, 29448, 4374, 1, 0, 0, 0, 29449, 29450, 7, 12, 0, 0, 29450, 29451, 7, 7, 0, 0, 29451, 29452, 7, 14, 0, 0, 29452, 29453, 7, 0, 0, 0, 29453, 29454, 7, 4, 0, 0, 29454, 29455, 7, 8, 0, 0, 29455, 29456, 7, 19, 0, 0, 29456, 29457, 7, 6, 0, 0, 29457, 29458, 7, 9, 0, 0, 29458, 4376, 1, 0, 0, 0, 29459, 29460, 7, 12, 0, 0, 29460, 29461, 7, 7, 0, 0, 29461, 29462, 7, 7, 0, 0, 29462, 29463, 7, 6, 0, 0, 29463, 29464, 7, 5, 0, 0, 29464, 29465, 7, 4, 0, 0, 29465, 29466, 5, 95, 0, 0, 29466, 29467, 7, 10, 0, 0, 29467, 29468, 7, 7, 0, 0, 29468, 29469, 7, 7, 0, 0, 29469, 29470, 7, 6, 0, 0, 29470, 29471, 7, 3, 0, 0, 29471, 29472, 7, 20, 0, 0, 29472, 29473, 5, 95, 0, 0, 29473, 29474, 7, 9, 0, 0, 29474, 29475, 7, 10, 0, 0, 29475, 29476, 7, 5, 0, 0, 29476, 29477, 7, 4, 0, 0, 29477, 29478, 7, 10, 0, 0, 29478, 29479, 7, 7, 0, 0, 29479, 29480, 7, 8, 0, 0, 29480, 29481, 7, 4, 0, 0, 29481, 29482, 5, 95, 0, 0, 29482, 29483, 7, 13, 0, 0, 29483, 29484, 7, 10, 0, 0, 29484, 29485, 7, 6, 0, 0, 29485, 29486, 7, 22, 0, 0, 29486, 4378, 1, 0, 0, 0, 29487, 29488, 7, 12, 0, 0, 29488, 29489, 7, 7, 0, 0, 29489, 29490, 7, 7, 0, 0, 29490, 29491, 7, 6, 0, 0, 29491, 29492, 7, 5, 0, 0, 29492, 29493, 7, 4, 0, 0, 29493, 29494, 5, 95, 0, 0, 29494, 29495, 7, 7, 0, 0, 29495, 29496, 7, 2, 0, 0, 29496, 29497, 7, 5, 0, 0, 29497, 29498, 7, 6, 0, 0, 29498, 29499, 7, 14, 0, 0, 29499, 29500, 7, 10, 0, 0, 29500, 29501, 7, 20, 0, 0, 29501, 29502, 5, 95, 0, 0, 29502, 29503, 7, 7, 0, 0, 29503, 29504, 7, 2, 0, 0, 29504, 29505, 7, 9, 0, 0, 29505, 29506, 7, 10, 0, 0, 29506, 29507, 7, 5, 0, 0, 29507, 29508, 7, 4, 0, 0, 29508, 29509, 7, 10, 0, 0, 29509, 29510, 7, 7, 0, 0, 29510, 29511, 7, 8, 0, 0, 29511, 29512, 7, 4, 0, 0, 29512, 29513, 7, 13, 0, 0, 29513, 29514, 7, 10, 0, 0, 29514, 29515, 7, 6, 0, 0, 29515, 29516, 7, 22, 0, 0, 29516, 4380, 1, 0, 0, 0, 29517, 29518, 7, 12, 0, 0, 29518, 29519, 7, 7, 0, 0, 29519, 29520, 7, 7, 0, 0, 29520, 29521, 7, 6, 0, 0, 29521, 29522, 7, 5, 0, 0, 29522, 29523, 7, 4, 0, 0, 29523, 29524, 5, 95, 0, 0, 29524, 29525, 7, 5, 0, 0, 29525, 29526, 7, 6, 0, 0, 29526, 29527, 7, 14, 0, 0, 29527, 29528, 7, 10, 0, 0, 29528, 29529, 7, 20, 0, 0, 29529, 29530, 5, 95, 0, 0, 29530, 29531, 7, 13, 0, 0, 29531, 29532, 7, 10, 0, 0, 29532, 29533, 7, 6, 0, 0, 29533, 29534, 7, 22, 0, 0, 29534, 4382, 1, 0, 0, 0, 29535, 29536, 7, 12, 0, 0, 29536, 29537, 7, 7, 0, 0, 29537, 29538, 7, 7, 0, 0, 29538, 29539, 7, 6, 0, 0, 29539, 29540, 7, 5, 0, 0, 29540, 29541, 7, 4, 0, 0, 29541, 4384, 1, 0, 0, 0, 29542, 29543, 7, 12, 0, 0, 29543, 29544, 7, 7, 0, 0, 29544, 29545, 7, 15, 0, 0, 29545, 29546, 7, 0, 0, 0, 29546, 29547, 7, 8, 0, 0, 29547, 29548, 7, 21, 0, 0, 29548, 29549, 7, 6, 0, 0, 29549, 29550, 7, 9, 0, 0, 29550, 4386, 1, 0, 0, 0, 29551, 29552, 7, 12, 0, 0, 29552, 29553, 7, 7, 0, 0, 29553, 29554, 7, 15, 0, 0, 29554, 29555, 7, 10, 0, 0, 29555, 29556, 7, 13, 0, 0, 29556, 29557, 7, 2, 0, 0, 29557, 29558, 7, 4, 0, 0, 29558, 4388, 1, 0, 0, 0, 29559, 29560, 7, 12, 0, 0, 29560, 29561, 7, 7, 0, 0, 29561, 29562, 7, 15, 0, 0, 29562, 29563, 7, 11, 0, 0, 29563, 29564, 7, 12, 0, 0, 29564, 29565, 7, 17, 0, 0, 29565, 4390, 1, 0, 0, 0, 29566, 29567, 7, 12, 0, 0, 29567, 29568, 7, 7, 0, 0, 29568, 29569, 7, 15, 0, 0, 29569, 29570, 7, 3, 0, 0, 29570, 29571, 7, 2, 0, 0, 29571, 29572, 7, 4, 0, 0, 29572, 29573, 7, 6, 0, 0, 29573, 29574, 7, 8, 0, 0, 29574, 29575, 7, 4, 0, 0, 29575, 29576, 7, 6, 0, 0, 29576, 29577, 7, 9, 0, 0, 29577, 4392, 1, 0, 0, 0, 29578, 29579, 7, 12, 0, 0, 29579, 29580, 7, 7, 0, 0, 29580, 29581, 7, 24, 0, 0, 29581, 29582, 7, 12, 0, 0, 29582, 29583, 7, 10, 0, 0, 29583, 29584, 7, 6, 0, 0, 29584, 29585, 7, 5, 0, 0, 29585, 29586, 7, 8, 0, 0, 29586, 29587, 7, 6, 0, 0, 29587, 4394, 1, 0, 0, 0, 29588, 29589, 7, 12, 0, 0, 29589, 29590, 7, 7, 0, 0, 29590, 29591, 7, 3, 0, 0, 29591, 29592, 7, 6, 0, 0, 29592, 29593, 7, 8, 0, 0, 29593, 29594, 7, 2, 0, 0, 29594, 29595, 7, 13, 0, 0, 29595, 29596, 7, 6, 0, 0, 29596, 29597, 7, 3, 0, 0, 29597, 29598, 7, 0, 0, 0, 29598, 29599, 7, 1, 0, 0, 29599, 29600, 7, 11, 0, 0, 29600, 29601, 7, 6, 0, 0, 29601, 4396, 1, 0, 0, 0, 29602, 29603, 7, 12, 0, 0, 29603, 29604, 7, 7, 0, 0, 29604, 29605, 7, 3, 0, 0, 29605, 29606, 7, 6, 0, 0, 29606, 29607, 7, 5, 0, 0, 29607, 29608, 7, 4, 0, 0, 29608, 29609, 7, 3, 0, 0, 29609, 29610, 7, 10, 0, 0, 29610, 29611, 7, 8, 0, 0, 29611, 29612, 7, 4, 0, 0, 29612, 29613, 7, 6, 0, 0, 29613, 29614, 7, 9, 0, 0, 29614, 4398, 1, 0, 0, 0, 29615, 29616, 7, 12, 0, 0, 29616, 29617, 7, 7, 0, 0, 29617, 29618, 7, 5, 0, 0, 29618, 29619, 7, 10, 0, 0, 29619, 29620, 7, 17, 0, 0, 29620, 29621, 7, 7, 0, 0, 29621, 29622, 7, 6, 0, 0, 29622, 29623, 7, 9, 0, 0, 29623, 4400, 1, 0, 0, 0, 29624, 29625, 7, 12, 0, 0, 29625, 29626, 7, 7, 0, 0, 29626, 29627, 7, 5, 0, 0, 29627, 29628, 7, 12, 0, 0, 29628, 29629, 7, 1, 0, 0, 29629, 29630, 7, 5, 0, 0, 29630, 29631, 7, 8, 0, 0, 29631, 29632, 7, 3, 0, 0, 29632, 29633, 7, 10, 0, 0, 29633, 29634, 7, 1, 0, 0, 29634, 29635, 7, 6, 0, 0, 29635, 4402, 1, 0, 0, 0, 29636, 29637, 7, 12, 0, 0, 29637, 29638, 7, 7, 0, 0, 29638, 29639, 7, 4, 0, 0, 29639, 29640, 7, 10, 0, 0, 29640, 29641, 7, 11, 0, 0, 29641, 4404, 1, 0, 0, 0, 29642, 29643, 7, 12, 0, 0, 29643, 29644, 7, 7, 0, 0, 29644, 29645, 7, 12, 0, 0, 29645, 29646, 7, 5, 0, 0, 29646, 29647, 7, 0, 0, 0, 29647, 29648, 7, 1, 0, 0, 29648, 29649, 7, 11, 0, 0, 29649, 29650, 7, 6, 0, 0, 29650, 4406, 1, 0, 0, 0, 29651, 29652, 7, 12, 0, 0, 29652, 29653, 7, 7, 0, 0, 29653, 29654, 7, 12, 0, 0, 29654, 29655, 7, 5, 0, 0, 29655, 29656, 7, 6, 0, 0, 29656, 29657, 7, 9, 0, 0, 29657, 4408, 1, 0, 0, 0, 29658, 29659, 7, 12, 0, 0, 29659, 29660, 7, 15, 0, 0, 29660, 29661, 7, 9, 0, 0, 29661, 29662, 7, 0, 0, 0, 29662, 29663, 7, 4, 0, 0, 29663, 29664, 7, 0, 0, 0, 29664, 29665, 7, 1, 0, 0, 29665, 29666, 7, 11, 0, 0, 29666, 29667, 7, 6, 0, 0, 29667, 4410, 1, 0, 0, 0, 29668, 29669, 7, 12, 0, 0, 29669, 29670, 7, 15, 0, 0, 29670, 29671, 7, 9, 0, 0, 29671, 29672, 7, 0, 0, 0, 29672, 29673, 7, 4, 0, 0, 29673, 29674, 7, 6, 0, 0, 29674, 29675, 7, 9, 0, 0, 29675, 4412, 1, 0, 0, 0, 29676, 29677, 7, 12, 0, 0, 29677, 29678, 7, 15, 0, 0, 29678, 29679, 7, 9, 0, 0, 29679, 29680, 7, 0, 0, 0, 29680, 29681, 7, 4, 0, 0, 29681, 29682, 7, 6, 0, 0, 29682, 4414, 1, 0, 0, 0, 29683, 29684, 7, 12, 0, 0, 29684, 29685, 7, 15, 0, 0, 29685, 29686, 7, 9, 0, 0, 29686, 29687, 7, 0, 0, 0, 29687, 29688, 7, 4, 0, 0, 29688, 29689, 7, 6, 0, 0, 29689, 29690, 7, 25, 0, 0, 29690, 29691, 7, 14, 0, 0, 29691, 29692, 7, 11, 0, 0, 29692, 4416, 1, 0, 0, 0, 29693, 29694, 7, 12, 0, 0, 29694, 29695, 7, 15, 0, 0, 29695, 29696, 7, 9, 0, 0, 29696, 29697, 5, 95, 0, 0, 29697, 29698, 7, 10, 0, 0, 29698, 29699, 7, 7, 0, 0, 29699, 29700, 7, 9, 0, 0, 29700, 29701, 7, 6, 0, 0, 29701, 29702, 7, 25, 0, 0, 29702, 29703, 7, 6, 0, 0, 29703, 29704, 7, 5, 0, 0, 29704, 4418, 1, 0, 0, 0, 29705, 29706, 7, 12, 0, 0, 29706, 29707, 7, 15, 0, 0, 29707, 29708, 7, 9, 0, 0, 29708, 29709, 5, 95, 0, 0, 29709, 29710, 7, 20, 0, 0, 29710, 29711, 7, 2, 0, 0, 29711, 29712, 7, 10, 0, 0, 29712, 29713, 7, 7, 0, 0, 29713, 29714, 7, 10, 0, 0, 29714, 29715, 7, 7, 0, 0, 29715, 29716, 7, 9, 0, 0, 29716, 29717, 7, 6, 0, 0, 29717, 29718, 7, 25, 0, 0, 29718, 4420, 1, 0, 0, 0, 29719, 29720, 7, 12, 0, 0, 29720, 29721, 7, 15, 0, 0, 29721, 29722, 7, 17, 0, 0, 29722, 29723, 7, 3, 0, 0, 29723, 29724, 7, 0, 0, 0, 29724, 29725, 7, 9, 0, 0, 29725, 29726, 7, 6, 0, 0, 29726, 4422, 1, 0, 0, 0, 29727, 29728, 7, 12, 0, 0, 29728, 29729, 7, 15, 0, 0, 29729, 29730, 7, 15, 0, 0, 29730, 29731, 7, 6, 0, 0, 29731, 29732, 7, 3, 0, 0, 29732, 4424, 1, 0, 0, 0, 29733, 29734, 7, 12, 0, 0, 29734, 29735, 7, 15, 0, 0, 29735, 29736, 7, 5, 0, 0, 29736, 29737, 7, 6, 0, 0, 29737, 29738, 7, 3, 0, 0, 29738, 29739, 7, 4, 0, 0, 29739, 4426, 1, 0, 0, 0, 29740, 29741, 7, 12, 0, 0, 29741, 29742, 7, 3, 0, 0, 29742, 29743, 7, 2, 0, 0, 29743, 29744, 7, 22, 0, 0, 29744, 29745, 7, 10, 0, 0, 29745, 29746, 7, 9, 0, 0, 29746, 4428, 1, 0, 0, 0, 29747, 29748, 7, 12, 0, 0, 29748, 29749, 7, 5, 0, 0, 29749, 29750, 7, 0, 0, 0, 29750, 29751, 7, 1, 0, 0, 29751, 29752, 7, 11, 0, 0, 29752, 29753, 7, 6, 0, 0, 29753, 4430, 1, 0, 0, 0, 29754, 29755, 7, 12, 0, 0, 29755, 29756, 7, 5, 0, 0, 29756, 29757, 7, 0, 0, 0, 29757, 29758, 7, 17, 0, 0, 29758, 29759, 7, 6, 0, 0, 29759, 4432, 1, 0, 0, 0, 29760, 29761, 7, 12, 0, 0, 29761, 29762, 7, 5, 0, 0, 29762, 29763, 7, 6, 0, 0, 29763, 29764, 5, 95, 0, 0, 29764, 29765, 7, 0, 0, 0, 29765, 29766, 7, 7, 0, 0, 29766, 29767, 7, 4, 0, 0, 29767, 29768, 7, 10, 0, 0, 29768, 4434, 1, 0, 0, 0, 29769, 29770, 7, 12, 0, 0, 29770, 29771, 7, 5, 0, 0, 29771, 29772, 7, 6, 0, 0, 29772, 29773, 5, 95, 0, 0, 29773, 29774, 7, 8, 0, 0, 29774, 29775, 7, 2, 0, 0, 29775, 29776, 7, 7, 0, 0, 29776, 29777, 7, 8, 0, 0, 29777, 29778, 7, 0, 0, 0, 29778, 29779, 7, 4, 0, 0, 29779, 4436, 1, 0, 0, 0, 29780, 29781, 7, 12, 0, 0, 29781, 29782, 7, 5, 0, 0, 29782, 29783, 7, 6, 0, 0, 29783, 29784, 5, 95, 0, 0, 29784, 29785, 7, 8, 0, 0, 29785, 29786, 7, 12, 0, 0, 29786, 29787, 7, 1, 0, 0, 29787, 29788, 7, 6, 0, 0, 29788, 4438, 1, 0, 0, 0, 29789, 29790, 7, 12, 0, 0, 29790, 29791, 7, 5, 0, 0, 29791, 29792, 7, 6, 0, 0, 29792, 29793, 5, 95, 0, 0, 29793, 29794, 7, 19, 0, 0, 29794, 29795, 7, 0, 0, 0, 29795, 29796, 7, 5, 0, 0, 29796, 29797, 7, 19, 0, 0, 29797, 29798, 5, 95, 0, 0, 29798, 29799, 7, 0, 0, 0, 29799, 29800, 7, 17, 0, 0, 29800, 29801, 7, 17, 0, 0, 29801, 29802, 7, 3, 0, 0, 29802, 29803, 7, 6, 0, 0, 29803, 29804, 7, 17, 0, 0, 29804, 29805, 7, 0, 0, 0, 29805, 29806, 7, 4, 0, 0, 29806, 29807, 7, 10, 0, 0, 29807, 29808, 7, 2, 0, 0, 29808, 29809, 7, 7, 0, 0, 29809, 4440, 1, 0, 0, 0, 29810, 29811, 7, 12, 0, 0, 29811, 29812, 7, 5, 0, 0, 29812, 29813, 7, 6, 0, 0, 29813, 29814, 5, 95, 0, 0, 29814, 29815, 7, 19, 0, 0, 29815, 29816, 7, 0, 0, 0, 29816, 29817, 7, 5, 0, 0, 29817, 29818, 7, 19, 0, 0, 29818, 29819, 5, 95, 0, 0, 29819, 29820, 7, 17, 0, 0, 29820, 29821, 7, 1, 0, 0, 29821, 29822, 7, 18, 0, 0, 29822, 29823, 5, 95, 0, 0, 29823, 29824, 7, 16, 0, 0, 29824, 29825, 7, 2, 0, 0, 29825, 29826, 7, 3, 0, 0, 29826, 29827, 5, 95, 0, 0, 29827, 29828, 7, 15, 0, 0, 29828, 29829, 7, 12, 0, 0, 29829, 29830, 7, 5, 0, 0, 29830, 29831, 7, 19, 0, 0, 29831, 29832, 7, 9, 0, 0, 29832, 29833, 7, 2, 0, 0, 29833, 29834, 7, 22, 0, 0, 29834, 29835, 7, 7, 0, 0, 29835, 4442, 1, 0, 0, 0, 29836, 29837, 7, 12, 0, 0, 29837, 29838, 7, 5, 0, 0, 29838, 29839, 7, 6, 0, 0, 29839, 29840, 5, 95, 0, 0, 29840, 29841, 7, 19, 0, 0, 29841, 29842, 7, 0, 0, 0, 29842, 29843, 7, 5, 0, 0, 29843, 29844, 7, 19, 0, 0, 29844, 4444, 1, 0, 0, 0, 29845, 29846, 7, 12, 0, 0, 29846, 29847, 7, 5, 0, 0, 29847, 29848, 7, 6, 0, 0, 29848, 29849, 5, 95, 0, 0, 29849, 29850, 7, 19, 0, 0, 29850, 29851, 7, 10, 0, 0, 29851, 29852, 7, 9, 0, 0, 29852, 29853, 7, 9, 0, 0, 29853, 29854, 7, 6, 0, 0, 29854, 29855, 7, 7, 0, 0, 29855, 29856, 5, 95, 0, 0, 29856, 29857, 7, 15, 0, 0, 29857, 29858, 7, 0, 0, 0, 29858, 29859, 7, 3, 0, 0, 29859, 29860, 7, 4, 0, 0, 29860, 29861, 7, 10, 0, 0, 29861, 29862, 7, 4, 0, 0, 29862, 29863, 7, 10, 0, 0, 29863, 29864, 7, 2, 0, 0, 29864, 29865, 7, 7, 0, 0, 29865, 29866, 7, 5, 0, 0, 29866, 4446, 1, 0, 0, 0, 29867, 29868, 7, 12, 0, 0, 29868, 29869, 7, 5, 0, 0, 29869, 29870, 7, 6, 0, 0, 29870, 29871, 5, 95, 0, 0, 29871, 29872, 7, 10, 0, 0, 29872, 29873, 7, 7, 0, 0, 29873, 29874, 7, 13, 0, 0, 29874, 29875, 7, 10, 0, 0, 29875, 29876, 7, 5, 0, 0, 29876, 29877, 7, 10, 0, 0, 29877, 29878, 7, 1, 0, 0, 29878, 29879, 7, 11, 0, 0, 29879, 29880, 7, 6, 0, 0, 29880, 29881, 5, 95, 0, 0, 29881, 29882, 7, 10, 0, 0, 29882, 29883, 7, 7, 0, 0, 29883, 29884, 7, 9, 0, 0, 29884, 29885, 7, 6, 0, 0, 29885, 29886, 7, 25, 0, 0, 29886, 29887, 7, 6, 0, 0, 29887, 29888, 7, 5, 0, 0, 29888, 4448, 1, 0, 0, 0, 29889, 29890, 7, 12, 0, 0, 29890, 29891, 7, 5, 0, 0, 29891, 29892, 7, 6, 0, 0, 29892, 29893, 5, 95, 0, 0, 29893, 29894, 7, 14, 0, 0, 29894, 29895, 7, 6, 0, 0, 29895, 29896, 7, 3, 0, 0, 29896, 29897, 7, 17, 0, 0, 29897, 29898, 7, 6, 0, 0, 29898, 29899, 5, 95, 0, 0, 29899, 29900, 7, 8, 0, 0, 29900, 29901, 7, 0, 0, 0, 29901, 29902, 7, 3, 0, 0, 29902, 29903, 7, 4, 0, 0, 29903, 29904, 7, 6, 0, 0, 29904, 29905, 7, 5, 0, 0, 29905, 29906, 7, 10, 0, 0, 29906, 29907, 7, 0, 0, 0, 29907, 29908, 7, 7, 0, 0, 29908, 4450, 1, 0, 0, 0, 29909, 29910, 7, 12, 0, 0, 29910, 29911, 7, 5, 0, 0, 29911, 29912, 7, 6, 0, 0, 29912, 29913, 5, 95, 0, 0, 29913, 29914, 7, 14, 0, 0, 29914, 29915, 7, 6, 0, 0, 29915, 29916, 7, 3, 0, 0, 29916, 29917, 7, 17, 0, 0, 29917, 29918, 7, 6, 0, 0, 29918, 4452, 1, 0, 0, 0, 29919, 29920, 7, 12, 0, 0, 29920, 29921, 7, 5, 0, 0, 29921, 29922, 7, 6, 0, 0, 29922, 29923, 5, 95, 0, 0, 29923, 29924, 7, 7, 0, 0, 29924, 29925, 7, 11, 0, 0, 29925, 4454, 1, 0, 0, 0, 29926, 29927, 7, 12, 0, 0, 29927, 29928, 7, 5, 0, 0, 29928, 29929, 7, 6, 0, 0, 29929, 29930, 5, 95, 0, 0, 29930, 29931, 7, 7, 0, 0, 29931, 29932, 7, 11, 0, 0, 29932, 29933, 5, 95, 0, 0, 29933, 29934, 7, 22, 0, 0, 29934, 29935, 7, 10, 0, 0, 29935, 29936, 7, 4, 0, 0, 29936, 29937, 7, 19, 0, 0, 29937, 29938, 5, 95, 0, 0, 29938, 29939, 7, 10, 0, 0, 29939, 29940, 7, 7, 0, 0, 29940, 29941, 7, 9, 0, 0, 29941, 29942, 7, 6, 0, 0, 29942, 29943, 7, 25, 0, 0, 29943, 4456, 1, 0, 0, 0, 29944, 29945, 7, 12, 0, 0, 29945, 29946, 7, 5, 0, 0, 29946, 29947, 7, 6, 0, 0, 29947, 29948, 5, 95, 0, 0, 29948, 29949, 7, 15, 0, 0, 29949, 29950, 7, 3, 0, 0, 29950, 29951, 7, 10, 0, 0, 29951, 29952, 7, 13, 0, 0, 29952, 29953, 7, 0, 0, 0, 29953, 29954, 7, 4, 0, 0, 29954, 29955, 7, 6, 0, 0, 29955, 29956, 5, 95, 0, 0, 29956, 29957, 7, 2, 0, 0, 29957, 29958, 7, 12, 0, 0, 29958, 29959, 7, 4, 0, 0, 29959, 29960, 7, 11, 0, 0, 29960, 29961, 7, 10, 0, 0, 29961, 29962, 7, 7, 0, 0, 29962, 29963, 7, 6, 0, 0, 29963, 29964, 7, 5, 0, 0, 29964, 4458, 1, 0, 0, 0, 29965, 29966, 7, 12, 0, 0, 29966, 29967, 7, 5, 0, 0, 29967, 29968, 7, 6, 0, 0, 29968, 29969, 7, 3, 0, 0, 29969, 29970, 5, 95, 0, 0, 29970, 29971, 7, 9, 0, 0, 29971, 29972, 7, 0, 0, 0, 29972, 29973, 7, 4, 0, 0, 29973, 29974, 7, 0, 0, 0, 29974, 4460, 1, 0, 0, 0, 29975, 29976, 7, 12, 0, 0, 29976, 29977, 7, 5, 0, 0, 29977, 29978, 7, 6, 0, 0, 29978, 29979, 7, 3, 0, 0, 29979, 29980, 5, 95, 0, 0, 29980, 29981, 7, 9, 0, 0, 29981, 29982, 7, 6, 0, 0, 29982, 29983, 7, 16, 0, 0, 29983, 29984, 7, 10, 0, 0, 29984, 29985, 7, 7, 0, 0, 29985, 29986, 7, 6, 0, 0, 29986, 29987, 7, 9, 0, 0, 29987, 4462, 1, 0, 0, 0, 29988, 29989, 7, 12, 0, 0, 29989, 29990, 7, 5, 0, 0, 29990, 29991, 7, 6, 0, 0, 29991, 29992, 7, 3, 0, 0, 29992, 29993, 7, 6, 0, 0, 29993, 29994, 7, 7, 0, 0, 29994, 29995, 7, 13, 0, 0, 29995, 4464, 1, 0, 0, 0, 29996, 29997, 7, 12, 0, 0, 29997, 29998, 7, 5, 0, 0, 29998, 29999, 7, 6, 0, 0, 29999, 30000, 7, 3, 0, 0, 30000, 30001, 7, 17, 0, 0, 30001, 30002, 7, 3, 0, 0, 30002, 30003, 7, 2, 0, 0, 30003, 30004, 7, 12, 0, 0, 30004, 30005, 7, 15, 0, 0, 30005, 4466, 1, 0, 0, 0, 30006, 30007, 7, 12, 0, 0, 30007, 30008, 7, 5, 0, 0, 30008, 30009, 7, 6, 0, 0, 30009, 30010, 7, 3, 0, 0, 30010, 30011, 5, 95, 0, 0, 30011, 30012, 7, 3, 0, 0, 30012, 30013, 7, 6, 0, 0, 30013, 30014, 7, 8, 0, 0, 30014, 30015, 7, 18, 0, 0, 30015, 30016, 7, 8, 0, 0, 30016, 30017, 7, 11, 0, 0, 30017, 30018, 7, 6, 0, 0, 30018, 30019, 7, 1, 0, 0, 30019, 30020, 7, 10, 0, 0, 30020, 30021, 7, 7, 0, 0, 30021, 4468, 1, 0, 0, 0, 30022, 30023, 7, 12, 0, 0, 30023, 30024, 7, 5, 0, 0, 30024, 30025, 7, 6, 0, 0, 30025, 30026, 7, 3, 0, 0, 30026, 30027, 7, 5, 0, 0, 30027, 4470, 1, 0, 0, 0, 30028, 30029, 7, 12, 0, 0, 30029, 30030, 7, 5, 0, 0, 30030, 30031, 7, 6, 0, 0, 30031, 30032, 7, 3, 0, 0, 30032, 30033, 5, 95, 0, 0, 30033, 30034, 7, 4, 0, 0, 30034, 30035, 7, 0, 0, 0, 30035, 30036, 7, 1, 0, 0, 30036, 30037, 7, 11, 0, 0, 30037, 30038, 7, 6, 0, 0, 30038, 30039, 7, 5, 0, 0, 30039, 30040, 7, 15, 0, 0, 30040, 30041, 7, 0, 0, 0, 30041, 30042, 7, 8, 0, 0, 30042, 30043, 7, 6, 0, 0, 30043, 30044, 7, 5, 0, 0, 30044, 4472, 1, 0, 0, 0, 30045, 30046, 7, 12, 0, 0, 30046, 30047, 7, 5, 0, 0, 30047, 30048, 7, 6, 0, 0, 30048, 30049, 7, 3, 0, 0, 30049, 4474, 1, 0, 0, 0, 30050, 30051, 7, 12, 0, 0, 30051, 30052, 7, 5, 0, 0, 30052, 30053, 7, 6, 0, 0, 30053, 30054, 5, 95, 0, 0, 30054, 30055, 7, 5, 0, 0, 30055, 30056, 7, 6, 0, 0, 30056, 30057, 7, 14, 0, 0, 30057, 30058, 7, 10, 0, 0, 30058, 4476, 1, 0, 0, 0, 30059, 30060, 7, 12, 0, 0, 30060, 30061, 7, 5, 0, 0, 30061, 30062, 7, 6, 0, 0, 30062, 30063, 5, 95, 0, 0, 30063, 30064, 7, 5, 0, 0, 30064, 30065, 7, 4, 0, 0, 30065, 30066, 7, 2, 0, 0, 30066, 30067, 7, 3, 0, 0, 30067, 30068, 7, 6, 0, 0, 30068, 30069, 7, 9, 0, 0, 30069, 30070, 5, 95, 0, 0, 30070, 30071, 7, 2, 0, 0, 30071, 30072, 7, 12, 0, 0, 30072, 30073, 7, 4, 0, 0, 30073, 30074, 7, 11, 0, 0, 30074, 30075, 7, 10, 0, 0, 30075, 30076, 7, 7, 0, 0, 30076, 30077, 7, 6, 0, 0, 30077, 30078, 7, 5, 0, 0, 30078, 4478, 1, 0, 0, 0, 30079, 30080, 7, 12, 0, 0, 30080, 30081, 7, 5, 0, 0, 30081, 30082, 7, 6, 0, 0, 30082, 30083, 5, 95, 0, 0, 30083, 30084, 7, 4, 0, 0, 30084, 30085, 7, 4, 0, 0, 30085, 30086, 7, 4, 0, 0, 30086, 30087, 5, 95, 0, 0, 30087, 30088, 7, 16, 0, 0, 30088, 30089, 7, 2, 0, 0, 30089, 30090, 7, 3, 0, 0, 30090, 30091, 5, 95, 0, 0, 30091, 30092, 7, 17, 0, 0, 30092, 30093, 7, 5, 0, 0, 30093, 30094, 7, 6, 0, 0, 30094, 30095, 7, 4, 0, 0, 30095, 30096, 7, 5, 0, 0, 30096, 4480, 1, 0, 0, 0, 30097, 30098, 7, 12, 0, 0, 30098, 30099, 7, 5, 0, 0, 30099, 30100, 7, 6, 0, 0, 30100, 4482, 1, 0, 0, 0, 30101, 30102, 7, 12, 0, 0, 30102, 30103, 7, 5, 0, 0, 30103, 30104, 7, 6, 0, 0, 30104, 30105, 5, 95, 0, 0, 30105, 30106, 7, 13, 0, 0, 30106, 30107, 7, 6, 0, 0, 30107, 30108, 7, 8, 0, 0, 30108, 30109, 7, 4, 0, 0, 30109, 30110, 7, 2, 0, 0, 30110, 30111, 7, 3, 0, 0, 30111, 30112, 5, 95, 0, 0, 30112, 30113, 7, 0, 0, 0, 30113, 30114, 7, 17, 0, 0, 30114, 30115, 7, 17, 0, 0, 30115, 30116, 7, 3, 0, 0, 30116, 30117, 7, 6, 0, 0, 30117, 30118, 7, 17, 0, 0, 30118, 30119, 7, 0, 0, 0, 30119, 30120, 7, 4, 0, 0, 30120, 30121, 7, 10, 0, 0, 30121, 30122, 7, 2, 0, 0, 30122, 30123, 7, 7, 0, 0, 30123, 4484, 1, 0, 0, 0, 30124, 30125, 7, 12, 0, 0, 30125, 30126, 7, 5, 0, 0, 30126, 30127, 7, 6, 0, 0, 30127, 30128, 5, 95, 0, 0, 30128, 30129, 7, 22, 0, 0, 30129, 30130, 7, 6, 0, 0, 30130, 30131, 7, 0, 0, 0, 30131, 30132, 7, 21, 0, 0, 30132, 30133, 5, 95, 0, 0, 30133, 30134, 7, 7, 0, 0, 30134, 30135, 7, 0, 0, 0, 30135, 30136, 7, 14, 0, 0, 30136, 30137, 7, 6, 0, 0, 30137, 30138, 5, 95, 0, 0, 30138, 30139, 7, 3, 0, 0, 30139, 30140, 7, 6, 0, 0, 30140, 30141, 7, 5, 0, 0, 30141, 30142, 7, 11, 0, 0, 30142, 4486, 1, 0, 0, 0, 30143, 30144, 7, 12, 0, 0, 30144, 30145, 7, 5, 0, 0, 30145, 30146, 7, 10, 0, 0, 30146, 30147, 7, 7, 0, 0, 30147, 30148, 7, 17, 0, 0, 30148, 30149, 5, 95, 0, 0, 30149, 30150, 7, 7, 0, 0, 30150, 30151, 7, 2, 0, 0, 30151, 30152, 5, 95, 0, 0, 30152, 30153, 7, 6, 0, 0, 30153, 30154, 7, 25, 0, 0, 30154, 30155, 7, 15, 0, 0, 30155, 30156, 7, 0, 0, 0, 30156, 30157, 7, 7, 0, 0, 30157, 30158, 7, 9, 0, 0, 30158, 4488, 1, 0, 0, 0, 30159, 30160, 7, 12, 0, 0, 30160, 30161, 7, 5, 0, 0, 30161, 30162, 7, 10, 0, 0, 30162, 30163, 7, 7, 0, 0, 30163, 30164, 7, 17, 0, 0, 30164, 30165, 5, 95, 0, 0, 30165, 30166, 7, 7, 0, 0, 30166, 30167, 7, 11, 0, 0, 30167, 30168, 7, 5, 0, 0, 30168, 30169, 5, 95, 0, 0, 30169, 30170, 7, 8, 0, 0, 30170, 30171, 7, 2, 0, 0, 30171, 30172, 7, 14, 0, 0, 30172, 30173, 7, 15, 0, 0, 30173, 4490, 1, 0, 0, 0, 30174, 30175, 7, 12, 0, 0, 30175, 30176, 7, 5, 0, 0, 30176, 30177, 7, 10, 0, 0, 30177, 30178, 7, 7, 0, 0, 30178, 30179, 7, 17, 0, 0, 30179, 4492, 1, 0, 0, 0, 30180, 30181, 7, 12, 0, 0, 30181, 30182, 7, 4, 0, 0, 30182, 30183, 7, 16, 0, 0, 30183, 30184, 5, 49, 0, 0, 30184, 30185, 5, 54, 0, 0, 30185, 30186, 7, 1, 0, 0, 30186, 30187, 7, 6, 0, 0, 30187, 4494, 1, 0, 0, 0, 30188, 30189, 7, 12, 0, 0, 30189, 30190, 7, 4, 0, 0, 30190, 30191, 7, 16, 0, 0, 30191, 30192, 5, 49, 0, 0, 30192, 30193, 5, 54, 0, 0, 30193, 30194, 7, 11, 0, 0, 30194, 30195, 7, 6, 0, 0, 30195, 4496, 1, 0, 0, 0, 30196, 30197, 7, 12, 0, 0, 30197, 30198, 7, 4, 0, 0, 30198, 30199, 7, 16, 0, 0, 30199, 30200, 5, 51, 0, 0, 30200, 30201, 5, 50, 0, 0, 30201, 4498, 1, 0, 0, 0, 30202, 30203, 7, 12, 0, 0, 30203, 30204, 7, 4, 0, 0, 30204, 30205, 7, 16, 0, 0, 30205, 30206, 5, 56, 0, 0, 30206, 4500, 1, 0, 0, 0, 30207, 30208, 7, 13, 0, 0, 30208, 30209, 5, 49, 0, 0, 30209, 4502, 1, 0, 0, 0, 30210, 30211, 7, 13, 0, 0, 30211, 30212, 5, 50, 0, 0, 30212, 4504, 1, 0, 0, 0, 30213, 30214, 7, 13, 0, 0, 30214, 30215, 7, 0, 0, 0, 30215, 30216, 7, 11, 0, 0, 30216, 30217, 7, 10, 0, 0, 30217, 30218, 7, 9, 0, 0, 30218, 30219, 7, 0, 0, 0, 30219, 30220, 7, 4, 0, 0, 30220, 30221, 7, 6, 0, 0, 30221, 4506, 1, 0, 0, 0, 30222, 30223, 7, 13, 0, 0, 30223, 30224, 7, 0, 0, 0, 30224, 30225, 7, 11, 0, 0, 30225, 30226, 7, 10, 0, 0, 30226, 30227, 7, 9, 0, 0, 30227, 30228, 7, 0, 0, 0, 30228, 30229, 7, 4, 0, 0, 30229, 30230, 7, 6, 0, 0, 30230, 30231, 5, 95, 0, 0, 30231, 30232, 7, 8, 0, 0, 30232, 30233, 7, 2, 0, 0, 30233, 30234, 7, 7, 0, 0, 30234, 30235, 7, 13, 0, 0, 30235, 30236, 7, 6, 0, 0, 30236, 30237, 7, 3, 0, 0, 30237, 30238, 7, 5, 0, 0, 30238, 30239, 7, 10, 0, 0, 30239, 30240, 7, 2, 0, 0, 30240, 30241, 7, 7, 0, 0, 30241, 4508, 1, 0, 0, 0, 30242, 30243, 7, 13, 0, 0, 30243, 30244, 7, 0, 0, 0, 30244, 30245, 7, 11, 0, 0, 30245, 30246, 7, 10, 0, 0, 30246, 30247, 7, 9, 0, 0, 30247, 30248, 7, 0, 0, 0, 30248, 30249, 7, 4, 0, 0, 30249, 30250, 7, 10, 0, 0, 30250, 30251, 7, 2, 0, 0, 30251, 30252, 7, 7, 0, 0, 30252, 4510, 1, 0, 0, 0, 30253, 30254, 7, 13, 0, 0, 30254, 30255, 7, 0, 0, 0, 30255, 30256, 7, 11, 0, 0, 30256, 30257, 7, 10, 0, 0, 30257, 30258, 7, 9, 0, 0, 30258, 30259, 5, 95, 0, 0, 30259, 30260, 7, 4, 0, 0, 30260, 30261, 7, 10, 0, 0, 30261, 30262, 7, 14, 0, 0, 30262, 30263, 7, 6, 0, 0, 30263, 30264, 5, 95, 0, 0, 30264, 30265, 7, 6, 0, 0, 30265, 30266, 7, 7, 0, 0, 30266, 30267, 7, 9, 0, 0, 30267, 4512, 1, 0, 0, 0, 30268, 30269, 7, 13, 0, 0, 30269, 30270, 7, 0, 0, 0, 30270, 30271, 7, 11, 0, 0, 30271, 30272, 7, 12, 0, 0, 30272, 30273, 7, 6, 0, 0, 30273, 30274, 7, 5, 0, 0, 30274, 4514, 1, 0, 0, 0, 30275, 30276, 7, 13, 0, 0, 30276, 30277, 7, 0, 0, 0, 30277, 30278, 7, 11, 0, 0, 30278, 30279, 7, 12, 0, 0, 30279, 30280, 7, 6, 0, 0, 30280, 4516, 1, 0, 0, 0, 30281, 30282, 7, 13, 0, 0, 30282, 30283, 7, 0, 0, 0, 30283, 30284, 7, 3, 0, 0, 30284, 30285, 7, 8, 0, 0, 30285, 30286, 7, 19, 0, 0, 30286, 30287, 7, 0, 0, 0, 30287, 30288, 7, 3, 0, 0, 30288, 30289, 5, 50, 0, 0, 30289, 4518, 1, 0, 0, 0, 30290, 30291, 7, 13, 0, 0, 30291, 30292, 7, 0, 0, 0, 30292, 30293, 7, 3, 0, 0, 30293, 30294, 7, 8, 0, 0, 30294, 30295, 7, 19, 0, 0, 30295, 30296, 7, 0, 0, 0, 30296, 30297, 7, 3, 0, 0, 30297, 4520, 1, 0, 0, 0, 30298, 30299, 7, 13, 0, 0, 30299, 30300, 7, 0, 0, 0, 30300, 30301, 7, 3, 0, 0, 30301, 30302, 7, 8, 0, 0, 30302, 30303, 7, 19, 0, 0, 30303, 30304, 7, 0, 0, 0, 30304, 30305, 7, 3, 0, 0, 30305, 30306, 7, 8, 0, 0, 30306, 4522, 1, 0, 0, 0, 30307, 30308, 7, 13, 0, 0, 30308, 30309, 7, 0, 0, 0, 30309, 30310, 7, 3, 0, 0, 30310, 30311, 7, 10, 0, 0, 30311, 30312, 7, 0, 0, 0, 30312, 30313, 7, 1, 0, 0, 30313, 30314, 7, 11, 0, 0, 30314, 30315, 7, 6, 0, 0, 30315, 4524, 1, 0, 0, 0, 30316, 30317, 7, 13, 0, 0, 30317, 30318, 7, 0, 0, 0, 30318, 30319, 7, 3, 0, 0, 30319, 30320, 7, 3, 0, 0, 30320, 30321, 7, 0, 0, 0, 30321, 30322, 7, 22, 0, 0, 30322, 4526, 1, 0, 0, 0, 30323, 30324, 7, 13, 0, 0, 30324, 30325, 7, 0, 0, 0, 30325, 30326, 7, 3, 0, 0, 30326, 30327, 7, 3, 0, 0, 30327, 30328, 7, 0, 0, 0, 30328, 30329, 7, 22, 0, 0, 30329, 30330, 7, 8, 0, 0, 30330, 4528, 1, 0, 0, 0, 30331, 30332, 7, 13, 0, 0, 30332, 30333, 7, 0, 0, 0, 30333, 30334, 7, 3, 0, 0, 30334, 30335, 5, 95, 0, 0, 30335, 30336, 7, 15, 0, 0, 30336, 30337, 7, 2, 0, 0, 30337, 30338, 7, 15, 0, 0, 30338, 4530, 1, 0, 0, 0, 30339, 30340, 7, 13, 0, 0, 30340, 30341, 7, 0, 0, 0, 30341, 30342, 7, 3, 0, 0, 30342, 30343, 7, 3, 0, 0, 30343, 30344, 7, 0, 0, 0, 30344, 30345, 7, 18, 0, 0, 30345, 30346, 7, 5, 0, 0, 30346, 4532, 1, 0, 0, 0, 30347, 30348, 7, 13, 0, 0, 30348, 30349, 7, 0, 0, 0, 30349, 30350, 7, 3, 0, 0, 30350, 30351, 7, 3, 0, 0, 30351, 30352, 7, 0, 0, 0, 30352, 30353, 7, 18, 0, 0, 30353, 4534, 1, 0, 0, 0, 30354, 30355, 7, 13, 0, 0, 30355, 30356, 7, 0, 0, 0, 30356, 30357, 7, 3, 0, 0, 30357, 30358, 5, 95, 0, 0, 30358, 30359, 7, 5, 0, 0, 30359, 30360, 7, 0, 0, 0, 30360, 30361, 7, 14, 0, 0, 30361, 30362, 7, 15, 0, 0, 30362, 4536, 1, 0, 0, 0, 30363, 30364, 7, 13, 0, 0, 30364, 30365, 7, 0, 0, 0, 30365, 30366, 7, 3, 0, 0, 30366, 30367, 7, 18, 0, 0, 30367, 30368, 7, 10, 0, 0, 30368, 30369, 7, 7, 0, 0, 30369, 30370, 7, 17, 0, 0, 30370, 4538, 1, 0, 0, 0, 30371, 30372, 7, 13, 0, 0, 30372, 30373, 7, 6, 0, 0, 30373, 30374, 7, 8, 0, 0, 30374, 30375, 7, 4, 0, 0, 30375, 30376, 7, 2, 0, 0, 30376, 30377, 7, 3, 0, 0, 30377, 30378, 5, 95, 0, 0, 30378, 30379, 7, 3, 0, 0, 30379, 30380, 7, 6, 0, 0, 30380, 30381, 7, 0, 0, 0, 30381, 30382, 7, 9, 0, 0, 30382, 30383, 5, 95, 0, 0, 30383, 30384, 7, 4, 0, 0, 30384, 30385, 7, 3, 0, 0, 30385, 30386, 7, 0, 0, 0, 30386, 30387, 7, 8, 0, 0, 30387, 30388, 7, 6, 0, 0, 30388, 4540, 1, 0, 0, 0, 30389, 30390, 7, 13, 0, 0, 30390, 30391, 7, 6, 0, 0, 30391, 30392, 7, 8, 0, 0, 30392, 30393, 7, 4, 0, 0, 30393, 30394, 7, 2, 0, 0, 30394, 30395, 7, 3, 0, 0, 30395, 30396, 5, 95, 0, 0, 30396, 30397, 7, 3, 0, 0, 30397, 30398, 7, 6, 0, 0, 30398, 30399, 7, 0, 0, 0, 30399, 30400, 7, 9, 0, 0, 30400, 4542, 1, 0, 0, 0, 30401, 30402, 7, 13, 0, 0, 30402, 30403, 7, 6, 0, 0, 30403, 30404, 7, 8, 0, 0, 30404, 30405, 7, 4, 0, 0, 30405, 30406, 7, 2, 0, 0, 30406, 30407, 7, 3, 0, 0, 30407, 30408, 5, 95, 0, 0, 30408, 30409, 7, 4, 0, 0, 30409, 30410, 7, 3, 0, 0, 30410, 30411, 7, 0, 0, 0, 30411, 30412, 7, 7, 0, 0, 30412, 30413, 7, 5, 0, 0, 30413, 30414, 7, 16, 0, 0, 30414, 30415, 7, 2, 0, 0, 30415, 30416, 7, 3, 0, 0, 30416, 30417, 7, 14, 0, 0, 30417, 30418, 5, 95, 0, 0, 30418, 30419, 7, 9, 0, 0, 30419, 30420, 7, 10, 0, 0, 30420, 30421, 7, 14, 0, 0, 30421, 30422, 7, 5, 0, 0, 30422, 4544, 1, 0, 0, 0, 30423, 30424, 7, 13, 0, 0, 30424, 30425, 7, 6, 0, 0, 30425, 30426, 7, 8, 0, 0, 30426, 30427, 7, 4, 0, 0, 30427, 30428, 7, 2, 0, 0, 30428, 30429, 7, 3, 0, 0, 30429, 30430, 5, 95, 0, 0, 30430, 30431, 7, 4, 0, 0, 30431, 30432, 7, 3, 0, 0, 30432, 30433, 7, 0, 0, 0, 30433, 30434, 7, 7, 0, 0, 30434, 30435, 7, 5, 0, 0, 30435, 30436, 7, 16, 0, 0, 30436, 30437, 7, 2, 0, 0, 30437, 30438, 7, 3, 0, 0, 30438, 30439, 7, 14, 0, 0, 30439, 30440, 5, 95, 0, 0, 30440, 30441, 7, 16, 0, 0, 30441, 30442, 7, 0, 0, 0, 30442, 30443, 7, 8, 0, 0, 30443, 30444, 7, 4, 0, 0, 30444, 4546, 1, 0, 0, 0, 30445, 30446, 7, 13, 0, 0, 30446, 30447, 7, 6, 0, 0, 30447, 30448, 7, 8, 0, 0, 30448, 30449, 7, 4, 0, 0, 30449, 30450, 7, 2, 0, 0, 30450, 30451, 7, 3, 0, 0, 30451, 30452, 5, 95, 0, 0, 30452, 30453, 7, 4, 0, 0, 30453, 30454, 7, 3, 0, 0, 30454, 30455, 7, 0, 0, 0, 30455, 30456, 7, 7, 0, 0, 30456, 30457, 7, 5, 0, 0, 30457, 30458, 7, 16, 0, 0, 30458, 30459, 7, 2, 0, 0, 30459, 30460, 7, 3, 0, 0, 30460, 30461, 7, 14, 0, 0, 30461, 4548, 1, 0, 0, 0, 30462, 30463, 7, 13, 0, 0, 30463, 30464, 7, 6, 0, 0, 30464, 30465, 7, 3, 0, 0, 30465, 30466, 7, 10, 0, 0, 30466, 30467, 7, 16, 0, 0, 30467, 30468, 7, 10, 0, 0, 30468, 30469, 7, 6, 0, 0, 30469, 30470, 7, 3, 0, 0, 30470, 4550, 1, 0, 0, 0, 30471, 30472, 7, 13, 0, 0, 30472, 30473, 7, 6, 0, 0, 30473, 30474, 7, 3, 0, 0, 30474, 30475, 7, 10, 0, 0, 30475, 30476, 7, 16, 0, 0, 30476, 30477, 7, 18, 0, 0, 30477, 4552, 1, 0, 0, 0, 30478, 30479, 7, 13, 0, 0, 30479, 30480, 7, 6, 0, 0, 30480, 30481, 7, 3, 0, 0, 30481, 30482, 7, 5, 0, 0, 30482, 30483, 7, 10, 0, 0, 30483, 30484, 7, 2, 0, 0, 30484, 30485, 7, 7, 0, 0, 30485, 30486, 7, 10, 0, 0, 30486, 30487, 7, 7, 0, 0, 30487, 30488, 7, 17, 0, 0, 30488, 4554, 1, 0, 0, 0, 30489, 30490, 7, 13, 0, 0, 30490, 30491, 7, 6, 0, 0, 30491, 30492, 7, 3, 0, 0, 30492, 30493, 7, 5, 0, 0, 30493, 30494, 7, 10, 0, 0, 30494, 30495, 7, 2, 0, 0, 30495, 30496, 7, 7, 0, 0, 30496, 30497, 7, 5, 0, 0, 30497, 30498, 5, 95, 0, 0, 30498, 30499, 7, 6, 0, 0, 30499, 30500, 7, 7, 0, 0, 30500, 30501, 7, 9, 0, 0, 30501, 30502, 7, 5, 0, 0, 30502, 30503, 7, 8, 0, 0, 30503, 30504, 7, 7, 0, 0, 30504, 4556, 1, 0, 0, 0, 30505, 30506, 7, 13, 0, 0, 30506, 30507, 7, 6, 0, 0, 30507, 30508, 7, 3, 0, 0, 30508, 30509, 7, 5, 0, 0, 30509, 30510, 7, 10, 0, 0, 30510, 30511, 7, 2, 0, 0, 30511, 30512, 7, 7, 0, 0, 30512, 30513, 7, 5, 0, 0, 30513, 30514, 5, 95, 0, 0, 30514, 30515, 7, 6, 0, 0, 30515, 30516, 7, 7, 0, 0, 30516, 30517, 7, 9, 0, 0, 30517, 30518, 7, 4, 0, 0, 30518, 30519, 7, 10, 0, 0, 30519, 30520, 7, 14, 0, 0, 30520, 30521, 7, 6, 0, 0, 30521, 4558, 1, 0, 0, 0, 30522, 30523, 7, 13, 0, 0, 30523, 30524, 7, 6, 0, 0, 30524, 30525, 7, 3, 0, 0, 30525, 30526, 7, 5, 0, 0, 30526, 30527, 7, 10, 0, 0, 30527, 30528, 7, 2, 0, 0, 30528, 30529, 7, 7, 0, 0, 30529, 30530, 7, 5, 0, 0, 30530, 30531, 5, 95, 0, 0, 30531, 30532, 7, 2, 0, 0, 30532, 30533, 7, 15, 0, 0, 30533, 30534, 7, 6, 0, 0, 30534, 30535, 7, 3, 0, 0, 30535, 30536, 7, 0, 0, 0, 30536, 30537, 7, 4, 0, 0, 30537, 30538, 7, 10, 0, 0, 30538, 30539, 7, 2, 0, 0, 30539, 30540, 7, 7, 0, 0, 30540, 4560, 1, 0, 0, 0, 30541, 30542, 7, 13, 0, 0, 30542, 30543, 7, 6, 0, 0, 30543, 30544, 7, 3, 0, 0, 30544, 30545, 7, 5, 0, 0, 30545, 30546, 7, 10, 0, 0, 30546, 30547, 7, 2, 0, 0, 30547, 30548, 7, 7, 0, 0, 30548, 30549, 7, 5, 0, 0, 30549, 30550, 5, 95, 0, 0, 30550, 30551, 7, 5, 0, 0, 30551, 30552, 7, 4, 0, 0, 30552, 30553, 7, 0, 0, 0, 30553, 30554, 7, 3, 0, 0, 30554, 30555, 7, 4, 0, 0, 30555, 30556, 7, 5, 0, 0, 30556, 30557, 7, 8, 0, 0, 30557, 30558, 7, 7, 0, 0, 30558, 4562, 1, 0, 0, 0, 30559, 30560, 7, 13, 0, 0, 30560, 30561, 7, 6, 0, 0, 30561, 30562, 7, 3, 0, 0, 30562, 30563, 7, 5, 0, 0, 30563, 30564, 7, 10, 0, 0, 30564, 30565, 7, 2, 0, 0, 30565, 30566, 7, 7, 0, 0, 30566, 30567, 7, 5, 0, 0, 30567, 30568, 5, 95, 0, 0, 30568, 30569, 7, 5, 0, 0, 30569, 30570, 7, 4, 0, 0, 30570, 30571, 7, 0, 0, 0, 30571, 30572, 7, 3, 0, 0, 30572, 30573, 7, 4, 0, 0, 30573, 30574, 7, 4, 0, 0, 30574, 30575, 7, 10, 0, 0, 30575, 30576, 7, 14, 0, 0, 30576, 30577, 7, 6, 0, 0, 30577, 4564, 1, 0, 0, 0, 30578, 30579, 7, 13, 0, 0, 30579, 30580, 7, 6, 0, 0, 30580, 30581, 7, 3, 0, 0, 30581, 30582, 7, 5, 0, 0, 30582, 30583, 7, 10, 0, 0, 30583, 30584, 7, 2, 0, 0, 30584, 30585, 7, 7, 0, 0, 30585, 30586, 7, 5, 0, 0, 30586, 4566, 1, 0, 0, 0, 30587, 30588, 7, 13, 0, 0, 30588, 30589, 7, 6, 0, 0, 30589, 30590, 7, 3, 0, 0, 30590, 30591, 7, 5, 0, 0, 30591, 30592, 7, 10, 0, 0, 30592, 30593, 7, 2, 0, 0, 30593, 30594, 7, 7, 0, 0, 30594, 30595, 7, 5, 0, 0, 30595, 30596, 5, 95, 0, 0, 30596, 30597, 7, 25, 0, 0, 30597, 30598, 7, 10, 0, 0, 30598, 30599, 7, 9, 0, 0, 30599, 4568, 1, 0, 0, 0, 30600, 30601, 7, 13, 0, 0, 30601, 30602, 7, 6, 0, 0, 30602, 30603, 7, 3, 0, 0, 30603, 30604, 7, 5, 0, 0, 30604, 30605, 7, 10, 0, 0, 30605, 30606, 7, 2, 0, 0, 30606, 30607, 7, 7, 0, 0, 30607, 4570, 1, 0, 0, 0, 30608, 30609, 7, 13, 0, 0, 30609, 30610, 7, 10, 0, 0, 30610, 30611, 7, 6, 0, 0, 30611, 30612, 7, 22, 0, 0, 30612, 4572, 1, 0, 0, 0, 30613, 30614, 7, 13, 0, 0, 30614, 30615, 7, 10, 0, 0, 30615, 30616, 7, 2, 0, 0, 30616, 30617, 7, 11, 0, 0, 30617, 30618, 7, 0, 0, 0, 30618, 30619, 7, 4, 0, 0, 30619, 30620, 7, 10, 0, 0, 30620, 30621, 7, 2, 0, 0, 30621, 30622, 7, 7, 0, 0, 30622, 4574, 1, 0, 0, 0, 30623, 30624, 7, 13, 0, 0, 30624, 30625, 7, 10, 0, 0, 30625, 30626, 7, 3, 0, 0, 30626, 30627, 7, 4, 0, 0, 30627, 30628, 7, 12, 0, 0, 30628, 30629, 7, 0, 0, 0, 30629, 30630, 7, 11, 0, 0, 30630, 4576, 1, 0, 0, 0, 30631, 30632, 7, 13, 0, 0, 30632, 30633, 7, 10, 0, 0, 30633, 30634, 7, 5, 0, 0, 30634, 30635, 7, 10, 0, 0, 30635, 30636, 7, 1, 0, 0, 30636, 30637, 7, 10, 0, 0, 30637, 30638, 7, 11, 0, 0, 30638, 30639, 7, 10, 0, 0, 30639, 30640, 7, 4, 0, 0, 30640, 30641, 7, 18, 0, 0, 30641, 4578, 1, 0, 0, 0, 30642, 30643, 7, 13, 0, 0, 30643, 30644, 7, 10, 0, 0, 30644, 30645, 7, 5, 0, 0, 30645, 30646, 7, 10, 0, 0, 30646, 30647, 7, 1, 0, 0, 30647, 30648, 7, 11, 0, 0, 30648, 30649, 7, 6, 0, 0, 30649, 4580, 1, 0, 0, 0, 30650, 30651, 7, 13, 0, 0, 30651, 30652, 7, 2, 0, 0, 30652, 30653, 7, 11, 0, 0, 30653, 30654, 7, 12, 0, 0, 30654, 30655, 7, 14, 0, 0, 30655, 30656, 7, 6, 0, 0, 30656, 4582, 1, 0, 0, 0, 30657, 30658, 7, 13, 0, 0, 30658, 30659, 7, 5, 0, 0, 30659, 30660, 7, 10, 0, 0, 30660, 30661, 7, 23, 0, 0, 30661, 30662, 7, 6, 0, 0, 30662, 4584, 1, 0, 0, 0, 30663, 30664, 7, 22, 0, 0, 30664, 30665, 7, 0, 0, 0, 30665, 30666, 7, 10, 0, 0, 30666, 30667, 7, 4, 0, 0, 30667, 4586, 1, 0, 0, 0, 30668, 30669, 7, 22, 0, 0, 30669, 30670, 7, 0, 0, 0, 30670, 30671, 7, 11, 0, 0, 30671, 30672, 7, 11, 0, 0, 30672, 30673, 7, 6, 0, 0, 30673, 30674, 7, 4, 0, 0, 30674, 4588, 1, 0, 0, 0, 30675, 30676, 7, 22, 0, 0, 30676, 30677, 7, 0, 0, 0, 30677, 30678, 7, 3, 0, 0, 30678, 30679, 7, 7, 0, 0, 30679, 30680, 7, 10, 0, 0, 30680, 30681, 7, 7, 0, 0, 30681, 30682, 7, 17, 0, 0, 30682, 4590, 1, 0, 0, 0, 30683, 30684, 7, 22, 0, 0, 30684, 30685, 7, 6, 0, 0, 30685, 30686, 7, 6, 0, 0, 30686, 30687, 7, 21, 0, 0, 30687, 30688, 7, 5, 0, 0, 30688, 4592, 1, 0, 0, 0, 30689, 30690, 7, 22, 0, 0, 30690, 30691, 7, 6, 0, 0, 30691, 30692, 7, 6, 0, 0, 30692, 30693, 7, 21, 0, 0, 30693, 4594, 1, 0, 0, 0, 30694, 30695, 7, 22, 0, 0, 30695, 30696, 7, 6, 0, 0, 30696, 30697, 7, 11, 0, 0, 30697, 30698, 7, 11, 0, 0, 30698, 30699, 7, 16, 0, 0, 30699, 30700, 7, 2, 0, 0, 30700, 30701, 7, 3, 0, 0, 30701, 30702, 7, 14, 0, 0, 30702, 30703, 7, 6, 0, 0, 30703, 30704, 7, 9, 0, 0, 30704, 4596, 1, 0, 0, 0, 30705, 30706, 7, 22, 0, 0, 30706, 30707, 7, 19, 0, 0, 30707, 30708, 7, 6, 0, 0, 30708, 30709, 7, 7, 0, 0, 30709, 30710, 7, 6, 0, 0, 30710, 30711, 7, 13, 0, 0, 30711, 30712, 7, 6, 0, 0, 30712, 30713, 7, 3, 0, 0, 30713, 4598, 1, 0, 0, 0, 30714, 30715, 7, 22, 0, 0, 30715, 30716, 7, 19, 0, 0, 30716, 30717, 7, 6, 0, 0, 30717, 30718, 7, 7, 0, 0, 30718, 4600, 1, 0, 0, 0, 30719, 30720, 7, 22, 0, 0, 30720, 30721, 7, 19, 0, 0, 30721, 30722, 7, 6, 0, 0, 30722, 30723, 7, 3, 0, 0, 30723, 30724, 7, 6, 0, 0, 30724, 4602, 1, 0, 0, 0, 30725, 30726, 7, 22, 0, 0, 30726, 30727, 7, 19, 0, 0, 30727, 30728, 7, 10, 0, 0, 30728, 30729, 7, 11, 0, 0, 30729, 30730, 7, 6, 0, 0, 30730, 4604, 1, 0, 0, 0, 30731, 30732, 7, 22, 0, 0, 30732, 30733, 7, 19, 0, 0, 30733, 30734, 7, 10, 0, 0, 30734, 30735, 7, 4, 0, 0, 30735, 30736, 7, 6, 0, 0, 30736, 30737, 7, 5, 0, 0, 30737, 30738, 7, 15, 0, 0, 30738, 30739, 7, 0, 0, 0, 30739, 30740, 7, 8, 0, 0, 30740, 30741, 7, 6, 0, 0, 30741, 4606, 1, 0, 0, 0, 30742, 30743, 7, 22, 0, 0, 30743, 30744, 7, 10, 0, 0, 30744, 30745, 7, 9, 0, 0, 30745, 30746, 7, 4, 0, 0, 30746, 30747, 7, 19, 0, 0, 30747, 30748, 5, 95, 0, 0, 30748, 30749, 7, 1, 0, 0, 30749, 30750, 7, 12, 0, 0, 30750, 30751, 7, 8, 0, 0, 30751, 30752, 7, 21, 0, 0, 30752, 30753, 7, 6, 0, 0, 30753, 30754, 7, 4, 0, 0, 30754, 4608, 1, 0, 0, 0, 30755, 30756, 7, 22, 0, 0, 30756, 30757, 7, 10, 0, 0, 30757, 30758, 7, 4, 0, 0, 30758, 30759, 7, 19, 0, 0, 30759, 30760, 7, 10, 0, 0, 30760, 30761, 7, 7, 0, 0, 30761, 4610, 1, 0, 0, 0, 30762, 30763, 7, 22, 0, 0, 30763, 30764, 7, 10, 0, 0, 30764, 30765, 7, 4, 0, 0, 30765, 30766, 7, 19, 0, 0, 30766, 30767, 7, 2, 0, 0, 30767, 30768, 7, 12, 0, 0, 30768, 30769, 7, 4, 0, 0, 30769, 4612, 1, 0, 0, 0, 30770, 30771, 7, 22, 0, 0, 30771, 30772, 7, 10, 0, 0, 30772, 30773, 7, 4, 0, 0, 30773, 30774, 7, 19, 0, 0, 30774, 30775, 5, 95, 0, 0, 30775, 30776, 7, 15, 0, 0, 30776, 30777, 7, 11, 0, 0, 30777, 30778, 7, 5, 0, 0, 30778, 30779, 7, 24, 0, 0, 30779, 30780, 7, 11, 0, 0, 30780, 4614, 1, 0, 0, 0, 30781, 30782, 7, 22, 0, 0, 30782, 30783, 7, 10, 0, 0, 30783, 30784, 7, 4, 0, 0, 30784, 30785, 7, 19, 0, 0, 30785, 4616, 1, 0, 0, 0, 30786, 30787, 7, 22, 0, 0, 30787, 30788, 7, 2, 0, 0, 30788, 30789, 7, 3, 0, 0, 30789, 30790, 7, 21, 0, 0, 30790, 4618, 1, 0, 0, 0, 30791, 30792, 7, 22, 0, 0, 30792, 30793, 7, 2, 0, 0, 30793, 30794, 7, 3, 0, 0, 30794, 30795, 7, 21, 0, 0, 30795, 30796, 7, 6, 0, 0, 30796, 30797, 7, 3, 0, 0, 30797, 30798, 7, 10, 0, 0, 30798, 30799, 7, 9, 0, 0, 30799, 4620, 1, 0, 0, 0, 30800, 30801, 7, 22, 0, 0, 30801, 30802, 7, 3, 0, 0, 30802, 30803, 7, 0, 0, 0, 30803, 30804, 7, 15, 0, 0, 30804, 30805, 7, 15, 0, 0, 30805, 30806, 7, 6, 0, 0, 30806, 30807, 7, 9, 0, 0, 30807, 4622, 1, 0, 0, 0, 30808, 30809, 7, 22, 0, 0, 30809, 30810, 7, 3, 0, 0, 30810, 30811, 7, 0, 0, 0, 30811, 30812, 7, 15, 0, 0, 30812, 30813, 7, 15, 0, 0, 30813, 30814, 7, 6, 0, 0, 30814, 30815, 7, 3, 0, 0, 30815, 4624, 1, 0, 0, 0, 30816, 30817, 7, 22, 0, 0, 30817, 30818, 7, 3, 0, 0, 30818, 30819, 7, 10, 0, 0, 30819, 30820, 7, 4, 0, 0, 30820, 30821, 7, 6, 0, 0, 30821, 4626, 1, 0, 0, 0, 30822, 30823, 7, 25, 0, 0, 30823, 30824, 7, 9, 0, 0, 30824, 30825, 7, 1, 0, 0, 30825, 30826, 5, 95, 0, 0, 30826, 30827, 7, 16, 0, 0, 30827, 30828, 7, 0, 0, 0, 30828, 30829, 7, 5, 0, 0, 30829, 30830, 7, 4, 0, 0, 30830, 30831, 7, 15, 0, 0, 30831, 30832, 7, 0, 0, 0, 30832, 30833, 7, 4, 0, 0, 30833, 30834, 7, 19, 0, 0, 30834, 30835, 5, 95, 0, 0, 30835, 30836, 7, 10, 0, 0, 30836, 30837, 7, 7, 0, 0, 30837, 30838, 7, 5, 0, 0, 30838, 30839, 7, 6, 0, 0, 30839, 30840, 7, 3, 0, 0, 30840, 30841, 7, 4, 0, 0, 30841, 4628, 1, 0, 0, 0, 30842, 30843, 7, 25, 0, 0, 30843, 30844, 7, 9, 0, 0, 30844, 30845, 7, 1, 0, 0, 30845, 4630, 1, 0, 0, 0, 30846, 30847, 7, 25, 0, 0, 30847, 30848, 5, 95, 0, 0, 30848, 30849, 7, 9, 0, 0, 30849, 30850, 7, 18, 0, 0, 30850, 30851, 7, 7, 0, 0, 30851, 30852, 5, 95, 0, 0, 30852, 30853, 7, 15, 0, 0, 30853, 30854, 7, 3, 0, 0, 30854, 30855, 7, 12, 0, 0, 30855, 30856, 7, 7, 0, 0, 30856, 30857, 7, 6, 0, 0, 30857, 4632, 1, 0, 0, 0, 30858, 30859, 7, 25, 0, 0, 30859, 30860, 7, 10, 0, 0, 30860, 30861, 7, 9, 0, 0, 30861, 4634, 1, 0, 0, 0, 30862, 30863, 7, 25, 0, 0, 30863, 30864, 7, 14, 0, 0, 30864, 30865, 7, 11, 0, 0, 30865, 30866, 5, 50, 0, 0, 30866, 30867, 7, 2, 0, 0, 30867, 30868, 7, 1, 0, 0, 30868, 30869, 7, 20, 0, 0, 30869, 30870, 7, 6, 0, 0, 30870, 30871, 7, 8, 0, 0, 30871, 30872, 7, 4, 0, 0, 30872, 4636, 1, 0, 0, 0, 30873, 30874, 7, 25, 0, 0, 30874, 30875, 7, 14, 0, 0, 30875, 30876, 7, 11, 0, 0, 30876, 30877, 7, 0, 0, 0, 30877, 30878, 7, 17, 0, 0, 30878, 30879, 7, 17, 0, 0, 30879, 4638, 1, 0, 0, 0, 30880, 30881, 7, 25, 0, 0, 30881, 30882, 7, 14, 0, 0, 30882, 30883, 7, 11, 0, 0, 30883, 30884, 7, 0, 0, 0, 30884, 30885, 7, 4, 0, 0, 30885, 30886, 7, 4, 0, 0, 30886, 30887, 7, 3, 0, 0, 30887, 30888, 7, 10, 0, 0, 30888, 30889, 7, 1, 0, 0, 30889, 30890, 7, 12, 0, 0, 30890, 30891, 7, 4, 0, 0, 30891, 30892, 7, 6, 0, 0, 30892, 30893, 7, 5, 0, 0, 30893, 4640, 1, 0, 0, 0, 30894, 30895, 7, 25, 0, 0, 30895, 30896, 7, 14, 0, 0, 30896, 30897, 7, 11, 0, 0, 30897, 30898, 7, 8, 0, 0, 30898, 30899, 7, 0, 0, 0, 30899, 30900, 7, 5, 0, 0, 30900, 30901, 7, 4, 0, 0, 30901, 4642, 1, 0, 0, 0, 30902, 30903, 7, 25, 0, 0, 30903, 30904, 7, 14, 0, 0, 30904, 30905, 7, 11, 0, 0, 30905, 30906, 7, 8, 0, 0, 30906, 30907, 7, 9, 0, 0, 30907, 30908, 7, 0, 0, 0, 30908, 30909, 7, 4, 0, 0, 30909, 30910, 7, 0, 0, 0, 30910, 4644, 1, 0, 0, 0, 30911, 30912, 7, 25, 0, 0, 30912, 30913, 7, 14, 0, 0, 30913, 30914, 7, 11, 0, 0, 30914, 30915, 7, 8, 0, 0, 30915, 30916, 7, 2, 0, 0, 30916, 30917, 7, 11, 0, 0, 30917, 30918, 7, 0, 0, 0, 30918, 30919, 7, 4, 0, 0, 30919, 30920, 7, 4, 0, 0, 30920, 30921, 7, 13, 0, 0, 30921, 30922, 7, 0, 0, 0, 30922, 30923, 7, 11, 0, 0, 30923, 4646, 1, 0, 0, 0, 30924, 30925, 7, 25, 0, 0, 30925, 30926, 7, 14, 0, 0, 30926, 30927, 7, 11, 0, 0, 30927, 30928, 7, 8, 0, 0, 30928, 30929, 7, 2, 0, 0, 30929, 30930, 7, 14, 0, 0, 30930, 30931, 7, 14, 0, 0, 30931, 30932, 7, 6, 0, 0, 30932, 30933, 7, 7, 0, 0, 30933, 30934, 7, 4, 0, 0, 30934, 4648, 1, 0, 0, 0, 30935, 30936, 7, 25, 0, 0, 30936, 30937, 7, 14, 0, 0, 30937, 30938, 7, 11, 0, 0, 30938, 30939, 7, 8, 0, 0, 30939, 30940, 7, 2, 0, 0, 30940, 30941, 7, 7, 0, 0, 30941, 30942, 7, 8, 0, 0, 30942, 30943, 7, 0, 0, 0, 30943, 30944, 7, 4, 0, 0, 30944, 4650, 1, 0, 0, 0, 30945, 30946, 7, 25, 0, 0, 30946, 30947, 7, 14, 0, 0, 30947, 30948, 7, 11, 0, 0, 30948, 30949, 7, 9, 0, 0, 30949, 30950, 7, 10, 0, 0, 30950, 30951, 7, 16, 0, 0, 30951, 30952, 7, 16, 0, 0, 30952, 4652, 1, 0, 0, 0, 30953, 30954, 7, 25, 0, 0, 30954, 30955, 7, 14, 0, 0, 30955, 30956, 7, 11, 0, 0, 30956, 30957, 5, 95, 0, 0, 30957, 30958, 7, 9, 0, 0, 30958, 30959, 7, 14, 0, 0, 30959, 30960, 7, 11, 0, 0, 30960, 30961, 5, 95, 0, 0, 30961, 30962, 7, 3, 0, 0, 30962, 30963, 7, 22, 0, 0, 30963, 30964, 7, 4, 0, 0, 30964, 30965, 5, 95, 0, 0, 30965, 30966, 7, 5, 0, 0, 30966, 30967, 7, 4, 0, 0, 30967, 30968, 7, 14, 0, 0, 30968, 30969, 7, 4, 0, 0, 30969, 4654, 1, 0, 0, 0, 30970, 30971, 7, 25, 0, 0, 30971, 30972, 7, 14, 0, 0, 30972, 30973, 7, 11, 0, 0, 30973, 30974, 7, 6, 0, 0, 30974, 30975, 7, 11, 0, 0, 30975, 30976, 7, 6, 0, 0, 30976, 30977, 7, 14, 0, 0, 30977, 30978, 7, 6, 0, 0, 30978, 30979, 7, 7, 0, 0, 30979, 30980, 7, 4, 0, 0, 30980, 4656, 1, 0, 0, 0, 30981, 30982, 7, 25, 0, 0, 30982, 30983, 7, 14, 0, 0, 30983, 30984, 7, 11, 0, 0, 30984, 30985, 7, 6, 0, 0, 30985, 30986, 7, 25, 0, 0, 30986, 30987, 7, 10, 0, 0, 30987, 30988, 7, 5, 0, 0, 30988, 30989, 7, 4, 0, 0, 30989, 30990, 7, 5, 0, 0, 30990, 30991, 5, 50, 0, 0, 30991, 4658, 1, 0, 0, 0, 30992, 30993, 7, 25, 0, 0, 30993, 30994, 7, 14, 0, 0, 30994, 30995, 7, 11, 0, 0, 30995, 30996, 7, 6, 0, 0, 30996, 30997, 7, 25, 0, 0, 30997, 30998, 7, 10, 0, 0, 30998, 30999, 7, 5, 0, 0, 30999, 31000, 7, 4, 0, 0, 31000, 31001, 7, 5, 0, 0, 31001, 4660, 1, 0, 0, 0, 31002, 31003, 7, 25, 0, 0, 31003, 31004, 7, 14, 0, 0, 31004, 31005, 7, 11, 0, 0, 31005, 31006, 7, 16, 0, 0, 31006, 31007, 7, 2, 0, 0, 31007, 31008, 7, 3, 0, 0, 31008, 31009, 7, 6, 0, 0, 31009, 31010, 7, 5, 0, 0, 31010, 31011, 7, 4, 0, 0, 31011, 4662, 1, 0, 0, 0, 31012, 31013, 7, 25, 0, 0, 31013, 31014, 7, 14, 0, 0, 31014, 31015, 7, 11, 0, 0, 31015, 31016, 7, 10, 0, 0, 31016, 31017, 7, 7, 0, 0, 31017, 31018, 7, 9, 0, 0, 31018, 31019, 7, 6, 0, 0, 31019, 31020, 7, 25, 0, 0, 31020, 4664, 1, 0, 0, 0, 31021, 31022, 7, 25, 0, 0, 31022, 31023, 7, 14, 0, 0, 31023, 31024, 7, 11, 0, 0, 31024, 31025, 7, 10, 0, 0, 31025, 31026, 7, 7, 0, 0, 31026, 31027, 7, 9, 0, 0, 31027, 31028, 7, 6, 0, 0, 31028, 31029, 7, 25, 0, 0, 31029, 31030, 5, 95, 0, 0, 31030, 31031, 7, 3, 0, 0, 31031, 31032, 7, 6, 0, 0, 31032, 31033, 7, 22, 0, 0, 31033, 31034, 7, 3, 0, 0, 31034, 31035, 7, 10, 0, 0, 31035, 31036, 7, 4, 0, 0, 31036, 31037, 7, 6, 0, 0, 31037, 31038, 5, 95, 0, 0, 31038, 31039, 7, 10, 0, 0, 31039, 31040, 7, 7, 0, 0, 31040, 31041, 5, 95, 0, 0, 31041, 31042, 7, 5, 0, 0, 31042, 31043, 7, 6, 0, 0, 31043, 31044, 7, 11, 0, 0, 31044, 31045, 7, 6, 0, 0, 31045, 31046, 7, 8, 0, 0, 31046, 31047, 7, 4, 0, 0, 31047, 4666, 1, 0, 0, 0, 31048, 31049, 7, 25, 0, 0, 31049, 31050, 7, 14, 0, 0, 31050, 31051, 7, 11, 0, 0, 31051, 31052, 7, 10, 0, 0, 31052, 31053, 7, 7, 0, 0, 31053, 31054, 7, 9, 0, 0, 31054, 31055, 7, 6, 0, 0, 31055, 31056, 7, 25, 0, 0, 31056, 31057, 5, 95, 0, 0, 31057, 31058, 7, 3, 0, 0, 31058, 31059, 7, 6, 0, 0, 31059, 31060, 7, 22, 0, 0, 31060, 31061, 7, 3, 0, 0, 31061, 31062, 7, 10, 0, 0, 31062, 31063, 7, 4, 0, 0, 31063, 31064, 7, 6, 0, 0, 31064, 4668, 1, 0, 0, 0, 31065, 31066, 7, 25, 0, 0, 31066, 31067, 7, 14, 0, 0, 31067, 31068, 7, 11, 0, 0, 31068, 31069, 7, 10, 0, 0, 31069, 31070, 7, 7, 0, 0, 31070, 31071, 7, 9, 0, 0, 31071, 31072, 7, 6, 0, 0, 31072, 31073, 7, 25, 0, 0, 31073, 31074, 5, 95, 0, 0, 31074, 31075, 7, 5, 0, 0, 31075, 31076, 7, 6, 0, 0, 31076, 31077, 7, 11, 0, 0, 31077, 31078, 5, 95, 0, 0, 31078, 31079, 7, 10, 0, 0, 31079, 31080, 7, 9, 0, 0, 31080, 31081, 7, 25, 0, 0, 31081, 31082, 5, 95, 0, 0, 31082, 31083, 7, 4, 0, 0, 31083, 31084, 7, 1, 0, 0, 31084, 31085, 7, 11, 0, 0, 31085, 4670, 1, 0, 0, 0, 31086, 31087, 7, 25, 0, 0, 31087, 31088, 7, 14, 0, 0, 31088, 31089, 7, 11, 0, 0, 31089, 31090, 7, 10, 0, 0, 31090, 31091, 7, 5, 0, 0, 31091, 31092, 7, 7, 0, 0, 31092, 31093, 7, 2, 0, 0, 31093, 31094, 7, 9, 0, 0, 31094, 31095, 7, 6, 0, 0, 31095, 4672, 1, 0, 0, 0, 31096, 31097, 7, 25, 0, 0, 31097, 31098, 7, 14, 0, 0, 31098, 31099, 7, 11, 0, 0, 31099, 31100, 7, 10, 0, 0, 31100, 31101, 7, 5, 0, 0, 31101, 31102, 7, 13, 0, 0, 31102, 31103, 7, 0, 0, 0, 31103, 31104, 7, 11, 0, 0, 31104, 31105, 7, 10, 0, 0, 31105, 31106, 7, 9, 0, 0, 31106, 4674, 1, 0, 0, 0, 31107, 31108, 7, 25, 0, 0, 31108, 31109, 7, 14, 0, 0, 31109, 31110, 7, 11, 0, 0, 31110, 31111, 7, 7, 0, 0, 31111, 31112, 7, 0, 0, 0, 31112, 31113, 7, 14, 0, 0, 31113, 31114, 7, 6, 0, 0, 31114, 31115, 7, 5, 0, 0, 31115, 31116, 7, 15, 0, 0, 31116, 31117, 7, 0, 0, 0, 31117, 31118, 7, 8, 0, 0, 31118, 31119, 7, 6, 0, 0, 31119, 31120, 7, 5, 0, 0, 31120, 4676, 1, 0, 0, 0, 31121, 31122, 7, 25, 0, 0, 31122, 31123, 7, 14, 0, 0, 31123, 31124, 7, 11, 0, 0, 31124, 31125, 7, 15, 0, 0, 31125, 31126, 7, 0, 0, 0, 31126, 31127, 7, 3, 0, 0, 31127, 31128, 7, 5, 0, 0, 31128, 31129, 7, 6, 0, 0, 31129, 4678, 1, 0, 0, 0, 31130, 31131, 7, 25, 0, 0, 31131, 31132, 7, 14, 0, 0, 31132, 31133, 7, 11, 0, 0, 31133, 31134, 7, 15, 0, 0, 31134, 31135, 7, 0, 0, 0, 31135, 31136, 7, 4, 0, 0, 31136, 31137, 7, 8, 0, 0, 31137, 31138, 7, 19, 0, 0, 31138, 4680, 1, 0, 0, 0, 31139, 31140, 7, 25, 0, 0, 31140, 31141, 7, 14, 0, 0, 31141, 31142, 7, 11, 0, 0, 31142, 31143, 7, 15, 0, 0, 31143, 31144, 7, 10, 0, 0, 31144, 4682, 1, 0, 0, 0, 31145, 31146, 7, 25, 0, 0, 31146, 31147, 7, 14, 0, 0, 31147, 31148, 7, 11, 0, 0, 31148, 31149, 7, 24, 0, 0, 31149, 31150, 7, 12, 0, 0, 31150, 31151, 7, 6, 0, 0, 31151, 31152, 7, 3, 0, 0, 31152, 31153, 7, 18, 0, 0, 31153, 31154, 7, 13, 0, 0, 31154, 31155, 7, 0, 0, 0, 31155, 31156, 7, 11, 0, 0, 31156, 4684, 1, 0, 0, 0, 31157, 31158, 7, 25, 0, 0, 31158, 31159, 7, 14, 0, 0, 31159, 31160, 7, 11, 0, 0, 31160, 31161, 7, 24, 0, 0, 31161, 31162, 7, 12, 0, 0, 31162, 31163, 7, 6, 0, 0, 31163, 31164, 7, 3, 0, 0, 31164, 31165, 7, 18, 0, 0, 31165, 4686, 1, 0, 0, 0, 31166, 31167, 7, 25, 0, 0, 31167, 31168, 7, 14, 0, 0, 31168, 31169, 7, 11, 0, 0, 31169, 31170, 7, 3, 0, 0, 31170, 31171, 7, 2, 0, 0, 31171, 31172, 7, 2, 0, 0, 31172, 31173, 7, 4, 0, 0, 31173, 4688, 1, 0, 0, 0, 31174, 31175, 7, 25, 0, 0, 31175, 31176, 7, 14, 0, 0, 31176, 31177, 7, 11, 0, 0, 31177, 31178, 7, 5, 0, 0, 31178, 31179, 7, 8, 0, 0, 31179, 31180, 7, 19, 0, 0, 31180, 31181, 7, 6, 0, 0, 31181, 31182, 7, 14, 0, 0, 31182, 31183, 7, 0, 0, 0, 31183, 4690, 1, 0, 0, 0, 31184, 31185, 7, 25, 0, 0, 31185, 31186, 7, 14, 0, 0, 31186, 31187, 7, 11, 0, 0, 31187, 31188, 7, 5, 0, 0, 31188, 31189, 7, 6, 0, 0, 31189, 31190, 7, 3, 0, 0, 31190, 31191, 7, 10, 0, 0, 31191, 31192, 7, 0, 0, 0, 31192, 31193, 7, 11, 0, 0, 31193, 31194, 7, 10, 0, 0, 31194, 31195, 7, 23, 0, 0, 31195, 31196, 7, 6, 0, 0, 31196, 4692, 1, 0, 0, 0, 31197, 31198, 7, 25, 0, 0, 31198, 31199, 7, 14, 0, 0, 31199, 31200, 7, 11, 0, 0, 31200, 31201, 7, 4, 0, 0, 31201, 31202, 7, 0, 0, 0, 31202, 31203, 7, 1, 0, 0, 31203, 31204, 7, 11, 0, 0, 31204, 31205, 7, 6, 0, 0, 31205, 4694, 1, 0, 0, 0, 31206, 31207, 7, 25, 0, 0, 31207, 31208, 7, 14, 0, 0, 31208, 31209, 7, 11, 0, 0, 31209, 31210, 7, 4, 0, 0, 31210, 31211, 7, 0, 0, 0, 31211, 31212, 7, 17, 0, 0, 31212, 4696, 1, 0, 0, 0, 31213, 31214, 7, 25, 0, 0, 31214, 31215, 7, 14, 0, 0, 31215, 31216, 7, 11, 0, 0, 31216, 31217, 7, 4, 0, 0, 31217, 31218, 7, 3, 0, 0, 31218, 31219, 7, 0, 0, 0, 31219, 31220, 7, 7, 0, 0, 31220, 31221, 7, 5, 0, 0, 31221, 31222, 7, 16, 0, 0, 31222, 31223, 7, 2, 0, 0, 31223, 31224, 7, 3, 0, 0, 31224, 31225, 7, 14, 0, 0, 31225, 31226, 7, 1, 0, 0, 31226, 31227, 7, 11, 0, 0, 31227, 31228, 7, 2, 0, 0, 31228, 31229, 7, 1, 0, 0, 31229, 4698, 1, 0, 0, 0, 31230, 31231, 7, 25, 0, 0, 31231, 31232, 7, 14, 0, 0, 31232, 31233, 7, 11, 0, 0, 31233, 31234, 7, 4, 0, 0, 31234, 31235, 7, 3, 0, 0, 31235, 31236, 7, 0, 0, 0, 31236, 31237, 7, 7, 0, 0, 31237, 31238, 7, 5, 0, 0, 31238, 31239, 7, 16, 0, 0, 31239, 31240, 7, 2, 0, 0, 31240, 31241, 7, 3, 0, 0, 31241, 31242, 7, 14, 0, 0, 31242, 4700, 1, 0, 0, 0, 31243, 31244, 7, 25, 0, 0, 31244, 31245, 7, 14, 0, 0, 31245, 31246, 7, 11, 0, 0, 31246, 31247, 7, 4, 0, 0, 31247, 31248, 7, 18, 0, 0, 31248, 31249, 7, 15, 0, 0, 31249, 31250, 7, 6, 0, 0, 31250, 4702, 1, 0, 0, 0, 31251, 31252, 7, 25, 0, 0, 31252, 31253, 7, 14, 0, 0, 31253, 31254, 7, 11, 0, 0, 31254, 4704, 1, 0, 0, 0, 31255, 31256, 7, 25, 0, 0, 31256, 31257, 7, 15, 0, 0, 31257, 31258, 7, 0, 0, 0, 31258, 31259, 7, 4, 0, 0, 31259, 31260, 7, 19, 0, 0, 31260, 31261, 7, 4, 0, 0, 31261, 31262, 7, 0, 0, 0, 31262, 31263, 7, 1, 0, 0, 31263, 31264, 7, 11, 0, 0, 31264, 31265, 7, 6, 0, 0, 31265, 4706, 1, 0, 0, 0, 31266, 31267, 7, 25, 0, 0, 31267, 31268, 7, 5, 0, 0, 31268, 31269, 5, 95, 0, 0, 31269, 31270, 7, 5, 0, 0, 31270, 31271, 7, 18, 0, 0, 31271, 31272, 7, 5, 0, 0, 31272, 31273, 5, 95, 0, 0, 31273, 31274, 7, 8, 0, 0, 31274, 31275, 7, 2, 0, 0, 31275, 31276, 7, 7, 0, 0, 31276, 31277, 7, 4, 0, 0, 31277, 31278, 7, 6, 0, 0, 31278, 31279, 7, 25, 0, 0, 31279, 31280, 7, 4, 0, 0, 31280, 4708, 1, 0, 0, 0, 31281, 31282, 7, 25, 0, 0, 31282, 31283, 7, 5, 0, 0, 31283, 4710, 1, 0, 0, 0, 31284, 31285, 7, 25, 0, 0, 31285, 31286, 7, 4, 0, 0, 31286, 31287, 7, 3, 0, 0, 31287, 31288, 7, 0, 0, 0, 31288, 31289, 7, 7, 0, 0, 31289, 31290, 7, 5, 0, 0, 31290, 31291, 7, 15, 0, 0, 31291, 31292, 7, 2, 0, 0, 31292, 31293, 7, 3, 0, 0, 31293, 31294, 7, 4, 0, 0, 31294, 4712, 1, 0, 0, 0, 31295, 31296, 7, 18, 0, 0, 31296, 31297, 7, 6, 0, 0, 31297, 31298, 7, 0, 0, 0, 31298, 31299, 7, 3, 0, 0, 31299, 31300, 7, 5, 0, 0, 31300, 4714, 1, 0, 0, 0, 31301, 31302, 7, 18, 0, 0, 31302, 31303, 7, 6, 0, 0, 31303, 31304, 7, 0, 0, 0, 31304, 31305, 7, 3, 0, 0, 31305, 4716, 1, 0, 0, 0, 31306, 31307, 7, 18, 0, 0, 31307, 31308, 7, 6, 0, 0, 31308, 31309, 7, 0, 0, 0, 31309, 31310, 7, 3, 0, 0, 31310, 31311, 5, 95, 0, 0, 31311, 31312, 7, 4, 0, 0, 31312, 31313, 7, 2, 0, 0, 31313, 31314, 5, 95, 0, 0, 31314, 31315, 7, 14, 0, 0, 31315, 31316, 7, 2, 0, 0, 31316, 31317, 7, 7, 0, 0, 31317, 31318, 7, 4, 0, 0, 31318, 31319, 7, 19, 0, 0, 31319, 4718, 1, 0, 0, 0, 31320, 31321, 7, 18, 0, 0, 31321, 31322, 7, 6, 0, 0, 31322, 31323, 7, 5, 0, 0, 31323, 4720, 1, 0, 0, 0, 31324, 31325, 7, 18, 0, 0, 31325, 31326, 7, 14, 0, 0, 31326, 31327, 7, 10, 0, 0, 31327, 31328, 7, 7, 0, 0, 31328, 31329, 7, 4, 0, 0, 31329, 31330, 7, 6, 0, 0, 31330, 31331, 7, 3, 0, 0, 31331, 31332, 7, 13, 0, 0, 31332, 31333, 7, 0, 0, 0, 31333, 31334, 7, 11, 0, 0, 31334, 31335, 5, 95, 0, 0, 31335, 31336, 7, 12, 0, 0, 31336, 31337, 7, 7, 0, 0, 31337, 31338, 7, 8, 0, 0, 31338, 31339, 7, 2, 0, 0, 31339, 31340, 7, 7, 0, 0, 31340, 31341, 7, 5, 0, 0, 31341, 31342, 7, 4, 0, 0, 31342, 31343, 7, 3, 0, 0, 31343, 31344, 7, 0, 0, 0, 31344, 31345, 7, 10, 0, 0, 31345, 31346, 7, 7, 0, 0, 31346, 31347, 7, 6, 0, 0, 31347, 31348, 7, 9, 0, 0, 31348, 4722, 1, 0, 0, 0, 31349, 31350, 7, 23, 0, 0, 31350, 31351, 7, 2, 0, 0, 31351, 31352, 7, 7, 0, 0, 31352, 31353, 7, 6, 0, 0, 31353, 31354, 7, 14, 0, 0, 31354, 31355, 7, 0, 0, 0, 31355, 31356, 7, 15, 0, 0, 31356, 4724, 1, 0, 0, 0, 31357, 31358, 7, 23, 0, 0, 31358, 31359, 7, 2, 0, 0, 31359, 31360, 7, 7, 0, 0, 31360, 31361, 7, 6, 0, 0, 31361, 4726, 1, 0, 0, 0, 31362, 31363, 7, 23, 0, 0, 31363, 31364, 7, 2, 0, 0, 31364, 31365, 7, 7, 0, 0, 31365, 31366, 7, 6, 0, 0, 31366, 31367, 7, 9, 0, 0, 31367, 4728, 1, 0, 0, 0, 31368, 31369, 7, 15, 0, 0, 31369, 31370, 7, 3, 0, 0, 31370, 31371, 7, 6, 0, 0, 31371, 31372, 7, 9, 0, 0, 31372, 31373, 7, 10, 0, 0, 31373, 31374, 7, 8, 0, 0, 31374, 31375, 7, 4, 0, 0, 31375, 31376, 7, 10, 0, 0, 31376, 31377, 7, 2, 0, 0, 31377, 31378, 7, 7, 0, 0, 31378, 4730, 1, 0, 0, 0, 31379, 31380, 7, 15, 0, 0, 31380, 31381, 7, 3, 0, 0, 31381, 31382, 7, 6, 0, 0, 31382, 31383, 7, 9, 0, 0, 31383, 31384, 7, 10, 0, 0, 31384, 31385, 7, 8, 0, 0, 31385, 31386, 7, 4, 0, 0, 31386, 31387, 7, 10, 0, 0, 31387, 31388, 7, 2, 0, 0, 31388, 31389, 7, 7, 0, 0, 31389, 31390, 5, 95, 0, 0, 31390, 31391, 7, 1, 0, 0, 31391, 31392, 7, 2, 0, 0, 31392, 31393, 7, 12, 0, 0, 31393, 31394, 7, 7, 0, 0, 31394, 31395, 7, 9, 0, 0, 31395, 31396, 7, 5, 0, 0, 31396, 4732, 1, 0, 0, 0, 31397, 31398, 7, 15, 0, 0, 31398, 31399, 7, 3, 0, 0, 31399, 31400, 7, 6, 0, 0, 31400, 31401, 7, 9, 0, 0, 31401, 31402, 7, 10, 0, 0, 31402, 31403, 7, 8, 0, 0, 31403, 31404, 7, 4, 0, 0, 31404, 31405, 7, 10, 0, 0, 31405, 31406, 7, 2, 0, 0, 31406, 31407, 7, 7, 0, 0, 31407, 31408, 5, 95, 0, 0, 31408, 31409, 7, 8, 0, 0, 31409, 31410, 7, 2, 0, 0, 31410, 31411, 7, 5, 0, 0, 31411, 31412, 7, 4, 0, 0, 31412, 4734, 1, 0, 0, 0, 31413, 31414, 7, 15, 0, 0, 31414, 31415, 7, 3, 0, 0, 31415, 31416, 7, 6, 0, 0, 31416, 31417, 7, 9, 0, 0, 31417, 31418, 7, 10, 0, 0, 31418, 31419, 7, 8, 0, 0, 31419, 31420, 7, 4, 0, 0, 31420, 31421, 7, 10, 0, 0, 31421, 31422, 7, 2, 0, 0, 31422, 31423, 7, 7, 0, 0, 31423, 31424, 5, 95, 0, 0, 31424, 31425, 7, 9, 0, 0, 31425, 31426, 7, 6, 0, 0, 31426, 31427, 7, 4, 0, 0, 31427, 31428, 7, 0, 0, 0, 31428, 31429, 7, 10, 0, 0, 31429, 31430, 7, 11, 0, 0, 31430, 31431, 7, 5, 0, 0, 31431, 4736, 1, 0, 0, 0, 31432, 31433, 7, 15, 0, 0, 31433, 31434, 7, 3, 0, 0, 31434, 31435, 7, 6, 0, 0, 31435, 31436, 7, 9, 0, 0, 31436, 31437, 7, 10, 0, 0, 31437, 31438, 7, 8, 0, 0, 31438, 31439, 7, 4, 0, 0, 31439, 31440, 7, 10, 0, 0, 31440, 31441, 7, 2, 0, 0, 31441, 31442, 7, 7, 0, 0, 31442, 31443, 5, 95, 0, 0, 31443, 31444, 7, 15, 0, 0, 31444, 31445, 7, 3, 0, 0, 31445, 31446, 7, 2, 0, 0, 31446, 31447, 7, 1, 0, 0, 31447, 31448, 7, 0, 0, 0, 31448, 31449, 7, 1, 0, 0, 31449, 31450, 7, 10, 0, 0, 31450, 31451, 7, 11, 0, 0, 31451, 31452, 7, 10, 0, 0, 31452, 31453, 7, 4, 0, 0, 31453, 31454, 7, 18, 0, 0, 31454, 4738, 1, 0, 0, 0, 31455, 31456, 7, 15, 0, 0, 31456, 31457, 7, 3, 0, 0, 31457, 31458, 7, 6, 0, 0, 31458, 31459, 7, 9, 0, 0, 31459, 31460, 7, 10, 0, 0, 31460, 31461, 7, 8, 0, 0, 31461, 31462, 7, 4, 0, 0, 31462, 31463, 7, 10, 0, 0, 31463, 31464, 7, 2, 0, 0, 31464, 31465, 7, 7, 0, 0, 31465, 31466, 5, 95, 0, 0, 31466, 31467, 7, 5, 0, 0, 31467, 31468, 7, 6, 0, 0, 31468, 31469, 7, 4, 0, 0, 31469, 4740, 1, 0, 0, 0, 31470, 31471, 7, 1, 0, 0, 31471, 31472, 7, 11, 0, 0, 31472, 31473, 7, 2, 0, 0, 31473, 31474, 7, 8, 0, 0, 31474, 31475, 7, 21, 0, 0, 31475, 31476, 7, 8, 0, 0, 31476, 31477, 7, 19, 0, 0, 31477, 31478, 7, 0, 0, 0, 31478, 31479, 7, 10, 0, 0, 31479, 31480, 7, 7, 0, 0, 31480, 4742, 1, 0, 0, 0, 31481, 31482, 7, 8, 0, 0, 31482, 31483, 7, 2, 0, 0, 31483, 31484, 7, 11, 0, 0, 31484, 31485, 7, 11, 0, 0, 31485, 31486, 7, 0, 0, 0, 31486, 31487, 7, 4, 0, 0, 31487, 31488, 7, 6, 0, 0, 31488, 4744, 1, 0, 0, 0, 31489, 31490, 7, 8, 0, 0, 31490, 31491, 7, 2, 0, 0, 31491, 31492, 7, 11, 0, 0, 31492, 31493, 7, 11, 0, 0, 31493, 31494, 7, 0, 0, 0, 31494, 31495, 7, 4, 0, 0, 31495, 31496, 7, 10, 0, 0, 31496, 31497, 7, 2, 0, 0, 31497, 31498, 7, 7, 0, 0, 31498, 4746, 1, 0, 0, 0, 31499, 31500, 7, 9, 0, 0, 31500, 31501, 7, 6, 0, 0, 31501, 31502, 7, 16, 0, 0, 31502, 31503, 7, 10, 0, 0, 31503, 31504, 7, 7, 0, 0, 31504, 31505, 7, 10, 0, 0, 31505, 31506, 7, 4, 0, 0, 31506, 31507, 7, 10, 0, 0, 31507, 31508, 7, 2, 0, 0, 31508, 31509, 7, 7, 0, 0, 31509, 4748, 1, 0, 0, 0, 31510, 31511, 7, 9, 0, 0, 31511, 31512, 7, 12, 0, 0, 31512, 31513, 7, 15, 0, 0, 31513, 31514, 7, 11, 0, 0, 31514, 31515, 7, 10, 0, 0, 31515, 31516, 7, 8, 0, 0, 31516, 31517, 7, 0, 0, 0, 31517, 31518, 7, 4, 0, 0, 31518, 31519, 7, 6, 0, 0, 31519, 31520, 7, 9, 0, 0, 31520, 4750, 1, 0, 0, 0, 31521, 31522, 7, 6, 0, 0, 31522, 31523, 7, 25, 0, 0, 31523, 31524, 7, 4, 0, 0, 31524, 31525, 7, 6, 0, 0, 31525, 31526, 7, 7, 0, 0, 31526, 31527, 7, 9, 0, 0, 31527, 31528, 7, 6, 0, 0, 31528, 31529, 7, 9, 0, 0, 31529, 4752, 1, 0, 0, 0, 31530, 31531, 7, 19, 0, 0, 31531, 31532, 7, 0, 0, 0, 31532, 31533, 7, 5, 0, 0, 31533, 31534, 7, 19, 0, 0, 31534, 31535, 7, 10, 0, 0, 31535, 31536, 7, 7, 0, 0, 31536, 31537, 7, 17, 0, 0, 31537, 4754, 1, 0, 0, 0, 31538, 31539, 7, 10, 0, 0, 31539, 31540, 7, 9, 0, 0, 31540, 31541, 7, 11, 0, 0, 31541, 31542, 7, 6, 0, 0, 31542, 4756, 1, 0, 0, 0, 31543, 31544, 7, 10, 0, 0, 31544, 31545, 7, 14, 0, 0, 31545, 31546, 7, 14, 0, 0, 31546, 31547, 7, 12, 0, 0, 31547, 31548, 7, 4, 0, 0, 31548, 31549, 7, 0, 0, 0, 31549, 31550, 7, 1, 0, 0, 31550, 31551, 7, 11, 0, 0, 31551, 31552, 7, 6, 0, 0, 31552, 4758, 1, 0, 0, 0, 31553, 31554, 7, 2, 0, 0, 31554, 31555, 7, 3, 0, 0, 31555, 31556, 7, 0, 0, 0, 31556, 31557, 7, 8, 0, 0, 31557, 31558, 7, 11, 0, 0, 31558, 31559, 7, 6, 0, 0, 31559, 31560, 5, 95, 0, 0, 31560, 31561, 7, 9, 0, 0, 31561, 31562, 7, 0, 0, 0, 31562, 31563, 7, 4, 0, 0, 31563, 31564, 7, 0, 0, 0, 31564, 31565, 7, 15, 0, 0, 31565, 31566, 7, 12, 0, 0, 31566, 31567, 7, 14, 0, 0, 31567, 31568, 7, 15, 0, 0, 31568, 4760, 1, 0, 0, 0, 31569, 31570, 7, 2, 0, 0, 31570, 31571, 7, 3, 0, 0, 31571, 31572, 7, 0, 0, 0, 31572, 31573, 7, 8, 0, 0, 31573, 31574, 7, 11, 0, 0, 31574, 31575, 7, 6, 0, 0, 31575, 31576, 5, 95, 0, 0, 31576, 31577, 7, 19, 0, 0, 31577, 31578, 7, 9, 0, 0, 31578, 31579, 7, 16, 0, 0, 31579, 31580, 7, 5, 0, 0, 31580, 4762, 1, 0, 0, 0, 31581, 31582, 7, 2, 0, 0, 31582, 31583, 7, 3, 0, 0, 31583, 31584, 7, 0, 0, 0, 31584, 31585, 7, 8, 0, 0, 31585, 31586, 7, 11, 0, 0, 31586, 31587, 7, 6, 0, 0, 31587, 31588, 5, 95, 0, 0, 31588, 31589, 7, 19, 0, 0, 31589, 31590, 7, 10, 0, 0, 31590, 31591, 7, 13, 0, 0, 31591, 31592, 7, 6, 0, 0, 31592, 4764, 1, 0, 0, 0, 31593, 31594, 7, 2, 0, 0, 31594, 31595, 7, 3, 0, 0, 31595, 31596, 7, 0, 0, 0, 31596, 31597, 7, 8, 0, 0, 31597, 31598, 7, 11, 0, 0, 31598, 31599, 7, 6, 0, 0, 31599, 31600, 5, 95, 0, 0, 31600, 31601, 7, 11, 0, 0, 31601, 31602, 7, 2, 0, 0, 31602, 31603, 7, 0, 0, 0, 31603, 31604, 7, 9, 0, 0, 31604, 31605, 7, 6, 0, 0, 31605, 31606, 7, 3, 0, 0, 31606, 4766, 1, 0, 0, 0, 31607, 31608, 5, 34, 0, 0, 31608, 31609, 7, 5, 0, 0, 31609, 31610, 7, 19, 0, 0, 31610, 31611, 7, 0, 0, 0, 31611, 31612, 5, 50, 0, 0, 31612, 31613, 5, 95, 0, 0, 31613, 31614, 5, 53, 0, 0, 31614, 31615, 5, 49, 0, 0, 31615, 31616, 5, 50, 0, 0, 31616, 31617, 5, 34, 0, 0, 31617, 4768, 1, 0, 0, 0, 31618, 31619, 7, 5, 0, 0, 31619, 31620, 7, 19, 0, 0, 31620, 31621, 7, 0, 0, 0, 31621, 31622, 7, 3, 0, 0, 31622, 31623, 7, 9, 0, 0, 31623, 31624, 7, 6, 0, 0, 31624, 31625, 7, 9, 0, 0, 31625, 4770, 1, 0, 0, 0, 31626, 31627, 5, 34, 0, 0, 31627, 31628, 7, 13, 0, 0, 31628, 31629, 5, 49, 0, 0, 31629, 31630, 5, 34, 0, 0, 31630, 4772, 1, 0, 0, 0, 31631, 31632, 7, 10, 0, 0, 31632, 31633, 7, 5, 0, 0, 31633, 31634, 7, 2, 0, 0, 31634, 31635, 7, 11, 0, 0, 31635, 31636, 7, 0, 0, 0, 31636, 31637, 7, 4, 0, 0, 31637, 31638, 7, 6, 0, 0, 31638, 4774, 1, 0, 0, 0, 31639, 31640, 7, 3, 0, 0, 31640, 31641, 7, 2, 0, 0, 31641, 31642, 7, 2, 0, 0, 31642, 31643, 7, 4, 0, 0, 31643, 4776, 1, 0, 0, 0, 31644, 31645, 7, 12, 0, 0, 31645, 31646, 7, 7, 0, 0, 31646, 31647, 7, 10, 0, 0, 31647, 31648, 7, 4, 0, 0, 31648, 31649, 7, 6, 0, 0, 31649, 4778, 1, 0, 0, 0, 31650, 31651, 7, 0, 0, 0, 31651, 31652, 7, 11, 0, 0, 31652, 31653, 7, 17, 0, 0, 31653, 31654, 7, 2, 0, 0, 31654, 31655, 7, 3, 0, 0, 31655, 31656, 7, 10, 0, 0, 31656, 31657, 7, 4, 0, 0, 31657, 31658, 7, 19, 0, 0, 31658, 31659, 7, 14, 0, 0, 31659, 4780, 1, 0, 0, 0, 31660, 31661, 7, 8, 0, 0, 31661, 31662, 7, 12, 0, 0, 31662, 31663, 7, 14, 0, 0, 31663, 31664, 7, 6, 0, 0, 31664, 31665, 5, 95, 0, 0, 31665, 31666, 7, 9, 0, 0, 31666, 31667, 7, 10, 0, 0, 31667, 31668, 7, 5, 0, 0, 31668, 31669, 7, 4, 0, 0, 31669, 4782, 1, 0, 0, 0, 31670, 31671, 7, 9, 0, 0, 31671, 31672, 7, 6, 0, 0, 31672, 31673, 7, 7, 0, 0, 31673, 31674, 7, 5, 0, 0, 31674, 31675, 7, 6, 0, 0, 31675, 31676, 5, 95, 0, 0, 31676, 31677, 7, 3, 0, 0, 31677, 31678, 7, 0, 0, 0, 31678, 31679, 7, 7, 0, 0, 31679, 31680, 7, 21, 0, 0, 31680, 4784, 1, 0, 0, 0, 31681, 31682, 7, 11, 0, 0, 31682, 31683, 7, 10, 0, 0, 31683, 31684, 7, 5, 0, 0, 31684, 31685, 7, 4, 0, 0, 31685, 31686, 7, 0, 0, 0, 31686, 31687, 7, 17, 0, 0, 31687, 31688, 7, 17, 0, 0, 31688, 4786, 1, 0, 0, 0, 31689, 31690, 7, 15, 0, 0, 31690, 31691, 7, 6, 0, 0, 31691, 31692, 7, 3, 0, 0, 31692, 31693, 7, 8, 0, 0, 31693, 31694, 7, 6, 0, 0, 31694, 31695, 7, 7, 0, 0, 31695, 31696, 7, 4, 0, 0, 31696, 31697, 5, 95, 0, 0, 31697, 31698, 7, 3, 0, 0, 31698, 31699, 7, 0, 0, 0, 31699, 31700, 7, 7, 0, 0, 31700, 31701, 7, 21, 0, 0, 31701, 4788, 1, 0, 0, 0, 31702, 31703, 7, 15, 0, 0, 31703, 31704, 7, 6, 0, 0, 31704, 31705, 7, 3, 0, 0, 31705, 31706, 7, 8, 0, 0, 31706, 31707, 7, 6, 0, 0, 31707, 31708, 7, 7, 0, 0, 31708, 31709, 7, 4, 0, 0, 31709, 31710, 7, 10, 0, 0, 31710, 31711, 7, 11, 0, 0, 31711, 31712, 7, 6, 0, 0, 31712, 31713, 5, 95, 0, 0, 31713, 31714, 7, 8, 0, 0, 31714, 31715, 7, 2, 0, 0, 31715, 31716, 7, 7, 0, 0, 31716, 31717, 7, 4, 0, 0, 31717, 4790, 1, 0, 0, 0, 31718, 31719, 7, 15, 0, 0, 31719, 31720, 7, 6, 0, 0, 31720, 31721, 7, 3, 0, 0, 31721, 31722, 7, 8, 0, 0, 31722, 31723, 7, 6, 0, 0, 31723, 31724, 7, 7, 0, 0, 31724, 31725, 7, 4, 0, 0, 31725, 31726, 7, 10, 0, 0, 31726, 31727, 7, 11, 0, 0, 31727, 31728, 7, 6, 0, 0, 31728, 31729, 5, 95, 0, 0, 31729, 31730, 7, 9, 0, 0, 31730, 31731, 7, 10, 0, 0, 31731, 31732, 7, 5, 0, 0, 31732, 31733, 7, 8, 0, 0, 31733, 4792, 1, 0, 0, 0, 31734, 31735, 7, 3, 0, 0, 31735, 31736, 7, 0, 0, 0, 31736, 31737, 7, 7, 0, 0, 31737, 31738, 7, 21, 0, 0, 31738, 4794, 1, 0, 0, 0, 31739, 31740, 7, 0, 0, 0, 31740, 31741, 7, 13, 0, 0, 31741, 31742, 7, 17, 0, 0, 31742, 4796, 1, 0, 0, 0, 31743, 31744, 7, 8, 0, 0, 31744, 31745, 7, 2, 0, 0, 31745, 31746, 7, 3, 0, 0, 31746, 31747, 7, 3, 0, 0, 31747, 4798, 1, 0, 0, 0, 31748, 31749, 7, 8, 0, 0, 31749, 31750, 7, 2, 0, 0, 31750, 31751, 7, 13, 0, 0, 31751, 31752, 7, 0, 0, 0, 31752, 31753, 7, 3, 0, 0, 31753, 31754, 5, 95, 0, 0, 31754, 4800, 1, 0, 0, 0, 31755, 31756, 7, 9, 0, 0, 31756, 31757, 7, 6, 0, 0, 31757, 31758, 7, 8, 0, 0, 31758, 31759, 7, 2, 0, 0, 31759, 31760, 7, 9, 0, 0, 31760, 31761, 7, 6, 0, 0, 31761, 4802, 1, 0, 0, 0, 31762, 31763, 7, 11, 0, 0, 31763, 31764, 7, 0, 0, 0, 31764, 31765, 7, 17, 0, 0, 31765, 4804, 1, 0, 0, 0, 31766, 31767, 7, 11, 0, 0, 31767, 31768, 7, 0, 0, 0, 31768, 31769, 7, 17, 0, 0, 31769, 31770, 5, 95, 0, 0, 31770, 31771, 7, 9, 0, 0, 31771, 31772, 7, 10, 0, 0, 31772, 31773, 7, 16, 0, 0, 31773, 31774, 7, 16, 0, 0, 31774, 4806, 1, 0, 0, 0, 31775, 31776, 7, 11, 0, 0, 31776, 31777, 7, 0, 0, 0, 31777, 31778, 7, 17, 0, 0, 31778, 31779, 5, 95, 0, 0, 31779, 31780, 7, 9, 0, 0, 31780, 31781, 7, 10, 0, 0, 31781, 31782, 7, 16, 0, 0, 31782, 31783, 7, 16, 0, 0, 31783, 31784, 5, 95, 0, 0, 31784, 31785, 7, 15, 0, 0, 31785, 31786, 7, 6, 0, 0, 31786, 31787, 7, 3, 0, 0, 31787, 31788, 7, 8, 0, 0, 31788, 31789, 7, 6, 0, 0, 31789, 31790, 7, 7, 0, 0, 31790, 31791, 7, 4, 0, 0, 31791, 4808, 1, 0, 0, 0, 31792, 31793, 7, 11, 0, 0, 31793, 31794, 7, 6, 0, 0, 31794, 31795, 7, 0, 0, 0, 31795, 31796, 7, 9, 0, 0, 31796, 4810, 1, 0, 0, 0, 31797, 31798, 7, 14, 0, 0, 31798, 31799, 7, 0, 0, 0, 31799, 31800, 7, 25, 0, 0, 31800, 4812, 1, 0, 0, 0, 31801, 31802, 7, 14, 0, 0, 31802, 31803, 7, 6, 0, 0, 31803, 31804, 7, 9, 0, 0, 31804, 31805, 7, 10, 0, 0, 31805, 31806, 7, 0, 0, 0, 31806, 31807, 7, 7, 0, 0, 31807, 4814, 1, 0, 0, 0, 31808, 31809, 7, 14, 0, 0, 31809, 31810, 7, 6, 0, 0, 31810, 31811, 7, 14, 0, 0, 31811, 31812, 7, 2, 0, 0, 31812, 31813, 7, 15, 0, 0, 31813, 31814, 7, 4, 0, 0, 31814, 31815, 7, 10, 0, 0, 31815, 31816, 7, 14, 0, 0, 31816, 31817, 7, 10, 0, 0, 31817, 31818, 7, 23, 0, 0, 31818, 31819, 7, 6, 0, 0, 31819, 4816, 1, 0, 0, 0, 31820, 31821, 7, 14, 0, 0, 31821, 31822, 7, 10, 0, 0, 31822, 31823, 7, 7, 0, 0, 31823, 4818, 1, 0, 0, 0, 31824, 31825, 7, 7, 0, 0, 31825, 31826, 7, 4, 0, 0, 31826, 31827, 7, 10, 0, 0, 31827, 31828, 7, 11, 0, 0, 31828, 31829, 7, 6, 0, 0, 31829, 4820, 1, 0, 0, 0, 31830, 31831, 7, 7, 0, 0, 31831, 31832, 7, 13, 0, 0, 31832, 31833, 7, 11, 0, 0, 31833, 4822, 1, 0, 0, 0, 31834, 31835, 7, 3, 0, 0, 31835, 31836, 7, 0, 0, 0, 31836, 31837, 7, 4, 0, 0, 31837, 31838, 7, 10, 0, 0, 31838, 31839, 7, 2, 0, 0, 31839, 31840, 5, 95, 0, 0, 31840, 31841, 7, 4, 0, 0, 31841, 31842, 7, 2, 0, 0, 31842, 31843, 5, 95, 0, 0, 31843, 31844, 7, 3, 0, 0, 31844, 31845, 7, 6, 0, 0, 31845, 31846, 7, 15, 0, 0, 31846, 31847, 7, 2, 0, 0, 31847, 31848, 7, 3, 0, 0, 31848, 31849, 7, 4, 0, 0, 31849, 4824, 1, 0, 0, 0, 31850, 31851, 7, 3, 0, 0, 31851, 31852, 7, 6, 0, 0, 31852, 31853, 7, 17, 0, 0, 31853, 31854, 7, 3, 0, 0, 31854, 31855, 5, 95, 0, 0, 31855, 4826, 1, 0, 0, 0, 31856, 31857, 7, 3, 0, 0, 31857, 31858, 7, 2, 0, 0, 31858, 31859, 7, 12, 0, 0, 31859, 31860, 7, 7, 0, 0, 31860, 31861, 7, 9, 0, 0, 31861, 4828, 1, 0, 0, 0, 31862, 31863, 7, 3, 0, 0, 31863, 31864, 7, 2, 0, 0, 31864, 31865, 7, 22, 0, 0, 31865, 31866, 5, 95, 0, 0, 31866, 31867, 7, 7, 0, 0, 31867, 31868, 7, 12, 0, 0, 31868, 31869, 7, 14, 0, 0, 31869, 31870, 7, 1, 0, 0, 31870, 31871, 7, 6, 0, 0, 31871, 31872, 7, 3, 0, 0, 31872, 4830, 1, 0, 0, 0, 31873, 31874, 7, 5, 0, 0, 31874, 31875, 7, 12, 0, 0, 31875, 31876, 7, 1, 0, 0, 31876, 31877, 7, 5, 0, 0, 31877, 31878, 7, 4, 0, 0, 31878, 31879, 7, 3, 0, 0, 31879, 4832, 1, 0, 0, 0, 31880, 31881, 7, 4, 0, 0, 31881, 31882, 7, 2, 0, 0, 31882, 31883, 5, 95, 0, 0, 31883, 31884, 7, 8, 0, 0, 31884, 31885, 7, 19, 0, 0, 31885, 31886, 7, 0, 0, 0, 31886, 31887, 7, 3, 0, 0, 31887, 4834, 1, 0, 0, 0, 31888, 31889, 7, 4, 0, 0, 31889, 31890, 7, 3, 0, 0, 31890, 31891, 7, 10, 0, 0, 31891, 31892, 7, 14, 0, 0, 31892, 4836, 1, 0, 0, 0, 31893, 31894, 7, 5, 0, 0, 31894, 31895, 7, 12, 0, 0, 31895, 31896, 7, 14, 0, 0, 31896, 4838, 1, 0, 0, 0, 31897, 31898, 7, 5, 0, 0, 31898, 31899, 7, 4, 0, 0, 31899, 31900, 7, 9, 0, 0, 31900, 31901, 7, 9, 0, 0, 31901, 31902, 7, 6, 0, 0, 31902, 31903, 7, 13, 0, 0, 31903, 4840, 1, 0, 0, 0, 31904, 31905, 7, 13, 0, 0, 31905, 31906, 7, 0, 0, 0, 31906, 31907, 7, 3, 0, 0, 31907, 31908, 5, 95, 0, 0, 31908, 4842, 1, 0, 0, 0, 31909, 31910, 7, 13, 0, 0, 31910, 31911, 7, 0, 0, 0, 31911, 31912, 7, 3, 0, 0, 31912, 31913, 7, 10, 0, 0, 31913, 31914, 7, 0, 0, 0, 31914, 31915, 7, 7, 0, 0, 31915, 31916, 7, 8, 0, 0, 31916, 31917, 7, 6, 0, 0, 31917, 4844, 1, 0, 0, 0, 31918, 31919, 7, 11, 0, 0, 31919, 31920, 7, 6, 0, 0, 31920, 31921, 7, 0, 0, 0, 31921, 31922, 7, 5, 0, 0, 31922, 31923, 7, 4, 0, 0, 31923, 4846, 1, 0, 0, 0, 31924, 31925, 7, 17, 0, 0, 31925, 31926, 7, 3, 0, 0, 31926, 31927, 7, 6, 0, 0, 31927, 31928, 7, 0, 0, 0, 31928, 31929, 7, 4, 0, 0, 31929, 31930, 7, 6, 0, 0, 31930, 31931, 7, 5, 0, 0, 31931, 31932, 7, 4, 0, 0, 31932, 4848, 1, 0, 0, 0, 31933, 31934, 7, 4, 0, 0, 31934, 31935, 7, 2, 0, 0, 31935, 31936, 5, 95, 0, 0, 31936, 31937, 7, 9, 0, 0, 31937, 31938, 7, 0, 0, 0, 31938, 31939, 7, 4, 0, 0, 31939, 31940, 7, 6, 0, 0, 31940, 4850, 1, 0, 0, 0, 31941, 31942, 7, 8, 0, 0, 31942, 31943, 7, 19, 0, 0, 31943, 31944, 7, 0, 0, 0, 31944, 31945, 7, 3, 0, 0, 31945, 31946, 7, 5, 0, 0, 31946, 31947, 7, 6, 0, 0, 31947, 31948, 7, 4, 0, 0, 31948, 31949, 7, 10, 0, 0, 31949, 31950, 7, 9, 0, 0, 31950, 4852, 1, 0, 0, 0, 31951, 31952, 7, 8, 0, 0, 31952, 31953, 7, 19, 0, 0, 31953, 31954, 7, 0, 0, 0, 31954, 31955, 7, 3, 0, 0, 31955, 31956, 7, 5, 0, 0, 31956, 31957, 7, 6, 0, 0, 31957, 31958, 7, 4, 0, 0, 31958, 31959, 7, 16, 0, 0, 31959, 31960, 7, 2, 0, 0, 31960, 31961, 7, 3, 0, 0, 31961, 31962, 7, 14, 0, 0, 31962, 4854, 1, 0, 0, 0, 31963, 31964, 7, 9, 0, 0, 31964, 31965, 7, 12, 0, 0, 31965, 31966, 7, 3, 0, 0, 31966, 31967, 7, 0, 0, 0, 31967, 31968, 7, 4, 0, 0, 31968, 31969, 7, 10, 0, 0, 31969, 31970, 7, 2, 0, 0, 31970, 31971, 7, 7, 0, 0, 31971, 4856, 1, 0, 0, 0, 31972, 31973, 7, 6, 0, 0, 31973, 31974, 7, 25, 0, 0, 31974, 31975, 7, 4, 0, 0, 31975, 31976, 7, 6, 0, 0, 31976, 31977, 7, 7, 0, 0, 31977, 31978, 7, 9, 0, 0, 31978, 4858, 1, 0, 0, 0, 31979, 31980, 7, 14, 0, 0, 31980, 31981, 7, 0, 0, 0, 31981, 31982, 7, 25, 0, 0, 31982, 31983, 7, 11, 0, 0, 31983, 31984, 7, 6, 0, 0, 31984, 31985, 7, 7, 0, 0, 31985, 4860, 1, 0, 0, 0, 31986, 31987, 7, 15, 0, 0, 31987, 31988, 7, 6, 0, 0, 31988, 31989, 7, 3, 0, 0, 31989, 31990, 7, 5, 0, 0, 31990, 31991, 7, 10, 0, 0, 31991, 31992, 7, 5, 0, 0, 31992, 31993, 7, 4, 0, 0, 31993, 31994, 7, 0, 0, 0, 31994, 31995, 7, 1, 0, 0, 31995, 31996, 7, 11, 0, 0, 31996, 31997, 7, 6, 0, 0, 31997, 4862, 1, 0, 0, 0, 31998, 31999, 7, 15, 0, 0, 31999, 32000, 7, 2, 0, 0, 32000, 32001, 7, 11, 0, 0, 32001, 32002, 7, 18, 0, 0, 32002, 32003, 7, 14, 0, 0, 32003, 32004, 7, 2, 0, 0, 32004, 32005, 7, 3, 0, 0, 32005, 32006, 7, 15, 0, 0, 32006, 32007, 7, 19, 0, 0, 32007, 32008, 7, 10, 0, 0, 32008, 32009, 7, 8, 0, 0, 32009, 4864, 1, 0, 0, 0, 32010, 32011, 7, 5, 0, 0, 32011, 32012, 7, 4, 0, 0, 32012, 32013, 7, 3, 0, 0, 32013, 32014, 7, 12, 0, 0, 32014, 32015, 7, 8, 0, 0, 32015, 32016, 7, 4, 0, 0, 32016, 4866, 1, 0, 0, 0, 32017, 32018, 7, 4, 0, 0, 32018, 32019, 7, 9, 0, 0, 32019, 32020, 7, 2, 0, 0, 32020, 4868, 1, 0, 0, 0, 32021, 32022, 7, 22, 0, 0, 32022, 32023, 7, 14, 0, 0, 32023, 32024, 5, 95, 0, 0, 32024, 32025, 7, 8, 0, 0, 32025, 32026, 7, 2, 0, 0, 32026, 32027, 7, 7, 0, 0, 32027, 32028, 7, 8, 0, 0, 32028, 32029, 7, 0, 0, 0, 32029, 32030, 7, 4, 0, 0, 32030, 4870, 1, 0, 0, 0, 32031, 32032, 7, 7, 0, 0, 32032, 32039, 5, 39, 0, 0, 32033, 32038, 8, 26, 0, 0, 32034, 32035, 5, 39, 0, 0, 32035, 32038, 5, 39, 0, 0, 32036, 32038, 3, 4997, 2498, 0, 32037, 32033, 1, 0, 0, 0, 32037, 32034, 1, 0, 0, 0, 32037, 32036, 1, 0, 0, 0, 32038, 32041, 1, 0, 0, 0, 32039, 32037, 1, 0, 0, 0, 32039, 32040, 1, 0, 0, 0, 32040, 32042, 1, 0, 0, 0, 32041, 32039, 1, 0, 0, 0, 32042, 32043, 5, 39, 0, 0, 32043, 4872, 1, 0, 0, 0, 32044, 32053, 7, 1, 0, 0, 32045, 32049, 5, 39, 0, 0, 32046, 32048, 7, 27, 0, 0, 32047, 32046, 1, 0, 0, 0, 32048, 32051, 1, 0, 0, 0, 32049, 32047, 1, 0, 0, 0, 32049, 32050, 1, 0, 0, 0, 32050, 32052, 1, 0, 0, 0, 32051, 32049, 1, 0, 0, 0, 32052, 32054, 5, 39, 0, 0, 32053, 32045, 1, 0, 0, 0, 32054, 32055, 1, 0, 0, 0, 32055, 32053, 1, 0, 0, 0, 32055, 32056, 1, 0, 0, 0, 32056, 4874, 1, 0, 0, 0, 32057, 32061, 7, 25, 0, 0, 32058, 32059, 5, 48, 0, 0, 32059, 32061, 7, 25, 0, 0, 32060, 32057, 1, 0, 0, 0, 32060, 32058, 1, 0, 0, 0, 32061, 32070, 1, 0, 0, 0, 32062, 32066, 5, 39, 0, 0, 32063, 32065, 7, 28, 0, 0, 32064, 32063, 1, 0, 0, 0, 32065, 32068, 1, 0, 0, 0, 32066, 32064, 1, 0, 0, 0, 32066, 32067, 1, 0, 0, 0, 32067, 32069, 1, 0, 0, 0, 32068, 32066, 1, 0, 0, 0, 32069, 32071, 5, 39, 0, 0, 32070, 32062, 1, 0, 0, 0, 32071, 32072, 1, 0, 0, 0, 32072, 32070, 1, 0, 0, 0, 32072, 32073, 1, 0, 0, 0, 32073, 4876, 1, 0, 0, 0, 32074, 32075, 5, 46, 0, 0, 32075, 32076, 5, 46, 0, 0, 32076, 4878, 1, 0, 0, 0, 32077, 32078, 5, 46, 0, 0, 32078, 4880, 1, 0, 0, 0, 32079, 32081, 7, 29, 0, 0, 32080, 32079, 1, 0, 0, 0, 32081, 32082, 1, 0, 0, 0, 32082, 32080, 1, 0, 0, 0, 32082, 32083, 1, 0, 0, 0, 32083, 4882, 1, 0, 0, 0, 32084, 32097, 3, 4995, 2497, 0, 32085, 32087, 7, 6, 0, 0, 32086, 32088, 7, 30, 0, 0, 32087, 32086, 1, 0, 0, 0, 32087, 32088, 1, 0, 0, 0, 32088, 32095, 1, 0, 0, 0, 32089, 32096, 3, 4995, 2497, 0, 32090, 32092, 7, 29, 0, 0, 32091, 32090, 1, 0, 0, 0, 32092, 32093, 1, 0, 0, 0, 32093, 32091, 1, 0, 0, 0, 32093, 32094, 1, 0, 0, 0, 32094, 32096, 1, 0, 0, 0, 32095, 32089, 1, 0, 0, 0, 32095, 32091, 1, 0, 0, 0, 32096, 32098, 1, 0, 0, 0, 32097, 32085, 1, 0, 0, 0, 32097, 32098, 1, 0, 0, 0, 32098, 32100, 1, 0, 0, 0, 32099, 32101, 7, 31, 0, 0, 32100, 32099, 1, 0, 0, 0, 32100, 32101, 1, 0, 0, 0, 32101, 4884, 1, 0, 0, 0, 32102, 32109, 5, 39, 0, 0, 32103, 32108, 8, 26, 0, 0, 32104, 32105, 5, 39, 0, 0, 32105, 32108, 5, 39, 0, 0, 32106, 32108, 3, 4997, 2498, 0, 32107, 32103, 1, 0, 0, 0, 32107, 32104, 1, 0, 0, 0, 32107, 32106, 1, 0, 0, 0, 32108, 32111, 1, 0, 0, 0, 32109, 32107, 1, 0, 0, 0, 32109, 32110, 1, 0, 0, 0, 32110, 32112, 1, 0, 0, 0, 32111, 32109, 1, 0, 0, 0, 32112, 32113, 5, 39, 0, 0, 32113, 4886, 1, 0, 0, 0, 32114, 32115, 7, 24, 0, 0, 32115, 32127, 5, 39, 0, 0, 32116, 32128, 3, 4889, 2444, 0, 32117, 32128, 3, 4891, 2445, 0, 32118, 32128, 3, 4893, 2446, 0, 32119, 32128, 3, 4895, 2447, 0, 32120, 32128, 3, 4897, 2448, 0, 32121, 32128, 3, 4899, 2449, 0, 32122, 32128, 3, 4901, 2450, 0, 32123, 32128, 3, 4903, 2451, 0, 32124, 32128, 3, 4905, 2452, 0, 32125, 32128, 3, 4907, 2453, 0, 32126, 32128, 3, 4909, 2454, 0, 32127, 32116, 1, 0, 0, 0, 32127, 32117, 1, 0, 0, 0, 32127, 32118, 1, 0, 0, 0, 32127, 32119, 1, 0, 0, 0, 32127, 32120, 1, 0, 0, 0, 32127, 32121, 1, 0, 0, 0, 32127, 32122, 1, 0, 0, 0, 32127, 32123, 1, 0, 0, 0, 32127, 32124, 1, 0, 0, 0, 32127, 32125, 1, 0, 0, 0, 32127, 32126, 1, 0, 0, 0, 32128, 32129, 1, 0, 0, 0, 32129, 32130, 5, 39, 0, 0, 32130, 32131, 1, 0, 0, 0, 32131, 32132, 6, 2443, 0, 0, 32132, 4888, 1, 0, 0, 0, 32133, 32137, 5, 60, 0, 0, 32134, 32136, 9, 0, 0, 0, 32135, 32134, 1, 0, 0, 0, 32136, 32139, 1, 0, 0, 0, 32137, 32138, 1, 0, 0, 0, 32137, 32135, 1, 0, 0, 0, 32138, 32140, 1, 0, 0, 0, 32139, 32137, 1, 0, 0, 0, 32140, 32141, 5, 62, 0, 0, 32141, 4890, 1, 0, 0, 0, 32142, 32146, 5, 123, 0, 0, 32143, 32145, 9, 0, 0, 0, 32144, 32143, 1, 0, 0, 0, 32145, 32148, 1, 0, 0, 0, 32146, 32147, 1, 0, 0, 0, 32146, 32144, 1, 0, 0, 0, 32147, 32149, 1, 0, 0, 0, 32148, 32146, 1, 0, 0, 0, 32149, 32150, 5, 125, 0, 0, 32150, 4892, 1, 0, 0, 0, 32151, 32155, 5, 91, 0, 0, 32152, 32154, 9, 0, 0, 0, 32153, 32152, 1, 0, 0, 0, 32154, 32157, 1, 0, 0, 0, 32155, 32156, 1, 0, 0, 0, 32155, 32153, 1, 0, 0, 0, 32156, 32158, 1, 0, 0, 0, 32157, 32155, 1, 0, 0, 0, 32158, 32159, 5, 93, 0, 0, 32159, 4894, 1, 0, 0, 0, 32160, 32164, 5, 40, 0, 0, 32161, 32163, 9, 0, 0, 0, 32162, 32161, 1, 0, 0, 0, 32163, 32166, 1, 0, 0, 0, 32164, 32165, 1, 0, 0, 0, 32164, 32162, 1, 0, 0, 0, 32165, 32167, 1, 0, 0, 0, 32166, 32164, 1, 0, 0, 0, 32167, 32168, 5, 41, 0, 0, 32168, 4896, 1, 0, 0, 0, 32169, 32173, 5, 33, 0, 0, 32170, 32172, 9, 0, 0, 0, 32171, 32170, 1, 0, 0, 0, 32172, 32175, 1, 0, 0, 0, 32173, 32174, 1, 0, 0, 0, 32173, 32171, 1, 0, 0, 0, 32174, 32176, 1, 0, 0, 0, 32175, 32173, 1, 0, 0, 0, 32176, 32177, 5, 33, 0, 0, 32177, 4898, 1, 0, 0, 0, 32178, 32182, 5, 35, 0, 0, 32179, 32181, 9, 0, 0, 0, 32180, 32179, 1, 0, 0, 0, 32181, 32184, 1, 0, 0, 0, 32182, 32183, 1, 0, 0, 0, 32182, 32180, 1, 0, 0, 0, 32183, 32185, 1, 0, 0, 0, 32184, 32182, 1, 0, 0, 0, 32185, 32186, 5, 35, 0, 0, 32186, 4900, 1, 0, 0, 0, 32187, 32191, 5, 39, 0, 0, 32188, 32190, 9, 0, 0, 0, 32189, 32188, 1, 0, 0, 0, 32190, 32193, 1, 0, 0, 0, 32191, 32192, 1, 0, 0, 0, 32191, 32189, 1, 0, 0, 0, 32192, 32194, 1, 0, 0, 0, 32193, 32191, 1, 0, 0, 0, 32194, 32195, 5, 39, 0, 0, 32195, 4902, 1, 0, 0, 0, 32196, 32200, 5, 34, 0, 0, 32197, 32199, 9, 0, 0, 0, 32198, 32197, 1, 0, 0, 0, 32199, 32202, 1, 0, 0, 0, 32200, 32201, 1, 0, 0, 0, 32200, 32198, 1, 0, 0, 0, 32201, 32203, 1, 0, 0, 0, 32202, 32200, 1, 0, 0, 0, 32203, 32204, 5, 34, 0, 0, 32204, 4904, 1, 0, 0, 0, 32205, 32209, 5, 126, 0, 0, 32206, 32208, 9, 0, 0, 0, 32207, 32206, 1, 0, 0, 0, 32208, 32211, 1, 0, 0, 0, 32209, 32210, 1, 0, 0, 0, 32209, 32207, 1, 0, 0, 0, 32210, 32212, 1, 0, 0, 0, 32211, 32209, 1, 0, 0, 0, 32212, 32213, 5, 126, 0, 0, 32213, 4906, 1, 0, 0, 0, 32214, 32218, 5, 47, 0, 0, 32215, 32217, 9, 0, 0, 0, 32216, 32215, 1, 0, 0, 0, 32217, 32220, 1, 0, 0, 0, 32218, 32219, 1, 0, 0, 0, 32218, 32216, 1, 0, 0, 0, 32219, 32221, 1, 0, 0, 0, 32220, 32218, 1, 0, 0, 0, 32221, 32222, 5, 47, 0, 0, 32222, 4908, 1, 0, 0, 0, 32223, 32227, 5, 92, 0, 0, 32224, 32226, 9, 0, 0, 0, 32225, 32224, 1, 0, 0, 0, 32226, 32229, 1, 0, 0, 0, 32227, 32228, 1, 0, 0, 0, 32227, 32225, 1, 0, 0, 0, 32228, 32230, 1, 0, 0, 0, 32229, 32227, 1, 0, 0, 0, 32230, 32231, 5, 92, 0, 0, 32231, 4910, 1, 0, 0, 0, 32232, 32236, 5, 34, 0, 0, 32233, 32237, 8, 32, 0, 0, 32234, 32235, 5, 34, 0, 0, 32235, 32237, 5, 34, 0, 0, 32236, 32233, 1, 0, 0, 0, 32236, 32234, 1, 0, 0, 0, 32237, 32238, 1, 0, 0, 0, 32238, 32236, 1, 0, 0, 0, 32238, 32239, 1, 0, 0, 0, 32239, 32240, 1, 0, 0, 0, 32240, 32241, 5, 34, 0, 0, 32241, 4912, 1, 0, 0, 0, 32242, 32243, 5, 37, 0, 0, 32243, 4914, 1, 0, 0, 0, 32244, 32245, 5, 38, 0, 0, 32245, 4916, 1, 0, 0, 0, 32246, 32247, 5, 40, 0, 0, 32247, 4918, 1, 0, 0, 0, 32248, 32249, 5, 41, 0, 0, 32249, 4920, 1, 0, 0, 0, 32250, 32251, 5, 42, 0, 0, 32251, 32252, 5, 42, 0, 0, 32252, 4922, 1, 0, 0, 0, 32253, 32254, 5, 42, 0, 0, 32254, 4924, 1, 0, 0, 0, 32255, 32256, 5, 43, 0, 0, 32256, 4926, 1, 0, 0, 0, 32257, 32258, 5, 45, 0, 0, 32258, 4928, 1, 0, 0, 0, 32259, 32260, 5, 44, 0, 0, 32260, 4930, 1, 0, 0, 0, 32261, 32262, 5, 47, 0, 0, 32262, 4932, 1, 0, 0, 0, 32263, 32264, 5, 92, 0, 0, 32264, 4934, 1, 0, 0, 0, 32265, 32266, 5, 64, 0, 0, 32266, 4936, 1, 0, 0, 0, 32267, 32268, 5, 58, 0, 0, 32268, 32269, 5, 61, 0, 0, 32269, 4938, 1, 0, 0, 0, 32270, 32271, 5, 35, 0, 0, 32271, 4940, 1, 0, 0, 0, 32272, 32273, 5, 123, 0, 0, 32273, 4942, 1, 0, 0, 0, 32274, 32275, 5, 125, 0, 0, 32275, 4944, 1, 0, 0, 0, 32276, 32277, 5, 39, 0, 0, 32277, 4946, 1, 0, 0, 0, 32278, 32279, 5, 58, 0, 0, 32279, 32284, 3, 4993, 2496, 0, 32280, 32283, 3, 4993, 2496, 0, 32281, 32283, 7, 33, 0, 0, 32282, 32280, 1, 0, 0, 0, 32282, 32281, 1, 0, 0, 0, 32283, 32286, 1, 0, 0, 0, 32284, 32282, 1, 0, 0, 0, 32284, 32285, 1, 0, 0, 0, 32285, 32293, 1, 0, 0, 0, 32286, 32284, 1, 0, 0, 0, 32287, 32288, 5, 58, 0, 0, 32288, 32293, 3, 4911, 2455, 0, 32289, 32290, 5, 58, 0, 0, 32290, 32293, 3, 4881, 2440, 0, 32291, 32293, 3, 4991, 2495, 0, 32292, 32278, 1, 0, 0, 0, 32292, 32287, 1, 0, 0, 0, 32292, 32289, 1, 0, 0, 0, 32292, 32291, 1, 0, 0, 0, 32293, 4948, 1, 0, 0, 0, 32294, 32295, 5, 33, 0, 0, 32295, 32303, 5, 61, 0, 0, 32296, 32297, 5, 60, 0, 0, 32297, 32303, 5, 62, 0, 0, 32298, 32299, 5, 94, 0, 0, 32299, 32303, 5, 61, 0, 0, 32300, 32301, 5, 126, 0, 0, 32301, 32303, 5, 61, 0, 0, 32302, 32294, 1, 0, 0, 0, 32302, 32296, 1, 0, 0, 0, 32302, 32298, 1, 0, 0, 0, 32302, 32300, 1, 0, 0, 0, 32303, 4950, 1, 0, 0, 0, 32304, 32305, 5, 94, 0, 0, 32305, 4952, 1, 0, 0, 0, 32306, 32307, 5, 126, 0, 0, 32307, 4954, 1, 0, 0, 0, 32308, 32309, 5, 33, 0, 0, 32309, 4956, 1, 0, 0, 0, 32310, 32311, 5, 62, 0, 0, 32311, 4958, 1, 0, 0, 0, 32312, 32313, 5, 60, 0, 0, 32313, 4960, 1, 0, 0, 0, 32314, 32315, 5, 58, 0, 0, 32315, 4962, 1, 0, 0, 0, 32316, 32317, 5, 59, 0, 0, 32317, 4964, 1, 0, 0, 0, 32318, 32319, 5, 124, 0, 0, 32319, 4966, 1, 0, 0, 0, 32320, 32321, 5, 61, 0, 0, 32321, 4968, 1, 0, 0, 0, 32322, 32323, 5, 91, 0, 0, 32323, 4970, 1, 0, 0, 0, 32324, 32325, 5, 93, 0, 0, 32325, 4972, 1, 0, 0, 0, 32326, 32327, 5, 95, 0, 0, 32327, 4974, 1, 0, 0, 0, 32328, 32329, 5, 45, 0, 0, 32329, 32330, 5, 45, 0, 0, 32330, 32334, 1, 0, 0, 0, 32331, 32333, 8, 34, 0, 0, 32332, 32331, 1, 0, 0, 0, 32333, 32336, 1, 0, 0, 0, 32334, 32332, 1, 0, 0, 0, 32334, 32335, 1, 0, 0, 0, 32335, 32337, 1, 0, 0, 0, 32336, 32334, 1, 0, 0, 0, 32337, 32338, 3, 4989, 2494, 0, 32338, 32339, 1, 0, 0, 0, 32339, 32340, 6, 2487, 1, 0, 32340, 4976, 1, 0, 0, 0, 32341, 32342, 5, 47, 0, 0, 32342, 32343, 5, 42, 0, 0, 32343, 32347, 1, 0, 0, 0, 32344, 32346, 9, 0, 0, 0, 32345, 32344, 1, 0, 0, 0, 32346, 32349, 1, 0, 0, 0, 32347, 32348, 1, 0, 0, 0, 32347, 32345, 1, 0, 0, 0, 32348, 32350, 1, 0, 0, 0, 32349, 32347, 1, 0, 0, 0, 32350, 32351, 5, 42, 0, 0, 32351, 32352, 5, 47, 0, 0, 32352, 32353, 1, 0, 0, 0, 32353, 32354, 6, 2488, 1, 0, 32354, 4978, 1, 0, 0, 0, 32355, 32356, 7, 3, 0, 0, 32356, 32357, 7, 6, 0, 0, 32357, 32358, 7, 14, 0, 0, 32358, 32359, 1, 0, 0, 0, 32359, 32363, 4, 2489, 0, 0, 32360, 32361, 7, 0, 0, 0, 32361, 32362, 7, 3, 0, 0, 32362, 32364, 7, 21, 0, 0, 32363, 32360, 1, 0, 0, 0, 32363, 32364, 1, 0, 0, 0, 32364, 32372, 1, 0, 0, 0, 32365, 32369, 5, 32, 0, 0, 32366, 32368, 8, 34, 0, 0, 32367, 32366, 1, 0, 0, 0, 32368, 32371, 1, 0, 0, 0, 32369, 32367, 1, 0, 0, 0, 32369, 32370, 1, 0, 0, 0, 32370, 32373, 1, 0, 0, 0, 32371, 32369, 1, 0, 0, 0, 32372, 32365, 1, 0, 0, 0, 32372, 32373, 1, 0, 0, 0, 32373, 32374, 1, 0, 0, 0, 32374, 32375, 3, 4989, 2494, 0, 32375, 32376, 1, 0, 0, 0, 32376, 32377, 6, 2489, 1, 0, 32377, 4980, 1, 0, 0, 0, 32378, 32379, 7, 15, 0, 0, 32379, 32380, 7, 3, 0, 0, 32380, 32381, 7, 2, 0, 0, 32381, 32382, 1, 0, 0, 0, 32382, 32386, 4, 2490, 1, 0, 32383, 32384, 7, 14, 0, 0, 32384, 32385, 7, 15, 0, 0, 32385, 32387, 7, 4, 0, 0, 32386, 32383, 1, 0, 0, 0, 32386, 32387, 1, 0, 0, 0, 32387, 32395, 1, 0, 0, 0, 32388, 32392, 5, 32, 0, 0, 32389, 32391, 8, 34, 0, 0, 32390, 32389, 1, 0, 0, 0, 32391, 32394, 1, 0, 0, 0, 32392, 32390, 1, 0, 0, 0, 32392, 32393, 1, 0, 0, 0, 32393, 32396, 1, 0, 0, 0, 32394, 32392, 1, 0, 0, 0, 32395, 32388, 1, 0, 0, 0, 32395, 32396, 1, 0, 0, 0, 32396, 32397, 1, 0, 0, 0, 32397, 32398, 3, 4989, 2494, 0, 32398, 4982, 1, 0, 0, 0, 32399, 32404, 3, 4993, 2496, 0, 32400, 32403, 3, 4993, 2496, 0, 32401, 32403, 7, 35, 0, 0, 32402, 32400, 1, 0, 0, 0, 32402, 32401, 1, 0, 0, 0, 32403, 32406, 1, 0, 0, 0, 32404, 32402, 1, 0, 0, 0, 32404, 32405, 1, 0, 0, 0, 32405, 4984, 1, 0, 0, 0, 32406, 32404, 1, 0, 0, 0, 32407, 32408, 5, 36, 0, 0, 32408, 32409, 5, 36, 0, 0, 32409, 32412, 1, 0, 0, 0, 32410, 32413, 3, 4993, 2496, 0, 32411, 32413, 5, 95, 0, 0, 32412, 32410, 1, 0, 0, 0, 32412, 32411, 1, 0, 0, 0, 32413, 32414, 1, 0, 0, 0, 32414, 32412, 1, 0, 0, 0, 32414, 32415, 1, 0, 0, 0, 32415, 4986, 1, 0, 0, 0, 32416, 32418, 7, 36, 0, 0, 32417, 32416, 1, 0, 0, 0, 32418, 32419, 1, 0, 0, 0, 32419, 32417, 1, 0, 0, 0, 32419, 32420, 1, 0, 0, 0, 32420, 32421, 1, 0, 0, 0, 32421, 32422, 6, 2493, 1, 0, 32422, 4988, 1, 0, 0, 0, 32423, 32426, 3, 4997, 2498, 0, 32424, 32426, 5, 0, 0, 1, 32425, 32423, 1, 0, 0, 0, 32425, 32424, 1, 0, 0, 0, 32426, 4990, 1, 0, 0, 0, 32427, 32428, 5, 63, 0, 0, 32428, 4992, 1, 0, 0, 0, 32429, 32430, 7, 37, 0, 0, 32430, 4994, 1, 0, 0, 0, 32431, 32433, 3, 4881, 2440, 0, 32432, 32431, 1, 0, 0, 0, 32433, 32436, 1, 0, 0, 0, 32434, 32432, 1, 0, 0, 0, 32434, 32435, 1, 0, 0, 0, 32435, 32438, 1, 0, 0, 0, 32436, 32434, 1, 0, 0, 0, 32437, 32439, 5, 46, 0, 0, 32438, 32437, 1, 0, 0, 0, 32438, 32439, 1, 0, 0, 0, 32439, 32441, 1, 0, 0, 0, 32440, 32442, 3, 4881, 2440, 0, 32441, 32440, 1, 0, 0, 0, 32442, 32443, 1, 0, 0, 0, 32443, 32441, 1, 0, 0, 0, 32443, 32444, 1, 0, 0, 0, 32444, 4996, 1, 0, 0, 0, 32445, 32447, 5, 13, 0, 0, 32446, 32445, 1, 0, 0, 0, 32446, 32447, 1, 0, 0, 0, 32447, 32448, 1, 0, 0, 0, 32448, 32449, 5, 10, 0, 0, 32449, 4998, 1, 0, 0, 0, 32450, 32451, 7, 38, 0, 0, 32451, 5000, 1, 0, 0, 0, 61, 0, 19918, 19931, 19945, 19983, 19999, 20014, 20026, 20049, 23375, 32037, 32039, 32049, 32055, 32060, 32066, 32072, 32082, 32087, 32093, 32095, 32097, 32100, 32107, 32109, 32127, 32137, 32146, 32155, 32164, 32173, 32182, 32191, 32200, 32209, 32218, 32227, 32236, 32238, 32282, 32284, 32292, 32302, 32334, 32347, 32363, 32369, 32372, 32386, 32392, 32395, 32402, 32404, 32412, 32414, 32419, 32425, 32434, 32438, 32443, 32446, 2, 7, 2443, 0, 0, 1, 0] \ No newline at end of file diff --git a/internal/engine/oracle/parser/PlSqlLexer.tokens b/internal/engine/oracle/parser/PlSqlLexer.tokens new file mode 100644 index 0000000000..dfc930c197 --- /dev/null +++ b/internal/engine/oracle/parser/PlSqlLexer.tokens @@ -0,0 +1,4939 @@ +ABORT=1 +ABS=2 +ABSENT=3 +ACCESS=4 +ACCESSED=5 +ACCESSIBLE=6 +ACCOUNT=7 +ACL=8 +ACOS=9 +ACROSS=10 +ACTION=11 +ACTIONS=12 +ACTIVATE=13 +ACTIVE=14 +ACTIVE_COMPONENT=15 +ACTIVE_DATA=16 +ACTIVE_FUNCTION=17 +ACTIVE_TAG=18 +ACTIVITY=19 +ADAPTIVE_PLAN=20 +ADD=21 +ADD_COLUMN=22 +ADD_GROUP=23 +ADD_MONTHS=24 +ADJ_DATE=25 +ADMIN=26 +ADMINISTER=27 +ADMINISTRATOR=28 +ADVANCED=29 +ADVISE=30 +ADVISOR=31 +AFD_DISKSTRING=32 +AFTER=33 +AGENT=34 +AGGREGATE=35 +A_LETTER=36 +ALIAS=37 +ALL=38 +ALLOCATE=39 +ALLOW=40 +ALL_ROWS=41 +ALTER=42 +ALTERNATE=43 +ALWAYS=44 +ANALYTIC=45 +ANALYZE=46 +ANCESTOR=47 +ANCILLARY=48 +AND=49 +AND_EQUAL=50 +ANNOTATIONS=51 +ANOMALY=52 +ANSI_REARCH=53 +ANTIJOIN=54 +ANY=55 +ANYSCHEMA=56 +APPEND=57 +APPENDCHILDXML=58 +APPEND_VALUES=59 +APPLICATION=60 +APPLY=61 +APPROX_COUNT_DISTINCT=62 +ARCHIVAL=63 +ARCHIVE=64 +ARCHIVED=65 +ARCHIVELOG=66 +ARE=67 +ARRAY=68 +AS=69 +ASC=70 +ASCII=71 +ASCIISTR=72 +ASIN=73 +ASIS=74 +ASSEMBLY=75 +ASSIGN=76 +ASSOCIATE=77 +ASYNC=78 +ASYNCHRONOUS=79 +ATAN2=80 +ATAN=81 +AT=82 +ATTRIBUTE=83 +ATTRIBUTES=84 +AUDIT=85 +AUTHENTICATED=86 +AUTHENTICATION=87 +AUTHID=88 +AUTHORIZATION=89 +AUTOALLOCATE=90 +AUTO=91 +AUTOBACKUP=92 +AUTOEXTEND=93 +AUTO_LOGIN=94 +AUTOMATIC=95 +AUTONOMOUS_TRANSACTION=96 +AUTO_REOPTIMIZE=97 +AVAILABILITY=98 +AVRO=99 +BACKGROUND=100 +BACKINGFILE=101 +BACKUP=102 +BACKUPS=103 +BACKUPSET=104 +BADFILE=105 +BASIC=106 +BASICFILE=107 +BATCH=108 +BATCHSIZE=109 +BATCH_TABLE_ACCESS_BY_ROWID=110 +BECOME=111 +BEFORE=112 +BEGIN=113 +BEGINNING=114 +BEGIN_OUTLINE_DATA=115 +BEHALF=116 +BEQUEATH=117 +BETWEEN=118 +BFILE=119 +BFILENAME=120 +BIG=121 +BIGFILE=122 +BIGINT=123 +BINARY=124 +BINARY_DOUBLE=125 +BINARY_DOUBLE_INFINITY=126 +BINARY_DOUBLE_NAN=127 +BINARY_FLOAT=128 +BINARY_FLOAT_INFINITY=129 +BINARY_FLOAT_NAN=130 +BINARY_INTEGER=131 +BIND_AWARE=132 +BINDING=133 +BIN_TO_NUM=134 +BITAND=135 +BITMAP_AND=136 +BITMAP=137 +BITMAPS=138 +BITMAP_TREE=139 +BITS=140 +BLANKS=141 +BLOB=142 +BLOCK=143 +BLOCK_RANGE=144 +BLOCKS=145 +BLOCKSIZE=146 +BODY=147 +BOOLEAN=148 +BOTH=149 +BOUND=150 +BRANCH=151 +BREADTH=152 +BROADCAST=153 +BSON=154 +BUFFER=155 +BUFFER_CACHE=156 +BUFFER_POOL=157 +BUILD=158 +BULK=159 +BY=160 +BYPASS_RECURSIVE_CHECK=161 +BYPASS_UJVC=162 +BYTE=163 +BYTES=164 +BYTEORDERMARK=165 +CACHE=166 +CACHE_CB=167 +CACHE_INSTANCES=168 +CACHE_TEMP_TABLE=169 +CACHING=170 +CALCULATED=171 +CALLBACK=172 +CALL=173 +CANCEL=174 +CANONICAL=175 +CAPACITY=176 +CAPTION=177 +CARDINALITY=178 +CASCADE=179 +CASE=180 +CAST=181 +CASESENSITIVE=182 +CATEGORY=183 +CDBDEFAULT=184 +CEIL=185 +CELL_FLASH_CACHE=186 +CERTIFICATE=187 +CFILE=188 +CHAINED=189 +CHANGE=190 +CHANGETRACKING=191 +CHANGE_DUPKEY_ERROR_INDEX=192 +CHARACTER=193 +CHARACTERS=194 +CHARACTERSET=195 +CHAR=196 +CHAR_CS=197 +CHARTOROWID=198 +CHECK_ACL_REWRITE=199 +CHECK=200 +CHECKPOINT=201 +CHILD=202 +CHOOSE=203 +CHR=204 +CHUNK=205 +CLASS=206 +CLASSIFICATION=207 +CLASSIFIER=208 +CLAUSE=209 +CLEAN=210 +CLEANUP=211 +CLEAR=212 +C_LETTER=213 +CLIENT=214 +CLOB=215 +CLONE=216 +CLOSE_CACHED_OPEN_CURSORS=217 +CLOSE=218 +CLUSTER_BY_ROWID=219 +CLUSTER=220 +CLUSTER_DETAILS=221 +CLUSTER_DISTANCE=222 +CLUSTER_ID=223 +CLUSTERING=224 +CLUSTERING_FACTOR=225 +CLUSTER_PROBABILITY=226 +CLUSTER_SET=227 +COALESCE=228 +COALESCE_SQ=229 +COARSE=230 +CO_AUTH_IND=231 +COLD=232 +COLLECT=233 +COLLECTION=234 +COLUMNAR=235 +COLUMN_AUTH_INDICATOR=236 +COLUMN=237 +COLUMNS=238 +COLUMN_STATS=239 +COLUMN_VALUE=240 +COMMENT=241 +COMMIT=242 +COMMITTED=243 +COMMON=244 +COMMON_DATA=245 +COMPACT=246 +COMPATIBLE=247 +COMPATIBILITY=248 +COMPILE=249 +COMPLETE=250 +COMPLIANCE=251 +COMPONENT=252 +COMPONENTS=253 +COMPOSE=254 +COMPOSITE=255 +COMPOSITE_LIMIT=256 +COMPOUND=257 +COMPRESS=258 +COMPRESSION=259 +COMPUTE=260 +COMPUTATION=261 +CONCAT=262 +CONCURRENT=263 +CON_DBID_TO_ID=264 +CONDITIONAL=265 +CONDITION=266 +CONFIRM=267 +CONFORMING=268 +CON_GUID_TO_ID=269 +CON_ID=270 +CON_NAME_TO_ID=271 +CONNECT_BY_CB_WHR_ONLY=272 +CONNECT_BY_COMBINE_SW=273 +CONNECT_BY_COST_BASED=274 +CONNECT_BY_ELIM_DUPS=275 +CONNECT_BY_FILTERING=276 +CONNECT_BY_ISCYCLE=277 +CONNECT_BY_ISLEAF=278 +CONNECT_BY_ROOT=279 +CONNECT=280 +CONNECT_TIME=281 +CONSIDER=282 +CONSISTENT=283 +CONSTANT=284 +CONST=285 +CONSTRAINT=286 +CONSTRAINTS=287 +CONSTRUCTOR=288 +CONTAINER=289 +CONTAINERS=290 +CONTAINERS_DEFAULT=291 +CONTAINER_DATA=292 +CONTAINER_MAP=293 +CONTENT=294 +CONTENTS=295 +CONTEXT=296 +CONTINUE=297 +CONTROLFILE=298 +CON_UID_TO_ID=299 +CONVERT=300 +CONVERSION=301 +COOKIE=302 +COPY=303 +CORR_K=304 +CORR_S=305 +CORRUPTION=306 +CORRUPT_XID_ALL=307 +CORRUPT_XID=308 +COS=309 +COSH=310 +COST=311 +COST_XML_QUERY_REWRITE=312 +COUNT=313 +COUNTED=314 +COVAR_POP=315 +COVAR_SAMP=316 +CPU_COSTING=317 +CPU_PER_CALL=318 +CPU_PER_SESSION=319 +CRASH=320 +CREATE=321 +CREATE_FILE_DEST=322 +CREATE_STORED_OUTLINES=323 +CREATION=324 +CREDENTIAL=325 +CRITICAL=326 +CROSS=327 +CROSSEDITION=328 +CSCONVERT=329 +CSV=330 +CUBE_AJ=331 +CUBE=332 +CUBE_GB=333 +CUBE_SJ=334 +CUME_DISTM=335 +CURRENT=336 +CURRENT_DATE=337 +CURRENT_SCHEMA=338 +CURRENT_TIME=339 +CURRENT_TIMESTAMP=340 +CURRENT_USER=341 +CURRENTV=342 +CURSOR=343 +CURSOR_SHARING_EXACT=344 +CURSOR_SPECIFIC_SEGMENT=345 +CUSTOMDATUM=346 +CV=347 +CYCLE=348 +DANGLING=349 +DATABASE=350 +DATA=351 +DATAFILE=352 +DATAFILES=353 +DATAGUARDCONFIG=354 +DATAMOVEMENT=355 +DATAOBJNO=356 +DATAOBJ_TO_MAT_PARTITION=357 +DATAOBJ_TO_PARTITION=358 +DATAPUMP=359 +DATA_SECURITY_REWRITE_LIMIT=360 +DATE=361 +DATE_CACHE=362 +DATE_FORMAT=363 +DATE_MODE=364 +DAY=365 +DAYS=366 +DAY_TO_SECOND=367 +DBA=368 +DBA_RECYCLEBIN=369 +DBLINK=370 +DBMS_STATS=371 +DB_ROLE_CHANGE=372 +DBTIMEZONE=373 +DB_UNIQUE_NAME=374 +DB_VERSION=375 +DDL=376 +DEALLOCATE=377 +DEBUG=378 +DEBUGGER=379 +DEC=380 +DECIMAL=381 +DECLARE=382 +DECOMPOSE=383 +DECORRELATE=384 +DECR=385 +DECREMENT=386 +DECRYPT=387 +DEDUPLICATE=388 +DEFAULT=389 +DEFAULTIF=390 +DEFAULTS=391 +DEFAULT_COLLATION=392 +DEFAULT_CREDENTIAL=393 +DEFERRABLE=394 +DEFERRED=395 +DEFINED=396 +DEFINE=397 +DEFINER=398 +DEGREE=399 +DELAY=400 +DELEGATE=401 +DELETE_ALL=402 +DELETE=403 +DELETEXML=404 +DELIMITED=405 +DEMAND=406 +DENSE_RANKM=407 +DEPENDENT=408 +DEPRECATE=409 +DEPTH=410 +DEQUEUE=411 +DEREF=412 +DEREF_NO_REWRITE=413 +DESC=414 +DESCRIPTION=415 +DESTROY=416 +DETACHED=417 +DETECTED=418 +DETERMINES=419 +DETERMINISTIC=420 +DICTIONARY=421 +DIMENSION=422 +DIMENSIONS=423 +DIRECTIO=424 +DIRECT_LOAD=425 +DIRECTORY=426 +DIRECT_PATH=427 +DISABLE_ALL=428 +DISABLE=429 +DISABLED=430 +DISABLE_DIRECTORY_LINK_CHECK=431 +DISABLE_PARALLEL_DML=432 +DISABLE_PRESET=433 +DISABLE_RPKE=434 +DISALLOW=435 +DISASSOCIATE=436 +DISCARD=437 +DISCARDFILE=438 +DISCONNECT=439 +DISK=440 +DISKGROUP=441 +DISKGROUP_PLUS=442 +DISKS=443 +DISMOUNT=444 +DISTINCT=445 +DISTINGUISHED=446 +DISTRIBUTED=447 +DISTRIBUTE=448 +DML=449 +DML_UPDATE=450 +DNFS_DISABLE=451 +DNFS_ENABLE=452 +DNFS_READBUFFERS=453 +DOCFIDELITY=454 +DOCUMENT=455 +DOLLAR_ELSE=456 +DOLLAR_ELSIF=457 +DOLLAR_END=458 +DOLLAR_ERROR=459 +DOLLAR_IF=460 +DOLLAR_THEN=461 +DOMAIN_INDEX_FILTER=462 +DOMAIN_INDEX_NO_SORT=463 +DOMAIN_INDEX_SORT=464 +DOUBLE=465 +DOWNGRADE=466 +DRIVING_SITE=467 +DROP_COLUMN=468 +DROP=469 +DROP_GROUP=470 +DSINTERVAL_UNCONSTRAINED=471 +DST_UPGRADE_INSERT_CONV=472 +DUMP=473 +DUMPSET=474 +DUPLICATE=475 +DV=476 +DYNAMIC=477 +DYNAMIC_SAMPLING=478 +DYNAMIC_SAMPLING_EST_CDN=479 +E_LETTER=480 +EACH=481 +EDITIONABLE=482 +EDITION=483 +EDITIONING=484 +EDITIONS=485 +ELEMENT=486 +ELIM_GROUPBY=487 +ELIMINATE_JOIN=488 +ELIMINATE_OBY=489 +ELIMINATE_OUTER_JOIN=490 +ELSE=491 +ELSIF=492 +EM=493 +EMBEDDED=494 +EMPTY_BLOB=495 +EMPTY_CLOB=496 +EMPTY_=497 +ENABLE_ALL=498 +ENABLE=499 +ENABLED=500 +ENABLE_PARALLEL_DML=501 +ENABLE_PRESET=502 +ENCLOSED=503 +ENCODING=504 +ENCRYPT=505 +ENCRYPTION=506 +ENCRYPTPASSWORDISNULL=507 +END=508 +END_OUTLINE_DATA=509 +ENDIAN=510 +ENFORCED=511 +ENFORCE=512 +ENQUEUE=513 +ENTERPRISE=514 +ENTITYESCAPING=515 +ENTRY=516 +EQUIPART=517 +ERR=518 +ERROR_ARGUMENT=519 +ERROR=520 +ERROR_ON_OVERLAP_TIME=521 +ERRORS=522 +ERROR_INDEX=523 +ERROR_CODE=524 +ESCAPE=525 +ESCAPED=526 +ESTIMATE=527 +EVAL=528 +EVALNAME=529 +EVALUATE=530 +EVALUATION=531 +EVENTS=532 +EVERY=533 +EXCEPT=534 +EXCEPTION=535 +EXCEPTION_INIT=536 +EXCEPTIONS=537 +EXCHANGE=538 +EXCLUDE=539 +EXCLUDING=540 +EXCLUSIVE=541 +EXECUTE=542 +EXEMPT=543 +EXISTING=544 +EXISTS=545 +EXISTSNODE=546 +EXIT=547 +EXPAND_GSET_TO_UNION=548 +EXPAND_TABLE=549 +EXP=550 +EXPIRE=551 +EXPLAIN=552 +EXPLOSION=553 +EXPORT=554 +EXPR_CORR_CHECK=555 +EXPRESS=556 +EXTENDS=557 +EXTENT=558 +EXTENTS=559 +EXTERNAL=560 +EXTERNALLY=561 +EXTRACTCLOBXML=562 +EXTRACT=563 +EXTRACTVALUE=564 +EXTRA=565 +FACILITY=566 +FACT=567 +FACTOR=568 +FACTORIZE_JOIN=569 +FAILED=570 +FAILED_LOGIN_ATTEMPTS=571 +FAILGROUP=572 +FAILOVER=573 +FAILURE=574 +FALSE=575 +FAMILY=576 +FAR=577 +FAST=578 +FASTSTART=579 +FBTSCAN=580 +FEATURE=581 +FEATURE_DETAILS=582 +FEATURE_ID=583 +FEATURE_SET=584 +FEATURE_VALUE=585 +FETCH=586 +FIELD=587 +FIELDS=588 +FILE=589 +FILE_NAME_CONVERT=590 +FILEGROUP=591 +FILESTORE=592 +FILESYSTEM_LIKE_LOGGING=593 +FILTER=594 +FINAL=595 +FINE=596 +FINISH=597 +FIRST=598 +FIRSTM=599 +FIRST_ROWS=600 +FIRST_VALUE=601 +FIXED=602 +FIXED_VIEW_DATA=603 +FLAGGER=604 +FLASHBACK=605 +FLASH_CACHE=606 +FLOAT=607 +FLOB=608 +FLEX=609 +FLOOR=610 +FLUSH=611 +FOLDER=612 +FOLLOWING=613 +FOLLOWS=614 +FORALL=615 +FORCE=616 +FORCE_XML_QUERY_REWRITE=617 +FOREIGN=618 +FOREVER=619 +FOR=620 +FORMAT=621 +FORWARD=622 +FRAGMENT_NUMBER=623 +FREELIST=624 +FREELISTS=625 +FREEPOOLS=626 +FRESH=627 +FROM=628 +FROM_TZ=629 +FULL=630 +FULL_OUTER_JOIN_TO_OUTER=631 +FUNCTION=632 +FUNCTIONS=633 +FTP=634 +G_LETTER=635 +GATHER_OPTIMIZER_STATISTICS=636 +GATHER_PLAN_STATISTICS=637 +GBY_CONC_ROLLUP=638 +GBY_PUSHDOWN=639 +GENERATED=640 +GET=641 +GLOBAL=642 +GLOBALLY=643 +GLOBAL_NAME=644 +GLOBAL_TOPIC_ENABLED=645 +GOTO=646 +GRANT=647 +GROUP_BY=648 +GROUP=649 +GROUP_ID=650 +GROUPING=651 +GROUPING_ID=652 +GROUPS=653 +GUARANTEED=654 +GUARANTEE=655 +GUARD=656 +HADOOP_TRAILERS=657 +HALF_YEARS=658 +HASH_AJ=659 +HASH=660 +HASHKEYS=661 +HASH_SJ=662 +HAVING=663 +HEADER=664 +HEAP=665 +HELP=666 +HEXTORAW=667 +HEXTOREF=668 +HIDDEN_KEYWORD=669 +HIDE=670 +HIER_ORDER=671 +HIERARCHICAL=672 +HIERARCHIES=673 +HIERARCHY=674 +HIGH=675 +HINTSET_BEGIN=676 +HINTSET_END=677 +HOT=678 +HOUR=679 +HOURS=680 +HTTP=681 +HWM_BROKERED=682 +HYBRID=683 +H_LETTER=684 +IDENTIFIED=685 +IDENTIFIER=686 +IDENTITY=687 +IDGENERATORS=688 +ID=689 +IDLE_TIME=690 +IF=691 +IGNORE=692 +IGNORE_CHARS_AFTER_EOR=693 +IGNORE_OPTIM_EMBEDDED_HINTS=694 +IGNORE_ROW_ON_DUPKEY_INDEX=695 +IGNORE_WHERE_CLAUSE=696 +ILM=697 +IMMEDIATE=698 +IMPACT=699 +IMPORT=700 +INACTIVE=701 +INACTIVE_ACCOUNT_TIME=702 +INCLUDE=703 +INCLUDE_VERSION=704 +INCLUDING=705 +INCREMENTAL=706 +INCREMENT=707 +INCR=708 +INDENT=709 +INDEX_ASC=710 +INDEX_COMBINE=711 +INDEX_DESC=712 +INDEXED=713 +INDEXES=714 +INDEX_FFS=715 +INDEX_FILTER=716 +INDEX=717 +INDEXING=718 +INDEX_JOIN=719 +INDEX_ROWS=720 +INDEX_RRS=721 +INDEX_RS_ASC=722 +INDEX_RS_DESC=723 +INDEX_RS=724 +INDEX_SCAN=725 +INDEX_SKIP_SCAN=726 +INDEX_SS_ASC=727 +INDEX_SS_DESC=728 +INDEX_SS=729 +INDEX_STATS=730 +INDEXTYPE=731 +INDEXTYPES=732 +INDICATOR=733 +INDICES=734 +INFINITE=735 +INFORMATIONAL=736 +INHERIT=737 +IN=738 +INITCAP=739 +INITIAL=740 +INITIALIZED=741 +INITIALLY=742 +INITRANS=743 +INLINE=744 +INLINE_XMLTYPE_NT=745 +INMEMORY=746 +IN_MEMORY_METADATA=747 +INMEMORY_PRUNING=748 +INNER=749 +INOUT=750 +INPLACE=751 +INPUTFORMAT=752 +INSERTCHILDXMLAFTER=753 +INSERTCHILDXMLBEFORE=754 +INSERTCHILDXML=755 +INSERT=756 +INSERTXMLAFTER=757 +INSERTXMLBEFORE=758 +INSTANCE=759 +INSTANCES=760 +INSTANTIABLE=761 +INSTANTLY=762 +INSTEAD=763 +INSTR2=764 +INSTR4=765 +INSTRB=766 +INSTRC=767 +INSTR=768 +INTEGER=769 +INTERLEAVED=770 +INTERMEDIATE=771 +INTERNAL_CONVERT=772 +INTERNAL_USE=773 +INTERPRETED=774 +INTERSECT=775 +INTERVAL=776 +INT=777 +INTERNAL=778 +INTO=779 +INVALIDATE=780 +INVALIDATION=781 +INVISIBLE=782 +IN_XQUERY=783 +IO_OPTIONS=784 +IS=785 +IS_LEAF=786 +ISOLATION=787 +ISOLATION_LEVEL=788 +ITEMS=789 +ITERATE=790 +ITERATION_NUMBER=791 +JAVA=792 +JOB=793 +JOIN=794 +JSON_ARRAYAGG=795 +JSON_ARRAY=796 +JSON_EQUAL=797 +JSON_EXISTS2=798 +JSON_EXISTS=799 +JSONGET=800 +JSON=801 +JSON_OBJECTAGG=802 +JSON_OBJECT=803 +JSONPARSE=804 +JSON_QUERY=805 +JSON_SERIALIZE=806 +JSON_TABLE=807 +JSON_TEXTCONTAINS2=808 +JSON_TEXTCONTAINS=809 +JSON_TRANSFORM=810 +JSON_VALUE=811 +K_LETTER=812 +KEEP_DUPLICATES=813 +KEEP=814 +KERBEROS=815 +KEY=816 +KEY_LENGTH=817 +KEYSIZE=818 +KEYS=819 +KEYSTORE=820 +KILL=821 +LABEL=822 +LANGUAGE=823 +LAST_DAY=824 +LAST=825 +LAST_VALUE=826 +LATERAL=827 +LATEST=828 +LAX=829 +LAYER=830 +LDAP_REGISTRATION_ENABLED=831 +LDAP_REGISTRATION=832 +LDAP_REG_SYNC_INTERVAL=833 +LDRTRIM=834 +LEAF=835 +LEAD_CDB=836 +LEAD_CDB_URI=837 +LEADING=838 +LEFT=839 +LENGTH2=840 +LENGTH4=841 +LENGTHB=842 +LENGTHC=843 +LENGTH=844 +LESS=845 +LEVEL=846 +LEVEL_NAME=847 +LEVELS=848 +LIBRARY=849 +LIFECYCLE=850 +LIFE=851 +LIFETIME=852 +LIKE2=853 +LIKE4=854 +LIKEC=855 +LIKE_EXPAND=856 +LIKE=857 +LIMIT=858 +LINEAR=859 +LINES=860 +LINK=861 +LIST=862 +LITTLE=863 +LLS=864 +LN=865 +LNNVL=866 +LOAD=867 +LOB=868 +LOBFILE=869 +LOBNVL=870 +LOBS=871 +LOCAL_INDEXES=872 +LOCAL=873 +LOCALTIME=874 +LOCALTIMESTAMP=875 +LOCATION=876 +LOCATOR=877 +LOCKDOWN=878 +LOCKED=879 +LOCKING=880 +LOCK=881 +LOGFILE=882 +LOGFILES=883 +LOGGING=884 +LOGICAL=885 +LOGICAL_READS_PER_CALL=886 +LOGICAL_READS_PER_SESSION=887 +LOG=888 +LOGMINING=889 +LOGOFF=890 +LOGON=891 +LOG_READ_ONLY_VIOLATIONS=892 +LONG=893 +LOOP=894 +LOST=895 +LOWER=896 +LOW=897 +LPAD=898 +LRTRIM=899 +LTRIM=900 +M_LETTER=901 +MAIN=902 +MAKE_REF=903 +MANAGED=904 +MANAGE=905 +MANAGEMENT=906 +MANAGER=907 +MANDATORY=908 +MANUAL=909 +MAP=910 +MAPPING=911 +MASK=912 +MASTER=913 +MATCHED=914 +MATCHES=915 +MATCH=916 +MATCH_NUMBER=917 +MATCH_RECOGNIZE=918 +MATERIALIZED=919 +MATERIALIZE=920 +MAXARCHLOGS=921 +MAXDATAFILES=922 +MAXEXTENTS=923 +MAXIMIZE=924 +MAXINSTANCES=925 +MAXLOGFILES=926 +MAXLOGHISTORY=927 +MAXLOGMEMBERS=928 +MAX_SHARED_TEMP_SIZE=929 +MAXSIZE=930 +MAXTRANS=931 +MAXVALUE=932 +MEASURE=933 +MEASURES=934 +MEDIUM=935 +MEMBER=936 +MEMBER_CAPTION=937 +MEMBER_DESCRIPTION=938 +MEMBER_NAME=939 +MEMBER_UNIQUE_NAME=940 +MEMCOMPRESS=941 +MEMORY=942 +MERGEACTIONS=943 +MERGE_AJ=944 +MERGE_CONST_ON=945 +MERGE=946 +MERGE_SJ=947 +METADATA=948 +METHOD=949 +MIGRATE=950 +MIGRATION=951 +MINEXTENTS=952 +MINIMIZE=953 +MINIMUM=954 +MINING=955 +MINUS=956 +MINUS_NULL=957 +MINUTE=958 +MINUTES=959 +MINVALUE=960 +MIRRORCOLD=961 +MIRRORHOT=962 +MIRROR=963 +MISSING=964 +MISMATCH=965 +MLSLABEL=966 +MODEL_COMPILE_SUBQUERY=967 +MODEL_DONTVERIFY_UNIQUENESS=968 +MODEL_DYNAMIC_SUBQUERY=969 +MODEL_MIN_ANALYSIS=970 +MODEL=971 +MODEL_NB=972 +MODEL_NO_ANALYSIS=973 +MODEL_PBY=974 +MODEL_PUSH_REF=975 +MODEL_SV=976 +MODE=977 +MODIFICATION=978 +MODIFY_COLUMN_TYPE=979 +MODIFY=980 +MOD=981 +MODULE=982 +MONITORING=983 +MONITOR=984 +MONTH=985 +MONTHS_BETWEEN=986 +MONTHS=987 +MOUNT=988 +MOUNTPATH=989 +MOUNTPOINT=990 +MOVEMENT=991 +MOVE=992 +MULTIDIMENSIONAL=993 +MULTISET=994 +MV_MERGE=995 +NAMED=996 +NAME=997 +NAMESPACE=998 +NAN_=999 +NANVL=1000 +NATIONAL=1001 +NATIVE_FULL_OUTER_JOIN=1002 +NATIVE=1003 +NATURAL=1004 +NATURALN=1005 +NAV=1006 +NCHAR_CS=1007 +NCHAR=1008 +NCHR=1009 +NCLOB=1010 +NEEDED=1011 +NEG=1012 +NESTED=1013 +NESTED_TABLE_FAST_INSERT=1014 +NESTED_TABLE_GET_REFS=1015 +NESTED_TABLE_ID=1016 +NESTED_TABLE_SET_REFS=1017 +NESTED_TABLE_SET_SETID=1018 +NETWORK=1019 +NEVER=1020 +NEW=1021 +NEWLINE_=1022 +NEW_TIME=1023 +NEXT_DAY=1024 +NEXT=1025 +NL_AJ=1026 +NLJ_BATCHING=1027 +NLJ_INDEX_FILTER=1028 +NLJ_INDEX_SCAN=1029 +NLJ_PREFETCH=1030 +NLS_CALENDAR=1031 +NLS_CHARACTERSET=1032 +NLS_CHARSET_DECL_LEN=1033 +NLS_CHARSET_ID=1034 +NLS_CHARSET_NAME=1035 +NLS_COMP=1036 +NLS_CURRENCY=1037 +NLS_DATE_FORMAT=1038 +NLS_DATE_LANGUAGE=1039 +NLS_INITCAP=1040 +NLS_ISO_CURRENCY=1041 +NL_SJ=1042 +NLS_LANG=1043 +NLS_LANGUAGE=1044 +NLS_LENGTH_SEMANTICS=1045 +NLS_LOWER=1046 +NLS_NCHAR_CONV_EXCP=1047 +NLS_NUMERIC_CHARACTERS=1048 +NLS_SORT=1049 +NLSSORT=1050 +NLS_SPECIAL_CHARS=1051 +NLS_TERRITORY=1052 +NLS_UPPER=1053 +NO_ACCESS=1054 +NO_ADAPTIVE_PLAN=1055 +NO_ANSI_REARCH=1056 +NOAPPEND=1057 +NOARCHIVELOG=1058 +NOAUDIT=1059 +NOBADFILE=1060 +NO_AUTO_REOPTIMIZE=1061 +NO_BASETABLE_MULTIMV_REWRITE=1062 +NO_BATCH_TABLE_ACCESS_BY_ROWID=1063 +NO_BIND_AWARE=1064 +NO_BUFFER=1065 +NOCACHE=1066 +NOCHECK=1067 +NO_CARTESIAN=1068 +NO_CHECK_ACL_REWRITE=1069 +NO_CLUSTER_BY_ROWID=1070 +NO_CLUSTERING=1071 +NO_COALESCE_SQ=1072 +NO_COMMON_DATA=1073 +NOCOMPRESS=1074 +NO_CONNECT_BY_CB_WHR_ONLY=1075 +NO_CONNECT_BY_COMBINE_SW=1076 +NO_CONNECT_BY_COST_BASED=1077 +NO_CONNECT_BY_ELIM_DUPS=1078 +NO_CONNECT_BY_FILTERING=1079 +NOCOPY=1080 +NO_COST_XML_QUERY_REWRITE=1081 +NO_CPU_COSTING=1082 +NOCPU_COSTING=1083 +NOCYCLE=1084 +NO_DATA_SECURITY_REWRITE=1085 +NO_DECORRELATE=1086 +NODELAY=1087 +NODIRECTIO=1088 +NODISCARDFILE=1089 +NO_DOMAIN_INDEX_FILTER=1090 +NO_DST_UPGRADE_INSERT_CONV=1091 +NO_ELIM_GROUPBY=1092 +NO_ELIMINATE_JOIN=1093 +NO_ELIMINATE_OBY=1094 +NO_ELIMINATE_OUTER_JOIN=1095 +NOENTITYESCAPING=1096 +NO_EXPAND_GSET_TO_UNION=1097 +NO_EXPAND=1098 +NO_EXPAND_TABLE=1099 +NOEXTEND=1100 +NO_FACT=1101 +NO_FACTORIZE_JOIN=1102 +NO_FILTERING=1103 +NOFORCE=1104 +NO_FULL_OUTER_JOIN_TO_OUTER=1105 +NO_GATHER_OPTIMIZER_STATISTICS=1106 +NO_GBY_PUSHDOWN=1107 +NOGUARANTEE=1108 +NO_INDEX_FFS=1109 +NO_INDEX=1110 +NO_INDEX_SS=1111 +NO_INMEMORY=1112 +NO_INMEMORY_PRUNING=1113 +NOKEEP=1114 +NO_LOAD=1115 +NOLOCAL=1116 +NOLOG=1117 +NOLOGFILE=1118 +NOLOGGING=1119 +NOMAPPING=1120 +NOMAXVALUE=1121 +NO_MERGE=1122 +NOMINIMIZE=1123 +NOMINVALUE=1124 +NO_MODEL_PUSH_REF=1125 +NO_MONITORING=1126 +NOMONITORING=1127 +NO_MONITOR=1128 +NO_MULTIMV_REWRITE=1129 +NO_NATIVE_FULL_OUTER_JOIN=1130 +NONBLOCKING=1131 +NONEDITIONABLE=1132 +NONE=1133 +NONULLIF=1134 +NO_NLJ_BATCHING=1135 +NO_NLJ_PREFETCH=1136 +NO=1137 +NONSCHEMA=1138 +NO_OBJECT_LINK=1139 +NOORDER=1140 +NO_ORDER_ROLLUPS=1141 +NO_OUTER_JOIN_TO_ANTI=1142 +NO_OUTER_JOIN_TO_INNER=1143 +NOOVERRIDE=1144 +NO_PARALLEL_INDEX=1145 +NOPARALLEL_INDEX=1146 +NO_PARALLEL=1147 +NOPARALLEL=1148 +NO_PARTIAL_COMMIT=1149 +NO_PARTIAL_JOIN=1150 +NO_PARTIAL_ROLLUP_PUSHDOWN=1151 +NOPARTITION=1152 +NO_PLACE_DISTINCT=1153 +NO_PLACE_GROUP_BY=1154 +NO_PQ_CONCURRENT_UNION=1155 +NO_PQ_MAP=1156 +NOPROMPT=1157 +NO_PQ_REPLICATE=1158 +NO_PQ_SKEW=1159 +NO_PRUNE_GSETS=1160 +NO_PULL_PRED=1161 +NO_PUSH_PRED=1162 +NO_PUSH_SUBQ=1163 +NO_PX_FAULT_TOLERANCE=1164 +NO_PX_JOIN_FILTER=1165 +NO_QKN_BUFF=1166 +NO_QUERY_TRANSFORMATION=1167 +NO_REF_CASCADE=1168 +NORELOCATE=1169 +NORELY=1170 +NOREPAIR=1171 +NOREPLAY=1172 +NORESETLOGS=1173 +NO_RESULT_CACHE=1174 +NOREVERSE=1175 +NO_REWRITE=1176 +NOREWRITE=1177 +NORMAL=1178 +NO_ROOT_SW_FOR_LOCAL=1179 +NOROWDEPENDENCIES=1180 +NOSCALE=1181 +NOSCHEMACHECK=1182 +NOSEGMENT=1183 +NO_SEMIJOIN=1184 +NO_SEMI_TO_INNER=1185 +NO_SET_TO_JOIN=1186 +NOSHARD=1187 +NOSORT=1188 +NO_SQL_TRANSLATION=1189 +NO_SQL_TUNE=1190 +NO_STAR_TRANSFORMATION=1191 +NO_STATEMENT_QUEUING=1192 +NO_STATS_GSETS=1193 +NOSTRICT=1194 +NO_SUBQUERY_PRUNING=1195 +NO_SUBSTRB_PAD=1196 +NO_SWAP_JOIN_INPUTS=1197 +NOSWITCH=1198 +NO_TABLE_LOOKUP_BY_NL=1199 +NO_TEMP_TABLE=1200 +NOTHING=1201 +NOTIFICATION=1202 +NOTRIM=1203 +NOT=1204 +NO_TRANSFORM_DISTINCT_AGG=1205 +NO_UNNEST=1206 +NO_USE_CUBE=1207 +NO_USE_HASH_AGGREGATION=1208 +NO_USE_HASH_GBY_FOR_PUSHDOWN=1209 +NO_USE_HASH=1210 +NO_USE_INVISIBLE_INDEXES=1211 +NO_USE_MERGE=1212 +NO_USE_NL=1213 +NO_USE_VECTOR_AGGREGATION=1214 +NOVALIDATE=1215 +NO_VECTOR_TRANSFORM_DIMS=1216 +NO_VECTOR_TRANSFORM_FACT=1217 +NO_VECTOR_TRANSFORM=1218 +NOWAIT=1219 +NO_XDB_FASTPATH_INSERT=1220 +NO_XML_DML_REWRITE=1221 +NO_XMLINDEX_REWRITE_IN_SELECT=1222 +NO_XMLINDEX_REWRITE=1223 +NO_XML_QUERY_REWRITE=1224 +NO_ZONEMAP=1225 +NTH_VALUE=1226 +NULLIF=1227 +NULL_=1228 +NULLS=1229 +NUMBER=1230 +NUMERIC=1231 +NUM_INDEX_KEYS=1232 +NUMTODSINTERVAL=1233 +NUMTOYMINTERVAL=1234 +NVARCHAR2=1235 +NVL2=1236 +OBJECT2XML=1237 +OBJECT=1238 +OBJ_ID=1239 +OBJNO=1240 +OBJNO_REUSE=1241 +OCCURENCES=1242 +OFFLINE=1243 +OFF=1244 +OFFSET=1245 +OF=1246 +OIDINDEX=1247 +OID=1248 +OLAP=1249 +OLD=1250 +OLD_PUSH_PRED=1251 +OLS=1252 +OLTP=1253 +OMIT=1254 +ONE=1255 +ONLINE=1256 +ONLINELOG=1257 +ONLY=1258 +ON=1259 +OPAQUE=1260 +OPAQUE_TRANSFORM=1261 +OPAQUE_XCANONICAL=1262 +OPCODE=1263 +OPEN=1264 +OPERATIONS=1265 +OPERATOR=1266 +OPT_ESTIMATE=1267 +OPTIMAL=1268 +OPTIMIZE=1269 +OPTIMIZER_FEATURES_ENABLE=1270 +OPTIMIZER_GOAL=1271 +OPTION=1272 +OPTIONALLY=1273 +OPT_PARAM=1274 +ORA_BRANCH=1275 +ORA_CHECK_ACL=1276 +ORA_CHECK_PRIVILEGE=1277 +ORA_CLUSTERING=1278 +ORADATA=1279 +ORC=1280 +ORACLE_DATE=1281 +ORACLE_NUMBER=1282 +ORADEBUG=1283 +ORA_DST_AFFECTED=1284 +ORA_DST_CONVERT=1285 +ORA_DST_ERROR=1286 +ORA_GET_ACLIDS=1287 +ORA_GET_PRIVILEGES=1288 +ORA_HASH=1289 +ORA_INVOKING_USERID=1290 +ORA_INVOKING_USER=1291 +ORA_INVOKING_XS_USER_GUID=1292 +ORA_INVOKING_XS_USER=1293 +ORA_RAWCOMPARE=1294 +ORA_RAWCONCAT=1295 +ORA_ROWSCN=1296 +ORA_ROWSCN_RAW=1297 +ORA_ROWVERSION=1298 +ORA_TABVERSION=1299 +ORA_WRITE_TIME=1300 +ORDERED=1301 +ORDERED_PREDICATES=1302 +ORDER=1303 +ORDINALITY=1304 +OR_EXPAND=1305 +ORGANIZATION=1306 +OR=1307 +OR_PREDICATES=1308 +OSERROR=1309 +OTHER=1310 +OUTER_JOIN_TO_ANTI=1311 +OUTER_JOIN_TO_INNER=1312 +OUTER=1313 +OUTLINE_LEAF=1314 +OUTLINE=1315 +OUTPUTFORMAT=1316 +OUT_OF_LINE=1317 +OUT=1318 +OVERFLOW_NOMOVE=1319 +OVERFLOW_=1320 +OVERLAPS=1321 +OVER=1322 +OVERRIDE=1323 +OVERRIDING=1324 +OWNER=1325 +OWNERSHIP=1326 +OWN=1327 +P_LETTER=1328 +PACKAGE=1329 +PACKAGES=1330 +PARALLEL_ENABLE=1331 +PARALLEL_INDEX=1332 +PARALLEL=1333 +PARAMETERFILE=1334 +PARAMETERS=1335 +PARAM=1336 +PARENT=1337 +PARENT_LEVEL_NAME=1338 +PARENT_UNIQUE_NAME=1339 +PARITY=1340 +PARQUET=1341 +PARTIAL_JOIN=1342 +PARTIALLY=1343 +PARTIAL=1344 +PARTIAL_ROLLUP_PUSHDOWN=1345 +PARTITION_HASH=1346 +PARTITION_LIST=1347 +PARTITION=1348 +PARTITION_RANGE=1349 +PARTITIONS=1350 +PARTNUMINST=1351 +PASSING=1352 +PASSWORD_GRACE_TIME=1353 +PASSWORD_LIFE_TIME=1354 +PASSWORD_LOCK_TIME=1355 +PASSWORD=1356 +PASSWORD_REUSE_MAX=1357 +PASSWORD_REUSE_TIME=1358 +PASSWORD_ROLLOVER_TIME=1359 +PASSWORD_VERIFY_FUNCTION=1360 +PAST=1361 +PATCH=1362 +PATH=1363 +PATH_PREFIX=1364 +PATHS=1365 +PATTERN=1366 +PBL_HS_BEGIN=1367 +PBL_HS_END=1368 +PCTFREE=1369 +PCTINCREASE=1370 +PCTTHRESHOLD=1371 +PCTUSED=1372 +PCTVERSION=1373 +PENDING=1374 +PERCENT_FOUND=1375 +PERCENT_ISOPEN=1376 +PERCENT_NOTFOUND=1377 +PERCENT_KEYWORD=1378 +PERCENT_RANKM=1379 +PERCENT_ROWCOUNT=1380 +PERCENT_ROWTYPE=1381 +PERCENT_TYPE=1382 +PERCENT_BULK_EXCEPTIONS=1383 +PERCENT_BULK_ROWCOUNT=1384 +PERFORMANCE=1385 +PERIOD_KEYWORD=1386 +PERMANENT=1387 +PERMISSION=1388 +PERMUTE=1389 +PER=1390 +PFILE=1391 +PHYSICAL=1392 +PIKEY=1393 +PIPELINED=1394 +PIPE=1395 +PIV_GB=1396 +PIVOT=1397 +PIV_SSF=1398 +PLACE_DISTINCT=1399 +PLACE_GROUP_BY=1400 +PLAN=1401 +PLSCOPE_SETTINGS=1402 +PLS_INTEGER=1403 +PLSQL_CCFLAGS=1404 +PLSQL_CODE_TYPE=1405 +PLSQL_DEBUG=1406 +PLSQL_OPTIMIZE_LEVEL=1407 +PLSQL_WARNINGS=1408 +PLUGGABLE=1409 +PMEM=1410 +POINT=1411 +POLICY=1412 +POOL_16K=1413 +POOL_2K=1414 +POOL_32K=1415 +POOL_4K=1416 +POOL_8K=1417 +POSITION=1418 +POSITIVEN=1419 +POSITIVE=1420 +POST_TRANSACTION=1421 +POWERMULTISET_BY_CARDINALITY=1422 +POWERMULTISET=1423 +POWER=1424 +PQ_CONCURRENT_UNION=1425 +PQ_DISTRIBUTE=1426 +PQ_DISTRIBUTE_WINDOW=1427 +PQ_FILTER=1428 +PQ_MAP=1429 +PQ_NOMAP=1430 +PQ_REPLICATE=1431 +PQ_SKEW=1432 +PRAGMA=1433 +PREBUILT=1434 +PRECEDES=1435 +PRECEDING=1436 +PRECISION=1437 +PRECOMPUTE_SUBQUERY=1438 +PREDICATE_REORDERS=1439 +PRELOAD=1440 +PREPARE=1441 +PREPROCESSOR=1442 +PRESENTNNV=1443 +PRESENT=1444 +PRESENTV=1445 +PRESERVE_OID=1446 +PRESERVE=1447 +PRETTY=1448 +PREVIOUS=1449 +PREV=1450 +PRIMARY=1451 +PRINTBLOBTOCLOB=1452 +PRIORITY=1453 +PRIOR=1454 +PRIVATE=1455 +PRIVATE_SGA=1456 +PRIVILEGED=1457 +PRIVILEGE=1458 +PRIVILEGES=1459 +PROCEDURAL=1460 +PROCEDURE=1461 +PROCESS=1462 +PROFILE=1463 +PROGRAM=1464 +PROJECT=1465 +PROPAGATE=1466 +PROPERTY=1467 +PROTECTED=1468 +PROTECTION=1469 +PROTOCOL=1470 +PROXY=1471 +PRUNING=1472 +PUBLIC=1473 +PULL_PRED=1474 +PURGE=1475 +PUSH_PRED=1476 +PUSH_SUBQ=1477 +PX_FAULT_TOLERANCE=1478 +PX_GRANULE=1479 +PX_JOIN_FILTER=1480 +QB_NAME=1481 +QUARTERS=1482 +QUERY_BLOCK=1483 +QUERY=1484 +QUEUE_CURR=1485 +QUEUE=1486 +QUEUE_ROWP=1487 +QUIESCE=1488 +QUORUM=1489 +QUOTA=1490 +QUOTAGROUP=1491 +RAISE=1492 +RANDOM_LOCAL=1493 +RANDOM=1494 +RANGE=1495 +RANKM=1496 +RAPIDLY=1497 +RAW=1498 +RAWTOHEX=1499 +RAWTONHEX=1500 +RBA=1501 +RBO_OUTLINE=1502 +RCFILE=1503 +RDBA=1504 +READ=1505 +READS=1506 +READSIZE=1507 +REALM=1508 +REAL=1509 +REBALANCE=1510 +REBUILD=1511 +RECORD=1512 +RECORDS=1513 +RECORDS_PER_BLOCK=1514 +RECOVERABLE=1515 +RECOVER=1516 +RECOVERY=1517 +RECYCLEBIN=1518 +RECYCLE=1519 +REDACTION=1520 +REDEFINE=1521 +REDO=1522 +REDUCED=1523 +REDUNDANCY=1524 +REF_CASCADE_CURSOR=1525 +REFERENCED=1526 +REFERENCE=1527 +REFERENCES=1528 +REFERENCING=1529 +REF=1530 +REFRESH=1531 +REFTOHEX=1532 +REGEXP_COUNT=1533 +REGEXP_INSTR=1534 +REGEXP_LIKE=1535 +REGEXP_REPLACE=1536 +REGEXP_SUBSTR=1537 +REGISTER=1538 +REGR_AVGX=1539 +REGR_AVGY=1540 +REGR_COUNT=1541 +REGR_INTERCEPT=1542 +REGR_R2=1543 +REGR_SLOPE=1544 +REGR_SXX=1545 +REGR_SXY=1546 +REGR_SYY=1547 +REGULAR=1548 +REJECT=1549 +REKEY=1550 +RELATIONAL=1551 +RELIES_ON=1552 +RELOCATE=1553 +RELY=1554 +REMAINDER=1555 +REMOTE=1556 +REMOTE_MAPPED=1557 +REMOVE=1558 +RENAME=1559 +REPAIR=1560 +REPEAT=1561 +REPLACE=1562 +REPLICATION=1563 +REQUIRED=1564 +RESETLOGS=1565 +RESET=1566 +RESIZE=1567 +RESOLVE=1568 +RESOLVER=1569 +RESOURCE=1570 +RESPECT=1571 +RESTART=1572 +RESTORE_AS_INTERVALS=1573 +RESTORE=1574 +RESTRICT_ALL_REF_CONS=1575 +RESTRICTED=1576 +RESTRICT_REFERENCES=1577 +RESTRICT=1578 +RESULT_CACHE=1579 +RESULT=1580 +RESUMABLE=1581 +RESUME=1582 +RETENTION=1583 +RETRY_ON_ROW_CHANGE=1584 +RETURNING=1585 +RETURN=1586 +REUSE=1587 +REVERSE=1588 +REVOKE=1589 +REWRITE_OR_ERROR=1590 +REWRITE=1591 +RIGHT=1592 +ROLE=1593 +ROLESET=1594 +ROLES=1595 +ROLLBACK=1596 +ROLLING=1597 +ROLLUP=1598 +ROWDEPENDENCIES=1599 +ROWID_MAPPING_TABLE=1600 +ROWID=1601 +ROWIDTOCHAR=1602 +ROWIDTONCHAR=1603 +ROW_LENGTH=1604 +ROWNUM=1605 +ROW=1606 +ROWS=1607 +RPAD=1608 +RTRIM=1609 +RULE=1610 +RULES=1611 +RUNNING=1612 +SALT=1613 +SAMPLE=1614 +SAVE_AS_INTERVALS=1615 +SAVEPOINT=1616 +SAVE=1617 +SB4=1618 +SCALE_ROWS=1619 +SCALE=1620 +SCAN_INSTANCES=1621 +SCAN=1622 +SCHEDULER=1623 +SCHEMACHECK=1624 +SCHEMA=1625 +SCN_ASCENDING=1626 +SCN=1627 +SCOPE=1628 +SCRUB=1629 +SD_ALL=1630 +SD_INHIBIT=1631 +SDO_GEOM_MBR=1632 +SDO_GEOMETRY=1633 +SD_SHOW=1634 +SEARCH=1635 +SECOND=1636 +SECONDS=1637 +SECRET=1638 +SECUREFILE_DBA=1639 +SECUREFILE=1640 +SECURITY=1641 +SEED=1642 +SEG_BLOCK=1643 +SEG_FILE=1644 +SEGMENT=1645 +SELECTIVITY=1646 +SELECT=1647 +SELF=1648 +SEMIJOIN_DRIVER=1649 +SEMIJOIN=1650 +SEMI_TO_INNER=1651 +SEQUENCED=1652 +SEQUENCE=1653 +SEQUENCEFILE=1654 +SEQUENTIAL=1655 +SEQ=1656 +SERDE=1657 +SERDEPROPERTIES=1658 +SERIALIZABLE=1659 +SERIALLY_REUSABLE=1660 +SERIAL=1661 +SERVERERROR=1662 +SERVICE_NAME_CONVERT=1663 +SERVICE=1664 +SERVICES=1665 +SESSION_CACHED_CURSORS=1666 +SESSION=1667 +SESSIONS_PER_USER=1668 +SESSIONTIMEZONE=1669 +SESSIONTZNAME=1670 +SET=1671 +SETS=1672 +SETTINGS=1673 +SET_TO_JOIN=1674 +SEVERE=1675 +SHARD=1676 +SHARDSPACE=1677 +SHARED_POOL=1678 +SHARED=1679 +SHARE=1680 +SHARING=1681 +SHELFLIFE=1682 +SHOW=1683 +SHRINK=1684 +SHUTDOWN=1685 +SIBLINGS=1686 +SID=1687 +SITE=1688 +SIGNAL_COMPONENT=1689 +SIGNAL_FUNCTION=1690 +SIGN=1691 +SIGNTYPE=1692 +SIMPLE_INTEGER=1693 +SIMPLE=1694 +SINGLE=1695 +SINGLETASK=1696 +SINH=1697 +SIN=1698 +SIZE=1699 +SIZES=1700 +SKIP_EXT_OPTIMIZER=1701 +SKIP_=1702 +SKIP_UNQ_UNUSABLE_IDX=1703 +SKIP_UNUSABLE_INDEXES=1704 +SMALLFILE=1705 +SMALLINT=1706 +SNAPSHOT=1707 +SOME=1708 +SORT=1709 +SOUNDEX=1710 +SOURCE_FILE_DIRECTORY=1711 +SOURCE_FILE_NAME_CONVERT=1712 +SOURCE=1713 +SPACE_KEYWORD=1714 +SPECIFICATION=1715 +SPFILE=1716 +SPLIT=1717 +SPREADSHEET=1718 +SQLDATA=1719 +SQLERROR=1720 +SQLLDR=1721 +SQL=1722 +FILE_EXT=1723 +SQL_MACRO=1724 +SQL_TRACE=1725 +SQL_TRANSLATION_PROFILE=1726 +SQRT=1727 +STALE=1728 +STANDALONE=1729 +STANDARD=1730 +STANDARD_HASH=1731 +STANDBY_MAX_DATA_DELAY=1732 +STANDBYS=1733 +STANDBY=1734 +STAR=1735 +STAR_TRANSFORMATION=1736 +START=1737 +STARTOF=1738 +STARTUP=1739 +STATEMENT_ID=1740 +STATEMENT_QUEUING=1741 +STATEMENTS=1742 +STATEMENT=1743 +STATE=1744 +STATIC=1745 +STATISTICS=1746 +STATS_BINOMIAL_TEST=1747 +STATS_CROSSTAB=1748 +STATS_F_TEST=1749 +STATS_KS_TEST=1750 +STATS_MODE=1751 +STATS_MW_TEST=1752 +STATS_ONE_WAY_ANOVA=1753 +STATS_T_TEST_INDEP=1754 +STATS_T_TEST_INDEPU=1755 +STATS_T_TEST_ONE=1756 +STATS_T_TEST_PAIRED=1757 +STATS_WSR_TEST=1758 +STDDEV_POP=1759 +STDDEV_SAMP=1760 +STOP=1761 +STORAGE=1762 +STORE=1763 +STREAMS=1764 +STREAM=1765 +STRICT=1766 +STRING=1767 +STRIPE_COLUMNS=1768 +STRIPE_WIDTH=1769 +STRIP=1770 +STRUCTURE=1771 +SUBMULTISET=1772 +SUBPARTITION_REL=1773 +SUBPARTITIONS=1774 +SUBPARTITION=1775 +SUBQUERIES=1776 +SUBQUERY_PRUNING=1777 +SUBSCRIBE=1778 +SUBSET=1779 +SUBSTITUTABLE=1780 +SUBSTR2=1781 +SUBSTR4=1782 +SUBSTRB=1783 +SUBSTRC=1784 +SUBTYPE=1785 +SUCCESSFUL=1786 +SUCCESS=1787 +SUMMARY=1788 +SUPPLEMENTAL=1789 +SUSPEND=1790 +SWAP_JOIN_INPUTS=1791 +SWITCHOVER=1792 +SWITCH=1793 +SYNCHRONOUS=1794 +SYNC=1795 +SYNONYM=1796 +SYS=1797 +SYSASM=1798 +SYS_AUDIT=1799 +SYSAUX=1800 +SYSBACKUP=1801 +SYS_CHECKACL=1802 +SYS_CHECK_PRIVILEGE=1803 +SYS_CONNECT_BY_PATH=1804 +SYS_CONTEXT=1805 +SYSDATE=1806 +SYSDBA=1807 +SYS_DBURIGEN=1808 +SYSDG=1809 +SYS_DL_CURSOR=1810 +SYS_DM_RXFORM_CHR=1811 +SYS_DM_RXFORM_NUM=1812 +SYS_DOM_COMPARE=1813 +SYS_DST_PRIM2SEC=1814 +SYS_DST_SEC2PRIM=1815 +SYS_ET_BFILE_TO_RAW=1816 +SYS_ET_BLOB_TO_IMAGE=1817 +SYS_ET_IMAGE_TO_BLOB=1818 +SYS_ET_RAW_TO_BFILE=1819 +SYS_EXTPDTXT=1820 +SYS_EXTRACT_UTC=1821 +SYS_FBT_INSDEL=1822 +SYS_FILTER_ACLS=1823 +SYS_FNMATCHES=1824 +SYS_FNREPLACE=1825 +SYS_GET_ACLIDS=1826 +SYS_GET_COL_ACLIDS=1827 +SYS_GET_PRIVILEGES=1828 +SYS_GETTOKENID=1829 +SYS_GETXTIVAL=1830 +SYS_GUID=1831 +SYSGUID=1832 +SYSKM=1833 +SYS_MAKE_XMLNODEID=1834 +SYS_MAKEXML=1835 +SYS_MKXMLATTR=1836 +SYS_MKXTI=1837 +SYSOBJ=1838 +SYS_OP_ADT2BIN=1839 +SYS_OP_ADTCONS=1840 +SYS_OP_ALSCRVAL=1841 +SYS_OP_ATG=1842 +SYS_OP_BIN2ADT=1843 +SYS_OP_BITVEC=1844 +SYS_OP_BL2R=1845 +SYS_OP_BLOOM_FILTER_LIST=1846 +SYS_OP_BLOOM_FILTER=1847 +SYS_OP_C2C=1848 +SYS_OP_CAST=1849 +SYS_OP_CEG=1850 +SYS_OP_CL2C=1851 +SYS_OP_COMBINED_HASH=1852 +SYS_OP_COMP=1853 +SYS_OP_CONVERT=1854 +SYS_OP_COUNTCHG=1855 +SYS_OP_CSCONV=1856 +SYS_OP_CSCONVTEST=1857 +SYS_OP_CSR=1858 +SYS_OP_CSX_PATCH=1859 +SYS_OP_CYCLED_SEQ=1860 +SYS_OP_DECOMP=1861 +SYS_OP_DESCEND=1862 +SYS_OP_DISTINCT=1863 +SYS_OP_DRA=1864 +SYS_OP_DUMP=1865 +SYS_OP_DV_CHECK=1866 +SYS_OP_ENFORCE_NOT_NULL=1867 +SYSOPER=1868 +SYS_OP_EXTRACT=1869 +SYS_OP_GROUPING=1870 +SYS_OP_GUID=1871 +SYS_OP_HASH=1872 +SYS_OP_IIX=1873 +SYS_OP_ITR=1874 +SYS_OP_KEY_VECTOR_CREATE=1875 +SYS_OP_KEY_VECTOR_FILTER_LIST=1876 +SYS_OP_KEY_VECTOR_FILTER=1877 +SYS_OP_KEY_VECTOR_SUCCEEDED=1878 +SYS_OP_KEY_VECTOR_USE=1879 +SYS_OP_LBID=1880 +SYS_OP_LOBLOC2BLOB=1881 +SYS_OP_LOBLOC2CLOB=1882 +SYS_OP_LOBLOC2ID=1883 +SYS_OP_LOBLOC2NCLOB=1884 +SYS_OP_LOBLOC2TYP=1885 +SYS_OP_LSVI=1886 +SYS_OP_LVL=1887 +SYS_OP_MAKEOID=1888 +SYS_OP_MAP_NONNULL=1889 +SYS_OP_MSR=1890 +SYS_OP_NICOMBINE=1891 +SYS_OP_NIEXTRACT=1892 +SYS_OP_NII=1893 +SYS_OP_NIX=1894 +SYS_OP_NOEXPAND=1895 +SYS_OP_NTCIMG=1896 +SYS_OP_NUMTORAW=1897 +SYS_OP_OIDVALUE=1898 +SYS_OP_OPNSIZE=1899 +SYS_OP_PAR_1=1900 +SYS_OP_PARGID_1=1901 +SYS_OP_PARGID=1902 +SYS_OP_PAR=1903 +SYS_OP_PART_ID=1904 +SYS_OP_PIVOT=1905 +SYS_OP_R2O=1906 +SYS_OP_RAWTONUM=1907 +SYS_OP_RDTM=1908 +SYS_OP_REF=1909 +SYS_OP_RMTD=1910 +SYS_OP_ROWIDTOOBJ=1911 +SYS_OP_RPB=1912 +SYS_OPTLOBPRBSC=1913 +SYS_OP_TOSETID=1914 +SYS_OP_TPR=1915 +SYS_OP_TRTB=1916 +SYS_OPTXICMP=1917 +SYS_OPTXQCASTASNQ=1918 +SYS_OP_UNDESCEND=1919 +SYS_OP_VECAND=1920 +SYS_OP_VECBIT=1921 +SYS_OP_VECOR=1922 +SYS_OP_VECXOR=1923 +SYS_OP_VERSION=1924 +SYS_OP_VREF=1925 +SYS_OP_VVD=1926 +SYS_OP_XMLCONS_FOR_CSX=1927 +SYS_OP_XPTHATG=1928 +SYS_OP_XPTHIDX=1929 +SYS_OP_XPTHOP=1930 +SYS_OP_XTXT2SQLT=1931 +SYS_OP_ZONE_ID=1932 +SYS_ORDERKEY_DEPTH=1933 +SYS_ORDERKEY_MAXCHILD=1934 +SYS_ORDERKEY_PARENT=1935 +SYS_PARALLEL_TXN=1936 +SYS_PATHID_IS_ATTR=1937 +SYS_PATHID_IS_NMSPC=1938 +SYS_PATHID_LASTNAME=1939 +SYS_PATHID_LASTNMSPC=1940 +SYS_PATH_REVERSE=1941 +SYS_PXQEXTRACT=1942 +SYS_RAW_TO_XSID=1943 +SYS_RID_ORDER=1944 +SYS_ROW_DELTA=1945 +SYS_SC_2_XMLT=1946 +SYS_SYNRCIREDO=1947 +SYSTEM_DEFINED=1948 +SYSTEM=1949 +SYSTIMESTAMP=1950 +SYS_TYPEID=1951 +SYS_UMAKEXML=1952 +SYS_XMLANALYZE=1953 +SYS_XMLCONTAINS=1954 +SYS_XMLCONV=1955 +SYS_XMLEXNSURI=1956 +SYS_XMLGEN=1957 +SYS_XMLI_LOC_ISNODE=1958 +SYS_XMLI_LOC_ISTEXT=1959 +SYS_XMLINSTR=1960 +SYS_XMLLOCATOR_GETSVAL=1961 +SYS_XMLNODEID_GETCID=1962 +SYS_XMLNODEID_GETLOCATOR=1963 +SYS_XMLNODEID_GETOKEY=1964 +SYS_XMLNODEID_GETPATHID=1965 +SYS_XMLNODEID_GETPTRID=1966 +SYS_XMLNODEID_GETRID=1967 +SYS_XMLNODEID_GETSVAL=1968 +SYS_XMLNODEID_GETTID=1969 +SYS_XMLNODEID=1970 +SYS_XMLT_2_SC=1971 +SYS_XMLTRANSLATE=1972 +SYS_XMLTYPE2SQL=1973 +SYS_XQ_ASQLCNV=1974 +SYS_XQ_ATOMCNVCHK=1975 +SYS_XQBASEURI=1976 +SYS_XQCASTABLEERRH=1977 +SYS_XQCODEP2STR=1978 +SYS_XQCODEPEQ=1979 +SYS_XQCON2SEQ=1980 +SYS_XQCONCAT=1981 +SYS_XQDELETE=1982 +SYS_XQDFLTCOLATION=1983 +SYS_XQDOC=1984 +SYS_XQDOCURI=1985 +SYS_XQDURDIV=1986 +SYS_XQED4URI=1987 +SYS_XQENDSWITH=1988 +SYS_XQERRH=1989 +SYS_XQERR=1990 +SYS_XQESHTMLURI=1991 +SYS_XQEXLOBVAL=1992 +SYS_XQEXSTWRP=1993 +SYS_XQEXTRACT=1994 +SYS_XQEXTRREF=1995 +SYS_XQEXVAL=1996 +SYS_XQFB2STR=1997 +SYS_XQFNBOOL=1998 +SYS_XQFNCMP=1999 +SYS_XQFNDATIM=2000 +SYS_XQFNLNAME=2001 +SYS_XQFNNM=2002 +SYS_XQFNNSURI=2003 +SYS_XQFNPREDTRUTH=2004 +SYS_XQFNQNM=2005 +SYS_XQFNROOT=2006 +SYS_XQFORMATNUM=2007 +SYS_XQFTCONTAIN=2008 +SYS_XQFUNCR=2009 +SYS_XQGETCONTENT=2010 +SYS_XQINDXOF=2011 +SYS_XQINSERT=2012 +SYS_XQINSPFX=2013 +SYS_XQIRI2URI=2014 +SYS_XQLANG=2015 +SYS_XQLLNMFRMQNM=2016 +SYS_XQMKNODEREF=2017 +SYS_XQNILLED=2018 +SYS_XQNODENAME=2019 +SYS_XQNORMSPACE=2020 +SYS_XQNORMUCODE=2021 +SYS_XQ_NRNG=2022 +SYS_XQNSP4PFX=2023 +SYS_XQNSPFRMQNM=2024 +SYS_XQPFXFRMQNM=2025 +SYS_XQ_PKSQL2XML=2026 +SYS_XQPOLYABS=2027 +SYS_XQPOLYADD=2028 +SYS_XQPOLYCEL=2029 +SYS_XQPOLYCSTBL=2030 +SYS_XQPOLYCST=2031 +SYS_XQPOLYDIV=2032 +SYS_XQPOLYFLR=2033 +SYS_XQPOLYMOD=2034 +SYS_XQPOLYMUL=2035 +SYS_XQPOLYRND=2036 +SYS_XQPOLYSQRT=2037 +SYS_XQPOLYSUB=2038 +SYS_XQPOLYUMUS=2039 +SYS_XQPOLYUPLS=2040 +SYS_XQPOLYVEQ=2041 +SYS_XQPOLYVGE=2042 +SYS_XQPOLYVGT=2043 +SYS_XQPOLYVLE=2044 +SYS_XQPOLYVLT=2045 +SYS_XQPOLYVNE=2046 +SYS_XQREF2VAL=2047 +SYS_XQRENAME=2048 +SYS_XQREPLACE=2049 +SYS_XQRESVURI=2050 +SYS_XQRNDHALF2EVN=2051 +SYS_XQRSLVQNM=2052 +SYS_XQRYENVPGET=2053 +SYS_XQRYVARGET=2054 +SYS_XQRYWRP=2055 +SYS_XQSEQ2CON4XC=2056 +SYS_XQSEQ2CON=2057 +SYS_XQSEQDEEPEQ=2058 +SYS_XQSEQINSB=2059 +SYS_XQSEQRM=2060 +SYS_XQSEQRVS=2061 +SYS_XQSEQSUB=2062 +SYS_XQSEQTYPMATCH=2063 +SYS_XQSTARTSWITH=2064 +SYS_XQSTATBURI=2065 +SYS_XQSTR2CODEP=2066 +SYS_XQSTRJOIN=2067 +SYS_XQSUBSTRAFT=2068 +SYS_XQSUBSTRBEF=2069 +SYS_XQTOKENIZE=2070 +SYS_XQTREATAS=2071 +SYS_XQ_UPKXML2SQL=2072 +SYS_XQXFORM=2073 +SYS_XSID_TO_RAW=2074 +SYS_ZMAP_FILTER=2075 +SYS_ZMAP_REFRESH=2076 +T_LETTER=2077 +TABLE_LOOKUP_BY_NL=2078 +TABLESPACE_NO=2079 +TABLESPACE=2080 +TABLES=2081 +TABLE_STATS=2082 +TABLE=2083 +TABNO=2084 +TAG=2085 +TANH=2086 +TAN=2087 +TBLORIDXPARTNUM=2088 +TEMPFILE=2089 +TEMPLATE=2090 +TEMPLATE_TABLE=2091 +TEMPORARY=2092 +TEMP_TABLE=2093 +TERMINATED=2094 +TEST=2095 +TEXT=2096 +TEXTFILE=2097 +THAN=2098 +THEN=2099 +THE=2100 +THESE=2101 +THREAD=2102 +THROUGH=2103 +TIER=2104 +TIES=2105 +TIMEOUT=2106 +TIMESTAMP_LTZ_UNCONSTRAINED=2107 +TIMESTAMP=2108 +TIMESTAMP_TZ_UNCONSTRAINED=2109 +TIMESTAMP_UNCONSTRAINED=2110 +TIMES=2111 +TIME=2112 +TIMEZONE=2113 +TIMEZONE_ABBR=2114 +TIMEZONE_HOUR=2115 +TIMEZONE_MINUTE=2116 +TIMEZONE_OFFSET=2117 +TIMEZONE_REGION=2118 +TIME_ZONE=2119 +TIMING=2120 +TINYINT=2121 +TIV_GB=2122 +TIV_SSF=2123 +TO_ACLID=2124 +TO_BINARY_DOUBLE=2125 +TO_BINARY_FLOAT=2126 +TO_BLOB=2127 +TO_CLOB=2128 +TO_DSINTERVAL=2129 +TO_LOB=2130 +TO_MULTI_BYTE=2131 +TO_NCHAR=2132 +TO_NCLOB=2133 +TO_NUMBER=2134 +TOPLEVEL=2135 +TO_SINGLE_BYTE=2136 +TO_TIMESTAMP=2137 +TO_TIMESTAMP_TZ=2138 +TO_TIME=2139 +TO_TIME_TZ=2140 +TO=2141 +TO_YMINTERVAL=2142 +TRACE=2143 +TRACING=2144 +TRACKING=2145 +TRAILING=2146 +TRANSACTION=2147 +TRANSFORM=2148 +TRANSFORMS=2149 +TRANSFORM_DISTINCT_AGG=2150 +TRANSITIONAL=2151 +TRANSITION=2152 +TRANSLATE=2153 +TRANSLATION=2154 +TREAT=2155 +TRIGGERS=2156 +TRIGGER=2157 +TRUE=2158 +TRUNCATE=2159 +TRUNC=2160 +TRUSTED=2161 +TRUST=2162 +TUNING=2163 +TX=2164 +TYPES=2165 +TYPE=2166 +TZ_OFFSET=2167 +UB2=2168 +UBA=2169 +UCS2=2170 +UDF=2171 +UID=2172 +UNARCHIVED=2173 +UNBOUNDED=2174 +UNBOUND=2175 +UNCONDITIONAL=2176 +UNDER=2177 +UNDO=2178 +UNDROP=2179 +UNIFORM=2180 +UNION=2181 +UNIONTYPE=2182 +UNIQUE=2183 +UNISTR=2184 +UNLIMITED=2185 +UNLOAD=2186 +UNLOCK=2187 +UNMATCHED=2188 +UNNEST_INNERJ_DISTINCT_VIEW=2189 +UNNEST_NOSEMIJ_NODISTINCTVIEW=2190 +UNNEST_SEMIJ_VIEW=2191 +UNNEST=2192 +UNPACKED=2193 +UNPIVOT=2194 +UNPLUG=2195 +UNPROTECTED=2196 +UNQUIESCE=2197 +UNRECOVERABLE=2198 +UNRESTRICTED=2199 +UNSIGNED=2200 +UNSUBSCRIBE=2201 +UNTIL=2202 +UNUSABLE=2203 +UNUSED=2204 +UPDATABLE=2205 +UPDATED=2206 +UPDATE=2207 +UPDATEXML=2208 +UPD_INDEXES=2209 +UPD_JOININDEX=2210 +UPGRADE=2211 +UPPER=2212 +UPSERT=2213 +UROWID=2214 +USABLE=2215 +USAGE=2216 +USE_ANTI=2217 +USE_CONCAT=2218 +USE_CUBE=2219 +USE_HASH_AGGREGATION=2220 +USE_HASH_GBY_FOR_PUSHDOWN=2221 +USE_HASH=2222 +USE_HIDDEN_PARTITIONS=2223 +USE_INVISIBLE_INDEXES=2224 +USE_MERGE_CARTESIAN=2225 +USE_MERGE=2226 +USE_NL=2227 +USE_NL_WITH_INDEX=2228 +USE_PRIVATE_OUTLINES=2229 +USER_DATA=2230 +USER_DEFINED=2231 +USERENV=2232 +USERGROUP=2233 +USER_RECYCLEBIN=2234 +USERS=2235 +USER_TABLESPACES=2236 +USER=2237 +USE_SEMI=2238 +USE_STORED_OUTLINES=2239 +USE_TTT_FOR_GSETS=2240 +USE=2241 +USE_VECTOR_AGGREGATION=2242 +USE_WEAK_NAME_RESL=2243 +USING_NO_EXPAND=2244 +USING_NLS_COMP=2245 +USING=2246 +UTF16BE=2247 +UTF16LE=2248 +UTF32=2249 +UTF8=2250 +V1=2251 +V2=2252 +VALIDATE=2253 +VALIDATE_CONVERSION=2254 +VALIDATION=2255 +VALID_TIME_END=2256 +VALUES=2257 +VALUE=2258 +VARCHAR2=2259 +VARCHAR=2260 +VARCHARC=2261 +VARIABLE=2262 +VARRAW=2263 +VARRAWC=2264 +VAR_POP=2265 +VARRAYS=2266 +VARRAY=2267 +VAR_SAMP=2268 +VARYING=2269 +VECTOR_READ_TRACE=2270 +VECTOR_READ=2271 +VECTOR_TRANSFORM_DIMS=2272 +VECTOR_TRANSFORM_FACT=2273 +VECTOR_TRANSFORM=2274 +VERIFIER=2275 +VERIFY=2276 +VERSIONING=2277 +VERSIONS_ENDSCN=2278 +VERSIONS_ENDTIME=2279 +VERSIONS_OPERATION=2280 +VERSIONS_STARTSCN=2281 +VERSIONS_STARTTIME=2282 +VERSIONS=2283 +VERSIONS_XID=2284 +VERSION=2285 +VIEW=2286 +VIOLATION=2287 +VIRTUAL=2288 +VISIBILITY=2289 +VISIBLE=2290 +VOLUME=2291 +VSIZE=2292 +WAIT=2293 +WALLET=2294 +WARNING=2295 +WEEKS=2296 +WEEK=2297 +WELLFORMED=2298 +WHENEVER=2299 +WHEN=2300 +WHERE=2301 +WHILE=2302 +WHITESPACE=2303 +WIDTH_BUCKET=2304 +WITHIN=2305 +WITHOUT=2306 +WITH_PLSQL=2307 +WITH=2308 +WORK=2309 +WORKERID=2310 +WRAPPED=2311 +WRAPPER=2312 +WRITE=2313 +XDB_FASTPATH_INSERT=2314 +XDB=2315 +X_DYN_PRUNE=2316 +XID=2317 +XML2OBJECT=2318 +XMLAGG=2319 +XMLATTRIBUTES=2320 +XMLCAST=2321 +XMLCDATA=2322 +XMLCOLATTVAL=2323 +XMLCOMMENT=2324 +XMLCONCAT=2325 +XMLDIFF=2326 +XML_DML_RWT_STMT=2327 +XMLELEMENT=2328 +XMLEXISTS2=2329 +XMLEXISTS=2330 +XMLFOREST=2331 +XMLINDEX=2332 +XMLINDEX_REWRITE_IN_SELECT=2333 +XMLINDEX_REWRITE=2334 +XMLINDEX_SEL_IDX_TBL=2335 +XMLISNODE=2336 +XMLISVALID=2337 +XMLNAMESPACES=2338 +XMLPARSE=2339 +XMLPATCH=2340 +XMLPI=2341 +XMLQUERYVAL=2342 +XMLQUERY=2343 +XMLROOT=2344 +XMLSCHEMA=2345 +XMLSERIALIZE=2346 +XMLTABLE=2347 +XMLTAG=2348 +XMLTRANSFORMBLOB=2349 +XMLTRANSFORM=2350 +XMLTYPE=2351 +XML=2352 +XPATHTABLE=2353 +XS_SYS_CONTEXT=2354 +XS=2355 +XTRANSPORT=2356 +YEARS=2357 +YEAR=2358 +YEAR_TO_MONTH=2359 +YES=2360 +YMINTERVAL_UNCONSTRAINED=2361 +ZONEMAP=2362 +ZONE=2363 +ZONED=2364 +PREDICTION=2365 +PREDICTION_BOUNDS=2366 +PREDICTION_COST=2367 +PREDICTION_DETAILS=2368 +PREDICTION_PROBABILITY=2369 +PREDICTION_SET=2370 +BLOCKCHAIN=2371 +COLLATE=2372 +COLLATION=2373 +DEFINITION=2374 +DUPLICATED=2375 +EXTENDED=2376 +HASHING=2377 +IDLE=2378 +IMMUTABLE=2379 +ORACLE_DATAPUMP=2380 +ORACLE_HDFS=2381 +ORACLE_HIVE=2382 +ORACLE_LOADER=2383 +SHA2_512_Q=2384 +SHARDED=2385 +V1_Q=2386 +ISOLATE=2387 +ROOT=2388 +UNITE=2389 +ALGORITHM=2390 +CUME_DIST=2391 +DENSE_RANK=2392 +LISTAGG=2393 +PERCENT_RANK=2394 +PERCENTILE_CONT=2395 +PERCENTILE_DISC=2396 +RANK=2397 +AVG=2398 +CORR=2399 +COVAR_=2400 +DECODE=2401 +LAG=2402 +LAG_DIFF=2403 +LAG_DIFF_PERCENT=2404 +LEAD=2405 +MAX=2406 +MEDIAN=2407 +MEMOPTIMIZE=2408 +MIN=2409 +NTILE=2410 +NVL=2411 +RATIO_TO_REPORT=2412 +REGR_=2413 +ROUND=2414 +ROW_NUMBER=2415 +SUBSTR=2416 +TO_CHAR=2417 +TRIM=2418 +SUM=2419 +STDDEV=2420 +VAR_=2421 +VARIANCE=2422 +LEAST=2423 +GREATEST=2424 +TO_DATE=2425 +CHARSETID=2426 +CHARSETFORM=2427 +DURATION=2428 +EXTEND=2429 +MAXLEN=2430 +PERSISTABLE=2431 +POLYMORPHIC=2432 +STRUCT=2433 +TDO=2434 +WM_CONCAT=2435 +NATIONAL_CHAR_STRING_LIT=2436 +BIT_STRING_LIT=2437 +HEX_STRING_LIT=2438 +DOUBLE_PERIOD=2439 +PERIOD=2440 +UNSIGNED_INTEGER=2441 +APPROXIMATE_NUM_LIT=2442 +CHAR_STRING=2443 +DELIMITED_ID=2444 +PERCENT=2445 +AMPERSAND=2446 +LEFT_PAREN=2447 +RIGHT_PAREN=2448 +DOUBLE_ASTERISK=2449 +ASTERISK=2450 +PLUS_SIGN=2451 +MINUS_SIGN=2452 +COMMA=2453 +SOLIDUS=2454 +RSOLIDUS=2455 +AT_SIGN=2456 +ASSIGN_OP=2457 +HASH_OP=2458 +LEFT_CURLY_PAREN=2459 +RIGHT_CURLY_PAREN=2460 +SQ=2461 +BINDVAR=2462 +NOT_EQUAL_OP=2463 +CARRET_OPERATOR_PART=2464 +TILDE_OPERATOR_PART=2465 +EXCLAMATION_OPERATOR_PART=2466 +GREATER_THAN_OP=2467 +LESS_THAN_OP=2468 +COLON=2469 +SEMICOLON=2470 +BAR=2471 +EQUALS_OP=2472 +LEFT_BRACKET=2473 +RIGHT_BRACKET=2474 +INTRODUCER=2475 +SINGLE_LINE_COMMENT=2476 +MULTI_LINE_COMMENT=2477 +REMARK_COMMENT=2478 +PROMPT_MESSAGE=2479 +REGULAR_ID=2480 +INQUIRY_DIRECTIVE=2481 +SPACES=2482 +'ABORT'=1 +'ABS'=2 +'ABSENT'=3 +'ACCESS'=4 +'ACCESSED'=5 +'ACCESSIBLE'=6 +'ACCOUNT'=7 +'ACL'=8 +'ACOS'=9 +'ACROSS'=10 +'ACTION'=11 +'ACTIONS'=12 +'ACTIVATE'=13 +'ACTIVE'=14 +'ACTIVE_COMPONENT'=15 +'ACTIVE_DATA'=16 +'ACTIVE_FUNCTION'=17 +'ACTIVE_TAG'=18 +'ACTIVITY'=19 +'ADAPTIVE_PLAN'=20 +'ADD'=21 +'ADD_COLUMN'=22 +'ADD_GROUP'=23 +'ADD_MONTHS'=24 +'ADJ_DATE'=25 +'ADMIN'=26 +'ADMINISTER'=27 +'ADMINISTRATOR'=28 +'ADVANCED'=29 +'ADVISE'=30 +'ADVISOR'=31 +'AFD_DISKSTRING'=32 +'AFTER'=33 +'AGENT'=34 +'AGGREGATE'=35 +'A'=36 +'ALIAS'=37 +'ALL'=38 +'ALLOCATE'=39 +'ALLOW'=40 +'ALL_ROWS'=41 +'ALTER'=42 +'ALTERNATE'=43 +'ALWAYS'=44 +'ANALYTIC'=45 +'ANALYZE'=46 +'ANCESTOR'=47 +'ANCILLARY'=48 +'AND'=49 +'AND_EQUAL'=50 +'ANNOTATIONS'=51 +'ANOMALY'=52 +'ANSI_REARCH'=53 +'ANTIJOIN'=54 +'ANY'=55 +'ANYSCHEMA'=56 +'APPEND'=57 +'APPENDCHILDXML'=58 +'APPEND_VALUES'=59 +'APPLICATION'=60 +'APPLY'=61 +'APPROX_COUNT_DISTINCT'=62 +'ARCHIVAL'=63 +'ARCHIVE'=64 +'ARCHIVED'=65 +'ARCHIVELOG'=66 +'ARE'=67 +'ARRAY'=68 +'AS'=69 +'ASC'=70 +'ASCII'=71 +'ASCIISTR'=72 +'ASIN'=73 +'ASIS'=74 +'ASSEMBLY'=75 +'ASSIGN'=76 +'ASSOCIATE'=77 +'ASYNC'=78 +'ASYNCHRONOUS'=79 +'ATAN2'=80 +'ATAN'=81 +'AT'=82 +'ATTRIBUTE'=83 +'ATTRIBUTES'=84 +'AUDIT'=85 +'AUTHENTICATED'=86 +'AUTHENTICATION'=87 +'AUTHID'=88 +'AUTHORIZATION'=89 +'AUTOALLOCATE'=90 +'AUTO'=91 +'AUTOBACKUP'=92 +'AUTOEXTEND'=93 +'AUTO_LOGIN'=94 +'AUTOMATIC'=95 +'AUTONOMOUS_TRANSACTION'=96 +'AUTO_REOPTIMIZE'=97 +'AVAILABILITY'=98 +'AVRO'=99 +'BACKGROUND'=100 +'BACKINGFILE'=101 +'BACKUP'=102 +'BACKUPS'=103 +'BACKUPSET'=104 +'BADFILE'=105 +'BASIC'=106 +'BASICFILE'=107 +'BATCH'=108 +'BATCHSIZE'=109 +'BATCH_TABLE_ACCESS_BY_ROWID'=110 +'BECOME'=111 +'BEFORE'=112 +'BEGIN'=113 +'BEGINNING'=114 +'BEGIN_OUTLINE_DATA'=115 +'BEHALF'=116 +'BEQUEATH'=117 +'BETWEEN'=118 +'BFILE'=119 +'BFILENAME'=120 +'BIG'=121 +'BIGFILE'=122 +'BIGINT'=123 +'BINARY'=124 +'BINARY_DOUBLE'=125 +'BINARY_DOUBLE_INFINITY'=126 +'BINARY_DOUBLE_NAN'=127 +'BINARY_FLOAT'=128 +'BINARY_FLOAT_INFINITY'=129 +'BINARY_FLOAT_NAN'=130 +'BINARY_INTEGER'=131 +'BIND_AWARE'=132 +'BINDING'=133 +'BIN_TO_NUM'=134 +'BITAND'=135 +'BITMAP_AND'=136 +'BITMAP'=137 +'BITMAPS'=138 +'BITMAP_TREE'=139 +'BITS'=140 +'BLANKS'=141 +'BLOB'=142 +'BLOCK'=143 +'BLOCK_RANGE'=144 +'BLOCKS'=145 +'BLOCKSIZE'=146 +'BODY'=147 +'BOOLEAN'=148 +'BOTH'=149 +'BOUND'=150 +'BRANCH'=151 +'BREADTH'=152 +'BROADCAST'=153 +'BSON'=154 +'BUFFER'=155 +'BUFFER_CACHE'=156 +'BUFFER_POOL'=157 +'BUILD'=158 +'BULK'=159 +'BY'=160 +'BYPASS_RECURSIVE_CHECK'=161 +'BYPASS_UJVC'=162 +'BYTE'=163 +'BYTES'=164 +'BYTEORDERMARK'=165 +'CACHE'=166 +'CACHE_CB'=167 +'CACHE_INSTANCES'=168 +'CACHE_TEMP_TABLE'=169 +'CACHING'=170 +'CALCULATED'=171 +'CALLBACK'=172 +'CALL'=173 +'CANCEL'=174 +'CANONICAL'=175 +'CAPACITY'=176 +'CAPTION'=177 +'CARDINALITY'=178 +'CASCADE'=179 +'CASE'=180 +'CAST'=181 +'CASE-SENSITIVE'=182 +'CATEGORY'=183 +'CDB$DEFAULT'=184 +'CEIL'=185 +'CELL_FLASH_CACHE'=186 +'CERTIFICATE'=187 +'CFILE'=188 +'CHAINED'=189 +'CHANGE'=190 +'CHANGETRACKING'=191 +'CHANGE_DUPKEY_ERROR_INDEX'=192 +'CHARACTER'=193 +'CHARACTERS'=194 +'CHARACTERSET'=195 +'CHAR'=196 +'CHAR_CS'=197 +'CHARTOROWID'=198 +'CHECK_ACL_REWRITE'=199 +'CHECK'=200 +'CHECKPOINT'=201 +'CHILD'=202 +'CHOOSE'=203 +'CHR'=204 +'CHUNK'=205 +'CLASS'=206 +'CLASSIFICATION'=207 +'CLASSIFIER'=208 +'CLAUSE'=209 +'CLEAN'=210 +'CLEANUP'=211 +'CLEAR'=212 +'C'=213 +'CLIENT'=214 +'CLOB'=215 +'CLONE'=216 +'CLOSE_CACHED_OPEN_CURSORS'=217 +'CLOSE'=218 +'CLUSTER_BY_ROWID'=219 +'CLUSTER'=220 +'CLUSTER_DETAILS'=221 +'CLUSTER_DISTANCE'=222 +'CLUSTER_ID'=223 +'CLUSTERING'=224 +'CLUSTERING_FACTOR'=225 +'CLUSTER_PROBABILITY'=226 +'CLUSTER_SET'=227 +'COALESCE'=228 +'COALESCE_SQ'=229 +'COARSE'=230 +'CO_AUTH_IND'=231 +'COLD'=232 +'COLLECT'=233 +'COLLECTION'=234 +'COLUMNAR'=235 +'COLUMN_AUTH_INDICATOR'=236 +'COLUMN'=237 +'COLUMNS'=238 +'COLUMN_STATS'=239 +'COLUMN_VALUE'=240 +'COMMENT'=241 +'COMMIT'=242 +'COMMITTED'=243 +'COMMON'=244 +'COMMON_DATA'=245 +'COMPACT'=246 +'COMPATIBLE'=247 +'COMPATIBILITY'=248 +'COMPILE'=249 +'COMPLETE'=250 +'COMPLIANCE'=251 +'COMPONENT'=252 +'COMPONENTS'=253 +'COMPOSE'=254 +'COMPOSITE'=255 +'COMPOSITE_LIMIT'=256 +'COMPOUND'=257 +'COMPRESS'=258 +'COMPRESSION'=259 +'COMPUTE'=260 +'COMPUTATION'=261 +'CONCAT'=262 +'CONCURRENT'=263 +'CON_DBID_TO_ID'=264 +'CONDITIONAL'=265 +'CONDITION'=266 +'CONFIRM'=267 +'CONFORMING'=268 +'CON_GUID_TO_ID'=269 +'CON_ID'=270 +'CON_NAME_TO_ID'=271 +'CONNECT_BY_CB_WHR_ONLY'=272 +'CONNECT_BY_COMBINE_SW'=273 +'CONNECT_BY_COST_BASED'=274 +'CONNECT_BY_ELIM_DUPS'=275 +'CONNECT_BY_FILTERING'=276 +'CONNECT_BY_ISCYCLE'=277 +'CONNECT_BY_ISLEAF'=278 +'CONNECT_BY_ROOT'=279 +'CONNECT'=280 +'CONNECT_TIME'=281 +'CONSIDER'=282 +'CONSISTENT'=283 +'CONSTANT'=284 +'CONST'=285 +'CONSTRAINT'=286 +'CONSTRAINTS'=287 +'CONSTRUCTOR'=288 +'CONTAINER'=289 +'CONTAINERS'=290 +'CONTAINERS_DEFAULT'=291 +'CONTAINER_DATA'=292 +'CONTAINER_MAP'=293 +'CONTENT'=294 +'CONTENTS'=295 +'CONTEXT'=296 +'CONTINUE'=297 +'CONTROLFILE'=298 +'CON_UID_TO_ID'=299 +'CONVERT'=300 +'CONVERSION'=301 +'COOKIE'=302 +'COPY'=303 +'CORR_K'=304 +'CORR_S'=305 +'CORRUPTION'=306 +'CORRUPT_XID_ALL'=307 +'CORRUPT_XID'=308 +'COS'=309 +'COSH'=310 +'COST'=311 +'COST_XML_QUERY_REWRITE'=312 +'COUNT'=313 +'COUNTED'=314 +'COVAR_POP'=315 +'COVAR_SAMP'=316 +'CPU_COSTING'=317 +'CPU_PER_CALL'=318 +'CPU_PER_SESSION'=319 +'CRASH'=320 +'CREATE'=321 +'CREATE_FILE_DEST'=322 +'CREATE_STORED_OUTLINES'=323 +'CREATION'=324 +'CREDENTIAL'=325 +'CRITICAL'=326 +'CROSS'=327 +'CROSSEDITION'=328 +'CSCONVERT'=329 +'CSV'=330 +'CUBE_AJ'=331 +'CUBE'=332 +'CUBE_GB'=333 +'CUBE_SJ'=334 +'CUME_DISTM'=335 +'CURRENT'=336 +'CURRENT_DATE'=337 +'CURRENT_SCHEMA'=338 +'CURRENT_TIME'=339 +'CURRENT_TIMESTAMP'=340 +'CURRENT_USER'=341 +'CURRENTV'=342 +'CURSOR'=343 +'CURSOR_SHARING_EXACT'=344 +'CURSOR_SPECIFIC_SEGMENT'=345 +'CUSTOMDATUM'=346 +'CV'=347 +'CYCLE'=348 +'DANGLING'=349 +'DATABASE'=350 +'DATA'=351 +'DATAFILE'=352 +'DATAFILES'=353 +'DATAGUARDCONFIG'=354 +'DATAMOVEMENT'=355 +'DATAOBJNO'=356 +'DATAOBJ_TO_MAT_PARTITION'=357 +'DATAOBJ_TO_PARTITION'=358 +'DATAPUMP'=359 +'DATA_SECURITY_REWRITE_LIMIT'=360 +'DATE'=361 +'DATE_CACHE'=362 +'DATE_FORMAT'=363 +'DATE_MODE'=364 +'DAY'=365 +'DAYS'=366 +'DAY_TO_SECOND'=367 +'DBA'=368 +'DBA_RECYCLEBIN'=369 +'DBLINK'=370 +'DBMS_STATS'=371 +'DB_ROLE_CHANGE'=372 +'DBTIMEZONE'=373 +'DB_UNIQUE_NAME'=374 +'DB_VERSION'=375 +'DDL'=376 +'DEALLOCATE'=377 +'DEBUG'=378 +'DEBUGGER'=379 +'DEC'=380 +'DECIMAL'=381 +'DECLARE'=382 +'DECOMPOSE'=383 +'DECORRELATE'=384 +'DECR'=385 +'DECREMENT'=386 +'DECRYPT'=387 +'DEDUPLICATE'=388 +'DEFAULT'=389 +'DEFAULTIF'=390 +'DEFAULTS'=391 +'DEFAULT_COLLATION'=392 +'DEFAULT_CREDENTIAL'=393 +'DEFERRABLE'=394 +'DEFERRED'=395 +'DEFINED'=396 +'DEFINE'=397 +'DEFINER'=398 +'DEGREE'=399 +'DELAY'=400 +'DELEGATE'=401 +'DELETE_ALL'=402 +'DELETE'=403 +'DELETEXML'=404 +'DELIMITED'=405 +'DEMAND'=406 +'DENSE_RANKM'=407 +'DEPENDENT'=408 +'DEPRECATE'=409 +'DEPTH'=410 +'DEQUEUE'=411 +'DEREF'=412 +'DEREF_NO_REWRITE'=413 +'DESC'=414 +'DESCRIPTION'=415 +'DESTROY'=416 +'DETACHED'=417 +'DETECTED'=418 +'DETERMINES'=419 +'DETERMINISTIC'=420 +'DICTIONARY'=421 +'DIMENSION'=422 +'DIMENSIONS'=423 +'DIRECTIO'=424 +'DIRECT_LOAD'=425 +'DIRECTORY'=426 +'DIRECT_PATH'=427 +'DISABLE_ALL'=428 +'DISABLE'=429 +'DISABLED'=430 +'DISABLE_DIRECTORY_LINK_CHECK'=431 +'DISABLE_PARALLEL_DML'=432 +'DISABLE_PRESET'=433 +'DISABLE_RPKE'=434 +'DISALLOW'=435 +'DISASSOCIATE'=436 +'DISCARD'=437 +'DISCARDFILE'=438 +'DISCONNECT'=439 +'DISK'=440 +'DISKGROUP'=441 +'\'+ DISKGROUP'=442 +'DISKS'=443 +'DISMOUNT'=444 +'DISTINCT'=445 +'DISTINGUISHED'=446 +'DISTRIBUTED'=447 +'DISTRIBUTE'=448 +'DML'=449 +'DML_UPDATE'=450 +'DNFS_DISABLE'=451 +'DNFS_ENABLE'=452 +'DNFS_READBUFFERS'=453 +'DOCFIDELITY'=454 +'DOCUMENT'=455 +'$ELSE'=456 +'$ELSIF'=457 +'$END'=458 +'$ERROR'=459 +'$IF'=460 +'$THEN'=461 +'DOMAIN_INDEX_FILTER'=462 +'DOMAIN_INDEX_NO_SORT'=463 +'DOMAIN_INDEX_SORT'=464 +'DOUBLE'=465 +'DOWNGRADE'=466 +'DRIVING_SITE'=467 +'DROP_COLUMN'=468 +'DROP'=469 +'DROP_GROUP'=470 +'DSINTERVAL_UNCONSTRAINED'=471 +'DST_UPGRADE_INSERT_CONV'=472 +'DUMP'=473 +'DUMPSET'=474 +'DUPLICATE'=475 +'DV'=476 +'DYNAMIC'=477 +'DYNAMIC_SAMPLING'=478 +'DYNAMIC_SAMPLING_EST_CDN'=479 +'E'=480 +'EACH'=481 +'EDITIONABLE'=482 +'EDITION'=483 +'EDITIONING'=484 +'EDITIONS'=485 +'ELEMENT'=486 +'ELIM_GROUPBY'=487 +'ELIMINATE_JOIN'=488 +'ELIMINATE_OBY'=489 +'ELIMINATE_OUTER_JOIN'=490 +'ELSE'=491 +'ELSIF'=492 +'EM'=493 +'EMBEDDED'=494 +'EMPTY_BLOB'=495 +'EMPTY_CLOB'=496 +'EMPTY'=497 +'ENABLE_ALL'=498 +'ENABLE'=499 +'ENABLED'=500 +'ENABLE_PARALLEL_DML'=501 +'ENABLE_PRESET'=502 +'ENCLOSED'=503 +'ENCODING'=504 +'ENCRYPT'=505 +'ENCRYPTION'=506 +'ENCRYPTPASSWORDISNULL'=507 +'END'=508 +'END_OUTLINE_DATA'=509 +'ENDIAN'=510 +'ENFORCED'=511 +'ENFORCE'=512 +'ENQUEUE'=513 +'ENTERPRISE'=514 +'ENTITYESCAPING'=515 +'ENTRY'=516 +'EQUIPART'=517 +'ERR'=518 +'ERROR_ARGUMENT'=519 +'ERROR'=520 +'ERROR_ON_OVERLAP_TIME'=521 +'ERRORS'=522 +'ERROR_INDEX'=523 +'ERROR_CODE'=524 +'ESCAPE'=525 +'ESCAPED'=526 +'ESTIMATE'=527 +'EVAL'=528 +'EVALNAME'=529 +'EVALUATE'=530 +'EVALUATION'=531 +'EVENTS'=532 +'EVERY'=533 +'EXCEPT'=534 +'EXCEPTION'=535 +'EXCEPTION_INIT'=536 +'EXCEPTIONS'=537 +'EXCHANGE'=538 +'EXCLUDE'=539 +'EXCLUDING'=540 +'EXCLUSIVE'=541 +'EXECUTE'=542 +'EXEMPT'=543 +'EXISTING'=544 +'EXISTS'=545 +'EXISTSNODE'=546 +'EXIT'=547 +'EXPAND_GSET_TO_UNION'=548 +'EXPAND_TABLE'=549 +'EXP'=550 +'EXPIRE'=551 +'EXPLAIN'=552 +'EXPLOSION'=553 +'EXPORT'=554 +'EXPR_CORR_CHECK'=555 +'EXPRESS'=556 +'EXTENDS'=557 +'EXTENT'=558 +'EXTENTS'=559 +'EXTERNAL'=560 +'EXTERNALLY'=561 +'EXTRACTCLOBXML'=562 +'EXTRACT'=563 +'EXTRACTVALUE'=564 +'EXTRA'=565 +'FACILITY'=566 +'FACT'=567 +'FACTOR'=568 +'FACTORIZE_JOIN'=569 +'FAILED'=570 +'FAILED_LOGIN_ATTEMPTS'=571 +'FAILGROUP'=572 +'FAILOVER'=573 +'FAILURE'=574 +'FALSE'=575 +'FAMILY'=576 +'FAR'=577 +'FAST'=578 +'FASTSTART'=579 +'FBTSCAN'=580 +'FEATURE'=581 +'FEATURE_DETAILS'=582 +'FEATURE_ID'=583 +'FEATURE_SET'=584 +'FEATURE_VALUE'=585 +'FETCH'=586 +'FIELD'=587 +'FIELDS'=588 +'FILE'=589 +'FILE_NAME_CONVERT'=590 +'FILEGROUP'=591 +'FILESTORE'=592 +'FILESYSTEM_LIKE_LOGGING'=593 +'FILTER'=594 +'FINAL'=595 +'FINE'=596 +'FINISH'=597 +'FIRST'=598 +'FIRSTM'=599 +'FIRST_ROWS'=600 +'FIRST_VALUE'=601 +'FIXED'=602 +'FIXED_VIEW_DATA'=603 +'FLAGGER'=604 +'FLASHBACK'=605 +'FLASH_CACHE'=606 +'FLOAT'=607 +'FLOB'=608 +'FLEX'=609 +'FLOOR'=610 +'FLUSH'=611 +'FOLDER'=612 +'FOLLOWING'=613 +'FOLLOWS'=614 +'FORALL'=615 +'FORCE'=616 +'FORCE_XML_QUERY_REWRITE'=617 +'FOREIGN'=618 +'FOREVER'=619 +'FOR'=620 +'FORMAT'=621 +'FORWARD'=622 +'FRAGMENT_NUMBER'=623 +'FREELIST'=624 +'FREELISTS'=625 +'FREEPOOLS'=626 +'FRESH'=627 +'FROM'=628 +'FROM_TZ'=629 +'FULL'=630 +'FULL_OUTER_JOIN_TO_OUTER'=631 +'FUNCTION'=632 +'FUNCTIONS'=633 +'FTP'=634 +'G'=635 +'GATHER_OPTIMIZER_STATISTICS'=636 +'GATHER_PLAN_STATISTICS'=637 +'GBY_CONC_ROLLUP'=638 +'GBY_PUSHDOWN'=639 +'GENERATED'=640 +'GET'=641 +'GLOBAL'=642 +'GLOBALLY'=643 +'GLOBAL_NAME'=644 +'GLOBAL_TOPIC_ENABLED'=645 +'GOTO'=646 +'GRANT'=647 +'GROUP_BY'=648 +'GROUP'=649 +'GROUP_ID'=650 +'GROUPING'=651 +'GROUPING_ID'=652 +'GROUPS'=653 +'GUARANTEED'=654 +'GUARANTEE'=655 +'GUARD'=656 +'HADOOP_TRAILERS'=657 +'HALF_YEARS'=658 +'HASH_AJ'=659 +'HASH'=660 +'HASHKEYS'=661 +'HASH_SJ'=662 +'HAVING'=663 +'HEADER'=664 +'HEAP'=665 +'HELP'=666 +'HEXTORAW'=667 +'HEXTOREF'=668 +'HIDDEN'=669 +'HIDE'=670 +'HIER_ORDER'=671 +'HIERARCHICAL'=672 +'HIERARCHIES'=673 +'HIERARCHY'=674 +'HIGH'=675 +'HINTSET_BEGIN'=676 +'HINTSET_END'=677 +'HOT'=678 +'HOUR'=679 +'HOURS'=680 +'HTTP'=681 +'HWM_BROKERED'=682 +'HYBRID'=683 +'H'=684 +'IDENTIFIED'=685 +'IDENTIFIER'=686 +'IDENTITY'=687 +'IDGENERATORS'=688 +'ID'=689 +'IDLE_TIME'=690 +'IF'=691 +'IGNORE'=692 +'IGNORE_CHARS_AFTER_EOR'=693 +'IGNORE_OPTIM_EMBEDDED_HINTS'=694 +'IGNORE_ROW_ON_DUPKEY_INDEX'=695 +'IGNORE_WHERE_CLAUSE'=696 +'ILM'=697 +'IMMEDIATE'=698 +'IMPACT'=699 +'IMPORT'=700 +'INACTIVE'=701 +'INACTIVE_ACCOUNT_TIME'=702 +'INCLUDE'=703 +'INCLUDE_VERSION'=704 +'INCLUDING'=705 +'INCREMENTAL'=706 +'INCREMENT'=707 +'INCR'=708 +'INDENT'=709 +'INDEX_ASC'=710 +'INDEX_COMBINE'=711 +'INDEX_DESC'=712 +'INDEXED'=713 +'INDEXES'=714 +'INDEX_FFS'=715 +'INDEX_FILTER'=716 +'INDEX'=717 +'INDEXING'=718 +'INDEX_JOIN'=719 +'INDEX_ROWS'=720 +'INDEX_RRS'=721 +'INDEX_RS_ASC'=722 +'INDEX_RS_DESC'=723 +'INDEX_RS'=724 +'INDEX_SCAN'=725 +'INDEX_SKIP_SCAN'=726 +'INDEX_SS_ASC'=727 +'INDEX_SS_DESC'=728 +'INDEX_SS'=729 +'INDEX_STATS'=730 +'INDEXTYPE'=731 +'INDEXTYPES'=732 +'INDICATOR'=733 +'INDICES'=734 +'INFINITE'=735 +'INFORMATIONAL'=736 +'INHERIT'=737 +'IN'=738 +'INITCAP'=739 +'INITIAL'=740 +'INITIALIZED'=741 +'INITIALLY'=742 +'INITRANS'=743 +'INLINE'=744 +'INLINE_XMLTYPE_NT'=745 +'INMEMORY'=746 +'IN_MEMORY_METADATA'=747 +'INMEMORY_PRUNING'=748 +'INNER'=749 +'INOUT'=750 +'INPLACE'=751 +'INPUTFORMAT'=752 +'INSERTCHILDXMLAFTER'=753 +'INSERTCHILDXMLBEFORE'=754 +'INSERTCHILDXML'=755 +'INSERT'=756 +'INSERTXMLAFTER'=757 +'INSERTXMLBEFORE'=758 +'INSTANCE'=759 +'INSTANCES'=760 +'INSTANTIABLE'=761 +'INSTANTLY'=762 +'INSTEAD'=763 +'INSTR2'=764 +'INSTR4'=765 +'INSTRB'=766 +'INSTRC'=767 +'INSTR'=768 +'INTEGER'=769 +'INTERLEAVED'=770 +'INTERMEDIATE'=771 +'INTERNAL_CONVERT'=772 +'INTERNAL_USE'=773 +'INTERPRETED'=774 +'INTERSECT'=775 +'INTERVAL'=776 +'INT'=777 +'INTERNAL'=778 +'INTO'=779 +'INVALIDATE'=780 +'INVALIDATION'=781 +'INVISIBLE'=782 +'IN_XQUERY'=783 +'IO_OPTIONS'=784 +'IS'=785 +'IS_LEAF'=786 +'ISOLATION'=787 +'ISOLATION_LEVEL'=788 +'ITEMS'=789 +'ITERATE'=790 +'ITERATION_NUMBER'=791 +'JAVA'=792 +'JOB'=793 +'JOIN'=794 +'JSON_ARRAYAGG'=795 +'JSON_ARRAY'=796 +'JSON_EQUAL'=797 +'JSON_EXISTS2'=798 +'JSON_EXISTS'=799 +'JSONGET'=800 +'JSON'=801 +'JSON_OBJECTAGG'=802 +'JSON_OBJECT'=803 +'JSONPARSE'=804 +'JSON_QUERY'=805 +'JSON_SERIALIZE'=806 +'JSON_TABLE'=807 +'JSON_TEXTCONTAINS2'=808 +'JSON_TEXTCONTAINS'=809 +'JSON_TRANSFORM'=810 +'JSON_VALUE'=811 +'K'=812 +'KEEP_DUPLICATES'=813 +'KEEP'=814 +'KERBEROS'=815 +'KEY'=816 +'KEY_LENGTH'=817 +'KEYSIZE'=818 +'KEYS'=819 +'KEYSTORE'=820 +'KILL'=821 +'LABEL'=822 +'LANGUAGE'=823 +'LAST_DAY'=824 +'LAST'=825 +'LAST_VALUE'=826 +'LATERAL'=827 +'LATEST'=828 +'LAX'=829 +'LAYER'=830 +'LDAP_REGISTRATION_ENABLED'=831 +'LDAP_REGISTRATION'=832 +'LDAP_REG_SYNC_INTERVAL'=833 +'LDRTRIM'=834 +'LEAF'=835 +'LEAD_CDB'=836 +'LEAD_CDB_URI'=837 +'LEADING'=838 +'LEFT'=839 +'LENGTH2'=840 +'LENGTH4'=841 +'LENGTHB'=842 +'LENGTHC'=843 +'LENGTH'=844 +'LESS'=845 +'LEVEL'=846 +'LEVEL_NAME'=847 +'LEVELS'=848 +'LIBRARY'=849 +'LIFECYCLE'=850 +'LIFE'=851 +'LIFETIME'=852 +'LIKE2'=853 +'LIKE4'=854 +'LIKEC'=855 +'LIKE_EXPAND'=856 +'LIKE'=857 +'LIMIT'=858 +'LINEAR'=859 +'LINES'=860 +'LINK'=861 +'LIST'=862 +'LITTLE'=863 +'LLS'=864 +'LN'=865 +'LNNVL'=866 +'LOAD'=867 +'LOB'=868 +'LOBFILE'=869 +'LOBNVL'=870 +'LOBS'=871 +'LOCAL_INDEXES'=872 +'LOCAL'=873 +'LOCALTIME'=874 +'LOCALTIMESTAMP'=875 +'LOCATION'=876 +'LOCATOR'=877 +'LOCKDOWN'=878 +'LOCKED'=879 +'LOCKING'=880 +'LOCK'=881 +'LOGFILE'=882 +'LOGFILES'=883 +'LOGGING'=884 +'LOGICAL'=885 +'LOGICAL_READS_PER_CALL'=886 +'LOGICAL_READS_PER_SESSION'=887 +'LOG'=888 +'LOGMINING'=889 +'LOGOFF'=890 +'LOGON'=891 +'LOG_READ_ONLY_VIOLATIONS'=892 +'LONG'=893 +'LOOP'=894 +'LOST'=895 +'LOWER'=896 +'LOW'=897 +'LPAD'=898 +'LRTRIM'=899 +'LTRIM'=900 +'M'=901 +'MAIN'=902 +'MAKE_REF'=903 +'MANAGED'=904 +'MANAGE'=905 +'MANAGEMENT'=906 +'MANAGER'=907 +'MANDATORY'=908 +'MANUAL'=909 +'MAP'=910 +'MAPPING'=911 +'MASK'=912 +'MASTER'=913 +'MATCHED'=914 +'MATCHES'=915 +'MATCH'=916 +'MATCH_NUMBER'=917 +'MATCH_RECOGNIZE'=918 +'MATERIALIZED'=919 +'MATERIALIZE'=920 +'MAXARCHLOGS'=921 +'MAXDATAFILES'=922 +'MAXEXTENTS'=923 +'MAXIMIZE'=924 +'MAXINSTANCES'=925 +'MAXLOGFILES'=926 +'MAXLOGHISTORY'=927 +'MAXLOGMEMBERS'=928 +'MAX_SHARED_TEMP_SIZE'=929 +'MAXSIZE'=930 +'MAXTRANS'=931 +'MAXVALUE'=932 +'MEASURE'=933 +'MEASURES'=934 +'MEDIUM'=935 +'MEMBER'=936 +'MEMBER_CAPTION'=937 +'MEMBER_DESCRIPTION'=938 +'MEMBER_NAME'=939 +'MEMBER_UNIQUE_NAME'=940 +'MEMCOMPRESS'=941 +'MEMORY'=942 +'MERGE$ACTIONS'=943 +'MERGE_AJ'=944 +'MERGE_CONST_ON'=945 +'MERGE'=946 +'MERGE_SJ'=947 +'METADATA'=948 +'METHOD'=949 +'MIGRATE'=950 +'MIGRATION'=951 +'MINEXTENTS'=952 +'MINIMIZE'=953 +'MINIMUM'=954 +'MINING'=955 +'MINUS'=956 +'MINUS_NULL'=957 +'MINUTE'=958 +'MINUTES'=959 +'MINVALUE'=960 +'MIRRORCOLD'=961 +'MIRRORHOT'=962 +'MIRROR'=963 +'MISSING'=964 +'MISMATCH'=965 +'MLSLABEL'=966 +'MODEL_COMPILE_SUBQUERY'=967 +'MODEL_DONTVERIFY_UNIQUENESS'=968 +'MODEL_DYNAMIC_SUBQUERY'=969 +'MODEL_MIN_ANALYSIS'=970 +'MODEL'=971 +'MODEL_NB'=972 +'MODEL_NO_ANALYSIS'=973 +'MODEL_PBY'=974 +'MODEL_PUSH_REF'=975 +'MODEL_SV'=976 +'MODE'=977 +'MODIFICATION'=978 +'MODIFY_COLUMN_TYPE'=979 +'MODIFY'=980 +'MOD'=981 +'MODULE'=982 +'MONITORING'=983 +'MONITOR'=984 +'MONTH'=985 +'MONTHS_BETWEEN'=986 +'MONTHS'=987 +'MOUNT'=988 +'MOUNTPATH'=989 +'MOUNTPOINT'=990 +'MOVEMENT'=991 +'MOVE'=992 +'MULTIDIMENSIONAL'=993 +'MULTISET'=994 +'MV_MERGE'=995 +'NAMED'=996 +'NAME'=997 +'NAMESPACE'=998 +'NAN'=999 +'NANVL'=1000 +'NATIONAL'=1001 +'NATIVE_FULL_OUTER_JOIN'=1002 +'NATIVE'=1003 +'NATURAL'=1004 +'NATURALN'=1005 +'NAV'=1006 +'NCHAR_CS'=1007 +'NCHAR'=1008 +'NCHR'=1009 +'NCLOB'=1010 +'NEEDED'=1011 +'NEG'=1012 +'NESTED'=1013 +'NESTED_TABLE_FAST_INSERT'=1014 +'NESTED_TABLE_GET_REFS'=1015 +'NESTED_TABLE_ID'=1016 +'NESTED_TABLE_SET_REFS'=1017 +'NESTED_TABLE_SET_SETID'=1018 +'NETWORK'=1019 +'NEVER'=1020 +'NEW'=1021 +'NEWLINE'=1022 +'NEW_TIME'=1023 +'NEXT_DAY'=1024 +'NEXT'=1025 +'NL_AJ'=1026 +'NLJ_BATCHING'=1027 +'NLJ_INDEX_FILTER'=1028 +'NLJ_INDEX_SCAN'=1029 +'NLJ_PREFETCH'=1030 +'NLS_CALENDAR'=1031 +'NLS_CHARACTERSET'=1032 +'NLS_CHARSET_DECL_LEN'=1033 +'NLS_CHARSET_ID'=1034 +'NLS_CHARSET_NAME'=1035 +'NLS_COMP'=1036 +'NLS_CURRENCY'=1037 +'NLS_DATE_FORMAT'=1038 +'NLS_DATE_LANGUAGE'=1039 +'NLS_INITCAP'=1040 +'NLS_ISO_CURRENCY'=1041 +'NL_SJ'=1042 +'NLS_LANG'=1043 +'NLS_LANGUAGE'=1044 +'NLS_LENGTH_SEMANTICS'=1045 +'NLS_LOWER'=1046 +'NLS_NCHAR_CONV_EXCP'=1047 +'NLS_NUMERIC_CHARACTERS'=1048 +'NLS_SORT'=1049 +'NLSSORT'=1050 +'NLS_SPECIAL_CHARS'=1051 +'NLS_TERRITORY'=1052 +'NLS_UPPER'=1053 +'NO_ACCESS'=1054 +'NO_ADAPTIVE_PLAN'=1055 +'NO_ANSI_REARCH'=1056 +'NOAPPEND'=1057 +'NOARCHIVELOG'=1058 +'NOAUDIT'=1059 +'NOBADFILE'=1060 +'NO_AUTO_REOPTIMIZE'=1061 +'NO_BASETABLE_MULTIMV_REWRITE'=1062 +'NO_BATCH_TABLE_ACCESS_BY_ROWID'=1063 +'NO_BIND_AWARE'=1064 +'NO_BUFFER'=1065 +'NOCACHE'=1066 +'NOCHECK'=1067 +'NO_CARTESIAN'=1068 +'NO_CHECK_ACL_REWRITE'=1069 +'NO_CLUSTER_BY_ROWID'=1070 +'NO_CLUSTERING'=1071 +'NO_COALESCE_SQ'=1072 +'NO_COMMON_DATA'=1073 +'NOCOMPRESS'=1074 +'NO_CONNECT_BY_CB_WHR_ONLY'=1075 +'NO_CONNECT_BY_COMBINE_SW'=1076 +'NO_CONNECT_BY_COST_BASED'=1077 +'NO_CONNECT_BY_ELIM_DUPS'=1078 +'NO_CONNECT_BY_FILTERING'=1079 +'NOCOPY'=1080 +'NO_COST_XML_QUERY_REWRITE'=1081 +'NO_CPU_COSTING'=1082 +'NOCPU_COSTING'=1083 +'NOCYCLE'=1084 +'NO_DATA_SECURITY_REWRITE'=1085 +'NO_DECORRELATE'=1086 +'NODELAY'=1087 +'NODIRECTIO'=1088 +'NODISCARDFILE'=1089 +'NO_DOMAIN_INDEX_FILTER'=1090 +'NO_DST_UPGRADE_INSERT_CONV'=1091 +'NO_ELIM_GROUPBY'=1092 +'NO_ELIMINATE_JOIN'=1093 +'NO_ELIMINATE_OBY'=1094 +'NO_ELIMINATE_OUTER_JOIN'=1095 +'NOENTITYESCAPING'=1096 +'NO_EXPAND_GSET_TO_UNION'=1097 +'NO_EXPAND'=1098 +'NO_EXPAND_TABLE'=1099 +'NOEXTEND'=1100 +'NO_FACT'=1101 +'NO_FACTORIZE_JOIN'=1102 +'NO_FILTERING'=1103 +'NOFORCE'=1104 +'NO_FULL_OUTER_JOIN_TO_OUTER'=1105 +'NO_GATHER_OPTIMIZER_STATISTICS'=1106 +'NO_GBY_PUSHDOWN'=1107 +'NOGUARANTEE'=1108 +'NO_INDEX_FFS'=1109 +'NO_INDEX'=1110 +'NO_INDEX_SS'=1111 +'NO_INMEMORY'=1112 +'NO_INMEMORY_PRUNING'=1113 +'NOKEEP'=1114 +'NO_LOAD'=1115 +'NOLOCAL'=1116 +'NOLOG'=1117 +'NOLOGFILE'=1118 +'NOLOGGING'=1119 +'NOMAPPING'=1120 +'NOMAXVALUE'=1121 +'NO_MERGE'=1122 +'NOMINIMIZE'=1123 +'NOMINVALUE'=1124 +'NO_MODEL_PUSH_REF'=1125 +'NO_MONITORING'=1126 +'NOMONITORING'=1127 +'NO_MONITOR'=1128 +'NO_MULTIMV_REWRITE'=1129 +'NO_NATIVE_FULL_OUTER_JOIN'=1130 +'NONBLOCKING'=1131 +'NONEDITIONABLE'=1132 +'NONE'=1133 +'NONULLIF'=1134 +'NO_NLJ_BATCHING'=1135 +'NO_NLJ_PREFETCH'=1136 +'NO'=1137 +'NONSCHEMA'=1138 +'NO_OBJECT_LINK'=1139 +'NOORDER'=1140 +'NO_ORDER_ROLLUPS'=1141 +'NO_OUTER_JOIN_TO_ANTI'=1142 +'NO_OUTER_JOIN_TO_INNER'=1143 +'NOOVERRIDE'=1144 +'NO_PARALLEL_INDEX'=1145 +'NOPARALLEL_INDEX'=1146 +'NO_PARALLEL'=1147 +'NOPARALLEL'=1148 +'NO_PARTIAL_COMMIT'=1149 +'NO_PARTIAL_JOIN'=1150 +'NO_PARTIAL_ROLLUP_PUSHDOWN'=1151 +'NOPARTITION'=1152 +'NO_PLACE_DISTINCT'=1153 +'NO_PLACE_GROUP_BY'=1154 +'NO_PQ_CONCURRENT_UNION'=1155 +'NO_PQ_MAP'=1156 +'NOPROMPT'=1157 +'NO_PQ_REPLICATE'=1158 +'NO_PQ_SKEW'=1159 +'NO_PRUNE_GSETS'=1160 +'NO_PULL_PRED'=1161 +'NO_PUSH_PRED'=1162 +'NO_PUSH_SUBQ'=1163 +'NO_PX_FAULT_TOLERANCE'=1164 +'NO_PX_JOIN_FILTER'=1165 +'NO_QKN_BUFF'=1166 +'NO_QUERY_TRANSFORMATION'=1167 +'NO_REF_CASCADE'=1168 +'NORELOCATE'=1169 +'NORELY'=1170 +'NOREPAIR'=1171 +'NOREPLAY'=1172 +'NORESETLOGS'=1173 +'NO_RESULT_CACHE'=1174 +'NOREVERSE'=1175 +'NO_REWRITE'=1176 +'NOREWRITE'=1177 +'NORMAL'=1178 +'NO_ROOT_SW_FOR_LOCAL'=1179 +'NOROWDEPENDENCIES'=1180 +'NOSCALE'=1181 +'NOSCHEMACHECK'=1182 +'NOSEGMENT'=1183 +'NO_SEMIJOIN'=1184 +'NO_SEMI_TO_INNER'=1185 +'NO_SET_TO_JOIN'=1186 +'NOSHARD'=1187 +'NOSORT'=1188 +'NO_SQL_TRANSLATION'=1189 +'NO_SQL_TUNE'=1190 +'NO_STAR_TRANSFORMATION'=1191 +'NO_STATEMENT_QUEUING'=1192 +'NO_STATS_GSETS'=1193 +'NOSTRICT'=1194 +'NO_SUBQUERY_PRUNING'=1195 +'NO_SUBSTRB_PAD'=1196 +'NO_SWAP_JOIN_INPUTS'=1197 +'NOSWITCH'=1198 +'NO_TABLE_LOOKUP_BY_NL'=1199 +'NO_TEMP_TABLE'=1200 +'NOTHING'=1201 +'NOTIFICATION'=1202 +'NOTRIM'=1203 +'NOT'=1204 +'NO_TRANSFORM_DISTINCT_AGG'=1205 +'NO_UNNEST'=1206 +'NO_USE_CUBE'=1207 +'NO_USE_HASH_AGGREGATION'=1208 +'NO_USE_HASH_GBY_FOR_PUSHDOWN'=1209 +'NO_USE_HASH'=1210 +'NO_USE_INVISIBLE_INDEXES'=1211 +'NO_USE_MERGE'=1212 +'NO_USE_NL'=1213 +'NO_USE_VECTOR_AGGREGATION'=1214 +'NOVALIDATE'=1215 +'NO_VECTOR_TRANSFORM_DIMS'=1216 +'NO_VECTOR_TRANSFORM_FACT'=1217 +'NO_VECTOR_TRANSFORM'=1218 +'NOWAIT'=1219 +'NO_XDB_FASTPATH_INSERT'=1220 +'NO_XML_DML_REWRITE'=1221 +'NO_XMLINDEX_REWRITE_IN_SELECT'=1222 +'NO_XMLINDEX_REWRITE'=1223 +'NO_XML_QUERY_REWRITE'=1224 +'NO_ZONEMAP'=1225 +'NTH_VALUE'=1226 +'NULLIF'=1227 +'NULL'=1228 +'NULLS'=1229 +'NUMBER'=1230 +'NUMERIC'=1231 +'NUM_INDEX_KEYS'=1232 +'NUMTODSINTERVAL'=1233 +'NUMTOYMINTERVAL'=1234 +'NVARCHAR2'=1235 +'NVL2'=1236 +'OBJECT2XML'=1237 +'OBJECT'=1238 +'OBJ_ID'=1239 +'OBJNO'=1240 +'OBJNO_REUSE'=1241 +'OCCURENCES'=1242 +'OFFLINE'=1243 +'OFF'=1244 +'OFFSET'=1245 +'OF'=1246 +'OIDINDEX'=1247 +'OID'=1248 +'OLAP'=1249 +'OLD'=1250 +'OLD_PUSH_PRED'=1251 +'OLS'=1252 +'OLTP'=1253 +'OMIT'=1254 +'ONE'=1255 +'ONLINE'=1256 +'ONLINELOG'=1257 +'ONLY'=1258 +'ON'=1259 +'OPAQUE'=1260 +'OPAQUE_TRANSFORM'=1261 +'OPAQUE_XCANONICAL'=1262 +'OPCODE'=1263 +'OPEN'=1264 +'OPERATIONS'=1265 +'OPERATOR'=1266 +'OPT_ESTIMATE'=1267 +'OPTIMAL'=1268 +'OPTIMIZE'=1269 +'OPTIMIZER_FEATURES_ENABLE'=1270 +'OPTIMIZER_GOAL'=1271 +'OPTION'=1272 +'OPTIONALLY'=1273 +'OPT_PARAM'=1274 +'ORA_BRANCH'=1275 +'ORA_CHECK_ACL'=1276 +'ORA_CHECK_PRIVILEGE'=1277 +'ORA_CLUSTERING'=1278 +'ORADATA'=1279 +'ORC'=1280 +'ORACLE_DATE'=1281 +'ORACLE_NUMBER'=1282 +'ORADEBUG'=1283 +'ORA_DST_AFFECTED'=1284 +'ORA_DST_CONVERT'=1285 +'ORA_DST_ERROR'=1286 +'ORA_GET_ACLIDS'=1287 +'ORA_GET_PRIVILEGES'=1288 +'ORA_HASH'=1289 +'ORA_INVOKING_USERID'=1290 +'ORA_INVOKING_USER'=1291 +'ORA_INVOKING_XS_USER_GUID'=1292 +'ORA_INVOKING_XS_USER'=1293 +'ORA_RAWCOMPARE'=1294 +'ORA_RAWCONCAT'=1295 +'ORA_ROWSCN'=1296 +'ORA_ROWSCN_RAW'=1297 +'ORA_ROWVERSION'=1298 +'ORA_TABVERSION'=1299 +'ORA_WRITE_TIME'=1300 +'ORDERED'=1301 +'ORDERED_PREDICATES'=1302 +'ORDER'=1303 +'ORDINALITY'=1304 +'OR_EXPAND'=1305 +'ORGANIZATION'=1306 +'OR'=1307 +'OR_PREDICATES'=1308 +'OSERROR'=1309 +'OTHER'=1310 +'OUTER_JOIN_TO_ANTI'=1311 +'OUTER_JOIN_TO_INNER'=1312 +'OUTER'=1313 +'OUTLINE_LEAF'=1314 +'OUTLINE'=1315 +'OUTPUTFORMAT'=1316 +'OUT_OF_LINE'=1317 +'OUT'=1318 +'OVERFLOW_NOMOVE'=1319 +'OVERFLOW'=1320 +'OVERLAPS'=1321 +'OVER'=1322 +'OVERRIDE'=1323 +'OVERRIDING'=1324 +'OWNER'=1325 +'OWNERSHIP'=1326 +'OWN'=1327 +'P'=1328 +'PACKAGE'=1329 +'PACKAGES'=1330 +'PARALLEL_ENABLE'=1331 +'PARALLEL_INDEX'=1332 +'PARALLEL'=1333 +'PARAMETERFILE'=1334 +'PARAMETERS'=1335 +'PARAM'=1336 +'PARENT'=1337 +'PARENT_LEVEL_NAME'=1338 +'PARENT_UNIQUE_NAME'=1339 +'PARITY'=1340 +'PARQUET'=1341 +'PARTIAL_JOIN'=1342 +'PARTIALLY'=1343 +'PARTIAL'=1344 +'PARTIAL_ROLLUP_PUSHDOWN'=1345 +'PARTITION_HASH'=1346 +'PARTITION_LIST'=1347 +'PARTITION'=1348 +'PARTITION_RANGE'=1349 +'PARTITIONS'=1350 +'PART$NUM$INST'=1351 +'PASSING'=1352 +'PASSWORD_GRACE_TIME'=1353 +'PASSWORD_LIFE_TIME'=1354 +'PASSWORD_LOCK_TIME'=1355 +'PASSWORD'=1356 +'PASSWORD_REUSE_MAX'=1357 +'PASSWORD_REUSE_TIME'=1358 +'PASSWORD_ROLLOVER_TIME'=1359 +'PASSWORD_VERIFY_FUNCTION'=1360 +'PAST'=1361 +'PATCH'=1362 +'PATH'=1363 +'PATH_PREFIX'=1364 +'PATHS'=1365 +'PATTERN'=1366 +'PBL_HS_BEGIN'=1367 +'PBL_HS_END'=1368 +'PCTFREE'=1369 +'PCTINCREASE'=1370 +'PCTTHRESHOLD'=1371 +'PCTUSED'=1372 +'PCTVERSION'=1373 +'PENDING'=1374 +'PERCENT'=1378 +'PERCENT_RANKM'=1379 +'PERFORMANCE'=1385 +'PERIOD'=1386 +'PERMANENT'=1387 +'PERMISSION'=1388 +'PERMUTE'=1389 +'PER'=1390 +'PFILE'=1391 +'PHYSICAL'=1392 +'PIKEY'=1393 +'PIPELINED'=1394 +'PIPE'=1395 +'PIV_GB'=1396 +'PIVOT'=1397 +'PIV_SSF'=1398 +'PLACE_DISTINCT'=1399 +'PLACE_GROUP_BY'=1400 +'PLAN'=1401 +'PLSCOPE_SETTINGS'=1402 +'PLS_INTEGER'=1403 +'PLSQL_CCFLAGS'=1404 +'PLSQL_CODE_TYPE'=1405 +'PLSQL_DEBUG'=1406 +'PLSQL_OPTIMIZE_LEVEL'=1407 +'PLSQL_WARNINGS'=1408 +'PLUGGABLE'=1409 +'PMEM'=1410 +'POINT'=1411 +'POLICY'=1412 +'POOL_16K'=1413 +'POOL_2K'=1414 +'POOL_32K'=1415 +'POOL_4K'=1416 +'POOL_8K'=1417 +'POSITION'=1418 +'POSITIVEN'=1419 +'POSITIVE'=1420 +'POST_TRANSACTION'=1421 +'POWERMULTISET_BY_CARDINALITY'=1422 +'POWERMULTISET'=1423 +'POWER'=1424 +'PQ_CONCURRENT_UNION'=1425 +'PQ_DISTRIBUTE'=1426 +'PQ_DISTRIBUTE_WINDOW'=1427 +'PQ_FILTER'=1428 +'PQ_MAP'=1429 +'PQ_NOMAP'=1430 +'PQ_REPLICATE'=1431 +'PQ_SKEW'=1432 +'PRAGMA'=1433 +'PREBUILT'=1434 +'PRECEDES'=1435 +'PRECEDING'=1436 +'PRECISION'=1437 +'PRECOMPUTE_SUBQUERY'=1438 +'PREDICATE_REORDERS'=1439 +'PRELOAD'=1440 +'PREPARE'=1441 +'PREPROCESSOR'=1442 +'PRESENTNNV'=1443 +'PRESENT'=1444 +'PRESENTV'=1445 +'PRESERVE_OID'=1446 +'PRESERVE'=1447 +'PRETTY'=1448 +'PREVIOUS'=1449 +'PREV'=1450 +'PRIMARY'=1451 +'PRINTBLOBTOCLOB'=1452 +'PRIORITY'=1453 +'PRIOR'=1454 +'PRIVATE'=1455 +'PRIVATE_SGA'=1456 +'PRIVILEGED'=1457 +'PRIVILEGE'=1458 +'PRIVILEGES'=1459 +'PROCEDURAL'=1460 +'PROCEDURE'=1461 +'PROCESS'=1462 +'PROFILE'=1463 +'PROGRAM'=1464 +'PROJECT'=1465 +'PROPAGATE'=1466 +'PROPERTY'=1467 +'PROTECTED'=1468 +'PROTECTION'=1469 +'PROTOCOL'=1470 +'PROXY'=1471 +'PRUNING'=1472 +'PUBLIC'=1473 +'PULL_PRED'=1474 +'PURGE'=1475 +'PUSH_PRED'=1476 +'PUSH_SUBQ'=1477 +'PX_FAULT_TOLERANCE'=1478 +'PX_GRANULE'=1479 +'PX_JOIN_FILTER'=1480 +'QB_NAME'=1481 +'QUARTERS'=1482 +'QUERY_BLOCK'=1483 +'QUERY'=1484 +'QUEUE_CURR'=1485 +'QUEUE'=1486 +'QUEUE_ROWP'=1487 +'QUIESCE'=1488 +'QUORUM'=1489 +'QUOTA'=1490 +'QUOTAGROUP'=1491 +'RAISE'=1492 +'RANDOM_LOCAL'=1493 +'RANDOM'=1494 +'RANGE'=1495 +'RANKM'=1496 +'RAPIDLY'=1497 +'RAW'=1498 +'RAWTOHEX'=1499 +'RAWTONHEX'=1500 +'RBA'=1501 +'RBO_OUTLINE'=1502 +'RCFILE'=1503 +'RDBA'=1504 +'READ'=1505 +'READS'=1506 +'READSIZE'=1507 +'REALM'=1508 +'REAL'=1509 +'REBALANCE'=1510 +'REBUILD'=1511 +'RECORD'=1512 +'RECORDS'=1513 +'RECORDS_PER_BLOCK'=1514 +'RECOVERABLE'=1515 +'RECOVER'=1516 +'RECOVERY'=1517 +'RECYCLEBIN'=1518 +'RECYCLE'=1519 +'REDACTION'=1520 +'REDEFINE'=1521 +'REDO'=1522 +'REDUCED'=1523 +'REDUNDANCY'=1524 +'REF_CASCADE_CURSOR'=1525 +'REFERENCED'=1526 +'REFERENCE'=1527 +'REFERENCES'=1528 +'REFERENCING'=1529 +'REF'=1530 +'REFRESH'=1531 +'REFTOHEX'=1532 +'REGEXP_COUNT'=1533 +'REGEXP_INSTR'=1534 +'REGEXP_LIKE'=1535 +'REGEXP_REPLACE'=1536 +'REGEXP_SUBSTR'=1537 +'REGISTER'=1538 +'REGR_AVGX'=1539 +'REGR_AVGY'=1540 +'REGR_COUNT'=1541 +'REGR_INTERCEPT'=1542 +'REGR_R2'=1543 +'REGR_SLOPE'=1544 +'REGR_SXX'=1545 +'REGR_SXY'=1546 +'REGR_SYY'=1547 +'REGULAR'=1548 +'REJECT'=1549 +'REKEY'=1550 +'RELATIONAL'=1551 +'RELIES_ON'=1552 +'RELOCATE'=1553 +'RELY'=1554 +'REMAINDER'=1555 +'REMOTE'=1556 +'REMOTE_MAPPED'=1557 +'REMOVE'=1558 +'RENAME'=1559 +'REPAIR'=1560 +'REPEAT'=1561 +'REPLACE'=1562 +'REPLICATION'=1563 +'REQUIRED'=1564 +'RESETLOGS'=1565 +'RESET'=1566 +'RESIZE'=1567 +'RESOLVE'=1568 +'RESOLVER'=1569 +'RESOURCE'=1570 +'RESPECT'=1571 +'RESTART'=1572 +'RESTORE_AS_INTERVALS'=1573 +'RESTORE'=1574 +'RESTRICT_ALL_REF_CONS'=1575 +'RESTRICTED'=1576 +'RESTRICT_REFERENCES'=1577 +'RESTRICT'=1578 +'RESULT_CACHE'=1579 +'RESULT'=1580 +'RESUMABLE'=1581 +'RESUME'=1582 +'RETENTION'=1583 +'RETRY_ON_ROW_CHANGE'=1584 +'RETURNING'=1585 +'RETURN'=1586 +'REUSE'=1587 +'REVERSE'=1588 +'REVOKE'=1589 +'REWRITE_OR_ERROR'=1590 +'REWRITE'=1591 +'RIGHT'=1592 +'ROLE'=1593 +'ROLESET'=1594 +'ROLES'=1595 +'ROLLBACK'=1596 +'ROLLING'=1597 +'ROLLUP'=1598 +'ROWDEPENDENCIES'=1599 +'ROWID_MAPPING_TABLE'=1600 +'ROWID'=1601 +'ROWIDTOCHAR'=1602 +'ROWIDTONCHAR'=1603 +'ROW_LENGTH'=1604 +'ROWNUM'=1605 +'ROW'=1606 +'ROWS'=1607 +'RPAD'=1608 +'RTRIM'=1609 +'RULE'=1610 +'RULES'=1611 +'RUNNING'=1612 +'SALT'=1613 +'SAMPLE'=1614 +'SAVE_AS_INTERVALS'=1615 +'SAVEPOINT'=1616 +'SAVE'=1617 +'SB4'=1618 +'SCALE_ROWS'=1619 +'SCALE'=1620 +'SCAN_INSTANCES'=1621 +'SCAN'=1622 +'SCHEDULER'=1623 +'SCHEMACHECK'=1624 +'SCHEMA'=1625 +'SCN_ASCENDING'=1626 +'SCN'=1627 +'SCOPE'=1628 +'SCRUB'=1629 +'SD_ALL'=1630 +'SD_INHIBIT'=1631 +'SDO_GEOM_MBR'=1632 +'SDO_GEOMETRY'=1633 +'SD_SHOW'=1634 +'SEARCH'=1635 +'SECOND'=1636 +'SECONDS'=1637 +'SECRET'=1638 +'SECUREFILE_DBA'=1639 +'SECUREFILE'=1640 +'SECURITY'=1641 +'SEED'=1642 +'SEG_BLOCK'=1643 +'SEG_FILE'=1644 +'SEGMENT'=1645 +'SELECTIVITY'=1646 +'SELECT'=1647 +'SELF'=1648 +'SEMIJOIN_DRIVER'=1649 +'SEMIJOIN'=1650 +'SEMI_TO_INNER'=1651 +'SEQUENCED'=1652 +'SEQUENCE'=1653 +'SEQUENCEFILE'=1654 +'SEQUENTIAL'=1655 +'SEQ'=1656 +'SERDE'=1657 +'SERDEPROPERTIES'=1658 +'SERIALIZABLE'=1659 +'SERIALLY_REUSABLE'=1660 +'SERIAL'=1661 +'SERVERERROR'=1662 +'SERVICE_NAME_CONVERT'=1663 +'SERVICE'=1664 +'SERVICES'=1665 +'SESSION_CACHED_CURSORS'=1666 +'SESSION'=1667 +'SESSIONS_PER_USER'=1668 +'SESSIONTIMEZONE'=1669 +'SESSIONTZNAME'=1670 +'SET'=1671 +'SETS'=1672 +'SETTINGS'=1673 +'SET_TO_JOIN'=1674 +'SEVERE'=1675 +'SHARD'=1676 +'SHARDSPACE'=1677 +'SHARED_POOL'=1678 +'SHARED'=1679 +'SHARE'=1680 +'SHARING'=1681 +'SHELFLIFE'=1682 +'SHOW'=1683 +'SHRINK'=1684 +'SHUTDOWN'=1685 +'SIBLINGS'=1686 +'SID'=1687 +'SITE'=1688 +'SIGNAL_COMPONENT'=1689 +'SIGNAL_FUNCTION'=1690 +'SIGN'=1691 +'SIGNTYPE'=1692 +'SIMPLE_INTEGER'=1693 +'SIMPLE'=1694 +'SINGLE'=1695 +'SINGLETASK'=1696 +'SINH'=1697 +'SIN'=1698 +'SIZE'=1699 +'SIZES'=1700 +'SKIP_EXT_OPTIMIZER'=1701 +'SKIP'=1702 +'SKIP_UNQ_UNUSABLE_IDX'=1703 +'SKIP_UNUSABLE_INDEXES'=1704 +'SMALLFILE'=1705 +'SMALLINT'=1706 +'SNAPSHOT'=1707 +'SOME'=1708 +'SORT'=1709 +'SOUNDEX'=1710 +'SOURCE_FILE_DIRECTORY'=1711 +'SOURCE_FILE_NAME_CONVERT'=1712 +'SOURCE'=1713 +'SPACE'=1714 +'SPECIFICATION'=1715 +'SPFILE'=1716 +'SPLIT'=1717 +'SPREADSHEET'=1718 +'SQLDATA'=1719 +'SQLERROR'=1720 +'SQLLDR'=1721 +'SQL'=1722 +'SQL_MACRO'=1724 +'SQL_TRACE'=1725 +'SQL_TRANSLATION_PROFILE'=1726 +'SQRT'=1727 +'STALE'=1728 +'STANDALONE'=1729 +'STANDARD'=1730 +'STANDARD_HASH'=1731 +'STANDBY_MAX_DATA_DELAY'=1732 +'STANDBYS'=1733 +'STANDBY'=1734 +'STAR'=1735 +'STAR_TRANSFORMATION'=1736 +'START'=1737 +'STARTOF'=1738 +'STARTUP'=1739 +'STATEMENT_ID'=1740 +'STATEMENT_QUEUING'=1741 +'STATEMENTS'=1742 +'STATEMENT'=1743 +'STATE'=1744 +'STATIC'=1745 +'STATISTICS'=1746 +'STATS_BINOMIAL_TEST'=1747 +'STATS_CROSSTAB'=1748 +'STATS_F_TEST'=1749 +'STATS_KS_TEST'=1750 +'STATS_MODE'=1751 +'STATS_MW_TEST'=1752 +'STATS_ONE_WAY_ANOVA'=1753 +'STATS_T_TEST_INDEP'=1754 +'STATS_T_TEST_INDEPU'=1755 +'STATS_T_TEST_ONE'=1756 +'STATS_T_TEST_PAIRED'=1757 +'STATS_WSR_TEST'=1758 +'STDDEV_POP'=1759 +'STDDEV_SAMP'=1760 +'STOP'=1761 +'STORAGE'=1762 +'STORE'=1763 +'STREAMS'=1764 +'STREAM'=1765 +'STRICT'=1766 +'STRING'=1767 +'STRIPE_COLUMNS'=1768 +'STRIPE_WIDTH'=1769 +'STRIP'=1770 +'STRUCTURE'=1771 +'SUBMULTISET'=1772 +'SUBPARTITION_REL'=1773 +'SUBPARTITIONS'=1774 +'SUBPARTITION'=1775 +'SUBQUERIES'=1776 +'SUBQUERY_PRUNING'=1777 +'SUBSCRIBE'=1778 +'SUBSET'=1779 +'SUBSTITUTABLE'=1780 +'SUBSTR2'=1781 +'SUBSTR4'=1782 +'SUBSTRB'=1783 +'SUBSTRC'=1784 +'SUBTYPE'=1785 +'SUCCESSFUL'=1786 +'SUCCESS'=1787 +'SUMMARY'=1788 +'SUPPLEMENTAL'=1789 +'SUSPEND'=1790 +'SWAP_JOIN_INPUTS'=1791 +'SWITCHOVER'=1792 +'SWITCH'=1793 +'SYNCHRONOUS'=1794 +'SYNC'=1795 +'SYNONYM'=1796 +'SYS'=1797 +'SYSASM'=1798 +'SYS_AUDIT'=1799 +'SYSAUX'=1800 +'SYSBACKUP'=1801 +'SYS_CHECKACL'=1802 +'SYS_CHECK_PRIVILEGE'=1803 +'SYS_CONNECT_BY_PATH'=1804 +'SYS_CONTEXT'=1805 +'SYSDATE'=1806 +'SYSDBA'=1807 +'SYS_DBURIGEN'=1808 +'SYSDG'=1809 +'SYS_DL_CURSOR'=1810 +'SYS_DM_RXFORM_CHR'=1811 +'SYS_DM_RXFORM_NUM'=1812 +'SYS_DOM_COMPARE'=1813 +'SYS_DST_PRIM2SEC'=1814 +'SYS_DST_SEC2PRIM'=1815 +'SYS_ET_BFILE_TO_RAW'=1816 +'SYS_ET_BLOB_TO_IMAGE'=1817 +'SYS_ET_IMAGE_TO_BLOB'=1818 +'SYS_ET_RAW_TO_BFILE'=1819 +'SYS_EXTPDTXT'=1820 +'SYS_EXTRACT_UTC'=1821 +'SYS_FBT_INSDEL'=1822 +'SYS_FILTER_ACLS'=1823 +'SYS_FNMATCHES'=1824 +'SYS_FNREPLACE'=1825 +'SYS_GET_ACLIDS'=1826 +'SYS_GET_COL_ACLIDS'=1827 +'SYS_GET_PRIVILEGES'=1828 +'SYS_GETTOKENID'=1829 +'SYS_GETXTIVAL'=1830 +'SYS_GUID'=1831 +'SYSGUID'=1832 +'SYSKM'=1833 +'SYS_MAKE_XMLNODEID'=1834 +'SYS_MAKEXML'=1835 +'SYS_MKXMLATTR'=1836 +'SYS_MKXTI'=1837 +'SYSOBJ'=1838 +'SYS_OP_ADT2BIN'=1839 +'SYS_OP_ADTCONS'=1840 +'SYS_OP_ALSCRVAL'=1841 +'SYS_OP_ATG'=1842 +'SYS_OP_BIN2ADT'=1843 +'SYS_OP_BITVEC'=1844 +'SYS_OP_BL2R'=1845 +'SYS_OP_BLOOM_FILTER_LIST'=1846 +'SYS_OP_BLOOM_FILTER'=1847 +'SYS_OP_C2C'=1848 +'SYS_OP_CAST'=1849 +'SYS_OP_CEG'=1850 +'SYS_OP_CL2C'=1851 +'SYS_OP_COMBINED_HASH'=1852 +'SYS_OP_COMP'=1853 +'SYS_OP_CONVERT'=1854 +'SYS_OP_COUNTCHG'=1855 +'SYS_OP_CSCONV'=1856 +'SYS_OP_CSCONVTEST'=1857 +'SYS_OP_CSR'=1858 +'SYS_OP_CSX_PATCH'=1859 +'SYS_OP_CYCLED_SEQ'=1860 +'SYS_OP_DECOMP'=1861 +'SYS_OP_DESCEND'=1862 +'SYS_OP_DISTINCT'=1863 +'SYS_OP_DRA'=1864 +'SYS_OP_DUMP'=1865 +'SYS_OP_DV_CHECK'=1866 +'SYS_OP_ENFORCE_NOT_NULL$'=1867 +'SYSOPER'=1868 +'SYS_OP_EXTRACT'=1869 +'SYS_OP_GROUPING'=1870 +'SYS_OP_GUID'=1871 +'SYS_OP_HASH'=1872 +'SYS_OP_IIX'=1873 +'SYS_OP_ITR'=1874 +'SYS_OP_KEY_VECTOR_CREATE'=1875 +'SYS_OP_KEY_VECTOR_FILTER_LIST'=1876 +'SYS_OP_KEY_VECTOR_FILTER'=1877 +'SYS_OP_KEY_VECTOR_SUCCEEDED'=1878 +'SYS_OP_KEY_VECTOR_USE'=1879 +'SYS_OP_LBID'=1880 +'SYS_OP_LOBLOC2BLOB'=1881 +'SYS_OP_LOBLOC2CLOB'=1882 +'SYS_OP_LOBLOC2ID'=1883 +'SYS_OP_LOBLOC2NCLOB'=1884 +'SYS_OP_LOBLOC2TYP'=1885 +'SYS_OP_LSVI'=1886 +'SYS_OP_LVL'=1887 +'SYS_OP_MAKEOID'=1888 +'SYS_OP_MAP_NONNULL'=1889 +'SYS_OP_MSR'=1890 +'SYS_OP_NICOMBINE'=1891 +'SYS_OP_NIEXTRACT'=1892 +'SYS_OP_NII'=1893 +'SYS_OP_NIX'=1894 +'SYS_OP_NOEXPAND'=1895 +'SYS_OP_NTCIMG$'=1896 +'SYS_OP_NUMTORAW'=1897 +'SYS_OP_OIDVALUE'=1898 +'SYS_OP_OPNSIZE'=1899 +'SYS_OP_PAR_1'=1900 +'SYS_OP_PARGID_1'=1901 +'SYS_OP_PARGID'=1902 +'SYS_OP_PAR'=1903 +'SYS_OP_PART_ID'=1904 +'SYS_OP_PIVOT'=1905 +'SYS_OP_R2O'=1906 +'SYS_OP_RAWTONUM'=1907 +'SYS_OP_RDTM'=1908 +'SYS_OP_REF'=1909 +'SYS_OP_RMTD'=1910 +'SYS_OP_ROWIDTOOBJ'=1911 +'SYS_OP_RPB'=1912 +'SYS_OPTLOBPRBSC'=1913 +'SYS_OP_TOSETID'=1914 +'SYS_OP_TPR'=1915 +'SYS_OP_TRTB'=1916 +'SYS_OPTXICMP'=1917 +'SYS_OPTXQCASTASNQ'=1918 +'SYS_OP_UNDESCEND'=1919 +'SYS_OP_VECAND'=1920 +'SYS_OP_VECBIT'=1921 +'SYS_OP_VECOR'=1922 +'SYS_OP_VECXOR'=1923 +'SYS_OP_VERSION'=1924 +'SYS_OP_VREF'=1925 +'SYS_OP_VVD'=1926 +'SYS_OP_XMLCONS_FOR_CSX'=1927 +'SYS_OP_XPTHATG'=1928 +'SYS_OP_XPTHIDX'=1929 +'SYS_OP_XPTHOP'=1930 +'SYS_OP_XTXT2SQLT'=1931 +'SYS_OP_ZONE_ID'=1932 +'SYS_ORDERKEY_DEPTH'=1933 +'SYS_ORDERKEY_MAXCHILD'=1934 +'SYS_ORDERKEY_PARENT'=1935 +'SYS_PARALLEL_TXN'=1936 +'SYS_PATHID_IS_ATTR'=1937 +'SYS_PATHID_IS_NMSPC'=1938 +'SYS_PATHID_LASTNAME'=1939 +'SYS_PATHID_LASTNMSPC'=1940 +'SYS_PATH_REVERSE'=1941 +'SYS_PXQEXTRACT'=1942 +'SYS_RAW_TO_XSID'=1943 +'SYS_RID_ORDER'=1944 +'SYS_ROW_DELTA'=1945 +'SYS_SC_2_XMLT'=1946 +'SYS_SYNRCIREDO'=1947 +'SYSTEM_DEFINED'=1948 +'SYSTEM'=1949 +'SYSTIMESTAMP'=1950 +'SYS_TYPEID'=1951 +'SYS_UMAKEXML'=1952 +'SYS_XMLANALYZE'=1953 +'SYS_XMLCONTAINS'=1954 +'SYS_XMLCONV'=1955 +'SYS_XMLEXNSURI'=1956 +'SYS_XMLGEN'=1957 +'SYS_XMLI_LOC_ISNODE'=1958 +'SYS_XMLI_LOC_ISTEXT'=1959 +'SYS_XMLINSTR'=1960 +'SYS_XMLLOCATOR_GETSVAL'=1961 +'SYS_XMLNODEID_GETCID'=1962 +'SYS_XMLNODEID_GETLOCATOR'=1963 +'SYS_XMLNODEID_GETOKEY'=1964 +'SYS_XMLNODEID_GETPATHID'=1965 +'SYS_XMLNODEID_GETPTRID'=1966 +'SYS_XMLNODEID_GETRID'=1967 +'SYS_XMLNODEID_GETSVAL'=1968 +'SYS_XMLNODEID_GETTID'=1969 +'SYS_XMLNODEID'=1970 +'SYS_XMLT_2_SC'=1971 +'SYS_XMLTRANSLATE'=1972 +'SYS_XMLTYPE2SQL'=1973 +'SYS_XQ_ASQLCNV'=1974 +'SYS_XQ_ATOMCNVCHK'=1975 +'SYS_XQBASEURI'=1976 +'SYS_XQCASTABLEERRH'=1977 +'SYS_XQCODEP2STR'=1978 +'SYS_XQCODEPEQ'=1979 +'SYS_XQCON2SEQ'=1980 +'SYS_XQCONCAT'=1981 +'SYS_XQDELETE'=1982 +'SYS_XQDFLTCOLATION'=1983 +'SYS_XQDOC'=1984 +'SYS_XQDOCURI'=1985 +'SYS_XQDURDIV'=1986 +'SYS_XQED4URI'=1987 +'SYS_XQENDSWITH'=1988 +'SYS_XQERRH'=1989 +'SYS_XQERR'=1990 +'SYS_XQESHTMLURI'=1991 +'SYS_XQEXLOBVAL'=1992 +'SYS_XQEXSTWRP'=1993 +'SYS_XQEXTRACT'=1994 +'SYS_XQEXTRREF'=1995 +'SYS_XQEXVAL'=1996 +'SYS_XQFB2STR'=1997 +'SYS_XQFNBOOL'=1998 +'SYS_XQFNCMP'=1999 +'SYS_XQFNDATIM'=2000 +'SYS_XQFNLNAME'=2001 +'SYS_XQFNNM'=2002 +'SYS_XQFNNSURI'=2003 +'SYS_XQFNPREDTRUTH'=2004 +'SYS_XQFNQNM'=2005 +'SYS_XQFNROOT'=2006 +'SYS_XQFORMATNUM'=2007 +'SYS_XQFTCONTAIN'=2008 +'SYS_XQFUNCR'=2009 +'SYS_XQGETCONTENT'=2010 +'SYS_XQINDXOF'=2011 +'SYS_XQINSERT'=2012 +'SYS_XQINSPFX'=2013 +'SYS_XQIRI2URI'=2014 +'SYS_XQLANG'=2015 +'SYS_XQLLNMFRMQNM'=2016 +'SYS_XQMKNODEREF'=2017 +'SYS_XQNILLED'=2018 +'SYS_XQNODENAME'=2019 +'SYS_XQNORMSPACE'=2020 +'SYS_XQNORMUCODE'=2021 +'SYS_XQ_NRNG'=2022 +'SYS_XQNSP4PFX'=2023 +'SYS_XQNSPFRMQNM'=2024 +'SYS_XQPFXFRMQNM'=2025 +'SYS_XQ_PKSQL2XML'=2026 +'SYS_XQPOLYABS'=2027 +'SYS_XQPOLYADD'=2028 +'SYS_XQPOLYCEL'=2029 +'SYS_XQPOLYCSTBL'=2030 +'SYS_XQPOLYCST'=2031 +'SYS_XQPOLYDIV'=2032 +'SYS_XQPOLYFLR'=2033 +'SYS_XQPOLYMOD'=2034 +'SYS_XQPOLYMUL'=2035 +'SYS_XQPOLYRND'=2036 +'SYS_XQPOLYSQRT'=2037 +'SYS_XQPOLYSUB'=2038 +'SYS_XQPOLYUMUS'=2039 +'SYS_XQPOLYUPLS'=2040 +'SYS_XQPOLYVEQ'=2041 +'SYS_XQPOLYVGE'=2042 +'SYS_XQPOLYVGT'=2043 +'SYS_XQPOLYVLE'=2044 +'SYS_XQPOLYVLT'=2045 +'SYS_XQPOLYVNE'=2046 +'SYS_XQREF2VAL'=2047 +'SYS_XQRENAME'=2048 +'SYS_XQREPLACE'=2049 +'SYS_XQRESVURI'=2050 +'SYS_XQRNDHALF2EVN'=2051 +'SYS_XQRSLVQNM'=2052 +'SYS_XQRYENVPGET'=2053 +'SYS_XQRYVARGET'=2054 +'SYS_XQRYWRP'=2055 +'SYS_XQSEQ2CON4XC'=2056 +'SYS_XQSEQ2CON'=2057 +'SYS_XQSEQDEEPEQ'=2058 +'SYS_XQSEQINSB'=2059 +'SYS_XQSEQRM'=2060 +'SYS_XQSEQRVS'=2061 +'SYS_XQSEQSUB'=2062 +'SYS_XQSEQTYPMATCH'=2063 +'SYS_XQSTARTSWITH'=2064 +'SYS_XQSTATBURI'=2065 +'SYS_XQSTR2CODEP'=2066 +'SYS_XQSTRJOIN'=2067 +'SYS_XQSUBSTRAFT'=2068 +'SYS_XQSUBSTRBEF'=2069 +'SYS_XQTOKENIZE'=2070 +'SYS_XQTREATAS'=2071 +'SYS_XQ_UPKXML2SQL'=2072 +'SYS_XQXFORM'=2073 +'SYS_XSID_TO_RAW'=2074 +'SYS_ZMAP_FILTER'=2075 +'SYS_ZMAP_REFRESH'=2076 +'T'=2077 +'TABLE_LOOKUP_BY_NL'=2078 +'TABLESPACE_NO'=2079 +'TABLESPACE'=2080 +'TABLES'=2081 +'TABLE_STATS'=2082 +'TABLE'=2083 +'TABNO'=2084 +'TAG'=2085 +'TANH'=2086 +'TAN'=2087 +'TBL$OR$IDX$PART$NUM'=2088 +'TEMPFILE'=2089 +'TEMPLATE'=2090 +'TEMPLATE_TABLE'=2091 +'TEMPORARY'=2092 +'TEMP_TABLE'=2093 +'TERMINATED'=2094 +'TEST'=2095 +'TEXT'=2096 +'TEXTFILE'=2097 +'THAN'=2098 +'THEN'=2099 +'THE'=2100 +'THESE'=2101 +'THREAD'=2102 +'THROUGH'=2103 +'TIER'=2104 +'TIES'=2105 +'TIMEOUT'=2106 +'TIMESTAMP_LTZ_UNCONSTRAINED'=2107 +'TIMESTAMP'=2108 +'TIMESTAMP_TZ_UNCONSTRAINED'=2109 +'TIMESTAMP_UNCONSTRAINED'=2110 +'TIMES'=2111 +'TIME'=2112 +'TIMEZONE'=2113 +'TIMEZONE_ABBR'=2114 +'TIMEZONE_HOUR'=2115 +'TIMEZONE_MINUTE'=2116 +'TIMEZONE_OFFSET'=2117 +'TIMEZONE_REGION'=2118 +'TIME_ZONE'=2119 +'TIMING'=2120 +'TINYINT'=2121 +'TIV_GB'=2122 +'TIV_SSF'=2123 +'TO_ACLID'=2124 +'TO_BINARY_DOUBLE'=2125 +'TO_BINARY_FLOAT'=2126 +'TO_BLOB'=2127 +'TO_CLOB'=2128 +'TO_DSINTERVAL'=2129 +'TO_LOB'=2130 +'TO_MULTI_BYTE'=2131 +'TO_NCHAR'=2132 +'TO_NCLOB'=2133 +'TO_NUMBER'=2134 +'TOPLEVEL'=2135 +'TO_SINGLE_BYTE'=2136 +'TO_TIMESTAMP'=2137 +'TO_TIMESTAMP_TZ'=2138 +'TO_TIME'=2139 +'TO_TIME_TZ'=2140 +'TO'=2141 +'TO_YMINTERVAL'=2142 +'TRACE'=2143 +'TRACING'=2144 +'TRACKING'=2145 +'TRAILING'=2146 +'TRANSACTION'=2147 +'TRANSFORM'=2148 +'TRANSFORMS'=2149 +'TRANSFORM_DISTINCT_AGG'=2150 +'TRANSITIONAL'=2151 +'TRANSITION'=2152 +'TRANSLATE'=2153 +'TRANSLATION'=2154 +'TREAT'=2155 +'TRIGGERS'=2156 +'TRIGGER'=2157 +'TRUE'=2158 +'TRUNCATE'=2159 +'TRUNC'=2160 +'TRUSTED'=2161 +'TRUST'=2162 +'TUNING'=2163 +'TX'=2164 +'TYPES'=2165 +'TYPE'=2166 +'TZ_OFFSET'=2167 +'UB2'=2168 +'UBA'=2169 +'UCS2'=2170 +'UDF'=2171 +'UID'=2172 +'UNARCHIVED'=2173 +'UNBOUNDED'=2174 +'UNBOUND'=2175 +'UNCONDITIONAL'=2176 +'UNDER'=2177 +'UNDO'=2178 +'UNDROP'=2179 +'UNIFORM'=2180 +'UNION'=2181 +'UNIONTYPE'=2182 +'UNIQUE'=2183 +'UNISTR'=2184 +'UNLIMITED'=2185 +'UNLOAD'=2186 +'UNLOCK'=2187 +'UNMATCHED'=2188 +'UNNEST_INNERJ_DISTINCT_VIEW'=2189 +'UNNEST_NOSEMIJ_NODISTINCTVIEW'=2190 +'UNNEST_SEMIJ_VIEW'=2191 +'UNNEST'=2192 +'UNPACKED'=2193 +'UNPIVOT'=2194 +'UNPLUG'=2195 +'UNPROTECTED'=2196 +'UNQUIESCE'=2197 +'UNRECOVERABLE'=2198 +'UNRESTRICTED'=2199 +'UNSIGNED'=2200 +'UNSUBSCRIBE'=2201 +'UNTIL'=2202 +'UNUSABLE'=2203 +'UNUSED'=2204 +'UPDATABLE'=2205 +'UPDATED'=2206 +'UPDATE'=2207 +'UPDATEXML'=2208 +'UPD_INDEXES'=2209 +'UPD_JOININDEX'=2210 +'UPGRADE'=2211 +'UPPER'=2212 +'UPSERT'=2213 +'UROWID'=2214 +'USABLE'=2215 +'USAGE'=2216 +'USE_ANTI'=2217 +'USE_CONCAT'=2218 +'USE_CUBE'=2219 +'USE_HASH_AGGREGATION'=2220 +'USE_HASH_GBY_FOR_PUSHDOWN'=2221 +'USE_HASH'=2222 +'USE_HIDDEN_PARTITIONS'=2223 +'USE_INVISIBLE_INDEXES'=2224 +'USE_MERGE_CARTESIAN'=2225 +'USE_MERGE'=2226 +'USE_NL'=2227 +'USE_NL_WITH_INDEX'=2228 +'USE_PRIVATE_OUTLINES'=2229 +'USER_DATA'=2230 +'USER_DEFINED'=2231 +'USERENV'=2232 +'USERGROUP'=2233 +'USER_RECYCLEBIN'=2234 +'USERS'=2235 +'USER_TABLESPACES'=2236 +'USER'=2237 +'USE_SEMI'=2238 +'USE_STORED_OUTLINES'=2239 +'USE_TTT_FOR_GSETS'=2240 +'USE'=2241 +'USE_VECTOR_AGGREGATION'=2242 +'USE_WEAK_NAME_RESL'=2243 +'USING_NO_EXPAND'=2244 +'USING_NLS_COMP'=2245 +'USING'=2246 +'UTF16BE'=2247 +'UTF16LE'=2248 +'UTF32'=2249 +'UTF8'=2250 +'V1'=2251 +'V2'=2252 +'VALIDATE'=2253 +'VALIDATE_CONVERSION'=2254 +'VALIDATION'=2255 +'VALID_TIME_END'=2256 +'VALUES'=2257 +'VALUE'=2258 +'VARCHAR2'=2259 +'VARCHAR'=2260 +'VARCHARC'=2261 +'VARIABLE'=2262 +'VARRAW'=2263 +'VARRAWC'=2264 +'VAR_POP'=2265 +'VARRAYS'=2266 +'VARRAY'=2267 +'VAR_SAMP'=2268 +'VARYING'=2269 +'VECTOR_READ_TRACE'=2270 +'VECTOR_READ'=2271 +'VECTOR_TRANSFORM_DIMS'=2272 +'VECTOR_TRANSFORM_FACT'=2273 +'VECTOR_TRANSFORM'=2274 +'VERIFIER'=2275 +'VERIFY'=2276 +'VERSIONING'=2277 +'VERSIONS_ENDSCN'=2278 +'VERSIONS_ENDTIME'=2279 +'VERSIONS_OPERATION'=2280 +'VERSIONS_STARTSCN'=2281 +'VERSIONS_STARTTIME'=2282 +'VERSIONS'=2283 +'VERSIONS_XID'=2284 +'VERSION'=2285 +'VIEW'=2286 +'VIOLATION'=2287 +'VIRTUAL'=2288 +'VISIBILITY'=2289 +'VISIBLE'=2290 +'VOLUME'=2291 +'VSIZE'=2292 +'WAIT'=2293 +'WALLET'=2294 +'WARNING'=2295 +'WEEKS'=2296 +'WEEK'=2297 +'WELLFORMED'=2298 +'WHENEVER'=2299 +'WHEN'=2300 +'WHERE'=2301 +'WHILE'=2302 +'WHITESPACE'=2303 +'WIDTH_BUCKET'=2304 +'WITHIN'=2305 +'WITHOUT'=2306 +'WITH_PLSQL'=2307 +'WITH'=2308 +'WORK'=2309 +'WORKERID'=2310 +'WRAPPED'=2311 +'WRAPPER'=2312 +'WRITE'=2313 +'XDB_FASTPATH_INSERT'=2314 +'XDB'=2315 +'X_DYN_PRUNE'=2316 +'XID'=2317 +'XML2OBJECT'=2318 +'XMLAGG'=2319 +'XMLATTRIBUTES'=2320 +'XMLCAST'=2321 +'XMLCDATA'=2322 +'XMLCOLATTVAL'=2323 +'XMLCOMMENT'=2324 +'XMLCONCAT'=2325 +'XMLDIFF'=2326 +'XML_DML_RWT_STMT'=2327 +'XMLELEMENT'=2328 +'XMLEXISTS2'=2329 +'XMLEXISTS'=2330 +'XMLFOREST'=2331 +'XMLINDEX'=2332 +'XMLINDEX_REWRITE_IN_SELECT'=2333 +'XMLINDEX_REWRITE'=2334 +'XMLINDEX_SEL_IDX_TBL'=2335 +'XMLISNODE'=2336 +'XMLISVALID'=2337 +'XMLNAMESPACES'=2338 +'XMLPARSE'=2339 +'XMLPATCH'=2340 +'XMLPI'=2341 +'XMLQUERYVAL'=2342 +'XMLQUERY'=2343 +'XMLROOT'=2344 +'XMLSCHEMA'=2345 +'XMLSERIALIZE'=2346 +'XMLTABLE'=2347 +'XMLTAG'=2348 +'XMLTRANSFORMBLOB'=2349 +'XMLTRANSFORM'=2350 +'XMLTYPE'=2351 +'XML'=2352 +'XPATHTABLE'=2353 +'XS_SYS_CONTEXT'=2354 +'XS'=2355 +'XTRANSPORT'=2356 +'YEARS'=2357 +'YEAR'=2358 +'YEAR_TO_MONTH'=2359 +'YES'=2360 +'YMINTERVAL_UNCONSTRAINED'=2361 +'ZONEMAP'=2362 +'ZONE'=2363 +'ZONED'=2364 +'PREDICTION'=2365 +'PREDICTION_BOUNDS'=2366 +'PREDICTION_COST'=2367 +'PREDICTION_DETAILS'=2368 +'PREDICTION_PROBABILITY'=2369 +'PREDICTION_SET'=2370 +'BLOCKCHAIN'=2371 +'COLLATE'=2372 +'COLLATION'=2373 +'DEFINITION'=2374 +'DUPLICATED'=2375 +'EXTENDED'=2376 +'HASHING'=2377 +'IDLE'=2378 +'IMMUTABLE'=2379 +'ORACLE_DATAPUMP'=2380 +'ORACLE_HDFS'=2381 +'ORACLE_HIVE'=2382 +'ORACLE_LOADER'=2383 +'"SHA2_512"'=2384 +'SHARDED'=2385 +'"V1"'=2386 +'ISOLATE'=2387 +'ROOT'=2388 +'UNITE'=2389 +'ALGORITHM'=2390 +'CUME_DIST'=2391 +'DENSE_RANK'=2392 +'LISTAGG'=2393 +'PERCENT_RANK'=2394 +'PERCENTILE_CONT'=2395 +'PERCENTILE_DISC'=2396 +'RANK'=2397 +'AVG'=2398 +'CORR'=2399 +'COVAR_'=2400 +'DECODE'=2401 +'LAG'=2402 +'LAG_DIFF'=2403 +'LAG_DIFF_PERCENT'=2404 +'LEAD'=2405 +'MAX'=2406 +'MEDIAN'=2407 +'MEMOPTIMIZE'=2408 +'MIN'=2409 +'NTILE'=2410 +'NVL'=2411 +'RATIO_TO_REPORT'=2412 +'REGR_'=2413 +'ROUND'=2414 +'ROW_NUMBER'=2415 +'SUBSTR'=2416 +'TO_CHAR'=2417 +'TRIM'=2418 +'SUM'=2419 +'STDDEV'=2420 +'VAR_'=2421 +'VARIANCE'=2422 +'LEAST'=2423 +'GREATEST'=2424 +'TO_DATE'=2425 +'CHARSETID'=2426 +'CHARSETFORM'=2427 +'DURATION'=2428 +'EXTEND'=2429 +'MAXLEN'=2430 +'PERSISTABLE'=2431 +'POLYMORPHIC'=2432 +'STRUCT'=2433 +'TDO'=2434 +'WM_CONCAT'=2435 +'..'=2439 +'.'=2440 +'%'=2445 +'&'=2446 +'('=2447 +')'=2448 +'**'=2449 +'*'=2450 +'+'=2451 +'-'=2452 +','=2453 +'/'=2454 +'\\'=2455 +'@'=2456 +':='=2457 +'#'=2458 +'{'=2459 +'}'=2460 +'\''=2461 +'^'=2464 +'~'=2465 +'!'=2466 +'>'=2467 +'<'=2468 +':'=2469 +';'=2470 +'|'=2471 +'='=2472 +'['=2473 +']'=2474 +'_'=2475 diff --git a/internal/engine/oracle/parser/PlSqlParser.g4 b/internal/engine/oracle/parser/PlSqlParser.g4 new file mode 100644 index 0000000000..554839180f --- /dev/null +++ b/internal/engine/oracle/parser/PlSqlParser.g4 @@ -0,0 +1,10042 @@ +/** + * Oracle(c) PL/SQL 11g Parser + * + * Copyright (c) 2009-2011 Alexandre Porcelli + * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies). + * Copyright (c) 2017-2018 Mark Adams + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// $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?)* ( + (sql_plus_command | unit_statement) (SEMICOLON '/'? (sql_plus_command | unit_statement))* SEMICOLON? '/'? + ) EOF + ; + +unit_statement + : alter_analytic_view + | alter_attribute_dimension + | alter_audit_policy + | alter_cluster + | alter_database + | alter_database_link + | alter_dimension + | alter_diskgroup + | alter_flashback_archive + | alter_function + | alter_hierarchy + | alter_index + | alter_inmemory_join_group + | alter_java + | alter_library + | alter_lockdown_profile + | alter_materialized_view + | alter_materialized_view_log + | alter_materialized_zonemap + | alter_operator + | alter_outline + | alter_package + | alter_pmem_filestore + | alter_procedure + | alter_resource_cost + | alter_role + | alter_rollback_segment + | alter_sequence + | alter_session + | alter_synonym + | alter_table + | alter_tablespace + | alter_tablespace_set + | alter_trigger + | alter_type + | alter_user + | alter_view + | anonymous_block + | 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_function_body + | create_hierarchy + | create_index + | create_inmemory_join_group + | create_java + | create_library + | create_lockdown_profile + | create_materialized_view + | create_materialized_view_log + | create_materialized_zonemap + | create_operator + | create_outline + | create_package + | create_package_body + | create_pmem_filestore + | create_procedure_body + | create_profile + | create_restore_point + | create_role + | create_rollback_segment + | create_sequence + | create_spfile + | create_synonym + | create_table + | create_tablespace + | create_tablespace_set + | create_trigger + | create_type + | create_user + | create_view + | drop_analytic_view + | drop_attribute_dimension + | drop_audit_policy + | drop_cluster + | drop_context + | drop_database + | drop_database_link + | drop_directory + | drop_diskgroup + | drop_edition + | drop_flashback_archive + | drop_function + | drop_hierarchy + | drop_index + | drop_indextype + | drop_inmemory_join_group + | drop_java + | drop_library + | drop_lockdown_profile + | drop_materialized_view + | drop_materialized_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)? 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)? 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_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_collection_clauses + : MODIFY (LIMIT expression | ELEMENT TYPE type_spec) + ; + +dependent_handling_clause + : INVALIDATE + | CASCADE (CONVERT TO SUBSTITUTABLE | NOT? INCLUDING TABLE DATA)? dependent_exceptions_part? + ; + +dependent_exceptions_part + : FORCE? EXCEPTIONS INTO tableview_name + ; + +create_type + : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? TYPE (type_definition | type_body) + ; + +// Create Type Specific Clauses + +type_definition + : type_name (OID CHAR_STRING)? FORCE? object_type_def? + ; + +object_type_def + : invoker_rights_clause? (object_as_part | object_under_part) sqlj_object_type? ( + '(' object_member_spec (',' object_member_spec)* ')' + )? modifier_clause* + ; + +object_as_part + : (IS | AS) (OBJECT | varray_type_def | nested_table_type_def) + ; + +object_under_part + : UNDER type_spec + ; + +nested_table_type_def + : TABLE OF type_spec (NOT NULL_)? + ; + +sqlj_object_type + : EXTERNAL NAME expression LANGUAGE JAVA USING (SQLDATA | CUSTOMDATUM | ORADATA) + ; + +type_body + : BODY type_name (IS | AS) (type_body_elements)+ END + ; + +type_body_elements + : map_order_func_declaration + | subprog_decl_in_type + | overriding_subprogram_spec + ; + +map_order_func_declaration + : (MAP | ORDER) MEMBER func_decl_in_type + ; + +subprog_decl_in_type + : (MEMBER | STATIC)? (proc_decl_in_type | func_decl_in_type | constructor_declaration) + ; + +proc_decl_in_type + : PROCEDURE procedure_name + ( + '(' type_elements_parameter (',' type_elements_parameter)* ')' + )? + (IS | AS) (call_spec | DECLARE? seq_of_declare_specs? body ';') + ; + +func_decl_in_type + : FUNCTION function_name ('(' type_elements_parameter (',' type_elements_parameter)* ')')? RETURN type_spec ( + IS + | AS + ) (call_spec | DECLARE? seq_of_declare_specs? body ';') + ; + +constructor_declaration + : FINAL? INSTANTIABLE? CONSTRUCTOR FUNCTION 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 + : {p.isVersion12()}? AUDIT ( + POLICY policy_name ((BY | EXCEPT) audit_user (',' audit_user)*)? (WHENEVER NOT? SUCCESSFUL)? + | CONTEXT NAMESPACE oracle_namespace ATTRIBUTES attribute_name (',' attribute_name)* ( + BY audit_user (',' audit_user)* + )? + ) + ; + +policy_name + : identifier + ; + +// https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4007.htm#SQLRF01107 +// https://docs.oracle.com/database/121/SQLRF/statements_4007.htm#SQLRF01107 + +audit_traditional + : AUDIT ( + audit_operation_clause (auditing_by_clause | IN SESSION CURRENT)? + | audit_schema_object_clause + | NETWORK + | audit_direct_path + ) (BY (SESSION | ACCESS))? (WHENEVER NOT? SUCCESSFUL)? audit_container_clause? + ; + +audit_direct_path + : {p.isVersion12()}? DIRECT_PATH auditing_by_clause + ; + +audit_container_clause + : {p.isVersion12()}? (CONTAINER EQUALS_OP (CURRENT | ALL)) + ; + +audit_operation_clause + : ( + (sql_statement_shortcut | ALL STATEMENTS?) (',' (sql_statement_shortcut | ALL STATEMENTS?))* + | (system_privilege | ALL PRIVILEGES) (',' (system_privilege | ALL PRIVILEGES))* + ) + ; + +auditing_by_clause + : BY audit_user (',' audit_user)* + ; + +audit_user + : regular_id + ; + +audit_schema_object_clause + : (sql_operation (',' sql_operation)* | ALL) auditing_on_clause + ; + +sql_operation + : ALTER + | AUDIT + | COMMENT + | DELETE + | EXECUTE + | FLASHBACK + | GRANT + | INDEX + | INSERT + | LOCK + | READ + | RENAME + | SELECT + | UPDATE + ; + +auditing_on_clause + : ON ( + object_name + | DIRECTORY regular_id + | MINING MODEL model_name + | {p.isVersion12()}? SQL TRANSLATION PROFILE profile_name + | DEFAULT + ) + ; + +model_name + : (id_expression '.')? id_expression + ; + +object_name + : (id_expression '.')? id_expression + ; + +profile_name + : (id_expression '.')? id_expression + ; + +sql_statement_shortcut + : ALTER SYSTEM + | CLUSTER + | CONTEXT + | DATABASE LINK + | DIMENSION + | DIRECTORY + | INDEX + | MATERIALIZED VIEW + | NOT EXISTS + | OUTLINE + | {p.isVersion12()}? PLUGGABLE DATABASE + | PROCEDURE + | PROFILE + | PUBLIC DATABASE LINK + | PUBLIC SYNONYM + | ROLE + | ROLLBACK SEGMENT + | SEQUENCE + | SESSION + | SYNONYM + | SYSTEM AUDIT + | SYSTEM GRANT + | TABLE + | TABLESPACE + | TRIGGER + | TYPE + | USER + | VIEW + | ALTER SEQUENCE + | ALTER TABLE + | COMMENT TABLE + | DELETE TABLE + | EXECUTE PROCEDURE + | GRANT DIRECTORY + | GRANT PROCEDURE + | GRANT SEQUENCE + | GRANT TABLE + | GRANT TYPE + | INSERT TABLE + | LOCK TABLE + | SELECT SEQUENCE + | SELECT TABLE + | UPDATE TABLE + ; + +drop_index + : DROP INDEX index_name (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 + : {p.isVersion12()}? (EDITIONABLE | NONEDITIONABLE) + ; + +library_debug + : {p.isVersion12()}? DEBUG + ; + +compiler_parameters_clause + : parameter_name EQUALS_OP parameter_value + ; + +parameter_value + : regular_id + | CHAR_STRING + ; + +library_name + : (regular_id '.')? regular_id + ; + +alter_dimension + : ALTER DIMENSION identifier ( + (ADD (level_clause | hierarchy_clause | attribute_clause | extended_attribute_clause))+ + | ( + DROP ( + LEVEL identifier (RESTRICT | CASCADE)? + | HIERARCHY identifier + | ATTRIBUTE identifier ( + LEVEL identifier (COLUMN column_name (',' COLUMN column_name)*)? + )? + ) + )+ + | COMPILE + ) + ; + +level_clause + : LEVEL identifier IS ( + table_name '.' column_name + | '(' table_name '.' column_name (',' table_name '.' column_name)* ')' + ) (SKIP_ WHEN NULL_)? + ; + +hierarchy_clause + : HIERARCHY identifier '(' identifier (CHILD OF identifier)+ dimension_join_clause? ')' + ; + +dimension_join_clause + : (JOIN KEY column_one_or_more_sub_clause REFERENCES identifier)+ + ; + +attribute_clause + : (ATTRIBUTE identifier DETERMINES column_one_or_more_sub_clause)+ + ; + +extended_attribute_clause + : ATTRIBUTE identifier (LEVEL identifier DETERMINES column_one_or_more_sub_clause)+ + ; + +column_one_or_more_sub_clause + : column_name + | '(' column_name (',' column_name)* ')' + ; + +// https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4004.htm#SQLRF01104 +// https://docs.oracle.com/database/121/SQLRF/statements_4004.htm#SQLRF01104 +alter_view + : ALTER VIEW tableview_name ( + ADD out_of_line_constraint + | MODIFY CONSTRAINT constraint_name (RELY | NORELY) + | DROP ( + CONSTRAINT constraint_name + | PRIMARY KEY + | UNIQUE '(' column_name (',' column_name)* ')' + ) + | COMPILE + | READ (ONLY | WRITE) + | alter_view_editionable? + ) + ; + +alter_view_editionable + : {p.isVersion12()}? (EDITIONABLE | NONEDITIONABLE) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-VIEW.html +create_view + : CREATE (OR REPLACE)? (NO? FORCE)? editioning_clause? VIEW (schema_name '.')? v = id_expression ( + 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 DELIMITED_ID (allow_or_disallow NONSCHEMA)? ( + allow_or_disallow ANYSCHEMA + )? + ; + +object_table + : OF (schema_name '.')? object_type object_table_substitution? ( + '(' object_properties (',' object_properties)* ')' + )? (ON COMMIT (DELETE | PRESERVE) ROWS)? oid_clause? oid_index_clause? physical_properties? table_properties? + ; + +object_type + : regular_id + ; + +oid_index_clause + : OIDINDEX index_name? '(' (physical_attributes_clause | TABLESPACE tablespace)+ ')' + ; + +oid_clause + : OBJECT IDENTIFIER IS (SYSTEM GENERATED | PRIMARY KEY) + ; + +object_properties + : (column_name | attribute_name) (DEFAULT expression)? ( + inline_constraint (',' inline_constraint)* + | inline_ref_constraint + )? + | out_of_line_constraint + | out_of_line_ref_constraint + | supplemental_logging_props + ; + +object_table_substitution + : NOT? SUBSTITUTABLE AT ALL LEVELS + ; + +relational_table + : ('(' relational_property (',' relational_property)* ')')? 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 + : {p.isVersion10()}? STANDBY ( + TABLESPACE tablespace (',' tablespace)* + | DATAFILE CHAR_STRING + | filenumber (',' CHAR_STRING | filenumber)* + ) UNTIL (CONSISTENT WITH)? CONTROLFILE + ; + +managed_standby_recovery + : RECOVER ( + MANAGED STANDBY DATABASE ( + ( + USING CURRENT LOGFILE + | DISCONNECT (FROM SESSION)? + | NODELAY + | UNTIL CHANGE UNSIGNED_INTEGER + | UNTIL CONSISTENT + | parallel_clause + )+ + | FINISH + | CANCEL + )? + | TO LOGICAL STANDBY (db_name | KEEP IDENTITY) + ) + ; + +db_name + : regular_id + ; + +database_file_clauses + : RENAME FILE filename (',' filename)* TO filename + | create_datafile_clause + | alter_datafile_clause + | alter_tempfile_clause + | move_datafile_clause + ; + +create_datafile_clause + : CREATE DATAFILE (filename | filenumber) (',' (filename | filenumber))* ( + AS ( + //TODO (','? file_specification)+ | + NEW + ) + )? + ; + +alter_datafile_clause + : DATAFILE (filename | filenumber) (',' (filename | filenumber))* ( + ONLINE + | OFFLINE (FOR DROP)? + | RESIZE size_clause + | autoextend_clause + | END BACKUP + ) + ; + +alter_tempfile_clause + : TEMPFILE (filename | filenumber) (',' (filename | filenumber))* ( + RESIZE size_clause + | autoextend_clause + | DROP (INCLUDING DATAFILES) + | ONLINE + | OFFLINE + ) + ; + +move_datafile_clause + : MOVE DATAFILE (filename | filenumber) (',' (filename | filenumber))* (TO filename)? REUSE? KEEP? + ; + +logfile_clauses + : (ARCHIVELOG MANUAL? | NOARCHIVELOG) + | NO? FORCE LOGGING + | SET STANDBY NOLOGGING FOR (DATA AVAILABILITY | LOAD PERFORMANCE) + | RENAME FILE filename (',' filename)* TO filename + | CLEAR UNARCHIVED? LOGFILE logfile_descriptor (',' logfile_descriptor)* ( + UNRECOVERABLE DATAFILE + )? + | add_logfile_clauses + | drop_logfile_clauses + | switch_logfile_clause + | supplemental_db_logging + ; + +add_logfile_clauses + : ADD STANDBY? LOGFILE ( + (INSTANCE CHAR_STRING | THREAD UNSIGNED_INTEGER)? group_redo_logfile+ + | MEMBER filename REUSE? (',' filename REUSE?)* TO logfile_descriptor ( + ',' logfile_descriptor + )* + ) + ; + +group_redo_logfile + : (GROUP UNSIGNED_INTEGER)? redo_log_file_spec + ; + +drop_logfile_clauses + : DROP STANDBY? LOGFILE ( + logfile_descriptor (',' logfile_descriptor)* + | MEMBER filename (',' filename)* + ) + ; + +switch_logfile_clause + : SWITCH ALL LOGFILES TO BLOCKSIZE UNSIGNED_INTEGER + ; + +supplemental_db_logging + : add_or_drop SUPPLEMENTAL LOG (DATA | supplemental_id_key_clause | supplemental_plsql_clause) + ; + +add_or_drop + : ADD + | DROP + ; + +supplemental_plsql_clause + : DATA FOR PROCEDURAL REPLICATION + ; + +logfile_descriptor + : GROUP UNSIGNED_INTEGER + | '(' filename (',' filename)* ')' + | filename + ; + +controlfile_clauses + : CREATE (LOGICAL | PHYSICAL)? STANDBY CONTROLFILE AS filename REUSE? + | BACKUP CONTROLFILE TO (filename REUSE? | trace_file_clause) + ; + +trace_file_clause + : TRACE (AS filename REUSE?)? (RESETLOGS | NORESETLOGS)? + ; + +standby_database_clauses + : ( + activate_standby_db_clause + | maximize_standby_db_clause + | register_logfile_clause + | commit_switchover_clause + | start_standby_clause + | stop_standby_clause + | convert_database_clause + ) parallel_clause? + ; + +activate_standby_db_clause + : ACTIVATE (PHYSICAL | LOGICAL)? STANDBY DATABASE (FINISH APPLY)? + ; + +maximize_standby_db_clause + : SET STANDBY DATABASE TO MAXIMIZE (PROTECTION | AVAILABILITY | PERFORMANCE) + ; + +register_logfile_clause + : REGISTER (OR REPLACE)? (PHYSICAL | LOGICAL) LOGFILE //TODO (','? file_specification)+ + //TODO (FOR logminer_session_name)? + ; + +commit_switchover_clause + : (PREPARE | COMMIT) TO SWITCHOVER ( + ( + TO ( + ((PHYSICAL | LOGICAL)? PRIMARY | PHYSICAL? STANDBY) ( + (WITH | WITHOUT)? SESSION SHUTDOWN (WAIT | NOWAIT) + )? + | LOGICAL STANDBY + ) + | LOGICAL STANDBY + ) + | CANCEL + )? + ; + +start_standby_clause + : START LOGICAL STANDBY APPLY IMMEDIATE? NODELAY? ( + NEW PRIMARY regular_id + | INITIAL scn_value = UNSIGNED_INTEGER? + | SKIP_ FAILED TRANSACTION + | FINISH + )? + ; + +stop_standby_clause + : (STOP | ABORT) LOGICAL STANDBY APPLY + ; + +convert_database_clause + : CONVERT TO (PHYSICAL | SNAPSHOT) STANDBY + ; + +default_settings_clause + : DEFAULT EDITION EQUALS_OP edition_name + | SET DEFAULT (BIGFILE | SMALLFILE) TABLESPACE + | DEFAULT TABLESPACE tablespace + | DEFAULT TEMPORARY TABLESPACE (tablespace | tablespace_group_name) + | RENAME GLOBAL_NAME TO database ('.' domain)+ + | ENABLE BLOCK CHANGE TRACKING (USING FILE filename REUSE?)? + | DISABLE BLOCK CHANGE TRACKING + | flashback_mode_clause + | set_time_zone_clause + ; + +set_time_zone_clause + : SET TIMEZONE EQUALS_OP CHAR_STRING + ; + +instance_clauses + : enable_or_disable INSTANCE CHAR_STRING + ; + +security_clause + : GUARD (ALL | STANDBY | NONE) + ; + +domain + : 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_properties + | constraint_clauses + | column_clauses + | alter_table_partitioning + //TODO | alter_external_table + | move_table_clause + ) ((enable_disable_clause | enable_or_disable (TABLE LOCK | ALL TRIGGERS))+)? + ; + +memoptimize_read_write_clause + : NO? MEMOPTIMIZE FOR (READ | WRITE) + ; + +alter_table_properties + : alter_table_properties_1 + | RENAME TO tableview_name + | shrink_clause + | READ ONLY + | READ WRITE + | REKEY CHAR_STRING + | 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? + | range_partitions + ) + ; + +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 + | 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? + ; + +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)? (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 + | CHUNK UNSIGNED_INTEGER + | PCTVERSION UNSIGNED_INTEGER + | FREEPOOLS UNSIGNED_INTEGER + | lob_retention_clause + | lob_deduplicate_clause + | lob_compression_clause + | ENCRYPT encryption_spec + | DECRYPT + | (CACHE | NOCACHE | CACHE READS) logging_clause? + )+ + ; + +lob_deduplicate_clause + : DEDUPLICATE + | KEEP_DUPLICATES + ; + +lob_compression_clause + : NOCOMPRESS + | COMPRESS (HIGH | MEDIUM | LOW)? + ; + +lob_retention_clause + : RETENTION (MAX | MIN UNSIGNED_INTEGER | AUTO | NONE)? + ; + +encryption_spec + : (USING CHAR_STRING)? (IDENTIFIED BY REGULAR_ID)? CHAR_STRING? (NO? SALT)? + ; + +tablespace + : id_expression + ; + +varray_item + : (id_expression '.')? (id_expression '.')? id_expression + ; + +column_properties + : ( + object_type_col_properties + | nested_table_col_properties + | (varray_col_properties | lob_storage_clause) ( + '(' lob_partition_storage (',' lob_partition_storage)* ')' + )? //TODO '(' ( ','? lob_partition_storage)+ ')' + | xmltype_column_properties + )+ + ; + +lob_partition_storage + : LOB ( + '(' lob_item (',' lob_item) ')' STORE AS ( + (SECUREFILE | BASICFILE) + | '(' lob_storage_parameters ')' + )+ + | '(' lob_item ')' STORE AS ( + (SECUREFILE | BASICFILE) + | lob_segname + | '(' lob_storage_parameters ')' + )+ + ) + ; + +period_definition + : {p.isVersion12()}? PERIOD FOR column_name ('(' start_time_column ',' end_time_column ')')? + ; + +start_time_column + : column_name + ; + +end_time_column + : column_name + ; + +column_definition + : column_name ((datatype | 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 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 + : with_clause? 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 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 + : subquery_basic_elements subquery_operation_part* + ; + +subquery_basic_elements + : query_block + | '(' subquery ')' + ; + +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* ({p.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_ ')' | 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 + | {p.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 + | {p.IsNotNumericFunction()}? atom + | implicit_cursor_expression + ; + +// 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* + | '(' 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 + | {p.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 TIMEZONE)? + | SDO_GEOMETRY + | expression (USING CASESENSITIVE MAPPING)? + ; + +json_value_on_mismatch_clause + : (IGNORE | ERROR | NULL_) ON MISMATCH ('(' MISSING DATA | EXTRA DATA | TYPE ERROR ')')? + ; + +literal + : CHAR_STRING + | string_function + | numeric + | 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 + ; + +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? ( + 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 , or rename to . +// Both are valid for sequences, tables, views, etc. +schema_object_name + : id_expression + ; + +dir_object_name + : id_expression + ; + +user_object_name + : id_expression + ; + +grant_object_name + : tableview_name + | USER user_object_name (',' user_object_name)* + | DIRECTORY dir_object_name + | EDITION schema_object_name + | MINING MODEL schema_object_name + | JAVA (SOURCE | RESOURCE) schema_object_name + | SQL TRANSLATION PROFILE schema_object_name + ; + +column_list + : column_name (',' column_name)* + ; + +paren_column_list + : LEFT_PAREN column_list RIGHT_PAREN + ; + +// PL/SQL Specs + +// NOTE: In reality this applies to aggregate functions only +keep_clause + : KEEP '(' DENSE_RANK (FIRST | LAST) (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 + ; + +// $> + +// $' +'<' +':' +';' +'|' +'=' +'[' +']' +'_' +null +null +null +null +null +null +null + +token symbolic names: +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 +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 +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 + +rule names: +sql_script +unit_statement +alter_diskgroup +add_disk_clause +drop_disk_clause +resize_disk_clause +replace_disk_clause +wait_nowait +rename_disk_clause +disk_online_clause +disk_offline_clause +timeout_clause +rebalance_diskgroup_clause +phase +check_diskgroup_clause +diskgroup_template_clauses +qualified_template_clause +redundancy_clause +striping_clause +force_noforce +diskgroup_directory_clauses +dir_name +diskgroup_alias_clauses +diskgroup_volume_clauses +add_volume_clause +modify_volume_clause +diskgroup_attributes +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_collection_clauses +dependent_handling_clause +dependent_exceptions_part +create_type +type_definition +object_type_def +object_as_part +object_under_part +nested_table_type_def +sqlj_object_type +type_body +type_body_elements +map_order_func_declaration +subprog_decl_in_type +proc_decl_in_type +func_decl_in_type +constructor_declaration +modifier_clause +object_member_spec +sqlj_object_type_attr +element_spec +element_spec_options +subprogram_spec +overriding_subprogram_spec +overriding_function_spec +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 +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 +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_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 +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 +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 + + +atn: +[4, 1, 2482, 21417, 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, 1, 0, 1, 0, 3, 0, 2421, 8, 0, 5, 0, 2423, 8, 0, 10, 0, 12, 0, 2426, 9, 0, 1, 0, 1, 0, 3, 0, 2430, 8, 0, 1, 0, 1, 0, 3, 0, 2434, 8, 0, 1, 0, 1, 0, 3, 0, 2438, 8, 0, 5, 0, 2440, 8, 0, 10, 0, 12, 0, 2443, 9, 0, 1, 0, 3, 0, 2446, 8, 0, 1, 0, 3, 0, 2449, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2594, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 2, 2601, 8, 2, 11, 2, 12, 2, 2602, 1, 2, 3, 2, 2606, 8, 2, 1, 2, 3, 2, 2609, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2631, 8, 2, 3, 2, 2633, 8, 2, 1, 2, 1, 2, 1, 2, 5, 2, 2638, 8, 2, 10, 2, 12, 2, 2641, 9, 2, 1, 2, 3, 2, 2644, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2649, 8, 2, 3, 2, 2651, 8, 2, 1, 3, 1, 3, 1, 3, 3, 3, 2656, 8, 3, 1, 3, 3, 3, 2659, 8, 3, 1, 3, 1, 3, 3, 3, 2663, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 2669, 8, 3, 10, 3, 12, 3, 2672, 9, 3, 4, 3, 2674, 8, 3, 11, 3, 12, 3, 2675, 1, 4, 1, 4, 3, 4, 2680, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2685, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2690, 8, 4, 5, 4, 2692, 8, 4, 10, 4, 12, 4, 2695, 9, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2700, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2705, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2710, 8, 4, 5, 4, 2712, 8, 4, 10, 4, 12, 4, 2715, 9, 4, 3, 4, 2717, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 2723, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 2731, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 2738, 8, 6, 5, 6, 2740, 8, 6, 10, 6, 12, 6, 2743, 9, 6, 1, 6, 1, 6, 3, 6, 2747, 8, 6, 1, 6, 3, 6, 2750, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 5, 8, 2764, 8, 8, 10, 8, 12, 8, 2767, 9, 8, 1, 8, 1, 8, 3, 8, 2771, 8, 8, 1, 9, 1, 9, 3, 9, 2775, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 2781, 8, 9, 10, 9, 12, 9, 2784, 9, 9, 1, 9, 1, 9, 1, 9, 3, 9, 2789, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 2795, 8, 9, 10, 9, 12, 9, 2798, 9, 9, 4, 9, 2800, 8, 9, 11, 9, 12, 9, 2801, 1, 9, 3, 9, 2805, 8, 9, 1, 9, 1, 9, 3, 9, 2809, 8, 9, 1, 9, 3, 9, 2812, 8, 9, 1, 10, 1, 10, 3, 10, 2816, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 2822, 8, 10, 10, 10, 12, 10, 2825, 9, 10, 1, 10, 1, 10, 1, 10, 3, 10, 2830, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 2836, 8, 10, 10, 10, 12, 10, 2839, 9, 10, 3, 10, 2841, 8, 10, 1, 10, 3, 10, 2844, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 4, 12, 2854, 8, 12, 11, 12, 12, 12, 2855, 3, 12, 2858, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2864, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2869, 8, 12, 3, 12, 2871, 8, 12, 1, 13, 1, 13, 1, 14, 1, 14, 3, 14, 2877, 8, 14, 1, 14, 3, 14, 2880, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 2890, 8, 15, 10, 15, 12, 15, 2893, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 2900, 8, 15, 10, 15, 12, 15, 2903, 9, 15, 3, 15, 2905, 8, 15, 1, 16, 1, 16, 1, 16, 3, 16, 2910, 8, 16, 1, 16, 3, 16, 2913, 8, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2928, 8, 20, 10, 20, 12, 20, 2931, 9, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2937, 8, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2942, 8, 20, 5, 20, 2944, 8, 20, 10, 20, 12, 20, 2947, 9, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2959, 8, 20, 10, 20, 12, 20, 2962, 9, 20, 3, 20, 2964, 8, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2977, 8, 22, 10, 22, 12, 22, 2980, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2987, 8, 22, 10, 22, 12, 22, 2990, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 3001, 8, 22, 10, 22, 12, 22, 3004, 9, 22, 3, 22, 3006, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 3019, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 3027, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 3033, 8, 24, 1, 24, 1, 24, 3, 24, 3037, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 3044, 8, 25, 1, 25, 1, 25, 3, 25, 3048, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 3061, 8, 27, 10, 27, 12, 27, 3064, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 3079, 8, 29, 10, 29, 12, 29, 3082, 9, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 3092, 8, 29, 10, 29, 12, 29, 3095, 9, 29, 1, 29, 1, 29, 1, 29, 3, 29, 3100, 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3107, 8, 30, 10, 30, 12, 30, 3110, 9, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3117, 8, 30, 10, 30, 12, 30, 3120, 9, 30, 1, 30, 3, 30, 3123, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3134, 8, 30, 10, 30, 12, 30, 3137, 9, 30, 3, 30, 3139, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 3148, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 3156, 8, 31, 5, 31, 3158, 8, 31, 10, 31, 12, 31, 3161, 9, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 3168, 8, 31, 10, 31, 12, 31, 3171, 9, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 3182, 8, 32, 10, 32, 12, 32, 3185, 9, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 3192, 8, 32, 10, 32, 12, 32, 3195, 9, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3202, 8, 33, 1, 33, 3, 33, 3205, 8, 33, 1, 33, 1, 33, 3, 33, 3209, 8, 33, 1, 33, 3, 33, 3212, 8, 33, 1, 33, 3, 33, 3215, 8, 33, 1, 33, 3, 33, 3218, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3228, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3247, 8, 34, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 3257, 8, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 3265, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 3270, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 3276, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 3297, 8, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 3306, 8, 44, 1, 44, 3, 44, 3309, 8, 44, 1, 44, 1, 44, 3, 44, 3313, 8, 44, 3, 44, 3315, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 3322, 8, 45, 10, 45, 12, 45, 3325, 9, 45, 1, 45, 3, 45, 3328, 8, 45, 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, 3, 47, 3344, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 3358, 8, 47, 3, 47, 3360, 8, 47, 1, 47, 3, 47, 3363, 8, 47, 1, 47, 1, 47, 3, 47, 3367, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 3374, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 3381, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 3, 49, 3390, 8, 49, 1, 49, 5, 49, 3393, 8, 49, 10, 49, 12, 49, 3396, 9, 49, 1, 49, 1, 49, 3, 49, 3400, 8, 49, 3, 49, 3402, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3410, 8, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3418, 8, 50, 1, 50, 1, 50, 3, 50, 3422, 8, 50, 1, 50, 1, 50, 4, 50, 3426, 8, 50, 11, 50, 12, 50, 3427, 1, 50, 1, 50, 3, 50, 3432, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3437, 8, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 3, 52, 3444, 8, 52, 1, 52, 3, 52, 3447, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 5, 52, 3455, 8, 52, 10, 52, 12, 52, 3458, 9, 52, 1, 52, 1, 52, 3, 52, 3462, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 3469, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 5, 52, 3478, 8, 52, 10, 52, 12, 52, 3481, 9, 52, 1, 52, 1, 52, 3, 52, 3485, 8, 52, 1, 52, 3, 52, 3488, 8, 52, 1, 52, 1, 52, 3, 52, 3492, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 3497, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 3, 54, 3509, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 3518, 8, 55, 1, 55, 3, 55, 3521, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, 3, 56, 3527, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 3533, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 3541, 8, 57, 10, 57, 12, 57, 3544, 9, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 3, 60, 3559, 8, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 3572, 8, 62, 10, 62, 12, 62, 3575, 9, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 3, 64, 3587, 8, 64, 1, 64, 1, 64, 4, 64, 3591, 8, 64, 11, 64, 12, 64, 3592, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 3605, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 3614, 8, 66, 1, 66, 1, 66, 1, 66, 3, 66, 3619, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 3635, 8, 67, 3, 67, 3637, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 3653, 8, 68, 3, 68, 3655, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 3676, 8, 69, 3, 69, 3678, 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, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 3698, 8, 70, 3, 70, 3700, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 4, 71, 3713, 8, 71, 11, 71, 12, 71, 3714, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 3724, 8, 71, 3, 71, 3726, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 3737, 8, 72, 1, 73, 1, 73, 1, 73, 5, 73, 3742, 8, 73, 10, 73, 12, 73, 3745, 9, 73, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 3757, 8, 76, 1, 76, 1, 76, 1, 76, 3, 76, 3762, 8, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3771, 8, 77, 1, 77, 3, 77, 3774, 8, 77, 1, 77, 5, 77, 3777, 8, 77, 10, 77, 12, 77, 3780, 9, 77, 1, 77, 1, 77, 3, 77, 3784, 8, 77, 1, 78, 1, 78, 1, 78, 3, 78, 3789, 8, 78, 1, 78, 3, 78, 3792, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3798, 8, 78, 1, 78, 1, 78, 3, 78, 3802, 8, 78, 1, 78, 1, 78, 5, 78, 3806, 8, 78, 10, 78, 12, 78, 3809, 9, 78, 1, 78, 1, 78, 3, 78, 3813, 8, 78, 1, 79, 1, 79, 1, 79, 3, 79, 3818, 8, 79, 1, 79, 3, 79, 3821, 8, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 3828, 8, 79, 1, 79, 1, 79, 1, 79, 5, 79, 3833, 8, 79, 10, 79, 12, 79, 3836, 9, 79, 1, 79, 1, 79, 1, 79, 1, 79, 4, 79, 3842, 8, 79, 11, 79, 12, 79, 3843, 3, 79, 3846, 8, 79, 3, 79, 3848, 8, 79, 1, 79, 1, 79, 3, 79, 3852, 8, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 3862, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 5, 81, 3870, 8, 81, 10, 81, 12, 81, 3873, 9, 81, 1, 81, 1, 81, 3, 81, 3877, 8, 81, 1, 81, 1, 81, 1, 81, 5, 81, 3882, 8, 81, 10, 81, 12, 81, 3885, 9, 81, 1, 81, 1, 81, 3, 81, 3889, 8, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 3899, 8, 82, 10, 82, 12, 82, 3902, 9, 82, 1, 82, 1, 82, 3, 82, 3906, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 3915, 8, 82, 10, 82, 12, 82, 3918, 9, 82, 1, 82, 1, 82, 3, 82, 3922, 8, 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, 3, 83, 3937, 8, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 3949, 8, 84, 1, 84, 1, 84, 3, 84, 3953, 8, 84, 1, 84, 3, 84, 3956, 8, 84, 1, 84, 3, 84, 3959, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 3966, 8, 85, 1, 85, 1, 85, 3, 85, 3970, 8, 85, 1, 85, 3, 85, 3973, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 3984, 8, 87, 1, 87, 5, 87, 3987, 8, 87, 10, 87, 12, 87, 3990, 9, 87, 1, 87, 1, 87, 3, 87, 3994, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 4002, 8, 88, 10, 88, 12, 88, 4005, 9, 88, 1, 88, 1, 88, 3, 88, 4009, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 4019, 8, 88, 10, 88, 12, 88, 4022, 9, 88, 1, 88, 1, 88, 3, 88, 4026, 8, 88, 1, 88, 3, 88, 4029, 8, 88, 1, 88, 1, 88, 3, 88, 4033, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 4038, 8, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 5, 89, 4048, 8, 89, 10, 89, 12, 89, 4051, 9, 89, 1, 89, 1, 89, 3, 89, 4055, 8, 89, 1, 89, 1, 89, 1, 89, 5, 89, 4060, 8, 89, 10, 89, 12, 89, 4063, 9, 89, 1, 89, 1, 89, 3, 89, 4067, 8, 89, 1, 89, 3, 89, 4070, 8, 89, 1, 89, 1, 89, 1, 89, 3, 89, 4075, 8, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 3, 90, 4082, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 4090, 8, 90, 10, 90, 12, 90, 4093, 9, 90, 1, 90, 1, 90, 3, 90, 4097, 8, 90, 1, 90, 3, 90, 4100, 8, 90, 1, 90, 5, 90, 4103, 8, 90, 10, 90, 12, 90, 4106, 9, 90, 1, 90, 1, 90, 3, 90, 4110, 8, 90, 1, 90, 3, 90, 4113, 8, 90, 1, 90, 1, 90, 1, 90, 3, 90, 4118, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 4, 91, 4125, 8, 91, 11, 91, 12, 91, 4126, 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, 3, 93, 4143, 8, 93, 3, 93, 4145, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 4155, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 4, 97, 4171, 8, 97, 11, 97, 12, 97, 4172, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 4180, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 4185, 8, 98, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 4191, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 4199, 8, 100, 10, 100, 12, 100, 4202, 9, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 4217, 8, 102, 1, 102, 5, 102, 4220, 8, 102, 10, 102, 12, 102, 4223, 9, 102, 1, 102, 1, 102, 3, 102, 4227, 8, 102, 3, 102, 4229, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 4234, 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 4241, 8, 103, 1, 103, 3, 103, 4244, 8, 103, 1, 103, 3, 103, 4247, 8, 103, 1, 103, 3, 103, 4250, 8, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 4258, 8, 104, 10, 104, 12, 104, 4261, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 4272, 8, 106, 1, 106, 1, 106, 3, 106, 4276, 8, 106, 1, 106, 3, 106, 4279, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 4288, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 4294, 8, 109, 10, 109, 12, 109, 4297, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 4304, 8, 109, 1, 109, 3, 109, 4307, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 4313, 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 4318, 8, 111, 1, 111, 4, 111, 4321, 8, 111, 11, 111, 12, 111, 4322, 1, 111, 1, 111, 3, 111, 4327, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 4365, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4393, 8, 113, 1, 114, 1, 114, 1, 114, 5, 114, 4398, 8, 114, 10, 114, 12, 114, 4401, 9, 114, 1, 114, 1, 114, 3, 114, 4405, 8, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 3, 115, 4412, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 3, 117, 4422, 8, 117, 1, 117, 5, 117, 4425, 8, 117, 10, 117, 12, 117, 4428, 9, 117, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 3, 119, 4436, 8, 119, 1, 119, 1, 119, 3, 119, 4440, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4451, 8, 120, 1, 120, 3, 120, 4454, 8, 120, 1, 121, 1, 121, 3, 121, 4458, 8, 121, 1, 121, 3, 121, 4461, 8, 121, 1, 121, 5, 121, 4464, 8, 121, 10, 121, 12, 121, 4467, 9, 121, 1, 121, 1, 121, 3, 121, 4471, 8, 121, 1, 122, 1, 122, 3, 122, 4475, 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 5, 122, 4483, 8, 122, 10, 122, 12, 122, 4486, 9, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 4493, 8, 123, 10, 123, 12, 123, 4496, 9, 123, 1, 124, 1, 124, 1, 124, 3, 124, 4501, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4509, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 4517, 8, 126, 1, 126, 1, 126, 1, 126, 3, 126, 4522, 8, 126, 1, 126, 3, 126, 4525, 8, 126, 3, 126, 4527, 8, 126, 1, 127, 3, 127, 4530, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 3, 128, 4539, 8, 128, 1, 128, 3, 128, 4542, 8, 128, 1, 128, 1, 128, 1, 128, 3, 128, 4547, 8, 128, 1, 129, 1, 129, 1, 129, 3, 129, 4552, 8, 129, 1, 129, 3, 129, 4555, 8, 129, 1, 129, 3, 129, 4558, 8, 129, 1, 130, 3, 130, 4561, 8, 130, 1, 130, 1, 130, 3, 130, 4565, 8, 130, 1, 130, 3, 130, 4568, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 4574, 8, 130, 10, 130, 12, 130, 4577, 9, 130, 1, 130, 1, 130, 3, 130, 4581, 8, 130, 1, 130, 5, 130, 4584, 8, 130, 10, 130, 12, 130, 4587, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 4593, 8, 131, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 4603, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 4, 135, 4617, 8, 135, 11, 135, 12, 135, 4618, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 3, 136, 4626, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 3, 138, 4633, 8, 138, 1, 138, 1, 138, 1, 138, 3, 138, 4638, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 5, 139, 4646, 8, 139, 10, 139, 12, 139, 4649, 9, 139, 1, 139, 1, 139, 3, 139, 4653, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 4658, 8, 139, 1, 139, 3, 139, 4661, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 4666, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 4674, 8, 140, 10, 140, 12, 140, 4677, 9, 140, 1, 140, 1, 140, 3, 140, 4681, 8, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4688, 8, 140, 1, 140, 3, 140, 4691, 8, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4696, 8, 140, 1, 141, 3, 141, 4699, 8, 141, 1, 141, 3, 141, 4702, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4714, 8, 141, 1, 141, 1, 141, 1, 141, 5, 141, 4719, 8, 141, 10, 141, 12, 141, 4722, 9, 141, 3, 141, 4724, 8, 141, 1, 141, 3, 141, 4727, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4736, 8, 141, 1, 141, 3, 141, 4739, 8, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4744, 8, 141, 1, 142, 3, 142, 4747, 8, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, 4754, 8, 143, 1, 143, 3, 143, 4757, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 3, 145, 4764, 8, 145, 1, 145, 4, 145, 4767, 8, 145, 11, 145, 12, 145, 4768, 1, 145, 1, 145, 3, 145, 4773, 8, 145, 1, 146, 1, 146, 1, 146, 3, 146, 4778, 8, 146, 1, 147, 1, 147, 1, 147, 3, 147, 4783, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 4791, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 5, 149, 4799, 8, 149, 10, 149, 12, 149, 4802, 9, 149, 1, 149, 1, 149, 3, 149, 4806, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 4813, 8, 149, 1, 149, 3, 149, 4816, 8, 149, 1, 149, 1, 149, 3, 149, 4820, 8, 149, 1, 149, 3, 149, 4823, 8, 149, 1, 149, 3, 149, 4826, 8, 149, 1, 149, 3, 149, 4829, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 4837, 8, 150, 10, 150, 12, 150, 4840, 9, 150, 1, 150, 1, 150, 3, 150, 4844, 8, 150, 1, 150, 1, 150, 1, 150, 3, 150, 4849, 8, 150, 1, 150, 3, 150, 4852, 8, 150, 1, 150, 1, 150, 1, 150, 3, 150, 4857, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 4865, 8, 151, 10, 151, 12, 151, 4868, 9, 151, 1, 151, 1, 151, 3, 151, 4872, 8, 151, 1, 151, 1, 151, 3, 151, 4876, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 4884, 8, 152, 10, 152, 12, 152, 4887, 9, 152, 1, 152, 1, 152, 3, 152, 4891, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 4898, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 4904, 8, 152, 1, 152, 1, 152, 3, 152, 4908, 8, 152, 1, 153, 3, 153, 4911, 8, 153, 1, 153, 3, 153, 4914, 8, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 4926, 8, 153, 1, 153, 1, 153, 1, 153, 5, 153, 4931, 8, 153, 10, 153, 12, 153, 4934, 9, 153, 3, 153, 4936, 8, 153, 1, 153, 3, 153, 4939, 8, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 4947, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 4959, 8, 155, 10, 155, 12, 155, 4962, 9, 155, 1, 155, 1, 155, 1, 156, 1, 156, 3, 156, 4968, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 4980, 8, 157, 1, 157, 1, 157, 1, 157, 3, 157, 4985, 8, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 4, 159, 4995, 8, 159, 11, 159, 12, 159, 4996, 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, 3, 160, 5017, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 5024, 8, 160, 3, 160, 5026, 8, 160, 1, 160, 1, 160, 3, 160, 5030, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, 4, 161, 5036, 8, 161, 11, 161, 12, 161, 5037, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 5049, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 5060, 8, 161, 3, 161, 5062, 8, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 5069, 8, 162, 1, 162, 1, 162, 5, 162, 5073, 8, 162, 10, 162, 12, 162, 5076, 9, 162, 1, 162, 1, 162, 1, 162, 3, 162, 5081, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 5104, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 5109, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 5114, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 3, 165, 5123, 8, 165, 1, 165, 3, 165, 5126, 8, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 5134, 8, 165, 1, 165, 5, 165, 5137, 8, 165, 10, 165, 12, 165, 5140, 9, 165, 1, 165, 3, 165, 5143, 8, 165, 1, 165, 3, 165, 5146, 8, 165, 1, 165, 3, 165, 5149, 8, 165, 1, 165, 3, 165, 5152, 8, 165, 1, 165, 3, 165, 5155, 8, 165, 1, 165, 3, 165, 5158, 8, 165, 1, 165, 3, 165, 5161, 8, 165, 1, 165, 3, 165, 5164, 8, 165, 1, 166, 1, 166, 3, 166, 5168, 8, 166, 1, 166, 3, 166, 5171, 8, 166, 1, 166, 3, 166, 5174, 8, 166, 1, 166, 5, 166, 5177, 8, 166, 10, 166, 12, 166, 5180, 9, 166, 1, 166, 3, 166, 5183, 8, 166, 1, 166, 3, 166, 5186, 8, 166, 1, 166, 4, 166, 5189, 8, 166, 11, 166, 12, 166, 5190, 3, 166, 5193, 8, 166, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 5205, 8, 169, 1, 169, 1, 169, 3, 169, 5209, 8, 169, 1, 170, 1, 170, 3, 170, 5213, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 5219, 8, 171, 1, 171, 1, 171, 3, 171, 5223, 8, 171, 1, 171, 3, 171, 5226, 8, 171, 1, 171, 3, 171, 5229, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 5237, 8, 172, 10, 172, 12, 172, 5240, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 5246, 8, 173, 10, 173, 12, 173, 5249, 9, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5256, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5263, 8, 173, 1, 173, 5, 173, 5266, 8, 173, 10, 173, 12, 173, 5269, 9, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5276, 8, 173, 1, 173, 3, 173, 5279, 8, 173, 1, 173, 1, 173, 3, 173, 5283, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5293, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 5, 173, 5300, 8, 173, 10, 173, 12, 173, 5303, 9, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 3, 174, 5310, 8, 174, 1, 174, 1, 174, 3, 174, 5314, 8, 174, 1, 174, 3, 174, 5317, 8, 174, 1, 175, 1, 175, 1, 175, 3, 175, 5322, 8, 175, 1, 175, 1, 175, 3, 175, 5326, 8, 175, 1, 175, 3, 175, 5329, 8, 175, 1, 175, 3, 175, 5332, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 5339, 8, 176, 10, 176, 12, 176, 5342, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 3, 177, 5349, 8, 177, 1, 178, 1, 178, 1, 178, 3, 178, 5354, 8, 178, 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, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 5, 183, 5378, 8, 183, 10, 183, 12, 183, 5381, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 5, 184, 5390, 8, 184, 10, 184, 12, 184, 5393, 9, 184, 1, 184, 1, 184, 1, 184, 1, 184, 5, 184, 5399, 8, 184, 10, 184, 12, 184, 5402, 9, 184, 3, 184, 5404, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 5, 185, 5411, 8, 185, 10, 185, 12, 185, 5414, 9, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 5423, 8, 186, 1, 186, 1, 186, 1, 186, 3, 186, 5428, 8, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 5439, 8, 187, 1, 187, 3, 187, 5442, 8, 187, 3, 187, 5444, 8, 187, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 5450, 8, 188, 1, 188, 1, 188, 1, 188, 3, 188, 5455, 8, 188, 1, 188, 5, 188, 5458, 8, 188, 10, 188, 12, 188, 5461, 9, 188, 3, 188, 5463, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 5469, 8, 189, 1, 190, 1, 190, 1, 190, 3, 190, 5474, 8, 190, 1, 190, 3, 190, 5477, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 5484, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 5490, 8, 190, 1, 190, 5, 190, 5493, 8, 190, 10, 190, 12, 190, 5496, 9, 190, 1, 190, 1, 190, 1, 190, 3, 190, 5501, 8, 190, 1, 190, 1, 190, 1, 190, 4, 190, 5506, 8, 190, 11, 190, 12, 190, 5507, 1, 190, 3, 190, 5511, 8, 190, 1, 191, 1, 191, 1, 191, 1, 191, 5, 191, 5517, 8, 191, 10, 191, 12, 191, 5520, 9, 191, 1, 191, 5, 191, 5523, 8, 191, 10, 191, 12, 191, 5526, 9, 191, 1, 192, 1, 192, 1, 192, 3, 192, 5531, 8, 192, 1, 192, 1, 192, 3, 192, 5535, 8, 192, 1, 192, 3, 192, 5538, 8, 192, 1, 192, 3, 192, 5541, 8, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 5, 194, 5552, 8, 194, 10, 194, 12, 194, 5555, 9, 194, 1, 195, 1, 195, 1, 195, 3, 195, 5560, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 5567, 8, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 5, 196, 5576, 8, 196, 10, 196, 12, 196, 5579, 9, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 3, 197, 5586, 8, 197, 1, 197, 1, 197, 3, 197, 5590, 8, 197, 1, 197, 3, 197, 5593, 8, 197, 1, 197, 5, 197, 5596, 8, 197, 10, 197, 12, 197, 5599, 9, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5608, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5613, 8, 198, 1, 198, 5, 198, 5616, 8, 198, 10, 198, 12, 198, 5619, 9, 198, 1, 198, 1, 198, 3, 198, 5623, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5628, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5633, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5638, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5643, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5648, 8, 198, 1, 198, 5, 198, 5651, 8, 198, 10, 198, 12, 198, 5654, 9, 198, 3, 198, 5656, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 5, 198, 5663, 8, 198, 10, 198, 12, 198, 5666, 9, 198, 1, 198, 1, 198, 3, 198, 5670, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 5678, 8, 199, 10, 199, 12, 199, 5681, 9, 199, 1, 199, 1, 199, 3, 199, 5685, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 3, 201, 5692, 8, 201, 1, 201, 1, 201, 3, 201, 5696, 8, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5705, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5712, 8, 202, 1, 202, 1, 202, 3, 202, 5716, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 5723, 8, 203, 1, 203, 3, 203, 5726, 8, 203, 1, 203, 3, 203, 5729, 8, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 5737, 8, 203, 1, 203, 1, 203, 3, 203, 5741, 8, 203, 1, 203, 3, 203, 5744, 8, 203, 1, 204, 1, 204, 1, 204, 1, 204, 5, 204, 5750, 8, 204, 10, 204, 12, 204, 5753, 9, 204, 1, 205, 1, 205, 1, 205, 4, 205, 5758, 8, 205, 11, 205, 12, 205, 5759, 1, 206, 1, 206, 1, 206, 1, 206, 5, 206, 5766, 8, 206, 10, 206, 12, 206, 5769, 9, 206, 1, 207, 1, 207, 1, 207, 1, 207, 5, 207, 5775, 8, 207, 10, 207, 12, 207, 5778, 9, 207, 1, 208, 1, 208, 3, 208, 5782, 8, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 5789, 8, 208, 1, 208, 1, 208, 1, 208, 3, 208, 5794, 8, 208, 1, 208, 3, 208, 5797, 8, 208, 1, 208, 1, 208, 3, 208, 5801, 8, 208, 3, 208, 5803, 8, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 5814, 8, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 5, 211, 5823, 8, 211, 10, 211, 12, 211, 5826, 9, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 5, 211, 5837, 8, 211, 10, 211, 12, 211, 5840, 9, 211, 1, 211, 1, 211, 3, 211, 5844, 8, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 5, 213, 5852, 8, 213, 10, 213, 12, 213, 5855, 9, 213, 1, 214, 1, 214, 1, 214, 3, 214, 5860, 8, 214, 1, 214, 3, 214, 5863, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5868, 8, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 5875, 8, 214, 10, 214, 12, 214, 5878, 9, 214, 3, 214, 5880, 8, 214, 1, 214, 5, 214, 5883, 8, 214, 10, 214, 12, 214, 5886, 9, 214, 1, 214, 3, 214, 5889, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, 215, 5913, 8, 215, 3, 215, 5915, 8, 215, 1, 216, 1, 216, 3, 216, 5919, 8, 216, 1, 216, 3, 216, 5922, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5927, 8, 216, 1, 216, 3, 216, 5930, 8, 216, 1, 216, 5, 216, 5933, 8, 216, 10, 216, 12, 216, 5936, 9, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 3, 218, 5944, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 5955, 8, 219, 1, 219, 3, 219, 5958, 8, 219, 1, 219, 3, 219, 5961, 8, 219, 1, 219, 3, 219, 5964, 8, 219, 1, 219, 1, 219, 3, 219, 5968, 8, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 5974, 8, 219, 10, 219, 12, 219, 5977, 9, 219, 4, 219, 5979, 8, 219, 11, 219, 12, 219, 5980, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 5991, 8, 219, 10, 219, 12, 219, 5994, 9, 219, 3, 219, 5996, 8, 219, 1, 220, 1, 220, 1, 220, 3, 220, 6001, 8, 220, 1, 220, 1, 220, 3, 220, 6005, 8, 220, 1, 220, 3, 220, 6008, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 6017, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 6023, 8, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, 6029, 8, 222, 1, 222, 3, 222, 6032, 8, 222, 1, 222, 1, 222, 3, 222, 6036, 8, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 3, 225, 6051, 8, 225, 1, 225, 3, 225, 6054, 8, 225, 1, 225, 3, 225, 6057, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6063, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6069, 8, 225, 1, 225, 5, 225, 6072, 8, 225, 10, 225, 12, 225, 6075, 9, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6080, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 6086, 8, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 6094, 8, 227, 4, 227, 6096, 8, 227, 11, 227, 12, 227, 6097, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 5, 229, 6110, 8, 229, 10, 229, 12, 229, 6113, 9, 229, 1, 230, 1, 230, 1, 231, 1, 231, 3, 231, 6119, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 6126, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 6132, 8, 231, 1, 231, 3, 231, 6135, 8, 231, 1, 231, 1, 231, 3, 231, 6139, 8, 231, 1, 232, 1, 232, 1, 232, 3, 232, 6144, 8, 232, 1, 233, 1, 233, 1, 233, 3, 233, 6149, 8, 233, 1, 233, 1, 233, 1, 234, 1, 234, 3, 234, 6155, 8, 234, 1, 234, 1, 234, 1, 234, 3, 234, 6160, 8, 234, 1, 234, 1, 234, 1, 234, 3, 234, 6165, 8, 234, 5, 234, 6167, 8, 234, 10, 234, 12, 234, 6170, 9, 234, 1, 234, 1, 234, 3, 234, 6174, 8, 234, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 6180, 8, 235, 1, 235, 1, 235, 3, 235, 6184, 8, 235, 1, 235, 1, 235, 1, 235, 3, 235, 6189, 8, 235, 1, 235, 1, 235, 3, 235, 6193, 8, 235, 5, 235, 6195, 8, 235, 10, 235, 12, 235, 6198, 9, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 6208, 8, 235, 10, 235, 12, 235, 6211, 9, 235, 1, 235, 1, 235, 3, 235, 6215, 8, 235, 1, 235, 3, 235, 6218, 8, 235, 1, 236, 1, 236, 3, 236, 6222, 8, 236, 1, 237, 1, 237, 1, 237, 4, 237, 6227, 8, 237, 11, 237, 12, 237, 6228, 1, 237, 1, 237, 1, 237, 1, 237, 3, 237, 6235, 8, 237, 3, 237, 6237, 8, 237, 1, 238, 1, 238, 3, 238, 6241, 8, 238, 1, 238, 3, 238, 6244, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 6251, 8, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 6262, 8, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 6272, 8, 239, 5, 239, 6274, 8, 239, 10, 239, 12, 239, 6277, 9, 239, 1, 239, 1, 239, 3, 239, 6281, 8, 239, 1, 240, 1, 240, 3, 240, 6285, 8, 240, 1, 240, 1, 240, 3, 240, 6289, 8, 240, 1, 240, 3, 240, 6292, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 6301, 8, 241, 10, 241, 12, 241, 6304, 9, 241, 1, 241, 1, 241, 3, 241, 6308, 8, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, 242, 6318, 8, 242, 10, 242, 12, 242, 6321, 9, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, 242, 6328, 8, 242, 10, 242, 12, 242, 6331, 9, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, 242, 6340, 8, 242, 10, 242, 12, 242, 6343, 9, 242, 1, 242, 1, 242, 1, 242, 3, 242, 6348, 8, 242, 3, 242, 6350, 8, 242, 1, 243, 1, 243, 3, 243, 6354, 8, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 6363, 8, 243, 1, 244, 1, 244, 1, 244, 5, 244, 6368, 8, 244, 10, 244, 12, 244, 6371, 9, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 6378, 8, 244, 10, 244, 12, 244, 6381, 9, 244, 3, 244, 6383, 8, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 6390, 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 6396, 8, 246, 10, 246, 12, 246, 6399, 9, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 5, 247, 6407, 8, 247, 10, 247, 12, 247, 6410, 9, 247, 1, 247, 1, 247, 1, 248, 1, 248, 3, 248, 6416, 8, 248, 1, 248, 1, 248, 5, 248, 6420, 8, 248, 10, 248, 12, 248, 6423, 9, 248, 1, 248, 3, 248, 6426, 8, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 5, 249, 6434, 8, 249, 10, 249, 12, 249, 6437, 9, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 5, 249, 6445, 8, 249, 10, 249, 12, 249, 6448, 9, 249, 1, 249, 1, 249, 3, 249, 6452, 8, 249, 1, 250, 1, 250, 3, 250, 6456, 8, 250, 1, 250, 1, 250, 3, 250, 6460, 8, 250, 1, 250, 3, 250, 6463, 8, 250, 1, 250, 3, 250, 6466, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 6474, 8, 251, 10, 251, 12, 251, 6477, 9, 251, 1, 251, 1, 251, 3, 251, 6481, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 6487, 8, 251, 10, 251, 12, 251, 6490, 9, 251, 1, 251, 1, 251, 1, 252, 1, 252, 3, 252, 6496, 8, 252, 1, 252, 1, 252, 5, 252, 6500, 8, 252, 10, 252, 12, 252, 6503, 9, 252, 1, 252, 3, 252, 6506, 8, 252, 1, 252, 3, 252, 6509, 8, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 6517, 8, 253, 10, 253, 12, 253, 6520, 9, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 6528, 8, 253, 10, 253, 12, 253, 6531, 9, 253, 1, 253, 1, 253, 3, 253, 6535, 8, 253, 1, 254, 1, 254, 3, 254, 6539, 8, 254, 1, 254, 1, 254, 3, 254, 6543, 8, 254, 1, 254, 3, 254, 6546, 8, 254, 1, 254, 3, 254, 6549, 8, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 3, 256, 6556, 8, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 6565, 8, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 4, 258, 6573, 8, 258, 11, 258, 12, 258, 6574, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 6598, 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6611, 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 5, 262, 6625, 8, 262, 10, 262, 12, 262, 6628, 9, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 3, 263, 6638, 8, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 6646, 8, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 6652, 8, 264, 1, 264, 3, 264, 6655, 8, 264, 1, 265, 1, 265, 1, 265, 3, 265, 6660, 8, 265, 1, 265, 1, 265, 3, 265, 6664, 8, 265, 1, 265, 3, 265, 6667, 8, 265, 1, 265, 3, 265, 6670, 8, 265, 1, 266, 1, 266, 1, 266, 3, 266, 6675, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 4, 267, 6681, 8, 267, 11, 267, 12, 267, 6682, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 3, 267, 6695, 8, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 6703, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 6710, 8, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 5, 271, 6727, 8, 271, 10, 271, 12, 271, 6730, 9, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 6740, 8, 271, 1, 271, 3, 271, 6743, 8, 271, 1, 272, 1, 272, 1, 272, 1, 272, 4, 272, 6749, 8, 272, 11, 272, 12, 272, 6750, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 3, 272, 6758, 8, 272, 1, 272, 3, 272, 6761, 8, 272, 3, 272, 6763, 8, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 6770, 8, 273, 1, 274, 1, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 6785, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 6793, 8, 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, 3, 278, 6807, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 4, 278, 6818, 8, 278, 11, 278, 12, 278, 6819, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 4, 279, 6836, 8, 279, 11, 279, 12, 279, 6837, 1, 279, 1, 279, 1, 279, 5, 279, 6843, 8, 279, 10, 279, 12, 279, 6846, 9, 279, 1, 279, 1, 279, 3, 279, 6850, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 6857, 8, 280, 1, 280, 3, 280, 6860, 8, 280, 1, 281, 1, 281, 1, 281, 3, 281, 6865, 8, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 3, 283, 6875, 8, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 3, 285, 6884, 8, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 5, 287, 6895, 8, 287, 10, 287, 12, 287, 6898, 9, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 5, 287, 6905, 8, 287, 10, 287, 12, 287, 6908, 9, 287, 5, 287, 6910, 8, 287, 10, 287, 12, 287, 6913, 9, 287, 3, 287, 6915, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 6921, 8, 288, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 5, 292, 6937, 8, 292, 10, 292, 12, 292, 6940, 9, 292, 3, 292, 6942, 8, 292, 1, 292, 3, 292, 6945, 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6953, 8, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6966, 8, 293, 3, 293, 6968, 8, 293, 1, 293, 1, 293, 3, 293, 6972, 8, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6980, 8, 293, 3, 293, 6982, 8, 293, 3, 293, 6984, 8, 293, 3, 293, 6986, 8, 293, 1, 294, 1, 294, 1, 294, 1, 294, 5, 294, 6992, 8, 294, 10, 294, 12, 294, 6995, 9, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 3, 295, 7005, 8, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 7016, 8, 297, 3, 297, 7018, 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 7027, 8, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 7038, 8, 299, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 7044, 8, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 7051, 8, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 7061, 8, 301, 1, 301, 1, 301, 3, 301, 7065, 8, 301, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 7074, 8, 303, 1, 303, 3, 303, 7077, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, 7083, 8, 304, 1, 304, 3, 304, 7086, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304, 7091, 8, 304, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 7097, 8, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 7105, 8, 305, 1, 306, 1, 306, 1, 306, 1, 306, 3, 306, 7111, 8, 306, 1, 306, 1, 306, 1, 306, 1, 306, 3, 306, 7117, 8, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 7129, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 7137, 8, 307, 1, 308, 3, 308, 7140, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 7151, 8, 308, 1, 308, 1, 308, 3, 308, 7155, 8, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 7166, 8, 309, 1, 309, 1, 309, 3, 309, 7170, 8, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 3, 310, 7181, 8, 310, 1, 311, 1, 311, 3, 311, 7185, 8, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 7191, 8, 311, 1, 311, 3, 311, 7194, 8, 311, 1, 311, 3, 311, 7197, 8, 311, 1, 311, 3, 311, 7200, 8, 311, 1, 311, 3, 311, 7203, 8, 311, 1, 311, 1, 311, 3, 311, 7207, 8, 311, 1, 311, 3, 311, 7210, 8, 311, 1, 312, 1, 312, 3, 312, 7214, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 7220, 8, 312, 1, 312, 3, 312, 7223, 8, 312, 1, 312, 3, 312, 7226, 8, 312, 1, 312, 3, 312, 7229, 8, 312, 1, 312, 3, 312, 7232, 8, 312, 1, 312, 1, 312, 3, 312, 7236, 8, 312, 1, 312, 3, 312, 7239, 8, 312, 1, 313, 1, 313, 1, 314, 1, 314, 1, 315, 1, 315, 3, 315, 7247, 8, 315, 1, 315, 1, 315, 1, 315, 3, 315, 7252, 8, 315, 1, 315, 3, 315, 7255, 8, 315, 1, 315, 1, 315, 3, 315, 7259, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 7267, 8, 316, 1, 316, 1, 316, 3, 316, 7271, 8, 316, 1, 317, 1, 317, 3, 317, 7275, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, 7284, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 5, 317, 7293, 8, 317, 10, 317, 12, 317, 7296, 9, 317, 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, 7302, 8, 317, 3, 317, 7304, 8, 317, 1, 318, 1, 318, 3, 318, 7308, 8, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 7317, 8, 318, 1, 318, 1, 318, 3, 318, 7321, 8, 318, 1, 319, 1, 319, 3, 319, 7325, 8, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 3, 319, 7332, 8, 319, 1, 319, 1, 319, 1, 319, 1, 319, 3, 319, 7338, 8, 319, 1, 320, 1, 320, 3, 320, 7342, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 7349, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 3, 321, 7358, 8, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 3, 321, 7370, 8, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 5, 321, 7382, 8, 321, 10, 321, 12, 321, 7385, 9, 321, 1, 321, 3, 321, 7388, 8, 321, 3, 321, 7390, 8, 321, 1, 321, 3, 321, 7393, 8, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 3, 322, 7400, 8, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 7414, 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 7423, 8, 326, 1, 326, 3, 326, 7426, 8, 326, 1, 326, 3, 326, 7429, 8, 326, 1, 326, 3, 326, 7432, 8, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 7440, 8, 327, 1, 327, 1, 327, 3, 327, 7444, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 7453, 8, 328, 1, 328, 1, 328, 3, 328, 7457, 8, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7472, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 3, 330, 7480, 8, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 3, 331, 7492, 8, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 334, 1, 334, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7509, 8, 336, 1, 336, 3, 336, 7512, 8, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7517, 8, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7523, 8, 336, 1, 336, 1, 336, 3, 336, 7527, 8, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7532, 8, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7538, 8, 336, 1, 336, 1, 336, 3, 336, 7542, 8, 336, 1, 336, 3, 336, 7545, 8, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 5, 337, 7557, 8, 337, 10, 337, 12, 337, 7560, 9, 337, 1, 337, 1, 337, 3, 337, 7564, 8, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 5, 337, 7576, 8, 337, 10, 337, 12, 337, 7579, 9, 337, 1, 337, 1, 337, 3, 337, 7583, 8, 337, 3, 337, 7585, 8, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 7594, 8, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 7602, 8, 338, 1, 338, 3, 338, 7605, 8, 338, 1, 338, 3, 338, 7608, 8, 338, 1, 338, 3, 338, 7611, 8, 338, 1, 338, 3, 338, 7614, 8, 338, 3, 338, 7616, 8, 338, 1, 339, 1, 339, 3, 339, 7620, 8, 339, 1, 339, 1, 339, 3, 339, 7624, 8, 339, 1, 340, 1, 340, 1, 340, 5, 340, 7629, 8, 340, 10, 340, 12, 340, 7632, 9, 340, 1, 340, 1, 340, 3, 340, 7636, 8, 340, 1, 340, 1, 340, 1, 340, 3, 340, 7641, 8, 340, 1, 340, 5, 340, 7644, 8, 340, 10, 340, 12, 340, 7647, 9, 340, 1, 340, 3, 340, 7650, 8, 340, 1, 340, 3, 340, 7653, 8, 340, 1, 340, 1, 340, 1, 340, 3, 340, 7658, 8, 340, 1, 340, 1, 340, 1, 340, 1, 340, 4, 340, 7664, 8, 340, 11, 340, 12, 340, 7665, 1, 340, 5, 340, 7669, 8, 340, 10, 340, 12, 340, 7672, 9, 340, 3, 340, 7674, 8, 340, 1, 341, 1, 341, 1, 342, 1, 342, 3, 342, 7680, 8, 342, 1, 343, 1, 343, 1, 343, 3, 343, 7685, 8, 343, 1, 344, 1, 344, 1, 344, 3, 344, 7690, 8, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7697, 8, 345, 1, 345, 3, 345, 7700, 8, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 5, 346, 7711, 8, 346, 10, 346, 12, 346, 7714, 9, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7722, 8, 347, 10, 347, 12, 347, 7725, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7731, 8, 347, 10, 347, 12, 347, 7734, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7740, 8, 347, 10, 347, 12, 347, 7743, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7749, 8, 347, 10, 347, 12, 347, 7752, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7758, 8, 347, 10, 347, 12, 347, 7761, 9, 347, 3, 347, 7763, 8, 347, 1, 347, 1, 347, 1, 347, 1, 347, 3, 347, 7769, 8, 347, 1, 347, 1, 347, 1, 347, 3, 347, 7774, 8, 347, 3, 347, 7776, 8, 347, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 3, 349, 7783, 8, 349, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 353, 1, 353, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 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, 5, 358, 7823, 8, 358, 10, 358, 12, 358, 7826, 9, 358, 3, 358, 7828, 8, 358, 1, 358, 1, 358, 3, 358, 7832, 8, 358, 1, 358, 3, 358, 7835, 8, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 5, 358, 7844, 8, 358, 10, 358, 12, 358, 7847, 9, 358, 1, 358, 1, 358, 1, 358, 1, 358, 5, 358, 7853, 8, 358, 10, 358, 12, 358, 7856, 9, 358, 3, 358, 7858, 8, 358, 3, 358, 7860, 8, 358, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 3, 360, 7870, 8, 360, 1, 360, 1, 360, 1, 360, 3, 360, 7875, 8, 360, 1, 360, 1, 360, 3, 360, 7879, 8, 360, 1, 360, 1, 360, 3, 360, 7883, 8, 360, 1, 360, 3, 360, 7886, 8, 360, 1, 360, 3, 360, 7889, 8, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 3, 363, 7903, 8, 363, 3, 363, 7905, 8, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7911, 8, 363, 3, 363, 7913, 8, 363, 5, 363, 7915, 8, 363, 10, 363, 12, 363, 7918, 9, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7923, 8, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7929, 8, 363, 5, 363, 7931, 8, 363, 10, 363, 12, 363, 7934, 9, 363, 3, 363, 7936, 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, 5, 364, 7942, 8, 364, 10, 364, 12, 364, 7945, 9, 364, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 5, 366, 7952, 8, 366, 10, 366, 12, 366, 7955, 9, 366, 1, 366, 3, 366, 7958, 8, 366, 1, 366, 1, 366, 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, 3, 368, 7977, 8, 368, 1, 369, 1, 369, 1, 369, 3, 369, 7982, 8, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 3, 370, 7989, 8, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 3, 371, 7996, 8, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 8070, 8, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 8077, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8086, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8095, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 5, 374, 8101, 8, 374, 10, 374, 12, 374, 8104, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8110, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8117, 8, 374, 1, 374, 5, 374, 8120, 8, 374, 10, 374, 12, 374, 8123, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8129, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8136, 8, 374, 1, 374, 5, 374, 8139, 8, 374, 10, 374, 12, 374, 8142, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8148, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8155, 8, 374, 1, 374, 5, 374, 8158, 8, 374, 10, 374, 12, 374, 8161, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8167, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8174, 8, 374, 1, 374, 5, 374, 8177, 8, 374, 10, 374, 12, 374, 8180, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8186, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8193, 8, 374, 1, 374, 5, 374, 8196, 8, 374, 10, 374, 12, 374, 8199, 9, 374, 3, 374, 8201, 8, 374, 1, 374, 3, 374, 8204, 8, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 8211, 8, 375, 1, 375, 1, 375, 3, 375, 8215, 8, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 3, 376, 8224, 8, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 5, 377, 8233, 8, 377, 10, 377, 12, 377, 8236, 9, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, 8244, 8, 377, 1, 377, 1, 377, 3, 377, 8248, 8, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, 8255, 8, 377, 3, 377, 8257, 8, 377, 1, 378, 1, 378, 1, 378, 5, 378, 8262, 8, 378, 10, 378, 12, 378, 8265, 9, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, 8272, 8, 379, 1, 379, 1, 379, 1, 379, 3, 379, 8277, 8, 379, 1, 379, 1, 379, 3, 379, 8281, 8, 379, 1, 380, 1, 380, 1, 380, 3, 380, 8286, 8, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 8293, 8, 380, 3, 380, 8295, 8, 380, 1, 380, 1, 380, 3, 380, 8299, 8, 380, 1, 380, 3, 380, 8302, 8, 380, 1, 380, 3, 380, 8305, 8, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 3, 382, 8314, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8320, 8, 382, 3, 382, 8322, 8, 382, 4, 382, 8324, 8, 382, 11, 382, 12, 382, 8325, 1, 382, 1, 382, 3, 382, 8330, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8335, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8340, 8, 382, 5, 382, 8342, 8, 382, 10, 382, 12, 382, 8345, 9, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8350, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8355, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8360, 8, 382, 1, 382, 3, 382, 8363, 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 3, 384, 8372, 8, 384, 1, 384, 3, 384, 8375, 8, 384, 1, 384, 3, 384, 8378, 8, 384, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 8384, 8, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 3, 386, 8391, 8, 386, 1, 386, 1, 386, 1, 386, 3, 386, 8396, 8, 386, 5, 386, 8398, 8, 386, 10, 386, 12, 386, 8401, 9, 386, 1, 387, 1, 387, 1, 387, 3, 387, 8406, 8, 387, 3, 387, 8408, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 8414, 8, 387, 3, 387, 8416, 8, 387, 5, 387, 8418, 8, 387, 10, 387, 12, 387, 8421, 9, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 8429, 8, 387, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8435, 8, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 5, 388, 8442, 8, 388, 10, 388, 12, 388, 8445, 9, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8456, 8, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8464, 8, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8473, 8, 388, 1, 388, 3, 388, 8476, 8, 388, 1, 389, 1, 389, 1, 389, 5, 389, 8481, 8, 389, 10, 389, 12, 389, 8484, 9, 389, 1, 389, 3, 389, 8487, 8, 389, 1, 389, 1, 389, 1, 389, 1, 389, 5, 389, 8493, 8, 389, 10, 389, 12, 389, 8496, 9, 389, 1, 390, 1, 390, 1, 390, 1, 390, 3, 390, 8502, 8, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 4, 391, 8510, 8, 391, 11, 391, 12, 391, 8511, 1, 391, 1, 391, 1, 391, 4, 391, 8517, 8, 391, 11, 391, 12, 391, 8518, 1, 392, 1, 392, 1, 392, 3, 392, 8524, 8, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 3, 392, 8531, 8, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8547, 8, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8554, 8, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8564, 8, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 4, 395, 8571, 8, 395, 11, 395, 12, 395, 8572, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 3, 396, 8582, 8, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 8591, 8, 397, 1, 397, 5, 397, 8594, 8, 397, 10, 397, 12, 397, 8597, 9, 397, 1, 397, 1, 397, 3, 397, 8601, 8, 397, 1, 397, 3, 397, 8604, 8, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 8612, 8, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 3, 400, 8623, 8, 400, 1, 400, 1, 400, 3, 400, 8627, 8, 400, 1, 400, 3, 400, 8630, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8638, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8644, 8, 400, 3, 400, 8646, 8, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8651, 8, 400, 1, 400, 3, 400, 8654, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8661, 8, 400, 1, 400, 1, 400, 3, 400, 8665, 8, 400, 1, 400, 4, 400, 8668, 8, 400, 11, 400, 12, 400, 8669, 1, 400, 3, 400, 8673, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8686, 8, 400, 1, 400, 1, 400, 3, 400, 8690, 8, 400, 1, 401, 1, 401, 1, 401, 3, 401, 8695, 8, 401, 1, 401, 3, 401, 8698, 8, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 8708, 8, 402, 1, 402, 1, 402, 3, 402, 8712, 8, 402, 1, 402, 1, 402, 3, 402, 8716, 8, 402, 1, 403, 1, 403, 1, 403, 3, 403, 8721, 8, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 3, 407, 8737, 8, 407, 1, 408, 1, 408, 1, 408, 3, 408, 8742, 8, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, 8754, 8, 409, 4, 409, 8756, 8, 409, 11, 409, 12, 409, 8757, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, 8764, 8, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 5, 409, 8777, 8, 409, 10, 409, 12, 409, 8780, 9, 409, 3, 409, 8782, 8, 409, 3, 409, 8784, 8, 409, 3, 409, 8786, 8, 409, 4, 409, 8788, 8, 409, 11, 409, 12, 409, 8789, 1, 409, 3, 409, 8793, 8, 409, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 5, 410, 8811, 8, 410, 10, 410, 12, 410, 8814, 9, 410, 1, 410, 1, 410, 3, 410, 8818, 8, 410, 1, 410, 1, 410, 1, 410, 3, 410, 8823, 8, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 4, 411, 8832, 8, 411, 11, 411, 12, 411, 8833, 1, 411, 3, 411, 8837, 8, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 4, 412, 8847, 8, 412, 11, 412, 12, 412, 8848, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 4, 413, 8856, 8, 413, 11, 413, 12, 413, 8857, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 4, 414, 8867, 8, 414, 11, 414, 12, 414, 8868, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 5, 415, 8876, 8, 415, 10, 415, 12, 415, 8879, 9, 415, 1, 415, 1, 415, 3, 415, 8883, 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, 1, 416, 1, 416, 1, 416, 1, 416, 5, 416, 8905, 8, 416, 10, 416, 12, 416, 8908, 9, 416, 1, 416, 1, 416, 3, 416, 8912, 8, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 8918, 8, 416, 3, 416, 8920, 8, 416, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 3, 418, 8928, 8, 418, 1, 418, 3, 418, 8931, 8, 418, 1, 418, 3, 418, 8934, 8, 418, 1, 418, 3, 418, 8937, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8943, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8949, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8955, 8, 418, 1, 418, 1, 418, 3, 418, 8959, 8, 418, 3, 418, 8961, 8, 418, 1, 418, 3, 418, 8964, 8, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8969, 8, 418, 1, 418, 1, 418, 3, 418, 8973, 8, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8978, 8, 418, 1, 418, 3, 418, 8981, 8, 418, 1, 419, 1, 419, 1, 419, 3, 419, 8986, 8, 419, 1, 419, 3, 419, 8989, 8, 419, 1, 420, 1, 420, 1, 420, 3, 420, 8994, 8, 420, 1, 421, 1, 421, 3, 421, 8998, 8, 421, 1, 421, 1, 421, 5, 421, 9002, 8, 421, 10, 421, 12, 421, 9005, 9, 421, 1, 421, 3, 421, 9008, 8, 421, 4, 421, 9010, 8, 421, 11, 421, 12, 421, 9011, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 9020, 8, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 5, 422, 9031, 8, 422, 10, 422, 12, 422, 9034, 9, 422, 1, 422, 3, 422, 9037, 8, 422, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 9043, 8, 422, 1, 422, 3, 422, 9046, 8, 422, 1, 422, 1, 422, 3, 422, 9050, 8, 422, 1, 422, 1, 422, 1, 422, 3, 422, 9055, 8, 422, 4, 422, 9057, 8, 422, 11, 422, 12, 422, 9058, 1, 422, 1, 422, 5, 422, 9063, 8, 422, 10, 422, 12, 422, 9066, 9, 422, 1, 423, 1, 423, 3, 423, 9070, 8, 423, 1, 423, 3, 423, 9073, 8, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 9081, 8, 423, 1, 423, 3, 423, 9084, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, 9093, 8, 424, 1, 424, 1, 424, 3, 424, 9097, 8, 424, 3, 424, 9099, 8, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 9118, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 9124, 8, 425, 1, 425, 4, 425, 9127, 8, 425, 11, 425, 12, 425, 9128, 1, 425, 1, 425, 1, 425, 3, 425, 9134, 8, 425, 3, 425, 9136, 8, 425, 1, 426, 1, 426, 3, 426, 9140, 8, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 5, 426, 9147, 8, 426, 10, 426, 12, 426, 9150, 9, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 5, 426, 9160, 8, 426, 10, 426, 12, 426, 9163, 9, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, 9173, 8, 426, 1, 426, 3, 426, 9176, 8, 426, 1, 426, 3, 426, 9179, 8, 426, 1, 427, 3, 427, 9182, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 4, 427, 9191, 8, 427, 11, 427, 12, 427, 9192, 1, 428, 1, 428, 1, 428, 3, 428, 9198, 8, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 5, 428, 9208, 8, 428, 10, 428, 12, 428, 9211, 9, 428, 1, 428, 1, 428, 3, 428, 9215, 8, 428, 1, 429, 1, 429, 3, 429, 9219, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9227, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9234, 8, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9239, 8, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9244, 8, 429, 1, 430, 1, 430, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 3, 432, 9255, 8, 432, 1, 432, 3, 432, 9258, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 3, 432, 9270, 8, 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, 3, 432, 9285, 8, 432, 1, 433, 1, 433, 1, 433, 3, 433, 9290, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 9296, 8, 433, 1, 433, 1, 433, 3, 433, 9300, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 9306, 8, 433, 1, 433, 1, 433, 3, 433, 9310, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 5, 433, 9317, 8, 433, 10, 433, 12, 433, 9320, 9, 433, 1, 433, 1, 433, 1, 433, 1, 433, 5, 433, 9326, 8, 433, 10, 433, 12, 433, 9329, 9, 433, 1, 433, 1, 433, 3, 433, 9333, 8, 433, 1, 434, 1, 434, 3, 434, 9337, 8, 434, 1, 434, 1, 434, 3, 434, 9341, 8, 434, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 9347, 8, 435, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 3, 437, 9354, 8, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 9360, 8, 437, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 440, 1, 440, 3, 440, 9369, 8, 440, 1, 440, 1, 440, 1, 440, 3, 440, 9374, 8, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 9381, 8, 441, 1, 441, 3, 441, 9384, 8, 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, 441, 1, 441, 1, 441, 5, 441, 9401, 8, 441, 10, 441, 12, 441, 9404, 9, 441, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 9418, 8, 444, 3, 444, 9420, 8, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 3, 446, 9433, 8, 446, 1, 446, 3, 446, 9436, 8, 446, 1, 446, 3, 446, 9439, 8, 446, 1, 446, 3, 446, 9442, 8, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 9450, 8, 447, 1, 447, 3, 447, 9453, 8, 447, 1, 447, 3, 447, 9456, 8, 447, 1, 447, 3, 447, 9459, 8, 447, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 3, 449, 9471, 8, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 5, 449, 9480, 8, 449, 10, 449, 12, 449, 9483, 9, 449, 3, 449, 9485, 8, 449, 1, 449, 4, 449, 9488, 8, 449, 11, 449, 12, 449, 9489, 1, 449, 1, 449, 3, 449, 9494, 8, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 9502, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 9515, 8, 450, 1, 451, 1, 451, 3, 451, 9519, 8, 451, 1, 451, 1, 451, 3, 451, 9523, 8, 451, 1, 452, 1, 452, 3, 452, 9527, 8, 452, 1, 452, 3, 452, 9530, 8, 452, 1, 452, 3, 452, 9533, 8, 452, 1, 452, 3, 452, 9536, 8, 452, 1, 452, 3, 452, 9539, 8, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 9549, 8, 453, 1, 453, 3, 453, 9552, 8, 453, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 9561, 8, 455, 1, 456, 1, 456, 3, 456, 9565, 8, 456, 1, 456, 1, 456, 1, 456, 1, 456, 5, 456, 9571, 8, 456, 10, 456, 12, 456, 9574, 9, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 5, 456, 9584, 8, 456, 10, 456, 12, 456, 9587, 9, 456, 3, 456, 9589, 8, 456, 3, 456, 9591, 8, 456, 1, 456, 1, 456, 3, 456, 9595, 8, 456, 1, 457, 1, 457, 3, 457, 9599, 8, 457, 1, 457, 1, 457, 1, 458, 1, 458, 3, 458, 9605, 8, 458, 1, 458, 1, 458, 1, 459, 3, 459, 9610, 8, 459, 1, 459, 1, 459, 3, 459, 9614, 8, 459, 1, 459, 3, 459, 9617, 8, 459, 1, 459, 3, 459, 9620, 8, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 5, 460, 9627, 8, 460, 10, 460, 12, 460, 9630, 9, 460, 1, 460, 1, 460, 3, 460, 9634, 8, 460, 1, 460, 1, 460, 3, 460, 9638, 8, 460, 1, 460, 1, 460, 3, 460, 9642, 8, 460, 1, 460, 3, 460, 9645, 8, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, 9652, 8, 461, 1, 461, 3, 461, 9655, 8, 461, 3, 461, 9657, 8, 461, 1, 462, 1, 462, 1, 462, 3, 462, 9662, 8, 462, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 9671, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 9677, 8, 464, 1, 464, 3, 464, 9680, 8, 464, 3, 464, 9682, 8, 464, 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, 5, 466, 9697, 8, 466, 10, 466, 12, 466, 9700, 9, 466, 1, 466, 1, 466, 1, 466, 5, 466, 9705, 8, 466, 10, 466, 12, 466, 9708, 9, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 3, 466, 9716, 8, 466, 1, 466, 3, 466, 9719, 8, 466, 1, 466, 1, 466, 1, 466, 3, 466, 9724, 8, 466, 1, 466, 3, 466, 9727, 8, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 3, 466, 9736, 8, 466, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 9756, 8, 468, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 9762, 8, 468, 1, 468, 1, 468, 1, 468, 4, 468, 9767, 8, 468, 11, 468, 12, 468, 9768, 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 3, 470, 9779, 8, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 9788, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 9800, 8, 471, 1, 471, 3, 471, 9803, 8, 471, 1, 471, 3, 471, 9806, 8, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 3, 473, 9816, 8, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 9825, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 5, 474, 9831, 8, 474, 10, 474, 12, 474, 9834, 9, 474, 1, 474, 1, 474, 3, 474, 9838, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 5, 474, 9844, 8, 474, 10, 474, 12, 474, 9847, 9, 474, 1, 474, 1, 474, 3, 474, 9851, 8, 474, 1, 474, 3, 474, 9854, 8, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 4, 475, 9867, 8, 475, 11, 475, 12, 475, 9868, 3, 475, 9871, 8, 475, 1, 475, 3, 475, 9874, 8, 475, 1, 475, 1, 475, 3, 475, 9878, 8, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 3, 475, 9888, 8, 475, 5, 475, 9890, 8, 475, 10, 475, 12, 475, 9893, 9, 475, 1, 475, 1, 475, 3, 475, 9897, 8, 475, 1, 475, 4, 475, 9900, 8, 475, 11, 475, 12, 475, 9901, 1, 475, 1, 475, 3, 475, 9906, 8, 475, 3, 475, 9908, 8, 475, 1, 475, 3, 475, 9911, 8, 475, 5, 475, 9913, 8, 475, 10, 475, 12, 475, 9916, 9, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 3, 477, 9925, 8, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, 478, 9935, 8, 478, 1, 478, 3, 478, 9938, 8, 478, 1, 478, 3, 478, 9941, 8, 478, 1, 478, 1, 478, 3, 478, 9945, 8, 478, 1, 478, 1, 478, 3, 478, 9949, 8, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 3, 479, 9962, 8, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 3, 481, 9971, 8, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 3, 481, 9982, 8, 481, 3, 481, 9984, 8, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 4, 482, 9995, 8, 482, 11, 482, 12, 482, 9996, 1, 483, 1, 483, 1, 483, 3, 483, 10002, 8, 483, 1, 484, 1, 484, 1, 484, 3, 484, 10007, 8, 484, 1, 485, 1, 485, 1, 485, 5, 485, 10012, 8, 485, 10, 485, 12, 485, 10015, 9, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 10032, 8, 488, 1, 489, 1, 489, 1, 489, 1, 489, 3, 489, 10038, 8, 489, 1, 490, 1, 490, 1, 490, 3, 490, 10043, 8, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 5, 490, 10051, 8, 490, 10, 490, 12, 490, 10054, 9, 490, 1, 490, 1, 490, 1, 490, 3, 490, 10059, 8, 490, 1, 491, 1, 491, 1, 491, 1, 491, 5, 491, 10065, 8, 491, 10, 491, 12, 491, 10068, 9, 491, 1, 491, 1, 491, 1, 491, 3, 491, 10073, 8, 491, 1, 491, 1, 491, 3, 491, 10077, 8, 491, 1, 491, 3, 491, 10080, 8, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 10092, 8, 493, 1, 494, 1, 494, 1, 494, 5, 494, 10097, 8, 494, 10, 494, 12, 494, 10100, 9, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 5, 495, 10107, 8, 495, 10, 495, 12, 495, 10110, 9, 495, 1, 495, 1, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 3, 496, 10124, 8, 496, 1, 496, 1, 496, 1, 496, 3, 496, 10129, 8, 496, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 5, 498, 10140, 8, 498, 10, 498, 12, 498, 10143, 9, 498, 1, 498, 1, 498, 3, 498, 10147, 8, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10155, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10160, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10165, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10170, 8, 499, 5, 499, 10172, 8, 499, 10, 499, 12, 499, 10175, 9, 499, 1, 499, 1, 499, 3, 499, 10179, 8, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10187, 8, 499, 1, 499, 3, 499, 10190, 8, 499, 1, 499, 3, 499, 10193, 8, 499, 1, 499, 3, 499, 10196, 8, 499, 1, 499, 3, 499, 10199, 8, 499, 3, 499, 10201, 8, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 4, 499, 10208, 8, 499, 11, 499, 12, 499, 10209, 5, 499, 10212, 8, 499, 10, 499, 12, 499, 10215, 9, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10220, 8, 499, 1, 499, 3, 499, 10223, 8, 499, 1, 499, 3, 499, 10226, 8, 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10232, 8, 499, 1, 499, 3, 499, 10235, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10240, 8, 499, 1, 499, 3, 499, 10243, 8, 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, 3, 500, 10257, 8, 500, 1, 500, 1, 500, 1, 501, 1, 501, 3, 501, 10263, 8, 501, 1, 501, 1, 501, 3, 501, 10267, 8, 501, 1, 501, 1, 501, 3, 501, 10271, 8, 501, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10282, 8, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10289, 8, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10294, 8, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10299, 8, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10304, 8, 502, 1, 502, 1, 502, 1, 502, 4, 502, 10309, 8, 502, 11, 502, 12, 502, 10310, 3, 502, 10313, 8, 502, 1, 503, 1, 503, 1, 503, 1, 503, 3, 503, 10319, 8, 503, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10325, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10332, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10340, 8, 504, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 3, 505, 10348, 8, 505, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 3, 506, 10356, 8, 506, 1, 506, 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 3, 507, 10364, 8, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 3, 507, 10372, 8, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 3, 507, 10379, 8, 507, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 10390, 8, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 10396, 8, 509, 5, 509, 10398, 8, 509, 10, 509, 12, 509, 10401, 9, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 10412, 8, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 10419, 8, 509, 5, 509, 10421, 8, 509, 10, 509, 12, 509, 10424, 9, 509, 1, 509, 3, 509, 10427, 8, 509, 1, 509, 3, 509, 10430, 8, 509, 1, 509, 3, 509, 10433, 8, 509, 1, 510, 1, 510, 3, 510, 10437, 8, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 4, 510, 10444, 8, 510, 11, 510, 12, 510, 10445, 1, 510, 3, 510, 10449, 8, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 3, 511, 10457, 8, 511, 3, 511, 10459, 8, 511, 1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 10465, 8, 512, 1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 10471, 8, 512, 1, 512, 1, 512, 1, 512, 3, 512, 10476, 8, 512, 3, 512, 10478, 8, 512, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 3, 513, 10486, 8, 513, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 3, 516, 10497, 8, 516, 1, 516, 3, 516, 10500, 8, 516, 1, 516, 1, 516, 3, 516, 10504, 8, 516, 1, 516, 1, 516, 3, 516, 10508, 8, 516, 1, 516, 3, 516, 10511, 8, 516, 1, 516, 1, 516, 1, 516, 3, 516, 10516, 8, 516, 1, 516, 1, 516, 3, 516, 10520, 8, 516, 1, 517, 1, 517, 3, 517, 10524, 8, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, 10533, 8, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, 10539, 8, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, 10545, 8, 517, 1, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10551, 8, 518, 1, 518, 3, 518, 10554, 8, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, 10562, 8, 519, 1, 519, 1, 519, 3, 519, 10566, 8, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, 10572, 8, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, 10578, 8, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, 10584, 8, 519, 1, 519, 1, 519, 3, 519, 10588, 8, 519, 3, 519, 10590, 8, 519, 1, 519, 1, 519, 1, 519, 3, 519, 10595, 8, 519, 1, 519, 3, 519, 10598, 8, 519, 1, 519, 1, 519, 3, 519, 10602, 8, 519, 1, 519, 1, 519, 3, 519, 10606, 8, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 3, 520, 10614, 8, 520, 1, 520, 1, 520, 3, 520, 10618, 8, 520, 1, 520, 3, 520, 10621, 8, 520, 1, 520, 3, 520, 10624, 8, 520, 1, 520, 1, 520, 1, 520, 1, 520, 3, 520, 10630, 8, 520, 1, 520, 3, 520, 10633, 8, 520, 1, 520, 3, 520, 10636, 8, 520, 1, 520, 3, 520, 10639, 8, 520, 1, 520, 3, 520, 10642, 8, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 5, 521, 10659, 8, 521, 10, 521, 12, 521, 10662, 9, 521, 1, 521, 1, 521, 1, 522, 1, 522, 3, 522, 10668, 8, 522, 1, 522, 1, 522, 3, 522, 10672, 8, 522, 1, 522, 3, 522, 10675, 8, 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10682, 8, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10687, 8, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10694, 8, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10700, 8, 523, 3, 523, 10702, 8, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10708, 8, 523, 1, 524, 1, 524, 3, 524, 10712, 8, 524, 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, 3, 524, 10719, 8, 524, 1, 524, 1, 524, 1, 524, 3, 524, 10724, 8, 524, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 10730, 8, 525, 1, 525, 1, 525, 3, 525, 10734, 8, 525, 1, 525, 1, 525, 1, 525, 1, 525, 5, 525, 10740, 8, 525, 10, 525, 12, 525, 10743, 9, 525, 1, 525, 1, 525, 3, 525, 10747, 8, 525, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 10753, 8, 525, 1, 525, 3, 525, 10756, 8, 525, 1, 525, 3, 525, 10759, 8, 525, 1, 525, 3, 525, 10762, 8, 525, 1, 525, 3, 525, 10765, 8, 525, 1, 526, 1, 526, 1, 527, 1, 527, 3, 527, 10771, 8, 527, 1, 527, 1, 527, 1, 527, 1, 527, 4, 527, 10777, 8, 527, 11, 527, 12, 527, 10778, 1, 527, 1, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 3, 528, 10790, 8, 528, 1, 529, 1, 529, 3, 529, 10794, 8, 529, 1, 529, 1, 529, 3, 529, 10798, 8, 529, 1, 529, 1, 529, 1, 529, 5, 529, 10803, 8, 529, 10, 529, 12, 529, 10806, 9, 529, 1, 529, 3, 529, 10809, 8, 529, 1, 529, 1, 529, 1, 529, 3, 529, 10814, 8, 529, 1, 530, 3, 530, 10817, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 5, 531, 10828, 8, 531, 10, 531, 12, 531, 10831, 9, 531, 1, 531, 1, 531, 3, 531, 10835, 8, 531, 1, 531, 3, 531, 10838, 8, 531, 1, 532, 4, 532, 10841, 8, 532, 11, 532, 12, 532, 10842, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 10856, 8, 533, 1, 533, 1, 533, 3, 533, 10860, 8, 533, 1, 534, 1, 534, 3, 534, 10864, 8, 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 10873, 8, 535, 1, 536, 1, 536, 1, 536, 3, 536, 10878, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 10886, 8, 536, 3, 536, 10888, 8, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 10901, 8, 538, 1, 539, 1, 539, 1, 539, 3, 539, 10906, 8, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 10914, 8, 539, 3, 539, 10916, 8, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 3, 542, 10952, 8, 542, 1, 542, 1, 542, 3, 542, 10956, 8, 542, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 3, 545, 10966, 8, 545, 1, 545, 1, 545, 3, 545, 10970, 8, 545, 1, 545, 1, 545, 3, 545, 10974, 8, 545, 1, 545, 3, 545, 10977, 8, 545, 1, 545, 1, 545, 1, 545, 3, 545, 10982, 8, 545, 1, 545, 3, 545, 10985, 8, 545, 1, 546, 1, 546, 1, 546, 3, 546, 10990, 8, 546, 1, 546, 1, 546, 1, 546, 1, 546, 5, 546, 10996, 8, 546, 10, 546, 12, 546, 10999, 9, 546, 1, 547, 1, 547, 1, 547, 1, 547, 3, 547, 11005, 8, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 548, 1, 548, 1, 549, 1, 549, 3, 549, 11017, 8, 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 5, 550, 11027, 8, 550, 10, 550, 12, 550, 11030, 9, 550, 1, 550, 1, 550, 3, 550, 11034, 8, 550, 1, 551, 1, 551, 1, 551, 1, 551, 5, 551, 11040, 8, 551, 10, 551, 12, 551, 11043, 9, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 11056, 8, 553, 1, 553, 1, 553, 1, 553, 3, 553, 11061, 8, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 11072, 8, 554, 1, 554, 1, 554, 3, 554, 11076, 8, 554, 1, 554, 1, 554, 3, 554, 11080, 8, 554, 3, 554, 11082, 8, 554, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 3, 556, 11092, 8, 556, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 3, 557, 11102, 8, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 5, 558, 11111, 8, 558, 10, 558, 12, 558, 11114, 9, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 5, 558, 11127, 8, 558, 10, 558, 12, 558, 11130, 9, 558, 1, 558, 1, 558, 3, 558, 11134, 8, 558, 3, 558, 11136, 8, 558, 1, 558, 1, 558, 1, 558, 3, 558, 11141, 8, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 3, 558, 11148, 8, 558, 1, 558, 1, 558, 1, 558, 5, 558, 11153, 8, 558, 10, 558, 12, 558, 11156, 9, 558, 1, 558, 1, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 5, 559, 11173, 8, 559, 10, 559, 12, 559, 11176, 9, 559, 1, 559, 1, 559, 3, 559, 11180, 8, 559, 3, 559, 11182, 8, 559, 1, 559, 1, 559, 1, 559, 3, 559, 11187, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 11194, 8, 559, 1, 559, 1, 559, 1, 559, 5, 559, 11199, 8, 559, 10, 559, 12, 559, 11202, 9, 559, 1, 559, 1, 559, 3, 559, 11206, 8, 559, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 5, 560, 11215, 8, 560, 10, 560, 12, 560, 11218, 9, 560, 1, 560, 1, 560, 1, 560, 3, 560, 11223, 8, 560, 1, 561, 1, 561, 1, 561, 3, 561, 11228, 8, 561, 1, 561, 3, 561, 11231, 8, 561, 1, 561, 1, 561, 1, 561, 3, 561, 11236, 8, 561, 1, 561, 3, 561, 11239, 8, 561, 5, 561, 11241, 8, 561, 10, 561, 12, 561, 11244, 9, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 5, 562, 11256, 8, 562, 10, 562, 12, 562, 11259, 9, 562, 1, 562, 1, 562, 3, 562, 11263, 8, 562, 1, 562, 1, 562, 3, 562, 11267, 8, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 5, 562, 11276, 8, 562, 10, 562, 12, 562, 11279, 9, 562, 1, 562, 1, 562, 3, 562, 11283, 8, 562, 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 5, 564, 11294, 8, 564, 10, 564, 12, 564, 11297, 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, 11310, 8, 564, 10, 564, 12, 564, 11313, 9, 564, 1, 564, 1, 564, 3, 564, 11317, 8, 564, 3, 564, 11319, 8, 564, 1, 564, 1, 564, 1, 564, 3, 564, 11324, 8, 564, 1, 564, 1, 564, 1, 564, 1, 564, 5, 564, 11330, 8, 564, 10, 564, 12, 564, 11333, 9, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 11346, 8, 565, 1, 565, 1, 565, 1, 565, 1, 565, 5, 565, 11352, 8, 565, 10, 565, 12, 565, 11355, 9, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 4, 566, 11365, 8, 566, 11, 566, 12, 566, 11366, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 11373, 8, 566, 1, 566, 1, 566, 3, 566, 11377, 8, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 5, 567, 11389, 8, 567, 10, 567, 12, 567, 11392, 9, 567, 1, 567, 1, 567, 3, 567, 11396, 8, 567, 1, 568, 1, 568, 3, 568, 11400, 8, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 5, 569, 11412, 8, 569, 10, 569, 12, 569, 11415, 9, 569, 3, 569, 11417, 8, 569, 1, 570, 1, 570, 3, 570, 11421, 8, 570, 1, 570, 3, 570, 11424, 8, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 5, 570, 11431, 8, 570, 10, 570, 12, 570, 11434, 9, 570, 1, 570, 1, 570, 1, 570, 5, 570, 11439, 8, 570, 10, 570, 12, 570, 11442, 9, 570, 1, 570, 1, 570, 1, 570, 5, 570, 11447, 8, 570, 10, 570, 12, 570, 11450, 9, 570, 3, 570, 11452, 8, 570, 1, 570, 1, 570, 1, 570, 3, 570, 11457, 8, 570, 3, 570, 11459, 8, 570, 1, 571, 1, 571, 3, 571, 11463, 8, 571, 1, 571, 3, 571, 11466, 8, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 5, 571, 11473, 8, 571, 10, 571, 12, 571, 11476, 9, 571, 1, 571, 1, 571, 1, 571, 5, 571, 11481, 8, 571, 10, 571, 12, 571, 11484, 9, 571, 1, 571, 1, 571, 1, 571, 5, 571, 11489, 8, 571, 10, 571, 12, 571, 11492, 9, 571, 3, 571, 11494, 8, 571, 1, 571, 1, 571, 1, 571, 3, 571, 11499, 8, 571, 3, 571, 11501, 8, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 5, 572, 11509, 8, 572, 10, 572, 12, 572, 11512, 9, 572, 1, 572, 1, 572, 1, 572, 5, 572, 11517, 8, 572, 10, 572, 12, 572, 11520, 9, 572, 1, 572, 1, 572, 1, 572, 5, 572, 11525, 8, 572, 10, 572, 12, 572, 11528, 9, 572, 3, 572, 11530, 8, 572, 1, 572, 1, 572, 1, 572, 3, 572, 11535, 8, 572, 1, 573, 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 5, 574, 11546, 8, 574, 10, 574, 12, 574, 11549, 9, 574, 1, 574, 1, 574, 3, 574, 11553, 8, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, 575, 11562, 8, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 5, 576, 11571, 8, 576, 10, 576, 12, 576, 11574, 9, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 5, 576, 11585, 8, 576, 10, 576, 12, 576, 11588, 9, 576, 1, 576, 1, 576, 3, 576, 11592, 8, 576, 1, 576, 3, 576, 11595, 8, 576, 1, 577, 1, 577, 1, 578, 1, 578, 3, 578, 11601, 8, 578, 1, 578, 1, 578, 3, 578, 11605, 8, 578, 1, 579, 1, 579, 3, 579, 11609, 8, 579, 1, 579, 1, 579, 3, 579, 11613, 8, 579, 1, 580, 1, 580, 3, 580, 11617, 8, 580, 1, 580, 3, 580, 11620, 8, 580, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 5, 581, 11630, 8, 581, 10, 581, 12, 581, 11633, 9, 581, 1, 581, 1, 581, 3, 581, 11637, 8, 581, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 583, 1, 583, 1, 583, 5, 583, 11649, 8, 583, 10, 583, 12, 583, 11652, 9, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 5, 583, 11659, 8, 583, 10, 583, 12, 583, 11662, 9, 583, 3, 583, 11664, 8, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 5, 584, 11671, 8, 584, 10, 584, 12, 584, 11674, 9, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 5, 584, 11681, 8, 584, 10, 584, 12, 584, 11684, 9, 584, 1, 584, 3, 584, 11687, 8, 584, 1, 584, 1, 584, 1, 585, 3, 585, 11692, 8, 585, 1, 585, 3, 585, 11695, 8, 585, 1, 585, 3, 585, 11698, 8, 585, 1, 585, 3, 585, 11701, 8, 585, 1, 585, 3, 585, 11704, 8, 585, 1, 585, 1, 585, 3, 585, 11708, 8, 585, 1, 585, 3, 585, 11711, 8, 585, 1, 585, 3, 585, 11714, 8, 585, 1, 585, 1, 585, 3, 585, 11718, 8, 585, 3, 585, 11720, 8, 585, 1, 585, 1, 585, 1, 585, 5, 585, 11725, 8, 585, 10, 585, 12, 585, 11728, 9, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 11735, 8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 11746, 8, 586, 1, 586, 1, 586, 1, 586, 4, 586, 11751, 8, 586, 11, 586, 12, 586, 11752, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 11762, 8, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 11770, 8, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 11777, 8, 587, 1, 588, 1, 588, 3, 588, 11781, 8, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11789, 8, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11795, 8, 589, 3, 589, 11797, 8, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11803, 8, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11811, 8, 589, 3, 589, 11813, 8, 589, 1, 589, 3, 589, 11816, 8, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11821, 8, 589, 1, 589, 3, 589, 11824, 8, 589, 1, 590, 4, 590, 11827, 8, 590, 11, 590, 12, 590, 11828, 1, 590, 1, 590, 3, 590, 11833, 8, 590, 1, 590, 1, 590, 3, 590, 11837, 8, 590, 1, 590, 5, 590, 11840, 8, 590, 10, 590, 12, 590, 11843, 9, 590, 3, 590, 11845, 8, 590, 1, 591, 1, 591, 1, 591, 1, 591, 4, 591, 11851, 8, 591, 11, 591, 12, 591, 11852, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 11860, 8, 592, 3, 592, 11862, 8, 592, 1, 592, 1, 592, 3, 592, 11866, 8, 592, 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 3, 594, 11878, 8, 594, 3, 594, 11880, 8, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 3, 594, 11888, 8, 594, 3, 594, 11890, 8, 594, 1, 595, 1, 595, 3, 595, 11894, 8, 595, 1, 595, 1, 595, 3, 595, 11898, 8, 595, 1, 596, 1, 596, 3, 596, 11902, 8, 596, 1, 596, 1, 596, 3, 596, 11906, 8, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 4, 597, 11922, 8, 597, 11, 597, 12, 597, 11923, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 3, 598, 11946, 8, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 4, 598, 11955, 8, 598, 11, 598, 12, 598, 11956, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 600, 1, 600, 1, 600, 1, 600, 3, 600, 11969, 8, 600, 1, 600, 3, 600, 11972, 8, 600, 1, 600, 1, 600, 4, 600, 11976, 8, 600, 11, 600, 12, 600, 11977, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 3, 601, 11988, 8, 601, 1, 601, 1, 601, 1, 601, 3, 601, 11993, 8, 601, 1, 601, 3, 601, 11996, 8, 601, 1, 601, 1, 601, 3, 601, 12000, 8, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 3, 601, 12008, 8, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 5, 601, 12016, 8, 601, 10, 601, 12, 601, 12019, 9, 601, 1, 601, 1, 601, 3, 601, 12023, 8, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 12035, 8, 602, 1, 603, 1, 603, 1, 603, 3, 603, 12040, 8, 603, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 3, 604, 12052, 8, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 3, 604, 12061, 8, 604, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 12067, 8, 605, 1, 605, 1, 605, 3, 605, 12071, 8, 605, 1, 605, 1, 605, 1, 605, 3, 605, 12076, 8, 605, 1, 605, 3, 605, 12079, 8, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 3, 606, 12087, 8, 606, 1, 606, 1, 606, 3, 606, 12091, 8, 606, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 3, 608, 12098, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 12105, 8, 608, 1, 608, 3, 608, 12108, 8, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 610, 3, 610, 12116, 8, 610, 1, 610, 3, 610, 12119, 8, 610, 1, 610, 3, 610, 12122, 8, 610, 1, 611, 1, 611, 1, 611, 3, 611, 12127, 8, 611, 1, 611, 1, 611, 1, 611, 3, 611, 12132, 8, 611, 1, 611, 1, 611, 1, 611, 1, 611, 3, 611, 12138, 8, 611, 3, 611, 12140, 8, 611, 1, 611, 3, 611, 12143, 8, 611, 1, 612, 1, 612, 1, 613, 1, 613, 1, 613, 3, 613, 12150, 8, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 4, 613, 12159, 8, 613, 11, 613, 12, 613, 12160, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 3, 613, 12168, 8, 613, 3, 613, 12170, 8, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 5, 613, 12177, 8, 613, 10, 613, 12, 613, 12180, 9, 613, 1, 613, 1, 613, 3, 613, 12184, 8, 613, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 5, 614, 12196, 8, 614, 10, 614, 12, 614, 12199, 9, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 3, 614, 12207, 8, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12218, 8, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 5, 615, 12225, 8, 615, 10, 615, 12, 615, 12228, 9, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12237, 8, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12245, 8, 615, 1, 616, 1, 616, 3, 616, 12249, 8, 616, 1, 616, 1, 616, 3, 616, 12253, 8, 616, 1, 616, 3, 616, 12256, 8, 616, 1, 617, 1, 617, 1, 617, 5, 617, 12261, 8, 617, 10, 617, 12, 617, 12264, 9, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 5, 618, 12271, 8, 618, 10, 618, 12, 618, 12274, 9, 618, 1, 619, 3, 619, 12277, 8, 619, 1, 619, 1, 619, 3, 619, 12281, 8, 619, 1, 619, 3, 619, 12284, 8, 619, 1, 619, 3, 619, 12287, 8, 619, 1, 619, 1, 619, 1, 619, 3, 619, 12292, 8, 619, 1, 619, 3, 619, 12295, 8, 619, 1, 619, 1, 619, 1, 620, 3, 620, 12300, 8, 620, 1, 620, 1, 620, 3, 620, 12304, 8, 620, 1, 620, 3, 620, 12307, 8, 620, 1, 620, 3, 620, 12310, 8, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12317, 8, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12324, 8, 620, 1, 620, 3, 620, 12327, 8, 620, 3, 620, 12329, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12334, 8, 620, 1, 620, 1, 620, 3, 620, 12338, 8, 620, 1, 620, 3, 620, 12341, 8, 620, 1, 620, 3, 620, 12344, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12349, 8, 620, 1, 620, 3, 620, 12352, 8, 620, 1, 620, 3, 620, 12355, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12360, 8, 620, 1, 620, 1, 620, 3, 620, 12364, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12369, 8, 620, 1, 620, 3, 620, 12372, 8, 620, 1, 620, 3, 620, 12375, 8, 620, 1, 620, 3, 620, 12378, 8, 620, 1, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12384, 8, 620, 1, 620, 1, 620, 3, 620, 12388, 8, 620, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 12395, 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 12401, 8, 621, 1, 621, 3, 621, 12404, 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 12411, 8, 621, 3, 621, 12413, 8, 621, 3, 621, 12415, 8, 621, 1, 622, 1, 622, 1, 623, 3, 623, 12420, 8, 623, 1, 623, 1, 623, 1, 623, 1, 623, 3, 623, 12426, 8, 623, 1, 623, 1, 623, 3, 623, 12430, 8, 623, 1, 623, 1, 623, 1, 623, 1, 623, 3, 623, 12436, 8, 623, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 3, 625, 12447, 8, 625, 1, 625, 1, 625, 1, 625, 1, 625, 3, 625, 12453, 8, 625, 1, 625, 1, 625, 1, 625, 5, 625, 12458, 8, 625, 10, 625, 12, 625, 12461, 9, 625, 1, 626, 1, 626, 1, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 12474, 8, 627, 1, 627, 1, 627, 3, 627, 12478, 8, 627, 1, 627, 1, 627, 3, 627, 12482, 8, 627, 1, 627, 1, 627, 1, 627, 5, 627, 12487, 8, 627, 10, 627, 12, 627, 12490, 9, 627, 1, 627, 3, 627, 12493, 8, 627, 3, 627, 12495, 8, 627, 1, 627, 5, 627, 12498, 8, 627, 10, 627, 12, 627, 12501, 9, 627, 1, 627, 4, 627, 12504, 8, 627, 11, 627, 12, 627, 12505, 3, 627, 12508, 8, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 12534, 8, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 12547, 8, 628, 1, 629, 1, 629, 1, 629, 3, 629, 12552, 8, 629, 1, 629, 3, 629, 12555, 8, 629, 1, 630, 1, 630, 3, 630, 12559, 8, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12564, 8, 630, 1, 630, 3, 630, 12567, 8, 630, 1, 630, 3, 630, 12570, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12577, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12584, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12592, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12598, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12605, 8, 630, 1, 630, 3, 630, 12608, 8, 630, 1, 630, 3, 630, 12611, 8, 630, 1, 630, 3, 630, 12614, 8, 630, 1, 630, 3, 630, 12617, 8, 630, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12624, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12630, 8, 631, 1, 631, 3, 631, 12633, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12641, 8, 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, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12675, 8, 631, 1, 632, 1, 632, 1, 632, 5, 632, 12680, 8, 632, 10, 632, 12, 632, 12683, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 5, 632, 12692, 8, 632, 10, 632, 12, 632, 12695, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12703, 8, 632, 1, 632, 1, 632, 1, 632, 5, 632, 12708, 8, 632, 10, 632, 12, 632, 12711, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12725, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12739, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12748, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 5, 632, 12762, 8, 632, 10, 632, 12, 632, 12765, 9, 632, 3, 632, 12767, 8, 632, 3, 632, 12769, 8, 632, 1, 632, 3, 632, 12772, 8, 632, 1, 633, 1, 633, 1, 633, 1, 633, 5, 633, 12778, 8, 633, 10, 633, 12, 633, 12781, 9, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 5, 634, 12794, 8, 634, 10, 634, 12, 634, 12797, 9, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 5, 634, 12805, 8, 634, 10, 634, 12, 634, 12808, 9, 634, 1, 634, 1, 634, 3, 634, 12812, 8, 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 12820, 8, 635, 1, 635, 1, 635, 3, 635, 12824, 8, 635, 1, 635, 1, 635, 1, 635, 3, 635, 12829, 8, 635, 1, 636, 3, 636, 12832, 8, 636, 1, 636, 1, 636, 1, 636, 1, 637, 1, 637, 1, 637, 3, 637, 12840, 8, 637, 1, 637, 1, 637, 1, 637, 3, 637, 12845, 8, 637, 1, 638, 1, 638, 3, 638, 12849, 8, 638, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 12856, 8, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 12863, 8, 639, 5, 639, 12865, 8, 639, 10, 639, 12, 639, 12868, 9, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 12876, 8, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 12884, 8, 639, 5, 639, 12886, 8, 639, 10, 639, 12, 639, 12889, 9, 639, 3, 639, 12891, 8, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 12899, 8, 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 12905, 8, 640, 5, 640, 12907, 8, 640, 10, 640, 12, 640, 12910, 9, 640, 1, 640, 1, 640, 3, 640, 12914, 8, 640, 1, 641, 1, 641, 1, 641, 3, 641, 12919, 8, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 3, 641, 12926, 8, 641, 1, 641, 1, 641, 3, 641, 12930, 8, 641, 4, 641, 12932, 8, 641, 11, 641, 12, 641, 12933, 1, 641, 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 4, 642, 12948, 8, 642, 11, 642, 12, 642, 12949, 1, 642, 3, 642, 12953, 8, 642, 1, 643, 1, 643, 1, 643, 1, 643, 3, 643, 12959, 8, 643, 1, 644, 1, 644, 1, 644, 3, 644, 12964, 8, 644, 1, 644, 3, 644, 12967, 8, 644, 1, 644, 3, 644, 12970, 8, 644, 1, 645, 3, 645, 12973, 8, 645, 1, 645, 1, 645, 1, 646, 1, 646, 3, 646, 12979, 8, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 3, 647, 12993, 8, 647, 3, 647, 12995, 8, 647, 1, 647, 1, 647, 3, 647, 12999, 8, 647, 1, 647, 3, 647, 13002, 8, 647, 1, 647, 3, 647, 13005, 8, 647, 1, 647, 3, 647, 13008, 8, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 3, 648, 13015, 8, 648, 1, 648, 1, 648, 3, 648, 13019, 8, 648, 1, 648, 1, 648, 3, 648, 13023, 8, 648, 1, 648, 3, 648, 13026, 8, 648, 1, 648, 1, 648, 3, 648, 13030, 8, 648, 1, 648, 3, 648, 13033, 8, 648, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 3, 649, 13040, 8, 649, 1, 649, 1, 649, 3, 649, 13044, 8, 649, 3, 649, 13046, 8, 649, 1, 649, 3, 649, 13049, 8, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 3, 650, 13056, 8, 650, 1, 651, 1, 651, 1, 651, 1, 651, 3, 651, 13062, 8, 651, 1, 651, 1, 651, 3, 651, 13066, 8, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 3, 652, 13073, 8, 652, 1, 652, 1, 652, 3, 652, 13077, 8, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 654, 1, 654, 1, 655, 1, 655, 1, 656, 1, 656, 3, 656, 13092, 8, 656, 1, 656, 1, 656, 1, 656, 1, 656, 3, 656, 13098, 8, 656, 1, 656, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 3, 657, 13106, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13115, 8, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13120, 8, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13125, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13131, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13138, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13145, 8, 657, 1, 657, 3, 657, 13148, 8, 657, 3, 657, 13150, 8, 657, 1, 658, 1, 658, 3, 658, 13154, 8, 658, 1, 658, 1, 658, 1, 658, 1, 658, 3, 658, 13160, 8, 658, 1, 658, 1, 658, 3, 658, 13164, 8, 658, 1, 659, 1, 659, 1, 659, 1, 659, 3, 659, 13170, 8, 659, 1, 659, 1, 659, 1, 659, 1, 659, 3, 659, 13176, 8, 659, 1, 659, 1, 659, 3, 659, 13180, 8, 659, 1, 659, 3, 659, 13183, 8, 659, 1, 660, 1, 660, 1, 661, 1, 661, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 3, 664, 13210, 8, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 3, 664, 13219, 8, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 3, 665, 13228, 8, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 5, 665, 13236, 8, 665, 10, 665, 12, 665, 13239, 9, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 3, 666, 13246, 8, 666, 1, 666, 1, 666, 1, 666, 3, 666, 13251, 8, 666, 1, 666, 1, 666, 1, 667, 1, 667, 1, 667, 5, 667, 13258, 8, 667, 10, 667, 12, 667, 13261, 9, 667, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 3, 668, 13270, 8, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 5, 668, 13278, 8, 668, 10, 668, 12, 668, 13281, 9, 668, 1, 668, 1, 668, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 3, 669, 13291, 8, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 3, 669, 13298, 8, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 3, 670, 13305, 8, 670, 1, 670, 3, 670, 13308, 8, 670, 1, 670, 3, 670, 13311, 8, 670, 1, 670, 3, 670, 13314, 8, 670, 1, 670, 1, 670, 3, 670, 13318, 8, 670, 3, 670, 13320, 8, 670, 1, 670, 3, 670, 13323, 8, 670, 1, 670, 3, 670, 13326, 8, 670, 1, 670, 3, 670, 13329, 8, 670, 1, 670, 3, 670, 13332, 8, 670, 1, 670, 1, 670, 3, 670, 13336, 8, 670, 3, 670, 13338, 8, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 3, 670, 13346, 8, 670, 3, 670, 13348, 8, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 4, 671, 13359, 8, 671, 11, 671, 12, 671, 13360, 1, 671, 3, 671, 13364, 8, 671, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 3, 672, 13372, 8, 672, 1, 672, 1, 672, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 3, 673, 13382, 8, 673, 1, 673, 1, 673, 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, 3, 676, 13403, 8, 676, 3, 676, 13405, 8, 676, 1, 677, 1, 677, 1, 677, 1, 677, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 3, 679, 13419, 8, 679, 1, 679, 1, 679, 3, 679, 13423, 8, 679, 1, 679, 3, 679, 13426, 8, 679, 1, 680, 1, 680, 1, 680, 1, 680, 3, 680, 13432, 8, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 3, 681, 13439, 8, 681, 1, 682, 1, 682, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 3, 684, 13462, 8, 684, 1, 685, 3, 685, 13465, 8, 685, 1, 685, 1, 685, 3, 685, 13469, 8, 685, 1, 686, 1, 686, 1, 686, 3, 686, 13474, 8, 686, 1, 686, 1, 686, 1, 686, 3, 686, 13479, 8, 686, 1, 686, 3, 686, 13482, 8, 686, 1, 686, 3, 686, 13485, 8, 686, 1, 686, 1, 686, 1, 686, 3, 686, 13490, 8, 686, 1, 687, 1, 687, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 3, 689, 13501, 8, 689, 1, 690, 1, 690, 1, 691, 1, 691, 3, 691, 13507, 8, 691, 1, 691, 1, 691, 3, 691, 13511, 8, 691, 1, 691, 1, 691, 1, 691, 1, 691, 3, 691, 13517, 8, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 4, 691, 13524, 8, 691, 11, 691, 12, 691, 13525, 3, 691, 13528, 8, 691, 1, 691, 1, 691, 3, 691, 13532, 8, 691, 1, 691, 3, 691, 13535, 8, 691, 1, 692, 3, 692, 13538, 8, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 3, 692, 13548, 8, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 4, 692, 13556, 8, 692, 11, 692, 12, 692, 13557, 3, 692, 13560, 8, 692, 1, 693, 1, 693, 1, 693, 1, 693, 5, 693, 13566, 8, 693, 10, 693, 12, 693, 13569, 9, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 5, 693, 13577, 8, 693, 10, 693, 12, 693, 13580, 9, 693, 1, 693, 3, 693, 13583, 8, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 5, 694, 13591, 8, 694, 10, 694, 12, 694, 13594, 9, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 5, 694, 13602, 8, 694, 10, 694, 12, 694, 13605, 9, 694, 3, 694, 13607, 8, 694, 1, 694, 1, 694, 1, 694, 3, 694, 13612, 8, 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, 3, 695, 13626, 8, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 4, 695, 13635, 8, 695, 11, 695, 12, 695, 13636, 1, 695, 1, 695, 3, 695, 13641, 8, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 3, 695, 13649, 8, 695, 3, 695, 13651, 8, 695, 1, 696, 1, 696, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 5, 697, 13660, 8, 697, 10, 697, 12, 697, 13663, 9, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 3, 697, 13672, 8, 697, 1, 698, 1, 698, 1, 698, 1, 698, 3, 698, 13678, 8, 698, 1, 698, 1, 698, 1, 698, 3, 698, 13683, 8, 698, 5, 698, 13685, 8, 698, 10, 698, 12, 698, 13688, 9, 698, 1, 698, 1, 698, 3, 698, 13692, 8, 698, 1, 699, 1, 699, 1, 699, 3, 699, 13697, 8, 699, 1, 699, 1, 699, 1, 699, 3, 699, 13702, 8, 699, 5, 699, 13704, 8, 699, 10, 699, 12, 699, 13707, 9, 699, 1, 699, 1, 699, 1, 699, 1, 699, 3, 699, 13713, 8, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 3, 699, 13720, 8, 699, 1, 700, 1, 700, 1, 700, 3, 700, 13725, 8, 700, 1, 700, 1, 700, 1, 700, 3, 700, 13730, 8, 700, 5, 700, 13732, 8, 700, 10, 700, 12, 700, 13735, 9, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 3, 700, 13745, 8, 700, 1, 701, 1, 701, 1, 701, 1, 701, 3, 701, 13751, 8, 701, 1, 701, 1, 701, 1, 701, 3, 701, 13756, 8, 701, 5, 701, 13758, 8, 701, 10, 701, 12, 701, 13761, 9, 701, 1, 701, 1, 701, 3, 701, 13765, 8, 701, 1, 701, 3, 701, 13768, 8, 701, 1, 701, 3, 701, 13771, 8, 701, 1, 702, 1, 702, 3, 702, 13775, 8, 702, 1, 702, 3, 702, 13778, 8, 702, 1, 702, 3, 702, 13781, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 3, 702, 13793, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 5, 702, 13800, 8, 702, 10, 702, 12, 702, 13803, 9, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 3, 702, 13810, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, 5, 702, 13816, 8, 702, 10, 702, 12, 702, 13819, 9, 702, 1, 702, 1, 702, 3, 702, 13823, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, 3, 702, 13829, 8, 702, 1, 703, 1, 703, 3, 703, 13833, 8, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 3, 703, 13840, 8, 703, 1, 703, 4, 703, 13843, 8, 703, 11, 703, 12, 703, 13844, 1, 703, 1, 703, 1, 703, 3, 703, 13850, 8, 703, 1, 703, 1, 703, 1, 703, 3, 703, 13855, 8, 703, 5, 703, 13857, 8, 703, 10, 703, 12, 703, 13860, 9, 703, 1, 703, 1, 703, 1, 703, 1, 703, 5, 703, 13866, 8, 703, 10, 703, 12, 703, 13869, 9, 703, 3, 703, 13871, 8, 703, 1, 704, 1, 704, 3, 704, 13875, 8, 704, 1, 704, 1, 704, 1, 705, 1, 705, 3, 705, 13881, 8, 705, 1, 705, 1, 705, 1, 705, 1, 705, 5, 705, 13887, 8, 705, 10, 705, 12, 705, 13890, 9, 705, 1, 705, 1, 705, 1, 705, 1, 705, 5, 705, 13896, 8, 705, 10, 705, 12, 705, 13899, 9, 705, 3, 705, 13901, 8, 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 3, 707, 13916, 8, 707, 1, 708, 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 5, 710, 13931, 8, 710, 10, 710, 12, 710, 13934, 9, 710, 1, 710, 1, 710, 1, 710, 3, 710, 13939, 8, 710, 1, 711, 1, 711, 3, 711, 13943, 8, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 3, 711, 13950, 8, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 3, 711, 13957, 8, 711, 1, 711, 3, 711, 13960, 8, 711, 3, 711, 13962, 8, 711, 1, 712, 1, 712, 1, 712, 1, 712, 3, 712, 13968, 8, 712, 3, 712, 13970, 8, 712, 1, 712, 3, 712, 13973, 8, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 3, 713, 13982, 8, 713, 1, 713, 3, 713, 13985, 8, 713, 1, 714, 1, 714, 3, 714, 13989, 8, 714, 1, 714, 1, 714, 1, 714, 1, 714, 3, 714, 13995, 8, 714, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 716, 1, 716, 1, 716, 3, 716, 14007, 8, 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 3, 717, 14017, 8, 717, 1, 717, 1, 717, 3, 717, 14021, 8, 717, 1, 717, 3, 717, 14024, 8, 717, 1, 717, 3, 717, 14027, 8, 717, 1, 717, 1, 717, 1, 717, 3, 717, 14032, 8, 717, 1, 717, 1, 717, 3, 717, 14036, 8, 717, 1, 717, 1, 717, 3, 717, 14040, 8, 717, 1, 717, 3, 717, 14043, 8, 717, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 14050, 8, 718, 1, 718, 3, 718, 14053, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 14060, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 14066, 8, 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 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, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 14094, 8, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 4, 721, 14102, 8, 721, 11, 721, 12, 721, 14103, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 14114, 8, 721, 3, 721, 14116, 8, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 14124, 8, 721, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 726, 1, 726, 1, 727, 1, 727, 1, 728, 1, 728, 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 3, 730, 14155, 8, 730, 1, 730, 1, 730, 1, 730, 3, 730, 14160, 8, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, 3, 733, 14174, 8, 733, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 3, 738, 14198, 8, 738, 1, 738, 3, 738, 14201, 8, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 3, 738, 14213, 8, 738, 1, 738, 3, 738, 14216, 8, 738, 1, 739, 1, 739, 1, 739, 1, 739, 3, 739, 14222, 8, 739, 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, 5, 741, 14238, 8, 741, 10, 741, 12, 741, 14241, 9, 741, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 3, 742, 14256, 8, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 3, 742, 14269, 8, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 5, 742, 14278, 8, 742, 10, 742, 12, 742, 14281, 9, 742, 1, 742, 4, 742, 14284, 8, 742, 11, 742, 12, 742, 14285, 1, 743, 1, 743, 1, 743, 1, 743, 5, 743, 14292, 8, 743, 10, 743, 12, 743, 14295, 9, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 3, 743, 14303, 8, 743, 1, 744, 1, 744, 3, 744, 14307, 8, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 3, 745, 14315, 8, 745, 1, 745, 1, 745, 1, 745, 1, 745, 5, 745, 14321, 8, 745, 10, 745, 12, 745, 14324, 9, 745, 1, 745, 1, 745, 1, 745, 3, 745, 14329, 8, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 3, 746, 14336, 8, 746, 1, 746, 1, 746, 3, 746, 14340, 8, 746, 1, 746, 1, 746, 3, 746, 14344, 8, 746, 3, 746, 14346, 8, 746, 1, 746, 3, 746, 14349, 8, 746, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 5, 747, 14357, 8, 747, 10, 747, 12, 747, 14360, 9, 747, 1, 747, 1, 747, 1, 747, 3, 747, 14365, 8, 747, 1, 748, 1, 748, 1, 748, 3, 748, 14370, 8, 748, 1, 749, 1, 749, 1, 749, 1, 749, 4, 749, 14376, 8, 749, 11, 749, 12, 749, 14377, 1, 750, 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 3, 751, 14389, 8, 751, 1, 751, 3, 751, 14392, 8, 751, 1, 752, 3, 752, 14395, 8, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 3, 752, 14405, 8, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 5, 752, 14412, 8, 752, 10, 752, 12, 752, 14415, 9, 752, 3, 752, 14417, 8, 752, 1, 752, 3, 752, 14420, 8, 752, 1, 753, 3, 753, 14423, 8, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 5, 753, 14432, 8, 753, 10, 753, 12, 753, 14435, 9, 753, 3, 753, 14437, 8, 753, 1, 754, 1, 754, 1, 754, 1, 754, 3, 754, 14443, 8, 754, 1, 754, 3, 754, 14446, 8, 754, 1, 755, 1, 755, 3, 755, 14450, 8, 755, 1, 755, 3, 755, 14453, 8, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 3, 755, 14466, 8, 755, 3, 755, 14468, 8, 755, 1, 755, 5, 755, 14471, 8, 755, 10, 755, 12, 755, 14474, 9, 755, 1, 755, 1, 755, 3, 755, 14478, 8, 755, 1, 756, 1, 756, 3, 756, 14482, 8, 756, 1, 756, 1, 756, 1, 756, 1, 756, 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, 3, 758, 14505, 8, 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, 3, 758, 14521, 8, 758, 1, 759, 1, 759, 1, 759, 3, 759, 14526, 8, 759, 1, 759, 1, 759, 3, 759, 14530, 8, 759, 1, 759, 1, 759, 3, 759, 14534, 8, 759, 1, 759, 1, 759, 3, 759, 14538, 8, 759, 1, 759, 3, 759, 14541, 8, 759, 1, 759, 1, 759, 1, 759, 3, 759, 14546, 8, 759, 3, 759, 14548, 8, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 5, 760, 14560, 8, 760, 10, 760, 12, 760, 14563, 9, 760, 1, 760, 1, 760, 3, 760, 14567, 8, 760, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, 3, 761, 14574, 8, 761, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 3, 762, 14585, 8, 762, 1, 762, 1, 762, 1, 762, 1, 762, 3, 762, 14591, 8, 762, 3, 762, 14593, 8, 762, 3, 762, 14595, 8, 762, 1, 763, 1, 763, 1, 763, 1, 763, 5, 763, 14601, 8, 763, 10, 763, 12, 763, 14604, 9, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 3, 763, 14612, 8, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 3, 763, 14620, 8, 763, 4, 763, 14622, 8, 763, 11, 763, 12, 763, 14623, 3, 763, 14626, 8, 763, 1, 764, 3, 764, 14629, 8, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 3, 765, 14647, 8, 765, 1, 765, 1, 765, 1, 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, 1, 766, 3, 766, 14665, 8, 766, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 3, 767, 14672, 8, 767, 1, 767, 1, 767, 3, 767, 14676, 8, 767, 1, 767, 3, 767, 14679, 8, 767, 1, 767, 3, 767, 14682, 8, 767, 3, 767, 14684, 8, 767, 1, 768, 1, 768, 1, 768, 3, 768, 14689, 8, 768, 1, 768, 1, 768, 3, 768, 14693, 8, 768, 3, 768, 14695, 8, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 3, 770, 14711, 8, 770, 1, 770, 1, 770, 3, 770, 14715, 8, 770, 1, 770, 3, 770, 14718, 8, 770, 1, 770, 1, 770, 1, 770, 3, 770, 14723, 8, 770, 1, 770, 3, 770, 14726, 8, 770, 1, 770, 3, 770, 14729, 8, 770, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 5, 771, 14738, 8, 771, 10, 771, 12, 771, 14741, 9, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 5, 771, 14749, 8, 771, 10, 771, 12, 771, 14752, 9, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 5, 771, 14761, 8, 771, 10, 771, 12, 771, 14764, 9, 771, 1, 771, 1, 771, 1, 771, 5, 771, 14769, 8, 771, 10, 771, 12, 771, 14772, 9, 771, 3, 771, 14774, 8, 771, 1, 771, 1, 771, 3, 771, 14778, 8, 771, 1, 771, 1, 771, 1, 771, 3, 771, 14783, 8, 771, 1, 772, 1, 772, 1, 772, 3, 772, 14788, 8, 772, 1, 772, 1, 772, 3, 772, 14792, 8, 772, 1, 772, 3, 772, 14795, 8, 772, 1, 772, 3, 772, 14798, 8, 772, 1, 772, 3, 772, 14801, 8, 772, 1, 772, 1, 772, 3, 772, 14805, 8, 772, 3, 772, 14807, 8, 772, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 3, 773, 14817, 8, 773, 1, 773, 1, 773, 3, 773, 14821, 8, 773, 1, 774, 1, 774, 1, 774, 3, 774, 14826, 8, 774, 1, 774, 1, 774, 1, 774, 3, 774, 14831, 8, 774, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 3, 775, 14838, 8, 775, 1, 775, 1, 775, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 14846, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 14852, 8, 776, 1, 776, 3, 776, 14855, 8, 776, 3, 776, 14857, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 5, 776, 14866, 8, 776, 10, 776, 12, 776, 14869, 9, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 3, 778, 14878, 8, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, 5, 779, 14887, 8, 779, 10, 779, 12, 779, 14890, 9, 779, 1, 779, 1, 779, 1, 779, 1, 779, 5, 779, 14896, 8, 779, 10, 779, 12, 779, 14899, 9, 779, 1, 779, 1, 779, 1, 779, 1, 779, 3, 779, 14905, 8, 779, 1, 779, 1, 779, 1, 779, 5, 779, 14910, 8, 779, 10, 779, 12, 779, 14913, 9, 779, 1, 779, 3, 779, 14916, 8, 779, 3, 779, 14918, 8, 779, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 14924, 8, 780, 1, 780, 1, 780, 1, 780, 1, 780, 5, 780, 14930, 8, 780, 10, 780, 12, 780, 14933, 9, 780, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 14939, 8, 780, 1, 780, 1, 780, 1, 780, 5, 780, 14944, 8, 780, 10, 780, 12, 780, 14947, 9, 780, 1, 780, 3, 780, 14950, 8, 780, 3, 780, 14952, 8, 780, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 4, 781, 14973, 8, 781, 11, 781, 12, 781, 14974, 1, 781, 3, 781, 14978, 8, 781, 1, 782, 1, 782, 1, 782, 1, 782, 3, 782, 14984, 8, 782, 1, 783, 1, 783, 1, 783, 1, 783, 3, 783, 14990, 8, 783, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 4, 784, 14998, 8, 784, 11, 784, 12, 784, 14999, 3, 784, 15002, 8, 784, 1, 785, 1, 785, 1, 785, 3, 785, 15007, 8, 785, 1, 785, 1, 785, 1, 785, 3, 785, 15012, 8, 785, 1, 785, 1, 785, 1, 785, 3, 785, 15017, 8, 785, 5, 785, 15019, 8, 785, 10, 785, 12, 785, 15022, 9, 785, 1, 785, 3, 785, 15025, 8, 785, 1, 786, 1, 786, 3, 786, 15029, 8, 786, 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 3, 788, 15041, 8, 788, 1, 789, 1, 789, 1, 789, 1, 789, 3, 789, 15047, 8, 789, 1, 789, 1, 789, 1, 789, 5, 789, 15052, 8, 789, 10, 789, 12, 789, 15055, 9, 789, 1, 790, 1, 790, 3, 790, 15059, 8, 790, 1, 790, 1, 790, 5, 790, 15063, 8, 790, 10, 790, 12, 790, 15066, 9, 790, 1, 791, 1, 791, 3, 791, 15070, 8, 791, 1, 791, 1, 791, 3, 791, 15074, 8, 791, 1, 791, 1, 791, 5, 791, 15078, 8, 791, 10, 791, 12, 791, 15081, 9, 791, 1, 792, 1, 792, 3, 792, 15085, 8, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 5, 792, 15092, 8, 792, 10, 792, 12, 792, 15095, 9, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 15103, 8, 792, 1, 792, 3, 792, 15106, 8, 792, 1, 792, 3, 792, 15109, 8, 792, 1, 792, 3, 792, 15112, 8, 792, 1, 792, 1, 792, 3, 792, 15116, 8, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 3, 793, 15126, 8, 793, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 3, 794, 15133, 8, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 4, 794, 15140, 8, 794, 11, 794, 12, 794, 15141, 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, 3, 797, 15152, 8, 797, 1, 797, 3, 797, 15155, 8, 797, 1, 797, 3, 797, 15158, 8, 797, 1, 797, 3, 797, 15161, 8, 797, 1, 797, 1, 797, 5, 797, 15165, 8, 797, 10, 797, 12, 797, 15168, 9, 797, 1, 797, 3, 797, 15171, 8, 797, 1, 798, 1, 798, 1, 798, 1, 798, 4, 798, 15177, 8, 798, 11, 798, 12, 798, 15178, 1, 798, 3, 798, 15182, 8, 798, 1, 798, 3, 798, 15185, 8, 798, 1, 799, 1, 799, 1, 799, 3, 799, 15190, 8, 799, 1, 800, 1, 800, 1, 800, 3, 800, 15195, 8, 800, 1, 801, 1, 801, 3, 801, 15199, 8, 801, 1, 801, 1, 801, 3, 801, 15203, 8, 801, 1, 802, 1, 802, 1, 802, 1, 802, 3, 802, 15209, 8, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, 806, 1, 807, 1, 807, 1, 808, 1, 808, 1, 808, 1, 808, 4, 808, 15235, 8, 808, 11, 808, 12, 808, 15236, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 5, 809, 15247, 8, 809, 10, 809, 12, 809, 15250, 9, 809, 1, 809, 1, 809, 3, 809, 15254, 8, 809, 1, 809, 1, 809, 1, 809, 5, 809, 15259, 8, 809, 10, 809, 12, 809, 15262, 9, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 5, 809, 15271, 8, 809, 10, 809, 12, 809, 15274, 9, 809, 1, 809, 1, 809, 3, 809, 15278, 8, 809, 1, 809, 1, 809, 1, 809, 5, 809, 15283, 8, 809, 10, 809, 12, 809, 15286, 9, 809, 1, 809, 1, 809, 3, 809, 15290, 8, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 3, 809, 15297, 8, 809, 1, 809, 1, 809, 3, 809, 15301, 8, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 5, 810, 15308, 8, 810, 10, 810, 12, 810, 15311, 9, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 5, 810, 15319, 8, 810, 10, 810, 12, 810, 15322, 9, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 3, 810, 15329, 8, 810, 1, 811, 1, 811, 3, 811, 15333, 8, 811, 1, 811, 1, 811, 1, 811, 3, 811, 15338, 8, 811, 1, 811, 3, 811, 15341, 8, 811, 1, 811, 1, 811, 1, 811, 3, 811, 15346, 8, 811, 1, 811, 5, 811, 15349, 8, 811, 10, 811, 12, 811, 15352, 9, 811, 1, 811, 3, 811, 15355, 8, 811, 1, 811, 3, 811, 15358, 8, 811, 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, 3, 813, 15366, 8, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 3, 813, 15373, 8, 813, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 15379, 8, 814, 1, 814, 1, 814, 1, 814, 3, 814, 15384, 8, 814, 5, 814, 15386, 8, 814, 10, 814, 12, 814, 15389, 9, 814, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 15395, 8, 814, 3, 814, 15397, 8, 814, 1, 814, 3, 814, 15400, 8, 814, 1, 815, 1, 815, 1, 815, 3, 815, 15405, 8, 815, 1, 815, 1, 815, 3, 815, 15409, 8, 815, 1, 816, 1, 816, 1, 816, 3, 816, 15414, 8, 816, 1, 816, 1, 816, 3, 816, 15418, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 15425, 8, 816, 1, 817, 1, 817, 3, 817, 15429, 8, 817, 1, 818, 1, 818, 1, 818, 3, 818, 15434, 8, 818, 1, 819, 1, 819, 1, 819, 1, 819, 3, 819, 15440, 8, 819, 1, 819, 3, 819, 15443, 8, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 5, 820, 15450, 8, 820, 10, 820, 12, 820, 15453, 9, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 5, 820, 15461, 8, 820, 10, 820, 12, 820, 15464, 9, 820, 1, 820, 4, 820, 15467, 8, 820, 11, 820, 12, 820, 15468, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 5, 820, 15480, 8, 820, 10, 820, 12, 820, 15483, 9, 820, 1, 820, 4, 820, 15486, 8, 820, 11, 820, 12, 820, 15487, 3, 820, 15490, 8, 820, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 3, 822, 15517, 8, 822, 1, 822, 3, 822, 15520, 8, 822, 1, 822, 1, 822, 1, 822, 4, 822, 15525, 8, 822, 11, 822, 12, 822, 15526, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 3, 823, 15549, 8, 823, 1, 823, 3, 823, 15552, 8, 823, 4, 823, 15554, 8, 823, 11, 823, 12, 823, 15555, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 3, 825, 15563, 8, 825, 3, 825, 15565, 8, 825, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 3, 826, 15573, 8, 826, 1, 827, 1, 827, 3, 827, 15577, 8, 827, 1, 827, 1, 827, 1, 827, 3, 827, 15582, 8, 827, 1, 827, 3, 827, 15585, 8, 827, 1, 827, 3, 827, 15588, 8, 827, 1, 827, 3, 827, 15591, 8, 827, 1, 828, 1, 828, 1, 829, 1, 829, 1, 829, 3, 829, 15598, 8, 829, 1, 829, 1, 829, 1, 829, 3, 829, 15603, 8, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 15611, 8, 830, 1, 830, 1, 830, 1, 830, 1, 830, 5, 830, 15617, 8, 830, 10, 830, 12, 830, 15620, 9, 830, 1, 830, 1, 830, 3, 830, 15624, 8, 830, 1, 830, 4, 830, 15627, 8, 830, 11, 830, 12, 830, 15628, 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, 4, 831, 15645, 8, 831, 11, 831, 12, 831, 15646, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 4, 831, 15660, 8, 831, 11, 831, 12, 831, 15661, 3, 831, 15664, 8, 831, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 3, 832, 15676, 8, 832, 1, 833, 1, 833, 1, 834, 1, 834, 1, 835, 1, 835, 1, 835, 3, 835, 15685, 8, 835, 1, 835, 1, 835, 3, 835, 15689, 8, 835, 3, 835, 15691, 8, 835, 1, 835, 3, 835, 15694, 8, 835, 1, 835, 3, 835, 15697, 8, 835, 1, 835, 1, 835, 1, 835, 3, 835, 15702, 8, 835, 1, 835, 1, 835, 3, 835, 15706, 8, 835, 1, 835, 1, 835, 3, 835, 15710, 8, 835, 1, 835, 4, 835, 15713, 8, 835, 11, 835, 12, 835, 15714, 1, 835, 3, 835, 15718, 8, 835, 1, 835, 3, 835, 15721, 8, 835, 1, 836, 1, 836, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 3, 837, 15731, 8, 837, 3, 837, 15733, 8, 837, 1, 837, 1, 837, 1, 837, 3, 837, 15738, 8, 837, 1, 838, 4, 838, 15741, 8, 838, 11, 838, 12, 838, 15742, 1, 838, 1, 838, 4, 838, 15747, 8, 838, 11, 838, 12, 838, 15748, 1, 838, 1, 838, 3, 838, 15753, 8, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 15760, 8, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 15783, 8, 839, 1, 840, 1, 840, 1, 840, 1, 840, 3, 840, 15789, 8, 840, 3, 840, 15791, 8, 840, 1, 840, 3, 840, 15794, 8, 840, 1, 840, 3, 840, 15797, 8, 840, 1, 840, 3, 840, 15800, 8, 840, 1, 840, 3, 840, 15803, 8, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 3, 840, 15811, 8, 840, 3, 840, 15813, 8, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 3, 840, 15822, 8, 840, 3, 840, 15824, 8, 840, 1, 840, 5, 840, 15827, 8, 840, 10, 840, 12, 840, 15830, 9, 840, 1, 840, 3, 840, 15833, 8, 840, 1, 841, 1, 841, 1, 841, 3, 841, 15838, 8, 841, 3, 841, 15840, 8, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 3, 841, 15847, 8, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 3, 842, 15855, 8, 842, 3, 842, 15857, 8, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 5, 842, 15864, 8, 842, 10, 842, 12, 842, 15867, 9, 842, 1, 842, 3, 842, 15870, 8, 842, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 15883, 8, 844, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 15889, 8, 845, 1, 845, 3, 845, 15892, 8, 845, 1, 845, 3, 845, 15895, 8, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 4, 845, 15907, 8, 845, 11, 845, 12, 845, 15908, 1, 845, 1, 845, 3, 845, 15913, 8, 845, 1, 845, 1, 845, 3, 845, 15917, 8, 845, 1, 845, 3, 845, 15920, 8, 845, 1, 846, 1, 846, 1, 847, 3, 847, 15925, 8, 847, 1, 847, 1, 847, 1, 847, 3, 847, 15930, 8, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 15937, 8, 847, 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 15943, 8, 847, 1, 848, 1, 848, 3, 848, 15947, 8, 848, 1, 849, 1, 849, 1, 849, 1, 849, 3, 849, 15953, 8, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 5, 851, 15964, 8, 851, 10, 851, 12, 851, 15967, 9, 851, 1, 851, 3, 851, 15970, 8, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 3, 851, 15977, 8, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 5, 851, 15989, 8, 851, 10, 851, 12, 851, 15992, 9, 851, 1, 851, 1, 851, 3, 851, 15996, 8, 851, 1, 851, 1, 851, 3, 851, 16000, 8, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 4, 851, 16009, 8, 851, 11, 851, 12, 851, 16010, 3, 851, 16013, 8, 851, 1, 852, 1, 852, 1, 853, 1, 853, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 5, 854, 16027, 8, 854, 10, 854, 12, 854, 16030, 9, 854, 1, 854, 1, 854, 1, 854, 1, 854, 3, 854, 16036, 8, 854, 1, 854, 3, 854, 16039, 8, 854, 1, 854, 1, 854, 3, 854, 16043, 8, 854, 1, 854, 3, 854, 16046, 8, 854, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 3, 855, 16053, 8, 855, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 3, 856, 16060, 8, 856, 1, 857, 1, 857, 1, 857, 3, 857, 16065, 8, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 3, 857, 16072, 8, 857, 3, 857, 16074, 8, 857, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 3, 858, 16081, 8, 858, 1, 859, 1, 859, 3, 859, 16085, 8, 859, 3, 859, 16087, 8, 859, 1, 859, 1, 859, 1, 859, 1, 859, 4, 859, 16093, 8, 859, 11, 859, 12, 859, 16094, 3, 859, 16097, 8, 859, 1, 859, 1, 859, 1, 860, 1, 860, 1, 860, 1, 861, 1, 861, 3, 861, 16106, 8, 861, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 863, 1, 863, 1, 863, 3, 863, 16116, 8, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 3, 863, 16127, 8, 863, 3, 863, 16129, 8, 863, 1, 863, 3, 863, 16132, 8, 863, 1, 863, 1, 863, 3, 863, 16136, 8, 863, 1, 863, 3, 863, 16139, 8, 863, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 5, 865, 16152, 8, 865, 10, 865, 12, 865, 16155, 9, 865, 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 3, 866, 16163, 8, 866, 1, 866, 1, 866, 3, 866, 16167, 8, 866, 1, 866, 3, 866, 16170, 8, 866, 1, 866, 1, 866, 3, 866, 16174, 8, 866, 1, 866, 3, 866, 16177, 8, 866, 3, 866, 16179, 8, 866, 1, 867, 1, 867, 3, 867, 16183, 8, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 3, 867, 16190, 8, 867, 1, 868, 1, 868, 5, 868, 16194, 8, 868, 10, 868, 12, 868, 16197, 9, 868, 1, 868, 3, 868, 16200, 8, 868, 1, 868, 3, 868, 16203, 8, 868, 1, 869, 1, 869, 1, 869, 1, 870, 4, 870, 16209, 8, 870, 11, 870, 12, 870, 16210, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 3, 871, 16224, 8, 871, 1, 872, 1, 872, 3, 872, 16228, 8, 872, 1, 872, 1, 872, 3, 872, 16232, 8, 872, 1, 872, 3, 872, 16235, 8, 872, 1, 872, 3, 872, 16238, 8, 872, 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 3, 873, 16251, 8, 873, 1, 873, 1, 873, 3, 873, 16255, 8, 873, 1, 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 5, 874, 16265, 8, 874, 10, 874, 12, 874, 16268, 9, 874, 1, 874, 1, 874, 3, 874, 16272, 8, 874, 1, 874, 1, 874, 3, 874, 16276, 8, 874, 1, 874, 1, 874, 3, 874, 16280, 8, 874, 1, 874, 1, 874, 1, 875, 1, 875, 3, 875, 16286, 8, 875, 1, 875, 3, 875, 16289, 8, 875, 1, 875, 3, 875, 16292, 8, 875, 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, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 16319, 8, 877, 1, 877, 1, 877, 4, 877, 16323, 8, 877, 11, 877, 12, 877, 16324, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 16334, 8, 877, 1, 877, 1, 877, 1, 877, 3, 877, 16339, 8, 877, 1, 877, 1, 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 5, 878, 16348, 8, 878, 10, 878, 12, 878, 16351, 9, 878, 1, 878, 1, 878, 1, 879, 1, 879, 3, 879, 16357, 8, 879, 1, 879, 1, 879, 3, 879, 16361, 8, 879, 1, 879, 3, 879, 16364, 8, 879, 1, 880, 1, 880, 1, 880, 1, 880, 3, 880, 16370, 8, 880, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 3, 881, 16379, 8, 881, 1, 881, 1, 881, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 3, 882, 16388, 8, 882, 1, 882, 3, 882, 16391, 8, 882, 1, 883, 1, 883, 3, 883, 16395, 8, 883, 1, 883, 1, 883, 1, 883, 1, 884, 1, 884, 3, 884, 16402, 8, 884, 1, 884, 3, 884, 16405, 8, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 3, 884, 16414, 8, 884, 1, 885, 5, 885, 16417, 8, 885, 10, 885, 12, 885, 16420, 9, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 4, 885, 16427, 8, 885, 11, 885, 12, 885, 16428, 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, 3, 887, 16454, 8, 887, 1, 888, 1, 888, 3, 888, 16458, 8, 888, 1, 888, 1, 888, 1, 888, 1, 889, 1, 889, 3, 889, 16465, 8, 889, 1, 889, 1, 889, 3, 889, 16469, 8, 889, 1, 890, 1, 890, 3, 890, 16473, 8, 890, 1, 890, 1, 890, 3, 890, 16477, 8, 890, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 5, 892, 16487, 8, 892, 10, 892, 12, 892, 16490, 9, 892, 1, 892, 3, 892, 16493, 8, 892, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 894, 1, 894, 1, 894, 1, 895, 3, 895, 16507, 8, 895, 1, 895, 1, 895, 1, 895, 1, 895, 3, 895, 16513, 8, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 3, 895, 16520, 8, 895, 1, 896, 1, 896, 1, 896, 3, 896, 16525, 8, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 3, 896, 16536, 8, 896, 1, 896, 3, 896, 16539, 8, 896, 1, 896, 1, 896, 1, 896, 1, 896, 3, 896, 16545, 8, 896, 3, 896, 16547, 8, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 3, 897, 16555, 8, 897, 1, 897, 1, 897, 3, 897, 16559, 8, 897, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 3, 898, 16569, 8, 898, 1, 898, 1, 898, 1, 898, 3, 898, 16574, 8, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 900, 1, 900, 1, 901, 1, 901, 1, 902, 1, 902, 1, 903, 1, 903, 3, 903, 16589, 8, 903, 1, 904, 1, 904, 3, 904, 16593, 8, 904, 1, 905, 3, 905, 16596, 8, 905, 1, 905, 1, 905, 3, 905, 16600, 8, 905, 1, 905, 1, 905, 1, 905, 3, 905, 16605, 8, 905, 5, 905, 16607, 8, 905, 10, 905, 12, 905, 16610, 9, 905, 1, 905, 1, 905, 3, 905, 16614, 8, 905, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 5, 907, 16628, 8, 907, 10, 907, 12, 907, 16631, 9, 907, 1, 907, 1, 907, 3, 907, 16635, 8, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 3, 909, 16644, 8, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 4, 909, 16653, 8, 909, 11, 909, 12, 909, 16654, 1, 910, 1, 910, 1, 910, 1, 910, 4, 910, 16661, 8, 910, 11, 910, 12, 910, 16662, 3, 910, 16665, 8, 910, 1, 910, 1, 910, 3, 910, 16669, 8, 910, 1, 911, 1, 911, 1, 911, 1, 911, 5, 911, 16675, 8, 911, 10, 911, 12, 911, 16678, 9, 911, 1, 911, 1, 911, 1, 911, 1, 912, 1, 912, 5, 912, 16685, 8, 912, 10, 912, 12, 912, 16688, 9, 912, 3, 912, 16690, 8, 912, 1, 912, 1, 912, 1, 913, 5, 913, 16695, 8, 913, 10, 913, 12, 913, 16698, 9, 913, 1, 913, 1, 913, 1, 914, 1, 914, 5, 914, 16704, 8, 914, 10, 914, 12, 914, 16707, 9, 914, 3, 914, 16709, 8, 914, 1, 914, 1, 914, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 3, 915, 16718, 8, 915, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 3, 916, 16725, 8, 916, 1, 916, 1, 916, 3, 916, 16729, 8, 916, 1, 916, 3, 916, 16732, 8, 916, 1, 917, 1, 917, 1, 917, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 3, 918, 16744, 8, 918, 1, 919, 1, 919, 1, 919, 1, 919, 3, 919, 16750, 8, 919, 1, 920, 1, 920, 1, 920, 1, 921, 1, 921, 1, 921, 1, 921, 3, 921, 16759, 8, 921, 1, 921, 3, 921, 16762, 8, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 5, 922, 16770, 8, 922, 10, 922, 12, 922, 16773, 9, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 5, 922, 16781, 8, 922, 10, 922, 12, 922, 16784, 9, 922, 1, 922, 1, 922, 1, 922, 3, 922, 16789, 8, 922, 3, 922, 16791, 8, 922, 3, 922, 16793, 8, 922, 1, 923, 1, 923, 3, 923, 16797, 8, 923, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 3, 924, 16804, 8, 924, 1, 924, 3, 924, 16807, 8, 924, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 3, 925, 16814, 8, 925, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 3, 926, 16825, 8, 926, 1, 926, 1, 926, 1, 926, 1, 926, 3, 926, 16831, 8, 926, 1, 926, 1, 926, 3, 926, 16835, 8, 926, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 5, 927, 16843, 8, 927, 10, 927, 12, 927, 16846, 9, 927, 3, 927, 16848, 8, 927, 1, 927, 1, 927, 1, 928, 1, 928, 3, 928, 16854, 8, 928, 1, 928, 3, 928, 16857, 8, 928, 1, 928, 1, 928, 1, 928, 3, 928, 16862, 8, 928, 1, 928, 1, 928, 1, 928, 1, 928, 3, 928, 16868, 8, 928, 1, 928, 1, 928, 1, 928, 3, 928, 16873, 8, 928, 3, 928, 16875, 8, 928, 1, 929, 1, 929, 1, 929, 5, 929, 16880, 8, 929, 10, 929, 12, 929, 16883, 9, 929, 1, 930, 1, 930, 3, 930, 16887, 8, 930, 1, 930, 1, 930, 3, 930, 16891, 8, 930, 1, 930, 1, 930, 1, 930, 3, 930, 16896, 8, 930, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 5, 932, 16908, 8, 932, 10, 932, 12, 932, 16911, 9, 932, 1, 932, 1, 932, 3, 932, 16915, 8, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 3, 932, 16922, 8, 932, 3, 932, 16924, 8, 932, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 3, 933, 16932, 8, 933, 1, 933, 1, 933, 3, 933, 16936, 8, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 3, 933, 16944, 8, 933, 1, 934, 3, 934, 16947, 8, 934, 1, 934, 1, 934, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 5, 935, 16956, 8, 935, 10, 935, 12, 935, 16959, 9, 935, 1, 936, 1, 936, 1, 936, 5, 936, 16964, 8, 936, 10, 936, 12, 936, 16967, 9, 936, 1, 936, 1, 936, 1, 936, 5, 936, 16972, 8, 936, 10, 936, 12, 936, 16975, 9, 936, 1, 936, 1, 936, 1, 936, 4, 936, 16980, 8, 936, 11, 936, 12, 936, 16981, 1, 936, 1, 936, 1, 936, 5, 936, 16987, 8, 936, 10, 936, 12, 936, 16990, 9, 936, 3, 936, 16992, 8, 936, 3, 936, 16994, 8, 936, 1, 937, 1, 937, 3, 937, 16998, 8, 937, 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, 3, 938, 17012, 8, 938, 1, 938, 3, 938, 17015, 8, 938, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 3, 939, 17023, 8, 939, 1, 939, 3, 939, 17026, 8, 939, 1, 939, 1, 939, 3, 939, 17030, 8, 939, 1, 939, 1, 939, 3, 939, 17034, 8, 939, 1, 939, 1, 939, 1, 939, 3, 939, 17039, 8, 939, 1, 939, 3, 939, 17042, 8, 939, 1, 939, 1, 939, 3, 939, 17046, 8, 939, 1, 939, 1, 939, 3, 939, 17050, 8, 939, 5, 939, 17052, 8, 939, 10, 939, 12, 939, 17055, 9, 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, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 942, 1, 942, 1, 942, 3, 942, 17080, 8, 942, 1, 942, 3, 942, 17083, 8, 942, 1, 942, 3, 942, 17086, 8, 942, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 5, 943, 17093, 8, 943, 10, 943, 12, 943, 17096, 9, 943, 1, 943, 1, 943, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 5, 944, 17106, 8, 944, 10, 944, 12, 944, 17109, 9, 944, 1, 944, 1, 944, 1, 945, 1, 945, 3, 945, 17115, 8, 945, 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 5, 946, 17126, 8, 946, 10, 946, 12, 946, 17129, 9, 946, 1, 946, 1, 946, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 948, 1, 948, 5, 948, 17141, 8, 948, 10, 948, 12, 948, 17144, 9, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 3, 949, 17151, 8, 949, 1, 950, 1, 950, 3, 950, 17155, 8, 950, 1, 950, 1, 950, 3, 950, 17159, 8, 950, 1, 950, 1, 950, 1, 951, 1, 951, 3, 951, 17165, 8, 951, 1, 951, 1, 951, 3, 951, 17169, 8, 951, 1, 951, 3, 951, 17172, 8, 951, 1, 951, 3, 951, 17175, 8, 951, 1, 951, 1, 951, 5, 951, 17179, 8, 951, 10, 951, 12, 951, 17182, 9, 951, 1, 951, 3, 951, 17185, 8, 951, 1, 951, 3, 951, 17188, 8, 951, 1, 951, 3, 951, 17191, 8, 951, 1, 951, 3, 951, 17194, 8, 951, 1, 952, 1, 952, 1, 952, 1, 952, 5, 952, 17200, 8, 952, 10, 952, 12, 952, 17203, 9, 952, 3, 952, 17205, 8, 952, 1, 953, 1, 953, 1, 953, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 3, 954, 17216, 8, 954, 3, 954, 17218, 8, 954, 1, 955, 1, 955, 1, 955, 5, 955, 17223, 8, 955, 10, 955, 12, 955, 17226, 9, 955, 1, 956, 1, 956, 5, 956, 17230, 8, 956, 10, 956, 12, 956, 17233, 9, 956, 1, 956, 1, 956, 3, 956, 17237, 8, 956, 1, 957, 1, 957, 5, 957, 17241, 8, 957, 10, 957, 12, 957, 17244, 9, 957, 1, 957, 1, 957, 3, 957, 17248, 8, 957, 1, 958, 1, 958, 1, 958, 3, 958, 17253, 8, 958, 1, 958, 1, 958, 1, 958, 5, 958, 17258, 8, 958, 10, 958, 12, 958, 17261, 9, 958, 1, 958, 1, 958, 1, 958, 3, 958, 17266, 8, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 3, 958, 17273, 8, 958, 1, 959, 3, 959, 17276, 8, 959, 1, 959, 3, 959, 17279, 8, 959, 1, 959, 1, 959, 3, 959, 17283, 8, 959, 1, 959, 1, 959, 1, 959, 3, 959, 17288, 8, 959, 1, 959, 1, 959, 5, 959, 17292, 8, 959, 10, 959, 12, 959, 17295, 9, 959, 1, 959, 1, 959, 1, 959, 3, 959, 17300, 8, 959, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, 961, 1, 962, 1, 962, 3, 962, 17310, 8, 962, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 3, 963, 17317, 8, 963, 1, 963, 1, 963, 3, 963, 17321, 8, 963, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 3, 964, 17331, 8, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 3, 964, 17346, 8, 964, 3, 964, 17348, 8, 964, 1, 965, 1, 965, 3, 965, 17352, 8, 965, 1, 965, 1, 965, 1, 965, 1, 965, 5, 965, 17358, 8, 965, 10, 965, 12, 965, 17361, 9, 965, 1, 965, 1, 965, 1, 965, 1, 965, 3, 965, 17367, 8, 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 3, 966, 17375, 8, 966, 1, 966, 3, 966, 17378, 8, 966, 1, 967, 1, 967, 1, 967, 3, 967, 17383, 8, 967, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 5, 968, 17391, 8, 968, 10, 968, 12, 968, 17394, 9, 968, 1, 968, 1, 968, 1, 968, 5, 968, 17399, 8, 968, 10, 968, 12, 968, 17402, 9, 968, 3, 968, 17404, 8, 968, 1, 968, 1, 968, 1, 969, 1, 969, 3, 969, 17410, 8, 969, 1, 970, 1, 970, 1, 970, 3, 970, 17415, 8, 970, 1, 970, 3, 970, 17418, 8, 970, 1, 971, 1, 971, 1, 971, 3, 971, 17423, 8, 971, 1, 971, 1, 971, 1, 971, 3, 971, 17428, 8, 971, 1, 971, 1, 971, 1, 971, 1, 971, 3, 971, 17434, 8, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 5, 972, 17441, 8, 972, 10, 972, 12, 972, 17444, 9, 972, 1, 972, 1, 972, 1, 973, 1, 973, 3, 973, 17450, 8, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 5, 973, 17458, 8, 973, 10, 973, 12, 973, 17461, 9, 973, 1, 973, 1, 973, 3, 973, 17465, 8, 973, 3, 973, 17467, 8, 973, 1, 974, 1, 974, 1, 974, 3, 974, 17472, 8, 974, 1, 974, 1, 974, 3, 974, 17476, 8, 974, 1, 974, 1, 974, 1, 974, 1, 974, 3, 974, 17482, 8, 974, 1, 974, 1, 974, 3, 974, 17486, 8, 974, 1, 975, 1, 975, 1, 975, 1, 975, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 5, 976, 17497, 8, 976, 10, 976, 12, 976, 17500, 9, 976, 1, 976, 3, 976, 17503, 8, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 5, 976, 17511, 8, 976, 10, 976, 12, 976, 17514, 9, 976, 3, 976, 17516, 8, 976, 3, 976, 17518, 8, 976, 1, 977, 1, 977, 1, 977, 3, 977, 17523, 8, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 5, 978, 17530, 8, 978, 10, 978, 12, 978, 17533, 9, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 5, 979, 17543, 8, 979, 10, 979, 12, 979, 17546, 9, 979, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 3, 980, 17553, 8, 980, 1, 980, 1, 980, 3, 980, 17557, 8, 980, 1, 981, 1, 981, 1, 981, 1, 982, 1, 982, 5, 982, 17564, 8, 982, 10, 982, 12, 982, 17567, 9, 982, 1, 982, 3, 982, 17570, 8, 982, 1, 982, 5, 982, 17573, 8, 982, 10, 982, 12, 982, 17576, 9, 982, 1, 982, 1, 982, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 3, 983, 17586, 8, 983, 3, 983, 17588, 8, 983, 1, 984, 1, 984, 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 5, 985, 17602, 8, 985, 10, 985, 12, 985, 17605, 9, 985, 1, 986, 1, 986, 3, 986, 17609, 8, 986, 1, 986, 1, 986, 5, 986, 17613, 8, 986, 10, 986, 12, 986, 17616, 9, 986, 1, 986, 1, 986, 1, 987, 3, 987, 17621, 8, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 988, 1, 988, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 5, 989, 17637, 8, 989, 10, 989, 12, 989, 17640, 9, 989, 1, 989, 1, 989, 1, 990, 1, 990, 3, 990, 17646, 8, 990, 1, 990, 3, 990, 17649, 8, 990, 1, 991, 3, 991, 17652, 8, 991, 1, 991, 1, 991, 1, 991, 1, 991, 5, 991, 17658, 8, 991, 10, 991, 12, 991, 17661, 9, 991, 3, 991, 17663, 8, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 992, 1, 992, 3, 992, 17671, 8, 992, 3, 992, 17673, 8, 992, 1, 992, 1, 992, 3, 992, 17677, 8, 992, 1, 992, 3, 992, 17680, 8, 992, 1, 993, 1, 993, 1, 993, 3, 993, 17685, 8, 993, 3, 993, 17687, 8, 993, 1, 993, 1, 993, 3, 993, 17691, 8, 993, 1, 993, 1, 993, 1, 993, 1, 994, 1, 994, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 3, 995, 17703, 8, 995, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 997, 1, 997, 3, 997, 17712, 8, 997, 1, 997, 1, 997, 1, 997, 1, 997, 5, 997, 17718, 8, 997, 10, 997, 12, 997, 17721, 9, 997, 1, 998, 1, 998, 3, 998, 17725, 8, 998, 1, 998, 1, 998, 3, 998, 17729, 8, 998, 1, 999, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 3, 1000, 17739, 8, 1000, 3, 1000, 17741, 8, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 3, 1000, 17747, 8, 1000, 1, 1001, 1, 1001, 1, 1001, 3, 1001, 17752, 8, 1001, 1, 1001, 3, 1001, 17755, 8, 1001, 1, 1002, 1, 1002, 1, 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 3, 1003, 17765, 8, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 3, 1004, 17771, 8, 1004, 1, 1004, 3, 1004, 17774, 8, 1004, 1, 1004, 3, 1004, 17777, 8, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 5, 1005, 17783, 8, 1005, 10, 1005, 12, 1005, 17786, 9, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 17795, 8, 1005, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 3, 1006, 17805, 8, 1006, 1, 1007, 1, 1007, 3, 1007, 17809, 8, 1007, 1, 1007, 1, 1007, 3, 1007, 17813, 8, 1007, 1, 1007, 3, 1007, 17816, 8, 1007, 1, 1007, 3, 1007, 17819, 8, 1007, 1, 1008, 1, 1008, 1, 1008, 3, 1008, 17824, 8, 1008, 1, 1009, 1, 1009, 1, 1009, 3, 1009, 17829, 8, 1009, 1, 1009, 3, 1009, 17832, 8, 1009, 1, 1009, 3, 1009, 17835, 8, 1009, 1, 1010, 1, 1010, 4, 1010, 17839, 8, 1010, 11, 1010, 12, 1010, 17840, 1, 1010, 3, 1010, 17844, 8, 1010, 1, 1010, 1, 1010, 1, 1011, 1, 1011, 3, 1011, 17850, 8, 1011, 1, 1011, 3, 1011, 17853, 8, 1011, 1, 1012, 3, 1012, 17856, 8, 1012, 1, 1012, 4, 1012, 17859, 8, 1012, 11, 1012, 12, 1012, 17860, 1, 1012, 3, 1012, 17864, 8, 1012, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 4, 1013, 17870, 8, 1013, 11, 1013, 12, 1013, 17871, 1, 1014, 1, 1014, 4, 1014, 17876, 8, 1014, 11, 1014, 12, 1014, 17877, 1, 1015, 1, 1015, 1, 1015, 3, 1015, 17883, 8, 1015, 1, 1015, 3, 1015, 17886, 8, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 3, 1016, 17895, 8, 1016, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 3, 1017, 17908, 8, 1017, 1, 1017, 1, 1017, 3, 1017, 17912, 8, 1017, 3, 1017, 17914, 8, 1017, 1, 1017, 3, 1017, 17917, 8, 1017, 1, 1017, 3, 1017, 17920, 8, 1017, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 5, 1018, 17930, 8, 1018, 10, 1018, 12, 1018, 17933, 9, 1018, 1, 1018, 3, 1018, 17936, 8, 1018, 1, 1018, 3, 1018, 17939, 8, 1018, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1020, 1, 1020, 1, 1020, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 3, 1021, 17954, 8, 1021, 1, 1021, 1, 1021, 3, 1021, 17958, 8, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 3, 1022, 17970, 8, 1022, 1, 1022, 3, 1022, 17973, 8, 1022, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 5, 1023, 17980, 8, 1023, 10, 1023, 12, 1023, 17983, 9, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 3, 1023, 17989, 8, 1023, 1, 1024, 1, 1024, 1, 1024, 3, 1024, 17994, 8, 1024, 1, 1025, 1, 1025, 3, 1025, 17998, 8, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 18006, 8, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 18012, 8, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 3, 1027, 18020, 8, 1027, 1, 1027, 3, 1027, 18023, 8, 1027, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1029, 3, 1029, 18032, 8, 1029, 1, 1029, 3, 1029, 18035, 8, 1029, 1, 1029, 3, 1029, 18038, 8, 1029, 1, 1030, 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 3, 1031, 18047, 8, 1031, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18053, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18059, 8, 1032, 1, 1032, 3, 1032, 18062, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18067, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18073, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18085, 8, 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 3, 1033, 18096, 8, 1033, 3, 1033, 18098, 8, 1033, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 3, 1034, 18107, 8, 1034, 3, 1034, 18109, 8, 1034, 1, 1035, 1, 1035, 3, 1035, 18113, 8, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 3, 1035, 18119, 8, 1035, 1, 1035, 1, 1035, 3, 1035, 18123, 8, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 3, 1037, 18136, 8, 1037, 1, 1038, 1, 1038, 1, 1038, 5, 1038, 18141, 8, 1038, 10, 1038, 12, 1038, 18144, 9, 1038, 1, 1039, 1, 1039, 3, 1039, 18148, 8, 1039, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 5, 1041, 18164, 8, 1041, 10, 1041, 12, 1041, 18167, 9, 1041, 1, 1042, 3, 1042, 18170, 8, 1042, 1, 1042, 1, 1042, 3, 1042, 18174, 8, 1042, 1, 1043, 1, 1043, 3, 1043, 18178, 8, 1043, 1, 1043, 1, 1043, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 3, 1044, 18191, 8, 1044, 1, 1044, 1, 1044, 3, 1044, 18195, 8, 1044, 1, 1044, 1, 1044, 1, 1044, 5, 1044, 18200, 8, 1044, 10, 1044, 12, 1044, 18203, 9, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 3, 1044, 18210, 8, 1044, 1, 1044, 3, 1044, 18213, 8, 1044, 1, 1044, 1, 1044, 1, 1044, 3, 1044, 18218, 8, 1044, 3, 1044, 18220, 8, 1044, 1, 1045, 1, 1045, 1, 1045, 3, 1045, 18225, 8, 1045, 1, 1045, 1, 1045, 3, 1045, 18229, 8, 1045, 1, 1045, 3, 1045, 18232, 8, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 3, 1045, 18238, 8, 1045, 1, 1045, 5, 1045, 18241, 8, 1045, 10, 1045, 12, 1045, 18244, 9, 1045, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 3, 1046, 18255, 8, 1046, 1, 1046, 1, 1046, 5, 1046, 18259, 8, 1046, 10, 1046, 12, 1046, 18262, 9, 1046, 1, 1047, 1, 1047, 3, 1047, 18266, 8, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 3, 1047, 18276, 8, 1047, 3, 1047, 18278, 8, 1047, 3, 1047, 18280, 8, 1047, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 3, 1048, 18290, 8, 1048, 1, 1048, 1, 1048, 3, 1048, 18294, 8, 1048, 3, 1048, 18296, 8, 1048, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 5, 1049, 18306, 8, 1049, 10, 1049, 12, 1049, 18309, 9, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 3, 1049, 18316, 8, 1049, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 18329, 8, 1051, 1, 1051, 3, 1051, 18332, 8, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 18337, 8, 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, 5, 1051, 18355, 8, 1051, 10, 1051, 12, 1051, 18358, 9, 1051, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 18365, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 18373, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 18380, 8, 1052, 1, 1052, 1, 1052, 3, 1052, 18384, 8, 1052, 1, 1053, 3, 1053, 18387, 8, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 3, 1053, 18394, 8, 1053, 1, 1054, 1, 1054, 3, 1054, 18398, 8, 1054, 1, 1054, 1, 1054, 1, 1054, 3, 1054, 18403, 8, 1054, 5, 1054, 18405, 8, 1054, 10, 1054, 12, 1054, 18408, 9, 1054, 1, 1054, 1, 1054, 1, 1054, 5, 1054, 18413, 8, 1054, 10, 1054, 12, 1054, 18416, 9, 1054, 1, 1054, 3, 1054, 18419, 8, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18426, 8, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18431, 8, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18440, 8, 1055, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 3, 1056, 18449, 8, 1056, 1, 1056, 3, 1056, 18452, 8, 1056, 1, 1056, 1, 1056, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 3, 1057, 18472, 8, 1057, 3, 1057, 18474, 8, 1057, 3, 1057, 18476, 8, 1057, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 3, 1058, 18484, 8, 1058, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 3, 1059, 18501, 8, 1059, 3, 1059, 18503, 8, 1059, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 5, 1060, 18511, 8, 1060, 10, 1060, 12, 1060, 18514, 9, 1060, 1, 1061, 1, 1061, 3, 1061, 18518, 8, 1061, 1, 1062, 3, 1062, 18521, 8, 1062, 1, 1062, 1, 1062, 1, 1062, 4, 1062, 18526, 8, 1062, 11, 1062, 12, 1062, 18527, 1, 1062, 3, 1062, 18531, 8, 1062, 1, 1062, 1, 1062, 3, 1062, 18535, 8, 1062, 1, 1062, 3, 1062, 18538, 8, 1062, 1, 1063, 3, 1063, 18541, 8, 1063, 1, 1063, 1, 1063, 4, 1063, 18545, 8, 1063, 11, 1063, 12, 1063, 18546, 1, 1063, 3, 1063, 18550, 8, 1063, 1, 1063, 1, 1063, 3, 1063, 18554, 8, 1063, 1, 1063, 3, 1063, 18557, 8, 1063, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1065, 1, 1065, 1, 1065, 1, 1066, 1, 1066, 3, 1066, 18569, 8, 1066, 1, 1067, 1, 1067, 1, 1067, 4, 1067, 18574, 8, 1067, 11, 1067, 12, 1067, 18575, 1, 1067, 3, 1067, 18579, 8, 1067, 1, 1067, 1, 1067, 3, 1067, 18583, 8, 1067, 1, 1068, 1, 1068, 4, 1068, 18587, 8, 1068, 11, 1068, 12, 1068, 18588, 1, 1068, 3, 1068, 18592, 8, 1068, 1, 1068, 1, 1068, 3, 1068, 18596, 8, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 3, 1071, 18611, 8, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 5, 1071, 18617, 8, 1071, 10, 1071, 12, 1071, 18620, 9, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 3, 1071, 18626, 8, 1071, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 5, 1072, 18637, 8, 1072, 10, 1072, 12, 1072, 18640, 9, 1072, 1, 1072, 1, 1072, 3, 1072, 18644, 8, 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18653, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18662, 8, 1073, 1, 1073, 1, 1073, 3, 1073, 18666, 8, 1073, 1, 1073, 1, 1073, 3, 1073, 18670, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18696, 8, 1073, 1, 1073, 3, 1073, 18699, 8, 1073, 1, 1073, 3, 1073, 18702, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18712, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18720, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18726, 8, 1073, 3, 1073, 18728, 8, 1073, 1, 1073, 1, 1073, 3, 1073, 18732, 8, 1073, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18739, 8, 1074, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 5, 1075, 18746, 8, 1075, 10, 1075, 12, 1075, 18749, 9, 1075, 1, 1075, 3, 1075, 18752, 8, 1075, 1, 1075, 3, 1075, 18755, 8, 1075, 1, 1075, 3, 1075, 18758, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18767, 8, 1075, 1, 1075, 3, 1075, 18770, 8, 1075, 1, 1075, 3, 1075, 18773, 8, 1075, 1, 1075, 3, 1075, 18776, 8, 1075, 1, 1075, 3, 1075, 18779, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18791, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18799, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18806, 8, 1075, 1, 1075, 3, 1075, 18809, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18813, 8, 1075, 3, 1075, 18815, 8, 1075, 1, 1075, 3, 1075, 18818, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18823, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18832, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18838, 8, 1075, 1, 1075, 3, 1075, 18841, 8, 1075, 1, 1075, 3, 1075, 18844, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18853, 8, 1075, 1, 1075, 3, 1075, 18856, 8, 1075, 1, 1075, 3, 1075, 18859, 8, 1075, 1, 1075, 3, 1075, 18862, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18868, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18872, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 5, 1075, 18882, 8, 1075, 10, 1075, 12, 1075, 18885, 9, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18894, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18898, 8, 1075, 1, 1075, 3, 1075, 18901, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18907, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18911, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18917, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18921, 8, 1075, 1, 1075, 3, 1075, 18924, 8, 1075, 1, 1075, 3, 1075, 18927, 8, 1075, 3, 1075, 18929, 8, 1075, 1, 1076, 1, 1076, 1, 1076, 5, 1076, 18934, 8, 1076, 10, 1076, 12, 1076, 18937, 9, 1076, 1, 1076, 3, 1076, 18940, 8, 1076, 1, 1076, 3, 1076, 18943, 8, 1076, 1, 1076, 3, 1076, 18946, 8, 1076, 1, 1076, 3, 1076, 18949, 8, 1076, 1, 1076, 1, 1076, 1, 1076, 3, 1076, 18954, 8, 1076, 1, 1077, 3, 1077, 18957, 8, 1077, 1, 1077, 1, 1077, 3, 1077, 18961, 8, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 3, 1077, 18970, 8, 1077, 1, 1077, 1, 1077, 3, 1077, 18974, 8, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18981, 8, 1078, 1, 1078, 1, 1078, 3, 1078, 18985, 8, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18990, 8, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18995, 8, 1078, 1, 1078, 3, 1078, 18998, 8, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 3, 1079, 19007, 8, 1079, 1, 1079, 1, 1079, 3, 1079, 19011, 8, 1079, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 3, 1081, 19022, 8, 1081, 1, 1081, 3, 1081, 19025, 8, 1081, 1, 1081, 1, 1081, 3, 1081, 19029, 8, 1081, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19034, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19038, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19047, 8, 1082, 1, 1082, 3, 1082, 19050, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19054, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19063, 8, 1082, 1, 1082, 3, 1082, 19066, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19070, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19075, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19084, 8, 1082, 1, 1082, 3, 1082, 19087, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19091, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19099, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19104, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19109, 8, 1082, 1, 1082, 3, 1082, 19112, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19116, 8, 1082, 3, 1082, 19118, 8, 1082, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 5, 1083, 19125, 8, 1083, 10, 1083, 12, 1083, 19128, 9, 1083, 1, 1083, 1, 1083, 1, 1084, 1, 1084, 3, 1084, 19134, 8, 1084, 1, 1084, 3, 1084, 19137, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19144, 8, 1084, 3, 1084, 19146, 8, 1084, 1, 1084, 3, 1084, 19149, 8, 1084, 1, 1084, 3, 1084, 19152, 8, 1084, 1, 1084, 1, 1084, 3, 1084, 19156, 8, 1084, 1, 1084, 3, 1084, 19159, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19164, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19171, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19177, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19185, 8, 1084, 1, 1085, 1, 1085, 3, 1085, 19189, 8, 1085, 1, 1085, 3, 1085, 19192, 8, 1085, 1, 1085, 3, 1085, 19195, 8, 1085, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 3, 1086, 19201, 8, 1086, 1, 1086, 3, 1086, 19204, 8, 1086, 1, 1086, 1, 1086, 3, 1086, 19208, 8, 1086, 1, 1087, 1, 1087, 3, 1087, 19212, 8, 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 19217, 8, 1087, 1, 1087, 3, 1087, 19220, 8, 1087, 1, 1087, 3, 1087, 19223, 8, 1087, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 3, 1088, 19232, 8, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 19244, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1090, 1, 1090, 3, 1090, 19251, 8, 1090, 1, 1090, 3, 1090, 19254, 8, 1090, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 3, 1091, 19260, 8, 1091, 1, 1091, 3, 1091, 19263, 8, 1091, 1, 1091, 3, 1091, 19266, 8, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 3, 1091, 19275, 8, 1091, 1, 1091, 3, 1091, 19278, 8, 1091, 1, 1091, 1, 1091, 1, 1091, 3, 1091, 19283, 8, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 3, 1091, 19290, 8, 1091, 3, 1091, 19292, 8, 1091, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 3, 1092, 19305, 8, 1092, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 3, 1093, 19312, 8, 1093, 1, 1094, 1, 1094, 1, 1094, 3, 1094, 19317, 8, 1094, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19322, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19328, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19334, 8, 1095, 1, 1095, 3, 1095, 19337, 8, 1095, 3, 1095, 19339, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19344, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19352, 8, 1095, 3, 1095, 19354, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19361, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19367, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19372, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19378, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19383, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19389, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19401, 8, 1095, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 3, 1096, 19407, 8, 1096, 1, 1096, 1, 1096, 3, 1096, 19411, 8, 1096, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19416, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19421, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19427, 8, 1097, 1, 1097, 3, 1097, 19430, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19434, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19444, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19454, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19460, 8, 1097, 3, 1097, 19462, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19472, 8, 1097, 3, 1097, 19474, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19481, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19485, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 4, 1097, 19492, 8, 1097, 11, 1097, 12, 1097, 19493, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19499, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19504, 8, 1097, 1, 1097, 3, 1097, 19507, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19516, 8, 1097, 1, 1097, 3, 1097, 19519, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19528, 8, 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, 3, 1097, 19542, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19549, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19557, 8, 1097, 1, 1097, 3, 1097, 19560, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19573, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19579, 8, 1097, 3, 1097, 19581, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19594, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19603, 8, 1097, 1, 1097, 1, 1097, 5, 1097, 19607, 8, 1097, 10, 1097, 12, 1097, 19610, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19619, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19625, 8, 1097, 10, 1097, 12, 1097, 19628, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19633, 8, 1097, 1, 1097, 3, 1097, 19636, 8, 1097, 1, 1097, 3, 1097, 19639, 8, 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, 3, 1097, 19653, 8, 1097, 3, 1097, 19655, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19663, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19668, 8, 1097, 10, 1097, 12, 1097, 19671, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19678, 8, 1097, 10, 1097, 12, 1097, 19681, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19686, 8, 1097, 10, 1097, 12, 1097, 19689, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19694, 8, 1097, 1, 1097, 3, 1097, 19697, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19702, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19707, 8, 1097, 5, 1097, 19709, 8, 1097, 10, 1097, 12, 1097, 19712, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19717, 8, 1097, 10, 1097, 12, 1097, 19720, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19726, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19735, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19740, 8, 1097, 10, 1097, 12, 1097, 19743, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19751, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19755, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19760, 8, 1097, 10, 1097, 12, 1097, 19763, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19769, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19776, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19781, 8, 1097, 10, 1097, 12, 1097, 19784, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19791, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19795, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19800, 8, 1097, 10, 1097, 12, 1097, 19803, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19811, 8, 1097, 1, 1097, 3, 1097, 19814, 8, 1097, 1, 1097, 3, 1097, 19817, 8, 1097, 1, 1097, 3, 1097, 19820, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19824, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19829, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19834, 8, 1097, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1101, 1, 1101, 1, 1101, 3, 1101, 19845, 8, 1101, 1, 1101, 1, 1101, 3, 1101, 19849, 8, 1101, 3, 1101, 19851, 8, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 3, 1101, 19862, 8, 1101, 3, 1101, 19864, 8, 1101, 1, 1101, 1, 1101, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 3, 1102, 19875, 8, 1102, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 3, 1104, 19886, 8, 1104, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 5, 1105, 19893, 8, 1105, 10, 1105, 12, 1105, 19896, 9, 1105, 3, 1105, 19898, 8, 1105, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 3, 1106, 19908, 8, 1106, 1, 1107, 1, 1107, 3, 1107, 19912, 8, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 5, 1108, 19919, 8, 1108, 10, 1108, 12, 1108, 19922, 9, 1108, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 3, 1109, 19931, 8, 1109, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 3, 1110, 19941, 8, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 5, 1110, 19947, 8, 1110, 10, 1110, 12, 1110, 19950, 9, 1110, 1, 1111, 1, 1111, 1, 1111, 3, 1111, 19955, 8, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 5, 1111, 19961, 8, 1111, 10, 1111, 12, 1111, 19964, 9, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 3, 1111, 19970, 8, 1111, 1, 1111, 1, 1111, 3, 1111, 19974, 8, 1111, 1, 1112, 1, 1112, 1, 1112, 3, 1112, 19979, 8, 1112, 1, 1112, 1, 1112, 3, 1112, 19983, 8, 1112, 1, 1112, 1, 1112, 1, 1112, 3, 1112, 19988, 8, 1112, 5, 1112, 19990, 8, 1112, 10, 1112, 12, 1112, 19993, 9, 1112, 1, 1113, 1, 1113, 1, 1113, 3, 1113, 19998, 8, 1113, 1, 1113, 3, 1113, 20001, 8, 1113, 1, 1113, 1, 1113, 1, 1113, 5, 1113, 20006, 8, 1113, 10, 1113, 12, 1113, 20009, 9, 1113, 1, 1113, 1, 1113, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 3, 1114, 20018, 8, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 5, 1114, 20024, 8, 1114, 10, 1114, 12, 1114, 20027, 9, 1114, 1, 1114, 3, 1114, 20030, 8, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 3, 1115, 20040, 8, 1115, 1, 1115, 3, 1115, 20043, 8, 1115, 3, 1115, 20045, 8, 1115, 1, 1116, 1, 1116, 1, 1116, 1, 1117, 1, 1117, 3, 1117, 20052, 8, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 3, 1117, 20058, 8, 1117, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 3, 1118, 20064, 8, 1118, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 3, 1119, 20070, 8, 1119, 3, 1119, 20072, 8, 1119, 1, 1120, 1, 1120, 1, 1120, 1, 1121, 1, 1121, 1, 1121, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 3, 1122, 20086, 8, 1122, 3, 1122, 20088, 8, 1122, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 3, 1124, 20101, 8, 1124, 1, 1124, 1, 1124, 1, 1124, 3, 1124, 20106, 8, 1124, 1, 1124, 3, 1124, 20109, 8, 1124, 1, 1124, 1, 1124, 1, 1124, 5, 1124, 20114, 8, 1124, 10, 1124, 12, 1124, 20117, 9, 1124, 1, 1125, 1, 1125, 3, 1125, 20121, 8, 1125, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 3, 1126, 20132, 8, 1126, 1, 1127, 1, 1127, 1, 1127, 3, 1127, 20137, 8, 1127, 3, 1127, 20139, 8, 1127, 1, 1127, 1, 1127, 1, 1128, 1, 1128, 1, 1128, 3, 1128, 20146, 8, 1128, 1, 1128, 3, 1128, 20149, 8, 1128, 1, 1128, 1, 1128, 1, 1128, 5, 1128, 20154, 8, 1128, 10, 1128, 12, 1128, 20157, 9, 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, 3, 1129, 20171, 8, 1129, 1, 1129, 3, 1129, 20174, 8, 1129, 1, 1129, 1, 1129, 3, 1129, 20178, 8, 1129, 3, 1129, 20180, 8, 1129, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 4, 1130, 20186, 8, 1130, 11, 1130, 12, 1130, 20187, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 3, 1130, 20196, 8, 1130, 3, 1130, 20198, 8, 1130, 1, 1131, 1, 1131, 1, 1131, 5, 1131, 20203, 8, 1131, 10, 1131, 12, 1131, 20206, 9, 1131, 1, 1131, 1, 1131, 3, 1131, 20210, 8, 1131, 1, 1132, 1, 1132, 3, 1132, 20214, 8, 1132, 1, 1132, 1, 1132, 3, 1132, 20218, 8, 1132, 1, 1133, 1, 1133, 3, 1133, 20222, 8, 1133, 1, 1133, 1, 1133, 3, 1133, 20226, 8, 1133, 1, 1133, 1, 1133, 1, 1134, 3, 1134, 20231, 8, 1134, 1, 1134, 1, 1134, 3, 1134, 20235, 8, 1134, 1, 1134, 3, 1134, 20238, 8, 1134, 1, 1135, 1, 1135, 3, 1135, 20242, 8, 1135, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 3, 1136, 20249, 8, 1136, 1, 1137, 1, 1137, 3, 1137, 20253, 8, 1137, 1, 1137, 1, 1137, 1, 1137, 3, 1137, 20258, 8, 1137, 1, 1137, 1, 1137, 1, 1137, 3, 1137, 20263, 8, 1137, 5, 1137, 20265, 8, 1137, 10, 1137, 12, 1137, 20268, 9, 1137, 1, 1138, 1, 1138, 3, 1138, 20272, 8, 1138, 1, 1139, 1, 1139, 1, 1140, 1, 1140, 1, 1141, 1, 1141, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, 1144, 1, 1144, 1, 1144, 5, 1144, 20287, 8, 1144, 10, 1144, 12, 1144, 20290, 9, 1144, 1, 1144, 1, 1144, 3, 1144, 20294, 8, 1144, 1, 1145, 1, 1145, 1, 1146, 1, 1146, 1, 1146, 3, 1146, 20301, 8, 1146, 1, 1147, 1, 1147, 1, 1148, 1, 1148, 1, 1149, 1, 1149, 1, 1150, 1, 1150, 1, 1150, 3, 1150, 20312, 8, 1150, 1, 1151, 1, 1151, 1, 1151, 5, 1151, 20317, 8, 1151, 10, 1151, 12, 1151, 20320, 9, 1151, 1, 1152, 1, 1152, 1, 1153, 1, 1153, 3, 1153, 20326, 8, 1153, 1, 1154, 1, 1154, 3, 1154, 20330, 8, 1154, 1, 1155, 1, 1155, 1, 1155, 5, 1155, 20335, 8, 1155, 10, 1155, 12, 1155, 20338, 9, 1155, 1, 1155, 1, 1155, 3, 1155, 20342, 8, 1155, 1, 1156, 1, 1156, 1, 1157, 1, 1157, 1, 1157, 5, 1157, 20349, 8, 1157, 10, 1157, 12, 1157, 20352, 9, 1157, 1, 1158, 1, 1158, 1, 1158, 5, 1158, 20357, 8, 1158, 10, 1158, 12, 1158, 20360, 9, 1158, 1, 1159, 1, 1159, 1, 1159, 5, 1159, 20365, 8, 1159, 10, 1159, 12, 1159, 20368, 9, 1159, 1, 1160, 1, 1160, 1, 1160, 3, 1160, 20373, 8, 1160, 1, 1161, 1, 1161, 1, 1161, 3, 1161, 20378, 8, 1161, 1, 1162, 1, 1162, 1, 1162, 3, 1162, 20383, 8, 1162, 1, 1163, 1, 1163, 3, 1163, 20387, 8, 1163, 1, 1163, 1, 1163, 1, 1163, 3, 1163, 20392, 8, 1163, 1, 1163, 3, 1163, 20395, 8, 1163, 1, 1164, 1, 1164, 1, 1164, 3, 1164, 20400, 8, 1164, 1, 1165, 1, 1165, 3, 1165, 20404, 8, 1165, 1, 1166, 1, 1166, 3, 1166, 20408, 8, 1166, 1, 1167, 1, 1167, 1, 1167, 5, 1167, 20413, 8, 1167, 10, 1167, 12, 1167, 20416, 9, 1167, 1, 1167, 1, 1167, 3, 1167, 20420, 8, 1167, 1, 1168, 1, 1168, 1, 1169, 1, 1169, 1, 1170, 1, 1170, 1, 1170, 5, 1170, 20429, 8, 1170, 10, 1170, 12, 1170, 20432, 9, 1170, 1, 1171, 1, 1171, 1, 1171, 3, 1171, 20437, 8, 1171, 1, 1171, 1, 1171, 1, 1171, 3, 1171, 20442, 8, 1171, 1, 1171, 1, 1171, 3, 1171, 20446, 8, 1171, 3, 1171, 20448, 8, 1171, 1, 1172, 1, 1172, 1, 1172, 1, 1172, 1, 1172, 3, 1172, 20455, 8, 1172, 1, 1172, 1, 1172, 3, 1172, 20459, 8, 1172, 1, 1172, 1, 1172, 1, 1172, 1, 1172, 5, 1172, 20465, 8, 1172, 10, 1172, 12, 1172, 20468, 9, 1172, 3, 1172, 20470, 8, 1172, 1, 1172, 1, 1172, 1, 1172, 3, 1172, 20475, 8, 1172, 1, 1173, 1, 1173, 1, 1173, 5, 1173, 20480, 8, 1173, 10, 1173, 12, 1173, 20483, 9, 1173, 1, 1174, 1, 1174, 1, 1175, 1, 1175, 1, 1176, 1, 1176, 1, 1177, 1, 1177, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 5, 1178, 20498, 8, 1178, 10, 1178, 12, 1178, 20501, 9, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 3, 1178, 20517, 8, 1178, 1, 1179, 1, 1179, 1, 1179, 5, 1179, 20522, 8, 1179, 10, 1179, 12, 1179, 20525, 9, 1179, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20537, 8, 1181, 1, 1181, 1, 1181, 3, 1181, 20541, 8, 1181, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 5, 1182, 20547, 8, 1182, 10, 1182, 12, 1182, 20550, 9, 1182, 3, 1182, 20552, 8, 1182, 1, 1182, 1, 1182, 3, 1182, 20556, 8, 1182, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20561, 8, 1183, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20566, 8, 1183, 5, 1183, 20568, 8, 1183, 10, 1183, 12, 1183, 20571, 9, 1183, 3, 1183, 20573, 8, 1183, 1, 1183, 1, 1183, 3, 1183, 20577, 8, 1183, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20584, 8, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20589, 8, 1184, 3, 1184, 20591, 8, 1184, 3, 1184, 20593, 8, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20603, 8, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20608, 8, 1184, 5, 1184, 20610, 8, 1184, 10, 1184, 12, 1184, 20613, 9, 1184, 3, 1184, 20615, 8, 1184, 1, 1184, 1, 1184, 3, 1184, 20619, 8, 1184, 1, 1185, 1, 1185, 1, 1185, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 3, 1186, 20628, 8, 1186, 1, 1186, 1, 1186, 1, 1187, 1, 1187, 3, 1187, 20634, 8, 1187, 1, 1187, 1, 1187, 3, 1187, 20638, 8, 1187, 3, 1187, 20640, 8, 1187, 1, 1188, 1, 1188, 3, 1188, 20644, 8, 1188, 1, 1188, 1, 1188, 3, 1188, 20648, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 3, 1188, 20655, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 3, 1188, 20663, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 3, 1188, 20671, 8, 1188, 3, 1188, 20673, 8, 1188, 1, 1189, 1, 1189, 1, 1189, 3, 1189, 20678, 8, 1189, 1, 1189, 1, 1189, 1, 1189, 3, 1189, 20683, 8, 1189, 3, 1189, 20685, 8, 1189, 1, 1189, 3, 1189, 20688, 8, 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, 1190, 3, 1190, 20712, 8, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 3, 1190, 20719, 8, 1190, 1, 1190, 1, 1190, 1, 1190, 3, 1190, 20724, 8, 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, 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, 3, 1190, 20757, 8, 1190, 1, 1191, 1, 1191, 1, 1191, 3, 1191, 20762, 8, 1191, 1, 1191, 3, 1191, 20765, 8, 1191, 1, 1191, 1, 1191, 1, 1191, 3, 1191, 20770, 8, 1191, 3, 1191, 20772, 8, 1191, 1, 1191, 1, 1191, 5, 1191, 20776, 8, 1191, 10, 1191, 12, 1191, 20779, 9, 1191, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 3, 1192, 20787, 8, 1192, 1, 1192, 1, 1192, 1, 1192, 4, 1192, 20792, 8, 1192, 11, 1192, 12, 1192, 20793, 5, 1192, 20796, 8, 1192, 10, 1192, 12, 1192, 20799, 9, 1192, 1, 1193, 1, 1193, 3, 1193, 20803, 8, 1193, 1, 1193, 1, 1193, 1, 1193, 3, 1193, 20808, 8, 1193, 1, 1193, 5, 1193, 20811, 8, 1193, 10, 1193, 12, 1193, 20814, 9, 1193, 1, 1194, 1, 1194, 3, 1194, 20818, 8, 1194, 1, 1194, 1, 1194, 1, 1194, 5, 1194, 20823, 8, 1194, 10, 1194, 12, 1194, 20826, 9, 1194, 1, 1195, 1, 1195, 3, 1195, 20830, 8, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 3, 1195, 20864, 8, 1195, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20871, 8, 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, 3, 1196, 20886, 8, 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, 3, 1196, 20902, 8, 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, 3, 1196, 20921, 8, 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, 3, 1196, 20938, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20945, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20953, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20966, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20975, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20984, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20993, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21003, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21011, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21021, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21031, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21043, 8, 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, 3, 1196, 21059, 8, 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, 3, 1196, 21077, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21090, 8, 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, 3, 1196, 21105, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21116, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21126, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21137, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21147, 8, 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, 3, 1196, 21164, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21170, 8, 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, 1196, 3, 1196, 21192, 8, 1196, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21197, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21203, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21209, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21215, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21220, 8, 1197, 3, 1197, 21222, 8, 1197, 1, 1197, 3, 1197, 21225, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21236, 8, 1197, 1, 1197, 3, 1197, 21239, 8, 1197, 3, 1197, 21241, 8, 1197, 3, 1197, 21243, 8, 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, 3, 1197, 21257, 8, 1197, 1, 1198, 1, 1198, 3, 1198, 21261, 8, 1198, 1, 1198, 3, 1198, 21264, 8, 1198, 1, 1199, 1, 1199, 1, 1199, 1, 1200, 1, 1200, 1, 1201, 1, 1201, 3, 1201, 21273, 8, 1201, 1, 1201, 1, 1201, 1, 1202, 1, 1202, 3, 1202, 21279, 8, 1202, 1, 1203, 1, 1203, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 3, 1205, 21409, 8, 1205, 1, 1206, 1, 1206, 1, 1207, 1, 1207, 1, 1208, 1, 1208, 1, 1208, 1, 3834, 7, 1250, 2082, 2090, 2092, 2102, 2220, 2384, 1209, 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, 0, 305, 2, 0, 1219, 1219, 2293, 2293, 2, 0, 684, 684, 901, 901, 2, 0, 2306, 2306, 2308, 2308, 2, 0, 1171, 1171, 1560, 1560, 2, 0, 21, 21, 980, 980, 5, 0, 465, 465, 675, 675, 963, 963, 1340, 1340, 2196, 2196, 2, 0, 230, 230, 596, 596, 2, 0, 616, 616, 1104, 1104, 2, 0, 812, 812, 901, 901, 2, 0, 21, 21, 469, 469, 3, 0, 649, 649, 1310, 1310, 1325, 1325, 2, 0, 1258, 1258, 2313, 2313, 2, 0, 649, 649, 1325, 1325, 4, 0, 91, 91, 675, 675, 897, 897, 2406, 2406, 3, 0, 220, 220, 350, 350, 2291, 2291, 2, 0, 1489, 1489, 1548, 1548, 2, 0, 1178, 1178, 1576, 1576, 2, 0, 429, 429, 499, 499, 2, 0, 206, 206, 1713, 1713, 2, 0, 2444, 2444, 2450, 2450, 2, 0, 482, 482, 1132, 1132, 2, 0, 948, 948, 1133, 1133, 2, 0, 69, 69, 785, 785, 3, 0, 660, 660, 862, 862, 1495, 1495, 2, 0, 389, 389, 616, 616, 2, 0, 1606, 1606, 2083, 2083, 5, 0, 632, 632, 1329, 1329, 1461, 1461, 2157, 2157, 2166, 2166, 2, 0, 220, 220, 1303, 1303, 2, 0, 1455, 1455, 1473, 1473, 3, 0, 38, 38, 244, 244, 873, 873, 2, 0, 932, 932, 960, 960, 3, 0, 147, 147, 1329, 1329, 1715, 1715, 2, 0, 35, 35, 1394, 1394, 2, 0, 420, 420, 1331, 1331, 4, 0, 281, 281, 319, 319, 887, 887, 1456, 1456, 2, 0, 146, 146, 1699, 1699, 2, 0, 33, 33, 112, 112, 3, 0, 403, 403, 756, 756, 2207, 2207, 3, 0, 1021, 1021, 1250, 1250, 1337, 1337, 2, 0, 616, 616, 2253, 2253, 2, 0, 147, 147, 1715, 1715, 3, 0, 346, 346, 1279, 1279, 1719, 1719, 2, 0, 910, 910, 1303, 1303, 2, 0, 936, 936, 1745, 1745, 3, 0, 595, 595, 761, 761, 1324, 1324, 3, 0, 242, 242, 1201, 1201, 1596, 1596, 3, 0, 376, 376, 449, 449, 1484, 1484, 2, 0, 14, 14, 38, 38, 3, 0, 351, 351, 948, 948, 1133, 1133, 2, 0, 1100, 1100, 2429, 2429, 1, 0, 2441, 2442, 2, 0, 1170, 1170, 1554, 1554, 2, 0, 1730, 1730, 2112, 2112, 10, 0, 366, 366, 658, 658, 680, 680, 959, 959, 987, 987, 1482, 1482, 1637, 1637, 1730, 1730, 2296, 2296, 2357, 2357, 2, 0, 2406, 2406, 2409, 2409, 2, 0, 70, 70, 414, 414, 2, 0, 598, 598, 825, 825, 3, 0, 759, 759, 1667, 1667, 1743, 1743, 14, 0, 42, 42, 85, 85, 241, 241, 403, 403, 542, 542, 605, 605, 647, 647, 717, 717, 756, 756, 881, 881, 1505, 1505, 1559, 1559, 1647, 1647, 2207, 2207, 3, 0, 42, 42, 321, 321, 469, 469, 3, 0, 542, 542, 1505, 1505, 2313, 2313, 4, 0, 359, 359, 425, 425, 1252, 1252, 2355, 2355, 3, 0, 87, 87, 634, 634, 681, 681, 2, 0, 1173, 1173, 1565, 1565, 5, 0, 480, 480, 635, 635, 901, 901, 1328, 1328, 2077, 2077, 3, 0, 365, 365, 985, 985, 2358, 2358, 6, 0, 410, 410, 671, 671, 786, 786, 847, 847, 937, 940, 1338, 1339, 2, 0, 137, 137, 2183, 2183, 2, 0, 2203, 2203, 2215, 2215, 2, 0, 395, 395, 698, 698, 2, 0, 782, 782, 2290, 2290, 2, 0, 983, 983, 1127, 1127, 2, 0, 21, 21, 1558, 1558, 2, 0, 561, 561, 643, 643, 2, 0, 389, 389, 2092, 2092, 2, 0, 881, 881, 2187, 2187, 2, 0, 21, 21, 2207, 2207, 2, 0, 1378, 1378, 1607, 1607, 2, 0, 1243, 1243, 1256, 1256, 2, 0, 1949, 1949, 2237, 2237, 2, 0, 160, 160, 534, 534, 2, 0, 4, 4, 1667, 1667, 2, 0, 38, 38, 336, 336, 2, 0, 1627, 1627, 2108, 2108, 2, 0, 717, 717, 2083, 2083, 2, 0, 26, 26, 401, 401, 2, 0, 1570, 1570, 1713, 1713, 3, 0, 632, 632, 1329, 1329, 1461, 1461, 3, 0, 206, 206, 1570, 1570, 1713, 1713, 2, 0, 249, 249, 1568, 1568, 3, 0, 119, 119, 142, 142, 215, 215, 2, 0, 179, 179, 1578, 1578, 2, 0, 341, 341, 398, 398, 2, 0, 291, 291, 293, 293, 2, 0, 686, 686, 689, 689, 1, 0, 286, 287, 2, 0, 1215, 1215, 2253, 2253, 2, 0, 871, 871, 2081, 2081, 2, 0, 352, 352, 2089, 2089, 3, 0, 698, 698, 1178, 1178, 2092, 2092, 2, 0, 1244, 1244, 1259, 1259, 2, 0, 122, 122, 1705, 1705, 3, 0, 593, 593, 884, 884, 1119, 1119, 2, 0, 91, 91, 909, 909, 2, 0, 655, 655, 1108, 1108, 2, 0, 675, 675, 897, 897, 2, 0, 389, 389, 2441, 2441, 2, 0, 242, 242, 406, 406, 2, 0, 511, 511, 2161, 2161, 2, 0, 166, 166, 1066, 1066, 2, 0, 540, 540, 705, 705, 2, 0, 79, 79, 1794, 1794, 3, 0, 249, 249, 578, 578, 616, 616, 3, 0, 250, 250, 578, 578, 616, 616, 3, 0, 242, 242, 406, 406, 1743, 1743, 2, 0, 873, 873, 913, 913, 2, 0, 1180, 1180, 1599, 1599, 6, 0, 256, 256, 281, 281, 318, 319, 690, 690, 886, 887, 1668, 1668, 3, 0, 389, 389, 2185, 2185, 2441, 2441, 4, 0, 571, 571, 702, 702, 1353, 1355, 1357, 1358, 2, 0, 642, 642, 1455, 1455, 2, 0, 403, 403, 1447, 1447, 2, 0, 107, 107, 1640, 1640, 2, 0, 469, 469, 1447, 1447, 2, 0, 770, 770, 859, 859, 2, 0, 1137, 1137, 2360, 2360, 2, 0, 560, 560, 778, 778, 6, 0, 480, 480, 635, 635, 812, 812, 901, 901, 1328, 1328, 2077, 2077, 2, 0, 64, 64, 1484, 1484, 2, 0, 29, 29, 106, 106, 2, 0, 176, 176, 1484, 1484, 5, 0, 326, 326, 675, 675, 897, 897, 935, 935, 1133, 1133, 2, 0, 2185, 2185, 2441, 2441, 3, 0, 389, 389, 814, 814, 1519, 1519, 3, 0, 389, 389, 814, 814, 1133, 1133, 3, 0, 403, 403, 429, 429, 499, 499, 2, 0, 237, 237, 1606, 1606, 2, 0, 4, 4, 978, 978, 2, 0, 649, 649, 1645, 1645, 4, 0, 365, 366, 985, 985, 987, 987, 2357, 2358, 1, 0, 2380, 2383, 2, 0, 262, 262, 869, 869, 1, 0, 2451, 2452, 2, 0, 381, 381, 2364, 2364, 2, 0, 2260, 2261, 2263, 2264, 4, 0, 834, 834, 899, 900, 1203, 1203, 1609, 1609, 2, 0, 367, 367, 2359, 2359, 2, 0, 390, 390, 1227, 1227, 2, 0, 49, 49, 1307, 1307, 2, 0, 121, 121, 863, 863, 2, 0, 200, 200, 1067, 1067, 2, 0, 164, 164, 194, 194, 2, 0, 424, 424, 1088, 1088, 1, 0, 451, 452, 3, 0, 1060, 1060, 1089, 1089, 1118, 1118, 3, 0, 105, 105, 438, 438, 882, 882, 2, 0, 361, 361, 2108, 2108, 2, 0, 2463, 2463, 2472, 2472, 2, 0, 430, 430, 499, 499, 4, 0, 106, 106, 675, 675, 897, 897, 935, 935, 2, 0, 430, 430, 500, 500, 2, 0, 2469, 2469, 2472, 2472, 2, 0, 953, 953, 1123, 1123, 2, 0, 1447, 1447, 1475, 1475, 2, 0, 469, 469, 814, 814, 2, 0, 49, 49, 814, 814, 2, 0, 40, 40, 435, 435, 3, 0, 249, 249, 482, 482, 1132, 1132, 2, 0, 469, 469, 1587, 1587, 2, 0, 216, 216, 1734, 1734, 2, 0, 466, 466, 2211, 2211, 2, 0, 113, 113, 508, 508, 2, 0, 885, 885, 1392, 1392, 3, 0, 98, 98, 1385, 1385, 1469, 1469, 2, 0, 242, 242, 1441, 1441, 2, 0, 1, 1, 1761, 1761, 2, 0, 1392, 1392, 1707, 1707, 3, 0, 38, 38, 1133, 1133, 1734, 1734, 3, 0, 675, 675, 963, 963, 2196, 2196, 4, 0, 429, 429, 499, 499, 1558, 1558, 1790, 1790, 2, 0, 575, 575, 2158, 2158, 2, 0, 1558, 1558, 1671, 1671, 2, 0, 1797, 1797, 1949, 1949, 2, 0, 922, 922, 925, 925, 1, 0, 926, 928, 2, 0, 38, 38, 835, 835, 2, 0, 505, 505, 1550, 1550, 3, 0, 387, 387, 505, 505, 1550, 1550, 2, 0, 1505, 1505, 2313, 2313, 2, 0, 1348, 1348, 1775, 1775, 2, 0, 1348, 1348, 1350, 1350, 1, 0, 1774, 1775, 2, 0, 780, 780, 2207, 2207, 2, 0, 1188, 1188, 1709, 1709, 2, 0, 877, 877, 2258, 2258, 2, 0, 626, 626, 1373, 1373, 2, 0, 388, 388, 813, 813, 3, 0, 675, 675, 897, 897, 935, 935, 2, 0, 336, 336, 1228, 1228, 2, 0, 642, 642, 873, 873, 2, 0, 469, 469, 816, 816, 1, 0, 2433, 2434, 4, 0, 738, 738, 750, 750, 1080, 1080, 1318, 1318, 2, 0, 389, 389, 2457, 2457, 1, 1, 2470, 2470, 1, 0, 1585, 1586, 2, 0, 108, 108, 698, 698, 2, 0, 403, 403, 2429, 2429, 2, 0, 152, 152, 410, 410, 3, 0, 38, 38, 445, 445, 2183, 2183, 2, 0, 327, 327, 1004, 1004, 2, 0, 327, 327, 1313, 1313, 3, 0, 630, 630, 839, 839, 1592, 1592, 3, 0, 1627, 1627, 1707, 1707, 2108, 2108, 2, 0, 539, 539, 703, 703, 2, 0, 332, 332, 1598, 1598, 2, 0, 692, 692, 814, 814, 2, 0, 38, 38, 2206, 2206, 2, 0, 95, 95, 1655, 1655, 1, 0, 1606, 1607, 2, 0, 598, 598, 1025, 1025, 2, 0, 38, 38, 598, 598, 2, 0, 2083, 2083, 2100, 2100, 2, 0, 829, 829, 1766, 1766, 2, 0, 936, 936, 1772, 1772, 3, 0, 534, 534, 775, 775, 2181, 2181, 2, 0, 38, 38, 445, 445, 2, 0, 853, 855, 857, 857, 1, 0, 2467, 2468, 2, 0, 520, 520, 2159, 2159, 3, 0, 981, 981, 2450, 2450, 2454, 2454, 2, 0, 386, 386, 707, 707, 4, 0, 313, 313, 598, 598, 825, 825, 858, 858, 3, 0, 545, 545, 1025, 1025, 1454, 1454, 1, 0, 523, 524, 4, 0, 38, 38, 55, 55, 545, 545, 1708, 1708, 3, 0, 149, 149, 838, 838, 2146, 2146, 2, 0, 3, 3, 1228, 1228, 2, 0, 163, 163, 196, 196, 2, 0, 68, 68, 1238, 1238, 2, 0, 785, 785, 2258, 2258, 2, 0, 520, 520, 1228, 1228, 2, 0, 497, 497, 1228, 1228, 2, 0, 520, 520, 692, 692, 3, 0, 520, 520, 692, 692, 1562, 1562, 4, 0, 520, 520, 692, 692, 1228, 1228, 1558, 1558, 3, 0, 321, 321, 520, 520, 692, 692, 3, 0, 520, 520, 692, 692, 1228, 1228, 2, 0, 265, 265, 2176, 2176, 2, 0, 181, 181, 2321, 2321, 2, 0, 445, 445, 2183, 2183, 2, 0, 1375, 1377, 1380, 1380, 2, 0, 175, 175, 248, 248, 2, 0, 601, 601, 826, 826, 2, 0, 2402, 2402, 2405, 2405, 3, 0, 2125, 2126, 2134, 2134, 2137, 2138, 2, 0, 2129, 2129, 2142, 2142, 2, 0, 197, 197, 1007, 1007, 2, 0, 2323, 2323, 2331, 2331, 2, 0, 515, 515, 1096, 1096, 2, 0, 529, 529, 997, 997, 2, 0, 294, 294, 455, 455, 2, 0, 670, 670, 1683, 1683, 10, 0, 1226, 1226, 2265, 2265, 2398, 2400, 2403, 2404, 2406, 2407, 2409, 2410, 2412, 2413, 2415, 2415, 2419, 2422, 2435, 2435, 2, 0, 2391, 2392, 2394, 2397, 1, 0, 2365, 2370, 2, 0, 1495, 1495, 1607, 1607, 2, 0, 613, 613, 1436, 1436, 2, 0, 1182, 1182, 1624, 1624, 2, 0, 518, 518, 522, 522, 1, 0, 2454, 2455, 1, 0, 1722, 1723, 2, 0, 1309, 1309, 1720, 1720, 2, 0, 242, 242, 1596, 1596, 3, 0, 242, 242, 1133, 1133, 1596, 1596, 2, 0, 692, 692, 1571, 1571, 1, 0, 1381, 1382, 2, 0, 365, 365, 2358, 2358, 2, 0, 985, 985, 1636, 1636, 2, 0, 42, 42, 469, 469, 2, 0, 321, 321, 469, 469, 2, 0, 42, 42, 321, 321, 3, 0, 42, 42, 469, 469, 542, 542, 2, 0, 55, 55, 560, 560, 2, 0, 206, 206, 1464, 1464, 4, 0, 42, 42, 241, 241, 469, 469, 1647, 1647, 4, 0, 42, 42, 469, 469, 1647, 1647, 2207, 2207, 3, 0, 403, 403, 469, 469, 756, 756, 6, 0, 42, 42, 403, 403, 469, 469, 756, 756, 1647, 1647, 2207, 2207, 2, 0, 469, 469, 2207, 2207, 3, 0, 42, 42, 469, 469, 647, 647, 3, 0, 42, 42, 469, 469, 1647, 1647, 3, 0, 42, 42, 321, 321, 1576, 1576, 3, 0, 42, 42, 469, 469, 2241, 2241, 10, 0, 42, 42, 102, 102, 241, 241, 403, 403, 469, 469, 756, 756, 881, 881, 1505, 1505, 1647, 1647, 2207, 2207, 5, 0, 42, 42, 321, 321, 469, 469, 905, 905, 2185, 2185, 4, 0, 42, 42, 469, 469, 542, 542, 2177, 2177, 3, 0, 469, 469, 946, 946, 2177, 2177, 2, 0, 46, 46, 85, 85, 2, 0, 421, 421, 2147, 2147, 6, 0, 365, 365, 679, 679, 958, 958, 985, 985, 1636, 1636, 2358, 2358, 2, 0, 2436, 2436, 2443, 2443, 1, 0, 2431, 2432, 256, 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, 544, 544, 556, 556, 562, 562, 568, 568, 573, 574, 576, 577, 579, 579, 581, 582, 586, 586, 590, 591, 603, 603, 609, 609, 621, 621, 634, 634, 636, 636, 641, 641, 658, 658, 671, 672, 680, 681, 684, 684, 697, 697, 701, 702, 718, 718, 737, 737, 746, 746, 748, 748, 751, 751, 770, 770, 781, 781, 786, 786, 795, 809, 811, 811, 820, 820, 822, 822, 829, 829, 836, 837, 847, 847, 850, 850, 859, 859, 878, 878, 880, 880, 889, 889, 895, 895, 908, 908, 910, 910, 915, 918, 929, 929, 937, 941, 948, 948, 959, 959, 972, 972, 976, 976, 978, 978, 982, 982, 987, 987, 993, 993, 1012, 1012, 1055, 1056, 1061, 1061, 1063, 1063, 1071, 1071, 1073, 1073, 1080, 1080, 1085, 1086, 1092, 1092, 1106, 1106, 1112, 1114, 1132, 1132, 1139, 1139, 1150, 1152, 1155, 1155, 1157, 1159, 1164, 1164, 1169, 1169, 1172, 1172, 1179, 1179, 1189, 1189, 1207, 1207, 1214, 1214, 1216, 1218, 1225, 1225, 1239, 1239, 1245, 1245, 1252, 1252, 1254, 1255, 1276, 1278, 1290, 1295, 1300, 1300, 1338, 1339, 1342, 1342, 1344, 1345, 1359, 1359, 1361, 1362, 1364, 1364, 1366, 1366, 1386, 1386, 1389, 1390, 1409, 1409, 1413, 1417, 1425, 1425, 1427, 1428, 1431, 1432, 1440, 1440, 1448, 1448, 1450, 1450, 1452, 1453, 1457, 1457, 1467, 1467, 1470, 1472, 1478, 1478, 1482, 1482, 1491, 1491, 1508, 1508, 1521, 1521, 1553, 1553, 1556, 1556, 1572, 1572, 1594, 1594, 1600, 1600, 1612, 1612, 1617, 1617, 1629, 1629, 1632, 1632, 1637, 1638, 1661, 1661, 1663, 1663, 1665, 1665, 1681, 1682, 1688, 1688, 1711, 1712, 1726, 1726, 1730, 1731, 1733, 1733, 1743, 1744, 1765, 1765, 1778, 1779, 1787, 1787, 1797, 1797, 1801, 1801, 1803, 1803, 1809, 1809, 1827, 1827, 1832, 1833, 1837, 1838, 1860, 1860, 1872, 1872, 1875, 1879, 1904, 1904, 1932, 1932, 1943, 1943, 2074, 2076, 2085, 2085, 2096, 2096, 2104, 2105, 2124, 2124, 2148, 2148, 2154, 2154, 2162, 2162, 2170, 2170, 2176, 2176, 2188, 2188, 2195, 2195, 2201, 2201, 2215, 2215, 2219, 2219, 2223, 2223, 2230, 2230, 2236, 2236, 2242, 2242, 2244, 2245, 2247, 2252, 2254, 2254, 2256, 2256, 2272, 2275, 2287, 2287, 2289, 2289, 2296, 2297, 2307, 2307, 2312, 2312, 2355, 2355, 2357, 2357, 2362, 2362, 2371, 2383, 2385, 2385, 2387, 2387, 2389, 2390, 2408, 2408, 2440, 2440, 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, 542, 543, 546, 546, 548, 555, 557, 561, 563, 567, 569, 572, 575, 575, 578, 578, 580, 580, 583, 585, 589, 589, 593, 601, 604, 606, 608, 608, 610, 614, 616, 619, 622, 627, 629, 633, 637, 640, 642, 645, 648, 648, 650, 656, 659, 662, 664, 670, 674, 679, 682, 683, 686, 692, 694, 696, 698, 700, 703, 716, 719, 733, 735, 736, 739, 745, 747, 747, 749, 749, 753, 755, 757, 768, 771, 774, 776, 777, 780, 780, 782, 783, 787, 788, 790, 794, 813, 819, 821, 821, 824, 827, 830, 833, 835, 835, 838, 846, 848, 849, 851, 856, 858, 858, 861, 862, 865, 868, 870, 877, 879, 879, 882, 888, 890, 892, 896, 898, 900, 900, 902, 907, 909, 909, 911, 911, 913, 914, 919, 928, 930, 936, 942, 947, 949, 955, 957, 958, 960, 963, 966, 971, 973, 975, 979, 981, 983, 986, 988, 989, 991, 992, 994, 1004, 1006, 1011, 1013, 1021, 1023, 1054, 1057, 1059, 1062, 1062, 1064, 1066, 1068, 1070, 1072, 1072, 1075, 1079, 1081, 1084, 1087, 1087, 1090, 1091, 1093, 1099, 1101, 1105, 1107, 1111, 1115, 1116, 1119, 1131, 1133, 1133, 1135, 1138, 1140, 1149, 1153, 1154, 1156, 1156, 1160, 1163, 1165, 1168, 1170, 1171, 1173, 1178, 1180, 1180, 1182, 1186, 1188, 1188, 1190, 1202, 1205, 1206, 1208, 1213, 1215, 1215, 1220, 1224, 1226, 1227, 1229, 1229, 1231, 1238, 1240, 1244, 1247, 1251, 1253, 1253, 1256, 1256, 1258, 1258, 1260, 1271, 1274, 1275, 1283, 1289, 1296, 1299, 1301, 1302, 1304, 1306, 1308, 1308, 1310, 1315, 1317, 1317, 1319, 1323, 1325, 1327, 1329, 1330, 1332, 1333, 1335, 1337, 1340, 1340, 1343, 1343, 1346, 1358, 1360, 1360, 1363, 1363, 1365, 1365, 1367, 1368, 1370, 1374, 1378, 1379, 1385, 1385, 1387, 1388, 1391, 1393, 1396, 1402, 1404, 1408, 1411, 1412, 1418, 1418, 1421, 1424, 1426, 1426, 1429, 1430, 1434, 1439, 1441, 1441, 1443, 1447, 1449, 1449, 1451, 1451, 1455, 1456, 1458, 1466, 1468, 1469, 1474, 1477, 1479, 1481, 1483, 1490, 1493, 1497, 1499, 1502, 1504, 1506, 1509, 1511, 1514, 1520, 1522, 1551, 1554, 1555, 1557, 1558, 1560, 1569, 1571, 1571, 1573, 1576, 1578, 1579, 1581, 1588, 1590, 1593, 1595, 1599, 1601, 1611, 1613, 1616, 1618, 1628, 1630, 1631, 1634, 1636, 1639, 1646, 1649, 1653, 1655, 1655, 1659, 1659, 1662, 1662, 1664, 1664, 1666, 1670, 1672, 1675, 1678, 1679, 1683, 1687, 1689, 1691, 1694, 1698, 1701, 1705, 1707, 1710, 1713, 1718, 1721, 1722, 1724, 1725, 1727, 1729, 1732, 1732, 1734, 1736, 1739, 1742, 1745, 1764, 1766, 1777, 1780, 1784, 1786, 1786, 1788, 1795, 1797, 1800, 1802, 1802, 1804, 1808, 1810, 1826, 1828, 1831, 1834, 1836, 1839, 1859, 1861, 1871, 1873, 1874, 1880, 1903, 1905, 1931, 1933, 1942, 1944, 2073, 2078, 2084, 2086, 2093, 2095, 2095, 2098, 2100, 2102, 2103, 2106, 2106, 2108, 2108, 2111, 2120, 2122, 2123, 2125, 2140, 2142, 2147, 2150, 2153, 2155, 2156, 2158, 2161, 2163, 2169, 2172, 2175, 2177, 2180, 2184, 2187, 2189, 2194, 2196, 2199, 2202, 2206, 2208, 2214, 2216, 2218, 2220, 2222, 2224, 2229, 2231, 2235, 2237, 2241, 2243, 2243, 2246, 2246, 2253, 2253, 2255, 2255, 2258, 2258, 2265, 2271, 2276, 2285, 2288, 2288, 2290, 2294, 2298, 2300, 2303, 2306, 2309, 2309, 2311, 2311, 2313, 2314, 2316, 2318, 2320, 2331, 2333, 2347, 2349, 2354, 2358, 2358, 2360, 2360, 2363, 2363, 2365, 2370, 2388, 2388, 2391, 2399, 2402, 2402, 2405, 2412, 2414, 2420, 2422, 2425, 24746, 0, 2424, 1, 0, 0, 0, 2, 2593, 1, 0, 0, 0, 4, 2595, 1, 0, 0, 0, 6, 2652, 1, 0, 0, 0, 8, 2677, 1, 0, 0, 0, 10, 2718, 1, 0, 0, 0, 12, 2724, 1, 0, 0, 0, 14, 2751, 1, 0, 0, 0, 16, 2753, 1, 0, 0, 0, 18, 2772, 1, 0, 0, 0, 20, 2813, 1, 0, 0, 0, 22, 2845, 1, 0, 0, 0, 24, 2850, 1, 0, 0, 0, 26, 2872, 1, 0, 0, 0, 28, 2874, 1, 0, 0, 0, 30, 2904, 1, 0, 0, 0, 32, 2906, 1, 0, 0, 0, 34, 2916, 1, 0, 0, 0, 36, 2918, 1, 0, 0, 0, 38, 2920, 1, 0, 0, 0, 40, 2963, 1, 0, 0, 0, 42, 2965, 1, 0, 0, 0, 44, 3005, 1, 0, 0, 0, 46, 3018, 1, 0, 0, 0, 48, 3020, 1, 0, 0, 0, 50, 3038, 1, 0, 0, 0, 52, 3049, 1, 0, 0, 0, 54, 3055, 1, 0, 0, 0, 56, 3065, 1, 0, 0, 0, 58, 3099, 1, 0, 0, 0, 60, 3138, 1, 0, 0, 0, 62, 3140, 1, 0, 0, 0, 64, 3172, 1, 0, 0, 0, 66, 3196, 1, 0, 0, 0, 68, 3246, 1, 0, 0, 0, 70, 3248, 1, 0, 0, 0, 72, 3250, 1, 0, 0, 0, 74, 3256, 1, 0, 0, 0, 76, 3258, 1, 0, 0, 0, 78, 3277, 1, 0, 0, 0, 80, 3285, 1, 0, 0, 0, 82, 3292, 1, 0, 0, 0, 84, 3298, 1, 0, 0, 0, 86, 3300, 1, 0, 0, 0, 88, 3314, 1, 0, 0, 0, 90, 3316, 1, 0, 0, 0, 92, 3329, 1, 0, 0, 0, 94, 3333, 1, 0, 0, 0, 96, 3368, 1, 0, 0, 0, 98, 3382, 1, 0, 0, 0, 100, 3403, 1, 0, 0, 0, 102, 3438, 1, 0, 0, 0, 104, 3440, 1, 0, 0, 0, 106, 3498, 1, 0, 0, 0, 108, 3506, 1, 0, 0, 0, 110, 3510, 1, 0, 0, 0, 112, 3524, 1, 0, 0, 0, 114, 3534, 1, 0, 0, 0, 116, 3547, 1, 0, 0, 0, 118, 3551, 1, 0, 0, 0, 120, 3555, 1, 0, 0, 0, 122, 3563, 1, 0, 0, 0, 124, 3566, 1, 0, 0, 0, 126, 3578, 1, 0, 0, 0, 128, 3583, 1, 0, 0, 0, 130, 3604, 1, 0, 0, 0, 132, 3606, 1, 0, 0, 0, 134, 3620, 1, 0, 0, 0, 136, 3638, 1, 0, 0, 0, 138, 3656, 1, 0, 0, 0, 140, 3679, 1, 0, 0, 0, 142, 3701, 1, 0, 0, 0, 144, 3736, 1, 0, 0, 0, 146, 3738, 1, 0, 0, 0, 148, 3746, 1, 0, 0, 0, 150, 3748, 1, 0, 0, 0, 152, 3753, 1, 0, 0, 0, 154, 3765, 1, 0, 0, 0, 156, 3785, 1, 0, 0, 0, 158, 3814, 1, 0, 0, 0, 160, 3861, 1, 0, 0, 0, 162, 3863, 1, 0, 0, 0, 164, 3892, 1, 0, 0, 0, 166, 3936, 1, 0, 0, 0, 168, 3938, 1, 0, 0, 0, 170, 3960, 1, 0, 0, 0, 172, 3974, 1, 0, 0, 0, 174, 3978, 1, 0, 0, 0, 176, 3995, 1, 0, 0, 0, 178, 4041, 1, 0, 0, 0, 180, 4078, 1, 0, 0, 0, 182, 4119, 1, 0, 0, 0, 184, 4128, 1, 0, 0, 0, 186, 4132, 1, 0, 0, 0, 188, 4146, 1, 0, 0, 0, 190, 4156, 1, 0, 0, 0, 192, 4161, 1, 0, 0, 0, 194, 4165, 1, 0, 0, 0, 196, 4184, 1, 0, 0, 0, 198, 4186, 1, 0, 0, 0, 200, 4188, 1, 0, 0, 0, 202, 4203, 1, 0, 0, 0, 204, 4207, 1, 0, 0, 0, 206, 4230, 1, 0, 0, 0, 208, 4253, 1, 0, 0, 0, 210, 4262, 1, 0, 0, 0, 212, 4271, 1, 0, 0, 0, 214, 4280, 1, 0, 0, 0, 216, 4284, 1, 0, 0, 0, 218, 4289, 1, 0, 0, 0, 220, 4312, 1, 0, 0, 0, 222, 4314, 1, 0, 0, 0, 224, 4364, 1, 0, 0, 0, 226, 4392, 1, 0, 0, 0, 228, 4394, 1, 0, 0, 0, 230, 4408, 1, 0, 0, 0, 232, 4413, 1, 0, 0, 0, 234, 4421, 1, 0, 0, 0, 236, 4429, 1, 0, 0, 0, 238, 4432, 1, 0, 0, 0, 240, 4441, 1, 0, 0, 0, 242, 4455, 1, 0, 0, 0, 244, 4472, 1, 0, 0, 0, 246, 4489, 1, 0, 0, 0, 248, 4497, 1, 0, 0, 0, 250, 4502, 1, 0, 0, 0, 252, 4526, 1, 0, 0, 0, 254, 4529, 1, 0, 0, 0, 256, 4535, 1, 0, 0, 0, 258, 4548, 1, 0, 0, 0, 260, 4560, 1, 0, 0, 0, 262, 4588, 1, 0, 0, 0, 264, 4594, 1, 0, 0, 0, 266, 4597, 1, 0, 0, 0, 268, 4604, 1, 0, 0, 0, 270, 4612, 1, 0, 0, 0, 272, 4625, 1, 0, 0, 0, 274, 4627, 1, 0, 0, 0, 276, 4632, 1, 0, 0, 0, 278, 4639, 1, 0, 0, 0, 280, 4667, 1, 0, 0, 0, 282, 4698, 1, 0, 0, 0, 284, 4746, 1, 0, 0, 0, 286, 4756, 1, 0, 0, 0, 288, 4758, 1, 0, 0, 0, 290, 4763, 1, 0, 0, 0, 292, 4777, 1, 0, 0, 0, 294, 4779, 1, 0, 0, 0, 296, 4790, 1, 0, 0, 0, 298, 4792, 1, 0, 0, 0, 300, 4830, 1, 0, 0, 0, 302, 4858, 1, 0, 0, 0, 304, 4877, 1, 0, 0, 0, 306, 4910, 1, 0, 0, 0, 308, 4948, 1, 0, 0, 0, 310, 4952, 1, 0, 0, 0, 312, 4967, 1, 0, 0, 0, 314, 4969, 1, 0, 0, 0, 316, 4986, 1, 0, 0, 0, 318, 4990, 1, 0, 0, 0, 320, 4998, 1, 0, 0, 0, 322, 5061, 1, 0, 0, 0, 324, 5063, 1, 0, 0, 0, 326, 5113, 1, 0, 0, 0, 328, 5115, 1, 0, 0, 0, 330, 5119, 1, 0, 0, 0, 332, 5192, 1, 0, 0, 0, 334, 5194, 1, 0, 0, 0, 336, 5197, 1, 0, 0, 0, 338, 5200, 1, 0, 0, 0, 340, 5212, 1, 0, 0, 0, 342, 5214, 1, 0, 0, 0, 344, 5230, 1, 0, 0, 0, 346, 5243, 1, 0, 0, 0, 348, 5309, 1, 0, 0, 0, 350, 5321, 1, 0, 0, 0, 352, 5333, 1, 0, 0, 0, 354, 5345, 1, 0, 0, 0, 356, 5350, 1, 0, 0, 0, 358, 5355, 1, 0, 0, 0, 360, 5359, 1, 0, 0, 0, 362, 5364, 1, 0, 0, 0, 364, 5368, 1, 0, 0, 0, 366, 5373, 1, 0, 0, 0, 368, 5382, 1, 0, 0, 0, 370, 5405, 1, 0, 0, 0, 372, 5418, 1, 0, 0, 0, 374, 5443, 1, 0, 0, 0, 376, 5445, 1, 0, 0, 0, 378, 5464, 1, 0, 0, 0, 380, 5470, 1, 0, 0, 0, 382, 5512, 1, 0, 0, 0, 384, 5530, 1, 0, 0, 0, 386, 5542, 1, 0, 0, 0, 388, 5548, 1, 0, 0, 0, 390, 5559, 1, 0, 0, 0, 392, 5570, 1, 0, 0, 0, 394, 5585, 1, 0, 0, 0, 396, 5600, 1, 0, 0, 0, 398, 5671, 1, 0, 0, 0, 400, 5686, 1, 0, 0, 0, 402, 5689, 1, 0, 0, 0, 404, 5697, 1, 0, 0, 0, 406, 5717, 1, 0, 0, 0, 408, 5745, 1, 0, 0, 0, 410, 5757, 1, 0, 0, 0, 412, 5761, 1, 0, 0, 0, 414, 5770, 1, 0, 0, 0, 416, 5802, 1, 0, 0, 0, 418, 5804, 1, 0, 0, 0, 420, 5813, 1, 0, 0, 0, 422, 5815, 1, 0, 0, 0, 424, 5845, 1, 0, 0, 0, 426, 5847, 1, 0, 0, 0, 428, 5856, 1, 0, 0, 0, 430, 5914, 1, 0, 0, 0, 432, 5916, 1, 0, 0, 0, 434, 5937, 1, 0, 0, 0, 436, 5943, 1, 0, 0, 0, 438, 5945, 1, 0, 0, 0, 440, 5997, 1, 0, 0, 0, 442, 6009, 1, 0, 0, 0, 444, 6018, 1, 0, 0, 0, 446, 6039, 1, 0, 0, 0, 448, 6043, 1, 0, 0, 0, 450, 6047, 1, 0, 0, 0, 452, 6081, 1, 0, 0, 0, 454, 6089, 1, 0, 0, 0, 456, 6101, 1, 0, 0, 0, 458, 6107, 1, 0, 0, 0, 460, 6114, 1, 0, 0, 0, 462, 6116, 1, 0, 0, 0, 464, 6140, 1, 0, 0, 0, 466, 6148, 1, 0, 0, 0, 468, 6152, 1, 0, 0, 0, 470, 6175, 1, 0, 0, 0, 472, 6221, 1, 0, 0, 0, 474, 6236, 1, 0, 0, 0, 476, 6238, 1, 0, 0, 0, 478, 6252, 1, 0, 0, 0, 480, 6284, 1, 0, 0, 0, 482, 6293, 1, 0, 0, 0, 484, 6309, 1, 0, 0, 0, 486, 6351, 1, 0, 0, 0, 488, 6382, 1, 0, 0, 0, 490, 6384, 1, 0, 0, 0, 492, 6391, 1, 0, 0, 0, 494, 6402, 1, 0, 0, 0, 496, 6413, 1, 0, 0, 0, 498, 6451, 1, 0, 0, 0, 500, 6453, 1, 0, 0, 0, 502, 6480, 1, 0, 0, 0, 504, 6493, 1, 0, 0, 0, 506, 6534, 1, 0, 0, 0, 508, 6536, 1, 0, 0, 0, 510, 6550, 1, 0, 0, 0, 512, 6555, 1, 0, 0, 0, 514, 6559, 1, 0, 0, 0, 516, 6572, 1, 0, 0, 0, 518, 6597, 1, 0, 0, 0, 520, 6599, 1, 0, 0, 0, 522, 6601, 1, 0, 0, 0, 524, 6603, 1, 0, 0, 0, 526, 6637, 1, 0, 0, 0, 528, 6639, 1, 0, 0, 0, 530, 6656, 1, 0, 0, 0, 532, 6671, 1, 0, 0, 0, 534, 6676, 1, 0, 0, 0, 536, 6702, 1, 0, 0, 0, 538, 6704, 1, 0, 0, 0, 540, 6714, 1, 0, 0, 0, 542, 6718, 1, 0, 0, 0, 544, 6744, 1, 0, 0, 0, 546, 6764, 1, 0, 0, 0, 548, 6771, 1, 0, 0, 0, 550, 6773, 1, 0, 0, 0, 552, 6775, 1, 0, 0, 0, 554, 6777, 1, 0, 0, 0, 556, 6800, 1, 0, 0, 0, 558, 6849, 1, 0, 0, 0, 560, 6851, 1, 0, 0, 0, 562, 6861, 1, 0, 0, 0, 564, 6866, 1, 0, 0, 0, 566, 6870, 1, 0, 0, 0, 568, 6876, 1, 0, 0, 0, 570, 6880, 1, 0, 0, 0, 572, 6888, 1, 0, 0, 0, 574, 6914, 1, 0, 0, 0, 576, 6916, 1, 0, 0, 0, 578, 6922, 1, 0, 0, 0, 580, 6925, 1, 0, 0, 0, 582, 6928, 1, 0, 0, 0, 584, 6931, 1, 0, 0, 0, 586, 6985, 1, 0, 0, 0, 588, 6987, 1, 0, 0, 0, 590, 6998, 1, 0, 0, 0, 592, 7006, 1, 0, 0, 0, 594, 7017, 1, 0, 0, 0, 596, 7019, 1, 0, 0, 0, 598, 7037, 1, 0, 0, 0, 600, 7039, 1, 0, 0, 0, 602, 7056, 1, 0, 0, 0, 604, 7066, 1, 0, 0, 0, 606, 7069, 1, 0, 0, 0, 608, 7078, 1, 0, 0, 0, 610, 7092, 1, 0, 0, 0, 612, 7106, 1, 0, 0, 0, 614, 7124, 1, 0, 0, 0, 616, 7139, 1, 0, 0, 0, 618, 7156, 1, 0, 0, 0, 620, 7180, 1, 0, 0, 0, 622, 7182, 1, 0, 0, 0, 624, 7211, 1, 0, 0, 0, 626, 7240, 1, 0, 0, 0, 628, 7242, 1, 0, 0, 0, 630, 7244, 1, 0, 0, 0, 632, 7260, 1, 0, 0, 0, 634, 7272, 1, 0, 0, 0, 636, 7305, 1, 0, 0, 0, 638, 7322, 1, 0, 0, 0, 640, 7339, 1, 0, 0, 0, 642, 7355, 1, 0, 0, 0, 644, 7394, 1, 0, 0, 0, 646, 7401, 1, 0, 0, 0, 648, 7405, 1, 0, 0, 0, 650, 7413, 1, 0, 0, 0, 652, 7415, 1, 0, 0, 0, 654, 7433, 1, 0, 0, 0, 656, 7445, 1, 0, 0, 0, 658, 7462, 1, 0, 0, 0, 660, 7477, 1, 0, 0, 0, 662, 7487, 1, 0, 0, 0, 664, 7493, 1, 0, 0, 0, 666, 7497, 1, 0, 0, 0, 668, 7499, 1, 0, 0, 0, 670, 7501, 1, 0, 0, 0, 672, 7516, 1, 0, 0, 0, 674, 7584, 1, 0, 0, 0, 676, 7615, 1, 0, 0, 0, 678, 7617, 1, 0, 0, 0, 680, 7625, 1, 0, 0, 0, 682, 7675, 1, 0, 0, 0, 684, 7677, 1, 0, 0, 0, 686, 7684, 1, 0, 0, 0, 688, 7689, 1, 0, 0, 0, 690, 7691, 1, 0, 0, 0, 692, 7701, 1, 0, 0, 0, 694, 7762, 1, 0, 0, 0, 696, 7777, 1, 0, 0, 0, 698, 7779, 1, 0, 0, 0, 700, 7784, 1, 0, 0, 0, 702, 7786, 1, 0, 0, 0, 704, 7796, 1, 0, 0, 0, 706, 7798, 1, 0, 0, 0, 708, 7800, 1, 0, 0, 0, 710, 7802, 1, 0, 0, 0, 712, 7806, 1, 0, 0, 0, 714, 7808, 1, 0, 0, 0, 716, 7814, 1, 0, 0, 0, 718, 7861, 1, 0, 0, 0, 720, 7863, 1, 0, 0, 0, 722, 7890, 1, 0, 0, 0, 724, 7894, 1, 0, 0, 0, 726, 7935, 1, 0, 0, 0, 728, 7937, 1, 0, 0, 0, 730, 7946, 1, 0, 0, 0, 732, 7957, 1, 0, 0, 0, 734, 7961, 1, 0, 0, 0, 736, 7963, 1, 0, 0, 0, 738, 7981, 1, 0, 0, 0, 740, 7988, 1, 0, 0, 0, 742, 7995, 1, 0, 0, 0, 744, 8069, 1, 0, 0, 0, 746, 8071, 1, 0, 0, 0, 748, 8078, 1, 0, 0, 0, 750, 8205, 1, 0, 0, 0, 752, 8216, 1, 0, 0, 0, 754, 8227, 1, 0, 0, 0, 756, 8258, 1, 0, 0, 0, 758, 8266, 1, 0, 0, 0, 760, 8282, 1, 0, 0, 0, 762, 8306, 1, 0, 0, 0, 764, 8311, 1, 0, 0, 0, 766, 8364, 1, 0, 0, 0, 768, 8368, 1, 0, 0, 0, 770, 8383, 1, 0, 0, 0, 772, 8390, 1, 0, 0, 0, 774, 8407, 1, 0, 0, 0, 776, 8430, 1, 0, 0, 0, 778, 8486, 1, 0, 0, 0, 780, 8497, 1, 0, 0, 0, 782, 8505, 1, 0, 0, 0, 784, 8520, 1, 0, 0, 0, 786, 8535, 1, 0, 0, 0, 788, 8537, 1, 0, 0, 0, 790, 8539, 1, 0, 0, 0, 792, 8576, 1, 0, 0, 0, 794, 8585, 1, 0, 0, 0, 796, 8605, 1, 0, 0, 0, 798, 8615, 1, 0, 0, 0, 800, 8619, 1, 0, 0, 0, 802, 8691, 1, 0, 0, 0, 804, 8702, 1, 0, 0, 0, 806, 8720, 1, 0, 0, 0, 808, 8724, 1, 0, 0, 0, 810, 8727, 1, 0, 0, 0, 812, 8730, 1, 0, 0, 0, 814, 8736, 1, 0, 0, 0, 816, 8741, 1, 0, 0, 0, 818, 8745, 1, 0, 0, 0, 820, 8794, 1, 0, 0, 0, 822, 8824, 1, 0, 0, 0, 824, 8846, 1, 0, 0, 0, 826, 8855, 1, 0, 0, 0, 828, 8859, 1, 0, 0, 0, 830, 8882, 1, 0, 0, 0, 832, 8884, 1, 0, 0, 0, 834, 8921, 1, 0, 0, 0, 836, 8924, 1, 0, 0, 0, 838, 8988, 1, 0, 0, 0, 840, 8993, 1, 0, 0, 0, 842, 8995, 1, 0, 0, 0, 844, 9015, 1, 0, 0, 0, 846, 9069, 1, 0, 0, 0, 848, 9098, 1, 0, 0, 0, 850, 9135, 1, 0, 0, 0, 852, 9139, 1, 0, 0, 0, 854, 9190, 1, 0, 0, 0, 856, 9194, 1, 0, 0, 0, 858, 9218, 1, 0, 0, 0, 860, 9245, 1, 0, 0, 0, 862, 9247, 1, 0, 0, 0, 864, 9249, 1, 0, 0, 0, 866, 9332, 1, 0, 0, 0, 868, 9340, 1, 0, 0, 0, 870, 9342, 1, 0, 0, 0, 872, 9348, 1, 0, 0, 0, 874, 9359, 1, 0, 0, 0, 876, 9361, 1, 0, 0, 0, 878, 9364, 1, 0, 0, 0, 880, 9366, 1, 0, 0, 0, 882, 9375, 1, 0, 0, 0, 884, 9405, 1, 0, 0, 0, 886, 9408, 1, 0, 0, 0, 888, 9410, 1, 0, 0, 0, 890, 9421, 1, 0, 0, 0, 892, 9426, 1, 0, 0, 0, 894, 9443, 1, 0, 0, 0, 896, 9460, 1, 0, 0, 0, 898, 9463, 1, 0, 0, 0, 900, 9514, 1, 0, 0, 0, 902, 9516, 1, 0, 0, 0, 904, 9524, 1, 0, 0, 0, 906, 9540, 1, 0, 0, 0, 908, 9553, 1, 0, 0, 0, 910, 9555, 1, 0, 0, 0, 912, 9594, 1, 0, 0, 0, 914, 9596, 1, 0, 0, 0, 916, 9602, 1, 0, 0, 0, 918, 9609, 1, 0, 0, 0, 920, 9633, 1, 0, 0, 0, 922, 9646, 1, 0, 0, 0, 924, 9658, 1, 0, 0, 0, 926, 9663, 1, 0, 0, 0, 928, 9681, 1, 0, 0, 0, 930, 9683, 1, 0, 0, 0, 932, 9686, 1, 0, 0, 0, 934, 9737, 1, 0, 0, 0, 936, 9739, 1, 0, 0, 0, 938, 9770, 1, 0, 0, 0, 940, 9772, 1, 0, 0, 0, 942, 9782, 1, 0, 0, 0, 944, 9807, 1, 0, 0, 0, 946, 9812, 1, 0, 0, 0, 948, 9817, 1, 0, 0, 0, 950, 9855, 1, 0, 0, 0, 952, 9917, 1, 0, 0, 0, 954, 9921, 1, 0, 0, 0, 956, 9926, 1, 0, 0, 0, 958, 9950, 1, 0, 0, 0, 960, 9963, 1, 0, 0, 0, 962, 9968, 1, 0, 0, 0, 964, 9994, 1, 0, 0, 0, 966, 9998, 1, 0, 0, 0, 968, 10003, 1, 0, 0, 0, 970, 10008, 1, 0, 0, 0, 972, 10016, 1, 0, 0, 0, 974, 10022, 1, 0, 0, 0, 976, 10025, 1, 0, 0, 0, 978, 10033, 1, 0, 0, 0, 980, 10039, 1, 0, 0, 0, 982, 10060, 1, 0, 0, 0, 984, 10083, 1, 0, 0, 0, 986, 10091, 1, 0, 0, 0, 988, 10093, 1, 0, 0, 0, 990, 10101, 1, 0, 0, 0, 992, 10113, 1, 0, 0, 0, 994, 10130, 1, 0, 0, 0, 996, 10133, 1, 0, 0, 0, 998, 10148, 1, 0, 0, 0, 1000, 10247, 1, 0, 0, 0, 1002, 10262, 1, 0, 0, 0, 1004, 10312, 1, 0, 0, 0, 1006, 10314, 1, 0, 0, 0, 1008, 10320, 1, 0, 0, 0, 1010, 10341, 1, 0, 0, 0, 1012, 10349, 1, 0, 0, 0, 1014, 10360, 1, 0, 0, 0, 1016, 10380, 1, 0, 0, 0, 1018, 10382, 1, 0, 0, 0, 1020, 10434, 1, 0, 0, 0, 1022, 10458, 1, 0, 0, 0, 1024, 10477, 1, 0, 0, 0, 1026, 10479, 1, 0, 0, 0, 1028, 10487, 1, 0, 0, 0, 1030, 10490, 1, 0, 0, 0, 1032, 10493, 1, 0, 0, 0, 1034, 10521, 1, 0, 0, 0, 1036, 10546, 1, 0, 0, 0, 1038, 10555, 1, 0, 0, 0, 1040, 10607, 1, 0, 0, 0, 1042, 10643, 1, 0, 0, 0, 1044, 10665, 1, 0, 0, 0, 1046, 10707, 1, 0, 0, 0, 1048, 10711, 1, 0, 0, 0, 1050, 10725, 1, 0, 0, 0, 1052, 10766, 1, 0, 0, 0, 1054, 10768, 1, 0, 0, 0, 1056, 10782, 1, 0, 0, 0, 1058, 10813, 1, 0, 0, 0, 1060, 10816, 1, 0, 0, 0, 1062, 10834, 1, 0, 0, 0, 1064, 10840, 1, 0, 0, 0, 1066, 10859, 1, 0, 0, 0, 1068, 10863, 1, 0, 0, 0, 1070, 10865, 1, 0, 0, 0, 1072, 10874, 1, 0, 0, 0, 1074, 10889, 1, 0, 0, 0, 1076, 10893, 1, 0, 0, 0, 1078, 10902, 1, 0, 0, 0, 1080, 10917, 1, 0, 0, 0, 1082, 10923, 1, 0, 0, 0, 1084, 10955, 1, 0, 0, 0, 1086, 10957, 1, 0, 0, 0, 1088, 10960, 1, 0, 0, 0, 1090, 10963, 1, 0, 0, 0, 1092, 10989, 1, 0, 0, 0, 1094, 11000, 1, 0, 0, 0, 1096, 11012, 1, 0, 0, 0, 1098, 11014, 1, 0, 0, 0, 1100, 11033, 1, 0, 0, 0, 1102, 11035, 1, 0, 0, 0, 1104, 11046, 1, 0, 0, 0, 1106, 11060, 1, 0, 0, 0, 1108, 11081, 1, 0, 0, 0, 1110, 11083, 1, 0, 0, 0, 1112, 11091, 1, 0, 0, 0, 1114, 11101, 1, 0, 0, 0, 1116, 11103, 1, 0, 0, 0, 1118, 11159, 1, 0, 0, 0, 1120, 11207, 1, 0, 0, 0, 1122, 11224, 1, 0, 0, 0, 1124, 11247, 1, 0, 0, 0, 1126, 11284, 1, 0, 0, 0, 1128, 11286, 1, 0, 0, 0, 1130, 11336, 1, 0, 0, 0, 1132, 11358, 1, 0, 0, 0, 1134, 11378, 1, 0, 0, 0, 1136, 11397, 1, 0, 0, 0, 1138, 11403, 1, 0, 0, 0, 1140, 11418, 1, 0, 0, 0, 1142, 11460, 1, 0, 0, 0, 1144, 11502, 1, 0, 0, 0, 1146, 11536, 1, 0, 0, 0, 1148, 11538, 1, 0, 0, 0, 1150, 11554, 1, 0, 0, 0, 1152, 11563, 1, 0, 0, 0, 1154, 11596, 1, 0, 0, 0, 1156, 11598, 1, 0, 0, 0, 1158, 11606, 1, 0, 0, 0, 1160, 11614, 1, 0, 0, 0, 1162, 11621, 1, 0, 0, 0, 1164, 11638, 1, 0, 0, 0, 1166, 11663, 1, 0, 0, 0, 1168, 11665, 1, 0, 0, 0, 1170, 11691, 1, 0, 0, 0, 1172, 11750, 1, 0, 0, 0, 1174, 11754, 1, 0, 0, 0, 1176, 11778, 1, 0, 0, 0, 1178, 11823, 1, 0, 0, 0, 1180, 11844, 1, 0, 0, 0, 1182, 11850, 1, 0, 0, 0, 1184, 11865, 1, 0, 0, 0, 1186, 11867, 1, 0, 0, 0, 1188, 11870, 1, 0, 0, 0, 1190, 11897, 1, 0, 0, 0, 1192, 11905, 1, 0, 0, 0, 1194, 11921, 1, 0, 0, 0, 1196, 11925, 1, 0, 0, 0, 1198, 11960, 1, 0, 0, 0, 1200, 11975, 1, 0, 0, 0, 1202, 12022, 1, 0, 0, 0, 1204, 12024, 1, 0, 0, 0, 1206, 12039, 1, 0, 0, 0, 1208, 12060, 1, 0, 0, 0, 1210, 12062, 1, 0, 0, 0, 1212, 12090, 1, 0, 0, 0, 1214, 12092, 1, 0, 0, 0, 1216, 12104, 1, 0, 0, 0, 1218, 12111, 1, 0, 0, 0, 1220, 12115, 1, 0, 0, 0, 1222, 12123, 1, 0, 0, 0, 1224, 12144, 1, 0, 0, 0, 1226, 12149, 1, 0, 0, 0, 1228, 12206, 1, 0, 0, 0, 1230, 12208, 1, 0, 0, 0, 1232, 12246, 1, 0, 0, 0, 1234, 12257, 1, 0, 0, 0, 1236, 12265, 1, 0, 0, 0, 1238, 12276, 1, 0, 0, 0, 1240, 12387, 1, 0, 0, 0, 1242, 12414, 1, 0, 0, 0, 1244, 12416, 1, 0, 0, 0, 1246, 12419, 1, 0, 0, 0, 1248, 12437, 1, 0, 0, 0, 1250, 12440, 1, 0, 0, 0, 1252, 12462, 1, 0, 0, 0, 1254, 12507, 1, 0, 0, 0, 1256, 12546, 1, 0, 0, 0, 1258, 12554, 1, 0, 0, 0, 1260, 12556, 1, 0, 0, 0, 1262, 12674, 1, 0, 0, 0, 1264, 12676, 1, 0, 0, 0, 1266, 12773, 1, 0, 0, 0, 1268, 12811, 1, 0, 0, 0, 1270, 12828, 1, 0, 0, 0, 1272, 12831, 1, 0, 0, 0, 1274, 12844, 1, 0, 0, 0, 1276, 12848, 1, 0, 0, 0, 1278, 12890, 1, 0, 0, 0, 1280, 12892, 1, 0, 0, 0, 1282, 12915, 1, 0, 0, 0, 1284, 12938, 1, 0, 0, 0, 1286, 12954, 1, 0, 0, 0, 1288, 12960, 1, 0, 0, 0, 1290, 12972, 1, 0, 0, 0, 1292, 12976, 1, 0, 0, 0, 1294, 12985, 1, 0, 0, 0, 1296, 13009, 1, 0, 0, 0, 1298, 13034, 1, 0, 0, 0, 1300, 13050, 1, 0, 0, 0, 1302, 13057, 1, 0, 0, 0, 1304, 13067, 1, 0, 0, 0, 1306, 13078, 1, 0, 0, 0, 1308, 13085, 1, 0, 0, 0, 1310, 13087, 1, 0, 0, 0, 1312, 13089, 1, 0, 0, 0, 1314, 13149, 1, 0, 0, 0, 1316, 13151, 1, 0, 0, 0, 1318, 13165, 1, 0, 0, 0, 1320, 13184, 1, 0, 0, 0, 1322, 13186, 1, 0, 0, 0, 1324, 13188, 1, 0, 0, 0, 1326, 13195, 1, 0, 0, 0, 1328, 13203, 1, 0, 0, 0, 1330, 13220, 1, 0, 0, 0, 1332, 13250, 1, 0, 0, 0, 1334, 13254, 1, 0, 0, 0, 1336, 13262, 1, 0, 0, 0, 1338, 13284, 1, 0, 0, 0, 1340, 13299, 1, 0, 0, 0, 1342, 13349, 1, 0, 0, 0, 1344, 13365, 1, 0, 0, 0, 1346, 13375, 1, 0, 0, 0, 1348, 13385, 1, 0, 0, 0, 1350, 13390, 1, 0, 0, 0, 1352, 13395, 1, 0, 0, 0, 1354, 13406, 1, 0, 0, 0, 1356, 13410, 1, 0, 0, 0, 1358, 13414, 1, 0, 0, 0, 1360, 13427, 1, 0, 0, 0, 1362, 13433, 1, 0, 0, 0, 1364, 13440, 1, 0, 0, 0, 1366, 13442, 1, 0, 0, 0, 1368, 13444, 1, 0, 0, 0, 1370, 13464, 1, 0, 0, 0, 1372, 13489, 1, 0, 0, 0, 1374, 13491, 1, 0, 0, 0, 1376, 13493, 1, 0, 0, 0, 1378, 13500, 1, 0, 0, 0, 1380, 13502, 1, 0, 0, 0, 1382, 13504, 1, 0, 0, 0, 1384, 13537, 1, 0, 0, 0, 1386, 13582, 1, 0, 0, 0, 1388, 13584, 1, 0, 0, 0, 1390, 13615, 1, 0, 0, 0, 1392, 13652, 1, 0, 0, 0, 1394, 13671, 1, 0, 0, 0, 1396, 13673, 1, 0, 0, 0, 1398, 13693, 1, 0, 0, 0, 1400, 13721, 1, 0, 0, 0, 1402, 13746, 1, 0, 0, 0, 1404, 13828, 1, 0, 0, 0, 1406, 13830, 1, 0, 0, 0, 1408, 13874, 1, 0, 0, 0, 1410, 13878, 1, 0, 0, 0, 1412, 13902, 1, 0, 0, 0, 1414, 13909, 1, 0, 0, 0, 1416, 13917, 1, 0, 0, 0, 1418, 13919, 1, 0, 0, 0, 1420, 13938, 1, 0, 0, 0, 1422, 13961, 1, 0, 0, 0, 1424, 13963, 1, 0, 0, 0, 1426, 13981, 1, 0, 0, 0, 1428, 13986, 1, 0, 0, 0, 1430, 13996, 1, 0, 0, 0, 1432, 14003, 1, 0, 0, 0, 1434, 14011, 1, 0, 0, 0, 1436, 14044, 1, 0, 0, 0, 1438, 14067, 1, 0, 0, 0, 1440, 14072, 1, 0, 0, 0, 1442, 14123, 1, 0, 0, 0, 1444, 14125, 1, 0, 0, 0, 1446, 14130, 1, 0, 0, 0, 1448, 14134, 1, 0, 0, 0, 1450, 14137, 1, 0, 0, 0, 1452, 14139, 1, 0, 0, 0, 1454, 14141, 1, 0, 0, 0, 1456, 14143, 1, 0, 0, 0, 1458, 14145, 1, 0, 0, 0, 1460, 14147, 1, 0, 0, 0, 1462, 14161, 1, 0, 0, 0, 1464, 14166, 1, 0, 0, 0, 1466, 14173, 1, 0, 0, 0, 1468, 14175, 1, 0, 0, 0, 1470, 14180, 1, 0, 0, 0, 1472, 14185, 1, 0, 0, 0, 1474, 14191, 1, 0, 0, 0, 1476, 14195, 1, 0, 0, 0, 1478, 14221, 1, 0, 0, 0, 1480, 14223, 1, 0, 0, 0, 1482, 14230, 1, 0, 0, 0, 1484, 14242, 1, 0, 0, 0, 1486, 14302, 1, 0, 0, 0, 1488, 14306, 1, 0, 0, 0, 1490, 14328, 1, 0, 0, 0, 1492, 14330, 1, 0, 0, 0, 1494, 14350, 1, 0, 0, 0, 1496, 14366, 1, 0, 0, 0, 1498, 14371, 1, 0, 0, 0, 1500, 14379, 1, 0, 0, 0, 1502, 14383, 1, 0, 0, 0, 1504, 14394, 1, 0, 0, 0, 1506, 14422, 1, 0, 0, 0, 1508, 14438, 1, 0, 0, 0, 1510, 14447, 1, 0, 0, 0, 1512, 14479, 1, 0, 0, 0, 1514, 14487, 1, 0, 0, 0, 1516, 14520, 1, 0, 0, 0, 1518, 14522, 1, 0, 0, 0, 1520, 14549, 1, 0, 0, 0, 1522, 14568, 1, 0, 0, 0, 1524, 14594, 1, 0, 0, 0, 1526, 14596, 1, 0, 0, 0, 1528, 14628, 1, 0, 0, 0, 1530, 14651, 1, 0, 0, 0, 1532, 14664, 1, 0, 0, 0, 1534, 14666, 1, 0, 0, 0, 1536, 14685, 1, 0, 0, 0, 1538, 14696, 1, 0, 0, 0, 1540, 14705, 1, 0, 0, 0, 1542, 14730, 1, 0, 0, 0, 1544, 14784, 1, 0, 0, 0, 1546, 14808, 1, 0, 0, 0, 1548, 14822, 1, 0, 0, 0, 1550, 14832, 1, 0, 0, 0, 1552, 14841, 1, 0, 0, 0, 1554, 14870, 1, 0, 0, 0, 1556, 14874, 1, 0, 0, 0, 1558, 14882, 1, 0, 0, 0, 1560, 14919, 1, 0, 0, 0, 1562, 14972, 1, 0, 0, 0, 1564, 14983, 1, 0, 0, 0, 1566, 14985, 1, 0, 0, 0, 1568, 15001, 1, 0, 0, 0, 1570, 15003, 1, 0, 0, 0, 1572, 15028, 1, 0, 0, 0, 1574, 15030, 1, 0, 0, 0, 1576, 15034, 1, 0, 0, 0, 1578, 15042, 1, 0, 0, 0, 1580, 15056, 1, 0, 0, 0, 1582, 15067, 1, 0, 0, 0, 1584, 15082, 1, 0, 0, 0, 1586, 15117, 1, 0, 0, 0, 1588, 15139, 1, 0, 0, 0, 1590, 15143, 1, 0, 0, 0, 1592, 15145, 1, 0, 0, 0, 1594, 15149, 1, 0, 0, 0, 1596, 15184, 1, 0, 0, 0, 1598, 15189, 1, 0, 0, 0, 1600, 15194, 1, 0, 0, 0, 1602, 15198, 1, 0, 0, 0, 1604, 15208, 1, 0, 0, 0, 1606, 15210, 1, 0, 0, 0, 1608, 15218, 1, 0, 0, 0, 1610, 15220, 1, 0, 0, 0, 1612, 15226, 1, 0, 0, 0, 1614, 15228, 1, 0, 0, 0, 1616, 15234, 1, 0, 0, 0, 1618, 15300, 1, 0, 0, 0, 1620, 15302, 1, 0, 0, 0, 1622, 15330, 1, 0, 0, 0, 1624, 15359, 1, 0, 0, 0, 1626, 15362, 1, 0, 0, 0, 1628, 15374, 1, 0, 0, 0, 1630, 15401, 1, 0, 0, 0, 1632, 15410, 1, 0, 0, 0, 1634, 15428, 1, 0, 0, 0, 1636, 15433, 1, 0, 0, 0, 1638, 15442, 1, 0, 0, 0, 1640, 15444, 1, 0, 0, 0, 1642, 15491, 1, 0, 0, 0, 1644, 15524, 1, 0, 0, 0, 1646, 15553, 1, 0, 0, 0, 1648, 15557, 1, 0, 0, 0, 1650, 15564, 1, 0, 0, 0, 1652, 15566, 1, 0, 0, 0, 1654, 15576, 1, 0, 0, 0, 1656, 15592, 1, 0, 0, 0, 1658, 15597, 1, 0, 0, 0, 1660, 15626, 1, 0, 0, 0, 1662, 15630, 1, 0, 0, 0, 1664, 15665, 1, 0, 0, 0, 1666, 15677, 1, 0, 0, 0, 1668, 15679, 1, 0, 0, 0, 1670, 15681, 1, 0, 0, 0, 1672, 15722, 1, 0, 0, 0, 1674, 15724, 1, 0, 0, 0, 1676, 15752, 1, 0, 0, 0, 1678, 15782, 1, 0, 0, 0, 1680, 15784, 1, 0, 0, 0, 1682, 15846, 1, 0, 0, 0, 1684, 15848, 1, 0, 0, 0, 1686, 15871, 1, 0, 0, 0, 1688, 15876, 1, 0, 0, 0, 1690, 15884, 1, 0, 0, 0, 1692, 15921, 1, 0, 0, 0, 1694, 15942, 1, 0, 0, 0, 1696, 15946, 1, 0, 0, 0, 1698, 15948, 1, 0, 0, 0, 1700, 15954, 1, 0, 0, 0, 1702, 16012, 1, 0, 0, 0, 1704, 16014, 1, 0, 0, 0, 1706, 16016, 1, 0, 0, 0, 1708, 16018, 1, 0, 0, 0, 1710, 16047, 1, 0, 0, 0, 1712, 16054, 1, 0, 0, 0, 1714, 16061, 1, 0, 0, 0, 1716, 16075, 1, 0, 0, 0, 1718, 16086, 1, 0, 0, 0, 1720, 16100, 1, 0, 0, 0, 1722, 16105, 1, 0, 0, 0, 1724, 16107, 1, 0, 0, 0, 1726, 16115, 1, 0, 0, 0, 1728, 16140, 1, 0, 0, 0, 1730, 16146, 1, 0, 0, 0, 1732, 16178, 1, 0, 0, 0, 1734, 16189, 1, 0, 0, 0, 1736, 16191, 1, 0, 0, 0, 1738, 16204, 1, 0, 0, 0, 1740, 16208, 1, 0, 0, 0, 1742, 16223, 1, 0, 0, 0, 1744, 16225, 1, 0, 0, 0, 1746, 16241, 1, 0, 0, 0, 1748, 16258, 1, 0, 0, 0, 1750, 16283, 1, 0, 0, 0, 1752, 16293, 1, 0, 0, 0, 1754, 16297, 1, 0, 0, 0, 1756, 16342, 1, 0, 0, 0, 1758, 16354, 1, 0, 0, 0, 1760, 16365, 1, 0, 0, 0, 1762, 16371, 1, 0, 0, 0, 1764, 16382, 1, 0, 0, 0, 1766, 16394, 1, 0, 0, 0, 1768, 16404, 1, 0, 0, 0, 1770, 16426, 1, 0, 0, 0, 1772, 16430, 1, 0, 0, 0, 1774, 16453, 1, 0, 0, 0, 1776, 16457, 1, 0, 0, 0, 1778, 16462, 1, 0, 0, 0, 1780, 16470, 1, 0, 0, 0, 1782, 16478, 1, 0, 0, 0, 1784, 16481, 1, 0, 0, 0, 1786, 16497, 1, 0, 0, 0, 1788, 16502, 1, 0, 0, 0, 1790, 16506, 1, 0, 0, 0, 1792, 16546, 1, 0, 0, 0, 1794, 16548, 1, 0, 0, 0, 1796, 16573, 1, 0, 0, 0, 1798, 16575, 1, 0, 0, 0, 1800, 16580, 1, 0, 0, 0, 1802, 16582, 1, 0, 0, 0, 1804, 16584, 1, 0, 0, 0, 1806, 16586, 1, 0, 0, 0, 1808, 16590, 1, 0, 0, 0, 1810, 16595, 1, 0, 0, 0, 1812, 16615, 1, 0, 0, 0, 1814, 16621, 1, 0, 0, 0, 1816, 16638, 1, 0, 0, 0, 1818, 16652, 1, 0, 0, 0, 1820, 16656, 1, 0, 0, 0, 1822, 16670, 1, 0, 0, 0, 1824, 16689, 1, 0, 0, 0, 1826, 16696, 1, 0, 0, 0, 1828, 16708, 1, 0, 0, 0, 1830, 16717, 1, 0, 0, 0, 1832, 16719, 1, 0, 0, 0, 1834, 16733, 1, 0, 0, 0, 1836, 16743, 1, 0, 0, 0, 1838, 16749, 1, 0, 0, 0, 1840, 16751, 1, 0, 0, 0, 1842, 16754, 1, 0, 0, 0, 1844, 16763, 1, 0, 0, 0, 1846, 16796, 1, 0, 0, 0, 1848, 16798, 1, 0, 0, 0, 1850, 16813, 1, 0, 0, 0, 1852, 16815, 1, 0, 0, 0, 1854, 16836, 1, 0, 0, 0, 1856, 16851, 1, 0, 0, 0, 1858, 16876, 1, 0, 0, 0, 1860, 16884, 1, 0, 0, 0, 1862, 16897, 1, 0, 0, 0, 1864, 16900, 1, 0, 0, 0, 1866, 16925, 1, 0, 0, 0, 1868, 16946, 1, 0, 0, 0, 1870, 16950, 1, 0, 0, 0, 1872, 16993, 1, 0, 0, 0, 1874, 16997, 1, 0, 0, 0, 1876, 16999, 1, 0, 0, 0, 1878, 17016, 1, 0, 0, 0, 1880, 17059, 1, 0, 0, 0, 1882, 17068, 1, 0, 0, 0, 1884, 17076, 1, 0, 0, 0, 1886, 17087, 1, 0, 0, 0, 1888, 17099, 1, 0, 0, 0, 1890, 17114, 1, 0, 0, 0, 1892, 17119, 1, 0, 0, 0, 1894, 17132, 1, 0, 0, 0, 1896, 17138, 1, 0, 0, 0, 1898, 17150, 1, 0, 0, 0, 1900, 17158, 1, 0, 0, 0, 1902, 17162, 1, 0, 0, 0, 1904, 17204, 1, 0, 0, 0, 1906, 17206, 1, 0, 0, 0, 1908, 17217, 1, 0, 0, 0, 1910, 17219, 1, 0, 0, 0, 1912, 17227, 1, 0, 0, 0, 1914, 17238, 1, 0, 0, 0, 1916, 17272, 1, 0, 0, 0, 1918, 17299, 1, 0, 0, 0, 1920, 17301, 1, 0, 0, 0, 1922, 17304, 1, 0, 0, 0, 1924, 17307, 1, 0, 0, 0, 1926, 17311, 1, 0, 0, 0, 1928, 17347, 1, 0, 0, 0, 1930, 17349, 1, 0, 0, 0, 1932, 17374, 1, 0, 0, 0, 1934, 17379, 1, 0, 0, 0, 1936, 17384, 1, 0, 0, 0, 1938, 17407, 1, 0, 0, 0, 1940, 17417, 1, 0, 0, 0, 1942, 17419, 1, 0, 0, 0, 1944, 17435, 1, 0, 0, 0, 1946, 17449, 1, 0, 0, 0, 1948, 17485, 1, 0, 0, 0, 1950, 17487, 1, 0, 0, 0, 1952, 17517, 1, 0, 0, 0, 1954, 17522, 1, 0, 0, 0, 1956, 17524, 1, 0, 0, 0, 1958, 17536, 1, 0, 0, 0, 1960, 17556, 1, 0, 0, 0, 1962, 17558, 1, 0, 0, 0, 1964, 17561, 1, 0, 0, 0, 1966, 17587, 1, 0, 0, 0, 1968, 17589, 1, 0, 0, 0, 1970, 17593, 1, 0, 0, 0, 1972, 17608, 1, 0, 0, 0, 1974, 17620, 1, 0, 0, 0, 1976, 17628, 1, 0, 0, 0, 1978, 17632, 1, 0, 0, 0, 1980, 17645, 1, 0, 0, 0, 1982, 17651, 1, 0, 0, 0, 1984, 17666, 1, 0, 0, 0, 1986, 17686, 1, 0, 0, 0, 1988, 17695, 1, 0, 0, 0, 1990, 17697, 1, 0, 0, 0, 1992, 17704, 1, 0, 0, 0, 1994, 17709, 1, 0, 0, 0, 1996, 17722, 1, 0, 0, 0, 1998, 17730, 1, 0, 0, 0, 2000, 17734, 1, 0, 0, 0, 2002, 17748, 1, 0, 0, 0, 2004, 17756, 1, 0, 0, 0, 2006, 17764, 1, 0, 0, 0, 2008, 17766, 1, 0, 0, 0, 2010, 17778, 1, 0, 0, 0, 2012, 17804, 1, 0, 0, 0, 2014, 17806, 1, 0, 0, 0, 2016, 17820, 1, 0, 0, 0, 2018, 17825, 1, 0, 0, 0, 2020, 17843, 1, 0, 0, 0, 2022, 17847, 1, 0, 0, 0, 2024, 17855, 1, 0, 0, 0, 2026, 17865, 1, 0, 0, 0, 2028, 17873, 1, 0, 0, 0, 2030, 17879, 1, 0, 0, 0, 2032, 17887, 1, 0, 0, 0, 2034, 17896, 1, 0, 0, 0, 2036, 17921, 1, 0, 0, 0, 2038, 17940, 1, 0, 0, 0, 2040, 17944, 1, 0, 0, 0, 2042, 17947, 1, 0, 0, 0, 2044, 17969, 1, 0, 0, 0, 2046, 17974, 1, 0, 0, 0, 2048, 17993, 1, 0, 0, 0, 2050, 17995, 1, 0, 0, 0, 2052, 18011, 1, 0, 0, 0, 2054, 18019, 1, 0, 0, 0, 2056, 18024, 1, 0, 0, 0, 2058, 18028, 1, 0, 0, 0, 2060, 18039, 1, 0, 0, 0, 2062, 18042, 1, 0, 0, 0, 2064, 18084, 1, 0, 0, 0, 2066, 18086, 1, 0, 0, 0, 2068, 18099, 1, 0, 0, 0, 2070, 18110, 1, 0, 0, 0, 2072, 18124, 1, 0, 0, 0, 2074, 18135, 1, 0, 0, 0, 2076, 18137, 1, 0, 0, 0, 2078, 18147, 1, 0, 0, 0, 2080, 18149, 1, 0, 0, 0, 2082, 18154, 1, 0, 0, 0, 2084, 18169, 1, 0, 0, 0, 2086, 18175, 1, 0, 0, 0, 2088, 18219, 1, 0, 0, 0, 2090, 18221, 1, 0, 0, 0, 2092, 18245, 1, 0, 0, 0, 2094, 18263, 1, 0, 0, 0, 2096, 18295, 1, 0, 0, 0, 2098, 18315, 1, 0, 0, 0, 2100, 18317, 1, 0, 0, 0, 2102, 18321, 1, 0, 0, 0, 2104, 18383, 1, 0, 0, 0, 2106, 18386, 1, 0, 0, 0, 2108, 18418, 1, 0, 0, 0, 2110, 18420, 1, 0, 0, 0, 2112, 18441, 1, 0, 0, 0, 2114, 18475, 1, 0, 0, 0, 2116, 18483, 1, 0, 0, 0, 2118, 18485, 1, 0, 0, 0, 2120, 18504, 1, 0, 0, 0, 2122, 18517, 1, 0, 0, 0, 2124, 18520, 1, 0, 0, 0, 2126, 18540, 1, 0, 0, 0, 2128, 18558, 1, 0, 0, 0, 2130, 18563, 1, 0, 0, 0, 2132, 18568, 1, 0, 0, 0, 2134, 18570, 1, 0, 0, 0, 2136, 18584, 1, 0, 0, 0, 2138, 18597, 1, 0, 0, 0, 2140, 18602, 1, 0, 0, 0, 2142, 18625, 1, 0, 0, 0, 2144, 18627, 1, 0, 0, 0, 2146, 18731, 1, 0, 0, 0, 2148, 18738, 1, 0, 0, 0, 2150, 18928, 1, 0, 0, 0, 2152, 18939, 1, 0, 0, 0, 2154, 18969, 1, 0, 0, 0, 2156, 18975, 1, 0, 0, 0, 2158, 19006, 1, 0, 0, 0, 2160, 19012, 1, 0, 0, 0, 2162, 19016, 1, 0, 0, 0, 2164, 19117, 1, 0, 0, 0, 2166, 19119, 1, 0, 0, 0, 2168, 19184, 1, 0, 0, 0, 2170, 19188, 1, 0, 0, 0, 2172, 19207, 1, 0, 0, 0, 2174, 19222, 1, 0, 0, 0, 2176, 19231, 1, 0, 0, 0, 2178, 19243, 1, 0, 0, 0, 2180, 19248, 1, 0, 0, 0, 2182, 19291, 1, 0, 0, 0, 2184, 19293, 1, 0, 0, 0, 2186, 19311, 1, 0, 0, 0, 2188, 19313, 1, 0, 0, 0, 2190, 19400, 1, 0, 0, 0, 2192, 19402, 1, 0, 0, 0, 2194, 19833, 1, 0, 0, 0, 2196, 19835, 1, 0, 0, 0, 2198, 19837, 1, 0, 0, 0, 2200, 19839, 1, 0, 0, 0, 2202, 19841, 1, 0, 0, 0, 2204, 19867, 1, 0, 0, 0, 2206, 19876, 1, 0, 0, 0, 2208, 19885, 1, 0, 0, 0, 2210, 19887, 1, 0, 0, 0, 2212, 19907, 1, 0, 0, 0, 2214, 19911, 1, 0, 0, 0, 2216, 19913, 1, 0, 0, 0, 2218, 19930, 1, 0, 0, 0, 2220, 19940, 1, 0, 0, 0, 2222, 19951, 1, 0, 0, 0, 2224, 19975, 1, 0, 0, 0, 2226, 19994, 1, 0, 0, 0, 2228, 20012, 1, 0, 0, 0, 2230, 20033, 1, 0, 0, 0, 2232, 20046, 1, 0, 0, 0, 2234, 20049, 1, 0, 0, 0, 2236, 20059, 1, 0, 0, 0, 2238, 20065, 1, 0, 0, 0, 2240, 20073, 1, 0, 0, 0, 2242, 20076, 1, 0, 0, 0, 2244, 20087, 1, 0, 0, 0, 2246, 20089, 1, 0, 0, 0, 2248, 20108, 1, 0, 0, 0, 2250, 20118, 1, 0, 0, 0, 2252, 20131, 1, 0, 0, 0, 2254, 20138, 1, 0, 0, 0, 2256, 20145, 1, 0, 0, 0, 2258, 20162, 1, 0, 0, 0, 2260, 20181, 1, 0, 0, 0, 2262, 20199, 1, 0, 0, 0, 2264, 20217, 1, 0, 0, 0, 2266, 20219, 1, 0, 0, 0, 2268, 20237, 1, 0, 0, 0, 2270, 20241, 1, 0, 0, 0, 2272, 20243, 1, 0, 0, 0, 2274, 20252, 1, 0, 0, 0, 2276, 20271, 1, 0, 0, 0, 2278, 20273, 1, 0, 0, 0, 2280, 20275, 1, 0, 0, 0, 2282, 20277, 1, 0, 0, 0, 2284, 20279, 1, 0, 0, 0, 2286, 20281, 1, 0, 0, 0, 2288, 20283, 1, 0, 0, 0, 2290, 20295, 1, 0, 0, 0, 2292, 20297, 1, 0, 0, 0, 2294, 20302, 1, 0, 0, 0, 2296, 20304, 1, 0, 0, 0, 2298, 20306, 1, 0, 0, 0, 2300, 20308, 1, 0, 0, 0, 2302, 20313, 1, 0, 0, 0, 2304, 20321, 1, 0, 0, 0, 2306, 20323, 1, 0, 0, 0, 2308, 20329, 1, 0, 0, 0, 2310, 20331, 1, 0, 0, 0, 2312, 20343, 1, 0, 0, 0, 2314, 20345, 1, 0, 0, 0, 2316, 20353, 1, 0, 0, 0, 2318, 20361, 1, 0, 0, 0, 2320, 20369, 1, 0, 0, 0, 2322, 20374, 1, 0, 0, 0, 2324, 20379, 1, 0, 0, 0, 2326, 20394, 1, 0, 0, 0, 2328, 20396, 1, 0, 0, 0, 2330, 20403, 1, 0, 0, 0, 2332, 20407, 1, 0, 0, 0, 2334, 20409, 1, 0, 0, 0, 2336, 20421, 1, 0, 0, 0, 2338, 20423, 1, 0, 0, 0, 2340, 20425, 1, 0, 0, 0, 2342, 20447, 1, 0, 0, 0, 2344, 20449, 1, 0, 0, 0, 2346, 20476, 1, 0, 0, 0, 2348, 20484, 1, 0, 0, 0, 2350, 20486, 1, 0, 0, 0, 2352, 20488, 1, 0, 0, 0, 2354, 20490, 1, 0, 0, 0, 2356, 20516, 1, 0, 0, 0, 2358, 20518, 1, 0, 0, 0, 2360, 20526, 1, 0, 0, 0, 2362, 20530, 1, 0, 0, 0, 2364, 20542, 1, 0, 0, 0, 2366, 20557, 1, 0, 0, 0, 2368, 20578, 1, 0, 0, 0, 2370, 20620, 1, 0, 0, 0, 2372, 20627, 1, 0, 0, 0, 2374, 20639, 1, 0, 0, 0, 2376, 20672, 1, 0, 0, 0, 2378, 20674, 1, 0, 0, 0, 2380, 20756, 1, 0, 0, 0, 2382, 20761, 1, 0, 0, 0, 2384, 20786, 1, 0, 0, 0, 2386, 20802, 1, 0, 0, 0, 2388, 20817, 1, 0, 0, 0, 2390, 20863, 1, 0, 0, 0, 2392, 21191, 1, 0, 0, 0, 2394, 21256, 1, 0, 0, 0, 2396, 21263, 1, 0, 0, 0, 2398, 21265, 1, 0, 0, 0, 2400, 21268, 1, 0, 0, 0, 2402, 21272, 1, 0, 0, 0, 2404, 21278, 1, 0, 0, 0, 2406, 21280, 1, 0, 0, 0, 2408, 21282, 1, 0, 0, 0, 2410, 21408, 1, 0, 0, 0, 2412, 21410, 1, 0, 0, 0, 2414, 21412, 1, 0, 0, 0, 2416, 21414, 1, 0, 0, 0, 2418, 2420, 3, 2252, 1126, 0, 2419, 2421, 5, 2470, 0, 0, 2420, 2419, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2418, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2429, 1, 0, 0, 0, 2426, 2424, 1, 0, 0, 0, 2427, 2430, 3, 2252, 1126, 0, 2428, 2430, 3, 2, 1, 0, 2429, 2427, 1, 0, 0, 0, 2429, 2428, 1, 0, 0, 0, 2430, 2441, 1, 0, 0, 0, 2431, 2433, 5, 2470, 0, 0, 2432, 2434, 5, 2454, 0, 0, 2433, 2432, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2438, 3, 2252, 1126, 0, 2436, 2438, 3, 2, 1, 0, 2437, 2435, 1, 0, 0, 0, 2437, 2436, 1, 0, 0, 0, 2438, 2440, 1, 0, 0, 0, 2439, 2431, 1, 0, 0, 0, 2440, 2443, 1, 0, 0, 0, 2441, 2439, 1, 0, 0, 0, 2441, 2442, 1, 0, 0, 0, 2442, 2445, 1, 0, 0, 0, 2443, 2441, 1, 0, 0, 0, 2444, 2446, 5, 2470, 0, 0, 2445, 2444, 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2448, 1, 0, 0, 0, 2447, 2449, 5, 2454, 0, 0, 2448, 2447, 1, 0, 0, 0, 2448, 2449, 1, 0, 0, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2451, 5, 0, 0, 1, 2451, 1, 1, 0, 0, 0, 2452, 2594, 3, 1328, 664, 0, 2453, 2594, 3, 1338, 669, 0, 2454, 2594, 3, 1340, 670, 0, 2455, 2594, 3, 1342, 671, 0, 2456, 2594, 3, 1368, 684, 0, 2457, 2594, 3, 1476, 738, 0, 2458, 2594, 3, 818, 409, 0, 2459, 2594, 3, 4, 2, 0, 2460, 2594, 3, 94, 47, 0, 2461, 2594, 3, 98, 49, 0, 2462, 2594, 3, 96, 48, 0, 2463, 2594, 3, 514, 257, 0, 2464, 2594, 3, 554, 277, 0, 2465, 2594, 3, 100, 50, 0, 2466, 2594, 3, 794, 397, 0, 2467, 2594, 3, 132, 66, 0, 2468, 2594, 3, 932, 466, 0, 2469, 2594, 3, 942, 471, 0, 2470, 2594, 3, 958, 479, 0, 2471, 2594, 3, 976, 488, 0, 2472, 2594, 3, 128, 64, 0, 2473, 2594, 3, 154, 77, 0, 2474, 2594, 3, 168, 84, 0, 2475, 2594, 3, 174, 87, 0, 2476, 2594, 3, 182, 91, 0, 2477, 2594, 3, 1522, 761, 0, 2478, 2594, 3, 186, 93, 0, 2479, 2594, 3, 318, 159, 0, 2480, 2594, 3, 320, 160, 0, 2481, 2594, 3, 1312, 656, 0, 2482, 2594, 3, 1526, 763, 0, 2483, 2594, 3, 864, 432, 0, 2484, 2594, 3, 1514, 757, 0, 2485, 2594, 3, 204, 102, 0, 2486, 2594, 3, 240, 120, 0, 2487, 2594, 3, 558, 279, 0, 2488, 2594, 3, 832, 416, 0, 2489, 2594, 3, 1718, 859, 0, 2490, 2594, 3, 1810, 905, 0, 2491, 2594, 3, 330, 165, 0, 2492, 2594, 3, 380, 190, 0, 2493, 2594, 3, 406, 203, 0, 2494, 2594, 3, 1018, 509, 0, 2495, 2594, 3, 1014, 507, 0, 2496, 2594, 3, 428, 214, 0, 2497, 2594, 3, 1482, 741, 0, 2498, 2594, 3, 1484, 742, 0, 2499, 2594, 3, 1510, 755, 0, 2500, 2594, 3, 782, 391, 0, 2501, 2594, 3, 784, 392, 0, 2502, 2594, 3, 438, 219, 0, 2503, 2594, 3, 442, 221, 0, 2504, 2594, 3, 444, 222, 0, 2505, 2594, 3, 104, 52, 0, 2506, 2594, 3, 450, 225, 0, 2507, 2594, 3, 462, 231, 0, 2508, 2594, 3, 790, 395, 0, 2509, 2594, 3, 800, 400, 0, 2510, 2594, 3, 802, 401, 0, 2511, 2594, 3, 1026, 513, 0, 2512, 2594, 3, 998, 499, 0, 2513, 2594, 3, 950, 475, 0, 2514, 2594, 3, 956, 478, 0, 2515, 2594, 3, 980, 490, 0, 2516, 2594, 3, 1032, 516, 0, 2517, 2594, 3, 156, 78, 0, 2518, 2594, 3, 158, 79, 0, 2519, 2594, 3, 194, 97, 0, 2520, 2594, 3, 180, 90, 0, 2521, 2594, 3, 1020, 510, 0, 2522, 2594, 3, 1034, 517, 0, 2523, 2594, 3, 1036, 518, 0, 2524, 2594, 3, 200, 100, 0, 2525, 2594, 3, 324, 162, 0, 2526, 2594, 3, 1318, 659, 0, 2527, 2594, 3, 1314, 657, 0, 2528, 2594, 3, 1038, 519, 0, 2529, 2594, 3, 880, 440, 0, 2530, 2594, 3, 898, 449, 0, 2531, 2594, 3, 206, 103, 0, 2532, 2594, 3, 256, 128, 0, 2533, 2594, 3, 556, 278, 0, 2534, 2594, 3, 836, 418, 0, 2535, 2594, 3, 1344, 672, 0, 2536, 2594, 3, 1346, 673, 0, 2537, 2594, 3, 1348, 674, 0, 2538, 2594, 3, 1352, 676, 0, 2539, 2594, 3, 1354, 677, 0, 2540, 2594, 3, 1508, 754, 0, 2541, 2594, 3, 1512, 756, 0, 2542, 2594, 3, 1356, 678, 0, 2543, 2594, 3, 1358, 679, 0, 2544, 2594, 3, 1360, 680, 0, 2545, 2594, 3, 1350, 675, 0, 2546, 2594, 3, 92, 46, 0, 2547, 2594, 3, 792, 396, 0, 2548, 2594, 3, 746, 373, 0, 2549, 2594, 3, 750, 375, 0, 2550, 2594, 3, 752, 376, 0, 2551, 2594, 3, 796, 398, 0, 2552, 2594, 3, 798, 399, 0, 2553, 2594, 3, 150, 75, 0, 2554, 2594, 3, 1010, 505, 0, 2555, 2594, 3, 1012, 506, 0, 2556, 2594, 3, 960, 480, 0, 2557, 2594, 3, 978, 489, 0, 2558, 2594, 3, 184, 92, 0, 2559, 2594, 3, 152, 76, 0, 2560, 2594, 3, 170, 85, 0, 2561, 2594, 3, 172, 86, 0, 2562, 2594, 3, 188, 94, 0, 2563, 2594, 3, 192, 96, 0, 2564, 2594, 3, 190, 95, 0, 2565, 2594, 3, 316, 158, 0, 2566, 2594, 3, 1316, 658, 0, 2567, 2594, 3, 1296, 648, 0, 2568, 2594, 3, 1298, 649, 0, 2569, 2594, 3, 1300, 650, 0, 2570, 2594, 3, 202, 101, 0, 2571, 2594, 3, 238, 119, 0, 2572, 2594, 3, 560, 280, 0, 2573, 2594, 3, 1304, 652, 0, 2574, 2594, 3, 596, 298, 0, 2575, 2594, 3, 672, 336, 0, 2576, 2594, 3, 690, 345, 0, 2577, 2594, 3, 720, 360, 0, 2578, 2594, 3, 1306, 653, 0, 2579, 2594, 3, 1326, 663, 0, 2580, 2594, 3, 1324, 662, 0, 2581, 2594, 3, 1836, 918, 0, 2582, 2594, 3, 748, 374, 0, 2583, 2594, 3, 754, 377, 0, 2584, 2594, 3, 764, 382, 0, 2585, 2594, 3, 760, 380, 0, 2586, 2594, 3, 758, 379, 0, 2587, 2594, 3, 762, 381, 0, 2588, 2594, 3, 768, 384, 0, 2589, 2594, 3, 1850, 925, 0, 2590, 2594, 3, 1362, 681, 0, 2591, 2594, 3, 1294, 647, 0, 2592, 2594, 3, 716, 358, 0, 2593, 2452, 1, 0, 0, 0, 2593, 2453, 1, 0, 0, 0, 2593, 2454, 1, 0, 0, 0, 2593, 2455, 1, 0, 0, 0, 2593, 2456, 1, 0, 0, 0, 2593, 2457, 1, 0, 0, 0, 2593, 2458, 1, 0, 0, 0, 2593, 2459, 1, 0, 0, 0, 2593, 2460, 1, 0, 0, 0, 2593, 2461, 1, 0, 0, 0, 2593, 2462, 1, 0, 0, 0, 2593, 2463, 1, 0, 0, 0, 2593, 2464, 1, 0, 0, 0, 2593, 2465, 1, 0, 0, 0, 2593, 2466, 1, 0, 0, 0, 2593, 2467, 1, 0, 0, 0, 2593, 2468, 1, 0, 0, 0, 2593, 2469, 1, 0, 0, 0, 2593, 2470, 1, 0, 0, 0, 2593, 2471, 1, 0, 0, 0, 2593, 2472, 1, 0, 0, 0, 2593, 2473, 1, 0, 0, 0, 2593, 2474, 1, 0, 0, 0, 2593, 2475, 1, 0, 0, 0, 2593, 2476, 1, 0, 0, 0, 2593, 2477, 1, 0, 0, 0, 2593, 2478, 1, 0, 0, 0, 2593, 2479, 1, 0, 0, 0, 2593, 2480, 1, 0, 0, 0, 2593, 2481, 1, 0, 0, 0, 2593, 2482, 1, 0, 0, 0, 2593, 2483, 1, 0, 0, 0, 2593, 2484, 1, 0, 0, 0, 2593, 2485, 1, 0, 0, 0, 2593, 2486, 1, 0, 0, 0, 2593, 2487, 1, 0, 0, 0, 2593, 2488, 1, 0, 0, 0, 2593, 2489, 1, 0, 0, 0, 2593, 2490, 1, 0, 0, 0, 2593, 2491, 1, 0, 0, 0, 2593, 2492, 1, 0, 0, 0, 2593, 2493, 1, 0, 0, 0, 2593, 2494, 1, 0, 0, 0, 2593, 2495, 1, 0, 0, 0, 2593, 2496, 1, 0, 0, 0, 2593, 2497, 1, 0, 0, 0, 2593, 2498, 1, 0, 0, 0, 2593, 2499, 1, 0, 0, 0, 2593, 2500, 1, 0, 0, 0, 2593, 2501, 1, 0, 0, 0, 2593, 2502, 1, 0, 0, 0, 2593, 2503, 1, 0, 0, 0, 2593, 2504, 1, 0, 0, 0, 2593, 2505, 1, 0, 0, 0, 2593, 2506, 1, 0, 0, 0, 2593, 2507, 1, 0, 0, 0, 2593, 2508, 1, 0, 0, 0, 2593, 2509, 1, 0, 0, 0, 2593, 2510, 1, 0, 0, 0, 2593, 2511, 1, 0, 0, 0, 2593, 2512, 1, 0, 0, 0, 2593, 2513, 1, 0, 0, 0, 2593, 2514, 1, 0, 0, 0, 2593, 2515, 1, 0, 0, 0, 2593, 2516, 1, 0, 0, 0, 2593, 2517, 1, 0, 0, 0, 2593, 2518, 1, 0, 0, 0, 2593, 2519, 1, 0, 0, 0, 2593, 2520, 1, 0, 0, 0, 2593, 2521, 1, 0, 0, 0, 2593, 2522, 1, 0, 0, 0, 2593, 2523, 1, 0, 0, 0, 2593, 2524, 1, 0, 0, 0, 2593, 2525, 1, 0, 0, 0, 2593, 2526, 1, 0, 0, 0, 2593, 2527, 1, 0, 0, 0, 2593, 2528, 1, 0, 0, 0, 2593, 2529, 1, 0, 0, 0, 2593, 2530, 1, 0, 0, 0, 2593, 2531, 1, 0, 0, 0, 2593, 2532, 1, 0, 0, 0, 2593, 2533, 1, 0, 0, 0, 2593, 2534, 1, 0, 0, 0, 2593, 2535, 1, 0, 0, 0, 2593, 2536, 1, 0, 0, 0, 2593, 2537, 1, 0, 0, 0, 2593, 2538, 1, 0, 0, 0, 2593, 2539, 1, 0, 0, 0, 2593, 2540, 1, 0, 0, 0, 2593, 2541, 1, 0, 0, 0, 2593, 2542, 1, 0, 0, 0, 2593, 2543, 1, 0, 0, 0, 2593, 2544, 1, 0, 0, 0, 2593, 2545, 1, 0, 0, 0, 2593, 2546, 1, 0, 0, 0, 2593, 2547, 1, 0, 0, 0, 2593, 2548, 1, 0, 0, 0, 2593, 2549, 1, 0, 0, 0, 2593, 2550, 1, 0, 0, 0, 2593, 2551, 1, 0, 0, 0, 2593, 2552, 1, 0, 0, 0, 2593, 2553, 1, 0, 0, 0, 2593, 2554, 1, 0, 0, 0, 2593, 2555, 1, 0, 0, 0, 2593, 2556, 1, 0, 0, 0, 2593, 2557, 1, 0, 0, 0, 2593, 2558, 1, 0, 0, 0, 2593, 2559, 1, 0, 0, 0, 2593, 2560, 1, 0, 0, 0, 2593, 2561, 1, 0, 0, 0, 2593, 2562, 1, 0, 0, 0, 2593, 2563, 1, 0, 0, 0, 2593, 2564, 1, 0, 0, 0, 2593, 2565, 1, 0, 0, 0, 2593, 2566, 1, 0, 0, 0, 2593, 2567, 1, 0, 0, 0, 2593, 2568, 1, 0, 0, 0, 2593, 2569, 1, 0, 0, 0, 2593, 2570, 1, 0, 0, 0, 2593, 2571, 1, 0, 0, 0, 2593, 2572, 1, 0, 0, 0, 2593, 2573, 1, 0, 0, 0, 2593, 2574, 1, 0, 0, 0, 2593, 2575, 1, 0, 0, 0, 2593, 2576, 1, 0, 0, 0, 2593, 2577, 1, 0, 0, 0, 2593, 2578, 1, 0, 0, 0, 2593, 2579, 1, 0, 0, 0, 2593, 2580, 1, 0, 0, 0, 2593, 2581, 1, 0, 0, 0, 2593, 2582, 1, 0, 0, 0, 2593, 2583, 1, 0, 0, 0, 2593, 2584, 1, 0, 0, 0, 2593, 2585, 1, 0, 0, 0, 2593, 2586, 1, 0, 0, 0, 2593, 2587, 1, 0, 0, 0, 2593, 2588, 1, 0, 0, 0, 2593, 2589, 1, 0, 0, 0, 2593, 2590, 1, 0, 0, 0, 2593, 2591, 1, 0, 0, 0, 2593, 2592, 1, 0, 0, 0, 2594, 3, 1, 0, 0, 0, 2595, 2596, 5, 42, 0, 0, 2596, 2650, 5, 441, 0, 0, 2597, 2632, 3, 2404, 1202, 0, 2598, 2601, 3, 6, 3, 0, 2599, 2601, 3, 8, 4, 0, 2600, 2598, 1, 0, 0, 0, 2600, 2599, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2600, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2606, 1, 0, 0, 0, 2604, 2606, 3, 10, 5, 0, 2605, 2600, 1, 0, 0, 0, 2605, 2604, 1, 0, 0, 0, 2606, 2608, 1, 0, 0, 0, 2607, 2609, 3, 24, 12, 0, 2608, 2607, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2633, 1, 0, 0, 0, 2610, 2631, 3, 12, 6, 0, 2611, 2631, 3, 16, 8, 0, 2612, 2631, 3, 18, 9, 0, 2613, 2631, 3, 20, 10, 0, 2614, 2631, 3, 24, 12, 0, 2615, 2631, 3, 28, 14, 0, 2616, 2631, 3, 30, 15, 0, 2617, 2631, 3, 40, 20, 0, 2618, 2631, 3, 44, 22, 0, 2619, 2631, 3, 46, 23, 0, 2620, 2631, 3, 52, 26, 0, 2621, 2631, 3, 54, 27, 0, 2622, 2631, 3, 56, 28, 0, 2623, 2631, 3, 58, 29, 0, 2624, 2631, 3, 60, 30, 0, 2625, 2631, 3, 62, 31, 0, 2626, 2631, 3, 64, 32, 0, 2627, 2631, 3, 66, 33, 0, 2628, 2631, 3, 68, 34, 0, 2629, 2631, 3, 74, 37, 0, 2630, 2610, 1, 0, 0, 0, 2630, 2611, 1, 0, 0, 0, 2630, 2612, 1, 0, 0, 0, 2630, 2613, 1, 0, 0, 0, 2630, 2614, 1, 0, 0, 0, 2630, 2615, 1, 0, 0, 0, 2630, 2616, 1, 0, 0, 0, 2630, 2617, 1, 0, 0, 0, 2630, 2618, 1, 0, 0, 0, 2630, 2619, 1, 0, 0, 0, 2630, 2620, 1, 0, 0, 0, 2630, 2621, 1, 0, 0, 0, 2630, 2622, 1, 0, 0, 0, 2630, 2623, 1, 0, 0, 0, 2630, 2624, 1, 0, 0, 0, 2630, 2625, 1, 0, 0, 0, 2630, 2626, 1, 0, 0, 0, 2630, 2627, 1, 0, 0, 0, 2630, 2628, 1, 0, 0, 0, 2630, 2629, 1, 0, 0, 0, 2631, 2633, 1, 0, 0, 0, 2632, 2605, 1, 0, 0, 0, 2632, 2630, 1, 0, 0, 0, 2633, 2651, 1, 0, 0, 0, 2634, 2639, 3, 2404, 1202, 0, 2635, 2636, 5, 2453, 0, 0, 2636, 2638, 3, 2404, 1202, 0, 2637, 2635, 1, 0, 0, 0, 2638, 2641, 1, 0, 0, 0, 2639, 2637, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2644, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2642, 2644, 5, 38, 0, 0, 2643, 2634, 1, 0, 0, 0, 2643, 2642, 1, 0, 0, 0, 2644, 2648, 1, 0, 0, 0, 2645, 2649, 3, 86, 43, 0, 2646, 2649, 3, 88, 44, 0, 2647, 2649, 3, 90, 45, 0, 2648, 2645, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2651, 1, 0, 0, 0, 2650, 2597, 1, 0, 0, 0, 2650, 2643, 1, 0, 0, 0, 2651, 5, 1, 0, 0, 0, 2652, 2673, 5, 21, 0, 0, 2653, 2654, 5, 1688, 0, 0, 2654, 2656, 3, 2404, 1202, 0, 2655, 2653, 1, 0, 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2659, 3, 84, 42, 0, 2658, 2657, 1, 0, 0, 0, 2658, 2659, 1, 0, 0, 0, 2659, 2662, 1, 0, 0, 0, 2660, 2661, 5, 572, 0, 0, 2661, 2663, 3, 2404, 1202, 0, 2662, 2660, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 2664, 1, 0, 0, 0, 2664, 2665, 5, 440, 0, 0, 2665, 2670, 3, 440, 220, 0, 2666, 2667, 5, 2453, 0, 0, 2667, 2669, 3, 440, 220, 0, 2668, 2666, 1, 0, 0, 0, 2669, 2672, 1, 0, 0, 0, 2670, 2668, 1, 0, 0, 0, 2670, 2671, 1, 0, 0, 0, 2671, 2674, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, 0, 2673, 2655, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 2673, 1, 0, 0, 0, 2675, 2676, 1, 0, 0, 0, 2676, 7, 1, 0, 0, 0, 2677, 2716, 5, 469, 0, 0, 2678, 2680, 3, 84, 42, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2682, 5, 440, 0, 0, 2682, 2684, 3, 2404, 1202, 0, 2683, 2685, 3, 38, 19, 0, 2684, 2683, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 2693, 1, 0, 0, 0, 2686, 2687, 5, 2453, 0, 0, 2687, 2689, 3, 2404, 1202, 0, 2688, 2690, 3, 38, 19, 0, 2689, 2688, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2692, 1, 0, 0, 0, 2691, 2686, 1, 0, 0, 0, 2692, 2695, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 2717, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2696, 2697, 5, 443, 0, 0, 2697, 2699, 5, 738, 0, 0, 2698, 2700, 3, 84, 42, 0, 2699, 2698, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2702, 5, 572, 0, 0, 2702, 2704, 3, 2404, 1202, 0, 2703, 2705, 3, 38, 19, 0, 2704, 2703, 1, 0, 0, 0, 2704, 2705, 1, 0, 0, 0, 2705, 2713, 1, 0, 0, 0, 2706, 2707, 5, 2453, 0, 0, 2707, 2709, 3, 2404, 1202, 0, 2708, 2710, 3, 38, 19, 0, 2709, 2708, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 2712, 1, 0, 0, 0, 2711, 2706, 1, 0, 0, 0, 2712, 2715, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2716, 2679, 1, 0, 0, 0, 2716, 2696, 1, 0, 0, 0, 2717, 9, 1, 0, 0, 0, 2718, 2719, 5, 1567, 0, 0, 2719, 2722, 5, 38, 0, 0, 2720, 2721, 5, 1699, 0, 0, 2721, 2723, 3, 1176, 588, 0, 2722, 2720, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, 11, 1, 0, 0, 0, 2724, 2725, 5, 1562, 0, 0, 2725, 2726, 5, 440, 0, 0, 2726, 2727, 3, 2404, 1202, 0, 2727, 2728, 5, 2308, 0, 0, 2728, 2730, 5, 2443, 0, 0, 2729, 2731, 3, 38, 19, 0, 2730, 2729, 1, 0, 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 2741, 1, 0, 0, 0, 2732, 2733, 5, 2453, 0, 0, 2733, 2734, 3, 2404, 1202, 0, 2734, 2735, 5, 2308, 0, 0, 2735, 2737, 5, 2443, 0, 0, 2736, 2738, 3, 38, 19, 0, 2737, 2736, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 2740, 1, 0, 0, 0, 2739, 2732, 1, 0, 0, 0, 2740, 2743, 1, 0, 0, 0, 2741, 2739, 1, 0, 0, 0, 2741, 2742, 1, 0, 0, 0, 2742, 2746, 1, 0, 0, 0, 2743, 2741, 1, 0, 0, 0, 2744, 2745, 5, 1424, 0, 0, 2745, 2747, 3, 2396, 1198, 0, 2746, 2744, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, 2747, 2749, 1, 0, 0, 0, 2748, 2750, 3, 14, 7, 0, 2749, 2748, 1, 0, 0, 0, 2749, 2750, 1, 0, 0, 0, 2750, 13, 1, 0, 0, 0, 2751, 2752, 7, 0, 0, 0, 2752, 15, 1, 0, 0, 0, 2753, 2770, 5, 1559, 0, 0, 2754, 2755, 5, 440, 0, 0, 2755, 2756, 3, 2404, 1202, 0, 2756, 2757, 5, 2141, 0, 0, 2757, 2765, 3, 2404, 1202, 0, 2758, 2759, 5, 2453, 0, 0, 2759, 2760, 3, 2404, 1202, 0, 2760, 2761, 5, 2141, 0, 0, 2761, 2762, 3, 2404, 1202, 0, 2762, 2764, 1, 0, 0, 0, 2763, 2758, 1, 0, 0, 0, 2764, 2767, 1, 0, 0, 0, 2765, 2763, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, 0, 2766, 2771, 1, 0, 0, 0, 2767, 2765, 1, 0, 0, 0, 2768, 2769, 5, 443, 0, 0, 2769, 2771, 5, 38, 0, 0, 2770, 2754, 1, 0, 0, 0, 2770, 2768, 1, 0, 0, 0, 2771, 17, 1, 0, 0, 0, 2772, 2804, 5, 1256, 0, 0, 2773, 2775, 3, 84, 42, 0, 2774, 2773, 1, 0, 0, 0, 2774, 2775, 1, 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 2777, 5, 440, 0, 0, 2777, 2782, 3, 2404, 1202, 0, 2778, 2779, 5, 2453, 0, 0, 2779, 2781, 3, 2404, 1202, 0, 2780, 2778, 1, 0, 0, 0, 2781, 2784, 1, 0, 0, 0, 2782, 2780, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 2800, 1, 0, 0, 0, 2784, 2782, 1, 0, 0, 0, 2785, 2786, 5, 443, 0, 0, 2786, 2788, 5, 738, 0, 0, 2787, 2789, 3, 84, 42, 0, 2788, 2787, 1, 0, 0, 0, 2788, 2789, 1, 0, 0, 0, 2789, 2790, 1, 0, 0, 0, 2790, 2791, 5, 572, 0, 0, 2791, 2796, 3, 2404, 1202, 0, 2792, 2793, 5, 2453, 0, 0, 2793, 2795, 3, 2404, 1202, 0, 2794, 2792, 1, 0, 0, 0, 2795, 2798, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, 2800, 1, 0, 0, 0, 2798, 2796, 1, 0, 0, 0, 2799, 2774, 1, 0, 0, 0, 2799, 2785, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2801, 2802, 1, 0, 0, 0, 2802, 2805, 1, 0, 0, 0, 2803, 2805, 5, 38, 0, 0, 2804, 2799, 1, 0, 0, 0, 2804, 2803, 1, 0, 0, 0, 2805, 2808, 1, 0, 0, 0, 2806, 2807, 5, 1424, 0, 0, 2807, 2809, 3, 2396, 1198, 0, 2808, 2806, 1, 0, 0, 0, 2808, 2809, 1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2812, 3, 14, 7, 0, 2811, 2810, 1, 0, 0, 0, 2811, 2812, 1, 0, 0, 0, 2812, 19, 1, 0, 0, 0, 2813, 2840, 5, 1243, 0, 0, 2814, 2816, 3, 84, 42, 0, 2815, 2814, 1, 0, 0, 0, 2815, 2816, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, 2818, 5, 440, 0, 0, 2818, 2823, 3, 2404, 1202, 0, 2819, 2820, 5, 2453, 0, 0, 2820, 2822, 3, 2404, 1202, 0, 2821, 2819, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2841, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2826, 2827, 5, 443, 0, 0, 2827, 2829, 5, 738, 0, 0, 2828, 2830, 3, 84, 42, 0, 2829, 2828, 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, 2831, 1, 0, 0, 0, 2831, 2832, 5, 572, 0, 0, 2832, 2837, 3, 2404, 1202, 0, 2833, 2834, 5, 2453, 0, 0, 2834, 2836, 3, 2404, 1202, 0, 2835, 2833, 1, 0, 0, 0, 2836, 2839, 1, 0, 0, 0, 2837, 2835, 1, 0, 0, 0, 2837, 2838, 1, 0, 0, 0, 2838, 2841, 1, 0, 0, 0, 2839, 2837, 1, 0, 0, 0, 2840, 2815, 1, 0, 0, 0, 2840, 2826, 1, 0, 0, 0, 2841, 2843, 1, 0, 0, 0, 2842, 2844, 3, 22, 11, 0, 2843, 2842, 1, 0, 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 21, 1, 0, 0, 0, 2845, 2846, 5, 469, 0, 0, 2846, 2847, 5, 33, 0, 0, 2847, 2848, 3, 2396, 1198, 0, 2848, 2849, 7, 1, 0, 0, 2849, 23, 1, 0, 0, 0, 2850, 2870, 5, 1510, 0, 0, 2851, 2853, 7, 2, 0, 0, 2852, 2854, 3, 26, 13, 0, 2853, 2852, 1, 0, 0, 0, 2854, 2855, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, 2858, 1, 0, 0, 0, 2857, 2851, 1, 0, 0, 0, 2857, 2858, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859, 2860, 5, 1424, 0, 0, 2860, 2861, 3, 2396, 1198, 0, 2861, 2863, 1, 0, 0, 0, 2862, 2864, 7, 0, 0, 0, 2863, 2862, 1, 0, 0, 0, 2863, 2864, 1, 0, 0, 0, 2864, 2871, 1, 0, 0, 0, 2865, 2866, 5, 980, 0, 0, 2866, 2868, 5, 1424, 0, 0, 2867, 2869, 3, 2396, 1198, 0, 2868, 2867, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2871, 1, 0, 0, 0, 2870, 2857, 1, 0, 0, 0, 2870, 2865, 1, 0, 0, 0, 2871, 25, 1, 0, 0, 0, 2872, 2873, 3, 2404, 1202, 0, 2873, 27, 1, 0, 0, 0, 2874, 2876, 5, 200, 0, 0, 2875, 2877, 5, 38, 0, 0, 2876, 2875, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 2879, 1, 0, 0, 0, 2878, 2880, 7, 3, 0, 0, 2879, 2878, 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 29, 1, 0, 0, 0, 2881, 2882, 7, 4, 0, 0, 2882, 2883, 5, 2090, 0, 0, 2883, 2884, 3, 2404, 1202, 0, 2884, 2891, 3, 32, 16, 0, 2885, 2886, 5, 2453, 0, 0, 2886, 2887, 3, 2404, 1202, 0, 2887, 2888, 3, 32, 16, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2885, 1, 0, 0, 0, 2890, 2893, 1, 0, 0, 0, 2891, 2889, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 2905, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2894, 2895, 5, 469, 0, 0, 2895, 2896, 5, 2090, 0, 0, 2896, 2901, 3, 2404, 1202, 0, 2897, 2898, 5, 2453, 0, 0, 2898, 2900, 3, 2404, 1202, 0, 2899, 2897, 1, 0, 0, 0, 2900, 2903, 1, 0, 0, 0, 2901, 2899, 1, 0, 0, 0, 2901, 2902, 1, 0, 0, 0, 2902, 2905, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2904, 2881, 1, 0, 0, 0, 2904, 2894, 1, 0, 0, 0, 2905, 31, 1, 0, 0, 0, 2906, 2907, 5, 84, 0, 0, 2907, 2909, 5, 2447, 0, 0, 2908, 2910, 3, 34, 17, 0, 2909, 2908, 1, 0, 0, 0, 2909, 2910, 1, 0, 0, 0, 2910, 2912, 1, 0, 0, 0, 2911, 2913, 3, 36, 18, 0, 2912, 2911, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, 0, 2914, 2915, 5, 2448, 0, 0, 2915, 33, 1, 0, 0, 0, 2916, 2917, 7, 5, 0, 0, 2917, 35, 1, 0, 0, 0, 2918, 2919, 7, 6, 0, 0, 2919, 37, 1, 0, 0, 0, 2920, 2921, 7, 7, 0, 0, 2921, 39, 1, 0, 0, 0, 2922, 2923, 5, 21, 0, 0, 2923, 2924, 5, 426, 0, 0, 2924, 2929, 3, 1458, 729, 0, 2925, 2926, 5, 2453, 0, 0, 2926, 2928, 3, 1458, 729, 0, 2927, 2925, 1, 0, 0, 0, 2928, 2931, 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2964, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2932, 2933, 5, 469, 0, 0, 2933, 2934, 5, 426, 0, 0, 2934, 2936, 3, 1458, 729, 0, 2935, 2937, 3, 38, 19, 0, 2936, 2935, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2945, 1, 0, 0, 0, 2938, 2939, 5, 2453, 0, 0, 2939, 2941, 3, 1458, 729, 0, 2940, 2942, 3, 38, 19, 0, 2941, 2940, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2944, 1, 0, 0, 0, 2943, 2938, 1, 0, 0, 0, 2944, 2947, 1, 0, 0, 0, 2945, 2943, 1, 0, 0, 0, 2945, 2946, 1, 0, 0, 0, 2946, 2964, 1, 0, 0, 0, 2947, 2945, 1, 0, 0, 0, 2948, 2949, 5, 1559, 0, 0, 2949, 2950, 5, 426, 0, 0, 2950, 2951, 3, 42, 21, 0, 2951, 2952, 5, 2141, 0, 0, 2952, 2960, 3, 42, 21, 0, 2953, 2954, 5, 2453, 0, 0, 2954, 2955, 3, 42, 21, 0, 2955, 2956, 5, 2141, 0, 0, 2956, 2957, 3, 42, 21, 0, 2957, 2959, 1, 0, 0, 0, 2958, 2953, 1, 0, 0, 0, 2959, 2962, 1, 0, 0, 0, 2960, 2958, 1, 0, 0, 0, 2960, 2961, 1, 0, 0, 0, 2961, 2964, 1, 0, 0, 0, 2962, 2960, 1, 0, 0, 0, 2963, 2922, 1, 0, 0, 0, 2963, 2932, 1, 0, 0, 0, 2963, 2948, 1, 0, 0, 0, 2964, 41, 1, 0, 0, 0, 2965, 2966, 5, 2443, 0, 0, 2966, 43, 1, 0, 0, 0, 2967, 2968, 5, 21, 0, 0, 2968, 2969, 5, 37, 0, 0, 2969, 2970, 5, 2443, 0, 0, 2970, 2971, 5, 620, 0, 0, 2971, 2978, 5, 2443, 0, 0, 2972, 2973, 5, 2453, 0, 0, 2973, 2974, 5, 2443, 0, 0, 2974, 2975, 5, 620, 0, 0, 2975, 2977, 5, 2443, 0, 0, 2976, 2972, 1, 0, 0, 0, 2977, 2980, 1, 0, 0, 0, 2978, 2976, 1, 0, 0, 0, 2978, 2979, 1, 0, 0, 0, 2979, 3006, 1, 0, 0, 0, 2980, 2978, 1, 0, 0, 0, 2981, 2982, 5, 469, 0, 0, 2982, 2983, 5, 37, 0, 0, 2983, 2988, 5, 2443, 0, 0, 2984, 2985, 5, 2453, 0, 0, 2985, 2987, 5, 2443, 0, 0, 2986, 2984, 1, 0, 0, 0, 2987, 2990, 1, 0, 0, 0, 2988, 2986, 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 3006, 1, 0, 0, 0, 2990, 2988, 1, 0, 0, 0, 2991, 2992, 5, 1559, 0, 0, 2992, 2993, 5, 37, 0, 0, 2993, 2994, 5, 2443, 0, 0, 2994, 2995, 5, 2141, 0, 0, 2995, 3002, 5, 2443, 0, 0, 2996, 2997, 5, 2453, 0, 0, 2997, 2998, 5, 2443, 0, 0, 2998, 2999, 5, 2141, 0, 0, 2999, 3001, 5, 2443, 0, 0, 3000, 2996, 1, 0, 0, 0, 3001, 3004, 1, 0, 0, 0, 3002, 3000, 1, 0, 0, 0, 3002, 3003, 1, 0, 0, 0, 3003, 3006, 1, 0, 0, 0, 3004, 3002, 1, 0, 0, 0, 3005, 2967, 1, 0, 0, 0, 3005, 2981, 1, 0, 0, 0, 3005, 2991, 1, 0, 0, 0, 3006, 45, 1, 0, 0, 0, 3007, 3019, 3, 48, 24, 0, 3008, 3019, 3, 50, 25, 0, 3009, 3010, 5, 1567, 0, 0, 3010, 3011, 5, 2291, 0, 0, 3011, 3012, 3, 2404, 1202, 0, 3012, 3013, 5, 1699, 0, 0, 3013, 3014, 3, 1176, 588, 0, 3014, 3019, 1, 0, 0, 0, 3015, 3016, 5, 469, 0, 0, 3016, 3017, 5, 2291, 0, 0, 3017, 3019, 3, 2404, 1202, 0, 3018, 3007, 1, 0, 0, 0, 3018, 3008, 1, 0, 0, 0, 3018, 3009, 1, 0, 0, 0, 3018, 3015, 1, 0, 0, 0, 3019, 47, 1, 0, 0, 0, 3020, 3021, 5, 21, 0, 0, 3021, 3022, 5, 2291, 0, 0, 3022, 3023, 3, 2404, 1202, 0, 3023, 3024, 5, 1699, 0, 0, 3024, 3026, 3, 1176, 588, 0, 3025, 3027, 3, 34, 17, 0, 3026, 3025, 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 3032, 1, 0, 0, 0, 3028, 3029, 5, 1769, 0, 0, 3029, 3030, 3, 2396, 1198, 0, 3030, 3031, 7, 8, 0, 0, 3031, 3033, 1, 0, 0, 0, 3032, 3028, 1, 0, 0, 0, 3032, 3033, 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3035, 5, 1768, 0, 0, 3035, 3037, 3, 2396, 1198, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 49, 1, 0, 0, 0, 3038, 3039, 5, 980, 0, 0, 3039, 3040, 5, 2291, 0, 0, 3040, 3043, 3, 2404, 1202, 0, 3041, 3042, 5, 989, 0, 0, 3042, 3044, 5, 2443, 0, 0, 3043, 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3047, 1, 0, 0, 0, 3045, 3046, 5, 2216, 0, 0, 3046, 3048, 5, 2443, 0, 0, 3047, 3045, 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 51, 1, 0, 0, 0, 3049, 3050, 5, 1671, 0, 0, 3050, 3051, 5, 83, 0, 0, 3051, 3052, 5, 2443, 0, 0, 3052, 3053, 5, 2472, 0, 0, 3053, 3054, 5, 2443, 0, 0, 3054, 53, 1, 0, 0, 0, 3055, 3056, 5, 469, 0, 0, 3056, 3057, 5, 589, 0, 0, 3057, 3062, 3, 1458, 729, 0, 3058, 3059, 5, 2453, 0, 0, 3059, 3061, 3, 1458, 729, 0, 3060, 3058, 1, 0, 0, 0, 3061, 3064, 1, 0, 0, 0, 3062, 3060, 1, 0, 0, 0, 3062, 3063, 1, 0, 0, 0, 3063, 55, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3065, 3066, 5, 300, 0, 0, 3066, 3067, 5, 1524, 0, 0, 3067, 3068, 5, 2141, 0, 0, 3068, 3069, 5, 609, 0, 0, 3069, 57, 1, 0, 0, 0, 3070, 3071, 5, 21, 0, 0, 3071, 3072, 5, 2233, 0, 0, 3072, 3073, 5, 2443, 0, 0, 3073, 3074, 5, 2308, 0, 0, 3074, 3075, 5, 936, 0, 0, 3075, 3080, 5, 2443, 0, 0, 3076, 3077, 5, 2453, 0, 0, 3077, 3079, 5, 2443, 0, 0, 3078, 3076, 1, 0, 0, 0, 3079, 3082, 1, 0, 0, 0, 3080, 3078, 1, 0, 0, 0, 3080, 3081, 1, 0, 0, 0, 3081, 3100, 1, 0, 0, 0, 3082, 3080, 1, 0, 0, 0, 3083, 3084, 5, 980, 0, 0, 3084, 3085, 5, 2233, 0, 0, 3085, 3086, 5, 2443, 0, 0, 3086, 3087, 7, 9, 0, 0, 3087, 3088, 5, 936, 0, 0, 3088, 3093, 5, 2443, 0, 0, 3089, 3090, 5, 2453, 0, 0, 3090, 3092, 5, 2443, 0, 0, 3091, 3089, 1, 0, 0, 0, 3092, 3095, 1, 0, 0, 0, 3093, 3091, 1, 0, 0, 0, 3093, 3094, 1, 0, 0, 0, 3094, 3100, 1, 0, 0, 0, 3095, 3093, 1, 0, 0, 0, 3096, 3097, 5, 469, 0, 0, 3097, 3098, 5, 2233, 0, 0, 3098, 3100, 5, 2443, 0, 0, 3099, 3070, 1, 0, 0, 0, 3099, 3083, 1, 0, 0, 0, 3099, 3096, 1, 0, 0, 0, 3100, 59, 1, 0, 0, 0, 3101, 3102, 5, 21, 0, 0, 3102, 3103, 5, 2237, 0, 0, 3103, 3108, 5, 2443, 0, 0, 3104, 3105, 5, 2453, 0, 0, 3105, 3107, 5, 2443, 0, 0, 3106, 3104, 1, 0, 0, 0, 3107, 3110, 1, 0, 0, 0, 3108, 3106, 1, 0, 0, 0, 3108, 3109, 1, 0, 0, 0, 3109, 3139, 1, 0, 0, 0, 3110, 3108, 1, 0, 0, 0, 3111, 3112, 5, 469, 0, 0, 3112, 3113, 5, 2237, 0, 0, 3113, 3118, 5, 2443, 0, 0, 3114, 3115, 5, 2453, 0, 0, 3115, 3117, 5, 2443, 0, 0, 3116, 3114, 1, 0, 0, 0, 3117, 3120, 1, 0, 0, 0, 3118, 3116, 1, 0, 0, 0, 3118, 3119, 1, 0, 0, 0, 3119, 3122, 1, 0, 0, 0, 3120, 3118, 1, 0, 0, 0, 3121, 3123, 5, 179, 0, 0, 3122, 3121, 1, 0, 0, 0, 3122, 3123, 1, 0, 0, 0, 3123, 3139, 1, 0, 0, 0, 3124, 3125, 5, 1562, 0, 0, 3125, 3126, 5, 2237, 0, 0, 3126, 3127, 5, 2443, 0, 0, 3127, 3128, 5, 2308, 0, 0, 3128, 3135, 5, 2443, 0, 0, 3129, 3130, 5, 2453, 0, 0, 3130, 3131, 5, 2443, 0, 0, 3131, 3132, 5, 2308, 0, 0, 3132, 3134, 5, 2443, 0, 0, 3133, 3129, 1, 0, 0, 0, 3134, 3137, 1, 0, 0, 0, 3135, 3133, 1, 0, 0, 0, 3135, 3136, 1, 0, 0, 0, 3136, 3139, 1, 0, 0, 0, 3137, 3135, 1, 0, 0, 0, 3138, 3101, 1, 0, 0, 0, 3138, 3111, 1, 0, 0, 0, 3138, 3124, 1, 0, 0, 0, 3139, 61, 1, 0, 0, 0, 3140, 3141, 5, 1671, 0, 0, 3141, 3142, 5, 1388, 0, 0, 3142, 3143, 7, 10, 0, 0, 3143, 3147, 5, 2472, 0, 0, 3144, 3148, 5, 1133, 0, 0, 3145, 3146, 5, 1505, 0, 0, 3146, 3148, 7, 11, 0, 0, 3147, 3144, 1, 0, 0, 0, 3147, 3145, 1, 0, 0, 0, 3148, 3159, 1, 0, 0, 0, 3149, 3150, 5, 2453, 0, 0, 3150, 3151, 7, 10, 0, 0, 3151, 3155, 5, 2472, 0, 0, 3152, 3156, 5, 1133, 0, 0, 3153, 3154, 5, 1505, 0, 0, 3154, 3156, 7, 11, 0, 0, 3155, 3152, 1, 0, 0, 0, 3155, 3153, 1, 0, 0, 0, 3156, 3158, 1, 0, 0, 0, 3157, 3149, 1, 0, 0, 0, 3158, 3161, 1, 0, 0, 0, 3159, 3157, 1, 0, 0, 0, 3159, 3160, 1, 0, 0, 0, 3160, 3162, 1, 0, 0, 0, 3161, 3159, 1, 0, 0, 0, 3162, 3163, 5, 620, 0, 0, 3163, 3164, 5, 589, 0, 0, 3164, 3169, 5, 2443, 0, 0, 3165, 3166, 5, 2453, 0, 0, 3166, 3168, 5, 2443, 0, 0, 3167, 3165, 1, 0, 0, 0, 3168, 3171, 1, 0, 0, 0, 3169, 3167, 1, 0, 0, 0, 3169, 3170, 1, 0, 0, 0, 3170, 63, 1, 0, 0, 0, 3171, 3169, 1, 0, 0, 0, 3172, 3173, 5, 1671, 0, 0, 3173, 3174, 5, 1326, 0, 0, 3174, 3175, 7, 12, 0, 0, 3175, 3176, 5, 2472, 0, 0, 3176, 3183, 5, 2443, 0, 0, 3177, 3178, 5, 2453, 0, 0, 3178, 3179, 7, 12, 0, 0, 3179, 3180, 5, 2472, 0, 0, 3180, 3182, 5, 2443, 0, 0, 3181, 3177, 1, 0, 0, 0, 3182, 3185, 1, 0, 0, 0, 3183, 3181, 1, 0, 0, 0, 3183, 3184, 1, 0, 0, 0, 3184, 3186, 1, 0, 0, 0, 3185, 3183, 1, 0, 0, 0, 3186, 3187, 5, 620, 0, 0, 3187, 3188, 5, 589, 0, 0, 3188, 3193, 5, 2443, 0, 0, 3189, 3190, 5, 2453, 0, 0, 3190, 3192, 5, 2443, 0, 0, 3191, 3189, 1, 0, 0, 0, 3192, 3195, 1, 0, 0, 0, 3193, 3191, 1, 0, 0, 0, 3193, 3194, 1, 0, 0, 0, 3194, 65, 1, 0, 0, 0, 3195, 3193, 1, 0, 0, 0, 3196, 3201, 5, 1629, 0, 0, 3197, 3198, 5, 589, 0, 0, 3198, 3202, 5, 2443, 0, 0, 3199, 3200, 5, 440, 0, 0, 3200, 3202, 3, 2404, 1202, 0, 3201, 3197, 1, 0, 0, 0, 3201, 3199, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202, 3204, 1, 0, 0, 0, 3203, 3205, 7, 3, 0, 0, 3204, 3203, 1, 0, 0, 0, 3204, 3205, 1, 0, 0, 0, 3205, 3208, 1, 0, 0, 0, 3206, 3207, 5, 1424, 0, 0, 3207, 3209, 7, 13, 0, 0, 3208, 3206, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, 3211, 1, 0, 0, 0, 3210, 3212, 3, 14, 7, 0, 3211, 3210, 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, 3214, 1, 0, 0, 0, 3213, 3215, 3, 38, 19, 0, 3214, 3213, 1, 0, 0, 0, 3214, 3215, 1, 0, 0, 0, 3215, 3217, 1, 0, 0, 0, 3216, 3218, 5, 1761, 0, 0, 3217, 3216, 1, 0, 0, 0, 3217, 3218, 1, 0, 0, 0, 3218, 67, 1, 0, 0, 0, 3219, 3220, 5, 21, 0, 0, 3220, 3221, 5, 1491, 0, 0, 3221, 3227, 3, 2404, 1202, 0, 3222, 3223, 5, 1671, 0, 0, 3223, 3224, 3, 70, 35, 0, 3224, 3225, 5, 2472, 0, 0, 3225, 3226, 3, 72, 36, 0, 3226, 3228, 1, 0, 0, 0, 3227, 3222, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 3247, 1, 0, 0, 0, 3229, 3230, 5, 980, 0, 0, 3230, 3231, 5, 1491, 0, 0, 3231, 3232, 3, 2404, 1202, 0, 3232, 3233, 5, 1671, 0, 0, 3233, 3234, 3, 70, 35, 0, 3234, 3235, 5, 2472, 0, 0, 3235, 3236, 3, 72, 36, 0, 3236, 3247, 1, 0, 0, 0, 3237, 3238, 5, 992, 0, 0, 3238, 3239, 5, 1491, 0, 0, 3239, 3240, 3, 2404, 1202, 0, 3240, 3241, 5, 2141, 0, 0, 3241, 3242, 3, 2404, 1202, 0, 3242, 3247, 1, 0, 0, 0, 3243, 3244, 5, 469, 0, 0, 3244, 3245, 5, 1491, 0, 0, 3245, 3247, 3, 2404, 1202, 0, 3246, 3219, 1, 0, 0, 0, 3246, 3229, 1, 0, 0, 0, 3246, 3237, 1, 0, 0, 0, 3246, 3243, 1, 0, 0, 0, 3247, 69, 1, 0, 0, 0, 3248, 3249, 3, 2404, 1202, 0, 3249, 71, 1, 0, 0, 0, 3250, 3251, 3, 2404, 1202, 0, 3251, 73, 1, 0, 0, 0, 3252, 3257, 3, 76, 38, 0, 3253, 3257, 3, 78, 39, 0, 3254, 3257, 3, 80, 40, 0, 3255, 3257, 3, 82, 41, 0, 3256, 3252, 1, 0, 0, 0, 3256, 3253, 1, 0, 0, 0, 3256, 3254, 1, 0, 0, 0, 3256, 3255, 1, 0, 0, 0, 3257, 75, 1, 0, 0, 0, 3258, 3259, 5, 21, 0, 0, 3259, 3260, 5, 591, 0, 0, 3260, 3264, 3, 2404, 1202, 0, 3261, 3262, 7, 14, 0, 0, 3262, 3265, 3, 2404, 1202, 0, 3263, 3265, 5, 2090, 0, 0, 3264, 3261, 1, 0, 0, 0, 3264, 3263, 1, 0, 0, 0, 3265, 3269, 1, 0, 0, 0, 3266, 3267, 5, 628, 0, 0, 3267, 3268, 5, 2090, 0, 0, 3268, 3270, 3, 2404, 1202, 0, 3269, 3266, 1, 0, 0, 0, 3269, 3270, 1, 0, 0, 0, 3270, 3275, 1, 0, 0, 0, 3271, 3272, 5, 1671, 0, 0, 3272, 3273, 5, 2443, 0, 0, 3273, 3274, 5, 2472, 0, 0, 3274, 3276, 5, 2443, 0, 0, 3275, 3271, 1, 0, 0, 0, 3275, 3276, 1, 0, 0, 0, 3276, 77, 1, 0, 0, 0, 3277, 3278, 5, 980, 0, 0, 3278, 3279, 5, 591, 0, 0, 3279, 3280, 3, 2404, 1202, 0, 3280, 3281, 5, 1671, 0, 0, 3281, 3282, 5, 2443, 0, 0, 3282, 3283, 5, 2472, 0, 0, 3283, 3284, 5, 2443, 0, 0, 3284, 79, 1, 0, 0, 0, 3285, 3286, 5, 992, 0, 0, 3286, 3287, 5, 589, 0, 0, 3287, 3288, 5, 2443, 0, 0, 3288, 3289, 5, 2141, 0, 0, 3289, 3290, 5, 591, 0, 0, 3290, 3291, 3, 2404, 1202, 0, 3291, 81, 1, 0, 0, 0, 3292, 3293, 5, 469, 0, 0, 3293, 3294, 5, 591, 0, 0, 3294, 3296, 3, 2404, 1202, 0, 3295, 3297, 5, 179, 0, 0, 3296, 3295, 1, 0, 0, 0, 3296, 3297, 1, 0, 0, 0, 3297, 83, 1, 0, 0, 0, 3298, 3299, 7, 15, 0, 0, 3299, 85, 1, 0, 0, 0, 3300, 3301, 5, 2179, 0, 0, 3301, 3302, 5, 443, 0, 0, 3302, 87, 1, 0, 0, 0, 3303, 3305, 5, 988, 0, 0, 3304, 3306, 7, 16, 0, 0, 3305, 3304, 1, 0, 0, 0, 3305, 3306, 1, 0, 0, 0, 3306, 3308, 1, 0, 0, 0, 3307, 3309, 7, 7, 0, 0, 3308, 3307, 1, 0, 0, 0, 3308, 3309, 1, 0, 0, 0, 3309, 3315, 1, 0, 0, 0, 3310, 3312, 5, 444, 0, 0, 3311, 3313, 7, 7, 0, 0, 3312, 3311, 1, 0, 0, 0, 3312, 3313, 1, 0, 0, 0, 3313, 3315, 1, 0, 0, 0, 3314, 3303, 1, 0, 0, 0, 3314, 3310, 1, 0, 0, 0, 3315, 89, 1, 0, 0, 0, 3316, 3317, 7, 17, 0, 0, 3317, 3327, 5, 2291, 0, 0, 3318, 3323, 3, 2404, 1202, 0, 3319, 3320, 5, 2453, 0, 0, 3320, 3322, 3, 2404, 1202, 0, 3321, 3319, 1, 0, 0, 0, 3322, 3325, 1, 0, 0, 0, 3323, 3321, 1, 0, 0, 0, 3323, 3324, 1, 0, 0, 0, 3324, 3328, 1, 0, 0, 0, 3325, 3323, 1, 0, 0, 0, 3326, 3328, 5, 38, 0, 0, 3327, 3318, 1, 0, 0, 0, 3327, 3326, 1, 0, 0, 0, 3328, 91, 1, 0, 0, 0, 3329, 3330, 5, 469, 0, 0, 3330, 3331, 5, 632, 0, 0, 3331, 3332, 3, 2320, 1160, 0, 3332, 93, 1, 0, 0, 0, 3333, 3334, 5, 42, 0, 0, 3334, 3335, 5, 605, 0, 0, 3335, 3336, 5, 64, 0, 0, 3336, 3366, 3, 2404, 1202, 0, 3337, 3338, 5, 1671, 0, 0, 3338, 3367, 5, 389, 0, 0, 3339, 3340, 7, 4, 0, 0, 3340, 3341, 5, 2080, 0, 0, 3341, 3343, 3, 2404, 1202, 0, 3342, 3344, 3, 446, 223, 0, 3343, 3342, 1, 0, 0, 0, 3343, 3344, 1, 0, 0, 0, 3344, 3367, 1, 0, 0, 0, 3345, 3346, 5, 1558, 0, 0, 3346, 3347, 5, 2080, 0, 0, 3347, 3367, 3, 2404, 1202, 0, 3348, 3349, 5, 980, 0, 0, 3349, 3367, 3, 448, 224, 0, 3350, 3359, 5, 1475, 0, 0, 3351, 3360, 5, 38, 0, 0, 3352, 3357, 5, 112, 0, 0, 3353, 3354, 5, 1627, 0, 0, 3354, 3358, 3, 2078, 1039, 0, 3355, 3356, 5, 2108, 0, 0, 3356, 3358, 3, 2078, 1039, 0, 3357, 3353, 1, 0, 0, 0, 3357, 3355, 1, 0, 0, 0, 3358, 3360, 1, 0, 0, 0, 3359, 3351, 1, 0, 0, 0, 3359, 3352, 1, 0, 0, 0, 3360, 3367, 1, 0, 0, 0, 3361, 3363, 5, 1137, 0, 0, 3362, 3361, 1, 0, 0, 0, 3362, 3363, 1, 0, 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3365, 5, 1269, 0, 0, 3365, 3367, 5, 351, 0, 0, 3366, 3337, 1, 0, 0, 0, 3366, 3339, 1, 0, 0, 0, 3366, 3345, 1, 0, 0, 0, 3366, 3348, 1, 0, 0, 0, 3366, 3350, 1, 0, 0, 0, 3366, 3362, 1, 0, 0, 0, 3367, 95, 1, 0, 0, 0, 3368, 3369, 5, 42, 0, 0, 3369, 3373, 5, 674, 0, 0, 3370, 3371, 3, 2286, 1143, 0, 3371, 3372, 5, 2440, 0, 0, 3372, 3374, 1, 0, 0, 0, 3373, 3370, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3375, 1, 0, 0, 0, 3375, 3380, 3, 2404, 1202, 0, 3376, 3377, 5, 1559, 0, 0, 3377, 3378, 5, 2141, 0, 0, 3378, 3381, 3, 2404, 1202, 0, 3379, 3381, 5, 249, 0, 0, 3380, 3376, 1, 0, 0, 0, 3380, 3379, 1, 0, 0, 0, 3381, 97, 1, 0, 0, 0, 3382, 3383, 5, 42, 0, 0, 3383, 3384, 5, 632, 0, 0, 3384, 3401, 3, 2320, 1160, 0, 3385, 3402, 5, 482, 0, 0, 3386, 3402, 5, 1132, 0, 0, 3387, 3389, 5, 249, 0, 0, 3388, 3390, 5, 378, 0, 0, 3389, 3388, 1, 0, 0, 0, 3389, 3390, 1, 0, 0, 0, 3390, 3394, 1, 0, 0, 0, 3391, 3393, 3, 812, 406, 0, 3392, 3391, 1, 0, 0, 0, 3393, 3396, 1, 0, 0, 0, 3394, 3392, 1, 0, 0, 0, 3394, 3395, 1, 0, 0, 0, 3395, 3399, 1, 0, 0, 0, 3396, 3394, 1, 0, 0, 0, 3397, 3398, 5, 1587, 0, 0, 3398, 3400, 5, 1673, 0, 0, 3399, 3397, 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 3402, 1, 0, 0, 0, 3401, 3385, 1, 0, 0, 0, 3401, 3386, 1, 0, 0, 0, 3401, 3387, 1, 0, 0, 0, 3402, 99, 1, 0, 0, 0, 3403, 3404, 5, 42, 0, 0, 3404, 3405, 5, 792, 0, 0, 3405, 3409, 7, 18, 0, 0, 3406, 3407, 3, 2286, 1143, 0, 3407, 3408, 5, 2440, 0, 0, 3408, 3410, 1, 0, 0, 0, 3409, 3406, 1, 0, 0, 0, 3409, 3410, 1, 0, 0, 0, 3410, 3411, 1, 0, 0, 0, 3411, 3431, 3, 2404, 1202, 0, 3412, 3413, 5, 1569, 0, 0, 3413, 3425, 5, 2447, 0, 0, 3414, 3415, 5, 2447, 0, 0, 3415, 3417, 3, 102, 51, 0, 3416, 3418, 5, 2453, 0, 0, 3417, 3416, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, 0, 3418, 3421, 1, 0, 0, 0, 3419, 3422, 3, 2286, 1143, 0, 3420, 3422, 5, 2452, 0, 0, 3421, 3419, 1, 0, 0, 0, 3421, 3420, 1, 0, 0, 0, 3422, 3423, 1, 0, 0, 0, 3423, 3424, 5, 2448, 0, 0, 3424, 3426, 1, 0, 0, 0, 3425, 3414, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3427, 3428, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3430, 5, 2448, 0, 0, 3430, 3432, 1, 0, 0, 0, 3431, 3412, 1, 0, 0, 0, 3431, 3432, 1, 0, 0, 0, 3432, 3436, 1, 0, 0, 0, 3433, 3437, 5, 249, 0, 0, 3434, 3437, 5, 1568, 0, 0, 3435, 3437, 3, 1720, 860, 0, 3436, 3433, 1, 0, 0, 0, 3436, 3434, 1, 0, 0, 0, 3436, 3435, 1, 0, 0, 0, 3437, 101, 1, 0, 0, 0, 3438, 3439, 7, 19, 0, 0, 3439, 103, 1, 0, 0, 0, 3440, 3443, 5, 321, 0, 0, 3441, 3442, 5, 1307, 0, 0, 3442, 3444, 5, 1562, 0, 0, 3443, 3441, 1, 0, 0, 0, 3443, 3444, 1, 0, 0, 0, 3444, 3446, 1, 0, 0, 0, 3445, 3447, 7, 20, 0, 0, 3446, 3445, 1, 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3448, 1, 0, 0, 0, 3448, 3449, 5, 632, 0, 0, 3449, 3461, 3, 2320, 1160, 0, 3450, 3451, 5, 2447, 0, 0, 3451, 3456, 3, 1736, 868, 0, 3452, 3453, 5, 2453, 0, 0, 3453, 3455, 3, 1736, 868, 0, 3454, 3452, 1, 0, 0, 0, 3455, 3458, 1, 0, 0, 0, 3456, 3454, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3459, 3460, 5, 2448, 0, 0, 3460, 3462, 1, 0, 0, 0, 3461, 3450, 1, 0, 0, 0, 3461, 3462, 1, 0, 0, 0, 3462, 3463, 1, 0, 0, 0, 3463, 3464, 5, 1586, 0, 0, 3464, 3468, 3, 2374, 1187, 0, 3465, 3466, 5, 1681, 0, 0, 3466, 3467, 5, 2472, 0, 0, 3467, 3469, 7, 21, 0, 0, 3468, 3465, 1, 0, 0, 0, 3468, 3469, 1, 0, 0, 0, 3469, 3479, 1, 0, 0, 0, 3470, 3478, 3, 1720, 860, 0, 3471, 3478, 3, 114, 57, 0, 3472, 3478, 3, 116, 58, 0, 3473, 3478, 3, 108, 54, 0, 3474, 3478, 3, 112, 56, 0, 3475, 3478, 5, 1394, 0, 0, 3476, 3478, 5, 420, 0, 0, 3477, 3470, 1, 0, 0, 0, 3477, 3471, 1, 0, 0, 0, 3477, 3472, 1, 0, 0, 0, 3477, 3473, 1, 0, 0, 0, 3477, 3474, 1, 0, 0, 0, 3477, 3475, 1, 0, 0, 0, 3477, 3476, 1, 0, 0, 0, 3478, 3481, 1, 0, 0, 0, 3479, 3477, 1, 0, 0, 0, 3479, 3480, 1, 0, 0, 0, 3480, 3496, 1, 0, 0, 0, 3481, 3479, 1, 0, 0, 0, 3482, 3491, 7, 22, 0, 0, 3483, 3485, 5, 382, 0, 0, 3484, 3483, 1, 0, 0, 0, 3484, 3485, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3488, 3, 1740, 870, 0, 3487, 3486, 1, 0, 0, 0, 3487, 3488, 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 3492, 3, 1820, 910, 0, 3490, 3492, 3, 1722, 861, 0, 3491, 3484, 1, 0, 0, 0, 3491, 3490, 1, 0, 0, 0, 3492, 3497, 1, 0, 0, 0, 3493, 3497, 3, 118, 59, 0, 3494, 3497, 3, 120, 60, 0, 3495, 3497, 3, 106, 53, 0, 3496, 3482, 1, 0, 0, 0, 3496, 3493, 1, 0, 0, 0, 3496, 3494, 1, 0, 0, 0, 3496, 3495, 1, 0, 0, 0, 3497, 105, 1, 0, 0, 0, 3498, 3499, 5, 1724, 0, 0, 3499, 3500, 5, 785, 0, 0, 3500, 3501, 5, 113, 0, 0, 3501, 3502, 5, 1586, 0, 0, 3502, 3503, 3, 2400, 1200, 0, 3503, 3504, 5, 2470, 0, 0, 3504, 3505, 5, 508, 0, 0, 3505, 107, 1, 0, 0, 0, 3506, 3508, 5, 1331, 0, 0, 3507, 3509, 3, 110, 55, 0, 3508, 3507, 1, 0, 0, 0, 3508, 3509, 1, 0, 0, 0, 3509, 109, 1, 0, 0, 0, 3510, 3511, 5, 2447, 0, 0, 3511, 3512, 5, 1348, 0, 0, 3512, 3513, 3, 2078, 1039, 0, 3513, 3517, 5, 160, 0, 0, 3514, 3518, 5, 55, 0, 0, 3515, 3516, 7, 23, 0, 0, 3516, 3518, 3, 2360, 1180, 0, 3517, 3514, 1, 0, 0, 0, 3517, 3515, 1, 0, 0, 0, 3518, 3520, 1, 0, 0, 0, 3519, 3521, 3, 126, 63, 0, 3520, 3519, 1, 0, 0, 0, 3520, 3521, 1, 0, 0, 0, 3521, 3522, 1, 0, 0, 0, 3522, 3523, 5, 2448, 0, 0, 3523, 111, 1, 0, 0, 0, 3524, 3526, 5, 1579, 0, 0, 3525, 3527, 3, 124, 62, 0, 3526, 3525, 1, 0, 0, 0, 3526, 3527, 1, 0, 0, 0, 3527, 3532, 1, 0, 0, 0, 3528, 3529, 5, 2447, 0, 0, 3529, 3530, 5, 977, 0, 0, 3530, 3531, 7, 24, 0, 0, 3531, 3533, 5, 2448, 0, 0, 3532, 3528, 1, 0, 0, 0, 3532, 3533, 1, 0, 0, 0, 3533, 113, 1, 0, 0, 0, 3534, 3535, 5, 6, 0, 0, 3535, 3536, 5, 160, 0, 0, 3536, 3537, 5, 2447, 0, 0, 3537, 3542, 3, 122, 61, 0, 3538, 3539, 5, 2453, 0, 0, 3539, 3541, 3, 122, 61, 0, 3540, 3538, 1, 0, 0, 0, 3541, 3544, 1, 0, 0, 0, 3542, 3540, 1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3545, 1, 0, 0, 0, 3544, 3542, 1, 0, 0, 0, 3545, 3546, 5, 2448, 0, 0, 3546, 115, 1, 0, 0, 0, 3547, 3548, 5, 389, 0, 0, 3548, 3549, 5, 2373, 0, 0, 3549, 3550, 5, 2245, 0, 0, 3550, 117, 1, 0, 0, 0, 3551, 3552, 5, 35, 0, 0, 3552, 3553, 5, 2246, 0, 0, 3553, 3554, 3, 2292, 1146, 0, 3554, 119, 1, 0, 0, 0, 3555, 3558, 5, 1394, 0, 0, 3556, 3557, 7, 25, 0, 0, 3557, 3559, 5, 2432, 0, 0, 3558, 3556, 1, 0, 0, 0, 3558, 3559, 1, 0, 0, 0, 3559, 3560, 1, 0, 0, 0, 3560, 3561, 5, 2246, 0, 0, 3561, 3562, 3, 2292, 1146, 0, 3562, 121, 1, 0, 0, 0, 3563, 3564, 7, 26, 0, 0, 3564, 3565, 3, 2320, 1160, 0, 3565, 123, 1, 0, 0, 0, 3566, 3567, 5, 1552, 0, 0, 3567, 3568, 5, 2447, 0, 0, 3568, 3573, 3, 2342, 1171, 0, 3569, 3570, 5, 2453, 0, 0, 3570, 3572, 3, 2342, 1171, 0, 3571, 3569, 1, 0, 0, 0, 3572, 3575, 1, 0, 0, 0, 3573, 3571, 1, 0, 0, 0, 3573, 3574, 1, 0, 0, 0, 3574, 3576, 1, 0, 0, 0, 3575, 3573, 1, 0, 0, 0, 3576, 3577, 5, 2448, 0, 0, 3577, 125, 1, 0, 0, 0, 3578, 3579, 7, 27, 0, 0, 3579, 3580, 3, 2078, 1039, 0, 3580, 3581, 5, 160, 0, 0, 3581, 3582, 3, 2360, 1180, 0, 3582, 127, 1, 0, 0, 0, 3583, 3584, 5, 42, 0, 0, 3584, 3586, 5, 1315, 0, 0, 3585, 3587, 7, 28, 0, 0, 3586, 3585, 1, 0, 0, 0, 3586, 3587, 1, 0, 0, 0, 3587, 3588, 1, 0, 0, 0, 3588, 3590, 3, 2404, 1202, 0, 3589, 3591, 3, 130, 65, 0, 3590, 3589, 1, 0, 0, 0, 3591, 3592, 1, 0, 0, 0, 3592, 3590, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 129, 1, 0, 0, 0, 3594, 3605, 5, 1511, 0, 0, 3595, 3596, 5, 1559, 0, 0, 3596, 3597, 5, 2141, 0, 0, 3597, 3605, 3, 2404, 1202, 0, 3598, 3599, 5, 190, 0, 0, 3599, 3600, 5, 183, 0, 0, 3600, 3601, 5, 2141, 0, 0, 3601, 3605, 3, 2404, 1202, 0, 3602, 3605, 5, 499, 0, 0, 3603, 3605, 5, 429, 0, 0, 3604, 3594, 1, 0, 0, 0, 3604, 3595, 1, 0, 0, 0, 3604, 3598, 1, 0, 0, 0, 3604, 3602, 1, 0, 0, 0, 3604, 3603, 1, 0, 0, 0, 3605, 131, 1, 0, 0, 0, 3606, 3607, 5, 42, 0, 0, 3607, 3608, 5, 878, 0, 0, 3608, 3609, 5, 1463, 0, 0, 3609, 3613, 3, 2404, 1202, 0, 3610, 3614, 3, 134, 67, 0, 3611, 3614, 3, 136, 68, 0, 3612, 3614, 3, 138, 69, 0, 3613, 3610, 1, 0, 0, 0, 3613, 3611, 1, 0, 0, 0, 3613, 3612, 1, 0, 0, 0, 3614, 3618, 1, 0, 0, 0, 3615, 3616, 5, 2235, 0, 0, 3616, 3617, 5, 2472, 0, 0, 3617, 3619, 7, 29, 0, 0, 3618, 3615, 1, 0, 0, 0, 3618, 3619, 1, 0, 0, 0, 3619, 133, 1, 0, 0, 0, 3620, 3621, 3, 148, 74, 0, 3621, 3636, 5, 581, 0, 0, 3622, 3623, 5, 2472, 0, 0, 3623, 3624, 5, 2447, 0, 0, 3624, 3625, 3, 146, 73, 0, 3625, 3626, 5, 2448, 0, 0, 3626, 3637, 1, 0, 0, 0, 3627, 3634, 5, 38, 0, 0, 3628, 3629, 5, 534, 0, 0, 3629, 3630, 5, 2472, 0, 0, 3630, 3631, 5, 2447, 0, 0, 3631, 3632, 3, 146, 73, 0, 3632, 3633, 5, 2448, 0, 0, 3633, 3635, 1, 0, 0, 0, 3634, 3628, 1, 0, 0, 0, 3634, 3635, 1, 0, 0, 0, 3635, 3637, 1, 0, 0, 0, 3636, 3622, 1, 0, 0, 0, 3636, 3627, 1, 0, 0, 0, 3637, 135, 1, 0, 0, 0, 3638, 3639, 3, 148, 74, 0, 3639, 3654, 5, 1272, 0, 0, 3640, 3641, 5, 2472, 0, 0, 3641, 3642, 5, 2447, 0, 0, 3642, 3643, 3, 146, 73, 0, 3643, 3644, 5, 2448, 0, 0, 3644, 3655, 1, 0, 0, 0, 3645, 3652, 5, 38, 0, 0, 3646, 3647, 5, 534, 0, 0, 3647, 3648, 5, 2472, 0, 0, 3648, 3649, 5, 2447, 0, 0, 3649, 3650, 3, 146, 73, 0, 3650, 3651, 5, 2448, 0, 0, 3651, 3653, 1, 0, 0, 0, 3652, 3646, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3655, 1, 0, 0, 0, 3654, 3640, 1, 0, 0, 0, 3654, 3645, 1, 0, 0, 0, 3655, 137, 1, 0, 0, 0, 3656, 3657, 3, 148, 74, 0, 3657, 3677, 5, 1743, 0, 0, 3658, 3659, 5, 2472, 0, 0, 3659, 3660, 5, 2447, 0, 0, 3660, 3661, 3, 146, 73, 0, 3661, 3662, 5, 2448, 0, 0, 3662, 3678, 1, 0, 0, 0, 3663, 3664, 5, 2472, 0, 0, 3664, 3665, 5, 2447, 0, 0, 3665, 3666, 5, 2443, 0, 0, 3666, 3667, 5, 2448, 0, 0, 3667, 3678, 3, 140, 70, 0, 3668, 3675, 5, 38, 0, 0, 3669, 3670, 5, 534, 0, 0, 3670, 3671, 5, 2472, 0, 0, 3671, 3672, 5, 2447, 0, 0, 3672, 3673, 3, 146, 73, 0, 3673, 3674, 5, 2448, 0, 0, 3674, 3676, 1, 0, 0, 0, 3675, 3669, 1, 0, 0, 0, 3675, 3676, 1, 0, 0, 0, 3676, 3678, 1, 0, 0, 0, 3677, 3658, 1, 0, 0, 0, 3677, 3663, 1, 0, 0, 0, 3677, 3668, 1, 0, 0, 0, 3678, 139, 1, 0, 0, 0, 3679, 3699, 5, 209, 0, 0, 3680, 3681, 5, 2472, 0, 0, 3681, 3682, 5, 2447, 0, 0, 3682, 3683, 3, 146, 73, 0, 3683, 3684, 5, 2448, 0, 0, 3684, 3700, 1, 0, 0, 0, 3685, 3686, 5, 2472, 0, 0, 3686, 3687, 5, 2447, 0, 0, 3687, 3688, 5, 2443, 0, 0, 3688, 3689, 5, 2448, 0, 0, 3689, 3700, 3, 142, 71, 0, 3690, 3697, 5, 38, 0, 0, 3691, 3692, 5, 534, 0, 0, 3692, 3693, 5, 2472, 0, 0, 3693, 3694, 5, 2447, 0, 0, 3694, 3695, 3, 146, 73, 0, 3695, 3696, 5, 2448, 0, 0, 3696, 3698, 1, 0, 0, 0, 3697, 3691, 1, 0, 0, 0, 3697, 3698, 1, 0, 0, 0, 3698, 3700, 1, 0, 0, 0, 3699, 3680, 1, 0, 0, 0, 3699, 3685, 1, 0, 0, 0, 3699, 3690, 1, 0, 0, 0, 3700, 141, 1, 0, 0, 0, 3701, 3725, 5, 1272, 0, 0, 3702, 3703, 5, 2472, 0, 0, 3703, 3704, 5, 2447, 0, 0, 3704, 3705, 3, 146, 73, 0, 3705, 3706, 5, 2448, 0, 0, 3706, 3726, 1, 0, 0, 0, 3707, 3708, 5, 2472, 0, 0, 3708, 3709, 5, 2447, 0, 0, 3709, 3710, 5, 2443, 0, 0, 3710, 3712, 5, 2448, 0, 0, 3711, 3713, 3, 144, 72, 0, 3712, 3711, 1, 0, 0, 0, 3713, 3714, 1, 0, 0, 0, 3714, 3712, 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3726, 1, 0, 0, 0, 3716, 3723, 5, 38, 0, 0, 3717, 3718, 5, 534, 0, 0, 3718, 3719, 5, 2472, 0, 0, 3719, 3720, 5, 2447, 0, 0, 3720, 3721, 3, 146, 73, 0, 3721, 3722, 5, 2448, 0, 0, 3722, 3724, 1, 0, 0, 0, 3723, 3717, 1, 0, 0, 0, 3723, 3724, 1, 0, 0, 0, 3724, 3726, 1, 0, 0, 0, 3725, 3702, 1, 0, 0, 0, 3725, 3707, 1, 0, 0, 0, 3725, 3716, 1, 0, 0, 0, 3726, 143, 1, 0, 0, 0, 3727, 3728, 5, 2258, 0, 0, 3728, 3729, 5, 2472, 0, 0, 3729, 3730, 5, 2447, 0, 0, 3730, 3731, 3, 146, 73, 0, 3731, 3732, 5, 2448, 0, 0, 3732, 3737, 1, 0, 0, 0, 3733, 3734, 7, 30, 0, 0, 3734, 3735, 5, 2472, 0, 0, 3735, 3737, 5, 2443, 0, 0, 3736, 3727, 1, 0, 0, 0, 3736, 3733, 1, 0, 0, 0, 3737, 145, 1, 0, 0, 0, 3738, 3743, 5, 2443, 0, 0, 3739, 3740, 5, 2453, 0, 0, 3740, 3742, 5, 2443, 0, 0, 3741, 3739, 1, 0, 0, 0, 3742, 3745, 1, 0, 0, 0, 3743, 3741, 1, 0, 0, 0, 3743, 3744, 1, 0, 0, 0, 3744, 147, 1, 0, 0, 0, 3745, 3743, 1, 0, 0, 0, 3746, 3747, 7, 17, 0, 0, 3747, 149, 1, 0, 0, 0, 3748, 3749, 5, 469, 0, 0, 3749, 3750, 5, 878, 0, 0, 3750, 3751, 5, 1463, 0, 0, 3751, 3752, 3, 2404, 1202, 0, 3752, 151, 1, 0, 0, 0, 3753, 3754, 5, 469, 0, 0, 3754, 3756, 5, 1329, 0, 0, 3755, 3757, 5, 147, 0, 0, 3756, 3755, 1, 0, 0, 0, 3756, 3757, 1, 0, 0, 0, 3757, 3761, 1, 0, 0, 0, 3758, 3759, 3, 2350, 1175, 0, 3759, 3760, 5, 2440, 0, 0, 3760, 3762, 1, 0, 0, 0, 3761, 3758, 1, 0, 0, 0, 3761, 3762, 1, 0, 0, 0, 3762, 3763, 1, 0, 0, 0, 3763, 3764, 3, 2290, 1145, 0, 3764, 153, 1, 0, 0, 0, 3765, 3766, 5, 42, 0, 0, 3766, 3767, 5, 1329, 0, 0, 3767, 3768, 3, 2290, 1145, 0, 3768, 3770, 5, 249, 0, 0, 3769, 3771, 5, 378, 0, 0, 3770, 3769, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 3773, 1, 0, 0, 0, 3772, 3774, 7, 31, 0, 0, 3773, 3772, 1, 0, 0, 0, 3773, 3774, 1, 0, 0, 0, 3774, 3778, 1, 0, 0, 0, 3775, 3777, 3, 812, 406, 0, 3776, 3775, 1, 0, 0, 0, 3777, 3780, 1, 0, 0, 0, 3778, 3776, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3783, 1, 0, 0, 0, 3780, 3778, 1, 0, 0, 0, 3781, 3782, 5, 1587, 0, 0, 3782, 3784, 5, 1673, 0, 0, 3783, 3781, 1, 0, 0, 0, 3783, 3784, 1, 0, 0, 0, 3784, 155, 1, 0, 0, 0, 3785, 3788, 5, 321, 0, 0, 3786, 3787, 5, 1307, 0, 0, 3787, 3789, 5, 1562, 0, 0, 3788, 3786, 1, 0, 0, 0, 3788, 3789, 1, 0, 0, 0, 3789, 3791, 1, 0, 0, 0, 3790, 3792, 7, 20, 0, 0, 3791, 3790, 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 3793, 1, 0, 0, 0, 3793, 3797, 5, 1329, 0, 0, 3794, 3795, 3, 2350, 1175, 0, 3795, 3796, 5, 2440, 0, 0, 3796, 3798, 1, 0, 0, 0, 3797, 3794, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, 3799, 1, 0, 0, 0, 3799, 3801, 3, 2290, 1145, 0, 3800, 3802, 3, 1720, 860, 0, 3801, 3800, 1, 0, 0, 0, 3801, 3802, 1, 0, 0, 0, 3802, 3803, 1, 0, 0, 0, 3803, 3807, 7, 22, 0, 0, 3804, 3806, 3, 160, 80, 0, 3805, 3804, 1, 0, 0, 0, 3806, 3809, 1, 0, 0, 0, 3807, 3805, 1, 0, 0, 0, 3807, 3808, 1, 0, 0, 0, 3808, 3810, 1, 0, 0, 0, 3809, 3807, 1, 0, 0, 0, 3810, 3812, 5, 508, 0, 0, 3811, 3813, 3, 2290, 1145, 0, 3812, 3811, 1, 0, 0, 0, 3812, 3813, 1, 0, 0, 0, 3813, 157, 1, 0, 0, 0, 3814, 3817, 5, 321, 0, 0, 3815, 3816, 5, 1307, 0, 0, 3816, 3818, 5, 1562, 0, 0, 3817, 3815, 1, 0, 0, 0, 3817, 3818, 1, 0, 0, 0, 3818, 3820, 1, 0, 0, 0, 3819, 3821, 7, 20, 0, 0, 3820, 3819, 1, 0, 0, 0, 3820, 3821, 1, 0, 0, 0, 3821, 3822, 1, 0, 0, 0, 3822, 3823, 5, 1329, 0, 0, 3823, 3827, 5, 147, 0, 0, 3824, 3825, 3, 2350, 1175, 0, 3825, 3826, 5, 2440, 0, 0, 3826, 3828, 1, 0, 0, 0, 3827, 3824, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3830, 3, 2290, 1145, 0, 3830, 3834, 7, 22, 0, 0, 3831, 3833, 3, 166, 83, 0, 3832, 3831, 1, 0, 0, 0, 3833, 3836, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3834, 3832, 1, 0, 0, 0, 3835, 3847, 1, 0, 0, 0, 3836, 3834, 1, 0, 0, 0, 3837, 3838, 5, 113, 0, 0, 3838, 3845, 3, 1770, 885, 0, 3839, 3841, 5, 535, 0, 0, 3840, 3842, 3, 1822, 911, 0, 3841, 3840, 1, 0, 0, 0, 3842, 3843, 1, 0, 0, 0, 3843, 3841, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, 3846, 1, 0, 0, 0, 3845, 3839, 1, 0, 0, 0, 3845, 3846, 1, 0, 0, 0, 3846, 3848, 1, 0, 0, 0, 3847, 3837, 1, 0, 0, 0, 3847, 3848, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, 3851, 5, 508, 0, 0, 3850, 3852, 3, 2290, 1145, 0, 3851, 3850, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, 0, 3852, 159, 1, 0, 0, 0, 3853, 3862, 3, 1754, 877, 0, 3854, 3862, 3, 1752, 876, 0, 3855, 3862, 3, 162, 81, 0, 3856, 3862, 3, 164, 82, 0, 3857, 3862, 3, 1744, 872, 0, 3858, 3862, 3, 1746, 873, 0, 3859, 3862, 3, 1748, 874, 0, 3860, 3862, 3, 1762, 881, 0, 3861, 3853, 1, 0, 0, 0, 3861, 3854, 1, 0, 0, 0, 3861, 3855, 1, 0, 0, 0, 3861, 3856, 1, 0, 0, 0, 3861, 3857, 1, 0, 0, 0, 3861, 3858, 1, 0, 0, 0, 3861, 3859, 1, 0, 0, 0, 3861, 3860, 1, 0, 0, 0, 3862, 161, 1, 0, 0, 0, 3863, 3864, 5, 1461, 0, 0, 3864, 3876, 3, 2402, 1201, 0, 3865, 3866, 5, 2447, 0, 0, 3866, 3871, 3, 1736, 868, 0, 3867, 3868, 5, 2453, 0, 0, 3868, 3870, 3, 1736, 868, 0, 3869, 3867, 1, 0, 0, 0, 3870, 3873, 1, 0, 0, 0, 3871, 3869, 1, 0, 0, 0, 3871, 3872, 1, 0, 0, 0, 3872, 3874, 1, 0, 0, 0, 3873, 3871, 1, 0, 0, 0, 3874, 3875, 5, 2448, 0, 0, 3875, 3877, 1, 0, 0, 0, 3876, 3865, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 3883, 1, 0, 0, 0, 3878, 3882, 3, 114, 57, 0, 3879, 3882, 5, 1331, 0, 0, 3880, 3882, 5, 420, 0, 0, 3881, 3878, 1, 0, 0, 0, 3881, 3879, 1, 0, 0, 0, 3881, 3880, 1, 0, 0, 0, 3882, 3885, 1, 0, 0, 0, 3883, 3881, 1, 0, 0, 0, 3883, 3884, 1, 0, 0, 0, 3884, 3888, 1, 0, 0, 0, 3885, 3883, 1, 0, 0, 0, 3886, 3887, 5, 69, 0, 0, 3887, 3889, 3, 1722, 861, 0, 3888, 3886, 1, 0, 0, 0, 3888, 3889, 1, 0, 0, 0, 3889, 3890, 1, 0, 0, 0, 3890, 3891, 5, 2470, 0, 0, 3891, 163, 1, 0, 0, 0, 3892, 3893, 5, 632, 0, 0, 3893, 3905, 3, 2402, 1201, 0, 3894, 3895, 5, 2447, 0, 0, 3895, 3900, 3, 1736, 868, 0, 3896, 3897, 5, 2453, 0, 0, 3897, 3899, 3, 1736, 868, 0, 3898, 3896, 1, 0, 0, 0, 3899, 3902, 1, 0, 0, 0, 3900, 3898, 1, 0, 0, 0, 3900, 3901, 1, 0, 0, 0, 3901, 3903, 1, 0, 0, 0, 3902, 3900, 1, 0, 0, 0, 3903, 3904, 5, 2448, 0, 0, 3904, 3906, 1, 0, 0, 0, 3905, 3894, 1, 0, 0, 0, 3905, 3906, 1, 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3908, 5, 1586, 0, 0, 3908, 3916, 3, 2374, 1187, 0, 3909, 3915, 5, 420, 0, 0, 3910, 3915, 5, 1394, 0, 0, 3911, 3915, 3, 108, 54, 0, 3912, 3915, 5, 1579, 0, 0, 3913, 3915, 3, 126, 63, 0, 3914, 3909, 1, 0, 0, 0, 3914, 3910, 1, 0, 0, 0, 3914, 3911, 1, 0, 0, 0, 3914, 3912, 1, 0, 0, 0, 3914, 3913, 1, 0, 0, 0, 3915, 3918, 1, 0, 0, 0, 3916, 3914, 1, 0, 0, 0, 3916, 3917, 1, 0, 0, 0, 3917, 3921, 1, 0, 0, 0, 3918, 3916, 1, 0, 0, 0, 3919, 3920, 5, 69, 0, 0, 3920, 3922, 3, 1722, 861, 0, 3921, 3919, 1, 0, 0, 0, 3921, 3922, 1, 0, 0, 0, 3922, 3923, 1, 0, 0, 0, 3923, 3924, 5, 2470, 0, 0, 3924, 165, 1, 0, 0, 0, 3925, 3937, 3, 1754, 877, 0, 3926, 3937, 3, 1752, 876, 0, 3927, 3937, 3, 162, 81, 0, 3928, 3937, 3, 164, 82, 0, 3929, 3937, 3, 1746, 873, 0, 3930, 3937, 3, 1748, 874, 0, 3931, 3937, 3, 1744, 872, 0, 3932, 3937, 3, 1762, 881, 0, 3933, 3937, 3, 178, 89, 0, 3934, 3937, 3, 176, 88, 0, 3935, 3937, 3, 1814, 907, 0, 3936, 3925, 1, 0, 0, 0, 3936, 3926, 1, 0, 0, 0, 3936, 3927, 1, 0, 0, 0, 3936, 3928, 1, 0, 0, 0, 3936, 3929, 1, 0, 0, 0, 3936, 3930, 1, 0, 0, 0, 3936, 3931, 1, 0, 0, 0, 3936, 3932, 1, 0, 0, 0, 3936, 3933, 1, 0, 0, 0, 3936, 3934, 1, 0, 0, 0, 3936, 3935, 1, 0, 0, 0, 3937, 167, 1, 0, 0, 0, 3938, 3939, 5, 42, 0, 0, 3939, 3940, 5, 1410, 0, 0, 3940, 3941, 5, 592, 0, 0, 3941, 3958, 3, 2404, 1202, 0, 3942, 3943, 5, 1567, 0, 0, 3943, 3959, 3, 1176, 588, 0, 3944, 3959, 3, 922, 461, 0, 3945, 3948, 5, 988, 0, 0, 3946, 3947, 5, 990, 0, 0, 3947, 3949, 3, 198, 99, 0, 3948, 3946, 1, 0, 0, 0, 3948, 3949, 1, 0, 0, 0, 3949, 3952, 1, 0, 0, 0, 3950, 3951, 5, 101, 0, 0, 3951, 3953, 3, 1458, 729, 0, 3952, 3950, 1, 0, 0, 0, 3952, 3953, 1, 0, 0, 0, 3953, 3955, 1, 0, 0, 0, 3954, 3956, 5, 616, 0, 0, 3955, 3954, 1, 0, 0, 0, 3955, 3956, 1, 0, 0, 0, 3956, 3959, 1, 0, 0, 0, 3957, 3959, 5, 444, 0, 0, 3958, 3942, 1, 0, 0, 0, 3958, 3944, 1, 0, 0, 0, 3958, 3945, 1, 0, 0, 0, 3958, 3957, 1, 0, 0, 0, 3959, 169, 1, 0, 0, 0, 3960, 3961, 5, 469, 0, 0, 3961, 3962, 5, 1410, 0, 0, 3962, 3963, 5, 592, 0, 0, 3963, 3972, 3, 2404, 1202, 0, 3964, 3966, 5, 616, 0, 0, 3965, 3964, 1, 0, 0, 0, 3965, 3966, 1, 0, 0, 0, 3966, 3967, 1, 0, 0, 0, 3967, 3970, 5, 705, 0, 0, 3968, 3970, 5, 540, 0, 0, 3969, 3965, 1, 0, 0, 0, 3969, 3968, 1, 0, 0, 0, 3970, 3971, 1, 0, 0, 0, 3971, 3973, 5, 295, 0, 0, 3972, 3969, 1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, 171, 1, 0, 0, 0, 3974, 3975, 5, 469, 0, 0, 3975, 3976, 5, 1461, 0, 0, 3976, 3977, 3, 2322, 1161, 0, 3977, 173, 1, 0, 0, 0, 3978, 3979, 5, 42, 0, 0, 3979, 3980, 5, 1461, 0, 0, 3980, 3981, 3, 2322, 1161, 0, 3981, 3983, 5, 249, 0, 0, 3982, 3984, 5, 378, 0, 0, 3983, 3982, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, 3984, 3988, 1, 0, 0, 0, 3985, 3987, 3, 812, 406, 0, 3986, 3985, 1, 0, 0, 0, 3987, 3990, 1, 0, 0, 0, 3988, 3986, 1, 0, 0, 0, 3988, 3989, 1, 0, 0, 0, 3989, 3993, 1, 0, 0, 0, 3990, 3988, 1, 0, 0, 0, 3991, 3992, 5, 1587, 0, 0, 3992, 3994, 5, 1673, 0, 0, 3993, 3991, 1, 0, 0, 0, 3993, 3994, 1, 0, 0, 0, 3994, 175, 1, 0, 0, 0, 3995, 3996, 5, 632, 0, 0, 3996, 4008, 3, 2402, 1201, 0, 3997, 3998, 5, 2447, 0, 0, 3998, 4003, 3, 1736, 868, 0, 3999, 4000, 5, 2453, 0, 0, 4000, 4002, 3, 1736, 868, 0, 4001, 3999, 1, 0, 0, 0, 4002, 4005, 1, 0, 0, 0, 4003, 4001, 1, 0, 0, 0, 4003, 4004, 1, 0, 0, 0, 4004, 4006, 1, 0, 0, 0, 4005, 4003, 1, 0, 0, 0, 4006, 4007, 5, 2448, 0, 0, 4007, 4009, 1, 0, 0, 0, 4008, 3997, 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4011, 5, 1586, 0, 0, 4011, 4020, 3, 2374, 1187, 0, 4012, 4019, 5, 1394, 0, 0, 4013, 4019, 5, 420, 0, 0, 4014, 4019, 3, 1720, 860, 0, 4015, 4019, 3, 108, 54, 0, 4016, 4019, 3, 112, 56, 0, 4017, 4019, 3, 126, 63, 0, 4018, 4012, 1, 0, 0, 0, 4018, 4013, 1, 0, 0, 0, 4018, 4014, 1, 0, 0, 0, 4018, 4015, 1, 0, 0, 0, 4018, 4016, 1, 0, 0, 0, 4018, 4017, 1, 0, 0, 0, 4019, 4022, 1, 0, 0, 0, 4020, 4018, 1, 0, 0, 0, 4020, 4021, 1, 0, 0, 0, 4021, 4037, 1, 0, 0, 0, 4022, 4020, 1, 0, 0, 0, 4023, 4032, 7, 22, 0, 0, 4024, 4026, 5, 382, 0, 0, 4025, 4024, 1, 0, 0, 0, 4025, 4026, 1, 0, 0, 0, 4026, 4028, 1, 0, 0, 0, 4027, 4029, 3, 1740, 870, 0, 4028, 4027, 1, 0, 0, 0, 4028, 4029, 1, 0, 0, 0, 4029, 4030, 1, 0, 0, 0, 4030, 4033, 3, 1820, 910, 0, 4031, 4033, 3, 1722, 861, 0, 4032, 4025, 1, 0, 0, 0, 4032, 4031, 1, 0, 0, 0, 4033, 4038, 1, 0, 0, 0, 4034, 4035, 7, 32, 0, 0, 4035, 4036, 5, 2246, 0, 0, 4036, 4038, 3, 2292, 1146, 0, 4037, 4023, 1, 0, 0, 0, 4037, 4034, 1, 0, 0, 0, 4038, 4039, 1, 0, 0, 0, 4039, 4040, 5, 2470, 0, 0, 4040, 177, 1, 0, 0, 0, 4041, 4042, 5, 1461, 0, 0, 4042, 4054, 3, 2402, 1201, 0, 4043, 4044, 5, 2447, 0, 0, 4044, 4049, 3, 1736, 868, 0, 4045, 4046, 5, 2453, 0, 0, 4046, 4048, 3, 1736, 868, 0, 4047, 4045, 1, 0, 0, 0, 4048, 4051, 1, 0, 0, 0, 4049, 4047, 1, 0, 0, 0, 4049, 4050, 1, 0, 0, 0, 4050, 4052, 1, 0, 0, 0, 4051, 4049, 1, 0, 0, 0, 4052, 4053, 5, 2448, 0, 0, 4053, 4055, 1, 0, 0, 0, 4054, 4043, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, 4061, 1, 0, 0, 0, 4056, 4060, 3, 114, 57, 0, 4057, 4060, 5, 1331, 0, 0, 4058, 4060, 5, 420, 0, 0, 4059, 4056, 1, 0, 0, 0, 4059, 4057, 1, 0, 0, 0, 4059, 4058, 1, 0, 0, 0, 4060, 4063, 1, 0, 0, 0, 4061, 4059, 1, 0, 0, 0, 4061, 4062, 1, 0, 0, 0, 4062, 4064, 1, 0, 0, 0, 4063, 4061, 1, 0, 0, 0, 4064, 4074, 7, 22, 0, 0, 4065, 4067, 5, 382, 0, 0, 4066, 4065, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4069, 1, 0, 0, 0, 4068, 4070, 3, 1740, 870, 0, 4069, 4068, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, 4070, 4071, 1, 0, 0, 0, 4071, 4075, 3, 1820, 910, 0, 4072, 4075, 3, 1722, 861, 0, 4073, 4075, 5, 560, 0, 0, 4074, 4066, 1, 0, 0, 0, 4074, 4072, 1, 0, 0, 0, 4074, 4073, 1, 0, 0, 0, 4075, 4076, 1, 0, 0, 0, 4076, 4077, 5, 2470, 0, 0, 4077, 179, 1, 0, 0, 0, 4078, 4081, 5, 321, 0, 0, 4079, 4080, 5, 1307, 0, 0, 4080, 4082, 5, 1562, 0, 0, 4081, 4079, 1, 0, 0, 0, 4081, 4082, 1, 0, 0, 0, 4082, 4083, 1, 0, 0, 0, 4083, 4084, 5, 1461, 0, 0, 4084, 4096, 3, 2322, 1161, 0, 4085, 4086, 5, 2447, 0, 0, 4086, 4091, 3, 1736, 868, 0, 4087, 4088, 5, 2453, 0, 0, 4088, 4090, 3, 1736, 868, 0, 4089, 4087, 1, 0, 0, 0, 4090, 4093, 1, 0, 0, 0, 4091, 4089, 1, 0, 0, 0, 4091, 4092, 1, 0, 0, 0, 4092, 4094, 1, 0, 0, 0, 4093, 4091, 1, 0, 0, 0, 4094, 4095, 5, 2448, 0, 0, 4095, 4097, 1, 0, 0, 0, 4096, 4085, 1, 0, 0, 0, 4096, 4097, 1, 0, 0, 0, 4097, 4099, 1, 0, 0, 0, 4098, 4100, 3, 1720, 860, 0, 4099, 4098, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4104, 1, 0, 0, 0, 4101, 4103, 7, 33, 0, 0, 4102, 4101, 1, 0, 0, 0, 4103, 4106, 1, 0, 0, 0, 4104, 4102, 1, 0, 0, 0, 4104, 4105, 1, 0, 0, 0, 4105, 4107, 1, 0, 0, 0, 4106, 4104, 1, 0, 0, 0, 4107, 4117, 7, 22, 0, 0, 4108, 4110, 5, 382, 0, 0, 4109, 4108, 1, 0, 0, 0, 4109, 4110, 1, 0, 0, 0, 4110, 4112, 1, 0, 0, 0, 4111, 4113, 3, 1740, 870, 0, 4112, 4111, 1, 0, 0, 0, 4112, 4113, 1, 0, 0, 0, 4113, 4114, 1, 0, 0, 0, 4114, 4118, 3, 1820, 910, 0, 4115, 4118, 3, 1722, 861, 0, 4116, 4118, 5, 560, 0, 0, 4117, 4109, 1, 0, 0, 0, 4117, 4115, 1, 0, 0, 0, 4117, 4116, 1, 0, 0, 0, 4118, 181, 1, 0, 0, 0, 4119, 4120, 5, 42, 0, 0, 4120, 4121, 5, 1570, 0, 0, 4121, 4124, 5, 311, 0, 0, 4122, 4123, 7, 34, 0, 0, 4123, 4125, 5, 2441, 0, 0, 4124, 4122, 1, 0, 0, 0, 4125, 4126, 1, 0, 0, 0, 4126, 4124, 1, 0, 0, 0, 4126, 4127, 1, 0, 0, 0, 4127, 183, 1, 0, 0, 0, 4128, 4129, 5, 469, 0, 0, 4129, 4130, 5, 1315, 0, 0, 4130, 4131, 3, 2404, 1202, 0, 4131, 185, 1, 0, 0, 0, 4132, 4133, 5, 42, 0, 0, 4133, 4134, 5, 1596, 0, 0, 4134, 4135, 5, 1645, 0, 0, 4135, 4144, 3, 2284, 1142, 0, 4136, 4145, 5, 1256, 0, 0, 4137, 4145, 5, 1243, 0, 0, 4138, 4145, 3, 1196, 598, 0, 4139, 4142, 5, 1684, 0, 0, 4140, 4141, 5, 2141, 0, 0, 4141, 4143, 3, 1176, 588, 0, 4142, 4140, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 4145, 1, 0, 0, 0, 4144, 4136, 1, 0, 0, 0, 4144, 4137, 1, 0, 0, 0, 4144, 4138, 1, 0, 0, 0, 4144, 4139, 1, 0, 0, 0, 4145, 187, 1, 0, 0, 0, 4146, 4147, 5, 469, 0, 0, 4147, 4148, 5, 1574, 0, 0, 4148, 4149, 5, 1411, 0, 0, 4149, 4154, 3, 2404, 1202, 0, 4150, 4151, 5, 620, 0, 0, 4151, 4152, 5, 1409, 0, 0, 4152, 4153, 5, 350, 0, 0, 4153, 4155, 3, 2404, 1202, 0, 4154, 4150, 1, 0, 0, 0, 4154, 4155, 1, 0, 0, 0, 4155, 189, 1, 0, 0, 0, 4156, 4157, 5, 469, 0, 0, 4157, 4158, 5, 1596, 0, 0, 4158, 4159, 5, 1645, 0, 0, 4159, 4160, 3, 2284, 1142, 0, 4160, 191, 1, 0, 0, 0, 4161, 4162, 5, 469, 0, 0, 4162, 4163, 5, 1593, 0, 0, 4163, 4164, 3, 2308, 1154, 0, 4164, 193, 1, 0, 0, 0, 4165, 4166, 5, 321, 0, 0, 4166, 4167, 5, 1410, 0, 0, 4167, 4168, 5, 592, 0, 0, 4168, 4170, 3, 2404, 1202, 0, 4169, 4171, 3, 196, 98, 0, 4170, 4169, 1, 0, 0, 0, 4171, 4172, 1, 0, 0, 0, 4172, 4170, 1, 0, 0, 0, 4172, 4173, 1, 0, 0, 0, 4173, 195, 1, 0, 0, 0, 4174, 4175, 5, 990, 0, 0, 4175, 4185, 3, 198, 99, 0, 4176, 4177, 5, 101, 0, 0, 4177, 4179, 3, 1458, 729, 0, 4178, 4180, 5, 1587, 0, 0, 4179, 4178, 1, 0, 0, 0, 4179, 4180, 1, 0, 0, 0, 4180, 4185, 1, 0, 0, 0, 4181, 4182, 7, 35, 0, 0, 4182, 4185, 3, 1176, 588, 0, 4183, 4185, 3, 922, 461, 0, 4184, 4174, 1, 0, 0, 0, 4184, 4176, 1, 0, 0, 0, 4184, 4181, 1, 0, 0, 0, 4184, 4183, 1, 0, 0, 0, 4185, 197, 1, 0, 0, 0, 4186, 4187, 5, 2443, 0, 0, 4187, 199, 1, 0, 0, 0, 4188, 4190, 5, 321, 0, 0, 4189, 4191, 5, 1473, 0, 0, 4190, 4189, 1, 0, 0, 0, 4190, 4191, 1, 0, 0, 0, 4191, 4192, 1, 0, 0, 0, 4192, 4193, 5, 1596, 0, 0, 4193, 4194, 5, 1645, 0, 0, 4194, 4200, 3, 2284, 1142, 0, 4195, 4196, 5, 2080, 0, 0, 4196, 4199, 3, 1656, 828, 0, 4197, 4199, 3, 1196, 598, 0, 4198, 4195, 1, 0, 0, 0, 4198, 4197, 1, 0, 0, 0, 4199, 4202, 1, 0, 0, 0, 4200, 4198, 1, 0, 0, 0, 4200, 4201, 1, 0, 0, 0, 4201, 201, 1, 0, 0, 0, 4202, 4200, 1, 0, 0, 0, 4203, 4204, 5, 469, 0, 0, 4204, 4205, 5, 2157, 0, 0, 4205, 4206, 3, 2324, 1162, 0, 4206, 203, 1, 0, 0, 0, 4207, 4208, 5, 42, 0, 0, 4208, 4209, 5, 2157, 0, 0, 4209, 4228, 3, 2324, 1162, 0, 4210, 4229, 7, 17, 0, 0, 4211, 4212, 5, 1559, 0, 0, 4212, 4213, 5, 2141, 0, 0, 4213, 4229, 3, 2324, 1162, 0, 4214, 4216, 5, 249, 0, 0, 4215, 4217, 5, 378, 0, 0, 4216, 4215, 1, 0, 0, 0, 4216, 4217, 1, 0, 0, 0, 4217, 4221, 1, 0, 0, 0, 4218, 4220, 3, 812, 406, 0, 4219, 4218, 1, 0, 0, 0, 4220, 4223, 1, 0, 0, 0, 4221, 4219, 1, 0, 0, 0, 4221, 4222, 1, 0, 0, 0, 4222, 4226, 1, 0, 0, 0, 4223, 4221, 1, 0, 0, 0, 4224, 4225, 5, 1587, 0, 0, 4225, 4227, 5, 1673, 0, 0, 4226, 4224, 1, 0, 0, 0, 4226, 4227, 1, 0, 0, 0, 4227, 4229, 1, 0, 0, 0, 4228, 4210, 1, 0, 0, 0, 4228, 4211, 1, 0, 0, 0, 4228, 4214, 1, 0, 0, 0, 4229, 205, 1, 0, 0, 0, 4230, 4233, 5, 321, 0, 0, 4231, 4232, 5, 1307, 0, 0, 4232, 4234, 5, 1562, 0, 0, 4233, 4231, 1, 0, 0, 0, 4233, 4234, 1, 0, 0, 0, 4234, 4235, 1, 0, 0, 0, 4235, 4236, 5, 2157, 0, 0, 4236, 4240, 3, 2324, 1162, 0, 4237, 4241, 3, 212, 106, 0, 4238, 4241, 3, 216, 108, 0, 4239, 4241, 3, 218, 109, 0, 4240, 4237, 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4240, 4239, 1, 0, 0, 0, 4241, 4243, 1, 0, 0, 0, 4242, 4244, 3, 208, 104, 0, 4243, 4242, 1, 0, 0, 0, 4243, 4244, 1, 0, 0, 0, 4244, 4246, 1, 0, 0, 0, 4245, 4247, 7, 17, 0, 0, 4246, 4245, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, 1, 0, 0, 0, 4248, 4250, 3, 210, 105, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 4252, 3, 220, 110, 0, 4252, 207, 1, 0, 0, 0, 4253, 4254, 5, 614, 0, 0, 4254, 4259, 3, 2324, 1162, 0, 4255, 4256, 5, 2453, 0, 0, 4256, 4258, 3, 2324, 1162, 0, 4257, 4255, 1, 0, 0, 0, 4258, 4261, 1, 0, 0, 0, 4259, 4257, 1, 0, 0, 0, 4259, 4260, 1, 0, 0, 0, 4260, 209, 1, 0, 0, 0, 4261, 4259, 1, 0, 0, 0, 4262, 4263, 5, 2300, 0, 0, 4263, 4264, 5, 2447, 0, 0, 4264, 4265, 3, 2074, 1037, 0, 4265, 4266, 5, 2448, 0, 0, 4266, 211, 1, 0, 0, 0, 4267, 4272, 5, 112, 0, 0, 4268, 4272, 5, 33, 0, 0, 4269, 4270, 5, 763, 0, 0, 4270, 4272, 5, 1246, 0, 0, 4271, 4267, 1, 0, 0, 0, 4271, 4268, 1, 0, 0, 0, 4271, 4269, 1, 0, 0, 0, 4272, 4273, 1, 0, 0, 0, 4273, 4275, 3, 228, 114, 0, 4274, 4276, 3, 234, 117, 0, 4275, 4274, 1, 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4278, 1, 0, 0, 0, 4277, 4279, 3, 214, 107, 0, 4278, 4277, 1, 0, 0, 0, 4278, 4279, 1, 0, 0, 0, 4279, 213, 1, 0, 0, 0, 4280, 4281, 5, 620, 0, 0, 4281, 4282, 5, 481, 0, 0, 4282, 4283, 5, 1606, 0, 0, 4283, 215, 1, 0, 0, 0, 4284, 4285, 5, 620, 0, 0, 4285, 4287, 3, 228, 114, 0, 4286, 4288, 3, 234, 117, 0, 4287, 4286, 1, 0, 0, 0, 4287, 4288, 1, 0, 0, 0, 4288, 217, 1, 0, 0, 0, 4289, 4290, 7, 36, 0, 0, 4290, 4295, 3, 226, 113, 0, 4291, 4292, 5, 1307, 0, 0, 4292, 4294, 3, 226, 113, 0, 4293, 4291, 1, 0, 0, 0, 4294, 4297, 1, 0, 0, 0, 4295, 4293, 1, 0, 0, 0, 4295, 4296, 1, 0, 0, 0, 4296, 4298, 1, 0, 0, 0, 4297, 4295, 1, 0, 0, 0, 4298, 4306, 5, 1259, 0, 0, 4299, 4307, 5, 350, 0, 0, 4300, 4301, 3, 2286, 1143, 0, 4301, 4302, 5, 2440, 0, 0, 4302, 4304, 1, 0, 0, 0, 4303, 4300, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4305, 1, 0, 0, 0, 4305, 4307, 5, 1625, 0, 0, 4306, 4299, 1, 0, 0, 0, 4306, 4303, 1, 0, 0, 0, 4307, 219, 1, 0, 0, 0, 4308, 4313, 3, 222, 111, 0, 4309, 4310, 5, 173, 0, 0, 4310, 4313, 3, 2402, 1201, 0, 4311, 4313, 3, 1824, 912, 0, 4312, 4308, 1, 0, 0, 0, 4312, 4309, 1, 0, 0, 0, 4312, 4311, 1, 0, 0, 0, 4313, 221, 1, 0, 0, 0, 4314, 4315, 5, 257, 0, 0, 4315, 4317, 5, 2157, 0, 0, 4316, 4318, 3, 1740, 870, 0, 4317, 4316, 1, 0, 0, 0, 4317, 4318, 1, 0, 0, 0, 4318, 4320, 1, 0, 0, 0, 4319, 4321, 3, 224, 112, 0, 4320, 4319, 1, 0, 0, 0, 4321, 4322, 1, 0, 0, 0, 4322, 4320, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, 4324, 1, 0, 0, 0, 4324, 4326, 5, 508, 0, 0, 4325, 4327, 3, 2324, 1162, 0, 4326, 4325, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 223, 1, 0, 0, 0, 4328, 4329, 5, 112, 0, 0, 4329, 4330, 5, 1743, 0, 0, 4330, 4331, 5, 785, 0, 0, 4331, 4332, 3, 1826, 913, 0, 4332, 4333, 5, 112, 0, 0, 4333, 4334, 5, 1743, 0, 0, 4334, 4335, 5, 2470, 0, 0, 4335, 4365, 1, 0, 0, 0, 4336, 4337, 5, 112, 0, 0, 4337, 4338, 5, 481, 0, 0, 4338, 4339, 5, 1606, 0, 0, 4339, 4340, 5, 785, 0, 0, 4340, 4341, 3, 1826, 913, 0, 4341, 4342, 5, 112, 0, 0, 4342, 4343, 5, 481, 0, 0, 4343, 4344, 5, 1606, 0, 0, 4344, 4345, 5, 2470, 0, 0, 4345, 4365, 1, 0, 0, 0, 4346, 4347, 5, 33, 0, 0, 4347, 4348, 5, 1743, 0, 0, 4348, 4349, 5, 785, 0, 0, 4349, 4350, 3, 1826, 913, 0, 4350, 4351, 5, 33, 0, 0, 4351, 4352, 5, 1743, 0, 0, 4352, 4353, 5, 2470, 0, 0, 4353, 4365, 1, 0, 0, 0, 4354, 4355, 5, 33, 0, 0, 4355, 4356, 5, 481, 0, 0, 4356, 4357, 5, 1606, 0, 0, 4357, 4358, 5, 785, 0, 0, 4358, 4359, 3, 1826, 913, 0, 4359, 4360, 5, 33, 0, 0, 4360, 4361, 5, 481, 0, 0, 4361, 4362, 5, 1606, 0, 0, 4362, 4363, 5, 2470, 0, 0, 4363, 4365, 1, 0, 0, 0, 4364, 4328, 1, 0, 0, 0, 4364, 4336, 1, 0, 0, 0, 4364, 4346, 1, 0, 0, 0, 4364, 4354, 1, 0, 0, 0, 4365, 225, 1, 0, 0, 0, 4366, 4393, 5, 42, 0, 0, 4367, 4393, 5, 46, 0, 0, 4368, 4369, 5, 77, 0, 0, 4369, 4393, 5, 1746, 0, 0, 4370, 4393, 5, 85, 0, 0, 4371, 4393, 5, 241, 0, 0, 4372, 4393, 5, 321, 0, 0, 4373, 4374, 5, 436, 0, 0, 4374, 4393, 5, 1746, 0, 0, 4375, 4393, 5, 469, 0, 0, 4376, 4393, 5, 647, 0, 0, 4377, 4393, 5, 1059, 0, 0, 4378, 4393, 5, 1559, 0, 0, 4379, 4393, 5, 1589, 0, 0, 4380, 4393, 5, 2159, 0, 0, 4381, 4393, 5, 376, 0, 0, 4382, 4393, 5, 1739, 0, 0, 4383, 4393, 5, 1685, 0, 0, 4384, 4393, 5, 372, 0, 0, 4385, 4393, 5, 891, 0, 0, 4386, 4393, 5, 890, 0, 0, 4387, 4393, 5, 1662, 0, 0, 4388, 4393, 5, 1790, 0, 0, 4389, 4393, 5, 350, 0, 0, 4390, 4393, 5, 1625, 0, 0, 4391, 4393, 5, 614, 0, 0, 4392, 4366, 1, 0, 0, 0, 4392, 4367, 1, 0, 0, 0, 4392, 4368, 1, 0, 0, 0, 4392, 4370, 1, 0, 0, 0, 4392, 4371, 1, 0, 0, 0, 4392, 4372, 1, 0, 0, 0, 4392, 4373, 1, 0, 0, 0, 4392, 4375, 1, 0, 0, 0, 4392, 4376, 1, 0, 0, 0, 4392, 4377, 1, 0, 0, 0, 4392, 4378, 1, 0, 0, 0, 4392, 4379, 1, 0, 0, 0, 4392, 4380, 1, 0, 0, 0, 4392, 4381, 1, 0, 0, 0, 4392, 4382, 1, 0, 0, 0, 4392, 4383, 1, 0, 0, 0, 4392, 4384, 1, 0, 0, 0, 4392, 4385, 1, 0, 0, 0, 4392, 4386, 1, 0, 0, 0, 4392, 4387, 1, 0, 0, 0, 4392, 4388, 1, 0, 0, 0, 4392, 4389, 1, 0, 0, 0, 4392, 4390, 1, 0, 0, 0, 4392, 4391, 1, 0, 0, 0, 4393, 227, 1, 0, 0, 0, 4394, 4399, 3, 230, 115, 0, 4395, 4396, 5, 1307, 0, 0, 4396, 4398, 3, 230, 115, 0, 4397, 4395, 1, 0, 0, 0, 4398, 4401, 1, 0, 0, 0, 4399, 4397, 1, 0, 0, 0, 4399, 4400, 1, 0, 0, 0, 4400, 4402, 1, 0, 0, 0, 4401, 4399, 1, 0, 0, 0, 4402, 4404, 5, 1259, 0, 0, 4403, 4405, 3, 232, 116, 0, 4404, 4403, 1, 0, 0, 0, 4404, 4405, 1, 0, 0, 0, 4405, 4406, 1, 0, 0, 0, 4406, 4407, 3, 2342, 1171, 0, 4407, 229, 1, 0, 0, 0, 4408, 4411, 7, 37, 0, 0, 4409, 4410, 5, 1246, 0, 0, 4410, 4412, 3, 2358, 1179, 0, 4411, 4409, 1, 0, 0, 0, 4411, 4412, 1, 0, 0, 0, 4412, 231, 1, 0, 0, 0, 4413, 4414, 5, 1013, 0, 0, 4414, 4415, 5, 2083, 0, 0, 4415, 4416, 3, 2342, 1171, 0, 4416, 4417, 5, 1246, 0, 0, 4417, 233, 1, 0, 0, 0, 4418, 4419, 5, 1529, 0, 0, 4419, 4422, 3, 236, 118, 0, 4420, 4422, 5, 1528, 0, 0, 4421, 4418, 1, 0, 0, 0, 4421, 4420, 1, 0, 0, 0, 4422, 4426, 1, 0, 0, 0, 4423, 4425, 3, 236, 118, 0, 4424, 4423, 1, 0, 0, 0, 4425, 4428, 1, 0, 0, 0, 4426, 4424, 1, 0, 0, 0, 4426, 4427, 1, 0, 0, 0, 4427, 235, 1, 0, 0, 0, 4428, 4426, 1, 0, 0, 0, 4429, 4430, 7, 38, 0, 0, 4430, 4431, 3, 2268, 1134, 0, 4431, 237, 1, 0, 0, 0, 4432, 4433, 5, 469, 0, 0, 4433, 4435, 5, 2166, 0, 0, 4434, 4436, 5, 147, 0, 0, 4435, 4434, 1, 0, 0, 0, 4435, 4436, 1, 0, 0, 0, 4436, 4437, 1, 0, 0, 0, 4437, 4439, 3, 2314, 1157, 0, 4438, 4440, 7, 39, 0, 0, 4439, 4438, 1, 0, 0, 0, 4439, 4440, 1, 0, 0, 0, 4440, 239, 1, 0, 0, 0, 4441, 4442, 5, 42, 0, 0, 4442, 4443, 5, 2166, 0, 0, 4443, 4450, 3, 2314, 1157, 0, 4444, 4451, 3, 242, 121, 0, 4445, 4451, 3, 244, 122, 0, 4446, 4451, 3, 246, 123, 0, 4447, 4451, 3, 250, 125, 0, 4448, 4451, 3, 284, 142, 0, 4449, 4451, 3, 296, 148, 0, 4450, 4444, 1, 0, 0, 0, 4450, 4445, 1, 0, 0, 0, 4450, 4446, 1, 0, 0, 0, 4450, 4447, 1, 0, 0, 0, 4450, 4448, 1, 0, 0, 0, 4450, 4449, 1, 0, 0, 0, 4451, 4453, 1, 0, 0, 0, 4452, 4454, 3, 252, 126, 0, 4453, 4452, 1, 0, 0, 0, 4453, 4454, 1, 0, 0, 0, 4454, 241, 1, 0, 0, 0, 4455, 4457, 5, 249, 0, 0, 4456, 4458, 5, 378, 0, 0, 4457, 4456, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458, 4460, 1, 0, 0, 0, 4459, 4461, 7, 40, 0, 0, 4460, 4459, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4465, 1, 0, 0, 0, 4462, 4464, 3, 812, 406, 0, 4463, 4462, 1, 0, 0, 0, 4464, 4467, 1, 0, 0, 0, 4465, 4463, 1, 0, 0, 0, 4465, 4466, 1, 0, 0, 0, 4466, 4470, 1, 0, 0, 0, 4467, 4465, 1, 0, 0, 0, 4468, 4469, 5, 1587, 0, 0, 4469, 4471, 5, 1673, 0, 0, 4470, 4468, 1, 0, 0, 0, 4470, 4471, 1, 0, 0, 0, 4471, 243, 1, 0, 0, 0, 4472, 4474, 5, 1562, 0, 0, 4473, 4475, 3, 1720, 860, 0, 4474, 4473, 1, 0, 0, 0, 4474, 4475, 1, 0, 0, 0, 4475, 4476, 1, 0, 0, 0, 4476, 4477, 5, 69, 0, 0, 4477, 4478, 5, 1238, 0, 0, 4478, 4479, 5, 2447, 0, 0, 4479, 4484, 3, 286, 143, 0, 4480, 4481, 5, 2453, 0, 0, 4481, 4483, 3, 286, 143, 0, 4482, 4480, 1, 0, 0, 0, 4483, 4486, 1, 0, 0, 0, 4484, 4482, 1, 0, 0, 0, 4484, 4485, 1, 0, 0, 0, 4485, 4487, 1, 0, 0, 0, 4486, 4484, 1, 0, 0, 0, 4487, 4488, 5, 2448, 0, 0, 4488, 245, 1, 0, 0, 0, 4489, 4494, 3, 248, 124, 0, 4490, 4491, 5, 2453, 0, 0, 4491, 4493, 3, 248, 124, 0, 4492, 4490, 1, 0, 0, 0, 4493, 4496, 1, 0, 0, 0, 4494, 4492, 1, 0, 0, 0, 4494, 4495, 1, 0, 0, 0, 4495, 247, 1, 0, 0, 0, 4496, 4494, 1, 0, 0, 0, 4497, 4500, 7, 9, 0, 0, 4498, 4501, 3, 308, 154, 0, 4499, 4501, 3, 294, 147, 0, 4500, 4498, 1, 0, 0, 0, 4500, 4499, 1, 0, 0, 0, 4501, 249, 1, 0, 0, 0, 4502, 4508, 5, 980, 0, 0, 4503, 4504, 5, 858, 0, 0, 4504, 4509, 3, 2078, 1039, 0, 4505, 4506, 5, 486, 0, 0, 4506, 4507, 5, 2166, 0, 0, 4507, 4509, 3, 2374, 1187, 0, 4508, 4503, 1, 0, 0, 0, 4508, 4505, 1, 0, 0, 0, 4509, 251, 1, 0, 0, 0, 4510, 4527, 5, 780, 0, 0, 4511, 4521, 5, 179, 0, 0, 4512, 4513, 5, 300, 0, 0, 4513, 4514, 5, 2141, 0, 0, 4514, 4522, 5, 1780, 0, 0, 4515, 4517, 5, 1204, 0, 0, 4516, 4515, 1, 0, 0, 0, 4516, 4517, 1, 0, 0, 0, 4517, 4518, 1, 0, 0, 0, 4518, 4519, 5, 705, 0, 0, 4519, 4520, 5, 2083, 0, 0, 4520, 4522, 5, 351, 0, 0, 4521, 4512, 1, 0, 0, 0, 4521, 4516, 1, 0, 0, 0, 4521, 4522, 1, 0, 0, 0, 4522, 4524, 1, 0, 0, 0, 4523, 4525, 3, 254, 127, 0, 4524, 4523, 1, 0, 0, 0, 4524, 4525, 1, 0, 0, 0, 4525, 4527, 1, 0, 0, 0, 4526, 4510, 1, 0, 0, 0, 4526, 4511, 1, 0, 0, 0, 4527, 253, 1, 0, 0, 0, 4528, 4530, 5, 616, 0, 0, 4529, 4528, 1, 0, 0, 0, 4529, 4530, 1, 0, 0, 0, 4530, 4531, 1, 0, 0, 0, 4531, 4532, 5, 537, 0, 0, 4532, 4533, 5, 779, 0, 0, 4533, 4534, 3, 2342, 1171, 0, 4534, 255, 1, 0, 0, 0, 4535, 4538, 5, 321, 0, 0, 4536, 4537, 5, 1307, 0, 0, 4537, 4539, 5, 1562, 0, 0, 4538, 4536, 1, 0, 0, 0, 4538, 4539, 1, 0, 0, 0, 4539, 4541, 1, 0, 0, 0, 4540, 4542, 7, 20, 0, 0, 4541, 4540, 1, 0, 0, 0, 4541, 4542, 1, 0, 0, 0, 4542, 4543, 1, 0, 0, 0, 4543, 4546, 5, 2166, 0, 0, 4544, 4547, 3, 258, 129, 0, 4545, 4547, 3, 270, 135, 0, 4546, 4544, 1, 0, 0, 0, 4546, 4545, 1, 0, 0, 0, 4547, 257, 1, 0, 0, 0, 4548, 4551, 3, 2314, 1157, 0, 4549, 4550, 5, 1248, 0, 0, 4550, 4552, 5, 2443, 0, 0, 4551, 4549, 1, 0, 0, 0, 4551, 4552, 1, 0, 0, 0, 4552, 4554, 1, 0, 0, 0, 4553, 4555, 5, 616, 0, 0, 4554, 4553, 1, 0, 0, 0, 4554, 4555, 1, 0, 0, 0, 4555, 4557, 1, 0, 0, 0, 4556, 4558, 3, 260, 130, 0, 4557, 4556, 1, 0, 0, 0, 4557, 4558, 1, 0, 0, 0, 4558, 259, 1, 0, 0, 0, 4559, 4561, 3, 1720, 860, 0, 4560, 4559, 1, 0, 0, 0, 4560, 4561, 1, 0, 0, 0, 4561, 4564, 1, 0, 0, 0, 4562, 4565, 3, 262, 131, 0, 4563, 4565, 3, 264, 132, 0, 4564, 4562, 1, 0, 0, 0, 4564, 4563, 1, 0, 0, 0, 4565, 4567, 1, 0, 0, 0, 4566, 4568, 3, 268, 134, 0, 4567, 4566, 1, 0, 0, 0, 4567, 4568, 1, 0, 0, 0, 4568, 4580, 1, 0, 0, 0, 4569, 4570, 5, 2447, 0, 0, 4570, 4575, 3, 286, 143, 0, 4571, 4572, 5, 2453, 0, 0, 4572, 4574, 3, 286, 143, 0, 4573, 4571, 1, 0, 0, 0, 4574, 4577, 1, 0, 0, 0, 4575, 4573, 1, 0, 0, 0, 4575, 4576, 1, 0, 0, 0, 4576, 4578, 1, 0, 0, 0, 4577, 4575, 1, 0, 0, 0, 4578, 4579, 5, 2448, 0, 0, 4579, 4581, 1, 0, 0, 0, 4580, 4569, 1, 0, 0, 0, 4580, 4581, 1, 0, 0, 0, 4581, 4585, 1, 0, 0, 0, 4582, 4584, 3, 284, 142, 0, 4583, 4582, 1, 0, 0, 0, 4584, 4587, 1, 0, 0, 0, 4585, 4583, 1, 0, 0, 0, 4585, 4586, 1, 0, 0, 0, 4586, 261, 1, 0, 0, 0, 4587, 4585, 1, 0, 0, 0, 4588, 4592, 7, 22, 0, 0, 4589, 4593, 5, 1238, 0, 0, 4590, 4593, 3, 1768, 884, 0, 4591, 4593, 3, 266, 133, 0, 4592, 4589, 1, 0, 0, 0, 4592, 4590, 1, 0, 0, 0, 4592, 4591, 1, 0, 0, 0, 4593, 263, 1, 0, 0, 0, 4594, 4595, 5, 2177, 0, 0, 4595, 4596, 3, 2374, 1187, 0, 4596, 265, 1, 0, 0, 0, 4597, 4598, 5, 2083, 0, 0, 4598, 4599, 5, 1246, 0, 0, 4599, 4602, 3, 2374, 1187, 0, 4600, 4601, 5, 1204, 0, 0, 4601, 4603, 5, 1228, 0, 0, 4602, 4600, 1, 0, 0, 0, 4602, 4603, 1, 0, 0, 0, 4603, 267, 1, 0, 0, 0, 4604, 4605, 5, 560, 0, 0, 4605, 4606, 5, 997, 0, 0, 4606, 4607, 3, 2078, 1039, 0, 4607, 4608, 5, 823, 0, 0, 4608, 4609, 5, 792, 0, 0, 4609, 4610, 5, 2246, 0, 0, 4610, 4611, 7, 41, 0, 0, 4611, 269, 1, 0, 0, 0, 4612, 4613, 5, 147, 0, 0, 4613, 4614, 3, 2314, 1157, 0, 4614, 4616, 7, 22, 0, 0, 4615, 4617, 3, 272, 136, 0, 4616, 4615, 1, 0, 0, 0, 4617, 4618, 1, 0, 0, 0, 4618, 4616, 1, 0, 0, 0, 4618, 4619, 1, 0, 0, 0, 4619, 4620, 1, 0, 0, 0, 4620, 4621, 5, 508, 0, 0, 4621, 271, 1, 0, 0, 0, 4622, 4626, 3, 274, 137, 0, 4623, 4626, 3, 276, 138, 0, 4624, 4626, 3, 296, 148, 0, 4625, 4622, 1, 0, 0, 0, 4625, 4623, 1, 0, 0, 0, 4625, 4624, 1, 0, 0, 0, 4626, 273, 1, 0, 0, 0, 4627, 4628, 7, 42, 0, 0, 4628, 4629, 5, 936, 0, 0, 4629, 4630, 3, 280, 140, 0, 4630, 275, 1, 0, 0, 0, 4631, 4633, 7, 43, 0, 0, 4632, 4631, 1, 0, 0, 0, 4632, 4633, 1, 0, 0, 0, 4633, 4637, 1, 0, 0, 0, 4634, 4638, 3, 278, 139, 0, 4635, 4638, 3, 280, 140, 0, 4636, 4638, 3, 282, 141, 0, 4637, 4634, 1, 0, 0, 0, 4637, 4635, 1, 0, 0, 0, 4637, 4636, 1, 0, 0, 0, 4638, 277, 1, 0, 0, 0, 4639, 4640, 5, 1461, 0, 0, 4640, 4652, 3, 2322, 1161, 0, 4641, 4642, 5, 2447, 0, 0, 4642, 4647, 3, 314, 157, 0, 4643, 4644, 5, 2453, 0, 0, 4644, 4646, 3, 314, 157, 0, 4645, 4643, 1, 0, 0, 0, 4646, 4649, 1, 0, 0, 0, 4647, 4645, 1, 0, 0, 0, 4647, 4648, 1, 0, 0, 0, 4648, 4650, 1, 0, 0, 0, 4649, 4647, 1, 0, 0, 0, 4650, 4651, 5, 2448, 0, 0, 4651, 4653, 1, 0, 0, 0, 4652, 4641, 1, 0, 0, 0, 4652, 4653, 1, 0, 0, 0, 4653, 4654, 1, 0, 0, 0, 4654, 4665, 7, 22, 0, 0, 4655, 4666, 3, 1722, 861, 0, 4656, 4658, 5, 382, 0, 0, 4657, 4656, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4660, 1, 0, 0, 0, 4659, 4661, 3, 1740, 870, 0, 4660, 4659, 1, 0, 0, 0, 4660, 4661, 1, 0, 0, 0, 4661, 4662, 1, 0, 0, 0, 4662, 4663, 3, 1820, 910, 0, 4663, 4664, 5, 2470, 0, 0, 4664, 4666, 1, 0, 0, 0, 4665, 4655, 1, 0, 0, 0, 4665, 4657, 1, 0, 0, 0, 4666, 279, 1, 0, 0, 0, 4667, 4668, 5, 632, 0, 0, 4668, 4680, 3, 2320, 1160, 0, 4669, 4670, 5, 2447, 0, 0, 4670, 4675, 3, 314, 157, 0, 4671, 4672, 5, 2453, 0, 0, 4672, 4674, 3, 314, 157, 0, 4673, 4671, 1, 0, 0, 0, 4674, 4677, 1, 0, 0, 0, 4675, 4673, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4678, 1, 0, 0, 0, 4677, 4675, 1, 0, 0, 0, 4678, 4679, 5, 2448, 0, 0, 4679, 4681, 1, 0, 0, 0, 4680, 4669, 1, 0, 0, 0, 4680, 4681, 1, 0, 0, 0, 4681, 4682, 1, 0, 0, 0, 4682, 4683, 5, 1586, 0, 0, 4683, 4684, 3, 2374, 1187, 0, 4684, 4695, 7, 22, 0, 0, 4685, 4696, 3, 1722, 861, 0, 4686, 4688, 5, 382, 0, 0, 4687, 4686, 1, 0, 0, 0, 4687, 4688, 1, 0, 0, 0, 4688, 4690, 1, 0, 0, 0, 4689, 4691, 3, 1740, 870, 0, 4690, 4689, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4692, 1, 0, 0, 0, 4692, 4693, 3, 1820, 910, 0, 4693, 4694, 5, 2470, 0, 0, 4694, 4696, 1, 0, 0, 0, 4695, 4685, 1, 0, 0, 0, 4695, 4687, 1, 0, 0, 0, 4696, 281, 1, 0, 0, 0, 4697, 4699, 5, 595, 0, 0, 4698, 4697, 1, 0, 0, 0, 4698, 4699, 1, 0, 0, 0, 4699, 4701, 1, 0, 0, 0, 4700, 4702, 5, 761, 0, 0, 4701, 4700, 1, 0, 0, 0, 4701, 4702, 1, 0, 0, 0, 4702, 4703, 1, 0, 0, 0, 4703, 4704, 5, 288, 0, 0, 4704, 4705, 5, 632, 0, 0, 4705, 4726, 3, 2320, 1160, 0, 4706, 4713, 5, 2447, 0, 0, 4707, 4708, 5, 1648, 0, 0, 4708, 4709, 5, 738, 0, 0, 4709, 4710, 5, 1318, 0, 0, 4710, 4711, 3, 2374, 1187, 0, 4711, 4712, 5, 2453, 0, 0, 4712, 4714, 1, 0, 0, 0, 4713, 4707, 1, 0, 0, 0, 4713, 4714, 1, 0, 0, 0, 4714, 4723, 1, 0, 0, 0, 4715, 4720, 3, 314, 157, 0, 4716, 4717, 5, 2453, 0, 0, 4717, 4719, 3, 314, 157, 0, 4718, 4716, 1, 0, 0, 0, 4719, 4722, 1, 0, 0, 0, 4720, 4718, 1, 0, 0, 0, 4720, 4721, 1, 0, 0, 0, 4721, 4724, 1, 0, 0, 0, 4722, 4720, 1, 0, 0, 0, 4723, 4715, 1, 0, 0, 0, 4723, 4724, 1, 0, 0, 0, 4724, 4725, 1, 0, 0, 0, 4725, 4727, 5, 2448, 0, 0, 4726, 4706, 1, 0, 0, 0, 4726, 4727, 1, 0, 0, 0, 4727, 4728, 1, 0, 0, 0, 4728, 4729, 5, 1586, 0, 0, 4729, 4730, 5, 1648, 0, 0, 4730, 4731, 5, 69, 0, 0, 4731, 4732, 5, 1580, 0, 0, 4732, 4743, 7, 22, 0, 0, 4733, 4744, 3, 1722, 861, 0, 4734, 4736, 5, 382, 0, 0, 4735, 4734, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4738, 1, 0, 0, 0, 4737, 4739, 3, 1740, 870, 0, 4738, 4737, 1, 0, 0, 0, 4738, 4739, 1, 0, 0, 0, 4739, 4740, 1, 0, 0, 0, 4740, 4741, 3, 1820, 910, 0, 4741, 4742, 5, 2470, 0, 0, 4742, 4744, 1, 0, 0, 0, 4743, 4733, 1, 0, 0, 0, 4743, 4735, 1, 0, 0, 0, 4744, 283, 1, 0, 0, 0, 4745, 4747, 5, 1204, 0, 0, 4746, 4745, 1, 0, 0, 0, 4746, 4747, 1, 0, 0, 0, 4747, 4748, 1, 0, 0, 0, 4748, 4749, 7, 44, 0, 0, 4749, 285, 1, 0, 0, 0, 4750, 4751, 3, 2402, 1201, 0, 4751, 4753, 3, 2374, 1187, 0, 4752, 4754, 3, 288, 144, 0, 4753, 4752, 1, 0, 0, 0, 4753, 4754, 1, 0, 0, 0, 4754, 4757, 1, 0, 0, 0, 4755, 4757, 3, 290, 145, 0, 4756, 4750, 1, 0, 0, 0, 4756, 4755, 1, 0, 0, 0, 4757, 287, 1, 0, 0, 0, 4758, 4759, 5, 560, 0, 0, 4759, 4760, 5, 997, 0, 0, 4760, 4761, 3, 2078, 1039, 0, 4761, 289, 1, 0, 0, 0, 4762, 4764, 3, 284, 142, 0, 4763, 4762, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4766, 1, 0, 0, 0, 4765, 4767, 3, 292, 146, 0, 4766, 4765, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4766, 1, 0, 0, 0, 4768, 4769, 1, 0, 0, 0, 4769, 4772, 1, 0, 0, 0, 4770, 4771, 5, 2453, 0, 0, 4771, 4773, 3, 310, 155, 0, 4772, 4770, 1, 0, 0, 0, 4772, 4773, 1, 0, 0, 0, 4773, 291, 1, 0, 0, 0, 4774, 4778, 3, 294, 147, 0, 4775, 4778, 3, 306, 153, 0, 4776, 4778, 3, 308, 154, 0, 4777, 4774, 1, 0, 0, 0, 4777, 4775, 1, 0, 0, 0, 4777, 4776, 1, 0, 0, 0, 4778, 293, 1, 0, 0, 0, 4779, 4782, 7, 43, 0, 0, 4780, 4783, 3, 302, 151, 0, 4781, 4783, 3, 304, 152, 0, 4782, 4780, 1, 0, 0, 0, 4782, 4781, 1, 0, 0, 0, 4783, 295, 1, 0, 0, 0, 4784, 4785, 5, 1324, 0, 0, 4785, 4786, 5, 936, 0, 0, 4786, 4791, 3, 298, 149, 0, 4787, 4788, 5, 1324, 0, 0, 4788, 4789, 5, 936, 0, 0, 4789, 4791, 3, 300, 150, 0, 4790, 4784, 1, 0, 0, 0, 4790, 4787, 1, 0, 0, 0, 4791, 297, 1, 0, 0, 0, 4792, 4793, 5, 632, 0, 0, 4793, 4805, 3, 2320, 1160, 0, 4794, 4795, 5, 2447, 0, 0, 4795, 4800, 3, 314, 157, 0, 4796, 4797, 5, 2453, 0, 0, 4797, 4799, 3, 314, 157, 0, 4798, 4796, 1, 0, 0, 0, 4799, 4802, 1, 0, 0, 0, 4800, 4798, 1, 0, 0, 0, 4800, 4801, 1, 0, 0, 0, 4801, 4803, 1, 0, 0, 0, 4802, 4800, 1, 0, 0, 0, 4803, 4804, 5, 2448, 0, 0, 4804, 4806, 1, 0, 0, 0, 4805, 4794, 1, 0, 0, 0, 4805, 4806, 1, 0, 0, 0, 4806, 4807, 1, 0, 0, 0, 4807, 4812, 5, 1586, 0, 0, 4808, 4813, 3, 2374, 1187, 0, 4809, 4810, 5, 1648, 0, 0, 4810, 4811, 5, 69, 0, 0, 4811, 4813, 5, 1580, 0, 0, 4812, 4808, 1, 0, 0, 0, 4812, 4809, 1, 0, 0, 0, 4813, 4825, 1, 0, 0, 0, 4814, 4816, 5, 1394, 0, 0, 4815, 4814, 1, 0, 0, 0, 4815, 4816, 1, 0, 0, 0, 4816, 4817, 1, 0, 0, 0, 4817, 4819, 7, 22, 0, 0, 4818, 4820, 5, 382, 0, 0, 4819, 4818, 1, 0, 0, 0, 4819, 4820, 1, 0, 0, 0, 4820, 4822, 1, 0, 0, 0, 4821, 4823, 3, 1740, 870, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 3, 1820, 910, 0, 4825, 4815, 1, 0, 0, 0, 4825, 4826, 1, 0, 0, 0, 4826, 4828, 1, 0, 0, 0, 4827, 4829, 5, 2470, 0, 0, 4828, 4827, 1, 0, 0, 0, 4828, 4829, 1, 0, 0, 0, 4829, 299, 1, 0, 0, 0, 4830, 4831, 5, 1461, 0, 0, 4831, 4843, 3, 2322, 1161, 0, 4832, 4833, 5, 2447, 0, 0, 4833, 4838, 3, 314, 157, 0, 4834, 4835, 5, 2453, 0, 0, 4835, 4837, 3, 314, 157, 0, 4836, 4834, 1, 0, 0, 0, 4837, 4840, 1, 0, 0, 0, 4838, 4836, 1, 0, 0, 0, 4838, 4839, 1, 0, 0, 0, 4839, 4841, 1, 0, 0, 0, 4840, 4838, 1, 0, 0, 0, 4841, 4842, 5, 2448, 0, 0, 4842, 4844, 1, 0, 0, 0, 4843, 4832, 1, 0, 0, 0, 4843, 4844, 1, 0, 0, 0, 4844, 4845, 1, 0, 0, 0, 4845, 4856, 7, 22, 0, 0, 4846, 4857, 3, 1722, 861, 0, 4847, 4849, 5, 382, 0, 0, 4848, 4847, 1, 0, 0, 0, 4848, 4849, 1, 0, 0, 0, 4849, 4851, 1, 0, 0, 0, 4850, 4852, 3, 1740, 870, 0, 4851, 4850, 1, 0, 0, 0, 4851, 4852, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4854, 3, 1820, 910, 0, 4854, 4855, 5, 2470, 0, 0, 4855, 4857, 1, 0, 0, 0, 4856, 4846, 1, 0, 0, 0, 4856, 4848, 1, 0, 0, 0, 4857, 301, 1, 0, 0, 0, 4858, 4859, 5, 1461, 0, 0, 4859, 4871, 3, 2322, 1161, 0, 4860, 4861, 5, 2447, 0, 0, 4861, 4866, 3, 314, 157, 0, 4862, 4863, 5, 2453, 0, 0, 4863, 4865, 3, 314, 157, 0, 4864, 4862, 1, 0, 0, 0, 4865, 4868, 1, 0, 0, 0, 4866, 4864, 1, 0, 0, 0, 4866, 4867, 1, 0, 0, 0, 4867, 4869, 1, 0, 0, 0, 4868, 4866, 1, 0, 0, 0, 4869, 4870, 5, 2448, 0, 0, 4870, 4872, 1, 0, 0, 0, 4871, 4860, 1, 0, 0, 0, 4871, 4872, 1, 0, 0, 0, 4872, 4875, 1, 0, 0, 0, 4873, 4874, 7, 22, 0, 0, 4874, 4876, 3, 1722, 861, 0, 4875, 4873, 1, 0, 0, 0, 4875, 4876, 1, 0, 0, 0, 4876, 303, 1, 0, 0, 0, 4877, 4878, 5, 632, 0, 0, 4878, 4890, 3, 2320, 1160, 0, 4879, 4880, 5, 2447, 0, 0, 4880, 4885, 3, 314, 157, 0, 4881, 4882, 5, 2453, 0, 0, 4882, 4884, 3, 314, 157, 0, 4883, 4881, 1, 0, 0, 0, 4884, 4887, 1, 0, 0, 0, 4885, 4883, 1, 0, 0, 0, 4885, 4886, 1, 0, 0, 0, 4886, 4888, 1, 0, 0, 0, 4887, 4885, 1, 0, 0, 0, 4888, 4889, 5, 2448, 0, 0, 4889, 4891, 1, 0, 0, 0, 4890, 4879, 1, 0, 0, 0, 4890, 4891, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4897, 5, 1586, 0, 0, 4893, 4898, 3, 2374, 1187, 0, 4894, 4895, 5, 1648, 0, 0, 4895, 4896, 5, 69, 0, 0, 4896, 4898, 5, 1580, 0, 0, 4897, 4893, 1, 0, 0, 0, 4897, 4894, 1, 0, 0, 0, 4898, 4907, 1, 0, 0, 0, 4899, 4900, 7, 22, 0, 0, 4900, 4908, 3, 1722, 861, 0, 4901, 4903, 5, 560, 0, 0, 4902, 4904, 5, 2262, 0, 0, 4903, 4902, 1, 0, 0, 0, 4903, 4904, 1, 0, 0, 0, 4904, 4905, 1, 0, 0, 0, 4905, 4906, 5, 997, 0, 0, 4906, 4908, 3, 2078, 1039, 0, 4907, 4899, 1, 0, 0, 0, 4907, 4901, 1, 0, 0, 0, 4907, 4908, 1, 0, 0, 0, 4908, 305, 1, 0, 0, 0, 4909, 4911, 5, 595, 0, 0, 4910, 4909, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4913, 1, 0, 0, 0, 4912, 4914, 5, 761, 0, 0, 4913, 4912, 1, 0, 0, 0, 4913, 4914, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4916, 5, 288, 0, 0, 4916, 4917, 5, 632, 0, 0, 4917, 4938, 3, 2374, 1187, 0, 4918, 4925, 5, 2447, 0, 0, 4919, 4920, 5, 1648, 0, 0, 4920, 4921, 5, 738, 0, 0, 4921, 4922, 5, 1318, 0, 0, 4922, 4923, 3, 2374, 1187, 0, 4923, 4924, 5, 2453, 0, 0, 4924, 4926, 1, 0, 0, 0, 4925, 4919, 1, 0, 0, 0, 4925, 4926, 1, 0, 0, 0, 4926, 4935, 1, 0, 0, 0, 4927, 4932, 3, 314, 157, 0, 4928, 4929, 5, 2453, 0, 0, 4929, 4931, 3, 314, 157, 0, 4930, 4928, 1, 0, 0, 0, 4931, 4934, 1, 0, 0, 0, 4932, 4930, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 4936, 1, 0, 0, 0, 4934, 4932, 1, 0, 0, 0, 4935, 4927, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, 4937, 1, 0, 0, 0, 4937, 4939, 5, 2448, 0, 0, 4938, 4918, 1, 0, 0, 0, 4938, 4939, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4941, 5, 1586, 0, 0, 4941, 4942, 5, 1648, 0, 0, 4942, 4943, 5, 69, 0, 0, 4943, 4946, 5, 1580, 0, 0, 4944, 4945, 7, 22, 0, 0, 4945, 4947, 3, 1722, 861, 0, 4946, 4944, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 307, 1, 0, 0, 0, 4948, 4949, 7, 42, 0, 0, 4949, 4950, 5, 936, 0, 0, 4950, 4951, 3, 304, 152, 0, 4951, 309, 1, 0, 0, 0, 4952, 4953, 5, 1433, 0, 0, 4953, 4954, 5, 1577, 0, 0, 4954, 4955, 5, 2447, 0, 0, 4955, 4960, 3, 312, 156, 0, 4956, 4957, 5, 2453, 0, 0, 4957, 4959, 3, 312, 156, 0, 4958, 4956, 1, 0, 0, 0, 4959, 4962, 1, 0, 0, 0, 4960, 4958, 1, 0, 0, 0, 4960, 4961, 1, 0, 0, 0, 4961, 4963, 1, 0, 0, 0, 4962, 4960, 1, 0, 0, 0, 4963, 4964, 5, 2448, 0, 0, 4964, 311, 1, 0, 0, 0, 4965, 4968, 3, 2402, 1201, 0, 4966, 4968, 5, 389, 0, 0, 4967, 4965, 1, 0, 0, 0, 4967, 4966, 1, 0, 0, 0, 4968, 313, 1, 0, 0, 0, 4969, 4979, 3, 2294, 1147, 0, 4970, 4971, 5, 738, 0, 0, 4971, 4972, 5, 1318, 0, 0, 4972, 4980, 5, 1080, 0, 0, 4973, 4974, 5, 738, 0, 0, 4974, 4980, 5, 1318, 0, 0, 4975, 4976, 5, 1318, 0, 0, 4976, 4980, 5, 1080, 0, 0, 4977, 4980, 5, 1318, 0, 0, 4978, 4980, 5, 738, 0, 0, 4979, 4970, 1, 0, 0, 0, 4979, 4973, 1, 0, 0, 0, 4979, 4975, 1, 0, 0, 0, 4979, 4977, 1, 0, 0, 0, 4979, 4978, 1, 0, 0, 0, 4979, 4980, 1, 0, 0, 0, 4980, 4981, 1, 0, 0, 0, 4981, 4984, 3, 2374, 1187, 0, 4982, 4983, 5, 2457, 0, 0, 4983, 4985, 3, 2394, 1197, 0, 4984, 4982, 1, 0, 0, 0, 4984, 4985, 1, 0, 0, 0, 4985, 315, 1, 0, 0, 0, 4986, 4987, 5, 469, 0, 0, 4987, 4988, 5, 1653, 0, 0, 4988, 4989, 3, 2316, 1158, 0, 4989, 317, 1, 0, 0, 0, 4990, 4991, 5, 42, 0, 0, 4991, 4992, 5, 1653, 0, 0, 4992, 4994, 3, 2316, 1158, 0, 4993, 4995, 3, 326, 163, 0, 4994, 4993, 1, 0, 0, 0, 4995, 4996, 1, 0, 0, 0, 4996, 4994, 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, 319, 1, 0, 0, 0, 4998, 4999, 5, 42, 0, 0, 4999, 5029, 5, 1667, 0, 0, 5000, 5001, 5, 30, 0, 0, 5001, 5030, 7, 45, 0, 0, 5002, 5003, 5, 218, 0, 0, 5003, 5004, 5, 350, 0, 0, 5004, 5005, 5, 861, 0, 0, 5005, 5030, 3, 2294, 1147, 0, 5006, 5007, 3, 1308, 654, 0, 5007, 5008, 5, 242, 0, 0, 5008, 5009, 5, 738, 0, 0, 5009, 5010, 5, 1461, 0, 0, 5010, 5030, 1, 0, 0, 0, 5011, 5012, 3, 1308, 654, 0, 5012, 5013, 5, 656, 0, 0, 5013, 5030, 1, 0, 0, 0, 5014, 5017, 3, 1308, 654, 0, 5015, 5017, 5, 616, 0, 0, 5016, 5014, 1, 0, 0, 0, 5016, 5015, 1, 0, 0, 0, 5017, 5018, 1, 0, 0, 0, 5018, 5019, 5, 1333, 0, 0, 5019, 5025, 7, 46, 0, 0, 5020, 5023, 5, 1333, 0, 0, 5021, 5024, 3, 2186, 1093, 0, 5022, 5024, 3, 2294, 1147, 0, 5023, 5021, 1, 0, 0, 0, 5023, 5022, 1, 0, 0, 0, 5024, 5026, 1, 0, 0, 0, 5025, 5020, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5030, 1, 0, 0, 0, 5027, 5028, 5, 1671, 0, 0, 5028, 5030, 3, 322, 161, 0, 5029, 5000, 1, 0, 0, 0, 5029, 5002, 1, 0, 0, 0, 5029, 5006, 1, 0, 0, 0, 5029, 5011, 1, 0, 0, 0, 5029, 5016, 1, 0, 0, 0, 5029, 5027, 1, 0, 0, 0, 5030, 321, 1, 0, 0, 0, 5031, 5032, 3, 2294, 1147, 0, 5032, 5033, 5, 2472, 0, 0, 5033, 5034, 3, 814, 407, 0, 5034, 5036, 1, 0, 0, 0, 5035, 5031, 1, 0, 0, 0, 5036, 5037, 1, 0, 0, 0, 5037, 5035, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, 5062, 1, 0, 0, 0, 5039, 5040, 5, 483, 0, 0, 5040, 5041, 5, 2472, 0, 0, 5041, 5062, 3, 2404, 1202, 0, 5042, 5043, 5, 289, 0, 0, 5043, 5044, 5, 2472, 0, 0, 5044, 5048, 3, 2404, 1202, 0, 5045, 5046, 5, 1664, 0, 0, 5046, 5047, 5, 2472, 0, 0, 5047, 5049, 3, 2404, 1202, 0, 5048, 5045, 1, 0, 0, 0, 5048, 5049, 1, 0, 0, 0, 5049, 5062, 1, 0, 0, 0, 5050, 5051, 5, 1606, 0, 0, 5051, 5052, 5, 63, 0, 0, 5052, 5053, 5, 2289, 0, 0, 5053, 5054, 5, 2472, 0, 0, 5054, 5062, 7, 47, 0, 0, 5055, 5056, 5, 392, 0, 0, 5056, 5059, 5, 2472, 0, 0, 5057, 5060, 3, 2404, 1202, 0, 5058, 5060, 5, 1133, 0, 0, 5059, 5057, 1, 0, 0, 0, 5059, 5058, 1, 0, 0, 0, 5060, 5062, 1, 0, 0, 0, 5061, 5035, 1, 0, 0, 0, 5061, 5039, 1, 0, 0, 0, 5061, 5042, 1, 0, 0, 0, 5061, 5050, 1, 0, 0, 0, 5061, 5055, 1, 0, 0, 0, 5062, 323, 1, 0, 0, 0, 5063, 5064, 5, 321, 0, 0, 5064, 5068, 5, 1653, 0, 0, 5065, 5066, 5, 691, 0, 0, 5066, 5067, 5, 1204, 0, 0, 5067, 5069, 5, 545, 0, 0, 5068, 5065, 1, 0, 0, 0, 5068, 5069, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5074, 3, 2316, 1158, 0, 5071, 5073, 3, 326, 163, 0, 5072, 5071, 1, 0, 0, 0, 5073, 5076, 1, 0, 0, 0, 5074, 5072, 1, 0, 0, 0, 5074, 5075, 1, 0, 0, 0, 5075, 5080, 1, 0, 0, 0, 5076, 5074, 1, 0, 0, 0, 5077, 5078, 5, 1681, 0, 0, 5078, 5079, 5, 2472, 0, 0, 5079, 5081, 7, 48, 0, 0, 5080, 5077, 1, 0, 0, 0, 5080, 5081, 1, 0, 0, 0, 5081, 325, 1, 0, 0, 0, 5082, 5083, 5, 707, 0, 0, 5083, 5084, 5, 160, 0, 0, 5084, 5114, 5, 2441, 0, 0, 5085, 5114, 3, 328, 164, 0, 5086, 5087, 5, 932, 0, 0, 5087, 5114, 5, 2441, 0, 0, 5088, 5114, 5, 1121, 0, 0, 5089, 5090, 5, 960, 0, 0, 5090, 5114, 5, 2441, 0, 0, 5091, 5114, 5, 1124, 0, 0, 5092, 5114, 5, 348, 0, 0, 5093, 5114, 5, 1084, 0, 0, 5094, 5095, 5, 166, 0, 0, 5095, 5114, 5, 2441, 0, 0, 5096, 5114, 5, 1066, 0, 0, 5097, 5114, 5, 1303, 0, 0, 5098, 5114, 5, 1140, 0, 0, 5099, 5114, 5, 814, 0, 0, 5100, 5114, 5, 1114, 0, 0, 5101, 5103, 5, 1620, 0, 0, 5102, 5104, 7, 49, 0, 0, 5103, 5102, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5114, 1, 0, 0, 0, 5105, 5114, 5, 1181, 0, 0, 5106, 5108, 5, 1676, 0, 0, 5107, 5109, 7, 49, 0, 0, 5108, 5107, 1, 0, 0, 0, 5108, 5109, 1, 0, 0, 0, 5109, 5114, 1, 0, 0, 0, 5110, 5114, 5, 1187, 0, 0, 5111, 5114, 5, 1667, 0, 0, 5112, 5114, 5, 642, 0, 0, 5113, 5082, 1, 0, 0, 0, 5113, 5085, 1, 0, 0, 0, 5113, 5086, 1, 0, 0, 0, 5113, 5088, 1, 0, 0, 0, 5113, 5089, 1, 0, 0, 0, 5113, 5091, 1, 0, 0, 0, 5113, 5092, 1, 0, 0, 0, 5113, 5093, 1, 0, 0, 0, 5113, 5094, 1, 0, 0, 0, 5113, 5096, 1, 0, 0, 0, 5113, 5097, 1, 0, 0, 0, 5113, 5098, 1, 0, 0, 0, 5113, 5099, 1, 0, 0, 0, 5113, 5100, 1, 0, 0, 0, 5113, 5101, 1, 0, 0, 0, 5113, 5105, 1, 0, 0, 0, 5113, 5106, 1, 0, 0, 0, 5113, 5110, 1, 0, 0, 0, 5113, 5111, 1, 0, 0, 0, 5113, 5112, 1, 0, 0, 0, 5114, 327, 1, 0, 0, 0, 5115, 5116, 5, 1737, 0, 0, 5116, 5117, 5, 2308, 0, 0, 5117, 5118, 7, 50, 0, 0, 5118, 329, 1, 0, 0, 0, 5119, 5122, 5, 321, 0, 0, 5120, 5121, 5, 1307, 0, 0, 5121, 5123, 5, 1562, 0, 0, 5122, 5120, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, 0, 5123, 5125, 1, 0, 0, 0, 5124, 5126, 7, 7, 0, 0, 5125, 5124, 1, 0, 0, 0, 5125, 5126, 1, 0, 0, 0, 5126, 5127, 1, 0, 0, 0, 5127, 5128, 5, 45, 0, 0, 5128, 5129, 5, 2286, 0, 0, 5129, 5133, 3, 2404, 1202, 0, 5130, 5131, 5, 1681, 0, 0, 5131, 5132, 5, 2472, 0, 0, 5132, 5134, 7, 21, 0, 0, 5133, 5130, 1, 0, 0, 0, 5133, 5134, 1, 0, 0, 0, 5134, 5138, 1, 0, 0, 0, 5135, 5137, 3, 332, 166, 0, 5136, 5135, 1, 0, 0, 0, 5137, 5140, 1, 0, 0, 0, 5138, 5136, 1, 0, 0, 0, 5138, 5139, 1, 0, 0, 0, 5139, 5142, 1, 0, 0, 0, 5140, 5138, 1, 0, 0, 0, 5141, 5143, 3, 342, 171, 0, 5142, 5141, 1, 0, 0, 0, 5142, 5143, 1, 0, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5146, 3, 344, 172, 0, 5145, 5144, 1, 0, 0, 0, 5145, 5146, 1, 0, 0, 0, 5146, 5148, 1, 0, 0, 0, 5147, 5149, 3, 352, 176, 0, 5148, 5147, 1, 0, 0, 0, 5148, 5149, 1, 0, 0, 0, 5149, 5151, 1, 0, 0, 0, 5150, 5152, 3, 362, 181, 0, 5151, 5150, 1, 0, 0, 0, 5151, 5152, 1, 0, 0, 0, 5152, 5154, 1, 0, 0, 0, 5153, 5155, 3, 364, 182, 0, 5154, 5153, 1, 0, 0, 0, 5154, 5155, 1, 0, 0, 0, 5155, 5157, 1, 0, 0, 0, 5156, 5158, 3, 366, 183, 0, 5157, 5156, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, 0, 5158, 5160, 1, 0, 0, 0, 5159, 5161, 3, 376, 188, 0, 5160, 5159, 1, 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161, 5163, 1, 0, 0, 0, 5162, 5164, 3, 378, 189, 0, 5163, 5162, 1, 0, 0, 0, 5163, 5164, 1, 0, 0, 0, 5164, 331, 1, 0, 0, 0, 5165, 5167, 3, 334, 167, 0, 5166, 5168, 3, 336, 168, 0, 5167, 5166, 1, 0, 0, 0, 5167, 5168, 1, 0, 0, 0, 5168, 5174, 1, 0, 0, 0, 5169, 5171, 3, 334, 167, 0, 5170, 5169, 1, 0, 0, 0, 5170, 5171, 1, 0, 0, 0, 5171, 5172, 1, 0, 0, 0, 5172, 5174, 3, 336, 168, 0, 5173, 5165, 1, 0, 0, 0, 5173, 5170, 1, 0, 0, 0, 5174, 5178, 1, 0, 0, 0, 5175, 5177, 3, 338, 169, 0, 5176, 5175, 1, 0, 0, 0, 5177, 5180, 1, 0, 0, 0, 5178, 5176, 1, 0, 0, 0, 5178, 5179, 1, 0, 0, 0, 5179, 5193, 1, 0, 0, 0, 5180, 5178, 1, 0, 0, 0, 5181, 5183, 3, 334, 167, 0, 5182, 5181, 1, 0, 0, 0, 5182, 5183, 1, 0, 0, 0, 5183, 5185, 1, 0, 0, 0, 5184, 5186, 3, 336, 168, 0, 5185, 5184, 1, 0, 0, 0, 5185, 5186, 1, 0, 0, 0, 5186, 5188, 1, 0, 0, 0, 5187, 5189, 3, 338, 169, 0, 5188, 5187, 1, 0, 0, 0, 5189, 5190, 1, 0, 0, 0, 5190, 5188, 1, 0, 0, 0, 5190, 5191, 1, 0, 0, 0, 5191, 5193, 1, 0, 0, 0, 5192, 5173, 1, 0, 0, 0, 5192, 5182, 1, 0, 0, 0, 5193, 333, 1, 0, 0, 0, 5194, 5195, 5, 177, 0, 0, 5195, 5196, 3, 2400, 1200, 0, 5196, 335, 1, 0, 0, 0, 5197, 5198, 5, 415, 0, 0, 5198, 5199, 3, 2400, 1200, 0, 5199, 337, 1, 0, 0, 0, 5200, 5201, 5, 207, 0, 0, 5201, 5204, 3, 2404, 1202, 0, 5202, 5203, 5, 2258, 0, 0, 5203, 5205, 3, 2400, 1200, 0, 5204, 5202, 1, 0, 0, 0, 5204, 5205, 1, 0, 0, 0, 5205, 5208, 1, 0, 0, 0, 5206, 5207, 5, 823, 0, 0, 5207, 5209, 3, 340, 170, 0, 5208, 5206, 1, 0, 0, 0, 5208, 5209, 1, 0, 0, 0, 5209, 339, 1, 0, 0, 0, 5210, 5213, 5, 1228, 0, 0, 5211, 5213, 3, 2404, 1202, 0, 5212, 5210, 1, 0, 0, 0, 5212, 5211, 1, 0, 0, 0, 5213, 341, 1, 0, 0, 0, 5214, 5218, 5, 2246, 0, 0, 5215, 5216, 3, 2286, 1143, 0, 5216, 5217, 5, 2440, 0, 0, 5217, 5219, 1, 0, 0, 0, 5218, 5215, 1, 0, 0, 0, 5218, 5219, 1, 0, 0, 0, 5219, 5220, 1, 0, 0, 0, 5220, 5222, 3, 2404, 1202, 0, 5221, 5223, 5, 1556, 0, 0, 5222, 5221, 1, 0, 0, 0, 5222, 5223, 1, 0, 0, 0, 5223, 5228, 1, 0, 0, 0, 5224, 5226, 5, 69, 0, 0, 5225, 5224, 1, 0, 0, 0, 5225, 5226, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, 5227, 5229, 3, 2404, 1202, 0, 5228, 5225, 1, 0, 0, 0, 5228, 5229, 1, 0, 0, 0, 5229, 343, 1, 0, 0, 0, 5230, 5231, 5, 422, 0, 0, 5231, 5232, 5, 160, 0, 0, 5232, 5233, 5, 2447, 0, 0, 5233, 5238, 3, 346, 173, 0, 5234, 5235, 5, 2453, 0, 0, 5235, 5237, 3, 346, 173, 0, 5236, 5234, 1, 0, 0, 0, 5237, 5240, 1, 0, 0, 0, 5238, 5236, 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, 5239, 5241, 1, 0, 0, 0, 5240, 5238, 1, 0, 0, 0, 5241, 5242, 5, 2448, 0, 0, 5242, 345, 1, 0, 0, 0, 5243, 5247, 3, 348, 174, 0, 5244, 5246, 3, 332, 166, 0, 5245, 5244, 1, 0, 0, 0, 5246, 5249, 1, 0, 0, 0, 5247, 5245, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, 5250, 1, 0, 0, 0, 5249, 5247, 1, 0, 0, 0, 5250, 5278, 5, 816, 0, 0, 5251, 5255, 5, 2447, 0, 0, 5252, 5253, 3, 2404, 1202, 0, 5253, 5254, 5, 2440, 0, 0, 5254, 5256, 1, 0, 0, 0, 5255, 5252, 1, 0, 0, 0, 5255, 5256, 1, 0, 0, 0, 5256, 5257, 1, 0, 0, 0, 5257, 5267, 3, 2340, 1170, 0, 5258, 5262, 5, 2453, 0, 0, 5259, 5260, 3, 2404, 1202, 0, 5260, 5261, 5, 2440, 0, 0, 5261, 5263, 1, 0, 0, 0, 5262, 5259, 1, 0, 0, 0, 5262, 5263, 1, 0, 0, 0, 5263, 5264, 1, 0, 0, 0, 5264, 5266, 3, 2340, 1170, 0, 5265, 5258, 1, 0, 0, 0, 5266, 5269, 1, 0, 0, 0, 5267, 5265, 1, 0, 0, 0, 5267, 5268, 1, 0, 0, 0, 5268, 5270, 1, 0, 0, 0, 5269, 5267, 1, 0, 0, 0, 5270, 5271, 5, 2448, 0, 0, 5271, 5279, 1, 0, 0, 0, 5272, 5273, 3, 2404, 1202, 0, 5273, 5274, 5, 2440, 0, 0, 5274, 5276, 1, 0, 0, 0, 5275, 5272, 1, 0, 0, 0, 5275, 5276, 1, 0, 0, 0, 5276, 5277, 1, 0, 0, 0, 5277, 5279, 3, 2340, 1170, 0, 5278, 5251, 1, 0, 0, 0, 5278, 5275, 1, 0, 0, 0, 5279, 5280, 1, 0, 0, 0, 5280, 5282, 5, 1528, 0, 0, 5281, 5283, 5, 445, 0, 0, 5282, 5281, 1, 0, 0, 0, 5282, 5283, 1, 0, 0, 0, 5283, 5292, 1, 0, 0, 0, 5284, 5285, 5, 2447, 0, 0, 5285, 5286, 3, 2280, 1140, 0, 5286, 5287, 5, 2453, 0, 0, 5287, 5288, 3, 2280, 1140, 0, 5288, 5289, 1, 0, 0, 0, 5289, 5290, 5, 2448, 0, 0, 5290, 5293, 1, 0, 0, 0, 5291, 5293, 3, 2280, 1140, 0, 5292, 5284, 1, 0, 0, 0, 5292, 5291, 1, 0, 0, 0, 5293, 5294, 1, 0, 0, 0, 5294, 5295, 5, 673, 0, 0, 5295, 5296, 5, 2447, 0, 0, 5296, 5301, 3, 350, 175, 0, 5297, 5298, 5, 2453, 0, 0, 5298, 5300, 3, 350, 175, 0, 5299, 5297, 1, 0, 0, 0, 5300, 5303, 1, 0, 0, 0, 5301, 5299, 1, 0, 0, 0, 5301, 5302, 1, 0, 0, 0, 5302, 5304, 1, 0, 0, 0, 5303, 5301, 1, 0, 0, 0, 5304, 5305, 5, 2448, 0, 0, 5305, 347, 1, 0, 0, 0, 5306, 5307, 3, 2286, 1143, 0, 5307, 5308, 5, 2440, 0, 0, 5308, 5310, 1, 0, 0, 0, 5309, 5306, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 5311, 1, 0, 0, 0, 5311, 5316, 3, 2404, 1202, 0, 5312, 5314, 5, 69, 0, 0, 5313, 5312, 1, 0, 0, 0, 5313, 5314, 1, 0, 0, 0, 5314, 5315, 1, 0, 0, 0, 5315, 5317, 3, 2404, 1202, 0, 5316, 5313, 1, 0, 0, 0, 5316, 5317, 1, 0, 0, 0, 5317, 349, 1, 0, 0, 0, 5318, 5319, 3, 2286, 1143, 0, 5319, 5320, 5, 2440, 0, 0, 5320, 5322, 1, 0, 0, 0, 5321, 5318, 1, 0, 0, 0, 5321, 5322, 1, 0, 0, 0, 5322, 5323, 1, 0, 0, 0, 5323, 5328, 3, 2404, 1202, 0, 5324, 5326, 5, 69, 0, 0, 5325, 5324, 1, 0, 0, 0, 5325, 5326, 1, 0, 0, 0, 5326, 5327, 1, 0, 0, 0, 5327, 5329, 3, 2404, 1202, 0, 5328, 5325, 1, 0, 0, 0, 5328, 5329, 1, 0, 0, 0, 5329, 5331, 1, 0, 0, 0, 5330, 5332, 5, 389, 0, 0, 5331, 5330, 1, 0, 0, 0, 5331, 5332, 1, 0, 0, 0, 5332, 351, 1, 0, 0, 0, 5333, 5334, 5, 934, 0, 0, 5334, 5335, 5, 2447, 0, 0, 5335, 5340, 3, 354, 177, 0, 5336, 5337, 5, 2453, 0, 0, 5337, 5339, 3, 354, 177, 0, 5338, 5336, 1, 0, 0, 0, 5339, 5342, 1, 0, 0, 0, 5340, 5338, 1, 0, 0, 0, 5340, 5341, 1, 0, 0, 0, 5341, 5343, 1, 0, 0, 0, 5342, 5340, 1, 0, 0, 0, 5343, 5344, 5, 2448, 0, 0, 5344, 353, 1, 0, 0, 0, 5345, 5348, 3, 2404, 1202, 0, 5346, 5349, 3, 356, 178, 0, 5347, 5349, 3, 360, 180, 0, 5348, 5346, 1, 0, 0, 0, 5348, 5347, 1, 0, 0, 0, 5348, 5349, 1, 0, 0, 0, 5349, 355, 1, 0, 0, 0, 5350, 5351, 5, 567, 0, 0, 5351, 5353, 3, 2404, 1202, 0, 5352, 5354, 3, 358, 179, 0, 5353, 5352, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 357, 1, 0, 0, 0, 5355, 5356, 5, 35, 0, 0, 5356, 5357, 5, 160, 0, 0, 5357, 5358, 3, 2302, 1151, 0, 5358, 359, 1, 0, 0, 0, 5359, 5360, 5, 69, 0, 0, 5360, 5361, 5, 2447, 0, 0, 5361, 5362, 3, 2078, 1039, 0, 5362, 5363, 5, 2448, 0, 0, 5363, 361, 1, 0, 0, 0, 5364, 5365, 5, 389, 0, 0, 5365, 5366, 5, 933, 0, 0, 5366, 5367, 3, 2404, 1202, 0, 5367, 363, 1, 0, 0, 0, 5368, 5369, 5, 389, 0, 0, 5369, 5370, 5, 35, 0, 0, 5370, 5371, 5, 160, 0, 0, 5371, 5372, 3, 2302, 1151, 0, 5372, 365, 1, 0, 0, 0, 5373, 5374, 5, 166, 0, 0, 5374, 5379, 3, 368, 184, 0, 5375, 5376, 5, 2453, 0, 0, 5376, 5378, 3, 368, 184, 0, 5377, 5375, 1, 0, 0, 0, 5378, 5381, 1, 0, 0, 0, 5379, 5377, 1, 0, 0, 0, 5379, 5380, 1, 0, 0, 0, 5380, 367, 1, 0, 0, 0, 5381, 5379, 1, 0, 0, 0, 5382, 5383, 5, 933, 0, 0, 5383, 5403, 5, 649, 0, 0, 5384, 5404, 5, 38, 0, 0, 5385, 5386, 5, 2447, 0, 0, 5386, 5391, 3, 2404, 1202, 0, 5387, 5388, 5, 2453, 0, 0, 5388, 5390, 3, 2404, 1202, 0, 5389, 5387, 1, 0, 0, 0, 5390, 5393, 1, 0, 0, 0, 5391, 5389, 1, 0, 0, 0, 5391, 5392, 1, 0, 0, 0, 5392, 5394, 1, 0, 0, 0, 5393, 5391, 1, 0, 0, 0, 5394, 5395, 5, 2448, 0, 0, 5395, 5400, 3, 370, 185, 0, 5396, 5397, 5, 2453, 0, 0, 5397, 5399, 3, 370, 185, 0, 5398, 5396, 1, 0, 0, 0, 5399, 5402, 1, 0, 0, 0, 5400, 5398, 1, 0, 0, 0, 5400, 5401, 1, 0, 0, 0, 5401, 5404, 1, 0, 0, 0, 5402, 5400, 1, 0, 0, 0, 5403, 5384, 1, 0, 0, 0, 5403, 5385, 1, 0, 0, 0, 5404, 369, 1, 0, 0, 0, 5405, 5406, 5, 848, 0, 0, 5406, 5407, 5, 2447, 0, 0, 5407, 5412, 3, 372, 186, 0, 5408, 5409, 5, 2453, 0, 0, 5409, 5411, 3, 372, 186, 0, 5410, 5408, 1, 0, 0, 0, 5411, 5414, 1, 0, 0, 0, 5412, 5410, 1, 0, 0, 0, 5412, 5413, 1, 0, 0, 0, 5413, 5415, 1, 0, 0, 0, 5414, 5412, 1, 0, 0, 0, 5415, 5416, 5, 2448, 0, 0, 5416, 5417, 3, 374, 187, 0, 5417, 371, 1, 0, 0, 0, 5418, 5427, 5, 2447, 0, 0, 5419, 5420, 3, 2404, 1202, 0, 5420, 5421, 5, 2440, 0, 0, 5421, 5423, 1, 0, 0, 0, 5422, 5419, 1, 0, 0, 0, 5422, 5423, 1, 0, 0, 0, 5423, 5424, 1, 0, 0, 0, 5424, 5425, 3, 2404, 1202, 0, 5425, 5426, 5, 2440, 0, 0, 5426, 5428, 1, 0, 0, 0, 5427, 5422, 1, 0, 0, 0, 5427, 5428, 1, 0, 0, 0, 5428, 5429, 1, 0, 0, 0, 5429, 5430, 3, 2404, 1202, 0, 5430, 5431, 5, 2448, 0, 0, 5431, 373, 1, 0, 0, 0, 5432, 5444, 5, 477, 0, 0, 5433, 5441, 5, 919, 0, 0, 5434, 5438, 5, 2246, 0, 0, 5435, 5436, 3, 2286, 1143, 0, 5436, 5437, 5, 2440, 0, 0, 5437, 5439, 1, 0, 0, 0, 5438, 5435, 1, 0, 0, 0, 5438, 5439, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5442, 3, 2404, 1202, 0, 5441, 5434, 1, 0, 0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5444, 1, 0, 0, 0, 5443, 5432, 1, 0, 0, 0, 5443, 5433, 1, 0, 0, 0, 5444, 375, 1, 0, 0, 0, 5445, 5446, 5, 567, 0, 0, 5446, 5447, 5, 237, 0, 0, 5447, 5462, 3, 2340, 1170, 0, 5448, 5450, 5, 69, 0, 0, 5449, 5448, 1, 0, 0, 0, 5449, 5450, 1, 0, 0, 0, 5450, 5451, 1, 0, 0, 0, 5451, 5459, 3, 2404, 1202, 0, 5452, 5454, 5, 2453, 0, 0, 5453, 5455, 5, 69, 0, 0, 5454, 5453, 1, 0, 0, 0, 5454, 5455, 1, 0, 0, 0, 5455, 5456, 1, 0, 0, 0, 5456, 5458, 3, 2404, 1202, 0, 5457, 5452, 1, 0, 0, 0, 5458, 5461, 1, 0, 0, 0, 5459, 5457, 1, 0, 0, 0, 5459, 5460, 1, 0, 0, 0, 5460, 5463, 1, 0, 0, 0, 5461, 5459, 1, 0, 0, 0, 5462, 5449, 1, 0, 0, 0, 5462, 5463, 1, 0, 0, 0, 5463, 377, 1, 0, 0, 0, 5464, 5465, 5, 499, 0, 0, 5465, 5466, 5, 1484, 0, 0, 5466, 5468, 5, 2148, 0, 0, 5467, 5469, 7, 51, 0, 0, 5468, 5467, 1, 0, 0, 0, 5468, 5469, 1, 0, 0, 0, 5469, 379, 1, 0, 0, 0, 5470, 5473, 5, 321, 0, 0, 5471, 5472, 5, 1307, 0, 0, 5472, 5474, 5, 1562, 0, 0, 5473, 5471, 1, 0, 0, 0, 5473, 5474, 1, 0, 0, 0, 5474, 5476, 1, 0, 0, 0, 5475, 5477, 7, 7, 0, 0, 5476, 5475, 1, 0, 0, 0, 5476, 5477, 1, 0, 0, 0, 5477, 5478, 1, 0, 0, 0, 5478, 5479, 5, 83, 0, 0, 5479, 5483, 5, 422, 0, 0, 5480, 5481, 3, 2286, 1143, 0, 5481, 5482, 5, 2440, 0, 0, 5482, 5484, 1, 0, 0, 0, 5483, 5480, 1, 0, 0, 0, 5483, 5484, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 5489, 3, 2404, 1202, 0, 5486, 5487, 5, 1681, 0, 0, 5487, 5488, 5, 2472, 0, 0, 5488, 5490, 7, 21, 0, 0, 5489, 5486, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 5494, 1, 0, 0, 0, 5491, 5493, 3, 332, 166, 0, 5492, 5491, 1, 0, 0, 0, 5493, 5496, 1, 0, 0, 0, 5494, 5492, 1, 0, 0, 0, 5494, 5495, 1, 0, 0, 0, 5495, 5500, 1, 0, 0, 0, 5496, 5494, 1, 0, 0, 0, 5497, 5498, 5, 422, 0, 0, 5498, 5499, 5, 2166, 0, 0, 5499, 5501, 7, 52, 0, 0, 5500, 5497, 1, 0, 0, 0, 5500, 5501, 1, 0, 0, 0, 5501, 5502, 1, 0, 0, 0, 5502, 5503, 3, 382, 191, 0, 5503, 5505, 3, 392, 196, 0, 5504, 5506, 3, 396, 198, 0, 5505, 5504, 1, 0, 0, 0, 5506, 5507, 1, 0, 0, 0, 5507, 5505, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5510, 1, 0, 0, 0, 5509, 5511, 3, 404, 202, 0, 5510, 5509, 1, 0, 0, 0, 5510, 5511, 1, 0, 0, 0, 5511, 381, 1, 0, 0, 0, 5512, 5513, 5, 2246, 0, 0, 5513, 5518, 3, 384, 192, 0, 5514, 5515, 5, 2453, 0, 0, 5515, 5517, 3, 384, 192, 0, 5516, 5514, 1, 0, 0, 0, 5517, 5520, 1, 0, 0, 0, 5518, 5516, 1, 0, 0, 0, 5518, 5519, 1, 0, 0, 0, 5519, 5524, 1, 0, 0, 0, 5520, 5518, 1, 0, 0, 0, 5521, 5523, 3, 386, 193, 0, 5522, 5521, 1, 0, 0, 0, 5523, 5526, 1, 0, 0, 0, 5524, 5522, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 383, 1, 0, 0, 0, 5526, 5524, 1, 0, 0, 0, 5527, 5528, 3, 2286, 1143, 0, 5528, 5529, 5, 2440, 0, 0, 5529, 5531, 1, 0, 0, 0, 5530, 5527, 1, 0, 0, 0, 5530, 5531, 1, 0, 0, 0, 5531, 5532, 1, 0, 0, 0, 5532, 5534, 3, 2404, 1202, 0, 5533, 5535, 5, 1556, 0, 0, 5534, 5533, 1, 0, 0, 0, 5534, 5535, 1, 0, 0, 0, 5535, 5540, 1, 0, 0, 0, 5536, 5538, 5, 69, 0, 0, 5537, 5536, 1, 0, 0, 0, 5537, 5538, 1, 0, 0, 0, 5538, 5539, 1, 0, 0, 0, 5539, 5541, 3, 2404, 1202, 0, 5540, 5537, 1, 0, 0, 0, 5540, 5541, 1, 0, 0, 0, 5541, 385, 1, 0, 0, 0, 5542, 5543, 5, 794, 0, 0, 5543, 5544, 5, 1363, 0, 0, 5544, 5545, 3, 2404, 1202, 0, 5545, 5546, 5, 1259, 0, 0, 5546, 5547, 3, 388, 194, 0, 5547, 387, 1, 0, 0, 0, 5548, 5553, 3, 390, 195, 0, 5549, 5550, 5, 49, 0, 0, 5550, 5552, 3, 390, 195, 0, 5551, 5549, 1, 0, 0, 0, 5552, 5555, 1, 0, 0, 0, 5553, 5551, 1, 0, 0, 0, 5553, 5554, 1, 0, 0, 0, 5554, 389, 1, 0, 0, 0, 5555, 5553, 1, 0, 0, 0, 5556, 5557, 3, 2404, 1202, 0, 5557, 5558, 5, 2440, 0, 0, 5558, 5560, 1, 0, 0, 0, 5559, 5556, 1, 0, 0, 0, 5559, 5560, 1, 0, 0, 0, 5560, 5561, 1, 0, 0, 0, 5561, 5562, 3, 2340, 1170, 0, 5562, 5566, 5, 2472, 0, 0, 5563, 5564, 3, 2404, 1202, 0, 5564, 5565, 5, 2440, 0, 0, 5565, 5567, 1, 0, 0, 0, 5566, 5563, 1, 0, 0, 0, 5566, 5567, 1, 0, 0, 0, 5567, 5568, 1, 0, 0, 0, 5568, 5569, 3, 2340, 1170, 0, 5569, 391, 1, 0, 0, 0, 5570, 5571, 5, 84, 0, 0, 5571, 5572, 5, 2447, 0, 0, 5572, 5577, 3, 394, 197, 0, 5573, 5574, 5, 2453, 0, 0, 5574, 5576, 3, 394, 197, 0, 5575, 5573, 1, 0, 0, 0, 5576, 5579, 1, 0, 0, 0, 5577, 5575, 1, 0, 0, 0, 5577, 5578, 1, 0, 0, 0, 5578, 5580, 1, 0, 0, 0, 5579, 5577, 1, 0, 0, 0, 5580, 5581, 5, 2448, 0, 0, 5581, 393, 1, 0, 0, 0, 5582, 5583, 3, 2404, 1202, 0, 5583, 5584, 5, 2440, 0, 0, 5584, 5586, 1, 0, 0, 0, 5585, 5582, 1, 0, 0, 0, 5585, 5586, 1, 0, 0, 0, 5586, 5587, 1, 0, 0, 0, 5587, 5592, 3, 2340, 1170, 0, 5588, 5590, 5, 69, 0, 0, 5589, 5588, 1, 0, 0, 0, 5589, 5590, 1, 0, 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 5593, 3, 2404, 1202, 0, 5592, 5589, 1, 0, 0, 0, 5592, 5593, 1, 0, 0, 0, 5593, 5597, 1, 0, 0, 0, 5594, 5596, 3, 332, 166, 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, 395, 1, 0, 0, 0, 5599, 5597, 1, 0, 0, 0, 5600, 5601, 5, 846, 0, 0, 5601, 5607, 3, 2404, 1202, 0, 5602, 5603, 5, 1204, 0, 0, 5603, 5608, 5, 1228, 0, 0, 5604, 5605, 5, 1702, 0, 0, 5605, 5606, 5, 2300, 0, 0, 5606, 5608, 5, 1228, 0, 0, 5607, 5602, 1, 0, 0, 0, 5607, 5604, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 5612, 1, 0, 0, 0, 5609, 5610, 5, 846, 0, 0, 5610, 5611, 5, 2166, 0, 0, 5611, 5613, 7, 53, 0, 0, 5612, 5609, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, 5613, 5617, 1, 0, 0, 0, 5614, 5616, 3, 332, 166, 0, 5615, 5614, 1, 0, 0, 0, 5616, 5619, 1, 0, 0, 0, 5617, 5615, 1, 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5620, 1, 0, 0, 0, 5619, 5617, 1, 0, 0, 0, 5620, 5622, 3, 398, 199, 0, 5621, 5623, 3, 400, 200, 0, 5622, 5621, 1, 0, 0, 0, 5622, 5623, 1, 0, 0, 0, 5623, 5627, 1, 0, 0, 0, 5624, 5625, 5, 936, 0, 0, 5625, 5626, 5, 997, 0, 0, 5626, 5628, 3, 2078, 1039, 0, 5627, 5624, 1, 0, 0, 0, 5627, 5628, 1, 0, 0, 0, 5628, 5632, 1, 0, 0, 0, 5629, 5630, 5, 936, 0, 0, 5630, 5631, 5, 177, 0, 0, 5631, 5633, 3, 2078, 1039, 0, 5632, 5629, 1, 0, 0, 0, 5632, 5633, 1, 0, 0, 0, 5633, 5637, 1, 0, 0, 0, 5634, 5635, 5, 936, 0, 0, 5635, 5636, 5, 415, 0, 0, 5636, 5638, 3, 2078, 1039, 0, 5637, 5634, 1, 0, 0, 0, 5637, 5638, 1, 0, 0, 0, 5638, 5655, 1, 0, 0, 0, 5639, 5640, 5, 1303, 0, 0, 5640, 5642, 5, 160, 0, 0, 5641, 5643, 7, 54, 0, 0, 5642, 5641, 1, 0, 0, 0, 5642, 5643, 1, 0, 0, 0, 5643, 5644, 1, 0, 0, 0, 5644, 5652, 3, 402, 201, 0, 5645, 5647, 5, 2453, 0, 0, 5646, 5648, 7, 54, 0, 0, 5647, 5646, 1, 0, 0, 0, 5647, 5648, 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 5651, 3, 402, 201, 0, 5650, 5645, 1, 0, 0, 0, 5651, 5654, 1, 0, 0, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, 1, 0, 0, 0, 5653, 5656, 1, 0, 0, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5639, 1, 0, 0, 0, 5655, 5656, 1, 0, 0, 0, 5656, 5669, 1, 0, 0, 0, 5657, 5658, 5, 419, 0, 0, 5658, 5659, 5, 2447, 0, 0, 5659, 5664, 3, 2404, 1202, 0, 5660, 5661, 5, 2453, 0, 0, 5661, 5663, 3, 2404, 1202, 0, 5662, 5660, 1, 0, 0, 0, 5663, 5666, 1, 0, 0, 0, 5664, 5662, 1, 0, 0, 0, 5664, 5665, 1, 0, 0, 0, 5665, 5667, 1, 0, 0, 0, 5666, 5664, 1, 0, 0, 0, 5667, 5668, 5, 2448, 0, 0, 5668, 5670, 1, 0, 0, 0, 5669, 5657, 1, 0, 0, 0, 5669, 5670, 1, 0, 0, 0, 5670, 397, 1, 0, 0, 0, 5671, 5684, 5, 816, 0, 0, 5672, 5685, 3, 2404, 1202, 0, 5673, 5674, 5, 2447, 0, 0, 5674, 5679, 3, 2404, 1202, 0, 5675, 5676, 5, 2453, 0, 0, 5676, 5678, 3, 2404, 1202, 0, 5677, 5675, 1, 0, 0, 0, 5678, 5681, 1, 0, 0, 0, 5679, 5677, 1, 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, 5682, 1, 0, 0, 0, 5681, 5679, 1, 0, 0, 0, 5682, 5683, 5, 2448, 0, 0, 5683, 5685, 1, 0, 0, 0, 5684, 5672, 1, 0, 0, 0, 5684, 5673, 1, 0, 0, 0, 5685, 399, 1, 0, 0, 0, 5686, 5687, 5, 43, 0, 0, 5687, 5688, 3, 398, 199, 0, 5688, 401, 1, 0, 0, 0, 5689, 5691, 3, 2404, 1202, 0, 5690, 5692, 7, 55, 0, 0, 5691, 5690, 1, 0, 0, 0, 5691, 5692, 1, 0, 0, 0, 5692, 5695, 1, 0, 0, 0, 5693, 5694, 5, 1229, 0, 0, 5694, 5696, 7, 56, 0, 0, 5695, 5693, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 403, 1, 0, 0, 0, 5697, 5698, 5, 38, 0, 0, 5698, 5715, 5, 936, 0, 0, 5699, 5700, 5, 997, 0, 0, 5700, 5704, 3, 2078, 1039, 0, 5701, 5702, 5, 936, 0, 0, 5702, 5703, 5, 177, 0, 0, 5703, 5705, 3, 2078, 1039, 0, 5704, 5701, 1, 0, 0, 0, 5704, 5705, 1, 0, 0, 0, 5705, 5716, 1, 0, 0, 0, 5706, 5707, 5, 177, 0, 0, 5707, 5711, 3, 2078, 1039, 0, 5708, 5709, 5, 936, 0, 0, 5709, 5710, 5, 415, 0, 0, 5710, 5712, 3, 2078, 1039, 0, 5711, 5708, 1, 0, 0, 0, 5711, 5712, 1, 0, 0, 0, 5712, 5716, 1, 0, 0, 0, 5713, 5714, 5, 415, 0, 0, 5714, 5716, 3, 2078, 1039, 0, 5715, 5699, 1, 0, 0, 0, 5715, 5706, 1, 0, 0, 0, 5715, 5713, 1, 0, 0, 0, 5716, 405, 1, 0, 0, 0, 5717, 5718, 5, 321, 0, 0, 5718, 5719, 5, 85, 0, 0, 5719, 5720, 5, 1412, 0, 0, 5720, 5722, 3, 2404, 1202, 0, 5721, 5723, 3, 408, 204, 0, 5722, 5721, 1, 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5726, 3, 410, 205, 0, 5725, 5724, 1, 0, 0, 0, 5725, 5726, 1, 0, 0, 0, 5726, 5728, 1, 0, 0, 0, 5727, 5729, 3, 426, 213, 0, 5728, 5727, 1, 0, 0, 0, 5728, 5729, 1, 0, 0, 0, 5729, 5736, 1, 0, 0, 0, 5730, 5731, 5, 2300, 0, 0, 5731, 5732, 3, 2400, 1200, 0, 5732, 5733, 5, 530, 0, 0, 5733, 5734, 5, 1390, 0, 0, 5734, 5735, 7, 57, 0, 0, 5735, 5737, 1, 0, 0, 0, 5736, 5730, 1, 0, 0, 0, 5736, 5737, 1, 0, 0, 0, 5737, 5740, 1, 0, 0, 0, 5738, 5739, 5, 1258, 0, 0, 5739, 5741, 5, 2135, 0, 0, 5740, 5738, 1, 0, 0, 0, 5740, 5741, 1, 0, 0, 0, 5741, 5743, 1, 0, 0, 0, 5742, 5744, 3, 766, 383, 0, 5743, 5742, 1, 0, 0, 0, 5743, 5744, 1, 0, 0, 0, 5744, 407, 1, 0, 0, 0, 5745, 5746, 5, 1459, 0, 0, 5746, 5751, 3, 2392, 1196, 0, 5747, 5748, 5, 2453, 0, 0, 5748, 5750, 3, 2392, 1196, 0, 5749, 5747, 1, 0, 0, 0, 5750, 5753, 1, 0, 0, 0, 5751, 5749, 1, 0, 0, 0, 5751, 5752, 1, 0, 0, 0, 5752, 409, 1, 0, 0, 0, 5753, 5751, 1, 0, 0, 0, 5754, 5758, 3, 414, 207, 0, 5755, 5758, 3, 422, 211, 0, 5756, 5758, 3, 412, 206, 0, 5757, 5754, 1, 0, 0, 0, 5757, 5755, 1, 0, 0, 0, 5757, 5756, 1, 0, 0, 0, 5758, 5759, 1, 0, 0, 0, 5759, 5757, 1, 0, 0, 0, 5759, 5760, 1, 0, 0, 0, 5760, 411, 1, 0, 0, 0, 5761, 5762, 5, 12, 0, 0, 5762, 5767, 3, 2392, 1196, 0, 5763, 5764, 5, 2453, 0, 0, 5764, 5766, 3, 2392, 1196, 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, 413, 1, 0, 0, 0, 5769, 5767, 1, 0, 0, 0, 5770, 5771, 5, 12, 0, 0, 5771, 5776, 3, 416, 208, 0, 5772, 5773, 5, 2453, 0, 0, 5773, 5775, 3, 416, 208, 0, 5774, 5772, 1, 0, 0, 0, 5775, 5778, 1, 0, 0, 0, 5776, 5774, 1, 0, 0, 0, 5776, 5777, 1, 0, 0, 0, 5777, 415, 1, 0, 0, 0, 5778, 5776, 1, 0, 0, 0, 5779, 5782, 3, 418, 209, 0, 5780, 5782, 5, 38, 0, 0, 5781, 5779, 1, 0, 0, 0, 5781, 5780, 1, 0, 0, 0, 5782, 5783, 1, 0, 0, 0, 5783, 5796, 5, 1259, 0, 0, 5784, 5785, 5, 426, 0, 0, 5785, 5797, 3, 786, 393, 0, 5786, 5787, 5, 955, 0, 0, 5787, 5789, 5, 971, 0, 0, 5788, 5786, 1, 0, 0, 0, 5788, 5789, 1, 0, 0, 0, 5789, 5793, 1, 0, 0, 0, 5790, 5791, 3, 2286, 1143, 0, 5791, 5792, 5, 2440, 0, 0, 5792, 5794, 1, 0, 0, 0, 5793, 5790, 1, 0, 0, 0, 5793, 5794, 1, 0, 0, 0, 5794, 5795, 1, 0, 0, 0, 5795, 5797, 3, 2404, 1202, 0, 5796, 5784, 1, 0, 0, 0, 5796, 5788, 1, 0, 0, 0, 5797, 5803, 1, 0, 0, 0, 5798, 5801, 3, 420, 210, 0, 5799, 5801, 5, 38, 0, 0, 5800, 5798, 1, 0, 0, 0, 5800, 5799, 1, 0, 0, 0, 5801, 5803, 1, 0, 0, 0, 5802, 5781, 1, 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5803, 417, 1, 0, 0, 0, 5804, 5805, 7, 58, 0, 0, 5805, 419, 1, 0, 0, 0, 5806, 5814, 3, 2404, 1202, 0, 5807, 5808, 7, 59, 0, 0, 5808, 5814, 5, 792, 0, 0, 5809, 5810, 5, 881, 0, 0, 5810, 5814, 5, 2083, 0, 0, 5811, 5812, 7, 60, 0, 0, 5812, 5814, 5, 426, 0, 0, 5813, 5806, 1, 0, 0, 0, 5813, 5807, 1, 0, 0, 0, 5813, 5809, 1, 0, 0, 0, 5813, 5811, 1, 0, 0, 0, 5814, 421, 1, 0, 0, 0, 5815, 5816, 5, 12, 0, 0, 5816, 5817, 5, 252, 0, 0, 5817, 5843, 5, 2472, 0, 0, 5818, 5819, 7, 61, 0, 0, 5819, 5824, 3, 424, 212, 0, 5820, 5821, 5, 2453, 0, 0, 5821, 5823, 3, 424, 212, 0, 5822, 5820, 1, 0, 0, 0, 5823, 5826, 1, 0, 0, 0, 5824, 5822, 1, 0, 0, 0, 5824, 5825, 1, 0, 0, 0, 5825, 5844, 1, 0, 0, 0, 5826, 5824, 1, 0, 0, 0, 5827, 5828, 5, 476, 0, 0, 5828, 5829, 3, 424, 212, 0, 5829, 5830, 5, 1259, 0, 0, 5830, 5838, 3, 2404, 1202, 0, 5831, 5832, 5, 2453, 0, 0, 5832, 5833, 3, 424, 212, 0, 5833, 5834, 5, 1259, 0, 0, 5834, 5835, 3, 2404, 1202, 0, 5835, 5837, 1, 0, 0, 0, 5836, 5831, 1, 0, 0, 0, 5837, 5840, 1, 0, 0, 0, 5838, 5836, 1, 0, 0, 0, 5838, 5839, 1, 0, 0, 0, 5839, 5844, 1, 0, 0, 0, 5840, 5838, 1, 0, 0, 0, 5841, 5842, 5, 1470, 0, 0, 5842, 5844, 7, 62, 0, 0, 5843, 5818, 1, 0, 0, 0, 5843, 5827, 1, 0, 0, 0, 5843, 5841, 1, 0, 0, 0, 5844, 423, 1, 0, 0, 0, 5845, 5846, 3, 2404, 1202, 0, 5846, 425, 1, 0, 0, 0, 5847, 5848, 5, 1595, 0, 0, 5848, 5853, 3, 2308, 1154, 0, 5849, 5850, 5, 2453, 0, 0, 5850, 5852, 3, 2308, 1154, 0, 5851, 5849, 1, 0, 0, 0, 5852, 5855, 1, 0, 0, 0, 5853, 5851, 1, 0, 0, 0, 5853, 5854, 1, 0, 0, 0, 5854, 427, 1, 0, 0, 0, 5855, 5853, 1, 0, 0, 0, 5856, 5857, 5, 321, 0, 0, 5857, 5859, 5, 298, 0, 0, 5858, 5860, 5, 1587, 0, 0, 5859, 5858, 1, 0, 0, 0, 5859, 5860, 1, 0, 0, 0, 5860, 5862, 1, 0, 0, 0, 5861, 5863, 5, 1671, 0, 0, 5862, 5861, 1, 0, 0, 0, 5862, 5863, 1, 0, 0, 0, 5863, 5864, 1, 0, 0, 0, 5864, 5865, 5, 350, 0, 0, 5865, 5867, 3, 2404, 1202, 0, 5866, 5868, 3, 432, 216, 0, 5867, 5866, 1, 0, 0, 0, 5867, 5868, 1, 0, 0, 0, 5868, 5869, 1, 0, 0, 0, 5869, 5879, 7, 63, 0, 0, 5870, 5871, 5, 352, 0, 0, 5871, 5876, 3, 436, 218, 0, 5872, 5873, 5, 2453, 0, 0, 5873, 5875, 3, 436, 218, 0, 5874, 5872, 1, 0, 0, 0, 5875, 5878, 1, 0, 0, 0, 5876, 5874, 1, 0, 0, 0, 5876, 5877, 1, 0, 0, 0, 5877, 5880, 1, 0, 0, 0, 5878, 5876, 1, 0, 0, 0, 5879, 5870, 1, 0, 0, 0, 5879, 5880, 1, 0, 0, 0, 5880, 5884, 1, 0, 0, 0, 5881, 5883, 3, 430, 215, 0, 5882, 5881, 1, 0, 0, 0, 5883, 5886, 1, 0, 0, 0, 5884, 5882, 1, 0, 0, 0, 5884, 5885, 1, 0, 0, 0, 5885, 5888, 1, 0, 0, 0, 5886, 5884, 1, 0, 0, 0, 5887, 5889, 3, 434, 217, 0, 5888, 5887, 1, 0, 0, 0, 5888, 5889, 1, 0, 0, 0, 5889, 429, 1, 0, 0, 0, 5890, 5891, 5, 926, 0, 0, 5891, 5915, 3, 2396, 1198, 0, 5892, 5893, 5, 928, 0, 0, 5893, 5915, 3, 2396, 1198, 0, 5894, 5895, 5, 927, 0, 0, 5895, 5915, 3, 2396, 1198, 0, 5896, 5897, 5, 922, 0, 0, 5897, 5915, 3, 2396, 1198, 0, 5898, 5899, 5, 925, 0, 0, 5899, 5915, 3, 2396, 1198, 0, 5900, 5915, 5, 66, 0, 0, 5901, 5915, 5, 1058, 0, 0, 5902, 5903, 5, 616, 0, 0, 5903, 5915, 5, 884, 0, 0, 5904, 5905, 5, 1671, 0, 0, 5905, 5906, 5, 1734, 0, 0, 5906, 5907, 5, 1119, 0, 0, 5907, 5912, 5, 620, 0, 0, 5908, 5909, 5, 351, 0, 0, 5909, 5913, 5, 98, 0, 0, 5910, 5911, 5, 867, 0, 0, 5911, 5913, 5, 1385, 0, 0, 5912, 5908, 1, 0, 0, 0, 5912, 5910, 1, 0, 0, 0, 5913, 5915, 1, 0, 0, 0, 5914, 5890, 1, 0, 0, 0, 5914, 5892, 1, 0, 0, 0, 5914, 5894, 1, 0, 0, 0, 5914, 5896, 1, 0, 0, 0, 5914, 5898, 1, 0, 0, 0, 5914, 5900, 1, 0, 0, 0, 5914, 5901, 1, 0, 0, 0, 5914, 5902, 1, 0, 0, 0, 5914, 5904, 1, 0, 0, 0, 5915, 431, 1, 0, 0, 0, 5916, 5921, 5, 882, 0, 0, 5917, 5919, 5, 649, 0, 0, 5918, 5917, 1, 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5920, 1, 0, 0, 0, 5920, 5922, 3, 2396, 1198, 0, 5921, 5918, 1, 0, 0, 0, 5921, 5922, 1, 0, 0, 0, 5922, 5923, 1, 0, 0, 0, 5923, 5934, 3, 436, 218, 0, 5924, 5929, 5, 2453, 0, 0, 5925, 5927, 5, 649, 0, 0, 5926, 5925, 1, 0, 0, 0, 5926, 5927, 1, 0, 0, 0, 5927, 5928, 1, 0, 0, 0, 5928, 5930, 3, 2396, 1198, 0, 5929, 5926, 1, 0, 0, 0, 5929, 5930, 1, 0, 0, 0, 5930, 5931, 1, 0, 0, 0, 5931, 5933, 3, 436, 218, 0, 5932, 5924, 1, 0, 0, 0, 5933, 5936, 1, 0, 0, 0, 5934, 5932, 1, 0, 0, 0, 5934, 5935, 1, 0, 0, 0, 5935, 433, 1, 0, 0, 0, 5936, 5934, 1, 0, 0, 0, 5937, 5938, 5, 193, 0, 0, 5938, 5939, 5, 1671, 0, 0, 5939, 5940, 3, 2404, 1202, 0, 5940, 435, 1, 0, 0, 0, 5941, 5944, 3, 918, 459, 0, 5942, 5944, 3, 920, 460, 0, 5943, 5941, 1, 0, 0, 0, 5943, 5942, 1, 0, 0, 0, 5944, 437, 1, 0, 0, 0, 5945, 5946, 5, 321, 0, 0, 5946, 5947, 5, 441, 0, 0, 5947, 5960, 3, 2404, 1202, 0, 5948, 5958, 5, 675, 0, 0, 5949, 5958, 5, 1178, 0, 0, 5950, 5958, 5, 609, 0, 0, 5951, 5954, 5, 2376, 0, 0, 5952, 5953, 5, 1688, 0, 0, 5953, 5955, 3, 2404, 1202, 0, 5954, 5952, 1, 0, 0, 0, 5954, 5955, 1, 0, 0, 0, 5955, 5958, 1, 0, 0, 0, 5956, 5958, 5, 560, 0, 0, 5957, 5948, 1, 0, 0, 0, 5957, 5949, 1, 0, 0, 0, 5957, 5950, 1, 0, 0, 0, 5957, 5951, 1, 0, 0, 0, 5957, 5956, 1, 0, 0, 0, 5958, 5959, 1, 0, 0, 0, 5959, 5961, 5, 1524, 0, 0, 5960, 5957, 1, 0, 0, 0, 5960, 5961, 1, 0, 0, 0, 5961, 5978, 1, 0, 0, 0, 5962, 5964, 3, 84, 42, 0, 5963, 5962, 1, 0, 0, 0, 5963, 5964, 1, 0, 0, 0, 5964, 5967, 1, 0, 0, 0, 5965, 5966, 5, 572, 0, 0, 5966, 5968, 3, 2404, 1202, 0, 5967, 5965, 1, 0, 0, 0, 5967, 5968, 1, 0, 0, 0, 5968, 5969, 1, 0, 0, 0, 5969, 5970, 5, 440, 0, 0, 5970, 5975, 3, 440, 220, 0, 5971, 5972, 5, 2453, 0, 0, 5972, 5974, 3, 440, 220, 0, 5973, 5971, 1, 0, 0, 0, 5974, 5977, 1, 0, 0, 0, 5975, 5973, 1, 0, 0, 0, 5975, 5976, 1, 0, 0, 0, 5976, 5979, 1, 0, 0, 0, 5977, 5975, 1, 0, 0, 0, 5978, 5963, 1, 0, 0, 0, 5979, 5980, 1, 0, 0, 0, 5980, 5978, 1, 0, 0, 0, 5980, 5981, 1, 0, 0, 0, 5981, 5995, 1, 0, 0, 0, 5982, 5983, 5, 83, 0, 0, 5983, 5984, 5, 2443, 0, 0, 5984, 5985, 5, 2472, 0, 0, 5985, 5992, 5, 2443, 0, 0, 5986, 5987, 5, 2453, 0, 0, 5987, 5988, 5, 2443, 0, 0, 5988, 5989, 5, 2472, 0, 0, 5989, 5991, 5, 2443, 0, 0, 5990, 5986, 1, 0, 0, 0, 5991, 5994, 1, 0, 0, 0, 5992, 5990, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5996, 1, 0, 0, 0, 5994, 5992, 1, 0, 0, 0, 5995, 5982, 1, 0, 0, 0, 5995, 5996, 1, 0, 0, 0, 5996, 439, 1, 0, 0, 0, 5997, 6000, 5, 2443, 0, 0, 5998, 5999, 5, 997, 0, 0, 5999, 6001, 3, 2404, 1202, 0, 6000, 5998, 1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, 6001, 6004, 1, 0, 0, 0, 6002, 6003, 5, 1699, 0, 0, 6003, 6005, 3, 1176, 588, 0, 6004, 6002, 1, 0, 0, 0, 6004, 6005, 1, 0, 0, 0, 6005, 6007, 1, 0, 0, 0, 6006, 6008, 3, 38, 19, 0, 6007, 6006, 1, 0, 0, 0, 6007, 6008, 1, 0, 0, 0, 6008, 441, 1, 0, 0, 0, 6009, 6010, 5, 321, 0, 0, 6010, 6011, 5, 483, 0, 0, 6011, 6016, 3, 2404, 1202, 0, 6012, 6013, 5, 69, 0, 0, 6013, 6014, 5, 202, 0, 0, 6014, 6015, 5, 1246, 0, 0, 6015, 6017, 3, 2404, 1202, 0, 6016, 6012, 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 443, 1, 0, 0, 0, 6018, 6019, 5, 321, 0, 0, 6019, 6020, 5, 605, 0, 0, 6020, 6022, 5, 64, 0, 0, 6021, 6023, 5, 389, 0, 0, 6022, 6021, 1, 0, 0, 0, 6022, 6023, 1, 0, 0, 0, 6023, 6024, 1, 0, 0, 0, 6024, 6025, 3, 2404, 1202, 0, 6025, 6026, 5, 2080, 0, 0, 6026, 6028, 3, 2404, 1202, 0, 6027, 6029, 3, 446, 223, 0, 6028, 6027, 1, 0, 0, 0, 6028, 6029, 1, 0, 0, 0, 6029, 6035, 1, 0, 0, 0, 6030, 6032, 5, 1137, 0, 0, 6031, 6030, 1, 0, 0, 0, 6031, 6032, 1, 0, 0, 0, 6032, 6033, 1, 0, 0, 0, 6033, 6034, 5, 1269, 0, 0, 6034, 6036, 5, 351, 0, 0, 6035, 6031, 1, 0, 0, 0, 6035, 6036, 1, 0, 0, 0, 6036, 6037, 1, 0, 0, 0, 6037, 6038, 3, 448, 224, 0, 6038, 445, 1, 0, 0, 0, 6039, 6040, 5, 1490, 0, 0, 6040, 6041, 5, 2441, 0, 0, 6041, 6042, 7, 64, 0, 0, 6042, 447, 1, 0, 0, 0, 6043, 6044, 5, 1583, 0, 0, 6044, 6045, 5, 2441, 0, 0, 6045, 6046, 7, 65, 0, 0, 6046, 449, 1, 0, 0, 0, 6047, 6050, 5, 321, 0, 0, 6048, 6049, 5, 1307, 0, 0, 6049, 6051, 5, 1562, 0, 0, 6050, 6048, 1, 0, 0, 0, 6050, 6051, 1, 0, 0, 0, 6051, 6056, 1, 0, 0, 0, 6052, 6054, 5, 1137, 0, 0, 6053, 6052, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, 0, 6054, 6055, 1, 0, 0, 0, 6055, 6057, 5, 616, 0, 0, 6056, 6053, 1, 0, 0, 0, 6056, 6057, 1, 0, 0, 0, 6057, 6058, 1, 0, 0, 0, 6058, 6062, 5, 674, 0, 0, 6059, 6060, 3, 2286, 1143, 0, 6060, 6061, 5, 2440, 0, 0, 6061, 6063, 1, 0, 0, 0, 6062, 6059, 1, 0, 0, 0, 6062, 6063, 1, 0, 0, 0, 6063, 6064, 1, 0, 0, 0, 6064, 6068, 3, 2404, 1202, 0, 6065, 6066, 5, 1681, 0, 0, 6066, 6067, 5, 2472, 0, 0, 6067, 6069, 7, 21, 0, 0, 6068, 6065, 1, 0, 0, 0, 6068, 6069, 1, 0, 0, 0, 6069, 6073, 1, 0, 0, 0, 6070, 6072, 3, 332, 166, 0, 6071, 6070, 1, 0, 0, 0, 6072, 6075, 1, 0, 0, 0, 6073, 6071, 1, 0, 0, 0, 6073, 6074, 1, 0, 0, 0, 6074, 6076, 1, 0, 0, 0, 6075, 6073, 1, 0, 0, 0, 6076, 6077, 3, 452, 226, 0, 6077, 6079, 3, 454, 227, 0, 6078, 6080, 3, 456, 228, 0, 6079, 6078, 1, 0, 0, 0, 6079, 6080, 1, 0, 0, 0, 6080, 451, 1, 0, 0, 0, 6081, 6085, 5, 2246, 0, 0, 6082, 6083, 3, 2286, 1143, 0, 6083, 6084, 5, 2440, 0, 0, 6084, 6086, 1, 0, 0, 0, 6085, 6082, 1, 0, 0, 0, 6085, 6086, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6088, 3, 2404, 1202, 0, 6088, 453, 1, 0, 0, 0, 6089, 6095, 5, 2447, 0, 0, 6090, 6093, 3, 2404, 1202, 0, 6091, 6092, 5, 202, 0, 0, 6092, 6094, 5, 1246, 0, 0, 6093, 6091, 1, 0, 0, 0, 6093, 6094, 1, 0, 0, 0, 6094, 6096, 1, 0, 0, 0, 6095, 6090, 1, 0, 0, 0, 6096, 6097, 1, 0, 0, 0, 6097, 6095, 1, 0, 0, 0, 6097, 6098, 1, 0, 0, 0, 6098, 6099, 1, 0, 0, 0, 6099, 6100, 5, 2448, 0, 0, 6100, 455, 1, 0, 0, 0, 6101, 6102, 5, 672, 0, 0, 6102, 6103, 5, 84, 0, 0, 6103, 6104, 5, 2447, 0, 0, 6104, 6105, 3, 458, 229, 0, 6105, 6106, 5, 2448, 0, 0, 6106, 457, 1, 0, 0, 0, 6107, 6111, 3, 460, 230, 0, 6108, 6110, 3, 332, 166, 0, 6109, 6108, 1, 0, 0, 0, 6110, 6113, 1, 0, 0, 0, 6111, 6109, 1, 0, 0, 0, 6111, 6112, 1, 0, 0, 0, 6112, 459, 1, 0, 0, 0, 6113, 6111, 1, 0, 0, 0, 6114, 6115, 7, 66, 0, 0, 6115, 461, 1, 0, 0, 0, 6116, 6118, 5, 321, 0, 0, 6117, 6119, 7, 67, 0, 0, 6118, 6117, 1, 0, 0, 0, 6118, 6119, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120, 6121, 5, 717, 0, 0, 6121, 6125, 3, 2328, 1164, 0, 6122, 6123, 5, 691, 0, 0, 6123, 6124, 5, 1204, 0, 0, 6124, 6126, 5, 545, 0, 0, 6125, 6122, 1, 0, 0, 0, 6125, 6126, 1, 0, 0, 0, 6126, 6127, 1, 0, 0, 0, 6127, 6131, 5, 1259, 0, 0, 6128, 6132, 3, 464, 232, 0, 6129, 6132, 3, 468, 234, 0, 6130, 6132, 3, 470, 235, 0, 6131, 6128, 1, 0, 0, 0, 6131, 6129, 1, 0, 0, 0, 6131, 6130, 1, 0, 0, 0, 6132, 6134, 1, 0, 0, 0, 6133, 6135, 7, 68, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, 0, 6135, 6138, 1, 0, 0, 0, 6136, 6137, 7, 69, 0, 0, 6137, 6139, 5, 781, 0, 0, 6138, 6136, 1, 0, 0, 0, 6138, 6139, 1, 0, 0, 0, 6139, 463, 1, 0, 0, 0, 6140, 6141, 5, 220, 0, 0, 6141, 6143, 3, 466, 233, 0, 6142, 6144, 3, 1588, 794, 0, 6143, 6142, 1, 0, 0, 0, 6143, 6144, 1, 0, 0, 0, 6144, 465, 1, 0, 0, 0, 6145, 6146, 3, 2404, 1202, 0, 6146, 6147, 5, 2440, 0, 0, 6147, 6149, 1, 0, 0, 0, 6148, 6145, 1, 0, 0, 0, 6148, 6149, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0, 6150, 6151, 3, 2404, 1202, 0, 6151, 467, 1, 0, 0, 0, 6152, 6154, 3, 2342, 1171, 0, 6153, 6155, 3, 2270, 1135, 0, 6154, 6153, 1, 0, 0, 0, 6154, 6155, 1, 0, 0, 0, 6155, 6156, 1, 0, 0, 0, 6156, 6157, 5, 2447, 0, 0, 6157, 6159, 3, 472, 236, 0, 6158, 6160, 7, 55, 0, 0, 6159, 6158, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6168, 1, 0, 0, 0, 6161, 6162, 5, 2453, 0, 0, 6162, 6164, 3, 472, 236, 0, 6163, 6165, 7, 55, 0, 0, 6164, 6163, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 6167, 1, 0, 0, 0, 6166, 6161, 1, 0, 0, 0, 6167, 6170, 1, 0, 0, 0, 6168, 6166, 1, 0, 0, 0, 6168, 6169, 1, 0, 0, 0, 6169, 6171, 1, 0, 0, 0, 6170, 6168, 1, 0, 0, 0, 6171, 6173, 5, 2448, 0, 0, 6172, 6174, 3, 474, 237, 0, 6173, 6172, 1, 0, 0, 0, 6173, 6174, 1, 0, 0, 0, 6174, 469, 1, 0, 0, 0, 6175, 6176, 3, 2342, 1171, 0, 6176, 6179, 5, 2447, 0, 0, 6177, 6180, 3, 2342, 1171, 0, 6178, 6180, 3, 2270, 1135, 0, 6179, 6177, 1, 0, 0, 0, 6179, 6178, 1, 0, 0, 0, 6179, 6180, 1, 0, 0, 0, 6180, 6181, 1, 0, 0, 0, 6181, 6183, 3, 2340, 1170, 0, 6182, 6184, 7, 55, 0, 0, 6183, 6182, 1, 0, 0, 0, 6183, 6184, 1, 0, 0, 0, 6184, 6196, 1, 0, 0, 0, 6185, 6188, 5, 2453, 0, 0, 6186, 6189, 3, 2342, 1171, 0, 6187, 6189, 3, 2270, 1135, 0, 6188, 6186, 1, 0, 0, 0, 6188, 6187, 1, 0, 0, 0, 6188, 6189, 1, 0, 0, 0, 6189, 6190, 1, 0, 0, 0, 6190, 6192, 3, 2340, 1170, 0, 6191, 6193, 7, 55, 0, 0, 6192, 6191, 1, 0, 0, 0, 6192, 6193, 1, 0, 0, 0, 6193, 6195, 1, 0, 0, 0, 6194, 6185, 1, 0, 0, 0, 6195, 6198, 1, 0, 0, 0, 6196, 6194, 1, 0, 0, 0, 6196, 6197, 1, 0, 0, 0, 6197, 6199, 1, 0, 0, 0, 6198, 6196, 1, 0, 0, 0, 6199, 6200, 5, 2448, 0, 0, 6200, 6201, 5, 628, 0, 0, 6201, 6202, 3, 2342, 1171, 0, 6202, 6209, 3, 2270, 1135, 0, 6203, 6204, 5, 2453, 0, 0, 6204, 6205, 3, 2342, 1171, 0, 6205, 6206, 3, 2270, 1135, 0, 6206, 6208, 1, 0, 0, 0, 6207, 6203, 1, 0, 0, 0, 6208, 6211, 1, 0, 0, 0, 6209, 6207, 1, 0, 0, 0, 6209, 6210, 1, 0, 0, 0, 6210, 6212, 1, 0, 0, 0, 6211, 6209, 1, 0, 0, 0, 6212, 6214, 3, 2272, 1136, 0, 6213, 6215, 3, 490, 245, 0, 6214, 6213, 1, 0, 0, 0, 6214, 6215, 1, 0, 0, 0, 6215, 6217, 1, 0, 0, 0, 6216, 6218, 3, 1588, 794, 0, 6217, 6216, 1, 0, 0, 0, 6217, 6218, 1, 0, 0, 0, 6218, 471, 1, 0, 0, 0, 6219, 6222, 3, 2340, 1170, 0, 6220, 6222, 3, 2078, 1039, 0, 6221, 6219, 1, 0, 0, 0, 6221, 6220, 1, 0, 0, 0, 6222, 473, 1, 0, 0, 0, 6223, 6227, 3, 484, 242, 0, 6224, 6227, 3, 490, 245, 0, 6225, 6227, 3, 1588, 794, 0, 6226, 6223, 1, 0, 0, 0, 6226, 6224, 1, 0, 0, 0, 6226, 6225, 1, 0, 0, 0, 6227, 6228, 1, 0, 0, 0, 6228, 6226, 1, 0, 0, 0, 6228, 6229, 1, 0, 0, 0, 6229, 6237, 1, 0, 0, 0, 6230, 6231, 5, 731, 0, 0, 6231, 6234, 5, 785, 0, 0, 6232, 6235, 3, 476, 238, 0, 6233, 6235, 3, 480, 240, 0, 6234, 6232, 1, 0, 0, 0, 6234, 6233, 1, 0, 0, 0, 6235, 6237, 1, 0, 0, 0, 6236, 6226, 1, 0, 0, 0, 6236, 6230, 1, 0, 0, 0, 6237, 475, 1, 0, 0, 0, 6238, 6240, 3, 512, 256, 0, 6239, 6241, 3, 478, 239, 0, 6240, 6239, 1, 0, 0, 0, 6240, 6241, 1, 0, 0, 0, 6241, 6243, 1, 0, 0, 0, 6242, 6244, 3, 928, 464, 0, 6243, 6242, 1, 0, 0, 0, 6243, 6244, 1, 0, 0, 0, 6244, 6250, 1, 0, 0, 0, 6245, 6246, 5, 1335, 0, 0, 6246, 6247, 5, 2447, 0, 0, 6247, 6248, 3, 510, 255, 0, 6248, 6249, 5, 2448, 0, 0, 6249, 6251, 1, 0, 0, 0, 6250, 6245, 1, 0, 0, 0, 6250, 6251, 1, 0, 0, 0, 6251, 477, 1, 0, 0, 0, 6252, 6280, 5, 873, 0, 0, 6253, 6254, 5, 2447, 0, 0, 6254, 6255, 5, 1348, 0, 0, 6255, 6261, 3, 1696, 848, 0, 6256, 6257, 5, 1335, 0, 0, 6257, 6258, 5, 2447, 0, 0, 6258, 6259, 3, 510, 255, 0, 6259, 6260, 5, 2448, 0, 0, 6260, 6262, 1, 0, 0, 0, 6261, 6256, 1, 0, 0, 0, 6261, 6262, 1, 0, 0, 0, 6262, 6275, 1, 0, 0, 0, 6263, 6264, 5, 2453, 0, 0, 6264, 6265, 5, 1348, 0, 0, 6265, 6271, 3, 1696, 848, 0, 6266, 6267, 5, 1335, 0, 0, 6267, 6268, 5, 2447, 0, 0, 6268, 6269, 3, 510, 255, 0, 6269, 6270, 5, 2448, 0, 0, 6270, 6272, 1, 0, 0, 0, 6271, 6266, 1, 0, 0, 0, 6271, 6272, 1, 0, 0, 0, 6272, 6274, 1, 0, 0, 0, 6273, 6263, 1, 0, 0, 0, 6274, 6277, 1, 0, 0, 0, 6275, 6273, 1, 0, 0, 0, 6275, 6276, 1, 0, 0, 0, 6276, 6278, 1, 0, 0, 0, 6277, 6275, 1, 0, 0, 0, 6278, 6279, 5, 2448, 0, 0, 6279, 6281, 1, 0, 0, 0, 6280, 6253, 1, 0, 0, 0, 6280, 6281, 1, 0, 0, 0, 6281, 479, 1, 0, 0, 0, 6282, 6283, 5, 2315, 0, 0, 6283, 6285, 5, 2440, 0, 0, 6284, 6282, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6286, 1, 0, 0, 0, 6286, 6288, 5, 2332, 0, 0, 6287, 6289, 3, 482, 241, 0, 6288, 6287, 1, 0, 0, 0, 6288, 6289, 1, 0, 0, 0, 6289, 6291, 1, 0, 0, 0, 6290, 6292, 3, 928, 464, 0, 6291, 6290, 1, 0, 0, 0, 6291, 6292, 1, 0, 0, 0, 6292, 481, 1, 0, 0, 0, 6293, 6307, 5, 873, 0, 0, 6294, 6295, 5, 2447, 0, 0, 6295, 6296, 5, 1348, 0, 0, 6296, 6302, 3, 1696, 848, 0, 6297, 6298, 5, 2453, 0, 0, 6298, 6299, 5, 1348, 0, 0, 6299, 6301, 3, 1696, 848, 0, 6300, 6297, 1, 0, 0, 0, 6301, 6304, 1, 0, 0, 0, 6302, 6300, 1, 0, 0, 0, 6302, 6303, 1, 0, 0, 0, 6303, 6305, 1, 0, 0, 0, 6304, 6302, 1, 0, 0, 0, 6305, 6306, 5, 2448, 0, 0, 6306, 6308, 1, 0, 0, 0, 6307, 6294, 1, 0, 0, 0, 6307, 6308, 1, 0, 0, 0, 6308, 483, 1, 0, 0, 0, 6309, 6310, 5, 642, 0, 0, 6310, 6311, 5, 1348, 0, 0, 6311, 6349, 5, 160, 0, 0, 6312, 6313, 5, 1495, 0, 0, 6313, 6314, 5, 2447, 0, 0, 6314, 6319, 3, 2340, 1170, 0, 6315, 6316, 5, 2453, 0, 0, 6316, 6318, 3, 2340, 1170, 0, 6317, 6315, 1, 0, 0, 0, 6318, 6321, 1, 0, 0, 0, 6319, 6317, 1, 0, 0, 0, 6319, 6320, 1, 0, 0, 0, 6320, 6322, 1, 0, 0, 0, 6321, 6319, 1, 0, 0, 0, 6322, 6323, 5, 2448, 0, 0, 6323, 6324, 5, 2447, 0, 0, 6324, 6329, 3, 486, 243, 0, 6325, 6326, 5, 2453, 0, 0, 6326, 6328, 3, 486, 243, 0, 6327, 6325, 1, 0, 0, 0, 6328, 6331, 1, 0, 0, 0, 6329, 6327, 1, 0, 0, 0, 6329, 6330, 1, 0, 0, 0, 6330, 6332, 1, 0, 0, 0, 6331, 6329, 1, 0, 0, 0, 6332, 6333, 5, 2448, 0, 0, 6333, 6350, 1, 0, 0, 0, 6334, 6335, 5, 660, 0, 0, 6335, 6336, 5, 2447, 0, 0, 6336, 6341, 3, 2340, 1170, 0, 6337, 6338, 5, 2453, 0, 0, 6338, 6340, 3, 2340, 1170, 0, 6339, 6337, 1, 0, 0, 0, 6340, 6343, 1, 0, 0, 0, 6341, 6339, 1, 0, 0, 0, 6341, 6342, 1, 0, 0, 0, 6342, 6344, 1, 0, 0, 0, 6343, 6341, 1, 0, 0, 0, 6344, 6347, 5, 2448, 0, 0, 6345, 6348, 3, 1122, 561, 0, 6346, 6348, 3, 1124, 562, 0, 6347, 6345, 1, 0, 0, 0, 6347, 6346, 1, 0, 0, 0, 6348, 6350, 1, 0, 0, 0, 6349, 6312, 1, 0, 0, 0, 6349, 6334, 1, 0, 0, 0, 6350, 485, 1, 0, 0, 0, 6351, 6353, 5, 1348, 0, 0, 6352, 6354, 3, 1696, 848, 0, 6353, 6352, 1, 0, 0, 0, 6353, 6354, 1, 0, 0, 0, 6354, 6355, 1, 0, 0, 0, 6355, 6356, 5, 2257, 0, 0, 6356, 6357, 5, 845, 0, 0, 6357, 6358, 5, 2098, 0, 0, 6358, 6359, 5, 2447, 0, 0, 6359, 6360, 3, 488, 244, 0, 6360, 6362, 5, 2448, 0, 0, 6361, 6363, 3, 1200, 600, 0, 6362, 6361, 1, 0, 0, 0, 6362, 6363, 1, 0, 0, 0, 6363, 487, 1, 0, 0, 0, 6364, 6369, 3, 2186, 1093, 0, 6365, 6366, 5, 2453, 0, 0, 6366, 6368, 3, 2186, 1093, 0, 6367, 6365, 1, 0, 0, 0, 6368, 6371, 1, 0, 0, 0, 6369, 6367, 1, 0, 0, 0, 6369, 6370, 1, 0, 0, 0, 6370, 6383, 1, 0, 0, 0, 6371, 6369, 1, 0, 0, 0, 6372, 6373, 5, 2108, 0, 0, 6373, 6379, 3, 2186, 1093, 0, 6374, 6375, 5, 2453, 0, 0, 6375, 6376, 5, 2108, 0, 0, 6376, 6378, 3, 2186, 1093, 0, 6377, 6374, 1, 0, 0, 0, 6378, 6381, 1, 0, 0, 0, 6379, 6377, 1, 0, 0, 0, 6379, 6380, 1, 0, 0, 0, 6380, 6383, 1, 0, 0, 0, 6381, 6379, 1, 0, 0, 0, 6382, 6364, 1, 0, 0, 0, 6382, 6372, 1, 0, 0, 0, 6383, 489, 1, 0, 0, 0, 6384, 6389, 5, 873, 0, 0, 6385, 6390, 3, 492, 246, 0, 6386, 6390, 3, 494, 247, 0, 6387, 6390, 3, 498, 249, 0, 6388, 6390, 3, 502, 251, 0, 6389, 6385, 1, 0, 0, 0, 6389, 6386, 1, 0, 0, 0, 6389, 6387, 1, 0, 0, 0, 6389, 6388, 1, 0, 0, 0, 6389, 6390, 1, 0, 0, 0, 6390, 491, 1, 0, 0, 0, 6391, 6392, 5, 2447, 0, 0, 6392, 6397, 3, 496, 248, 0, 6393, 6394, 5, 2453, 0, 0, 6394, 6396, 3, 496, 248, 0, 6395, 6393, 1, 0, 0, 0, 6396, 6399, 1, 0, 0, 0, 6397, 6395, 1, 0, 0, 0, 6397, 6398, 1, 0, 0, 0, 6398, 6400, 1, 0, 0, 0, 6399, 6397, 1, 0, 0, 0, 6400, 6401, 5, 2448, 0, 0, 6401, 493, 1, 0, 0, 0, 6402, 6403, 5, 2447, 0, 0, 6403, 6408, 3, 496, 248, 0, 6404, 6405, 5, 2453, 0, 0, 6405, 6407, 3, 496, 248, 0, 6406, 6404, 1, 0, 0, 0, 6407, 6410, 1, 0, 0, 0, 6408, 6406, 1, 0, 0, 0, 6408, 6409, 1, 0, 0, 0, 6409, 6411, 1, 0, 0, 0, 6410, 6408, 1, 0, 0, 0, 6411, 6412, 5, 2448, 0, 0, 6412, 495, 1, 0, 0, 0, 6413, 6415, 5, 1348, 0, 0, 6414, 6416, 3, 1696, 848, 0, 6415, 6414, 1, 0, 0, 0, 6415, 6416, 1, 0, 0, 0, 6416, 6421, 1, 0, 0, 0, 6417, 6420, 3, 1200, 600, 0, 6418, 6420, 3, 1600, 800, 0, 6419, 6417, 1, 0, 0, 0, 6419, 6418, 1, 0, 0, 0, 6420, 6423, 1, 0, 0, 0, 6421, 6419, 1, 0, 0, 0, 6421, 6422, 1, 0, 0, 0, 6422, 6425, 1, 0, 0, 0, 6423, 6421, 1, 0, 0, 0, 6424, 6426, 5, 2203, 0, 0, 6425, 6424, 1, 0, 0, 0, 6425, 6426, 1, 0, 0, 0, 6426, 497, 1, 0, 0, 0, 6427, 6428, 5, 1763, 0, 0, 6428, 6429, 5, 738, 0, 0, 6429, 6430, 5, 2447, 0, 0, 6430, 6435, 3, 1656, 828, 0, 6431, 6432, 5, 2453, 0, 0, 6432, 6434, 3, 1656, 828, 0, 6433, 6431, 1, 0, 0, 0, 6434, 6437, 1, 0, 0, 0, 6435, 6433, 1, 0, 0, 0, 6435, 6436, 1, 0, 0, 0, 6436, 6438, 1, 0, 0, 0, 6437, 6435, 1, 0, 0, 0, 6438, 6439, 5, 2448, 0, 0, 6439, 6452, 1, 0, 0, 0, 6440, 6441, 5, 2447, 0, 0, 6441, 6446, 3, 500, 250, 0, 6442, 6443, 5, 2453, 0, 0, 6443, 6445, 3, 500, 250, 0, 6444, 6442, 1, 0, 0, 0, 6445, 6448, 1, 0, 0, 0, 6446, 6444, 1, 0, 0, 0, 6446, 6447, 1, 0, 0, 0, 6447, 6449, 1, 0, 0, 0, 6448, 6446, 1, 0, 0, 0, 6449, 6450, 5, 2448, 0, 0, 6450, 6452, 1, 0, 0, 0, 6451, 6427, 1, 0, 0, 0, 6451, 6440, 1, 0, 0, 0, 6452, 499, 1, 0, 0, 0, 6453, 6455, 5, 1348, 0, 0, 6454, 6456, 3, 1696, 848, 0, 6455, 6454, 1, 0, 0, 0, 6455, 6456, 1, 0, 0, 0, 6456, 6459, 1, 0, 0, 0, 6457, 6458, 5, 2080, 0, 0, 6458, 6460, 3, 1656, 828, 0, 6459, 6457, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6462, 1, 0, 0, 0, 6461, 6463, 3, 1600, 800, 0, 6462, 6461, 1, 0, 0, 0, 6462, 6463, 1, 0, 0, 0, 6463, 6465, 1, 0, 0, 0, 6464, 6466, 5, 2203, 0, 0, 6465, 6464, 1, 0, 0, 0, 6465, 6466, 1, 0, 0, 0, 6466, 501, 1, 0, 0, 0, 6467, 6468, 5, 1763, 0, 0, 6468, 6469, 5, 738, 0, 0, 6469, 6470, 5, 2447, 0, 0, 6470, 6475, 3, 1656, 828, 0, 6471, 6472, 5, 2453, 0, 0, 6472, 6474, 3, 1656, 828, 0, 6473, 6471, 1, 0, 0, 0, 6474, 6477, 1, 0, 0, 0, 6475, 6473, 1, 0, 0, 0, 6475, 6476, 1, 0, 0, 0, 6476, 6478, 1, 0, 0, 0, 6477, 6475, 1, 0, 0, 0, 6478, 6479, 5, 2448, 0, 0, 6479, 6481, 1, 0, 0, 0, 6480, 6467, 1, 0, 0, 0, 6480, 6481, 1, 0, 0, 0, 6481, 6482, 1, 0, 0, 0, 6482, 6483, 5, 2447, 0, 0, 6483, 6488, 3, 504, 252, 0, 6484, 6485, 5, 2453, 0, 0, 6485, 6487, 3, 504, 252, 0, 6486, 6484, 1, 0, 0, 0, 6487, 6490, 1, 0, 0, 0, 6488, 6486, 1, 0, 0, 0, 6488, 6489, 1, 0, 0, 0, 6489, 6491, 1, 0, 0, 0, 6490, 6488, 1, 0, 0, 0, 6491, 6492, 5, 2448, 0, 0, 6492, 503, 1, 0, 0, 0, 6493, 6495, 5, 1348, 0, 0, 6494, 6496, 3, 1696, 848, 0, 6495, 6494, 1, 0, 0, 0, 6495, 6496, 1, 0, 0, 0, 6496, 6501, 1, 0, 0, 0, 6497, 6500, 3, 1200, 600, 0, 6498, 6500, 3, 1600, 800, 0, 6499, 6497, 1, 0, 0, 0, 6499, 6498, 1, 0, 0, 0, 6500, 6503, 1, 0, 0, 0, 6501, 6499, 1, 0, 0, 0, 6501, 6502, 1, 0, 0, 0, 6502, 6505, 1, 0, 0, 0, 6503, 6501, 1, 0, 0, 0, 6504, 6506, 5, 2203, 0, 0, 6505, 6504, 1, 0, 0, 0, 6505, 6506, 1, 0, 0, 0, 6506, 6508, 1, 0, 0, 0, 6507, 6509, 3, 506, 253, 0, 6508, 6507, 1, 0, 0, 0, 6508, 6509, 1, 0, 0, 0, 6509, 505, 1, 0, 0, 0, 6510, 6511, 5, 1763, 0, 0, 6511, 6512, 5, 738, 0, 0, 6512, 6513, 5, 2447, 0, 0, 6513, 6518, 3, 1656, 828, 0, 6514, 6515, 5, 2453, 0, 0, 6515, 6517, 3, 1656, 828, 0, 6516, 6514, 1, 0, 0, 0, 6517, 6520, 1, 0, 0, 0, 6518, 6516, 1, 0, 0, 0, 6518, 6519, 1, 0, 0, 0, 6519, 6521, 1, 0, 0, 0, 6520, 6518, 1, 0, 0, 0, 6521, 6522, 5, 2448, 0, 0, 6522, 6535, 1, 0, 0, 0, 6523, 6524, 5, 2447, 0, 0, 6524, 6529, 3, 508, 254, 0, 6525, 6526, 5, 2453, 0, 0, 6526, 6528, 3, 508, 254, 0, 6527, 6525, 1, 0, 0, 0, 6528, 6531, 1, 0, 0, 0, 6529, 6527, 1, 0, 0, 0, 6529, 6530, 1, 0, 0, 0, 6530, 6532, 1, 0, 0, 0, 6531, 6529, 1, 0, 0, 0, 6532, 6533, 5, 2448, 0, 0, 6533, 6535, 1, 0, 0, 0, 6534, 6510, 1, 0, 0, 0, 6534, 6523, 1, 0, 0, 0, 6535, 507, 1, 0, 0, 0, 6536, 6538, 5, 1775, 0, 0, 6537, 6539, 3, 1154, 577, 0, 6538, 6537, 1, 0, 0, 0, 6538, 6539, 1, 0, 0, 0, 6539, 6542, 1, 0, 0, 0, 6540, 6541, 5, 2080, 0, 0, 6541, 6543, 3, 1656, 828, 0, 6542, 6540, 1, 0, 0, 0, 6542, 6543, 1, 0, 0, 0, 6543, 6545, 1, 0, 0, 0, 6544, 6546, 3, 1600, 800, 0, 6545, 6544, 1, 0, 0, 0, 6545, 6546, 1, 0, 0, 0, 6546, 6548, 1, 0, 0, 0, 6547, 6549, 5, 2203, 0, 0, 6548, 6547, 1, 0, 0, 0, 6548, 6549, 1, 0, 0, 0, 6549, 509, 1, 0, 0, 0, 6550, 6551, 5, 2443, 0, 0, 6551, 511, 1, 0, 0, 0, 6552, 6553, 3, 2404, 1202, 0, 6553, 6554, 5, 2440, 0, 0, 6554, 6556, 1, 0, 0, 0, 6555, 6552, 1, 0, 0, 0, 6555, 6556, 1, 0, 0, 0, 6556, 6557, 1, 0, 0, 0, 6557, 6558, 3, 2404, 1202, 0, 6558, 513, 1, 0, 0, 0, 6559, 6560, 5, 42, 0, 0, 6560, 6561, 5, 717, 0, 0, 6561, 6564, 3, 2328, 1164, 0, 6562, 6565, 3, 516, 258, 0, 6563, 6565, 3, 518, 259, 0, 6564, 6562, 1, 0, 0, 0, 6564, 6563, 1, 0, 0, 0, 6565, 515, 1, 0, 0, 0, 6566, 6573, 3, 1286, 643, 0, 6567, 6573, 3, 1284, 642, 0, 6568, 6573, 3, 1288, 644, 0, 6569, 6573, 3, 928, 464, 0, 6570, 6573, 3, 1194, 597, 0, 6571, 6573, 3, 886, 443, 0, 6572, 6566, 1, 0, 0, 0, 6572, 6567, 1, 0, 0, 0, 6572, 6568, 1, 0, 0, 0, 6572, 6569, 1, 0, 0, 0, 6572, 6570, 1, 0, 0, 0, 6572, 6571, 1, 0, 0, 0, 6573, 6574, 1, 0, 0, 0, 6574, 6572, 1, 0, 0, 0, 6574, 6575, 1, 0, 0, 0, 6575, 517, 1, 0, 0, 0, 6576, 6598, 3, 524, 262, 0, 6577, 6578, 5, 1335, 0, 0, 6578, 6579, 5, 2447, 0, 0, 6579, 6580, 3, 510, 255, 0, 6580, 6581, 5, 2448, 0, 0, 6581, 6598, 1, 0, 0, 0, 6582, 6598, 5, 249, 0, 0, 6583, 6598, 3, 1308, 654, 0, 6584, 6598, 5, 2203, 0, 0, 6585, 6598, 3, 520, 260, 0, 6586, 6587, 5, 1559, 0, 0, 6587, 6588, 5, 2141, 0, 0, 6588, 6598, 3, 552, 276, 0, 6589, 6598, 5, 228, 0, 0, 6590, 6591, 3, 522, 261, 0, 6591, 6592, 5, 2216, 0, 0, 6592, 6598, 1, 0, 0, 0, 6593, 6594, 5, 2207, 0, 0, 6594, 6595, 5, 143, 0, 0, 6595, 6598, 5, 1528, 0, 0, 6596, 6598, 3, 526, 263, 0, 6597, 6576, 1, 0, 0, 0, 6597, 6577, 1, 0, 0, 0, 6597, 6582, 1, 0, 0, 0, 6597, 6583, 1, 0, 0, 0, 6597, 6584, 1, 0, 0, 0, 6597, 6585, 1, 0, 0, 0, 6597, 6586, 1, 0, 0, 0, 6597, 6589, 1, 0, 0, 0, 6597, 6590, 1, 0, 0, 0, 6597, 6593, 1, 0, 0, 0, 6597, 6596, 1, 0, 0, 0, 6598, 519, 1, 0, 0, 0, 6599, 6600, 7, 70, 0, 0, 6600, 521, 1, 0, 0, 0, 6601, 6602, 7, 71, 0, 0, 6602, 523, 1, 0, 0, 0, 6603, 6610, 5, 1511, 0, 0, 6604, 6605, 5, 1348, 0, 0, 6605, 6611, 3, 1696, 848, 0, 6606, 6607, 5, 1775, 0, 0, 6607, 6611, 3, 1154, 577, 0, 6608, 6611, 5, 1588, 0, 0, 6609, 6611, 5, 1175, 0, 0, 6610, 6604, 1, 0, 0, 0, 6610, 6606, 1, 0, 0, 0, 6610, 6608, 1, 0, 0, 0, 6610, 6609, 1, 0, 0, 0, 6610, 6611, 1, 0, 0, 0, 6611, 6626, 1, 0, 0, 0, 6612, 6625, 3, 928, 464, 0, 6613, 6614, 5, 2080, 0, 0, 6614, 6625, 3, 1656, 828, 0, 6615, 6616, 5, 1335, 0, 0, 6616, 6617, 5, 2447, 0, 0, 6617, 6618, 3, 510, 255, 0, 6618, 6619, 5, 2448, 0, 0, 6619, 6625, 1, 0, 0, 0, 6620, 6625, 5, 1256, 0, 0, 6621, 6625, 3, 1194, 597, 0, 6622, 6625, 3, 1600, 800, 0, 6623, 6625, 3, 886, 443, 0, 6624, 6612, 1, 0, 0, 0, 6624, 6613, 1, 0, 0, 0, 6624, 6615, 1, 0, 0, 0, 6624, 6620, 1, 0, 0, 0, 6624, 6621, 1, 0, 0, 0, 6624, 6622, 1, 0, 0, 0, 6624, 6623, 1, 0, 0, 0, 6625, 6628, 1, 0, 0, 0, 6626, 6624, 1, 0, 0, 0, 6626, 6627, 1, 0, 0, 0, 6627, 525, 1, 0, 0, 0, 6628, 6626, 1, 0, 0, 0, 6629, 6638, 3, 528, 264, 0, 6630, 6638, 3, 530, 265, 0, 6631, 6638, 3, 534, 267, 0, 6632, 6638, 3, 538, 269, 0, 6633, 6638, 3, 540, 270, 0, 6634, 6638, 3, 542, 271, 0, 6635, 6638, 3, 532, 266, 0, 6636, 6638, 3, 546, 273, 0, 6637, 6629, 1, 0, 0, 0, 6637, 6630, 1, 0, 0, 0, 6637, 6631, 1, 0, 0, 0, 6637, 6632, 1, 0, 0, 0, 6637, 6633, 1, 0, 0, 0, 6637, 6634, 1, 0, 0, 0, 6637, 6635, 1, 0, 0, 0, 6637, 6636, 1, 0, 0, 0, 6638, 527, 1, 0, 0, 0, 6639, 6640, 5, 980, 0, 0, 6640, 6641, 5, 389, 0, 0, 6641, 6645, 5, 84, 0, 0, 6642, 6643, 5, 620, 0, 0, 6643, 6644, 5, 1348, 0, 0, 6644, 6646, 3, 1696, 848, 0, 6645, 6642, 1, 0, 0, 0, 6645, 6646, 1, 0, 0, 0, 6646, 6654, 1, 0, 0, 0, 6647, 6655, 3, 1194, 597, 0, 6648, 6651, 5, 2080, 0, 0, 6649, 6652, 3, 1656, 828, 0, 6650, 6652, 5, 389, 0, 0, 6651, 6649, 1, 0, 0, 0, 6651, 6650, 1, 0, 0, 0, 6652, 6655, 1, 0, 0, 0, 6653, 6655, 3, 886, 443, 0, 6654, 6647, 1, 0, 0, 0, 6654, 6648, 1, 0, 0, 0, 6654, 6653, 1, 0, 0, 0, 6655, 529, 1, 0, 0, 0, 6656, 6657, 5, 21, 0, 0, 6657, 6659, 5, 1348, 0, 0, 6658, 6660, 3, 1696, 848, 0, 6659, 6658, 1, 0, 0, 0, 6659, 6660, 1, 0, 0, 0, 6660, 6663, 1, 0, 0, 0, 6661, 6662, 5, 2080, 0, 0, 6662, 6664, 3, 1656, 828, 0, 6663, 6661, 1, 0, 0, 0, 6663, 6664, 1, 0, 0, 0, 6664, 6666, 1, 0, 0, 0, 6665, 6667, 3, 1600, 800, 0, 6666, 6665, 1, 0, 0, 0, 6666, 6667, 1, 0, 0, 0, 6667, 6669, 1, 0, 0, 0, 6668, 6670, 3, 928, 464, 0, 6669, 6668, 1, 0, 0, 0, 6669, 6670, 1, 0, 0, 0, 6670, 531, 1, 0, 0, 0, 6671, 6672, 5, 228, 0, 0, 6672, 6674, 5, 1348, 0, 0, 6673, 6675, 3, 928, 464, 0, 6674, 6673, 1, 0, 0, 0, 6674, 6675, 1, 0, 0, 0, 6675, 533, 1, 0, 0, 0, 6676, 6677, 5, 980, 0, 0, 6677, 6678, 5, 1348, 0, 0, 6678, 6694, 3, 1696, 848, 0, 6679, 6681, 3, 536, 268, 0, 6680, 6679, 1, 0, 0, 0, 6681, 6682, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, 0, 6683, 6695, 1, 0, 0, 0, 6684, 6685, 5, 1335, 0, 0, 6685, 6686, 5, 2447, 0, 0, 6686, 6687, 3, 510, 255, 0, 6687, 6688, 5, 2448, 0, 0, 6688, 6695, 1, 0, 0, 0, 6689, 6695, 5, 228, 0, 0, 6690, 6691, 5, 2207, 0, 0, 6691, 6692, 5, 143, 0, 0, 6692, 6695, 5, 1528, 0, 0, 6693, 6695, 5, 2203, 0, 0, 6694, 6680, 1, 0, 0, 0, 6694, 6684, 1, 0, 0, 0, 6694, 6689, 1, 0, 0, 0, 6694, 6690, 1, 0, 0, 0, 6694, 6693, 1, 0, 0, 0, 6695, 535, 1, 0, 0, 0, 6696, 6703, 3, 1286, 643, 0, 6697, 6703, 3, 1284, 642, 0, 6698, 6703, 3, 1194, 597, 0, 6699, 6703, 3, 886, 443, 0, 6700, 6703, 3, 1600, 800, 0, 6701, 6703, 3, 1288, 644, 0, 6702, 6696, 1, 0, 0, 0, 6702, 6697, 1, 0, 0, 0, 6702, 6698, 1, 0, 0, 0, 6702, 6699, 1, 0, 0, 0, 6702, 6700, 1, 0, 0, 0, 6702, 6701, 1, 0, 0, 0, 6703, 537, 1, 0, 0, 0, 6704, 6709, 5, 1559, 0, 0, 6705, 6706, 5, 1348, 0, 0, 6706, 6710, 3, 1696, 848, 0, 6707, 6708, 5, 1775, 0, 0, 6708, 6710, 3, 1154, 577, 0, 6709, 6705, 1, 0, 0, 0, 6709, 6707, 1, 0, 0, 0, 6710, 6711, 1, 0, 0, 0, 6711, 6712, 5, 2141, 0, 0, 6712, 6713, 3, 550, 275, 0, 6713, 539, 1, 0, 0, 0, 6714, 6715, 5, 469, 0, 0, 6715, 6716, 5, 1348, 0, 0, 6716, 6717, 3, 1696, 848, 0, 6717, 541, 1, 0, 0, 0, 6718, 6719, 5, 1717, 0, 0, 6719, 6720, 5, 1348, 0, 0, 6720, 6721, 3, 548, 274, 0, 6721, 6722, 5, 82, 0, 0, 6722, 6723, 5, 2447, 0, 0, 6723, 6728, 3, 2186, 1093, 0, 6724, 6725, 5, 2453, 0, 0, 6725, 6727, 3, 2186, 1093, 0, 6726, 6724, 1, 0, 0, 0, 6727, 6730, 1, 0, 0, 0, 6728, 6726, 1, 0, 0, 0, 6728, 6729, 1, 0, 0, 0, 6729, 6731, 1, 0, 0, 0, 6730, 6728, 1, 0, 0, 0, 6731, 6739, 5, 2448, 0, 0, 6732, 6733, 5, 779, 0, 0, 6733, 6734, 5, 2447, 0, 0, 6734, 6735, 3, 544, 272, 0, 6735, 6736, 5, 2453, 0, 0, 6736, 6737, 3, 544, 272, 0, 6737, 6738, 5, 2448, 0, 0, 6738, 6740, 1, 0, 0, 0, 6739, 6732, 1, 0, 0, 0, 6739, 6740, 1, 0, 0, 0, 6740, 6742, 1, 0, 0, 0, 6741, 6743, 3, 928, 464, 0, 6742, 6741, 1, 0, 0, 0, 6742, 6743, 1, 0, 0, 0, 6743, 543, 1, 0, 0, 0, 6744, 6762, 5, 1348, 0, 0, 6745, 6757, 3, 1696, 848, 0, 6746, 6749, 3, 1200, 600, 0, 6747, 6749, 3, 1600, 800, 0, 6748, 6746, 1, 0, 0, 0, 6748, 6747, 1, 0, 0, 0, 6749, 6750, 1, 0, 0, 0, 6750, 6748, 1, 0, 0, 0, 6750, 6751, 1, 0, 0, 0, 6751, 6758, 1, 0, 0, 0, 6752, 6753, 5, 1335, 0, 0, 6753, 6754, 5, 2447, 0, 0, 6754, 6755, 3, 510, 255, 0, 6755, 6756, 5, 2448, 0, 0, 6756, 6758, 1, 0, 0, 0, 6757, 6748, 1, 0, 0, 0, 6757, 6752, 1, 0, 0, 0, 6758, 6760, 1, 0, 0, 0, 6759, 6761, 5, 2203, 0, 0, 6760, 6759, 1, 0, 0, 0, 6760, 6761, 1, 0, 0, 0, 6761, 6763, 1, 0, 0, 0, 6762, 6745, 1, 0, 0, 0, 6762, 6763, 1, 0, 0, 0, 6763, 545, 1, 0, 0, 0, 6764, 6765, 5, 980, 0, 0, 6765, 6766, 5, 1775, 0, 0, 6766, 6769, 3, 1154, 577, 0, 6767, 6770, 5, 2203, 0, 0, 6768, 6770, 3, 536, 268, 0, 6769, 6767, 1, 0, 0, 0, 6769, 6768, 1, 0, 0, 0, 6770, 547, 1, 0, 0, 0, 6771, 6772, 3, 1696, 848, 0, 6772, 549, 1, 0, 0, 0, 6773, 6774, 3, 1696, 848, 0, 6774, 551, 1, 0, 0, 0, 6775, 6776, 3, 2328, 1164, 0, 6776, 553, 1, 0, 0, 0, 6777, 6778, 5, 42, 0, 0, 6778, 6779, 5, 746, 0, 0, 6779, 6780, 5, 794, 0, 0, 6780, 6784, 5, 649, 0, 0, 6781, 6782, 3, 2286, 1143, 0, 6782, 6783, 5, 2440, 0, 0, 6783, 6785, 1, 0, 0, 0, 6784, 6781, 1, 0, 0, 0, 6784, 6785, 1, 0, 0, 0, 6785, 6786, 1, 0, 0, 0, 6786, 6787, 3, 2404, 1202, 0, 6787, 6788, 7, 72, 0, 0, 6788, 6792, 5, 2447, 0, 0, 6789, 6790, 3, 2286, 1143, 0, 6790, 6791, 5, 2440, 0, 0, 6791, 6793, 1, 0, 0, 0, 6792, 6789, 1, 0, 0, 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, 1, 0, 0, 0, 6794, 6795, 3, 2404, 1202, 0, 6795, 6796, 5, 2447, 0, 0, 6796, 6797, 3, 2404, 1202, 0, 6797, 6798, 5, 2448, 0, 0, 6798, 6799, 5, 2448, 0, 0, 6799, 555, 1, 0, 0, 0, 6800, 6801, 5, 321, 0, 0, 6801, 6802, 5, 2237, 0, 0, 6802, 6806, 3, 2354, 1177, 0, 6803, 6804, 5, 691, 0, 0, 6804, 6805, 5, 1204, 0, 0, 6805, 6807, 5, 545, 0, 0, 6806, 6803, 1, 0, 0, 0, 6806, 6807, 1, 0, 0, 0, 6807, 6817, 1, 0, 0, 0, 6808, 6818, 3, 564, 282, 0, 6809, 6818, 3, 566, 283, 0, 6810, 6818, 3, 568, 284, 0, 6811, 6818, 3, 570, 285, 0, 6812, 6818, 3, 572, 286, 0, 6813, 6818, 3, 578, 289, 0, 6814, 6818, 3, 580, 290, 0, 6815, 6818, 3, 582, 291, 0, 6816, 6818, 3, 766, 383, 0, 6817, 6808, 1, 0, 0, 0, 6817, 6809, 1, 0, 0, 0, 6817, 6810, 1, 0, 0, 0, 6817, 6811, 1, 0, 0, 0, 6817, 6812, 1, 0, 0, 0, 6817, 6813, 1, 0, 0, 0, 6817, 6814, 1, 0, 0, 0, 6817, 6815, 1, 0, 0, 0, 6817, 6816, 1, 0, 0, 0, 6818, 6819, 1, 0, 0, 0, 6819, 6817, 1, 0, 0, 0, 6819, 6820, 1, 0, 0, 0, 6820, 557, 1, 0, 0, 0, 6821, 6822, 5, 42, 0, 0, 6822, 6823, 5, 2237, 0, 0, 6823, 6835, 3, 2354, 1177, 0, 6824, 6836, 3, 562, 281, 0, 6825, 6836, 3, 566, 283, 0, 6826, 6836, 3, 568, 284, 0, 6827, 6836, 3, 570, 285, 0, 6828, 6836, 3, 572, 286, 0, 6829, 6836, 3, 576, 288, 0, 6830, 6836, 3, 578, 289, 0, 6831, 6836, 3, 580, 290, 0, 6832, 6836, 3, 584, 292, 0, 6833, 6836, 3, 766, 383, 0, 6834, 6836, 3, 594, 297, 0, 6835, 6824, 1, 0, 0, 0, 6835, 6825, 1, 0, 0, 0, 6835, 6826, 1, 0, 0, 0, 6835, 6827, 1, 0, 0, 0, 6835, 6828, 1, 0, 0, 0, 6835, 6829, 1, 0, 0, 0, 6835, 6830, 1, 0, 0, 0, 6835, 6831, 1, 0, 0, 0, 6835, 6832, 1, 0, 0, 0, 6835, 6833, 1, 0, 0, 0, 6835, 6834, 1, 0, 0, 0, 6836, 6837, 1, 0, 0, 0, 6837, 6835, 1, 0, 0, 0, 6837, 6838, 1, 0, 0, 0, 6838, 6850, 1, 0, 0, 0, 6839, 6844, 3, 2354, 1177, 0, 6840, 6841, 5, 2453, 0, 0, 6841, 6843, 3, 2354, 1177, 0, 6842, 6840, 1, 0, 0, 0, 6843, 6846, 1, 0, 0, 0, 6844, 6842, 1, 0, 0, 0, 6844, 6845, 1, 0, 0, 0, 6845, 6847, 1, 0, 0, 0, 6846, 6844, 1, 0, 0, 0, 6847, 6848, 3, 586, 293, 0, 6848, 6850, 1, 0, 0, 0, 6849, 6821, 1, 0, 0, 0, 6849, 6839, 1, 0, 0, 0, 6850, 559, 1, 0, 0, 0, 6851, 6852, 5, 469, 0, 0, 6852, 6853, 5, 2237, 0, 0, 6853, 6856, 3, 2354, 1177, 0, 6854, 6855, 5, 691, 0, 0, 6855, 6857, 5, 545, 0, 0, 6856, 6854, 1, 0, 0, 0, 6856, 6857, 1, 0, 0, 0, 6857, 6859, 1, 0, 0, 0, 6858, 6860, 5, 179, 0, 0, 6859, 6858, 1, 0, 0, 0, 6859, 6860, 1, 0, 0, 0, 6860, 561, 1, 0, 0, 0, 6861, 6864, 3, 564, 282, 0, 6862, 6863, 5, 1562, 0, 0, 6863, 6865, 3, 2404, 1202, 0, 6864, 6862, 1, 0, 0, 0, 6864, 6865, 1, 0, 0, 0, 6865, 563, 1, 0, 0, 0, 6866, 6867, 5, 685, 0, 0, 6867, 6868, 5, 160, 0, 0, 6868, 6869, 3, 2404, 1202, 0, 6869, 565, 1, 0, 0, 0, 6870, 6871, 5, 685, 0, 0, 6871, 6874, 7, 73, 0, 0, 6872, 6873, 5, 69, 0, 0, 6873, 6875, 3, 2400, 1200, 0, 6874, 6872, 1, 0, 0, 0, 6874, 6875, 1, 0, 0, 0, 6875, 567, 1, 0, 0, 0, 6876, 6877, 7, 74, 0, 0, 6877, 6878, 5, 2080, 0, 0, 6878, 6879, 3, 2404, 1202, 0, 6879, 569, 1, 0, 0, 0, 6880, 6883, 5, 1490, 0, 0, 6881, 6884, 3, 1176, 588, 0, 6882, 6884, 5, 2185, 0, 0, 6883, 6881, 1, 0, 0, 0, 6883, 6882, 1, 0, 0, 0, 6884, 6885, 1, 0, 0, 0, 6885, 6886, 5, 1259, 0, 0, 6886, 6887, 3, 2404, 1202, 0, 6887, 571, 1, 0, 0, 0, 6888, 6889, 5, 1463, 0, 0, 6889, 6890, 3, 2404, 1202, 0, 6890, 573, 1, 0, 0, 0, 6891, 6896, 3, 2308, 1154, 0, 6892, 6893, 5, 2453, 0, 0, 6893, 6895, 3, 2308, 1154, 0, 6894, 6892, 1, 0, 0, 0, 6895, 6898, 1, 0, 0, 0, 6896, 6894, 1, 0, 0, 0, 6896, 6897, 1, 0, 0, 0, 6897, 6915, 1, 0, 0, 0, 6898, 6896, 1, 0, 0, 0, 6899, 6911, 5, 38, 0, 0, 6900, 6901, 5, 534, 0, 0, 6901, 6906, 3, 2308, 1154, 0, 6902, 6903, 5, 2453, 0, 0, 6903, 6905, 3, 2308, 1154, 0, 6904, 6902, 1, 0, 0, 0, 6905, 6908, 1, 0, 0, 0, 6906, 6904, 1, 0, 0, 0, 6906, 6907, 1, 0, 0, 0, 6907, 6910, 1, 0, 0, 0, 6908, 6906, 1, 0, 0, 0, 6909, 6900, 1, 0, 0, 0, 6910, 6913, 1, 0, 0, 0, 6911, 6909, 1, 0, 0, 0, 6911, 6912, 1, 0, 0, 0, 6912, 6915, 1, 0, 0, 0, 6913, 6911, 1, 0, 0, 0, 6914, 6891, 1, 0, 0, 0, 6914, 6899, 1, 0, 0, 0, 6915, 575, 1, 0, 0, 0, 6916, 6917, 5, 389, 0, 0, 6917, 6920, 5, 1593, 0, 0, 6918, 6921, 5, 1133, 0, 0, 6919, 6921, 3, 574, 287, 0, 6920, 6918, 1, 0, 0, 0, 6920, 6919, 1, 0, 0, 0, 6921, 577, 1, 0, 0, 0, 6922, 6923, 5, 1356, 0, 0, 6923, 6924, 5, 551, 0, 0, 6924, 579, 1, 0, 0, 0, 6925, 6926, 5, 7, 0, 0, 6926, 6927, 7, 75, 0, 0, 6927, 581, 1, 0, 0, 0, 6928, 6929, 5, 499, 0, 0, 6929, 6930, 5, 485, 0, 0, 6930, 583, 1, 0, 0, 0, 6931, 6941, 3, 582, 291, 0, 6932, 6933, 5, 620, 0, 0, 6933, 6938, 3, 2410, 1205, 0, 6934, 6935, 5, 2453, 0, 0, 6935, 6937, 3, 2410, 1205, 0, 6936, 6934, 1, 0, 0, 0, 6937, 6940, 1, 0, 0, 0, 6938, 6936, 1, 0, 0, 0, 6938, 6939, 1, 0, 0, 0, 6939, 6942, 1, 0, 0, 0, 6940, 6938, 1, 0, 0, 0, 6941, 6932, 1, 0, 0, 0, 6941, 6942, 1, 0, 0, 0, 6942, 6944, 1, 0, 0, 0, 6943, 6945, 5, 616, 0, 0, 6944, 6943, 1, 0, 0, 0, 6944, 6945, 1, 0, 0, 0, 6945, 585, 1, 0, 0, 0, 6946, 6947, 5, 1589, 0, 0, 6947, 6948, 5, 280, 0, 0, 6948, 6952, 5, 2103, 0, 0, 6949, 6950, 5, 514, 0, 0, 6950, 6953, 5, 2235, 0, 0, 6951, 6953, 3, 2354, 1177, 0, 6952, 6949, 1, 0, 0, 0, 6952, 6951, 1, 0, 0, 0, 6953, 6986, 1, 0, 0, 0, 6954, 6955, 5, 647, 0, 0, 6955, 6956, 5, 280, 0, 0, 6956, 6983, 5, 2103, 0, 0, 6957, 6958, 5, 514, 0, 0, 6958, 6984, 5, 2235, 0, 0, 6959, 6967, 3, 2354, 1177, 0, 6960, 6965, 5, 2308, 0, 0, 6961, 6962, 5, 1137, 0, 0, 6962, 6966, 5, 1595, 0, 0, 6963, 6964, 5, 1593, 0, 0, 6964, 6966, 3, 574, 287, 0, 6965, 6961, 1, 0, 0, 0, 6965, 6963, 1, 0, 0, 0, 6966, 6968, 1, 0, 0, 0, 6967, 6960, 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 6971, 1, 0, 0, 0, 6969, 6970, 5, 87, 0, 0, 6970, 6972, 5, 1564, 0, 0, 6971, 6969, 1, 0, 0, 0, 6971, 6972, 1, 0, 0, 0, 6972, 6981, 1, 0, 0, 0, 6973, 6974, 5, 86, 0, 0, 6974, 6979, 5, 2246, 0, 0, 6975, 6980, 5, 1356, 0, 0, 6976, 6980, 5, 187, 0, 0, 6977, 6978, 5, 446, 0, 0, 6978, 6980, 5, 997, 0, 0, 6979, 6975, 1, 0, 0, 0, 6979, 6976, 1, 0, 0, 0, 6979, 6977, 1, 0, 0, 0, 6980, 6982, 1, 0, 0, 0, 6981, 6973, 1, 0, 0, 0, 6981, 6982, 1, 0, 0, 0, 6982, 6984, 1, 0, 0, 0, 6983, 6957, 1, 0, 0, 0, 6983, 6959, 1, 0, 0, 0, 6984, 6986, 1, 0, 0, 0, 6985, 6946, 1, 0, 0, 0, 6985, 6954, 1, 0, 0, 0, 6986, 587, 1, 0, 0, 0, 6987, 6988, 5, 2447, 0, 0, 6988, 6993, 3, 2404, 1202, 0, 6989, 6990, 5, 2453, 0, 0, 6990, 6992, 3, 2404, 1202, 0, 6991, 6989, 1, 0, 0, 0, 6992, 6995, 1, 0, 0, 0, 6993, 6991, 1, 0, 0, 0, 6993, 6994, 1, 0, 0, 0, 6994, 6996, 1, 0, 0, 0, 6995, 6993, 1, 0, 0, 0, 6996, 6997, 5, 2448, 0, 0, 6997, 589, 1, 0, 0, 0, 6998, 6999, 5, 1671, 0, 0, 6999, 7000, 5, 292, 0, 0, 7000, 7004, 5, 2472, 0, 0, 7001, 7005, 5, 38, 0, 0, 7002, 7005, 5, 389, 0, 0, 7003, 7005, 3, 588, 294, 0, 7004, 7001, 1, 0, 0, 0, 7004, 7002, 1, 0, 0, 0, 7004, 7003, 1, 0, 0, 0, 7005, 591, 1, 0, 0, 0, 7006, 7007, 7, 72, 0, 0, 7007, 7008, 5, 292, 0, 0, 7008, 7009, 5, 2472, 0, 0, 7009, 7010, 3, 588, 294, 0, 7010, 593, 1, 0, 0, 0, 7011, 7018, 3, 590, 295, 0, 7012, 7015, 3, 592, 296, 0, 7013, 7014, 5, 620, 0, 0, 7014, 7016, 3, 2300, 1150, 0, 7015, 7013, 1, 0, 0, 0, 7015, 7016, 1, 0, 0, 0, 7016, 7018, 1, 0, 0, 0, 7017, 7011, 1, 0, 0, 0, 7017, 7012, 1, 0, 0, 0, 7018, 595, 1, 0, 0, 0, 7019, 7020, 5, 27, 0, 0, 7020, 7021, 5, 816, 0, 0, 7021, 7026, 5, 906, 0, 0, 7022, 7027, 3, 598, 299, 0, 7023, 7027, 3, 620, 310, 0, 7024, 7027, 3, 650, 325, 0, 7025, 7027, 3, 660, 330, 0, 7026, 7022, 1, 0, 0, 0, 7026, 7023, 1, 0, 0, 0, 7026, 7024, 1, 0, 0, 0, 7026, 7025, 1, 0, 0, 0, 7027, 597, 1, 0, 0, 0, 7028, 7038, 3, 600, 300, 0, 7029, 7038, 3, 602, 301, 0, 7030, 7038, 3, 606, 303, 0, 7031, 7038, 3, 608, 304, 0, 7032, 7038, 3, 610, 305, 0, 7033, 7038, 3, 612, 306, 0, 7034, 7038, 3, 614, 307, 0, 7035, 7038, 3, 616, 308, 0, 7036, 7038, 3, 618, 309, 0, 7037, 7028, 1, 0, 0, 0, 7037, 7029, 1, 0, 0, 0, 7037, 7030, 1, 0, 0, 0, 7037, 7031, 1, 0, 0, 0, 7037, 7032, 1, 0, 0, 0, 7037, 7033, 1, 0, 0, 0, 7037, 7034, 1, 0, 0, 0, 7037, 7035, 1, 0, 0, 0, 7037, 7036, 1, 0, 0, 0, 7038, 599, 1, 0, 0, 0, 7039, 7050, 5, 321, 0, 0, 7040, 7041, 5, 820, 0, 0, 7041, 7051, 5, 2443, 0, 0, 7042, 7044, 5, 873, 0, 0, 7043, 7042, 1, 0, 0, 0, 7043, 7044, 1, 0, 0, 0, 7044, 7045, 1, 0, 0, 0, 7045, 7046, 5, 94, 0, 0, 7046, 7047, 5, 820, 0, 0, 7047, 7048, 5, 628, 0, 0, 7048, 7049, 5, 820, 0, 0, 7049, 7051, 5, 2443, 0, 0, 7050, 7040, 1, 0, 0, 0, 7050, 7043, 1, 0, 0, 0, 7051, 7052, 1, 0, 0, 0, 7052, 7053, 5, 685, 0, 0, 7053, 7054, 5, 160, 0, 0, 7054, 7055, 3, 666, 333, 0, 7055, 601, 1, 0, 0, 0, 7056, 7057, 5, 1671, 0, 0, 7057, 7058, 5, 820, 0, 0, 7058, 7060, 5, 1264, 0, 0, 7059, 7061, 3, 604, 302, 0, 7060, 7059, 1, 0, 0, 0, 7060, 7061, 1, 0, 0, 0, 7061, 7062, 1, 0, 0, 0, 7062, 7064, 3, 644, 322, 0, 7063, 7065, 3, 766, 383, 0, 7064, 7063, 1, 0, 0, 0, 7064, 7065, 1, 0, 0, 0, 7065, 603, 1, 0, 0, 0, 7066, 7067, 5, 616, 0, 0, 7067, 7068, 5, 820, 0, 0, 7068, 605, 1, 0, 0, 0, 7069, 7070, 5, 1671, 0, 0, 7070, 7071, 5, 820, 0, 0, 7071, 7073, 5, 218, 0, 0, 7072, 7074, 3, 644, 322, 0, 7073, 7072, 1, 0, 0, 0, 7073, 7074, 1, 0, 0, 0, 7074, 7076, 1, 0, 0, 0, 7075, 7077, 3, 766, 383, 0, 7076, 7075, 1, 0, 0, 0, 7076, 7077, 1, 0, 0, 0, 7077, 607, 1, 0, 0, 0, 7078, 7079, 5, 102, 0, 0, 7079, 7082, 5, 820, 0, 0, 7080, 7081, 5, 2246, 0, 0, 7081, 7083, 5, 2443, 0, 0, 7082, 7080, 1, 0, 0, 0, 7082, 7083, 1, 0, 0, 0, 7083, 7085, 1, 0, 0, 0, 7084, 7086, 3, 604, 302, 0, 7085, 7084, 1, 0, 0, 0, 7085, 7086, 1, 0, 0, 0, 7086, 7087, 1, 0, 0, 0, 7087, 7090, 3, 644, 322, 0, 7088, 7089, 5, 2141, 0, 0, 7089, 7091, 5, 2443, 0, 0, 7090, 7088, 1, 0, 0, 0, 7090, 7091, 1, 0, 0, 0, 7091, 609, 1, 0, 0, 0, 7092, 7093, 5, 42, 0, 0, 7093, 7094, 5, 820, 0, 0, 7094, 7096, 5, 1356, 0, 0, 7095, 7097, 3, 604, 302, 0, 7096, 7095, 1, 0, 0, 0, 7096, 7097, 1, 0, 0, 0, 7097, 7098, 1, 0, 0, 0, 7098, 7099, 5, 685, 0, 0, 7099, 7100, 5, 160, 0, 0, 7100, 7101, 3, 666, 333, 0, 7101, 7102, 5, 1671, 0, 0, 7102, 7104, 3, 666, 333, 0, 7103, 7105, 3, 662, 331, 0, 7104, 7103, 1, 0, 0, 0, 7104, 7105, 1, 0, 0, 0, 7105, 611, 1, 0, 0, 0, 7106, 7107, 5, 946, 0, 0, 7107, 7108, 5, 820, 0, 0, 7108, 7110, 5, 2443, 0, 0, 7109, 7111, 3, 664, 332, 0, 7110, 7109, 1, 0, 0, 0, 7110, 7111, 1, 0, 0, 0, 7111, 7112, 1, 0, 0, 0, 7112, 7113, 5, 49, 0, 0, 7113, 7114, 5, 820, 0, 0, 7114, 7116, 5, 2443, 0, 0, 7115, 7117, 3, 664, 332, 0, 7116, 7115, 1, 0, 0, 0, 7116, 7117, 1, 0, 0, 0, 7117, 7118, 1, 0, 0, 0, 7118, 7119, 5, 779, 0, 0, 7119, 7120, 5, 1021, 0, 0, 7120, 7121, 5, 820, 0, 0, 7121, 7122, 5, 2443, 0, 0, 7122, 7123, 3, 664, 332, 0, 7123, 613, 1, 0, 0, 0, 7124, 7125, 5, 946, 0, 0, 7125, 7126, 5, 820, 0, 0, 7126, 7128, 5, 2443, 0, 0, 7127, 7129, 3, 664, 332, 0, 7128, 7127, 1, 0, 0, 0, 7128, 7129, 1, 0, 0, 0, 7129, 7130, 1, 0, 0, 0, 7130, 7131, 5, 779, 0, 0, 7131, 7132, 5, 544, 0, 0, 7132, 7133, 5, 820, 0, 0, 7133, 7134, 5, 2443, 0, 0, 7134, 7136, 3, 664, 332, 0, 7135, 7137, 3, 662, 331, 0, 7136, 7135, 1, 0, 0, 0, 7136, 7137, 1, 0, 0, 0, 7137, 615, 1, 0, 0, 0, 7138, 7140, 5, 616, 0, 0, 7139, 7138, 1, 0, 0, 0, 7139, 7140, 1, 0, 0, 0, 7140, 7141, 1, 0, 0, 0, 7141, 7142, 5, 2387, 0, 0, 7142, 7143, 5, 820, 0, 0, 7143, 7144, 5, 685, 0, 0, 7144, 7145, 5, 160, 0, 0, 7145, 7146, 3, 666, 333, 0, 7146, 7147, 5, 628, 0, 0, 7147, 7148, 5, 2388, 0, 0, 7148, 7150, 5, 820, 0, 0, 7149, 7151, 3, 604, 302, 0, 7150, 7149, 1, 0, 0, 0, 7150, 7151, 1, 0, 0, 0, 7151, 7152, 1, 0, 0, 0, 7152, 7154, 3, 644, 322, 0, 7153, 7155, 3, 662, 331, 0, 7154, 7153, 1, 0, 0, 0, 7154, 7155, 1, 0, 0, 0, 7155, 617, 1, 0, 0, 0, 7156, 7157, 5, 2389, 0, 0, 7157, 7158, 5, 820, 0, 0, 7158, 7159, 5, 685, 0, 0, 7159, 7160, 5, 160, 0, 0, 7160, 7161, 3, 666, 333, 0, 7161, 7162, 5, 2308, 0, 0, 7162, 7163, 5, 2388, 0, 0, 7163, 7165, 5, 820, 0, 0, 7164, 7166, 3, 604, 302, 0, 7165, 7164, 1, 0, 0, 0, 7165, 7166, 1, 0, 0, 0, 7166, 7167, 1, 0, 0, 0, 7167, 7169, 3, 644, 322, 0, 7168, 7170, 3, 662, 331, 0, 7169, 7168, 1, 0, 0, 0, 7169, 7170, 1, 0, 0, 0, 7170, 619, 1, 0, 0, 0, 7171, 7181, 3, 622, 311, 0, 7172, 7181, 3, 624, 312, 0, 7173, 7181, 3, 630, 315, 0, 7174, 7181, 3, 632, 316, 0, 7175, 7181, 3, 634, 317, 0, 7176, 7181, 3, 636, 318, 0, 7177, 7181, 3, 638, 319, 0, 7178, 7181, 3, 640, 320, 0, 7179, 7181, 3, 642, 321, 0, 7180, 7171, 1, 0, 0, 0, 7180, 7172, 1, 0, 0, 0, 7180, 7173, 1, 0, 0, 0, 7180, 7174, 1, 0, 0, 0, 7180, 7175, 1, 0, 0, 0, 7180, 7176, 1, 0, 0, 0, 7180, 7177, 1, 0, 0, 0, 7180, 7178, 1, 0, 0, 0, 7180, 7179, 1, 0, 0, 0, 7181, 621, 1, 0, 0, 0, 7182, 7184, 5, 1671, 0, 0, 7183, 7185, 5, 506, 0, 0, 7184, 7183, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7186, 1, 0, 0, 0, 7186, 7193, 5, 816, 0, 0, 7187, 7188, 3, 626, 313, 0, 7188, 7189, 5, 2469, 0, 0, 7189, 7191, 1, 0, 0, 0, 7190, 7187, 1, 0, 0, 0, 7190, 7191, 1, 0, 0, 0, 7191, 7192, 1, 0, 0, 0, 7192, 7194, 3, 628, 314, 0, 7193, 7190, 1, 0, 0, 0, 7193, 7194, 1, 0, 0, 0, 7194, 7196, 1, 0, 0, 0, 7195, 7197, 3, 648, 324, 0, 7196, 7195, 1, 0, 0, 0, 7196, 7197, 1, 0, 0, 0, 7197, 7199, 1, 0, 0, 0, 7198, 7200, 3, 646, 323, 0, 7199, 7198, 1, 0, 0, 0, 7199, 7200, 1, 0, 0, 0, 7200, 7202, 1, 0, 0, 0, 7201, 7203, 3, 604, 302, 0, 7202, 7201, 1, 0, 0, 0, 7202, 7203, 1, 0, 0, 0, 7203, 7204, 1, 0, 0, 0, 7204, 7206, 3, 644, 322, 0, 7205, 7207, 3, 662, 331, 0, 7206, 7205, 1, 0, 0, 0, 7206, 7207, 1, 0, 0, 0, 7207, 7209, 1, 0, 0, 0, 7208, 7210, 3, 766, 383, 0, 7209, 7208, 1, 0, 0, 0, 7209, 7210, 1, 0, 0, 0, 7210, 623, 1, 0, 0, 0, 7211, 7213, 5, 321, 0, 0, 7212, 7214, 5, 506, 0, 0, 7213, 7212, 1, 0, 0, 0, 7213, 7214, 1, 0, 0, 0, 7214, 7215, 1, 0, 0, 0, 7215, 7222, 5, 816, 0, 0, 7216, 7217, 3, 626, 313, 0, 7217, 7218, 5, 2469, 0, 0, 7218, 7220, 1, 0, 0, 0, 7219, 7216, 1, 0, 0, 0, 7219, 7220, 1, 0, 0, 0, 7220, 7221, 1, 0, 0, 0, 7221, 7223, 3, 628, 314, 0, 7222, 7219, 1, 0, 0, 0, 7222, 7223, 1, 0, 0, 0, 7223, 7225, 1, 0, 0, 0, 7224, 7226, 3, 648, 324, 0, 7225, 7224, 1, 0, 0, 0, 7225, 7226, 1, 0, 0, 0, 7226, 7228, 1, 0, 0, 0, 7227, 7229, 3, 646, 323, 0, 7228, 7227, 1, 0, 0, 0, 7228, 7229, 1, 0, 0, 0, 7229, 7231, 1, 0, 0, 0, 7230, 7232, 3, 604, 302, 0, 7231, 7230, 1, 0, 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7233, 1, 0, 0, 0, 7233, 7235, 3, 644, 322, 0, 7234, 7236, 3, 662, 331, 0, 7235, 7234, 1, 0, 0, 0, 7235, 7236, 1, 0, 0, 0, 7236, 7238, 1, 0, 0, 0, 7237, 7239, 3, 766, 383, 0, 7238, 7237, 1, 0, 0, 0, 7238, 7239, 1, 0, 0, 0, 7239, 625, 1, 0, 0, 0, 7240, 7241, 5, 2443, 0, 0, 7241, 627, 1, 0, 0, 0, 7242, 7243, 5, 2443, 0, 0, 7243, 629, 1, 0, 0, 0, 7244, 7246, 5, 2241, 0, 0, 7245, 7247, 5, 506, 0, 0, 7246, 7245, 1, 0, 0, 0, 7246, 7247, 1, 0, 0, 0, 7247, 7248, 1, 0, 0, 0, 7248, 7249, 5, 816, 0, 0, 7249, 7251, 5, 2443, 0, 0, 7250, 7252, 3, 648, 324, 0, 7251, 7250, 1, 0, 0, 0, 7251, 7252, 1, 0, 0, 0, 7252, 7254, 1, 0, 0, 0, 7253, 7255, 3, 604, 302, 0, 7254, 7253, 1, 0, 0, 0, 7254, 7255, 1, 0, 0, 0, 7255, 7256, 1, 0, 0, 0, 7256, 7258, 3, 644, 322, 0, 7257, 7259, 3, 662, 331, 0, 7258, 7257, 1, 0, 0, 0, 7258, 7259, 1, 0, 0, 0, 7259, 631, 1, 0, 0, 0, 7260, 7261, 5, 1671, 0, 0, 7261, 7262, 5, 2085, 0, 0, 7262, 7263, 5, 2443, 0, 0, 7263, 7264, 5, 620, 0, 0, 7264, 7266, 5, 2443, 0, 0, 7265, 7267, 3, 604, 302, 0, 7266, 7265, 1, 0, 0, 0, 7266, 7267, 1, 0, 0, 0, 7267, 7268, 1, 0, 0, 0, 7268, 7270, 3, 644, 322, 0, 7269, 7271, 3, 662, 331, 0, 7270, 7269, 1, 0, 0, 0, 7270, 7271, 1, 0, 0, 0, 7271, 633, 1, 0, 0, 0, 7272, 7274, 5, 554, 0, 0, 7273, 7275, 5, 506, 0, 0, 7274, 7273, 1, 0, 0, 0, 7274, 7275, 1, 0, 0, 0, 7275, 7276, 1, 0, 0, 0, 7276, 7277, 5, 819, 0, 0, 7277, 7278, 5, 2308, 0, 0, 7278, 7279, 5, 1638, 0, 0, 7279, 7280, 3, 670, 335, 0, 7280, 7281, 5, 2141, 0, 0, 7281, 7283, 3, 1458, 729, 0, 7282, 7284, 3, 604, 302, 0, 7283, 7282, 1, 0, 0, 0, 7283, 7284, 1, 0, 0, 0, 7284, 7285, 1, 0, 0, 0, 7285, 7303, 3, 644, 322, 0, 7286, 7287, 5, 2308, 0, 0, 7287, 7288, 5, 686, 0, 0, 7288, 7301, 5, 738, 0, 0, 7289, 7294, 5, 2443, 0, 0, 7290, 7291, 5, 2453, 0, 0, 7291, 7293, 5, 2443, 0, 0, 7292, 7290, 1, 0, 0, 0, 7293, 7296, 1, 0, 0, 0, 7294, 7292, 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7302, 1, 0, 0, 0, 7296, 7294, 1, 0, 0, 0, 7297, 7298, 5, 2447, 0, 0, 7298, 7299, 3, 1896, 948, 0, 7299, 7300, 5, 2448, 0, 0, 7300, 7302, 1, 0, 0, 0, 7301, 7289, 1, 0, 0, 0, 7301, 7297, 1, 0, 0, 0, 7302, 7304, 1, 0, 0, 0, 7303, 7286, 1, 0, 0, 0, 7303, 7304, 1, 0, 0, 0, 7304, 635, 1, 0, 0, 0, 7305, 7307, 5, 700, 0, 0, 7306, 7308, 5, 506, 0, 0, 7307, 7306, 1, 0, 0, 0, 7307, 7308, 1, 0, 0, 0, 7308, 7309, 1, 0, 0, 0, 7309, 7310, 5, 819, 0, 0, 7310, 7311, 5, 2308, 0, 0, 7311, 7312, 5, 1638, 0, 0, 7312, 7313, 3, 670, 335, 0, 7313, 7314, 5, 628, 0, 0, 7314, 7316, 3, 1458, 729, 0, 7315, 7317, 3, 604, 302, 0, 7316, 7315, 1, 0, 0, 0, 7316, 7317, 1, 0, 0, 0, 7317, 7318, 1, 0, 0, 0, 7318, 7320, 3, 644, 322, 0, 7319, 7321, 3, 662, 331, 0, 7320, 7319, 1, 0, 0, 0, 7320, 7321, 1, 0, 0, 0, 7321, 637, 1, 0, 0, 0, 7322, 7324, 5, 1671, 0, 0, 7323, 7325, 5, 506, 0, 0, 7324, 7323, 1, 0, 0, 0, 7324, 7325, 1, 0, 0, 0, 7325, 7326, 1, 0, 0, 0, 7326, 7327, 5, 816, 0, 0, 7327, 7328, 5, 685, 0, 0, 7328, 7329, 5, 160, 0, 0, 7329, 7331, 3, 670, 335, 0, 7330, 7332, 3, 604, 302, 0, 7331, 7330, 1, 0, 0, 0, 7331, 7332, 1, 0, 0, 0, 7332, 7333, 1, 0, 0, 0, 7333, 7334, 5, 950, 0, 0, 7334, 7335, 5, 2246, 0, 0, 7335, 7337, 3, 666, 333, 0, 7336, 7338, 3, 662, 331, 0, 7337, 7336, 1, 0, 0, 0, 7337, 7338, 1, 0, 0, 0, 7338, 639, 1, 0, 0, 0, 7339, 7341, 5, 1671, 0, 0, 7340, 7342, 5, 506, 0, 0, 7341, 7340, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7343, 1, 0, 0, 0, 7343, 7344, 5, 816, 0, 0, 7344, 7345, 5, 685, 0, 0, 7345, 7346, 5, 160, 0, 0, 7346, 7348, 3, 670, 335, 0, 7347, 7349, 3, 604, 302, 0, 7348, 7347, 1, 0, 0, 0, 7348, 7349, 1, 0, 0, 0, 7349, 7350, 1, 0, 0, 0, 7350, 7351, 5, 1588, 0, 0, 7351, 7352, 5, 950, 0, 0, 7352, 7353, 5, 2246, 0, 0, 7353, 7354, 3, 670, 335, 0, 7354, 641, 1, 0, 0, 0, 7355, 7357, 5, 992, 0, 0, 7356, 7358, 5, 506, 0, 0, 7357, 7356, 1, 0, 0, 0, 7357, 7358, 1, 0, 0, 0, 7358, 7359, 1, 0, 0, 0, 7359, 7360, 5, 819, 0, 0, 7360, 7361, 5, 2141, 0, 0, 7361, 7362, 5, 1021, 0, 0, 7362, 7363, 5, 820, 0, 0, 7363, 7364, 5, 2443, 0, 0, 7364, 7365, 5, 685, 0, 0, 7365, 7366, 5, 160, 0, 0, 7366, 7367, 3, 666, 333, 0, 7367, 7369, 5, 628, 0, 0, 7368, 7370, 5, 616, 0, 0, 7369, 7368, 1, 0, 0, 0, 7369, 7370, 1, 0, 0, 0, 7370, 7371, 1, 0, 0, 0, 7371, 7372, 5, 820, 0, 0, 7372, 7373, 5, 685, 0, 0, 7373, 7374, 5, 160, 0, 0, 7374, 7389, 3, 666, 333, 0, 7375, 7376, 5, 2308, 0, 0, 7376, 7377, 5, 686, 0, 0, 7377, 7387, 5, 738, 0, 0, 7378, 7383, 5, 2443, 0, 0, 7379, 7380, 5, 2453, 0, 0, 7380, 7382, 5, 2443, 0, 0, 7381, 7379, 1, 0, 0, 0, 7382, 7385, 1, 0, 0, 0, 7383, 7381, 1, 0, 0, 0, 7383, 7384, 1, 0, 0, 0, 7384, 7388, 1, 0, 0, 0, 7385, 7383, 1, 0, 0, 0, 7386, 7388, 3, 1896, 948, 0, 7387, 7378, 1, 0, 0, 0, 7387, 7386, 1, 0, 0, 0, 7388, 7390, 1, 0, 0, 0, 7389, 7375, 1, 0, 0, 0, 7389, 7390, 1, 0, 0, 0, 7390, 7392, 1, 0, 0, 0, 7391, 7393, 3, 662, 331, 0, 7392, 7391, 1, 0, 0, 0, 7392, 7393, 1, 0, 0, 0, 7393, 643, 1, 0, 0, 0, 7394, 7395, 5, 685, 0, 0, 7395, 7399, 5, 160, 0, 0, 7396, 7397, 5, 560, 0, 0, 7397, 7400, 5, 1763, 0, 0, 7398, 7400, 3, 666, 333, 0, 7399, 7396, 1, 0, 0, 0, 7399, 7398, 1, 0, 0, 0, 7400, 645, 1, 0, 0, 0, 7401, 7402, 5, 2246, 0, 0, 7402, 7403, 5, 2390, 0, 0, 7403, 7404, 5, 2443, 0, 0, 7404, 647, 1, 0, 0, 0, 7405, 7406, 5, 2246, 0, 0, 7406, 7407, 5, 2085, 0, 0, 7407, 7408, 5, 2443, 0, 0, 7408, 649, 1, 0, 0, 0, 7409, 7414, 3, 652, 326, 0, 7410, 7414, 3, 654, 327, 0, 7411, 7414, 3, 656, 328, 0, 7412, 7414, 3, 658, 329, 0, 7413, 7409, 1, 0, 0, 0, 7413, 7410, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7413, 7412, 1, 0, 0, 0, 7414, 651, 1, 0, 0, 0, 7415, 7416, 7, 76, 0, 0, 7416, 7417, 5, 1638, 0, 0, 7417, 7418, 5, 2443, 0, 0, 7418, 7419, 5, 620, 0, 0, 7419, 7420, 5, 214, 0, 0, 7420, 7422, 5, 2443, 0, 0, 7421, 7423, 3, 648, 324, 0, 7422, 7421, 1, 0, 0, 0, 7422, 7423, 1, 0, 0, 0, 7423, 7425, 1, 0, 0, 0, 7424, 7426, 3, 604, 302, 0, 7425, 7424, 1, 0, 0, 0, 7425, 7426, 1, 0, 0, 0, 7426, 7428, 1, 0, 0, 0, 7427, 7429, 3, 644, 322, 0, 7428, 7427, 1, 0, 0, 0, 7428, 7429, 1, 0, 0, 0, 7429, 7431, 1, 0, 0, 0, 7430, 7432, 3, 662, 331, 0, 7431, 7430, 1, 0, 0, 0, 7431, 7432, 1, 0, 0, 0, 7432, 653, 1, 0, 0, 0, 7433, 7434, 5, 403, 0, 0, 7434, 7435, 5, 1638, 0, 0, 7435, 7436, 5, 620, 0, 0, 7436, 7437, 5, 214, 0, 0, 7437, 7439, 5, 2443, 0, 0, 7438, 7440, 3, 604, 302, 0, 7439, 7438, 1, 0, 0, 0, 7439, 7440, 1, 0, 0, 0, 7440, 7441, 1, 0, 0, 0, 7441, 7443, 3, 644, 322, 0, 7442, 7444, 3, 662, 331, 0, 7443, 7442, 1, 0, 0, 0, 7443, 7444, 1, 0, 0, 0, 7444, 655, 1, 0, 0, 0, 7445, 7446, 7, 76, 0, 0, 7446, 7447, 5, 1638, 0, 0, 7447, 7448, 5, 2443, 0, 0, 7448, 7449, 5, 620, 0, 0, 7449, 7450, 5, 214, 0, 0, 7450, 7452, 5, 2443, 0, 0, 7451, 7453, 3, 648, 324, 0, 7452, 7451, 1, 0, 0, 0, 7452, 7453, 1, 0, 0, 0, 7453, 7454, 1, 0, 0, 0, 7454, 7456, 5, 2141, 0, 0, 7455, 7457, 5, 873, 0, 0, 7456, 7455, 1, 0, 0, 0, 7456, 7457, 1, 0, 0, 0, 7457, 7458, 1, 0, 0, 0, 7458, 7459, 5, 94, 0, 0, 7459, 7460, 5, 820, 0, 0, 7460, 7461, 3, 788, 394, 0, 7461, 657, 1, 0, 0, 0, 7462, 7463, 5, 403, 0, 0, 7463, 7464, 5, 1638, 0, 0, 7464, 7465, 5, 2443, 0, 0, 7465, 7466, 5, 2461, 0, 0, 7466, 7467, 5, 620, 0, 0, 7467, 7468, 5, 214, 0, 0, 7468, 7469, 5, 2443, 0, 0, 7469, 7471, 5, 628, 0, 0, 7470, 7472, 5, 873, 0, 0, 7471, 7470, 1, 0, 0, 0, 7471, 7472, 1, 0, 0, 0, 7472, 7473, 1, 0, 0, 0, 7473, 7474, 5, 94, 0, 0, 7474, 7475, 5, 820, 0, 0, 7475, 7476, 3, 788, 394, 0, 7476, 659, 1, 0, 0, 0, 7477, 7479, 5, 1792, 0, 0, 7478, 7480, 5, 2141, 0, 0, 7479, 7478, 1, 0, 0, 0, 7479, 7480, 1, 0, 0, 0, 7480, 7481, 1, 0, 0, 0, 7481, 7482, 5, 849, 0, 0, 7482, 7483, 3, 668, 334, 0, 7483, 7484, 5, 620, 0, 0, 7484, 7485, 5, 38, 0, 0, 7485, 7486, 5, 290, 0, 0, 7486, 661, 1, 0, 0, 0, 7487, 7488, 5, 2308, 0, 0, 7488, 7491, 5, 102, 0, 0, 7489, 7490, 5, 2246, 0, 0, 7490, 7492, 5, 2443, 0, 0, 7491, 7489, 1, 0, 0, 0, 7491, 7492, 1, 0, 0, 0, 7492, 663, 1, 0, 0, 0, 7493, 7494, 5, 685, 0, 0, 7494, 7495, 5, 160, 0, 0, 7495, 7496, 3, 666, 333, 0, 7496, 665, 1, 0, 0, 0, 7497, 7498, 5, 2444, 0, 0, 7498, 667, 1, 0, 0, 0, 7499, 7500, 5, 2443, 0, 0, 7500, 669, 1, 0, 0, 0, 7501, 7502, 5, 2444, 0, 0, 7502, 671, 1, 0, 0, 0, 7503, 7508, 5, 46, 0, 0, 7504, 7505, 5, 2083, 0, 0, 7505, 7509, 3, 2342, 1171, 0, 7506, 7507, 5, 717, 0, 0, 7507, 7509, 3, 2328, 1164, 0, 7508, 7504, 1, 0, 0, 0, 7508, 7506, 1, 0, 0, 0, 7509, 7511, 1, 0, 0, 0, 7510, 7512, 3, 674, 337, 0, 7511, 7510, 1, 0, 0, 0, 7511, 7512, 1, 0, 0, 0, 7512, 7517, 1, 0, 0, 0, 7513, 7514, 5, 46, 0, 0, 7514, 7515, 5, 220, 0, 0, 7515, 7517, 3, 466, 233, 0, 7516, 7503, 1, 0, 0, 0, 7516, 7513, 1, 0, 0, 0, 7517, 7544, 1, 0, 0, 0, 7518, 7545, 3, 676, 338, 0, 7519, 7545, 3, 678, 339, 0, 7520, 7522, 5, 527, 0, 0, 7521, 7523, 5, 1949, 0, 0, 7522, 7521, 1, 0, 0, 0, 7522, 7523, 1, 0, 0, 0, 7523, 7524, 1, 0, 0, 0, 7524, 7526, 5, 1746, 0, 0, 7525, 7527, 3, 680, 340, 0, 7526, 7525, 1, 0, 0, 0, 7526, 7527, 1, 0, 0, 0, 7527, 7531, 1, 0, 0, 0, 7528, 7529, 5, 1614, 0, 0, 7529, 7530, 5, 2441, 0, 0, 7530, 7532, 7, 77, 0, 0, 7531, 7528, 1, 0, 0, 0, 7531, 7532, 1, 0, 0, 0, 7532, 7545, 1, 0, 0, 0, 7533, 7534, 5, 862, 0, 0, 7534, 7535, 5, 189, 0, 0, 7535, 7537, 5, 1607, 0, 0, 7536, 7538, 3, 684, 342, 0, 7537, 7536, 1, 0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 7545, 1, 0, 0, 0, 7539, 7541, 5, 403, 0, 0, 7540, 7542, 5, 1949, 0, 0, 7541, 7540, 1, 0, 0, 0, 7541, 7542, 1, 0, 0, 0, 7542, 7543, 1, 0, 0, 0, 7543, 7545, 5, 1746, 0, 0, 7544, 7518, 1, 0, 0, 0, 7544, 7519, 1, 0, 0, 0, 7544, 7520, 1, 0, 0, 0, 7544, 7533, 1, 0, 0, 0, 7544, 7539, 1, 0, 0, 0, 7545, 673, 1, 0, 0, 0, 7546, 7563, 5, 1348, 0, 0, 7547, 7548, 5, 2447, 0, 0, 7548, 7549, 3, 1696, 848, 0, 7549, 7550, 5, 2448, 0, 0, 7550, 7564, 1, 0, 0, 0, 7551, 7552, 5, 620, 0, 0, 7552, 7553, 5, 2447, 0, 0, 7553, 7558, 3, 686, 343, 0, 7554, 7555, 5, 2453, 0, 0, 7555, 7557, 3, 686, 343, 0, 7556, 7554, 1, 0, 0, 0, 7557, 7560, 1, 0, 0, 0, 7558, 7556, 1, 0, 0, 0, 7558, 7559, 1, 0, 0, 0, 7559, 7561, 1, 0, 0, 0, 7560, 7558, 1, 0, 0, 0, 7561, 7562, 5, 2448, 0, 0, 7562, 7564, 1, 0, 0, 0, 7563, 7547, 1, 0, 0, 0, 7563, 7551, 1, 0, 0, 0, 7564, 7585, 1, 0, 0, 0, 7565, 7582, 5, 1775, 0, 0, 7566, 7567, 5, 2447, 0, 0, 7567, 7568, 3, 1154, 577, 0, 7568, 7569, 5, 2448, 0, 0, 7569, 7583, 1, 0, 0, 0, 7570, 7571, 5, 620, 0, 0, 7571, 7572, 5, 2447, 0, 0, 7572, 7577, 3, 688, 344, 0, 7573, 7574, 5, 2453, 0, 0, 7574, 7576, 3, 688, 344, 0, 7575, 7573, 1, 0, 0, 0, 7576, 7579, 1, 0, 0, 0, 7577, 7575, 1, 0, 0, 0, 7577, 7578, 1, 0, 0, 0, 7578, 7580, 1, 0, 0, 0, 7579, 7577, 1, 0, 0, 0, 7580, 7581, 5, 2448, 0, 0, 7581, 7583, 1, 0, 0, 0, 7582, 7566, 1, 0, 0, 0, 7582, 7570, 1, 0, 0, 0, 7583, 7585, 1, 0, 0, 0, 7584, 7546, 1, 0, 0, 0, 7584, 7565, 1, 0, 0, 0, 7585, 675, 1, 0, 0, 0, 7586, 7587, 5, 2253, 0, 0, 7587, 7588, 5, 1530, 0, 0, 7588, 7593, 5, 2207, 0, 0, 7589, 7590, 5, 1671, 0, 0, 7590, 7591, 5, 349, 0, 0, 7591, 7592, 5, 2141, 0, 0, 7592, 7594, 5, 1228, 0, 0, 7593, 7589, 1, 0, 0, 0, 7593, 7594, 1, 0, 0, 0, 7594, 7616, 1, 0, 0, 0, 7595, 7596, 5, 2253, 0, 0, 7596, 7607, 5, 1771, 0, 0, 7597, 7598, 5, 179, 0, 0, 7598, 7608, 5, 578, 0, 0, 7599, 7601, 5, 179, 0, 0, 7600, 7602, 3, 682, 341, 0, 7601, 7600, 1, 0, 0, 0, 7601, 7602, 1, 0, 0, 0, 7602, 7604, 1, 0, 0, 0, 7603, 7605, 3, 2274, 1137, 0, 7604, 7603, 1, 0, 0, 0, 7604, 7605, 1, 0, 0, 0, 7605, 7608, 1, 0, 0, 0, 7606, 7608, 5, 179, 0, 0, 7607, 7597, 1, 0, 0, 0, 7607, 7599, 1, 0, 0, 0, 7607, 7606, 1, 0, 0, 0, 7607, 7608, 1, 0, 0, 0, 7608, 7610, 1, 0, 0, 0, 7609, 7611, 3, 682, 341, 0, 7610, 7609, 1, 0, 0, 0, 7610, 7611, 1, 0, 0, 0, 7611, 7613, 1, 0, 0, 0, 7612, 7614, 3, 2274, 1137, 0, 7613, 7612, 1, 0, 0, 0, 7613, 7614, 1, 0, 0, 0, 7614, 7616, 1, 0, 0, 0, 7615, 7586, 1, 0, 0, 0, 7615, 7595, 1, 0, 0, 0, 7616, 677, 1, 0, 0, 0, 7617, 7619, 5, 260, 0, 0, 7618, 7620, 5, 1949, 0, 0, 7619, 7618, 1, 0, 0, 0, 7619, 7620, 1, 0, 0, 0, 7620, 7621, 1, 0, 0, 0, 7621, 7623, 5, 1746, 0, 0, 7622, 7624, 3, 680, 340, 0, 7623, 7622, 1, 0, 0, 0, 7623, 7624, 1, 0, 0, 0, 7624, 679, 1, 0, 0, 0, 7625, 7673, 5, 620, 0, 0, 7626, 7630, 5, 2083, 0, 0, 7627, 7629, 3, 680, 340, 0, 7628, 7627, 1, 0, 0, 0, 7629, 7632, 1, 0, 0, 0, 7630, 7628, 1, 0, 0, 0, 7630, 7631, 1, 0, 0, 0, 7631, 7674, 1, 0, 0, 0, 7632, 7630, 1, 0, 0, 0, 7633, 7652, 5, 38, 0, 0, 7634, 7636, 5, 713, 0, 0, 7635, 7634, 1, 0, 0, 0, 7635, 7636, 1, 0, 0, 0, 7636, 7637, 1, 0, 0, 0, 7637, 7640, 5, 238, 0, 0, 7638, 7639, 5, 1699, 0, 0, 7639, 7641, 5, 2441, 0, 0, 7640, 7638, 1, 0, 0, 0, 7640, 7641, 1, 0, 0, 0, 7641, 7645, 1, 0, 0, 0, 7642, 7644, 3, 680, 340, 0, 7643, 7642, 1, 0, 0, 0, 7644, 7647, 1, 0, 0, 0, 7645, 7643, 1, 0, 0, 0, 7645, 7646, 1, 0, 0, 0, 7646, 7653, 1, 0, 0, 0, 7647, 7645, 1, 0, 0, 0, 7648, 7650, 5, 873, 0, 0, 7649, 7648, 1, 0, 0, 0, 7649, 7650, 1, 0, 0, 0, 7650, 7651, 1, 0, 0, 0, 7651, 7653, 5, 714, 0, 0, 7652, 7635, 1, 0, 0, 0, 7652, 7649, 1, 0, 0, 0, 7653, 7674, 1, 0, 0, 0, 7654, 7657, 5, 238, 0, 0, 7655, 7656, 5, 1699, 0, 0, 7656, 7658, 5, 2441, 0, 0, 7657, 7655, 1, 0, 0, 0, 7657, 7658, 1, 0, 0, 0, 7658, 7663, 1, 0, 0, 0, 7659, 7660, 3, 2340, 1170, 0, 7660, 7661, 5, 1699, 0, 0, 7661, 7662, 5, 2441, 0, 0, 7662, 7664, 1, 0, 0, 0, 7663, 7659, 1, 0, 0, 0, 7664, 7665, 1, 0, 0, 0, 7665, 7663, 1, 0, 0, 0, 7665, 7666, 1, 0, 0, 0, 7666, 7670, 1, 0, 0, 0, 7667, 7669, 3, 680, 340, 0, 7668, 7667, 1, 0, 0, 0, 7669, 7672, 1, 0, 0, 0, 7670, 7668, 1, 0, 0, 0, 7670, 7671, 1, 0, 0, 0, 7671, 7674, 1, 0, 0, 0, 7672, 7670, 1, 0, 0, 0, 7673, 7626, 1, 0, 0, 0, 7673, 7633, 1, 0, 0, 0, 7673, 7654, 1, 0, 0, 0, 7674, 681, 1, 0, 0, 0, 7675, 7676, 7, 78, 0, 0, 7676, 683, 1, 0, 0, 0, 7677, 7679, 5, 779, 0, 0, 7678, 7680, 3, 2342, 1171, 0, 7679, 7678, 1, 0, 0, 0, 7679, 7680, 1, 0, 0, 0, 7680, 685, 1, 0, 0, 0, 7681, 7685, 3, 2186, 1093, 0, 7682, 7683, 5, 2108, 0, 0, 7683, 7685, 3, 2400, 1200, 0, 7684, 7681, 1, 0, 0, 0, 7684, 7682, 1, 0, 0, 0, 7685, 687, 1, 0, 0, 0, 7686, 7690, 3, 2186, 1093, 0, 7687, 7688, 5, 2108, 0, 0, 7688, 7690, 3, 2400, 1200, 0, 7689, 7686, 1, 0, 0, 0, 7689, 7687, 1, 0, 0, 0, 7690, 689, 1, 0, 0, 0, 7691, 7692, 5, 77, 0, 0, 7692, 7693, 5, 1746, 0, 0, 7693, 7696, 5, 2308, 0, 0, 7694, 7697, 3, 692, 346, 0, 7695, 7697, 3, 694, 347, 0, 7696, 7694, 1, 0, 0, 0, 7696, 7695, 1, 0, 0, 0, 7697, 7699, 1, 0, 0, 0, 7698, 7700, 3, 714, 357, 0, 7699, 7698, 1, 0, 0, 0, 7699, 7700, 1, 0, 0, 0, 7700, 691, 1, 0, 0, 0, 7701, 7702, 5, 238, 0, 0, 7702, 7703, 3, 2342, 1171, 0, 7703, 7704, 5, 2440, 0, 0, 7704, 7712, 3, 2340, 1170, 0, 7705, 7706, 5, 2453, 0, 0, 7706, 7707, 3, 2342, 1171, 0, 7707, 7708, 5, 2440, 0, 0, 7708, 7709, 3, 2340, 1170, 0, 7709, 7711, 1, 0, 0, 0, 7710, 7705, 1, 0, 0, 0, 7711, 7714, 1, 0, 0, 0, 7712, 7710, 1, 0, 0, 0, 7712, 7713, 1, 0, 0, 0, 7713, 7715, 1, 0, 0, 0, 7714, 7712, 1, 0, 0, 0, 7715, 7716, 3, 698, 349, 0, 7716, 693, 1, 0, 0, 0, 7717, 7718, 5, 633, 0, 0, 7718, 7723, 3, 2320, 1160, 0, 7719, 7720, 5, 2453, 0, 0, 7720, 7722, 3, 2320, 1160, 0, 7721, 7719, 1, 0, 0, 0, 7722, 7725, 1, 0, 0, 0, 7723, 7721, 1, 0, 0, 0, 7723, 7724, 1, 0, 0, 0, 7724, 7763, 1, 0, 0, 0, 7725, 7723, 1, 0, 0, 0, 7726, 7727, 5, 1330, 0, 0, 7727, 7732, 3, 2290, 1145, 0, 7728, 7729, 5, 2453, 0, 0, 7729, 7731, 3, 2290, 1145, 0, 7730, 7728, 1, 0, 0, 0, 7731, 7734, 1, 0, 0, 0, 7732, 7730, 1, 0, 0, 0, 7732, 7733, 1, 0, 0, 0, 7733, 7763, 1, 0, 0, 0, 7734, 7732, 1, 0, 0, 0, 7735, 7736, 5, 2165, 0, 0, 7736, 7741, 3, 2314, 1157, 0, 7737, 7738, 5, 2453, 0, 0, 7738, 7740, 3, 2314, 1157, 0, 7739, 7737, 1, 0, 0, 0, 7740, 7743, 1, 0, 0, 0, 7741, 7739, 1, 0, 0, 0, 7741, 7742, 1, 0, 0, 0, 7742, 7763, 1, 0, 0, 0, 7743, 7741, 1, 0, 0, 0, 7744, 7745, 5, 714, 0, 0, 7745, 7750, 3, 2328, 1164, 0, 7746, 7747, 5, 2453, 0, 0, 7747, 7749, 3, 2328, 1164, 0, 7748, 7746, 1, 0, 0, 0, 7749, 7752, 1, 0, 0, 0, 7750, 7748, 1, 0, 0, 0, 7750, 7751, 1, 0, 0, 0, 7751, 7763, 1, 0, 0, 0, 7752, 7750, 1, 0, 0, 0, 7753, 7754, 5, 732, 0, 0, 7754, 7759, 3, 696, 348, 0, 7755, 7756, 5, 2453, 0, 0, 7756, 7758, 3, 696, 348, 0, 7757, 7755, 1, 0, 0, 0, 7758, 7761, 1, 0, 0, 0, 7759, 7757, 1, 0, 0, 0, 7759, 7760, 1, 0, 0, 0, 7760, 7763, 1, 0, 0, 0, 7761, 7759, 1, 0, 0, 0, 7762, 7717, 1, 0, 0, 0, 7762, 7726, 1, 0, 0, 0, 7762, 7735, 1, 0, 0, 0, 7762, 7744, 1, 0, 0, 0, 7762, 7753, 1, 0, 0, 0, 7763, 7775, 1, 0, 0, 0, 7764, 7776, 3, 698, 349, 0, 7765, 7768, 3, 702, 351, 0, 7766, 7767, 5, 2453, 0, 0, 7767, 7769, 3, 710, 355, 0, 7768, 7766, 1, 0, 0, 0, 7768, 7769, 1, 0, 0, 0, 7769, 7776, 1, 0, 0, 0, 7770, 7773, 3, 710, 355, 0, 7771, 7772, 5, 2453, 0, 0, 7772, 7774, 3, 702, 351, 0, 7773, 7771, 1, 0, 0, 0, 7773, 7774, 1, 0, 0, 0, 7774, 7776, 1, 0, 0, 0, 7775, 7764, 1, 0, 0, 0, 7775, 7765, 1, 0, 0, 0, 7775, 7770, 1, 0, 0, 0, 7776, 695, 1, 0, 0, 0, 7777, 7778, 3, 2404, 1202, 0, 7778, 697, 1, 0, 0, 0, 7779, 7782, 5, 2246, 0, 0, 7780, 7783, 3, 700, 350, 0, 7781, 7783, 5, 1228, 0, 0, 7782, 7780, 1, 0, 0, 0, 7782, 7781, 1, 0, 0, 0, 7783, 699, 1, 0, 0, 0, 7784, 7785, 3, 2410, 1205, 0, 7785, 701, 1, 0, 0, 0, 7786, 7787, 5, 389, 0, 0, 7787, 7788, 5, 311, 0, 0, 7788, 7789, 5, 2447, 0, 0, 7789, 7790, 3, 704, 352, 0, 7790, 7791, 5, 2453, 0, 0, 7791, 7792, 3, 706, 353, 0, 7792, 7793, 5, 2453, 0, 0, 7793, 7794, 3, 708, 354, 0, 7794, 7795, 5, 2448, 0, 0, 7795, 703, 1, 0, 0, 0, 7796, 7797, 5, 2441, 0, 0, 7797, 705, 1, 0, 0, 0, 7798, 7799, 5, 2441, 0, 0, 7799, 707, 1, 0, 0, 0, 7800, 7801, 5, 2441, 0, 0, 7801, 709, 1, 0, 0, 0, 7802, 7803, 5, 389, 0, 0, 7803, 7804, 5, 1646, 0, 0, 7804, 7805, 3, 712, 356, 0, 7805, 711, 1, 0, 0, 0, 7806, 7807, 5, 2441, 0, 0, 7807, 713, 1, 0, 0, 0, 7808, 7809, 5, 2308, 0, 0, 7809, 7810, 7, 79, 0, 0, 7810, 7811, 5, 904, 0, 0, 7811, 7812, 5, 1762, 0, 0, 7812, 7813, 5, 2081, 0, 0, 7813, 715, 1, 0, 0, 0, 7814, 7815, 4, 358, 0, 0, 7815, 7859, 5, 85, 0, 0, 7816, 7817, 5, 1412, 0, 0, 7817, 7827, 3, 718, 359, 0, 7818, 7819, 7, 80, 0, 0, 7819, 7824, 3, 730, 365, 0, 7820, 7821, 5, 2453, 0, 0, 7821, 7823, 3, 730, 365, 0, 7822, 7820, 1, 0, 0, 0, 7823, 7826, 1, 0, 0, 0, 7824, 7822, 1, 0, 0, 0, 7824, 7825, 1, 0, 0, 0, 7825, 7828, 1, 0, 0, 0, 7826, 7824, 1, 0, 0, 0, 7827, 7818, 1, 0, 0, 0, 7827, 7828, 1, 0, 0, 0, 7828, 7834, 1, 0, 0, 0, 7829, 7831, 5, 2299, 0, 0, 7830, 7832, 5, 1204, 0, 0, 7831, 7830, 1, 0, 0, 0, 7831, 7832, 1, 0, 0, 0, 7832, 7833, 1, 0, 0, 0, 7833, 7835, 5, 1786, 0, 0, 7834, 7829, 1, 0, 0, 0, 7834, 7835, 1, 0, 0, 0, 7835, 7860, 1, 0, 0, 0, 7836, 7837, 5, 296, 0, 0, 7837, 7838, 5, 998, 0, 0, 7838, 7839, 3, 1016, 508, 0, 7839, 7840, 5, 84, 0, 0, 7840, 7845, 3, 2280, 1140, 0, 7841, 7842, 5, 2453, 0, 0, 7842, 7844, 3, 2280, 1140, 0, 7843, 7841, 1, 0, 0, 0, 7844, 7847, 1, 0, 0, 0, 7845, 7843, 1, 0, 0, 0, 7845, 7846, 1, 0, 0, 0, 7846, 7857, 1, 0, 0, 0, 7847, 7845, 1, 0, 0, 0, 7848, 7849, 5, 160, 0, 0, 7849, 7854, 3, 730, 365, 0, 7850, 7851, 5, 2453, 0, 0, 7851, 7853, 3, 730, 365, 0, 7852, 7850, 1, 0, 0, 0, 7853, 7856, 1, 0, 0, 0, 7854, 7852, 1, 0, 0, 0, 7854, 7855, 1, 0, 0, 0, 7855, 7858, 1, 0, 0, 0, 7856, 7854, 1, 0, 0, 0, 7857, 7848, 1, 0, 0, 0, 7857, 7858, 1, 0, 0, 0, 7858, 7860, 1, 0, 0, 0, 7859, 7816, 1, 0, 0, 0, 7859, 7836, 1, 0, 0, 0, 7860, 717, 1, 0, 0, 0, 7861, 7862, 3, 2402, 1201, 0, 7862, 719, 1, 0, 0, 0, 7863, 7874, 5, 85, 0, 0, 7864, 7869, 3, 726, 363, 0, 7865, 7870, 3, 728, 364, 0, 7866, 7867, 5, 738, 0, 0, 7867, 7868, 5, 1667, 0, 0, 7868, 7870, 5, 336, 0, 0, 7869, 7865, 1, 0, 0, 0, 7869, 7866, 1, 0, 0, 0, 7869, 7870, 1, 0, 0, 0, 7870, 7875, 1, 0, 0, 0, 7871, 7875, 3, 732, 366, 0, 7872, 7875, 5, 1019, 0, 0, 7873, 7875, 3, 722, 361, 0, 7874, 7864, 1, 0, 0, 0, 7874, 7871, 1, 0, 0, 0, 7874, 7872, 1, 0, 0, 0, 7874, 7873, 1, 0, 0, 0, 7875, 7878, 1, 0, 0, 0, 7876, 7877, 5, 160, 0, 0, 7877, 7879, 7, 81, 0, 0, 7878, 7876, 1, 0, 0, 0, 7878, 7879, 1, 0, 0, 0, 7879, 7885, 1, 0, 0, 0, 7880, 7882, 5, 2299, 0, 0, 7881, 7883, 5, 1204, 0, 0, 7882, 7881, 1, 0, 0, 0, 7882, 7883, 1, 0, 0, 0, 7883, 7884, 1, 0, 0, 0, 7884, 7886, 5, 1786, 0, 0, 7885, 7880, 1, 0, 0, 0, 7885, 7886, 1, 0, 0, 0, 7886, 7888, 1, 0, 0, 0, 7887, 7889, 3, 724, 362, 0, 7888, 7887, 1, 0, 0, 0, 7888, 7889, 1, 0, 0, 0, 7889, 721, 1, 0, 0, 0, 7890, 7891, 4, 361, 1, 0, 7891, 7892, 5, 427, 0, 0, 7892, 7893, 3, 728, 364, 0, 7893, 723, 1, 0, 0, 0, 7894, 7895, 4, 362, 2, 0, 7895, 7896, 5, 289, 0, 0, 7896, 7897, 5, 2472, 0, 0, 7897, 7898, 7, 82, 0, 0, 7898, 725, 1, 0, 0, 0, 7899, 7905, 3, 744, 372, 0, 7900, 7902, 5, 38, 0, 0, 7901, 7903, 5, 1742, 0, 0, 7902, 7901, 1, 0, 0, 0, 7902, 7903, 1, 0, 0, 0, 7903, 7905, 1, 0, 0, 0, 7904, 7899, 1, 0, 0, 0, 7904, 7900, 1, 0, 0, 0, 7905, 7916, 1, 0, 0, 0, 7906, 7912, 5, 2453, 0, 0, 7907, 7913, 3, 744, 372, 0, 7908, 7910, 5, 38, 0, 0, 7909, 7911, 5, 1742, 0, 0, 7910, 7909, 1, 0, 0, 0, 7910, 7911, 1, 0, 0, 0, 7911, 7913, 1, 0, 0, 0, 7912, 7907, 1, 0, 0, 0, 7912, 7908, 1, 0, 0, 0, 7913, 7915, 1, 0, 0, 0, 7914, 7906, 1, 0, 0, 0, 7915, 7918, 1, 0, 0, 0, 7916, 7914, 1, 0, 0, 0, 7916, 7917, 1, 0, 0, 0, 7917, 7936, 1, 0, 0, 0, 7918, 7916, 1, 0, 0, 0, 7919, 7923, 3, 2392, 1196, 0, 7920, 7921, 5, 38, 0, 0, 7921, 7923, 5, 1459, 0, 0, 7922, 7919, 1, 0, 0, 0, 7922, 7920, 1, 0, 0, 0, 7923, 7932, 1, 0, 0, 0, 7924, 7928, 5, 2453, 0, 0, 7925, 7929, 3, 2392, 1196, 0, 7926, 7927, 5, 38, 0, 0, 7927, 7929, 5, 1459, 0, 0, 7928, 7925, 1, 0, 0, 0, 7928, 7926, 1, 0, 0, 0, 7929, 7931, 1, 0, 0, 0, 7930, 7924, 1, 0, 0, 0, 7931, 7934, 1, 0, 0, 0, 7932, 7930, 1, 0, 0, 0, 7932, 7933, 1, 0, 0, 0, 7933, 7936, 1, 0, 0, 0, 7934, 7932, 1, 0, 0, 0, 7935, 7904, 1, 0, 0, 0, 7935, 7922, 1, 0, 0, 0, 7936, 727, 1, 0, 0, 0, 7937, 7938, 5, 160, 0, 0, 7938, 7943, 3, 730, 365, 0, 7939, 7940, 5, 2453, 0, 0, 7940, 7942, 3, 730, 365, 0, 7941, 7939, 1, 0, 0, 0, 7942, 7945, 1, 0, 0, 0, 7943, 7941, 1, 0, 0, 0, 7943, 7944, 1, 0, 0, 0, 7944, 729, 1, 0, 0, 0, 7945, 7943, 1, 0, 0, 0, 7946, 7947, 3, 2410, 1205, 0, 7947, 731, 1, 0, 0, 0, 7948, 7953, 3, 734, 367, 0, 7949, 7950, 5, 2453, 0, 0, 7950, 7952, 3, 734, 367, 0, 7951, 7949, 1, 0, 0, 0, 7952, 7955, 1, 0, 0, 0, 7953, 7951, 1, 0, 0, 0, 7953, 7954, 1, 0, 0, 0, 7954, 7958, 1, 0, 0, 0, 7955, 7953, 1, 0, 0, 0, 7956, 7958, 5, 38, 0, 0, 7957, 7948, 1, 0, 0, 0, 7957, 7956, 1, 0, 0, 0, 7958, 7959, 1, 0, 0, 0, 7959, 7960, 3, 736, 368, 0, 7960, 733, 1, 0, 0, 0, 7961, 7962, 7, 58, 0, 0, 7962, 735, 1, 0, 0, 0, 7963, 7976, 5, 1259, 0, 0, 7964, 7977, 3, 740, 370, 0, 7965, 7966, 5, 426, 0, 0, 7966, 7977, 3, 2410, 1205, 0, 7967, 7968, 5, 955, 0, 0, 7968, 7969, 5, 971, 0, 0, 7969, 7977, 3, 738, 369, 0, 7970, 7971, 4, 368, 3, 0, 7971, 7972, 5, 1722, 0, 0, 7972, 7973, 5, 2154, 0, 0, 7973, 7974, 5, 1463, 0, 0, 7974, 7977, 3, 742, 371, 0, 7975, 7977, 5, 389, 0, 0, 7976, 7964, 1, 0, 0, 0, 7976, 7965, 1, 0, 0, 0, 7976, 7967, 1, 0, 0, 0, 7976, 7970, 1, 0, 0, 0, 7976, 7975, 1, 0, 0, 0, 7977, 737, 1, 0, 0, 0, 7978, 7979, 3, 2404, 1202, 0, 7979, 7980, 5, 2440, 0, 0, 7980, 7982, 1, 0, 0, 0, 7981, 7978, 1, 0, 0, 0, 7981, 7982, 1, 0, 0, 0, 7982, 7983, 1, 0, 0, 0, 7983, 7984, 3, 2404, 1202, 0, 7984, 739, 1, 0, 0, 0, 7985, 7986, 3, 2404, 1202, 0, 7986, 7987, 5, 2440, 0, 0, 7987, 7989, 1, 0, 0, 0, 7988, 7985, 1, 0, 0, 0, 7988, 7989, 1, 0, 0, 0, 7989, 7990, 1, 0, 0, 0, 7990, 7991, 3, 2404, 1202, 0, 7991, 741, 1, 0, 0, 0, 7992, 7993, 3, 2404, 1202, 0, 7993, 7994, 5, 2440, 0, 0, 7994, 7996, 1, 0, 0, 0, 7995, 7992, 1, 0, 0, 0, 7995, 7996, 1, 0, 0, 0, 7996, 7997, 1, 0, 0, 0, 7997, 7998, 3, 2404, 1202, 0, 7998, 743, 1, 0, 0, 0, 7999, 8000, 5, 42, 0, 0, 8000, 8070, 5, 1949, 0, 0, 8001, 8070, 5, 220, 0, 0, 8002, 8070, 5, 296, 0, 0, 8003, 8004, 5, 350, 0, 0, 8004, 8070, 5, 861, 0, 0, 8005, 8070, 5, 422, 0, 0, 8006, 8070, 5, 426, 0, 0, 8007, 8070, 5, 717, 0, 0, 8008, 8009, 5, 919, 0, 0, 8009, 8070, 5, 2286, 0, 0, 8010, 8011, 5, 1204, 0, 0, 8011, 8070, 5, 545, 0, 0, 8012, 8070, 5, 1315, 0, 0, 8013, 8014, 4, 372, 4, 0, 8014, 8015, 5, 1409, 0, 0, 8015, 8070, 5, 350, 0, 0, 8016, 8070, 5, 1461, 0, 0, 8017, 8070, 5, 1463, 0, 0, 8018, 8019, 5, 1473, 0, 0, 8019, 8020, 5, 350, 0, 0, 8020, 8070, 5, 861, 0, 0, 8021, 8022, 5, 1473, 0, 0, 8022, 8070, 5, 1796, 0, 0, 8023, 8070, 5, 1593, 0, 0, 8024, 8025, 5, 1596, 0, 0, 8025, 8070, 5, 1645, 0, 0, 8026, 8070, 5, 1653, 0, 0, 8027, 8070, 5, 1667, 0, 0, 8028, 8070, 5, 1796, 0, 0, 8029, 8030, 5, 1949, 0, 0, 8030, 8070, 5, 85, 0, 0, 8031, 8032, 5, 1949, 0, 0, 8032, 8070, 5, 647, 0, 0, 8033, 8070, 5, 2083, 0, 0, 8034, 8070, 5, 2080, 0, 0, 8035, 8070, 5, 2157, 0, 0, 8036, 8070, 5, 2166, 0, 0, 8037, 8070, 5, 2237, 0, 0, 8038, 8070, 5, 2286, 0, 0, 8039, 8040, 5, 42, 0, 0, 8040, 8070, 5, 1653, 0, 0, 8041, 8042, 5, 42, 0, 0, 8042, 8070, 5, 2083, 0, 0, 8043, 8044, 5, 241, 0, 0, 8044, 8070, 5, 2083, 0, 0, 8045, 8046, 5, 403, 0, 0, 8046, 8070, 5, 2083, 0, 0, 8047, 8048, 5, 542, 0, 0, 8048, 8070, 5, 1461, 0, 0, 8049, 8050, 5, 647, 0, 0, 8050, 8070, 5, 426, 0, 0, 8051, 8052, 5, 647, 0, 0, 8052, 8070, 5, 1461, 0, 0, 8053, 8054, 5, 647, 0, 0, 8054, 8070, 5, 1653, 0, 0, 8055, 8056, 5, 647, 0, 0, 8056, 8070, 5, 2083, 0, 0, 8057, 8058, 5, 647, 0, 0, 8058, 8070, 5, 2166, 0, 0, 8059, 8060, 5, 756, 0, 0, 8060, 8070, 5, 2083, 0, 0, 8061, 8062, 5, 881, 0, 0, 8062, 8070, 5, 2083, 0, 0, 8063, 8064, 5, 1647, 0, 0, 8064, 8070, 5, 1653, 0, 0, 8065, 8066, 5, 1647, 0, 0, 8066, 8070, 5, 2083, 0, 0, 8067, 8068, 5, 2207, 0, 0, 8068, 8070, 5, 2083, 0, 0, 8069, 7999, 1, 0, 0, 0, 8069, 8001, 1, 0, 0, 0, 8069, 8002, 1, 0, 0, 0, 8069, 8003, 1, 0, 0, 0, 8069, 8005, 1, 0, 0, 0, 8069, 8006, 1, 0, 0, 0, 8069, 8007, 1, 0, 0, 0, 8069, 8008, 1, 0, 0, 0, 8069, 8010, 1, 0, 0, 0, 8069, 8012, 1, 0, 0, 0, 8069, 8013, 1, 0, 0, 0, 8069, 8016, 1, 0, 0, 0, 8069, 8017, 1, 0, 0, 0, 8069, 8018, 1, 0, 0, 0, 8069, 8021, 1, 0, 0, 0, 8069, 8023, 1, 0, 0, 0, 8069, 8024, 1, 0, 0, 0, 8069, 8026, 1, 0, 0, 0, 8069, 8027, 1, 0, 0, 0, 8069, 8028, 1, 0, 0, 0, 8069, 8029, 1, 0, 0, 0, 8069, 8031, 1, 0, 0, 0, 8069, 8033, 1, 0, 0, 0, 8069, 8034, 1, 0, 0, 0, 8069, 8035, 1, 0, 0, 0, 8069, 8036, 1, 0, 0, 0, 8069, 8037, 1, 0, 0, 0, 8069, 8038, 1, 0, 0, 0, 8069, 8039, 1, 0, 0, 0, 8069, 8041, 1, 0, 0, 0, 8069, 8043, 1, 0, 0, 0, 8069, 8045, 1, 0, 0, 0, 8069, 8047, 1, 0, 0, 0, 8069, 8049, 1, 0, 0, 0, 8069, 8051, 1, 0, 0, 0, 8069, 8053, 1, 0, 0, 0, 8069, 8055, 1, 0, 0, 0, 8069, 8057, 1, 0, 0, 0, 8069, 8059, 1, 0, 0, 0, 8069, 8061, 1, 0, 0, 0, 8069, 8063, 1, 0, 0, 0, 8069, 8065, 1, 0, 0, 0, 8069, 8067, 1, 0, 0, 0, 8070, 745, 1, 0, 0, 0, 8071, 8072, 5, 469, 0, 0, 8072, 8073, 5, 717, 0, 0, 8073, 8076, 3, 2328, 1164, 0, 8074, 8075, 5, 691, 0, 0, 8075, 8077, 5, 545, 0, 0, 8076, 8074, 1, 0, 0, 0, 8076, 8077, 1, 0, 0, 0, 8077, 747, 1, 0, 0, 0, 8078, 8079, 5, 436, 0, 0, 8079, 8080, 5, 1746, 0, 0, 8080, 8200, 5, 628, 0, 0, 8081, 8085, 5, 238, 0, 0, 8082, 8083, 3, 2286, 1143, 0, 8083, 8084, 5, 2440, 0, 0, 8084, 8086, 1, 0, 0, 0, 8085, 8082, 1, 0, 0, 0, 8085, 8086, 1, 0, 0, 0, 8086, 8087, 1, 0, 0, 0, 8087, 8088, 3, 2404, 1202, 0, 8088, 8089, 5, 2440, 0, 0, 8089, 8102, 3, 2404, 1202, 0, 8090, 8094, 5, 2453, 0, 0, 8091, 8092, 3, 2286, 1143, 0, 8092, 8093, 5, 2440, 0, 0, 8093, 8095, 1, 0, 0, 0, 8094, 8091, 1, 0, 0, 0, 8094, 8095, 1, 0, 0, 0, 8095, 8096, 1, 0, 0, 0, 8096, 8097, 3, 2404, 1202, 0, 8097, 8098, 5, 2440, 0, 0, 8098, 8099, 3, 2404, 1202, 0, 8099, 8101, 1, 0, 0, 0, 8100, 8090, 1, 0, 0, 0, 8101, 8104, 1, 0, 0, 0, 8102, 8100, 1, 0, 0, 0, 8102, 8103, 1, 0, 0, 0, 8103, 8201, 1, 0, 0, 0, 8104, 8102, 1, 0, 0, 0, 8105, 8109, 5, 633, 0, 0, 8106, 8107, 3, 2286, 1143, 0, 8107, 8108, 5, 2440, 0, 0, 8108, 8110, 1, 0, 0, 0, 8109, 8106, 1, 0, 0, 0, 8109, 8110, 1, 0, 0, 0, 8110, 8111, 1, 0, 0, 0, 8111, 8121, 3, 2404, 1202, 0, 8112, 8116, 5, 2453, 0, 0, 8113, 8114, 3, 2286, 1143, 0, 8114, 8115, 5, 2440, 0, 0, 8115, 8117, 1, 0, 0, 0, 8116, 8113, 1, 0, 0, 0, 8116, 8117, 1, 0, 0, 0, 8117, 8118, 1, 0, 0, 0, 8118, 8120, 3, 2404, 1202, 0, 8119, 8112, 1, 0, 0, 0, 8120, 8123, 1, 0, 0, 0, 8121, 8119, 1, 0, 0, 0, 8121, 8122, 1, 0, 0, 0, 8122, 8201, 1, 0, 0, 0, 8123, 8121, 1, 0, 0, 0, 8124, 8128, 5, 1330, 0, 0, 8125, 8126, 3, 2286, 1143, 0, 8126, 8127, 5, 2440, 0, 0, 8127, 8129, 1, 0, 0, 0, 8128, 8125, 1, 0, 0, 0, 8128, 8129, 1, 0, 0, 0, 8129, 8130, 1, 0, 0, 0, 8130, 8140, 3, 2404, 1202, 0, 8131, 8135, 5, 2453, 0, 0, 8132, 8133, 3, 2286, 1143, 0, 8133, 8134, 5, 2440, 0, 0, 8134, 8136, 1, 0, 0, 0, 8135, 8132, 1, 0, 0, 0, 8135, 8136, 1, 0, 0, 0, 8136, 8137, 1, 0, 0, 0, 8137, 8139, 3, 2404, 1202, 0, 8138, 8131, 1, 0, 0, 0, 8139, 8142, 1, 0, 0, 0, 8140, 8138, 1, 0, 0, 0, 8140, 8141, 1, 0, 0, 0, 8141, 8201, 1, 0, 0, 0, 8142, 8140, 1, 0, 0, 0, 8143, 8147, 5, 2165, 0, 0, 8144, 8145, 3, 2286, 1143, 0, 8145, 8146, 5, 2440, 0, 0, 8146, 8148, 1, 0, 0, 0, 8147, 8144, 1, 0, 0, 0, 8147, 8148, 1, 0, 0, 0, 8148, 8149, 1, 0, 0, 0, 8149, 8159, 3, 2404, 1202, 0, 8150, 8154, 5, 2453, 0, 0, 8151, 8152, 3, 2286, 1143, 0, 8152, 8153, 5, 2440, 0, 0, 8153, 8155, 1, 0, 0, 0, 8154, 8151, 1, 0, 0, 0, 8154, 8155, 1, 0, 0, 0, 8155, 8156, 1, 0, 0, 0, 8156, 8158, 3, 2404, 1202, 0, 8157, 8150, 1, 0, 0, 0, 8158, 8161, 1, 0, 0, 0, 8159, 8157, 1, 0, 0, 0, 8159, 8160, 1, 0, 0, 0, 8160, 8201, 1, 0, 0, 0, 8161, 8159, 1, 0, 0, 0, 8162, 8166, 5, 714, 0, 0, 8163, 8164, 3, 2286, 1143, 0, 8164, 8165, 5, 2440, 0, 0, 8165, 8167, 1, 0, 0, 0, 8166, 8163, 1, 0, 0, 0, 8166, 8167, 1, 0, 0, 0, 8167, 8168, 1, 0, 0, 0, 8168, 8178, 3, 2404, 1202, 0, 8169, 8173, 5, 2453, 0, 0, 8170, 8171, 3, 2286, 1143, 0, 8171, 8172, 5, 2440, 0, 0, 8172, 8174, 1, 0, 0, 0, 8173, 8170, 1, 0, 0, 0, 8173, 8174, 1, 0, 0, 0, 8174, 8175, 1, 0, 0, 0, 8175, 8177, 3, 2404, 1202, 0, 8176, 8169, 1, 0, 0, 0, 8177, 8180, 1, 0, 0, 0, 8178, 8176, 1, 0, 0, 0, 8178, 8179, 1, 0, 0, 0, 8179, 8201, 1, 0, 0, 0, 8180, 8178, 1, 0, 0, 0, 8181, 8185, 5, 732, 0, 0, 8182, 8183, 3, 2286, 1143, 0, 8183, 8184, 5, 2440, 0, 0, 8184, 8186, 1, 0, 0, 0, 8185, 8182, 1, 0, 0, 0, 8185, 8186, 1, 0, 0, 0, 8186, 8187, 1, 0, 0, 0, 8187, 8197, 3, 2404, 1202, 0, 8188, 8192, 5, 2453, 0, 0, 8189, 8190, 3, 2286, 1143, 0, 8190, 8191, 5, 2440, 0, 0, 8191, 8193, 1, 0, 0, 0, 8192, 8189, 1, 0, 0, 0, 8192, 8193, 1, 0, 0, 0, 8193, 8194, 1, 0, 0, 0, 8194, 8196, 3, 2404, 1202, 0, 8195, 8188, 1, 0, 0, 0, 8196, 8199, 1, 0, 0, 0, 8197, 8195, 1, 0, 0, 0, 8197, 8198, 1, 0, 0, 0, 8198, 8201, 1, 0, 0, 0, 8199, 8197, 1, 0, 0, 0, 8200, 8081, 1, 0, 0, 0, 8200, 8105, 1, 0, 0, 0, 8200, 8124, 1, 0, 0, 0, 8200, 8143, 1, 0, 0, 0, 8200, 8162, 1, 0, 0, 0, 8200, 8181, 1, 0, 0, 0, 8201, 8203, 1, 0, 0, 0, 8202, 8204, 5, 616, 0, 0, 8203, 8202, 1, 0, 0, 0, 8203, 8204, 1, 0, 0, 0, 8204, 749, 1, 0, 0, 0, 8205, 8206, 5, 469, 0, 0, 8206, 8210, 5, 731, 0, 0, 8207, 8208, 3, 2286, 1143, 0, 8208, 8209, 5, 2440, 0, 0, 8209, 8211, 1, 0, 0, 0, 8210, 8207, 1, 0, 0, 0, 8210, 8211, 1, 0, 0, 0, 8211, 8212, 1, 0, 0, 0, 8212, 8214, 3, 2404, 1202, 0, 8213, 8215, 5, 616, 0, 0, 8214, 8213, 1, 0, 0, 0, 8214, 8215, 1, 0, 0, 0, 8215, 751, 1, 0, 0, 0, 8216, 8217, 5, 469, 0, 0, 8217, 8218, 5, 746, 0, 0, 8218, 8219, 5, 794, 0, 0, 8219, 8223, 5, 649, 0, 0, 8220, 8221, 3, 2286, 1143, 0, 8221, 8222, 5, 2440, 0, 0, 8222, 8224, 1, 0, 0, 0, 8223, 8220, 1, 0, 0, 0, 8223, 8224, 1, 0, 0, 0, 8224, 8225, 1, 0, 0, 0, 8225, 8226, 3, 2404, 1202, 0, 8226, 753, 1, 0, 0, 0, 8227, 8228, 5, 605, 0, 0, 8228, 8229, 5, 2083, 0, 0, 8229, 8234, 3, 2342, 1171, 0, 8230, 8231, 5, 2453, 0, 0, 8231, 8233, 3, 2342, 1171, 0, 8232, 8230, 1, 0, 0, 0, 8233, 8236, 1, 0, 0, 0, 8234, 8232, 1, 0, 0, 0, 8234, 8235, 1, 0, 0, 0, 8235, 8237, 1, 0, 0, 0, 8236, 8234, 1, 0, 0, 0, 8237, 8256, 5, 2141, 0, 0, 8238, 8239, 7, 83, 0, 0, 8239, 8244, 3, 2078, 1039, 0, 8240, 8241, 5, 1574, 0, 0, 8241, 8242, 5, 1411, 0, 0, 8242, 8244, 3, 756, 378, 0, 8243, 8238, 1, 0, 0, 0, 8243, 8240, 1, 0, 0, 0, 8244, 8247, 1, 0, 0, 0, 8245, 8246, 7, 17, 0, 0, 8246, 8248, 5, 2156, 0, 0, 8247, 8245, 1, 0, 0, 0, 8247, 8248, 1, 0, 0, 0, 8248, 8257, 1, 0, 0, 0, 8249, 8250, 5, 112, 0, 0, 8250, 8254, 5, 469, 0, 0, 8251, 8252, 5, 1559, 0, 0, 8252, 8253, 5, 2141, 0, 0, 8253, 8255, 3, 2342, 1171, 0, 8254, 8251, 1, 0, 0, 0, 8254, 8255, 1, 0, 0, 0, 8255, 8257, 1, 0, 0, 0, 8256, 8243, 1, 0, 0, 0, 8256, 8249, 1, 0, 0, 0, 8257, 755, 1, 0, 0, 0, 8258, 8263, 3, 2402, 1201, 0, 8259, 8260, 5, 2440, 0, 0, 8260, 8262, 3, 2404, 1202, 0, 8261, 8259, 1, 0, 0, 0, 8262, 8265, 1, 0, 0, 0, 8263, 8261, 1, 0, 0, 0, 8263, 8264, 1, 0, 0, 0, 8264, 757, 1, 0, 0, 0, 8265, 8263, 1, 0, 0, 0, 8266, 8280, 5, 1475, 0, 0, 8267, 8268, 7, 84, 0, 0, 8268, 8281, 3, 2404, 1202, 0, 8269, 8271, 5, 2080, 0, 0, 8270, 8272, 5, 1671, 0, 0, 8271, 8270, 1, 0, 0, 0, 8271, 8272, 1, 0, 0, 0, 8272, 8273, 1, 0, 0, 0, 8273, 8276, 3, 2404, 1202, 0, 8274, 8275, 5, 2237, 0, 0, 8275, 8277, 3, 2404, 1202, 0, 8276, 8274, 1, 0, 0, 0, 8276, 8277, 1, 0, 0, 0, 8277, 8281, 1, 0, 0, 0, 8278, 8281, 5, 1518, 0, 0, 8279, 8281, 5, 369, 0, 0, 8280, 8267, 1, 0, 0, 0, 8280, 8269, 1, 0, 0, 0, 8280, 8278, 1, 0, 0, 0, 8280, 8279, 1, 0, 0, 0, 8281, 759, 1, 0, 0, 0, 8282, 8294, 5, 1059, 0, 0, 8283, 8285, 3, 726, 363, 0, 8284, 8286, 3, 728, 364, 0, 8285, 8284, 1, 0, 0, 0, 8285, 8286, 1, 0, 0, 0, 8286, 8295, 1, 0, 0, 0, 8287, 8295, 3, 732, 366, 0, 8288, 8295, 5, 1019, 0, 0, 8289, 8290, 5, 427, 0, 0, 8290, 8292, 5, 867, 0, 0, 8291, 8293, 3, 728, 364, 0, 8292, 8291, 1, 0, 0, 0, 8292, 8293, 1, 0, 0, 0, 8293, 8295, 1, 0, 0, 0, 8294, 8283, 1, 0, 0, 0, 8294, 8287, 1, 0, 0, 0, 8294, 8288, 1, 0, 0, 0, 8294, 8289, 1, 0, 0, 0, 8295, 8301, 1, 0, 0, 0, 8296, 8298, 5, 2299, 0, 0, 8297, 8299, 5, 1204, 0, 0, 8298, 8297, 1, 0, 0, 0, 8298, 8299, 1, 0, 0, 0, 8299, 8300, 1, 0, 0, 0, 8300, 8302, 5, 1786, 0, 0, 8301, 8296, 1, 0, 0, 0, 8301, 8302, 1, 0, 0, 0, 8302, 8304, 1, 0, 0, 0, 8303, 8305, 3, 766, 383, 0, 8304, 8303, 1, 0, 0, 0, 8304, 8305, 1, 0, 0, 0, 8305, 761, 1, 0, 0, 0, 8306, 8307, 5, 1559, 0, 0, 8307, 8308, 3, 740, 370, 0, 8308, 8309, 5, 2141, 0, 0, 8309, 8310, 3, 740, 370, 0, 8310, 763, 1, 0, 0, 0, 8311, 8323, 5, 647, 0, 0, 8312, 8314, 5, 2453, 0, 0, 8313, 8312, 1, 0, 0, 0, 8313, 8314, 1, 0, 0, 0, 8314, 8321, 1, 0, 0, 0, 8315, 8322, 3, 2308, 1154, 0, 8316, 8322, 3, 2392, 1196, 0, 8317, 8319, 3, 2390, 1195, 0, 8318, 8320, 3, 2360, 1180, 0, 8319, 8318, 1, 0, 0, 0, 8319, 8320, 1, 0, 0, 0, 8320, 8322, 1, 0, 0, 0, 8321, 8315, 1, 0, 0, 0, 8321, 8316, 1, 0, 0, 0, 8321, 8317, 1, 0, 0, 0, 8322, 8324, 1, 0, 0, 0, 8323, 8313, 1, 0, 0, 0, 8324, 8325, 1, 0, 0, 0, 8325, 8323, 1, 0, 0, 0, 8325, 8326, 1, 0, 0, 0, 8326, 8329, 1, 0, 0, 0, 8327, 8328, 5, 1259, 0, 0, 8328, 8330, 3, 2356, 1178, 0, 8329, 8327, 1, 0, 0, 0, 8329, 8330, 1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 8334, 5, 2141, 0, 0, 8332, 8335, 3, 2306, 1153, 0, 8333, 8335, 5, 1473, 0, 0, 8334, 8332, 1, 0, 0, 0, 8334, 8333, 1, 0, 0, 0, 8335, 8343, 1, 0, 0, 0, 8336, 8339, 5, 2453, 0, 0, 8337, 8340, 3, 2306, 1153, 0, 8338, 8340, 5, 1473, 0, 0, 8339, 8337, 1, 0, 0, 0, 8339, 8338, 1, 0, 0, 0, 8340, 8342, 1, 0, 0, 0, 8341, 8336, 1, 0, 0, 0, 8342, 8345, 1, 0, 0, 0, 8343, 8341, 1, 0, 0, 0, 8343, 8344, 1, 0, 0, 0, 8344, 8349, 1, 0, 0, 0, 8345, 8343, 1, 0, 0, 0, 8346, 8347, 5, 2308, 0, 0, 8347, 8348, 7, 85, 0, 0, 8348, 8350, 5, 1272, 0, 0, 8349, 8346, 1, 0, 0, 0, 8349, 8350, 1, 0, 0, 0, 8350, 8354, 1, 0, 0, 0, 8351, 8352, 5, 2308, 0, 0, 8352, 8353, 5, 674, 0, 0, 8353, 8355, 5, 1272, 0, 0, 8354, 8351, 1, 0, 0, 0, 8354, 8355, 1, 0, 0, 0, 8355, 8359, 1, 0, 0, 0, 8356, 8357, 5, 2308, 0, 0, 8357, 8358, 5, 647, 0, 0, 8358, 8360, 5, 1272, 0, 0, 8359, 8356, 1, 0, 0, 0, 8359, 8360, 1, 0, 0, 0, 8360, 8362, 1, 0, 0, 0, 8361, 8363, 3, 766, 383, 0, 8362, 8361, 1, 0, 0, 0, 8362, 8363, 1, 0, 0, 0, 8363, 765, 1, 0, 0, 0, 8364, 8365, 5, 289, 0, 0, 8365, 8366, 5, 2472, 0, 0, 8366, 8367, 7, 82, 0, 0, 8367, 767, 1, 0, 0, 0, 8368, 8377, 5, 1589, 0, 0, 8369, 8372, 3, 770, 385, 0, 8370, 8372, 3, 774, 387, 0, 8371, 8369, 1, 0, 0, 0, 8371, 8370, 1, 0, 0, 0, 8372, 8374, 1, 0, 0, 0, 8373, 8375, 3, 766, 383, 0, 8374, 8373, 1, 0, 0, 0, 8374, 8375, 1, 0, 0, 0, 8375, 8378, 1, 0, 0, 0, 8376, 8378, 3, 778, 389, 0, 8377, 8371, 1, 0, 0, 0, 8377, 8376, 1, 0, 0, 0, 8378, 769, 1, 0, 0, 0, 8379, 8384, 3, 2392, 1196, 0, 8380, 8384, 3, 2308, 1154, 0, 8381, 8382, 5, 38, 0, 0, 8382, 8384, 5, 1459, 0, 0, 8383, 8379, 1, 0, 0, 0, 8383, 8380, 1, 0, 0, 0, 8383, 8381, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8386, 5, 628, 0, 0, 8386, 8387, 3, 772, 386, 0, 8387, 771, 1, 0, 0, 0, 8388, 8391, 3, 2404, 1202, 0, 8389, 8391, 5, 1473, 0, 0, 8390, 8388, 1, 0, 0, 0, 8390, 8389, 1, 0, 0, 0, 8391, 8399, 1, 0, 0, 0, 8392, 8395, 5, 2453, 0, 0, 8393, 8396, 3, 2404, 1202, 0, 8394, 8396, 5, 1473, 0, 0, 8395, 8393, 1, 0, 0, 0, 8395, 8394, 1, 0, 0, 0, 8396, 8398, 1, 0, 0, 0, 8397, 8392, 1, 0, 0, 0, 8398, 8401, 1, 0, 0, 0, 8399, 8397, 1, 0, 0, 0, 8399, 8400, 1, 0, 0, 0, 8400, 773, 1, 0, 0, 0, 8401, 8399, 1, 0, 0, 0, 8402, 8408, 3, 2390, 1195, 0, 8403, 8405, 5, 38, 0, 0, 8404, 8406, 5, 1459, 0, 0, 8405, 8404, 1, 0, 0, 0, 8405, 8406, 1, 0, 0, 0, 8406, 8408, 1, 0, 0, 0, 8407, 8402, 1, 0, 0, 0, 8407, 8403, 1, 0, 0, 0, 8408, 8419, 1, 0, 0, 0, 8409, 8415, 5, 2453, 0, 0, 8410, 8416, 3, 2390, 1195, 0, 8411, 8413, 5, 38, 0, 0, 8412, 8414, 5, 1459, 0, 0, 8413, 8412, 1, 0, 0, 0, 8413, 8414, 1, 0, 0, 0, 8414, 8416, 1, 0, 0, 0, 8415, 8410, 1, 0, 0, 0, 8415, 8411, 1, 0, 0, 0, 8416, 8418, 1, 0, 0, 0, 8417, 8409, 1, 0, 0, 0, 8418, 8421, 1, 0, 0, 0, 8419, 8417, 1, 0, 0, 0, 8419, 8420, 1, 0, 0, 0, 8420, 8422, 1, 0, 0, 0, 8421, 8419, 1, 0, 0, 0, 8422, 8423, 3, 776, 388, 0, 8423, 8424, 5, 628, 0, 0, 8424, 8428, 3, 772, 386, 0, 8425, 8426, 5, 179, 0, 0, 8426, 8429, 5, 287, 0, 0, 8427, 8429, 5, 616, 0, 0, 8428, 8425, 1, 0, 0, 0, 8428, 8427, 1, 0, 0, 0, 8428, 8429, 1, 0, 0, 0, 8429, 775, 1, 0, 0, 0, 8430, 8475, 5, 1259, 0, 0, 8431, 8432, 3, 2286, 1143, 0, 8432, 8433, 5, 2440, 0, 0, 8433, 8435, 1, 0, 0, 0, 8434, 8431, 1, 0, 0, 0, 8434, 8435, 1, 0, 0, 0, 8435, 8436, 1, 0, 0, 0, 8436, 8476, 3, 2404, 1202, 0, 8437, 8438, 5, 2237, 0, 0, 8438, 8443, 3, 2404, 1202, 0, 8439, 8440, 5, 2453, 0, 0, 8440, 8442, 3, 2404, 1202, 0, 8441, 8439, 1, 0, 0, 0, 8442, 8445, 1, 0, 0, 0, 8443, 8441, 1, 0, 0, 0, 8443, 8444, 1, 0, 0, 0, 8444, 8476, 1, 0, 0, 0, 8445, 8443, 1, 0, 0, 0, 8446, 8447, 5, 426, 0, 0, 8447, 8476, 3, 786, 393, 0, 8448, 8449, 5, 483, 0, 0, 8449, 8476, 3, 1454, 727, 0, 8450, 8451, 5, 955, 0, 0, 8451, 8455, 5, 971, 0, 0, 8452, 8453, 3, 2286, 1143, 0, 8453, 8454, 5, 2440, 0, 0, 8454, 8456, 1, 0, 0, 0, 8455, 8452, 1, 0, 0, 0, 8455, 8456, 1, 0, 0, 0, 8456, 8457, 1, 0, 0, 0, 8457, 8476, 3, 2404, 1202, 0, 8458, 8459, 5, 792, 0, 0, 8459, 8463, 7, 86, 0, 0, 8460, 8461, 3, 2286, 1143, 0, 8461, 8462, 5, 2440, 0, 0, 8462, 8464, 1, 0, 0, 0, 8463, 8460, 1, 0, 0, 0, 8463, 8464, 1, 0, 0, 0, 8464, 8465, 1, 0, 0, 0, 8465, 8476, 3, 2404, 1202, 0, 8466, 8467, 5, 1722, 0, 0, 8467, 8468, 5, 2154, 0, 0, 8468, 8472, 5, 1463, 0, 0, 8469, 8470, 3, 2286, 1143, 0, 8470, 8471, 5, 2440, 0, 0, 8471, 8473, 1, 0, 0, 0, 8472, 8469, 1, 0, 0, 0, 8472, 8473, 1, 0, 0, 0, 8473, 8474, 1, 0, 0, 0, 8474, 8476, 3, 2404, 1202, 0, 8475, 8434, 1, 0, 0, 0, 8475, 8437, 1, 0, 0, 0, 8475, 8446, 1, 0, 0, 0, 8475, 8448, 1, 0, 0, 0, 8475, 8450, 1, 0, 0, 0, 8475, 8458, 1, 0, 0, 0, 8475, 8466, 1, 0, 0, 0, 8476, 777, 1, 0, 0, 0, 8477, 8482, 3, 2308, 1154, 0, 8478, 8479, 5, 2453, 0, 0, 8479, 8481, 3, 2308, 1154, 0, 8480, 8478, 1, 0, 0, 0, 8481, 8484, 1, 0, 0, 0, 8482, 8480, 1, 0, 0, 0, 8482, 8483, 1, 0, 0, 0, 8483, 8487, 1, 0, 0, 0, 8484, 8482, 1, 0, 0, 0, 8485, 8487, 5, 38, 0, 0, 8486, 8477, 1, 0, 0, 0, 8486, 8485, 1, 0, 0, 0, 8487, 8488, 1, 0, 0, 0, 8488, 8489, 5, 628, 0, 0, 8489, 8494, 3, 780, 390, 0, 8490, 8491, 5, 2453, 0, 0, 8491, 8493, 3, 780, 390, 0, 8492, 8490, 1, 0, 0, 0, 8493, 8496, 1, 0, 0, 0, 8494, 8492, 1, 0, 0, 0, 8494, 8495, 1, 0, 0, 0, 8495, 779, 1, 0, 0, 0, 8496, 8494, 1, 0, 0, 0, 8497, 8501, 7, 87, 0, 0, 8498, 8499, 3, 2286, 1143, 0, 8499, 8500, 5, 2440, 0, 0, 8500, 8502, 1, 0, 0, 0, 8501, 8498, 1, 0, 0, 0, 8501, 8502, 1, 0, 0, 0, 8502, 8503, 1, 0, 0, 0, 8503, 8504, 3, 2404, 1202, 0, 8504, 781, 1, 0, 0, 0, 8505, 8506, 5, 321, 0, 0, 8506, 8507, 5, 422, 0, 0, 8507, 8509, 3, 2402, 1201, 0, 8508, 8510, 3, 820, 410, 0, 8509, 8508, 1, 0, 0, 0, 8510, 8511, 1, 0, 0, 0, 8511, 8509, 1, 0, 0, 0, 8511, 8512, 1, 0, 0, 0, 8512, 8516, 1, 0, 0, 0, 8513, 8517, 3, 822, 411, 0, 8514, 8517, 3, 826, 413, 0, 8515, 8517, 3, 828, 414, 0, 8516, 8513, 1, 0, 0, 0, 8516, 8514, 1, 0, 0, 0, 8516, 8515, 1, 0, 0, 0, 8517, 8518, 1, 0, 0, 0, 8518, 8516, 1, 0, 0, 0, 8518, 8519, 1, 0, 0, 0, 8519, 783, 1, 0, 0, 0, 8520, 8523, 5, 321, 0, 0, 8521, 8522, 5, 1307, 0, 0, 8522, 8524, 5, 1562, 0, 0, 8523, 8521, 1, 0, 0, 0, 8523, 8524, 1, 0, 0, 0, 8524, 8525, 1, 0, 0, 0, 8525, 8526, 5, 426, 0, 0, 8526, 8530, 3, 786, 393, 0, 8527, 8528, 5, 1681, 0, 0, 8528, 8529, 5, 2472, 0, 0, 8529, 8531, 7, 21, 0, 0, 8530, 8527, 1, 0, 0, 0, 8530, 8531, 1, 0, 0, 0, 8531, 8532, 1, 0, 0, 0, 8532, 8533, 5, 69, 0, 0, 8533, 8534, 3, 788, 394, 0, 8534, 785, 1, 0, 0, 0, 8535, 8536, 3, 2410, 1205, 0, 8536, 787, 1, 0, 0, 0, 8537, 8538, 5, 2443, 0, 0, 8538, 789, 1, 0, 0, 0, 8539, 8540, 5, 321, 0, 0, 8540, 8541, 5, 746, 0, 0, 8541, 8542, 5, 794, 0, 0, 8542, 8546, 5, 649, 0, 0, 8543, 8544, 3, 2286, 1143, 0, 8544, 8545, 5, 2440, 0, 0, 8545, 8547, 1, 0, 0, 0, 8546, 8543, 1, 0, 0, 0, 8546, 8547, 1, 0, 0, 0, 8547, 8548, 1, 0, 0, 0, 8548, 8549, 3, 2404, 1202, 0, 8549, 8553, 5, 2447, 0, 0, 8550, 8551, 3, 2286, 1143, 0, 8551, 8552, 5, 2440, 0, 0, 8552, 8554, 1, 0, 0, 0, 8553, 8550, 1, 0, 0, 0, 8553, 8554, 1, 0, 0, 0, 8554, 8555, 1, 0, 0, 0, 8555, 8556, 3, 2404, 1202, 0, 8556, 8557, 5, 2447, 0, 0, 8557, 8558, 3, 2404, 1202, 0, 8558, 8570, 5, 2448, 0, 0, 8559, 8563, 5, 2453, 0, 0, 8560, 8561, 3, 2286, 1143, 0, 8561, 8562, 5, 2440, 0, 0, 8562, 8564, 1, 0, 0, 0, 8563, 8560, 1, 0, 0, 0, 8563, 8564, 1, 0, 0, 0, 8564, 8565, 1, 0, 0, 0, 8565, 8566, 3, 2404, 1202, 0, 8566, 8567, 5, 2447, 0, 0, 8567, 8568, 3, 2404, 1202, 0, 8568, 8569, 5, 2448, 0, 0, 8569, 8571, 1, 0, 0, 0, 8570, 8559, 1, 0, 0, 0, 8571, 8572, 1, 0, 0, 0, 8572, 8570, 1, 0, 0, 0, 8572, 8573, 1, 0, 0, 0, 8573, 8574, 1, 0, 0, 0, 8574, 8575, 5, 2448, 0, 0, 8575, 791, 1, 0, 0, 0, 8576, 8577, 5, 469, 0, 0, 8577, 8581, 5, 674, 0, 0, 8578, 8579, 3, 2286, 1143, 0, 8579, 8580, 5, 2440, 0, 0, 8580, 8582, 1, 0, 0, 0, 8581, 8578, 1, 0, 0, 0, 8581, 8582, 1, 0, 0, 0, 8582, 8583, 1, 0, 0, 0, 8583, 8584, 3, 2404, 1202, 0, 8584, 793, 1, 0, 0, 0, 8585, 8586, 5, 42, 0, 0, 8586, 8587, 5, 849, 0, 0, 8587, 8603, 3, 816, 408, 0, 8588, 8590, 5, 249, 0, 0, 8589, 8591, 3, 810, 405, 0, 8590, 8589, 1, 0, 0, 0, 8590, 8591, 1, 0, 0, 0, 8591, 8595, 1, 0, 0, 0, 8592, 8594, 3, 812, 406, 0, 8593, 8592, 1, 0, 0, 0, 8594, 8597, 1, 0, 0, 0, 8595, 8593, 1, 0, 0, 0, 8595, 8596, 1, 0, 0, 0, 8596, 8600, 1, 0, 0, 0, 8597, 8595, 1, 0, 0, 0, 8598, 8599, 5, 1587, 0, 0, 8599, 8601, 5, 1673, 0, 0, 8600, 8598, 1, 0, 0, 0, 8600, 8601, 1, 0, 0, 0, 8601, 8604, 1, 0, 0, 0, 8602, 8604, 3, 808, 404, 0, 8603, 8588, 1, 0, 0, 0, 8603, 8602, 1, 0, 0, 0, 8604, 795, 1, 0, 0, 0, 8605, 8606, 5, 469, 0, 0, 8606, 8607, 5, 792, 0, 0, 8607, 8611, 7, 88, 0, 0, 8608, 8609, 3, 2286, 1143, 0, 8609, 8610, 5, 2440, 0, 0, 8610, 8612, 1, 0, 0, 0, 8611, 8608, 1, 0, 0, 0, 8611, 8612, 1, 0, 0, 0, 8612, 8613, 1, 0, 0, 0, 8613, 8614, 3, 2404, 1202, 0, 8614, 797, 1, 0, 0, 0, 8615, 8616, 5, 469, 0, 0, 8616, 8617, 5, 849, 0, 0, 8617, 8618, 3, 816, 408, 0, 8618, 799, 1, 0, 0, 0, 8619, 8622, 5, 321, 0, 0, 8620, 8621, 5, 1307, 0, 0, 8621, 8623, 5, 1562, 0, 0, 8622, 8620, 1, 0, 0, 0, 8622, 8623, 1, 0, 0, 0, 8623, 8626, 1, 0, 0, 0, 8624, 8625, 5, 49, 0, 0, 8625, 8627, 7, 89, 0, 0, 8626, 8624, 1, 0, 0, 0, 8626, 8627, 1, 0, 0, 0, 8627, 8629, 1, 0, 0, 0, 8628, 8630, 5, 1104, 0, 0, 8629, 8628, 1, 0, 0, 0, 8629, 8630, 1, 0, 0, 0, 8630, 8631, 1, 0, 0, 0, 8631, 8645, 5, 792, 0, 0, 8632, 8633, 7, 86, 0, 0, 8633, 8637, 5, 996, 0, 0, 8634, 8635, 3, 2286, 1143, 0, 8635, 8636, 5, 2440, 0, 0, 8636, 8638, 1, 0, 0, 0, 8637, 8634, 1, 0, 0, 0, 8637, 8638, 1, 0, 0, 0, 8638, 8639, 1, 0, 0, 0, 8639, 8646, 3, 2404, 1202, 0, 8640, 8643, 5, 206, 0, 0, 8641, 8642, 5, 1625, 0, 0, 8642, 8644, 3, 2404, 1202, 0, 8643, 8641, 1, 0, 0, 0, 8643, 8644, 1, 0, 0, 0, 8644, 8646, 1, 0, 0, 0, 8645, 8632, 1, 0, 0, 0, 8645, 8640, 1, 0, 0, 0, 8646, 8650, 1, 0, 0, 0, 8647, 8648, 5, 1681, 0, 0, 8648, 8649, 5, 2472, 0, 0, 8649, 8651, 7, 21, 0, 0, 8650, 8647, 1, 0, 0, 0, 8650, 8651, 1, 0, 0, 0, 8651, 8653, 1, 0, 0, 0, 8652, 8654, 3, 1720, 860, 0, 8653, 8652, 1, 0, 0, 0, 8653, 8654, 1, 0, 0, 0, 8654, 8672, 1, 0, 0, 0, 8655, 8656, 5, 1569, 0, 0, 8656, 8667, 5, 2447, 0, 0, 8657, 8658, 5, 2447, 0, 0, 8658, 8660, 5, 2443, 0, 0, 8659, 8661, 5, 2453, 0, 0, 8660, 8659, 1, 0, 0, 0, 8660, 8661, 1, 0, 0, 0, 8661, 8664, 1, 0, 0, 0, 8662, 8665, 3, 2404, 1202, 0, 8663, 8665, 5, 2452, 0, 0, 8664, 8662, 1, 0, 0, 0, 8664, 8663, 1, 0, 0, 0, 8665, 8666, 1, 0, 0, 0, 8666, 8668, 5, 2448, 0, 0, 8667, 8657, 1, 0, 0, 0, 8668, 8669, 1, 0, 0, 0, 8669, 8667, 1, 0, 0, 0, 8669, 8670, 1, 0, 0, 0, 8670, 8671, 1, 0, 0, 0, 8671, 8673, 5, 2448, 0, 0, 8672, 8655, 1, 0, 0, 0, 8672, 8673, 1, 0, 0, 0, 8673, 8689, 1, 0, 0, 0, 8674, 8685, 5, 2246, 0, 0, 8675, 8676, 5, 119, 0, 0, 8676, 8677, 5, 2447, 0, 0, 8677, 8678, 3, 2404, 1202, 0, 8678, 8679, 5, 2453, 0, 0, 8679, 8680, 3, 1458, 729, 0, 8680, 8681, 5, 2448, 0, 0, 8681, 8686, 1, 0, 0, 0, 8682, 8683, 7, 90, 0, 0, 8683, 8686, 3, 1896, 948, 0, 8684, 8686, 5, 2443, 0, 0, 8685, 8675, 1, 0, 0, 0, 8685, 8682, 1, 0, 0, 0, 8685, 8684, 1, 0, 0, 0, 8686, 8690, 1, 0, 0, 0, 8687, 8688, 5, 69, 0, 0, 8688, 8690, 5, 2443, 0, 0, 8689, 8674, 1, 0, 0, 0, 8689, 8687, 1, 0, 0, 0, 8690, 801, 1, 0, 0, 0, 8691, 8694, 5, 321, 0, 0, 8692, 8693, 5, 1307, 0, 0, 8693, 8695, 5, 1562, 0, 0, 8694, 8692, 1, 0, 0, 0, 8694, 8695, 1, 0, 0, 0, 8695, 8697, 1, 0, 0, 0, 8696, 8698, 7, 20, 0, 0, 8697, 8696, 1, 0, 0, 0, 8697, 8698, 1, 0, 0, 0, 8698, 8699, 1, 0, 0, 0, 8699, 8700, 5, 849, 0, 0, 8700, 8701, 3, 804, 402, 0, 8701, 803, 1, 0, 0, 0, 8702, 8703, 3, 816, 408, 0, 8703, 8704, 7, 22, 0, 0, 8704, 8707, 3, 2400, 1200, 0, 8705, 8706, 5, 738, 0, 0, 8706, 8708, 3, 786, 393, 0, 8707, 8705, 1, 0, 0, 0, 8707, 8708, 1, 0, 0, 0, 8708, 8711, 1, 0, 0, 0, 8709, 8710, 5, 34, 0, 0, 8710, 8712, 3, 2400, 1200, 0, 8711, 8709, 1, 0, 0, 0, 8711, 8712, 1, 0, 0, 0, 8712, 8715, 1, 0, 0, 0, 8713, 8714, 5, 325, 0, 0, 8714, 8716, 3, 806, 403, 0, 8715, 8713, 1, 0, 0, 0, 8715, 8716, 1, 0, 0, 0, 8716, 805, 1, 0, 0, 0, 8717, 8718, 3, 2404, 1202, 0, 8718, 8719, 5, 2440, 0, 0, 8719, 8721, 1, 0, 0, 0, 8720, 8717, 1, 0, 0, 0, 8720, 8721, 1, 0, 0, 0, 8721, 8722, 1, 0, 0, 0, 8722, 8723, 3, 2404, 1202, 0, 8723, 807, 1, 0, 0, 0, 8724, 8725, 4, 404, 5, 0, 8725, 8726, 7, 20, 0, 0, 8726, 809, 1, 0, 0, 0, 8727, 8728, 4, 405, 6, 0, 8728, 8729, 5, 378, 0, 0, 8729, 811, 1, 0, 0, 0, 8730, 8731, 3, 2294, 1147, 0, 8731, 8732, 5, 2472, 0, 0, 8732, 8733, 3, 814, 407, 0, 8733, 813, 1, 0, 0, 0, 8734, 8737, 3, 2410, 1205, 0, 8735, 8737, 5, 2443, 0, 0, 8736, 8734, 1, 0, 0, 0, 8736, 8735, 1, 0, 0, 0, 8737, 815, 1, 0, 0, 0, 8738, 8739, 3, 2410, 1205, 0, 8739, 8740, 5, 2440, 0, 0, 8740, 8742, 1, 0, 0, 0, 8741, 8738, 1, 0, 0, 0, 8741, 8742, 1, 0, 0, 0, 8742, 8743, 1, 0, 0, 0, 8743, 8744, 3, 2410, 1205, 0, 8744, 817, 1, 0, 0, 0, 8745, 8746, 5, 42, 0, 0, 8746, 8747, 5, 422, 0, 0, 8747, 8792, 3, 2402, 1201, 0, 8748, 8753, 5, 21, 0, 0, 8749, 8754, 3, 820, 410, 0, 8750, 8754, 3, 822, 411, 0, 8751, 8754, 3, 826, 413, 0, 8752, 8754, 3, 828, 414, 0, 8753, 8749, 1, 0, 0, 0, 8753, 8750, 1, 0, 0, 0, 8753, 8751, 1, 0, 0, 0, 8753, 8752, 1, 0, 0, 0, 8754, 8756, 1, 0, 0, 0, 8755, 8748, 1, 0, 0, 0, 8756, 8757, 1, 0, 0, 0, 8757, 8755, 1, 0, 0, 0, 8757, 8758, 1, 0, 0, 0, 8758, 8793, 1, 0, 0, 0, 8759, 8785, 5, 469, 0, 0, 8760, 8761, 5, 846, 0, 0, 8761, 8763, 3, 2402, 1201, 0, 8762, 8764, 7, 91, 0, 0, 8763, 8762, 1, 0, 0, 0, 8763, 8764, 1, 0, 0, 0, 8764, 8786, 1, 0, 0, 0, 8765, 8766, 5, 674, 0, 0, 8766, 8786, 3, 2402, 1201, 0, 8767, 8768, 5, 83, 0, 0, 8768, 8783, 3, 2402, 1201, 0, 8769, 8770, 5, 846, 0, 0, 8770, 8781, 3, 2402, 1201, 0, 8771, 8772, 5, 237, 0, 0, 8772, 8778, 3, 2340, 1170, 0, 8773, 8774, 5, 2453, 0, 0, 8774, 8775, 5, 237, 0, 0, 8775, 8777, 3, 2340, 1170, 0, 8776, 8773, 1, 0, 0, 0, 8777, 8780, 1, 0, 0, 0, 8778, 8776, 1, 0, 0, 0, 8778, 8779, 1, 0, 0, 0, 8779, 8782, 1, 0, 0, 0, 8780, 8778, 1, 0, 0, 0, 8781, 8771, 1, 0, 0, 0, 8781, 8782, 1, 0, 0, 0, 8782, 8784, 1, 0, 0, 0, 8783, 8769, 1, 0, 0, 0, 8783, 8784, 1, 0, 0, 0, 8784, 8786, 1, 0, 0, 0, 8785, 8760, 1, 0, 0, 0, 8785, 8765, 1, 0, 0, 0, 8785, 8767, 1, 0, 0, 0, 8786, 8788, 1, 0, 0, 0, 8787, 8759, 1, 0, 0, 0, 8788, 8789, 1, 0, 0, 0, 8789, 8787, 1, 0, 0, 0, 8789, 8790, 1, 0, 0, 0, 8790, 8793, 1, 0, 0, 0, 8791, 8793, 5, 249, 0, 0, 8792, 8755, 1, 0, 0, 0, 8792, 8787, 1, 0, 0, 0, 8792, 8791, 1, 0, 0, 0, 8793, 819, 1, 0, 0, 0, 8794, 8795, 5, 846, 0, 0, 8795, 8796, 3, 2402, 1201, 0, 8796, 8817, 5, 785, 0, 0, 8797, 8798, 3, 1110, 555, 0, 8798, 8799, 5, 2440, 0, 0, 8799, 8800, 3, 2340, 1170, 0, 8800, 8818, 1, 0, 0, 0, 8801, 8802, 5, 2447, 0, 0, 8802, 8803, 3, 1110, 555, 0, 8803, 8804, 5, 2440, 0, 0, 8804, 8812, 3, 2340, 1170, 0, 8805, 8806, 5, 2453, 0, 0, 8806, 8807, 3, 1110, 555, 0, 8807, 8808, 5, 2440, 0, 0, 8808, 8809, 3, 2340, 1170, 0, 8809, 8811, 1, 0, 0, 0, 8810, 8805, 1, 0, 0, 0, 8811, 8814, 1, 0, 0, 0, 8812, 8810, 1, 0, 0, 0, 8812, 8813, 1, 0, 0, 0, 8813, 8815, 1, 0, 0, 0, 8814, 8812, 1, 0, 0, 0, 8815, 8816, 5, 2448, 0, 0, 8816, 8818, 1, 0, 0, 0, 8817, 8797, 1, 0, 0, 0, 8817, 8801, 1, 0, 0, 0, 8818, 8822, 1, 0, 0, 0, 8819, 8820, 5, 1702, 0, 0, 8820, 8821, 5, 2300, 0, 0, 8821, 8823, 5, 1228, 0, 0, 8822, 8819, 1, 0, 0, 0, 8822, 8823, 1, 0, 0, 0, 8823, 821, 1, 0, 0, 0, 8824, 8825, 5, 674, 0, 0, 8825, 8826, 3, 2402, 1201, 0, 8826, 8827, 5, 2447, 0, 0, 8827, 8831, 3, 2402, 1201, 0, 8828, 8829, 5, 202, 0, 0, 8829, 8830, 5, 1246, 0, 0, 8830, 8832, 3, 2402, 1201, 0, 8831, 8828, 1, 0, 0, 0, 8832, 8833, 1, 0, 0, 0, 8833, 8831, 1, 0, 0, 0, 8833, 8834, 1, 0, 0, 0, 8834, 8836, 1, 0, 0, 0, 8835, 8837, 3, 824, 412, 0, 8836, 8835, 1, 0, 0, 0, 8836, 8837, 1, 0, 0, 0, 8837, 8838, 1, 0, 0, 0, 8838, 8839, 5, 2448, 0, 0, 8839, 823, 1, 0, 0, 0, 8840, 8841, 5, 794, 0, 0, 8841, 8842, 5, 816, 0, 0, 8842, 8843, 3, 830, 415, 0, 8843, 8844, 5, 1528, 0, 0, 8844, 8845, 3, 2402, 1201, 0, 8845, 8847, 1, 0, 0, 0, 8846, 8840, 1, 0, 0, 0, 8847, 8848, 1, 0, 0, 0, 8848, 8846, 1, 0, 0, 0, 8848, 8849, 1, 0, 0, 0, 8849, 825, 1, 0, 0, 0, 8850, 8851, 5, 83, 0, 0, 8851, 8852, 3, 2402, 1201, 0, 8852, 8853, 5, 419, 0, 0, 8853, 8854, 3, 830, 415, 0, 8854, 8856, 1, 0, 0, 0, 8855, 8850, 1, 0, 0, 0, 8856, 8857, 1, 0, 0, 0, 8857, 8855, 1, 0, 0, 0, 8857, 8858, 1, 0, 0, 0, 8858, 827, 1, 0, 0, 0, 8859, 8860, 5, 83, 0, 0, 8860, 8866, 3, 2402, 1201, 0, 8861, 8862, 5, 846, 0, 0, 8862, 8863, 3, 2402, 1201, 0, 8863, 8864, 5, 419, 0, 0, 8864, 8865, 3, 830, 415, 0, 8865, 8867, 1, 0, 0, 0, 8866, 8861, 1, 0, 0, 0, 8867, 8868, 1, 0, 0, 0, 8868, 8866, 1, 0, 0, 0, 8868, 8869, 1, 0, 0, 0, 8869, 829, 1, 0, 0, 0, 8870, 8883, 3, 2340, 1170, 0, 8871, 8872, 5, 2447, 0, 0, 8872, 8877, 3, 2340, 1170, 0, 8873, 8874, 5, 2453, 0, 0, 8874, 8876, 3, 2340, 1170, 0, 8875, 8873, 1, 0, 0, 0, 8876, 8879, 1, 0, 0, 0, 8877, 8875, 1, 0, 0, 0, 8877, 8878, 1, 0, 0, 0, 8878, 8880, 1, 0, 0, 0, 8879, 8877, 1, 0, 0, 0, 8880, 8881, 5, 2448, 0, 0, 8881, 8883, 1, 0, 0, 0, 8882, 8870, 1, 0, 0, 0, 8882, 8871, 1, 0, 0, 0, 8883, 831, 1, 0, 0, 0, 8884, 8885, 5, 42, 0, 0, 8885, 8886, 5, 2286, 0, 0, 8886, 8919, 3, 2342, 1171, 0, 8887, 8888, 5, 21, 0, 0, 8888, 8920, 3, 852, 426, 0, 8889, 8890, 5, 980, 0, 0, 8890, 8891, 5, 286, 0, 0, 8891, 8892, 3, 2310, 1155, 0, 8892, 8893, 7, 51, 0, 0, 8893, 8920, 1, 0, 0, 0, 8894, 8911, 5, 469, 0, 0, 8895, 8896, 5, 286, 0, 0, 8896, 8912, 3, 2310, 1155, 0, 8897, 8898, 5, 1451, 0, 0, 8898, 8912, 5, 816, 0, 0, 8899, 8900, 5, 2183, 0, 0, 8900, 8901, 5, 2447, 0, 0, 8901, 8906, 3, 2340, 1170, 0, 8902, 8903, 5, 2453, 0, 0, 8903, 8905, 3, 2340, 1170, 0, 8904, 8902, 1, 0, 0, 0, 8905, 8908, 1, 0, 0, 0, 8906, 8904, 1, 0, 0, 0, 8906, 8907, 1, 0, 0, 0, 8907, 8909, 1, 0, 0, 0, 8908, 8906, 1, 0, 0, 0, 8909, 8910, 5, 2448, 0, 0, 8910, 8912, 1, 0, 0, 0, 8911, 8895, 1, 0, 0, 0, 8911, 8897, 1, 0, 0, 0, 8911, 8899, 1, 0, 0, 0, 8912, 8920, 1, 0, 0, 0, 8913, 8920, 5, 249, 0, 0, 8914, 8915, 5, 1505, 0, 0, 8915, 8920, 7, 11, 0, 0, 8916, 8918, 3, 834, 417, 0, 8917, 8916, 1, 0, 0, 0, 8917, 8918, 1, 0, 0, 0, 8918, 8920, 1, 0, 0, 0, 8919, 8887, 1, 0, 0, 0, 8919, 8889, 1, 0, 0, 0, 8919, 8894, 1, 0, 0, 0, 8919, 8913, 1, 0, 0, 0, 8919, 8914, 1, 0, 0, 0, 8919, 8917, 1, 0, 0, 0, 8920, 833, 1, 0, 0, 0, 8921, 8922, 4, 417, 7, 0, 8922, 8923, 7, 20, 0, 0, 8923, 835, 1, 0, 0, 0, 8924, 8927, 5, 321, 0, 0, 8925, 8926, 5, 1307, 0, 0, 8926, 8928, 5, 1562, 0, 0, 8927, 8925, 1, 0, 0, 0, 8927, 8928, 1, 0, 0, 0, 8928, 8933, 1, 0, 0, 0, 8929, 8931, 5, 1137, 0, 0, 8930, 8929, 1, 0, 0, 0, 8930, 8931, 1, 0, 0, 0, 8931, 8932, 1, 0, 0, 0, 8932, 8934, 5, 616, 0, 0, 8933, 8930, 1, 0, 0, 0, 8933, 8934, 1, 0, 0, 0, 8934, 8936, 1, 0, 0, 0, 8935, 8937, 3, 838, 419, 0, 8936, 8935, 1, 0, 0, 0, 8936, 8937, 1, 0, 0, 0, 8937, 8938, 1, 0, 0, 0, 8938, 8942, 5, 2286, 0, 0, 8939, 8940, 3, 2286, 1143, 0, 8940, 8941, 5, 2440, 0, 0, 8941, 8943, 1, 0, 0, 0, 8942, 8939, 1, 0, 0, 0, 8942, 8943, 1, 0, 0, 0, 8943, 8944, 1, 0, 0, 0, 8944, 8948, 3, 2404, 1202, 0, 8945, 8946, 5, 691, 0, 0, 8946, 8947, 5, 1204, 0, 0, 8947, 8949, 5, 545, 0, 0, 8948, 8945, 1, 0, 0, 0, 8948, 8949, 1, 0, 0, 0, 8949, 8960, 1, 0, 0, 0, 8950, 8951, 5, 1681, 0, 0, 8951, 8958, 5, 2472, 0, 0, 8952, 8959, 5, 948, 0, 0, 8953, 8955, 5, 2376, 0, 0, 8954, 8953, 1, 0, 0, 0, 8954, 8955, 1, 0, 0, 0, 8955, 8956, 1, 0, 0, 0, 8956, 8959, 5, 351, 0, 0, 8957, 8959, 5, 1133, 0, 0, 8958, 8952, 1, 0, 0, 0, 8958, 8954, 1, 0, 0, 0, 8958, 8957, 1, 0, 0, 0, 8959, 8961, 1, 0, 0, 0, 8960, 8950, 1, 0, 0, 0, 8960, 8961, 1, 0, 0, 0, 8961, 8963, 1, 0, 0, 0, 8962, 8964, 3, 840, 420, 0, 8963, 8962, 1, 0, 0, 0, 8963, 8964, 1, 0, 0, 0, 8964, 8968, 1, 0, 0, 0, 8965, 8966, 5, 389, 0, 0, 8966, 8967, 5, 2373, 0, 0, 8967, 8969, 3, 2404, 1202, 0, 8968, 8965, 1, 0, 0, 0, 8968, 8969, 1, 0, 0, 0, 8969, 8972, 1, 0, 0, 0, 8970, 8971, 5, 117, 0, 0, 8971, 8973, 7, 92, 0, 0, 8972, 8970, 1, 0, 0, 0, 8972, 8973, 1, 0, 0, 0, 8973, 8974, 1, 0, 0, 0, 8974, 8975, 5, 69, 0, 0, 8975, 8977, 3, 1868, 934, 0, 8976, 8978, 3, 2068, 1034, 0, 8977, 8976, 1, 0, 0, 0, 8977, 8978, 1, 0, 0, 0, 8978, 8980, 1, 0, 0, 0, 8979, 8981, 7, 93, 0, 0, 8980, 8979, 1, 0, 0, 0, 8980, 8981, 1, 0, 0, 0, 8981, 837, 1, 0, 0, 0, 8982, 8989, 5, 484, 0, 0, 8983, 8985, 5, 482, 0, 0, 8984, 8986, 5, 484, 0, 0, 8985, 8984, 1, 0, 0, 0, 8985, 8986, 1, 0, 0, 0, 8986, 8989, 1, 0, 0, 0, 8987, 8989, 5, 1132, 0, 0, 8988, 8982, 1, 0, 0, 0, 8988, 8983, 1, 0, 0, 0, 8988, 8987, 1, 0, 0, 0, 8989, 839, 1, 0, 0, 0, 8990, 8994, 3, 842, 421, 0, 8991, 8994, 3, 844, 422, 0, 8992, 8994, 3, 856, 428, 0, 8993, 8990, 1, 0, 0, 0, 8993, 8991, 1, 0, 0, 0, 8993, 8992, 1, 0, 0, 0, 8994, 841, 1, 0, 0, 0, 8995, 9009, 5, 2447, 0, 0, 8996, 8998, 5, 2453, 0, 0, 8997, 8996, 1, 0, 0, 0, 8997, 8998, 1, 0, 0, 0, 8998, 9007, 1, 0, 0, 0, 8999, 9003, 3, 2270, 1135, 0, 9000, 9002, 3, 846, 423, 0, 9001, 9000, 1, 0, 0, 0, 9002, 9005, 1, 0, 0, 0, 9003, 9001, 1, 0, 0, 0, 9003, 9004, 1, 0, 0, 0, 9004, 9008, 1, 0, 0, 0, 9005, 9003, 1, 0, 0, 0, 9006, 9008, 3, 852, 426, 0, 9007, 8999, 1, 0, 0, 0, 9007, 9006, 1, 0, 0, 0, 9008, 9010, 1, 0, 0, 0, 9009, 8997, 1, 0, 0, 0, 9010, 9011, 1, 0, 0, 0, 9011, 9009, 1, 0, 0, 0, 9011, 9012, 1, 0, 0, 0, 9012, 9013, 1, 0, 0, 0, 9013, 9014, 5, 2448, 0, 0, 9014, 843, 1, 0, 0, 0, 9015, 9019, 5, 1246, 0, 0, 9016, 9017, 3, 2286, 1143, 0, 9017, 9018, 5, 2440, 0, 0, 9018, 9020, 1, 0, 0, 0, 9019, 9016, 1, 0, 0, 0, 9019, 9020, 1, 0, 0, 0, 9020, 9021, 1, 0, 0, 0, 9021, 9045, 3, 2404, 1202, 0, 9022, 9023, 5, 2308, 0, 0, 9023, 9024, 5, 1238, 0, 0, 9024, 9036, 7, 94, 0, 0, 9025, 9037, 5, 389, 0, 0, 9026, 9027, 5, 2447, 0, 0, 9027, 9032, 5, 2480, 0, 0, 9028, 9029, 5, 2453, 0, 0, 9029, 9031, 5, 2480, 0, 0, 9030, 9028, 1, 0, 0, 0, 9031, 9034, 1, 0, 0, 0, 9032, 9030, 1, 0, 0, 0, 9032, 9033, 1, 0, 0, 0, 9033, 9035, 1, 0, 0, 0, 9034, 9032, 1, 0, 0, 0, 9035, 9037, 5, 2448, 0, 0, 9036, 9025, 1, 0, 0, 0, 9036, 9026, 1, 0, 0, 0, 9037, 9046, 1, 0, 0, 0, 9038, 9042, 5, 2177, 0, 0, 9039, 9040, 3, 2286, 1143, 0, 9040, 9041, 5, 2440, 0, 0, 9041, 9043, 1, 0, 0, 0, 9042, 9039, 1, 0, 0, 0, 9042, 9043, 1, 0, 0, 0, 9043, 9044, 1, 0, 0, 0, 9044, 9046, 3, 2404, 1202, 0, 9045, 9022, 1, 0, 0, 0, 9045, 9038, 1, 0, 0, 0, 9046, 9064, 1, 0, 0, 0, 9047, 9056, 5, 2447, 0, 0, 9048, 9050, 5, 2453, 0, 0, 9049, 9048, 1, 0, 0, 0, 9049, 9050, 1, 0, 0, 0, 9050, 9054, 1, 0, 0, 0, 9051, 9055, 3, 852, 426, 0, 9052, 9053, 5, 2480, 0, 0, 9053, 9055, 3, 846, 423, 0, 9054, 9051, 1, 0, 0, 0, 9054, 9052, 1, 0, 0, 0, 9055, 9057, 1, 0, 0, 0, 9056, 9049, 1, 0, 0, 0, 9057, 9058, 1, 0, 0, 0, 9058, 9056, 1, 0, 0, 0, 9058, 9059, 1, 0, 0, 0, 9059, 9060, 1, 0, 0, 0, 9060, 9061, 5, 2448, 0, 0, 9061, 9063, 1, 0, 0, 0, 9062, 9047, 1, 0, 0, 0, 9063, 9066, 1, 0, 0, 0, 9064, 9062, 1, 0, 0, 0, 9064, 9065, 1, 0, 0, 0, 9065, 845, 1, 0, 0, 0, 9066, 9064, 1, 0, 0, 0, 9067, 9068, 5, 286, 0, 0, 9068, 9070, 3, 2310, 1155, 0, 9069, 9067, 1, 0, 0, 0, 9069, 9070, 1, 0, 0, 0, 9070, 9080, 1, 0, 0, 0, 9071, 9073, 5, 1204, 0, 0, 9072, 9071, 1, 0, 0, 0, 9072, 9073, 1, 0, 0, 0, 9073, 9074, 1, 0, 0, 0, 9074, 9081, 5, 1228, 0, 0, 9075, 9081, 5, 2183, 0, 0, 9076, 9077, 5, 1451, 0, 0, 9077, 9081, 5, 816, 0, 0, 9078, 9081, 3, 1714, 857, 0, 9079, 9081, 3, 1710, 855, 0, 9080, 9072, 1, 0, 0, 0, 9080, 9075, 1, 0, 0, 0, 9080, 9076, 1, 0, 0, 0, 9080, 9078, 1, 0, 0, 0, 9080, 9079, 1, 0, 0, 0, 9081, 9083, 1, 0, 0, 0, 9082, 9084, 3, 854, 427, 0, 9083, 9082, 1, 0, 0, 0, 9083, 9084, 1, 0, 0, 0, 9084, 847, 1, 0, 0, 0, 9085, 9086, 5, 1628, 0, 0, 9086, 9087, 5, 785, 0, 0, 9087, 9099, 3, 2342, 1171, 0, 9088, 9089, 5, 2308, 0, 0, 9089, 9099, 5, 1601, 0, 0, 9090, 9091, 5, 286, 0, 0, 9091, 9093, 3, 2310, 1155, 0, 9092, 9090, 1, 0, 0, 0, 9092, 9093, 1, 0, 0, 0, 9093, 9094, 1, 0, 0, 0, 9094, 9096, 3, 1714, 857, 0, 9095, 9097, 3, 854, 427, 0, 9096, 9095, 1, 0, 0, 0, 9096, 9097, 1, 0, 0, 0, 9097, 9099, 1, 0, 0, 0, 9098, 9085, 1, 0, 0, 0, 9098, 9088, 1, 0, 0, 0, 9098, 9092, 1, 0, 0, 0, 9099, 849, 1, 0, 0, 0, 9100, 9101, 5, 1628, 0, 0, 9101, 9102, 5, 620, 0, 0, 9102, 9103, 5, 2447, 0, 0, 9103, 9104, 3, 2410, 1205, 0, 9104, 9105, 5, 2448, 0, 0, 9105, 9106, 5, 785, 0, 0, 9106, 9107, 3, 2342, 1171, 0, 9107, 9136, 1, 0, 0, 0, 9108, 9109, 5, 1530, 0, 0, 9109, 9110, 5, 2447, 0, 0, 9110, 9111, 3, 2410, 1205, 0, 9111, 9112, 5, 2448, 0, 0, 9112, 9113, 5, 2308, 0, 0, 9113, 9114, 5, 1601, 0, 0, 9114, 9136, 1, 0, 0, 0, 9115, 9116, 5, 286, 0, 0, 9116, 9118, 3, 2310, 1155, 0, 9117, 9115, 1, 0, 0, 0, 9117, 9118, 1, 0, 0, 0, 9118, 9119, 1, 0, 0, 0, 9119, 9120, 5, 618, 0, 0, 9120, 9121, 5, 816, 0, 0, 9121, 9126, 5, 2447, 0, 0, 9122, 9124, 5, 2453, 0, 0, 9123, 9122, 1, 0, 0, 0, 9123, 9124, 1, 0, 0, 0, 9124, 9125, 1, 0, 0, 0, 9125, 9127, 3, 2410, 1205, 0, 9126, 9123, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, 9126, 1, 0, 0, 0, 9128, 9129, 1, 0, 0, 0, 9129, 9130, 1, 0, 0, 0, 9130, 9131, 5, 2448, 0, 0, 9131, 9133, 3, 1714, 857, 0, 9132, 9134, 3, 854, 427, 0, 9133, 9132, 1, 0, 0, 0, 9133, 9134, 1, 0, 0, 0, 9134, 9136, 1, 0, 0, 0, 9135, 9100, 1, 0, 0, 0, 9135, 9108, 1, 0, 0, 0, 9135, 9117, 1, 0, 0, 0, 9136, 851, 1, 0, 0, 0, 9137, 9138, 7, 95, 0, 0, 9138, 9140, 3, 2310, 1155, 0, 9139, 9137, 1, 0, 0, 0, 9139, 9140, 1, 0, 0, 0, 9140, 9172, 1, 0, 0, 0, 9141, 9142, 5, 2183, 0, 0, 9142, 9143, 5, 2447, 0, 0, 9143, 9148, 3, 2340, 1170, 0, 9144, 9145, 5, 2453, 0, 0, 9145, 9147, 3, 2340, 1170, 0, 9146, 9144, 1, 0, 0, 0, 9147, 9150, 1, 0, 0, 0, 9148, 9146, 1, 0, 0, 0, 9148, 9149, 1, 0, 0, 0, 9149, 9151, 1, 0, 0, 0, 9150, 9148, 1, 0, 0, 0, 9151, 9152, 5, 2448, 0, 0, 9152, 9173, 1, 0, 0, 0, 9153, 9154, 5, 1451, 0, 0, 9154, 9155, 5, 816, 0, 0, 9155, 9156, 5, 2447, 0, 0, 9156, 9161, 3, 2340, 1170, 0, 9157, 9158, 5, 2453, 0, 0, 9158, 9160, 3, 2340, 1170, 0, 9159, 9157, 1, 0, 0, 0, 9160, 9163, 1, 0, 0, 0, 9161, 9159, 1, 0, 0, 0, 9161, 9162, 1, 0, 0, 0, 9162, 9164, 1, 0, 0, 0, 9163, 9161, 1, 0, 0, 0, 9164, 9165, 5, 2448, 0, 0, 9165, 9173, 1, 0, 0, 0, 9166, 9173, 3, 1712, 856, 0, 9167, 9168, 5, 200, 0, 0, 9168, 9169, 5, 2447, 0, 0, 9169, 9170, 3, 2074, 1037, 0, 9170, 9171, 5, 2448, 0, 0, 9171, 9173, 1, 0, 0, 0, 9172, 9141, 1, 0, 0, 0, 9172, 9153, 1, 0, 0, 0, 9172, 9166, 1, 0, 0, 0, 9172, 9167, 1, 0, 0, 0, 9173, 9175, 1, 0, 0, 0, 9174, 9176, 3, 854, 427, 0, 9175, 9174, 1, 0, 0, 0, 9175, 9176, 1, 0, 0, 0, 9176, 9178, 1, 0, 0, 0, 9177, 9179, 3, 928, 464, 0, 9178, 9177, 1, 0, 0, 0, 9178, 9179, 1, 0, 0, 0, 9179, 853, 1, 0, 0, 0, 9180, 9182, 5, 1204, 0, 0, 9181, 9180, 1, 0, 0, 0, 9181, 9182, 1, 0, 0, 0, 9182, 9183, 1, 0, 0, 0, 9183, 9191, 5, 394, 0, 0, 9184, 9185, 5, 742, 0, 0, 9185, 9191, 7, 69, 0, 0, 9186, 9191, 7, 51, 0, 0, 9187, 9191, 7, 17, 0, 0, 9188, 9191, 7, 96, 0, 0, 9189, 9191, 3, 1586, 793, 0, 9190, 9181, 1, 0, 0, 0, 9190, 9184, 1, 0, 0, 0, 9190, 9186, 1, 0, 0, 0, 9190, 9187, 1, 0, 0, 0, 9190, 9188, 1, 0, 0, 0, 9190, 9189, 1, 0, 0, 0, 9191, 9192, 1, 0, 0, 0, 9192, 9190, 1, 0, 0, 0, 9192, 9193, 1, 0, 0, 0, 9193, 855, 1, 0, 0, 0, 9194, 9195, 5, 1246, 0, 0, 9195, 9197, 5, 2351, 0, 0, 9196, 9198, 3, 858, 429, 0, 9197, 9196, 1, 0, 0, 0, 9197, 9198, 1, 0, 0, 0, 9198, 9199, 1, 0, 0, 0, 9199, 9200, 5, 2308, 0, 0, 9200, 9201, 5, 1238, 0, 0, 9201, 9214, 7, 94, 0, 0, 9202, 9215, 5, 389, 0, 0, 9203, 9204, 5, 2447, 0, 0, 9204, 9209, 3, 2078, 1039, 0, 9205, 9206, 5, 2453, 0, 0, 9206, 9208, 3, 2078, 1039, 0, 9207, 9205, 1, 0, 0, 0, 9208, 9211, 1, 0, 0, 0, 9209, 9207, 1, 0, 0, 0, 9209, 9210, 1, 0, 0, 0, 9210, 9212, 1, 0, 0, 0, 9211, 9209, 1, 0, 0, 0, 9212, 9213, 5, 2448, 0, 0, 9213, 9215, 1, 0, 0, 0, 9214, 9202, 1, 0, 0, 0, 9214, 9203, 1, 0, 0, 0, 9215, 857, 1, 0, 0, 0, 9216, 9217, 5, 2345, 0, 0, 9217, 9219, 3, 860, 430, 0, 9218, 9216, 1, 0, 0, 0, 9218, 9219, 1, 0, 0, 0, 9219, 9220, 1, 0, 0, 0, 9220, 9226, 5, 486, 0, 0, 9221, 9227, 3, 862, 431, 0, 9222, 9223, 3, 860, 430, 0, 9223, 9224, 5, 2458, 0, 0, 9224, 9225, 3, 862, 431, 0, 9225, 9227, 1, 0, 0, 0, 9226, 9221, 1, 0, 0, 0, 9226, 9222, 1, 0, 0, 0, 9227, 9233, 1, 0, 0, 0, 9228, 9229, 5, 1763, 0, 0, 9229, 9230, 5, 38, 0, 0, 9230, 9231, 5, 2266, 0, 0, 9231, 9232, 5, 69, 0, 0, 9232, 9234, 7, 97, 0, 0, 9233, 9228, 1, 0, 0, 0, 9233, 9234, 1, 0, 0, 0, 9234, 9238, 1, 0, 0, 0, 9235, 9236, 3, 1310, 655, 0, 9236, 9237, 5, 1138, 0, 0, 9237, 9239, 1, 0, 0, 0, 9238, 9235, 1, 0, 0, 0, 9238, 9239, 1, 0, 0, 0, 9239, 9243, 1, 0, 0, 0, 9240, 9241, 3, 1310, 655, 0, 9241, 9242, 5, 56, 0, 0, 9242, 9244, 1, 0, 0, 0, 9243, 9240, 1, 0, 0, 0, 9243, 9244, 1, 0, 0, 0, 9244, 859, 1, 0, 0, 0, 9245, 9246, 5, 2444, 0, 0, 9246, 861, 1, 0, 0, 0, 9247, 9248, 5, 2444, 0, 0, 9248, 863, 1, 0, 0, 0, 9249, 9250, 5, 42, 0, 0, 9250, 9251, 5, 2080, 0, 0, 9251, 9284, 3, 1656, 828, 0, 9252, 9254, 5, 389, 0, 0, 9253, 9255, 3, 1178, 589, 0, 9254, 9253, 1, 0, 0, 0, 9254, 9255, 1, 0, 0, 0, 9255, 9257, 1, 0, 0, 0, 9256, 9258, 3, 1196, 598, 0, 9257, 9256, 1, 0, 0, 0, 9257, 9258, 1, 0, 0, 0, 9258, 9285, 1, 0, 0, 0, 9259, 9260, 5, 954, 0, 0, 9260, 9261, 5, 558, 0, 0, 9261, 9285, 3, 1176, 588, 0, 9262, 9263, 5, 1567, 0, 0, 9263, 9285, 3, 1176, 588, 0, 9264, 9285, 5, 228, 0, 0, 9265, 9266, 5, 1684, 0, 0, 9266, 9269, 5, 1714, 0, 0, 9267, 9268, 5, 814, 0, 0, 9268, 9270, 3, 1176, 588, 0, 9269, 9267, 1, 0, 0, 0, 9269, 9270, 1, 0, 0, 0, 9270, 9285, 1, 0, 0, 0, 9271, 9272, 5, 1559, 0, 0, 9272, 9273, 5, 2141, 0, 0, 9273, 9285, 3, 878, 439, 0, 9274, 9275, 3, 1380, 690, 0, 9275, 9276, 5, 102, 0, 0, 9276, 9285, 1, 0, 0, 0, 9277, 9285, 3, 866, 433, 0, 9278, 9285, 3, 868, 434, 0, 9279, 9285, 3, 870, 435, 0, 9280, 9285, 3, 874, 437, 0, 9281, 9285, 3, 922, 461, 0, 9282, 9285, 3, 876, 438, 0, 9283, 9285, 3, 896, 448, 0, 9284, 9252, 1, 0, 0, 0, 9284, 9259, 1, 0, 0, 0, 9284, 9262, 1, 0, 0, 0, 9284, 9264, 1, 0, 0, 0, 9284, 9265, 1, 0, 0, 0, 9284, 9271, 1, 0, 0, 0, 9284, 9274, 1, 0, 0, 0, 9284, 9277, 1, 0, 0, 0, 9284, 9278, 1, 0, 0, 0, 9284, 9279, 1, 0, 0, 0, 9284, 9280, 1, 0, 0, 0, 9284, 9281, 1, 0, 0, 0, 9284, 9282, 1, 0, 0, 0, 9284, 9283, 1, 0, 0, 0, 9285, 865, 1, 0, 0, 0, 9286, 9289, 5, 21, 0, 0, 9287, 9290, 3, 914, 457, 0, 9288, 9290, 3, 916, 458, 0, 9289, 9287, 1, 0, 0, 0, 9289, 9288, 1, 0, 0, 0, 9290, 9333, 1, 0, 0, 0, 9291, 9292, 5, 469, 0, 0, 9292, 9295, 7, 98, 0, 0, 9293, 9296, 3, 1458, 729, 0, 9294, 9296, 5, 2441, 0, 0, 9295, 9293, 1, 0, 0, 0, 9295, 9294, 1, 0, 0, 0, 9296, 9299, 1, 0, 0, 0, 9297, 9298, 5, 814, 0, 0, 9298, 9300, 3, 1176, 588, 0, 9299, 9297, 1, 0, 0, 0, 9299, 9300, 1, 0, 0, 0, 9300, 9333, 1, 0, 0, 0, 9301, 9302, 5, 1684, 0, 0, 9302, 9305, 5, 2089, 0, 0, 9303, 9306, 3, 1458, 729, 0, 9304, 9306, 5, 2441, 0, 0, 9305, 9303, 1, 0, 0, 0, 9305, 9304, 1, 0, 0, 0, 9306, 9309, 1, 0, 0, 0, 9307, 9308, 5, 814, 0, 0, 9308, 9310, 3, 1176, 588, 0, 9309, 9307, 1, 0, 0, 0, 9309, 9310, 1, 0, 0, 0, 9310, 9333, 1, 0, 0, 0, 9311, 9312, 5, 1559, 0, 0, 9312, 9313, 5, 352, 0, 0, 9313, 9318, 3, 1458, 729, 0, 9314, 9315, 5, 2453, 0, 0, 9315, 9317, 3, 1458, 729, 0, 9316, 9314, 1, 0, 0, 0, 9317, 9320, 1, 0, 0, 0, 9318, 9316, 1, 0, 0, 0, 9318, 9319, 1, 0, 0, 0, 9319, 9321, 1, 0, 0, 0, 9320, 9318, 1, 0, 0, 0, 9321, 9322, 5, 2141, 0, 0, 9322, 9327, 3, 1458, 729, 0, 9323, 9324, 5, 2453, 0, 0, 9324, 9326, 3, 1458, 729, 0, 9325, 9323, 1, 0, 0, 0, 9326, 9329, 1, 0, 0, 0, 9327, 9325, 1, 0, 0, 0, 9327, 9328, 1, 0, 0, 0, 9328, 9333, 1, 0, 0, 0, 9329, 9327, 1, 0, 0, 0, 9330, 9331, 7, 98, 0, 0, 9331, 9333, 3, 682, 341, 0, 9332, 9286, 1, 0, 0, 0, 9332, 9291, 1, 0, 0, 0, 9332, 9301, 1, 0, 0, 0, 9332, 9311, 1, 0, 0, 0, 9332, 9330, 1, 0, 0, 0, 9333, 867, 1, 0, 0, 0, 9334, 9341, 3, 886, 443, 0, 9335, 9337, 5, 1137, 0, 0, 9336, 9335, 1, 0, 0, 0, 9336, 9337, 1, 0, 0, 0, 9337, 9338, 1, 0, 0, 0, 9338, 9339, 5, 616, 0, 0, 9339, 9341, 5, 884, 0, 0, 9340, 9334, 1, 0, 0, 0, 9340, 9336, 1, 0, 0, 0, 9341, 869, 1, 0, 0, 0, 9342, 9343, 5, 2080, 0, 0, 9343, 9346, 5, 649, 0, 0, 9344, 9347, 3, 872, 436, 0, 9345, 9347, 5, 2443, 0, 0, 9346, 9344, 1, 0, 0, 0, 9346, 9345, 1, 0, 0, 0, 9347, 871, 1, 0, 0, 0, 9348, 9349, 3, 2410, 1205, 0, 9349, 873, 1, 0, 0, 0, 9350, 9360, 5, 1256, 0, 0, 9351, 9353, 5, 1243, 0, 0, 9352, 9354, 7, 99, 0, 0, 9353, 9352, 1, 0, 0, 0, 9353, 9354, 1, 0, 0, 0, 9354, 9360, 1, 0, 0, 0, 9355, 9356, 5, 1505, 0, 0, 9356, 9360, 7, 11, 0, 0, 9357, 9360, 5, 1387, 0, 0, 9358, 9360, 5, 2092, 0, 0, 9359, 9350, 1, 0, 0, 0, 9359, 9351, 1, 0, 0, 0, 9359, 9355, 1, 0, 0, 0, 9359, 9357, 1, 0, 0, 0, 9359, 9358, 1, 0, 0, 0, 9360, 875, 1, 0, 0, 0, 9361, 9362, 5, 605, 0, 0, 9362, 9363, 7, 100, 0, 0, 9363, 877, 1, 0, 0, 0, 9364, 9365, 3, 1656, 828, 0, 9365, 879, 1, 0, 0, 0, 9366, 9368, 5, 321, 0, 0, 9367, 9369, 7, 101, 0, 0, 9368, 9367, 1, 0, 0, 0, 9368, 9369, 1, 0, 0, 0, 9369, 9373, 1, 0, 0, 0, 9370, 9374, 3, 882, 441, 0, 9371, 9374, 3, 892, 446, 0, 9372, 9374, 3, 894, 447, 0, 9373, 9370, 1, 0, 0, 0, 9373, 9371, 1, 0, 0, 0, 9373, 9372, 1, 0, 0, 0, 9374, 881, 1, 0, 0, 0, 9375, 9376, 5, 2080, 0, 0, 9376, 9380, 3, 2404, 1202, 0, 9377, 9378, 5, 691, 0, 0, 9378, 9379, 5, 1204, 0, 0, 9379, 9381, 5, 545, 0, 0, 9380, 9377, 1, 0, 0, 0, 9380, 9381, 1, 0, 0, 0, 9381, 9383, 1, 0, 0, 0, 9382, 9384, 3, 914, 457, 0, 9383, 9382, 1, 0, 0, 0, 9383, 9384, 1, 0, 0, 0, 9384, 9402, 1, 0, 0, 0, 9385, 9386, 5, 954, 0, 0, 9386, 9387, 5, 558, 0, 0, 9387, 9401, 3, 1176, 588, 0, 9388, 9389, 5, 146, 0, 0, 9389, 9401, 3, 1176, 588, 0, 9390, 9401, 3, 886, 443, 0, 9391, 9392, 5, 616, 0, 0, 9392, 9401, 5, 884, 0, 0, 9393, 9401, 7, 78, 0, 0, 9394, 9395, 5, 506, 0, 0, 9395, 9401, 3, 884, 442, 0, 9396, 9401, 5, 389, 0, 0, 9397, 9401, 3, 888, 444, 0, 9398, 9401, 3, 890, 445, 0, 9399, 9401, 3, 876, 438, 0, 9400, 9385, 1, 0, 0, 0, 9400, 9388, 1, 0, 0, 0, 9400, 9390, 1, 0, 0, 0, 9400, 9391, 1, 0, 0, 0, 9400, 9393, 1, 0, 0, 0, 9400, 9394, 1, 0, 0, 0, 9400, 9396, 1, 0, 0, 0, 9400, 9397, 1, 0, 0, 0, 9400, 9398, 1, 0, 0, 0, 9400, 9399, 1, 0, 0, 0, 9401, 9404, 1, 0, 0, 0, 9402, 9400, 1, 0, 0, 0, 9402, 9403, 1, 0, 0, 0, 9403, 883, 1, 0, 0, 0, 9404, 9402, 1, 0, 0, 0, 9405, 9406, 5, 2246, 0, 0, 9406, 9407, 5, 2443, 0, 0, 9407, 885, 1, 0, 0, 0, 9408, 9409, 7, 102, 0, 0, 9409, 887, 1, 0, 0, 0, 9410, 9411, 5, 558, 0, 0, 9411, 9412, 5, 906, 0, 0, 9412, 9419, 5, 873, 0, 0, 9413, 9420, 5, 90, 0, 0, 9414, 9417, 5, 2180, 0, 0, 9415, 9416, 5, 1699, 0, 0, 9416, 9418, 3, 1176, 588, 0, 9417, 9415, 1, 0, 0, 0, 9417, 9418, 1, 0, 0, 0, 9418, 9420, 1, 0, 0, 0, 9419, 9413, 1, 0, 0, 0, 9419, 9414, 1, 0, 0, 0, 9419, 9420, 1, 0, 0, 0, 9420, 889, 1, 0, 0, 0, 9421, 9422, 5, 1645, 0, 0, 9422, 9423, 5, 1714, 0, 0, 9423, 9424, 5, 906, 0, 0, 9424, 9425, 7, 103, 0, 0, 9425, 891, 1, 0, 0, 0, 9426, 9427, 5, 2092, 0, 0, 9427, 9428, 5, 2080, 0, 0, 9428, 9432, 3, 2404, 1202, 0, 9429, 9430, 5, 691, 0, 0, 9430, 9431, 5, 1204, 0, 0, 9431, 9433, 5, 545, 0, 0, 9432, 9429, 1, 0, 0, 0, 9432, 9433, 1, 0, 0, 0, 9433, 9435, 1, 0, 0, 0, 9434, 9436, 3, 916, 458, 0, 9435, 9434, 1, 0, 0, 0, 9435, 9436, 1, 0, 0, 0, 9436, 9438, 1, 0, 0, 0, 9437, 9439, 3, 870, 435, 0, 9438, 9437, 1, 0, 0, 0, 9438, 9439, 1, 0, 0, 0, 9439, 9441, 1, 0, 0, 0, 9440, 9442, 3, 888, 444, 0, 9441, 9440, 1, 0, 0, 0, 9441, 9442, 1, 0, 0, 0, 9442, 893, 1, 0, 0, 0, 9443, 9444, 5, 2178, 0, 0, 9444, 9445, 5, 2080, 0, 0, 9445, 9449, 3, 2404, 1202, 0, 9446, 9447, 5, 691, 0, 0, 9447, 9448, 5, 1204, 0, 0, 9448, 9450, 5, 545, 0, 0, 9449, 9446, 1, 0, 0, 0, 9449, 9450, 1, 0, 0, 0, 9450, 9452, 1, 0, 0, 0, 9451, 9453, 3, 914, 457, 0, 9452, 9451, 1, 0, 0, 0, 9452, 9453, 1, 0, 0, 0, 9453, 9455, 1, 0, 0, 0, 9454, 9456, 3, 888, 444, 0, 9455, 9454, 1, 0, 0, 0, 9455, 9456, 1, 0, 0, 0, 9456, 9458, 1, 0, 0, 0, 9457, 9459, 3, 896, 448, 0, 9458, 9457, 1, 0, 0, 0, 9458, 9459, 1, 0, 0, 0, 9459, 895, 1, 0, 0, 0, 9460, 9461, 5, 1583, 0, 0, 9461, 9462, 7, 104, 0, 0, 9462, 897, 1, 0, 0, 0, 9463, 9464, 5, 321, 0, 0, 9464, 9465, 5, 2080, 0, 0, 9465, 9466, 5, 1671, 0, 0, 9466, 9470, 3, 2404, 1202, 0, 9467, 9468, 5, 738, 0, 0, 9468, 9469, 5, 1677, 0, 0, 9469, 9471, 3, 2404, 1202, 0, 9470, 9467, 1, 0, 0, 0, 9470, 9471, 1, 0, 0, 0, 9471, 9493, 1, 0, 0, 0, 9472, 9473, 5, 2246, 0, 0, 9473, 9474, 5, 2090, 0, 0, 9474, 9484, 5, 2447, 0, 0, 9475, 9476, 5, 352, 0, 0, 9476, 9481, 3, 436, 218, 0, 9477, 9478, 5, 2453, 0, 0, 9478, 9480, 3, 436, 218, 0, 9479, 9477, 1, 0, 0, 0, 9480, 9483, 1, 0, 0, 0, 9481, 9479, 1, 0, 0, 0, 9481, 9482, 1, 0, 0, 0, 9482, 9485, 1, 0, 0, 0, 9483, 9481, 1, 0, 0, 0, 9484, 9475, 1, 0, 0, 0, 9484, 9485, 1, 0, 0, 0, 9485, 9487, 1, 0, 0, 0, 9486, 9488, 3, 900, 450, 0, 9487, 9486, 1, 0, 0, 0, 9488, 9489, 1, 0, 0, 0, 9489, 9487, 1, 0, 0, 0, 9489, 9490, 1, 0, 0, 0, 9490, 9491, 1, 0, 0, 0, 9491, 9492, 5, 2448, 0, 0, 9492, 9494, 1, 0, 0, 0, 9493, 9472, 1, 0, 0, 0, 9493, 9494, 1, 0, 0, 0, 9494, 899, 1, 0, 0, 0, 9495, 9496, 5, 954, 0, 0, 9496, 9497, 5, 558, 0, 0, 9497, 9515, 3, 1176, 588, 0, 9498, 9499, 5, 146, 0, 0, 9499, 9501, 3, 2396, 1198, 0, 9500, 9502, 5, 812, 0, 0, 9501, 9500, 1, 0, 0, 0, 9501, 9502, 1, 0, 0, 0, 9502, 9515, 1, 0, 0, 0, 9503, 9515, 3, 886, 443, 0, 9504, 9505, 5, 616, 0, 0, 9505, 9515, 5, 884, 0, 0, 9506, 9515, 3, 902, 451, 0, 9507, 9515, 3, 904, 452, 0, 9508, 9515, 5, 1256, 0, 0, 9509, 9515, 5, 1243, 0, 0, 9510, 9515, 3, 888, 444, 0, 9511, 9515, 3, 890, 445, 0, 9512, 9515, 3, 876, 438, 0, 9513, 9515, 3, 1464, 732, 0, 9514, 9495, 1, 0, 0, 0, 9514, 9498, 1, 0, 0, 0, 9514, 9503, 1, 0, 0, 0, 9514, 9504, 1, 0, 0, 0, 9514, 9506, 1, 0, 0, 0, 9514, 9507, 1, 0, 0, 0, 9514, 9508, 1, 0, 0, 0, 9514, 9509, 1, 0, 0, 0, 9514, 9510, 1, 0, 0, 0, 9514, 9511, 1, 0, 0, 0, 9514, 9512, 1, 0, 0, 0, 9514, 9513, 1, 0, 0, 0, 9515, 901, 1, 0, 0, 0, 9516, 9522, 5, 506, 0, 0, 9517, 9519, 3, 884, 442, 0, 9518, 9517, 1, 0, 0, 0, 9518, 9519, 1, 0, 0, 0, 9519, 9520, 1, 0, 0, 0, 9520, 9523, 5, 505, 0, 0, 9521, 9523, 5, 387, 0, 0, 9522, 9518, 1, 0, 0, 0, 9522, 9521, 1, 0, 0, 0, 9523, 903, 1, 0, 0, 0, 9524, 9526, 5, 389, 0, 0, 9525, 9527, 3, 906, 453, 0, 9526, 9525, 1, 0, 0, 0, 9526, 9527, 1, 0, 0, 0, 9527, 9529, 1, 0, 0, 0, 9528, 9530, 3, 910, 455, 0, 9529, 9528, 1, 0, 0, 0, 9529, 9530, 1, 0, 0, 0, 9530, 9532, 1, 0, 0, 0, 9531, 9533, 3, 912, 456, 0, 9532, 9531, 1, 0, 0, 0, 9532, 9533, 1, 0, 0, 0, 9533, 9535, 1, 0, 0, 0, 9534, 9536, 3, 1204, 602, 0, 9535, 9534, 1, 0, 0, 0, 9535, 9536, 1, 0, 0, 0, 9536, 9538, 1, 0, 0, 0, 9537, 9539, 3, 1196, 598, 0, 9538, 9537, 1, 0, 0, 0, 9538, 9539, 1, 0, 0, 0, 9539, 905, 1, 0, 0, 0, 9540, 9551, 5, 2083, 0, 0, 9541, 9542, 5, 258, 0, 0, 9542, 9548, 5, 620, 0, 0, 9543, 9549, 5, 1253, 0, 0, 9544, 9545, 5, 1484, 0, 0, 9545, 9549, 3, 908, 454, 0, 9546, 9547, 5, 64, 0, 0, 9547, 9549, 3, 908, 454, 0, 9548, 9543, 1, 0, 0, 0, 9548, 9544, 1, 0, 0, 0, 9548, 9546, 1, 0, 0, 0, 9549, 9552, 1, 0, 0, 0, 9550, 9552, 5, 1074, 0, 0, 9551, 9541, 1, 0, 0, 0, 9551, 9550, 1, 0, 0, 0, 9552, 907, 1, 0, 0, 0, 9553, 9554, 7, 105, 0, 0, 9554, 909, 1, 0, 0, 0, 9555, 9560, 5, 717, 0, 0, 9556, 9557, 5, 258, 0, 0, 9557, 9558, 5, 29, 0, 0, 9558, 9561, 3, 908, 454, 0, 9559, 9561, 5, 1074, 0, 0, 9560, 9556, 1, 0, 0, 0, 9560, 9559, 1, 0, 0, 0, 9561, 911, 1, 0, 0, 0, 9562, 9564, 5, 746, 0, 0, 9563, 9565, 3, 1182, 591, 0, 9564, 9563, 1, 0, 0, 0, 9564, 9565, 1, 0, 0, 0, 9565, 9590, 1, 0, 0, 0, 9566, 9588, 5, 2096, 0, 0, 9567, 9572, 3, 2340, 1170, 0, 9568, 9569, 5, 2453, 0, 0, 9569, 9571, 3, 2340, 1170, 0, 9570, 9568, 1, 0, 0, 0, 9571, 9574, 1, 0, 0, 0, 9572, 9570, 1, 0, 0, 0, 9572, 9573, 1, 0, 0, 0, 9573, 9589, 1, 0, 0, 0, 9574, 9572, 1, 0, 0, 0, 9575, 9576, 3, 2340, 1170, 0, 9576, 9577, 5, 2246, 0, 0, 9577, 9585, 3, 718, 359, 0, 9578, 9579, 5, 2453, 0, 0, 9579, 9580, 3, 2340, 1170, 0, 9580, 9581, 5, 2246, 0, 0, 9581, 9582, 3, 718, 359, 0, 9582, 9584, 1, 0, 0, 0, 9583, 9578, 1, 0, 0, 0, 9584, 9587, 1, 0, 0, 0, 9585, 9583, 1, 0, 0, 0, 9585, 9586, 1, 0, 0, 0, 9586, 9589, 1, 0, 0, 0, 9587, 9585, 1, 0, 0, 0, 9588, 9567, 1, 0, 0, 0, 9588, 9575, 1, 0, 0, 0, 9589, 9591, 1, 0, 0, 0, 9590, 9566, 1, 0, 0, 0, 9590, 9591, 1, 0, 0, 0, 9591, 9595, 1, 0, 0, 0, 9592, 9593, 5, 1137, 0, 0, 9593, 9595, 5, 746, 0, 0, 9594, 9562, 1, 0, 0, 0, 9594, 9592, 1, 0, 0, 0, 9595, 913, 1, 0, 0, 0, 9596, 9598, 5, 352, 0, 0, 9597, 9599, 5, 2453, 0, 0, 9598, 9597, 1, 0, 0, 0, 9598, 9599, 1, 0, 0, 0, 9599, 9600, 1, 0, 0, 0, 9600, 9601, 3, 918, 459, 0, 9601, 915, 1, 0, 0, 0, 9602, 9604, 5, 2089, 0, 0, 9603, 9605, 5, 2453, 0, 0, 9604, 9603, 1, 0, 0, 0, 9604, 9605, 1, 0, 0, 0, 9605, 9606, 1, 0, 0, 0, 9606, 9607, 3, 918, 459, 0, 9607, 917, 1, 0, 0, 0, 9608, 9610, 5, 2443, 0, 0, 9609, 9608, 1, 0, 0, 0, 9609, 9610, 1, 0, 0, 0, 9610, 9613, 1, 0, 0, 0, 9611, 9612, 5, 1699, 0, 0, 9612, 9614, 3, 1176, 588, 0, 9613, 9611, 1, 0, 0, 0, 9613, 9614, 1, 0, 0, 0, 9614, 9616, 1, 0, 0, 0, 9615, 9617, 5, 1587, 0, 0, 9616, 9615, 1, 0, 0, 0, 9616, 9617, 1, 0, 0, 0, 9617, 9619, 1, 0, 0, 0, 9618, 9620, 3, 922, 461, 0, 9619, 9618, 1, 0, 0, 0, 9619, 9620, 1, 0, 0, 0, 9620, 919, 1, 0, 0, 0, 9621, 9634, 3, 1458, 729, 0, 9622, 9623, 5, 2447, 0, 0, 9623, 9628, 3, 1458, 729, 0, 9624, 9625, 5, 2453, 0, 0, 9625, 9627, 3, 1458, 729, 0, 9626, 9624, 1, 0, 0, 0, 9627, 9630, 1, 0, 0, 0, 9628, 9626, 1, 0, 0, 0, 9628, 9629, 1, 0, 0, 0, 9629, 9631, 1, 0, 0, 0, 9630, 9628, 1, 0, 0, 0, 9631, 9632, 5, 2448, 0, 0, 9632, 9634, 1, 0, 0, 0, 9633, 9621, 1, 0, 0, 0, 9633, 9622, 1, 0, 0, 0, 9634, 9637, 1, 0, 0, 0, 9635, 9636, 5, 1699, 0, 0, 9636, 9638, 3, 1176, 588, 0, 9637, 9635, 1, 0, 0, 0, 9637, 9638, 1, 0, 0, 0, 9638, 9641, 1, 0, 0, 0, 9639, 9640, 5, 146, 0, 0, 9640, 9642, 3, 1176, 588, 0, 9641, 9639, 1, 0, 0, 0, 9641, 9642, 1, 0, 0, 0, 9642, 9644, 1, 0, 0, 0, 9643, 9645, 5, 1587, 0, 0, 9644, 9643, 1, 0, 0, 0, 9644, 9645, 1, 0, 0, 0, 9645, 921, 1, 0, 0, 0, 9646, 9656, 5, 93, 0, 0, 9647, 9657, 5, 1244, 0, 0, 9648, 9651, 5, 1259, 0, 0, 9649, 9650, 5, 1025, 0, 0, 9650, 9652, 3, 1176, 588, 0, 9651, 9649, 1, 0, 0, 0, 9651, 9652, 1, 0, 0, 0, 9652, 9654, 1, 0, 0, 0, 9653, 9655, 3, 924, 462, 0, 9654, 9653, 1, 0, 0, 0, 9654, 9655, 1, 0, 0, 0, 9655, 9657, 1, 0, 0, 0, 9656, 9647, 1, 0, 0, 0, 9656, 9648, 1, 0, 0, 0, 9657, 923, 1, 0, 0, 0, 9658, 9661, 5, 930, 0, 0, 9659, 9662, 5, 2185, 0, 0, 9660, 9662, 3, 1176, 588, 0, 9661, 9659, 1, 0, 0, 0, 9661, 9660, 1, 0, 0, 0, 9662, 925, 1, 0, 0, 0, 9663, 9664, 5, 158, 0, 0, 9664, 9665, 7, 69, 0, 0, 9665, 927, 1, 0, 0, 0, 9666, 9682, 5, 1148, 0, 0, 9667, 9679, 5, 1333, 0, 0, 9668, 9670, 5, 2441, 0, 0, 9669, 9671, 3, 930, 465, 0, 9670, 9669, 1, 0, 0, 0, 9670, 9671, 1, 0, 0, 0, 9671, 9680, 1, 0, 0, 0, 9672, 9673, 5, 2447, 0, 0, 9673, 9674, 5, 399, 0, 0, 9674, 9676, 5, 2441, 0, 0, 9675, 9677, 3, 930, 465, 0, 9676, 9675, 1, 0, 0, 0, 9676, 9677, 1, 0, 0, 0, 9677, 9678, 1, 0, 0, 0, 9678, 9680, 5, 2448, 0, 0, 9679, 9668, 1, 0, 0, 0, 9679, 9672, 1, 0, 0, 0, 9679, 9680, 1, 0, 0, 0, 9680, 9682, 1, 0, 0, 0, 9681, 9666, 1, 0, 0, 0, 9681, 9667, 1, 0, 0, 0, 9682, 929, 1, 0, 0, 0, 9683, 9684, 5, 760, 0, 0, 9684, 9685, 7, 106, 0, 0, 9685, 931, 1, 0, 0, 0, 9686, 9687, 5, 42, 0, 0, 9687, 9688, 5, 919, 0, 0, 9688, 9689, 5, 2286, 0, 0, 9689, 9715, 3, 2342, 1171, 0, 9690, 9716, 3, 1194, 597, 0, 9691, 9716, 3, 940, 470, 0, 9692, 9716, 3, 1178, 589, 0, 9693, 9698, 3, 1640, 820, 0, 9694, 9695, 5, 2453, 0, 0, 9695, 9697, 3, 1640, 820, 0, 9696, 9694, 1, 0, 0, 0, 9697, 9700, 1, 0, 0, 0, 9698, 9696, 1, 0, 0, 0, 9698, 9699, 1, 0, 0, 0, 9699, 9716, 1, 0, 0, 0, 9700, 9698, 1, 0, 0, 0, 9701, 9706, 3, 1642, 821, 0, 9702, 9703, 5, 2453, 0, 0, 9703, 9705, 3, 1642, 821, 0, 9704, 9702, 1, 0, 0, 0, 9705, 9708, 1, 0, 0, 0, 9706, 9704, 1, 0, 0, 0, 9706, 9707, 1, 0, 0, 0, 9707, 9716, 1, 0, 0, 0, 9708, 9706, 1, 0, 0, 0, 9709, 9716, 3, 928, 464, 0, 9710, 9716, 3, 886, 443, 0, 9711, 9716, 3, 1284, 642, 0, 9712, 9716, 3, 1286, 643, 0, 9713, 9716, 3, 1288, 644, 0, 9714, 9716, 3, 1364, 682, 0, 9715, 9690, 1, 0, 0, 0, 9715, 9691, 1, 0, 0, 0, 9715, 9692, 1, 0, 0, 0, 9715, 9693, 1, 0, 0, 0, 9715, 9701, 1, 0, 0, 0, 9715, 9709, 1, 0, 0, 0, 9715, 9710, 1, 0, 0, 0, 9715, 9711, 1, 0, 0, 0, 9715, 9712, 1, 0, 0, 0, 9715, 9713, 1, 0, 0, 0, 9715, 9714, 1, 0, 0, 0, 9715, 9716, 1, 0, 0, 0, 9716, 9718, 1, 0, 0, 0, 9717, 9719, 3, 1564, 782, 0, 9718, 9717, 1, 0, 0, 0, 9718, 9719, 1, 0, 0, 0, 9719, 9723, 1, 0, 0, 0, 9720, 9721, 5, 2246, 0, 0, 9721, 9722, 5, 717, 0, 0, 9722, 9724, 3, 1194, 597, 0, 9723, 9720, 1, 0, 0, 0, 9723, 9724, 1, 0, 0, 0, 9724, 9726, 1, 0, 0, 0, 9725, 9727, 3, 934, 467, 0, 9726, 9725, 1, 0, 0, 0, 9726, 9727, 1, 0, 0, 0, 9727, 9735, 1, 0, 0, 0, 9728, 9729, 3, 1308, 654, 0, 9729, 9730, 5, 1484, 0, 0, 9730, 9731, 5, 1591, 0, 0, 9731, 9736, 1, 0, 0, 0, 9732, 9736, 5, 249, 0, 0, 9733, 9734, 5, 282, 0, 0, 9734, 9736, 5, 627, 0, 0, 9735, 9728, 1, 0, 0, 0, 9735, 9732, 1, 0, 0, 0, 9735, 9733, 1, 0, 0, 0, 9735, 9736, 1, 0, 0, 0, 9736, 933, 1, 0, 0, 0, 9737, 9738, 3, 936, 468, 0, 9738, 935, 1, 0, 0, 0, 9739, 9766, 5, 1531, 0, 0, 9740, 9767, 5, 578, 0, 0, 9741, 9767, 5, 250, 0, 0, 9742, 9767, 5, 616, 0, 0, 9743, 9744, 5, 1259, 0, 0, 9744, 9767, 7, 107, 0, 0, 9745, 9746, 5, 1737, 0, 0, 9746, 9747, 5, 2308, 0, 0, 9747, 9767, 3, 2078, 1039, 0, 9748, 9749, 5, 1025, 0, 0, 9749, 9767, 3, 2078, 1039, 0, 9750, 9751, 5, 2308, 0, 0, 9751, 9752, 5, 1451, 0, 0, 9752, 9767, 5, 816, 0, 0, 9753, 9755, 5, 2246, 0, 0, 9754, 9756, 5, 389, 0, 0, 9755, 9754, 1, 0, 0, 0, 9755, 9756, 1, 0, 0, 0, 9756, 9757, 1, 0, 0, 0, 9757, 9758, 5, 913, 0, 0, 9758, 9759, 5, 1596, 0, 0, 9759, 9761, 5, 1645, 0, 0, 9760, 9762, 3, 938, 469, 0, 9761, 9760, 1, 0, 0, 0, 9761, 9762, 1, 0, 0, 0, 9762, 9767, 1, 0, 0, 0, 9763, 9764, 5, 2246, 0, 0, 9764, 9765, 7, 108, 0, 0, 9765, 9767, 5, 287, 0, 0, 9766, 9740, 1, 0, 0, 0, 9766, 9741, 1, 0, 0, 0, 9766, 9742, 1, 0, 0, 0, 9766, 9743, 1, 0, 0, 0, 9766, 9745, 1, 0, 0, 0, 9766, 9748, 1, 0, 0, 0, 9766, 9750, 1, 0, 0, 0, 9766, 9753, 1, 0, 0, 0, 9766, 9763, 1, 0, 0, 0, 9767, 9768, 1, 0, 0, 0, 9768, 9766, 1, 0, 0, 0, 9768, 9769, 1, 0, 0, 0, 9769, 937, 1, 0, 0, 0, 9770, 9771, 3, 2410, 1205, 0, 9771, 939, 1, 0, 0, 0, 9772, 9773, 5, 980, 0, 0, 9773, 9774, 5, 2447, 0, 0, 9774, 9778, 3, 2340, 1170, 0, 9775, 9776, 5, 505, 0, 0, 9776, 9779, 3, 1654, 827, 0, 9777, 9779, 5, 387, 0, 0, 9778, 9775, 1, 0, 0, 0, 9778, 9777, 1, 0, 0, 0, 9778, 9779, 1, 0, 0, 0, 9779, 9780, 1, 0, 0, 0, 9780, 9781, 5, 2448, 0, 0, 9781, 941, 1, 0, 0, 0, 9782, 9783, 5, 42, 0, 0, 9783, 9784, 5, 919, 0, 0, 9784, 9785, 5, 2286, 0, 0, 9785, 9787, 5, 888, 0, 0, 9786, 9788, 5, 616, 0, 0, 9787, 9786, 1, 0, 0, 0, 9787, 9788, 1, 0, 0, 0, 9788, 9789, 1, 0, 0, 0, 9789, 9790, 5, 1259, 0, 0, 9790, 9799, 3, 2342, 1171, 0, 9791, 9800, 3, 1194, 597, 0, 9792, 9800, 3, 944, 472, 0, 9793, 9800, 3, 928, 464, 0, 9794, 9800, 3, 886, 443, 0, 9795, 9800, 3, 1284, 642, 0, 9796, 9800, 3, 1288, 644, 0, 9797, 9800, 3, 946, 473, 0, 9798, 9800, 3, 1364, 682, 0, 9799, 9791, 1, 0, 0, 0, 9799, 9792, 1, 0, 0, 0, 9799, 9793, 1, 0, 0, 0, 9799, 9794, 1, 0, 0, 0, 9799, 9795, 1, 0, 0, 0, 9799, 9796, 1, 0, 0, 0, 9799, 9797, 1, 0, 0, 0, 9799, 9798, 1, 0, 0, 0, 9799, 9800, 1, 0, 0, 0, 9800, 9802, 1, 0, 0, 0, 9801, 9803, 3, 948, 474, 0, 9802, 9801, 1, 0, 0, 0, 9802, 9803, 1, 0, 0, 0, 9803, 9805, 1, 0, 0, 0, 9804, 9806, 3, 954, 477, 0, 9805, 9804, 1, 0, 0, 0, 9805, 9806, 1, 0, 0, 0, 9806, 943, 1, 0, 0, 0, 9807, 9808, 5, 21, 0, 0, 9808, 9809, 5, 2447, 0, 0, 9809, 9810, 3, 2340, 1170, 0, 9810, 9811, 5, 2448, 0, 0, 9811, 945, 1, 0, 0, 0, 9812, 9813, 5, 992, 0, 0, 9813, 9815, 3, 1200, 600, 0, 9814, 9816, 3, 928, 464, 0, 9815, 9814, 1, 0, 0, 0, 9815, 9816, 1, 0, 0, 0, 9816, 947, 1, 0, 0, 0, 9817, 9850, 5, 21, 0, 0, 9818, 9819, 5, 1238, 0, 0, 9819, 9825, 5, 689, 0, 0, 9820, 9821, 5, 1451, 0, 0, 9821, 9825, 5, 816, 0, 0, 9822, 9825, 5, 1601, 0, 0, 9823, 9825, 5, 1653, 0, 0, 9824, 9818, 1, 0, 0, 0, 9824, 9820, 1, 0, 0, 0, 9824, 9822, 1, 0, 0, 0, 9824, 9823, 1, 0, 0, 0, 9825, 9837, 1, 0, 0, 0, 9826, 9827, 5, 2447, 0, 0, 9827, 9832, 3, 2340, 1170, 0, 9828, 9829, 5, 2453, 0, 0, 9829, 9831, 3, 2340, 1170, 0, 9830, 9828, 1, 0, 0, 0, 9831, 9834, 1, 0, 0, 0, 9832, 9830, 1, 0, 0, 0, 9832, 9833, 1, 0, 0, 0, 9833, 9835, 1, 0, 0, 0, 9834, 9832, 1, 0, 0, 0, 9835, 9836, 5, 2448, 0, 0, 9836, 9838, 1, 0, 0, 0, 9837, 9826, 1, 0, 0, 0, 9837, 9838, 1, 0, 0, 0, 9838, 9851, 1, 0, 0, 0, 9839, 9840, 5, 2447, 0, 0, 9840, 9845, 3, 2340, 1170, 0, 9841, 9842, 5, 2453, 0, 0, 9842, 9844, 3, 2340, 1170, 0, 9843, 9841, 1, 0, 0, 0, 9844, 9847, 1, 0, 0, 0, 9845, 9843, 1, 0, 0, 0, 9845, 9846, 1, 0, 0, 0, 9846, 9848, 1, 0, 0, 0, 9847, 9845, 1, 0, 0, 0, 9848, 9849, 5, 2448, 0, 0, 9849, 9851, 1, 0, 0, 0, 9850, 9824, 1, 0, 0, 0, 9850, 9839, 1, 0, 0, 0, 9851, 9853, 1, 0, 0, 0, 9852, 9854, 3, 952, 476, 0, 9853, 9852, 1, 0, 0, 0, 9853, 9854, 1, 0, 0, 0, 9854, 949, 1, 0, 0, 0, 9855, 9856, 5, 321, 0, 0, 9856, 9857, 5, 919, 0, 0, 9857, 9858, 5, 2286, 0, 0, 9858, 9859, 5, 888, 0, 0, 9859, 9860, 5, 1259, 0, 0, 9860, 9870, 3, 2342, 1171, 0, 9861, 9867, 3, 1194, 597, 0, 9862, 9863, 5, 2080, 0, 0, 9863, 9867, 3, 2404, 1202, 0, 9864, 9867, 3, 886, 443, 0, 9865, 9867, 7, 109, 0, 0, 9866, 9861, 1, 0, 0, 0, 9866, 9862, 1, 0, 0, 0, 9866, 9864, 1, 0, 0, 0, 9866, 9865, 1, 0, 0, 0, 9867, 9868, 1, 0, 0, 0, 9868, 9866, 1, 0, 0, 0, 9868, 9869, 1, 0, 0, 0, 9869, 9871, 1, 0, 0, 0, 9870, 9866, 1, 0, 0, 0, 9870, 9871, 1, 0, 0, 0, 9871, 9873, 1, 0, 0, 0, 9872, 9874, 3, 928, 464, 0, 9873, 9872, 1, 0, 0, 0, 9873, 9874, 1, 0, 0, 0, 9874, 9914, 1, 0, 0, 0, 9875, 9891, 5, 2308, 0, 0, 9876, 9878, 5, 2453, 0, 0, 9877, 9876, 1, 0, 0, 0, 9877, 9878, 1, 0, 0, 0, 9878, 9887, 1, 0, 0, 0, 9879, 9880, 5, 1238, 0, 0, 9880, 9888, 5, 689, 0, 0, 9881, 9882, 5, 1451, 0, 0, 9882, 9888, 5, 816, 0, 0, 9883, 9888, 5, 1601, 0, 0, 9884, 9888, 5, 1653, 0, 0, 9885, 9886, 5, 242, 0, 0, 9886, 9888, 5, 1627, 0, 0, 9887, 9879, 1, 0, 0, 0, 9887, 9881, 1, 0, 0, 0, 9887, 9883, 1, 0, 0, 0, 9887, 9884, 1, 0, 0, 0, 9887, 9885, 1, 0, 0, 0, 9888, 9890, 1, 0, 0, 0, 9889, 9877, 1, 0, 0, 0, 9890, 9893, 1, 0, 0, 0, 9891, 9889, 1, 0, 0, 0, 9891, 9892, 1, 0, 0, 0, 9892, 9907, 1, 0, 0, 0, 9893, 9891, 1, 0, 0, 0, 9894, 9899, 5, 2447, 0, 0, 9895, 9897, 5, 2453, 0, 0, 9896, 9895, 1, 0, 0, 0, 9896, 9897, 1, 0, 0, 0, 9897, 9898, 1, 0, 0, 0, 9898, 9900, 3, 2410, 1205, 0, 9899, 9896, 1, 0, 0, 0, 9900, 9901, 1, 0, 0, 0, 9901, 9899, 1, 0, 0, 0, 9901, 9902, 1, 0, 0, 0, 9902, 9903, 1, 0, 0, 0, 9903, 9905, 5, 2448, 0, 0, 9904, 9906, 3, 952, 476, 0, 9905, 9904, 1, 0, 0, 0, 9905, 9906, 1, 0, 0, 0, 9906, 9908, 1, 0, 0, 0, 9907, 9894, 1, 0, 0, 0, 9907, 9908, 1, 0, 0, 0, 9908, 9910, 1, 0, 0, 0, 9909, 9911, 3, 954, 477, 0, 9910, 9909, 1, 0, 0, 0, 9910, 9911, 1, 0, 0, 0, 9911, 9913, 1, 0, 0, 0, 9912, 9875, 1, 0, 0, 0, 9913, 9916, 1, 0, 0, 0, 9914, 9912, 1, 0, 0, 0, 9914, 9915, 1, 0, 0, 0, 9915, 951, 1, 0, 0, 0, 9916, 9914, 1, 0, 0, 0, 9917, 9918, 7, 110, 0, 0, 9918, 9919, 5, 1021, 0, 0, 9919, 9920, 5, 2257, 0, 0, 9920, 953, 1, 0, 0, 0, 9921, 9922, 5, 1475, 0, 0, 9922, 9924, 5, 698, 0, 0, 9923, 9925, 7, 111, 0, 0, 9924, 9923, 1, 0, 0, 0, 9924, 9925, 1, 0, 0, 0, 9925, 955, 1, 0, 0, 0, 9926, 9927, 5, 321, 0, 0, 9927, 9928, 5, 919, 0, 0, 9928, 9929, 5, 2362, 0, 0, 9929, 9934, 3, 966, 483, 0, 9930, 9931, 5, 2447, 0, 0, 9931, 9932, 3, 2358, 1179, 0, 9932, 9933, 5, 2448, 0, 0, 9933, 9935, 1, 0, 0, 0, 9934, 9930, 1, 0, 0, 0, 9934, 9935, 1, 0, 0, 0, 9935, 9937, 1, 0, 0, 0, 9936, 9938, 3, 964, 482, 0, 9937, 9936, 1, 0, 0, 0, 9937, 9938, 1, 0, 0, 0, 9938, 9940, 1, 0, 0, 0, 9939, 9941, 3, 962, 481, 0, 9940, 9939, 1, 0, 0, 0, 9940, 9941, 1, 0, 0, 0, 9941, 9944, 1, 0, 0, 0, 9942, 9943, 7, 17, 0, 0, 9943, 9945, 5, 1472, 0, 0, 9944, 9942, 1, 0, 0, 0, 9944, 9945, 1, 0, 0, 0, 9945, 9948, 1, 0, 0, 0, 9946, 9949, 3, 972, 486, 0, 9947, 9949, 3, 974, 487, 0, 9948, 9946, 1, 0, 0, 0, 9948, 9947, 1, 0, 0, 0, 9949, 957, 1, 0, 0, 0, 9950, 9951, 5, 42, 0, 0, 9951, 9952, 5, 919, 0, 0, 9952, 9953, 5, 2362, 0, 0, 9953, 9961, 3, 966, 483, 0, 9954, 9962, 3, 964, 482, 0, 9955, 9962, 3, 962, 481, 0, 9956, 9957, 7, 17, 0, 0, 9957, 9962, 5, 1472, 0, 0, 9958, 9962, 5, 249, 0, 0, 9959, 9962, 5, 1511, 0, 0, 9960, 9962, 5, 2203, 0, 0, 9961, 9954, 1, 0, 0, 0, 9961, 9955, 1, 0, 0, 0, 9961, 9956, 1, 0, 0, 0, 9961, 9958, 1, 0, 0, 0, 9961, 9959, 1, 0, 0, 0, 9961, 9960, 1, 0, 0, 0, 9962, 959, 1, 0, 0, 0, 9963, 9964, 5, 469, 0, 0, 9964, 9965, 5, 919, 0, 0, 9965, 9966, 5, 2362, 0, 0, 9966, 9967, 3, 966, 483, 0, 9967, 961, 1, 0, 0, 0, 9968, 9970, 5, 1531, 0, 0, 9969, 9971, 7, 112, 0, 0, 9970, 9969, 1, 0, 0, 0, 9970, 9971, 1, 0, 0, 0, 9971, 9983, 1, 0, 0, 0, 9972, 9981, 5, 1259, 0, 0, 9973, 9982, 5, 406, 0, 0, 9974, 9982, 5, 242, 0, 0, 9975, 9982, 5, 867, 0, 0, 9976, 9977, 5, 351, 0, 0, 9977, 9982, 5, 991, 0, 0, 9978, 9979, 5, 867, 0, 0, 9979, 9980, 5, 351, 0, 0, 9980, 9982, 5, 991, 0, 0, 9981, 9973, 1, 0, 0, 0, 9981, 9974, 1, 0, 0, 0, 9981, 9975, 1, 0, 0, 0, 9981, 9976, 1, 0, 0, 0, 9981, 9978, 1, 0, 0, 0, 9982, 9984, 1, 0, 0, 0, 9983, 9972, 1, 0, 0, 0, 9983, 9984, 1, 0, 0, 0, 9984, 963, 1, 0, 0, 0, 9985, 9986, 5, 1369, 0, 0, 9986, 9995, 3, 2396, 1198, 0, 9987, 9988, 5, 1372, 0, 0, 9988, 9995, 3, 2396, 1198, 0, 9989, 9990, 5, 1620, 0, 0, 9990, 9995, 3, 2396, 1198, 0, 9991, 9992, 5, 2080, 0, 0, 9992, 9995, 3, 1656, 828, 0, 9993, 9995, 7, 109, 0, 0, 9994, 9985, 1, 0, 0, 0, 9994, 9987, 1, 0, 0, 0, 9994, 9989, 1, 0, 0, 0, 9994, 9991, 1, 0, 0, 0, 9994, 9993, 1, 0, 0, 0, 9995, 9996, 1, 0, 0, 0, 9996, 9994, 1, 0, 0, 0, 9996, 9997, 1, 0, 0, 0, 9997, 965, 1, 0, 0, 0, 9998, 10001, 3, 2402, 1201, 0, 9999, 10000, 5, 2440, 0, 0, 10000, 10002, 3, 2404, 1202, 0, 10001, 9999, 1, 0, 0, 0, 10001, 10002, 1, 0, 0, 0, 10002, 967, 1, 0, 0, 0, 10003, 10006, 3, 2402, 1201, 0, 10004, 10005, 5, 2440, 0, 0, 10005, 10007, 3, 2404, 1202, 0, 10006, 10004, 1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, 10007, 969, 1, 0, 0, 0, 10008, 10013, 3, 2402, 1201, 0, 10009, 10010, 5, 2440, 0, 0, 10010, 10012, 3, 2404, 1202, 0, 10011, 10009, 1, 0, 0, 0, 10012, 10015, 1, 0, 0, 0, 10013, 10011, 1, 0, 0, 0, 10013, 10014, 1, 0, 0, 0, 10014, 971, 1, 0, 0, 0, 10015, 10013, 1, 0, 0, 0, 10016, 10017, 5, 1259, 0, 0, 10017, 10018, 3, 2342, 1171, 0, 10018, 10019, 5, 2447, 0, 0, 10019, 10020, 3, 2358, 1179, 0, 10020, 10021, 5, 2448, 0, 0, 10021, 973, 1, 0, 0, 0, 10022, 10023, 5, 69, 0, 0, 10023, 10024, 3, 1896, 948, 0, 10024, 975, 1, 0, 0, 0, 10025, 10026, 5, 42, 0, 0, 10026, 10027, 5, 1266, 0, 0, 10027, 10031, 3, 968, 484, 0, 10028, 10032, 3, 984, 492, 0, 10029, 10032, 3, 996, 498, 0, 10030, 10032, 5, 249, 0, 0, 10031, 10028, 1, 0, 0, 0, 10031, 10029, 1, 0, 0, 0, 10031, 10030, 1, 0, 0, 0, 10032, 977, 1, 0, 0, 0, 10033, 10034, 5, 469, 0, 0, 10034, 10035, 5, 1266, 0, 0, 10035, 10037, 3, 968, 484, 0, 10036, 10038, 5, 616, 0, 0, 10037, 10036, 1, 0, 0, 0, 10037, 10038, 1, 0, 0, 0, 10038, 979, 1, 0, 0, 0, 10039, 10042, 5, 321, 0, 0, 10040, 10041, 5, 1307, 0, 0, 10041, 10043, 5, 1562, 0, 0, 10042, 10040, 1, 0, 0, 0, 10042, 10043, 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044, 10045, 5, 1266, 0, 0, 10045, 10046, 3, 968, 484, 0, 10046, 10047, 5, 133, 0, 0, 10047, 10052, 3, 982, 491, 0, 10048, 10049, 5, 2453, 0, 0, 10049, 10051, 3, 982, 491, 0, 10050, 10048, 1, 0, 0, 0, 10051, 10054, 1, 0, 0, 0, 10052, 10050, 1, 0, 0, 0, 10052, 10053, 1, 0, 0, 0, 10053, 10058, 1, 0, 0, 0, 10054, 10052, 1, 0, 0, 0, 10055, 10056, 5, 1681, 0, 0, 10056, 10057, 5, 2472, 0, 0, 10057, 10059, 7, 21, 0, 0, 10058, 10055, 1, 0, 0, 0, 10058, 10059, 1, 0, 0, 0, 10059, 981, 1, 0, 0, 0, 10060, 10061, 5, 2447, 0, 0, 10061, 10066, 3, 2376, 1188, 0, 10062, 10063, 5, 2453, 0, 0, 10063, 10065, 3, 2376, 1188, 0, 10064, 10062, 1, 0, 0, 0, 10065, 10068, 1, 0, 0, 0, 10066, 10064, 1, 0, 0, 0, 10066, 10067, 1, 0, 0, 0, 10067, 10069, 1, 0, 0, 0, 10068, 10066, 1, 0, 0, 0, 10069, 10070, 5, 2448, 0, 0, 10070, 10072, 5, 1586, 0, 0, 10071, 10073, 5, 2447, 0, 0, 10072, 10071, 1, 0, 0, 0, 10072, 10073, 1, 0, 0, 0, 10073, 10074, 1, 0, 0, 0, 10074, 10076, 3, 2376, 1188, 0, 10075, 10077, 5, 2448, 0, 0, 10076, 10075, 1, 0, 0, 0, 10076, 10077, 1, 0, 0, 0, 10077, 10079, 1, 0, 0, 0, 10078, 10080, 3, 986, 493, 0, 10079, 10078, 1, 0, 0, 0, 10079, 10080, 1, 0, 0, 0, 10080, 10081, 1, 0, 0, 0, 10081, 10082, 3, 994, 497, 0, 10082, 983, 1, 0, 0, 0, 10083, 10084, 5, 21, 0, 0, 10084, 10085, 5, 133, 0, 0, 10085, 10086, 3, 982, 491, 0, 10086, 985, 1, 0, 0, 0, 10087, 10088, 5, 48, 0, 0, 10088, 10089, 5, 2141, 0, 0, 10089, 10092, 3, 988, 494, 0, 10090, 10092, 3, 992, 496, 0, 10091, 10087, 1, 0, 0, 0, 10091, 10090, 1, 0, 0, 0, 10092, 987, 1, 0, 0, 0, 10093, 10098, 3, 990, 495, 0, 10094, 10095, 5, 2453, 0, 0, 10095, 10097, 3, 990, 495, 0, 10096, 10094, 1, 0, 0, 0, 10097, 10100, 1, 0, 0, 0, 10098, 10096, 1, 0, 0, 0, 10098, 10099, 1, 0, 0, 0, 10099, 989, 1, 0, 0, 0, 10100, 10098, 1, 0, 0, 0, 10101, 10102, 3, 2350, 1175, 0, 10102, 10103, 5, 2447, 0, 0, 10103, 10108, 3, 2376, 1188, 0, 10104, 10105, 5, 2453, 0, 0, 10105, 10107, 3, 2376, 1188, 0, 10106, 10104, 1, 0, 0, 0, 10107, 10110, 1, 0, 0, 0, 10108, 10106, 1, 0, 0, 0, 10108, 10109, 1, 0, 0, 0, 10109, 10111, 1, 0, 0, 0, 10110, 10108, 1, 0, 0, 0, 10111, 10112, 5, 2448, 0, 0, 10112, 991, 1, 0, 0, 0, 10113, 10114, 5, 2308, 0, 0, 10114, 10115, 5, 717, 0, 0, 10115, 10116, 5, 296, 0, 0, 10116, 10117, 5, 2453, 0, 0, 10117, 10118, 5, 1622, 0, 0, 10118, 10119, 5, 296, 0, 0, 10119, 10123, 3, 2292, 1146, 0, 10120, 10121, 5, 260, 0, 0, 10121, 10122, 5, 48, 0, 0, 10122, 10124, 5, 351, 0, 0, 10123, 10120, 1, 0, 0, 0, 10123, 10124, 1, 0, 0, 0, 10124, 10128, 1, 0, 0, 0, 10125, 10126, 5, 2308, 0, 0, 10126, 10127, 5, 237, 0, 0, 10127, 10129, 5, 296, 0, 0, 10128, 10125, 1, 0, 0, 0, 10128, 10129, 1, 0, 0, 0, 10129, 993, 1, 0, 0, 0, 10130, 10131, 5, 2246, 0, 0, 10131, 10132, 3, 970, 485, 0, 10132, 995, 1, 0, 0, 0, 10133, 10134, 5, 469, 0, 0, 10134, 10135, 5, 133, 0, 0, 10135, 10136, 5, 2447, 0, 0, 10136, 10141, 3, 2376, 1188, 0, 10137, 10138, 5, 2453, 0, 0, 10138, 10140, 3, 2376, 1188, 0, 10139, 10137, 1, 0, 0, 0, 10140, 10143, 1, 0, 0, 0, 10141, 10139, 1, 0, 0, 0, 10141, 10142, 1, 0, 0, 0, 10142, 10144, 1, 0, 0, 0, 10143, 10141, 1, 0, 0, 0, 10144, 10146, 5, 2448, 0, 0, 10145, 10147, 5, 616, 0, 0, 10146, 10145, 1, 0, 0, 0, 10146, 10147, 1, 0, 0, 0, 10147, 997, 1, 0, 0, 0, 10148, 10149, 5, 321, 0, 0, 10149, 10150, 5, 919, 0, 0, 10150, 10154, 5, 2286, 0, 0, 10151, 10152, 5, 691, 0, 0, 10152, 10153, 5, 1204, 0, 0, 10153, 10155, 5, 545, 0, 0, 10154, 10151, 1, 0, 0, 0, 10154, 10155, 1, 0, 0, 0, 10155, 10156, 1, 0, 0, 0, 10156, 10159, 3, 2342, 1171, 0, 10157, 10158, 5, 1246, 0, 0, 10158, 10160, 3, 2314, 1157, 0, 10159, 10157, 1, 0, 0, 0, 10159, 10160, 1, 0, 0, 0, 10160, 10178, 1, 0, 0, 0, 10161, 10164, 5, 2447, 0, 0, 10162, 10165, 3, 1000, 500, 0, 10163, 10165, 3, 1002, 501, 0, 10164, 10162, 1, 0, 0, 0, 10164, 10163, 1, 0, 0, 0, 10165, 10173, 1, 0, 0, 0, 10166, 10169, 5, 2453, 0, 0, 10167, 10170, 3, 1000, 500, 0, 10168, 10170, 3, 1002, 501, 0, 10169, 10167, 1, 0, 0, 0, 10169, 10168, 1, 0, 0, 0, 10170, 10172, 1, 0, 0, 0, 10171, 10166, 1, 0, 0, 0, 10172, 10175, 1, 0, 0, 0, 10173, 10171, 1, 0, 0, 0, 10173, 10174, 1, 0, 0, 0, 10174, 10176, 1, 0, 0, 0, 10175, 10173, 1, 0, 0, 0, 10176, 10177, 5, 2448, 0, 0, 10177, 10179, 1, 0, 0, 0, 10178, 10161, 1, 0, 0, 0, 10178, 10179, 1, 0, 0, 0, 10179, 10200, 1, 0, 0, 0, 10180, 10181, 5, 1259, 0, 0, 10181, 10182, 5, 1434, 0, 0, 10182, 10186, 5, 2083, 0, 0, 10183, 10184, 7, 2, 0, 0, 10184, 10185, 5, 1523, 0, 0, 10185, 10187, 5, 1437, 0, 0, 10186, 10183, 1, 0, 0, 0, 10186, 10187, 1, 0, 0, 0, 10187, 10201, 1, 0, 0, 0, 10188, 10190, 3, 1202, 601, 0, 10189, 10188, 1, 0, 0, 0, 10189, 10190, 1, 0, 0, 0, 10190, 10192, 1, 0, 0, 0, 10191, 10193, 7, 109, 0, 0, 10192, 10191, 1, 0, 0, 0, 10192, 10193, 1, 0, 0, 0, 10193, 10195, 1, 0, 0, 0, 10194, 10196, 3, 928, 464, 0, 10195, 10194, 1, 0, 0, 0, 10195, 10196, 1, 0, 0, 0, 10196, 10198, 1, 0, 0, 0, 10197, 10199, 3, 926, 463, 0, 10198, 10197, 1, 0, 0, 0, 10198, 10199, 1, 0, 0, 0, 10199, 10201, 1, 0, 0, 0, 10200, 10180, 1, 0, 0, 0, 10200, 10189, 1, 0, 0, 0, 10201, 10219, 1, 0, 0, 0, 10202, 10203, 5, 2246, 0, 0, 10203, 10213, 5, 717, 0, 0, 10204, 10208, 3, 1194, 597, 0, 10205, 10206, 5, 2080, 0, 0, 10206, 10208, 3, 2404, 1202, 0, 10207, 10204, 1, 0, 0, 0, 10207, 10205, 1, 0, 0, 0, 10208, 10209, 1, 0, 0, 0, 10209, 10207, 1, 0, 0, 0, 10209, 10210, 1, 0, 0, 0, 10210, 10212, 1, 0, 0, 0, 10211, 10207, 1, 0, 0, 0, 10212, 10215, 1, 0, 0, 0, 10213, 10211, 1, 0, 0, 0, 10213, 10214, 1, 0, 0, 0, 10214, 10220, 1, 0, 0, 0, 10215, 10213, 1, 0, 0, 0, 10216, 10217, 5, 2246, 0, 0, 10217, 10218, 5, 1137, 0, 0, 10218, 10220, 5, 717, 0, 0, 10219, 10202, 1, 0, 0, 0, 10219, 10216, 1, 0, 0, 0, 10219, 10220, 1, 0, 0, 0, 10220, 10222, 1, 0, 0, 0, 10221, 10223, 3, 1004, 502, 0, 10222, 10221, 1, 0, 0, 0, 10222, 10223, 1, 0, 0, 0, 10223, 10225, 1, 0, 0, 0, 10224, 10226, 3, 1688, 844, 0, 10225, 10224, 1, 0, 0, 0, 10225, 10226, 1, 0, 0, 0, 10226, 10231, 1, 0, 0, 0, 10227, 10228, 7, 17, 0, 0, 10228, 10229, 5, 1259, 0, 0, 10229, 10230, 5, 1484, 0, 0, 10230, 10232, 5, 261, 0, 0, 10231, 10227, 1, 0, 0, 0, 10231, 10232, 1, 0, 0, 0, 10232, 10234, 1, 0, 0, 0, 10233, 10235, 3, 1006, 503, 0, 10234, 10233, 1, 0, 0, 0, 10234, 10235, 1, 0, 0, 0, 10235, 10239, 1, 0, 0, 0, 10236, 10237, 7, 17, 0, 0, 10237, 10238, 5, 263, 0, 0, 10238, 10240, 5, 1531, 0, 0, 10239, 10236, 1, 0, 0, 0, 10239, 10240, 1, 0, 0, 0, 10240, 10242, 1, 0, 0, 0, 10241, 10243, 3, 2246, 1123, 0, 10242, 10241, 1, 0, 0, 0, 10242, 10243, 1, 0, 0, 0, 10243, 10244, 1, 0, 0, 0, 10244, 10245, 5, 69, 0, 0, 10245, 10246, 3, 1868, 934, 0, 10246, 999, 1, 0, 0, 0, 10247, 10248, 5, 1628, 0, 0, 10248, 10249, 5, 620, 0, 0, 10249, 10250, 5, 2447, 0, 0, 10250, 10251, 3, 2402, 1201, 0, 10251, 10252, 5, 2448, 0, 0, 10252, 10256, 5, 785, 0, 0, 10253, 10254, 3, 2286, 1143, 0, 10254, 10255, 5, 2440, 0, 0, 10255, 10257, 1, 0, 0, 0, 10256, 10253, 1, 0, 0, 0, 10256, 10257, 1, 0, 0, 0, 10257, 10258, 1, 0, 0, 0, 10258, 10259, 3, 2402, 1201, 0, 10259, 1001, 1, 0, 0, 0, 10260, 10263, 3, 2402, 1201, 0, 10261, 10263, 3, 2400, 1200, 0, 10262, 10260, 1, 0, 0, 0, 10262, 10261, 1, 0, 0, 0, 10263, 10266, 1, 0, 0, 0, 10264, 10265, 5, 505, 0, 0, 10265, 10267, 3, 1654, 827, 0, 10266, 10264, 1, 0, 0, 0, 10266, 10267, 1, 0, 0, 0, 10267, 10270, 1, 0, 0, 0, 10268, 10271, 3, 2246, 1123, 0, 10269, 10271, 3, 1000, 500, 0, 10270, 10268, 1, 0, 0, 0, 10270, 10269, 1, 0, 0, 0, 10270, 10271, 1, 0, 0, 0, 10271, 1003, 1, 0, 0, 0, 10272, 10273, 5, 1020, 0, 0, 10273, 10313, 5, 1531, 0, 0, 10274, 10308, 5, 1531, 0, 0, 10275, 10309, 7, 113, 0, 0, 10276, 10277, 5, 1259, 0, 0, 10277, 10309, 7, 114, 0, 0, 10278, 10279, 5, 1737, 0, 0, 10279, 10282, 5, 2308, 0, 0, 10280, 10282, 5, 1025, 0, 0, 10281, 10278, 1, 0, 0, 0, 10281, 10280, 1, 0, 0, 0, 10282, 10283, 1, 0, 0, 0, 10283, 10309, 3, 2078, 1039, 0, 10284, 10288, 5, 2308, 0, 0, 10285, 10286, 5, 1451, 0, 0, 10286, 10289, 5, 816, 0, 0, 10287, 10289, 5, 1601, 0, 0, 10288, 10285, 1, 0, 0, 0, 10288, 10287, 1, 0, 0, 0, 10289, 10309, 1, 0, 0, 0, 10290, 10303, 5, 2246, 0, 0, 10291, 10293, 5, 389, 0, 0, 10292, 10294, 7, 115, 0, 0, 10293, 10292, 1, 0, 0, 0, 10293, 10294, 1, 0, 0, 0, 10294, 10295, 1, 0, 0, 0, 10295, 10296, 5, 1596, 0, 0, 10296, 10304, 5, 1645, 0, 0, 10297, 10299, 7, 115, 0, 0, 10298, 10297, 1, 0, 0, 0, 10298, 10299, 1, 0, 0, 0, 10299, 10300, 1, 0, 0, 0, 10300, 10301, 5, 1596, 0, 0, 10301, 10302, 5, 1645, 0, 0, 10302, 10304, 3, 2284, 1142, 0, 10303, 10291, 1, 0, 0, 0, 10303, 10298, 1, 0, 0, 0, 10304, 10309, 1, 0, 0, 0, 10305, 10306, 5, 2246, 0, 0, 10306, 10307, 7, 108, 0, 0, 10307, 10309, 5, 287, 0, 0, 10308, 10275, 1, 0, 0, 0, 10308, 10276, 1, 0, 0, 0, 10308, 10281, 1, 0, 0, 0, 10308, 10284, 1, 0, 0, 0, 10308, 10290, 1, 0, 0, 0, 10308, 10305, 1, 0, 0, 0, 10309, 10310, 1, 0, 0, 0, 10310, 10308, 1, 0, 0, 0, 10310, 10311, 1, 0, 0, 0, 10311, 10313, 1, 0, 0, 0, 10312, 10272, 1, 0, 0, 0, 10312, 10274, 1, 0, 0, 0, 10313, 1005, 1, 0, 0, 0, 10314, 10315, 7, 17, 0, 0, 10315, 10316, 5, 1484, 0, 0, 10316, 10318, 5, 1591, 0, 0, 10317, 10319, 3, 1008, 504, 0, 10318, 10317, 1, 0, 0, 0, 10318, 10319, 1, 0, 0, 0, 10319, 1007, 1, 0, 0, 0, 10320, 10339, 5, 2203, 0, 0, 10321, 10325, 5, 112, 0, 0, 10322, 10323, 5, 114, 0, 0, 10323, 10325, 5, 2308, 0, 0, 10324, 10321, 1, 0, 0, 0, 10324, 10322, 1, 0, 0, 0, 10325, 10326, 1, 0, 0, 0, 10326, 10327, 5, 336, 0, 0, 10327, 10340, 5, 483, 0, 0, 10328, 10332, 5, 112, 0, 0, 10329, 10330, 5, 114, 0, 0, 10330, 10332, 5, 2308, 0, 0, 10331, 10328, 1, 0, 0, 0, 10331, 10329, 1, 0, 0, 0, 10332, 10333, 1, 0, 0, 0, 10333, 10334, 5, 483, 0, 0, 10334, 10340, 3, 1454, 727, 0, 10335, 10336, 5, 114, 0, 0, 10336, 10337, 5, 2308, 0, 0, 10337, 10338, 5, 1228, 0, 0, 10338, 10340, 5, 483, 0, 0, 10339, 10324, 1, 0, 0, 0, 10339, 10331, 1, 0, 0, 0, 10339, 10335, 1, 0, 0, 0, 10340, 1009, 1, 0, 0, 0, 10341, 10342, 5, 469, 0, 0, 10342, 10343, 5, 919, 0, 0, 10343, 10344, 5, 2286, 0, 0, 10344, 10347, 3, 2342, 1171, 0, 10345, 10346, 5, 1447, 0, 0, 10346, 10348, 5, 2083, 0, 0, 10347, 10345, 1, 0, 0, 0, 10347, 10348, 1, 0, 0, 0, 10348, 1011, 1, 0, 0, 0, 10349, 10350, 5, 469, 0, 0, 10350, 10351, 5, 919, 0, 0, 10351, 10352, 5, 2286, 0, 0, 10352, 10355, 5, 888, 0, 0, 10353, 10354, 5, 691, 0, 0, 10354, 10356, 5, 545, 0, 0, 10355, 10353, 1, 0, 0, 0, 10355, 10356, 1, 0, 0, 0, 10356, 10357, 1, 0, 0, 0, 10357, 10358, 5, 1259, 0, 0, 10358, 10359, 3, 2342, 1171, 0, 10359, 1013, 1, 0, 0, 0, 10360, 10363, 5, 321, 0, 0, 10361, 10362, 5, 1307, 0, 0, 10362, 10364, 5, 1562, 0, 0, 10363, 10361, 1, 0, 0, 0, 10363, 10364, 1, 0, 0, 0, 10364, 10365, 1, 0, 0, 0, 10365, 10366, 5, 296, 0, 0, 10366, 10367, 3, 1016, 508, 0, 10367, 10371, 5, 2246, 0, 0, 10368, 10369, 3, 2350, 1175, 0, 10369, 10370, 5, 2440, 0, 0, 10370, 10372, 1, 0, 0, 0, 10371, 10368, 1, 0, 0, 0, 10371, 10372, 1, 0, 0, 0, 10372, 10373, 1, 0, 0, 0, 10373, 10378, 3, 2290, 1145, 0, 10374, 10375, 5, 741, 0, 0, 10375, 10379, 7, 73, 0, 0, 10376, 10377, 5, 5, 0, 0, 10377, 10379, 5, 643, 0, 0, 10378, 10374, 1, 0, 0, 0, 10378, 10376, 1, 0, 0, 0, 10378, 10379, 1, 0, 0, 0, 10379, 1015, 1, 0, 0, 0, 10380, 10381, 3, 2404, 1202, 0, 10381, 1017, 1, 0, 0, 0, 10382, 10383, 5, 321, 0, 0, 10383, 10384, 5, 220, 0, 0, 10384, 10385, 3, 466, 233, 0, 10385, 10386, 5, 2447, 0, 0, 10386, 10387, 3, 2340, 1170, 0, 10387, 10389, 3, 2376, 1188, 0, 10388, 10390, 5, 1709, 0, 0, 10389, 10388, 1, 0, 0, 0, 10389, 10390, 1, 0, 0, 0, 10390, 10399, 1, 0, 0, 0, 10391, 10392, 5, 2453, 0, 0, 10392, 10393, 3, 2340, 1170, 0, 10393, 10395, 3, 2376, 1188, 0, 10394, 10396, 5, 1709, 0, 0, 10395, 10394, 1, 0, 0, 0, 10395, 10396, 1, 0, 0, 0, 10396, 10398, 1, 0, 0, 0, 10397, 10391, 1, 0, 0, 0, 10398, 10401, 1, 0, 0, 0, 10399, 10397, 1, 0, 0, 0, 10399, 10400, 1, 0, 0, 0, 10400, 10402, 1, 0, 0, 0, 10401, 10399, 1, 0, 0, 0, 10402, 10422, 5, 2448, 0, 0, 10403, 10421, 3, 1194, 597, 0, 10404, 10405, 5, 1699, 0, 0, 10405, 10421, 3, 1176, 588, 0, 10406, 10407, 5, 2080, 0, 0, 10407, 10421, 3, 1656, 828, 0, 10408, 10421, 5, 717, 0, 0, 10409, 10410, 5, 1695, 0, 0, 10410, 10412, 5, 2083, 0, 0, 10411, 10409, 1, 0, 0, 0, 10411, 10412, 1, 0, 0, 0, 10412, 10413, 1, 0, 0, 0, 10413, 10414, 5, 661, 0, 0, 10414, 10418, 5, 2441, 0, 0, 10415, 10416, 5, 660, 0, 0, 10416, 10417, 5, 785, 0, 0, 10417, 10419, 3, 2078, 1039, 0, 10418, 10415, 1, 0, 0, 0, 10418, 10419, 1, 0, 0, 0, 10419, 10421, 1, 0, 0, 0, 10420, 10403, 1, 0, 0, 0, 10420, 10404, 1, 0, 0, 0, 10420, 10406, 1, 0, 0, 0, 10420, 10408, 1, 0, 0, 0, 10420, 10411, 1, 0, 0, 0, 10421, 10424, 1, 0, 0, 0, 10422, 10420, 1, 0, 0, 0, 10422, 10423, 1, 0, 0, 0, 10423, 10426, 1, 0, 0, 0, 10424, 10422, 1, 0, 0, 0, 10425, 10427, 3, 928, 464, 0, 10426, 10425, 1, 0, 0, 0, 10426, 10427, 1, 0, 0, 0, 10427, 10429, 1, 0, 0, 0, 10428, 10430, 7, 116, 0, 0, 10429, 10428, 1, 0, 0, 0, 10429, 10430, 1, 0, 0, 0, 10430, 10432, 1, 0, 0, 0, 10431, 10433, 7, 109, 0, 0, 10432, 10431, 1, 0, 0, 0, 10432, 10433, 1, 0, 0, 0, 10433, 1019, 1, 0, 0, 0, 10434, 10436, 5, 321, 0, 0, 10435, 10437, 5, 908, 0, 0, 10436, 10435, 1, 0, 0, 0, 10436, 10437, 1, 0, 0, 0, 10437, 10438, 1, 0, 0, 0, 10438, 10439, 5, 1463, 0, 0, 10439, 10440, 3, 2404, 1202, 0, 10440, 10443, 5, 858, 0, 0, 10441, 10444, 3, 1022, 511, 0, 10442, 10444, 3, 1024, 512, 0, 10443, 10441, 1, 0, 0, 0, 10443, 10442, 1, 0, 0, 0, 10444, 10445, 1, 0, 0, 0, 10445, 10443, 1, 0, 0, 0, 10445, 10446, 1, 0, 0, 0, 10446, 10448, 1, 0, 0, 0, 10447, 10449, 3, 766, 383, 0, 10448, 10447, 1, 0, 0, 0, 10448, 10449, 1, 0, 0, 0, 10449, 1021, 1, 0, 0, 0, 10450, 10451, 7, 117, 0, 0, 10451, 10459, 7, 118, 0, 0, 10452, 10456, 5, 1456, 0, 0, 10453, 10457, 3, 1176, 588, 0, 10454, 10457, 5, 2185, 0, 0, 10455, 10457, 5, 389, 0, 0, 10456, 10453, 1, 0, 0, 0, 10456, 10454, 1, 0, 0, 0, 10456, 10455, 1, 0, 0, 0, 10457, 10459, 1, 0, 0, 0, 10458, 10450, 1, 0, 0, 0, 10458, 10452, 1, 0, 0, 0, 10459, 1023, 1, 0, 0, 0, 10460, 10464, 7, 119, 0, 0, 10461, 10465, 3, 2078, 1039, 0, 10462, 10465, 5, 2185, 0, 0, 10463, 10465, 5, 389, 0, 0, 10464, 10461, 1, 0, 0, 0, 10464, 10462, 1, 0, 0, 0, 10464, 10463, 1, 0, 0, 0, 10465, 10478, 1, 0, 0, 0, 10466, 10470, 5, 1360, 0, 0, 10467, 10471, 3, 2320, 1160, 0, 10468, 10471, 5, 1228, 0, 0, 10469, 10471, 5, 389, 0, 0, 10470, 10467, 1, 0, 0, 0, 10470, 10468, 1, 0, 0, 0, 10470, 10469, 1, 0, 0, 0, 10471, 10478, 1, 0, 0, 0, 10472, 10475, 5, 1359, 0, 0, 10473, 10476, 3, 2078, 1039, 0, 10474, 10476, 5, 389, 0, 0, 10475, 10473, 1, 0, 0, 0, 10475, 10474, 1, 0, 0, 0, 10476, 10478, 1, 0, 0, 0, 10477, 10460, 1, 0, 0, 0, 10477, 10466, 1, 0, 0, 0, 10477, 10472, 1, 0, 0, 0, 10478, 1025, 1, 0, 0, 0, 10479, 10480, 5, 321, 0, 0, 10480, 10481, 5, 878, 0, 0, 10481, 10482, 5, 1463, 0, 0, 10482, 10485, 3, 2404, 1202, 0, 10483, 10486, 3, 1028, 514, 0, 10484, 10486, 3, 1030, 515, 0, 10485, 10483, 1, 0, 0, 0, 10485, 10484, 1, 0, 0, 0, 10485, 10486, 1, 0, 0, 0, 10486, 1027, 1, 0, 0, 0, 10487, 10488, 5, 628, 0, 0, 10488, 10489, 3, 2404, 1202, 0, 10489, 1029, 1, 0, 0, 0, 10490, 10491, 5, 705, 0, 0, 10491, 10492, 3, 2404, 1202, 0, 10492, 1031, 1, 0, 0, 0, 10493, 10496, 5, 321, 0, 0, 10494, 10495, 5, 1307, 0, 0, 10495, 10497, 5, 1562, 0, 0, 10496, 10494, 1, 0, 0, 0, 10496, 10497, 1, 0, 0, 0, 10497, 10499, 1, 0, 0, 0, 10498, 10500, 7, 28, 0, 0, 10499, 10498, 1, 0, 0, 0, 10499, 10500, 1, 0, 0, 0, 10500, 10501, 1, 0, 0, 0, 10501, 10503, 5, 1315, 0, 0, 10502, 10504, 3, 2404, 1202, 0, 10503, 10502, 1, 0, 0, 0, 10503, 10504, 1, 0, 0, 0, 10504, 10510, 1, 0, 0, 0, 10505, 10507, 5, 628, 0, 0, 10506, 10508, 7, 28, 0, 0, 10507, 10506, 1, 0, 0, 0, 10507, 10508, 1, 0, 0, 0, 10508, 10509, 1, 0, 0, 0, 10509, 10511, 3, 2404, 1202, 0, 10510, 10505, 1, 0, 0, 0, 10510, 10511, 1, 0, 0, 0, 10511, 10515, 1, 0, 0, 0, 10512, 10513, 5, 620, 0, 0, 10513, 10514, 5, 183, 0, 0, 10514, 10516, 3, 2404, 1202, 0, 10515, 10512, 1, 0, 0, 0, 10515, 10516, 1, 0, 0, 0, 10516, 10519, 1, 0, 0, 0, 10517, 10518, 5, 1259, 0, 0, 10518, 10520, 3, 1774, 887, 0, 10519, 10517, 1, 0, 0, 0, 10519, 10520, 1, 0, 0, 0, 10520, 1033, 1, 0, 0, 0, 10521, 10523, 5, 321, 0, 0, 10522, 10524, 5, 210, 0, 0, 10523, 10522, 1, 0, 0, 0, 10523, 10524, 1, 0, 0, 0, 10524, 10525, 1, 0, 0, 0, 10525, 10526, 5, 1574, 0, 0, 10526, 10527, 5, 1411, 0, 0, 10527, 10532, 3, 2404, 1202, 0, 10528, 10529, 5, 620, 0, 0, 10529, 10530, 5, 1409, 0, 0, 10530, 10531, 5, 350, 0, 0, 10531, 10533, 3, 2404, 1202, 0, 10532, 10528, 1, 0, 0, 0, 10532, 10533, 1, 0, 0, 0, 10533, 10538, 1, 0, 0, 0, 10534, 10535, 5, 69, 0, 0, 10535, 10536, 5, 1246, 0, 0, 10536, 10537, 7, 83, 0, 0, 10537, 10539, 3, 2078, 1039, 0, 10538, 10534, 1, 0, 0, 0, 10538, 10539, 1, 0, 0, 0, 10539, 10544, 1, 0, 0, 0, 10540, 10545, 5, 1447, 0, 0, 10541, 10542, 5, 655, 0, 0, 10542, 10543, 5, 605, 0, 0, 10543, 10545, 5, 350, 0, 0, 10544, 10540, 1, 0, 0, 0, 10544, 10541, 1, 0, 0, 0, 10544, 10545, 1, 0, 0, 0, 10545, 1035, 1, 0, 0, 0, 10546, 10547, 5, 321, 0, 0, 10547, 10548, 5, 1593, 0, 0, 10548, 10550, 3, 2308, 1154, 0, 10549, 10551, 3, 1524, 762, 0, 10550, 10549, 1, 0, 0, 0, 10550, 10551, 1, 0, 0, 0, 10551, 10553, 1, 0, 0, 0, 10552, 10554, 3, 766, 383, 0, 10553, 10552, 1, 0, 0, 0, 10553, 10554, 1, 0, 0, 0, 10554, 1037, 1, 0, 0, 0, 10555, 10565, 5, 321, 0, 0, 10556, 10557, 7, 120, 0, 0, 10557, 10566, 5, 2092, 0, 0, 10558, 10566, 5, 2385, 0, 0, 10559, 10566, 5, 2375, 0, 0, 10560, 10562, 5, 2379, 0, 0, 10561, 10560, 1, 0, 0, 0, 10561, 10562, 1, 0, 0, 0, 10562, 10563, 1, 0, 0, 0, 10563, 10566, 5, 2371, 0, 0, 10564, 10566, 5, 2379, 0, 0, 10565, 10556, 1, 0, 0, 0, 10565, 10558, 1, 0, 0, 0, 10565, 10559, 1, 0, 0, 0, 10565, 10561, 1, 0, 0, 0, 10565, 10564, 1, 0, 0, 0, 10565, 10566, 1, 0, 0, 0, 10566, 10567, 1, 0, 0, 0, 10567, 10571, 5, 2083, 0, 0, 10568, 10569, 3, 2286, 1143, 0, 10569, 10570, 5, 2440, 0, 0, 10570, 10572, 1, 0, 0, 0, 10571, 10568, 1, 0, 0, 0, 10571, 10572, 1, 0, 0, 0, 10572, 10573, 1, 0, 0, 0, 10573, 10577, 3, 1110, 555, 0, 10574, 10575, 5, 691, 0, 0, 10575, 10576, 5, 1204, 0, 0, 10576, 10578, 5, 545, 0, 0, 10577, 10574, 1, 0, 0, 0, 10577, 10578, 1, 0, 0, 0, 10578, 10589, 1, 0, 0, 0, 10579, 10580, 5, 1681, 0, 0, 10580, 10587, 5, 2472, 0, 0, 10581, 10588, 5, 948, 0, 0, 10582, 10584, 5, 2376, 0, 0, 10583, 10582, 1, 0, 0, 0, 10583, 10584, 1, 0, 0, 0, 10584, 10585, 1, 0, 0, 0, 10585, 10588, 5, 351, 0, 0, 10586, 10588, 5, 1133, 0, 0, 10587, 10581, 1, 0, 0, 0, 10587, 10583, 1, 0, 0, 0, 10587, 10586, 1, 0, 0, 0, 10588, 10590, 1, 0, 0, 0, 10589, 10579, 1, 0, 0, 0, 10589, 10590, 1, 0, 0, 0, 10590, 10594, 1, 0, 0, 0, 10591, 10595, 3, 1062, 531, 0, 10592, 10595, 3, 1040, 520, 0, 10593, 10595, 3, 1050, 525, 0, 10594, 10591, 1, 0, 0, 0, 10594, 10592, 1, 0, 0, 0, 10594, 10593, 1, 0, 0, 0, 10595, 10597, 1, 0, 0, 0, 10596, 10598, 3, 1528, 764, 0, 10597, 10596, 1, 0, 0, 0, 10597, 10598, 1, 0, 0, 0, 10598, 10601, 1, 0, 0, 0, 10599, 10600, 5, 1337, 0, 0, 10600, 10602, 3, 2342, 1171, 0, 10601, 10599, 1, 0, 0, 0, 10601, 10602, 1, 0, 0, 0, 10602, 10605, 1, 0, 0, 0, 10603, 10604, 5, 2216, 0, 0, 10604, 10606, 5, 1486, 0, 0, 10605, 10603, 1, 0, 0, 0, 10605, 10606, 1, 0, 0, 0, 10606, 1039, 1, 0, 0, 0, 10607, 10608, 5, 1246, 0, 0, 10608, 10613, 5, 2351, 0, 0, 10609, 10610, 5, 2447, 0, 0, 10610, 10611, 3, 1058, 529, 0, 10611, 10612, 5, 2448, 0, 0, 10612, 10614, 1, 0, 0, 0, 10613, 10609, 1, 0, 0, 0, 10613, 10614, 1, 0, 0, 0, 10614, 10617, 1, 0, 0, 0, 10615, 10616, 5, 2351, 0, 0, 10616, 10618, 3, 1046, 523, 0, 10617, 10615, 1, 0, 0, 0, 10617, 10618, 1, 0, 0, 0, 10618, 10620, 1, 0, 0, 0, 10619, 10621, 3, 1048, 524, 0, 10620, 10619, 1, 0, 0, 0, 10620, 10621, 1, 0, 0, 0, 10621, 10623, 1, 0, 0, 0, 10622, 10624, 3, 1042, 521, 0, 10623, 10622, 1, 0, 0, 0, 10623, 10624, 1, 0, 0, 0, 10624, 10629, 1, 0, 0, 0, 10625, 10626, 5, 1259, 0, 0, 10626, 10627, 5, 242, 0, 0, 10627, 10628, 7, 121, 0, 0, 10628, 10630, 5, 1607, 0, 0, 10629, 10625, 1, 0, 0, 0, 10629, 10630, 1, 0, 0, 0, 10630, 10632, 1, 0, 0, 0, 10631, 10633, 3, 1056, 528, 0, 10632, 10631, 1, 0, 0, 0, 10632, 10633, 1, 0, 0, 0, 10633, 10635, 1, 0, 0, 0, 10634, 10636, 3, 1054, 527, 0, 10635, 10634, 1, 0, 0, 0, 10635, 10636, 1, 0, 0, 0, 10636, 10638, 1, 0, 0, 0, 10637, 10639, 3, 1202, 601, 0, 10638, 10637, 1, 0, 0, 0, 10638, 10639, 1, 0, 0, 0, 10639, 10641, 1, 0, 0, 0, 10640, 10642, 3, 1084, 542, 0, 10641, 10640, 1, 0, 0, 0, 10641, 10642, 1, 0, 0, 0, 10642, 1041, 1, 0, 0, 0, 10643, 10644, 5, 2288, 0, 0, 10644, 10645, 5, 238, 0, 0, 10645, 10646, 5, 2447, 0, 0, 10646, 10647, 3, 2340, 1170, 0, 10647, 10648, 5, 69, 0, 0, 10648, 10649, 5, 2447, 0, 0, 10649, 10650, 3, 2078, 1039, 0, 10650, 10660, 5, 2448, 0, 0, 10651, 10652, 5, 2453, 0, 0, 10652, 10653, 3, 2340, 1170, 0, 10653, 10654, 5, 69, 0, 0, 10654, 10655, 5, 2447, 0, 0, 10655, 10656, 3, 2078, 1039, 0, 10656, 10657, 5, 2448, 0, 0, 10657, 10659, 1, 0, 0, 0, 10658, 10651, 1, 0, 0, 0, 10659, 10662, 1, 0, 0, 0, 10660, 10658, 1, 0, 0, 0, 10660, 10661, 1, 0, 0, 0, 10661, 10663, 1, 0, 0, 0, 10662, 10660, 1, 0, 0, 0, 10663, 10664, 5, 2448, 0, 0, 10664, 1043, 1, 0, 0, 0, 10665, 10667, 5, 2351, 0, 0, 10666, 10668, 5, 237, 0, 0, 10667, 10666, 1, 0, 0, 0, 10667, 10668, 1, 0, 0, 0, 10668, 10669, 1, 0, 0, 0, 10669, 10671, 3, 2340, 1170, 0, 10670, 10672, 3, 1046, 523, 0, 10671, 10670, 1, 0, 0, 0, 10671, 10672, 1, 0, 0, 0, 10672, 10674, 1, 0, 0, 0, 10673, 10675, 3, 1048, 524, 0, 10674, 10673, 1, 0, 0, 0, 10674, 10675, 1, 0, 0, 0, 10675, 1045, 1, 0, 0, 0, 10676, 10677, 5, 1763, 0, 0, 10677, 10701, 5, 69, 0, 0, 10678, 10679, 5, 1238, 0, 0, 10679, 10702, 5, 1551, 0, 0, 10680, 10682, 7, 122, 0, 0, 10681, 10680, 1, 0, 0, 0, 10681, 10682, 1, 0, 0, 0, 10682, 10686, 1, 0, 0, 0, 10683, 10687, 5, 215, 0, 0, 10684, 10685, 5, 124, 0, 0, 10685, 10687, 5, 2352, 0, 0, 10686, 10683, 1, 0, 0, 0, 10686, 10684, 1, 0, 0, 0, 10687, 10699, 1, 0, 0, 0, 10688, 10693, 3, 1634, 817, 0, 10689, 10690, 5, 2447, 0, 0, 10690, 10691, 3, 1646, 823, 0, 10691, 10692, 5, 2448, 0, 0, 10692, 10694, 1, 0, 0, 0, 10693, 10689, 1, 0, 0, 0, 10693, 10694, 1, 0, 0, 0, 10694, 10700, 1, 0, 0, 0, 10695, 10696, 5, 2447, 0, 0, 10696, 10697, 3, 1646, 823, 0, 10697, 10698, 5, 2448, 0, 0, 10698, 10700, 1, 0, 0, 0, 10699, 10688, 1, 0, 0, 0, 10699, 10695, 1, 0, 0, 0, 10699, 10700, 1, 0, 0, 0, 10700, 10702, 1, 0, 0, 0, 10701, 10678, 1, 0, 0, 0, 10701, 10681, 1, 0, 0, 0, 10702, 10708, 1, 0, 0, 0, 10703, 10704, 5, 1763, 0, 0, 10704, 10705, 5, 2266, 0, 0, 10705, 10706, 5, 69, 0, 0, 10706, 10708, 7, 97, 0, 0, 10707, 10676, 1, 0, 0, 0, 10707, 10703, 1, 0, 0, 0, 10708, 1047, 1, 0, 0, 0, 10709, 10710, 5, 2345, 0, 0, 10710, 10712, 5, 2444, 0, 0, 10711, 10709, 1, 0, 0, 0, 10711, 10712, 1, 0, 0, 0, 10712, 10713, 1, 0, 0, 0, 10713, 10714, 5, 486, 0, 0, 10714, 10718, 5, 2444, 0, 0, 10715, 10716, 3, 1310, 655, 0, 10716, 10717, 5, 1138, 0, 0, 10717, 10719, 1, 0, 0, 0, 10718, 10715, 1, 0, 0, 0, 10718, 10719, 1, 0, 0, 0, 10719, 10723, 1, 0, 0, 0, 10720, 10721, 3, 1310, 655, 0, 10721, 10722, 5, 56, 0, 0, 10722, 10724, 1, 0, 0, 0, 10723, 10720, 1, 0, 0, 0, 10723, 10724, 1, 0, 0, 0, 10724, 1049, 1, 0, 0, 0, 10725, 10729, 5, 1246, 0, 0, 10726, 10727, 3, 2286, 1143, 0, 10727, 10728, 5, 2440, 0, 0, 10728, 10730, 1, 0, 0, 0, 10729, 10726, 1, 0, 0, 0, 10729, 10730, 1, 0, 0, 0, 10730, 10731, 1, 0, 0, 0, 10731, 10733, 3, 1052, 526, 0, 10732, 10734, 3, 1060, 530, 0, 10733, 10732, 1, 0, 0, 0, 10733, 10734, 1, 0, 0, 0, 10734, 10746, 1, 0, 0, 0, 10735, 10736, 5, 2447, 0, 0, 10736, 10741, 3, 1058, 529, 0, 10737, 10738, 5, 2453, 0, 0, 10738, 10740, 3, 1058, 529, 0, 10739, 10737, 1, 0, 0, 0, 10740, 10743, 1, 0, 0, 0, 10741, 10739, 1, 0, 0, 0, 10741, 10742, 1, 0, 0, 0, 10742, 10744, 1, 0, 0, 0, 10743, 10741, 1, 0, 0, 0, 10744, 10745, 5, 2448, 0, 0, 10745, 10747, 1, 0, 0, 0, 10746, 10735, 1, 0, 0, 0, 10746, 10747, 1, 0, 0, 0, 10747, 10752, 1, 0, 0, 0, 10748, 10749, 5, 1259, 0, 0, 10749, 10750, 5, 242, 0, 0, 10750, 10751, 7, 121, 0, 0, 10751, 10753, 5, 1607, 0, 0, 10752, 10748, 1, 0, 0, 0, 10752, 10753, 1, 0, 0, 0, 10753, 10755, 1, 0, 0, 0, 10754, 10756, 3, 1056, 528, 0, 10755, 10754, 1, 0, 0, 0, 10755, 10756, 1, 0, 0, 0, 10756, 10758, 1, 0, 0, 0, 10757, 10759, 3, 1054, 527, 0, 10758, 10757, 1, 0, 0, 0, 10758, 10759, 1, 0, 0, 0, 10759, 10761, 1, 0, 0, 0, 10760, 10762, 3, 1202, 601, 0, 10761, 10760, 1, 0, 0, 0, 10761, 10762, 1, 0, 0, 0, 10762, 10764, 1, 0, 0, 0, 10763, 10765, 3, 1084, 542, 0, 10764, 10763, 1, 0, 0, 0, 10764, 10765, 1, 0, 0, 0, 10765, 1051, 1, 0, 0, 0, 10766, 10767, 3, 2410, 1205, 0, 10767, 1053, 1, 0, 0, 0, 10768, 10770, 5, 1247, 0, 0, 10769, 10771, 3, 2328, 1164, 0, 10770, 10769, 1, 0, 0, 0, 10770, 10771, 1, 0, 0, 0, 10771, 10772, 1, 0, 0, 0, 10772, 10776, 5, 2447, 0, 0, 10773, 10777, 3, 1194, 597, 0, 10774, 10775, 5, 2080, 0, 0, 10775, 10777, 3, 1656, 828, 0, 10776, 10773, 1, 0, 0, 0, 10776, 10774, 1, 0, 0, 0, 10777, 10778, 1, 0, 0, 0, 10778, 10776, 1, 0, 0, 0, 10778, 10779, 1, 0, 0, 0, 10779, 10780, 1, 0, 0, 0, 10780, 10781, 5, 2448, 0, 0, 10781, 1055, 1, 0, 0, 0, 10782, 10783, 5, 1238, 0, 0, 10783, 10784, 5, 686, 0, 0, 10784, 10789, 5, 785, 0, 0, 10785, 10786, 5, 1949, 0, 0, 10786, 10790, 5, 640, 0, 0, 10787, 10788, 5, 1451, 0, 0, 10788, 10790, 5, 816, 0, 0, 10789, 10785, 1, 0, 0, 0, 10789, 10787, 1, 0, 0, 0, 10790, 1057, 1, 0, 0, 0, 10791, 10794, 3, 2340, 1170, 0, 10792, 10794, 3, 2280, 1140, 0, 10793, 10791, 1, 0, 0, 0, 10793, 10792, 1, 0, 0, 0, 10794, 10797, 1, 0, 0, 0, 10795, 10796, 5, 389, 0, 0, 10796, 10798, 3, 2078, 1039, 0, 10797, 10795, 1, 0, 0, 0, 10797, 10798, 1, 0, 0, 0, 10798, 10808, 1, 0, 0, 0, 10799, 10804, 3, 846, 423, 0, 10800, 10801, 5, 2453, 0, 0, 10801, 10803, 3, 846, 423, 0, 10802, 10800, 1, 0, 0, 0, 10803, 10806, 1, 0, 0, 0, 10804, 10802, 1, 0, 0, 0, 10804, 10805, 1, 0, 0, 0, 10805, 10809, 1, 0, 0, 0, 10806, 10804, 1, 0, 0, 0, 10807, 10809, 3, 848, 424, 0, 10808, 10799, 1, 0, 0, 0, 10808, 10807, 1, 0, 0, 0, 10808, 10809, 1, 0, 0, 0, 10809, 10814, 1, 0, 0, 0, 10810, 10814, 3, 852, 426, 0, 10811, 10814, 3, 850, 425, 0, 10812, 10814, 3, 1698, 849, 0, 10813, 10793, 1, 0, 0, 0, 10813, 10810, 1, 0, 0, 0, 10813, 10811, 1, 0, 0, 0, 10813, 10812, 1, 0, 0, 0, 10814, 1059, 1, 0, 0, 0, 10815, 10817, 5, 1204, 0, 0, 10816, 10815, 1, 0, 0, 0, 10816, 10817, 1, 0, 0, 0, 10817, 10818, 1, 0, 0, 0, 10818, 10819, 5, 1780, 0, 0, 10819, 10820, 5, 82, 0, 0, 10820, 10821, 5, 38, 0, 0, 10821, 10822, 5, 848, 0, 0, 10822, 1061, 1, 0, 0, 0, 10823, 10824, 5, 2447, 0, 0, 10824, 10829, 3, 1112, 556, 0, 10825, 10826, 5, 2453, 0, 0, 10826, 10828, 3, 1112, 556, 0, 10827, 10825, 1, 0, 0, 0, 10828, 10831, 1, 0, 0, 0, 10829, 10827, 1, 0, 0, 0, 10829, 10830, 1, 0, 0, 0, 10830, 10832, 1, 0, 0, 0, 10831, 10829, 1, 0, 0, 0, 10832, 10833, 5, 2448, 0, 0, 10833, 10835, 1, 0, 0, 0, 10834, 10823, 1, 0, 0, 0, 10834, 10835, 1, 0, 0, 0, 10835, 10837, 1, 0, 0, 0, 10836, 10838, 3, 1064, 532, 0, 10837, 10836, 1, 0, 0, 0, 10837, 10838, 1, 0, 0, 0, 10838, 1063, 1, 0, 0, 0, 10839, 10841, 3, 1066, 533, 0, 10840, 10839, 1, 0, 0, 0, 10841, 10842, 1, 0, 0, 0, 10842, 10840, 1, 0, 0, 0, 10842, 10843, 1, 0, 0, 0, 10843, 1065, 1, 0, 0, 0, 10844, 10860, 3, 1068, 534, 0, 10845, 10860, 3, 1074, 537, 0, 10846, 10847, 5, 389, 0, 0, 10847, 10848, 5, 2373, 0, 0, 10848, 10860, 3, 1082, 541, 0, 10849, 10850, 5, 1259, 0, 0, 10850, 10855, 5, 242, 0, 0, 10851, 10852, 7, 123, 0, 0, 10852, 10856, 5, 2374, 0, 0, 10853, 10854, 7, 121, 0, 0, 10854, 10856, 5, 1607, 0, 0, 10855, 10851, 1, 0, 0, 0, 10855, 10853, 1, 0, 0, 0, 10856, 10860, 1, 0, 0, 0, 10857, 10860, 3, 1202, 601, 0, 10858, 10860, 3, 1084, 542, 0, 10859, 10844, 1, 0, 0, 0, 10859, 10845, 1, 0, 0, 0, 10859, 10846, 1, 0, 0, 0, 10859, 10849, 1, 0, 0, 0, 10859, 10857, 1, 0, 0, 0, 10859, 10858, 1, 0, 0, 0, 10860, 1067, 1, 0, 0, 0, 10861, 10864, 3, 1070, 535, 0, 10862, 10864, 3, 1072, 536, 0, 10863, 10861, 1, 0, 0, 0, 10863, 10862, 1, 0, 0, 0, 10864, 1069, 1, 0, 0, 0, 10865, 10866, 5, 1137, 0, 0, 10866, 10872, 5, 469, 0, 0, 10867, 10868, 5, 2202, 0, 0, 10868, 10869, 3, 2396, 1198, 0, 10869, 10870, 5, 366, 0, 0, 10870, 10871, 5, 2378, 0, 0, 10871, 10873, 1, 0, 0, 0, 10872, 10867, 1, 0, 0, 0, 10872, 10873, 1, 0, 0, 0, 10873, 1071, 1, 0, 0, 0, 10874, 10875, 5, 1137, 0, 0, 10875, 10887, 5, 403, 0, 0, 10876, 10878, 5, 879, 0, 0, 10877, 10876, 1, 0, 0, 0, 10877, 10878, 1, 0, 0, 0, 10878, 10888, 1, 0, 0, 0, 10879, 10880, 5, 2202, 0, 0, 10880, 10881, 3, 2396, 1198, 0, 10881, 10882, 5, 366, 0, 0, 10882, 10883, 5, 33, 0, 0, 10883, 10885, 5, 756, 0, 0, 10884, 10886, 5, 879, 0, 0, 10885, 10884, 1, 0, 0, 0, 10885, 10886, 1, 0, 0, 0, 10886, 10888, 1, 0, 0, 0, 10887, 10877, 1, 0, 0, 0, 10887, 10879, 1, 0, 0, 0, 10888, 1073, 1, 0, 0, 0, 10889, 10890, 3, 1076, 538, 0, 10890, 10891, 3, 1078, 539, 0, 10891, 10892, 3, 1080, 540, 0, 10892, 1075, 1, 0, 0, 0, 10893, 10894, 5, 1137, 0, 0, 10894, 10900, 5, 469, 0, 0, 10895, 10896, 5, 2202, 0, 0, 10896, 10897, 3, 2396, 1198, 0, 10897, 10898, 5, 366, 0, 0, 10898, 10899, 5, 2378, 0, 0, 10899, 10901, 1, 0, 0, 0, 10900, 10895, 1, 0, 0, 0, 10900, 10901, 1, 0, 0, 0, 10901, 1077, 1, 0, 0, 0, 10902, 10903, 5, 1137, 0, 0, 10903, 10915, 5, 403, 0, 0, 10904, 10906, 5, 879, 0, 0, 10905, 10904, 1, 0, 0, 0, 10905, 10906, 1, 0, 0, 0, 10906, 10916, 1, 0, 0, 0, 10907, 10908, 5, 2202, 0, 0, 10908, 10909, 3, 2396, 1198, 0, 10909, 10910, 5, 366, 0, 0, 10910, 10911, 5, 33, 0, 0, 10911, 10913, 5, 756, 0, 0, 10912, 10914, 5, 879, 0, 0, 10913, 10912, 1, 0, 0, 0, 10913, 10914, 1, 0, 0, 0, 10914, 10916, 1, 0, 0, 0, 10915, 10905, 1, 0, 0, 0, 10915, 10907, 1, 0, 0, 0, 10916, 1079, 1, 0, 0, 0, 10917, 10918, 5, 2377, 0, 0, 10918, 10919, 5, 2246, 0, 0, 10919, 10920, 5, 2384, 0, 0, 10920, 10921, 5, 2285, 0, 0, 10921, 10922, 5, 2386, 0, 0, 10922, 1081, 1, 0, 0, 0, 10923, 10924, 3, 2402, 1201, 0, 10924, 1083, 1, 0, 0, 0, 10925, 10956, 3, 1660, 830, 0, 10926, 10956, 3, 1086, 543, 0, 10927, 10956, 3, 1088, 544, 0, 10928, 10956, 3, 1114, 557, 0, 10929, 10956, 3, 1090, 545, 0, 10930, 10956, 7, 109, 0, 0, 10931, 10956, 3, 112, 56, 0, 10932, 10956, 3, 928, 464, 0, 10933, 10956, 3, 522, 261, 0, 10934, 10956, 7, 116, 0, 0, 10935, 10956, 3, 1584, 792, 0, 10936, 10956, 3, 1272, 636, 0, 10937, 10956, 3, 1108, 554, 0, 10938, 10956, 3, 1274, 637, 0, 10939, 10956, 3, 1202, 601, 0, 10940, 10941, 5, 1606, 0, 0, 10941, 10956, 5, 63, 0, 0, 10942, 10943, 5, 69, 0, 0, 10943, 10956, 3, 1868, 934, 0, 10944, 10945, 5, 620, 0, 0, 10945, 10946, 5, 538, 0, 0, 10946, 10947, 5, 2308, 0, 0, 10947, 10951, 5, 2083, 0, 0, 10948, 10949, 3, 2286, 1143, 0, 10949, 10950, 5, 2440, 0, 0, 10950, 10952, 1, 0, 0, 0, 10951, 10948, 1, 0, 0, 0, 10951, 10952, 1, 0, 0, 0, 10952, 10953, 1, 0, 0, 0, 10953, 10956, 3, 1110, 555, 0, 10954, 10956, 3, 2246, 1123, 0, 10955, 10925, 1, 0, 0, 0, 10955, 10926, 1, 0, 0, 0, 10955, 10927, 1, 0, 0, 0, 10955, 10928, 1, 0, 0, 0, 10955, 10929, 1, 0, 0, 0, 10955, 10930, 1, 0, 0, 0, 10955, 10931, 1, 0, 0, 0, 10955, 10932, 1, 0, 0, 0, 10955, 10933, 1, 0, 0, 0, 10955, 10934, 1, 0, 0, 0, 10955, 10935, 1, 0, 0, 0, 10955, 10936, 1, 0, 0, 0, 10955, 10937, 1, 0, 0, 0, 10955, 10938, 1, 0, 0, 0, 10955, 10939, 1, 0, 0, 0, 10955, 10940, 1, 0, 0, 0, 10955, 10942, 1, 0, 0, 0, 10955, 10944, 1, 0, 0, 0, 10955, 10954, 1, 0, 0, 0, 10956, 1085, 1, 0, 0, 0, 10957, 10958, 5, 1505, 0, 0, 10958, 10959, 7, 11, 0, 0, 10959, 1087, 1, 0, 0, 0, 10960, 10961, 5, 718, 0, 0, 10961, 10962, 7, 100, 0, 0, 10962, 1089, 1, 0, 0, 0, 10963, 10965, 5, 224, 0, 0, 10964, 10966, 3, 1092, 546, 0, 10965, 10964, 1, 0, 0, 0, 10965, 10966, 1, 0, 0, 0, 10966, 10967, 1, 0, 0, 0, 10967, 10973, 3, 1098, 549, 0, 10968, 10970, 3, 1104, 552, 0, 10969, 10968, 1, 0, 0, 0, 10969, 10970, 1, 0, 0, 0, 10970, 10971, 1, 0, 0, 0, 10971, 10972, 5, 1259, 0, 0, 10972, 10974, 5, 867, 0, 0, 10973, 10969, 1, 0, 0, 0, 10973, 10974, 1, 0, 0, 0, 10974, 10981, 1, 0, 0, 0, 10975, 10977, 3, 1104, 552, 0, 10976, 10975, 1, 0, 0, 0, 10976, 10977, 1, 0, 0, 0, 10977, 10978, 1, 0, 0, 0, 10978, 10979, 5, 1259, 0, 0, 10979, 10980, 5, 351, 0, 0, 10980, 10982, 5, 991, 0, 0, 10981, 10976, 1, 0, 0, 0, 10981, 10982, 1, 0, 0, 0, 10982, 10984, 1, 0, 0, 0, 10983, 10985, 3, 1106, 553, 0, 10984, 10983, 1, 0, 0, 0, 10984, 10985, 1, 0, 0, 0, 10985, 1091, 1, 0, 0, 0, 10986, 10987, 3, 2286, 1143, 0, 10987, 10988, 5, 2440, 0, 0, 10988, 10990, 1, 0, 0, 0, 10989, 10986, 1, 0, 0, 0, 10989, 10990, 1, 0, 0, 0, 10990, 10991, 1, 0, 0, 0, 10991, 10992, 3, 1110, 555, 0, 10992, 10997, 3, 1094, 547, 0, 10993, 10994, 5, 2453, 0, 0, 10994, 10996, 3, 1094, 547, 0, 10995, 10993, 1, 0, 0, 0, 10996, 10999, 1, 0, 0, 0, 10997, 10995, 1, 0, 0, 0, 10997, 10998, 1, 0, 0, 0, 10998, 1093, 1, 0, 0, 0, 10999, 10997, 1, 0, 0, 0, 11000, 11004, 5, 794, 0, 0, 11001, 11002, 3, 2286, 1143, 0, 11002, 11003, 5, 2440, 0, 0, 11003, 11005, 1, 0, 0, 0, 11004, 11001, 1, 0, 0, 0, 11004, 11005, 1, 0, 0, 0, 11005, 11006, 1, 0, 0, 0, 11006, 11007, 3, 1110, 555, 0, 11007, 11008, 5, 1259, 0, 0, 11008, 11009, 5, 2447, 0, 0, 11009, 11010, 3, 1096, 548, 0, 11010, 11011, 5, 2448, 0, 0, 11011, 1095, 1, 0, 0, 0, 11012, 11013, 3, 2078, 1039, 0, 11013, 1097, 1, 0, 0, 0, 11014, 11016, 5, 160, 0, 0, 11015, 11017, 7, 124, 0, 0, 11016, 11015, 1, 0, 0, 0, 11016, 11017, 1, 0, 0, 0, 11017, 11018, 1, 0, 0, 0, 11018, 11019, 5, 1303, 0, 0, 11019, 11020, 3, 1100, 550, 0, 11020, 1099, 1, 0, 0, 0, 11021, 11034, 3, 1102, 551, 0, 11022, 11023, 5, 2447, 0, 0, 11023, 11028, 3, 1102, 551, 0, 11024, 11025, 5, 2453, 0, 0, 11025, 11027, 3, 1102, 551, 0, 11026, 11024, 1, 0, 0, 0, 11027, 11030, 1, 0, 0, 0, 11028, 11026, 1, 0, 0, 0, 11028, 11029, 1, 0, 0, 0, 11029, 11031, 1, 0, 0, 0, 11030, 11028, 1, 0, 0, 0, 11031, 11032, 5, 2448, 0, 0, 11032, 11034, 1, 0, 0, 0, 11033, 11021, 1, 0, 0, 0, 11033, 11022, 1, 0, 0, 0, 11034, 1101, 1, 0, 0, 0, 11035, 11036, 5, 2447, 0, 0, 11036, 11041, 3, 2340, 1170, 0, 11037, 11038, 5, 2453, 0, 0, 11038, 11040, 3, 2340, 1170, 0, 11039, 11037, 1, 0, 0, 0, 11040, 11043, 1, 0, 0, 0, 11041, 11039, 1, 0, 0, 0, 11041, 11042, 1, 0, 0, 0, 11042, 11044, 1, 0, 0, 0, 11043, 11041, 1, 0, 0, 0, 11044, 11045, 5, 2448, 0, 0, 11045, 1103, 1, 0, 0, 0, 11046, 11047, 7, 125, 0, 0, 11047, 1105, 1, 0, 0, 0, 11048, 11049, 5, 2308, 0, 0, 11049, 11050, 5, 919, 0, 0, 11050, 11055, 5, 2362, 0, 0, 11051, 11052, 5, 2447, 0, 0, 11052, 11053, 3, 966, 483, 0, 11053, 11054, 5, 2448, 0, 0, 11054, 11056, 1, 0, 0, 0, 11055, 11051, 1, 0, 0, 0, 11055, 11056, 1, 0, 0, 0, 11056, 11061, 1, 0, 0, 0, 11057, 11058, 5, 2306, 0, 0, 11058, 11059, 5, 919, 0, 0, 11059, 11061, 5, 2362, 0, 0, 11060, 11048, 1, 0, 0, 0, 11060, 11057, 1, 0, 0, 0, 11061, 1107, 1, 0, 0, 0, 11062, 11063, 5, 429, 0, 0, 11063, 11064, 5, 885, 0, 0, 11064, 11082, 5, 1563, 0, 0, 11065, 11066, 5, 499, 0, 0, 11066, 11067, 5, 885, 0, 0, 11067, 11079, 5, 1563, 0, 0, 11068, 11072, 5, 38, 0, 0, 11069, 11070, 5, 40, 0, 0, 11070, 11072, 5, 1215, 0, 0, 11071, 11068, 1, 0, 0, 0, 11071, 11069, 1, 0, 0, 0, 11072, 11073, 1, 0, 0, 0, 11073, 11080, 5, 819, 0, 0, 11074, 11076, 5, 1137, 0, 0, 11075, 11074, 1, 0, 0, 0, 11075, 11076, 1, 0, 0, 0, 11076, 11077, 1, 0, 0, 0, 11077, 11078, 5, 1344, 0, 0, 11078, 11080, 5, 801, 0, 0, 11079, 11071, 1, 0, 0, 0, 11079, 11075, 1, 0, 0, 0, 11079, 11080, 1, 0, 0, 0, 11080, 11082, 1, 0, 0, 0, 11081, 11062, 1, 0, 0, 0, 11081, 11065, 1, 0, 0, 0, 11082, 1109, 1, 0, 0, 0, 11083, 11084, 3, 2402, 1201, 0, 11084, 1111, 1, 0, 0, 0, 11085, 11092, 3, 852, 426, 0, 11086, 11092, 3, 850, 425, 0, 11087, 11092, 3, 1670, 835, 0, 11088, 11092, 3, 1680, 840, 0, 11089, 11092, 3, 1664, 832, 0, 11090, 11092, 3, 1698, 849, 0, 11091, 11085, 1, 0, 0, 0, 11091, 11086, 1, 0, 0, 0, 11091, 11087, 1, 0, 0, 0, 11091, 11088, 1, 0, 0, 0, 11091, 11089, 1, 0, 0, 0, 11091, 11090, 1, 0, 0, 0, 11092, 1113, 1, 0, 0, 0, 11093, 11102, 3, 1116, 558, 0, 11094, 11102, 3, 1118, 559, 0, 11095, 11102, 3, 1120, 560, 0, 11096, 11102, 3, 1128, 564, 0, 11097, 11102, 3, 1130, 565, 0, 11098, 11102, 3, 1132, 566, 0, 11099, 11102, 3, 1134, 567, 0, 11100, 11102, 3, 1138, 569, 0, 11101, 11093, 1, 0, 0, 0, 11101, 11094, 1, 0, 0, 0, 11101, 11095, 1, 0, 0, 0, 11101, 11096, 1, 0, 0, 0, 11101, 11097, 1, 0, 0, 0, 11101, 11098, 1, 0, 0, 0, 11101, 11099, 1, 0, 0, 0, 11101, 11100, 1, 0, 0, 0, 11102, 1115, 1, 0, 0, 0, 11103, 11104, 5, 1348, 0, 0, 11104, 11105, 5, 160, 0, 0, 11105, 11106, 5, 1495, 0, 0, 11106, 11107, 5, 2447, 0, 0, 11107, 11112, 3, 2340, 1170, 0, 11108, 11109, 5, 2453, 0, 0, 11109, 11111, 3, 2340, 1170, 0, 11110, 11108, 1, 0, 0, 0, 11111, 11114, 1, 0, 0, 0, 11112, 11110, 1, 0, 0, 0, 11112, 11113, 1, 0, 0, 0, 11113, 11115, 1, 0, 0, 0, 11114, 11112, 1, 0, 0, 0, 11115, 11135, 5, 2448, 0, 0, 11116, 11117, 5, 776, 0, 0, 11117, 11118, 5, 2447, 0, 0, 11118, 11119, 3, 2078, 1039, 0, 11119, 11133, 5, 2448, 0, 0, 11120, 11121, 5, 1763, 0, 0, 11121, 11122, 5, 738, 0, 0, 11122, 11123, 5, 2447, 0, 0, 11123, 11128, 3, 1656, 828, 0, 11124, 11125, 5, 2453, 0, 0, 11125, 11127, 3, 1656, 828, 0, 11126, 11124, 1, 0, 0, 0, 11127, 11130, 1, 0, 0, 0, 11128, 11126, 1, 0, 0, 0, 11128, 11129, 1, 0, 0, 0, 11129, 11131, 1, 0, 0, 0, 11130, 11128, 1, 0, 0, 0, 11131, 11132, 5, 2448, 0, 0, 11132, 11134, 1, 0, 0, 0, 11133, 11120, 1, 0, 0, 0, 11133, 11134, 1, 0, 0, 0, 11134, 11136, 1, 0, 0, 0, 11135, 11116, 1, 0, 0, 0, 11135, 11136, 1, 0, 0, 0, 11136, 11137, 1, 0, 0, 0, 11137, 11138, 5, 2447, 0, 0, 11138, 11140, 5, 1348, 0, 0, 11139, 11141, 3, 1696, 848, 0, 11140, 11139, 1, 0, 0, 0, 11140, 11141, 1, 0, 0, 0, 11141, 11142, 1, 0, 0, 0, 11142, 11143, 3, 1164, 582, 0, 11143, 11154, 3, 1170, 585, 0, 11144, 11145, 5, 2453, 0, 0, 11145, 11147, 5, 1348, 0, 0, 11146, 11148, 3, 1696, 848, 0, 11147, 11146, 1, 0, 0, 0, 11147, 11148, 1, 0, 0, 0, 11148, 11149, 1, 0, 0, 0, 11149, 11150, 3, 1164, 582, 0, 11150, 11151, 3, 1170, 585, 0, 11151, 11153, 1, 0, 0, 0, 11152, 11144, 1, 0, 0, 0, 11153, 11156, 1, 0, 0, 0, 11154, 11152, 1, 0, 0, 0, 11154, 11155, 1, 0, 0, 0, 11155, 11157, 1, 0, 0, 0, 11156, 11154, 1, 0, 0, 0, 11157, 11158, 5, 2448, 0, 0, 11158, 1117, 1, 0, 0, 0, 11159, 11160, 5, 1348, 0, 0, 11160, 11161, 5, 160, 0, 0, 11161, 11162, 5, 862, 0, 0, 11162, 11163, 5, 2447, 0, 0, 11163, 11164, 3, 2340, 1170, 0, 11164, 11181, 5, 2448, 0, 0, 11165, 11179, 5, 95, 0, 0, 11166, 11167, 5, 1763, 0, 0, 11167, 11168, 5, 738, 0, 0, 11168, 11169, 5, 2447, 0, 0, 11169, 11174, 3, 1656, 828, 0, 11170, 11171, 5, 2453, 0, 0, 11171, 11173, 3, 1656, 828, 0, 11172, 11170, 1, 0, 0, 0, 11173, 11176, 1, 0, 0, 0, 11174, 11172, 1, 0, 0, 0, 11174, 11175, 1, 0, 0, 0, 11175, 11177, 1, 0, 0, 0, 11176, 11174, 1, 0, 0, 0, 11177, 11178, 5, 2448, 0, 0, 11178, 11180, 1, 0, 0, 0, 11179, 11166, 1, 0, 0, 0, 11179, 11180, 1, 0, 0, 0, 11180, 11182, 1, 0, 0, 0, 11181, 11165, 1, 0, 0, 0, 11181, 11182, 1, 0, 0, 0, 11182, 11205, 1, 0, 0, 0, 11183, 11184, 5, 2447, 0, 0, 11184, 11186, 5, 1348, 0, 0, 11185, 11187, 3, 1696, 848, 0, 11186, 11185, 1, 0, 0, 0, 11186, 11187, 1, 0, 0, 0, 11187, 11188, 1, 0, 0, 0, 11188, 11189, 3, 1168, 584, 0, 11189, 11200, 3, 1170, 585, 0, 11190, 11191, 5, 2453, 0, 0, 11191, 11193, 5, 1348, 0, 0, 11192, 11194, 3, 1696, 848, 0, 11193, 11192, 1, 0, 0, 0, 11193, 11194, 1, 0, 0, 0, 11194, 11195, 1, 0, 0, 0, 11195, 11196, 3, 1168, 584, 0, 11196, 11197, 3, 1170, 585, 0, 11197, 11199, 1, 0, 0, 0, 11198, 11190, 1, 0, 0, 0, 11199, 11202, 1, 0, 0, 0, 11200, 11198, 1, 0, 0, 0, 11200, 11201, 1, 0, 0, 0, 11201, 11203, 1, 0, 0, 0, 11202, 11200, 1, 0, 0, 0, 11203, 11204, 5, 2448, 0, 0, 11204, 11206, 1, 0, 0, 0, 11205, 11183, 1, 0, 0, 0, 11205, 11206, 1, 0, 0, 0, 11206, 1119, 1, 0, 0, 0, 11207, 11208, 5, 1348, 0, 0, 11208, 11209, 5, 160, 0, 0, 11209, 11210, 5, 660, 0, 0, 11210, 11211, 5, 2447, 0, 0, 11211, 11216, 3, 2340, 1170, 0, 11212, 11213, 5, 2453, 0, 0, 11213, 11215, 3, 2340, 1170, 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, 11222, 5, 2448, 0, 0, 11220, 11223, 3, 1122, 561, 0, 11221, 11223, 3, 1124, 562, 0, 11222, 11220, 1, 0, 0, 0, 11222, 11221, 1, 0, 0, 0, 11223, 1121, 1, 0, 0, 0, 11224, 11225, 5, 2447, 0, 0, 11225, 11227, 5, 1348, 0, 0, 11226, 11228, 3, 1696, 848, 0, 11227, 11226, 1, 0, 0, 0, 11227, 11228, 1, 0, 0, 0, 11228, 11230, 1, 0, 0, 0, 11229, 11231, 3, 1172, 586, 0, 11230, 11229, 1, 0, 0, 0, 11230, 11231, 1, 0, 0, 0, 11231, 11242, 1, 0, 0, 0, 11232, 11233, 5, 2453, 0, 0, 11233, 11235, 5, 1348, 0, 0, 11234, 11236, 3, 1696, 848, 0, 11235, 11234, 1, 0, 0, 0, 11235, 11236, 1, 0, 0, 0, 11236, 11238, 1, 0, 0, 0, 11237, 11239, 3, 1172, 586, 0, 11238, 11237, 1, 0, 0, 0, 11238, 11239, 1, 0, 0, 0, 11239, 11241, 1, 0, 0, 0, 11240, 11232, 1, 0, 0, 0, 11241, 11244, 1, 0, 0, 0, 11242, 11240, 1, 0, 0, 0, 11242, 11243, 1, 0, 0, 0, 11243, 11245, 1, 0, 0, 0, 11244, 11242, 1, 0, 0, 0, 11245, 11246, 5, 2448, 0, 0, 11246, 1123, 1, 0, 0, 0, 11247, 11248, 5, 1350, 0, 0, 11248, 11262, 3, 1126, 563, 0, 11249, 11250, 5, 1763, 0, 0, 11250, 11251, 5, 738, 0, 0, 11251, 11252, 5, 2447, 0, 0, 11252, 11257, 3, 1656, 828, 0, 11253, 11254, 5, 2453, 0, 0, 11254, 11256, 3, 1656, 828, 0, 11255, 11253, 1, 0, 0, 0, 11256, 11259, 1, 0, 0, 0, 11257, 11255, 1, 0, 0, 0, 11257, 11258, 1, 0, 0, 0, 11258, 11260, 1, 0, 0, 0, 11259, 11257, 1, 0, 0, 0, 11260, 11261, 5, 2448, 0, 0, 11261, 11263, 1, 0, 0, 0, 11262, 11249, 1, 0, 0, 0, 11262, 11263, 1, 0, 0, 0, 11263, 11266, 1, 0, 0, 0, 11264, 11267, 3, 1178, 589, 0, 11265, 11267, 3, 1600, 800, 0, 11266, 11264, 1, 0, 0, 0, 11266, 11265, 1, 0, 0, 0, 11266, 11267, 1, 0, 0, 0, 11267, 11282, 1, 0, 0, 0, 11268, 11269, 5, 1320, 0, 0, 11269, 11270, 5, 1763, 0, 0, 11270, 11271, 5, 738, 0, 0, 11271, 11272, 5, 2447, 0, 0, 11272, 11277, 3, 1656, 828, 0, 11273, 11274, 5, 2453, 0, 0, 11274, 11276, 3, 1656, 828, 0, 11275, 11273, 1, 0, 0, 0, 11276, 11279, 1, 0, 0, 0, 11277, 11275, 1, 0, 0, 0, 11277, 11278, 1, 0, 0, 0, 11278, 11280, 1, 0, 0, 0, 11279, 11277, 1, 0, 0, 0, 11280, 11281, 5, 2448, 0, 0, 11281, 11283, 1, 0, 0, 0, 11282, 11268, 1, 0, 0, 0, 11282, 11283, 1, 0, 0, 0, 11283, 1125, 1, 0, 0, 0, 11284, 11285, 5, 2441, 0, 0, 11285, 1127, 1, 0, 0, 0, 11286, 11287, 5, 1348, 0, 0, 11287, 11288, 5, 160, 0, 0, 11288, 11289, 5, 1495, 0, 0, 11289, 11290, 5, 2447, 0, 0, 11290, 11295, 3, 2340, 1170, 0, 11291, 11292, 5, 2453, 0, 0, 11292, 11294, 3, 2340, 1170, 0, 11293, 11291, 1, 0, 0, 0, 11294, 11297, 1, 0, 0, 0, 11295, 11293, 1, 0, 0, 0, 11295, 11296, 1, 0, 0, 0, 11296, 11298, 1, 0, 0, 0, 11297, 11295, 1, 0, 0, 0, 11298, 11318, 5, 2448, 0, 0, 11299, 11300, 5, 776, 0, 0, 11300, 11301, 5, 2447, 0, 0, 11301, 11302, 3, 2078, 1039, 0, 11302, 11316, 5, 2448, 0, 0, 11303, 11304, 5, 1763, 0, 0, 11304, 11305, 5, 738, 0, 0, 11305, 11306, 5, 2447, 0, 0, 11306, 11311, 3, 1656, 828, 0, 11307, 11308, 5, 2453, 0, 0, 11308, 11310, 3, 1656, 828, 0, 11309, 11307, 1, 0, 0, 0, 11310, 11313, 1, 0, 0, 0, 11311, 11309, 1, 0, 0, 0, 11311, 11312, 1, 0, 0, 0, 11312, 11314, 1, 0, 0, 0, 11313, 11311, 1, 0, 0, 0, 11314, 11315, 5, 2448, 0, 0, 11315, 11317, 1, 0, 0, 0, 11316, 11303, 1, 0, 0, 0, 11316, 11317, 1, 0, 0, 0, 11317, 11319, 1, 0, 0, 0, 11318, 11299, 1, 0, 0, 0, 11318, 11319, 1, 0, 0, 0, 11319, 11323, 1, 0, 0, 0, 11320, 11324, 3, 1148, 574, 0, 11321, 11324, 3, 1150, 575, 0, 11322, 11324, 3, 1152, 576, 0, 11323, 11320, 1, 0, 0, 0, 11323, 11321, 1, 0, 0, 0, 11323, 11322, 1, 0, 0, 0, 11324, 11325, 1, 0, 0, 0, 11325, 11326, 5, 2447, 0, 0, 11326, 11331, 3, 1140, 570, 0, 11327, 11328, 5, 2453, 0, 0, 11328, 11330, 3, 1140, 570, 0, 11329, 11327, 1, 0, 0, 0, 11330, 11333, 1, 0, 0, 0, 11331, 11329, 1, 0, 0, 0, 11331, 11332, 1, 0, 0, 0, 11332, 11334, 1, 0, 0, 0, 11333, 11331, 1, 0, 0, 0, 11334, 11335, 5, 2448, 0, 0, 11335, 1129, 1, 0, 0, 0, 11336, 11337, 5, 1348, 0, 0, 11337, 11338, 5, 160, 0, 0, 11338, 11339, 5, 862, 0, 0, 11339, 11340, 5, 2447, 0, 0, 11340, 11341, 3, 2340, 1170, 0, 11341, 11345, 5, 2448, 0, 0, 11342, 11346, 3, 1148, 574, 0, 11343, 11346, 3, 1150, 575, 0, 11344, 11346, 3, 1152, 576, 0, 11345, 11342, 1, 0, 0, 0, 11345, 11343, 1, 0, 0, 0, 11345, 11344, 1, 0, 0, 0, 11346, 11347, 1, 0, 0, 0, 11347, 11348, 5, 2447, 0, 0, 11348, 11353, 3, 1142, 571, 0, 11349, 11350, 5, 2453, 0, 0, 11350, 11352, 3, 1142, 571, 0, 11351, 11349, 1, 0, 0, 0, 11352, 11355, 1, 0, 0, 0, 11353, 11351, 1, 0, 0, 0, 11353, 11354, 1, 0, 0, 0, 11354, 11356, 1, 0, 0, 0, 11355, 11353, 1, 0, 0, 0, 11356, 11357, 5, 2448, 0, 0, 11357, 1131, 1, 0, 0, 0, 11358, 11359, 5, 1348, 0, 0, 11359, 11360, 5, 160, 0, 0, 11360, 11361, 5, 660, 0, 0, 11361, 11364, 5, 2447, 0, 0, 11362, 11363, 5, 2453, 0, 0, 11363, 11365, 3, 2340, 1170, 0, 11364, 11362, 1, 0, 0, 0, 11365, 11366, 1, 0, 0, 0, 11366, 11364, 1, 0, 0, 0, 11366, 11367, 1, 0, 0, 0, 11367, 11368, 1, 0, 0, 0, 11368, 11372, 5, 2448, 0, 0, 11369, 11373, 3, 1148, 574, 0, 11370, 11373, 3, 1150, 575, 0, 11371, 11373, 3, 1152, 576, 0, 11372, 11369, 1, 0, 0, 0, 11372, 11370, 1, 0, 0, 0, 11372, 11371, 1, 0, 0, 0, 11373, 11376, 1, 0, 0, 0, 11374, 11377, 3, 1122, 561, 0, 11375, 11377, 3, 1124, 562, 0, 11376, 11374, 1, 0, 0, 0, 11376, 11375, 1, 0, 0, 0, 11377, 1133, 1, 0, 0, 0, 11378, 11379, 5, 1348, 0, 0, 11379, 11380, 5, 160, 0, 0, 11380, 11381, 5, 1527, 0, 0, 11381, 11382, 5, 2447, 0, 0, 11382, 11383, 3, 2310, 1155, 0, 11383, 11395, 5, 2448, 0, 0, 11384, 11385, 5, 2447, 0, 0, 11385, 11390, 3, 1136, 568, 0, 11386, 11387, 5, 2453, 0, 0, 11387, 11389, 3, 1136, 568, 0, 11388, 11386, 1, 0, 0, 0, 11389, 11392, 1, 0, 0, 0, 11390, 11388, 1, 0, 0, 0, 11390, 11391, 1, 0, 0, 0, 11391, 11393, 1, 0, 0, 0, 11392, 11390, 1, 0, 0, 0, 11393, 11394, 5, 2448, 0, 0, 11394, 11396, 1, 0, 0, 0, 11395, 11384, 1, 0, 0, 0, 11395, 11396, 1, 0, 0, 0, 11396, 1135, 1, 0, 0, 0, 11397, 11399, 5, 1348, 0, 0, 11398, 11400, 3, 1696, 848, 0, 11399, 11398, 1, 0, 0, 0, 11399, 11400, 1, 0, 0, 0, 11400, 11401, 1, 0, 0, 0, 11401, 11402, 3, 1170, 585, 0, 11402, 1137, 1, 0, 0, 0, 11403, 11404, 5, 1348, 0, 0, 11404, 11405, 5, 160, 0, 0, 11405, 11416, 5, 1949, 0, 0, 11406, 11407, 5, 1350, 0, 0, 11407, 11417, 5, 2441, 0, 0, 11408, 11413, 3, 1136, 568, 0, 11409, 11410, 5, 2453, 0, 0, 11410, 11412, 3, 1136, 568, 0, 11411, 11409, 1, 0, 0, 0, 11412, 11415, 1, 0, 0, 0, 11413, 11411, 1, 0, 0, 0, 11413, 11414, 1, 0, 0, 0, 11414, 11417, 1, 0, 0, 0, 11415, 11413, 1, 0, 0, 0, 11416, 11406, 1, 0, 0, 0, 11416, 11408, 1, 0, 0, 0, 11416, 11417, 1, 0, 0, 0, 11417, 1139, 1, 0, 0, 0, 11418, 11420, 5, 1348, 0, 0, 11419, 11421, 3, 1696, 848, 0, 11420, 11419, 1, 0, 0, 0, 11420, 11421, 1, 0, 0, 0, 11421, 11423, 1, 0, 0, 0, 11422, 11424, 3, 1164, 582, 0, 11423, 11422, 1, 0, 0, 0, 11423, 11424, 1, 0, 0, 0, 11424, 11425, 1, 0, 0, 0, 11425, 11458, 3, 1170, 585, 0, 11426, 11451, 5, 2447, 0, 0, 11427, 11432, 3, 1156, 578, 0, 11428, 11429, 5, 2453, 0, 0, 11429, 11431, 3, 1156, 578, 0, 11430, 11428, 1, 0, 0, 0, 11431, 11434, 1, 0, 0, 0, 11432, 11430, 1, 0, 0, 0, 11432, 11433, 1, 0, 0, 0, 11433, 11452, 1, 0, 0, 0, 11434, 11432, 1, 0, 0, 0, 11435, 11440, 3, 1158, 579, 0, 11436, 11437, 5, 2453, 0, 0, 11437, 11439, 3, 1158, 579, 0, 11438, 11436, 1, 0, 0, 0, 11439, 11442, 1, 0, 0, 0, 11440, 11438, 1, 0, 0, 0, 11440, 11441, 1, 0, 0, 0, 11441, 11452, 1, 0, 0, 0, 11442, 11440, 1, 0, 0, 0, 11443, 11448, 3, 1160, 580, 0, 11444, 11445, 5, 2453, 0, 0, 11445, 11447, 3, 1160, 580, 0, 11446, 11444, 1, 0, 0, 0, 11447, 11450, 1, 0, 0, 0, 11448, 11446, 1, 0, 0, 0, 11448, 11449, 1, 0, 0, 0, 11449, 11452, 1, 0, 0, 0, 11450, 11448, 1, 0, 0, 0, 11451, 11427, 1, 0, 0, 0, 11451, 11435, 1, 0, 0, 0, 11451, 11443, 1, 0, 0, 0, 11452, 11453, 1, 0, 0, 0, 11453, 11454, 5, 2448, 0, 0, 11454, 11457, 1, 0, 0, 0, 11455, 11457, 3, 1162, 581, 0, 11456, 11426, 1, 0, 0, 0, 11456, 11455, 1, 0, 0, 0, 11457, 11459, 1, 0, 0, 0, 11458, 11456, 1, 0, 0, 0, 11458, 11459, 1, 0, 0, 0, 11459, 1141, 1, 0, 0, 0, 11460, 11462, 5, 1348, 0, 0, 11461, 11463, 3, 1696, 848, 0, 11462, 11461, 1, 0, 0, 0, 11462, 11463, 1, 0, 0, 0, 11463, 11465, 1, 0, 0, 0, 11464, 11466, 3, 1168, 584, 0, 11465, 11464, 1, 0, 0, 0, 11465, 11466, 1, 0, 0, 0, 11466, 11467, 1, 0, 0, 0, 11467, 11500, 3, 1170, 585, 0, 11468, 11493, 5, 2447, 0, 0, 11469, 11474, 3, 1156, 578, 0, 11470, 11471, 5, 2453, 0, 0, 11471, 11473, 3, 1156, 578, 0, 11472, 11470, 1, 0, 0, 0, 11473, 11476, 1, 0, 0, 0, 11474, 11472, 1, 0, 0, 0, 11474, 11475, 1, 0, 0, 0, 11475, 11494, 1, 0, 0, 0, 11476, 11474, 1, 0, 0, 0, 11477, 11482, 3, 1158, 579, 0, 11478, 11479, 5, 2453, 0, 0, 11479, 11481, 3, 1158, 579, 0, 11480, 11478, 1, 0, 0, 0, 11481, 11484, 1, 0, 0, 0, 11482, 11480, 1, 0, 0, 0, 11482, 11483, 1, 0, 0, 0, 11483, 11494, 1, 0, 0, 0, 11484, 11482, 1, 0, 0, 0, 11485, 11490, 3, 1160, 580, 0, 11486, 11487, 5, 2453, 0, 0, 11487, 11489, 3, 1160, 580, 0, 11488, 11486, 1, 0, 0, 0, 11489, 11492, 1, 0, 0, 0, 11490, 11488, 1, 0, 0, 0, 11490, 11491, 1, 0, 0, 0, 11491, 11494, 1, 0, 0, 0, 11492, 11490, 1, 0, 0, 0, 11493, 11469, 1, 0, 0, 0, 11493, 11477, 1, 0, 0, 0, 11493, 11485, 1, 0, 0, 0, 11494, 11495, 1, 0, 0, 0, 11495, 11496, 5, 2448, 0, 0, 11496, 11499, 1, 0, 0, 0, 11497, 11499, 3, 1162, 581, 0, 11498, 11468, 1, 0, 0, 0, 11498, 11497, 1, 0, 0, 0, 11499, 11501, 1, 0, 0, 0, 11500, 11498, 1, 0, 0, 0, 11500, 11501, 1, 0, 0, 0, 11501, 1143, 1, 0, 0, 0, 11502, 11503, 5, 1775, 0, 0, 11503, 11534, 5, 2090, 0, 0, 11504, 11529, 5, 2447, 0, 0, 11505, 11510, 3, 1156, 578, 0, 11506, 11507, 5, 2453, 0, 0, 11507, 11509, 3, 1156, 578, 0, 11508, 11506, 1, 0, 0, 0, 11509, 11512, 1, 0, 0, 0, 11510, 11508, 1, 0, 0, 0, 11510, 11511, 1, 0, 0, 0, 11511, 11530, 1, 0, 0, 0, 11512, 11510, 1, 0, 0, 0, 11513, 11518, 3, 1158, 579, 0, 11514, 11515, 5, 2453, 0, 0, 11515, 11517, 3, 1158, 579, 0, 11516, 11514, 1, 0, 0, 0, 11517, 11520, 1, 0, 0, 0, 11518, 11516, 1, 0, 0, 0, 11518, 11519, 1, 0, 0, 0, 11519, 11530, 1, 0, 0, 0, 11520, 11518, 1, 0, 0, 0, 11521, 11526, 3, 1160, 580, 0, 11522, 11523, 5, 2453, 0, 0, 11523, 11525, 3, 1160, 580, 0, 11524, 11522, 1, 0, 0, 0, 11525, 11528, 1, 0, 0, 0, 11526, 11524, 1, 0, 0, 0, 11526, 11527, 1, 0, 0, 0, 11527, 11530, 1, 0, 0, 0, 11528, 11526, 1, 0, 0, 0, 11529, 11505, 1, 0, 0, 0, 11529, 11513, 1, 0, 0, 0, 11529, 11521, 1, 0, 0, 0, 11530, 11531, 1, 0, 0, 0, 11531, 11532, 5, 2448, 0, 0, 11532, 11535, 1, 0, 0, 0, 11533, 11535, 3, 1146, 573, 0, 11534, 11504, 1, 0, 0, 0, 11534, 11533, 1, 0, 0, 0, 11535, 1145, 1, 0, 0, 0, 11536, 11537, 5, 2441, 0, 0, 11537, 1147, 1, 0, 0, 0, 11538, 11539, 5, 1775, 0, 0, 11539, 11540, 5, 160, 0, 0, 11540, 11541, 5, 1495, 0, 0, 11541, 11542, 5, 2447, 0, 0, 11542, 11547, 3, 2340, 1170, 0, 11543, 11544, 5, 2453, 0, 0, 11544, 11546, 3, 2340, 1170, 0, 11545, 11543, 1, 0, 0, 0, 11546, 11549, 1, 0, 0, 0, 11547, 11545, 1, 0, 0, 0, 11547, 11548, 1, 0, 0, 0, 11548, 11550, 1, 0, 0, 0, 11549, 11547, 1, 0, 0, 0, 11550, 11552, 5, 2448, 0, 0, 11551, 11553, 3, 1144, 572, 0, 11552, 11551, 1, 0, 0, 0, 11552, 11553, 1, 0, 0, 0, 11553, 1149, 1, 0, 0, 0, 11554, 11555, 5, 1775, 0, 0, 11555, 11556, 5, 160, 0, 0, 11556, 11557, 5, 862, 0, 0, 11557, 11558, 5, 2447, 0, 0, 11558, 11559, 3, 2340, 1170, 0, 11559, 11561, 5, 2448, 0, 0, 11560, 11562, 3, 1144, 572, 0, 11561, 11560, 1, 0, 0, 0, 11561, 11562, 1, 0, 0, 0, 11562, 1151, 1, 0, 0, 0, 11563, 11564, 5, 1775, 0, 0, 11564, 11565, 5, 160, 0, 0, 11565, 11566, 5, 660, 0, 0, 11566, 11567, 5, 2447, 0, 0, 11567, 11572, 3, 2340, 1170, 0, 11568, 11569, 5, 2453, 0, 0, 11569, 11571, 3, 2340, 1170, 0, 11570, 11568, 1, 0, 0, 0, 11571, 11574, 1, 0, 0, 0, 11572, 11570, 1, 0, 0, 0, 11572, 11573, 1, 0, 0, 0, 11573, 11575, 1, 0, 0, 0, 11574, 11572, 1, 0, 0, 0, 11575, 11594, 5, 2448, 0, 0, 11576, 11577, 5, 1774, 0, 0, 11577, 11591, 5, 2441, 0, 0, 11578, 11579, 5, 1763, 0, 0, 11579, 11580, 5, 738, 0, 0, 11580, 11581, 5, 2447, 0, 0, 11581, 11586, 3, 1656, 828, 0, 11582, 11583, 5, 2453, 0, 0, 11583, 11585, 3, 1656, 828, 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, 11589, 1, 0, 0, 0, 11588, 11586, 1, 0, 0, 0, 11589, 11590, 5, 2448, 0, 0, 11590, 11592, 1, 0, 0, 0, 11591, 11578, 1, 0, 0, 0, 11591, 11592, 1, 0, 0, 0, 11592, 11595, 1, 0, 0, 0, 11593, 11595, 3, 1144, 572, 0, 11594, 11576, 1, 0, 0, 0, 11594, 11593, 1, 0, 0, 0, 11594, 11595, 1, 0, 0, 0, 11595, 1153, 1, 0, 0, 0, 11596, 11597, 3, 1696, 848, 0, 11597, 1155, 1, 0, 0, 0, 11598, 11600, 5, 1775, 0, 0, 11599, 11601, 3, 1154, 577, 0, 11600, 11599, 1, 0, 0, 0, 11600, 11601, 1, 0, 0, 0, 11601, 11602, 1, 0, 0, 0, 11602, 11604, 3, 1164, 582, 0, 11603, 11605, 3, 1172, 586, 0, 11604, 11603, 1, 0, 0, 0, 11604, 11605, 1, 0, 0, 0, 11605, 1157, 1, 0, 0, 0, 11606, 11608, 5, 1775, 0, 0, 11607, 11609, 3, 1154, 577, 0, 11608, 11607, 1, 0, 0, 0, 11608, 11609, 1, 0, 0, 0, 11609, 11610, 1, 0, 0, 0, 11610, 11612, 3, 1168, 584, 0, 11611, 11613, 3, 1172, 586, 0, 11612, 11611, 1, 0, 0, 0, 11612, 11613, 1, 0, 0, 0, 11613, 1159, 1, 0, 0, 0, 11614, 11616, 5, 1775, 0, 0, 11615, 11617, 3, 1154, 577, 0, 11616, 11615, 1, 0, 0, 0, 11616, 11617, 1, 0, 0, 0, 11617, 11619, 1, 0, 0, 0, 11618, 11620, 3, 1172, 586, 0, 11619, 11618, 1, 0, 0, 0, 11619, 11620, 1, 0, 0, 0, 11620, 1161, 1, 0, 0, 0, 11621, 11622, 5, 1774, 0, 0, 11622, 11636, 5, 2441, 0, 0, 11623, 11624, 5, 1763, 0, 0, 11624, 11625, 5, 738, 0, 0, 11625, 11626, 5, 2447, 0, 0, 11626, 11631, 3, 1656, 828, 0, 11627, 11628, 5, 2453, 0, 0, 11628, 11630, 3, 1656, 828, 0, 11629, 11627, 1, 0, 0, 0, 11630, 11633, 1, 0, 0, 0, 11631, 11629, 1, 0, 0, 0, 11631, 11632, 1, 0, 0, 0, 11632, 11634, 1, 0, 0, 0, 11633, 11631, 1, 0, 0, 0, 11634, 11635, 5, 2448, 0, 0, 11635, 11637, 1, 0, 0, 0, 11636, 11623, 1, 0, 0, 0, 11636, 11637, 1, 0, 0, 0, 11637, 1163, 1, 0, 0, 0, 11638, 11639, 5, 2257, 0, 0, 11639, 11640, 5, 845, 0, 0, 11640, 11641, 5, 2098, 0, 0, 11641, 11642, 5, 2447, 0, 0, 11642, 11643, 3, 1166, 583, 0, 11643, 11644, 5, 2448, 0, 0, 11644, 1165, 1, 0, 0, 0, 11645, 11650, 3, 2186, 1093, 0, 11646, 11647, 5, 2453, 0, 0, 11647, 11649, 3, 2186, 1093, 0, 11648, 11646, 1, 0, 0, 0, 11649, 11652, 1, 0, 0, 0, 11650, 11648, 1, 0, 0, 0, 11650, 11651, 1, 0, 0, 0, 11651, 11664, 1, 0, 0, 0, 11652, 11650, 1, 0, 0, 0, 11653, 11654, 5, 2108, 0, 0, 11654, 11660, 3, 2186, 1093, 0, 11655, 11656, 5, 2453, 0, 0, 11656, 11657, 5, 2108, 0, 0, 11657, 11659, 3, 2186, 1093, 0, 11658, 11655, 1, 0, 0, 0, 11659, 11662, 1, 0, 0, 0, 11660, 11658, 1, 0, 0, 0, 11660, 11661, 1, 0, 0, 0, 11661, 11664, 1, 0, 0, 0, 11662, 11660, 1, 0, 0, 0, 11663, 11645, 1, 0, 0, 0, 11663, 11653, 1, 0, 0, 0, 11664, 1167, 1, 0, 0, 0, 11665, 11666, 5, 2257, 0, 0, 11666, 11686, 5, 2447, 0, 0, 11667, 11672, 3, 2186, 1093, 0, 11668, 11669, 5, 2453, 0, 0, 11669, 11671, 3, 2186, 1093, 0, 11670, 11668, 1, 0, 0, 0, 11671, 11674, 1, 0, 0, 0, 11672, 11670, 1, 0, 0, 0, 11672, 11673, 1, 0, 0, 0, 11673, 11687, 1, 0, 0, 0, 11674, 11672, 1, 0, 0, 0, 11675, 11676, 5, 2108, 0, 0, 11676, 11682, 3, 2186, 1093, 0, 11677, 11678, 5, 2453, 0, 0, 11678, 11679, 5, 2108, 0, 0, 11679, 11681, 3, 2186, 1093, 0, 11680, 11677, 1, 0, 0, 0, 11681, 11684, 1, 0, 0, 0, 11682, 11680, 1, 0, 0, 0, 11682, 11683, 1, 0, 0, 0, 11683, 11687, 1, 0, 0, 0, 11684, 11682, 1, 0, 0, 0, 11685, 11687, 5, 389, 0, 0, 11686, 11667, 1, 0, 0, 0, 11686, 11675, 1, 0, 0, 0, 11686, 11685, 1, 0, 0, 0, 11687, 11688, 1, 0, 0, 0, 11688, 11689, 5, 2448, 0, 0, 11689, 1169, 1, 0, 0, 0, 11690, 11692, 7, 126, 0, 0, 11691, 11690, 1, 0, 0, 0, 11691, 11692, 1, 0, 0, 0, 11692, 11694, 1, 0, 0, 0, 11693, 11695, 3, 1198, 599, 0, 11694, 11693, 1, 0, 0, 0, 11694, 11695, 1, 0, 0, 0, 11695, 11697, 1, 0, 0, 0, 11696, 11698, 3, 1086, 543, 0, 11697, 11696, 1, 0, 0, 0, 11697, 11698, 1, 0, 0, 0, 11698, 11700, 1, 0, 0, 0, 11699, 11701, 3, 1088, 544, 0, 11700, 11699, 1, 0, 0, 0, 11700, 11701, 1, 0, 0, 0, 11701, 11703, 1, 0, 0, 0, 11702, 11704, 3, 1200, 600, 0, 11703, 11702, 1, 0, 0, 0, 11703, 11704, 1, 0, 0, 0, 11704, 11707, 1, 0, 0, 0, 11705, 11708, 3, 1178, 589, 0, 11706, 11708, 3, 1600, 800, 0, 11707, 11705, 1, 0, 0, 0, 11707, 11706, 1, 0, 0, 0, 11707, 11708, 1, 0, 0, 0, 11708, 11710, 1, 0, 0, 0, 11709, 11711, 3, 1180, 590, 0, 11710, 11709, 1, 0, 0, 0, 11710, 11711, 1, 0, 0, 0, 11711, 11713, 1, 0, 0, 0, 11712, 11714, 3, 1204, 602, 0, 11713, 11712, 1, 0, 0, 0, 11713, 11714, 1, 0, 0, 0, 11714, 11719, 1, 0, 0, 0, 11715, 11717, 5, 1320, 0, 0, 11716, 11718, 3, 1200, 600, 0, 11717, 11716, 1, 0, 0, 0, 11717, 11718, 1, 0, 0, 0, 11718, 11720, 1, 0, 0, 0, 11719, 11715, 1, 0, 0, 0, 11719, 11720, 1, 0, 0, 0, 11720, 11726, 1, 0, 0, 0, 11721, 11725, 3, 1640, 820, 0, 11722, 11725, 3, 1630, 815, 0, 11723, 11725, 3, 1690, 845, 0, 11724, 11721, 1, 0, 0, 0, 11724, 11722, 1, 0, 0, 0, 11724, 11723, 1, 0, 0, 0, 11725, 11728, 1, 0, 0, 0, 11726, 11724, 1, 0, 0, 0, 11726, 11727, 1, 0, 0, 0, 11727, 1171, 1, 0, 0, 0, 11728, 11726, 1, 0, 0, 0, 11729, 11730, 5, 2080, 0, 0, 11730, 11751, 3, 1656, 828, 0, 11731, 11734, 5, 1320, 0, 0, 11732, 11733, 5, 2080, 0, 0, 11733, 11735, 3, 1656, 828, 0, 11734, 11732, 1, 0, 0, 0, 11734, 11735, 1, 0, 0, 0, 11735, 11751, 1, 0, 0, 0, 11736, 11751, 3, 1178, 589, 0, 11737, 11751, 3, 1600, 800, 0, 11738, 11751, 3, 1180, 590, 0, 11739, 11751, 3, 1174, 587, 0, 11740, 11741, 5, 2267, 0, 0, 11741, 11742, 3, 1658, 829, 0, 11742, 11743, 5, 1763, 0, 0, 11743, 11745, 5, 69, 0, 0, 11744, 11746, 7, 122, 0, 0, 11745, 11744, 1, 0, 0, 0, 11745, 11746, 1, 0, 0, 0, 11746, 11747, 1, 0, 0, 0, 11747, 11748, 5, 868, 0, 0, 11748, 11749, 3, 1634, 817, 0, 11749, 11751, 1, 0, 0, 0, 11750, 11729, 1, 0, 0, 0, 11750, 11731, 1, 0, 0, 0, 11750, 11736, 1, 0, 0, 0, 11750, 11737, 1, 0, 0, 0, 11750, 11738, 1, 0, 0, 0, 11750, 11739, 1, 0, 0, 0, 11750, 11740, 1, 0, 0, 0, 11751, 11752, 1, 0, 0, 0, 11752, 11750, 1, 0, 0, 0, 11752, 11753, 1, 0, 0, 0, 11753, 1173, 1, 0, 0, 0, 11754, 11755, 5, 868, 0, 0, 11755, 11756, 5, 2447, 0, 0, 11756, 11757, 3, 1636, 818, 0, 11757, 11758, 5, 2448, 0, 0, 11758, 11759, 5, 1763, 0, 0, 11759, 11761, 5, 69, 0, 0, 11760, 11762, 7, 122, 0, 0, 11761, 11760, 1, 0, 0, 0, 11761, 11762, 1, 0, 0, 0, 11762, 11776, 1, 0, 0, 0, 11763, 11769, 3, 1634, 817, 0, 11764, 11765, 5, 2447, 0, 0, 11765, 11766, 5, 2080, 0, 0, 11766, 11767, 3, 1656, 828, 0, 11767, 11768, 5, 2448, 0, 0, 11768, 11770, 1, 0, 0, 0, 11769, 11764, 1, 0, 0, 0, 11769, 11770, 1, 0, 0, 0, 11770, 11777, 1, 0, 0, 0, 11771, 11772, 5, 2447, 0, 0, 11772, 11773, 5, 2080, 0, 0, 11773, 11774, 3, 1656, 828, 0, 11774, 11775, 5, 2448, 0, 0, 11775, 11777, 1, 0, 0, 0, 11776, 11763, 1, 0, 0, 0, 11776, 11771, 1, 0, 0, 0, 11777, 1175, 1, 0, 0, 0, 11778, 11780, 5, 2441, 0, 0, 11779, 11781, 7, 127, 0, 0, 11780, 11779, 1, 0, 0, 0, 11780, 11781, 1, 0, 0, 0, 11781, 1177, 1, 0, 0, 0, 11782, 11796, 5, 258, 0, 0, 11783, 11797, 5, 106, 0, 0, 11784, 11794, 5, 620, 0, 0, 11785, 11795, 5, 1253, 0, 0, 11786, 11788, 7, 128, 0, 0, 11787, 11789, 7, 105, 0, 0, 11788, 11787, 1, 0, 0, 0, 11788, 11789, 1, 0, 0, 0, 11789, 11795, 1, 0, 0, 0, 11790, 11791, 5, 38, 0, 0, 11791, 11795, 5, 1265, 0, 0, 11792, 11793, 5, 425, 0, 0, 11793, 11795, 5, 1265, 0, 0, 11794, 11785, 1, 0, 0, 0, 11794, 11786, 1, 0, 0, 0, 11794, 11790, 1, 0, 0, 0, 11794, 11792, 1, 0, 0, 0, 11795, 11797, 1, 0, 0, 0, 11796, 11783, 1, 0, 0, 0, 11796, 11784, 1, 0, 0, 0, 11796, 11797, 1, 0, 0, 0, 11797, 11824, 1, 0, 0, 0, 11798, 11799, 5, 1606, 0, 0, 11799, 11800, 5, 1763, 0, 0, 11800, 11802, 5, 258, 0, 0, 11801, 11803, 7, 129, 0, 0, 11802, 11801, 1, 0, 0, 0, 11802, 11803, 1, 0, 0, 0, 11803, 11824, 1, 0, 0, 0, 11804, 11805, 5, 237, 0, 0, 11805, 11806, 5, 1763, 0, 0, 11806, 11812, 5, 258, 0, 0, 11807, 11808, 5, 620, 0, 0, 11808, 11810, 7, 128, 0, 0, 11809, 11811, 7, 105, 0, 0, 11810, 11809, 1, 0, 0, 0, 11810, 11811, 1, 0, 0, 0, 11811, 11813, 1, 0, 0, 0, 11812, 11807, 1, 0, 0, 0, 11812, 11813, 1, 0, 0, 0, 11813, 11820, 1, 0, 0, 0, 11814, 11816, 5, 1137, 0, 0, 11815, 11814, 1, 0, 0, 0, 11815, 11816, 1, 0, 0, 0, 11816, 11817, 1, 0, 0, 0, 11817, 11818, 5, 1606, 0, 0, 11818, 11819, 5, 846, 0, 0, 11819, 11821, 5, 880, 0, 0, 11820, 11815, 1, 0, 0, 0, 11820, 11821, 1, 0, 0, 0, 11821, 11824, 1, 0, 0, 0, 11822, 11824, 5, 1074, 0, 0, 11823, 11782, 1, 0, 0, 0, 11823, 11798, 1, 0, 0, 0, 11823, 11804, 1, 0, 0, 0, 11823, 11822, 1, 0, 0, 0, 11824, 1179, 1, 0, 0, 0, 11825, 11827, 3, 1192, 596, 0, 11826, 11825, 1, 0, 0, 0, 11827, 11828, 1, 0, 0, 0, 11828, 11826, 1, 0, 0, 0, 11828, 11829, 1, 0, 0, 0, 11829, 11845, 1, 0, 0, 0, 11830, 11832, 5, 746, 0, 0, 11831, 11833, 3, 1182, 591, 0, 11832, 11831, 1, 0, 0, 0, 11832, 11833, 1, 0, 0, 0, 11833, 11837, 1, 0, 0, 0, 11834, 11835, 5, 1137, 0, 0, 11835, 11837, 5, 746, 0, 0, 11836, 11830, 1, 0, 0, 0, 11836, 11834, 1, 0, 0, 0, 11837, 11841, 1, 0, 0, 0, 11838, 11840, 3, 1192, 596, 0, 11839, 11838, 1, 0, 0, 0, 11840, 11843, 1, 0, 0, 0, 11841, 11839, 1, 0, 0, 0, 11841, 11842, 1, 0, 0, 0, 11842, 11845, 1, 0, 0, 0, 11843, 11841, 1, 0, 0, 0, 11844, 11826, 1, 0, 0, 0, 11844, 11836, 1, 0, 0, 0, 11845, 1181, 1, 0, 0, 0, 11846, 11851, 3, 1184, 592, 0, 11847, 11851, 3, 1186, 593, 0, 11848, 11851, 3, 1188, 594, 0, 11849, 11851, 3, 1190, 595, 0, 11850, 11846, 1, 0, 0, 0, 11850, 11847, 1, 0, 0, 0, 11850, 11848, 1, 0, 0, 0, 11850, 11849, 1, 0, 0, 0, 11851, 11852, 1, 0, 0, 0, 11852, 11850, 1, 0, 0, 0, 11852, 11853, 1, 0, 0, 0, 11853, 1183, 1, 0, 0, 0, 11854, 11855, 5, 941, 0, 0, 11855, 11861, 5, 620, 0, 0, 11856, 11862, 5, 449, 0, 0, 11857, 11859, 7, 130, 0, 0, 11858, 11860, 7, 105, 0, 0, 11859, 11858, 1, 0, 0, 0, 11859, 11860, 1, 0, 0, 0, 11860, 11862, 1, 0, 0, 0, 11861, 11856, 1, 0, 0, 0, 11861, 11857, 1, 0, 0, 0, 11862, 11866, 1, 0, 0, 0, 11863, 11864, 5, 1137, 0, 0, 11864, 11866, 5, 941, 0, 0, 11865, 11854, 1, 0, 0, 0, 11865, 11863, 1, 0, 0, 0, 11866, 1185, 1, 0, 0, 0, 11867, 11868, 5, 1453, 0, 0, 11868, 11869, 7, 131, 0, 0, 11869, 1187, 1, 0, 0, 0, 11870, 11879, 5, 448, 0, 0, 11871, 11880, 5, 91, 0, 0, 11872, 11877, 5, 160, 0, 0, 11873, 11874, 5, 1601, 0, 0, 11874, 11878, 5, 1495, 0, 0, 11875, 11878, 5, 1348, 0, 0, 11876, 11878, 5, 1775, 0, 0, 11877, 11873, 1, 0, 0, 0, 11877, 11875, 1, 0, 0, 0, 11877, 11876, 1, 0, 0, 0, 11878, 11880, 1, 0, 0, 0, 11879, 11871, 1, 0, 0, 0, 11879, 11872, 1, 0, 0, 0, 11879, 11880, 1, 0, 0, 0, 11880, 11889, 1, 0, 0, 0, 11881, 11882, 5, 620, 0, 0, 11882, 11887, 5, 1664, 0, 0, 11883, 11888, 5, 389, 0, 0, 11884, 11888, 5, 38, 0, 0, 11885, 11888, 3, 2402, 1201, 0, 11886, 11888, 5, 1133, 0, 0, 11887, 11883, 1, 0, 0, 0, 11887, 11884, 1, 0, 0, 0, 11887, 11885, 1, 0, 0, 0, 11887, 11886, 1, 0, 0, 0, 11888, 11890, 1, 0, 0, 0, 11889, 11881, 1, 0, 0, 0, 11889, 11890, 1, 0, 0, 0, 11890, 1189, 1, 0, 0, 0, 11891, 11893, 5, 475, 0, 0, 11892, 11894, 5, 38, 0, 0, 11893, 11892, 1, 0, 0, 0, 11893, 11894, 1, 0, 0, 0, 11894, 11898, 1, 0, 0, 0, 11895, 11896, 5, 1137, 0, 0, 11896, 11898, 5, 475, 0, 0, 11897, 11891, 1, 0, 0, 0, 11897, 11895, 1, 0, 0, 0, 11898, 1191, 1, 0, 0, 0, 11899, 11901, 5, 746, 0, 0, 11900, 11902, 3, 1184, 592, 0, 11901, 11900, 1, 0, 0, 0, 11901, 11902, 1, 0, 0, 0, 11902, 11906, 1, 0, 0, 0, 11903, 11904, 5, 1137, 0, 0, 11904, 11906, 5, 746, 0, 0, 11905, 11899, 1, 0, 0, 0, 11905, 11903, 1, 0, 0, 0, 11906, 11907, 1, 0, 0, 0, 11907, 11908, 5, 2447, 0, 0, 11908, 11909, 3, 2358, 1179, 0, 11909, 11910, 5, 2448, 0, 0, 11910, 1193, 1, 0, 0, 0, 11911, 11912, 5, 1369, 0, 0, 11912, 11922, 5, 2441, 0, 0, 11913, 11914, 5, 1372, 0, 0, 11914, 11922, 5, 2441, 0, 0, 11915, 11916, 5, 743, 0, 0, 11916, 11922, 5, 2441, 0, 0, 11917, 11918, 5, 931, 0, 0, 11918, 11922, 5, 2441, 0, 0, 11919, 11922, 3, 1196, 598, 0, 11920, 11922, 3, 678, 339, 0, 11921, 11911, 1, 0, 0, 0, 11921, 11913, 1, 0, 0, 0, 11921, 11915, 1, 0, 0, 0, 11921, 11917, 1, 0, 0, 0, 11921, 11919, 1, 0, 0, 0, 11921, 11920, 1, 0, 0, 0, 11922, 11923, 1, 0, 0, 0, 11923, 11921, 1, 0, 0, 0, 11923, 11924, 1, 0, 0, 0, 11924, 1195, 1, 0, 0, 0, 11925, 11926, 5, 1762, 0, 0, 11926, 11954, 5, 2447, 0, 0, 11927, 11928, 5, 740, 0, 0, 11928, 11955, 3, 1176, 588, 0, 11929, 11930, 5, 1025, 0, 0, 11930, 11955, 3, 1176, 588, 0, 11931, 11932, 5, 952, 0, 0, 11932, 11955, 7, 132, 0, 0, 11933, 11934, 5, 923, 0, 0, 11934, 11955, 7, 132, 0, 0, 11935, 11936, 5, 1370, 0, 0, 11936, 11955, 5, 2441, 0, 0, 11937, 11938, 5, 625, 0, 0, 11938, 11955, 5, 2441, 0, 0, 11939, 11940, 5, 624, 0, 0, 11940, 11941, 5, 653, 0, 0, 11941, 11955, 5, 2441, 0, 0, 11942, 11945, 5, 1268, 0, 0, 11943, 11946, 3, 1176, 588, 0, 11944, 11946, 5, 1228, 0, 0, 11945, 11943, 1, 0, 0, 0, 11945, 11944, 1, 0, 0, 0, 11946, 11955, 1, 0, 0, 0, 11947, 11948, 5, 157, 0, 0, 11948, 11955, 7, 133, 0, 0, 11949, 11950, 5, 606, 0, 0, 11950, 11955, 7, 134, 0, 0, 11951, 11952, 5, 186, 0, 0, 11952, 11955, 7, 134, 0, 0, 11953, 11955, 5, 505, 0, 0, 11954, 11927, 1, 0, 0, 0, 11954, 11929, 1, 0, 0, 0, 11954, 11931, 1, 0, 0, 0, 11954, 11933, 1, 0, 0, 0, 11954, 11935, 1, 0, 0, 0, 11954, 11937, 1, 0, 0, 0, 11954, 11939, 1, 0, 0, 0, 11954, 11942, 1, 0, 0, 0, 11954, 11947, 1, 0, 0, 0, 11954, 11949, 1, 0, 0, 0, 11954, 11951, 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, 11958, 1, 0, 0, 0, 11958, 11959, 5, 2448, 0, 0, 11959, 1197, 1, 0, 0, 0, 11960, 11961, 5, 1645, 0, 0, 11961, 11962, 5, 324, 0, 0, 11962, 11963, 7, 69, 0, 0, 11963, 1199, 1, 0, 0, 0, 11964, 11976, 3, 1194, 597, 0, 11965, 11971, 5, 2080, 0, 0, 11966, 11972, 3, 2404, 1202, 0, 11967, 11969, 5, 1671, 0, 0, 11968, 11967, 1, 0, 0, 0, 11968, 11969, 1, 0, 0, 0, 11969, 11970, 1, 0, 0, 0, 11970, 11972, 3, 2402, 1201, 0, 11971, 11966, 1, 0, 0, 0, 11971, 11968, 1, 0, 0, 0, 11972, 11976, 1, 0, 0, 0, 11973, 11976, 3, 1178, 589, 0, 11974, 11976, 3, 886, 443, 0, 11975, 11964, 1, 0, 0, 0, 11975, 11965, 1, 0, 0, 0, 11975, 11973, 1, 0, 0, 0, 11975, 11974, 1, 0, 0, 0, 11976, 11977, 1, 0, 0, 0, 11977, 11975, 1, 0, 0, 0, 11977, 11978, 1, 0, 0, 0, 11978, 1201, 1, 0, 0, 0, 11979, 12023, 3, 1198, 599, 0, 11980, 12023, 3, 1200, 600, 0, 11981, 12023, 3, 1178, 589, 0, 11982, 12023, 3, 1180, 590, 0, 11983, 12023, 3, 1204, 602, 0, 11984, 11999, 5, 1306, 0, 0, 11985, 11987, 5, 665, 0, 0, 11986, 11988, 3, 1200, 600, 0, 11987, 11986, 1, 0, 0, 0, 11987, 11988, 1, 0, 0, 0, 11988, 11989, 1, 0, 0, 0, 11989, 12000, 3, 1220, 610, 0, 11990, 11992, 5, 717, 0, 0, 11991, 11993, 3, 1200, 600, 0, 11992, 11991, 1, 0, 0, 0, 11992, 11993, 1, 0, 0, 0, 11993, 11995, 1, 0, 0, 0, 11994, 11996, 3, 1596, 798, 0, 11995, 11994, 1, 0, 0, 0, 11995, 11996, 1, 0, 0, 0, 11996, 12000, 1, 0, 0, 0, 11997, 11998, 5, 560, 0, 0, 11998, 12000, 3, 1222, 611, 0, 11999, 11985, 1, 0, 0, 0, 11999, 11990, 1, 0, 0, 0, 11999, 11997, 1, 0, 0, 0, 12000, 12023, 1, 0, 0, 0, 12001, 12002, 5, 560, 0, 0, 12002, 12003, 5, 1348, 0, 0, 12003, 12004, 5, 84, 0, 0, 12004, 12007, 3, 1222, 611, 0, 12005, 12006, 5, 1549, 0, 0, 12006, 12008, 5, 858, 0, 0, 12007, 12005, 1, 0, 0, 0, 12007, 12008, 1, 0, 0, 0, 12008, 12023, 1, 0, 0, 0, 12009, 12010, 5, 220, 0, 0, 12010, 12011, 3, 466, 233, 0, 12011, 12012, 5, 2447, 0, 0, 12012, 12017, 3, 2340, 1170, 0, 12013, 12014, 5, 2453, 0, 0, 12014, 12016, 3, 2340, 1170, 0, 12015, 12013, 1, 0, 0, 0, 12016, 12019, 1, 0, 0, 0, 12017, 12015, 1, 0, 0, 0, 12017, 12018, 1, 0, 0, 0, 12018, 12020, 1, 0, 0, 0, 12019, 12017, 1, 0, 0, 0, 12020, 12021, 5, 2448, 0, 0, 12021, 12023, 1, 0, 0, 0, 12022, 11979, 1, 0, 0, 0, 12022, 11980, 1, 0, 0, 0, 12022, 11981, 1, 0, 0, 0, 12022, 11982, 1, 0, 0, 0, 12022, 11983, 1, 0, 0, 0, 12022, 11984, 1, 0, 0, 0, 12022, 12001, 1, 0, 0, 0, 12022, 12009, 1, 0, 0, 0, 12023, 1203, 1, 0, 0, 0, 12024, 12034, 5, 697, 0, 0, 12025, 12026, 5, 21, 0, 0, 12026, 12027, 5, 1412, 0, 0, 12027, 12035, 3, 1206, 603, 0, 12028, 12029, 7, 135, 0, 0, 12029, 12030, 5, 1412, 0, 0, 12030, 12035, 3, 1206, 603, 0, 12031, 12035, 5, 402, 0, 0, 12032, 12035, 5, 498, 0, 0, 12033, 12035, 5, 428, 0, 0, 12034, 12025, 1, 0, 0, 0, 12034, 12028, 1, 0, 0, 0, 12034, 12031, 1, 0, 0, 0, 12034, 12032, 1, 0, 0, 0, 12034, 12033, 1, 0, 0, 0, 12035, 1205, 1, 0, 0, 0, 12036, 12040, 3, 1208, 604, 0, 12037, 12040, 3, 1210, 605, 0, 12038, 12040, 3, 1216, 608, 0, 12039, 12036, 1, 0, 0, 0, 12039, 12037, 1, 0, 0, 0, 12039, 12038, 1, 0, 0, 0, 12040, 1207, 1, 0, 0, 0, 12041, 12042, 3, 1178, 589, 0, 12042, 12043, 3, 1214, 607, 0, 12043, 12044, 3, 1212, 606, 0, 12044, 12061, 1, 0, 0, 0, 12045, 12046, 7, 136, 0, 0, 12046, 12047, 5, 1763, 0, 0, 12047, 12051, 5, 258, 0, 0, 12048, 12052, 5, 29, 0, 0, 12049, 12050, 5, 620, 0, 0, 12050, 12052, 5, 1484, 0, 0, 12051, 12048, 1, 0, 0, 0, 12051, 12049, 1, 0, 0, 0, 12052, 12053, 1, 0, 0, 0, 12053, 12054, 5, 1606, 0, 0, 12054, 12055, 5, 33, 0, 0, 12055, 12056, 3, 1218, 609, 0, 12056, 12057, 5, 1246, 0, 0, 12057, 12058, 5, 1137, 0, 0, 12058, 12059, 5, 978, 0, 0, 12059, 12061, 1, 0, 0, 0, 12060, 12041, 1, 0, 0, 0, 12060, 12045, 1, 0, 0, 0, 12061, 1209, 1, 0, 0, 0, 12062, 12063, 5, 2104, 0, 0, 12063, 12064, 5, 2141, 0, 0, 12064, 12078, 3, 1656, 828, 0, 12065, 12067, 3, 1214, 607, 0, 12066, 12065, 1, 0, 0, 0, 12066, 12067, 1, 0, 0, 0, 12067, 12070, 1, 0, 0, 0, 12068, 12069, 5, 1259, 0, 0, 12069, 12071, 3, 2320, 1160, 0, 12070, 12068, 1, 0, 0, 0, 12070, 12071, 1, 0, 0, 0, 12071, 12079, 1, 0, 0, 0, 12072, 12073, 5, 1505, 0, 0, 12073, 12075, 5, 1258, 0, 0, 12074, 12076, 3, 1214, 607, 0, 12075, 12074, 1, 0, 0, 0, 12075, 12076, 1, 0, 0, 0, 12076, 12077, 1, 0, 0, 0, 12077, 12079, 3, 1212, 606, 0, 12078, 12066, 1, 0, 0, 0, 12078, 12072, 1, 0, 0, 0, 12079, 1211, 1, 0, 0, 0, 12080, 12081, 5, 33, 0, 0, 12081, 12082, 3, 1218, 609, 0, 12082, 12086, 5, 1246, 0, 0, 12083, 12084, 5, 1137, 0, 0, 12084, 12087, 7, 137, 0, 0, 12085, 12087, 5, 324, 0, 0, 12086, 12083, 1, 0, 0, 0, 12086, 12085, 1, 0, 0, 0, 12087, 12091, 1, 0, 0, 0, 12088, 12089, 5, 1259, 0, 0, 12089, 12091, 3, 2320, 1160, 0, 12090, 12080, 1, 0, 0, 0, 12090, 12088, 1, 0, 0, 0, 12091, 1213, 1, 0, 0, 0, 12092, 12093, 7, 138, 0, 0, 12093, 1215, 1, 0, 0, 0, 12094, 12095, 5, 1671, 0, 0, 12095, 12097, 5, 746, 0, 0, 12096, 12098, 3, 1182, 591, 0, 12097, 12096, 1, 0, 0, 0, 12097, 12098, 1, 0, 0, 0, 12098, 12105, 1, 0, 0, 0, 12099, 12100, 5, 980, 0, 0, 12100, 12101, 5, 746, 0, 0, 12101, 12105, 3, 1184, 592, 0, 12102, 12103, 5, 1137, 0, 0, 12103, 12105, 5, 746, 0, 0, 12104, 12094, 1, 0, 0, 0, 12104, 12099, 1, 0, 0, 0, 12104, 12102, 1, 0, 0, 0, 12105, 12107, 1, 0, 0, 0, 12106, 12108, 5, 1645, 0, 0, 12107, 12106, 1, 0, 0, 0, 12107, 12108, 1, 0, 0, 0, 12108, 12109, 1, 0, 0, 0, 12109, 12110, 3, 1212, 606, 0, 12110, 1217, 1, 0, 0, 0, 12111, 12112, 3, 2396, 1198, 0, 12112, 12113, 7, 139, 0, 0, 12113, 1219, 1, 0, 0, 0, 12114, 12116, 3, 1178, 589, 0, 12115, 12114, 1, 0, 0, 0, 12115, 12116, 1, 0, 0, 0, 12116, 12118, 1, 0, 0, 0, 12117, 12119, 3, 1180, 590, 0, 12118, 12117, 1, 0, 0, 0, 12118, 12119, 1, 0, 0, 0, 12119, 12121, 1, 0, 0, 0, 12120, 12122, 3, 1204, 602, 0, 12121, 12120, 1, 0, 0, 0, 12121, 12122, 1, 0, 0, 0, 12122, 1221, 1, 0, 0, 0, 12123, 12126, 5, 2447, 0, 0, 12124, 12125, 5, 2166, 0, 0, 12125, 12127, 3, 1224, 612, 0, 12126, 12124, 1, 0, 0, 0, 12126, 12127, 1, 0, 0, 0, 12127, 12128, 1, 0, 0, 0, 12128, 12129, 3, 1226, 613, 0, 12129, 12131, 5, 2448, 0, 0, 12130, 12132, 3, 928, 464, 0, 12131, 12130, 1, 0, 0, 0, 12131, 12132, 1, 0, 0, 0, 12132, 12139, 1, 0, 0, 0, 12133, 12134, 5, 1549, 0, 0, 12134, 12137, 5, 858, 0, 0, 12135, 12138, 3, 2396, 1198, 0, 12136, 12138, 5, 2185, 0, 0, 12137, 12135, 1, 0, 0, 0, 12137, 12136, 1, 0, 0, 0, 12138, 12140, 1, 0, 0, 0, 12139, 12133, 1, 0, 0, 0, 12139, 12140, 1, 0, 0, 0, 12140, 12142, 1, 0, 0, 0, 12141, 12143, 3, 1180, 590, 0, 12142, 12141, 1, 0, 0, 0, 12142, 12143, 1, 0, 0, 0, 12143, 1223, 1, 0, 0, 0, 12144, 12145, 7, 140, 0, 0, 12145, 1225, 1, 0, 0, 0, 12146, 12147, 5, 389, 0, 0, 12147, 12148, 5, 426, 0, 0, 12148, 12150, 3, 1270, 635, 0, 12149, 12146, 1, 0, 0, 0, 12149, 12150, 1, 0, 0, 0, 12150, 12169, 1, 0, 0, 0, 12151, 12152, 5, 4, 0, 0, 12152, 12167, 5, 1335, 0, 0, 12153, 12154, 5, 2447, 0, 0, 12154, 12155, 5, 2443, 0, 0, 12155, 12168, 5, 2448, 0, 0, 12156, 12158, 5, 2447, 0, 0, 12157, 12159, 3, 1228, 614, 0, 12158, 12157, 1, 0, 0, 0, 12159, 12160, 1, 0, 0, 0, 12160, 12158, 1, 0, 0, 0, 12160, 12161, 1, 0, 0, 0, 12161, 12162, 1, 0, 0, 0, 12162, 12163, 5, 2448, 0, 0, 12163, 12168, 1, 0, 0, 0, 12164, 12165, 5, 2246, 0, 0, 12165, 12166, 5, 215, 0, 0, 12166, 12168, 3, 1868, 934, 0, 12167, 12153, 1, 0, 0, 0, 12167, 12156, 1, 0, 0, 0, 12167, 12164, 1, 0, 0, 0, 12168, 12170, 1, 0, 0, 0, 12169, 12151, 1, 0, 0, 0, 12169, 12170, 1, 0, 0, 0, 12170, 12183, 1, 0, 0, 0, 12171, 12172, 5, 876, 0, 0, 12172, 12173, 5, 2447, 0, 0, 12173, 12178, 3, 1270, 635, 0, 12174, 12175, 5, 2453, 0, 0, 12175, 12177, 3, 1270, 635, 0, 12176, 12174, 1, 0, 0, 0, 12177, 12180, 1, 0, 0, 0, 12178, 12176, 1, 0, 0, 0, 12178, 12179, 1, 0, 0, 0, 12179, 12181, 1, 0, 0, 0, 12180, 12178, 1, 0, 0, 0, 12181, 12182, 5, 2448, 0, 0, 12182, 12184, 1, 0, 0, 0, 12183, 12171, 1, 0, 0, 0, 12183, 12184, 1, 0, 0, 0, 12184, 1227, 1, 0, 0, 0, 12185, 12186, 5, 1513, 0, 0, 12186, 12187, 5, 405, 0, 0, 12187, 12188, 5, 160, 0, 0, 12188, 12207, 5, 1022, 0, 0, 12189, 12190, 5, 237, 0, 0, 12190, 12191, 5, 2149, 0, 0, 12191, 12192, 5, 2447, 0, 0, 12192, 12197, 3, 1230, 615, 0, 12193, 12194, 5, 2453, 0, 0, 12194, 12196, 3, 1230, 615, 0, 12195, 12193, 1, 0, 0, 0, 12196, 12199, 1, 0, 0, 0, 12197, 12195, 1, 0, 0, 0, 12197, 12198, 1, 0, 0, 0, 12198, 12200, 1, 0, 0, 0, 12199, 12197, 1, 0, 0, 0, 12200, 12201, 5, 2448, 0, 0, 12201, 12207, 1, 0, 0, 0, 12202, 12207, 3, 1254, 627, 0, 12203, 12207, 3, 1260, 630, 0, 12204, 12207, 3, 1262, 631, 0, 12205, 12207, 3, 1264, 632, 0, 12206, 12185, 1, 0, 0, 0, 12206, 12189, 1, 0, 0, 0, 12206, 12202, 1, 0, 0, 0, 12206, 12203, 1, 0, 0, 0, 12206, 12204, 1, 0, 0, 0, 12206, 12205, 1, 0, 0, 0, 12207, 1229, 1, 0, 0, 0, 12208, 12209, 3, 2340, 1170, 0, 12209, 12244, 5, 628, 0, 0, 12210, 12245, 5, 1228, 0, 0, 12211, 12212, 5, 284, 0, 0, 12212, 12245, 3, 2400, 1200, 0, 12213, 12217, 7, 141, 0, 0, 12214, 12218, 3, 1232, 616, 0, 12215, 12216, 5, 284, 0, 0, 12216, 12218, 3, 2400, 1200, 0, 12217, 12214, 1, 0, 0, 0, 12217, 12215, 1, 0, 0, 0, 12218, 12245, 1, 0, 0, 0, 12219, 12220, 5, 628, 0, 0, 12220, 12221, 5, 2447, 0, 0, 12221, 12226, 3, 1270, 635, 0, 12222, 12223, 5, 2453, 0, 0, 12223, 12225, 3, 1270, 635, 0, 12224, 12222, 1, 0, 0, 0, 12225, 12228, 1, 0, 0, 0, 12226, 12224, 1, 0, 0, 0, 12226, 12227, 1, 0, 0, 0, 12227, 12229, 1, 0, 0, 0, 12228, 12226, 1, 0, 0, 0, 12229, 12230, 5, 2448, 0, 0, 12230, 12237, 1, 0, 0, 0, 12231, 12237, 5, 215, 0, 0, 12232, 12237, 5, 142, 0, 0, 12233, 12234, 5, 195, 0, 0, 12234, 12235, 5, 2472, 0, 0, 12235, 12237, 3, 2346, 1173, 0, 12236, 12219, 1, 0, 0, 0, 12236, 12231, 1, 0, 0, 0, 12236, 12232, 1, 0, 0, 0, 12236, 12233, 1, 0, 0, 0, 12237, 12245, 1, 0, 0, 0, 12238, 12239, 5, 1738, 0, 0, 12239, 12240, 3, 1234, 617, 0, 12240, 12241, 5, 2447, 0, 0, 12241, 12242, 5, 2441, 0, 0, 12242, 12243, 5, 2448, 0, 0, 12243, 12245, 1, 0, 0, 0, 12244, 12210, 1, 0, 0, 0, 12244, 12211, 1, 0, 0, 0, 12244, 12213, 1, 0, 0, 0, 12244, 12236, 1, 0, 0, 0, 12244, 12238, 1, 0, 0, 0, 12245, 1231, 1, 0, 0, 0, 12246, 12248, 3, 2340, 1170, 0, 12247, 12249, 3, 2314, 1157, 0, 12248, 12247, 1, 0, 0, 0, 12248, 12249, 1, 0, 0, 0, 12249, 12252, 1, 0, 0, 0, 12250, 12251, 5, 1204, 0, 0, 12251, 12253, 5, 1228, 0, 0, 12252, 12250, 1, 0, 0, 0, 12252, 12253, 1, 0, 0, 0, 12253, 12255, 1, 0, 0, 0, 12254, 12256, 3, 1738, 869, 0, 12255, 12254, 1, 0, 0, 0, 12255, 12256, 1, 0, 0, 0, 12256, 1233, 1, 0, 0, 0, 12257, 12262, 3, 1236, 618, 0, 12258, 12259, 5, 2453, 0, 0, 12259, 12261, 3, 1236, 618, 0, 12260, 12258, 1, 0, 0, 0, 12261, 12264, 1, 0, 0, 0, 12262, 12260, 1, 0, 0, 0, 12262, 12263, 1, 0, 0, 0, 12263, 1235, 1, 0, 0, 0, 12264, 12262, 1, 0, 0, 0, 12265, 12272, 3, 1232, 616, 0, 12266, 12271, 3, 1238, 619, 0, 12267, 12271, 3, 1240, 620, 0, 12268, 12271, 3, 1248, 624, 0, 12269, 12271, 3, 1252, 626, 0, 12270, 12266, 1, 0, 0, 0, 12270, 12267, 1, 0, 0, 0, 12270, 12268, 1, 0, 0, 0, 12270, 12269, 1, 0, 0, 0, 12271, 12274, 1, 0, 0, 0, 12272, 12270, 1, 0, 0, 0, 12272, 12273, 1, 0, 0, 0, 12273, 1237, 1, 0, 0, 0, 12274, 12272, 1, 0, 0, 0, 12275, 12277, 5, 1418, 0, 0, 12276, 12275, 1, 0, 0, 0, 12276, 12277, 1, 0, 0, 0, 12277, 12278, 1, 0, 0, 0, 12278, 12280, 5, 2447, 0, 0, 12279, 12281, 5, 2450, 0, 0, 12280, 12279, 1, 0, 0, 0, 12280, 12281, 1, 0, 0, 0, 12281, 12283, 1, 0, 0, 0, 12282, 12284, 7, 142, 0, 0, 12283, 12282, 1, 0, 0, 0, 12283, 12284, 1, 0, 0, 0, 12284, 12286, 1, 0, 0, 0, 12285, 12287, 5, 2441, 0, 0, 12286, 12285, 1, 0, 0, 0, 12286, 12287, 1, 0, 0, 0, 12287, 12294, 1, 0, 0, 0, 12288, 12295, 5, 2462, 0, 0, 12289, 12291, 5, 2469, 0, 0, 12290, 12292, 7, 142, 0, 0, 12291, 12290, 1, 0, 0, 0, 12291, 12292, 1, 0, 0, 0, 12292, 12293, 1, 0, 0, 0, 12293, 12295, 5, 2441, 0, 0, 12294, 12288, 1, 0, 0, 0, 12294, 12289, 1, 0, 0, 0, 12295, 12296, 1, 0, 0, 0, 12296, 12297, 5, 2448, 0, 0, 12297, 1239, 1, 0, 0, 0, 12298, 12300, 5, 2200, 0, 0, 12299, 12298, 1, 0, 0, 0, 12299, 12300, 1, 0, 0, 0, 12300, 12301, 1, 0, 0, 0, 12301, 12303, 5, 769, 0, 0, 12302, 12304, 5, 560, 0, 0, 12303, 12302, 1, 0, 0, 0, 12303, 12304, 1, 0, 0, 0, 12304, 12306, 1, 0, 0, 0, 12305, 12307, 5, 2441, 0, 0, 12306, 12305, 1, 0, 0, 0, 12306, 12307, 1, 0, 0, 0, 12307, 12309, 1, 0, 0, 0, 12308, 12310, 3, 1242, 621, 0, 12309, 12308, 1, 0, 0, 0, 12309, 12310, 1, 0, 0, 0, 12310, 12388, 1, 0, 0, 0, 12311, 12328, 7, 143, 0, 0, 12312, 12313, 5, 2447, 0, 0, 12313, 12316, 5, 2441, 0, 0, 12314, 12315, 5, 2453, 0, 0, 12315, 12317, 5, 2441, 0, 0, 12316, 12314, 1, 0, 0, 0, 12316, 12317, 1, 0, 0, 0, 12317, 12318, 1, 0, 0, 0, 12318, 12329, 5, 2448, 0, 0, 12319, 12323, 5, 560, 0, 0, 12320, 12321, 5, 2447, 0, 0, 12321, 12322, 5, 2441, 0, 0, 12322, 12324, 5, 2448, 0, 0, 12323, 12320, 1, 0, 0, 0, 12323, 12324, 1, 0, 0, 0, 12324, 12326, 1, 0, 0, 0, 12325, 12327, 3, 1242, 621, 0, 12326, 12325, 1, 0, 0, 0, 12326, 12327, 1, 0, 0, 0, 12327, 12329, 1, 0, 0, 0, 12328, 12312, 1, 0, 0, 0, 12328, 12319, 1, 0, 0, 0, 12329, 12388, 1, 0, 0, 0, 12330, 12388, 5, 1281, 0, 0, 12331, 12333, 5, 1282, 0, 0, 12332, 12334, 5, 314, 0, 0, 12333, 12332, 1, 0, 0, 0, 12333, 12334, 1, 0, 0, 0, 12334, 12388, 1, 0, 0, 0, 12335, 12337, 5, 607, 0, 0, 12336, 12338, 5, 560, 0, 0, 12337, 12336, 1, 0, 0, 0, 12337, 12338, 1, 0, 0, 0, 12338, 12340, 1, 0, 0, 0, 12339, 12341, 5, 2441, 0, 0, 12340, 12339, 1, 0, 0, 0, 12340, 12341, 1, 0, 0, 0, 12341, 12343, 1, 0, 0, 0, 12342, 12344, 3, 1242, 621, 0, 12343, 12342, 1, 0, 0, 0, 12343, 12344, 1, 0, 0, 0, 12344, 12388, 1, 0, 0, 0, 12345, 12388, 5, 465, 0, 0, 12346, 12348, 5, 128, 0, 0, 12347, 12349, 5, 560, 0, 0, 12348, 12347, 1, 0, 0, 0, 12348, 12349, 1, 0, 0, 0, 12349, 12351, 1, 0, 0, 0, 12350, 12352, 5, 2441, 0, 0, 12351, 12350, 1, 0, 0, 0, 12351, 12352, 1, 0, 0, 0, 12352, 12354, 1, 0, 0, 0, 12353, 12355, 3, 1242, 621, 0, 12354, 12353, 1, 0, 0, 0, 12354, 12355, 1, 0, 0, 0, 12355, 12388, 1, 0, 0, 0, 12356, 12388, 5, 125, 0, 0, 12357, 12359, 5, 1498, 0, 0, 12358, 12360, 5, 2441, 0, 0, 12359, 12358, 1, 0, 0, 0, 12359, 12360, 1, 0, 0, 0, 12360, 12388, 1, 0, 0, 0, 12361, 12363, 5, 196, 0, 0, 12362, 12364, 5, 560, 0, 0, 12363, 12362, 1, 0, 0, 0, 12363, 12364, 1, 0, 0, 0, 12364, 12368, 1, 0, 0, 0, 12365, 12366, 5, 2447, 0, 0, 12366, 12367, 5, 2441, 0, 0, 12367, 12369, 5, 2448, 0, 0, 12368, 12365, 1, 0, 0, 0, 12368, 12369, 1, 0, 0, 0, 12369, 12371, 1, 0, 0, 0, 12370, 12372, 3, 1242, 621, 0, 12371, 12370, 1, 0, 0, 0, 12371, 12372, 1, 0, 0, 0, 12372, 12374, 1, 0, 0, 0, 12373, 12375, 3, 1244, 622, 0, 12374, 12373, 1, 0, 0, 0, 12374, 12375, 1, 0, 0, 0, 12375, 12377, 1, 0, 0, 0, 12376, 12378, 3, 1246, 623, 0, 12377, 12376, 1, 0, 0, 0, 12377, 12378, 1, 0, 0, 0, 12378, 12388, 1, 0, 0, 0, 12379, 12380, 7, 144, 0, 0, 12380, 12383, 5, 2447, 0, 0, 12381, 12382, 5, 2441, 0, 0, 12382, 12384, 5, 2453, 0, 0, 12383, 12381, 1, 0, 0, 0, 12383, 12384, 1, 0, 0, 0, 12384, 12385, 1, 0, 0, 0, 12385, 12386, 5, 2441, 0, 0, 12386, 12388, 5, 2448, 0, 0, 12387, 12299, 1, 0, 0, 0, 12387, 12311, 1, 0, 0, 0, 12387, 12330, 1, 0, 0, 0, 12387, 12331, 1, 0, 0, 0, 12387, 12335, 1, 0, 0, 0, 12387, 12345, 1, 0, 0, 0, 12387, 12346, 1, 0, 0, 0, 12387, 12356, 1, 0, 0, 0, 12387, 12357, 1, 0, 0, 0, 12387, 12361, 1, 0, 0, 0, 12387, 12379, 1, 0, 0, 0, 12388, 1241, 1, 0, 0, 0, 12389, 12390, 5, 503, 0, 0, 12390, 12391, 5, 160, 0, 0, 12391, 12394, 3, 2400, 1200, 0, 12392, 12393, 5, 49, 0, 0, 12393, 12395, 3, 2400, 1200, 0, 12394, 12392, 1, 0, 0, 0, 12394, 12395, 1, 0, 0, 0, 12395, 12415, 1, 0, 0, 0, 12396, 12397, 5, 2094, 0, 0, 12397, 12400, 5, 160, 0, 0, 12398, 12401, 3, 2400, 1200, 0, 12399, 12401, 5, 2303, 0, 0, 12400, 12398, 1, 0, 0, 0, 12400, 12399, 1, 0, 0, 0, 12401, 12412, 1, 0, 0, 0, 12402, 12404, 5, 1273, 0, 0, 12403, 12402, 1, 0, 0, 0, 12403, 12404, 1, 0, 0, 0, 12404, 12405, 1, 0, 0, 0, 12405, 12406, 5, 503, 0, 0, 12406, 12407, 5, 160, 0, 0, 12407, 12410, 3, 2400, 1200, 0, 12408, 12409, 5, 49, 0, 0, 12409, 12411, 3, 2400, 1200, 0, 12410, 12408, 1, 0, 0, 0, 12410, 12411, 1, 0, 0, 0, 12411, 12413, 1, 0, 0, 0, 12412, 12403, 1, 0, 0, 0, 12412, 12413, 1, 0, 0, 0, 12413, 12415, 1, 0, 0, 0, 12414, 12389, 1, 0, 0, 0, 12414, 12396, 1, 0, 0, 0, 12415, 1243, 1, 0, 0, 0, 12416, 12417, 7, 145, 0, 0, 12417, 1245, 1, 0, 0, 0, 12418, 12420, 5, 363, 0, 0, 12419, 12418, 1, 0, 0, 0, 12419, 12420, 1, 0, 0, 0, 12420, 12435, 1, 0, 0, 0, 12421, 12436, 5, 361, 0, 0, 12422, 12429, 5, 2108, 0, 0, 12423, 12425, 5, 2308, 0, 0, 12424, 12426, 5, 873, 0, 0, 12425, 12424, 1, 0, 0, 0, 12425, 12426, 1, 0, 0, 0, 12426, 12427, 1, 0, 0, 0, 12427, 12428, 5, 2112, 0, 0, 12428, 12430, 5, 2363, 0, 0, 12429, 12423, 1, 0, 0, 0, 12429, 12430, 1, 0, 0, 0, 12430, 12431, 1, 0, 0, 0, 12431, 12432, 5, 912, 0, 0, 12432, 12436, 3, 2400, 1200, 0, 12433, 12434, 5, 776, 0, 0, 12434, 12436, 7, 146, 0, 0, 12435, 12421, 1, 0, 0, 0, 12435, 12422, 1, 0, 0, 0, 12435, 12433, 1, 0, 0, 0, 12436, 1247, 1, 0, 0, 0, 12437, 12438, 7, 147, 0, 0, 12438, 12439, 3, 1250, 625, 0, 12439, 1249, 1, 0, 0, 0, 12440, 12446, 6, 625, -1, 0, 12441, 12447, 3, 1758, 879, 0, 12442, 12443, 5, 2447, 0, 0, 12443, 12444, 5, 2441, 0, 0, 12444, 12445, 5, 2462, 0, 0, 12445, 12447, 5, 2448, 0, 0, 12446, 12441, 1, 0, 0, 0, 12446, 12442, 1, 0, 0, 0, 12447, 12448, 1, 0, 0, 0, 12448, 12452, 3, 2096, 1048, 0, 12449, 12453, 3, 2400, 1200, 0, 12450, 12453, 5, 2438, 0, 0, 12451, 12453, 5, 141, 0, 0, 12452, 12449, 1, 0, 0, 0, 12452, 12450, 1, 0, 0, 0, 12452, 12451, 1, 0, 0, 0, 12453, 12459, 1, 0, 0, 0, 12454, 12455, 10, 1, 0, 0, 12455, 12456, 7, 148, 0, 0, 12456, 12458, 3, 1250, 625, 2, 12457, 12454, 1, 0, 0, 0, 12458, 12461, 1, 0, 0, 0, 12459, 12457, 1, 0, 0, 0, 12459, 12460, 1, 0, 0, 0, 12460, 1251, 1, 0, 0, 0, 12461, 12459, 1, 0, 0, 0, 12462, 12463, 5, 864, 0, 0, 12463, 12464, 3, 1270, 635, 0, 12464, 1253, 1, 0, 0, 0, 12465, 12494, 5, 1513, 0, 0, 12466, 12467, 5, 602, 0, 0, 12467, 12495, 5, 2441, 0, 0, 12468, 12469, 5, 2262, 0, 0, 12469, 12495, 5, 2441, 0, 0, 12470, 12471, 5, 405, 0, 0, 12471, 12477, 5, 160, 0, 0, 12472, 12474, 5, 418, 0, 0, 12473, 12472, 1, 0, 0, 0, 12473, 12474, 1, 0, 0, 0, 12474, 12475, 1, 0, 0, 0, 12475, 12478, 5, 1022, 0, 0, 12476, 12478, 3, 2400, 1200, 0, 12477, 12473, 1, 0, 0, 0, 12477, 12476, 1, 0, 0, 0, 12478, 12495, 1, 0, 0, 0, 12479, 12481, 5, 2348, 0, 0, 12480, 12482, 5, 2447, 0, 0, 12481, 12480, 1, 0, 0, 0, 12481, 12482, 1, 0, 0, 0, 12482, 12483, 1, 0, 0, 0, 12483, 12488, 3, 2404, 1202, 0, 12484, 12485, 5, 2453, 0, 0, 12485, 12487, 3, 2404, 1202, 0, 12486, 12484, 1, 0, 0, 0, 12487, 12490, 1, 0, 0, 0, 12488, 12486, 1, 0, 0, 0, 12488, 12489, 1, 0, 0, 0, 12489, 12492, 1, 0, 0, 0, 12490, 12488, 1, 0, 0, 0, 12491, 12493, 5, 2448, 0, 0, 12492, 12491, 1, 0, 0, 0, 12492, 12493, 1, 0, 0, 0, 12493, 12495, 1, 0, 0, 0, 12494, 12466, 1, 0, 0, 0, 12494, 12468, 1, 0, 0, 0, 12494, 12470, 1, 0, 0, 0, 12494, 12479, 1, 0, 0, 0, 12495, 12499, 1, 0, 0, 0, 12496, 12498, 3, 1256, 628, 0, 12497, 12496, 1, 0, 0, 0, 12498, 12501, 1, 0, 0, 0, 12499, 12497, 1, 0, 0, 0, 12499, 12500, 1, 0, 0, 0, 12500, 12508, 1, 0, 0, 0, 12501, 12499, 1, 0, 0, 0, 12502, 12504, 3, 1256, 628, 0, 12503, 12502, 1, 0, 0, 0, 12504, 12505, 1, 0, 0, 0, 12505, 12503, 1, 0, 0, 0, 12505, 12506, 1, 0, 0, 0, 12506, 12508, 1, 0, 0, 0, 12507, 12465, 1, 0, 0, 0, 12507, 12503, 1, 0, 0, 0, 12508, 1255, 1, 0, 0, 0, 12509, 12510, 5, 195, 0, 0, 12510, 12547, 3, 2346, 1173, 0, 12511, 12512, 5, 560, 0, 0, 12512, 12513, 5, 2262, 0, 0, 12513, 12547, 5, 351, 0, 0, 12514, 12515, 5, 1442, 0, 0, 12515, 12547, 3, 1270, 635, 0, 12516, 12517, 5, 351, 0, 0, 12517, 12518, 5, 785, 0, 0, 12518, 12519, 7, 149, 0, 0, 12519, 12547, 5, 510, 0, 0, 12520, 12521, 5, 165, 0, 0, 12521, 12547, 7, 150, 0, 0, 12522, 12523, 5, 1767, 0, 0, 12523, 12524, 5, 1700, 0, 0, 12524, 12525, 5, 67, 0, 0, 12525, 12526, 5, 738, 0, 0, 12526, 12547, 7, 151, 0, 0, 12527, 12528, 5, 867, 0, 0, 12528, 12529, 5, 2300, 0, 0, 12529, 12547, 3, 1250, 625, 0, 12530, 12547, 3, 1258, 629, 0, 12531, 12533, 5, 1507, 0, 0, 12532, 12534, 5, 2472, 0, 0, 12533, 12532, 1, 0, 0, 0, 12533, 12534, 1, 0, 0, 0, 12534, 12535, 1, 0, 0, 0, 12535, 12547, 5, 2441, 0, 0, 12536, 12547, 5, 431, 0, 0, 12537, 12538, 5, 362, 0, 0, 12538, 12547, 5, 2441, 0, 0, 12539, 12540, 5, 1702, 0, 0, 12540, 12547, 5, 2441, 0, 0, 12541, 12542, 5, 784, 0, 0, 12542, 12547, 7, 152, 0, 0, 12543, 12547, 7, 153, 0, 0, 12544, 12545, 5, 453, 0, 0, 12545, 12547, 5, 2441, 0, 0, 12546, 12509, 1, 0, 0, 0, 12546, 12511, 1, 0, 0, 0, 12546, 12514, 1, 0, 0, 0, 12546, 12516, 1, 0, 0, 0, 12546, 12520, 1, 0, 0, 0, 12546, 12522, 1, 0, 0, 0, 12546, 12527, 1, 0, 0, 0, 12546, 12530, 1, 0, 0, 0, 12546, 12531, 1, 0, 0, 0, 12546, 12536, 1, 0, 0, 0, 12546, 12537, 1, 0, 0, 0, 12546, 12539, 1, 0, 0, 0, 12546, 12541, 1, 0, 0, 0, 12546, 12543, 1, 0, 0, 0, 12546, 12544, 1, 0, 0, 0, 12547, 1257, 1, 0, 0, 0, 12548, 12555, 7, 154, 0, 0, 12549, 12551, 7, 155, 0, 0, 12550, 12552, 3, 1270, 635, 0, 12551, 12550, 1, 0, 0, 0, 12551, 12552, 1, 0, 0, 0, 12552, 12553, 1, 0, 0, 0, 12553, 12555, 3, 1458, 729, 0, 12554, 12548, 1, 0, 0, 0, 12554, 12549, 1, 0, 0, 0, 12555, 1259, 1, 0, 0, 0, 12556, 12558, 5, 588, 0, 0, 12557, 12559, 5, 693, 0, 0, 12558, 12557, 1, 0, 0, 0, 12558, 12559, 1, 0, 0, 0, 12559, 12563, 1, 0, 0, 0, 12560, 12561, 5, 330, 0, 0, 12561, 12562, 7, 2, 0, 0, 12562, 12564, 5, 494, 0, 0, 12563, 12560, 1, 0, 0, 0, 12563, 12564, 1, 0, 0, 0, 12564, 12566, 1, 0, 0, 0, 12565, 12567, 3, 1242, 621, 0, 12566, 12565, 1, 0, 0, 0, 12566, 12567, 1, 0, 0, 0, 12567, 12569, 1, 0, 0, 0, 12568, 12570, 3, 1244, 622, 0, 12569, 12568, 1, 0, 0, 0, 12569, 12570, 1, 0, 0, 0, 12570, 12576, 1, 0, 0, 0, 12571, 12572, 5, 38, 0, 0, 12572, 12573, 5, 588, 0, 0, 12573, 12574, 5, 1323, 0, 0, 12574, 12575, 5, 2101, 0, 0, 12575, 12577, 5, 588, 0, 0, 12576, 12571, 1, 0, 0, 0, 12576, 12577, 1, 0, 0, 0, 12577, 12583, 1, 0, 0, 0, 12578, 12579, 5, 964, 0, 0, 12579, 12580, 5, 587, 0, 0, 12580, 12581, 5, 2257, 0, 0, 12581, 12582, 5, 67, 0, 0, 12582, 12584, 5, 1228, 0, 0, 12583, 12578, 1, 0, 0, 0, 12583, 12584, 1, 0, 0, 0, 12584, 12591, 1, 0, 0, 0, 12585, 12586, 5, 1549, 0, 0, 12586, 12587, 5, 1607, 0, 0, 12587, 12588, 5, 2308, 0, 0, 12588, 12589, 5, 38, 0, 0, 12589, 12590, 5, 1228, 0, 0, 12590, 12592, 5, 588, 0, 0, 12591, 12585, 1, 0, 0, 0, 12591, 12592, 1, 0, 0, 0, 12592, 12597, 1, 0, 0, 0, 12593, 12594, 5, 363, 0, 0, 12594, 12595, 7, 156, 0, 0, 12595, 12596, 5, 912, 0, 0, 12596, 12598, 3, 2400, 1200, 0, 12597, 12593, 1, 0, 0, 0, 12597, 12598, 1, 0, 0, 0, 12598, 12607, 1, 0, 0, 0, 12599, 12600, 5, 1227, 0, 0, 12600, 12604, 7, 157, 0, 0, 12601, 12605, 3, 2400, 1200, 0, 12602, 12605, 5, 2438, 0, 0, 12603, 12605, 5, 141, 0, 0, 12604, 12601, 1, 0, 0, 0, 12604, 12602, 1, 0, 0, 0, 12604, 12603, 1, 0, 0, 0, 12605, 12608, 1, 0, 0, 0, 12606, 12608, 5, 1134, 0, 0, 12607, 12599, 1, 0, 0, 0, 12607, 12606, 1, 0, 0, 0, 12607, 12608, 1, 0, 0, 0, 12608, 12610, 1, 0, 0, 0, 12609, 12611, 5, 2447, 0, 0, 12610, 12609, 1, 0, 0, 0, 12610, 12611, 1, 0, 0, 0, 12611, 12613, 1, 0, 0, 0, 12612, 12614, 3, 1234, 617, 0, 12613, 12612, 1, 0, 0, 0, 12613, 12614, 1, 0, 0, 0, 12614, 12616, 1, 0, 0, 0, 12615, 12617, 5, 2448, 0, 0, 12616, 12615, 1, 0, 0, 0, 12616, 12617, 1, 0, 0, 0, 12617, 1261, 1, 0, 0, 0, 12618, 12619, 5, 506, 0, 0, 12619, 12675, 7, 158, 0, 0, 12620, 12675, 5, 1118, 0, 0, 12621, 12623, 5, 882, 0, 0, 12622, 12624, 3, 1270, 635, 0, 12623, 12622, 1, 0, 0, 0, 12623, 12624, 1, 0, 0, 0, 12624, 12625, 1, 0, 0, 0, 12625, 12675, 3, 1458, 729, 0, 12626, 12632, 5, 259, 0, 0, 12627, 12629, 5, 500, 0, 0, 12628, 12630, 7, 159, 0, 0, 12629, 12628, 1, 0, 0, 0, 12629, 12630, 1, 0, 0, 0, 12630, 12633, 1, 0, 0, 0, 12631, 12633, 5, 430, 0, 0, 12632, 12627, 1, 0, 0, 0, 12632, 12631, 1, 0, 0, 0, 12632, 12633, 1, 0, 0, 0, 12633, 12675, 1, 0, 0, 0, 12634, 12635, 5, 657, 0, 0, 12635, 12636, 7, 160, 0, 0, 12636, 12640, 5, 2285, 0, 0, 12637, 12641, 5, 247, 0, 0, 12638, 12641, 5, 828, 0, 0, 12639, 12641, 3, 2400, 1200, 0, 12640, 12637, 1, 0, 0, 0, 12640, 12638, 1, 0, 0, 0, 12640, 12639, 1, 0, 0, 0, 12641, 12675, 1, 0, 0, 0, 12642, 12675, 5, 1117, 0, 0, 12643, 12644, 5, 378, 0, 0, 12644, 12645, 5, 2472, 0, 0, 12645, 12646, 5, 2447, 0, 0, 12646, 12647, 5, 2441, 0, 0, 12647, 12648, 5, 2453, 0, 0, 12648, 12649, 5, 2441, 0, 0, 12649, 12675, 5, 2448, 0, 0, 12650, 12651, 5, 359, 0, 0, 12651, 12652, 5, 778, 0, 0, 12652, 12653, 5, 2083, 0, 0, 12653, 12675, 3, 2342, 1171, 0, 12654, 12655, 5, 2091, 0, 0, 12655, 12675, 3, 2342, 1171, 0, 12656, 12657, 5, 793, 0, 0, 12657, 12658, 5, 2447, 0, 0, 12658, 12659, 3, 2286, 1143, 0, 12659, 12660, 5, 2453, 0, 0, 12660, 12661, 3, 2342, 1171, 0, 12661, 12662, 5, 2453, 0, 0, 12662, 12663, 5, 2441, 0, 0, 12663, 12664, 5, 2448, 0, 0, 12664, 12675, 1, 0, 0, 0, 12665, 12666, 5, 2310, 0, 0, 12666, 12675, 5, 2441, 0, 0, 12667, 12668, 5, 1333, 0, 0, 12668, 12675, 5, 2441, 0, 0, 12669, 12670, 5, 2285, 0, 0, 12670, 12675, 3, 2400, 1200, 0, 12671, 12675, 5, 507, 0, 0, 12672, 12673, 5, 370, 0, 0, 12673, 12675, 3, 2400, 1200, 0, 12674, 12618, 1, 0, 0, 0, 12674, 12620, 1, 0, 0, 0, 12674, 12621, 1, 0, 0, 0, 12674, 12626, 1, 0, 0, 0, 12674, 12634, 1, 0, 0, 0, 12674, 12642, 1, 0, 0, 0, 12674, 12643, 1, 0, 0, 0, 12674, 12650, 1, 0, 0, 0, 12674, 12654, 1, 0, 0, 0, 12674, 12656, 1, 0, 0, 0, 12674, 12665, 1, 0, 0, 0, 12674, 12667, 1, 0, 0, 0, 12674, 12669, 1, 0, 0, 0, 12674, 12671, 1, 0, 0, 0, 12674, 12672, 1, 0, 0, 0, 12675, 1263, 1, 0, 0, 0, 12676, 12681, 3, 2404, 1202, 0, 12677, 12678, 5, 2440, 0, 0, 12678, 12680, 3, 2404, 1202, 0, 12679, 12677, 1, 0, 0, 0, 12680, 12683, 1, 0, 0, 0, 12681, 12679, 1, 0, 0, 0, 12681, 12682, 1, 0, 0, 0, 12682, 12684, 1, 0, 0, 0, 12683, 12681, 1, 0, 0, 0, 12684, 12768, 7, 161, 0, 0, 12685, 12769, 3, 2342, 1171, 0, 12686, 12769, 3, 1266, 633, 0, 12687, 12688, 5, 2473, 0, 0, 12688, 12693, 3, 1266, 633, 0, 12689, 12690, 5, 2453, 0, 0, 12690, 12692, 3, 1266, 633, 0, 12691, 12689, 1, 0, 0, 0, 12692, 12695, 1, 0, 0, 0, 12693, 12691, 1, 0, 0, 0, 12693, 12694, 1, 0, 0, 0, 12694, 12696, 1, 0, 0, 0, 12695, 12693, 1, 0, 0, 0, 12696, 12697, 5, 2474, 0, 0, 12697, 12769, 1, 0, 0, 0, 12698, 12699, 3, 1232, 616, 0, 12699, 12702, 3, 2376, 1188, 0, 12700, 12701, 5, 241, 0, 0, 12701, 12703, 3, 2400, 1200, 0, 12702, 12700, 1, 0, 0, 0, 12702, 12703, 1, 0, 0, 0, 12703, 12709, 1, 0, 0, 0, 12704, 12705, 5, 2453, 0, 0, 12705, 12706, 5, 241, 0, 0, 12706, 12708, 3, 2400, 1200, 0, 12707, 12704, 1, 0, 0, 0, 12708, 12711, 1, 0, 0, 0, 12709, 12707, 1, 0, 0, 0, 12709, 12710, 1, 0, 0, 0, 12710, 12769, 1, 0, 0, 0, 12711, 12709, 1, 0, 0, 0, 12712, 12769, 5, 1654, 0, 0, 12713, 12769, 5, 2097, 0, 0, 12714, 12769, 5, 1503, 0, 0, 12715, 12769, 5, 1280, 0, 0, 12716, 12769, 5, 1341, 0, 0, 12717, 12718, 5, 752, 0, 0, 12718, 12719, 3, 2400, 1200, 0, 12719, 12720, 5, 1316, 0, 0, 12720, 12721, 3, 2400, 1200, 0, 12721, 12769, 1, 0, 0, 0, 12722, 12769, 3, 1270, 635, 0, 12723, 12725, 5, 405, 0, 0, 12724, 12723, 1, 0, 0, 0, 12724, 12725, 1, 0, 0, 0, 12725, 12747, 1, 0, 0, 0, 12726, 12727, 5, 588, 0, 0, 12727, 12728, 5, 2094, 0, 0, 12728, 12729, 5, 160, 0, 0, 12729, 12730, 5, 193, 0, 0, 12730, 12731, 5, 526, 0, 0, 12731, 12732, 5, 160, 0, 0, 12732, 12748, 5, 193, 0, 0, 12733, 12734, 5, 234, 0, 0, 12734, 12739, 5, 789, 0, 0, 12735, 12736, 5, 910, 0, 0, 12736, 12739, 5, 819, 0, 0, 12737, 12739, 5, 860, 0, 0, 12738, 12733, 1, 0, 0, 0, 12738, 12735, 1, 0, 0, 0, 12738, 12737, 1, 0, 0, 0, 12739, 12740, 1, 0, 0, 0, 12740, 12741, 5, 2094, 0, 0, 12741, 12742, 5, 160, 0, 0, 12742, 12748, 5, 193, 0, 0, 12743, 12744, 5, 1228, 0, 0, 12744, 12745, 5, 396, 0, 0, 12745, 12746, 5, 69, 0, 0, 12746, 12748, 5, 193, 0, 0, 12747, 12726, 1, 0, 0, 0, 12747, 12738, 1, 0, 0, 0, 12747, 12743, 1, 0, 0, 0, 12748, 12769, 1, 0, 0, 0, 12749, 12750, 5, 1657, 0, 0, 12750, 12766, 3, 2400, 1200, 0, 12751, 12752, 5, 2308, 0, 0, 12752, 12753, 5, 1658, 0, 0, 12753, 12754, 3, 2400, 1200, 0, 12754, 12755, 5, 2472, 0, 0, 12755, 12763, 3, 2400, 1200, 0, 12756, 12757, 5, 2453, 0, 0, 12757, 12758, 3, 2400, 1200, 0, 12758, 12759, 5, 2472, 0, 0, 12759, 12760, 3, 2400, 1200, 0, 12760, 12762, 1, 0, 0, 0, 12761, 12756, 1, 0, 0, 0, 12762, 12765, 1, 0, 0, 0, 12763, 12761, 1, 0, 0, 0, 12763, 12764, 1, 0, 0, 0, 12764, 12767, 1, 0, 0, 0, 12765, 12763, 1, 0, 0, 0, 12766, 12751, 1, 0, 0, 0, 12766, 12767, 1, 0, 0, 0, 12767, 12769, 1, 0, 0, 0, 12768, 12685, 1, 0, 0, 0, 12768, 12686, 1, 0, 0, 0, 12768, 12687, 1, 0, 0, 0, 12768, 12698, 1, 0, 0, 0, 12768, 12712, 1, 0, 0, 0, 12768, 12713, 1, 0, 0, 0, 12768, 12714, 1, 0, 0, 0, 12768, 12715, 1, 0, 0, 0, 12768, 12716, 1, 0, 0, 0, 12768, 12717, 1, 0, 0, 0, 12768, 12722, 1, 0, 0, 0, 12768, 12724, 1, 0, 0, 0, 12768, 12749, 1, 0, 0, 0, 12769, 12771, 1, 0, 0, 0, 12770, 12772, 3, 1264, 632, 0, 12771, 12770, 1, 0, 0, 0, 12771, 12772, 1, 0, 0, 0, 12772, 1265, 1, 0, 0, 0, 12773, 12774, 5, 2459, 0, 0, 12774, 12779, 3, 1268, 634, 0, 12775, 12776, 5, 2453, 0, 0, 12776, 12778, 3, 1268, 634, 0, 12777, 12775, 1, 0, 0, 0, 12778, 12781, 1, 0, 0, 0, 12779, 12777, 1, 0, 0, 0, 12779, 12780, 1, 0, 0, 0, 12780, 12782, 1, 0, 0, 0, 12781, 12779, 1, 0, 0, 0, 12782, 12783, 5, 2460, 0, 0, 12783, 1267, 1, 0, 0, 0, 12784, 12785, 3, 2404, 1202, 0, 12785, 12786, 5, 2462, 0, 0, 12786, 12812, 1, 0, 0, 0, 12787, 12788, 3, 2404, 1202, 0, 12788, 12789, 5, 2469, 0, 0, 12789, 12790, 5, 2473, 0, 0, 12790, 12795, 3, 2404, 1202, 0, 12791, 12792, 5, 2453, 0, 0, 12792, 12794, 3, 2404, 1202, 0, 12793, 12791, 1, 0, 0, 0, 12794, 12797, 1, 0, 0, 0, 12795, 12793, 1, 0, 0, 0, 12795, 12796, 1, 0, 0, 0, 12796, 12798, 1, 0, 0, 0, 12797, 12795, 1, 0, 0, 0, 12798, 12799, 5, 2474, 0, 0, 12799, 12812, 1, 0, 0, 0, 12800, 12801, 5, 2473, 0, 0, 12801, 12806, 3, 2404, 1202, 0, 12802, 12803, 5, 2453, 0, 0, 12803, 12805, 3, 2404, 1202, 0, 12804, 12802, 1, 0, 0, 0, 12805, 12808, 1, 0, 0, 0, 12806, 12804, 1, 0, 0, 0, 12806, 12807, 1, 0, 0, 0, 12807, 12809, 1, 0, 0, 0, 12808, 12806, 1, 0, 0, 0, 12809, 12810, 5, 2474, 0, 0, 12810, 12812, 1, 0, 0, 0, 12811, 12784, 1, 0, 0, 0, 12811, 12787, 1, 0, 0, 0, 12811, 12800, 1, 0, 0, 0, 12812, 1269, 1, 0, 0, 0, 12813, 12814, 3, 786, 393, 0, 12814, 12815, 5, 2469, 0, 0, 12815, 12816, 5, 2443, 0, 0, 12816, 12829, 1, 0, 0, 0, 12817, 12819, 3, 786, 393, 0, 12818, 12820, 3, 740, 370, 0, 12819, 12818, 1, 0, 0, 0, 12819, 12820, 1, 0, 0, 0, 12820, 12821, 1, 0, 0, 0, 12821, 12822, 5, 2469, 0, 0, 12822, 12824, 1, 0, 0, 0, 12823, 12817, 1, 0, 0, 0, 12823, 12824, 1, 0, 0, 0, 12824, 12825, 1, 0, 0, 0, 12825, 12829, 5, 2443, 0, 0, 12826, 12829, 3, 2400, 1200, 0, 12827, 12829, 3, 2326, 1163, 0, 12828, 12813, 1, 0, 0, 0, 12828, 12823, 1, 0, 0, 0, 12828, 12826, 1, 0, 0, 0, 12828, 12827, 1, 0, 0, 0, 12829, 1271, 1, 0, 0, 0, 12830, 12832, 7, 17, 0, 0, 12831, 12830, 1, 0, 0, 0, 12831, 12832, 1, 0, 0, 0, 12832, 12833, 1, 0, 0, 0, 12833, 12834, 5, 1606, 0, 0, 12834, 12835, 5, 991, 0, 0, 12835, 1273, 1, 0, 0, 0, 12836, 12837, 5, 605, 0, 0, 12837, 12839, 5, 64, 0, 0, 12838, 12840, 3, 2404, 1202, 0, 12839, 12838, 1, 0, 0, 0, 12839, 12840, 1, 0, 0, 0, 12840, 12845, 1, 0, 0, 0, 12841, 12842, 5, 1137, 0, 0, 12842, 12843, 5, 605, 0, 0, 12843, 12845, 5, 64, 0, 0, 12844, 12836, 1, 0, 0, 0, 12844, 12841, 1, 0, 0, 0, 12845, 1275, 1, 0, 0, 0, 12846, 12849, 5, 2441, 0, 0, 12847, 12849, 3, 2402, 1201, 0, 12848, 12846, 1, 0, 0, 0, 12848, 12847, 1, 0, 0, 0, 12849, 1277, 1, 0, 0, 0, 12850, 12851, 5, 21, 0, 0, 12851, 12852, 5, 1789, 0, 0, 12852, 12855, 5, 888, 0, 0, 12853, 12856, 3, 1280, 640, 0, 12854, 12856, 3, 1282, 641, 0, 12855, 12853, 1, 0, 0, 0, 12855, 12854, 1, 0, 0, 0, 12856, 12866, 1, 0, 0, 0, 12857, 12858, 5, 2453, 0, 0, 12858, 12859, 5, 1789, 0, 0, 12859, 12862, 5, 888, 0, 0, 12860, 12863, 3, 1280, 640, 0, 12861, 12863, 3, 1282, 641, 0, 12862, 12860, 1, 0, 0, 0, 12862, 12861, 1, 0, 0, 0, 12863, 12865, 1, 0, 0, 0, 12864, 12857, 1, 0, 0, 0, 12865, 12868, 1, 0, 0, 0, 12866, 12864, 1, 0, 0, 0, 12866, 12867, 1, 0, 0, 0, 12867, 12891, 1, 0, 0, 0, 12868, 12866, 1, 0, 0, 0, 12869, 12870, 5, 469, 0, 0, 12870, 12871, 5, 1789, 0, 0, 12871, 12875, 5, 888, 0, 0, 12872, 12876, 3, 1282, 641, 0, 12873, 12874, 5, 649, 0, 0, 12874, 12876, 3, 1276, 638, 0, 12875, 12872, 1, 0, 0, 0, 12875, 12873, 1, 0, 0, 0, 12876, 12887, 1, 0, 0, 0, 12877, 12878, 5, 2453, 0, 0, 12878, 12879, 5, 1789, 0, 0, 12879, 12883, 5, 888, 0, 0, 12880, 12884, 3, 1282, 641, 0, 12881, 12882, 5, 649, 0, 0, 12882, 12884, 3, 1276, 638, 0, 12883, 12880, 1, 0, 0, 0, 12883, 12881, 1, 0, 0, 0, 12884, 12886, 1, 0, 0, 0, 12885, 12877, 1, 0, 0, 0, 12886, 12889, 1, 0, 0, 0, 12887, 12885, 1, 0, 0, 0, 12887, 12888, 1, 0, 0, 0, 12888, 12891, 1, 0, 0, 0, 12889, 12887, 1, 0, 0, 0, 12890, 12850, 1, 0, 0, 0, 12890, 12869, 1, 0, 0, 0, 12891, 1279, 1, 0, 0, 0, 12892, 12893, 5, 649, 0, 0, 12893, 12894, 3, 1276, 638, 0, 12894, 12895, 5, 2447, 0, 0, 12895, 12898, 3, 2340, 1170, 0, 12896, 12897, 5, 1137, 0, 0, 12897, 12899, 5, 888, 0, 0, 12898, 12896, 1, 0, 0, 0, 12898, 12899, 1, 0, 0, 0, 12899, 12908, 1, 0, 0, 0, 12900, 12901, 5, 2453, 0, 0, 12901, 12904, 3, 2340, 1170, 0, 12902, 12903, 5, 1137, 0, 0, 12903, 12905, 5, 888, 0, 0, 12904, 12902, 1, 0, 0, 0, 12904, 12905, 1, 0, 0, 0, 12905, 12907, 1, 0, 0, 0, 12906, 12900, 1, 0, 0, 0, 12907, 12910, 1, 0, 0, 0, 12908, 12906, 1, 0, 0, 0, 12908, 12909, 1, 0, 0, 0, 12909, 12911, 1, 0, 0, 0, 12910, 12908, 1, 0, 0, 0, 12911, 12913, 5, 2448, 0, 0, 12912, 12914, 5, 44, 0, 0, 12913, 12912, 1, 0, 0, 0, 12913, 12914, 1, 0, 0, 0, 12914, 1281, 1, 0, 0, 0, 12915, 12916, 5, 351, 0, 0, 12916, 12931, 5, 2447, 0, 0, 12917, 12919, 5, 2453, 0, 0, 12918, 12917, 1, 0, 0, 0, 12918, 12919, 1, 0, 0, 0, 12919, 12929, 1, 0, 0, 0, 12920, 12930, 5, 38, 0, 0, 12921, 12922, 5, 1451, 0, 0, 12922, 12930, 5, 816, 0, 0, 12923, 12925, 5, 2183, 0, 0, 12924, 12926, 5, 717, 0, 0, 12925, 12924, 1, 0, 0, 0, 12925, 12926, 1, 0, 0, 0, 12926, 12930, 1, 0, 0, 0, 12927, 12928, 5, 618, 0, 0, 12928, 12930, 5, 816, 0, 0, 12929, 12920, 1, 0, 0, 0, 12929, 12921, 1, 0, 0, 0, 12929, 12923, 1, 0, 0, 0, 12929, 12927, 1, 0, 0, 0, 12930, 12932, 1, 0, 0, 0, 12931, 12918, 1, 0, 0, 0, 12932, 12933, 1, 0, 0, 0, 12933, 12931, 1, 0, 0, 0, 12933, 12934, 1, 0, 0, 0, 12934, 12935, 1, 0, 0, 0, 12935, 12936, 5, 2448, 0, 0, 12936, 12937, 5, 238, 0, 0, 12937, 1283, 1, 0, 0, 0, 12938, 12939, 5, 39, 0, 0, 12939, 12952, 5, 558, 0, 0, 12940, 12947, 5, 2447, 0, 0, 12941, 12942, 5, 1699, 0, 0, 12942, 12948, 3, 1176, 588, 0, 12943, 12944, 5, 352, 0, 0, 12944, 12948, 5, 2443, 0, 0, 12945, 12946, 5, 759, 0, 0, 12946, 12948, 5, 2441, 0, 0, 12947, 12941, 1, 0, 0, 0, 12947, 12943, 1, 0, 0, 0, 12947, 12945, 1, 0, 0, 0, 12948, 12949, 1, 0, 0, 0, 12949, 12947, 1, 0, 0, 0, 12949, 12950, 1, 0, 0, 0, 12950, 12951, 1, 0, 0, 0, 12951, 12953, 5, 2448, 0, 0, 12952, 12940, 1, 0, 0, 0, 12952, 12953, 1, 0, 0, 0, 12953, 1285, 1, 0, 0, 0, 12954, 12955, 5, 377, 0, 0, 12955, 12958, 5, 2204, 0, 0, 12956, 12957, 5, 814, 0, 0, 12957, 12959, 3, 1176, 588, 0, 12958, 12956, 1, 0, 0, 0, 12958, 12959, 1, 0, 0, 0, 12959, 1287, 1, 0, 0, 0, 12960, 12961, 5, 1684, 0, 0, 12961, 12963, 5, 1714, 0, 0, 12962, 12964, 5, 246, 0, 0, 12963, 12962, 1, 0, 0, 0, 12963, 12964, 1, 0, 0, 0, 12964, 12966, 1, 0, 0, 0, 12965, 12967, 5, 179, 0, 0, 12966, 12965, 1, 0, 0, 0, 12966, 12967, 1, 0, 0, 0, 12967, 12969, 1, 0, 0, 0, 12968, 12970, 5, 200, 0, 0, 12969, 12968, 1, 0, 0, 0, 12969, 12970, 1, 0, 0, 0, 12970, 1289, 1, 0, 0, 0, 12971, 12973, 7, 162, 0, 0, 12972, 12971, 1, 0, 0, 0, 12972, 12973, 1, 0, 0, 0, 12973, 12974, 1, 0, 0, 0, 12974, 12975, 5, 1514, 0, 0, 12975, 1291, 1, 0, 0, 0, 12976, 12978, 5, 2211, 0, 0, 12977, 12979, 5, 1204, 0, 0, 12978, 12977, 1, 0, 0, 0, 12978, 12979, 1, 0, 0, 0, 12979, 12980, 1, 0, 0, 0, 12980, 12981, 5, 705, 0, 0, 12981, 12982, 5, 351, 0, 0, 12982, 12983, 1, 0, 0, 0, 12983, 12984, 3, 1660, 830, 0, 12984, 1293, 1, 0, 0, 0, 12985, 12986, 5, 2159, 0, 0, 12986, 12987, 5, 2083, 0, 0, 12987, 12994, 3, 2342, 1171, 0, 12988, 12992, 7, 163, 0, 0, 12989, 12990, 5, 919, 0, 0, 12990, 12991, 5, 2286, 0, 0, 12991, 12993, 5, 888, 0, 0, 12992, 12989, 1, 0, 0, 0, 12992, 12993, 1, 0, 0, 0, 12993, 12995, 1, 0, 0, 0, 12994, 12988, 1, 0, 0, 0, 12994, 12995, 1, 0, 0, 0, 12995, 13004, 1, 0, 0, 0, 12996, 12998, 5, 469, 0, 0, 12997, 12999, 5, 38, 0, 0, 12998, 12997, 1, 0, 0, 0, 12998, 12999, 1, 0, 0, 0, 12999, 13002, 1, 0, 0, 0, 13000, 13002, 5, 1587, 0, 0, 13001, 12996, 1, 0, 0, 0, 13001, 13000, 1, 0, 0, 0, 13002, 13003, 1, 0, 0, 0, 13003, 13005, 5, 1762, 0, 0, 13004, 13001, 1, 0, 0, 0, 13004, 13005, 1, 0, 0, 0, 13005, 13007, 1, 0, 0, 0, 13006, 13008, 5, 179, 0, 0, 13007, 13006, 1, 0, 0, 0, 13007, 13008, 1, 0, 0, 0, 13008, 1295, 1, 0, 0, 0, 13009, 13010, 5, 469, 0, 0, 13010, 13011, 5, 2083, 0, 0, 13011, 13014, 3, 2342, 1171, 0, 13012, 13013, 5, 691, 0, 0, 13013, 13015, 5, 545, 0, 0, 13014, 13012, 1, 0, 0, 0, 13014, 13015, 1, 0, 0, 0, 13015, 13018, 1, 0, 0, 0, 13016, 13017, 5, 69, 0, 0, 13017, 13019, 3, 2342, 1171, 0, 13018, 13016, 1, 0, 0, 0, 13018, 13019, 1, 0, 0, 0, 13019, 13022, 1, 0, 0, 0, 13020, 13021, 5, 179, 0, 0, 13021, 13023, 7, 95, 0, 0, 13022, 13020, 1, 0, 0, 0, 13022, 13023, 1, 0, 0, 0, 13023, 13025, 1, 0, 0, 0, 13024, 13026, 5, 1475, 0, 0, 13025, 13024, 1, 0, 0, 0, 13025, 13026, 1, 0, 0, 0, 13026, 13029, 1, 0, 0, 0, 13027, 13028, 5, 69, 0, 0, 13028, 13030, 3, 2270, 1135, 0, 13029, 13027, 1, 0, 0, 0, 13029, 13030, 1, 0, 0, 0, 13030, 13032, 1, 0, 0, 0, 13031, 13033, 5, 616, 0, 0, 13032, 13031, 1, 0, 0, 0, 13032, 13033, 1, 0, 0, 0, 13033, 1297, 1, 0, 0, 0, 13034, 13035, 5, 469, 0, 0, 13035, 13036, 5, 2080, 0, 0, 13036, 13039, 3, 2404, 1202, 0, 13037, 13038, 5, 691, 0, 0, 13038, 13040, 5, 545, 0, 0, 13039, 13037, 1, 0, 0, 0, 13039, 13040, 1, 0, 0, 0, 13040, 13045, 1, 0, 0, 0, 13041, 13043, 7, 164, 0, 0, 13042, 13044, 5, 1490, 0, 0, 13043, 13042, 1, 0, 0, 0, 13043, 13044, 1, 0, 0, 0, 13044, 13046, 1, 0, 0, 0, 13045, 13041, 1, 0, 0, 0, 13045, 13046, 1, 0, 0, 0, 13046, 13048, 1, 0, 0, 0, 13047, 13049, 3, 1302, 651, 0, 13048, 13047, 1, 0, 0, 0, 13048, 13049, 1, 0, 0, 0, 13049, 1299, 1, 0, 0, 0, 13050, 13051, 5, 469, 0, 0, 13051, 13052, 5, 2080, 0, 0, 13052, 13053, 5, 1671, 0, 0, 13053, 13055, 3, 2404, 1202, 0, 13054, 13056, 3, 1302, 651, 0, 13055, 13054, 1, 0, 0, 0, 13055, 13056, 1, 0, 0, 0, 13056, 1301, 1, 0, 0, 0, 13057, 13058, 5, 705, 0, 0, 13058, 13061, 5, 295, 0, 0, 13059, 13060, 7, 165, 0, 0, 13060, 13062, 5, 353, 0, 0, 13061, 13059, 1, 0, 0, 0, 13061, 13062, 1, 0, 0, 0, 13062, 13065, 1, 0, 0, 0, 13063, 13064, 5, 179, 0, 0, 13064, 13066, 5, 287, 0, 0, 13065, 13063, 1, 0, 0, 0, 13065, 13066, 1, 0, 0, 0, 13066, 1303, 1, 0, 0, 0, 13067, 13068, 5, 469, 0, 0, 13068, 13069, 5, 2286, 0, 0, 13069, 13072, 3, 2342, 1171, 0, 13070, 13071, 5, 691, 0, 0, 13071, 13073, 5, 545, 0, 0, 13072, 13070, 1, 0, 0, 0, 13072, 13073, 1, 0, 0, 0, 13073, 13076, 1, 0, 0, 0, 13074, 13075, 5, 179, 0, 0, 13075, 13077, 5, 286, 0, 0, 13076, 13074, 1, 0, 0, 0, 13076, 13077, 1, 0, 0, 0, 13077, 1305, 1, 0, 0, 0, 13078, 13079, 5, 241, 0, 0, 13079, 13080, 5, 1259, 0, 0, 13080, 13081, 5, 237, 0, 0, 13081, 13082, 3, 2340, 1170, 0, 13082, 13083, 5, 785, 0, 0, 13083, 13084, 3, 2400, 1200, 0, 13084, 1307, 1, 0, 0, 0, 13085, 13086, 7, 17, 0, 0, 13086, 1309, 1, 0, 0, 0, 13087, 13088, 7, 166, 0, 0, 13088, 1311, 1, 0, 0, 0, 13089, 13091, 5, 42, 0, 0, 13090, 13092, 5, 1473, 0, 0, 13091, 13090, 1, 0, 0, 0, 13091, 13092, 1, 0, 0, 0, 13092, 13093, 1, 0, 0, 0, 13093, 13097, 5, 1796, 0, 0, 13094, 13095, 3, 2286, 1143, 0, 13095, 13096, 5, 2440, 0, 0, 13096, 13098, 1, 0, 0, 0, 13097, 13094, 1, 0, 0, 0, 13097, 13098, 1, 0, 0, 0, 13098, 13099, 1, 0, 0, 0, 13099, 13100, 3, 2348, 1174, 0, 13100, 13101, 7, 167, 0, 0, 13101, 1313, 1, 0, 0, 0, 13102, 13105, 5, 321, 0, 0, 13103, 13104, 5, 1307, 0, 0, 13104, 13106, 5, 1562, 0, 0, 13105, 13103, 1, 0, 0, 0, 13105, 13106, 1, 0, 0, 0, 13106, 13107, 1, 0, 0, 0, 13107, 13108, 5, 1473, 0, 0, 13108, 13109, 5, 1796, 0, 0, 13109, 13110, 3, 2348, 1174, 0, 13110, 13114, 5, 620, 0, 0, 13111, 13112, 3, 2286, 1143, 0, 13112, 13113, 5, 2440, 0, 0, 13113, 13115, 1, 0, 0, 0, 13114, 13111, 1, 0, 0, 0, 13114, 13115, 1, 0, 0, 0, 13115, 13116, 1, 0, 0, 0, 13116, 13119, 3, 2350, 1175, 0, 13117, 13118, 5, 2456, 0, 0, 13118, 13120, 3, 2334, 1167, 0, 13119, 13117, 1, 0, 0, 0, 13119, 13120, 1, 0, 0, 0, 13120, 13150, 1, 0, 0, 0, 13121, 13124, 5, 321, 0, 0, 13122, 13123, 5, 1307, 0, 0, 13123, 13125, 5, 1562, 0, 0, 13124, 13122, 1, 0, 0, 0, 13124, 13125, 1, 0, 0, 0, 13125, 13126, 1, 0, 0, 0, 13126, 13130, 5, 1796, 0, 0, 13127, 13128, 3, 2286, 1143, 0, 13128, 13129, 5, 2440, 0, 0, 13129, 13131, 1, 0, 0, 0, 13130, 13127, 1, 0, 0, 0, 13130, 13131, 1, 0, 0, 0, 13131, 13132, 1, 0, 0, 0, 13132, 13133, 3, 2348, 1174, 0, 13133, 13137, 5, 620, 0, 0, 13134, 13135, 3, 2286, 1143, 0, 13135, 13136, 5, 2440, 0, 0, 13136, 13138, 1, 0, 0, 0, 13137, 13134, 1, 0, 0, 0, 13137, 13138, 1, 0, 0, 0, 13138, 13139, 1, 0, 0, 0, 13139, 13147, 3, 2350, 1175, 0, 13140, 13144, 5, 2456, 0, 0, 13141, 13142, 3, 2286, 1143, 0, 13142, 13143, 5, 2440, 0, 0, 13143, 13145, 1, 0, 0, 0, 13144, 13141, 1, 0, 0, 0, 13144, 13145, 1, 0, 0, 0, 13145, 13146, 1, 0, 0, 0, 13146, 13148, 3, 2334, 1167, 0, 13147, 13140, 1, 0, 0, 0, 13147, 13148, 1, 0, 0, 0, 13148, 13150, 1, 0, 0, 0, 13149, 13102, 1, 0, 0, 0, 13149, 13121, 1, 0, 0, 0, 13150, 1315, 1, 0, 0, 0, 13151, 13153, 5, 469, 0, 0, 13152, 13154, 5, 1473, 0, 0, 13153, 13152, 1, 0, 0, 0, 13153, 13154, 1, 0, 0, 0, 13154, 13155, 1, 0, 0, 0, 13155, 13159, 5, 1796, 0, 0, 13156, 13157, 3, 2286, 1143, 0, 13157, 13158, 5, 2440, 0, 0, 13158, 13160, 1, 0, 0, 0, 13159, 13156, 1, 0, 0, 0, 13159, 13160, 1, 0, 0, 0, 13160, 13161, 1, 0, 0, 0, 13161, 13163, 3, 2348, 1174, 0, 13162, 13164, 5, 616, 0, 0, 13163, 13162, 1, 0, 0, 0, 13163, 13164, 1, 0, 0, 0, 13164, 1317, 1, 0, 0, 0, 13165, 13166, 5, 321, 0, 0, 13166, 13169, 5, 1716, 0, 0, 13167, 13168, 5, 2472, 0, 0, 13168, 13170, 3, 1320, 660, 0, 13169, 13167, 1, 0, 0, 0, 13169, 13170, 1, 0, 0, 0, 13170, 13171, 1, 0, 0, 0, 13171, 13182, 5, 628, 0, 0, 13172, 13175, 5, 1391, 0, 0, 13173, 13174, 5, 2472, 0, 0, 13174, 13176, 3, 1322, 661, 0, 13175, 13173, 1, 0, 0, 0, 13175, 13176, 1, 0, 0, 0, 13176, 13179, 1, 0, 0, 0, 13177, 13178, 5, 69, 0, 0, 13178, 13180, 5, 303, 0, 0, 13179, 13177, 1, 0, 0, 0, 13179, 13180, 1, 0, 0, 0, 13180, 13183, 1, 0, 0, 0, 13181, 13183, 5, 942, 0, 0, 13182, 13172, 1, 0, 0, 0, 13182, 13181, 1, 0, 0, 0, 13183, 1319, 1, 0, 0, 0, 13184, 13185, 5, 2443, 0, 0, 13185, 1321, 1, 0, 0, 0, 13186, 13187, 5, 2443, 0, 0, 13187, 1323, 1, 0, 0, 0, 13188, 13189, 5, 241, 0, 0, 13189, 13190, 5, 1259, 0, 0, 13190, 13191, 5, 2083, 0, 0, 13191, 13192, 3, 2342, 1171, 0, 13192, 13193, 5, 785, 0, 0, 13193, 13194, 3, 2400, 1200, 0, 13194, 1325, 1, 0, 0, 0, 13195, 13196, 5, 241, 0, 0, 13196, 13197, 5, 1259, 0, 0, 13197, 13198, 5, 919, 0, 0, 13198, 13199, 5, 2286, 0, 0, 13199, 13200, 3, 2342, 1171, 0, 13200, 13201, 5, 785, 0, 0, 13201, 13202, 3, 2400, 1200, 0, 13202, 1327, 1, 0, 0, 0, 13203, 13204, 5, 42, 0, 0, 13204, 13205, 5, 45, 0, 0, 13205, 13209, 5, 2286, 0, 0, 13206, 13207, 3, 2286, 1143, 0, 13207, 13208, 5, 2440, 0, 0, 13208, 13210, 1, 0, 0, 0, 13209, 13206, 1, 0, 0, 0, 13209, 13210, 1, 0, 0, 0, 13210, 13211, 1, 0, 0, 0, 13211, 13218, 3, 2404, 1202, 0, 13212, 13213, 5, 1559, 0, 0, 13213, 13214, 5, 2141, 0, 0, 13214, 13219, 3, 2404, 1202, 0, 13215, 13219, 5, 249, 0, 0, 13216, 13219, 3, 1330, 665, 0, 13217, 13219, 3, 1336, 668, 0, 13218, 13212, 1, 0, 0, 0, 13218, 13215, 1, 0, 0, 0, 13218, 13216, 1, 0, 0, 0, 13218, 13217, 1, 0, 0, 0, 13219, 1329, 1, 0, 0, 0, 13220, 13221, 5, 21, 0, 0, 13221, 13222, 5, 166, 0, 0, 13222, 13223, 5, 933, 0, 0, 13223, 13224, 5, 649, 0, 0, 13224, 13227, 5, 2447, 0, 0, 13225, 13228, 5, 38, 0, 0, 13226, 13228, 3, 1334, 667, 0, 13227, 13225, 1, 0, 0, 0, 13227, 13226, 1, 0, 0, 0, 13227, 13228, 1, 0, 0, 0, 13228, 13229, 1, 0, 0, 0, 13229, 13230, 5, 2448, 0, 0, 13230, 13231, 5, 848, 0, 0, 13231, 13232, 5, 2447, 0, 0, 13232, 13237, 3, 1332, 666, 0, 13233, 13234, 5, 2453, 0, 0, 13234, 13236, 3, 1332, 666, 0, 13235, 13233, 1, 0, 0, 0, 13236, 13239, 1, 0, 0, 0, 13237, 13235, 1, 0, 0, 0, 13237, 13238, 1, 0, 0, 0, 13238, 13240, 1, 0, 0, 0, 13239, 13237, 1, 0, 0, 0, 13240, 13241, 5, 2448, 0, 0, 13241, 1331, 1, 0, 0, 0, 13242, 13243, 3, 2404, 1202, 0, 13243, 13244, 5, 2440, 0, 0, 13244, 13246, 1, 0, 0, 0, 13245, 13242, 1, 0, 0, 0, 13245, 13246, 1, 0, 0, 0, 13246, 13247, 1, 0, 0, 0, 13247, 13248, 3, 2404, 1202, 0, 13248, 13249, 5, 2440, 0, 0, 13249, 13251, 1, 0, 0, 0, 13250, 13245, 1, 0, 0, 0, 13250, 13251, 1, 0, 0, 0, 13251, 13252, 1, 0, 0, 0, 13252, 13253, 3, 2404, 1202, 0, 13253, 1333, 1, 0, 0, 0, 13254, 13259, 3, 2404, 1202, 0, 13255, 13256, 5, 2453, 0, 0, 13256, 13258, 3, 2404, 1202, 0, 13257, 13255, 1, 0, 0, 0, 13258, 13261, 1, 0, 0, 0, 13259, 13257, 1, 0, 0, 0, 13259, 13260, 1, 0, 0, 0, 13260, 1335, 1, 0, 0, 0, 13261, 13259, 1, 0, 0, 0, 13262, 13263, 5, 469, 0, 0, 13263, 13264, 5, 166, 0, 0, 13264, 13265, 5, 933, 0, 0, 13265, 13266, 5, 649, 0, 0, 13266, 13269, 5, 2447, 0, 0, 13267, 13270, 5, 38, 0, 0, 13268, 13270, 3, 1334, 667, 0, 13269, 13267, 1, 0, 0, 0, 13269, 13268, 1, 0, 0, 0, 13269, 13270, 1, 0, 0, 0, 13270, 13271, 1, 0, 0, 0, 13271, 13272, 5, 2448, 0, 0, 13272, 13273, 5, 848, 0, 0, 13273, 13274, 5, 2447, 0, 0, 13274, 13279, 3, 1332, 666, 0, 13275, 13276, 5, 2453, 0, 0, 13276, 13278, 3, 1332, 666, 0, 13277, 13275, 1, 0, 0, 0, 13278, 13281, 1, 0, 0, 0, 13279, 13277, 1, 0, 0, 0, 13279, 13280, 1, 0, 0, 0, 13280, 13282, 1, 0, 0, 0, 13281, 13279, 1, 0, 0, 0, 13282, 13283, 5, 2448, 0, 0, 13283, 1337, 1, 0, 0, 0, 13284, 13285, 5, 42, 0, 0, 13285, 13286, 5, 83, 0, 0, 13286, 13290, 5, 422, 0, 0, 13287, 13288, 3, 2286, 1143, 0, 13288, 13289, 5, 2440, 0, 0, 13289, 13291, 1, 0, 0, 0, 13290, 13287, 1, 0, 0, 0, 13290, 13291, 1, 0, 0, 0, 13291, 13292, 1, 0, 0, 0, 13292, 13297, 3, 2404, 1202, 0, 13293, 13294, 5, 1559, 0, 0, 13294, 13295, 5, 2141, 0, 0, 13295, 13298, 3, 2404, 1202, 0, 13296, 13298, 5, 249, 0, 0, 13297, 13293, 1, 0, 0, 0, 13297, 13296, 1, 0, 0, 0, 13298, 1339, 1, 0, 0, 0, 13299, 13300, 5, 42, 0, 0, 13300, 13301, 5, 85, 0, 0, 13301, 13302, 5, 1412, 0, 0, 13302, 13304, 3, 2404, 1202, 0, 13303, 13305, 5, 21, 0, 0, 13304, 13303, 1, 0, 0, 0, 13304, 13305, 1, 0, 0, 0, 13305, 13319, 1, 0, 0, 0, 13306, 13308, 3, 408, 204, 0, 13307, 13306, 1, 0, 0, 0, 13307, 13308, 1, 0, 0, 0, 13308, 13310, 1, 0, 0, 0, 13309, 13311, 3, 410, 205, 0, 13310, 13309, 1, 0, 0, 0, 13310, 13311, 1, 0, 0, 0, 13311, 13313, 1, 0, 0, 0, 13312, 13314, 3, 426, 213, 0, 13313, 13312, 1, 0, 0, 0, 13313, 13314, 1, 0, 0, 0, 13314, 13320, 1, 0, 0, 0, 13315, 13316, 5, 1258, 0, 0, 13316, 13318, 5, 2135, 0, 0, 13317, 13315, 1, 0, 0, 0, 13317, 13318, 1, 0, 0, 0, 13318, 13320, 1, 0, 0, 0, 13319, 13307, 1, 0, 0, 0, 13319, 13317, 1, 0, 0, 0, 13320, 13322, 1, 0, 0, 0, 13321, 13323, 5, 469, 0, 0, 13322, 13321, 1, 0, 0, 0, 13322, 13323, 1, 0, 0, 0, 13323, 13337, 1, 0, 0, 0, 13324, 13326, 3, 408, 204, 0, 13325, 13324, 1, 0, 0, 0, 13325, 13326, 1, 0, 0, 0, 13326, 13328, 1, 0, 0, 0, 13327, 13329, 3, 410, 205, 0, 13328, 13327, 1, 0, 0, 0, 13328, 13329, 1, 0, 0, 0, 13329, 13331, 1, 0, 0, 0, 13330, 13332, 3, 426, 213, 0, 13331, 13330, 1, 0, 0, 0, 13331, 13332, 1, 0, 0, 0, 13332, 13338, 1, 0, 0, 0, 13333, 13334, 5, 1258, 0, 0, 13334, 13336, 5, 2135, 0, 0, 13335, 13333, 1, 0, 0, 0, 13335, 13336, 1, 0, 0, 0, 13336, 13338, 1, 0, 0, 0, 13337, 13325, 1, 0, 0, 0, 13337, 13335, 1, 0, 0, 0, 13338, 13347, 1, 0, 0, 0, 13339, 13345, 5, 266, 0, 0, 13340, 13346, 5, 469, 0, 0, 13341, 13342, 5, 2443, 0, 0, 13342, 13343, 5, 530, 0, 0, 13343, 13344, 5, 1390, 0, 0, 13344, 13346, 7, 57, 0, 0, 13345, 13340, 1, 0, 0, 0, 13345, 13341, 1, 0, 0, 0, 13346, 13348, 1, 0, 0, 0, 13347, 13339, 1, 0, 0, 0, 13347, 13348, 1, 0, 0, 0, 13348, 1341, 1, 0, 0, 0, 13349, 13350, 5, 42, 0, 0, 13350, 13351, 5, 220, 0, 0, 13351, 13358, 3, 466, 233, 0, 13352, 13359, 3, 1194, 597, 0, 13353, 13354, 5, 1699, 0, 0, 13354, 13359, 3, 1176, 588, 0, 13355, 13359, 3, 1284, 642, 0, 13356, 13359, 3, 1286, 643, 0, 13357, 13359, 3, 1364, 682, 0, 13358, 13352, 1, 0, 0, 0, 13358, 13353, 1, 0, 0, 0, 13358, 13355, 1, 0, 0, 0, 13358, 13356, 1, 0, 0, 0, 13358, 13357, 1, 0, 0, 0, 13359, 13360, 1, 0, 0, 0, 13360, 13358, 1, 0, 0, 0, 13360, 13361, 1, 0, 0, 0, 13361, 13363, 1, 0, 0, 0, 13362, 13364, 3, 928, 464, 0, 13363, 13362, 1, 0, 0, 0, 13363, 13364, 1, 0, 0, 0, 13364, 1343, 1, 0, 0, 0, 13365, 13366, 5, 469, 0, 0, 13366, 13367, 5, 45, 0, 0, 13367, 13371, 5, 2286, 0, 0, 13368, 13369, 3, 2286, 1143, 0, 13369, 13370, 5, 2440, 0, 0, 13370, 13372, 1, 0, 0, 0, 13371, 13368, 1, 0, 0, 0, 13371, 13372, 1, 0, 0, 0, 13372, 13373, 1, 0, 0, 0, 13373, 13374, 3, 2404, 1202, 0, 13374, 1345, 1, 0, 0, 0, 13375, 13376, 5, 469, 0, 0, 13376, 13377, 5, 83, 0, 0, 13377, 13381, 5, 422, 0, 0, 13378, 13379, 3, 2286, 1143, 0, 13379, 13380, 5, 2440, 0, 0, 13380, 13382, 1, 0, 0, 0, 13381, 13378, 1, 0, 0, 0, 13381, 13382, 1, 0, 0, 0, 13382, 13383, 1, 0, 0, 0, 13383, 13384, 3, 2404, 1202, 0, 13384, 1347, 1, 0, 0, 0, 13385, 13386, 5, 469, 0, 0, 13386, 13387, 5, 85, 0, 0, 13387, 13388, 5, 1412, 0, 0, 13388, 13389, 3, 2404, 1202, 0, 13389, 1349, 1, 0, 0, 0, 13390, 13391, 5, 469, 0, 0, 13391, 13392, 5, 605, 0, 0, 13392, 13393, 5, 64, 0, 0, 13393, 13394, 3, 2404, 1202, 0, 13394, 1351, 1, 0, 0, 0, 13395, 13396, 5, 469, 0, 0, 13396, 13397, 5, 220, 0, 0, 13397, 13404, 3, 466, 233, 0, 13398, 13399, 5, 705, 0, 0, 13399, 13402, 5, 2081, 0, 0, 13400, 13401, 5, 179, 0, 0, 13401, 13403, 5, 287, 0, 0, 13402, 13400, 1, 0, 0, 0, 13402, 13403, 1, 0, 0, 0, 13403, 13405, 1, 0, 0, 0, 13404, 13398, 1, 0, 0, 0, 13404, 13405, 1, 0, 0, 0, 13405, 1353, 1, 0, 0, 0, 13406, 13407, 5, 469, 0, 0, 13407, 13408, 5, 296, 0, 0, 13408, 13409, 3, 2404, 1202, 0, 13409, 1355, 1, 0, 0, 0, 13410, 13411, 5, 469, 0, 0, 13411, 13412, 5, 426, 0, 0, 13412, 13413, 3, 2404, 1202, 0, 13413, 1357, 1, 0, 0, 0, 13414, 13415, 5, 469, 0, 0, 13415, 13416, 5, 441, 0, 0, 13416, 13425, 3, 2404, 1202, 0, 13417, 13419, 5, 616, 0, 0, 13418, 13417, 1, 0, 0, 0, 13418, 13419, 1, 0, 0, 0, 13419, 13420, 1, 0, 0, 0, 13420, 13423, 5, 705, 0, 0, 13421, 13423, 5, 540, 0, 0, 13422, 13418, 1, 0, 0, 0, 13422, 13421, 1, 0, 0, 0, 13423, 13424, 1, 0, 0, 0, 13424, 13426, 5, 295, 0, 0, 13425, 13422, 1, 0, 0, 0, 13425, 13426, 1, 0, 0, 0, 13426, 1359, 1, 0, 0, 0, 13427, 13428, 5, 469, 0, 0, 13428, 13429, 5, 483, 0, 0, 13429, 13431, 3, 2404, 1202, 0, 13430, 13432, 5, 179, 0, 0, 13431, 13430, 1, 0, 0, 0, 13431, 13432, 1, 0, 0, 0, 13432, 1361, 1, 0, 0, 0, 13433, 13434, 5, 2159, 0, 0, 13434, 13435, 5, 220, 0, 0, 13435, 13438, 3, 466, 233, 0, 13436, 13437, 7, 168, 0, 0, 13437, 13439, 5, 1762, 0, 0, 13438, 13436, 1, 0, 0, 0, 13438, 13439, 1, 0, 0, 0, 13439, 1363, 1, 0, 0, 0, 13440, 13441, 7, 109, 0, 0, 13441, 1365, 1, 0, 0, 0, 13442, 13443, 3, 2404, 1202, 0, 13443, 1367, 1, 0, 0, 0, 13444, 13445, 5, 42, 0, 0, 13445, 13461, 3, 1370, 685, 0, 13446, 13462, 3, 1372, 686, 0, 13447, 13462, 3, 1378, 689, 0, 13448, 13462, 3, 1394, 697, 0, 13449, 13462, 3, 1404, 702, 0, 13450, 13462, 3, 1422, 711, 0, 13451, 13462, 3, 1426, 713, 0, 13452, 13462, 3, 1442, 721, 0, 13453, 13462, 3, 1446, 723, 0, 13454, 13462, 3, 1448, 724, 0, 13455, 13462, 3, 1460, 730, 0, 13456, 13462, 3, 1462, 731, 0, 13457, 13462, 3, 1464, 732, 0, 13458, 13462, 3, 1466, 733, 0, 13459, 13462, 3, 1472, 736, 0, 13460, 13462, 3, 1474, 737, 0, 13461, 13446, 1, 0, 0, 0, 13461, 13447, 1, 0, 0, 0, 13461, 13448, 1, 0, 0, 0, 13461, 13449, 1, 0, 0, 0, 13461, 13450, 1, 0, 0, 0, 13461, 13451, 1, 0, 0, 0, 13461, 13452, 1, 0, 0, 0, 13461, 13453, 1, 0, 0, 0, 13461, 13454, 1, 0, 0, 0, 13461, 13455, 1, 0, 0, 0, 13461, 13456, 1, 0, 0, 0, 13461, 13457, 1, 0, 0, 0, 13461, 13458, 1, 0, 0, 0, 13461, 13459, 1, 0, 0, 0, 13461, 13460, 1, 0, 0, 0, 13462, 1369, 1, 0, 0, 0, 13463, 13465, 5, 1409, 0, 0, 13464, 13463, 1, 0, 0, 0, 13464, 13465, 1, 0, 0, 0, 13465, 13466, 1, 0, 0, 0, 13466, 13468, 5, 350, 0, 0, 13467, 13469, 3, 1366, 683, 0, 13468, 13467, 1, 0, 0, 0, 13468, 13469, 1, 0, 0, 0, 13469, 1371, 1, 0, 0, 0, 13470, 13473, 5, 988, 0, 0, 13471, 13472, 7, 169, 0, 0, 13472, 13474, 5, 350, 0, 0, 13473, 13471, 1, 0, 0, 0, 13473, 13474, 1, 0, 0, 0, 13474, 13490, 1, 0, 0, 0, 13475, 13478, 5, 1264, 0, 0, 13476, 13477, 5, 1505, 0, 0, 13477, 13479, 5, 2313, 0, 0, 13478, 13476, 1, 0, 0, 0, 13478, 13479, 1, 0, 0, 0, 13479, 13481, 1, 0, 0, 0, 13480, 13482, 3, 1374, 687, 0, 13481, 13480, 1, 0, 0, 0, 13481, 13482, 1, 0, 0, 0, 13482, 13484, 1, 0, 0, 0, 13483, 13485, 3, 1376, 688, 0, 13484, 13483, 1, 0, 0, 0, 13484, 13485, 1, 0, 0, 0, 13485, 13490, 1, 0, 0, 0, 13486, 13487, 5, 1264, 0, 0, 13487, 13488, 5, 1505, 0, 0, 13488, 13490, 5, 1258, 0, 0, 13489, 13470, 1, 0, 0, 0, 13489, 13475, 1, 0, 0, 0, 13489, 13486, 1, 0, 0, 0, 13490, 1373, 1, 0, 0, 0, 13491, 13492, 7, 63, 0, 0, 13492, 1375, 1, 0, 0, 0, 13493, 13494, 7, 170, 0, 0, 13494, 1377, 1, 0, 0, 0, 13495, 13501, 3, 1382, 691, 0, 13496, 13501, 3, 1390, 695, 0, 13497, 13498, 3, 1380, 690, 0, 13498, 13499, 5, 102, 0, 0, 13499, 13501, 1, 0, 0, 0, 13500, 13495, 1, 0, 0, 0, 13500, 13496, 1, 0, 0, 0, 13500, 13497, 1, 0, 0, 0, 13501, 1379, 1, 0, 0, 0, 13502, 13503, 7, 171, 0, 0, 13503, 1381, 1, 0, 0, 0, 13504, 13506, 5, 1516, 0, 0, 13505, 13507, 5, 95, 0, 0, 13506, 13505, 1, 0, 0, 0, 13506, 13507, 1, 0, 0, 0, 13507, 13510, 1, 0, 0, 0, 13508, 13509, 5, 628, 0, 0, 13509, 13511, 5, 2443, 0, 0, 13510, 13508, 1, 0, 0, 0, 13510, 13511, 1, 0, 0, 0, 13511, 13534, 1, 0, 0, 0, 13512, 13517, 3, 1384, 692, 0, 13513, 13517, 3, 1386, 693, 0, 13514, 13515, 5, 882, 0, 0, 13515, 13517, 5, 2443, 0, 0, 13516, 13512, 1, 0, 0, 0, 13516, 13513, 1, 0, 0, 0, 13516, 13514, 1, 0, 0, 0, 13516, 13517, 1, 0, 0, 0, 13517, 13527, 1, 0, 0, 0, 13518, 13524, 5, 2095, 0, 0, 13519, 13520, 5, 40, 0, 0, 13520, 13521, 5, 2441, 0, 0, 13521, 13524, 5, 306, 0, 0, 13522, 13524, 3, 928, 464, 0, 13523, 13518, 1, 0, 0, 0, 13523, 13519, 1, 0, 0, 0, 13523, 13522, 1, 0, 0, 0, 13524, 13525, 1, 0, 0, 0, 13525, 13523, 1, 0, 0, 0, 13525, 13526, 1, 0, 0, 0, 13526, 13528, 1, 0, 0, 0, 13527, 13523, 1, 0, 0, 0, 13527, 13528, 1, 0, 0, 0, 13528, 13535, 1, 0, 0, 0, 13529, 13531, 5, 297, 0, 0, 13530, 13532, 5, 389, 0, 0, 13531, 13530, 1, 0, 0, 0, 13531, 13532, 1, 0, 0, 0, 13532, 13535, 1, 0, 0, 0, 13533, 13535, 5, 174, 0, 0, 13534, 13516, 1, 0, 0, 0, 13534, 13529, 1, 0, 0, 0, 13534, 13533, 1, 0, 0, 0, 13535, 1383, 1, 0, 0, 0, 13536, 13538, 5, 1734, 0, 0, 13537, 13536, 1, 0, 0, 0, 13537, 13538, 1, 0, 0, 0, 13538, 13539, 1, 0, 0, 0, 13539, 13559, 5, 350, 0, 0, 13540, 13547, 5, 2202, 0, 0, 13541, 13548, 5, 174, 0, 0, 13542, 13543, 5, 2112, 0, 0, 13543, 13548, 5, 2443, 0, 0, 13544, 13545, 5, 190, 0, 0, 13545, 13548, 5, 2441, 0, 0, 13546, 13548, 5, 283, 0, 0, 13547, 13541, 1, 0, 0, 0, 13547, 13542, 1, 0, 0, 0, 13547, 13544, 1, 0, 0, 0, 13547, 13546, 1, 0, 0, 0, 13548, 13556, 1, 0, 0, 0, 13549, 13550, 5, 2246, 0, 0, 13550, 13551, 5, 102, 0, 0, 13551, 13556, 5, 298, 0, 0, 13552, 13553, 5, 1707, 0, 0, 13553, 13554, 5, 2112, 0, 0, 13554, 13556, 5, 2443, 0, 0, 13555, 13540, 1, 0, 0, 0, 13555, 13549, 1, 0, 0, 0, 13555, 13552, 1, 0, 0, 0, 13556, 13557, 1, 0, 0, 0, 13557, 13555, 1, 0, 0, 0, 13557, 13558, 1, 0, 0, 0, 13558, 13560, 1, 0, 0, 0, 13559, 13555, 1, 0, 0, 0, 13559, 13560, 1, 0, 0, 0, 13560, 1385, 1, 0, 0, 0, 13561, 13562, 5, 2080, 0, 0, 13562, 13567, 3, 1656, 828, 0, 13563, 13564, 5, 2453, 0, 0, 13564, 13566, 3, 1656, 828, 0, 13565, 13563, 1, 0, 0, 0, 13566, 13569, 1, 0, 0, 0, 13567, 13565, 1, 0, 0, 0, 13567, 13568, 1, 0, 0, 0, 13568, 13583, 1, 0, 0, 0, 13569, 13567, 1, 0, 0, 0, 13570, 13571, 5, 352, 0, 0, 13571, 13583, 5, 2443, 0, 0, 13572, 13578, 3, 1456, 728, 0, 13573, 13574, 5, 2453, 0, 0, 13574, 13577, 5, 2443, 0, 0, 13575, 13577, 3, 1456, 728, 0, 13576, 13573, 1, 0, 0, 0, 13576, 13575, 1, 0, 0, 0, 13577, 13580, 1, 0, 0, 0, 13578, 13576, 1, 0, 0, 0, 13578, 13579, 1, 0, 0, 0, 13579, 13583, 1, 0, 0, 0, 13580, 13578, 1, 0, 0, 0, 13581, 13583, 3, 1388, 694, 0, 13582, 13561, 1, 0, 0, 0, 13582, 13570, 1, 0, 0, 0, 13582, 13572, 1, 0, 0, 0, 13582, 13581, 1, 0, 0, 0, 13583, 1387, 1, 0, 0, 0, 13584, 13585, 4, 694, 9, 0, 13585, 13606, 5, 1734, 0, 0, 13586, 13587, 5, 2080, 0, 0, 13587, 13592, 3, 1656, 828, 0, 13588, 13589, 5, 2453, 0, 0, 13589, 13591, 3, 1656, 828, 0, 13590, 13588, 1, 0, 0, 0, 13591, 13594, 1, 0, 0, 0, 13592, 13590, 1, 0, 0, 0, 13592, 13593, 1, 0, 0, 0, 13593, 13607, 1, 0, 0, 0, 13594, 13592, 1, 0, 0, 0, 13595, 13596, 5, 352, 0, 0, 13596, 13607, 5, 2443, 0, 0, 13597, 13603, 3, 1456, 728, 0, 13598, 13599, 5, 2453, 0, 0, 13599, 13602, 5, 2443, 0, 0, 13600, 13602, 3, 1456, 728, 0, 13601, 13598, 1, 0, 0, 0, 13601, 13600, 1, 0, 0, 0, 13602, 13605, 1, 0, 0, 0, 13603, 13601, 1, 0, 0, 0, 13603, 13604, 1, 0, 0, 0, 13604, 13607, 1, 0, 0, 0, 13605, 13603, 1, 0, 0, 0, 13606, 13586, 1, 0, 0, 0, 13606, 13595, 1, 0, 0, 0, 13606, 13597, 1, 0, 0, 0, 13607, 13608, 1, 0, 0, 0, 13608, 13611, 5, 2202, 0, 0, 13609, 13610, 5, 283, 0, 0, 13610, 13612, 5, 2308, 0, 0, 13611, 13609, 1, 0, 0, 0, 13611, 13612, 1, 0, 0, 0, 13612, 13613, 1, 0, 0, 0, 13613, 13614, 5, 298, 0, 0, 13614, 1389, 1, 0, 0, 0, 13615, 13650, 5, 1516, 0, 0, 13616, 13617, 5, 904, 0, 0, 13617, 13618, 5, 1734, 0, 0, 13618, 13640, 5, 350, 0, 0, 13619, 13620, 5, 2246, 0, 0, 13620, 13621, 5, 336, 0, 0, 13621, 13635, 5, 882, 0, 0, 13622, 13625, 5, 439, 0, 0, 13623, 13624, 5, 628, 0, 0, 13624, 13626, 5, 1667, 0, 0, 13625, 13623, 1, 0, 0, 0, 13625, 13626, 1, 0, 0, 0, 13626, 13635, 1, 0, 0, 0, 13627, 13635, 5, 1087, 0, 0, 13628, 13629, 5, 2202, 0, 0, 13629, 13630, 5, 190, 0, 0, 13630, 13635, 5, 2441, 0, 0, 13631, 13632, 5, 2202, 0, 0, 13632, 13635, 5, 283, 0, 0, 13633, 13635, 3, 928, 464, 0, 13634, 13619, 1, 0, 0, 0, 13634, 13622, 1, 0, 0, 0, 13634, 13627, 1, 0, 0, 0, 13634, 13628, 1, 0, 0, 0, 13634, 13631, 1, 0, 0, 0, 13634, 13633, 1, 0, 0, 0, 13635, 13636, 1, 0, 0, 0, 13636, 13634, 1, 0, 0, 0, 13636, 13637, 1, 0, 0, 0, 13637, 13641, 1, 0, 0, 0, 13638, 13641, 5, 597, 0, 0, 13639, 13641, 5, 174, 0, 0, 13640, 13634, 1, 0, 0, 0, 13640, 13638, 1, 0, 0, 0, 13640, 13639, 1, 0, 0, 0, 13640, 13641, 1, 0, 0, 0, 13641, 13651, 1, 0, 0, 0, 13642, 13643, 5, 2141, 0, 0, 13643, 13644, 5, 885, 0, 0, 13644, 13648, 5, 1734, 0, 0, 13645, 13649, 3, 1392, 696, 0, 13646, 13647, 5, 814, 0, 0, 13647, 13649, 5, 687, 0, 0, 13648, 13645, 1, 0, 0, 0, 13648, 13646, 1, 0, 0, 0, 13649, 13651, 1, 0, 0, 0, 13650, 13616, 1, 0, 0, 0, 13650, 13642, 1, 0, 0, 0, 13651, 1391, 1, 0, 0, 0, 13652, 13653, 3, 2410, 1205, 0, 13653, 1393, 1, 0, 0, 0, 13654, 13655, 5, 1559, 0, 0, 13655, 13656, 5, 589, 0, 0, 13656, 13661, 3, 1458, 729, 0, 13657, 13658, 5, 2453, 0, 0, 13658, 13660, 3, 1458, 729, 0, 13659, 13657, 1, 0, 0, 0, 13660, 13663, 1, 0, 0, 0, 13661, 13659, 1, 0, 0, 0, 13661, 13662, 1, 0, 0, 0, 13662, 13664, 1, 0, 0, 0, 13663, 13661, 1, 0, 0, 0, 13664, 13665, 5, 2141, 0, 0, 13665, 13666, 3, 1458, 729, 0, 13666, 13672, 1, 0, 0, 0, 13667, 13672, 3, 1396, 698, 0, 13668, 13672, 3, 1398, 699, 0, 13669, 13672, 3, 1400, 700, 0, 13670, 13672, 3, 1402, 701, 0, 13671, 13654, 1, 0, 0, 0, 13671, 13667, 1, 0, 0, 0, 13671, 13668, 1, 0, 0, 0, 13671, 13669, 1, 0, 0, 0, 13671, 13670, 1, 0, 0, 0, 13672, 1395, 1, 0, 0, 0, 13673, 13674, 5, 321, 0, 0, 13674, 13677, 5, 352, 0, 0, 13675, 13678, 3, 1458, 729, 0, 13676, 13678, 3, 1456, 728, 0, 13677, 13675, 1, 0, 0, 0, 13677, 13676, 1, 0, 0, 0, 13678, 13686, 1, 0, 0, 0, 13679, 13682, 5, 2453, 0, 0, 13680, 13683, 3, 1458, 729, 0, 13681, 13683, 3, 1456, 728, 0, 13682, 13680, 1, 0, 0, 0, 13682, 13681, 1, 0, 0, 0, 13683, 13685, 1, 0, 0, 0, 13684, 13679, 1, 0, 0, 0, 13685, 13688, 1, 0, 0, 0, 13686, 13684, 1, 0, 0, 0, 13686, 13687, 1, 0, 0, 0, 13687, 13691, 1, 0, 0, 0, 13688, 13686, 1, 0, 0, 0, 13689, 13690, 5, 69, 0, 0, 13690, 13692, 5, 1021, 0, 0, 13691, 13689, 1, 0, 0, 0, 13691, 13692, 1, 0, 0, 0, 13692, 1397, 1, 0, 0, 0, 13693, 13696, 5, 352, 0, 0, 13694, 13697, 3, 1458, 729, 0, 13695, 13697, 3, 1456, 728, 0, 13696, 13694, 1, 0, 0, 0, 13696, 13695, 1, 0, 0, 0, 13697, 13705, 1, 0, 0, 0, 13698, 13701, 5, 2453, 0, 0, 13699, 13702, 3, 1458, 729, 0, 13700, 13702, 3, 1456, 728, 0, 13701, 13699, 1, 0, 0, 0, 13701, 13700, 1, 0, 0, 0, 13702, 13704, 1, 0, 0, 0, 13703, 13698, 1, 0, 0, 0, 13704, 13707, 1, 0, 0, 0, 13705, 13703, 1, 0, 0, 0, 13705, 13706, 1, 0, 0, 0, 13706, 13719, 1, 0, 0, 0, 13707, 13705, 1, 0, 0, 0, 13708, 13720, 5, 1256, 0, 0, 13709, 13712, 5, 1243, 0, 0, 13710, 13711, 5, 620, 0, 0, 13711, 13713, 5, 469, 0, 0, 13712, 13710, 1, 0, 0, 0, 13712, 13713, 1, 0, 0, 0, 13713, 13720, 1, 0, 0, 0, 13714, 13715, 5, 1567, 0, 0, 13715, 13720, 3, 1176, 588, 0, 13716, 13720, 3, 922, 461, 0, 13717, 13718, 5, 508, 0, 0, 13718, 13720, 5, 102, 0, 0, 13719, 13708, 1, 0, 0, 0, 13719, 13709, 1, 0, 0, 0, 13719, 13714, 1, 0, 0, 0, 13719, 13716, 1, 0, 0, 0, 13719, 13717, 1, 0, 0, 0, 13720, 1399, 1, 0, 0, 0, 13721, 13724, 5, 2089, 0, 0, 13722, 13725, 3, 1458, 729, 0, 13723, 13725, 3, 1456, 728, 0, 13724, 13722, 1, 0, 0, 0, 13724, 13723, 1, 0, 0, 0, 13725, 13733, 1, 0, 0, 0, 13726, 13729, 5, 2453, 0, 0, 13727, 13730, 3, 1458, 729, 0, 13728, 13730, 3, 1456, 728, 0, 13729, 13727, 1, 0, 0, 0, 13729, 13728, 1, 0, 0, 0, 13730, 13732, 1, 0, 0, 0, 13731, 13726, 1, 0, 0, 0, 13732, 13735, 1, 0, 0, 0, 13733, 13731, 1, 0, 0, 0, 13733, 13734, 1, 0, 0, 0, 13734, 13744, 1, 0, 0, 0, 13735, 13733, 1, 0, 0, 0, 13736, 13737, 5, 1567, 0, 0, 13737, 13745, 3, 1176, 588, 0, 13738, 13745, 3, 922, 461, 0, 13739, 13740, 5, 469, 0, 0, 13740, 13741, 5, 705, 0, 0, 13741, 13745, 5, 353, 0, 0, 13742, 13745, 5, 1256, 0, 0, 13743, 13745, 5, 1243, 0, 0, 13744, 13736, 1, 0, 0, 0, 13744, 13738, 1, 0, 0, 0, 13744, 13739, 1, 0, 0, 0, 13744, 13742, 1, 0, 0, 0, 13744, 13743, 1, 0, 0, 0, 13745, 1401, 1, 0, 0, 0, 13746, 13747, 5, 992, 0, 0, 13747, 13750, 5, 352, 0, 0, 13748, 13751, 3, 1458, 729, 0, 13749, 13751, 3, 1456, 728, 0, 13750, 13748, 1, 0, 0, 0, 13750, 13749, 1, 0, 0, 0, 13751, 13759, 1, 0, 0, 0, 13752, 13755, 5, 2453, 0, 0, 13753, 13756, 3, 1458, 729, 0, 13754, 13756, 3, 1456, 728, 0, 13755, 13753, 1, 0, 0, 0, 13755, 13754, 1, 0, 0, 0, 13756, 13758, 1, 0, 0, 0, 13757, 13752, 1, 0, 0, 0, 13758, 13761, 1, 0, 0, 0, 13759, 13757, 1, 0, 0, 0, 13759, 13760, 1, 0, 0, 0, 13760, 13764, 1, 0, 0, 0, 13761, 13759, 1, 0, 0, 0, 13762, 13763, 5, 2141, 0, 0, 13763, 13765, 3, 1458, 729, 0, 13764, 13762, 1, 0, 0, 0, 13764, 13765, 1, 0, 0, 0, 13765, 13767, 1, 0, 0, 0, 13766, 13768, 5, 1587, 0, 0, 13767, 13766, 1, 0, 0, 0, 13767, 13768, 1, 0, 0, 0, 13768, 13770, 1, 0, 0, 0, 13769, 13771, 5, 814, 0, 0, 13770, 13769, 1, 0, 0, 0, 13770, 13771, 1, 0, 0, 0, 13771, 1403, 1, 0, 0, 0, 13772, 13774, 5, 66, 0, 0, 13773, 13775, 5, 909, 0, 0, 13774, 13773, 1, 0, 0, 0, 13774, 13775, 1, 0, 0, 0, 13775, 13778, 1, 0, 0, 0, 13776, 13778, 5, 1058, 0, 0, 13777, 13772, 1, 0, 0, 0, 13777, 13776, 1, 0, 0, 0, 13778, 13829, 1, 0, 0, 0, 13779, 13781, 5, 1137, 0, 0, 13780, 13779, 1, 0, 0, 0, 13780, 13781, 1, 0, 0, 0, 13781, 13782, 1, 0, 0, 0, 13782, 13783, 5, 616, 0, 0, 13783, 13829, 5, 884, 0, 0, 13784, 13785, 5, 1671, 0, 0, 13785, 13786, 5, 1734, 0, 0, 13786, 13787, 5, 1119, 0, 0, 13787, 13792, 5, 620, 0, 0, 13788, 13789, 5, 351, 0, 0, 13789, 13793, 5, 98, 0, 0, 13790, 13791, 5, 867, 0, 0, 13791, 13793, 5, 1385, 0, 0, 13792, 13788, 1, 0, 0, 0, 13792, 13790, 1, 0, 0, 0, 13793, 13829, 1, 0, 0, 0, 13794, 13795, 5, 1559, 0, 0, 13795, 13796, 5, 589, 0, 0, 13796, 13801, 3, 1458, 729, 0, 13797, 13798, 5, 2453, 0, 0, 13798, 13800, 3, 1458, 729, 0, 13799, 13797, 1, 0, 0, 0, 13800, 13803, 1, 0, 0, 0, 13801, 13799, 1, 0, 0, 0, 13801, 13802, 1, 0, 0, 0, 13802, 13804, 1, 0, 0, 0, 13803, 13801, 1, 0, 0, 0, 13804, 13805, 5, 2141, 0, 0, 13805, 13806, 3, 1458, 729, 0, 13806, 13829, 1, 0, 0, 0, 13807, 13809, 5, 212, 0, 0, 13808, 13810, 5, 2173, 0, 0, 13809, 13808, 1, 0, 0, 0, 13809, 13810, 1, 0, 0, 0, 13810, 13811, 1, 0, 0, 0, 13811, 13812, 5, 882, 0, 0, 13812, 13817, 3, 1420, 710, 0, 13813, 13814, 5, 2453, 0, 0, 13814, 13816, 3, 1420, 710, 0, 13815, 13813, 1, 0, 0, 0, 13816, 13819, 1, 0, 0, 0, 13817, 13815, 1, 0, 0, 0, 13817, 13818, 1, 0, 0, 0, 13818, 13822, 1, 0, 0, 0, 13819, 13817, 1, 0, 0, 0, 13820, 13821, 5, 2198, 0, 0, 13821, 13823, 5, 352, 0, 0, 13822, 13820, 1, 0, 0, 0, 13822, 13823, 1, 0, 0, 0, 13823, 13829, 1, 0, 0, 0, 13824, 13829, 3, 1406, 703, 0, 13825, 13829, 3, 1410, 705, 0, 13826, 13829, 3, 1412, 706, 0, 13827, 13829, 3, 1414, 707, 0, 13828, 13777, 1, 0, 0, 0, 13828, 13780, 1, 0, 0, 0, 13828, 13784, 1, 0, 0, 0, 13828, 13794, 1, 0, 0, 0, 13828, 13807, 1, 0, 0, 0, 13828, 13824, 1, 0, 0, 0, 13828, 13825, 1, 0, 0, 0, 13828, 13826, 1, 0, 0, 0, 13828, 13827, 1, 0, 0, 0, 13829, 1405, 1, 0, 0, 0, 13830, 13832, 5, 21, 0, 0, 13831, 13833, 5, 1734, 0, 0, 13832, 13831, 1, 0, 0, 0, 13832, 13833, 1, 0, 0, 0, 13833, 13834, 1, 0, 0, 0, 13834, 13870, 5, 882, 0, 0, 13835, 13836, 5, 759, 0, 0, 13836, 13840, 5, 2443, 0, 0, 13837, 13838, 5, 2102, 0, 0, 13838, 13840, 5, 2441, 0, 0, 13839, 13835, 1, 0, 0, 0, 13839, 13837, 1, 0, 0, 0, 13839, 13840, 1, 0, 0, 0, 13840, 13842, 1, 0, 0, 0, 13841, 13843, 3, 1408, 704, 0, 13842, 13841, 1, 0, 0, 0, 13843, 13844, 1, 0, 0, 0, 13844, 13842, 1, 0, 0, 0, 13844, 13845, 1, 0, 0, 0, 13845, 13871, 1, 0, 0, 0, 13846, 13847, 5, 936, 0, 0, 13847, 13849, 3, 1458, 729, 0, 13848, 13850, 5, 1587, 0, 0, 13849, 13848, 1, 0, 0, 0, 13849, 13850, 1, 0, 0, 0, 13850, 13858, 1, 0, 0, 0, 13851, 13852, 5, 2453, 0, 0, 13852, 13854, 3, 1458, 729, 0, 13853, 13855, 5, 1587, 0, 0, 13854, 13853, 1, 0, 0, 0, 13854, 13855, 1, 0, 0, 0, 13855, 13857, 1, 0, 0, 0, 13856, 13851, 1, 0, 0, 0, 13857, 13860, 1, 0, 0, 0, 13858, 13856, 1, 0, 0, 0, 13858, 13859, 1, 0, 0, 0, 13859, 13861, 1, 0, 0, 0, 13860, 13858, 1, 0, 0, 0, 13861, 13862, 5, 2141, 0, 0, 13862, 13867, 3, 1420, 710, 0, 13863, 13864, 5, 2453, 0, 0, 13864, 13866, 3, 1420, 710, 0, 13865, 13863, 1, 0, 0, 0, 13866, 13869, 1, 0, 0, 0, 13867, 13865, 1, 0, 0, 0, 13867, 13868, 1, 0, 0, 0, 13868, 13871, 1, 0, 0, 0, 13869, 13867, 1, 0, 0, 0, 13870, 13839, 1, 0, 0, 0, 13870, 13846, 1, 0, 0, 0, 13871, 1407, 1, 0, 0, 0, 13872, 13873, 5, 649, 0, 0, 13873, 13875, 5, 2441, 0, 0, 13874, 13872, 1, 0, 0, 0, 13874, 13875, 1, 0, 0, 0, 13875, 13876, 1, 0, 0, 0, 13876, 13877, 3, 920, 460, 0, 13877, 1409, 1, 0, 0, 0, 13878, 13880, 5, 469, 0, 0, 13879, 13881, 5, 1734, 0, 0, 13880, 13879, 1, 0, 0, 0, 13880, 13881, 1, 0, 0, 0, 13881, 13882, 1, 0, 0, 0, 13882, 13900, 5, 882, 0, 0, 13883, 13888, 3, 1420, 710, 0, 13884, 13885, 5, 2453, 0, 0, 13885, 13887, 3, 1420, 710, 0, 13886, 13884, 1, 0, 0, 0, 13887, 13890, 1, 0, 0, 0, 13888, 13886, 1, 0, 0, 0, 13888, 13889, 1, 0, 0, 0, 13889, 13901, 1, 0, 0, 0, 13890, 13888, 1, 0, 0, 0, 13891, 13892, 5, 936, 0, 0, 13892, 13897, 3, 1458, 729, 0, 13893, 13894, 5, 2453, 0, 0, 13894, 13896, 3, 1458, 729, 0, 13895, 13893, 1, 0, 0, 0, 13896, 13899, 1, 0, 0, 0, 13897, 13895, 1, 0, 0, 0, 13897, 13898, 1, 0, 0, 0, 13898, 13901, 1, 0, 0, 0, 13899, 13897, 1, 0, 0, 0, 13900, 13883, 1, 0, 0, 0, 13900, 13891, 1, 0, 0, 0, 13901, 1411, 1, 0, 0, 0, 13902, 13903, 5, 1793, 0, 0, 13903, 13904, 5, 38, 0, 0, 13904, 13905, 5, 883, 0, 0, 13905, 13906, 5, 2141, 0, 0, 13906, 13907, 5, 146, 0, 0, 13907, 13908, 5, 2441, 0, 0, 13908, 1413, 1, 0, 0, 0, 13909, 13910, 3, 1416, 708, 0, 13910, 13911, 5, 1789, 0, 0, 13911, 13915, 5, 888, 0, 0, 13912, 13916, 5, 351, 0, 0, 13913, 13916, 3, 1282, 641, 0, 13914, 13916, 3, 1418, 709, 0, 13915, 13912, 1, 0, 0, 0, 13915, 13913, 1, 0, 0, 0, 13915, 13914, 1, 0, 0, 0, 13916, 1415, 1, 0, 0, 0, 13917, 13918, 7, 9, 0, 0, 13918, 1417, 1, 0, 0, 0, 13919, 13920, 5, 351, 0, 0, 13920, 13921, 5, 620, 0, 0, 13921, 13922, 5, 1460, 0, 0, 13922, 13923, 5, 1563, 0, 0, 13923, 1419, 1, 0, 0, 0, 13924, 13925, 5, 649, 0, 0, 13925, 13939, 5, 2441, 0, 0, 13926, 13927, 5, 2447, 0, 0, 13927, 13932, 3, 1458, 729, 0, 13928, 13929, 5, 2453, 0, 0, 13929, 13931, 3, 1458, 729, 0, 13930, 13928, 1, 0, 0, 0, 13931, 13934, 1, 0, 0, 0, 13932, 13930, 1, 0, 0, 0, 13932, 13933, 1, 0, 0, 0, 13933, 13935, 1, 0, 0, 0, 13934, 13932, 1, 0, 0, 0, 13935, 13936, 5, 2448, 0, 0, 13936, 13939, 1, 0, 0, 0, 13937, 13939, 3, 1458, 729, 0, 13938, 13924, 1, 0, 0, 0, 13938, 13926, 1, 0, 0, 0, 13938, 13937, 1, 0, 0, 0, 13939, 1421, 1, 0, 0, 0, 13940, 13942, 5, 321, 0, 0, 13941, 13943, 7, 172, 0, 0, 13942, 13941, 1, 0, 0, 0, 13942, 13943, 1, 0, 0, 0, 13943, 13944, 1, 0, 0, 0, 13944, 13945, 5, 1734, 0, 0, 13945, 13946, 5, 298, 0, 0, 13946, 13947, 5, 69, 0, 0, 13947, 13949, 3, 1458, 729, 0, 13948, 13950, 5, 1587, 0, 0, 13949, 13948, 1, 0, 0, 0, 13949, 13950, 1, 0, 0, 0, 13950, 13962, 1, 0, 0, 0, 13951, 13952, 5, 102, 0, 0, 13952, 13953, 5, 298, 0, 0, 13953, 13959, 5, 2141, 0, 0, 13954, 13956, 3, 1458, 729, 0, 13955, 13957, 5, 1587, 0, 0, 13956, 13955, 1, 0, 0, 0, 13956, 13957, 1, 0, 0, 0, 13957, 13960, 1, 0, 0, 0, 13958, 13960, 3, 1424, 712, 0, 13959, 13954, 1, 0, 0, 0, 13959, 13958, 1, 0, 0, 0, 13960, 13962, 1, 0, 0, 0, 13961, 13940, 1, 0, 0, 0, 13961, 13951, 1, 0, 0, 0, 13962, 1423, 1, 0, 0, 0, 13963, 13969, 5, 2143, 0, 0, 13964, 13965, 5, 69, 0, 0, 13965, 13967, 3, 1458, 729, 0, 13966, 13968, 5, 1587, 0, 0, 13967, 13966, 1, 0, 0, 0, 13967, 13968, 1, 0, 0, 0, 13968, 13970, 1, 0, 0, 0, 13969, 13964, 1, 0, 0, 0, 13969, 13970, 1, 0, 0, 0, 13970, 13972, 1, 0, 0, 0, 13971, 13973, 7, 63, 0, 0, 13972, 13971, 1, 0, 0, 0, 13972, 13973, 1, 0, 0, 0, 13973, 1425, 1, 0, 0, 0, 13974, 13982, 3, 1428, 714, 0, 13975, 13982, 3, 1430, 715, 0, 13976, 13982, 3, 1432, 716, 0, 13977, 13982, 3, 1434, 717, 0, 13978, 13982, 3, 1436, 718, 0, 13979, 13982, 3, 1438, 719, 0, 13980, 13982, 3, 1440, 720, 0, 13981, 13974, 1, 0, 0, 0, 13981, 13975, 1, 0, 0, 0, 13981, 13976, 1, 0, 0, 0, 13981, 13977, 1, 0, 0, 0, 13981, 13978, 1, 0, 0, 0, 13981, 13979, 1, 0, 0, 0, 13981, 13980, 1, 0, 0, 0, 13982, 13984, 1, 0, 0, 0, 13983, 13985, 3, 928, 464, 0, 13984, 13983, 1, 0, 0, 0, 13984, 13985, 1, 0, 0, 0, 13985, 1427, 1, 0, 0, 0, 13986, 13988, 5, 13, 0, 0, 13987, 13989, 7, 172, 0, 0, 13988, 13987, 1, 0, 0, 0, 13988, 13989, 1, 0, 0, 0, 13989, 13990, 1, 0, 0, 0, 13990, 13991, 5, 1734, 0, 0, 13991, 13994, 5, 350, 0, 0, 13992, 13993, 5, 597, 0, 0, 13993, 13995, 5, 61, 0, 0, 13994, 13992, 1, 0, 0, 0, 13994, 13995, 1, 0, 0, 0, 13995, 1429, 1, 0, 0, 0, 13996, 13997, 5, 1671, 0, 0, 13997, 13998, 5, 1734, 0, 0, 13998, 13999, 5, 350, 0, 0, 13999, 14000, 5, 2141, 0, 0, 14000, 14001, 5, 924, 0, 0, 14001, 14002, 7, 173, 0, 0, 14002, 1431, 1, 0, 0, 0, 14003, 14006, 5, 1538, 0, 0, 14004, 14005, 5, 1307, 0, 0, 14005, 14007, 5, 1562, 0, 0, 14006, 14004, 1, 0, 0, 0, 14006, 14007, 1, 0, 0, 0, 14007, 14008, 1, 0, 0, 0, 14008, 14009, 7, 172, 0, 0, 14009, 14010, 5, 882, 0, 0, 14010, 1433, 1, 0, 0, 0, 14011, 14012, 7, 174, 0, 0, 14012, 14013, 5, 2141, 0, 0, 14013, 14042, 5, 1792, 0, 0, 14014, 14035, 5, 2141, 0, 0, 14015, 14017, 7, 172, 0, 0, 14016, 14015, 1, 0, 0, 0, 14016, 14017, 1, 0, 0, 0, 14017, 14018, 1, 0, 0, 0, 14018, 14024, 5, 1451, 0, 0, 14019, 14021, 5, 1392, 0, 0, 14020, 14019, 1, 0, 0, 0, 14020, 14021, 1, 0, 0, 0, 14021, 14022, 1, 0, 0, 0, 14022, 14024, 5, 1734, 0, 0, 14023, 14016, 1, 0, 0, 0, 14023, 14020, 1, 0, 0, 0, 14024, 14031, 1, 0, 0, 0, 14025, 14027, 7, 2, 0, 0, 14026, 14025, 1, 0, 0, 0, 14026, 14027, 1, 0, 0, 0, 14027, 14028, 1, 0, 0, 0, 14028, 14029, 5, 1667, 0, 0, 14029, 14030, 5, 1685, 0, 0, 14030, 14032, 7, 0, 0, 0, 14031, 14026, 1, 0, 0, 0, 14031, 14032, 1, 0, 0, 0, 14032, 14036, 1, 0, 0, 0, 14033, 14034, 5, 885, 0, 0, 14034, 14036, 5, 1734, 0, 0, 14035, 14023, 1, 0, 0, 0, 14035, 14033, 1, 0, 0, 0, 14036, 14040, 1, 0, 0, 0, 14037, 14038, 5, 885, 0, 0, 14038, 14040, 5, 1734, 0, 0, 14039, 14014, 1, 0, 0, 0, 14039, 14037, 1, 0, 0, 0, 14040, 14043, 1, 0, 0, 0, 14041, 14043, 5, 174, 0, 0, 14042, 14039, 1, 0, 0, 0, 14042, 14041, 1, 0, 0, 0, 14042, 14043, 1, 0, 0, 0, 14043, 1435, 1, 0, 0, 0, 14044, 14045, 5, 1737, 0, 0, 14045, 14046, 5, 885, 0, 0, 14046, 14047, 5, 1734, 0, 0, 14047, 14049, 5, 61, 0, 0, 14048, 14050, 5, 698, 0, 0, 14049, 14048, 1, 0, 0, 0, 14049, 14050, 1, 0, 0, 0, 14050, 14052, 1, 0, 0, 0, 14051, 14053, 5, 1087, 0, 0, 14052, 14051, 1, 0, 0, 0, 14052, 14053, 1, 0, 0, 0, 14053, 14065, 1, 0, 0, 0, 14054, 14055, 5, 1021, 0, 0, 14055, 14056, 5, 1451, 0, 0, 14056, 14066, 3, 2410, 1205, 0, 14057, 14059, 5, 740, 0, 0, 14058, 14060, 5, 2441, 0, 0, 14059, 14058, 1, 0, 0, 0, 14059, 14060, 1, 0, 0, 0, 14060, 14066, 1, 0, 0, 0, 14061, 14062, 5, 1702, 0, 0, 14062, 14063, 5, 570, 0, 0, 14063, 14066, 5, 2147, 0, 0, 14064, 14066, 5, 597, 0, 0, 14065, 14054, 1, 0, 0, 0, 14065, 14057, 1, 0, 0, 0, 14065, 14061, 1, 0, 0, 0, 14065, 14064, 1, 0, 0, 0, 14065, 14066, 1, 0, 0, 0, 14066, 1437, 1, 0, 0, 0, 14067, 14068, 7, 175, 0, 0, 14068, 14069, 5, 885, 0, 0, 14069, 14070, 5, 1734, 0, 0, 14070, 14071, 5, 61, 0, 0, 14071, 1439, 1, 0, 0, 0, 14072, 14073, 5, 300, 0, 0, 14073, 14074, 5, 2141, 0, 0, 14074, 14075, 7, 176, 0, 0, 14075, 14076, 5, 1734, 0, 0, 14076, 1441, 1, 0, 0, 0, 14077, 14078, 5, 389, 0, 0, 14078, 14079, 5, 483, 0, 0, 14079, 14080, 5, 2472, 0, 0, 14080, 14124, 3, 1454, 727, 0, 14081, 14082, 5, 1671, 0, 0, 14082, 14083, 5, 389, 0, 0, 14083, 14084, 7, 101, 0, 0, 14084, 14124, 5, 2080, 0, 0, 14085, 14086, 5, 389, 0, 0, 14086, 14087, 5, 2080, 0, 0, 14087, 14124, 3, 1656, 828, 0, 14088, 14089, 5, 389, 0, 0, 14089, 14090, 5, 2092, 0, 0, 14090, 14093, 5, 2080, 0, 0, 14091, 14094, 3, 1656, 828, 0, 14092, 14094, 3, 872, 436, 0, 14093, 14091, 1, 0, 0, 0, 14093, 14092, 1, 0, 0, 0, 14094, 14124, 1, 0, 0, 0, 14095, 14096, 5, 1559, 0, 0, 14096, 14097, 5, 644, 0, 0, 14097, 14098, 5, 2141, 0, 0, 14098, 14101, 3, 1452, 726, 0, 14099, 14100, 5, 2440, 0, 0, 14100, 14102, 3, 1450, 725, 0, 14101, 14099, 1, 0, 0, 0, 14102, 14103, 1, 0, 0, 0, 14103, 14101, 1, 0, 0, 0, 14103, 14104, 1, 0, 0, 0, 14104, 14124, 1, 0, 0, 0, 14105, 14106, 5, 499, 0, 0, 14106, 14107, 5, 143, 0, 0, 14107, 14108, 5, 190, 0, 0, 14108, 14115, 5, 2145, 0, 0, 14109, 14110, 5, 2246, 0, 0, 14110, 14111, 5, 589, 0, 0, 14111, 14113, 3, 1458, 729, 0, 14112, 14114, 5, 1587, 0, 0, 14113, 14112, 1, 0, 0, 0, 14113, 14114, 1, 0, 0, 0, 14114, 14116, 1, 0, 0, 0, 14115, 14109, 1, 0, 0, 0, 14115, 14116, 1, 0, 0, 0, 14116, 14124, 1, 0, 0, 0, 14117, 14118, 5, 429, 0, 0, 14118, 14119, 5, 143, 0, 0, 14119, 14120, 5, 190, 0, 0, 14120, 14124, 5, 2145, 0, 0, 14121, 14124, 3, 876, 438, 0, 14122, 14124, 3, 1444, 722, 0, 14123, 14077, 1, 0, 0, 0, 14123, 14081, 1, 0, 0, 0, 14123, 14085, 1, 0, 0, 0, 14123, 14088, 1, 0, 0, 0, 14123, 14095, 1, 0, 0, 0, 14123, 14105, 1, 0, 0, 0, 14123, 14117, 1, 0, 0, 0, 14123, 14121, 1, 0, 0, 0, 14123, 14122, 1, 0, 0, 0, 14124, 1443, 1, 0, 0, 0, 14125, 14126, 5, 1671, 0, 0, 14126, 14127, 5, 2113, 0, 0, 14127, 14128, 5, 2472, 0, 0, 14128, 14129, 5, 2443, 0, 0, 14129, 1445, 1, 0, 0, 0, 14130, 14131, 3, 1308, 654, 0, 14131, 14132, 5, 759, 0, 0, 14132, 14133, 5, 2443, 0, 0, 14133, 1447, 1, 0, 0, 0, 14134, 14135, 5, 656, 0, 0, 14135, 14136, 7, 177, 0, 0, 14136, 1449, 1, 0, 0, 0, 14137, 14138, 3, 2404, 1202, 0, 14138, 1451, 1, 0, 0, 0, 14139, 14140, 3, 2404, 1202, 0, 14140, 1453, 1, 0, 0, 0, 14141, 14142, 3, 2410, 1205, 0, 14142, 1455, 1, 0, 0, 0, 14143, 14144, 5, 2441, 0, 0, 14144, 1457, 1, 0, 0, 0, 14145, 14146, 5, 2443, 0, 0, 14146, 1459, 1, 0, 0, 0, 14147, 14148, 5, 1441, 0, 0, 14148, 14149, 5, 963, 0, 0, 14149, 14150, 5, 303, 0, 0, 14150, 14154, 3, 2404, 1202, 0, 14151, 14152, 5, 2308, 0, 0, 14152, 14153, 7, 178, 0, 0, 14153, 14155, 5, 1524, 0, 0, 14154, 14151, 1, 0, 0, 0, 14154, 14155, 1, 0, 0, 0, 14155, 14159, 1, 0, 0, 0, 14156, 14157, 5, 620, 0, 0, 14157, 14158, 5, 350, 0, 0, 14158, 14160, 3, 2404, 1202, 0, 14159, 14156, 1, 0, 0, 0, 14159, 14160, 1, 0, 0, 0, 14160, 1461, 1, 0, 0, 0, 14161, 14162, 5, 469, 0, 0, 14162, 14163, 5, 963, 0, 0, 14163, 14164, 5, 303, 0, 0, 14164, 14165, 3, 2404, 1202, 0, 14165, 1463, 1, 0, 0, 0, 14166, 14167, 7, 179, 0, 0, 14167, 14168, 5, 895, 0, 0, 14168, 14169, 5, 2313, 0, 0, 14169, 14170, 5, 1469, 0, 0, 14170, 1465, 1, 0, 0, 0, 14171, 14174, 3, 1468, 734, 0, 14172, 14174, 3, 1470, 735, 0, 14173, 14171, 1, 0, 0, 0, 14173, 14172, 1, 0, 0, 0, 14174, 1467, 1, 0, 0, 0, 14175, 14176, 5, 1671, 0, 0, 14176, 14177, 5, 836, 0, 0, 14177, 14178, 5, 2472, 0, 0, 14178, 14179, 7, 180, 0, 0, 14179, 1469, 1, 0, 0, 0, 14180, 14181, 5, 1671, 0, 0, 14181, 14182, 5, 837, 0, 0, 14182, 14183, 5, 2472, 0, 0, 14183, 14184, 5, 2443, 0, 0, 14184, 1471, 1, 0, 0, 0, 14185, 14186, 5, 1467, 0, 0, 14186, 14187, 7, 181, 0, 0, 14187, 14188, 5, 393, 0, 0, 14188, 14189, 5, 2472, 0, 0, 14189, 14190, 3, 2404, 1202, 0, 14190, 1473, 1, 0, 0, 0, 14191, 14192, 5, 2211, 0, 0, 14192, 14193, 5, 1795, 0, 0, 14193, 14194, 7, 100, 0, 0, 14194, 1475, 1, 0, 0, 0, 14195, 14197, 5, 42, 0, 0, 14196, 14198, 5, 1679, 0, 0, 14197, 14196, 1, 0, 0, 0, 14197, 14198, 1, 0, 0, 0, 14198, 14200, 1, 0, 0, 0, 14199, 14201, 5, 1473, 0, 0, 14200, 14199, 1, 0, 0, 0, 14200, 14201, 1, 0, 0, 0, 14201, 14202, 1, 0, 0, 0, 14202, 14203, 5, 350, 0, 0, 14203, 14204, 5, 861, 0, 0, 14204, 14215, 3, 2336, 1168, 0, 14205, 14206, 5, 280, 0, 0, 14206, 14207, 5, 2141, 0, 0, 14207, 14208, 3, 2354, 1177, 0, 14208, 14209, 5, 685, 0, 0, 14209, 14210, 5, 160, 0, 0, 14210, 14212, 3, 1478, 739, 0, 14211, 14213, 3, 1480, 740, 0, 14212, 14211, 1, 0, 0, 0, 14212, 14213, 1, 0, 0, 0, 14213, 14216, 1, 0, 0, 0, 14214, 14216, 3, 1480, 740, 0, 14215, 14205, 1, 0, 0, 0, 14215, 14214, 1, 0, 0, 0, 14216, 1477, 1, 0, 0, 0, 14217, 14222, 3, 2404, 1202, 0, 14218, 14222, 3, 2396, 1198, 0, 14219, 14220, 5, 2257, 0, 0, 14220, 14222, 5, 2443, 0, 0, 14221, 14217, 1, 0, 0, 0, 14221, 14218, 1, 0, 0, 0, 14221, 14219, 1, 0, 0, 0, 14222, 1479, 1, 0, 0, 0, 14223, 14224, 5, 86, 0, 0, 14224, 14225, 5, 160, 0, 0, 14225, 14226, 3, 2354, 1177, 0, 14226, 14227, 5, 685, 0, 0, 14227, 14228, 5, 160, 0, 0, 14228, 14229, 3, 1478, 739, 0, 14229, 1481, 1, 0, 0, 0, 14230, 14231, 5, 321, 0, 0, 14231, 14232, 5, 1625, 0, 0, 14232, 14233, 5, 89, 0, 0, 14233, 14239, 3, 2286, 1143, 0, 14234, 14238, 3, 1038, 519, 0, 14235, 14238, 3, 836, 418, 0, 14236, 14238, 3, 764, 382, 0, 14237, 14234, 1, 0, 0, 0, 14237, 14235, 1, 0, 0, 0, 14237, 14236, 1, 0, 0, 0, 14238, 14241, 1, 0, 0, 0, 14239, 14237, 1, 0, 0, 0, 14239, 14240, 1, 0, 0, 0, 14240, 1483, 1, 0, 0, 0, 14241, 14239, 1, 0, 0, 0, 14242, 14243, 5, 321, 0, 0, 14243, 14244, 5, 350, 0, 0, 14244, 14283, 3, 1366, 683, 0, 14245, 14246, 5, 2237, 0, 0, 14246, 14247, 7, 182, 0, 0, 14247, 14248, 5, 685, 0, 0, 14248, 14249, 5, 160, 0, 0, 14249, 14284, 3, 1478, 739, 0, 14250, 14251, 5, 298, 0, 0, 14251, 14284, 5, 1587, 0, 0, 14252, 14253, 7, 183, 0, 0, 14253, 14284, 5, 2441, 0, 0, 14254, 14256, 5, 1001, 0, 0, 14255, 14254, 1, 0, 0, 0, 14255, 14256, 1, 0, 0, 0, 14256, 14257, 1, 0, 0, 0, 14257, 14258, 5, 193, 0, 0, 14258, 14259, 5, 1671, 0, 0, 14259, 14284, 3, 2346, 1173, 0, 14260, 14261, 5, 1671, 0, 0, 14261, 14262, 5, 389, 0, 0, 14262, 14263, 7, 101, 0, 0, 14263, 14284, 5, 2080, 0, 0, 14264, 14284, 3, 1486, 743, 0, 14265, 14284, 3, 1490, 745, 0, 14266, 14284, 3, 1444, 722, 0, 14267, 14269, 7, 101, 0, 0, 14268, 14267, 1, 0, 0, 0, 14268, 14269, 1, 0, 0, 0, 14269, 14270, 1, 0, 0, 0, 14270, 14271, 5, 2230, 0, 0, 14271, 14272, 5, 2080, 0, 0, 14272, 14273, 3, 872, 436, 0, 14273, 14274, 5, 352, 0, 0, 14274, 14279, 3, 918, 459, 0, 14275, 14276, 5, 2453, 0, 0, 14276, 14278, 3, 918, 459, 0, 14277, 14275, 1, 0, 0, 0, 14278, 14281, 1, 0, 0, 0, 14279, 14277, 1, 0, 0, 0, 14279, 14280, 1, 0, 0, 0, 14280, 14284, 1, 0, 0, 0, 14281, 14279, 1, 0, 0, 0, 14282, 14284, 3, 1492, 746, 0, 14283, 14245, 1, 0, 0, 0, 14283, 14250, 1, 0, 0, 0, 14283, 14252, 1, 0, 0, 0, 14283, 14255, 1, 0, 0, 0, 14283, 14260, 1, 0, 0, 0, 14283, 14264, 1, 0, 0, 0, 14283, 14265, 1, 0, 0, 0, 14283, 14266, 1, 0, 0, 0, 14283, 14268, 1, 0, 0, 0, 14283, 14282, 1, 0, 0, 0, 14284, 14285, 1, 0, 0, 0, 14285, 14283, 1, 0, 0, 0, 14285, 14286, 1, 0, 0, 0, 14286, 1485, 1, 0, 0, 0, 14287, 14288, 5, 882, 0, 0, 14288, 14293, 3, 1488, 744, 0, 14289, 14290, 5, 2453, 0, 0, 14290, 14292, 3, 1488, 744, 0, 14291, 14289, 1, 0, 0, 0, 14292, 14295, 1, 0, 0, 0, 14293, 14291, 1, 0, 0, 0, 14293, 14294, 1, 0, 0, 0, 14294, 14303, 1, 0, 0, 0, 14295, 14293, 1, 0, 0, 0, 14296, 14297, 7, 184, 0, 0, 14297, 14303, 5, 2441, 0, 0, 14298, 14303, 5, 66, 0, 0, 14299, 14303, 5, 1058, 0, 0, 14300, 14301, 5, 616, 0, 0, 14301, 14303, 5, 884, 0, 0, 14302, 14287, 1, 0, 0, 0, 14302, 14296, 1, 0, 0, 0, 14302, 14298, 1, 0, 0, 0, 14302, 14299, 1, 0, 0, 0, 14302, 14300, 1, 0, 0, 0, 14303, 1487, 1, 0, 0, 0, 14304, 14305, 5, 649, 0, 0, 14305, 14307, 5, 2441, 0, 0, 14306, 14304, 1, 0, 0, 0, 14306, 14307, 1, 0, 0, 0, 14307, 14308, 1, 0, 0, 0, 14308, 14309, 3, 436, 218, 0, 14309, 1489, 1, 0, 0, 0, 14310, 14311, 5, 558, 0, 0, 14311, 14312, 5, 906, 0, 0, 14312, 14329, 5, 873, 0, 0, 14313, 14315, 5, 1800, 0, 0, 14314, 14313, 1, 0, 0, 0, 14314, 14315, 1, 0, 0, 0, 14315, 14316, 1, 0, 0, 0, 14316, 14317, 5, 352, 0, 0, 14317, 14322, 3, 436, 218, 0, 14318, 14319, 5, 2453, 0, 0, 14319, 14321, 3, 436, 218, 0, 14320, 14318, 1, 0, 0, 0, 14321, 14324, 1, 0, 0, 0, 14322, 14320, 1, 0, 0, 0, 14322, 14323, 1, 0, 0, 0, 14323, 14329, 1, 0, 0, 0, 14324, 14322, 1, 0, 0, 0, 14325, 14329, 3, 1502, 751, 0, 14326, 14329, 3, 1504, 752, 0, 14327, 14329, 3, 1506, 753, 0, 14328, 14310, 1, 0, 0, 0, 14328, 14314, 1, 0, 0, 0, 14328, 14325, 1, 0, 0, 0, 14328, 14326, 1, 0, 0, 0, 14328, 14327, 1, 0, 0, 0, 14329, 1491, 1, 0, 0, 0, 14330, 14331, 5, 499, 0, 0, 14331, 14332, 5, 1409, 0, 0, 14332, 14345, 5, 350, 0, 0, 14333, 14335, 5, 1642, 0, 0, 14334, 14336, 3, 1494, 747, 0, 14335, 14334, 1, 0, 0, 0, 14335, 14336, 1, 0, 0, 0, 14336, 14339, 1, 0, 0, 0, 14337, 14338, 5, 1949, 0, 0, 14338, 14340, 3, 1498, 749, 0, 14339, 14337, 1, 0, 0, 0, 14339, 14340, 1, 0, 0, 0, 14340, 14343, 1, 0, 0, 0, 14341, 14342, 5, 1800, 0, 0, 14342, 14344, 3, 1498, 749, 0, 14343, 14341, 1, 0, 0, 0, 14343, 14344, 1, 0, 0, 0, 14344, 14346, 1, 0, 0, 0, 14345, 14333, 1, 0, 0, 0, 14345, 14346, 1, 0, 0, 0, 14346, 14348, 1, 0, 0, 0, 14347, 14349, 3, 1500, 750, 0, 14348, 14347, 1, 0, 0, 0, 14348, 14349, 1, 0, 0, 0, 14349, 1493, 1, 0, 0, 0, 14350, 14351, 5, 590, 0, 0, 14351, 14364, 5, 2472, 0, 0, 14352, 14353, 5, 2447, 0, 0, 14353, 14358, 3, 1496, 748, 0, 14354, 14355, 5, 2453, 0, 0, 14355, 14357, 3, 1496, 748, 0, 14356, 14354, 1, 0, 0, 0, 14357, 14360, 1, 0, 0, 0, 14358, 14356, 1, 0, 0, 0, 14358, 14359, 1, 0, 0, 0, 14359, 14361, 1, 0, 0, 0, 14360, 14358, 1, 0, 0, 0, 14361, 14362, 5, 2448, 0, 0, 14362, 14365, 1, 0, 0, 0, 14363, 14365, 5, 1133, 0, 0, 14364, 14352, 1, 0, 0, 0, 14364, 14363, 1, 0, 0, 0, 14365, 1495, 1, 0, 0, 0, 14366, 14369, 5, 2443, 0, 0, 14367, 14368, 5, 2453, 0, 0, 14368, 14370, 5, 2443, 0, 0, 14369, 14367, 1, 0, 0, 0, 14369, 14370, 1, 0, 0, 0, 14370, 1497, 1, 0, 0, 0, 14371, 14375, 5, 353, 0, 0, 14372, 14373, 5, 1699, 0, 0, 14373, 14376, 3, 1176, 588, 0, 14374, 14376, 3, 922, 461, 0, 14375, 14372, 1, 0, 0, 0, 14375, 14374, 1, 0, 0, 0, 14376, 14377, 1, 0, 0, 0, 14377, 14375, 1, 0, 0, 0, 14377, 14378, 1, 0, 0, 0, 14378, 1499, 1, 0, 0, 0, 14379, 14380, 5, 873, 0, 0, 14380, 14381, 5, 2178, 0, 0, 14381, 14382, 7, 100, 0, 0, 14382, 1501, 1, 0, 0, 0, 14383, 14384, 5, 389, 0, 0, 14384, 14385, 5, 2080, 0, 0, 14385, 14388, 3, 1656, 828, 0, 14386, 14387, 5, 352, 0, 0, 14387, 14389, 3, 918, 459, 0, 14388, 14386, 1, 0, 0, 0, 14388, 14389, 1, 0, 0, 0, 14389, 14391, 1, 0, 0, 0, 14390, 14392, 3, 888, 444, 0, 14391, 14390, 1, 0, 0, 0, 14391, 14392, 1, 0, 0, 0, 14392, 1503, 1, 0, 0, 0, 14393, 14395, 7, 101, 0, 0, 14394, 14393, 1, 0, 0, 0, 14394, 14395, 1, 0, 0, 0, 14395, 14396, 1, 0, 0, 0, 14396, 14404, 5, 389, 0, 0, 14397, 14398, 5, 2092, 0, 0, 14398, 14405, 5, 2080, 0, 0, 14399, 14400, 5, 873, 0, 0, 14400, 14401, 5, 2092, 0, 0, 14401, 14402, 5, 2080, 0, 0, 14402, 14403, 5, 620, 0, 0, 14403, 14405, 7, 185, 0, 0, 14404, 14397, 1, 0, 0, 0, 14404, 14399, 1, 0, 0, 0, 14405, 14406, 1, 0, 0, 0, 14406, 14416, 3, 1656, 828, 0, 14407, 14408, 5, 2089, 0, 0, 14408, 14413, 3, 436, 218, 0, 14409, 14410, 5, 2453, 0, 0, 14410, 14412, 3, 436, 218, 0, 14411, 14409, 1, 0, 0, 0, 14412, 14415, 1, 0, 0, 0, 14413, 14411, 1, 0, 0, 0, 14413, 14414, 1, 0, 0, 0, 14414, 14417, 1, 0, 0, 0, 14415, 14413, 1, 0, 0, 0, 14416, 14407, 1, 0, 0, 0, 14416, 14417, 1, 0, 0, 0, 14417, 14419, 1, 0, 0, 0, 14418, 14420, 3, 888, 444, 0, 14419, 14418, 1, 0, 0, 0, 14419, 14420, 1, 0, 0, 0, 14420, 1505, 1, 0, 0, 0, 14421, 14423, 7, 101, 0, 0, 14422, 14421, 1, 0, 0, 0, 14422, 14423, 1, 0, 0, 0, 14423, 14424, 1, 0, 0, 0, 14424, 14425, 5, 2178, 0, 0, 14425, 14426, 5, 2080, 0, 0, 14426, 14436, 3, 1656, 828, 0, 14427, 14428, 5, 352, 0, 0, 14428, 14433, 3, 436, 218, 0, 14429, 14430, 5, 2453, 0, 0, 14430, 14432, 3, 436, 218, 0, 14431, 14429, 1, 0, 0, 0, 14432, 14435, 1, 0, 0, 0, 14433, 14431, 1, 0, 0, 0, 14433, 14434, 1, 0, 0, 0, 14434, 14437, 1, 0, 0, 0, 14435, 14433, 1, 0, 0, 0, 14436, 14427, 1, 0, 0, 0, 14436, 14437, 1, 0, 0, 0, 14437, 1507, 1, 0, 0, 0, 14438, 14439, 5, 469, 0, 0, 14439, 14442, 5, 350, 0, 0, 14440, 14441, 5, 705, 0, 0, 14441, 14443, 5, 103, 0, 0, 14442, 14440, 1, 0, 0, 0, 14442, 14443, 1, 0, 0, 0, 14443, 14445, 1, 0, 0, 0, 14444, 14446, 5, 1157, 0, 0, 14445, 14444, 1, 0, 0, 0, 14445, 14446, 1, 0, 0, 0, 14446, 1509, 1, 0, 0, 0, 14447, 14449, 5, 321, 0, 0, 14448, 14450, 5, 1679, 0, 0, 14449, 14448, 1, 0, 0, 0, 14449, 14450, 1, 0, 0, 0, 14450, 14452, 1, 0, 0, 0, 14451, 14453, 5, 1473, 0, 0, 14452, 14451, 1, 0, 0, 0, 14452, 14453, 1, 0, 0, 0, 14453, 14454, 1, 0, 0, 0, 14454, 14455, 5, 350, 0, 0, 14455, 14456, 5, 861, 0, 0, 14456, 14472, 3, 2334, 1167, 0, 14457, 14458, 5, 280, 0, 0, 14458, 14467, 5, 2141, 0, 0, 14459, 14468, 5, 341, 0, 0, 14460, 14461, 3, 2354, 1177, 0, 14461, 14462, 5, 685, 0, 0, 14462, 14463, 5, 160, 0, 0, 14463, 14465, 3, 1478, 739, 0, 14464, 14466, 3, 1480, 740, 0, 14465, 14464, 1, 0, 0, 0, 14465, 14466, 1, 0, 0, 0, 14466, 14468, 1, 0, 0, 0, 14467, 14459, 1, 0, 0, 0, 14467, 14460, 1, 0, 0, 0, 14468, 14471, 1, 0, 0, 0, 14469, 14471, 3, 1480, 740, 0, 14470, 14457, 1, 0, 0, 0, 14470, 14469, 1, 0, 0, 0, 14471, 14474, 1, 0, 0, 0, 14472, 14470, 1, 0, 0, 0, 14472, 14473, 1, 0, 0, 0, 14473, 14477, 1, 0, 0, 0, 14474, 14472, 1, 0, 0, 0, 14475, 14476, 5, 2246, 0, 0, 14476, 14478, 5, 2443, 0, 0, 14477, 14475, 1, 0, 0, 0, 14477, 14478, 1, 0, 0, 0, 14478, 1511, 1, 0, 0, 0, 14479, 14481, 5, 469, 0, 0, 14480, 14482, 5, 1473, 0, 0, 14481, 14480, 1, 0, 0, 0, 14481, 14482, 1, 0, 0, 0, 14482, 14483, 1, 0, 0, 0, 14483, 14484, 5, 350, 0, 0, 14484, 14485, 5, 861, 0, 0, 14485, 14486, 3, 2334, 1167, 0, 14486, 1513, 1, 0, 0, 0, 14487, 14488, 5, 42, 0, 0, 14488, 14489, 5, 2080, 0, 0, 14489, 14490, 5, 1671, 0, 0, 14490, 14491, 3, 2404, 1202, 0, 14491, 14492, 3, 1516, 758, 0, 14492, 1515, 1, 0, 0, 0, 14493, 14521, 3, 904, 452, 0, 14494, 14495, 5, 954, 0, 0, 14495, 14496, 5, 558, 0, 0, 14496, 14521, 3, 1176, 588, 0, 14497, 14498, 5, 1567, 0, 0, 14498, 14521, 3, 1176, 588, 0, 14499, 14521, 5, 228, 0, 0, 14500, 14501, 5, 1684, 0, 0, 14501, 14504, 5, 1714, 0, 0, 14502, 14503, 5, 814, 0, 0, 14503, 14505, 3, 1176, 588, 0, 14504, 14502, 1, 0, 0, 0, 14504, 14505, 1, 0, 0, 0, 14505, 14521, 1, 0, 0, 0, 14506, 14507, 5, 1559, 0, 0, 14507, 14508, 5, 2141, 0, 0, 14508, 14521, 3, 2404, 1202, 0, 14509, 14510, 7, 171, 0, 0, 14510, 14521, 5, 102, 0, 0, 14511, 14521, 3, 866, 433, 0, 14512, 14521, 3, 868, 434, 0, 14513, 14521, 3, 870, 435, 0, 14514, 14521, 3, 874, 437, 0, 14515, 14521, 3, 922, 461, 0, 14516, 14521, 3, 876, 438, 0, 14517, 14521, 3, 896, 448, 0, 14518, 14521, 3, 1518, 759, 0, 14519, 14521, 3, 1464, 732, 0, 14520, 14493, 1, 0, 0, 0, 14520, 14494, 1, 0, 0, 0, 14520, 14497, 1, 0, 0, 0, 14520, 14499, 1, 0, 0, 0, 14520, 14500, 1, 0, 0, 0, 14520, 14506, 1, 0, 0, 0, 14520, 14509, 1, 0, 0, 0, 14520, 14511, 1, 0, 0, 0, 14520, 14512, 1, 0, 0, 0, 14520, 14513, 1, 0, 0, 0, 14520, 14514, 1, 0, 0, 0, 14520, 14515, 1, 0, 0, 0, 14520, 14516, 1, 0, 0, 0, 14520, 14517, 1, 0, 0, 0, 14520, 14518, 1, 0, 0, 0, 14520, 14519, 1, 0, 0, 0, 14521, 1517, 1, 0, 0, 0, 14522, 14547, 5, 506, 0, 0, 14523, 14529, 5, 1243, 0, 0, 14524, 14526, 3, 884, 442, 0, 14525, 14524, 1, 0, 0, 0, 14525, 14526, 1, 0, 0, 0, 14526, 14527, 1, 0, 0, 0, 14527, 14530, 5, 505, 0, 0, 14528, 14530, 5, 387, 0, 0, 14529, 14525, 1, 0, 0, 0, 14529, 14528, 1, 0, 0, 0, 14530, 14548, 1, 0, 0, 0, 14531, 14537, 5, 1256, 0, 0, 14532, 14534, 3, 884, 442, 0, 14533, 14532, 1, 0, 0, 0, 14533, 14534, 1, 0, 0, 0, 14534, 14535, 1, 0, 0, 0, 14535, 14538, 7, 186, 0, 0, 14536, 14538, 5, 387, 0, 0, 14537, 14533, 1, 0, 0, 0, 14537, 14536, 1, 0, 0, 0, 14538, 14540, 1, 0, 0, 0, 14539, 14541, 3, 1520, 760, 0, 14540, 14539, 1, 0, 0, 0, 14540, 14541, 1, 0, 0, 0, 14541, 14548, 1, 0, 0, 0, 14542, 14543, 5, 597, 0, 0, 14543, 14545, 7, 187, 0, 0, 14544, 14546, 3, 1520, 760, 0, 14545, 14544, 1, 0, 0, 0, 14545, 14546, 1, 0, 0, 0, 14546, 14548, 1, 0, 0, 0, 14547, 14523, 1, 0, 0, 0, 14547, 14531, 1, 0, 0, 0, 14547, 14542, 1, 0, 0, 0, 14548, 1519, 1, 0, 0, 0, 14549, 14550, 5, 590, 0, 0, 14550, 14551, 5, 2472, 0, 0, 14551, 14552, 5, 2447, 0, 0, 14552, 14553, 5, 2443, 0, 0, 14553, 14554, 5, 2453, 0, 0, 14554, 14561, 5, 2443, 0, 0, 14555, 14556, 5, 2453, 0, 0, 14556, 14557, 5, 2443, 0, 0, 14557, 14558, 5, 2453, 0, 0, 14558, 14560, 5, 2443, 0, 0, 14559, 14555, 1, 0, 0, 0, 14560, 14563, 1, 0, 0, 0, 14561, 14559, 1, 0, 0, 0, 14561, 14562, 1, 0, 0, 0, 14562, 14564, 1, 0, 0, 0, 14563, 14561, 1, 0, 0, 0, 14564, 14566, 5, 2448, 0, 0, 14565, 14567, 5, 814, 0, 0, 14566, 14565, 1, 0, 0, 0, 14566, 14567, 1, 0, 0, 0, 14567, 1521, 1, 0, 0, 0, 14568, 14569, 5, 42, 0, 0, 14569, 14570, 5, 1593, 0, 0, 14570, 14571, 3, 2308, 1154, 0, 14571, 14573, 3, 1524, 762, 0, 14572, 14574, 3, 766, 383, 0, 14573, 14572, 1, 0, 0, 0, 14573, 14574, 1, 0, 0, 0, 14574, 1523, 1, 0, 0, 0, 14575, 14576, 5, 1204, 0, 0, 14576, 14595, 5, 685, 0, 0, 14577, 14592, 5, 685, 0, 0, 14578, 14579, 5, 160, 0, 0, 14579, 14593, 3, 2402, 1201, 0, 14580, 14581, 5, 2246, 0, 0, 14581, 14584, 3, 2402, 1201, 0, 14582, 14583, 5, 2440, 0, 0, 14583, 14585, 3, 2404, 1202, 0, 14584, 14582, 1, 0, 0, 0, 14584, 14585, 1, 0, 0, 0, 14585, 14593, 1, 0, 0, 0, 14586, 14593, 5, 561, 0, 0, 14587, 14590, 5, 643, 0, 0, 14588, 14589, 5, 69, 0, 0, 14589, 14591, 5, 2443, 0, 0, 14590, 14588, 1, 0, 0, 0, 14590, 14591, 1, 0, 0, 0, 14591, 14593, 1, 0, 0, 0, 14592, 14578, 1, 0, 0, 0, 14592, 14580, 1, 0, 0, 0, 14592, 14586, 1, 0, 0, 0, 14592, 14587, 1, 0, 0, 0, 14593, 14595, 1, 0, 0, 0, 14594, 14575, 1, 0, 0, 0, 14594, 14577, 1, 0, 0, 0, 14595, 1525, 1, 0, 0, 0, 14596, 14597, 5, 42, 0, 0, 14597, 14598, 5, 2083, 0, 0, 14598, 14602, 3, 2342, 1171, 0, 14599, 14601, 3, 1528, 764, 0, 14600, 14599, 1, 0, 0, 0, 14601, 14604, 1, 0, 0, 0, 14602, 14600, 1, 0, 0, 0, 14602, 14603, 1, 0, 0, 0, 14603, 14611, 1, 0, 0, 0, 14604, 14602, 1, 0, 0, 0, 14605, 14612, 1, 0, 0, 0, 14606, 14612, 3, 1530, 765, 0, 14607, 14612, 3, 1702, 851, 0, 14608, 14612, 3, 1604, 802, 0, 14609, 14612, 3, 1532, 766, 0, 14610, 14612, 3, 1594, 797, 0, 14611, 14605, 1, 0, 0, 0, 14611, 14606, 1, 0, 0, 0, 14611, 14607, 1, 0, 0, 0, 14611, 14608, 1, 0, 0, 0, 14611, 14609, 1, 0, 0, 0, 14611, 14610, 1, 0, 0, 0, 14612, 14625, 1, 0, 0, 0, 14613, 14622, 3, 1584, 792, 0, 14614, 14619, 3, 1308, 654, 0, 14615, 14616, 5, 2083, 0, 0, 14616, 14620, 5, 881, 0, 0, 14617, 14618, 5, 38, 0, 0, 14618, 14620, 5, 2156, 0, 0, 14619, 14615, 1, 0, 0, 0, 14619, 14617, 1, 0, 0, 0, 14620, 14622, 1, 0, 0, 0, 14621, 14613, 1, 0, 0, 0, 14621, 14614, 1, 0, 0, 0, 14622, 14623, 1, 0, 0, 0, 14623, 14621, 1, 0, 0, 0, 14623, 14624, 1, 0, 0, 0, 14624, 14626, 1, 0, 0, 0, 14625, 14621, 1, 0, 0, 0, 14625, 14626, 1, 0, 0, 0, 14626, 1527, 1, 0, 0, 0, 14627, 14629, 5, 1137, 0, 0, 14628, 14627, 1, 0, 0, 0, 14628, 14629, 1, 0, 0, 0, 14629, 14630, 1, 0, 0, 0, 14630, 14631, 5, 2408, 0, 0, 14631, 14632, 5, 620, 0, 0, 14632, 14633, 7, 188, 0, 0, 14633, 1529, 1, 0, 0, 0, 14634, 14652, 3, 1562, 781, 0, 14635, 14636, 5, 1559, 0, 0, 14636, 14637, 5, 2141, 0, 0, 14637, 14652, 3, 2342, 1171, 0, 14638, 14652, 3, 1288, 644, 0, 14639, 14640, 5, 1505, 0, 0, 14640, 14652, 5, 1258, 0, 0, 14641, 14642, 5, 1505, 0, 0, 14642, 14652, 5, 2313, 0, 0, 14643, 14644, 5, 1550, 0, 0, 14644, 14652, 5, 2443, 0, 0, 14645, 14647, 5, 1137, 0, 0, 14646, 14645, 1, 0, 0, 0, 14646, 14647, 1, 0, 0, 0, 14647, 14648, 1, 0, 0, 0, 14648, 14649, 5, 1606, 0, 0, 14649, 14652, 5, 63, 0, 0, 14650, 14652, 3, 2246, 1123, 0, 14651, 14634, 1, 0, 0, 0, 14651, 14635, 1, 0, 0, 0, 14651, 14638, 1, 0, 0, 0, 14651, 14639, 1, 0, 0, 0, 14651, 14641, 1, 0, 0, 0, 14651, 14643, 1, 0, 0, 0, 14651, 14646, 1, 0, 0, 0, 14651, 14650, 1, 0, 0, 0, 14652, 1531, 1, 0, 0, 0, 14653, 14665, 3, 1534, 767, 0, 14654, 14665, 3, 1536, 768, 0, 14655, 14665, 3, 1538, 769, 0, 14656, 14665, 3, 1540, 770, 0, 14657, 14665, 3, 1542, 771, 0, 14658, 14665, 3, 1544, 772, 0, 14659, 14665, 3, 1546, 773, 0, 14660, 14665, 3, 1548, 774, 0, 14661, 14665, 3, 1550, 775, 0, 14662, 14665, 3, 1552, 776, 0, 14663, 14665, 3, 1556, 778, 0, 14664, 14653, 1, 0, 0, 0, 14664, 14654, 1, 0, 0, 0, 14664, 14655, 1, 0, 0, 0, 14664, 14656, 1, 0, 0, 0, 14664, 14657, 1, 0, 0, 0, 14664, 14658, 1, 0, 0, 0, 14664, 14659, 1, 0, 0, 0, 14664, 14660, 1, 0, 0, 0, 14664, 14661, 1, 0, 0, 0, 14664, 14662, 1, 0, 0, 0, 14664, 14663, 1, 0, 0, 0, 14665, 1533, 1, 0, 0, 0, 14666, 14683, 5, 21, 0, 0, 14667, 14684, 3, 1140, 570, 0, 14668, 14684, 3, 1142, 571, 0, 14669, 14671, 5, 1348, 0, 0, 14670, 14672, 3, 1696, 848, 0, 14671, 14670, 1, 0, 0, 0, 14671, 14672, 1, 0, 0, 0, 14672, 14675, 1, 0, 0, 0, 14673, 14674, 5, 2080, 0, 0, 14674, 14676, 3, 1656, 828, 0, 14675, 14673, 1, 0, 0, 0, 14675, 14676, 1, 0, 0, 0, 14676, 14678, 1, 0, 0, 0, 14677, 14679, 3, 1600, 800, 0, 14678, 14677, 1, 0, 0, 0, 14678, 14679, 1, 0, 0, 0, 14679, 14681, 1, 0, 0, 0, 14680, 14682, 5, 2203, 0, 0, 14681, 14680, 1, 0, 0, 0, 14681, 14682, 1, 0, 0, 0, 14682, 14684, 1, 0, 0, 0, 14683, 14667, 1, 0, 0, 0, 14683, 14668, 1, 0, 0, 0, 14683, 14669, 1, 0, 0, 0, 14684, 1535, 1, 0, 0, 0, 14685, 14688, 5, 469, 0, 0, 14686, 14689, 3, 1558, 779, 0, 14687, 14689, 3, 1560, 780, 0, 14688, 14686, 1, 0, 0, 0, 14688, 14687, 1, 0, 0, 0, 14689, 14694, 1, 0, 0, 0, 14690, 14692, 3, 1572, 786, 0, 14691, 14693, 3, 928, 464, 0, 14692, 14691, 1, 0, 0, 0, 14692, 14693, 1, 0, 0, 0, 14693, 14695, 1, 0, 0, 0, 14694, 14690, 1, 0, 0, 0, 14694, 14695, 1, 0, 0, 0, 14695, 1537, 1, 0, 0, 0, 14696, 14697, 5, 946, 0, 0, 14697, 14698, 5, 1348, 0, 0, 14698, 14699, 3, 1696, 848, 0, 14699, 14700, 5, 49, 0, 0, 14700, 14701, 3, 1696, 848, 0, 14701, 14702, 5, 779, 0, 0, 14702, 14703, 5, 1348, 0, 0, 14703, 14704, 3, 1696, 848, 0, 14704, 1539, 1, 0, 0, 0, 14705, 14728, 5, 980, 0, 0, 14706, 14707, 7, 189, 0, 0, 14707, 14710, 3, 1696, 848, 0, 14708, 14709, 7, 9, 0, 0, 14709, 14711, 3, 1168, 584, 0, 14710, 14708, 1, 0, 0, 0, 14710, 14711, 1, 0, 0, 0, 14711, 14714, 1, 0, 0, 0, 14712, 14713, 5, 21, 0, 0, 14713, 14715, 3, 1156, 578, 0, 14714, 14712, 1, 0, 0, 0, 14714, 14715, 1, 0, 0, 0, 14715, 14722, 1, 0, 0, 0, 14716, 14718, 5, 1511, 0, 0, 14717, 14716, 1, 0, 0, 0, 14717, 14718, 1, 0, 0, 0, 14718, 14719, 1, 0, 0, 0, 14719, 14720, 5, 2203, 0, 0, 14720, 14721, 5, 873, 0, 0, 14721, 14723, 5, 714, 0, 0, 14722, 14717, 1, 0, 0, 0, 14722, 14723, 1, 0, 0, 0, 14723, 14725, 1, 0, 0, 0, 14724, 14726, 3, 1288, 644, 0, 14725, 14724, 1, 0, 0, 0, 14725, 14726, 1, 0, 0, 0, 14726, 14729, 1, 0, 0, 0, 14727, 14729, 3, 1116, 558, 0, 14728, 14706, 1, 0, 0, 0, 14728, 14727, 1, 0, 0, 0, 14729, 1541, 1, 0, 0, 0, 14730, 14731, 5, 1717, 0, 0, 14731, 14777, 3, 1558, 779, 0, 14732, 14733, 5, 82, 0, 0, 14733, 14734, 5, 2447, 0, 0, 14734, 14739, 3, 2186, 1093, 0, 14735, 14736, 5, 2453, 0, 0, 14736, 14738, 3, 2186, 1093, 0, 14737, 14735, 1, 0, 0, 0, 14738, 14741, 1, 0, 0, 0, 14739, 14737, 1, 0, 0, 0, 14739, 14740, 1, 0, 0, 0, 14740, 14742, 1, 0, 0, 0, 14741, 14739, 1, 0, 0, 0, 14742, 14743, 5, 2448, 0, 0, 14743, 14744, 5, 779, 0, 0, 14744, 14745, 5, 2447, 0, 0, 14745, 14750, 3, 1140, 570, 0, 14746, 14747, 5, 2453, 0, 0, 14747, 14749, 3, 1140, 570, 0, 14748, 14746, 1, 0, 0, 0, 14749, 14752, 1, 0, 0, 0, 14750, 14748, 1, 0, 0, 0, 14750, 14751, 1, 0, 0, 0, 14751, 14753, 1, 0, 0, 0, 14752, 14750, 1, 0, 0, 0, 14753, 14754, 5, 2448, 0, 0, 14754, 14778, 1, 0, 0, 0, 14755, 14756, 5, 779, 0, 0, 14756, 14773, 5, 2447, 0, 0, 14757, 14762, 3, 1140, 570, 0, 14758, 14759, 5, 2453, 0, 0, 14759, 14761, 3, 1140, 570, 0, 14760, 14758, 1, 0, 0, 0, 14761, 14764, 1, 0, 0, 0, 14762, 14760, 1, 0, 0, 0, 14762, 14763, 1, 0, 0, 0, 14763, 14774, 1, 0, 0, 0, 14764, 14762, 1, 0, 0, 0, 14765, 14770, 3, 1142, 571, 0, 14766, 14767, 5, 2453, 0, 0, 14767, 14769, 3, 1142, 571, 0, 14768, 14766, 1, 0, 0, 0, 14769, 14772, 1, 0, 0, 0, 14770, 14768, 1, 0, 0, 0, 14770, 14771, 1, 0, 0, 0, 14771, 14774, 1, 0, 0, 0, 14772, 14770, 1, 0, 0, 0, 14773, 14757, 1, 0, 0, 0, 14773, 14765, 1, 0, 0, 0, 14774, 14775, 1, 0, 0, 0, 14775, 14776, 5, 2448, 0, 0, 14776, 14778, 1, 0, 0, 0, 14777, 14732, 1, 0, 0, 0, 14777, 14755, 1, 0, 0, 0, 14778, 14782, 1, 0, 0, 0, 14779, 14783, 3, 1574, 787, 0, 14780, 14783, 3, 1572, 786, 0, 14781, 14783, 5, 1256, 0, 0, 14782, 14779, 1, 0, 0, 0, 14782, 14780, 1, 0, 0, 0, 14782, 14781, 1, 0, 0, 0, 14782, 14783, 1, 0, 0, 0, 14783, 1543, 1, 0, 0, 0, 14784, 14787, 5, 2159, 0, 0, 14785, 14788, 3, 1558, 779, 0, 14786, 14788, 3, 1560, 780, 0, 14787, 14785, 1, 0, 0, 0, 14787, 14786, 1, 0, 0, 0, 14788, 14797, 1, 0, 0, 0, 14789, 14791, 5, 469, 0, 0, 14790, 14792, 5, 38, 0, 0, 14791, 14790, 1, 0, 0, 0, 14791, 14792, 1, 0, 0, 0, 14792, 14795, 1, 0, 0, 0, 14793, 14795, 5, 1587, 0, 0, 14794, 14789, 1, 0, 0, 0, 14794, 14793, 1, 0, 0, 0, 14794, 14795, 1, 0, 0, 0, 14795, 14796, 1, 0, 0, 0, 14796, 14798, 5, 1762, 0, 0, 14797, 14794, 1, 0, 0, 0, 14797, 14798, 1, 0, 0, 0, 14798, 14800, 1, 0, 0, 0, 14799, 14801, 5, 179, 0, 0, 14800, 14799, 1, 0, 0, 0, 14800, 14801, 1, 0, 0, 0, 14801, 14806, 1, 0, 0, 0, 14802, 14804, 3, 1572, 786, 0, 14803, 14805, 3, 928, 464, 0, 14804, 14803, 1, 0, 0, 0, 14804, 14805, 1, 0, 0, 0, 14805, 14807, 1, 0, 0, 0, 14806, 14802, 1, 0, 0, 0, 14806, 14807, 1, 0, 0, 0, 14807, 1545, 1, 0, 0, 0, 14808, 14809, 5, 538, 0, 0, 14809, 14810, 5, 1348, 0, 0, 14810, 14811, 3, 1696, 848, 0, 14811, 14812, 5, 2308, 0, 0, 14812, 14813, 5, 2083, 0, 0, 14813, 14816, 3, 2342, 1171, 0, 14814, 14815, 7, 110, 0, 0, 14815, 14817, 5, 714, 0, 0, 14816, 14814, 1, 0, 0, 0, 14816, 14817, 1, 0, 0, 0, 14817, 14820, 1, 0, 0, 0, 14818, 14819, 7, 2, 0, 0, 14819, 14821, 5, 2255, 0, 0, 14820, 14818, 1, 0, 0, 0, 14820, 14821, 1, 0, 0, 0, 14821, 1547, 1, 0, 0, 0, 14822, 14823, 5, 228, 0, 0, 14823, 14825, 5, 1348, 0, 0, 14824, 14826, 3, 928, 464, 0, 14825, 14824, 1, 0, 0, 0, 14825, 14826, 1, 0, 0, 0, 14826, 14830, 1, 0, 0, 0, 14827, 14828, 3, 1310, 655, 0, 14828, 14829, 5, 224, 0, 0, 14829, 14831, 1, 0, 0, 0, 14830, 14827, 1, 0, 0, 0, 14830, 14831, 1, 0, 0, 0, 14831, 1549, 1, 0, 0, 0, 14832, 14833, 5, 1671, 0, 0, 14833, 14834, 5, 776, 0, 0, 14834, 14837, 5, 2447, 0, 0, 14835, 14838, 3, 2394, 1197, 0, 14836, 14838, 3, 2078, 1039, 0, 14837, 14835, 1, 0, 0, 0, 14837, 14836, 1, 0, 0, 0, 14837, 14838, 1, 0, 0, 0, 14838, 14839, 1, 0, 0, 0, 14839, 14840, 5, 2448, 0, 0, 14840, 1551, 1, 0, 0, 0, 14841, 14856, 5, 992, 0, 0, 14842, 14845, 3, 1558, 779, 0, 14843, 14844, 5, 911, 0, 0, 14844, 14846, 5, 2083, 0, 0, 14845, 14843, 1, 0, 0, 0, 14845, 14846, 1, 0, 0, 0, 14846, 14847, 1, 0, 0, 0, 14847, 14848, 3, 1170, 585, 0, 14848, 14857, 1, 0, 0, 0, 14849, 14851, 3, 1560, 780, 0, 14850, 14852, 3, 1088, 544, 0, 14851, 14850, 1, 0, 0, 0, 14851, 14852, 1, 0, 0, 0, 14852, 14854, 1, 0, 0, 0, 14853, 14855, 3, 1172, 586, 0, 14854, 14853, 1, 0, 0, 0, 14854, 14855, 1, 0, 0, 0, 14855, 14857, 1, 0, 0, 0, 14856, 14842, 1, 0, 0, 0, 14856, 14849, 1, 0, 0, 0, 14857, 14867, 1, 0, 0, 0, 14858, 14866, 3, 1554, 777, 0, 14859, 14866, 3, 1572, 786, 0, 14860, 14866, 3, 928, 464, 0, 14861, 14862, 3, 1310, 655, 0, 14862, 14863, 5, 224, 0, 0, 14863, 14866, 1, 0, 0, 0, 14864, 14866, 5, 1256, 0, 0, 14865, 14858, 1, 0, 0, 0, 14865, 14859, 1, 0, 0, 0, 14865, 14860, 1, 0, 0, 0, 14865, 14861, 1, 0, 0, 0, 14865, 14864, 1, 0, 0, 0, 14866, 14869, 1, 0, 0, 0, 14867, 14865, 1, 0, 0, 0, 14867, 14868, 1, 0, 0, 0, 14868, 1553, 1, 0, 0, 0, 14869, 14867, 1, 0, 0, 0, 14870, 14871, 5, 705, 0, 0, 14871, 14872, 5, 1607, 0, 0, 14872, 14873, 3, 2272, 1136, 0, 14873, 1555, 1, 0, 0, 0, 14874, 14877, 5, 1559, 0, 0, 14875, 14878, 3, 1558, 779, 0, 14876, 14878, 3, 1560, 780, 0, 14877, 14875, 1, 0, 0, 0, 14877, 14876, 1, 0, 0, 0, 14878, 14879, 1, 0, 0, 0, 14879, 14880, 5, 2141, 0, 0, 14880, 14881, 3, 1696, 848, 0, 14881, 1557, 1, 0, 0, 0, 14882, 14917, 7, 190, 0, 0, 14883, 14888, 3, 1696, 848, 0, 14884, 14885, 5, 2453, 0, 0, 14885, 14887, 3, 1696, 848, 0, 14886, 14884, 1, 0, 0, 0, 14887, 14890, 1, 0, 0, 0, 14888, 14886, 1, 0, 0, 0, 14888, 14889, 1, 0, 0, 0, 14889, 14918, 1, 0, 0, 0, 14890, 14888, 1, 0, 0, 0, 14891, 14892, 5, 2447, 0, 0, 14892, 14897, 3, 1696, 848, 0, 14893, 14894, 5, 2453, 0, 0, 14894, 14896, 3, 1696, 848, 0, 14895, 14893, 1, 0, 0, 0, 14896, 14899, 1, 0, 0, 0, 14897, 14895, 1, 0, 0, 0, 14897, 14898, 1, 0, 0, 0, 14898, 14900, 1, 0, 0, 0, 14899, 14897, 1, 0, 0, 0, 14900, 14901, 5, 2448, 0, 0, 14901, 14918, 1, 0, 0, 0, 14902, 14904, 5, 620, 0, 0, 14903, 14905, 5, 2447, 0, 0, 14904, 14903, 1, 0, 0, 0, 14904, 14905, 1, 0, 0, 0, 14905, 14906, 1, 0, 0, 0, 14906, 14911, 3, 686, 343, 0, 14907, 14908, 5, 2453, 0, 0, 14908, 14910, 3, 686, 343, 0, 14909, 14907, 1, 0, 0, 0, 14910, 14913, 1, 0, 0, 0, 14911, 14909, 1, 0, 0, 0, 14911, 14912, 1, 0, 0, 0, 14912, 14915, 1, 0, 0, 0, 14913, 14911, 1, 0, 0, 0, 14914, 14916, 5, 2448, 0, 0, 14915, 14914, 1, 0, 0, 0, 14915, 14916, 1, 0, 0, 0, 14916, 14918, 1, 0, 0, 0, 14917, 14883, 1, 0, 0, 0, 14917, 14891, 1, 0, 0, 0, 14917, 14902, 1, 0, 0, 0, 14918, 1559, 1, 0, 0, 0, 14919, 14951, 7, 191, 0, 0, 14920, 14923, 3, 1696, 848, 0, 14921, 14922, 5, 2207, 0, 0, 14922, 14924, 5, 714, 0, 0, 14923, 14921, 1, 0, 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14952, 1, 0, 0, 0, 14925, 14926, 5, 2447, 0, 0, 14926, 14931, 3, 1696, 848, 0, 14927, 14928, 5, 2453, 0, 0, 14928, 14930, 3, 1696, 848, 0, 14929, 14927, 1, 0, 0, 0, 14930, 14933, 1, 0, 0, 0, 14931, 14929, 1, 0, 0, 0, 14931, 14932, 1, 0, 0, 0, 14932, 14934, 1, 0, 0, 0, 14933, 14931, 1, 0, 0, 0, 14934, 14935, 5, 2448, 0, 0, 14935, 14952, 1, 0, 0, 0, 14936, 14938, 5, 620, 0, 0, 14937, 14939, 5, 2447, 0, 0, 14938, 14937, 1, 0, 0, 0, 14938, 14939, 1, 0, 0, 0, 14939, 14940, 1, 0, 0, 0, 14940, 14945, 3, 688, 344, 0, 14941, 14942, 5, 2453, 0, 0, 14942, 14944, 3, 688, 344, 0, 14943, 14941, 1, 0, 0, 0, 14944, 14947, 1, 0, 0, 0, 14945, 14943, 1, 0, 0, 0, 14945, 14946, 1, 0, 0, 0, 14946, 14949, 1, 0, 0, 0, 14947, 14945, 1, 0, 0, 0, 14948, 14950, 5, 2448, 0, 0, 14949, 14948, 1, 0, 0, 0, 14949, 14950, 1, 0, 0, 0, 14950, 14952, 1, 0, 0, 0, 14951, 14920, 1, 0, 0, 0, 14951, 14925, 1, 0, 0, 0, 14951, 14936, 1, 0, 0, 0, 14952, 1561, 1, 0, 0, 0, 14953, 14973, 3, 1194, 597, 0, 14954, 14973, 3, 886, 443, 0, 14955, 14973, 3, 1178, 589, 0, 14956, 14973, 3, 1180, 590, 0, 14957, 14973, 3, 1278, 639, 0, 14958, 14973, 3, 1284, 642, 0, 14959, 14973, 3, 1286, 643, 0, 14960, 14973, 7, 109, 0, 0, 14961, 14962, 5, 1579, 0, 0, 14962, 14963, 5, 2447, 0, 0, 14963, 14964, 5, 977, 0, 0, 14964, 14965, 7, 24, 0, 0, 14965, 14973, 5, 2448, 0, 0, 14966, 14973, 3, 1292, 646, 0, 14967, 14973, 3, 1290, 645, 0, 14968, 14973, 3, 928, 464, 0, 14969, 14973, 3, 1272, 636, 0, 14970, 14973, 3, 1108, 554, 0, 14971, 14973, 3, 1274, 637, 0, 14972, 14953, 1, 0, 0, 0, 14972, 14954, 1, 0, 0, 0, 14972, 14955, 1, 0, 0, 0, 14972, 14956, 1, 0, 0, 0, 14972, 14957, 1, 0, 0, 0, 14972, 14958, 1, 0, 0, 0, 14972, 14959, 1, 0, 0, 0, 14972, 14960, 1, 0, 0, 0, 14972, 14961, 1, 0, 0, 0, 14972, 14966, 1, 0, 0, 0, 14972, 14967, 1, 0, 0, 0, 14972, 14968, 1, 0, 0, 0, 14972, 14969, 1, 0, 0, 0, 14972, 14970, 1, 0, 0, 0, 14972, 14971, 1, 0, 0, 0, 14973, 14974, 1, 0, 0, 0, 14974, 14972, 1, 0, 0, 0, 14974, 14975, 1, 0, 0, 0, 14975, 14977, 1, 0, 0, 0, 14976, 14978, 3, 1564, 782, 0, 14977, 14976, 1, 0, 0, 0, 14977, 14978, 1, 0, 0, 0, 14978, 1563, 1, 0, 0, 0, 14979, 14984, 3, 1596, 798, 0, 14980, 14984, 3, 1568, 784, 0, 14981, 14984, 3, 1566, 783, 0, 14982, 14984, 5, 228, 0, 0, 14983, 14979, 1, 0, 0, 0, 14983, 14980, 1, 0, 0, 0, 14983, 14981, 1, 0, 0, 0, 14983, 14982, 1, 0, 0, 0, 14984, 1565, 1, 0, 0, 0, 14985, 14986, 5, 911, 0, 0, 14986, 14989, 5, 2083, 0, 0, 14987, 14990, 3, 1284, 642, 0, 14988, 14990, 3, 1286, 643, 0, 14989, 14987, 1, 0, 0, 0, 14989, 14988, 1, 0, 0, 0, 14990, 1567, 1, 0, 0, 0, 14991, 15002, 3, 1570, 785, 0, 14992, 14997, 5, 1320, 0, 0, 14993, 14998, 3, 1200, 600, 0, 14994, 14998, 3, 1284, 642, 0, 14995, 14998, 3, 1288, 644, 0, 14996, 14998, 3, 1286, 643, 0, 14997, 14993, 1, 0, 0, 0, 14997, 14994, 1, 0, 0, 0, 14997, 14995, 1, 0, 0, 0, 14997, 14996, 1, 0, 0, 0, 14998, 14999, 1, 0, 0, 0, 14999, 14997, 1, 0, 0, 0, 14999, 15000, 1, 0, 0, 0, 15000, 15002, 1, 0, 0, 0, 15001, 14991, 1, 0, 0, 0, 15001, 14992, 1, 0, 0, 0, 15002, 1569, 1, 0, 0, 0, 15003, 15004, 5, 21, 0, 0, 15004, 15006, 5, 1320, 0, 0, 15005, 15007, 3, 1200, 600, 0, 15006, 15005, 1, 0, 0, 0, 15006, 15007, 1, 0, 0, 0, 15007, 15024, 1, 0, 0, 0, 15008, 15009, 5, 2447, 0, 0, 15009, 15011, 5, 1348, 0, 0, 15010, 15012, 3, 1200, 600, 0, 15011, 15010, 1, 0, 0, 0, 15011, 15012, 1, 0, 0, 0, 15012, 15020, 1, 0, 0, 0, 15013, 15014, 5, 2453, 0, 0, 15014, 15016, 5, 1348, 0, 0, 15015, 15017, 3, 1200, 600, 0, 15016, 15015, 1, 0, 0, 0, 15016, 15017, 1, 0, 0, 0, 15017, 15019, 1, 0, 0, 0, 15018, 15013, 1, 0, 0, 0, 15019, 15022, 1, 0, 0, 0, 15020, 15018, 1, 0, 0, 0, 15020, 15021, 1, 0, 0, 0, 15021, 15023, 1, 0, 0, 0, 15022, 15020, 1, 0, 0, 0, 15023, 15025, 5, 2448, 0, 0, 15024, 15008, 1, 0, 0, 0, 15024, 15025, 1, 0, 0, 0, 15025, 1571, 1, 0, 0, 0, 15026, 15029, 3, 1574, 787, 0, 15027, 15029, 3, 1576, 788, 0, 15028, 15026, 1, 0, 0, 0, 15028, 15027, 1, 0, 0, 0, 15029, 1573, 1, 0, 0, 0, 15030, 15031, 7, 192, 0, 0, 15031, 15032, 5, 642, 0, 0, 15032, 15033, 5, 714, 0, 0, 15033, 1575, 1, 0, 0, 0, 15034, 15035, 5, 2207, 0, 0, 15035, 15040, 5, 714, 0, 0, 15036, 15037, 5, 2447, 0, 0, 15037, 15038, 3, 1578, 789, 0, 15038, 15039, 5, 2448, 0, 0, 15039, 15041, 1, 0, 0, 0, 15040, 15036, 1, 0, 0, 0, 15040, 15041, 1, 0, 0, 0, 15041, 1577, 1, 0, 0, 0, 15042, 15043, 3, 2328, 1164, 0, 15043, 15046, 5, 2447, 0, 0, 15044, 15047, 3, 1580, 790, 0, 15045, 15047, 3, 1582, 791, 0, 15046, 15044, 1, 0, 0, 0, 15046, 15045, 1, 0, 0, 0, 15047, 15048, 1, 0, 0, 0, 15048, 15053, 5, 2448, 0, 0, 15049, 15050, 5, 2453, 0, 0, 15050, 15052, 3, 1576, 788, 0, 15051, 15049, 1, 0, 0, 0, 15052, 15055, 1, 0, 0, 0, 15053, 15051, 1, 0, 0, 0, 15053, 15054, 1, 0, 0, 0, 15054, 1579, 1, 0, 0, 0, 15055, 15053, 1, 0, 0, 0, 15056, 15058, 3, 544, 272, 0, 15057, 15059, 3, 506, 253, 0, 15058, 15057, 1, 0, 0, 0, 15058, 15059, 1, 0, 0, 0, 15059, 15064, 1, 0, 0, 0, 15060, 15061, 5, 2453, 0, 0, 15061, 15063, 3, 1580, 790, 0, 15062, 15060, 1, 0, 0, 0, 15063, 15066, 1, 0, 0, 0, 15064, 15062, 1, 0, 0, 0, 15064, 15065, 1, 0, 0, 0, 15065, 1581, 1, 0, 0, 0, 15066, 15064, 1, 0, 0, 0, 15067, 15069, 5, 1775, 0, 0, 15068, 15070, 3, 1154, 577, 0, 15069, 15068, 1, 0, 0, 0, 15069, 15070, 1, 0, 0, 0, 15070, 15073, 1, 0, 0, 0, 15071, 15072, 5, 2080, 0, 0, 15072, 15074, 3, 1656, 828, 0, 15073, 15071, 1, 0, 0, 0, 15073, 15074, 1, 0, 0, 0, 15074, 15079, 1, 0, 0, 0, 15075, 15076, 5, 2453, 0, 0, 15076, 15078, 3, 1582, 791, 0, 15077, 15075, 1, 0, 0, 0, 15078, 15081, 1, 0, 0, 0, 15079, 15077, 1, 0, 0, 0, 15079, 15080, 1, 0, 0, 0, 15080, 1583, 1, 0, 0, 0, 15081, 15079, 1, 0, 0, 0, 15082, 15084, 7, 17, 0, 0, 15083, 15085, 7, 96, 0, 0, 15084, 15083, 1, 0, 0, 0, 15084, 15085, 1, 0, 0, 0, 15085, 15102, 1, 0, 0, 0, 15086, 15087, 5, 2183, 0, 0, 15087, 15088, 5, 2447, 0, 0, 15088, 15093, 3, 2340, 1170, 0, 15089, 15090, 5, 2453, 0, 0, 15090, 15092, 3, 2340, 1170, 0, 15091, 15089, 1, 0, 0, 0, 15092, 15095, 1, 0, 0, 0, 15093, 15091, 1, 0, 0, 0, 15093, 15094, 1, 0, 0, 0, 15094, 15096, 1, 0, 0, 0, 15095, 15093, 1, 0, 0, 0, 15096, 15097, 5, 2448, 0, 0, 15097, 15103, 1, 0, 0, 0, 15098, 15099, 5, 1451, 0, 0, 15099, 15103, 5, 816, 0, 0, 15100, 15101, 5, 286, 0, 0, 15101, 15103, 3, 2310, 1155, 0, 15102, 15086, 1, 0, 0, 0, 15102, 15098, 1, 0, 0, 0, 15102, 15100, 1, 0, 0, 0, 15103, 15105, 1, 0, 0, 0, 15104, 15106, 3, 1586, 793, 0, 15105, 15104, 1, 0, 0, 0, 15105, 15106, 1, 0, 0, 0, 15106, 15108, 1, 0, 0, 0, 15107, 15109, 3, 1592, 796, 0, 15108, 15107, 1, 0, 0, 0, 15108, 15109, 1, 0, 0, 0, 15109, 15111, 1, 0, 0, 0, 15110, 15112, 5, 179, 0, 0, 15111, 15110, 1, 0, 0, 0, 15111, 15112, 1, 0, 0, 0, 15112, 15115, 1, 0, 0, 0, 15113, 15114, 7, 164, 0, 0, 15114, 15116, 5, 717, 0, 0, 15115, 15113, 1, 0, 0, 0, 15115, 15116, 1, 0, 0, 0, 15116, 1585, 1, 0, 0, 0, 15117, 15118, 5, 2246, 0, 0, 15118, 15125, 5, 717, 0, 0, 15119, 15126, 3, 2328, 1164, 0, 15120, 15121, 5, 2447, 0, 0, 15121, 15122, 3, 462, 231, 0, 15122, 15123, 5, 2448, 0, 0, 15123, 15126, 1, 0, 0, 0, 15124, 15126, 3, 474, 237, 0, 15125, 15119, 1, 0, 0, 0, 15125, 15120, 1, 0, 0, 0, 15125, 15124, 1, 0, 0, 0, 15126, 1587, 1, 0, 0, 0, 15127, 15140, 3, 1194, 597, 0, 15128, 15140, 3, 886, 443, 0, 15129, 15132, 5, 2080, 0, 0, 15130, 15133, 3, 1656, 828, 0, 15131, 15133, 5, 389, 0, 0, 15132, 15130, 1, 0, 0, 0, 15132, 15131, 1, 0, 0, 0, 15133, 15140, 1, 0, 0, 0, 15134, 15140, 3, 1600, 800, 0, 15135, 15140, 3, 1590, 795, 0, 15136, 15140, 5, 1588, 0, 0, 15137, 15140, 3, 520, 260, 0, 15138, 15140, 3, 928, 464, 0, 15139, 15127, 1, 0, 0, 0, 15139, 15128, 1, 0, 0, 0, 15139, 15129, 1, 0, 0, 0, 15139, 15134, 1, 0, 0, 0, 15139, 15135, 1, 0, 0, 0, 15139, 15136, 1, 0, 0, 0, 15139, 15137, 1, 0, 0, 0, 15139, 15138, 1, 0, 0, 0, 15140, 15141, 1, 0, 0, 0, 15141, 15139, 1, 0, 0, 0, 15141, 15142, 1, 0, 0, 0, 15142, 1589, 1, 0, 0, 0, 15143, 15144, 7, 193, 0, 0, 15144, 1591, 1, 0, 0, 0, 15145, 15146, 5, 537, 0, 0, 15146, 15147, 5, 779, 0, 0, 15147, 15148, 3, 2342, 1171, 0, 15148, 1593, 1, 0, 0, 0, 15149, 15151, 5, 992, 0, 0, 15150, 15152, 5, 1256, 0, 0, 15151, 15150, 1, 0, 0, 0, 15151, 15152, 1, 0, 0, 0, 15152, 15154, 1, 0, 0, 0, 15153, 15155, 3, 1200, 600, 0, 15154, 15153, 1, 0, 0, 0, 15154, 15155, 1, 0, 0, 0, 15155, 15157, 1, 0, 0, 0, 15156, 15158, 3, 1178, 589, 0, 15157, 15156, 1, 0, 0, 0, 15157, 15158, 1, 0, 0, 0, 15158, 15160, 1, 0, 0, 0, 15159, 15161, 3, 1596, 798, 0, 15160, 15159, 1, 0, 0, 0, 15160, 15161, 1, 0, 0, 0, 15161, 15166, 1, 0, 0, 0, 15162, 15165, 3, 1640, 820, 0, 15163, 15165, 3, 1630, 815, 0, 15164, 15162, 1, 0, 0, 0, 15164, 15163, 1, 0, 0, 0, 15165, 15168, 1, 0, 0, 0, 15166, 15164, 1, 0, 0, 0, 15166, 15167, 1, 0, 0, 0, 15167, 15170, 1, 0, 0, 0, 15168, 15166, 1, 0, 0, 0, 15169, 15171, 3, 928, 464, 0, 15170, 15169, 1, 0, 0, 0, 15170, 15171, 1, 0, 0, 0, 15171, 1595, 1, 0, 0, 0, 15172, 15177, 3, 1598, 799, 0, 15173, 15174, 5, 1371, 0, 0, 15174, 15177, 5, 2441, 0, 0, 15175, 15177, 3, 1600, 800, 0, 15176, 15172, 1, 0, 0, 0, 15176, 15173, 1, 0, 0, 0, 15176, 15175, 1, 0, 0, 0, 15177, 15178, 1, 0, 0, 0, 15178, 15176, 1, 0, 0, 0, 15178, 15179, 1, 0, 0, 0, 15179, 15181, 1, 0, 0, 0, 15180, 15182, 3, 1602, 801, 0, 15181, 15180, 1, 0, 0, 0, 15181, 15182, 1, 0, 0, 0, 15182, 15185, 1, 0, 0, 0, 15183, 15185, 3, 1602, 801, 0, 15184, 15176, 1, 0, 0, 0, 15184, 15183, 1, 0, 0, 0, 15185, 1597, 1, 0, 0, 0, 15186, 15187, 5, 911, 0, 0, 15187, 15190, 5, 2083, 0, 0, 15188, 15190, 5, 1120, 0, 0, 15189, 15186, 1, 0, 0, 0, 15189, 15188, 1, 0, 0, 0, 15190, 1599, 1, 0, 0, 0, 15191, 15195, 5, 1074, 0, 0, 15192, 15193, 5, 258, 0, 0, 15193, 15195, 5, 2441, 0, 0, 15194, 15191, 1, 0, 0, 0, 15194, 15192, 1, 0, 0, 0, 15195, 1601, 1, 0, 0, 0, 15196, 15197, 5, 705, 0, 0, 15197, 15199, 3, 2340, 1170, 0, 15198, 15196, 1, 0, 0, 0, 15198, 15199, 1, 0, 0, 0, 15199, 15200, 1, 0, 0, 0, 15200, 15202, 5, 1320, 0, 0, 15201, 15203, 3, 1200, 600, 0, 15202, 15201, 1, 0, 0, 0, 15202, 15203, 1, 0, 0, 0, 15203, 1603, 1, 0, 0, 0, 15204, 15209, 3, 1616, 808, 0, 15205, 15209, 3, 1610, 805, 0, 15206, 15209, 3, 1606, 803, 0, 15207, 15209, 3, 1642, 821, 0, 15208, 15204, 1, 0, 0, 0, 15208, 15205, 1, 0, 0, 0, 15208, 15206, 1, 0, 0, 0, 15208, 15207, 1, 0, 0, 0, 15209, 1605, 1, 0, 0, 0, 15210, 15211, 5, 980, 0, 0, 15211, 15212, 5, 1013, 0, 0, 15212, 15213, 5, 2083, 0, 0, 15213, 15214, 3, 1608, 804, 0, 15214, 15215, 5, 1586, 0, 0, 15215, 15216, 5, 69, 0, 0, 15216, 15217, 7, 194, 0, 0, 15217, 1607, 1, 0, 0, 0, 15218, 15219, 3, 2342, 1171, 0, 15219, 1609, 1, 0, 0, 0, 15220, 15221, 5, 1559, 0, 0, 15221, 15222, 5, 237, 0, 0, 15222, 15223, 3, 1612, 806, 0, 15223, 15224, 5, 2141, 0, 0, 15224, 15225, 3, 1614, 807, 0, 15225, 1611, 1, 0, 0, 0, 15226, 15227, 3, 2340, 1170, 0, 15227, 1613, 1, 0, 0, 0, 15228, 15229, 3, 2340, 1170, 0, 15229, 1615, 1, 0, 0, 0, 15230, 15235, 3, 1702, 851, 0, 15231, 15235, 3, 1628, 814, 0, 15232, 15235, 3, 1620, 810, 0, 15233, 15235, 3, 1618, 809, 0, 15234, 15230, 1, 0, 0, 0, 15234, 15231, 1, 0, 0, 0, 15234, 15232, 1, 0, 0, 0, 15234, 15233, 1, 0, 0, 0, 15235, 15236, 1, 0, 0, 0, 15236, 15234, 1, 0, 0, 0, 15236, 15237, 1, 0, 0, 0, 15237, 1617, 1, 0, 0, 0, 15238, 15239, 5, 1671, 0, 0, 15239, 15253, 5, 2204, 0, 0, 15240, 15241, 5, 237, 0, 0, 15241, 15254, 3, 2340, 1170, 0, 15242, 15243, 5, 2447, 0, 0, 15243, 15248, 3, 2340, 1170, 0, 15244, 15245, 5, 2453, 0, 0, 15245, 15247, 3, 2340, 1170, 0, 15246, 15244, 1, 0, 0, 0, 15247, 15250, 1, 0, 0, 0, 15248, 15246, 1, 0, 0, 0, 15248, 15249, 1, 0, 0, 0, 15249, 15251, 1, 0, 0, 0, 15250, 15248, 1, 0, 0, 0, 15251, 15252, 5, 2448, 0, 0, 15252, 15254, 1, 0, 0, 0, 15253, 15240, 1, 0, 0, 0, 15253, 15242, 1, 0, 0, 0, 15254, 15260, 1, 0, 0, 0, 15255, 15256, 5, 179, 0, 0, 15256, 15259, 5, 287, 0, 0, 15257, 15259, 5, 780, 0, 0, 15258, 15255, 1, 0, 0, 0, 15258, 15257, 1, 0, 0, 0, 15259, 15262, 1, 0, 0, 0, 15260, 15258, 1, 0, 0, 0, 15260, 15261, 1, 0, 0, 0, 15261, 15301, 1, 0, 0, 0, 15262, 15260, 1, 0, 0, 0, 15263, 15277, 5, 469, 0, 0, 15264, 15265, 5, 237, 0, 0, 15265, 15278, 3, 2340, 1170, 0, 15266, 15267, 5, 2447, 0, 0, 15267, 15272, 3, 2340, 1170, 0, 15268, 15269, 5, 2453, 0, 0, 15269, 15271, 3, 2340, 1170, 0, 15270, 15268, 1, 0, 0, 0, 15271, 15274, 1, 0, 0, 0, 15272, 15270, 1, 0, 0, 0, 15272, 15273, 1, 0, 0, 0, 15273, 15275, 1, 0, 0, 0, 15274, 15272, 1, 0, 0, 0, 15275, 15276, 5, 2448, 0, 0, 15276, 15278, 1, 0, 0, 0, 15277, 15264, 1, 0, 0, 0, 15277, 15266, 1, 0, 0, 0, 15278, 15284, 1, 0, 0, 0, 15279, 15280, 5, 179, 0, 0, 15280, 15283, 5, 287, 0, 0, 15281, 15283, 5, 780, 0, 0, 15282, 15279, 1, 0, 0, 0, 15282, 15281, 1, 0, 0, 0, 15283, 15286, 1, 0, 0, 0, 15284, 15282, 1, 0, 0, 0, 15284, 15285, 1, 0, 0, 0, 15285, 15289, 1, 0, 0, 0, 15286, 15284, 1, 0, 0, 0, 15287, 15288, 5, 201, 0, 0, 15288, 15290, 5, 2441, 0, 0, 15289, 15287, 1, 0, 0, 0, 15289, 15290, 1, 0, 0, 0, 15290, 15301, 1, 0, 0, 0, 15291, 15296, 5, 469, 0, 0, 15292, 15293, 5, 2204, 0, 0, 15293, 15297, 5, 238, 0, 0, 15294, 15295, 5, 238, 0, 0, 15295, 15297, 5, 297, 0, 0, 15296, 15292, 1, 0, 0, 0, 15296, 15294, 1, 0, 0, 0, 15297, 15298, 1, 0, 0, 0, 15298, 15299, 5, 201, 0, 0, 15299, 15301, 5, 2441, 0, 0, 15300, 15238, 1, 0, 0, 0, 15300, 15263, 1, 0, 0, 0, 15300, 15291, 1, 0, 0, 0, 15301, 1619, 1, 0, 0, 0, 15302, 15328, 5, 980, 0, 0, 15303, 15304, 5, 2447, 0, 0, 15304, 15309, 3, 1622, 811, 0, 15305, 15306, 5, 2453, 0, 0, 15306, 15308, 3, 1622, 811, 0, 15307, 15305, 1, 0, 0, 0, 15308, 15311, 1, 0, 0, 0, 15309, 15307, 1, 0, 0, 0, 15309, 15310, 1, 0, 0, 0, 15310, 15312, 1, 0, 0, 0, 15311, 15309, 1, 0, 0, 0, 15312, 15313, 5, 2448, 0, 0, 15313, 15329, 1, 0, 0, 0, 15314, 15315, 5, 2447, 0, 0, 15315, 15320, 3, 1624, 812, 0, 15316, 15317, 5, 2453, 0, 0, 15317, 15319, 3, 1624, 812, 0, 15318, 15316, 1, 0, 0, 0, 15319, 15322, 1, 0, 0, 0, 15320, 15318, 1, 0, 0, 0, 15320, 15321, 1, 0, 0, 0, 15321, 15323, 1, 0, 0, 0, 15322, 15320, 1, 0, 0, 0, 15323, 15324, 5, 2448, 0, 0, 15324, 15329, 1, 0, 0, 0, 15325, 15329, 3, 1622, 811, 0, 15326, 15329, 3, 1624, 812, 0, 15327, 15329, 3, 1626, 813, 0, 15328, 15303, 1, 0, 0, 0, 15328, 15314, 1, 0, 0, 0, 15328, 15325, 1, 0, 0, 0, 15328, 15326, 1, 0, 0, 0, 15328, 15327, 1, 0, 0, 0, 15329, 1621, 1, 0, 0, 0, 15330, 15332, 3, 2340, 1170, 0, 15331, 15333, 3, 2376, 1188, 0, 15332, 15331, 1, 0, 0, 0, 15332, 15333, 1, 0, 0, 0, 15333, 15340, 1, 0, 0, 0, 15334, 15337, 5, 389, 0, 0, 15335, 15336, 5, 1259, 0, 0, 15336, 15338, 5, 1228, 0, 0, 15337, 15335, 1, 0, 0, 0, 15337, 15338, 1, 0, 0, 0, 15338, 15339, 1, 0, 0, 0, 15339, 15341, 3, 2078, 1039, 0, 15340, 15334, 1, 0, 0, 0, 15340, 15341, 1, 0, 0, 0, 15341, 15345, 1, 0, 0, 0, 15342, 15343, 5, 505, 0, 0, 15343, 15346, 3, 1654, 827, 0, 15344, 15346, 5, 387, 0, 0, 15345, 15342, 1, 0, 0, 0, 15345, 15344, 1, 0, 0, 0, 15345, 15346, 1, 0, 0, 0, 15346, 15350, 1, 0, 0, 0, 15347, 15349, 3, 846, 423, 0, 15348, 15347, 1, 0, 0, 0, 15349, 15352, 1, 0, 0, 0, 15350, 15348, 1, 0, 0, 0, 15350, 15351, 1, 0, 0, 0, 15351, 15354, 1, 0, 0, 0, 15352, 15350, 1, 0, 0, 0, 15353, 15355, 3, 1640, 820, 0, 15354, 15353, 1, 0, 0, 0, 15354, 15355, 1, 0, 0, 0, 15355, 15357, 1, 0, 0, 0, 15356, 15358, 3, 2246, 1123, 0, 15357, 15356, 1, 0, 0, 0, 15357, 15358, 1, 0, 0, 0, 15358, 1623, 1, 0, 0, 0, 15359, 15360, 3, 2340, 1170, 0, 15360, 15361, 7, 70, 0, 0, 15361, 1625, 1, 0, 0, 0, 15362, 15363, 5, 237, 0, 0, 15363, 15365, 3, 2340, 1170, 0, 15364, 15366, 5, 1204, 0, 0, 15365, 15364, 1, 0, 0, 0, 15365, 15366, 1, 0, 0, 0, 15366, 15367, 1, 0, 0, 0, 15367, 15368, 5, 1780, 0, 0, 15368, 15369, 5, 82, 0, 0, 15369, 15370, 5, 38, 0, 0, 15370, 15372, 5, 848, 0, 0, 15371, 15373, 5, 616, 0, 0, 15372, 15371, 1, 0, 0, 0, 15372, 15373, 1, 0, 0, 0, 15373, 1627, 1, 0, 0, 0, 15374, 15396, 5, 21, 0, 0, 15375, 15378, 5, 2447, 0, 0, 15376, 15379, 3, 1670, 835, 0, 15377, 15379, 3, 1680, 840, 0, 15378, 15376, 1, 0, 0, 0, 15378, 15377, 1, 0, 0, 0, 15379, 15387, 1, 0, 0, 0, 15380, 15383, 5, 2453, 0, 0, 15381, 15384, 3, 1670, 835, 0, 15382, 15384, 3, 1680, 840, 0, 15383, 15381, 1, 0, 0, 0, 15383, 15382, 1, 0, 0, 0, 15384, 15386, 1, 0, 0, 0, 15385, 15380, 1, 0, 0, 0, 15386, 15389, 1, 0, 0, 0, 15387, 15385, 1, 0, 0, 0, 15387, 15388, 1, 0, 0, 0, 15388, 15390, 1, 0, 0, 0, 15389, 15387, 1, 0, 0, 0, 15390, 15391, 5, 2448, 0, 0, 15391, 15397, 1, 0, 0, 0, 15392, 15395, 3, 1670, 835, 0, 15393, 15395, 3, 1680, 840, 0, 15394, 15392, 1, 0, 0, 0, 15394, 15393, 1, 0, 0, 0, 15395, 15397, 1, 0, 0, 0, 15396, 15375, 1, 0, 0, 0, 15396, 15394, 1, 0, 0, 0, 15397, 15399, 1, 0, 0, 0, 15398, 15400, 3, 1660, 830, 0, 15399, 15398, 1, 0, 0, 0, 15399, 15400, 1, 0, 0, 0, 15400, 1629, 1, 0, 0, 0, 15401, 15402, 5, 2267, 0, 0, 15402, 15408, 3, 1658, 829, 0, 15403, 15405, 3, 1694, 847, 0, 15404, 15403, 1, 0, 0, 0, 15404, 15405, 1, 0, 0, 0, 15405, 15406, 1, 0, 0, 0, 15406, 15409, 3, 1632, 816, 0, 15407, 15409, 3, 1694, 847, 0, 15408, 15404, 1, 0, 0, 0, 15408, 15407, 1, 0, 0, 0, 15409, 1631, 1, 0, 0, 0, 15410, 15411, 5, 1763, 0, 0, 15411, 15413, 5, 69, 0, 0, 15412, 15414, 7, 122, 0, 0, 15413, 15412, 1, 0, 0, 0, 15413, 15414, 1, 0, 0, 0, 15414, 15415, 1, 0, 0, 0, 15415, 15424, 5, 868, 0, 0, 15416, 15418, 3, 1634, 817, 0, 15417, 15416, 1, 0, 0, 0, 15417, 15418, 1, 0, 0, 0, 15418, 15419, 1, 0, 0, 0, 15419, 15420, 5, 2447, 0, 0, 15420, 15421, 3, 1638, 819, 0, 15421, 15422, 5, 2448, 0, 0, 15422, 15425, 1, 0, 0, 0, 15423, 15425, 3, 1634, 817, 0, 15424, 15417, 1, 0, 0, 0, 15424, 15423, 1, 0, 0, 0, 15424, 15425, 1, 0, 0, 0, 15425, 1633, 1, 0, 0, 0, 15426, 15429, 3, 2410, 1205, 0, 15427, 15429, 5, 2444, 0, 0, 15428, 15426, 1, 0, 0, 0, 15428, 15427, 1, 0, 0, 0, 15429, 1635, 1, 0, 0, 0, 15430, 15434, 3, 2410, 1205, 0, 15431, 15434, 3, 2400, 1200, 0, 15432, 15434, 5, 2444, 0, 0, 15433, 15430, 1, 0, 0, 0, 15433, 15431, 1, 0, 0, 0, 15433, 15432, 1, 0, 0, 0, 15434, 1637, 1, 0, 0, 0, 15435, 15436, 5, 2080, 0, 0, 15436, 15443, 3, 2404, 1202, 0, 15437, 15439, 3, 1646, 823, 0, 15438, 15440, 3, 1196, 598, 0, 15439, 15438, 1, 0, 0, 0, 15439, 15440, 1, 0, 0, 0, 15440, 15443, 1, 0, 0, 0, 15441, 15443, 3, 1196, 598, 0, 15442, 15435, 1, 0, 0, 0, 15442, 15437, 1, 0, 0, 0, 15442, 15441, 1, 0, 0, 0, 15443, 1639, 1, 0, 0, 0, 15444, 15489, 5, 868, 0, 0, 15445, 15446, 5, 2447, 0, 0, 15446, 15451, 3, 1636, 818, 0, 15447, 15448, 5, 2453, 0, 0, 15448, 15450, 3, 1636, 818, 0, 15449, 15447, 1, 0, 0, 0, 15450, 15453, 1, 0, 0, 0, 15451, 15449, 1, 0, 0, 0, 15451, 15452, 1, 0, 0, 0, 15452, 15454, 1, 0, 0, 0, 15453, 15451, 1, 0, 0, 0, 15454, 15455, 5, 2448, 0, 0, 15455, 15456, 5, 1763, 0, 0, 15456, 15466, 5, 69, 0, 0, 15457, 15467, 7, 122, 0, 0, 15458, 15462, 5, 2447, 0, 0, 15459, 15461, 3, 1638, 819, 0, 15460, 15459, 1, 0, 0, 0, 15461, 15464, 1, 0, 0, 0, 15462, 15460, 1, 0, 0, 0, 15462, 15463, 1, 0, 0, 0, 15463, 15465, 1, 0, 0, 0, 15464, 15462, 1, 0, 0, 0, 15465, 15467, 5, 2448, 0, 0, 15466, 15457, 1, 0, 0, 0, 15466, 15458, 1, 0, 0, 0, 15467, 15468, 1, 0, 0, 0, 15468, 15466, 1, 0, 0, 0, 15468, 15469, 1, 0, 0, 0, 15469, 15490, 1, 0, 0, 0, 15470, 15471, 5, 2447, 0, 0, 15471, 15472, 3, 1636, 818, 0, 15472, 15473, 5, 2448, 0, 0, 15473, 15474, 5, 1763, 0, 0, 15474, 15485, 5, 69, 0, 0, 15475, 15486, 7, 122, 0, 0, 15476, 15486, 3, 1634, 817, 0, 15477, 15481, 5, 2447, 0, 0, 15478, 15480, 3, 1638, 819, 0, 15479, 15478, 1, 0, 0, 0, 15480, 15483, 1, 0, 0, 0, 15481, 15479, 1, 0, 0, 0, 15481, 15482, 1, 0, 0, 0, 15482, 15484, 1, 0, 0, 0, 15483, 15481, 1, 0, 0, 0, 15484, 15486, 5, 2448, 0, 0, 15485, 15475, 1, 0, 0, 0, 15485, 15476, 1, 0, 0, 0, 15485, 15477, 1, 0, 0, 0, 15486, 15487, 1, 0, 0, 0, 15487, 15485, 1, 0, 0, 0, 15487, 15488, 1, 0, 0, 0, 15488, 15490, 1, 0, 0, 0, 15489, 15445, 1, 0, 0, 0, 15489, 15470, 1, 0, 0, 0, 15490, 1641, 1, 0, 0, 0, 15491, 15492, 5, 980, 0, 0, 15492, 15493, 5, 868, 0, 0, 15493, 15494, 5, 2447, 0, 0, 15494, 15495, 3, 1636, 818, 0, 15495, 15496, 5, 2448, 0, 0, 15496, 15497, 5, 2447, 0, 0, 15497, 15498, 3, 1644, 822, 0, 15498, 15499, 5, 2448, 0, 0, 15499, 1643, 1, 0, 0, 0, 15500, 15525, 3, 1196, 598, 0, 15501, 15502, 7, 195, 0, 0, 15502, 15525, 5, 2441, 0, 0, 15503, 15504, 5, 1511, 0, 0, 15504, 15525, 5, 626, 0, 0, 15505, 15525, 3, 1652, 826, 0, 15506, 15525, 3, 1648, 824, 0, 15507, 15525, 3, 1650, 825, 0, 15508, 15509, 5, 505, 0, 0, 15509, 15525, 3, 1654, 827, 0, 15510, 15525, 5, 387, 0, 0, 15511, 15525, 5, 166, 0, 0, 15512, 15517, 5, 166, 0, 0, 15513, 15517, 5, 1066, 0, 0, 15514, 15515, 5, 166, 0, 0, 15515, 15517, 5, 1506, 0, 0, 15516, 15512, 1, 0, 0, 0, 15516, 15513, 1, 0, 0, 0, 15516, 15514, 1, 0, 0, 0, 15517, 15519, 1, 0, 0, 0, 15518, 15520, 3, 886, 443, 0, 15519, 15518, 1, 0, 0, 0, 15519, 15520, 1, 0, 0, 0, 15520, 15525, 1, 0, 0, 0, 15521, 15525, 3, 1284, 642, 0, 15522, 15525, 3, 1288, 644, 0, 15523, 15525, 3, 1286, 643, 0, 15524, 15500, 1, 0, 0, 0, 15524, 15501, 1, 0, 0, 0, 15524, 15503, 1, 0, 0, 0, 15524, 15505, 1, 0, 0, 0, 15524, 15506, 1, 0, 0, 0, 15524, 15507, 1, 0, 0, 0, 15524, 15508, 1, 0, 0, 0, 15524, 15510, 1, 0, 0, 0, 15524, 15511, 1, 0, 0, 0, 15524, 15516, 1, 0, 0, 0, 15524, 15521, 1, 0, 0, 0, 15524, 15522, 1, 0, 0, 0, 15524, 15523, 1, 0, 0, 0, 15525, 15526, 1, 0, 0, 0, 15526, 15524, 1, 0, 0, 0, 15526, 15527, 1, 0, 0, 0, 15527, 1645, 1, 0, 0, 0, 15528, 15529, 7, 17, 0, 0, 15529, 15530, 5, 1762, 0, 0, 15530, 15531, 5, 738, 0, 0, 15531, 15554, 5, 1606, 0, 0, 15532, 15533, 5, 205, 0, 0, 15533, 15554, 5, 2441, 0, 0, 15534, 15535, 5, 1373, 0, 0, 15535, 15554, 5, 2441, 0, 0, 15536, 15537, 5, 626, 0, 0, 15537, 15554, 5, 2441, 0, 0, 15538, 15554, 3, 1652, 826, 0, 15539, 15554, 3, 1648, 824, 0, 15540, 15554, 3, 1650, 825, 0, 15541, 15542, 5, 505, 0, 0, 15542, 15554, 3, 1654, 827, 0, 15543, 15554, 5, 387, 0, 0, 15544, 15549, 5, 166, 0, 0, 15545, 15549, 5, 1066, 0, 0, 15546, 15547, 5, 166, 0, 0, 15547, 15549, 5, 1506, 0, 0, 15548, 15544, 1, 0, 0, 0, 15548, 15545, 1, 0, 0, 0, 15548, 15546, 1, 0, 0, 0, 15549, 15551, 1, 0, 0, 0, 15550, 15552, 3, 886, 443, 0, 15551, 15550, 1, 0, 0, 0, 15551, 15552, 1, 0, 0, 0, 15552, 15554, 1, 0, 0, 0, 15553, 15528, 1, 0, 0, 0, 15553, 15532, 1, 0, 0, 0, 15553, 15534, 1, 0, 0, 0, 15553, 15536, 1, 0, 0, 0, 15553, 15538, 1, 0, 0, 0, 15553, 15539, 1, 0, 0, 0, 15553, 15540, 1, 0, 0, 0, 15553, 15541, 1, 0, 0, 0, 15553, 15543, 1, 0, 0, 0, 15553, 15548, 1, 0, 0, 0, 15554, 15555, 1, 0, 0, 0, 15555, 15553, 1, 0, 0, 0, 15555, 15556, 1, 0, 0, 0, 15556, 1647, 1, 0, 0, 0, 15557, 15558, 7, 196, 0, 0, 15558, 1649, 1, 0, 0, 0, 15559, 15565, 5, 1074, 0, 0, 15560, 15562, 5, 258, 0, 0, 15561, 15563, 7, 197, 0, 0, 15562, 15561, 1, 0, 0, 0, 15562, 15563, 1, 0, 0, 0, 15563, 15565, 1, 0, 0, 0, 15564, 15559, 1, 0, 0, 0, 15564, 15560, 1, 0, 0, 0, 15565, 1651, 1, 0, 0, 0, 15566, 15572, 5, 1583, 0, 0, 15567, 15573, 5, 2406, 0, 0, 15568, 15569, 5, 2409, 0, 0, 15569, 15573, 5, 2441, 0, 0, 15570, 15573, 5, 91, 0, 0, 15571, 15573, 5, 1133, 0, 0, 15572, 15567, 1, 0, 0, 0, 15572, 15568, 1, 0, 0, 0, 15572, 15570, 1, 0, 0, 0, 15572, 15571, 1, 0, 0, 0, 15572, 15573, 1, 0, 0, 0, 15573, 1653, 1, 0, 0, 0, 15574, 15575, 5, 2246, 0, 0, 15575, 15577, 5, 2443, 0, 0, 15576, 15574, 1, 0, 0, 0, 15576, 15577, 1, 0, 0, 0, 15577, 15581, 1, 0, 0, 0, 15578, 15579, 5, 685, 0, 0, 15579, 15580, 5, 160, 0, 0, 15580, 15582, 5, 2480, 0, 0, 15581, 15578, 1, 0, 0, 0, 15581, 15582, 1, 0, 0, 0, 15582, 15584, 1, 0, 0, 0, 15583, 15585, 5, 2443, 0, 0, 15584, 15583, 1, 0, 0, 0, 15584, 15585, 1, 0, 0, 0, 15585, 15590, 1, 0, 0, 0, 15586, 15588, 5, 1137, 0, 0, 15587, 15586, 1, 0, 0, 0, 15587, 15588, 1, 0, 0, 0, 15588, 15589, 1, 0, 0, 0, 15589, 15591, 5, 1613, 0, 0, 15590, 15587, 1, 0, 0, 0, 15590, 15591, 1, 0, 0, 0, 15591, 1655, 1, 0, 0, 0, 15592, 15593, 3, 2404, 1202, 0, 15593, 1657, 1, 0, 0, 0, 15594, 15595, 3, 2404, 1202, 0, 15595, 15596, 5, 2440, 0, 0, 15596, 15598, 1, 0, 0, 0, 15597, 15594, 1, 0, 0, 0, 15597, 15598, 1, 0, 0, 0, 15598, 15602, 1, 0, 0, 0, 15599, 15600, 3, 2404, 1202, 0, 15600, 15601, 5, 2440, 0, 0, 15601, 15603, 1, 0, 0, 0, 15602, 15599, 1, 0, 0, 0, 15602, 15603, 1, 0, 0, 0, 15603, 15604, 1, 0, 0, 0, 15604, 15605, 3, 2404, 1202, 0, 15605, 1659, 1, 0, 0, 0, 15606, 15627, 3, 1700, 850, 0, 15607, 15627, 3, 1690, 845, 0, 15608, 15611, 3, 1630, 815, 0, 15609, 15611, 3, 1640, 820, 0, 15610, 15608, 1, 0, 0, 0, 15610, 15609, 1, 0, 0, 0, 15611, 15623, 1, 0, 0, 0, 15612, 15613, 5, 2447, 0, 0, 15613, 15618, 3, 1662, 831, 0, 15614, 15615, 5, 2453, 0, 0, 15615, 15617, 3, 1662, 831, 0, 15616, 15614, 1, 0, 0, 0, 15617, 15620, 1, 0, 0, 0, 15618, 15616, 1, 0, 0, 0, 15618, 15619, 1, 0, 0, 0, 15619, 15621, 1, 0, 0, 0, 15620, 15618, 1, 0, 0, 0, 15621, 15622, 5, 2448, 0, 0, 15622, 15624, 1, 0, 0, 0, 15623, 15612, 1, 0, 0, 0, 15623, 15624, 1, 0, 0, 0, 15624, 15627, 1, 0, 0, 0, 15625, 15627, 3, 1044, 522, 0, 15626, 15606, 1, 0, 0, 0, 15626, 15607, 1, 0, 0, 0, 15626, 15610, 1, 0, 0, 0, 15626, 15625, 1, 0, 0, 0, 15627, 15628, 1, 0, 0, 0, 15628, 15626, 1, 0, 0, 0, 15628, 15629, 1, 0, 0, 0, 15629, 1661, 1, 0, 0, 0, 15630, 15663, 5, 868, 0, 0, 15631, 15632, 5, 2447, 0, 0, 15632, 15633, 3, 1636, 818, 0, 15633, 15634, 5, 2453, 0, 0, 15634, 15635, 3, 1636, 818, 0, 15635, 15636, 1, 0, 0, 0, 15636, 15637, 5, 2448, 0, 0, 15637, 15638, 5, 1763, 0, 0, 15638, 15644, 5, 69, 0, 0, 15639, 15645, 7, 122, 0, 0, 15640, 15641, 5, 2447, 0, 0, 15641, 15642, 3, 1638, 819, 0, 15642, 15643, 5, 2448, 0, 0, 15643, 15645, 1, 0, 0, 0, 15644, 15639, 1, 0, 0, 0, 15644, 15640, 1, 0, 0, 0, 15645, 15646, 1, 0, 0, 0, 15646, 15644, 1, 0, 0, 0, 15646, 15647, 1, 0, 0, 0, 15647, 15664, 1, 0, 0, 0, 15648, 15649, 5, 2447, 0, 0, 15649, 15650, 3, 1636, 818, 0, 15650, 15651, 5, 2448, 0, 0, 15651, 15652, 5, 1763, 0, 0, 15652, 15659, 5, 69, 0, 0, 15653, 15660, 7, 122, 0, 0, 15654, 15660, 3, 1634, 817, 0, 15655, 15656, 5, 2447, 0, 0, 15656, 15657, 3, 1638, 819, 0, 15657, 15658, 5, 2448, 0, 0, 15658, 15660, 1, 0, 0, 0, 15659, 15653, 1, 0, 0, 0, 15659, 15654, 1, 0, 0, 0, 15659, 15655, 1, 0, 0, 0, 15660, 15661, 1, 0, 0, 0, 15661, 15659, 1, 0, 0, 0, 15661, 15662, 1, 0, 0, 0, 15662, 15664, 1, 0, 0, 0, 15663, 15631, 1, 0, 0, 0, 15663, 15648, 1, 0, 0, 0, 15664, 1663, 1, 0, 0, 0, 15665, 15666, 4, 832, 10, 0, 15666, 15667, 5, 2440, 0, 0, 15667, 15668, 5, 620, 0, 0, 15668, 15675, 3, 2340, 1170, 0, 15669, 15670, 5, 2447, 0, 0, 15670, 15671, 3, 1666, 833, 0, 15671, 15672, 5, 2453, 0, 0, 15672, 15673, 3, 1668, 834, 0, 15673, 15674, 5, 2448, 0, 0, 15674, 15676, 1, 0, 0, 0, 15675, 15669, 1, 0, 0, 0, 15675, 15676, 1, 0, 0, 0, 15676, 1665, 1, 0, 0, 0, 15677, 15678, 3, 2340, 1170, 0, 15678, 1667, 1, 0, 0, 0, 15679, 15680, 3, 2340, 1170, 0, 15680, 1669, 1, 0, 0, 0, 15681, 15690, 3, 2340, 1170, 0, 15682, 15685, 3, 2376, 1188, 0, 15683, 15685, 3, 2314, 1157, 0, 15684, 15682, 1, 0, 0, 0, 15684, 15683, 1, 0, 0, 0, 15685, 15688, 1, 0, 0, 0, 15686, 15687, 5, 2372, 0, 0, 15687, 15689, 3, 1672, 836, 0, 15688, 15686, 1, 0, 0, 0, 15688, 15689, 1, 0, 0, 0, 15689, 15691, 1, 0, 0, 0, 15690, 15684, 1, 0, 0, 0, 15690, 15691, 1, 0, 0, 0, 15691, 15693, 1, 0, 0, 0, 15692, 15694, 5, 1709, 0, 0, 15693, 15692, 1, 0, 0, 0, 15693, 15694, 1, 0, 0, 0, 15694, 15696, 1, 0, 0, 0, 15695, 15697, 7, 70, 0, 0, 15696, 15695, 1, 0, 0, 0, 15696, 15697, 1, 0, 0, 0, 15697, 15705, 1, 0, 0, 0, 15698, 15701, 5, 389, 0, 0, 15699, 15700, 5, 1259, 0, 0, 15700, 15702, 5, 1228, 0, 0, 15701, 15699, 1, 0, 0, 0, 15701, 15702, 1, 0, 0, 0, 15702, 15703, 1, 0, 0, 0, 15703, 15706, 3, 2078, 1039, 0, 15704, 15706, 3, 1674, 837, 0, 15705, 15698, 1, 0, 0, 0, 15705, 15704, 1, 0, 0, 0, 15705, 15706, 1, 0, 0, 0, 15706, 15709, 1, 0, 0, 0, 15707, 15708, 5, 505, 0, 0, 15708, 15710, 3, 1654, 827, 0, 15709, 15707, 1, 0, 0, 0, 15709, 15710, 1, 0, 0, 0, 15710, 15717, 1, 0, 0, 0, 15711, 15713, 3, 846, 423, 0, 15712, 15711, 1, 0, 0, 0, 15713, 15714, 1, 0, 0, 0, 15714, 15712, 1, 0, 0, 0, 15714, 15715, 1, 0, 0, 0, 15715, 15718, 1, 0, 0, 0, 15716, 15718, 3, 848, 424, 0, 15717, 15712, 1, 0, 0, 0, 15717, 15716, 1, 0, 0, 0, 15717, 15718, 1, 0, 0, 0, 15718, 15720, 1, 0, 0, 0, 15719, 15721, 3, 2246, 1123, 0, 15720, 15719, 1, 0, 0, 0, 15720, 15721, 1, 0, 0, 0, 15721, 1671, 1, 0, 0, 0, 15722, 15723, 3, 2404, 1202, 0, 15723, 1673, 1, 0, 0, 0, 15724, 15732, 5, 640, 0, 0, 15725, 15733, 5, 44, 0, 0, 15726, 15727, 5, 160, 0, 0, 15727, 15730, 5, 389, 0, 0, 15728, 15729, 5, 1259, 0, 0, 15729, 15731, 5, 1228, 0, 0, 15730, 15728, 1, 0, 0, 0, 15730, 15731, 1, 0, 0, 0, 15731, 15733, 1, 0, 0, 0, 15732, 15725, 1, 0, 0, 0, 15732, 15726, 1, 0, 0, 0, 15732, 15733, 1, 0, 0, 0, 15733, 15734, 1, 0, 0, 0, 15734, 15735, 5, 69, 0, 0, 15735, 15737, 5, 687, 0, 0, 15736, 15738, 3, 1676, 838, 0, 15737, 15736, 1, 0, 0, 0, 15737, 15738, 1, 0, 0, 0, 15738, 1675, 1, 0, 0, 0, 15739, 15741, 3, 1678, 839, 0, 15740, 15739, 1, 0, 0, 0, 15741, 15742, 1, 0, 0, 0, 15742, 15740, 1, 0, 0, 0, 15742, 15743, 1, 0, 0, 0, 15743, 15753, 1, 0, 0, 0, 15744, 15746, 5, 2447, 0, 0, 15745, 15747, 3, 1678, 839, 0, 15746, 15745, 1, 0, 0, 0, 15747, 15748, 1, 0, 0, 0, 15748, 15746, 1, 0, 0, 0, 15748, 15749, 1, 0, 0, 0, 15749, 15750, 1, 0, 0, 0, 15750, 15751, 5, 2448, 0, 0, 15751, 15753, 1, 0, 0, 0, 15752, 15740, 1, 0, 0, 0, 15752, 15744, 1, 0, 0, 0, 15753, 1677, 1, 0, 0, 0, 15754, 15755, 5, 1737, 0, 0, 15755, 15759, 5, 2308, 0, 0, 15756, 15760, 3, 2396, 1198, 0, 15757, 15758, 5, 858, 0, 0, 15758, 15760, 5, 2258, 0, 0, 15759, 15756, 1, 0, 0, 0, 15759, 15757, 1, 0, 0, 0, 15760, 15783, 1, 0, 0, 0, 15761, 15762, 5, 707, 0, 0, 15762, 15763, 5, 160, 0, 0, 15763, 15783, 3, 2396, 1198, 0, 15764, 15765, 5, 932, 0, 0, 15765, 15783, 3, 2396, 1198, 0, 15766, 15783, 5, 1121, 0, 0, 15767, 15768, 5, 960, 0, 0, 15768, 15783, 3, 2396, 1198, 0, 15769, 15783, 5, 1124, 0, 0, 15770, 15783, 5, 348, 0, 0, 15771, 15783, 5, 1084, 0, 0, 15772, 15773, 5, 166, 0, 0, 15773, 15783, 3, 2396, 1198, 0, 15774, 15783, 5, 1066, 0, 0, 15775, 15783, 5, 1303, 0, 0, 15776, 15783, 5, 1140, 0, 0, 15777, 15778, 5, 1620, 0, 0, 15778, 15783, 7, 49, 0, 0, 15779, 15783, 5, 1181, 0, 0, 15780, 15783, 5, 814, 0, 0, 15781, 15783, 5, 1114, 0, 0, 15782, 15754, 1, 0, 0, 0, 15782, 15761, 1, 0, 0, 0, 15782, 15764, 1, 0, 0, 0, 15782, 15766, 1, 0, 0, 0, 15782, 15767, 1, 0, 0, 0, 15782, 15769, 1, 0, 0, 0, 15782, 15770, 1, 0, 0, 0, 15782, 15771, 1, 0, 0, 0, 15782, 15772, 1, 0, 0, 0, 15782, 15774, 1, 0, 0, 0, 15782, 15775, 1, 0, 0, 0, 15782, 15776, 1, 0, 0, 0, 15782, 15777, 1, 0, 0, 0, 15782, 15779, 1, 0, 0, 0, 15782, 15780, 1, 0, 0, 0, 15782, 15781, 1, 0, 0, 0, 15783, 1679, 1, 0, 0, 0, 15784, 15790, 3, 2340, 1170, 0, 15785, 15788, 3, 2376, 1188, 0, 15786, 15787, 5, 2372, 0, 0, 15787, 15789, 3, 1672, 836, 0, 15788, 15786, 1, 0, 0, 0, 15788, 15789, 1, 0, 0, 0, 15789, 15791, 1, 0, 0, 0, 15790, 15785, 1, 0, 0, 0, 15790, 15791, 1, 0, 0, 0, 15791, 15793, 1, 0, 0, 0, 15792, 15794, 7, 70, 0, 0, 15793, 15792, 1, 0, 0, 0, 15793, 15794, 1, 0, 0, 0, 15794, 15796, 1, 0, 0, 0, 15795, 15797, 3, 1682, 841, 0, 15796, 15795, 1, 0, 0, 0, 15796, 15797, 1, 0, 0, 0, 15797, 15799, 1, 0, 0, 0, 15798, 15800, 5, 2288, 0, 0, 15799, 15798, 1, 0, 0, 0, 15799, 15800, 1, 0, 0, 0, 15800, 15802, 1, 0, 0, 0, 15801, 15803, 3, 1688, 844, 0, 15802, 15801, 1, 0, 0, 0, 15802, 15803, 1, 0, 0, 0, 15803, 15812, 1, 0, 0, 0, 15804, 15805, 5, 2203, 0, 0, 15805, 15810, 5, 112, 0, 0, 15806, 15807, 5, 336, 0, 0, 15807, 15811, 5, 483, 0, 0, 15808, 15809, 5, 483, 0, 0, 15809, 15811, 3, 1454, 727, 0, 15810, 15806, 1, 0, 0, 0, 15810, 15808, 1, 0, 0, 0, 15811, 15813, 1, 0, 0, 0, 15812, 15804, 1, 0, 0, 0, 15812, 15813, 1, 0, 0, 0, 15813, 15823, 1, 0, 0, 0, 15814, 15815, 5, 2203, 0, 0, 15815, 15816, 5, 114, 0, 0, 15816, 15821, 5, 2308, 0, 0, 15817, 15818, 7, 198, 0, 0, 15818, 15822, 5, 483, 0, 0, 15819, 15820, 5, 483, 0, 0, 15820, 15822, 3, 1454, 727, 0, 15821, 15817, 1, 0, 0, 0, 15821, 15819, 1, 0, 0, 0, 15822, 15824, 1, 0, 0, 0, 15823, 15814, 1, 0, 0, 0, 15823, 15824, 1, 0, 0, 0, 15824, 15828, 1, 0, 0, 0, 15825, 15827, 3, 846, 423, 0, 15826, 15825, 1, 0, 0, 0, 15827, 15830, 1, 0, 0, 0, 15828, 15826, 1, 0, 0, 0, 15828, 15829, 1, 0, 0, 0, 15829, 15832, 1, 0, 0, 0, 15830, 15828, 1, 0, 0, 0, 15831, 15833, 3, 1686, 843, 0, 15832, 15831, 1, 0, 0, 0, 15832, 15833, 1, 0, 0, 0, 15833, 1681, 1, 0, 0, 0, 15834, 15847, 3, 1684, 842, 0, 15835, 15837, 5, 640, 0, 0, 15836, 15838, 5, 44, 0, 0, 15837, 15836, 1, 0, 0, 0, 15837, 15838, 1, 0, 0, 0, 15838, 15840, 1, 0, 0, 0, 15839, 15835, 1, 0, 0, 0, 15839, 15840, 1, 0, 0, 0, 15840, 15841, 1, 0, 0, 0, 15841, 15842, 5, 69, 0, 0, 15842, 15843, 5, 2447, 0, 0, 15843, 15844, 3, 2078, 1039, 0, 15844, 15845, 5, 2448, 0, 0, 15845, 15847, 1, 0, 0, 0, 15846, 15834, 1, 0, 0, 0, 15846, 15839, 1, 0, 0, 0, 15847, 1683, 1, 0, 0, 0, 15848, 15856, 5, 640, 0, 0, 15849, 15857, 5, 44, 0, 0, 15850, 15851, 5, 160, 0, 0, 15851, 15854, 5, 389, 0, 0, 15852, 15853, 5, 1259, 0, 0, 15853, 15855, 5, 1228, 0, 0, 15854, 15852, 1, 0, 0, 0, 15854, 15855, 1, 0, 0, 0, 15855, 15857, 1, 0, 0, 0, 15856, 15849, 1, 0, 0, 0, 15856, 15850, 1, 0, 0, 0, 15856, 15857, 1, 0, 0, 0, 15857, 15858, 1, 0, 0, 0, 15858, 15859, 5, 69, 0, 0, 15859, 15869, 5, 687, 0, 0, 15860, 15865, 5, 2447, 0, 0, 15861, 15864, 3, 328, 164, 0, 15862, 15864, 3, 326, 163, 0, 15863, 15861, 1, 0, 0, 0, 15863, 15862, 1, 0, 0, 0, 15864, 15867, 1, 0, 0, 0, 15865, 15863, 1, 0, 0, 0, 15865, 15866, 1, 0, 0, 0, 15866, 15868, 1, 0, 0, 0, 15867, 15865, 1, 0, 0, 0, 15868, 15870, 5, 2448, 0, 0, 15869, 15860, 1, 0, 0, 0, 15869, 15870, 1, 0, 0, 0, 15870, 1685, 1, 0, 0, 0, 15871, 15872, 5, 160, 0, 0, 15872, 15873, 5, 2237, 0, 0, 15873, 15874, 5, 620, 0, 0, 15874, 15875, 5, 1746, 0, 0, 15875, 1687, 1, 0, 0, 0, 15876, 15877, 5, 530, 0, 0, 15877, 15882, 5, 2246, 0, 0, 15878, 15879, 7, 198, 0, 0, 15879, 15883, 5, 483, 0, 0, 15880, 15881, 5, 483, 0, 0, 15881, 15883, 3, 1454, 727, 0, 15882, 15878, 1, 0, 0, 0, 15882, 15880, 1, 0, 0, 0, 15883, 1689, 1, 0, 0, 0, 15884, 15885, 5, 1013, 0, 0, 15885, 15888, 5, 2083, 0, 0, 15886, 15889, 3, 1692, 846, 0, 15887, 15889, 5, 240, 0, 0, 15888, 15886, 1, 0, 0, 0, 15888, 15887, 1, 0, 0, 0, 15889, 15891, 1, 0, 0, 0, 15890, 15892, 3, 1694, 847, 0, 15891, 15890, 1, 0, 0, 0, 15891, 15892, 1, 0, 0, 0, 15892, 15894, 1, 0, 0, 0, 15893, 15895, 7, 199, 0, 0, 15894, 15893, 1, 0, 0, 0, 15894, 15895, 1, 0, 0, 0, 15895, 15896, 1, 0, 0, 0, 15896, 15897, 5, 1763, 0, 0, 15897, 15898, 5, 69, 0, 0, 15898, 15912, 3, 2342, 1171, 0, 15899, 15906, 5, 2447, 0, 0, 15900, 15901, 5, 2447, 0, 0, 15901, 15902, 3, 1058, 529, 0, 15902, 15903, 5, 2448, 0, 0, 15903, 15907, 1, 0, 0, 0, 15904, 15907, 3, 1202, 601, 0, 15905, 15907, 3, 1660, 830, 0, 15906, 15900, 1, 0, 0, 0, 15906, 15904, 1, 0, 0, 0, 15906, 15905, 1, 0, 0, 0, 15907, 15908, 1, 0, 0, 0, 15908, 15906, 1, 0, 0, 0, 15908, 15909, 1, 0, 0, 0, 15909, 15910, 1, 0, 0, 0, 15910, 15911, 5, 2448, 0, 0, 15911, 15913, 1, 0, 0, 0, 15912, 15899, 1, 0, 0, 0, 15912, 15913, 1, 0, 0, 0, 15913, 15919, 1, 0, 0, 0, 15914, 15916, 5, 1586, 0, 0, 15915, 15917, 5, 69, 0, 0, 15916, 15915, 1, 0, 0, 0, 15916, 15917, 1, 0, 0, 0, 15917, 15918, 1, 0, 0, 0, 15918, 15920, 7, 194, 0, 0, 15919, 15914, 1, 0, 0, 0, 15919, 15920, 1, 0, 0, 0, 15920, 1691, 1, 0, 0, 0, 15921, 15922, 3, 2410, 1205, 0, 15922, 1693, 1, 0, 0, 0, 15923, 15925, 5, 486, 0, 0, 15924, 15923, 1, 0, 0, 0, 15924, 15925, 1, 0, 0, 0, 15925, 15926, 1, 0, 0, 0, 15926, 15927, 5, 785, 0, 0, 15927, 15929, 5, 1246, 0, 0, 15928, 15930, 5, 2166, 0, 0, 15929, 15928, 1, 0, 0, 0, 15929, 15930, 1, 0, 0, 0, 15930, 15931, 1, 0, 0, 0, 15931, 15932, 5, 2447, 0, 0, 15932, 15933, 3, 2314, 1157, 0, 15933, 15934, 5, 2448, 0, 0, 15934, 15943, 1, 0, 0, 0, 15935, 15937, 5, 1204, 0, 0, 15936, 15935, 1, 0, 0, 0, 15936, 15937, 1, 0, 0, 0, 15937, 15938, 1, 0, 0, 0, 15938, 15939, 5, 1780, 0, 0, 15939, 15940, 5, 82, 0, 0, 15940, 15941, 5, 38, 0, 0, 15941, 15943, 5, 848, 0, 0, 15942, 15924, 1, 0, 0, 0, 15942, 15936, 1, 0, 0, 0, 15943, 1695, 1, 0, 0, 0, 15944, 15947, 3, 2410, 1205, 0, 15945, 15947, 5, 2444, 0, 0, 15946, 15944, 1, 0, 0, 0, 15946, 15945, 1, 0, 0, 0, 15947, 1697, 1, 0, 0, 0, 15948, 15949, 5, 1789, 0, 0, 15949, 15952, 5, 888, 0, 0, 15950, 15953, 3, 1280, 640, 0, 15951, 15953, 3, 1282, 641, 0, 15952, 15950, 1, 0, 0, 0, 15952, 15951, 1, 0, 0, 0, 15953, 1699, 1, 0, 0, 0, 15954, 15955, 5, 237, 0, 0, 15955, 15956, 3, 2410, 1205, 0, 15956, 15957, 3, 1694, 847, 0, 15957, 1701, 1, 0, 0, 0, 15958, 15959, 5, 21, 0, 0, 15959, 15969, 5, 2447, 0, 0, 15960, 15965, 3, 852, 426, 0, 15961, 15962, 5, 2453, 0, 0, 15962, 15964, 3, 852, 426, 0, 15963, 15961, 1, 0, 0, 0, 15964, 15967, 1, 0, 0, 0, 15965, 15963, 1, 0, 0, 0, 15965, 15966, 1, 0, 0, 0, 15966, 15970, 1, 0, 0, 0, 15967, 15965, 1, 0, 0, 0, 15968, 15970, 3, 850, 425, 0, 15969, 15960, 1, 0, 0, 0, 15969, 15968, 1, 0, 0, 0, 15970, 15971, 1, 0, 0, 0, 15971, 15972, 5, 2448, 0, 0, 15972, 16013, 1, 0, 0, 0, 15973, 15976, 5, 21, 0, 0, 15974, 15977, 3, 852, 426, 0, 15975, 15977, 3, 850, 425, 0, 15976, 15974, 1, 0, 0, 0, 15976, 15975, 1, 0, 0, 0, 15977, 16013, 1, 0, 0, 0, 15978, 15995, 5, 980, 0, 0, 15979, 15980, 5, 286, 0, 0, 15980, 15996, 3, 2310, 1155, 0, 15981, 15982, 5, 1451, 0, 0, 15982, 15996, 5, 816, 0, 0, 15983, 15984, 5, 2183, 0, 0, 15984, 15985, 5, 2447, 0, 0, 15985, 15990, 3, 2340, 1170, 0, 15986, 15987, 5, 2453, 0, 0, 15987, 15989, 3, 2340, 1170, 0, 15988, 15986, 1, 0, 0, 0, 15989, 15992, 1, 0, 0, 0, 15990, 15988, 1, 0, 0, 0, 15990, 15991, 1, 0, 0, 0, 15991, 15993, 1, 0, 0, 0, 15992, 15990, 1, 0, 0, 0, 15993, 15994, 5, 2448, 0, 0, 15994, 15996, 1, 0, 0, 0, 15995, 15979, 1, 0, 0, 0, 15995, 15981, 1, 0, 0, 0, 15995, 15983, 1, 0, 0, 0, 15996, 15997, 1, 0, 0, 0, 15997, 15999, 3, 854, 427, 0, 15998, 16000, 5, 179, 0, 0, 15999, 15998, 1, 0, 0, 0, 15999, 16000, 1, 0, 0, 0, 16000, 16013, 1, 0, 0, 0, 16001, 16002, 5, 1559, 0, 0, 16002, 16003, 5, 286, 0, 0, 16003, 16004, 3, 1704, 852, 0, 16004, 16005, 5, 2141, 0, 0, 16005, 16006, 3, 1706, 853, 0, 16006, 16013, 1, 0, 0, 0, 16007, 16009, 3, 1708, 854, 0, 16008, 16007, 1, 0, 0, 0, 16009, 16010, 1, 0, 0, 0, 16010, 16008, 1, 0, 0, 0, 16010, 16011, 1, 0, 0, 0, 16011, 16013, 1, 0, 0, 0, 16012, 15958, 1, 0, 0, 0, 16012, 15973, 1, 0, 0, 0, 16012, 15978, 1, 0, 0, 0, 16012, 16001, 1, 0, 0, 0, 16012, 16008, 1, 0, 0, 0, 16013, 1703, 1, 0, 0, 0, 16014, 16015, 3, 2310, 1155, 0, 16015, 1705, 1, 0, 0, 0, 16016, 16017, 3, 2310, 1155, 0, 16017, 1707, 1, 0, 0, 0, 16018, 16035, 5, 469, 0, 0, 16019, 16020, 5, 1451, 0, 0, 16020, 16036, 5, 816, 0, 0, 16021, 16022, 5, 2183, 0, 0, 16022, 16023, 5, 2447, 0, 0, 16023, 16028, 3, 2340, 1170, 0, 16024, 16025, 5, 2453, 0, 0, 16025, 16027, 3, 2340, 1170, 0, 16026, 16024, 1, 0, 0, 0, 16027, 16030, 1, 0, 0, 0, 16028, 16026, 1, 0, 0, 0, 16028, 16029, 1, 0, 0, 0, 16029, 16031, 1, 0, 0, 0, 16030, 16028, 1, 0, 0, 0, 16031, 16032, 5, 2448, 0, 0, 16032, 16036, 1, 0, 0, 0, 16033, 16034, 5, 286, 0, 0, 16034, 16036, 3, 2310, 1155, 0, 16035, 16019, 1, 0, 0, 0, 16035, 16021, 1, 0, 0, 0, 16035, 16033, 1, 0, 0, 0, 16036, 16038, 1, 0, 0, 0, 16037, 16039, 5, 179, 0, 0, 16038, 16037, 1, 0, 0, 0, 16038, 16039, 1, 0, 0, 0, 16039, 16042, 1, 0, 0, 0, 16040, 16041, 7, 200, 0, 0, 16041, 16043, 5, 717, 0, 0, 16042, 16040, 1, 0, 0, 0, 16042, 16043, 1, 0, 0, 0, 16043, 16045, 1, 0, 0, 0, 16044, 16046, 5, 1256, 0, 0, 16045, 16044, 1, 0, 0, 0, 16045, 16046, 1, 0, 0, 0, 16046, 1709, 1, 0, 0, 0, 16047, 16048, 5, 200, 0, 0, 16048, 16049, 5, 2447, 0, 0, 16049, 16050, 3, 2074, 1037, 0, 16050, 16052, 5, 2448, 0, 0, 16051, 16053, 5, 429, 0, 0, 16052, 16051, 1, 0, 0, 0, 16052, 16053, 1, 0, 0, 0, 16053, 1711, 1, 0, 0, 0, 16054, 16055, 5, 618, 0, 0, 16055, 16056, 5, 816, 0, 0, 16056, 16057, 3, 2360, 1180, 0, 16057, 16059, 3, 1714, 857, 0, 16058, 16060, 3, 1716, 858, 0, 16059, 16058, 1, 0, 0, 0, 16059, 16060, 1, 0, 0, 0, 16060, 1713, 1, 0, 0, 0, 16061, 16062, 5, 1528, 0, 0, 16062, 16064, 3, 2342, 1171, 0, 16063, 16065, 3, 2360, 1180, 0, 16064, 16063, 1, 0, 0, 0, 16064, 16065, 1, 0, 0, 0, 16065, 16073, 1, 0, 0, 0, 16066, 16067, 5, 1259, 0, 0, 16067, 16071, 5, 403, 0, 0, 16068, 16072, 5, 179, 0, 0, 16069, 16070, 5, 1671, 0, 0, 16070, 16072, 5, 1228, 0, 0, 16071, 16068, 1, 0, 0, 0, 16071, 16069, 1, 0, 0, 0, 16072, 16074, 1, 0, 0, 0, 16073, 16066, 1, 0, 0, 0, 16073, 16074, 1, 0, 0, 0, 16074, 1715, 1, 0, 0, 0, 16075, 16076, 5, 1259, 0, 0, 16076, 16080, 5, 403, 0, 0, 16077, 16081, 5, 179, 0, 0, 16078, 16079, 5, 1671, 0, 0, 16079, 16081, 5, 1228, 0, 0, 16080, 16077, 1, 0, 0, 0, 16080, 16078, 1, 0, 0, 0, 16081, 1717, 1, 0, 0, 0, 16082, 16084, 5, 382, 0, 0, 16083, 16085, 3, 1740, 870, 0, 16084, 16083, 1, 0, 0, 0, 16084, 16085, 1, 0, 0, 0, 16085, 16087, 1, 0, 0, 0, 16086, 16082, 1, 0, 0, 0, 16086, 16087, 1, 0, 0, 0, 16087, 16088, 1, 0, 0, 0, 16088, 16089, 5, 113, 0, 0, 16089, 16096, 3, 1770, 885, 0, 16090, 16092, 5, 535, 0, 0, 16091, 16093, 3, 1822, 911, 0, 16092, 16091, 1, 0, 0, 0, 16093, 16094, 1, 0, 0, 0, 16094, 16092, 1, 0, 0, 0, 16094, 16095, 1, 0, 0, 0, 16095, 16097, 1, 0, 0, 0, 16096, 16090, 1, 0, 0, 0, 16096, 16097, 1, 0, 0, 0, 16097, 16098, 1, 0, 0, 0, 16098, 16099, 5, 508, 0, 0, 16099, 1719, 1, 0, 0, 0, 16100, 16101, 5, 88, 0, 0, 16101, 16102, 7, 92, 0, 0, 16102, 1721, 1, 0, 0, 0, 16103, 16106, 3, 1724, 862, 0, 16104, 16106, 3, 1726, 863, 0, 16105, 16103, 1, 0, 0, 0, 16105, 16104, 1, 0, 0, 0, 16106, 1723, 1, 0, 0, 0, 16107, 16108, 5, 823, 0, 0, 16108, 16109, 5, 792, 0, 0, 16109, 16110, 5, 997, 0, 0, 16110, 16111, 5, 2443, 0, 0, 16111, 1725, 1, 0, 0, 0, 16112, 16113, 5, 823, 0, 0, 16113, 16116, 5, 213, 0, 0, 16114, 16116, 5, 560, 0, 0, 16115, 16112, 1, 0, 0, 0, 16115, 16114, 1, 0, 0, 0, 16116, 16128, 1, 0, 0, 0, 16117, 16118, 5, 997, 0, 0, 16118, 16119, 3, 2404, 1202, 0, 16119, 16120, 5, 849, 0, 0, 16120, 16121, 3, 2402, 1201, 0, 16121, 16129, 1, 0, 0, 0, 16122, 16123, 5, 849, 0, 0, 16123, 16126, 3, 2402, 1201, 0, 16124, 16125, 5, 997, 0, 0, 16125, 16127, 3, 2404, 1202, 0, 16126, 16124, 1, 0, 0, 0, 16126, 16127, 1, 0, 0, 0, 16127, 16129, 1, 0, 0, 0, 16128, 16117, 1, 0, 0, 0, 16128, 16122, 1, 0, 0, 0, 16129, 16131, 1, 0, 0, 0, 16130, 16132, 3, 1728, 864, 0, 16131, 16130, 1, 0, 0, 0, 16131, 16132, 1, 0, 0, 0, 16132, 16135, 1, 0, 0, 0, 16133, 16134, 5, 2308, 0, 0, 16134, 16136, 5, 296, 0, 0, 16135, 16133, 1, 0, 0, 0, 16135, 16136, 1, 0, 0, 0, 16136, 16138, 1, 0, 0, 0, 16137, 16139, 3, 1730, 865, 0, 16138, 16137, 1, 0, 0, 0, 16138, 16139, 1, 0, 0, 0, 16139, 1727, 1, 0, 0, 0, 16140, 16141, 5, 34, 0, 0, 16141, 16142, 5, 738, 0, 0, 16142, 16143, 5, 2447, 0, 0, 16143, 16144, 3, 2076, 1038, 0, 16144, 16145, 5, 2448, 0, 0, 16145, 1729, 1, 0, 0, 0, 16146, 16147, 5, 1335, 0, 0, 16147, 16148, 5, 2447, 0, 0, 16148, 16153, 3, 1732, 866, 0, 16149, 16150, 5, 2453, 0, 0, 16150, 16152, 3, 1732, 866, 0, 16151, 16149, 1, 0, 0, 0, 16152, 16155, 1, 0, 0, 0, 16153, 16151, 1, 0, 0, 0, 16153, 16154, 1, 0, 0, 0, 16154, 16156, 1, 0, 0, 0, 16155, 16153, 1, 0, 0, 0, 16156, 16157, 5, 2448, 0, 0, 16157, 1731, 1, 0, 0, 0, 16158, 16179, 5, 296, 0, 0, 16159, 16162, 5, 1648, 0, 0, 16160, 16163, 5, 2434, 0, 0, 16161, 16163, 3, 1734, 867, 0, 16162, 16160, 1, 0, 0, 0, 16162, 16161, 1, 0, 0, 0, 16162, 16163, 1, 0, 0, 0, 16163, 16179, 1, 0, 0, 0, 16164, 16167, 3, 2294, 1147, 0, 16165, 16167, 5, 1586, 0, 0, 16166, 16164, 1, 0, 0, 0, 16166, 16165, 1, 0, 0, 0, 16167, 16169, 1, 0, 0, 0, 16168, 16170, 3, 1734, 867, 0, 16169, 16168, 1, 0, 0, 0, 16169, 16170, 1, 0, 0, 0, 16170, 16173, 1, 0, 0, 0, 16171, 16172, 5, 160, 0, 0, 16172, 16174, 5, 1527, 0, 0, 16173, 16171, 1, 0, 0, 0, 16173, 16174, 1, 0, 0, 0, 16174, 16176, 1, 0, 0, 0, 16175, 16177, 3, 2410, 1205, 0, 16176, 16175, 1, 0, 0, 0, 16176, 16177, 1, 0, 0, 0, 16177, 16179, 1, 0, 0, 0, 16178, 16158, 1, 0, 0, 0, 16178, 16159, 1, 0, 0, 0, 16178, 16166, 1, 0, 0, 0, 16179, 1733, 1, 0, 0, 0, 16180, 16182, 5, 733, 0, 0, 16181, 16183, 7, 201, 0, 0, 16182, 16181, 1, 0, 0, 0, 16182, 16183, 1, 0, 0, 0, 16183, 16190, 1, 0, 0, 0, 16184, 16190, 5, 844, 0, 0, 16185, 16190, 5, 2428, 0, 0, 16186, 16190, 5, 2430, 0, 0, 16187, 16190, 5, 2426, 0, 0, 16188, 16190, 5, 2427, 0, 0, 16189, 16180, 1, 0, 0, 0, 16189, 16184, 1, 0, 0, 0, 16189, 16185, 1, 0, 0, 0, 16189, 16186, 1, 0, 0, 0, 16189, 16187, 1, 0, 0, 0, 16189, 16188, 1, 0, 0, 0, 16190, 1735, 1, 0, 0, 0, 16191, 16195, 3, 2294, 1147, 0, 16192, 16194, 7, 202, 0, 0, 16193, 16192, 1, 0, 0, 0, 16194, 16197, 1, 0, 0, 0, 16195, 16193, 1, 0, 0, 0, 16195, 16196, 1, 0, 0, 0, 16196, 16199, 1, 0, 0, 0, 16197, 16195, 1, 0, 0, 0, 16198, 16200, 3, 2374, 1187, 0, 16199, 16198, 1, 0, 0, 0, 16199, 16200, 1, 0, 0, 0, 16200, 16202, 1, 0, 0, 0, 16201, 16203, 3, 1738, 869, 0, 16202, 16201, 1, 0, 0, 0, 16202, 16203, 1, 0, 0, 0, 16203, 1737, 1, 0, 0, 0, 16204, 16205, 7, 203, 0, 0, 16205, 16206, 3, 2078, 1039, 0, 16206, 1739, 1, 0, 0, 0, 16207, 16209, 3, 1742, 871, 0, 16208, 16207, 1, 0, 0, 0, 16209, 16210, 1, 0, 0, 0, 16210, 16208, 1, 0, 0, 0, 16210, 16211, 1, 0, 0, 0, 16211, 1741, 1, 0, 0, 0, 16212, 16224, 3, 1754, 877, 0, 16213, 16224, 3, 1752, 876, 0, 16214, 16224, 3, 162, 81, 0, 16215, 16224, 3, 164, 82, 0, 16216, 16224, 3, 1744, 872, 0, 16217, 16224, 3, 1746, 873, 0, 16218, 16224, 3, 1748, 874, 0, 16219, 16224, 3, 1762, 881, 0, 16220, 16224, 3, 178, 89, 0, 16221, 16224, 3, 176, 88, 0, 16222, 16224, 3, 1814, 907, 0, 16223, 16212, 1, 0, 0, 0, 16223, 16213, 1, 0, 0, 0, 16223, 16214, 1, 0, 0, 0, 16223, 16215, 1, 0, 0, 0, 16223, 16216, 1, 0, 0, 0, 16223, 16217, 1, 0, 0, 0, 16223, 16218, 1, 0, 0, 0, 16223, 16219, 1, 0, 0, 0, 16223, 16220, 1, 0, 0, 0, 16223, 16221, 1, 0, 0, 0, 16223, 16222, 1, 0, 0, 0, 16224, 1743, 1, 0, 0, 0, 16225, 16227, 3, 2402, 1201, 0, 16226, 16228, 5, 284, 0, 0, 16227, 16226, 1, 0, 0, 0, 16227, 16228, 1, 0, 0, 0, 16228, 16229, 1, 0, 0, 0, 16229, 16234, 3, 2374, 1187, 0, 16230, 16232, 5, 1204, 0, 0, 16231, 16230, 1, 0, 0, 0, 16231, 16232, 1, 0, 0, 0, 16232, 16233, 1, 0, 0, 0, 16233, 16235, 5, 1228, 0, 0, 16234, 16231, 1, 0, 0, 0, 16234, 16235, 1, 0, 0, 0, 16235, 16237, 1, 0, 0, 0, 16236, 16238, 3, 1738, 869, 0, 16237, 16236, 1, 0, 0, 0, 16237, 16238, 1, 0, 0, 0, 16238, 16239, 1, 0, 0, 0, 16239, 16240, 5, 2470, 0, 0, 16240, 1745, 1, 0, 0, 0, 16241, 16242, 5, 1785, 0, 0, 16242, 16243, 3, 2402, 1201, 0, 16243, 16244, 5, 785, 0, 0, 16244, 16250, 3, 2374, 1187, 0, 16245, 16246, 5, 1495, 0, 0, 16246, 16247, 3, 2078, 1039, 0, 16247, 16248, 5, 2439, 0, 0, 16248, 16249, 3, 2078, 1039, 0, 16249, 16251, 1, 0, 0, 0, 16250, 16245, 1, 0, 0, 0, 16250, 16251, 1, 0, 0, 0, 16251, 16254, 1, 0, 0, 0, 16252, 16253, 5, 1204, 0, 0, 16253, 16255, 5, 1228, 0, 0, 16254, 16252, 1, 0, 0, 0, 16254, 16255, 1, 0, 0, 0, 16255, 16256, 1, 0, 0, 0, 16256, 16257, 5, 2470, 0, 0, 16257, 1747, 1, 0, 0, 0, 16258, 16259, 5, 343, 0, 0, 16259, 16271, 3, 2402, 1201, 0, 16260, 16261, 5, 2447, 0, 0, 16261, 16266, 3, 1750, 875, 0, 16262, 16263, 5, 2453, 0, 0, 16263, 16265, 3, 1750, 875, 0, 16264, 16262, 1, 0, 0, 0, 16265, 16268, 1, 0, 0, 0, 16266, 16264, 1, 0, 0, 0, 16266, 16267, 1, 0, 0, 0, 16267, 16269, 1, 0, 0, 0, 16268, 16266, 1, 0, 0, 0, 16269, 16270, 5, 2448, 0, 0, 16270, 16272, 1, 0, 0, 0, 16271, 16260, 1, 0, 0, 0, 16271, 16272, 1, 0, 0, 0, 16272, 16275, 1, 0, 0, 0, 16273, 16274, 5, 1586, 0, 0, 16274, 16276, 3, 2374, 1187, 0, 16275, 16273, 1, 0, 0, 0, 16275, 16276, 1, 0, 0, 0, 16276, 16279, 1, 0, 0, 0, 16277, 16278, 5, 785, 0, 0, 16278, 16280, 3, 1870, 935, 0, 16279, 16277, 1, 0, 0, 0, 16279, 16280, 1, 0, 0, 0, 16280, 16281, 1, 0, 0, 0, 16281, 16282, 5, 2470, 0, 0, 16282, 1749, 1, 0, 0, 0, 16283, 16288, 3, 2294, 1147, 0, 16284, 16286, 5, 738, 0, 0, 16285, 16284, 1, 0, 0, 0, 16285, 16286, 1, 0, 0, 0, 16286, 16287, 1, 0, 0, 0, 16287, 16289, 3, 2374, 1187, 0, 16288, 16285, 1, 0, 0, 0, 16288, 16289, 1, 0, 0, 0, 16289, 16291, 1, 0, 0, 0, 16290, 16292, 3, 1738, 869, 0, 16291, 16290, 1, 0, 0, 0, 16291, 16292, 1, 0, 0, 0, 16292, 1751, 1, 0, 0, 0, 16293, 16294, 3, 2402, 1201, 0, 16294, 16295, 5, 535, 0, 0, 16295, 16296, 5, 2470, 0, 0, 16296, 1753, 1, 0, 0, 0, 16297, 16338, 5, 1433, 0, 0, 16298, 16339, 5, 1660, 0, 0, 16299, 16339, 5, 96, 0, 0, 16300, 16301, 5, 536, 0, 0, 16301, 16302, 5, 2447, 0, 0, 16302, 16303, 3, 2318, 1159, 0, 16303, 16304, 5, 2453, 0, 0, 16304, 16305, 3, 2398, 1199, 0, 16305, 16306, 5, 2448, 0, 0, 16306, 16339, 1, 0, 0, 0, 16307, 16308, 5, 744, 0, 0, 16308, 16309, 5, 2447, 0, 0, 16309, 16310, 3, 2402, 1201, 0, 16310, 16311, 5, 2453, 0, 0, 16311, 16312, 3, 2078, 1039, 0, 16312, 16313, 5, 2448, 0, 0, 16313, 16339, 1, 0, 0, 0, 16314, 16315, 5, 1577, 0, 0, 16315, 16318, 5, 2447, 0, 0, 16316, 16319, 3, 2402, 1201, 0, 16317, 16319, 5, 389, 0, 0, 16318, 16316, 1, 0, 0, 0, 16318, 16317, 1, 0, 0, 0, 16319, 16322, 1, 0, 0, 0, 16320, 16321, 5, 2453, 0, 0, 16321, 16323, 3, 2402, 1201, 0, 16322, 16320, 1, 0, 0, 0, 16323, 16324, 1, 0, 0, 0, 16324, 16322, 1, 0, 0, 0, 16324, 16325, 1, 0, 0, 0, 16325, 16326, 1, 0, 0, 0, 16326, 16327, 5, 2448, 0, 0, 16327, 16339, 1, 0, 0, 0, 16328, 16329, 5, 409, 0, 0, 16329, 16330, 5, 2447, 0, 0, 16330, 16333, 3, 2402, 1201, 0, 16331, 16332, 5, 2453, 0, 0, 16332, 16334, 5, 2443, 0, 0, 16333, 16331, 1, 0, 0, 0, 16333, 16334, 1, 0, 0, 0, 16334, 16335, 1, 0, 0, 0, 16335, 16336, 5, 2448, 0, 0, 16336, 16339, 1, 0, 0, 0, 16337, 16339, 5, 2171, 0, 0, 16338, 16298, 1, 0, 0, 0, 16338, 16299, 1, 0, 0, 0, 16338, 16300, 1, 0, 0, 0, 16338, 16307, 1, 0, 0, 0, 16338, 16314, 1, 0, 0, 0, 16338, 16328, 1, 0, 0, 0, 16338, 16337, 1, 0, 0, 0, 16339, 16340, 1, 0, 0, 0, 16340, 16341, 5, 2470, 0, 0, 16341, 1755, 1, 0, 0, 0, 16342, 16343, 5, 1512, 0, 0, 16343, 16344, 5, 2447, 0, 0, 16344, 16349, 3, 1758, 879, 0, 16345, 16346, 5, 2453, 0, 0, 16346, 16348, 3, 1758, 879, 0, 16347, 16345, 1, 0, 0, 0, 16348, 16351, 1, 0, 0, 0, 16349, 16347, 1, 0, 0, 0, 16349, 16350, 1, 0, 0, 0, 16350, 16352, 1, 0, 0, 0, 16351, 16349, 1, 0, 0, 0, 16352, 16353, 5, 2448, 0, 0, 16353, 1757, 1, 0, 0, 0, 16354, 16356, 3, 2340, 1170, 0, 16355, 16357, 3, 2374, 1187, 0, 16356, 16355, 1, 0, 0, 0, 16356, 16357, 1, 0, 0, 0, 16357, 16360, 1, 0, 0, 0, 16358, 16359, 5, 1204, 0, 0, 16359, 16361, 5, 1228, 0, 0, 16360, 16358, 1, 0, 0, 0, 16360, 16361, 1, 0, 0, 0, 16361, 16363, 1, 0, 0, 0, 16362, 16364, 3, 1738, 869, 0, 16363, 16362, 1, 0, 0, 0, 16363, 16364, 1, 0, 0, 0, 16364, 1759, 1, 0, 0, 0, 16365, 16366, 5, 1530, 0, 0, 16366, 16369, 5, 343, 0, 0, 16367, 16368, 5, 1586, 0, 0, 16368, 16370, 3, 2374, 1187, 0, 16369, 16367, 1, 0, 0, 0, 16369, 16370, 1, 0, 0, 0, 16370, 1761, 1, 0, 0, 0, 16371, 16372, 5, 2166, 0, 0, 16372, 16373, 3, 2402, 1201, 0, 16373, 16378, 5, 785, 0, 0, 16374, 16379, 3, 1764, 882, 0, 16375, 16379, 3, 1768, 884, 0, 16376, 16379, 3, 1756, 878, 0, 16377, 16379, 3, 1760, 880, 0, 16378, 16374, 1, 0, 0, 0, 16378, 16375, 1, 0, 0, 0, 16378, 16376, 1, 0, 0, 0, 16378, 16377, 1, 0, 0, 0, 16379, 16380, 1, 0, 0, 0, 16380, 16381, 5, 2470, 0, 0, 16381, 1763, 1, 0, 0, 0, 16382, 16383, 5, 2083, 0, 0, 16383, 16384, 5, 1246, 0, 0, 16384, 16387, 3, 2374, 1187, 0, 16385, 16386, 5, 1204, 0, 0, 16386, 16388, 5, 1228, 0, 0, 16387, 16385, 1, 0, 0, 0, 16387, 16388, 1, 0, 0, 0, 16388, 16390, 1, 0, 0, 0, 16389, 16391, 3, 1766, 883, 0, 16390, 16389, 1, 0, 0, 0, 16390, 16391, 1, 0, 0, 0, 16391, 1765, 1, 0, 0, 0, 16392, 16395, 5, 713, 0, 0, 16393, 16395, 5, 717, 0, 0, 16394, 16392, 1, 0, 0, 0, 16394, 16393, 1, 0, 0, 0, 16395, 16396, 1, 0, 0, 0, 16396, 16397, 5, 160, 0, 0, 16397, 16398, 3, 2374, 1187, 0, 16398, 1767, 1, 0, 0, 0, 16399, 16405, 5, 2267, 0, 0, 16400, 16402, 5, 2269, 0, 0, 16401, 16400, 1, 0, 0, 0, 16401, 16402, 1, 0, 0, 0, 16402, 16403, 1, 0, 0, 0, 16403, 16405, 5, 68, 0, 0, 16404, 16399, 1, 0, 0, 0, 16404, 16401, 1, 0, 0, 0, 16405, 16406, 1, 0, 0, 0, 16406, 16407, 5, 2447, 0, 0, 16407, 16408, 3, 2078, 1039, 0, 16408, 16409, 5, 2448, 0, 0, 16409, 16410, 5, 1246, 0, 0, 16410, 16413, 3, 2374, 1187, 0, 16411, 16412, 5, 1204, 0, 0, 16412, 16414, 5, 1228, 0, 0, 16413, 16411, 1, 0, 0, 0, 16413, 16414, 1, 0, 0, 0, 16414, 1769, 1, 0, 0, 0, 16415, 16417, 3, 1754, 877, 0, 16416, 16415, 1, 0, 0, 0, 16417, 16420, 1, 0, 0, 0, 16418, 16416, 1, 0, 0, 0, 16418, 16419, 1, 0, 0, 0, 16419, 16421, 1, 0, 0, 0, 16420, 16418, 1, 0, 0, 0, 16421, 16422, 3, 1774, 887, 0, 16422, 16423, 7, 204, 0, 0, 16423, 16427, 1, 0, 0, 0, 16424, 16427, 3, 1772, 886, 0, 16425, 16427, 3, 1814, 907, 0, 16426, 16418, 1, 0, 0, 0, 16426, 16424, 1, 0, 0, 0, 16426, 16425, 1, 0, 0, 0, 16427, 16428, 1, 0, 0, 0, 16428, 16426, 1, 0, 0, 0, 16428, 16429, 1, 0, 0, 0, 16429, 1771, 1, 0, 0, 0, 16430, 16431, 5, 2468, 0, 0, 16431, 16432, 5, 2468, 0, 0, 16432, 16433, 3, 2312, 1156, 0, 16433, 16434, 5, 2467, 0, 0, 16434, 16435, 5, 2467, 0, 0, 16435, 1773, 1, 0, 0, 0, 16436, 16454, 3, 1820, 910, 0, 16437, 16454, 3, 1828, 914, 0, 16438, 16454, 3, 1776, 888, 0, 16439, 16454, 3, 1778, 889, 0, 16440, 16454, 3, 1780, 890, 0, 16441, 16454, 3, 1782, 891, 0, 16442, 16454, 3, 1784, 892, 0, 16443, 16454, 3, 1790, 895, 0, 16444, 16454, 3, 1794, 897, 0, 16445, 16454, 3, 1804, 902, 0, 16446, 16454, 3, 1806, 903, 0, 16447, 16454, 3, 1808, 904, 0, 16448, 16454, 3, 2122, 1061, 0, 16449, 16454, 3, 1830, 915, 0, 16450, 16454, 3, 1810, 905, 0, 16451, 16454, 3, 1812, 906, 0, 16452, 16454, 3, 764, 382, 0, 16453, 16436, 1, 0, 0, 0, 16453, 16437, 1, 0, 0, 0, 16453, 16438, 1, 0, 0, 0, 16453, 16439, 1, 0, 0, 0, 16453, 16440, 1, 0, 0, 0, 16453, 16441, 1, 0, 0, 0, 16453, 16442, 1, 0, 0, 0, 16453, 16443, 1, 0, 0, 0, 16453, 16444, 1, 0, 0, 0, 16453, 16445, 1, 0, 0, 0, 16453, 16446, 1, 0, 0, 0, 16453, 16447, 1, 0, 0, 0, 16453, 16448, 1, 0, 0, 0, 16453, 16449, 1, 0, 0, 0, 16453, 16450, 1, 0, 0, 0, 16453, 16451, 1, 0, 0, 0, 16453, 16452, 1, 0, 0, 0, 16454, 1775, 1, 0, 0, 0, 16455, 16458, 3, 2384, 1192, 0, 16456, 16458, 3, 2382, 1191, 0, 16457, 16455, 1, 0, 0, 0, 16457, 16456, 1, 0, 0, 0, 16458, 16459, 1, 0, 0, 0, 16459, 16460, 5, 2457, 0, 0, 16460, 16461, 3, 2078, 1039, 0, 16461, 1777, 1, 0, 0, 0, 16462, 16464, 5, 297, 0, 0, 16463, 16465, 3, 2312, 1156, 0, 16464, 16463, 1, 0, 0, 0, 16464, 16465, 1, 0, 0, 0, 16465, 16468, 1, 0, 0, 0, 16466, 16467, 5, 2300, 0, 0, 16467, 16469, 3, 2074, 1037, 0, 16468, 16466, 1, 0, 0, 0, 16468, 16469, 1, 0, 0, 0, 16469, 1779, 1, 0, 0, 0, 16470, 16472, 5, 547, 0, 0, 16471, 16473, 3, 2312, 1156, 0, 16472, 16471, 1, 0, 0, 0, 16472, 16473, 1, 0, 0, 0, 16473, 16476, 1, 0, 0, 0, 16474, 16475, 5, 2300, 0, 0, 16475, 16477, 3, 2074, 1037, 0, 16476, 16474, 1, 0, 0, 0, 16476, 16477, 1, 0, 0, 0, 16477, 1781, 1, 0, 0, 0, 16478, 16479, 5, 646, 0, 0, 16479, 16480, 3, 2312, 1156, 0, 16480, 1783, 1, 0, 0, 0, 16481, 16482, 5, 691, 0, 0, 16482, 16483, 3, 2074, 1037, 0, 16483, 16484, 5, 2099, 0, 0, 16484, 16488, 3, 1770, 885, 0, 16485, 16487, 3, 1786, 893, 0, 16486, 16485, 1, 0, 0, 0, 16487, 16490, 1, 0, 0, 0, 16488, 16486, 1, 0, 0, 0, 16488, 16489, 1, 0, 0, 0, 16489, 16492, 1, 0, 0, 0, 16490, 16488, 1, 0, 0, 0, 16491, 16493, 3, 1788, 894, 0, 16492, 16491, 1, 0, 0, 0, 16492, 16493, 1, 0, 0, 0, 16493, 16494, 1, 0, 0, 0, 16494, 16495, 5, 508, 0, 0, 16495, 16496, 5, 691, 0, 0, 16496, 1785, 1, 0, 0, 0, 16497, 16498, 5, 492, 0, 0, 16498, 16499, 3, 2074, 1037, 0, 16499, 16500, 5, 2099, 0, 0, 16500, 16501, 3, 1770, 885, 0, 16501, 1787, 1, 0, 0, 0, 16502, 16503, 5, 491, 0, 0, 16503, 16504, 3, 1770, 885, 0, 16504, 1789, 1, 0, 0, 0, 16505, 16507, 3, 1772, 886, 0, 16506, 16505, 1, 0, 0, 0, 16506, 16507, 1, 0, 0, 0, 16507, 16512, 1, 0, 0, 0, 16508, 16509, 5, 2302, 0, 0, 16509, 16513, 3, 2074, 1037, 0, 16510, 16511, 5, 620, 0, 0, 16511, 16513, 3, 1792, 896, 0, 16512, 16508, 1, 0, 0, 0, 16512, 16510, 1, 0, 0, 0, 16512, 16513, 1, 0, 0, 0, 16513, 16514, 1, 0, 0, 0, 16514, 16515, 5, 894, 0, 0, 16515, 16516, 3, 1770, 885, 0, 16516, 16517, 5, 508, 0, 0, 16517, 16519, 5, 894, 0, 0, 16518, 16520, 3, 2312, 1156, 0, 16519, 16518, 1, 0, 0, 0, 16519, 16520, 1, 0, 0, 0, 16520, 1791, 1, 0, 0, 0, 16521, 16522, 3, 2328, 1164, 0, 16522, 16524, 5, 738, 0, 0, 16523, 16525, 5, 1588, 0, 0, 16524, 16523, 1, 0, 0, 0, 16524, 16525, 1, 0, 0, 0, 16525, 16526, 1, 0, 0, 0, 16526, 16527, 3, 1800, 900, 0, 16527, 16528, 5, 2439, 0, 0, 16528, 16529, 3, 1802, 901, 0, 16529, 16547, 1, 0, 0, 0, 16530, 16531, 3, 2332, 1166, 0, 16531, 16544, 5, 738, 0, 0, 16532, 16538, 3, 2330, 1165, 0, 16533, 16535, 5, 2447, 0, 0, 16534, 16536, 3, 2076, 1038, 0, 16535, 16534, 1, 0, 0, 0, 16535, 16536, 1, 0, 0, 0, 16536, 16537, 1, 0, 0, 0, 16537, 16539, 5, 2448, 0, 0, 16538, 16533, 1, 0, 0, 0, 16538, 16539, 1, 0, 0, 0, 16539, 16545, 1, 0, 0, 0, 16540, 16541, 5, 2447, 0, 0, 16541, 16542, 3, 1870, 935, 0, 16542, 16543, 5, 2448, 0, 0, 16543, 16545, 1, 0, 0, 0, 16544, 16532, 1, 0, 0, 0, 16544, 16540, 1, 0, 0, 0, 16545, 16547, 1, 0, 0, 0, 16546, 16521, 1, 0, 0, 0, 16546, 16530, 1, 0, 0, 0, 16547, 1793, 1, 0, 0, 0, 16548, 16549, 5, 615, 0, 0, 16549, 16550, 3, 2328, 1164, 0, 16550, 16551, 5, 738, 0, 0, 16551, 16554, 3, 1796, 898, 0, 16552, 16553, 5, 1617, 0, 0, 16553, 16555, 5, 537, 0, 0, 16554, 16552, 1, 0, 0, 0, 16554, 16555, 1, 0, 0, 0, 16555, 16558, 1, 0, 0, 0, 16556, 16559, 3, 1836, 918, 0, 16557, 16559, 3, 1832, 916, 0, 16558, 16556, 1, 0, 0, 0, 16558, 16557, 1, 0, 0, 0, 16559, 1795, 1, 0, 0, 0, 16560, 16561, 3, 1800, 900, 0, 16561, 16562, 5, 2439, 0, 0, 16562, 16563, 3, 1802, 901, 0, 16563, 16574, 1, 0, 0, 0, 16564, 16565, 5, 734, 0, 0, 16565, 16566, 5, 1246, 0, 0, 16566, 16568, 3, 2384, 1192, 0, 16567, 16569, 3, 1798, 899, 0, 16568, 16567, 1, 0, 0, 0, 16568, 16569, 1, 0, 0, 0, 16569, 16574, 1, 0, 0, 0, 16570, 16571, 5, 2257, 0, 0, 16571, 16572, 5, 1246, 0, 0, 16572, 16574, 3, 2328, 1164, 0, 16573, 16560, 1, 0, 0, 0, 16573, 16564, 1, 0, 0, 0, 16573, 16570, 1, 0, 0, 0, 16574, 1797, 1, 0, 0, 0, 16575, 16576, 5, 118, 0, 0, 16576, 16577, 3, 1800, 900, 0, 16577, 16578, 5, 49, 0, 0, 16578, 16579, 3, 1802, 901, 0, 16579, 1799, 1, 0, 0, 0, 16580, 16581, 3, 2102, 1051, 0, 16581, 1801, 1, 0, 0, 0, 16582, 16583, 3, 2102, 1051, 0, 16583, 1803, 1, 0, 0, 0, 16584, 16585, 5, 1228, 0, 0, 16585, 1805, 1, 0, 0, 0, 16586, 16588, 5, 1492, 0, 0, 16587, 16589, 3, 2318, 1159, 0, 16588, 16587, 1, 0, 0, 0, 16588, 16589, 1, 0, 0, 0, 16589, 1807, 1, 0, 0, 0, 16590, 16592, 5, 1586, 0, 0, 16591, 16593, 3, 2078, 1039, 0, 16592, 16591, 1, 0, 0, 0, 16592, 16593, 1, 0, 0, 0, 16593, 1809, 1, 0, 0, 0, 16594, 16596, 5, 173, 0, 0, 16595, 16594, 1, 0, 0, 0, 16595, 16596, 1, 0, 0, 0, 16596, 16597, 1, 0, 0, 0, 16597, 16599, 3, 2288, 1144, 0, 16598, 16600, 3, 2364, 1182, 0, 16599, 16598, 1, 0, 0, 0, 16599, 16600, 1, 0, 0, 0, 16600, 16608, 1, 0, 0, 0, 16601, 16602, 5, 2440, 0, 0, 16602, 16604, 3, 2288, 1144, 0, 16603, 16605, 3, 2364, 1182, 0, 16604, 16603, 1, 0, 0, 0, 16604, 16605, 1, 0, 0, 0, 16605, 16607, 1, 0, 0, 0, 16606, 16601, 1, 0, 0, 0, 16607, 16610, 1, 0, 0, 0, 16608, 16606, 1, 0, 0, 0, 16608, 16609, 1, 0, 0, 0, 16609, 16613, 1, 0, 0, 0, 16610, 16608, 1, 0, 0, 0, 16611, 16612, 5, 779, 0, 0, 16612, 16614, 3, 2382, 1191, 0, 16613, 16611, 1, 0, 0, 0, 16613, 16614, 1, 0, 0, 0, 16614, 1811, 1, 0, 0, 0, 16615, 16616, 5, 1395, 0, 0, 16616, 16617, 5, 1606, 0, 0, 16617, 16618, 5, 2447, 0, 0, 16618, 16619, 3, 2078, 1039, 0, 16619, 16620, 5, 2448, 0, 0, 16620, 1813, 1, 0, 0, 0, 16621, 16622, 5, 460, 0, 0, 16622, 16623, 3, 2074, 1037, 0, 16623, 16624, 5, 461, 0, 0, 16624, 16629, 3, 1818, 909, 0, 16625, 16626, 5, 457, 0, 0, 16626, 16628, 3, 1818, 909, 0, 16627, 16625, 1, 0, 0, 0, 16628, 16631, 1, 0, 0, 0, 16629, 16627, 1, 0, 0, 0, 16629, 16630, 1, 0, 0, 0, 16630, 16634, 1, 0, 0, 0, 16631, 16629, 1, 0, 0, 0, 16632, 16633, 5, 456, 0, 0, 16633, 16635, 3, 1818, 909, 0, 16634, 16632, 1, 0, 0, 0, 16634, 16635, 1, 0, 0, 0, 16635, 16636, 1, 0, 0, 0, 16636, 16637, 5, 458, 0, 0, 16637, 1815, 1, 0, 0, 0, 16638, 16639, 5, 459, 0, 0, 16639, 16640, 3, 2102, 1051, 0, 16640, 16641, 5, 458, 0, 0, 16641, 1817, 1, 0, 0, 0, 16642, 16644, 3, 1754, 877, 0, 16643, 16642, 1, 0, 0, 0, 16643, 16644, 1, 0, 0, 0, 16644, 16645, 1, 0, 0, 0, 16645, 16646, 3, 1774, 887, 0, 16646, 16647, 5, 2470, 0, 0, 16647, 16653, 1, 0, 0, 0, 16648, 16653, 3, 1744, 872, 0, 16649, 16653, 3, 1816, 908, 0, 16650, 16653, 3, 176, 88, 0, 16651, 16653, 3, 178, 89, 0, 16652, 16643, 1, 0, 0, 0, 16652, 16648, 1, 0, 0, 0, 16652, 16649, 1, 0, 0, 0, 16652, 16650, 1, 0, 0, 0, 16652, 16651, 1, 0, 0, 0, 16653, 16654, 1, 0, 0, 0, 16654, 16652, 1, 0, 0, 0, 16654, 16655, 1, 0, 0, 0, 16655, 1819, 1, 0, 0, 0, 16656, 16657, 5, 113, 0, 0, 16657, 16664, 3, 1770, 885, 0, 16658, 16660, 5, 535, 0, 0, 16659, 16661, 3, 1822, 911, 0, 16660, 16659, 1, 0, 0, 0, 16661, 16662, 1, 0, 0, 0, 16662, 16660, 1, 0, 0, 0, 16662, 16663, 1, 0, 0, 0, 16663, 16665, 1, 0, 0, 0, 16664, 16658, 1, 0, 0, 0, 16664, 16665, 1, 0, 0, 0, 16665, 16666, 1, 0, 0, 0, 16666, 16668, 5, 508, 0, 0, 16667, 16669, 3, 2312, 1156, 0, 16668, 16667, 1, 0, 0, 0, 16668, 16669, 1, 0, 0, 0, 16669, 1821, 1, 0, 0, 0, 16670, 16671, 5, 2300, 0, 0, 16671, 16676, 3, 2318, 1159, 0, 16672, 16673, 5, 1307, 0, 0, 16673, 16675, 3, 2318, 1159, 0, 16674, 16672, 1, 0, 0, 0, 16675, 16678, 1, 0, 0, 0, 16676, 16674, 1, 0, 0, 0, 16676, 16677, 1, 0, 0, 0, 16677, 16679, 1, 0, 0, 0, 16678, 16676, 1, 0, 0, 0, 16679, 16680, 5, 2099, 0, 0, 16680, 16681, 3, 1770, 885, 0, 16681, 1823, 1, 0, 0, 0, 16682, 16686, 5, 382, 0, 0, 16683, 16685, 3, 1742, 871, 0, 16684, 16683, 1, 0, 0, 0, 16685, 16688, 1, 0, 0, 0, 16686, 16684, 1, 0, 0, 0, 16686, 16687, 1, 0, 0, 0, 16687, 16690, 1, 0, 0, 0, 16688, 16686, 1, 0, 0, 0, 16689, 16682, 1, 0, 0, 0, 16689, 16690, 1, 0, 0, 0, 16690, 16691, 1, 0, 0, 0, 16691, 16692, 3, 1820, 910, 0, 16692, 1825, 1, 0, 0, 0, 16693, 16695, 3, 1742, 871, 0, 16694, 16693, 1, 0, 0, 0, 16695, 16698, 1, 0, 0, 0, 16696, 16694, 1, 0, 0, 0, 16696, 16697, 1, 0, 0, 0, 16697, 16699, 1, 0, 0, 0, 16698, 16696, 1, 0, 0, 0, 16699, 16700, 3, 1820, 910, 0, 16700, 1827, 1, 0, 0, 0, 16701, 16705, 5, 382, 0, 0, 16702, 16704, 3, 1742, 871, 0, 16703, 16702, 1, 0, 0, 0, 16704, 16707, 1, 0, 0, 0, 16705, 16703, 1, 0, 0, 0, 16705, 16706, 1, 0, 0, 0, 16706, 16709, 1, 0, 0, 0, 16707, 16705, 1, 0, 0, 0, 16708, 16701, 1, 0, 0, 0, 16708, 16709, 1, 0, 0, 0, 16709, 16710, 1, 0, 0, 0, 16710, 16711, 3, 1820, 910, 0, 16711, 1829, 1, 0, 0, 0, 16712, 16718, 3, 1832, 916, 0, 16713, 16718, 3, 1836, 918, 0, 16714, 16718, 3, 1838, 919, 0, 16715, 16718, 3, 1850, 925, 0, 16716, 16718, 3, 1864, 932, 0, 16717, 16712, 1, 0, 0, 0, 16717, 16713, 1, 0, 0, 0, 16717, 16714, 1, 0, 0, 0, 16717, 16715, 1, 0, 0, 0, 16717, 16716, 1, 0, 0, 0, 16718, 1831, 1, 0, 0, 0, 16719, 16720, 5, 542, 0, 0, 16720, 16721, 5, 698, 0, 0, 16721, 16731, 3, 2078, 1039, 0, 16722, 16724, 3, 2274, 1137, 0, 16723, 16725, 3, 2210, 1105, 0, 16724, 16723, 1, 0, 0, 0, 16724, 16725, 1, 0, 0, 0, 16725, 16732, 1, 0, 0, 0, 16726, 16728, 3, 2210, 1105, 0, 16727, 16729, 3, 1834, 917, 0, 16728, 16727, 1, 0, 0, 0, 16728, 16729, 1, 0, 0, 0, 16729, 16732, 1, 0, 0, 0, 16730, 16732, 3, 1834, 917, 0, 16731, 16722, 1, 0, 0, 0, 16731, 16726, 1, 0, 0, 0, 16731, 16730, 1, 0, 0, 0, 16731, 16732, 1, 0, 0, 0, 16732, 1833, 1, 0, 0, 0, 16733, 16734, 7, 205, 0, 0, 16734, 16735, 3, 2274, 1137, 0, 16735, 1835, 1, 0, 0, 0, 16736, 16744, 3, 2034, 1017, 0, 16737, 16744, 3, 2046, 1023, 0, 16738, 16744, 3, 1870, 935, 0, 16739, 16744, 3, 2008, 1004, 0, 16740, 16744, 3, 2014, 1007, 0, 16741, 16744, 3, 2016, 1008, 0, 16742, 16744, 3, 1866, 933, 0, 16743, 16736, 1, 0, 0, 0, 16743, 16737, 1, 0, 0, 0, 16743, 16738, 1, 0, 0, 0, 16743, 16739, 1, 0, 0, 0, 16743, 16740, 1, 0, 0, 0, 16743, 16741, 1, 0, 0, 0, 16743, 16742, 1, 0, 0, 0, 16744, 1837, 1, 0, 0, 0, 16745, 16750, 3, 1840, 920, 0, 16746, 16750, 3, 1842, 921, 0, 16747, 16750, 3, 1844, 922, 0, 16748, 16750, 3, 1848, 924, 0, 16749, 16745, 1, 0, 0, 0, 16749, 16746, 1, 0, 0, 0, 16749, 16747, 1, 0, 0, 0, 16749, 16748, 1, 0, 0, 0, 16750, 1839, 1, 0, 0, 0, 16751, 16752, 5, 218, 0, 0, 16752, 16753, 3, 2330, 1165, 0, 16753, 1841, 1, 0, 0, 0, 16754, 16755, 5, 1264, 0, 0, 16755, 16761, 3, 2330, 1165, 0, 16756, 16758, 5, 2447, 0, 0, 16757, 16759, 3, 2076, 1038, 0, 16758, 16757, 1, 0, 0, 0, 16758, 16759, 1, 0, 0, 0, 16759, 16760, 1, 0, 0, 0, 16760, 16762, 5, 2448, 0, 0, 16761, 16756, 1, 0, 0, 0, 16761, 16762, 1, 0, 0, 0, 16762, 1843, 1, 0, 0, 0, 16763, 16764, 5, 586, 0, 0, 16764, 16792, 3, 2330, 1165, 0, 16765, 16766, 5, 779, 0, 0, 16766, 16771, 3, 1846, 923, 0, 16767, 16768, 5, 2453, 0, 0, 16768, 16770, 3, 1846, 923, 0, 16769, 16767, 1, 0, 0, 0, 16770, 16773, 1, 0, 0, 0, 16771, 16769, 1, 0, 0, 0, 16771, 16772, 1, 0, 0, 0, 16772, 16793, 1, 0, 0, 0, 16773, 16771, 1, 0, 0, 0, 16774, 16775, 5, 159, 0, 0, 16775, 16776, 5, 233, 0, 0, 16776, 16777, 5, 779, 0, 0, 16777, 16782, 3, 1846, 923, 0, 16778, 16779, 5, 2453, 0, 0, 16779, 16781, 3, 1846, 923, 0, 16780, 16778, 1, 0, 0, 0, 16781, 16784, 1, 0, 0, 0, 16782, 16780, 1, 0, 0, 0, 16782, 16783, 1, 0, 0, 0, 16783, 16790, 1, 0, 0, 0, 16784, 16782, 1, 0, 0, 0, 16785, 16788, 5, 858, 0, 0, 16786, 16789, 3, 2396, 1198, 0, 16787, 16789, 3, 1846, 923, 0, 16788, 16786, 1, 0, 0, 0, 16788, 16787, 1, 0, 0, 0, 16789, 16791, 1, 0, 0, 0, 16790, 16785, 1, 0, 0, 0, 16790, 16791, 1, 0, 0, 0, 16791, 16793, 1, 0, 0, 0, 16792, 16765, 1, 0, 0, 0, 16792, 16774, 1, 0, 0, 0, 16793, 1845, 1, 0, 0, 0, 16794, 16797, 3, 2326, 1163, 0, 16795, 16797, 3, 2120, 1060, 0, 16796, 16794, 1, 0, 0, 0, 16796, 16795, 1, 0, 0, 0, 16797, 1847, 1, 0, 0, 0, 16798, 16799, 5, 1264, 0, 0, 16799, 16800, 3, 2326, 1163, 0, 16800, 16803, 5, 620, 0, 0, 16801, 16804, 3, 1870, 935, 0, 16802, 16804, 3, 2078, 1039, 0, 16803, 16801, 1, 0, 0, 0, 16803, 16802, 1, 0, 0, 0, 16804, 16806, 1, 0, 0, 0, 16805, 16807, 3, 2210, 1105, 0, 16806, 16805, 1, 0, 0, 0, 16806, 16807, 1, 0, 0, 0, 16807, 1849, 1, 0, 0, 0, 16808, 16814, 3, 1852, 926, 0, 16809, 16814, 3, 1854, 927, 0, 16810, 16814, 3, 1856, 928, 0, 16811, 16814, 3, 1860, 930, 0, 16812, 16814, 3, 1862, 931, 0, 16813, 16808, 1, 0, 0, 0, 16813, 16809, 1, 0, 0, 0, 16813, 16810, 1, 0, 0, 0, 16813, 16811, 1, 0, 0, 0, 16813, 16812, 1, 0, 0, 0, 16814, 1851, 1, 0, 0, 0, 16815, 16816, 5, 1671, 0, 0, 16816, 16830, 5, 2147, 0, 0, 16817, 16818, 5, 1505, 0, 0, 16818, 16831, 7, 11, 0, 0, 16819, 16820, 5, 787, 0, 0, 16820, 16824, 5, 846, 0, 0, 16821, 16825, 5, 1659, 0, 0, 16822, 16823, 5, 1505, 0, 0, 16823, 16825, 5, 243, 0, 0, 16824, 16821, 1, 0, 0, 0, 16824, 16822, 1, 0, 0, 0, 16825, 16831, 1, 0, 0, 0, 16826, 16827, 5, 2241, 0, 0, 16827, 16828, 5, 1596, 0, 0, 16828, 16829, 5, 1645, 0, 0, 16829, 16831, 3, 2284, 1142, 0, 16830, 16817, 1, 0, 0, 0, 16830, 16819, 1, 0, 0, 0, 16830, 16826, 1, 0, 0, 0, 16830, 16831, 1, 0, 0, 0, 16831, 16834, 1, 0, 0, 0, 16832, 16833, 5, 997, 0, 0, 16833, 16835, 3, 2400, 1200, 0, 16834, 16832, 1, 0, 0, 0, 16834, 16835, 1, 0, 0, 0, 16835, 1853, 1, 0, 0, 0, 16836, 16837, 5, 1671, 0, 0, 16837, 16847, 7, 95, 0, 0, 16838, 16848, 5, 38, 0, 0, 16839, 16844, 3, 2310, 1155, 0, 16840, 16841, 5, 2453, 0, 0, 16841, 16843, 3, 2310, 1155, 0, 16842, 16840, 1, 0, 0, 0, 16843, 16846, 1, 0, 0, 0, 16844, 16842, 1, 0, 0, 0, 16844, 16845, 1, 0, 0, 0, 16845, 16848, 1, 0, 0, 0, 16846, 16844, 1, 0, 0, 0, 16847, 16838, 1, 0, 0, 0, 16847, 16839, 1, 0, 0, 0, 16848, 16849, 1, 0, 0, 0, 16849, 16850, 7, 69, 0, 0, 16850, 1855, 1, 0, 0, 0, 16851, 16853, 5, 242, 0, 0, 16852, 16854, 5, 2309, 0, 0, 16853, 16852, 1, 0, 0, 0, 16853, 16854, 1, 0, 0, 0, 16854, 16856, 1, 0, 0, 0, 16855, 16857, 3, 1858, 929, 0, 16856, 16855, 1, 0, 0, 0, 16856, 16857, 1, 0, 0, 0, 16857, 16874, 1, 0, 0, 0, 16858, 16859, 5, 241, 0, 0, 16859, 16861, 5, 2443, 0, 0, 16860, 16862, 3, 1858, 929, 0, 16861, 16860, 1, 0, 0, 0, 16861, 16862, 1, 0, 0, 0, 16862, 16875, 1, 0, 0, 0, 16863, 16872, 5, 616, 0, 0, 16864, 16867, 5, 2443, 0, 0, 16865, 16866, 5, 2453, 0, 0, 16866, 16868, 3, 2396, 1198, 0, 16867, 16865, 1, 0, 0, 0, 16867, 16868, 1, 0, 0, 0, 16868, 16873, 1, 0, 0, 0, 16869, 16870, 5, 308, 0, 0, 16870, 16873, 5, 2443, 0, 0, 16871, 16873, 5, 307, 0, 0, 16872, 16864, 1, 0, 0, 0, 16872, 16869, 1, 0, 0, 0, 16872, 16871, 1, 0, 0, 0, 16873, 16875, 1, 0, 0, 0, 16874, 16858, 1, 0, 0, 0, 16874, 16863, 1, 0, 0, 0, 16874, 16875, 1, 0, 0, 0, 16875, 1857, 1, 0, 0, 0, 16876, 16881, 5, 2313, 0, 0, 16877, 16880, 7, 206, 0, 0, 16878, 16880, 7, 0, 0, 0, 16879, 16877, 1, 0, 0, 0, 16879, 16878, 1, 0, 0, 0, 16880, 16883, 1, 0, 0, 0, 16881, 16879, 1, 0, 0, 0, 16881, 16882, 1, 0, 0, 0, 16882, 1859, 1, 0, 0, 0, 16883, 16881, 1, 0, 0, 0, 16884, 16886, 5, 1596, 0, 0, 16885, 16887, 5, 2309, 0, 0, 16886, 16885, 1, 0, 0, 0, 16886, 16887, 1, 0, 0, 0, 16887, 16895, 1, 0, 0, 0, 16888, 16890, 5, 2141, 0, 0, 16889, 16891, 5, 1616, 0, 0, 16890, 16889, 1, 0, 0, 0, 16890, 16891, 1, 0, 0, 0, 16891, 16892, 1, 0, 0, 0, 16892, 16896, 3, 2282, 1141, 0, 16893, 16894, 5, 616, 0, 0, 16894, 16896, 3, 2400, 1200, 0, 16895, 16888, 1, 0, 0, 0, 16895, 16893, 1, 0, 0, 0, 16895, 16896, 1, 0, 0, 0, 16896, 1861, 1, 0, 0, 0, 16897, 16898, 5, 1616, 0, 0, 16898, 16899, 3, 2282, 1141, 0, 16899, 1863, 1, 0, 0, 0, 16900, 16901, 3, 2078, 1039, 0, 16901, 16923, 5, 2440, 0, 0, 16902, 16914, 7, 207, 0, 0, 16903, 16904, 5, 2447, 0, 0, 16904, 16909, 3, 2078, 1039, 0, 16905, 16906, 5, 2453, 0, 0, 16906, 16908, 3, 2078, 1039, 0, 16907, 16905, 1, 0, 0, 0, 16908, 16911, 1, 0, 0, 0, 16909, 16907, 1, 0, 0, 0, 16909, 16910, 1, 0, 0, 0, 16910, 16912, 1, 0, 0, 0, 16911, 16909, 1, 0, 0, 0, 16912, 16913, 5, 2448, 0, 0, 16913, 16915, 1, 0, 0, 0, 16914, 16903, 1, 0, 0, 0, 16914, 16915, 1, 0, 0, 0, 16915, 16924, 1, 0, 0, 0, 16916, 16921, 5, 2418, 0, 0, 16917, 16918, 5, 2447, 0, 0, 16918, 16919, 3, 2078, 1039, 0, 16919, 16920, 5, 2448, 0, 0, 16920, 16922, 1, 0, 0, 0, 16921, 16917, 1, 0, 0, 0, 16921, 16922, 1, 0, 0, 0, 16922, 16924, 1, 0, 0, 0, 16923, 16902, 1, 0, 0, 0, 16923, 16916, 1, 0, 0, 0, 16924, 1865, 1, 0, 0, 0, 16925, 16926, 5, 552, 0, 0, 16926, 16931, 5, 1401, 0, 0, 16927, 16928, 5, 1671, 0, 0, 16928, 16929, 5, 1740, 0, 0, 16929, 16930, 5, 2472, 0, 0, 16930, 16932, 3, 2400, 1200, 0, 16931, 16927, 1, 0, 0, 0, 16931, 16932, 1, 0, 0, 0, 16932, 16935, 1, 0, 0, 0, 16933, 16934, 5, 779, 0, 0, 16934, 16936, 3, 2342, 1171, 0, 16935, 16933, 1, 0, 0, 0, 16935, 16936, 1, 0, 0, 0, 16936, 16937, 1, 0, 0, 0, 16937, 16943, 5, 620, 0, 0, 16938, 16944, 3, 1870, 935, 0, 16939, 16944, 3, 2008, 1004, 0, 16940, 16944, 3, 2014, 1007, 0, 16941, 16944, 3, 2016, 1008, 0, 16942, 16944, 3, 2034, 1017, 0, 16943, 16938, 1, 0, 0, 0, 16943, 16939, 1, 0, 0, 0, 16943, 16940, 1, 0, 0, 0, 16943, 16941, 1, 0, 0, 0, 16943, 16942, 1, 0, 0, 0, 16944, 1867, 1, 0, 0, 0, 16945, 16947, 3, 1872, 936, 0, 16946, 16945, 1, 0, 0, 0, 16946, 16947, 1, 0, 0, 0, 16947, 16948, 1, 0, 0, 0, 16948, 16949, 3, 1896, 948, 0, 16949, 1869, 1, 0, 0, 0, 16950, 16957, 3, 1868, 934, 0, 16951, 16956, 3, 2002, 1001, 0, 16952, 16956, 3, 1994, 997, 0, 16953, 16956, 3, 1998, 999, 0, 16954, 16956, 3, 2000, 1000, 0, 16955, 16951, 1, 0, 0, 0, 16955, 16952, 1, 0, 0, 0, 16955, 16953, 1, 0, 0, 0, 16955, 16954, 1, 0, 0, 0, 16956, 16959, 1, 0, 0, 0, 16957, 16955, 1, 0, 0, 0, 16957, 16958, 1, 0, 0, 0, 16958, 1871, 1, 0, 0, 0, 16959, 16957, 1, 0, 0, 0, 16960, 16965, 5, 2308, 0, 0, 16961, 16964, 3, 176, 88, 0, 16962, 16964, 3, 178, 89, 0, 16963, 16961, 1, 0, 0, 0, 16963, 16962, 1, 0, 0, 0, 16964, 16967, 1, 0, 0, 0, 16965, 16963, 1, 0, 0, 0, 16965, 16966, 1, 0, 0, 0, 16966, 16968, 1, 0, 0, 0, 16967, 16965, 1, 0, 0, 0, 16968, 16973, 3, 1874, 937, 0, 16969, 16970, 5, 2453, 0, 0, 16970, 16972, 3, 1874, 937, 0, 16971, 16969, 1, 0, 0, 0, 16972, 16975, 1, 0, 0, 0, 16973, 16971, 1, 0, 0, 0, 16973, 16974, 1, 0, 0, 0, 16974, 16994, 1, 0, 0, 0, 16975, 16973, 1, 0, 0, 0, 16976, 16979, 5, 2308, 0, 0, 16977, 16980, 3, 176, 88, 0, 16978, 16980, 3, 178, 89, 0, 16979, 16977, 1, 0, 0, 0, 16979, 16978, 1, 0, 0, 0, 16980, 16981, 1, 0, 0, 0, 16981, 16979, 1, 0, 0, 0, 16981, 16982, 1, 0, 0, 0, 16982, 16991, 1, 0, 0, 0, 16983, 16988, 3, 1874, 937, 0, 16984, 16985, 5, 2453, 0, 0, 16985, 16987, 3, 1874, 937, 0, 16986, 16984, 1, 0, 0, 0, 16987, 16990, 1, 0, 0, 0, 16988, 16986, 1, 0, 0, 0, 16988, 16989, 1, 0, 0, 0, 16989, 16992, 1, 0, 0, 0, 16990, 16988, 1, 0, 0, 0, 16991, 16983, 1, 0, 0, 0, 16991, 16992, 1, 0, 0, 0, 16992, 16994, 1, 0, 0, 0, 16993, 16960, 1, 0, 0, 0, 16993, 16976, 1, 0, 0, 0, 16994, 1873, 1, 0, 0, 0, 16995, 16998, 3, 1876, 938, 0, 16996, 16998, 3, 1882, 941, 0, 16997, 16995, 1, 0, 0, 0, 16997, 16996, 1, 0, 0, 0, 16998, 1875, 1, 0, 0, 0, 16999, 17001, 3, 2304, 1152, 0, 17000, 17002, 3, 2360, 1180, 0, 17001, 17000, 1, 0, 0, 0, 17001, 17002, 1, 0, 0, 0, 17002, 17003, 1, 0, 0, 0, 17003, 17004, 5, 69, 0, 0, 17004, 17005, 5, 2447, 0, 0, 17005, 17007, 3, 1896, 948, 0, 17006, 17008, 3, 1994, 997, 0, 17007, 17006, 1, 0, 0, 0, 17007, 17008, 1, 0, 0, 0, 17008, 17009, 1, 0, 0, 0, 17009, 17011, 5, 2448, 0, 0, 17010, 17012, 3, 1878, 939, 0, 17011, 17010, 1, 0, 0, 0, 17011, 17012, 1, 0, 0, 0, 17012, 17014, 1, 0, 0, 0, 17013, 17015, 3, 1880, 940, 0, 17014, 17013, 1, 0, 0, 0, 17014, 17015, 1, 0, 0, 0, 17015, 1877, 1, 0, 0, 0, 17016, 17017, 5, 1635, 0, 0, 17017, 17018, 7, 208, 0, 0, 17018, 17019, 5, 598, 0, 0, 17019, 17020, 5, 160, 0, 0, 17020, 17022, 3, 2340, 1170, 0, 17021, 17023, 5, 70, 0, 0, 17022, 17021, 1, 0, 0, 0, 17022, 17023, 1, 0, 0, 0, 17023, 17025, 1, 0, 0, 0, 17024, 17026, 5, 414, 0, 0, 17025, 17024, 1, 0, 0, 0, 17025, 17026, 1, 0, 0, 0, 17026, 17029, 1, 0, 0, 0, 17027, 17028, 5, 1229, 0, 0, 17028, 17030, 5, 598, 0, 0, 17029, 17027, 1, 0, 0, 0, 17029, 17030, 1, 0, 0, 0, 17030, 17033, 1, 0, 0, 0, 17031, 17032, 5, 1229, 0, 0, 17032, 17034, 5, 825, 0, 0, 17033, 17031, 1, 0, 0, 0, 17033, 17034, 1, 0, 0, 0, 17034, 17053, 1, 0, 0, 0, 17035, 17036, 5, 2453, 0, 0, 17036, 17038, 3, 2340, 1170, 0, 17037, 17039, 5, 70, 0, 0, 17038, 17037, 1, 0, 0, 0, 17038, 17039, 1, 0, 0, 0, 17039, 17041, 1, 0, 0, 0, 17040, 17042, 5, 414, 0, 0, 17041, 17040, 1, 0, 0, 0, 17041, 17042, 1, 0, 0, 0, 17042, 17045, 1, 0, 0, 0, 17043, 17044, 5, 1229, 0, 0, 17044, 17046, 5, 598, 0, 0, 17045, 17043, 1, 0, 0, 0, 17045, 17046, 1, 0, 0, 0, 17046, 17049, 1, 0, 0, 0, 17047, 17048, 5, 1229, 0, 0, 17048, 17050, 5, 825, 0, 0, 17049, 17047, 1, 0, 0, 0, 17049, 17050, 1, 0, 0, 0, 17050, 17052, 1, 0, 0, 0, 17051, 17035, 1, 0, 0, 0, 17052, 17055, 1, 0, 0, 0, 17053, 17051, 1, 0, 0, 0, 17053, 17054, 1, 0, 0, 0, 17054, 17056, 1, 0, 0, 0, 17055, 17053, 1, 0, 0, 0, 17056, 17057, 5, 1671, 0, 0, 17057, 17058, 3, 2340, 1170, 0, 17058, 1879, 1, 0, 0, 0, 17059, 17060, 5, 348, 0, 0, 17060, 17061, 3, 2358, 1179, 0, 17061, 17062, 5, 1671, 0, 0, 17062, 17063, 3, 2340, 1170, 0, 17063, 17064, 5, 2141, 0, 0, 17064, 17065, 3, 2078, 1039, 0, 17065, 17066, 5, 389, 0, 0, 17066, 17067, 3, 2078, 1039, 0, 17067, 1881, 1, 0, 0, 0, 17068, 17069, 3, 2404, 1202, 0, 17069, 17070, 5, 45, 0, 0, 17070, 17071, 5, 2286, 0, 0, 17071, 17072, 5, 69, 0, 0, 17072, 17073, 5, 2447, 0, 0, 17073, 17074, 3, 1884, 942, 0, 17074, 17075, 5, 2448, 0, 0, 17075, 1883, 1, 0, 0, 0, 17076, 17077, 5, 2246, 0, 0, 17077, 17079, 3, 740, 370, 0, 17078, 17080, 3, 1886, 943, 0, 17079, 17078, 1, 0, 0, 0, 17079, 17080, 1, 0, 0, 0, 17080, 17082, 1, 0, 0, 0, 17081, 17083, 3, 1888, 944, 0, 17082, 17081, 1, 0, 0, 0, 17082, 17083, 1, 0, 0, 0, 17083, 17085, 1, 0, 0, 0, 17084, 17086, 3, 1892, 946, 0, 17085, 17084, 1, 0, 0, 0, 17085, 17086, 1, 0, 0, 0, 17086, 1885, 1, 0, 0, 0, 17087, 17088, 5, 673, 0, 0, 17088, 17089, 5, 2447, 0, 0, 17089, 17094, 3, 740, 370, 0, 17090, 17091, 5, 2453, 0, 0, 17091, 17093, 3, 740, 370, 0, 17092, 17090, 1, 0, 0, 0, 17093, 17096, 1, 0, 0, 0, 17094, 17092, 1, 0, 0, 0, 17094, 17095, 1, 0, 0, 0, 17095, 17097, 1, 0, 0, 0, 17096, 17094, 1, 0, 0, 0, 17097, 17098, 5, 2448, 0, 0, 17098, 1887, 1, 0, 0, 0, 17099, 17100, 5, 594, 0, 0, 17100, 17101, 5, 567, 0, 0, 17101, 17102, 5, 2447, 0, 0, 17102, 17107, 3, 1890, 945, 0, 17103, 17104, 5, 2453, 0, 0, 17104, 17106, 3, 1890, 945, 0, 17105, 17103, 1, 0, 0, 0, 17106, 17109, 1, 0, 0, 0, 17107, 17105, 1, 0, 0, 0, 17107, 17108, 1, 0, 0, 0, 17108, 17110, 1, 0, 0, 0, 17109, 17107, 1, 0, 0, 0, 17110, 17111, 5, 2448, 0, 0, 17111, 1889, 1, 0, 0, 0, 17112, 17115, 5, 934, 0, 0, 17113, 17115, 3, 740, 370, 0, 17114, 17112, 1, 0, 0, 0, 17114, 17113, 1, 0, 0, 0, 17115, 17116, 1, 0, 0, 0, 17116, 17117, 5, 2141, 0, 0, 17117, 17118, 3, 2074, 1037, 0, 17118, 1891, 1, 0, 0, 0, 17119, 17120, 5, 21, 0, 0, 17120, 17121, 5, 934, 0, 0, 17121, 17122, 5, 2447, 0, 0, 17122, 17127, 3, 1894, 947, 0, 17123, 17124, 5, 2453, 0, 0, 17124, 17126, 3, 1894, 947, 0, 17125, 17123, 1, 0, 0, 0, 17126, 17129, 1, 0, 0, 0, 17127, 17125, 1, 0, 0, 0, 17127, 17128, 1, 0, 0, 0, 17128, 17130, 1, 0, 0, 0, 17129, 17127, 1, 0, 0, 0, 17130, 17131, 5, 2448, 0, 0, 17131, 1893, 1, 0, 0, 0, 17132, 17133, 3, 2404, 1202, 0, 17133, 17134, 5, 69, 0, 0, 17134, 17135, 5, 2447, 0, 0, 17135, 17136, 3, 2078, 1039, 0, 17136, 17137, 5, 2448, 0, 0, 17137, 1895, 1, 0, 0, 0, 17138, 17142, 3, 1898, 949, 0, 17139, 17141, 3, 1900, 950, 0, 17140, 17139, 1, 0, 0, 0, 17141, 17144, 1, 0, 0, 0, 17142, 17140, 1, 0, 0, 0, 17142, 17143, 1, 0, 0, 0, 17143, 1897, 1, 0, 0, 0, 17144, 17142, 1, 0, 0, 0, 17145, 17151, 3, 1902, 951, 0, 17146, 17147, 5, 2447, 0, 0, 17147, 17148, 3, 1896, 948, 0, 17148, 17149, 5, 2448, 0, 0, 17149, 17151, 1, 0, 0, 0, 17150, 17145, 1, 0, 0, 0, 17150, 17146, 1, 0, 0, 0, 17151, 1899, 1, 0, 0, 0, 17152, 17154, 5, 2181, 0, 0, 17153, 17155, 5, 38, 0, 0, 17154, 17153, 1, 0, 0, 0, 17154, 17155, 1, 0, 0, 0, 17155, 17159, 1, 0, 0, 0, 17156, 17159, 5, 775, 0, 0, 17157, 17159, 5, 956, 0, 0, 17158, 17152, 1, 0, 0, 0, 17158, 17156, 1, 0, 0, 0, 17158, 17157, 1, 0, 0, 0, 17159, 17160, 1, 0, 0, 0, 17160, 17161, 3, 1898, 949, 0, 17161, 1901, 1, 0, 0, 0, 17162, 17164, 5, 1647, 0, 0, 17163, 17165, 7, 209, 0, 0, 17164, 17163, 1, 0, 0, 0, 17164, 17165, 1, 0, 0, 0, 17165, 17166, 1, 0, 0, 0, 17166, 17168, 3, 1904, 952, 0, 17167, 17169, 3, 2274, 1137, 0, 17168, 17167, 1, 0, 0, 0, 17168, 17169, 1, 0, 0, 0, 17169, 17171, 1, 0, 0, 0, 17170, 17172, 3, 1906, 953, 0, 17171, 17170, 1, 0, 0, 0, 17171, 17172, 1, 0, 0, 0, 17172, 17174, 1, 0, 0, 0, 17173, 17175, 3, 2272, 1136, 0, 17174, 17173, 1, 0, 0, 0, 17174, 17175, 1, 0, 0, 0, 17175, 17180, 1, 0, 0, 0, 17176, 17179, 3, 1948, 974, 0, 17177, 17179, 3, 1952, 976, 0, 17178, 17176, 1, 0, 0, 0, 17178, 17177, 1, 0, 0, 0, 17179, 17182, 1, 0, 0, 0, 17180, 17178, 1, 0, 0, 0, 17180, 17181, 1, 0, 0, 0, 17181, 17184, 1, 0, 0, 0, 17182, 17180, 1, 0, 0, 0, 17183, 17185, 3, 1964, 982, 0, 17184, 17183, 1, 0, 0, 0, 17184, 17185, 1, 0, 0, 0, 17185, 17187, 1, 0, 0, 0, 17186, 17188, 3, 1994, 997, 0, 17187, 17186, 1, 0, 0, 0, 17187, 17188, 1, 0, 0, 0, 17188, 17190, 1, 0, 0, 0, 17189, 17191, 3, 1998, 999, 0, 17190, 17189, 1, 0, 0, 0, 17190, 17191, 1, 0, 0, 0, 17191, 17193, 1, 0, 0, 0, 17192, 17194, 3, 2000, 1000, 0, 17193, 17192, 1, 0, 0, 0, 17193, 17194, 1, 0, 0, 0, 17194, 1903, 1, 0, 0, 0, 17195, 17205, 5, 2450, 0, 0, 17196, 17201, 3, 1908, 954, 0, 17197, 17198, 5, 2453, 0, 0, 17198, 17200, 3, 1908, 954, 0, 17199, 17197, 1, 0, 0, 0, 17200, 17203, 1, 0, 0, 0, 17201, 17199, 1, 0, 0, 0, 17201, 17202, 1, 0, 0, 0, 17202, 17205, 1, 0, 0, 0, 17203, 17201, 1, 0, 0, 0, 17204, 17195, 1, 0, 0, 0, 17204, 17196, 1, 0, 0, 0, 17205, 1905, 1, 0, 0, 0, 17206, 17207, 5, 628, 0, 0, 17207, 17208, 3, 1910, 955, 0, 17208, 1907, 1, 0, 0, 0, 17209, 17210, 3, 2342, 1171, 0, 17210, 17211, 5, 2440, 0, 0, 17211, 17212, 5, 2450, 0, 0, 17212, 17218, 1, 0, 0, 0, 17213, 17215, 3, 2078, 1039, 0, 17214, 17216, 3, 2268, 1134, 0, 17215, 17214, 1, 0, 0, 0, 17215, 17216, 1, 0, 0, 0, 17216, 17218, 1, 0, 0, 0, 17217, 17209, 1, 0, 0, 0, 17217, 17213, 1, 0, 0, 0, 17218, 1909, 1, 0, 0, 0, 17219, 17224, 3, 1912, 956, 0, 17220, 17221, 5, 2453, 0, 0, 17221, 17223, 3, 1912, 956, 0, 17222, 17220, 1, 0, 0, 0, 17223, 17226, 1, 0, 0, 0, 17224, 17222, 1, 0, 0, 0, 17224, 17225, 1, 0, 0, 0, 17225, 1911, 1, 0, 0, 0, 17226, 17224, 1, 0, 0, 0, 17227, 17231, 3, 1914, 957, 0, 17228, 17230, 3, 1918, 959, 0, 17229, 17228, 1, 0, 0, 0, 17230, 17233, 1, 0, 0, 0, 17231, 17229, 1, 0, 0, 0, 17231, 17232, 1, 0, 0, 0, 17232, 17236, 1, 0, 0, 0, 17233, 17231, 1, 0, 0, 0, 17234, 17237, 3, 1930, 965, 0, 17235, 17237, 3, 1942, 971, 0, 17236, 17234, 1, 0, 0, 0, 17236, 17235, 1, 0, 0, 0, 17236, 17237, 1, 0, 0, 0, 17237, 1913, 1, 0, 0, 0, 17238, 17242, 3, 1916, 958, 0, 17239, 17241, 3, 1928, 964, 0, 17240, 17239, 1, 0, 0, 0, 17241, 17244, 1, 0, 0, 0, 17242, 17240, 1, 0, 0, 0, 17242, 17243, 1, 0, 0, 0, 17243, 17247, 1, 0, 0, 0, 17244, 17242, 1, 0, 0, 0, 17245, 17246, 4, 957, 11, 0, 17246, 17248, 3, 2270, 1135, 0, 17247, 17245, 1, 0, 0, 0, 17247, 17248, 1, 0, 0, 0, 17248, 1915, 1, 0, 0, 0, 17249, 17252, 3, 2064, 1032, 0, 17250, 17253, 3, 1930, 965, 0, 17251, 17253, 3, 1942, 971, 0, 17252, 17250, 1, 0, 0, 0, 17252, 17251, 1, 0, 0, 0, 17252, 17253, 1, 0, 0, 0, 17253, 17273, 1, 0, 0, 0, 17254, 17255, 5, 2447, 0, 0, 17255, 17259, 3, 1912, 956, 0, 17256, 17258, 3, 1900, 950, 0, 17257, 17256, 1, 0, 0, 0, 17258, 17261, 1, 0, 0, 0, 17259, 17257, 1, 0, 0, 0, 17259, 17260, 1, 0, 0, 0, 17260, 17262, 1, 0, 0, 0, 17261, 17259, 1, 0, 0, 0, 17262, 17265, 5, 2448, 0, 0, 17263, 17266, 3, 1930, 965, 0, 17264, 17266, 3, 1942, 971, 0, 17265, 17263, 1, 0, 0, 0, 17265, 17264, 1, 0, 0, 0, 17265, 17266, 1, 0, 0, 0, 17266, 17273, 1, 0, 0, 0, 17267, 17268, 5, 1258, 0, 0, 17268, 17269, 5, 2447, 0, 0, 17269, 17270, 3, 2064, 1032, 0, 17270, 17271, 5, 2448, 0, 0, 17271, 17273, 1, 0, 0, 0, 17272, 17249, 1, 0, 0, 0, 17272, 17254, 1, 0, 0, 0, 17272, 17267, 1, 0, 0, 0, 17273, 1917, 1, 0, 0, 0, 17274, 17276, 3, 1926, 963, 0, 17275, 17274, 1, 0, 0, 0, 17275, 17276, 1, 0, 0, 0, 17276, 17278, 1, 0, 0, 0, 17277, 17279, 7, 210, 0, 0, 17278, 17277, 1, 0, 0, 0, 17278, 17279, 1, 0, 0, 0, 17279, 17282, 1, 0, 0, 0, 17280, 17283, 5, 749, 0, 0, 17281, 17283, 3, 1924, 962, 0, 17282, 17280, 1, 0, 0, 0, 17282, 17281, 1, 0, 0, 0, 17282, 17283, 1, 0, 0, 0, 17283, 17284, 1, 0, 0, 0, 17284, 17285, 5, 794, 0, 0, 17285, 17287, 3, 1914, 957, 0, 17286, 17288, 3, 1926, 963, 0, 17287, 17286, 1, 0, 0, 0, 17287, 17288, 1, 0, 0, 0, 17288, 17293, 1, 0, 0, 0, 17289, 17292, 3, 1920, 960, 0, 17290, 17292, 3, 1922, 961, 0, 17291, 17289, 1, 0, 0, 0, 17291, 17290, 1, 0, 0, 0, 17292, 17295, 1, 0, 0, 0, 17293, 17291, 1, 0, 0, 0, 17293, 17294, 1, 0, 0, 0, 17294, 17300, 1, 0, 0, 0, 17295, 17293, 1, 0, 0, 0, 17296, 17297, 7, 211, 0, 0, 17297, 17298, 5, 61, 0, 0, 17298, 17300, 3, 1914, 957, 0, 17299, 17275, 1, 0, 0, 0, 17299, 17296, 1, 0, 0, 0, 17300, 1919, 1, 0, 0, 0, 17301, 17302, 5, 1259, 0, 0, 17302, 17303, 3, 2074, 1037, 0, 17303, 1921, 1, 0, 0, 0, 17304, 17305, 5, 2246, 0, 0, 17305, 17306, 3, 2360, 1180, 0, 17306, 1923, 1, 0, 0, 0, 17307, 17309, 7, 212, 0, 0, 17308, 17310, 5, 1313, 0, 0, 17309, 17308, 1, 0, 0, 0, 17309, 17310, 1, 0, 0, 0, 17310, 1925, 1, 0, 0, 0, 17311, 17312, 5, 1348, 0, 0, 17312, 17320, 5, 160, 0, 0, 17313, 17316, 5, 2447, 0, 0, 17314, 17317, 3, 1896, 948, 0, 17315, 17317, 3, 2076, 1038, 0, 17316, 17314, 1, 0, 0, 0, 17316, 17315, 1, 0, 0, 0, 17316, 17317, 1, 0, 0, 0, 17317, 17318, 1, 0, 0, 0, 17318, 17321, 5, 2448, 0, 0, 17319, 17321, 3, 2076, 1038, 0, 17320, 17313, 1, 0, 0, 0, 17320, 17319, 1, 0, 0, 0, 17321, 1927, 1, 0, 0, 0, 17322, 17330, 5, 2283, 0, 0, 17323, 17324, 5, 1386, 0, 0, 17324, 17325, 5, 620, 0, 0, 17325, 17326, 3, 2340, 1170, 0, 17326, 17327, 5, 118, 0, 0, 17327, 17331, 1, 0, 0, 0, 17328, 17329, 5, 118, 0, 0, 17329, 17331, 7, 83, 0, 0, 17330, 17323, 1, 0, 0, 0, 17330, 17328, 1, 0, 0, 0, 17331, 17332, 1, 0, 0, 0, 17332, 17333, 3, 2078, 1039, 0, 17333, 17334, 5, 49, 0, 0, 17334, 17335, 3, 2078, 1039, 0, 17335, 17348, 1, 0, 0, 0, 17336, 17337, 5, 69, 0, 0, 17337, 17345, 5, 1246, 0, 0, 17338, 17339, 7, 213, 0, 0, 17339, 17346, 3, 2078, 1039, 0, 17340, 17341, 5, 1386, 0, 0, 17341, 17342, 5, 620, 0, 0, 17342, 17343, 3, 2340, 1170, 0, 17343, 17344, 3, 2078, 1039, 0, 17344, 17346, 1, 0, 0, 0, 17345, 17338, 1, 0, 0, 0, 17345, 17340, 1, 0, 0, 0, 17346, 17348, 1, 0, 0, 0, 17347, 17322, 1, 0, 0, 0, 17347, 17336, 1, 0, 0, 0, 17348, 1929, 1, 0, 0, 0, 17349, 17351, 5, 1397, 0, 0, 17350, 17352, 5, 2352, 0, 0, 17351, 17350, 1, 0, 0, 0, 17351, 17352, 1, 0, 0, 0, 17352, 17353, 1, 0, 0, 0, 17353, 17354, 5, 2447, 0, 0, 17354, 17359, 3, 1932, 966, 0, 17355, 17356, 5, 2453, 0, 0, 17356, 17358, 3, 1932, 966, 0, 17357, 17355, 1, 0, 0, 0, 17358, 17361, 1, 0, 0, 0, 17359, 17357, 1, 0, 0, 0, 17359, 17360, 1, 0, 0, 0, 17360, 17362, 1, 0, 0, 0, 17361, 17359, 1, 0, 0, 0, 17362, 17363, 3, 1934, 967, 0, 17363, 17364, 3, 1936, 968, 0, 17364, 17366, 5, 2448, 0, 0, 17365, 17367, 3, 2270, 1135, 0, 17366, 17365, 1, 0, 0, 0, 17366, 17367, 1, 0, 0, 0, 17367, 1931, 1, 0, 0, 0, 17368, 17375, 3, 2190, 1095, 0, 17369, 17370, 3, 2302, 1151, 0, 17370, 17371, 5, 2447, 0, 0, 17371, 17372, 3, 2078, 1039, 0, 17372, 17373, 5, 2448, 0, 0, 17373, 17375, 1, 0, 0, 0, 17374, 17368, 1, 0, 0, 0, 17374, 17369, 1, 0, 0, 0, 17375, 17377, 1, 0, 0, 0, 17376, 17378, 3, 2268, 1134, 0, 17377, 17376, 1, 0, 0, 0, 17377, 17378, 1, 0, 0, 0, 17378, 1933, 1, 0, 0, 0, 17379, 17382, 5, 620, 0, 0, 17380, 17383, 3, 2340, 1170, 0, 17381, 17383, 3, 2360, 1180, 0, 17382, 17380, 1, 0, 0, 0, 17382, 17381, 1, 0, 0, 0, 17383, 1935, 1, 0, 0, 0, 17384, 17385, 5, 738, 0, 0, 17385, 17403, 5, 2447, 0, 0, 17386, 17404, 3, 1896, 948, 0, 17387, 17392, 5, 55, 0, 0, 17388, 17389, 5, 2453, 0, 0, 17389, 17391, 5, 55, 0, 0, 17390, 17388, 1, 0, 0, 0, 17391, 17394, 1, 0, 0, 0, 17392, 17390, 1, 0, 0, 0, 17392, 17393, 1, 0, 0, 0, 17393, 17404, 1, 0, 0, 0, 17394, 17392, 1, 0, 0, 0, 17395, 17400, 3, 1938, 969, 0, 17396, 17397, 5, 2453, 0, 0, 17397, 17399, 3, 1938, 969, 0, 17398, 17396, 1, 0, 0, 0, 17399, 17402, 1, 0, 0, 0, 17400, 17398, 1, 0, 0, 0, 17400, 17401, 1, 0, 0, 0, 17401, 17404, 1, 0, 0, 0, 17402, 17400, 1, 0, 0, 0, 17403, 17386, 1, 0, 0, 0, 17403, 17387, 1, 0, 0, 0, 17403, 17395, 1, 0, 0, 0, 17404, 17405, 1, 0, 0, 0, 17405, 17406, 5, 2448, 0, 0, 17406, 1937, 1, 0, 0, 0, 17407, 17409, 3, 1940, 970, 0, 17408, 17410, 3, 2268, 1134, 0, 17409, 17408, 1, 0, 0, 0, 17409, 17410, 1, 0, 0, 0, 17410, 1939, 1, 0, 0, 0, 17411, 17418, 3, 2078, 1039, 0, 17412, 17414, 5, 2447, 0, 0, 17413, 17415, 3, 2076, 1038, 0, 17414, 17413, 1, 0, 0, 0, 17414, 17415, 1, 0, 0, 0, 17415, 17416, 1, 0, 0, 0, 17416, 17418, 5, 2448, 0, 0, 17417, 17411, 1, 0, 0, 0, 17417, 17412, 1, 0, 0, 0, 17418, 1941, 1, 0, 0, 0, 17419, 17422, 5, 2194, 0, 0, 17420, 17421, 7, 214, 0, 0, 17421, 17423, 5, 1229, 0, 0, 17422, 17420, 1, 0, 0, 0, 17422, 17423, 1, 0, 0, 0, 17423, 17424, 1, 0, 0, 0, 17424, 17427, 5, 2447, 0, 0, 17425, 17428, 3, 2340, 1170, 0, 17426, 17428, 3, 2360, 1180, 0, 17427, 17425, 1, 0, 0, 0, 17427, 17426, 1, 0, 0, 0, 17428, 17429, 1, 0, 0, 0, 17429, 17430, 3, 1934, 967, 0, 17430, 17431, 3, 1944, 972, 0, 17431, 17433, 5, 2448, 0, 0, 17432, 17434, 3, 2270, 1135, 0, 17433, 17432, 1, 0, 0, 0, 17433, 17434, 1, 0, 0, 0, 17434, 1943, 1, 0, 0, 0, 17435, 17436, 5, 738, 0, 0, 17436, 17437, 5, 2447, 0, 0, 17437, 17442, 3, 1946, 973, 0, 17438, 17439, 5, 2453, 0, 0, 17439, 17441, 3, 1946, 973, 0, 17440, 17438, 1, 0, 0, 0, 17441, 17444, 1, 0, 0, 0, 17442, 17440, 1, 0, 0, 0, 17442, 17443, 1, 0, 0, 0, 17443, 17445, 1, 0, 0, 0, 17444, 17442, 1, 0, 0, 0, 17445, 17446, 5, 2448, 0, 0, 17446, 1945, 1, 0, 0, 0, 17447, 17450, 3, 2340, 1170, 0, 17448, 17450, 3, 2360, 1180, 0, 17449, 17447, 1, 0, 0, 0, 17449, 17448, 1, 0, 0, 0, 17450, 17466, 1, 0, 0, 0, 17451, 17464, 5, 69, 0, 0, 17452, 17465, 3, 2394, 1197, 0, 17453, 17454, 5, 2447, 0, 0, 17454, 17459, 3, 2394, 1197, 0, 17455, 17456, 5, 2453, 0, 0, 17456, 17458, 3, 2394, 1197, 0, 17457, 17455, 1, 0, 0, 0, 17458, 17461, 1, 0, 0, 0, 17459, 17457, 1, 0, 0, 0, 17459, 17460, 1, 0, 0, 0, 17460, 17462, 1, 0, 0, 0, 17461, 17459, 1, 0, 0, 0, 17462, 17463, 5, 2448, 0, 0, 17463, 17465, 1, 0, 0, 0, 17464, 17452, 1, 0, 0, 0, 17464, 17453, 1, 0, 0, 0, 17465, 17467, 1, 0, 0, 0, 17466, 17451, 1, 0, 0, 0, 17466, 17467, 1, 0, 0, 0, 17467, 1947, 1, 0, 0, 0, 17468, 17469, 5, 280, 0, 0, 17469, 17471, 5, 160, 0, 0, 17470, 17472, 5, 1084, 0, 0, 17471, 17470, 1, 0, 0, 0, 17471, 17472, 1, 0, 0, 0, 17472, 17473, 1, 0, 0, 0, 17473, 17475, 3, 2074, 1037, 0, 17474, 17476, 3, 1950, 975, 0, 17475, 17474, 1, 0, 0, 0, 17475, 17476, 1, 0, 0, 0, 17476, 17486, 1, 0, 0, 0, 17477, 17478, 3, 1950, 975, 0, 17478, 17479, 5, 280, 0, 0, 17479, 17481, 5, 160, 0, 0, 17480, 17482, 5, 1084, 0, 0, 17481, 17480, 1, 0, 0, 0, 17481, 17482, 1, 0, 0, 0, 17482, 17483, 1, 0, 0, 0, 17483, 17484, 3, 2074, 1037, 0, 17484, 17486, 1, 0, 0, 0, 17485, 17468, 1, 0, 0, 0, 17485, 17477, 1, 0, 0, 0, 17486, 1949, 1, 0, 0, 0, 17487, 17488, 5, 1737, 0, 0, 17488, 17489, 5, 2308, 0, 0, 17489, 17490, 3, 2074, 1037, 0, 17490, 1951, 1, 0, 0, 0, 17491, 17492, 5, 649, 0, 0, 17492, 17493, 5, 160, 0, 0, 17493, 17498, 3, 1954, 977, 0, 17494, 17495, 5, 2453, 0, 0, 17495, 17497, 3, 1954, 977, 0, 17496, 17494, 1, 0, 0, 0, 17497, 17500, 1, 0, 0, 0, 17498, 17496, 1, 0, 0, 0, 17498, 17499, 1, 0, 0, 0, 17499, 17502, 1, 0, 0, 0, 17500, 17498, 1, 0, 0, 0, 17501, 17503, 3, 1962, 981, 0, 17502, 17501, 1, 0, 0, 0, 17502, 17503, 1, 0, 0, 0, 17503, 17518, 1, 0, 0, 0, 17504, 17515, 3, 1962, 981, 0, 17505, 17506, 5, 649, 0, 0, 17506, 17507, 5, 160, 0, 0, 17507, 17512, 3, 1954, 977, 0, 17508, 17509, 5, 2453, 0, 0, 17509, 17511, 3, 1954, 977, 0, 17510, 17508, 1, 0, 0, 0, 17511, 17514, 1, 0, 0, 0, 17512, 17510, 1, 0, 0, 0, 17512, 17513, 1, 0, 0, 0, 17513, 17516, 1, 0, 0, 0, 17514, 17512, 1, 0, 0, 0, 17515, 17505, 1, 0, 0, 0, 17515, 17516, 1, 0, 0, 0, 17516, 17518, 1, 0, 0, 0, 17517, 17491, 1, 0, 0, 0, 17517, 17504, 1, 0, 0, 0, 17518, 1953, 1, 0, 0, 0, 17519, 17523, 3, 1958, 979, 0, 17520, 17523, 3, 1956, 978, 0, 17521, 17523, 3, 2078, 1039, 0, 17522, 17519, 1, 0, 0, 0, 17522, 17520, 1, 0, 0, 0, 17522, 17521, 1, 0, 0, 0, 17523, 1955, 1, 0, 0, 0, 17524, 17525, 7, 215, 0, 0, 17525, 17526, 5, 2447, 0, 0, 17526, 17531, 3, 1960, 980, 0, 17527, 17528, 5, 2453, 0, 0, 17528, 17530, 3, 1960, 980, 0, 17529, 17527, 1, 0, 0, 0, 17530, 17533, 1, 0, 0, 0, 17531, 17529, 1, 0, 0, 0, 17531, 17532, 1, 0, 0, 0, 17532, 17534, 1, 0, 0, 0, 17533, 17531, 1, 0, 0, 0, 17534, 17535, 5, 2448, 0, 0, 17535, 1957, 1, 0, 0, 0, 17536, 17537, 5, 651, 0, 0, 17537, 17538, 5, 1672, 0, 0, 17538, 17539, 5, 2447, 0, 0, 17539, 17544, 3, 1960, 980, 0, 17540, 17541, 5, 2453, 0, 0, 17541, 17543, 3, 1960, 980, 0, 17542, 17540, 1, 0, 0, 0, 17543, 17546, 1, 0, 0, 0, 17544, 17542, 1, 0, 0, 0, 17544, 17545, 1, 0, 0, 0, 17545, 17547, 1, 0, 0, 0, 17546, 17544, 1, 0, 0, 0, 17547, 17548, 5, 2448, 0, 0, 17548, 1959, 1, 0, 0, 0, 17549, 17557, 3, 1956, 978, 0, 17550, 17552, 5, 2447, 0, 0, 17551, 17553, 3, 2076, 1038, 0, 17552, 17551, 1, 0, 0, 0, 17552, 17553, 1, 0, 0, 0, 17553, 17554, 1, 0, 0, 0, 17554, 17557, 5, 2448, 0, 0, 17555, 17557, 3, 2078, 1039, 0, 17556, 17549, 1, 0, 0, 0, 17556, 17550, 1, 0, 0, 0, 17556, 17555, 1, 0, 0, 0, 17557, 1961, 1, 0, 0, 0, 17558, 17559, 5, 663, 0, 0, 17559, 17560, 3, 2074, 1037, 0, 17560, 1963, 1, 0, 0, 0, 17561, 17565, 5, 971, 0, 0, 17562, 17564, 3, 1966, 983, 0, 17563, 17562, 1, 0, 0, 0, 17564, 17567, 1, 0, 0, 0, 17565, 17563, 1, 0, 0, 0, 17565, 17566, 1, 0, 0, 0, 17566, 17569, 1, 0, 0, 0, 17567, 17565, 1, 0, 0, 0, 17568, 17570, 3, 1968, 984, 0, 17569, 17568, 1, 0, 0, 0, 17569, 17570, 1, 0, 0, 0, 17570, 17574, 1, 0, 0, 0, 17571, 17573, 3, 1970, 985, 0, 17572, 17571, 1, 0, 0, 0, 17573, 17576, 1, 0, 0, 0, 17574, 17572, 1, 0, 0, 0, 17574, 17575, 1, 0, 0, 0, 17575, 17577, 1, 0, 0, 0, 17576, 17574, 1, 0, 0, 0, 17577, 17578, 3, 1972, 986, 0, 17578, 1965, 1, 0, 0, 0, 17579, 17580, 7, 216, 0, 0, 17580, 17588, 5, 1006, 0, 0, 17581, 17585, 5, 2183, 0, 0, 17582, 17586, 5, 422, 0, 0, 17583, 17584, 5, 1695, 0, 0, 17584, 17586, 5, 1527, 0, 0, 17585, 17582, 1, 0, 0, 0, 17585, 17583, 1, 0, 0, 0, 17586, 17588, 1, 0, 0, 0, 17587, 17579, 1, 0, 0, 0, 17587, 17581, 1, 0, 0, 0, 17588, 1967, 1, 0, 0, 0, 17589, 17590, 5, 1586, 0, 0, 17590, 17591, 7, 217, 0, 0, 17591, 17592, 5, 1607, 0, 0, 17592, 1969, 1, 0, 0, 0, 17593, 17594, 5, 1527, 0, 0, 17594, 17595, 3, 2296, 1148, 0, 17595, 17596, 5, 1259, 0, 0, 17596, 17597, 5, 2447, 0, 0, 17597, 17598, 3, 1896, 948, 0, 17598, 17599, 5, 2448, 0, 0, 17599, 17603, 3, 1974, 987, 0, 17600, 17602, 3, 1966, 983, 0, 17601, 17600, 1, 0, 0, 0, 17602, 17605, 1, 0, 0, 0, 17603, 17601, 1, 0, 0, 0, 17603, 17604, 1, 0, 0, 0, 17604, 1971, 1, 0, 0, 0, 17605, 17603, 1, 0, 0, 0, 17606, 17607, 5, 902, 0, 0, 17607, 17609, 3, 2298, 1149, 0, 17608, 17606, 1, 0, 0, 0, 17608, 17609, 1, 0, 0, 0, 17609, 17610, 1, 0, 0, 0, 17610, 17614, 3, 1974, 987, 0, 17611, 17613, 3, 1966, 983, 0, 17612, 17611, 1, 0, 0, 0, 17613, 17616, 1, 0, 0, 0, 17614, 17612, 1, 0, 0, 0, 17614, 17615, 1, 0, 0, 0, 17615, 17617, 1, 0, 0, 0, 17616, 17614, 1, 0, 0, 0, 17617, 17618, 3, 1982, 991, 0, 17618, 1973, 1, 0, 0, 0, 17619, 17621, 3, 1976, 988, 0, 17620, 17619, 1, 0, 0, 0, 17620, 17621, 1, 0, 0, 0, 17621, 17622, 1, 0, 0, 0, 17622, 17623, 5, 422, 0, 0, 17623, 17624, 5, 160, 0, 0, 17624, 17625, 3, 1978, 989, 0, 17625, 17626, 5, 934, 0, 0, 17626, 17627, 3, 1978, 989, 0, 17627, 1975, 1, 0, 0, 0, 17628, 17629, 5, 1348, 0, 0, 17629, 17630, 5, 160, 0, 0, 17630, 17631, 3, 1978, 989, 0, 17631, 1977, 1, 0, 0, 0, 17632, 17633, 5, 2447, 0, 0, 17633, 17638, 3, 1980, 990, 0, 17634, 17635, 5, 2453, 0, 0, 17635, 17637, 3, 1980, 990, 0, 17636, 17634, 1, 0, 0, 0, 17637, 17640, 1, 0, 0, 0, 17638, 17636, 1, 0, 0, 0, 17638, 17639, 1, 0, 0, 0, 17639, 17641, 1, 0, 0, 0, 17640, 17638, 1, 0, 0, 0, 17641, 17642, 5, 2448, 0, 0, 17642, 1979, 1, 0, 0, 0, 17643, 17646, 3, 2078, 1039, 0, 17644, 17646, 3, 1902, 951, 0, 17645, 17643, 1, 0, 0, 0, 17645, 17644, 1, 0, 0, 0, 17646, 17648, 1, 0, 0, 0, 17647, 17649, 3, 2268, 1134, 0, 17648, 17647, 1, 0, 0, 0, 17648, 17649, 1, 0, 0, 0, 17649, 1981, 1, 0, 0, 0, 17650, 17652, 3, 1984, 992, 0, 17651, 17650, 1, 0, 0, 0, 17651, 17652, 1, 0, 0, 0, 17652, 17653, 1, 0, 0, 0, 17653, 17662, 5, 2447, 0, 0, 17654, 17659, 3, 1986, 993, 0, 17655, 17656, 5, 2453, 0, 0, 17656, 17658, 3, 1986, 993, 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, 17654, 1, 0, 0, 0, 17662, 17663, 1, 0, 0, 0, 17663, 17664, 1, 0, 0, 0, 17664, 17665, 5, 2448, 0, 0, 17665, 1983, 1, 0, 0, 0, 17666, 17672, 5, 1611, 0, 0, 17667, 17673, 5, 2207, 0, 0, 17668, 17670, 5, 2213, 0, 0, 17669, 17671, 5, 38, 0, 0, 17670, 17669, 1, 0, 0, 0, 17670, 17671, 1, 0, 0, 0, 17671, 17673, 1, 0, 0, 0, 17672, 17667, 1, 0, 0, 0, 17672, 17668, 1, 0, 0, 0, 17672, 17673, 1, 0, 0, 0, 17673, 17676, 1, 0, 0, 0, 17674, 17675, 7, 218, 0, 0, 17675, 17677, 5, 1303, 0, 0, 17676, 17674, 1, 0, 0, 0, 17676, 17677, 1, 0, 0, 0, 17677, 17679, 1, 0, 0, 0, 17678, 17680, 3, 1990, 995, 0, 17679, 17678, 1, 0, 0, 0, 17679, 17680, 1, 0, 0, 0, 17680, 1985, 1, 0, 0, 0, 17681, 17687, 5, 2207, 0, 0, 17682, 17684, 5, 2213, 0, 0, 17683, 17685, 5, 38, 0, 0, 17684, 17683, 1, 0, 0, 0, 17684, 17685, 1, 0, 0, 0, 17685, 17687, 1, 0, 0, 0, 17686, 17681, 1, 0, 0, 0, 17686, 17682, 1, 0, 0, 0, 17686, 17687, 1, 0, 0, 0, 17687, 17688, 1, 0, 0, 0, 17688, 17690, 3, 1988, 994, 0, 17689, 17691, 3, 1994, 997, 0, 17690, 17689, 1, 0, 0, 0, 17690, 17691, 1, 0, 0, 0, 17691, 17692, 1, 0, 0, 0, 17692, 17693, 5, 2472, 0, 0, 17693, 17694, 3, 2078, 1039, 0, 17694, 1987, 1, 0, 0, 0, 17695, 17696, 3, 2106, 1053, 0, 17696, 1989, 1, 0, 0, 0, 17697, 17698, 5, 790, 0, 0, 17698, 17699, 5, 2447, 0, 0, 17699, 17700, 3, 2078, 1039, 0, 17700, 17702, 5, 2448, 0, 0, 17701, 17703, 3, 1992, 996, 0, 17702, 17701, 1, 0, 0, 0, 17702, 17703, 1, 0, 0, 0, 17703, 1991, 1, 0, 0, 0, 17704, 17705, 5, 2202, 0, 0, 17705, 17706, 5, 2447, 0, 0, 17706, 17707, 3, 2074, 1037, 0, 17707, 17708, 5, 2448, 0, 0, 17708, 1993, 1, 0, 0, 0, 17709, 17711, 5, 1303, 0, 0, 17710, 17712, 5, 1686, 0, 0, 17711, 17710, 1, 0, 0, 0, 17711, 17712, 1, 0, 0, 0, 17712, 17713, 1, 0, 0, 0, 17713, 17714, 5, 160, 0, 0, 17714, 17719, 3, 1996, 998, 0, 17715, 17716, 5, 2453, 0, 0, 17716, 17718, 3, 1996, 998, 0, 17717, 17715, 1, 0, 0, 0, 17718, 17721, 1, 0, 0, 0, 17719, 17717, 1, 0, 0, 0, 17719, 17720, 1, 0, 0, 0, 17720, 1995, 1, 0, 0, 0, 17721, 17719, 1, 0, 0, 0, 17722, 17724, 3, 2078, 1039, 0, 17723, 17725, 7, 55, 0, 0, 17724, 17723, 1, 0, 0, 0, 17724, 17725, 1, 0, 0, 0, 17725, 17728, 1, 0, 0, 0, 17726, 17727, 5, 1229, 0, 0, 17727, 17729, 7, 56, 0, 0, 17728, 17726, 1, 0, 0, 0, 17728, 17729, 1, 0, 0, 0, 17729, 1997, 1, 0, 0, 0, 17730, 17731, 5, 1245, 0, 0, 17731, 17732, 3, 2078, 1039, 0, 17732, 17733, 7, 219, 0, 0, 17733, 1999, 1, 0, 0, 0, 17734, 17735, 5, 586, 0, 0, 17735, 17740, 7, 220, 0, 0, 17736, 17738, 3, 2078, 1039, 0, 17737, 17739, 5, 1378, 0, 0, 17738, 17737, 1, 0, 0, 0, 17738, 17739, 1, 0, 0, 0, 17739, 17741, 1, 0, 0, 0, 17740, 17736, 1, 0, 0, 0, 17740, 17741, 1, 0, 0, 0, 17741, 17742, 1, 0, 0, 0, 17742, 17746, 7, 219, 0, 0, 17743, 17747, 5, 1258, 0, 0, 17744, 17745, 5, 2308, 0, 0, 17745, 17747, 5, 2105, 0, 0, 17746, 17743, 1, 0, 0, 0, 17746, 17744, 1, 0, 0, 0, 17747, 2001, 1, 0, 0, 0, 17748, 17749, 5, 620, 0, 0, 17749, 17751, 5, 2207, 0, 0, 17750, 17752, 3, 2004, 1002, 0, 17751, 17750, 1, 0, 0, 0, 17751, 17752, 1, 0, 0, 0, 17752, 17754, 1, 0, 0, 0, 17753, 17755, 3, 2006, 1003, 0, 17754, 17753, 1, 0, 0, 0, 17754, 17755, 1, 0, 0, 0, 17755, 2003, 1, 0, 0, 0, 17756, 17757, 5, 1246, 0, 0, 17757, 17758, 3, 2358, 1179, 0, 17758, 2005, 1, 0, 0, 0, 17759, 17760, 5, 1702, 0, 0, 17760, 17765, 5, 879, 0, 0, 17761, 17765, 5, 1219, 0, 0, 17762, 17763, 5, 2293, 0, 0, 17763, 17765, 3, 2078, 1039, 0, 17764, 17759, 1, 0, 0, 0, 17764, 17761, 1, 0, 0, 0, 17764, 17762, 1, 0, 0, 0, 17765, 2007, 1, 0, 0, 0, 17766, 17767, 5, 2207, 0, 0, 17767, 17768, 3, 2054, 1027, 0, 17768, 17770, 3, 2010, 1005, 0, 17769, 17771, 3, 2272, 1136, 0, 17770, 17769, 1, 0, 0, 0, 17770, 17771, 1, 0, 0, 0, 17771, 17773, 1, 0, 0, 0, 17772, 17774, 3, 2056, 1028, 0, 17773, 17772, 1, 0, 0, 0, 17773, 17774, 1, 0, 0, 0, 17774, 17776, 1, 0, 0, 0, 17775, 17777, 3, 2058, 1029, 0, 17776, 17775, 1, 0, 0, 0, 17776, 17777, 1, 0, 0, 0, 17777, 2009, 1, 0, 0, 0, 17778, 17794, 5, 1671, 0, 0, 17779, 17784, 3, 2012, 1006, 0, 17780, 17781, 5, 2453, 0, 0, 17781, 17783, 3, 2012, 1006, 0, 17782, 17780, 1, 0, 0, 0, 17783, 17786, 1, 0, 0, 0, 17784, 17782, 1, 0, 0, 0, 17784, 17785, 1, 0, 0, 0, 17785, 17795, 1, 0, 0, 0, 17786, 17784, 1, 0, 0, 0, 17787, 17788, 5, 2258, 0, 0, 17788, 17789, 5, 2447, 0, 0, 17789, 17790, 3, 2402, 1201, 0, 17790, 17791, 5, 2448, 0, 0, 17791, 17792, 5, 2472, 0, 0, 17792, 17793, 3, 2078, 1039, 0, 17793, 17795, 1, 0, 0, 0, 17794, 17779, 1, 0, 0, 0, 17794, 17787, 1, 0, 0, 0, 17795, 2011, 1, 0, 0, 0, 17796, 17797, 3, 2340, 1170, 0, 17797, 17798, 5, 2472, 0, 0, 17798, 17799, 3, 2078, 1039, 0, 17799, 17805, 1, 0, 0, 0, 17800, 17801, 3, 2360, 1180, 0, 17801, 17802, 5, 2472, 0, 0, 17802, 17803, 3, 1896, 948, 0, 17803, 17805, 1, 0, 0, 0, 17804, 17796, 1, 0, 0, 0, 17804, 17800, 1, 0, 0, 0, 17805, 2013, 1, 0, 0, 0, 17806, 17808, 5, 403, 0, 0, 17807, 17809, 5, 628, 0, 0, 17808, 17807, 1, 0, 0, 0, 17808, 17809, 1, 0, 0, 0, 17809, 17810, 1, 0, 0, 0, 17810, 17812, 3, 2054, 1027, 0, 17811, 17813, 3, 2272, 1136, 0, 17812, 17811, 1, 0, 0, 0, 17812, 17813, 1, 0, 0, 0, 17813, 17815, 1, 0, 0, 0, 17814, 17816, 3, 2056, 1028, 0, 17815, 17814, 1, 0, 0, 0, 17815, 17816, 1, 0, 0, 0, 17816, 17818, 1, 0, 0, 0, 17817, 17819, 3, 2058, 1029, 0, 17818, 17817, 1, 0, 0, 0, 17818, 17819, 1, 0, 0, 0, 17819, 2015, 1, 0, 0, 0, 17820, 17823, 5, 756, 0, 0, 17821, 17824, 3, 2018, 1009, 0, 17822, 17824, 3, 2020, 1010, 0, 17823, 17821, 1, 0, 0, 0, 17823, 17822, 1, 0, 0, 0, 17824, 2017, 1, 0, 0, 0, 17825, 17831, 3, 2030, 1015, 0, 17826, 17828, 3, 2032, 1016, 0, 17827, 17829, 3, 2056, 1028, 0, 17828, 17827, 1, 0, 0, 0, 17828, 17829, 1, 0, 0, 0, 17829, 17832, 1, 0, 0, 0, 17830, 17832, 3, 1870, 935, 0, 17831, 17826, 1, 0, 0, 0, 17831, 17830, 1, 0, 0, 0, 17832, 17834, 1, 0, 0, 0, 17833, 17835, 3, 2058, 1029, 0, 17834, 17833, 1, 0, 0, 0, 17834, 17835, 1, 0, 0, 0, 17835, 2019, 1, 0, 0, 0, 17836, 17838, 5, 38, 0, 0, 17837, 17839, 3, 2022, 1011, 0, 17838, 17837, 1, 0, 0, 0, 17839, 17840, 1, 0, 0, 0, 17840, 17838, 1, 0, 0, 0, 17840, 17841, 1, 0, 0, 0, 17841, 17844, 1, 0, 0, 0, 17842, 17844, 3, 2024, 1012, 0, 17843, 17836, 1, 0, 0, 0, 17843, 17842, 1, 0, 0, 0, 17844, 17845, 1, 0, 0, 0, 17845, 17846, 3, 1870, 935, 0, 17846, 2021, 1, 0, 0, 0, 17847, 17849, 3, 2030, 1015, 0, 17848, 17850, 3, 2032, 1016, 0, 17849, 17848, 1, 0, 0, 0, 17849, 17850, 1, 0, 0, 0, 17850, 17852, 1, 0, 0, 0, 17851, 17853, 3, 2058, 1029, 0, 17852, 17851, 1, 0, 0, 0, 17852, 17853, 1, 0, 0, 0, 17853, 2023, 1, 0, 0, 0, 17854, 17856, 7, 221, 0, 0, 17855, 17854, 1, 0, 0, 0, 17855, 17856, 1, 0, 0, 0, 17856, 17858, 1, 0, 0, 0, 17857, 17859, 3, 2026, 1013, 0, 17858, 17857, 1, 0, 0, 0, 17859, 17860, 1, 0, 0, 0, 17860, 17858, 1, 0, 0, 0, 17860, 17861, 1, 0, 0, 0, 17861, 17863, 1, 0, 0, 0, 17862, 17864, 3, 2028, 1014, 0, 17863, 17862, 1, 0, 0, 0, 17863, 17864, 1, 0, 0, 0, 17864, 2025, 1, 0, 0, 0, 17865, 17866, 5, 2300, 0, 0, 17866, 17867, 3, 2074, 1037, 0, 17867, 17869, 5, 2099, 0, 0, 17868, 17870, 3, 2022, 1011, 0, 17869, 17868, 1, 0, 0, 0, 17870, 17871, 1, 0, 0, 0, 17871, 17869, 1, 0, 0, 0, 17871, 17872, 1, 0, 0, 0, 17872, 2027, 1, 0, 0, 0, 17873, 17875, 5, 491, 0, 0, 17874, 17876, 3, 2022, 1011, 0, 17875, 17874, 1, 0, 0, 0, 17876, 17877, 1, 0, 0, 0, 17877, 17875, 1, 0, 0, 0, 17877, 17878, 1, 0, 0, 0, 17878, 2029, 1, 0, 0, 0, 17879, 17880, 5, 779, 0, 0, 17880, 17882, 3, 2054, 1027, 0, 17881, 17883, 5, 588, 0, 0, 17882, 17881, 1, 0, 0, 0, 17882, 17883, 1, 0, 0, 0, 17883, 17885, 1, 0, 0, 0, 17884, 17886, 3, 2360, 1180, 0, 17885, 17884, 1, 0, 0, 0, 17885, 17886, 1, 0, 0, 0, 17886, 2031, 1, 0, 0, 0, 17887, 17894, 5, 2257, 0, 0, 17888, 17895, 5, 2480, 0, 0, 17889, 17890, 5, 2447, 0, 0, 17890, 17891, 3, 2076, 1038, 0, 17891, 17892, 5, 2448, 0, 0, 17892, 17895, 1, 0, 0, 0, 17893, 17895, 3, 2120, 1060, 0, 17894, 17888, 1, 0, 0, 0, 17894, 17889, 1, 0, 0, 0, 17894, 17893, 1, 0, 0, 0, 17895, 2033, 1, 0, 0, 0, 17896, 17897, 5, 946, 0, 0, 17897, 17898, 5, 779, 0, 0, 17898, 17899, 3, 2044, 1022, 0, 17899, 17900, 5, 2246, 0, 0, 17900, 17901, 3, 2044, 1022, 0, 17901, 17902, 5, 1259, 0, 0, 17902, 17903, 5, 2447, 0, 0, 17903, 17904, 3, 2074, 1037, 0, 17904, 17913, 5, 2448, 0, 0, 17905, 17907, 3, 2036, 1018, 0, 17906, 17908, 3, 2042, 1021, 0, 17907, 17906, 1, 0, 0, 0, 17907, 17908, 1, 0, 0, 0, 17908, 17914, 1, 0, 0, 0, 17909, 17911, 3, 2042, 1021, 0, 17910, 17912, 3, 2036, 1018, 0, 17911, 17910, 1, 0, 0, 0, 17911, 17912, 1, 0, 0, 0, 17912, 17914, 1, 0, 0, 0, 17913, 17905, 1, 0, 0, 0, 17913, 17909, 1, 0, 0, 0, 17914, 17916, 1, 0, 0, 0, 17915, 17917, 3, 2058, 1029, 0, 17916, 17915, 1, 0, 0, 0, 17916, 17917, 1, 0, 0, 0, 17917, 17919, 1, 0, 0, 0, 17918, 17920, 3, 2056, 1028, 0, 17919, 17918, 1, 0, 0, 0, 17919, 17920, 1, 0, 0, 0, 17920, 2035, 1, 0, 0, 0, 17921, 17922, 5, 2300, 0, 0, 17922, 17923, 5, 914, 0, 0, 17923, 17924, 5, 2099, 0, 0, 17924, 17925, 5, 2207, 0, 0, 17925, 17926, 5, 1671, 0, 0, 17926, 17931, 3, 2038, 1019, 0, 17927, 17928, 5, 2453, 0, 0, 17928, 17930, 3, 2038, 1019, 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, 17935, 1, 0, 0, 0, 17933, 17931, 1, 0, 0, 0, 17934, 17936, 3, 2272, 1136, 0, 17935, 17934, 1, 0, 0, 0, 17935, 17936, 1, 0, 0, 0, 17936, 17938, 1, 0, 0, 0, 17937, 17939, 3, 2040, 1020, 0, 17938, 17937, 1, 0, 0, 0, 17938, 17939, 1, 0, 0, 0, 17939, 2037, 1, 0, 0, 0, 17940, 17941, 3, 2340, 1170, 0, 17941, 17942, 5, 2472, 0, 0, 17942, 17943, 3, 2078, 1039, 0, 17943, 2039, 1, 0, 0, 0, 17944, 17945, 5, 403, 0, 0, 17945, 17946, 3, 2272, 1136, 0, 17946, 2041, 1, 0, 0, 0, 17947, 17948, 5, 2300, 0, 0, 17948, 17949, 5, 1204, 0, 0, 17949, 17950, 5, 914, 0, 0, 17950, 17951, 5, 2099, 0, 0, 17951, 17953, 5, 756, 0, 0, 17952, 17954, 3, 2360, 1180, 0, 17953, 17952, 1, 0, 0, 0, 17953, 17954, 1, 0, 0, 0, 17954, 17955, 1, 0, 0, 0, 17955, 17957, 3, 2032, 1016, 0, 17956, 17958, 3, 2272, 1136, 0, 17957, 17956, 1, 0, 0, 0, 17957, 17958, 1, 0, 0, 0, 17958, 2043, 1, 0, 0, 0, 17959, 17970, 3, 2342, 1171, 0, 17960, 17961, 5, 2447, 0, 0, 17961, 17962, 3, 1870, 935, 0, 17962, 17963, 5, 2448, 0, 0, 17963, 17970, 1, 0, 0, 0, 17964, 17970, 3, 2066, 1033, 0, 17965, 17966, 5, 2447, 0, 0, 17966, 17967, 3, 2066, 1033, 0, 17967, 17968, 5, 2448, 0, 0, 17968, 17970, 1, 0, 0, 0, 17969, 17959, 1, 0, 0, 0, 17969, 17960, 1, 0, 0, 0, 17969, 17964, 1, 0, 0, 0, 17969, 17965, 1, 0, 0, 0, 17970, 17972, 1, 0, 0, 0, 17971, 17973, 3, 2270, 1135, 0, 17972, 17971, 1, 0, 0, 0, 17972, 17973, 1, 0, 0, 0, 17973, 2045, 1, 0, 0, 0, 17974, 17975, 5, 881, 0, 0, 17975, 17976, 5, 2083, 0, 0, 17976, 17981, 3, 2050, 1025, 0, 17977, 17978, 5, 2453, 0, 0, 17978, 17980, 3, 2050, 1025, 0, 17979, 17977, 1, 0, 0, 0, 17980, 17983, 1, 0, 0, 0, 17981, 17979, 1, 0, 0, 0, 17981, 17982, 1, 0, 0, 0, 17982, 17984, 1, 0, 0, 0, 17983, 17981, 1, 0, 0, 0, 17984, 17985, 5, 738, 0, 0, 17985, 17986, 3, 2052, 1026, 0, 17986, 17988, 5, 977, 0, 0, 17987, 17989, 3, 2048, 1024, 0, 17988, 17987, 1, 0, 0, 0, 17988, 17989, 1, 0, 0, 0, 17989, 2047, 1, 0, 0, 0, 17990, 17991, 5, 2293, 0, 0, 17991, 17994, 3, 2078, 1039, 0, 17992, 17994, 5, 1219, 0, 0, 17993, 17990, 1, 0, 0, 0, 17993, 17992, 1, 0, 0, 0, 17994, 2049, 1, 0, 0, 0, 17995, 17997, 3, 2342, 1171, 0, 17996, 17998, 3, 2266, 1133, 0, 17997, 17996, 1, 0, 0, 0, 17997, 17998, 1, 0, 0, 0, 17998, 2051, 1, 0, 0, 0, 17999, 18000, 5, 1606, 0, 0, 18000, 18012, 5, 1680, 0, 0, 18001, 18002, 5, 1606, 0, 0, 18002, 18012, 5, 541, 0, 0, 18003, 18005, 5, 1680, 0, 0, 18004, 18006, 5, 2207, 0, 0, 18005, 18004, 1, 0, 0, 0, 18005, 18006, 1, 0, 0, 0, 18006, 18012, 1, 0, 0, 0, 18007, 18008, 5, 1680, 0, 0, 18008, 18009, 5, 1606, 0, 0, 18009, 18012, 5, 541, 0, 0, 18010, 18012, 5, 541, 0, 0, 18011, 17999, 1, 0, 0, 0, 18011, 18001, 1, 0, 0, 0, 18011, 18003, 1, 0, 0, 0, 18011, 18007, 1, 0, 0, 0, 18011, 18010, 1, 0, 0, 0, 18012, 2053, 1, 0, 0, 0, 18013, 18020, 3, 2064, 1032, 0, 18014, 18015, 5, 1258, 0, 0, 18015, 18016, 5, 2447, 0, 0, 18016, 18017, 3, 2064, 1032, 0, 18017, 18018, 5, 2448, 0, 0, 18018, 18020, 1, 0, 0, 0, 18019, 18013, 1, 0, 0, 0, 18019, 18014, 1, 0, 0, 0, 18020, 18022, 1, 0, 0, 0, 18021, 18023, 3, 2270, 1135, 0, 18022, 18021, 1, 0, 0, 0, 18022, 18023, 1, 0, 0, 0, 18023, 2055, 1, 0, 0, 0, 18024, 18025, 7, 205, 0, 0, 18025, 18026, 3, 2076, 1038, 0, 18026, 18027, 3, 2274, 1137, 0, 18027, 2057, 1, 0, 0, 0, 18028, 18029, 5, 888, 0, 0, 18029, 18031, 5, 522, 0, 0, 18030, 18032, 3, 2060, 1030, 0, 18031, 18030, 1, 0, 0, 0, 18031, 18032, 1, 0, 0, 0, 18032, 18034, 1, 0, 0, 0, 18033, 18035, 3, 2078, 1039, 0, 18034, 18033, 1, 0, 0, 0, 18034, 18035, 1, 0, 0, 0, 18035, 18037, 1, 0, 0, 0, 18036, 18038, 3, 2062, 1031, 0, 18037, 18036, 1, 0, 0, 0, 18037, 18038, 1, 0, 0, 0, 18038, 2059, 1, 0, 0, 0, 18039, 18040, 5, 779, 0, 0, 18040, 18041, 3, 2342, 1171, 0, 18041, 2061, 1, 0, 0, 0, 18042, 18043, 5, 1549, 0, 0, 18043, 18046, 5, 858, 0, 0, 18044, 18047, 5, 2185, 0, 0, 18045, 18047, 3, 2078, 1039, 0, 18046, 18044, 1, 0, 0, 0, 18046, 18045, 1, 0, 0, 0, 18047, 2063, 1, 0, 0, 0, 18048, 18085, 3, 2066, 1033, 0, 18049, 18050, 5, 2447, 0, 0, 18050, 18052, 3, 1870, 935, 0, 18051, 18053, 3, 2068, 1034, 0, 18052, 18051, 1, 0, 0, 0, 18052, 18053, 1, 0, 0, 0, 18053, 18054, 1, 0, 0, 0, 18054, 18055, 5, 2448, 0, 0, 18055, 18085, 1, 0, 0, 0, 18056, 18058, 3, 2342, 1171, 0, 18057, 18059, 3, 1886, 943, 0, 18058, 18057, 1, 0, 0, 0, 18058, 18059, 1, 0, 0, 0, 18059, 18061, 1, 0, 0, 0, 18060, 18062, 3, 2070, 1035, 0, 18061, 18060, 1, 0, 0, 0, 18061, 18062, 1, 0, 0, 0, 18062, 18085, 1, 0, 0, 0, 18063, 18066, 3, 2156, 1078, 0, 18064, 18065, 5, 69, 0, 0, 18065, 18067, 3, 2402, 1201, 0, 18066, 18064, 1, 0, 0, 0, 18066, 18067, 1, 0, 0, 0, 18067, 18085, 1, 0, 0, 0, 18068, 18069, 5, 827, 0, 0, 18069, 18070, 5, 2447, 0, 0, 18070, 18072, 3, 1896, 948, 0, 18071, 18073, 3, 2068, 1034, 0, 18072, 18071, 1, 0, 0, 0, 18072, 18073, 1, 0, 0, 0, 18073, 18074, 1, 0, 0, 0, 18074, 18075, 5, 2448, 0, 0, 18075, 18085, 1, 0, 0, 0, 18076, 18077, 4, 1032, 12, 0, 18077, 18078, 5, 1551, 0, 0, 18078, 18079, 5, 2447, 0, 0, 18079, 18080, 3, 2342, 1171, 0, 18080, 18081, 5, 1204, 0, 0, 18081, 18082, 5, 2351, 0, 0, 18082, 18083, 5, 2448, 0, 0, 18083, 18085, 1, 0, 0, 0, 18084, 18048, 1, 0, 0, 0, 18084, 18049, 1, 0, 0, 0, 18084, 18056, 1, 0, 0, 0, 18084, 18063, 1, 0, 0, 0, 18084, 18068, 1, 0, 0, 0, 18084, 18076, 1, 0, 0, 0, 18085, 2065, 1, 0, 0, 0, 18086, 18097, 7, 222, 0, 0, 18087, 18088, 5, 2447, 0, 0, 18088, 18089, 3, 1896, 948, 0, 18089, 18090, 5, 2448, 0, 0, 18090, 18098, 1, 0, 0, 0, 18091, 18092, 5, 2447, 0, 0, 18092, 18093, 3, 2078, 1039, 0, 18093, 18095, 5, 2448, 0, 0, 18094, 18096, 3, 2408, 1204, 0, 18095, 18094, 1, 0, 0, 0, 18095, 18096, 1, 0, 0, 0, 18096, 18098, 1, 0, 0, 0, 18097, 18087, 1, 0, 0, 0, 18097, 18091, 1, 0, 0, 0, 18098, 2067, 1, 0, 0, 0, 18099, 18108, 5, 2308, 0, 0, 18100, 18101, 5, 1505, 0, 0, 18101, 18109, 5, 1258, 0, 0, 18102, 18103, 5, 200, 0, 0, 18103, 18106, 5, 1272, 0, 0, 18104, 18105, 5, 286, 0, 0, 18105, 18107, 3, 2310, 1155, 0, 18106, 18104, 1, 0, 0, 0, 18106, 18107, 1, 0, 0, 0, 18107, 18109, 1, 0, 0, 0, 18108, 18100, 1, 0, 0, 0, 18108, 18102, 1, 0, 0, 0, 18109, 2069, 1, 0, 0, 0, 18110, 18112, 5, 1614, 0, 0, 18111, 18113, 5, 143, 0, 0, 18112, 18111, 1, 0, 0, 0, 18112, 18113, 1, 0, 0, 0, 18113, 18114, 1, 0, 0, 0, 18114, 18115, 5, 2447, 0, 0, 18115, 18118, 3, 2078, 1039, 0, 18116, 18117, 5, 2453, 0, 0, 18117, 18119, 3, 2078, 1039, 0, 18118, 18116, 1, 0, 0, 0, 18118, 18119, 1, 0, 0, 0, 18119, 18120, 1, 0, 0, 0, 18120, 18122, 5, 2448, 0, 0, 18121, 18123, 3, 2072, 1036, 0, 18122, 18121, 1, 0, 0, 0, 18122, 18123, 1, 0, 0, 0, 18123, 2071, 1, 0, 0, 0, 18124, 18125, 5, 1642, 0, 0, 18125, 18126, 5, 2447, 0, 0, 18126, 18127, 3, 2078, 1039, 0, 18127, 18128, 5, 2448, 0, 0, 18128, 2073, 1, 0, 0, 0, 18129, 18136, 3, 2078, 1039, 0, 18130, 18131, 5, 797, 0, 0, 18131, 18132, 5, 2447, 0, 0, 18132, 18133, 3, 2076, 1038, 0, 18133, 18134, 5, 2448, 0, 0, 18134, 18136, 1, 0, 0, 0, 18135, 18129, 1, 0, 0, 0, 18135, 18130, 1, 0, 0, 0, 18136, 2075, 1, 0, 0, 0, 18137, 18142, 3, 2078, 1039, 0, 18138, 18139, 5, 2453, 0, 0, 18139, 18141, 3, 2078, 1039, 0, 18140, 18138, 1, 0, 0, 0, 18141, 18144, 1, 0, 0, 0, 18142, 18140, 1, 0, 0, 0, 18142, 18143, 1, 0, 0, 0, 18143, 2077, 1, 0, 0, 0, 18144, 18142, 1, 0, 0, 0, 18145, 18148, 3, 2080, 1040, 0, 18146, 18148, 3, 2082, 1041, 0, 18147, 18145, 1, 0, 0, 0, 18147, 18146, 1, 0, 0, 0, 18148, 2079, 1, 0, 0, 0, 18149, 18150, 5, 343, 0, 0, 18150, 18151, 5, 2447, 0, 0, 18151, 18152, 3, 1896, 948, 0, 18152, 18153, 5, 2448, 0, 0, 18153, 2081, 1, 0, 0, 0, 18154, 18155, 6, 1041, -1, 0, 18155, 18156, 3, 2084, 1042, 0, 18156, 18165, 1, 0, 0, 0, 18157, 18158, 10, 2, 0, 0, 18158, 18159, 5, 49, 0, 0, 18159, 18164, 3, 2082, 1041, 3, 18160, 18161, 10, 1, 0, 0, 18161, 18162, 5, 1307, 0, 0, 18162, 18164, 3, 2082, 1041, 2, 18163, 18157, 1, 0, 0, 0, 18163, 18160, 1, 0, 0, 0, 18164, 18167, 1, 0, 0, 0, 18165, 18163, 1, 0, 0, 0, 18165, 18166, 1, 0, 0, 0, 18166, 2083, 1, 0, 0, 0, 18167, 18165, 1, 0, 0, 0, 18168, 18170, 5, 1204, 0, 0, 18169, 18168, 1, 0, 0, 0, 18169, 18170, 1, 0, 0, 0, 18170, 18171, 1, 0, 0, 0, 18171, 18173, 3, 2090, 1045, 0, 18172, 18174, 3, 2086, 1043, 0, 18173, 18172, 1, 0, 0, 0, 18173, 18174, 1, 0, 0, 0, 18174, 2085, 1, 0, 0, 0, 18175, 18177, 5, 785, 0, 0, 18176, 18178, 5, 1204, 0, 0, 18177, 18176, 1, 0, 0, 0, 18177, 18178, 1, 0, 0, 0, 18178, 18179, 1, 0, 0, 0, 18179, 18180, 3, 2088, 1044, 0, 18180, 2087, 1, 0, 0, 0, 18181, 18220, 5, 1228, 0, 0, 18182, 18220, 5, 999, 0, 0, 18183, 18220, 5, 1444, 0, 0, 18184, 18220, 5, 735, 0, 0, 18185, 18186, 5, 36, 0, 0, 18186, 18220, 5, 1671, 0, 0, 18187, 18220, 5, 497, 0, 0, 18188, 18190, 5, 1246, 0, 0, 18189, 18191, 5, 2166, 0, 0, 18190, 18189, 1, 0, 0, 0, 18190, 18191, 1, 0, 0, 0, 18191, 18192, 1, 0, 0, 0, 18192, 18194, 5, 2447, 0, 0, 18193, 18195, 5, 1258, 0, 0, 18194, 18193, 1, 0, 0, 0, 18194, 18195, 1, 0, 0, 0, 18195, 18196, 1, 0, 0, 0, 18196, 18201, 3, 2374, 1187, 0, 18197, 18198, 5, 2453, 0, 0, 18198, 18200, 3, 2374, 1187, 0, 18199, 18197, 1, 0, 0, 0, 18200, 18203, 1, 0, 0, 0, 18201, 18199, 1, 0, 0, 0, 18201, 18202, 1, 0, 0, 0, 18202, 18204, 1, 0, 0, 0, 18203, 18201, 1, 0, 0, 0, 18204, 18205, 5, 2448, 0, 0, 18205, 18220, 1, 0, 0, 0, 18206, 18209, 5, 801, 0, 0, 18207, 18208, 5, 621, 0, 0, 18208, 18210, 5, 801, 0, 0, 18209, 18207, 1, 0, 0, 0, 18209, 18210, 1, 0, 0, 0, 18210, 18212, 1, 0, 0, 0, 18211, 18213, 7, 223, 0, 0, 18212, 18211, 1, 0, 0, 0, 18212, 18213, 1, 0, 0, 0, 18213, 18217, 1, 0, 0, 0, 18214, 18215, 7, 2, 0, 0, 18215, 18216, 5, 2183, 0, 0, 18216, 18218, 5, 819, 0, 0, 18217, 18214, 1, 0, 0, 0, 18217, 18218, 1, 0, 0, 0, 18218, 18220, 1, 0, 0, 0, 18219, 18181, 1, 0, 0, 0, 18219, 18182, 1, 0, 0, 0, 18219, 18183, 1, 0, 0, 0, 18219, 18184, 1, 0, 0, 0, 18219, 18185, 1, 0, 0, 0, 18219, 18187, 1, 0, 0, 0, 18219, 18188, 1, 0, 0, 0, 18219, 18206, 1, 0, 0, 0, 18220, 2089, 1, 0, 0, 0, 18221, 18222, 6, 1045, -1, 0, 18222, 18231, 3, 2092, 1046, 0, 18223, 18225, 5, 1204, 0, 0, 18224, 18223, 1, 0, 0, 0, 18224, 18225, 1, 0, 0, 0, 18225, 18226, 1, 0, 0, 0, 18226, 18228, 7, 224, 0, 0, 18227, 18229, 5, 1246, 0, 0, 18228, 18227, 1, 0, 0, 0, 18228, 18229, 1, 0, 0, 0, 18229, 18230, 1, 0, 0, 0, 18230, 18232, 3, 2102, 1051, 0, 18231, 18224, 1, 0, 0, 0, 18231, 18232, 1, 0, 0, 0, 18232, 18242, 1, 0, 0, 0, 18233, 18234, 10, 1, 0, 0, 18234, 18235, 5, 994, 0, 0, 18235, 18237, 7, 225, 0, 0, 18236, 18238, 7, 226, 0, 0, 18237, 18236, 1, 0, 0, 0, 18237, 18238, 1, 0, 0, 0, 18238, 18239, 1, 0, 0, 0, 18239, 18241, 3, 2092, 1046, 0, 18240, 18233, 1, 0, 0, 0, 18241, 18244, 1, 0, 0, 0, 18242, 18240, 1, 0, 0, 0, 18242, 18243, 1, 0, 0, 0, 18243, 2091, 1, 0, 0, 0, 18244, 18242, 1, 0, 0, 0, 18245, 18246, 6, 1046, -1, 0, 18246, 18247, 3, 2094, 1047, 0, 18247, 18260, 1, 0, 0, 0, 18248, 18249, 10, 3, 0, 0, 18249, 18250, 3, 2096, 1048, 0, 18250, 18251, 3, 2092, 1046, 4, 18251, 18259, 1, 0, 0, 0, 18252, 18254, 10, 2, 0, 0, 18253, 18255, 5, 1204, 0, 0, 18254, 18253, 1, 0, 0, 0, 18254, 18255, 1, 0, 0, 0, 18255, 18256, 1, 0, 0, 0, 18256, 18257, 5, 738, 0, 0, 18257, 18259, 3, 2098, 1049, 0, 18258, 18248, 1, 0, 0, 0, 18258, 18252, 1, 0, 0, 0, 18259, 18262, 1, 0, 0, 0, 18260, 18258, 1, 0, 0, 0, 18260, 18261, 1, 0, 0, 0, 18261, 2093, 1, 0, 0, 0, 18262, 18260, 1, 0, 0, 0, 18263, 18279, 3, 2102, 1051, 0, 18264, 18266, 5, 1204, 0, 0, 18265, 18264, 1, 0, 0, 0, 18265, 18266, 1, 0, 0, 0, 18266, 18277, 1, 0, 0, 0, 18267, 18268, 5, 738, 0, 0, 18268, 18278, 3, 2098, 1049, 0, 18269, 18270, 5, 118, 0, 0, 18270, 18278, 3, 2100, 1050, 0, 18271, 18272, 7, 227, 0, 0, 18272, 18275, 3, 2102, 1051, 0, 18273, 18274, 5, 525, 0, 0, 18274, 18276, 3, 2102, 1051, 0, 18275, 18273, 1, 0, 0, 0, 18275, 18276, 1, 0, 0, 0, 18276, 18278, 1, 0, 0, 0, 18277, 18267, 1, 0, 0, 0, 18277, 18269, 1, 0, 0, 0, 18277, 18271, 1, 0, 0, 0, 18278, 18280, 1, 0, 0, 0, 18279, 18265, 1, 0, 0, 0, 18279, 18280, 1, 0, 0, 0, 18280, 2095, 1, 0, 0, 0, 18281, 18296, 5, 2472, 0, 0, 18282, 18290, 5, 2463, 0, 0, 18283, 18284, 5, 2468, 0, 0, 18284, 18290, 5, 2467, 0, 0, 18285, 18286, 5, 2466, 0, 0, 18286, 18290, 5, 2472, 0, 0, 18287, 18288, 5, 2464, 0, 0, 18288, 18290, 5, 2472, 0, 0, 18289, 18282, 1, 0, 0, 0, 18289, 18283, 1, 0, 0, 0, 18289, 18285, 1, 0, 0, 0, 18289, 18287, 1, 0, 0, 0, 18290, 18296, 1, 0, 0, 0, 18291, 18293, 7, 228, 0, 0, 18292, 18294, 5, 2472, 0, 0, 18293, 18292, 1, 0, 0, 0, 18293, 18294, 1, 0, 0, 0, 18294, 18296, 1, 0, 0, 0, 18295, 18281, 1, 0, 0, 0, 18295, 18289, 1, 0, 0, 0, 18295, 18291, 1, 0, 0, 0, 18296, 2097, 1, 0, 0, 0, 18297, 18298, 5, 2447, 0, 0, 18298, 18299, 3, 1896, 948, 0, 18299, 18300, 5, 2448, 0, 0, 18300, 18316, 1, 0, 0, 0, 18301, 18302, 5, 2447, 0, 0, 18302, 18307, 3, 2102, 1051, 0, 18303, 18304, 5, 2453, 0, 0, 18304, 18306, 3, 2102, 1051, 0, 18305, 18303, 1, 0, 0, 0, 18306, 18309, 1, 0, 0, 0, 18307, 18305, 1, 0, 0, 0, 18307, 18308, 1, 0, 0, 0, 18308, 18310, 1, 0, 0, 0, 18309, 18307, 1, 0, 0, 0, 18310, 18311, 5, 2448, 0, 0, 18311, 18316, 1, 0, 0, 0, 18312, 18316, 3, 2394, 1197, 0, 18313, 18316, 3, 2382, 1191, 0, 18314, 18316, 3, 2384, 1192, 0, 18315, 18297, 1, 0, 0, 0, 18315, 18301, 1, 0, 0, 0, 18315, 18312, 1, 0, 0, 0, 18315, 18313, 1, 0, 0, 0, 18315, 18314, 1, 0, 0, 0, 18316, 2099, 1, 0, 0, 0, 18317, 18318, 3, 2102, 1051, 0, 18318, 18319, 5, 49, 0, 0, 18319, 18320, 3, 2102, 1051, 0, 18320, 2101, 1, 0, 0, 0, 18321, 18322, 6, 1051, -1, 0, 18322, 18331, 3, 2106, 1053, 0, 18323, 18328, 5, 82, 0, 0, 18324, 18329, 5, 873, 0, 0, 18325, 18326, 5, 2112, 0, 0, 18326, 18327, 5, 2363, 0, 0, 18327, 18329, 3, 2102, 1051, 0, 18328, 18324, 1, 0, 0, 0, 18328, 18325, 1, 0, 0, 0, 18329, 18332, 1, 0, 0, 0, 18330, 18332, 3, 2104, 1052, 0, 18331, 18323, 1, 0, 0, 0, 18331, 18330, 1, 0, 0, 0, 18331, 18332, 1, 0, 0, 0, 18332, 18336, 1, 0, 0, 0, 18333, 18334, 5, 1259, 0, 0, 18334, 18335, 5, 1320, 0, 0, 18335, 18337, 7, 229, 0, 0, 18336, 18333, 1, 0, 0, 0, 18336, 18337, 1, 0, 0, 0, 18337, 18356, 1, 0, 0, 0, 18338, 18339, 10, 5, 0, 0, 18339, 18340, 5, 2449, 0, 0, 18340, 18355, 3, 2102, 1051, 6, 18341, 18342, 10, 4, 0, 0, 18342, 18343, 7, 230, 0, 0, 18343, 18355, 3, 2102, 1051, 5, 18344, 18345, 10, 3, 0, 0, 18345, 18346, 7, 142, 0, 0, 18346, 18355, 3, 2102, 1051, 4, 18347, 18348, 10, 2, 0, 0, 18348, 18349, 5, 2471, 0, 0, 18349, 18350, 5, 2471, 0, 0, 18350, 18355, 3, 2102, 1051, 3, 18351, 18352, 10, 1, 0, 0, 18352, 18353, 5, 2372, 0, 0, 18353, 18355, 3, 1672, 836, 0, 18354, 18338, 1, 0, 0, 0, 18354, 18341, 1, 0, 0, 0, 18354, 18344, 1, 0, 0, 0, 18354, 18347, 1, 0, 0, 0, 18354, 18351, 1, 0, 0, 0, 18355, 18358, 1, 0, 0, 0, 18356, 18354, 1, 0, 0, 0, 18356, 18357, 1, 0, 0, 0, 18357, 2103, 1, 0, 0, 0, 18358, 18356, 1, 0, 0, 0, 18359, 18364, 5, 365, 0, 0, 18360, 18361, 5, 2447, 0, 0, 18361, 18362, 3, 2102, 1051, 0, 18362, 18363, 5, 2448, 0, 0, 18363, 18365, 1, 0, 0, 0, 18364, 18360, 1, 0, 0, 0, 18364, 18365, 1, 0, 0, 0, 18365, 18366, 1, 0, 0, 0, 18366, 18367, 5, 2141, 0, 0, 18367, 18372, 5, 1636, 0, 0, 18368, 18369, 5, 2447, 0, 0, 18369, 18370, 3, 2102, 1051, 0, 18370, 18371, 5, 2448, 0, 0, 18371, 18373, 1, 0, 0, 0, 18372, 18368, 1, 0, 0, 0, 18372, 18373, 1, 0, 0, 0, 18373, 18384, 1, 0, 0, 0, 18374, 18379, 5, 2358, 0, 0, 18375, 18376, 5, 2447, 0, 0, 18376, 18377, 3, 2102, 1051, 0, 18377, 18378, 5, 2448, 0, 0, 18378, 18380, 1, 0, 0, 0, 18379, 18375, 1, 0, 0, 0, 18379, 18380, 1, 0, 0, 0, 18380, 18381, 1, 0, 0, 0, 18381, 18382, 5, 2141, 0, 0, 18382, 18384, 5, 985, 0, 0, 18383, 18359, 1, 0, 0, 0, 18383, 18374, 1, 0, 0, 0, 18384, 2105, 1, 0, 0, 0, 18385, 18387, 7, 142, 0, 0, 18386, 18385, 1, 0, 0, 0, 18386, 18387, 1, 0, 0, 0, 18387, 18388, 1, 0, 0, 0, 18388, 18393, 3, 2114, 1057, 0, 18389, 18390, 5, 2473, 0, 0, 18390, 18391, 3, 2108, 1054, 0, 18391, 18392, 5, 2474, 0, 0, 18392, 18394, 1, 0, 0, 0, 18393, 18389, 1, 0, 0, 0, 18393, 18394, 1, 0, 0, 0, 18394, 2107, 1, 0, 0, 0, 18395, 18398, 5, 55, 0, 0, 18396, 18398, 3, 2078, 1039, 0, 18397, 18395, 1, 0, 0, 0, 18397, 18396, 1, 0, 0, 0, 18398, 18406, 1, 0, 0, 0, 18399, 18402, 5, 2453, 0, 0, 18400, 18403, 5, 55, 0, 0, 18401, 18403, 3, 2078, 1039, 0, 18402, 18400, 1, 0, 0, 0, 18402, 18401, 1, 0, 0, 0, 18403, 18405, 1, 0, 0, 0, 18404, 18399, 1, 0, 0, 0, 18405, 18408, 1, 0, 0, 0, 18406, 18404, 1, 0, 0, 0, 18406, 18407, 1, 0, 0, 0, 18407, 18419, 1, 0, 0, 0, 18408, 18406, 1, 0, 0, 0, 18409, 18414, 3, 2110, 1055, 0, 18410, 18411, 5, 2453, 0, 0, 18411, 18413, 3, 2110, 1055, 0, 18412, 18410, 1, 0, 0, 0, 18413, 18416, 1, 0, 0, 0, 18414, 18412, 1, 0, 0, 0, 18414, 18415, 1, 0, 0, 0, 18415, 18419, 1, 0, 0, 0, 18416, 18414, 1, 0, 0, 0, 18417, 18419, 3, 2112, 1056, 0, 18418, 18397, 1, 0, 0, 0, 18418, 18409, 1, 0, 0, 0, 18418, 18417, 1, 0, 0, 0, 18419, 2109, 1, 0, 0, 0, 18420, 18421, 5, 620, 0, 0, 18421, 18439, 3, 2340, 1170, 0, 18422, 18423, 5, 738, 0, 0, 18423, 18425, 5, 2447, 0, 0, 18424, 18426, 3, 2076, 1038, 0, 18425, 18424, 1, 0, 0, 0, 18425, 18426, 1, 0, 0, 0, 18426, 18427, 1, 0, 0, 0, 18427, 18440, 5, 2448, 0, 0, 18428, 18429, 5, 857, 0, 0, 18429, 18431, 3, 2078, 1039, 0, 18430, 18428, 1, 0, 0, 0, 18430, 18431, 1, 0, 0, 0, 18431, 18432, 1, 0, 0, 0, 18432, 18433, 5, 628, 0, 0, 18433, 18434, 3, 2078, 1039, 0, 18434, 18435, 5, 2141, 0, 0, 18435, 18436, 3, 2078, 1039, 0, 18436, 18437, 7, 231, 0, 0, 18437, 18438, 3, 2078, 1039, 0, 18438, 18440, 1, 0, 0, 0, 18439, 18422, 1, 0, 0, 0, 18439, 18430, 1, 0, 0, 0, 18440, 2111, 1, 0, 0, 0, 18441, 18442, 5, 620, 0, 0, 18442, 18443, 3, 2360, 1180, 0, 18443, 18444, 5, 738, 0, 0, 18444, 18451, 5, 2447, 0, 0, 18445, 18452, 3, 1896, 948, 0, 18446, 18448, 5, 2447, 0, 0, 18447, 18449, 3, 2076, 1038, 0, 18448, 18447, 1, 0, 0, 0, 18448, 18449, 1, 0, 0, 0, 18449, 18450, 1, 0, 0, 0, 18450, 18452, 5, 2448, 0, 0, 18451, 18445, 1, 0, 0, 0, 18451, 18446, 1, 0, 0, 0, 18452, 18453, 1, 0, 0, 0, 18453, 18454, 5, 2448, 0, 0, 18454, 2113, 1, 0, 0, 0, 18455, 18456, 5, 1454, 0, 0, 18456, 18476, 3, 2116, 1058, 0, 18457, 18458, 5, 279, 0, 0, 18458, 18476, 3, 2116, 1058, 0, 18459, 18460, 5, 1021, 0, 0, 18460, 18476, 3, 2116, 1058, 0, 18461, 18462, 5, 1250, 0, 0, 18462, 18476, 3, 2116, 1058, 0, 18463, 18473, 3, 2116, 1058, 0, 18464, 18471, 5, 2440, 0, 0, 18465, 18472, 7, 232, 0, 0, 18466, 18467, 7, 233, 0, 0, 18467, 18468, 5, 2447, 0, 0, 18468, 18469, 3, 2078, 1039, 0, 18469, 18470, 5, 2448, 0, 0, 18470, 18472, 1, 0, 0, 0, 18471, 18465, 1, 0, 0, 0, 18471, 18466, 1, 0, 0, 0, 18472, 18474, 1, 0, 0, 0, 18473, 18464, 1, 0, 0, 0, 18473, 18474, 1, 0, 0, 0, 18474, 18476, 1, 0, 0, 0, 18475, 18455, 1, 0, 0, 0, 18475, 18457, 1, 0, 0, 0, 18475, 18459, 1, 0, 0, 0, 18475, 18461, 1, 0, 0, 0, 18475, 18463, 1, 0, 0, 0, 18476, 2115, 1, 0, 0, 0, 18477, 18484, 3, 2132, 1066, 0, 18478, 18484, 3, 2144, 1072, 0, 18479, 18484, 3, 2148, 1074, 0, 18480, 18481, 4, 1058, 23, 0, 18481, 18484, 3, 2142, 1071, 0, 18482, 18484, 3, 2118, 1059, 0, 18483, 18477, 1, 0, 0, 0, 18483, 18478, 1, 0, 0, 0, 18483, 18479, 1, 0, 0, 0, 18483, 18480, 1, 0, 0, 0, 18483, 18482, 1, 0, 0, 0, 18484, 2117, 1, 0, 0, 0, 18485, 18502, 5, 1722, 0, 0, 18486, 18487, 5, 1384, 0, 0, 18487, 18488, 5, 2447, 0, 0, 18488, 18489, 3, 2078, 1039, 0, 18489, 18490, 5, 2448, 0, 0, 18490, 18503, 1, 0, 0, 0, 18491, 18500, 5, 1383, 0, 0, 18492, 18493, 5, 2440, 0, 0, 18493, 18501, 5, 313, 0, 0, 18494, 18495, 5, 2447, 0, 0, 18495, 18496, 3, 2078, 1039, 0, 18496, 18497, 5, 2448, 0, 0, 18497, 18498, 5, 2440, 0, 0, 18498, 18499, 7, 234, 0, 0, 18499, 18501, 1, 0, 0, 0, 18500, 18492, 1, 0, 0, 0, 18500, 18494, 1, 0, 0, 0, 18501, 18503, 1, 0, 0, 0, 18502, 18486, 1, 0, 0, 0, 18502, 18491, 1, 0, 0, 0, 18503, 2119, 1, 0, 0, 0, 18504, 18505, 3, 1082, 541, 0, 18505, 18506, 5, 2447, 0, 0, 18506, 18507, 3, 2078, 1039, 0, 18507, 18512, 5, 2448, 0, 0, 18508, 18509, 5, 2440, 0, 0, 18509, 18511, 3, 2386, 1193, 0, 18510, 18508, 1, 0, 0, 0, 18511, 18514, 1, 0, 0, 0, 18512, 18510, 1, 0, 0, 0, 18512, 18513, 1, 0, 0, 0, 18513, 2121, 1, 0, 0, 0, 18514, 18512, 1, 0, 0, 0, 18515, 18518, 3, 2126, 1063, 0, 18516, 18518, 3, 2124, 1062, 0, 18517, 18515, 1, 0, 0, 0, 18517, 18516, 1, 0, 0, 0, 18518, 2123, 1, 0, 0, 0, 18519, 18521, 3, 1772, 886, 0, 18520, 18519, 1, 0, 0, 0, 18520, 18521, 1, 0, 0, 0, 18521, 18522, 1, 0, 0, 0, 18522, 18523, 5, 180, 0, 0, 18523, 18525, 3, 2078, 1039, 0, 18524, 18526, 3, 2128, 1064, 0, 18525, 18524, 1, 0, 0, 0, 18526, 18527, 1, 0, 0, 0, 18527, 18525, 1, 0, 0, 0, 18527, 18528, 1, 0, 0, 0, 18528, 18530, 1, 0, 0, 0, 18529, 18531, 3, 2130, 1065, 0, 18530, 18529, 1, 0, 0, 0, 18530, 18531, 1, 0, 0, 0, 18531, 18532, 1, 0, 0, 0, 18532, 18534, 5, 508, 0, 0, 18533, 18535, 5, 180, 0, 0, 18534, 18533, 1, 0, 0, 0, 18534, 18535, 1, 0, 0, 0, 18535, 18537, 1, 0, 0, 0, 18536, 18538, 3, 2312, 1156, 0, 18537, 18536, 1, 0, 0, 0, 18537, 18538, 1, 0, 0, 0, 18538, 2125, 1, 0, 0, 0, 18539, 18541, 3, 1772, 886, 0, 18540, 18539, 1, 0, 0, 0, 18540, 18541, 1, 0, 0, 0, 18541, 18542, 1, 0, 0, 0, 18542, 18544, 5, 180, 0, 0, 18543, 18545, 3, 2128, 1064, 0, 18544, 18543, 1, 0, 0, 0, 18545, 18546, 1, 0, 0, 0, 18546, 18544, 1, 0, 0, 0, 18546, 18547, 1, 0, 0, 0, 18547, 18549, 1, 0, 0, 0, 18548, 18550, 3, 2130, 1065, 0, 18549, 18548, 1, 0, 0, 0, 18549, 18550, 1, 0, 0, 0, 18550, 18551, 1, 0, 0, 0, 18551, 18553, 5, 508, 0, 0, 18552, 18554, 5, 180, 0, 0, 18553, 18552, 1, 0, 0, 0, 18553, 18554, 1, 0, 0, 0, 18554, 18556, 1, 0, 0, 0, 18555, 18557, 3, 2312, 1156, 0, 18556, 18555, 1, 0, 0, 0, 18556, 18557, 1, 0, 0, 0, 18557, 2127, 1, 0, 0, 0, 18558, 18559, 5, 2300, 0, 0, 18559, 18560, 3, 2078, 1039, 0, 18560, 18561, 5, 2099, 0, 0, 18561, 18562, 3, 1770, 885, 0, 18562, 2129, 1, 0, 0, 0, 18563, 18564, 5, 491, 0, 0, 18564, 18565, 3, 1770, 885, 0, 18565, 2131, 1, 0, 0, 0, 18566, 18569, 3, 2136, 1068, 0, 18567, 18569, 3, 2134, 1067, 0, 18568, 18566, 1, 0, 0, 0, 18568, 18567, 1, 0, 0, 0, 18569, 2133, 1, 0, 0, 0, 18570, 18571, 5, 180, 0, 0, 18571, 18573, 3, 2078, 1039, 0, 18572, 18574, 3, 2138, 1069, 0, 18573, 18572, 1, 0, 0, 0, 18574, 18575, 1, 0, 0, 0, 18575, 18573, 1, 0, 0, 0, 18575, 18576, 1, 0, 0, 0, 18576, 18578, 1, 0, 0, 0, 18577, 18579, 3, 2140, 1070, 0, 18578, 18577, 1, 0, 0, 0, 18578, 18579, 1, 0, 0, 0, 18579, 18580, 1, 0, 0, 0, 18580, 18582, 5, 508, 0, 0, 18581, 18583, 5, 180, 0, 0, 18582, 18581, 1, 0, 0, 0, 18582, 18583, 1, 0, 0, 0, 18583, 2135, 1, 0, 0, 0, 18584, 18586, 5, 180, 0, 0, 18585, 18587, 3, 2138, 1069, 0, 18586, 18585, 1, 0, 0, 0, 18587, 18588, 1, 0, 0, 0, 18588, 18586, 1, 0, 0, 0, 18588, 18589, 1, 0, 0, 0, 18589, 18591, 1, 0, 0, 0, 18590, 18592, 3, 2140, 1070, 0, 18591, 18590, 1, 0, 0, 0, 18591, 18592, 1, 0, 0, 0, 18592, 18593, 1, 0, 0, 0, 18593, 18595, 5, 508, 0, 0, 18594, 18596, 5, 180, 0, 0, 18595, 18594, 1, 0, 0, 0, 18595, 18596, 1, 0, 0, 0, 18596, 2137, 1, 0, 0, 0, 18597, 18598, 5, 2300, 0, 0, 18598, 18599, 3, 2078, 1039, 0, 18599, 18600, 5, 2099, 0, 0, 18600, 18601, 3, 2078, 1039, 0, 18601, 2139, 1, 0, 0, 0, 18602, 18603, 5, 491, 0, 0, 18603, 18604, 3, 2078, 1039, 0, 18604, 2141, 1, 0, 0, 0, 18605, 18626, 3, 2382, 1191, 0, 18606, 18626, 3, 2394, 1197, 0, 18607, 18626, 3, 2406, 1203, 0, 18608, 18610, 3, 2384, 1192, 0, 18609, 18611, 3, 2408, 1204, 0, 18610, 18609, 1, 0, 0, 0, 18610, 18611, 1, 0, 0, 0, 18611, 18626, 1, 0, 0, 0, 18612, 18613, 5, 2447, 0, 0, 18613, 18614, 3, 1896, 948, 0, 18614, 18618, 5, 2448, 0, 0, 18615, 18617, 3, 1900, 950, 0, 18616, 18615, 1, 0, 0, 0, 18617, 18620, 1, 0, 0, 0, 18618, 18616, 1, 0, 0, 0, 18618, 18619, 1, 0, 0, 0, 18619, 18626, 1, 0, 0, 0, 18620, 18618, 1, 0, 0, 0, 18621, 18622, 5, 2447, 0, 0, 18622, 18623, 3, 2076, 1038, 0, 18623, 18624, 5, 2448, 0, 0, 18624, 18626, 1, 0, 0, 0, 18625, 18605, 1, 0, 0, 0, 18625, 18606, 1, 0, 0, 0, 18625, 18607, 1, 0, 0, 0, 18625, 18608, 1, 0, 0, 0, 18625, 18612, 1, 0, 0, 0, 18625, 18621, 1, 0, 0, 0, 18626, 2143, 1, 0, 0, 0, 18627, 18643, 7, 235, 0, 0, 18628, 18629, 5, 2447, 0, 0, 18629, 18630, 3, 1868, 934, 0, 18630, 18631, 5, 2448, 0, 0, 18631, 18644, 1, 0, 0, 0, 18632, 18633, 5, 2447, 0, 0, 18633, 18638, 3, 2078, 1039, 0, 18634, 18635, 5, 2453, 0, 0, 18635, 18637, 3, 2078, 1039, 0, 18636, 18634, 1, 0, 0, 0, 18637, 18640, 1, 0, 0, 0, 18638, 18636, 1, 0, 0, 0, 18638, 18639, 1, 0, 0, 0, 18639, 18641, 1, 0, 0, 0, 18640, 18638, 1, 0, 0, 0, 18641, 18642, 5, 2448, 0, 0, 18642, 18644, 1, 0, 0, 0, 18643, 18628, 1, 0, 0, 0, 18643, 18632, 1, 0, 0, 0, 18644, 2145, 1, 0, 0, 0, 18645, 18646, 5, 2416, 0, 0, 18646, 18647, 5, 2447, 0, 0, 18647, 18648, 3, 2078, 1039, 0, 18648, 18649, 5, 2453, 0, 0, 18649, 18652, 3, 2078, 1039, 0, 18650, 18651, 5, 2453, 0, 0, 18651, 18653, 3, 2078, 1039, 0, 18652, 18650, 1, 0, 0, 0, 18652, 18653, 1, 0, 0, 0, 18653, 18654, 1, 0, 0, 0, 18654, 18655, 5, 2448, 0, 0, 18655, 18732, 1, 0, 0, 0, 18656, 18657, 5, 2417, 0, 0, 18657, 18661, 5, 2447, 0, 0, 18658, 18662, 3, 2388, 1194, 0, 18659, 18662, 3, 2148, 1074, 0, 18660, 18662, 3, 2078, 1039, 0, 18661, 18658, 1, 0, 0, 0, 18661, 18659, 1, 0, 0, 0, 18661, 18660, 1, 0, 0, 0, 18662, 18665, 1, 0, 0, 0, 18663, 18664, 5, 2453, 0, 0, 18664, 18666, 3, 2400, 1200, 0, 18665, 18663, 1, 0, 0, 0, 18665, 18666, 1, 0, 0, 0, 18666, 18669, 1, 0, 0, 0, 18667, 18668, 5, 2453, 0, 0, 18668, 18670, 3, 2400, 1200, 0, 18669, 18667, 1, 0, 0, 0, 18669, 18670, 1, 0, 0, 0, 18670, 18671, 1, 0, 0, 0, 18671, 18672, 5, 2448, 0, 0, 18672, 18732, 1, 0, 0, 0, 18673, 18674, 5, 2401, 0, 0, 18674, 18675, 5, 2447, 0, 0, 18675, 18676, 3, 2076, 1038, 0, 18676, 18677, 5, 2448, 0, 0, 18677, 18732, 1, 0, 0, 0, 18678, 18679, 5, 204, 0, 0, 18679, 18680, 5, 2447, 0, 0, 18680, 18681, 3, 2102, 1051, 0, 18681, 18682, 5, 2246, 0, 0, 18682, 18683, 5, 1007, 0, 0, 18683, 18684, 5, 2448, 0, 0, 18684, 18732, 1, 0, 0, 0, 18685, 18686, 5, 2411, 0, 0, 18686, 18687, 5, 2447, 0, 0, 18687, 18688, 3, 2078, 1039, 0, 18688, 18689, 5, 2453, 0, 0, 18689, 18690, 3, 2078, 1039, 0, 18690, 18691, 5, 2448, 0, 0, 18691, 18732, 1, 0, 0, 0, 18692, 18693, 5, 2418, 0, 0, 18693, 18701, 5, 2447, 0, 0, 18694, 18696, 7, 236, 0, 0, 18695, 18694, 1, 0, 0, 0, 18695, 18696, 1, 0, 0, 0, 18696, 18698, 1, 0, 0, 0, 18697, 18699, 3, 2078, 1039, 0, 18698, 18697, 1, 0, 0, 0, 18698, 18699, 1, 0, 0, 0, 18699, 18700, 1, 0, 0, 0, 18700, 18702, 5, 628, 0, 0, 18701, 18695, 1, 0, 0, 0, 18701, 18702, 1, 0, 0, 0, 18702, 18703, 1, 0, 0, 0, 18703, 18704, 3, 2102, 1051, 0, 18704, 18705, 5, 2448, 0, 0, 18705, 18732, 1, 0, 0, 0, 18706, 18707, 5, 2425, 0, 0, 18707, 18711, 5, 2447, 0, 0, 18708, 18712, 3, 2388, 1194, 0, 18709, 18712, 3, 2148, 1074, 0, 18710, 18712, 3, 2078, 1039, 0, 18711, 18708, 1, 0, 0, 0, 18711, 18709, 1, 0, 0, 0, 18711, 18710, 1, 0, 0, 0, 18712, 18719, 1, 0, 0, 0, 18713, 18714, 5, 389, 0, 0, 18714, 18715, 3, 2102, 1051, 0, 18715, 18716, 5, 1259, 0, 0, 18716, 18717, 5, 301, 0, 0, 18717, 18718, 5, 520, 0, 0, 18718, 18720, 1, 0, 0, 0, 18719, 18713, 1, 0, 0, 0, 18719, 18720, 1, 0, 0, 0, 18720, 18727, 1, 0, 0, 0, 18721, 18722, 5, 2453, 0, 0, 18722, 18725, 3, 2400, 1200, 0, 18723, 18724, 5, 2453, 0, 0, 18724, 18726, 3, 2400, 1200, 0, 18725, 18723, 1, 0, 0, 0, 18725, 18726, 1, 0, 0, 0, 18726, 18728, 1, 0, 0, 0, 18727, 18721, 1, 0, 0, 0, 18727, 18728, 1, 0, 0, 0, 18728, 18729, 1, 0, 0, 0, 18729, 18730, 5, 2448, 0, 0, 18730, 18732, 1, 0, 0, 0, 18731, 18645, 1, 0, 0, 0, 18731, 18656, 1, 0, 0, 0, 18731, 18673, 1, 0, 0, 0, 18731, 18678, 1, 0, 0, 0, 18731, 18685, 1, 0, 0, 0, 18731, 18692, 1, 0, 0, 0, 18731, 18706, 1, 0, 0, 0, 18732, 2147, 1, 0, 0, 0, 18733, 18739, 3, 2146, 1073, 0, 18734, 18739, 3, 2188, 1094, 0, 18735, 18739, 3, 2150, 1075, 0, 18736, 18737, 4, 1074, 24, 0, 18737, 18739, 3, 2194, 1097, 0, 18738, 18733, 1, 0, 0, 0, 18738, 18734, 1, 0, 0, 0, 18738, 18735, 1, 0, 0, 0, 18738, 18736, 1, 0, 0, 0, 18739, 2149, 1, 0, 0, 0, 18740, 18741, 5, 796, 0, 0, 18741, 18742, 5, 2447, 0, 0, 18742, 18747, 3, 2158, 1079, 0, 18743, 18744, 5, 2453, 0, 0, 18744, 18746, 3, 2158, 1079, 0, 18745, 18743, 1, 0, 0, 0, 18746, 18749, 1, 0, 0, 0, 18747, 18745, 1, 0, 0, 0, 18747, 18748, 1, 0, 0, 0, 18748, 18751, 1, 0, 0, 0, 18749, 18747, 1, 0, 0, 0, 18750, 18752, 3, 2160, 1080, 0, 18751, 18750, 1, 0, 0, 0, 18751, 18752, 1, 0, 0, 0, 18752, 18754, 1, 0, 0, 0, 18753, 18755, 3, 2162, 1081, 0, 18754, 18753, 1, 0, 0, 0, 18754, 18755, 1, 0, 0, 0, 18755, 18757, 1, 0, 0, 0, 18756, 18758, 5, 1766, 0, 0, 18757, 18756, 1, 0, 0, 0, 18757, 18758, 1, 0, 0, 0, 18758, 18759, 1, 0, 0, 0, 18759, 18760, 5, 2448, 0, 0, 18760, 18929, 1, 0, 0, 0, 18761, 18762, 5, 795, 0, 0, 18762, 18763, 5, 2447, 0, 0, 18763, 18766, 3, 2078, 1039, 0, 18764, 18765, 5, 621, 0, 0, 18765, 18767, 5, 801, 0, 0, 18766, 18764, 1, 0, 0, 0, 18766, 18767, 1, 0, 0, 0, 18767, 18769, 1, 0, 0, 0, 18768, 18770, 3, 1994, 997, 0, 18769, 18768, 1, 0, 0, 0, 18769, 18770, 1, 0, 0, 0, 18770, 18772, 1, 0, 0, 0, 18771, 18773, 3, 2160, 1080, 0, 18772, 18771, 1, 0, 0, 0, 18772, 18773, 1, 0, 0, 0, 18773, 18775, 1, 0, 0, 0, 18774, 18776, 3, 2162, 1081, 0, 18775, 18774, 1, 0, 0, 0, 18775, 18776, 1, 0, 0, 0, 18776, 18778, 1, 0, 0, 0, 18777, 18779, 5, 1766, 0, 0, 18778, 18777, 1, 0, 0, 0, 18778, 18779, 1, 0, 0, 0, 18779, 18780, 1, 0, 0, 0, 18780, 18781, 5, 2448, 0, 0, 18781, 18929, 1, 0, 0, 0, 18782, 18783, 5, 803, 0, 0, 18783, 18784, 5, 2447, 0, 0, 18784, 18785, 3, 2152, 1076, 0, 18785, 18786, 5, 2448, 0, 0, 18786, 18929, 1, 0, 0, 0, 18787, 18788, 5, 802, 0, 0, 18788, 18790, 5, 2447, 0, 0, 18789, 18791, 5, 816, 0, 0, 18790, 18789, 1, 0, 0, 0, 18790, 18791, 1, 0, 0, 0, 18791, 18792, 1, 0, 0, 0, 18792, 18793, 3, 2078, 1039, 0, 18793, 18794, 5, 2258, 0, 0, 18794, 18798, 3, 2078, 1039, 0, 18795, 18796, 7, 237, 0, 0, 18796, 18797, 5, 1259, 0, 0, 18797, 18799, 5, 1228, 0, 0, 18798, 18795, 1, 0, 0, 0, 18798, 18799, 1, 0, 0, 0, 18799, 18814, 1, 0, 0, 0, 18800, 18812, 5, 1585, 0, 0, 18801, 18808, 5, 2259, 0, 0, 18802, 18803, 5, 2447, 0, 0, 18803, 18805, 5, 2441, 0, 0, 18804, 18806, 7, 238, 0, 0, 18805, 18804, 1, 0, 0, 0, 18805, 18806, 1, 0, 0, 0, 18806, 18807, 1, 0, 0, 0, 18807, 18809, 5, 2448, 0, 0, 18808, 18802, 1, 0, 0, 0, 18808, 18809, 1, 0, 0, 0, 18809, 18813, 1, 0, 0, 0, 18810, 18813, 5, 215, 0, 0, 18811, 18813, 5, 142, 0, 0, 18812, 18801, 1, 0, 0, 0, 18812, 18810, 1, 0, 0, 0, 18812, 18811, 1, 0, 0, 0, 18813, 18815, 1, 0, 0, 0, 18814, 18800, 1, 0, 0, 0, 18814, 18815, 1, 0, 0, 0, 18815, 18817, 1, 0, 0, 0, 18816, 18818, 5, 1766, 0, 0, 18817, 18816, 1, 0, 0, 0, 18817, 18818, 1, 0, 0, 0, 18818, 18822, 1, 0, 0, 0, 18819, 18820, 5, 2308, 0, 0, 18820, 18821, 5, 2183, 0, 0, 18821, 18823, 5, 819, 0, 0, 18822, 18819, 1, 0, 0, 0, 18822, 18823, 1, 0, 0, 0, 18823, 18824, 1, 0, 0, 0, 18824, 18825, 5, 2448, 0, 0, 18825, 18929, 1, 0, 0, 0, 18826, 18827, 5, 805, 0, 0, 18827, 18828, 5, 2447, 0, 0, 18828, 18831, 3, 2078, 1039, 0, 18829, 18830, 5, 621, 0, 0, 18830, 18832, 5, 801, 0, 0, 18831, 18829, 1, 0, 0, 0, 18831, 18832, 1, 0, 0, 0, 18832, 18833, 1, 0, 0, 0, 18833, 18834, 5, 2453, 0, 0, 18834, 18835, 5, 2443, 0, 0, 18835, 18837, 3, 2170, 1085, 0, 18836, 18838, 3, 2174, 1087, 0, 18837, 18836, 1, 0, 0, 0, 18837, 18838, 1, 0, 0, 0, 18838, 18840, 1, 0, 0, 0, 18839, 18841, 3, 2176, 1088, 0, 18840, 18839, 1, 0, 0, 0, 18840, 18841, 1, 0, 0, 0, 18841, 18843, 1, 0, 0, 0, 18842, 18844, 3, 2178, 1089, 0, 18843, 18842, 1, 0, 0, 0, 18843, 18844, 1, 0, 0, 0, 18844, 18845, 1, 0, 0, 0, 18845, 18846, 5, 2448, 0, 0, 18846, 18929, 1, 0, 0, 0, 18847, 18848, 5, 806, 0, 0, 18848, 18849, 5, 2447, 0, 0, 18849, 18852, 5, 2443, 0, 0, 18850, 18851, 5, 1585, 0, 0, 18851, 18853, 3, 2172, 1086, 0, 18852, 18850, 1, 0, 0, 0, 18852, 18853, 1, 0, 0, 0, 18853, 18855, 1, 0, 0, 0, 18854, 18856, 5, 1448, 0, 0, 18855, 18854, 1, 0, 0, 0, 18855, 18856, 1, 0, 0, 0, 18856, 18858, 1, 0, 0, 0, 18857, 18859, 5, 71, 0, 0, 18858, 18857, 1, 0, 0, 0, 18858, 18859, 1, 0, 0, 0, 18859, 18861, 1, 0, 0, 0, 18860, 18862, 5, 2159, 0, 0, 18861, 18860, 1, 0, 0, 0, 18861, 18862, 1, 0, 0, 0, 18862, 18871, 1, 0, 0, 0, 18863, 18868, 5, 1228, 0, 0, 18864, 18868, 5, 520, 0, 0, 18865, 18866, 5, 497, 0, 0, 18866, 18868, 7, 239, 0, 0, 18867, 18863, 1, 0, 0, 0, 18867, 18864, 1, 0, 0, 0, 18867, 18865, 1, 0, 0, 0, 18868, 18869, 1, 0, 0, 0, 18869, 18870, 5, 1259, 0, 0, 18870, 18872, 5, 520, 0, 0, 18871, 18867, 1, 0, 0, 0, 18871, 18872, 1, 0, 0, 0, 18872, 18873, 1, 0, 0, 0, 18873, 18929, 5, 2448, 0, 0, 18874, 18875, 5, 810, 0, 0, 18875, 18876, 5, 2447, 0, 0, 18876, 18877, 3, 2078, 1039, 0, 18877, 18878, 5, 2453, 0, 0, 18878, 18883, 3, 2164, 1082, 0, 18879, 18880, 5, 2453, 0, 0, 18880, 18882, 3, 2164, 1082, 0, 18881, 18879, 1, 0, 0, 0, 18882, 18885, 1, 0, 0, 0, 18883, 18881, 1, 0, 0, 0, 18883, 18884, 1, 0, 0, 0, 18884, 18886, 1, 0, 0, 0, 18885, 18883, 1, 0, 0, 0, 18886, 18887, 5, 2448, 0, 0, 18887, 18929, 1, 0, 0, 0, 18888, 18889, 5, 811, 0, 0, 18889, 18890, 5, 2447, 0, 0, 18890, 18893, 3, 2078, 1039, 0, 18891, 18892, 5, 621, 0, 0, 18892, 18894, 5, 801, 0, 0, 18893, 18891, 1, 0, 0, 0, 18893, 18894, 1, 0, 0, 0, 18894, 18926, 1, 0, 0, 0, 18895, 18897, 5, 2453, 0, 0, 18896, 18898, 5, 2443, 0, 0, 18897, 18896, 1, 0, 0, 0, 18897, 18898, 1, 0, 0, 0, 18898, 18900, 1, 0, 0, 0, 18899, 18901, 3, 2180, 1090, 0, 18900, 18899, 1, 0, 0, 0, 18900, 18901, 1, 0, 0, 0, 18901, 18910, 1, 0, 0, 0, 18902, 18907, 5, 520, 0, 0, 18903, 18907, 5, 1228, 0, 0, 18904, 18905, 5, 389, 0, 0, 18905, 18907, 3, 2186, 1093, 0, 18906, 18902, 1, 0, 0, 0, 18906, 18903, 1, 0, 0, 0, 18906, 18904, 1, 0, 0, 0, 18906, 18907, 1, 0, 0, 0, 18907, 18908, 1, 0, 0, 0, 18908, 18909, 5, 1259, 0, 0, 18909, 18911, 5, 520, 0, 0, 18910, 18906, 1, 0, 0, 0, 18910, 18911, 1, 0, 0, 0, 18911, 18920, 1, 0, 0, 0, 18912, 18917, 5, 520, 0, 0, 18913, 18917, 5, 1228, 0, 0, 18914, 18915, 5, 389, 0, 0, 18915, 18917, 3, 2186, 1093, 0, 18916, 18912, 1, 0, 0, 0, 18916, 18913, 1, 0, 0, 0, 18916, 18914, 1, 0, 0, 0, 18916, 18917, 1, 0, 0, 0, 18917, 18918, 1, 0, 0, 0, 18918, 18919, 5, 1259, 0, 0, 18919, 18921, 5, 497, 0, 0, 18920, 18916, 1, 0, 0, 0, 18920, 18921, 1, 0, 0, 0, 18921, 18923, 1, 0, 0, 0, 18922, 18924, 3, 2184, 1092, 0, 18923, 18922, 1, 0, 0, 0, 18923, 18924, 1, 0, 0, 0, 18924, 18925, 1, 0, 0, 0, 18925, 18927, 5, 2448, 0, 0, 18926, 18895, 1, 0, 0, 0, 18926, 18927, 1, 0, 0, 0, 18927, 18929, 1, 0, 0, 0, 18928, 18740, 1, 0, 0, 0, 18928, 18761, 1, 0, 0, 0, 18928, 18782, 1, 0, 0, 0, 18928, 18787, 1, 0, 0, 0, 18928, 18826, 1, 0, 0, 0, 18928, 18847, 1, 0, 0, 0, 18928, 18874, 1, 0, 0, 0, 18928, 18888, 1, 0, 0, 0, 18929, 2151, 1, 0, 0, 0, 18930, 18935, 3, 2154, 1077, 0, 18931, 18932, 5, 2453, 0, 0, 18932, 18934, 3, 2154, 1077, 0, 18933, 18931, 1, 0, 0, 0, 18934, 18937, 1, 0, 0, 0, 18935, 18933, 1, 0, 0, 0, 18935, 18936, 1, 0, 0, 0, 18936, 18940, 1, 0, 0, 0, 18937, 18935, 1, 0, 0, 0, 18938, 18940, 5, 2450, 0, 0, 18939, 18930, 1, 0, 0, 0, 18939, 18938, 1, 0, 0, 0, 18940, 18942, 1, 0, 0, 0, 18941, 18943, 3, 2160, 1080, 0, 18942, 18941, 1, 0, 0, 0, 18942, 18943, 1, 0, 0, 0, 18943, 18945, 1, 0, 0, 0, 18944, 18946, 3, 2162, 1081, 0, 18945, 18944, 1, 0, 0, 0, 18945, 18946, 1, 0, 0, 0, 18946, 18948, 1, 0, 0, 0, 18947, 18949, 5, 1766, 0, 0, 18948, 18947, 1, 0, 0, 0, 18948, 18949, 1, 0, 0, 0, 18949, 18953, 1, 0, 0, 0, 18950, 18951, 5, 2308, 0, 0, 18951, 18952, 5, 2183, 0, 0, 18952, 18954, 5, 819, 0, 0, 18953, 18950, 1, 0, 0, 0, 18953, 18954, 1, 0, 0, 0, 18954, 2153, 1, 0, 0, 0, 18955, 18957, 5, 816, 0, 0, 18956, 18955, 1, 0, 0, 0, 18956, 18957, 1, 0, 0, 0, 18957, 18958, 1, 0, 0, 0, 18958, 18960, 3, 2078, 1039, 0, 18959, 18961, 7, 240, 0, 0, 18960, 18959, 1, 0, 0, 0, 18960, 18961, 1, 0, 0, 0, 18961, 18962, 1, 0, 0, 0, 18962, 18963, 3, 2078, 1039, 0, 18963, 18970, 1, 0, 0, 0, 18964, 18965, 3, 2078, 1039, 0, 18965, 18966, 5, 2469, 0, 0, 18966, 18967, 3, 2078, 1039, 0, 18967, 18970, 1, 0, 0, 0, 18968, 18970, 3, 2402, 1201, 0, 18969, 18956, 1, 0, 0, 0, 18969, 18964, 1, 0, 0, 0, 18969, 18968, 1, 0, 0, 0, 18970, 18973, 1, 0, 0, 0, 18971, 18972, 5, 621, 0, 0, 18972, 18974, 5, 801, 0, 0, 18973, 18971, 1, 0, 0, 0, 18973, 18974, 1, 0, 0, 0, 18974, 2155, 1, 0, 0, 0, 18975, 18976, 5, 807, 0, 0, 18976, 18977, 5, 2447, 0, 0, 18977, 18980, 3, 2078, 1039, 0, 18978, 18979, 5, 621, 0, 0, 18979, 18981, 5, 801, 0, 0, 18980, 18978, 1, 0, 0, 0, 18980, 18981, 1, 0, 0, 0, 18981, 18984, 1, 0, 0, 0, 18982, 18983, 5, 2453, 0, 0, 18983, 18985, 5, 2443, 0, 0, 18984, 18982, 1, 0, 0, 0, 18984, 18985, 1, 0, 0, 0, 18985, 18989, 1, 0, 0, 0, 18986, 18987, 7, 241, 0, 0, 18987, 18988, 5, 1259, 0, 0, 18988, 18990, 5, 520, 0, 0, 18989, 18986, 1, 0, 0, 0, 18989, 18990, 1, 0, 0, 0, 18990, 18994, 1, 0, 0, 0, 18991, 18992, 7, 242, 0, 0, 18992, 18993, 5, 1259, 0, 0, 18993, 18995, 5, 497, 0, 0, 18994, 18991, 1, 0, 0, 0, 18994, 18995, 1, 0, 0, 0, 18995, 18997, 1, 0, 0, 0, 18996, 18998, 3, 2166, 1083, 0, 18997, 18996, 1, 0, 0, 0, 18997, 18998, 1, 0, 0, 0, 18998, 18999, 1, 0, 0, 0, 18999, 19000, 5, 2448, 0, 0, 19000, 2157, 1, 0, 0, 0, 19001, 19007, 3, 2078, 1039, 0, 19002, 19007, 5, 2443, 0, 0, 19003, 19007, 5, 1228, 0, 0, 19004, 19007, 5, 2441, 0, 0, 19005, 19007, 3, 2150, 1075, 0, 19006, 19001, 1, 0, 0, 0, 19006, 19002, 1, 0, 0, 0, 19006, 19003, 1, 0, 0, 0, 19006, 19004, 1, 0, 0, 0, 19006, 19005, 1, 0, 0, 0, 19007, 19010, 1, 0, 0, 0, 19008, 19009, 5, 621, 0, 0, 19009, 19011, 5, 801, 0, 0, 19010, 19008, 1, 0, 0, 0, 19010, 19011, 1, 0, 0, 0, 19011, 2159, 1, 0, 0, 0, 19012, 19013, 7, 237, 0, 0, 19013, 19014, 5, 1259, 0, 0, 19014, 19015, 5, 1228, 0, 0, 19015, 2161, 1, 0, 0, 0, 19016, 19028, 5, 1585, 0, 0, 19017, 19024, 5, 2259, 0, 0, 19018, 19019, 5, 2447, 0, 0, 19019, 19021, 5, 2441, 0, 0, 19020, 19022, 7, 238, 0, 0, 19021, 19020, 1, 0, 0, 0, 19021, 19022, 1, 0, 0, 0, 19022, 19023, 1, 0, 0, 0, 19023, 19025, 5, 2448, 0, 0, 19024, 19018, 1, 0, 0, 0, 19024, 19025, 1, 0, 0, 0, 19025, 19029, 1, 0, 0, 0, 19026, 19029, 5, 215, 0, 0, 19027, 19029, 5, 142, 0, 0, 19028, 19017, 1, 0, 0, 0, 19028, 19026, 1, 0, 0, 0, 19028, 19027, 1, 0, 0, 0, 19029, 2163, 1, 0, 0, 0, 19030, 19031, 5, 1558, 0, 0, 19031, 19037, 5, 2443, 0, 0, 19032, 19034, 7, 243, 0, 0, 19033, 19032, 1, 0, 0, 0, 19033, 19034, 1, 0, 0, 0, 19034, 19035, 1, 0, 0, 0, 19035, 19036, 5, 1259, 0, 0, 19036, 19038, 5, 964, 0, 0, 19037, 19033, 1, 0, 0, 0, 19037, 19038, 1, 0, 0, 0, 19038, 19118, 1, 0, 0, 0, 19039, 19040, 5, 756, 0, 0, 19040, 19041, 5, 2443, 0, 0, 19041, 19042, 5, 2472, 0, 0, 19042, 19046, 5, 2443, 0, 0, 19043, 19044, 7, 244, 0, 0, 19044, 19045, 5, 1259, 0, 0, 19045, 19047, 5, 544, 0, 0, 19046, 19043, 1, 0, 0, 0, 19046, 19047, 1, 0, 0, 0, 19047, 19053, 1, 0, 0, 0, 19048, 19050, 7, 245, 0, 0, 19049, 19048, 1, 0, 0, 0, 19049, 19050, 1, 0, 0, 0, 19050, 19051, 1, 0, 0, 0, 19051, 19052, 5, 1259, 0, 0, 19052, 19054, 5, 1228, 0, 0, 19053, 19049, 1, 0, 0, 0, 19053, 19054, 1, 0, 0, 0, 19054, 19118, 1, 0, 0, 0, 19055, 19056, 5, 1562, 0, 0, 19056, 19057, 5, 2443, 0, 0, 19057, 19058, 5, 2472, 0, 0, 19058, 19062, 5, 2443, 0, 0, 19059, 19060, 7, 246, 0, 0, 19060, 19061, 5, 1259, 0, 0, 19061, 19063, 5, 964, 0, 0, 19062, 19059, 1, 0, 0, 0, 19062, 19063, 1, 0, 0, 0, 19063, 19069, 1, 0, 0, 0, 19064, 19066, 7, 247, 0, 0, 19065, 19064, 1, 0, 0, 0, 19065, 19066, 1, 0, 0, 0, 19066, 19067, 1, 0, 0, 0, 19067, 19068, 5, 1259, 0, 0, 19068, 19070, 5, 1228, 0, 0, 19069, 19065, 1, 0, 0, 0, 19069, 19070, 1, 0, 0, 0, 19070, 19118, 1, 0, 0, 0, 19071, 19074, 3, 2078, 1039, 0, 19072, 19073, 5, 621, 0, 0, 19073, 19075, 5, 801, 0, 0, 19074, 19072, 1, 0, 0, 0, 19074, 19075, 1, 0, 0, 0, 19075, 19118, 1, 0, 0, 0, 19076, 19077, 5, 57, 0, 0, 19077, 19078, 5, 2443, 0, 0, 19078, 19079, 5, 2472, 0, 0, 19079, 19083, 5, 2443, 0, 0, 19080, 19081, 7, 246, 0, 0, 19081, 19082, 5, 1259, 0, 0, 19082, 19084, 5, 964, 0, 0, 19083, 19080, 1, 0, 0, 0, 19083, 19084, 1, 0, 0, 0, 19084, 19090, 1, 0, 0, 0, 19085, 19087, 7, 247, 0, 0, 19086, 19085, 1, 0, 0, 0, 19086, 19087, 1, 0, 0, 0, 19087, 19088, 1, 0, 0, 0, 19088, 19089, 5, 1259, 0, 0, 19089, 19091, 5, 1228, 0, 0, 19090, 19086, 1, 0, 0, 0, 19090, 19091, 1, 0, 0, 0, 19091, 19118, 1, 0, 0, 0, 19092, 19093, 5, 1671, 0, 0, 19093, 19094, 5, 2443, 0, 0, 19094, 19095, 5, 2472, 0, 0, 19095, 19098, 3, 2078, 1039, 0, 19096, 19097, 5, 621, 0, 0, 19097, 19099, 5, 801, 0, 0, 19098, 19096, 1, 0, 0, 0, 19098, 19099, 1, 0, 0, 0, 19099, 19103, 1, 0, 0, 0, 19100, 19101, 7, 244, 0, 0, 19101, 19102, 5, 1259, 0, 0, 19102, 19104, 5, 544, 0, 0, 19103, 19100, 1, 0, 0, 0, 19103, 19104, 1, 0, 0, 0, 19104, 19108, 1, 0, 0, 0, 19105, 19106, 7, 246, 0, 0, 19106, 19107, 5, 1259, 0, 0, 19107, 19109, 5, 964, 0, 0, 19108, 19105, 1, 0, 0, 0, 19108, 19109, 1, 0, 0, 0, 19109, 19115, 1, 0, 0, 0, 19110, 19112, 7, 247, 0, 0, 19111, 19110, 1, 0, 0, 0, 19111, 19112, 1, 0, 0, 0, 19112, 19113, 1, 0, 0, 0, 19113, 19114, 5, 1259, 0, 0, 19114, 19116, 5, 1228, 0, 0, 19115, 19111, 1, 0, 0, 0, 19115, 19116, 1, 0, 0, 0, 19116, 19118, 1, 0, 0, 0, 19117, 19030, 1, 0, 0, 0, 19117, 19039, 1, 0, 0, 0, 19117, 19055, 1, 0, 0, 0, 19117, 19071, 1, 0, 0, 0, 19117, 19076, 1, 0, 0, 0, 19117, 19092, 1, 0, 0, 0, 19118, 2165, 1, 0, 0, 0, 19119, 19120, 5, 238, 0, 0, 19120, 19121, 5, 2447, 0, 0, 19121, 19126, 3, 2168, 1084, 0, 19122, 19123, 5, 2453, 0, 0, 19123, 19125, 3, 2168, 1084, 0, 19124, 19122, 1, 0, 0, 0, 19125, 19128, 1, 0, 0, 0, 19126, 19124, 1, 0, 0, 0, 19126, 19127, 1, 0, 0, 0, 19127, 19129, 1, 0, 0, 0, 19128, 19126, 1, 0, 0, 0, 19129, 19130, 5, 2448, 0, 0, 19130, 2167, 1, 0, 0, 0, 19131, 19133, 3, 2078, 1039, 0, 19132, 19134, 3, 2182, 1091, 0, 19133, 19132, 1, 0, 0, 0, 19133, 19134, 1, 0, 0, 0, 19134, 19145, 1, 0, 0, 0, 19135, 19137, 5, 545, 0, 0, 19136, 19135, 1, 0, 0, 0, 19136, 19137, 1, 0, 0, 0, 19137, 19138, 1, 0, 0, 0, 19138, 19139, 5, 1363, 0, 0, 19139, 19146, 5, 2443, 0, 0, 19140, 19143, 5, 2159, 0, 0, 19141, 19142, 5, 1363, 0, 0, 19142, 19144, 5, 2443, 0, 0, 19143, 19141, 1, 0, 0, 0, 19143, 19144, 1, 0, 0, 0, 19144, 19146, 1, 0, 0, 0, 19145, 19136, 1, 0, 0, 0, 19145, 19140, 1, 0, 0, 0, 19145, 19146, 1, 0, 0, 0, 19146, 19148, 1, 0, 0, 0, 19147, 19149, 3, 2176, 1088, 0, 19148, 19147, 1, 0, 0, 0, 19148, 19149, 1, 0, 0, 0, 19149, 19151, 1, 0, 0, 0, 19150, 19152, 3, 2178, 1089, 0, 19151, 19150, 1, 0, 0, 0, 19151, 19152, 1, 0, 0, 0, 19152, 19185, 1, 0, 0, 0, 19153, 19155, 3, 2078, 1039, 0, 19154, 19156, 3, 2172, 1086, 0, 19155, 19154, 1, 0, 0, 0, 19155, 19156, 1, 0, 0, 0, 19156, 19158, 1, 0, 0, 0, 19157, 19159, 5, 2159, 0, 0, 19158, 19157, 1, 0, 0, 0, 19158, 19159, 1, 0, 0, 0, 19159, 19160, 1, 0, 0, 0, 19160, 19161, 5, 621, 0, 0, 19161, 19163, 5, 801, 0, 0, 19162, 19164, 3, 2174, 1087, 0, 19163, 19162, 1, 0, 0, 0, 19163, 19164, 1, 0, 0, 0, 19164, 19165, 1, 0, 0, 0, 19165, 19166, 5, 1363, 0, 0, 19166, 19167, 5, 2443, 0, 0, 19167, 19185, 1, 0, 0, 0, 19168, 19170, 5, 1013, 0, 0, 19169, 19171, 5, 1363, 0, 0, 19170, 19169, 1, 0, 0, 0, 19170, 19171, 1, 0, 0, 0, 19171, 19172, 1, 0, 0, 0, 19172, 19176, 3, 2078, 1039, 0, 19173, 19174, 5, 2473, 0, 0, 19174, 19175, 5, 2450, 0, 0, 19175, 19177, 5, 2474, 0, 0, 19176, 19173, 1, 0, 0, 0, 19176, 19177, 1, 0, 0, 0, 19177, 19178, 1, 0, 0, 0, 19178, 19179, 3, 2166, 1083, 0, 19179, 19185, 1, 0, 0, 0, 19180, 19181, 3, 2078, 1039, 0, 19181, 19182, 5, 620, 0, 0, 19182, 19183, 5, 1304, 0, 0, 19183, 19185, 1, 0, 0, 0, 19184, 19131, 1, 0, 0, 0, 19184, 19153, 1, 0, 0, 0, 19184, 19168, 1, 0, 0, 0, 19184, 19180, 1, 0, 0, 0, 19185, 2169, 1, 0, 0, 0, 19186, 19187, 5, 1585, 0, 0, 19187, 19189, 3, 2172, 1086, 0, 19188, 19186, 1, 0, 0, 0, 19188, 19189, 1, 0, 0, 0, 19189, 19191, 1, 0, 0, 0, 19190, 19192, 5, 1448, 0, 0, 19191, 19190, 1, 0, 0, 0, 19191, 19192, 1, 0, 0, 0, 19192, 19194, 1, 0, 0, 0, 19193, 19195, 5, 71, 0, 0, 19194, 19193, 1, 0, 0, 0, 19194, 19195, 1, 0, 0, 0, 19195, 2171, 1, 0, 0, 0, 19196, 19203, 5, 2259, 0, 0, 19197, 19198, 5, 2447, 0, 0, 19198, 19200, 5, 2441, 0, 0, 19199, 19201, 7, 238, 0, 0, 19200, 19199, 1, 0, 0, 0, 19200, 19201, 1, 0, 0, 0, 19201, 19202, 1, 0, 0, 0, 19202, 19204, 5, 2448, 0, 0, 19203, 19197, 1, 0, 0, 0, 19203, 19204, 1, 0, 0, 0, 19204, 19208, 1, 0, 0, 0, 19205, 19208, 5, 215, 0, 0, 19206, 19208, 5, 142, 0, 0, 19207, 19196, 1, 0, 0, 0, 19207, 19205, 1, 0, 0, 0, 19207, 19206, 1, 0, 0, 0, 19208, 2173, 1, 0, 0, 0, 19209, 19211, 5, 2306, 0, 0, 19210, 19212, 5, 68, 0, 0, 19211, 19210, 1, 0, 0, 0, 19211, 19212, 1, 0, 0, 0, 19212, 19213, 1, 0, 0, 0, 19213, 19223, 5, 2312, 0, 0, 19214, 19216, 5, 2308, 0, 0, 19215, 19217, 7, 248, 0, 0, 19216, 19215, 1, 0, 0, 0, 19216, 19217, 1, 0, 0, 0, 19217, 19219, 1, 0, 0, 0, 19218, 19220, 5, 68, 0, 0, 19219, 19218, 1, 0, 0, 0, 19219, 19220, 1, 0, 0, 0, 19220, 19221, 1, 0, 0, 0, 19221, 19223, 5, 2312, 0, 0, 19222, 19209, 1, 0, 0, 0, 19222, 19214, 1, 0, 0, 0, 19223, 2175, 1, 0, 0, 0, 19224, 19232, 5, 520, 0, 0, 19225, 19232, 5, 1228, 0, 0, 19226, 19232, 5, 497, 0, 0, 19227, 19228, 5, 497, 0, 0, 19228, 19232, 5, 68, 0, 0, 19229, 19230, 5, 497, 0, 0, 19230, 19232, 5, 1238, 0, 0, 19231, 19224, 1, 0, 0, 0, 19231, 19225, 1, 0, 0, 0, 19231, 19226, 1, 0, 0, 0, 19231, 19227, 1, 0, 0, 0, 19231, 19229, 1, 0, 0, 0, 19231, 19232, 1, 0, 0, 0, 19232, 19233, 1, 0, 0, 0, 19233, 19234, 5, 1259, 0, 0, 19234, 19235, 5, 520, 0, 0, 19235, 2177, 1, 0, 0, 0, 19236, 19244, 5, 520, 0, 0, 19237, 19244, 5, 1228, 0, 0, 19238, 19244, 5, 497, 0, 0, 19239, 19240, 5, 497, 0, 0, 19240, 19244, 5, 68, 0, 0, 19241, 19242, 5, 497, 0, 0, 19242, 19244, 5, 1238, 0, 0, 19243, 19236, 1, 0, 0, 0, 19243, 19237, 1, 0, 0, 0, 19243, 19238, 1, 0, 0, 0, 19243, 19239, 1, 0, 0, 0, 19243, 19241, 1, 0, 0, 0, 19243, 19244, 1, 0, 0, 0, 19244, 19245, 1, 0, 0, 0, 19245, 19246, 5, 1259, 0, 0, 19246, 19247, 5, 497, 0, 0, 19247, 2179, 1, 0, 0, 0, 19248, 19250, 5, 1585, 0, 0, 19249, 19251, 3, 2182, 1091, 0, 19250, 19249, 1, 0, 0, 0, 19250, 19251, 1, 0, 0, 0, 19251, 19253, 1, 0, 0, 0, 19252, 19254, 5, 71, 0, 0, 19253, 19252, 1, 0, 0, 0, 19253, 19254, 1, 0, 0, 0, 19254, 2181, 1, 0, 0, 0, 19255, 19262, 5, 2259, 0, 0, 19256, 19257, 5, 2447, 0, 0, 19257, 19259, 5, 2441, 0, 0, 19258, 19260, 7, 238, 0, 0, 19259, 19258, 1, 0, 0, 0, 19259, 19260, 1, 0, 0, 0, 19260, 19261, 1, 0, 0, 0, 19261, 19263, 5, 2448, 0, 0, 19262, 19256, 1, 0, 0, 0, 19262, 19263, 1, 0, 0, 0, 19263, 19265, 1, 0, 0, 0, 19264, 19266, 5, 2159, 0, 0, 19265, 19264, 1, 0, 0, 0, 19265, 19266, 1, 0, 0, 0, 19266, 19292, 1, 0, 0, 0, 19267, 19292, 5, 215, 0, 0, 19268, 19292, 5, 361, 0, 0, 19269, 19277, 5, 1230, 0, 0, 19270, 19271, 5, 2447, 0, 0, 19271, 19274, 5, 769, 0, 0, 19272, 19273, 5, 2453, 0, 0, 19273, 19275, 5, 769, 0, 0, 19274, 19272, 1, 0, 0, 0, 19274, 19275, 1, 0, 0, 0, 19275, 19276, 1, 0, 0, 0, 19276, 19278, 5, 2448, 0, 0, 19277, 19270, 1, 0, 0, 0, 19277, 19278, 1, 0, 0, 0, 19278, 19292, 1, 0, 0, 0, 19279, 19282, 5, 2108, 0, 0, 19280, 19281, 5, 2308, 0, 0, 19281, 19283, 5, 2113, 0, 0, 19282, 19280, 1, 0, 0, 0, 19282, 19283, 1, 0, 0, 0, 19283, 19292, 1, 0, 0, 0, 19284, 19292, 5, 1633, 0, 0, 19285, 19289, 3, 2078, 1039, 0, 19286, 19287, 5, 2246, 0, 0, 19287, 19288, 5, 182, 0, 0, 19288, 19290, 5, 911, 0, 0, 19289, 19286, 1, 0, 0, 0, 19289, 19290, 1, 0, 0, 0, 19290, 19292, 1, 0, 0, 0, 19291, 19255, 1, 0, 0, 0, 19291, 19267, 1, 0, 0, 0, 19291, 19268, 1, 0, 0, 0, 19291, 19269, 1, 0, 0, 0, 19291, 19279, 1, 0, 0, 0, 19291, 19284, 1, 0, 0, 0, 19291, 19285, 1, 0, 0, 0, 19292, 2183, 1, 0, 0, 0, 19293, 19294, 7, 247, 0, 0, 19294, 19295, 5, 1259, 0, 0, 19295, 19304, 5, 965, 0, 0, 19296, 19297, 5, 2447, 0, 0, 19297, 19298, 5, 964, 0, 0, 19298, 19305, 5, 351, 0, 0, 19299, 19300, 5, 565, 0, 0, 19300, 19305, 5, 351, 0, 0, 19301, 19302, 5, 2166, 0, 0, 19302, 19303, 5, 520, 0, 0, 19303, 19305, 5, 2448, 0, 0, 19304, 19296, 1, 0, 0, 0, 19304, 19299, 1, 0, 0, 0, 19304, 19301, 1, 0, 0, 0, 19304, 19305, 1, 0, 0, 0, 19305, 2185, 1, 0, 0, 0, 19306, 19312, 5, 2443, 0, 0, 19307, 19312, 3, 2146, 1073, 0, 19308, 19312, 3, 2396, 1198, 0, 19309, 19312, 3, 2398, 1199, 0, 19310, 19312, 5, 932, 0, 0, 19311, 19306, 1, 0, 0, 0, 19311, 19307, 1, 0, 0, 0, 19311, 19308, 1, 0, 0, 0, 19311, 19309, 1, 0, 0, 0, 19311, 19310, 1, 0, 0, 0, 19312, 2187, 1, 0, 0, 0, 19313, 19316, 3, 2190, 1095, 0, 19314, 19317, 3, 2110, 1055, 0, 19315, 19317, 3, 2112, 1056, 0, 19316, 19314, 1, 0, 0, 0, 19316, 19315, 1, 0, 0, 0, 19316, 19317, 1, 0, 0, 0, 19317, 2189, 1, 0, 0, 0, 19318, 19319, 5, 2419, 0, 0, 19319, 19321, 5, 2447, 0, 0, 19320, 19322, 7, 226, 0, 0, 19321, 19320, 1, 0, 0, 0, 19321, 19322, 1, 0, 0, 0, 19322, 19323, 1, 0, 0, 0, 19323, 19324, 3, 2078, 1039, 0, 19324, 19327, 5, 2448, 0, 0, 19325, 19328, 3, 2202, 1101, 0, 19326, 19328, 3, 2362, 1181, 0, 19327, 19325, 1, 0, 0, 0, 19327, 19326, 1, 0, 0, 0, 19327, 19328, 1, 0, 0, 0, 19328, 19401, 1, 0, 0, 0, 19329, 19330, 5, 313, 0, 0, 19330, 19338, 5, 2447, 0, 0, 19331, 19339, 5, 2450, 0, 0, 19332, 19334, 7, 209, 0, 0, 19333, 19332, 1, 0, 0, 0, 19333, 19334, 1, 0, 0, 0, 19334, 19335, 1, 0, 0, 0, 19335, 19337, 3, 2102, 1051, 0, 19336, 19333, 1, 0, 0, 0, 19336, 19337, 1, 0, 0, 0, 19337, 19339, 1, 0, 0, 0, 19338, 19331, 1, 0, 0, 0, 19338, 19336, 1, 0, 0, 0, 19339, 19340, 1, 0, 0, 0, 19340, 19343, 5, 2448, 0, 0, 19341, 19344, 3, 2202, 1101, 0, 19342, 19344, 3, 2362, 1181, 0, 19343, 19341, 1, 0, 0, 0, 19343, 19342, 1, 0, 0, 0, 19343, 19344, 1, 0, 0, 0, 19344, 19401, 1, 0, 0, 0, 19345, 19346, 5, 2414, 0, 0, 19346, 19347, 5, 2447, 0, 0, 19347, 19353, 3, 2078, 1039, 0, 19348, 19351, 5, 2453, 0, 0, 19349, 19352, 5, 2441, 0, 0, 19350, 19352, 3, 2078, 1039, 0, 19351, 19349, 1, 0, 0, 0, 19351, 19350, 1, 0, 0, 0, 19352, 19354, 1, 0, 0, 0, 19353, 19348, 1, 0, 0, 0, 19353, 19354, 1, 0, 0, 0, 19354, 19355, 1, 0, 0, 0, 19355, 19356, 5, 2448, 0, 0, 19356, 19401, 1, 0, 0, 0, 19357, 19358, 5, 2398, 0, 0, 19358, 19360, 5, 2447, 0, 0, 19359, 19361, 7, 226, 0, 0, 19360, 19359, 1, 0, 0, 0, 19360, 19361, 1, 0, 0, 0, 19361, 19362, 1, 0, 0, 0, 19362, 19363, 3, 2078, 1039, 0, 19363, 19366, 5, 2448, 0, 0, 19364, 19367, 3, 2202, 1101, 0, 19365, 19367, 3, 2362, 1181, 0, 19366, 19364, 1, 0, 0, 0, 19366, 19365, 1, 0, 0, 0, 19366, 19367, 1, 0, 0, 0, 19367, 19401, 1, 0, 0, 0, 19368, 19369, 5, 2409, 0, 0, 19369, 19371, 5, 2447, 0, 0, 19370, 19372, 7, 226, 0, 0, 19371, 19370, 1, 0, 0, 0, 19371, 19372, 1, 0, 0, 0, 19372, 19373, 1, 0, 0, 0, 19373, 19374, 3, 2078, 1039, 0, 19374, 19377, 5, 2448, 0, 0, 19375, 19378, 3, 2202, 1101, 0, 19376, 19378, 3, 2362, 1181, 0, 19377, 19375, 1, 0, 0, 0, 19377, 19376, 1, 0, 0, 0, 19377, 19378, 1, 0, 0, 0, 19378, 19401, 1, 0, 0, 0, 19379, 19380, 5, 2406, 0, 0, 19380, 19382, 5, 2447, 0, 0, 19381, 19383, 7, 226, 0, 0, 19382, 19381, 1, 0, 0, 0, 19382, 19383, 1, 0, 0, 0, 19383, 19384, 1, 0, 0, 0, 19384, 19385, 3, 2078, 1039, 0, 19385, 19388, 5, 2448, 0, 0, 19386, 19389, 3, 2202, 1101, 0, 19387, 19389, 3, 2362, 1181, 0, 19388, 19386, 1, 0, 0, 0, 19388, 19387, 1, 0, 0, 0, 19388, 19389, 1, 0, 0, 0, 19389, 19401, 1, 0, 0, 0, 19390, 19391, 5, 2423, 0, 0, 19391, 19392, 5, 2447, 0, 0, 19392, 19393, 3, 2076, 1038, 0, 19393, 19394, 5, 2448, 0, 0, 19394, 19401, 1, 0, 0, 0, 19395, 19396, 5, 2424, 0, 0, 19396, 19397, 5, 2447, 0, 0, 19397, 19398, 3, 2076, 1038, 0, 19398, 19399, 5, 2448, 0, 0, 19399, 19401, 1, 0, 0, 0, 19400, 19318, 1, 0, 0, 0, 19400, 19329, 1, 0, 0, 0, 19400, 19345, 1, 0, 0, 0, 19400, 19357, 1, 0, 0, 0, 19400, 19368, 1, 0, 0, 0, 19400, 19379, 1, 0, 0, 0, 19400, 19390, 1, 0, 0, 0, 19400, 19395, 1, 0, 0, 0, 19401, 2191, 1, 0, 0, 0, 19402, 19403, 5, 1259, 0, 0, 19403, 19404, 5, 1320, 0, 0, 19404, 19406, 7, 229, 0, 0, 19405, 19407, 5, 2443, 0, 0, 19406, 19405, 1, 0, 0, 0, 19406, 19407, 1, 0, 0, 0, 19407, 19410, 1, 0, 0, 0, 19408, 19409, 7, 2, 0, 0, 19409, 19411, 5, 313, 0, 0, 19410, 19408, 1, 0, 0, 0, 19410, 19411, 1, 0, 0, 0, 19411, 2193, 1, 0, 0, 0, 19412, 19413, 3, 2196, 1098, 0, 19413, 19415, 3, 2366, 1183, 0, 19414, 19416, 3, 2202, 1101, 0, 19415, 19414, 1, 0, 0, 0, 19415, 19416, 1, 0, 0, 0, 19416, 19834, 1, 0, 0, 0, 19417, 19418, 3, 2410, 1205, 0, 19418, 19420, 3, 2368, 1184, 0, 19419, 19421, 3, 2210, 1105, 0, 19420, 19419, 1, 0, 0, 0, 19420, 19421, 1, 0, 0, 0, 19421, 19834, 1, 0, 0, 0, 19422, 19423, 5, 313, 0, 0, 19423, 19429, 5, 2447, 0, 0, 19424, 19430, 5, 2450, 0, 0, 19425, 19427, 7, 209, 0, 0, 19426, 19425, 1, 0, 0, 0, 19426, 19427, 1, 0, 0, 0, 19427, 19428, 1, 0, 0, 0, 19428, 19430, 3, 2102, 1051, 0, 19429, 19424, 1, 0, 0, 0, 19429, 19426, 1, 0, 0, 0, 19430, 19431, 1, 0, 0, 0, 19431, 19433, 5, 2448, 0, 0, 19432, 19434, 3, 2202, 1101, 0, 19433, 19432, 1, 0, 0, 0, 19433, 19434, 1, 0, 0, 0, 19434, 19834, 1, 0, 0, 0, 19435, 19436, 7, 249, 0, 0, 19436, 19443, 5, 2447, 0, 0, 19437, 19438, 5, 994, 0, 0, 19438, 19439, 5, 2447, 0, 0, 19439, 19440, 3, 1896, 948, 0, 19440, 19441, 5, 2448, 0, 0, 19441, 19444, 1, 0, 0, 0, 19442, 19444, 3, 2102, 1051, 0, 19443, 19437, 1, 0, 0, 0, 19443, 19442, 1, 0, 0, 0, 19444, 19445, 1, 0, 0, 0, 19445, 19446, 5, 69, 0, 0, 19446, 19453, 3, 2374, 1187, 0, 19447, 19448, 5, 389, 0, 0, 19448, 19449, 3, 2102, 1051, 0, 19449, 19450, 5, 1259, 0, 0, 19450, 19451, 5, 301, 0, 0, 19451, 19452, 5, 520, 0, 0, 19452, 19454, 1, 0, 0, 0, 19453, 19447, 1, 0, 0, 0, 19453, 19454, 1, 0, 0, 0, 19454, 19461, 1, 0, 0, 0, 19455, 19456, 5, 2453, 0, 0, 19456, 19459, 3, 2400, 1200, 0, 19457, 19458, 5, 2453, 0, 0, 19458, 19460, 3, 2400, 1200, 0, 19459, 19457, 1, 0, 0, 0, 19459, 19460, 1, 0, 0, 0, 19460, 19462, 1, 0, 0, 0, 19461, 19455, 1, 0, 0, 0, 19461, 19462, 1, 0, 0, 0, 19462, 19463, 1, 0, 0, 0, 19463, 19464, 5, 2448, 0, 0, 19464, 19834, 1, 0, 0, 0, 19465, 19466, 5, 228, 0, 0, 19466, 19467, 5, 2447, 0, 0, 19467, 19473, 3, 2388, 1194, 0, 19468, 19471, 5, 2453, 0, 0, 19469, 19472, 3, 2396, 1198, 0, 19470, 19472, 3, 2400, 1200, 0, 19471, 19469, 1, 0, 0, 0, 19471, 19470, 1, 0, 0, 0, 19472, 19474, 1, 0, 0, 0, 19473, 19468, 1, 0, 0, 0, 19473, 19474, 1, 0, 0, 0, 19474, 19475, 1, 0, 0, 0, 19475, 19476, 5, 2448, 0, 0, 19476, 19834, 1, 0, 0, 0, 19477, 19478, 5, 233, 0, 0, 19478, 19480, 5, 2447, 0, 0, 19479, 19481, 7, 250, 0, 0, 19480, 19479, 1, 0, 0, 0, 19480, 19481, 1, 0, 0, 0, 19481, 19482, 1, 0, 0, 0, 19482, 19484, 3, 2102, 1051, 0, 19483, 19485, 3, 2216, 1108, 0, 19484, 19483, 1, 0, 0, 0, 19484, 19485, 1, 0, 0, 0, 19485, 19486, 1, 0, 0, 0, 19486, 19487, 5, 2448, 0, 0, 19487, 19834, 1, 0, 0, 0, 19488, 19489, 3, 2198, 1099, 0, 19489, 19491, 3, 2364, 1182, 0, 19490, 19492, 3, 2218, 1109, 0, 19491, 19490, 1, 0, 0, 0, 19492, 19493, 1, 0, 0, 0, 19493, 19491, 1, 0, 0, 0, 19493, 19494, 1, 0, 0, 0, 19494, 19834, 1, 0, 0, 0, 19495, 19496, 5, 2393, 0, 0, 19496, 19498, 5, 2447, 0, 0, 19497, 19499, 7, 209, 0, 0, 19498, 19497, 1, 0, 0, 0, 19498, 19499, 1, 0, 0, 0, 19499, 19500, 1, 0, 0, 0, 19500, 19503, 3, 2372, 1186, 0, 19501, 19502, 5, 2453, 0, 0, 19502, 19504, 3, 2078, 1039, 0, 19503, 19501, 1, 0, 0, 0, 19503, 19504, 1, 0, 0, 0, 19504, 19506, 1, 0, 0, 0, 19505, 19507, 3, 2192, 1096, 0, 19506, 19505, 1, 0, 0, 0, 19506, 19507, 1, 0, 0, 0, 19507, 19508, 1, 0, 0, 0, 19508, 19515, 5, 2448, 0, 0, 19509, 19510, 5, 2305, 0, 0, 19510, 19511, 5, 649, 0, 0, 19511, 19512, 5, 2447, 0, 0, 19512, 19513, 3, 1994, 997, 0, 19513, 19514, 5, 2448, 0, 0, 19514, 19516, 1, 0, 0, 0, 19515, 19509, 1, 0, 0, 0, 19515, 19516, 1, 0, 0, 0, 19516, 19518, 1, 0, 0, 0, 19517, 19519, 3, 2202, 1101, 0, 19518, 19517, 1, 0, 0, 0, 19518, 19519, 1, 0, 0, 0, 19519, 19834, 1, 0, 0, 0, 19520, 19521, 3, 2330, 1165, 0, 19521, 19522, 7, 251, 0, 0, 19522, 19834, 1, 0, 0, 0, 19523, 19524, 5, 383, 0, 0, 19524, 19525, 5, 2447, 0, 0, 19525, 19527, 3, 2102, 1051, 0, 19526, 19528, 7, 252, 0, 0, 19527, 19526, 1, 0, 0, 0, 19527, 19528, 1, 0, 0, 0, 19528, 19529, 1, 0, 0, 0, 19529, 19530, 5, 2448, 0, 0, 19530, 19834, 1, 0, 0, 0, 19531, 19532, 5, 563, 0, 0, 19532, 19533, 5, 2447, 0, 0, 19533, 19534, 3, 2410, 1205, 0, 19534, 19535, 5, 628, 0, 0, 19535, 19536, 3, 2102, 1051, 0, 19536, 19537, 5, 2448, 0, 0, 19537, 19834, 1, 0, 0, 0, 19538, 19539, 7, 253, 0, 0, 19539, 19541, 3, 2366, 1183, 0, 19540, 19542, 3, 2370, 1185, 0, 19541, 19540, 1, 0, 0, 0, 19541, 19542, 1, 0, 0, 0, 19542, 19543, 1, 0, 0, 0, 19543, 19544, 3, 2202, 1101, 0, 19544, 19834, 1, 0, 0, 0, 19545, 19546, 7, 254, 0, 0, 19546, 19548, 3, 2366, 1183, 0, 19547, 19549, 3, 2370, 1185, 0, 19548, 19547, 1, 0, 0, 0, 19548, 19549, 1, 0, 0, 0, 19549, 19550, 1, 0, 0, 0, 19550, 19551, 3, 2202, 1101, 0, 19551, 19834, 1, 0, 0, 0, 19552, 19553, 3, 2200, 1100, 0, 19553, 19554, 5, 2447, 0, 0, 19554, 19556, 3, 2076, 1038, 0, 19555, 19557, 3, 2222, 1111, 0, 19556, 19555, 1, 0, 0, 0, 19556, 19557, 1, 0, 0, 0, 19557, 19559, 1, 0, 0, 0, 19558, 19560, 3, 2210, 1105, 0, 19559, 19558, 1, 0, 0, 0, 19559, 19560, 1, 0, 0, 0, 19560, 19561, 1, 0, 0, 0, 19561, 19562, 5, 2448, 0, 0, 19562, 19834, 1, 0, 0, 0, 19563, 19564, 7, 255, 0, 0, 19564, 19565, 5, 2447, 0, 0, 19565, 19572, 3, 2102, 1051, 0, 19566, 19567, 5, 389, 0, 0, 19567, 19568, 3, 2102, 1051, 0, 19568, 19569, 5, 1259, 0, 0, 19569, 19570, 5, 301, 0, 0, 19570, 19571, 5, 520, 0, 0, 19571, 19573, 1, 0, 0, 0, 19572, 19566, 1, 0, 0, 0, 19572, 19573, 1, 0, 0, 0, 19573, 19580, 1, 0, 0, 0, 19574, 19575, 5, 2453, 0, 0, 19575, 19578, 3, 2400, 1200, 0, 19576, 19577, 5, 2453, 0, 0, 19577, 19579, 3, 2400, 1200, 0, 19578, 19576, 1, 0, 0, 0, 19578, 19579, 1, 0, 0, 0, 19579, 19581, 1, 0, 0, 0, 19580, 19574, 1, 0, 0, 0, 19580, 19581, 1, 0, 0, 0, 19581, 19582, 1, 0, 0, 0, 19582, 19583, 5, 2448, 0, 0, 19583, 19834, 1, 0, 0, 0, 19584, 19585, 7, 256, 0, 0, 19585, 19586, 5, 2447, 0, 0, 19586, 19593, 3, 2102, 1051, 0, 19587, 19588, 5, 389, 0, 0, 19588, 19589, 3, 2102, 1051, 0, 19589, 19590, 5, 1259, 0, 0, 19590, 19591, 5, 301, 0, 0, 19591, 19592, 5, 520, 0, 0, 19592, 19594, 1, 0, 0, 0, 19593, 19587, 1, 0, 0, 0, 19593, 19594, 1, 0, 0, 0, 19594, 19595, 1, 0, 0, 0, 19595, 19596, 5, 2448, 0, 0, 19596, 19834, 1, 0, 0, 0, 19597, 19598, 5, 2153, 0, 0, 19598, 19599, 5, 2447, 0, 0, 19599, 19602, 3, 2078, 1039, 0, 19600, 19601, 5, 2246, 0, 0, 19601, 19603, 7, 257, 0, 0, 19602, 19600, 1, 0, 0, 0, 19602, 19603, 1, 0, 0, 0, 19603, 19608, 1, 0, 0, 0, 19604, 19605, 5, 2453, 0, 0, 19605, 19607, 3, 2078, 1039, 0, 19606, 19604, 1, 0, 0, 0, 19607, 19610, 1, 0, 0, 0, 19608, 19606, 1, 0, 0, 0, 19608, 19609, 1, 0, 0, 0, 19609, 19611, 1, 0, 0, 0, 19610, 19608, 1, 0, 0, 0, 19611, 19612, 5, 2448, 0, 0, 19612, 19834, 1, 0, 0, 0, 19613, 19614, 5, 2155, 0, 0, 19614, 19615, 5, 2447, 0, 0, 19615, 19616, 3, 2078, 1039, 0, 19616, 19618, 5, 69, 0, 0, 19617, 19619, 5, 1530, 0, 0, 19618, 19617, 1, 0, 0, 0, 19618, 19619, 1, 0, 0, 0, 19619, 19620, 1, 0, 0, 0, 19620, 19621, 3, 2374, 1187, 0, 19621, 19626, 5, 2448, 0, 0, 19622, 19623, 5, 2440, 0, 0, 19623, 19625, 3, 2386, 1193, 0, 19624, 19622, 1, 0, 0, 0, 19625, 19628, 1, 0, 0, 0, 19626, 19624, 1, 0, 0, 0, 19626, 19627, 1, 0, 0, 0, 19627, 19834, 1, 0, 0, 0, 19628, 19626, 1, 0, 0, 0, 19629, 19630, 5, 2418, 0, 0, 19630, 19638, 5, 2447, 0, 0, 19631, 19633, 7, 236, 0, 0, 19632, 19631, 1, 0, 0, 0, 19632, 19633, 1, 0, 0, 0, 19633, 19635, 1, 0, 0, 0, 19634, 19636, 3, 2400, 1200, 0, 19635, 19634, 1, 0, 0, 0, 19635, 19636, 1, 0, 0, 0, 19636, 19637, 1, 0, 0, 0, 19637, 19639, 5, 628, 0, 0, 19638, 19632, 1, 0, 0, 0, 19638, 19639, 1, 0, 0, 0, 19639, 19640, 1, 0, 0, 0, 19640, 19641, 3, 2102, 1051, 0, 19641, 19642, 5, 2448, 0, 0, 19642, 19834, 1, 0, 0, 0, 19643, 19644, 5, 2254, 0, 0, 19644, 19645, 5, 2447, 0, 0, 19645, 19646, 3, 2102, 1051, 0, 19646, 19647, 5, 69, 0, 0, 19647, 19654, 3, 2374, 1187, 0, 19648, 19649, 5, 2453, 0, 0, 19649, 19652, 3, 2400, 1200, 0, 19650, 19651, 5, 2453, 0, 0, 19651, 19653, 3, 2400, 1200, 0, 19652, 19650, 1, 0, 0, 0, 19652, 19653, 1, 0, 0, 0, 19653, 19655, 1, 0, 0, 0, 19654, 19648, 1, 0, 0, 0, 19654, 19655, 1, 0, 0, 0, 19655, 19656, 1, 0, 0, 0, 19656, 19657, 5, 2448, 0, 0, 19657, 19834, 1, 0, 0, 0, 19658, 19659, 5, 2319, 0, 0, 19659, 19660, 5, 2447, 0, 0, 19660, 19662, 3, 2078, 1039, 0, 19661, 19663, 3, 1994, 997, 0, 19662, 19661, 1, 0, 0, 0, 19662, 19663, 1, 0, 0, 0, 19663, 19664, 1, 0, 0, 0, 19664, 19669, 5, 2448, 0, 0, 19665, 19666, 5, 2440, 0, 0, 19666, 19668, 3, 2386, 1193, 0, 19667, 19665, 1, 0, 0, 0, 19668, 19671, 1, 0, 0, 0, 19669, 19667, 1, 0, 0, 0, 19669, 19670, 1, 0, 0, 0, 19670, 19834, 1, 0, 0, 0, 19671, 19669, 1, 0, 0, 0, 19672, 19673, 7, 258, 0, 0, 19673, 19674, 5, 2447, 0, 0, 19674, 19679, 3, 2234, 1117, 0, 19675, 19676, 5, 2453, 0, 0, 19676, 19678, 3, 2234, 1117, 0, 19677, 19675, 1, 0, 0, 0, 19678, 19681, 1, 0, 0, 0, 19679, 19677, 1, 0, 0, 0, 19679, 19680, 1, 0, 0, 0, 19680, 19682, 1, 0, 0, 0, 19681, 19679, 1, 0, 0, 0, 19682, 19687, 5, 2448, 0, 0, 19683, 19684, 5, 2440, 0, 0, 19684, 19686, 3, 2386, 1193, 0, 19685, 19683, 1, 0, 0, 0, 19686, 19689, 1, 0, 0, 0, 19687, 19685, 1, 0, 0, 0, 19687, 19688, 1, 0, 0, 0, 19688, 19834, 1, 0, 0, 0, 19689, 19687, 1, 0, 0, 0, 19690, 19691, 5, 2328, 0, 0, 19691, 19693, 5, 2447, 0, 0, 19692, 19694, 7, 259, 0, 0, 19693, 19692, 1, 0, 0, 0, 19693, 19694, 1, 0, 0, 0, 19694, 19696, 1, 0, 0, 0, 19695, 19697, 7, 260, 0, 0, 19696, 19695, 1, 0, 0, 0, 19696, 19697, 1, 0, 0, 0, 19697, 19698, 1, 0, 0, 0, 19698, 19701, 3, 2078, 1039, 0, 19699, 19700, 5, 2453, 0, 0, 19700, 19702, 3, 2226, 1113, 0, 19701, 19699, 1, 0, 0, 0, 19701, 19702, 1, 0, 0, 0, 19702, 19710, 1, 0, 0, 0, 19703, 19704, 5, 2453, 0, 0, 19704, 19706, 3, 2078, 1039, 0, 19705, 19707, 3, 2268, 1134, 0, 19706, 19705, 1, 0, 0, 0, 19706, 19707, 1, 0, 0, 0, 19707, 19709, 1, 0, 0, 0, 19708, 19703, 1, 0, 0, 0, 19709, 19712, 1, 0, 0, 0, 19710, 19708, 1, 0, 0, 0, 19710, 19711, 1, 0, 0, 0, 19711, 19713, 1, 0, 0, 0, 19712, 19710, 1, 0, 0, 0, 19713, 19718, 5, 2448, 0, 0, 19714, 19715, 5, 2440, 0, 0, 19715, 19717, 3, 2386, 1193, 0, 19716, 19714, 1, 0, 0, 0, 19717, 19720, 1, 0, 0, 0, 19718, 19716, 1, 0, 0, 0, 19718, 19719, 1, 0, 0, 0, 19719, 19834, 1, 0, 0, 0, 19720, 19718, 1, 0, 0, 0, 19721, 19722, 5, 2330, 0, 0, 19722, 19723, 5, 2447, 0, 0, 19723, 19725, 3, 2078, 1039, 0, 19724, 19726, 3, 2224, 1112, 0, 19725, 19724, 1, 0, 0, 0, 19725, 19726, 1, 0, 0, 0, 19726, 19727, 1, 0, 0, 0, 19727, 19728, 5, 2448, 0, 0, 19728, 19834, 1, 0, 0, 0, 19729, 19730, 5, 2339, 0, 0, 19730, 19731, 5, 2447, 0, 0, 19731, 19732, 7, 261, 0, 0, 19732, 19734, 3, 2102, 1051, 0, 19733, 19735, 5, 2298, 0, 0, 19734, 19733, 1, 0, 0, 0, 19734, 19735, 1, 0, 0, 0, 19735, 19736, 1, 0, 0, 0, 19736, 19741, 5, 2448, 0, 0, 19737, 19738, 5, 2440, 0, 0, 19738, 19740, 3, 2386, 1193, 0, 19739, 19737, 1, 0, 0, 0, 19740, 19743, 1, 0, 0, 0, 19741, 19739, 1, 0, 0, 0, 19741, 19742, 1, 0, 0, 0, 19742, 19834, 1, 0, 0, 0, 19743, 19741, 1, 0, 0, 0, 19744, 19745, 5, 2341, 0, 0, 19745, 19750, 5, 2447, 0, 0, 19746, 19747, 5, 997, 0, 0, 19747, 19751, 3, 2402, 1201, 0, 19748, 19749, 5, 529, 0, 0, 19749, 19751, 3, 2102, 1051, 0, 19750, 19746, 1, 0, 0, 0, 19750, 19748, 1, 0, 0, 0, 19751, 19754, 1, 0, 0, 0, 19752, 19753, 5, 2453, 0, 0, 19753, 19755, 3, 2102, 1051, 0, 19754, 19752, 1, 0, 0, 0, 19754, 19755, 1, 0, 0, 0, 19755, 19756, 1, 0, 0, 0, 19756, 19761, 5, 2448, 0, 0, 19757, 19758, 5, 2440, 0, 0, 19758, 19760, 3, 2386, 1193, 0, 19759, 19757, 1, 0, 0, 0, 19760, 19763, 1, 0, 0, 0, 19761, 19759, 1, 0, 0, 0, 19761, 19762, 1, 0, 0, 0, 19762, 19834, 1, 0, 0, 0, 19763, 19761, 1, 0, 0, 0, 19764, 19765, 5, 2343, 0, 0, 19765, 19766, 5, 2447, 0, 0, 19766, 19768, 3, 2102, 1051, 0, 19767, 19769, 3, 2224, 1112, 0, 19768, 19767, 1, 0, 0, 0, 19768, 19769, 1, 0, 0, 0, 19769, 19770, 1, 0, 0, 0, 19770, 19771, 5, 1585, 0, 0, 19771, 19775, 5, 294, 0, 0, 19772, 19773, 5, 1228, 0, 0, 19773, 19774, 5, 1259, 0, 0, 19774, 19776, 5, 497, 0, 0, 19775, 19772, 1, 0, 0, 0, 19775, 19776, 1, 0, 0, 0, 19776, 19777, 1, 0, 0, 0, 19777, 19782, 5, 2448, 0, 0, 19778, 19779, 5, 2440, 0, 0, 19779, 19781, 3, 2386, 1193, 0, 19780, 19778, 1, 0, 0, 0, 19781, 19784, 1, 0, 0, 0, 19782, 19780, 1, 0, 0, 0, 19782, 19783, 1, 0, 0, 0, 19783, 19834, 1, 0, 0, 0, 19784, 19782, 1, 0, 0, 0, 19785, 19786, 5, 2344, 0, 0, 19786, 19787, 5, 2447, 0, 0, 19787, 19790, 3, 2102, 1051, 0, 19788, 19789, 5, 2453, 0, 0, 19789, 19791, 3, 2236, 1118, 0, 19790, 19788, 1, 0, 0, 0, 19790, 19791, 1, 0, 0, 0, 19791, 19794, 1, 0, 0, 0, 19792, 19793, 5, 2453, 0, 0, 19793, 19795, 3, 2238, 1119, 0, 19794, 19792, 1, 0, 0, 0, 19794, 19795, 1, 0, 0, 0, 19795, 19796, 1, 0, 0, 0, 19796, 19801, 5, 2448, 0, 0, 19797, 19798, 5, 2440, 0, 0, 19798, 19800, 3, 2386, 1193, 0, 19799, 19797, 1, 0, 0, 0, 19800, 19803, 1, 0, 0, 0, 19801, 19799, 1, 0, 0, 0, 19801, 19802, 1, 0, 0, 0, 19802, 19834, 1, 0, 0, 0, 19803, 19801, 1, 0, 0, 0, 19804, 19805, 5, 2346, 0, 0, 19805, 19806, 5, 2447, 0, 0, 19806, 19807, 7, 261, 0, 0, 19807, 19810, 3, 2102, 1051, 0, 19808, 19809, 5, 69, 0, 0, 19809, 19811, 3, 2374, 1187, 0, 19810, 19808, 1, 0, 0, 0, 19810, 19811, 1, 0, 0, 0, 19811, 19813, 1, 0, 0, 0, 19812, 19814, 3, 2240, 1120, 0, 19813, 19812, 1, 0, 0, 0, 19813, 19814, 1, 0, 0, 0, 19814, 19816, 1, 0, 0, 0, 19815, 19817, 3, 2242, 1121, 0, 19816, 19815, 1, 0, 0, 0, 19816, 19817, 1, 0, 0, 0, 19817, 19819, 1, 0, 0, 0, 19818, 19820, 3, 2244, 1122, 0, 19819, 19818, 1, 0, 0, 0, 19819, 19820, 1, 0, 0, 0, 19820, 19823, 1, 0, 0, 0, 19821, 19822, 7, 262, 0, 0, 19822, 19824, 5, 391, 0, 0, 19823, 19821, 1, 0, 0, 0, 19823, 19824, 1, 0, 0, 0, 19824, 19825, 1, 0, 0, 0, 19825, 19828, 5, 2448, 0, 0, 19826, 19827, 5, 2440, 0, 0, 19827, 19829, 3, 2386, 1193, 0, 19828, 19826, 1, 0, 0, 0, 19828, 19829, 1, 0, 0, 0, 19829, 19834, 1, 0, 0, 0, 19830, 19831, 5, 2112, 0, 0, 19831, 19834, 5, 2443, 0, 0, 19832, 19834, 3, 2344, 1172, 0, 19833, 19412, 1, 0, 0, 0, 19833, 19417, 1, 0, 0, 0, 19833, 19422, 1, 0, 0, 0, 19833, 19435, 1, 0, 0, 0, 19833, 19465, 1, 0, 0, 0, 19833, 19477, 1, 0, 0, 0, 19833, 19488, 1, 0, 0, 0, 19833, 19495, 1, 0, 0, 0, 19833, 19520, 1, 0, 0, 0, 19833, 19523, 1, 0, 0, 0, 19833, 19531, 1, 0, 0, 0, 19833, 19538, 1, 0, 0, 0, 19833, 19545, 1, 0, 0, 0, 19833, 19552, 1, 0, 0, 0, 19833, 19563, 1, 0, 0, 0, 19833, 19584, 1, 0, 0, 0, 19833, 19597, 1, 0, 0, 0, 19833, 19613, 1, 0, 0, 0, 19833, 19629, 1, 0, 0, 0, 19833, 19643, 1, 0, 0, 0, 19833, 19658, 1, 0, 0, 0, 19833, 19672, 1, 0, 0, 0, 19833, 19690, 1, 0, 0, 0, 19833, 19721, 1, 0, 0, 0, 19833, 19729, 1, 0, 0, 0, 19833, 19744, 1, 0, 0, 0, 19833, 19764, 1, 0, 0, 0, 19833, 19785, 1, 0, 0, 0, 19833, 19804, 1, 0, 0, 0, 19833, 19830, 1, 0, 0, 0, 19833, 19832, 1, 0, 0, 0, 19834, 2195, 1, 0, 0, 0, 19835, 19836, 7, 263, 0, 0, 19836, 2197, 1, 0, 0, 0, 19837, 19838, 7, 264, 0, 0, 19838, 2199, 1, 0, 0, 0, 19839, 19840, 7, 265, 0, 0, 19840, 2201, 1, 0, 0, 0, 19841, 19842, 5, 1322, 0, 0, 19842, 19863, 5, 2447, 0, 0, 19843, 19845, 3, 1926, 963, 0, 19844, 19843, 1, 0, 0, 0, 19844, 19845, 1, 0, 0, 0, 19845, 19850, 1, 0, 0, 0, 19846, 19848, 3, 1994, 997, 0, 19847, 19849, 3, 2204, 1102, 0, 19848, 19847, 1, 0, 0, 0, 19848, 19849, 1, 0, 0, 0, 19849, 19851, 1, 0, 0, 0, 19850, 19846, 1, 0, 0, 0, 19850, 19851, 1, 0, 0, 0, 19851, 19864, 1, 0, 0, 0, 19852, 19853, 5, 674, 0, 0, 19853, 19854, 3, 2404, 1202, 0, 19854, 19855, 5, 1245, 0, 0, 19855, 19861, 3, 2396, 1198, 0, 19856, 19857, 5, 10, 0, 0, 19857, 19858, 5, 47, 0, 0, 19858, 19859, 5, 82, 0, 0, 19859, 19860, 5, 846, 0, 0, 19860, 19862, 3, 2404, 1202, 0, 19861, 19856, 1, 0, 0, 0, 19861, 19862, 1, 0, 0, 0, 19862, 19864, 1, 0, 0, 0, 19863, 19844, 1, 0, 0, 0, 19863, 19852, 1, 0, 0, 0, 19864, 19865, 1, 0, 0, 0, 19865, 19866, 5, 2448, 0, 0, 19866, 2203, 1, 0, 0, 0, 19867, 19874, 3, 2206, 1103, 0, 19868, 19869, 5, 118, 0, 0, 19869, 19870, 3, 2208, 1104, 0, 19870, 19871, 5, 49, 0, 0, 19871, 19872, 3, 2208, 1104, 0, 19872, 19875, 1, 0, 0, 0, 19873, 19875, 3, 2208, 1104, 0, 19874, 19868, 1, 0, 0, 0, 19874, 19873, 1, 0, 0, 0, 19875, 2205, 1, 0, 0, 0, 19876, 19877, 7, 266, 0, 0, 19877, 2207, 1, 0, 0, 0, 19878, 19879, 5, 2174, 0, 0, 19879, 19886, 5, 1436, 0, 0, 19880, 19881, 5, 336, 0, 0, 19881, 19886, 5, 1606, 0, 0, 19882, 19883, 3, 2102, 1051, 0, 19883, 19884, 7, 267, 0, 0, 19884, 19886, 1, 0, 0, 0, 19885, 19878, 1, 0, 0, 0, 19885, 19880, 1, 0, 0, 0, 19885, 19882, 1, 0, 0, 0, 19886, 2209, 1, 0, 0, 0, 19887, 19897, 5, 2246, 0, 0, 19888, 19898, 5, 2450, 0, 0, 19889, 19894, 3, 2212, 1106, 0, 19890, 19891, 5, 2453, 0, 0, 19891, 19893, 3, 2212, 1106, 0, 19892, 19890, 1, 0, 0, 0, 19893, 19896, 1, 0, 0, 0, 19894, 19892, 1, 0, 0, 0, 19894, 19895, 1, 0, 0, 0, 19895, 19898, 1, 0, 0, 0, 19896, 19894, 1, 0, 0, 0, 19897, 19888, 1, 0, 0, 0, 19897, 19889, 1, 0, 0, 0, 19898, 2211, 1, 0, 0, 0, 19899, 19900, 5, 738, 0, 0, 19900, 19908, 3, 2078, 1039, 0, 19901, 19902, 5, 738, 0, 0, 19902, 19903, 5, 1318, 0, 0, 19903, 19908, 3, 2214, 1107, 0, 19904, 19905, 5, 1318, 0, 0, 19905, 19908, 3, 2214, 1107, 0, 19906, 19908, 3, 2078, 1039, 0, 19907, 19899, 1, 0, 0, 0, 19907, 19901, 1, 0, 0, 0, 19907, 19904, 1, 0, 0, 0, 19907, 19906, 1, 0, 0, 0, 19908, 2213, 1, 0, 0, 0, 19909, 19912, 3, 2384, 1192, 0, 19910, 19912, 3, 2382, 1191, 0, 19911, 19909, 1, 0, 0, 0, 19911, 19910, 1, 0, 0, 0, 19912, 2215, 1, 0, 0, 0, 19913, 19914, 5, 1303, 0, 0, 19914, 19915, 5, 160, 0, 0, 19915, 19920, 3, 2102, 1051, 0, 19916, 19917, 5, 2453, 0, 0, 19917, 19919, 3, 2102, 1051, 0, 19918, 19916, 1, 0, 0, 0, 19919, 19922, 1, 0, 0, 0, 19920, 19918, 1, 0, 0, 0, 19920, 19921, 1, 0, 0, 0, 19921, 2217, 1, 0, 0, 0, 19922, 19920, 1, 0, 0, 0, 19923, 19924, 5, 2305, 0, 0, 19924, 19925, 5, 649, 0, 0, 19925, 19926, 5, 2447, 0, 0, 19926, 19927, 3, 1994, 997, 0, 19927, 19928, 5, 2448, 0, 0, 19928, 19931, 1, 0, 0, 0, 19929, 19931, 3, 2202, 1101, 0, 19930, 19923, 1, 0, 0, 0, 19930, 19929, 1, 0, 0, 0, 19931, 2219, 1, 0, 0, 0, 19932, 19933, 6, 1110, -1, 0, 19933, 19941, 5, 2443, 0, 0, 19934, 19941, 3, 2146, 1073, 0, 19935, 19936, 5, 2447, 0, 0, 19936, 19937, 3, 2220, 1110, 0, 19937, 19938, 5, 2448, 0, 0, 19938, 19941, 1, 0, 0, 0, 19939, 19941, 3, 2404, 1202, 0, 19940, 19932, 1, 0, 0, 0, 19940, 19934, 1, 0, 0, 0, 19940, 19935, 1, 0, 0, 0, 19940, 19939, 1, 0, 0, 0, 19941, 19948, 1, 0, 0, 0, 19942, 19943, 10, 3, 0, 0, 19943, 19944, 5, 2471, 0, 0, 19944, 19945, 5, 2471, 0, 0, 19945, 19947, 3, 2220, 1110, 4, 19946, 19942, 1, 0, 0, 0, 19947, 19950, 1, 0, 0, 0, 19948, 19946, 1, 0, 0, 0, 19948, 19949, 1, 0, 0, 0, 19949, 2221, 1, 0, 0, 0, 19950, 19948, 1, 0, 0, 0, 19951, 19973, 5, 311, 0, 0, 19952, 19954, 5, 971, 0, 0, 19953, 19955, 5, 91, 0, 0, 19954, 19953, 1, 0, 0, 0, 19954, 19955, 1, 0, 0, 0, 19955, 19974, 1, 0, 0, 0, 19956, 19957, 5, 2447, 0, 0, 19957, 19962, 3, 2278, 1139, 0, 19958, 19959, 5, 2453, 0, 0, 19959, 19961, 3, 2278, 1139, 0, 19960, 19958, 1, 0, 0, 0, 19961, 19964, 1, 0, 0, 0, 19962, 19960, 1, 0, 0, 0, 19962, 19963, 1, 0, 0, 0, 19963, 19965, 1, 0, 0, 0, 19964, 19962, 1, 0, 0, 0, 19965, 19966, 5, 2448, 0, 0, 19966, 19967, 5, 2257, 0, 0, 19967, 19969, 5, 2447, 0, 0, 19968, 19970, 3, 2076, 1038, 0, 19969, 19968, 1, 0, 0, 0, 19969, 19970, 1, 0, 0, 0, 19970, 19971, 1, 0, 0, 0, 19971, 19972, 5, 2448, 0, 0, 19972, 19974, 1, 0, 0, 0, 19973, 19952, 1, 0, 0, 0, 19973, 19956, 1, 0, 0, 0, 19974, 2223, 1, 0, 0, 0, 19975, 19978, 5, 1352, 0, 0, 19976, 19977, 5, 160, 0, 0, 19977, 19979, 5, 2258, 0, 0, 19978, 19976, 1, 0, 0, 0, 19978, 19979, 1, 0, 0, 0, 19979, 19980, 1, 0, 0, 0, 19980, 19982, 3, 2078, 1039, 0, 19981, 19983, 3, 2268, 1134, 0, 19982, 19981, 1, 0, 0, 0, 19982, 19983, 1, 0, 0, 0, 19983, 19991, 1, 0, 0, 0, 19984, 19985, 5, 2453, 0, 0, 19985, 19987, 3, 2078, 1039, 0, 19986, 19988, 3, 2268, 1134, 0, 19987, 19986, 1, 0, 0, 0, 19987, 19988, 1, 0, 0, 0, 19988, 19990, 1, 0, 0, 0, 19989, 19984, 1, 0, 0, 0, 19990, 19993, 1, 0, 0, 0, 19991, 19989, 1, 0, 0, 0, 19991, 19992, 1, 0, 0, 0, 19992, 2225, 1, 0, 0, 0, 19993, 19991, 1, 0, 0, 0, 19994, 19995, 5, 2320, 0, 0, 19995, 19997, 5, 2447, 0, 0, 19996, 19998, 7, 259, 0, 0, 19997, 19996, 1, 0, 0, 0, 19997, 19998, 1, 0, 0, 0, 19998, 20000, 1, 0, 0, 0, 19999, 20001, 7, 268, 0, 0, 20000, 19999, 1, 0, 0, 0, 20000, 20001, 1, 0, 0, 0, 20001, 20002, 1, 0, 0, 0, 20002, 20007, 3, 2234, 1117, 0, 20003, 20004, 5, 2453, 0, 0, 20004, 20006, 3, 2234, 1117, 0, 20005, 20003, 1, 0, 0, 0, 20006, 20009, 1, 0, 0, 0, 20007, 20005, 1, 0, 0, 0, 20007, 20008, 1, 0, 0, 0, 20008, 20010, 1, 0, 0, 0, 20009, 20007, 1, 0, 0, 0, 20010, 20011, 5, 2448, 0, 0, 20011, 2227, 1, 0, 0, 0, 20012, 20013, 5, 2338, 0, 0, 20013, 20017, 5, 2447, 0, 0, 20014, 20015, 3, 2102, 1051, 0, 20015, 20016, 3, 2268, 1134, 0, 20016, 20018, 1, 0, 0, 0, 20017, 20014, 1, 0, 0, 0, 20017, 20018, 1, 0, 0, 0, 20018, 20025, 1, 0, 0, 0, 20019, 20020, 5, 2453, 0, 0, 20020, 20021, 3, 2102, 1051, 0, 20021, 20022, 3, 2268, 1134, 0, 20022, 20024, 1, 0, 0, 0, 20023, 20019, 1, 0, 0, 0, 20024, 20027, 1, 0, 0, 0, 20025, 20023, 1, 0, 0, 0, 20025, 20026, 1, 0, 0, 0, 20026, 20029, 1, 0, 0, 0, 20027, 20025, 1, 0, 0, 0, 20028, 20030, 3, 2232, 1116, 0, 20029, 20028, 1, 0, 0, 0, 20029, 20030, 1, 0, 0, 0, 20030, 20031, 1, 0, 0, 0, 20031, 20032, 5, 2448, 0, 0, 20032, 2229, 1, 0, 0, 0, 20033, 20044, 3, 2276, 1138, 0, 20034, 20035, 5, 620, 0, 0, 20035, 20045, 5, 1304, 0, 0, 20036, 20039, 3, 2374, 1187, 0, 20037, 20038, 5, 1363, 0, 0, 20038, 20040, 3, 2102, 1051, 0, 20039, 20037, 1, 0, 0, 0, 20039, 20040, 1, 0, 0, 0, 20040, 20042, 1, 0, 0, 0, 20041, 20043, 3, 2232, 1116, 0, 20042, 20041, 1, 0, 0, 0, 20042, 20043, 1, 0, 0, 0, 20043, 20045, 1, 0, 0, 0, 20044, 20034, 1, 0, 0, 0, 20044, 20036, 1, 0, 0, 0, 20045, 2231, 1, 0, 0, 0, 20046, 20047, 5, 389, 0, 0, 20047, 20048, 3, 2102, 1051, 0, 20048, 2233, 1, 0, 0, 0, 20049, 20057, 3, 2078, 1039, 0, 20050, 20052, 5, 69, 0, 0, 20051, 20050, 1, 0, 0, 0, 20051, 20052, 1, 0, 0, 0, 20052, 20053, 1, 0, 0, 0, 20053, 20058, 3, 2404, 1202, 0, 20054, 20055, 5, 69, 0, 0, 20055, 20056, 5, 529, 0, 0, 20056, 20058, 3, 2078, 1039, 0, 20057, 20051, 1, 0, 0, 0, 20057, 20054, 1, 0, 0, 0, 20057, 20058, 1, 0, 0, 0, 20058, 2235, 1, 0, 0, 0, 20059, 20063, 5, 2285, 0, 0, 20060, 20061, 5, 1137, 0, 0, 20061, 20064, 5, 2258, 0, 0, 20062, 20064, 3, 2078, 1039, 0, 20063, 20060, 1, 0, 0, 0, 20063, 20062, 1, 0, 0, 0, 20064, 2237, 1, 0, 0, 0, 20065, 20071, 5, 1729, 0, 0, 20066, 20072, 5, 2360, 0, 0, 20067, 20069, 5, 1137, 0, 0, 20068, 20070, 5, 2258, 0, 0, 20069, 20068, 1, 0, 0, 0, 20069, 20070, 1, 0, 0, 0, 20070, 20072, 1, 0, 0, 0, 20071, 20066, 1, 0, 0, 0, 20071, 20067, 1, 0, 0, 0, 20072, 2239, 1, 0, 0, 0, 20073, 20074, 5, 504, 0, 0, 20074, 20075, 3, 2102, 1051, 0, 20075, 2241, 1, 0, 0, 0, 20076, 20077, 5, 2285, 0, 0, 20077, 20078, 3, 2102, 1051, 0, 20078, 2243, 1, 0, 0, 0, 20079, 20080, 5, 1137, 0, 0, 20080, 20088, 5, 709, 0, 0, 20081, 20085, 5, 709, 0, 0, 20082, 20083, 5, 1699, 0, 0, 20083, 20084, 5, 2472, 0, 0, 20084, 20086, 3, 2102, 1051, 0, 20085, 20082, 1, 0, 0, 0, 20085, 20086, 1, 0, 0, 0, 20086, 20088, 1, 0, 0, 0, 20087, 20079, 1, 0, 0, 0, 20087, 20081, 1, 0, 0, 0, 20088, 2245, 1, 0, 0, 0, 20089, 20090, 5, 51, 0, 0, 20090, 20091, 5, 2447, 0, 0, 20091, 20092, 3, 2248, 1124, 0, 20092, 20093, 5, 2448, 0, 0, 20093, 2247, 1, 0, 0, 0, 20094, 20100, 5, 21, 0, 0, 20095, 20096, 5, 691, 0, 0, 20096, 20097, 5, 1204, 0, 0, 20097, 20101, 5, 545, 0, 0, 20098, 20099, 5, 1307, 0, 0, 20099, 20101, 5, 1562, 0, 0, 20100, 20095, 1, 0, 0, 0, 20100, 20098, 1, 0, 0, 0, 20100, 20101, 1, 0, 0, 0, 20101, 20109, 1, 0, 0, 0, 20102, 20105, 5, 469, 0, 0, 20103, 20104, 5, 691, 0, 0, 20104, 20106, 5, 545, 0, 0, 20105, 20103, 1, 0, 0, 0, 20105, 20106, 1, 0, 0, 0, 20106, 20109, 1, 0, 0, 0, 20107, 20109, 5, 1562, 0, 0, 20108, 20094, 1, 0, 0, 0, 20108, 20102, 1, 0, 0, 0, 20108, 20107, 1, 0, 0, 0, 20108, 20109, 1, 0, 0, 0, 20109, 20110, 1, 0, 0, 0, 20110, 20115, 3, 2250, 1125, 0, 20111, 20112, 5, 2453, 0, 0, 20112, 20114, 3, 2248, 1124, 0, 20113, 20111, 1, 0, 0, 0, 20114, 20117, 1, 0, 0, 0, 20115, 20113, 1, 0, 0, 0, 20115, 20116, 1, 0, 0, 0, 20116, 2249, 1, 0, 0, 0, 20117, 20115, 1, 0, 0, 0, 20118, 20120, 3, 2402, 1201, 0, 20119, 20121, 5, 2443, 0, 0, 20120, 20119, 1, 0, 0, 0, 20120, 20121, 1, 0, 0, 0, 20121, 2251, 1, 0, 0, 0, 20122, 20132, 5, 547, 0, 0, 20123, 20132, 5, 2479, 0, 0, 20124, 20125, 5, 1683, 0, 0, 20125, 20132, 7, 269, 0, 0, 20126, 20132, 3, 2258, 1129, 0, 20127, 20132, 3, 2262, 1131, 0, 20128, 20132, 3, 2254, 1127, 0, 20129, 20132, 3, 2260, 1130, 0, 20130, 20132, 3, 2264, 1132, 0, 20131, 20122, 1, 0, 0, 0, 20131, 20123, 1, 0, 0, 0, 20131, 20124, 1, 0, 0, 0, 20131, 20126, 1, 0, 0, 0, 20131, 20127, 1, 0, 0, 0, 20131, 20128, 1, 0, 0, 0, 20131, 20129, 1, 0, 0, 0, 20131, 20130, 1, 0, 0, 0, 20132, 2253, 1, 0, 0, 0, 20133, 20139, 5, 1737, 0, 0, 20134, 20136, 5, 2456, 0, 0, 20135, 20137, 5, 2456, 0, 0, 20136, 20135, 1, 0, 0, 0, 20136, 20137, 1, 0, 0, 0, 20137, 20139, 1, 0, 0, 0, 20138, 20133, 1, 0, 0, 0, 20138, 20134, 1, 0, 0, 0, 20139, 20140, 1, 0, 0, 0, 20140, 20141, 3, 2256, 1128, 0, 20141, 2255, 1, 0, 0, 0, 20142, 20143, 3, 2404, 1202, 0, 20143, 20144, 5, 2469, 0, 0, 20144, 20146, 1, 0, 0, 0, 20145, 20142, 1, 0, 0, 0, 20145, 20146, 1, 0, 0, 0, 20146, 20148, 1, 0, 0, 0, 20147, 20149, 7, 270, 0, 0, 20148, 20147, 1, 0, 0, 0, 20148, 20149, 1, 0, 0, 0, 20149, 20155, 1, 0, 0, 0, 20150, 20151, 3, 2404, 1202, 0, 20151, 20152, 7, 270, 0, 0, 20152, 20154, 1, 0, 0, 0, 20153, 20150, 1, 0, 0, 0, 20154, 20157, 1, 0, 0, 0, 20155, 20153, 1, 0, 0, 0, 20155, 20156, 1, 0, 0, 0, 20156, 20158, 1, 0, 0, 0, 20157, 20155, 1, 0, 0, 0, 20158, 20159, 3, 2404, 1202, 0, 20159, 20160, 5, 2440, 0, 0, 20160, 20161, 7, 271, 0, 0, 20161, 2257, 1, 0, 0, 0, 20162, 20163, 5, 2299, 0, 0, 20163, 20179, 7, 272, 0, 0, 20164, 20170, 5, 547, 0, 0, 20165, 20171, 5, 1787, 0, 0, 20166, 20171, 5, 574, 0, 0, 20167, 20171, 5, 2295, 0, 0, 20168, 20171, 3, 2326, 1163, 0, 20169, 20171, 3, 2396, 1198, 0, 20170, 20165, 1, 0, 0, 0, 20170, 20166, 1, 0, 0, 0, 20170, 20167, 1, 0, 0, 0, 20170, 20168, 1, 0, 0, 0, 20170, 20169, 1, 0, 0, 0, 20171, 20173, 1, 0, 0, 0, 20172, 20174, 7, 273, 0, 0, 20173, 20172, 1, 0, 0, 0, 20173, 20174, 1, 0, 0, 0, 20174, 20180, 1, 0, 0, 0, 20175, 20177, 5, 297, 0, 0, 20176, 20178, 7, 274, 0, 0, 20177, 20176, 1, 0, 0, 0, 20177, 20178, 1, 0, 0, 0, 20178, 20180, 1, 0, 0, 0, 20179, 20164, 1, 0, 0, 0, 20179, 20175, 1, 0, 0, 0, 20180, 2259, 1, 0, 0, 0, 20181, 20197, 5, 1671, 0, 0, 20182, 20183, 3, 2410, 1205, 0, 20183, 20184, 7, 100, 0, 0, 20184, 20186, 1, 0, 0, 0, 20185, 20182, 1, 0, 0, 0, 20186, 20187, 1, 0, 0, 0, 20187, 20185, 1, 0, 0, 0, 20187, 20188, 1, 0, 0, 0, 20188, 20198, 1, 0, 0, 0, 20189, 20195, 3, 2410, 1205, 0, 20190, 20196, 5, 2443, 0, 0, 20191, 20196, 5, 1259, 0, 0, 20192, 20196, 5, 1244, 0, 0, 20193, 20196, 3, 2396, 1198, 0, 20194, 20196, 3, 2410, 1205, 0, 20195, 20190, 1, 0, 0, 0, 20195, 20191, 1, 0, 0, 0, 20195, 20192, 1, 0, 0, 0, 20195, 20193, 1, 0, 0, 0, 20195, 20194, 1, 0, 0, 0, 20196, 20198, 1, 0, 0, 0, 20197, 20185, 1, 0, 0, 0, 20197, 20189, 1, 0, 0, 0, 20198, 2261, 1, 0, 0, 0, 20199, 20209, 5, 2120, 0, 0, 20200, 20204, 5, 1737, 0, 0, 20201, 20203, 3, 2404, 1202, 0, 20202, 20201, 1, 0, 0, 0, 20203, 20206, 1, 0, 0, 0, 20204, 20202, 1, 0, 0, 0, 20204, 20205, 1, 0, 0, 0, 20205, 20210, 1, 0, 0, 0, 20206, 20204, 1, 0, 0, 0, 20207, 20210, 5, 1683, 0, 0, 20208, 20210, 5, 1761, 0, 0, 20209, 20200, 1, 0, 0, 0, 20209, 20207, 1, 0, 0, 0, 20209, 20208, 1, 0, 0, 0, 20209, 20210, 1, 0, 0, 0, 20210, 2263, 1, 0, 0, 0, 20211, 20213, 5, 212, 0, 0, 20212, 20214, 5, 237, 0, 0, 20213, 20212, 1, 0, 0, 0, 20213, 20214, 1, 0, 0, 0, 20214, 20215, 1, 0, 0, 0, 20215, 20218, 3, 2410, 1205, 0, 20216, 20218, 5, 38, 0, 0, 20217, 20211, 1, 0, 0, 0, 20217, 20216, 1, 0, 0, 0, 20218, 2265, 1, 0, 0, 0, 20219, 20221, 7, 189, 0, 0, 20220, 20222, 5, 620, 0, 0, 20221, 20220, 1, 0, 0, 0, 20221, 20222, 1, 0, 0, 0, 20222, 20223, 1, 0, 0, 0, 20223, 20225, 5, 2447, 0, 0, 20224, 20226, 3, 2076, 1038, 0, 20225, 20224, 1, 0, 0, 0, 20225, 20226, 1, 0, 0, 0, 20226, 20227, 1, 0, 0, 0, 20227, 20228, 5, 2448, 0, 0, 20228, 2267, 1, 0, 0, 0, 20229, 20231, 5, 69, 0, 0, 20230, 20229, 1, 0, 0, 0, 20230, 20231, 1, 0, 0, 0, 20231, 20234, 1, 0, 0, 0, 20232, 20235, 3, 2402, 1201, 0, 20233, 20235, 3, 2400, 1200, 0, 20234, 20232, 1, 0, 0, 0, 20234, 20233, 1, 0, 0, 0, 20235, 20238, 1, 0, 0, 0, 20236, 20238, 5, 69, 0, 0, 20237, 20230, 1, 0, 0, 0, 20237, 20236, 1, 0, 0, 0, 20238, 2269, 1, 0, 0, 0, 20239, 20242, 3, 2402, 1201, 0, 20240, 20242, 3, 2400, 1200, 0, 20241, 20239, 1, 0, 0, 0, 20241, 20240, 1, 0, 0, 0, 20242, 2271, 1, 0, 0, 0, 20243, 20248, 5, 2301, 0, 0, 20244, 20245, 5, 336, 0, 0, 20245, 20246, 5, 1246, 0, 0, 20246, 20249, 3, 2330, 1165, 0, 20247, 20249, 3, 2074, 1037, 0, 20248, 20244, 1, 0, 0, 0, 20248, 20247, 1, 0, 0, 0, 20249, 2273, 1, 0, 0, 0, 20250, 20251, 5, 159, 0, 0, 20251, 20253, 5, 233, 0, 0, 20252, 20250, 1, 0, 0, 0, 20252, 20253, 1, 0, 0, 0, 20253, 20254, 1, 0, 0, 0, 20254, 20257, 5, 779, 0, 0, 20255, 20258, 3, 2384, 1192, 0, 20256, 20258, 3, 2382, 1191, 0, 20257, 20255, 1, 0, 0, 0, 20257, 20256, 1, 0, 0, 0, 20258, 20266, 1, 0, 0, 0, 20259, 20262, 5, 2453, 0, 0, 20260, 20263, 3, 2384, 1192, 0, 20261, 20263, 3, 2382, 1191, 0, 20262, 20260, 1, 0, 0, 0, 20262, 20261, 1, 0, 0, 0, 20263, 20265, 1, 0, 0, 0, 20264, 20259, 1, 0, 0, 0, 20265, 20268, 1, 0, 0, 0, 20266, 20264, 1, 0, 0, 0, 20266, 20267, 1, 0, 0, 0, 20267, 2275, 1, 0, 0, 0, 20268, 20266, 1, 0, 0, 0, 20269, 20272, 3, 2402, 1201, 0, 20270, 20272, 3, 2400, 1200, 0, 20271, 20269, 1, 0, 0, 0, 20271, 20270, 1, 0, 0, 0, 20272, 2277, 1, 0, 0, 0, 20273, 20274, 3, 2402, 1201, 0, 20274, 2279, 1, 0, 0, 0, 20275, 20276, 3, 2402, 1201, 0, 20276, 2281, 1, 0, 0, 0, 20277, 20278, 3, 2402, 1201, 0, 20278, 2283, 1, 0, 0, 0, 20279, 20280, 3, 2402, 1201, 0, 20280, 2285, 1, 0, 0, 0, 20281, 20282, 3, 2402, 1201, 0, 20282, 2287, 1, 0, 0, 0, 20283, 20288, 3, 2402, 1201, 0, 20284, 20285, 5, 2440, 0, 0, 20285, 20287, 3, 2404, 1202, 0, 20286, 20284, 1, 0, 0, 0, 20287, 20290, 1, 0, 0, 0, 20288, 20286, 1, 0, 0, 0, 20288, 20289, 1, 0, 0, 0, 20289, 20293, 1, 0, 0, 0, 20290, 20288, 1, 0, 0, 0, 20291, 20292, 5, 2456, 0, 0, 20292, 20294, 3, 2334, 1167, 0, 20293, 20291, 1, 0, 0, 0, 20293, 20294, 1, 0, 0, 0, 20294, 2289, 1, 0, 0, 0, 20295, 20296, 3, 2402, 1201, 0, 20296, 2291, 1, 0, 0, 0, 20297, 20300, 3, 2402, 1201, 0, 20298, 20299, 5, 2440, 0, 0, 20299, 20301, 3, 2404, 1202, 0, 20300, 20298, 1, 0, 0, 0, 20300, 20301, 1, 0, 0, 0, 20301, 2293, 1, 0, 0, 0, 20302, 20303, 3, 2402, 1201, 0, 20303, 2295, 1, 0, 0, 0, 20304, 20305, 3, 2402, 1201, 0, 20305, 2297, 1, 0, 0, 0, 20306, 20307, 3, 2402, 1201, 0, 20307, 2299, 1, 0, 0, 0, 20308, 20311, 3, 2402, 1201, 0, 20309, 20310, 5, 2440, 0, 0, 20310, 20312, 3, 2404, 1202, 0, 20311, 20309, 1, 0, 0, 0, 20311, 20312, 1, 0, 0, 0, 20312, 2301, 1, 0, 0, 0, 20313, 20318, 3, 2402, 1201, 0, 20314, 20315, 5, 2440, 0, 0, 20315, 20317, 3, 2404, 1202, 0, 20316, 20314, 1, 0, 0, 0, 20317, 20320, 1, 0, 0, 0, 20318, 20316, 1, 0, 0, 0, 20318, 20319, 1, 0, 0, 0, 20319, 2303, 1, 0, 0, 0, 20320, 20318, 1, 0, 0, 0, 20321, 20322, 3, 2402, 1201, 0, 20322, 2305, 1, 0, 0, 0, 20323, 20325, 3, 2404, 1202, 0, 20324, 20326, 3, 564, 282, 0, 20325, 20324, 1, 0, 0, 0, 20325, 20326, 1, 0, 0, 0, 20326, 2307, 1, 0, 0, 0, 20327, 20330, 3, 2404, 1202, 0, 20328, 20330, 5, 280, 0, 0, 20329, 20327, 1, 0, 0, 0, 20329, 20328, 1, 0, 0, 0, 20330, 2309, 1, 0, 0, 0, 20331, 20336, 3, 2402, 1201, 0, 20332, 20333, 5, 2440, 0, 0, 20333, 20335, 3, 2404, 1202, 0, 20334, 20332, 1, 0, 0, 0, 20335, 20338, 1, 0, 0, 0, 20336, 20334, 1, 0, 0, 0, 20336, 20337, 1, 0, 0, 0, 20337, 20341, 1, 0, 0, 0, 20338, 20336, 1, 0, 0, 0, 20339, 20340, 5, 2456, 0, 0, 20340, 20342, 3, 2334, 1167, 0, 20341, 20339, 1, 0, 0, 0, 20341, 20342, 1, 0, 0, 0, 20342, 2311, 1, 0, 0, 0, 20343, 20344, 3, 2404, 1202, 0, 20344, 2313, 1, 0, 0, 0, 20345, 20350, 3, 2404, 1202, 0, 20346, 20347, 5, 2440, 0, 0, 20347, 20349, 3, 2404, 1202, 0, 20348, 20346, 1, 0, 0, 0, 20349, 20352, 1, 0, 0, 0, 20350, 20348, 1, 0, 0, 0, 20350, 20351, 1, 0, 0, 0, 20351, 2315, 1, 0, 0, 0, 20352, 20350, 1, 0, 0, 0, 20353, 20358, 3, 2404, 1202, 0, 20354, 20355, 5, 2440, 0, 0, 20355, 20357, 3, 2404, 1202, 0, 20356, 20354, 1, 0, 0, 0, 20357, 20360, 1, 0, 0, 0, 20358, 20356, 1, 0, 0, 0, 20358, 20359, 1, 0, 0, 0, 20359, 2317, 1, 0, 0, 0, 20360, 20358, 1, 0, 0, 0, 20361, 20366, 3, 2402, 1201, 0, 20362, 20363, 5, 2440, 0, 0, 20363, 20365, 3, 2404, 1202, 0, 20364, 20362, 1, 0, 0, 0, 20365, 20368, 1, 0, 0, 0, 20366, 20364, 1, 0, 0, 0, 20366, 20367, 1, 0, 0, 0, 20367, 2319, 1, 0, 0, 0, 20368, 20366, 1, 0, 0, 0, 20369, 20372, 3, 2402, 1201, 0, 20370, 20371, 5, 2440, 0, 0, 20371, 20373, 3, 2404, 1202, 0, 20372, 20370, 1, 0, 0, 0, 20372, 20373, 1, 0, 0, 0, 20373, 2321, 1, 0, 0, 0, 20374, 20377, 3, 2402, 1201, 0, 20375, 20376, 5, 2440, 0, 0, 20376, 20378, 3, 2404, 1202, 0, 20377, 20375, 1, 0, 0, 0, 20377, 20378, 1, 0, 0, 0, 20378, 2323, 1, 0, 0, 0, 20379, 20382, 3, 2402, 1201, 0, 20380, 20381, 5, 2440, 0, 0, 20381, 20383, 3, 2404, 1202, 0, 20382, 20380, 1, 0, 0, 0, 20382, 20383, 1, 0, 0, 0, 20383, 2325, 1, 0, 0, 0, 20384, 20385, 5, 2475, 0, 0, 20385, 20387, 3, 2346, 1173, 0, 20386, 20384, 1, 0, 0, 0, 20386, 20387, 1, 0, 0, 0, 20387, 20388, 1, 0, 0, 0, 20388, 20391, 3, 2404, 1202, 0, 20389, 20390, 5, 2440, 0, 0, 20390, 20392, 3, 2404, 1202, 0, 20391, 20389, 1, 0, 0, 0, 20391, 20392, 1, 0, 0, 0, 20392, 20395, 1, 0, 0, 0, 20393, 20395, 3, 2382, 1191, 0, 20394, 20386, 1, 0, 0, 0, 20394, 20393, 1, 0, 0, 0, 20395, 2327, 1, 0, 0, 0, 20396, 20399, 3, 2402, 1201, 0, 20397, 20398, 5, 2440, 0, 0, 20398, 20400, 3, 2404, 1202, 0, 20399, 20397, 1, 0, 0, 0, 20399, 20400, 1, 0, 0, 0, 20400, 2329, 1, 0, 0, 0, 20401, 20404, 3, 2384, 1192, 0, 20402, 20404, 3, 2382, 1191, 0, 20403, 20401, 1, 0, 0, 0, 20403, 20402, 1, 0, 0, 0, 20404, 2331, 1, 0, 0, 0, 20405, 20408, 3, 2402, 1201, 0, 20406, 20408, 3, 2382, 1191, 0, 20407, 20405, 1, 0, 0, 0, 20407, 20406, 1, 0, 0, 0, 20408, 2333, 1, 0, 0, 0, 20409, 20414, 3, 1452, 726, 0, 20410, 20411, 5, 2440, 0, 0, 20411, 20413, 3, 1450, 725, 0, 20412, 20410, 1, 0, 0, 0, 20413, 20416, 1, 0, 0, 0, 20414, 20412, 1, 0, 0, 0, 20414, 20415, 1, 0, 0, 0, 20415, 20419, 1, 0, 0, 0, 20416, 20414, 1, 0, 0, 0, 20417, 20418, 5, 2456, 0, 0, 20418, 20420, 3, 2338, 1169, 0, 20419, 20417, 1, 0, 0, 0, 20419, 20420, 1, 0, 0, 0, 20420, 2335, 1, 0, 0, 0, 20421, 20422, 3, 2402, 1201, 0, 20422, 2337, 1, 0, 0, 0, 20423, 20424, 3, 2402, 1201, 0, 20424, 2339, 1, 0, 0, 0, 20425, 20430, 3, 2402, 1201, 0, 20426, 20427, 5, 2440, 0, 0, 20427, 20429, 3, 2404, 1202, 0, 20428, 20426, 1, 0, 0, 0, 20429, 20432, 1, 0, 0, 0, 20430, 20428, 1, 0, 0, 0, 20430, 20431, 1, 0, 0, 0, 20431, 2341, 1, 0, 0, 0, 20432, 20430, 1, 0, 0, 0, 20433, 20436, 3, 2402, 1201, 0, 20434, 20435, 5, 2440, 0, 0, 20435, 20437, 3, 2404, 1202, 0, 20436, 20434, 1, 0, 0, 0, 20436, 20437, 1, 0, 0, 0, 20437, 20441, 1, 0, 0, 0, 20438, 20439, 5, 2456, 0, 0, 20439, 20442, 3, 2334, 1167, 0, 20440, 20442, 3, 2266, 1133, 0, 20441, 20438, 1, 0, 0, 0, 20441, 20440, 1, 0, 0, 0, 20441, 20442, 1, 0, 0, 0, 20442, 20448, 1, 0, 0, 0, 20443, 20445, 3, 2344, 1172, 0, 20444, 20446, 3, 2408, 1204, 0, 20445, 20444, 1, 0, 0, 0, 20445, 20446, 1, 0, 0, 0, 20446, 20448, 1, 0, 0, 0, 20447, 20433, 1, 0, 0, 0, 20447, 20443, 1, 0, 0, 0, 20448, 2343, 1, 0, 0, 0, 20449, 20450, 5, 2347, 0, 0, 20450, 20454, 5, 2447, 0, 0, 20451, 20452, 3, 2228, 1114, 0, 20452, 20453, 5, 2453, 0, 0, 20453, 20455, 1, 0, 0, 0, 20454, 20451, 1, 0, 0, 0, 20454, 20455, 1, 0, 0, 0, 20455, 20456, 1, 0, 0, 0, 20456, 20458, 3, 2102, 1051, 0, 20457, 20459, 3, 2224, 1112, 0, 20458, 20457, 1, 0, 0, 0, 20458, 20459, 1, 0, 0, 0, 20459, 20469, 1, 0, 0, 0, 20460, 20461, 5, 238, 0, 0, 20461, 20466, 3, 2230, 1115, 0, 20462, 20463, 5, 2453, 0, 0, 20463, 20465, 3, 2230, 1115, 0, 20464, 20462, 1, 0, 0, 0, 20465, 20468, 1, 0, 0, 0, 20466, 20464, 1, 0, 0, 0, 20466, 20467, 1, 0, 0, 0, 20467, 20470, 1, 0, 0, 0, 20468, 20466, 1, 0, 0, 0, 20469, 20460, 1, 0, 0, 0, 20469, 20470, 1, 0, 0, 0, 20470, 20471, 1, 0, 0, 0, 20471, 20474, 5, 2448, 0, 0, 20472, 20473, 5, 2440, 0, 0, 20473, 20475, 3, 2386, 1193, 0, 20474, 20472, 1, 0, 0, 0, 20474, 20475, 1, 0, 0, 0, 20475, 2345, 1, 0, 0, 0, 20476, 20481, 3, 2404, 1202, 0, 20477, 20478, 5, 2440, 0, 0, 20478, 20480, 3, 2404, 1202, 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, 2347, 1, 0, 0, 0, 20483, 20481, 1, 0, 0, 0, 20484, 20485, 3, 2402, 1201, 0, 20485, 2349, 1, 0, 0, 0, 20486, 20487, 3, 2404, 1202, 0, 20487, 2351, 1, 0, 0, 0, 20488, 20489, 3, 2404, 1202, 0, 20489, 2353, 1, 0, 0, 0, 20490, 20491, 3, 2404, 1202, 0, 20491, 2355, 1, 0, 0, 0, 20492, 20517, 3, 2342, 1171, 0, 20493, 20494, 5, 2237, 0, 0, 20494, 20499, 3, 2354, 1177, 0, 20495, 20496, 5, 2453, 0, 0, 20496, 20498, 3, 2354, 1177, 0, 20497, 20495, 1, 0, 0, 0, 20498, 20501, 1, 0, 0, 0, 20499, 20497, 1, 0, 0, 0, 20499, 20500, 1, 0, 0, 0, 20500, 20517, 1, 0, 0, 0, 20501, 20499, 1, 0, 0, 0, 20502, 20503, 5, 426, 0, 0, 20503, 20517, 3, 2352, 1176, 0, 20504, 20505, 5, 483, 0, 0, 20505, 20517, 3, 2350, 1175, 0, 20506, 20507, 5, 955, 0, 0, 20507, 20508, 5, 971, 0, 0, 20508, 20517, 3, 2350, 1175, 0, 20509, 20510, 5, 792, 0, 0, 20510, 20511, 7, 86, 0, 0, 20511, 20517, 3, 2350, 1175, 0, 20512, 20513, 5, 1722, 0, 0, 20513, 20514, 5, 2154, 0, 0, 20514, 20515, 5, 1463, 0, 0, 20515, 20517, 3, 2350, 1175, 0, 20516, 20492, 1, 0, 0, 0, 20516, 20493, 1, 0, 0, 0, 20516, 20502, 1, 0, 0, 0, 20516, 20504, 1, 0, 0, 0, 20516, 20506, 1, 0, 0, 0, 20516, 20509, 1, 0, 0, 0, 20516, 20512, 1, 0, 0, 0, 20517, 2357, 1, 0, 0, 0, 20518, 20523, 3, 2340, 1170, 0, 20519, 20520, 5, 2453, 0, 0, 20520, 20522, 3, 2340, 1170, 0, 20521, 20519, 1, 0, 0, 0, 20522, 20525, 1, 0, 0, 0, 20523, 20521, 1, 0, 0, 0, 20523, 20524, 1, 0, 0, 0, 20524, 2359, 1, 0, 0, 0, 20525, 20523, 1, 0, 0, 0, 20526, 20527, 5, 2447, 0, 0, 20527, 20528, 3, 2358, 1179, 0, 20528, 20529, 5, 2448, 0, 0, 20529, 2361, 1, 0, 0, 0, 20530, 20531, 5, 814, 0, 0, 20531, 20532, 5, 2447, 0, 0, 20532, 20533, 5, 2392, 0, 0, 20533, 20536, 7, 56, 0, 0, 20534, 20537, 3, 1926, 963, 0, 20535, 20537, 3, 1994, 997, 0, 20536, 20534, 1, 0, 0, 0, 20536, 20535, 1, 0, 0, 0, 20537, 20538, 1, 0, 0, 0, 20538, 20540, 5, 2448, 0, 0, 20539, 20541, 3, 2202, 1101, 0, 20540, 20539, 1, 0, 0, 0, 20540, 20541, 1, 0, 0, 0, 20541, 2363, 1, 0, 0, 0, 20542, 20551, 5, 2447, 0, 0, 20543, 20548, 3, 2372, 1186, 0, 20544, 20545, 5, 2453, 0, 0, 20545, 20547, 3, 2372, 1186, 0, 20546, 20544, 1, 0, 0, 0, 20547, 20550, 1, 0, 0, 0, 20548, 20546, 1, 0, 0, 0, 20548, 20549, 1, 0, 0, 0, 20549, 20552, 1, 0, 0, 0, 20550, 20548, 1, 0, 0, 0, 20551, 20543, 1, 0, 0, 0, 20551, 20552, 1, 0, 0, 0, 20552, 20553, 1, 0, 0, 0, 20553, 20555, 5, 2448, 0, 0, 20554, 20556, 3, 2362, 1181, 0, 20555, 20554, 1, 0, 0, 0, 20555, 20556, 1, 0, 0, 0, 20556, 2365, 1, 0, 0, 0, 20557, 20572, 5, 2447, 0, 0, 20558, 20560, 3, 2372, 1186, 0, 20559, 20561, 3, 2370, 1185, 0, 20560, 20559, 1, 0, 0, 0, 20560, 20561, 1, 0, 0, 0, 20561, 20569, 1, 0, 0, 0, 20562, 20563, 5, 2453, 0, 0, 20563, 20565, 3, 2372, 1186, 0, 20564, 20566, 3, 2370, 1185, 0, 20565, 20564, 1, 0, 0, 0, 20565, 20566, 1, 0, 0, 0, 20566, 20568, 1, 0, 0, 0, 20567, 20562, 1, 0, 0, 0, 20568, 20571, 1, 0, 0, 0, 20569, 20567, 1, 0, 0, 0, 20569, 20570, 1, 0, 0, 0, 20570, 20573, 1, 0, 0, 0, 20571, 20569, 1, 0, 0, 0, 20572, 20558, 1, 0, 0, 0, 20572, 20573, 1, 0, 0, 0, 20573, 20574, 1, 0, 0, 0, 20574, 20576, 5, 2448, 0, 0, 20575, 20577, 3, 2362, 1181, 0, 20576, 20575, 1, 0, 0, 0, 20576, 20577, 1, 0, 0, 0, 20577, 2367, 1, 0, 0, 0, 20578, 20579, 5, 2447, 0, 0, 20579, 20592, 3, 2340, 1170, 0, 20580, 20583, 5, 2453, 0, 0, 20581, 20584, 3, 2396, 1198, 0, 20582, 20584, 5, 1228, 0, 0, 20583, 20581, 1, 0, 0, 0, 20583, 20582, 1, 0, 0, 0, 20584, 20590, 1, 0, 0, 0, 20585, 20588, 5, 2453, 0, 0, 20586, 20589, 3, 2396, 1198, 0, 20587, 20589, 5, 1228, 0, 0, 20588, 20586, 1, 0, 0, 0, 20588, 20587, 1, 0, 0, 0, 20589, 20591, 1, 0, 0, 0, 20590, 20585, 1, 0, 0, 0, 20590, 20591, 1, 0, 0, 0, 20591, 20593, 1, 0, 0, 0, 20592, 20580, 1, 0, 0, 0, 20592, 20593, 1, 0, 0, 0, 20593, 20594, 1, 0, 0, 0, 20594, 20614, 5, 2246, 0, 0, 20595, 20596, 3, 2342, 1171, 0, 20596, 20597, 5, 2440, 0, 0, 20597, 20598, 5, 2450, 0, 0, 20598, 20615, 1, 0, 0, 0, 20599, 20615, 5, 2450, 0, 0, 20600, 20602, 3, 2078, 1039, 0, 20601, 20603, 3, 2268, 1134, 0, 20602, 20601, 1, 0, 0, 0, 20602, 20603, 1, 0, 0, 0, 20603, 20611, 1, 0, 0, 0, 20604, 20605, 5, 2453, 0, 0, 20605, 20607, 3, 2078, 1039, 0, 20606, 20608, 3, 2268, 1134, 0, 20607, 20606, 1, 0, 0, 0, 20607, 20608, 1, 0, 0, 0, 20608, 20610, 1, 0, 0, 0, 20609, 20604, 1, 0, 0, 0, 20610, 20613, 1, 0, 0, 0, 20611, 20609, 1, 0, 0, 0, 20611, 20612, 1, 0, 0, 0, 20612, 20615, 1, 0, 0, 0, 20613, 20611, 1, 0, 0, 0, 20614, 20595, 1, 0, 0, 0, 20614, 20599, 1, 0, 0, 0, 20614, 20600, 1, 0, 0, 0, 20615, 20616, 1, 0, 0, 0, 20616, 20618, 5, 2448, 0, 0, 20617, 20619, 3, 2362, 1181, 0, 20618, 20617, 1, 0, 0, 0, 20618, 20619, 1, 0, 0, 0, 20619, 2369, 1, 0, 0, 0, 20620, 20621, 7, 275, 0, 0, 20621, 20622, 5, 1229, 0, 0, 20622, 2371, 1, 0, 0, 0, 20623, 20624, 3, 2402, 1201, 0, 20624, 20625, 5, 2472, 0, 0, 20625, 20626, 5, 2467, 0, 0, 20626, 20628, 1, 0, 0, 0, 20627, 20623, 1, 0, 0, 0, 20627, 20628, 1, 0, 0, 0, 20628, 20629, 1, 0, 0, 0, 20629, 20630, 3, 2078, 1039, 0, 20630, 2373, 1, 0, 0, 0, 20631, 20640, 3, 2376, 1188, 0, 20632, 20634, 5, 1530, 0, 0, 20633, 20632, 1, 0, 0, 0, 20633, 20634, 1, 0, 0, 0, 20634, 20635, 1, 0, 0, 0, 20635, 20637, 3, 2314, 1157, 0, 20636, 20638, 7, 276, 0, 0, 20637, 20636, 1, 0, 0, 0, 20637, 20638, 1, 0, 0, 0, 20638, 20640, 1, 0, 0, 0, 20639, 20631, 1, 0, 0, 0, 20639, 20633, 1, 0, 0, 0, 20640, 2375, 1, 0, 0, 0, 20641, 20643, 3, 2380, 1190, 0, 20642, 20644, 3, 2378, 1189, 0, 20643, 20642, 1, 0, 0, 0, 20643, 20644, 1, 0, 0, 0, 20644, 20654, 1, 0, 0, 0, 20645, 20647, 5, 2308, 0, 0, 20646, 20648, 5, 873, 0, 0, 20647, 20646, 1, 0, 0, 0, 20647, 20648, 1, 0, 0, 0, 20648, 20649, 1, 0, 0, 0, 20649, 20650, 5, 2112, 0, 0, 20650, 20655, 5, 2363, 0, 0, 20651, 20652, 5, 193, 0, 0, 20652, 20653, 5, 1671, 0, 0, 20653, 20655, 3, 2346, 1173, 0, 20654, 20645, 1, 0, 0, 0, 20654, 20651, 1, 0, 0, 0, 20654, 20655, 1, 0, 0, 0, 20655, 20673, 1, 0, 0, 0, 20656, 20657, 5, 776, 0, 0, 20657, 20662, 7, 277, 0, 0, 20658, 20659, 5, 2447, 0, 0, 20659, 20660, 3, 2078, 1039, 0, 20660, 20661, 5, 2448, 0, 0, 20661, 20663, 1, 0, 0, 0, 20662, 20658, 1, 0, 0, 0, 20662, 20663, 1, 0, 0, 0, 20663, 20664, 1, 0, 0, 0, 20664, 20665, 5, 2141, 0, 0, 20665, 20670, 7, 278, 0, 0, 20666, 20667, 5, 2447, 0, 0, 20667, 20668, 3, 2078, 1039, 0, 20668, 20669, 5, 2448, 0, 0, 20669, 20671, 1, 0, 0, 0, 20670, 20666, 1, 0, 0, 0, 20670, 20671, 1, 0, 0, 0, 20671, 20673, 1, 0, 0, 0, 20672, 20641, 1, 0, 0, 0, 20672, 20656, 1, 0, 0, 0, 20673, 2377, 1, 0, 0, 0, 20674, 20677, 5, 2447, 0, 0, 20675, 20678, 3, 2396, 1198, 0, 20676, 20678, 5, 2450, 0, 0, 20677, 20675, 1, 0, 0, 0, 20677, 20676, 1, 0, 0, 0, 20678, 20684, 1, 0, 0, 0, 20679, 20682, 5, 2453, 0, 0, 20680, 20683, 3, 2396, 1198, 0, 20681, 20683, 3, 2398, 1199, 0, 20682, 20680, 1, 0, 0, 0, 20682, 20681, 1, 0, 0, 0, 20683, 20685, 1, 0, 0, 0, 20684, 20679, 1, 0, 0, 0, 20684, 20685, 1, 0, 0, 0, 20685, 20687, 1, 0, 0, 0, 20686, 20688, 7, 238, 0, 0, 20687, 20686, 1, 0, 0, 0, 20687, 20688, 1, 0, 0, 0, 20688, 20689, 1, 0, 0, 0, 20689, 20690, 5, 2448, 0, 0, 20690, 2379, 1, 0, 0, 0, 20691, 20757, 5, 131, 0, 0, 20692, 20757, 5, 1403, 0, 0, 20693, 20757, 5, 1004, 0, 0, 20694, 20757, 5, 128, 0, 0, 20695, 20757, 5, 125, 0, 0, 20696, 20757, 5, 1005, 0, 0, 20697, 20757, 5, 1420, 0, 0, 20698, 20757, 5, 1419, 0, 0, 20699, 20757, 5, 1692, 0, 0, 20700, 20757, 5, 1693, 0, 0, 20701, 20757, 5, 1235, 0, 0, 20702, 20757, 5, 380, 0, 0, 20703, 20757, 5, 769, 0, 0, 20704, 20757, 5, 777, 0, 0, 20705, 20757, 5, 1231, 0, 0, 20706, 20757, 5, 1706, 0, 0, 20707, 20757, 5, 1230, 0, 0, 20708, 20757, 5, 381, 0, 0, 20709, 20711, 5, 465, 0, 0, 20710, 20712, 5, 1437, 0, 0, 20711, 20710, 1, 0, 0, 0, 20711, 20712, 1, 0, 0, 0, 20712, 20757, 1, 0, 0, 0, 20713, 20757, 5, 607, 0, 0, 20714, 20757, 5, 1509, 0, 0, 20715, 20757, 5, 1008, 0, 0, 20716, 20718, 5, 893, 0, 0, 20717, 20719, 5, 1498, 0, 0, 20718, 20717, 1, 0, 0, 0, 20718, 20719, 1, 0, 0, 0, 20719, 20757, 1, 0, 0, 0, 20720, 20757, 5, 196, 0, 0, 20721, 20723, 5, 193, 0, 0, 20722, 20724, 5, 2269, 0, 0, 20723, 20722, 1, 0, 0, 0, 20723, 20724, 1, 0, 0, 0, 20724, 20757, 1, 0, 0, 0, 20725, 20757, 5, 2259, 0, 0, 20726, 20757, 5, 2260, 0, 0, 20727, 20757, 5, 1767, 0, 0, 20728, 20757, 5, 1498, 0, 0, 20729, 20757, 5, 148, 0, 0, 20730, 20757, 5, 361, 0, 0, 20731, 20757, 5, 1601, 0, 0, 20732, 20757, 5, 2214, 0, 0, 20733, 20757, 5, 2358, 0, 0, 20734, 20757, 5, 985, 0, 0, 20735, 20757, 5, 365, 0, 0, 20736, 20757, 5, 679, 0, 0, 20737, 20757, 5, 958, 0, 0, 20738, 20757, 5, 1636, 0, 0, 20739, 20757, 5, 1633, 0, 0, 20740, 20757, 5, 2115, 0, 0, 20741, 20757, 5, 2116, 0, 0, 20742, 20757, 5, 2118, 0, 0, 20743, 20757, 5, 2114, 0, 0, 20744, 20757, 5, 2108, 0, 0, 20745, 20757, 5, 2110, 0, 0, 20746, 20757, 5, 2109, 0, 0, 20747, 20757, 5, 2107, 0, 0, 20748, 20757, 5, 2361, 0, 0, 20749, 20757, 5, 471, 0, 0, 20750, 20757, 5, 119, 0, 0, 20751, 20757, 5, 142, 0, 0, 20752, 20757, 5, 215, 0, 0, 20753, 20757, 5, 1010, 0, 0, 20754, 20757, 5, 966, 0, 0, 20755, 20757, 5, 2351, 0, 0, 20756, 20691, 1, 0, 0, 0, 20756, 20692, 1, 0, 0, 0, 20756, 20693, 1, 0, 0, 0, 20756, 20694, 1, 0, 0, 0, 20756, 20695, 1, 0, 0, 0, 20756, 20696, 1, 0, 0, 0, 20756, 20697, 1, 0, 0, 0, 20756, 20698, 1, 0, 0, 0, 20756, 20699, 1, 0, 0, 0, 20756, 20700, 1, 0, 0, 0, 20756, 20701, 1, 0, 0, 0, 20756, 20702, 1, 0, 0, 0, 20756, 20703, 1, 0, 0, 0, 20756, 20704, 1, 0, 0, 0, 20756, 20705, 1, 0, 0, 0, 20756, 20706, 1, 0, 0, 0, 20756, 20707, 1, 0, 0, 0, 20756, 20708, 1, 0, 0, 0, 20756, 20709, 1, 0, 0, 0, 20756, 20713, 1, 0, 0, 0, 20756, 20714, 1, 0, 0, 0, 20756, 20715, 1, 0, 0, 0, 20756, 20716, 1, 0, 0, 0, 20756, 20720, 1, 0, 0, 0, 20756, 20721, 1, 0, 0, 0, 20756, 20725, 1, 0, 0, 0, 20756, 20726, 1, 0, 0, 0, 20756, 20727, 1, 0, 0, 0, 20756, 20728, 1, 0, 0, 0, 20756, 20729, 1, 0, 0, 0, 20756, 20730, 1, 0, 0, 0, 20756, 20731, 1, 0, 0, 0, 20756, 20732, 1, 0, 0, 0, 20756, 20733, 1, 0, 0, 0, 20756, 20734, 1, 0, 0, 0, 20756, 20735, 1, 0, 0, 0, 20756, 20736, 1, 0, 0, 0, 20756, 20737, 1, 0, 0, 0, 20756, 20738, 1, 0, 0, 0, 20756, 20739, 1, 0, 0, 0, 20756, 20740, 1, 0, 0, 0, 20756, 20741, 1, 0, 0, 0, 20756, 20742, 1, 0, 0, 0, 20756, 20743, 1, 0, 0, 0, 20756, 20744, 1, 0, 0, 0, 20756, 20745, 1, 0, 0, 0, 20756, 20746, 1, 0, 0, 0, 20756, 20747, 1, 0, 0, 0, 20756, 20748, 1, 0, 0, 0, 20756, 20749, 1, 0, 0, 0, 20756, 20750, 1, 0, 0, 0, 20756, 20751, 1, 0, 0, 0, 20756, 20752, 1, 0, 0, 0, 20756, 20753, 1, 0, 0, 0, 20756, 20754, 1, 0, 0, 0, 20756, 20755, 1, 0, 0, 0, 20757, 2381, 1, 0, 0, 0, 20758, 20762, 5, 2462, 0, 0, 20759, 20760, 5, 2469, 0, 0, 20760, 20762, 5, 2441, 0, 0, 20761, 20758, 1, 0, 0, 0, 20761, 20759, 1, 0, 0, 0, 20762, 20771, 1, 0, 0, 0, 20763, 20765, 5, 733, 0, 0, 20764, 20763, 1, 0, 0, 0, 20764, 20765, 1, 0, 0, 0, 20765, 20769, 1, 0, 0, 0, 20766, 20770, 5, 2462, 0, 0, 20767, 20768, 5, 2469, 0, 0, 20768, 20770, 5, 2441, 0, 0, 20769, 20766, 1, 0, 0, 0, 20769, 20767, 1, 0, 0, 0, 20770, 20772, 1, 0, 0, 0, 20771, 20764, 1, 0, 0, 0, 20771, 20772, 1, 0, 0, 0, 20772, 20777, 1, 0, 0, 0, 20773, 20774, 5, 2440, 0, 0, 20774, 20776, 3, 2386, 1193, 0, 20775, 20773, 1, 0, 0, 0, 20776, 20779, 1, 0, 0, 0, 20777, 20775, 1, 0, 0, 0, 20777, 20778, 1, 0, 0, 0, 20778, 2383, 1, 0, 0, 0, 20779, 20777, 1, 0, 0, 0, 20780, 20781, 6, 1192, -1, 0, 20781, 20787, 3, 2386, 1193, 0, 20782, 20783, 5, 2447, 0, 0, 20783, 20784, 3, 2384, 1192, 0, 20784, 20785, 5, 2448, 0, 0, 20785, 20787, 1, 0, 0, 0, 20786, 20780, 1, 0, 0, 0, 20786, 20782, 1, 0, 0, 0, 20787, 20797, 1, 0, 0, 0, 20788, 20791, 10, 2, 0, 0, 20789, 20790, 5, 2440, 0, 0, 20790, 20792, 3, 2386, 1193, 0, 20791, 20789, 1, 0, 0, 0, 20792, 20793, 1, 0, 0, 0, 20793, 20791, 1, 0, 0, 0, 20793, 20794, 1, 0, 0, 0, 20794, 20796, 1, 0, 0, 0, 20795, 20788, 1, 0, 0, 0, 20796, 20799, 1, 0, 0, 0, 20797, 20795, 1, 0, 0, 0, 20797, 20798, 1, 0, 0, 0, 20798, 2385, 1, 0, 0, 0, 20799, 20797, 1, 0, 0, 0, 20800, 20801, 5, 2475, 0, 0, 20801, 20803, 3, 2346, 1173, 0, 20802, 20800, 1, 0, 0, 0, 20802, 20803, 1, 0, 0, 0, 20803, 20804, 1, 0, 0, 0, 20804, 20807, 3, 2404, 1202, 0, 20805, 20806, 5, 2456, 0, 0, 20806, 20808, 3, 2334, 1167, 0, 20807, 20805, 1, 0, 0, 0, 20807, 20808, 1, 0, 0, 0, 20808, 20812, 1, 0, 0, 0, 20809, 20811, 3, 2364, 1182, 0, 20810, 20809, 1, 0, 0, 0, 20811, 20814, 1, 0, 0, 0, 20812, 20810, 1, 0, 0, 0, 20812, 20813, 1, 0, 0, 0, 20813, 2387, 1, 0, 0, 0, 20814, 20812, 1, 0, 0, 0, 20815, 20816, 5, 2475, 0, 0, 20816, 20818, 3, 2346, 1173, 0, 20817, 20815, 1, 0, 0, 0, 20817, 20818, 1, 0, 0, 0, 20818, 20819, 1, 0, 0, 0, 20819, 20824, 3, 2404, 1202, 0, 20820, 20821, 5, 2440, 0, 0, 20821, 20823, 3, 2404, 1202, 0, 20822, 20820, 1, 0, 0, 0, 20823, 20826, 1, 0, 0, 0, 20824, 20822, 1, 0, 0, 0, 20824, 20825, 1, 0, 0, 0, 20825, 2389, 1, 0, 0, 0, 20826, 20824, 1, 0, 0, 0, 20827, 20829, 5, 38, 0, 0, 20828, 20830, 5, 1459, 0, 0, 20829, 20828, 1, 0, 0, 0, 20829, 20830, 1, 0, 0, 0, 20830, 20864, 1, 0, 0, 0, 20831, 20864, 5, 42, 0, 0, 20832, 20864, 5, 378, 0, 0, 20833, 20864, 5, 403, 0, 0, 20834, 20864, 5, 542, 0, 0, 20835, 20864, 5, 605, 0, 0, 20836, 20837, 5, 605, 0, 0, 20837, 20864, 5, 64, 0, 0, 20838, 20864, 5, 717, 0, 0, 20839, 20840, 5, 737, 0, 0, 20840, 20864, 5, 1459, 0, 0, 20841, 20842, 5, 737, 0, 0, 20842, 20843, 5, 1556, 0, 0, 20843, 20864, 5, 1459, 0, 0, 20844, 20864, 5, 756, 0, 0, 20845, 20846, 5, 814, 0, 0, 20846, 20864, 5, 1653, 0, 0, 20847, 20848, 5, 946, 0, 0, 20848, 20864, 5, 2286, 0, 0, 20849, 20850, 5, 1259, 0, 0, 20850, 20851, 5, 242, 0, 0, 20851, 20864, 5, 1531, 0, 0, 20852, 20853, 5, 1484, 0, 0, 20853, 20864, 5, 1591, 0, 0, 20854, 20864, 5, 1505, 0, 0, 20855, 20864, 5, 1528, 0, 0, 20856, 20864, 5, 1647, 0, 0, 20857, 20858, 5, 2153, 0, 0, 20858, 20864, 5, 1722, 0, 0, 20859, 20864, 5, 2177, 0, 0, 20860, 20864, 5, 2207, 0, 0, 20861, 20864, 5, 2241, 0, 0, 20862, 20864, 5, 2313, 0, 0, 20863, 20827, 1, 0, 0, 0, 20863, 20831, 1, 0, 0, 0, 20863, 20832, 1, 0, 0, 0, 20863, 20833, 1, 0, 0, 0, 20863, 20834, 1, 0, 0, 0, 20863, 20835, 1, 0, 0, 0, 20863, 20836, 1, 0, 0, 0, 20863, 20838, 1, 0, 0, 0, 20863, 20839, 1, 0, 0, 0, 20863, 20841, 1, 0, 0, 0, 20863, 20844, 1, 0, 0, 0, 20863, 20845, 1, 0, 0, 0, 20863, 20847, 1, 0, 0, 0, 20863, 20849, 1, 0, 0, 0, 20863, 20852, 1, 0, 0, 0, 20863, 20854, 1, 0, 0, 0, 20863, 20855, 1, 0, 0, 0, 20863, 20856, 1, 0, 0, 0, 20863, 20857, 1, 0, 0, 0, 20863, 20859, 1, 0, 0, 0, 20863, 20860, 1, 0, 0, 0, 20863, 20861, 1, 0, 0, 0, 20863, 20862, 1, 0, 0, 0, 20864, 2391, 1, 0, 0, 0, 20865, 20866, 5, 38, 0, 0, 20866, 21192, 5, 1459, 0, 0, 20867, 21192, 5, 31, 0, 0, 20868, 20870, 5, 27, 0, 0, 20869, 20871, 5, 55, 0, 0, 20870, 20869, 1, 0, 0, 0, 20870, 20871, 1, 0, 0, 0, 20871, 20872, 1, 0, 0, 0, 20872, 20873, 5, 1722, 0, 0, 20873, 20874, 5, 2163, 0, 0, 20874, 21192, 5, 1671, 0, 0, 20875, 20876, 7, 59, 0, 0, 20876, 20877, 5, 55, 0, 0, 20877, 20878, 5, 1722, 0, 0, 20878, 21192, 5, 1463, 0, 0, 20879, 20880, 5, 27, 0, 0, 20880, 20881, 5, 1722, 0, 0, 20881, 20882, 5, 906, 0, 0, 20882, 21192, 5, 1238, 0, 0, 20883, 20885, 5, 321, 0, 0, 20884, 20886, 5, 55, 0, 0, 20885, 20884, 1, 0, 0, 0, 20885, 20886, 1, 0, 0, 0, 20886, 20887, 1, 0, 0, 0, 20887, 21192, 5, 220, 0, 0, 20888, 20889, 7, 279, 0, 0, 20889, 20890, 5, 55, 0, 0, 20890, 21192, 5, 220, 0, 0, 20891, 20892, 7, 280, 0, 0, 20892, 20893, 5, 55, 0, 0, 20893, 21192, 5, 296, 0, 0, 20894, 20895, 5, 543, 0, 0, 20895, 20896, 5, 1520, 0, 0, 20896, 21192, 5, 1412, 0, 0, 20897, 20898, 5, 42, 0, 0, 20898, 21192, 5, 350, 0, 0, 20899, 20901, 7, 281, 0, 0, 20900, 20902, 5, 1473, 0, 0, 20901, 20900, 1, 0, 0, 0, 20901, 20902, 1, 0, 0, 0, 20902, 20903, 1, 0, 0, 0, 20903, 20904, 5, 350, 0, 0, 20904, 21192, 5, 861, 0, 0, 20905, 20906, 5, 469, 0, 0, 20906, 20907, 5, 1473, 0, 0, 20907, 20908, 5, 350, 0, 0, 20908, 21192, 5, 861, 0, 0, 20909, 20910, 5, 378, 0, 0, 20910, 20911, 5, 280, 0, 0, 20911, 21192, 5, 1667, 0, 0, 20912, 20913, 5, 378, 0, 0, 20913, 20914, 5, 55, 0, 0, 20914, 21192, 5, 1461, 0, 0, 20915, 20916, 5, 46, 0, 0, 20916, 20917, 5, 55, 0, 0, 20917, 21192, 5, 421, 0, 0, 20918, 20920, 5, 321, 0, 0, 20919, 20921, 5, 55, 0, 0, 20920, 20919, 1, 0, 0, 0, 20920, 20921, 1, 0, 0, 0, 20921, 20922, 1, 0, 0, 0, 20922, 21192, 5, 422, 0, 0, 20923, 20924, 7, 279, 0, 0, 20924, 20925, 5, 55, 0, 0, 20925, 21192, 5, 422, 0, 0, 20926, 20927, 7, 280, 0, 0, 20927, 20928, 5, 55, 0, 0, 20928, 21192, 5, 426, 0, 0, 20929, 20930, 7, 280, 0, 0, 20930, 20931, 5, 55, 0, 0, 20931, 21192, 5, 483, 0, 0, 20932, 20937, 5, 605, 0, 0, 20933, 20934, 5, 64, 0, 0, 20934, 20938, 5, 27, 0, 0, 20935, 20936, 5, 55, 0, 0, 20936, 20938, 5, 2083, 0, 0, 20937, 20933, 1, 0, 0, 0, 20937, 20935, 1, 0, 0, 0, 20938, 21192, 1, 0, 0, 0, 20939, 20940, 7, 59, 0, 0, 20940, 20941, 5, 55, 0, 0, 20941, 21192, 5, 717, 0, 0, 20942, 20944, 5, 321, 0, 0, 20943, 20945, 5, 55, 0, 0, 20944, 20943, 1, 0, 0, 0, 20944, 20945, 1, 0, 0, 0, 20945, 20946, 1, 0, 0, 0, 20946, 21192, 5, 731, 0, 0, 20947, 20948, 7, 282, 0, 0, 20948, 20949, 5, 55, 0, 0, 20949, 21192, 5, 731, 0, 0, 20950, 20952, 5, 321, 0, 0, 20951, 20953, 7, 283, 0, 0, 20952, 20951, 1, 0, 0, 0, 20952, 20953, 1, 0, 0, 0, 20953, 20954, 1, 0, 0, 0, 20954, 21192, 5, 793, 0, 0, 20955, 20956, 5, 542, 0, 0, 20956, 20957, 5, 55, 0, 0, 20957, 21192, 7, 284, 0, 0, 20958, 20959, 5, 905, 0, 0, 20959, 21192, 5, 1623, 0, 0, 20960, 20961, 5, 27, 0, 0, 20961, 20962, 5, 816, 0, 0, 20962, 21192, 5, 906, 0, 0, 20963, 20965, 5, 321, 0, 0, 20964, 20966, 5, 55, 0, 0, 20965, 20964, 1, 0, 0, 0, 20965, 20966, 1, 0, 0, 0, 20966, 20967, 1, 0, 0, 0, 20967, 21192, 5, 849, 0, 0, 20968, 20969, 7, 282, 0, 0, 20969, 20970, 5, 55, 0, 0, 20970, 21192, 5, 849, 0, 0, 20971, 21192, 5, 889, 0, 0, 20972, 20974, 5, 321, 0, 0, 20973, 20975, 5, 55, 0, 0, 20974, 20973, 1, 0, 0, 0, 20974, 20975, 1, 0, 0, 0, 20975, 20976, 1, 0, 0, 0, 20976, 20977, 5, 919, 0, 0, 20977, 21192, 5, 2286, 0, 0, 20978, 20979, 7, 279, 0, 0, 20979, 20980, 5, 55, 0, 0, 20980, 20981, 5, 919, 0, 0, 20981, 21192, 5, 2286, 0, 0, 20982, 20984, 5, 642, 0, 0, 20983, 20982, 1, 0, 0, 0, 20983, 20984, 1, 0, 0, 0, 20984, 20985, 1, 0, 0, 0, 20985, 20986, 5, 1484, 0, 0, 20986, 21192, 5, 1591, 0, 0, 20987, 20988, 5, 1259, 0, 0, 20988, 20989, 5, 242, 0, 0, 20989, 21192, 5, 1531, 0, 0, 20990, 20992, 5, 321, 0, 0, 20991, 20993, 5, 55, 0, 0, 20992, 20991, 1, 0, 0, 0, 20992, 20993, 1, 0, 0, 0, 20993, 20994, 1, 0, 0, 0, 20994, 20995, 5, 955, 0, 0, 20995, 21192, 5, 971, 0, 0, 20996, 20997, 7, 285, 0, 0, 20997, 20998, 5, 55, 0, 0, 20998, 20999, 5, 955, 0, 0, 20999, 21192, 5, 971, 0, 0, 21000, 21002, 5, 321, 0, 0, 21001, 21003, 5, 55, 0, 0, 21002, 21001, 1, 0, 0, 0, 21002, 21003, 1, 0, 0, 0, 21003, 21004, 1, 0, 0, 0, 21004, 21192, 5, 332, 0, 0, 21005, 21006, 7, 286, 0, 0, 21006, 21007, 5, 55, 0, 0, 21007, 21192, 5, 332, 0, 0, 21008, 21010, 5, 321, 0, 0, 21009, 21011, 5, 55, 0, 0, 21010, 21009, 1, 0, 0, 0, 21010, 21011, 1, 0, 0, 0, 21011, 21012, 1, 0, 0, 0, 21012, 21013, 5, 933, 0, 0, 21013, 21192, 5, 612, 0, 0, 21014, 21015, 7, 287, 0, 0, 21015, 21016, 5, 55, 0, 0, 21016, 21017, 5, 933, 0, 0, 21017, 21192, 5, 612, 0, 0, 21018, 21020, 5, 321, 0, 0, 21019, 21021, 5, 55, 0, 0, 21020, 21019, 1, 0, 0, 0, 21020, 21021, 1, 0, 0, 0, 21021, 21022, 1, 0, 0, 0, 21022, 21023, 5, 332, 0, 0, 21023, 21192, 5, 422, 0, 0, 21024, 21025, 7, 288, 0, 0, 21025, 21026, 5, 55, 0, 0, 21026, 21027, 5, 332, 0, 0, 21027, 21192, 5, 422, 0, 0, 21028, 21030, 5, 321, 0, 0, 21029, 21031, 5, 55, 0, 0, 21030, 21029, 1, 0, 0, 0, 21030, 21031, 1, 0, 0, 0, 21031, 21032, 1, 0, 0, 0, 21032, 21033, 5, 332, 0, 0, 21033, 21034, 5, 158, 0, 0, 21034, 21192, 5, 1462, 0, 0, 21035, 21036, 7, 289, 0, 0, 21036, 21037, 5, 55, 0, 0, 21037, 21038, 5, 332, 0, 0, 21038, 21039, 5, 158, 0, 0, 21039, 21192, 5, 1462, 0, 0, 21040, 21042, 5, 321, 0, 0, 21041, 21043, 5, 55, 0, 0, 21042, 21041, 1, 0, 0, 0, 21042, 21043, 1, 0, 0, 0, 21043, 21044, 1, 0, 0, 0, 21044, 21192, 5, 1266, 0, 0, 21045, 21046, 7, 282, 0, 0, 21046, 21047, 5, 55, 0, 0, 21047, 21192, 5, 1266, 0, 0, 21048, 21049, 7, 59, 0, 0, 21049, 21050, 5, 55, 0, 0, 21050, 21192, 5, 1315, 0, 0, 21051, 21052, 5, 321, 0, 0, 21052, 21053, 5, 1409, 0, 0, 21053, 21192, 5, 350, 0, 0, 21054, 21055, 5, 1671, 0, 0, 21055, 21192, 5, 289, 0, 0, 21056, 21058, 5, 321, 0, 0, 21057, 21059, 5, 55, 0, 0, 21058, 21057, 1, 0, 0, 0, 21058, 21059, 1, 0, 0, 0, 21059, 21060, 1, 0, 0, 0, 21060, 21192, 5, 1461, 0, 0, 21061, 21062, 7, 282, 0, 0, 21062, 21063, 5, 55, 0, 0, 21063, 21192, 5, 1461, 0, 0, 21064, 21065, 7, 59, 0, 0, 21065, 21192, 5, 1463, 0, 0, 21066, 21067, 5, 321, 0, 0, 21067, 21192, 5, 1593, 0, 0, 21068, 21069, 7, 290, 0, 0, 21069, 21070, 5, 55, 0, 0, 21070, 21192, 5, 1593, 0, 0, 21071, 21072, 7, 59, 0, 0, 21072, 21073, 5, 1596, 0, 0, 21073, 21192, 5, 1645, 0, 0, 21074, 21076, 5, 321, 0, 0, 21075, 21077, 5, 55, 0, 0, 21076, 21075, 1, 0, 0, 0, 21076, 21077, 1, 0, 0, 0, 21077, 21078, 1, 0, 0, 0, 21078, 21192, 5, 1653, 0, 0, 21079, 21080, 7, 291, 0, 0, 21080, 21081, 5, 55, 0, 0, 21081, 21192, 5, 1653, 0, 0, 21082, 21083, 7, 292, 0, 0, 21083, 21192, 5, 1667, 0, 0, 21084, 21085, 5, 42, 0, 0, 21085, 21086, 5, 1570, 0, 0, 21086, 21192, 5, 311, 0, 0, 21087, 21089, 5, 321, 0, 0, 21088, 21090, 5, 55, 0, 0, 21089, 21088, 1, 0, 0, 0, 21089, 21090, 1, 0, 0, 0, 21090, 21091, 1, 0, 0, 0, 21091, 21092, 5, 1722, 0, 0, 21092, 21093, 5, 2154, 0, 0, 21093, 21192, 5, 1463, 0, 0, 21094, 21095, 7, 293, 0, 0, 21095, 21096, 5, 55, 0, 0, 21096, 21097, 5, 1722, 0, 0, 21097, 21098, 5, 2154, 0, 0, 21098, 21192, 5, 1463, 0, 0, 21099, 21100, 5, 2153, 0, 0, 21100, 21101, 5, 55, 0, 0, 21101, 21192, 5, 1722, 0, 0, 21102, 21104, 5, 321, 0, 0, 21103, 21105, 5, 55, 0, 0, 21104, 21103, 1, 0, 0, 0, 21104, 21105, 1, 0, 0, 0, 21105, 21106, 1, 0, 0, 0, 21106, 21192, 5, 1796, 0, 0, 21107, 21108, 5, 469, 0, 0, 21108, 21109, 5, 55, 0, 0, 21109, 21192, 5, 1796, 0, 0, 21110, 21111, 7, 280, 0, 0, 21111, 21112, 5, 1473, 0, 0, 21112, 21192, 5, 1796, 0, 0, 21113, 21115, 5, 321, 0, 0, 21114, 21116, 5, 55, 0, 0, 21115, 21114, 1, 0, 0, 0, 21115, 21116, 1, 0, 0, 0, 21116, 21117, 1, 0, 0, 0, 21117, 21192, 5, 2083, 0, 0, 21118, 21119, 7, 294, 0, 0, 21119, 21120, 5, 55, 0, 0, 21120, 21192, 5, 2083, 0, 0, 21121, 21122, 7, 295, 0, 0, 21122, 21192, 5, 2080, 0, 0, 21123, 21125, 5, 321, 0, 0, 21124, 21126, 5, 55, 0, 0, 21125, 21124, 1, 0, 0, 0, 21125, 21126, 1, 0, 0, 0, 21126, 21127, 1, 0, 0, 0, 21127, 21192, 5, 2157, 0, 0, 21128, 21129, 7, 279, 0, 0, 21129, 21130, 5, 55, 0, 0, 21130, 21192, 5, 2157, 0, 0, 21131, 21132, 5, 27, 0, 0, 21132, 21133, 5, 350, 0, 0, 21133, 21192, 5, 2157, 0, 0, 21134, 21136, 5, 321, 0, 0, 21135, 21137, 5, 55, 0, 0, 21136, 21135, 1, 0, 0, 0, 21136, 21137, 1, 0, 0, 0, 21137, 21138, 1, 0, 0, 0, 21138, 21192, 5, 2166, 0, 0, 21139, 21140, 7, 296, 0, 0, 21140, 21141, 5, 55, 0, 0, 21141, 21192, 5, 2166, 0, 0, 21142, 21143, 7, 59, 0, 0, 21143, 21192, 5, 2237, 0, 0, 21144, 21146, 5, 321, 0, 0, 21145, 21147, 5, 55, 0, 0, 21146, 21145, 1, 0, 0, 0, 21146, 21147, 1, 0, 0, 0, 21147, 21148, 1, 0, 0, 0, 21148, 21192, 5, 2286, 0, 0, 21149, 21150, 7, 297, 0, 0, 21150, 21151, 5, 55, 0, 0, 21151, 21192, 5, 2286, 0, 0, 21152, 21153, 7, 298, 0, 0, 21153, 21192, 5, 55, 0, 0, 21154, 21155, 5, 111, 0, 0, 21155, 21192, 5, 2237, 0, 0, 21156, 21157, 5, 190, 0, 0, 21157, 21192, 5, 1202, 0, 0, 21158, 21159, 5, 543, 0, 0, 21159, 21160, 5, 4, 0, 0, 21160, 21192, 5, 1412, 0, 0, 21161, 21163, 5, 616, 0, 0, 21162, 21164, 5, 55, 0, 0, 21163, 21162, 1, 0, 0, 0, 21163, 21164, 1, 0, 0, 0, 21164, 21165, 1, 0, 0, 0, 21165, 21192, 5, 2147, 0, 0, 21166, 21167, 5, 647, 0, 0, 21167, 21169, 5, 55, 0, 0, 21168, 21170, 5, 1238, 0, 0, 21169, 21168, 1, 0, 0, 0, 21169, 21170, 1, 0, 0, 0, 21170, 21171, 1, 0, 0, 0, 21171, 21192, 5, 1458, 0, 0, 21172, 21173, 5, 737, 0, 0, 21173, 21174, 5, 55, 0, 0, 21174, 21192, 5, 1459, 0, 0, 21175, 21176, 5, 814, 0, 0, 21176, 21177, 5, 361, 0, 0, 21177, 21192, 5, 2112, 0, 0, 21178, 21179, 5, 814, 0, 0, 21179, 21192, 5, 1832, 0, 0, 21180, 21181, 5, 1475, 0, 0, 21181, 21192, 5, 369, 0, 0, 21182, 21192, 5, 1581, 0, 0, 21183, 21184, 5, 1647, 0, 0, 21184, 21185, 5, 55, 0, 0, 21185, 21192, 7, 299, 0, 0, 21186, 21192, 5, 1801, 0, 0, 21187, 21192, 5, 1807, 0, 0, 21188, 21192, 5, 1809, 0, 0, 21189, 21192, 5, 1833, 0, 0, 21190, 21192, 5, 1868, 0, 0, 21191, 20865, 1, 0, 0, 0, 21191, 20867, 1, 0, 0, 0, 21191, 20868, 1, 0, 0, 0, 21191, 20875, 1, 0, 0, 0, 21191, 20879, 1, 0, 0, 0, 21191, 20883, 1, 0, 0, 0, 21191, 20888, 1, 0, 0, 0, 21191, 20891, 1, 0, 0, 0, 21191, 20894, 1, 0, 0, 0, 21191, 20897, 1, 0, 0, 0, 21191, 20899, 1, 0, 0, 0, 21191, 20905, 1, 0, 0, 0, 21191, 20909, 1, 0, 0, 0, 21191, 20912, 1, 0, 0, 0, 21191, 20915, 1, 0, 0, 0, 21191, 20918, 1, 0, 0, 0, 21191, 20923, 1, 0, 0, 0, 21191, 20926, 1, 0, 0, 0, 21191, 20929, 1, 0, 0, 0, 21191, 20932, 1, 0, 0, 0, 21191, 20939, 1, 0, 0, 0, 21191, 20942, 1, 0, 0, 0, 21191, 20947, 1, 0, 0, 0, 21191, 20950, 1, 0, 0, 0, 21191, 20955, 1, 0, 0, 0, 21191, 20958, 1, 0, 0, 0, 21191, 20960, 1, 0, 0, 0, 21191, 20963, 1, 0, 0, 0, 21191, 20968, 1, 0, 0, 0, 21191, 20971, 1, 0, 0, 0, 21191, 20972, 1, 0, 0, 0, 21191, 20978, 1, 0, 0, 0, 21191, 20983, 1, 0, 0, 0, 21191, 20987, 1, 0, 0, 0, 21191, 20990, 1, 0, 0, 0, 21191, 20996, 1, 0, 0, 0, 21191, 21000, 1, 0, 0, 0, 21191, 21005, 1, 0, 0, 0, 21191, 21008, 1, 0, 0, 0, 21191, 21014, 1, 0, 0, 0, 21191, 21018, 1, 0, 0, 0, 21191, 21024, 1, 0, 0, 0, 21191, 21028, 1, 0, 0, 0, 21191, 21035, 1, 0, 0, 0, 21191, 21040, 1, 0, 0, 0, 21191, 21045, 1, 0, 0, 0, 21191, 21048, 1, 0, 0, 0, 21191, 21051, 1, 0, 0, 0, 21191, 21054, 1, 0, 0, 0, 21191, 21056, 1, 0, 0, 0, 21191, 21061, 1, 0, 0, 0, 21191, 21064, 1, 0, 0, 0, 21191, 21066, 1, 0, 0, 0, 21191, 21068, 1, 0, 0, 0, 21191, 21071, 1, 0, 0, 0, 21191, 21074, 1, 0, 0, 0, 21191, 21079, 1, 0, 0, 0, 21191, 21082, 1, 0, 0, 0, 21191, 21084, 1, 0, 0, 0, 21191, 21087, 1, 0, 0, 0, 21191, 21094, 1, 0, 0, 0, 21191, 21099, 1, 0, 0, 0, 21191, 21102, 1, 0, 0, 0, 21191, 21107, 1, 0, 0, 0, 21191, 21110, 1, 0, 0, 0, 21191, 21113, 1, 0, 0, 0, 21191, 21118, 1, 0, 0, 0, 21191, 21121, 1, 0, 0, 0, 21191, 21123, 1, 0, 0, 0, 21191, 21128, 1, 0, 0, 0, 21191, 21131, 1, 0, 0, 0, 21191, 21134, 1, 0, 0, 0, 21191, 21139, 1, 0, 0, 0, 21191, 21142, 1, 0, 0, 0, 21191, 21144, 1, 0, 0, 0, 21191, 21149, 1, 0, 0, 0, 21191, 21152, 1, 0, 0, 0, 21191, 21154, 1, 0, 0, 0, 21191, 21156, 1, 0, 0, 0, 21191, 21158, 1, 0, 0, 0, 21191, 21161, 1, 0, 0, 0, 21191, 21166, 1, 0, 0, 0, 21191, 21172, 1, 0, 0, 0, 21191, 21175, 1, 0, 0, 0, 21191, 21178, 1, 0, 0, 0, 21191, 21180, 1, 0, 0, 0, 21191, 21182, 1, 0, 0, 0, 21191, 21183, 1, 0, 0, 0, 21191, 21186, 1, 0, 0, 0, 21191, 21187, 1, 0, 0, 0, 21191, 21188, 1, 0, 0, 0, 21191, 21189, 1, 0, 0, 0, 21191, 21190, 1, 0, 0, 0, 21192, 2393, 1, 0, 0, 0, 21193, 21196, 5, 2108, 0, 0, 21194, 21197, 3, 2400, 1200, 0, 21195, 21197, 3, 2382, 1191, 0, 21196, 21194, 1, 0, 0, 0, 21196, 21195, 1, 0, 0, 0, 21197, 21202, 1, 0, 0, 0, 21198, 21199, 5, 82, 0, 0, 21199, 21200, 5, 2112, 0, 0, 21200, 21201, 5, 2363, 0, 0, 21201, 21203, 3, 2400, 1200, 0, 21202, 21198, 1, 0, 0, 0, 21202, 21203, 1, 0, 0, 0, 21203, 21257, 1, 0, 0, 0, 21204, 21208, 5, 776, 0, 0, 21205, 21209, 3, 2400, 1200, 0, 21206, 21209, 3, 2382, 1191, 0, 21207, 21209, 3, 2386, 1193, 0, 21208, 21205, 1, 0, 0, 0, 21208, 21206, 1, 0, 0, 0, 21208, 21207, 1, 0, 0, 0, 21209, 21210, 1, 0, 0, 0, 21210, 21224, 7, 300, 0, 0, 21211, 21214, 5, 2447, 0, 0, 21212, 21215, 5, 2441, 0, 0, 21213, 21215, 3, 2382, 1191, 0, 21214, 21212, 1, 0, 0, 0, 21214, 21213, 1, 0, 0, 0, 21215, 21221, 1, 0, 0, 0, 21216, 21219, 5, 2453, 0, 0, 21217, 21220, 5, 2441, 0, 0, 21218, 21220, 3, 2382, 1191, 0, 21219, 21217, 1, 0, 0, 0, 21219, 21218, 1, 0, 0, 0, 21220, 21222, 1, 0, 0, 0, 21221, 21216, 1, 0, 0, 0, 21221, 21222, 1, 0, 0, 0, 21222, 21223, 1, 0, 0, 0, 21223, 21225, 5, 2448, 0, 0, 21224, 21211, 1, 0, 0, 0, 21224, 21225, 1, 0, 0, 0, 21225, 21242, 1, 0, 0, 0, 21226, 21240, 5, 2141, 0, 0, 21227, 21241, 5, 985, 0, 0, 21228, 21241, 5, 365, 0, 0, 21229, 21241, 5, 679, 0, 0, 21230, 21241, 5, 958, 0, 0, 21231, 21238, 5, 1636, 0, 0, 21232, 21235, 5, 2447, 0, 0, 21233, 21236, 5, 2441, 0, 0, 21234, 21236, 3, 2382, 1191, 0, 21235, 21233, 1, 0, 0, 0, 21235, 21234, 1, 0, 0, 0, 21236, 21237, 1, 0, 0, 0, 21237, 21239, 5, 2448, 0, 0, 21238, 21232, 1, 0, 0, 0, 21238, 21239, 1, 0, 0, 0, 21239, 21241, 1, 0, 0, 0, 21240, 21227, 1, 0, 0, 0, 21240, 21228, 1, 0, 0, 0, 21240, 21229, 1, 0, 0, 0, 21240, 21230, 1, 0, 0, 0, 21240, 21231, 1, 0, 0, 0, 21241, 21243, 1, 0, 0, 0, 21242, 21226, 1, 0, 0, 0, 21242, 21243, 1, 0, 0, 0, 21243, 21257, 1, 0, 0, 0, 21244, 21257, 3, 2396, 1198, 0, 21245, 21246, 5, 361, 0, 0, 21246, 21257, 3, 2400, 1200, 0, 21247, 21257, 3, 2400, 1200, 0, 21248, 21257, 5, 1228, 0, 0, 21249, 21257, 5, 2158, 0, 0, 21250, 21257, 5, 575, 0, 0, 21251, 21257, 5, 373, 0, 0, 21252, 21257, 5, 1669, 0, 0, 21253, 21257, 5, 960, 0, 0, 21254, 21257, 5, 932, 0, 0, 21255, 21257, 5, 389, 0, 0, 21256, 21193, 1, 0, 0, 0, 21256, 21204, 1, 0, 0, 0, 21256, 21244, 1, 0, 0, 0, 21256, 21245, 1, 0, 0, 0, 21256, 21247, 1, 0, 0, 0, 21256, 21248, 1, 0, 0, 0, 21256, 21249, 1, 0, 0, 0, 21256, 21250, 1, 0, 0, 0, 21256, 21251, 1, 0, 0, 0, 21256, 21252, 1, 0, 0, 0, 21256, 21253, 1, 0, 0, 0, 21256, 21254, 1, 0, 0, 0, 21256, 21255, 1, 0, 0, 0, 21257, 2395, 1, 0, 0, 0, 21258, 21260, 5, 2441, 0, 0, 21259, 21261, 5, 2440, 0, 0, 21260, 21259, 1, 0, 0, 0, 21260, 21261, 1, 0, 0, 0, 21261, 21264, 1, 0, 0, 0, 21262, 21264, 5, 2442, 0, 0, 21263, 21258, 1, 0, 0, 0, 21263, 21262, 1, 0, 0, 0, 21264, 2397, 1, 0, 0, 0, 21265, 21266, 5, 2452, 0, 0, 21266, 21267, 3, 2396, 1198, 0, 21267, 2399, 1, 0, 0, 0, 21268, 21269, 7, 301, 0, 0, 21269, 2401, 1, 0, 0, 0, 21270, 21271, 5, 2475, 0, 0, 21271, 21273, 3, 2346, 1173, 0, 21272, 21270, 1, 0, 0, 0, 21272, 21273, 1, 0, 0, 0, 21273, 21274, 1, 0, 0, 0, 21274, 21275, 3, 2404, 1202, 0, 21275, 2403, 1, 0, 0, 0, 21276, 21279, 3, 2410, 1205, 0, 21277, 21279, 5, 2444, 0, 0, 21278, 21276, 1, 0, 0, 0, 21278, 21277, 1, 0, 0, 0, 21279, 2405, 1, 0, 0, 0, 21280, 21281, 5, 2481, 0, 0, 21281, 2407, 1, 0, 0, 0, 21282, 21283, 5, 2447, 0, 0, 21283, 21284, 5, 2451, 0, 0, 21284, 21285, 5, 2448, 0, 0, 21285, 2409, 1, 0, 0, 0, 21286, 21409, 3, 2416, 1208, 0, 21287, 21409, 3, 2414, 1207, 0, 21288, 21409, 3, 2412, 1206, 0, 21289, 21409, 5, 2480, 0, 0, 21290, 21409, 5, 85, 0, 0, 21291, 21409, 5, 789, 0, 0, 21292, 21409, 5, 164, 0, 0, 21293, 21409, 5, 860, 0, 0, 21294, 21409, 5, 1513, 0, 0, 21295, 21409, 5, 1022, 0, 0, 21296, 21409, 5, 587, 0, 0, 21297, 21409, 5, 912, 0, 0, 21298, 21409, 5, 3, 0, 0, 21299, 21409, 5, 36, 0, 0, 21300, 21409, 5, 34, 0, 0, 21301, 21409, 5, 35, 0, 0, 21302, 21409, 5, 46, 0, 0, 21303, 21409, 5, 96, 0, 0, 21304, 21409, 5, 101, 0, 0, 21305, 21409, 5, 108, 0, 0, 21306, 21409, 5, 131, 0, 0, 21307, 21409, 5, 148, 0, 0, 21308, 21409, 5, 213, 0, 0, 21309, 21409, 5, 196, 0, 0, 21310, 21409, 5, 2426, 0, 0, 21311, 21409, 5, 2427, 0, 0, 21312, 21409, 5, 220, 0, 0, 21313, 21409, 5, 288, 0, 0, 21314, 21409, 5, 346, 0, 0, 21315, 21409, 5, 182, 0, 0, 21316, 21409, 5, 381, 0, 0, 21317, 21409, 5, 403, 0, 0, 21318, 21409, 5, 409, 0, 0, 21319, 21409, 5, 420, 0, 0, 21320, 21409, 5, 471, 0, 0, 21321, 21409, 5, 2428, 0, 0, 21322, 21409, 5, 480, 0, 0, 21323, 21409, 5, 500, 0, 0, 21324, 21409, 5, 523, 0, 0, 21325, 21409, 5, 524, 0, 0, 21326, 21409, 5, 518, 0, 0, 21327, 21409, 5, 535, 0, 0, 21328, 21409, 5, 536, 0, 0, 21329, 21409, 5, 537, 0, 0, 21330, 21409, 5, 545, 0, 0, 21331, 21409, 5, 547, 0, 0, 21332, 21409, 5, 2429, 0, 0, 21333, 21409, 5, 588, 0, 0, 21334, 21409, 5, 592, 0, 0, 21335, 21409, 5, 607, 0, 0, 21336, 21409, 5, 615, 0, 0, 21337, 21409, 5, 635, 0, 0, 21338, 21409, 5, 734, 0, 0, 21339, 21409, 5, 750, 0, 0, 21340, 21409, 5, 769, 0, 0, 21341, 21409, 5, 778, 0, 0, 21342, 21409, 5, 810, 0, 0, 21343, 21409, 5, 812, 0, 0, 21344, 21409, 5, 823, 0, 0, 21345, 21409, 5, 893, 0, 0, 21346, 21409, 5, 894, 0, 0, 21347, 21409, 5, 2430, 0, 0, 21348, 21409, 5, 990, 0, 0, 21349, 21409, 5, 901, 0, 0, 21350, 21409, 5, 964, 0, 0, 21351, 21409, 5, 965, 0, 0, 21352, 21409, 5, 1230, 0, 0, 21353, 21409, 5, 1279, 0, 0, 21354, 21409, 5, 1280, 0, 0, 21355, 21409, 5, 1309, 0, 0, 21356, 21409, 5, 1318, 0, 0, 21357, 21409, 5, 1324, 0, 0, 21358, 21409, 5, 1328, 0, 0, 21359, 21409, 5, 1331, 0, 0, 21360, 21409, 5, 1394, 0, 0, 21361, 21409, 5, 1403, 0, 0, 21362, 21409, 5, 1410, 0, 0, 21363, 21409, 5, 1420, 0, 0, 21364, 21409, 5, 1419, 0, 0, 21365, 21409, 5, 1433, 0, 0, 21366, 21409, 5, 1473, 0, 0, 21367, 21409, 5, 1492, 0, 0, 21368, 21409, 5, 1498, 0, 0, 21369, 21409, 5, 1512, 0, 0, 21370, 21409, 5, 1530, 0, 0, 21371, 21409, 5, 1559, 0, 0, 21372, 21409, 5, 1577, 0, 0, 21373, 21409, 5, 1580, 0, 0, 21374, 21409, 5, 1633, 0, 0, 21375, 21409, 5, 1648, 0, 0, 21376, 21409, 5, 1660, 0, 0, 21377, 21409, 5, 1671, 0, 0, 21378, 21409, 5, 1656, 0, 0, 21379, 21409, 5, 1677, 0, 0, 21380, 21409, 5, 1692, 0, 0, 21381, 21409, 5, 1693, 0, 0, 21382, 21409, 5, 1706, 0, 0, 21383, 21409, 5, 2433, 0, 0, 21384, 21409, 5, 1719, 0, 0, 21385, 21409, 5, 1720, 0, 0, 21386, 21409, 5, 1785, 0, 0, 21387, 21409, 5, 2077, 0, 0, 21388, 21409, 5, 2434, 0, 0, 21389, 21409, 5, 2107, 0, 0, 21390, 21409, 5, 2109, 0, 0, 21391, 21409, 5, 2110, 0, 0, 21392, 21409, 5, 2113, 0, 0, 21393, 21409, 5, 2157, 0, 0, 21394, 21409, 5, 2171, 0, 0, 21395, 21409, 5, 2260, 0, 0, 21396, 21409, 5, 2259, 0, 0, 21397, 21409, 5, 2262, 0, 0, 21398, 21409, 5, 2295, 0, 0, 21399, 21409, 5, 2302, 0, 0, 21400, 21409, 5, 2435, 0, 0, 21401, 21409, 5, 2319, 0, 0, 21402, 21409, 5, 2361, 0, 0, 21403, 21409, 5, 2413, 0, 0, 21404, 21409, 5, 2421, 0, 0, 21405, 21409, 5, 2258, 0, 0, 21406, 21409, 5, 2400, 0, 0, 21407, 21409, 5, 363, 0, 0, 21408, 21286, 1, 0, 0, 0, 21408, 21287, 1, 0, 0, 0, 21408, 21288, 1, 0, 0, 0, 21408, 21289, 1, 0, 0, 0, 21408, 21290, 1, 0, 0, 0, 21408, 21291, 1, 0, 0, 0, 21408, 21292, 1, 0, 0, 0, 21408, 21293, 1, 0, 0, 0, 21408, 21294, 1, 0, 0, 0, 21408, 21295, 1, 0, 0, 0, 21408, 21296, 1, 0, 0, 0, 21408, 21297, 1, 0, 0, 0, 21408, 21298, 1, 0, 0, 0, 21408, 21299, 1, 0, 0, 0, 21408, 21300, 1, 0, 0, 0, 21408, 21301, 1, 0, 0, 0, 21408, 21302, 1, 0, 0, 0, 21408, 21303, 1, 0, 0, 0, 21408, 21304, 1, 0, 0, 0, 21408, 21305, 1, 0, 0, 0, 21408, 21306, 1, 0, 0, 0, 21408, 21307, 1, 0, 0, 0, 21408, 21308, 1, 0, 0, 0, 21408, 21309, 1, 0, 0, 0, 21408, 21310, 1, 0, 0, 0, 21408, 21311, 1, 0, 0, 0, 21408, 21312, 1, 0, 0, 0, 21408, 21313, 1, 0, 0, 0, 21408, 21314, 1, 0, 0, 0, 21408, 21315, 1, 0, 0, 0, 21408, 21316, 1, 0, 0, 0, 21408, 21317, 1, 0, 0, 0, 21408, 21318, 1, 0, 0, 0, 21408, 21319, 1, 0, 0, 0, 21408, 21320, 1, 0, 0, 0, 21408, 21321, 1, 0, 0, 0, 21408, 21322, 1, 0, 0, 0, 21408, 21323, 1, 0, 0, 0, 21408, 21324, 1, 0, 0, 0, 21408, 21325, 1, 0, 0, 0, 21408, 21326, 1, 0, 0, 0, 21408, 21327, 1, 0, 0, 0, 21408, 21328, 1, 0, 0, 0, 21408, 21329, 1, 0, 0, 0, 21408, 21330, 1, 0, 0, 0, 21408, 21331, 1, 0, 0, 0, 21408, 21332, 1, 0, 0, 0, 21408, 21333, 1, 0, 0, 0, 21408, 21334, 1, 0, 0, 0, 21408, 21335, 1, 0, 0, 0, 21408, 21336, 1, 0, 0, 0, 21408, 21337, 1, 0, 0, 0, 21408, 21338, 1, 0, 0, 0, 21408, 21339, 1, 0, 0, 0, 21408, 21340, 1, 0, 0, 0, 21408, 21341, 1, 0, 0, 0, 21408, 21342, 1, 0, 0, 0, 21408, 21343, 1, 0, 0, 0, 21408, 21344, 1, 0, 0, 0, 21408, 21345, 1, 0, 0, 0, 21408, 21346, 1, 0, 0, 0, 21408, 21347, 1, 0, 0, 0, 21408, 21348, 1, 0, 0, 0, 21408, 21349, 1, 0, 0, 0, 21408, 21350, 1, 0, 0, 0, 21408, 21351, 1, 0, 0, 0, 21408, 21352, 1, 0, 0, 0, 21408, 21353, 1, 0, 0, 0, 21408, 21354, 1, 0, 0, 0, 21408, 21355, 1, 0, 0, 0, 21408, 21356, 1, 0, 0, 0, 21408, 21357, 1, 0, 0, 0, 21408, 21358, 1, 0, 0, 0, 21408, 21359, 1, 0, 0, 0, 21408, 21360, 1, 0, 0, 0, 21408, 21361, 1, 0, 0, 0, 21408, 21362, 1, 0, 0, 0, 21408, 21363, 1, 0, 0, 0, 21408, 21364, 1, 0, 0, 0, 21408, 21365, 1, 0, 0, 0, 21408, 21366, 1, 0, 0, 0, 21408, 21367, 1, 0, 0, 0, 21408, 21368, 1, 0, 0, 0, 21408, 21369, 1, 0, 0, 0, 21408, 21370, 1, 0, 0, 0, 21408, 21371, 1, 0, 0, 0, 21408, 21372, 1, 0, 0, 0, 21408, 21373, 1, 0, 0, 0, 21408, 21374, 1, 0, 0, 0, 21408, 21375, 1, 0, 0, 0, 21408, 21376, 1, 0, 0, 0, 21408, 21377, 1, 0, 0, 0, 21408, 21378, 1, 0, 0, 0, 21408, 21379, 1, 0, 0, 0, 21408, 21380, 1, 0, 0, 0, 21408, 21381, 1, 0, 0, 0, 21408, 21382, 1, 0, 0, 0, 21408, 21383, 1, 0, 0, 0, 21408, 21384, 1, 0, 0, 0, 21408, 21385, 1, 0, 0, 0, 21408, 21386, 1, 0, 0, 0, 21408, 21387, 1, 0, 0, 0, 21408, 21388, 1, 0, 0, 0, 21408, 21389, 1, 0, 0, 0, 21408, 21390, 1, 0, 0, 0, 21408, 21391, 1, 0, 0, 0, 21408, 21392, 1, 0, 0, 0, 21408, 21393, 1, 0, 0, 0, 21408, 21394, 1, 0, 0, 0, 21408, 21395, 1, 0, 0, 0, 21408, 21396, 1, 0, 0, 0, 21408, 21397, 1, 0, 0, 0, 21408, 21398, 1, 0, 0, 0, 21408, 21399, 1, 0, 0, 0, 21408, 21400, 1, 0, 0, 0, 21408, 21401, 1, 0, 0, 0, 21408, 21402, 1, 0, 0, 0, 21408, 21403, 1, 0, 0, 0, 21408, 21404, 1, 0, 0, 0, 21408, 21405, 1, 0, 0, 0, 21408, 21406, 1, 0, 0, 0, 21408, 21407, 1, 0, 0, 0, 21409, 2411, 1, 0, 0, 0, 21410, 21411, 7, 302, 0, 0, 21411, 2413, 1, 0, 0, 0, 21412, 21413, 7, 303, 0, 0, 21413, 2415, 1, 0, 0, 0, 21414, 21415, 7, 304, 0, 0, 21415, 2417, 1, 0, 0, 0, 3015, 2420, 2424, 2429, 2433, 2437, 2441, 2445, 2448, 2593, 2600, 2602, 2605, 2608, 2630, 2632, 2639, 2643, 2648, 2650, 2655, 2658, 2662, 2670, 2675, 2679, 2684, 2689, 2693, 2699, 2704, 2709, 2713, 2716, 2722, 2730, 2737, 2741, 2746, 2749, 2765, 2770, 2774, 2782, 2788, 2796, 2799, 2801, 2804, 2808, 2811, 2815, 2823, 2829, 2837, 2840, 2843, 2855, 2857, 2863, 2868, 2870, 2876, 2879, 2891, 2901, 2904, 2909, 2912, 2929, 2936, 2941, 2945, 2960, 2963, 2978, 2988, 3002, 3005, 3018, 3026, 3032, 3036, 3043, 3047, 3062, 3080, 3093, 3099, 3108, 3118, 3122, 3135, 3138, 3147, 3155, 3159, 3169, 3183, 3193, 3201, 3204, 3208, 3211, 3214, 3217, 3227, 3246, 3256, 3264, 3269, 3275, 3296, 3305, 3308, 3312, 3314, 3323, 3327, 3343, 3357, 3359, 3362, 3366, 3373, 3380, 3389, 3394, 3399, 3401, 3409, 3417, 3421, 3427, 3431, 3436, 3443, 3446, 3456, 3461, 3468, 3477, 3479, 3484, 3487, 3491, 3496, 3508, 3517, 3520, 3526, 3532, 3542, 3558, 3573, 3586, 3592, 3604, 3613, 3618, 3634, 3636, 3652, 3654, 3675, 3677, 3697, 3699, 3714, 3723, 3725, 3736, 3743, 3756, 3761, 3770, 3773, 3778, 3783, 3788, 3791, 3797, 3801, 3807, 3812, 3817, 3820, 3827, 3834, 3843, 3845, 3847, 3851, 3861, 3871, 3876, 3881, 3883, 3888, 3900, 3905, 3914, 3916, 3921, 3936, 3948, 3952, 3955, 3958, 3965, 3969, 3972, 3983, 3988, 3993, 4003, 4008, 4018, 4020, 4025, 4028, 4032, 4037, 4049, 4054, 4059, 4061, 4066, 4069, 4074, 4081, 4091, 4096, 4099, 4104, 4109, 4112, 4117, 4126, 4142, 4144, 4154, 4172, 4179, 4184, 4190, 4198, 4200, 4216, 4221, 4226, 4228, 4233, 4240, 4243, 4246, 4249, 4259, 4271, 4275, 4278, 4287, 4295, 4303, 4306, 4312, 4317, 4322, 4326, 4364, 4392, 4399, 4404, 4411, 4421, 4426, 4435, 4439, 4450, 4453, 4457, 4460, 4465, 4470, 4474, 4484, 4494, 4500, 4508, 4516, 4521, 4524, 4526, 4529, 4538, 4541, 4546, 4551, 4554, 4557, 4560, 4564, 4567, 4575, 4580, 4585, 4592, 4602, 4618, 4625, 4632, 4637, 4647, 4652, 4657, 4660, 4665, 4675, 4680, 4687, 4690, 4695, 4698, 4701, 4713, 4720, 4723, 4726, 4735, 4738, 4743, 4746, 4753, 4756, 4763, 4768, 4772, 4777, 4782, 4790, 4800, 4805, 4812, 4815, 4819, 4822, 4825, 4828, 4838, 4843, 4848, 4851, 4856, 4866, 4871, 4875, 4885, 4890, 4897, 4903, 4907, 4910, 4913, 4925, 4932, 4935, 4938, 4946, 4960, 4967, 4979, 4984, 4996, 5016, 5023, 5025, 5029, 5037, 5048, 5059, 5061, 5068, 5074, 5080, 5103, 5108, 5113, 5122, 5125, 5133, 5138, 5142, 5145, 5148, 5151, 5154, 5157, 5160, 5163, 5167, 5170, 5173, 5178, 5182, 5185, 5190, 5192, 5204, 5208, 5212, 5218, 5222, 5225, 5228, 5238, 5247, 5255, 5262, 5267, 5275, 5278, 5282, 5292, 5301, 5309, 5313, 5316, 5321, 5325, 5328, 5331, 5340, 5348, 5353, 5379, 5391, 5400, 5403, 5412, 5422, 5427, 5438, 5441, 5443, 5449, 5454, 5459, 5462, 5468, 5473, 5476, 5483, 5489, 5494, 5500, 5507, 5510, 5518, 5524, 5530, 5534, 5537, 5540, 5553, 5559, 5566, 5577, 5585, 5589, 5592, 5597, 5607, 5612, 5617, 5622, 5627, 5632, 5637, 5642, 5647, 5652, 5655, 5664, 5669, 5679, 5684, 5691, 5695, 5704, 5711, 5715, 5722, 5725, 5728, 5736, 5740, 5743, 5751, 5757, 5759, 5767, 5776, 5781, 5788, 5793, 5796, 5800, 5802, 5813, 5824, 5838, 5843, 5853, 5859, 5862, 5867, 5876, 5879, 5884, 5888, 5912, 5914, 5918, 5921, 5926, 5929, 5934, 5943, 5954, 5957, 5960, 5963, 5967, 5975, 5980, 5992, 5995, 6000, 6004, 6007, 6016, 6022, 6028, 6031, 6035, 6050, 6053, 6056, 6062, 6068, 6073, 6079, 6085, 6093, 6097, 6111, 6118, 6125, 6131, 6134, 6138, 6143, 6148, 6154, 6159, 6164, 6168, 6173, 6179, 6183, 6188, 6192, 6196, 6209, 6214, 6217, 6221, 6226, 6228, 6234, 6236, 6240, 6243, 6250, 6261, 6271, 6275, 6280, 6284, 6288, 6291, 6302, 6307, 6319, 6329, 6341, 6347, 6349, 6353, 6362, 6369, 6379, 6382, 6389, 6397, 6408, 6415, 6419, 6421, 6425, 6435, 6446, 6451, 6455, 6459, 6462, 6465, 6475, 6480, 6488, 6495, 6499, 6501, 6505, 6508, 6518, 6529, 6534, 6538, 6542, 6545, 6548, 6555, 6564, 6572, 6574, 6597, 6610, 6624, 6626, 6637, 6645, 6651, 6654, 6659, 6663, 6666, 6669, 6674, 6682, 6694, 6702, 6709, 6728, 6739, 6742, 6748, 6750, 6757, 6760, 6762, 6769, 6784, 6792, 6806, 6817, 6819, 6835, 6837, 6844, 6849, 6856, 6859, 6864, 6874, 6883, 6896, 6906, 6911, 6914, 6920, 6938, 6941, 6944, 6952, 6965, 6967, 6971, 6979, 6981, 6983, 6985, 6993, 7004, 7015, 7017, 7026, 7037, 7043, 7050, 7060, 7064, 7073, 7076, 7082, 7085, 7090, 7096, 7104, 7110, 7116, 7128, 7136, 7139, 7150, 7154, 7165, 7169, 7180, 7184, 7190, 7193, 7196, 7199, 7202, 7206, 7209, 7213, 7219, 7222, 7225, 7228, 7231, 7235, 7238, 7246, 7251, 7254, 7258, 7266, 7270, 7274, 7283, 7294, 7301, 7303, 7307, 7316, 7320, 7324, 7331, 7337, 7341, 7348, 7357, 7369, 7383, 7387, 7389, 7392, 7399, 7413, 7422, 7425, 7428, 7431, 7439, 7443, 7452, 7456, 7471, 7479, 7491, 7508, 7511, 7516, 7522, 7526, 7531, 7537, 7541, 7544, 7558, 7563, 7577, 7582, 7584, 7593, 7601, 7604, 7607, 7610, 7613, 7615, 7619, 7623, 7630, 7635, 7640, 7645, 7649, 7652, 7657, 7665, 7670, 7673, 7679, 7684, 7689, 7696, 7699, 7712, 7723, 7732, 7741, 7750, 7759, 7762, 7768, 7773, 7775, 7782, 7824, 7827, 7831, 7834, 7845, 7854, 7857, 7859, 7869, 7874, 7878, 7882, 7885, 7888, 7902, 7904, 7910, 7912, 7916, 7922, 7928, 7932, 7935, 7943, 7953, 7957, 7976, 7981, 7988, 7995, 8069, 8076, 8085, 8094, 8102, 8109, 8116, 8121, 8128, 8135, 8140, 8147, 8154, 8159, 8166, 8173, 8178, 8185, 8192, 8197, 8200, 8203, 8210, 8214, 8223, 8234, 8243, 8247, 8254, 8256, 8263, 8271, 8276, 8280, 8285, 8292, 8294, 8298, 8301, 8304, 8313, 8319, 8321, 8325, 8329, 8334, 8339, 8343, 8349, 8354, 8359, 8362, 8371, 8374, 8377, 8383, 8390, 8395, 8399, 8405, 8407, 8413, 8415, 8419, 8428, 8434, 8443, 8455, 8463, 8472, 8475, 8482, 8486, 8494, 8501, 8511, 8516, 8518, 8523, 8530, 8546, 8553, 8563, 8572, 8581, 8590, 8595, 8600, 8603, 8611, 8622, 8626, 8629, 8637, 8643, 8645, 8650, 8653, 8660, 8664, 8669, 8672, 8685, 8689, 8694, 8697, 8707, 8711, 8715, 8720, 8736, 8741, 8753, 8757, 8763, 8778, 8781, 8783, 8785, 8789, 8792, 8812, 8817, 8822, 8833, 8836, 8848, 8857, 8868, 8877, 8882, 8906, 8911, 8917, 8919, 8927, 8930, 8933, 8936, 8942, 8948, 8954, 8958, 8960, 8963, 8968, 8972, 8977, 8980, 8985, 8988, 8993, 8997, 9003, 9007, 9011, 9019, 9032, 9036, 9042, 9045, 9049, 9054, 9058, 9064, 9069, 9072, 9080, 9083, 9092, 9096, 9098, 9117, 9123, 9128, 9133, 9135, 9139, 9148, 9161, 9172, 9175, 9178, 9181, 9190, 9192, 9197, 9209, 9214, 9218, 9226, 9233, 9238, 9243, 9254, 9257, 9269, 9284, 9289, 9295, 9299, 9305, 9309, 9318, 9327, 9332, 9336, 9340, 9346, 9353, 9359, 9368, 9373, 9380, 9383, 9400, 9402, 9417, 9419, 9432, 9435, 9438, 9441, 9449, 9452, 9455, 9458, 9470, 9481, 9484, 9489, 9493, 9501, 9514, 9518, 9522, 9526, 9529, 9532, 9535, 9538, 9548, 9551, 9560, 9564, 9572, 9585, 9588, 9590, 9594, 9598, 9604, 9609, 9613, 9616, 9619, 9628, 9633, 9637, 9641, 9644, 9651, 9654, 9656, 9661, 9670, 9676, 9679, 9681, 9698, 9706, 9715, 9718, 9723, 9726, 9735, 9755, 9761, 9766, 9768, 9778, 9787, 9799, 9802, 9805, 9815, 9824, 9832, 9837, 9845, 9850, 9853, 9866, 9868, 9870, 9873, 9877, 9887, 9891, 9896, 9901, 9905, 9907, 9910, 9914, 9924, 9934, 9937, 9940, 9944, 9948, 9961, 9970, 9981, 9983, 9994, 9996, 10001, 10006, 10013, 10031, 10037, 10042, 10052, 10058, 10066, 10072, 10076, 10079, 10091, 10098, 10108, 10123, 10128, 10141, 10146, 10154, 10159, 10164, 10169, 10173, 10178, 10186, 10189, 10192, 10195, 10198, 10200, 10207, 10209, 10213, 10219, 10222, 10225, 10231, 10234, 10239, 10242, 10256, 10262, 10266, 10270, 10281, 10288, 10293, 10298, 10303, 10308, 10310, 10312, 10318, 10324, 10331, 10339, 10347, 10355, 10363, 10371, 10378, 10389, 10395, 10399, 10411, 10418, 10420, 10422, 10426, 10429, 10432, 10436, 10443, 10445, 10448, 10456, 10458, 10464, 10470, 10475, 10477, 10485, 10496, 10499, 10503, 10507, 10510, 10515, 10519, 10523, 10532, 10538, 10544, 10550, 10553, 10561, 10565, 10571, 10577, 10583, 10587, 10589, 10594, 10597, 10601, 10605, 10613, 10617, 10620, 10623, 10629, 10632, 10635, 10638, 10641, 10660, 10667, 10671, 10674, 10681, 10686, 10693, 10699, 10701, 10707, 10711, 10718, 10723, 10729, 10733, 10741, 10746, 10752, 10755, 10758, 10761, 10764, 10770, 10776, 10778, 10789, 10793, 10797, 10804, 10808, 10813, 10816, 10829, 10834, 10837, 10842, 10855, 10859, 10863, 10872, 10877, 10885, 10887, 10900, 10905, 10913, 10915, 10951, 10955, 10965, 10969, 10973, 10976, 10981, 10984, 10989, 10997, 11004, 11016, 11028, 11033, 11041, 11055, 11060, 11071, 11075, 11079, 11081, 11091, 11101, 11112, 11128, 11133, 11135, 11140, 11147, 11154, 11174, 11179, 11181, 11186, 11193, 11200, 11205, 11216, 11222, 11227, 11230, 11235, 11238, 11242, 11257, 11262, 11266, 11277, 11282, 11295, 11311, 11316, 11318, 11323, 11331, 11345, 11353, 11366, 11372, 11376, 11390, 11395, 11399, 11413, 11416, 11420, 11423, 11432, 11440, 11448, 11451, 11456, 11458, 11462, 11465, 11474, 11482, 11490, 11493, 11498, 11500, 11510, 11518, 11526, 11529, 11534, 11547, 11552, 11561, 11572, 11586, 11591, 11594, 11600, 11604, 11608, 11612, 11616, 11619, 11631, 11636, 11650, 11660, 11663, 11672, 11682, 11686, 11691, 11694, 11697, 11700, 11703, 11707, 11710, 11713, 11717, 11719, 11724, 11726, 11734, 11745, 11750, 11752, 11761, 11769, 11776, 11780, 11788, 11794, 11796, 11802, 11810, 11812, 11815, 11820, 11823, 11828, 11832, 11836, 11841, 11844, 11850, 11852, 11859, 11861, 11865, 11877, 11879, 11887, 11889, 11893, 11897, 11901, 11905, 11921, 11923, 11945, 11954, 11956, 11968, 11971, 11975, 11977, 11987, 11992, 11995, 11999, 12007, 12017, 12022, 12034, 12039, 12051, 12060, 12066, 12070, 12075, 12078, 12086, 12090, 12097, 12104, 12107, 12115, 12118, 12121, 12126, 12131, 12137, 12139, 12142, 12149, 12160, 12167, 12169, 12178, 12183, 12197, 12206, 12217, 12226, 12236, 12244, 12248, 12252, 12255, 12262, 12270, 12272, 12276, 12280, 12283, 12286, 12291, 12294, 12299, 12303, 12306, 12309, 12316, 12323, 12326, 12328, 12333, 12337, 12340, 12343, 12348, 12351, 12354, 12359, 12363, 12368, 12371, 12374, 12377, 12383, 12387, 12394, 12400, 12403, 12410, 12412, 12414, 12419, 12425, 12429, 12435, 12446, 12452, 12459, 12473, 12477, 12481, 12488, 12492, 12494, 12499, 12505, 12507, 12533, 12546, 12551, 12554, 12558, 12563, 12566, 12569, 12576, 12583, 12591, 12597, 12604, 12607, 12610, 12613, 12616, 12623, 12629, 12632, 12640, 12674, 12681, 12693, 12702, 12709, 12724, 12738, 12747, 12763, 12766, 12768, 12771, 12779, 12795, 12806, 12811, 12819, 12823, 12828, 12831, 12839, 12844, 12848, 12855, 12862, 12866, 12875, 12883, 12887, 12890, 12898, 12904, 12908, 12913, 12918, 12925, 12929, 12933, 12947, 12949, 12952, 12958, 12963, 12966, 12969, 12972, 12978, 12992, 12994, 12998, 13001, 13004, 13007, 13014, 13018, 13022, 13025, 13029, 13032, 13039, 13043, 13045, 13048, 13055, 13061, 13065, 13072, 13076, 13091, 13097, 13105, 13114, 13119, 13124, 13130, 13137, 13144, 13147, 13149, 13153, 13159, 13163, 13169, 13175, 13179, 13182, 13209, 13218, 13227, 13237, 13245, 13250, 13259, 13269, 13279, 13290, 13297, 13304, 13307, 13310, 13313, 13317, 13319, 13322, 13325, 13328, 13331, 13335, 13337, 13345, 13347, 13358, 13360, 13363, 13371, 13381, 13402, 13404, 13418, 13422, 13425, 13431, 13438, 13461, 13464, 13468, 13473, 13478, 13481, 13484, 13489, 13500, 13506, 13510, 13516, 13523, 13525, 13527, 13531, 13534, 13537, 13547, 13555, 13557, 13559, 13567, 13576, 13578, 13582, 13592, 13601, 13603, 13606, 13611, 13625, 13634, 13636, 13640, 13648, 13650, 13661, 13671, 13677, 13682, 13686, 13691, 13696, 13701, 13705, 13712, 13719, 13724, 13729, 13733, 13744, 13750, 13755, 13759, 13764, 13767, 13770, 13774, 13777, 13780, 13792, 13801, 13809, 13817, 13822, 13828, 13832, 13839, 13844, 13849, 13854, 13858, 13867, 13870, 13874, 13880, 13888, 13897, 13900, 13915, 13932, 13938, 13942, 13949, 13956, 13959, 13961, 13967, 13969, 13972, 13981, 13984, 13988, 13994, 14006, 14016, 14020, 14023, 14026, 14031, 14035, 14039, 14042, 14049, 14052, 14059, 14065, 14093, 14103, 14113, 14115, 14123, 14154, 14159, 14173, 14197, 14200, 14212, 14215, 14221, 14237, 14239, 14255, 14268, 14279, 14283, 14285, 14293, 14302, 14306, 14314, 14322, 14328, 14335, 14339, 14343, 14345, 14348, 14358, 14364, 14369, 14375, 14377, 14388, 14391, 14394, 14404, 14413, 14416, 14419, 14422, 14433, 14436, 14442, 14445, 14449, 14452, 14465, 14467, 14470, 14472, 14477, 14481, 14504, 14520, 14525, 14529, 14533, 14537, 14540, 14545, 14547, 14561, 14566, 14573, 14584, 14590, 14592, 14594, 14602, 14611, 14619, 14621, 14623, 14625, 14628, 14646, 14651, 14664, 14671, 14675, 14678, 14681, 14683, 14688, 14692, 14694, 14710, 14714, 14717, 14722, 14725, 14728, 14739, 14750, 14762, 14770, 14773, 14777, 14782, 14787, 14791, 14794, 14797, 14800, 14804, 14806, 14816, 14820, 14825, 14830, 14837, 14845, 14851, 14854, 14856, 14865, 14867, 14877, 14888, 14897, 14904, 14911, 14915, 14917, 14923, 14931, 14938, 14945, 14949, 14951, 14972, 14974, 14977, 14983, 14989, 14997, 14999, 15001, 15006, 15011, 15016, 15020, 15024, 15028, 15040, 15046, 15053, 15058, 15064, 15069, 15073, 15079, 15084, 15093, 15102, 15105, 15108, 15111, 15115, 15125, 15132, 15139, 15141, 15151, 15154, 15157, 15160, 15164, 15166, 15170, 15176, 15178, 15181, 15184, 15189, 15194, 15198, 15202, 15208, 15234, 15236, 15248, 15253, 15258, 15260, 15272, 15277, 15282, 15284, 15289, 15296, 15300, 15309, 15320, 15328, 15332, 15337, 15340, 15345, 15350, 15354, 15357, 15365, 15372, 15378, 15383, 15387, 15394, 15396, 15399, 15404, 15408, 15413, 15417, 15424, 15428, 15433, 15439, 15442, 15451, 15462, 15466, 15468, 15481, 15485, 15487, 15489, 15516, 15519, 15524, 15526, 15548, 15551, 15553, 15555, 15562, 15564, 15572, 15576, 15581, 15584, 15587, 15590, 15597, 15602, 15610, 15618, 15623, 15626, 15628, 15644, 15646, 15659, 15661, 15663, 15675, 15684, 15688, 15690, 15693, 15696, 15701, 15705, 15709, 15714, 15717, 15720, 15730, 15732, 15737, 15742, 15748, 15752, 15759, 15782, 15788, 15790, 15793, 15796, 15799, 15802, 15810, 15812, 15821, 15823, 15828, 15832, 15837, 15839, 15846, 15854, 15856, 15863, 15865, 15869, 15882, 15888, 15891, 15894, 15906, 15908, 15912, 15916, 15919, 15924, 15929, 15936, 15942, 15946, 15952, 15965, 15969, 15976, 15990, 15995, 15999, 16010, 16012, 16028, 16035, 16038, 16042, 16045, 16052, 16059, 16064, 16071, 16073, 16080, 16084, 16086, 16094, 16096, 16105, 16115, 16126, 16128, 16131, 16135, 16138, 16153, 16162, 16166, 16169, 16173, 16176, 16178, 16182, 16189, 16195, 16199, 16202, 16210, 16223, 16227, 16231, 16234, 16237, 16250, 16254, 16266, 16271, 16275, 16279, 16285, 16288, 16291, 16318, 16324, 16333, 16338, 16349, 16356, 16360, 16363, 16369, 16378, 16387, 16390, 16394, 16401, 16404, 16413, 16418, 16426, 16428, 16453, 16457, 16464, 16468, 16472, 16476, 16488, 16492, 16506, 16512, 16519, 16524, 16535, 16538, 16544, 16546, 16554, 16558, 16568, 16573, 16588, 16592, 16595, 16599, 16604, 16608, 16613, 16629, 16634, 16643, 16652, 16654, 16662, 16664, 16668, 16676, 16686, 16689, 16696, 16705, 16708, 16717, 16724, 16728, 16731, 16743, 16749, 16758, 16761, 16771, 16782, 16788, 16790, 16792, 16796, 16803, 16806, 16813, 16824, 16830, 16834, 16844, 16847, 16853, 16856, 16861, 16867, 16872, 16874, 16879, 16881, 16886, 16890, 16895, 16909, 16914, 16921, 16923, 16931, 16935, 16943, 16946, 16955, 16957, 16963, 16965, 16973, 16979, 16981, 16988, 16991, 16993, 16997, 17001, 17007, 17011, 17014, 17022, 17025, 17029, 17033, 17038, 17041, 17045, 17049, 17053, 17079, 17082, 17085, 17094, 17107, 17114, 17127, 17142, 17150, 17154, 17158, 17164, 17168, 17171, 17174, 17178, 17180, 17184, 17187, 17190, 17193, 17201, 17204, 17215, 17217, 17224, 17231, 17236, 17242, 17247, 17252, 17259, 17265, 17272, 17275, 17278, 17282, 17287, 17291, 17293, 17299, 17309, 17316, 17320, 17330, 17345, 17347, 17351, 17359, 17366, 17374, 17377, 17382, 17392, 17400, 17403, 17409, 17414, 17417, 17422, 17427, 17433, 17442, 17449, 17459, 17464, 17466, 17471, 17475, 17481, 17485, 17498, 17502, 17512, 17515, 17517, 17522, 17531, 17544, 17552, 17556, 17565, 17569, 17574, 17585, 17587, 17603, 17608, 17614, 17620, 17638, 17645, 17648, 17651, 17659, 17662, 17670, 17672, 17676, 17679, 17684, 17686, 17690, 17702, 17711, 17719, 17724, 17728, 17738, 17740, 17746, 17751, 17754, 17764, 17770, 17773, 17776, 17784, 17794, 17804, 17808, 17812, 17815, 17818, 17823, 17828, 17831, 17834, 17840, 17843, 17849, 17852, 17855, 17860, 17863, 17871, 17877, 17882, 17885, 17894, 17907, 17911, 17913, 17916, 17919, 17931, 17935, 17938, 17953, 17957, 17969, 17972, 17981, 17988, 17993, 17997, 18005, 18011, 18019, 18022, 18031, 18034, 18037, 18046, 18052, 18058, 18061, 18066, 18072, 18084, 18095, 18097, 18106, 18108, 18112, 18118, 18122, 18135, 18142, 18147, 18163, 18165, 18169, 18173, 18177, 18190, 18194, 18201, 18209, 18212, 18217, 18219, 18224, 18228, 18231, 18237, 18242, 18254, 18258, 18260, 18265, 18275, 18277, 18279, 18289, 18293, 18295, 18307, 18315, 18328, 18331, 18336, 18354, 18356, 18364, 18372, 18379, 18383, 18386, 18393, 18397, 18402, 18406, 18414, 18418, 18425, 18430, 18439, 18448, 18451, 18471, 18473, 18475, 18483, 18500, 18502, 18512, 18517, 18520, 18527, 18530, 18534, 18537, 18540, 18546, 18549, 18553, 18556, 18568, 18575, 18578, 18582, 18588, 18591, 18595, 18610, 18618, 18625, 18638, 18643, 18652, 18661, 18665, 18669, 18695, 18698, 18701, 18711, 18719, 18725, 18727, 18731, 18738, 18747, 18751, 18754, 18757, 18766, 18769, 18772, 18775, 18778, 18790, 18798, 18805, 18808, 18812, 18814, 18817, 18822, 18831, 18837, 18840, 18843, 18852, 18855, 18858, 18861, 18867, 18871, 18883, 18893, 18897, 18900, 18906, 18910, 18916, 18920, 18923, 18926, 18928, 18935, 18939, 18942, 18945, 18948, 18953, 18956, 18960, 18969, 18973, 18980, 18984, 18989, 18994, 18997, 19006, 19010, 19021, 19024, 19028, 19033, 19037, 19046, 19049, 19053, 19062, 19065, 19069, 19074, 19083, 19086, 19090, 19098, 19103, 19108, 19111, 19115, 19117, 19126, 19133, 19136, 19143, 19145, 19148, 19151, 19155, 19158, 19163, 19170, 19176, 19184, 19188, 19191, 19194, 19200, 19203, 19207, 19211, 19216, 19219, 19222, 19231, 19243, 19250, 19253, 19259, 19262, 19265, 19274, 19277, 19282, 19289, 19291, 19304, 19311, 19316, 19321, 19327, 19333, 19336, 19338, 19343, 19351, 19353, 19360, 19366, 19371, 19377, 19382, 19388, 19400, 19406, 19410, 19415, 19420, 19426, 19429, 19433, 19443, 19453, 19459, 19461, 19471, 19473, 19480, 19484, 19493, 19498, 19503, 19506, 19515, 19518, 19527, 19541, 19548, 19556, 19559, 19572, 19578, 19580, 19593, 19602, 19608, 19618, 19626, 19632, 19635, 19638, 19652, 19654, 19662, 19669, 19679, 19687, 19693, 19696, 19701, 19706, 19710, 19718, 19725, 19734, 19741, 19750, 19754, 19761, 19768, 19775, 19782, 19790, 19794, 19801, 19810, 19813, 19816, 19819, 19823, 19828, 19833, 19844, 19848, 19850, 19861, 19863, 19874, 19885, 19894, 19897, 19907, 19911, 19920, 19930, 19940, 19948, 19954, 19962, 19969, 19973, 19978, 19982, 19987, 19991, 19997, 20000, 20007, 20017, 20025, 20029, 20039, 20042, 20044, 20051, 20057, 20063, 20069, 20071, 20085, 20087, 20100, 20105, 20108, 20115, 20120, 20131, 20136, 20138, 20145, 20148, 20155, 20170, 20173, 20177, 20179, 20187, 20195, 20197, 20204, 20209, 20213, 20217, 20221, 20225, 20230, 20234, 20237, 20241, 20248, 20252, 20257, 20262, 20266, 20271, 20288, 20293, 20300, 20311, 20318, 20325, 20329, 20336, 20341, 20350, 20358, 20366, 20372, 20377, 20382, 20386, 20391, 20394, 20399, 20403, 20407, 20414, 20419, 20430, 20436, 20441, 20445, 20447, 20454, 20458, 20466, 20469, 20474, 20481, 20499, 20516, 20523, 20536, 20540, 20548, 20551, 20555, 20560, 20565, 20569, 20572, 20576, 20583, 20588, 20590, 20592, 20602, 20607, 20611, 20614, 20618, 20627, 20633, 20637, 20639, 20643, 20647, 20654, 20662, 20670, 20672, 20677, 20682, 20684, 20687, 20711, 20718, 20723, 20756, 20761, 20764, 20769, 20771, 20777, 20786, 20793, 20797, 20802, 20807, 20812, 20817, 20824, 20829, 20863, 20870, 20885, 20901, 20920, 20937, 20944, 20952, 20965, 20974, 20983, 20992, 21002, 21010, 21020, 21030, 21042, 21058, 21076, 21089, 21104, 21115, 21125, 21136, 21146, 21163, 21169, 21191, 21196, 21202, 21208, 21214, 21219, 21221, 21224, 21235, 21238, 21240, 21242, 21256, 21260, 21263, 21272, 21278, 21408] \ No newline at end of file diff --git a/internal/engine/oracle/parser/PlSqlParser.tokens b/internal/engine/oracle/parser/PlSqlParser.tokens new file mode 100644 index 0000000000..dfc930c197 --- /dev/null +++ b/internal/engine/oracle/parser/PlSqlParser.tokens @@ -0,0 +1,4939 @@ +ABORT=1 +ABS=2 +ABSENT=3 +ACCESS=4 +ACCESSED=5 +ACCESSIBLE=6 +ACCOUNT=7 +ACL=8 +ACOS=9 +ACROSS=10 +ACTION=11 +ACTIONS=12 +ACTIVATE=13 +ACTIVE=14 +ACTIVE_COMPONENT=15 +ACTIVE_DATA=16 +ACTIVE_FUNCTION=17 +ACTIVE_TAG=18 +ACTIVITY=19 +ADAPTIVE_PLAN=20 +ADD=21 +ADD_COLUMN=22 +ADD_GROUP=23 +ADD_MONTHS=24 +ADJ_DATE=25 +ADMIN=26 +ADMINISTER=27 +ADMINISTRATOR=28 +ADVANCED=29 +ADVISE=30 +ADVISOR=31 +AFD_DISKSTRING=32 +AFTER=33 +AGENT=34 +AGGREGATE=35 +A_LETTER=36 +ALIAS=37 +ALL=38 +ALLOCATE=39 +ALLOW=40 +ALL_ROWS=41 +ALTER=42 +ALTERNATE=43 +ALWAYS=44 +ANALYTIC=45 +ANALYZE=46 +ANCESTOR=47 +ANCILLARY=48 +AND=49 +AND_EQUAL=50 +ANNOTATIONS=51 +ANOMALY=52 +ANSI_REARCH=53 +ANTIJOIN=54 +ANY=55 +ANYSCHEMA=56 +APPEND=57 +APPENDCHILDXML=58 +APPEND_VALUES=59 +APPLICATION=60 +APPLY=61 +APPROX_COUNT_DISTINCT=62 +ARCHIVAL=63 +ARCHIVE=64 +ARCHIVED=65 +ARCHIVELOG=66 +ARE=67 +ARRAY=68 +AS=69 +ASC=70 +ASCII=71 +ASCIISTR=72 +ASIN=73 +ASIS=74 +ASSEMBLY=75 +ASSIGN=76 +ASSOCIATE=77 +ASYNC=78 +ASYNCHRONOUS=79 +ATAN2=80 +ATAN=81 +AT=82 +ATTRIBUTE=83 +ATTRIBUTES=84 +AUDIT=85 +AUTHENTICATED=86 +AUTHENTICATION=87 +AUTHID=88 +AUTHORIZATION=89 +AUTOALLOCATE=90 +AUTO=91 +AUTOBACKUP=92 +AUTOEXTEND=93 +AUTO_LOGIN=94 +AUTOMATIC=95 +AUTONOMOUS_TRANSACTION=96 +AUTO_REOPTIMIZE=97 +AVAILABILITY=98 +AVRO=99 +BACKGROUND=100 +BACKINGFILE=101 +BACKUP=102 +BACKUPS=103 +BACKUPSET=104 +BADFILE=105 +BASIC=106 +BASICFILE=107 +BATCH=108 +BATCHSIZE=109 +BATCH_TABLE_ACCESS_BY_ROWID=110 +BECOME=111 +BEFORE=112 +BEGIN=113 +BEGINNING=114 +BEGIN_OUTLINE_DATA=115 +BEHALF=116 +BEQUEATH=117 +BETWEEN=118 +BFILE=119 +BFILENAME=120 +BIG=121 +BIGFILE=122 +BIGINT=123 +BINARY=124 +BINARY_DOUBLE=125 +BINARY_DOUBLE_INFINITY=126 +BINARY_DOUBLE_NAN=127 +BINARY_FLOAT=128 +BINARY_FLOAT_INFINITY=129 +BINARY_FLOAT_NAN=130 +BINARY_INTEGER=131 +BIND_AWARE=132 +BINDING=133 +BIN_TO_NUM=134 +BITAND=135 +BITMAP_AND=136 +BITMAP=137 +BITMAPS=138 +BITMAP_TREE=139 +BITS=140 +BLANKS=141 +BLOB=142 +BLOCK=143 +BLOCK_RANGE=144 +BLOCKS=145 +BLOCKSIZE=146 +BODY=147 +BOOLEAN=148 +BOTH=149 +BOUND=150 +BRANCH=151 +BREADTH=152 +BROADCAST=153 +BSON=154 +BUFFER=155 +BUFFER_CACHE=156 +BUFFER_POOL=157 +BUILD=158 +BULK=159 +BY=160 +BYPASS_RECURSIVE_CHECK=161 +BYPASS_UJVC=162 +BYTE=163 +BYTES=164 +BYTEORDERMARK=165 +CACHE=166 +CACHE_CB=167 +CACHE_INSTANCES=168 +CACHE_TEMP_TABLE=169 +CACHING=170 +CALCULATED=171 +CALLBACK=172 +CALL=173 +CANCEL=174 +CANONICAL=175 +CAPACITY=176 +CAPTION=177 +CARDINALITY=178 +CASCADE=179 +CASE=180 +CAST=181 +CASESENSITIVE=182 +CATEGORY=183 +CDBDEFAULT=184 +CEIL=185 +CELL_FLASH_CACHE=186 +CERTIFICATE=187 +CFILE=188 +CHAINED=189 +CHANGE=190 +CHANGETRACKING=191 +CHANGE_DUPKEY_ERROR_INDEX=192 +CHARACTER=193 +CHARACTERS=194 +CHARACTERSET=195 +CHAR=196 +CHAR_CS=197 +CHARTOROWID=198 +CHECK_ACL_REWRITE=199 +CHECK=200 +CHECKPOINT=201 +CHILD=202 +CHOOSE=203 +CHR=204 +CHUNK=205 +CLASS=206 +CLASSIFICATION=207 +CLASSIFIER=208 +CLAUSE=209 +CLEAN=210 +CLEANUP=211 +CLEAR=212 +C_LETTER=213 +CLIENT=214 +CLOB=215 +CLONE=216 +CLOSE_CACHED_OPEN_CURSORS=217 +CLOSE=218 +CLUSTER_BY_ROWID=219 +CLUSTER=220 +CLUSTER_DETAILS=221 +CLUSTER_DISTANCE=222 +CLUSTER_ID=223 +CLUSTERING=224 +CLUSTERING_FACTOR=225 +CLUSTER_PROBABILITY=226 +CLUSTER_SET=227 +COALESCE=228 +COALESCE_SQ=229 +COARSE=230 +CO_AUTH_IND=231 +COLD=232 +COLLECT=233 +COLLECTION=234 +COLUMNAR=235 +COLUMN_AUTH_INDICATOR=236 +COLUMN=237 +COLUMNS=238 +COLUMN_STATS=239 +COLUMN_VALUE=240 +COMMENT=241 +COMMIT=242 +COMMITTED=243 +COMMON=244 +COMMON_DATA=245 +COMPACT=246 +COMPATIBLE=247 +COMPATIBILITY=248 +COMPILE=249 +COMPLETE=250 +COMPLIANCE=251 +COMPONENT=252 +COMPONENTS=253 +COMPOSE=254 +COMPOSITE=255 +COMPOSITE_LIMIT=256 +COMPOUND=257 +COMPRESS=258 +COMPRESSION=259 +COMPUTE=260 +COMPUTATION=261 +CONCAT=262 +CONCURRENT=263 +CON_DBID_TO_ID=264 +CONDITIONAL=265 +CONDITION=266 +CONFIRM=267 +CONFORMING=268 +CON_GUID_TO_ID=269 +CON_ID=270 +CON_NAME_TO_ID=271 +CONNECT_BY_CB_WHR_ONLY=272 +CONNECT_BY_COMBINE_SW=273 +CONNECT_BY_COST_BASED=274 +CONNECT_BY_ELIM_DUPS=275 +CONNECT_BY_FILTERING=276 +CONNECT_BY_ISCYCLE=277 +CONNECT_BY_ISLEAF=278 +CONNECT_BY_ROOT=279 +CONNECT=280 +CONNECT_TIME=281 +CONSIDER=282 +CONSISTENT=283 +CONSTANT=284 +CONST=285 +CONSTRAINT=286 +CONSTRAINTS=287 +CONSTRUCTOR=288 +CONTAINER=289 +CONTAINERS=290 +CONTAINERS_DEFAULT=291 +CONTAINER_DATA=292 +CONTAINER_MAP=293 +CONTENT=294 +CONTENTS=295 +CONTEXT=296 +CONTINUE=297 +CONTROLFILE=298 +CON_UID_TO_ID=299 +CONVERT=300 +CONVERSION=301 +COOKIE=302 +COPY=303 +CORR_K=304 +CORR_S=305 +CORRUPTION=306 +CORRUPT_XID_ALL=307 +CORRUPT_XID=308 +COS=309 +COSH=310 +COST=311 +COST_XML_QUERY_REWRITE=312 +COUNT=313 +COUNTED=314 +COVAR_POP=315 +COVAR_SAMP=316 +CPU_COSTING=317 +CPU_PER_CALL=318 +CPU_PER_SESSION=319 +CRASH=320 +CREATE=321 +CREATE_FILE_DEST=322 +CREATE_STORED_OUTLINES=323 +CREATION=324 +CREDENTIAL=325 +CRITICAL=326 +CROSS=327 +CROSSEDITION=328 +CSCONVERT=329 +CSV=330 +CUBE_AJ=331 +CUBE=332 +CUBE_GB=333 +CUBE_SJ=334 +CUME_DISTM=335 +CURRENT=336 +CURRENT_DATE=337 +CURRENT_SCHEMA=338 +CURRENT_TIME=339 +CURRENT_TIMESTAMP=340 +CURRENT_USER=341 +CURRENTV=342 +CURSOR=343 +CURSOR_SHARING_EXACT=344 +CURSOR_SPECIFIC_SEGMENT=345 +CUSTOMDATUM=346 +CV=347 +CYCLE=348 +DANGLING=349 +DATABASE=350 +DATA=351 +DATAFILE=352 +DATAFILES=353 +DATAGUARDCONFIG=354 +DATAMOVEMENT=355 +DATAOBJNO=356 +DATAOBJ_TO_MAT_PARTITION=357 +DATAOBJ_TO_PARTITION=358 +DATAPUMP=359 +DATA_SECURITY_REWRITE_LIMIT=360 +DATE=361 +DATE_CACHE=362 +DATE_FORMAT=363 +DATE_MODE=364 +DAY=365 +DAYS=366 +DAY_TO_SECOND=367 +DBA=368 +DBA_RECYCLEBIN=369 +DBLINK=370 +DBMS_STATS=371 +DB_ROLE_CHANGE=372 +DBTIMEZONE=373 +DB_UNIQUE_NAME=374 +DB_VERSION=375 +DDL=376 +DEALLOCATE=377 +DEBUG=378 +DEBUGGER=379 +DEC=380 +DECIMAL=381 +DECLARE=382 +DECOMPOSE=383 +DECORRELATE=384 +DECR=385 +DECREMENT=386 +DECRYPT=387 +DEDUPLICATE=388 +DEFAULT=389 +DEFAULTIF=390 +DEFAULTS=391 +DEFAULT_COLLATION=392 +DEFAULT_CREDENTIAL=393 +DEFERRABLE=394 +DEFERRED=395 +DEFINED=396 +DEFINE=397 +DEFINER=398 +DEGREE=399 +DELAY=400 +DELEGATE=401 +DELETE_ALL=402 +DELETE=403 +DELETEXML=404 +DELIMITED=405 +DEMAND=406 +DENSE_RANKM=407 +DEPENDENT=408 +DEPRECATE=409 +DEPTH=410 +DEQUEUE=411 +DEREF=412 +DEREF_NO_REWRITE=413 +DESC=414 +DESCRIPTION=415 +DESTROY=416 +DETACHED=417 +DETECTED=418 +DETERMINES=419 +DETERMINISTIC=420 +DICTIONARY=421 +DIMENSION=422 +DIMENSIONS=423 +DIRECTIO=424 +DIRECT_LOAD=425 +DIRECTORY=426 +DIRECT_PATH=427 +DISABLE_ALL=428 +DISABLE=429 +DISABLED=430 +DISABLE_DIRECTORY_LINK_CHECK=431 +DISABLE_PARALLEL_DML=432 +DISABLE_PRESET=433 +DISABLE_RPKE=434 +DISALLOW=435 +DISASSOCIATE=436 +DISCARD=437 +DISCARDFILE=438 +DISCONNECT=439 +DISK=440 +DISKGROUP=441 +DISKGROUP_PLUS=442 +DISKS=443 +DISMOUNT=444 +DISTINCT=445 +DISTINGUISHED=446 +DISTRIBUTED=447 +DISTRIBUTE=448 +DML=449 +DML_UPDATE=450 +DNFS_DISABLE=451 +DNFS_ENABLE=452 +DNFS_READBUFFERS=453 +DOCFIDELITY=454 +DOCUMENT=455 +DOLLAR_ELSE=456 +DOLLAR_ELSIF=457 +DOLLAR_END=458 +DOLLAR_ERROR=459 +DOLLAR_IF=460 +DOLLAR_THEN=461 +DOMAIN_INDEX_FILTER=462 +DOMAIN_INDEX_NO_SORT=463 +DOMAIN_INDEX_SORT=464 +DOUBLE=465 +DOWNGRADE=466 +DRIVING_SITE=467 +DROP_COLUMN=468 +DROP=469 +DROP_GROUP=470 +DSINTERVAL_UNCONSTRAINED=471 +DST_UPGRADE_INSERT_CONV=472 +DUMP=473 +DUMPSET=474 +DUPLICATE=475 +DV=476 +DYNAMIC=477 +DYNAMIC_SAMPLING=478 +DYNAMIC_SAMPLING_EST_CDN=479 +E_LETTER=480 +EACH=481 +EDITIONABLE=482 +EDITION=483 +EDITIONING=484 +EDITIONS=485 +ELEMENT=486 +ELIM_GROUPBY=487 +ELIMINATE_JOIN=488 +ELIMINATE_OBY=489 +ELIMINATE_OUTER_JOIN=490 +ELSE=491 +ELSIF=492 +EM=493 +EMBEDDED=494 +EMPTY_BLOB=495 +EMPTY_CLOB=496 +EMPTY_=497 +ENABLE_ALL=498 +ENABLE=499 +ENABLED=500 +ENABLE_PARALLEL_DML=501 +ENABLE_PRESET=502 +ENCLOSED=503 +ENCODING=504 +ENCRYPT=505 +ENCRYPTION=506 +ENCRYPTPASSWORDISNULL=507 +END=508 +END_OUTLINE_DATA=509 +ENDIAN=510 +ENFORCED=511 +ENFORCE=512 +ENQUEUE=513 +ENTERPRISE=514 +ENTITYESCAPING=515 +ENTRY=516 +EQUIPART=517 +ERR=518 +ERROR_ARGUMENT=519 +ERROR=520 +ERROR_ON_OVERLAP_TIME=521 +ERRORS=522 +ERROR_INDEX=523 +ERROR_CODE=524 +ESCAPE=525 +ESCAPED=526 +ESTIMATE=527 +EVAL=528 +EVALNAME=529 +EVALUATE=530 +EVALUATION=531 +EVENTS=532 +EVERY=533 +EXCEPT=534 +EXCEPTION=535 +EXCEPTION_INIT=536 +EXCEPTIONS=537 +EXCHANGE=538 +EXCLUDE=539 +EXCLUDING=540 +EXCLUSIVE=541 +EXECUTE=542 +EXEMPT=543 +EXISTING=544 +EXISTS=545 +EXISTSNODE=546 +EXIT=547 +EXPAND_GSET_TO_UNION=548 +EXPAND_TABLE=549 +EXP=550 +EXPIRE=551 +EXPLAIN=552 +EXPLOSION=553 +EXPORT=554 +EXPR_CORR_CHECK=555 +EXPRESS=556 +EXTENDS=557 +EXTENT=558 +EXTENTS=559 +EXTERNAL=560 +EXTERNALLY=561 +EXTRACTCLOBXML=562 +EXTRACT=563 +EXTRACTVALUE=564 +EXTRA=565 +FACILITY=566 +FACT=567 +FACTOR=568 +FACTORIZE_JOIN=569 +FAILED=570 +FAILED_LOGIN_ATTEMPTS=571 +FAILGROUP=572 +FAILOVER=573 +FAILURE=574 +FALSE=575 +FAMILY=576 +FAR=577 +FAST=578 +FASTSTART=579 +FBTSCAN=580 +FEATURE=581 +FEATURE_DETAILS=582 +FEATURE_ID=583 +FEATURE_SET=584 +FEATURE_VALUE=585 +FETCH=586 +FIELD=587 +FIELDS=588 +FILE=589 +FILE_NAME_CONVERT=590 +FILEGROUP=591 +FILESTORE=592 +FILESYSTEM_LIKE_LOGGING=593 +FILTER=594 +FINAL=595 +FINE=596 +FINISH=597 +FIRST=598 +FIRSTM=599 +FIRST_ROWS=600 +FIRST_VALUE=601 +FIXED=602 +FIXED_VIEW_DATA=603 +FLAGGER=604 +FLASHBACK=605 +FLASH_CACHE=606 +FLOAT=607 +FLOB=608 +FLEX=609 +FLOOR=610 +FLUSH=611 +FOLDER=612 +FOLLOWING=613 +FOLLOWS=614 +FORALL=615 +FORCE=616 +FORCE_XML_QUERY_REWRITE=617 +FOREIGN=618 +FOREVER=619 +FOR=620 +FORMAT=621 +FORWARD=622 +FRAGMENT_NUMBER=623 +FREELIST=624 +FREELISTS=625 +FREEPOOLS=626 +FRESH=627 +FROM=628 +FROM_TZ=629 +FULL=630 +FULL_OUTER_JOIN_TO_OUTER=631 +FUNCTION=632 +FUNCTIONS=633 +FTP=634 +G_LETTER=635 +GATHER_OPTIMIZER_STATISTICS=636 +GATHER_PLAN_STATISTICS=637 +GBY_CONC_ROLLUP=638 +GBY_PUSHDOWN=639 +GENERATED=640 +GET=641 +GLOBAL=642 +GLOBALLY=643 +GLOBAL_NAME=644 +GLOBAL_TOPIC_ENABLED=645 +GOTO=646 +GRANT=647 +GROUP_BY=648 +GROUP=649 +GROUP_ID=650 +GROUPING=651 +GROUPING_ID=652 +GROUPS=653 +GUARANTEED=654 +GUARANTEE=655 +GUARD=656 +HADOOP_TRAILERS=657 +HALF_YEARS=658 +HASH_AJ=659 +HASH=660 +HASHKEYS=661 +HASH_SJ=662 +HAVING=663 +HEADER=664 +HEAP=665 +HELP=666 +HEXTORAW=667 +HEXTOREF=668 +HIDDEN_KEYWORD=669 +HIDE=670 +HIER_ORDER=671 +HIERARCHICAL=672 +HIERARCHIES=673 +HIERARCHY=674 +HIGH=675 +HINTSET_BEGIN=676 +HINTSET_END=677 +HOT=678 +HOUR=679 +HOURS=680 +HTTP=681 +HWM_BROKERED=682 +HYBRID=683 +H_LETTER=684 +IDENTIFIED=685 +IDENTIFIER=686 +IDENTITY=687 +IDGENERATORS=688 +ID=689 +IDLE_TIME=690 +IF=691 +IGNORE=692 +IGNORE_CHARS_AFTER_EOR=693 +IGNORE_OPTIM_EMBEDDED_HINTS=694 +IGNORE_ROW_ON_DUPKEY_INDEX=695 +IGNORE_WHERE_CLAUSE=696 +ILM=697 +IMMEDIATE=698 +IMPACT=699 +IMPORT=700 +INACTIVE=701 +INACTIVE_ACCOUNT_TIME=702 +INCLUDE=703 +INCLUDE_VERSION=704 +INCLUDING=705 +INCREMENTAL=706 +INCREMENT=707 +INCR=708 +INDENT=709 +INDEX_ASC=710 +INDEX_COMBINE=711 +INDEX_DESC=712 +INDEXED=713 +INDEXES=714 +INDEX_FFS=715 +INDEX_FILTER=716 +INDEX=717 +INDEXING=718 +INDEX_JOIN=719 +INDEX_ROWS=720 +INDEX_RRS=721 +INDEX_RS_ASC=722 +INDEX_RS_DESC=723 +INDEX_RS=724 +INDEX_SCAN=725 +INDEX_SKIP_SCAN=726 +INDEX_SS_ASC=727 +INDEX_SS_DESC=728 +INDEX_SS=729 +INDEX_STATS=730 +INDEXTYPE=731 +INDEXTYPES=732 +INDICATOR=733 +INDICES=734 +INFINITE=735 +INFORMATIONAL=736 +INHERIT=737 +IN=738 +INITCAP=739 +INITIAL=740 +INITIALIZED=741 +INITIALLY=742 +INITRANS=743 +INLINE=744 +INLINE_XMLTYPE_NT=745 +INMEMORY=746 +IN_MEMORY_METADATA=747 +INMEMORY_PRUNING=748 +INNER=749 +INOUT=750 +INPLACE=751 +INPUTFORMAT=752 +INSERTCHILDXMLAFTER=753 +INSERTCHILDXMLBEFORE=754 +INSERTCHILDXML=755 +INSERT=756 +INSERTXMLAFTER=757 +INSERTXMLBEFORE=758 +INSTANCE=759 +INSTANCES=760 +INSTANTIABLE=761 +INSTANTLY=762 +INSTEAD=763 +INSTR2=764 +INSTR4=765 +INSTRB=766 +INSTRC=767 +INSTR=768 +INTEGER=769 +INTERLEAVED=770 +INTERMEDIATE=771 +INTERNAL_CONVERT=772 +INTERNAL_USE=773 +INTERPRETED=774 +INTERSECT=775 +INTERVAL=776 +INT=777 +INTERNAL=778 +INTO=779 +INVALIDATE=780 +INVALIDATION=781 +INVISIBLE=782 +IN_XQUERY=783 +IO_OPTIONS=784 +IS=785 +IS_LEAF=786 +ISOLATION=787 +ISOLATION_LEVEL=788 +ITEMS=789 +ITERATE=790 +ITERATION_NUMBER=791 +JAVA=792 +JOB=793 +JOIN=794 +JSON_ARRAYAGG=795 +JSON_ARRAY=796 +JSON_EQUAL=797 +JSON_EXISTS2=798 +JSON_EXISTS=799 +JSONGET=800 +JSON=801 +JSON_OBJECTAGG=802 +JSON_OBJECT=803 +JSONPARSE=804 +JSON_QUERY=805 +JSON_SERIALIZE=806 +JSON_TABLE=807 +JSON_TEXTCONTAINS2=808 +JSON_TEXTCONTAINS=809 +JSON_TRANSFORM=810 +JSON_VALUE=811 +K_LETTER=812 +KEEP_DUPLICATES=813 +KEEP=814 +KERBEROS=815 +KEY=816 +KEY_LENGTH=817 +KEYSIZE=818 +KEYS=819 +KEYSTORE=820 +KILL=821 +LABEL=822 +LANGUAGE=823 +LAST_DAY=824 +LAST=825 +LAST_VALUE=826 +LATERAL=827 +LATEST=828 +LAX=829 +LAYER=830 +LDAP_REGISTRATION_ENABLED=831 +LDAP_REGISTRATION=832 +LDAP_REG_SYNC_INTERVAL=833 +LDRTRIM=834 +LEAF=835 +LEAD_CDB=836 +LEAD_CDB_URI=837 +LEADING=838 +LEFT=839 +LENGTH2=840 +LENGTH4=841 +LENGTHB=842 +LENGTHC=843 +LENGTH=844 +LESS=845 +LEVEL=846 +LEVEL_NAME=847 +LEVELS=848 +LIBRARY=849 +LIFECYCLE=850 +LIFE=851 +LIFETIME=852 +LIKE2=853 +LIKE4=854 +LIKEC=855 +LIKE_EXPAND=856 +LIKE=857 +LIMIT=858 +LINEAR=859 +LINES=860 +LINK=861 +LIST=862 +LITTLE=863 +LLS=864 +LN=865 +LNNVL=866 +LOAD=867 +LOB=868 +LOBFILE=869 +LOBNVL=870 +LOBS=871 +LOCAL_INDEXES=872 +LOCAL=873 +LOCALTIME=874 +LOCALTIMESTAMP=875 +LOCATION=876 +LOCATOR=877 +LOCKDOWN=878 +LOCKED=879 +LOCKING=880 +LOCK=881 +LOGFILE=882 +LOGFILES=883 +LOGGING=884 +LOGICAL=885 +LOGICAL_READS_PER_CALL=886 +LOGICAL_READS_PER_SESSION=887 +LOG=888 +LOGMINING=889 +LOGOFF=890 +LOGON=891 +LOG_READ_ONLY_VIOLATIONS=892 +LONG=893 +LOOP=894 +LOST=895 +LOWER=896 +LOW=897 +LPAD=898 +LRTRIM=899 +LTRIM=900 +M_LETTER=901 +MAIN=902 +MAKE_REF=903 +MANAGED=904 +MANAGE=905 +MANAGEMENT=906 +MANAGER=907 +MANDATORY=908 +MANUAL=909 +MAP=910 +MAPPING=911 +MASK=912 +MASTER=913 +MATCHED=914 +MATCHES=915 +MATCH=916 +MATCH_NUMBER=917 +MATCH_RECOGNIZE=918 +MATERIALIZED=919 +MATERIALIZE=920 +MAXARCHLOGS=921 +MAXDATAFILES=922 +MAXEXTENTS=923 +MAXIMIZE=924 +MAXINSTANCES=925 +MAXLOGFILES=926 +MAXLOGHISTORY=927 +MAXLOGMEMBERS=928 +MAX_SHARED_TEMP_SIZE=929 +MAXSIZE=930 +MAXTRANS=931 +MAXVALUE=932 +MEASURE=933 +MEASURES=934 +MEDIUM=935 +MEMBER=936 +MEMBER_CAPTION=937 +MEMBER_DESCRIPTION=938 +MEMBER_NAME=939 +MEMBER_UNIQUE_NAME=940 +MEMCOMPRESS=941 +MEMORY=942 +MERGEACTIONS=943 +MERGE_AJ=944 +MERGE_CONST_ON=945 +MERGE=946 +MERGE_SJ=947 +METADATA=948 +METHOD=949 +MIGRATE=950 +MIGRATION=951 +MINEXTENTS=952 +MINIMIZE=953 +MINIMUM=954 +MINING=955 +MINUS=956 +MINUS_NULL=957 +MINUTE=958 +MINUTES=959 +MINVALUE=960 +MIRRORCOLD=961 +MIRRORHOT=962 +MIRROR=963 +MISSING=964 +MISMATCH=965 +MLSLABEL=966 +MODEL_COMPILE_SUBQUERY=967 +MODEL_DONTVERIFY_UNIQUENESS=968 +MODEL_DYNAMIC_SUBQUERY=969 +MODEL_MIN_ANALYSIS=970 +MODEL=971 +MODEL_NB=972 +MODEL_NO_ANALYSIS=973 +MODEL_PBY=974 +MODEL_PUSH_REF=975 +MODEL_SV=976 +MODE=977 +MODIFICATION=978 +MODIFY_COLUMN_TYPE=979 +MODIFY=980 +MOD=981 +MODULE=982 +MONITORING=983 +MONITOR=984 +MONTH=985 +MONTHS_BETWEEN=986 +MONTHS=987 +MOUNT=988 +MOUNTPATH=989 +MOUNTPOINT=990 +MOVEMENT=991 +MOVE=992 +MULTIDIMENSIONAL=993 +MULTISET=994 +MV_MERGE=995 +NAMED=996 +NAME=997 +NAMESPACE=998 +NAN_=999 +NANVL=1000 +NATIONAL=1001 +NATIVE_FULL_OUTER_JOIN=1002 +NATIVE=1003 +NATURAL=1004 +NATURALN=1005 +NAV=1006 +NCHAR_CS=1007 +NCHAR=1008 +NCHR=1009 +NCLOB=1010 +NEEDED=1011 +NEG=1012 +NESTED=1013 +NESTED_TABLE_FAST_INSERT=1014 +NESTED_TABLE_GET_REFS=1015 +NESTED_TABLE_ID=1016 +NESTED_TABLE_SET_REFS=1017 +NESTED_TABLE_SET_SETID=1018 +NETWORK=1019 +NEVER=1020 +NEW=1021 +NEWLINE_=1022 +NEW_TIME=1023 +NEXT_DAY=1024 +NEXT=1025 +NL_AJ=1026 +NLJ_BATCHING=1027 +NLJ_INDEX_FILTER=1028 +NLJ_INDEX_SCAN=1029 +NLJ_PREFETCH=1030 +NLS_CALENDAR=1031 +NLS_CHARACTERSET=1032 +NLS_CHARSET_DECL_LEN=1033 +NLS_CHARSET_ID=1034 +NLS_CHARSET_NAME=1035 +NLS_COMP=1036 +NLS_CURRENCY=1037 +NLS_DATE_FORMAT=1038 +NLS_DATE_LANGUAGE=1039 +NLS_INITCAP=1040 +NLS_ISO_CURRENCY=1041 +NL_SJ=1042 +NLS_LANG=1043 +NLS_LANGUAGE=1044 +NLS_LENGTH_SEMANTICS=1045 +NLS_LOWER=1046 +NLS_NCHAR_CONV_EXCP=1047 +NLS_NUMERIC_CHARACTERS=1048 +NLS_SORT=1049 +NLSSORT=1050 +NLS_SPECIAL_CHARS=1051 +NLS_TERRITORY=1052 +NLS_UPPER=1053 +NO_ACCESS=1054 +NO_ADAPTIVE_PLAN=1055 +NO_ANSI_REARCH=1056 +NOAPPEND=1057 +NOARCHIVELOG=1058 +NOAUDIT=1059 +NOBADFILE=1060 +NO_AUTO_REOPTIMIZE=1061 +NO_BASETABLE_MULTIMV_REWRITE=1062 +NO_BATCH_TABLE_ACCESS_BY_ROWID=1063 +NO_BIND_AWARE=1064 +NO_BUFFER=1065 +NOCACHE=1066 +NOCHECK=1067 +NO_CARTESIAN=1068 +NO_CHECK_ACL_REWRITE=1069 +NO_CLUSTER_BY_ROWID=1070 +NO_CLUSTERING=1071 +NO_COALESCE_SQ=1072 +NO_COMMON_DATA=1073 +NOCOMPRESS=1074 +NO_CONNECT_BY_CB_WHR_ONLY=1075 +NO_CONNECT_BY_COMBINE_SW=1076 +NO_CONNECT_BY_COST_BASED=1077 +NO_CONNECT_BY_ELIM_DUPS=1078 +NO_CONNECT_BY_FILTERING=1079 +NOCOPY=1080 +NO_COST_XML_QUERY_REWRITE=1081 +NO_CPU_COSTING=1082 +NOCPU_COSTING=1083 +NOCYCLE=1084 +NO_DATA_SECURITY_REWRITE=1085 +NO_DECORRELATE=1086 +NODELAY=1087 +NODIRECTIO=1088 +NODISCARDFILE=1089 +NO_DOMAIN_INDEX_FILTER=1090 +NO_DST_UPGRADE_INSERT_CONV=1091 +NO_ELIM_GROUPBY=1092 +NO_ELIMINATE_JOIN=1093 +NO_ELIMINATE_OBY=1094 +NO_ELIMINATE_OUTER_JOIN=1095 +NOENTITYESCAPING=1096 +NO_EXPAND_GSET_TO_UNION=1097 +NO_EXPAND=1098 +NO_EXPAND_TABLE=1099 +NOEXTEND=1100 +NO_FACT=1101 +NO_FACTORIZE_JOIN=1102 +NO_FILTERING=1103 +NOFORCE=1104 +NO_FULL_OUTER_JOIN_TO_OUTER=1105 +NO_GATHER_OPTIMIZER_STATISTICS=1106 +NO_GBY_PUSHDOWN=1107 +NOGUARANTEE=1108 +NO_INDEX_FFS=1109 +NO_INDEX=1110 +NO_INDEX_SS=1111 +NO_INMEMORY=1112 +NO_INMEMORY_PRUNING=1113 +NOKEEP=1114 +NO_LOAD=1115 +NOLOCAL=1116 +NOLOG=1117 +NOLOGFILE=1118 +NOLOGGING=1119 +NOMAPPING=1120 +NOMAXVALUE=1121 +NO_MERGE=1122 +NOMINIMIZE=1123 +NOMINVALUE=1124 +NO_MODEL_PUSH_REF=1125 +NO_MONITORING=1126 +NOMONITORING=1127 +NO_MONITOR=1128 +NO_MULTIMV_REWRITE=1129 +NO_NATIVE_FULL_OUTER_JOIN=1130 +NONBLOCKING=1131 +NONEDITIONABLE=1132 +NONE=1133 +NONULLIF=1134 +NO_NLJ_BATCHING=1135 +NO_NLJ_PREFETCH=1136 +NO=1137 +NONSCHEMA=1138 +NO_OBJECT_LINK=1139 +NOORDER=1140 +NO_ORDER_ROLLUPS=1141 +NO_OUTER_JOIN_TO_ANTI=1142 +NO_OUTER_JOIN_TO_INNER=1143 +NOOVERRIDE=1144 +NO_PARALLEL_INDEX=1145 +NOPARALLEL_INDEX=1146 +NO_PARALLEL=1147 +NOPARALLEL=1148 +NO_PARTIAL_COMMIT=1149 +NO_PARTIAL_JOIN=1150 +NO_PARTIAL_ROLLUP_PUSHDOWN=1151 +NOPARTITION=1152 +NO_PLACE_DISTINCT=1153 +NO_PLACE_GROUP_BY=1154 +NO_PQ_CONCURRENT_UNION=1155 +NO_PQ_MAP=1156 +NOPROMPT=1157 +NO_PQ_REPLICATE=1158 +NO_PQ_SKEW=1159 +NO_PRUNE_GSETS=1160 +NO_PULL_PRED=1161 +NO_PUSH_PRED=1162 +NO_PUSH_SUBQ=1163 +NO_PX_FAULT_TOLERANCE=1164 +NO_PX_JOIN_FILTER=1165 +NO_QKN_BUFF=1166 +NO_QUERY_TRANSFORMATION=1167 +NO_REF_CASCADE=1168 +NORELOCATE=1169 +NORELY=1170 +NOREPAIR=1171 +NOREPLAY=1172 +NORESETLOGS=1173 +NO_RESULT_CACHE=1174 +NOREVERSE=1175 +NO_REWRITE=1176 +NOREWRITE=1177 +NORMAL=1178 +NO_ROOT_SW_FOR_LOCAL=1179 +NOROWDEPENDENCIES=1180 +NOSCALE=1181 +NOSCHEMACHECK=1182 +NOSEGMENT=1183 +NO_SEMIJOIN=1184 +NO_SEMI_TO_INNER=1185 +NO_SET_TO_JOIN=1186 +NOSHARD=1187 +NOSORT=1188 +NO_SQL_TRANSLATION=1189 +NO_SQL_TUNE=1190 +NO_STAR_TRANSFORMATION=1191 +NO_STATEMENT_QUEUING=1192 +NO_STATS_GSETS=1193 +NOSTRICT=1194 +NO_SUBQUERY_PRUNING=1195 +NO_SUBSTRB_PAD=1196 +NO_SWAP_JOIN_INPUTS=1197 +NOSWITCH=1198 +NO_TABLE_LOOKUP_BY_NL=1199 +NO_TEMP_TABLE=1200 +NOTHING=1201 +NOTIFICATION=1202 +NOTRIM=1203 +NOT=1204 +NO_TRANSFORM_DISTINCT_AGG=1205 +NO_UNNEST=1206 +NO_USE_CUBE=1207 +NO_USE_HASH_AGGREGATION=1208 +NO_USE_HASH_GBY_FOR_PUSHDOWN=1209 +NO_USE_HASH=1210 +NO_USE_INVISIBLE_INDEXES=1211 +NO_USE_MERGE=1212 +NO_USE_NL=1213 +NO_USE_VECTOR_AGGREGATION=1214 +NOVALIDATE=1215 +NO_VECTOR_TRANSFORM_DIMS=1216 +NO_VECTOR_TRANSFORM_FACT=1217 +NO_VECTOR_TRANSFORM=1218 +NOWAIT=1219 +NO_XDB_FASTPATH_INSERT=1220 +NO_XML_DML_REWRITE=1221 +NO_XMLINDEX_REWRITE_IN_SELECT=1222 +NO_XMLINDEX_REWRITE=1223 +NO_XML_QUERY_REWRITE=1224 +NO_ZONEMAP=1225 +NTH_VALUE=1226 +NULLIF=1227 +NULL_=1228 +NULLS=1229 +NUMBER=1230 +NUMERIC=1231 +NUM_INDEX_KEYS=1232 +NUMTODSINTERVAL=1233 +NUMTOYMINTERVAL=1234 +NVARCHAR2=1235 +NVL2=1236 +OBJECT2XML=1237 +OBJECT=1238 +OBJ_ID=1239 +OBJNO=1240 +OBJNO_REUSE=1241 +OCCURENCES=1242 +OFFLINE=1243 +OFF=1244 +OFFSET=1245 +OF=1246 +OIDINDEX=1247 +OID=1248 +OLAP=1249 +OLD=1250 +OLD_PUSH_PRED=1251 +OLS=1252 +OLTP=1253 +OMIT=1254 +ONE=1255 +ONLINE=1256 +ONLINELOG=1257 +ONLY=1258 +ON=1259 +OPAQUE=1260 +OPAQUE_TRANSFORM=1261 +OPAQUE_XCANONICAL=1262 +OPCODE=1263 +OPEN=1264 +OPERATIONS=1265 +OPERATOR=1266 +OPT_ESTIMATE=1267 +OPTIMAL=1268 +OPTIMIZE=1269 +OPTIMIZER_FEATURES_ENABLE=1270 +OPTIMIZER_GOAL=1271 +OPTION=1272 +OPTIONALLY=1273 +OPT_PARAM=1274 +ORA_BRANCH=1275 +ORA_CHECK_ACL=1276 +ORA_CHECK_PRIVILEGE=1277 +ORA_CLUSTERING=1278 +ORADATA=1279 +ORC=1280 +ORACLE_DATE=1281 +ORACLE_NUMBER=1282 +ORADEBUG=1283 +ORA_DST_AFFECTED=1284 +ORA_DST_CONVERT=1285 +ORA_DST_ERROR=1286 +ORA_GET_ACLIDS=1287 +ORA_GET_PRIVILEGES=1288 +ORA_HASH=1289 +ORA_INVOKING_USERID=1290 +ORA_INVOKING_USER=1291 +ORA_INVOKING_XS_USER_GUID=1292 +ORA_INVOKING_XS_USER=1293 +ORA_RAWCOMPARE=1294 +ORA_RAWCONCAT=1295 +ORA_ROWSCN=1296 +ORA_ROWSCN_RAW=1297 +ORA_ROWVERSION=1298 +ORA_TABVERSION=1299 +ORA_WRITE_TIME=1300 +ORDERED=1301 +ORDERED_PREDICATES=1302 +ORDER=1303 +ORDINALITY=1304 +OR_EXPAND=1305 +ORGANIZATION=1306 +OR=1307 +OR_PREDICATES=1308 +OSERROR=1309 +OTHER=1310 +OUTER_JOIN_TO_ANTI=1311 +OUTER_JOIN_TO_INNER=1312 +OUTER=1313 +OUTLINE_LEAF=1314 +OUTLINE=1315 +OUTPUTFORMAT=1316 +OUT_OF_LINE=1317 +OUT=1318 +OVERFLOW_NOMOVE=1319 +OVERFLOW_=1320 +OVERLAPS=1321 +OVER=1322 +OVERRIDE=1323 +OVERRIDING=1324 +OWNER=1325 +OWNERSHIP=1326 +OWN=1327 +P_LETTER=1328 +PACKAGE=1329 +PACKAGES=1330 +PARALLEL_ENABLE=1331 +PARALLEL_INDEX=1332 +PARALLEL=1333 +PARAMETERFILE=1334 +PARAMETERS=1335 +PARAM=1336 +PARENT=1337 +PARENT_LEVEL_NAME=1338 +PARENT_UNIQUE_NAME=1339 +PARITY=1340 +PARQUET=1341 +PARTIAL_JOIN=1342 +PARTIALLY=1343 +PARTIAL=1344 +PARTIAL_ROLLUP_PUSHDOWN=1345 +PARTITION_HASH=1346 +PARTITION_LIST=1347 +PARTITION=1348 +PARTITION_RANGE=1349 +PARTITIONS=1350 +PARTNUMINST=1351 +PASSING=1352 +PASSWORD_GRACE_TIME=1353 +PASSWORD_LIFE_TIME=1354 +PASSWORD_LOCK_TIME=1355 +PASSWORD=1356 +PASSWORD_REUSE_MAX=1357 +PASSWORD_REUSE_TIME=1358 +PASSWORD_ROLLOVER_TIME=1359 +PASSWORD_VERIFY_FUNCTION=1360 +PAST=1361 +PATCH=1362 +PATH=1363 +PATH_PREFIX=1364 +PATHS=1365 +PATTERN=1366 +PBL_HS_BEGIN=1367 +PBL_HS_END=1368 +PCTFREE=1369 +PCTINCREASE=1370 +PCTTHRESHOLD=1371 +PCTUSED=1372 +PCTVERSION=1373 +PENDING=1374 +PERCENT_FOUND=1375 +PERCENT_ISOPEN=1376 +PERCENT_NOTFOUND=1377 +PERCENT_KEYWORD=1378 +PERCENT_RANKM=1379 +PERCENT_ROWCOUNT=1380 +PERCENT_ROWTYPE=1381 +PERCENT_TYPE=1382 +PERCENT_BULK_EXCEPTIONS=1383 +PERCENT_BULK_ROWCOUNT=1384 +PERFORMANCE=1385 +PERIOD_KEYWORD=1386 +PERMANENT=1387 +PERMISSION=1388 +PERMUTE=1389 +PER=1390 +PFILE=1391 +PHYSICAL=1392 +PIKEY=1393 +PIPELINED=1394 +PIPE=1395 +PIV_GB=1396 +PIVOT=1397 +PIV_SSF=1398 +PLACE_DISTINCT=1399 +PLACE_GROUP_BY=1400 +PLAN=1401 +PLSCOPE_SETTINGS=1402 +PLS_INTEGER=1403 +PLSQL_CCFLAGS=1404 +PLSQL_CODE_TYPE=1405 +PLSQL_DEBUG=1406 +PLSQL_OPTIMIZE_LEVEL=1407 +PLSQL_WARNINGS=1408 +PLUGGABLE=1409 +PMEM=1410 +POINT=1411 +POLICY=1412 +POOL_16K=1413 +POOL_2K=1414 +POOL_32K=1415 +POOL_4K=1416 +POOL_8K=1417 +POSITION=1418 +POSITIVEN=1419 +POSITIVE=1420 +POST_TRANSACTION=1421 +POWERMULTISET_BY_CARDINALITY=1422 +POWERMULTISET=1423 +POWER=1424 +PQ_CONCURRENT_UNION=1425 +PQ_DISTRIBUTE=1426 +PQ_DISTRIBUTE_WINDOW=1427 +PQ_FILTER=1428 +PQ_MAP=1429 +PQ_NOMAP=1430 +PQ_REPLICATE=1431 +PQ_SKEW=1432 +PRAGMA=1433 +PREBUILT=1434 +PRECEDES=1435 +PRECEDING=1436 +PRECISION=1437 +PRECOMPUTE_SUBQUERY=1438 +PREDICATE_REORDERS=1439 +PRELOAD=1440 +PREPARE=1441 +PREPROCESSOR=1442 +PRESENTNNV=1443 +PRESENT=1444 +PRESENTV=1445 +PRESERVE_OID=1446 +PRESERVE=1447 +PRETTY=1448 +PREVIOUS=1449 +PREV=1450 +PRIMARY=1451 +PRINTBLOBTOCLOB=1452 +PRIORITY=1453 +PRIOR=1454 +PRIVATE=1455 +PRIVATE_SGA=1456 +PRIVILEGED=1457 +PRIVILEGE=1458 +PRIVILEGES=1459 +PROCEDURAL=1460 +PROCEDURE=1461 +PROCESS=1462 +PROFILE=1463 +PROGRAM=1464 +PROJECT=1465 +PROPAGATE=1466 +PROPERTY=1467 +PROTECTED=1468 +PROTECTION=1469 +PROTOCOL=1470 +PROXY=1471 +PRUNING=1472 +PUBLIC=1473 +PULL_PRED=1474 +PURGE=1475 +PUSH_PRED=1476 +PUSH_SUBQ=1477 +PX_FAULT_TOLERANCE=1478 +PX_GRANULE=1479 +PX_JOIN_FILTER=1480 +QB_NAME=1481 +QUARTERS=1482 +QUERY_BLOCK=1483 +QUERY=1484 +QUEUE_CURR=1485 +QUEUE=1486 +QUEUE_ROWP=1487 +QUIESCE=1488 +QUORUM=1489 +QUOTA=1490 +QUOTAGROUP=1491 +RAISE=1492 +RANDOM_LOCAL=1493 +RANDOM=1494 +RANGE=1495 +RANKM=1496 +RAPIDLY=1497 +RAW=1498 +RAWTOHEX=1499 +RAWTONHEX=1500 +RBA=1501 +RBO_OUTLINE=1502 +RCFILE=1503 +RDBA=1504 +READ=1505 +READS=1506 +READSIZE=1507 +REALM=1508 +REAL=1509 +REBALANCE=1510 +REBUILD=1511 +RECORD=1512 +RECORDS=1513 +RECORDS_PER_BLOCK=1514 +RECOVERABLE=1515 +RECOVER=1516 +RECOVERY=1517 +RECYCLEBIN=1518 +RECYCLE=1519 +REDACTION=1520 +REDEFINE=1521 +REDO=1522 +REDUCED=1523 +REDUNDANCY=1524 +REF_CASCADE_CURSOR=1525 +REFERENCED=1526 +REFERENCE=1527 +REFERENCES=1528 +REFERENCING=1529 +REF=1530 +REFRESH=1531 +REFTOHEX=1532 +REGEXP_COUNT=1533 +REGEXP_INSTR=1534 +REGEXP_LIKE=1535 +REGEXP_REPLACE=1536 +REGEXP_SUBSTR=1537 +REGISTER=1538 +REGR_AVGX=1539 +REGR_AVGY=1540 +REGR_COUNT=1541 +REGR_INTERCEPT=1542 +REGR_R2=1543 +REGR_SLOPE=1544 +REGR_SXX=1545 +REGR_SXY=1546 +REGR_SYY=1547 +REGULAR=1548 +REJECT=1549 +REKEY=1550 +RELATIONAL=1551 +RELIES_ON=1552 +RELOCATE=1553 +RELY=1554 +REMAINDER=1555 +REMOTE=1556 +REMOTE_MAPPED=1557 +REMOVE=1558 +RENAME=1559 +REPAIR=1560 +REPEAT=1561 +REPLACE=1562 +REPLICATION=1563 +REQUIRED=1564 +RESETLOGS=1565 +RESET=1566 +RESIZE=1567 +RESOLVE=1568 +RESOLVER=1569 +RESOURCE=1570 +RESPECT=1571 +RESTART=1572 +RESTORE_AS_INTERVALS=1573 +RESTORE=1574 +RESTRICT_ALL_REF_CONS=1575 +RESTRICTED=1576 +RESTRICT_REFERENCES=1577 +RESTRICT=1578 +RESULT_CACHE=1579 +RESULT=1580 +RESUMABLE=1581 +RESUME=1582 +RETENTION=1583 +RETRY_ON_ROW_CHANGE=1584 +RETURNING=1585 +RETURN=1586 +REUSE=1587 +REVERSE=1588 +REVOKE=1589 +REWRITE_OR_ERROR=1590 +REWRITE=1591 +RIGHT=1592 +ROLE=1593 +ROLESET=1594 +ROLES=1595 +ROLLBACK=1596 +ROLLING=1597 +ROLLUP=1598 +ROWDEPENDENCIES=1599 +ROWID_MAPPING_TABLE=1600 +ROWID=1601 +ROWIDTOCHAR=1602 +ROWIDTONCHAR=1603 +ROW_LENGTH=1604 +ROWNUM=1605 +ROW=1606 +ROWS=1607 +RPAD=1608 +RTRIM=1609 +RULE=1610 +RULES=1611 +RUNNING=1612 +SALT=1613 +SAMPLE=1614 +SAVE_AS_INTERVALS=1615 +SAVEPOINT=1616 +SAVE=1617 +SB4=1618 +SCALE_ROWS=1619 +SCALE=1620 +SCAN_INSTANCES=1621 +SCAN=1622 +SCHEDULER=1623 +SCHEMACHECK=1624 +SCHEMA=1625 +SCN_ASCENDING=1626 +SCN=1627 +SCOPE=1628 +SCRUB=1629 +SD_ALL=1630 +SD_INHIBIT=1631 +SDO_GEOM_MBR=1632 +SDO_GEOMETRY=1633 +SD_SHOW=1634 +SEARCH=1635 +SECOND=1636 +SECONDS=1637 +SECRET=1638 +SECUREFILE_DBA=1639 +SECUREFILE=1640 +SECURITY=1641 +SEED=1642 +SEG_BLOCK=1643 +SEG_FILE=1644 +SEGMENT=1645 +SELECTIVITY=1646 +SELECT=1647 +SELF=1648 +SEMIJOIN_DRIVER=1649 +SEMIJOIN=1650 +SEMI_TO_INNER=1651 +SEQUENCED=1652 +SEQUENCE=1653 +SEQUENCEFILE=1654 +SEQUENTIAL=1655 +SEQ=1656 +SERDE=1657 +SERDEPROPERTIES=1658 +SERIALIZABLE=1659 +SERIALLY_REUSABLE=1660 +SERIAL=1661 +SERVERERROR=1662 +SERVICE_NAME_CONVERT=1663 +SERVICE=1664 +SERVICES=1665 +SESSION_CACHED_CURSORS=1666 +SESSION=1667 +SESSIONS_PER_USER=1668 +SESSIONTIMEZONE=1669 +SESSIONTZNAME=1670 +SET=1671 +SETS=1672 +SETTINGS=1673 +SET_TO_JOIN=1674 +SEVERE=1675 +SHARD=1676 +SHARDSPACE=1677 +SHARED_POOL=1678 +SHARED=1679 +SHARE=1680 +SHARING=1681 +SHELFLIFE=1682 +SHOW=1683 +SHRINK=1684 +SHUTDOWN=1685 +SIBLINGS=1686 +SID=1687 +SITE=1688 +SIGNAL_COMPONENT=1689 +SIGNAL_FUNCTION=1690 +SIGN=1691 +SIGNTYPE=1692 +SIMPLE_INTEGER=1693 +SIMPLE=1694 +SINGLE=1695 +SINGLETASK=1696 +SINH=1697 +SIN=1698 +SIZE=1699 +SIZES=1700 +SKIP_EXT_OPTIMIZER=1701 +SKIP_=1702 +SKIP_UNQ_UNUSABLE_IDX=1703 +SKIP_UNUSABLE_INDEXES=1704 +SMALLFILE=1705 +SMALLINT=1706 +SNAPSHOT=1707 +SOME=1708 +SORT=1709 +SOUNDEX=1710 +SOURCE_FILE_DIRECTORY=1711 +SOURCE_FILE_NAME_CONVERT=1712 +SOURCE=1713 +SPACE_KEYWORD=1714 +SPECIFICATION=1715 +SPFILE=1716 +SPLIT=1717 +SPREADSHEET=1718 +SQLDATA=1719 +SQLERROR=1720 +SQLLDR=1721 +SQL=1722 +FILE_EXT=1723 +SQL_MACRO=1724 +SQL_TRACE=1725 +SQL_TRANSLATION_PROFILE=1726 +SQRT=1727 +STALE=1728 +STANDALONE=1729 +STANDARD=1730 +STANDARD_HASH=1731 +STANDBY_MAX_DATA_DELAY=1732 +STANDBYS=1733 +STANDBY=1734 +STAR=1735 +STAR_TRANSFORMATION=1736 +START=1737 +STARTOF=1738 +STARTUP=1739 +STATEMENT_ID=1740 +STATEMENT_QUEUING=1741 +STATEMENTS=1742 +STATEMENT=1743 +STATE=1744 +STATIC=1745 +STATISTICS=1746 +STATS_BINOMIAL_TEST=1747 +STATS_CROSSTAB=1748 +STATS_F_TEST=1749 +STATS_KS_TEST=1750 +STATS_MODE=1751 +STATS_MW_TEST=1752 +STATS_ONE_WAY_ANOVA=1753 +STATS_T_TEST_INDEP=1754 +STATS_T_TEST_INDEPU=1755 +STATS_T_TEST_ONE=1756 +STATS_T_TEST_PAIRED=1757 +STATS_WSR_TEST=1758 +STDDEV_POP=1759 +STDDEV_SAMP=1760 +STOP=1761 +STORAGE=1762 +STORE=1763 +STREAMS=1764 +STREAM=1765 +STRICT=1766 +STRING=1767 +STRIPE_COLUMNS=1768 +STRIPE_WIDTH=1769 +STRIP=1770 +STRUCTURE=1771 +SUBMULTISET=1772 +SUBPARTITION_REL=1773 +SUBPARTITIONS=1774 +SUBPARTITION=1775 +SUBQUERIES=1776 +SUBQUERY_PRUNING=1777 +SUBSCRIBE=1778 +SUBSET=1779 +SUBSTITUTABLE=1780 +SUBSTR2=1781 +SUBSTR4=1782 +SUBSTRB=1783 +SUBSTRC=1784 +SUBTYPE=1785 +SUCCESSFUL=1786 +SUCCESS=1787 +SUMMARY=1788 +SUPPLEMENTAL=1789 +SUSPEND=1790 +SWAP_JOIN_INPUTS=1791 +SWITCHOVER=1792 +SWITCH=1793 +SYNCHRONOUS=1794 +SYNC=1795 +SYNONYM=1796 +SYS=1797 +SYSASM=1798 +SYS_AUDIT=1799 +SYSAUX=1800 +SYSBACKUP=1801 +SYS_CHECKACL=1802 +SYS_CHECK_PRIVILEGE=1803 +SYS_CONNECT_BY_PATH=1804 +SYS_CONTEXT=1805 +SYSDATE=1806 +SYSDBA=1807 +SYS_DBURIGEN=1808 +SYSDG=1809 +SYS_DL_CURSOR=1810 +SYS_DM_RXFORM_CHR=1811 +SYS_DM_RXFORM_NUM=1812 +SYS_DOM_COMPARE=1813 +SYS_DST_PRIM2SEC=1814 +SYS_DST_SEC2PRIM=1815 +SYS_ET_BFILE_TO_RAW=1816 +SYS_ET_BLOB_TO_IMAGE=1817 +SYS_ET_IMAGE_TO_BLOB=1818 +SYS_ET_RAW_TO_BFILE=1819 +SYS_EXTPDTXT=1820 +SYS_EXTRACT_UTC=1821 +SYS_FBT_INSDEL=1822 +SYS_FILTER_ACLS=1823 +SYS_FNMATCHES=1824 +SYS_FNREPLACE=1825 +SYS_GET_ACLIDS=1826 +SYS_GET_COL_ACLIDS=1827 +SYS_GET_PRIVILEGES=1828 +SYS_GETTOKENID=1829 +SYS_GETXTIVAL=1830 +SYS_GUID=1831 +SYSGUID=1832 +SYSKM=1833 +SYS_MAKE_XMLNODEID=1834 +SYS_MAKEXML=1835 +SYS_MKXMLATTR=1836 +SYS_MKXTI=1837 +SYSOBJ=1838 +SYS_OP_ADT2BIN=1839 +SYS_OP_ADTCONS=1840 +SYS_OP_ALSCRVAL=1841 +SYS_OP_ATG=1842 +SYS_OP_BIN2ADT=1843 +SYS_OP_BITVEC=1844 +SYS_OP_BL2R=1845 +SYS_OP_BLOOM_FILTER_LIST=1846 +SYS_OP_BLOOM_FILTER=1847 +SYS_OP_C2C=1848 +SYS_OP_CAST=1849 +SYS_OP_CEG=1850 +SYS_OP_CL2C=1851 +SYS_OP_COMBINED_HASH=1852 +SYS_OP_COMP=1853 +SYS_OP_CONVERT=1854 +SYS_OP_COUNTCHG=1855 +SYS_OP_CSCONV=1856 +SYS_OP_CSCONVTEST=1857 +SYS_OP_CSR=1858 +SYS_OP_CSX_PATCH=1859 +SYS_OP_CYCLED_SEQ=1860 +SYS_OP_DECOMP=1861 +SYS_OP_DESCEND=1862 +SYS_OP_DISTINCT=1863 +SYS_OP_DRA=1864 +SYS_OP_DUMP=1865 +SYS_OP_DV_CHECK=1866 +SYS_OP_ENFORCE_NOT_NULL=1867 +SYSOPER=1868 +SYS_OP_EXTRACT=1869 +SYS_OP_GROUPING=1870 +SYS_OP_GUID=1871 +SYS_OP_HASH=1872 +SYS_OP_IIX=1873 +SYS_OP_ITR=1874 +SYS_OP_KEY_VECTOR_CREATE=1875 +SYS_OP_KEY_VECTOR_FILTER_LIST=1876 +SYS_OP_KEY_VECTOR_FILTER=1877 +SYS_OP_KEY_VECTOR_SUCCEEDED=1878 +SYS_OP_KEY_VECTOR_USE=1879 +SYS_OP_LBID=1880 +SYS_OP_LOBLOC2BLOB=1881 +SYS_OP_LOBLOC2CLOB=1882 +SYS_OP_LOBLOC2ID=1883 +SYS_OP_LOBLOC2NCLOB=1884 +SYS_OP_LOBLOC2TYP=1885 +SYS_OP_LSVI=1886 +SYS_OP_LVL=1887 +SYS_OP_MAKEOID=1888 +SYS_OP_MAP_NONNULL=1889 +SYS_OP_MSR=1890 +SYS_OP_NICOMBINE=1891 +SYS_OP_NIEXTRACT=1892 +SYS_OP_NII=1893 +SYS_OP_NIX=1894 +SYS_OP_NOEXPAND=1895 +SYS_OP_NTCIMG=1896 +SYS_OP_NUMTORAW=1897 +SYS_OP_OIDVALUE=1898 +SYS_OP_OPNSIZE=1899 +SYS_OP_PAR_1=1900 +SYS_OP_PARGID_1=1901 +SYS_OP_PARGID=1902 +SYS_OP_PAR=1903 +SYS_OP_PART_ID=1904 +SYS_OP_PIVOT=1905 +SYS_OP_R2O=1906 +SYS_OP_RAWTONUM=1907 +SYS_OP_RDTM=1908 +SYS_OP_REF=1909 +SYS_OP_RMTD=1910 +SYS_OP_ROWIDTOOBJ=1911 +SYS_OP_RPB=1912 +SYS_OPTLOBPRBSC=1913 +SYS_OP_TOSETID=1914 +SYS_OP_TPR=1915 +SYS_OP_TRTB=1916 +SYS_OPTXICMP=1917 +SYS_OPTXQCASTASNQ=1918 +SYS_OP_UNDESCEND=1919 +SYS_OP_VECAND=1920 +SYS_OP_VECBIT=1921 +SYS_OP_VECOR=1922 +SYS_OP_VECXOR=1923 +SYS_OP_VERSION=1924 +SYS_OP_VREF=1925 +SYS_OP_VVD=1926 +SYS_OP_XMLCONS_FOR_CSX=1927 +SYS_OP_XPTHATG=1928 +SYS_OP_XPTHIDX=1929 +SYS_OP_XPTHOP=1930 +SYS_OP_XTXT2SQLT=1931 +SYS_OP_ZONE_ID=1932 +SYS_ORDERKEY_DEPTH=1933 +SYS_ORDERKEY_MAXCHILD=1934 +SYS_ORDERKEY_PARENT=1935 +SYS_PARALLEL_TXN=1936 +SYS_PATHID_IS_ATTR=1937 +SYS_PATHID_IS_NMSPC=1938 +SYS_PATHID_LASTNAME=1939 +SYS_PATHID_LASTNMSPC=1940 +SYS_PATH_REVERSE=1941 +SYS_PXQEXTRACT=1942 +SYS_RAW_TO_XSID=1943 +SYS_RID_ORDER=1944 +SYS_ROW_DELTA=1945 +SYS_SC_2_XMLT=1946 +SYS_SYNRCIREDO=1947 +SYSTEM_DEFINED=1948 +SYSTEM=1949 +SYSTIMESTAMP=1950 +SYS_TYPEID=1951 +SYS_UMAKEXML=1952 +SYS_XMLANALYZE=1953 +SYS_XMLCONTAINS=1954 +SYS_XMLCONV=1955 +SYS_XMLEXNSURI=1956 +SYS_XMLGEN=1957 +SYS_XMLI_LOC_ISNODE=1958 +SYS_XMLI_LOC_ISTEXT=1959 +SYS_XMLINSTR=1960 +SYS_XMLLOCATOR_GETSVAL=1961 +SYS_XMLNODEID_GETCID=1962 +SYS_XMLNODEID_GETLOCATOR=1963 +SYS_XMLNODEID_GETOKEY=1964 +SYS_XMLNODEID_GETPATHID=1965 +SYS_XMLNODEID_GETPTRID=1966 +SYS_XMLNODEID_GETRID=1967 +SYS_XMLNODEID_GETSVAL=1968 +SYS_XMLNODEID_GETTID=1969 +SYS_XMLNODEID=1970 +SYS_XMLT_2_SC=1971 +SYS_XMLTRANSLATE=1972 +SYS_XMLTYPE2SQL=1973 +SYS_XQ_ASQLCNV=1974 +SYS_XQ_ATOMCNVCHK=1975 +SYS_XQBASEURI=1976 +SYS_XQCASTABLEERRH=1977 +SYS_XQCODEP2STR=1978 +SYS_XQCODEPEQ=1979 +SYS_XQCON2SEQ=1980 +SYS_XQCONCAT=1981 +SYS_XQDELETE=1982 +SYS_XQDFLTCOLATION=1983 +SYS_XQDOC=1984 +SYS_XQDOCURI=1985 +SYS_XQDURDIV=1986 +SYS_XQED4URI=1987 +SYS_XQENDSWITH=1988 +SYS_XQERRH=1989 +SYS_XQERR=1990 +SYS_XQESHTMLURI=1991 +SYS_XQEXLOBVAL=1992 +SYS_XQEXSTWRP=1993 +SYS_XQEXTRACT=1994 +SYS_XQEXTRREF=1995 +SYS_XQEXVAL=1996 +SYS_XQFB2STR=1997 +SYS_XQFNBOOL=1998 +SYS_XQFNCMP=1999 +SYS_XQFNDATIM=2000 +SYS_XQFNLNAME=2001 +SYS_XQFNNM=2002 +SYS_XQFNNSURI=2003 +SYS_XQFNPREDTRUTH=2004 +SYS_XQFNQNM=2005 +SYS_XQFNROOT=2006 +SYS_XQFORMATNUM=2007 +SYS_XQFTCONTAIN=2008 +SYS_XQFUNCR=2009 +SYS_XQGETCONTENT=2010 +SYS_XQINDXOF=2011 +SYS_XQINSERT=2012 +SYS_XQINSPFX=2013 +SYS_XQIRI2URI=2014 +SYS_XQLANG=2015 +SYS_XQLLNMFRMQNM=2016 +SYS_XQMKNODEREF=2017 +SYS_XQNILLED=2018 +SYS_XQNODENAME=2019 +SYS_XQNORMSPACE=2020 +SYS_XQNORMUCODE=2021 +SYS_XQ_NRNG=2022 +SYS_XQNSP4PFX=2023 +SYS_XQNSPFRMQNM=2024 +SYS_XQPFXFRMQNM=2025 +SYS_XQ_PKSQL2XML=2026 +SYS_XQPOLYABS=2027 +SYS_XQPOLYADD=2028 +SYS_XQPOLYCEL=2029 +SYS_XQPOLYCSTBL=2030 +SYS_XQPOLYCST=2031 +SYS_XQPOLYDIV=2032 +SYS_XQPOLYFLR=2033 +SYS_XQPOLYMOD=2034 +SYS_XQPOLYMUL=2035 +SYS_XQPOLYRND=2036 +SYS_XQPOLYSQRT=2037 +SYS_XQPOLYSUB=2038 +SYS_XQPOLYUMUS=2039 +SYS_XQPOLYUPLS=2040 +SYS_XQPOLYVEQ=2041 +SYS_XQPOLYVGE=2042 +SYS_XQPOLYVGT=2043 +SYS_XQPOLYVLE=2044 +SYS_XQPOLYVLT=2045 +SYS_XQPOLYVNE=2046 +SYS_XQREF2VAL=2047 +SYS_XQRENAME=2048 +SYS_XQREPLACE=2049 +SYS_XQRESVURI=2050 +SYS_XQRNDHALF2EVN=2051 +SYS_XQRSLVQNM=2052 +SYS_XQRYENVPGET=2053 +SYS_XQRYVARGET=2054 +SYS_XQRYWRP=2055 +SYS_XQSEQ2CON4XC=2056 +SYS_XQSEQ2CON=2057 +SYS_XQSEQDEEPEQ=2058 +SYS_XQSEQINSB=2059 +SYS_XQSEQRM=2060 +SYS_XQSEQRVS=2061 +SYS_XQSEQSUB=2062 +SYS_XQSEQTYPMATCH=2063 +SYS_XQSTARTSWITH=2064 +SYS_XQSTATBURI=2065 +SYS_XQSTR2CODEP=2066 +SYS_XQSTRJOIN=2067 +SYS_XQSUBSTRAFT=2068 +SYS_XQSUBSTRBEF=2069 +SYS_XQTOKENIZE=2070 +SYS_XQTREATAS=2071 +SYS_XQ_UPKXML2SQL=2072 +SYS_XQXFORM=2073 +SYS_XSID_TO_RAW=2074 +SYS_ZMAP_FILTER=2075 +SYS_ZMAP_REFRESH=2076 +T_LETTER=2077 +TABLE_LOOKUP_BY_NL=2078 +TABLESPACE_NO=2079 +TABLESPACE=2080 +TABLES=2081 +TABLE_STATS=2082 +TABLE=2083 +TABNO=2084 +TAG=2085 +TANH=2086 +TAN=2087 +TBLORIDXPARTNUM=2088 +TEMPFILE=2089 +TEMPLATE=2090 +TEMPLATE_TABLE=2091 +TEMPORARY=2092 +TEMP_TABLE=2093 +TERMINATED=2094 +TEST=2095 +TEXT=2096 +TEXTFILE=2097 +THAN=2098 +THEN=2099 +THE=2100 +THESE=2101 +THREAD=2102 +THROUGH=2103 +TIER=2104 +TIES=2105 +TIMEOUT=2106 +TIMESTAMP_LTZ_UNCONSTRAINED=2107 +TIMESTAMP=2108 +TIMESTAMP_TZ_UNCONSTRAINED=2109 +TIMESTAMP_UNCONSTRAINED=2110 +TIMES=2111 +TIME=2112 +TIMEZONE=2113 +TIMEZONE_ABBR=2114 +TIMEZONE_HOUR=2115 +TIMEZONE_MINUTE=2116 +TIMEZONE_OFFSET=2117 +TIMEZONE_REGION=2118 +TIME_ZONE=2119 +TIMING=2120 +TINYINT=2121 +TIV_GB=2122 +TIV_SSF=2123 +TO_ACLID=2124 +TO_BINARY_DOUBLE=2125 +TO_BINARY_FLOAT=2126 +TO_BLOB=2127 +TO_CLOB=2128 +TO_DSINTERVAL=2129 +TO_LOB=2130 +TO_MULTI_BYTE=2131 +TO_NCHAR=2132 +TO_NCLOB=2133 +TO_NUMBER=2134 +TOPLEVEL=2135 +TO_SINGLE_BYTE=2136 +TO_TIMESTAMP=2137 +TO_TIMESTAMP_TZ=2138 +TO_TIME=2139 +TO_TIME_TZ=2140 +TO=2141 +TO_YMINTERVAL=2142 +TRACE=2143 +TRACING=2144 +TRACKING=2145 +TRAILING=2146 +TRANSACTION=2147 +TRANSFORM=2148 +TRANSFORMS=2149 +TRANSFORM_DISTINCT_AGG=2150 +TRANSITIONAL=2151 +TRANSITION=2152 +TRANSLATE=2153 +TRANSLATION=2154 +TREAT=2155 +TRIGGERS=2156 +TRIGGER=2157 +TRUE=2158 +TRUNCATE=2159 +TRUNC=2160 +TRUSTED=2161 +TRUST=2162 +TUNING=2163 +TX=2164 +TYPES=2165 +TYPE=2166 +TZ_OFFSET=2167 +UB2=2168 +UBA=2169 +UCS2=2170 +UDF=2171 +UID=2172 +UNARCHIVED=2173 +UNBOUNDED=2174 +UNBOUND=2175 +UNCONDITIONAL=2176 +UNDER=2177 +UNDO=2178 +UNDROP=2179 +UNIFORM=2180 +UNION=2181 +UNIONTYPE=2182 +UNIQUE=2183 +UNISTR=2184 +UNLIMITED=2185 +UNLOAD=2186 +UNLOCK=2187 +UNMATCHED=2188 +UNNEST_INNERJ_DISTINCT_VIEW=2189 +UNNEST_NOSEMIJ_NODISTINCTVIEW=2190 +UNNEST_SEMIJ_VIEW=2191 +UNNEST=2192 +UNPACKED=2193 +UNPIVOT=2194 +UNPLUG=2195 +UNPROTECTED=2196 +UNQUIESCE=2197 +UNRECOVERABLE=2198 +UNRESTRICTED=2199 +UNSIGNED=2200 +UNSUBSCRIBE=2201 +UNTIL=2202 +UNUSABLE=2203 +UNUSED=2204 +UPDATABLE=2205 +UPDATED=2206 +UPDATE=2207 +UPDATEXML=2208 +UPD_INDEXES=2209 +UPD_JOININDEX=2210 +UPGRADE=2211 +UPPER=2212 +UPSERT=2213 +UROWID=2214 +USABLE=2215 +USAGE=2216 +USE_ANTI=2217 +USE_CONCAT=2218 +USE_CUBE=2219 +USE_HASH_AGGREGATION=2220 +USE_HASH_GBY_FOR_PUSHDOWN=2221 +USE_HASH=2222 +USE_HIDDEN_PARTITIONS=2223 +USE_INVISIBLE_INDEXES=2224 +USE_MERGE_CARTESIAN=2225 +USE_MERGE=2226 +USE_NL=2227 +USE_NL_WITH_INDEX=2228 +USE_PRIVATE_OUTLINES=2229 +USER_DATA=2230 +USER_DEFINED=2231 +USERENV=2232 +USERGROUP=2233 +USER_RECYCLEBIN=2234 +USERS=2235 +USER_TABLESPACES=2236 +USER=2237 +USE_SEMI=2238 +USE_STORED_OUTLINES=2239 +USE_TTT_FOR_GSETS=2240 +USE=2241 +USE_VECTOR_AGGREGATION=2242 +USE_WEAK_NAME_RESL=2243 +USING_NO_EXPAND=2244 +USING_NLS_COMP=2245 +USING=2246 +UTF16BE=2247 +UTF16LE=2248 +UTF32=2249 +UTF8=2250 +V1=2251 +V2=2252 +VALIDATE=2253 +VALIDATE_CONVERSION=2254 +VALIDATION=2255 +VALID_TIME_END=2256 +VALUES=2257 +VALUE=2258 +VARCHAR2=2259 +VARCHAR=2260 +VARCHARC=2261 +VARIABLE=2262 +VARRAW=2263 +VARRAWC=2264 +VAR_POP=2265 +VARRAYS=2266 +VARRAY=2267 +VAR_SAMP=2268 +VARYING=2269 +VECTOR_READ_TRACE=2270 +VECTOR_READ=2271 +VECTOR_TRANSFORM_DIMS=2272 +VECTOR_TRANSFORM_FACT=2273 +VECTOR_TRANSFORM=2274 +VERIFIER=2275 +VERIFY=2276 +VERSIONING=2277 +VERSIONS_ENDSCN=2278 +VERSIONS_ENDTIME=2279 +VERSIONS_OPERATION=2280 +VERSIONS_STARTSCN=2281 +VERSIONS_STARTTIME=2282 +VERSIONS=2283 +VERSIONS_XID=2284 +VERSION=2285 +VIEW=2286 +VIOLATION=2287 +VIRTUAL=2288 +VISIBILITY=2289 +VISIBLE=2290 +VOLUME=2291 +VSIZE=2292 +WAIT=2293 +WALLET=2294 +WARNING=2295 +WEEKS=2296 +WEEK=2297 +WELLFORMED=2298 +WHENEVER=2299 +WHEN=2300 +WHERE=2301 +WHILE=2302 +WHITESPACE=2303 +WIDTH_BUCKET=2304 +WITHIN=2305 +WITHOUT=2306 +WITH_PLSQL=2307 +WITH=2308 +WORK=2309 +WORKERID=2310 +WRAPPED=2311 +WRAPPER=2312 +WRITE=2313 +XDB_FASTPATH_INSERT=2314 +XDB=2315 +X_DYN_PRUNE=2316 +XID=2317 +XML2OBJECT=2318 +XMLAGG=2319 +XMLATTRIBUTES=2320 +XMLCAST=2321 +XMLCDATA=2322 +XMLCOLATTVAL=2323 +XMLCOMMENT=2324 +XMLCONCAT=2325 +XMLDIFF=2326 +XML_DML_RWT_STMT=2327 +XMLELEMENT=2328 +XMLEXISTS2=2329 +XMLEXISTS=2330 +XMLFOREST=2331 +XMLINDEX=2332 +XMLINDEX_REWRITE_IN_SELECT=2333 +XMLINDEX_REWRITE=2334 +XMLINDEX_SEL_IDX_TBL=2335 +XMLISNODE=2336 +XMLISVALID=2337 +XMLNAMESPACES=2338 +XMLPARSE=2339 +XMLPATCH=2340 +XMLPI=2341 +XMLQUERYVAL=2342 +XMLQUERY=2343 +XMLROOT=2344 +XMLSCHEMA=2345 +XMLSERIALIZE=2346 +XMLTABLE=2347 +XMLTAG=2348 +XMLTRANSFORMBLOB=2349 +XMLTRANSFORM=2350 +XMLTYPE=2351 +XML=2352 +XPATHTABLE=2353 +XS_SYS_CONTEXT=2354 +XS=2355 +XTRANSPORT=2356 +YEARS=2357 +YEAR=2358 +YEAR_TO_MONTH=2359 +YES=2360 +YMINTERVAL_UNCONSTRAINED=2361 +ZONEMAP=2362 +ZONE=2363 +ZONED=2364 +PREDICTION=2365 +PREDICTION_BOUNDS=2366 +PREDICTION_COST=2367 +PREDICTION_DETAILS=2368 +PREDICTION_PROBABILITY=2369 +PREDICTION_SET=2370 +BLOCKCHAIN=2371 +COLLATE=2372 +COLLATION=2373 +DEFINITION=2374 +DUPLICATED=2375 +EXTENDED=2376 +HASHING=2377 +IDLE=2378 +IMMUTABLE=2379 +ORACLE_DATAPUMP=2380 +ORACLE_HDFS=2381 +ORACLE_HIVE=2382 +ORACLE_LOADER=2383 +SHA2_512_Q=2384 +SHARDED=2385 +V1_Q=2386 +ISOLATE=2387 +ROOT=2388 +UNITE=2389 +ALGORITHM=2390 +CUME_DIST=2391 +DENSE_RANK=2392 +LISTAGG=2393 +PERCENT_RANK=2394 +PERCENTILE_CONT=2395 +PERCENTILE_DISC=2396 +RANK=2397 +AVG=2398 +CORR=2399 +COVAR_=2400 +DECODE=2401 +LAG=2402 +LAG_DIFF=2403 +LAG_DIFF_PERCENT=2404 +LEAD=2405 +MAX=2406 +MEDIAN=2407 +MEMOPTIMIZE=2408 +MIN=2409 +NTILE=2410 +NVL=2411 +RATIO_TO_REPORT=2412 +REGR_=2413 +ROUND=2414 +ROW_NUMBER=2415 +SUBSTR=2416 +TO_CHAR=2417 +TRIM=2418 +SUM=2419 +STDDEV=2420 +VAR_=2421 +VARIANCE=2422 +LEAST=2423 +GREATEST=2424 +TO_DATE=2425 +CHARSETID=2426 +CHARSETFORM=2427 +DURATION=2428 +EXTEND=2429 +MAXLEN=2430 +PERSISTABLE=2431 +POLYMORPHIC=2432 +STRUCT=2433 +TDO=2434 +WM_CONCAT=2435 +NATIONAL_CHAR_STRING_LIT=2436 +BIT_STRING_LIT=2437 +HEX_STRING_LIT=2438 +DOUBLE_PERIOD=2439 +PERIOD=2440 +UNSIGNED_INTEGER=2441 +APPROXIMATE_NUM_LIT=2442 +CHAR_STRING=2443 +DELIMITED_ID=2444 +PERCENT=2445 +AMPERSAND=2446 +LEFT_PAREN=2447 +RIGHT_PAREN=2448 +DOUBLE_ASTERISK=2449 +ASTERISK=2450 +PLUS_SIGN=2451 +MINUS_SIGN=2452 +COMMA=2453 +SOLIDUS=2454 +RSOLIDUS=2455 +AT_SIGN=2456 +ASSIGN_OP=2457 +HASH_OP=2458 +LEFT_CURLY_PAREN=2459 +RIGHT_CURLY_PAREN=2460 +SQ=2461 +BINDVAR=2462 +NOT_EQUAL_OP=2463 +CARRET_OPERATOR_PART=2464 +TILDE_OPERATOR_PART=2465 +EXCLAMATION_OPERATOR_PART=2466 +GREATER_THAN_OP=2467 +LESS_THAN_OP=2468 +COLON=2469 +SEMICOLON=2470 +BAR=2471 +EQUALS_OP=2472 +LEFT_BRACKET=2473 +RIGHT_BRACKET=2474 +INTRODUCER=2475 +SINGLE_LINE_COMMENT=2476 +MULTI_LINE_COMMENT=2477 +REMARK_COMMENT=2478 +PROMPT_MESSAGE=2479 +REGULAR_ID=2480 +INQUIRY_DIRECTIVE=2481 +SPACES=2482 +'ABORT'=1 +'ABS'=2 +'ABSENT'=3 +'ACCESS'=4 +'ACCESSED'=5 +'ACCESSIBLE'=6 +'ACCOUNT'=7 +'ACL'=8 +'ACOS'=9 +'ACROSS'=10 +'ACTION'=11 +'ACTIONS'=12 +'ACTIVATE'=13 +'ACTIVE'=14 +'ACTIVE_COMPONENT'=15 +'ACTIVE_DATA'=16 +'ACTIVE_FUNCTION'=17 +'ACTIVE_TAG'=18 +'ACTIVITY'=19 +'ADAPTIVE_PLAN'=20 +'ADD'=21 +'ADD_COLUMN'=22 +'ADD_GROUP'=23 +'ADD_MONTHS'=24 +'ADJ_DATE'=25 +'ADMIN'=26 +'ADMINISTER'=27 +'ADMINISTRATOR'=28 +'ADVANCED'=29 +'ADVISE'=30 +'ADVISOR'=31 +'AFD_DISKSTRING'=32 +'AFTER'=33 +'AGENT'=34 +'AGGREGATE'=35 +'A'=36 +'ALIAS'=37 +'ALL'=38 +'ALLOCATE'=39 +'ALLOW'=40 +'ALL_ROWS'=41 +'ALTER'=42 +'ALTERNATE'=43 +'ALWAYS'=44 +'ANALYTIC'=45 +'ANALYZE'=46 +'ANCESTOR'=47 +'ANCILLARY'=48 +'AND'=49 +'AND_EQUAL'=50 +'ANNOTATIONS'=51 +'ANOMALY'=52 +'ANSI_REARCH'=53 +'ANTIJOIN'=54 +'ANY'=55 +'ANYSCHEMA'=56 +'APPEND'=57 +'APPENDCHILDXML'=58 +'APPEND_VALUES'=59 +'APPLICATION'=60 +'APPLY'=61 +'APPROX_COUNT_DISTINCT'=62 +'ARCHIVAL'=63 +'ARCHIVE'=64 +'ARCHIVED'=65 +'ARCHIVELOG'=66 +'ARE'=67 +'ARRAY'=68 +'AS'=69 +'ASC'=70 +'ASCII'=71 +'ASCIISTR'=72 +'ASIN'=73 +'ASIS'=74 +'ASSEMBLY'=75 +'ASSIGN'=76 +'ASSOCIATE'=77 +'ASYNC'=78 +'ASYNCHRONOUS'=79 +'ATAN2'=80 +'ATAN'=81 +'AT'=82 +'ATTRIBUTE'=83 +'ATTRIBUTES'=84 +'AUDIT'=85 +'AUTHENTICATED'=86 +'AUTHENTICATION'=87 +'AUTHID'=88 +'AUTHORIZATION'=89 +'AUTOALLOCATE'=90 +'AUTO'=91 +'AUTOBACKUP'=92 +'AUTOEXTEND'=93 +'AUTO_LOGIN'=94 +'AUTOMATIC'=95 +'AUTONOMOUS_TRANSACTION'=96 +'AUTO_REOPTIMIZE'=97 +'AVAILABILITY'=98 +'AVRO'=99 +'BACKGROUND'=100 +'BACKINGFILE'=101 +'BACKUP'=102 +'BACKUPS'=103 +'BACKUPSET'=104 +'BADFILE'=105 +'BASIC'=106 +'BASICFILE'=107 +'BATCH'=108 +'BATCHSIZE'=109 +'BATCH_TABLE_ACCESS_BY_ROWID'=110 +'BECOME'=111 +'BEFORE'=112 +'BEGIN'=113 +'BEGINNING'=114 +'BEGIN_OUTLINE_DATA'=115 +'BEHALF'=116 +'BEQUEATH'=117 +'BETWEEN'=118 +'BFILE'=119 +'BFILENAME'=120 +'BIG'=121 +'BIGFILE'=122 +'BIGINT'=123 +'BINARY'=124 +'BINARY_DOUBLE'=125 +'BINARY_DOUBLE_INFINITY'=126 +'BINARY_DOUBLE_NAN'=127 +'BINARY_FLOAT'=128 +'BINARY_FLOAT_INFINITY'=129 +'BINARY_FLOAT_NAN'=130 +'BINARY_INTEGER'=131 +'BIND_AWARE'=132 +'BINDING'=133 +'BIN_TO_NUM'=134 +'BITAND'=135 +'BITMAP_AND'=136 +'BITMAP'=137 +'BITMAPS'=138 +'BITMAP_TREE'=139 +'BITS'=140 +'BLANKS'=141 +'BLOB'=142 +'BLOCK'=143 +'BLOCK_RANGE'=144 +'BLOCKS'=145 +'BLOCKSIZE'=146 +'BODY'=147 +'BOOLEAN'=148 +'BOTH'=149 +'BOUND'=150 +'BRANCH'=151 +'BREADTH'=152 +'BROADCAST'=153 +'BSON'=154 +'BUFFER'=155 +'BUFFER_CACHE'=156 +'BUFFER_POOL'=157 +'BUILD'=158 +'BULK'=159 +'BY'=160 +'BYPASS_RECURSIVE_CHECK'=161 +'BYPASS_UJVC'=162 +'BYTE'=163 +'BYTES'=164 +'BYTEORDERMARK'=165 +'CACHE'=166 +'CACHE_CB'=167 +'CACHE_INSTANCES'=168 +'CACHE_TEMP_TABLE'=169 +'CACHING'=170 +'CALCULATED'=171 +'CALLBACK'=172 +'CALL'=173 +'CANCEL'=174 +'CANONICAL'=175 +'CAPACITY'=176 +'CAPTION'=177 +'CARDINALITY'=178 +'CASCADE'=179 +'CASE'=180 +'CAST'=181 +'CASE-SENSITIVE'=182 +'CATEGORY'=183 +'CDB$DEFAULT'=184 +'CEIL'=185 +'CELL_FLASH_CACHE'=186 +'CERTIFICATE'=187 +'CFILE'=188 +'CHAINED'=189 +'CHANGE'=190 +'CHANGETRACKING'=191 +'CHANGE_DUPKEY_ERROR_INDEX'=192 +'CHARACTER'=193 +'CHARACTERS'=194 +'CHARACTERSET'=195 +'CHAR'=196 +'CHAR_CS'=197 +'CHARTOROWID'=198 +'CHECK_ACL_REWRITE'=199 +'CHECK'=200 +'CHECKPOINT'=201 +'CHILD'=202 +'CHOOSE'=203 +'CHR'=204 +'CHUNK'=205 +'CLASS'=206 +'CLASSIFICATION'=207 +'CLASSIFIER'=208 +'CLAUSE'=209 +'CLEAN'=210 +'CLEANUP'=211 +'CLEAR'=212 +'C'=213 +'CLIENT'=214 +'CLOB'=215 +'CLONE'=216 +'CLOSE_CACHED_OPEN_CURSORS'=217 +'CLOSE'=218 +'CLUSTER_BY_ROWID'=219 +'CLUSTER'=220 +'CLUSTER_DETAILS'=221 +'CLUSTER_DISTANCE'=222 +'CLUSTER_ID'=223 +'CLUSTERING'=224 +'CLUSTERING_FACTOR'=225 +'CLUSTER_PROBABILITY'=226 +'CLUSTER_SET'=227 +'COALESCE'=228 +'COALESCE_SQ'=229 +'COARSE'=230 +'CO_AUTH_IND'=231 +'COLD'=232 +'COLLECT'=233 +'COLLECTION'=234 +'COLUMNAR'=235 +'COLUMN_AUTH_INDICATOR'=236 +'COLUMN'=237 +'COLUMNS'=238 +'COLUMN_STATS'=239 +'COLUMN_VALUE'=240 +'COMMENT'=241 +'COMMIT'=242 +'COMMITTED'=243 +'COMMON'=244 +'COMMON_DATA'=245 +'COMPACT'=246 +'COMPATIBLE'=247 +'COMPATIBILITY'=248 +'COMPILE'=249 +'COMPLETE'=250 +'COMPLIANCE'=251 +'COMPONENT'=252 +'COMPONENTS'=253 +'COMPOSE'=254 +'COMPOSITE'=255 +'COMPOSITE_LIMIT'=256 +'COMPOUND'=257 +'COMPRESS'=258 +'COMPRESSION'=259 +'COMPUTE'=260 +'COMPUTATION'=261 +'CONCAT'=262 +'CONCURRENT'=263 +'CON_DBID_TO_ID'=264 +'CONDITIONAL'=265 +'CONDITION'=266 +'CONFIRM'=267 +'CONFORMING'=268 +'CON_GUID_TO_ID'=269 +'CON_ID'=270 +'CON_NAME_TO_ID'=271 +'CONNECT_BY_CB_WHR_ONLY'=272 +'CONNECT_BY_COMBINE_SW'=273 +'CONNECT_BY_COST_BASED'=274 +'CONNECT_BY_ELIM_DUPS'=275 +'CONNECT_BY_FILTERING'=276 +'CONNECT_BY_ISCYCLE'=277 +'CONNECT_BY_ISLEAF'=278 +'CONNECT_BY_ROOT'=279 +'CONNECT'=280 +'CONNECT_TIME'=281 +'CONSIDER'=282 +'CONSISTENT'=283 +'CONSTANT'=284 +'CONST'=285 +'CONSTRAINT'=286 +'CONSTRAINTS'=287 +'CONSTRUCTOR'=288 +'CONTAINER'=289 +'CONTAINERS'=290 +'CONTAINERS_DEFAULT'=291 +'CONTAINER_DATA'=292 +'CONTAINER_MAP'=293 +'CONTENT'=294 +'CONTENTS'=295 +'CONTEXT'=296 +'CONTINUE'=297 +'CONTROLFILE'=298 +'CON_UID_TO_ID'=299 +'CONVERT'=300 +'CONVERSION'=301 +'COOKIE'=302 +'COPY'=303 +'CORR_K'=304 +'CORR_S'=305 +'CORRUPTION'=306 +'CORRUPT_XID_ALL'=307 +'CORRUPT_XID'=308 +'COS'=309 +'COSH'=310 +'COST'=311 +'COST_XML_QUERY_REWRITE'=312 +'COUNT'=313 +'COUNTED'=314 +'COVAR_POP'=315 +'COVAR_SAMP'=316 +'CPU_COSTING'=317 +'CPU_PER_CALL'=318 +'CPU_PER_SESSION'=319 +'CRASH'=320 +'CREATE'=321 +'CREATE_FILE_DEST'=322 +'CREATE_STORED_OUTLINES'=323 +'CREATION'=324 +'CREDENTIAL'=325 +'CRITICAL'=326 +'CROSS'=327 +'CROSSEDITION'=328 +'CSCONVERT'=329 +'CSV'=330 +'CUBE_AJ'=331 +'CUBE'=332 +'CUBE_GB'=333 +'CUBE_SJ'=334 +'CUME_DISTM'=335 +'CURRENT'=336 +'CURRENT_DATE'=337 +'CURRENT_SCHEMA'=338 +'CURRENT_TIME'=339 +'CURRENT_TIMESTAMP'=340 +'CURRENT_USER'=341 +'CURRENTV'=342 +'CURSOR'=343 +'CURSOR_SHARING_EXACT'=344 +'CURSOR_SPECIFIC_SEGMENT'=345 +'CUSTOMDATUM'=346 +'CV'=347 +'CYCLE'=348 +'DANGLING'=349 +'DATABASE'=350 +'DATA'=351 +'DATAFILE'=352 +'DATAFILES'=353 +'DATAGUARDCONFIG'=354 +'DATAMOVEMENT'=355 +'DATAOBJNO'=356 +'DATAOBJ_TO_MAT_PARTITION'=357 +'DATAOBJ_TO_PARTITION'=358 +'DATAPUMP'=359 +'DATA_SECURITY_REWRITE_LIMIT'=360 +'DATE'=361 +'DATE_CACHE'=362 +'DATE_FORMAT'=363 +'DATE_MODE'=364 +'DAY'=365 +'DAYS'=366 +'DAY_TO_SECOND'=367 +'DBA'=368 +'DBA_RECYCLEBIN'=369 +'DBLINK'=370 +'DBMS_STATS'=371 +'DB_ROLE_CHANGE'=372 +'DBTIMEZONE'=373 +'DB_UNIQUE_NAME'=374 +'DB_VERSION'=375 +'DDL'=376 +'DEALLOCATE'=377 +'DEBUG'=378 +'DEBUGGER'=379 +'DEC'=380 +'DECIMAL'=381 +'DECLARE'=382 +'DECOMPOSE'=383 +'DECORRELATE'=384 +'DECR'=385 +'DECREMENT'=386 +'DECRYPT'=387 +'DEDUPLICATE'=388 +'DEFAULT'=389 +'DEFAULTIF'=390 +'DEFAULTS'=391 +'DEFAULT_COLLATION'=392 +'DEFAULT_CREDENTIAL'=393 +'DEFERRABLE'=394 +'DEFERRED'=395 +'DEFINED'=396 +'DEFINE'=397 +'DEFINER'=398 +'DEGREE'=399 +'DELAY'=400 +'DELEGATE'=401 +'DELETE_ALL'=402 +'DELETE'=403 +'DELETEXML'=404 +'DELIMITED'=405 +'DEMAND'=406 +'DENSE_RANKM'=407 +'DEPENDENT'=408 +'DEPRECATE'=409 +'DEPTH'=410 +'DEQUEUE'=411 +'DEREF'=412 +'DEREF_NO_REWRITE'=413 +'DESC'=414 +'DESCRIPTION'=415 +'DESTROY'=416 +'DETACHED'=417 +'DETECTED'=418 +'DETERMINES'=419 +'DETERMINISTIC'=420 +'DICTIONARY'=421 +'DIMENSION'=422 +'DIMENSIONS'=423 +'DIRECTIO'=424 +'DIRECT_LOAD'=425 +'DIRECTORY'=426 +'DIRECT_PATH'=427 +'DISABLE_ALL'=428 +'DISABLE'=429 +'DISABLED'=430 +'DISABLE_DIRECTORY_LINK_CHECK'=431 +'DISABLE_PARALLEL_DML'=432 +'DISABLE_PRESET'=433 +'DISABLE_RPKE'=434 +'DISALLOW'=435 +'DISASSOCIATE'=436 +'DISCARD'=437 +'DISCARDFILE'=438 +'DISCONNECT'=439 +'DISK'=440 +'DISKGROUP'=441 +'\'+ DISKGROUP'=442 +'DISKS'=443 +'DISMOUNT'=444 +'DISTINCT'=445 +'DISTINGUISHED'=446 +'DISTRIBUTED'=447 +'DISTRIBUTE'=448 +'DML'=449 +'DML_UPDATE'=450 +'DNFS_DISABLE'=451 +'DNFS_ENABLE'=452 +'DNFS_READBUFFERS'=453 +'DOCFIDELITY'=454 +'DOCUMENT'=455 +'$ELSE'=456 +'$ELSIF'=457 +'$END'=458 +'$ERROR'=459 +'$IF'=460 +'$THEN'=461 +'DOMAIN_INDEX_FILTER'=462 +'DOMAIN_INDEX_NO_SORT'=463 +'DOMAIN_INDEX_SORT'=464 +'DOUBLE'=465 +'DOWNGRADE'=466 +'DRIVING_SITE'=467 +'DROP_COLUMN'=468 +'DROP'=469 +'DROP_GROUP'=470 +'DSINTERVAL_UNCONSTRAINED'=471 +'DST_UPGRADE_INSERT_CONV'=472 +'DUMP'=473 +'DUMPSET'=474 +'DUPLICATE'=475 +'DV'=476 +'DYNAMIC'=477 +'DYNAMIC_SAMPLING'=478 +'DYNAMIC_SAMPLING_EST_CDN'=479 +'E'=480 +'EACH'=481 +'EDITIONABLE'=482 +'EDITION'=483 +'EDITIONING'=484 +'EDITIONS'=485 +'ELEMENT'=486 +'ELIM_GROUPBY'=487 +'ELIMINATE_JOIN'=488 +'ELIMINATE_OBY'=489 +'ELIMINATE_OUTER_JOIN'=490 +'ELSE'=491 +'ELSIF'=492 +'EM'=493 +'EMBEDDED'=494 +'EMPTY_BLOB'=495 +'EMPTY_CLOB'=496 +'EMPTY'=497 +'ENABLE_ALL'=498 +'ENABLE'=499 +'ENABLED'=500 +'ENABLE_PARALLEL_DML'=501 +'ENABLE_PRESET'=502 +'ENCLOSED'=503 +'ENCODING'=504 +'ENCRYPT'=505 +'ENCRYPTION'=506 +'ENCRYPTPASSWORDISNULL'=507 +'END'=508 +'END_OUTLINE_DATA'=509 +'ENDIAN'=510 +'ENFORCED'=511 +'ENFORCE'=512 +'ENQUEUE'=513 +'ENTERPRISE'=514 +'ENTITYESCAPING'=515 +'ENTRY'=516 +'EQUIPART'=517 +'ERR'=518 +'ERROR_ARGUMENT'=519 +'ERROR'=520 +'ERROR_ON_OVERLAP_TIME'=521 +'ERRORS'=522 +'ERROR_INDEX'=523 +'ERROR_CODE'=524 +'ESCAPE'=525 +'ESCAPED'=526 +'ESTIMATE'=527 +'EVAL'=528 +'EVALNAME'=529 +'EVALUATE'=530 +'EVALUATION'=531 +'EVENTS'=532 +'EVERY'=533 +'EXCEPT'=534 +'EXCEPTION'=535 +'EXCEPTION_INIT'=536 +'EXCEPTIONS'=537 +'EXCHANGE'=538 +'EXCLUDE'=539 +'EXCLUDING'=540 +'EXCLUSIVE'=541 +'EXECUTE'=542 +'EXEMPT'=543 +'EXISTING'=544 +'EXISTS'=545 +'EXISTSNODE'=546 +'EXIT'=547 +'EXPAND_GSET_TO_UNION'=548 +'EXPAND_TABLE'=549 +'EXP'=550 +'EXPIRE'=551 +'EXPLAIN'=552 +'EXPLOSION'=553 +'EXPORT'=554 +'EXPR_CORR_CHECK'=555 +'EXPRESS'=556 +'EXTENDS'=557 +'EXTENT'=558 +'EXTENTS'=559 +'EXTERNAL'=560 +'EXTERNALLY'=561 +'EXTRACTCLOBXML'=562 +'EXTRACT'=563 +'EXTRACTVALUE'=564 +'EXTRA'=565 +'FACILITY'=566 +'FACT'=567 +'FACTOR'=568 +'FACTORIZE_JOIN'=569 +'FAILED'=570 +'FAILED_LOGIN_ATTEMPTS'=571 +'FAILGROUP'=572 +'FAILOVER'=573 +'FAILURE'=574 +'FALSE'=575 +'FAMILY'=576 +'FAR'=577 +'FAST'=578 +'FASTSTART'=579 +'FBTSCAN'=580 +'FEATURE'=581 +'FEATURE_DETAILS'=582 +'FEATURE_ID'=583 +'FEATURE_SET'=584 +'FEATURE_VALUE'=585 +'FETCH'=586 +'FIELD'=587 +'FIELDS'=588 +'FILE'=589 +'FILE_NAME_CONVERT'=590 +'FILEGROUP'=591 +'FILESTORE'=592 +'FILESYSTEM_LIKE_LOGGING'=593 +'FILTER'=594 +'FINAL'=595 +'FINE'=596 +'FINISH'=597 +'FIRST'=598 +'FIRSTM'=599 +'FIRST_ROWS'=600 +'FIRST_VALUE'=601 +'FIXED'=602 +'FIXED_VIEW_DATA'=603 +'FLAGGER'=604 +'FLASHBACK'=605 +'FLASH_CACHE'=606 +'FLOAT'=607 +'FLOB'=608 +'FLEX'=609 +'FLOOR'=610 +'FLUSH'=611 +'FOLDER'=612 +'FOLLOWING'=613 +'FOLLOWS'=614 +'FORALL'=615 +'FORCE'=616 +'FORCE_XML_QUERY_REWRITE'=617 +'FOREIGN'=618 +'FOREVER'=619 +'FOR'=620 +'FORMAT'=621 +'FORWARD'=622 +'FRAGMENT_NUMBER'=623 +'FREELIST'=624 +'FREELISTS'=625 +'FREEPOOLS'=626 +'FRESH'=627 +'FROM'=628 +'FROM_TZ'=629 +'FULL'=630 +'FULL_OUTER_JOIN_TO_OUTER'=631 +'FUNCTION'=632 +'FUNCTIONS'=633 +'FTP'=634 +'G'=635 +'GATHER_OPTIMIZER_STATISTICS'=636 +'GATHER_PLAN_STATISTICS'=637 +'GBY_CONC_ROLLUP'=638 +'GBY_PUSHDOWN'=639 +'GENERATED'=640 +'GET'=641 +'GLOBAL'=642 +'GLOBALLY'=643 +'GLOBAL_NAME'=644 +'GLOBAL_TOPIC_ENABLED'=645 +'GOTO'=646 +'GRANT'=647 +'GROUP_BY'=648 +'GROUP'=649 +'GROUP_ID'=650 +'GROUPING'=651 +'GROUPING_ID'=652 +'GROUPS'=653 +'GUARANTEED'=654 +'GUARANTEE'=655 +'GUARD'=656 +'HADOOP_TRAILERS'=657 +'HALF_YEARS'=658 +'HASH_AJ'=659 +'HASH'=660 +'HASHKEYS'=661 +'HASH_SJ'=662 +'HAVING'=663 +'HEADER'=664 +'HEAP'=665 +'HELP'=666 +'HEXTORAW'=667 +'HEXTOREF'=668 +'HIDDEN'=669 +'HIDE'=670 +'HIER_ORDER'=671 +'HIERARCHICAL'=672 +'HIERARCHIES'=673 +'HIERARCHY'=674 +'HIGH'=675 +'HINTSET_BEGIN'=676 +'HINTSET_END'=677 +'HOT'=678 +'HOUR'=679 +'HOURS'=680 +'HTTP'=681 +'HWM_BROKERED'=682 +'HYBRID'=683 +'H'=684 +'IDENTIFIED'=685 +'IDENTIFIER'=686 +'IDENTITY'=687 +'IDGENERATORS'=688 +'ID'=689 +'IDLE_TIME'=690 +'IF'=691 +'IGNORE'=692 +'IGNORE_CHARS_AFTER_EOR'=693 +'IGNORE_OPTIM_EMBEDDED_HINTS'=694 +'IGNORE_ROW_ON_DUPKEY_INDEX'=695 +'IGNORE_WHERE_CLAUSE'=696 +'ILM'=697 +'IMMEDIATE'=698 +'IMPACT'=699 +'IMPORT'=700 +'INACTIVE'=701 +'INACTIVE_ACCOUNT_TIME'=702 +'INCLUDE'=703 +'INCLUDE_VERSION'=704 +'INCLUDING'=705 +'INCREMENTAL'=706 +'INCREMENT'=707 +'INCR'=708 +'INDENT'=709 +'INDEX_ASC'=710 +'INDEX_COMBINE'=711 +'INDEX_DESC'=712 +'INDEXED'=713 +'INDEXES'=714 +'INDEX_FFS'=715 +'INDEX_FILTER'=716 +'INDEX'=717 +'INDEXING'=718 +'INDEX_JOIN'=719 +'INDEX_ROWS'=720 +'INDEX_RRS'=721 +'INDEX_RS_ASC'=722 +'INDEX_RS_DESC'=723 +'INDEX_RS'=724 +'INDEX_SCAN'=725 +'INDEX_SKIP_SCAN'=726 +'INDEX_SS_ASC'=727 +'INDEX_SS_DESC'=728 +'INDEX_SS'=729 +'INDEX_STATS'=730 +'INDEXTYPE'=731 +'INDEXTYPES'=732 +'INDICATOR'=733 +'INDICES'=734 +'INFINITE'=735 +'INFORMATIONAL'=736 +'INHERIT'=737 +'IN'=738 +'INITCAP'=739 +'INITIAL'=740 +'INITIALIZED'=741 +'INITIALLY'=742 +'INITRANS'=743 +'INLINE'=744 +'INLINE_XMLTYPE_NT'=745 +'INMEMORY'=746 +'IN_MEMORY_METADATA'=747 +'INMEMORY_PRUNING'=748 +'INNER'=749 +'INOUT'=750 +'INPLACE'=751 +'INPUTFORMAT'=752 +'INSERTCHILDXMLAFTER'=753 +'INSERTCHILDXMLBEFORE'=754 +'INSERTCHILDXML'=755 +'INSERT'=756 +'INSERTXMLAFTER'=757 +'INSERTXMLBEFORE'=758 +'INSTANCE'=759 +'INSTANCES'=760 +'INSTANTIABLE'=761 +'INSTANTLY'=762 +'INSTEAD'=763 +'INSTR2'=764 +'INSTR4'=765 +'INSTRB'=766 +'INSTRC'=767 +'INSTR'=768 +'INTEGER'=769 +'INTERLEAVED'=770 +'INTERMEDIATE'=771 +'INTERNAL_CONVERT'=772 +'INTERNAL_USE'=773 +'INTERPRETED'=774 +'INTERSECT'=775 +'INTERVAL'=776 +'INT'=777 +'INTERNAL'=778 +'INTO'=779 +'INVALIDATE'=780 +'INVALIDATION'=781 +'INVISIBLE'=782 +'IN_XQUERY'=783 +'IO_OPTIONS'=784 +'IS'=785 +'IS_LEAF'=786 +'ISOLATION'=787 +'ISOLATION_LEVEL'=788 +'ITEMS'=789 +'ITERATE'=790 +'ITERATION_NUMBER'=791 +'JAVA'=792 +'JOB'=793 +'JOIN'=794 +'JSON_ARRAYAGG'=795 +'JSON_ARRAY'=796 +'JSON_EQUAL'=797 +'JSON_EXISTS2'=798 +'JSON_EXISTS'=799 +'JSONGET'=800 +'JSON'=801 +'JSON_OBJECTAGG'=802 +'JSON_OBJECT'=803 +'JSONPARSE'=804 +'JSON_QUERY'=805 +'JSON_SERIALIZE'=806 +'JSON_TABLE'=807 +'JSON_TEXTCONTAINS2'=808 +'JSON_TEXTCONTAINS'=809 +'JSON_TRANSFORM'=810 +'JSON_VALUE'=811 +'K'=812 +'KEEP_DUPLICATES'=813 +'KEEP'=814 +'KERBEROS'=815 +'KEY'=816 +'KEY_LENGTH'=817 +'KEYSIZE'=818 +'KEYS'=819 +'KEYSTORE'=820 +'KILL'=821 +'LABEL'=822 +'LANGUAGE'=823 +'LAST_DAY'=824 +'LAST'=825 +'LAST_VALUE'=826 +'LATERAL'=827 +'LATEST'=828 +'LAX'=829 +'LAYER'=830 +'LDAP_REGISTRATION_ENABLED'=831 +'LDAP_REGISTRATION'=832 +'LDAP_REG_SYNC_INTERVAL'=833 +'LDRTRIM'=834 +'LEAF'=835 +'LEAD_CDB'=836 +'LEAD_CDB_URI'=837 +'LEADING'=838 +'LEFT'=839 +'LENGTH2'=840 +'LENGTH4'=841 +'LENGTHB'=842 +'LENGTHC'=843 +'LENGTH'=844 +'LESS'=845 +'LEVEL'=846 +'LEVEL_NAME'=847 +'LEVELS'=848 +'LIBRARY'=849 +'LIFECYCLE'=850 +'LIFE'=851 +'LIFETIME'=852 +'LIKE2'=853 +'LIKE4'=854 +'LIKEC'=855 +'LIKE_EXPAND'=856 +'LIKE'=857 +'LIMIT'=858 +'LINEAR'=859 +'LINES'=860 +'LINK'=861 +'LIST'=862 +'LITTLE'=863 +'LLS'=864 +'LN'=865 +'LNNVL'=866 +'LOAD'=867 +'LOB'=868 +'LOBFILE'=869 +'LOBNVL'=870 +'LOBS'=871 +'LOCAL_INDEXES'=872 +'LOCAL'=873 +'LOCALTIME'=874 +'LOCALTIMESTAMP'=875 +'LOCATION'=876 +'LOCATOR'=877 +'LOCKDOWN'=878 +'LOCKED'=879 +'LOCKING'=880 +'LOCK'=881 +'LOGFILE'=882 +'LOGFILES'=883 +'LOGGING'=884 +'LOGICAL'=885 +'LOGICAL_READS_PER_CALL'=886 +'LOGICAL_READS_PER_SESSION'=887 +'LOG'=888 +'LOGMINING'=889 +'LOGOFF'=890 +'LOGON'=891 +'LOG_READ_ONLY_VIOLATIONS'=892 +'LONG'=893 +'LOOP'=894 +'LOST'=895 +'LOWER'=896 +'LOW'=897 +'LPAD'=898 +'LRTRIM'=899 +'LTRIM'=900 +'M'=901 +'MAIN'=902 +'MAKE_REF'=903 +'MANAGED'=904 +'MANAGE'=905 +'MANAGEMENT'=906 +'MANAGER'=907 +'MANDATORY'=908 +'MANUAL'=909 +'MAP'=910 +'MAPPING'=911 +'MASK'=912 +'MASTER'=913 +'MATCHED'=914 +'MATCHES'=915 +'MATCH'=916 +'MATCH_NUMBER'=917 +'MATCH_RECOGNIZE'=918 +'MATERIALIZED'=919 +'MATERIALIZE'=920 +'MAXARCHLOGS'=921 +'MAXDATAFILES'=922 +'MAXEXTENTS'=923 +'MAXIMIZE'=924 +'MAXINSTANCES'=925 +'MAXLOGFILES'=926 +'MAXLOGHISTORY'=927 +'MAXLOGMEMBERS'=928 +'MAX_SHARED_TEMP_SIZE'=929 +'MAXSIZE'=930 +'MAXTRANS'=931 +'MAXVALUE'=932 +'MEASURE'=933 +'MEASURES'=934 +'MEDIUM'=935 +'MEMBER'=936 +'MEMBER_CAPTION'=937 +'MEMBER_DESCRIPTION'=938 +'MEMBER_NAME'=939 +'MEMBER_UNIQUE_NAME'=940 +'MEMCOMPRESS'=941 +'MEMORY'=942 +'MERGE$ACTIONS'=943 +'MERGE_AJ'=944 +'MERGE_CONST_ON'=945 +'MERGE'=946 +'MERGE_SJ'=947 +'METADATA'=948 +'METHOD'=949 +'MIGRATE'=950 +'MIGRATION'=951 +'MINEXTENTS'=952 +'MINIMIZE'=953 +'MINIMUM'=954 +'MINING'=955 +'MINUS'=956 +'MINUS_NULL'=957 +'MINUTE'=958 +'MINUTES'=959 +'MINVALUE'=960 +'MIRRORCOLD'=961 +'MIRRORHOT'=962 +'MIRROR'=963 +'MISSING'=964 +'MISMATCH'=965 +'MLSLABEL'=966 +'MODEL_COMPILE_SUBQUERY'=967 +'MODEL_DONTVERIFY_UNIQUENESS'=968 +'MODEL_DYNAMIC_SUBQUERY'=969 +'MODEL_MIN_ANALYSIS'=970 +'MODEL'=971 +'MODEL_NB'=972 +'MODEL_NO_ANALYSIS'=973 +'MODEL_PBY'=974 +'MODEL_PUSH_REF'=975 +'MODEL_SV'=976 +'MODE'=977 +'MODIFICATION'=978 +'MODIFY_COLUMN_TYPE'=979 +'MODIFY'=980 +'MOD'=981 +'MODULE'=982 +'MONITORING'=983 +'MONITOR'=984 +'MONTH'=985 +'MONTHS_BETWEEN'=986 +'MONTHS'=987 +'MOUNT'=988 +'MOUNTPATH'=989 +'MOUNTPOINT'=990 +'MOVEMENT'=991 +'MOVE'=992 +'MULTIDIMENSIONAL'=993 +'MULTISET'=994 +'MV_MERGE'=995 +'NAMED'=996 +'NAME'=997 +'NAMESPACE'=998 +'NAN'=999 +'NANVL'=1000 +'NATIONAL'=1001 +'NATIVE_FULL_OUTER_JOIN'=1002 +'NATIVE'=1003 +'NATURAL'=1004 +'NATURALN'=1005 +'NAV'=1006 +'NCHAR_CS'=1007 +'NCHAR'=1008 +'NCHR'=1009 +'NCLOB'=1010 +'NEEDED'=1011 +'NEG'=1012 +'NESTED'=1013 +'NESTED_TABLE_FAST_INSERT'=1014 +'NESTED_TABLE_GET_REFS'=1015 +'NESTED_TABLE_ID'=1016 +'NESTED_TABLE_SET_REFS'=1017 +'NESTED_TABLE_SET_SETID'=1018 +'NETWORK'=1019 +'NEVER'=1020 +'NEW'=1021 +'NEWLINE'=1022 +'NEW_TIME'=1023 +'NEXT_DAY'=1024 +'NEXT'=1025 +'NL_AJ'=1026 +'NLJ_BATCHING'=1027 +'NLJ_INDEX_FILTER'=1028 +'NLJ_INDEX_SCAN'=1029 +'NLJ_PREFETCH'=1030 +'NLS_CALENDAR'=1031 +'NLS_CHARACTERSET'=1032 +'NLS_CHARSET_DECL_LEN'=1033 +'NLS_CHARSET_ID'=1034 +'NLS_CHARSET_NAME'=1035 +'NLS_COMP'=1036 +'NLS_CURRENCY'=1037 +'NLS_DATE_FORMAT'=1038 +'NLS_DATE_LANGUAGE'=1039 +'NLS_INITCAP'=1040 +'NLS_ISO_CURRENCY'=1041 +'NL_SJ'=1042 +'NLS_LANG'=1043 +'NLS_LANGUAGE'=1044 +'NLS_LENGTH_SEMANTICS'=1045 +'NLS_LOWER'=1046 +'NLS_NCHAR_CONV_EXCP'=1047 +'NLS_NUMERIC_CHARACTERS'=1048 +'NLS_SORT'=1049 +'NLSSORT'=1050 +'NLS_SPECIAL_CHARS'=1051 +'NLS_TERRITORY'=1052 +'NLS_UPPER'=1053 +'NO_ACCESS'=1054 +'NO_ADAPTIVE_PLAN'=1055 +'NO_ANSI_REARCH'=1056 +'NOAPPEND'=1057 +'NOARCHIVELOG'=1058 +'NOAUDIT'=1059 +'NOBADFILE'=1060 +'NO_AUTO_REOPTIMIZE'=1061 +'NO_BASETABLE_MULTIMV_REWRITE'=1062 +'NO_BATCH_TABLE_ACCESS_BY_ROWID'=1063 +'NO_BIND_AWARE'=1064 +'NO_BUFFER'=1065 +'NOCACHE'=1066 +'NOCHECK'=1067 +'NO_CARTESIAN'=1068 +'NO_CHECK_ACL_REWRITE'=1069 +'NO_CLUSTER_BY_ROWID'=1070 +'NO_CLUSTERING'=1071 +'NO_COALESCE_SQ'=1072 +'NO_COMMON_DATA'=1073 +'NOCOMPRESS'=1074 +'NO_CONNECT_BY_CB_WHR_ONLY'=1075 +'NO_CONNECT_BY_COMBINE_SW'=1076 +'NO_CONNECT_BY_COST_BASED'=1077 +'NO_CONNECT_BY_ELIM_DUPS'=1078 +'NO_CONNECT_BY_FILTERING'=1079 +'NOCOPY'=1080 +'NO_COST_XML_QUERY_REWRITE'=1081 +'NO_CPU_COSTING'=1082 +'NOCPU_COSTING'=1083 +'NOCYCLE'=1084 +'NO_DATA_SECURITY_REWRITE'=1085 +'NO_DECORRELATE'=1086 +'NODELAY'=1087 +'NODIRECTIO'=1088 +'NODISCARDFILE'=1089 +'NO_DOMAIN_INDEX_FILTER'=1090 +'NO_DST_UPGRADE_INSERT_CONV'=1091 +'NO_ELIM_GROUPBY'=1092 +'NO_ELIMINATE_JOIN'=1093 +'NO_ELIMINATE_OBY'=1094 +'NO_ELIMINATE_OUTER_JOIN'=1095 +'NOENTITYESCAPING'=1096 +'NO_EXPAND_GSET_TO_UNION'=1097 +'NO_EXPAND'=1098 +'NO_EXPAND_TABLE'=1099 +'NOEXTEND'=1100 +'NO_FACT'=1101 +'NO_FACTORIZE_JOIN'=1102 +'NO_FILTERING'=1103 +'NOFORCE'=1104 +'NO_FULL_OUTER_JOIN_TO_OUTER'=1105 +'NO_GATHER_OPTIMIZER_STATISTICS'=1106 +'NO_GBY_PUSHDOWN'=1107 +'NOGUARANTEE'=1108 +'NO_INDEX_FFS'=1109 +'NO_INDEX'=1110 +'NO_INDEX_SS'=1111 +'NO_INMEMORY'=1112 +'NO_INMEMORY_PRUNING'=1113 +'NOKEEP'=1114 +'NO_LOAD'=1115 +'NOLOCAL'=1116 +'NOLOG'=1117 +'NOLOGFILE'=1118 +'NOLOGGING'=1119 +'NOMAPPING'=1120 +'NOMAXVALUE'=1121 +'NO_MERGE'=1122 +'NOMINIMIZE'=1123 +'NOMINVALUE'=1124 +'NO_MODEL_PUSH_REF'=1125 +'NO_MONITORING'=1126 +'NOMONITORING'=1127 +'NO_MONITOR'=1128 +'NO_MULTIMV_REWRITE'=1129 +'NO_NATIVE_FULL_OUTER_JOIN'=1130 +'NONBLOCKING'=1131 +'NONEDITIONABLE'=1132 +'NONE'=1133 +'NONULLIF'=1134 +'NO_NLJ_BATCHING'=1135 +'NO_NLJ_PREFETCH'=1136 +'NO'=1137 +'NONSCHEMA'=1138 +'NO_OBJECT_LINK'=1139 +'NOORDER'=1140 +'NO_ORDER_ROLLUPS'=1141 +'NO_OUTER_JOIN_TO_ANTI'=1142 +'NO_OUTER_JOIN_TO_INNER'=1143 +'NOOVERRIDE'=1144 +'NO_PARALLEL_INDEX'=1145 +'NOPARALLEL_INDEX'=1146 +'NO_PARALLEL'=1147 +'NOPARALLEL'=1148 +'NO_PARTIAL_COMMIT'=1149 +'NO_PARTIAL_JOIN'=1150 +'NO_PARTIAL_ROLLUP_PUSHDOWN'=1151 +'NOPARTITION'=1152 +'NO_PLACE_DISTINCT'=1153 +'NO_PLACE_GROUP_BY'=1154 +'NO_PQ_CONCURRENT_UNION'=1155 +'NO_PQ_MAP'=1156 +'NOPROMPT'=1157 +'NO_PQ_REPLICATE'=1158 +'NO_PQ_SKEW'=1159 +'NO_PRUNE_GSETS'=1160 +'NO_PULL_PRED'=1161 +'NO_PUSH_PRED'=1162 +'NO_PUSH_SUBQ'=1163 +'NO_PX_FAULT_TOLERANCE'=1164 +'NO_PX_JOIN_FILTER'=1165 +'NO_QKN_BUFF'=1166 +'NO_QUERY_TRANSFORMATION'=1167 +'NO_REF_CASCADE'=1168 +'NORELOCATE'=1169 +'NORELY'=1170 +'NOREPAIR'=1171 +'NOREPLAY'=1172 +'NORESETLOGS'=1173 +'NO_RESULT_CACHE'=1174 +'NOREVERSE'=1175 +'NO_REWRITE'=1176 +'NOREWRITE'=1177 +'NORMAL'=1178 +'NO_ROOT_SW_FOR_LOCAL'=1179 +'NOROWDEPENDENCIES'=1180 +'NOSCALE'=1181 +'NOSCHEMACHECK'=1182 +'NOSEGMENT'=1183 +'NO_SEMIJOIN'=1184 +'NO_SEMI_TO_INNER'=1185 +'NO_SET_TO_JOIN'=1186 +'NOSHARD'=1187 +'NOSORT'=1188 +'NO_SQL_TRANSLATION'=1189 +'NO_SQL_TUNE'=1190 +'NO_STAR_TRANSFORMATION'=1191 +'NO_STATEMENT_QUEUING'=1192 +'NO_STATS_GSETS'=1193 +'NOSTRICT'=1194 +'NO_SUBQUERY_PRUNING'=1195 +'NO_SUBSTRB_PAD'=1196 +'NO_SWAP_JOIN_INPUTS'=1197 +'NOSWITCH'=1198 +'NO_TABLE_LOOKUP_BY_NL'=1199 +'NO_TEMP_TABLE'=1200 +'NOTHING'=1201 +'NOTIFICATION'=1202 +'NOTRIM'=1203 +'NOT'=1204 +'NO_TRANSFORM_DISTINCT_AGG'=1205 +'NO_UNNEST'=1206 +'NO_USE_CUBE'=1207 +'NO_USE_HASH_AGGREGATION'=1208 +'NO_USE_HASH_GBY_FOR_PUSHDOWN'=1209 +'NO_USE_HASH'=1210 +'NO_USE_INVISIBLE_INDEXES'=1211 +'NO_USE_MERGE'=1212 +'NO_USE_NL'=1213 +'NO_USE_VECTOR_AGGREGATION'=1214 +'NOVALIDATE'=1215 +'NO_VECTOR_TRANSFORM_DIMS'=1216 +'NO_VECTOR_TRANSFORM_FACT'=1217 +'NO_VECTOR_TRANSFORM'=1218 +'NOWAIT'=1219 +'NO_XDB_FASTPATH_INSERT'=1220 +'NO_XML_DML_REWRITE'=1221 +'NO_XMLINDEX_REWRITE_IN_SELECT'=1222 +'NO_XMLINDEX_REWRITE'=1223 +'NO_XML_QUERY_REWRITE'=1224 +'NO_ZONEMAP'=1225 +'NTH_VALUE'=1226 +'NULLIF'=1227 +'NULL'=1228 +'NULLS'=1229 +'NUMBER'=1230 +'NUMERIC'=1231 +'NUM_INDEX_KEYS'=1232 +'NUMTODSINTERVAL'=1233 +'NUMTOYMINTERVAL'=1234 +'NVARCHAR2'=1235 +'NVL2'=1236 +'OBJECT2XML'=1237 +'OBJECT'=1238 +'OBJ_ID'=1239 +'OBJNO'=1240 +'OBJNO_REUSE'=1241 +'OCCURENCES'=1242 +'OFFLINE'=1243 +'OFF'=1244 +'OFFSET'=1245 +'OF'=1246 +'OIDINDEX'=1247 +'OID'=1248 +'OLAP'=1249 +'OLD'=1250 +'OLD_PUSH_PRED'=1251 +'OLS'=1252 +'OLTP'=1253 +'OMIT'=1254 +'ONE'=1255 +'ONLINE'=1256 +'ONLINELOG'=1257 +'ONLY'=1258 +'ON'=1259 +'OPAQUE'=1260 +'OPAQUE_TRANSFORM'=1261 +'OPAQUE_XCANONICAL'=1262 +'OPCODE'=1263 +'OPEN'=1264 +'OPERATIONS'=1265 +'OPERATOR'=1266 +'OPT_ESTIMATE'=1267 +'OPTIMAL'=1268 +'OPTIMIZE'=1269 +'OPTIMIZER_FEATURES_ENABLE'=1270 +'OPTIMIZER_GOAL'=1271 +'OPTION'=1272 +'OPTIONALLY'=1273 +'OPT_PARAM'=1274 +'ORA_BRANCH'=1275 +'ORA_CHECK_ACL'=1276 +'ORA_CHECK_PRIVILEGE'=1277 +'ORA_CLUSTERING'=1278 +'ORADATA'=1279 +'ORC'=1280 +'ORACLE_DATE'=1281 +'ORACLE_NUMBER'=1282 +'ORADEBUG'=1283 +'ORA_DST_AFFECTED'=1284 +'ORA_DST_CONVERT'=1285 +'ORA_DST_ERROR'=1286 +'ORA_GET_ACLIDS'=1287 +'ORA_GET_PRIVILEGES'=1288 +'ORA_HASH'=1289 +'ORA_INVOKING_USERID'=1290 +'ORA_INVOKING_USER'=1291 +'ORA_INVOKING_XS_USER_GUID'=1292 +'ORA_INVOKING_XS_USER'=1293 +'ORA_RAWCOMPARE'=1294 +'ORA_RAWCONCAT'=1295 +'ORA_ROWSCN'=1296 +'ORA_ROWSCN_RAW'=1297 +'ORA_ROWVERSION'=1298 +'ORA_TABVERSION'=1299 +'ORA_WRITE_TIME'=1300 +'ORDERED'=1301 +'ORDERED_PREDICATES'=1302 +'ORDER'=1303 +'ORDINALITY'=1304 +'OR_EXPAND'=1305 +'ORGANIZATION'=1306 +'OR'=1307 +'OR_PREDICATES'=1308 +'OSERROR'=1309 +'OTHER'=1310 +'OUTER_JOIN_TO_ANTI'=1311 +'OUTER_JOIN_TO_INNER'=1312 +'OUTER'=1313 +'OUTLINE_LEAF'=1314 +'OUTLINE'=1315 +'OUTPUTFORMAT'=1316 +'OUT_OF_LINE'=1317 +'OUT'=1318 +'OVERFLOW_NOMOVE'=1319 +'OVERFLOW'=1320 +'OVERLAPS'=1321 +'OVER'=1322 +'OVERRIDE'=1323 +'OVERRIDING'=1324 +'OWNER'=1325 +'OWNERSHIP'=1326 +'OWN'=1327 +'P'=1328 +'PACKAGE'=1329 +'PACKAGES'=1330 +'PARALLEL_ENABLE'=1331 +'PARALLEL_INDEX'=1332 +'PARALLEL'=1333 +'PARAMETERFILE'=1334 +'PARAMETERS'=1335 +'PARAM'=1336 +'PARENT'=1337 +'PARENT_LEVEL_NAME'=1338 +'PARENT_UNIQUE_NAME'=1339 +'PARITY'=1340 +'PARQUET'=1341 +'PARTIAL_JOIN'=1342 +'PARTIALLY'=1343 +'PARTIAL'=1344 +'PARTIAL_ROLLUP_PUSHDOWN'=1345 +'PARTITION_HASH'=1346 +'PARTITION_LIST'=1347 +'PARTITION'=1348 +'PARTITION_RANGE'=1349 +'PARTITIONS'=1350 +'PART$NUM$INST'=1351 +'PASSING'=1352 +'PASSWORD_GRACE_TIME'=1353 +'PASSWORD_LIFE_TIME'=1354 +'PASSWORD_LOCK_TIME'=1355 +'PASSWORD'=1356 +'PASSWORD_REUSE_MAX'=1357 +'PASSWORD_REUSE_TIME'=1358 +'PASSWORD_ROLLOVER_TIME'=1359 +'PASSWORD_VERIFY_FUNCTION'=1360 +'PAST'=1361 +'PATCH'=1362 +'PATH'=1363 +'PATH_PREFIX'=1364 +'PATHS'=1365 +'PATTERN'=1366 +'PBL_HS_BEGIN'=1367 +'PBL_HS_END'=1368 +'PCTFREE'=1369 +'PCTINCREASE'=1370 +'PCTTHRESHOLD'=1371 +'PCTUSED'=1372 +'PCTVERSION'=1373 +'PENDING'=1374 +'PERCENT'=1378 +'PERCENT_RANKM'=1379 +'PERFORMANCE'=1385 +'PERIOD'=1386 +'PERMANENT'=1387 +'PERMISSION'=1388 +'PERMUTE'=1389 +'PER'=1390 +'PFILE'=1391 +'PHYSICAL'=1392 +'PIKEY'=1393 +'PIPELINED'=1394 +'PIPE'=1395 +'PIV_GB'=1396 +'PIVOT'=1397 +'PIV_SSF'=1398 +'PLACE_DISTINCT'=1399 +'PLACE_GROUP_BY'=1400 +'PLAN'=1401 +'PLSCOPE_SETTINGS'=1402 +'PLS_INTEGER'=1403 +'PLSQL_CCFLAGS'=1404 +'PLSQL_CODE_TYPE'=1405 +'PLSQL_DEBUG'=1406 +'PLSQL_OPTIMIZE_LEVEL'=1407 +'PLSQL_WARNINGS'=1408 +'PLUGGABLE'=1409 +'PMEM'=1410 +'POINT'=1411 +'POLICY'=1412 +'POOL_16K'=1413 +'POOL_2K'=1414 +'POOL_32K'=1415 +'POOL_4K'=1416 +'POOL_8K'=1417 +'POSITION'=1418 +'POSITIVEN'=1419 +'POSITIVE'=1420 +'POST_TRANSACTION'=1421 +'POWERMULTISET_BY_CARDINALITY'=1422 +'POWERMULTISET'=1423 +'POWER'=1424 +'PQ_CONCURRENT_UNION'=1425 +'PQ_DISTRIBUTE'=1426 +'PQ_DISTRIBUTE_WINDOW'=1427 +'PQ_FILTER'=1428 +'PQ_MAP'=1429 +'PQ_NOMAP'=1430 +'PQ_REPLICATE'=1431 +'PQ_SKEW'=1432 +'PRAGMA'=1433 +'PREBUILT'=1434 +'PRECEDES'=1435 +'PRECEDING'=1436 +'PRECISION'=1437 +'PRECOMPUTE_SUBQUERY'=1438 +'PREDICATE_REORDERS'=1439 +'PRELOAD'=1440 +'PREPARE'=1441 +'PREPROCESSOR'=1442 +'PRESENTNNV'=1443 +'PRESENT'=1444 +'PRESENTV'=1445 +'PRESERVE_OID'=1446 +'PRESERVE'=1447 +'PRETTY'=1448 +'PREVIOUS'=1449 +'PREV'=1450 +'PRIMARY'=1451 +'PRINTBLOBTOCLOB'=1452 +'PRIORITY'=1453 +'PRIOR'=1454 +'PRIVATE'=1455 +'PRIVATE_SGA'=1456 +'PRIVILEGED'=1457 +'PRIVILEGE'=1458 +'PRIVILEGES'=1459 +'PROCEDURAL'=1460 +'PROCEDURE'=1461 +'PROCESS'=1462 +'PROFILE'=1463 +'PROGRAM'=1464 +'PROJECT'=1465 +'PROPAGATE'=1466 +'PROPERTY'=1467 +'PROTECTED'=1468 +'PROTECTION'=1469 +'PROTOCOL'=1470 +'PROXY'=1471 +'PRUNING'=1472 +'PUBLIC'=1473 +'PULL_PRED'=1474 +'PURGE'=1475 +'PUSH_PRED'=1476 +'PUSH_SUBQ'=1477 +'PX_FAULT_TOLERANCE'=1478 +'PX_GRANULE'=1479 +'PX_JOIN_FILTER'=1480 +'QB_NAME'=1481 +'QUARTERS'=1482 +'QUERY_BLOCK'=1483 +'QUERY'=1484 +'QUEUE_CURR'=1485 +'QUEUE'=1486 +'QUEUE_ROWP'=1487 +'QUIESCE'=1488 +'QUORUM'=1489 +'QUOTA'=1490 +'QUOTAGROUP'=1491 +'RAISE'=1492 +'RANDOM_LOCAL'=1493 +'RANDOM'=1494 +'RANGE'=1495 +'RANKM'=1496 +'RAPIDLY'=1497 +'RAW'=1498 +'RAWTOHEX'=1499 +'RAWTONHEX'=1500 +'RBA'=1501 +'RBO_OUTLINE'=1502 +'RCFILE'=1503 +'RDBA'=1504 +'READ'=1505 +'READS'=1506 +'READSIZE'=1507 +'REALM'=1508 +'REAL'=1509 +'REBALANCE'=1510 +'REBUILD'=1511 +'RECORD'=1512 +'RECORDS'=1513 +'RECORDS_PER_BLOCK'=1514 +'RECOVERABLE'=1515 +'RECOVER'=1516 +'RECOVERY'=1517 +'RECYCLEBIN'=1518 +'RECYCLE'=1519 +'REDACTION'=1520 +'REDEFINE'=1521 +'REDO'=1522 +'REDUCED'=1523 +'REDUNDANCY'=1524 +'REF_CASCADE_CURSOR'=1525 +'REFERENCED'=1526 +'REFERENCE'=1527 +'REFERENCES'=1528 +'REFERENCING'=1529 +'REF'=1530 +'REFRESH'=1531 +'REFTOHEX'=1532 +'REGEXP_COUNT'=1533 +'REGEXP_INSTR'=1534 +'REGEXP_LIKE'=1535 +'REGEXP_REPLACE'=1536 +'REGEXP_SUBSTR'=1537 +'REGISTER'=1538 +'REGR_AVGX'=1539 +'REGR_AVGY'=1540 +'REGR_COUNT'=1541 +'REGR_INTERCEPT'=1542 +'REGR_R2'=1543 +'REGR_SLOPE'=1544 +'REGR_SXX'=1545 +'REGR_SXY'=1546 +'REGR_SYY'=1547 +'REGULAR'=1548 +'REJECT'=1549 +'REKEY'=1550 +'RELATIONAL'=1551 +'RELIES_ON'=1552 +'RELOCATE'=1553 +'RELY'=1554 +'REMAINDER'=1555 +'REMOTE'=1556 +'REMOTE_MAPPED'=1557 +'REMOVE'=1558 +'RENAME'=1559 +'REPAIR'=1560 +'REPEAT'=1561 +'REPLACE'=1562 +'REPLICATION'=1563 +'REQUIRED'=1564 +'RESETLOGS'=1565 +'RESET'=1566 +'RESIZE'=1567 +'RESOLVE'=1568 +'RESOLVER'=1569 +'RESOURCE'=1570 +'RESPECT'=1571 +'RESTART'=1572 +'RESTORE_AS_INTERVALS'=1573 +'RESTORE'=1574 +'RESTRICT_ALL_REF_CONS'=1575 +'RESTRICTED'=1576 +'RESTRICT_REFERENCES'=1577 +'RESTRICT'=1578 +'RESULT_CACHE'=1579 +'RESULT'=1580 +'RESUMABLE'=1581 +'RESUME'=1582 +'RETENTION'=1583 +'RETRY_ON_ROW_CHANGE'=1584 +'RETURNING'=1585 +'RETURN'=1586 +'REUSE'=1587 +'REVERSE'=1588 +'REVOKE'=1589 +'REWRITE_OR_ERROR'=1590 +'REWRITE'=1591 +'RIGHT'=1592 +'ROLE'=1593 +'ROLESET'=1594 +'ROLES'=1595 +'ROLLBACK'=1596 +'ROLLING'=1597 +'ROLLUP'=1598 +'ROWDEPENDENCIES'=1599 +'ROWID_MAPPING_TABLE'=1600 +'ROWID'=1601 +'ROWIDTOCHAR'=1602 +'ROWIDTONCHAR'=1603 +'ROW_LENGTH'=1604 +'ROWNUM'=1605 +'ROW'=1606 +'ROWS'=1607 +'RPAD'=1608 +'RTRIM'=1609 +'RULE'=1610 +'RULES'=1611 +'RUNNING'=1612 +'SALT'=1613 +'SAMPLE'=1614 +'SAVE_AS_INTERVALS'=1615 +'SAVEPOINT'=1616 +'SAVE'=1617 +'SB4'=1618 +'SCALE_ROWS'=1619 +'SCALE'=1620 +'SCAN_INSTANCES'=1621 +'SCAN'=1622 +'SCHEDULER'=1623 +'SCHEMACHECK'=1624 +'SCHEMA'=1625 +'SCN_ASCENDING'=1626 +'SCN'=1627 +'SCOPE'=1628 +'SCRUB'=1629 +'SD_ALL'=1630 +'SD_INHIBIT'=1631 +'SDO_GEOM_MBR'=1632 +'SDO_GEOMETRY'=1633 +'SD_SHOW'=1634 +'SEARCH'=1635 +'SECOND'=1636 +'SECONDS'=1637 +'SECRET'=1638 +'SECUREFILE_DBA'=1639 +'SECUREFILE'=1640 +'SECURITY'=1641 +'SEED'=1642 +'SEG_BLOCK'=1643 +'SEG_FILE'=1644 +'SEGMENT'=1645 +'SELECTIVITY'=1646 +'SELECT'=1647 +'SELF'=1648 +'SEMIJOIN_DRIVER'=1649 +'SEMIJOIN'=1650 +'SEMI_TO_INNER'=1651 +'SEQUENCED'=1652 +'SEQUENCE'=1653 +'SEQUENCEFILE'=1654 +'SEQUENTIAL'=1655 +'SEQ'=1656 +'SERDE'=1657 +'SERDEPROPERTIES'=1658 +'SERIALIZABLE'=1659 +'SERIALLY_REUSABLE'=1660 +'SERIAL'=1661 +'SERVERERROR'=1662 +'SERVICE_NAME_CONVERT'=1663 +'SERVICE'=1664 +'SERVICES'=1665 +'SESSION_CACHED_CURSORS'=1666 +'SESSION'=1667 +'SESSIONS_PER_USER'=1668 +'SESSIONTIMEZONE'=1669 +'SESSIONTZNAME'=1670 +'SET'=1671 +'SETS'=1672 +'SETTINGS'=1673 +'SET_TO_JOIN'=1674 +'SEVERE'=1675 +'SHARD'=1676 +'SHARDSPACE'=1677 +'SHARED_POOL'=1678 +'SHARED'=1679 +'SHARE'=1680 +'SHARING'=1681 +'SHELFLIFE'=1682 +'SHOW'=1683 +'SHRINK'=1684 +'SHUTDOWN'=1685 +'SIBLINGS'=1686 +'SID'=1687 +'SITE'=1688 +'SIGNAL_COMPONENT'=1689 +'SIGNAL_FUNCTION'=1690 +'SIGN'=1691 +'SIGNTYPE'=1692 +'SIMPLE_INTEGER'=1693 +'SIMPLE'=1694 +'SINGLE'=1695 +'SINGLETASK'=1696 +'SINH'=1697 +'SIN'=1698 +'SIZE'=1699 +'SIZES'=1700 +'SKIP_EXT_OPTIMIZER'=1701 +'SKIP'=1702 +'SKIP_UNQ_UNUSABLE_IDX'=1703 +'SKIP_UNUSABLE_INDEXES'=1704 +'SMALLFILE'=1705 +'SMALLINT'=1706 +'SNAPSHOT'=1707 +'SOME'=1708 +'SORT'=1709 +'SOUNDEX'=1710 +'SOURCE_FILE_DIRECTORY'=1711 +'SOURCE_FILE_NAME_CONVERT'=1712 +'SOURCE'=1713 +'SPACE'=1714 +'SPECIFICATION'=1715 +'SPFILE'=1716 +'SPLIT'=1717 +'SPREADSHEET'=1718 +'SQLDATA'=1719 +'SQLERROR'=1720 +'SQLLDR'=1721 +'SQL'=1722 +'SQL_MACRO'=1724 +'SQL_TRACE'=1725 +'SQL_TRANSLATION_PROFILE'=1726 +'SQRT'=1727 +'STALE'=1728 +'STANDALONE'=1729 +'STANDARD'=1730 +'STANDARD_HASH'=1731 +'STANDBY_MAX_DATA_DELAY'=1732 +'STANDBYS'=1733 +'STANDBY'=1734 +'STAR'=1735 +'STAR_TRANSFORMATION'=1736 +'START'=1737 +'STARTOF'=1738 +'STARTUP'=1739 +'STATEMENT_ID'=1740 +'STATEMENT_QUEUING'=1741 +'STATEMENTS'=1742 +'STATEMENT'=1743 +'STATE'=1744 +'STATIC'=1745 +'STATISTICS'=1746 +'STATS_BINOMIAL_TEST'=1747 +'STATS_CROSSTAB'=1748 +'STATS_F_TEST'=1749 +'STATS_KS_TEST'=1750 +'STATS_MODE'=1751 +'STATS_MW_TEST'=1752 +'STATS_ONE_WAY_ANOVA'=1753 +'STATS_T_TEST_INDEP'=1754 +'STATS_T_TEST_INDEPU'=1755 +'STATS_T_TEST_ONE'=1756 +'STATS_T_TEST_PAIRED'=1757 +'STATS_WSR_TEST'=1758 +'STDDEV_POP'=1759 +'STDDEV_SAMP'=1760 +'STOP'=1761 +'STORAGE'=1762 +'STORE'=1763 +'STREAMS'=1764 +'STREAM'=1765 +'STRICT'=1766 +'STRING'=1767 +'STRIPE_COLUMNS'=1768 +'STRIPE_WIDTH'=1769 +'STRIP'=1770 +'STRUCTURE'=1771 +'SUBMULTISET'=1772 +'SUBPARTITION_REL'=1773 +'SUBPARTITIONS'=1774 +'SUBPARTITION'=1775 +'SUBQUERIES'=1776 +'SUBQUERY_PRUNING'=1777 +'SUBSCRIBE'=1778 +'SUBSET'=1779 +'SUBSTITUTABLE'=1780 +'SUBSTR2'=1781 +'SUBSTR4'=1782 +'SUBSTRB'=1783 +'SUBSTRC'=1784 +'SUBTYPE'=1785 +'SUCCESSFUL'=1786 +'SUCCESS'=1787 +'SUMMARY'=1788 +'SUPPLEMENTAL'=1789 +'SUSPEND'=1790 +'SWAP_JOIN_INPUTS'=1791 +'SWITCHOVER'=1792 +'SWITCH'=1793 +'SYNCHRONOUS'=1794 +'SYNC'=1795 +'SYNONYM'=1796 +'SYS'=1797 +'SYSASM'=1798 +'SYS_AUDIT'=1799 +'SYSAUX'=1800 +'SYSBACKUP'=1801 +'SYS_CHECKACL'=1802 +'SYS_CHECK_PRIVILEGE'=1803 +'SYS_CONNECT_BY_PATH'=1804 +'SYS_CONTEXT'=1805 +'SYSDATE'=1806 +'SYSDBA'=1807 +'SYS_DBURIGEN'=1808 +'SYSDG'=1809 +'SYS_DL_CURSOR'=1810 +'SYS_DM_RXFORM_CHR'=1811 +'SYS_DM_RXFORM_NUM'=1812 +'SYS_DOM_COMPARE'=1813 +'SYS_DST_PRIM2SEC'=1814 +'SYS_DST_SEC2PRIM'=1815 +'SYS_ET_BFILE_TO_RAW'=1816 +'SYS_ET_BLOB_TO_IMAGE'=1817 +'SYS_ET_IMAGE_TO_BLOB'=1818 +'SYS_ET_RAW_TO_BFILE'=1819 +'SYS_EXTPDTXT'=1820 +'SYS_EXTRACT_UTC'=1821 +'SYS_FBT_INSDEL'=1822 +'SYS_FILTER_ACLS'=1823 +'SYS_FNMATCHES'=1824 +'SYS_FNREPLACE'=1825 +'SYS_GET_ACLIDS'=1826 +'SYS_GET_COL_ACLIDS'=1827 +'SYS_GET_PRIVILEGES'=1828 +'SYS_GETTOKENID'=1829 +'SYS_GETXTIVAL'=1830 +'SYS_GUID'=1831 +'SYSGUID'=1832 +'SYSKM'=1833 +'SYS_MAKE_XMLNODEID'=1834 +'SYS_MAKEXML'=1835 +'SYS_MKXMLATTR'=1836 +'SYS_MKXTI'=1837 +'SYSOBJ'=1838 +'SYS_OP_ADT2BIN'=1839 +'SYS_OP_ADTCONS'=1840 +'SYS_OP_ALSCRVAL'=1841 +'SYS_OP_ATG'=1842 +'SYS_OP_BIN2ADT'=1843 +'SYS_OP_BITVEC'=1844 +'SYS_OP_BL2R'=1845 +'SYS_OP_BLOOM_FILTER_LIST'=1846 +'SYS_OP_BLOOM_FILTER'=1847 +'SYS_OP_C2C'=1848 +'SYS_OP_CAST'=1849 +'SYS_OP_CEG'=1850 +'SYS_OP_CL2C'=1851 +'SYS_OP_COMBINED_HASH'=1852 +'SYS_OP_COMP'=1853 +'SYS_OP_CONVERT'=1854 +'SYS_OP_COUNTCHG'=1855 +'SYS_OP_CSCONV'=1856 +'SYS_OP_CSCONVTEST'=1857 +'SYS_OP_CSR'=1858 +'SYS_OP_CSX_PATCH'=1859 +'SYS_OP_CYCLED_SEQ'=1860 +'SYS_OP_DECOMP'=1861 +'SYS_OP_DESCEND'=1862 +'SYS_OP_DISTINCT'=1863 +'SYS_OP_DRA'=1864 +'SYS_OP_DUMP'=1865 +'SYS_OP_DV_CHECK'=1866 +'SYS_OP_ENFORCE_NOT_NULL$'=1867 +'SYSOPER'=1868 +'SYS_OP_EXTRACT'=1869 +'SYS_OP_GROUPING'=1870 +'SYS_OP_GUID'=1871 +'SYS_OP_HASH'=1872 +'SYS_OP_IIX'=1873 +'SYS_OP_ITR'=1874 +'SYS_OP_KEY_VECTOR_CREATE'=1875 +'SYS_OP_KEY_VECTOR_FILTER_LIST'=1876 +'SYS_OP_KEY_VECTOR_FILTER'=1877 +'SYS_OP_KEY_VECTOR_SUCCEEDED'=1878 +'SYS_OP_KEY_VECTOR_USE'=1879 +'SYS_OP_LBID'=1880 +'SYS_OP_LOBLOC2BLOB'=1881 +'SYS_OP_LOBLOC2CLOB'=1882 +'SYS_OP_LOBLOC2ID'=1883 +'SYS_OP_LOBLOC2NCLOB'=1884 +'SYS_OP_LOBLOC2TYP'=1885 +'SYS_OP_LSVI'=1886 +'SYS_OP_LVL'=1887 +'SYS_OP_MAKEOID'=1888 +'SYS_OP_MAP_NONNULL'=1889 +'SYS_OP_MSR'=1890 +'SYS_OP_NICOMBINE'=1891 +'SYS_OP_NIEXTRACT'=1892 +'SYS_OP_NII'=1893 +'SYS_OP_NIX'=1894 +'SYS_OP_NOEXPAND'=1895 +'SYS_OP_NTCIMG$'=1896 +'SYS_OP_NUMTORAW'=1897 +'SYS_OP_OIDVALUE'=1898 +'SYS_OP_OPNSIZE'=1899 +'SYS_OP_PAR_1'=1900 +'SYS_OP_PARGID_1'=1901 +'SYS_OP_PARGID'=1902 +'SYS_OP_PAR'=1903 +'SYS_OP_PART_ID'=1904 +'SYS_OP_PIVOT'=1905 +'SYS_OP_R2O'=1906 +'SYS_OP_RAWTONUM'=1907 +'SYS_OP_RDTM'=1908 +'SYS_OP_REF'=1909 +'SYS_OP_RMTD'=1910 +'SYS_OP_ROWIDTOOBJ'=1911 +'SYS_OP_RPB'=1912 +'SYS_OPTLOBPRBSC'=1913 +'SYS_OP_TOSETID'=1914 +'SYS_OP_TPR'=1915 +'SYS_OP_TRTB'=1916 +'SYS_OPTXICMP'=1917 +'SYS_OPTXQCASTASNQ'=1918 +'SYS_OP_UNDESCEND'=1919 +'SYS_OP_VECAND'=1920 +'SYS_OP_VECBIT'=1921 +'SYS_OP_VECOR'=1922 +'SYS_OP_VECXOR'=1923 +'SYS_OP_VERSION'=1924 +'SYS_OP_VREF'=1925 +'SYS_OP_VVD'=1926 +'SYS_OP_XMLCONS_FOR_CSX'=1927 +'SYS_OP_XPTHATG'=1928 +'SYS_OP_XPTHIDX'=1929 +'SYS_OP_XPTHOP'=1930 +'SYS_OP_XTXT2SQLT'=1931 +'SYS_OP_ZONE_ID'=1932 +'SYS_ORDERKEY_DEPTH'=1933 +'SYS_ORDERKEY_MAXCHILD'=1934 +'SYS_ORDERKEY_PARENT'=1935 +'SYS_PARALLEL_TXN'=1936 +'SYS_PATHID_IS_ATTR'=1937 +'SYS_PATHID_IS_NMSPC'=1938 +'SYS_PATHID_LASTNAME'=1939 +'SYS_PATHID_LASTNMSPC'=1940 +'SYS_PATH_REVERSE'=1941 +'SYS_PXQEXTRACT'=1942 +'SYS_RAW_TO_XSID'=1943 +'SYS_RID_ORDER'=1944 +'SYS_ROW_DELTA'=1945 +'SYS_SC_2_XMLT'=1946 +'SYS_SYNRCIREDO'=1947 +'SYSTEM_DEFINED'=1948 +'SYSTEM'=1949 +'SYSTIMESTAMP'=1950 +'SYS_TYPEID'=1951 +'SYS_UMAKEXML'=1952 +'SYS_XMLANALYZE'=1953 +'SYS_XMLCONTAINS'=1954 +'SYS_XMLCONV'=1955 +'SYS_XMLEXNSURI'=1956 +'SYS_XMLGEN'=1957 +'SYS_XMLI_LOC_ISNODE'=1958 +'SYS_XMLI_LOC_ISTEXT'=1959 +'SYS_XMLINSTR'=1960 +'SYS_XMLLOCATOR_GETSVAL'=1961 +'SYS_XMLNODEID_GETCID'=1962 +'SYS_XMLNODEID_GETLOCATOR'=1963 +'SYS_XMLNODEID_GETOKEY'=1964 +'SYS_XMLNODEID_GETPATHID'=1965 +'SYS_XMLNODEID_GETPTRID'=1966 +'SYS_XMLNODEID_GETRID'=1967 +'SYS_XMLNODEID_GETSVAL'=1968 +'SYS_XMLNODEID_GETTID'=1969 +'SYS_XMLNODEID'=1970 +'SYS_XMLT_2_SC'=1971 +'SYS_XMLTRANSLATE'=1972 +'SYS_XMLTYPE2SQL'=1973 +'SYS_XQ_ASQLCNV'=1974 +'SYS_XQ_ATOMCNVCHK'=1975 +'SYS_XQBASEURI'=1976 +'SYS_XQCASTABLEERRH'=1977 +'SYS_XQCODEP2STR'=1978 +'SYS_XQCODEPEQ'=1979 +'SYS_XQCON2SEQ'=1980 +'SYS_XQCONCAT'=1981 +'SYS_XQDELETE'=1982 +'SYS_XQDFLTCOLATION'=1983 +'SYS_XQDOC'=1984 +'SYS_XQDOCURI'=1985 +'SYS_XQDURDIV'=1986 +'SYS_XQED4URI'=1987 +'SYS_XQENDSWITH'=1988 +'SYS_XQERRH'=1989 +'SYS_XQERR'=1990 +'SYS_XQESHTMLURI'=1991 +'SYS_XQEXLOBVAL'=1992 +'SYS_XQEXSTWRP'=1993 +'SYS_XQEXTRACT'=1994 +'SYS_XQEXTRREF'=1995 +'SYS_XQEXVAL'=1996 +'SYS_XQFB2STR'=1997 +'SYS_XQFNBOOL'=1998 +'SYS_XQFNCMP'=1999 +'SYS_XQFNDATIM'=2000 +'SYS_XQFNLNAME'=2001 +'SYS_XQFNNM'=2002 +'SYS_XQFNNSURI'=2003 +'SYS_XQFNPREDTRUTH'=2004 +'SYS_XQFNQNM'=2005 +'SYS_XQFNROOT'=2006 +'SYS_XQFORMATNUM'=2007 +'SYS_XQFTCONTAIN'=2008 +'SYS_XQFUNCR'=2009 +'SYS_XQGETCONTENT'=2010 +'SYS_XQINDXOF'=2011 +'SYS_XQINSERT'=2012 +'SYS_XQINSPFX'=2013 +'SYS_XQIRI2URI'=2014 +'SYS_XQLANG'=2015 +'SYS_XQLLNMFRMQNM'=2016 +'SYS_XQMKNODEREF'=2017 +'SYS_XQNILLED'=2018 +'SYS_XQNODENAME'=2019 +'SYS_XQNORMSPACE'=2020 +'SYS_XQNORMUCODE'=2021 +'SYS_XQ_NRNG'=2022 +'SYS_XQNSP4PFX'=2023 +'SYS_XQNSPFRMQNM'=2024 +'SYS_XQPFXFRMQNM'=2025 +'SYS_XQ_PKSQL2XML'=2026 +'SYS_XQPOLYABS'=2027 +'SYS_XQPOLYADD'=2028 +'SYS_XQPOLYCEL'=2029 +'SYS_XQPOLYCSTBL'=2030 +'SYS_XQPOLYCST'=2031 +'SYS_XQPOLYDIV'=2032 +'SYS_XQPOLYFLR'=2033 +'SYS_XQPOLYMOD'=2034 +'SYS_XQPOLYMUL'=2035 +'SYS_XQPOLYRND'=2036 +'SYS_XQPOLYSQRT'=2037 +'SYS_XQPOLYSUB'=2038 +'SYS_XQPOLYUMUS'=2039 +'SYS_XQPOLYUPLS'=2040 +'SYS_XQPOLYVEQ'=2041 +'SYS_XQPOLYVGE'=2042 +'SYS_XQPOLYVGT'=2043 +'SYS_XQPOLYVLE'=2044 +'SYS_XQPOLYVLT'=2045 +'SYS_XQPOLYVNE'=2046 +'SYS_XQREF2VAL'=2047 +'SYS_XQRENAME'=2048 +'SYS_XQREPLACE'=2049 +'SYS_XQRESVURI'=2050 +'SYS_XQRNDHALF2EVN'=2051 +'SYS_XQRSLVQNM'=2052 +'SYS_XQRYENVPGET'=2053 +'SYS_XQRYVARGET'=2054 +'SYS_XQRYWRP'=2055 +'SYS_XQSEQ2CON4XC'=2056 +'SYS_XQSEQ2CON'=2057 +'SYS_XQSEQDEEPEQ'=2058 +'SYS_XQSEQINSB'=2059 +'SYS_XQSEQRM'=2060 +'SYS_XQSEQRVS'=2061 +'SYS_XQSEQSUB'=2062 +'SYS_XQSEQTYPMATCH'=2063 +'SYS_XQSTARTSWITH'=2064 +'SYS_XQSTATBURI'=2065 +'SYS_XQSTR2CODEP'=2066 +'SYS_XQSTRJOIN'=2067 +'SYS_XQSUBSTRAFT'=2068 +'SYS_XQSUBSTRBEF'=2069 +'SYS_XQTOKENIZE'=2070 +'SYS_XQTREATAS'=2071 +'SYS_XQ_UPKXML2SQL'=2072 +'SYS_XQXFORM'=2073 +'SYS_XSID_TO_RAW'=2074 +'SYS_ZMAP_FILTER'=2075 +'SYS_ZMAP_REFRESH'=2076 +'T'=2077 +'TABLE_LOOKUP_BY_NL'=2078 +'TABLESPACE_NO'=2079 +'TABLESPACE'=2080 +'TABLES'=2081 +'TABLE_STATS'=2082 +'TABLE'=2083 +'TABNO'=2084 +'TAG'=2085 +'TANH'=2086 +'TAN'=2087 +'TBL$OR$IDX$PART$NUM'=2088 +'TEMPFILE'=2089 +'TEMPLATE'=2090 +'TEMPLATE_TABLE'=2091 +'TEMPORARY'=2092 +'TEMP_TABLE'=2093 +'TERMINATED'=2094 +'TEST'=2095 +'TEXT'=2096 +'TEXTFILE'=2097 +'THAN'=2098 +'THEN'=2099 +'THE'=2100 +'THESE'=2101 +'THREAD'=2102 +'THROUGH'=2103 +'TIER'=2104 +'TIES'=2105 +'TIMEOUT'=2106 +'TIMESTAMP_LTZ_UNCONSTRAINED'=2107 +'TIMESTAMP'=2108 +'TIMESTAMP_TZ_UNCONSTRAINED'=2109 +'TIMESTAMP_UNCONSTRAINED'=2110 +'TIMES'=2111 +'TIME'=2112 +'TIMEZONE'=2113 +'TIMEZONE_ABBR'=2114 +'TIMEZONE_HOUR'=2115 +'TIMEZONE_MINUTE'=2116 +'TIMEZONE_OFFSET'=2117 +'TIMEZONE_REGION'=2118 +'TIME_ZONE'=2119 +'TIMING'=2120 +'TINYINT'=2121 +'TIV_GB'=2122 +'TIV_SSF'=2123 +'TO_ACLID'=2124 +'TO_BINARY_DOUBLE'=2125 +'TO_BINARY_FLOAT'=2126 +'TO_BLOB'=2127 +'TO_CLOB'=2128 +'TO_DSINTERVAL'=2129 +'TO_LOB'=2130 +'TO_MULTI_BYTE'=2131 +'TO_NCHAR'=2132 +'TO_NCLOB'=2133 +'TO_NUMBER'=2134 +'TOPLEVEL'=2135 +'TO_SINGLE_BYTE'=2136 +'TO_TIMESTAMP'=2137 +'TO_TIMESTAMP_TZ'=2138 +'TO_TIME'=2139 +'TO_TIME_TZ'=2140 +'TO'=2141 +'TO_YMINTERVAL'=2142 +'TRACE'=2143 +'TRACING'=2144 +'TRACKING'=2145 +'TRAILING'=2146 +'TRANSACTION'=2147 +'TRANSFORM'=2148 +'TRANSFORMS'=2149 +'TRANSFORM_DISTINCT_AGG'=2150 +'TRANSITIONAL'=2151 +'TRANSITION'=2152 +'TRANSLATE'=2153 +'TRANSLATION'=2154 +'TREAT'=2155 +'TRIGGERS'=2156 +'TRIGGER'=2157 +'TRUE'=2158 +'TRUNCATE'=2159 +'TRUNC'=2160 +'TRUSTED'=2161 +'TRUST'=2162 +'TUNING'=2163 +'TX'=2164 +'TYPES'=2165 +'TYPE'=2166 +'TZ_OFFSET'=2167 +'UB2'=2168 +'UBA'=2169 +'UCS2'=2170 +'UDF'=2171 +'UID'=2172 +'UNARCHIVED'=2173 +'UNBOUNDED'=2174 +'UNBOUND'=2175 +'UNCONDITIONAL'=2176 +'UNDER'=2177 +'UNDO'=2178 +'UNDROP'=2179 +'UNIFORM'=2180 +'UNION'=2181 +'UNIONTYPE'=2182 +'UNIQUE'=2183 +'UNISTR'=2184 +'UNLIMITED'=2185 +'UNLOAD'=2186 +'UNLOCK'=2187 +'UNMATCHED'=2188 +'UNNEST_INNERJ_DISTINCT_VIEW'=2189 +'UNNEST_NOSEMIJ_NODISTINCTVIEW'=2190 +'UNNEST_SEMIJ_VIEW'=2191 +'UNNEST'=2192 +'UNPACKED'=2193 +'UNPIVOT'=2194 +'UNPLUG'=2195 +'UNPROTECTED'=2196 +'UNQUIESCE'=2197 +'UNRECOVERABLE'=2198 +'UNRESTRICTED'=2199 +'UNSIGNED'=2200 +'UNSUBSCRIBE'=2201 +'UNTIL'=2202 +'UNUSABLE'=2203 +'UNUSED'=2204 +'UPDATABLE'=2205 +'UPDATED'=2206 +'UPDATE'=2207 +'UPDATEXML'=2208 +'UPD_INDEXES'=2209 +'UPD_JOININDEX'=2210 +'UPGRADE'=2211 +'UPPER'=2212 +'UPSERT'=2213 +'UROWID'=2214 +'USABLE'=2215 +'USAGE'=2216 +'USE_ANTI'=2217 +'USE_CONCAT'=2218 +'USE_CUBE'=2219 +'USE_HASH_AGGREGATION'=2220 +'USE_HASH_GBY_FOR_PUSHDOWN'=2221 +'USE_HASH'=2222 +'USE_HIDDEN_PARTITIONS'=2223 +'USE_INVISIBLE_INDEXES'=2224 +'USE_MERGE_CARTESIAN'=2225 +'USE_MERGE'=2226 +'USE_NL'=2227 +'USE_NL_WITH_INDEX'=2228 +'USE_PRIVATE_OUTLINES'=2229 +'USER_DATA'=2230 +'USER_DEFINED'=2231 +'USERENV'=2232 +'USERGROUP'=2233 +'USER_RECYCLEBIN'=2234 +'USERS'=2235 +'USER_TABLESPACES'=2236 +'USER'=2237 +'USE_SEMI'=2238 +'USE_STORED_OUTLINES'=2239 +'USE_TTT_FOR_GSETS'=2240 +'USE'=2241 +'USE_VECTOR_AGGREGATION'=2242 +'USE_WEAK_NAME_RESL'=2243 +'USING_NO_EXPAND'=2244 +'USING_NLS_COMP'=2245 +'USING'=2246 +'UTF16BE'=2247 +'UTF16LE'=2248 +'UTF32'=2249 +'UTF8'=2250 +'V1'=2251 +'V2'=2252 +'VALIDATE'=2253 +'VALIDATE_CONVERSION'=2254 +'VALIDATION'=2255 +'VALID_TIME_END'=2256 +'VALUES'=2257 +'VALUE'=2258 +'VARCHAR2'=2259 +'VARCHAR'=2260 +'VARCHARC'=2261 +'VARIABLE'=2262 +'VARRAW'=2263 +'VARRAWC'=2264 +'VAR_POP'=2265 +'VARRAYS'=2266 +'VARRAY'=2267 +'VAR_SAMP'=2268 +'VARYING'=2269 +'VECTOR_READ_TRACE'=2270 +'VECTOR_READ'=2271 +'VECTOR_TRANSFORM_DIMS'=2272 +'VECTOR_TRANSFORM_FACT'=2273 +'VECTOR_TRANSFORM'=2274 +'VERIFIER'=2275 +'VERIFY'=2276 +'VERSIONING'=2277 +'VERSIONS_ENDSCN'=2278 +'VERSIONS_ENDTIME'=2279 +'VERSIONS_OPERATION'=2280 +'VERSIONS_STARTSCN'=2281 +'VERSIONS_STARTTIME'=2282 +'VERSIONS'=2283 +'VERSIONS_XID'=2284 +'VERSION'=2285 +'VIEW'=2286 +'VIOLATION'=2287 +'VIRTUAL'=2288 +'VISIBILITY'=2289 +'VISIBLE'=2290 +'VOLUME'=2291 +'VSIZE'=2292 +'WAIT'=2293 +'WALLET'=2294 +'WARNING'=2295 +'WEEKS'=2296 +'WEEK'=2297 +'WELLFORMED'=2298 +'WHENEVER'=2299 +'WHEN'=2300 +'WHERE'=2301 +'WHILE'=2302 +'WHITESPACE'=2303 +'WIDTH_BUCKET'=2304 +'WITHIN'=2305 +'WITHOUT'=2306 +'WITH_PLSQL'=2307 +'WITH'=2308 +'WORK'=2309 +'WORKERID'=2310 +'WRAPPED'=2311 +'WRAPPER'=2312 +'WRITE'=2313 +'XDB_FASTPATH_INSERT'=2314 +'XDB'=2315 +'X_DYN_PRUNE'=2316 +'XID'=2317 +'XML2OBJECT'=2318 +'XMLAGG'=2319 +'XMLATTRIBUTES'=2320 +'XMLCAST'=2321 +'XMLCDATA'=2322 +'XMLCOLATTVAL'=2323 +'XMLCOMMENT'=2324 +'XMLCONCAT'=2325 +'XMLDIFF'=2326 +'XML_DML_RWT_STMT'=2327 +'XMLELEMENT'=2328 +'XMLEXISTS2'=2329 +'XMLEXISTS'=2330 +'XMLFOREST'=2331 +'XMLINDEX'=2332 +'XMLINDEX_REWRITE_IN_SELECT'=2333 +'XMLINDEX_REWRITE'=2334 +'XMLINDEX_SEL_IDX_TBL'=2335 +'XMLISNODE'=2336 +'XMLISVALID'=2337 +'XMLNAMESPACES'=2338 +'XMLPARSE'=2339 +'XMLPATCH'=2340 +'XMLPI'=2341 +'XMLQUERYVAL'=2342 +'XMLQUERY'=2343 +'XMLROOT'=2344 +'XMLSCHEMA'=2345 +'XMLSERIALIZE'=2346 +'XMLTABLE'=2347 +'XMLTAG'=2348 +'XMLTRANSFORMBLOB'=2349 +'XMLTRANSFORM'=2350 +'XMLTYPE'=2351 +'XML'=2352 +'XPATHTABLE'=2353 +'XS_SYS_CONTEXT'=2354 +'XS'=2355 +'XTRANSPORT'=2356 +'YEARS'=2357 +'YEAR'=2358 +'YEAR_TO_MONTH'=2359 +'YES'=2360 +'YMINTERVAL_UNCONSTRAINED'=2361 +'ZONEMAP'=2362 +'ZONE'=2363 +'ZONED'=2364 +'PREDICTION'=2365 +'PREDICTION_BOUNDS'=2366 +'PREDICTION_COST'=2367 +'PREDICTION_DETAILS'=2368 +'PREDICTION_PROBABILITY'=2369 +'PREDICTION_SET'=2370 +'BLOCKCHAIN'=2371 +'COLLATE'=2372 +'COLLATION'=2373 +'DEFINITION'=2374 +'DUPLICATED'=2375 +'EXTENDED'=2376 +'HASHING'=2377 +'IDLE'=2378 +'IMMUTABLE'=2379 +'ORACLE_DATAPUMP'=2380 +'ORACLE_HDFS'=2381 +'ORACLE_HIVE'=2382 +'ORACLE_LOADER'=2383 +'"SHA2_512"'=2384 +'SHARDED'=2385 +'"V1"'=2386 +'ISOLATE'=2387 +'ROOT'=2388 +'UNITE'=2389 +'ALGORITHM'=2390 +'CUME_DIST'=2391 +'DENSE_RANK'=2392 +'LISTAGG'=2393 +'PERCENT_RANK'=2394 +'PERCENTILE_CONT'=2395 +'PERCENTILE_DISC'=2396 +'RANK'=2397 +'AVG'=2398 +'CORR'=2399 +'COVAR_'=2400 +'DECODE'=2401 +'LAG'=2402 +'LAG_DIFF'=2403 +'LAG_DIFF_PERCENT'=2404 +'LEAD'=2405 +'MAX'=2406 +'MEDIAN'=2407 +'MEMOPTIMIZE'=2408 +'MIN'=2409 +'NTILE'=2410 +'NVL'=2411 +'RATIO_TO_REPORT'=2412 +'REGR_'=2413 +'ROUND'=2414 +'ROW_NUMBER'=2415 +'SUBSTR'=2416 +'TO_CHAR'=2417 +'TRIM'=2418 +'SUM'=2419 +'STDDEV'=2420 +'VAR_'=2421 +'VARIANCE'=2422 +'LEAST'=2423 +'GREATEST'=2424 +'TO_DATE'=2425 +'CHARSETID'=2426 +'CHARSETFORM'=2427 +'DURATION'=2428 +'EXTEND'=2429 +'MAXLEN'=2430 +'PERSISTABLE'=2431 +'POLYMORPHIC'=2432 +'STRUCT'=2433 +'TDO'=2434 +'WM_CONCAT'=2435 +'..'=2439 +'.'=2440 +'%'=2445 +'&'=2446 +'('=2447 +')'=2448 +'**'=2449 +'*'=2450 +'+'=2451 +'-'=2452 +','=2453 +'/'=2454 +'\\'=2455 +'@'=2456 +':='=2457 +'#'=2458 +'{'=2459 +'}'=2460 +'\''=2461 +'^'=2464 +'~'=2465 +'!'=2466 +'>'=2467 +'<'=2468 +':'=2469 +';'=2470 +'|'=2471 +'='=2472 +'['=2473 +']'=2474 +'_'=2475 diff --git a/internal/engine/oracle/parser/README.md b/internal/engine/oracle/parser/README.md new file mode 100644 index 0000000000..765e611025 --- /dev/null +++ b/internal/engine/oracle/parser/README.md @@ -0,0 +1,45 @@ +# Oracle PL/SQL parser (ANTLR-generated) + +This package contains the ANTLR-generated Go lexer/parser for Oracle SQL/PL-SQL, +following the same pattern as [`internal/engine/sqlite/parser`](../../sqlite/parser). + +## Provenance + +- **Grammar:** `PlSqlLexer.g4`, `PlSqlParser.g4` are vendored from + [antlr/grammars-v4](https://github.com/antlr/grammars-v4) (`sql/plsql`). They have + been transformed for the Go target: the embedded `this.` actions were rewritten to + `p.` (parser) / `l.` (lexer) via `transformGrammar.py`. +- **Base classes:** `plsql_lexer_base.go` and `plsql_parser_base.go` are hand-written + and supply the grammar `superClass` implementations + (`PlSqlLexerBase` / `PlSqlParserBase`). They embed `antlr.BaseLexer` / + `antlr.BaseParser` from `github.com/antlr4-go/antlr/v4`. +- **ANTLR version:** 4.13.1, matching the `github.com/antlr4-go/antlr/v4` runtime + version pinned in `go.mod` (and the version used by the SQLite engine). + +## Generated files (committed, do not edit) + +- `plsql_lexer.go` +- `plsql_parser.go` +- `plsqlparser_listener.go` +- `plsqlparser_base_listener.go` +- `*.interp`, `*.tokens` + +Because these are committed, a normal `go build` does **not** require Java. Java + +the ANTLR jar are only needed to regenerate. + +## Regenerating + +```sh +# from this directory +make fetch-grammar # refresh .g4 from grammars-v4 and re-apply the Go transform +make # downloads the ANTLR jar (if missing) and regenerates the Go code +``` + +The ANTLR jar (`antlr-4.13.1-complete.jar`) is git-ignored. + +## Entry point + +The top-level parser rule is `Sql_script()` (grammar rule `sql_script`). Individual +statements are reachable via `Unit_statement()` / +`Data_manipulation_language_statements()`. The Phase 2 AST converter consumes these +to produce sqlc's shared AST in [`internal/sql/ast`](../../../sql/ast). diff --git a/internal/engine/oracle/parser/plsql_lexer.go b/internal/engine/oracle/parser/plsql_lexer.go new file mode 100644 index 0000000000..de7490d146 --- /dev/null +++ b/internal/engine/oracle/parser/plsql_lexer.go @@ -0,0 +1,19838 @@ +// Code generated from PlSqlLexer.g4 by ANTLR 4.13.1. DO NOT EDIT. + +package parser + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type PlSqlLexer struct { + PlSqlLexerBase + channelNames []string + modeNames []string + // TODO: EOF string +} + +var PlSqlLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func plsqllexerLexerInit() { + staticData := &PlSqlLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", "'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'", "'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'", "'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'", + "", "", "", "'PERCENT'", "'PERCENT_RANKM'", "", "", "", "", "", "'PERFORMANCE'", + "'PERIOD'", "'PERMANENT'", "'PERMISSION'", "'PERMUTE'", "'PER'", "'PFILE'", + "'PHYSICAL'", "'PIKEY'", "'PIPELINED'", "'PIPE'", "'PIV_GB'", "'PIVOT'", + "'PIV_SSF'", "'PLACE_DISTINCT'", "'PLACE_GROUP_BY'", "'PLAN'", "'PLSCOPE_SETTINGS'", + "'PLS_INTEGER'", "'PLSQL_CCFLAGS'", "'PLSQL_CODE_TYPE'", "'PLSQL_DEBUG'", + "'PLSQL_OPTIMIZE_LEVEL'", "'PLSQL_WARNINGS'", "'PLUGGABLE'", "'PMEM'", + "'POINT'", "'POLICY'", "'POOL_16K'", "'POOL_2K'", "'POOL_32K'", "'POOL_4K'", + "'POOL_8K'", "'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'", "", "'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'", "", "", "", "'..'", "'.'", "", "", + "", "", "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", "','", + "'/'", "'\\'", "'@'", "':='", "'#'", "'{'", "'}'", "'''", "", "", "'^'", + "'~'", "'!'", "'>'", "'<'", "':'", "';'", "'|'", "'='", "'['", "']'", + "'_'", + } + staticData.SymbolicNames = []string{ + "", "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", "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", "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", + } + staticData.RuleNames = []string{ + "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", "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", "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", "QS_ANGLE", "QS_BRACE", "QS_BRACK", + "QS_PAREN", "QS_EXCLAM", "QS_SHARP", "QS_QUOTE", "QS_DQUOTE", "QS_TILDA", + "QS_SOLIDUS", "QS_RSOLIDUS", "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", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 2482, 32452, 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, 2, 2491, + 7, 2491, 2, 2492, 7, 2492, 2, 2493, 7, 2493, 2, 2494, 7, 2494, 2, 2495, + 7, 2495, 2, 2496, 7, 2496, 2, 2497, 7, 2497, 2, 2498, 7, 2498, 2, 2499, + 7, 2499, 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, 541, 1, + 541, 1, 541, 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, 543, 1, 543, 1, + 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 1, + 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, + 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 547, 1, 547, 1, 547, 1, 547, 1, + 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, + 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 548, 1, + 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, + 548, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, + 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, + 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, + 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 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, 554, 1, 554, 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, + 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, 558, 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, 559, 1, 560, 1, 560, 1, 560, 1, 560, 1, + 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 561, 1, 561, 1, + 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, + 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, + 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 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, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, + 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, + 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, + 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, + 568, 1, 568, 1, 568, 1, 568, 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, + 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 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, 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, 574, 1, 574, 1, 574, 1, + 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, + 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, + 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, + 578, 1, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, + 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, + 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, + 581, 1, 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, + 583, 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, 584, 1, 584, 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, 587, 1, + 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, + 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, + 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, + 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, 592, 1, + 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, + 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, + 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, + 595, 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, + 596, 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 598, 1, + 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, + 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 600, 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, 602, 1, + 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, + 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, + 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 604, 1, 604, 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, 605, 1, 605, 1, + 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 607, 1, 607, 1, 607, 1, + 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, + 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, + 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, + 612, 1, 612, 1, 612, 1, 612, 1, 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, 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, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, + 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, + 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, + 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 618, 1, + 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, + 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, + 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 622, 1, + 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, + 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 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, 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, 627, 1, 627, 1, 627, 1, 627, 1, + 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, + 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, + 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, + 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, + 630, 1, 630, 1, 630, 1, 631, 1, 631, 1, 631, 1, 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, 632, 1, 633, 1, 633, 1, 633, 1, 633, 1, 634, 1, + 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, + 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, + 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, + 635, 1, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, + 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, + 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 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, + 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, 641, 1, 641, 1, 641, 1, 641, 1, + 641, 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, + 642, 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, + 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 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, 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, 646, 1, 646, 1, 646, 1, 646, 1, + 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, + 647, 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, + 649, 1, 649, 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, 651, 1, + 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, + 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, + 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, + 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, + 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, + 656, 1, 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, + 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, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, + 660, 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, + 661, 1, 661, 1, 661, 1, 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, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, + 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, + 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, 669, 1, 669, 1, + 669, 1, 669, 1, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, + 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, + 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, + 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, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, + 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, + 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, 677, 1, + 677, 1, 677, 1, 677, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, + 679, 1, 679, 1, 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, 681, 1, 681, 1, 681, 1, + 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, + 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, + 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 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, + 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, + 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 1, 688, 1, 689, 1, 689, 1, + 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 690, 1, + 690, 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, + 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, + 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, + 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, + 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, + 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 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, 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, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, + 697, 1, 697, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, + 698, 1, 698, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, + 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, + 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, + 701, 1, 701, 1, 701, 1, 701, 1, 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, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, + 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, + 703, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 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, 705, 1, 705, 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, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, + 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, + 709, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, + 710, 1, 710, 1, 710, 1, 710, 1, 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, 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, 714, 1, 714, 1, 715, 1, 715, 1, + 715, 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, 717, 1, + 717, 1, 717, 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, 718, 1, + 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, + 719, 1, 719, 1, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, + 720, 1, 720, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, + 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 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, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, + 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, + 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, + 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, + 725, 1, 725, 1, 725, 1, 725, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, + 726, 1, 726, 1, 726, 1, 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, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, + 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, + 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 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, + 731, 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, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, + 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, + 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, + 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, 1, 737, 1, 737, 1, 738, 1, + 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 739, 1, 739, 1, + 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1, 740, 1, 740, 1, + 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, + 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, + 741, 1, 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, 744, 1, + 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, + 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, + 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, + 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, + 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, + 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, + 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 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, 750, 1, + 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, + 751, 1, 751, 1, 751, 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, + 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, + 752, 1, 752, 1, 752, 1, 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, 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, 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, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, + 756, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 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, 759, 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, 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, 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, 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, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, + 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, + 769, 1, 769, 1, 769, 1, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, + 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 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, 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, 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, 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, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, + 777, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, + 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 780, 1, + 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, + 780, 1, 780, 1, 780, 1, 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, 783, 1, 784, 1, 784, 1, + 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, + 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 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, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, + 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, + 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, + 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, + 790, 1, 790, 1, 790, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, + 792, 1, 792, 1, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 794, 1, + 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, + 794, 1, 794, 1, 794, 1, 794, 1, 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, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, + 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 799, 1, 799, 1, 799, 1, + 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, + 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, + 801, 1, 801, 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, 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, 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, + 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, + 805, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, + 806, 1, 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, 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, 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, 811, 1, 811, 1, 812, 1, 812, 1, 812, 1, 812, 1, + 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, + 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, + 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 815, 1, + 815, 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, + 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, + 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, + 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, + 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, 1, 821, 1, 821, 1, + 821, 1, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, + 822, 1, 822, 1, 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, 825, 1, 825, 1, + 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, + 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, + 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, 1, 828, 1, 828, 1, + 828, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, + 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, + 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, + 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, + 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, + 831, 1, 831, 1, 831, 1, 831, 1, 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, 832, 1, 832, 1, 832, 1, + 832, 1, 832, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, + 833, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, 835, 1, + 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, + 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 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, + 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, + 839, 1, 839, 1, 839, 1, 839, 1, 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, 844, 1, + 844, 1, 844, 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, + 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, + 846, 1, 846, 1, 846, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, + 847, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, + 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, + 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, + 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 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, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, + 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, 1, 857, 1, 857, 1, 857, 1, + 857, 1, 857, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, + 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 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, 862, 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 1, + 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, + 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 867, 1, 867, 1, 867, 1, 867, 1, + 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 869, 1, + 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, 870, 1, + 870, 1, 870, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, + 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 872, 1, 872, 1, + 872, 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, + 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, + 874, 1, 874, 1, 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, 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, + 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 879, 1, + 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 880, 1, 880, 1, + 880, 1, 880, 1, 880, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, + 881, 1, 881, 1, 882, 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, 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, 885, 1, + 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, + 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 886, 1, 886, 1, 886, 1, 886, 1, + 886, 1, 886, 1, 886, 1, 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, 888, 1, + 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, + 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 890, 1, 890, 1, + 890, 1, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, + 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, + 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, + 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 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, 895, 1, 896, 1, 896, 1, 896, 1, 896, 1, + 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 1, 898, 1, + 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, + 900, 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, + 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 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, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, + 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, 906, 1, + 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, + 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, + 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, 1, + 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 911, 1, 911, 1, + 911, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, + 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, + 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 915, 1, + 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 916, 1, 916, 1, 916, 1, 916, 1, + 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, + 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, 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, 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, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, + 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 923, 1, 923, 1, 923, 1, 923, 1, + 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 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, 926, 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, 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, + 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, 930, 1, 930, 1, 930, 1, + 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 931, 1, 931, 1, 931, 1, + 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, 1, + 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 933, 1, 933, 1, 933, 1, 933, 1, + 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 934, 1, 934, 1, 934, 1, 934, 1, + 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, 936, 1, + 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 937, 1, 937, 1, + 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 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, 939, 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, 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, 941, 1, 941, 1, 941, 1, + 941, 1, 941, 1, 941, 1, 941, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, + 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, + 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, + 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, + 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 945, 1, 945, 1, 945, 1, + 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, + 946, 1, 946, 1, 946, 1, 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, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, + 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, + 950, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, + 951, 1, 951, 1, 951, 1, 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, 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, 956, 1, 956, 1, 956, 1, + 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 957, 1, + 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 958, 1, 958, 1, 958, 1, + 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 959, 1, 959, 1, 959, 1, 959, 1, + 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 960, 1, 960, 1, 960, 1, 960, 1, + 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, + 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 962, 1, + 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 963, 1, 963, 1, 963, 1, + 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 964, 1, 964, 1, 964, 1, 964, 1, + 964, 1, 964, 1, 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, 966, 1, 966, 1, 966, 1, 966, 1, + 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, + 966, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, + 967, 1, 967, 1, 967, 1, 967, 1, 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, 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, 971, 1, 971, 1, 971, 1, 971, 1, + 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, + 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, + 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 973, 1, 973, 1, 973, 1, 973, 1, + 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 974, 1, 974, 1, 974, 1, + 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, + 974, 1, 974, 1, 974, 1, 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, 977, 1, + 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, + 977, 1, 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, + 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, + 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, + 979, 1, 979, 1, 980, 1, 980, 1, 980, 1, 980, 1, 981, 1, 981, 1, 981, 1, + 981, 1, 981, 1, 981, 1, 981, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, + 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 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, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, + 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 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, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, + 988, 1, 988, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, + 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 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, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, + 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, 1, + 992, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, + 993, 1, 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, 996, 1, 996, 1, + 996, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, + 997, 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, 998, 1, 999, 1, + 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, + 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 1, 1002, 1, 1002, 1, 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, + 1, 1003, 1, 1003, 1, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, + 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, + 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, + 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1009, 1, 1009, + 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, 1, 1012, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1013, 1, 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, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 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, 1017, + 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, 1020, 1, 1020, + 1, 1020, 1, 1020, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, + 1, 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 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, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1026, + 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, + 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 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, 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, 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, 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, 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, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1035, 1, 1035, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1036, 1, 1036, 1, 1036, + 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 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, 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, 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, 1040, 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, 1040, 1, 1040, 1, 1040, + 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1042, + 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, + 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, + 1, 1043, 1, 1043, 1, 1043, 1, 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, 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, 1046, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 1, 1046, 1, 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, 1047, 1, 1047, 1, 1047, 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, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, + 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, 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, 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, 1057, 1, 1057, + 1, 1057, 1, 1057, 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, 1059, 1, 1059, 1, 1060, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 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, 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, 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, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 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, 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, 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, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 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, 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, 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, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, 1, 1081, + 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, + 1, 1081, 1, 1081, 1, 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, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1083, 1, 1083, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 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, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, + 1, 1086, 1, 1086, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1088, 1, 1088, 1, 1088, + 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, 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, 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, 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, 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, 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, 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, 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, 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, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, + 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, + 1, 1098, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, + 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1101, 1, 1101, 1, 1101, 1, 1101, + 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 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, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, + 1, 1103, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1105, + 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 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, 1107, 1, 1107, + 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, + 1, 1107, 1, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, + 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, + 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, + 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 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, 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, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, + 1, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, + 1, 1115, 1, 1115, 1, 1115, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, + 1, 1117, 1, 1117, 1, 1117, 1, 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, 1120, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, + 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 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, 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, 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, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, + 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 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, 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, 1131, 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, 1131, + 1, 1131, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1133, 1, 1133, + 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1135, + 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, + 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 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, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, + 1, 1139, 1, 1139, 1, 1139, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, + 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, + 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1141, 1, 1141, 1, 1141, 1, 1141, + 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, + 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, + 1, 1141, 1, 1141, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, + 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 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, 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, 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, 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, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, + 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, + 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, + 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, + 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, + 1, 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, 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, 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, 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, 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, 1157, + 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1158, 1, 1158, 1, 1158, + 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, + 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, + 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 1171, 1, 1171, 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, 1172, 1, 1172, + 1, 1172, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, + 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, 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, 1178, + 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, + 1, 1178, 1, 1178, 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, 1179, 1, 1179, 1, 1179, 1, 1179, 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, 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, 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, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, + 1, 1184, 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, 1185, + 1, 1185, 1, 1185, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, + 1, 1186, 1, 1186, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1187, 1, 1187, + 1, 1187, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, + 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, + 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1189, 1, 1189, 1, 1189, 1, 1189, + 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 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, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 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, 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, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1194, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 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, 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, 1198, 1, 1198, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, + 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, + 1, 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, 1202, 1, 1202, 1, 1202, + 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1203, 1, 1203, 1, 1203, 1, 1203, + 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1204, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, + 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1206, 1, 1206, 1, 1206, 1, 1206, + 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, + 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, + 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, + 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, + 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, + 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, + 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, + 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1209, 1, 1209, 1, 1209, + 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, + 1, 1209, 1, 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, 1211, 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, 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, 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, 1216, + 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, + 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 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, 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, 1219, + 1, 1219, 1, 1219, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, + 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, + 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1221, 1, 1221, 1, 1221, + 1, 1221, 1, 1221, 1, 1221, 1, 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, 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, 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, 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, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, + 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1228, 1, 1228, 1, 1228, + 1, 1228, 1, 1228, 1, 1228, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, + 1, 1229, 1, 1229, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, + 1, 1230, 1, 1230, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, + 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, + 1, 1231, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, + 1, 1232, 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, 1233, 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, 1236, 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, 1237, 1, 1237, 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, 1240, + 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, + 1, 1240, 1, 1240, 1, 1240, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, + 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1242, 1, 1242, + 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1243, 1, 1243, + 1, 1243, 1, 1243, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1244, 1, 1244, + 1, 1244, 1, 1245, 1, 1245, 1, 1245, 1, 1246, 1, 1246, 1, 1246, 1, 1246, + 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1247, 1, 1247, 1, 1247, + 1, 1247, 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, 1250, + 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, + 1, 1251, 1, 1251, 1, 1251, 1, 1251, 1, 1252, 1, 1252, 1, 1252, 1, 1252, + 1, 1252, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1254, 1, 1254, + 1, 1254, 1, 1254, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, + 1, 1255, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, + 1, 1256, 1, 1256, 1, 1256, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, + 1, 1258, 1, 1258, 1, 1258, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, + 1, 1259, 1, 1259, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, + 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, + 1, 1260, 1, 1260, 1, 1260, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, + 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, + 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1262, 1, 1262, 1, 1262, + 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1263, 1, 1263, 1, 1263, 1, 1263, + 1, 1263, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, + 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1265, 1, 1265, 1, 1265, 1, 1265, + 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1266, 1, 1266, 1, 1266, + 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, + 1, 1266, 1, 1266, 1, 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, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, + 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, + 1, 1269, 1, 1269, 1, 1269, 1, 1269, 1, 1269, 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, 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, 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, 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, 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, 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, 1277, 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, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, + 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1281, 1, 1281, 1, 1281, 1, 1281, + 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 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, 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, 1283, 1, 1283, 1, 1283, 1, 1284, 1, 1284, 1, 1284, 1, 1284, + 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, + 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1285, 1, 1285, 1, 1285, 1, 1285, + 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 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, 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, 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, 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, 1289, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, + 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 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, 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, 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, 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, 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, 1296, 1, 1297, 1, 1297, 1, 1297, 1, 1297, 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, 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, 1301, 1, 1301, 1, 1301, + 1, 1301, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1303, + 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, + 1, 1303, 1, 1303, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, + 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1305, 1, 1305, 1, 1305, 1, 1305, + 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, + 1, 1305, 1, 1306, 1, 1306, 1, 1306, 1, 1307, 1, 1307, 1, 1307, 1, 1307, + 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, + 1, 1307, 1, 1307, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, + 1, 1308, 1, 1308, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, + 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, + 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, + 1, 1310, 1, 1310, 1, 1310, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, + 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, + 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1312, + 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1313, 1, 1313, 1, 1313, + 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, + 1, 1313, 1, 1313, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, + 1, 1314, 1, 1314, 1, 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, 1316, + 1, 1316, 1, 1316, 1, 1316, 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, 1318, 1, 1318, 1, 1318, 1, 1318, 1, 1319, + 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, + 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, + 1, 1320, 1, 1321, 1, 1321, 1, 1321, 1, 1321, 1, 1321, 1, 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, 1323, 1, 1323, 1, 1323, 1, 1323, + 1, 1323, 1, 1323, 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, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1327, 1, 1327, + 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, + 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, + 1, 1329, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, + 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, + 1, 1330, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, + 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, + 1, 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, 1334, + 1, 1334, 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, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1337, + 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, + 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, + 1, 1337, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, + 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, + 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1339, 1, 1339, 1, 1339, 1, 1339, + 1, 1339, 1, 1339, 1, 1339, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, + 1, 1340, 1, 1340, 1, 1340, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, + 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, + 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, + 1, 1342, 1, 1342, 1, 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, 1344, 1, 1344, 1, 1344, 1, 1344, + 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, 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, 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, 1348, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, + 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1350, 1, 1350, 1, 1350, + 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 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, 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, 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, 1353, + 1, 1353, 1, 1353, 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, 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, 1357, 1, 1357, 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, 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, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1360, 1, 1360, 1, 1360, + 1, 1360, 1, 1360, 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, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, + 1, 1363, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1365, + 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1366, + 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 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, 1367, 1, 1367, 1, 1367, 1, 1368, + 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1369, + 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, + 1, 1369, 1, 1369, 1, 1369, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, + 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, + 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, + 1, 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, 5, 1374, 19917, 8, 1374, 10, + 1374, 12, 1374, 19920, 9, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1374, 1, + 1374, 1, 1374, 1, 1375, 1, 1375, 5, 1375, 19930, 8, 1375, 10, 1375, 12, + 1375, 19933, 9, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, + 1, 1375, 1, 1376, 1, 1376, 5, 1376, 19944, 8, 1376, 10, 1376, 12, 1376, + 19947, 9, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, + 1376, 1, 1376, 1, 1376, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, + 1377, 1, 1377, 1, 1377, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, + 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, + 1378, 1, 1379, 1, 1379, 5, 1379, 19982, 8, 1379, 10, 1379, 12, 1379, 19985, + 9, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, + 1, 1379, 1, 1379, 1, 1380, 1, 1380, 5, 1380, 19998, 8, 1380, 10, 1380, + 12, 1380, 20001, 9, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, + 1, 1380, 1, 1380, 1, 1380, 1, 1381, 1, 1381, 5, 1381, 20013, 8, 1381, 10, + 1381, 12, 1381, 20016, 9, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, + 1381, 1, 1382, 1, 1382, 5, 1382, 20025, 8, 1382, 10, 1382, 12, 1382, 20028, + 9, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, + 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, + 1, 1382, 1, 1383, 1, 1383, 5, 1383, 20048, 8, 1383, 10, 1383, 12, 1383, + 20051, 9, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, + 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, + 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, + 1384, 1, 1384, 1, 1384, 1, 1384, 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, 1387, 1, 1387, 1, 1387, 1, + 1387, 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, + 1389, 1, 1389, 1, 1389, 1, 1389, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, + 1390, 1, 1390, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, + 1391, 1, 1391, 1, 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, 1393, 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, 1396, 1, + 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1397, 1, 1397, 1, 1397, 1, + 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1398, 1, 1398, 1, 1398, 1, + 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 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, 1399, 1, 1399, 1, 1399, 1, 1399, 1, + 1399, 1, 1399, 1, 1399, 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, 1401, 1, + 1401, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, + 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1403, 1, 1403, 1, 1403, 1, + 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 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, 1404, 1, + 1404, 1, 1404, 1, 1404, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, + 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1406, 1, + 1406, 1, 1406, 1, 1406, 1, 1406, 1, 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, + 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, 1409, 1, 1409, 1, 1409, 1, + 1409, 1, 1409, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, + 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1412, 1, + 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, + 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 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, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, + 1417, 1, 1417, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, + 1418, 1, 1418, 1, 1418, 1, 1418, 1, 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, 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, 1421, 1, + 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, + 1421, 1, 1421, 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, 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, 1424, 1, 1424, 1, 1424, 1, + 1424, 1, 1424, 1, 1424, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, + 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, + 1425, 1, 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, 1426, 1, 1427, 1, 1427, 1, + 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, + 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 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, 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, 1432, 1, 1432, 1, 1432, 1, + 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, + 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1434, 1, 1434, 1, 1434, 1, + 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1435, 1, 1435, 1, + 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, + 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, + 1436, 1, 1436, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, + 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, + 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, + 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, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, + 1440, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, + 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1442, 1, 1442, 1, + 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, + 1442, 1, 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, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, + 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1446, 1, + 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, + 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 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, 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, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, + 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1452, 1, 1452, 1, 1452, 1, + 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 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, 1455, 1, 1455, 1, 1455, 1, 1455, 1, + 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, + 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 1456, 1, 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, 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, 1459, 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, 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, 1465, 1, 1465, 1, 1466, 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, 1468, 1, 1468, 1, 1469, 1, 1469, 1, 1469, 1, + 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1470, 1, 1470, 1, + 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, + 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, + 1472, 1, 1472, 1, 1472, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, + 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1474, 1, 1474, 1, 1474, 1, + 1474, 1, 1474, 1, 1474, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, + 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1476, 1, 1476, 1, 1476, 1, + 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1477, 1, + 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, + 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, + 1477, 1, 1477, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, + 1478, 1, 1478, 1, 1478, 1, 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, 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, 1482, 1, 1482, 1, 1482, 1, + 1482, 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, 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, 1487, 1, 1487, 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, + 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, + 1490, 1, 1490, 1, 1490, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, + 1491, 1, 1492, 1, 1492, 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, 1493, 1, 1494, 1, 1494, 1, 1494, 1, + 1494, 1, 1494, 1, 1494, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, + 1495, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, + 1496, 1, 1497, 1, 1497, 1, 1497, 1, 1497, 1, 1498, 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, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 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, 1501, 1, 1501, 1, + 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1503, 1, + 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, + 1504, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1506, 1, + 1506, 1, 1506, 1, 1506, 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, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, + 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1509, 1, 1510, 1, 1510, 1, 1510, 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, 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, 1513, 1, 1513, 1, 1513, 1, 1513, 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, 1514, 1, 1514, 1, + 1514, 1, 1514, 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, 1517, 1, 1517, 1, 1517, 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, 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, + 1520, 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, 1523, 1, 1523, 1, + 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, + 1523, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, + 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 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, 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, 1528, 1, 1528, 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, 1531, 1, 1531, 1, 1531, 1, 1531, 1, + 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1532, 1, 1532, 1, 1532, 1, + 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, + 1532, 1, 1532, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, + 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1534, 1, + 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 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, + 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, 1536, 1, 1536, 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, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, + 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1540, 1, 1540, 1, 1540, 1, + 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, + 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, + 1541, 1, 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, 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, 1544, 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, 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, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, + 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1551, 1, 1551, 1, 1551, 1, + 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 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, 1554, 1, 1554, 1, 1554, 1, + 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1555, 1, + 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1556, 1, 1556, 1, + 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, + 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, + 1557, 1, 1557, 1, 1557, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, + 1558, 1, 1558, 1, 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, 1561, 1, + 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, + 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1563, 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, 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, 1567, 1, 1567, 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, 1568, 1, 1568, 1, 1569, 1, 1569, 1, 1569, 1, + 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1570, 1, 1570, 1, + 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 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, 1572, 1, 1572, 1, + 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, + 1572, 1, 1572, 1, 1572, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, + 1573, 1, 1573, 1, 1573, 1, 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, + 1574, 1, 1575, 1, 1575, 1, 1575, 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, + 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, 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, 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, 1583, 1, + 1583, 1, 1583, 1, 1583, 1, 1583, 1, 1583, 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, 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, 1587, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, + 1588, 1, 1588, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, + 1589, 1, 1589, 1, 1589, 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, 1590, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, + 1591, 1, 1592, 1, 1592, 1, 1592, 1, 1592, 1, 1592, 1, 1593, 1, 1593, 1, + 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1593, 1, 1594, 1, 1594, 1, + 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, + 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1596, 1, 1596, 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, 1598, 1, 1598, 1, 1598, 1, 1598, 1, + 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, + 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, + 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, + 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, + 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 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, + 1602, 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, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, + 1604, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1606, 1, 1606, 1, 1606, 1, + 1606, 1, 1606, 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1608, 1, + 1608, 1, 1608, 1, 1608, 1, 1608, 1, 1608, 1, 1609, 1, 1609, 1, 1609, 1, + 1609, 1, 1609, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, + 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 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, 1614, 1, 1614, 1, 1614, 1, 1614, 1, + 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, + 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1615, 1, 1615, 1, + 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, + 1616, 1, 1616, 1, 1616, 1, 1616, 1, 1616, 1, 1617, 1, 1617, 1, 1617, 1, + 1617, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, + 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1619, 1, 1619, 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, 1620, 1, 1620, 1, 1620, 1, + 1620, 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, + 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, + 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, + 1624, 1, 1624, 1, 1624, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, + 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, + 1625, 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1627, 1, 1627, 1, 1627, 1, + 1627, 1, 1627, 1, 1627, 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, + 1628, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, + 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, + 1630, 1, 1630, 1, 1630, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, + 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, + 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, + 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1633, 1, 1633, 1, 1633, 1, + 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 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, 1636, 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, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, + 1638, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, + 1639, 1, 1639, 1, 1639, 1, 1639, 1, 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, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, + 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, + 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1644, 1, 1644, 1, 1644, 1, + 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1645, 1, 1645, 1, 1645, 1, + 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, + 1645, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, + 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1648, 1, 1648, 1, 1648, 1, + 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, + 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1649, 1, 1649, 1, 1649, 1, + 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1650, 1, 1650, 1, + 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, + 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, + 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1652, 1, 1652, 1, + 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1653, 1, + 1653, 1, 1653, 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, 1654, 1, 1654, 1, 1655, 1, + 1655, 1, 1655, 1, 1655, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, + 1656, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, + 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, + 1657, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, + 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, 1659, 1, 1659, 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, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, + 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, + 1662, 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, + 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, + 1664, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, + 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, + 1665, 1, 1665, 1, 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, + 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, 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, + 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, + 1671, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, + 1672, 1, 1672, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, + 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1674, 1, 1674, 1, + 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1675, 1, 1675, 1, 1675, 1, + 1675, 1, 1675, 1, 1675, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, + 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1677, 1, 1677, 1, + 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, + 1677, 1, 1677, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, + 1678, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1680, 1, + 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1681, 1, + 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, + 1681, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1683, 1, 1683, 1, + 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1684, 1, 1684, 1, 1684, 1, + 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1685, 1, 1685, 1, + 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1686, 1, + 1686, 1, 1686, 1, 1686, 1, 1687, 1, 1687, 1, 1687, 1, 1687, 1, 1687, 1, + 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, + 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, + 1688, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, + 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, + 1689, 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, 1692, 1, + 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, + 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1693, 1, 1693, 1, + 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1694, 1, 1694, 1, 1694, 1, + 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, + 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1696, 1, + 1696, 1, 1696, 1, 1696, 1, 1696, 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, 1699, 1, 1699, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, + 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, + 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 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, 1702, 1, 1702, 1, + 1702, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, + 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, + 1703, 1, 1703, 1, 1703, 1, 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, 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, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, + 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1709, 1, 1709, 1, 1709, 1, + 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1710, 1, 1710, 1, 1710, 1, + 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, + 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, + 1710, 1, 1710, 1, 1710, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, + 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, + 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, + 1711, 1, 1711, 1, 1711, 1, 1711, 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, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, + 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1715, 1, + 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1716, 1, 1716, 1, + 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, + 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, + 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, + 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, + 1719, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, + 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, + 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, + 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 3, 1722, 23376, 8, 1722, 1, 1723, + 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, + 1, 1723, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1724, + 1, 1724, 1, 1724, 1, 1724, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, + 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, 1, 1725, + 1, 1725, 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, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1728, 1, 1728, + 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, + 1, 1728, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, + 1, 1729, 1, 1729, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, + 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, + 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, + 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 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, 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, 1735, 1, 1735, 1, 1735, + 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, + 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, + 1, 1735, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1737, + 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1738, + 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1739, + 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, + 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1740, 1, 1740, 1, 1740, 1, 1740, + 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, + 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1741, 1, 1741, + 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, + 1, 1741, 1, 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, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, + 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, + 1, 1745, 1, 1745, 1, 1745, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, + 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, + 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1747, + 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, + 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 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, 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, 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, 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, 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, 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, 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, 1762, 1, 1762, 1, 1762, + 1, 1762, 1, 1762, 1, 1762, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, + 1, 1763, 1, 1763, 1, 1763, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, + 1, 1764, 1, 1764, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, + 1, 1765, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, + 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, + 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1769, 1, 1769, 1, 1769, 1, 1769, + 1, 1769, 1, 1769, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, + 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1771, 1, 1771, 1, 1771, 1, 1771, + 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, + 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, + 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, + 1, 1772, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, + 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 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, 1776, + 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, + 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, + 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, + 1, 1777, 1, 1777, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, + 1, 1778, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, + 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1780, + 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1781, + 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 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, 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, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, + 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1789, + 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1790, + 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, + 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, + 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, + 1, 1791, 1, 1791, 1, 1791, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, + 1, 1792, 1, 1792, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, + 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1794, 1, 1794, + 1, 1794, 1, 1794, 1, 1794, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, + 1, 1795, 1, 1795, 1, 1795, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1797, + 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1798, 1, 1798, + 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, + 1, 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, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1802, 1, 1802, + 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, + 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, + 1, 1802, 1, 1802, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, + 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, + 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 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, 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, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, + 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1808, 1, 1808, + 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 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, 1809, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, + 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, + 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1811, 1, 1811, 1, 1811, 1, 1811, + 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, + 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 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, 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, 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, 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, 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, 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, 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, 1821, + 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, + 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1822, 1, 1822, + 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, + 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 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, 1824, 1, 1824, 1, 1824, 1, 1824, + 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, + 1, 1824, 1, 1824, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, + 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, + 1, 1825, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, + 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, + 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1827, 1, 1827, 1, 1827, 1, 1827, + 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, + 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 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, 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, 1832, 1, 1832, 1, 1832, + 1, 1832, 1, 1832, 1, 1832, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, + 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, + 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1834, 1, 1834, + 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, + 1, 1834, 1, 1834, 1, 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, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, + 1, 1837, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, + 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, + 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, + 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1840, + 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, + 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 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, 1843, 1, 1843, 1, 1843, 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, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, + 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, + 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, + 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1846, 1, 1846, 1, 1846, 1, 1846, + 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, + 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 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, 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, 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, 1854, 1, 1854, + 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, + 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1855, 1, 1855, + 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, + 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1856, 1, 1856, 1, 1856, 1, 1856, + 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, + 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1857, 1, 1857, + 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, + 1, 1857, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, + 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, + 1, 1858, 1, 1858, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, + 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, + 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 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, 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, 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, 1864, 1, 1864, 1, 1864, 1, 1864, + 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, + 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, + 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, + 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, + 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 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, 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, 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, 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, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, + 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1874, 1, 1874, + 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, + 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, + 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1875, + 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, + 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, + 1, 1875, 1, 1875, 1, 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, 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, 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, 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, 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, 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, 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, 1886, 1, 1886, 1, 1886, + 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, + 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, + 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1888, + 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, + 1, 1888, 1, 1888, 1, 1888, 1, 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, 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, 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, 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, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1895, 1, 1895, 1, 1895, + 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, + 1, 1895, 1, 1895, 1, 1895, 1, 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, 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, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, + 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, + 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, + 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, + 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, + 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 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, 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, 1903, + 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, + 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1905, 1, 1905, 1, 1905, + 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, + 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, + 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 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, 1907, 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, 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, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, + 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, + 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, + 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 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, 1916, 1, 1916, + 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, + 1, 1916, 1, 1916, 1, 1916, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, + 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, + 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1918, 1, 1918, 1, 1918, + 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, + 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1919, 1, 1919, + 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, + 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1920, 1, 1920, 1, 1920, 1, 1920, + 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, + 1, 1920, 1, 1920, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, + 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1922, + 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, + 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1923, 1, 1923, 1, 1923, + 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, + 1, 1923, 1, 1923, 1, 1923, 1, 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, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, + 1, 1925, 1, 1925, 1, 1925, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, + 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, + 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, + 1, 1926, 1, 1926, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, + 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, + 1, 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, 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, 1930, 1, 1930, 1, 1931, + 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, + 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1932, 1, 1932, + 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, + 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 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, 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, 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, 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, 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, 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, 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, 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, 1943, 1, 1943, 1, 1943, 1, 1943, + 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, + 1, 1943, 1, 1943, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, + 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, + 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, + 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1946, 1, 1946, + 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, + 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1947, 1, 1947, 1, 1947, + 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, + 1, 1947, 1, 1947, 1, 1947, 1, 1947, 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, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, + 1, 1950, 1, 1950, 1, 1950, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, + 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, + 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, + 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 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, 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, 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, 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, 1957, 1, 1957, 1, 1957, 1, 1957, + 1, 1957, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, + 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, + 1, 1958, 1, 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, 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, 1960, 1, 1960, + 1, 1960, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, + 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, + 1, 1961, 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 1982, 1, 1982, + 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1983, 1, 1983, 1, 1983, 1, 1983, + 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1984, 1, 1984, + 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, + 1, 1984, 1, 1984, 1, 1984, 1, 1985, 1, 1985, 1, 1985, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, + 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, + 1, 2002, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, + 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 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, 2005, + 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, + 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2006, 1, 2006, 1, 2006, 1, 2006, + 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, + 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2007, 1, 2007, 1, 2007, 1, 2007, + 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 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, 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, 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, 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, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, + 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, + 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, + 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 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, 2015, + 1, 2015, 1, 2015, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, + 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, + 1, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2074, 1, 2074, + 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, + 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2075, 1, 2075, + 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, + 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2076, + 1, 2076, 1, 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, 2077, 1, 2077, 1, 2078, 1, 2078, 1, 2078, 1, 2078, + 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, + 1, 2078, 1, 2078, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, + 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 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, 2081, + 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, 2084, 1, 2084, 1, 2084, 1, 2084, + 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, 2087, 1, 2087, + 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, + 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2088, 1, 2088, 1, 2088, + 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 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, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2091, 1, 2091, + 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, + 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, + 1, 2092, 1, 2092, 1, 2092, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, + 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2094, 1, 2094, + 1, 2094, 1, 2094, 1, 2094, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2095, + 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, + 1, 2096, 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2098, 1, 2098, + 1, 2098, 1, 2098, 1, 2098, 1, 2099, 1, 2099, 1, 2099, 1, 2099, 1, 2100, + 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2101, 1, 2101, 1, 2101, + 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2102, 1, 2102, 1, 2102, 1, 2102, + 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2103, 1, 2103, 1, 2103, 1, 2103, + 1, 2103, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2105, 1, 2105, + 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, + 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 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, 2109, 1, 2109, 1, 2109, 1, 2109, 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, 2111, 1, 2111, 1, 2111, + 1, 2111, 1, 2111, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, + 1, 2112, 1, 2112, 1, 2112, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, + 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, + 1, 2113, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, + 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 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, 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, 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, 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, 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, 2123, 1, 2123, + 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2124, + 1, 2124, 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, 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, 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, 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, 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, 2131, 1, 2131, 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, 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, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, + 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, + 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 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, 2137, 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, 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, 2141, 1, 2141, + 1, 2141, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2143, + 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2144, + 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, + 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, + 1, 2145, 1, 2146, 1, 2146, 1, 2146, 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, 2147, 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, 2149, 1, 2149, 1, 2149, 1, 2149, + 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, + 1, 2149, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, + 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 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, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, + 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2154, + 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 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, 2156, 1, 2156, 1, 2157, 1, 2157, + 1, 2157, 1, 2157, 1, 2157, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, + 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2159, 1, 2159, 1, 2159, 1, 2159, + 1, 2159, 1, 2159, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, + 1, 2160, 1, 2160, 1, 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, 2163, + 1, 2163, 1, 2163, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2164, + 1, 2165, 1, 2165, 1, 2165, 1, 2165, 1, 2165, 1, 2166, 1, 2166, 1, 2166, + 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2167, + 1, 2167, 1, 2167, 1, 2167, 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2169, + 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, 2172, 1, 2172, 1, 2172, 1, 2172, + 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2173, + 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, + 1, 2173, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, + 1, 2174, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 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, 2177, 1, 2177, 1, 2177, + 1, 2177, 1, 2177, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, + 1, 2178, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, 1, 2179, + 1, 2179, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2181, + 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, + 1, 2181, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, + 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2184, + 1, 2184, 1, 2184, 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, 2187, + 1, 2187, 1, 2187, 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, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, + 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 1, 2188, 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, 2189, + 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, + 1, 2189, 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, 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, 2193, 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, 2195, 1, 2195, 1, 2195, 1, 2195, + 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, 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, 2197, 1, 2197, + 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, + 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 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, 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, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, + 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, + 1, 2204, 1, 2204, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, + 1, 2205, 1, 2205, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, + 1, 2206, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, + 1, 2207, 1, 2207, 1, 2207, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, + 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2209, + 1, 2209, 1, 2209, 1, 2209, 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, 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, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, + 1, 2213, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, + 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2216, 1, 2216, + 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2217, + 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, + 1, 2217, 1, 2217, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, + 1, 2218, 1, 2218, 1, 2218, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, + 1, 2219, 1, 2219, 1, 2219, 1, 2219, 1, 2219, 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, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, + 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, + 1, 2220, 1, 2220, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, + 1, 2221, 1, 2221, 1, 2221, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, + 1, 2222, 1, 2222, 1, 2222, 1, 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, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, + 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2224, + 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, + 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 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, 2226, 1, 2226, 1, 2226, + 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2227, 1, 2227, 1, 2227, 1, 2227, + 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, + 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2228, 1, 2228, + 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, + 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, + 1, 2228, 1, 2228, 1, 2228, 1, 2229, 1, 2229, 1, 2229, 1, 2229, 1, 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, 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, 2233, 1, 2233, 1, 2233, 1, 2233, + 1, 2233, 1, 2233, 1, 2233, 1, 2233, 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, 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, 2235, 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, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, + 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, + 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2239, 1, 2239, 1, 2239, + 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, + 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 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, 2241, 1, 2241, 1, 2241, + 1, 2241, 1, 2241, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, + 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, + 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2243, 1, 2243, 1, 2243, + 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, + 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 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, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, + 1, 2246, 1, 2246, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, + 1, 2247, 1, 2247, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, + 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2250, 1, 2250, 1, 2250, + 1, 2251, 1, 2251, 1, 2251, 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2252, + 1, 2252, 1, 2252, 1, 2252, 1, 2252, 1, 2253, 1, 2253, 1, 2253, 1, 2253, + 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, + 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, + 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, + 1, 2254, 1, 2254, 1, 2254, 1, 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, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2258, + 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, + 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, + 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, 1, 2260, + 1, 2260, 1, 2261, 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, 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, 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, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, + 1, 2267, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, + 1, 2268, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, + 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, + 1, 2269, 1, 2269, 1, 2269, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, + 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 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, 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, 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, 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, 2276, 1, 2276, 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, 2277, 1, 2277, + 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2278, + 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, + 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, + 1, 2279, 1, 2279, 1, 2279, 1, 2279, 1, 2279, 1, 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, 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, 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, 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, 2286, 1, 2286, 1, 2287, 1, 2287, 1, 2287, + 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2288, 1, 2288, 1, 2288, + 1, 2288, 1, 2288, 1, 2288, 1, 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, 2291, + 1, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2292, 1, 2292, 1, 2292, + 1, 2292, 1, 2292, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2293, + 1, 2293, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2294, + 1, 2294, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2295, 1, 2296, + 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2297, 1, 2297, 1, 2297, 1, 2297, + 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2298, + 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, + 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2300, 1, 2300, 1, 2300, + 1, 2300, 1, 2300, 1, 2300, 1, 2301, 1, 2301, 1, 2301, 1, 2301, 1, 2301, + 1, 2301, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, + 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2303, 1, 2303, 1, 2303, 1, 2303, + 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, + 1, 2303, 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, 2306, 1, 2306, 1, 2306, 1, 2306, 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, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2309, 1, 2309, 1, 2309, + 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2310, 1, 2310, + 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 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, 2313, 1, 2313, 1, 2313, 1, 2313, + 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, + 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, + 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, 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, 2318, + 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2319, 1, 2319, + 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, + 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2320, 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, 2322, 1, 2322, 1, 2322, + 1, 2322, 1, 2322, 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, 2323, 1, 2323, 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, 2326, + 1, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 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, 2327, 1, 2327, 1, 2327, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, + 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2329, 1, 2329, + 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, + 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, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, + 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, + 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, + 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2333, 1, 2333, + 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 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, 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, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, + 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 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, 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, 2341, 1, 2341, 1, 2341, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, + 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2343, 1, 2343, 1, 2343, 1, 2343, + 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2344, 1, 2344, 1, 2344, 1, 2344, + 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2345, 1, 2345, + 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 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, 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, 2348, 1, 2348, 1, 2348, 1, 2348, + 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2349, 1, 2349, 1, 2349, 1, 2349, + 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, + 1, 2349, 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, 2352, 1, 2352, 1, 2352, + 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, + 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, + 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 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, 2356, 1, 2356, 1, 2356, + 1, 2356, 1, 2356, 1, 2356, 1, 2357, 1, 2357, 1, 2357, 1, 2357, 1, 2357, + 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, + 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 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, 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, 2361, + 1, 2361, 1, 2361, 1, 2361, 1, 2362, 1, 2362, 1, 2362, 1, 2362, 1, 2362, + 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2364, 1, 2364, + 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, 1, 2364, + 1, 2364, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, + 1, 2365, 1, 2365, 1, 2365, 1, 2365, 1, 2365, 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, 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, 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, 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, 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, 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, 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, 2374, 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, 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, 2378, 1, 2378, 1, 2379, + 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, 1, 2379, + 1, 2379, 1, 2379, 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, 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, 2382, + 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, 2382, 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, 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, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, 1, 2389, + 1, 2389, 1, 2389, 1, 2390, 1, 2390, 1, 2390, 1, 2390, 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, 2391, 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, 2393, 1, 2393, 1, 2394, 1, 2394, 1, 2394, 1, 2394, + 1, 2394, 1, 2394, 1, 2394, 1, 2394, 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, 2395, 1, 2395, 1, 2395, 1, 2396, 1, 2396, 1, 2396, 1, 2396, + 1, 2396, 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, 2399, 1, 2399, + 1, 2399, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, 1, 2400, + 1, 2401, 1, 2401, 1, 2401, 1, 2401, 1, 2402, 1, 2402, 1, 2402, 1, 2402, + 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2402, 1, 2403, 1, 2403, 1, 2403, + 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, + 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2403, 1, 2404, 1, 2404, + 1, 2404, 1, 2404, 1, 2404, 1, 2405, 1, 2405, 1, 2405, 1, 2405, 1, 2406, + 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2406, 1, 2407, 1, 2407, + 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, 1, 2407, + 1, 2407, 1, 2407, 1, 2408, 1, 2408, 1, 2408, 1, 2408, 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, 2411, 1, 2411, + 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, 1, 2411, + 1, 2412, 1, 2412, 1, 2412, 1, 2412, 1, 2412, 1, 2412, 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, 2414, 1, 2414, 1, 2414, 1, 2414, 1, 2414, 1, 2415, + 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, 2417, 1, 2417, + 1, 2417, 1, 2417, 1, 2417, 1, 2418, 1, 2418, 1, 2418, 1, 2418, 1, 2419, + 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2419, 1, 2420, 1, 2420, + 1, 2420, 1, 2420, 1, 2420, 1, 2421, 1, 2421, 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, 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, 2424, 1, 2424, 1, 2425, 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, 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, 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, 2430, 1, 2430, 1, 2430, 1, 2430, 1, 2430, 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, 2431, 1, 2431, 1, 2431, 1, 2431, 1, 2431, + 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2433, + 1, 2433, 1, 2433, 1, 2433, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, + 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2434, 1, 2435, 1, 2435, 1, 2435, + 1, 2435, 1, 2435, 1, 2435, 5, 2435, 32038, 8, 2435, 10, 2435, 12, 2435, + 32041, 9, 2435, 1, 2435, 1, 2435, 1, 2436, 1, 2436, 1, 2436, 5, 2436, 32048, + 8, 2436, 10, 2436, 12, 2436, 32051, 9, 2436, 1, 2436, 4, 2436, 32054, 8, + 2436, 11, 2436, 12, 2436, 32055, 1, 2437, 1, 2437, 1, 2437, 3, 2437, 32061, + 8, 2437, 1, 2437, 1, 2437, 5, 2437, 32065, 8, 2437, 10, 2437, 12, 2437, + 32068, 9, 2437, 1, 2437, 4, 2437, 32071, 8, 2437, 11, 2437, 12, 2437, 32072, + 1, 2438, 1, 2438, 1, 2438, 1, 2439, 1, 2439, 1, 2440, 4, 2440, 32081, 8, + 2440, 11, 2440, 12, 2440, 32082, 1, 2441, 1, 2441, 1, 2441, 3, 2441, 32088, + 8, 2441, 1, 2441, 1, 2441, 4, 2441, 32092, 8, 2441, 11, 2441, 12, 2441, + 32093, 3, 2441, 32096, 8, 2441, 3, 2441, 32098, 8, 2441, 1, 2441, 3, 2441, + 32101, 8, 2441, 1, 2442, 1, 2442, 1, 2442, 1, 2442, 1, 2442, 5, 2442, 32108, + 8, 2442, 10, 2442, 12, 2442, 32111, 9, 2442, 1, 2442, 1, 2442, 1, 2443, + 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, 1, 2443, + 1, 2443, 1, 2443, 1, 2443, 1, 2443, 3, 2443, 32128, 8, 2443, 1, 2443, 1, + 2443, 1, 2443, 1, 2443, 1, 2444, 1, 2444, 5, 2444, 32136, 8, 2444, 10, + 2444, 12, 2444, 32139, 9, 2444, 1, 2444, 1, 2444, 1, 2445, 1, 2445, 5, + 2445, 32145, 8, 2445, 10, 2445, 12, 2445, 32148, 9, 2445, 1, 2445, 1, 2445, + 1, 2446, 1, 2446, 5, 2446, 32154, 8, 2446, 10, 2446, 12, 2446, 32157, 9, + 2446, 1, 2446, 1, 2446, 1, 2447, 1, 2447, 5, 2447, 32163, 8, 2447, 10, + 2447, 12, 2447, 32166, 9, 2447, 1, 2447, 1, 2447, 1, 2448, 1, 2448, 5, + 2448, 32172, 8, 2448, 10, 2448, 12, 2448, 32175, 9, 2448, 1, 2448, 1, 2448, + 1, 2449, 1, 2449, 5, 2449, 32181, 8, 2449, 10, 2449, 12, 2449, 32184, 9, + 2449, 1, 2449, 1, 2449, 1, 2450, 1, 2450, 5, 2450, 32190, 8, 2450, 10, + 2450, 12, 2450, 32193, 9, 2450, 1, 2450, 1, 2450, 1, 2451, 1, 2451, 5, + 2451, 32199, 8, 2451, 10, 2451, 12, 2451, 32202, 9, 2451, 1, 2451, 1, 2451, + 1, 2452, 1, 2452, 5, 2452, 32208, 8, 2452, 10, 2452, 12, 2452, 32211, 9, + 2452, 1, 2452, 1, 2452, 1, 2453, 1, 2453, 5, 2453, 32217, 8, 2453, 10, + 2453, 12, 2453, 32220, 9, 2453, 1, 2453, 1, 2453, 1, 2454, 1, 2454, 5, + 2454, 32226, 8, 2454, 10, 2454, 12, 2454, 32229, 9, 2454, 1, 2454, 1, 2454, + 1, 2455, 1, 2455, 1, 2455, 1, 2455, 4, 2455, 32237, 8, 2455, 11, 2455, + 12, 2455, 32238, 1, 2455, 1, 2455, 1, 2456, 1, 2456, 1, 2457, 1, 2457, + 1, 2458, 1, 2458, 1, 2459, 1, 2459, 1, 2460, 1, 2460, 1, 2460, 1, 2461, + 1, 2461, 1, 2462, 1, 2462, 1, 2463, 1, 2463, 1, 2464, 1, 2464, 1, 2465, + 1, 2465, 1, 2466, 1, 2466, 1, 2467, 1, 2467, 1, 2468, 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, 2473, 1, 2473, 5, 2473, 32283, 8, 2473, 10, 2473, + 12, 2473, 32286, 9, 2473, 1, 2473, 1, 2473, 1, 2473, 1, 2473, 1, 2473, + 3, 2473, 32293, 8, 2473, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, 2474, 1, + 2474, 1, 2474, 1, 2474, 3, 2474, 32303, 8, 2474, 1, 2475, 1, 2475, 1, 2476, + 1, 2476, 1, 2477, 1, 2477, 1, 2478, 1, 2478, 1, 2479, 1, 2479, 1, 2480, + 1, 2480, 1, 2481, 1, 2481, 1, 2482, 1, 2482, 1, 2483, 1, 2483, 1, 2484, + 1, 2484, 1, 2485, 1, 2485, 1, 2486, 1, 2486, 1, 2487, 1, 2487, 1, 2487, + 1, 2487, 5, 2487, 32333, 8, 2487, 10, 2487, 12, 2487, 32336, 9, 2487, 1, + 2487, 1, 2487, 1, 2487, 1, 2487, 1, 2488, 1, 2488, 1, 2488, 1, 2488, 5, + 2488, 32346, 8, 2488, 10, 2488, 12, 2488, 32349, 9, 2488, 1, 2488, 1, 2488, + 1, 2488, 1, 2488, 1, 2488, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, + 1, 2489, 1, 2489, 1, 2489, 3, 2489, 32364, 8, 2489, 1, 2489, 1, 2489, 5, + 2489, 32368, 8, 2489, 10, 2489, 12, 2489, 32371, 9, 2489, 3, 2489, 32373, + 8, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2489, 1, 2490, 1, 2490, 1, 2490, + 1, 2490, 1, 2490, 1, 2490, 1, 2490, 1, 2490, 3, 2490, 32387, 8, 2490, 1, + 2490, 1, 2490, 5, 2490, 32391, 8, 2490, 10, 2490, 12, 2490, 32394, 9, 2490, + 3, 2490, 32396, 8, 2490, 1, 2490, 1, 2490, 1, 2491, 1, 2491, 1, 2491, 5, + 2491, 32403, 8, 2491, 10, 2491, 12, 2491, 32406, 9, 2491, 1, 2492, 1, 2492, + 1, 2492, 1, 2492, 1, 2492, 4, 2492, 32413, 8, 2492, 11, 2492, 12, 2492, + 32414, 1, 2493, 4, 2493, 32418, 8, 2493, 11, 2493, 12, 2493, 32419, 1, + 2493, 1, 2493, 1, 2494, 1, 2494, 3, 2494, 32426, 8, 2494, 1, 2495, 1, 2495, + 1, 2496, 1, 2496, 1, 2497, 5, 2497, 32433, 8, 2497, 10, 2497, 12, 2497, + 32436, 9, 2497, 1, 2497, 3, 2497, 32439, 8, 2497, 1, 2497, 4, 2497, 32442, + 8, 2497, 11, 2497, 12, 2497, 32443, 1, 2498, 3, 2498, 32447, 8, 2498, 1, + 2498, 1, 2498, 1, 2499, 1, 2499, 12, 32137, 32146, 32155, 32164, 32173, + 32182, 32191, 32200, 32209, 32218, 32227, 32347, 0, 2500, 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, 0, 4889, 0, 4891, 0, 4893, 0, 4895, 0, 4897, 0, + 4899, 0, 4901, 0, 4903, 0, 4905, 0, 4907, 0, 4909, 0, 4911, 2444, 4913, + 2445, 4915, 2446, 4917, 2447, 4919, 2448, 4921, 2449, 4923, 2450, 4925, + 2451, 4927, 2452, 4929, 2453, 4931, 2454, 4933, 2455, 4935, 2456, 4937, + 2457, 4939, 2458, 4941, 2459, 4943, 2460, 4945, 2461, 4947, 2462, 4949, + 2463, 4951, 2464, 4953, 2465, 4955, 2466, 4957, 2467, 4959, 2468, 4961, + 2469, 4963, 2470, 4965, 2471, 4967, 2472, 4969, 2473, 4971, 2474, 4973, + 2475, 4975, 2476, 4977, 2477, 4979, 2478, 4981, 2479, 4983, 2480, 4985, + 2481, 4987, 2482, 4989, 0, 4991, 0, 4993, 0, 4995, 0, 4997, 0, 4999, 0, + 1, 0, 39, 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, 2, 0, 0, + 0, 34, 34, 2, 0, 48, 57, 95, 95, 2, 0, 10, 10, 13, 13, 3, 0, 35, 36, 48, + 57, 95, 95, 3, 0, 9, 10, 13, 13, 32, 32, 659, 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, 7304, 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, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 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, 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, 69248, 69289, + 69296, 69297, 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, 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, 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, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, + 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, + 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, + 94208, 100343, 100352, 101589, 101632, 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, 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, 194560, 195101, 196608, 201546, 201552, 205743, 2, 0, 9, + 9, 32, 32, 32513, 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, 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, 0, 4971, 1, 0, 0, 0, 0, 4973, 1, 0, 0, 0, 0, 4975, + 1, 0, 0, 0, 0, 4977, 1, 0, 0, 0, 0, 4979, 1, 0, 0, 0, 0, 4981, 1, 0, 0, + 0, 0, 4983, 1, 0, 0, 0, 0, 4985, 1, 0, 0, 0, 0, 4987, 1, 0, 0, 0, 1, 5001, + 1, 0, 0, 0, 3, 5007, 1, 0, 0, 0, 5, 5011, 1, 0, 0, 0, 7, 5018, 1, 0, 0, + 0, 9, 5025, 1, 0, 0, 0, 11, 5034, 1, 0, 0, 0, 13, 5045, 1, 0, 0, 0, 15, + 5053, 1, 0, 0, 0, 17, 5057, 1, 0, 0, 0, 19, 5062, 1, 0, 0, 0, 21, 5069, + 1, 0, 0, 0, 23, 5076, 1, 0, 0, 0, 25, 5084, 1, 0, 0, 0, 27, 5093, 1, 0, + 0, 0, 29, 5100, 1, 0, 0, 0, 31, 5117, 1, 0, 0, 0, 33, 5129, 1, 0, 0, 0, + 35, 5145, 1, 0, 0, 0, 37, 5156, 1, 0, 0, 0, 39, 5165, 1, 0, 0, 0, 41, 5179, + 1, 0, 0, 0, 43, 5183, 1, 0, 0, 0, 45, 5194, 1, 0, 0, 0, 47, 5204, 1, 0, + 0, 0, 49, 5215, 1, 0, 0, 0, 51, 5224, 1, 0, 0, 0, 53, 5230, 1, 0, 0, 0, + 55, 5241, 1, 0, 0, 0, 57, 5255, 1, 0, 0, 0, 59, 5264, 1, 0, 0, 0, 61, 5271, + 1, 0, 0, 0, 63, 5279, 1, 0, 0, 0, 65, 5294, 1, 0, 0, 0, 67, 5300, 1, 0, + 0, 0, 69, 5306, 1, 0, 0, 0, 71, 5316, 1, 0, 0, 0, 73, 5318, 1, 0, 0, 0, + 75, 5324, 1, 0, 0, 0, 77, 5328, 1, 0, 0, 0, 79, 5337, 1, 0, 0, 0, 81, 5343, + 1, 0, 0, 0, 83, 5352, 1, 0, 0, 0, 85, 5358, 1, 0, 0, 0, 87, 5368, 1, 0, + 0, 0, 89, 5375, 1, 0, 0, 0, 91, 5384, 1, 0, 0, 0, 93, 5392, 1, 0, 0, 0, + 95, 5401, 1, 0, 0, 0, 97, 5411, 1, 0, 0, 0, 99, 5415, 1, 0, 0, 0, 101, + 5425, 1, 0, 0, 0, 103, 5437, 1, 0, 0, 0, 105, 5445, 1, 0, 0, 0, 107, 5457, + 1, 0, 0, 0, 109, 5466, 1, 0, 0, 0, 111, 5470, 1, 0, 0, 0, 113, 5480, 1, + 0, 0, 0, 115, 5487, 1, 0, 0, 0, 117, 5502, 1, 0, 0, 0, 119, 5516, 1, 0, + 0, 0, 121, 5528, 1, 0, 0, 0, 123, 5534, 1, 0, 0, 0, 125, 5556, 1, 0, 0, + 0, 127, 5565, 1, 0, 0, 0, 129, 5573, 1, 0, 0, 0, 131, 5582, 1, 0, 0, 0, + 133, 5593, 1, 0, 0, 0, 135, 5597, 1, 0, 0, 0, 137, 5603, 1, 0, 0, 0, 139, + 5606, 1, 0, 0, 0, 141, 5610, 1, 0, 0, 0, 143, 5616, 1, 0, 0, 0, 145, 5625, + 1, 0, 0, 0, 147, 5630, 1, 0, 0, 0, 149, 5635, 1, 0, 0, 0, 151, 5644, 1, + 0, 0, 0, 153, 5651, 1, 0, 0, 0, 155, 5661, 1, 0, 0, 0, 157, 5667, 1, 0, + 0, 0, 159, 5680, 1, 0, 0, 0, 161, 5686, 1, 0, 0, 0, 163, 5691, 1, 0, 0, + 0, 165, 5694, 1, 0, 0, 0, 167, 5704, 1, 0, 0, 0, 169, 5715, 1, 0, 0, 0, + 171, 5721, 1, 0, 0, 0, 173, 5735, 1, 0, 0, 0, 175, 5750, 1, 0, 0, 0, 177, + 5757, 1, 0, 0, 0, 179, 5771, 1, 0, 0, 0, 181, 5784, 1, 0, 0, 0, 183, 5789, + 1, 0, 0, 0, 185, 5800, 1, 0, 0, 0, 187, 5811, 1, 0, 0, 0, 189, 5822, 1, + 0, 0, 0, 191, 5832, 1, 0, 0, 0, 193, 5855, 1, 0, 0, 0, 195, 5871, 1, 0, + 0, 0, 197, 5884, 1, 0, 0, 0, 199, 5889, 1, 0, 0, 0, 201, 5900, 1, 0, 0, + 0, 203, 5912, 1, 0, 0, 0, 205, 5919, 1, 0, 0, 0, 207, 5927, 1, 0, 0, 0, + 209, 5937, 1, 0, 0, 0, 211, 5945, 1, 0, 0, 0, 213, 5951, 1, 0, 0, 0, 215, + 5961, 1, 0, 0, 0, 217, 5967, 1, 0, 0, 0, 219, 5977, 1, 0, 0, 0, 221, 6005, + 1, 0, 0, 0, 223, 6012, 1, 0, 0, 0, 225, 6019, 1, 0, 0, 0, 227, 6025, 1, + 0, 0, 0, 229, 6035, 1, 0, 0, 0, 231, 6054, 1, 0, 0, 0, 233, 6061, 1, 0, + 0, 0, 235, 6070, 1, 0, 0, 0, 237, 6078, 1, 0, 0, 0, 239, 6084, 1, 0, 0, + 0, 241, 6094, 1, 0, 0, 0, 243, 6098, 1, 0, 0, 0, 245, 6106, 1, 0, 0, 0, + 247, 6113, 1, 0, 0, 0, 249, 6120, 1, 0, 0, 0, 251, 6134, 1, 0, 0, 0, 253, + 6157, 1, 0, 0, 0, 255, 6175, 1, 0, 0, 0, 257, 6188, 1, 0, 0, 0, 259, 6210, + 1, 0, 0, 0, 261, 6227, 1, 0, 0, 0, 263, 6242, 1, 0, 0, 0, 265, 6253, 1, + 0, 0, 0, 267, 6261, 1, 0, 0, 0, 269, 6272, 1, 0, 0, 0, 271, 6279, 1, 0, + 0, 0, 273, 6290, 1, 0, 0, 0, 275, 6297, 1, 0, 0, 0, 277, 6305, 1, 0, 0, + 0, 279, 6317, 1, 0, 0, 0, 281, 6322, 1, 0, 0, 0, 283, 6329, 1, 0, 0, 0, + 285, 6334, 1, 0, 0, 0, 287, 6340, 1, 0, 0, 0, 289, 6352, 1, 0, 0, 0, 291, + 6359, 1, 0, 0, 0, 293, 6369, 1, 0, 0, 0, 295, 6374, 1, 0, 0, 0, 297, 6382, + 1, 0, 0, 0, 299, 6387, 1, 0, 0, 0, 301, 6393, 1, 0, 0, 0, 303, 6400, 1, + 0, 0, 0, 305, 6408, 1, 0, 0, 0, 307, 6418, 1, 0, 0, 0, 309, 6423, 1, 0, + 0, 0, 311, 6430, 1, 0, 0, 0, 313, 6443, 1, 0, 0, 0, 315, 6455, 1, 0, 0, + 0, 317, 6461, 1, 0, 0, 0, 319, 6466, 1, 0, 0, 0, 321, 6469, 1, 0, 0, 0, + 323, 6492, 1, 0, 0, 0, 325, 6504, 1, 0, 0, 0, 327, 6509, 1, 0, 0, 0, 329, + 6515, 1, 0, 0, 0, 331, 6529, 1, 0, 0, 0, 333, 6535, 1, 0, 0, 0, 335, 6544, + 1, 0, 0, 0, 337, 6560, 1, 0, 0, 0, 339, 6577, 1, 0, 0, 0, 341, 6585, 1, + 0, 0, 0, 343, 6596, 1, 0, 0, 0, 345, 6605, 1, 0, 0, 0, 347, 6610, 1, 0, + 0, 0, 349, 6617, 1, 0, 0, 0, 351, 6627, 1, 0, 0, 0, 353, 6636, 1, 0, 0, + 0, 355, 6644, 1, 0, 0, 0, 357, 6656, 1, 0, 0, 0, 359, 6664, 1, 0, 0, 0, + 361, 6669, 1, 0, 0, 0, 363, 6674, 1, 0, 0, 0, 365, 6689, 1, 0, 0, 0, 367, + 6698, 1, 0, 0, 0, 369, 6710, 1, 0, 0, 0, 371, 6715, 1, 0, 0, 0, 373, 6732, + 1, 0, 0, 0, 375, 6744, 1, 0, 0, 0, 377, 6750, 1, 0, 0, 0, 379, 6758, 1, + 0, 0, 0, 381, 6765, 1, 0, 0, 0, 383, 6780, 1, 0, 0, 0, 385, 6806, 1, 0, + 0, 0, 387, 6816, 1, 0, 0, 0, 389, 6827, 1, 0, 0, 0, 391, 6840, 1, 0, 0, + 0, 393, 6845, 1, 0, 0, 0, 395, 6853, 1, 0, 0, 0, 397, 6865, 1, 0, 0, 0, + 399, 6883, 1, 0, 0, 0, 401, 6889, 1, 0, 0, 0, 403, 6900, 1, 0, 0, 0, 405, + 6906, 1, 0, 0, 0, 407, 6913, 1, 0, 0, 0, 409, 6917, 1, 0, 0, 0, 411, 6923, + 1, 0, 0, 0, 413, 6929, 1, 0, 0, 0, 415, 6944, 1, 0, 0, 0, 417, 6955, 1, + 0, 0, 0, 419, 6962, 1, 0, 0, 0, 421, 6968, 1, 0, 0, 0, 423, 6976, 1, 0, + 0, 0, 425, 6982, 1, 0, 0, 0, 427, 6984, 1, 0, 0, 0, 429, 6991, 1, 0, 0, + 0, 431, 6996, 1, 0, 0, 0, 433, 7002, 1, 0, 0, 0, 435, 7028, 1, 0, 0, 0, + 437, 7034, 1, 0, 0, 0, 439, 7051, 1, 0, 0, 0, 441, 7059, 1, 0, 0, 0, 443, + 7075, 1, 0, 0, 0, 445, 7092, 1, 0, 0, 0, 447, 7103, 1, 0, 0, 0, 449, 7114, + 1, 0, 0, 0, 451, 7132, 1, 0, 0, 0, 453, 7152, 1, 0, 0, 0, 455, 7164, 1, + 0, 0, 0, 457, 7173, 1, 0, 0, 0, 459, 7185, 1, 0, 0, 0, 461, 7192, 1, 0, + 0, 0, 463, 7204, 1, 0, 0, 0, 465, 7209, 1, 0, 0, 0, 467, 7217, 1, 0, 0, + 0, 469, 7228, 1, 0, 0, 0, 471, 7237, 1, 0, 0, 0, 473, 7259, 1, 0, 0, 0, + 475, 7266, 1, 0, 0, 0, 477, 7274, 1, 0, 0, 0, 479, 7287, 1, 0, 0, 0, 481, + 7300, 1, 0, 0, 0, 483, 7308, 1, 0, 0, 0, 485, 7315, 1, 0, 0, 0, 487, 7325, + 1, 0, 0, 0, 489, 7332, 1, 0, 0, 0, 491, 7344, 1, 0, 0, 0, 493, 7352, 1, + 0, 0, 0, 495, 7363, 1, 0, 0, 0, 497, 7377, 1, 0, 0, 0, 499, 7385, 1, 0, + 0, 0, 501, 7394, 1, 0, 0, 0, 503, 7405, 1, 0, 0, 0, 505, 7415, 1, 0, 0, + 0, 507, 7426, 1, 0, 0, 0, 509, 7434, 1, 0, 0, 0, 511, 7444, 1, 0, 0, 0, + 513, 7460, 1, 0, 0, 0, 515, 7469, 1, 0, 0, 0, 517, 7478, 1, 0, 0, 0, 519, + 7490, 1, 0, 0, 0, 521, 7498, 1, 0, 0, 0, 523, 7510, 1, 0, 0, 0, 525, 7517, + 1, 0, 0, 0, 527, 7528, 1, 0, 0, 0, 529, 7543, 1, 0, 0, 0, 531, 7555, 1, + 0, 0, 0, 533, 7565, 1, 0, 0, 0, 535, 7573, 1, 0, 0, 0, 537, 7584, 1, 0, + 0, 0, 539, 7599, 1, 0, 0, 0, 541, 7606, 1, 0, 0, 0, 543, 7621, 1, 0, 0, + 0, 545, 7644, 1, 0, 0, 0, 547, 7666, 1, 0, 0, 0, 549, 7688, 1, 0, 0, 0, + 551, 7709, 1, 0, 0, 0, 553, 7730, 1, 0, 0, 0, 555, 7749, 1, 0, 0, 0, 557, + 7767, 1, 0, 0, 0, 559, 7783, 1, 0, 0, 0, 561, 7791, 1, 0, 0, 0, 563, 7804, + 1, 0, 0, 0, 565, 7813, 1, 0, 0, 0, 567, 7824, 1, 0, 0, 0, 569, 7833, 1, + 0, 0, 0, 571, 7839, 1, 0, 0, 0, 573, 7850, 1, 0, 0, 0, 575, 7862, 1, 0, + 0, 0, 577, 7874, 1, 0, 0, 0, 579, 7884, 1, 0, 0, 0, 581, 7895, 1, 0, 0, + 0, 583, 7914, 1, 0, 0, 0, 585, 7929, 1, 0, 0, 0, 587, 7943, 1, 0, 0, 0, + 589, 7951, 1, 0, 0, 0, 591, 7960, 1, 0, 0, 0, 593, 7968, 1, 0, 0, 0, 595, + 7977, 1, 0, 0, 0, 597, 7989, 1, 0, 0, 0, 599, 8003, 1, 0, 0, 0, 601, 8011, + 1, 0, 0, 0, 603, 8022, 1, 0, 0, 0, 605, 8029, 1, 0, 0, 0, 607, 8034, 1, + 0, 0, 0, 609, 8041, 1, 0, 0, 0, 611, 8048, 1, 0, 0, 0, 613, 8059, 1, 0, + 0, 0, 615, 8075, 1, 0, 0, 0, 617, 8087, 1, 0, 0, 0, 619, 8091, 1, 0, 0, + 0, 621, 8096, 1, 0, 0, 0, 623, 8101, 1, 0, 0, 0, 625, 8124, 1, 0, 0, 0, + 627, 8130, 1, 0, 0, 0, 629, 8138, 1, 0, 0, 0, 631, 8148, 1, 0, 0, 0, 633, + 8159, 1, 0, 0, 0, 635, 8171, 1, 0, 0, 0, 637, 8184, 1, 0, 0, 0, 639, 8200, + 1, 0, 0, 0, 641, 8206, 1, 0, 0, 0, 643, 8213, 1, 0, 0, 0, 645, 8230, 1, + 0, 0, 0, 647, 8253, 1, 0, 0, 0, 649, 8262, 1, 0, 0, 0, 651, 8273, 1, 0, + 0, 0, 653, 8282, 1, 0, 0, 0, 655, 8288, 1, 0, 0, 0, 657, 8301, 1, 0, 0, + 0, 659, 8311, 1, 0, 0, 0, 661, 8315, 1, 0, 0, 0, 663, 8323, 1, 0, 0, 0, + 665, 8328, 1, 0, 0, 0, 667, 8336, 1, 0, 0, 0, 669, 8344, 1, 0, 0, 0, 671, + 8355, 1, 0, 0, 0, 673, 8363, 1, 0, 0, 0, 675, 8376, 1, 0, 0, 0, 677, 8391, + 1, 0, 0, 0, 679, 8404, 1, 0, 0, 0, 681, 8422, 1, 0, 0, 0, 683, 8435, 1, + 0, 0, 0, 685, 8444, 1, 0, 0, 0, 687, 8451, 1, 0, 0, 0, 689, 8472, 1, 0, + 0, 0, 691, 8496, 1, 0, 0, 0, 693, 8508, 1, 0, 0, 0, 695, 8511, 1, 0, 0, + 0, 697, 8517, 1, 0, 0, 0, 699, 8526, 1, 0, 0, 0, 701, 8535, 1, 0, 0, 0, + 703, 8540, 1, 0, 0, 0, 705, 8549, 1, 0, 0, 0, 707, 8559, 1, 0, 0, 0, 709, + 8575, 1, 0, 0, 0, 711, 8588, 1, 0, 0, 0, 713, 8598, 1, 0, 0, 0, 715, 8623, + 1, 0, 0, 0, 717, 8644, 1, 0, 0, 0, 719, 8653, 1, 0, 0, 0, 721, 8681, 1, + 0, 0, 0, 723, 8686, 1, 0, 0, 0, 725, 8697, 1, 0, 0, 0, 727, 8709, 1, 0, + 0, 0, 729, 8719, 1, 0, 0, 0, 731, 8723, 1, 0, 0, 0, 733, 8728, 1, 0, 0, + 0, 735, 8742, 1, 0, 0, 0, 737, 8746, 1, 0, 0, 0, 739, 8761, 1, 0, 0, 0, + 741, 8768, 1, 0, 0, 0, 743, 8779, 1, 0, 0, 0, 745, 8794, 1, 0, 0, 0, 747, + 8805, 1, 0, 0, 0, 749, 8820, 1, 0, 0, 0, 751, 8831, 1, 0, 0, 0, 753, 8835, + 1, 0, 0, 0, 755, 8846, 1, 0, 0, 0, 757, 8852, 1, 0, 0, 0, 759, 8861, 1, + 0, 0, 0, 761, 8865, 1, 0, 0, 0, 763, 8873, 1, 0, 0, 0, 765, 8881, 1, 0, + 0, 0, 767, 8891, 1, 0, 0, 0, 769, 8903, 1, 0, 0, 0, 771, 8908, 1, 0, 0, + 0, 773, 8918, 1, 0, 0, 0, 775, 8926, 1, 0, 0, 0, 777, 8938, 1, 0, 0, 0, + 779, 8946, 1, 0, 0, 0, 781, 8956, 1, 0, 0, 0, 783, 8965, 1, 0, 0, 0, 785, + 8983, 1, 0, 0, 0, 787, 9002, 1, 0, 0, 0, 789, 9013, 1, 0, 0, 0, 791, 9022, + 1, 0, 0, 0, 793, 9030, 1, 0, 0, 0, 795, 9037, 1, 0, 0, 0, 797, 9045, 1, + 0, 0, 0, 799, 9052, 1, 0, 0, 0, 801, 9058, 1, 0, 0, 0, 803, 9067, 1, 0, + 0, 0, 805, 9078, 1, 0, 0, 0, 807, 9085, 1, 0, 0, 0, 809, 9095, 1, 0, 0, + 0, 811, 9105, 1, 0, 0, 0, 813, 9112, 1, 0, 0, 0, 815, 9124, 1, 0, 0, 0, + 817, 9134, 1, 0, 0, 0, 819, 9144, 1, 0, 0, 0, 821, 9150, 1, 0, 0, 0, 823, + 9158, 1, 0, 0, 0, 825, 9164, 1, 0, 0, 0, 827, 9181, 1, 0, 0, 0, 829, 9186, + 1, 0, 0, 0, 831, 9198, 1, 0, 0, 0, 833, 9206, 1, 0, 0, 0, 835, 9215, 1, + 0, 0, 0, 837, 9224, 1, 0, 0, 0, 839, 9235, 1, 0, 0, 0, 841, 9249, 1, 0, + 0, 0, 843, 9260, 1, 0, 0, 0, 845, 9270, 1, 0, 0, 0, 847, 9281, 1, 0, 0, + 0, 849, 9290, 1, 0, 0, 0, 851, 9302, 1, 0, 0, 0, 853, 9312, 1, 0, 0, 0, + 855, 9324, 1, 0, 0, 0, 857, 9336, 1, 0, 0, 0, 859, 9344, 1, 0, 0, 0, 861, + 9353, 1, 0, 0, 0, 863, 9382, 1, 0, 0, 0, 865, 9403, 1, 0, 0, 0, 867, 9418, + 1, 0, 0, 0, 869, 9431, 1, 0, 0, 0, 871, 9440, 1, 0, 0, 0, 873, 9453, 1, + 0, 0, 0, 875, 9461, 1, 0, 0, 0, 877, 9473, 1, 0, 0, 0, 879, 9484, 1, 0, + 0, 0, 881, 9489, 1, 0, 0, 0, 883, 9499, 1, 0, 0, 0, 885, 9512, 1, 0, 0, + 0, 887, 9518, 1, 0, 0, 0, 889, 9527, 1, 0, 0, 0, 891, 9536, 1, 0, 0, 0, + 893, 9550, 1, 0, 0, 0, 895, 9562, 1, 0, 0, 0, 897, 9573, 1, 0, 0, 0, 899, + 9577, 1, 0, 0, 0, 901, 9588, 1, 0, 0, 0, 903, 9601, 1, 0, 0, 0, 905, 9613, + 1, 0, 0, 0, 907, 9630, 1, 0, 0, 0, 909, 9642, 1, 0, 0, 0, 911, 9651, 1, + 0, 0, 0, 913, 9657, 1, 0, 0, 0, 915, 9664, 1, 0, 0, 0, 917, 9669, 1, 0, + 0, 0, 919, 9676, 1, 0, 0, 0, 921, 9680, 1, 0, 0, 0, 923, 9686, 1, 0, 0, + 0, 925, 9706, 1, 0, 0, 0, 927, 9727, 1, 0, 0, 0, 929, 9745, 1, 0, 0, 0, + 931, 9752, 1, 0, 0, 0, 933, 9762, 1, 0, 0, 0, 935, 9775, 1, 0, 0, 0, 937, + 9787, 1, 0, 0, 0, 939, 9792, 1, 0, 0, 0, 941, 9803, 1, 0, 0, 0, 943, 9828, + 1, 0, 0, 0, 945, 9852, 1, 0, 0, 0, 947, 9857, 1, 0, 0, 0, 949, 9865, 1, + 0, 0, 0, 951, 9875, 1, 0, 0, 0, 953, 9878, 1, 0, 0, 0, 955, 9886, 1, 0, + 0, 0, 957, 9903, 1, 0, 0, 0, 959, 9928, 1, 0, 0, 0, 961, 9930, 1, 0, 0, + 0, 963, 9935, 1, 0, 0, 0, 965, 9947, 1, 0, 0, 0, 967, 9955, 1, 0, 0, 0, + 969, 9966, 1, 0, 0, 0, 971, 9975, 1, 0, 0, 0, 973, 9983, 1, 0, 0, 0, 975, + 9996, 1, 0, 0, 0, 977, 10011, 1, 0, 0, 0, 979, 10025, 1, 0, 0, 0, 981, + 10046, 1, 0, 0, 0, 983, 10051, 1, 0, 0, 0, 985, 10057, 1, 0, 0, 0, 987, + 10060, 1, 0, 0, 0, 989, 10069, 1, 0, 0, 0, 991, 10080, 1, 0, 0, 0, 993, + 10091, 1, 0, 0, 0, 995, 10097, 1, 0, 0, 0, 997, 10108, 1, 0, 0, 0, 999, + 10115, 1, 0, 0, 0, 1001, 10123, 1, 0, 0, 0, 1003, 10143, 1, 0, 0, 0, 1005, + 10157, 1, 0, 0, 0, 1007, 10166, 1, 0, 0, 0, 1009, 10175, 1, 0, 0, 0, 1011, + 10183, 1, 0, 0, 0, 1013, 10194, 1, 0, 0, 0, 1015, 10216, 1, 0, 0, 0, 1017, + 10220, 1, 0, 0, 0, 1019, 10237, 1, 0, 0, 0, 1021, 10244, 1, 0, 0, 0, 1023, + 10253, 1, 0, 0, 0, 1025, 10261, 1, 0, 0, 0, 1027, 10269, 1, 0, 0, 0, 1029, + 10280, 1, 0, 0, 0, 1031, 10295, 1, 0, 0, 0, 1033, 10301, 1, 0, 0, 0, 1035, + 10310, 1, 0, 0, 0, 1037, 10314, 1, 0, 0, 0, 1039, 10329, 1, 0, 0, 0, 1041, + 10335, 1, 0, 0, 0, 1043, 10357, 1, 0, 0, 0, 1045, 10364, 1, 0, 0, 0, 1047, + 10376, 1, 0, 0, 0, 1049, 10387, 1, 0, 0, 0, 1051, 10394, 1, 0, 0, 0, 1053, + 10402, 1, 0, 0, 0, 1055, 10411, 1, 0, 0, 0, 1057, 10416, 1, 0, 0, 0, 1059, + 10425, 1, 0, 0, 0, 1061, 10434, 1, 0, 0, 0, 1063, 10445, 1, 0, 0, 0, 1065, + 10452, 1, 0, 0, 0, 1067, 10458, 1, 0, 0, 0, 1069, 10465, 1, 0, 0, 0, 1071, + 10475, 1, 0, 0, 0, 1073, 10490, 1, 0, 0, 0, 1075, 10501, 1, 0, 0, 0, 1077, + 10510, 1, 0, 0, 0, 1079, 10518, 1, 0, 0, 0, 1081, 10528, 1, 0, 0, 0, 1083, + 10538, 1, 0, 0, 0, 1085, 10546, 1, 0, 0, 0, 1087, 10553, 1, 0, 0, 0, 1089, + 10562, 1, 0, 0, 0, 1091, 10569, 1, 0, 0, 0, 1093, 10580, 1, 0, 0, 0, 1095, + 10585, 1, 0, 0, 0, 1097, 10606, 1, 0, 0, 0, 1099, 10619, 1, 0, 0, 0, 1101, + 10623, 1, 0, 0, 0, 1103, 10630, 1, 0, 0, 0, 1105, 10638, 1, 0, 0, 0, 1107, + 10648, 1, 0, 0, 0, 1109, 10655, 1, 0, 0, 0, 1111, 10671, 1, 0, 0, 0, 1113, + 10679, 1, 0, 0, 0, 1115, 10687, 1, 0, 0, 0, 1117, 10694, 1, 0, 0, 0, 1119, + 10702, 1, 0, 0, 0, 1121, 10711, 1, 0, 0, 0, 1123, 10722, 1, 0, 0, 0, 1125, + 10737, 1, 0, 0, 0, 1127, 10745, 1, 0, 0, 0, 1129, 10758, 1, 0, 0, 0, 1131, + 10764, 1, 0, 0, 0, 1133, 10773, 1, 0, 0, 0, 1135, 10778, 1, 0, 0, 0, 1137, + 10785, 1, 0, 0, 0, 1139, 10800, 1, 0, 0, 0, 1141, 10807, 1, 0, 0, 0, 1143, + 10829, 1, 0, 0, 0, 1145, 10839, 1, 0, 0, 0, 1147, 10848, 1, 0, 0, 0, 1149, + 10856, 1, 0, 0, 0, 1151, 10862, 1, 0, 0, 0, 1153, 10869, 1, 0, 0, 0, 1155, + 10873, 1, 0, 0, 0, 1157, 10878, 1, 0, 0, 0, 1159, 10888, 1, 0, 0, 0, 1161, + 10896, 1, 0, 0, 0, 1163, 10904, 1, 0, 0, 0, 1165, 10920, 1, 0, 0, 0, 1167, + 10931, 1, 0, 0, 0, 1169, 10943, 1, 0, 0, 0, 1171, 10957, 1, 0, 0, 0, 1173, + 10963, 1, 0, 0, 0, 1175, 10969, 1, 0, 0, 0, 1177, 10976, 1, 0, 0, 0, 1179, + 10981, 1, 0, 0, 0, 1181, 10999, 1, 0, 0, 0, 1183, 11009, 1, 0, 0, 0, 1185, + 11019, 1, 0, 0, 0, 1187, 11043, 1, 0, 0, 0, 1189, 11050, 1, 0, 0, 0, 1191, + 11056, 1, 0, 0, 0, 1193, 11061, 1, 0, 0, 0, 1195, 11068, 1, 0, 0, 0, 1197, + 11074, 1, 0, 0, 0, 1199, 11081, 1, 0, 0, 0, 1201, 11092, 1, 0, 0, 0, 1203, + 11104, 1, 0, 0, 0, 1205, 11110, 1, 0, 0, 0, 1207, 11126, 1, 0, 0, 0, 1209, + 11134, 1, 0, 0, 0, 1211, 11144, 1, 0, 0, 0, 1213, 11156, 1, 0, 0, 0, 1215, + 11162, 1, 0, 0, 0, 1217, 11167, 1, 0, 0, 0, 1219, 11172, 1, 0, 0, 0, 1221, + 11178, 1, 0, 0, 0, 1223, 11184, 1, 0, 0, 0, 1225, 11191, 1, 0, 0, 0, 1227, + 11201, 1, 0, 0, 0, 1229, 11209, 1, 0, 0, 0, 1231, 11216, 1, 0, 0, 0, 1233, + 11222, 1, 0, 0, 0, 1235, 11246, 1, 0, 0, 0, 1237, 11254, 1, 0, 0, 0, 1239, + 11262, 1, 0, 0, 0, 1241, 11266, 1, 0, 0, 0, 1243, 11273, 1, 0, 0, 0, 1245, + 11281, 1, 0, 0, 0, 1247, 11297, 1, 0, 0, 0, 1249, 11306, 1, 0, 0, 0, 1251, + 11316, 1, 0, 0, 0, 1253, 11326, 1, 0, 0, 0, 1255, 11332, 1, 0, 0, 0, 1257, + 11337, 1, 0, 0, 0, 1259, 11345, 1, 0, 0, 0, 1261, 11350, 1, 0, 0, 0, 1263, + 11375, 1, 0, 0, 0, 1265, 11384, 1, 0, 0, 0, 1267, 11394, 1, 0, 0, 0, 1269, + 11398, 1, 0, 0, 0, 1271, 11400, 1, 0, 0, 0, 1273, 11428, 1, 0, 0, 0, 1275, + 11451, 1, 0, 0, 0, 1277, 11467, 1, 0, 0, 0, 1279, 11480, 1, 0, 0, 0, 1281, + 11490, 1, 0, 0, 0, 1283, 11494, 1, 0, 0, 0, 1285, 11501, 1, 0, 0, 0, 1287, + 11510, 1, 0, 0, 0, 1289, 11522, 1, 0, 0, 0, 1291, 11543, 1, 0, 0, 0, 1293, + 11548, 1, 0, 0, 0, 1295, 11554, 1, 0, 0, 0, 1297, 11563, 1, 0, 0, 0, 1299, + 11569, 1, 0, 0, 0, 1301, 11578, 1, 0, 0, 0, 1303, 11587, 1, 0, 0, 0, 1305, + 11599, 1, 0, 0, 0, 1307, 11606, 1, 0, 0, 0, 1309, 11617, 1, 0, 0, 0, 1311, + 11627, 1, 0, 0, 0, 1313, 11633, 1, 0, 0, 0, 1315, 11649, 1, 0, 0, 0, 1317, + 11660, 1, 0, 0, 0, 1319, 11668, 1, 0, 0, 0, 1321, 11673, 1, 0, 0, 0, 1323, + 11682, 1, 0, 0, 0, 1325, 11690, 1, 0, 0, 0, 1327, 11697, 1, 0, 0, 0, 1329, + 11704, 1, 0, 0, 0, 1331, 11709, 1, 0, 0, 0, 1333, 11714, 1, 0, 0, 0, 1335, + 11723, 1, 0, 0, 0, 1337, 11732, 1, 0, 0, 0, 1339, 11739, 1, 0, 0, 0, 1341, + 11744, 1, 0, 0, 0, 1343, 11755, 1, 0, 0, 0, 1345, 11768, 1, 0, 0, 0, 1347, + 11780, 1, 0, 0, 0, 1349, 11790, 1, 0, 0, 0, 1351, 11795, 1, 0, 0, 0, 1353, + 11809, 1, 0, 0, 0, 1355, 11821, 1, 0, 0, 0, 1357, 11825, 1, 0, 0, 0, 1359, + 11830, 1, 0, 0, 0, 1361, 11836, 1, 0, 0, 0, 1363, 11841, 1, 0, 0, 0, 1365, + 11854, 1, 0, 0, 0, 1367, 11861, 1, 0, 0, 0, 1369, 11863, 1, 0, 0, 0, 1371, + 11874, 1, 0, 0, 0, 1373, 11885, 1, 0, 0, 0, 1375, 11894, 1, 0, 0, 0, 1377, + 11907, 1, 0, 0, 0, 1379, 11910, 1, 0, 0, 0, 1381, 11920, 1, 0, 0, 0, 1383, + 11923, 1, 0, 0, 0, 1385, 11930, 1, 0, 0, 0, 1387, 11953, 1, 0, 0, 0, 1389, + 11981, 1, 0, 0, 0, 1391, 12008, 1, 0, 0, 0, 1393, 12028, 1, 0, 0, 0, 1395, + 12032, 1, 0, 0, 0, 1397, 12042, 1, 0, 0, 0, 1399, 12049, 1, 0, 0, 0, 1401, + 12056, 1, 0, 0, 0, 1403, 12065, 1, 0, 0, 0, 1405, 12087, 1, 0, 0, 0, 1407, + 12095, 1, 0, 0, 0, 1409, 12111, 1, 0, 0, 0, 1411, 12121, 1, 0, 0, 0, 1413, + 12133, 1, 0, 0, 0, 1415, 12143, 1, 0, 0, 0, 1417, 12148, 1, 0, 0, 0, 1419, + 12155, 1, 0, 0, 0, 1421, 12165, 1, 0, 0, 0, 1423, 12179, 1, 0, 0, 0, 1425, + 12190, 1, 0, 0, 0, 1427, 12198, 1, 0, 0, 0, 1429, 12206, 1, 0, 0, 0, 1431, + 12216, 1, 0, 0, 0, 1433, 12229, 1, 0, 0, 0, 1435, 12235, 1, 0, 0, 0, 1437, + 12244, 1, 0, 0, 0, 1439, 12255, 1, 0, 0, 0, 1441, 12266, 1, 0, 0, 0, 1443, + 12276, 1, 0, 0, 0, 1445, 12289, 1, 0, 0, 0, 1447, 12303, 1, 0, 0, 0, 1449, + 12312, 1, 0, 0, 0, 1451, 12323, 1, 0, 0, 0, 1453, 12339, 1, 0, 0, 0, 1455, + 12352, 1, 0, 0, 0, 1457, 12366, 1, 0, 0, 0, 1459, 12375, 1, 0, 0, 0, 1461, + 12387, 1, 0, 0, 0, 1463, 12397, 1, 0, 0, 0, 1465, 12408, 1, 0, 0, 0, 1467, + 12418, 1, 0, 0, 0, 1469, 12426, 1, 0, 0, 0, 1471, 12435, 1, 0, 0, 0, 1473, + 12449, 1, 0, 0, 0, 1475, 12457, 1, 0, 0, 0, 1477, 12460, 1, 0, 0, 0, 1479, + 12468, 1, 0, 0, 0, 1481, 12476, 1, 0, 0, 0, 1483, 12488, 1, 0, 0, 0, 1485, + 12498, 1, 0, 0, 0, 1487, 12507, 1, 0, 0, 0, 1489, 12514, 1, 0, 0, 0, 1491, + 12532, 1, 0, 0, 0, 1493, 12541, 1, 0, 0, 0, 1495, 12560, 1, 0, 0, 0, 1497, + 12577, 1, 0, 0, 0, 1499, 12583, 1, 0, 0, 0, 1501, 12589, 1, 0, 0, 0, 1503, + 12597, 1, 0, 0, 0, 1505, 12609, 1, 0, 0, 0, 1507, 12629, 1, 0, 0, 0, 1509, + 12650, 1, 0, 0, 0, 1511, 12665, 1, 0, 0, 0, 1513, 12672, 1, 0, 0, 0, 1515, + 12687, 1, 0, 0, 0, 1517, 12703, 1, 0, 0, 0, 1519, 12712, 1, 0, 0, 0, 1521, + 12722, 1, 0, 0, 0, 1523, 12735, 1, 0, 0, 0, 1525, 12745, 1, 0, 0, 0, 1527, + 12753, 1, 0, 0, 0, 1529, 12760, 1, 0, 0, 0, 1531, 12767, 1, 0, 0, 0, 1533, + 12774, 1, 0, 0, 0, 1535, 12781, 1, 0, 0, 0, 1537, 12787, 1, 0, 0, 0, 1539, + 12795, 1, 0, 0, 0, 1541, 12807, 1, 0, 0, 0, 1543, 12820, 1, 0, 0, 0, 1545, + 12837, 1, 0, 0, 0, 1547, 12850, 1, 0, 0, 0, 1549, 12862, 1, 0, 0, 0, 1551, + 12872, 1, 0, 0, 0, 1553, 12881, 1, 0, 0, 0, 1555, 12885, 1, 0, 0, 0, 1557, + 12894, 1, 0, 0, 0, 1559, 12899, 1, 0, 0, 0, 1561, 12910, 1, 0, 0, 0, 1563, + 12923, 1, 0, 0, 0, 1565, 12933, 1, 0, 0, 0, 1567, 12943, 1, 0, 0, 0, 1569, + 12954, 1, 0, 0, 0, 1571, 12957, 1, 0, 0, 0, 1573, 12965, 1, 0, 0, 0, 1575, + 12975, 1, 0, 0, 0, 1577, 12991, 1, 0, 0, 0, 1579, 12997, 1, 0, 0, 0, 1581, + 13005, 1, 0, 0, 0, 1583, 13022, 1, 0, 0, 0, 1585, 13027, 1, 0, 0, 0, 1587, + 13031, 1, 0, 0, 0, 1589, 13036, 1, 0, 0, 0, 1591, 13050, 1, 0, 0, 0, 1593, + 13061, 1, 0, 0, 0, 1595, 13072, 1, 0, 0, 0, 1597, 13085, 1, 0, 0, 0, 1599, + 13097, 1, 0, 0, 0, 1601, 13105, 1, 0, 0, 0, 1603, 13110, 1, 0, 0, 0, 1605, + 13125, 1, 0, 0, 0, 1607, 13137, 1, 0, 0, 0, 1609, 13147, 1, 0, 0, 0, 1611, + 13158, 1, 0, 0, 0, 1613, 13173, 1, 0, 0, 0, 1615, 13184, 1, 0, 0, 0, 1617, + 13203, 1, 0, 0, 0, 1619, 13221, 1, 0, 0, 0, 1621, 13236, 1, 0, 0, 0, 1623, + 13247, 1, 0, 0, 0, 1625, 13249, 1, 0, 0, 0, 1627, 13265, 1, 0, 0, 0, 1629, + 13270, 1, 0, 0, 0, 1631, 13279, 1, 0, 0, 0, 1633, 13283, 1, 0, 0, 0, 1635, + 13294, 1, 0, 0, 0, 1637, 13302, 1, 0, 0, 0, 1639, 13307, 1, 0, 0, 0, 1641, + 13316, 1, 0, 0, 0, 1643, 13321, 1, 0, 0, 0, 1645, 13327, 1, 0, 0, 0, 1647, + 13336, 1, 0, 0, 0, 1649, 13345, 1, 0, 0, 0, 1651, 13350, 1, 0, 0, 0, 1653, + 13361, 1, 0, 0, 0, 1655, 13369, 1, 0, 0, 0, 1657, 13376, 1, 0, 0, 0, 1659, + 13380, 1, 0, 0, 0, 1661, 13386, 1, 0, 0, 0, 1663, 13412, 1, 0, 0, 0, 1665, + 13430, 1, 0, 0, 0, 1667, 13453, 1, 0, 0, 0, 1669, 13461, 1, 0, 0, 0, 1671, + 13466, 1, 0, 0, 0, 1673, 13475, 1, 0, 0, 0, 1675, 13488, 1, 0, 0, 0, 1677, + 13496, 1, 0, 0, 0, 1679, 13501, 1, 0, 0, 0, 1681, 13509, 1, 0, 0, 0, 1683, + 13517, 1, 0, 0, 0, 1685, 13525, 1, 0, 0, 0, 1687, 13533, 1, 0, 0, 0, 1689, + 13540, 1, 0, 0, 0, 1691, 13545, 1, 0, 0, 0, 1693, 13551, 1, 0, 0, 0, 1695, + 13562, 1, 0, 0, 0, 1697, 13569, 1, 0, 0, 0, 1699, 13577, 1, 0, 0, 0, 1701, + 13587, 1, 0, 0, 0, 1703, 13592, 1, 0, 0, 0, 1705, 13601, 1, 0, 0, 0, 1707, + 13607, 1, 0, 0, 0, 1709, 13613, 1, 0, 0, 0, 1711, 13619, 1, 0, 0, 0, 1713, + 13631, 1, 0, 0, 0, 1715, 13636, 1, 0, 0, 0, 1717, 13642, 1, 0, 0, 0, 1719, + 13649, 1, 0, 0, 0, 1721, 13655, 1, 0, 0, 0, 1723, 13660, 1, 0, 0, 0, 1725, + 13665, 1, 0, 0, 0, 1727, 13672, 1, 0, 0, 0, 1729, 13676, 1, 0, 0, 0, 1731, + 13679, 1, 0, 0, 0, 1733, 13685, 1, 0, 0, 0, 1735, 13690, 1, 0, 0, 0, 1737, + 13694, 1, 0, 0, 0, 1739, 13702, 1, 0, 0, 0, 1741, 13709, 1, 0, 0, 0, 1743, + 13714, 1, 0, 0, 0, 1745, 13728, 1, 0, 0, 0, 1747, 13734, 1, 0, 0, 0, 1749, + 13744, 1, 0, 0, 0, 1751, 13759, 1, 0, 0, 0, 1753, 13768, 1, 0, 0, 0, 1755, + 13776, 1, 0, 0, 0, 1757, 13785, 1, 0, 0, 0, 1759, 13792, 1, 0, 0, 0, 1761, + 13800, 1, 0, 0, 0, 1763, 13805, 1, 0, 0, 0, 1765, 13813, 1, 0, 0, 0, 1767, + 13822, 1, 0, 0, 0, 1769, 13830, 1, 0, 0, 0, 1771, 13838, 1, 0, 0, 0, 1773, + 13861, 1, 0, 0, 0, 1775, 13887, 1, 0, 0, 0, 1777, 13891, 1, 0, 0, 0, 1779, + 13901, 1, 0, 0, 0, 1781, 13908, 1, 0, 0, 0, 1783, 13914, 1, 0, 0, 0, 1785, + 13939, 1, 0, 0, 0, 1787, 13944, 1, 0, 0, 0, 1789, 13949, 1, 0, 0, 0, 1791, + 13954, 1, 0, 0, 0, 1793, 13960, 1, 0, 0, 0, 1795, 13964, 1, 0, 0, 0, 1797, + 13969, 1, 0, 0, 0, 1799, 13976, 1, 0, 0, 0, 1801, 13982, 1, 0, 0, 0, 1803, + 13984, 1, 0, 0, 0, 1805, 13989, 1, 0, 0, 0, 1807, 13998, 1, 0, 0, 0, 1809, + 14006, 1, 0, 0, 0, 1811, 14013, 1, 0, 0, 0, 1813, 14024, 1, 0, 0, 0, 1815, + 14032, 1, 0, 0, 0, 1817, 14042, 1, 0, 0, 0, 1819, 14049, 1, 0, 0, 0, 1821, + 14053, 1, 0, 0, 0, 1823, 14061, 1, 0, 0, 0, 1825, 14066, 1, 0, 0, 0, 1827, + 14073, 1, 0, 0, 0, 1829, 14081, 1, 0, 0, 0, 1831, 14089, 1, 0, 0, 0, 1833, + 14095, 1, 0, 0, 0, 1835, 14108, 1, 0, 0, 0, 1837, 14124, 1, 0, 0, 0, 1839, + 14137, 1, 0, 0, 0, 1841, 14149, 1, 0, 0, 0, 1843, 14161, 1, 0, 0, 0, 1845, + 14174, 1, 0, 0, 0, 1847, 14185, 1, 0, 0, 0, 1849, 14194, 1, 0, 0, 0, 1851, + 14207, 1, 0, 0, 0, 1853, 14219, 1, 0, 0, 0, 1855, 14233, 1, 0, 0, 0, 1857, + 14247, 1, 0, 0, 0, 1859, 14268, 1, 0, 0, 0, 1861, 14276, 1, 0, 0, 0, 1863, + 14285, 1, 0, 0, 0, 1865, 14294, 1, 0, 0, 0, 1867, 14302, 1, 0, 0, 0, 1869, + 14311, 1, 0, 0, 0, 1871, 14318, 1, 0, 0, 0, 1873, 14325, 1, 0, 0, 0, 1875, + 14340, 1, 0, 0, 0, 1877, 14359, 1, 0, 0, 0, 1879, 14371, 1, 0, 0, 0, 1881, + 14390, 1, 0, 0, 0, 1883, 14402, 1, 0, 0, 0, 1885, 14409, 1, 0, 0, 0, 1887, + 14423, 1, 0, 0, 0, 1889, 14432, 1, 0, 0, 0, 1891, 14447, 1, 0, 0, 0, 1893, + 14453, 1, 0, 0, 0, 1895, 14462, 1, 0, 0, 0, 1897, 14471, 1, 0, 0, 0, 1899, + 14478, 1, 0, 0, 0, 1901, 14486, 1, 0, 0, 0, 1903, 14496, 1, 0, 0, 0, 1905, + 14507, 1, 0, 0, 0, 1907, 14516, 1, 0, 0, 0, 1909, 14524, 1, 0, 0, 0, 1911, + 14531, 1, 0, 0, 0, 1913, 14537, 1, 0, 0, 0, 1915, 14548, 1, 0, 0, 0, 1917, + 14555, 1, 0, 0, 0, 1919, 14563, 1, 0, 0, 0, 1921, 14572, 1, 0, 0, 0, 1923, + 14583, 1, 0, 0, 0, 1925, 14593, 1, 0, 0, 0, 1927, 14600, 1, 0, 0, 0, 1929, + 14608, 1, 0, 0, 0, 1931, 14617, 1, 0, 0, 0, 1933, 14626, 1, 0, 0, 0, 1935, + 14649, 1, 0, 0, 0, 1937, 14677, 1, 0, 0, 0, 1939, 14700, 1, 0, 0, 0, 1941, + 14719, 1, 0, 0, 0, 1943, 14725, 1, 0, 0, 0, 1945, 14734, 1, 0, 0, 0, 1947, + 14752, 1, 0, 0, 0, 1949, 14762, 1, 0, 0, 0, 1951, 14777, 1, 0, 0, 0, 1953, + 14786, 1, 0, 0, 0, 1955, 14791, 1, 0, 0, 0, 1957, 14804, 1, 0, 0, 0, 1959, + 14823, 1, 0, 0, 0, 1961, 14830, 1, 0, 0, 0, 1963, 14834, 1, 0, 0, 0, 1965, + 14841, 1, 0, 0, 0, 1967, 14852, 1, 0, 0, 0, 1969, 14860, 1, 0, 0, 0, 1971, + 14866, 1, 0, 0, 0, 1973, 14881, 1, 0, 0, 0, 1975, 14888, 1, 0, 0, 0, 1977, + 14894, 1, 0, 0, 0, 1979, 14904, 1, 0, 0, 0, 1981, 14915, 1, 0, 0, 0, 1983, + 14924, 1, 0, 0, 0, 1985, 14929, 1, 0, 0, 0, 1987, 14946, 1, 0, 0, 0, 1989, + 14955, 1, 0, 0, 0, 1991, 14964, 1, 0, 0, 0, 1993, 14970, 1, 0, 0, 0, 1995, + 14975, 1, 0, 0, 0, 1997, 14985, 1, 0, 0, 0, 1999, 14989, 1, 0, 0, 0, 2001, + 14995, 1, 0, 0, 0, 2003, 15004, 1, 0, 0, 0, 2005, 15027, 1, 0, 0, 0, 2007, + 15034, 1, 0, 0, 0, 2009, 15042, 1, 0, 0, 0, 2011, 15051, 1, 0, 0, 0, 2013, + 15055, 1, 0, 0, 0, 2015, 15064, 1, 0, 0, 0, 2017, 15070, 1, 0, 0, 0, 2019, + 15075, 1, 0, 0, 0, 2021, 15081, 1, 0, 0, 0, 2023, 15088, 1, 0, 0, 0, 2025, + 15092, 1, 0, 0, 0, 2027, 15099, 1, 0, 0, 0, 2029, 15124, 1, 0, 0, 0, 2031, + 15146, 1, 0, 0, 0, 2033, 15162, 1, 0, 0, 0, 2035, 15184, 1, 0, 0, 0, 2037, + 15207, 1, 0, 0, 0, 2039, 15215, 1, 0, 0, 0, 2041, 15221, 1, 0, 0, 0, 2043, + 15225, 1, 0, 0, 0, 2045, 15233, 1, 0, 0, 0, 2047, 15242, 1, 0, 0, 0, 2049, + 15251, 1, 0, 0, 0, 2051, 15256, 1, 0, 0, 0, 2053, 15262, 1, 0, 0, 0, 2055, + 15275, 1, 0, 0, 0, 2057, 15292, 1, 0, 0, 0, 2059, 15307, 1, 0, 0, 0, 2061, + 15320, 1, 0, 0, 0, 2063, 15333, 1, 0, 0, 0, 2065, 15350, 1, 0, 0, 0, 2067, + 15371, 1, 0, 0, 0, 2069, 15386, 1, 0, 0, 0, 2071, 15403, 1, 0, 0, 0, 2073, + 15412, 1, 0, 0, 0, 2075, 15425, 1, 0, 0, 0, 2077, 15441, 1, 0, 0, 0, 2079, + 15459, 1, 0, 0, 0, 2081, 15471, 1, 0, 0, 0, 2083, 15488, 1, 0, 0, 0, 2085, + 15494, 1, 0, 0, 0, 2087, 15503, 1, 0, 0, 0, 2089, 15516, 1, 0, 0, 0, 2091, + 15537, 1, 0, 0, 0, 2093, 15547, 1, 0, 0, 0, 2095, 15567, 1, 0, 0, 0, 2097, + 15590, 1, 0, 0, 0, 2099, 15599, 1, 0, 0, 0, 2101, 15607, 1, 0, 0, 0, 2103, + 15625, 1, 0, 0, 0, 2105, 15639, 1, 0, 0, 0, 2107, 15649, 1, 0, 0, 0, 2109, + 15659, 1, 0, 0, 0, 2111, 15676, 1, 0, 0, 0, 2113, 15691, 1, 0, 0, 0, 2115, + 15700, 1, 0, 0, 0, 2117, 15713, 1, 0, 0, 0, 2119, 15721, 1, 0, 0, 0, 2121, + 15731, 1, 0, 0, 0, 2123, 15750, 1, 0, 0, 0, 2125, 15779, 1, 0, 0, 0, 2127, + 15810, 1, 0, 0, 0, 2129, 15824, 1, 0, 0, 0, 2131, 15834, 1, 0, 0, 0, 2133, + 15842, 1, 0, 0, 0, 2135, 15850, 1, 0, 0, 0, 2137, 15863, 1, 0, 0, 0, 2139, + 15884, 1, 0, 0, 0, 2141, 15904, 1, 0, 0, 0, 2143, 15918, 1, 0, 0, 0, 2145, + 15933, 1, 0, 0, 0, 2147, 15948, 1, 0, 0, 0, 2149, 15959, 1, 0, 0, 0, 2151, + 15985, 1, 0, 0, 0, 2153, 16010, 1, 0, 0, 0, 2155, 16035, 1, 0, 0, 0, 2157, + 16059, 1, 0, 0, 0, 2159, 16083, 1, 0, 0, 0, 2161, 16090, 1, 0, 0, 0, 2163, + 16116, 1, 0, 0, 0, 2165, 16131, 1, 0, 0, 0, 2167, 16145, 1, 0, 0, 0, 2169, + 16153, 1, 0, 0, 0, 2171, 16178, 1, 0, 0, 0, 2173, 16193, 1, 0, 0, 0, 2175, + 16201, 1, 0, 0, 0, 2177, 16212, 1, 0, 0, 0, 2179, 16226, 1, 0, 0, 0, 2181, + 16249, 1, 0, 0, 0, 2183, 16276, 1, 0, 0, 0, 2185, 16292, 1, 0, 0, 0, 2187, + 16310, 1, 0, 0, 0, 2189, 16327, 1, 0, 0, 0, 2191, 16351, 1, 0, 0, 0, 2193, + 16368, 1, 0, 0, 0, 2195, 16392, 1, 0, 0, 0, 2197, 16402, 1, 0, 0, 0, 2199, + 16418, 1, 0, 0, 0, 2201, 16427, 1, 0, 0, 0, 2203, 16435, 1, 0, 0, 0, 2205, + 16453, 1, 0, 0, 0, 2207, 16466, 1, 0, 0, 0, 2209, 16474, 1, 0, 0, 0, 2211, + 16502, 1, 0, 0, 0, 2213, 16533, 1, 0, 0, 0, 2215, 16549, 1, 0, 0, 0, 2217, + 16561, 1, 0, 0, 0, 2219, 16574, 1, 0, 0, 0, 2221, 16583, 1, 0, 0, 0, 2223, + 16595, 1, 0, 0, 0, 2225, 16607, 1, 0, 0, 0, 2227, 16627, 1, 0, 0, 0, 2229, + 16634, 1, 0, 0, 0, 2231, 16642, 1, 0, 0, 0, 2233, 16650, 1, 0, 0, 0, 2235, + 16656, 1, 0, 0, 0, 2237, 16666, 1, 0, 0, 0, 2239, 16676, 1, 0, 0, 0, 2241, + 16686, 1, 0, 0, 0, 2243, 16697, 1, 0, 0, 0, 2245, 16706, 1, 0, 0, 0, 2247, + 16717, 1, 0, 0, 0, 2249, 16728, 1, 0, 0, 0, 2251, 16746, 1, 0, 0, 0, 2253, + 16760, 1, 0, 0, 0, 2255, 16773, 1, 0, 0, 0, 2257, 16784, 1, 0, 0, 0, 2259, + 16803, 1, 0, 0, 0, 2261, 16829, 1, 0, 0, 0, 2263, 16841, 1, 0, 0, 0, 2265, + 16856, 1, 0, 0, 0, 2267, 16861, 1, 0, 0, 0, 2269, 16870, 1, 0, 0, 0, 2271, + 16886, 1, 0, 0, 0, 2273, 16902, 1, 0, 0, 0, 2275, 16905, 1, 0, 0, 0, 2277, + 16915, 1, 0, 0, 0, 2279, 16930, 1, 0, 0, 0, 2281, 16938, 1, 0, 0, 0, 2283, + 16955, 1, 0, 0, 0, 2285, 16977, 1, 0, 0, 0, 2287, 17000, 1, 0, 0, 0, 2289, + 17011, 1, 0, 0, 0, 2291, 17029, 1, 0, 0, 0, 2293, 17046, 1, 0, 0, 0, 2295, + 17058, 1, 0, 0, 0, 2297, 17069, 1, 0, 0, 0, 2299, 17087, 1, 0, 0, 0, 2301, + 17103, 1, 0, 0, 0, 2303, 17130, 1, 0, 0, 0, 2305, 17142, 1, 0, 0, 0, 2307, + 17160, 1, 0, 0, 0, 2309, 17178, 1, 0, 0, 0, 2311, 17201, 1, 0, 0, 0, 2313, + 17211, 1, 0, 0, 0, 2315, 17220, 1, 0, 0, 0, 2317, 17236, 1, 0, 0, 0, 2319, + 17247, 1, 0, 0, 0, 2321, 17262, 1, 0, 0, 0, 2323, 17275, 1, 0, 0, 0, 2325, + 17288, 1, 0, 0, 0, 2327, 17301, 1, 0, 0, 0, 2329, 17323, 1, 0, 0, 0, 2331, + 17341, 1, 0, 0, 0, 2333, 17353, 1, 0, 0, 0, 2335, 17377, 1, 0, 0, 0, 2337, + 17392, 1, 0, 0, 0, 2339, 17403, 1, 0, 0, 0, 2341, 17410, 1, 0, 0, 0, 2343, + 17419, 1, 0, 0, 0, 2345, 17428, 1, 0, 0, 0, 2347, 17440, 1, 0, 0, 0, 2349, + 17456, 1, 0, 0, 0, 2351, 17466, 1, 0, 0, 0, 2353, 17477, 1, 0, 0, 0, 2355, + 17487, 1, 0, 0, 0, 2357, 17494, 1, 0, 0, 0, 2359, 17515, 1, 0, 0, 0, 2361, + 17533, 1, 0, 0, 0, 2363, 17541, 1, 0, 0, 0, 2365, 17555, 1, 0, 0, 0, 2367, + 17565, 1, 0, 0, 0, 2369, 17577, 1, 0, 0, 0, 2371, 17594, 1, 0, 0, 0, 2373, + 17609, 1, 0, 0, 0, 2375, 17617, 1, 0, 0, 0, 2377, 17624, 1, 0, 0, 0, 2379, + 17643, 1, 0, 0, 0, 2381, 17655, 1, 0, 0, 0, 2383, 17678, 1, 0, 0, 0, 2385, + 17699, 1, 0, 0, 0, 2387, 17714, 1, 0, 0, 0, 2389, 17723, 1, 0, 0, 0, 2391, + 17743, 1, 0, 0, 0, 2393, 17758, 1, 0, 0, 0, 2395, 17778, 1, 0, 0, 0, 2397, + 17787, 1, 0, 0, 0, 2399, 17809, 1, 0, 0, 0, 2401, 17823, 1, 0, 0, 0, 2403, + 17831, 1, 0, 0, 0, 2405, 17844, 1, 0, 0, 0, 2407, 17851, 1, 0, 0, 0, 2409, + 17855, 1, 0, 0, 0, 2411, 17881, 1, 0, 0, 0, 2413, 17891, 1, 0, 0, 0, 2415, + 17903, 1, 0, 0, 0, 2417, 17927, 1, 0, 0, 0, 2419, 17956, 1, 0, 0, 0, 2421, + 17968, 1, 0, 0, 0, 2423, 17993, 1, 0, 0, 0, 2425, 18006, 1, 0, 0, 0, 2427, + 18016, 1, 0, 0, 0, 2429, 18042, 1, 0, 0, 0, 2431, 18053, 1, 0, 0, 0, 2433, + 18078, 1, 0, 0, 0, 2435, 18103, 1, 0, 0, 0, 2437, 18123, 1, 0, 0, 0, 2439, + 18130, 1, 0, 0, 0, 2441, 18153, 1, 0, 0, 0, 2443, 18172, 1, 0, 0, 0, 2445, + 18202, 1, 0, 0, 0, 2447, 18222, 1, 0, 0, 0, 2449, 18243, 1, 0, 0, 0, 2451, + 18254, 1, 0, 0, 0, 2453, 18264, 1, 0, 0, 0, 2455, 18271, 1, 0, 0, 0, 2457, + 18276, 1, 0, 0, 0, 2459, 18282, 1, 0, 0, 0, 2461, 18289, 1, 0, 0, 0, 2463, + 18297, 1, 0, 0, 0, 2465, 18312, 1, 0, 0, 0, 2467, 18328, 1, 0, 0, 0, 2469, + 18344, 1, 0, 0, 0, 2471, 18354, 1, 0, 0, 0, 2473, 18359, 1, 0, 0, 0, 2475, + 18370, 1, 0, 0, 0, 2477, 18377, 1, 0, 0, 0, 2479, 18384, 1, 0, 0, 0, 2481, + 18390, 1, 0, 0, 0, 2483, 18402, 1, 0, 0, 0, 2485, 18413, 1, 0, 0, 0, 2487, + 18421, 1, 0, 0, 0, 2489, 18425, 1, 0, 0, 0, 2491, 18432, 1, 0, 0, 0, 2493, + 18435, 1, 0, 0, 0, 2495, 18444, 1, 0, 0, 0, 2497, 18448, 1, 0, 0, 0, 2499, + 18453, 1, 0, 0, 0, 2501, 18457, 1, 0, 0, 0, 2503, 18471, 1, 0, 0, 0, 2505, + 18475, 1, 0, 0, 0, 2507, 18480, 1, 0, 0, 0, 2509, 18485, 1, 0, 0, 0, 2511, + 18489, 1, 0, 0, 0, 2513, 18496, 1, 0, 0, 0, 2515, 18506, 1, 0, 0, 0, 2517, + 18511, 1, 0, 0, 0, 2519, 18514, 1, 0, 0, 0, 2521, 18521, 1, 0, 0, 0, 2523, + 18538, 1, 0, 0, 0, 2525, 18556, 1, 0, 0, 0, 2527, 18563, 1, 0, 0, 0, 2529, + 18568, 1, 0, 0, 0, 2531, 18579, 1, 0, 0, 0, 2533, 18588, 1, 0, 0, 0, 2535, + 18601, 1, 0, 0, 0, 2537, 18609, 1, 0, 0, 0, 2539, 18618, 1, 0, 0, 0, 2541, + 18644, 1, 0, 0, 0, 2543, 18659, 1, 0, 0, 0, 2545, 18666, 1, 0, 0, 0, 2547, + 18677, 1, 0, 0, 0, 2549, 18687, 1, 0, 0, 0, 2551, 18698, 1, 0, 0, 0, 2553, + 18712, 1, 0, 0, 0, 2555, 18732, 1, 0, 0, 0, 2557, 18747, 1, 0, 0, 0, 2559, + 18755, 1, 0, 0, 0, 2561, 18759, 1, 0, 0, 0, 2563, 18771, 1, 0, 0, 0, 2565, + 18785, 1, 0, 0, 0, 2567, 18794, 1, 0, 0, 0, 2569, 18811, 1, 0, 0, 0, 2571, + 18827, 1, 0, 0, 0, 2573, 18841, 1, 0, 0, 0, 2575, 18856, 1, 0, 0, 0, 2577, + 18875, 1, 0, 0, 0, 2579, 18884, 1, 0, 0, 0, 2581, 18904, 1, 0, 0, 0, 2583, + 18922, 1, 0, 0, 0, 2585, 18948, 1, 0, 0, 0, 2587, 18969, 1, 0, 0, 0, 2589, + 18984, 1, 0, 0, 0, 2591, 18998, 1, 0, 0, 0, 2593, 19009, 1, 0, 0, 0, 2595, + 19024, 1, 0, 0, 0, 2597, 19039, 1, 0, 0, 0, 2599, 19054, 1, 0, 0, 0, 2601, + 19069, 1, 0, 0, 0, 2603, 19077, 1, 0, 0, 0, 2605, 19096, 1, 0, 0, 0, 2607, + 19102, 1, 0, 0, 0, 2609, 19113, 1, 0, 0, 0, 2611, 19123, 1, 0, 0, 0, 2613, + 19136, 1, 0, 0, 0, 2615, 19139, 1, 0, 0, 0, 2617, 19153, 1, 0, 0, 0, 2619, + 19161, 1, 0, 0, 0, 2621, 19167, 1, 0, 0, 0, 2623, 19186, 1, 0, 0, 0, 2625, + 19206, 1, 0, 0, 0, 2627, 19212, 1, 0, 0, 0, 2629, 19225, 1, 0, 0, 0, 2631, + 19233, 1, 0, 0, 0, 2633, 19246, 1, 0, 0, 0, 2635, 19258, 1, 0, 0, 0, 2637, + 19262, 1, 0, 0, 0, 2639, 19278, 1, 0, 0, 0, 2641, 19287, 1, 0, 0, 0, 2643, + 19296, 1, 0, 0, 0, 2645, 19301, 1, 0, 0, 0, 2647, 19310, 1, 0, 0, 0, 2649, + 19321, 1, 0, 0, 0, 2651, 19327, 1, 0, 0, 0, 2653, 19337, 1, 0, 0, 0, 2655, + 19341, 1, 0, 0, 0, 2657, 19343, 1, 0, 0, 0, 2659, 19351, 1, 0, 0, 0, 2661, + 19360, 1, 0, 0, 0, 2663, 19376, 1, 0, 0, 0, 2665, 19391, 1, 0, 0, 0, 2667, + 19400, 1, 0, 0, 0, 2669, 19414, 1, 0, 0, 0, 2671, 19425, 1, 0, 0, 0, 2673, + 19431, 1, 0, 0, 0, 2675, 19438, 1, 0, 0, 0, 2677, 19456, 1, 0, 0, 0, 2679, + 19475, 1, 0, 0, 0, 2681, 19482, 1, 0, 0, 0, 2683, 19490, 1, 0, 0, 0, 2685, + 19503, 1, 0, 0, 0, 2687, 19513, 1, 0, 0, 0, 2689, 19521, 1, 0, 0, 0, 2691, + 19545, 1, 0, 0, 0, 2693, 19560, 1, 0, 0, 0, 2695, 19575, 1, 0, 0, 0, 2697, + 19585, 1, 0, 0, 0, 2699, 19601, 1, 0, 0, 0, 2701, 19612, 1, 0, 0, 0, 2703, + 19626, 1, 0, 0, 0, 2705, 19634, 1, 0, 0, 0, 2707, 19654, 1, 0, 0, 0, 2709, + 19673, 1, 0, 0, 0, 2711, 19692, 1, 0, 0, 0, 2713, 19701, 1, 0, 0, 0, 2715, + 19720, 1, 0, 0, 0, 2717, 19740, 1, 0, 0, 0, 2719, 19763, 1, 0, 0, 0, 2721, + 19788, 1, 0, 0, 0, 2723, 19793, 1, 0, 0, 0, 2725, 19799, 1, 0, 0, 0, 2727, + 19804, 1, 0, 0, 0, 2729, 19816, 1, 0, 0, 0, 2731, 19822, 1, 0, 0, 0, 2733, + 19830, 1, 0, 0, 0, 2735, 19843, 1, 0, 0, 0, 2737, 19854, 1, 0, 0, 0, 2739, + 19862, 1, 0, 0, 0, 2741, 19874, 1, 0, 0, 0, 2743, 19887, 1, 0, 0, 0, 2745, + 19895, 1, 0, 0, 0, 2747, 19906, 1, 0, 0, 0, 2749, 19914, 1, 0, 0, 0, 2751, + 19927, 1, 0, 0, 0, 2753, 19941, 1, 0, 0, 0, 2755, 19957, 1, 0, 0, 0, 2757, + 19965, 1, 0, 0, 0, 2759, 19979, 1, 0, 0, 0, 2761, 19995, 1, 0, 0, 0, 2763, + 20010, 1, 0, 0, 0, 2765, 20022, 1, 0, 0, 0, 2767, 20045, 1, 0, 0, 0, 2769, + 20066, 1, 0, 0, 0, 2771, 20078, 1, 0, 0, 0, 2773, 20085, 1, 0, 0, 0, 2775, + 20095, 1, 0, 0, 0, 2777, 20106, 1, 0, 0, 0, 2779, 20114, 1, 0, 0, 0, 2781, + 20118, 1, 0, 0, 0, 2783, 20124, 1, 0, 0, 0, 2785, 20133, 1, 0, 0, 0, 2787, + 20139, 1, 0, 0, 0, 2789, 20149, 1, 0, 0, 0, 2791, 20154, 1, 0, 0, 0, 2793, + 20161, 1, 0, 0, 0, 2795, 20167, 1, 0, 0, 0, 2797, 20175, 1, 0, 0, 0, 2799, + 20190, 1, 0, 0, 0, 2801, 20205, 1, 0, 0, 0, 2803, 20210, 1, 0, 0, 0, 2805, + 20227, 1, 0, 0, 0, 2807, 20239, 1, 0, 0, 0, 2809, 20253, 1, 0, 0, 0, 2811, + 20269, 1, 0, 0, 0, 2813, 20281, 1, 0, 0, 0, 2815, 20302, 1, 0, 0, 0, 2817, + 20317, 1, 0, 0, 0, 2819, 20327, 1, 0, 0, 0, 2821, 20332, 1, 0, 0, 0, 2823, + 20338, 1, 0, 0, 0, 2825, 20345, 1, 0, 0, 0, 2827, 20354, 1, 0, 0, 0, 2829, + 20362, 1, 0, 0, 0, 2831, 20371, 1, 0, 0, 0, 2833, 20379, 1, 0, 0, 0, 2835, + 20387, 1, 0, 0, 0, 2837, 20396, 1, 0, 0, 0, 2839, 20406, 1, 0, 0, 0, 2841, + 20415, 1, 0, 0, 0, 2843, 20432, 1, 0, 0, 0, 2845, 20461, 1, 0, 0, 0, 2847, + 20475, 1, 0, 0, 0, 2849, 20481, 1, 0, 0, 0, 2851, 20501, 1, 0, 0, 0, 2853, + 20515, 1, 0, 0, 0, 2855, 20536, 1, 0, 0, 0, 2857, 20546, 1, 0, 0, 0, 2859, + 20553, 1, 0, 0, 0, 2861, 20562, 1, 0, 0, 0, 2863, 20575, 1, 0, 0, 0, 2865, + 20583, 1, 0, 0, 0, 2867, 20590, 1, 0, 0, 0, 2869, 20599, 1, 0, 0, 0, 2871, + 20608, 1, 0, 0, 0, 2873, 20618, 1, 0, 0, 0, 2875, 20628, 1, 0, 0, 0, 2877, + 20648, 1, 0, 0, 0, 2879, 20667, 1, 0, 0, 0, 2881, 20675, 1, 0, 0, 0, 2883, + 20683, 1, 0, 0, 0, 2885, 20696, 1, 0, 0, 0, 2887, 20707, 1, 0, 0, 0, 2889, + 20715, 1, 0, 0, 0, 2891, 20724, 1, 0, 0, 0, 2893, 20737, 1, 0, 0, 0, 2895, + 20746, 1, 0, 0, 0, 2897, 20753, 1, 0, 0, 0, 2899, 20762, 1, 0, 0, 0, 2901, + 20767, 1, 0, 0, 0, 2903, 20775, 1, 0, 0, 0, 2905, 20791, 1, 0, 0, 0, 2907, + 20800, 1, 0, 0, 0, 2909, 20806, 1, 0, 0, 0, 2911, 20814, 1, 0, 0, 0, 2913, + 20826, 1, 0, 0, 0, 2915, 20837, 1, 0, 0, 0, 2917, 20847, 1, 0, 0, 0, 2919, + 20858, 1, 0, 0, 0, 2921, 20869, 1, 0, 0, 0, 2923, 20879, 1, 0, 0, 0, 2925, + 20887, 1, 0, 0, 0, 2927, 20895, 1, 0, 0, 0, 2929, 20903, 1, 0, 0, 0, 2931, + 20911, 1, 0, 0, 0, 2933, 20921, 1, 0, 0, 0, 2935, 20930, 1, 0, 0, 0, 2937, + 20940, 1, 0, 0, 0, 2939, 20951, 1, 0, 0, 0, 2941, 20960, 1, 0, 0, 0, 2943, + 20966, 1, 0, 0, 0, 2945, 20974, 1, 0, 0, 0, 2947, 20981, 1, 0, 0, 0, 2949, + 20991, 1, 0, 0, 0, 2951, 20997, 1, 0, 0, 0, 2953, 21007, 1, 0, 0, 0, 2955, + 21017, 1, 0, 0, 0, 2957, 21036, 1, 0, 0, 0, 2959, 21047, 1, 0, 0, 0, 2961, + 21062, 1, 0, 0, 0, 2963, 21070, 1, 0, 0, 0, 2965, 21079, 1, 0, 0, 0, 2967, + 21091, 1, 0, 0, 0, 2969, 21097, 1, 0, 0, 0, 2971, 21108, 1, 0, 0, 0, 2973, + 21114, 1, 0, 0, 0, 2975, 21125, 1, 0, 0, 0, 2977, 21133, 1, 0, 0, 0, 2979, + 21140, 1, 0, 0, 0, 2981, 21146, 1, 0, 0, 0, 2983, 21157, 1, 0, 0, 0, 2985, + 21163, 1, 0, 0, 0, 2987, 21176, 1, 0, 0, 0, 2989, 21183, 1, 0, 0, 0, 2991, + 21189, 1, 0, 0, 0, 2993, 21195, 1, 0, 0, 0, 2995, 21203, 1, 0, 0, 0, 2997, + 21207, 1, 0, 0, 0, 2999, 21216, 1, 0, 0, 0, 3001, 21226, 1, 0, 0, 0, 3003, + 21230, 1, 0, 0, 0, 3005, 21242, 1, 0, 0, 0, 3007, 21249, 1, 0, 0, 0, 3009, + 21254, 1, 0, 0, 0, 3011, 21259, 1, 0, 0, 0, 3013, 21265, 1, 0, 0, 0, 3015, + 21274, 1, 0, 0, 0, 3017, 21280, 1, 0, 0, 0, 3019, 21285, 1, 0, 0, 0, 3021, + 21295, 1, 0, 0, 0, 3023, 21303, 1, 0, 0, 0, 3025, 21310, 1, 0, 0, 0, 3027, + 21318, 1, 0, 0, 0, 3029, 21336, 1, 0, 0, 0, 3031, 21348, 1, 0, 0, 0, 3033, + 21356, 1, 0, 0, 0, 3035, 21365, 1, 0, 0, 0, 3037, 21376, 1, 0, 0, 0, 3039, + 21384, 1, 0, 0, 0, 3041, 21394, 1, 0, 0, 0, 3043, 21403, 1, 0, 0, 0, 3045, + 21408, 1, 0, 0, 0, 3047, 21416, 1, 0, 0, 0, 3049, 21427, 1, 0, 0, 0, 3051, + 21446, 1, 0, 0, 0, 3053, 21457, 1, 0, 0, 0, 3055, 21467, 1, 0, 0, 0, 3057, + 21478, 1, 0, 0, 0, 3059, 21490, 1, 0, 0, 0, 3061, 21494, 1, 0, 0, 0, 3063, + 21502, 1, 0, 0, 0, 3065, 21511, 1, 0, 0, 0, 3067, 21524, 1, 0, 0, 0, 3069, + 21537, 1, 0, 0, 0, 3071, 21549, 1, 0, 0, 0, 3073, 21564, 1, 0, 0, 0, 3075, + 21578, 1, 0, 0, 0, 3077, 21587, 1, 0, 0, 0, 3079, 21597, 1, 0, 0, 0, 3081, + 21607, 1, 0, 0, 0, 3083, 21618, 1, 0, 0, 0, 3085, 21633, 1, 0, 0, 0, 3087, + 21641, 1, 0, 0, 0, 3089, 21652, 1, 0, 0, 0, 3091, 21661, 1, 0, 0, 0, 3093, + 21670, 1, 0, 0, 0, 3095, 21679, 1, 0, 0, 0, 3097, 21687, 1, 0, 0, 0, 3099, + 21694, 1, 0, 0, 0, 3101, 21700, 1, 0, 0, 0, 3103, 21711, 1, 0, 0, 0, 3105, + 21721, 1, 0, 0, 0, 3107, 21730, 1, 0, 0, 0, 3109, 21735, 1, 0, 0, 0, 3111, + 21745, 1, 0, 0, 0, 3113, 21752, 1, 0, 0, 0, 3115, 21766, 1, 0, 0, 0, 3117, + 21773, 1, 0, 0, 0, 3119, 21780, 1, 0, 0, 0, 3121, 21787, 1, 0, 0, 0, 3123, + 21794, 1, 0, 0, 0, 3125, 21802, 1, 0, 0, 0, 3127, 21814, 1, 0, 0, 0, 3129, + 21823, 1, 0, 0, 0, 3131, 21833, 1, 0, 0, 0, 3133, 21839, 1, 0, 0, 0, 3135, + 21846, 1, 0, 0, 0, 3137, 21854, 1, 0, 0, 0, 3139, 21863, 1, 0, 0, 0, 3141, + 21872, 1, 0, 0, 0, 3143, 21880, 1, 0, 0, 0, 3145, 21888, 1, 0, 0, 0, 3147, + 21909, 1, 0, 0, 0, 3149, 21917, 1, 0, 0, 0, 3151, 21939, 1, 0, 0, 0, 3153, + 21950, 1, 0, 0, 0, 3155, 21970, 1, 0, 0, 0, 3157, 21979, 1, 0, 0, 0, 3159, + 21992, 1, 0, 0, 0, 3161, 21999, 1, 0, 0, 0, 3163, 22009, 1, 0, 0, 0, 3165, + 22016, 1, 0, 0, 0, 3167, 22026, 1, 0, 0, 0, 3169, 22046, 1, 0, 0, 0, 3171, + 22056, 1, 0, 0, 0, 3173, 22063, 1, 0, 0, 0, 3175, 22069, 1, 0, 0, 0, 3177, + 22077, 1, 0, 0, 0, 3179, 22084, 1, 0, 0, 0, 3181, 22101, 1, 0, 0, 0, 3183, + 22109, 1, 0, 0, 0, 3185, 22115, 1, 0, 0, 0, 3187, 22120, 1, 0, 0, 0, 3189, + 22128, 1, 0, 0, 0, 3191, 22134, 1, 0, 0, 0, 3193, 22143, 1, 0, 0, 0, 3195, + 22151, 1, 0, 0, 0, 3197, 22158, 1, 0, 0, 0, 3199, 22174, 1, 0, 0, 0, 3201, + 22194, 1, 0, 0, 0, 3203, 22200, 1, 0, 0, 0, 3205, 22212, 1, 0, 0, 0, 3207, + 22225, 1, 0, 0, 0, 3209, 22236, 1, 0, 0, 0, 3211, 22243, 1, 0, 0, 0, 3213, + 22247, 1, 0, 0, 0, 3215, 22252, 1, 0, 0, 0, 3217, 22257, 1, 0, 0, 0, 3219, + 22263, 1, 0, 0, 0, 3221, 22268, 1, 0, 0, 0, 3223, 22274, 1, 0, 0, 0, 3225, + 22282, 1, 0, 0, 0, 3227, 22287, 1, 0, 0, 0, 3229, 22294, 1, 0, 0, 0, 3231, + 22312, 1, 0, 0, 0, 3233, 22322, 1, 0, 0, 0, 3235, 22327, 1, 0, 0, 0, 3237, + 22331, 1, 0, 0, 0, 3239, 22342, 1, 0, 0, 0, 3241, 22348, 1, 0, 0, 0, 3243, + 22363, 1, 0, 0, 0, 3245, 22368, 1, 0, 0, 0, 3247, 22378, 1, 0, 0, 0, 3249, + 22390, 1, 0, 0, 0, 3251, 22397, 1, 0, 0, 0, 3253, 22411, 1, 0, 0, 0, 3255, + 22415, 1, 0, 0, 0, 3257, 22421, 1, 0, 0, 0, 3259, 22427, 1, 0, 0, 0, 3261, + 22434, 1, 0, 0, 0, 3263, 22445, 1, 0, 0, 0, 3265, 22458, 1, 0, 0, 0, 3267, + 22471, 1, 0, 0, 0, 3269, 22479, 1, 0, 0, 0, 3271, 22486, 1, 0, 0, 0, 3273, + 22493, 1, 0, 0, 0, 3275, 22501, 1, 0, 0, 0, 3277, 22508, 1, 0, 0, 0, 3279, + 22523, 1, 0, 0, 0, 3281, 22534, 1, 0, 0, 0, 3283, 22543, 1, 0, 0, 0, 3285, + 22548, 1, 0, 0, 0, 3287, 22558, 1, 0, 0, 0, 3289, 22567, 1, 0, 0, 0, 3291, + 22575, 1, 0, 0, 0, 3293, 22587, 1, 0, 0, 0, 3295, 22594, 1, 0, 0, 0, 3297, + 22599, 1, 0, 0, 0, 3299, 22615, 1, 0, 0, 0, 3301, 22624, 1, 0, 0, 0, 3303, + 22638, 1, 0, 0, 0, 3305, 22648, 1, 0, 0, 0, 3307, 22657, 1, 0, 0, 0, 3309, + 22670, 1, 0, 0, 0, 3311, 22681, 1, 0, 0, 0, 3313, 22685, 1, 0, 0, 0, 3315, + 22691, 1, 0, 0, 0, 3317, 22707, 1, 0, 0, 0, 3319, 22720, 1, 0, 0, 0, 3321, + 22738, 1, 0, 0, 0, 3323, 22745, 1, 0, 0, 0, 3325, 22757, 1, 0, 0, 0, 3327, + 22778, 1, 0, 0, 0, 3329, 22786, 1, 0, 0, 0, 3331, 22795, 1, 0, 0, 0, 3333, + 22818, 1, 0, 0, 0, 3335, 22826, 1, 0, 0, 0, 3337, 22844, 1, 0, 0, 0, 3339, + 22860, 1, 0, 0, 0, 3341, 22874, 1, 0, 0, 0, 3343, 22878, 1, 0, 0, 0, 3345, + 22883, 1, 0, 0, 0, 3347, 22892, 1, 0, 0, 0, 3349, 22904, 1, 0, 0, 0, 3351, + 22911, 1, 0, 0, 0, 3353, 22917, 1, 0, 0, 0, 3355, 22928, 1, 0, 0, 0, 3357, + 22940, 1, 0, 0, 0, 3359, 22947, 1, 0, 0, 0, 3361, 22953, 1, 0, 0, 0, 3363, + 22961, 1, 0, 0, 0, 3365, 22971, 1, 0, 0, 0, 3367, 22976, 1, 0, 0, 0, 3369, + 22983, 1, 0, 0, 0, 3371, 22992, 1, 0, 0, 0, 3373, 23001, 1, 0, 0, 0, 3375, + 23005, 1, 0, 0, 0, 3377, 23010, 1, 0, 0, 0, 3379, 23027, 1, 0, 0, 0, 3381, + 23043, 1, 0, 0, 0, 3383, 23048, 1, 0, 0, 0, 3385, 23057, 1, 0, 0, 0, 3387, + 23072, 1, 0, 0, 0, 3389, 23079, 1, 0, 0, 0, 3391, 23086, 1, 0, 0, 0, 3393, + 23097, 1, 0, 0, 0, 3395, 23102, 1, 0, 0, 0, 3397, 23106, 1, 0, 0, 0, 3399, + 23111, 1, 0, 0, 0, 3401, 23117, 1, 0, 0, 0, 3403, 23136, 1, 0, 0, 0, 3405, + 23141, 1, 0, 0, 0, 3407, 23163, 1, 0, 0, 0, 3409, 23185, 1, 0, 0, 0, 3411, + 23195, 1, 0, 0, 0, 3413, 23204, 1, 0, 0, 0, 3415, 23213, 1, 0, 0, 0, 3417, + 23218, 1, 0, 0, 0, 3419, 23223, 1, 0, 0, 0, 3421, 23231, 1, 0, 0, 0, 3423, + 23253, 1, 0, 0, 0, 3425, 23278, 1, 0, 0, 0, 3427, 23285, 1, 0, 0, 0, 3429, + 23291, 1, 0, 0, 0, 3431, 23305, 1, 0, 0, 0, 3433, 23312, 1, 0, 0, 0, 3435, + 23318, 1, 0, 0, 0, 3437, 23330, 1, 0, 0, 0, 3439, 23338, 1, 0, 0, 0, 3441, + 23347, 1, 0, 0, 0, 3443, 23354, 1, 0, 0, 0, 3445, 23375, 1, 0, 0, 0, 3447, + 23377, 1, 0, 0, 0, 3449, 23387, 1, 0, 0, 0, 3451, 23397, 1, 0, 0, 0, 3453, + 23421, 1, 0, 0, 0, 3455, 23426, 1, 0, 0, 0, 3457, 23432, 1, 0, 0, 0, 3459, + 23443, 1, 0, 0, 0, 3461, 23452, 1, 0, 0, 0, 3463, 23466, 1, 0, 0, 0, 3465, + 23489, 1, 0, 0, 0, 3467, 23498, 1, 0, 0, 0, 3469, 23506, 1, 0, 0, 0, 3471, + 23511, 1, 0, 0, 0, 3473, 23531, 1, 0, 0, 0, 3475, 23537, 1, 0, 0, 0, 3477, + 23545, 1, 0, 0, 0, 3479, 23553, 1, 0, 0, 0, 3481, 23566, 1, 0, 0, 0, 3483, + 23584, 1, 0, 0, 0, 3485, 23595, 1, 0, 0, 0, 3487, 23605, 1, 0, 0, 0, 3489, + 23611, 1, 0, 0, 0, 3491, 23618, 1, 0, 0, 0, 3493, 23629, 1, 0, 0, 0, 3495, + 23649, 1, 0, 0, 0, 3497, 23664, 1, 0, 0, 0, 3499, 23677, 1, 0, 0, 0, 3501, + 23691, 1, 0, 0, 0, 3503, 23702, 1, 0, 0, 0, 3505, 23716, 1, 0, 0, 0, 3507, + 23736, 1, 0, 0, 0, 3509, 23755, 1, 0, 0, 0, 3511, 23775, 1, 0, 0, 0, 3513, + 23792, 1, 0, 0, 0, 3515, 23812, 1, 0, 0, 0, 3517, 23827, 1, 0, 0, 0, 3519, + 23838, 1, 0, 0, 0, 3521, 23850, 1, 0, 0, 0, 3523, 23855, 1, 0, 0, 0, 3525, + 23863, 1, 0, 0, 0, 3527, 23869, 1, 0, 0, 0, 3529, 23877, 1, 0, 0, 0, 3531, + 23884, 1, 0, 0, 0, 3533, 23891, 1, 0, 0, 0, 3535, 23898, 1, 0, 0, 0, 3537, + 23913, 1, 0, 0, 0, 3539, 23926, 1, 0, 0, 0, 3541, 23932, 1, 0, 0, 0, 3543, + 23942, 1, 0, 0, 0, 3545, 23954, 1, 0, 0, 0, 3547, 23971, 1, 0, 0, 0, 3549, + 23985, 1, 0, 0, 0, 3551, 23998, 1, 0, 0, 0, 3553, 24009, 1, 0, 0, 0, 3555, + 24026, 1, 0, 0, 0, 3557, 24036, 1, 0, 0, 0, 3559, 24043, 1, 0, 0, 0, 3561, + 24057, 1, 0, 0, 0, 3563, 24065, 1, 0, 0, 0, 3565, 24073, 1, 0, 0, 0, 3567, + 24081, 1, 0, 0, 0, 3569, 24089, 1, 0, 0, 0, 3571, 24097, 1, 0, 0, 0, 3573, + 24108, 1, 0, 0, 0, 3575, 24116, 1, 0, 0, 0, 3577, 24124, 1, 0, 0, 0, 3579, + 24137, 1, 0, 0, 0, 3581, 24145, 1, 0, 0, 0, 3583, 24162, 1, 0, 0, 0, 3585, + 24173, 1, 0, 0, 0, 3587, 24180, 1, 0, 0, 0, 3589, 24192, 1, 0, 0, 0, 3591, + 24197, 1, 0, 0, 0, 3593, 24205, 1, 0, 0, 0, 3595, 24209, 1, 0, 0, 0, 3597, + 24216, 1, 0, 0, 0, 3599, 24226, 1, 0, 0, 0, 3601, 24233, 1, 0, 0, 0, 3603, + 24243, 1, 0, 0, 0, 3605, 24256, 1, 0, 0, 0, 3607, 24276, 1, 0, 0, 0, 3609, + 24296, 1, 0, 0, 0, 3611, 24308, 1, 0, 0, 0, 3613, 24316, 1, 0, 0, 0, 3615, + 24323, 1, 0, 0, 0, 3617, 24336, 1, 0, 0, 0, 3619, 24342, 1, 0, 0, 0, 3621, + 24356, 1, 0, 0, 0, 3623, 24374, 1, 0, 0, 0, 3625, 24392, 1, 0, 0, 0, 3627, + 24408, 1, 0, 0, 0, 3629, 24425, 1, 0, 0, 0, 3631, 24442, 1, 0, 0, 0, 3633, + 24462, 1, 0, 0, 0, 3635, 24483, 1, 0, 0, 0, 3637, 24504, 1, 0, 0, 0, 3639, + 24524, 1, 0, 0, 0, 3641, 24537, 1, 0, 0, 0, 3643, 24553, 1, 0, 0, 0, 3645, + 24568, 1, 0, 0, 0, 3647, 24584, 1, 0, 0, 0, 3649, 24598, 1, 0, 0, 0, 3651, + 24612, 1, 0, 0, 0, 3653, 24627, 1, 0, 0, 0, 3655, 24646, 1, 0, 0, 0, 3657, + 24665, 1, 0, 0, 0, 3659, 24680, 1, 0, 0, 0, 3661, 24694, 1, 0, 0, 0, 3663, + 24703, 1, 0, 0, 0, 3665, 24711, 1, 0, 0, 0, 3667, 24717, 1, 0, 0, 0, 3669, + 24736, 1, 0, 0, 0, 3671, 24748, 1, 0, 0, 0, 3673, 24762, 1, 0, 0, 0, 3675, + 24772, 1, 0, 0, 0, 3677, 24779, 1, 0, 0, 0, 3679, 24794, 1, 0, 0, 0, 3681, + 24809, 1, 0, 0, 0, 3683, 24825, 1, 0, 0, 0, 3685, 24836, 1, 0, 0, 0, 3687, + 24851, 1, 0, 0, 0, 3689, 24865, 1, 0, 0, 0, 3691, 24877, 1, 0, 0, 0, 3693, + 24902, 1, 0, 0, 0, 3695, 24922, 1, 0, 0, 0, 3697, 24933, 1, 0, 0, 0, 3699, + 24945, 1, 0, 0, 0, 3701, 24956, 1, 0, 0, 0, 3703, 24968, 1, 0, 0, 0, 3705, + 24989, 1, 0, 0, 0, 3707, 25001, 1, 0, 0, 0, 3709, 25016, 1, 0, 0, 0, 3711, + 25032, 1, 0, 0, 0, 3713, 25046, 1, 0, 0, 0, 3715, 25064, 1, 0, 0, 0, 3717, + 25075, 1, 0, 0, 0, 3719, 25092, 1, 0, 0, 0, 3721, 25110, 1, 0, 0, 0, 3723, + 25124, 1, 0, 0, 0, 3725, 25139, 1, 0, 0, 0, 3727, 25155, 1, 0, 0, 0, 3729, + 25166, 1, 0, 0, 0, 3731, 25178, 1, 0, 0, 0, 3733, 25194, 1, 0, 0, 0, 3735, + 25219, 1, 0, 0, 0, 3737, 25227, 1, 0, 0, 0, 3739, 25242, 1, 0, 0, 0, 3741, + 25258, 1, 0, 0, 0, 3743, 25270, 1, 0, 0, 0, 3745, 25282, 1, 0, 0, 0, 3747, + 25293, 1, 0, 0, 0, 3749, 25304, 1, 0, 0, 0, 3751, 25329, 1, 0, 0, 0, 3753, + 25359, 1, 0, 0, 0, 3755, 25384, 1, 0, 0, 0, 3757, 25412, 1, 0, 0, 0, 3759, + 25434, 1, 0, 0, 0, 3761, 25446, 1, 0, 0, 0, 3763, 25465, 1, 0, 0, 0, 3765, + 25484, 1, 0, 0, 0, 3767, 25501, 1, 0, 0, 0, 3769, 25521, 1, 0, 0, 0, 3771, + 25539, 1, 0, 0, 0, 3773, 25551, 1, 0, 0, 0, 3775, 25562, 1, 0, 0, 0, 3777, + 25577, 1, 0, 0, 0, 3779, 25596, 1, 0, 0, 0, 3781, 25607, 1, 0, 0, 0, 3783, + 25624, 1, 0, 0, 0, 3785, 25641, 1, 0, 0, 0, 3787, 25652, 1, 0, 0, 0, 3789, + 25663, 1, 0, 0, 0, 3791, 25679, 1, 0, 0, 0, 3793, 25694, 1, 0, 0, 0, 3795, + 25710, 1, 0, 0, 0, 3797, 25726, 1, 0, 0, 0, 3799, 25741, 1, 0, 0, 0, 3801, + 25754, 1, 0, 0, 0, 3803, 25770, 1, 0, 0, 0, 3805, 25784, 1, 0, 0, 0, 3807, + 25795, 1, 0, 0, 0, 3809, 25810, 1, 0, 0, 0, 3811, 25823, 1, 0, 0, 0, 3813, + 25834, 1, 0, 0, 0, 3815, 25850, 1, 0, 0, 0, 3817, 25862, 1, 0, 0, 0, 3819, + 25873, 1, 0, 0, 0, 3821, 25885, 1, 0, 0, 0, 3823, 25903, 1, 0, 0, 0, 3825, + 25914, 1, 0, 0, 0, 3827, 25930, 1, 0, 0, 0, 3829, 25945, 1, 0, 0, 0, 3831, + 25956, 1, 0, 0, 0, 3833, 25968, 1, 0, 0, 0, 3835, 25981, 1, 0, 0, 0, 3837, + 25999, 1, 0, 0, 0, 3839, 26016, 1, 0, 0, 0, 3841, 26030, 1, 0, 0, 0, 3843, + 26044, 1, 0, 0, 0, 3845, 26057, 1, 0, 0, 0, 3847, 26071, 1, 0, 0, 0, 3849, + 26086, 1, 0, 0, 0, 3851, 26098, 1, 0, 0, 0, 3853, 26109, 1, 0, 0, 0, 3855, + 26132, 1, 0, 0, 0, 3857, 26147, 1, 0, 0, 0, 3859, 26162, 1, 0, 0, 0, 3861, + 26176, 1, 0, 0, 0, 3863, 26193, 1, 0, 0, 0, 3865, 26208, 1, 0, 0, 0, 3867, + 26227, 1, 0, 0, 0, 3869, 26249, 1, 0, 0, 0, 3871, 26269, 1, 0, 0, 0, 3873, + 26286, 1, 0, 0, 0, 3875, 26305, 1, 0, 0, 0, 3877, 26325, 1, 0, 0, 0, 3879, + 26345, 1, 0, 0, 0, 3881, 26366, 1, 0, 0, 0, 3883, 26383, 1, 0, 0, 0, 3885, + 26398, 1, 0, 0, 0, 3887, 26414, 1, 0, 0, 0, 3889, 26428, 1, 0, 0, 0, 3891, + 26442, 1, 0, 0, 0, 3893, 26456, 1, 0, 0, 0, 3895, 26471, 1, 0, 0, 0, 3897, + 26486, 1, 0, 0, 0, 3899, 26493, 1, 0, 0, 0, 3901, 26506, 1, 0, 0, 0, 3903, + 26517, 1, 0, 0, 0, 3905, 26530, 1, 0, 0, 0, 3907, 26545, 1, 0, 0, 0, 3909, + 26561, 1, 0, 0, 0, 3911, 26573, 1, 0, 0, 0, 3913, 26588, 1, 0, 0, 0, 3915, + 26599, 1, 0, 0, 0, 3917, 26619, 1, 0, 0, 0, 3919, 26639, 1, 0, 0, 0, 3921, + 26652, 1, 0, 0, 0, 3923, 26675, 1, 0, 0, 0, 3925, 26696, 1, 0, 0, 0, 3927, + 26721, 1, 0, 0, 0, 3929, 26743, 1, 0, 0, 0, 3931, 26767, 1, 0, 0, 0, 3933, + 26790, 1, 0, 0, 0, 3935, 26811, 1, 0, 0, 0, 3937, 26833, 1, 0, 0, 0, 3939, + 26854, 1, 0, 0, 0, 3941, 26868, 1, 0, 0, 0, 3943, 26882, 1, 0, 0, 0, 3945, + 26899, 1, 0, 0, 0, 3947, 26915, 1, 0, 0, 0, 3949, 26930, 1, 0, 0, 0, 3951, + 26948, 1, 0, 0, 0, 3953, 26962, 1, 0, 0, 0, 3955, 26981, 1, 0, 0, 0, 3957, + 26997, 1, 0, 0, 0, 3959, 27011, 1, 0, 0, 0, 3961, 27025, 1, 0, 0, 0, 3963, + 27038, 1, 0, 0, 0, 3965, 27051, 1, 0, 0, 0, 3967, 27070, 1, 0, 0, 0, 3969, + 27080, 1, 0, 0, 0, 3971, 27093, 1, 0, 0, 0, 3973, 27106, 1, 0, 0, 0, 3975, + 27119, 1, 0, 0, 0, 3977, 27134, 1, 0, 0, 0, 3979, 27145, 1, 0, 0, 0, 3981, + 27155, 1, 0, 0, 0, 3983, 27171, 1, 0, 0, 0, 3985, 27186, 1, 0, 0, 0, 3987, + 27200, 1, 0, 0, 0, 3989, 27214, 1, 0, 0, 0, 3991, 27228, 1, 0, 0, 0, 3993, + 27240, 1, 0, 0, 0, 3995, 27253, 1, 0, 0, 0, 3997, 27266, 1, 0, 0, 0, 3999, + 27278, 1, 0, 0, 0, 4001, 27292, 1, 0, 0, 0, 4003, 27306, 1, 0, 0, 0, 4005, + 27317, 1, 0, 0, 0, 4007, 27331, 1, 0, 0, 0, 4009, 27349, 1, 0, 0, 0, 4011, + 27361, 1, 0, 0, 0, 4013, 27374, 1, 0, 0, 0, 4015, 27390, 1, 0, 0, 0, 4017, + 27406, 1, 0, 0, 0, 4019, 27418, 1, 0, 0, 0, 4021, 27435, 1, 0, 0, 0, 4023, + 27448, 1, 0, 0, 0, 4025, 27461, 1, 0, 0, 0, 4027, 27474, 1, 0, 0, 0, 4029, + 27488, 1, 0, 0, 0, 4031, 27499, 1, 0, 0, 0, 4033, 27516, 1, 0, 0, 0, 4035, + 27532, 1, 0, 0, 0, 4037, 27545, 1, 0, 0, 0, 4039, 27560, 1, 0, 0, 0, 4041, + 27576, 1, 0, 0, 0, 4043, 27592, 1, 0, 0, 0, 4045, 27604, 1, 0, 0, 0, 4047, + 27618, 1, 0, 0, 0, 4049, 27634, 1, 0, 0, 0, 4051, 27650, 1, 0, 0, 0, 4053, + 27667, 1, 0, 0, 0, 4055, 27681, 1, 0, 0, 0, 4057, 27695, 1, 0, 0, 0, 4059, + 27709, 1, 0, 0, 0, 4061, 27725, 1, 0, 0, 0, 4063, 27739, 1, 0, 0, 0, 4065, + 27753, 1, 0, 0, 0, 4067, 27767, 1, 0, 0, 0, 4069, 27781, 1, 0, 0, 0, 4071, + 27795, 1, 0, 0, 0, 4073, 27809, 1, 0, 0, 0, 4075, 27824, 1, 0, 0, 0, 4077, + 27838, 1, 0, 0, 0, 4079, 27853, 1, 0, 0, 0, 4081, 27868, 1, 0, 0, 0, 4083, + 27882, 1, 0, 0, 0, 4085, 27896, 1, 0, 0, 0, 4087, 27910, 1, 0, 0, 0, 4089, + 27924, 1, 0, 0, 0, 4091, 27938, 1, 0, 0, 0, 4093, 27952, 1, 0, 0, 0, 4095, + 27966, 1, 0, 0, 0, 4097, 27979, 1, 0, 0, 0, 4099, 27993, 1, 0, 0, 0, 4101, + 28007, 1, 0, 0, 0, 4103, 28025, 1, 0, 0, 0, 4105, 28039, 1, 0, 0, 0, 4107, + 28055, 1, 0, 0, 0, 4109, 28070, 1, 0, 0, 0, 4111, 28082, 1, 0, 0, 0, 4113, + 28099, 1, 0, 0, 0, 4115, 28113, 1, 0, 0, 0, 4117, 28129, 1, 0, 0, 0, 4119, + 28143, 1, 0, 0, 0, 4121, 28155, 1, 0, 0, 0, 4123, 28168, 1, 0, 0, 0, 4125, + 28181, 1, 0, 0, 0, 4127, 28199, 1, 0, 0, 0, 4129, 28216, 1, 0, 0, 0, 4131, + 28231, 1, 0, 0, 0, 4133, 28247, 1, 0, 0, 0, 4135, 28261, 1, 0, 0, 0, 4137, + 28277, 1, 0, 0, 0, 4139, 28293, 1, 0, 0, 0, 4141, 28308, 1, 0, 0, 0, 4143, + 28322, 1, 0, 0, 0, 4145, 28340, 1, 0, 0, 0, 4147, 28352, 1, 0, 0, 0, 4149, + 28368, 1, 0, 0, 0, 4151, 28384, 1, 0, 0, 0, 4153, 28401, 1, 0, 0, 0, 4155, + 28403, 1, 0, 0, 0, 4157, 28422, 1, 0, 0, 0, 4159, 28436, 1, 0, 0, 0, 4161, + 28447, 1, 0, 0, 0, 4163, 28454, 1, 0, 0, 0, 4165, 28466, 1, 0, 0, 0, 4167, + 28472, 1, 0, 0, 0, 4169, 28478, 1, 0, 0, 0, 4171, 28482, 1, 0, 0, 0, 4173, + 28487, 1, 0, 0, 0, 4175, 28491, 1, 0, 0, 0, 4177, 28511, 1, 0, 0, 0, 4179, + 28520, 1, 0, 0, 0, 4181, 28529, 1, 0, 0, 0, 4183, 28544, 1, 0, 0, 0, 4185, + 28554, 1, 0, 0, 0, 4187, 28565, 1, 0, 0, 0, 4189, 28576, 1, 0, 0, 0, 4191, + 28581, 1, 0, 0, 0, 4193, 28586, 1, 0, 0, 0, 4195, 28595, 1, 0, 0, 0, 4197, + 28600, 1, 0, 0, 0, 4199, 28605, 1, 0, 0, 0, 4201, 28609, 1, 0, 0, 0, 4203, + 28615, 1, 0, 0, 0, 4205, 28622, 1, 0, 0, 0, 4207, 28630, 1, 0, 0, 0, 4209, + 28635, 1, 0, 0, 0, 4211, 28640, 1, 0, 0, 0, 4213, 28648, 1, 0, 0, 0, 4215, + 28676, 1, 0, 0, 0, 4217, 28686, 1, 0, 0, 0, 4219, 28713, 1, 0, 0, 0, 4221, + 28737, 1, 0, 0, 0, 4223, 28743, 1, 0, 0, 0, 4225, 28748, 1, 0, 0, 0, 4227, + 28757, 1, 0, 0, 0, 4229, 28771, 1, 0, 0, 0, 4231, 28785, 1, 0, 0, 0, 4233, + 28801, 1, 0, 0, 0, 4235, 28817, 1, 0, 0, 0, 4237, 28833, 1, 0, 0, 0, 4239, + 28843, 1, 0, 0, 0, 4241, 28850, 1, 0, 0, 0, 4243, 28858, 1, 0, 0, 0, 4245, + 28865, 1, 0, 0, 0, 4247, 28873, 1, 0, 0, 0, 4249, 28882, 1, 0, 0, 0, 4251, + 28899, 1, 0, 0, 0, 4253, 28915, 1, 0, 0, 0, 4255, 28923, 1, 0, 0, 0, 4257, + 28931, 1, 0, 0, 0, 4259, 28945, 1, 0, 0, 0, 4261, 28952, 1, 0, 0, 0, 4263, + 28966, 1, 0, 0, 0, 4265, 28975, 1, 0, 0, 0, 4267, 28984, 1, 0, 0, 0, 4269, + 28994, 1, 0, 0, 0, 4271, 29003, 1, 0, 0, 0, 4273, 29018, 1, 0, 0, 0, 4275, + 29031, 1, 0, 0, 0, 4277, 29047, 1, 0, 0, 0, 4279, 29055, 1, 0, 0, 0, 4281, + 29066, 1, 0, 0, 0, 4283, 29069, 1, 0, 0, 0, 4285, 29083, 1, 0, 0, 0, 4287, + 29089, 1, 0, 0, 0, 4289, 29097, 1, 0, 0, 0, 4291, 29106, 1, 0, 0, 0, 4293, + 29115, 1, 0, 0, 0, 4295, 29127, 1, 0, 0, 0, 4297, 29137, 1, 0, 0, 0, 4299, + 29148, 1, 0, 0, 0, 4301, 29171, 1, 0, 0, 0, 4303, 29184, 1, 0, 0, 0, 4305, + 29195, 1, 0, 0, 0, 4307, 29205, 1, 0, 0, 0, 4309, 29217, 1, 0, 0, 0, 4311, + 29223, 1, 0, 0, 0, 4313, 29232, 1, 0, 0, 0, 4315, 29240, 1, 0, 0, 0, 4317, + 29245, 1, 0, 0, 0, 4319, 29254, 1, 0, 0, 0, 4321, 29260, 1, 0, 0, 0, 4323, + 29268, 1, 0, 0, 0, 4325, 29274, 1, 0, 0, 0, 4327, 29281, 1, 0, 0, 0, 4329, + 29284, 1, 0, 0, 0, 4331, 29290, 1, 0, 0, 0, 4333, 29295, 1, 0, 0, 0, 4335, + 29305, 1, 0, 0, 0, 4337, 29309, 1, 0, 0, 0, 4339, 29313, 1, 0, 0, 0, 4341, + 29318, 1, 0, 0, 0, 4343, 29322, 1, 0, 0, 0, 4345, 29326, 1, 0, 0, 0, 4347, + 29337, 1, 0, 0, 0, 4349, 29347, 1, 0, 0, 0, 4351, 29355, 1, 0, 0, 0, 4353, + 29369, 1, 0, 0, 0, 4355, 29375, 1, 0, 0, 0, 4357, 29380, 1, 0, 0, 0, 4359, + 29387, 1, 0, 0, 0, 4361, 29395, 1, 0, 0, 0, 4363, 29401, 1, 0, 0, 0, 4365, + 29411, 1, 0, 0, 0, 4367, 29418, 1, 0, 0, 0, 4369, 29425, 1, 0, 0, 0, 4371, + 29435, 1, 0, 0, 0, 4373, 29442, 1, 0, 0, 0, 4375, 29449, 1, 0, 0, 0, 4377, + 29459, 1, 0, 0, 0, 4379, 29487, 1, 0, 0, 0, 4381, 29517, 1, 0, 0, 0, 4383, + 29535, 1, 0, 0, 0, 4385, 29542, 1, 0, 0, 0, 4387, 29551, 1, 0, 0, 0, 4389, + 29559, 1, 0, 0, 0, 4391, 29566, 1, 0, 0, 0, 4393, 29578, 1, 0, 0, 0, 4395, + 29588, 1, 0, 0, 0, 4397, 29602, 1, 0, 0, 0, 4399, 29615, 1, 0, 0, 0, 4401, + 29624, 1, 0, 0, 0, 4403, 29636, 1, 0, 0, 0, 4405, 29642, 1, 0, 0, 0, 4407, + 29651, 1, 0, 0, 0, 4409, 29658, 1, 0, 0, 0, 4411, 29668, 1, 0, 0, 0, 4413, + 29676, 1, 0, 0, 0, 4415, 29683, 1, 0, 0, 0, 4417, 29693, 1, 0, 0, 0, 4419, + 29705, 1, 0, 0, 0, 4421, 29719, 1, 0, 0, 0, 4423, 29727, 1, 0, 0, 0, 4425, + 29733, 1, 0, 0, 0, 4427, 29740, 1, 0, 0, 0, 4429, 29747, 1, 0, 0, 0, 4431, + 29754, 1, 0, 0, 0, 4433, 29760, 1, 0, 0, 0, 4435, 29769, 1, 0, 0, 0, 4437, + 29780, 1, 0, 0, 0, 4439, 29789, 1, 0, 0, 0, 4441, 29810, 1, 0, 0, 0, 4443, + 29836, 1, 0, 0, 0, 4445, 29845, 1, 0, 0, 0, 4447, 29867, 1, 0, 0, 0, 4449, + 29889, 1, 0, 0, 0, 4451, 29909, 1, 0, 0, 0, 4453, 29919, 1, 0, 0, 0, 4455, + 29926, 1, 0, 0, 0, 4457, 29944, 1, 0, 0, 0, 4459, 29965, 1, 0, 0, 0, 4461, + 29975, 1, 0, 0, 0, 4463, 29988, 1, 0, 0, 0, 4465, 29996, 1, 0, 0, 0, 4467, + 30006, 1, 0, 0, 0, 4469, 30022, 1, 0, 0, 0, 4471, 30028, 1, 0, 0, 0, 4473, + 30045, 1, 0, 0, 0, 4475, 30050, 1, 0, 0, 0, 4477, 30059, 1, 0, 0, 0, 4479, + 30079, 1, 0, 0, 0, 4481, 30097, 1, 0, 0, 0, 4483, 30101, 1, 0, 0, 0, 4485, + 30124, 1, 0, 0, 0, 4487, 30143, 1, 0, 0, 0, 4489, 30159, 1, 0, 0, 0, 4491, + 30174, 1, 0, 0, 0, 4493, 30180, 1, 0, 0, 0, 4495, 30188, 1, 0, 0, 0, 4497, + 30196, 1, 0, 0, 0, 4499, 30202, 1, 0, 0, 0, 4501, 30207, 1, 0, 0, 0, 4503, + 30210, 1, 0, 0, 0, 4505, 30213, 1, 0, 0, 0, 4507, 30222, 1, 0, 0, 0, 4509, + 30242, 1, 0, 0, 0, 4511, 30253, 1, 0, 0, 0, 4513, 30268, 1, 0, 0, 0, 4515, + 30275, 1, 0, 0, 0, 4517, 30281, 1, 0, 0, 0, 4519, 30290, 1, 0, 0, 0, 4521, + 30298, 1, 0, 0, 0, 4523, 30307, 1, 0, 0, 0, 4525, 30316, 1, 0, 0, 0, 4527, + 30323, 1, 0, 0, 0, 4529, 30331, 1, 0, 0, 0, 4531, 30339, 1, 0, 0, 0, 4533, + 30347, 1, 0, 0, 0, 4535, 30354, 1, 0, 0, 0, 4537, 30363, 1, 0, 0, 0, 4539, + 30371, 1, 0, 0, 0, 4541, 30389, 1, 0, 0, 0, 4543, 30401, 1, 0, 0, 0, 4545, + 30423, 1, 0, 0, 0, 4547, 30445, 1, 0, 0, 0, 4549, 30462, 1, 0, 0, 0, 4551, + 30471, 1, 0, 0, 0, 4553, 30478, 1, 0, 0, 0, 4555, 30489, 1, 0, 0, 0, 4557, + 30505, 1, 0, 0, 0, 4559, 30522, 1, 0, 0, 0, 4561, 30541, 1, 0, 0, 0, 4563, + 30559, 1, 0, 0, 0, 4565, 30578, 1, 0, 0, 0, 4567, 30587, 1, 0, 0, 0, 4569, + 30600, 1, 0, 0, 0, 4571, 30608, 1, 0, 0, 0, 4573, 30613, 1, 0, 0, 0, 4575, + 30623, 1, 0, 0, 0, 4577, 30631, 1, 0, 0, 0, 4579, 30642, 1, 0, 0, 0, 4581, + 30650, 1, 0, 0, 0, 4583, 30657, 1, 0, 0, 0, 4585, 30663, 1, 0, 0, 0, 4587, + 30668, 1, 0, 0, 0, 4589, 30675, 1, 0, 0, 0, 4591, 30683, 1, 0, 0, 0, 4593, + 30689, 1, 0, 0, 0, 4595, 30694, 1, 0, 0, 0, 4597, 30705, 1, 0, 0, 0, 4599, + 30714, 1, 0, 0, 0, 4601, 30719, 1, 0, 0, 0, 4603, 30725, 1, 0, 0, 0, 4605, + 30731, 1, 0, 0, 0, 4607, 30742, 1, 0, 0, 0, 4609, 30755, 1, 0, 0, 0, 4611, + 30762, 1, 0, 0, 0, 4613, 30770, 1, 0, 0, 0, 4615, 30781, 1, 0, 0, 0, 4617, + 30786, 1, 0, 0, 0, 4619, 30791, 1, 0, 0, 0, 4621, 30800, 1, 0, 0, 0, 4623, + 30808, 1, 0, 0, 0, 4625, 30816, 1, 0, 0, 0, 4627, 30822, 1, 0, 0, 0, 4629, + 30842, 1, 0, 0, 0, 4631, 30846, 1, 0, 0, 0, 4633, 30858, 1, 0, 0, 0, 4635, + 30862, 1, 0, 0, 0, 4637, 30873, 1, 0, 0, 0, 4639, 30880, 1, 0, 0, 0, 4641, + 30894, 1, 0, 0, 0, 4643, 30902, 1, 0, 0, 0, 4645, 30911, 1, 0, 0, 0, 4647, + 30924, 1, 0, 0, 0, 4649, 30935, 1, 0, 0, 0, 4651, 30945, 1, 0, 0, 0, 4653, + 30953, 1, 0, 0, 0, 4655, 30970, 1, 0, 0, 0, 4657, 30981, 1, 0, 0, 0, 4659, + 30992, 1, 0, 0, 0, 4661, 31002, 1, 0, 0, 0, 4663, 31012, 1, 0, 0, 0, 4665, + 31021, 1, 0, 0, 0, 4667, 31048, 1, 0, 0, 0, 4669, 31065, 1, 0, 0, 0, 4671, + 31086, 1, 0, 0, 0, 4673, 31096, 1, 0, 0, 0, 4675, 31107, 1, 0, 0, 0, 4677, + 31121, 1, 0, 0, 0, 4679, 31130, 1, 0, 0, 0, 4681, 31139, 1, 0, 0, 0, 4683, + 31145, 1, 0, 0, 0, 4685, 31157, 1, 0, 0, 0, 4687, 31166, 1, 0, 0, 0, 4689, + 31174, 1, 0, 0, 0, 4691, 31184, 1, 0, 0, 0, 4693, 31197, 1, 0, 0, 0, 4695, + 31206, 1, 0, 0, 0, 4697, 31213, 1, 0, 0, 0, 4699, 31230, 1, 0, 0, 0, 4701, + 31243, 1, 0, 0, 0, 4703, 31251, 1, 0, 0, 0, 4705, 31255, 1, 0, 0, 0, 4707, + 31266, 1, 0, 0, 0, 4709, 31281, 1, 0, 0, 0, 4711, 31284, 1, 0, 0, 0, 4713, + 31295, 1, 0, 0, 0, 4715, 31301, 1, 0, 0, 0, 4717, 31306, 1, 0, 0, 0, 4719, + 31320, 1, 0, 0, 0, 4721, 31324, 1, 0, 0, 0, 4723, 31349, 1, 0, 0, 0, 4725, + 31357, 1, 0, 0, 0, 4727, 31362, 1, 0, 0, 0, 4729, 31368, 1, 0, 0, 0, 4731, + 31379, 1, 0, 0, 0, 4733, 31397, 1, 0, 0, 0, 4735, 31413, 1, 0, 0, 0, 4737, + 31432, 1, 0, 0, 0, 4739, 31455, 1, 0, 0, 0, 4741, 31470, 1, 0, 0, 0, 4743, + 31481, 1, 0, 0, 0, 4745, 31489, 1, 0, 0, 0, 4747, 31499, 1, 0, 0, 0, 4749, + 31510, 1, 0, 0, 0, 4751, 31521, 1, 0, 0, 0, 4753, 31530, 1, 0, 0, 0, 4755, + 31538, 1, 0, 0, 0, 4757, 31543, 1, 0, 0, 0, 4759, 31553, 1, 0, 0, 0, 4761, + 31569, 1, 0, 0, 0, 4763, 31581, 1, 0, 0, 0, 4765, 31593, 1, 0, 0, 0, 4767, + 31607, 1, 0, 0, 0, 4769, 31618, 1, 0, 0, 0, 4771, 31626, 1, 0, 0, 0, 4773, + 31631, 1, 0, 0, 0, 4775, 31639, 1, 0, 0, 0, 4777, 31644, 1, 0, 0, 0, 4779, + 31650, 1, 0, 0, 0, 4781, 31660, 1, 0, 0, 0, 4783, 31670, 1, 0, 0, 0, 4785, + 31681, 1, 0, 0, 0, 4787, 31689, 1, 0, 0, 0, 4789, 31702, 1, 0, 0, 0, 4791, + 31718, 1, 0, 0, 0, 4793, 31734, 1, 0, 0, 0, 4795, 31739, 1, 0, 0, 0, 4797, + 31743, 1, 0, 0, 0, 4799, 31748, 1, 0, 0, 0, 4801, 31755, 1, 0, 0, 0, 4803, + 31762, 1, 0, 0, 0, 4805, 31766, 1, 0, 0, 0, 4807, 31775, 1, 0, 0, 0, 4809, + 31792, 1, 0, 0, 0, 4811, 31797, 1, 0, 0, 0, 4813, 31801, 1, 0, 0, 0, 4815, + 31808, 1, 0, 0, 0, 4817, 31820, 1, 0, 0, 0, 4819, 31824, 1, 0, 0, 0, 4821, + 31830, 1, 0, 0, 0, 4823, 31834, 1, 0, 0, 0, 4825, 31850, 1, 0, 0, 0, 4827, + 31856, 1, 0, 0, 0, 4829, 31862, 1, 0, 0, 0, 4831, 31873, 1, 0, 0, 0, 4833, + 31880, 1, 0, 0, 0, 4835, 31888, 1, 0, 0, 0, 4837, 31893, 1, 0, 0, 0, 4839, + 31897, 1, 0, 0, 0, 4841, 31904, 1, 0, 0, 0, 4843, 31909, 1, 0, 0, 0, 4845, + 31918, 1, 0, 0, 0, 4847, 31924, 1, 0, 0, 0, 4849, 31933, 1, 0, 0, 0, 4851, + 31941, 1, 0, 0, 0, 4853, 31951, 1, 0, 0, 0, 4855, 31963, 1, 0, 0, 0, 4857, + 31972, 1, 0, 0, 0, 4859, 31979, 1, 0, 0, 0, 4861, 31986, 1, 0, 0, 0, 4863, + 31998, 1, 0, 0, 0, 4865, 32010, 1, 0, 0, 0, 4867, 32017, 1, 0, 0, 0, 4869, + 32021, 1, 0, 0, 0, 4871, 32031, 1, 0, 0, 0, 4873, 32044, 1, 0, 0, 0, 4875, + 32060, 1, 0, 0, 0, 4877, 32074, 1, 0, 0, 0, 4879, 32077, 1, 0, 0, 0, 4881, + 32080, 1, 0, 0, 0, 4883, 32084, 1, 0, 0, 0, 4885, 32102, 1, 0, 0, 0, 4887, + 32114, 1, 0, 0, 0, 4889, 32133, 1, 0, 0, 0, 4891, 32142, 1, 0, 0, 0, 4893, + 32151, 1, 0, 0, 0, 4895, 32160, 1, 0, 0, 0, 4897, 32169, 1, 0, 0, 0, 4899, + 32178, 1, 0, 0, 0, 4901, 32187, 1, 0, 0, 0, 4903, 32196, 1, 0, 0, 0, 4905, + 32205, 1, 0, 0, 0, 4907, 32214, 1, 0, 0, 0, 4909, 32223, 1, 0, 0, 0, 4911, + 32232, 1, 0, 0, 0, 4913, 32242, 1, 0, 0, 0, 4915, 32244, 1, 0, 0, 0, 4917, + 32246, 1, 0, 0, 0, 4919, 32248, 1, 0, 0, 0, 4921, 32250, 1, 0, 0, 0, 4923, + 32253, 1, 0, 0, 0, 4925, 32255, 1, 0, 0, 0, 4927, 32257, 1, 0, 0, 0, 4929, + 32259, 1, 0, 0, 0, 4931, 32261, 1, 0, 0, 0, 4933, 32263, 1, 0, 0, 0, 4935, + 32265, 1, 0, 0, 0, 4937, 32267, 1, 0, 0, 0, 4939, 32270, 1, 0, 0, 0, 4941, + 32272, 1, 0, 0, 0, 4943, 32274, 1, 0, 0, 0, 4945, 32276, 1, 0, 0, 0, 4947, + 32292, 1, 0, 0, 0, 4949, 32302, 1, 0, 0, 0, 4951, 32304, 1, 0, 0, 0, 4953, + 32306, 1, 0, 0, 0, 4955, 32308, 1, 0, 0, 0, 4957, 32310, 1, 0, 0, 0, 4959, + 32312, 1, 0, 0, 0, 4961, 32314, 1, 0, 0, 0, 4963, 32316, 1, 0, 0, 0, 4965, + 32318, 1, 0, 0, 0, 4967, 32320, 1, 0, 0, 0, 4969, 32322, 1, 0, 0, 0, 4971, + 32324, 1, 0, 0, 0, 4973, 32326, 1, 0, 0, 0, 4975, 32328, 1, 0, 0, 0, 4977, + 32341, 1, 0, 0, 0, 4979, 32355, 1, 0, 0, 0, 4981, 32378, 1, 0, 0, 0, 4983, + 32399, 1, 0, 0, 0, 4985, 32407, 1, 0, 0, 0, 4987, 32417, 1, 0, 0, 0, 4989, + 32425, 1, 0, 0, 0, 4991, 32427, 1, 0, 0, 0, 4993, 32429, 1, 0, 0, 0, 4995, + 32434, 1, 0, 0, 0, 4997, 32446, 1, 0, 0, 0, 4999, 32450, 1, 0, 0, 0, 5001, + 5002, 7, 0, 0, 0, 5002, 5003, 7, 1, 0, 0, 5003, 5004, 7, 2, 0, 0, 5004, + 5005, 7, 3, 0, 0, 5005, 5006, 7, 4, 0, 0, 5006, 2, 1, 0, 0, 0, 5007, 5008, + 7, 0, 0, 0, 5008, 5009, 7, 1, 0, 0, 5009, 5010, 7, 5, 0, 0, 5010, 4, 1, + 0, 0, 0, 5011, 5012, 7, 0, 0, 0, 5012, 5013, 7, 1, 0, 0, 5013, 5014, 7, + 5, 0, 0, 5014, 5015, 7, 6, 0, 0, 5015, 5016, 7, 7, 0, 0, 5016, 5017, 7, + 4, 0, 0, 5017, 6, 1, 0, 0, 0, 5018, 5019, 7, 0, 0, 0, 5019, 5020, 7, 8, + 0, 0, 5020, 5021, 7, 8, 0, 0, 5021, 5022, 7, 6, 0, 0, 5022, 5023, 7, 5, + 0, 0, 5023, 5024, 7, 5, 0, 0, 5024, 8, 1, 0, 0, 0, 5025, 5026, 7, 0, 0, + 0, 5026, 5027, 7, 8, 0, 0, 5027, 5028, 7, 8, 0, 0, 5028, 5029, 7, 6, 0, + 0, 5029, 5030, 7, 5, 0, 0, 5030, 5031, 7, 5, 0, 0, 5031, 5032, 7, 6, 0, + 0, 5032, 5033, 7, 9, 0, 0, 5033, 10, 1, 0, 0, 0, 5034, 5035, 7, 0, 0, 0, + 5035, 5036, 7, 8, 0, 0, 5036, 5037, 7, 8, 0, 0, 5037, 5038, 7, 6, 0, 0, + 5038, 5039, 7, 5, 0, 0, 5039, 5040, 7, 5, 0, 0, 5040, 5041, 7, 10, 0, 0, + 5041, 5042, 7, 1, 0, 0, 5042, 5043, 7, 11, 0, 0, 5043, 5044, 7, 6, 0, 0, + 5044, 12, 1, 0, 0, 0, 5045, 5046, 7, 0, 0, 0, 5046, 5047, 7, 8, 0, 0, 5047, + 5048, 7, 8, 0, 0, 5048, 5049, 7, 2, 0, 0, 5049, 5050, 7, 12, 0, 0, 5050, + 5051, 7, 7, 0, 0, 5051, 5052, 7, 4, 0, 0, 5052, 14, 1, 0, 0, 0, 5053, 5054, + 7, 0, 0, 0, 5054, 5055, 7, 8, 0, 0, 5055, 5056, 7, 11, 0, 0, 5056, 16, + 1, 0, 0, 0, 5057, 5058, 7, 0, 0, 0, 5058, 5059, 7, 8, 0, 0, 5059, 5060, + 7, 2, 0, 0, 5060, 5061, 7, 5, 0, 0, 5061, 18, 1, 0, 0, 0, 5062, 5063, 7, + 0, 0, 0, 5063, 5064, 7, 8, 0, 0, 5064, 5065, 7, 3, 0, 0, 5065, 5066, 7, + 2, 0, 0, 5066, 5067, 7, 5, 0, 0, 5067, 5068, 7, 5, 0, 0, 5068, 20, 1, 0, + 0, 0, 5069, 5070, 7, 0, 0, 0, 5070, 5071, 7, 8, 0, 0, 5071, 5072, 7, 4, + 0, 0, 5072, 5073, 7, 10, 0, 0, 5073, 5074, 7, 2, 0, 0, 5074, 5075, 7, 7, + 0, 0, 5075, 22, 1, 0, 0, 0, 5076, 5077, 7, 0, 0, 0, 5077, 5078, 7, 8, 0, + 0, 5078, 5079, 7, 4, 0, 0, 5079, 5080, 7, 10, 0, 0, 5080, 5081, 7, 2, 0, + 0, 5081, 5082, 7, 7, 0, 0, 5082, 5083, 7, 5, 0, 0, 5083, 24, 1, 0, 0, 0, + 5084, 5085, 7, 0, 0, 0, 5085, 5086, 7, 8, 0, 0, 5086, 5087, 7, 4, 0, 0, + 5087, 5088, 7, 10, 0, 0, 5088, 5089, 7, 13, 0, 0, 5089, 5090, 7, 0, 0, + 0, 5090, 5091, 7, 4, 0, 0, 5091, 5092, 7, 6, 0, 0, 5092, 26, 1, 0, 0, 0, + 5093, 5094, 7, 0, 0, 0, 5094, 5095, 7, 8, 0, 0, 5095, 5096, 7, 4, 0, 0, + 5096, 5097, 7, 10, 0, 0, 5097, 5098, 7, 13, 0, 0, 5098, 5099, 7, 6, 0, + 0, 5099, 28, 1, 0, 0, 0, 5100, 5101, 7, 0, 0, 0, 5101, 5102, 7, 8, 0, 0, + 5102, 5103, 7, 4, 0, 0, 5103, 5104, 7, 10, 0, 0, 5104, 5105, 7, 13, 0, + 0, 5105, 5106, 7, 6, 0, 0, 5106, 5107, 5, 95, 0, 0, 5107, 5108, 7, 8, 0, + 0, 5108, 5109, 7, 2, 0, 0, 5109, 5110, 7, 14, 0, 0, 5110, 5111, 7, 15, + 0, 0, 5111, 5112, 7, 2, 0, 0, 5112, 5113, 7, 7, 0, 0, 5113, 5114, 7, 6, + 0, 0, 5114, 5115, 7, 7, 0, 0, 5115, 5116, 7, 4, 0, 0, 5116, 30, 1, 0, 0, + 0, 5117, 5118, 7, 0, 0, 0, 5118, 5119, 7, 8, 0, 0, 5119, 5120, 7, 4, 0, + 0, 5120, 5121, 7, 10, 0, 0, 5121, 5122, 7, 13, 0, 0, 5122, 5123, 7, 6, + 0, 0, 5123, 5124, 5, 95, 0, 0, 5124, 5125, 7, 9, 0, 0, 5125, 5126, 7, 0, + 0, 0, 5126, 5127, 7, 4, 0, 0, 5127, 5128, 7, 0, 0, 0, 5128, 32, 1, 0, 0, + 0, 5129, 5130, 7, 0, 0, 0, 5130, 5131, 7, 8, 0, 0, 5131, 5132, 7, 4, 0, + 0, 5132, 5133, 7, 10, 0, 0, 5133, 5134, 7, 13, 0, 0, 5134, 5135, 7, 6, + 0, 0, 5135, 5136, 5, 95, 0, 0, 5136, 5137, 7, 16, 0, 0, 5137, 5138, 7, + 12, 0, 0, 5138, 5139, 7, 7, 0, 0, 5139, 5140, 7, 8, 0, 0, 5140, 5141, 7, + 4, 0, 0, 5141, 5142, 7, 10, 0, 0, 5142, 5143, 7, 2, 0, 0, 5143, 5144, 7, + 7, 0, 0, 5144, 34, 1, 0, 0, 0, 5145, 5146, 7, 0, 0, 0, 5146, 5147, 7, 8, + 0, 0, 5147, 5148, 7, 4, 0, 0, 5148, 5149, 7, 10, 0, 0, 5149, 5150, 7, 13, + 0, 0, 5150, 5151, 7, 6, 0, 0, 5151, 5152, 5, 95, 0, 0, 5152, 5153, 7, 4, + 0, 0, 5153, 5154, 7, 0, 0, 0, 5154, 5155, 7, 17, 0, 0, 5155, 36, 1, 0, + 0, 0, 5156, 5157, 7, 0, 0, 0, 5157, 5158, 7, 8, 0, 0, 5158, 5159, 7, 4, + 0, 0, 5159, 5160, 7, 10, 0, 0, 5160, 5161, 7, 13, 0, 0, 5161, 5162, 7, + 10, 0, 0, 5162, 5163, 7, 4, 0, 0, 5163, 5164, 7, 18, 0, 0, 5164, 38, 1, + 0, 0, 0, 5165, 5166, 7, 0, 0, 0, 5166, 5167, 7, 9, 0, 0, 5167, 5168, 7, + 0, 0, 0, 5168, 5169, 7, 15, 0, 0, 5169, 5170, 7, 4, 0, 0, 5170, 5171, 7, + 10, 0, 0, 5171, 5172, 7, 13, 0, 0, 5172, 5173, 7, 6, 0, 0, 5173, 5174, + 5, 95, 0, 0, 5174, 5175, 7, 15, 0, 0, 5175, 5176, 7, 11, 0, 0, 5176, 5177, + 7, 0, 0, 0, 5177, 5178, 7, 7, 0, 0, 5178, 40, 1, 0, 0, 0, 5179, 5180, 7, + 0, 0, 0, 5180, 5181, 7, 9, 0, 0, 5181, 5182, 7, 9, 0, 0, 5182, 42, 1, 0, + 0, 0, 5183, 5184, 7, 0, 0, 0, 5184, 5185, 7, 9, 0, 0, 5185, 5186, 7, 9, + 0, 0, 5186, 5187, 5, 95, 0, 0, 5187, 5188, 7, 8, 0, 0, 5188, 5189, 7, 2, + 0, 0, 5189, 5190, 7, 11, 0, 0, 5190, 5191, 7, 12, 0, 0, 5191, 5192, 7, + 14, 0, 0, 5192, 5193, 7, 7, 0, 0, 5193, 44, 1, 0, 0, 0, 5194, 5195, 7, + 0, 0, 0, 5195, 5196, 7, 9, 0, 0, 5196, 5197, 7, 9, 0, 0, 5197, 5198, 5, + 95, 0, 0, 5198, 5199, 7, 17, 0, 0, 5199, 5200, 7, 3, 0, 0, 5200, 5201, + 7, 2, 0, 0, 5201, 5202, 7, 12, 0, 0, 5202, 5203, 7, 15, 0, 0, 5203, 46, + 1, 0, 0, 0, 5204, 5205, 7, 0, 0, 0, 5205, 5206, 7, 9, 0, 0, 5206, 5207, + 7, 9, 0, 0, 5207, 5208, 5, 95, 0, 0, 5208, 5209, 7, 14, 0, 0, 5209, 5210, + 7, 2, 0, 0, 5210, 5211, 7, 7, 0, 0, 5211, 5212, 7, 4, 0, 0, 5212, 5213, + 7, 19, 0, 0, 5213, 5214, 7, 5, 0, 0, 5214, 48, 1, 0, 0, 0, 5215, 5216, + 7, 0, 0, 0, 5216, 5217, 7, 9, 0, 0, 5217, 5218, 7, 20, 0, 0, 5218, 5219, + 5, 95, 0, 0, 5219, 5220, 7, 9, 0, 0, 5220, 5221, 7, 0, 0, 0, 5221, 5222, + 7, 4, 0, 0, 5222, 5223, 7, 6, 0, 0, 5223, 50, 1, 0, 0, 0, 5224, 5225, 7, + 0, 0, 0, 5225, 5226, 7, 9, 0, 0, 5226, 5227, 7, 14, 0, 0, 5227, 5228, 7, + 10, 0, 0, 5228, 5229, 7, 7, 0, 0, 5229, 52, 1, 0, 0, 0, 5230, 5231, 7, + 0, 0, 0, 5231, 5232, 7, 9, 0, 0, 5232, 5233, 7, 14, 0, 0, 5233, 5234, 7, + 10, 0, 0, 5234, 5235, 7, 7, 0, 0, 5235, 5236, 7, 10, 0, 0, 5236, 5237, + 7, 5, 0, 0, 5237, 5238, 7, 4, 0, 0, 5238, 5239, 7, 6, 0, 0, 5239, 5240, + 7, 3, 0, 0, 5240, 54, 1, 0, 0, 0, 5241, 5242, 7, 0, 0, 0, 5242, 5243, 7, + 9, 0, 0, 5243, 5244, 7, 14, 0, 0, 5244, 5245, 7, 10, 0, 0, 5245, 5246, + 7, 7, 0, 0, 5246, 5247, 7, 10, 0, 0, 5247, 5248, 7, 5, 0, 0, 5248, 5249, + 7, 4, 0, 0, 5249, 5250, 7, 3, 0, 0, 5250, 5251, 7, 0, 0, 0, 5251, 5252, + 7, 4, 0, 0, 5252, 5253, 7, 2, 0, 0, 5253, 5254, 7, 3, 0, 0, 5254, 56, 1, + 0, 0, 0, 5255, 5256, 7, 0, 0, 0, 5256, 5257, 7, 9, 0, 0, 5257, 5258, 7, + 13, 0, 0, 5258, 5259, 7, 0, 0, 0, 5259, 5260, 7, 7, 0, 0, 5260, 5261, 7, + 8, 0, 0, 5261, 5262, 7, 6, 0, 0, 5262, 5263, 7, 9, 0, 0, 5263, 58, 1, 0, + 0, 0, 5264, 5265, 7, 0, 0, 0, 5265, 5266, 7, 9, 0, 0, 5266, 5267, 7, 13, + 0, 0, 5267, 5268, 7, 10, 0, 0, 5268, 5269, 7, 5, 0, 0, 5269, 5270, 7, 6, + 0, 0, 5270, 60, 1, 0, 0, 0, 5271, 5272, 7, 0, 0, 0, 5272, 5273, 7, 9, 0, + 0, 5273, 5274, 7, 13, 0, 0, 5274, 5275, 7, 10, 0, 0, 5275, 5276, 7, 5, + 0, 0, 5276, 5277, 7, 2, 0, 0, 5277, 5278, 7, 3, 0, 0, 5278, 62, 1, 0, 0, + 0, 5279, 5280, 7, 0, 0, 0, 5280, 5281, 7, 16, 0, 0, 5281, 5282, 7, 9, 0, + 0, 5282, 5283, 5, 95, 0, 0, 5283, 5284, 7, 9, 0, 0, 5284, 5285, 7, 10, + 0, 0, 5285, 5286, 7, 5, 0, 0, 5286, 5287, 7, 21, 0, 0, 5287, 5288, 7, 5, + 0, 0, 5288, 5289, 7, 4, 0, 0, 5289, 5290, 7, 3, 0, 0, 5290, 5291, 7, 10, + 0, 0, 5291, 5292, 7, 7, 0, 0, 5292, 5293, 7, 17, 0, 0, 5293, 64, 1, 0, + 0, 0, 5294, 5295, 7, 0, 0, 0, 5295, 5296, 7, 16, 0, 0, 5296, 5297, 7, 4, + 0, 0, 5297, 5298, 7, 6, 0, 0, 5298, 5299, 7, 3, 0, 0, 5299, 66, 1, 0, 0, + 0, 5300, 5301, 7, 0, 0, 0, 5301, 5302, 7, 17, 0, 0, 5302, 5303, 7, 6, 0, + 0, 5303, 5304, 7, 7, 0, 0, 5304, 5305, 7, 4, 0, 0, 5305, 68, 1, 0, 0, 0, + 5306, 5307, 7, 0, 0, 0, 5307, 5308, 7, 17, 0, 0, 5308, 5309, 7, 17, 0, + 0, 5309, 5310, 7, 3, 0, 0, 5310, 5311, 7, 6, 0, 0, 5311, 5312, 7, 17, 0, + 0, 5312, 5313, 7, 0, 0, 0, 5313, 5314, 7, 4, 0, 0, 5314, 5315, 7, 6, 0, + 0, 5315, 70, 1, 0, 0, 0, 5316, 5317, 7, 0, 0, 0, 5317, 72, 1, 0, 0, 0, + 5318, 5319, 7, 0, 0, 0, 5319, 5320, 7, 11, 0, 0, 5320, 5321, 7, 10, 0, + 0, 5321, 5322, 7, 0, 0, 0, 5322, 5323, 7, 5, 0, 0, 5323, 74, 1, 0, 0, 0, + 5324, 5325, 7, 0, 0, 0, 5325, 5326, 7, 11, 0, 0, 5326, 5327, 7, 11, 0, + 0, 5327, 76, 1, 0, 0, 0, 5328, 5329, 7, 0, 0, 0, 5329, 5330, 7, 11, 0, + 0, 5330, 5331, 7, 11, 0, 0, 5331, 5332, 7, 2, 0, 0, 5332, 5333, 7, 8, 0, + 0, 5333, 5334, 7, 0, 0, 0, 5334, 5335, 7, 4, 0, 0, 5335, 5336, 7, 6, 0, + 0, 5336, 78, 1, 0, 0, 0, 5337, 5338, 7, 0, 0, 0, 5338, 5339, 7, 11, 0, + 0, 5339, 5340, 7, 11, 0, 0, 5340, 5341, 7, 2, 0, 0, 5341, 5342, 7, 22, + 0, 0, 5342, 80, 1, 0, 0, 0, 5343, 5344, 7, 0, 0, 0, 5344, 5345, 7, 11, + 0, 0, 5345, 5346, 7, 11, 0, 0, 5346, 5347, 5, 95, 0, 0, 5347, 5348, 7, + 3, 0, 0, 5348, 5349, 7, 2, 0, 0, 5349, 5350, 7, 22, 0, 0, 5350, 5351, 7, + 5, 0, 0, 5351, 82, 1, 0, 0, 0, 5352, 5353, 7, 0, 0, 0, 5353, 5354, 7, 11, + 0, 0, 5354, 5355, 7, 4, 0, 0, 5355, 5356, 7, 6, 0, 0, 5356, 5357, 7, 3, + 0, 0, 5357, 84, 1, 0, 0, 0, 5358, 5359, 7, 0, 0, 0, 5359, 5360, 7, 11, + 0, 0, 5360, 5361, 7, 4, 0, 0, 5361, 5362, 7, 6, 0, 0, 5362, 5363, 7, 3, + 0, 0, 5363, 5364, 7, 7, 0, 0, 5364, 5365, 7, 0, 0, 0, 5365, 5366, 7, 4, + 0, 0, 5366, 5367, 7, 6, 0, 0, 5367, 86, 1, 0, 0, 0, 5368, 5369, 7, 0, 0, + 0, 5369, 5370, 7, 11, 0, 0, 5370, 5371, 7, 22, 0, 0, 5371, 5372, 7, 0, + 0, 0, 5372, 5373, 7, 18, 0, 0, 5373, 5374, 7, 5, 0, 0, 5374, 88, 1, 0, + 0, 0, 5375, 5376, 7, 0, 0, 0, 5376, 5377, 7, 7, 0, 0, 5377, 5378, 7, 0, + 0, 0, 5378, 5379, 7, 11, 0, 0, 5379, 5380, 7, 18, 0, 0, 5380, 5381, 7, + 4, 0, 0, 5381, 5382, 7, 10, 0, 0, 5382, 5383, 7, 8, 0, 0, 5383, 90, 1, + 0, 0, 0, 5384, 5385, 7, 0, 0, 0, 5385, 5386, 7, 7, 0, 0, 5386, 5387, 7, + 0, 0, 0, 5387, 5388, 7, 11, 0, 0, 5388, 5389, 7, 18, 0, 0, 5389, 5390, + 7, 23, 0, 0, 5390, 5391, 7, 6, 0, 0, 5391, 92, 1, 0, 0, 0, 5392, 5393, + 7, 0, 0, 0, 5393, 5394, 7, 7, 0, 0, 5394, 5395, 7, 8, 0, 0, 5395, 5396, + 7, 6, 0, 0, 5396, 5397, 7, 5, 0, 0, 5397, 5398, 7, 4, 0, 0, 5398, 5399, + 7, 2, 0, 0, 5399, 5400, 7, 3, 0, 0, 5400, 94, 1, 0, 0, 0, 5401, 5402, 7, + 0, 0, 0, 5402, 5403, 7, 7, 0, 0, 5403, 5404, 7, 8, 0, 0, 5404, 5405, 7, + 10, 0, 0, 5405, 5406, 7, 11, 0, 0, 5406, 5407, 7, 11, 0, 0, 5407, 5408, + 7, 0, 0, 0, 5408, 5409, 7, 3, 0, 0, 5409, 5410, 7, 18, 0, 0, 5410, 96, + 1, 0, 0, 0, 5411, 5412, 7, 0, 0, 0, 5412, 5413, 7, 7, 0, 0, 5413, 5414, + 7, 9, 0, 0, 5414, 98, 1, 0, 0, 0, 5415, 5416, 7, 0, 0, 0, 5416, 5417, 7, + 7, 0, 0, 5417, 5418, 7, 9, 0, 0, 5418, 5419, 5, 95, 0, 0, 5419, 5420, 7, + 6, 0, 0, 5420, 5421, 7, 24, 0, 0, 5421, 5422, 7, 12, 0, 0, 5422, 5423, + 7, 0, 0, 0, 5423, 5424, 7, 11, 0, 0, 5424, 100, 1, 0, 0, 0, 5425, 5426, + 7, 0, 0, 0, 5426, 5427, 7, 7, 0, 0, 5427, 5428, 7, 7, 0, 0, 5428, 5429, + 7, 2, 0, 0, 5429, 5430, 7, 4, 0, 0, 5430, 5431, 7, 0, 0, 0, 5431, 5432, + 7, 4, 0, 0, 5432, 5433, 7, 10, 0, 0, 5433, 5434, 7, 2, 0, 0, 5434, 5435, + 7, 7, 0, 0, 5435, 5436, 7, 5, 0, 0, 5436, 102, 1, 0, 0, 0, 5437, 5438, + 7, 0, 0, 0, 5438, 5439, 7, 7, 0, 0, 5439, 5440, 7, 2, 0, 0, 5440, 5441, + 7, 14, 0, 0, 5441, 5442, 7, 0, 0, 0, 5442, 5443, 7, 11, 0, 0, 5443, 5444, + 7, 18, 0, 0, 5444, 104, 1, 0, 0, 0, 5445, 5446, 7, 0, 0, 0, 5446, 5447, + 7, 7, 0, 0, 5447, 5448, 7, 5, 0, 0, 5448, 5449, 7, 10, 0, 0, 5449, 5450, + 5, 95, 0, 0, 5450, 5451, 7, 3, 0, 0, 5451, 5452, 7, 6, 0, 0, 5452, 5453, + 7, 0, 0, 0, 5453, 5454, 7, 3, 0, 0, 5454, 5455, 7, 8, 0, 0, 5455, 5456, + 7, 19, 0, 0, 5456, 106, 1, 0, 0, 0, 5457, 5458, 7, 0, 0, 0, 5458, 5459, + 7, 7, 0, 0, 5459, 5460, 7, 4, 0, 0, 5460, 5461, 7, 10, 0, 0, 5461, 5462, + 7, 20, 0, 0, 5462, 5463, 7, 2, 0, 0, 5463, 5464, 7, 10, 0, 0, 5464, 5465, + 7, 7, 0, 0, 5465, 108, 1, 0, 0, 0, 5466, 5467, 7, 0, 0, 0, 5467, 5468, + 7, 7, 0, 0, 5468, 5469, 7, 18, 0, 0, 5469, 110, 1, 0, 0, 0, 5470, 5471, + 7, 0, 0, 0, 5471, 5472, 7, 7, 0, 0, 5472, 5473, 7, 18, 0, 0, 5473, 5474, + 7, 5, 0, 0, 5474, 5475, 7, 8, 0, 0, 5475, 5476, 7, 19, 0, 0, 5476, 5477, + 7, 6, 0, 0, 5477, 5478, 7, 14, 0, 0, 5478, 5479, 7, 0, 0, 0, 5479, 112, + 1, 0, 0, 0, 5480, 5481, 7, 0, 0, 0, 5481, 5482, 7, 15, 0, 0, 5482, 5483, + 7, 15, 0, 0, 5483, 5484, 7, 6, 0, 0, 5484, 5485, 7, 7, 0, 0, 5485, 5486, + 7, 9, 0, 0, 5486, 114, 1, 0, 0, 0, 5487, 5488, 7, 0, 0, 0, 5488, 5489, + 7, 15, 0, 0, 5489, 5490, 7, 15, 0, 0, 5490, 5491, 7, 6, 0, 0, 5491, 5492, + 7, 7, 0, 0, 5492, 5493, 7, 9, 0, 0, 5493, 5494, 7, 8, 0, 0, 5494, 5495, + 7, 19, 0, 0, 5495, 5496, 7, 10, 0, 0, 5496, 5497, 7, 11, 0, 0, 5497, 5498, + 7, 9, 0, 0, 5498, 5499, 7, 25, 0, 0, 5499, 5500, 7, 14, 0, 0, 5500, 5501, + 7, 11, 0, 0, 5501, 116, 1, 0, 0, 0, 5502, 5503, 7, 0, 0, 0, 5503, 5504, + 7, 15, 0, 0, 5504, 5505, 7, 15, 0, 0, 5505, 5506, 7, 6, 0, 0, 5506, 5507, + 7, 7, 0, 0, 5507, 5508, 7, 9, 0, 0, 5508, 5509, 5, 95, 0, 0, 5509, 5510, + 7, 13, 0, 0, 5510, 5511, 7, 0, 0, 0, 5511, 5512, 7, 11, 0, 0, 5512, 5513, + 7, 12, 0, 0, 5513, 5514, 7, 6, 0, 0, 5514, 5515, 7, 5, 0, 0, 5515, 118, + 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, 11, 0, 0, 5520, 5521, 7, 10, 0, 0, 5521, 5522, + 7, 8, 0, 0, 5522, 5523, 7, 0, 0, 0, 5523, 5524, 7, 4, 0, 0, 5524, 5525, + 7, 10, 0, 0, 5525, 5526, 7, 2, 0, 0, 5526, 5527, 7, 7, 0, 0, 5527, 120, + 1, 0, 0, 0, 5528, 5529, 7, 0, 0, 0, 5529, 5530, 7, 15, 0, 0, 5530, 5531, + 7, 15, 0, 0, 5531, 5532, 7, 11, 0, 0, 5532, 5533, 7, 18, 0, 0, 5533, 122, + 1, 0, 0, 0, 5534, 5535, 7, 0, 0, 0, 5535, 5536, 7, 15, 0, 0, 5536, 5537, + 7, 15, 0, 0, 5537, 5538, 7, 3, 0, 0, 5538, 5539, 7, 2, 0, 0, 5539, 5540, + 7, 25, 0, 0, 5540, 5541, 5, 95, 0, 0, 5541, 5542, 7, 8, 0, 0, 5542, 5543, + 7, 2, 0, 0, 5543, 5544, 7, 12, 0, 0, 5544, 5545, 7, 7, 0, 0, 5545, 5546, + 7, 4, 0, 0, 5546, 5547, 5, 95, 0, 0, 5547, 5548, 7, 9, 0, 0, 5548, 5549, + 7, 10, 0, 0, 5549, 5550, 7, 5, 0, 0, 5550, 5551, 7, 4, 0, 0, 5551, 5552, + 7, 10, 0, 0, 5552, 5553, 7, 7, 0, 0, 5553, 5554, 7, 8, 0, 0, 5554, 5555, + 7, 4, 0, 0, 5555, 124, 1, 0, 0, 0, 5556, 5557, 7, 0, 0, 0, 5557, 5558, + 7, 3, 0, 0, 5558, 5559, 7, 8, 0, 0, 5559, 5560, 7, 19, 0, 0, 5560, 5561, + 7, 10, 0, 0, 5561, 5562, 7, 13, 0, 0, 5562, 5563, 7, 0, 0, 0, 5563, 5564, + 7, 11, 0, 0, 5564, 126, 1, 0, 0, 0, 5565, 5566, 7, 0, 0, 0, 5566, 5567, + 7, 3, 0, 0, 5567, 5568, 7, 8, 0, 0, 5568, 5569, 7, 19, 0, 0, 5569, 5570, + 7, 10, 0, 0, 5570, 5571, 7, 13, 0, 0, 5571, 5572, 7, 6, 0, 0, 5572, 128, + 1, 0, 0, 0, 5573, 5574, 7, 0, 0, 0, 5574, 5575, 7, 3, 0, 0, 5575, 5576, + 7, 8, 0, 0, 5576, 5577, 7, 19, 0, 0, 5577, 5578, 7, 10, 0, 0, 5578, 5579, + 7, 13, 0, 0, 5579, 5580, 7, 6, 0, 0, 5580, 5581, 7, 9, 0, 0, 5581, 130, + 1, 0, 0, 0, 5582, 5583, 7, 0, 0, 0, 5583, 5584, 7, 3, 0, 0, 5584, 5585, + 7, 8, 0, 0, 5585, 5586, 7, 19, 0, 0, 5586, 5587, 7, 10, 0, 0, 5587, 5588, + 7, 13, 0, 0, 5588, 5589, 7, 6, 0, 0, 5589, 5590, 7, 11, 0, 0, 5590, 5591, + 7, 2, 0, 0, 5591, 5592, 7, 17, 0, 0, 5592, 132, 1, 0, 0, 0, 5593, 5594, + 7, 0, 0, 0, 5594, 5595, 7, 3, 0, 0, 5595, 5596, 7, 6, 0, 0, 5596, 134, + 1, 0, 0, 0, 5597, 5598, 7, 0, 0, 0, 5598, 5599, 7, 3, 0, 0, 5599, 5600, + 7, 3, 0, 0, 5600, 5601, 7, 0, 0, 0, 5601, 5602, 7, 18, 0, 0, 5602, 136, + 1, 0, 0, 0, 5603, 5604, 7, 0, 0, 0, 5604, 5605, 7, 5, 0, 0, 5605, 138, + 1, 0, 0, 0, 5606, 5607, 7, 0, 0, 0, 5607, 5608, 7, 5, 0, 0, 5608, 5609, + 7, 8, 0, 0, 5609, 140, 1, 0, 0, 0, 5610, 5611, 7, 0, 0, 0, 5611, 5612, + 7, 5, 0, 0, 5612, 5613, 7, 8, 0, 0, 5613, 5614, 7, 10, 0, 0, 5614, 5615, + 7, 10, 0, 0, 5615, 142, 1, 0, 0, 0, 5616, 5617, 7, 0, 0, 0, 5617, 5618, + 7, 5, 0, 0, 5618, 5619, 7, 8, 0, 0, 5619, 5620, 7, 10, 0, 0, 5620, 5621, + 7, 10, 0, 0, 5621, 5622, 7, 5, 0, 0, 5622, 5623, 7, 4, 0, 0, 5623, 5624, + 7, 3, 0, 0, 5624, 144, 1, 0, 0, 0, 5625, 5626, 7, 0, 0, 0, 5626, 5627, + 7, 5, 0, 0, 5627, 5628, 7, 10, 0, 0, 5628, 5629, 7, 7, 0, 0, 5629, 146, + 1, 0, 0, 0, 5630, 5631, 7, 0, 0, 0, 5631, 5632, 7, 5, 0, 0, 5632, 5633, + 7, 10, 0, 0, 5633, 5634, 7, 5, 0, 0, 5634, 148, 1, 0, 0, 0, 5635, 5636, + 7, 0, 0, 0, 5636, 5637, 7, 5, 0, 0, 5637, 5638, 7, 5, 0, 0, 5638, 5639, + 7, 6, 0, 0, 5639, 5640, 7, 14, 0, 0, 5640, 5641, 7, 1, 0, 0, 5641, 5642, + 7, 11, 0, 0, 5642, 5643, 7, 18, 0, 0, 5643, 150, 1, 0, 0, 0, 5644, 5645, + 7, 0, 0, 0, 5645, 5646, 7, 5, 0, 0, 5646, 5647, 7, 5, 0, 0, 5647, 5648, + 7, 10, 0, 0, 5648, 5649, 7, 17, 0, 0, 5649, 5650, 7, 7, 0, 0, 5650, 152, + 1, 0, 0, 0, 5651, 5652, 7, 0, 0, 0, 5652, 5653, 7, 5, 0, 0, 5653, 5654, + 7, 5, 0, 0, 5654, 5655, 7, 2, 0, 0, 5655, 5656, 7, 8, 0, 0, 5656, 5657, + 7, 10, 0, 0, 5657, 5658, 7, 0, 0, 0, 5658, 5659, 7, 4, 0, 0, 5659, 5660, + 7, 6, 0, 0, 5660, 154, 1, 0, 0, 0, 5661, 5662, 7, 0, 0, 0, 5662, 5663, + 7, 5, 0, 0, 5663, 5664, 7, 18, 0, 0, 5664, 5665, 7, 7, 0, 0, 5665, 5666, + 7, 8, 0, 0, 5666, 156, 1, 0, 0, 0, 5667, 5668, 7, 0, 0, 0, 5668, 5669, + 7, 5, 0, 0, 5669, 5670, 7, 18, 0, 0, 5670, 5671, 7, 7, 0, 0, 5671, 5672, + 7, 8, 0, 0, 5672, 5673, 7, 19, 0, 0, 5673, 5674, 7, 3, 0, 0, 5674, 5675, + 7, 2, 0, 0, 5675, 5676, 7, 7, 0, 0, 5676, 5677, 7, 2, 0, 0, 5677, 5678, + 7, 12, 0, 0, 5678, 5679, 7, 5, 0, 0, 5679, 158, 1, 0, 0, 0, 5680, 5681, + 7, 0, 0, 0, 5681, 5682, 7, 4, 0, 0, 5682, 5683, 7, 0, 0, 0, 5683, 5684, + 7, 7, 0, 0, 5684, 5685, 5, 50, 0, 0, 5685, 160, 1, 0, 0, 0, 5686, 5687, + 7, 0, 0, 0, 5687, 5688, 7, 4, 0, 0, 5688, 5689, 7, 0, 0, 0, 5689, 5690, + 7, 7, 0, 0, 5690, 162, 1, 0, 0, 0, 5691, 5692, 7, 0, 0, 0, 5692, 5693, + 7, 4, 0, 0, 5693, 164, 1, 0, 0, 0, 5694, 5695, 7, 0, 0, 0, 5695, 5696, + 7, 4, 0, 0, 5696, 5697, 7, 4, 0, 0, 5697, 5698, 7, 3, 0, 0, 5698, 5699, + 7, 10, 0, 0, 5699, 5700, 7, 1, 0, 0, 5700, 5701, 7, 12, 0, 0, 5701, 5702, + 7, 4, 0, 0, 5702, 5703, 7, 6, 0, 0, 5703, 166, 1, 0, 0, 0, 5704, 5705, + 7, 0, 0, 0, 5705, 5706, 7, 4, 0, 0, 5706, 5707, 7, 4, 0, 0, 5707, 5708, + 7, 3, 0, 0, 5708, 5709, 7, 10, 0, 0, 5709, 5710, 7, 1, 0, 0, 5710, 5711, + 7, 12, 0, 0, 5711, 5712, 7, 4, 0, 0, 5712, 5713, 7, 6, 0, 0, 5713, 5714, + 7, 5, 0, 0, 5714, 168, 1, 0, 0, 0, 5715, 5716, 7, 0, 0, 0, 5716, 5717, + 7, 12, 0, 0, 5717, 5718, 7, 9, 0, 0, 5718, 5719, 7, 10, 0, 0, 5719, 5720, + 7, 4, 0, 0, 5720, 170, 1, 0, 0, 0, 5721, 5722, 7, 0, 0, 0, 5722, 5723, + 7, 12, 0, 0, 5723, 5724, 7, 4, 0, 0, 5724, 5725, 7, 19, 0, 0, 5725, 5726, + 7, 6, 0, 0, 5726, 5727, 7, 7, 0, 0, 5727, 5728, 7, 4, 0, 0, 5728, 5729, + 7, 10, 0, 0, 5729, 5730, 7, 8, 0, 0, 5730, 5731, 7, 0, 0, 0, 5731, 5732, + 7, 4, 0, 0, 5732, 5733, 7, 6, 0, 0, 5733, 5734, 7, 9, 0, 0, 5734, 172, + 1, 0, 0, 0, 5735, 5736, 7, 0, 0, 0, 5736, 5737, 7, 12, 0, 0, 5737, 5738, + 7, 4, 0, 0, 5738, 5739, 7, 19, 0, 0, 5739, 5740, 7, 6, 0, 0, 5740, 5741, + 7, 7, 0, 0, 5741, 5742, 7, 4, 0, 0, 5742, 5743, 7, 10, 0, 0, 5743, 5744, + 7, 8, 0, 0, 5744, 5745, 7, 0, 0, 0, 5745, 5746, 7, 4, 0, 0, 5746, 5747, + 7, 10, 0, 0, 5747, 5748, 7, 2, 0, 0, 5748, 5749, 7, 7, 0, 0, 5749, 174, + 1, 0, 0, 0, 5750, 5751, 7, 0, 0, 0, 5751, 5752, 7, 12, 0, 0, 5752, 5753, + 7, 4, 0, 0, 5753, 5754, 7, 19, 0, 0, 5754, 5755, 7, 10, 0, 0, 5755, 5756, + 7, 9, 0, 0, 5756, 176, 1, 0, 0, 0, 5757, 5758, 7, 0, 0, 0, 5758, 5759, + 7, 12, 0, 0, 5759, 5760, 7, 4, 0, 0, 5760, 5761, 7, 19, 0, 0, 5761, 5762, + 7, 2, 0, 0, 5762, 5763, 7, 3, 0, 0, 5763, 5764, 7, 10, 0, 0, 5764, 5765, + 7, 23, 0, 0, 5765, 5766, 7, 0, 0, 0, 5766, 5767, 7, 4, 0, 0, 5767, 5768, + 7, 10, 0, 0, 5768, 5769, 7, 2, 0, 0, 5769, 5770, 7, 7, 0, 0, 5770, 178, + 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, 0, 0, 0, 5776, 5777, + 7, 11, 0, 0, 5777, 5778, 7, 11, 0, 0, 5778, 5779, 7, 2, 0, 0, 5779, 5780, + 7, 8, 0, 0, 5780, 5781, 7, 0, 0, 0, 5781, 5782, 7, 4, 0, 0, 5782, 5783, + 7, 6, 0, 0, 5783, 180, 1, 0, 0, 0, 5784, 5785, 7, 0, 0, 0, 5785, 5786, + 7, 12, 0, 0, 5786, 5787, 7, 4, 0, 0, 5787, 5788, 7, 2, 0, 0, 5788, 182, + 1, 0, 0, 0, 5789, 5790, 7, 0, 0, 0, 5790, 5791, 7, 12, 0, 0, 5791, 5792, + 7, 4, 0, 0, 5792, 5793, 7, 2, 0, 0, 5793, 5794, 7, 1, 0, 0, 5794, 5795, + 7, 0, 0, 0, 5795, 5796, 7, 8, 0, 0, 5796, 5797, 7, 21, 0, 0, 5797, 5798, + 7, 12, 0, 0, 5798, 5799, 7, 15, 0, 0, 5799, 184, 1, 0, 0, 0, 5800, 5801, + 7, 0, 0, 0, 5801, 5802, 7, 12, 0, 0, 5802, 5803, 7, 4, 0, 0, 5803, 5804, + 7, 2, 0, 0, 5804, 5805, 7, 6, 0, 0, 5805, 5806, 7, 25, 0, 0, 5806, 5807, + 7, 4, 0, 0, 5807, 5808, 7, 6, 0, 0, 5808, 5809, 7, 7, 0, 0, 5809, 5810, + 7, 9, 0, 0, 5810, 186, 1, 0, 0, 0, 5811, 5812, 7, 0, 0, 0, 5812, 5813, + 7, 12, 0, 0, 5813, 5814, 7, 4, 0, 0, 5814, 5815, 7, 2, 0, 0, 5815, 5816, + 5, 95, 0, 0, 5816, 5817, 7, 11, 0, 0, 5817, 5818, 7, 2, 0, 0, 5818, 5819, + 7, 17, 0, 0, 5819, 5820, 7, 10, 0, 0, 5820, 5821, 7, 7, 0, 0, 5821, 188, + 1, 0, 0, 0, 5822, 5823, 7, 0, 0, 0, 5823, 5824, 7, 12, 0, 0, 5824, 5825, + 7, 4, 0, 0, 5825, 5826, 7, 2, 0, 0, 5826, 5827, 7, 14, 0, 0, 5827, 5828, + 7, 0, 0, 0, 5828, 5829, 7, 4, 0, 0, 5829, 5830, 7, 10, 0, 0, 5830, 5831, + 7, 8, 0, 0, 5831, 190, 1, 0, 0, 0, 5832, 5833, 7, 0, 0, 0, 5833, 5834, + 7, 12, 0, 0, 5834, 5835, 7, 4, 0, 0, 5835, 5836, 7, 2, 0, 0, 5836, 5837, + 7, 7, 0, 0, 5837, 5838, 7, 2, 0, 0, 5838, 5839, 7, 14, 0, 0, 5839, 5840, + 7, 2, 0, 0, 5840, 5841, 7, 12, 0, 0, 5841, 5842, 7, 5, 0, 0, 5842, 5843, + 5, 95, 0, 0, 5843, 5844, 7, 4, 0, 0, 5844, 5845, 7, 3, 0, 0, 5845, 5846, + 7, 0, 0, 0, 5846, 5847, 7, 7, 0, 0, 5847, 5848, 7, 5, 0, 0, 5848, 5849, + 7, 0, 0, 0, 5849, 5850, 7, 8, 0, 0, 5850, 5851, 7, 4, 0, 0, 5851, 5852, + 7, 10, 0, 0, 5852, 5853, 7, 2, 0, 0, 5853, 5854, 7, 7, 0, 0, 5854, 192, + 1, 0, 0, 0, 5855, 5856, 7, 0, 0, 0, 5856, 5857, 7, 12, 0, 0, 5857, 5858, + 7, 4, 0, 0, 5858, 5859, 7, 2, 0, 0, 5859, 5860, 5, 95, 0, 0, 5860, 5861, + 7, 3, 0, 0, 5861, 5862, 7, 6, 0, 0, 5862, 5863, 7, 2, 0, 0, 5863, 5864, + 7, 15, 0, 0, 5864, 5865, 7, 4, 0, 0, 5865, 5866, 7, 10, 0, 0, 5866, 5867, + 7, 14, 0, 0, 5867, 5868, 7, 10, 0, 0, 5868, 5869, 7, 23, 0, 0, 5869, 5870, + 7, 6, 0, 0, 5870, 194, 1, 0, 0, 0, 5871, 5872, 7, 0, 0, 0, 5872, 5873, + 7, 13, 0, 0, 5873, 5874, 7, 0, 0, 0, 5874, 5875, 7, 10, 0, 0, 5875, 5876, + 7, 11, 0, 0, 5876, 5877, 7, 0, 0, 0, 5877, 5878, 7, 1, 0, 0, 5878, 5879, + 7, 10, 0, 0, 5879, 5880, 7, 11, 0, 0, 5880, 5881, 7, 10, 0, 0, 5881, 5882, + 7, 4, 0, 0, 5882, 5883, 7, 18, 0, 0, 5883, 196, 1, 0, 0, 0, 5884, 5885, + 7, 0, 0, 0, 5885, 5886, 7, 13, 0, 0, 5886, 5887, 7, 3, 0, 0, 5887, 5888, + 7, 2, 0, 0, 5888, 198, 1, 0, 0, 0, 5889, 5890, 7, 1, 0, 0, 5890, 5891, + 7, 0, 0, 0, 5891, 5892, 7, 8, 0, 0, 5892, 5893, 7, 21, 0, 0, 5893, 5894, + 7, 17, 0, 0, 5894, 5895, 7, 3, 0, 0, 5895, 5896, 7, 2, 0, 0, 5896, 5897, + 7, 12, 0, 0, 5897, 5898, 7, 7, 0, 0, 5898, 5899, 7, 9, 0, 0, 5899, 200, + 1, 0, 0, 0, 5900, 5901, 7, 1, 0, 0, 5901, 5902, 7, 0, 0, 0, 5902, 5903, + 7, 8, 0, 0, 5903, 5904, 7, 21, 0, 0, 5904, 5905, 7, 10, 0, 0, 5905, 5906, + 7, 7, 0, 0, 5906, 5907, 7, 17, 0, 0, 5907, 5908, 7, 16, 0, 0, 5908, 5909, + 7, 10, 0, 0, 5909, 5910, 7, 11, 0, 0, 5910, 5911, 7, 6, 0, 0, 5911, 202, + 1, 0, 0, 0, 5912, 5913, 7, 1, 0, 0, 5913, 5914, 7, 0, 0, 0, 5914, 5915, + 7, 8, 0, 0, 5915, 5916, 7, 21, 0, 0, 5916, 5917, 7, 12, 0, 0, 5917, 5918, + 7, 15, 0, 0, 5918, 204, 1, 0, 0, 0, 5919, 5920, 7, 1, 0, 0, 5920, 5921, + 7, 0, 0, 0, 5921, 5922, 7, 8, 0, 0, 5922, 5923, 7, 21, 0, 0, 5923, 5924, + 7, 12, 0, 0, 5924, 5925, 7, 15, 0, 0, 5925, 5926, 7, 5, 0, 0, 5926, 206, + 1, 0, 0, 0, 5927, 5928, 7, 1, 0, 0, 5928, 5929, 7, 0, 0, 0, 5929, 5930, + 7, 8, 0, 0, 5930, 5931, 7, 21, 0, 0, 5931, 5932, 7, 12, 0, 0, 5932, 5933, + 7, 15, 0, 0, 5933, 5934, 7, 5, 0, 0, 5934, 5935, 7, 6, 0, 0, 5935, 5936, + 7, 4, 0, 0, 5936, 208, 1, 0, 0, 0, 5937, 5938, 7, 1, 0, 0, 5938, 5939, + 7, 0, 0, 0, 5939, 5940, 7, 9, 0, 0, 5940, 5941, 7, 16, 0, 0, 5941, 5942, + 7, 10, 0, 0, 5942, 5943, 7, 11, 0, 0, 5943, 5944, 7, 6, 0, 0, 5944, 210, + 1, 0, 0, 0, 5945, 5946, 7, 1, 0, 0, 5946, 5947, 7, 0, 0, 0, 5947, 5948, + 7, 5, 0, 0, 5948, 5949, 7, 10, 0, 0, 5949, 5950, 7, 8, 0, 0, 5950, 212, + 1, 0, 0, 0, 5951, 5952, 7, 1, 0, 0, 5952, 5953, 7, 0, 0, 0, 5953, 5954, + 7, 5, 0, 0, 5954, 5955, 7, 10, 0, 0, 5955, 5956, 7, 8, 0, 0, 5956, 5957, + 7, 16, 0, 0, 5957, 5958, 7, 10, 0, 0, 5958, 5959, 7, 11, 0, 0, 5959, 5960, + 7, 6, 0, 0, 5960, 214, 1, 0, 0, 0, 5961, 5962, 7, 1, 0, 0, 5962, 5963, + 7, 0, 0, 0, 5963, 5964, 7, 4, 0, 0, 5964, 5965, 7, 8, 0, 0, 5965, 5966, + 7, 19, 0, 0, 5966, 216, 1, 0, 0, 0, 5967, 5968, 7, 1, 0, 0, 5968, 5969, + 7, 0, 0, 0, 5969, 5970, 7, 4, 0, 0, 5970, 5971, 7, 8, 0, 0, 5971, 5972, + 7, 19, 0, 0, 5972, 5973, 7, 5, 0, 0, 5973, 5974, 7, 10, 0, 0, 5974, 5975, + 7, 23, 0, 0, 5975, 5976, 7, 6, 0, 0, 5976, 218, 1, 0, 0, 0, 5977, 5978, + 7, 1, 0, 0, 5978, 5979, 7, 0, 0, 0, 5979, 5980, 7, 4, 0, 0, 5980, 5981, + 7, 8, 0, 0, 5981, 5982, 7, 19, 0, 0, 5982, 5983, 5, 95, 0, 0, 5983, 5984, + 7, 4, 0, 0, 5984, 5985, 7, 0, 0, 0, 5985, 5986, 7, 1, 0, 0, 5986, 5987, + 7, 11, 0, 0, 5987, 5988, 7, 6, 0, 0, 5988, 5989, 5, 95, 0, 0, 5989, 5990, + 7, 0, 0, 0, 5990, 5991, 7, 8, 0, 0, 5991, 5992, 7, 8, 0, 0, 5992, 5993, + 7, 6, 0, 0, 5993, 5994, 7, 5, 0, 0, 5994, 5995, 7, 5, 0, 0, 5995, 5996, + 5, 95, 0, 0, 5996, 5997, 7, 1, 0, 0, 5997, 5998, 7, 18, 0, 0, 5998, 5999, + 5, 95, 0, 0, 5999, 6000, 7, 3, 0, 0, 6000, 6001, 7, 2, 0, 0, 6001, 6002, + 7, 22, 0, 0, 6002, 6003, 7, 10, 0, 0, 6003, 6004, 7, 9, 0, 0, 6004, 220, + 1, 0, 0, 0, 6005, 6006, 7, 1, 0, 0, 6006, 6007, 7, 6, 0, 0, 6007, 6008, + 7, 8, 0, 0, 6008, 6009, 7, 2, 0, 0, 6009, 6010, 7, 14, 0, 0, 6010, 6011, + 7, 6, 0, 0, 6011, 222, 1, 0, 0, 0, 6012, 6013, 7, 1, 0, 0, 6013, 6014, + 7, 6, 0, 0, 6014, 6015, 7, 16, 0, 0, 6015, 6016, 7, 2, 0, 0, 6016, 6017, + 7, 3, 0, 0, 6017, 6018, 7, 6, 0, 0, 6018, 224, 1, 0, 0, 0, 6019, 6020, + 7, 1, 0, 0, 6020, 6021, 7, 6, 0, 0, 6021, 6022, 7, 17, 0, 0, 6022, 6023, + 7, 10, 0, 0, 6023, 6024, 7, 7, 0, 0, 6024, 226, 1, 0, 0, 0, 6025, 6026, + 7, 1, 0, 0, 6026, 6027, 7, 6, 0, 0, 6027, 6028, 7, 17, 0, 0, 6028, 6029, + 7, 10, 0, 0, 6029, 6030, 7, 7, 0, 0, 6030, 6031, 7, 7, 0, 0, 6031, 6032, + 7, 10, 0, 0, 6032, 6033, 7, 7, 0, 0, 6033, 6034, 7, 17, 0, 0, 6034, 228, + 1, 0, 0, 0, 6035, 6036, 7, 1, 0, 0, 6036, 6037, 7, 6, 0, 0, 6037, 6038, + 7, 17, 0, 0, 6038, 6039, 7, 10, 0, 0, 6039, 6040, 7, 7, 0, 0, 6040, 6041, + 5, 95, 0, 0, 6041, 6042, 7, 2, 0, 0, 6042, 6043, 7, 12, 0, 0, 6043, 6044, + 7, 4, 0, 0, 6044, 6045, 7, 11, 0, 0, 6045, 6046, 7, 10, 0, 0, 6046, 6047, + 7, 7, 0, 0, 6047, 6048, 7, 6, 0, 0, 6048, 6049, 5, 95, 0, 0, 6049, 6050, + 7, 9, 0, 0, 6050, 6051, 7, 0, 0, 0, 6051, 6052, 7, 4, 0, 0, 6052, 6053, + 7, 0, 0, 0, 6053, 230, 1, 0, 0, 0, 6054, 6055, 7, 1, 0, 0, 6055, 6056, + 7, 6, 0, 0, 6056, 6057, 7, 19, 0, 0, 6057, 6058, 7, 0, 0, 0, 6058, 6059, + 7, 11, 0, 0, 6059, 6060, 7, 16, 0, 0, 6060, 232, 1, 0, 0, 0, 6061, 6062, + 7, 1, 0, 0, 6062, 6063, 7, 6, 0, 0, 6063, 6064, 7, 24, 0, 0, 6064, 6065, + 7, 12, 0, 0, 6065, 6066, 7, 6, 0, 0, 6066, 6067, 7, 0, 0, 0, 6067, 6068, + 7, 4, 0, 0, 6068, 6069, 7, 19, 0, 0, 6069, 234, 1, 0, 0, 0, 6070, 6071, + 7, 1, 0, 0, 6071, 6072, 7, 6, 0, 0, 6072, 6073, 7, 4, 0, 0, 6073, 6074, + 7, 22, 0, 0, 6074, 6075, 7, 6, 0, 0, 6075, 6076, 7, 6, 0, 0, 6076, 6077, + 7, 7, 0, 0, 6077, 236, 1, 0, 0, 0, 6078, 6079, 7, 1, 0, 0, 6079, 6080, + 7, 16, 0, 0, 6080, 6081, 7, 10, 0, 0, 6081, 6082, 7, 11, 0, 0, 6082, 6083, + 7, 6, 0, 0, 6083, 238, 1, 0, 0, 0, 6084, 6085, 7, 1, 0, 0, 6085, 6086, + 7, 16, 0, 0, 6086, 6087, 7, 10, 0, 0, 6087, 6088, 7, 11, 0, 0, 6088, 6089, + 7, 6, 0, 0, 6089, 6090, 7, 7, 0, 0, 6090, 6091, 7, 0, 0, 0, 6091, 6092, + 7, 14, 0, 0, 6092, 6093, 7, 6, 0, 0, 6093, 240, 1, 0, 0, 0, 6094, 6095, + 7, 1, 0, 0, 6095, 6096, 7, 10, 0, 0, 6096, 6097, 7, 17, 0, 0, 6097, 242, + 1, 0, 0, 0, 6098, 6099, 7, 1, 0, 0, 6099, 6100, 7, 10, 0, 0, 6100, 6101, + 7, 17, 0, 0, 6101, 6102, 7, 16, 0, 0, 6102, 6103, 7, 10, 0, 0, 6103, 6104, + 7, 11, 0, 0, 6104, 6105, 7, 6, 0, 0, 6105, 244, 1, 0, 0, 0, 6106, 6107, + 7, 1, 0, 0, 6107, 6108, 7, 10, 0, 0, 6108, 6109, 7, 17, 0, 0, 6109, 6110, + 7, 10, 0, 0, 6110, 6111, 7, 7, 0, 0, 6111, 6112, 7, 4, 0, 0, 6112, 246, + 1, 0, 0, 0, 6113, 6114, 7, 1, 0, 0, 6114, 6115, 7, 10, 0, 0, 6115, 6116, + 7, 7, 0, 0, 6116, 6117, 7, 0, 0, 0, 6117, 6118, 7, 3, 0, 0, 6118, 6119, + 7, 18, 0, 0, 6119, 248, 1, 0, 0, 0, 6120, 6121, 7, 1, 0, 0, 6121, 6122, + 7, 10, 0, 0, 6122, 6123, 7, 7, 0, 0, 6123, 6124, 7, 0, 0, 0, 6124, 6125, + 7, 3, 0, 0, 6125, 6126, 7, 18, 0, 0, 6126, 6127, 5, 95, 0, 0, 6127, 6128, + 7, 9, 0, 0, 6128, 6129, 7, 2, 0, 0, 6129, 6130, 7, 12, 0, 0, 6130, 6131, + 7, 1, 0, 0, 6131, 6132, 7, 11, 0, 0, 6132, 6133, 7, 6, 0, 0, 6133, 250, + 1, 0, 0, 0, 6134, 6135, 7, 1, 0, 0, 6135, 6136, 7, 10, 0, 0, 6136, 6137, + 7, 7, 0, 0, 6137, 6138, 7, 0, 0, 0, 6138, 6139, 7, 3, 0, 0, 6139, 6140, + 7, 18, 0, 0, 6140, 6141, 5, 95, 0, 0, 6141, 6142, 7, 9, 0, 0, 6142, 6143, + 7, 2, 0, 0, 6143, 6144, 7, 12, 0, 0, 6144, 6145, 7, 1, 0, 0, 6145, 6146, + 7, 11, 0, 0, 6146, 6147, 7, 6, 0, 0, 6147, 6148, 5, 95, 0, 0, 6148, 6149, + 7, 10, 0, 0, 6149, 6150, 7, 7, 0, 0, 6150, 6151, 7, 16, 0, 0, 6151, 6152, + 7, 10, 0, 0, 6152, 6153, 7, 7, 0, 0, 6153, 6154, 7, 10, 0, 0, 6154, 6155, + 7, 4, 0, 0, 6155, 6156, 7, 18, 0, 0, 6156, 252, 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, 9, 0, 0, 6165, 6166, 7, 2, 0, 0, 6166, 6167, + 7, 12, 0, 0, 6167, 6168, 7, 1, 0, 0, 6168, 6169, 7, 11, 0, 0, 6169, 6170, + 7, 6, 0, 0, 6170, 6171, 5, 95, 0, 0, 6171, 6172, 7, 7, 0, 0, 6172, 6173, + 7, 0, 0, 0, 6173, 6174, 7, 7, 0, 0, 6174, 254, 1, 0, 0, 0, 6175, 6176, + 7, 1, 0, 0, 6176, 6177, 7, 10, 0, 0, 6177, 6178, 7, 7, 0, 0, 6178, 6179, + 7, 0, 0, 0, 6179, 6180, 7, 3, 0, 0, 6180, 6181, 7, 18, 0, 0, 6181, 6182, + 5, 95, 0, 0, 6182, 6183, 7, 16, 0, 0, 6183, 6184, 7, 11, 0, 0, 6184, 6185, + 7, 2, 0, 0, 6185, 6186, 7, 0, 0, 0, 6186, 6187, 7, 4, 0, 0, 6187, 256, + 1, 0, 0, 0, 6188, 6189, 7, 1, 0, 0, 6189, 6190, 7, 10, 0, 0, 6190, 6191, + 7, 7, 0, 0, 6191, 6192, 7, 0, 0, 0, 6192, 6193, 7, 3, 0, 0, 6193, 6194, + 7, 18, 0, 0, 6194, 6195, 5, 95, 0, 0, 6195, 6196, 7, 16, 0, 0, 6196, 6197, + 7, 11, 0, 0, 6197, 6198, 7, 2, 0, 0, 6198, 6199, 7, 0, 0, 0, 6199, 6200, + 7, 4, 0, 0, 6200, 6201, 5, 95, 0, 0, 6201, 6202, 7, 10, 0, 0, 6202, 6203, + 7, 7, 0, 0, 6203, 6204, 7, 16, 0, 0, 6204, 6205, 7, 10, 0, 0, 6205, 6206, + 7, 7, 0, 0, 6206, 6207, 7, 10, 0, 0, 6207, 6208, 7, 4, 0, 0, 6208, 6209, + 7, 18, 0, 0, 6209, 258, 1, 0, 0, 0, 6210, 6211, 7, 1, 0, 0, 6211, 6212, + 7, 10, 0, 0, 6212, 6213, 7, 7, 0, 0, 6213, 6214, 7, 0, 0, 0, 6214, 6215, + 7, 3, 0, 0, 6215, 6216, 7, 18, 0, 0, 6216, 6217, 5, 95, 0, 0, 6217, 6218, + 7, 16, 0, 0, 6218, 6219, 7, 11, 0, 0, 6219, 6220, 7, 2, 0, 0, 6220, 6221, + 7, 0, 0, 0, 6221, 6222, 7, 4, 0, 0, 6222, 6223, 5, 95, 0, 0, 6223, 6224, + 7, 7, 0, 0, 6224, 6225, 7, 0, 0, 0, 6225, 6226, 7, 7, 0, 0, 6226, 260, + 1, 0, 0, 0, 6227, 6228, 7, 1, 0, 0, 6228, 6229, 7, 10, 0, 0, 6229, 6230, + 7, 7, 0, 0, 6230, 6231, 7, 0, 0, 0, 6231, 6232, 7, 3, 0, 0, 6232, 6233, + 7, 18, 0, 0, 6233, 6234, 5, 95, 0, 0, 6234, 6235, 7, 10, 0, 0, 6235, 6236, + 7, 7, 0, 0, 6236, 6237, 7, 4, 0, 0, 6237, 6238, 7, 6, 0, 0, 6238, 6239, + 7, 17, 0, 0, 6239, 6240, 7, 6, 0, 0, 6240, 6241, 7, 3, 0, 0, 6241, 262, + 1, 0, 0, 0, 6242, 6243, 7, 1, 0, 0, 6243, 6244, 7, 10, 0, 0, 6244, 6245, + 7, 7, 0, 0, 6245, 6246, 7, 9, 0, 0, 6246, 6247, 5, 95, 0, 0, 6247, 6248, + 7, 0, 0, 0, 6248, 6249, 7, 22, 0, 0, 6249, 6250, 7, 0, 0, 0, 6250, 6251, + 7, 3, 0, 0, 6251, 6252, 7, 6, 0, 0, 6252, 264, 1, 0, 0, 0, 6253, 6254, + 7, 1, 0, 0, 6254, 6255, 7, 10, 0, 0, 6255, 6256, 7, 7, 0, 0, 6256, 6257, + 7, 9, 0, 0, 6257, 6258, 7, 10, 0, 0, 6258, 6259, 7, 7, 0, 0, 6259, 6260, + 7, 17, 0, 0, 6260, 266, 1, 0, 0, 0, 6261, 6262, 7, 1, 0, 0, 6262, 6263, + 7, 10, 0, 0, 6263, 6264, 7, 7, 0, 0, 6264, 6265, 5, 95, 0, 0, 6265, 6266, + 7, 4, 0, 0, 6266, 6267, 7, 2, 0, 0, 6267, 6268, 5, 95, 0, 0, 6268, 6269, + 7, 7, 0, 0, 6269, 6270, 7, 12, 0, 0, 6270, 6271, 7, 14, 0, 0, 6271, 268, + 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, 0, 0, 0, 6276, 6277, 7, 7, 0, 0, 6277, 6278, + 7, 9, 0, 0, 6278, 270, 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, 5, 95, 0, 0, 6286, 6287, + 7, 0, 0, 0, 6287, 6288, 7, 7, 0, 0, 6288, 6289, 7, 9, 0, 0, 6289, 272, + 1, 0, 0, 0, 6290, 6291, 7, 1, 0, 0, 6291, 6292, 7, 10, 0, 0, 6292, 6293, + 7, 4, 0, 0, 6293, 6294, 7, 14, 0, 0, 6294, 6295, 7, 0, 0, 0, 6295, 6296, + 7, 15, 0, 0, 6296, 274, 1, 0, 0, 0, 6297, 6298, 7, 1, 0, 0, 6298, 6299, + 7, 10, 0, 0, 6299, 6300, 7, 4, 0, 0, 6300, 6301, 7, 14, 0, 0, 6301, 6302, + 7, 0, 0, 0, 6302, 6303, 7, 15, 0, 0, 6303, 6304, 7, 5, 0, 0, 6304, 276, + 1, 0, 0, 0, 6305, 6306, 7, 1, 0, 0, 6306, 6307, 7, 10, 0, 0, 6307, 6308, + 7, 4, 0, 0, 6308, 6309, 7, 14, 0, 0, 6309, 6310, 7, 0, 0, 0, 6310, 6311, + 7, 15, 0, 0, 6311, 6312, 5, 95, 0, 0, 6312, 6313, 7, 4, 0, 0, 6313, 6314, + 7, 3, 0, 0, 6314, 6315, 7, 6, 0, 0, 6315, 6316, 7, 6, 0, 0, 6316, 278, + 1, 0, 0, 0, 6317, 6318, 7, 1, 0, 0, 6318, 6319, 7, 10, 0, 0, 6319, 6320, + 7, 4, 0, 0, 6320, 6321, 7, 5, 0, 0, 6321, 280, 1, 0, 0, 0, 6322, 6323, + 7, 1, 0, 0, 6323, 6324, 7, 11, 0, 0, 6324, 6325, 7, 0, 0, 0, 6325, 6326, + 7, 7, 0, 0, 6326, 6327, 7, 21, 0, 0, 6327, 6328, 7, 5, 0, 0, 6328, 282, + 1, 0, 0, 0, 6329, 6330, 7, 1, 0, 0, 6330, 6331, 7, 11, 0, 0, 6331, 6332, + 7, 2, 0, 0, 6332, 6333, 7, 1, 0, 0, 6333, 284, 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, 286, 1, 0, 0, 0, 6340, 6341, + 7, 1, 0, 0, 6341, 6342, 7, 11, 0, 0, 6342, 6343, 7, 2, 0, 0, 6343, 6344, + 7, 8, 0, 0, 6344, 6345, 7, 21, 0, 0, 6345, 6346, 5, 95, 0, 0, 6346, 6347, + 7, 3, 0, 0, 6347, 6348, 7, 0, 0, 0, 6348, 6349, 7, 7, 0, 0, 6349, 6350, + 7, 17, 0, 0, 6350, 6351, 7, 6, 0, 0, 6351, 288, 1, 0, 0, 0, 6352, 6353, + 7, 1, 0, 0, 6353, 6354, 7, 11, 0, 0, 6354, 6355, 7, 2, 0, 0, 6355, 6356, + 7, 8, 0, 0, 6356, 6357, 7, 21, 0, 0, 6357, 6358, 7, 5, 0, 0, 6358, 290, + 1, 0, 0, 0, 6359, 6360, 7, 1, 0, 0, 6360, 6361, 7, 11, 0, 0, 6361, 6362, + 7, 2, 0, 0, 6362, 6363, 7, 8, 0, 0, 6363, 6364, 7, 21, 0, 0, 6364, 6365, + 7, 5, 0, 0, 6365, 6366, 7, 10, 0, 0, 6366, 6367, 7, 23, 0, 0, 6367, 6368, + 7, 6, 0, 0, 6368, 292, 1, 0, 0, 0, 6369, 6370, 7, 1, 0, 0, 6370, 6371, + 7, 2, 0, 0, 6371, 6372, 7, 9, 0, 0, 6372, 6373, 7, 18, 0, 0, 6373, 294, + 1, 0, 0, 0, 6374, 6375, 7, 1, 0, 0, 6375, 6376, 7, 2, 0, 0, 6376, 6377, + 7, 2, 0, 0, 6377, 6378, 7, 11, 0, 0, 6378, 6379, 7, 6, 0, 0, 6379, 6380, + 7, 0, 0, 0, 6380, 6381, 7, 7, 0, 0, 6381, 296, 1, 0, 0, 0, 6382, 6383, + 7, 1, 0, 0, 6383, 6384, 7, 2, 0, 0, 6384, 6385, 7, 4, 0, 0, 6385, 6386, + 7, 19, 0, 0, 6386, 298, 1, 0, 0, 0, 6387, 6388, 7, 1, 0, 0, 6388, 6389, + 7, 2, 0, 0, 6389, 6390, 7, 12, 0, 0, 6390, 6391, 7, 7, 0, 0, 6391, 6392, + 7, 9, 0, 0, 6392, 300, 1, 0, 0, 0, 6393, 6394, 7, 1, 0, 0, 6394, 6395, + 7, 3, 0, 0, 6395, 6396, 7, 0, 0, 0, 6396, 6397, 7, 7, 0, 0, 6397, 6398, + 7, 8, 0, 0, 6398, 6399, 7, 19, 0, 0, 6399, 302, 1, 0, 0, 0, 6400, 6401, + 7, 1, 0, 0, 6401, 6402, 7, 3, 0, 0, 6402, 6403, 7, 6, 0, 0, 6403, 6404, + 7, 0, 0, 0, 6404, 6405, 7, 9, 0, 0, 6405, 6406, 7, 4, 0, 0, 6406, 6407, + 7, 19, 0, 0, 6407, 304, 1, 0, 0, 0, 6408, 6409, 7, 1, 0, 0, 6409, 6410, + 7, 3, 0, 0, 6410, 6411, 7, 2, 0, 0, 6411, 6412, 7, 0, 0, 0, 6412, 6413, + 7, 9, 0, 0, 6413, 6414, 7, 8, 0, 0, 6414, 6415, 7, 0, 0, 0, 6415, 6416, + 7, 5, 0, 0, 6416, 6417, 7, 4, 0, 0, 6417, 306, 1, 0, 0, 0, 6418, 6419, + 7, 1, 0, 0, 6419, 6420, 7, 5, 0, 0, 6420, 6421, 7, 2, 0, 0, 6421, 6422, + 7, 7, 0, 0, 6422, 308, 1, 0, 0, 0, 6423, 6424, 7, 1, 0, 0, 6424, 6425, + 7, 12, 0, 0, 6425, 6426, 7, 16, 0, 0, 6426, 6427, 7, 16, 0, 0, 6427, 6428, + 7, 6, 0, 0, 6428, 6429, 7, 3, 0, 0, 6429, 310, 1, 0, 0, 0, 6430, 6431, + 7, 1, 0, 0, 6431, 6432, 7, 12, 0, 0, 6432, 6433, 7, 16, 0, 0, 6433, 6434, + 7, 16, 0, 0, 6434, 6435, 7, 6, 0, 0, 6435, 6436, 7, 3, 0, 0, 6436, 6437, + 5, 95, 0, 0, 6437, 6438, 7, 8, 0, 0, 6438, 6439, 7, 0, 0, 0, 6439, 6440, + 7, 8, 0, 0, 6440, 6441, 7, 19, 0, 0, 6441, 6442, 7, 6, 0, 0, 6442, 312, + 1, 0, 0, 0, 6443, 6444, 7, 1, 0, 0, 6444, 6445, 7, 12, 0, 0, 6445, 6446, + 7, 16, 0, 0, 6446, 6447, 7, 16, 0, 0, 6447, 6448, 7, 6, 0, 0, 6448, 6449, + 7, 3, 0, 0, 6449, 6450, 5, 95, 0, 0, 6450, 6451, 7, 15, 0, 0, 6451, 6452, + 7, 2, 0, 0, 6452, 6453, 7, 2, 0, 0, 6453, 6454, 7, 11, 0, 0, 6454, 314, + 1, 0, 0, 0, 6455, 6456, 7, 1, 0, 0, 6456, 6457, 7, 12, 0, 0, 6457, 6458, + 7, 10, 0, 0, 6458, 6459, 7, 11, 0, 0, 6459, 6460, 7, 9, 0, 0, 6460, 316, + 1, 0, 0, 0, 6461, 6462, 7, 1, 0, 0, 6462, 6463, 7, 12, 0, 0, 6463, 6464, + 7, 11, 0, 0, 6464, 6465, 7, 21, 0, 0, 6465, 318, 1, 0, 0, 0, 6466, 6467, + 7, 1, 0, 0, 6467, 6468, 7, 18, 0, 0, 6468, 320, 1, 0, 0, 0, 6469, 6470, + 7, 1, 0, 0, 6470, 6471, 7, 18, 0, 0, 6471, 6472, 7, 15, 0, 0, 6472, 6473, + 7, 0, 0, 0, 6473, 6474, 7, 5, 0, 0, 6474, 6475, 7, 5, 0, 0, 6475, 6476, + 5, 95, 0, 0, 6476, 6477, 7, 3, 0, 0, 6477, 6478, 7, 6, 0, 0, 6478, 6479, + 7, 8, 0, 0, 6479, 6480, 7, 12, 0, 0, 6480, 6481, 7, 3, 0, 0, 6481, 6482, + 7, 5, 0, 0, 6482, 6483, 7, 10, 0, 0, 6483, 6484, 7, 13, 0, 0, 6484, 6485, + 7, 6, 0, 0, 6485, 6486, 5, 95, 0, 0, 6486, 6487, 7, 8, 0, 0, 6487, 6488, + 7, 19, 0, 0, 6488, 6489, 7, 6, 0, 0, 6489, 6490, 7, 8, 0, 0, 6490, 6491, + 7, 21, 0, 0, 6491, 322, 1, 0, 0, 0, 6492, 6493, 7, 1, 0, 0, 6493, 6494, + 7, 18, 0, 0, 6494, 6495, 7, 15, 0, 0, 6495, 6496, 7, 0, 0, 0, 6496, 6497, + 7, 5, 0, 0, 6497, 6498, 7, 5, 0, 0, 6498, 6499, 5, 95, 0, 0, 6499, 6500, + 7, 12, 0, 0, 6500, 6501, 7, 20, 0, 0, 6501, 6502, 7, 13, 0, 0, 6502, 6503, + 7, 8, 0, 0, 6503, 324, 1, 0, 0, 0, 6504, 6505, 7, 1, 0, 0, 6505, 6506, + 7, 18, 0, 0, 6506, 6507, 7, 4, 0, 0, 6507, 6508, 7, 6, 0, 0, 6508, 326, + 1, 0, 0, 0, 6509, 6510, 7, 1, 0, 0, 6510, 6511, 7, 18, 0, 0, 6511, 6512, + 7, 4, 0, 0, 6512, 6513, 7, 6, 0, 0, 6513, 6514, 7, 5, 0, 0, 6514, 328, + 1, 0, 0, 0, 6515, 6516, 7, 1, 0, 0, 6516, 6517, 7, 18, 0, 0, 6517, 6518, + 7, 4, 0, 0, 6518, 6519, 7, 6, 0, 0, 6519, 6520, 7, 2, 0, 0, 6520, 6521, + 7, 3, 0, 0, 6521, 6522, 7, 9, 0, 0, 6522, 6523, 7, 6, 0, 0, 6523, 6524, + 7, 3, 0, 0, 6524, 6525, 7, 14, 0, 0, 6525, 6526, 7, 0, 0, 0, 6526, 6527, + 7, 3, 0, 0, 6527, 6528, 7, 21, 0, 0, 6528, 330, 1, 0, 0, 0, 6529, 6530, + 7, 8, 0, 0, 6530, 6531, 7, 0, 0, 0, 6531, 6532, 7, 8, 0, 0, 6532, 6533, + 7, 19, 0, 0, 6533, 6534, 7, 6, 0, 0, 6534, 332, 1, 0, 0, 0, 6535, 6536, + 7, 8, 0, 0, 6536, 6537, 7, 0, 0, 0, 6537, 6538, 7, 8, 0, 0, 6538, 6539, + 7, 19, 0, 0, 6539, 6540, 7, 6, 0, 0, 6540, 6541, 5, 95, 0, 0, 6541, 6542, + 7, 8, 0, 0, 6542, 6543, 7, 1, 0, 0, 6543, 334, 1, 0, 0, 0, 6544, 6545, + 7, 8, 0, 0, 6545, 6546, 7, 0, 0, 0, 6546, 6547, 7, 8, 0, 0, 6547, 6548, + 7, 19, 0, 0, 6548, 6549, 7, 6, 0, 0, 6549, 6550, 5, 95, 0, 0, 6550, 6551, + 7, 10, 0, 0, 6551, 6552, 7, 7, 0, 0, 6552, 6553, 7, 5, 0, 0, 6553, 6554, + 7, 4, 0, 0, 6554, 6555, 7, 0, 0, 0, 6555, 6556, 7, 7, 0, 0, 6556, 6557, + 7, 8, 0, 0, 6557, 6558, 7, 6, 0, 0, 6558, 6559, 7, 5, 0, 0, 6559, 336, + 1, 0, 0, 0, 6560, 6561, 7, 8, 0, 0, 6561, 6562, 7, 0, 0, 0, 6562, 6563, + 7, 8, 0, 0, 6563, 6564, 7, 19, 0, 0, 6564, 6565, 7, 6, 0, 0, 6565, 6566, + 5, 95, 0, 0, 6566, 6567, 7, 4, 0, 0, 6567, 6568, 7, 6, 0, 0, 6568, 6569, + 7, 14, 0, 0, 6569, 6570, 7, 15, 0, 0, 6570, 6571, 5, 95, 0, 0, 6571, 6572, + 7, 4, 0, 0, 6572, 6573, 7, 0, 0, 0, 6573, 6574, 7, 1, 0, 0, 6574, 6575, + 7, 11, 0, 0, 6575, 6576, 7, 6, 0, 0, 6576, 338, 1, 0, 0, 0, 6577, 6578, + 7, 8, 0, 0, 6578, 6579, 7, 0, 0, 0, 6579, 6580, 7, 8, 0, 0, 6580, 6581, + 7, 19, 0, 0, 6581, 6582, 7, 10, 0, 0, 6582, 6583, 7, 7, 0, 0, 6583, 6584, + 7, 17, 0, 0, 6584, 340, 1, 0, 0, 0, 6585, 6586, 7, 8, 0, 0, 6586, 6587, + 7, 0, 0, 0, 6587, 6588, 7, 11, 0, 0, 6588, 6589, 7, 8, 0, 0, 6589, 6590, + 7, 12, 0, 0, 6590, 6591, 7, 11, 0, 0, 6591, 6592, 7, 0, 0, 0, 6592, 6593, + 7, 4, 0, 0, 6593, 6594, 7, 6, 0, 0, 6594, 6595, 7, 9, 0, 0, 6595, 342, + 1, 0, 0, 0, 6596, 6597, 7, 8, 0, 0, 6597, 6598, 7, 0, 0, 0, 6598, 6599, + 7, 11, 0, 0, 6599, 6600, 7, 11, 0, 0, 6600, 6601, 7, 1, 0, 0, 6601, 6602, + 7, 0, 0, 0, 6602, 6603, 7, 8, 0, 0, 6603, 6604, 7, 21, 0, 0, 6604, 344, + 1, 0, 0, 0, 6605, 6606, 7, 8, 0, 0, 6606, 6607, 7, 0, 0, 0, 6607, 6608, + 7, 11, 0, 0, 6608, 6609, 7, 11, 0, 0, 6609, 346, 1, 0, 0, 0, 6610, 6611, + 7, 8, 0, 0, 6611, 6612, 7, 0, 0, 0, 6612, 6613, 7, 7, 0, 0, 6613, 6614, + 7, 8, 0, 0, 6614, 6615, 7, 6, 0, 0, 6615, 6616, 7, 11, 0, 0, 6616, 348, + 1, 0, 0, 0, 6617, 6618, 7, 8, 0, 0, 6618, 6619, 7, 0, 0, 0, 6619, 6620, + 7, 7, 0, 0, 6620, 6621, 7, 2, 0, 0, 6621, 6622, 7, 7, 0, 0, 6622, 6623, + 7, 10, 0, 0, 6623, 6624, 7, 8, 0, 0, 6624, 6625, 7, 0, 0, 0, 6625, 6626, + 7, 11, 0, 0, 6626, 350, 1, 0, 0, 0, 6627, 6628, 7, 8, 0, 0, 6628, 6629, + 7, 0, 0, 0, 6629, 6630, 7, 15, 0, 0, 6630, 6631, 7, 0, 0, 0, 6631, 6632, + 7, 8, 0, 0, 6632, 6633, 7, 10, 0, 0, 6633, 6634, 7, 4, 0, 0, 6634, 6635, + 7, 18, 0, 0, 6635, 352, 1, 0, 0, 0, 6636, 6637, 7, 8, 0, 0, 6637, 6638, + 7, 0, 0, 0, 6638, 6639, 7, 15, 0, 0, 6639, 6640, 7, 4, 0, 0, 6640, 6641, + 7, 10, 0, 0, 6641, 6642, 7, 2, 0, 0, 6642, 6643, 7, 7, 0, 0, 6643, 354, + 1, 0, 0, 0, 6644, 6645, 7, 8, 0, 0, 6645, 6646, 7, 0, 0, 0, 6646, 6647, + 7, 3, 0, 0, 6647, 6648, 7, 9, 0, 0, 6648, 6649, 7, 10, 0, 0, 6649, 6650, + 7, 7, 0, 0, 6650, 6651, 7, 0, 0, 0, 6651, 6652, 7, 11, 0, 0, 6652, 6653, + 7, 10, 0, 0, 6653, 6654, 7, 4, 0, 0, 6654, 6655, 7, 18, 0, 0, 6655, 356, + 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, 8, 0, 0, 6660, 6661, 7, 0, 0, 0, 6661, 6662, + 7, 9, 0, 0, 6662, 6663, 7, 6, 0, 0, 6663, 358, 1, 0, 0, 0, 6664, 6665, + 7, 8, 0, 0, 6665, 6666, 7, 0, 0, 0, 6666, 6667, 7, 5, 0, 0, 6667, 6668, + 7, 6, 0, 0, 6668, 360, 1, 0, 0, 0, 6669, 6670, 7, 8, 0, 0, 6670, 6671, + 7, 0, 0, 0, 6671, 6672, 7, 5, 0, 0, 6672, 6673, 7, 4, 0, 0, 6673, 362, + 1, 0, 0, 0, 6674, 6675, 7, 8, 0, 0, 6675, 6676, 7, 0, 0, 0, 6676, 6677, + 7, 5, 0, 0, 6677, 6678, 7, 6, 0, 0, 6678, 6679, 5, 45, 0, 0, 6679, 6680, + 7, 5, 0, 0, 6680, 6681, 7, 6, 0, 0, 6681, 6682, 7, 7, 0, 0, 6682, 6683, + 7, 5, 0, 0, 6683, 6684, 7, 10, 0, 0, 6684, 6685, 7, 4, 0, 0, 6685, 6686, + 7, 10, 0, 0, 6686, 6687, 7, 13, 0, 0, 6687, 6688, 7, 6, 0, 0, 6688, 364, + 1, 0, 0, 0, 6689, 6690, 7, 8, 0, 0, 6690, 6691, 7, 0, 0, 0, 6691, 6692, + 7, 4, 0, 0, 6692, 6693, 7, 6, 0, 0, 6693, 6694, 7, 17, 0, 0, 6694, 6695, + 7, 2, 0, 0, 6695, 6696, 7, 3, 0, 0, 6696, 6697, 7, 18, 0, 0, 6697, 366, + 1, 0, 0, 0, 6698, 6699, 7, 8, 0, 0, 6699, 6700, 7, 9, 0, 0, 6700, 6701, + 7, 1, 0, 0, 6701, 6702, 5, 36, 0, 0, 6702, 6703, 7, 9, 0, 0, 6703, 6704, + 7, 6, 0, 0, 6704, 6705, 7, 16, 0, 0, 6705, 6706, 7, 0, 0, 0, 6706, 6707, + 7, 12, 0, 0, 6707, 6708, 7, 11, 0, 0, 6708, 6709, 7, 4, 0, 0, 6709, 368, + 1, 0, 0, 0, 6710, 6711, 7, 8, 0, 0, 6711, 6712, 7, 6, 0, 0, 6712, 6713, + 7, 10, 0, 0, 6713, 6714, 7, 11, 0, 0, 6714, 370, 1, 0, 0, 0, 6715, 6716, + 7, 8, 0, 0, 6716, 6717, 7, 6, 0, 0, 6717, 6718, 7, 11, 0, 0, 6718, 6719, + 7, 11, 0, 0, 6719, 6720, 5, 95, 0, 0, 6720, 6721, 7, 16, 0, 0, 6721, 6722, + 7, 11, 0, 0, 6722, 6723, 7, 0, 0, 0, 6723, 6724, 7, 5, 0, 0, 6724, 6725, + 7, 19, 0, 0, 6725, 6726, 5, 95, 0, 0, 6726, 6727, 7, 8, 0, 0, 6727, 6728, + 7, 0, 0, 0, 6728, 6729, 7, 8, 0, 0, 6729, 6730, 7, 19, 0, 0, 6730, 6731, + 7, 6, 0, 0, 6731, 372, 1, 0, 0, 0, 6732, 6733, 7, 8, 0, 0, 6733, 6734, + 7, 6, 0, 0, 6734, 6735, 7, 3, 0, 0, 6735, 6736, 7, 4, 0, 0, 6736, 6737, + 7, 10, 0, 0, 6737, 6738, 7, 16, 0, 0, 6738, 6739, 7, 10, 0, 0, 6739, 6740, + 7, 8, 0, 0, 6740, 6741, 7, 0, 0, 0, 6741, 6742, 7, 4, 0, 0, 6742, 6743, + 7, 6, 0, 0, 6743, 374, 1, 0, 0, 0, 6744, 6745, 7, 8, 0, 0, 6745, 6746, + 7, 16, 0, 0, 6746, 6747, 7, 10, 0, 0, 6747, 6748, 7, 11, 0, 0, 6748, 6749, + 7, 6, 0, 0, 6749, 376, 1, 0, 0, 0, 6750, 6751, 7, 8, 0, 0, 6751, 6752, + 7, 19, 0, 0, 6752, 6753, 7, 0, 0, 0, 6753, 6754, 7, 10, 0, 0, 6754, 6755, + 7, 7, 0, 0, 6755, 6756, 7, 6, 0, 0, 6756, 6757, 7, 9, 0, 0, 6757, 378, + 1, 0, 0, 0, 6758, 6759, 7, 8, 0, 0, 6759, 6760, 7, 19, 0, 0, 6760, 6761, + 7, 0, 0, 0, 6761, 6762, 7, 7, 0, 0, 6762, 6763, 7, 17, 0, 0, 6763, 6764, + 7, 6, 0, 0, 6764, 380, 1, 0, 0, 0, 6765, 6766, 7, 8, 0, 0, 6766, 6767, + 7, 19, 0, 0, 6767, 6768, 7, 0, 0, 0, 6768, 6769, 7, 7, 0, 0, 6769, 6770, + 7, 17, 0, 0, 6770, 6771, 7, 6, 0, 0, 6771, 6772, 7, 4, 0, 0, 6772, 6773, + 7, 3, 0, 0, 6773, 6774, 7, 0, 0, 0, 6774, 6775, 7, 8, 0, 0, 6775, 6776, + 7, 21, 0, 0, 6776, 6777, 7, 10, 0, 0, 6777, 6778, 7, 7, 0, 0, 6778, 6779, + 7, 17, 0, 0, 6779, 382, 1, 0, 0, 0, 6780, 6781, 7, 8, 0, 0, 6781, 6782, + 7, 19, 0, 0, 6782, 6783, 7, 0, 0, 0, 6783, 6784, 7, 7, 0, 0, 6784, 6785, + 7, 17, 0, 0, 6785, 6786, 7, 6, 0, 0, 6786, 6787, 5, 95, 0, 0, 6787, 6788, + 7, 9, 0, 0, 6788, 6789, 7, 12, 0, 0, 6789, 6790, 7, 15, 0, 0, 6790, 6791, + 7, 21, 0, 0, 6791, 6792, 7, 6, 0, 0, 6792, 6793, 7, 18, 0, 0, 6793, 6794, + 5, 95, 0, 0, 6794, 6795, 7, 6, 0, 0, 6795, 6796, 7, 3, 0, 0, 6796, 6797, + 7, 3, 0, 0, 6797, 6798, 7, 2, 0, 0, 6798, 6799, 7, 3, 0, 0, 6799, 6800, + 5, 95, 0, 0, 6800, 6801, 7, 10, 0, 0, 6801, 6802, 7, 7, 0, 0, 6802, 6803, + 7, 9, 0, 0, 6803, 6804, 7, 6, 0, 0, 6804, 6805, 7, 25, 0, 0, 6805, 384, + 1, 0, 0, 0, 6806, 6807, 7, 8, 0, 0, 6807, 6808, 7, 19, 0, 0, 6808, 6809, + 7, 0, 0, 0, 6809, 6810, 7, 3, 0, 0, 6810, 6811, 7, 0, 0, 0, 6811, 6812, + 7, 8, 0, 0, 6812, 6813, 7, 4, 0, 0, 6813, 6814, 7, 6, 0, 0, 6814, 6815, + 7, 3, 0, 0, 6815, 386, 1, 0, 0, 0, 6816, 6817, 7, 8, 0, 0, 6817, 6818, + 7, 19, 0, 0, 6818, 6819, 7, 0, 0, 0, 6819, 6820, 7, 3, 0, 0, 6820, 6821, + 7, 0, 0, 0, 6821, 6822, 7, 8, 0, 0, 6822, 6823, 7, 4, 0, 0, 6823, 6824, + 7, 6, 0, 0, 6824, 6825, 7, 3, 0, 0, 6825, 6826, 7, 5, 0, 0, 6826, 388, + 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, 7, 0, 0, 0, 6832, 6833, + 7, 8, 0, 0, 6833, 6834, 7, 4, 0, 0, 6834, 6835, 7, 6, 0, 0, 6835, 6836, + 7, 3, 0, 0, 6836, 6837, 7, 5, 0, 0, 6837, 6838, 7, 6, 0, 0, 6838, 6839, + 7, 4, 0, 0, 6839, 390, 1, 0, 0, 0, 6840, 6841, 7, 8, 0, 0, 6841, 6842, + 7, 19, 0, 0, 6842, 6843, 7, 0, 0, 0, 6843, 6844, 7, 3, 0, 0, 6844, 392, + 1, 0, 0, 0, 6845, 6846, 7, 8, 0, 0, 6846, 6847, 7, 19, 0, 0, 6847, 6848, + 7, 0, 0, 0, 6848, 6849, 7, 3, 0, 0, 6849, 6850, 5, 95, 0, 0, 6850, 6851, + 7, 8, 0, 0, 6851, 6852, 7, 5, 0, 0, 6852, 394, 1, 0, 0, 0, 6853, 6854, + 7, 8, 0, 0, 6854, 6855, 7, 19, 0, 0, 6855, 6856, 7, 0, 0, 0, 6856, 6857, + 7, 3, 0, 0, 6857, 6858, 7, 4, 0, 0, 6858, 6859, 7, 2, 0, 0, 6859, 6860, + 7, 3, 0, 0, 6860, 6861, 7, 2, 0, 0, 6861, 6862, 7, 22, 0, 0, 6862, 6863, + 7, 10, 0, 0, 6863, 6864, 7, 9, 0, 0, 6864, 396, 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, 6871, 5, 95, 0, 0, 6871, 6872, + 7, 0, 0, 0, 6872, 6873, 7, 8, 0, 0, 6873, 6874, 7, 11, 0, 0, 6874, 6875, + 5, 95, 0, 0, 6875, 6876, 7, 3, 0, 0, 6876, 6877, 7, 6, 0, 0, 6877, 6878, + 7, 22, 0, 0, 6878, 6879, 7, 3, 0, 0, 6879, 6880, 7, 10, 0, 0, 6880, 6881, + 7, 4, 0, 0, 6881, 6882, 7, 6, 0, 0, 6882, 398, 1, 0, 0, 0, 6883, 6884, + 7, 8, 0, 0, 6884, 6885, 7, 19, 0, 0, 6885, 6886, 7, 6, 0, 0, 6886, 6887, + 7, 8, 0, 0, 6887, 6888, 7, 21, 0, 0, 6888, 400, 1, 0, 0, 0, 6889, 6890, + 7, 8, 0, 0, 6890, 6891, 7, 19, 0, 0, 6891, 6892, 7, 6, 0, 0, 6892, 6893, + 7, 8, 0, 0, 6893, 6894, 7, 21, 0, 0, 6894, 6895, 7, 15, 0, 0, 6895, 6896, + 7, 2, 0, 0, 6896, 6897, 7, 10, 0, 0, 6897, 6898, 7, 7, 0, 0, 6898, 6899, + 7, 4, 0, 0, 6899, 402, 1, 0, 0, 0, 6900, 6901, 7, 8, 0, 0, 6901, 6902, + 7, 19, 0, 0, 6902, 6903, 7, 10, 0, 0, 6903, 6904, 7, 11, 0, 0, 6904, 6905, + 7, 9, 0, 0, 6905, 404, 1, 0, 0, 0, 6906, 6907, 7, 8, 0, 0, 6907, 6908, + 7, 19, 0, 0, 6908, 6909, 7, 2, 0, 0, 6909, 6910, 7, 2, 0, 0, 6910, 6911, + 7, 5, 0, 0, 6911, 6912, 7, 6, 0, 0, 6912, 406, 1, 0, 0, 0, 6913, 6914, + 7, 8, 0, 0, 6914, 6915, 7, 19, 0, 0, 6915, 6916, 7, 3, 0, 0, 6916, 408, + 1, 0, 0, 0, 6917, 6918, 7, 8, 0, 0, 6918, 6919, 7, 19, 0, 0, 6919, 6920, + 7, 12, 0, 0, 6920, 6921, 7, 7, 0, 0, 6921, 6922, 7, 21, 0, 0, 6922, 410, + 1, 0, 0, 0, 6923, 6924, 7, 8, 0, 0, 6924, 6925, 7, 11, 0, 0, 6925, 6926, + 7, 0, 0, 0, 6926, 6927, 7, 5, 0, 0, 6927, 6928, 7, 5, 0, 0, 6928, 412, + 1, 0, 0, 0, 6929, 6930, 7, 8, 0, 0, 6930, 6931, 7, 11, 0, 0, 6931, 6932, + 7, 0, 0, 0, 6932, 6933, 7, 5, 0, 0, 6933, 6934, 7, 5, 0, 0, 6934, 6935, + 7, 10, 0, 0, 6935, 6936, 7, 16, 0, 0, 6936, 6937, 7, 10, 0, 0, 6937, 6938, + 7, 8, 0, 0, 6938, 6939, 7, 0, 0, 0, 6939, 6940, 7, 4, 0, 0, 6940, 6941, + 7, 10, 0, 0, 6941, 6942, 7, 2, 0, 0, 6942, 6943, 7, 7, 0, 0, 6943, 414, + 1, 0, 0, 0, 6944, 6945, 7, 8, 0, 0, 6945, 6946, 7, 11, 0, 0, 6946, 6947, + 7, 0, 0, 0, 6947, 6948, 7, 5, 0, 0, 6948, 6949, 7, 5, 0, 0, 6949, 6950, + 7, 10, 0, 0, 6950, 6951, 7, 16, 0, 0, 6951, 6952, 7, 10, 0, 0, 6952, 6953, + 7, 6, 0, 0, 6953, 6954, 7, 3, 0, 0, 6954, 416, 1, 0, 0, 0, 6955, 6956, + 7, 8, 0, 0, 6956, 6957, 7, 11, 0, 0, 6957, 6958, 7, 0, 0, 0, 6958, 6959, + 7, 12, 0, 0, 6959, 6960, 7, 5, 0, 0, 6960, 6961, 7, 6, 0, 0, 6961, 418, + 1, 0, 0, 0, 6962, 6963, 7, 8, 0, 0, 6963, 6964, 7, 11, 0, 0, 6964, 6965, + 7, 6, 0, 0, 6965, 6966, 7, 0, 0, 0, 6966, 6967, 7, 7, 0, 0, 6967, 420, + 1, 0, 0, 0, 6968, 6969, 7, 8, 0, 0, 6969, 6970, 7, 11, 0, 0, 6970, 6971, + 7, 6, 0, 0, 6971, 6972, 7, 0, 0, 0, 6972, 6973, 7, 7, 0, 0, 6973, 6974, + 7, 12, 0, 0, 6974, 6975, 7, 15, 0, 0, 6975, 422, 1, 0, 0, 0, 6976, 6977, + 7, 8, 0, 0, 6977, 6978, 7, 11, 0, 0, 6978, 6979, 7, 6, 0, 0, 6979, 6980, + 7, 0, 0, 0, 6980, 6981, 7, 3, 0, 0, 6981, 424, 1, 0, 0, 0, 6982, 6983, + 7, 8, 0, 0, 6983, 426, 1, 0, 0, 0, 6984, 6985, 7, 8, 0, 0, 6985, 6986, + 7, 11, 0, 0, 6986, 6987, 7, 10, 0, 0, 6987, 6988, 7, 6, 0, 0, 6988, 6989, + 7, 7, 0, 0, 6989, 6990, 7, 4, 0, 0, 6990, 428, 1, 0, 0, 0, 6991, 6992, + 7, 8, 0, 0, 6992, 6993, 7, 11, 0, 0, 6993, 6994, 7, 2, 0, 0, 6994, 6995, + 7, 1, 0, 0, 6995, 430, 1, 0, 0, 0, 6996, 6997, 7, 8, 0, 0, 6997, 6998, + 7, 11, 0, 0, 6998, 6999, 7, 2, 0, 0, 6999, 7000, 7, 7, 0, 0, 7000, 7001, + 7, 6, 0, 0, 7001, 432, 1, 0, 0, 0, 7002, 7003, 7, 8, 0, 0, 7003, 7004, + 7, 11, 0, 0, 7004, 7005, 7, 2, 0, 0, 7005, 7006, 7, 5, 0, 0, 7006, 7007, + 7, 6, 0, 0, 7007, 7008, 5, 95, 0, 0, 7008, 7009, 7, 8, 0, 0, 7009, 7010, + 7, 0, 0, 0, 7010, 7011, 7, 8, 0, 0, 7011, 7012, 7, 19, 0, 0, 7012, 7013, + 7, 6, 0, 0, 7013, 7014, 7, 9, 0, 0, 7014, 7015, 5, 95, 0, 0, 7015, 7016, + 7, 2, 0, 0, 7016, 7017, 7, 15, 0, 0, 7017, 7018, 7, 6, 0, 0, 7018, 7019, + 7, 7, 0, 0, 7019, 7020, 5, 95, 0, 0, 7020, 7021, 7, 8, 0, 0, 7021, 7022, + 7, 12, 0, 0, 7022, 7023, 7, 3, 0, 0, 7023, 7024, 7, 5, 0, 0, 7024, 7025, + 7, 2, 0, 0, 7025, 7026, 7, 3, 0, 0, 7026, 7027, 7, 5, 0, 0, 7027, 434, + 1, 0, 0, 0, 7028, 7029, 7, 8, 0, 0, 7029, 7030, 7, 11, 0, 0, 7030, 7031, + 7, 2, 0, 0, 7031, 7032, 7, 5, 0, 0, 7032, 7033, 7, 6, 0, 0, 7033, 436, + 1, 0, 0, 0, 7034, 7035, 7, 8, 0, 0, 7035, 7036, 7, 11, 0, 0, 7036, 7037, + 7, 12, 0, 0, 7037, 7038, 7, 5, 0, 0, 7038, 7039, 7, 4, 0, 0, 7039, 7040, + 7, 6, 0, 0, 7040, 7041, 7, 3, 0, 0, 7041, 7042, 5, 95, 0, 0, 7042, 7043, + 7, 1, 0, 0, 7043, 7044, 7, 18, 0, 0, 7044, 7045, 5, 95, 0, 0, 7045, 7046, + 7, 3, 0, 0, 7046, 7047, 7, 2, 0, 0, 7047, 7048, 7, 22, 0, 0, 7048, 7049, + 7, 10, 0, 0, 7049, 7050, 7, 9, 0, 0, 7050, 438, 1, 0, 0, 0, 7051, 7052, + 7, 8, 0, 0, 7052, 7053, 7, 11, 0, 0, 7053, 7054, 7, 12, 0, 0, 7054, 7055, + 7, 5, 0, 0, 7055, 7056, 7, 4, 0, 0, 7056, 7057, 7, 6, 0, 0, 7057, 7058, + 7, 3, 0, 0, 7058, 440, 1, 0, 0, 0, 7059, 7060, 7, 8, 0, 0, 7060, 7061, + 7, 11, 0, 0, 7061, 7062, 7, 12, 0, 0, 7062, 7063, 7, 5, 0, 0, 7063, 7064, + 7, 4, 0, 0, 7064, 7065, 7, 6, 0, 0, 7065, 7066, 7, 3, 0, 0, 7066, 7067, + 5, 95, 0, 0, 7067, 7068, 7, 9, 0, 0, 7068, 7069, 7, 6, 0, 0, 7069, 7070, + 7, 4, 0, 0, 7070, 7071, 7, 0, 0, 0, 7071, 7072, 7, 10, 0, 0, 7072, 7073, + 7, 11, 0, 0, 7073, 7074, 7, 5, 0, 0, 7074, 442, 1, 0, 0, 0, 7075, 7076, + 7, 8, 0, 0, 7076, 7077, 7, 11, 0, 0, 7077, 7078, 7, 12, 0, 0, 7078, 7079, + 7, 5, 0, 0, 7079, 7080, 7, 4, 0, 0, 7080, 7081, 7, 6, 0, 0, 7081, 7082, + 7, 3, 0, 0, 7082, 7083, 5, 95, 0, 0, 7083, 7084, 7, 9, 0, 0, 7084, 7085, + 7, 10, 0, 0, 7085, 7086, 7, 5, 0, 0, 7086, 7087, 7, 4, 0, 0, 7087, 7088, + 7, 0, 0, 0, 7088, 7089, 7, 7, 0, 0, 7089, 7090, 7, 8, 0, 0, 7090, 7091, + 7, 6, 0, 0, 7091, 444, 1, 0, 0, 0, 7092, 7093, 7, 8, 0, 0, 7093, 7094, + 7, 11, 0, 0, 7094, 7095, 7, 12, 0, 0, 7095, 7096, 7, 5, 0, 0, 7096, 7097, + 7, 4, 0, 0, 7097, 7098, 7, 6, 0, 0, 7098, 7099, 7, 3, 0, 0, 7099, 7100, + 5, 95, 0, 0, 7100, 7101, 7, 10, 0, 0, 7101, 7102, 7, 9, 0, 0, 7102, 446, + 1, 0, 0, 0, 7103, 7104, 7, 8, 0, 0, 7104, 7105, 7, 11, 0, 0, 7105, 7106, + 7, 12, 0, 0, 7106, 7107, 7, 5, 0, 0, 7107, 7108, 7, 4, 0, 0, 7108, 7109, + 7, 6, 0, 0, 7109, 7110, 7, 3, 0, 0, 7110, 7111, 7, 10, 0, 0, 7111, 7112, + 7, 7, 0, 0, 7112, 7113, 7, 17, 0, 0, 7113, 448, 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, 7, 10, 0, 0, 7122, 7123, 7, 7, 0, 0, 7123, 7124, + 7, 17, 0, 0, 7124, 7125, 5, 95, 0, 0, 7125, 7126, 7, 16, 0, 0, 7126, 7127, + 7, 0, 0, 0, 7127, 7128, 7, 8, 0, 0, 7128, 7129, 7, 4, 0, 0, 7129, 7130, + 7, 2, 0, 0, 7130, 7131, 7, 3, 0, 0, 7131, 450, 1, 0, 0, 0, 7132, 7133, + 7, 8, 0, 0, 7133, 7134, 7, 11, 0, 0, 7134, 7135, 7, 12, 0, 0, 7135, 7136, + 7, 5, 0, 0, 7136, 7137, 7, 4, 0, 0, 7137, 7138, 7, 6, 0, 0, 7138, 7139, + 7, 3, 0, 0, 7139, 7140, 5, 95, 0, 0, 7140, 7141, 7, 15, 0, 0, 7141, 7142, + 7, 3, 0, 0, 7142, 7143, 7, 2, 0, 0, 7143, 7144, 7, 1, 0, 0, 7144, 7145, + 7, 0, 0, 0, 7145, 7146, 7, 1, 0, 0, 7146, 7147, 7, 10, 0, 0, 7147, 7148, + 7, 11, 0, 0, 7148, 7149, 7, 10, 0, 0, 7149, 7150, 7, 4, 0, 0, 7150, 7151, + 7, 18, 0, 0, 7151, 452, 1, 0, 0, 0, 7152, 7153, 7, 8, 0, 0, 7153, 7154, + 7, 11, 0, 0, 7154, 7155, 7, 12, 0, 0, 7155, 7156, 7, 5, 0, 0, 7156, 7157, + 7, 4, 0, 0, 7157, 7158, 7, 6, 0, 0, 7158, 7159, 7, 3, 0, 0, 7159, 7160, + 5, 95, 0, 0, 7160, 7161, 7, 5, 0, 0, 7161, 7162, 7, 6, 0, 0, 7162, 7163, + 7, 4, 0, 0, 7163, 454, 1, 0, 0, 0, 7164, 7165, 7, 8, 0, 0, 7165, 7166, + 7, 2, 0, 0, 7166, 7167, 7, 0, 0, 0, 7167, 7168, 7, 11, 0, 0, 7168, 7169, + 7, 6, 0, 0, 7169, 7170, 7, 5, 0, 0, 7170, 7171, 7, 8, 0, 0, 7171, 7172, + 7, 6, 0, 0, 7172, 456, 1, 0, 0, 0, 7173, 7174, 7, 8, 0, 0, 7174, 7175, + 7, 2, 0, 0, 7175, 7176, 7, 0, 0, 0, 7176, 7177, 7, 11, 0, 0, 7177, 7178, + 7, 6, 0, 0, 7178, 7179, 7, 5, 0, 0, 7179, 7180, 7, 8, 0, 0, 7180, 7181, + 7, 6, 0, 0, 7181, 7182, 5, 95, 0, 0, 7182, 7183, 7, 5, 0, 0, 7183, 7184, + 7, 24, 0, 0, 7184, 458, 1, 0, 0, 0, 7185, 7186, 7, 8, 0, 0, 7186, 7187, + 7, 2, 0, 0, 7187, 7188, 7, 0, 0, 0, 7188, 7189, 7, 3, 0, 0, 7189, 7190, + 7, 5, 0, 0, 7190, 7191, 7, 6, 0, 0, 7191, 460, 1, 0, 0, 0, 7192, 7193, + 7, 8, 0, 0, 7193, 7194, 7, 2, 0, 0, 7194, 7195, 5, 95, 0, 0, 7195, 7196, + 7, 0, 0, 0, 7196, 7197, 7, 12, 0, 0, 7197, 7198, 7, 4, 0, 0, 7198, 7199, + 7, 19, 0, 0, 7199, 7200, 5, 95, 0, 0, 7200, 7201, 7, 10, 0, 0, 7201, 7202, + 7, 7, 0, 0, 7202, 7203, 7, 9, 0, 0, 7203, 462, 1, 0, 0, 0, 7204, 7205, + 7, 8, 0, 0, 7205, 7206, 7, 2, 0, 0, 7206, 7207, 7, 11, 0, 0, 7207, 7208, + 7, 9, 0, 0, 7208, 464, 1, 0, 0, 0, 7209, 7210, 7, 8, 0, 0, 7210, 7211, + 7, 2, 0, 0, 7211, 7212, 7, 11, 0, 0, 7212, 7213, 7, 11, 0, 0, 7213, 7214, + 7, 6, 0, 0, 7214, 7215, 7, 8, 0, 0, 7215, 7216, 7, 4, 0, 0, 7216, 466, + 1, 0, 0, 0, 7217, 7218, 7, 8, 0, 0, 7218, 7219, 7, 2, 0, 0, 7219, 7220, + 7, 11, 0, 0, 7220, 7221, 7, 11, 0, 0, 7221, 7222, 7, 6, 0, 0, 7222, 7223, + 7, 8, 0, 0, 7223, 7224, 7, 4, 0, 0, 7224, 7225, 7, 10, 0, 0, 7225, 7226, + 7, 2, 0, 0, 7226, 7227, 7, 7, 0, 0, 7227, 468, 1, 0, 0, 0, 7228, 7229, + 7, 8, 0, 0, 7229, 7230, 7, 2, 0, 0, 7230, 7231, 7, 11, 0, 0, 7231, 7232, + 7, 12, 0, 0, 7232, 7233, 7, 14, 0, 0, 7233, 7234, 7, 7, 0, 0, 7234, 7235, + 7, 0, 0, 0, 7235, 7236, 7, 3, 0, 0, 7236, 470, 1, 0, 0, 0, 7237, 7238, + 7, 8, 0, 0, 7238, 7239, 7, 2, 0, 0, 7239, 7240, 7, 11, 0, 0, 7240, 7241, + 7, 12, 0, 0, 7241, 7242, 7, 14, 0, 0, 7242, 7243, 7, 7, 0, 0, 7243, 7244, + 5, 95, 0, 0, 7244, 7245, 7, 0, 0, 0, 7245, 7246, 7, 12, 0, 0, 7246, 7247, + 7, 4, 0, 0, 7247, 7248, 7, 19, 0, 0, 7248, 7249, 5, 95, 0, 0, 7249, 7250, + 7, 10, 0, 0, 7250, 7251, 7, 7, 0, 0, 7251, 7252, 7, 9, 0, 0, 7252, 7253, + 7, 10, 0, 0, 7253, 7254, 7, 8, 0, 0, 7254, 7255, 7, 0, 0, 0, 7255, 7256, + 7, 4, 0, 0, 7256, 7257, 7, 2, 0, 0, 7257, 7258, 7, 3, 0, 0, 7258, 472, + 1, 0, 0, 0, 7259, 7260, 7, 8, 0, 0, 7260, 7261, 7, 2, 0, 0, 7261, 7262, + 7, 11, 0, 0, 7262, 7263, 7, 12, 0, 0, 7263, 7264, 7, 14, 0, 0, 7264, 7265, + 7, 7, 0, 0, 7265, 474, 1, 0, 0, 0, 7266, 7267, 7, 8, 0, 0, 7267, 7268, + 7, 2, 0, 0, 7268, 7269, 7, 11, 0, 0, 7269, 7270, 7, 12, 0, 0, 7270, 7271, + 7, 14, 0, 0, 7271, 7272, 7, 7, 0, 0, 7272, 7273, 7, 5, 0, 0, 7273, 476, + 1, 0, 0, 0, 7274, 7275, 7, 8, 0, 0, 7275, 7276, 7, 2, 0, 0, 7276, 7277, + 7, 11, 0, 0, 7277, 7278, 7, 12, 0, 0, 7278, 7279, 7, 14, 0, 0, 7279, 7280, + 7, 7, 0, 0, 7280, 7281, 5, 95, 0, 0, 7281, 7282, 7, 5, 0, 0, 7282, 7283, + 7, 4, 0, 0, 7283, 7284, 7, 0, 0, 0, 7284, 7285, 7, 4, 0, 0, 7285, 7286, + 7, 5, 0, 0, 7286, 478, 1, 0, 0, 0, 7287, 7288, 7, 8, 0, 0, 7288, 7289, + 7, 2, 0, 0, 7289, 7290, 7, 11, 0, 0, 7290, 7291, 7, 12, 0, 0, 7291, 7292, + 7, 14, 0, 0, 7292, 7293, 7, 7, 0, 0, 7293, 7294, 5, 95, 0, 0, 7294, 7295, + 7, 13, 0, 0, 7295, 7296, 7, 0, 0, 0, 7296, 7297, 7, 11, 0, 0, 7297, 7298, + 7, 12, 0, 0, 7298, 7299, 7, 6, 0, 0, 7299, 480, 1, 0, 0, 0, 7300, 7301, + 7, 8, 0, 0, 7301, 7302, 7, 2, 0, 0, 7302, 7303, 7, 14, 0, 0, 7303, 7304, + 7, 14, 0, 0, 7304, 7305, 7, 6, 0, 0, 7305, 7306, 7, 7, 0, 0, 7306, 7307, + 7, 4, 0, 0, 7307, 482, 1, 0, 0, 0, 7308, 7309, 7, 8, 0, 0, 7309, 7310, + 7, 2, 0, 0, 7310, 7311, 7, 14, 0, 0, 7311, 7312, 7, 14, 0, 0, 7312, 7313, + 7, 10, 0, 0, 7313, 7314, 7, 4, 0, 0, 7314, 484, 1, 0, 0, 0, 7315, 7316, + 7, 8, 0, 0, 7316, 7317, 7, 2, 0, 0, 7317, 7318, 7, 14, 0, 0, 7318, 7319, + 7, 14, 0, 0, 7319, 7320, 7, 10, 0, 0, 7320, 7321, 7, 4, 0, 0, 7321, 7322, + 7, 4, 0, 0, 7322, 7323, 7, 6, 0, 0, 7323, 7324, 7, 9, 0, 0, 7324, 486, + 1, 0, 0, 0, 7325, 7326, 7, 8, 0, 0, 7326, 7327, 7, 2, 0, 0, 7327, 7328, + 7, 14, 0, 0, 7328, 7329, 7, 14, 0, 0, 7329, 7330, 7, 2, 0, 0, 7330, 7331, + 7, 7, 0, 0, 7331, 488, 1, 0, 0, 0, 7332, 7333, 7, 8, 0, 0, 7333, 7334, + 7, 2, 0, 0, 7334, 7335, 7, 14, 0, 0, 7335, 7336, 7, 14, 0, 0, 7336, 7337, + 7, 2, 0, 0, 7337, 7338, 7, 7, 0, 0, 7338, 7339, 5, 95, 0, 0, 7339, 7340, + 7, 9, 0, 0, 7340, 7341, 7, 0, 0, 0, 7341, 7342, 7, 4, 0, 0, 7342, 7343, + 7, 0, 0, 0, 7343, 490, 1, 0, 0, 0, 7344, 7345, 7, 8, 0, 0, 7345, 7346, + 7, 2, 0, 0, 7346, 7347, 7, 14, 0, 0, 7347, 7348, 7, 15, 0, 0, 7348, 7349, + 7, 0, 0, 0, 7349, 7350, 7, 8, 0, 0, 7350, 7351, 7, 4, 0, 0, 7351, 492, + 1, 0, 0, 0, 7352, 7353, 7, 8, 0, 0, 7353, 7354, 7, 2, 0, 0, 7354, 7355, + 7, 14, 0, 0, 7355, 7356, 7, 15, 0, 0, 7356, 7357, 7, 0, 0, 0, 7357, 7358, + 7, 4, 0, 0, 7358, 7359, 7, 10, 0, 0, 7359, 7360, 7, 1, 0, 0, 7360, 7361, + 7, 11, 0, 0, 7361, 7362, 7, 6, 0, 0, 7362, 494, 1, 0, 0, 0, 7363, 7364, + 7, 8, 0, 0, 7364, 7365, 7, 2, 0, 0, 7365, 7366, 7, 14, 0, 0, 7366, 7367, + 7, 15, 0, 0, 7367, 7368, 7, 0, 0, 0, 7368, 7369, 7, 4, 0, 0, 7369, 7370, + 7, 10, 0, 0, 7370, 7371, 7, 1, 0, 0, 7371, 7372, 7, 10, 0, 0, 7372, 7373, + 7, 11, 0, 0, 7373, 7374, 7, 10, 0, 0, 7374, 7375, 7, 4, 0, 0, 7375, 7376, + 7, 18, 0, 0, 7376, 496, 1, 0, 0, 0, 7377, 7378, 7, 8, 0, 0, 7378, 7379, + 7, 2, 0, 0, 7379, 7380, 7, 14, 0, 0, 7380, 7381, 7, 15, 0, 0, 7381, 7382, + 7, 10, 0, 0, 7382, 7383, 7, 11, 0, 0, 7383, 7384, 7, 6, 0, 0, 7384, 498, + 1, 0, 0, 0, 7385, 7386, 7, 8, 0, 0, 7386, 7387, 7, 2, 0, 0, 7387, 7388, + 7, 14, 0, 0, 7388, 7389, 7, 15, 0, 0, 7389, 7390, 7, 11, 0, 0, 7390, 7391, + 7, 6, 0, 0, 7391, 7392, 7, 4, 0, 0, 7392, 7393, 7, 6, 0, 0, 7393, 500, + 1, 0, 0, 0, 7394, 7395, 7, 8, 0, 0, 7395, 7396, 7, 2, 0, 0, 7396, 7397, + 7, 14, 0, 0, 7397, 7398, 7, 15, 0, 0, 7398, 7399, 7, 11, 0, 0, 7399, 7400, + 7, 10, 0, 0, 7400, 7401, 7, 0, 0, 0, 7401, 7402, 7, 7, 0, 0, 7402, 7403, + 7, 8, 0, 0, 7403, 7404, 7, 6, 0, 0, 7404, 502, 1, 0, 0, 0, 7405, 7406, + 7, 8, 0, 0, 7406, 7407, 7, 2, 0, 0, 7407, 7408, 7, 14, 0, 0, 7408, 7409, + 7, 15, 0, 0, 7409, 7410, 7, 2, 0, 0, 7410, 7411, 7, 7, 0, 0, 7411, 7412, + 7, 6, 0, 0, 7412, 7413, 7, 7, 0, 0, 7413, 7414, 7, 4, 0, 0, 7414, 504, + 1, 0, 0, 0, 7415, 7416, 7, 8, 0, 0, 7416, 7417, 7, 2, 0, 0, 7417, 7418, + 7, 14, 0, 0, 7418, 7419, 7, 15, 0, 0, 7419, 7420, 7, 2, 0, 0, 7420, 7421, + 7, 7, 0, 0, 7421, 7422, 7, 6, 0, 0, 7422, 7423, 7, 7, 0, 0, 7423, 7424, + 7, 4, 0, 0, 7424, 7425, 7, 5, 0, 0, 7425, 506, 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, 6, 0, 0, 7433, 508, 1, 0, 0, 0, 7434, 7435, 7, 8, 0, 0, 7435, 7436, + 7, 2, 0, 0, 7436, 7437, 7, 14, 0, 0, 7437, 7438, 7, 15, 0, 0, 7438, 7439, + 7, 2, 0, 0, 7439, 7440, 7, 5, 0, 0, 7440, 7441, 7, 10, 0, 0, 7441, 7442, + 7, 4, 0, 0, 7442, 7443, 7, 6, 0, 0, 7443, 510, 1, 0, 0, 0, 7444, 7445, + 7, 8, 0, 0, 7445, 7446, 7, 2, 0, 0, 7446, 7447, 7, 14, 0, 0, 7447, 7448, + 7, 15, 0, 0, 7448, 7449, 7, 2, 0, 0, 7449, 7450, 7, 5, 0, 0, 7450, 7451, + 7, 10, 0, 0, 7451, 7452, 7, 4, 0, 0, 7452, 7453, 7, 6, 0, 0, 7453, 7454, + 5, 95, 0, 0, 7454, 7455, 7, 11, 0, 0, 7455, 7456, 7, 10, 0, 0, 7456, 7457, + 7, 14, 0, 0, 7457, 7458, 7, 10, 0, 0, 7458, 7459, 7, 4, 0, 0, 7459, 512, + 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, 2, 0, 0, 7465, 7466, + 7, 12, 0, 0, 7466, 7467, 7, 7, 0, 0, 7467, 7468, 7, 9, 0, 0, 7468, 514, + 1, 0, 0, 0, 7469, 7470, 7, 8, 0, 0, 7470, 7471, 7, 2, 0, 0, 7471, 7472, + 7, 14, 0, 0, 7472, 7473, 7, 15, 0, 0, 7473, 7474, 7, 3, 0, 0, 7474, 7475, + 7, 6, 0, 0, 7475, 7476, 7, 5, 0, 0, 7476, 7477, 7, 5, 0, 0, 7477, 516, + 1, 0, 0, 0, 7478, 7479, 7, 8, 0, 0, 7479, 7480, 7, 2, 0, 0, 7480, 7481, + 7, 14, 0, 0, 7481, 7482, 7, 15, 0, 0, 7482, 7483, 7, 3, 0, 0, 7483, 7484, + 7, 6, 0, 0, 7484, 7485, 7, 5, 0, 0, 7485, 7486, 7, 5, 0, 0, 7486, 7487, + 7, 10, 0, 0, 7487, 7488, 7, 2, 0, 0, 7488, 7489, 7, 7, 0, 0, 7489, 518, + 1, 0, 0, 0, 7490, 7491, 7, 8, 0, 0, 7491, 7492, 7, 2, 0, 0, 7492, 7493, + 7, 14, 0, 0, 7493, 7494, 7, 15, 0, 0, 7494, 7495, 7, 12, 0, 0, 7495, 7496, + 7, 4, 0, 0, 7496, 7497, 7, 6, 0, 0, 7497, 520, 1, 0, 0, 0, 7498, 7499, + 7, 8, 0, 0, 7499, 7500, 7, 2, 0, 0, 7500, 7501, 7, 14, 0, 0, 7501, 7502, + 7, 15, 0, 0, 7502, 7503, 7, 12, 0, 0, 7503, 7504, 7, 4, 0, 0, 7504, 7505, + 7, 0, 0, 0, 7505, 7506, 7, 4, 0, 0, 7506, 7507, 7, 10, 0, 0, 7507, 7508, + 7, 2, 0, 0, 7508, 7509, 7, 7, 0, 0, 7509, 522, 1, 0, 0, 0, 7510, 7511, + 7, 8, 0, 0, 7511, 7512, 7, 2, 0, 0, 7512, 7513, 7, 7, 0, 0, 7513, 7514, + 7, 8, 0, 0, 7514, 7515, 7, 0, 0, 0, 7515, 7516, 7, 4, 0, 0, 7516, 524, + 1, 0, 0, 0, 7517, 7518, 7, 8, 0, 0, 7518, 7519, 7, 2, 0, 0, 7519, 7520, + 7, 7, 0, 0, 7520, 7521, 7, 8, 0, 0, 7521, 7522, 7, 12, 0, 0, 7522, 7523, + 7, 3, 0, 0, 7523, 7524, 7, 3, 0, 0, 7524, 7525, 7, 6, 0, 0, 7525, 7526, + 7, 7, 0, 0, 7526, 7527, 7, 4, 0, 0, 7527, 526, 1, 0, 0, 0, 7528, 7529, + 7, 8, 0, 0, 7529, 7530, 7, 2, 0, 0, 7530, 7531, 7, 7, 0, 0, 7531, 7532, + 5, 95, 0, 0, 7532, 7533, 7, 9, 0, 0, 7533, 7534, 7, 1, 0, 0, 7534, 7535, + 7, 10, 0, 0, 7535, 7536, 7, 9, 0, 0, 7536, 7537, 5, 95, 0, 0, 7537, 7538, + 7, 4, 0, 0, 7538, 7539, 7, 2, 0, 0, 7539, 7540, 5, 95, 0, 0, 7540, 7541, + 7, 10, 0, 0, 7541, 7542, 7, 9, 0, 0, 7542, 528, 1, 0, 0, 0, 7543, 7544, + 7, 8, 0, 0, 7544, 7545, 7, 2, 0, 0, 7545, 7546, 7, 7, 0, 0, 7546, 7547, + 7, 9, 0, 0, 7547, 7548, 7, 10, 0, 0, 7548, 7549, 7, 4, 0, 0, 7549, 7550, + 7, 10, 0, 0, 7550, 7551, 7, 2, 0, 0, 7551, 7552, 7, 7, 0, 0, 7552, 7553, + 7, 0, 0, 0, 7553, 7554, 7, 11, 0, 0, 7554, 530, 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, 9, 0, 0, 7559, 7560, 7, 10, 0, 0, 7560, 7561, 7, 4, 0, 0, 7561, 7562, + 7, 10, 0, 0, 7562, 7563, 7, 2, 0, 0, 7563, 7564, 7, 7, 0, 0, 7564, 532, + 1, 0, 0, 0, 7565, 7566, 7, 8, 0, 0, 7566, 7567, 7, 2, 0, 0, 7567, 7568, + 7, 7, 0, 0, 7568, 7569, 7, 16, 0, 0, 7569, 7570, 7, 10, 0, 0, 7570, 7571, + 7, 3, 0, 0, 7571, 7572, 7, 14, 0, 0, 7572, 534, 1, 0, 0, 0, 7573, 7574, + 7, 8, 0, 0, 7574, 7575, 7, 2, 0, 0, 7575, 7576, 7, 7, 0, 0, 7576, 7577, + 7, 16, 0, 0, 7577, 7578, 7, 2, 0, 0, 7578, 7579, 7, 3, 0, 0, 7579, 7580, + 7, 14, 0, 0, 7580, 7581, 7, 10, 0, 0, 7581, 7582, 7, 7, 0, 0, 7582, 7583, + 7, 17, 0, 0, 7583, 536, 1, 0, 0, 0, 7584, 7585, 7, 8, 0, 0, 7585, 7586, + 7, 2, 0, 0, 7586, 7587, 7, 7, 0, 0, 7587, 7588, 5, 95, 0, 0, 7588, 7589, + 7, 17, 0, 0, 7589, 7590, 7, 12, 0, 0, 7590, 7591, 7, 10, 0, 0, 7591, 7592, + 7, 9, 0, 0, 7592, 7593, 5, 95, 0, 0, 7593, 7594, 7, 4, 0, 0, 7594, 7595, + 7, 2, 0, 0, 7595, 7596, 5, 95, 0, 0, 7596, 7597, 7, 10, 0, 0, 7597, 7598, + 7, 9, 0, 0, 7598, 538, 1, 0, 0, 0, 7599, 7600, 7, 8, 0, 0, 7600, 7601, + 7, 2, 0, 0, 7601, 7602, 7, 7, 0, 0, 7602, 7603, 5, 95, 0, 0, 7603, 7604, + 7, 10, 0, 0, 7604, 7605, 7, 9, 0, 0, 7605, 540, 1, 0, 0, 0, 7606, 7607, + 7, 8, 0, 0, 7607, 7608, 7, 2, 0, 0, 7608, 7609, 7, 7, 0, 0, 7609, 7610, + 5, 95, 0, 0, 7610, 7611, 7, 7, 0, 0, 7611, 7612, 7, 0, 0, 0, 7612, 7613, + 7, 14, 0, 0, 7613, 7614, 7, 6, 0, 0, 7614, 7615, 5, 95, 0, 0, 7615, 7616, + 7, 4, 0, 0, 7616, 7617, 7, 2, 0, 0, 7617, 7618, 5, 95, 0, 0, 7618, 7619, + 7, 10, 0, 0, 7619, 7620, 7, 9, 0, 0, 7620, 542, 1, 0, 0, 0, 7621, 7622, + 7, 8, 0, 0, 7622, 7623, 7, 2, 0, 0, 7623, 7624, 7, 7, 0, 0, 7624, 7625, + 7, 7, 0, 0, 7625, 7626, 7, 6, 0, 0, 7626, 7627, 7, 8, 0, 0, 7627, 7628, + 7, 4, 0, 0, 7628, 7629, 5, 95, 0, 0, 7629, 7630, 7, 1, 0, 0, 7630, 7631, + 7, 18, 0, 0, 7631, 7632, 5, 95, 0, 0, 7632, 7633, 7, 8, 0, 0, 7633, 7634, + 7, 1, 0, 0, 7634, 7635, 5, 95, 0, 0, 7635, 7636, 7, 22, 0, 0, 7636, 7637, + 7, 19, 0, 0, 7637, 7638, 7, 3, 0, 0, 7638, 7639, 5, 95, 0, 0, 7639, 7640, + 7, 2, 0, 0, 7640, 7641, 7, 7, 0, 0, 7641, 7642, 7, 11, 0, 0, 7642, 7643, + 7, 18, 0, 0, 7643, 544, 1, 0, 0, 0, 7644, 7645, 7, 8, 0, 0, 7645, 7646, + 7, 2, 0, 0, 7646, 7647, 7, 7, 0, 0, 7647, 7648, 7, 7, 0, 0, 7648, 7649, + 7, 6, 0, 0, 7649, 7650, 7, 8, 0, 0, 7650, 7651, 7, 4, 0, 0, 7651, 7652, + 5, 95, 0, 0, 7652, 7653, 7, 1, 0, 0, 7653, 7654, 7, 18, 0, 0, 7654, 7655, + 5, 95, 0, 0, 7655, 7656, 7, 8, 0, 0, 7656, 7657, 7, 2, 0, 0, 7657, 7658, + 7, 14, 0, 0, 7658, 7659, 7, 1, 0, 0, 7659, 7660, 7, 10, 0, 0, 7660, 7661, + 7, 7, 0, 0, 7661, 7662, 7, 6, 0, 0, 7662, 7663, 5, 95, 0, 0, 7663, 7664, + 7, 5, 0, 0, 7664, 7665, 7, 22, 0, 0, 7665, 546, 1, 0, 0, 0, 7666, 7667, + 7, 8, 0, 0, 7667, 7668, 7, 2, 0, 0, 7668, 7669, 7, 7, 0, 0, 7669, 7670, + 7, 7, 0, 0, 7670, 7671, 7, 6, 0, 0, 7671, 7672, 7, 8, 0, 0, 7672, 7673, + 7, 4, 0, 0, 7673, 7674, 5, 95, 0, 0, 7674, 7675, 7, 1, 0, 0, 7675, 7676, + 7, 18, 0, 0, 7676, 7677, 5, 95, 0, 0, 7677, 7678, 7, 8, 0, 0, 7678, 7679, + 7, 2, 0, 0, 7679, 7680, 7, 5, 0, 0, 7680, 7681, 7, 4, 0, 0, 7681, 7682, + 5, 95, 0, 0, 7682, 7683, 7, 1, 0, 0, 7683, 7684, 7, 0, 0, 0, 7684, 7685, + 7, 5, 0, 0, 7685, 7686, 7, 6, 0, 0, 7686, 7687, 7, 9, 0, 0, 7687, 548, + 1, 0, 0, 0, 7688, 7689, 7, 8, 0, 0, 7689, 7690, 7, 2, 0, 0, 7690, 7691, + 7, 7, 0, 0, 7691, 7692, 7, 7, 0, 0, 7692, 7693, 7, 6, 0, 0, 7693, 7694, + 7, 8, 0, 0, 7694, 7695, 7, 4, 0, 0, 7695, 7696, 5, 95, 0, 0, 7696, 7697, + 7, 1, 0, 0, 7697, 7698, 7, 18, 0, 0, 7698, 7699, 5, 95, 0, 0, 7699, 7700, + 7, 6, 0, 0, 7700, 7701, 7, 11, 0, 0, 7701, 7702, 7, 10, 0, 0, 7702, 7703, + 7, 14, 0, 0, 7703, 7704, 5, 95, 0, 0, 7704, 7705, 7, 9, 0, 0, 7705, 7706, + 7, 12, 0, 0, 7706, 7707, 7, 15, 0, 0, 7707, 7708, 7, 5, 0, 0, 7708, 550, + 1, 0, 0, 0, 7709, 7710, 7, 8, 0, 0, 7710, 7711, 7, 2, 0, 0, 7711, 7712, + 7, 7, 0, 0, 7712, 7713, 7, 7, 0, 0, 7713, 7714, 7, 6, 0, 0, 7714, 7715, + 7, 8, 0, 0, 7715, 7716, 7, 4, 0, 0, 7716, 7717, 5, 95, 0, 0, 7717, 7718, + 7, 1, 0, 0, 7718, 7719, 7, 18, 0, 0, 7719, 7720, 5, 95, 0, 0, 7720, 7721, + 7, 16, 0, 0, 7721, 7722, 7, 10, 0, 0, 7722, 7723, 7, 11, 0, 0, 7723, 7724, + 7, 4, 0, 0, 7724, 7725, 7, 6, 0, 0, 7725, 7726, 7, 3, 0, 0, 7726, 7727, + 7, 10, 0, 0, 7727, 7728, 7, 7, 0, 0, 7728, 7729, 7, 17, 0, 0, 7729, 552, + 1, 0, 0, 0, 7730, 7731, 7, 8, 0, 0, 7731, 7732, 7, 2, 0, 0, 7732, 7733, + 7, 7, 0, 0, 7733, 7734, 7, 7, 0, 0, 7734, 7735, 7, 6, 0, 0, 7735, 7736, + 7, 8, 0, 0, 7736, 7737, 7, 4, 0, 0, 7737, 7738, 5, 95, 0, 0, 7738, 7739, + 7, 1, 0, 0, 7739, 7740, 7, 18, 0, 0, 7740, 7741, 5, 95, 0, 0, 7741, 7742, + 7, 10, 0, 0, 7742, 7743, 7, 5, 0, 0, 7743, 7744, 7, 8, 0, 0, 7744, 7745, + 7, 18, 0, 0, 7745, 7746, 7, 8, 0, 0, 7746, 7747, 7, 11, 0, 0, 7747, 7748, + 7, 6, 0, 0, 7748, 554, 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, 10, 0, 0, 7761, 7762, 7, 5, 0, 0, 7762, 7763, + 7, 11, 0, 0, 7763, 7764, 7, 6, 0, 0, 7764, 7765, 7, 0, 0, 0, 7765, 7766, + 7, 16, 0, 0, 7766, 556, 1, 0, 0, 0, 7767, 7768, 7, 8, 0, 0, 7768, 7769, + 7, 2, 0, 0, 7769, 7770, 7, 7, 0, 0, 7770, 7771, 7, 7, 0, 0, 7771, 7772, + 7, 6, 0, 0, 7772, 7773, 7, 8, 0, 0, 7773, 7774, 7, 4, 0, 0, 7774, 7775, + 5, 95, 0, 0, 7775, 7776, 7, 1, 0, 0, 7776, 7777, 7, 18, 0, 0, 7777, 7778, + 5, 95, 0, 0, 7778, 7779, 7, 3, 0, 0, 7779, 7780, 7, 2, 0, 0, 7780, 7781, + 7, 2, 0, 0, 7781, 7782, 7, 4, 0, 0, 7782, 558, 1, 0, 0, 0, 7783, 7784, + 7, 8, 0, 0, 7784, 7785, 7, 2, 0, 0, 7785, 7786, 7, 7, 0, 0, 7786, 7787, + 7, 7, 0, 0, 7787, 7788, 7, 6, 0, 0, 7788, 7789, 7, 8, 0, 0, 7789, 7790, + 7, 4, 0, 0, 7790, 560, 1, 0, 0, 0, 7791, 7792, 7, 8, 0, 0, 7792, 7793, + 7, 2, 0, 0, 7793, 7794, 7, 7, 0, 0, 7794, 7795, 7, 7, 0, 0, 7795, 7796, + 7, 6, 0, 0, 7796, 7797, 7, 8, 0, 0, 7797, 7798, 7, 4, 0, 0, 7798, 7799, + 5, 95, 0, 0, 7799, 7800, 7, 4, 0, 0, 7800, 7801, 7, 10, 0, 0, 7801, 7802, + 7, 14, 0, 0, 7802, 7803, 7, 6, 0, 0, 7803, 562, 1, 0, 0, 0, 7804, 7805, + 7, 8, 0, 0, 7805, 7806, 7, 2, 0, 0, 7806, 7807, 7, 7, 0, 0, 7807, 7808, + 7, 5, 0, 0, 7808, 7809, 7, 10, 0, 0, 7809, 7810, 7, 9, 0, 0, 7810, 7811, + 7, 6, 0, 0, 7811, 7812, 7, 3, 0, 0, 7812, 564, 1, 0, 0, 0, 7813, 7814, + 7, 8, 0, 0, 7814, 7815, 7, 2, 0, 0, 7815, 7816, 7, 7, 0, 0, 7816, 7817, + 7, 5, 0, 0, 7817, 7818, 7, 10, 0, 0, 7818, 7819, 7, 5, 0, 0, 7819, 7820, + 7, 4, 0, 0, 7820, 7821, 7, 6, 0, 0, 7821, 7822, 7, 7, 0, 0, 7822, 7823, + 7, 4, 0, 0, 7823, 566, 1, 0, 0, 0, 7824, 7825, 7, 8, 0, 0, 7825, 7826, + 7, 2, 0, 0, 7826, 7827, 7, 7, 0, 0, 7827, 7828, 7, 5, 0, 0, 7828, 7829, + 7, 4, 0, 0, 7829, 7830, 7, 0, 0, 0, 7830, 7831, 7, 7, 0, 0, 7831, 7832, + 7, 4, 0, 0, 7832, 568, 1, 0, 0, 0, 7833, 7834, 7, 8, 0, 0, 7834, 7835, + 7, 2, 0, 0, 7835, 7836, 7, 7, 0, 0, 7836, 7837, 7, 5, 0, 0, 7837, 7838, + 7, 4, 0, 0, 7838, 570, 1, 0, 0, 0, 7839, 7840, 7, 8, 0, 0, 7840, 7841, + 7, 2, 0, 0, 7841, 7842, 7, 7, 0, 0, 7842, 7843, 7, 5, 0, 0, 7843, 7844, + 7, 4, 0, 0, 7844, 7845, 7, 3, 0, 0, 7845, 7846, 7, 0, 0, 0, 7846, 7847, + 7, 10, 0, 0, 7847, 7848, 7, 7, 0, 0, 7848, 7849, 7, 4, 0, 0, 7849, 572, + 1, 0, 0, 0, 7850, 7851, 7, 8, 0, 0, 7851, 7852, 7, 2, 0, 0, 7852, 7853, + 7, 7, 0, 0, 7853, 7854, 7, 5, 0, 0, 7854, 7855, 7, 4, 0, 0, 7855, 7856, + 7, 3, 0, 0, 7856, 7857, 7, 0, 0, 0, 7857, 7858, 7, 10, 0, 0, 7858, 7859, + 7, 7, 0, 0, 7859, 7860, 7, 4, 0, 0, 7860, 7861, 7, 5, 0, 0, 7861, 574, + 1, 0, 0, 0, 7862, 7863, 7, 8, 0, 0, 7863, 7864, 7, 2, 0, 0, 7864, 7865, + 7, 7, 0, 0, 7865, 7866, 7, 5, 0, 0, 7866, 7867, 7, 4, 0, 0, 7867, 7868, + 7, 3, 0, 0, 7868, 7869, 7, 12, 0, 0, 7869, 7870, 7, 8, 0, 0, 7870, 7871, + 7, 4, 0, 0, 7871, 7872, 7, 2, 0, 0, 7872, 7873, 7, 3, 0, 0, 7873, 576, + 1, 0, 0, 0, 7874, 7875, 7, 8, 0, 0, 7875, 7876, 7, 2, 0, 0, 7876, 7877, + 7, 7, 0, 0, 7877, 7878, 7, 4, 0, 0, 7878, 7879, 7, 0, 0, 0, 7879, 7880, + 7, 10, 0, 0, 7880, 7881, 7, 7, 0, 0, 7881, 7882, 7, 6, 0, 0, 7882, 7883, + 7, 3, 0, 0, 7883, 578, 1, 0, 0, 0, 7884, 7885, 7, 8, 0, 0, 7885, 7886, + 7, 2, 0, 0, 7886, 7887, 7, 7, 0, 0, 7887, 7888, 7, 4, 0, 0, 7888, 7889, + 7, 0, 0, 0, 7889, 7890, 7, 10, 0, 0, 7890, 7891, 7, 7, 0, 0, 7891, 7892, + 7, 6, 0, 0, 7892, 7893, 7, 3, 0, 0, 7893, 7894, 7, 5, 0, 0, 7894, 580, + 1, 0, 0, 0, 7895, 7896, 7, 8, 0, 0, 7896, 7897, 7, 2, 0, 0, 7897, 7898, + 7, 7, 0, 0, 7898, 7899, 7, 4, 0, 0, 7899, 7900, 7, 0, 0, 0, 7900, 7901, + 7, 10, 0, 0, 7901, 7902, 7, 7, 0, 0, 7902, 7903, 7, 6, 0, 0, 7903, 7904, + 7, 3, 0, 0, 7904, 7905, 7, 5, 0, 0, 7905, 7906, 5, 95, 0, 0, 7906, 7907, + 7, 9, 0, 0, 7907, 7908, 7, 6, 0, 0, 7908, 7909, 7, 16, 0, 0, 7909, 7910, + 7, 0, 0, 0, 7910, 7911, 7, 12, 0, 0, 7911, 7912, 7, 11, 0, 0, 7912, 7913, + 7, 4, 0, 0, 7913, 582, 1, 0, 0, 0, 7914, 7915, 7, 8, 0, 0, 7915, 7916, + 7, 2, 0, 0, 7916, 7917, 7, 7, 0, 0, 7917, 7918, 7, 4, 0, 0, 7918, 7919, + 7, 0, 0, 0, 7919, 7920, 7, 10, 0, 0, 7920, 7921, 7, 7, 0, 0, 7921, 7922, + 7, 6, 0, 0, 7922, 7923, 7, 3, 0, 0, 7923, 7924, 5, 95, 0, 0, 7924, 7925, + 7, 9, 0, 0, 7925, 7926, 7, 0, 0, 0, 7926, 7927, 7, 4, 0, 0, 7927, 7928, + 7, 0, 0, 0, 7928, 584, 1, 0, 0, 0, 7929, 7930, 7, 8, 0, 0, 7930, 7931, + 7, 2, 0, 0, 7931, 7932, 7, 7, 0, 0, 7932, 7933, 7, 4, 0, 0, 7933, 7934, + 7, 0, 0, 0, 7934, 7935, 7, 10, 0, 0, 7935, 7936, 7, 7, 0, 0, 7936, 7937, + 7, 6, 0, 0, 7937, 7938, 7, 3, 0, 0, 7938, 7939, 5, 95, 0, 0, 7939, 7940, + 7, 14, 0, 0, 7940, 7941, 7, 0, 0, 0, 7941, 7942, 7, 15, 0, 0, 7942, 586, + 1, 0, 0, 0, 7943, 7944, 7, 8, 0, 0, 7944, 7945, 7, 2, 0, 0, 7945, 7946, + 7, 7, 0, 0, 7946, 7947, 7, 4, 0, 0, 7947, 7948, 7, 6, 0, 0, 7948, 7949, + 7, 7, 0, 0, 7949, 7950, 7, 4, 0, 0, 7950, 588, 1, 0, 0, 0, 7951, 7952, + 7, 8, 0, 0, 7952, 7953, 7, 2, 0, 0, 7953, 7954, 7, 7, 0, 0, 7954, 7955, + 7, 4, 0, 0, 7955, 7956, 7, 6, 0, 0, 7956, 7957, 7, 7, 0, 0, 7957, 7958, + 7, 4, 0, 0, 7958, 7959, 7, 5, 0, 0, 7959, 590, 1, 0, 0, 0, 7960, 7961, + 7, 8, 0, 0, 7961, 7962, 7, 2, 0, 0, 7962, 7963, 7, 7, 0, 0, 7963, 7964, + 7, 4, 0, 0, 7964, 7965, 7, 6, 0, 0, 7965, 7966, 7, 25, 0, 0, 7966, 7967, + 7, 4, 0, 0, 7967, 592, 1, 0, 0, 0, 7968, 7969, 7, 8, 0, 0, 7969, 7970, + 7, 2, 0, 0, 7970, 7971, 7, 7, 0, 0, 7971, 7972, 7, 4, 0, 0, 7972, 7973, + 7, 10, 0, 0, 7973, 7974, 7, 7, 0, 0, 7974, 7975, 7, 12, 0, 0, 7975, 7976, + 7, 6, 0, 0, 7976, 594, 1, 0, 0, 0, 7977, 7978, 7, 8, 0, 0, 7978, 7979, + 7, 2, 0, 0, 7979, 7980, 7, 7, 0, 0, 7980, 7981, 7, 4, 0, 0, 7981, 7982, + 7, 3, 0, 0, 7982, 7983, 7, 2, 0, 0, 7983, 7984, 7, 11, 0, 0, 7984, 7985, + 7, 16, 0, 0, 7985, 7986, 7, 10, 0, 0, 7986, 7987, 7, 11, 0, 0, 7987, 7988, + 7, 6, 0, 0, 7988, 596, 1, 0, 0, 0, 7989, 7990, 7, 8, 0, 0, 7990, 7991, + 7, 2, 0, 0, 7991, 7992, 7, 7, 0, 0, 7992, 7993, 5, 95, 0, 0, 7993, 7994, + 7, 12, 0, 0, 7994, 7995, 7, 10, 0, 0, 7995, 7996, 7, 9, 0, 0, 7996, 7997, + 5, 95, 0, 0, 7997, 7998, 7, 4, 0, 0, 7998, 7999, 7, 2, 0, 0, 7999, 8000, + 5, 95, 0, 0, 8000, 8001, 7, 10, 0, 0, 8001, 8002, 7, 9, 0, 0, 8002, 598, + 1, 0, 0, 0, 8003, 8004, 7, 8, 0, 0, 8004, 8005, 7, 2, 0, 0, 8005, 8006, + 7, 7, 0, 0, 8006, 8007, 7, 13, 0, 0, 8007, 8008, 7, 6, 0, 0, 8008, 8009, + 7, 3, 0, 0, 8009, 8010, 7, 4, 0, 0, 8010, 600, 1, 0, 0, 0, 8011, 8012, + 7, 8, 0, 0, 8012, 8013, 7, 2, 0, 0, 8013, 8014, 7, 7, 0, 0, 8014, 8015, + 7, 13, 0, 0, 8015, 8016, 7, 6, 0, 0, 8016, 8017, 7, 3, 0, 0, 8017, 8018, + 7, 5, 0, 0, 8018, 8019, 7, 10, 0, 0, 8019, 8020, 7, 2, 0, 0, 8020, 8021, + 7, 7, 0, 0, 8021, 602, 1, 0, 0, 0, 8022, 8023, 7, 8, 0, 0, 8023, 8024, + 7, 2, 0, 0, 8024, 8025, 7, 2, 0, 0, 8025, 8026, 7, 21, 0, 0, 8026, 8027, + 7, 10, 0, 0, 8027, 8028, 7, 6, 0, 0, 8028, 604, 1, 0, 0, 0, 8029, 8030, + 7, 8, 0, 0, 8030, 8031, 7, 2, 0, 0, 8031, 8032, 7, 15, 0, 0, 8032, 8033, + 7, 18, 0, 0, 8033, 606, 1, 0, 0, 0, 8034, 8035, 7, 8, 0, 0, 8035, 8036, + 7, 2, 0, 0, 8036, 8037, 7, 3, 0, 0, 8037, 8038, 7, 3, 0, 0, 8038, 8039, + 5, 95, 0, 0, 8039, 8040, 7, 21, 0, 0, 8040, 608, 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, 5, 95, 0, 0, 8046, 8047, 7, 5, 0, 0, 8047, 610, + 1, 0, 0, 0, 8048, 8049, 7, 8, 0, 0, 8049, 8050, 7, 2, 0, 0, 8050, 8051, + 7, 3, 0, 0, 8051, 8052, 7, 3, 0, 0, 8052, 8053, 7, 12, 0, 0, 8053, 8054, + 7, 15, 0, 0, 8054, 8055, 7, 4, 0, 0, 8055, 8056, 7, 10, 0, 0, 8056, 8057, + 7, 2, 0, 0, 8057, 8058, 7, 7, 0, 0, 8058, 612, 1, 0, 0, 0, 8059, 8060, + 7, 8, 0, 0, 8060, 8061, 7, 2, 0, 0, 8061, 8062, 7, 3, 0, 0, 8062, 8063, + 7, 3, 0, 0, 8063, 8064, 7, 12, 0, 0, 8064, 8065, 7, 15, 0, 0, 8065, 8066, + 7, 4, 0, 0, 8066, 8067, 5, 95, 0, 0, 8067, 8068, 7, 25, 0, 0, 8068, 8069, + 7, 10, 0, 0, 8069, 8070, 7, 9, 0, 0, 8070, 8071, 5, 95, 0, 0, 8071, 8072, + 7, 0, 0, 0, 8072, 8073, 7, 11, 0, 0, 8073, 8074, 7, 11, 0, 0, 8074, 614, + 1, 0, 0, 0, 8075, 8076, 7, 8, 0, 0, 8076, 8077, 7, 2, 0, 0, 8077, 8078, + 7, 3, 0, 0, 8078, 8079, 7, 3, 0, 0, 8079, 8080, 7, 12, 0, 0, 8080, 8081, + 7, 15, 0, 0, 8081, 8082, 7, 4, 0, 0, 8082, 8083, 5, 95, 0, 0, 8083, 8084, + 7, 25, 0, 0, 8084, 8085, 7, 10, 0, 0, 8085, 8086, 7, 9, 0, 0, 8086, 616, + 1, 0, 0, 0, 8087, 8088, 7, 8, 0, 0, 8088, 8089, 7, 2, 0, 0, 8089, 8090, + 7, 5, 0, 0, 8090, 618, 1, 0, 0, 0, 8091, 8092, 7, 8, 0, 0, 8092, 8093, + 7, 2, 0, 0, 8093, 8094, 7, 5, 0, 0, 8094, 8095, 7, 19, 0, 0, 8095, 620, + 1, 0, 0, 0, 8096, 8097, 7, 8, 0, 0, 8097, 8098, 7, 2, 0, 0, 8098, 8099, + 7, 5, 0, 0, 8099, 8100, 7, 4, 0, 0, 8100, 622, 1, 0, 0, 0, 8101, 8102, + 7, 8, 0, 0, 8102, 8103, 7, 2, 0, 0, 8103, 8104, 7, 5, 0, 0, 8104, 8105, + 7, 4, 0, 0, 8105, 8106, 5, 95, 0, 0, 8106, 8107, 7, 25, 0, 0, 8107, 8108, + 7, 14, 0, 0, 8108, 8109, 7, 11, 0, 0, 8109, 8110, 5, 95, 0, 0, 8110, 8111, + 7, 24, 0, 0, 8111, 8112, 7, 12, 0, 0, 8112, 8113, 7, 6, 0, 0, 8113, 8114, + 7, 3, 0, 0, 8114, 8115, 7, 18, 0, 0, 8115, 8116, 5, 95, 0, 0, 8116, 8117, + 7, 3, 0, 0, 8117, 8118, 7, 6, 0, 0, 8118, 8119, 7, 22, 0, 0, 8119, 8120, + 7, 3, 0, 0, 8120, 8121, 7, 10, 0, 0, 8121, 8122, 7, 4, 0, 0, 8122, 8123, + 7, 6, 0, 0, 8123, 624, 1, 0, 0, 0, 8124, 8125, 7, 8, 0, 0, 8125, 8126, + 7, 2, 0, 0, 8126, 8127, 7, 12, 0, 0, 8127, 8128, 7, 7, 0, 0, 8128, 8129, + 7, 4, 0, 0, 8129, 626, 1, 0, 0, 0, 8130, 8131, 7, 8, 0, 0, 8131, 8132, + 7, 2, 0, 0, 8132, 8133, 7, 12, 0, 0, 8133, 8134, 7, 7, 0, 0, 8134, 8135, + 7, 4, 0, 0, 8135, 8136, 7, 6, 0, 0, 8136, 8137, 7, 9, 0, 0, 8137, 628, + 1, 0, 0, 0, 8138, 8139, 7, 8, 0, 0, 8139, 8140, 7, 2, 0, 0, 8140, 8141, + 7, 13, 0, 0, 8141, 8142, 7, 0, 0, 0, 8142, 8143, 7, 3, 0, 0, 8143, 8144, + 5, 95, 0, 0, 8144, 8145, 7, 15, 0, 0, 8145, 8146, 7, 2, 0, 0, 8146, 8147, + 7, 15, 0, 0, 8147, 630, 1, 0, 0, 0, 8148, 8149, 7, 8, 0, 0, 8149, 8150, + 7, 2, 0, 0, 8150, 8151, 7, 13, 0, 0, 8151, 8152, 7, 0, 0, 0, 8152, 8153, + 7, 3, 0, 0, 8153, 8154, 5, 95, 0, 0, 8154, 8155, 7, 5, 0, 0, 8155, 8156, + 7, 0, 0, 0, 8156, 8157, 7, 14, 0, 0, 8157, 8158, 7, 15, 0, 0, 8158, 632, + 1, 0, 0, 0, 8159, 8160, 7, 8, 0, 0, 8160, 8161, 7, 15, 0, 0, 8161, 8162, + 7, 12, 0, 0, 8162, 8163, 5, 95, 0, 0, 8163, 8164, 7, 8, 0, 0, 8164, 8165, + 7, 2, 0, 0, 8165, 8166, 7, 5, 0, 0, 8166, 8167, 7, 4, 0, 0, 8167, 8168, + 7, 10, 0, 0, 8168, 8169, 7, 7, 0, 0, 8169, 8170, 7, 17, 0, 0, 8170, 634, + 1, 0, 0, 0, 8171, 8172, 7, 8, 0, 0, 8172, 8173, 7, 15, 0, 0, 8173, 8174, + 7, 12, 0, 0, 8174, 8175, 5, 95, 0, 0, 8175, 8176, 7, 15, 0, 0, 8176, 8177, + 7, 6, 0, 0, 8177, 8178, 7, 3, 0, 0, 8178, 8179, 5, 95, 0, 0, 8179, 8180, + 7, 8, 0, 0, 8180, 8181, 7, 0, 0, 0, 8181, 8182, 7, 11, 0, 0, 8182, 8183, + 7, 11, 0, 0, 8183, 636, 1, 0, 0, 0, 8184, 8185, 7, 8, 0, 0, 8185, 8186, + 7, 15, 0, 0, 8186, 8187, 7, 12, 0, 0, 8187, 8188, 5, 95, 0, 0, 8188, 8189, + 7, 15, 0, 0, 8189, 8190, 7, 6, 0, 0, 8190, 8191, 7, 3, 0, 0, 8191, 8192, + 5, 95, 0, 0, 8192, 8193, 7, 5, 0, 0, 8193, 8194, 7, 6, 0, 0, 8194, 8195, + 7, 5, 0, 0, 8195, 8196, 7, 5, 0, 0, 8196, 8197, 7, 10, 0, 0, 8197, 8198, + 7, 2, 0, 0, 8198, 8199, 7, 7, 0, 0, 8199, 638, 1, 0, 0, 0, 8200, 8201, + 7, 8, 0, 0, 8201, 8202, 7, 3, 0, 0, 8202, 8203, 7, 0, 0, 0, 8203, 8204, + 7, 5, 0, 0, 8204, 8205, 7, 19, 0, 0, 8205, 640, 1, 0, 0, 0, 8206, 8207, + 7, 8, 0, 0, 8207, 8208, 7, 3, 0, 0, 8208, 8209, 7, 6, 0, 0, 8209, 8210, + 7, 0, 0, 0, 8210, 8211, 7, 4, 0, 0, 8211, 8212, 7, 6, 0, 0, 8212, 642, + 1, 0, 0, 0, 8213, 8214, 7, 8, 0, 0, 8214, 8215, 7, 3, 0, 0, 8215, 8216, + 7, 6, 0, 0, 8216, 8217, 7, 0, 0, 0, 8217, 8218, 7, 4, 0, 0, 8218, 8219, + 7, 6, 0, 0, 8219, 8220, 5, 95, 0, 0, 8220, 8221, 7, 16, 0, 0, 8221, 8222, + 7, 10, 0, 0, 8222, 8223, 7, 11, 0, 0, 8223, 8224, 7, 6, 0, 0, 8224, 8225, + 5, 95, 0, 0, 8225, 8226, 7, 9, 0, 0, 8226, 8227, 7, 6, 0, 0, 8227, 8228, + 7, 5, 0, 0, 8228, 8229, 7, 4, 0, 0, 8229, 644, 1, 0, 0, 0, 8230, 8231, + 7, 8, 0, 0, 8231, 8232, 7, 3, 0, 0, 8232, 8233, 7, 6, 0, 0, 8233, 8234, + 7, 0, 0, 0, 8234, 8235, 7, 4, 0, 0, 8235, 8236, 7, 6, 0, 0, 8236, 8237, + 5, 95, 0, 0, 8237, 8238, 7, 5, 0, 0, 8238, 8239, 7, 4, 0, 0, 8239, 8240, + 7, 2, 0, 0, 8240, 8241, 7, 3, 0, 0, 8241, 8242, 7, 6, 0, 0, 8242, 8243, + 7, 9, 0, 0, 8243, 8244, 5, 95, 0, 0, 8244, 8245, 7, 2, 0, 0, 8245, 8246, + 7, 12, 0, 0, 8246, 8247, 7, 4, 0, 0, 8247, 8248, 7, 11, 0, 0, 8248, 8249, + 7, 10, 0, 0, 8249, 8250, 7, 7, 0, 0, 8250, 8251, 7, 6, 0, 0, 8251, 8252, + 7, 5, 0, 0, 8252, 646, 1, 0, 0, 0, 8253, 8254, 7, 8, 0, 0, 8254, 8255, + 7, 3, 0, 0, 8255, 8256, 7, 6, 0, 0, 8256, 8257, 7, 0, 0, 0, 8257, 8258, + 7, 4, 0, 0, 8258, 8259, 7, 10, 0, 0, 8259, 8260, 7, 2, 0, 0, 8260, 8261, + 7, 7, 0, 0, 8261, 648, 1, 0, 0, 0, 8262, 8263, 7, 8, 0, 0, 8263, 8264, + 7, 3, 0, 0, 8264, 8265, 7, 6, 0, 0, 8265, 8266, 7, 9, 0, 0, 8266, 8267, + 7, 6, 0, 0, 8267, 8268, 7, 7, 0, 0, 8268, 8269, 7, 4, 0, 0, 8269, 8270, + 7, 10, 0, 0, 8270, 8271, 7, 0, 0, 0, 8271, 8272, 7, 11, 0, 0, 8272, 650, + 1, 0, 0, 0, 8273, 8274, 7, 8, 0, 0, 8274, 8275, 7, 3, 0, 0, 8275, 8276, + 7, 10, 0, 0, 8276, 8277, 7, 4, 0, 0, 8277, 8278, 7, 10, 0, 0, 8278, 8279, + 7, 8, 0, 0, 8279, 8280, 7, 0, 0, 0, 8280, 8281, 7, 11, 0, 0, 8281, 652, + 1, 0, 0, 0, 8282, 8283, 7, 8, 0, 0, 8283, 8284, 7, 3, 0, 0, 8284, 8285, + 7, 2, 0, 0, 8285, 8286, 7, 5, 0, 0, 8286, 8287, 7, 5, 0, 0, 8287, 654, + 1, 0, 0, 0, 8288, 8289, 7, 8, 0, 0, 8289, 8290, 7, 3, 0, 0, 8290, 8291, + 7, 2, 0, 0, 8291, 8292, 7, 5, 0, 0, 8292, 8293, 7, 5, 0, 0, 8293, 8294, + 7, 6, 0, 0, 8294, 8295, 7, 9, 0, 0, 8295, 8296, 7, 10, 0, 0, 8296, 8297, + 7, 4, 0, 0, 8297, 8298, 7, 10, 0, 0, 8298, 8299, 7, 2, 0, 0, 8299, 8300, + 7, 7, 0, 0, 8300, 656, 1, 0, 0, 0, 8301, 8302, 7, 8, 0, 0, 8302, 8303, + 7, 5, 0, 0, 8303, 8304, 7, 8, 0, 0, 8304, 8305, 7, 2, 0, 0, 8305, 8306, + 7, 7, 0, 0, 8306, 8307, 7, 13, 0, 0, 8307, 8308, 7, 6, 0, 0, 8308, 8309, + 7, 3, 0, 0, 8309, 8310, 7, 4, 0, 0, 8310, 658, 1, 0, 0, 0, 8311, 8312, + 7, 8, 0, 0, 8312, 8313, 7, 5, 0, 0, 8313, 8314, 7, 13, 0, 0, 8314, 660, + 1, 0, 0, 0, 8315, 8316, 7, 8, 0, 0, 8316, 8317, 7, 12, 0, 0, 8317, 8318, + 7, 1, 0, 0, 8318, 8319, 7, 6, 0, 0, 8319, 8320, 5, 95, 0, 0, 8320, 8321, + 7, 0, 0, 0, 8321, 8322, 7, 20, 0, 0, 8322, 662, 1, 0, 0, 0, 8323, 8324, + 7, 8, 0, 0, 8324, 8325, 7, 12, 0, 0, 8325, 8326, 7, 1, 0, 0, 8326, 8327, + 7, 6, 0, 0, 8327, 664, 1, 0, 0, 0, 8328, 8329, 7, 8, 0, 0, 8329, 8330, + 7, 12, 0, 0, 8330, 8331, 7, 1, 0, 0, 8331, 8332, 7, 6, 0, 0, 8332, 8333, + 5, 95, 0, 0, 8333, 8334, 7, 17, 0, 0, 8334, 8335, 7, 1, 0, 0, 8335, 666, + 1, 0, 0, 0, 8336, 8337, 7, 8, 0, 0, 8337, 8338, 7, 12, 0, 0, 8338, 8339, + 7, 1, 0, 0, 8339, 8340, 7, 6, 0, 0, 8340, 8341, 5, 95, 0, 0, 8341, 8342, + 7, 5, 0, 0, 8342, 8343, 7, 20, 0, 0, 8343, 668, 1, 0, 0, 0, 8344, 8345, + 7, 8, 0, 0, 8345, 8346, 7, 12, 0, 0, 8346, 8347, 7, 14, 0, 0, 8347, 8348, + 7, 6, 0, 0, 8348, 8349, 5, 95, 0, 0, 8349, 8350, 7, 9, 0, 0, 8350, 8351, + 7, 10, 0, 0, 8351, 8352, 7, 5, 0, 0, 8352, 8353, 7, 4, 0, 0, 8353, 8354, + 7, 14, 0, 0, 8354, 670, 1, 0, 0, 0, 8355, 8356, 7, 8, 0, 0, 8356, 8357, + 7, 12, 0, 0, 8357, 8358, 7, 3, 0, 0, 8358, 8359, 7, 3, 0, 0, 8359, 8360, + 7, 6, 0, 0, 8360, 8361, 7, 7, 0, 0, 8361, 8362, 7, 4, 0, 0, 8362, 672, + 1, 0, 0, 0, 8363, 8364, 7, 8, 0, 0, 8364, 8365, 7, 12, 0, 0, 8365, 8366, + 7, 3, 0, 0, 8366, 8367, 7, 3, 0, 0, 8367, 8368, 7, 6, 0, 0, 8368, 8369, + 7, 7, 0, 0, 8369, 8370, 7, 4, 0, 0, 8370, 8371, 5, 95, 0, 0, 8371, 8372, + 7, 9, 0, 0, 8372, 8373, 7, 0, 0, 0, 8373, 8374, 7, 4, 0, 0, 8374, 8375, + 7, 6, 0, 0, 8375, 674, 1, 0, 0, 0, 8376, 8377, 7, 8, 0, 0, 8377, 8378, + 7, 12, 0, 0, 8378, 8379, 7, 3, 0, 0, 8379, 8380, 7, 3, 0, 0, 8380, 8381, + 7, 6, 0, 0, 8381, 8382, 7, 7, 0, 0, 8382, 8383, 7, 4, 0, 0, 8383, 8384, + 5, 95, 0, 0, 8384, 8385, 7, 5, 0, 0, 8385, 8386, 7, 8, 0, 0, 8386, 8387, + 7, 19, 0, 0, 8387, 8388, 7, 6, 0, 0, 8388, 8389, 7, 14, 0, 0, 8389, 8390, + 7, 0, 0, 0, 8390, 676, 1, 0, 0, 0, 8391, 8392, 7, 8, 0, 0, 8392, 8393, + 7, 12, 0, 0, 8393, 8394, 7, 3, 0, 0, 8394, 8395, 7, 3, 0, 0, 8395, 8396, + 7, 6, 0, 0, 8396, 8397, 7, 7, 0, 0, 8397, 8398, 7, 4, 0, 0, 8398, 8399, + 5, 95, 0, 0, 8399, 8400, 7, 4, 0, 0, 8400, 8401, 7, 10, 0, 0, 8401, 8402, + 7, 14, 0, 0, 8402, 8403, 7, 6, 0, 0, 8403, 678, 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, 4, 0, 0, 8413, 8414, + 7, 10, 0, 0, 8414, 8415, 7, 14, 0, 0, 8415, 8416, 7, 6, 0, 0, 8416, 8417, + 7, 5, 0, 0, 8417, 8418, 7, 4, 0, 0, 8418, 8419, 7, 0, 0, 0, 8419, 8420, + 7, 14, 0, 0, 8420, 8421, 7, 15, 0, 0, 8421, 680, 1, 0, 0, 0, 8422, 8423, + 7, 8, 0, 0, 8423, 8424, 7, 12, 0, 0, 8424, 8425, 7, 3, 0, 0, 8425, 8426, + 7, 3, 0, 0, 8426, 8427, 7, 6, 0, 0, 8427, 8428, 7, 7, 0, 0, 8428, 8429, + 7, 4, 0, 0, 8429, 8430, 5, 95, 0, 0, 8430, 8431, 7, 12, 0, 0, 8431, 8432, + 7, 5, 0, 0, 8432, 8433, 7, 6, 0, 0, 8433, 8434, 7, 3, 0, 0, 8434, 682, + 1, 0, 0, 0, 8435, 8436, 7, 8, 0, 0, 8436, 8437, 7, 12, 0, 0, 8437, 8438, + 7, 3, 0, 0, 8438, 8439, 7, 3, 0, 0, 8439, 8440, 7, 6, 0, 0, 8440, 8441, + 7, 7, 0, 0, 8441, 8442, 7, 4, 0, 0, 8442, 8443, 7, 13, 0, 0, 8443, 684, + 1, 0, 0, 0, 8444, 8445, 7, 8, 0, 0, 8445, 8446, 7, 12, 0, 0, 8446, 8447, + 7, 3, 0, 0, 8447, 8448, 7, 5, 0, 0, 8448, 8449, 7, 2, 0, 0, 8449, 8450, + 7, 3, 0, 0, 8450, 686, 1, 0, 0, 0, 8451, 8452, 7, 8, 0, 0, 8452, 8453, + 7, 12, 0, 0, 8453, 8454, 7, 3, 0, 0, 8454, 8455, 7, 5, 0, 0, 8455, 8456, + 7, 2, 0, 0, 8456, 8457, 7, 3, 0, 0, 8457, 8458, 5, 95, 0, 0, 8458, 8459, + 7, 5, 0, 0, 8459, 8460, 7, 19, 0, 0, 8460, 8461, 7, 0, 0, 0, 8461, 8462, + 7, 3, 0, 0, 8462, 8463, 7, 10, 0, 0, 8463, 8464, 7, 7, 0, 0, 8464, 8465, + 7, 17, 0, 0, 8465, 8466, 5, 95, 0, 0, 8466, 8467, 7, 6, 0, 0, 8467, 8468, + 7, 25, 0, 0, 8468, 8469, 7, 0, 0, 0, 8469, 8470, 7, 8, 0, 0, 8470, 8471, + 7, 4, 0, 0, 8471, 688, 1, 0, 0, 0, 8472, 8473, 7, 8, 0, 0, 8473, 8474, + 7, 12, 0, 0, 8474, 8475, 7, 3, 0, 0, 8475, 8476, 7, 5, 0, 0, 8476, 8477, + 7, 2, 0, 0, 8477, 8478, 7, 3, 0, 0, 8478, 8479, 5, 95, 0, 0, 8479, 8480, + 7, 5, 0, 0, 8480, 8481, 7, 15, 0, 0, 8481, 8482, 7, 6, 0, 0, 8482, 8483, + 7, 8, 0, 0, 8483, 8484, 7, 10, 0, 0, 8484, 8485, 7, 16, 0, 0, 8485, 8486, + 7, 10, 0, 0, 8486, 8487, 7, 8, 0, 0, 8487, 8488, 5, 95, 0, 0, 8488, 8489, + 7, 5, 0, 0, 8489, 8490, 7, 6, 0, 0, 8490, 8491, 7, 17, 0, 0, 8491, 8492, + 7, 14, 0, 0, 8492, 8493, 7, 6, 0, 0, 8493, 8494, 7, 7, 0, 0, 8494, 8495, + 7, 4, 0, 0, 8495, 690, 1, 0, 0, 0, 8496, 8497, 7, 8, 0, 0, 8497, 8498, + 7, 12, 0, 0, 8498, 8499, 7, 5, 0, 0, 8499, 8500, 7, 4, 0, 0, 8500, 8501, + 7, 2, 0, 0, 8501, 8502, 7, 14, 0, 0, 8502, 8503, 7, 9, 0, 0, 8503, 8504, + 7, 0, 0, 0, 8504, 8505, 7, 4, 0, 0, 8505, 8506, 7, 12, 0, 0, 8506, 8507, + 7, 14, 0, 0, 8507, 692, 1, 0, 0, 0, 8508, 8509, 7, 8, 0, 0, 8509, 8510, + 7, 13, 0, 0, 8510, 694, 1, 0, 0, 0, 8511, 8512, 7, 8, 0, 0, 8512, 8513, + 7, 18, 0, 0, 8513, 8514, 7, 8, 0, 0, 8514, 8515, 7, 11, 0, 0, 8515, 8516, + 7, 6, 0, 0, 8516, 696, 1, 0, 0, 0, 8517, 8518, 7, 9, 0, 0, 8518, 8519, + 7, 0, 0, 0, 8519, 8520, 7, 7, 0, 0, 8520, 8521, 7, 17, 0, 0, 8521, 8522, + 7, 11, 0, 0, 8522, 8523, 7, 10, 0, 0, 8523, 8524, 7, 7, 0, 0, 8524, 8525, + 7, 17, 0, 0, 8525, 698, 1, 0, 0, 0, 8526, 8527, 7, 9, 0, 0, 8527, 8528, + 7, 0, 0, 0, 8528, 8529, 7, 4, 0, 0, 8529, 8530, 7, 0, 0, 0, 8530, 8531, + 7, 1, 0, 0, 8531, 8532, 7, 0, 0, 0, 8532, 8533, 7, 5, 0, 0, 8533, 8534, + 7, 6, 0, 0, 8534, 700, 1, 0, 0, 0, 8535, 8536, 7, 9, 0, 0, 8536, 8537, + 7, 0, 0, 0, 8537, 8538, 7, 4, 0, 0, 8538, 8539, 7, 0, 0, 0, 8539, 702, + 1, 0, 0, 0, 8540, 8541, 7, 9, 0, 0, 8541, 8542, 7, 0, 0, 0, 8542, 8543, + 7, 4, 0, 0, 8543, 8544, 7, 0, 0, 0, 8544, 8545, 7, 16, 0, 0, 8545, 8546, + 7, 10, 0, 0, 8546, 8547, 7, 11, 0, 0, 8547, 8548, 7, 6, 0, 0, 8548, 704, + 1, 0, 0, 0, 8549, 8550, 7, 9, 0, 0, 8550, 8551, 7, 0, 0, 0, 8551, 8552, + 7, 4, 0, 0, 8552, 8553, 7, 0, 0, 0, 8553, 8554, 7, 16, 0, 0, 8554, 8555, + 7, 10, 0, 0, 8555, 8556, 7, 11, 0, 0, 8556, 8557, 7, 6, 0, 0, 8557, 8558, + 7, 5, 0, 0, 8558, 706, 1, 0, 0, 0, 8559, 8560, 7, 9, 0, 0, 8560, 8561, + 7, 0, 0, 0, 8561, 8562, 7, 4, 0, 0, 8562, 8563, 7, 0, 0, 0, 8563, 8564, + 7, 17, 0, 0, 8564, 8565, 7, 12, 0, 0, 8565, 8566, 7, 0, 0, 0, 8566, 8567, + 7, 3, 0, 0, 8567, 8568, 7, 9, 0, 0, 8568, 8569, 7, 8, 0, 0, 8569, 8570, + 7, 2, 0, 0, 8570, 8571, 7, 7, 0, 0, 8571, 8572, 7, 16, 0, 0, 8572, 8573, + 7, 10, 0, 0, 8573, 8574, 7, 17, 0, 0, 8574, 708, 1, 0, 0, 0, 8575, 8576, + 7, 9, 0, 0, 8576, 8577, 7, 0, 0, 0, 8577, 8578, 7, 4, 0, 0, 8578, 8579, + 7, 0, 0, 0, 8579, 8580, 7, 14, 0, 0, 8580, 8581, 7, 2, 0, 0, 8581, 8582, + 7, 13, 0, 0, 8582, 8583, 7, 6, 0, 0, 8583, 8584, 7, 14, 0, 0, 8584, 8585, + 7, 6, 0, 0, 8585, 8586, 7, 7, 0, 0, 8586, 8587, 7, 4, 0, 0, 8587, 710, + 1, 0, 0, 0, 8588, 8589, 7, 9, 0, 0, 8589, 8590, 7, 0, 0, 0, 8590, 8591, + 7, 4, 0, 0, 8591, 8592, 7, 0, 0, 0, 8592, 8593, 7, 2, 0, 0, 8593, 8594, + 7, 1, 0, 0, 8594, 8595, 7, 20, 0, 0, 8595, 8596, 7, 7, 0, 0, 8596, 8597, + 7, 2, 0, 0, 8597, 712, 1, 0, 0, 0, 8598, 8599, 7, 9, 0, 0, 8599, 8600, + 7, 0, 0, 0, 8600, 8601, 7, 4, 0, 0, 8601, 8602, 7, 0, 0, 0, 8602, 8603, + 7, 2, 0, 0, 8603, 8604, 7, 1, 0, 0, 8604, 8605, 7, 20, 0, 0, 8605, 8606, + 5, 95, 0, 0, 8606, 8607, 7, 4, 0, 0, 8607, 8608, 7, 2, 0, 0, 8608, 8609, + 5, 95, 0, 0, 8609, 8610, 7, 14, 0, 0, 8610, 8611, 7, 0, 0, 0, 8611, 8612, + 7, 4, 0, 0, 8612, 8613, 5, 95, 0, 0, 8613, 8614, 7, 15, 0, 0, 8614, 8615, + 7, 0, 0, 0, 8615, 8616, 7, 3, 0, 0, 8616, 8617, 7, 4, 0, 0, 8617, 8618, + 7, 10, 0, 0, 8618, 8619, 7, 4, 0, 0, 8619, 8620, 7, 10, 0, 0, 8620, 8621, + 7, 2, 0, 0, 8621, 8622, 7, 7, 0, 0, 8622, 714, 1, 0, 0, 0, 8623, 8624, + 7, 9, 0, 0, 8624, 8625, 7, 0, 0, 0, 8625, 8626, 7, 4, 0, 0, 8626, 8627, + 7, 0, 0, 0, 8627, 8628, 7, 2, 0, 0, 8628, 8629, 7, 1, 0, 0, 8629, 8630, + 7, 20, 0, 0, 8630, 8631, 5, 95, 0, 0, 8631, 8632, 7, 4, 0, 0, 8632, 8633, + 7, 2, 0, 0, 8633, 8634, 5, 95, 0, 0, 8634, 8635, 7, 15, 0, 0, 8635, 8636, + 7, 0, 0, 0, 8636, 8637, 7, 3, 0, 0, 8637, 8638, 7, 4, 0, 0, 8638, 8639, + 7, 10, 0, 0, 8639, 8640, 7, 4, 0, 0, 8640, 8641, 7, 10, 0, 0, 8641, 8642, + 7, 2, 0, 0, 8642, 8643, 7, 7, 0, 0, 8643, 716, 1, 0, 0, 0, 8644, 8645, + 7, 9, 0, 0, 8645, 8646, 7, 0, 0, 0, 8646, 8647, 7, 4, 0, 0, 8647, 8648, + 7, 0, 0, 0, 8648, 8649, 7, 15, 0, 0, 8649, 8650, 7, 12, 0, 0, 8650, 8651, + 7, 14, 0, 0, 8651, 8652, 7, 15, 0, 0, 8652, 718, 1, 0, 0, 0, 8653, 8654, + 7, 9, 0, 0, 8654, 8655, 7, 0, 0, 0, 8655, 8656, 7, 4, 0, 0, 8656, 8657, + 7, 0, 0, 0, 8657, 8658, 5, 95, 0, 0, 8658, 8659, 7, 5, 0, 0, 8659, 8660, + 7, 6, 0, 0, 8660, 8661, 7, 8, 0, 0, 8661, 8662, 7, 12, 0, 0, 8662, 8663, + 7, 3, 0, 0, 8663, 8664, 7, 10, 0, 0, 8664, 8665, 7, 4, 0, 0, 8665, 8666, + 7, 18, 0, 0, 8666, 8667, 5, 95, 0, 0, 8667, 8668, 7, 3, 0, 0, 8668, 8669, + 7, 6, 0, 0, 8669, 8670, 7, 22, 0, 0, 8670, 8671, 7, 3, 0, 0, 8671, 8672, + 7, 10, 0, 0, 8672, 8673, 7, 4, 0, 0, 8673, 8674, 7, 6, 0, 0, 8674, 8675, + 5, 95, 0, 0, 8675, 8676, 7, 11, 0, 0, 8676, 8677, 7, 10, 0, 0, 8677, 8678, + 7, 14, 0, 0, 8678, 8679, 7, 10, 0, 0, 8679, 8680, 7, 4, 0, 0, 8680, 720, + 1, 0, 0, 0, 8681, 8682, 7, 9, 0, 0, 8682, 8683, 7, 0, 0, 0, 8683, 8684, + 7, 4, 0, 0, 8684, 8685, 7, 6, 0, 0, 8685, 722, 1, 0, 0, 0, 8686, 8687, + 7, 9, 0, 0, 8687, 8688, 7, 0, 0, 0, 8688, 8689, 7, 4, 0, 0, 8689, 8690, + 7, 6, 0, 0, 8690, 8691, 5, 95, 0, 0, 8691, 8692, 7, 8, 0, 0, 8692, 8693, + 7, 0, 0, 0, 8693, 8694, 7, 8, 0, 0, 8694, 8695, 7, 19, 0, 0, 8695, 8696, + 7, 6, 0, 0, 8696, 724, 1, 0, 0, 0, 8697, 8698, 7, 9, 0, 0, 8698, 8699, + 7, 0, 0, 0, 8699, 8700, 7, 4, 0, 0, 8700, 8701, 7, 6, 0, 0, 8701, 8702, + 5, 95, 0, 0, 8702, 8703, 7, 16, 0, 0, 8703, 8704, 7, 2, 0, 0, 8704, 8705, + 7, 3, 0, 0, 8705, 8706, 7, 14, 0, 0, 8706, 8707, 7, 0, 0, 0, 8707, 8708, + 7, 4, 0, 0, 8708, 726, 1, 0, 0, 0, 8709, 8710, 7, 9, 0, 0, 8710, 8711, + 7, 0, 0, 0, 8711, 8712, 7, 4, 0, 0, 8712, 8713, 7, 6, 0, 0, 8713, 8714, + 5, 95, 0, 0, 8714, 8715, 7, 14, 0, 0, 8715, 8716, 7, 2, 0, 0, 8716, 8717, + 7, 9, 0, 0, 8717, 8718, 7, 6, 0, 0, 8718, 728, 1, 0, 0, 0, 8719, 8720, + 7, 9, 0, 0, 8720, 8721, 7, 0, 0, 0, 8721, 8722, 7, 18, 0, 0, 8722, 730, + 1, 0, 0, 0, 8723, 8724, 7, 9, 0, 0, 8724, 8725, 7, 0, 0, 0, 8725, 8726, + 7, 18, 0, 0, 8726, 8727, 7, 5, 0, 0, 8727, 732, 1, 0, 0, 0, 8728, 8729, + 7, 9, 0, 0, 8729, 8730, 7, 0, 0, 0, 8730, 8731, 7, 18, 0, 0, 8731, 8732, + 5, 95, 0, 0, 8732, 8733, 7, 4, 0, 0, 8733, 8734, 7, 2, 0, 0, 8734, 8735, + 5, 95, 0, 0, 8735, 8736, 7, 5, 0, 0, 8736, 8737, 7, 6, 0, 0, 8737, 8738, + 7, 8, 0, 0, 8738, 8739, 7, 2, 0, 0, 8739, 8740, 7, 7, 0, 0, 8740, 8741, + 7, 9, 0, 0, 8741, 734, 1, 0, 0, 0, 8742, 8743, 7, 9, 0, 0, 8743, 8744, + 7, 1, 0, 0, 8744, 8745, 7, 0, 0, 0, 8745, 736, 1, 0, 0, 0, 8746, 8747, + 7, 9, 0, 0, 8747, 8748, 7, 1, 0, 0, 8748, 8749, 7, 0, 0, 0, 8749, 8750, + 5, 95, 0, 0, 8750, 8751, 7, 3, 0, 0, 8751, 8752, 7, 6, 0, 0, 8752, 8753, + 7, 8, 0, 0, 8753, 8754, 7, 18, 0, 0, 8754, 8755, 7, 8, 0, 0, 8755, 8756, + 7, 11, 0, 0, 8756, 8757, 7, 6, 0, 0, 8757, 8758, 7, 1, 0, 0, 8758, 8759, + 7, 10, 0, 0, 8759, 8760, 7, 7, 0, 0, 8760, 738, 1, 0, 0, 0, 8761, 8762, + 7, 9, 0, 0, 8762, 8763, 7, 1, 0, 0, 8763, 8764, 7, 11, 0, 0, 8764, 8765, + 7, 10, 0, 0, 8765, 8766, 7, 7, 0, 0, 8766, 8767, 7, 21, 0, 0, 8767, 740, + 1, 0, 0, 0, 8768, 8769, 7, 9, 0, 0, 8769, 8770, 7, 1, 0, 0, 8770, 8771, + 7, 14, 0, 0, 8771, 8772, 7, 5, 0, 0, 8772, 8773, 5, 95, 0, 0, 8773, 8774, + 7, 5, 0, 0, 8774, 8775, 7, 4, 0, 0, 8775, 8776, 7, 0, 0, 0, 8776, 8777, + 7, 4, 0, 0, 8777, 8778, 7, 5, 0, 0, 8778, 742, 1, 0, 0, 0, 8779, 8780, + 7, 9, 0, 0, 8780, 8781, 7, 1, 0, 0, 8781, 8782, 5, 95, 0, 0, 8782, 8783, + 7, 3, 0, 0, 8783, 8784, 7, 2, 0, 0, 8784, 8785, 7, 11, 0, 0, 8785, 8786, + 7, 6, 0, 0, 8786, 8787, 5, 95, 0, 0, 8787, 8788, 7, 8, 0, 0, 8788, 8789, + 7, 19, 0, 0, 8789, 8790, 7, 0, 0, 0, 8790, 8791, 7, 7, 0, 0, 8791, 8792, + 7, 17, 0, 0, 8792, 8793, 7, 6, 0, 0, 8793, 744, 1, 0, 0, 0, 8794, 8795, + 7, 9, 0, 0, 8795, 8796, 7, 1, 0, 0, 8796, 8797, 7, 4, 0, 0, 8797, 8798, + 7, 10, 0, 0, 8798, 8799, 7, 14, 0, 0, 8799, 8800, 7, 6, 0, 0, 8800, 8801, + 7, 23, 0, 0, 8801, 8802, 7, 2, 0, 0, 8802, 8803, 7, 7, 0, 0, 8803, 8804, + 7, 6, 0, 0, 8804, 746, 1, 0, 0, 0, 8805, 8806, 7, 9, 0, 0, 8806, 8807, + 7, 1, 0, 0, 8807, 8808, 5, 95, 0, 0, 8808, 8809, 7, 12, 0, 0, 8809, 8810, + 7, 7, 0, 0, 8810, 8811, 7, 10, 0, 0, 8811, 8812, 7, 24, 0, 0, 8812, 8813, + 7, 12, 0, 0, 8813, 8814, 7, 6, 0, 0, 8814, 8815, 5, 95, 0, 0, 8815, 8816, + 7, 7, 0, 0, 8816, 8817, 7, 0, 0, 0, 8817, 8818, 7, 14, 0, 0, 8818, 8819, + 7, 6, 0, 0, 8819, 748, 1, 0, 0, 0, 8820, 8821, 7, 9, 0, 0, 8821, 8822, + 7, 1, 0, 0, 8822, 8823, 5, 95, 0, 0, 8823, 8824, 7, 13, 0, 0, 8824, 8825, + 7, 6, 0, 0, 8825, 8826, 7, 3, 0, 0, 8826, 8827, 7, 5, 0, 0, 8827, 8828, + 7, 10, 0, 0, 8828, 8829, 7, 2, 0, 0, 8829, 8830, 7, 7, 0, 0, 8830, 750, + 1, 0, 0, 0, 8831, 8832, 7, 9, 0, 0, 8832, 8833, 7, 9, 0, 0, 8833, 8834, + 7, 11, 0, 0, 8834, 752, 1, 0, 0, 0, 8835, 8836, 7, 9, 0, 0, 8836, 8837, + 7, 6, 0, 0, 8837, 8838, 7, 0, 0, 0, 8838, 8839, 7, 11, 0, 0, 8839, 8840, + 7, 11, 0, 0, 8840, 8841, 7, 2, 0, 0, 8841, 8842, 7, 8, 0, 0, 8842, 8843, + 7, 0, 0, 0, 8843, 8844, 7, 4, 0, 0, 8844, 8845, 7, 6, 0, 0, 8845, 754, + 1, 0, 0, 0, 8846, 8847, 7, 9, 0, 0, 8847, 8848, 7, 6, 0, 0, 8848, 8849, + 7, 1, 0, 0, 8849, 8850, 7, 12, 0, 0, 8850, 8851, 7, 17, 0, 0, 8851, 756, + 1, 0, 0, 0, 8852, 8853, 7, 9, 0, 0, 8853, 8854, 7, 6, 0, 0, 8854, 8855, + 7, 1, 0, 0, 8855, 8856, 7, 12, 0, 0, 8856, 8857, 7, 17, 0, 0, 8857, 8858, + 7, 17, 0, 0, 8858, 8859, 7, 6, 0, 0, 8859, 8860, 7, 3, 0, 0, 8860, 758, + 1, 0, 0, 0, 8861, 8862, 7, 9, 0, 0, 8862, 8863, 7, 6, 0, 0, 8863, 8864, + 7, 8, 0, 0, 8864, 760, 1, 0, 0, 0, 8865, 8866, 7, 9, 0, 0, 8866, 8867, + 7, 6, 0, 0, 8867, 8868, 7, 8, 0, 0, 8868, 8869, 7, 10, 0, 0, 8869, 8870, + 7, 14, 0, 0, 8870, 8871, 7, 0, 0, 0, 8871, 8872, 7, 11, 0, 0, 8872, 762, + 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, 11, 0, 0, 8877, 8878, 7, 0, 0, 0, 8878, 8879, + 7, 3, 0, 0, 8879, 8880, 7, 6, 0, 0, 8880, 764, 1, 0, 0, 0, 8881, 8882, + 7, 9, 0, 0, 8882, 8883, 7, 6, 0, 0, 8883, 8884, 7, 8, 0, 0, 8884, 8885, + 7, 2, 0, 0, 8885, 8886, 7, 14, 0, 0, 8886, 8887, 7, 15, 0, 0, 8887, 8888, + 7, 2, 0, 0, 8888, 8889, 7, 5, 0, 0, 8889, 8890, 7, 6, 0, 0, 8890, 766, + 1, 0, 0, 0, 8891, 8892, 7, 9, 0, 0, 8892, 8893, 7, 6, 0, 0, 8893, 8894, + 7, 8, 0, 0, 8894, 8895, 7, 2, 0, 0, 8895, 8896, 7, 3, 0, 0, 8896, 8897, + 7, 3, 0, 0, 8897, 8898, 7, 6, 0, 0, 8898, 8899, 7, 11, 0, 0, 8899, 8900, + 7, 0, 0, 0, 8900, 8901, 7, 4, 0, 0, 8901, 8902, 7, 6, 0, 0, 8902, 768, + 1, 0, 0, 0, 8903, 8904, 7, 9, 0, 0, 8904, 8905, 7, 6, 0, 0, 8905, 8906, + 7, 8, 0, 0, 8906, 8907, 7, 3, 0, 0, 8907, 770, 1, 0, 0, 0, 8908, 8909, + 7, 9, 0, 0, 8909, 8910, 7, 6, 0, 0, 8910, 8911, 7, 8, 0, 0, 8911, 8912, + 7, 3, 0, 0, 8912, 8913, 7, 6, 0, 0, 8913, 8914, 7, 14, 0, 0, 8914, 8915, + 7, 6, 0, 0, 8915, 8916, 7, 7, 0, 0, 8916, 8917, 7, 4, 0, 0, 8917, 772, + 1, 0, 0, 0, 8918, 8919, 7, 9, 0, 0, 8919, 8920, 7, 6, 0, 0, 8920, 8921, + 7, 8, 0, 0, 8921, 8922, 7, 3, 0, 0, 8922, 8923, 7, 18, 0, 0, 8923, 8924, + 7, 15, 0, 0, 8924, 8925, 7, 4, 0, 0, 8925, 774, 1, 0, 0, 0, 8926, 8927, + 7, 9, 0, 0, 8927, 8928, 7, 6, 0, 0, 8928, 8929, 7, 9, 0, 0, 8929, 8930, + 7, 12, 0, 0, 8930, 8931, 7, 15, 0, 0, 8931, 8932, 7, 11, 0, 0, 8932, 8933, + 7, 10, 0, 0, 8933, 8934, 7, 8, 0, 0, 8934, 8935, 7, 0, 0, 0, 8935, 8936, + 7, 4, 0, 0, 8936, 8937, 7, 6, 0, 0, 8937, 776, 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, 778, 1, 0, 0, 0, 8946, 8947, 7, 9, 0, 0, 8947, 8948, + 7, 6, 0, 0, 8948, 8949, 7, 16, 0, 0, 8949, 8950, 7, 0, 0, 0, 8950, 8951, + 7, 12, 0, 0, 8951, 8952, 7, 11, 0, 0, 8952, 8953, 7, 4, 0, 0, 8953, 8954, + 7, 10, 0, 0, 8954, 8955, 7, 16, 0, 0, 8955, 780, 1, 0, 0, 0, 8956, 8957, + 7, 9, 0, 0, 8957, 8958, 7, 6, 0, 0, 8958, 8959, 7, 16, 0, 0, 8959, 8960, + 7, 0, 0, 0, 8960, 8961, 7, 12, 0, 0, 8961, 8962, 7, 11, 0, 0, 8962, 8963, + 7, 4, 0, 0, 8963, 8964, 7, 5, 0, 0, 8964, 782, 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, 2, 0, 0, 8975, 8976, 7, 11, 0, 0, 8976, 8977, 7, 11, 0, 0, 8977, 8978, + 7, 0, 0, 0, 8978, 8979, 7, 4, 0, 0, 8979, 8980, 7, 10, 0, 0, 8980, 8981, + 7, 2, 0, 0, 8981, 8982, 7, 7, 0, 0, 8982, 784, 1, 0, 0, 0, 8983, 8984, + 7, 9, 0, 0, 8984, 8985, 7, 6, 0, 0, 8985, 8986, 7, 16, 0, 0, 8986, 8987, + 7, 0, 0, 0, 8987, 8988, 7, 12, 0, 0, 8988, 8989, 7, 11, 0, 0, 8989, 8990, + 7, 4, 0, 0, 8990, 8991, 5, 95, 0, 0, 8991, 8992, 7, 8, 0, 0, 8992, 8993, + 7, 3, 0, 0, 8993, 8994, 7, 6, 0, 0, 8994, 8995, 7, 9, 0, 0, 8995, 8996, + 7, 6, 0, 0, 8996, 8997, 7, 7, 0, 0, 8997, 8998, 7, 4, 0, 0, 8998, 8999, + 7, 10, 0, 0, 8999, 9000, 7, 0, 0, 0, 9000, 9001, 7, 11, 0, 0, 9001, 786, + 1, 0, 0, 0, 9002, 9003, 7, 9, 0, 0, 9003, 9004, 7, 6, 0, 0, 9004, 9005, + 7, 16, 0, 0, 9005, 9006, 7, 6, 0, 0, 9006, 9007, 7, 3, 0, 0, 9007, 9008, + 7, 3, 0, 0, 9008, 9009, 7, 0, 0, 0, 9009, 9010, 7, 1, 0, 0, 9010, 9011, + 7, 11, 0, 0, 9011, 9012, 7, 6, 0, 0, 9012, 788, 1, 0, 0, 0, 9013, 9014, + 7, 9, 0, 0, 9014, 9015, 7, 6, 0, 0, 9015, 9016, 7, 16, 0, 0, 9016, 9017, + 7, 6, 0, 0, 9017, 9018, 7, 3, 0, 0, 9018, 9019, 7, 3, 0, 0, 9019, 9020, + 7, 6, 0, 0, 9020, 9021, 7, 9, 0, 0, 9021, 790, 1, 0, 0, 0, 9022, 9023, + 7, 9, 0, 0, 9023, 9024, 7, 6, 0, 0, 9024, 9025, 7, 16, 0, 0, 9025, 9026, + 7, 10, 0, 0, 9026, 9027, 7, 7, 0, 0, 9027, 9028, 7, 6, 0, 0, 9028, 9029, + 7, 9, 0, 0, 9029, 792, 1, 0, 0, 0, 9030, 9031, 7, 9, 0, 0, 9031, 9032, + 7, 6, 0, 0, 9032, 9033, 7, 16, 0, 0, 9033, 9034, 7, 10, 0, 0, 9034, 9035, + 7, 7, 0, 0, 9035, 9036, 7, 6, 0, 0, 9036, 794, 1, 0, 0, 0, 9037, 9038, + 7, 9, 0, 0, 9038, 9039, 7, 6, 0, 0, 9039, 9040, 7, 16, 0, 0, 9040, 9041, + 7, 10, 0, 0, 9041, 9042, 7, 7, 0, 0, 9042, 9043, 7, 6, 0, 0, 9043, 9044, + 7, 3, 0, 0, 9044, 796, 1, 0, 0, 0, 9045, 9046, 7, 9, 0, 0, 9046, 9047, + 7, 6, 0, 0, 9047, 9048, 7, 17, 0, 0, 9048, 9049, 7, 3, 0, 0, 9049, 9050, + 7, 6, 0, 0, 9050, 9051, 7, 6, 0, 0, 9051, 798, 1, 0, 0, 0, 9052, 9053, + 7, 9, 0, 0, 9053, 9054, 7, 6, 0, 0, 9054, 9055, 7, 11, 0, 0, 9055, 9056, + 7, 0, 0, 0, 9056, 9057, 7, 18, 0, 0, 9057, 800, 1, 0, 0, 0, 9058, 9059, + 7, 9, 0, 0, 9059, 9060, 7, 6, 0, 0, 9060, 9061, 7, 11, 0, 0, 9061, 9062, + 7, 6, 0, 0, 9062, 9063, 7, 17, 0, 0, 9063, 9064, 7, 0, 0, 0, 9064, 9065, + 7, 4, 0, 0, 9065, 9066, 7, 6, 0, 0, 9066, 802, 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, + 5, 95, 0, 0, 9074, 9075, 7, 0, 0, 0, 9075, 9076, 7, 11, 0, 0, 9076, 9077, + 7, 11, 0, 0, 9077, 804, 1, 0, 0, 0, 9078, 9079, 7, 9, 0, 0, 9079, 9080, + 7, 6, 0, 0, 9080, 9081, 7, 11, 0, 0, 9081, 9082, 7, 6, 0, 0, 9082, 9083, + 7, 4, 0, 0, 9083, 9084, 7, 6, 0, 0, 9084, 806, 1, 0, 0, 0, 9085, 9086, + 7, 9, 0, 0, 9086, 9087, 7, 6, 0, 0, 9087, 9088, 7, 11, 0, 0, 9088, 9089, + 7, 6, 0, 0, 9089, 9090, 7, 4, 0, 0, 9090, 9091, 7, 6, 0, 0, 9091, 9092, + 7, 25, 0, 0, 9092, 9093, 7, 14, 0, 0, 9093, 9094, 7, 11, 0, 0, 9094, 808, + 1, 0, 0, 0, 9095, 9096, 7, 9, 0, 0, 9096, 9097, 7, 6, 0, 0, 9097, 9098, + 7, 11, 0, 0, 9098, 9099, 7, 10, 0, 0, 9099, 9100, 7, 14, 0, 0, 9100, 9101, + 7, 10, 0, 0, 9101, 9102, 7, 4, 0, 0, 9102, 9103, 7, 6, 0, 0, 9103, 9104, + 7, 9, 0, 0, 9104, 810, 1, 0, 0, 0, 9105, 9106, 7, 9, 0, 0, 9106, 9107, + 7, 6, 0, 0, 9107, 9108, 7, 14, 0, 0, 9108, 9109, 7, 0, 0, 0, 9109, 9110, + 7, 7, 0, 0, 9110, 9111, 7, 9, 0, 0, 9111, 812, 1, 0, 0, 0, 9112, 9113, + 7, 9, 0, 0, 9113, 9114, 7, 6, 0, 0, 9114, 9115, 7, 7, 0, 0, 9115, 9116, + 7, 5, 0, 0, 9116, 9117, 7, 6, 0, 0, 9117, 9118, 5, 95, 0, 0, 9118, 9119, + 7, 3, 0, 0, 9119, 9120, 7, 0, 0, 0, 9120, 9121, 7, 7, 0, 0, 9121, 9122, + 7, 21, 0, 0, 9122, 9123, 7, 14, 0, 0, 9123, 814, 1, 0, 0, 0, 9124, 9125, + 7, 9, 0, 0, 9125, 9126, 7, 6, 0, 0, 9126, 9127, 7, 15, 0, 0, 9127, 9128, + 7, 6, 0, 0, 9128, 9129, 7, 7, 0, 0, 9129, 9130, 7, 9, 0, 0, 9130, 9131, + 7, 6, 0, 0, 9131, 9132, 7, 7, 0, 0, 9132, 9133, 7, 4, 0, 0, 9133, 816, + 1, 0, 0, 0, 9134, 9135, 7, 9, 0, 0, 9135, 9136, 7, 6, 0, 0, 9136, 9137, + 7, 15, 0, 0, 9137, 9138, 7, 3, 0, 0, 9138, 9139, 7, 6, 0, 0, 9139, 9140, + 7, 8, 0, 0, 9140, 9141, 7, 0, 0, 0, 9141, 9142, 7, 4, 0, 0, 9142, 9143, + 7, 6, 0, 0, 9143, 818, 1, 0, 0, 0, 9144, 9145, 7, 9, 0, 0, 9145, 9146, + 7, 6, 0, 0, 9146, 9147, 7, 15, 0, 0, 9147, 9148, 7, 4, 0, 0, 9148, 9149, + 7, 19, 0, 0, 9149, 820, 1, 0, 0, 0, 9150, 9151, 7, 9, 0, 0, 9151, 9152, + 7, 6, 0, 0, 9152, 9153, 7, 24, 0, 0, 9153, 9154, 7, 12, 0, 0, 9154, 9155, + 7, 6, 0, 0, 9155, 9156, 7, 12, 0, 0, 9156, 9157, 7, 6, 0, 0, 9157, 822, + 1, 0, 0, 0, 9158, 9159, 7, 9, 0, 0, 9159, 9160, 7, 6, 0, 0, 9160, 9161, + 7, 3, 0, 0, 9161, 9162, 7, 6, 0, 0, 9162, 9163, 7, 16, 0, 0, 9163, 824, + 1, 0, 0, 0, 9164, 9165, 7, 9, 0, 0, 9165, 9166, 7, 6, 0, 0, 9166, 9167, + 7, 3, 0, 0, 9167, 9168, 7, 6, 0, 0, 9168, 9169, 7, 16, 0, 0, 9169, 9170, + 5, 95, 0, 0, 9170, 9171, 7, 7, 0, 0, 9171, 9172, 7, 2, 0, 0, 9172, 9173, + 5, 95, 0, 0, 9173, 9174, 7, 3, 0, 0, 9174, 9175, 7, 6, 0, 0, 9175, 9176, + 7, 22, 0, 0, 9176, 9177, 7, 3, 0, 0, 9177, 9178, 7, 10, 0, 0, 9178, 9179, + 7, 4, 0, 0, 9179, 9180, 7, 6, 0, 0, 9180, 826, 1, 0, 0, 0, 9181, 9182, + 7, 9, 0, 0, 9182, 9183, 7, 6, 0, 0, 9183, 9184, 7, 5, 0, 0, 9184, 9185, + 7, 8, 0, 0, 9185, 828, 1, 0, 0, 0, 9186, 9187, 7, 9, 0, 0, 9187, 9188, + 7, 6, 0, 0, 9188, 9189, 7, 5, 0, 0, 9189, 9190, 7, 8, 0, 0, 9190, 9191, + 7, 3, 0, 0, 9191, 9192, 7, 10, 0, 0, 9192, 9193, 7, 15, 0, 0, 9193, 9194, + 7, 4, 0, 0, 9194, 9195, 7, 10, 0, 0, 9195, 9196, 7, 2, 0, 0, 9196, 9197, + 7, 7, 0, 0, 9197, 830, 1, 0, 0, 0, 9198, 9199, 7, 9, 0, 0, 9199, 9200, + 7, 6, 0, 0, 9200, 9201, 7, 5, 0, 0, 9201, 9202, 7, 4, 0, 0, 9202, 9203, + 7, 3, 0, 0, 9203, 9204, 7, 2, 0, 0, 9204, 9205, 7, 18, 0, 0, 9205, 832, + 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, 0, 0, 0, 9210, 9211, 7, 8, 0, 0, 9211, 9212, + 7, 19, 0, 0, 9212, 9213, 7, 6, 0, 0, 9213, 9214, 7, 9, 0, 0, 9214, 834, + 1, 0, 0, 0, 9215, 9216, 7, 9, 0, 0, 9216, 9217, 7, 6, 0, 0, 9217, 9218, + 7, 4, 0, 0, 9218, 9219, 7, 6, 0, 0, 9219, 9220, 7, 8, 0, 0, 9220, 9221, + 7, 4, 0, 0, 9221, 9222, 7, 6, 0, 0, 9222, 9223, 7, 9, 0, 0, 9223, 836, + 1, 0, 0, 0, 9224, 9225, 7, 9, 0, 0, 9225, 9226, 7, 6, 0, 0, 9226, 9227, + 7, 4, 0, 0, 9227, 9228, 7, 6, 0, 0, 9228, 9229, 7, 3, 0, 0, 9229, 9230, + 7, 14, 0, 0, 9230, 9231, 7, 10, 0, 0, 9231, 9232, 7, 7, 0, 0, 9232, 9233, + 7, 6, 0, 0, 9233, 9234, 7, 5, 0, 0, 9234, 838, 1, 0, 0, 0, 9235, 9236, + 7, 9, 0, 0, 9236, 9237, 7, 6, 0, 0, 9237, 9238, 7, 4, 0, 0, 9238, 9239, + 7, 6, 0, 0, 9239, 9240, 7, 3, 0, 0, 9240, 9241, 7, 14, 0, 0, 9241, 9242, + 7, 10, 0, 0, 9242, 9243, 7, 7, 0, 0, 9243, 9244, 7, 10, 0, 0, 9244, 9245, + 7, 5, 0, 0, 9245, 9246, 7, 4, 0, 0, 9246, 9247, 7, 10, 0, 0, 9247, 9248, + 7, 8, 0, 0, 9248, 840, 1, 0, 0, 0, 9249, 9250, 7, 9, 0, 0, 9250, 9251, + 7, 10, 0, 0, 9251, 9252, 7, 8, 0, 0, 9252, 9253, 7, 4, 0, 0, 9253, 9254, + 7, 10, 0, 0, 9254, 9255, 7, 2, 0, 0, 9255, 9256, 7, 7, 0, 0, 9256, 9257, + 7, 0, 0, 0, 9257, 9258, 7, 3, 0, 0, 9258, 9259, 7, 18, 0, 0, 9259, 842, + 1, 0, 0, 0, 9260, 9261, 7, 9, 0, 0, 9261, 9262, 7, 10, 0, 0, 9262, 9263, + 7, 14, 0, 0, 9263, 9264, 7, 6, 0, 0, 9264, 9265, 7, 7, 0, 0, 9265, 9266, + 7, 5, 0, 0, 9266, 9267, 7, 10, 0, 0, 9267, 9268, 7, 2, 0, 0, 9268, 9269, + 7, 7, 0, 0, 9269, 844, 1, 0, 0, 0, 9270, 9271, 7, 9, 0, 0, 9271, 9272, + 7, 10, 0, 0, 9272, 9273, 7, 14, 0, 0, 9273, 9274, 7, 6, 0, 0, 9274, 9275, + 7, 7, 0, 0, 9275, 9276, 7, 5, 0, 0, 9276, 9277, 7, 10, 0, 0, 9277, 9278, + 7, 2, 0, 0, 9278, 9279, 7, 7, 0, 0, 9279, 9280, 7, 5, 0, 0, 9280, 846, + 1, 0, 0, 0, 9281, 9282, 7, 9, 0, 0, 9282, 9283, 7, 10, 0, 0, 9283, 9284, + 7, 3, 0, 0, 9284, 9285, 7, 6, 0, 0, 9285, 9286, 7, 8, 0, 0, 9286, 9287, + 7, 4, 0, 0, 9287, 9288, 7, 10, 0, 0, 9288, 9289, 7, 2, 0, 0, 9289, 848, + 1, 0, 0, 0, 9290, 9291, 7, 9, 0, 0, 9291, 9292, 7, 10, 0, 0, 9292, 9293, + 7, 3, 0, 0, 9293, 9294, 7, 6, 0, 0, 9294, 9295, 7, 8, 0, 0, 9295, 9296, + 7, 4, 0, 0, 9296, 9297, 5, 95, 0, 0, 9297, 9298, 7, 11, 0, 0, 9298, 9299, + 7, 2, 0, 0, 9299, 9300, 7, 0, 0, 0, 9300, 9301, 7, 9, 0, 0, 9301, 850, + 1, 0, 0, 0, 9302, 9303, 7, 9, 0, 0, 9303, 9304, 7, 10, 0, 0, 9304, 9305, + 7, 3, 0, 0, 9305, 9306, 7, 6, 0, 0, 9306, 9307, 7, 8, 0, 0, 9307, 9308, + 7, 4, 0, 0, 9308, 9309, 7, 2, 0, 0, 9309, 9310, 7, 3, 0, 0, 9310, 9311, + 7, 18, 0, 0, 9311, 852, 1, 0, 0, 0, 9312, 9313, 7, 9, 0, 0, 9313, 9314, + 7, 10, 0, 0, 9314, 9315, 7, 3, 0, 0, 9315, 9316, 7, 6, 0, 0, 9316, 9317, + 7, 8, 0, 0, 9317, 9318, 7, 4, 0, 0, 9318, 9319, 5, 95, 0, 0, 9319, 9320, + 7, 15, 0, 0, 9320, 9321, 7, 0, 0, 0, 9321, 9322, 7, 4, 0, 0, 9322, 9323, + 7, 19, 0, 0, 9323, 854, 1, 0, 0, 0, 9324, 9325, 7, 9, 0, 0, 9325, 9326, + 7, 10, 0, 0, 9326, 9327, 7, 5, 0, 0, 9327, 9328, 7, 0, 0, 0, 9328, 9329, + 7, 1, 0, 0, 9329, 9330, 7, 11, 0, 0, 9330, 9331, 7, 6, 0, 0, 9331, 9332, + 5, 95, 0, 0, 9332, 9333, 7, 0, 0, 0, 9333, 9334, 7, 11, 0, 0, 9334, 9335, + 7, 11, 0, 0, 9335, 856, 1, 0, 0, 0, 9336, 9337, 7, 9, 0, 0, 9337, 9338, + 7, 10, 0, 0, 9338, 9339, 7, 5, 0, 0, 9339, 9340, 7, 0, 0, 0, 9340, 9341, + 7, 1, 0, 0, 9341, 9342, 7, 11, 0, 0, 9342, 9343, 7, 6, 0, 0, 9343, 858, + 1, 0, 0, 0, 9344, 9345, 7, 9, 0, 0, 9345, 9346, 7, 10, 0, 0, 9346, 9347, + 7, 5, 0, 0, 9347, 9348, 7, 0, 0, 0, 9348, 9349, 7, 1, 0, 0, 9349, 9350, + 7, 11, 0, 0, 9350, 9351, 7, 6, 0, 0, 9351, 9352, 7, 9, 0, 0, 9352, 860, + 1, 0, 0, 0, 9353, 9354, 7, 9, 0, 0, 9354, 9355, 7, 10, 0, 0, 9355, 9356, + 7, 5, 0, 0, 9356, 9357, 7, 0, 0, 0, 9357, 9358, 7, 1, 0, 0, 9358, 9359, + 7, 11, 0, 0, 9359, 9360, 7, 6, 0, 0, 9360, 9361, 5, 95, 0, 0, 9361, 9362, + 7, 9, 0, 0, 9362, 9363, 7, 10, 0, 0, 9363, 9364, 7, 3, 0, 0, 9364, 9365, + 7, 6, 0, 0, 9365, 9366, 7, 8, 0, 0, 9366, 9367, 7, 4, 0, 0, 9367, 9368, + 7, 2, 0, 0, 9368, 9369, 7, 3, 0, 0, 9369, 9370, 7, 18, 0, 0, 9370, 9371, + 5, 95, 0, 0, 9371, 9372, 7, 11, 0, 0, 9372, 9373, 7, 10, 0, 0, 9373, 9374, + 7, 7, 0, 0, 9374, 9375, 7, 21, 0, 0, 9375, 9376, 5, 95, 0, 0, 9376, 9377, + 7, 8, 0, 0, 9377, 9378, 7, 19, 0, 0, 9378, 9379, 7, 6, 0, 0, 9379, 9380, + 7, 8, 0, 0, 9380, 9381, 7, 21, 0, 0, 9381, 862, 1, 0, 0, 0, 9382, 9383, + 7, 9, 0, 0, 9383, 9384, 7, 10, 0, 0, 9384, 9385, 7, 5, 0, 0, 9385, 9386, + 7, 0, 0, 0, 9386, 9387, 7, 1, 0, 0, 9387, 9388, 7, 11, 0, 0, 9388, 9389, + 7, 6, 0, 0, 9389, 9390, 5, 95, 0, 0, 9390, 9391, 7, 15, 0, 0, 9391, 9392, + 7, 0, 0, 0, 9392, 9393, 7, 3, 0, 0, 9393, 9394, 7, 0, 0, 0, 9394, 9395, + 7, 11, 0, 0, 9395, 9396, 7, 11, 0, 0, 9396, 9397, 7, 6, 0, 0, 9397, 9398, + 7, 11, 0, 0, 9398, 9399, 5, 95, 0, 0, 9399, 9400, 7, 9, 0, 0, 9400, 9401, + 7, 14, 0, 0, 9401, 9402, 7, 11, 0, 0, 9402, 864, 1, 0, 0, 0, 9403, 9404, + 7, 9, 0, 0, 9404, 9405, 7, 10, 0, 0, 9405, 9406, 7, 5, 0, 0, 9406, 9407, + 7, 0, 0, 0, 9407, 9408, 7, 1, 0, 0, 9408, 9409, 7, 11, 0, 0, 9409, 9410, + 7, 6, 0, 0, 9410, 9411, 5, 95, 0, 0, 9411, 9412, 7, 15, 0, 0, 9412, 9413, + 7, 3, 0, 0, 9413, 9414, 7, 6, 0, 0, 9414, 9415, 7, 5, 0, 0, 9415, 9416, + 7, 6, 0, 0, 9416, 9417, 7, 4, 0, 0, 9417, 866, 1, 0, 0, 0, 9418, 9419, + 7, 9, 0, 0, 9419, 9420, 7, 10, 0, 0, 9420, 9421, 7, 5, 0, 0, 9421, 9422, + 7, 0, 0, 0, 9422, 9423, 7, 1, 0, 0, 9423, 9424, 7, 11, 0, 0, 9424, 9425, + 7, 6, 0, 0, 9425, 9426, 5, 95, 0, 0, 9426, 9427, 7, 3, 0, 0, 9427, 9428, + 7, 15, 0, 0, 9428, 9429, 7, 21, 0, 0, 9429, 9430, 7, 6, 0, 0, 9430, 868, + 1, 0, 0, 0, 9431, 9432, 7, 9, 0, 0, 9432, 9433, 7, 10, 0, 0, 9433, 9434, + 7, 5, 0, 0, 9434, 9435, 7, 0, 0, 0, 9435, 9436, 7, 11, 0, 0, 9436, 9437, + 7, 11, 0, 0, 9437, 9438, 7, 2, 0, 0, 9438, 9439, 7, 22, 0, 0, 9439, 870, + 1, 0, 0, 0, 9440, 9441, 7, 9, 0, 0, 9441, 9442, 7, 10, 0, 0, 9442, 9443, + 7, 5, 0, 0, 9443, 9444, 7, 0, 0, 0, 9444, 9445, 7, 5, 0, 0, 9445, 9446, + 7, 5, 0, 0, 9446, 9447, 7, 2, 0, 0, 9447, 9448, 7, 8, 0, 0, 9448, 9449, + 7, 10, 0, 0, 9449, 9450, 7, 0, 0, 0, 9450, 9451, 7, 4, 0, 0, 9451, 9452, + 7, 6, 0, 0, 9452, 872, 1, 0, 0, 0, 9453, 9454, 7, 9, 0, 0, 9454, 9455, + 7, 10, 0, 0, 9455, 9456, 7, 5, 0, 0, 9456, 9457, 7, 8, 0, 0, 9457, 9458, + 7, 0, 0, 0, 9458, 9459, 7, 3, 0, 0, 9459, 9460, 7, 9, 0, 0, 9460, 874, + 1, 0, 0, 0, 9461, 9462, 7, 9, 0, 0, 9462, 9463, 7, 10, 0, 0, 9463, 9464, + 7, 5, 0, 0, 9464, 9465, 7, 8, 0, 0, 9465, 9466, 7, 0, 0, 0, 9466, 9467, + 7, 3, 0, 0, 9467, 9468, 7, 9, 0, 0, 9468, 9469, 7, 16, 0, 0, 9469, 9470, + 7, 10, 0, 0, 9470, 9471, 7, 11, 0, 0, 9471, 9472, 7, 6, 0, 0, 9472, 876, + 1, 0, 0, 0, 9473, 9474, 7, 9, 0, 0, 9474, 9475, 7, 10, 0, 0, 9475, 9476, + 7, 5, 0, 0, 9476, 9477, 7, 8, 0, 0, 9477, 9478, 7, 2, 0, 0, 9478, 9479, + 7, 7, 0, 0, 9479, 9480, 7, 7, 0, 0, 9480, 9481, 7, 6, 0, 0, 9481, 9482, + 7, 8, 0, 0, 9482, 9483, 7, 4, 0, 0, 9483, 878, 1, 0, 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, 880, 1, 0, 0, 0, 9489, 9490, 7, 9, 0, 0, 9490, 9491, + 7, 10, 0, 0, 9491, 9492, 7, 5, 0, 0, 9492, 9493, 7, 21, 0, 0, 9493, 9494, + 7, 17, 0, 0, 9494, 9495, 7, 3, 0, 0, 9495, 9496, 7, 2, 0, 0, 9496, 9497, + 7, 12, 0, 0, 9497, 9498, 7, 15, 0, 0, 9498, 882, 1, 0, 0, 0, 9499, 9500, + 5, 39, 0, 0, 9500, 9501, 5, 43, 0, 0, 9501, 9502, 5, 32, 0, 0, 9502, 9503, + 7, 9, 0, 0, 9503, 9504, 7, 10, 0, 0, 9504, 9505, 7, 5, 0, 0, 9505, 9506, + 7, 21, 0, 0, 9506, 9507, 7, 17, 0, 0, 9507, 9508, 7, 3, 0, 0, 9508, 9509, + 7, 2, 0, 0, 9509, 9510, 7, 12, 0, 0, 9510, 9511, 7, 15, 0, 0, 9511, 884, + 1, 0, 0, 0, 9512, 9513, 7, 9, 0, 0, 9513, 9514, 7, 10, 0, 0, 9514, 9515, + 7, 5, 0, 0, 9515, 9516, 7, 21, 0, 0, 9516, 9517, 7, 5, 0, 0, 9517, 886, + 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, 14, 0, 0, 9522, 9523, 7, 2, 0, 0, 9523, 9524, + 7, 12, 0, 0, 9524, 9525, 7, 7, 0, 0, 9525, 9526, 7, 4, 0, 0, 9526, 888, + 1, 0, 0, 0, 9527, 9528, 7, 9, 0, 0, 9528, 9529, 7, 10, 0, 0, 9529, 9530, + 7, 5, 0, 0, 9530, 9531, 7, 4, 0, 0, 9531, 9532, 7, 10, 0, 0, 9532, 9533, + 7, 7, 0, 0, 9533, 9534, 7, 8, 0, 0, 9534, 9535, 7, 4, 0, 0, 9535, 890, + 1, 0, 0, 0, 9536, 9537, 7, 9, 0, 0, 9537, 9538, 7, 10, 0, 0, 9538, 9539, + 7, 5, 0, 0, 9539, 9540, 7, 4, 0, 0, 9540, 9541, 7, 10, 0, 0, 9541, 9542, + 7, 7, 0, 0, 9542, 9543, 7, 17, 0, 0, 9543, 9544, 7, 12, 0, 0, 9544, 9545, + 7, 10, 0, 0, 9545, 9546, 7, 5, 0, 0, 9546, 9547, 7, 19, 0, 0, 9547, 9548, + 7, 6, 0, 0, 9548, 9549, 7, 9, 0, 0, 9549, 892, 1, 0, 0, 0, 9550, 9551, + 7, 9, 0, 0, 9551, 9552, 7, 10, 0, 0, 9552, 9553, 7, 5, 0, 0, 9553, 9554, + 7, 4, 0, 0, 9554, 9555, 7, 3, 0, 0, 9555, 9556, 7, 10, 0, 0, 9556, 9557, + 7, 1, 0, 0, 9557, 9558, 7, 12, 0, 0, 9558, 9559, 7, 4, 0, 0, 9559, 9560, + 7, 6, 0, 0, 9560, 9561, 7, 9, 0, 0, 9561, 894, 1, 0, 0, 0, 9562, 9563, + 7, 9, 0, 0, 9563, 9564, 7, 10, 0, 0, 9564, 9565, 7, 5, 0, 0, 9565, 9566, + 7, 4, 0, 0, 9566, 9567, 7, 3, 0, 0, 9567, 9568, 7, 10, 0, 0, 9568, 9569, + 7, 1, 0, 0, 9569, 9570, 7, 12, 0, 0, 9570, 9571, 7, 4, 0, 0, 9571, 9572, + 7, 6, 0, 0, 9572, 896, 1, 0, 0, 0, 9573, 9574, 7, 9, 0, 0, 9574, 9575, + 7, 14, 0, 0, 9575, 9576, 7, 11, 0, 0, 9576, 898, 1, 0, 0, 0, 9577, 9578, + 7, 9, 0, 0, 9578, 9579, 7, 14, 0, 0, 9579, 9580, 7, 11, 0, 0, 9580, 9581, + 5, 95, 0, 0, 9581, 9582, 7, 12, 0, 0, 9582, 9583, 7, 15, 0, 0, 9583, 9584, + 7, 9, 0, 0, 9584, 9585, 7, 0, 0, 0, 9585, 9586, 7, 4, 0, 0, 9586, 9587, + 7, 6, 0, 0, 9587, 900, 1, 0, 0, 0, 9588, 9589, 7, 9, 0, 0, 9589, 9590, + 7, 7, 0, 0, 9590, 9591, 7, 16, 0, 0, 9591, 9592, 7, 5, 0, 0, 9592, 9593, + 5, 95, 0, 0, 9593, 9594, 7, 9, 0, 0, 9594, 9595, 7, 10, 0, 0, 9595, 9596, + 7, 5, 0, 0, 9596, 9597, 7, 0, 0, 0, 9597, 9598, 7, 1, 0, 0, 9598, 9599, + 7, 11, 0, 0, 9599, 9600, 7, 6, 0, 0, 9600, 902, 1, 0, 0, 0, 9601, 9602, + 7, 9, 0, 0, 9602, 9603, 7, 7, 0, 0, 9603, 9604, 7, 16, 0, 0, 9604, 9605, + 7, 5, 0, 0, 9605, 9606, 5, 95, 0, 0, 9606, 9607, 7, 6, 0, 0, 9607, 9608, + 7, 7, 0, 0, 9608, 9609, 7, 0, 0, 0, 9609, 9610, 7, 1, 0, 0, 9610, 9611, + 7, 11, 0, 0, 9611, 9612, 7, 6, 0, 0, 9612, 904, 1, 0, 0, 0, 9613, 9614, + 7, 9, 0, 0, 9614, 9615, 7, 7, 0, 0, 9615, 9616, 7, 16, 0, 0, 9616, 9617, + 7, 5, 0, 0, 9617, 9618, 5, 95, 0, 0, 9618, 9619, 7, 3, 0, 0, 9619, 9620, + 7, 6, 0, 0, 9620, 9621, 7, 0, 0, 0, 9621, 9622, 7, 9, 0, 0, 9622, 9623, + 7, 1, 0, 0, 9623, 9624, 7, 12, 0, 0, 9624, 9625, 7, 16, 0, 0, 9625, 9626, + 7, 16, 0, 0, 9626, 9627, 7, 6, 0, 0, 9627, 9628, 7, 3, 0, 0, 9628, 9629, + 7, 5, 0, 0, 9629, 906, 1, 0, 0, 0, 9630, 9631, 7, 9, 0, 0, 9631, 9632, + 7, 2, 0, 0, 9632, 9633, 7, 8, 0, 0, 9633, 9634, 7, 16, 0, 0, 9634, 9635, + 7, 10, 0, 0, 9635, 9636, 7, 9, 0, 0, 9636, 9637, 7, 6, 0, 0, 9637, 9638, + 7, 11, 0, 0, 9638, 9639, 7, 10, 0, 0, 9639, 9640, 7, 4, 0, 0, 9640, 9641, + 7, 18, 0, 0, 9641, 908, 1, 0, 0, 0, 9642, 9643, 7, 9, 0, 0, 9643, 9644, + 7, 2, 0, 0, 9644, 9645, 7, 8, 0, 0, 9645, 9646, 7, 12, 0, 0, 9646, 9647, + 7, 14, 0, 0, 9647, 9648, 7, 6, 0, 0, 9648, 9649, 7, 7, 0, 0, 9649, 9650, + 7, 4, 0, 0, 9650, 910, 1, 0, 0, 0, 9651, 9652, 5, 36, 0, 0, 9652, 9653, + 7, 6, 0, 0, 9653, 9654, 7, 11, 0, 0, 9654, 9655, 7, 5, 0, 0, 9655, 9656, + 7, 6, 0, 0, 9656, 912, 1, 0, 0, 0, 9657, 9658, 5, 36, 0, 0, 9658, 9659, + 7, 6, 0, 0, 9659, 9660, 7, 11, 0, 0, 9660, 9661, 7, 5, 0, 0, 9661, 9662, + 7, 10, 0, 0, 9662, 9663, 7, 16, 0, 0, 9663, 914, 1, 0, 0, 0, 9664, 9665, + 5, 36, 0, 0, 9665, 9666, 7, 6, 0, 0, 9666, 9667, 7, 7, 0, 0, 9667, 9668, + 7, 9, 0, 0, 9668, 916, 1, 0, 0, 0, 9669, 9670, 5, 36, 0, 0, 9670, 9671, + 7, 6, 0, 0, 9671, 9672, 7, 3, 0, 0, 9672, 9673, 7, 3, 0, 0, 9673, 9674, + 7, 2, 0, 0, 9674, 9675, 7, 3, 0, 0, 9675, 918, 1, 0, 0, 0, 9676, 9677, + 5, 36, 0, 0, 9677, 9678, 7, 10, 0, 0, 9678, 9679, 7, 16, 0, 0, 9679, 920, + 1, 0, 0, 0, 9680, 9681, 5, 36, 0, 0, 9681, 9682, 7, 4, 0, 0, 9682, 9683, + 7, 19, 0, 0, 9683, 9684, 7, 6, 0, 0, 9684, 9685, 7, 7, 0, 0, 9685, 922, + 1, 0, 0, 0, 9686, 9687, 7, 9, 0, 0, 9687, 9688, 7, 2, 0, 0, 9688, 9689, + 7, 14, 0, 0, 9689, 9690, 7, 0, 0, 0, 9690, 9691, 7, 10, 0, 0, 9691, 9692, + 7, 7, 0, 0, 9692, 9693, 5, 95, 0, 0, 9693, 9694, 7, 10, 0, 0, 9694, 9695, + 7, 7, 0, 0, 9695, 9696, 7, 9, 0, 0, 9696, 9697, 7, 6, 0, 0, 9697, 9698, + 7, 25, 0, 0, 9698, 9699, 5, 95, 0, 0, 9699, 9700, 7, 16, 0, 0, 9700, 9701, + 7, 10, 0, 0, 9701, 9702, 7, 11, 0, 0, 9702, 9703, 7, 4, 0, 0, 9703, 9704, + 7, 6, 0, 0, 9704, 9705, 7, 3, 0, 0, 9705, 924, 1, 0, 0, 0, 9706, 9707, + 7, 9, 0, 0, 9707, 9708, 7, 2, 0, 0, 9708, 9709, 7, 14, 0, 0, 9709, 9710, + 7, 0, 0, 0, 9710, 9711, 7, 10, 0, 0, 9711, 9712, 7, 7, 0, 0, 9712, 9713, + 5, 95, 0, 0, 9713, 9714, 7, 10, 0, 0, 9714, 9715, 7, 7, 0, 0, 9715, 9716, + 7, 9, 0, 0, 9716, 9717, 7, 6, 0, 0, 9717, 9718, 7, 25, 0, 0, 9718, 9719, + 5, 95, 0, 0, 9719, 9720, 7, 7, 0, 0, 9720, 9721, 7, 2, 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, 926, 1, 0, 0, 0, 9727, 9728, + 7, 9, 0, 0, 9728, 9729, 7, 2, 0, 0, 9729, 9730, 7, 14, 0, 0, 9730, 9731, + 7, 0, 0, 0, 9731, 9732, 7, 10, 0, 0, 9732, 9733, 7, 7, 0, 0, 9733, 9734, + 5, 95, 0, 0, 9734, 9735, 7, 10, 0, 0, 9735, 9736, 7, 7, 0, 0, 9736, 9737, + 7, 9, 0, 0, 9737, 9738, 7, 6, 0, 0, 9738, 9739, 7, 25, 0, 0, 9739, 9740, + 5, 95, 0, 0, 9740, 9741, 7, 5, 0, 0, 9741, 9742, 7, 2, 0, 0, 9742, 9743, + 7, 3, 0, 0, 9743, 9744, 7, 4, 0, 0, 9744, 928, 1, 0, 0, 0, 9745, 9746, + 7, 9, 0, 0, 9746, 9747, 7, 2, 0, 0, 9747, 9748, 7, 12, 0, 0, 9748, 9749, + 7, 1, 0, 0, 9749, 9750, 7, 11, 0, 0, 9750, 9751, 7, 6, 0, 0, 9751, 930, + 1, 0, 0, 0, 9752, 9753, 7, 9, 0, 0, 9753, 9754, 7, 2, 0, 0, 9754, 9755, + 7, 22, 0, 0, 9755, 9756, 7, 7, 0, 0, 9756, 9757, 7, 17, 0, 0, 9757, 9758, + 7, 3, 0, 0, 9758, 9759, 7, 0, 0, 0, 9759, 9760, 7, 9, 0, 0, 9760, 9761, + 7, 6, 0, 0, 9761, 932, 1, 0, 0, 0, 9762, 9763, 7, 9, 0, 0, 9763, 9764, + 7, 3, 0, 0, 9764, 9765, 7, 10, 0, 0, 9765, 9766, 7, 13, 0, 0, 9766, 9767, + 7, 10, 0, 0, 9767, 9768, 7, 7, 0, 0, 9768, 9769, 7, 17, 0, 0, 9769, 9770, + 5, 95, 0, 0, 9770, 9771, 7, 5, 0, 0, 9771, 9772, 7, 10, 0, 0, 9772, 9773, + 7, 4, 0, 0, 9773, 9774, 7, 6, 0, 0, 9774, 934, 1, 0, 0, 0, 9775, 9776, + 7, 9, 0, 0, 9776, 9777, 7, 3, 0, 0, 9777, 9778, 7, 2, 0, 0, 9778, 9779, + 7, 15, 0, 0, 9779, 9780, 5, 95, 0, 0, 9780, 9781, 7, 8, 0, 0, 9781, 9782, + 7, 2, 0, 0, 9782, 9783, 7, 11, 0, 0, 9783, 9784, 7, 12, 0, 0, 9784, 9785, + 7, 14, 0, 0, 9785, 9786, 7, 7, 0, 0, 9786, 936, 1, 0, 0, 0, 9787, 9788, + 7, 9, 0, 0, 9788, 9789, 7, 3, 0, 0, 9789, 9790, 7, 2, 0, 0, 9790, 9791, + 7, 15, 0, 0, 9791, 938, 1, 0, 0, 0, 9792, 9793, 7, 9, 0, 0, 9793, 9794, + 7, 3, 0, 0, 9794, 9795, 7, 2, 0, 0, 9795, 9796, 7, 15, 0, 0, 9796, 9797, + 5, 95, 0, 0, 9797, 9798, 7, 17, 0, 0, 9798, 9799, 7, 3, 0, 0, 9799, 9800, + 7, 2, 0, 0, 9800, 9801, 7, 12, 0, 0, 9801, 9802, 7, 15, 0, 0, 9802, 940, + 1, 0, 0, 0, 9803, 9804, 7, 9, 0, 0, 9804, 9805, 7, 5, 0, 0, 9805, 9806, + 7, 10, 0, 0, 9806, 9807, 7, 7, 0, 0, 9807, 9808, 7, 4, 0, 0, 9808, 9809, + 7, 6, 0, 0, 9809, 9810, 7, 3, 0, 0, 9810, 9811, 7, 13, 0, 0, 9811, 9812, + 7, 0, 0, 0, 9812, 9813, 7, 11, 0, 0, 9813, 9814, 5, 95, 0, 0, 9814, 9815, + 7, 12, 0, 0, 9815, 9816, 7, 7, 0, 0, 9816, 9817, 7, 8, 0, 0, 9817, 9818, + 7, 2, 0, 0, 9818, 9819, 7, 7, 0, 0, 9819, 9820, 7, 5, 0, 0, 9820, 9821, + 7, 4, 0, 0, 9821, 9822, 7, 3, 0, 0, 9822, 9823, 7, 0, 0, 0, 9823, 9824, + 7, 10, 0, 0, 9824, 9825, 7, 7, 0, 0, 9825, 9826, 7, 6, 0, 0, 9826, 9827, + 7, 9, 0, 0, 9827, 942, 1, 0, 0, 0, 9828, 9829, 7, 9, 0, 0, 9829, 9830, + 7, 5, 0, 0, 9830, 9831, 7, 4, 0, 0, 9831, 9832, 5, 95, 0, 0, 9832, 9833, + 7, 12, 0, 0, 9833, 9834, 7, 15, 0, 0, 9834, 9835, 7, 17, 0, 0, 9835, 9836, + 7, 3, 0, 0, 9836, 9837, 7, 0, 0, 0, 9837, 9838, 7, 9, 0, 0, 9838, 9839, + 7, 6, 0, 0, 9839, 9840, 5, 95, 0, 0, 9840, 9841, 7, 10, 0, 0, 9841, 9842, + 7, 7, 0, 0, 9842, 9843, 7, 5, 0, 0, 9843, 9844, 7, 6, 0, 0, 9844, 9845, + 7, 3, 0, 0, 9845, 9846, 7, 4, 0, 0, 9846, 9847, 5, 95, 0, 0, 9847, 9848, + 7, 8, 0, 0, 9848, 9849, 7, 2, 0, 0, 9849, 9850, 7, 7, 0, 0, 9850, 9851, + 7, 13, 0, 0, 9851, 944, 1, 0, 0, 0, 9852, 9853, 7, 9, 0, 0, 9853, 9854, + 7, 12, 0, 0, 9854, 9855, 7, 14, 0, 0, 9855, 9856, 7, 15, 0, 0, 9856, 946, + 1, 0, 0, 0, 9857, 9858, 7, 9, 0, 0, 9858, 9859, 7, 12, 0, 0, 9859, 9860, + 7, 14, 0, 0, 9860, 9861, 7, 15, 0, 0, 9861, 9862, 7, 5, 0, 0, 9862, 9863, + 7, 6, 0, 0, 9863, 9864, 7, 4, 0, 0, 9864, 948, 1, 0, 0, 0, 9865, 9866, + 7, 9, 0, 0, 9866, 9867, 7, 12, 0, 0, 9867, 9868, 7, 15, 0, 0, 9868, 9869, + 7, 11, 0, 0, 9869, 9870, 7, 10, 0, 0, 9870, 9871, 7, 8, 0, 0, 9871, 9872, + 7, 0, 0, 0, 9872, 9873, 7, 4, 0, 0, 9873, 9874, 7, 6, 0, 0, 9874, 950, + 1, 0, 0, 0, 9875, 9876, 7, 9, 0, 0, 9876, 9877, 7, 13, 0, 0, 9877, 952, + 1, 0, 0, 0, 9878, 9879, 7, 9, 0, 0, 9879, 9880, 7, 18, 0, 0, 9880, 9881, + 7, 7, 0, 0, 9881, 9882, 7, 0, 0, 0, 9882, 9883, 7, 14, 0, 0, 9883, 9884, + 7, 10, 0, 0, 9884, 9885, 7, 8, 0, 0, 9885, 954, 1, 0, 0, 0, 9886, 9887, + 7, 9, 0, 0, 9887, 9888, 7, 18, 0, 0, 9888, 9889, 7, 7, 0, 0, 9889, 9890, + 7, 0, 0, 0, 9890, 9891, 7, 14, 0, 0, 9891, 9892, 7, 10, 0, 0, 9892, 9893, + 7, 8, 0, 0, 9893, 9894, 5, 95, 0, 0, 9894, 9895, 7, 5, 0, 0, 9895, 9896, + 7, 0, 0, 0, 9896, 9897, 7, 14, 0, 0, 9897, 9898, 7, 15, 0, 0, 9898, 9899, + 7, 11, 0, 0, 9899, 9900, 7, 10, 0, 0, 9900, 9901, 7, 7, 0, 0, 9901, 9902, + 7, 17, 0, 0, 9902, 956, 1, 0, 0, 0, 9903, 9904, 7, 9, 0, 0, 9904, 9905, + 7, 18, 0, 0, 9905, 9906, 7, 7, 0, 0, 9906, 9907, 7, 0, 0, 0, 9907, 9908, + 7, 14, 0, 0, 9908, 9909, 7, 10, 0, 0, 9909, 9910, 7, 8, 0, 0, 9910, 9911, + 5, 95, 0, 0, 9911, 9912, 7, 5, 0, 0, 9912, 9913, 7, 0, 0, 0, 9913, 9914, + 7, 14, 0, 0, 9914, 9915, 7, 15, 0, 0, 9915, 9916, 7, 11, 0, 0, 9916, 9917, + 7, 10, 0, 0, 9917, 9918, 7, 7, 0, 0, 9918, 9919, 7, 17, 0, 0, 9919, 9920, + 5, 95, 0, 0, 9920, 9921, 7, 6, 0, 0, 9921, 9922, 7, 5, 0, 0, 9922, 9923, + 7, 4, 0, 0, 9923, 9924, 5, 95, 0, 0, 9924, 9925, 7, 8, 0, 0, 9925, 9926, + 7, 9, 0, 0, 9926, 9927, 7, 7, 0, 0, 9927, 958, 1, 0, 0, 0, 9928, 9929, + 7, 6, 0, 0, 9929, 960, 1, 0, 0, 0, 9930, 9931, 7, 6, 0, 0, 9931, 9932, + 7, 0, 0, 0, 9932, 9933, 7, 8, 0, 0, 9933, 9934, 7, 19, 0, 0, 9934, 962, + 1, 0, 0, 0, 9935, 9936, 7, 6, 0, 0, 9936, 9937, 7, 9, 0, 0, 9937, 9938, + 7, 10, 0, 0, 9938, 9939, 7, 4, 0, 0, 9939, 9940, 7, 10, 0, 0, 9940, 9941, + 7, 2, 0, 0, 9941, 9942, 7, 7, 0, 0, 9942, 9943, 7, 0, 0, 0, 9943, 9944, + 7, 1, 0, 0, 9944, 9945, 7, 11, 0, 0, 9945, 9946, 7, 6, 0, 0, 9946, 964, + 1, 0, 0, 0, 9947, 9948, 7, 6, 0, 0, 9948, 9949, 7, 9, 0, 0, 9949, 9950, + 7, 10, 0, 0, 9950, 9951, 7, 4, 0, 0, 9951, 9952, 7, 10, 0, 0, 9952, 9953, + 7, 2, 0, 0, 9953, 9954, 7, 7, 0, 0, 9954, 966, 1, 0, 0, 0, 9955, 9956, + 7, 6, 0, 0, 9956, 9957, 7, 9, 0, 0, 9957, 9958, 7, 10, 0, 0, 9958, 9959, + 7, 4, 0, 0, 9959, 9960, 7, 10, 0, 0, 9960, 9961, 7, 2, 0, 0, 9961, 9962, + 7, 7, 0, 0, 9962, 9963, 7, 10, 0, 0, 9963, 9964, 7, 7, 0, 0, 9964, 9965, + 7, 17, 0, 0, 9965, 968, 1, 0, 0, 0, 9966, 9967, 7, 6, 0, 0, 9967, 9968, + 7, 9, 0, 0, 9968, 9969, 7, 10, 0, 0, 9969, 9970, 7, 4, 0, 0, 9970, 9971, + 7, 10, 0, 0, 9971, 9972, 7, 2, 0, 0, 9972, 9973, 7, 7, 0, 0, 9973, 9974, + 7, 5, 0, 0, 9974, 970, 1, 0, 0, 0, 9975, 9976, 7, 6, 0, 0, 9976, 9977, + 7, 11, 0, 0, 9977, 9978, 7, 6, 0, 0, 9978, 9979, 7, 14, 0, 0, 9979, 9980, + 7, 6, 0, 0, 9980, 9981, 7, 7, 0, 0, 9981, 9982, 7, 4, 0, 0, 9982, 972, + 1, 0, 0, 0, 9983, 9984, 7, 6, 0, 0, 9984, 9985, 7, 11, 0, 0, 9985, 9986, + 7, 10, 0, 0, 9986, 9987, 7, 14, 0, 0, 9987, 9988, 5, 95, 0, 0, 9988, 9989, + 7, 17, 0, 0, 9989, 9990, 7, 3, 0, 0, 9990, 9991, 7, 2, 0, 0, 9991, 9992, + 7, 12, 0, 0, 9992, 9993, 7, 15, 0, 0, 9993, 9994, 7, 1, 0, 0, 9994, 9995, + 7, 18, 0, 0, 9995, 974, 1, 0, 0, 0, 9996, 9997, 7, 6, 0, 0, 9997, 9998, + 7, 11, 0, 0, 9998, 9999, 7, 10, 0, 0, 9999, 10000, 7, 14, 0, 0, 10000, + 10001, 7, 10, 0, 0, 10001, 10002, 7, 7, 0, 0, 10002, 10003, 7, 0, 0, 0, + 10003, 10004, 7, 4, 0, 0, 10004, 10005, 7, 6, 0, 0, 10005, 10006, 5, 95, + 0, 0, 10006, 10007, 7, 20, 0, 0, 10007, 10008, 7, 2, 0, 0, 10008, 10009, + 7, 10, 0, 0, 10009, 10010, 7, 7, 0, 0, 10010, 976, 1, 0, 0, 0, 10011, 10012, + 7, 6, 0, 0, 10012, 10013, 7, 11, 0, 0, 10013, 10014, 7, 10, 0, 0, 10014, + 10015, 7, 14, 0, 0, 10015, 10016, 7, 10, 0, 0, 10016, 10017, 7, 7, 0, 0, + 10017, 10018, 7, 0, 0, 0, 10018, 10019, 7, 4, 0, 0, 10019, 10020, 7, 6, + 0, 0, 10020, 10021, 5, 95, 0, 0, 10021, 10022, 7, 2, 0, 0, 10022, 10023, + 7, 1, 0, 0, 10023, 10024, 7, 18, 0, 0, 10024, 978, 1, 0, 0, 0, 10025, 10026, + 7, 6, 0, 0, 10026, 10027, 7, 11, 0, 0, 10027, 10028, 7, 10, 0, 0, 10028, + 10029, 7, 14, 0, 0, 10029, 10030, 7, 10, 0, 0, 10030, 10031, 7, 7, 0, 0, + 10031, 10032, 7, 0, 0, 0, 10032, 10033, 7, 4, 0, 0, 10033, 10034, 7, 6, + 0, 0, 10034, 10035, 5, 95, 0, 0, 10035, 10036, 7, 2, 0, 0, 10036, 10037, + 7, 12, 0, 0, 10037, 10038, 7, 4, 0, 0, 10038, 10039, 7, 6, 0, 0, 10039, + 10040, 7, 3, 0, 0, 10040, 10041, 5, 95, 0, 0, 10041, 10042, 7, 20, 0, 0, + 10042, 10043, 7, 2, 0, 0, 10043, 10044, 7, 10, 0, 0, 10044, 10045, 7, 7, + 0, 0, 10045, 980, 1, 0, 0, 0, 10046, 10047, 7, 6, 0, 0, 10047, 10048, 7, + 11, 0, 0, 10048, 10049, 7, 5, 0, 0, 10049, 10050, 7, 6, 0, 0, 10050, 982, + 1, 0, 0, 0, 10051, 10052, 7, 6, 0, 0, 10052, 10053, 7, 11, 0, 0, 10053, + 10054, 7, 5, 0, 0, 10054, 10055, 7, 10, 0, 0, 10055, 10056, 7, 16, 0, 0, + 10056, 984, 1, 0, 0, 0, 10057, 10058, 7, 6, 0, 0, 10058, 10059, 7, 14, + 0, 0, 10059, 986, 1, 0, 0, 0, 10060, 10061, 7, 6, 0, 0, 10061, 10062, 7, + 14, 0, 0, 10062, 10063, 7, 1, 0, 0, 10063, 10064, 7, 6, 0, 0, 10064, 10065, + 7, 9, 0, 0, 10065, 10066, 7, 9, 0, 0, 10066, 10067, 7, 6, 0, 0, 10067, + 10068, 7, 9, 0, 0, 10068, 988, 1, 0, 0, 0, 10069, 10070, 7, 6, 0, 0, 10070, + 10071, 7, 14, 0, 0, 10071, 10072, 7, 15, 0, 0, 10072, 10073, 7, 4, 0, 0, + 10073, 10074, 7, 18, 0, 0, 10074, 10075, 5, 95, 0, 0, 10075, 10076, 7, + 1, 0, 0, 10076, 10077, 7, 11, 0, 0, 10077, 10078, 7, 2, 0, 0, 10078, 10079, + 7, 1, 0, 0, 10079, 990, 1, 0, 0, 0, 10080, 10081, 7, 6, 0, 0, 10081, 10082, + 7, 14, 0, 0, 10082, 10083, 7, 15, 0, 0, 10083, 10084, 7, 4, 0, 0, 10084, + 10085, 7, 18, 0, 0, 10085, 10086, 5, 95, 0, 0, 10086, 10087, 7, 8, 0, 0, + 10087, 10088, 7, 11, 0, 0, 10088, 10089, 7, 2, 0, 0, 10089, 10090, 7, 1, + 0, 0, 10090, 992, 1, 0, 0, 0, 10091, 10092, 7, 6, 0, 0, 10092, 10093, 7, + 14, 0, 0, 10093, 10094, 7, 15, 0, 0, 10094, 10095, 7, 4, 0, 0, 10095, 10096, + 7, 18, 0, 0, 10096, 994, 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, 5, 95, 0, 0, + 10104, 10105, 7, 0, 0, 0, 10105, 10106, 7, 11, 0, 0, 10106, 10107, 7, 11, + 0, 0, 10107, 996, 1, 0, 0, 0, 10108, 10109, 7, 6, 0, 0, 10109, 10110, 7, + 7, 0, 0, 10110, 10111, 7, 0, 0, 0, 10111, 10112, 7, 1, 0, 0, 10112, 10113, + 7, 11, 0, 0, 10113, 10114, 7, 6, 0, 0, 10114, 998, 1, 0, 0, 0, 10115, 10116, + 7, 6, 0, 0, 10116, 10117, 7, 7, 0, 0, 10117, 10118, 7, 0, 0, 0, 10118, + 10119, 7, 1, 0, 0, 10119, 10120, 7, 11, 0, 0, 10120, 10121, 7, 6, 0, 0, + 10121, 10122, 7, 9, 0, 0, 10122, 1000, 1, 0, 0, 0, 10123, 10124, 7, 6, + 0, 0, 10124, 10125, 7, 7, 0, 0, 10125, 10126, 7, 0, 0, 0, 10126, 10127, + 7, 1, 0, 0, 10127, 10128, 7, 11, 0, 0, 10128, 10129, 7, 6, 0, 0, 10129, + 10130, 5, 95, 0, 0, 10130, 10131, 7, 15, 0, 0, 10131, 10132, 7, 0, 0, 0, + 10132, 10133, 7, 3, 0, 0, 10133, 10134, 7, 0, 0, 0, 10134, 10135, 7, 11, + 0, 0, 10135, 10136, 7, 11, 0, 0, 10136, 10137, 7, 6, 0, 0, 10137, 10138, + 7, 11, 0, 0, 10138, 10139, 5, 95, 0, 0, 10139, 10140, 7, 9, 0, 0, 10140, + 10141, 7, 14, 0, 0, 10141, 10142, 7, 11, 0, 0, 10142, 1002, 1, 0, 0, 0, + 10143, 10144, 7, 6, 0, 0, 10144, 10145, 7, 7, 0, 0, 10145, 10146, 7, 0, + 0, 0, 10146, 10147, 7, 1, 0, 0, 10147, 10148, 7, 11, 0, 0, 10148, 10149, + 7, 6, 0, 0, 10149, 10150, 5, 95, 0, 0, 10150, 10151, 7, 15, 0, 0, 10151, + 10152, 7, 3, 0, 0, 10152, 10153, 7, 6, 0, 0, 10153, 10154, 7, 5, 0, 0, + 10154, 10155, 7, 6, 0, 0, 10155, 10156, 7, 4, 0, 0, 10156, 1004, 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, 11, 0, 0, 10161, 10162, 7, 2, 0, 0, 10162, + 10163, 7, 5, 0, 0, 10163, 10164, 7, 6, 0, 0, 10164, 10165, 7, 9, 0, 0, + 10165, 1006, 1, 0, 0, 0, 10166, 10167, 7, 6, 0, 0, 10167, 10168, 7, 7, + 0, 0, 10168, 10169, 7, 8, 0, 0, 10169, 10170, 7, 2, 0, 0, 10170, 10171, + 7, 9, 0, 0, 10171, 10172, 7, 10, 0, 0, 10172, 10173, 7, 7, 0, 0, 10173, + 10174, 7, 17, 0, 0, 10174, 1008, 1, 0, 0, 0, 10175, 10176, 7, 6, 0, 0, + 10176, 10177, 7, 7, 0, 0, 10177, 10178, 7, 8, 0, 0, 10178, 10179, 7, 3, + 0, 0, 10179, 10180, 7, 18, 0, 0, 10180, 10181, 7, 15, 0, 0, 10181, 10182, + 7, 4, 0, 0, 10182, 1010, 1, 0, 0, 0, 10183, 10184, 7, 6, 0, 0, 10184, 10185, + 7, 7, 0, 0, 10185, 10186, 7, 8, 0, 0, 10186, 10187, 7, 3, 0, 0, 10187, + 10188, 7, 18, 0, 0, 10188, 10189, 7, 15, 0, 0, 10189, 10190, 7, 4, 0, 0, + 10190, 10191, 7, 10, 0, 0, 10191, 10192, 7, 2, 0, 0, 10192, 10193, 7, 7, + 0, 0, 10193, 1012, 1, 0, 0, 0, 10194, 10195, 7, 6, 0, 0, 10195, 10196, + 7, 7, 0, 0, 10196, 10197, 7, 8, 0, 0, 10197, 10198, 7, 3, 0, 0, 10198, + 10199, 7, 18, 0, 0, 10199, 10200, 7, 15, 0, 0, 10200, 10201, 7, 4, 0, 0, + 10201, 10202, 7, 15, 0, 0, 10202, 10203, 7, 0, 0, 0, 10203, 10204, 7, 5, + 0, 0, 10204, 10205, 7, 5, 0, 0, 10205, 10206, 7, 22, 0, 0, 10206, 10207, + 7, 2, 0, 0, 10207, 10208, 7, 3, 0, 0, 10208, 10209, 7, 9, 0, 0, 10209, + 10210, 7, 10, 0, 0, 10210, 10211, 7, 5, 0, 0, 10211, 10212, 7, 7, 0, 0, + 10212, 10213, 7, 12, 0, 0, 10213, 10214, 7, 11, 0, 0, 10214, 10215, 7, + 11, 0, 0, 10215, 1014, 1, 0, 0, 0, 10216, 10217, 7, 6, 0, 0, 10217, 10218, + 7, 7, 0, 0, 10218, 10219, 7, 9, 0, 0, 10219, 1016, 1, 0, 0, 0, 10220, 10221, + 7, 6, 0, 0, 10221, 10222, 7, 7, 0, 0, 10222, 10223, 7, 9, 0, 0, 10223, + 10224, 5, 95, 0, 0, 10224, 10225, 7, 2, 0, 0, 10225, 10226, 7, 12, 0, 0, + 10226, 10227, 7, 4, 0, 0, 10227, 10228, 7, 11, 0, 0, 10228, 10229, 7, 10, + 0, 0, 10229, 10230, 7, 7, 0, 0, 10230, 10231, 7, 6, 0, 0, 10231, 10232, + 5, 95, 0, 0, 10232, 10233, 7, 9, 0, 0, 10233, 10234, 7, 0, 0, 0, 10234, + 10235, 7, 4, 0, 0, 10235, 10236, 7, 0, 0, 0, 10236, 1018, 1, 0, 0, 0, 10237, + 10238, 7, 6, 0, 0, 10238, 10239, 7, 7, 0, 0, 10239, 10240, 7, 9, 0, 0, + 10240, 10241, 7, 10, 0, 0, 10241, 10242, 7, 0, 0, 0, 10242, 10243, 7, 7, + 0, 0, 10243, 1020, 1, 0, 0, 0, 10244, 10245, 7, 6, 0, 0, 10245, 10246, + 7, 7, 0, 0, 10246, 10247, 7, 16, 0, 0, 10247, 10248, 7, 2, 0, 0, 10248, + 10249, 7, 3, 0, 0, 10249, 10250, 7, 8, 0, 0, 10250, 10251, 7, 6, 0, 0, + 10251, 10252, 7, 9, 0, 0, 10252, 1022, 1, 0, 0, 0, 10253, 10254, 7, 6, + 0, 0, 10254, 10255, 7, 7, 0, 0, 10255, 10256, 7, 16, 0, 0, 10256, 10257, + 7, 2, 0, 0, 10257, 10258, 7, 3, 0, 0, 10258, 10259, 7, 8, 0, 0, 10259, + 10260, 7, 6, 0, 0, 10260, 1024, 1, 0, 0, 0, 10261, 10262, 7, 6, 0, 0, 10262, + 10263, 7, 7, 0, 0, 10263, 10264, 7, 24, 0, 0, 10264, 10265, 7, 12, 0, 0, + 10265, 10266, 7, 6, 0, 0, 10266, 10267, 7, 12, 0, 0, 10267, 10268, 7, 6, + 0, 0, 10268, 1026, 1, 0, 0, 0, 10269, 10270, 7, 6, 0, 0, 10270, 10271, + 7, 7, 0, 0, 10271, 10272, 7, 4, 0, 0, 10272, 10273, 7, 6, 0, 0, 10273, + 10274, 7, 3, 0, 0, 10274, 10275, 7, 15, 0, 0, 10275, 10276, 7, 3, 0, 0, + 10276, 10277, 7, 10, 0, 0, 10277, 10278, 7, 5, 0, 0, 10278, 10279, 7, 6, + 0, 0, 10279, 1028, 1, 0, 0, 0, 10280, 10281, 7, 6, 0, 0, 10281, 10282, + 7, 7, 0, 0, 10282, 10283, 7, 4, 0, 0, 10283, 10284, 7, 10, 0, 0, 10284, + 10285, 7, 4, 0, 0, 10285, 10286, 7, 18, 0, 0, 10286, 10287, 7, 6, 0, 0, + 10287, 10288, 7, 5, 0, 0, 10288, 10289, 7, 8, 0, 0, 10289, 10290, 7, 0, + 0, 0, 10290, 10291, 7, 15, 0, 0, 10291, 10292, 7, 10, 0, 0, 10292, 10293, + 7, 7, 0, 0, 10293, 10294, 7, 17, 0, 0, 10294, 1030, 1, 0, 0, 0, 10295, + 10296, 7, 6, 0, 0, 10296, 10297, 7, 7, 0, 0, 10297, 10298, 7, 4, 0, 0, + 10298, 10299, 7, 3, 0, 0, 10299, 10300, 7, 18, 0, 0, 10300, 1032, 1, 0, + 0, 0, 10301, 10302, 7, 6, 0, 0, 10302, 10303, 7, 24, 0, 0, 10303, 10304, + 7, 12, 0, 0, 10304, 10305, 7, 10, 0, 0, 10305, 10306, 7, 15, 0, 0, 10306, + 10307, 7, 0, 0, 0, 10307, 10308, 7, 3, 0, 0, 10308, 10309, 7, 4, 0, 0, + 10309, 1034, 1, 0, 0, 0, 10310, 10311, 7, 6, 0, 0, 10311, 10312, 7, 3, + 0, 0, 10312, 10313, 7, 3, 0, 0, 10313, 1036, 1, 0, 0, 0, 10314, 10315, + 7, 6, 0, 0, 10315, 10316, 7, 3, 0, 0, 10316, 10317, 7, 3, 0, 0, 10317, + 10318, 7, 2, 0, 0, 10318, 10319, 7, 3, 0, 0, 10319, 10320, 5, 95, 0, 0, + 10320, 10321, 7, 0, 0, 0, 10321, 10322, 7, 3, 0, 0, 10322, 10323, 7, 17, + 0, 0, 10323, 10324, 7, 12, 0, 0, 10324, 10325, 7, 14, 0, 0, 10325, 10326, + 7, 6, 0, 0, 10326, 10327, 7, 7, 0, 0, 10327, 10328, 7, 4, 0, 0, 10328, + 1038, 1, 0, 0, 0, 10329, 10330, 7, 6, 0, 0, 10330, 10331, 7, 3, 0, 0, 10331, + 10332, 7, 3, 0, 0, 10332, 10333, 7, 2, 0, 0, 10333, 10334, 7, 3, 0, 0, + 10334, 1040, 1, 0, 0, 0, 10335, 10336, 7, 6, 0, 0, 10336, 10337, 7, 3, + 0, 0, 10337, 10338, 7, 3, 0, 0, 10338, 10339, 7, 2, 0, 0, 10339, 10340, + 7, 3, 0, 0, 10340, 10341, 5, 95, 0, 0, 10341, 10342, 7, 2, 0, 0, 10342, + 10343, 7, 7, 0, 0, 10343, 10344, 5, 95, 0, 0, 10344, 10345, 7, 2, 0, 0, + 10345, 10346, 7, 13, 0, 0, 10346, 10347, 7, 6, 0, 0, 10347, 10348, 7, 3, + 0, 0, 10348, 10349, 7, 11, 0, 0, 10349, 10350, 7, 0, 0, 0, 10350, 10351, + 7, 15, 0, 0, 10351, 10352, 5, 95, 0, 0, 10352, 10353, 7, 4, 0, 0, 10353, + 10354, 7, 10, 0, 0, 10354, 10355, 7, 14, 0, 0, 10355, 10356, 7, 6, 0, 0, + 10356, 1042, 1, 0, 0, 0, 10357, 10358, 7, 6, 0, 0, 10358, 10359, 7, 3, + 0, 0, 10359, 10360, 7, 3, 0, 0, 10360, 10361, 7, 2, 0, 0, 10361, 10362, + 7, 3, 0, 0, 10362, 10363, 7, 5, 0, 0, 10363, 1044, 1, 0, 0, 0, 10364, 10365, + 7, 6, 0, 0, 10365, 10366, 7, 3, 0, 0, 10366, 10367, 7, 3, 0, 0, 10367, + 10368, 7, 2, 0, 0, 10368, 10369, 7, 3, 0, 0, 10369, 10370, 5, 95, 0, 0, + 10370, 10371, 7, 10, 0, 0, 10371, 10372, 7, 7, 0, 0, 10372, 10373, 7, 9, + 0, 0, 10373, 10374, 7, 6, 0, 0, 10374, 10375, 7, 25, 0, 0, 10375, 1046, + 1, 0, 0, 0, 10376, 10377, 7, 6, 0, 0, 10377, 10378, 7, 3, 0, 0, 10378, + 10379, 7, 3, 0, 0, 10379, 10380, 7, 2, 0, 0, 10380, 10381, 7, 3, 0, 0, + 10381, 10382, 5, 95, 0, 0, 10382, 10383, 7, 8, 0, 0, 10383, 10384, 7, 2, + 0, 0, 10384, 10385, 7, 9, 0, 0, 10385, 10386, 7, 6, 0, 0, 10386, 1048, + 1, 0, 0, 0, 10387, 10388, 7, 6, 0, 0, 10388, 10389, 7, 5, 0, 0, 10389, + 10390, 7, 8, 0, 0, 10390, 10391, 7, 0, 0, 0, 10391, 10392, 7, 15, 0, 0, + 10392, 10393, 7, 6, 0, 0, 10393, 1050, 1, 0, 0, 0, 10394, 10395, 7, 6, + 0, 0, 10395, 10396, 7, 5, 0, 0, 10396, 10397, 7, 8, 0, 0, 10397, 10398, + 7, 0, 0, 0, 10398, 10399, 7, 15, 0, 0, 10399, 10400, 7, 6, 0, 0, 10400, + 10401, 7, 9, 0, 0, 10401, 1052, 1, 0, 0, 0, 10402, 10403, 7, 6, 0, 0, 10403, + 10404, 7, 5, 0, 0, 10404, 10405, 7, 4, 0, 0, 10405, 10406, 7, 10, 0, 0, + 10406, 10407, 7, 14, 0, 0, 10407, 10408, 7, 0, 0, 0, 10408, 10409, 7, 4, + 0, 0, 10409, 10410, 7, 6, 0, 0, 10410, 1054, 1, 0, 0, 0, 10411, 10412, + 7, 6, 0, 0, 10412, 10413, 7, 13, 0, 0, 10413, 10414, 7, 0, 0, 0, 10414, + 10415, 7, 11, 0, 0, 10415, 1056, 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, 7, 0, 0, 10421, 10422, 7, 0, 0, 0, 10422, 10423, + 7, 14, 0, 0, 10423, 10424, 7, 6, 0, 0, 10424, 1058, 1, 0, 0, 0, 10425, + 10426, 7, 6, 0, 0, 10426, 10427, 7, 13, 0, 0, 10427, 10428, 7, 0, 0, 0, + 10428, 10429, 7, 11, 0, 0, 10429, 10430, 7, 12, 0, 0, 10430, 10431, 7, + 0, 0, 0, 10431, 10432, 7, 4, 0, 0, 10432, 10433, 7, 6, 0, 0, 10433, 1060, + 1, 0, 0, 0, 10434, 10435, 7, 6, 0, 0, 10435, 10436, 7, 13, 0, 0, 10436, + 10437, 7, 0, 0, 0, 10437, 10438, 7, 11, 0, 0, 10438, 10439, 7, 12, 0, 0, + 10439, 10440, 7, 0, 0, 0, 10440, 10441, 7, 4, 0, 0, 10441, 10442, 7, 10, + 0, 0, 10442, 10443, 7, 2, 0, 0, 10443, 10444, 7, 7, 0, 0, 10444, 1062, + 1, 0, 0, 0, 10445, 10446, 7, 6, 0, 0, 10446, 10447, 7, 13, 0, 0, 10447, + 10448, 7, 6, 0, 0, 10448, 10449, 7, 7, 0, 0, 10449, 10450, 7, 4, 0, 0, + 10450, 10451, 7, 5, 0, 0, 10451, 1064, 1, 0, 0, 0, 10452, 10453, 7, 6, + 0, 0, 10453, 10454, 7, 13, 0, 0, 10454, 10455, 7, 6, 0, 0, 10455, 10456, + 7, 3, 0, 0, 10456, 10457, 7, 18, 0, 0, 10457, 1066, 1, 0, 0, 0, 10458, + 10459, 7, 6, 0, 0, 10459, 10460, 7, 25, 0, 0, 10460, 10461, 7, 8, 0, 0, + 10461, 10462, 7, 6, 0, 0, 10462, 10463, 7, 15, 0, 0, 10463, 10464, 7, 4, + 0, 0, 10464, 1068, 1, 0, 0, 0, 10465, 10466, 7, 6, 0, 0, 10466, 10467, + 7, 25, 0, 0, 10467, 10468, 7, 8, 0, 0, 10468, 10469, 7, 6, 0, 0, 10469, + 10470, 7, 15, 0, 0, 10470, 10471, 7, 4, 0, 0, 10471, 10472, 7, 10, 0, 0, + 10472, 10473, 7, 2, 0, 0, 10473, 10474, 7, 7, 0, 0, 10474, 1070, 1, 0, + 0, 0, 10475, 10476, 7, 6, 0, 0, 10476, 10477, 7, 25, 0, 0, 10477, 10478, + 7, 8, 0, 0, 10478, 10479, 7, 6, 0, 0, 10479, 10480, 7, 15, 0, 0, 10480, + 10481, 7, 4, 0, 0, 10481, 10482, 7, 10, 0, 0, 10482, 10483, 7, 2, 0, 0, + 10483, 10484, 7, 7, 0, 0, 10484, 10485, 5, 95, 0, 0, 10485, 10486, 7, 10, + 0, 0, 10486, 10487, 7, 7, 0, 0, 10487, 10488, 7, 10, 0, 0, 10488, 10489, + 7, 4, 0, 0, 10489, 1072, 1, 0, 0, 0, 10490, 10491, 7, 6, 0, 0, 10491, 10492, + 7, 25, 0, 0, 10492, 10493, 7, 8, 0, 0, 10493, 10494, 7, 6, 0, 0, 10494, + 10495, 7, 15, 0, 0, 10495, 10496, 7, 4, 0, 0, 10496, 10497, 7, 10, 0, 0, + 10497, 10498, 7, 2, 0, 0, 10498, 10499, 7, 7, 0, 0, 10499, 10500, 7, 5, + 0, 0, 10500, 1074, 1, 0, 0, 0, 10501, 10502, 7, 6, 0, 0, 10502, 10503, + 7, 25, 0, 0, 10503, 10504, 7, 8, 0, 0, 10504, 10505, 7, 19, 0, 0, 10505, + 10506, 7, 0, 0, 0, 10506, 10507, 7, 7, 0, 0, 10507, 10508, 7, 17, 0, 0, + 10508, 10509, 7, 6, 0, 0, 10509, 1076, 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, 9, 0, 0, 10516, + 10517, 7, 6, 0, 0, 10517, 1078, 1, 0, 0, 0, 10518, 10519, 7, 6, 0, 0, 10519, + 10520, 7, 25, 0, 0, 10520, 10521, 7, 8, 0, 0, 10521, 10522, 7, 11, 0, 0, + 10522, 10523, 7, 12, 0, 0, 10523, 10524, 7, 9, 0, 0, 10524, 10525, 7, 10, + 0, 0, 10525, 10526, 7, 7, 0, 0, 10526, 10527, 7, 17, 0, 0, 10527, 1080, + 1, 0, 0, 0, 10528, 10529, 7, 6, 0, 0, 10529, 10530, 7, 25, 0, 0, 10530, + 10531, 7, 8, 0, 0, 10531, 10532, 7, 11, 0, 0, 10532, 10533, 7, 12, 0, 0, + 10533, 10534, 7, 5, 0, 0, 10534, 10535, 7, 10, 0, 0, 10535, 10536, 7, 13, + 0, 0, 10536, 10537, 7, 6, 0, 0, 10537, 1082, 1, 0, 0, 0, 10538, 10539, + 7, 6, 0, 0, 10539, 10540, 7, 25, 0, 0, 10540, 10541, 7, 6, 0, 0, 10541, + 10542, 7, 8, 0, 0, 10542, 10543, 7, 12, 0, 0, 10543, 10544, 7, 4, 0, 0, + 10544, 10545, 7, 6, 0, 0, 10545, 1084, 1, 0, 0, 0, 10546, 10547, 7, 6, + 0, 0, 10547, 10548, 7, 25, 0, 0, 10548, 10549, 7, 6, 0, 0, 10549, 10550, + 7, 14, 0, 0, 10550, 10551, 7, 15, 0, 0, 10551, 10552, 7, 4, 0, 0, 10552, + 1086, 1, 0, 0, 0, 10553, 10554, 7, 6, 0, 0, 10554, 10555, 7, 25, 0, 0, + 10555, 10556, 7, 10, 0, 0, 10556, 10557, 7, 5, 0, 0, 10557, 10558, 7, 4, + 0, 0, 10558, 10559, 7, 10, 0, 0, 10559, 10560, 7, 7, 0, 0, 10560, 10561, + 7, 17, 0, 0, 10561, 1088, 1, 0, 0, 0, 10562, 10563, 7, 6, 0, 0, 10563, + 10564, 7, 25, 0, 0, 10564, 10565, 7, 10, 0, 0, 10565, 10566, 7, 5, 0, 0, + 10566, 10567, 7, 4, 0, 0, 10567, 10568, 7, 5, 0, 0, 10568, 1090, 1, 0, + 0, 0, 10569, 10570, 7, 6, 0, 0, 10570, 10571, 7, 25, 0, 0, 10571, 10572, + 7, 10, 0, 0, 10572, 10573, 7, 5, 0, 0, 10573, 10574, 7, 4, 0, 0, 10574, + 10575, 7, 5, 0, 0, 10575, 10576, 7, 7, 0, 0, 10576, 10577, 7, 2, 0, 0, + 10577, 10578, 7, 9, 0, 0, 10578, 10579, 7, 6, 0, 0, 10579, 1092, 1, 0, + 0, 0, 10580, 10581, 7, 6, 0, 0, 10581, 10582, 7, 25, 0, 0, 10582, 10583, + 7, 10, 0, 0, 10583, 10584, 7, 4, 0, 0, 10584, 1094, 1, 0, 0, 0, 10585, + 10586, 7, 6, 0, 0, 10586, 10587, 7, 25, 0, 0, 10587, 10588, 7, 15, 0, 0, + 10588, 10589, 7, 0, 0, 0, 10589, 10590, 7, 7, 0, 0, 10590, 10591, 7, 9, + 0, 0, 10591, 10592, 5, 95, 0, 0, 10592, 10593, 7, 17, 0, 0, 10593, 10594, + 7, 5, 0, 0, 10594, 10595, 7, 6, 0, 0, 10595, 10596, 7, 4, 0, 0, 10596, + 10597, 5, 95, 0, 0, 10597, 10598, 7, 4, 0, 0, 10598, 10599, 7, 2, 0, 0, + 10599, 10600, 5, 95, 0, 0, 10600, 10601, 7, 12, 0, 0, 10601, 10602, 7, + 7, 0, 0, 10602, 10603, 7, 10, 0, 0, 10603, 10604, 7, 2, 0, 0, 10604, 10605, + 7, 7, 0, 0, 10605, 1096, 1, 0, 0, 0, 10606, 10607, 7, 6, 0, 0, 10607, 10608, + 7, 25, 0, 0, 10608, 10609, 7, 15, 0, 0, 10609, 10610, 7, 0, 0, 0, 10610, + 10611, 7, 7, 0, 0, 10611, 10612, 7, 9, 0, 0, 10612, 10613, 5, 95, 0, 0, + 10613, 10614, 7, 4, 0, 0, 10614, 10615, 7, 0, 0, 0, 10615, 10616, 7, 1, + 0, 0, 10616, 10617, 7, 11, 0, 0, 10617, 10618, 7, 6, 0, 0, 10618, 1098, + 1, 0, 0, 0, 10619, 10620, 7, 6, 0, 0, 10620, 10621, 7, 25, 0, 0, 10621, + 10622, 7, 15, 0, 0, 10622, 1100, 1, 0, 0, 0, 10623, 10624, 7, 6, 0, 0, + 10624, 10625, 7, 25, 0, 0, 10625, 10626, 7, 15, 0, 0, 10626, 10627, 7, + 10, 0, 0, 10627, 10628, 7, 3, 0, 0, 10628, 10629, 7, 6, 0, 0, 10629, 1102, + 1, 0, 0, 0, 10630, 10631, 7, 6, 0, 0, 10631, 10632, 7, 25, 0, 0, 10632, + 10633, 7, 15, 0, 0, 10633, 10634, 7, 11, 0, 0, 10634, 10635, 7, 0, 0, 0, + 10635, 10636, 7, 10, 0, 0, 10636, 10637, 7, 7, 0, 0, 10637, 1104, 1, 0, + 0, 0, 10638, 10639, 7, 6, 0, 0, 10639, 10640, 7, 25, 0, 0, 10640, 10641, + 7, 15, 0, 0, 10641, 10642, 7, 11, 0, 0, 10642, 10643, 7, 2, 0, 0, 10643, + 10644, 7, 5, 0, 0, 10644, 10645, 7, 10, 0, 0, 10645, 10646, 7, 2, 0, 0, + 10646, 10647, 7, 7, 0, 0, 10647, 1106, 1, 0, 0, 0, 10648, 10649, 7, 6, + 0, 0, 10649, 10650, 7, 25, 0, 0, 10650, 10651, 7, 15, 0, 0, 10651, 10652, + 7, 2, 0, 0, 10652, 10653, 7, 3, 0, 0, 10653, 10654, 7, 4, 0, 0, 10654, + 1108, 1, 0, 0, 0, 10655, 10656, 7, 6, 0, 0, 10656, 10657, 7, 25, 0, 0, + 10657, 10658, 7, 15, 0, 0, 10658, 10659, 7, 3, 0, 0, 10659, 10660, 5, 95, + 0, 0, 10660, 10661, 7, 8, 0, 0, 10661, 10662, 7, 2, 0, 0, 10662, 10663, + 7, 3, 0, 0, 10663, 10664, 7, 3, 0, 0, 10664, 10665, 5, 95, 0, 0, 10665, + 10666, 7, 8, 0, 0, 10666, 10667, 7, 19, 0, 0, 10667, 10668, 7, 6, 0, 0, + 10668, 10669, 7, 8, 0, 0, 10669, 10670, 7, 21, 0, 0, 10670, 1110, 1, 0, + 0, 0, 10671, 10672, 7, 6, 0, 0, 10672, 10673, 7, 25, 0, 0, 10673, 10674, + 7, 15, 0, 0, 10674, 10675, 7, 3, 0, 0, 10675, 10676, 7, 6, 0, 0, 10676, + 10677, 7, 5, 0, 0, 10677, 10678, 7, 5, 0, 0, 10678, 1112, 1, 0, 0, 0, 10679, + 10680, 7, 6, 0, 0, 10680, 10681, 7, 25, 0, 0, 10681, 10682, 7, 4, 0, 0, + 10682, 10683, 7, 6, 0, 0, 10683, 10684, 7, 7, 0, 0, 10684, 10685, 7, 9, + 0, 0, 10685, 10686, 7, 5, 0, 0, 10686, 1114, 1, 0, 0, 0, 10687, 10688, + 7, 6, 0, 0, 10688, 10689, 7, 25, 0, 0, 10689, 10690, 7, 4, 0, 0, 10690, + 10691, 7, 6, 0, 0, 10691, 10692, 7, 7, 0, 0, 10692, 10693, 7, 4, 0, 0, + 10693, 1116, 1, 0, 0, 0, 10694, 10695, 7, 6, 0, 0, 10695, 10696, 7, 25, + 0, 0, 10696, 10697, 7, 4, 0, 0, 10697, 10698, 7, 6, 0, 0, 10698, 10699, + 7, 7, 0, 0, 10699, 10700, 7, 4, 0, 0, 10700, 10701, 7, 5, 0, 0, 10701, + 1118, 1, 0, 0, 0, 10702, 10703, 7, 6, 0, 0, 10703, 10704, 7, 25, 0, 0, + 10704, 10705, 7, 4, 0, 0, 10705, 10706, 7, 6, 0, 0, 10706, 10707, 7, 3, + 0, 0, 10707, 10708, 7, 7, 0, 0, 10708, 10709, 7, 0, 0, 0, 10709, 10710, + 7, 11, 0, 0, 10710, 1120, 1, 0, 0, 0, 10711, 10712, 7, 6, 0, 0, 10712, + 10713, 7, 25, 0, 0, 10713, 10714, 7, 4, 0, 0, 10714, 10715, 7, 6, 0, 0, + 10715, 10716, 7, 3, 0, 0, 10716, 10717, 7, 7, 0, 0, 10717, 10718, 7, 0, + 0, 0, 10718, 10719, 7, 11, 0, 0, 10719, 10720, 7, 11, 0, 0, 10720, 10721, + 7, 18, 0, 0, 10721, 1122, 1, 0, 0, 0, 10722, 10723, 7, 6, 0, 0, 10723, + 10724, 7, 25, 0, 0, 10724, 10725, 7, 4, 0, 0, 10725, 10726, 7, 3, 0, 0, + 10726, 10727, 7, 0, 0, 0, 10727, 10728, 7, 8, 0, 0, 10728, 10729, 7, 4, + 0, 0, 10729, 10730, 7, 8, 0, 0, 10730, 10731, 7, 11, 0, 0, 10731, 10732, + 7, 2, 0, 0, 10732, 10733, 7, 1, 0, 0, 10733, 10734, 7, 25, 0, 0, 10734, + 10735, 7, 14, 0, 0, 10735, 10736, 7, 11, 0, 0, 10736, 1124, 1, 0, 0, 0, + 10737, 10738, 7, 6, 0, 0, 10738, 10739, 7, 25, 0, 0, 10739, 10740, 7, 4, + 0, 0, 10740, 10741, 7, 3, 0, 0, 10741, 10742, 7, 0, 0, 0, 10742, 10743, + 7, 8, 0, 0, 10743, 10744, 7, 4, 0, 0, 10744, 1126, 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, 10751, 7, 8, 0, 0, + 10751, 10752, 7, 4, 0, 0, 10752, 10753, 7, 13, 0, 0, 10753, 10754, 7, 0, + 0, 0, 10754, 10755, 7, 11, 0, 0, 10755, 10756, 7, 12, 0, 0, 10756, 10757, + 7, 6, 0, 0, 10757, 1128, 1, 0, 0, 0, 10758, 10759, 7, 6, 0, 0, 10759, 10760, + 7, 25, 0, 0, 10760, 10761, 7, 4, 0, 0, 10761, 10762, 7, 3, 0, 0, 10762, + 10763, 7, 0, 0, 0, 10763, 1130, 1, 0, 0, 0, 10764, 10765, 7, 16, 0, 0, + 10765, 10766, 7, 0, 0, 0, 10766, 10767, 7, 8, 0, 0, 10767, 10768, 7, 10, + 0, 0, 10768, 10769, 7, 11, 0, 0, 10769, 10770, 7, 10, 0, 0, 10770, 10771, + 7, 4, 0, 0, 10771, 10772, 7, 18, 0, 0, 10772, 1132, 1, 0, 0, 0, 10773, + 10774, 7, 16, 0, 0, 10774, 10775, 7, 0, 0, 0, 10775, 10776, 7, 8, 0, 0, + 10776, 10777, 7, 4, 0, 0, 10777, 1134, 1, 0, 0, 0, 10778, 10779, 7, 16, + 0, 0, 10779, 10780, 7, 0, 0, 0, 10780, 10781, 7, 8, 0, 0, 10781, 10782, + 7, 4, 0, 0, 10782, 10783, 7, 2, 0, 0, 10783, 10784, 7, 3, 0, 0, 10784, + 1136, 1, 0, 0, 0, 10785, 10786, 7, 16, 0, 0, 10786, 10787, 7, 0, 0, 0, + 10787, 10788, 7, 8, 0, 0, 10788, 10789, 7, 4, 0, 0, 10789, 10790, 7, 2, + 0, 0, 10790, 10791, 7, 3, 0, 0, 10791, 10792, 7, 10, 0, 0, 10792, 10793, + 7, 23, 0, 0, 10793, 10794, 7, 6, 0, 0, 10794, 10795, 5, 95, 0, 0, 10795, + 10796, 7, 20, 0, 0, 10796, 10797, 7, 2, 0, 0, 10797, 10798, 7, 10, 0, 0, + 10798, 10799, 7, 7, 0, 0, 10799, 1138, 1, 0, 0, 0, 10800, 10801, 7, 16, + 0, 0, 10801, 10802, 7, 0, 0, 0, 10802, 10803, 7, 10, 0, 0, 10803, 10804, + 7, 11, 0, 0, 10804, 10805, 7, 6, 0, 0, 10805, 10806, 7, 9, 0, 0, 10806, + 1140, 1, 0, 0, 0, 10807, 10808, 7, 16, 0, 0, 10808, 10809, 7, 0, 0, 0, + 10809, 10810, 7, 10, 0, 0, 10810, 10811, 7, 11, 0, 0, 10811, 10812, 7, + 6, 0, 0, 10812, 10813, 7, 9, 0, 0, 10813, 10814, 5, 95, 0, 0, 10814, 10815, + 7, 11, 0, 0, 10815, 10816, 7, 2, 0, 0, 10816, 10817, 7, 17, 0, 0, 10817, + 10818, 7, 10, 0, 0, 10818, 10819, 7, 7, 0, 0, 10819, 10820, 5, 95, 0, 0, + 10820, 10821, 7, 0, 0, 0, 10821, 10822, 7, 4, 0, 0, 10822, 10823, 7, 4, + 0, 0, 10823, 10824, 7, 6, 0, 0, 10824, 10825, 7, 14, 0, 0, 10825, 10826, + 7, 15, 0, 0, 10826, 10827, 7, 4, 0, 0, 10827, 10828, 7, 5, 0, 0, 10828, + 1142, 1, 0, 0, 0, 10829, 10830, 7, 16, 0, 0, 10830, 10831, 7, 0, 0, 0, + 10831, 10832, 7, 10, 0, 0, 10832, 10833, 7, 11, 0, 0, 10833, 10834, 7, + 17, 0, 0, 10834, 10835, 7, 3, 0, 0, 10835, 10836, 7, 2, 0, 0, 10836, 10837, + 7, 12, 0, 0, 10837, 10838, 7, 15, 0, 0, 10838, 1144, 1, 0, 0, 0, 10839, + 10840, 7, 16, 0, 0, 10840, 10841, 7, 0, 0, 0, 10841, 10842, 7, 10, 0, 0, + 10842, 10843, 7, 11, 0, 0, 10843, 10844, 7, 2, 0, 0, 10844, 10845, 7, 13, + 0, 0, 10845, 10846, 7, 6, 0, 0, 10846, 10847, 7, 3, 0, 0, 10847, 1146, + 1, 0, 0, 0, 10848, 10849, 7, 16, 0, 0, 10849, 10850, 7, 0, 0, 0, 10850, + 10851, 7, 10, 0, 0, 10851, 10852, 7, 11, 0, 0, 10852, 10853, 7, 12, 0, + 0, 10853, 10854, 7, 3, 0, 0, 10854, 10855, 7, 6, 0, 0, 10855, 1148, 1, + 0, 0, 0, 10856, 10857, 7, 16, 0, 0, 10857, 10858, 7, 0, 0, 0, 10858, 10859, + 7, 11, 0, 0, 10859, 10860, 7, 5, 0, 0, 10860, 10861, 7, 6, 0, 0, 10861, + 1150, 1, 0, 0, 0, 10862, 10863, 7, 16, 0, 0, 10863, 10864, 7, 0, 0, 0, + 10864, 10865, 7, 14, 0, 0, 10865, 10866, 7, 10, 0, 0, 10866, 10867, 7, + 11, 0, 0, 10867, 10868, 7, 18, 0, 0, 10868, 1152, 1, 0, 0, 0, 10869, 10870, + 7, 16, 0, 0, 10870, 10871, 7, 0, 0, 0, 10871, 10872, 7, 3, 0, 0, 10872, + 1154, 1, 0, 0, 0, 10873, 10874, 7, 16, 0, 0, 10874, 10875, 7, 0, 0, 0, + 10875, 10876, 7, 5, 0, 0, 10876, 10877, 7, 4, 0, 0, 10877, 1156, 1, 0, + 0, 0, 10878, 10879, 7, 16, 0, 0, 10879, 10880, 7, 0, 0, 0, 10880, 10881, + 7, 5, 0, 0, 10881, 10882, 7, 4, 0, 0, 10882, 10883, 7, 5, 0, 0, 10883, + 10884, 7, 4, 0, 0, 10884, 10885, 7, 0, 0, 0, 10885, 10886, 7, 3, 0, 0, + 10886, 10887, 7, 4, 0, 0, 10887, 1158, 1, 0, 0, 0, 10888, 10889, 7, 16, + 0, 0, 10889, 10890, 7, 1, 0, 0, 10890, 10891, 7, 4, 0, 0, 10891, 10892, + 7, 5, 0, 0, 10892, 10893, 7, 8, 0, 0, 10893, 10894, 7, 0, 0, 0, 10894, + 10895, 7, 7, 0, 0, 10895, 1160, 1, 0, 0, 0, 10896, 10897, 7, 16, 0, 0, + 10897, 10898, 7, 6, 0, 0, 10898, 10899, 7, 0, 0, 0, 10899, 10900, 7, 4, + 0, 0, 10900, 10901, 7, 12, 0, 0, 10901, 10902, 7, 3, 0, 0, 10902, 10903, + 7, 6, 0, 0, 10903, 1162, 1, 0, 0, 0, 10904, 10905, 7, 16, 0, 0, 10905, + 10906, 7, 6, 0, 0, 10906, 10907, 7, 0, 0, 0, 10907, 10908, 7, 4, 0, 0, + 10908, 10909, 7, 12, 0, 0, 10909, 10910, 7, 3, 0, 0, 10910, 10911, 7, 6, + 0, 0, 10911, 10912, 5, 95, 0, 0, 10912, 10913, 7, 9, 0, 0, 10913, 10914, + 7, 6, 0, 0, 10914, 10915, 7, 4, 0, 0, 10915, 10916, 7, 0, 0, 0, 10916, + 10917, 7, 10, 0, 0, 10917, 10918, 7, 11, 0, 0, 10918, 10919, 7, 5, 0, 0, + 10919, 1164, 1, 0, 0, 0, 10920, 10921, 7, 16, 0, 0, 10921, 10922, 7, 6, + 0, 0, 10922, 10923, 7, 0, 0, 0, 10923, 10924, 7, 4, 0, 0, 10924, 10925, + 7, 12, 0, 0, 10925, 10926, 7, 3, 0, 0, 10926, 10927, 7, 6, 0, 0, 10927, + 10928, 5, 95, 0, 0, 10928, 10929, 7, 10, 0, 0, 10929, 10930, 7, 9, 0, 0, + 10930, 1166, 1, 0, 0, 0, 10931, 10932, 7, 16, 0, 0, 10932, 10933, 7, 6, + 0, 0, 10933, 10934, 7, 0, 0, 0, 10934, 10935, 7, 4, 0, 0, 10935, 10936, + 7, 12, 0, 0, 10936, 10937, 7, 3, 0, 0, 10937, 10938, 7, 6, 0, 0, 10938, + 10939, 5, 95, 0, 0, 10939, 10940, 7, 5, 0, 0, 10940, 10941, 7, 6, 0, 0, + 10941, 10942, 7, 4, 0, 0, 10942, 1168, 1, 0, 0, 0, 10943, 10944, 7, 16, + 0, 0, 10944, 10945, 7, 6, 0, 0, 10945, 10946, 7, 0, 0, 0, 10946, 10947, + 7, 4, 0, 0, 10947, 10948, 7, 12, 0, 0, 10948, 10949, 7, 3, 0, 0, 10949, + 10950, 7, 6, 0, 0, 10950, 10951, 5, 95, 0, 0, 10951, 10952, 7, 13, 0, 0, + 10952, 10953, 7, 0, 0, 0, 10953, 10954, 7, 11, 0, 0, 10954, 10955, 7, 12, + 0, 0, 10955, 10956, 7, 6, 0, 0, 10956, 1170, 1, 0, 0, 0, 10957, 10958, + 7, 16, 0, 0, 10958, 10959, 7, 6, 0, 0, 10959, 10960, 7, 4, 0, 0, 10960, + 10961, 7, 8, 0, 0, 10961, 10962, 7, 19, 0, 0, 10962, 1172, 1, 0, 0, 0, + 10963, 10964, 7, 16, 0, 0, 10964, 10965, 7, 10, 0, 0, 10965, 10966, 7, + 6, 0, 0, 10966, 10967, 7, 11, 0, 0, 10967, 10968, 7, 9, 0, 0, 10968, 1174, + 1, 0, 0, 0, 10969, 10970, 7, 16, 0, 0, 10970, 10971, 7, 10, 0, 0, 10971, + 10972, 7, 6, 0, 0, 10972, 10973, 7, 11, 0, 0, 10973, 10974, 7, 9, 0, 0, + 10974, 10975, 7, 5, 0, 0, 10975, 1176, 1, 0, 0, 0, 10976, 10977, 7, 16, + 0, 0, 10977, 10978, 7, 10, 0, 0, 10978, 10979, 7, 11, 0, 0, 10979, 10980, + 7, 6, 0, 0, 10980, 1178, 1, 0, 0, 0, 10981, 10982, 7, 16, 0, 0, 10982, + 10983, 7, 10, 0, 0, 10983, 10984, 7, 11, 0, 0, 10984, 10985, 7, 6, 0, 0, + 10985, 10986, 5, 95, 0, 0, 10986, 10987, 7, 7, 0, 0, 10987, 10988, 7, 0, + 0, 0, 10988, 10989, 7, 14, 0, 0, 10989, 10990, 7, 6, 0, 0, 10990, 10991, + 5, 95, 0, 0, 10991, 10992, 7, 8, 0, 0, 10992, 10993, 7, 2, 0, 0, 10993, + 10994, 7, 7, 0, 0, 10994, 10995, 7, 13, 0, 0, 10995, 10996, 7, 6, 0, 0, + 10996, 10997, 7, 3, 0, 0, 10997, 10998, 7, 4, 0, 0, 10998, 1180, 1, 0, + 0, 0, 10999, 11000, 7, 16, 0, 0, 11000, 11001, 7, 10, 0, 0, 11001, 11002, + 7, 11, 0, 0, 11002, 11003, 7, 6, 0, 0, 11003, 11004, 7, 17, 0, 0, 11004, + 11005, 7, 3, 0, 0, 11005, 11006, 7, 2, 0, 0, 11006, 11007, 7, 12, 0, 0, + 11007, 11008, 7, 15, 0, 0, 11008, 1182, 1, 0, 0, 0, 11009, 11010, 7, 16, + 0, 0, 11010, 11011, 7, 10, 0, 0, 11011, 11012, 7, 11, 0, 0, 11012, 11013, + 7, 6, 0, 0, 11013, 11014, 7, 5, 0, 0, 11014, 11015, 7, 4, 0, 0, 11015, + 11016, 7, 2, 0, 0, 11016, 11017, 7, 3, 0, 0, 11017, 11018, 7, 6, 0, 0, + 11018, 1184, 1, 0, 0, 0, 11019, 11020, 7, 16, 0, 0, 11020, 11021, 7, 10, + 0, 0, 11021, 11022, 7, 11, 0, 0, 11022, 11023, 7, 6, 0, 0, 11023, 11024, + 7, 5, 0, 0, 11024, 11025, 7, 18, 0, 0, 11025, 11026, 7, 5, 0, 0, 11026, + 11027, 7, 4, 0, 0, 11027, 11028, 7, 6, 0, 0, 11028, 11029, 7, 14, 0, 0, + 11029, 11030, 5, 95, 0, 0, 11030, 11031, 7, 11, 0, 0, 11031, 11032, 7, + 10, 0, 0, 11032, 11033, 7, 21, 0, 0, 11033, 11034, 7, 6, 0, 0, 11034, 11035, + 5, 95, 0, 0, 11035, 11036, 7, 11, 0, 0, 11036, 11037, 7, 2, 0, 0, 11037, + 11038, 7, 17, 0, 0, 11038, 11039, 7, 17, 0, 0, 11039, 11040, 7, 10, 0, + 0, 11040, 11041, 7, 7, 0, 0, 11041, 11042, 7, 17, 0, 0, 11042, 1186, 1, + 0, 0, 0, 11043, 11044, 7, 16, 0, 0, 11044, 11045, 7, 10, 0, 0, 11045, 11046, + 7, 11, 0, 0, 11046, 11047, 7, 4, 0, 0, 11047, 11048, 7, 6, 0, 0, 11048, + 11049, 7, 3, 0, 0, 11049, 1188, 1, 0, 0, 0, 11050, 11051, 7, 16, 0, 0, + 11051, 11052, 7, 10, 0, 0, 11052, 11053, 7, 7, 0, 0, 11053, 11054, 7, 0, + 0, 0, 11054, 11055, 7, 11, 0, 0, 11055, 1190, 1, 0, 0, 0, 11056, 11057, + 7, 16, 0, 0, 11057, 11058, 7, 10, 0, 0, 11058, 11059, 7, 7, 0, 0, 11059, + 11060, 7, 6, 0, 0, 11060, 1192, 1, 0, 0, 0, 11061, 11062, 7, 16, 0, 0, + 11062, 11063, 7, 10, 0, 0, 11063, 11064, 7, 7, 0, 0, 11064, 11065, 7, 10, + 0, 0, 11065, 11066, 7, 5, 0, 0, 11066, 11067, 7, 19, 0, 0, 11067, 1194, + 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, 1196, 1, 0, 0, 0, 11074, 11075, 7, 16, 0, 0, 11075, 11076, 7, 10, + 0, 0, 11076, 11077, 7, 3, 0, 0, 11077, 11078, 7, 5, 0, 0, 11078, 11079, + 7, 4, 0, 0, 11079, 11080, 7, 14, 0, 0, 11080, 1198, 1, 0, 0, 0, 11081, + 11082, 7, 16, 0, 0, 11082, 11083, 7, 10, 0, 0, 11083, 11084, 7, 3, 0, 0, + 11084, 11085, 7, 5, 0, 0, 11085, 11086, 7, 4, 0, 0, 11086, 11087, 5, 95, + 0, 0, 11087, 11088, 7, 3, 0, 0, 11088, 11089, 7, 2, 0, 0, 11089, 11090, + 7, 22, 0, 0, 11090, 11091, 7, 5, 0, 0, 11091, 1200, 1, 0, 0, 0, 11092, + 11093, 7, 16, 0, 0, 11093, 11094, 7, 10, 0, 0, 11094, 11095, 7, 3, 0, 0, + 11095, 11096, 7, 5, 0, 0, 11096, 11097, 7, 4, 0, 0, 11097, 11098, 5, 95, + 0, 0, 11098, 11099, 7, 13, 0, 0, 11099, 11100, 7, 0, 0, 0, 11100, 11101, + 7, 11, 0, 0, 11101, 11102, 7, 12, 0, 0, 11102, 11103, 7, 6, 0, 0, 11103, + 1202, 1, 0, 0, 0, 11104, 11105, 7, 16, 0, 0, 11105, 11106, 7, 10, 0, 0, + 11106, 11107, 7, 25, 0, 0, 11107, 11108, 7, 6, 0, 0, 11108, 11109, 7, 9, + 0, 0, 11109, 1204, 1, 0, 0, 0, 11110, 11111, 7, 16, 0, 0, 11111, 11112, + 7, 10, 0, 0, 11112, 11113, 7, 25, 0, 0, 11113, 11114, 7, 6, 0, 0, 11114, + 11115, 7, 9, 0, 0, 11115, 11116, 5, 95, 0, 0, 11116, 11117, 7, 13, 0, 0, + 11117, 11118, 7, 10, 0, 0, 11118, 11119, 7, 6, 0, 0, 11119, 11120, 7, 22, + 0, 0, 11120, 11121, 5, 95, 0, 0, 11121, 11122, 7, 9, 0, 0, 11122, 11123, + 7, 0, 0, 0, 11123, 11124, 7, 4, 0, 0, 11124, 11125, 7, 0, 0, 0, 11125, + 1206, 1, 0, 0, 0, 11126, 11127, 7, 16, 0, 0, 11127, 11128, 7, 11, 0, 0, + 11128, 11129, 7, 0, 0, 0, 11129, 11130, 7, 17, 0, 0, 11130, 11131, 7, 17, + 0, 0, 11131, 11132, 7, 6, 0, 0, 11132, 11133, 7, 3, 0, 0, 11133, 1208, + 1, 0, 0, 0, 11134, 11135, 7, 16, 0, 0, 11135, 11136, 7, 11, 0, 0, 11136, + 11137, 7, 0, 0, 0, 11137, 11138, 7, 5, 0, 0, 11138, 11139, 7, 19, 0, 0, + 11139, 11140, 7, 1, 0, 0, 11140, 11141, 7, 0, 0, 0, 11141, 11142, 7, 8, + 0, 0, 11142, 11143, 7, 21, 0, 0, 11143, 1210, 1, 0, 0, 0, 11144, 11145, + 7, 16, 0, 0, 11145, 11146, 7, 11, 0, 0, 11146, 11147, 7, 0, 0, 0, 11147, + 11148, 7, 5, 0, 0, 11148, 11149, 7, 19, 0, 0, 11149, 11150, 5, 95, 0, 0, + 11150, 11151, 7, 8, 0, 0, 11151, 11152, 7, 0, 0, 0, 11152, 11153, 7, 8, + 0, 0, 11153, 11154, 7, 19, 0, 0, 11154, 11155, 7, 6, 0, 0, 11155, 1212, + 1, 0, 0, 0, 11156, 11157, 7, 16, 0, 0, 11157, 11158, 7, 11, 0, 0, 11158, + 11159, 7, 2, 0, 0, 11159, 11160, 7, 0, 0, 0, 11160, 11161, 7, 4, 0, 0, + 11161, 1214, 1, 0, 0, 0, 11162, 11163, 7, 16, 0, 0, 11163, 11164, 7, 11, + 0, 0, 11164, 11165, 7, 2, 0, 0, 11165, 11166, 7, 1, 0, 0, 11166, 1216, + 1, 0, 0, 0, 11167, 11168, 7, 16, 0, 0, 11168, 11169, 7, 11, 0, 0, 11169, + 11170, 7, 6, 0, 0, 11170, 11171, 7, 25, 0, 0, 11171, 1218, 1, 0, 0, 0, + 11172, 11173, 7, 16, 0, 0, 11173, 11174, 7, 11, 0, 0, 11174, 11175, 7, + 2, 0, 0, 11175, 11176, 7, 2, 0, 0, 11176, 11177, 7, 3, 0, 0, 11177, 1220, + 1, 0, 0, 0, 11178, 11179, 7, 16, 0, 0, 11179, 11180, 7, 11, 0, 0, 11180, + 11181, 7, 12, 0, 0, 11181, 11182, 7, 5, 0, 0, 11182, 11183, 7, 19, 0, 0, + 11183, 1222, 1, 0, 0, 0, 11184, 11185, 7, 16, 0, 0, 11185, 11186, 7, 2, + 0, 0, 11186, 11187, 7, 11, 0, 0, 11187, 11188, 7, 9, 0, 0, 11188, 11189, + 7, 6, 0, 0, 11189, 11190, 7, 3, 0, 0, 11190, 1224, 1, 0, 0, 0, 11191, 11192, + 7, 16, 0, 0, 11192, 11193, 7, 2, 0, 0, 11193, 11194, 7, 11, 0, 0, 11194, + 11195, 7, 11, 0, 0, 11195, 11196, 7, 2, 0, 0, 11196, 11197, 7, 22, 0, 0, + 11197, 11198, 7, 10, 0, 0, 11198, 11199, 7, 7, 0, 0, 11199, 11200, 7, 17, + 0, 0, 11200, 1226, 1, 0, 0, 0, 11201, 11202, 7, 16, 0, 0, 11202, 11203, + 7, 2, 0, 0, 11203, 11204, 7, 11, 0, 0, 11204, 11205, 7, 11, 0, 0, 11205, + 11206, 7, 2, 0, 0, 11206, 11207, 7, 22, 0, 0, 11207, 11208, 7, 5, 0, 0, + 11208, 1228, 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, 0, 0, 0, 11213, 11214, + 7, 11, 0, 0, 11214, 11215, 7, 11, 0, 0, 11215, 1230, 1, 0, 0, 0, 11216, + 11217, 7, 16, 0, 0, 11217, 11218, 7, 2, 0, 0, 11218, 11219, 7, 3, 0, 0, + 11219, 11220, 7, 8, 0, 0, 11220, 11221, 7, 6, 0, 0, 11221, 1232, 1, 0, + 0, 0, 11222, 11223, 7, 16, 0, 0, 11223, 11224, 7, 2, 0, 0, 11224, 11225, + 7, 3, 0, 0, 11225, 11226, 7, 8, 0, 0, 11226, 11227, 7, 6, 0, 0, 11227, + 11228, 5, 95, 0, 0, 11228, 11229, 7, 25, 0, 0, 11229, 11230, 7, 14, 0, + 0, 11230, 11231, 7, 11, 0, 0, 11231, 11232, 5, 95, 0, 0, 11232, 11233, + 7, 24, 0, 0, 11233, 11234, 7, 12, 0, 0, 11234, 11235, 7, 6, 0, 0, 11235, + 11236, 7, 3, 0, 0, 11236, 11237, 7, 18, 0, 0, 11237, 11238, 5, 95, 0, 0, + 11238, 11239, 7, 3, 0, 0, 11239, 11240, 7, 6, 0, 0, 11240, 11241, 7, 22, + 0, 0, 11241, 11242, 7, 3, 0, 0, 11242, 11243, 7, 10, 0, 0, 11243, 11244, + 7, 4, 0, 0, 11244, 11245, 7, 6, 0, 0, 11245, 1234, 1, 0, 0, 0, 11246, 11247, + 7, 16, 0, 0, 11247, 11248, 7, 2, 0, 0, 11248, 11249, 7, 3, 0, 0, 11249, + 11250, 7, 6, 0, 0, 11250, 11251, 7, 10, 0, 0, 11251, 11252, 7, 17, 0, 0, + 11252, 11253, 7, 7, 0, 0, 11253, 1236, 1, 0, 0, 0, 11254, 11255, 7, 16, + 0, 0, 11255, 11256, 7, 2, 0, 0, 11256, 11257, 7, 3, 0, 0, 11257, 11258, + 7, 6, 0, 0, 11258, 11259, 7, 13, 0, 0, 11259, 11260, 7, 6, 0, 0, 11260, + 11261, 7, 3, 0, 0, 11261, 1238, 1, 0, 0, 0, 11262, 11263, 7, 16, 0, 0, + 11263, 11264, 7, 2, 0, 0, 11264, 11265, 7, 3, 0, 0, 11265, 1240, 1, 0, + 0, 0, 11266, 11267, 7, 16, 0, 0, 11267, 11268, 7, 2, 0, 0, 11268, 11269, + 7, 3, 0, 0, 11269, 11270, 7, 14, 0, 0, 11270, 11271, 7, 0, 0, 0, 11271, + 11272, 7, 4, 0, 0, 11272, 1242, 1, 0, 0, 0, 11273, 11274, 7, 16, 0, 0, + 11274, 11275, 7, 2, 0, 0, 11275, 11276, 7, 3, 0, 0, 11276, 11277, 7, 22, + 0, 0, 11277, 11278, 7, 0, 0, 0, 11278, 11279, 7, 3, 0, 0, 11279, 11280, + 7, 9, 0, 0, 11280, 1244, 1, 0, 0, 0, 11281, 11282, 7, 16, 0, 0, 11282, + 11283, 7, 3, 0, 0, 11283, 11284, 7, 0, 0, 0, 11284, 11285, 7, 17, 0, 0, + 11285, 11286, 7, 14, 0, 0, 11286, 11287, 7, 6, 0, 0, 11287, 11288, 7, 7, + 0, 0, 11288, 11289, 7, 4, 0, 0, 11289, 11290, 5, 95, 0, 0, 11290, 11291, + 7, 7, 0, 0, 11291, 11292, 7, 12, 0, 0, 11292, 11293, 7, 14, 0, 0, 11293, + 11294, 7, 1, 0, 0, 11294, 11295, 7, 6, 0, 0, 11295, 11296, 7, 3, 0, 0, + 11296, 1246, 1, 0, 0, 0, 11297, 11298, 7, 16, 0, 0, 11298, 11299, 7, 3, + 0, 0, 11299, 11300, 7, 6, 0, 0, 11300, 11301, 7, 6, 0, 0, 11301, 11302, + 7, 11, 0, 0, 11302, 11303, 7, 10, 0, 0, 11303, 11304, 7, 5, 0, 0, 11304, + 11305, 7, 4, 0, 0, 11305, 1248, 1, 0, 0, 0, 11306, 11307, 7, 16, 0, 0, + 11307, 11308, 7, 3, 0, 0, 11308, 11309, 7, 6, 0, 0, 11309, 11310, 7, 6, + 0, 0, 11310, 11311, 7, 11, 0, 0, 11311, 11312, 7, 10, 0, 0, 11312, 11313, + 7, 5, 0, 0, 11313, 11314, 7, 4, 0, 0, 11314, 11315, 7, 5, 0, 0, 11315, + 1250, 1, 0, 0, 0, 11316, 11317, 7, 16, 0, 0, 11317, 11318, 7, 3, 0, 0, + 11318, 11319, 7, 6, 0, 0, 11319, 11320, 7, 6, 0, 0, 11320, 11321, 7, 15, + 0, 0, 11321, 11322, 7, 2, 0, 0, 11322, 11323, 7, 2, 0, 0, 11323, 11324, + 7, 11, 0, 0, 11324, 11325, 7, 5, 0, 0, 11325, 1252, 1, 0, 0, 0, 11326, + 11327, 7, 16, 0, 0, 11327, 11328, 7, 3, 0, 0, 11328, 11329, 7, 6, 0, 0, + 11329, 11330, 7, 5, 0, 0, 11330, 11331, 7, 19, 0, 0, 11331, 1254, 1, 0, + 0, 0, 11332, 11333, 7, 16, 0, 0, 11333, 11334, 7, 3, 0, 0, 11334, 11335, + 7, 2, 0, 0, 11335, 11336, 7, 14, 0, 0, 11336, 1256, 1, 0, 0, 0, 11337, + 11338, 7, 16, 0, 0, 11338, 11339, 7, 3, 0, 0, 11339, 11340, 7, 2, 0, 0, + 11340, 11341, 7, 14, 0, 0, 11341, 11342, 5, 95, 0, 0, 11342, 11343, 7, + 4, 0, 0, 11343, 11344, 7, 23, 0, 0, 11344, 1258, 1, 0, 0, 0, 11345, 11346, + 7, 16, 0, 0, 11346, 11347, 7, 12, 0, 0, 11347, 11348, 7, 11, 0, 0, 11348, + 11349, 7, 11, 0, 0, 11349, 1260, 1, 0, 0, 0, 11350, 11351, 7, 16, 0, 0, + 11351, 11352, 7, 12, 0, 0, 11352, 11353, 7, 11, 0, 0, 11353, 11354, 7, + 11, 0, 0, 11354, 11355, 5, 95, 0, 0, 11355, 11356, 7, 2, 0, 0, 11356, 11357, + 7, 12, 0, 0, 11357, 11358, 7, 4, 0, 0, 11358, 11359, 7, 6, 0, 0, 11359, + 11360, 7, 3, 0, 0, 11360, 11361, 5, 95, 0, 0, 11361, 11362, 7, 20, 0, 0, + 11362, 11363, 7, 2, 0, 0, 11363, 11364, 7, 10, 0, 0, 11364, 11365, 7, 7, + 0, 0, 11365, 11366, 5, 95, 0, 0, 11366, 11367, 7, 4, 0, 0, 11367, 11368, + 7, 2, 0, 0, 11368, 11369, 5, 95, 0, 0, 11369, 11370, 7, 2, 0, 0, 11370, + 11371, 7, 12, 0, 0, 11371, 11372, 7, 4, 0, 0, 11372, 11373, 7, 6, 0, 0, + 11373, 11374, 7, 3, 0, 0, 11374, 1262, 1, 0, 0, 0, 11375, 11376, 7, 16, + 0, 0, 11376, 11377, 7, 12, 0, 0, 11377, 11378, 7, 7, 0, 0, 11378, 11379, + 7, 8, 0, 0, 11379, 11380, 7, 4, 0, 0, 11380, 11381, 7, 10, 0, 0, 11381, + 11382, 7, 2, 0, 0, 11382, 11383, 7, 7, 0, 0, 11383, 1264, 1, 0, 0, 0, 11384, + 11385, 7, 16, 0, 0, 11385, 11386, 7, 12, 0, 0, 11386, 11387, 7, 7, 0, 0, + 11387, 11388, 7, 8, 0, 0, 11388, 11389, 7, 4, 0, 0, 11389, 11390, 7, 10, + 0, 0, 11390, 11391, 7, 2, 0, 0, 11391, 11392, 7, 7, 0, 0, 11392, 11393, + 7, 5, 0, 0, 11393, 1266, 1, 0, 0, 0, 11394, 11395, 7, 16, 0, 0, 11395, + 11396, 7, 4, 0, 0, 11396, 11397, 7, 15, 0, 0, 11397, 1268, 1, 0, 0, 0, + 11398, 11399, 7, 17, 0, 0, 11399, 1270, 1, 0, 0, 0, 11400, 11401, 7, 17, + 0, 0, 11401, 11402, 7, 0, 0, 0, 11402, 11403, 7, 4, 0, 0, 11403, 11404, + 7, 19, 0, 0, 11404, 11405, 7, 6, 0, 0, 11405, 11406, 7, 3, 0, 0, 11406, + 11407, 5, 95, 0, 0, 11407, 11408, 7, 2, 0, 0, 11408, 11409, 7, 15, 0, 0, + 11409, 11410, 7, 4, 0, 0, 11410, 11411, 7, 10, 0, 0, 11411, 11412, 7, 14, + 0, 0, 11412, 11413, 7, 10, 0, 0, 11413, 11414, 7, 23, 0, 0, 11414, 11415, + 7, 6, 0, 0, 11415, 11416, 7, 3, 0, 0, 11416, 11417, 5, 95, 0, 0, 11417, + 11418, 7, 5, 0, 0, 11418, 11419, 7, 4, 0, 0, 11419, 11420, 7, 0, 0, 0, + 11420, 11421, 7, 4, 0, 0, 11421, 11422, 7, 10, 0, 0, 11422, 11423, 7, 5, + 0, 0, 11423, 11424, 7, 4, 0, 0, 11424, 11425, 7, 10, 0, 0, 11425, 11426, + 7, 8, 0, 0, 11426, 11427, 7, 5, 0, 0, 11427, 1272, 1, 0, 0, 0, 11428, 11429, + 7, 17, 0, 0, 11429, 11430, 7, 0, 0, 0, 11430, 11431, 7, 4, 0, 0, 11431, + 11432, 7, 19, 0, 0, 11432, 11433, 7, 6, 0, 0, 11433, 11434, 7, 3, 0, 0, + 11434, 11435, 5, 95, 0, 0, 11435, 11436, 7, 15, 0, 0, 11436, 11437, 7, + 11, 0, 0, 11437, 11438, 7, 0, 0, 0, 11438, 11439, 7, 7, 0, 0, 11439, 11440, + 5, 95, 0, 0, 11440, 11441, 7, 5, 0, 0, 11441, 11442, 7, 4, 0, 0, 11442, + 11443, 7, 0, 0, 0, 11443, 11444, 7, 4, 0, 0, 11444, 11445, 7, 10, 0, 0, + 11445, 11446, 7, 5, 0, 0, 11446, 11447, 7, 4, 0, 0, 11447, 11448, 7, 10, + 0, 0, 11448, 11449, 7, 8, 0, 0, 11449, 11450, 7, 5, 0, 0, 11450, 1274, + 1, 0, 0, 0, 11451, 11452, 7, 17, 0, 0, 11452, 11453, 7, 1, 0, 0, 11453, + 11454, 7, 18, 0, 0, 11454, 11455, 5, 95, 0, 0, 11455, 11456, 7, 8, 0, 0, + 11456, 11457, 7, 2, 0, 0, 11457, 11458, 7, 7, 0, 0, 11458, 11459, 7, 8, + 0, 0, 11459, 11460, 5, 95, 0, 0, 11460, 11461, 7, 3, 0, 0, 11461, 11462, + 7, 2, 0, 0, 11462, 11463, 7, 11, 0, 0, 11463, 11464, 7, 11, 0, 0, 11464, + 11465, 7, 12, 0, 0, 11465, 11466, 7, 15, 0, 0, 11466, 1276, 1, 0, 0, 0, + 11467, 11468, 7, 17, 0, 0, 11468, 11469, 7, 1, 0, 0, 11469, 11470, 7, 18, + 0, 0, 11470, 11471, 5, 95, 0, 0, 11471, 11472, 7, 15, 0, 0, 11472, 11473, + 7, 12, 0, 0, 11473, 11474, 7, 5, 0, 0, 11474, 11475, 7, 19, 0, 0, 11475, + 11476, 7, 9, 0, 0, 11476, 11477, 7, 2, 0, 0, 11477, 11478, 7, 22, 0, 0, + 11478, 11479, 7, 7, 0, 0, 11479, 1278, 1, 0, 0, 0, 11480, 11481, 7, 17, + 0, 0, 11481, 11482, 7, 6, 0, 0, 11482, 11483, 7, 7, 0, 0, 11483, 11484, + 7, 6, 0, 0, 11484, 11485, 7, 3, 0, 0, 11485, 11486, 7, 0, 0, 0, 11486, + 11487, 7, 4, 0, 0, 11487, 11488, 7, 6, 0, 0, 11488, 11489, 7, 9, 0, 0, + 11489, 1280, 1, 0, 0, 0, 11490, 11491, 7, 17, 0, 0, 11491, 11492, 7, 6, + 0, 0, 11492, 11493, 7, 4, 0, 0, 11493, 1282, 1, 0, 0, 0, 11494, 11495, + 7, 17, 0, 0, 11495, 11496, 7, 11, 0, 0, 11496, 11497, 7, 2, 0, 0, 11497, + 11498, 7, 1, 0, 0, 11498, 11499, 7, 0, 0, 0, 11499, 11500, 7, 11, 0, 0, + 11500, 1284, 1, 0, 0, 0, 11501, 11502, 7, 17, 0, 0, 11502, 11503, 7, 11, + 0, 0, 11503, 11504, 7, 2, 0, 0, 11504, 11505, 7, 1, 0, 0, 11505, 11506, + 7, 0, 0, 0, 11506, 11507, 7, 11, 0, 0, 11507, 11508, 7, 11, 0, 0, 11508, + 11509, 7, 18, 0, 0, 11509, 1286, 1, 0, 0, 0, 11510, 11511, 7, 17, 0, 0, + 11511, 11512, 7, 11, 0, 0, 11512, 11513, 7, 2, 0, 0, 11513, 11514, 7, 1, + 0, 0, 11514, 11515, 7, 0, 0, 0, 11515, 11516, 7, 11, 0, 0, 11516, 11517, + 5, 95, 0, 0, 11517, 11518, 7, 7, 0, 0, 11518, 11519, 7, 0, 0, 0, 11519, + 11520, 7, 14, 0, 0, 11520, 11521, 7, 6, 0, 0, 11521, 1288, 1, 0, 0, 0, + 11522, 11523, 7, 17, 0, 0, 11523, 11524, 7, 11, 0, 0, 11524, 11525, 7, + 2, 0, 0, 11525, 11526, 7, 1, 0, 0, 11526, 11527, 7, 0, 0, 0, 11527, 11528, + 7, 11, 0, 0, 11528, 11529, 5, 95, 0, 0, 11529, 11530, 7, 4, 0, 0, 11530, + 11531, 7, 2, 0, 0, 11531, 11532, 7, 15, 0, 0, 11532, 11533, 7, 10, 0, 0, + 11533, 11534, 7, 8, 0, 0, 11534, 11535, 5, 95, 0, 0, 11535, 11536, 7, 6, + 0, 0, 11536, 11537, 7, 7, 0, 0, 11537, 11538, 7, 0, 0, 0, 11538, 11539, + 7, 1, 0, 0, 11539, 11540, 7, 11, 0, 0, 11540, 11541, 7, 6, 0, 0, 11541, + 11542, 7, 9, 0, 0, 11542, 1290, 1, 0, 0, 0, 11543, 11544, 7, 17, 0, 0, + 11544, 11545, 7, 2, 0, 0, 11545, 11546, 7, 4, 0, 0, 11546, 11547, 7, 2, + 0, 0, 11547, 1292, 1, 0, 0, 0, 11548, 11549, 7, 17, 0, 0, 11549, 11550, + 7, 3, 0, 0, 11550, 11551, 7, 0, 0, 0, 11551, 11552, 7, 7, 0, 0, 11552, + 11553, 7, 4, 0, 0, 11553, 1294, 1, 0, 0, 0, 11554, 11555, 7, 17, 0, 0, + 11555, 11556, 7, 3, 0, 0, 11556, 11557, 7, 2, 0, 0, 11557, 11558, 7, 12, + 0, 0, 11558, 11559, 7, 15, 0, 0, 11559, 11560, 5, 95, 0, 0, 11560, 11561, + 7, 1, 0, 0, 11561, 11562, 7, 18, 0, 0, 11562, 1296, 1, 0, 0, 0, 11563, + 11564, 7, 17, 0, 0, 11564, 11565, 7, 3, 0, 0, 11565, 11566, 7, 2, 0, 0, + 11566, 11567, 7, 12, 0, 0, 11567, 11568, 7, 15, 0, 0, 11568, 1298, 1, 0, + 0, 0, 11569, 11570, 7, 17, 0, 0, 11570, 11571, 7, 3, 0, 0, 11571, 11572, + 7, 2, 0, 0, 11572, 11573, 7, 12, 0, 0, 11573, 11574, 7, 15, 0, 0, 11574, + 11575, 5, 95, 0, 0, 11575, 11576, 7, 10, 0, 0, 11576, 11577, 7, 9, 0, 0, + 11577, 1300, 1, 0, 0, 0, 11578, 11579, 7, 17, 0, 0, 11579, 11580, 7, 3, + 0, 0, 11580, 11581, 7, 2, 0, 0, 11581, 11582, 7, 12, 0, 0, 11582, 11583, + 7, 15, 0, 0, 11583, 11584, 7, 10, 0, 0, 11584, 11585, 7, 7, 0, 0, 11585, + 11586, 7, 17, 0, 0, 11586, 1302, 1, 0, 0, 0, 11587, 11588, 7, 17, 0, 0, + 11588, 11589, 7, 3, 0, 0, 11589, 11590, 7, 2, 0, 0, 11590, 11591, 7, 12, + 0, 0, 11591, 11592, 7, 15, 0, 0, 11592, 11593, 7, 10, 0, 0, 11593, 11594, + 7, 7, 0, 0, 11594, 11595, 7, 17, 0, 0, 11595, 11596, 5, 95, 0, 0, 11596, + 11597, 7, 10, 0, 0, 11597, 11598, 7, 9, 0, 0, 11598, 1304, 1, 0, 0, 0, + 11599, 11600, 7, 17, 0, 0, 11600, 11601, 7, 3, 0, 0, 11601, 11602, 7, 2, + 0, 0, 11602, 11603, 7, 12, 0, 0, 11603, 11604, 7, 15, 0, 0, 11604, 11605, + 7, 5, 0, 0, 11605, 1306, 1, 0, 0, 0, 11606, 11607, 7, 17, 0, 0, 11607, + 11608, 7, 12, 0, 0, 11608, 11609, 7, 0, 0, 0, 11609, 11610, 7, 3, 0, 0, + 11610, 11611, 7, 0, 0, 0, 11611, 11612, 7, 7, 0, 0, 11612, 11613, 7, 4, + 0, 0, 11613, 11614, 7, 6, 0, 0, 11614, 11615, 7, 6, 0, 0, 11615, 11616, + 7, 9, 0, 0, 11616, 1308, 1, 0, 0, 0, 11617, 11618, 7, 17, 0, 0, 11618, + 11619, 7, 12, 0, 0, 11619, 11620, 7, 0, 0, 0, 11620, 11621, 7, 3, 0, 0, + 11621, 11622, 7, 0, 0, 0, 11622, 11623, 7, 7, 0, 0, 11623, 11624, 7, 4, + 0, 0, 11624, 11625, 7, 6, 0, 0, 11625, 11626, 7, 6, 0, 0, 11626, 1310, + 1, 0, 0, 0, 11627, 11628, 7, 17, 0, 0, 11628, 11629, 7, 12, 0, 0, 11629, + 11630, 7, 0, 0, 0, 11630, 11631, 7, 3, 0, 0, 11631, 11632, 7, 9, 0, 0, + 11632, 1312, 1, 0, 0, 0, 11633, 11634, 7, 19, 0, 0, 11634, 11635, 7, 0, + 0, 0, 11635, 11636, 7, 9, 0, 0, 11636, 11637, 7, 2, 0, 0, 11637, 11638, + 7, 2, 0, 0, 11638, 11639, 7, 15, 0, 0, 11639, 11640, 5, 95, 0, 0, 11640, + 11641, 7, 4, 0, 0, 11641, 11642, 7, 3, 0, 0, 11642, 11643, 7, 0, 0, 0, + 11643, 11644, 7, 10, 0, 0, 11644, 11645, 7, 11, 0, 0, 11645, 11646, 7, + 6, 0, 0, 11646, 11647, 7, 3, 0, 0, 11647, 11648, 7, 5, 0, 0, 11648, 1314, + 1, 0, 0, 0, 11649, 11650, 7, 19, 0, 0, 11650, 11651, 7, 0, 0, 0, 11651, + 11652, 7, 11, 0, 0, 11652, 11653, 7, 16, 0, 0, 11653, 11654, 5, 95, 0, + 0, 11654, 11655, 7, 18, 0, 0, 11655, 11656, 7, 6, 0, 0, 11656, 11657, 7, + 0, 0, 0, 11657, 11658, 7, 3, 0, 0, 11658, 11659, 7, 5, 0, 0, 11659, 1316, + 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, 5, 95, 0, 0, + 11665, 11666, 7, 0, 0, 0, 11666, 11667, 7, 20, 0, 0, 11667, 1318, 1, 0, + 0, 0, 11668, 11669, 7, 19, 0, 0, 11669, 11670, 7, 0, 0, 0, 11670, 11671, + 7, 5, 0, 0, 11671, 11672, 7, 19, 0, 0, 11672, 1320, 1, 0, 0, 0, 11673, + 11674, 7, 19, 0, 0, 11674, 11675, 7, 0, 0, 0, 11675, 11676, 7, 5, 0, 0, + 11676, 11677, 7, 19, 0, 0, 11677, 11678, 7, 21, 0, 0, 11678, 11679, 7, + 6, 0, 0, 11679, 11680, 7, 18, 0, 0, 11680, 11681, 7, 5, 0, 0, 11681, 1322, + 1, 0, 0, 0, 11682, 11683, 7, 19, 0, 0, 11683, 11684, 7, 0, 0, 0, 11684, + 11685, 7, 5, 0, 0, 11685, 11686, 7, 19, 0, 0, 11686, 11687, 5, 95, 0, 0, + 11687, 11688, 7, 5, 0, 0, 11688, 11689, 7, 20, 0, 0, 11689, 1324, 1, 0, + 0, 0, 11690, 11691, 7, 19, 0, 0, 11691, 11692, 7, 0, 0, 0, 11692, 11693, + 7, 13, 0, 0, 11693, 11694, 7, 10, 0, 0, 11694, 11695, 7, 7, 0, 0, 11695, + 11696, 7, 17, 0, 0, 11696, 1326, 1, 0, 0, 0, 11697, 11698, 7, 19, 0, 0, + 11698, 11699, 7, 6, 0, 0, 11699, 11700, 7, 0, 0, 0, 11700, 11701, 7, 9, + 0, 0, 11701, 11702, 7, 6, 0, 0, 11702, 11703, 7, 3, 0, 0, 11703, 1328, + 1, 0, 0, 0, 11704, 11705, 7, 19, 0, 0, 11705, 11706, 7, 6, 0, 0, 11706, + 11707, 7, 0, 0, 0, 11707, 11708, 7, 15, 0, 0, 11708, 1330, 1, 0, 0, 0, + 11709, 11710, 7, 19, 0, 0, 11710, 11711, 7, 6, 0, 0, 11711, 11712, 7, 11, + 0, 0, 11712, 11713, 7, 15, 0, 0, 11713, 1332, 1, 0, 0, 0, 11714, 11715, + 7, 19, 0, 0, 11715, 11716, 7, 6, 0, 0, 11716, 11717, 7, 25, 0, 0, 11717, + 11718, 7, 4, 0, 0, 11718, 11719, 7, 2, 0, 0, 11719, 11720, 7, 3, 0, 0, + 11720, 11721, 7, 0, 0, 0, 11721, 11722, 7, 22, 0, 0, 11722, 1334, 1, 0, + 0, 0, 11723, 11724, 7, 19, 0, 0, 11724, 11725, 7, 6, 0, 0, 11725, 11726, + 7, 25, 0, 0, 11726, 11727, 7, 4, 0, 0, 11727, 11728, 7, 2, 0, 0, 11728, + 11729, 7, 3, 0, 0, 11729, 11730, 7, 6, 0, 0, 11730, 11731, 7, 16, 0, 0, + 11731, 1336, 1, 0, 0, 0, 11732, 11733, 7, 19, 0, 0, 11733, 11734, 7, 10, + 0, 0, 11734, 11735, 7, 9, 0, 0, 11735, 11736, 7, 9, 0, 0, 11736, 11737, + 7, 6, 0, 0, 11737, 11738, 7, 7, 0, 0, 11738, 1338, 1, 0, 0, 0, 11739, 11740, + 7, 19, 0, 0, 11740, 11741, 7, 10, 0, 0, 11741, 11742, 7, 9, 0, 0, 11742, + 11743, 7, 6, 0, 0, 11743, 1340, 1, 0, 0, 0, 11744, 11745, 7, 19, 0, 0, + 11745, 11746, 7, 10, 0, 0, 11746, 11747, 7, 6, 0, 0, 11747, 11748, 7, 3, + 0, 0, 11748, 11749, 5, 95, 0, 0, 11749, 11750, 7, 2, 0, 0, 11750, 11751, + 7, 3, 0, 0, 11751, 11752, 7, 9, 0, 0, 11752, 11753, 7, 6, 0, 0, 11753, + 11754, 7, 3, 0, 0, 11754, 1342, 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, 8, 0, 0, 11765, 11766, 7, 0, 0, 0, 11766, 11767, 7, 11, 0, 0, + 11767, 1344, 1, 0, 0, 0, 11768, 11769, 7, 19, 0, 0, 11769, 11770, 7, 10, + 0, 0, 11770, 11771, 7, 6, 0, 0, 11771, 11772, 7, 3, 0, 0, 11772, 11773, + 7, 0, 0, 0, 11773, 11774, 7, 3, 0, 0, 11774, 11775, 7, 8, 0, 0, 11775, + 11776, 7, 19, 0, 0, 11776, 11777, 7, 10, 0, 0, 11777, 11778, 7, 6, 0, 0, + 11778, 11779, 7, 5, 0, 0, 11779, 1346, 1, 0, 0, 0, 11780, 11781, 7, 19, + 0, 0, 11781, 11782, 7, 10, 0, 0, 11782, 11783, 7, 6, 0, 0, 11783, 11784, + 7, 3, 0, 0, 11784, 11785, 7, 0, 0, 0, 11785, 11786, 7, 3, 0, 0, 11786, + 11787, 7, 8, 0, 0, 11787, 11788, 7, 19, 0, 0, 11788, 11789, 7, 18, 0, 0, + 11789, 1348, 1, 0, 0, 0, 11790, 11791, 7, 19, 0, 0, 11791, 11792, 7, 10, + 0, 0, 11792, 11793, 7, 17, 0, 0, 11793, 11794, 7, 19, 0, 0, 11794, 1350, + 1, 0, 0, 0, 11795, 11796, 7, 19, 0, 0, 11796, 11797, 7, 10, 0, 0, 11797, + 11798, 7, 7, 0, 0, 11798, 11799, 7, 4, 0, 0, 11799, 11800, 7, 5, 0, 0, + 11800, 11801, 7, 6, 0, 0, 11801, 11802, 7, 4, 0, 0, 11802, 11803, 5, 95, + 0, 0, 11803, 11804, 7, 1, 0, 0, 11804, 11805, 7, 6, 0, 0, 11805, 11806, + 7, 17, 0, 0, 11806, 11807, 7, 10, 0, 0, 11807, 11808, 7, 7, 0, 0, 11808, + 1352, 1, 0, 0, 0, 11809, 11810, 7, 19, 0, 0, 11810, 11811, 7, 10, 0, 0, + 11811, 11812, 7, 7, 0, 0, 11812, 11813, 7, 4, 0, 0, 11813, 11814, 7, 5, + 0, 0, 11814, 11815, 7, 6, 0, 0, 11815, 11816, 7, 4, 0, 0, 11816, 11817, + 5, 95, 0, 0, 11817, 11818, 7, 6, 0, 0, 11818, 11819, 7, 7, 0, 0, 11819, + 11820, 7, 9, 0, 0, 11820, 1354, 1, 0, 0, 0, 11821, 11822, 7, 19, 0, 0, + 11822, 11823, 7, 2, 0, 0, 11823, 11824, 7, 4, 0, 0, 11824, 1356, 1, 0, + 0, 0, 11825, 11826, 7, 19, 0, 0, 11826, 11827, 7, 2, 0, 0, 11827, 11828, + 7, 12, 0, 0, 11828, 11829, 7, 3, 0, 0, 11829, 1358, 1, 0, 0, 0, 11830, + 11831, 7, 19, 0, 0, 11831, 11832, 7, 2, 0, 0, 11832, 11833, 7, 12, 0, 0, + 11833, 11834, 7, 3, 0, 0, 11834, 11835, 7, 5, 0, 0, 11835, 1360, 1, 0, + 0, 0, 11836, 11837, 7, 19, 0, 0, 11837, 11838, 7, 4, 0, 0, 11838, 11839, + 7, 4, 0, 0, 11839, 11840, 7, 15, 0, 0, 11840, 1362, 1, 0, 0, 0, 11841, + 11842, 7, 19, 0, 0, 11842, 11843, 7, 22, 0, 0, 11843, 11844, 7, 14, 0, + 0, 11844, 11845, 5, 95, 0, 0, 11845, 11846, 7, 1, 0, 0, 11846, 11847, 7, + 3, 0, 0, 11847, 11848, 7, 2, 0, 0, 11848, 11849, 7, 21, 0, 0, 11849, 11850, + 7, 6, 0, 0, 11850, 11851, 7, 3, 0, 0, 11851, 11852, 7, 6, 0, 0, 11852, + 11853, 7, 9, 0, 0, 11853, 1364, 1, 0, 0, 0, 11854, 11855, 7, 19, 0, 0, + 11855, 11856, 7, 18, 0, 0, 11856, 11857, 7, 1, 0, 0, 11857, 11858, 7, 3, + 0, 0, 11858, 11859, 7, 10, 0, 0, 11859, 11860, 7, 9, 0, 0, 11860, 1366, + 1, 0, 0, 0, 11861, 11862, 7, 19, 0, 0, 11862, 1368, 1, 0, 0, 0, 11863, + 11864, 7, 10, 0, 0, 11864, 11865, 7, 9, 0, 0, 11865, 11866, 7, 6, 0, 0, + 11866, 11867, 7, 7, 0, 0, 11867, 11868, 7, 4, 0, 0, 11868, 11869, 7, 10, + 0, 0, 11869, 11870, 7, 16, 0, 0, 11870, 11871, 7, 10, 0, 0, 11871, 11872, + 7, 6, 0, 0, 11872, 11873, 7, 9, 0, 0, 11873, 1370, 1, 0, 0, 0, 11874, 11875, + 7, 10, 0, 0, 11875, 11876, 7, 9, 0, 0, 11876, 11877, 7, 6, 0, 0, 11877, + 11878, 7, 7, 0, 0, 11878, 11879, 7, 4, 0, 0, 11879, 11880, 7, 10, 0, 0, + 11880, 11881, 7, 16, 0, 0, 11881, 11882, 7, 10, 0, 0, 11882, 11883, 7, + 6, 0, 0, 11883, 11884, 7, 3, 0, 0, 11884, 1372, 1, 0, 0, 0, 11885, 11886, + 7, 10, 0, 0, 11886, 11887, 7, 9, 0, 0, 11887, 11888, 7, 6, 0, 0, 11888, + 11889, 7, 7, 0, 0, 11889, 11890, 7, 4, 0, 0, 11890, 11891, 7, 10, 0, 0, + 11891, 11892, 7, 4, 0, 0, 11892, 11893, 7, 18, 0, 0, 11893, 1374, 1, 0, + 0, 0, 11894, 11895, 7, 10, 0, 0, 11895, 11896, 7, 9, 0, 0, 11896, 11897, + 7, 17, 0, 0, 11897, 11898, 7, 6, 0, 0, 11898, 11899, 7, 7, 0, 0, 11899, + 11900, 7, 6, 0, 0, 11900, 11901, 7, 3, 0, 0, 11901, 11902, 7, 0, 0, 0, + 11902, 11903, 7, 4, 0, 0, 11903, 11904, 7, 2, 0, 0, 11904, 11905, 7, 3, + 0, 0, 11905, 11906, 7, 5, 0, 0, 11906, 1376, 1, 0, 0, 0, 11907, 11908, + 7, 10, 0, 0, 11908, 11909, 7, 9, 0, 0, 11909, 1378, 1, 0, 0, 0, 11910, + 11911, 7, 10, 0, 0, 11911, 11912, 7, 9, 0, 0, 11912, 11913, 7, 11, 0, 0, + 11913, 11914, 7, 6, 0, 0, 11914, 11915, 5, 95, 0, 0, 11915, 11916, 7, 4, + 0, 0, 11916, 11917, 7, 10, 0, 0, 11917, 11918, 7, 14, 0, 0, 11918, 11919, + 7, 6, 0, 0, 11919, 1380, 1, 0, 0, 0, 11920, 11921, 7, 10, 0, 0, 11921, + 11922, 7, 16, 0, 0, 11922, 1382, 1, 0, 0, 0, 11923, 11924, 7, 10, 0, 0, + 11924, 11925, 7, 17, 0, 0, 11925, 11926, 7, 7, 0, 0, 11926, 11927, 7, 2, + 0, 0, 11927, 11928, 7, 3, 0, 0, 11928, 11929, 7, 6, 0, 0, 11929, 1384, + 1, 0, 0, 0, 11930, 11931, 7, 10, 0, 0, 11931, 11932, 7, 17, 0, 0, 11932, + 11933, 7, 7, 0, 0, 11933, 11934, 7, 2, 0, 0, 11934, 11935, 7, 3, 0, 0, + 11935, 11936, 7, 6, 0, 0, 11936, 11937, 5, 95, 0, 0, 11937, 11938, 7, 8, + 0, 0, 11938, 11939, 7, 19, 0, 0, 11939, 11940, 7, 0, 0, 0, 11940, 11941, + 7, 3, 0, 0, 11941, 11942, 7, 5, 0, 0, 11942, 11943, 5, 95, 0, 0, 11943, + 11944, 7, 0, 0, 0, 11944, 11945, 7, 16, 0, 0, 11945, 11946, 7, 4, 0, 0, + 11946, 11947, 7, 6, 0, 0, 11947, 11948, 7, 3, 0, 0, 11948, 11949, 5, 95, + 0, 0, 11949, 11950, 7, 6, 0, 0, 11950, 11951, 7, 2, 0, 0, 11951, 11952, + 7, 3, 0, 0, 11952, 1386, 1, 0, 0, 0, 11953, 11954, 7, 10, 0, 0, 11954, + 11955, 7, 17, 0, 0, 11955, 11956, 7, 7, 0, 0, 11956, 11957, 7, 2, 0, 0, + 11957, 11958, 7, 3, 0, 0, 11958, 11959, 7, 6, 0, 0, 11959, 11960, 5, 95, + 0, 0, 11960, 11961, 7, 2, 0, 0, 11961, 11962, 7, 15, 0, 0, 11962, 11963, + 7, 4, 0, 0, 11963, 11964, 7, 10, 0, 0, 11964, 11965, 7, 14, 0, 0, 11965, + 11966, 5, 95, 0, 0, 11966, 11967, 7, 6, 0, 0, 11967, 11968, 7, 14, 0, 0, + 11968, 11969, 7, 1, 0, 0, 11969, 11970, 7, 6, 0, 0, 11970, 11971, 7, 9, + 0, 0, 11971, 11972, 7, 9, 0, 0, 11972, 11973, 7, 6, 0, 0, 11973, 11974, + 7, 9, 0, 0, 11974, 11975, 5, 95, 0, 0, 11975, 11976, 7, 19, 0, 0, 11976, + 11977, 7, 10, 0, 0, 11977, 11978, 7, 7, 0, 0, 11978, 11979, 7, 4, 0, 0, + 11979, 11980, 7, 5, 0, 0, 11980, 1388, 1, 0, 0, 0, 11981, 11982, 7, 10, + 0, 0, 11982, 11983, 7, 17, 0, 0, 11983, 11984, 7, 7, 0, 0, 11984, 11985, + 7, 2, 0, 0, 11985, 11986, 7, 3, 0, 0, 11986, 11987, 7, 6, 0, 0, 11987, + 11988, 5, 95, 0, 0, 11988, 11989, 7, 3, 0, 0, 11989, 11990, 7, 2, 0, 0, + 11990, 11991, 7, 22, 0, 0, 11991, 11992, 5, 95, 0, 0, 11992, 11993, 7, + 2, 0, 0, 11993, 11994, 7, 7, 0, 0, 11994, 11995, 5, 95, 0, 0, 11995, 11996, + 7, 9, 0, 0, 11996, 11997, 7, 12, 0, 0, 11997, 11998, 7, 15, 0, 0, 11998, + 11999, 7, 21, 0, 0, 11999, 12000, 7, 6, 0, 0, 12000, 12001, 7, 18, 0, 0, + 12001, 12002, 5, 95, 0, 0, 12002, 12003, 7, 10, 0, 0, 12003, 12004, 7, + 7, 0, 0, 12004, 12005, 7, 9, 0, 0, 12005, 12006, 7, 6, 0, 0, 12006, 12007, + 7, 25, 0, 0, 12007, 1390, 1, 0, 0, 0, 12008, 12009, 7, 10, 0, 0, 12009, + 12010, 7, 17, 0, 0, 12010, 12011, 7, 7, 0, 0, 12011, 12012, 7, 2, 0, 0, + 12012, 12013, 7, 3, 0, 0, 12013, 12014, 7, 6, 0, 0, 12014, 12015, 5, 95, + 0, 0, 12015, 12016, 7, 22, 0, 0, 12016, 12017, 7, 19, 0, 0, 12017, 12018, + 7, 6, 0, 0, 12018, 12019, 7, 3, 0, 0, 12019, 12020, 7, 6, 0, 0, 12020, + 12021, 5, 95, 0, 0, 12021, 12022, 7, 8, 0, 0, 12022, 12023, 7, 11, 0, 0, + 12023, 12024, 7, 0, 0, 0, 12024, 12025, 7, 12, 0, 0, 12025, 12026, 7, 5, + 0, 0, 12026, 12027, 7, 6, 0, 0, 12027, 1392, 1, 0, 0, 0, 12028, 12029, + 7, 10, 0, 0, 12029, 12030, 7, 11, 0, 0, 12030, 12031, 7, 14, 0, 0, 12031, + 1394, 1, 0, 0, 0, 12032, 12033, 7, 10, 0, 0, 12033, 12034, 7, 14, 0, 0, + 12034, 12035, 7, 14, 0, 0, 12035, 12036, 7, 6, 0, 0, 12036, 12037, 7, 9, + 0, 0, 12037, 12038, 7, 10, 0, 0, 12038, 12039, 7, 0, 0, 0, 12039, 12040, + 7, 4, 0, 0, 12040, 12041, 7, 6, 0, 0, 12041, 1396, 1, 0, 0, 0, 12042, 12043, + 7, 10, 0, 0, 12043, 12044, 7, 14, 0, 0, 12044, 12045, 7, 15, 0, 0, 12045, + 12046, 7, 0, 0, 0, 12046, 12047, 7, 8, 0, 0, 12047, 12048, 7, 4, 0, 0, + 12048, 1398, 1, 0, 0, 0, 12049, 12050, 7, 10, 0, 0, 12050, 12051, 7, 14, + 0, 0, 12051, 12052, 7, 15, 0, 0, 12052, 12053, 7, 2, 0, 0, 12053, 12054, + 7, 3, 0, 0, 12054, 12055, 7, 4, 0, 0, 12055, 1400, 1, 0, 0, 0, 12056, 12057, + 7, 10, 0, 0, 12057, 12058, 7, 7, 0, 0, 12058, 12059, 7, 0, 0, 0, 12059, + 12060, 7, 8, 0, 0, 12060, 12061, 7, 4, 0, 0, 12061, 12062, 7, 10, 0, 0, + 12062, 12063, 7, 13, 0, 0, 12063, 12064, 7, 6, 0, 0, 12064, 1402, 1, 0, + 0, 0, 12065, 12066, 7, 10, 0, 0, 12066, 12067, 7, 7, 0, 0, 12067, 12068, + 7, 0, 0, 0, 12068, 12069, 7, 8, 0, 0, 12069, 12070, 7, 4, 0, 0, 12070, + 12071, 7, 10, 0, 0, 12071, 12072, 7, 13, 0, 0, 12072, 12073, 7, 6, 0, 0, + 12073, 12074, 5, 95, 0, 0, 12074, 12075, 7, 0, 0, 0, 12075, 12076, 7, 8, + 0, 0, 12076, 12077, 7, 8, 0, 0, 12077, 12078, 7, 2, 0, 0, 12078, 12079, + 7, 12, 0, 0, 12079, 12080, 7, 7, 0, 0, 12080, 12081, 7, 4, 0, 0, 12081, + 12082, 5, 95, 0, 0, 12082, 12083, 7, 4, 0, 0, 12083, 12084, 7, 10, 0, 0, + 12084, 12085, 7, 14, 0, 0, 12085, 12086, 7, 6, 0, 0, 12086, 1404, 1, 0, + 0, 0, 12087, 12088, 7, 10, 0, 0, 12088, 12089, 7, 7, 0, 0, 12089, 12090, + 7, 8, 0, 0, 12090, 12091, 7, 11, 0, 0, 12091, 12092, 7, 12, 0, 0, 12092, + 12093, 7, 9, 0, 0, 12093, 12094, 7, 6, 0, 0, 12094, 1406, 1, 0, 0, 0, 12095, + 12096, 7, 10, 0, 0, 12096, 12097, 7, 7, 0, 0, 12097, 12098, 7, 8, 0, 0, + 12098, 12099, 7, 11, 0, 0, 12099, 12100, 7, 12, 0, 0, 12100, 12101, 7, + 9, 0, 0, 12101, 12102, 7, 6, 0, 0, 12102, 12103, 5, 95, 0, 0, 12103, 12104, + 7, 13, 0, 0, 12104, 12105, 7, 6, 0, 0, 12105, 12106, 7, 3, 0, 0, 12106, + 12107, 7, 5, 0, 0, 12107, 12108, 7, 10, 0, 0, 12108, 12109, 7, 2, 0, 0, + 12109, 12110, 7, 7, 0, 0, 12110, 1408, 1, 0, 0, 0, 12111, 12112, 7, 10, + 0, 0, 12112, 12113, 7, 7, 0, 0, 12113, 12114, 7, 8, 0, 0, 12114, 12115, + 7, 11, 0, 0, 12115, 12116, 7, 12, 0, 0, 12116, 12117, 7, 9, 0, 0, 12117, + 12118, 7, 10, 0, 0, 12118, 12119, 7, 7, 0, 0, 12119, 12120, 7, 17, 0, 0, + 12120, 1410, 1, 0, 0, 0, 12121, 12122, 7, 10, 0, 0, 12122, 12123, 7, 7, + 0, 0, 12123, 12124, 7, 8, 0, 0, 12124, 12125, 7, 3, 0, 0, 12125, 12126, + 7, 6, 0, 0, 12126, 12127, 7, 14, 0, 0, 12127, 12128, 7, 6, 0, 0, 12128, + 12129, 7, 7, 0, 0, 12129, 12130, 7, 4, 0, 0, 12130, 12131, 7, 0, 0, 0, + 12131, 12132, 7, 11, 0, 0, 12132, 1412, 1, 0, 0, 0, 12133, 12134, 7, 10, + 0, 0, 12134, 12135, 7, 7, 0, 0, 12135, 12136, 7, 8, 0, 0, 12136, 12137, + 7, 3, 0, 0, 12137, 12138, 7, 6, 0, 0, 12138, 12139, 7, 14, 0, 0, 12139, + 12140, 7, 6, 0, 0, 12140, 12141, 7, 7, 0, 0, 12141, 12142, 7, 4, 0, 0, + 12142, 1414, 1, 0, 0, 0, 12143, 12144, 7, 10, 0, 0, 12144, 12145, 7, 7, + 0, 0, 12145, 12146, 7, 8, 0, 0, 12146, 12147, 7, 3, 0, 0, 12147, 1416, + 1, 0, 0, 0, 12148, 12149, 7, 10, 0, 0, 12149, 12150, 7, 7, 0, 0, 12150, + 12151, 7, 9, 0, 0, 12151, 12152, 7, 6, 0, 0, 12152, 12153, 7, 7, 0, 0, + 12153, 12154, 7, 4, 0, 0, 12154, 1418, 1, 0, 0, 0, 12155, 12156, 7, 10, + 0, 0, 12156, 12157, 7, 7, 0, 0, 12157, 12158, 7, 9, 0, 0, 12158, 12159, + 7, 6, 0, 0, 12159, 12160, 7, 25, 0, 0, 12160, 12161, 5, 95, 0, 0, 12161, + 12162, 7, 0, 0, 0, 12162, 12163, 7, 5, 0, 0, 12163, 12164, 7, 8, 0, 0, + 12164, 1420, 1, 0, 0, 0, 12165, 12166, 7, 10, 0, 0, 12166, 12167, 7, 7, + 0, 0, 12167, 12168, 7, 9, 0, 0, 12168, 12169, 7, 6, 0, 0, 12169, 12170, + 7, 25, 0, 0, 12170, 12171, 5, 95, 0, 0, 12171, 12172, 7, 8, 0, 0, 12172, + 12173, 7, 2, 0, 0, 12173, 12174, 7, 14, 0, 0, 12174, 12175, 7, 1, 0, 0, + 12175, 12176, 7, 10, 0, 0, 12176, 12177, 7, 7, 0, 0, 12177, 12178, 7, 6, + 0, 0, 12178, 1422, 1, 0, 0, 0, 12179, 12180, 7, 10, 0, 0, 12180, 12181, + 7, 7, 0, 0, 12181, 12182, 7, 9, 0, 0, 12182, 12183, 7, 6, 0, 0, 12183, + 12184, 7, 25, 0, 0, 12184, 12185, 5, 95, 0, 0, 12185, 12186, 7, 9, 0, 0, + 12186, 12187, 7, 6, 0, 0, 12187, 12188, 7, 5, 0, 0, 12188, 12189, 7, 8, + 0, 0, 12189, 1424, 1, 0, 0, 0, 12190, 12191, 7, 10, 0, 0, 12191, 12192, + 7, 7, 0, 0, 12192, 12193, 7, 9, 0, 0, 12193, 12194, 7, 6, 0, 0, 12194, + 12195, 7, 25, 0, 0, 12195, 12196, 7, 6, 0, 0, 12196, 12197, 7, 9, 0, 0, + 12197, 1426, 1, 0, 0, 0, 12198, 12199, 7, 10, 0, 0, 12199, 12200, 7, 7, + 0, 0, 12200, 12201, 7, 9, 0, 0, 12201, 12202, 7, 6, 0, 0, 12202, 12203, + 7, 25, 0, 0, 12203, 12204, 7, 6, 0, 0, 12204, 12205, 7, 5, 0, 0, 12205, + 1428, 1, 0, 0, 0, 12206, 12207, 7, 10, 0, 0, 12207, 12208, 7, 7, 0, 0, + 12208, 12209, 7, 9, 0, 0, 12209, 12210, 7, 6, 0, 0, 12210, 12211, 7, 25, + 0, 0, 12211, 12212, 5, 95, 0, 0, 12212, 12213, 7, 16, 0, 0, 12213, 12214, + 7, 16, 0, 0, 12214, 12215, 7, 5, 0, 0, 12215, 1430, 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, 12222, 5, 95, + 0, 0, 12222, 12223, 7, 16, 0, 0, 12223, 12224, 7, 10, 0, 0, 12224, 12225, + 7, 11, 0, 0, 12225, 12226, 7, 4, 0, 0, 12226, 12227, 7, 6, 0, 0, 12227, + 12228, 7, 3, 0, 0, 12228, 1432, 1, 0, 0, 0, 12229, 12230, 7, 10, 0, 0, + 12230, 12231, 7, 7, 0, 0, 12231, 12232, 7, 9, 0, 0, 12232, 12233, 7, 6, + 0, 0, 12233, 12234, 7, 25, 0, 0, 12234, 1434, 1, 0, 0, 0, 12235, 12236, + 7, 10, 0, 0, 12236, 12237, 7, 7, 0, 0, 12237, 12238, 7, 9, 0, 0, 12238, + 12239, 7, 6, 0, 0, 12239, 12240, 7, 25, 0, 0, 12240, 12241, 7, 10, 0, 0, + 12241, 12242, 7, 7, 0, 0, 12242, 12243, 7, 17, 0, 0, 12243, 1436, 1, 0, + 0, 0, 12244, 12245, 7, 10, 0, 0, 12245, 12246, 7, 7, 0, 0, 12246, 12247, + 7, 9, 0, 0, 12247, 12248, 7, 6, 0, 0, 12248, 12249, 7, 25, 0, 0, 12249, + 12250, 5, 95, 0, 0, 12250, 12251, 7, 20, 0, 0, 12251, 12252, 7, 2, 0, 0, + 12252, 12253, 7, 10, 0, 0, 12253, 12254, 7, 7, 0, 0, 12254, 1438, 1, 0, + 0, 0, 12255, 12256, 7, 10, 0, 0, 12256, 12257, 7, 7, 0, 0, 12257, 12258, + 7, 9, 0, 0, 12258, 12259, 7, 6, 0, 0, 12259, 12260, 7, 25, 0, 0, 12260, + 12261, 5, 95, 0, 0, 12261, 12262, 7, 3, 0, 0, 12262, 12263, 7, 2, 0, 0, + 12263, 12264, 7, 22, 0, 0, 12264, 12265, 7, 5, 0, 0, 12265, 1440, 1, 0, + 0, 0, 12266, 12267, 7, 10, 0, 0, 12267, 12268, 7, 7, 0, 0, 12268, 12269, + 7, 9, 0, 0, 12269, 12270, 7, 6, 0, 0, 12270, 12271, 7, 25, 0, 0, 12271, + 12272, 5, 95, 0, 0, 12272, 12273, 7, 3, 0, 0, 12273, 12274, 7, 3, 0, 0, + 12274, 12275, 7, 5, 0, 0, 12275, 1442, 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, 0, 0, 0, 12286, 12287, 7, 5, 0, 0, 12287, 12288, 7, 8, + 0, 0, 12288, 1444, 1, 0, 0, 0, 12289, 12290, 7, 10, 0, 0, 12290, 12291, + 7, 7, 0, 0, 12291, 12292, 7, 9, 0, 0, 12292, 12293, 7, 6, 0, 0, 12293, + 12294, 7, 25, 0, 0, 12294, 12295, 5, 95, 0, 0, 12295, 12296, 7, 3, 0, 0, + 12296, 12297, 7, 5, 0, 0, 12297, 12298, 5, 95, 0, 0, 12298, 12299, 7, 9, + 0, 0, 12299, 12300, 7, 6, 0, 0, 12300, 12301, 7, 5, 0, 0, 12301, 12302, + 7, 8, 0, 0, 12302, 1446, 1, 0, 0, 0, 12303, 12304, 7, 10, 0, 0, 12304, + 12305, 7, 7, 0, 0, 12305, 12306, 7, 9, 0, 0, 12306, 12307, 7, 6, 0, 0, + 12307, 12308, 7, 25, 0, 0, 12308, 12309, 5, 95, 0, 0, 12309, 12310, 7, + 3, 0, 0, 12310, 12311, 7, 5, 0, 0, 12311, 1448, 1, 0, 0, 0, 12312, 12313, + 7, 10, 0, 0, 12313, 12314, 7, 7, 0, 0, 12314, 12315, 7, 9, 0, 0, 12315, + 12316, 7, 6, 0, 0, 12316, 12317, 7, 25, 0, 0, 12317, 12318, 5, 95, 0, 0, + 12318, 12319, 7, 5, 0, 0, 12319, 12320, 7, 8, 0, 0, 12320, 12321, 7, 0, + 0, 0, 12321, 12322, 7, 7, 0, 0, 12322, 1450, 1, 0, 0, 0, 12323, 12324, + 7, 10, 0, 0, 12324, 12325, 7, 7, 0, 0, 12325, 12326, 7, 9, 0, 0, 12326, + 12327, 7, 6, 0, 0, 12327, 12328, 7, 25, 0, 0, 12328, 12329, 5, 95, 0, 0, + 12329, 12330, 7, 5, 0, 0, 12330, 12331, 7, 21, 0, 0, 12331, 12332, 7, 10, + 0, 0, 12332, 12333, 7, 15, 0, 0, 12333, 12334, 5, 95, 0, 0, 12334, 12335, + 7, 5, 0, 0, 12335, 12336, 7, 8, 0, 0, 12336, 12337, 7, 0, 0, 0, 12337, + 12338, 7, 7, 0, 0, 12338, 1452, 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, 0, 0, 0, 12349, 12350, 7, 5, 0, 0, 12350, 12351, 7, 8, 0, 0, + 12351, 1454, 1, 0, 0, 0, 12352, 12353, 7, 10, 0, 0, 12353, 12354, 7, 7, + 0, 0, 12354, 12355, 7, 9, 0, 0, 12355, 12356, 7, 6, 0, 0, 12356, 12357, + 7, 25, 0, 0, 12357, 12358, 5, 95, 0, 0, 12358, 12359, 7, 5, 0, 0, 12359, + 12360, 7, 5, 0, 0, 12360, 12361, 5, 95, 0, 0, 12361, 12362, 7, 9, 0, 0, + 12362, 12363, 7, 6, 0, 0, 12363, 12364, 7, 5, 0, 0, 12364, 12365, 7, 8, + 0, 0, 12365, 1456, 1, 0, 0, 0, 12366, 12367, 7, 10, 0, 0, 12367, 12368, + 7, 7, 0, 0, 12368, 12369, 7, 9, 0, 0, 12369, 12370, 7, 6, 0, 0, 12370, + 12371, 7, 25, 0, 0, 12371, 12372, 5, 95, 0, 0, 12372, 12373, 7, 5, 0, 0, + 12373, 12374, 7, 5, 0, 0, 12374, 1458, 1, 0, 0, 0, 12375, 12376, 7, 10, + 0, 0, 12376, 12377, 7, 7, 0, 0, 12377, 12378, 7, 9, 0, 0, 12378, 12379, + 7, 6, 0, 0, 12379, 12380, 7, 25, 0, 0, 12380, 12381, 5, 95, 0, 0, 12381, + 12382, 7, 5, 0, 0, 12382, 12383, 7, 4, 0, 0, 12383, 12384, 7, 0, 0, 0, + 12384, 12385, 7, 4, 0, 0, 12385, 12386, 7, 5, 0, 0, 12386, 1460, 1, 0, + 0, 0, 12387, 12388, 7, 10, 0, 0, 12388, 12389, 7, 7, 0, 0, 12389, 12390, + 7, 9, 0, 0, 12390, 12391, 7, 6, 0, 0, 12391, 12392, 7, 25, 0, 0, 12392, + 12393, 7, 4, 0, 0, 12393, 12394, 7, 18, 0, 0, 12394, 12395, 7, 15, 0, 0, + 12395, 12396, 7, 6, 0, 0, 12396, 1462, 1, 0, 0, 0, 12397, 12398, 7, 10, + 0, 0, 12398, 12399, 7, 7, 0, 0, 12399, 12400, 7, 9, 0, 0, 12400, 12401, + 7, 6, 0, 0, 12401, 12402, 7, 25, 0, 0, 12402, 12403, 7, 4, 0, 0, 12403, + 12404, 7, 18, 0, 0, 12404, 12405, 7, 15, 0, 0, 12405, 12406, 7, 6, 0, 0, + 12406, 12407, 7, 5, 0, 0, 12407, 1464, 1, 0, 0, 0, 12408, 12409, 7, 10, + 0, 0, 12409, 12410, 7, 7, 0, 0, 12410, 12411, 7, 9, 0, 0, 12411, 12412, + 7, 10, 0, 0, 12412, 12413, 7, 8, 0, 0, 12413, 12414, 7, 0, 0, 0, 12414, + 12415, 7, 4, 0, 0, 12415, 12416, 7, 2, 0, 0, 12416, 12417, 7, 3, 0, 0, + 12417, 1466, 1, 0, 0, 0, 12418, 12419, 7, 10, 0, 0, 12419, 12420, 7, 7, + 0, 0, 12420, 12421, 7, 9, 0, 0, 12421, 12422, 7, 10, 0, 0, 12422, 12423, + 7, 8, 0, 0, 12423, 12424, 7, 6, 0, 0, 12424, 12425, 7, 5, 0, 0, 12425, + 1468, 1, 0, 0, 0, 12426, 12427, 7, 10, 0, 0, 12427, 12428, 7, 7, 0, 0, + 12428, 12429, 7, 16, 0, 0, 12429, 12430, 7, 10, 0, 0, 12430, 12431, 7, + 7, 0, 0, 12431, 12432, 7, 10, 0, 0, 12432, 12433, 7, 4, 0, 0, 12433, 12434, + 7, 6, 0, 0, 12434, 1470, 1, 0, 0, 0, 12435, 12436, 7, 10, 0, 0, 12436, + 12437, 7, 7, 0, 0, 12437, 12438, 7, 16, 0, 0, 12438, 12439, 7, 2, 0, 0, + 12439, 12440, 7, 3, 0, 0, 12440, 12441, 7, 14, 0, 0, 12441, 12442, 7, 0, + 0, 0, 12442, 12443, 7, 4, 0, 0, 12443, 12444, 7, 10, 0, 0, 12444, 12445, + 7, 2, 0, 0, 12445, 12446, 7, 7, 0, 0, 12446, 12447, 7, 0, 0, 0, 12447, + 12448, 7, 11, 0, 0, 12448, 1472, 1, 0, 0, 0, 12449, 12450, 7, 10, 0, 0, + 12450, 12451, 7, 7, 0, 0, 12451, 12452, 7, 19, 0, 0, 12452, 12453, 7, 6, + 0, 0, 12453, 12454, 7, 3, 0, 0, 12454, 12455, 7, 10, 0, 0, 12455, 12456, + 7, 4, 0, 0, 12456, 1474, 1, 0, 0, 0, 12457, 12458, 7, 10, 0, 0, 12458, + 12459, 7, 7, 0, 0, 12459, 1476, 1, 0, 0, 0, 12460, 12461, 7, 10, 0, 0, + 12461, 12462, 7, 7, 0, 0, 12462, 12463, 7, 10, 0, 0, 12463, 12464, 7, 4, + 0, 0, 12464, 12465, 7, 8, 0, 0, 12465, 12466, 7, 0, 0, 0, 12466, 12467, + 7, 15, 0, 0, 12467, 1478, 1, 0, 0, 0, 12468, 12469, 7, 10, 0, 0, 12469, + 12470, 7, 7, 0, 0, 12470, 12471, 7, 10, 0, 0, 12471, 12472, 7, 4, 0, 0, + 12472, 12473, 7, 10, 0, 0, 12473, 12474, 7, 0, 0, 0, 12474, 12475, 7, 11, + 0, 0, 12475, 1480, 1, 0, 0, 0, 12476, 12477, 7, 10, 0, 0, 12477, 12478, + 7, 7, 0, 0, 12478, 12479, 7, 10, 0, 0, 12479, 12480, 7, 4, 0, 0, 12480, + 12481, 7, 10, 0, 0, 12481, 12482, 7, 0, 0, 0, 12482, 12483, 7, 11, 0, 0, + 12483, 12484, 7, 10, 0, 0, 12484, 12485, 7, 23, 0, 0, 12485, 12486, 7, + 6, 0, 0, 12486, 12487, 7, 9, 0, 0, 12487, 1482, 1, 0, 0, 0, 12488, 12489, + 7, 10, 0, 0, 12489, 12490, 7, 7, 0, 0, 12490, 12491, 7, 10, 0, 0, 12491, + 12492, 7, 4, 0, 0, 12492, 12493, 7, 10, 0, 0, 12493, 12494, 7, 0, 0, 0, + 12494, 12495, 7, 11, 0, 0, 12495, 12496, 7, 11, 0, 0, 12496, 12497, 7, + 18, 0, 0, 12497, 1484, 1, 0, 0, 0, 12498, 12499, 7, 10, 0, 0, 12499, 12500, + 7, 7, 0, 0, 12500, 12501, 7, 10, 0, 0, 12501, 12502, 7, 4, 0, 0, 12502, + 12503, 7, 3, 0, 0, 12503, 12504, 7, 0, 0, 0, 12504, 12505, 7, 7, 0, 0, + 12505, 12506, 7, 5, 0, 0, 12506, 1486, 1, 0, 0, 0, 12507, 12508, 7, 10, + 0, 0, 12508, 12509, 7, 7, 0, 0, 12509, 12510, 7, 11, 0, 0, 12510, 12511, + 7, 10, 0, 0, 12511, 12512, 7, 7, 0, 0, 12512, 12513, 7, 6, 0, 0, 12513, + 1488, 1, 0, 0, 0, 12514, 12515, 7, 10, 0, 0, 12515, 12516, 7, 7, 0, 0, + 12516, 12517, 7, 11, 0, 0, 12517, 12518, 7, 10, 0, 0, 12518, 12519, 7, + 7, 0, 0, 12519, 12520, 7, 6, 0, 0, 12520, 12521, 5, 95, 0, 0, 12521, 12522, + 7, 25, 0, 0, 12522, 12523, 7, 14, 0, 0, 12523, 12524, 7, 11, 0, 0, 12524, + 12525, 7, 4, 0, 0, 12525, 12526, 7, 18, 0, 0, 12526, 12527, 7, 15, 0, 0, + 12527, 12528, 7, 6, 0, 0, 12528, 12529, 5, 95, 0, 0, 12529, 12530, 7, 7, + 0, 0, 12530, 12531, 7, 4, 0, 0, 12531, 1490, 1, 0, 0, 0, 12532, 12533, + 7, 10, 0, 0, 12533, 12534, 7, 7, 0, 0, 12534, 12535, 7, 14, 0, 0, 12535, + 12536, 7, 6, 0, 0, 12536, 12537, 7, 14, 0, 0, 12537, 12538, 7, 2, 0, 0, + 12538, 12539, 7, 3, 0, 0, 12539, 12540, 7, 18, 0, 0, 12540, 1492, 1, 0, + 0, 0, 12541, 12542, 7, 10, 0, 0, 12542, 12543, 7, 7, 0, 0, 12543, 12544, + 5, 95, 0, 0, 12544, 12545, 7, 14, 0, 0, 12545, 12546, 7, 6, 0, 0, 12546, + 12547, 7, 14, 0, 0, 12547, 12548, 7, 2, 0, 0, 12548, 12549, 7, 3, 0, 0, + 12549, 12550, 7, 18, 0, 0, 12550, 12551, 5, 95, 0, 0, 12551, 12552, 7, + 14, 0, 0, 12552, 12553, 7, 6, 0, 0, 12553, 12554, 7, 4, 0, 0, 12554, 12555, + 7, 0, 0, 0, 12555, 12556, 7, 9, 0, 0, 12556, 12557, 7, 0, 0, 0, 12557, + 12558, 7, 4, 0, 0, 12558, 12559, 7, 0, 0, 0, 12559, 1494, 1, 0, 0, 0, 12560, + 12561, 7, 10, 0, 0, 12561, 12562, 7, 7, 0, 0, 12562, 12563, 7, 14, 0, 0, + 12563, 12564, 7, 6, 0, 0, 12564, 12565, 7, 14, 0, 0, 12565, 12566, 7, 2, + 0, 0, 12566, 12567, 7, 3, 0, 0, 12567, 12568, 7, 18, 0, 0, 12568, 12569, + 5, 95, 0, 0, 12569, 12570, 7, 15, 0, 0, 12570, 12571, 7, 3, 0, 0, 12571, + 12572, 7, 12, 0, 0, 12572, 12573, 7, 7, 0, 0, 12573, 12574, 7, 10, 0, 0, + 12574, 12575, 7, 7, 0, 0, 12575, 12576, 7, 17, 0, 0, 12576, 1496, 1, 0, + 0, 0, 12577, 12578, 7, 10, 0, 0, 12578, 12579, 7, 7, 0, 0, 12579, 12580, + 7, 7, 0, 0, 12580, 12581, 7, 6, 0, 0, 12581, 12582, 7, 3, 0, 0, 12582, + 1498, 1, 0, 0, 0, 12583, 12584, 7, 10, 0, 0, 12584, 12585, 7, 7, 0, 0, + 12585, 12586, 7, 2, 0, 0, 12586, 12587, 7, 12, 0, 0, 12587, 12588, 7, 4, + 0, 0, 12588, 1500, 1, 0, 0, 0, 12589, 12590, 7, 10, 0, 0, 12590, 12591, + 7, 7, 0, 0, 12591, 12592, 7, 15, 0, 0, 12592, 12593, 7, 11, 0, 0, 12593, + 12594, 7, 0, 0, 0, 12594, 12595, 7, 8, 0, 0, 12595, 12596, 7, 6, 0, 0, + 12596, 1502, 1, 0, 0, 0, 12597, 12598, 7, 10, 0, 0, 12598, 12599, 7, 7, + 0, 0, 12599, 12600, 7, 15, 0, 0, 12600, 12601, 7, 12, 0, 0, 12601, 12602, + 7, 4, 0, 0, 12602, 12603, 7, 16, 0, 0, 12603, 12604, 7, 2, 0, 0, 12604, + 12605, 7, 3, 0, 0, 12605, 12606, 7, 14, 0, 0, 12606, 12607, 7, 0, 0, 0, + 12607, 12608, 7, 4, 0, 0, 12608, 1504, 1, 0, 0, 0, 12609, 12610, 7, 10, + 0, 0, 12610, 12611, 7, 7, 0, 0, 12611, 12612, 7, 5, 0, 0, 12612, 12613, + 7, 6, 0, 0, 12613, 12614, 7, 3, 0, 0, 12614, 12615, 7, 4, 0, 0, 12615, + 12616, 7, 8, 0, 0, 12616, 12617, 7, 19, 0, 0, 12617, 12618, 7, 10, 0, 0, + 12618, 12619, 7, 11, 0, 0, 12619, 12620, 7, 9, 0, 0, 12620, 12621, 7, 25, + 0, 0, 12621, 12622, 7, 14, 0, 0, 12622, 12623, 7, 11, 0, 0, 12623, 12624, + 7, 0, 0, 0, 12624, 12625, 7, 16, 0, 0, 12625, 12626, 7, 4, 0, 0, 12626, + 12627, 7, 6, 0, 0, 12627, 12628, 7, 3, 0, 0, 12628, 1506, 1, 0, 0, 0, 12629, + 12630, 7, 10, 0, 0, 12630, 12631, 7, 7, 0, 0, 12631, 12632, 7, 5, 0, 0, + 12632, 12633, 7, 6, 0, 0, 12633, 12634, 7, 3, 0, 0, 12634, 12635, 7, 4, + 0, 0, 12635, 12636, 7, 8, 0, 0, 12636, 12637, 7, 19, 0, 0, 12637, 12638, + 7, 10, 0, 0, 12638, 12639, 7, 11, 0, 0, 12639, 12640, 7, 9, 0, 0, 12640, + 12641, 7, 25, 0, 0, 12641, 12642, 7, 14, 0, 0, 12642, 12643, 7, 11, 0, + 0, 12643, 12644, 7, 1, 0, 0, 12644, 12645, 7, 6, 0, 0, 12645, 12646, 7, + 16, 0, 0, 12646, 12647, 7, 2, 0, 0, 12647, 12648, 7, 3, 0, 0, 12648, 12649, + 7, 6, 0, 0, 12649, 1508, 1, 0, 0, 0, 12650, 12651, 7, 10, 0, 0, 12651, + 12652, 7, 7, 0, 0, 12652, 12653, 7, 5, 0, 0, 12653, 12654, 7, 6, 0, 0, + 12654, 12655, 7, 3, 0, 0, 12655, 12656, 7, 4, 0, 0, 12656, 12657, 7, 8, + 0, 0, 12657, 12658, 7, 19, 0, 0, 12658, 12659, 7, 10, 0, 0, 12659, 12660, + 7, 11, 0, 0, 12660, 12661, 7, 9, 0, 0, 12661, 12662, 7, 25, 0, 0, 12662, + 12663, 7, 14, 0, 0, 12663, 12664, 7, 11, 0, 0, 12664, 1510, 1, 0, 0, 0, + 12665, 12666, 7, 10, 0, 0, 12666, 12667, 7, 7, 0, 0, 12667, 12668, 7, 5, + 0, 0, 12668, 12669, 7, 6, 0, 0, 12669, 12670, 7, 3, 0, 0, 12670, 12671, + 7, 4, 0, 0, 12671, 1512, 1, 0, 0, 0, 12672, 12673, 7, 10, 0, 0, 12673, + 12674, 7, 7, 0, 0, 12674, 12675, 7, 5, 0, 0, 12675, 12676, 7, 6, 0, 0, + 12676, 12677, 7, 3, 0, 0, 12677, 12678, 7, 4, 0, 0, 12678, 12679, 7, 25, + 0, 0, 12679, 12680, 7, 14, 0, 0, 12680, 12681, 7, 11, 0, 0, 12681, 12682, + 7, 0, 0, 0, 12682, 12683, 7, 16, 0, 0, 12683, 12684, 7, 4, 0, 0, 12684, + 12685, 7, 6, 0, 0, 12685, 12686, 7, 3, 0, 0, 12686, 1514, 1, 0, 0, 0, 12687, + 12688, 7, 10, 0, 0, 12688, 12689, 7, 7, 0, 0, 12689, 12690, 7, 5, 0, 0, + 12690, 12691, 7, 6, 0, 0, 12691, 12692, 7, 3, 0, 0, 12692, 12693, 7, 4, + 0, 0, 12693, 12694, 7, 25, 0, 0, 12694, 12695, 7, 14, 0, 0, 12695, 12696, + 7, 11, 0, 0, 12696, 12697, 7, 1, 0, 0, 12697, 12698, 7, 6, 0, 0, 12698, + 12699, 7, 16, 0, 0, 12699, 12700, 7, 2, 0, 0, 12700, 12701, 7, 3, 0, 0, + 12701, 12702, 7, 6, 0, 0, 12702, 1516, 1, 0, 0, 0, 12703, 12704, 7, 10, + 0, 0, 12704, 12705, 7, 7, 0, 0, 12705, 12706, 7, 5, 0, 0, 12706, 12707, + 7, 4, 0, 0, 12707, 12708, 7, 0, 0, 0, 12708, 12709, 7, 7, 0, 0, 12709, + 12710, 7, 8, 0, 0, 12710, 12711, 7, 6, 0, 0, 12711, 1518, 1, 0, 0, 0, 12712, + 12713, 7, 10, 0, 0, 12713, 12714, 7, 7, 0, 0, 12714, 12715, 7, 5, 0, 0, + 12715, 12716, 7, 4, 0, 0, 12716, 12717, 7, 0, 0, 0, 12717, 12718, 7, 7, + 0, 0, 12718, 12719, 7, 8, 0, 0, 12719, 12720, 7, 6, 0, 0, 12720, 12721, + 7, 5, 0, 0, 12721, 1520, 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, 10, 0, 0, 12730, 12731, 7, 0, 0, 0, 12731, 12732, + 7, 1, 0, 0, 12732, 12733, 7, 11, 0, 0, 12733, 12734, 7, 6, 0, 0, 12734, + 1522, 1, 0, 0, 0, 12735, 12736, 7, 10, 0, 0, 12736, 12737, 7, 7, 0, 0, + 12737, 12738, 7, 5, 0, 0, 12738, 12739, 7, 4, 0, 0, 12739, 12740, 7, 0, + 0, 0, 12740, 12741, 7, 7, 0, 0, 12741, 12742, 7, 4, 0, 0, 12742, 12743, + 7, 11, 0, 0, 12743, 12744, 7, 18, 0, 0, 12744, 1524, 1, 0, 0, 0, 12745, + 12746, 7, 10, 0, 0, 12746, 12747, 7, 7, 0, 0, 12747, 12748, 7, 5, 0, 0, + 12748, 12749, 7, 4, 0, 0, 12749, 12750, 7, 6, 0, 0, 12750, 12751, 7, 0, + 0, 0, 12751, 12752, 7, 9, 0, 0, 12752, 1526, 1, 0, 0, 0, 12753, 12754, + 7, 10, 0, 0, 12754, 12755, 7, 7, 0, 0, 12755, 12756, 7, 5, 0, 0, 12756, + 12757, 7, 4, 0, 0, 12757, 12758, 7, 3, 0, 0, 12758, 12759, 5, 50, 0, 0, + 12759, 1528, 1, 0, 0, 0, 12760, 12761, 7, 10, 0, 0, 12761, 12762, 7, 7, + 0, 0, 12762, 12763, 7, 5, 0, 0, 12763, 12764, 7, 4, 0, 0, 12764, 12765, + 7, 3, 0, 0, 12765, 12766, 5, 52, 0, 0, 12766, 1530, 1, 0, 0, 0, 12767, + 12768, 7, 10, 0, 0, 12768, 12769, 7, 7, 0, 0, 12769, 12770, 7, 5, 0, 0, + 12770, 12771, 7, 4, 0, 0, 12771, 12772, 7, 3, 0, 0, 12772, 12773, 7, 1, + 0, 0, 12773, 1532, 1, 0, 0, 0, 12774, 12775, 7, 10, 0, 0, 12775, 12776, + 7, 7, 0, 0, 12776, 12777, 7, 5, 0, 0, 12777, 12778, 7, 4, 0, 0, 12778, + 12779, 7, 3, 0, 0, 12779, 12780, 7, 8, 0, 0, 12780, 1534, 1, 0, 0, 0, 12781, + 12782, 7, 10, 0, 0, 12782, 12783, 7, 7, 0, 0, 12783, 12784, 7, 5, 0, 0, + 12784, 12785, 7, 4, 0, 0, 12785, 12786, 7, 3, 0, 0, 12786, 1536, 1, 0, + 0, 0, 12787, 12788, 7, 10, 0, 0, 12788, 12789, 7, 7, 0, 0, 12789, 12790, + 7, 4, 0, 0, 12790, 12791, 7, 6, 0, 0, 12791, 12792, 7, 17, 0, 0, 12792, + 12793, 7, 6, 0, 0, 12793, 12794, 7, 3, 0, 0, 12794, 1538, 1, 0, 0, 0, 12795, + 12796, 7, 10, 0, 0, 12796, 12797, 7, 7, 0, 0, 12797, 12798, 7, 4, 0, 0, + 12798, 12799, 7, 6, 0, 0, 12799, 12800, 7, 3, 0, 0, 12800, 12801, 7, 11, + 0, 0, 12801, 12802, 7, 6, 0, 0, 12802, 12803, 7, 0, 0, 0, 12803, 12804, + 7, 13, 0, 0, 12804, 12805, 7, 6, 0, 0, 12805, 12806, 7, 9, 0, 0, 12806, + 1540, 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, 14, 0, 0, 12813, 12814, 7, 6, 0, 0, 12814, 12815, + 7, 9, 0, 0, 12815, 12816, 7, 10, 0, 0, 12816, 12817, 7, 0, 0, 0, 12817, + 12818, 7, 4, 0, 0, 12818, 12819, 7, 6, 0, 0, 12819, 1542, 1, 0, 0, 0, 12820, + 12821, 7, 10, 0, 0, 12821, 12822, 7, 7, 0, 0, 12822, 12823, 7, 4, 0, 0, + 12823, 12824, 7, 6, 0, 0, 12824, 12825, 7, 3, 0, 0, 12825, 12826, 7, 7, + 0, 0, 12826, 12827, 7, 0, 0, 0, 12827, 12828, 7, 11, 0, 0, 12828, 12829, + 5, 95, 0, 0, 12829, 12830, 7, 8, 0, 0, 12830, 12831, 7, 2, 0, 0, 12831, + 12832, 7, 7, 0, 0, 12832, 12833, 7, 13, 0, 0, 12833, 12834, 7, 6, 0, 0, + 12834, 12835, 7, 3, 0, 0, 12835, 12836, 7, 4, 0, 0, 12836, 1544, 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, 7, 0, 0, 12843, 12844, 7, 0, 0, 0, 12844, 12845, 7, 11, 0, 0, + 12845, 12846, 5, 95, 0, 0, 12846, 12847, 7, 12, 0, 0, 12847, 12848, 7, + 5, 0, 0, 12848, 12849, 7, 6, 0, 0, 12849, 1546, 1, 0, 0, 0, 12850, 12851, + 7, 10, 0, 0, 12851, 12852, 7, 7, 0, 0, 12852, 12853, 7, 4, 0, 0, 12853, + 12854, 7, 6, 0, 0, 12854, 12855, 7, 3, 0, 0, 12855, 12856, 7, 15, 0, 0, + 12856, 12857, 7, 3, 0, 0, 12857, 12858, 7, 6, 0, 0, 12858, 12859, 7, 4, + 0, 0, 12859, 12860, 7, 6, 0, 0, 12860, 12861, 7, 9, 0, 0, 12861, 1548, + 1, 0, 0, 0, 12862, 12863, 7, 10, 0, 0, 12863, 12864, 7, 7, 0, 0, 12864, + 12865, 7, 4, 0, 0, 12865, 12866, 7, 6, 0, 0, 12866, 12867, 7, 3, 0, 0, + 12867, 12868, 7, 5, 0, 0, 12868, 12869, 7, 6, 0, 0, 12869, 12870, 7, 8, + 0, 0, 12870, 12871, 7, 4, 0, 0, 12871, 1550, 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, 13, 0, 0, + 12878, 12879, 7, 0, 0, 0, 12879, 12880, 7, 11, 0, 0, 12880, 1552, 1, 0, + 0, 0, 12881, 12882, 7, 10, 0, 0, 12882, 12883, 7, 7, 0, 0, 12883, 12884, + 7, 4, 0, 0, 12884, 1554, 1, 0, 0, 0, 12885, 12886, 7, 10, 0, 0, 12886, + 12887, 7, 7, 0, 0, 12887, 12888, 7, 4, 0, 0, 12888, 12889, 7, 6, 0, 0, + 12889, 12890, 7, 3, 0, 0, 12890, 12891, 7, 7, 0, 0, 12891, 12892, 7, 0, + 0, 0, 12892, 12893, 7, 11, 0, 0, 12893, 1556, 1, 0, 0, 0, 12894, 12895, + 7, 10, 0, 0, 12895, 12896, 7, 7, 0, 0, 12896, 12897, 7, 4, 0, 0, 12897, + 12898, 7, 2, 0, 0, 12898, 1558, 1, 0, 0, 0, 12899, 12900, 7, 10, 0, 0, + 12900, 12901, 7, 7, 0, 0, 12901, 12902, 7, 13, 0, 0, 12902, 12903, 7, 0, + 0, 0, 12903, 12904, 7, 11, 0, 0, 12904, 12905, 7, 10, 0, 0, 12905, 12906, + 7, 9, 0, 0, 12906, 12907, 7, 0, 0, 0, 12907, 12908, 7, 4, 0, 0, 12908, + 12909, 7, 6, 0, 0, 12909, 1560, 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, 0, + 0, 0, 12914, 12915, 7, 11, 0, 0, 12915, 12916, 7, 10, 0, 0, 12916, 12917, + 7, 9, 0, 0, 12917, 12918, 7, 0, 0, 0, 12918, 12919, 7, 4, 0, 0, 12919, + 12920, 7, 10, 0, 0, 12920, 12921, 7, 2, 0, 0, 12921, 12922, 7, 7, 0, 0, + 12922, 1562, 1, 0, 0, 0, 12923, 12924, 7, 10, 0, 0, 12924, 12925, 7, 7, + 0, 0, 12925, 12926, 7, 13, 0, 0, 12926, 12927, 7, 10, 0, 0, 12927, 12928, + 7, 5, 0, 0, 12928, 12929, 7, 10, 0, 0, 12929, 12930, 7, 1, 0, 0, 12930, + 12931, 7, 11, 0, 0, 12931, 12932, 7, 6, 0, 0, 12932, 1564, 1, 0, 0, 0, + 12933, 12934, 7, 10, 0, 0, 12934, 12935, 7, 7, 0, 0, 12935, 12936, 5, 95, + 0, 0, 12936, 12937, 7, 25, 0, 0, 12937, 12938, 7, 24, 0, 0, 12938, 12939, + 7, 12, 0, 0, 12939, 12940, 7, 6, 0, 0, 12940, 12941, 7, 3, 0, 0, 12941, + 12942, 7, 18, 0, 0, 12942, 1566, 1, 0, 0, 0, 12943, 12944, 7, 10, 0, 0, + 12944, 12945, 7, 2, 0, 0, 12945, 12946, 5, 95, 0, 0, 12946, 12947, 7, 2, + 0, 0, 12947, 12948, 7, 15, 0, 0, 12948, 12949, 7, 4, 0, 0, 12949, 12950, + 7, 10, 0, 0, 12950, 12951, 7, 2, 0, 0, 12951, 12952, 7, 7, 0, 0, 12952, + 12953, 7, 5, 0, 0, 12953, 1568, 1, 0, 0, 0, 12954, 12955, 7, 10, 0, 0, + 12955, 12956, 7, 5, 0, 0, 12956, 1570, 1, 0, 0, 0, 12957, 12958, 7, 10, + 0, 0, 12958, 12959, 7, 5, 0, 0, 12959, 12960, 5, 95, 0, 0, 12960, 12961, + 7, 11, 0, 0, 12961, 12962, 7, 6, 0, 0, 12962, 12963, 7, 0, 0, 0, 12963, + 12964, 7, 16, 0, 0, 12964, 1572, 1, 0, 0, 0, 12965, 12966, 7, 10, 0, 0, + 12966, 12967, 7, 5, 0, 0, 12967, 12968, 7, 2, 0, 0, 12968, 12969, 7, 11, + 0, 0, 12969, 12970, 7, 0, 0, 0, 12970, 12971, 7, 4, 0, 0, 12971, 12972, + 7, 10, 0, 0, 12972, 12973, 7, 2, 0, 0, 12973, 12974, 7, 7, 0, 0, 12974, + 1574, 1, 0, 0, 0, 12975, 12976, 7, 10, 0, 0, 12976, 12977, 7, 5, 0, 0, + 12977, 12978, 7, 2, 0, 0, 12978, 12979, 7, 11, 0, 0, 12979, 12980, 7, 0, + 0, 0, 12980, 12981, 7, 4, 0, 0, 12981, 12982, 7, 10, 0, 0, 12982, 12983, + 7, 2, 0, 0, 12983, 12984, 7, 7, 0, 0, 12984, 12985, 5, 95, 0, 0, 12985, + 12986, 7, 11, 0, 0, 12986, 12987, 7, 6, 0, 0, 12987, 12988, 7, 13, 0, 0, + 12988, 12989, 7, 6, 0, 0, 12989, 12990, 7, 11, 0, 0, 12990, 1576, 1, 0, + 0, 0, 12991, 12992, 7, 10, 0, 0, 12992, 12993, 7, 4, 0, 0, 12993, 12994, + 7, 6, 0, 0, 12994, 12995, 7, 14, 0, 0, 12995, 12996, 7, 5, 0, 0, 12996, + 1578, 1, 0, 0, 0, 12997, 12998, 7, 10, 0, 0, 12998, 12999, 7, 4, 0, 0, + 12999, 13000, 7, 6, 0, 0, 13000, 13001, 7, 3, 0, 0, 13001, 13002, 7, 0, + 0, 0, 13002, 13003, 7, 4, 0, 0, 13003, 13004, 7, 6, 0, 0, 13004, 1580, + 1, 0, 0, 0, 13005, 13006, 7, 10, 0, 0, 13006, 13007, 7, 4, 0, 0, 13007, + 13008, 7, 6, 0, 0, 13008, 13009, 7, 3, 0, 0, 13009, 13010, 7, 0, 0, 0, + 13010, 13011, 7, 4, 0, 0, 13011, 13012, 7, 10, 0, 0, 13012, 13013, 7, 2, + 0, 0, 13013, 13014, 7, 7, 0, 0, 13014, 13015, 5, 95, 0, 0, 13015, 13016, + 7, 7, 0, 0, 13016, 13017, 7, 12, 0, 0, 13017, 13018, 7, 14, 0, 0, 13018, + 13019, 7, 1, 0, 0, 13019, 13020, 7, 6, 0, 0, 13020, 13021, 7, 3, 0, 0, + 13021, 1582, 1, 0, 0, 0, 13022, 13023, 7, 20, 0, 0, 13023, 13024, 7, 0, + 0, 0, 13024, 13025, 7, 13, 0, 0, 13025, 13026, 7, 0, 0, 0, 13026, 1584, + 1, 0, 0, 0, 13027, 13028, 7, 20, 0, 0, 13028, 13029, 7, 2, 0, 0, 13029, + 13030, 7, 1, 0, 0, 13030, 1586, 1, 0, 0, 0, 13031, 13032, 7, 20, 0, 0, + 13032, 13033, 7, 2, 0, 0, 13033, 13034, 7, 10, 0, 0, 13034, 13035, 7, 7, + 0, 0, 13035, 1588, 1, 0, 0, 0, 13036, 13037, 7, 20, 0, 0, 13037, 13038, + 7, 5, 0, 0, 13038, 13039, 7, 2, 0, 0, 13039, 13040, 7, 7, 0, 0, 13040, + 13041, 5, 95, 0, 0, 13041, 13042, 7, 0, 0, 0, 13042, 13043, 7, 3, 0, 0, + 13043, 13044, 7, 3, 0, 0, 13044, 13045, 7, 0, 0, 0, 13045, 13046, 7, 18, + 0, 0, 13046, 13047, 7, 0, 0, 0, 13047, 13048, 7, 17, 0, 0, 13048, 13049, + 7, 17, 0, 0, 13049, 1590, 1, 0, 0, 0, 13050, 13051, 7, 20, 0, 0, 13051, + 13052, 7, 5, 0, 0, 13052, 13053, 7, 2, 0, 0, 13053, 13054, 7, 7, 0, 0, + 13054, 13055, 5, 95, 0, 0, 13055, 13056, 7, 0, 0, 0, 13056, 13057, 7, 3, + 0, 0, 13057, 13058, 7, 3, 0, 0, 13058, 13059, 7, 0, 0, 0, 13059, 13060, + 7, 18, 0, 0, 13060, 1592, 1, 0, 0, 0, 13061, 13062, 7, 20, 0, 0, 13062, + 13063, 7, 5, 0, 0, 13063, 13064, 7, 2, 0, 0, 13064, 13065, 7, 7, 0, 0, + 13065, 13066, 5, 95, 0, 0, 13066, 13067, 7, 6, 0, 0, 13067, 13068, 7, 24, + 0, 0, 13068, 13069, 7, 12, 0, 0, 13069, 13070, 7, 0, 0, 0, 13070, 13071, + 7, 11, 0, 0, 13071, 1594, 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, 13084, 5, 50, 0, 0, 13084, + 1596, 1, 0, 0, 0, 13085, 13086, 7, 20, 0, 0, 13086, 13087, 7, 5, 0, 0, + 13087, 13088, 7, 2, 0, 0, 13088, 13089, 7, 7, 0, 0, 13089, 13090, 5, 95, + 0, 0, 13090, 13091, 7, 6, 0, 0, 13091, 13092, 7, 25, 0, 0, 13092, 13093, + 7, 10, 0, 0, 13093, 13094, 7, 5, 0, 0, 13094, 13095, 7, 4, 0, 0, 13095, + 13096, 7, 5, 0, 0, 13096, 1598, 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, 7, 17, 0, 0, 13102, 13103, 7, 6, 0, 0, 13103, 13104, + 7, 4, 0, 0, 13104, 1600, 1, 0, 0, 0, 13105, 13106, 7, 20, 0, 0, 13106, + 13107, 7, 5, 0, 0, 13107, 13108, 7, 2, 0, 0, 13108, 13109, 7, 7, 0, 0, + 13109, 1602, 1, 0, 0, 0, 13110, 13111, 7, 20, 0, 0, 13111, 13112, 7, 5, + 0, 0, 13112, 13113, 7, 2, 0, 0, 13113, 13114, 7, 7, 0, 0, 13114, 13115, + 5, 95, 0, 0, 13115, 13116, 7, 2, 0, 0, 13116, 13117, 7, 1, 0, 0, 13117, + 13118, 7, 20, 0, 0, 13118, 13119, 7, 6, 0, 0, 13119, 13120, 7, 8, 0, 0, + 13120, 13121, 7, 4, 0, 0, 13121, 13122, 7, 0, 0, 0, 13122, 13123, 7, 17, + 0, 0, 13123, 13124, 7, 17, 0, 0, 13124, 1604, 1, 0, 0, 0, 13125, 13126, + 7, 20, 0, 0, 13126, 13127, 7, 5, 0, 0, 13127, 13128, 7, 2, 0, 0, 13128, + 13129, 7, 7, 0, 0, 13129, 13130, 5, 95, 0, 0, 13130, 13131, 7, 2, 0, 0, + 13131, 13132, 7, 1, 0, 0, 13132, 13133, 7, 20, 0, 0, 13133, 13134, 7, 6, + 0, 0, 13134, 13135, 7, 8, 0, 0, 13135, 13136, 7, 4, 0, 0, 13136, 1606, + 1, 0, 0, 0, 13137, 13138, 7, 20, 0, 0, 13138, 13139, 7, 5, 0, 0, 13139, + 13140, 7, 2, 0, 0, 13140, 13141, 7, 7, 0, 0, 13141, 13142, 7, 15, 0, 0, + 13142, 13143, 7, 0, 0, 0, 13143, 13144, 7, 3, 0, 0, 13144, 13145, 7, 5, + 0, 0, 13145, 13146, 7, 6, 0, 0, 13146, 1608, 1, 0, 0, 0, 13147, 13148, + 7, 20, 0, 0, 13148, 13149, 7, 5, 0, 0, 13149, 13150, 7, 2, 0, 0, 13150, + 13151, 7, 7, 0, 0, 13151, 13152, 5, 95, 0, 0, 13152, 13153, 7, 24, 0, 0, + 13153, 13154, 7, 12, 0, 0, 13154, 13155, 7, 6, 0, 0, 13155, 13156, 7, 3, + 0, 0, 13156, 13157, 7, 18, 0, 0, 13157, 1610, 1, 0, 0, 0, 13158, 13159, + 7, 20, 0, 0, 13159, 13160, 7, 5, 0, 0, 13160, 13161, 7, 2, 0, 0, 13161, + 13162, 7, 7, 0, 0, 13162, 13163, 5, 95, 0, 0, 13163, 13164, 7, 5, 0, 0, + 13164, 13165, 7, 6, 0, 0, 13165, 13166, 7, 3, 0, 0, 13166, 13167, 7, 10, + 0, 0, 13167, 13168, 7, 0, 0, 0, 13168, 13169, 7, 11, 0, 0, 13169, 13170, + 7, 10, 0, 0, 13170, 13171, 7, 23, 0, 0, 13171, 13172, 7, 6, 0, 0, 13172, + 1612, 1, 0, 0, 0, 13173, 13174, 7, 20, 0, 0, 13174, 13175, 7, 5, 0, 0, + 13175, 13176, 7, 2, 0, 0, 13176, 13177, 7, 7, 0, 0, 13177, 13178, 5, 95, + 0, 0, 13178, 13179, 7, 4, 0, 0, 13179, 13180, 7, 0, 0, 0, 13180, 13181, + 7, 1, 0, 0, 13181, 13182, 7, 11, 0, 0, 13182, 13183, 7, 6, 0, 0, 13183, + 1614, 1, 0, 0, 0, 13184, 13185, 7, 20, 0, 0, 13185, 13186, 7, 5, 0, 0, + 13186, 13187, 7, 2, 0, 0, 13187, 13188, 7, 7, 0, 0, 13188, 13189, 5, 95, + 0, 0, 13189, 13190, 7, 4, 0, 0, 13190, 13191, 7, 6, 0, 0, 13191, 13192, + 7, 25, 0, 0, 13192, 13193, 7, 4, 0, 0, 13193, 13194, 7, 8, 0, 0, 13194, + 13195, 7, 2, 0, 0, 13195, 13196, 7, 7, 0, 0, 13196, 13197, 7, 4, 0, 0, + 13197, 13198, 7, 0, 0, 0, 13198, 13199, 7, 10, 0, 0, 13199, 13200, 7, 7, + 0, 0, 13200, 13201, 7, 5, 0, 0, 13201, 13202, 5, 50, 0, 0, 13202, 1616, + 1, 0, 0, 0, 13203, 13204, 7, 20, 0, 0, 13204, 13205, 7, 5, 0, 0, 13205, + 13206, 7, 2, 0, 0, 13206, 13207, 7, 7, 0, 0, 13207, 13208, 5, 95, 0, 0, + 13208, 13209, 7, 4, 0, 0, 13209, 13210, 7, 6, 0, 0, 13210, 13211, 7, 25, + 0, 0, 13211, 13212, 7, 4, 0, 0, 13212, 13213, 7, 8, 0, 0, 13213, 13214, + 7, 2, 0, 0, 13214, 13215, 7, 7, 0, 0, 13215, 13216, 7, 4, 0, 0, 13216, + 13217, 7, 0, 0, 0, 13217, 13218, 7, 10, 0, 0, 13218, 13219, 7, 7, 0, 0, + 13219, 13220, 7, 5, 0, 0, 13220, 1618, 1, 0, 0, 0, 13221, 13222, 7, 20, + 0, 0, 13222, 13223, 7, 5, 0, 0, 13223, 13224, 7, 2, 0, 0, 13224, 13225, + 7, 7, 0, 0, 13225, 13226, 5, 95, 0, 0, 13226, 13227, 7, 4, 0, 0, 13227, + 13228, 7, 3, 0, 0, 13228, 13229, 7, 0, 0, 0, 13229, 13230, 7, 7, 0, 0, + 13230, 13231, 7, 5, 0, 0, 13231, 13232, 7, 16, 0, 0, 13232, 13233, 7, 2, + 0, 0, 13233, 13234, 7, 3, 0, 0, 13234, 13235, 7, 14, 0, 0, 13235, 1620, + 1, 0, 0, 0, 13236, 13237, 7, 20, 0, 0, 13237, 13238, 7, 5, 0, 0, 13238, + 13239, 7, 2, 0, 0, 13239, 13240, 7, 7, 0, 0, 13240, 13241, 5, 95, 0, 0, + 13241, 13242, 7, 13, 0, 0, 13242, 13243, 7, 0, 0, 0, 13243, 13244, 7, 11, + 0, 0, 13244, 13245, 7, 12, 0, 0, 13245, 13246, 7, 6, 0, 0, 13246, 1622, + 1, 0, 0, 0, 13247, 13248, 7, 21, 0, 0, 13248, 1624, 1, 0, 0, 0, 13249, + 13250, 7, 21, 0, 0, 13250, 13251, 7, 6, 0, 0, 13251, 13252, 7, 6, 0, 0, + 13252, 13253, 7, 15, 0, 0, 13253, 13254, 5, 95, 0, 0, 13254, 13255, 7, + 9, 0, 0, 13255, 13256, 7, 12, 0, 0, 13256, 13257, 7, 15, 0, 0, 13257, 13258, + 7, 11, 0, 0, 13258, 13259, 7, 10, 0, 0, 13259, 13260, 7, 8, 0, 0, 13260, + 13261, 7, 0, 0, 0, 13261, 13262, 7, 4, 0, 0, 13262, 13263, 7, 6, 0, 0, + 13263, 13264, 7, 5, 0, 0, 13264, 1626, 1, 0, 0, 0, 13265, 13266, 7, 21, + 0, 0, 13266, 13267, 7, 6, 0, 0, 13267, 13268, 7, 6, 0, 0, 13268, 13269, + 7, 15, 0, 0, 13269, 1628, 1, 0, 0, 0, 13270, 13271, 7, 21, 0, 0, 13271, + 13272, 7, 6, 0, 0, 13272, 13273, 7, 3, 0, 0, 13273, 13274, 7, 1, 0, 0, + 13274, 13275, 7, 6, 0, 0, 13275, 13276, 7, 3, 0, 0, 13276, 13277, 7, 2, + 0, 0, 13277, 13278, 7, 5, 0, 0, 13278, 1630, 1, 0, 0, 0, 13279, 13280, + 7, 21, 0, 0, 13280, 13281, 7, 6, 0, 0, 13281, 13282, 7, 18, 0, 0, 13282, + 1632, 1, 0, 0, 0, 13283, 13284, 7, 21, 0, 0, 13284, 13285, 7, 6, 0, 0, + 13285, 13286, 7, 18, 0, 0, 13286, 13287, 5, 95, 0, 0, 13287, 13288, 7, + 11, 0, 0, 13288, 13289, 7, 6, 0, 0, 13289, 13290, 7, 7, 0, 0, 13290, 13291, + 7, 17, 0, 0, 13291, 13292, 7, 4, 0, 0, 13292, 13293, 7, 19, 0, 0, 13293, + 1634, 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, 10, + 0, 0, 13299, 13300, 7, 23, 0, 0, 13300, 13301, 7, 6, 0, 0, 13301, 1636, + 1, 0, 0, 0, 13302, 13303, 7, 21, 0, 0, 13303, 13304, 7, 6, 0, 0, 13304, + 13305, 7, 18, 0, 0, 13305, 13306, 7, 5, 0, 0, 13306, 1638, 1, 0, 0, 0, + 13307, 13308, 7, 21, 0, 0, 13308, 13309, 7, 6, 0, 0, 13309, 13310, 7, 18, + 0, 0, 13310, 13311, 7, 5, 0, 0, 13311, 13312, 7, 4, 0, 0, 13312, 13313, + 7, 2, 0, 0, 13313, 13314, 7, 3, 0, 0, 13314, 13315, 7, 6, 0, 0, 13315, + 1640, 1, 0, 0, 0, 13316, 13317, 7, 21, 0, 0, 13317, 13318, 7, 10, 0, 0, + 13318, 13319, 7, 11, 0, 0, 13319, 13320, 7, 11, 0, 0, 13320, 1642, 1, 0, + 0, 0, 13321, 13322, 7, 11, 0, 0, 13322, 13323, 7, 0, 0, 0, 13323, 13324, + 7, 1, 0, 0, 13324, 13325, 7, 6, 0, 0, 13325, 13326, 7, 11, 0, 0, 13326, + 1644, 1, 0, 0, 0, 13327, 13328, 7, 11, 0, 0, 13328, 13329, 7, 0, 0, 0, + 13329, 13330, 7, 7, 0, 0, 13330, 13331, 7, 17, 0, 0, 13331, 13332, 7, 12, + 0, 0, 13332, 13333, 7, 0, 0, 0, 13333, 13334, 7, 17, 0, 0, 13334, 13335, + 7, 6, 0, 0, 13335, 1646, 1, 0, 0, 0, 13336, 13337, 7, 11, 0, 0, 13337, + 13338, 7, 0, 0, 0, 13338, 13339, 7, 5, 0, 0, 13339, 13340, 7, 4, 0, 0, + 13340, 13341, 5, 95, 0, 0, 13341, 13342, 7, 9, 0, 0, 13342, 13343, 7, 0, + 0, 0, 13343, 13344, 7, 18, 0, 0, 13344, 1648, 1, 0, 0, 0, 13345, 13346, + 7, 11, 0, 0, 13346, 13347, 7, 0, 0, 0, 13347, 13348, 7, 5, 0, 0, 13348, + 13349, 7, 4, 0, 0, 13349, 1650, 1, 0, 0, 0, 13350, 13351, 7, 11, 0, 0, + 13351, 13352, 7, 0, 0, 0, 13352, 13353, 7, 5, 0, 0, 13353, 13354, 7, 4, + 0, 0, 13354, 13355, 5, 95, 0, 0, 13355, 13356, 7, 13, 0, 0, 13356, 13357, + 7, 0, 0, 0, 13357, 13358, 7, 11, 0, 0, 13358, 13359, 7, 12, 0, 0, 13359, + 13360, 7, 6, 0, 0, 13360, 1652, 1, 0, 0, 0, 13361, 13362, 7, 11, 0, 0, + 13362, 13363, 7, 0, 0, 0, 13363, 13364, 7, 4, 0, 0, 13364, 13365, 7, 6, + 0, 0, 13365, 13366, 7, 3, 0, 0, 13366, 13367, 7, 0, 0, 0, 13367, 13368, + 7, 11, 0, 0, 13368, 1654, 1, 0, 0, 0, 13369, 13370, 7, 11, 0, 0, 13370, + 13371, 7, 0, 0, 0, 13371, 13372, 7, 4, 0, 0, 13372, 13373, 7, 6, 0, 0, + 13373, 13374, 7, 5, 0, 0, 13374, 13375, 7, 4, 0, 0, 13375, 1656, 1, 0, + 0, 0, 13376, 13377, 7, 11, 0, 0, 13377, 13378, 7, 0, 0, 0, 13378, 13379, + 7, 25, 0, 0, 13379, 1658, 1, 0, 0, 0, 13380, 13381, 7, 11, 0, 0, 13381, + 13382, 7, 0, 0, 0, 13382, 13383, 7, 18, 0, 0, 13383, 13384, 7, 6, 0, 0, + 13384, 13385, 7, 3, 0, 0, 13385, 1660, 1, 0, 0, 0, 13386, 13387, 7, 11, + 0, 0, 13387, 13388, 7, 9, 0, 0, 13388, 13389, 7, 0, 0, 0, 13389, 13390, + 7, 15, 0, 0, 13390, 13391, 5, 95, 0, 0, 13391, 13392, 7, 3, 0, 0, 13392, + 13393, 7, 6, 0, 0, 13393, 13394, 7, 17, 0, 0, 13394, 13395, 7, 10, 0, 0, + 13395, 13396, 7, 5, 0, 0, 13396, 13397, 7, 4, 0, 0, 13397, 13398, 7, 3, + 0, 0, 13398, 13399, 7, 0, 0, 0, 13399, 13400, 7, 4, 0, 0, 13400, 13401, + 7, 10, 0, 0, 13401, 13402, 7, 2, 0, 0, 13402, 13403, 7, 7, 0, 0, 13403, + 13404, 5, 95, 0, 0, 13404, 13405, 7, 6, 0, 0, 13405, 13406, 7, 7, 0, 0, + 13406, 13407, 7, 0, 0, 0, 13407, 13408, 7, 1, 0, 0, 13408, 13409, 7, 11, + 0, 0, 13409, 13410, 7, 6, 0, 0, 13410, 13411, 7, 9, 0, 0, 13411, 1662, + 1, 0, 0, 0, 13412, 13413, 7, 11, 0, 0, 13413, 13414, 7, 9, 0, 0, 13414, + 13415, 7, 0, 0, 0, 13415, 13416, 7, 15, 0, 0, 13416, 13417, 5, 95, 0, 0, + 13417, 13418, 7, 3, 0, 0, 13418, 13419, 7, 6, 0, 0, 13419, 13420, 7, 17, + 0, 0, 13420, 13421, 7, 10, 0, 0, 13421, 13422, 7, 5, 0, 0, 13422, 13423, + 7, 4, 0, 0, 13423, 13424, 7, 3, 0, 0, 13424, 13425, 7, 0, 0, 0, 13425, + 13426, 7, 4, 0, 0, 13426, 13427, 7, 10, 0, 0, 13427, 13428, 7, 2, 0, 0, + 13428, 13429, 7, 7, 0, 0, 13429, 1664, 1, 0, 0, 0, 13430, 13431, 7, 11, + 0, 0, 13431, 13432, 7, 9, 0, 0, 13432, 13433, 7, 0, 0, 0, 13433, 13434, + 7, 15, 0, 0, 13434, 13435, 5, 95, 0, 0, 13435, 13436, 7, 3, 0, 0, 13436, + 13437, 7, 6, 0, 0, 13437, 13438, 7, 17, 0, 0, 13438, 13439, 5, 95, 0, 0, + 13439, 13440, 7, 5, 0, 0, 13440, 13441, 7, 18, 0, 0, 13441, 13442, 7, 7, + 0, 0, 13442, 13443, 7, 8, 0, 0, 13443, 13444, 5, 95, 0, 0, 13444, 13445, + 7, 10, 0, 0, 13445, 13446, 7, 7, 0, 0, 13446, 13447, 7, 4, 0, 0, 13447, + 13448, 7, 6, 0, 0, 13448, 13449, 7, 3, 0, 0, 13449, 13450, 7, 13, 0, 0, + 13450, 13451, 7, 0, 0, 0, 13451, 13452, 7, 11, 0, 0, 13452, 1666, 1, 0, + 0, 0, 13453, 13454, 7, 11, 0, 0, 13454, 13455, 7, 9, 0, 0, 13455, 13456, + 7, 3, 0, 0, 13456, 13457, 7, 4, 0, 0, 13457, 13458, 7, 3, 0, 0, 13458, + 13459, 7, 10, 0, 0, 13459, 13460, 7, 14, 0, 0, 13460, 1668, 1, 0, 0, 0, + 13461, 13462, 7, 11, 0, 0, 13462, 13463, 7, 6, 0, 0, 13463, 13464, 7, 0, + 0, 0, 13464, 13465, 7, 16, 0, 0, 13465, 1670, 1, 0, 0, 0, 13466, 13467, + 7, 11, 0, 0, 13467, 13468, 7, 6, 0, 0, 13468, 13469, 7, 0, 0, 0, 13469, + 13470, 7, 9, 0, 0, 13470, 13471, 5, 95, 0, 0, 13471, 13472, 7, 8, 0, 0, + 13472, 13473, 7, 9, 0, 0, 13473, 13474, 7, 1, 0, 0, 13474, 1672, 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, 5, 95, 0, 0, 13480, + 13481, 7, 8, 0, 0, 13481, 13482, 7, 9, 0, 0, 13482, 13483, 7, 1, 0, 0, + 13483, 13484, 5, 95, 0, 0, 13484, 13485, 7, 12, 0, 0, 13485, 13486, 7, + 3, 0, 0, 13486, 13487, 7, 10, 0, 0, 13487, 1674, 1, 0, 0, 0, 13488, 13489, + 7, 11, 0, 0, 13489, 13490, 7, 6, 0, 0, 13490, 13491, 7, 0, 0, 0, 13491, + 13492, 7, 9, 0, 0, 13492, 13493, 7, 10, 0, 0, 13493, 13494, 7, 7, 0, 0, + 13494, 13495, 7, 17, 0, 0, 13495, 1676, 1, 0, 0, 0, 13496, 13497, 7, 11, + 0, 0, 13497, 13498, 7, 6, 0, 0, 13498, 13499, 7, 16, 0, 0, 13499, 13500, + 7, 4, 0, 0, 13500, 1678, 1, 0, 0, 0, 13501, 13502, 7, 11, 0, 0, 13502, + 13503, 7, 6, 0, 0, 13503, 13504, 7, 7, 0, 0, 13504, 13505, 7, 17, 0, 0, + 13505, 13506, 7, 4, 0, 0, 13506, 13507, 7, 19, 0, 0, 13507, 13508, 5, 50, + 0, 0, 13508, 1680, 1, 0, 0, 0, 13509, 13510, 7, 11, 0, 0, 13510, 13511, + 7, 6, 0, 0, 13511, 13512, 7, 7, 0, 0, 13512, 13513, 7, 17, 0, 0, 13513, + 13514, 7, 4, 0, 0, 13514, 13515, 7, 19, 0, 0, 13515, 13516, 5, 52, 0, 0, + 13516, 1682, 1, 0, 0, 0, 13517, 13518, 7, 11, 0, 0, 13518, 13519, 7, 6, + 0, 0, 13519, 13520, 7, 7, 0, 0, 13520, 13521, 7, 17, 0, 0, 13521, 13522, + 7, 4, 0, 0, 13522, 13523, 7, 19, 0, 0, 13523, 13524, 7, 1, 0, 0, 13524, + 1684, 1, 0, 0, 0, 13525, 13526, 7, 11, 0, 0, 13526, 13527, 7, 6, 0, 0, + 13527, 13528, 7, 7, 0, 0, 13528, 13529, 7, 17, 0, 0, 13529, 13530, 7, 4, + 0, 0, 13530, 13531, 7, 19, 0, 0, 13531, 13532, 7, 8, 0, 0, 13532, 1686, + 1, 0, 0, 0, 13533, 13534, 7, 11, 0, 0, 13534, 13535, 7, 6, 0, 0, 13535, + 13536, 7, 7, 0, 0, 13536, 13537, 7, 17, 0, 0, 13537, 13538, 7, 4, 0, 0, + 13538, 13539, 7, 19, 0, 0, 13539, 1688, 1, 0, 0, 0, 13540, 13541, 7, 11, + 0, 0, 13541, 13542, 7, 6, 0, 0, 13542, 13543, 7, 5, 0, 0, 13543, 13544, + 7, 5, 0, 0, 13544, 1690, 1, 0, 0, 0, 13545, 13546, 7, 11, 0, 0, 13546, + 13547, 7, 6, 0, 0, 13547, 13548, 7, 13, 0, 0, 13548, 13549, 7, 6, 0, 0, + 13549, 13550, 7, 11, 0, 0, 13550, 1692, 1, 0, 0, 0, 13551, 13552, 7, 11, + 0, 0, 13552, 13553, 7, 6, 0, 0, 13553, 13554, 7, 13, 0, 0, 13554, 13555, + 7, 6, 0, 0, 13555, 13556, 7, 11, 0, 0, 13556, 13557, 5, 95, 0, 0, 13557, + 13558, 7, 7, 0, 0, 13558, 13559, 7, 0, 0, 0, 13559, 13560, 7, 14, 0, 0, + 13560, 13561, 7, 6, 0, 0, 13561, 1694, 1, 0, 0, 0, 13562, 13563, 7, 11, + 0, 0, 13563, 13564, 7, 6, 0, 0, 13564, 13565, 7, 13, 0, 0, 13565, 13566, + 7, 6, 0, 0, 13566, 13567, 7, 11, 0, 0, 13567, 13568, 7, 5, 0, 0, 13568, + 1696, 1, 0, 0, 0, 13569, 13570, 7, 11, 0, 0, 13570, 13571, 7, 10, 0, 0, + 13571, 13572, 7, 1, 0, 0, 13572, 13573, 7, 3, 0, 0, 13573, 13574, 7, 0, + 0, 0, 13574, 13575, 7, 3, 0, 0, 13575, 13576, 7, 18, 0, 0, 13576, 1698, + 1, 0, 0, 0, 13577, 13578, 7, 11, 0, 0, 13578, 13579, 7, 10, 0, 0, 13579, + 13580, 7, 16, 0, 0, 13580, 13581, 7, 6, 0, 0, 13581, 13582, 7, 8, 0, 0, + 13582, 13583, 7, 18, 0, 0, 13583, 13584, 7, 8, 0, 0, 13584, 13585, 7, 11, + 0, 0, 13585, 13586, 7, 6, 0, 0, 13586, 1700, 1, 0, 0, 0, 13587, 13588, + 7, 11, 0, 0, 13588, 13589, 7, 10, 0, 0, 13589, 13590, 7, 16, 0, 0, 13590, + 13591, 7, 6, 0, 0, 13591, 1702, 1, 0, 0, 0, 13592, 13593, 7, 11, 0, 0, + 13593, 13594, 7, 10, 0, 0, 13594, 13595, 7, 16, 0, 0, 13595, 13596, 7, + 6, 0, 0, 13596, 13597, 7, 4, 0, 0, 13597, 13598, 7, 10, 0, 0, 13598, 13599, + 7, 14, 0, 0, 13599, 13600, 7, 6, 0, 0, 13600, 1704, 1, 0, 0, 0, 13601, + 13602, 7, 11, 0, 0, 13602, 13603, 7, 10, 0, 0, 13603, 13604, 7, 21, 0, + 0, 13604, 13605, 7, 6, 0, 0, 13605, 13606, 5, 50, 0, 0, 13606, 1706, 1, + 0, 0, 0, 13607, 13608, 7, 11, 0, 0, 13608, 13609, 7, 10, 0, 0, 13609, 13610, + 7, 21, 0, 0, 13610, 13611, 7, 6, 0, 0, 13611, 13612, 5, 52, 0, 0, 13612, + 1708, 1, 0, 0, 0, 13613, 13614, 7, 11, 0, 0, 13614, 13615, 7, 10, 0, 0, + 13615, 13616, 7, 21, 0, 0, 13616, 13617, 7, 6, 0, 0, 13617, 13618, 7, 8, + 0, 0, 13618, 1710, 1, 0, 0, 0, 13619, 13620, 7, 11, 0, 0, 13620, 13621, + 7, 10, 0, 0, 13621, 13622, 7, 21, 0, 0, 13622, 13623, 7, 6, 0, 0, 13623, + 13624, 5, 95, 0, 0, 13624, 13625, 7, 6, 0, 0, 13625, 13626, 7, 25, 0, 0, + 13626, 13627, 7, 15, 0, 0, 13627, 13628, 7, 0, 0, 0, 13628, 13629, 7, 7, + 0, 0, 13629, 13630, 7, 9, 0, 0, 13630, 1712, 1, 0, 0, 0, 13631, 13632, + 7, 11, 0, 0, 13632, 13633, 7, 10, 0, 0, 13633, 13634, 7, 21, 0, 0, 13634, + 13635, 7, 6, 0, 0, 13635, 1714, 1, 0, 0, 0, 13636, 13637, 7, 11, 0, 0, + 13637, 13638, 7, 10, 0, 0, 13638, 13639, 7, 14, 0, 0, 13639, 13640, 7, + 10, 0, 0, 13640, 13641, 7, 4, 0, 0, 13641, 1716, 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, 6, 0, 0, 13646, 13647, 7, 0, 0, 0, 13647, 13648, 7, 3, 0, 0, + 13648, 1718, 1, 0, 0, 0, 13649, 13650, 7, 11, 0, 0, 13650, 13651, 7, 10, + 0, 0, 13651, 13652, 7, 7, 0, 0, 13652, 13653, 7, 6, 0, 0, 13653, 13654, + 7, 5, 0, 0, 13654, 1720, 1, 0, 0, 0, 13655, 13656, 7, 11, 0, 0, 13656, + 13657, 7, 10, 0, 0, 13657, 13658, 7, 7, 0, 0, 13658, 13659, 7, 21, 0, 0, + 13659, 1722, 1, 0, 0, 0, 13660, 13661, 7, 11, 0, 0, 13661, 13662, 7, 10, + 0, 0, 13662, 13663, 7, 5, 0, 0, 13663, 13664, 7, 4, 0, 0, 13664, 1724, + 1, 0, 0, 0, 13665, 13666, 7, 11, 0, 0, 13666, 13667, 7, 10, 0, 0, 13667, + 13668, 7, 4, 0, 0, 13668, 13669, 7, 4, 0, 0, 13669, 13670, 7, 11, 0, 0, + 13670, 13671, 7, 6, 0, 0, 13671, 1726, 1, 0, 0, 0, 13672, 13673, 7, 11, + 0, 0, 13673, 13674, 7, 11, 0, 0, 13674, 13675, 7, 5, 0, 0, 13675, 1728, + 1, 0, 0, 0, 13676, 13677, 7, 11, 0, 0, 13677, 13678, 7, 7, 0, 0, 13678, + 1730, 1, 0, 0, 0, 13679, 13680, 7, 11, 0, 0, 13680, 13681, 7, 7, 0, 0, + 13681, 13682, 7, 7, 0, 0, 13682, 13683, 7, 13, 0, 0, 13683, 13684, 7, 11, + 0, 0, 13684, 1732, 1, 0, 0, 0, 13685, 13686, 7, 11, 0, 0, 13686, 13687, + 7, 2, 0, 0, 13687, 13688, 7, 0, 0, 0, 13688, 13689, 7, 9, 0, 0, 13689, + 1734, 1, 0, 0, 0, 13690, 13691, 7, 11, 0, 0, 13691, 13692, 7, 2, 0, 0, + 13692, 13693, 7, 1, 0, 0, 13693, 1736, 1, 0, 0, 0, 13694, 13695, 7, 11, + 0, 0, 13695, 13696, 7, 2, 0, 0, 13696, 13697, 7, 1, 0, 0, 13697, 13698, + 7, 16, 0, 0, 13698, 13699, 7, 10, 0, 0, 13699, 13700, 7, 11, 0, 0, 13700, + 13701, 7, 6, 0, 0, 13701, 1738, 1, 0, 0, 0, 13702, 13703, 7, 11, 0, 0, + 13703, 13704, 7, 2, 0, 0, 13704, 13705, 7, 1, 0, 0, 13705, 13706, 7, 7, + 0, 0, 13706, 13707, 7, 13, 0, 0, 13707, 13708, 7, 11, 0, 0, 13708, 1740, + 1, 0, 0, 0, 13709, 13710, 7, 11, 0, 0, 13710, 13711, 7, 2, 0, 0, 13711, + 13712, 7, 1, 0, 0, 13712, 13713, 7, 5, 0, 0, 13713, 1742, 1, 0, 0, 0, 13714, + 13715, 7, 11, 0, 0, 13715, 13716, 7, 2, 0, 0, 13716, 13717, 7, 8, 0, 0, + 13717, 13718, 7, 0, 0, 0, 13718, 13719, 7, 11, 0, 0, 13719, 13720, 5, 95, + 0, 0, 13720, 13721, 7, 10, 0, 0, 13721, 13722, 7, 7, 0, 0, 13722, 13723, + 7, 9, 0, 0, 13723, 13724, 7, 6, 0, 0, 13724, 13725, 7, 25, 0, 0, 13725, + 13726, 7, 6, 0, 0, 13726, 13727, 7, 5, 0, 0, 13727, 1744, 1, 0, 0, 0, 13728, + 13729, 7, 11, 0, 0, 13729, 13730, 7, 2, 0, 0, 13730, 13731, 7, 8, 0, 0, + 13731, 13732, 7, 0, 0, 0, 13732, 13733, 7, 11, 0, 0, 13733, 1746, 1, 0, + 0, 0, 13734, 13735, 7, 11, 0, 0, 13735, 13736, 7, 2, 0, 0, 13736, 13737, + 7, 8, 0, 0, 13737, 13738, 7, 0, 0, 0, 13738, 13739, 7, 11, 0, 0, 13739, + 13740, 7, 4, 0, 0, 13740, 13741, 7, 10, 0, 0, 13741, 13742, 7, 14, 0, 0, + 13742, 13743, 7, 6, 0, 0, 13743, 1748, 1, 0, 0, 0, 13744, 13745, 7, 11, + 0, 0, 13745, 13746, 7, 2, 0, 0, 13746, 13747, 7, 8, 0, 0, 13747, 13748, + 7, 0, 0, 0, 13748, 13749, 7, 11, 0, 0, 13749, 13750, 7, 4, 0, 0, 13750, + 13751, 7, 10, 0, 0, 13751, 13752, 7, 14, 0, 0, 13752, 13753, 7, 6, 0, 0, + 13753, 13754, 7, 5, 0, 0, 13754, 13755, 7, 4, 0, 0, 13755, 13756, 7, 0, + 0, 0, 13756, 13757, 7, 14, 0, 0, 13757, 13758, 7, 15, 0, 0, 13758, 1750, + 1, 0, 0, 0, 13759, 13760, 7, 11, 0, 0, 13760, 13761, 7, 2, 0, 0, 13761, + 13762, 7, 8, 0, 0, 13762, 13763, 7, 0, 0, 0, 13763, 13764, 7, 4, 0, 0, + 13764, 13765, 7, 10, 0, 0, 13765, 13766, 7, 2, 0, 0, 13766, 13767, 7, 7, + 0, 0, 13767, 1752, 1, 0, 0, 0, 13768, 13769, 7, 11, 0, 0, 13769, 13770, + 7, 2, 0, 0, 13770, 13771, 7, 8, 0, 0, 13771, 13772, 7, 0, 0, 0, 13772, + 13773, 7, 4, 0, 0, 13773, 13774, 7, 2, 0, 0, 13774, 13775, 7, 3, 0, 0, + 13775, 1754, 1, 0, 0, 0, 13776, 13777, 7, 11, 0, 0, 13777, 13778, 7, 2, + 0, 0, 13778, 13779, 7, 8, 0, 0, 13779, 13780, 7, 21, 0, 0, 13780, 13781, + 7, 9, 0, 0, 13781, 13782, 7, 2, 0, 0, 13782, 13783, 7, 22, 0, 0, 13783, + 13784, 7, 7, 0, 0, 13784, 1756, 1, 0, 0, 0, 13785, 13786, 7, 11, 0, 0, + 13786, 13787, 7, 2, 0, 0, 13787, 13788, 7, 8, 0, 0, 13788, 13789, 7, 21, + 0, 0, 13789, 13790, 7, 6, 0, 0, 13790, 13791, 7, 9, 0, 0, 13791, 1758, + 1, 0, 0, 0, 13792, 13793, 7, 11, 0, 0, 13793, 13794, 7, 2, 0, 0, 13794, + 13795, 7, 8, 0, 0, 13795, 13796, 7, 21, 0, 0, 13796, 13797, 7, 10, 0, 0, + 13797, 13798, 7, 7, 0, 0, 13798, 13799, 7, 17, 0, 0, 13799, 1760, 1, 0, + 0, 0, 13800, 13801, 7, 11, 0, 0, 13801, 13802, 7, 2, 0, 0, 13802, 13803, + 7, 8, 0, 0, 13803, 13804, 7, 21, 0, 0, 13804, 1762, 1, 0, 0, 0, 13805, + 13806, 7, 11, 0, 0, 13806, 13807, 7, 2, 0, 0, 13807, 13808, 7, 17, 0, 0, + 13808, 13809, 7, 16, 0, 0, 13809, 13810, 7, 10, 0, 0, 13810, 13811, 7, + 11, 0, 0, 13811, 13812, 7, 6, 0, 0, 13812, 1764, 1, 0, 0, 0, 13813, 13814, + 7, 11, 0, 0, 13814, 13815, 7, 2, 0, 0, 13815, 13816, 7, 17, 0, 0, 13816, + 13817, 7, 16, 0, 0, 13817, 13818, 7, 10, 0, 0, 13818, 13819, 7, 11, 0, + 0, 13819, 13820, 7, 6, 0, 0, 13820, 13821, 7, 5, 0, 0, 13821, 1766, 1, + 0, 0, 0, 13822, 13823, 7, 11, 0, 0, 13823, 13824, 7, 2, 0, 0, 13824, 13825, + 7, 17, 0, 0, 13825, 13826, 7, 17, 0, 0, 13826, 13827, 7, 10, 0, 0, 13827, + 13828, 7, 7, 0, 0, 13828, 13829, 7, 17, 0, 0, 13829, 1768, 1, 0, 0, 0, + 13830, 13831, 7, 11, 0, 0, 13831, 13832, 7, 2, 0, 0, 13832, 13833, 7, 17, + 0, 0, 13833, 13834, 7, 10, 0, 0, 13834, 13835, 7, 8, 0, 0, 13835, 13836, + 7, 0, 0, 0, 13836, 13837, 7, 11, 0, 0, 13837, 1770, 1, 0, 0, 0, 13838, + 13839, 7, 11, 0, 0, 13839, 13840, 7, 2, 0, 0, 13840, 13841, 7, 17, 0, 0, + 13841, 13842, 7, 10, 0, 0, 13842, 13843, 7, 8, 0, 0, 13843, 13844, 7, 0, + 0, 0, 13844, 13845, 7, 11, 0, 0, 13845, 13846, 5, 95, 0, 0, 13846, 13847, + 7, 3, 0, 0, 13847, 13848, 7, 6, 0, 0, 13848, 13849, 7, 0, 0, 0, 13849, + 13850, 7, 9, 0, 0, 13850, 13851, 7, 5, 0, 0, 13851, 13852, 5, 95, 0, 0, + 13852, 13853, 7, 15, 0, 0, 13853, 13854, 7, 6, 0, 0, 13854, 13855, 7, 3, + 0, 0, 13855, 13856, 5, 95, 0, 0, 13856, 13857, 7, 8, 0, 0, 13857, 13858, + 7, 0, 0, 0, 13858, 13859, 7, 11, 0, 0, 13859, 13860, 7, 11, 0, 0, 13860, + 1772, 1, 0, 0, 0, 13861, 13862, 7, 11, 0, 0, 13862, 13863, 7, 2, 0, 0, + 13863, 13864, 7, 17, 0, 0, 13864, 13865, 7, 10, 0, 0, 13865, 13866, 7, + 8, 0, 0, 13866, 13867, 7, 0, 0, 0, 13867, 13868, 7, 11, 0, 0, 13868, 13869, + 5, 95, 0, 0, 13869, 13870, 7, 3, 0, 0, 13870, 13871, 7, 6, 0, 0, 13871, + 13872, 7, 0, 0, 0, 13872, 13873, 7, 9, 0, 0, 13873, 13874, 7, 5, 0, 0, + 13874, 13875, 5, 95, 0, 0, 13875, 13876, 7, 15, 0, 0, 13876, 13877, 7, + 6, 0, 0, 13877, 13878, 7, 3, 0, 0, 13878, 13879, 5, 95, 0, 0, 13879, 13880, + 7, 5, 0, 0, 13880, 13881, 7, 6, 0, 0, 13881, 13882, 7, 5, 0, 0, 13882, + 13883, 7, 5, 0, 0, 13883, 13884, 7, 10, 0, 0, 13884, 13885, 7, 2, 0, 0, + 13885, 13886, 7, 7, 0, 0, 13886, 1774, 1, 0, 0, 0, 13887, 13888, 7, 11, + 0, 0, 13888, 13889, 7, 2, 0, 0, 13889, 13890, 7, 17, 0, 0, 13890, 1776, + 1, 0, 0, 0, 13891, 13892, 7, 11, 0, 0, 13892, 13893, 7, 2, 0, 0, 13893, + 13894, 7, 17, 0, 0, 13894, 13895, 7, 14, 0, 0, 13895, 13896, 7, 10, 0, + 0, 13896, 13897, 7, 7, 0, 0, 13897, 13898, 7, 10, 0, 0, 13898, 13899, 7, + 7, 0, 0, 13899, 13900, 7, 17, 0, 0, 13900, 1778, 1, 0, 0, 0, 13901, 13902, + 7, 11, 0, 0, 13902, 13903, 7, 2, 0, 0, 13903, 13904, 7, 17, 0, 0, 13904, + 13905, 7, 2, 0, 0, 13905, 13906, 7, 16, 0, 0, 13906, 13907, 7, 16, 0, 0, + 13907, 1780, 1, 0, 0, 0, 13908, 13909, 7, 11, 0, 0, 13909, 13910, 7, 2, + 0, 0, 13910, 13911, 7, 17, 0, 0, 13911, 13912, 7, 2, 0, 0, 13912, 13913, + 7, 7, 0, 0, 13913, 1782, 1, 0, 0, 0, 13914, 13915, 7, 11, 0, 0, 13915, + 13916, 7, 2, 0, 0, 13916, 13917, 7, 17, 0, 0, 13917, 13918, 5, 95, 0, 0, + 13918, 13919, 7, 3, 0, 0, 13919, 13920, 7, 6, 0, 0, 13920, 13921, 7, 0, + 0, 0, 13921, 13922, 7, 9, 0, 0, 13922, 13923, 5, 95, 0, 0, 13923, 13924, + 7, 2, 0, 0, 13924, 13925, 7, 7, 0, 0, 13925, 13926, 7, 11, 0, 0, 13926, + 13927, 7, 18, 0, 0, 13927, 13928, 5, 95, 0, 0, 13928, 13929, 7, 13, 0, + 0, 13929, 13930, 7, 10, 0, 0, 13930, 13931, 7, 2, 0, 0, 13931, 13932, 7, + 11, 0, 0, 13932, 13933, 7, 0, 0, 0, 13933, 13934, 7, 4, 0, 0, 13934, 13935, + 7, 10, 0, 0, 13935, 13936, 7, 2, 0, 0, 13936, 13937, 7, 7, 0, 0, 13937, + 13938, 7, 5, 0, 0, 13938, 1784, 1, 0, 0, 0, 13939, 13940, 7, 11, 0, 0, + 13940, 13941, 7, 2, 0, 0, 13941, 13942, 7, 7, 0, 0, 13942, 13943, 7, 17, + 0, 0, 13943, 1786, 1, 0, 0, 0, 13944, 13945, 7, 11, 0, 0, 13945, 13946, + 7, 2, 0, 0, 13946, 13947, 7, 2, 0, 0, 13947, 13948, 7, 15, 0, 0, 13948, + 1788, 1, 0, 0, 0, 13949, 13950, 7, 11, 0, 0, 13950, 13951, 7, 2, 0, 0, + 13951, 13952, 7, 5, 0, 0, 13952, 13953, 7, 4, 0, 0, 13953, 1790, 1, 0, + 0, 0, 13954, 13955, 7, 11, 0, 0, 13955, 13956, 7, 2, 0, 0, 13956, 13957, + 7, 22, 0, 0, 13957, 13958, 7, 6, 0, 0, 13958, 13959, 7, 3, 0, 0, 13959, + 1792, 1, 0, 0, 0, 13960, 13961, 7, 11, 0, 0, 13961, 13962, 7, 2, 0, 0, + 13962, 13963, 7, 22, 0, 0, 13963, 1794, 1, 0, 0, 0, 13964, 13965, 7, 11, + 0, 0, 13965, 13966, 7, 15, 0, 0, 13966, 13967, 7, 0, 0, 0, 13967, 13968, + 7, 9, 0, 0, 13968, 1796, 1, 0, 0, 0, 13969, 13970, 7, 11, 0, 0, 13970, + 13971, 7, 3, 0, 0, 13971, 13972, 7, 4, 0, 0, 13972, 13973, 7, 3, 0, 0, + 13973, 13974, 7, 10, 0, 0, 13974, 13975, 7, 14, 0, 0, 13975, 1798, 1, 0, + 0, 0, 13976, 13977, 7, 11, 0, 0, 13977, 13978, 7, 4, 0, 0, 13978, 13979, + 7, 3, 0, 0, 13979, 13980, 7, 10, 0, 0, 13980, 13981, 7, 14, 0, 0, 13981, + 1800, 1, 0, 0, 0, 13982, 13983, 7, 14, 0, 0, 13983, 1802, 1, 0, 0, 0, 13984, + 13985, 7, 14, 0, 0, 13985, 13986, 7, 0, 0, 0, 13986, 13987, 7, 10, 0, 0, + 13987, 13988, 7, 7, 0, 0, 13988, 1804, 1, 0, 0, 0, 13989, 13990, 7, 14, + 0, 0, 13990, 13991, 7, 0, 0, 0, 13991, 13992, 7, 21, 0, 0, 13992, 13993, + 7, 6, 0, 0, 13993, 13994, 5, 95, 0, 0, 13994, 13995, 7, 3, 0, 0, 13995, + 13996, 7, 6, 0, 0, 13996, 13997, 7, 16, 0, 0, 13997, 1806, 1, 0, 0, 0, + 13998, 13999, 7, 14, 0, 0, 13999, 14000, 7, 0, 0, 0, 14000, 14001, 7, 7, + 0, 0, 14001, 14002, 7, 0, 0, 0, 14002, 14003, 7, 17, 0, 0, 14003, 14004, + 7, 6, 0, 0, 14004, 14005, 7, 9, 0, 0, 14005, 1808, 1, 0, 0, 0, 14006, 14007, + 7, 14, 0, 0, 14007, 14008, 7, 0, 0, 0, 14008, 14009, 7, 7, 0, 0, 14009, + 14010, 7, 0, 0, 0, 14010, 14011, 7, 17, 0, 0, 14011, 14012, 7, 6, 0, 0, + 14012, 1810, 1, 0, 0, 0, 14013, 14014, 7, 14, 0, 0, 14014, 14015, 7, 0, + 0, 0, 14015, 14016, 7, 7, 0, 0, 14016, 14017, 7, 0, 0, 0, 14017, 14018, + 7, 17, 0, 0, 14018, 14019, 7, 6, 0, 0, 14019, 14020, 7, 14, 0, 0, 14020, + 14021, 7, 6, 0, 0, 14021, 14022, 7, 7, 0, 0, 14022, 14023, 7, 4, 0, 0, + 14023, 1812, 1, 0, 0, 0, 14024, 14025, 7, 14, 0, 0, 14025, 14026, 7, 0, + 0, 0, 14026, 14027, 7, 7, 0, 0, 14027, 14028, 7, 0, 0, 0, 14028, 14029, + 7, 17, 0, 0, 14029, 14030, 7, 6, 0, 0, 14030, 14031, 7, 3, 0, 0, 14031, + 1814, 1, 0, 0, 0, 14032, 14033, 7, 14, 0, 0, 14033, 14034, 7, 0, 0, 0, + 14034, 14035, 7, 7, 0, 0, 14035, 14036, 7, 9, 0, 0, 14036, 14037, 7, 0, + 0, 0, 14037, 14038, 7, 4, 0, 0, 14038, 14039, 7, 2, 0, 0, 14039, 14040, + 7, 3, 0, 0, 14040, 14041, 7, 18, 0, 0, 14041, 1816, 1, 0, 0, 0, 14042, + 14043, 7, 14, 0, 0, 14043, 14044, 7, 0, 0, 0, 14044, 14045, 7, 7, 0, 0, + 14045, 14046, 7, 12, 0, 0, 14046, 14047, 7, 0, 0, 0, 14047, 14048, 7, 11, + 0, 0, 14048, 1818, 1, 0, 0, 0, 14049, 14050, 7, 14, 0, 0, 14050, 14051, + 7, 0, 0, 0, 14051, 14052, 7, 15, 0, 0, 14052, 1820, 1, 0, 0, 0, 14053, + 14054, 7, 14, 0, 0, 14054, 14055, 7, 0, 0, 0, 14055, 14056, 7, 15, 0, 0, + 14056, 14057, 7, 15, 0, 0, 14057, 14058, 7, 10, 0, 0, 14058, 14059, 7, + 7, 0, 0, 14059, 14060, 7, 17, 0, 0, 14060, 1822, 1, 0, 0, 0, 14061, 14062, + 7, 14, 0, 0, 14062, 14063, 7, 0, 0, 0, 14063, 14064, 7, 5, 0, 0, 14064, + 14065, 7, 21, 0, 0, 14065, 1824, 1, 0, 0, 0, 14066, 14067, 7, 14, 0, 0, + 14067, 14068, 7, 0, 0, 0, 14068, 14069, 7, 5, 0, 0, 14069, 14070, 7, 4, + 0, 0, 14070, 14071, 7, 6, 0, 0, 14071, 14072, 7, 3, 0, 0, 14072, 1826, + 1, 0, 0, 0, 14073, 14074, 7, 14, 0, 0, 14074, 14075, 7, 0, 0, 0, 14075, + 14076, 7, 4, 0, 0, 14076, 14077, 7, 8, 0, 0, 14077, 14078, 7, 19, 0, 0, + 14078, 14079, 7, 6, 0, 0, 14079, 14080, 7, 9, 0, 0, 14080, 1828, 1, 0, + 0, 0, 14081, 14082, 7, 14, 0, 0, 14082, 14083, 7, 0, 0, 0, 14083, 14084, + 7, 4, 0, 0, 14084, 14085, 7, 8, 0, 0, 14085, 14086, 7, 19, 0, 0, 14086, + 14087, 7, 6, 0, 0, 14087, 14088, 7, 5, 0, 0, 14088, 1830, 1, 0, 0, 0, 14089, + 14090, 7, 14, 0, 0, 14090, 14091, 7, 0, 0, 0, 14091, 14092, 7, 4, 0, 0, + 14092, 14093, 7, 8, 0, 0, 14093, 14094, 7, 19, 0, 0, 14094, 1832, 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, 7, 0, 0, 14102, 14103, 7, 12, 0, 0, + 14103, 14104, 7, 14, 0, 0, 14104, 14105, 7, 1, 0, 0, 14105, 14106, 7, 6, + 0, 0, 14106, 14107, 7, 3, 0, 0, 14107, 1834, 1, 0, 0, 0, 14108, 14109, + 7, 14, 0, 0, 14109, 14110, 7, 0, 0, 0, 14110, 14111, 7, 4, 0, 0, 14111, + 14112, 7, 8, 0, 0, 14112, 14113, 7, 19, 0, 0, 14113, 14114, 5, 95, 0, 0, + 14114, 14115, 7, 3, 0, 0, 14115, 14116, 7, 6, 0, 0, 14116, 14117, 7, 8, + 0, 0, 14117, 14118, 7, 2, 0, 0, 14118, 14119, 7, 17, 0, 0, 14119, 14120, + 7, 7, 0, 0, 14120, 14121, 7, 10, 0, 0, 14121, 14122, 7, 23, 0, 0, 14122, + 14123, 7, 6, 0, 0, 14123, 1836, 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, 14136, 7, 9, 0, 0, + 14136, 1838, 1, 0, 0, 0, 14137, 14138, 7, 14, 0, 0, 14138, 14139, 7, 0, + 0, 0, 14139, 14140, 7, 4, 0, 0, 14140, 14141, 7, 6, 0, 0, 14141, 14142, + 7, 3, 0, 0, 14142, 14143, 7, 10, 0, 0, 14143, 14144, 7, 0, 0, 0, 14144, + 14145, 7, 11, 0, 0, 14145, 14146, 7, 10, 0, 0, 14146, 14147, 7, 23, 0, + 0, 14147, 14148, 7, 6, 0, 0, 14148, 1840, 1, 0, 0, 0, 14149, 14150, 7, + 14, 0, 0, 14150, 14151, 7, 0, 0, 0, 14151, 14152, 7, 25, 0, 0, 14152, 14153, + 7, 0, 0, 0, 14153, 14154, 7, 3, 0, 0, 14154, 14155, 7, 8, 0, 0, 14155, + 14156, 7, 19, 0, 0, 14156, 14157, 7, 11, 0, 0, 14157, 14158, 7, 2, 0, 0, + 14158, 14159, 7, 17, 0, 0, 14159, 14160, 7, 5, 0, 0, 14160, 1842, 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, 9, 0, 0, 14165, 14166, 7, 0, 0, 0, 14166, + 14167, 7, 4, 0, 0, 14167, 14168, 7, 0, 0, 0, 14168, 14169, 7, 16, 0, 0, + 14169, 14170, 7, 10, 0, 0, 14170, 14171, 7, 11, 0, 0, 14171, 14172, 7, + 6, 0, 0, 14172, 14173, 7, 5, 0, 0, 14173, 1844, 1, 0, 0, 0, 14174, 14175, + 7, 14, 0, 0, 14175, 14176, 7, 0, 0, 0, 14176, 14177, 7, 25, 0, 0, 14177, + 14178, 7, 6, 0, 0, 14178, 14179, 7, 25, 0, 0, 14179, 14180, 7, 4, 0, 0, + 14180, 14181, 7, 6, 0, 0, 14181, 14182, 7, 7, 0, 0, 14182, 14183, 7, 4, + 0, 0, 14183, 14184, 7, 5, 0, 0, 14184, 1846, 1, 0, 0, 0, 14185, 14186, + 7, 14, 0, 0, 14186, 14187, 7, 0, 0, 0, 14187, 14188, 7, 25, 0, 0, 14188, + 14189, 7, 10, 0, 0, 14189, 14190, 7, 14, 0, 0, 14190, 14191, 7, 10, 0, + 0, 14191, 14192, 7, 23, 0, 0, 14192, 14193, 7, 6, 0, 0, 14193, 1848, 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, 10, 0, 0, 14198, 14199, 7, 7, 0, 0, 14199, + 14200, 7, 5, 0, 0, 14200, 14201, 7, 4, 0, 0, 14201, 14202, 7, 0, 0, 0, + 14202, 14203, 7, 7, 0, 0, 14203, 14204, 7, 8, 0, 0, 14204, 14205, 7, 6, + 0, 0, 14205, 14206, 7, 5, 0, 0, 14206, 1850, 1, 0, 0, 0, 14207, 14208, + 7, 14, 0, 0, 14208, 14209, 7, 0, 0, 0, 14209, 14210, 7, 25, 0, 0, 14210, + 14211, 7, 11, 0, 0, 14211, 14212, 7, 2, 0, 0, 14212, 14213, 7, 17, 0, 0, + 14213, 14214, 7, 16, 0, 0, 14214, 14215, 7, 10, 0, 0, 14215, 14216, 7, + 11, 0, 0, 14216, 14217, 7, 6, 0, 0, 14217, 14218, 7, 5, 0, 0, 14218, 1852, + 1, 0, 0, 0, 14219, 14220, 7, 14, 0, 0, 14220, 14221, 7, 0, 0, 0, 14221, + 14222, 7, 25, 0, 0, 14222, 14223, 7, 11, 0, 0, 14223, 14224, 7, 2, 0, 0, + 14224, 14225, 7, 17, 0, 0, 14225, 14226, 7, 19, 0, 0, 14226, 14227, 7, + 10, 0, 0, 14227, 14228, 7, 5, 0, 0, 14228, 14229, 7, 4, 0, 0, 14229, 14230, + 7, 2, 0, 0, 14230, 14231, 7, 3, 0, 0, 14231, 14232, 7, 18, 0, 0, 14232, + 1854, 1, 0, 0, 0, 14233, 14234, 7, 14, 0, 0, 14234, 14235, 7, 0, 0, 0, + 14235, 14236, 7, 25, 0, 0, 14236, 14237, 7, 11, 0, 0, 14237, 14238, 7, + 2, 0, 0, 14238, 14239, 7, 17, 0, 0, 14239, 14240, 7, 14, 0, 0, 14240, 14241, + 7, 6, 0, 0, 14241, 14242, 7, 14, 0, 0, 14242, 14243, 7, 1, 0, 0, 14243, + 14244, 7, 6, 0, 0, 14244, 14245, 7, 3, 0, 0, 14245, 14246, 7, 5, 0, 0, + 14246, 1856, 1, 0, 0, 0, 14247, 14248, 7, 14, 0, 0, 14248, 14249, 7, 0, + 0, 0, 14249, 14250, 7, 25, 0, 0, 14250, 14251, 5, 95, 0, 0, 14251, 14252, + 7, 5, 0, 0, 14252, 14253, 7, 19, 0, 0, 14253, 14254, 7, 0, 0, 0, 14254, + 14255, 7, 3, 0, 0, 14255, 14256, 7, 6, 0, 0, 14256, 14257, 7, 9, 0, 0, + 14257, 14258, 5, 95, 0, 0, 14258, 14259, 7, 4, 0, 0, 14259, 14260, 7, 6, + 0, 0, 14260, 14261, 7, 14, 0, 0, 14261, 14262, 7, 15, 0, 0, 14262, 14263, + 5, 95, 0, 0, 14263, 14264, 7, 5, 0, 0, 14264, 14265, 7, 10, 0, 0, 14265, + 14266, 7, 23, 0, 0, 14266, 14267, 7, 6, 0, 0, 14267, 1858, 1, 0, 0, 0, + 14268, 14269, 7, 14, 0, 0, 14269, 14270, 7, 0, 0, 0, 14270, 14271, 7, 25, + 0, 0, 14271, 14272, 7, 5, 0, 0, 14272, 14273, 7, 10, 0, 0, 14273, 14274, + 7, 23, 0, 0, 14274, 14275, 7, 6, 0, 0, 14275, 1860, 1, 0, 0, 0, 14276, + 14277, 7, 14, 0, 0, 14277, 14278, 7, 0, 0, 0, 14278, 14279, 7, 25, 0, 0, + 14279, 14280, 7, 4, 0, 0, 14280, 14281, 7, 3, 0, 0, 14281, 14282, 7, 0, + 0, 0, 14282, 14283, 7, 7, 0, 0, 14283, 14284, 7, 5, 0, 0, 14284, 1862, + 1, 0, 0, 0, 14285, 14286, 7, 14, 0, 0, 14286, 14287, 7, 0, 0, 0, 14287, + 14288, 7, 25, 0, 0, 14288, 14289, 7, 13, 0, 0, 14289, 14290, 7, 0, 0, 0, + 14290, 14291, 7, 11, 0, 0, 14291, 14292, 7, 12, 0, 0, 14292, 14293, 7, + 6, 0, 0, 14293, 1864, 1, 0, 0, 0, 14294, 14295, 7, 14, 0, 0, 14295, 14296, + 7, 6, 0, 0, 14296, 14297, 7, 0, 0, 0, 14297, 14298, 7, 5, 0, 0, 14298, + 14299, 7, 12, 0, 0, 14299, 14300, 7, 3, 0, 0, 14300, 14301, 7, 6, 0, 0, + 14301, 1866, 1, 0, 0, 0, 14302, 14303, 7, 14, 0, 0, 14303, 14304, 7, 6, + 0, 0, 14304, 14305, 7, 0, 0, 0, 14305, 14306, 7, 5, 0, 0, 14306, 14307, + 7, 12, 0, 0, 14307, 14308, 7, 3, 0, 0, 14308, 14309, 7, 6, 0, 0, 14309, + 14310, 7, 5, 0, 0, 14310, 1868, 1, 0, 0, 0, 14311, 14312, 7, 14, 0, 0, + 14312, 14313, 7, 6, 0, 0, 14313, 14314, 7, 9, 0, 0, 14314, 14315, 7, 10, + 0, 0, 14315, 14316, 7, 12, 0, 0, 14316, 14317, 7, 14, 0, 0, 14317, 1870, + 1, 0, 0, 0, 14318, 14319, 7, 14, 0, 0, 14319, 14320, 7, 6, 0, 0, 14320, + 14321, 7, 14, 0, 0, 14321, 14322, 7, 1, 0, 0, 14322, 14323, 7, 6, 0, 0, + 14323, 14324, 7, 3, 0, 0, 14324, 1872, 1, 0, 0, 0, 14325, 14326, 7, 14, + 0, 0, 14326, 14327, 7, 6, 0, 0, 14327, 14328, 7, 14, 0, 0, 14328, 14329, + 7, 1, 0, 0, 14329, 14330, 7, 6, 0, 0, 14330, 14331, 7, 3, 0, 0, 14331, + 14332, 5, 95, 0, 0, 14332, 14333, 7, 8, 0, 0, 14333, 14334, 7, 0, 0, 0, + 14334, 14335, 7, 15, 0, 0, 14335, 14336, 7, 4, 0, 0, 14336, 14337, 7, 10, + 0, 0, 14337, 14338, 7, 2, 0, 0, 14338, 14339, 7, 7, 0, 0, 14339, 1874, + 1, 0, 0, 0, 14340, 14341, 7, 14, 0, 0, 14341, 14342, 7, 6, 0, 0, 14342, + 14343, 7, 14, 0, 0, 14343, 14344, 7, 1, 0, 0, 14344, 14345, 7, 6, 0, 0, + 14345, 14346, 7, 3, 0, 0, 14346, 14347, 5, 95, 0, 0, 14347, 14348, 7, 9, + 0, 0, 14348, 14349, 7, 6, 0, 0, 14349, 14350, 7, 5, 0, 0, 14350, 14351, + 7, 8, 0, 0, 14351, 14352, 7, 3, 0, 0, 14352, 14353, 7, 10, 0, 0, 14353, + 14354, 7, 15, 0, 0, 14354, 14355, 7, 4, 0, 0, 14355, 14356, 7, 10, 0, 0, + 14356, 14357, 7, 2, 0, 0, 14357, 14358, 7, 7, 0, 0, 14358, 1876, 1, 0, + 0, 0, 14359, 14360, 7, 14, 0, 0, 14360, 14361, 7, 6, 0, 0, 14361, 14362, + 7, 14, 0, 0, 14362, 14363, 7, 1, 0, 0, 14363, 14364, 7, 6, 0, 0, 14364, + 14365, 7, 3, 0, 0, 14365, 14366, 5, 95, 0, 0, 14366, 14367, 7, 7, 0, 0, + 14367, 14368, 7, 0, 0, 0, 14368, 14369, 7, 14, 0, 0, 14369, 14370, 7, 6, + 0, 0, 14370, 1878, 1, 0, 0, 0, 14371, 14372, 7, 14, 0, 0, 14372, 14373, + 7, 6, 0, 0, 14373, 14374, 7, 14, 0, 0, 14374, 14375, 7, 1, 0, 0, 14375, + 14376, 7, 6, 0, 0, 14376, 14377, 7, 3, 0, 0, 14377, 14378, 5, 95, 0, 0, + 14378, 14379, 7, 12, 0, 0, 14379, 14380, 7, 7, 0, 0, 14380, 14381, 7, 10, + 0, 0, 14381, 14382, 7, 24, 0, 0, 14382, 14383, 7, 12, 0, 0, 14383, 14384, + 7, 6, 0, 0, 14384, 14385, 5, 95, 0, 0, 14385, 14386, 7, 7, 0, 0, 14386, + 14387, 7, 0, 0, 0, 14387, 14388, 7, 14, 0, 0, 14388, 14389, 7, 6, 0, 0, + 14389, 1880, 1, 0, 0, 0, 14390, 14391, 7, 14, 0, 0, 14391, 14392, 7, 6, + 0, 0, 14392, 14393, 7, 14, 0, 0, 14393, 14394, 7, 8, 0, 0, 14394, 14395, + 7, 2, 0, 0, 14395, 14396, 7, 14, 0, 0, 14396, 14397, 7, 15, 0, 0, 14397, + 14398, 7, 3, 0, 0, 14398, 14399, 7, 6, 0, 0, 14399, 14400, 7, 5, 0, 0, + 14400, 14401, 7, 5, 0, 0, 14401, 1882, 1, 0, 0, 0, 14402, 14403, 7, 14, + 0, 0, 14403, 14404, 7, 6, 0, 0, 14404, 14405, 7, 14, 0, 0, 14405, 14406, + 7, 2, 0, 0, 14406, 14407, 7, 3, 0, 0, 14407, 14408, 7, 18, 0, 0, 14408, + 1884, 1, 0, 0, 0, 14409, 14410, 7, 14, 0, 0, 14410, 14411, 7, 6, 0, 0, + 14411, 14412, 7, 3, 0, 0, 14412, 14413, 7, 17, 0, 0, 14413, 14414, 7, 6, + 0, 0, 14414, 14415, 5, 36, 0, 0, 14415, 14416, 7, 0, 0, 0, 14416, 14417, + 7, 8, 0, 0, 14417, 14418, 7, 4, 0, 0, 14418, 14419, 7, 10, 0, 0, 14419, + 14420, 7, 2, 0, 0, 14420, 14421, 7, 7, 0, 0, 14421, 14422, 7, 5, 0, 0, + 14422, 1886, 1, 0, 0, 0, 14423, 14424, 7, 14, 0, 0, 14424, 14425, 7, 6, + 0, 0, 14425, 14426, 7, 3, 0, 0, 14426, 14427, 7, 17, 0, 0, 14427, 14428, + 7, 6, 0, 0, 14428, 14429, 5, 95, 0, 0, 14429, 14430, 7, 0, 0, 0, 14430, + 14431, 7, 20, 0, 0, 14431, 1888, 1, 0, 0, 0, 14432, 14433, 7, 14, 0, 0, + 14433, 14434, 7, 6, 0, 0, 14434, 14435, 7, 3, 0, 0, 14435, 14436, 7, 17, + 0, 0, 14436, 14437, 7, 6, 0, 0, 14437, 14438, 5, 95, 0, 0, 14438, 14439, + 7, 8, 0, 0, 14439, 14440, 7, 2, 0, 0, 14440, 14441, 7, 7, 0, 0, 14441, + 14442, 7, 5, 0, 0, 14442, 14443, 7, 4, 0, 0, 14443, 14444, 5, 95, 0, 0, + 14444, 14445, 7, 2, 0, 0, 14445, 14446, 7, 7, 0, 0, 14446, 1890, 1, 0, + 0, 0, 14447, 14448, 7, 14, 0, 0, 14448, 14449, 7, 6, 0, 0, 14449, 14450, + 7, 3, 0, 0, 14450, 14451, 7, 17, 0, 0, 14451, 14452, 7, 6, 0, 0, 14452, + 1892, 1, 0, 0, 0, 14453, 14454, 7, 14, 0, 0, 14454, 14455, 7, 6, 0, 0, + 14455, 14456, 7, 3, 0, 0, 14456, 14457, 7, 17, 0, 0, 14457, 14458, 7, 6, + 0, 0, 14458, 14459, 5, 95, 0, 0, 14459, 14460, 7, 5, 0, 0, 14460, 14461, + 7, 20, 0, 0, 14461, 1894, 1, 0, 0, 0, 14462, 14463, 7, 14, 0, 0, 14463, + 14464, 7, 6, 0, 0, 14464, 14465, 7, 4, 0, 0, 14465, 14466, 7, 0, 0, 0, + 14466, 14467, 7, 9, 0, 0, 14467, 14468, 7, 0, 0, 0, 14468, 14469, 7, 4, + 0, 0, 14469, 14470, 7, 0, 0, 0, 14470, 1896, 1, 0, 0, 0, 14471, 14472, + 7, 14, 0, 0, 14472, 14473, 7, 6, 0, 0, 14473, 14474, 7, 4, 0, 0, 14474, + 14475, 7, 19, 0, 0, 14475, 14476, 7, 2, 0, 0, 14476, 14477, 7, 9, 0, 0, + 14477, 1898, 1, 0, 0, 0, 14478, 14479, 7, 14, 0, 0, 14479, 14480, 7, 10, + 0, 0, 14480, 14481, 7, 17, 0, 0, 14481, 14482, 7, 3, 0, 0, 14482, 14483, + 7, 0, 0, 0, 14483, 14484, 7, 4, 0, 0, 14484, 14485, 7, 6, 0, 0, 14485, + 1900, 1, 0, 0, 0, 14486, 14487, 7, 14, 0, 0, 14487, 14488, 7, 10, 0, 0, + 14488, 14489, 7, 17, 0, 0, 14489, 14490, 7, 3, 0, 0, 14490, 14491, 7, 0, + 0, 0, 14491, 14492, 7, 4, 0, 0, 14492, 14493, 7, 10, 0, 0, 14493, 14494, + 7, 2, 0, 0, 14494, 14495, 7, 7, 0, 0, 14495, 1902, 1, 0, 0, 0, 14496, 14497, + 7, 14, 0, 0, 14497, 14498, 7, 10, 0, 0, 14498, 14499, 7, 7, 0, 0, 14499, + 14500, 7, 6, 0, 0, 14500, 14501, 7, 25, 0, 0, 14501, 14502, 7, 4, 0, 0, + 14502, 14503, 7, 6, 0, 0, 14503, 14504, 7, 7, 0, 0, 14504, 14505, 7, 4, + 0, 0, 14505, 14506, 7, 5, 0, 0, 14506, 1904, 1, 0, 0, 0, 14507, 14508, + 7, 14, 0, 0, 14508, 14509, 7, 10, 0, 0, 14509, 14510, 7, 7, 0, 0, 14510, + 14511, 7, 10, 0, 0, 14511, 14512, 7, 14, 0, 0, 14512, 14513, 7, 10, 0, + 0, 14513, 14514, 7, 23, 0, 0, 14514, 14515, 7, 6, 0, 0, 14515, 1906, 1, + 0, 0, 0, 14516, 14517, 7, 14, 0, 0, 14517, 14518, 7, 10, 0, 0, 14518, 14519, + 7, 7, 0, 0, 14519, 14520, 7, 10, 0, 0, 14520, 14521, 7, 14, 0, 0, 14521, + 14522, 7, 12, 0, 0, 14522, 14523, 7, 14, 0, 0, 14523, 1908, 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, 10, 0, 0, 14528, 14529, 7, 7, 0, 0, 14529, 14530, + 7, 17, 0, 0, 14530, 1910, 1, 0, 0, 0, 14531, 14532, 7, 14, 0, 0, 14532, + 14533, 7, 10, 0, 0, 14533, 14534, 7, 7, 0, 0, 14534, 14535, 7, 12, 0, 0, + 14535, 14536, 7, 5, 0, 0, 14536, 1912, 1, 0, 0, 0, 14537, 14538, 7, 14, + 0, 0, 14538, 14539, 7, 10, 0, 0, 14539, 14540, 7, 7, 0, 0, 14540, 14541, + 7, 12, 0, 0, 14541, 14542, 7, 5, 0, 0, 14542, 14543, 5, 95, 0, 0, 14543, + 14544, 7, 7, 0, 0, 14544, 14545, 7, 12, 0, 0, 14545, 14546, 7, 11, 0, 0, + 14546, 14547, 7, 11, 0, 0, 14547, 1914, 1, 0, 0, 0, 14548, 14549, 7, 14, + 0, 0, 14549, 14550, 7, 10, 0, 0, 14550, 14551, 7, 7, 0, 0, 14551, 14552, + 7, 12, 0, 0, 14552, 14553, 7, 4, 0, 0, 14553, 14554, 7, 6, 0, 0, 14554, + 1916, 1, 0, 0, 0, 14555, 14556, 7, 14, 0, 0, 14556, 14557, 7, 10, 0, 0, + 14557, 14558, 7, 7, 0, 0, 14558, 14559, 7, 12, 0, 0, 14559, 14560, 7, 4, + 0, 0, 14560, 14561, 7, 6, 0, 0, 14561, 14562, 7, 5, 0, 0, 14562, 1918, + 1, 0, 0, 0, 14563, 14564, 7, 14, 0, 0, 14564, 14565, 7, 10, 0, 0, 14565, + 14566, 7, 7, 0, 0, 14566, 14567, 7, 13, 0, 0, 14567, 14568, 7, 0, 0, 0, + 14568, 14569, 7, 11, 0, 0, 14569, 14570, 7, 12, 0, 0, 14570, 14571, 7, + 6, 0, 0, 14571, 1920, 1, 0, 0, 0, 14572, 14573, 7, 14, 0, 0, 14573, 14574, + 7, 10, 0, 0, 14574, 14575, 7, 3, 0, 0, 14575, 14576, 7, 3, 0, 0, 14576, + 14577, 7, 2, 0, 0, 14577, 14578, 7, 3, 0, 0, 14578, 14579, 7, 8, 0, 0, + 14579, 14580, 7, 2, 0, 0, 14580, 14581, 7, 11, 0, 0, 14581, 14582, 7, 9, + 0, 0, 14582, 1922, 1, 0, 0, 0, 14583, 14584, 7, 14, 0, 0, 14584, 14585, + 7, 10, 0, 0, 14585, 14586, 7, 3, 0, 0, 14586, 14587, 7, 3, 0, 0, 14587, + 14588, 7, 2, 0, 0, 14588, 14589, 7, 3, 0, 0, 14589, 14590, 7, 19, 0, 0, + 14590, 14591, 7, 2, 0, 0, 14591, 14592, 7, 4, 0, 0, 14592, 1924, 1, 0, + 0, 0, 14593, 14594, 7, 14, 0, 0, 14594, 14595, 7, 10, 0, 0, 14595, 14596, + 7, 3, 0, 0, 14596, 14597, 7, 3, 0, 0, 14597, 14598, 7, 2, 0, 0, 14598, + 14599, 7, 3, 0, 0, 14599, 1926, 1, 0, 0, 0, 14600, 14601, 7, 14, 0, 0, + 14601, 14602, 7, 10, 0, 0, 14602, 14603, 7, 5, 0, 0, 14603, 14604, 7, 5, + 0, 0, 14604, 14605, 7, 10, 0, 0, 14605, 14606, 7, 7, 0, 0, 14606, 14607, + 7, 17, 0, 0, 14607, 1928, 1, 0, 0, 0, 14608, 14609, 7, 14, 0, 0, 14609, + 14610, 7, 10, 0, 0, 14610, 14611, 7, 5, 0, 0, 14611, 14612, 7, 14, 0, 0, + 14612, 14613, 7, 0, 0, 0, 14613, 14614, 7, 4, 0, 0, 14614, 14615, 7, 8, + 0, 0, 14615, 14616, 7, 19, 0, 0, 14616, 1930, 1, 0, 0, 0, 14617, 14618, + 7, 14, 0, 0, 14618, 14619, 7, 11, 0, 0, 14619, 14620, 7, 5, 0, 0, 14620, + 14621, 7, 11, 0, 0, 14621, 14622, 7, 0, 0, 0, 14622, 14623, 7, 1, 0, 0, + 14623, 14624, 7, 6, 0, 0, 14624, 14625, 7, 11, 0, 0, 14625, 1932, 1, 0, + 0, 0, 14626, 14627, 7, 14, 0, 0, 14627, 14628, 7, 2, 0, 0, 14628, 14629, + 7, 9, 0, 0, 14629, 14630, 7, 6, 0, 0, 14630, 14631, 7, 11, 0, 0, 14631, + 14632, 5, 95, 0, 0, 14632, 14633, 7, 8, 0, 0, 14633, 14634, 7, 2, 0, 0, + 14634, 14635, 7, 14, 0, 0, 14635, 14636, 7, 15, 0, 0, 14636, 14637, 7, + 10, 0, 0, 14637, 14638, 7, 11, 0, 0, 14638, 14639, 7, 6, 0, 0, 14639, 14640, + 5, 95, 0, 0, 14640, 14641, 7, 5, 0, 0, 14641, 14642, 7, 12, 0, 0, 14642, + 14643, 7, 1, 0, 0, 14643, 14644, 7, 24, 0, 0, 14644, 14645, 7, 12, 0, 0, + 14645, 14646, 7, 6, 0, 0, 14646, 14647, 7, 3, 0, 0, 14647, 14648, 7, 18, + 0, 0, 14648, 1934, 1, 0, 0, 0, 14649, 14650, 7, 14, 0, 0, 14650, 14651, + 7, 2, 0, 0, 14651, 14652, 7, 9, 0, 0, 14652, 14653, 7, 6, 0, 0, 14653, + 14654, 7, 11, 0, 0, 14654, 14655, 5, 95, 0, 0, 14655, 14656, 7, 9, 0, 0, + 14656, 14657, 7, 2, 0, 0, 14657, 14658, 7, 7, 0, 0, 14658, 14659, 7, 4, + 0, 0, 14659, 14660, 7, 13, 0, 0, 14660, 14661, 7, 6, 0, 0, 14661, 14662, + 7, 3, 0, 0, 14662, 14663, 7, 10, 0, 0, 14663, 14664, 7, 16, 0, 0, 14664, + 14665, 7, 18, 0, 0, 14665, 14666, 5, 95, 0, 0, 14666, 14667, 7, 12, 0, + 0, 14667, 14668, 7, 7, 0, 0, 14668, 14669, 7, 10, 0, 0, 14669, 14670, 7, + 24, 0, 0, 14670, 14671, 7, 12, 0, 0, 14671, 14672, 7, 6, 0, 0, 14672, 14673, + 7, 7, 0, 0, 14673, 14674, 7, 6, 0, 0, 14674, 14675, 7, 5, 0, 0, 14675, + 14676, 7, 5, 0, 0, 14676, 1936, 1, 0, 0, 0, 14677, 14678, 7, 14, 0, 0, + 14678, 14679, 7, 2, 0, 0, 14679, 14680, 7, 9, 0, 0, 14680, 14681, 7, 6, + 0, 0, 14681, 14682, 7, 11, 0, 0, 14682, 14683, 5, 95, 0, 0, 14683, 14684, + 7, 9, 0, 0, 14684, 14685, 7, 18, 0, 0, 14685, 14686, 7, 7, 0, 0, 14686, + 14687, 7, 0, 0, 0, 14687, 14688, 7, 14, 0, 0, 14688, 14689, 7, 10, 0, 0, + 14689, 14690, 7, 8, 0, 0, 14690, 14691, 5, 95, 0, 0, 14691, 14692, 7, 5, + 0, 0, 14692, 14693, 7, 12, 0, 0, 14693, 14694, 7, 1, 0, 0, 14694, 14695, + 7, 24, 0, 0, 14695, 14696, 7, 12, 0, 0, 14696, 14697, 7, 6, 0, 0, 14697, + 14698, 7, 3, 0, 0, 14698, 14699, 7, 18, 0, 0, 14699, 1938, 1, 0, 0, 0, + 14700, 14701, 7, 14, 0, 0, 14701, 14702, 7, 2, 0, 0, 14702, 14703, 7, 9, + 0, 0, 14703, 14704, 7, 6, 0, 0, 14704, 14705, 7, 11, 0, 0, 14705, 14706, + 5, 95, 0, 0, 14706, 14707, 7, 14, 0, 0, 14707, 14708, 7, 10, 0, 0, 14708, + 14709, 7, 7, 0, 0, 14709, 14710, 5, 95, 0, 0, 14710, 14711, 7, 0, 0, 0, + 14711, 14712, 7, 7, 0, 0, 14712, 14713, 7, 0, 0, 0, 14713, 14714, 7, 11, + 0, 0, 14714, 14715, 7, 18, 0, 0, 14715, 14716, 7, 5, 0, 0, 14716, 14717, + 7, 10, 0, 0, 14717, 14718, 7, 5, 0, 0, 14718, 1940, 1, 0, 0, 0, 14719, + 14720, 7, 14, 0, 0, 14720, 14721, 7, 2, 0, 0, 14721, 14722, 7, 9, 0, 0, + 14722, 14723, 7, 6, 0, 0, 14723, 14724, 7, 11, 0, 0, 14724, 1942, 1, 0, + 0, 0, 14725, 14726, 7, 14, 0, 0, 14726, 14727, 7, 2, 0, 0, 14727, 14728, + 7, 9, 0, 0, 14728, 14729, 7, 6, 0, 0, 14729, 14730, 7, 11, 0, 0, 14730, + 14731, 5, 95, 0, 0, 14731, 14732, 7, 7, 0, 0, 14732, 14733, 7, 1, 0, 0, + 14733, 1944, 1, 0, 0, 0, 14734, 14735, 7, 14, 0, 0, 14735, 14736, 7, 2, + 0, 0, 14736, 14737, 7, 9, 0, 0, 14737, 14738, 7, 6, 0, 0, 14738, 14739, + 7, 11, 0, 0, 14739, 14740, 5, 95, 0, 0, 14740, 14741, 7, 7, 0, 0, 14741, + 14742, 7, 2, 0, 0, 14742, 14743, 5, 95, 0, 0, 14743, 14744, 7, 0, 0, 0, + 14744, 14745, 7, 7, 0, 0, 14745, 14746, 7, 0, 0, 0, 14746, 14747, 7, 11, + 0, 0, 14747, 14748, 7, 18, 0, 0, 14748, 14749, 7, 5, 0, 0, 14749, 14750, + 7, 10, 0, 0, 14750, 14751, 7, 5, 0, 0, 14751, 1946, 1, 0, 0, 0, 14752, + 14753, 7, 14, 0, 0, 14753, 14754, 7, 2, 0, 0, 14754, 14755, 7, 9, 0, 0, + 14755, 14756, 7, 6, 0, 0, 14756, 14757, 7, 11, 0, 0, 14757, 14758, 5, 95, + 0, 0, 14758, 14759, 7, 15, 0, 0, 14759, 14760, 7, 1, 0, 0, 14760, 14761, + 7, 18, 0, 0, 14761, 1948, 1, 0, 0, 0, 14762, 14763, 7, 14, 0, 0, 14763, + 14764, 7, 2, 0, 0, 14764, 14765, 7, 9, 0, 0, 14765, 14766, 7, 6, 0, 0, + 14766, 14767, 7, 11, 0, 0, 14767, 14768, 5, 95, 0, 0, 14768, 14769, 7, + 15, 0, 0, 14769, 14770, 7, 12, 0, 0, 14770, 14771, 7, 5, 0, 0, 14771, 14772, + 7, 19, 0, 0, 14772, 14773, 5, 95, 0, 0, 14773, 14774, 7, 3, 0, 0, 14774, + 14775, 7, 6, 0, 0, 14775, 14776, 7, 16, 0, 0, 14776, 1950, 1, 0, 0, 0, + 14777, 14778, 7, 14, 0, 0, 14778, 14779, 7, 2, 0, 0, 14779, 14780, 7, 9, + 0, 0, 14780, 14781, 7, 6, 0, 0, 14781, 14782, 7, 11, 0, 0, 14782, 14783, + 5, 95, 0, 0, 14783, 14784, 7, 5, 0, 0, 14784, 14785, 7, 13, 0, 0, 14785, + 1952, 1, 0, 0, 0, 14786, 14787, 7, 14, 0, 0, 14787, 14788, 7, 2, 0, 0, + 14788, 14789, 7, 9, 0, 0, 14789, 14790, 7, 6, 0, 0, 14790, 1954, 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, 10, 0, 0, 14797, 14798, 7, 8, 0, 0, 14798, 14799, 7, 0, 0, 0, + 14799, 14800, 7, 4, 0, 0, 14800, 14801, 7, 10, 0, 0, 14801, 14802, 7, 2, + 0, 0, 14802, 14803, 7, 7, 0, 0, 14803, 1956, 1, 0, 0, 0, 14804, 14805, + 7, 14, 0, 0, 14805, 14806, 7, 2, 0, 0, 14806, 14807, 7, 9, 0, 0, 14807, + 14808, 7, 10, 0, 0, 14808, 14809, 7, 16, 0, 0, 14809, 14810, 7, 18, 0, + 0, 14810, 14811, 5, 95, 0, 0, 14811, 14812, 7, 8, 0, 0, 14812, 14813, 7, + 2, 0, 0, 14813, 14814, 7, 11, 0, 0, 14814, 14815, 7, 12, 0, 0, 14815, 14816, + 7, 14, 0, 0, 14816, 14817, 7, 7, 0, 0, 14817, 14818, 5, 95, 0, 0, 14818, + 14819, 7, 4, 0, 0, 14819, 14820, 7, 18, 0, 0, 14820, 14821, 7, 15, 0, 0, + 14821, 14822, 7, 6, 0, 0, 14822, 1958, 1, 0, 0, 0, 14823, 14824, 7, 14, + 0, 0, 14824, 14825, 7, 2, 0, 0, 14825, 14826, 7, 9, 0, 0, 14826, 14827, + 7, 10, 0, 0, 14827, 14828, 7, 16, 0, 0, 14828, 14829, 7, 18, 0, 0, 14829, + 1960, 1, 0, 0, 0, 14830, 14831, 7, 14, 0, 0, 14831, 14832, 7, 2, 0, 0, + 14832, 14833, 7, 9, 0, 0, 14833, 1962, 1, 0, 0, 0, 14834, 14835, 7, 14, + 0, 0, 14835, 14836, 7, 2, 0, 0, 14836, 14837, 7, 9, 0, 0, 14837, 14838, + 7, 12, 0, 0, 14838, 14839, 7, 11, 0, 0, 14839, 14840, 7, 6, 0, 0, 14840, + 1964, 1, 0, 0, 0, 14841, 14842, 7, 14, 0, 0, 14842, 14843, 7, 2, 0, 0, + 14843, 14844, 7, 7, 0, 0, 14844, 14845, 7, 10, 0, 0, 14845, 14846, 7, 4, + 0, 0, 14846, 14847, 7, 2, 0, 0, 14847, 14848, 7, 3, 0, 0, 14848, 14849, + 7, 10, 0, 0, 14849, 14850, 7, 7, 0, 0, 14850, 14851, 7, 17, 0, 0, 14851, + 1966, 1, 0, 0, 0, 14852, 14853, 7, 14, 0, 0, 14853, 14854, 7, 2, 0, 0, + 14854, 14855, 7, 7, 0, 0, 14855, 14856, 7, 10, 0, 0, 14856, 14857, 7, 4, + 0, 0, 14857, 14858, 7, 2, 0, 0, 14858, 14859, 7, 3, 0, 0, 14859, 1968, + 1, 0, 0, 0, 14860, 14861, 7, 14, 0, 0, 14861, 14862, 7, 2, 0, 0, 14862, + 14863, 7, 7, 0, 0, 14863, 14864, 7, 4, 0, 0, 14864, 14865, 7, 19, 0, 0, + 14865, 1970, 1, 0, 0, 0, 14866, 14867, 7, 14, 0, 0, 14867, 14868, 7, 2, + 0, 0, 14868, 14869, 7, 7, 0, 0, 14869, 14870, 7, 4, 0, 0, 14870, 14871, + 7, 19, 0, 0, 14871, 14872, 7, 5, 0, 0, 14872, 14873, 5, 95, 0, 0, 14873, + 14874, 7, 1, 0, 0, 14874, 14875, 7, 6, 0, 0, 14875, 14876, 7, 4, 0, 0, + 14876, 14877, 7, 22, 0, 0, 14877, 14878, 7, 6, 0, 0, 14878, 14879, 7, 6, + 0, 0, 14879, 14880, 7, 7, 0, 0, 14880, 1972, 1, 0, 0, 0, 14881, 14882, + 7, 14, 0, 0, 14882, 14883, 7, 2, 0, 0, 14883, 14884, 7, 7, 0, 0, 14884, + 14885, 7, 4, 0, 0, 14885, 14886, 7, 19, 0, 0, 14886, 14887, 7, 5, 0, 0, + 14887, 1974, 1, 0, 0, 0, 14888, 14889, 7, 14, 0, 0, 14889, 14890, 7, 2, + 0, 0, 14890, 14891, 7, 12, 0, 0, 14891, 14892, 7, 7, 0, 0, 14892, 14893, + 7, 4, 0, 0, 14893, 1976, 1, 0, 0, 0, 14894, 14895, 7, 14, 0, 0, 14895, + 14896, 7, 2, 0, 0, 14896, 14897, 7, 12, 0, 0, 14897, 14898, 7, 7, 0, 0, + 14898, 14899, 7, 4, 0, 0, 14899, 14900, 7, 15, 0, 0, 14900, 14901, 7, 0, + 0, 0, 14901, 14902, 7, 4, 0, 0, 14902, 14903, 7, 19, 0, 0, 14903, 1978, + 1, 0, 0, 0, 14904, 14905, 7, 14, 0, 0, 14905, 14906, 7, 2, 0, 0, 14906, + 14907, 7, 12, 0, 0, 14907, 14908, 7, 7, 0, 0, 14908, 14909, 7, 4, 0, 0, + 14909, 14910, 7, 15, 0, 0, 14910, 14911, 7, 2, 0, 0, 14911, 14912, 7, 10, + 0, 0, 14912, 14913, 7, 7, 0, 0, 14913, 14914, 7, 4, 0, 0, 14914, 1980, + 1, 0, 0, 0, 14915, 14916, 7, 14, 0, 0, 14916, 14917, 7, 2, 0, 0, 14917, + 14918, 7, 13, 0, 0, 14918, 14919, 7, 6, 0, 0, 14919, 14920, 7, 14, 0, 0, + 14920, 14921, 7, 6, 0, 0, 14921, 14922, 7, 7, 0, 0, 14922, 14923, 7, 4, + 0, 0, 14923, 1982, 1, 0, 0, 0, 14924, 14925, 7, 14, 0, 0, 14925, 14926, + 7, 2, 0, 0, 14926, 14927, 7, 13, 0, 0, 14927, 14928, 7, 6, 0, 0, 14928, + 1984, 1, 0, 0, 0, 14929, 14930, 7, 14, 0, 0, 14930, 14931, 7, 12, 0, 0, + 14931, 14932, 7, 11, 0, 0, 14932, 14933, 7, 4, 0, 0, 14933, 14934, 7, 10, + 0, 0, 14934, 14935, 7, 9, 0, 0, 14935, 14936, 7, 10, 0, 0, 14936, 14937, + 7, 14, 0, 0, 14937, 14938, 7, 6, 0, 0, 14938, 14939, 7, 7, 0, 0, 14939, + 14940, 7, 5, 0, 0, 14940, 14941, 7, 10, 0, 0, 14941, 14942, 7, 2, 0, 0, + 14942, 14943, 7, 7, 0, 0, 14943, 14944, 7, 0, 0, 0, 14944, 14945, 7, 11, + 0, 0, 14945, 1986, 1, 0, 0, 0, 14946, 14947, 7, 14, 0, 0, 14947, 14948, + 7, 12, 0, 0, 14948, 14949, 7, 11, 0, 0, 14949, 14950, 7, 4, 0, 0, 14950, + 14951, 7, 10, 0, 0, 14951, 14952, 7, 5, 0, 0, 14952, 14953, 7, 6, 0, 0, + 14953, 14954, 7, 4, 0, 0, 14954, 1988, 1, 0, 0, 0, 14955, 14956, 7, 14, + 0, 0, 14956, 14957, 7, 13, 0, 0, 14957, 14958, 5, 95, 0, 0, 14958, 14959, + 7, 14, 0, 0, 14959, 14960, 7, 6, 0, 0, 14960, 14961, 7, 3, 0, 0, 14961, + 14962, 7, 17, 0, 0, 14962, 14963, 7, 6, 0, 0, 14963, 1990, 1, 0, 0, 0, + 14964, 14965, 7, 7, 0, 0, 14965, 14966, 7, 0, 0, 0, 14966, 14967, 7, 14, + 0, 0, 14967, 14968, 7, 6, 0, 0, 14968, 14969, 7, 9, 0, 0, 14969, 1992, + 1, 0, 0, 0, 14970, 14971, 7, 7, 0, 0, 14971, 14972, 7, 0, 0, 0, 14972, + 14973, 7, 14, 0, 0, 14973, 14974, 7, 6, 0, 0, 14974, 1994, 1, 0, 0, 0, + 14975, 14976, 7, 7, 0, 0, 14976, 14977, 7, 0, 0, 0, 14977, 14978, 7, 14, + 0, 0, 14978, 14979, 7, 6, 0, 0, 14979, 14980, 7, 5, 0, 0, 14980, 14981, + 7, 15, 0, 0, 14981, 14982, 7, 0, 0, 0, 14982, 14983, 7, 8, 0, 0, 14983, + 14984, 7, 6, 0, 0, 14984, 1996, 1, 0, 0, 0, 14985, 14986, 7, 7, 0, 0, 14986, + 14987, 7, 0, 0, 0, 14987, 14988, 7, 7, 0, 0, 14988, 1998, 1, 0, 0, 0, 14989, + 14990, 7, 7, 0, 0, 14990, 14991, 7, 0, 0, 0, 14991, 14992, 7, 7, 0, 0, + 14992, 14993, 7, 13, 0, 0, 14993, 14994, 7, 11, 0, 0, 14994, 2000, 1, 0, + 0, 0, 14995, 14996, 7, 7, 0, 0, 14996, 14997, 7, 0, 0, 0, 14997, 14998, + 7, 4, 0, 0, 14998, 14999, 7, 10, 0, 0, 14999, 15000, 7, 2, 0, 0, 15000, + 15001, 7, 7, 0, 0, 15001, 15002, 7, 0, 0, 0, 15002, 15003, 7, 11, 0, 0, + 15003, 2002, 1, 0, 0, 0, 15004, 15005, 7, 7, 0, 0, 15005, 15006, 7, 0, + 0, 0, 15006, 15007, 7, 4, 0, 0, 15007, 15008, 7, 10, 0, 0, 15008, 15009, + 7, 13, 0, 0, 15009, 15010, 7, 6, 0, 0, 15010, 15011, 5, 95, 0, 0, 15011, + 15012, 7, 16, 0, 0, 15012, 15013, 7, 12, 0, 0, 15013, 15014, 7, 11, 0, + 0, 15014, 15015, 7, 11, 0, 0, 15015, 15016, 5, 95, 0, 0, 15016, 15017, + 7, 2, 0, 0, 15017, 15018, 7, 12, 0, 0, 15018, 15019, 7, 4, 0, 0, 15019, + 15020, 7, 6, 0, 0, 15020, 15021, 7, 3, 0, 0, 15021, 15022, 5, 95, 0, 0, + 15022, 15023, 7, 20, 0, 0, 15023, 15024, 7, 2, 0, 0, 15024, 15025, 7, 10, + 0, 0, 15025, 15026, 7, 7, 0, 0, 15026, 2004, 1, 0, 0, 0, 15027, 15028, + 7, 7, 0, 0, 15028, 15029, 7, 0, 0, 0, 15029, 15030, 7, 4, 0, 0, 15030, + 15031, 7, 10, 0, 0, 15031, 15032, 7, 13, 0, 0, 15032, 15033, 7, 6, 0, 0, + 15033, 2006, 1, 0, 0, 0, 15034, 15035, 7, 7, 0, 0, 15035, 15036, 7, 0, + 0, 0, 15036, 15037, 7, 4, 0, 0, 15037, 15038, 7, 12, 0, 0, 15038, 15039, + 7, 3, 0, 0, 15039, 15040, 7, 0, 0, 0, 15040, 15041, 7, 11, 0, 0, 15041, + 2008, 1, 0, 0, 0, 15042, 15043, 7, 7, 0, 0, 15043, 15044, 7, 0, 0, 0, 15044, + 15045, 7, 4, 0, 0, 15045, 15046, 7, 12, 0, 0, 15046, 15047, 7, 3, 0, 0, + 15047, 15048, 7, 0, 0, 0, 15048, 15049, 7, 11, 0, 0, 15049, 15050, 7, 7, + 0, 0, 15050, 2010, 1, 0, 0, 0, 15051, 15052, 7, 7, 0, 0, 15052, 15053, + 7, 0, 0, 0, 15053, 15054, 7, 13, 0, 0, 15054, 2012, 1, 0, 0, 0, 15055, + 15056, 7, 7, 0, 0, 15056, 15057, 7, 8, 0, 0, 15057, 15058, 7, 19, 0, 0, + 15058, 15059, 7, 0, 0, 0, 15059, 15060, 7, 3, 0, 0, 15060, 15061, 5, 95, + 0, 0, 15061, 15062, 7, 8, 0, 0, 15062, 15063, 7, 5, 0, 0, 15063, 2014, + 1, 0, 0, 0, 15064, 15065, 7, 7, 0, 0, 15065, 15066, 7, 8, 0, 0, 15066, + 15067, 7, 19, 0, 0, 15067, 15068, 7, 0, 0, 0, 15068, 15069, 7, 3, 0, 0, + 15069, 2016, 1, 0, 0, 0, 15070, 15071, 7, 7, 0, 0, 15071, 15072, 7, 8, + 0, 0, 15072, 15073, 7, 19, 0, 0, 15073, 15074, 7, 3, 0, 0, 15074, 2018, + 1, 0, 0, 0, 15075, 15076, 7, 7, 0, 0, 15076, 15077, 7, 8, 0, 0, 15077, + 15078, 7, 11, 0, 0, 15078, 15079, 7, 2, 0, 0, 15079, 15080, 7, 1, 0, 0, + 15080, 2020, 1, 0, 0, 0, 15081, 15082, 7, 7, 0, 0, 15082, 15083, 7, 6, + 0, 0, 15083, 15084, 7, 6, 0, 0, 15084, 15085, 7, 9, 0, 0, 15085, 15086, + 7, 6, 0, 0, 15086, 15087, 7, 9, 0, 0, 15087, 2022, 1, 0, 0, 0, 15088, 15089, + 7, 7, 0, 0, 15089, 15090, 7, 6, 0, 0, 15090, 15091, 7, 17, 0, 0, 15091, + 2024, 1, 0, 0, 0, 15092, 15093, 7, 7, 0, 0, 15093, 15094, 7, 6, 0, 0, 15094, + 15095, 7, 5, 0, 0, 15095, 15096, 7, 4, 0, 0, 15096, 15097, 7, 6, 0, 0, + 15097, 15098, 7, 9, 0, 0, 15098, 2026, 1, 0, 0, 0, 15099, 15100, 7, 7, + 0, 0, 15100, 15101, 7, 6, 0, 0, 15101, 15102, 7, 5, 0, 0, 15102, 15103, + 7, 4, 0, 0, 15103, 15104, 7, 6, 0, 0, 15104, 15105, 7, 9, 0, 0, 15105, + 15106, 5, 95, 0, 0, 15106, 15107, 7, 4, 0, 0, 15107, 15108, 7, 0, 0, 0, + 15108, 15109, 7, 1, 0, 0, 15109, 15110, 7, 11, 0, 0, 15110, 15111, 7, 6, + 0, 0, 15111, 15112, 5, 95, 0, 0, 15112, 15113, 7, 16, 0, 0, 15113, 15114, + 7, 0, 0, 0, 15114, 15115, 7, 5, 0, 0, 15115, 15116, 7, 4, 0, 0, 15116, + 15117, 5, 95, 0, 0, 15117, 15118, 7, 10, 0, 0, 15118, 15119, 7, 7, 0, 0, + 15119, 15120, 7, 5, 0, 0, 15120, 15121, 7, 6, 0, 0, 15121, 15122, 7, 3, + 0, 0, 15122, 15123, 7, 4, 0, 0, 15123, 2028, 1, 0, 0, 0, 15124, 15125, + 7, 7, 0, 0, 15125, 15126, 7, 6, 0, 0, 15126, 15127, 7, 5, 0, 0, 15127, + 15128, 7, 4, 0, 0, 15128, 15129, 7, 6, 0, 0, 15129, 15130, 7, 9, 0, 0, + 15130, 15131, 5, 95, 0, 0, 15131, 15132, 7, 4, 0, 0, 15132, 15133, 7, 0, + 0, 0, 15133, 15134, 7, 1, 0, 0, 15134, 15135, 7, 11, 0, 0, 15135, 15136, + 7, 6, 0, 0, 15136, 15137, 5, 95, 0, 0, 15137, 15138, 7, 17, 0, 0, 15138, + 15139, 7, 6, 0, 0, 15139, 15140, 7, 4, 0, 0, 15140, 15141, 5, 95, 0, 0, + 15141, 15142, 7, 3, 0, 0, 15142, 15143, 7, 6, 0, 0, 15143, 15144, 7, 16, + 0, 0, 15144, 15145, 7, 5, 0, 0, 15145, 2030, 1, 0, 0, 0, 15146, 15147, + 7, 7, 0, 0, 15147, 15148, 7, 6, 0, 0, 15148, 15149, 7, 5, 0, 0, 15149, + 15150, 7, 4, 0, 0, 15150, 15151, 7, 6, 0, 0, 15151, 15152, 7, 9, 0, 0, + 15152, 15153, 5, 95, 0, 0, 15153, 15154, 7, 4, 0, 0, 15154, 15155, 7, 0, + 0, 0, 15155, 15156, 7, 1, 0, 0, 15156, 15157, 7, 11, 0, 0, 15157, 15158, + 7, 6, 0, 0, 15158, 15159, 5, 95, 0, 0, 15159, 15160, 7, 10, 0, 0, 15160, + 15161, 7, 9, 0, 0, 15161, 2032, 1, 0, 0, 0, 15162, 15163, 7, 7, 0, 0, 15163, + 15164, 7, 6, 0, 0, 15164, 15165, 7, 5, 0, 0, 15165, 15166, 7, 4, 0, 0, + 15166, 15167, 7, 6, 0, 0, 15167, 15168, 7, 9, 0, 0, 15168, 15169, 5, 95, + 0, 0, 15169, 15170, 7, 4, 0, 0, 15170, 15171, 7, 0, 0, 0, 15171, 15172, + 7, 1, 0, 0, 15172, 15173, 7, 11, 0, 0, 15173, 15174, 7, 6, 0, 0, 15174, + 15175, 5, 95, 0, 0, 15175, 15176, 7, 5, 0, 0, 15176, 15177, 7, 6, 0, 0, + 15177, 15178, 7, 4, 0, 0, 15178, 15179, 5, 95, 0, 0, 15179, 15180, 7, 3, + 0, 0, 15180, 15181, 7, 6, 0, 0, 15181, 15182, 7, 16, 0, 0, 15182, 15183, + 7, 5, 0, 0, 15183, 2034, 1, 0, 0, 0, 15184, 15185, 7, 7, 0, 0, 15185, 15186, + 7, 6, 0, 0, 15186, 15187, 7, 5, 0, 0, 15187, 15188, 7, 4, 0, 0, 15188, + 15189, 7, 6, 0, 0, 15189, 15190, 7, 9, 0, 0, 15190, 15191, 5, 95, 0, 0, + 15191, 15192, 7, 4, 0, 0, 15192, 15193, 7, 0, 0, 0, 15193, 15194, 7, 1, + 0, 0, 15194, 15195, 7, 11, 0, 0, 15195, 15196, 7, 6, 0, 0, 15196, 15197, + 5, 95, 0, 0, 15197, 15198, 7, 5, 0, 0, 15198, 15199, 7, 6, 0, 0, 15199, + 15200, 7, 4, 0, 0, 15200, 15201, 5, 95, 0, 0, 15201, 15202, 7, 5, 0, 0, + 15202, 15203, 7, 6, 0, 0, 15203, 15204, 7, 4, 0, 0, 15204, 15205, 7, 10, + 0, 0, 15205, 15206, 7, 9, 0, 0, 15206, 2036, 1, 0, 0, 0, 15207, 15208, + 7, 7, 0, 0, 15208, 15209, 7, 6, 0, 0, 15209, 15210, 7, 4, 0, 0, 15210, + 15211, 7, 22, 0, 0, 15211, 15212, 7, 2, 0, 0, 15212, 15213, 7, 3, 0, 0, + 15213, 15214, 7, 21, 0, 0, 15214, 2038, 1, 0, 0, 0, 15215, 15216, 7, 7, + 0, 0, 15216, 15217, 7, 6, 0, 0, 15217, 15218, 7, 13, 0, 0, 15218, 15219, + 7, 6, 0, 0, 15219, 15220, 7, 3, 0, 0, 15220, 2040, 1, 0, 0, 0, 15221, 15222, + 7, 7, 0, 0, 15222, 15223, 7, 6, 0, 0, 15223, 15224, 7, 22, 0, 0, 15224, + 2042, 1, 0, 0, 0, 15225, 15226, 7, 7, 0, 0, 15226, 15227, 7, 6, 0, 0, 15227, + 15228, 7, 22, 0, 0, 15228, 15229, 7, 11, 0, 0, 15229, 15230, 7, 10, 0, + 0, 15230, 15231, 7, 7, 0, 0, 15231, 15232, 7, 6, 0, 0, 15232, 2044, 1, + 0, 0, 0, 15233, 15234, 7, 7, 0, 0, 15234, 15235, 7, 6, 0, 0, 15235, 15236, + 7, 22, 0, 0, 15236, 15237, 5, 95, 0, 0, 15237, 15238, 7, 4, 0, 0, 15238, + 15239, 7, 10, 0, 0, 15239, 15240, 7, 14, 0, 0, 15240, 15241, 7, 6, 0, 0, + 15241, 2046, 1, 0, 0, 0, 15242, 15243, 7, 7, 0, 0, 15243, 15244, 7, 6, + 0, 0, 15244, 15245, 7, 25, 0, 0, 15245, 15246, 7, 4, 0, 0, 15246, 15247, + 5, 95, 0, 0, 15247, 15248, 7, 9, 0, 0, 15248, 15249, 7, 0, 0, 0, 15249, + 15250, 7, 18, 0, 0, 15250, 2048, 1, 0, 0, 0, 15251, 15252, 7, 7, 0, 0, + 15252, 15253, 7, 6, 0, 0, 15253, 15254, 7, 25, 0, 0, 15254, 15255, 7, 4, + 0, 0, 15255, 2050, 1, 0, 0, 0, 15256, 15257, 7, 7, 0, 0, 15257, 15258, + 7, 11, 0, 0, 15258, 15259, 5, 95, 0, 0, 15259, 15260, 7, 0, 0, 0, 15260, + 15261, 7, 20, 0, 0, 15261, 2052, 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, 1, 0, 0, 15267, 15268, 7, 0, 0, 0, 15268, 15269, + 7, 4, 0, 0, 15269, 15270, 7, 8, 0, 0, 15270, 15271, 7, 19, 0, 0, 15271, + 15272, 7, 10, 0, 0, 15272, 15273, 7, 7, 0, 0, 15273, 15274, 7, 17, 0, 0, + 15274, 2054, 1, 0, 0, 0, 15275, 15276, 7, 7, 0, 0, 15276, 15277, 7, 11, + 0, 0, 15277, 15278, 7, 20, 0, 0, 15278, 15279, 5, 95, 0, 0, 15279, 15280, + 7, 10, 0, 0, 15280, 15281, 7, 7, 0, 0, 15281, 15282, 7, 9, 0, 0, 15282, + 15283, 7, 6, 0, 0, 15283, 15284, 7, 25, 0, 0, 15284, 15285, 5, 95, 0, 0, + 15285, 15286, 7, 16, 0, 0, 15286, 15287, 7, 10, 0, 0, 15287, 15288, 7, + 11, 0, 0, 15288, 15289, 7, 4, 0, 0, 15289, 15290, 7, 6, 0, 0, 15290, 15291, + 7, 3, 0, 0, 15291, 2056, 1, 0, 0, 0, 15292, 15293, 7, 7, 0, 0, 15293, 15294, + 7, 11, 0, 0, 15294, 15295, 7, 20, 0, 0, 15295, 15296, 5, 95, 0, 0, 15296, + 15297, 7, 10, 0, 0, 15297, 15298, 7, 7, 0, 0, 15298, 15299, 7, 9, 0, 0, + 15299, 15300, 7, 6, 0, 0, 15300, 15301, 7, 25, 0, 0, 15301, 15302, 5, 95, + 0, 0, 15302, 15303, 7, 5, 0, 0, 15303, 15304, 7, 8, 0, 0, 15304, 15305, + 7, 0, 0, 0, 15305, 15306, 7, 7, 0, 0, 15306, 2058, 1, 0, 0, 0, 15307, 15308, + 7, 7, 0, 0, 15308, 15309, 7, 11, 0, 0, 15309, 15310, 7, 20, 0, 0, 15310, + 15311, 5, 95, 0, 0, 15311, 15312, 7, 15, 0, 0, 15312, 15313, 7, 3, 0, 0, + 15313, 15314, 7, 6, 0, 0, 15314, 15315, 7, 16, 0, 0, 15315, 15316, 7, 6, + 0, 0, 15316, 15317, 7, 4, 0, 0, 15317, 15318, 7, 8, 0, 0, 15318, 15319, + 7, 19, 0, 0, 15319, 2060, 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, 0, 0, 0, 15326, 15327, 7, 11, + 0, 0, 15327, 15328, 7, 6, 0, 0, 15328, 15329, 7, 7, 0, 0, 15329, 15330, + 7, 9, 0, 0, 15330, 15331, 7, 0, 0, 0, 15331, 15332, 7, 3, 0, 0, 15332, + 2062, 1, 0, 0, 0, 15333, 15334, 7, 7, 0, 0, 15334, 15335, 7, 11, 0, 0, + 15335, 15336, 7, 5, 0, 0, 15336, 15337, 5, 95, 0, 0, 15337, 15338, 7, 8, + 0, 0, 15338, 15339, 7, 19, 0, 0, 15339, 15340, 7, 0, 0, 0, 15340, 15341, + 7, 3, 0, 0, 15341, 15342, 7, 0, 0, 0, 15342, 15343, 7, 8, 0, 0, 15343, + 15344, 7, 4, 0, 0, 15344, 15345, 7, 6, 0, 0, 15345, 15346, 7, 3, 0, 0, + 15346, 15347, 7, 5, 0, 0, 15347, 15348, 7, 6, 0, 0, 15348, 15349, 7, 4, + 0, 0, 15349, 2064, 1, 0, 0, 0, 15350, 15351, 7, 7, 0, 0, 15351, 15352, + 7, 11, 0, 0, 15352, 15353, 7, 5, 0, 0, 15353, 15354, 5, 95, 0, 0, 15354, + 15355, 7, 8, 0, 0, 15355, 15356, 7, 19, 0, 0, 15356, 15357, 7, 0, 0, 0, + 15357, 15358, 7, 3, 0, 0, 15358, 15359, 7, 5, 0, 0, 15359, 15360, 7, 6, + 0, 0, 15360, 15361, 7, 4, 0, 0, 15361, 15362, 5, 95, 0, 0, 15362, 15363, + 7, 9, 0, 0, 15363, 15364, 7, 6, 0, 0, 15364, 15365, 7, 8, 0, 0, 15365, + 15366, 7, 11, 0, 0, 15366, 15367, 5, 95, 0, 0, 15367, 15368, 7, 11, 0, + 0, 15368, 15369, 7, 6, 0, 0, 15369, 15370, 7, 7, 0, 0, 15370, 2066, 1, + 0, 0, 0, 15371, 15372, 7, 7, 0, 0, 15372, 15373, 7, 11, 0, 0, 15373, 15374, + 7, 5, 0, 0, 15374, 15375, 5, 95, 0, 0, 15375, 15376, 7, 8, 0, 0, 15376, + 15377, 7, 19, 0, 0, 15377, 15378, 7, 0, 0, 0, 15378, 15379, 7, 3, 0, 0, + 15379, 15380, 7, 5, 0, 0, 15380, 15381, 7, 6, 0, 0, 15381, 15382, 7, 4, + 0, 0, 15382, 15383, 5, 95, 0, 0, 15383, 15384, 7, 10, 0, 0, 15384, 15385, + 7, 9, 0, 0, 15385, 2068, 1, 0, 0, 0, 15386, 15387, 7, 7, 0, 0, 15387, 15388, + 7, 11, 0, 0, 15388, 15389, 7, 5, 0, 0, 15389, 15390, 5, 95, 0, 0, 15390, + 15391, 7, 8, 0, 0, 15391, 15392, 7, 19, 0, 0, 15392, 15393, 7, 0, 0, 0, + 15393, 15394, 7, 3, 0, 0, 15394, 15395, 7, 5, 0, 0, 15395, 15396, 7, 6, + 0, 0, 15396, 15397, 7, 4, 0, 0, 15397, 15398, 5, 95, 0, 0, 15398, 15399, + 7, 7, 0, 0, 15399, 15400, 7, 0, 0, 0, 15400, 15401, 7, 14, 0, 0, 15401, + 15402, 7, 6, 0, 0, 15402, 2070, 1, 0, 0, 0, 15403, 15404, 7, 7, 0, 0, 15404, + 15405, 7, 11, 0, 0, 15405, 15406, 7, 5, 0, 0, 15406, 15407, 5, 95, 0, 0, + 15407, 15408, 7, 8, 0, 0, 15408, 15409, 7, 2, 0, 0, 15409, 15410, 7, 14, + 0, 0, 15410, 15411, 7, 15, 0, 0, 15411, 2072, 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, 8, 0, 0, 15417, 15418, 7, 12, 0, 0, + 15418, 15419, 7, 3, 0, 0, 15419, 15420, 7, 3, 0, 0, 15420, 15421, 7, 6, + 0, 0, 15421, 15422, 7, 7, 0, 0, 15422, 15423, 7, 8, 0, 0, 15423, 15424, + 7, 18, 0, 0, 15424, 2074, 1, 0, 0, 0, 15425, 15426, 7, 7, 0, 0, 15426, + 15427, 7, 11, 0, 0, 15427, 15428, 7, 5, 0, 0, 15428, 15429, 5, 95, 0, 0, + 15429, 15430, 7, 9, 0, 0, 15430, 15431, 7, 0, 0, 0, 15431, 15432, 7, 4, + 0, 0, 15432, 15433, 7, 6, 0, 0, 15433, 15434, 5, 95, 0, 0, 15434, 15435, + 7, 16, 0, 0, 15435, 15436, 7, 2, 0, 0, 15436, 15437, 7, 3, 0, 0, 15437, + 15438, 7, 14, 0, 0, 15438, 15439, 7, 0, 0, 0, 15439, 15440, 7, 4, 0, 0, + 15440, 2076, 1, 0, 0, 0, 15441, 15442, 7, 7, 0, 0, 15442, 15443, 7, 11, + 0, 0, 15443, 15444, 7, 5, 0, 0, 15444, 15445, 5, 95, 0, 0, 15445, 15446, + 7, 9, 0, 0, 15446, 15447, 7, 0, 0, 0, 15447, 15448, 7, 4, 0, 0, 15448, + 15449, 7, 6, 0, 0, 15449, 15450, 5, 95, 0, 0, 15450, 15451, 7, 11, 0, 0, + 15451, 15452, 7, 0, 0, 0, 15452, 15453, 7, 7, 0, 0, 15453, 15454, 7, 17, + 0, 0, 15454, 15455, 7, 12, 0, 0, 15455, 15456, 7, 0, 0, 0, 15456, 15457, + 7, 17, 0, 0, 15457, 15458, 7, 6, 0, 0, 15458, 2078, 1, 0, 0, 0, 15459, + 15460, 7, 7, 0, 0, 15460, 15461, 7, 11, 0, 0, 15461, 15462, 7, 5, 0, 0, + 15462, 15463, 5, 95, 0, 0, 15463, 15464, 7, 10, 0, 0, 15464, 15465, 7, + 7, 0, 0, 15465, 15466, 7, 10, 0, 0, 15466, 15467, 7, 4, 0, 0, 15467, 15468, + 7, 8, 0, 0, 15468, 15469, 7, 0, 0, 0, 15469, 15470, 7, 15, 0, 0, 15470, + 2080, 1, 0, 0, 0, 15471, 15472, 7, 7, 0, 0, 15472, 15473, 7, 11, 0, 0, + 15473, 15474, 7, 5, 0, 0, 15474, 15475, 5, 95, 0, 0, 15475, 15476, 7, 10, + 0, 0, 15476, 15477, 7, 5, 0, 0, 15477, 15478, 7, 2, 0, 0, 15478, 15479, + 5, 95, 0, 0, 15479, 15480, 7, 8, 0, 0, 15480, 15481, 7, 12, 0, 0, 15481, + 15482, 7, 3, 0, 0, 15482, 15483, 7, 3, 0, 0, 15483, 15484, 7, 6, 0, 0, + 15484, 15485, 7, 7, 0, 0, 15485, 15486, 7, 8, 0, 0, 15486, 15487, 7, 18, + 0, 0, 15487, 2082, 1, 0, 0, 0, 15488, 15489, 7, 7, 0, 0, 15489, 15490, + 7, 11, 0, 0, 15490, 15491, 5, 95, 0, 0, 15491, 15492, 7, 5, 0, 0, 15492, + 15493, 7, 20, 0, 0, 15493, 2084, 1, 0, 0, 0, 15494, 15495, 7, 7, 0, 0, + 15495, 15496, 7, 11, 0, 0, 15496, 15497, 7, 5, 0, 0, 15497, 15498, 5, 95, + 0, 0, 15498, 15499, 7, 11, 0, 0, 15499, 15500, 7, 0, 0, 0, 15500, 15501, + 7, 7, 0, 0, 15501, 15502, 7, 17, 0, 0, 15502, 2086, 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, + 0, 0, 0, 15509, 15510, 7, 7, 0, 0, 15510, 15511, 7, 17, 0, 0, 15511, 15512, + 7, 12, 0, 0, 15512, 15513, 7, 0, 0, 0, 15513, 15514, 7, 17, 0, 0, 15514, + 15515, 7, 6, 0, 0, 15515, 2088, 1, 0, 0, 0, 15516, 15517, 7, 7, 0, 0, 15517, + 15518, 7, 11, 0, 0, 15518, 15519, 7, 5, 0, 0, 15519, 15520, 5, 95, 0, 0, + 15520, 15521, 7, 11, 0, 0, 15521, 15522, 7, 6, 0, 0, 15522, 15523, 7, 7, + 0, 0, 15523, 15524, 7, 17, 0, 0, 15524, 15525, 7, 4, 0, 0, 15525, 15526, + 7, 19, 0, 0, 15526, 15527, 5, 95, 0, 0, 15527, 15528, 7, 5, 0, 0, 15528, + 15529, 7, 6, 0, 0, 15529, 15530, 7, 14, 0, 0, 15530, 15531, 7, 0, 0, 0, + 15531, 15532, 7, 7, 0, 0, 15532, 15533, 7, 4, 0, 0, 15533, 15534, 7, 10, + 0, 0, 15534, 15535, 7, 8, 0, 0, 15535, 15536, 7, 5, 0, 0, 15536, 2090, + 1, 0, 0, 0, 15537, 15538, 7, 7, 0, 0, 15538, 15539, 7, 11, 0, 0, 15539, + 15540, 7, 5, 0, 0, 15540, 15541, 5, 95, 0, 0, 15541, 15542, 7, 11, 0, 0, + 15542, 15543, 7, 2, 0, 0, 15543, 15544, 7, 22, 0, 0, 15544, 15545, 7, 6, + 0, 0, 15545, 15546, 7, 3, 0, 0, 15546, 2092, 1, 0, 0, 0, 15547, 15548, + 7, 7, 0, 0, 15548, 15549, 7, 11, 0, 0, 15549, 15550, 7, 5, 0, 0, 15550, + 15551, 5, 95, 0, 0, 15551, 15552, 7, 7, 0, 0, 15552, 15553, 7, 8, 0, 0, + 15553, 15554, 7, 19, 0, 0, 15554, 15555, 7, 0, 0, 0, 15555, 15556, 7, 3, + 0, 0, 15556, 15557, 5, 95, 0, 0, 15557, 15558, 7, 8, 0, 0, 15558, 15559, + 7, 2, 0, 0, 15559, 15560, 7, 7, 0, 0, 15560, 15561, 7, 13, 0, 0, 15561, + 15562, 5, 95, 0, 0, 15562, 15563, 7, 6, 0, 0, 15563, 15564, 7, 25, 0, 0, + 15564, 15565, 7, 8, 0, 0, 15565, 15566, 7, 15, 0, 0, 15566, 2094, 1, 0, + 0, 0, 15567, 15568, 7, 7, 0, 0, 15568, 15569, 7, 11, 0, 0, 15569, 15570, + 7, 5, 0, 0, 15570, 15571, 5, 95, 0, 0, 15571, 15572, 7, 7, 0, 0, 15572, + 15573, 7, 12, 0, 0, 15573, 15574, 7, 14, 0, 0, 15574, 15575, 7, 6, 0, 0, + 15575, 15576, 7, 3, 0, 0, 15576, 15577, 7, 10, 0, 0, 15577, 15578, 7, 8, + 0, 0, 15578, 15579, 5, 95, 0, 0, 15579, 15580, 7, 8, 0, 0, 15580, 15581, + 7, 19, 0, 0, 15581, 15582, 7, 0, 0, 0, 15582, 15583, 7, 3, 0, 0, 15583, + 15584, 7, 0, 0, 0, 15584, 15585, 7, 8, 0, 0, 15585, 15586, 7, 4, 0, 0, + 15586, 15587, 7, 6, 0, 0, 15587, 15588, 7, 3, 0, 0, 15588, 15589, 7, 5, + 0, 0, 15589, 2096, 1, 0, 0, 0, 15590, 15591, 7, 7, 0, 0, 15591, 15592, + 7, 11, 0, 0, 15592, 15593, 7, 5, 0, 0, 15593, 15594, 5, 95, 0, 0, 15594, + 15595, 7, 5, 0, 0, 15595, 15596, 7, 2, 0, 0, 15596, 15597, 7, 3, 0, 0, + 15597, 15598, 7, 4, 0, 0, 15598, 2098, 1, 0, 0, 0, 15599, 15600, 7, 7, + 0, 0, 15600, 15601, 7, 11, 0, 0, 15601, 15602, 7, 5, 0, 0, 15602, 15603, + 7, 5, 0, 0, 15603, 15604, 7, 2, 0, 0, 15604, 15605, 7, 3, 0, 0, 15605, + 15606, 7, 4, 0, 0, 15606, 2100, 1, 0, 0, 0, 15607, 15608, 7, 7, 0, 0, 15608, + 15609, 7, 11, 0, 0, 15609, 15610, 7, 5, 0, 0, 15610, 15611, 5, 95, 0, 0, + 15611, 15612, 7, 5, 0, 0, 15612, 15613, 7, 15, 0, 0, 15613, 15614, 7, 6, + 0, 0, 15614, 15615, 7, 8, 0, 0, 15615, 15616, 7, 10, 0, 0, 15616, 15617, + 7, 0, 0, 0, 15617, 15618, 7, 11, 0, 0, 15618, 15619, 5, 95, 0, 0, 15619, + 15620, 7, 8, 0, 0, 15620, 15621, 7, 19, 0, 0, 15621, 15622, 7, 0, 0, 0, + 15622, 15623, 7, 3, 0, 0, 15623, 15624, 7, 5, 0, 0, 15624, 2102, 1, 0, + 0, 0, 15625, 15626, 7, 7, 0, 0, 15626, 15627, 7, 11, 0, 0, 15627, 15628, + 7, 5, 0, 0, 15628, 15629, 5, 95, 0, 0, 15629, 15630, 7, 4, 0, 0, 15630, + 15631, 7, 6, 0, 0, 15631, 15632, 7, 3, 0, 0, 15632, 15633, 7, 3, 0, 0, + 15633, 15634, 7, 10, 0, 0, 15634, 15635, 7, 4, 0, 0, 15635, 15636, 7, 2, + 0, 0, 15636, 15637, 7, 3, 0, 0, 15637, 15638, 7, 18, 0, 0, 15638, 2104, + 1, 0, 0, 0, 15639, 15640, 7, 7, 0, 0, 15640, 15641, 7, 11, 0, 0, 15641, + 15642, 7, 5, 0, 0, 15642, 15643, 5, 95, 0, 0, 15643, 15644, 7, 12, 0, 0, + 15644, 15645, 7, 15, 0, 0, 15645, 15646, 7, 15, 0, 0, 15646, 15647, 7, + 6, 0, 0, 15647, 15648, 7, 3, 0, 0, 15648, 2106, 1, 0, 0, 0, 15649, 15650, + 7, 7, 0, 0, 15650, 15651, 7, 2, 0, 0, 15651, 15652, 5, 95, 0, 0, 15652, + 15653, 7, 0, 0, 0, 15653, 15654, 7, 8, 0, 0, 15654, 15655, 7, 8, 0, 0, + 15655, 15656, 7, 6, 0, 0, 15656, 15657, 7, 5, 0, 0, 15657, 15658, 7, 5, + 0, 0, 15658, 2108, 1, 0, 0, 0, 15659, 15660, 7, 7, 0, 0, 15660, 15661, + 7, 2, 0, 0, 15661, 15662, 5, 95, 0, 0, 15662, 15663, 7, 0, 0, 0, 15663, + 15664, 7, 9, 0, 0, 15664, 15665, 7, 0, 0, 0, 15665, 15666, 7, 15, 0, 0, + 15666, 15667, 7, 4, 0, 0, 15667, 15668, 7, 10, 0, 0, 15668, 15669, 7, 13, + 0, 0, 15669, 15670, 7, 6, 0, 0, 15670, 15671, 5, 95, 0, 0, 15671, 15672, + 7, 15, 0, 0, 15672, 15673, 7, 11, 0, 0, 15673, 15674, 7, 0, 0, 0, 15674, + 15675, 7, 7, 0, 0, 15675, 2110, 1, 0, 0, 0, 15676, 15677, 7, 7, 0, 0, 15677, + 15678, 7, 2, 0, 0, 15678, 15679, 5, 95, 0, 0, 15679, 15680, 7, 0, 0, 0, + 15680, 15681, 7, 7, 0, 0, 15681, 15682, 7, 5, 0, 0, 15682, 15683, 7, 10, + 0, 0, 15683, 15684, 5, 95, 0, 0, 15684, 15685, 7, 3, 0, 0, 15685, 15686, + 7, 6, 0, 0, 15686, 15687, 7, 0, 0, 0, 15687, 15688, 7, 3, 0, 0, 15688, + 15689, 7, 8, 0, 0, 15689, 15690, 7, 19, 0, 0, 15690, 2112, 1, 0, 0, 0, + 15691, 15692, 7, 7, 0, 0, 15692, 15693, 7, 2, 0, 0, 15693, 15694, 7, 0, + 0, 0, 15694, 15695, 7, 15, 0, 0, 15695, 15696, 7, 15, 0, 0, 15696, 15697, + 7, 6, 0, 0, 15697, 15698, 7, 7, 0, 0, 15698, 15699, 7, 9, 0, 0, 15699, + 2114, 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, 3, 0, 0, 15704, 15705, 7, 8, 0, 0, + 15705, 15706, 7, 19, 0, 0, 15706, 15707, 7, 10, 0, 0, 15707, 15708, 7, + 13, 0, 0, 15708, 15709, 7, 6, 0, 0, 15709, 15710, 7, 11, 0, 0, 15710, 15711, + 7, 2, 0, 0, 15711, 15712, 7, 17, 0, 0, 15712, 2116, 1, 0, 0, 0, 15713, + 15714, 7, 7, 0, 0, 15714, 15715, 7, 2, 0, 0, 15715, 15716, 7, 0, 0, 0, + 15716, 15717, 7, 12, 0, 0, 15717, 15718, 7, 9, 0, 0, 15718, 15719, 7, 10, + 0, 0, 15719, 15720, 7, 4, 0, 0, 15720, 2118, 1, 0, 0, 0, 15721, 15722, + 7, 7, 0, 0, 15722, 15723, 7, 2, 0, 0, 15723, 15724, 7, 1, 0, 0, 15724, + 15725, 7, 0, 0, 0, 15725, 15726, 7, 9, 0, 0, 15726, 15727, 7, 16, 0, 0, + 15727, 15728, 7, 10, 0, 0, 15728, 15729, 7, 11, 0, 0, 15729, 15730, 7, + 6, 0, 0, 15730, 2120, 1, 0, 0, 0, 15731, 15732, 7, 7, 0, 0, 15732, 15733, + 7, 2, 0, 0, 15733, 15734, 5, 95, 0, 0, 15734, 15735, 7, 0, 0, 0, 15735, + 15736, 7, 12, 0, 0, 15736, 15737, 7, 4, 0, 0, 15737, 15738, 7, 2, 0, 0, + 15738, 15739, 5, 95, 0, 0, 15739, 15740, 7, 3, 0, 0, 15740, 15741, 7, 6, + 0, 0, 15741, 15742, 7, 2, 0, 0, 15742, 15743, 7, 15, 0, 0, 15743, 15744, + 7, 4, 0, 0, 15744, 15745, 7, 10, 0, 0, 15745, 15746, 7, 14, 0, 0, 15746, + 15747, 7, 10, 0, 0, 15747, 15748, 7, 23, 0, 0, 15748, 15749, 7, 6, 0, 0, + 15749, 2122, 1, 0, 0, 0, 15750, 15751, 7, 7, 0, 0, 15751, 15752, 7, 2, + 0, 0, 15752, 15753, 5, 95, 0, 0, 15753, 15754, 7, 1, 0, 0, 15754, 15755, + 7, 0, 0, 0, 15755, 15756, 7, 5, 0, 0, 15756, 15757, 7, 6, 0, 0, 15757, + 15758, 7, 4, 0, 0, 15758, 15759, 7, 0, 0, 0, 15759, 15760, 7, 1, 0, 0, + 15760, 15761, 7, 11, 0, 0, 15761, 15762, 7, 6, 0, 0, 15762, 15763, 5, 95, + 0, 0, 15763, 15764, 7, 14, 0, 0, 15764, 15765, 7, 12, 0, 0, 15765, 15766, + 7, 11, 0, 0, 15766, 15767, 7, 4, 0, 0, 15767, 15768, 7, 10, 0, 0, 15768, + 15769, 7, 14, 0, 0, 15769, 15770, 7, 13, 0, 0, 15770, 15771, 5, 95, 0, + 0, 15771, 15772, 7, 3, 0, 0, 15772, 15773, 7, 6, 0, 0, 15773, 15774, 7, + 22, 0, 0, 15774, 15775, 7, 3, 0, 0, 15775, 15776, 7, 10, 0, 0, 15776, 15777, + 7, 4, 0, 0, 15777, 15778, 7, 6, 0, 0, 15778, 2124, 1, 0, 0, 0, 15779, 15780, + 7, 7, 0, 0, 15780, 15781, 7, 2, 0, 0, 15781, 15782, 5, 95, 0, 0, 15782, + 15783, 7, 1, 0, 0, 15783, 15784, 7, 0, 0, 0, 15784, 15785, 7, 4, 0, 0, + 15785, 15786, 7, 8, 0, 0, 15786, 15787, 7, 19, 0, 0, 15787, 15788, 5, 95, + 0, 0, 15788, 15789, 7, 4, 0, 0, 15789, 15790, 7, 0, 0, 0, 15790, 15791, + 7, 1, 0, 0, 15791, 15792, 7, 11, 0, 0, 15792, 15793, 7, 6, 0, 0, 15793, + 15794, 5, 95, 0, 0, 15794, 15795, 7, 0, 0, 0, 15795, 15796, 7, 8, 0, 0, + 15796, 15797, 7, 8, 0, 0, 15797, 15798, 7, 6, 0, 0, 15798, 15799, 7, 5, + 0, 0, 15799, 15800, 7, 5, 0, 0, 15800, 15801, 5, 95, 0, 0, 15801, 15802, + 7, 1, 0, 0, 15802, 15803, 7, 18, 0, 0, 15803, 15804, 5, 95, 0, 0, 15804, + 15805, 7, 3, 0, 0, 15805, 15806, 7, 2, 0, 0, 15806, 15807, 7, 22, 0, 0, + 15807, 15808, 7, 10, 0, 0, 15808, 15809, 7, 9, 0, 0, 15809, 2126, 1, 0, + 0, 0, 15810, 15811, 7, 7, 0, 0, 15811, 15812, 7, 2, 0, 0, 15812, 15813, + 5, 95, 0, 0, 15813, 15814, 7, 1, 0, 0, 15814, 15815, 7, 10, 0, 0, 15815, + 15816, 7, 7, 0, 0, 15816, 15817, 7, 9, 0, 0, 15817, 15818, 5, 95, 0, 0, + 15818, 15819, 7, 0, 0, 0, 15819, 15820, 7, 22, 0, 0, 15820, 15821, 7, 0, + 0, 0, 15821, 15822, 7, 3, 0, 0, 15822, 15823, 7, 6, 0, 0, 15823, 2128, + 1, 0, 0, 0, 15824, 15825, 7, 7, 0, 0, 15825, 15826, 7, 2, 0, 0, 15826, + 15827, 5, 95, 0, 0, 15827, 15828, 7, 1, 0, 0, 15828, 15829, 7, 12, 0, 0, + 15829, 15830, 7, 16, 0, 0, 15830, 15831, 7, 16, 0, 0, 15831, 15832, 7, + 6, 0, 0, 15832, 15833, 7, 3, 0, 0, 15833, 2130, 1, 0, 0, 0, 15834, 15835, + 7, 7, 0, 0, 15835, 15836, 7, 2, 0, 0, 15836, 15837, 7, 8, 0, 0, 15837, + 15838, 7, 0, 0, 0, 15838, 15839, 7, 8, 0, 0, 15839, 15840, 7, 19, 0, 0, + 15840, 15841, 7, 6, 0, 0, 15841, 2132, 1, 0, 0, 0, 15842, 15843, 7, 7, + 0, 0, 15843, 15844, 7, 2, 0, 0, 15844, 15845, 7, 8, 0, 0, 15845, 15846, + 7, 19, 0, 0, 15846, 15847, 7, 6, 0, 0, 15847, 15848, 7, 8, 0, 0, 15848, + 15849, 7, 21, 0, 0, 15849, 2134, 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, 0, 0, 0, 15855, 15856, 7, 3, 0, 0, 15856, 15857, + 7, 4, 0, 0, 15857, 15858, 7, 6, 0, 0, 15858, 15859, 7, 5, 0, 0, 15859, + 15860, 7, 10, 0, 0, 15860, 15861, 7, 0, 0, 0, 15861, 15862, 7, 7, 0, 0, + 15862, 2136, 1, 0, 0, 0, 15863, 15864, 7, 7, 0, 0, 15864, 15865, 7, 2, + 0, 0, 15865, 15866, 5, 95, 0, 0, 15866, 15867, 7, 8, 0, 0, 15867, 15868, + 7, 19, 0, 0, 15868, 15869, 7, 6, 0, 0, 15869, 15870, 7, 8, 0, 0, 15870, + 15871, 7, 21, 0, 0, 15871, 15872, 5, 95, 0, 0, 15872, 15873, 7, 0, 0, 0, + 15873, 15874, 7, 8, 0, 0, 15874, 15875, 7, 11, 0, 0, 15875, 15876, 5, 95, + 0, 0, 15876, 15877, 7, 3, 0, 0, 15877, 15878, 7, 6, 0, 0, 15878, 15879, + 7, 22, 0, 0, 15879, 15880, 7, 3, 0, 0, 15880, 15881, 7, 10, 0, 0, 15881, + 15882, 7, 4, 0, 0, 15882, 15883, 7, 6, 0, 0, 15883, 2138, 1, 0, 0, 0, 15884, + 15885, 7, 7, 0, 0, 15885, 15886, 7, 2, 0, 0, 15886, 15887, 5, 95, 0, 0, + 15887, 15888, 7, 8, 0, 0, 15888, 15889, 7, 11, 0, 0, 15889, 15890, 7, 12, + 0, 0, 15890, 15891, 7, 5, 0, 0, 15891, 15892, 7, 4, 0, 0, 15892, 15893, + 7, 6, 0, 0, 15893, 15894, 7, 3, 0, 0, 15894, 15895, 5, 95, 0, 0, 15895, + 15896, 7, 1, 0, 0, 15896, 15897, 7, 18, 0, 0, 15897, 15898, 5, 95, 0, 0, + 15898, 15899, 7, 3, 0, 0, 15899, 15900, 7, 2, 0, 0, 15900, 15901, 7, 22, + 0, 0, 15901, 15902, 7, 10, 0, 0, 15902, 15903, 7, 9, 0, 0, 15903, 2140, + 1, 0, 0, 0, 15904, 15905, 7, 7, 0, 0, 15905, 15906, 7, 2, 0, 0, 15906, + 15907, 5, 95, 0, 0, 15907, 15908, 7, 8, 0, 0, 15908, 15909, 7, 11, 0, 0, + 15909, 15910, 7, 12, 0, 0, 15910, 15911, 7, 5, 0, 0, 15911, 15912, 7, 4, + 0, 0, 15912, 15913, 7, 6, 0, 0, 15913, 15914, 7, 3, 0, 0, 15914, 15915, + 7, 10, 0, 0, 15915, 15916, 7, 7, 0, 0, 15916, 15917, 7, 17, 0, 0, 15917, + 2142, 1, 0, 0, 0, 15918, 15919, 7, 7, 0, 0, 15919, 15920, 7, 2, 0, 0, 15920, + 15921, 5, 95, 0, 0, 15921, 15922, 7, 8, 0, 0, 15922, 15923, 7, 2, 0, 0, + 15923, 15924, 7, 0, 0, 0, 15924, 15925, 7, 11, 0, 0, 15925, 15926, 7, 6, + 0, 0, 15926, 15927, 7, 5, 0, 0, 15927, 15928, 7, 8, 0, 0, 15928, 15929, + 7, 6, 0, 0, 15929, 15930, 5, 95, 0, 0, 15930, 15931, 7, 5, 0, 0, 15931, + 15932, 7, 24, 0, 0, 15932, 2144, 1, 0, 0, 0, 15933, 15934, 7, 7, 0, 0, + 15934, 15935, 7, 2, 0, 0, 15935, 15936, 5, 95, 0, 0, 15936, 15937, 7, 8, + 0, 0, 15937, 15938, 7, 2, 0, 0, 15938, 15939, 7, 14, 0, 0, 15939, 15940, + 7, 14, 0, 0, 15940, 15941, 7, 2, 0, 0, 15941, 15942, 7, 7, 0, 0, 15942, + 15943, 5, 95, 0, 0, 15943, 15944, 7, 9, 0, 0, 15944, 15945, 7, 0, 0, 0, + 15945, 15946, 7, 4, 0, 0, 15946, 15947, 7, 0, 0, 0, 15947, 2146, 1, 0, + 0, 0, 15948, 15949, 7, 7, 0, 0, 15949, 15950, 7, 2, 0, 0, 15950, 15951, + 7, 8, 0, 0, 15951, 15952, 7, 2, 0, 0, 15952, 15953, 7, 14, 0, 0, 15953, + 15954, 7, 15, 0, 0, 15954, 15955, 7, 3, 0, 0, 15955, 15956, 7, 6, 0, 0, + 15956, 15957, 7, 5, 0, 0, 15957, 15958, 7, 5, 0, 0, 15958, 2148, 1, 0, + 0, 0, 15959, 15960, 7, 7, 0, 0, 15960, 15961, 7, 2, 0, 0, 15961, 15962, + 5, 95, 0, 0, 15962, 15963, 7, 8, 0, 0, 15963, 15964, 7, 2, 0, 0, 15964, + 15965, 7, 7, 0, 0, 15965, 15966, 7, 7, 0, 0, 15966, 15967, 7, 6, 0, 0, + 15967, 15968, 7, 8, 0, 0, 15968, 15969, 7, 4, 0, 0, 15969, 15970, 5, 95, + 0, 0, 15970, 15971, 7, 1, 0, 0, 15971, 15972, 7, 18, 0, 0, 15972, 15973, + 5, 95, 0, 0, 15973, 15974, 7, 8, 0, 0, 15974, 15975, 7, 1, 0, 0, 15975, + 15976, 5, 95, 0, 0, 15976, 15977, 7, 22, 0, 0, 15977, 15978, 7, 19, 0, + 0, 15978, 15979, 7, 3, 0, 0, 15979, 15980, 5, 95, 0, 0, 15980, 15981, 7, + 2, 0, 0, 15981, 15982, 7, 7, 0, 0, 15982, 15983, 7, 11, 0, 0, 15983, 15984, + 7, 18, 0, 0, 15984, 2150, 1, 0, 0, 0, 15985, 15986, 7, 7, 0, 0, 15986, + 15987, 7, 2, 0, 0, 15987, 15988, 5, 95, 0, 0, 15988, 15989, 7, 8, 0, 0, + 15989, 15990, 7, 2, 0, 0, 15990, 15991, 7, 7, 0, 0, 15991, 15992, 7, 7, + 0, 0, 15992, 15993, 7, 6, 0, 0, 15993, 15994, 7, 8, 0, 0, 15994, 15995, + 7, 4, 0, 0, 15995, 15996, 5, 95, 0, 0, 15996, 15997, 7, 1, 0, 0, 15997, + 15998, 7, 18, 0, 0, 15998, 15999, 5, 95, 0, 0, 15999, 16000, 7, 8, 0, 0, + 16000, 16001, 7, 2, 0, 0, 16001, 16002, 7, 14, 0, 0, 16002, 16003, 7, 1, + 0, 0, 16003, 16004, 7, 10, 0, 0, 16004, 16005, 7, 7, 0, 0, 16005, 16006, + 7, 6, 0, 0, 16006, 16007, 5, 95, 0, 0, 16007, 16008, 7, 5, 0, 0, 16008, + 16009, 7, 22, 0, 0, 16009, 2152, 1, 0, 0, 0, 16010, 16011, 7, 7, 0, 0, + 16011, 16012, 7, 2, 0, 0, 16012, 16013, 5, 95, 0, 0, 16013, 16014, 7, 8, + 0, 0, 16014, 16015, 7, 2, 0, 0, 16015, 16016, 7, 7, 0, 0, 16016, 16017, + 7, 7, 0, 0, 16017, 16018, 7, 6, 0, 0, 16018, 16019, 7, 8, 0, 0, 16019, + 16020, 7, 4, 0, 0, 16020, 16021, 5, 95, 0, 0, 16021, 16022, 7, 1, 0, 0, + 16022, 16023, 7, 18, 0, 0, 16023, 16024, 5, 95, 0, 0, 16024, 16025, 7, + 8, 0, 0, 16025, 16026, 7, 2, 0, 0, 16026, 16027, 7, 5, 0, 0, 16027, 16028, + 7, 4, 0, 0, 16028, 16029, 5, 95, 0, 0, 16029, 16030, 7, 1, 0, 0, 16030, + 16031, 7, 0, 0, 0, 16031, 16032, 7, 5, 0, 0, 16032, 16033, 7, 6, 0, 0, + 16033, 16034, 7, 9, 0, 0, 16034, 2154, 1, 0, 0, 0, 16035, 16036, 7, 7, + 0, 0, 16036, 16037, 7, 2, 0, 0, 16037, 16038, 5, 95, 0, 0, 16038, 16039, + 7, 8, 0, 0, 16039, 16040, 7, 2, 0, 0, 16040, 16041, 7, 7, 0, 0, 16041, + 16042, 7, 7, 0, 0, 16042, 16043, 7, 6, 0, 0, 16043, 16044, 7, 8, 0, 0, + 16044, 16045, 7, 4, 0, 0, 16045, 16046, 5, 95, 0, 0, 16046, 16047, 7, 1, + 0, 0, 16047, 16048, 7, 18, 0, 0, 16048, 16049, 5, 95, 0, 0, 16049, 16050, + 7, 6, 0, 0, 16050, 16051, 7, 11, 0, 0, 16051, 16052, 7, 10, 0, 0, 16052, + 16053, 7, 14, 0, 0, 16053, 16054, 5, 95, 0, 0, 16054, 16055, 7, 9, 0, 0, + 16055, 16056, 7, 12, 0, 0, 16056, 16057, 7, 15, 0, 0, 16057, 16058, 7, + 5, 0, 0, 16058, 2156, 1, 0, 0, 0, 16059, 16060, 7, 7, 0, 0, 16060, 16061, + 7, 2, 0, 0, 16061, 16062, 5, 95, 0, 0, 16062, 16063, 7, 8, 0, 0, 16063, + 16064, 7, 2, 0, 0, 16064, 16065, 7, 7, 0, 0, 16065, 16066, 7, 7, 0, 0, + 16066, 16067, 7, 6, 0, 0, 16067, 16068, 7, 8, 0, 0, 16068, 16069, 7, 4, + 0, 0, 16069, 16070, 5, 95, 0, 0, 16070, 16071, 7, 1, 0, 0, 16071, 16072, + 7, 18, 0, 0, 16072, 16073, 5, 95, 0, 0, 16073, 16074, 7, 16, 0, 0, 16074, + 16075, 7, 10, 0, 0, 16075, 16076, 7, 11, 0, 0, 16076, 16077, 7, 4, 0, 0, + 16077, 16078, 7, 6, 0, 0, 16078, 16079, 7, 3, 0, 0, 16079, 16080, 7, 10, + 0, 0, 16080, 16081, 7, 7, 0, 0, 16081, 16082, 7, 17, 0, 0, 16082, 2158, + 1, 0, 0, 0, 16083, 16084, 7, 7, 0, 0, 16084, 16085, 7, 2, 0, 0, 16085, + 16086, 7, 8, 0, 0, 16086, 16087, 7, 2, 0, 0, 16087, 16088, 7, 15, 0, 0, + 16088, 16089, 7, 18, 0, 0, 16089, 2160, 1, 0, 0, 0, 16090, 16091, 7, 7, + 0, 0, 16091, 16092, 7, 2, 0, 0, 16092, 16093, 5, 95, 0, 0, 16093, 16094, + 7, 8, 0, 0, 16094, 16095, 7, 2, 0, 0, 16095, 16096, 7, 5, 0, 0, 16096, + 16097, 7, 4, 0, 0, 16097, 16098, 5, 95, 0, 0, 16098, 16099, 7, 25, 0, 0, + 16099, 16100, 7, 14, 0, 0, 16100, 16101, 7, 11, 0, 0, 16101, 16102, 5, + 95, 0, 0, 16102, 16103, 7, 24, 0, 0, 16103, 16104, 7, 12, 0, 0, 16104, + 16105, 7, 6, 0, 0, 16105, 16106, 7, 3, 0, 0, 16106, 16107, 7, 18, 0, 0, + 16107, 16108, 5, 95, 0, 0, 16108, 16109, 7, 3, 0, 0, 16109, 16110, 7, 6, + 0, 0, 16110, 16111, 7, 22, 0, 0, 16111, 16112, 7, 3, 0, 0, 16112, 16113, + 7, 10, 0, 0, 16113, 16114, 7, 4, 0, 0, 16114, 16115, 7, 6, 0, 0, 16115, + 2162, 1, 0, 0, 0, 16116, 16117, 7, 7, 0, 0, 16117, 16118, 7, 2, 0, 0, 16118, + 16119, 5, 95, 0, 0, 16119, 16120, 7, 8, 0, 0, 16120, 16121, 7, 15, 0, 0, + 16121, 16122, 7, 12, 0, 0, 16122, 16123, 5, 95, 0, 0, 16123, 16124, 7, + 8, 0, 0, 16124, 16125, 7, 2, 0, 0, 16125, 16126, 7, 5, 0, 0, 16126, 16127, + 7, 4, 0, 0, 16127, 16128, 7, 10, 0, 0, 16128, 16129, 7, 7, 0, 0, 16129, + 16130, 7, 17, 0, 0, 16130, 2164, 1, 0, 0, 0, 16131, 16132, 7, 7, 0, 0, + 16132, 16133, 7, 2, 0, 0, 16133, 16134, 7, 8, 0, 0, 16134, 16135, 7, 15, + 0, 0, 16135, 16136, 7, 12, 0, 0, 16136, 16137, 5, 95, 0, 0, 16137, 16138, + 7, 8, 0, 0, 16138, 16139, 7, 2, 0, 0, 16139, 16140, 7, 5, 0, 0, 16140, + 16141, 7, 4, 0, 0, 16141, 16142, 7, 10, 0, 0, 16142, 16143, 7, 7, 0, 0, + 16143, 16144, 7, 17, 0, 0, 16144, 2166, 1, 0, 0, 0, 16145, 16146, 7, 7, + 0, 0, 16146, 16147, 7, 2, 0, 0, 16147, 16148, 7, 8, 0, 0, 16148, 16149, + 7, 18, 0, 0, 16149, 16150, 7, 8, 0, 0, 16150, 16151, 7, 11, 0, 0, 16151, + 16152, 7, 6, 0, 0, 16152, 2168, 1, 0, 0, 0, 16153, 16154, 7, 7, 0, 0, 16154, + 16155, 7, 2, 0, 0, 16155, 16156, 5, 95, 0, 0, 16156, 16157, 7, 9, 0, 0, + 16157, 16158, 7, 0, 0, 0, 16158, 16159, 7, 4, 0, 0, 16159, 16160, 7, 0, + 0, 0, 16160, 16161, 5, 95, 0, 0, 16161, 16162, 7, 5, 0, 0, 16162, 16163, + 7, 6, 0, 0, 16163, 16164, 7, 8, 0, 0, 16164, 16165, 7, 12, 0, 0, 16165, + 16166, 7, 3, 0, 0, 16166, 16167, 7, 10, 0, 0, 16167, 16168, 7, 4, 0, 0, + 16168, 16169, 7, 18, 0, 0, 16169, 16170, 5, 95, 0, 0, 16170, 16171, 7, + 3, 0, 0, 16171, 16172, 7, 6, 0, 0, 16172, 16173, 7, 22, 0, 0, 16173, 16174, + 7, 3, 0, 0, 16174, 16175, 7, 10, 0, 0, 16175, 16176, 7, 4, 0, 0, 16176, + 16177, 7, 6, 0, 0, 16177, 2170, 1, 0, 0, 0, 16178, 16179, 7, 7, 0, 0, 16179, + 16180, 7, 2, 0, 0, 16180, 16181, 5, 95, 0, 0, 16181, 16182, 7, 9, 0, 0, + 16182, 16183, 7, 6, 0, 0, 16183, 16184, 7, 8, 0, 0, 16184, 16185, 7, 2, + 0, 0, 16185, 16186, 7, 3, 0, 0, 16186, 16187, 7, 3, 0, 0, 16187, 16188, + 7, 6, 0, 0, 16188, 16189, 7, 11, 0, 0, 16189, 16190, 7, 0, 0, 0, 16190, + 16191, 7, 4, 0, 0, 16191, 16192, 7, 6, 0, 0, 16192, 2172, 1, 0, 0, 0, 16193, + 16194, 7, 7, 0, 0, 16194, 16195, 7, 2, 0, 0, 16195, 16196, 7, 9, 0, 0, + 16196, 16197, 7, 6, 0, 0, 16197, 16198, 7, 11, 0, 0, 16198, 16199, 7, 0, + 0, 0, 16199, 16200, 7, 18, 0, 0, 16200, 2174, 1, 0, 0, 0, 16201, 16202, + 7, 7, 0, 0, 16202, 16203, 7, 2, 0, 0, 16203, 16204, 7, 9, 0, 0, 16204, + 16205, 7, 10, 0, 0, 16205, 16206, 7, 3, 0, 0, 16206, 16207, 7, 6, 0, 0, + 16207, 16208, 7, 8, 0, 0, 16208, 16209, 7, 4, 0, 0, 16209, 16210, 7, 10, + 0, 0, 16210, 16211, 7, 2, 0, 0, 16211, 2176, 1, 0, 0, 0, 16212, 16213, + 7, 7, 0, 0, 16213, 16214, 7, 2, 0, 0, 16214, 16215, 7, 9, 0, 0, 16215, + 16216, 7, 10, 0, 0, 16216, 16217, 7, 5, 0, 0, 16217, 16218, 7, 8, 0, 0, + 16218, 16219, 7, 0, 0, 0, 16219, 16220, 7, 3, 0, 0, 16220, 16221, 7, 9, + 0, 0, 16221, 16222, 7, 16, 0, 0, 16222, 16223, 7, 10, 0, 0, 16223, 16224, + 7, 11, 0, 0, 16224, 16225, 7, 6, 0, 0, 16225, 2178, 1, 0, 0, 0, 16226, + 16227, 7, 7, 0, 0, 16227, 16228, 7, 2, 0, 0, 16228, 16229, 5, 95, 0, 0, + 16229, 16230, 7, 9, 0, 0, 16230, 16231, 7, 2, 0, 0, 16231, 16232, 7, 14, + 0, 0, 16232, 16233, 7, 0, 0, 0, 16233, 16234, 7, 10, 0, 0, 16234, 16235, + 7, 7, 0, 0, 16235, 16236, 5, 95, 0, 0, 16236, 16237, 7, 10, 0, 0, 16237, + 16238, 7, 7, 0, 0, 16238, 16239, 7, 9, 0, 0, 16239, 16240, 7, 6, 0, 0, + 16240, 16241, 7, 25, 0, 0, 16241, 16242, 5, 95, 0, 0, 16242, 16243, 7, + 16, 0, 0, 16243, 16244, 7, 10, 0, 0, 16244, 16245, 7, 11, 0, 0, 16245, + 16246, 7, 4, 0, 0, 16246, 16247, 7, 6, 0, 0, 16247, 16248, 7, 3, 0, 0, + 16248, 2180, 1, 0, 0, 0, 16249, 16250, 7, 7, 0, 0, 16250, 16251, 7, 2, + 0, 0, 16251, 16252, 5, 95, 0, 0, 16252, 16253, 7, 9, 0, 0, 16253, 16254, + 7, 5, 0, 0, 16254, 16255, 7, 4, 0, 0, 16255, 16256, 5, 95, 0, 0, 16256, + 16257, 7, 12, 0, 0, 16257, 16258, 7, 15, 0, 0, 16258, 16259, 7, 17, 0, + 0, 16259, 16260, 7, 3, 0, 0, 16260, 16261, 7, 0, 0, 0, 16261, 16262, 7, + 9, 0, 0, 16262, 16263, 7, 6, 0, 0, 16263, 16264, 5, 95, 0, 0, 16264, 16265, + 7, 10, 0, 0, 16265, 16266, 7, 7, 0, 0, 16266, 16267, 7, 5, 0, 0, 16267, + 16268, 7, 6, 0, 0, 16268, 16269, 7, 3, 0, 0, 16269, 16270, 7, 4, 0, 0, + 16270, 16271, 5, 95, 0, 0, 16271, 16272, 7, 8, 0, 0, 16272, 16273, 7, 2, + 0, 0, 16273, 16274, 7, 7, 0, 0, 16274, 16275, 7, 13, 0, 0, 16275, 2182, + 1, 0, 0, 0, 16276, 16277, 7, 7, 0, 0, 16277, 16278, 7, 2, 0, 0, 16278, + 16279, 5, 95, 0, 0, 16279, 16280, 7, 6, 0, 0, 16280, 16281, 7, 11, 0, 0, + 16281, 16282, 7, 10, 0, 0, 16282, 16283, 7, 14, 0, 0, 16283, 16284, 5, + 95, 0, 0, 16284, 16285, 7, 17, 0, 0, 16285, 16286, 7, 3, 0, 0, 16286, 16287, + 7, 2, 0, 0, 16287, 16288, 7, 12, 0, 0, 16288, 16289, 7, 15, 0, 0, 16289, + 16290, 7, 1, 0, 0, 16290, 16291, 7, 18, 0, 0, 16291, 2184, 1, 0, 0, 0, + 16292, 16293, 7, 7, 0, 0, 16293, 16294, 7, 2, 0, 0, 16294, 16295, 5, 95, + 0, 0, 16295, 16296, 7, 6, 0, 0, 16296, 16297, 7, 11, 0, 0, 16297, 16298, + 7, 10, 0, 0, 16298, 16299, 7, 14, 0, 0, 16299, 16300, 7, 10, 0, 0, 16300, + 16301, 7, 7, 0, 0, 16301, 16302, 7, 0, 0, 0, 16302, 16303, 7, 4, 0, 0, + 16303, 16304, 7, 6, 0, 0, 16304, 16305, 5, 95, 0, 0, 16305, 16306, 7, 20, + 0, 0, 16306, 16307, 7, 2, 0, 0, 16307, 16308, 7, 10, 0, 0, 16308, 16309, + 7, 7, 0, 0, 16309, 2186, 1, 0, 0, 0, 16310, 16311, 7, 7, 0, 0, 16311, 16312, + 7, 2, 0, 0, 16312, 16313, 5, 95, 0, 0, 16313, 16314, 7, 6, 0, 0, 16314, + 16315, 7, 11, 0, 0, 16315, 16316, 7, 10, 0, 0, 16316, 16317, 7, 14, 0, + 0, 16317, 16318, 7, 10, 0, 0, 16318, 16319, 7, 7, 0, 0, 16319, 16320, 7, + 0, 0, 0, 16320, 16321, 7, 4, 0, 0, 16321, 16322, 7, 6, 0, 0, 16322, 16323, + 5, 95, 0, 0, 16323, 16324, 7, 2, 0, 0, 16324, 16325, 7, 1, 0, 0, 16325, + 16326, 7, 18, 0, 0, 16326, 2188, 1, 0, 0, 0, 16327, 16328, 7, 7, 0, 0, + 16328, 16329, 7, 2, 0, 0, 16329, 16330, 5, 95, 0, 0, 16330, 16331, 7, 6, + 0, 0, 16331, 16332, 7, 11, 0, 0, 16332, 16333, 7, 10, 0, 0, 16333, 16334, + 7, 14, 0, 0, 16334, 16335, 7, 10, 0, 0, 16335, 16336, 7, 7, 0, 0, 16336, + 16337, 7, 0, 0, 0, 16337, 16338, 7, 4, 0, 0, 16338, 16339, 7, 6, 0, 0, + 16339, 16340, 5, 95, 0, 0, 16340, 16341, 7, 2, 0, 0, 16341, 16342, 7, 12, + 0, 0, 16342, 16343, 7, 4, 0, 0, 16343, 16344, 7, 6, 0, 0, 16344, 16345, + 7, 3, 0, 0, 16345, 16346, 5, 95, 0, 0, 16346, 16347, 7, 20, 0, 0, 16347, + 16348, 7, 2, 0, 0, 16348, 16349, 7, 10, 0, 0, 16349, 16350, 7, 7, 0, 0, + 16350, 2190, 1, 0, 0, 0, 16351, 16352, 7, 7, 0, 0, 16352, 16353, 7, 2, + 0, 0, 16353, 16354, 7, 6, 0, 0, 16354, 16355, 7, 7, 0, 0, 16355, 16356, + 7, 4, 0, 0, 16356, 16357, 7, 10, 0, 0, 16357, 16358, 7, 4, 0, 0, 16358, + 16359, 7, 18, 0, 0, 16359, 16360, 7, 6, 0, 0, 16360, 16361, 7, 5, 0, 0, + 16361, 16362, 7, 8, 0, 0, 16362, 16363, 7, 0, 0, 0, 16363, 16364, 7, 15, + 0, 0, 16364, 16365, 7, 10, 0, 0, 16365, 16366, 7, 7, 0, 0, 16366, 16367, + 7, 17, 0, 0, 16367, 2192, 1, 0, 0, 0, 16368, 16369, 7, 7, 0, 0, 16369, + 16370, 7, 2, 0, 0, 16370, 16371, 5, 95, 0, 0, 16371, 16372, 7, 6, 0, 0, + 16372, 16373, 7, 25, 0, 0, 16373, 16374, 7, 15, 0, 0, 16374, 16375, 7, + 0, 0, 0, 16375, 16376, 7, 7, 0, 0, 16376, 16377, 7, 9, 0, 0, 16377, 16378, + 5, 95, 0, 0, 16378, 16379, 7, 17, 0, 0, 16379, 16380, 7, 5, 0, 0, 16380, + 16381, 7, 6, 0, 0, 16381, 16382, 7, 4, 0, 0, 16382, 16383, 5, 95, 0, 0, + 16383, 16384, 7, 4, 0, 0, 16384, 16385, 7, 2, 0, 0, 16385, 16386, 5, 95, + 0, 0, 16386, 16387, 7, 12, 0, 0, 16387, 16388, 7, 7, 0, 0, 16388, 16389, + 7, 10, 0, 0, 16389, 16390, 7, 2, 0, 0, 16390, 16391, 7, 7, 0, 0, 16391, + 2194, 1, 0, 0, 0, 16392, 16393, 7, 7, 0, 0, 16393, 16394, 7, 2, 0, 0, 16394, + 16395, 5, 95, 0, 0, 16395, 16396, 7, 6, 0, 0, 16396, 16397, 7, 25, 0, 0, + 16397, 16398, 7, 15, 0, 0, 16398, 16399, 7, 0, 0, 0, 16399, 16400, 7, 7, + 0, 0, 16400, 16401, 7, 9, 0, 0, 16401, 2196, 1, 0, 0, 0, 16402, 16403, + 7, 7, 0, 0, 16403, 16404, 7, 2, 0, 0, 16404, 16405, 5, 95, 0, 0, 16405, + 16406, 7, 6, 0, 0, 16406, 16407, 7, 25, 0, 0, 16407, 16408, 7, 15, 0, 0, + 16408, 16409, 7, 0, 0, 0, 16409, 16410, 7, 7, 0, 0, 16410, 16411, 7, 9, + 0, 0, 16411, 16412, 5, 95, 0, 0, 16412, 16413, 7, 4, 0, 0, 16413, 16414, + 7, 0, 0, 0, 16414, 16415, 7, 1, 0, 0, 16415, 16416, 7, 11, 0, 0, 16416, + 16417, 7, 6, 0, 0, 16417, 2198, 1, 0, 0, 0, 16418, 16419, 7, 7, 0, 0, 16419, + 16420, 7, 2, 0, 0, 16420, 16421, 7, 6, 0, 0, 16421, 16422, 7, 25, 0, 0, + 16422, 16423, 7, 4, 0, 0, 16423, 16424, 7, 6, 0, 0, 16424, 16425, 7, 7, + 0, 0, 16425, 16426, 7, 9, 0, 0, 16426, 2200, 1, 0, 0, 0, 16427, 16428, + 7, 7, 0, 0, 16428, 16429, 7, 2, 0, 0, 16429, 16430, 5, 95, 0, 0, 16430, + 16431, 7, 16, 0, 0, 16431, 16432, 7, 0, 0, 0, 16432, 16433, 7, 8, 0, 0, + 16433, 16434, 7, 4, 0, 0, 16434, 2202, 1, 0, 0, 0, 16435, 16436, 7, 7, + 0, 0, 16436, 16437, 7, 2, 0, 0, 16437, 16438, 5, 95, 0, 0, 16438, 16439, + 7, 16, 0, 0, 16439, 16440, 7, 0, 0, 0, 16440, 16441, 7, 8, 0, 0, 16441, + 16442, 7, 4, 0, 0, 16442, 16443, 7, 2, 0, 0, 16443, 16444, 7, 3, 0, 0, + 16444, 16445, 7, 10, 0, 0, 16445, 16446, 7, 23, 0, 0, 16446, 16447, 7, + 6, 0, 0, 16447, 16448, 5, 95, 0, 0, 16448, 16449, 7, 20, 0, 0, 16449, 16450, + 7, 2, 0, 0, 16450, 16451, 7, 10, 0, 0, 16451, 16452, 7, 7, 0, 0, 16452, + 2204, 1, 0, 0, 0, 16453, 16454, 7, 7, 0, 0, 16454, 16455, 7, 2, 0, 0, 16455, + 16456, 5, 95, 0, 0, 16456, 16457, 7, 16, 0, 0, 16457, 16458, 7, 10, 0, + 0, 16458, 16459, 7, 11, 0, 0, 16459, 16460, 7, 4, 0, 0, 16460, 16461, 7, + 6, 0, 0, 16461, 16462, 7, 3, 0, 0, 16462, 16463, 7, 10, 0, 0, 16463, 16464, + 7, 7, 0, 0, 16464, 16465, 7, 17, 0, 0, 16465, 2206, 1, 0, 0, 0, 16466, + 16467, 7, 7, 0, 0, 16467, 16468, 7, 2, 0, 0, 16468, 16469, 7, 16, 0, 0, + 16469, 16470, 7, 2, 0, 0, 16470, 16471, 7, 3, 0, 0, 16471, 16472, 7, 8, + 0, 0, 16472, 16473, 7, 6, 0, 0, 16473, 2208, 1, 0, 0, 0, 16474, 16475, + 7, 7, 0, 0, 16475, 16476, 7, 2, 0, 0, 16476, 16477, 5, 95, 0, 0, 16477, + 16478, 7, 16, 0, 0, 16478, 16479, 7, 12, 0, 0, 16479, 16480, 7, 11, 0, + 0, 16480, 16481, 7, 11, 0, 0, 16481, 16482, 5, 95, 0, 0, 16482, 16483, + 7, 2, 0, 0, 16483, 16484, 7, 12, 0, 0, 16484, 16485, 7, 4, 0, 0, 16485, + 16486, 7, 6, 0, 0, 16486, 16487, 7, 3, 0, 0, 16487, 16488, 5, 95, 0, 0, + 16488, 16489, 7, 20, 0, 0, 16489, 16490, 7, 2, 0, 0, 16490, 16491, 7, 10, + 0, 0, 16491, 16492, 7, 7, 0, 0, 16492, 16493, 5, 95, 0, 0, 16493, 16494, + 7, 4, 0, 0, 16494, 16495, 7, 2, 0, 0, 16495, 16496, 5, 95, 0, 0, 16496, + 16497, 7, 2, 0, 0, 16497, 16498, 7, 12, 0, 0, 16498, 16499, 7, 4, 0, 0, + 16499, 16500, 7, 6, 0, 0, 16500, 16501, 7, 3, 0, 0, 16501, 2210, 1, 0, + 0, 0, 16502, 16503, 7, 7, 0, 0, 16503, 16504, 7, 2, 0, 0, 16504, 16505, + 5, 95, 0, 0, 16505, 16506, 7, 17, 0, 0, 16506, 16507, 7, 0, 0, 0, 16507, + 16508, 7, 4, 0, 0, 16508, 16509, 7, 19, 0, 0, 16509, 16510, 7, 6, 0, 0, + 16510, 16511, 7, 3, 0, 0, 16511, 16512, 5, 95, 0, 0, 16512, 16513, 7, 2, + 0, 0, 16513, 16514, 7, 15, 0, 0, 16514, 16515, 7, 4, 0, 0, 16515, 16516, + 7, 10, 0, 0, 16516, 16517, 7, 14, 0, 0, 16517, 16518, 7, 10, 0, 0, 16518, + 16519, 7, 23, 0, 0, 16519, 16520, 7, 6, 0, 0, 16520, 16521, 7, 3, 0, 0, + 16521, 16522, 5, 95, 0, 0, 16522, 16523, 7, 5, 0, 0, 16523, 16524, 7, 4, + 0, 0, 16524, 16525, 7, 0, 0, 0, 16525, 16526, 7, 4, 0, 0, 16526, 16527, + 7, 10, 0, 0, 16527, 16528, 7, 5, 0, 0, 16528, 16529, 7, 4, 0, 0, 16529, + 16530, 7, 10, 0, 0, 16530, 16531, 7, 8, 0, 0, 16531, 16532, 7, 5, 0, 0, + 16532, 2212, 1, 0, 0, 0, 16533, 16534, 7, 7, 0, 0, 16534, 16535, 7, 2, + 0, 0, 16535, 16536, 5, 95, 0, 0, 16536, 16537, 7, 17, 0, 0, 16537, 16538, + 7, 1, 0, 0, 16538, 16539, 7, 18, 0, 0, 16539, 16540, 5, 95, 0, 0, 16540, + 16541, 7, 15, 0, 0, 16541, 16542, 7, 12, 0, 0, 16542, 16543, 7, 5, 0, 0, + 16543, 16544, 7, 19, 0, 0, 16544, 16545, 7, 9, 0, 0, 16545, 16546, 7, 2, + 0, 0, 16546, 16547, 7, 22, 0, 0, 16547, 16548, 7, 7, 0, 0, 16548, 2214, + 1, 0, 0, 0, 16549, 16550, 7, 7, 0, 0, 16550, 16551, 7, 2, 0, 0, 16551, + 16552, 7, 17, 0, 0, 16552, 16553, 7, 12, 0, 0, 16553, 16554, 7, 0, 0, 0, + 16554, 16555, 7, 3, 0, 0, 16555, 16556, 7, 0, 0, 0, 16556, 16557, 7, 7, + 0, 0, 16557, 16558, 7, 4, 0, 0, 16558, 16559, 7, 6, 0, 0, 16559, 16560, + 7, 6, 0, 0, 16560, 2216, 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, 16570, 5, 95, 0, 0, 16570, 16571, 7, + 16, 0, 0, 16571, 16572, 7, 16, 0, 0, 16572, 16573, 7, 5, 0, 0, 16573, 2218, + 1, 0, 0, 0, 16574, 16575, 7, 7, 0, 0, 16575, 16576, 7, 2, 0, 0, 16576, + 16577, 5, 95, 0, 0, 16577, 16578, 7, 10, 0, 0, 16578, 16579, 7, 7, 0, 0, + 16579, 16580, 7, 9, 0, 0, 16580, 16581, 7, 6, 0, 0, 16581, 16582, 7, 25, + 0, 0, 16582, 2220, 1, 0, 0, 0, 16583, 16584, 7, 7, 0, 0, 16584, 16585, + 7, 2, 0, 0, 16585, 16586, 5, 95, 0, 0, 16586, 16587, 7, 10, 0, 0, 16587, + 16588, 7, 7, 0, 0, 16588, 16589, 7, 9, 0, 0, 16589, 16590, 7, 6, 0, 0, + 16590, 16591, 7, 25, 0, 0, 16591, 16592, 5, 95, 0, 0, 16592, 16593, 7, + 5, 0, 0, 16593, 16594, 7, 5, 0, 0, 16594, 2222, 1, 0, 0, 0, 16595, 16596, + 7, 7, 0, 0, 16596, 16597, 7, 2, 0, 0, 16597, 16598, 5, 95, 0, 0, 16598, + 16599, 7, 10, 0, 0, 16599, 16600, 7, 7, 0, 0, 16600, 16601, 7, 14, 0, 0, + 16601, 16602, 7, 6, 0, 0, 16602, 16603, 7, 14, 0, 0, 16603, 16604, 7, 2, + 0, 0, 16604, 16605, 7, 3, 0, 0, 16605, 16606, 7, 18, 0, 0, 16606, 2224, + 1, 0, 0, 0, 16607, 16608, 7, 7, 0, 0, 16608, 16609, 7, 2, 0, 0, 16609, + 16610, 5, 95, 0, 0, 16610, 16611, 7, 10, 0, 0, 16611, 16612, 7, 7, 0, 0, + 16612, 16613, 7, 14, 0, 0, 16613, 16614, 7, 6, 0, 0, 16614, 16615, 7, 14, + 0, 0, 16615, 16616, 7, 2, 0, 0, 16616, 16617, 7, 3, 0, 0, 16617, 16618, + 7, 18, 0, 0, 16618, 16619, 5, 95, 0, 0, 16619, 16620, 7, 15, 0, 0, 16620, + 16621, 7, 3, 0, 0, 16621, 16622, 7, 12, 0, 0, 16622, 16623, 7, 7, 0, 0, + 16623, 16624, 7, 10, 0, 0, 16624, 16625, 7, 7, 0, 0, 16625, 16626, 7, 17, + 0, 0, 16626, 2226, 1, 0, 0, 0, 16627, 16628, 7, 7, 0, 0, 16628, 16629, + 7, 2, 0, 0, 16629, 16630, 7, 21, 0, 0, 16630, 16631, 7, 6, 0, 0, 16631, + 16632, 7, 6, 0, 0, 16632, 16633, 7, 15, 0, 0, 16633, 2228, 1, 0, 0, 0, + 16634, 16635, 7, 7, 0, 0, 16635, 16636, 7, 2, 0, 0, 16636, 16637, 5, 95, + 0, 0, 16637, 16638, 7, 11, 0, 0, 16638, 16639, 7, 2, 0, 0, 16639, 16640, + 7, 0, 0, 0, 16640, 16641, 7, 9, 0, 0, 16641, 2230, 1, 0, 0, 0, 16642, 16643, + 7, 7, 0, 0, 16643, 16644, 7, 2, 0, 0, 16644, 16645, 7, 11, 0, 0, 16645, + 16646, 7, 2, 0, 0, 16646, 16647, 7, 8, 0, 0, 16647, 16648, 7, 0, 0, 0, + 16648, 16649, 7, 11, 0, 0, 16649, 2232, 1, 0, 0, 0, 16650, 16651, 7, 7, + 0, 0, 16651, 16652, 7, 2, 0, 0, 16652, 16653, 7, 11, 0, 0, 16653, 16654, + 7, 2, 0, 0, 16654, 16655, 7, 17, 0, 0, 16655, 2234, 1, 0, 0, 0, 16656, + 16657, 7, 7, 0, 0, 16657, 16658, 7, 2, 0, 0, 16658, 16659, 7, 11, 0, 0, + 16659, 16660, 7, 2, 0, 0, 16660, 16661, 7, 17, 0, 0, 16661, 16662, 7, 16, + 0, 0, 16662, 16663, 7, 10, 0, 0, 16663, 16664, 7, 11, 0, 0, 16664, 16665, + 7, 6, 0, 0, 16665, 2236, 1, 0, 0, 0, 16666, 16667, 7, 7, 0, 0, 16667, 16668, + 7, 2, 0, 0, 16668, 16669, 7, 11, 0, 0, 16669, 16670, 7, 2, 0, 0, 16670, + 16671, 7, 17, 0, 0, 16671, 16672, 7, 17, 0, 0, 16672, 16673, 7, 10, 0, + 0, 16673, 16674, 7, 7, 0, 0, 16674, 16675, 7, 17, 0, 0, 16675, 2238, 1, + 0, 0, 0, 16676, 16677, 7, 7, 0, 0, 16677, 16678, 7, 2, 0, 0, 16678, 16679, + 7, 14, 0, 0, 16679, 16680, 7, 0, 0, 0, 16680, 16681, 7, 15, 0, 0, 16681, + 16682, 7, 15, 0, 0, 16682, 16683, 7, 10, 0, 0, 16683, 16684, 7, 7, 0, 0, + 16684, 16685, 7, 17, 0, 0, 16685, 2240, 1, 0, 0, 0, 16686, 16687, 7, 7, + 0, 0, 16687, 16688, 7, 2, 0, 0, 16688, 16689, 7, 14, 0, 0, 16689, 16690, + 7, 0, 0, 0, 16690, 16691, 7, 25, 0, 0, 16691, 16692, 7, 13, 0, 0, 16692, + 16693, 7, 0, 0, 0, 16693, 16694, 7, 11, 0, 0, 16694, 16695, 7, 12, 0, 0, + 16695, 16696, 7, 6, 0, 0, 16696, 2242, 1, 0, 0, 0, 16697, 16698, 7, 7, + 0, 0, 16698, 16699, 7, 2, 0, 0, 16699, 16700, 5, 95, 0, 0, 16700, 16701, + 7, 14, 0, 0, 16701, 16702, 7, 6, 0, 0, 16702, 16703, 7, 3, 0, 0, 16703, + 16704, 7, 17, 0, 0, 16704, 16705, 7, 6, 0, 0, 16705, 2244, 1, 0, 0, 0, + 16706, 16707, 7, 7, 0, 0, 16707, 16708, 7, 2, 0, 0, 16708, 16709, 7, 14, + 0, 0, 16709, 16710, 7, 10, 0, 0, 16710, 16711, 7, 7, 0, 0, 16711, 16712, + 7, 10, 0, 0, 16712, 16713, 7, 14, 0, 0, 16713, 16714, 7, 10, 0, 0, 16714, + 16715, 7, 23, 0, 0, 16715, 16716, 7, 6, 0, 0, 16716, 2246, 1, 0, 0, 0, + 16717, 16718, 7, 7, 0, 0, 16718, 16719, 7, 2, 0, 0, 16719, 16720, 7, 14, + 0, 0, 16720, 16721, 7, 10, 0, 0, 16721, 16722, 7, 7, 0, 0, 16722, 16723, + 7, 13, 0, 0, 16723, 16724, 7, 0, 0, 0, 16724, 16725, 7, 11, 0, 0, 16725, + 16726, 7, 12, 0, 0, 16726, 16727, 7, 6, 0, 0, 16727, 2248, 1, 0, 0, 0, + 16728, 16729, 7, 7, 0, 0, 16729, 16730, 7, 2, 0, 0, 16730, 16731, 5, 95, + 0, 0, 16731, 16732, 7, 14, 0, 0, 16732, 16733, 7, 2, 0, 0, 16733, 16734, + 7, 9, 0, 0, 16734, 16735, 7, 6, 0, 0, 16735, 16736, 7, 11, 0, 0, 16736, + 16737, 5, 95, 0, 0, 16737, 16738, 7, 15, 0, 0, 16738, 16739, 7, 12, 0, + 0, 16739, 16740, 7, 5, 0, 0, 16740, 16741, 7, 19, 0, 0, 16741, 16742, 5, + 95, 0, 0, 16742, 16743, 7, 3, 0, 0, 16743, 16744, 7, 6, 0, 0, 16744, 16745, + 7, 16, 0, 0, 16745, 2250, 1, 0, 0, 0, 16746, 16747, 7, 7, 0, 0, 16747, + 16748, 7, 2, 0, 0, 16748, 16749, 5, 95, 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, 2252, 1, 0, 0, 0, 16760, 16761, 7, 7, 0, 0, + 16761, 16762, 7, 2, 0, 0, 16762, 16763, 7, 14, 0, 0, 16763, 16764, 7, 2, + 0, 0, 16764, 16765, 7, 7, 0, 0, 16765, 16766, 7, 10, 0, 0, 16766, 16767, + 7, 4, 0, 0, 16767, 16768, 7, 2, 0, 0, 16768, 16769, 7, 3, 0, 0, 16769, + 16770, 7, 10, 0, 0, 16770, 16771, 7, 7, 0, 0, 16771, 16772, 7, 17, 0, 0, + 16772, 2254, 1, 0, 0, 0, 16773, 16774, 7, 7, 0, 0, 16774, 16775, 7, 2, + 0, 0, 16775, 16776, 5, 95, 0, 0, 16776, 16777, 7, 14, 0, 0, 16777, 16778, + 7, 2, 0, 0, 16778, 16779, 7, 7, 0, 0, 16779, 16780, 7, 10, 0, 0, 16780, + 16781, 7, 4, 0, 0, 16781, 16782, 7, 2, 0, 0, 16782, 16783, 7, 3, 0, 0, + 16783, 2256, 1, 0, 0, 0, 16784, 16785, 7, 7, 0, 0, 16785, 16786, 7, 2, + 0, 0, 16786, 16787, 5, 95, 0, 0, 16787, 16788, 7, 14, 0, 0, 16788, 16789, + 7, 12, 0, 0, 16789, 16790, 7, 11, 0, 0, 16790, 16791, 7, 4, 0, 0, 16791, + 16792, 7, 10, 0, 0, 16792, 16793, 7, 14, 0, 0, 16793, 16794, 7, 13, 0, + 0, 16794, 16795, 5, 95, 0, 0, 16795, 16796, 7, 3, 0, 0, 16796, 16797, 7, + 6, 0, 0, 16797, 16798, 7, 22, 0, 0, 16798, 16799, 7, 3, 0, 0, 16799, 16800, + 7, 10, 0, 0, 16800, 16801, 7, 4, 0, 0, 16801, 16802, 7, 6, 0, 0, 16802, + 2258, 1, 0, 0, 0, 16803, 16804, 7, 7, 0, 0, 16804, 16805, 7, 2, 0, 0, 16805, + 16806, 5, 95, 0, 0, 16806, 16807, 7, 7, 0, 0, 16807, 16808, 7, 0, 0, 0, + 16808, 16809, 7, 4, 0, 0, 16809, 16810, 7, 10, 0, 0, 16810, 16811, 7, 13, + 0, 0, 16811, 16812, 7, 6, 0, 0, 16812, 16813, 5, 95, 0, 0, 16813, 16814, + 7, 16, 0, 0, 16814, 16815, 7, 12, 0, 0, 16815, 16816, 7, 11, 0, 0, 16816, + 16817, 7, 11, 0, 0, 16817, 16818, 5, 95, 0, 0, 16818, 16819, 7, 2, 0, 0, + 16819, 16820, 7, 12, 0, 0, 16820, 16821, 7, 4, 0, 0, 16821, 16822, 7, 6, + 0, 0, 16822, 16823, 7, 3, 0, 0, 16823, 16824, 5, 95, 0, 0, 16824, 16825, + 7, 20, 0, 0, 16825, 16826, 7, 2, 0, 0, 16826, 16827, 7, 10, 0, 0, 16827, + 16828, 7, 7, 0, 0, 16828, 2260, 1, 0, 0, 0, 16829, 16830, 7, 7, 0, 0, 16830, + 16831, 7, 2, 0, 0, 16831, 16832, 7, 7, 0, 0, 16832, 16833, 7, 1, 0, 0, + 16833, 16834, 7, 11, 0, 0, 16834, 16835, 7, 2, 0, 0, 16835, 16836, 7, 8, + 0, 0, 16836, 16837, 7, 21, 0, 0, 16837, 16838, 7, 10, 0, 0, 16838, 16839, + 7, 7, 0, 0, 16839, 16840, 7, 17, 0, 0, 16840, 2262, 1, 0, 0, 0, 16841, + 16842, 7, 7, 0, 0, 16842, 16843, 7, 2, 0, 0, 16843, 16844, 7, 7, 0, 0, + 16844, 16845, 7, 6, 0, 0, 16845, 16846, 7, 9, 0, 0, 16846, 16847, 7, 10, + 0, 0, 16847, 16848, 7, 4, 0, 0, 16848, 16849, 7, 10, 0, 0, 16849, 16850, + 7, 2, 0, 0, 16850, 16851, 7, 7, 0, 0, 16851, 16852, 7, 0, 0, 0, 16852, + 16853, 7, 1, 0, 0, 16853, 16854, 7, 11, 0, 0, 16854, 16855, 7, 6, 0, 0, + 16855, 2264, 1, 0, 0, 0, 16856, 16857, 7, 7, 0, 0, 16857, 16858, 7, 2, + 0, 0, 16858, 16859, 7, 7, 0, 0, 16859, 16860, 7, 6, 0, 0, 16860, 2266, + 1, 0, 0, 0, 16861, 16862, 7, 7, 0, 0, 16862, 16863, 7, 2, 0, 0, 16863, + 16864, 7, 7, 0, 0, 16864, 16865, 7, 12, 0, 0, 16865, 16866, 7, 11, 0, 0, + 16866, 16867, 7, 11, 0, 0, 16867, 16868, 7, 10, 0, 0, 16868, 16869, 7, + 16, 0, 0, 16869, 2268, 1, 0, 0, 0, 16870, 16871, 7, 7, 0, 0, 16871, 16872, + 7, 2, 0, 0, 16872, 16873, 5, 95, 0, 0, 16873, 16874, 7, 7, 0, 0, 16874, + 16875, 7, 11, 0, 0, 16875, 16876, 7, 20, 0, 0, 16876, 16877, 5, 95, 0, + 0, 16877, 16878, 7, 1, 0, 0, 16878, 16879, 7, 0, 0, 0, 16879, 16880, 7, + 4, 0, 0, 16880, 16881, 7, 8, 0, 0, 16881, 16882, 7, 19, 0, 0, 16882, 16883, + 7, 10, 0, 0, 16883, 16884, 7, 7, 0, 0, 16884, 16885, 7, 17, 0, 0, 16885, + 2270, 1, 0, 0, 0, 16886, 16887, 7, 7, 0, 0, 16887, 16888, 7, 2, 0, 0, 16888, + 16889, 5, 95, 0, 0, 16889, 16890, 7, 7, 0, 0, 16890, 16891, 7, 11, 0, 0, + 16891, 16892, 7, 20, 0, 0, 16892, 16893, 5, 95, 0, 0, 16893, 16894, 7, + 15, 0, 0, 16894, 16895, 7, 3, 0, 0, 16895, 16896, 7, 6, 0, 0, 16896, 16897, + 7, 16, 0, 0, 16897, 16898, 7, 6, 0, 0, 16898, 16899, 7, 4, 0, 0, 16899, + 16900, 7, 8, 0, 0, 16900, 16901, 7, 19, 0, 0, 16901, 2272, 1, 0, 0, 0, + 16902, 16903, 7, 7, 0, 0, 16903, 16904, 7, 2, 0, 0, 16904, 2274, 1, 0, + 0, 0, 16905, 16906, 7, 7, 0, 0, 16906, 16907, 7, 2, 0, 0, 16907, 16908, + 7, 7, 0, 0, 16908, 16909, 7, 5, 0, 0, 16909, 16910, 7, 8, 0, 0, 16910, + 16911, 7, 19, 0, 0, 16911, 16912, 7, 6, 0, 0, 16912, 16913, 7, 14, 0, 0, + 16913, 16914, 7, 0, 0, 0, 16914, 2276, 1, 0, 0, 0, 16915, 16916, 7, 7, + 0, 0, 16916, 16917, 7, 2, 0, 0, 16917, 16918, 5, 95, 0, 0, 16918, 16919, + 7, 2, 0, 0, 16919, 16920, 7, 1, 0, 0, 16920, 16921, 7, 20, 0, 0, 16921, + 16922, 7, 6, 0, 0, 16922, 16923, 7, 8, 0, 0, 16923, 16924, 7, 4, 0, 0, + 16924, 16925, 5, 95, 0, 0, 16925, 16926, 7, 11, 0, 0, 16926, 16927, 7, + 10, 0, 0, 16927, 16928, 7, 7, 0, 0, 16928, 16929, 7, 21, 0, 0, 16929, 2278, + 1, 0, 0, 0, 16930, 16931, 7, 7, 0, 0, 16931, 16932, 7, 2, 0, 0, 16932, + 16933, 7, 2, 0, 0, 16933, 16934, 7, 3, 0, 0, 16934, 16935, 7, 9, 0, 0, + 16935, 16936, 7, 6, 0, 0, 16936, 16937, 7, 3, 0, 0, 16937, 2280, 1, 0, + 0, 0, 16938, 16939, 7, 7, 0, 0, 16939, 16940, 7, 2, 0, 0, 16940, 16941, + 5, 95, 0, 0, 16941, 16942, 7, 2, 0, 0, 16942, 16943, 7, 3, 0, 0, 16943, + 16944, 7, 9, 0, 0, 16944, 16945, 7, 6, 0, 0, 16945, 16946, 7, 3, 0, 0, + 16946, 16947, 5, 95, 0, 0, 16947, 16948, 7, 3, 0, 0, 16948, 16949, 7, 2, + 0, 0, 16949, 16950, 7, 11, 0, 0, 16950, 16951, 7, 11, 0, 0, 16951, 16952, + 7, 12, 0, 0, 16952, 16953, 7, 15, 0, 0, 16953, 16954, 7, 5, 0, 0, 16954, + 2282, 1, 0, 0, 0, 16955, 16956, 7, 7, 0, 0, 16956, 16957, 7, 2, 0, 0, 16957, + 16958, 5, 95, 0, 0, 16958, 16959, 7, 2, 0, 0, 16959, 16960, 7, 12, 0, 0, + 16960, 16961, 7, 4, 0, 0, 16961, 16962, 7, 6, 0, 0, 16962, 16963, 7, 3, + 0, 0, 16963, 16964, 5, 95, 0, 0, 16964, 16965, 7, 20, 0, 0, 16965, 16966, + 7, 2, 0, 0, 16966, 16967, 7, 10, 0, 0, 16967, 16968, 7, 7, 0, 0, 16968, + 16969, 5, 95, 0, 0, 16969, 16970, 7, 4, 0, 0, 16970, 16971, 7, 2, 0, 0, + 16971, 16972, 5, 95, 0, 0, 16972, 16973, 7, 0, 0, 0, 16973, 16974, 7, 7, + 0, 0, 16974, 16975, 7, 4, 0, 0, 16975, 16976, 7, 10, 0, 0, 16976, 2284, + 1, 0, 0, 0, 16977, 16978, 7, 7, 0, 0, 16978, 16979, 7, 2, 0, 0, 16979, + 16980, 5, 95, 0, 0, 16980, 16981, 7, 2, 0, 0, 16981, 16982, 7, 12, 0, 0, + 16982, 16983, 7, 4, 0, 0, 16983, 16984, 7, 6, 0, 0, 16984, 16985, 7, 3, + 0, 0, 16985, 16986, 5, 95, 0, 0, 16986, 16987, 7, 20, 0, 0, 16987, 16988, + 7, 2, 0, 0, 16988, 16989, 7, 10, 0, 0, 16989, 16990, 7, 7, 0, 0, 16990, + 16991, 5, 95, 0, 0, 16991, 16992, 7, 4, 0, 0, 16992, 16993, 7, 2, 0, 0, + 16993, 16994, 5, 95, 0, 0, 16994, 16995, 7, 10, 0, 0, 16995, 16996, 7, + 7, 0, 0, 16996, 16997, 7, 7, 0, 0, 16997, 16998, 7, 6, 0, 0, 16998, 16999, + 7, 3, 0, 0, 16999, 2286, 1, 0, 0, 0, 17000, 17001, 7, 7, 0, 0, 17001, 17002, + 7, 2, 0, 0, 17002, 17003, 7, 2, 0, 0, 17003, 17004, 7, 13, 0, 0, 17004, + 17005, 7, 6, 0, 0, 17005, 17006, 7, 3, 0, 0, 17006, 17007, 7, 3, 0, 0, + 17007, 17008, 7, 10, 0, 0, 17008, 17009, 7, 9, 0, 0, 17009, 17010, 7, 6, + 0, 0, 17010, 2288, 1, 0, 0, 0, 17011, 17012, 7, 7, 0, 0, 17012, 17013, + 7, 2, 0, 0, 17013, 17014, 5, 95, 0, 0, 17014, 17015, 7, 15, 0, 0, 17015, + 17016, 7, 0, 0, 0, 17016, 17017, 7, 3, 0, 0, 17017, 17018, 7, 0, 0, 0, + 17018, 17019, 7, 11, 0, 0, 17019, 17020, 7, 11, 0, 0, 17020, 17021, 7, + 6, 0, 0, 17021, 17022, 7, 11, 0, 0, 17022, 17023, 5, 95, 0, 0, 17023, 17024, + 7, 10, 0, 0, 17024, 17025, 7, 7, 0, 0, 17025, 17026, 7, 9, 0, 0, 17026, + 17027, 7, 6, 0, 0, 17027, 17028, 7, 25, 0, 0, 17028, 2290, 1, 0, 0, 0, + 17029, 17030, 7, 7, 0, 0, 17030, 17031, 7, 2, 0, 0, 17031, 17032, 7, 15, + 0, 0, 17032, 17033, 7, 0, 0, 0, 17033, 17034, 7, 3, 0, 0, 17034, 17035, + 7, 0, 0, 0, 17035, 17036, 7, 11, 0, 0, 17036, 17037, 7, 11, 0, 0, 17037, + 17038, 7, 6, 0, 0, 17038, 17039, 7, 11, 0, 0, 17039, 17040, 5, 95, 0, 0, + 17040, 17041, 7, 10, 0, 0, 17041, 17042, 7, 7, 0, 0, 17042, 17043, 7, 9, + 0, 0, 17043, 17044, 7, 6, 0, 0, 17044, 17045, 7, 25, 0, 0, 17045, 2292, + 1, 0, 0, 0, 17046, 17047, 7, 7, 0, 0, 17047, 17048, 7, 2, 0, 0, 17048, + 17049, 5, 95, 0, 0, 17049, 17050, 7, 15, 0, 0, 17050, 17051, 7, 0, 0, 0, + 17051, 17052, 7, 3, 0, 0, 17052, 17053, 7, 0, 0, 0, 17053, 17054, 7, 11, + 0, 0, 17054, 17055, 7, 11, 0, 0, 17055, 17056, 7, 6, 0, 0, 17056, 17057, + 7, 11, 0, 0, 17057, 2294, 1, 0, 0, 0, 17058, 17059, 7, 7, 0, 0, 17059, + 17060, 7, 2, 0, 0, 17060, 17061, 7, 15, 0, 0, 17061, 17062, 7, 0, 0, 0, + 17062, 17063, 7, 3, 0, 0, 17063, 17064, 7, 0, 0, 0, 17064, 17065, 7, 11, + 0, 0, 17065, 17066, 7, 11, 0, 0, 17066, 17067, 7, 6, 0, 0, 17067, 17068, + 7, 11, 0, 0, 17068, 2296, 1, 0, 0, 0, 17069, 17070, 7, 7, 0, 0, 17070, + 17071, 7, 2, 0, 0, 17071, 17072, 5, 95, 0, 0, 17072, 17073, 7, 15, 0, 0, + 17073, 17074, 7, 0, 0, 0, 17074, 17075, 7, 3, 0, 0, 17075, 17076, 7, 4, + 0, 0, 17076, 17077, 7, 10, 0, 0, 17077, 17078, 7, 0, 0, 0, 17078, 17079, + 7, 11, 0, 0, 17079, 17080, 5, 95, 0, 0, 17080, 17081, 7, 8, 0, 0, 17081, + 17082, 7, 2, 0, 0, 17082, 17083, 7, 14, 0, 0, 17083, 17084, 7, 14, 0, 0, + 17084, 17085, 7, 10, 0, 0, 17085, 17086, 7, 4, 0, 0, 17086, 2298, 1, 0, + 0, 0, 17087, 17088, 7, 7, 0, 0, 17088, 17089, 7, 2, 0, 0, 17089, 17090, + 5, 95, 0, 0, 17090, 17091, 7, 15, 0, 0, 17091, 17092, 7, 0, 0, 0, 17092, + 17093, 7, 3, 0, 0, 17093, 17094, 7, 4, 0, 0, 17094, 17095, 7, 10, 0, 0, + 17095, 17096, 7, 0, 0, 0, 17096, 17097, 7, 11, 0, 0, 17097, 17098, 5, 95, + 0, 0, 17098, 17099, 7, 20, 0, 0, 17099, 17100, 7, 2, 0, 0, 17100, 17101, + 7, 10, 0, 0, 17101, 17102, 7, 7, 0, 0, 17102, 2300, 1, 0, 0, 0, 17103, + 17104, 7, 7, 0, 0, 17104, 17105, 7, 2, 0, 0, 17105, 17106, 5, 95, 0, 0, + 17106, 17107, 7, 15, 0, 0, 17107, 17108, 7, 0, 0, 0, 17108, 17109, 7, 3, + 0, 0, 17109, 17110, 7, 4, 0, 0, 17110, 17111, 7, 10, 0, 0, 17111, 17112, + 7, 0, 0, 0, 17112, 17113, 7, 11, 0, 0, 17113, 17114, 5, 95, 0, 0, 17114, + 17115, 7, 3, 0, 0, 17115, 17116, 7, 2, 0, 0, 17116, 17117, 7, 11, 0, 0, + 17117, 17118, 7, 11, 0, 0, 17118, 17119, 7, 12, 0, 0, 17119, 17120, 7, + 15, 0, 0, 17120, 17121, 5, 95, 0, 0, 17121, 17122, 7, 15, 0, 0, 17122, + 17123, 7, 12, 0, 0, 17123, 17124, 7, 5, 0, 0, 17124, 17125, 7, 19, 0, 0, + 17125, 17126, 7, 9, 0, 0, 17126, 17127, 7, 2, 0, 0, 17127, 17128, 7, 22, + 0, 0, 17128, 17129, 7, 7, 0, 0, 17129, 2302, 1, 0, 0, 0, 17130, 17131, + 7, 7, 0, 0, 17131, 17132, 7, 2, 0, 0, 17132, 17133, 7, 15, 0, 0, 17133, + 17134, 7, 0, 0, 0, 17134, 17135, 7, 3, 0, 0, 17135, 17136, 7, 4, 0, 0, + 17136, 17137, 7, 10, 0, 0, 17137, 17138, 7, 4, 0, 0, 17138, 17139, 7, 10, + 0, 0, 17139, 17140, 7, 2, 0, 0, 17140, 17141, 7, 7, 0, 0, 17141, 2304, + 1, 0, 0, 0, 17142, 17143, 7, 7, 0, 0, 17143, 17144, 7, 2, 0, 0, 17144, + 17145, 5, 95, 0, 0, 17145, 17146, 7, 15, 0, 0, 17146, 17147, 7, 11, 0, + 0, 17147, 17148, 7, 0, 0, 0, 17148, 17149, 7, 8, 0, 0, 17149, 17150, 7, + 6, 0, 0, 17150, 17151, 5, 95, 0, 0, 17151, 17152, 7, 9, 0, 0, 17152, 17153, + 7, 10, 0, 0, 17153, 17154, 7, 5, 0, 0, 17154, 17155, 7, 4, 0, 0, 17155, + 17156, 7, 10, 0, 0, 17156, 17157, 7, 7, 0, 0, 17157, 17158, 7, 8, 0, 0, + 17158, 17159, 7, 4, 0, 0, 17159, 2306, 1, 0, 0, 0, 17160, 17161, 7, 7, + 0, 0, 17161, 17162, 7, 2, 0, 0, 17162, 17163, 5, 95, 0, 0, 17163, 17164, + 7, 15, 0, 0, 17164, 17165, 7, 11, 0, 0, 17165, 17166, 7, 0, 0, 0, 17166, + 17167, 7, 8, 0, 0, 17167, 17168, 7, 6, 0, 0, 17168, 17169, 5, 95, 0, 0, + 17169, 17170, 7, 17, 0, 0, 17170, 17171, 7, 3, 0, 0, 17171, 17172, 7, 2, + 0, 0, 17172, 17173, 7, 12, 0, 0, 17173, 17174, 7, 15, 0, 0, 17174, 17175, + 5, 95, 0, 0, 17175, 17176, 7, 1, 0, 0, 17176, 17177, 7, 18, 0, 0, 17177, + 2308, 1, 0, 0, 0, 17178, 17179, 7, 7, 0, 0, 17179, 17180, 7, 2, 0, 0, 17180, + 17181, 5, 95, 0, 0, 17181, 17182, 7, 15, 0, 0, 17182, 17183, 7, 24, 0, + 0, 17183, 17184, 5, 95, 0, 0, 17184, 17185, 7, 8, 0, 0, 17185, 17186, 7, + 2, 0, 0, 17186, 17187, 7, 7, 0, 0, 17187, 17188, 7, 8, 0, 0, 17188, 17189, + 7, 12, 0, 0, 17189, 17190, 7, 3, 0, 0, 17190, 17191, 7, 3, 0, 0, 17191, + 17192, 7, 6, 0, 0, 17192, 17193, 7, 7, 0, 0, 17193, 17194, 7, 4, 0, 0, + 17194, 17195, 5, 95, 0, 0, 17195, 17196, 7, 12, 0, 0, 17196, 17197, 7, + 7, 0, 0, 17197, 17198, 7, 10, 0, 0, 17198, 17199, 7, 2, 0, 0, 17199, 17200, + 7, 7, 0, 0, 17200, 2310, 1, 0, 0, 0, 17201, 17202, 7, 7, 0, 0, 17202, 17203, + 7, 2, 0, 0, 17203, 17204, 5, 95, 0, 0, 17204, 17205, 7, 15, 0, 0, 17205, + 17206, 7, 24, 0, 0, 17206, 17207, 5, 95, 0, 0, 17207, 17208, 7, 14, 0, + 0, 17208, 17209, 7, 0, 0, 0, 17209, 17210, 7, 15, 0, 0, 17210, 2312, 1, + 0, 0, 0, 17211, 17212, 7, 7, 0, 0, 17212, 17213, 7, 2, 0, 0, 17213, 17214, + 7, 15, 0, 0, 17214, 17215, 7, 3, 0, 0, 17215, 17216, 7, 2, 0, 0, 17216, + 17217, 7, 14, 0, 0, 17217, 17218, 7, 15, 0, 0, 17218, 17219, 7, 4, 0, 0, + 17219, 2314, 1, 0, 0, 0, 17220, 17221, 7, 7, 0, 0, 17221, 17222, 7, 2, + 0, 0, 17222, 17223, 5, 95, 0, 0, 17223, 17224, 7, 15, 0, 0, 17224, 17225, + 7, 24, 0, 0, 17225, 17226, 5, 95, 0, 0, 17226, 17227, 7, 3, 0, 0, 17227, + 17228, 7, 6, 0, 0, 17228, 17229, 7, 15, 0, 0, 17229, 17230, 7, 11, 0, 0, + 17230, 17231, 7, 10, 0, 0, 17231, 17232, 7, 8, 0, 0, 17232, 17233, 7, 0, + 0, 0, 17233, 17234, 7, 4, 0, 0, 17234, 17235, 7, 6, 0, 0, 17235, 2316, + 1, 0, 0, 0, 17236, 17237, 7, 7, 0, 0, 17237, 17238, 7, 2, 0, 0, 17238, + 17239, 5, 95, 0, 0, 17239, 17240, 7, 15, 0, 0, 17240, 17241, 7, 24, 0, + 0, 17241, 17242, 5, 95, 0, 0, 17242, 17243, 7, 5, 0, 0, 17243, 17244, 7, + 21, 0, 0, 17244, 17245, 7, 6, 0, 0, 17245, 17246, 7, 22, 0, 0, 17246, 2318, + 1, 0, 0, 0, 17247, 17248, 7, 7, 0, 0, 17248, 17249, 7, 2, 0, 0, 17249, + 17250, 5, 95, 0, 0, 17250, 17251, 7, 15, 0, 0, 17251, 17252, 7, 3, 0, 0, + 17252, 17253, 7, 12, 0, 0, 17253, 17254, 7, 7, 0, 0, 17254, 17255, 7, 6, + 0, 0, 17255, 17256, 5, 95, 0, 0, 17256, 17257, 7, 17, 0, 0, 17257, 17258, + 7, 5, 0, 0, 17258, 17259, 7, 6, 0, 0, 17259, 17260, 7, 4, 0, 0, 17260, + 17261, 7, 5, 0, 0, 17261, 2320, 1, 0, 0, 0, 17262, 17263, 7, 7, 0, 0, 17263, + 17264, 7, 2, 0, 0, 17264, 17265, 5, 95, 0, 0, 17265, 17266, 7, 15, 0, 0, + 17266, 17267, 7, 12, 0, 0, 17267, 17268, 7, 11, 0, 0, 17268, 17269, 7, + 11, 0, 0, 17269, 17270, 5, 95, 0, 0, 17270, 17271, 7, 15, 0, 0, 17271, + 17272, 7, 3, 0, 0, 17272, 17273, 7, 6, 0, 0, 17273, 17274, 7, 9, 0, 0, + 17274, 2322, 1, 0, 0, 0, 17275, 17276, 7, 7, 0, 0, 17276, 17277, 7, 2, + 0, 0, 17277, 17278, 5, 95, 0, 0, 17278, 17279, 7, 15, 0, 0, 17279, 17280, + 7, 12, 0, 0, 17280, 17281, 7, 5, 0, 0, 17281, 17282, 7, 19, 0, 0, 17282, + 17283, 5, 95, 0, 0, 17283, 17284, 7, 15, 0, 0, 17284, 17285, 7, 3, 0, 0, + 17285, 17286, 7, 6, 0, 0, 17286, 17287, 7, 9, 0, 0, 17287, 2324, 1, 0, + 0, 0, 17288, 17289, 7, 7, 0, 0, 17289, 17290, 7, 2, 0, 0, 17290, 17291, + 5, 95, 0, 0, 17291, 17292, 7, 15, 0, 0, 17292, 17293, 7, 12, 0, 0, 17293, + 17294, 7, 5, 0, 0, 17294, 17295, 7, 19, 0, 0, 17295, 17296, 5, 95, 0, 0, + 17296, 17297, 7, 5, 0, 0, 17297, 17298, 7, 12, 0, 0, 17298, 17299, 7, 1, + 0, 0, 17299, 17300, 7, 24, 0, 0, 17300, 2326, 1, 0, 0, 0, 17301, 17302, + 7, 7, 0, 0, 17302, 17303, 7, 2, 0, 0, 17303, 17304, 5, 95, 0, 0, 17304, + 17305, 7, 15, 0, 0, 17305, 17306, 7, 25, 0, 0, 17306, 17307, 5, 95, 0, + 0, 17307, 17308, 7, 16, 0, 0, 17308, 17309, 7, 0, 0, 0, 17309, 17310, 7, + 12, 0, 0, 17310, 17311, 7, 11, 0, 0, 17311, 17312, 7, 4, 0, 0, 17312, 17313, + 5, 95, 0, 0, 17313, 17314, 7, 4, 0, 0, 17314, 17315, 7, 2, 0, 0, 17315, + 17316, 7, 11, 0, 0, 17316, 17317, 7, 6, 0, 0, 17317, 17318, 7, 3, 0, 0, + 17318, 17319, 7, 0, 0, 0, 17319, 17320, 7, 7, 0, 0, 17320, 17321, 7, 8, + 0, 0, 17321, 17322, 7, 6, 0, 0, 17322, 2328, 1, 0, 0, 0, 17323, 17324, + 7, 7, 0, 0, 17324, 17325, 7, 2, 0, 0, 17325, 17326, 5, 95, 0, 0, 17326, + 17327, 7, 15, 0, 0, 17327, 17328, 7, 25, 0, 0, 17328, 17329, 5, 95, 0, + 0, 17329, 17330, 7, 20, 0, 0, 17330, 17331, 7, 2, 0, 0, 17331, 17332, 7, + 10, 0, 0, 17332, 17333, 7, 7, 0, 0, 17333, 17334, 5, 95, 0, 0, 17334, 17335, + 7, 16, 0, 0, 17335, 17336, 7, 10, 0, 0, 17336, 17337, 7, 11, 0, 0, 17337, + 17338, 7, 4, 0, 0, 17338, 17339, 7, 6, 0, 0, 17339, 17340, 7, 3, 0, 0, + 17340, 2330, 1, 0, 0, 0, 17341, 17342, 7, 7, 0, 0, 17342, 17343, 7, 2, + 0, 0, 17343, 17344, 5, 95, 0, 0, 17344, 17345, 7, 24, 0, 0, 17345, 17346, + 7, 21, 0, 0, 17346, 17347, 7, 7, 0, 0, 17347, 17348, 5, 95, 0, 0, 17348, + 17349, 7, 1, 0, 0, 17349, 17350, 7, 12, 0, 0, 17350, 17351, 7, 16, 0, 0, + 17351, 17352, 7, 16, 0, 0, 17352, 2332, 1, 0, 0, 0, 17353, 17354, 7, 7, + 0, 0, 17354, 17355, 7, 2, 0, 0, 17355, 17356, 5, 95, 0, 0, 17356, 17357, + 7, 24, 0, 0, 17357, 17358, 7, 12, 0, 0, 17358, 17359, 7, 6, 0, 0, 17359, + 17360, 7, 3, 0, 0, 17360, 17361, 7, 18, 0, 0, 17361, 17362, 5, 95, 0, 0, + 17362, 17363, 7, 4, 0, 0, 17363, 17364, 7, 3, 0, 0, 17364, 17365, 7, 0, + 0, 0, 17365, 17366, 7, 7, 0, 0, 17366, 17367, 7, 5, 0, 0, 17367, 17368, + 7, 16, 0, 0, 17368, 17369, 7, 2, 0, 0, 17369, 17370, 7, 3, 0, 0, 17370, + 17371, 7, 14, 0, 0, 17371, 17372, 7, 0, 0, 0, 17372, 17373, 7, 4, 0, 0, + 17373, 17374, 7, 10, 0, 0, 17374, 17375, 7, 2, 0, 0, 17375, 17376, 7, 7, + 0, 0, 17376, 2334, 1, 0, 0, 0, 17377, 17378, 7, 7, 0, 0, 17378, 17379, + 7, 2, 0, 0, 17379, 17380, 5, 95, 0, 0, 17380, 17381, 7, 3, 0, 0, 17381, + 17382, 7, 6, 0, 0, 17382, 17383, 7, 16, 0, 0, 17383, 17384, 5, 95, 0, 0, + 17384, 17385, 7, 8, 0, 0, 17385, 17386, 7, 0, 0, 0, 17386, 17387, 7, 5, + 0, 0, 17387, 17388, 7, 8, 0, 0, 17388, 17389, 7, 0, 0, 0, 17389, 17390, + 7, 9, 0, 0, 17390, 17391, 7, 6, 0, 0, 17391, 2336, 1, 0, 0, 0, 17392, 17393, + 7, 7, 0, 0, 17393, 17394, 7, 2, 0, 0, 17394, 17395, 7, 3, 0, 0, 17395, + 17396, 7, 6, 0, 0, 17396, 17397, 7, 11, 0, 0, 17397, 17398, 7, 2, 0, 0, + 17398, 17399, 7, 8, 0, 0, 17399, 17400, 7, 0, 0, 0, 17400, 17401, 7, 4, + 0, 0, 17401, 17402, 7, 6, 0, 0, 17402, 2338, 1, 0, 0, 0, 17403, 17404, + 7, 7, 0, 0, 17404, 17405, 7, 2, 0, 0, 17405, 17406, 7, 3, 0, 0, 17406, + 17407, 7, 6, 0, 0, 17407, 17408, 7, 11, 0, 0, 17408, 17409, 7, 18, 0, 0, + 17409, 2340, 1, 0, 0, 0, 17410, 17411, 7, 7, 0, 0, 17411, 17412, 7, 2, + 0, 0, 17412, 17413, 7, 3, 0, 0, 17413, 17414, 7, 6, 0, 0, 17414, 17415, + 7, 15, 0, 0, 17415, 17416, 7, 0, 0, 0, 17416, 17417, 7, 10, 0, 0, 17417, + 17418, 7, 3, 0, 0, 17418, 2342, 1, 0, 0, 0, 17419, 17420, 7, 7, 0, 0, 17420, + 17421, 7, 2, 0, 0, 17421, 17422, 7, 3, 0, 0, 17422, 17423, 7, 6, 0, 0, + 17423, 17424, 7, 15, 0, 0, 17424, 17425, 7, 11, 0, 0, 17425, 17426, 7, + 0, 0, 0, 17426, 17427, 7, 18, 0, 0, 17427, 2344, 1, 0, 0, 0, 17428, 17429, + 7, 7, 0, 0, 17429, 17430, 7, 2, 0, 0, 17430, 17431, 7, 3, 0, 0, 17431, + 17432, 7, 6, 0, 0, 17432, 17433, 7, 5, 0, 0, 17433, 17434, 7, 6, 0, 0, + 17434, 17435, 7, 4, 0, 0, 17435, 17436, 7, 11, 0, 0, 17436, 17437, 7, 2, + 0, 0, 17437, 17438, 7, 17, 0, 0, 17438, 17439, 7, 5, 0, 0, 17439, 2346, + 1, 0, 0, 0, 17440, 17441, 7, 7, 0, 0, 17441, 17442, 7, 2, 0, 0, 17442, + 17443, 5, 95, 0, 0, 17443, 17444, 7, 3, 0, 0, 17444, 17445, 7, 6, 0, 0, + 17445, 17446, 7, 5, 0, 0, 17446, 17447, 7, 12, 0, 0, 17447, 17448, 7, 11, + 0, 0, 17448, 17449, 7, 4, 0, 0, 17449, 17450, 5, 95, 0, 0, 17450, 17451, + 7, 8, 0, 0, 17451, 17452, 7, 0, 0, 0, 17452, 17453, 7, 8, 0, 0, 17453, + 17454, 7, 19, 0, 0, 17454, 17455, 7, 6, 0, 0, 17455, 2348, 1, 0, 0, 0, + 17456, 17457, 7, 7, 0, 0, 17457, 17458, 7, 2, 0, 0, 17458, 17459, 7, 3, + 0, 0, 17459, 17460, 7, 6, 0, 0, 17460, 17461, 7, 13, 0, 0, 17461, 17462, + 7, 6, 0, 0, 17462, 17463, 7, 3, 0, 0, 17463, 17464, 7, 5, 0, 0, 17464, + 17465, 7, 6, 0, 0, 17465, 2350, 1, 0, 0, 0, 17466, 17467, 7, 7, 0, 0, 17467, + 17468, 7, 2, 0, 0, 17468, 17469, 5, 95, 0, 0, 17469, 17470, 7, 3, 0, 0, + 17470, 17471, 7, 6, 0, 0, 17471, 17472, 7, 22, 0, 0, 17472, 17473, 7, 3, + 0, 0, 17473, 17474, 7, 10, 0, 0, 17474, 17475, 7, 4, 0, 0, 17475, 17476, + 7, 6, 0, 0, 17476, 2352, 1, 0, 0, 0, 17477, 17478, 7, 7, 0, 0, 17478, 17479, + 7, 2, 0, 0, 17479, 17480, 7, 3, 0, 0, 17480, 17481, 7, 6, 0, 0, 17481, + 17482, 7, 22, 0, 0, 17482, 17483, 7, 3, 0, 0, 17483, 17484, 7, 10, 0, 0, + 17484, 17485, 7, 4, 0, 0, 17485, 17486, 7, 6, 0, 0, 17486, 2354, 1, 0, + 0, 0, 17487, 17488, 7, 7, 0, 0, 17488, 17489, 7, 2, 0, 0, 17489, 17490, + 7, 3, 0, 0, 17490, 17491, 7, 14, 0, 0, 17491, 17492, 7, 0, 0, 0, 17492, + 17493, 7, 11, 0, 0, 17493, 2356, 1, 0, 0, 0, 17494, 17495, 7, 7, 0, 0, + 17495, 17496, 7, 2, 0, 0, 17496, 17497, 5, 95, 0, 0, 17497, 17498, 7, 3, + 0, 0, 17498, 17499, 7, 2, 0, 0, 17499, 17500, 7, 2, 0, 0, 17500, 17501, + 7, 4, 0, 0, 17501, 17502, 5, 95, 0, 0, 17502, 17503, 7, 5, 0, 0, 17503, + 17504, 7, 22, 0, 0, 17504, 17505, 5, 95, 0, 0, 17505, 17506, 7, 16, 0, + 0, 17506, 17507, 7, 2, 0, 0, 17507, 17508, 7, 3, 0, 0, 17508, 17509, 5, + 95, 0, 0, 17509, 17510, 7, 11, 0, 0, 17510, 17511, 7, 2, 0, 0, 17511, 17512, + 7, 8, 0, 0, 17512, 17513, 7, 0, 0, 0, 17513, 17514, 7, 11, 0, 0, 17514, + 2358, 1, 0, 0, 0, 17515, 17516, 7, 7, 0, 0, 17516, 17517, 7, 2, 0, 0, 17517, + 17518, 7, 3, 0, 0, 17518, 17519, 7, 2, 0, 0, 17519, 17520, 7, 22, 0, 0, + 17520, 17521, 7, 9, 0, 0, 17521, 17522, 7, 6, 0, 0, 17522, 17523, 7, 15, + 0, 0, 17523, 17524, 7, 6, 0, 0, 17524, 17525, 7, 7, 0, 0, 17525, 17526, + 7, 9, 0, 0, 17526, 17527, 7, 6, 0, 0, 17527, 17528, 7, 7, 0, 0, 17528, + 17529, 7, 8, 0, 0, 17529, 17530, 7, 10, 0, 0, 17530, 17531, 7, 6, 0, 0, + 17531, 17532, 7, 5, 0, 0, 17532, 2360, 1, 0, 0, 0, 17533, 17534, 7, 7, + 0, 0, 17534, 17535, 7, 2, 0, 0, 17535, 17536, 7, 5, 0, 0, 17536, 17537, + 7, 8, 0, 0, 17537, 17538, 7, 0, 0, 0, 17538, 17539, 7, 11, 0, 0, 17539, + 17540, 7, 6, 0, 0, 17540, 2362, 1, 0, 0, 0, 17541, 17542, 7, 7, 0, 0, 17542, + 17543, 7, 2, 0, 0, 17543, 17544, 7, 5, 0, 0, 17544, 17545, 7, 8, 0, 0, + 17545, 17546, 7, 19, 0, 0, 17546, 17547, 7, 6, 0, 0, 17547, 17548, 7, 14, + 0, 0, 17548, 17549, 7, 0, 0, 0, 17549, 17550, 7, 8, 0, 0, 17550, 17551, + 7, 19, 0, 0, 17551, 17552, 7, 6, 0, 0, 17552, 17553, 7, 8, 0, 0, 17553, + 17554, 7, 21, 0, 0, 17554, 2364, 1, 0, 0, 0, 17555, 17556, 7, 7, 0, 0, + 17556, 17557, 7, 2, 0, 0, 17557, 17558, 7, 5, 0, 0, 17558, 17559, 7, 6, + 0, 0, 17559, 17560, 7, 17, 0, 0, 17560, 17561, 7, 14, 0, 0, 17561, 17562, + 7, 6, 0, 0, 17562, 17563, 7, 7, 0, 0, 17563, 17564, 7, 4, 0, 0, 17564, + 2366, 1, 0, 0, 0, 17565, 17566, 7, 7, 0, 0, 17566, 17567, 7, 2, 0, 0, 17567, + 17568, 5, 95, 0, 0, 17568, 17569, 7, 5, 0, 0, 17569, 17570, 7, 6, 0, 0, + 17570, 17571, 7, 14, 0, 0, 17571, 17572, 7, 10, 0, 0, 17572, 17573, 7, + 20, 0, 0, 17573, 17574, 7, 2, 0, 0, 17574, 17575, 7, 10, 0, 0, 17575, 17576, + 7, 7, 0, 0, 17576, 2368, 1, 0, 0, 0, 17577, 17578, 7, 7, 0, 0, 17578, 17579, + 7, 2, 0, 0, 17579, 17580, 5, 95, 0, 0, 17580, 17581, 7, 5, 0, 0, 17581, + 17582, 7, 6, 0, 0, 17582, 17583, 7, 14, 0, 0, 17583, 17584, 7, 10, 0, 0, + 17584, 17585, 5, 95, 0, 0, 17585, 17586, 7, 4, 0, 0, 17586, 17587, 7, 2, + 0, 0, 17587, 17588, 5, 95, 0, 0, 17588, 17589, 7, 10, 0, 0, 17589, 17590, + 7, 7, 0, 0, 17590, 17591, 7, 7, 0, 0, 17591, 17592, 7, 6, 0, 0, 17592, + 17593, 7, 3, 0, 0, 17593, 2370, 1, 0, 0, 0, 17594, 17595, 7, 7, 0, 0, 17595, + 17596, 7, 2, 0, 0, 17596, 17597, 5, 95, 0, 0, 17597, 17598, 7, 5, 0, 0, + 17598, 17599, 7, 6, 0, 0, 17599, 17600, 7, 4, 0, 0, 17600, 17601, 5, 95, + 0, 0, 17601, 17602, 7, 4, 0, 0, 17602, 17603, 7, 2, 0, 0, 17603, 17604, + 5, 95, 0, 0, 17604, 17605, 7, 20, 0, 0, 17605, 17606, 7, 2, 0, 0, 17606, + 17607, 7, 10, 0, 0, 17607, 17608, 7, 7, 0, 0, 17608, 2372, 1, 0, 0, 0, + 17609, 17610, 7, 7, 0, 0, 17610, 17611, 7, 2, 0, 0, 17611, 17612, 7, 5, + 0, 0, 17612, 17613, 7, 19, 0, 0, 17613, 17614, 7, 0, 0, 0, 17614, 17615, + 7, 3, 0, 0, 17615, 17616, 7, 9, 0, 0, 17616, 2374, 1, 0, 0, 0, 17617, 17618, + 7, 7, 0, 0, 17618, 17619, 7, 2, 0, 0, 17619, 17620, 7, 5, 0, 0, 17620, + 17621, 7, 2, 0, 0, 17621, 17622, 7, 3, 0, 0, 17622, 17623, 7, 4, 0, 0, + 17623, 2376, 1, 0, 0, 0, 17624, 17625, 7, 7, 0, 0, 17625, 17626, 7, 2, + 0, 0, 17626, 17627, 5, 95, 0, 0, 17627, 17628, 7, 5, 0, 0, 17628, 17629, + 7, 24, 0, 0, 17629, 17630, 7, 11, 0, 0, 17630, 17631, 5, 95, 0, 0, 17631, + 17632, 7, 4, 0, 0, 17632, 17633, 7, 3, 0, 0, 17633, 17634, 7, 0, 0, 0, + 17634, 17635, 7, 7, 0, 0, 17635, 17636, 7, 5, 0, 0, 17636, 17637, 7, 11, + 0, 0, 17637, 17638, 7, 0, 0, 0, 17638, 17639, 7, 4, 0, 0, 17639, 17640, + 7, 10, 0, 0, 17640, 17641, 7, 2, 0, 0, 17641, 17642, 7, 7, 0, 0, 17642, + 2378, 1, 0, 0, 0, 17643, 17644, 7, 7, 0, 0, 17644, 17645, 7, 2, 0, 0, 17645, + 17646, 5, 95, 0, 0, 17646, 17647, 7, 5, 0, 0, 17647, 17648, 7, 24, 0, 0, + 17648, 17649, 7, 11, 0, 0, 17649, 17650, 5, 95, 0, 0, 17650, 17651, 7, + 4, 0, 0, 17651, 17652, 7, 12, 0, 0, 17652, 17653, 7, 7, 0, 0, 17653, 17654, + 7, 6, 0, 0, 17654, 2380, 1, 0, 0, 0, 17655, 17656, 7, 7, 0, 0, 17656, 17657, + 7, 2, 0, 0, 17657, 17658, 5, 95, 0, 0, 17658, 17659, 7, 5, 0, 0, 17659, + 17660, 7, 4, 0, 0, 17660, 17661, 7, 0, 0, 0, 17661, 17662, 7, 3, 0, 0, + 17662, 17663, 5, 95, 0, 0, 17663, 17664, 7, 4, 0, 0, 17664, 17665, 7, 3, + 0, 0, 17665, 17666, 7, 0, 0, 0, 17666, 17667, 7, 7, 0, 0, 17667, 17668, + 7, 5, 0, 0, 17668, 17669, 7, 16, 0, 0, 17669, 17670, 7, 2, 0, 0, 17670, + 17671, 7, 3, 0, 0, 17671, 17672, 7, 14, 0, 0, 17672, 17673, 7, 0, 0, 0, + 17673, 17674, 7, 4, 0, 0, 17674, 17675, 7, 10, 0, 0, 17675, 17676, 7, 2, + 0, 0, 17676, 17677, 7, 7, 0, 0, 17677, 2382, 1, 0, 0, 0, 17678, 17679, + 7, 7, 0, 0, 17679, 17680, 7, 2, 0, 0, 17680, 17681, 5, 95, 0, 0, 17681, + 17682, 7, 5, 0, 0, 17682, 17683, 7, 4, 0, 0, 17683, 17684, 7, 0, 0, 0, + 17684, 17685, 7, 4, 0, 0, 17685, 17686, 7, 6, 0, 0, 17686, 17687, 7, 14, + 0, 0, 17687, 17688, 7, 6, 0, 0, 17688, 17689, 7, 7, 0, 0, 17689, 17690, + 7, 4, 0, 0, 17690, 17691, 5, 95, 0, 0, 17691, 17692, 7, 24, 0, 0, 17692, + 17693, 7, 12, 0, 0, 17693, 17694, 7, 6, 0, 0, 17694, 17695, 7, 12, 0, 0, + 17695, 17696, 7, 10, 0, 0, 17696, 17697, 7, 7, 0, 0, 17697, 17698, 7, 17, + 0, 0, 17698, 2384, 1, 0, 0, 0, 17699, 17700, 7, 7, 0, 0, 17700, 17701, + 7, 2, 0, 0, 17701, 17702, 5, 95, 0, 0, 17702, 17703, 7, 5, 0, 0, 17703, + 17704, 7, 4, 0, 0, 17704, 17705, 7, 0, 0, 0, 17705, 17706, 7, 4, 0, 0, + 17706, 17707, 7, 5, 0, 0, 17707, 17708, 5, 95, 0, 0, 17708, 17709, 7, 17, + 0, 0, 17709, 17710, 7, 5, 0, 0, 17710, 17711, 7, 6, 0, 0, 17711, 17712, + 7, 4, 0, 0, 17712, 17713, 7, 5, 0, 0, 17713, 2386, 1, 0, 0, 0, 17714, 17715, + 7, 7, 0, 0, 17715, 17716, 7, 2, 0, 0, 17716, 17717, 7, 5, 0, 0, 17717, + 17718, 7, 4, 0, 0, 17718, 17719, 7, 3, 0, 0, 17719, 17720, 7, 10, 0, 0, + 17720, 17721, 7, 8, 0, 0, 17721, 17722, 7, 4, 0, 0, 17722, 2388, 1, 0, + 0, 0, 17723, 17724, 7, 7, 0, 0, 17724, 17725, 7, 2, 0, 0, 17725, 17726, + 5, 95, 0, 0, 17726, 17727, 7, 5, 0, 0, 17727, 17728, 7, 12, 0, 0, 17728, + 17729, 7, 1, 0, 0, 17729, 17730, 7, 24, 0, 0, 17730, 17731, 7, 12, 0, 0, + 17731, 17732, 7, 6, 0, 0, 17732, 17733, 7, 3, 0, 0, 17733, 17734, 7, 18, + 0, 0, 17734, 17735, 5, 95, 0, 0, 17735, 17736, 7, 15, 0, 0, 17736, 17737, + 7, 3, 0, 0, 17737, 17738, 7, 12, 0, 0, 17738, 17739, 7, 7, 0, 0, 17739, + 17740, 7, 10, 0, 0, 17740, 17741, 7, 7, 0, 0, 17741, 17742, 7, 17, 0, 0, + 17742, 2390, 1, 0, 0, 0, 17743, 17744, 7, 7, 0, 0, 17744, 17745, 7, 2, + 0, 0, 17745, 17746, 5, 95, 0, 0, 17746, 17747, 7, 5, 0, 0, 17747, 17748, + 7, 12, 0, 0, 17748, 17749, 7, 1, 0, 0, 17749, 17750, 7, 5, 0, 0, 17750, + 17751, 7, 4, 0, 0, 17751, 17752, 7, 3, 0, 0, 17752, 17753, 7, 1, 0, 0, + 17753, 17754, 5, 95, 0, 0, 17754, 17755, 7, 15, 0, 0, 17755, 17756, 7, + 0, 0, 0, 17756, 17757, 7, 9, 0, 0, 17757, 2392, 1, 0, 0, 0, 17758, 17759, + 7, 7, 0, 0, 17759, 17760, 7, 2, 0, 0, 17760, 17761, 5, 95, 0, 0, 17761, + 17762, 7, 5, 0, 0, 17762, 17763, 7, 22, 0, 0, 17763, 17764, 7, 0, 0, 0, + 17764, 17765, 7, 15, 0, 0, 17765, 17766, 5, 95, 0, 0, 17766, 17767, 7, + 20, 0, 0, 17767, 17768, 7, 2, 0, 0, 17768, 17769, 7, 10, 0, 0, 17769, 17770, + 7, 7, 0, 0, 17770, 17771, 5, 95, 0, 0, 17771, 17772, 7, 10, 0, 0, 17772, + 17773, 7, 7, 0, 0, 17773, 17774, 7, 15, 0, 0, 17774, 17775, 7, 12, 0, 0, + 17775, 17776, 7, 4, 0, 0, 17776, 17777, 7, 5, 0, 0, 17777, 2394, 1, 0, + 0, 0, 17778, 17779, 7, 7, 0, 0, 17779, 17780, 7, 2, 0, 0, 17780, 17781, + 7, 5, 0, 0, 17781, 17782, 7, 22, 0, 0, 17782, 17783, 7, 10, 0, 0, 17783, + 17784, 7, 4, 0, 0, 17784, 17785, 7, 8, 0, 0, 17785, 17786, 7, 19, 0, 0, + 17786, 2396, 1, 0, 0, 0, 17787, 17788, 7, 7, 0, 0, 17788, 17789, 7, 2, + 0, 0, 17789, 17790, 5, 95, 0, 0, 17790, 17791, 7, 4, 0, 0, 17791, 17792, + 7, 0, 0, 0, 17792, 17793, 7, 1, 0, 0, 17793, 17794, 7, 11, 0, 0, 17794, + 17795, 7, 6, 0, 0, 17795, 17796, 5, 95, 0, 0, 17796, 17797, 7, 11, 0, 0, + 17797, 17798, 7, 2, 0, 0, 17798, 17799, 7, 2, 0, 0, 17799, 17800, 7, 21, + 0, 0, 17800, 17801, 7, 12, 0, 0, 17801, 17802, 7, 15, 0, 0, 17802, 17803, + 5, 95, 0, 0, 17803, 17804, 7, 1, 0, 0, 17804, 17805, 7, 18, 0, 0, 17805, + 17806, 5, 95, 0, 0, 17806, 17807, 7, 7, 0, 0, 17807, 17808, 7, 11, 0, 0, + 17808, 2398, 1, 0, 0, 0, 17809, 17810, 7, 7, 0, 0, 17810, 17811, 7, 2, + 0, 0, 17811, 17812, 5, 95, 0, 0, 17812, 17813, 7, 4, 0, 0, 17813, 17814, + 7, 6, 0, 0, 17814, 17815, 7, 14, 0, 0, 17815, 17816, 7, 15, 0, 0, 17816, + 17817, 5, 95, 0, 0, 17817, 17818, 7, 4, 0, 0, 17818, 17819, 7, 0, 0, 0, + 17819, 17820, 7, 1, 0, 0, 17820, 17821, 7, 11, 0, 0, 17821, 17822, 7, 6, + 0, 0, 17822, 2400, 1, 0, 0, 0, 17823, 17824, 7, 7, 0, 0, 17824, 17825, + 7, 2, 0, 0, 17825, 17826, 7, 4, 0, 0, 17826, 17827, 7, 19, 0, 0, 17827, + 17828, 7, 10, 0, 0, 17828, 17829, 7, 7, 0, 0, 17829, 17830, 7, 17, 0, 0, + 17830, 2402, 1, 0, 0, 0, 17831, 17832, 7, 7, 0, 0, 17832, 17833, 7, 2, + 0, 0, 17833, 17834, 7, 4, 0, 0, 17834, 17835, 7, 10, 0, 0, 17835, 17836, + 7, 16, 0, 0, 17836, 17837, 7, 10, 0, 0, 17837, 17838, 7, 8, 0, 0, 17838, + 17839, 7, 0, 0, 0, 17839, 17840, 7, 4, 0, 0, 17840, 17841, 7, 10, 0, 0, + 17841, 17842, 7, 2, 0, 0, 17842, 17843, 7, 7, 0, 0, 17843, 2404, 1, 0, + 0, 0, 17844, 17845, 7, 7, 0, 0, 17845, 17846, 7, 2, 0, 0, 17846, 17847, + 7, 4, 0, 0, 17847, 17848, 7, 3, 0, 0, 17848, 17849, 7, 10, 0, 0, 17849, + 17850, 7, 14, 0, 0, 17850, 2406, 1, 0, 0, 0, 17851, 17852, 7, 7, 0, 0, + 17852, 17853, 7, 2, 0, 0, 17853, 17854, 7, 4, 0, 0, 17854, 2408, 1, 0, + 0, 0, 17855, 17856, 7, 7, 0, 0, 17856, 17857, 7, 2, 0, 0, 17857, 17858, + 5, 95, 0, 0, 17858, 17859, 7, 4, 0, 0, 17859, 17860, 7, 3, 0, 0, 17860, + 17861, 7, 0, 0, 0, 17861, 17862, 7, 7, 0, 0, 17862, 17863, 7, 5, 0, 0, + 17863, 17864, 7, 16, 0, 0, 17864, 17865, 7, 2, 0, 0, 17865, 17866, 7, 3, + 0, 0, 17866, 17867, 7, 14, 0, 0, 17867, 17868, 5, 95, 0, 0, 17868, 17869, + 7, 9, 0, 0, 17869, 17870, 7, 10, 0, 0, 17870, 17871, 7, 5, 0, 0, 17871, + 17872, 7, 4, 0, 0, 17872, 17873, 7, 10, 0, 0, 17873, 17874, 7, 7, 0, 0, + 17874, 17875, 7, 8, 0, 0, 17875, 17876, 7, 4, 0, 0, 17876, 17877, 5, 95, + 0, 0, 17877, 17878, 7, 0, 0, 0, 17878, 17879, 7, 17, 0, 0, 17879, 17880, + 7, 17, 0, 0, 17880, 2410, 1, 0, 0, 0, 17881, 17882, 7, 7, 0, 0, 17882, + 17883, 7, 2, 0, 0, 17883, 17884, 5, 95, 0, 0, 17884, 17885, 7, 12, 0, 0, + 17885, 17886, 7, 7, 0, 0, 17886, 17887, 7, 7, 0, 0, 17887, 17888, 7, 6, + 0, 0, 17888, 17889, 7, 5, 0, 0, 17889, 17890, 7, 4, 0, 0, 17890, 2412, + 1, 0, 0, 0, 17891, 17892, 7, 7, 0, 0, 17892, 17893, 7, 2, 0, 0, 17893, + 17894, 5, 95, 0, 0, 17894, 17895, 7, 12, 0, 0, 17895, 17896, 7, 5, 0, 0, + 17896, 17897, 7, 6, 0, 0, 17897, 17898, 5, 95, 0, 0, 17898, 17899, 7, 8, + 0, 0, 17899, 17900, 7, 12, 0, 0, 17900, 17901, 7, 1, 0, 0, 17901, 17902, + 7, 6, 0, 0, 17902, 2414, 1, 0, 0, 0, 17903, 17904, 7, 7, 0, 0, 17904, 17905, + 7, 2, 0, 0, 17905, 17906, 5, 95, 0, 0, 17906, 17907, 7, 12, 0, 0, 17907, + 17908, 7, 5, 0, 0, 17908, 17909, 7, 6, 0, 0, 17909, 17910, 5, 95, 0, 0, + 17910, 17911, 7, 19, 0, 0, 17911, 17912, 7, 0, 0, 0, 17912, 17913, 7, 5, + 0, 0, 17913, 17914, 7, 19, 0, 0, 17914, 17915, 5, 95, 0, 0, 17915, 17916, + 7, 0, 0, 0, 17916, 17917, 7, 17, 0, 0, 17917, 17918, 7, 17, 0, 0, 17918, + 17919, 7, 3, 0, 0, 17919, 17920, 7, 6, 0, 0, 17920, 17921, 7, 17, 0, 0, + 17921, 17922, 7, 0, 0, 0, 17922, 17923, 7, 4, 0, 0, 17923, 17924, 7, 10, + 0, 0, 17924, 17925, 7, 2, 0, 0, 17925, 17926, 7, 7, 0, 0, 17926, 2416, + 1, 0, 0, 0, 17927, 17928, 7, 7, 0, 0, 17928, 17929, 7, 2, 0, 0, 17929, + 17930, 5, 95, 0, 0, 17930, 17931, 7, 12, 0, 0, 17931, 17932, 7, 5, 0, 0, + 17932, 17933, 7, 6, 0, 0, 17933, 17934, 5, 95, 0, 0, 17934, 17935, 7, 19, + 0, 0, 17935, 17936, 7, 0, 0, 0, 17936, 17937, 7, 5, 0, 0, 17937, 17938, + 7, 19, 0, 0, 17938, 17939, 5, 95, 0, 0, 17939, 17940, 7, 17, 0, 0, 17940, + 17941, 7, 1, 0, 0, 17941, 17942, 7, 18, 0, 0, 17942, 17943, 5, 95, 0, 0, + 17943, 17944, 7, 16, 0, 0, 17944, 17945, 7, 2, 0, 0, 17945, 17946, 7, 3, + 0, 0, 17946, 17947, 5, 95, 0, 0, 17947, 17948, 7, 15, 0, 0, 17948, 17949, + 7, 12, 0, 0, 17949, 17950, 7, 5, 0, 0, 17950, 17951, 7, 19, 0, 0, 17951, + 17952, 7, 9, 0, 0, 17952, 17953, 7, 2, 0, 0, 17953, 17954, 7, 22, 0, 0, + 17954, 17955, 7, 7, 0, 0, 17955, 2418, 1, 0, 0, 0, 17956, 17957, 7, 7, + 0, 0, 17957, 17958, 7, 2, 0, 0, 17958, 17959, 5, 95, 0, 0, 17959, 17960, + 7, 12, 0, 0, 17960, 17961, 7, 5, 0, 0, 17961, 17962, 7, 6, 0, 0, 17962, + 17963, 5, 95, 0, 0, 17963, 17964, 7, 19, 0, 0, 17964, 17965, 7, 0, 0, 0, + 17965, 17966, 7, 5, 0, 0, 17966, 17967, 7, 19, 0, 0, 17967, 2420, 1, 0, + 0, 0, 17968, 17969, 7, 7, 0, 0, 17969, 17970, 7, 2, 0, 0, 17970, 17971, + 5, 95, 0, 0, 17971, 17972, 7, 12, 0, 0, 17972, 17973, 7, 5, 0, 0, 17973, + 17974, 7, 6, 0, 0, 17974, 17975, 5, 95, 0, 0, 17975, 17976, 7, 10, 0, 0, + 17976, 17977, 7, 7, 0, 0, 17977, 17978, 7, 13, 0, 0, 17978, 17979, 7, 10, + 0, 0, 17979, 17980, 7, 5, 0, 0, 17980, 17981, 7, 10, 0, 0, 17981, 17982, + 7, 1, 0, 0, 17982, 17983, 7, 11, 0, 0, 17983, 17984, 7, 6, 0, 0, 17984, + 17985, 5, 95, 0, 0, 17985, 17986, 7, 10, 0, 0, 17986, 17987, 7, 7, 0, 0, + 17987, 17988, 7, 9, 0, 0, 17988, 17989, 7, 6, 0, 0, 17989, 17990, 7, 25, + 0, 0, 17990, 17991, 7, 6, 0, 0, 17991, 17992, 7, 5, 0, 0, 17992, 2422, + 1, 0, 0, 0, 17993, 17994, 7, 7, 0, 0, 17994, 17995, 7, 2, 0, 0, 17995, + 17996, 5, 95, 0, 0, 17996, 17997, 7, 12, 0, 0, 17997, 17998, 7, 5, 0, 0, + 17998, 17999, 7, 6, 0, 0, 17999, 18000, 5, 95, 0, 0, 18000, 18001, 7, 14, + 0, 0, 18001, 18002, 7, 6, 0, 0, 18002, 18003, 7, 3, 0, 0, 18003, 18004, + 7, 17, 0, 0, 18004, 18005, 7, 6, 0, 0, 18005, 2424, 1, 0, 0, 0, 18006, + 18007, 7, 7, 0, 0, 18007, 18008, 7, 2, 0, 0, 18008, 18009, 5, 95, 0, 0, + 18009, 18010, 7, 12, 0, 0, 18010, 18011, 7, 5, 0, 0, 18011, 18012, 7, 6, + 0, 0, 18012, 18013, 5, 95, 0, 0, 18013, 18014, 7, 7, 0, 0, 18014, 18015, + 7, 11, 0, 0, 18015, 2426, 1, 0, 0, 0, 18016, 18017, 7, 7, 0, 0, 18017, + 18018, 7, 2, 0, 0, 18018, 18019, 5, 95, 0, 0, 18019, 18020, 7, 12, 0, 0, + 18020, 18021, 7, 5, 0, 0, 18021, 18022, 7, 6, 0, 0, 18022, 18023, 5, 95, + 0, 0, 18023, 18024, 7, 13, 0, 0, 18024, 18025, 7, 6, 0, 0, 18025, 18026, + 7, 8, 0, 0, 18026, 18027, 7, 4, 0, 0, 18027, 18028, 7, 2, 0, 0, 18028, + 18029, 7, 3, 0, 0, 18029, 18030, 5, 95, 0, 0, 18030, 18031, 7, 0, 0, 0, + 18031, 18032, 7, 17, 0, 0, 18032, 18033, 7, 17, 0, 0, 18033, 18034, 7, + 3, 0, 0, 18034, 18035, 7, 6, 0, 0, 18035, 18036, 7, 17, 0, 0, 18036, 18037, + 7, 0, 0, 0, 18037, 18038, 7, 4, 0, 0, 18038, 18039, 7, 10, 0, 0, 18039, + 18040, 7, 2, 0, 0, 18040, 18041, 7, 7, 0, 0, 18041, 2428, 1, 0, 0, 0, 18042, + 18043, 7, 7, 0, 0, 18043, 18044, 7, 2, 0, 0, 18044, 18045, 7, 13, 0, 0, + 18045, 18046, 7, 0, 0, 0, 18046, 18047, 7, 11, 0, 0, 18047, 18048, 7, 10, + 0, 0, 18048, 18049, 7, 9, 0, 0, 18049, 18050, 7, 0, 0, 0, 18050, 18051, + 7, 4, 0, 0, 18051, 18052, 7, 6, 0, 0, 18052, 2430, 1, 0, 0, 0, 18053, 18054, + 7, 7, 0, 0, 18054, 18055, 7, 2, 0, 0, 18055, 18056, 5, 95, 0, 0, 18056, + 18057, 7, 13, 0, 0, 18057, 18058, 7, 6, 0, 0, 18058, 18059, 7, 8, 0, 0, + 18059, 18060, 7, 4, 0, 0, 18060, 18061, 7, 2, 0, 0, 18061, 18062, 7, 3, + 0, 0, 18062, 18063, 5, 95, 0, 0, 18063, 18064, 7, 4, 0, 0, 18064, 18065, + 7, 3, 0, 0, 18065, 18066, 7, 0, 0, 0, 18066, 18067, 7, 7, 0, 0, 18067, + 18068, 7, 5, 0, 0, 18068, 18069, 7, 16, 0, 0, 18069, 18070, 7, 2, 0, 0, + 18070, 18071, 7, 3, 0, 0, 18071, 18072, 7, 14, 0, 0, 18072, 18073, 5, 95, + 0, 0, 18073, 18074, 7, 9, 0, 0, 18074, 18075, 7, 10, 0, 0, 18075, 18076, + 7, 14, 0, 0, 18076, 18077, 7, 5, 0, 0, 18077, 2432, 1, 0, 0, 0, 18078, + 18079, 7, 7, 0, 0, 18079, 18080, 7, 2, 0, 0, 18080, 18081, 5, 95, 0, 0, + 18081, 18082, 7, 13, 0, 0, 18082, 18083, 7, 6, 0, 0, 18083, 18084, 7, 8, + 0, 0, 18084, 18085, 7, 4, 0, 0, 18085, 18086, 7, 2, 0, 0, 18086, 18087, + 7, 3, 0, 0, 18087, 18088, 5, 95, 0, 0, 18088, 18089, 7, 4, 0, 0, 18089, + 18090, 7, 3, 0, 0, 18090, 18091, 7, 0, 0, 0, 18091, 18092, 7, 7, 0, 0, + 18092, 18093, 7, 5, 0, 0, 18093, 18094, 7, 16, 0, 0, 18094, 18095, 7, 2, + 0, 0, 18095, 18096, 7, 3, 0, 0, 18096, 18097, 7, 14, 0, 0, 18097, 18098, + 5, 95, 0, 0, 18098, 18099, 7, 16, 0, 0, 18099, 18100, 7, 0, 0, 0, 18100, + 18101, 7, 8, 0, 0, 18101, 18102, 7, 4, 0, 0, 18102, 2434, 1, 0, 0, 0, 18103, + 18104, 7, 7, 0, 0, 18104, 18105, 7, 2, 0, 0, 18105, 18106, 5, 95, 0, 0, + 18106, 18107, 7, 13, 0, 0, 18107, 18108, 7, 6, 0, 0, 18108, 18109, 7, 8, + 0, 0, 18109, 18110, 7, 4, 0, 0, 18110, 18111, 7, 2, 0, 0, 18111, 18112, + 7, 3, 0, 0, 18112, 18113, 5, 95, 0, 0, 18113, 18114, 7, 4, 0, 0, 18114, + 18115, 7, 3, 0, 0, 18115, 18116, 7, 0, 0, 0, 18116, 18117, 7, 7, 0, 0, + 18117, 18118, 7, 5, 0, 0, 18118, 18119, 7, 16, 0, 0, 18119, 18120, 7, 2, + 0, 0, 18120, 18121, 7, 3, 0, 0, 18121, 18122, 7, 14, 0, 0, 18122, 2436, + 1, 0, 0, 0, 18123, 18124, 7, 7, 0, 0, 18124, 18125, 7, 2, 0, 0, 18125, + 18126, 7, 22, 0, 0, 18126, 18127, 7, 0, 0, 0, 18127, 18128, 7, 10, 0, 0, + 18128, 18129, 7, 4, 0, 0, 18129, 2438, 1, 0, 0, 0, 18130, 18131, 7, 7, + 0, 0, 18131, 18132, 7, 2, 0, 0, 18132, 18133, 5, 95, 0, 0, 18133, 18134, + 7, 25, 0, 0, 18134, 18135, 7, 9, 0, 0, 18135, 18136, 7, 1, 0, 0, 18136, + 18137, 5, 95, 0, 0, 18137, 18138, 7, 16, 0, 0, 18138, 18139, 7, 0, 0, 0, + 18139, 18140, 7, 5, 0, 0, 18140, 18141, 7, 4, 0, 0, 18141, 18142, 7, 15, + 0, 0, 18142, 18143, 7, 0, 0, 0, 18143, 18144, 7, 4, 0, 0, 18144, 18145, + 7, 19, 0, 0, 18145, 18146, 5, 95, 0, 0, 18146, 18147, 7, 10, 0, 0, 18147, + 18148, 7, 7, 0, 0, 18148, 18149, 7, 5, 0, 0, 18149, 18150, 7, 6, 0, 0, + 18150, 18151, 7, 3, 0, 0, 18151, 18152, 7, 4, 0, 0, 18152, 2440, 1, 0, + 0, 0, 18153, 18154, 7, 7, 0, 0, 18154, 18155, 7, 2, 0, 0, 18155, 18156, + 5, 95, 0, 0, 18156, 18157, 7, 25, 0, 0, 18157, 18158, 7, 14, 0, 0, 18158, + 18159, 7, 11, 0, 0, 18159, 18160, 5, 95, 0, 0, 18160, 18161, 7, 9, 0, 0, + 18161, 18162, 7, 14, 0, 0, 18162, 18163, 7, 11, 0, 0, 18163, 18164, 5, + 95, 0, 0, 18164, 18165, 7, 3, 0, 0, 18165, 18166, 7, 6, 0, 0, 18166, 18167, + 7, 22, 0, 0, 18167, 18168, 7, 3, 0, 0, 18168, 18169, 7, 10, 0, 0, 18169, + 18170, 7, 4, 0, 0, 18170, 18171, 7, 6, 0, 0, 18171, 2442, 1, 0, 0, 0, 18172, + 18173, 7, 7, 0, 0, 18173, 18174, 7, 2, 0, 0, 18174, 18175, 5, 95, 0, 0, + 18175, 18176, 7, 25, 0, 0, 18176, 18177, 7, 14, 0, 0, 18177, 18178, 7, + 11, 0, 0, 18178, 18179, 7, 10, 0, 0, 18179, 18180, 7, 7, 0, 0, 18180, 18181, + 7, 9, 0, 0, 18181, 18182, 7, 6, 0, 0, 18182, 18183, 7, 25, 0, 0, 18183, + 18184, 5, 95, 0, 0, 18184, 18185, 7, 3, 0, 0, 18185, 18186, 7, 6, 0, 0, + 18186, 18187, 7, 22, 0, 0, 18187, 18188, 7, 3, 0, 0, 18188, 18189, 7, 10, + 0, 0, 18189, 18190, 7, 4, 0, 0, 18190, 18191, 7, 6, 0, 0, 18191, 18192, + 5, 95, 0, 0, 18192, 18193, 7, 10, 0, 0, 18193, 18194, 7, 7, 0, 0, 18194, + 18195, 5, 95, 0, 0, 18195, 18196, 7, 5, 0, 0, 18196, 18197, 7, 6, 0, 0, + 18197, 18198, 7, 11, 0, 0, 18198, 18199, 7, 6, 0, 0, 18199, 18200, 7, 8, + 0, 0, 18200, 18201, 7, 4, 0, 0, 18201, 2444, 1, 0, 0, 0, 18202, 18203, + 7, 7, 0, 0, 18203, 18204, 7, 2, 0, 0, 18204, 18205, 5, 95, 0, 0, 18205, + 18206, 7, 25, 0, 0, 18206, 18207, 7, 14, 0, 0, 18207, 18208, 7, 11, 0, + 0, 18208, 18209, 7, 10, 0, 0, 18209, 18210, 7, 7, 0, 0, 18210, 18211, 7, + 9, 0, 0, 18211, 18212, 7, 6, 0, 0, 18212, 18213, 7, 25, 0, 0, 18213, 18214, + 5, 95, 0, 0, 18214, 18215, 7, 3, 0, 0, 18215, 18216, 7, 6, 0, 0, 18216, + 18217, 7, 22, 0, 0, 18217, 18218, 7, 3, 0, 0, 18218, 18219, 7, 10, 0, 0, + 18219, 18220, 7, 4, 0, 0, 18220, 18221, 7, 6, 0, 0, 18221, 2446, 1, 0, + 0, 0, 18222, 18223, 7, 7, 0, 0, 18223, 18224, 7, 2, 0, 0, 18224, 18225, + 5, 95, 0, 0, 18225, 18226, 7, 25, 0, 0, 18226, 18227, 7, 14, 0, 0, 18227, + 18228, 7, 11, 0, 0, 18228, 18229, 5, 95, 0, 0, 18229, 18230, 7, 24, 0, + 0, 18230, 18231, 7, 12, 0, 0, 18231, 18232, 7, 6, 0, 0, 18232, 18233, 7, + 3, 0, 0, 18233, 18234, 7, 18, 0, 0, 18234, 18235, 5, 95, 0, 0, 18235, 18236, + 7, 3, 0, 0, 18236, 18237, 7, 6, 0, 0, 18237, 18238, 7, 22, 0, 0, 18238, + 18239, 7, 3, 0, 0, 18239, 18240, 7, 10, 0, 0, 18240, 18241, 7, 4, 0, 0, + 18241, 18242, 7, 6, 0, 0, 18242, 2448, 1, 0, 0, 0, 18243, 18244, 7, 7, + 0, 0, 18244, 18245, 7, 2, 0, 0, 18245, 18246, 5, 95, 0, 0, 18246, 18247, + 7, 23, 0, 0, 18247, 18248, 7, 2, 0, 0, 18248, 18249, 7, 7, 0, 0, 18249, + 18250, 7, 6, 0, 0, 18250, 18251, 7, 14, 0, 0, 18251, 18252, 7, 0, 0, 0, + 18252, 18253, 7, 15, 0, 0, 18253, 2450, 1, 0, 0, 0, 18254, 18255, 7, 7, + 0, 0, 18255, 18256, 7, 4, 0, 0, 18256, 18257, 7, 19, 0, 0, 18257, 18258, + 5, 95, 0, 0, 18258, 18259, 7, 13, 0, 0, 18259, 18260, 7, 0, 0, 0, 18260, + 18261, 7, 11, 0, 0, 18261, 18262, 7, 12, 0, 0, 18262, 18263, 7, 6, 0, 0, + 18263, 2452, 1, 0, 0, 0, 18264, 18265, 7, 7, 0, 0, 18265, 18266, 7, 12, + 0, 0, 18266, 18267, 7, 11, 0, 0, 18267, 18268, 7, 11, 0, 0, 18268, 18269, + 7, 10, 0, 0, 18269, 18270, 7, 16, 0, 0, 18270, 2454, 1, 0, 0, 0, 18271, + 18272, 7, 7, 0, 0, 18272, 18273, 7, 12, 0, 0, 18273, 18274, 7, 11, 0, 0, + 18274, 18275, 7, 11, 0, 0, 18275, 2456, 1, 0, 0, 0, 18276, 18277, 7, 7, + 0, 0, 18277, 18278, 7, 12, 0, 0, 18278, 18279, 7, 11, 0, 0, 18279, 18280, + 7, 11, 0, 0, 18280, 18281, 7, 5, 0, 0, 18281, 2458, 1, 0, 0, 0, 18282, + 18283, 7, 7, 0, 0, 18283, 18284, 7, 12, 0, 0, 18284, 18285, 7, 14, 0, 0, + 18285, 18286, 7, 1, 0, 0, 18286, 18287, 7, 6, 0, 0, 18287, 18288, 7, 3, + 0, 0, 18288, 2460, 1, 0, 0, 0, 18289, 18290, 7, 7, 0, 0, 18290, 18291, + 7, 12, 0, 0, 18291, 18292, 7, 14, 0, 0, 18292, 18293, 7, 6, 0, 0, 18293, + 18294, 7, 3, 0, 0, 18294, 18295, 7, 10, 0, 0, 18295, 18296, 7, 8, 0, 0, + 18296, 2462, 1, 0, 0, 0, 18297, 18298, 7, 7, 0, 0, 18298, 18299, 7, 12, + 0, 0, 18299, 18300, 7, 14, 0, 0, 18300, 18301, 5, 95, 0, 0, 18301, 18302, + 7, 10, 0, 0, 18302, 18303, 7, 7, 0, 0, 18303, 18304, 7, 9, 0, 0, 18304, + 18305, 7, 6, 0, 0, 18305, 18306, 7, 25, 0, 0, 18306, 18307, 5, 95, 0, 0, + 18307, 18308, 7, 21, 0, 0, 18308, 18309, 7, 6, 0, 0, 18309, 18310, 7, 18, + 0, 0, 18310, 18311, 7, 5, 0, 0, 18311, 2464, 1, 0, 0, 0, 18312, 18313, + 7, 7, 0, 0, 18313, 18314, 7, 12, 0, 0, 18314, 18315, 7, 14, 0, 0, 18315, + 18316, 7, 4, 0, 0, 18316, 18317, 7, 2, 0, 0, 18317, 18318, 7, 9, 0, 0, + 18318, 18319, 7, 5, 0, 0, 18319, 18320, 7, 10, 0, 0, 18320, 18321, 7, 7, + 0, 0, 18321, 18322, 7, 4, 0, 0, 18322, 18323, 7, 6, 0, 0, 18323, 18324, + 7, 3, 0, 0, 18324, 18325, 7, 13, 0, 0, 18325, 18326, 7, 0, 0, 0, 18326, + 18327, 7, 11, 0, 0, 18327, 2466, 1, 0, 0, 0, 18328, 18329, 7, 7, 0, 0, + 18329, 18330, 7, 12, 0, 0, 18330, 18331, 7, 14, 0, 0, 18331, 18332, 7, + 4, 0, 0, 18332, 18333, 7, 2, 0, 0, 18333, 18334, 7, 18, 0, 0, 18334, 18335, + 7, 14, 0, 0, 18335, 18336, 7, 10, 0, 0, 18336, 18337, 7, 7, 0, 0, 18337, + 18338, 7, 4, 0, 0, 18338, 18339, 7, 6, 0, 0, 18339, 18340, 7, 3, 0, 0, + 18340, 18341, 7, 13, 0, 0, 18341, 18342, 7, 0, 0, 0, 18342, 18343, 7, 11, + 0, 0, 18343, 2468, 1, 0, 0, 0, 18344, 18345, 7, 7, 0, 0, 18345, 18346, + 7, 13, 0, 0, 18346, 18347, 7, 0, 0, 0, 18347, 18348, 7, 3, 0, 0, 18348, + 18349, 7, 8, 0, 0, 18349, 18350, 7, 19, 0, 0, 18350, 18351, 7, 0, 0, 0, + 18351, 18352, 7, 3, 0, 0, 18352, 18353, 5, 50, 0, 0, 18353, 2470, 1, 0, + 0, 0, 18354, 18355, 7, 7, 0, 0, 18355, 18356, 7, 13, 0, 0, 18356, 18357, + 7, 11, 0, 0, 18357, 18358, 5, 50, 0, 0, 18358, 2472, 1, 0, 0, 0, 18359, + 18360, 7, 2, 0, 0, 18360, 18361, 7, 1, 0, 0, 18361, 18362, 7, 20, 0, 0, + 18362, 18363, 7, 6, 0, 0, 18363, 18364, 7, 8, 0, 0, 18364, 18365, 7, 4, + 0, 0, 18365, 18366, 5, 50, 0, 0, 18366, 18367, 7, 25, 0, 0, 18367, 18368, + 7, 14, 0, 0, 18368, 18369, 7, 11, 0, 0, 18369, 2474, 1, 0, 0, 0, 18370, + 18371, 7, 2, 0, 0, 18371, 18372, 7, 1, 0, 0, 18372, 18373, 7, 20, 0, 0, + 18373, 18374, 7, 6, 0, 0, 18374, 18375, 7, 8, 0, 0, 18375, 18376, 7, 4, + 0, 0, 18376, 2476, 1, 0, 0, 0, 18377, 18378, 7, 2, 0, 0, 18378, 18379, + 7, 1, 0, 0, 18379, 18380, 7, 20, 0, 0, 18380, 18381, 5, 95, 0, 0, 18381, + 18382, 7, 10, 0, 0, 18382, 18383, 7, 9, 0, 0, 18383, 2478, 1, 0, 0, 0, + 18384, 18385, 7, 2, 0, 0, 18385, 18386, 7, 1, 0, 0, 18386, 18387, 7, 20, + 0, 0, 18387, 18388, 7, 7, 0, 0, 18388, 18389, 7, 2, 0, 0, 18389, 2480, + 1, 0, 0, 0, 18390, 18391, 7, 2, 0, 0, 18391, 18392, 7, 1, 0, 0, 18392, + 18393, 7, 20, 0, 0, 18393, 18394, 7, 7, 0, 0, 18394, 18395, 7, 2, 0, 0, + 18395, 18396, 5, 95, 0, 0, 18396, 18397, 7, 3, 0, 0, 18397, 18398, 7, 6, + 0, 0, 18398, 18399, 7, 12, 0, 0, 18399, 18400, 7, 5, 0, 0, 18400, 18401, + 7, 6, 0, 0, 18401, 2482, 1, 0, 0, 0, 18402, 18403, 7, 2, 0, 0, 18403, 18404, + 7, 8, 0, 0, 18404, 18405, 7, 8, 0, 0, 18405, 18406, 7, 12, 0, 0, 18406, + 18407, 7, 3, 0, 0, 18407, 18408, 7, 6, 0, 0, 18408, 18409, 7, 7, 0, 0, + 18409, 18410, 7, 8, 0, 0, 18410, 18411, 7, 6, 0, 0, 18411, 18412, 7, 5, + 0, 0, 18412, 2484, 1, 0, 0, 0, 18413, 18414, 7, 2, 0, 0, 18414, 18415, + 7, 16, 0, 0, 18415, 18416, 7, 16, 0, 0, 18416, 18417, 7, 11, 0, 0, 18417, + 18418, 7, 10, 0, 0, 18418, 18419, 7, 7, 0, 0, 18419, 18420, 7, 6, 0, 0, + 18420, 2486, 1, 0, 0, 0, 18421, 18422, 7, 2, 0, 0, 18422, 18423, 7, 16, + 0, 0, 18423, 18424, 7, 16, 0, 0, 18424, 2488, 1, 0, 0, 0, 18425, 18426, + 7, 2, 0, 0, 18426, 18427, 7, 16, 0, 0, 18427, 18428, 7, 16, 0, 0, 18428, + 18429, 7, 5, 0, 0, 18429, 18430, 7, 6, 0, 0, 18430, 18431, 7, 4, 0, 0, + 18431, 2490, 1, 0, 0, 0, 18432, 18433, 7, 2, 0, 0, 18433, 18434, 7, 16, + 0, 0, 18434, 2492, 1, 0, 0, 0, 18435, 18436, 7, 2, 0, 0, 18436, 18437, + 7, 10, 0, 0, 18437, 18438, 7, 9, 0, 0, 18438, 18439, 7, 10, 0, 0, 18439, + 18440, 7, 7, 0, 0, 18440, 18441, 7, 9, 0, 0, 18441, 18442, 7, 6, 0, 0, + 18442, 18443, 7, 25, 0, 0, 18443, 2494, 1, 0, 0, 0, 18444, 18445, 7, 2, + 0, 0, 18445, 18446, 7, 10, 0, 0, 18446, 18447, 7, 9, 0, 0, 18447, 2496, + 1, 0, 0, 0, 18448, 18449, 7, 2, 0, 0, 18449, 18450, 7, 11, 0, 0, 18450, + 18451, 7, 0, 0, 0, 18451, 18452, 7, 15, 0, 0, 18452, 2498, 1, 0, 0, 0, + 18453, 18454, 7, 2, 0, 0, 18454, 18455, 7, 11, 0, 0, 18455, 18456, 7, 9, + 0, 0, 18456, 2500, 1, 0, 0, 0, 18457, 18458, 7, 2, 0, 0, 18458, 18459, + 7, 11, 0, 0, 18459, 18460, 7, 9, 0, 0, 18460, 18461, 5, 95, 0, 0, 18461, + 18462, 7, 15, 0, 0, 18462, 18463, 7, 12, 0, 0, 18463, 18464, 7, 5, 0, 0, + 18464, 18465, 7, 19, 0, 0, 18465, 18466, 5, 95, 0, 0, 18466, 18467, 7, + 15, 0, 0, 18467, 18468, 7, 3, 0, 0, 18468, 18469, 7, 6, 0, 0, 18469, 18470, + 7, 9, 0, 0, 18470, 2502, 1, 0, 0, 0, 18471, 18472, 7, 2, 0, 0, 18472, 18473, + 7, 11, 0, 0, 18473, 18474, 7, 5, 0, 0, 18474, 2504, 1, 0, 0, 0, 18475, + 18476, 7, 2, 0, 0, 18476, 18477, 7, 11, 0, 0, 18477, 18478, 7, 4, 0, 0, + 18478, 18479, 7, 15, 0, 0, 18479, 2506, 1, 0, 0, 0, 18480, 18481, 7, 2, + 0, 0, 18481, 18482, 7, 14, 0, 0, 18482, 18483, 7, 10, 0, 0, 18483, 18484, + 7, 4, 0, 0, 18484, 2508, 1, 0, 0, 0, 18485, 18486, 7, 2, 0, 0, 18486, 18487, + 7, 7, 0, 0, 18487, 18488, 7, 6, 0, 0, 18488, 2510, 1, 0, 0, 0, 18489, 18490, + 7, 2, 0, 0, 18490, 18491, 7, 7, 0, 0, 18491, 18492, 7, 11, 0, 0, 18492, + 18493, 7, 10, 0, 0, 18493, 18494, 7, 7, 0, 0, 18494, 18495, 7, 6, 0, 0, + 18495, 2512, 1, 0, 0, 0, 18496, 18497, 7, 2, 0, 0, 18497, 18498, 7, 7, + 0, 0, 18498, 18499, 7, 11, 0, 0, 18499, 18500, 7, 10, 0, 0, 18500, 18501, + 7, 7, 0, 0, 18501, 18502, 7, 6, 0, 0, 18502, 18503, 7, 11, 0, 0, 18503, + 18504, 7, 2, 0, 0, 18504, 18505, 7, 17, 0, 0, 18505, 2514, 1, 0, 0, 0, + 18506, 18507, 7, 2, 0, 0, 18507, 18508, 7, 7, 0, 0, 18508, 18509, 7, 11, + 0, 0, 18509, 18510, 7, 18, 0, 0, 18510, 2516, 1, 0, 0, 0, 18511, 18512, + 7, 2, 0, 0, 18512, 18513, 7, 7, 0, 0, 18513, 2518, 1, 0, 0, 0, 18514, 18515, + 7, 2, 0, 0, 18515, 18516, 7, 15, 0, 0, 18516, 18517, 7, 0, 0, 0, 18517, + 18518, 7, 24, 0, 0, 18518, 18519, 7, 12, 0, 0, 18519, 18520, 7, 6, 0, 0, + 18520, 2520, 1, 0, 0, 0, 18521, 18522, 7, 2, 0, 0, 18522, 18523, 7, 15, + 0, 0, 18523, 18524, 7, 0, 0, 0, 18524, 18525, 7, 24, 0, 0, 18525, 18526, + 7, 12, 0, 0, 18526, 18527, 7, 6, 0, 0, 18527, 18528, 5, 95, 0, 0, 18528, + 18529, 7, 4, 0, 0, 18529, 18530, 7, 3, 0, 0, 18530, 18531, 7, 0, 0, 0, + 18531, 18532, 7, 7, 0, 0, 18532, 18533, 7, 5, 0, 0, 18533, 18534, 7, 16, + 0, 0, 18534, 18535, 7, 2, 0, 0, 18535, 18536, 7, 3, 0, 0, 18536, 18537, + 7, 14, 0, 0, 18537, 2522, 1, 0, 0, 0, 18538, 18539, 7, 2, 0, 0, 18539, + 18540, 7, 15, 0, 0, 18540, 18541, 7, 0, 0, 0, 18541, 18542, 7, 24, 0, 0, + 18542, 18543, 7, 12, 0, 0, 18543, 18544, 7, 6, 0, 0, 18544, 18545, 5, 95, + 0, 0, 18545, 18546, 7, 25, 0, 0, 18546, 18547, 7, 8, 0, 0, 18547, 18548, + 7, 0, 0, 0, 18548, 18549, 7, 7, 0, 0, 18549, 18550, 7, 2, 0, 0, 18550, + 18551, 7, 7, 0, 0, 18551, 18552, 7, 10, 0, 0, 18552, 18553, 7, 8, 0, 0, + 18553, 18554, 7, 0, 0, 0, 18554, 18555, 7, 11, 0, 0, 18555, 2524, 1, 0, + 0, 0, 18556, 18557, 7, 2, 0, 0, 18557, 18558, 7, 15, 0, 0, 18558, 18559, + 7, 8, 0, 0, 18559, 18560, 7, 2, 0, 0, 18560, 18561, 7, 9, 0, 0, 18561, + 18562, 7, 6, 0, 0, 18562, 2526, 1, 0, 0, 0, 18563, 18564, 7, 2, 0, 0, 18564, + 18565, 7, 15, 0, 0, 18565, 18566, 7, 6, 0, 0, 18566, 18567, 7, 7, 0, 0, + 18567, 2528, 1, 0, 0, 0, 18568, 18569, 7, 2, 0, 0, 18569, 18570, 7, 15, + 0, 0, 18570, 18571, 7, 6, 0, 0, 18571, 18572, 7, 3, 0, 0, 18572, 18573, + 7, 0, 0, 0, 18573, 18574, 7, 4, 0, 0, 18574, 18575, 7, 10, 0, 0, 18575, + 18576, 7, 2, 0, 0, 18576, 18577, 7, 7, 0, 0, 18577, 18578, 7, 5, 0, 0, + 18578, 2530, 1, 0, 0, 0, 18579, 18580, 7, 2, 0, 0, 18580, 18581, 7, 15, + 0, 0, 18581, 18582, 7, 6, 0, 0, 18582, 18583, 7, 3, 0, 0, 18583, 18584, + 7, 0, 0, 0, 18584, 18585, 7, 4, 0, 0, 18585, 18586, 7, 2, 0, 0, 18586, + 18587, 7, 3, 0, 0, 18587, 2532, 1, 0, 0, 0, 18588, 18589, 7, 2, 0, 0, 18589, + 18590, 7, 15, 0, 0, 18590, 18591, 7, 4, 0, 0, 18591, 18592, 5, 95, 0, 0, + 18592, 18593, 7, 6, 0, 0, 18593, 18594, 7, 5, 0, 0, 18594, 18595, 7, 4, + 0, 0, 18595, 18596, 7, 10, 0, 0, 18596, 18597, 7, 14, 0, 0, 18597, 18598, + 7, 0, 0, 0, 18598, 18599, 7, 4, 0, 0, 18599, 18600, 7, 6, 0, 0, 18600, + 2534, 1, 0, 0, 0, 18601, 18602, 7, 2, 0, 0, 18602, 18603, 7, 15, 0, 0, + 18603, 18604, 7, 4, 0, 0, 18604, 18605, 7, 10, 0, 0, 18605, 18606, 7, 14, + 0, 0, 18606, 18607, 7, 0, 0, 0, 18607, 18608, 7, 11, 0, 0, 18608, 2536, + 1, 0, 0, 0, 18609, 18610, 7, 2, 0, 0, 18610, 18611, 7, 15, 0, 0, 18611, + 18612, 7, 4, 0, 0, 18612, 18613, 7, 10, 0, 0, 18613, 18614, 7, 14, 0, 0, + 18614, 18615, 7, 10, 0, 0, 18615, 18616, 7, 23, 0, 0, 18616, 18617, 7, + 6, 0, 0, 18617, 2538, 1, 0, 0, 0, 18618, 18619, 7, 2, 0, 0, 18619, 18620, + 7, 15, 0, 0, 18620, 18621, 7, 4, 0, 0, 18621, 18622, 7, 10, 0, 0, 18622, + 18623, 7, 14, 0, 0, 18623, 18624, 7, 10, 0, 0, 18624, 18625, 7, 23, 0, + 0, 18625, 18626, 7, 6, 0, 0, 18626, 18627, 7, 3, 0, 0, 18627, 18628, 5, + 95, 0, 0, 18628, 18629, 7, 16, 0, 0, 18629, 18630, 7, 6, 0, 0, 18630, 18631, + 7, 0, 0, 0, 18631, 18632, 7, 4, 0, 0, 18632, 18633, 7, 12, 0, 0, 18633, + 18634, 7, 3, 0, 0, 18634, 18635, 7, 6, 0, 0, 18635, 18636, 7, 5, 0, 0, + 18636, 18637, 5, 95, 0, 0, 18637, 18638, 7, 6, 0, 0, 18638, 18639, 7, 7, + 0, 0, 18639, 18640, 7, 0, 0, 0, 18640, 18641, 7, 1, 0, 0, 18641, 18642, + 7, 11, 0, 0, 18642, 18643, 7, 6, 0, 0, 18643, 2540, 1, 0, 0, 0, 18644, + 18645, 7, 2, 0, 0, 18645, 18646, 7, 15, 0, 0, 18646, 18647, 7, 4, 0, 0, + 18647, 18648, 7, 10, 0, 0, 18648, 18649, 7, 14, 0, 0, 18649, 18650, 7, + 10, 0, 0, 18650, 18651, 7, 23, 0, 0, 18651, 18652, 7, 6, 0, 0, 18652, 18653, + 7, 3, 0, 0, 18653, 18654, 5, 95, 0, 0, 18654, 18655, 7, 17, 0, 0, 18655, + 18656, 7, 2, 0, 0, 18656, 18657, 7, 0, 0, 0, 18657, 18658, 7, 11, 0, 0, + 18658, 2542, 1, 0, 0, 0, 18659, 18660, 7, 2, 0, 0, 18660, 18661, 7, 15, + 0, 0, 18661, 18662, 7, 4, 0, 0, 18662, 18663, 7, 10, 0, 0, 18663, 18664, + 7, 2, 0, 0, 18664, 18665, 7, 7, 0, 0, 18665, 2544, 1, 0, 0, 0, 18666, 18667, + 7, 2, 0, 0, 18667, 18668, 7, 15, 0, 0, 18668, 18669, 7, 4, 0, 0, 18669, + 18670, 7, 10, 0, 0, 18670, 18671, 7, 2, 0, 0, 18671, 18672, 7, 7, 0, 0, + 18672, 18673, 7, 0, 0, 0, 18673, 18674, 7, 11, 0, 0, 18674, 18675, 7, 11, + 0, 0, 18675, 18676, 7, 18, 0, 0, 18676, 2546, 1, 0, 0, 0, 18677, 18678, + 7, 2, 0, 0, 18678, 18679, 7, 15, 0, 0, 18679, 18680, 7, 4, 0, 0, 18680, + 18681, 5, 95, 0, 0, 18681, 18682, 7, 15, 0, 0, 18682, 18683, 7, 0, 0, 0, + 18683, 18684, 7, 3, 0, 0, 18684, 18685, 7, 0, 0, 0, 18685, 18686, 7, 14, + 0, 0, 18686, 2548, 1, 0, 0, 0, 18687, 18688, 7, 2, 0, 0, 18688, 18689, + 7, 3, 0, 0, 18689, 18690, 7, 0, 0, 0, 18690, 18691, 5, 95, 0, 0, 18691, + 18692, 7, 1, 0, 0, 18692, 18693, 7, 3, 0, 0, 18693, 18694, 7, 0, 0, 0, + 18694, 18695, 7, 7, 0, 0, 18695, 18696, 7, 8, 0, 0, 18696, 18697, 7, 19, + 0, 0, 18697, 2550, 1, 0, 0, 0, 18698, 18699, 7, 2, 0, 0, 18699, 18700, + 7, 3, 0, 0, 18700, 18701, 7, 0, 0, 0, 18701, 18702, 5, 95, 0, 0, 18702, + 18703, 7, 8, 0, 0, 18703, 18704, 7, 19, 0, 0, 18704, 18705, 7, 6, 0, 0, + 18705, 18706, 7, 8, 0, 0, 18706, 18707, 7, 21, 0, 0, 18707, 18708, 5, 95, + 0, 0, 18708, 18709, 7, 0, 0, 0, 18709, 18710, 7, 8, 0, 0, 18710, 18711, + 7, 11, 0, 0, 18711, 2552, 1, 0, 0, 0, 18712, 18713, 7, 2, 0, 0, 18713, + 18714, 7, 3, 0, 0, 18714, 18715, 7, 0, 0, 0, 18715, 18716, 5, 95, 0, 0, + 18716, 18717, 7, 8, 0, 0, 18717, 18718, 7, 19, 0, 0, 18718, 18719, 7, 6, + 0, 0, 18719, 18720, 7, 8, 0, 0, 18720, 18721, 7, 21, 0, 0, 18721, 18722, + 5, 95, 0, 0, 18722, 18723, 7, 15, 0, 0, 18723, 18724, 7, 3, 0, 0, 18724, + 18725, 7, 10, 0, 0, 18725, 18726, 7, 13, 0, 0, 18726, 18727, 7, 10, 0, + 0, 18727, 18728, 7, 11, 0, 0, 18728, 18729, 7, 6, 0, 0, 18729, 18730, 7, + 17, 0, 0, 18730, 18731, 7, 6, 0, 0, 18731, 2554, 1, 0, 0, 0, 18732, 18733, + 7, 2, 0, 0, 18733, 18734, 7, 3, 0, 0, 18734, 18735, 7, 0, 0, 0, 18735, + 18736, 5, 95, 0, 0, 18736, 18737, 7, 8, 0, 0, 18737, 18738, 7, 11, 0, 0, + 18738, 18739, 7, 12, 0, 0, 18739, 18740, 7, 5, 0, 0, 18740, 18741, 7, 4, + 0, 0, 18741, 18742, 7, 6, 0, 0, 18742, 18743, 7, 3, 0, 0, 18743, 18744, + 7, 10, 0, 0, 18744, 18745, 7, 7, 0, 0, 18745, 18746, 7, 17, 0, 0, 18746, + 2556, 1, 0, 0, 0, 18747, 18748, 7, 2, 0, 0, 18748, 18749, 7, 3, 0, 0, 18749, + 18750, 7, 0, 0, 0, 18750, 18751, 7, 9, 0, 0, 18751, 18752, 7, 0, 0, 0, + 18752, 18753, 7, 4, 0, 0, 18753, 18754, 7, 0, 0, 0, 18754, 2558, 1, 0, + 0, 0, 18755, 18756, 7, 2, 0, 0, 18756, 18757, 7, 3, 0, 0, 18757, 18758, + 7, 8, 0, 0, 18758, 2560, 1, 0, 0, 0, 18759, 18760, 7, 2, 0, 0, 18760, 18761, + 7, 3, 0, 0, 18761, 18762, 7, 0, 0, 0, 18762, 18763, 7, 8, 0, 0, 18763, + 18764, 7, 11, 0, 0, 18764, 18765, 7, 6, 0, 0, 18765, 18766, 5, 95, 0, 0, + 18766, 18767, 7, 9, 0, 0, 18767, 18768, 7, 0, 0, 0, 18768, 18769, 7, 4, + 0, 0, 18769, 18770, 7, 6, 0, 0, 18770, 2562, 1, 0, 0, 0, 18771, 18772, + 7, 2, 0, 0, 18772, 18773, 7, 3, 0, 0, 18773, 18774, 7, 0, 0, 0, 18774, + 18775, 7, 8, 0, 0, 18775, 18776, 7, 11, 0, 0, 18776, 18777, 7, 6, 0, 0, + 18777, 18778, 5, 95, 0, 0, 18778, 18779, 7, 7, 0, 0, 18779, 18780, 7, 12, + 0, 0, 18780, 18781, 7, 14, 0, 0, 18781, 18782, 7, 1, 0, 0, 18782, 18783, + 7, 6, 0, 0, 18783, 18784, 7, 3, 0, 0, 18784, 2564, 1, 0, 0, 0, 18785, 18786, + 7, 2, 0, 0, 18786, 18787, 7, 3, 0, 0, 18787, 18788, 7, 0, 0, 0, 18788, + 18789, 7, 9, 0, 0, 18789, 18790, 7, 6, 0, 0, 18790, 18791, 7, 1, 0, 0, + 18791, 18792, 7, 12, 0, 0, 18792, 18793, 7, 17, 0, 0, 18793, 2566, 1, 0, + 0, 0, 18794, 18795, 7, 2, 0, 0, 18795, 18796, 7, 3, 0, 0, 18796, 18797, + 7, 0, 0, 0, 18797, 18798, 5, 95, 0, 0, 18798, 18799, 7, 9, 0, 0, 18799, + 18800, 7, 5, 0, 0, 18800, 18801, 7, 4, 0, 0, 18801, 18802, 5, 95, 0, 0, + 18802, 18803, 7, 0, 0, 0, 18803, 18804, 7, 16, 0, 0, 18804, 18805, 7, 16, + 0, 0, 18805, 18806, 7, 6, 0, 0, 18806, 18807, 7, 8, 0, 0, 18807, 18808, + 7, 4, 0, 0, 18808, 18809, 7, 6, 0, 0, 18809, 18810, 7, 9, 0, 0, 18810, + 2568, 1, 0, 0, 0, 18811, 18812, 7, 2, 0, 0, 18812, 18813, 7, 3, 0, 0, 18813, + 18814, 7, 0, 0, 0, 18814, 18815, 5, 95, 0, 0, 18815, 18816, 7, 9, 0, 0, + 18816, 18817, 7, 5, 0, 0, 18817, 18818, 7, 4, 0, 0, 18818, 18819, 5, 95, + 0, 0, 18819, 18820, 7, 8, 0, 0, 18820, 18821, 7, 2, 0, 0, 18821, 18822, + 7, 7, 0, 0, 18822, 18823, 7, 13, 0, 0, 18823, 18824, 7, 6, 0, 0, 18824, + 18825, 7, 3, 0, 0, 18825, 18826, 7, 4, 0, 0, 18826, 2570, 1, 0, 0, 0, 18827, + 18828, 7, 2, 0, 0, 18828, 18829, 7, 3, 0, 0, 18829, 18830, 7, 0, 0, 0, + 18830, 18831, 5, 95, 0, 0, 18831, 18832, 7, 9, 0, 0, 18832, 18833, 7, 5, + 0, 0, 18833, 18834, 7, 4, 0, 0, 18834, 18835, 5, 95, 0, 0, 18835, 18836, + 7, 6, 0, 0, 18836, 18837, 7, 3, 0, 0, 18837, 18838, 7, 3, 0, 0, 18838, + 18839, 7, 2, 0, 0, 18839, 18840, 7, 3, 0, 0, 18840, 2572, 1, 0, 0, 0, 18841, + 18842, 7, 2, 0, 0, 18842, 18843, 7, 3, 0, 0, 18843, 18844, 7, 0, 0, 0, + 18844, 18845, 5, 95, 0, 0, 18845, 18846, 7, 17, 0, 0, 18846, 18847, 7, + 6, 0, 0, 18847, 18848, 7, 4, 0, 0, 18848, 18849, 5, 95, 0, 0, 18849, 18850, + 7, 0, 0, 0, 18850, 18851, 7, 8, 0, 0, 18851, 18852, 7, 11, 0, 0, 18852, + 18853, 7, 10, 0, 0, 18853, 18854, 7, 9, 0, 0, 18854, 18855, 7, 5, 0, 0, + 18855, 2574, 1, 0, 0, 0, 18856, 18857, 7, 2, 0, 0, 18857, 18858, 7, 3, + 0, 0, 18858, 18859, 7, 0, 0, 0, 18859, 18860, 5, 95, 0, 0, 18860, 18861, + 7, 17, 0, 0, 18861, 18862, 7, 6, 0, 0, 18862, 18863, 7, 4, 0, 0, 18863, + 18864, 5, 95, 0, 0, 18864, 18865, 7, 15, 0, 0, 18865, 18866, 7, 3, 0, 0, + 18866, 18867, 7, 10, 0, 0, 18867, 18868, 7, 13, 0, 0, 18868, 18869, 7, + 10, 0, 0, 18869, 18870, 7, 11, 0, 0, 18870, 18871, 7, 6, 0, 0, 18871, 18872, + 7, 17, 0, 0, 18872, 18873, 7, 6, 0, 0, 18873, 18874, 7, 5, 0, 0, 18874, + 2576, 1, 0, 0, 0, 18875, 18876, 7, 2, 0, 0, 18876, 18877, 7, 3, 0, 0, 18877, + 18878, 7, 0, 0, 0, 18878, 18879, 5, 95, 0, 0, 18879, 18880, 7, 19, 0, 0, + 18880, 18881, 7, 0, 0, 0, 18881, 18882, 7, 5, 0, 0, 18882, 18883, 7, 19, + 0, 0, 18883, 2578, 1, 0, 0, 0, 18884, 18885, 7, 2, 0, 0, 18885, 18886, + 7, 3, 0, 0, 18886, 18887, 7, 0, 0, 0, 18887, 18888, 5, 95, 0, 0, 18888, + 18889, 7, 10, 0, 0, 18889, 18890, 7, 7, 0, 0, 18890, 18891, 7, 13, 0, 0, + 18891, 18892, 7, 2, 0, 0, 18892, 18893, 7, 21, 0, 0, 18893, 18894, 7, 10, + 0, 0, 18894, 18895, 7, 7, 0, 0, 18895, 18896, 7, 17, 0, 0, 18896, 18897, + 5, 95, 0, 0, 18897, 18898, 7, 12, 0, 0, 18898, 18899, 7, 5, 0, 0, 18899, + 18900, 7, 6, 0, 0, 18900, 18901, 7, 3, 0, 0, 18901, 18902, 7, 10, 0, 0, + 18902, 18903, 7, 9, 0, 0, 18903, 2580, 1, 0, 0, 0, 18904, 18905, 7, 2, + 0, 0, 18905, 18906, 7, 3, 0, 0, 18906, 18907, 7, 0, 0, 0, 18907, 18908, + 5, 95, 0, 0, 18908, 18909, 7, 10, 0, 0, 18909, 18910, 7, 7, 0, 0, 18910, + 18911, 7, 13, 0, 0, 18911, 18912, 7, 2, 0, 0, 18912, 18913, 7, 21, 0, 0, + 18913, 18914, 7, 10, 0, 0, 18914, 18915, 7, 7, 0, 0, 18915, 18916, 7, 17, + 0, 0, 18916, 18917, 5, 95, 0, 0, 18917, 18918, 7, 12, 0, 0, 18918, 18919, + 7, 5, 0, 0, 18919, 18920, 7, 6, 0, 0, 18920, 18921, 7, 3, 0, 0, 18921, + 2582, 1, 0, 0, 0, 18922, 18923, 7, 2, 0, 0, 18923, 18924, 7, 3, 0, 0, 18924, + 18925, 7, 0, 0, 0, 18925, 18926, 5, 95, 0, 0, 18926, 18927, 7, 10, 0, 0, + 18927, 18928, 7, 7, 0, 0, 18928, 18929, 7, 13, 0, 0, 18929, 18930, 7, 2, + 0, 0, 18930, 18931, 7, 21, 0, 0, 18931, 18932, 7, 10, 0, 0, 18932, 18933, + 7, 7, 0, 0, 18933, 18934, 7, 17, 0, 0, 18934, 18935, 5, 95, 0, 0, 18935, + 18936, 7, 25, 0, 0, 18936, 18937, 7, 5, 0, 0, 18937, 18938, 5, 95, 0, 0, + 18938, 18939, 7, 12, 0, 0, 18939, 18940, 7, 5, 0, 0, 18940, 18941, 7, 6, + 0, 0, 18941, 18942, 7, 3, 0, 0, 18942, 18943, 5, 95, 0, 0, 18943, 18944, + 7, 17, 0, 0, 18944, 18945, 7, 12, 0, 0, 18945, 18946, 7, 10, 0, 0, 18946, + 18947, 7, 9, 0, 0, 18947, 2584, 1, 0, 0, 0, 18948, 18949, 7, 2, 0, 0, 18949, + 18950, 7, 3, 0, 0, 18950, 18951, 7, 0, 0, 0, 18951, 18952, 5, 95, 0, 0, + 18952, 18953, 7, 10, 0, 0, 18953, 18954, 7, 7, 0, 0, 18954, 18955, 7, 13, + 0, 0, 18955, 18956, 7, 2, 0, 0, 18956, 18957, 7, 21, 0, 0, 18957, 18958, + 7, 10, 0, 0, 18958, 18959, 7, 7, 0, 0, 18959, 18960, 7, 17, 0, 0, 18960, + 18961, 5, 95, 0, 0, 18961, 18962, 7, 25, 0, 0, 18962, 18963, 7, 5, 0, 0, + 18963, 18964, 5, 95, 0, 0, 18964, 18965, 7, 12, 0, 0, 18965, 18966, 7, + 5, 0, 0, 18966, 18967, 7, 6, 0, 0, 18967, 18968, 7, 3, 0, 0, 18968, 2586, + 1, 0, 0, 0, 18969, 18970, 7, 2, 0, 0, 18970, 18971, 7, 3, 0, 0, 18971, + 18972, 7, 0, 0, 0, 18972, 18973, 5, 95, 0, 0, 18973, 18974, 7, 3, 0, 0, + 18974, 18975, 7, 0, 0, 0, 18975, 18976, 7, 22, 0, 0, 18976, 18977, 7, 8, + 0, 0, 18977, 18978, 7, 2, 0, 0, 18978, 18979, 7, 14, 0, 0, 18979, 18980, + 7, 15, 0, 0, 18980, 18981, 7, 0, 0, 0, 18981, 18982, 7, 3, 0, 0, 18982, + 18983, 7, 6, 0, 0, 18983, 2588, 1, 0, 0, 0, 18984, 18985, 7, 2, 0, 0, 18985, + 18986, 7, 3, 0, 0, 18986, 18987, 7, 0, 0, 0, 18987, 18988, 5, 95, 0, 0, + 18988, 18989, 7, 3, 0, 0, 18989, 18990, 7, 0, 0, 0, 18990, 18991, 7, 22, + 0, 0, 18991, 18992, 7, 8, 0, 0, 18992, 18993, 7, 2, 0, 0, 18993, 18994, + 7, 7, 0, 0, 18994, 18995, 7, 8, 0, 0, 18995, 18996, 7, 0, 0, 0, 18996, + 18997, 7, 4, 0, 0, 18997, 2590, 1, 0, 0, 0, 18998, 18999, 7, 2, 0, 0, 18999, + 19000, 7, 3, 0, 0, 19000, 19001, 7, 0, 0, 0, 19001, 19002, 5, 95, 0, 0, + 19002, 19003, 7, 3, 0, 0, 19003, 19004, 7, 2, 0, 0, 19004, 19005, 7, 22, + 0, 0, 19005, 19006, 7, 5, 0, 0, 19006, 19007, 7, 8, 0, 0, 19007, 19008, + 7, 7, 0, 0, 19008, 2592, 1, 0, 0, 0, 19009, 19010, 7, 2, 0, 0, 19010, 19011, + 7, 3, 0, 0, 19011, 19012, 7, 0, 0, 0, 19012, 19013, 5, 95, 0, 0, 19013, + 19014, 7, 3, 0, 0, 19014, 19015, 7, 2, 0, 0, 19015, 19016, 7, 22, 0, 0, + 19016, 19017, 7, 5, 0, 0, 19017, 19018, 7, 8, 0, 0, 19018, 19019, 7, 7, + 0, 0, 19019, 19020, 5, 95, 0, 0, 19020, 19021, 7, 3, 0, 0, 19021, 19022, + 7, 0, 0, 0, 19022, 19023, 7, 22, 0, 0, 19023, 2594, 1, 0, 0, 0, 19024, + 19025, 7, 2, 0, 0, 19025, 19026, 7, 3, 0, 0, 19026, 19027, 7, 0, 0, 0, + 19027, 19028, 5, 95, 0, 0, 19028, 19029, 7, 3, 0, 0, 19029, 19030, 7, 2, + 0, 0, 19030, 19031, 7, 22, 0, 0, 19031, 19032, 7, 13, 0, 0, 19032, 19033, + 7, 6, 0, 0, 19033, 19034, 7, 3, 0, 0, 19034, 19035, 7, 5, 0, 0, 19035, + 19036, 7, 10, 0, 0, 19036, 19037, 7, 2, 0, 0, 19037, 19038, 7, 7, 0, 0, + 19038, 2596, 1, 0, 0, 0, 19039, 19040, 7, 2, 0, 0, 19040, 19041, 7, 3, + 0, 0, 19041, 19042, 7, 0, 0, 0, 19042, 19043, 5, 95, 0, 0, 19043, 19044, + 7, 4, 0, 0, 19044, 19045, 7, 0, 0, 0, 19045, 19046, 7, 1, 0, 0, 19046, + 19047, 7, 13, 0, 0, 19047, 19048, 7, 6, 0, 0, 19048, 19049, 7, 3, 0, 0, + 19049, 19050, 7, 5, 0, 0, 19050, 19051, 7, 10, 0, 0, 19051, 19052, 7, 2, + 0, 0, 19052, 19053, 7, 7, 0, 0, 19053, 2598, 1, 0, 0, 0, 19054, 19055, + 7, 2, 0, 0, 19055, 19056, 7, 3, 0, 0, 19056, 19057, 7, 0, 0, 0, 19057, + 19058, 5, 95, 0, 0, 19058, 19059, 7, 22, 0, 0, 19059, 19060, 7, 3, 0, 0, + 19060, 19061, 7, 10, 0, 0, 19061, 19062, 7, 4, 0, 0, 19062, 19063, 7, 6, + 0, 0, 19063, 19064, 5, 95, 0, 0, 19064, 19065, 7, 4, 0, 0, 19065, 19066, + 7, 10, 0, 0, 19066, 19067, 7, 14, 0, 0, 19067, 19068, 7, 6, 0, 0, 19068, + 2600, 1, 0, 0, 0, 19069, 19070, 7, 2, 0, 0, 19070, 19071, 7, 3, 0, 0, 19071, + 19072, 7, 9, 0, 0, 19072, 19073, 7, 6, 0, 0, 19073, 19074, 7, 3, 0, 0, + 19074, 19075, 7, 6, 0, 0, 19075, 19076, 7, 9, 0, 0, 19076, 2602, 1, 0, + 0, 0, 19077, 19078, 7, 2, 0, 0, 19078, 19079, 7, 3, 0, 0, 19079, 19080, + 7, 9, 0, 0, 19080, 19081, 7, 6, 0, 0, 19081, 19082, 7, 3, 0, 0, 19082, + 19083, 7, 6, 0, 0, 19083, 19084, 7, 9, 0, 0, 19084, 19085, 5, 95, 0, 0, + 19085, 19086, 7, 15, 0, 0, 19086, 19087, 7, 3, 0, 0, 19087, 19088, 7, 6, + 0, 0, 19088, 19089, 7, 9, 0, 0, 19089, 19090, 7, 10, 0, 0, 19090, 19091, + 7, 8, 0, 0, 19091, 19092, 7, 0, 0, 0, 19092, 19093, 7, 4, 0, 0, 19093, + 19094, 7, 6, 0, 0, 19094, 19095, 7, 5, 0, 0, 19095, 2604, 1, 0, 0, 0, 19096, + 19097, 7, 2, 0, 0, 19097, 19098, 7, 3, 0, 0, 19098, 19099, 7, 9, 0, 0, + 19099, 19100, 7, 6, 0, 0, 19100, 19101, 7, 3, 0, 0, 19101, 2606, 1, 0, + 0, 0, 19102, 19103, 7, 2, 0, 0, 19103, 19104, 7, 3, 0, 0, 19104, 19105, + 7, 9, 0, 0, 19105, 19106, 7, 10, 0, 0, 19106, 19107, 7, 7, 0, 0, 19107, + 19108, 7, 0, 0, 0, 19108, 19109, 7, 11, 0, 0, 19109, 19110, 7, 10, 0, 0, + 19110, 19111, 7, 4, 0, 0, 19111, 19112, 7, 18, 0, 0, 19112, 2608, 1, 0, + 0, 0, 19113, 19114, 7, 2, 0, 0, 19114, 19115, 7, 3, 0, 0, 19115, 19116, + 5, 95, 0, 0, 19116, 19117, 7, 6, 0, 0, 19117, 19118, 7, 25, 0, 0, 19118, + 19119, 7, 15, 0, 0, 19119, 19120, 7, 0, 0, 0, 19120, 19121, 7, 7, 0, 0, + 19121, 19122, 7, 9, 0, 0, 19122, 2610, 1, 0, 0, 0, 19123, 19124, 7, 2, + 0, 0, 19124, 19125, 7, 3, 0, 0, 19125, 19126, 7, 17, 0, 0, 19126, 19127, + 7, 0, 0, 0, 19127, 19128, 7, 7, 0, 0, 19128, 19129, 7, 10, 0, 0, 19129, + 19130, 7, 23, 0, 0, 19130, 19131, 7, 0, 0, 0, 19131, 19132, 7, 4, 0, 0, + 19132, 19133, 7, 10, 0, 0, 19133, 19134, 7, 2, 0, 0, 19134, 19135, 7, 7, + 0, 0, 19135, 2612, 1, 0, 0, 0, 19136, 19137, 7, 2, 0, 0, 19137, 19138, + 7, 3, 0, 0, 19138, 2614, 1, 0, 0, 0, 19139, 19140, 7, 2, 0, 0, 19140, 19141, + 7, 3, 0, 0, 19141, 19142, 5, 95, 0, 0, 19142, 19143, 7, 15, 0, 0, 19143, + 19144, 7, 3, 0, 0, 19144, 19145, 7, 6, 0, 0, 19145, 19146, 7, 9, 0, 0, + 19146, 19147, 7, 10, 0, 0, 19147, 19148, 7, 8, 0, 0, 19148, 19149, 7, 0, + 0, 0, 19149, 19150, 7, 4, 0, 0, 19150, 19151, 7, 6, 0, 0, 19151, 19152, + 7, 5, 0, 0, 19152, 2616, 1, 0, 0, 0, 19153, 19154, 7, 2, 0, 0, 19154, 19155, + 7, 5, 0, 0, 19155, 19156, 7, 6, 0, 0, 19156, 19157, 7, 3, 0, 0, 19157, + 19158, 7, 3, 0, 0, 19158, 19159, 7, 2, 0, 0, 19159, 19160, 7, 3, 0, 0, + 19160, 2618, 1, 0, 0, 0, 19161, 19162, 7, 2, 0, 0, 19162, 19163, 7, 4, + 0, 0, 19163, 19164, 7, 19, 0, 0, 19164, 19165, 7, 6, 0, 0, 19165, 19166, + 7, 3, 0, 0, 19166, 2620, 1, 0, 0, 0, 19167, 19168, 7, 2, 0, 0, 19168, 19169, + 7, 12, 0, 0, 19169, 19170, 7, 4, 0, 0, 19170, 19171, 7, 6, 0, 0, 19171, + 19172, 7, 3, 0, 0, 19172, 19173, 5, 95, 0, 0, 19173, 19174, 7, 20, 0, 0, + 19174, 19175, 7, 2, 0, 0, 19175, 19176, 7, 10, 0, 0, 19176, 19177, 7, 7, + 0, 0, 19177, 19178, 5, 95, 0, 0, 19178, 19179, 7, 4, 0, 0, 19179, 19180, + 7, 2, 0, 0, 19180, 19181, 5, 95, 0, 0, 19181, 19182, 7, 0, 0, 0, 19182, + 19183, 7, 7, 0, 0, 19183, 19184, 7, 4, 0, 0, 19184, 19185, 7, 10, 0, 0, + 19185, 2622, 1, 0, 0, 0, 19186, 19187, 7, 2, 0, 0, 19187, 19188, 7, 12, + 0, 0, 19188, 19189, 7, 4, 0, 0, 19189, 19190, 7, 6, 0, 0, 19190, 19191, + 7, 3, 0, 0, 19191, 19192, 5, 95, 0, 0, 19192, 19193, 7, 20, 0, 0, 19193, + 19194, 7, 2, 0, 0, 19194, 19195, 7, 10, 0, 0, 19195, 19196, 7, 7, 0, 0, + 19196, 19197, 5, 95, 0, 0, 19197, 19198, 7, 4, 0, 0, 19198, 19199, 7, 2, + 0, 0, 19199, 19200, 5, 95, 0, 0, 19200, 19201, 7, 10, 0, 0, 19201, 19202, + 7, 7, 0, 0, 19202, 19203, 7, 7, 0, 0, 19203, 19204, 7, 6, 0, 0, 19204, + 19205, 7, 3, 0, 0, 19205, 2624, 1, 0, 0, 0, 19206, 19207, 7, 2, 0, 0, 19207, + 19208, 7, 12, 0, 0, 19208, 19209, 7, 4, 0, 0, 19209, 19210, 7, 6, 0, 0, + 19210, 19211, 7, 3, 0, 0, 19211, 2626, 1, 0, 0, 0, 19212, 19213, 7, 2, + 0, 0, 19213, 19214, 7, 12, 0, 0, 19214, 19215, 7, 4, 0, 0, 19215, 19216, + 7, 11, 0, 0, 19216, 19217, 7, 10, 0, 0, 19217, 19218, 7, 7, 0, 0, 19218, + 19219, 7, 6, 0, 0, 19219, 19220, 5, 95, 0, 0, 19220, 19221, 7, 11, 0, 0, + 19221, 19222, 7, 6, 0, 0, 19222, 19223, 7, 0, 0, 0, 19223, 19224, 7, 16, + 0, 0, 19224, 2628, 1, 0, 0, 0, 19225, 19226, 7, 2, 0, 0, 19226, 19227, + 7, 12, 0, 0, 19227, 19228, 7, 4, 0, 0, 19228, 19229, 7, 11, 0, 0, 19229, + 19230, 7, 10, 0, 0, 19230, 19231, 7, 7, 0, 0, 19231, 19232, 7, 6, 0, 0, + 19232, 2630, 1, 0, 0, 0, 19233, 19234, 7, 2, 0, 0, 19234, 19235, 7, 12, + 0, 0, 19235, 19236, 7, 4, 0, 0, 19236, 19237, 7, 15, 0, 0, 19237, 19238, + 7, 12, 0, 0, 19238, 19239, 7, 4, 0, 0, 19239, 19240, 7, 16, 0, 0, 19240, + 19241, 7, 2, 0, 0, 19241, 19242, 7, 3, 0, 0, 19242, 19243, 7, 14, 0, 0, + 19243, 19244, 7, 0, 0, 0, 19244, 19245, 7, 4, 0, 0, 19245, 2632, 1, 0, + 0, 0, 19246, 19247, 7, 2, 0, 0, 19247, 19248, 7, 12, 0, 0, 19248, 19249, + 7, 4, 0, 0, 19249, 19250, 5, 95, 0, 0, 19250, 19251, 7, 2, 0, 0, 19251, + 19252, 7, 16, 0, 0, 19252, 19253, 5, 95, 0, 0, 19253, 19254, 7, 11, 0, + 0, 19254, 19255, 7, 10, 0, 0, 19255, 19256, 7, 7, 0, 0, 19256, 19257, 7, + 6, 0, 0, 19257, 2634, 1, 0, 0, 0, 19258, 19259, 7, 2, 0, 0, 19259, 19260, + 7, 12, 0, 0, 19260, 19261, 7, 4, 0, 0, 19261, 2636, 1, 0, 0, 0, 19262, + 19263, 7, 2, 0, 0, 19263, 19264, 7, 13, 0, 0, 19264, 19265, 7, 6, 0, 0, + 19265, 19266, 7, 3, 0, 0, 19266, 19267, 7, 16, 0, 0, 19267, 19268, 7, 11, + 0, 0, 19268, 19269, 7, 2, 0, 0, 19269, 19270, 7, 22, 0, 0, 19270, 19271, + 5, 95, 0, 0, 19271, 19272, 7, 7, 0, 0, 19272, 19273, 7, 2, 0, 0, 19273, + 19274, 7, 14, 0, 0, 19274, 19275, 7, 2, 0, 0, 19275, 19276, 7, 13, 0, 0, + 19276, 19277, 7, 6, 0, 0, 19277, 2638, 1, 0, 0, 0, 19278, 19279, 7, 2, + 0, 0, 19279, 19280, 7, 13, 0, 0, 19280, 19281, 7, 6, 0, 0, 19281, 19282, + 7, 3, 0, 0, 19282, 19283, 7, 16, 0, 0, 19283, 19284, 7, 11, 0, 0, 19284, + 19285, 7, 2, 0, 0, 19285, 19286, 7, 22, 0, 0, 19286, 2640, 1, 0, 0, 0, + 19287, 19288, 7, 2, 0, 0, 19288, 19289, 7, 13, 0, 0, 19289, 19290, 7, 6, + 0, 0, 19290, 19291, 7, 3, 0, 0, 19291, 19292, 7, 11, 0, 0, 19292, 19293, + 7, 0, 0, 0, 19293, 19294, 7, 15, 0, 0, 19294, 19295, 7, 5, 0, 0, 19295, + 2642, 1, 0, 0, 0, 19296, 19297, 7, 2, 0, 0, 19297, 19298, 7, 13, 0, 0, + 19298, 19299, 7, 6, 0, 0, 19299, 19300, 7, 3, 0, 0, 19300, 2644, 1, 0, + 0, 0, 19301, 19302, 7, 2, 0, 0, 19302, 19303, 7, 13, 0, 0, 19303, 19304, + 7, 6, 0, 0, 19304, 19305, 7, 3, 0, 0, 19305, 19306, 7, 3, 0, 0, 19306, + 19307, 7, 10, 0, 0, 19307, 19308, 7, 9, 0, 0, 19308, 19309, 7, 6, 0, 0, + 19309, 2646, 1, 0, 0, 0, 19310, 19311, 7, 2, 0, 0, 19311, 19312, 7, 13, + 0, 0, 19312, 19313, 7, 6, 0, 0, 19313, 19314, 7, 3, 0, 0, 19314, 19315, + 7, 3, 0, 0, 19315, 19316, 7, 10, 0, 0, 19316, 19317, 7, 9, 0, 0, 19317, + 19318, 7, 10, 0, 0, 19318, 19319, 7, 7, 0, 0, 19319, 19320, 7, 17, 0, 0, + 19320, 2648, 1, 0, 0, 0, 19321, 19322, 7, 2, 0, 0, 19322, 19323, 7, 22, + 0, 0, 19323, 19324, 7, 7, 0, 0, 19324, 19325, 7, 6, 0, 0, 19325, 19326, + 7, 3, 0, 0, 19326, 2650, 1, 0, 0, 0, 19327, 19328, 7, 2, 0, 0, 19328, 19329, + 7, 22, 0, 0, 19329, 19330, 7, 7, 0, 0, 19330, 19331, 7, 6, 0, 0, 19331, + 19332, 7, 3, 0, 0, 19332, 19333, 7, 5, 0, 0, 19333, 19334, 7, 19, 0, 0, + 19334, 19335, 7, 10, 0, 0, 19335, 19336, 7, 15, 0, 0, 19336, 2652, 1, 0, + 0, 0, 19337, 19338, 7, 2, 0, 0, 19338, 19339, 7, 22, 0, 0, 19339, 19340, + 7, 7, 0, 0, 19340, 2654, 1, 0, 0, 0, 19341, 19342, 7, 15, 0, 0, 19342, + 2656, 1, 0, 0, 0, 19343, 19344, 7, 15, 0, 0, 19344, 19345, 7, 0, 0, 0, + 19345, 19346, 7, 8, 0, 0, 19346, 19347, 7, 21, 0, 0, 19347, 19348, 7, 0, + 0, 0, 19348, 19349, 7, 17, 0, 0, 19349, 19350, 7, 6, 0, 0, 19350, 2658, + 1, 0, 0, 0, 19351, 19352, 7, 15, 0, 0, 19352, 19353, 7, 0, 0, 0, 19353, + 19354, 7, 8, 0, 0, 19354, 19355, 7, 21, 0, 0, 19355, 19356, 7, 0, 0, 0, + 19356, 19357, 7, 17, 0, 0, 19357, 19358, 7, 6, 0, 0, 19358, 19359, 7, 5, + 0, 0, 19359, 2660, 1, 0, 0, 0, 19360, 19361, 7, 15, 0, 0, 19361, 19362, + 7, 0, 0, 0, 19362, 19363, 7, 3, 0, 0, 19363, 19364, 7, 0, 0, 0, 19364, + 19365, 7, 11, 0, 0, 19365, 19366, 7, 11, 0, 0, 19366, 19367, 7, 6, 0, 0, + 19367, 19368, 7, 11, 0, 0, 19368, 19369, 5, 95, 0, 0, 19369, 19370, 7, + 6, 0, 0, 19370, 19371, 7, 7, 0, 0, 19371, 19372, 7, 0, 0, 0, 19372, 19373, + 7, 1, 0, 0, 19373, 19374, 7, 11, 0, 0, 19374, 19375, 7, 6, 0, 0, 19375, + 2662, 1, 0, 0, 0, 19376, 19377, 7, 15, 0, 0, 19377, 19378, 7, 0, 0, 0, + 19378, 19379, 7, 3, 0, 0, 19379, 19380, 7, 0, 0, 0, 19380, 19381, 7, 11, + 0, 0, 19381, 19382, 7, 11, 0, 0, 19382, 19383, 7, 6, 0, 0, 19383, 19384, + 7, 11, 0, 0, 19384, 19385, 5, 95, 0, 0, 19385, 19386, 7, 10, 0, 0, 19386, + 19387, 7, 7, 0, 0, 19387, 19388, 7, 9, 0, 0, 19388, 19389, 7, 6, 0, 0, + 19389, 19390, 7, 25, 0, 0, 19390, 2664, 1, 0, 0, 0, 19391, 19392, 7, 15, + 0, 0, 19392, 19393, 7, 0, 0, 0, 19393, 19394, 7, 3, 0, 0, 19394, 19395, + 7, 0, 0, 0, 19395, 19396, 7, 11, 0, 0, 19396, 19397, 7, 11, 0, 0, 19397, + 19398, 7, 6, 0, 0, 19398, 19399, 7, 11, 0, 0, 19399, 2666, 1, 0, 0, 0, + 19400, 19401, 7, 15, 0, 0, 19401, 19402, 7, 0, 0, 0, 19402, 19403, 7, 3, + 0, 0, 19403, 19404, 7, 0, 0, 0, 19404, 19405, 7, 14, 0, 0, 19405, 19406, + 7, 6, 0, 0, 19406, 19407, 7, 4, 0, 0, 19407, 19408, 7, 6, 0, 0, 19408, + 19409, 7, 3, 0, 0, 19409, 19410, 7, 16, 0, 0, 19410, 19411, 7, 10, 0, 0, + 19411, 19412, 7, 11, 0, 0, 19412, 19413, 7, 6, 0, 0, 19413, 2668, 1, 0, + 0, 0, 19414, 19415, 7, 15, 0, 0, 19415, 19416, 7, 0, 0, 0, 19416, 19417, + 7, 3, 0, 0, 19417, 19418, 7, 0, 0, 0, 19418, 19419, 7, 14, 0, 0, 19419, + 19420, 7, 6, 0, 0, 19420, 19421, 7, 4, 0, 0, 19421, 19422, 7, 6, 0, 0, + 19422, 19423, 7, 3, 0, 0, 19423, 19424, 7, 5, 0, 0, 19424, 2670, 1, 0, + 0, 0, 19425, 19426, 7, 15, 0, 0, 19426, 19427, 7, 0, 0, 0, 19427, 19428, + 7, 3, 0, 0, 19428, 19429, 7, 0, 0, 0, 19429, 19430, 7, 14, 0, 0, 19430, + 2672, 1, 0, 0, 0, 19431, 19432, 7, 15, 0, 0, 19432, 19433, 7, 0, 0, 0, + 19433, 19434, 7, 3, 0, 0, 19434, 19435, 7, 6, 0, 0, 19435, 19436, 7, 7, + 0, 0, 19436, 19437, 7, 4, 0, 0, 19437, 2674, 1, 0, 0, 0, 19438, 19439, + 7, 15, 0, 0, 19439, 19440, 7, 0, 0, 0, 19440, 19441, 7, 3, 0, 0, 19441, + 19442, 7, 6, 0, 0, 19442, 19443, 7, 7, 0, 0, 19443, 19444, 7, 4, 0, 0, + 19444, 19445, 5, 95, 0, 0, 19445, 19446, 7, 11, 0, 0, 19446, 19447, 7, + 6, 0, 0, 19447, 19448, 7, 13, 0, 0, 19448, 19449, 7, 6, 0, 0, 19449, 19450, + 7, 11, 0, 0, 19450, 19451, 5, 95, 0, 0, 19451, 19452, 7, 7, 0, 0, 19452, + 19453, 7, 0, 0, 0, 19453, 19454, 7, 14, 0, 0, 19454, 19455, 7, 6, 0, 0, + 19455, 2676, 1, 0, 0, 0, 19456, 19457, 7, 15, 0, 0, 19457, 19458, 7, 0, + 0, 0, 19458, 19459, 7, 3, 0, 0, 19459, 19460, 7, 6, 0, 0, 19460, 19461, + 7, 7, 0, 0, 19461, 19462, 7, 4, 0, 0, 19462, 19463, 5, 95, 0, 0, 19463, + 19464, 7, 12, 0, 0, 19464, 19465, 7, 7, 0, 0, 19465, 19466, 7, 10, 0, 0, + 19466, 19467, 7, 24, 0, 0, 19467, 19468, 7, 12, 0, 0, 19468, 19469, 7, + 6, 0, 0, 19469, 19470, 5, 95, 0, 0, 19470, 19471, 7, 7, 0, 0, 19471, 19472, + 7, 0, 0, 0, 19472, 19473, 7, 14, 0, 0, 19473, 19474, 7, 6, 0, 0, 19474, + 2678, 1, 0, 0, 0, 19475, 19476, 7, 15, 0, 0, 19476, 19477, 7, 0, 0, 0, + 19477, 19478, 7, 3, 0, 0, 19478, 19479, 7, 10, 0, 0, 19479, 19480, 7, 4, + 0, 0, 19480, 19481, 7, 18, 0, 0, 19481, 2680, 1, 0, 0, 0, 19482, 19483, + 7, 15, 0, 0, 19483, 19484, 7, 0, 0, 0, 19484, 19485, 7, 3, 0, 0, 19485, + 19486, 7, 24, 0, 0, 19486, 19487, 7, 12, 0, 0, 19487, 19488, 7, 6, 0, 0, + 19488, 19489, 7, 4, 0, 0, 19489, 2682, 1, 0, 0, 0, 19490, 19491, 7, 15, + 0, 0, 19491, 19492, 7, 0, 0, 0, 19492, 19493, 7, 3, 0, 0, 19493, 19494, + 7, 4, 0, 0, 19494, 19495, 7, 10, 0, 0, 19495, 19496, 7, 0, 0, 0, 19496, + 19497, 7, 11, 0, 0, 19497, 19498, 5, 95, 0, 0, 19498, 19499, 7, 20, 0, + 0, 19499, 19500, 7, 2, 0, 0, 19500, 19501, 7, 10, 0, 0, 19501, 19502, 7, + 7, 0, 0, 19502, 2684, 1, 0, 0, 0, 19503, 19504, 7, 15, 0, 0, 19504, 19505, + 7, 0, 0, 0, 19505, 19506, 7, 3, 0, 0, 19506, 19507, 7, 4, 0, 0, 19507, + 19508, 7, 10, 0, 0, 19508, 19509, 7, 0, 0, 0, 19509, 19510, 7, 11, 0, 0, + 19510, 19511, 7, 11, 0, 0, 19511, 19512, 7, 18, 0, 0, 19512, 2686, 1, 0, + 0, 0, 19513, 19514, 7, 15, 0, 0, 19514, 19515, 7, 0, 0, 0, 19515, 19516, + 7, 3, 0, 0, 19516, 19517, 7, 4, 0, 0, 19517, 19518, 7, 10, 0, 0, 19518, + 19519, 7, 0, 0, 0, 19519, 19520, 7, 11, 0, 0, 19520, 2688, 1, 0, 0, 0, + 19521, 19522, 7, 15, 0, 0, 19522, 19523, 7, 0, 0, 0, 19523, 19524, 7, 3, + 0, 0, 19524, 19525, 7, 4, 0, 0, 19525, 19526, 7, 10, 0, 0, 19526, 19527, + 7, 0, 0, 0, 19527, 19528, 7, 11, 0, 0, 19528, 19529, 5, 95, 0, 0, 19529, + 19530, 7, 3, 0, 0, 19530, 19531, 7, 2, 0, 0, 19531, 19532, 7, 11, 0, 0, + 19532, 19533, 7, 11, 0, 0, 19533, 19534, 7, 12, 0, 0, 19534, 19535, 7, + 15, 0, 0, 19535, 19536, 5, 95, 0, 0, 19536, 19537, 7, 15, 0, 0, 19537, + 19538, 7, 12, 0, 0, 19538, 19539, 7, 5, 0, 0, 19539, 19540, 7, 19, 0, 0, + 19540, 19541, 7, 9, 0, 0, 19541, 19542, 7, 2, 0, 0, 19542, 19543, 7, 22, + 0, 0, 19543, 19544, 7, 7, 0, 0, 19544, 2690, 1, 0, 0, 0, 19545, 19546, + 7, 15, 0, 0, 19546, 19547, 7, 0, 0, 0, 19547, 19548, 7, 3, 0, 0, 19548, + 19549, 7, 4, 0, 0, 19549, 19550, 7, 10, 0, 0, 19550, 19551, 7, 4, 0, 0, + 19551, 19552, 7, 10, 0, 0, 19552, 19553, 7, 2, 0, 0, 19553, 19554, 7, 7, + 0, 0, 19554, 19555, 5, 95, 0, 0, 19555, 19556, 7, 19, 0, 0, 19556, 19557, + 7, 0, 0, 0, 19557, 19558, 7, 5, 0, 0, 19558, 19559, 7, 19, 0, 0, 19559, + 2692, 1, 0, 0, 0, 19560, 19561, 7, 15, 0, 0, 19561, 19562, 7, 0, 0, 0, + 19562, 19563, 7, 3, 0, 0, 19563, 19564, 7, 4, 0, 0, 19564, 19565, 7, 10, + 0, 0, 19565, 19566, 7, 4, 0, 0, 19566, 19567, 7, 10, 0, 0, 19567, 19568, + 7, 2, 0, 0, 19568, 19569, 7, 7, 0, 0, 19569, 19570, 5, 95, 0, 0, 19570, + 19571, 7, 11, 0, 0, 19571, 19572, 7, 10, 0, 0, 19572, 19573, 7, 5, 0, 0, + 19573, 19574, 7, 4, 0, 0, 19574, 2694, 1, 0, 0, 0, 19575, 19576, 7, 15, + 0, 0, 19576, 19577, 7, 0, 0, 0, 19577, 19578, 7, 3, 0, 0, 19578, 19579, + 7, 4, 0, 0, 19579, 19580, 7, 10, 0, 0, 19580, 19581, 7, 4, 0, 0, 19581, + 19582, 7, 10, 0, 0, 19582, 19583, 7, 2, 0, 0, 19583, 19584, 7, 7, 0, 0, + 19584, 2696, 1, 0, 0, 0, 19585, 19586, 7, 15, 0, 0, 19586, 19587, 7, 0, + 0, 0, 19587, 19588, 7, 3, 0, 0, 19588, 19589, 7, 4, 0, 0, 19589, 19590, + 7, 10, 0, 0, 19590, 19591, 7, 4, 0, 0, 19591, 19592, 7, 10, 0, 0, 19592, + 19593, 7, 2, 0, 0, 19593, 19594, 7, 7, 0, 0, 19594, 19595, 5, 95, 0, 0, + 19595, 19596, 7, 3, 0, 0, 19596, 19597, 7, 0, 0, 0, 19597, 19598, 7, 7, + 0, 0, 19598, 19599, 7, 17, 0, 0, 19599, 19600, 7, 6, 0, 0, 19600, 2698, + 1, 0, 0, 0, 19601, 19602, 7, 15, 0, 0, 19602, 19603, 7, 0, 0, 0, 19603, + 19604, 7, 3, 0, 0, 19604, 19605, 7, 4, 0, 0, 19605, 19606, 7, 10, 0, 0, + 19606, 19607, 7, 4, 0, 0, 19607, 19608, 7, 10, 0, 0, 19608, 19609, 7, 2, + 0, 0, 19609, 19610, 7, 7, 0, 0, 19610, 19611, 7, 5, 0, 0, 19611, 2700, + 1, 0, 0, 0, 19612, 19613, 7, 15, 0, 0, 19613, 19614, 7, 0, 0, 0, 19614, + 19615, 7, 3, 0, 0, 19615, 19616, 7, 4, 0, 0, 19616, 19617, 5, 36, 0, 0, + 19617, 19618, 7, 7, 0, 0, 19618, 19619, 7, 12, 0, 0, 19619, 19620, 7, 14, + 0, 0, 19620, 19621, 5, 36, 0, 0, 19621, 19622, 7, 10, 0, 0, 19622, 19623, + 7, 7, 0, 0, 19623, 19624, 7, 5, 0, 0, 19624, 19625, 7, 4, 0, 0, 19625, + 2702, 1, 0, 0, 0, 19626, 19627, 7, 15, 0, 0, 19627, 19628, 7, 0, 0, 0, + 19628, 19629, 7, 5, 0, 0, 19629, 19630, 7, 5, 0, 0, 19630, 19631, 7, 10, + 0, 0, 19631, 19632, 7, 7, 0, 0, 19632, 19633, 7, 17, 0, 0, 19633, 2704, + 1, 0, 0, 0, 19634, 19635, 7, 15, 0, 0, 19635, 19636, 7, 0, 0, 0, 19636, + 19637, 7, 5, 0, 0, 19637, 19638, 7, 5, 0, 0, 19638, 19639, 7, 22, 0, 0, + 19639, 19640, 7, 2, 0, 0, 19640, 19641, 7, 3, 0, 0, 19641, 19642, 7, 9, + 0, 0, 19642, 19643, 5, 95, 0, 0, 19643, 19644, 7, 17, 0, 0, 19644, 19645, + 7, 3, 0, 0, 19645, 19646, 7, 0, 0, 0, 19646, 19647, 7, 8, 0, 0, 19647, + 19648, 7, 6, 0, 0, 19648, 19649, 5, 95, 0, 0, 19649, 19650, 7, 4, 0, 0, + 19650, 19651, 7, 10, 0, 0, 19651, 19652, 7, 14, 0, 0, 19652, 19653, 7, + 6, 0, 0, 19653, 2706, 1, 0, 0, 0, 19654, 19655, 7, 15, 0, 0, 19655, 19656, + 7, 0, 0, 0, 19656, 19657, 7, 5, 0, 0, 19657, 19658, 7, 5, 0, 0, 19658, + 19659, 7, 22, 0, 0, 19659, 19660, 7, 2, 0, 0, 19660, 19661, 7, 3, 0, 0, + 19661, 19662, 7, 9, 0, 0, 19662, 19663, 5, 95, 0, 0, 19663, 19664, 7, 11, + 0, 0, 19664, 19665, 7, 10, 0, 0, 19665, 19666, 7, 16, 0, 0, 19666, 19667, + 7, 6, 0, 0, 19667, 19668, 5, 95, 0, 0, 19668, 19669, 7, 4, 0, 0, 19669, + 19670, 7, 10, 0, 0, 19670, 19671, 7, 14, 0, 0, 19671, 19672, 7, 6, 0, 0, + 19672, 2708, 1, 0, 0, 0, 19673, 19674, 7, 15, 0, 0, 19674, 19675, 7, 0, + 0, 0, 19675, 19676, 7, 5, 0, 0, 19676, 19677, 7, 5, 0, 0, 19677, 19678, + 7, 22, 0, 0, 19678, 19679, 7, 2, 0, 0, 19679, 19680, 7, 3, 0, 0, 19680, + 19681, 7, 9, 0, 0, 19681, 19682, 5, 95, 0, 0, 19682, 19683, 7, 11, 0, 0, + 19683, 19684, 7, 2, 0, 0, 19684, 19685, 7, 8, 0, 0, 19685, 19686, 7, 21, + 0, 0, 19686, 19687, 5, 95, 0, 0, 19687, 19688, 7, 4, 0, 0, 19688, 19689, + 7, 10, 0, 0, 19689, 19690, 7, 14, 0, 0, 19690, 19691, 7, 6, 0, 0, 19691, + 2710, 1, 0, 0, 0, 19692, 19693, 7, 15, 0, 0, 19693, 19694, 7, 0, 0, 0, + 19694, 19695, 7, 5, 0, 0, 19695, 19696, 7, 5, 0, 0, 19696, 19697, 7, 22, + 0, 0, 19697, 19698, 7, 2, 0, 0, 19698, 19699, 7, 3, 0, 0, 19699, 19700, + 7, 9, 0, 0, 19700, 2712, 1, 0, 0, 0, 19701, 19702, 7, 15, 0, 0, 19702, + 19703, 7, 0, 0, 0, 19703, 19704, 7, 5, 0, 0, 19704, 19705, 7, 5, 0, 0, + 19705, 19706, 7, 22, 0, 0, 19706, 19707, 7, 2, 0, 0, 19707, 19708, 7, 3, + 0, 0, 19708, 19709, 7, 9, 0, 0, 19709, 19710, 5, 95, 0, 0, 19710, 19711, + 7, 3, 0, 0, 19711, 19712, 7, 6, 0, 0, 19712, 19713, 7, 12, 0, 0, 19713, + 19714, 7, 5, 0, 0, 19714, 19715, 7, 6, 0, 0, 19715, 19716, 5, 95, 0, 0, + 19716, 19717, 7, 14, 0, 0, 19717, 19718, 7, 0, 0, 0, 19718, 19719, 7, 25, + 0, 0, 19719, 2714, 1, 0, 0, 0, 19720, 19721, 7, 15, 0, 0, 19721, 19722, + 7, 0, 0, 0, 19722, 19723, 7, 5, 0, 0, 19723, 19724, 7, 5, 0, 0, 19724, + 19725, 7, 22, 0, 0, 19725, 19726, 7, 2, 0, 0, 19726, 19727, 7, 3, 0, 0, + 19727, 19728, 7, 9, 0, 0, 19728, 19729, 5, 95, 0, 0, 19729, 19730, 7, 3, + 0, 0, 19730, 19731, 7, 6, 0, 0, 19731, 19732, 7, 12, 0, 0, 19732, 19733, + 7, 5, 0, 0, 19733, 19734, 7, 6, 0, 0, 19734, 19735, 5, 95, 0, 0, 19735, + 19736, 7, 4, 0, 0, 19736, 19737, 7, 10, 0, 0, 19737, 19738, 7, 14, 0, 0, + 19738, 19739, 7, 6, 0, 0, 19739, 2716, 1, 0, 0, 0, 19740, 19741, 7, 15, + 0, 0, 19741, 19742, 7, 0, 0, 0, 19742, 19743, 7, 5, 0, 0, 19743, 19744, + 7, 5, 0, 0, 19744, 19745, 7, 22, 0, 0, 19745, 19746, 7, 2, 0, 0, 19746, + 19747, 7, 3, 0, 0, 19747, 19748, 7, 9, 0, 0, 19748, 19749, 5, 95, 0, 0, + 19749, 19750, 7, 3, 0, 0, 19750, 19751, 7, 2, 0, 0, 19751, 19752, 7, 11, + 0, 0, 19752, 19753, 7, 11, 0, 0, 19753, 19754, 7, 2, 0, 0, 19754, 19755, + 7, 13, 0, 0, 19755, 19756, 7, 6, 0, 0, 19756, 19757, 7, 3, 0, 0, 19757, + 19758, 5, 95, 0, 0, 19758, 19759, 7, 4, 0, 0, 19759, 19760, 7, 10, 0, 0, + 19760, 19761, 7, 14, 0, 0, 19761, 19762, 7, 6, 0, 0, 19762, 2718, 1, 0, + 0, 0, 19763, 19764, 7, 15, 0, 0, 19764, 19765, 7, 0, 0, 0, 19765, 19766, + 7, 5, 0, 0, 19766, 19767, 7, 5, 0, 0, 19767, 19768, 7, 22, 0, 0, 19768, + 19769, 7, 2, 0, 0, 19769, 19770, 7, 3, 0, 0, 19770, 19771, 7, 9, 0, 0, + 19771, 19772, 5, 95, 0, 0, 19772, 19773, 7, 13, 0, 0, 19773, 19774, 7, + 6, 0, 0, 19774, 19775, 7, 3, 0, 0, 19775, 19776, 7, 10, 0, 0, 19776, 19777, + 7, 16, 0, 0, 19777, 19778, 7, 18, 0, 0, 19778, 19779, 5, 95, 0, 0, 19779, + 19780, 7, 16, 0, 0, 19780, 19781, 7, 12, 0, 0, 19781, 19782, 7, 7, 0, 0, + 19782, 19783, 7, 8, 0, 0, 19783, 19784, 7, 4, 0, 0, 19784, 19785, 7, 10, + 0, 0, 19785, 19786, 7, 2, 0, 0, 19786, 19787, 7, 7, 0, 0, 19787, 2720, + 1, 0, 0, 0, 19788, 19789, 7, 15, 0, 0, 19789, 19790, 7, 0, 0, 0, 19790, + 19791, 7, 5, 0, 0, 19791, 19792, 7, 4, 0, 0, 19792, 2722, 1, 0, 0, 0, 19793, + 19794, 7, 15, 0, 0, 19794, 19795, 7, 0, 0, 0, 19795, 19796, 7, 4, 0, 0, + 19796, 19797, 7, 8, 0, 0, 19797, 19798, 7, 19, 0, 0, 19798, 2724, 1, 0, + 0, 0, 19799, 19800, 7, 15, 0, 0, 19800, 19801, 7, 0, 0, 0, 19801, 19802, + 7, 4, 0, 0, 19802, 19803, 7, 19, 0, 0, 19803, 2726, 1, 0, 0, 0, 19804, + 19805, 7, 15, 0, 0, 19805, 19806, 7, 0, 0, 0, 19806, 19807, 7, 4, 0, 0, + 19807, 19808, 7, 19, 0, 0, 19808, 19809, 5, 95, 0, 0, 19809, 19810, 7, + 15, 0, 0, 19810, 19811, 7, 3, 0, 0, 19811, 19812, 7, 6, 0, 0, 19812, 19813, + 7, 16, 0, 0, 19813, 19814, 7, 10, 0, 0, 19814, 19815, 7, 25, 0, 0, 19815, + 2728, 1, 0, 0, 0, 19816, 19817, 7, 15, 0, 0, 19817, 19818, 7, 0, 0, 0, + 19818, 19819, 7, 4, 0, 0, 19819, 19820, 7, 19, 0, 0, 19820, 19821, 7, 5, + 0, 0, 19821, 2730, 1, 0, 0, 0, 19822, 19823, 7, 15, 0, 0, 19823, 19824, + 7, 0, 0, 0, 19824, 19825, 7, 4, 0, 0, 19825, 19826, 7, 4, 0, 0, 19826, + 19827, 7, 6, 0, 0, 19827, 19828, 7, 3, 0, 0, 19828, 19829, 7, 7, 0, 0, + 19829, 2732, 1, 0, 0, 0, 19830, 19831, 7, 15, 0, 0, 19831, 19832, 7, 1, + 0, 0, 19832, 19833, 7, 11, 0, 0, 19833, 19834, 5, 95, 0, 0, 19834, 19835, + 7, 19, 0, 0, 19835, 19836, 7, 5, 0, 0, 19836, 19837, 5, 95, 0, 0, 19837, + 19838, 7, 1, 0, 0, 19838, 19839, 7, 6, 0, 0, 19839, 19840, 7, 17, 0, 0, + 19840, 19841, 7, 10, 0, 0, 19841, 19842, 7, 7, 0, 0, 19842, 2734, 1, 0, + 0, 0, 19843, 19844, 7, 15, 0, 0, 19844, 19845, 7, 1, 0, 0, 19845, 19846, + 7, 11, 0, 0, 19846, 19847, 5, 95, 0, 0, 19847, 19848, 7, 19, 0, 0, 19848, + 19849, 7, 5, 0, 0, 19849, 19850, 5, 95, 0, 0, 19850, 19851, 7, 6, 0, 0, + 19851, 19852, 7, 7, 0, 0, 19852, 19853, 7, 9, 0, 0, 19853, 2736, 1, 0, + 0, 0, 19854, 19855, 7, 15, 0, 0, 19855, 19856, 7, 8, 0, 0, 19856, 19857, + 7, 4, 0, 0, 19857, 19858, 7, 16, 0, 0, 19858, 19859, 7, 3, 0, 0, 19859, + 19860, 7, 6, 0, 0, 19860, 19861, 7, 6, 0, 0, 19861, 2738, 1, 0, 0, 0, 19862, + 19863, 7, 15, 0, 0, 19863, 19864, 7, 8, 0, 0, 19864, 19865, 7, 4, 0, 0, + 19865, 19866, 7, 10, 0, 0, 19866, 19867, 7, 7, 0, 0, 19867, 19868, 7, 8, + 0, 0, 19868, 19869, 7, 3, 0, 0, 19869, 19870, 7, 6, 0, 0, 19870, 19871, + 7, 0, 0, 0, 19871, 19872, 7, 5, 0, 0, 19872, 19873, 7, 6, 0, 0, 19873, + 2740, 1, 0, 0, 0, 19874, 19875, 7, 15, 0, 0, 19875, 19876, 7, 8, 0, 0, + 19876, 19877, 7, 4, 0, 0, 19877, 19878, 7, 4, 0, 0, 19878, 19879, 7, 19, + 0, 0, 19879, 19880, 7, 3, 0, 0, 19880, 19881, 7, 6, 0, 0, 19881, 19882, + 7, 5, 0, 0, 19882, 19883, 7, 19, 0, 0, 19883, 19884, 7, 2, 0, 0, 19884, + 19885, 7, 11, 0, 0, 19885, 19886, 7, 9, 0, 0, 19886, 2742, 1, 0, 0, 0, + 19887, 19888, 7, 15, 0, 0, 19888, 19889, 7, 8, 0, 0, 19889, 19890, 7, 4, + 0, 0, 19890, 19891, 7, 12, 0, 0, 19891, 19892, 7, 5, 0, 0, 19892, 19893, + 7, 6, 0, 0, 19893, 19894, 7, 9, 0, 0, 19894, 2744, 1, 0, 0, 0, 19895, 19896, + 7, 15, 0, 0, 19896, 19897, 7, 8, 0, 0, 19897, 19898, 7, 4, 0, 0, 19898, + 19899, 7, 13, 0, 0, 19899, 19900, 7, 6, 0, 0, 19900, 19901, 7, 3, 0, 0, + 19901, 19902, 7, 5, 0, 0, 19902, 19903, 7, 10, 0, 0, 19903, 19904, 7, 2, + 0, 0, 19904, 19905, 7, 7, 0, 0, 19905, 2746, 1, 0, 0, 0, 19906, 19907, + 7, 15, 0, 0, 19907, 19908, 7, 6, 0, 0, 19908, 19909, 7, 7, 0, 0, 19909, + 19910, 7, 9, 0, 0, 19910, 19911, 7, 10, 0, 0, 19911, 19912, 7, 7, 0, 0, + 19912, 19913, 7, 17, 0, 0, 19913, 2748, 1, 0, 0, 0, 19914, 19918, 5, 37, + 0, 0, 19915, 19917, 3, 4999, 2499, 0, 19916, 19915, 1, 0, 0, 0, 19917, + 19920, 1, 0, 0, 0, 19918, 19916, 1, 0, 0, 0, 19918, 19919, 1, 0, 0, 0, + 19919, 19921, 1, 0, 0, 0, 19920, 19918, 1, 0, 0, 0, 19921, 19922, 7, 16, + 0, 0, 19922, 19923, 7, 2, 0, 0, 19923, 19924, 7, 12, 0, 0, 19924, 19925, + 7, 7, 0, 0, 19925, 19926, 7, 9, 0, 0, 19926, 2750, 1, 0, 0, 0, 19927, 19931, + 5, 37, 0, 0, 19928, 19930, 3, 4999, 2499, 0, 19929, 19928, 1, 0, 0, 0, + 19930, 19933, 1, 0, 0, 0, 19931, 19929, 1, 0, 0, 0, 19931, 19932, 1, 0, + 0, 0, 19932, 19934, 1, 0, 0, 0, 19933, 19931, 1, 0, 0, 0, 19934, 19935, + 7, 10, 0, 0, 19935, 19936, 7, 5, 0, 0, 19936, 19937, 7, 2, 0, 0, 19937, + 19938, 7, 15, 0, 0, 19938, 19939, 7, 6, 0, 0, 19939, 19940, 7, 7, 0, 0, + 19940, 2752, 1, 0, 0, 0, 19941, 19945, 5, 37, 0, 0, 19942, 19944, 3, 4999, + 2499, 0, 19943, 19942, 1, 0, 0, 0, 19944, 19947, 1, 0, 0, 0, 19945, 19943, + 1, 0, 0, 0, 19945, 19946, 1, 0, 0, 0, 19946, 19948, 1, 0, 0, 0, 19947, + 19945, 1, 0, 0, 0, 19948, 19949, 7, 7, 0, 0, 19949, 19950, 7, 2, 0, 0, + 19950, 19951, 7, 4, 0, 0, 19951, 19952, 7, 16, 0, 0, 19952, 19953, 7, 2, + 0, 0, 19953, 19954, 7, 12, 0, 0, 19954, 19955, 7, 7, 0, 0, 19955, 19956, + 7, 9, 0, 0, 19956, 2754, 1, 0, 0, 0, 19957, 19958, 7, 15, 0, 0, 19958, + 19959, 7, 6, 0, 0, 19959, 19960, 7, 3, 0, 0, 19960, 19961, 7, 8, 0, 0, + 19961, 19962, 7, 6, 0, 0, 19962, 19963, 7, 7, 0, 0, 19963, 19964, 7, 4, + 0, 0, 19964, 2756, 1, 0, 0, 0, 19965, 19966, 7, 15, 0, 0, 19966, 19967, + 7, 6, 0, 0, 19967, 19968, 7, 3, 0, 0, 19968, 19969, 7, 8, 0, 0, 19969, + 19970, 7, 6, 0, 0, 19970, 19971, 7, 7, 0, 0, 19971, 19972, 7, 4, 0, 0, + 19972, 19973, 5, 95, 0, 0, 19973, 19974, 7, 3, 0, 0, 19974, 19975, 7, 0, + 0, 0, 19975, 19976, 7, 7, 0, 0, 19976, 19977, 7, 21, 0, 0, 19977, 19978, + 7, 14, 0, 0, 19978, 2758, 1, 0, 0, 0, 19979, 19983, 5, 37, 0, 0, 19980, + 19982, 3, 4999, 2499, 0, 19981, 19980, 1, 0, 0, 0, 19982, 19985, 1, 0, + 0, 0, 19983, 19981, 1, 0, 0, 0, 19983, 19984, 1, 0, 0, 0, 19984, 19986, + 1, 0, 0, 0, 19985, 19983, 1, 0, 0, 0, 19986, 19987, 7, 3, 0, 0, 19987, + 19988, 7, 2, 0, 0, 19988, 19989, 7, 22, 0, 0, 19989, 19990, 7, 8, 0, 0, + 19990, 19991, 7, 2, 0, 0, 19991, 19992, 7, 12, 0, 0, 19992, 19993, 7, 7, + 0, 0, 19993, 19994, 7, 4, 0, 0, 19994, 2760, 1, 0, 0, 0, 19995, 19999, + 5, 37, 0, 0, 19996, 19998, 3, 4999, 2499, 0, 19997, 19996, 1, 0, 0, 0, + 19998, 20001, 1, 0, 0, 0, 19999, 19997, 1, 0, 0, 0, 19999, 20000, 1, 0, + 0, 0, 20000, 20002, 1, 0, 0, 0, 20001, 19999, 1, 0, 0, 0, 20002, 20003, + 7, 3, 0, 0, 20003, 20004, 7, 2, 0, 0, 20004, 20005, 7, 22, 0, 0, 20005, + 20006, 7, 4, 0, 0, 20006, 20007, 7, 18, 0, 0, 20007, 20008, 7, 15, 0, 0, + 20008, 20009, 7, 6, 0, 0, 20009, 2762, 1, 0, 0, 0, 20010, 20014, 5, 37, + 0, 0, 20011, 20013, 3, 4999, 2499, 0, 20012, 20011, 1, 0, 0, 0, 20013, + 20016, 1, 0, 0, 0, 20014, 20012, 1, 0, 0, 0, 20014, 20015, 1, 0, 0, 0, + 20015, 20017, 1, 0, 0, 0, 20016, 20014, 1, 0, 0, 0, 20017, 20018, 7, 4, + 0, 0, 20018, 20019, 7, 18, 0, 0, 20019, 20020, 7, 15, 0, 0, 20020, 20021, + 7, 6, 0, 0, 20021, 2764, 1, 0, 0, 0, 20022, 20026, 5, 37, 0, 0, 20023, + 20025, 3, 4999, 2499, 0, 20024, 20023, 1, 0, 0, 0, 20025, 20028, 1, 0, + 0, 0, 20026, 20024, 1, 0, 0, 0, 20026, 20027, 1, 0, 0, 0, 20027, 20029, + 1, 0, 0, 0, 20028, 20026, 1, 0, 0, 0, 20029, 20030, 7, 1, 0, 0, 20030, + 20031, 7, 12, 0, 0, 20031, 20032, 7, 11, 0, 0, 20032, 20033, 7, 21, 0, + 0, 20033, 20034, 5, 95, 0, 0, 20034, 20035, 7, 6, 0, 0, 20035, 20036, 7, + 25, 0, 0, 20036, 20037, 7, 8, 0, 0, 20037, 20038, 7, 6, 0, 0, 20038, 20039, + 7, 15, 0, 0, 20039, 20040, 7, 4, 0, 0, 20040, 20041, 7, 10, 0, 0, 20041, + 20042, 7, 2, 0, 0, 20042, 20043, 7, 7, 0, 0, 20043, 20044, 7, 5, 0, 0, + 20044, 2766, 1, 0, 0, 0, 20045, 20049, 5, 37, 0, 0, 20046, 20048, 3, 4999, + 2499, 0, 20047, 20046, 1, 0, 0, 0, 20048, 20051, 1, 0, 0, 0, 20049, 20047, + 1, 0, 0, 0, 20049, 20050, 1, 0, 0, 0, 20050, 20052, 1, 0, 0, 0, 20051, + 20049, 1, 0, 0, 0, 20052, 20053, 7, 1, 0, 0, 20053, 20054, 7, 12, 0, 0, + 20054, 20055, 7, 11, 0, 0, 20055, 20056, 7, 21, 0, 0, 20056, 20057, 5, + 95, 0, 0, 20057, 20058, 7, 3, 0, 0, 20058, 20059, 7, 2, 0, 0, 20059, 20060, + 7, 22, 0, 0, 20060, 20061, 7, 8, 0, 0, 20061, 20062, 7, 2, 0, 0, 20062, + 20063, 7, 12, 0, 0, 20063, 20064, 7, 7, 0, 0, 20064, 20065, 7, 4, 0, 0, + 20065, 2768, 1, 0, 0, 0, 20066, 20067, 7, 15, 0, 0, 20067, 20068, 7, 6, + 0, 0, 20068, 20069, 7, 3, 0, 0, 20069, 20070, 7, 16, 0, 0, 20070, 20071, + 7, 2, 0, 0, 20071, 20072, 7, 3, 0, 0, 20072, 20073, 7, 14, 0, 0, 20073, + 20074, 7, 0, 0, 0, 20074, 20075, 7, 7, 0, 0, 20075, 20076, 7, 8, 0, 0, + 20076, 20077, 7, 6, 0, 0, 20077, 2770, 1, 0, 0, 0, 20078, 20079, 7, 15, + 0, 0, 20079, 20080, 7, 6, 0, 0, 20080, 20081, 7, 3, 0, 0, 20081, 20082, + 7, 10, 0, 0, 20082, 20083, 7, 2, 0, 0, 20083, 20084, 7, 9, 0, 0, 20084, + 2772, 1, 0, 0, 0, 20085, 20086, 7, 15, 0, 0, 20086, 20087, 7, 6, 0, 0, + 20087, 20088, 7, 3, 0, 0, 20088, 20089, 7, 14, 0, 0, 20089, 20090, 7, 0, + 0, 0, 20090, 20091, 7, 7, 0, 0, 20091, 20092, 7, 6, 0, 0, 20092, 20093, + 7, 7, 0, 0, 20093, 20094, 7, 4, 0, 0, 20094, 2774, 1, 0, 0, 0, 20095, 20096, + 7, 15, 0, 0, 20096, 20097, 7, 6, 0, 0, 20097, 20098, 7, 3, 0, 0, 20098, + 20099, 7, 14, 0, 0, 20099, 20100, 7, 10, 0, 0, 20100, 20101, 7, 5, 0, 0, + 20101, 20102, 7, 5, 0, 0, 20102, 20103, 7, 10, 0, 0, 20103, 20104, 7, 2, + 0, 0, 20104, 20105, 7, 7, 0, 0, 20105, 2776, 1, 0, 0, 0, 20106, 20107, + 7, 15, 0, 0, 20107, 20108, 7, 6, 0, 0, 20108, 20109, 7, 3, 0, 0, 20109, + 20110, 7, 14, 0, 0, 20110, 20111, 7, 12, 0, 0, 20111, 20112, 7, 4, 0, 0, + 20112, 20113, 7, 6, 0, 0, 20113, 2778, 1, 0, 0, 0, 20114, 20115, 7, 15, + 0, 0, 20115, 20116, 7, 6, 0, 0, 20116, 20117, 7, 3, 0, 0, 20117, 2780, + 1, 0, 0, 0, 20118, 20119, 7, 15, 0, 0, 20119, 20120, 7, 16, 0, 0, 20120, + 20121, 7, 10, 0, 0, 20121, 20122, 7, 11, 0, 0, 20122, 20123, 7, 6, 0, 0, + 20123, 2782, 1, 0, 0, 0, 20124, 20125, 7, 15, 0, 0, 20125, 20126, 7, 19, + 0, 0, 20126, 20127, 7, 18, 0, 0, 20127, 20128, 7, 5, 0, 0, 20128, 20129, + 7, 10, 0, 0, 20129, 20130, 7, 8, 0, 0, 20130, 20131, 7, 0, 0, 0, 20131, + 20132, 7, 11, 0, 0, 20132, 2784, 1, 0, 0, 0, 20133, 20134, 7, 15, 0, 0, + 20134, 20135, 7, 10, 0, 0, 20135, 20136, 7, 21, 0, 0, 20136, 20137, 7, + 6, 0, 0, 20137, 20138, 7, 18, 0, 0, 20138, 2786, 1, 0, 0, 0, 20139, 20140, + 7, 15, 0, 0, 20140, 20141, 7, 10, 0, 0, 20141, 20142, 7, 15, 0, 0, 20142, + 20143, 7, 6, 0, 0, 20143, 20144, 7, 11, 0, 0, 20144, 20145, 7, 10, 0, 0, + 20145, 20146, 7, 7, 0, 0, 20146, 20147, 7, 6, 0, 0, 20147, 20148, 7, 9, + 0, 0, 20148, 2788, 1, 0, 0, 0, 20149, 20150, 7, 15, 0, 0, 20150, 20151, + 7, 10, 0, 0, 20151, 20152, 7, 15, 0, 0, 20152, 20153, 7, 6, 0, 0, 20153, + 2790, 1, 0, 0, 0, 20154, 20155, 7, 15, 0, 0, 20155, 20156, 7, 10, 0, 0, + 20156, 20157, 7, 13, 0, 0, 20157, 20158, 5, 95, 0, 0, 20158, 20159, 7, + 17, 0, 0, 20159, 20160, 7, 1, 0, 0, 20160, 2792, 1, 0, 0, 0, 20161, 20162, + 7, 15, 0, 0, 20162, 20163, 7, 10, 0, 0, 20163, 20164, 7, 13, 0, 0, 20164, + 20165, 7, 2, 0, 0, 20165, 20166, 7, 4, 0, 0, 20166, 2794, 1, 0, 0, 0, 20167, + 20168, 7, 15, 0, 0, 20168, 20169, 7, 10, 0, 0, 20169, 20170, 7, 13, 0, + 0, 20170, 20171, 5, 95, 0, 0, 20171, 20172, 7, 5, 0, 0, 20172, 20173, 7, + 5, 0, 0, 20173, 20174, 7, 16, 0, 0, 20174, 2796, 1, 0, 0, 0, 20175, 20176, + 7, 15, 0, 0, 20176, 20177, 7, 11, 0, 0, 20177, 20178, 7, 0, 0, 0, 20178, + 20179, 7, 8, 0, 0, 20179, 20180, 7, 6, 0, 0, 20180, 20181, 5, 95, 0, 0, + 20181, 20182, 7, 9, 0, 0, 20182, 20183, 7, 10, 0, 0, 20183, 20184, 7, 5, + 0, 0, 20184, 20185, 7, 4, 0, 0, 20185, 20186, 7, 10, 0, 0, 20186, 20187, + 7, 7, 0, 0, 20187, 20188, 7, 8, 0, 0, 20188, 20189, 7, 4, 0, 0, 20189, + 2798, 1, 0, 0, 0, 20190, 20191, 7, 15, 0, 0, 20191, 20192, 7, 11, 0, 0, + 20192, 20193, 7, 0, 0, 0, 20193, 20194, 7, 8, 0, 0, 20194, 20195, 7, 6, + 0, 0, 20195, 20196, 5, 95, 0, 0, 20196, 20197, 7, 17, 0, 0, 20197, 20198, + 7, 3, 0, 0, 20198, 20199, 7, 2, 0, 0, 20199, 20200, 7, 12, 0, 0, 20200, + 20201, 7, 15, 0, 0, 20201, 20202, 5, 95, 0, 0, 20202, 20203, 7, 1, 0, 0, + 20203, 20204, 7, 18, 0, 0, 20204, 2800, 1, 0, 0, 0, 20205, 20206, 7, 15, + 0, 0, 20206, 20207, 7, 11, 0, 0, 20207, 20208, 7, 0, 0, 0, 20208, 20209, + 7, 7, 0, 0, 20209, 2802, 1, 0, 0, 0, 20210, 20211, 7, 15, 0, 0, 20211, + 20212, 7, 11, 0, 0, 20212, 20213, 7, 5, 0, 0, 20213, 20214, 7, 8, 0, 0, + 20214, 20215, 7, 2, 0, 0, 20215, 20216, 7, 15, 0, 0, 20216, 20217, 7, 6, + 0, 0, 20217, 20218, 5, 95, 0, 0, 20218, 20219, 7, 5, 0, 0, 20219, 20220, + 7, 6, 0, 0, 20220, 20221, 7, 4, 0, 0, 20221, 20222, 7, 4, 0, 0, 20222, + 20223, 7, 10, 0, 0, 20223, 20224, 7, 7, 0, 0, 20224, 20225, 7, 17, 0, 0, + 20225, 20226, 7, 5, 0, 0, 20226, 2804, 1, 0, 0, 0, 20227, 20228, 7, 15, + 0, 0, 20228, 20229, 7, 11, 0, 0, 20229, 20230, 7, 5, 0, 0, 20230, 20231, + 5, 95, 0, 0, 20231, 20232, 7, 10, 0, 0, 20232, 20233, 7, 7, 0, 0, 20233, + 20234, 7, 4, 0, 0, 20234, 20235, 7, 6, 0, 0, 20235, 20236, 7, 17, 0, 0, + 20236, 20237, 7, 6, 0, 0, 20237, 20238, 7, 3, 0, 0, 20238, 2806, 1, 0, + 0, 0, 20239, 20240, 7, 15, 0, 0, 20240, 20241, 7, 11, 0, 0, 20241, 20242, + 7, 5, 0, 0, 20242, 20243, 7, 24, 0, 0, 20243, 20244, 7, 11, 0, 0, 20244, + 20245, 5, 95, 0, 0, 20245, 20246, 7, 8, 0, 0, 20246, 20247, 7, 8, 0, 0, + 20247, 20248, 7, 16, 0, 0, 20248, 20249, 7, 11, 0, 0, 20249, 20250, 7, + 0, 0, 0, 20250, 20251, 7, 17, 0, 0, 20251, 20252, 7, 5, 0, 0, 20252, 2808, + 1, 0, 0, 0, 20253, 20254, 7, 15, 0, 0, 20254, 20255, 7, 11, 0, 0, 20255, + 20256, 7, 5, 0, 0, 20256, 20257, 7, 24, 0, 0, 20257, 20258, 7, 11, 0, 0, + 20258, 20259, 5, 95, 0, 0, 20259, 20260, 7, 8, 0, 0, 20260, 20261, 7, 2, + 0, 0, 20261, 20262, 7, 9, 0, 0, 20262, 20263, 7, 6, 0, 0, 20263, 20264, + 5, 95, 0, 0, 20264, 20265, 7, 4, 0, 0, 20265, 20266, 7, 18, 0, 0, 20266, + 20267, 7, 15, 0, 0, 20267, 20268, 7, 6, 0, 0, 20268, 2810, 1, 0, 0, 0, + 20269, 20270, 7, 15, 0, 0, 20270, 20271, 7, 11, 0, 0, 20271, 20272, 7, + 5, 0, 0, 20272, 20273, 7, 24, 0, 0, 20273, 20274, 7, 11, 0, 0, 20274, 20275, + 5, 95, 0, 0, 20275, 20276, 7, 9, 0, 0, 20276, 20277, 7, 6, 0, 0, 20277, + 20278, 7, 1, 0, 0, 20278, 20279, 7, 12, 0, 0, 20279, 20280, 7, 17, 0, 0, + 20280, 2812, 1, 0, 0, 0, 20281, 20282, 7, 15, 0, 0, 20282, 20283, 7, 11, + 0, 0, 20283, 20284, 7, 5, 0, 0, 20284, 20285, 7, 24, 0, 0, 20285, 20286, + 7, 11, 0, 0, 20286, 20287, 5, 95, 0, 0, 20287, 20288, 7, 2, 0, 0, 20288, + 20289, 7, 15, 0, 0, 20289, 20290, 7, 4, 0, 0, 20290, 20291, 7, 10, 0, 0, + 20291, 20292, 7, 14, 0, 0, 20292, 20293, 7, 10, 0, 0, 20293, 20294, 7, + 23, 0, 0, 20294, 20295, 7, 6, 0, 0, 20295, 20296, 5, 95, 0, 0, 20296, 20297, + 7, 11, 0, 0, 20297, 20298, 7, 6, 0, 0, 20298, 20299, 7, 13, 0, 0, 20299, + 20300, 7, 6, 0, 0, 20300, 20301, 7, 11, 0, 0, 20301, 2814, 1, 0, 0, 0, + 20302, 20303, 7, 15, 0, 0, 20303, 20304, 7, 11, 0, 0, 20304, 20305, 7, + 5, 0, 0, 20305, 20306, 7, 24, 0, 0, 20306, 20307, 7, 11, 0, 0, 20307, 20308, + 5, 95, 0, 0, 20308, 20309, 7, 22, 0, 0, 20309, 20310, 7, 0, 0, 0, 20310, + 20311, 7, 3, 0, 0, 20311, 20312, 7, 7, 0, 0, 20312, 20313, 7, 10, 0, 0, + 20313, 20314, 7, 7, 0, 0, 20314, 20315, 7, 17, 0, 0, 20315, 20316, 7, 5, + 0, 0, 20316, 2816, 1, 0, 0, 0, 20317, 20318, 7, 15, 0, 0, 20318, 20319, + 7, 11, 0, 0, 20319, 20320, 7, 12, 0, 0, 20320, 20321, 7, 17, 0, 0, 20321, + 20322, 7, 17, 0, 0, 20322, 20323, 7, 0, 0, 0, 20323, 20324, 7, 1, 0, 0, + 20324, 20325, 7, 11, 0, 0, 20325, 20326, 7, 6, 0, 0, 20326, 2818, 1, 0, + 0, 0, 20327, 20328, 7, 15, 0, 0, 20328, 20329, 7, 14, 0, 0, 20329, 20330, + 7, 6, 0, 0, 20330, 20331, 7, 14, 0, 0, 20331, 2820, 1, 0, 0, 0, 20332, + 20333, 7, 15, 0, 0, 20333, 20334, 7, 2, 0, 0, 20334, 20335, 7, 10, 0, 0, + 20335, 20336, 7, 7, 0, 0, 20336, 20337, 7, 4, 0, 0, 20337, 2822, 1, 0, + 0, 0, 20338, 20339, 7, 15, 0, 0, 20339, 20340, 7, 2, 0, 0, 20340, 20341, + 7, 11, 0, 0, 20341, 20342, 7, 10, 0, 0, 20342, 20343, 7, 8, 0, 0, 20343, + 20344, 7, 18, 0, 0, 20344, 2824, 1, 0, 0, 0, 20345, 20346, 7, 15, 0, 0, + 20346, 20347, 7, 2, 0, 0, 20347, 20348, 7, 2, 0, 0, 20348, 20349, 7, 11, + 0, 0, 20349, 20350, 5, 95, 0, 0, 20350, 20351, 5, 49, 0, 0, 20351, 20352, + 5, 54, 0, 0, 20352, 20353, 7, 21, 0, 0, 20353, 2826, 1, 0, 0, 0, 20354, + 20355, 7, 15, 0, 0, 20355, 20356, 7, 2, 0, 0, 20356, 20357, 7, 2, 0, 0, + 20357, 20358, 7, 11, 0, 0, 20358, 20359, 5, 95, 0, 0, 20359, 20360, 5, + 50, 0, 0, 20360, 20361, 7, 21, 0, 0, 20361, 2828, 1, 0, 0, 0, 20362, 20363, + 7, 15, 0, 0, 20363, 20364, 7, 2, 0, 0, 20364, 20365, 7, 2, 0, 0, 20365, + 20366, 7, 11, 0, 0, 20366, 20367, 5, 95, 0, 0, 20367, 20368, 5, 51, 0, + 0, 20368, 20369, 5, 50, 0, 0, 20369, 20370, 7, 21, 0, 0, 20370, 2830, 1, + 0, 0, 0, 20371, 20372, 7, 15, 0, 0, 20372, 20373, 7, 2, 0, 0, 20373, 20374, + 7, 2, 0, 0, 20374, 20375, 7, 11, 0, 0, 20375, 20376, 5, 95, 0, 0, 20376, + 20377, 5, 52, 0, 0, 20377, 20378, 7, 21, 0, 0, 20378, 2832, 1, 0, 0, 0, + 20379, 20380, 7, 15, 0, 0, 20380, 20381, 7, 2, 0, 0, 20381, 20382, 7, 2, + 0, 0, 20382, 20383, 7, 11, 0, 0, 20383, 20384, 5, 95, 0, 0, 20384, 20385, + 5, 56, 0, 0, 20385, 20386, 7, 21, 0, 0, 20386, 2834, 1, 0, 0, 0, 20387, + 20388, 7, 15, 0, 0, 20388, 20389, 7, 2, 0, 0, 20389, 20390, 7, 5, 0, 0, + 20390, 20391, 7, 10, 0, 0, 20391, 20392, 7, 4, 0, 0, 20392, 20393, 7, 10, + 0, 0, 20393, 20394, 7, 2, 0, 0, 20394, 20395, 7, 7, 0, 0, 20395, 2836, + 1, 0, 0, 0, 20396, 20397, 7, 15, 0, 0, 20397, 20398, 7, 2, 0, 0, 20398, + 20399, 7, 5, 0, 0, 20399, 20400, 7, 10, 0, 0, 20400, 20401, 7, 4, 0, 0, + 20401, 20402, 7, 10, 0, 0, 20402, 20403, 7, 13, 0, 0, 20403, 20404, 7, + 6, 0, 0, 20404, 20405, 7, 7, 0, 0, 20405, 2838, 1, 0, 0, 0, 20406, 20407, + 7, 15, 0, 0, 20407, 20408, 7, 2, 0, 0, 20408, 20409, 7, 5, 0, 0, 20409, + 20410, 7, 10, 0, 0, 20410, 20411, 7, 4, 0, 0, 20411, 20412, 7, 10, 0, 0, + 20412, 20413, 7, 13, 0, 0, 20413, 20414, 7, 6, 0, 0, 20414, 2840, 1, 0, + 0, 0, 20415, 20416, 7, 15, 0, 0, 20416, 20417, 7, 2, 0, 0, 20417, 20418, + 7, 5, 0, 0, 20418, 20419, 7, 4, 0, 0, 20419, 20420, 5, 95, 0, 0, 20420, + 20421, 7, 4, 0, 0, 20421, 20422, 7, 3, 0, 0, 20422, 20423, 7, 0, 0, 0, + 20423, 20424, 7, 7, 0, 0, 20424, 20425, 7, 5, 0, 0, 20425, 20426, 7, 0, + 0, 0, 20426, 20427, 7, 8, 0, 0, 20427, 20428, 7, 4, 0, 0, 20428, 20429, + 7, 10, 0, 0, 20429, 20430, 7, 2, 0, 0, 20430, 20431, 7, 7, 0, 0, 20431, + 2842, 1, 0, 0, 0, 20432, 20433, 7, 15, 0, 0, 20433, 20434, 7, 2, 0, 0, + 20434, 20435, 7, 22, 0, 0, 20435, 20436, 7, 6, 0, 0, 20436, 20437, 7, 3, + 0, 0, 20437, 20438, 7, 14, 0, 0, 20438, 20439, 7, 12, 0, 0, 20439, 20440, + 7, 11, 0, 0, 20440, 20441, 7, 4, 0, 0, 20441, 20442, 7, 10, 0, 0, 20442, + 20443, 7, 5, 0, 0, 20443, 20444, 7, 6, 0, 0, 20444, 20445, 7, 4, 0, 0, + 20445, 20446, 5, 95, 0, 0, 20446, 20447, 7, 1, 0, 0, 20447, 20448, 7, 18, + 0, 0, 20448, 20449, 5, 95, 0, 0, 20449, 20450, 7, 8, 0, 0, 20450, 20451, + 7, 0, 0, 0, 20451, 20452, 7, 3, 0, 0, 20452, 20453, 7, 9, 0, 0, 20453, + 20454, 7, 10, 0, 0, 20454, 20455, 7, 7, 0, 0, 20455, 20456, 7, 0, 0, 0, + 20456, 20457, 7, 11, 0, 0, 20457, 20458, 7, 10, 0, 0, 20458, 20459, 7, + 4, 0, 0, 20459, 20460, 7, 18, 0, 0, 20460, 2844, 1, 0, 0, 0, 20461, 20462, + 7, 15, 0, 0, 20462, 20463, 7, 2, 0, 0, 20463, 20464, 7, 22, 0, 0, 20464, + 20465, 7, 6, 0, 0, 20465, 20466, 7, 3, 0, 0, 20466, 20467, 7, 14, 0, 0, + 20467, 20468, 7, 12, 0, 0, 20468, 20469, 7, 11, 0, 0, 20469, 20470, 7, + 4, 0, 0, 20470, 20471, 7, 10, 0, 0, 20471, 20472, 7, 5, 0, 0, 20472, 20473, + 7, 6, 0, 0, 20473, 20474, 7, 4, 0, 0, 20474, 2846, 1, 0, 0, 0, 20475, 20476, + 7, 15, 0, 0, 20476, 20477, 7, 2, 0, 0, 20477, 20478, 7, 22, 0, 0, 20478, + 20479, 7, 6, 0, 0, 20479, 20480, 7, 3, 0, 0, 20480, 2848, 1, 0, 0, 0, 20481, + 20482, 7, 15, 0, 0, 20482, 20483, 7, 24, 0, 0, 20483, 20484, 5, 95, 0, + 0, 20484, 20485, 7, 8, 0, 0, 20485, 20486, 7, 2, 0, 0, 20486, 20487, 7, + 7, 0, 0, 20487, 20488, 7, 8, 0, 0, 20488, 20489, 7, 12, 0, 0, 20489, 20490, + 7, 3, 0, 0, 20490, 20491, 7, 3, 0, 0, 20491, 20492, 7, 6, 0, 0, 20492, + 20493, 7, 7, 0, 0, 20493, 20494, 7, 4, 0, 0, 20494, 20495, 5, 95, 0, 0, + 20495, 20496, 7, 12, 0, 0, 20496, 20497, 7, 7, 0, 0, 20497, 20498, 7, 10, + 0, 0, 20498, 20499, 7, 2, 0, 0, 20499, 20500, 7, 7, 0, 0, 20500, 2850, + 1, 0, 0, 0, 20501, 20502, 7, 15, 0, 0, 20502, 20503, 7, 24, 0, 0, 20503, + 20504, 5, 95, 0, 0, 20504, 20505, 7, 9, 0, 0, 20505, 20506, 7, 10, 0, 0, + 20506, 20507, 7, 5, 0, 0, 20507, 20508, 7, 4, 0, 0, 20508, 20509, 7, 3, + 0, 0, 20509, 20510, 7, 10, 0, 0, 20510, 20511, 7, 1, 0, 0, 20511, 20512, + 7, 12, 0, 0, 20512, 20513, 7, 4, 0, 0, 20513, 20514, 7, 6, 0, 0, 20514, + 2852, 1, 0, 0, 0, 20515, 20516, 7, 15, 0, 0, 20516, 20517, 7, 24, 0, 0, + 20517, 20518, 5, 95, 0, 0, 20518, 20519, 7, 9, 0, 0, 20519, 20520, 7, 10, + 0, 0, 20520, 20521, 7, 5, 0, 0, 20521, 20522, 7, 4, 0, 0, 20522, 20523, + 7, 3, 0, 0, 20523, 20524, 7, 10, 0, 0, 20524, 20525, 7, 1, 0, 0, 20525, + 20526, 7, 12, 0, 0, 20526, 20527, 7, 4, 0, 0, 20527, 20528, 7, 6, 0, 0, + 20528, 20529, 5, 95, 0, 0, 20529, 20530, 7, 22, 0, 0, 20530, 20531, 7, + 10, 0, 0, 20531, 20532, 7, 7, 0, 0, 20532, 20533, 7, 9, 0, 0, 20533, 20534, + 7, 2, 0, 0, 20534, 20535, 7, 22, 0, 0, 20535, 2854, 1, 0, 0, 0, 20536, + 20537, 7, 15, 0, 0, 20537, 20538, 7, 24, 0, 0, 20538, 20539, 5, 95, 0, + 0, 20539, 20540, 7, 16, 0, 0, 20540, 20541, 7, 10, 0, 0, 20541, 20542, + 7, 11, 0, 0, 20542, 20543, 7, 4, 0, 0, 20543, 20544, 7, 6, 0, 0, 20544, + 20545, 7, 3, 0, 0, 20545, 2856, 1, 0, 0, 0, 20546, 20547, 7, 15, 0, 0, + 20547, 20548, 7, 24, 0, 0, 20548, 20549, 5, 95, 0, 0, 20549, 20550, 7, + 14, 0, 0, 20550, 20551, 7, 0, 0, 0, 20551, 20552, 7, 15, 0, 0, 20552, 2858, + 1, 0, 0, 0, 20553, 20554, 7, 15, 0, 0, 20554, 20555, 7, 24, 0, 0, 20555, + 20556, 5, 95, 0, 0, 20556, 20557, 7, 7, 0, 0, 20557, 20558, 7, 2, 0, 0, + 20558, 20559, 7, 14, 0, 0, 20559, 20560, 7, 0, 0, 0, 20560, 20561, 7, 15, + 0, 0, 20561, 2860, 1, 0, 0, 0, 20562, 20563, 7, 15, 0, 0, 20563, 20564, + 7, 24, 0, 0, 20564, 20565, 5, 95, 0, 0, 20565, 20566, 7, 3, 0, 0, 20566, + 20567, 7, 6, 0, 0, 20567, 20568, 7, 15, 0, 0, 20568, 20569, 7, 11, 0, 0, + 20569, 20570, 7, 10, 0, 0, 20570, 20571, 7, 8, 0, 0, 20571, 20572, 7, 0, + 0, 0, 20572, 20573, 7, 4, 0, 0, 20573, 20574, 7, 6, 0, 0, 20574, 2862, + 1, 0, 0, 0, 20575, 20576, 7, 15, 0, 0, 20576, 20577, 7, 24, 0, 0, 20577, + 20578, 5, 95, 0, 0, 20578, 20579, 7, 5, 0, 0, 20579, 20580, 7, 21, 0, 0, + 20580, 20581, 7, 6, 0, 0, 20581, 20582, 7, 22, 0, 0, 20582, 2864, 1, 0, + 0, 0, 20583, 20584, 7, 15, 0, 0, 20584, 20585, 7, 3, 0, 0, 20585, 20586, + 7, 0, 0, 0, 20586, 20587, 7, 17, 0, 0, 20587, 20588, 7, 14, 0, 0, 20588, + 20589, 7, 0, 0, 0, 20589, 2866, 1, 0, 0, 0, 20590, 20591, 7, 15, 0, 0, + 20591, 20592, 7, 3, 0, 0, 20592, 20593, 7, 6, 0, 0, 20593, 20594, 7, 1, + 0, 0, 20594, 20595, 7, 12, 0, 0, 20595, 20596, 7, 10, 0, 0, 20596, 20597, + 7, 11, 0, 0, 20597, 20598, 7, 4, 0, 0, 20598, 2868, 1, 0, 0, 0, 20599, + 20600, 7, 15, 0, 0, 20600, 20601, 7, 3, 0, 0, 20601, 20602, 7, 6, 0, 0, + 20602, 20603, 7, 8, 0, 0, 20603, 20604, 7, 6, 0, 0, 20604, 20605, 7, 9, + 0, 0, 20605, 20606, 7, 6, 0, 0, 20606, 20607, 7, 5, 0, 0, 20607, 2870, + 1, 0, 0, 0, 20608, 20609, 7, 15, 0, 0, 20609, 20610, 7, 3, 0, 0, 20610, + 20611, 7, 6, 0, 0, 20611, 20612, 7, 8, 0, 0, 20612, 20613, 7, 6, 0, 0, + 20613, 20614, 7, 9, 0, 0, 20614, 20615, 7, 10, 0, 0, 20615, 20616, 7, 7, + 0, 0, 20616, 20617, 7, 17, 0, 0, 20617, 2872, 1, 0, 0, 0, 20618, 20619, + 7, 15, 0, 0, 20619, 20620, 7, 3, 0, 0, 20620, 20621, 7, 6, 0, 0, 20621, + 20622, 7, 8, 0, 0, 20622, 20623, 7, 10, 0, 0, 20623, 20624, 7, 5, 0, 0, + 20624, 20625, 7, 10, 0, 0, 20625, 20626, 7, 2, 0, 0, 20626, 20627, 7, 7, + 0, 0, 20627, 2874, 1, 0, 0, 0, 20628, 20629, 7, 15, 0, 0, 20629, 20630, + 7, 3, 0, 0, 20630, 20631, 7, 6, 0, 0, 20631, 20632, 7, 8, 0, 0, 20632, + 20633, 7, 2, 0, 0, 20633, 20634, 7, 14, 0, 0, 20634, 20635, 7, 15, 0, 0, + 20635, 20636, 7, 12, 0, 0, 20636, 20637, 7, 4, 0, 0, 20637, 20638, 7, 6, + 0, 0, 20638, 20639, 5, 95, 0, 0, 20639, 20640, 7, 5, 0, 0, 20640, 20641, + 7, 12, 0, 0, 20641, 20642, 7, 1, 0, 0, 20642, 20643, 7, 24, 0, 0, 20643, + 20644, 7, 12, 0, 0, 20644, 20645, 7, 6, 0, 0, 20645, 20646, 7, 3, 0, 0, + 20646, 20647, 7, 18, 0, 0, 20647, 2876, 1, 0, 0, 0, 20648, 20649, 7, 15, + 0, 0, 20649, 20650, 7, 3, 0, 0, 20650, 20651, 7, 6, 0, 0, 20651, 20652, + 7, 9, 0, 0, 20652, 20653, 7, 10, 0, 0, 20653, 20654, 7, 8, 0, 0, 20654, + 20655, 7, 0, 0, 0, 20655, 20656, 7, 4, 0, 0, 20656, 20657, 7, 6, 0, 0, + 20657, 20658, 5, 95, 0, 0, 20658, 20659, 7, 3, 0, 0, 20659, 20660, 7, 6, + 0, 0, 20660, 20661, 7, 2, 0, 0, 20661, 20662, 7, 3, 0, 0, 20662, 20663, + 7, 9, 0, 0, 20663, 20664, 7, 6, 0, 0, 20664, 20665, 7, 3, 0, 0, 20665, + 20666, 7, 5, 0, 0, 20666, 2878, 1, 0, 0, 0, 20667, 20668, 7, 15, 0, 0, + 20668, 20669, 7, 3, 0, 0, 20669, 20670, 7, 6, 0, 0, 20670, 20671, 7, 11, + 0, 0, 20671, 20672, 7, 2, 0, 0, 20672, 20673, 7, 0, 0, 0, 20673, 20674, + 7, 9, 0, 0, 20674, 2880, 1, 0, 0, 0, 20675, 20676, 7, 15, 0, 0, 20676, + 20677, 7, 3, 0, 0, 20677, 20678, 7, 6, 0, 0, 20678, 20679, 7, 15, 0, 0, + 20679, 20680, 7, 0, 0, 0, 20680, 20681, 7, 3, 0, 0, 20681, 20682, 7, 6, + 0, 0, 20682, 2882, 1, 0, 0, 0, 20683, 20684, 7, 15, 0, 0, 20684, 20685, + 7, 3, 0, 0, 20685, 20686, 7, 6, 0, 0, 20686, 20687, 7, 15, 0, 0, 20687, + 20688, 7, 3, 0, 0, 20688, 20689, 7, 2, 0, 0, 20689, 20690, 7, 8, 0, 0, + 20690, 20691, 7, 6, 0, 0, 20691, 20692, 7, 5, 0, 0, 20692, 20693, 7, 5, + 0, 0, 20693, 20694, 7, 2, 0, 0, 20694, 20695, 7, 3, 0, 0, 20695, 2884, + 1, 0, 0, 0, 20696, 20697, 7, 15, 0, 0, 20697, 20698, 7, 3, 0, 0, 20698, + 20699, 7, 6, 0, 0, 20699, 20700, 7, 5, 0, 0, 20700, 20701, 7, 6, 0, 0, + 20701, 20702, 7, 7, 0, 0, 20702, 20703, 7, 4, 0, 0, 20703, 20704, 7, 7, + 0, 0, 20704, 20705, 7, 7, 0, 0, 20705, 20706, 7, 13, 0, 0, 20706, 2886, + 1, 0, 0, 0, 20707, 20708, 7, 15, 0, 0, 20708, 20709, 7, 3, 0, 0, 20709, + 20710, 7, 6, 0, 0, 20710, 20711, 7, 5, 0, 0, 20711, 20712, 7, 6, 0, 0, + 20712, 20713, 7, 7, 0, 0, 20713, 20714, 7, 4, 0, 0, 20714, 2888, 1, 0, + 0, 0, 20715, 20716, 7, 15, 0, 0, 20716, 20717, 7, 3, 0, 0, 20717, 20718, + 7, 6, 0, 0, 20718, 20719, 7, 5, 0, 0, 20719, 20720, 7, 6, 0, 0, 20720, + 20721, 7, 7, 0, 0, 20721, 20722, 7, 4, 0, 0, 20722, 20723, 7, 13, 0, 0, + 20723, 2890, 1, 0, 0, 0, 20724, 20725, 7, 15, 0, 0, 20725, 20726, 7, 3, + 0, 0, 20726, 20727, 7, 6, 0, 0, 20727, 20728, 7, 5, 0, 0, 20728, 20729, + 7, 6, 0, 0, 20729, 20730, 7, 3, 0, 0, 20730, 20731, 7, 13, 0, 0, 20731, + 20732, 7, 6, 0, 0, 20732, 20733, 5, 95, 0, 0, 20733, 20734, 7, 2, 0, 0, + 20734, 20735, 7, 10, 0, 0, 20735, 20736, 7, 9, 0, 0, 20736, 2892, 1, 0, + 0, 0, 20737, 20738, 7, 15, 0, 0, 20738, 20739, 7, 3, 0, 0, 20739, 20740, + 7, 6, 0, 0, 20740, 20741, 7, 5, 0, 0, 20741, 20742, 7, 6, 0, 0, 20742, + 20743, 7, 3, 0, 0, 20743, 20744, 7, 13, 0, 0, 20744, 20745, 7, 6, 0, 0, + 20745, 2894, 1, 0, 0, 0, 20746, 20747, 7, 15, 0, 0, 20747, 20748, 7, 3, + 0, 0, 20748, 20749, 7, 6, 0, 0, 20749, 20750, 7, 4, 0, 0, 20750, 20751, + 7, 4, 0, 0, 20751, 20752, 7, 18, 0, 0, 20752, 2896, 1, 0, 0, 0, 20753, + 20754, 7, 15, 0, 0, 20754, 20755, 7, 3, 0, 0, 20755, 20756, 7, 6, 0, 0, + 20756, 20757, 7, 13, 0, 0, 20757, 20758, 7, 10, 0, 0, 20758, 20759, 7, + 2, 0, 0, 20759, 20760, 7, 12, 0, 0, 20760, 20761, 7, 5, 0, 0, 20761, 2898, + 1, 0, 0, 0, 20762, 20763, 7, 15, 0, 0, 20763, 20764, 7, 3, 0, 0, 20764, + 20765, 7, 6, 0, 0, 20765, 20766, 7, 13, 0, 0, 20766, 2900, 1, 0, 0, 0, + 20767, 20768, 7, 15, 0, 0, 20768, 20769, 7, 3, 0, 0, 20769, 20770, 7, 10, + 0, 0, 20770, 20771, 7, 14, 0, 0, 20771, 20772, 7, 0, 0, 0, 20772, 20773, + 7, 3, 0, 0, 20773, 20774, 7, 18, 0, 0, 20774, 2902, 1, 0, 0, 0, 20775, + 20776, 7, 15, 0, 0, 20776, 20777, 7, 3, 0, 0, 20777, 20778, 7, 10, 0, 0, + 20778, 20779, 7, 7, 0, 0, 20779, 20780, 7, 4, 0, 0, 20780, 20781, 7, 1, + 0, 0, 20781, 20782, 7, 11, 0, 0, 20782, 20783, 7, 2, 0, 0, 20783, 20784, + 7, 1, 0, 0, 20784, 20785, 7, 4, 0, 0, 20785, 20786, 7, 2, 0, 0, 20786, + 20787, 7, 8, 0, 0, 20787, 20788, 7, 11, 0, 0, 20788, 20789, 7, 2, 0, 0, + 20789, 20790, 7, 1, 0, 0, 20790, 2904, 1, 0, 0, 0, 20791, 20792, 7, 15, + 0, 0, 20792, 20793, 7, 3, 0, 0, 20793, 20794, 7, 10, 0, 0, 20794, 20795, + 7, 2, 0, 0, 20795, 20796, 7, 3, 0, 0, 20796, 20797, 7, 10, 0, 0, 20797, + 20798, 7, 4, 0, 0, 20798, 20799, 7, 18, 0, 0, 20799, 2906, 1, 0, 0, 0, + 20800, 20801, 7, 15, 0, 0, 20801, 20802, 7, 3, 0, 0, 20802, 20803, 7, 10, + 0, 0, 20803, 20804, 7, 2, 0, 0, 20804, 20805, 7, 3, 0, 0, 20805, 2908, + 1, 0, 0, 0, 20806, 20807, 7, 15, 0, 0, 20807, 20808, 7, 3, 0, 0, 20808, + 20809, 7, 10, 0, 0, 20809, 20810, 7, 13, 0, 0, 20810, 20811, 7, 0, 0, 0, + 20811, 20812, 7, 4, 0, 0, 20812, 20813, 7, 6, 0, 0, 20813, 2910, 1, 0, + 0, 0, 20814, 20815, 7, 15, 0, 0, 20815, 20816, 7, 3, 0, 0, 20816, 20817, + 7, 10, 0, 0, 20817, 20818, 7, 13, 0, 0, 20818, 20819, 7, 0, 0, 0, 20819, + 20820, 7, 4, 0, 0, 20820, 20821, 7, 6, 0, 0, 20821, 20822, 5, 95, 0, 0, + 20822, 20823, 7, 5, 0, 0, 20823, 20824, 7, 17, 0, 0, 20824, 20825, 7, 0, + 0, 0, 20825, 2912, 1, 0, 0, 0, 20826, 20827, 7, 15, 0, 0, 20827, 20828, + 7, 3, 0, 0, 20828, 20829, 7, 10, 0, 0, 20829, 20830, 7, 13, 0, 0, 20830, + 20831, 7, 10, 0, 0, 20831, 20832, 7, 11, 0, 0, 20832, 20833, 7, 6, 0, 0, + 20833, 20834, 7, 17, 0, 0, 20834, 20835, 7, 6, 0, 0, 20835, 20836, 7, 9, + 0, 0, 20836, 2914, 1, 0, 0, 0, 20837, 20838, 7, 15, 0, 0, 20838, 20839, + 7, 3, 0, 0, 20839, 20840, 7, 10, 0, 0, 20840, 20841, 7, 13, 0, 0, 20841, + 20842, 7, 10, 0, 0, 20842, 20843, 7, 11, 0, 0, 20843, 20844, 7, 6, 0, 0, + 20844, 20845, 7, 17, 0, 0, 20845, 20846, 7, 6, 0, 0, 20846, 2916, 1, 0, + 0, 0, 20847, 20848, 7, 15, 0, 0, 20848, 20849, 7, 3, 0, 0, 20849, 20850, + 7, 10, 0, 0, 20850, 20851, 7, 13, 0, 0, 20851, 20852, 7, 10, 0, 0, 20852, + 20853, 7, 11, 0, 0, 20853, 20854, 7, 6, 0, 0, 20854, 20855, 7, 17, 0, 0, + 20855, 20856, 7, 6, 0, 0, 20856, 20857, 7, 5, 0, 0, 20857, 2918, 1, 0, + 0, 0, 20858, 20859, 7, 15, 0, 0, 20859, 20860, 7, 3, 0, 0, 20860, 20861, + 7, 2, 0, 0, 20861, 20862, 7, 8, 0, 0, 20862, 20863, 7, 6, 0, 0, 20863, + 20864, 7, 9, 0, 0, 20864, 20865, 7, 12, 0, 0, 20865, 20866, 7, 3, 0, 0, + 20866, 20867, 7, 0, 0, 0, 20867, 20868, 7, 11, 0, 0, 20868, 2920, 1, 0, + 0, 0, 20869, 20870, 7, 15, 0, 0, 20870, 20871, 7, 3, 0, 0, 20871, 20872, + 7, 2, 0, 0, 20872, 20873, 7, 8, 0, 0, 20873, 20874, 7, 6, 0, 0, 20874, + 20875, 7, 9, 0, 0, 20875, 20876, 7, 12, 0, 0, 20876, 20877, 7, 3, 0, 0, + 20877, 20878, 7, 6, 0, 0, 20878, 2922, 1, 0, 0, 0, 20879, 20880, 7, 15, + 0, 0, 20880, 20881, 7, 3, 0, 0, 20881, 20882, 7, 2, 0, 0, 20882, 20883, + 7, 8, 0, 0, 20883, 20884, 7, 6, 0, 0, 20884, 20885, 7, 5, 0, 0, 20885, + 20886, 7, 5, 0, 0, 20886, 2924, 1, 0, 0, 0, 20887, 20888, 7, 15, 0, 0, + 20888, 20889, 7, 3, 0, 0, 20889, 20890, 7, 2, 0, 0, 20890, 20891, 7, 16, + 0, 0, 20891, 20892, 7, 10, 0, 0, 20892, 20893, 7, 11, 0, 0, 20893, 20894, + 7, 6, 0, 0, 20894, 2926, 1, 0, 0, 0, 20895, 20896, 7, 15, 0, 0, 20896, + 20897, 7, 3, 0, 0, 20897, 20898, 7, 2, 0, 0, 20898, 20899, 7, 17, 0, 0, + 20899, 20900, 7, 3, 0, 0, 20900, 20901, 7, 0, 0, 0, 20901, 20902, 7, 14, + 0, 0, 20902, 2928, 1, 0, 0, 0, 20903, 20904, 7, 15, 0, 0, 20904, 20905, + 7, 3, 0, 0, 20905, 20906, 7, 2, 0, 0, 20906, 20907, 7, 20, 0, 0, 20907, + 20908, 7, 6, 0, 0, 20908, 20909, 7, 8, 0, 0, 20909, 20910, 7, 4, 0, 0, + 20910, 2930, 1, 0, 0, 0, 20911, 20912, 7, 15, 0, 0, 20912, 20913, 7, 3, + 0, 0, 20913, 20914, 7, 2, 0, 0, 20914, 20915, 7, 15, 0, 0, 20915, 20916, + 7, 0, 0, 0, 20916, 20917, 7, 17, 0, 0, 20917, 20918, 7, 0, 0, 0, 20918, + 20919, 7, 4, 0, 0, 20919, 20920, 7, 6, 0, 0, 20920, 2932, 1, 0, 0, 0, 20921, + 20922, 7, 15, 0, 0, 20922, 20923, 7, 3, 0, 0, 20923, 20924, 7, 2, 0, 0, + 20924, 20925, 7, 15, 0, 0, 20925, 20926, 7, 6, 0, 0, 20926, 20927, 7, 3, + 0, 0, 20927, 20928, 7, 4, 0, 0, 20928, 20929, 7, 18, 0, 0, 20929, 2934, + 1, 0, 0, 0, 20930, 20931, 7, 15, 0, 0, 20931, 20932, 7, 3, 0, 0, 20932, + 20933, 7, 2, 0, 0, 20933, 20934, 7, 4, 0, 0, 20934, 20935, 7, 6, 0, 0, + 20935, 20936, 7, 8, 0, 0, 20936, 20937, 7, 4, 0, 0, 20937, 20938, 7, 6, + 0, 0, 20938, 20939, 7, 9, 0, 0, 20939, 2936, 1, 0, 0, 0, 20940, 20941, + 7, 15, 0, 0, 20941, 20942, 7, 3, 0, 0, 20942, 20943, 7, 2, 0, 0, 20943, + 20944, 7, 4, 0, 0, 20944, 20945, 7, 6, 0, 0, 20945, 20946, 7, 8, 0, 0, + 20946, 20947, 7, 4, 0, 0, 20947, 20948, 7, 10, 0, 0, 20948, 20949, 7, 2, + 0, 0, 20949, 20950, 7, 7, 0, 0, 20950, 2938, 1, 0, 0, 0, 20951, 20952, + 7, 15, 0, 0, 20952, 20953, 7, 3, 0, 0, 20953, 20954, 7, 2, 0, 0, 20954, + 20955, 7, 4, 0, 0, 20955, 20956, 7, 2, 0, 0, 20956, 20957, 7, 8, 0, 0, + 20957, 20958, 7, 2, 0, 0, 20958, 20959, 7, 11, 0, 0, 20959, 2940, 1, 0, + 0, 0, 20960, 20961, 7, 15, 0, 0, 20961, 20962, 7, 3, 0, 0, 20962, 20963, + 7, 2, 0, 0, 20963, 20964, 7, 25, 0, 0, 20964, 20965, 7, 18, 0, 0, 20965, + 2942, 1, 0, 0, 0, 20966, 20967, 7, 15, 0, 0, 20967, 20968, 7, 3, 0, 0, + 20968, 20969, 7, 12, 0, 0, 20969, 20970, 7, 7, 0, 0, 20970, 20971, 7, 10, + 0, 0, 20971, 20972, 7, 7, 0, 0, 20972, 20973, 7, 17, 0, 0, 20973, 2944, + 1, 0, 0, 0, 20974, 20975, 7, 15, 0, 0, 20975, 20976, 7, 12, 0, 0, 20976, + 20977, 7, 1, 0, 0, 20977, 20978, 7, 11, 0, 0, 20978, 20979, 7, 10, 0, 0, + 20979, 20980, 7, 8, 0, 0, 20980, 2946, 1, 0, 0, 0, 20981, 20982, 7, 15, + 0, 0, 20982, 20983, 7, 12, 0, 0, 20983, 20984, 7, 11, 0, 0, 20984, 20985, + 7, 11, 0, 0, 20985, 20986, 5, 95, 0, 0, 20986, 20987, 7, 15, 0, 0, 20987, + 20988, 7, 3, 0, 0, 20988, 20989, 7, 6, 0, 0, 20989, 20990, 7, 9, 0, 0, + 20990, 2948, 1, 0, 0, 0, 20991, 20992, 7, 15, 0, 0, 20992, 20993, 7, 12, + 0, 0, 20993, 20994, 7, 3, 0, 0, 20994, 20995, 7, 17, 0, 0, 20995, 20996, + 7, 6, 0, 0, 20996, 2950, 1, 0, 0, 0, 20997, 20998, 7, 15, 0, 0, 20998, + 20999, 7, 12, 0, 0, 20999, 21000, 7, 5, 0, 0, 21000, 21001, 7, 19, 0, 0, + 21001, 21002, 5, 95, 0, 0, 21002, 21003, 7, 15, 0, 0, 21003, 21004, 7, + 3, 0, 0, 21004, 21005, 7, 6, 0, 0, 21005, 21006, 7, 9, 0, 0, 21006, 2952, + 1, 0, 0, 0, 21007, 21008, 7, 15, 0, 0, 21008, 21009, 7, 12, 0, 0, 21009, + 21010, 7, 5, 0, 0, 21010, 21011, 7, 19, 0, 0, 21011, 21012, 5, 95, 0, 0, + 21012, 21013, 7, 5, 0, 0, 21013, 21014, 7, 12, 0, 0, 21014, 21015, 7, 1, + 0, 0, 21015, 21016, 7, 24, 0, 0, 21016, 2954, 1, 0, 0, 0, 21017, 21018, + 7, 15, 0, 0, 21018, 21019, 7, 25, 0, 0, 21019, 21020, 5, 95, 0, 0, 21020, + 21021, 7, 16, 0, 0, 21021, 21022, 7, 0, 0, 0, 21022, 21023, 7, 12, 0, 0, + 21023, 21024, 7, 11, 0, 0, 21024, 21025, 7, 4, 0, 0, 21025, 21026, 5, 95, + 0, 0, 21026, 21027, 7, 4, 0, 0, 21027, 21028, 7, 2, 0, 0, 21028, 21029, + 7, 11, 0, 0, 21029, 21030, 7, 6, 0, 0, 21030, 21031, 7, 3, 0, 0, 21031, + 21032, 7, 0, 0, 0, 21032, 21033, 7, 7, 0, 0, 21033, 21034, 7, 8, 0, 0, + 21034, 21035, 7, 6, 0, 0, 21035, 2956, 1, 0, 0, 0, 21036, 21037, 7, 15, + 0, 0, 21037, 21038, 7, 25, 0, 0, 21038, 21039, 5, 95, 0, 0, 21039, 21040, + 7, 17, 0, 0, 21040, 21041, 7, 3, 0, 0, 21041, 21042, 7, 0, 0, 0, 21042, + 21043, 7, 7, 0, 0, 21043, 21044, 7, 12, 0, 0, 21044, 21045, 7, 11, 0, 0, + 21045, 21046, 7, 6, 0, 0, 21046, 2958, 1, 0, 0, 0, 21047, 21048, 7, 15, + 0, 0, 21048, 21049, 7, 25, 0, 0, 21049, 21050, 5, 95, 0, 0, 21050, 21051, + 7, 20, 0, 0, 21051, 21052, 7, 2, 0, 0, 21052, 21053, 7, 10, 0, 0, 21053, + 21054, 7, 7, 0, 0, 21054, 21055, 5, 95, 0, 0, 21055, 21056, 7, 16, 0, 0, + 21056, 21057, 7, 10, 0, 0, 21057, 21058, 7, 11, 0, 0, 21058, 21059, 7, + 4, 0, 0, 21059, 21060, 7, 6, 0, 0, 21060, 21061, 7, 3, 0, 0, 21061, 2960, + 1, 0, 0, 0, 21062, 21063, 7, 24, 0, 0, 21063, 21064, 7, 1, 0, 0, 21064, + 21065, 5, 95, 0, 0, 21065, 21066, 7, 7, 0, 0, 21066, 21067, 7, 0, 0, 0, + 21067, 21068, 7, 14, 0, 0, 21068, 21069, 7, 6, 0, 0, 21069, 2962, 1, 0, + 0, 0, 21070, 21071, 7, 24, 0, 0, 21071, 21072, 7, 12, 0, 0, 21072, 21073, + 7, 0, 0, 0, 21073, 21074, 7, 3, 0, 0, 21074, 21075, 7, 4, 0, 0, 21075, + 21076, 7, 6, 0, 0, 21076, 21077, 7, 3, 0, 0, 21077, 21078, 7, 5, 0, 0, + 21078, 2964, 1, 0, 0, 0, 21079, 21080, 7, 24, 0, 0, 21080, 21081, 7, 12, + 0, 0, 21081, 21082, 7, 6, 0, 0, 21082, 21083, 7, 3, 0, 0, 21083, 21084, + 7, 18, 0, 0, 21084, 21085, 5, 95, 0, 0, 21085, 21086, 7, 1, 0, 0, 21086, + 21087, 7, 11, 0, 0, 21087, 21088, 7, 2, 0, 0, 21088, 21089, 7, 8, 0, 0, + 21089, 21090, 7, 21, 0, 0, 21090, 2966, 1, 0, 0, 0, 21091, 21092, 7, 24, + 0, 0, 21092, 21093, 7, 12, 0, 0, 21093, 21094, 7, 6, 0, 0, 21094, 21095, + 7, 3, 0, 0, 21095, 21096, 7, 18, 0, 0, 21096, 2968, 1, 0, 0, 0, 21097, + 21098, 7, 24, 0, 0, 21098, 21099, 7, 12, 0, 0, 21099, 21100, 7, 6, 0, 0, + 21100, 21101, 7, 12, 0, 0, 21101, 21102, 7, 6, 0, 0, 21102, 21103, 5, 95, + 0, 0, 21103, 21104, 7, 8, 0, 0, 21104, 21105, 7, 12, 0, 0, 21105, 21106, + 7, 3, 0, 0, 21106, 21107, 7, 3, 0, 0, 21107, 2970, 1, 0, 0, 0, 21108, 21109, + 7, 24, 0, 0, 21109, 21110, 7, 12, 0, 0, 21110, 21111, 7, 6, 0, 0, 21111, + 21112, 7, 12, 0, 0, 21112, 21113, 7, 6, 0, 0, 21113, 2972, 1, 0, 0, 0, + 21114, 21115, 7, 24, 0, 0, 21115, 21116, 7, 12, 0, 0, 21116, 21117, 7, + 6, 0, 0, 21117, 21118, 7, 12, 0, 0, 21118, 21119, 7, 6, 0, 0, 21119, 21120, + 5, 95, 0, 0, 21120, 21121, 7, 3, 0, 0, 21121, 21122, 7, 2, 0, 0, 21122, + 21123, 7, 22, 0, 0, 21123, 21124, 7, 15, 0, 0, 21124, 2974, 1, 0, 0, 0, + 21125, 21126, 7, 24, 0, 0, 21126, 21127, 7, 12, 0, 0, 21127, 21128, 7, + 10, 0, 0, 21128, 21129, 7, 6, 0, 0, 21129, 21130, 7, 5, 0, 0, 21130, 21131, + 7, 8, 0, 0, 21131, 21132, 7, 6, 0, 0, 21132, 2976, 1, 0, 0, 0, 21133, 21134, + 7, 24, 0, 0, 21134, 21135, 7, 12, 0, 0, 21135, 21136, 7, 2, 0, 0, 21136, + 21137, 7, 3, 0, 0, 21137, 21138, 7, 12, 0, 0, 21138, 21139, 7, 14, 0, 0, + 21139, 2978, 1, 0, 0, 0, 21140, 21141, 7, 24, 0, 0, 21141, 21142, 7, 12, + 0, 0, 21142, 21143, 7, 2, 0, 0, 21143, 21144, 7, 4, 0, 0, 21144, 21145, + 7, 0, 0, 0, 21145, 2980, 1, 0, 0, 0, 21146, 21147, 7, 24, 0, 0, 21147, + 21148, 7, 12, 0, 0, 21148, 21149, 7, 2, 0, 0, 21149, 21150, 7, 4, 0, 0, + 21150, 21151, 7, 0, 0, 0, 21151, 21152, 7, 17, 0, 0, 21152, 21153, 7, 3, + 0, 0, 21153, 21154, 7, 2, 0, 0, 21154, 21155, 7, 12, 0, 0, 21155, 21156, + 7, 15, 0, 0, 21156, 2982, 1, 0, 0, 0, 21157, 21158, 7, 3, 0, 0, 21158, + 21159, 7, 0, 0, 0, 21159, 21160, 7, 10, 0, 0, 21160, 21161, 7, 5, 0, 0, + 21161, 21162, 7, 6, 0, 0, 21162, 2984, 1, 0, 0, 0, 21163, 21164, 7, 3, + 0, 0, 21164, 21165, 7, 0, 0, 0, 21165, 21166, 7, 7, 0, 0, 21166, 21167, + 7, 9, 0, 0, 21167, 21168, 7, 2, 0, 0, 21168, 21169, 7, 14, 0, 0, 21169, + 21170, 5, 95, 0, 0, 21170, 21171, 7, 11, 0, 0, 21171, 21172, 7, 2, 0, 0, + 21172, 21173, 7, 8, 0, 0, 21173, 21174, 7, 0, 0, 0, 21174, 21175, 7, 11, + 0, 0, 21175, 2986, 1, 0, 0, 0, 21176, 21177, 7, 3, 0, 0, 21177, 21178, + 7, 0, 0, 0, 21178, 21179, 7, 7, 0, 0, 21179, 21180, 7, 9, 0, 0, 21180, + 21181, 7, 2, 0, 0, 21181, 21182, 7, 14, 0, 0, 21182, 2988, 1, 0, 0, 0, + 21183, 21184, 7, 3, 0, 0, 21184, 21185, 7, 0, 0, 0, 21185, 21186, 7, 7, + 0, 0, 21186, 21187, 7, 17, 0, 0, 21187, 21188, 7, 6, 0, 0, 21188, 2990, + 1, 0, 0, 0, 21189, 21190, 7, 3, 0, 0, 21190, 21191, 7, 0, 0, 0, 21191, + 21192, 7, 7, 0, 0, 21192, 21193, 7, 21, 0, 0, 21193, 21194, 7, 14, 0, 0, + 21194, 2992, 1, 0, 0, 0, 21195, 21196, 7, 3, 0, 0, 21196, 21197, 7, 0, + 0, 0, 21197, 21198, 7, 15, 0, 0, 21198, 21199, 7, 10, 0, 0, 21199, 21200, + 7, 9, 0, 0, 21200, 21201, 7, 11, 0, 0, 21201, 21202, 7, 18, 0, 0, 21202, + 2994, 1, 0, 0, 0, 21203, 21204, 7, 3, 0, 0, 21204, 21205, 7, 0, 0, 0, 21205, + 21206, 7, 22, 0, 0, 21206, 2996, 1, 0, 0, 0, 21207, 21208, 7, 3, 0, 0, + 21208, 21209, 7, 0, 0, 0, 21209, 21210, 7, 22, 0, 0, 21210, 21211, 7, 4, + 0, 0, 21211, 21212, 7, 2, 0, 0, 21212, 21213, 7, 19, 0, 0, 21213, 21214, + 7, 6, 0, 0, 21214, 21215, 7, 25, 0, 0, 21215, 2998, 1, 0, 0, 0, 21216, + 21217, 7, 3, 0, 0, 21217, 21218, 7, 0, 0, 0, 21218, 21219, 7, 22, 0, 0, + 21219, 21220, 7, 4, 0, 0, 21220, 21221, 7, 2, 0, 0, 21221, 21222, 7, 7, + 0, 0, 21222, 21223, 7, 19, 0, 0, 21223, 21224, 7, 6, 0, 0, 21224, 21225, + 7, 25, 0, 0, 21225, 3000, 1, 0, 0, 0, 21226, 21227, 7, 3, 0, 0, 21227, + 21228, 7, 1, 0, 0, 21228, 21229, 7, 0, 0, 0, 21229, 3002, 1, 0, 0, 0, 21230, + 21231, 7, 3, 0, 0, 21231, 21232, 7, 1, 0, 0, 21232, 21233, 7, 2, 0, 0, + 21233, 21234, 5, 95, 0, 0, 21234, 21235, 7, 2, 0, 0, 21235, 21236, 7, 12, + 0, 0, 21236, 21237, 7, 4, 0, 0, 21237, 21238, 7, 11, 0, 0, 21238, 21239, + 7, 10, 0, 0, 21239, 21240, 7, 7, 0, 0, 21240, 21241, 7, 6, 0, 0, 21241, + 3004, 1, 0, 0, 0, 21242, 21243, 7, 3, 0, 0, 21243, 21244, 7, 8, 0, 0, 21244, + 21245, 7, 16, 0, 0, 21245, 21246, 7, 10, 0, 0, 21246, 21247, 7, 11, 0, + 0, 21247, 21248, 7, 6, 0, 0, 21248, 3006, 1, 0, 0, 0, 21249, 21250, 7, + 3, 0, 0, 21250, 21251, 7, 9, 0, 0, 21251, 21252, 7, 1, 0, 0, 21252, 21253, + 7, 0, 0, 0, 21253, 3008, 1, 0, 0, 0, 21254, 21255, 7, 3, 0, 0, 21255, 21256, + 7, 6, 0, 0, 21256, 21257, 7, 0, 0, 0, 21257, 21258, 7, 9, 0, 0, 21258, + 3010, 1, 0, 0, 0, 21259, 21260, 7, 3, 0, 0, 21260, 21261, 7, 6, 0, 0, 21261, + 21262, 7, 0, 0, 0, 21262, 21263, 7, 9, 0, 0, 21263, 21264, 7, 5, 0, 0, + 21264, 3012, 1, 0, 0, 0, 21265, 21266, 7, 3, 0, 0, 21266, 21267, 7, 6, + 0, 0, 21267, 21268, 7, 0, 0, 0, 21268, 21269, 7, 9, 0, 0, 21269, 21270, + 7, 5, 0, 0, 21270, 21271, 7, 10, 0, 0, 21271, 21272, 7, 23, 0, 0, 21272, + 21273, 7, 6, 0, 0, 21273, 3014, 1, 0, 0, 0, 21274, 21275, 7, 3, 0, 0, 21275, + 21276, 7, 6, 0, 0, 21276, 21277, 7, 0, 0, 0, 21277, 21278, 7, 11, 0, 0, + 21278, 21279, 7, 14, 0, 0, 21279, 3016, 1, 0, 0, 0, 21280, 21281, 7, 3, + 0, 0, 21281, 21282, 7, 6, 0, 0, 21282, 21283, 7, 0, 0, 0, 21283, 21284, + 7, 11, 0, 0, 21284, 3018, 1, 0, 0, 0, 21285, 21286, 7, 3, 0, 0, 21286, + 21287, 7, 6, 0, 0, 21287, 21288, 7, 1, 0, 0, 21288, 21289, 7, 0, 0, 0, + 21289, 21290, 7, 11, 0, 0, 21290, 21291, 7, 0, 0, 0, 21291, 21292, 7, 7, + 0, 0, 21292, 21293, 7, 8, 0, 0, 21293, 21294, 7, 6, 0, 0, 21294, 3020, + 1, 0, 0, 0, 21295, 21296, 7, 3, 0, 0, 21296, 21297, 7, 6, 0, 0, 21297, + 21298, 7, 1, 0, 0, 21298, 21299, 7, 12, 0, 0, 21299, 21300, 7, 10, 0, 0, + 21300, 21301, 7, 11, 0, 0, 21301, 21302, 7, 9, 0, 0, 21302, 3022, 1, 0, + 0, 0, 21303, 21304, 7, 3, 0, 0, 21304, 21305, 7, 6, 0, 0, 21305, 21306, + 7, 8, 0, 0, 21306, 21307, 7, 2, 0, 0, 21307, 21308, 7, 3, 0, 0, 21308, + 21309, 7, 9, 0, 0, 21309, 3024, 1, 0, 0, 0, 21310, 21311, 7, 3, 0, 0, 21311, + 21312, 7, 6, 0, 0, 21312, 21313, 7, 8, 0, 0, 21313, 21314, 7, 2, 0, 0, + 21314, 21315, 7, 3, 0, 0, 21315, 21316, 7, 9, 0, 0, 21316, 21317, 7, 5, + 0, 0, 21317, 3026, 1, 0, 0, 0, 21318, 21319, 7, 3, 0, 0, 21319, 21320, + 7, 6, 0, 0, 21320, 21321, 7, 8, 0, 0, 21321, 21322, 7, 2, 0, 0, 21322, + 21323, 7, 3, 0, 0, 21323, 21324, 7, 9, 0, 0, 21324, 21325, 7, 5, 0, 0, + 21325, 21326, 5, 95, 0, 0, 21326, 21327, 7, 15, 0, 0, 21327, 21328, 7, + 6, 0, 0, 21328, 21329, 7, 3, 0, 0, 21329, 21330, 5, 95, 0, 0, 21330, 21331, + 7, 1, 0, 0, 21331, 21332, 7, 11, 0, 0, 21332, 21333, 7, 2, 0, 0, 21333, + 21334, 7, 8, 0, 0, 21334, 21335, 7, 21, 0, 0, 21335, 3028, 1, 0, 0, 0, + 21336, 21337, 7, 3, 0, 0, 21337, 21338, 7, 6, 0, 0, 21338, 21339, 7, 8, + 0, 0, 21339, 21340, 7, 2, 0, 0, 21340, 21341, 7, 13, 0, 0, 21341, 21342, + 7, 6, 0, 0, 21342, 21343, 7, 3, 0, 0, 21343, 21344, 7, 0, 0, 0, 21344, + 21345, 7, 1, 0, 0, 21345, 21346, 7, 11, 0, 0, 21346, 21347, 7, 6, 0, 0, + 21347, 3030, 1, 0, 0, 0, 21348, 21349, 7, 3, 0, 0, 21349, 21350, 7, 6, + 0, 0, 21350, 21351, 7, 8, 0, 0, 21351, 21352, 7, 2, 0, 0, 21352, 21353, + 7, 13, 0, 0, 21353, 21354, 7, 6, 0, 0, 21354, 21355, 7, 3, 0, 0, 21355, + 3032, 1, 0, 0, 0, 21356, 21357, 7, 3, 0, 0, 21357, 21358, 7, 6, 0, 0, 21358, + 21359, 7, 8, 0, 0, 21359, 21360, 7, 2, 0, 0, 21360, 21361, 7, 13, 0, 0, + 21361, 21362, 7, 6, 0, 0, 21362, 21363, 7, 3, 0, 0, 21363, 21364, 7, 18, + 0, 0, 21364, 3034, 1, 0, 0, 0, 21365, 21366, 7, 3, 0, 0, 21366, 21367, + 7, 6, 0, 0, 21367, 21368, 7, 8, 0, 0, 21368, 21369, 7, 18, 0, 0, 21369, + 21370, 7, 8, 0, 0, 21370, 21371, 7, 11, 0, 0, 21371, 21372, 7, 6, 0, 0, + 21372, 21373, 7, 1, 0, 0, 21373, 21374, 7, 10, 0, 0, 21374, 21375, 7, 7, + 0, 0, 21375, 3036, 1, 0, 0, 0, 21376, 21377, 7, 3, 0, 0, 21377, 21378, + 7, 6, 0, 0, 21378, 21379, 7, 8, 0, 0, 21379, 21380, 7, 18, 0, 0, 21380, + 21381, 7, 8, 0, 0, 21381, 21382, 7, 11, 0, 0, 21382, 21383, 7, 6, 0, 0, + 21383, 3038, 1, 0, 0, 0, 21384, 21385, 7, 3, 0, 0, 21385, 21386, 7, 6, + 0, 0, 21386, 21387, 7, 9, 0, 0, 21387, 21388, 7, 0, 0, 0, 21388, 21389, + 7, 8, 0, 0, 21389, 21390, 7, 4, 0, 0, 21390, 21391, 7, 10, 0, 0, 21391, + 21392, 7, 2, 0, 0, 21392, 21393, 7, 7, 0, 0, 21393, 3040, 1, 0, 0, 0, 21394, + 21395, 7, 3, 0, 0, 21395, 21396, 7, 6, 0, 0, 21396, 21397, 7, 9, 0, 0, + 21397, 21398, 7, 6, 0, 0, 21398, 21399, 7, 16, 0, 0, 21399, 21400, 7, 10, + 0, 0, 21400, 21401, 7, 7, 0, 0, 21401, 21402, 7, 6, 0, 0, 21402, 3042, + 1, 0, 0, 0, 21403, 21404, 7, 3, 0, 0, 21404, 21405, 7, 6, 0, 0, 21405, + 21406, 7, 9, 0, 0, 21406, 21407, 7, 2, 0, 0, 21407, 3044, 1, 0, 0, 0, 21408, + 21409, 7, 3, 0, 0, 21409, 21410, 7, 6, 0, 0, 21410, 21411, 7, 9, 0, 0, + 21411, 21412, 7, 12, 0, 0, 21412, 21413, 7, 8, 0, 0, 21413, 21414, 7, 6, + 0, 0, 21414, 21415, 7, 9, 0, 0, 21415, 3046, 1, 0, 0, 0, 21416, 21417, + 7, 3, 0, 0, 21417, 21418, 7, 6, 0, 0, 21418, 21419, 7, 9, 0, 0, 21419, + 21420, 7, 12, 0, 0, 21420, 21421, 7, 7, 0, 0, 21421, 21422, 7, 9, 0, 0, + 21422, 21423, 7, 0, 0, 0, 21423, 21424, 7, 7, 0, 0, 21424, 21425, 7, 8, + 0, 0, 21425, 21426, 7, 18, 0, 0, 21426, 3048, 1, 0, 0, 0, 21427, 21428, + 7, 3, 0, 0, 21428, 21429, 7, 6, 0, 0, 21429, 21430, 7, 16, 0, 0, 21430, + 21431, 5, 95, 0, 0, 21431, 21432, 7, 8, 0, 0, 21432, 21433, 7, 0, 0, 0, + 21433, 21434, 7, 5, 0, 0, 21434, 21435, 7, 8, 0, 0, 21435, 21436, 7, 0, + 0, 0, 21436, 21437, 7, 9, 0, 0, 21437, 21438, 7, 6, 0, 0, 21438, 21439, + 5, 95, 0, 0, 21439, 21440, 7, 8, 0, 0, 21440, 21441, 7, 12, 0, 0, 21441, + 21442, 7, 3, 0, 0, 21442, 21443, 7, 5, 0, 0, 21443, 21444, 7, 2, 0, 0, + 21444, 21445, 7, 3, 0, 0, 21445, 3050, 1, 0, 0, 0, 21446, 21447, 7, 3, + 0, 0, 21447, 21448, 7, 6, 0, 0, 21448, 21449, 7, 16, 0, 0, 21449, 21450, + 7, 6, 0, 0, 21450, 21451, 7, 3, 0, 0, 21451, 21452, 7, 6, 0, 0, 21452, + 21453, 7, 7, 0, 0, 21453, 21454, 7, 8, 0, 0, 21454, 21455, 7, 6, 0, 0, + 21455, 21456, 7, 9, 0, 0, 21456, 3052, 1, 0, 0, 0, 21457, 21458, 7, 3, + 0, 0, 21458, 21459, 7, 6, 0, 0, 21459, 21460, 7, 16, 0, 0, 21460, 21461, + 7, 6, 0, 0, 21461, 21462, 7, 3, 0, 0, 21462, 21463, 7, 6, 0, 0, 21463, + 21464, 7, 7, 0, 0, 21464, 21465, 7, 8, 0, 0, 21465, 21466, 7, 6, 0, 0, + 21466, 3054, 1, 0, 0, 0, 21467, 21468, 7, 3, 0, 0, 21468, 21469, 7, 6, + 0, 0, 21469, 21470, 7, 16, 0, 0, 21470, 21471, 7, 6, 0, 0, 21471, 21472, + 7, 3, 0, 0, 21472, 21473, 7, 6, 0, 0, 21473, 21474, 7, 7, 0, 0, 21474, + 21475, 7, 8, 0, 0, 21475, 21476, 7, 6, 0, 0, 21476, 21477, 7, 5, 0, 0, + 21477, 3056, 1, 0, 0, 0, 21478, 21479, 7, 3, 0, 0, 21479, 21480, 7, 6, + 0, 0, 21480, 21481, 7, 16, 0, 0, 21481, 21482, 7, 6, 0, 0, 21482, 21483, + 7, 3, 0, 0, 21483, 21484, 7, 6, 0, 0, 21484, 21485, 7, 7, 0, 0, 21485, + 21486, 7, 8, 0, 0, 21486, 21487, 7, 10, 0, 0, 21487, 21488, 7, 7, 0, 0, + 21488, 21489, 7, 17, 0, 0, 21489, 3058, 1, 0, 0, 0, 21490, 21491, 7, 3, + 0, 0, 21491, 21492, 7, 6, 0, 0, 21492, 21493, 7, 16, 0, 0, 21493, 3060, + 1, 0, 0, 0, 21494, 21495, 7, 3, 0, 0, 21495, 21496, 7, 6, 0, 0, 21496, + 21497, 7, 16, 0, 0, 21497, 21498, 7, 3, 0, 0, 21498, 21499, 7, 6, 0, 0, + 21499, 21500, 7, 5, 0, 0, 21500, 21501, 7, 19, 0, 0, 21501, 3062, 1, 0, + 0, 0, 21502, 21503, 7, 3, 0, 0, 21503, 21504, 7, 6, 0, 0, 21504, 21505, + 7, 16, 0, 0, 21505, 21506, 7, 4, 0, 0, 21506, 21507, 7, 2, 0, 0, 21507, + 21508, 7, 19, 0, 0, 21508, 21509, 7, 6, 0, 0, 21509, 21510, 7, 25, 0, 0, + 21510, 3064, 1, 0, 0, 0, 21511, 21512, 7, 3, 0, 0, 21512, 21513, 7, 6, + 0, 0, 21513, 21514, 7, 17, 0, 0, 21514, 21515, 7, 6, 0, 0, 21515, 21516, + 7, 25, 0, 0, 21516, 21517, 7, 15, 0, 0, 21517, 21518, 5, 95, 0, 0, 21518, + 21519, 7, 8, 0, 0, 21519, 21520, 7, 2, 0, 0, 21520, 21521, 7, 12, 0, 0, + 21521, 21522, 7, 7, 0, 0, 21522, 21523, 7, 4, 0, 0, 21523, 3066, 1, 0, + 0, 0, 21524, 21525, 7, 3, 0, 0, 21525, 21526, 7, 6, 0, 0, 21526, 21527, + 7, 17, 0, 0, 21527, 21528, 7, 6, 0, 0, 21528, 21529, 7, 25, 0, 0, 21529, + 21530, 7, 15, 0, 0, 21530, 21531, 5, 95, 0, 0, 21531, 21532, 7, 10, 0, + 0, 21532, 21533, 7, 7, 0, 0, 21533, 21534, 7, 5, 0, 0, 21534, 21535, 7, + 4, 0, 0, 21535, 21536, 7, 3, 0, 0, 21536, 3068, 1, 0, 0, 0, 21537, 21538, + 7, 3, 0, 0, 21538, 21539, 7, 6, 0, 0, 21539, 21540, 7, 17, 0, 0, 21540, + 21541, 7, 6, 0, 0, 21541, 21542, 7, 25, 0, 0, 21542, 21543, 7, 15, 0, 0, + 21543, 21544, 5, 95, 0, 0, 21544, 21545, 7, 11, 0, 0, 21545, 21546, 7, + 10, 0, 0, 21546, 21547, 7, 21, 0, 0, 21547, 21548, 7, 6, 0, 0, 21548, 3070, + 1, 0, 0, 0, 21549, 21550, 7, 3, 0, 0, 21550, 21551, 7, 6, 0, 0, 21551, + 21552, 7, 17, 0, 0, 21552, 21553, 7, 6, 0, 0, 21553, 21554, 7, 25, 0, 0, + 21554, 21555, 7, 15, 0, 0, 21555, 21556, 5, 95, 0, 0, 21556, 21557, 7, + 3, 0, 0, 21557, 21558, 7, 6, 0, 0, 21558, 21559, 7, 15, 0, 0, 21559, 21560, + 7, 11, 0, 0, 21560, 21561, 7, 0, 0, 0, 21561, 21562, 7, 8, 0, 0, 21562, + 21563, 7, 6, 0, 0, 21563, 3072, 1, 0, 0, 0, 21564, 21565, 7, 3, 0, 0, 21565, + 21566, 7, 6, 0, 0, 21566, 21567, 7, 17, 0, 0, 21567, 21568, 7, 6, 0, 0, + 21568, 21569, 7, 25, 0, 0, 21569, 21570, 7, 15, 0, 0, 21570, 21571, 5, + 95, 0, 0, 21571, 21572, 7, 5, 0, 0, 21572, 21573, 7, 12, 0, 0, 21573, 21574, + 7, 1, 0, 0, 21574, 21575, 7, 5, 0, 0, 21575, 21576, 7, 4, 0, 0, 21576, + 21577, 7, 3, 0, 0, 21577, 3074, 1, 0, 0, 0, 21578, 21579, 7, 3, 0, 0, 21579, + 21580, 7, 6, 0, 0, 21580, 21581, 7, 17, 0, 0, 21581, 21582, 7, 10, 0, 0, + 21582, 21583, 7, 5, 0, 0, 21583, 21584, 7, 4, 0, 0, 21584, 21585, 7, 6, + 0, 0, 21585, 21586, 7, 3, 0, 0, 21586, 3076, 1, 0, 0, 0, 21587, 21588, + 7, 3, 0, 0, 21588, 21589, 7, 6, 0, 0, 21589, 21590, 7, 17, 0, 0, 21590, + 21591, 7, 3, 0, 0, 21591, 21592, 5, 95, 0, 0, 21592, 21593, 7, 0, 0, 0, + 21593, 21594, 7, 13, 0, 0, 21594, 21595, 7, 17, 0, 0, 21595, 21596, 7, + 25, 0, 0, 21596, 3078, 1, 0, 0, 0, 21597, 21598, 7, 3, 0, 0, 21598, 21599, + 7, 6, 0, 0, 21599, 21600, 7, 17, 0, 0, 21600, 21601, 7, 3, 0, 0, 21601, + 21602, 5, 95, 0, 0, 21602, 21603, 7, 0, 0, 0, 21603, 21604, 7, 13, 0, 0, + 21604, 21605, 7, 17, 0, 0, 21605, 21606, 7, 18, 0, 0, 21606, 3080, 1, 0, + 0, 0, 21607, 21608, 7, 3, 0, 0, 21608, 21609, 7, 6, 0, 0, 21609, 21610, + 7, 17, 0, 0, 21610, 21611, 7, 3, 0, 0, 21611, 21612, 5, 95, 0, 0, 21612, + 21613, 7, 8, 0, 0, 21613, 21614, 7, 2, 0, 0, 21614, 21615, 7, 12, 0, 0, + 21615, 21616, 7, 7, 0, 0, 21616, 21617, 7, 4, 0, 0, 21617, 3082, 1, 0, + 0, 0, 21618, 21619, 7, 3, 0, 0, 21619, 21620, 7, 6, 0, 0, 21620, 21621, + 7, 17, 0, 0, 21621, 21622, 7, 3, 0, 0, 21622, 21623, 5, 95, 0, 0, 21623, + 21624, 7, 10, 0, 0, 21624, 21625, 7, 7, 0, 0, 21625, 21626, 7, 4, 0, 0, + 21626, 21627, 7, 6, 0, 0, 21627, 21628, 7, 3, 0, 0, 21628, 21629, 7, 8, + 0, 0, 21629, 21630, 7, 6, 0, 0, 21630, 21631, 7, 15, 0, 0, 21631, 21632, + 7, 4, 0, 0, 21632, 3084, 1, 0, 0, 0, 21633, 21634, 7, 3, 0, 0, 21634, 21635, + 7, 6, 0, 0, 21635, 21636, 7, 17, 0, 0, 21636, 21637, 7, 3, 0, 0, 21637, + 21638, 5, 95, 0, 0, 21638, 21639, 7, 3, 0, 0, 21639, 21640, 5, 50, 0, 0, + 21640, 3086, 1, 0, 0, 0, 21641, 21642, 7, 3, 0, 0, 21642, 21643, 7, 6, + 0, 0, 21643, 21644, 7, 17, 0, 0, 21644, 21645, 7, 3, 0, 0, 21645, 21646, + 5, 95, 0, 0, 21646, 21647, 7, 5, 0, 0, 21647, 21648, 7, 11, 0, 0, 21648, + 21649, 7, 2, 0, 0, 21649, 21650, 7, 15, 0, 0, 21650, 21651, 7, 6, 0, 0, + 21651, 3088, 1, 0, 0, 0, 21652, 21653, 7, 3, 0, 0, 21653, 21654, 7, 6, + 0, 0, 21654, 21655, 7, 17, 0, 0, 21655, 21656, 7, 3, 0, 0, 21656, 21657, + 5, 95, 0, 0, 21657, 21658, 7, 5, 0, 0, 21658, 21659, 7, 25, 0, 0, 21659, + 21660, 7, 25, 0, 0, 21660, 3090, 1, 0, 0, 0, 21661, 21662, 7, 3, 0, 0, + 21662, 21663, 7, 6, 0, 0, 21663, 21664, 7, 17, 0, 0, 21664, 21665, 7, 3, + 0, 0, 21665, 21666, 5, 95, 0, 0, 21666, 21667, 7, 5, 0, 0, 21667, 21668, + 7, 25, 0, 0, 21668, 21669, 7, 18, 0, 0, 21669, 3092, 1, 0, 0, 0, 21670, + 21671, 7, 3, 0, 0, 21671, 21672, 7, 6, 0, 0, 21672, 21673, 7, 17, 0, 0, + 21673, 21674, 7, 3, 0, 0, 21674, 21675, 5, 95, 0, 0, 21675, 21676, 7, 5, + 0, 0, 21676, 21677, 7, 18, 0, 0, 21677, 21678, 7, 18, 0, 0, 21678, 3094, + 1, 0, 0, 0, 21679, 21680, 7, 3, 0, 0, 21680, 21681, 7, 6, 0, 0, 21681, + 21682, 7, 17, 0, 0, 21682, 21683, 7, 12, 0, 0, 21683, 21684, 7, 11, 0, + 0, 21684, 21685, 7, 0, 0, 0, 21685, 21686, 7, 3, 0, 0, 21686, 3096, 1, + 0, 0, 0, 21687, 21688, 7, 3, 0, 0, 21688, 21689, 7, 6, 0, 0, 21689, 21690, + 7, 20, 0, 0, 21690, 21691, 7, 6, 0, 0, 21691, 21692, 7, 8, 0, 0, 21692, + 21693, 7, 4, 0, 0, 21693, 3098, 1, 0, 0, 0, 21694, 21695, 7, 3, 0, 0, 21695, + 21696, 7, 6, 0, 0, 21696, 21697, 7, 21, 0, 0, 21697, 21698, 7, 6, 0, 0, + 21698, 21699, 7, 18, 0, 0, 21699, 3100, 1, 0, 0, 0, 21700, 21701, 7, 3, + 0, 0, 21701, 21702, 7, 6, 0, 0, 21702, 21703, 7, 11, 0, 0, 21703, 21704, + 7, 0, 0, 0, 21704, 21705, 7, 4, 0, 0, 21705, 21706, 7, 10, 0, 0, 21706, + 21707, 7, 2, 0, 0, 21707, 21708, 7, 7, 0, 0, 21708, 21709, 7, 0, 0, 0, + 21709, 21710, 7, 11, 0, 0, 21710, 3102, 1, 0, 0, 0, 21711, 21712, 7, 3, + 0, 0, 21712, 21713, 7, 6, 0, 0, 21713, 21714, 7, 11, 0, 0, 21714, 21715, + 7, 10, 0, 0, 21715, 21716, 7, 6, 0, 0, 21716, 21717, 7, 5, 0, 0, 21717, + 21718, 5, 95, 0, 0, 21718, 21719, 7, 2, 0, 0, 21719, 21720, 7, 7, 0, 0, + 21720, 3104, 1, 0, 0, 0, 21721, 21722, 7, 3, 0, 0, 21722, 21723, 7, 6, + 0, 0, 21723, 21724, 7, 11, 0, 0, 21724, 21725, 7, 2, 0, 0, 21725, 21726, + 7, 8, 0, 0, 21726, 21727, 7, 0, 0, 0, 21727, 21728, 7, 4, 0, 0, 21728, + 21729, 7, 6, 0, 0, 21729, 3106, 1, 0, 0, 0, 21730, 21731, 7, 3, 0, 0, 21731, + 21732, 7, 6, 0, 0, 21732, 21733, 7, 11, 0, 0, 21733, 21734, 7, 18, 0, 0, + 21734, 3108, 1, 0, 0, 0, 21735, 21736, 7, 3, 0, 0, 21736, 21737, 7, 6, + 0, 0, 21737, 21738, 7, 14, 0, 0, 21738, 21739, 7, 0, 0, 0, 21739, 21740, + 7, 10, 0, 0, 21740, 21741, 7, 7, 0, 0, 21741, 21742, 7, 9, 0, 0, 21742, + 21743, 7, 6, 0, 0, 21743, 21744, 7, 3, 0, 0, 21744, 3110, 1, 0, 0, 0, 21745, + 21746, 7, 3, 0, 0, 21746, 21747, 7, 6, 0, 0, 21747, 21748, 7, 14, 0, 0, + 21748, 21749, 7, 2, 0, 0, 21749, 21750, 7, 4, 0, 0, 21750, 21751, 7, 6, + 0, 0, 21751, 3112, 1, 0, 0, 0, 21752, 21753, 7, 3, 0, 0, 21753, 21754, + 7, 6, 0, 0, 21754, 21755, 7, 14, 0, 0, 21755, 21756, 7, 2, 0, 0, 21756, + 21757, 7, 4, 0, 0, 21757, 21758, 7, 6, 0, 0, 21758, 21759, 5, 95, 0, 0, + 21759, 21760, 7, 14, 0, 0, 21760, 21761, 7, 0, 0, 0, 21761, 21762, 7, 15, + 0, 0, 21762, 21763, 7, 15, 0, 0, 21763, 21764, 7, 6, 0, 0, 21764, 21765, + 7, 9, 0, 0, 21765, 3114, 1, 0, 0, 0, 21766, 21767, 7, 3, 0, 0, 21767, 21768, + 7, 6, 0, 0, 21768, 21769, 7, 14, 0, 0, 21769, 21770, 7, 2, 0, 0, 21770, + 21771, 7, 13, 0, 0, 21771, 21772, 7, 6, 0, 0, 21772, 3116, 1, 0, 0, 0, + 21773, 21774, 7, 3, 0, 0, 21774, 21775, 7, 6, 0, 0, 21775, 21776, 7, 7, + 0, 0, 21776, 21777, 7, 0, 0, 0, 21777, 21778, 7, 14, 0, 0, 21778, 21779, + 7, 6, 0, 0, 21779, 3118, 1, 0, 0, 0, 21780, 21781, 7, 3, 0, 0, 21781, 21782, + 7, 6, 0, 0, 21782, 21783, 7, 15, 0, 0, 21783, 21784, 7, 0, 0, 0, 21784, + 21785, 7, 10, 0, 0, 21785, 21786, 7, 3, 0, 0, 21786, 3120, 1, 0, 0, 0, + 21787, 21788, 7, 3, 0, 0, 21788, 21789, 7, 6, 0, 0, 21789, 21790, 7, 15, + 0, 0, 21790, 21791, 7, 6, 0, 0, 21791, 21792, 7, 0, 0, 0, 21792, 21793, + 7, 4, 0, 0, 21793, 3122, 1, 0, 0, 0, 21794, 21795, 7, 3, 0, 0, 21795, 21796, + 7, 6, 0, 0, 21796, 21797, 7, 15, 0, 0, 21797, 21798, 7, 11, 0, 0, 21798, + 21799, 7, 0, 0, 0, 21799, 21800, 7, 8, 0, 0, 21800, 21801, 7, 6, 0, 0, + 21801, 3124, 1, 0, 0, 0, 21802, 21803, 7, 3, 0, 0, 21803, 21804, 7, 6, + 0, 0, 21804, 21805, 7, 15, 0, 0, 21805, 21806, 7, 11, 0, 0, 21806, 21807, + 7, 10, 0, 0, 21807, 21808, 7, 8, 0, 0, 21808, 21809, 7, 0, 0, 0, 21809, + 21810, 7, 4, 0, 0, 21810, 21811, 7, 10, 0, 0, 21811, 21812, 7, 2, 0, 0, + 21812, 21813, 7, 7, 0, 0, 21813, 3126, 1, 0, 0, 0, 21814, 21815, 7, 3, + 0, 0, 21815, 21816, 7, 6, 0, 0, 21816, 21817, 7, 24, 0, 0, 21817, 21818, + 7, 12, 0, 0, 21818, 21819, 7, 10, 0, 0, 21819, 21820, 7, 3, 0, 0, 21820, + 21821, 7, 6, 0, 0, 21821, 21822, 7, 9, 0, 0, 21822, 3128, 1, 0, 0, 0, 21823, + 21824, 7, 3, 0, 0, 21824, 21825, 7, 6, 0, 0, 21825, 21826, 7, 5, 0, 0, + 21826, 21827, 7, 6, 0, 0, 21827, 21828, 7, 4, 0, 0, 21828, 21829, 7, 11, + 0, 0, 21829, 21830, 7, 2, 0, 0, 21830, 21831, 7, 17, 0, 0, 21831, 21832, + 7, 5, 0, 0, 21832, 3130, 1, 0, 0, 0, 21833, 21834, 7, 3, 0, 0, 21834, 21835, + 7, 6, 0, 0, 21835, 21836, 7, 5, 0, 0, 21836, 21837, 7, 6, 0, 0, 21837, + 21838, 7, 4, 0, 0, 21838, 3132, 1, 0, 0, 0, 21839, 21840, 7, 3, 0, 0, 21840, + 21841, 7, 6, 0, 0, 21841, 21842, 7, 5, 0, 0, 21842, 21843, 7, 10, 0, 0, + 21843, 21844, 7, 23, 0, 0, 21844, 21845, 7, 6, 0, 0, 21845, 3134, 1, 0, + 0, 0, 21846, 21847, 7, 3, 0, 0, 21847, 21848, 7, 6, 0, 0, 21848, 21849, + 7, 5, 0, 0, 21849, 21850, 7, 2, 0, 0, 21850, 21851, 7, 11, 0, 0, 21851, + 21852, 7, 13, 0, 0, 21852, 21853, 7, 6, 0, 0, 21853, 3136, 1, 0, 0, 0, + 21854, 21855, 7, 3, 0, 0, 21855, 21856, 7, 6, 0, 0, 21856, 21857, 7, 5, + 0, 0, 21857, 21858, 7, 2, 0, 0, 21858, 21859, 7, 11, 0, 0, 21859, 21860, + 7, 13, 0, 0, 21860, 21861, 7, 6, 0, 0, 21861, 21862, 7, 3, 0, 0, 21862, + 3138, 1, 0, 0, 0, 21863, 21864, 7, 3, 0, 0, 21864, 21865, 7, 6, 0, 0, 21865, + 21866, 7, 5, 0, 0, 21866, 21867, 7, 2, 0, 0, 21867, 21868, 7, 12, 0, 0, + 21868, 21869, 7, 3, 0, 0, 21869, 21870, 7, 8, 0, 0, 21870, 21871, 7, 6, + 0, 0, 21871, 3140, 1, 0, 0, 0, 21872, 21873, 7, 3, 0, 0, 21873, 21874, + 7, 6, 0, 0, 21874, 21875, 7, 5, 0, 0, 21875, 21876, 7, 15, 0, 0, 21876, + 21877, 7, 6, 0, 0, 21877, 21878, 7, 8, 0, 0, 21878, 21879, 7, 4, 0, 0, + 21879, 3142, 1, 0, 0, 0, 21880, 21881, 7, 3, 0, 0, 21881, 21882, 7, 6, + 0, 0, 21882, 21883, 7, 5, 0, 0, 21883, 21884, 7, 4, 0, 0, 21884, 21885, + 7, 0, 0, 0, 21885, 21886, 7, 3, 0, 0, 21886, 21887, 7, 4, 0, 0, 21887, + 3144, 1, 0, 0, 0, 21888, 21889, 7, 3, 0, 0, 21889, 21890, 7, 6, 0, 0, 21890, + 21891, 7, 5, 0, 0, 21891, 21892, 7, 4, 0, 0, 21892, 21893, 7, 2, 0, 0, + 21893, 21894, 7, 3, 0, 0, 21894, 21895, 7, 6, 0, 0, 21895, 21896, 5, 95, + 0, 0, 21896, 21897, 7, 0, 0, 0, 21897, 21898, 7, 5, 0, 0, 21898, 21899, + 5, 95, 0, 0, 21899, 21900, 7, 10, 0, 0, 21900, 21901, 7, 7, 0, 0, 21901, + 21902, 7, 4, 0, 0, 21902, 21903, 7, 6, 0, 0, 21903, 21904, 7, 3, 0, 0, + 21904, 21905, 7, 13, 0, 0, 21905, 21906, 7, 0, 0, 0, 21906, 21907, 7, 11, + 0, 0, 21907, 21908, 7, 5, 0, 0, 21908, 3146, 1, 0, 0, 0, 21909, 21910, + 7, 3, 0, 0, 21910, 21911, 7, 6, 0, 0, 21911, 21912, 7, 5, 0, 0, 21912, + 21913, 7, 4, 0, 0, 21913, 21914, 7, 2, 0, 0, 21914, 21915, 7, 3, 0, 0, + 21915, 21916, 7, 6, 0, 0, 21916, 3148, 1, 0, 0, 0, 21917, 21918, 7, 3, + 0, 0, 21918, 21919, 7, 6, 0, 0, 21919, 21920, 7, 5, 0, 0, 21920, 21921, + 7, 4, 0, 0, 21921, 21922, 7, 3, 0, 0, 21922, 21923, 7, 10, 0, 0, 21923, + 21924, 7, 8, 0, 0, 21924, 21925, 7, 4, 0, 0, 21925, 21926, 5, 95, 0, 0, + 21926, 21927, 7, 0, 0, 0, 21927, 21928, 7, 11, 0, 0, 21928, 21929, 7, 11, + 0, 0, 21929, 21930, 5, 95, 0, 0, 21930, 21931, 7, 3, 0, 0, 21931, 21932, + 7, 6, 0, 0, 21932, 21933, 7, 16, 0, 0, 21933, 21934, 5, 95, 0, 0, 21934, + 21935, 7, 8, 0, 0, 21935, 21936, 7, 2, 0, 0, 21936, 21937, 7, 7, 0, 0, + 21937, 21938, 7, 5, 0, 0, 21938, 3150, 1, 0, 0, 0, 21939, 21940, 7, 3, + 0, 0, 21940, 21941, 7, 6, 0, 0, 21941, 21942, 7, 5, 0, 0, 21942, 21943, + 7, 4, 0, 0, 21943, 21944, 7, 3, 0, 0, 21944, 21945, 7, 10, 0, 0, 21945, + 21946, 7, 8, 0, 0, 21946, 21947, 7, 4, 0, 0, 21947, 21948, 7, 6, 0, 0, + 21948, 21949, 7, 9, 0, 0, 21949, 3152, 1, 0, 0, 0, 21950, 21951, 7, 3, + 0, 0, 21951, 21952, 7, 6, 0, 0, 21952, 21953, 7, 5, 0, 0, 21953, 21954, + 7, 4, 0, 0, 21954, 21955, 7, 3, 0, 0, 21955, 21956, 7, 10, 0, 0, 21956, + 21957, 7, 8, 0, 0, 21957, 21958, 7, 4, 0, 0, 21958, 21959, 5, 95, 0, 0, + 21959, 21960, 7, 3, 0, 0, 21960, 21961, 7, 6, 0, 0, 21961, 21962, 7, 16, + 0, 0, 21962, 21963, 7, 6, 0, 0, 21963, 21964, 7, 3, 0, 0, 21964, 21965, + 7, 6, 0, 0, 21965, 21966, 7, 7, 0, 0, 21966, 21967, 7, 8, 0, 0, 21967, + 21968, 7, 6, 0, 0, 21968, 21969, 7, 5, 0, 0, 21969, 3154, 1, 0, 0, 0, 21970, + 21971, 7, 3, 0, 0, 21971, 21972, 7, 6, 0, 0, 21972, 21973, 7, 5, 0, 0, + 21973, 21974, 7, 4, 0, 0, 21974, 21975, 7, 3, 0, 0, 21975, 21976, 7, 10, + 0, 0, 21976, 21977, 7, 8, 0, 0, 21977, 21978, 7, 4, 0, 0, 21978, 3156, + 1, 0, 0, 0, 21979, 21980, 7, 3, 0, 0, 21980, 21981, 7, 6, 0, 0, 21981, + 21982, 7, 5, 0, 0, 21982, 21983, 7, 12, 0, 0, 21983, 21984, 7, 11, 0, 0, + 21984, 21985, 7, 4, 0, 0, 21985, 21986, 5, 95, 0, 0, 21986, 21987, 7, 8, + 0, 0, 21987, 21988, 7, 0, 0, 0, 21988, 21989, 7, 8, 0, 0, 21989, 21990, + 7, 19, 0, 0, 21990, 21991, 7, 6, 0, 0, 21991, 3158, 1, 0, 0, 0, 21992, + 21993, 7, 3, 0, 0, 21993, 21994, 7, 6, 0, 0, 21994, 21995, 7, 5, 0, 0, + 21995, 21996, 7, 12, 0, 0, 21996, 21997, 7, 11, 0, 0, 21997, 21998, 7, + 4, 0, 0, 21998, 3160, 1, 0, 0, 0, 21999, 22000, 7, 3, 0, 0, 22000, 22001, + 7, 6, 0, 0, 22001, 22002, 7, 5, 0, 0, 22002, 22003, 7, 12, 0, 0, 22003, + 22004, 7, 14, 0, 0, 22004, 22005, 7, 0, 0, 0, 22005, 22006, 7, 1, 0, 0, + 22006, 22007, 7, 11, 0, 0, 22007, 22008, 7, 6, 0, 0, 22008, 3162, 1, 0, + 0, 0, 22009, 22010, 7, 3, 0, 0, 22010, 22011, 7, 6, 0, 0, 22011, 22012, + 7, 5, 0, 0, 22012, 22013, 7, 12, 0, 0, 22013, 22014, 7, 14, 0, 0, 22014, + 22015, 7, 6, 0, 0, 22015, 3164, 1, 0, 0, 0, 22016, 22017, 7, 3, 0, 0, 22017, + 22018, 7, 6, 0, 0, 22018, 22019, 7, 4, 0, 0, 22019, 22020, 7, 6, 0, 0, + 22020, 22021, 7, 7, 0, 0, 22021, 22022, 7, 4, 0, 0, 22022, 22023, 7, 10, + 0, 0, 22023, 22024, 7, 2, 0, 0, 22024, 22025, 7, 7, 0, 0, 22025, 3166, + 1, 0, 0, 0, 22026, 22027, 7, 3, 0, 0, 22027, 22028, 7, 6, 0, 0, 22028, + 22029, 7, 4, 0, 0, 22029, 22030, 7, 3, 0, 0, 22030, 22031, 7, 18, 0, 0, + 22031, 22032, 5, 95, 0, 0, 22032, 22033, 7, 2, 0, 0, 22033, 22034, 7, 7, + 0, 0, 22034, 22035, 5, 95, 0, 0, 22035, 22036, 7, 3, 0, 0, 22036, 22037, + 7, 2, 0, 0, 22037, 22038, 7, 22, 0, 0, 22038, 22039, 5, 95, 0, 0, 22039, + 22040, 7, 8, 0, 0, 22040, 22041, 7, 19, 0, 0, 22041, 22042, 7, 0, 0, 0, + 22042, 22043, 7, 7, 0, 0, 22043, 22044, 7, 17, 0, 0, 22044, 22045, 7, 6, + 0, 0, 22045, 3168, 1, 0, 0, 0, 22046, 22047, 7, 3, 0, 0, 22047, 22048, + 7, 6, 0, 0, 22048, 22049, 7, 4, 0, 0, 22049, 22050, 7, 12, 0, 0, 22050, + 22051, 7, 3, 0, 0, 22051, 22052, 7, 7, 0, 0, 22052, 22053, 7, 10, 0, 0, + 22053, 22054, 7, 7, 0, 0, 22054, 22055, 7, 17, 0, 0, 22055, 3170, 1, 0, + 0, 0, 22056, 22057, 7, 3, 0, 0, 22057, 22058, 7, 6, 0, 0, 22058, 22059, + 7, 4, 0, 0, 22059, 22060, 7, 12, 0, 0, 22060, 22061, 7, 3, 0, 0, 22061, + 22062, 7, 7, 0, 0, 22062, 3172, 1, 0, 0, 0, 22063, 22064, 7, 3, 0, 0, 22064, + 22065, 7, 6, 0, 0, 22065, 22066, 7, 12, 0, 0, 22066, 22067, 7, 5, 0, 0, + 22067, 22068, 7, 6, 0, 0, 22068, 3174, 1, 0, 0, 0, 22069, 22070, 7, 3, + 0, 0, 22070, 22071, 7, 6, 0, 0, 22071, 22072, 7, 13, 0, 0, 22072, 22073, + 7, 6, 0, 0, 22073, 22074, 7, 3, 0, 0, 22074, 22075, 7, 5, 0, 0, 22075, + 22076, 7, 6, 0, 0, 22076, 3176, 1, 0, 0, 0, 22077, 22078, 7, 3, 0, 0, 22078, + 22079, 7, 6, 0, 0, 22079, 22080, 7, 13, 0, 0, 22080, 22081, 7, 2, 0, 0, + 22081, 22082, 7, 21, 0, 0, 22082, 22083, 7, 6, 0, 0, 22083, 3178, 1, 0, + 0, 0, 22084, 22085, 7, 3, 0, 0, 22085, 22086, 7, 6, 0, 0, 22086, 22087, + 7, 22, 0, 0, 22087, 22088, 7, 3, 0, 0, 22088, 22089, 7, 10, 0, 0, 22089, + 22090, 7, 4, 0, 0, 22090, 22091, 7, 6, 0, 0, 22091, 22092, 5, 95, 0, 0, + 22092, 22093, 7, 2, 0, 0, 22093, 22094, 7, 3, 0, 0, 22094, 22095, 5, 95, + 0, 0, 22095, 22096, 7, 6, 0, 0, 22096, 22097, 7, 3, 0, 0, 22097, 22098, + 7, 3, 0, 0, 22098, 22099, 7, 2, 0, 0, 22099, 22100, 7, 3, 0, 0, 22100, + 3180, 1, 0, 0, 0, 22101, 22102, 7, 3, 0, 0, 22102, 22103, 7, 6, 0, 0, 22103, + 22104, 7, 22, 0, 0, 22104, 22105, 7, 3, 0, 0, 22105, 22106, 7, 10, 0, 0, + 22106, 22107, 7, 4, 0, 0, 22107, 22108, 7, 6, 0, 0, 22108, 3182, 1, 0, + 0, 0, 22109, 22110, 7, 3, 0, 0, 22110, 22111, 7, 10, 0, 0, 22111, 22112, + 7, 17, 0, 0, 22112, 22113, 7, 19, 0, 0, 22113, 22114, 7, 4, 0, 0, 22114, + 3184, 1, 0, 0, 0, 22115, 22116, 7, 3, 0, 0, 22116, 22117, 7, 2, 0, 0, 22117, + 22118, 7, 11, 0, 0, 22118, 22119, 7, 6, 0, 0, 22119, 3186, 1, 0, 0, 0, + 22120, 22121, 7, 3, 0, 0, 22121, 22122, 7, 2, 0, 0, 22122, 22123, 7, 11, + 0, 0, 22123, 22124, 7, 6, 0, 0, 22124, 22125, 7, 5, 0, 0, 22125, 22126, + 7, 6, 0, 0, 22126, 22127, 7, 4, 0, 0, 22127, 3188, 1, 0, 0, 0, 22128, 22129, + 7, 3, 0, 0, 22129, 22130, 7, 2, 0, 0, 22130, 22131, 7, 11, 0, 0, 22131, + 22132, 7, 6, 0, 0, 22132, 22133, 7, 5, 0, 0, 22133, 3190, 1, 0, 0, 0, 22134, + 22135, 7, 3, 0, 0, 22135, 22136, 7, 2, 0, 0, 22136, 22137, 7, 11, 0, 0, + 22137, 22138, 7, 11, 0, 0, 22138, 22139, 7, 1, 0, 0, 22139, 22140, 7, 0, + 0, 0, 22140, 22141, 7, 8, 0, 0, 22141, 22142, 7, 21, 0, 0, 22142, 3192, + 1, 0, 0, 0, 22143, 22144, 7, 3, 0, 0, 22144, 22145, 7, 2, 0, 0, 22145, + 22146, 7, 11, 0, 0, 22146, 22147, 7, 11, 0, 0, 22147, 22148, 7, 10, 0, + 0, 22148, 22149, 7, 7, 0, 0, 22149, 22150, 7, 17, 0, 0, 22150, 3194, 1, + 0, 0, 0, 22151, 22152, 7, 3, 0, 0, 22152, 22153, 7, 2, 0, 0, 22153, 22154, + 7, 11, 0, 0, 22154, 22155, 7, 11, 0, 0, 22155, 22156, 7, 12, 0, 0, 22156, + 22157, 7, 15, 0, 0, 22157, 3196, 1, 0, 0, 0, 22158, 22159, 7, 3, 0, 0, + 22159, 22160, 7, 2, 0, 0, 22160, 22161, 7, 22, 0, 0, 22161, 22162, 7, 9, + 0, 0, 22162, 22163, 7, 6, 0, 0, 22163, 22164, 7, 15, 0, 0, 22164, 22165, + 7, 6, 0, 0, 22165, 22166, 7, 7, 0, 0, 22166, 22167, 7, 9, 0, 0, 22167, + 22168, 7, 6, 0, 0, 22168, 22169, 7, 7, 0, 0, 22169, 22170, 7, 8, 0, 0, + 22170, 22171, 7, 10, 0, 0, 22171, 22172, 7, 6, 0, 0, 22172, 22173, 7, 5, + 0, 0, 22173, 3198, 1, 0, 0, 0, 22174, 22175, 7, 3, 0, 0, 22175, 22176, + 7, 2, 0, 0, 22176, 22177, 7, 22, 0, 0, 22177, 22178, 7, 10, 0, 0, 22178, + 22179, 7, 9, 0, 0, 22179, 22180, 5, 95, 0, 0, 22180, 22181, 7, 14, 0, 0, + 22181, 22182, 7, 0, 0, 0, 22182, 22183, 7, 15, 0, 0, 22183, 22184, 7, 15, + 0, 0, 22184, 22185, 7, 10, 0, 0, 22185, 22186, 7, 7, 0, 0, 22186, 22187, + 7, 17, 0, 0, 22187, 22188, 5, 95, 0, 0, 22188, 22189, 7, 4, 0, 0, 22189, + 22190, 7, 0, 0, 0, 22190, 22191, 7, 1, 0, 0, 22191, 22192, 7, 11, 0, 0, + 22192, 22193, 7, 6, 0, 0, 22193, 3200, 1, 0, 0, 0, 22194, 22195, 7, 3, + 0, 0, 22195, 22196, 7, 2, 0, 0, 22196, 22197, 7, 22, 0, 0, 22197, 22198, + 7, 10, 0, 0, 22198, 22199, 7, 9, 0, 0, 22199, 3202, 1, 0, 0, 0, 22200, + 22201, 7, 3, 0, 0, 22201, 22202, 7, 2, 0, 0, 22202, 22203, 7, 22, 0, 0, + 22203, 22204, 7, 10, 0, 0, 22204, 22205, 7, 9, 0, 0, 22205, 22206, 7, 4, + 0, 0, 22206, 22207, 7, 2, 0, 0, 22207, 22208, 7, 8, 0, 0, 22208, 22209, + 7, 19, 0, 0, 22209, 22210, 7, 0, 0, 0, 22210, 22211, 7, 3, 0, 0, 22211, + 3204, 1, 0, 0, 0, 22212, 22213, 7, 3, 0, 0, 22213, 22214, 7, 2, 0, 0, 22214, + 22215, 7, 22, 0, 0, 22215, 22216, 7, 10, 0, 0, 22216, 22217, 7, 9, 0, 0, + 22217, 22218, 7, 4, 0, 0, 22218, 22219, 7, 2, 0, 0, 22219, 22220, 7, 7, + 0, 0, 22220, 22221, 7, 8, 0, 0, 22221, 22222, 7, 19, 0, 0, 22222, 22223, + 7, 0, 0, 0, 22223, 22224, 7, 3, 0, 0, 22224, 3206, 1, 0, 0, 0, 22225, 22226, + 7, 3, 0, 0, 22226, 22227, 7, 2, 0, 0, 22227, 22228, 7, 22, 0, 0, 22228, + 22229, 5, 95, 0, 0, 22229, 22230, 7, 11, 0, 0, 22230, 22231, 7, 6, 0, 0, + 22231, 22232, 7, 7, 0, 0, 22232, 22233, 7, 17, 0, 0, 22233, 22234, 7, 4, + 0, 0, 22234, 22235, 7, 19, 0, 0, 22235, 3208, 1, 0, 0, 0, 22236, 22237, + 7, 3, 0, 0, 22237, 22238, 7, 2, 0, 0, 22238, 22239, 7, 22, 0, 0, 22239, + 22240, 7, 7, 0, 0, 22240, 22241, 7, 12, 0, 0, 22241, 22242, 7, 14, 0, 0, + 22242, 3210, 1, 0, 0, 0, 22243, 22244, 7, 3, 0, 0, 22244, 22245, 7, 2, + 0, 0, 22245, 22246, 7, 22, 0, 0, 22246, 3212, 1, 0, 0, 0, 22247, 22248, + 7, 3, 0, 0, 22248, 22249, 7, 2, 0, 0, 22249, 22250, 7, 22, 0, 0, 22250, + 22251, 7, 5, 0, 0, 22251, 3214, 1, 0, 0, 0, 22252, 22253, 7, 3, 0, 0, 22253, + 22254, 7, 15, 0, 0, 22254, 22255, 7, 0, 0, 0, 22255, 22256, 7, 9, 0, 0, + 22256, 3216, 1, 0, 0, 0, 22257, 22258, 7, 3, 0, 0, 22258, 22259, 7, 4, + 0, 0, 22259, 22260, 7, 3, 0, 0, 22260, 22261, 7, 10, 0, 0, 22261, 22262, + 7, 14, 0, 0, 22262, 3218, 1, 0, 0, 0, 22263, 22264, 7, 3, 0, 0, 22264, + 22265, 7, 12, 0, 0, 22265, 22266, 7, 11, 0, 0, 22266, 22267, 7, 6, 0, 0, + 22267, 3220, 1, 0, 0, 0, 22268, 22269, 7, 3, 0, 0, 22269, 22270, 7, 12, + 0, 0, 22270, 22271, 7, 11, 0, 0, 22271, 22272, 7, 6, 0, 0, 22272, 22273, + 7, 5, 0, 0, 22273, 3222, 1, 0, 0, 0, 22274, 22275, 7, 3, 0, 0, 22275, 22276, + 7, 12, 0, 0, 22276, 22277, 7, 7, 0, 0, 22277, 22278, 7, 7, 0, 0, 22278, + 22279, 7, 10, 0, 0, 22279, 22280, 7, 7, 0, 0, 22280, 22281, 7, 17, 0, 0, + 22281, 3224, 1, 0, 0, 0, 22282, 22283, 7, 5, 0, 0, 22283, 22284, 7, 0, + 0, 0, 22284, 22285, 7, 11, 0, 0, 22285, 22286, 7, 4, 0, 0, 22286, 3226, + 1, 0, 0, 0, 22287, 22288, 7, 5, 0, 0, 22288, 22289, 7, 0, 0, 0, 22289, + 22290, 7, 14, 0, 0, 22290, 22291, 7, 15, 0, 0, 22291, 22292, 7, 11, 0, + 0, 22292, 22293, 7, 6, 0, 0, 22293, 3228, 1, 0, 0, 0, 22294, 22295, 7, + 5, 0, 0, 22295, 22296, 7, 0, 0, 0, 22296, 22297, 7, 13, 0, 0, 22297, 22298, + 7, 6, 0, 0, 22298, 22299, 5, 95, 0, 0, 22299, 22300, 7, 0, 0, 0, 22300, + 22301, 7, 5, 0, 0, 22301, 22302, 5, 95, 0, 0, 22302, 22303, 7, 10, 0, 0, + 22303, 22304, 7, 7, 0, 0, 22304, 22305, 7, 4, 0, 0, 22305, 22306, 7, 6, + 0, 0, 22306, 22307, 7, 3, 0, 0, 22307, 22308, 7, 13, 0, 0, 22308, 22309, + 7, 0, 0, 0, 22309, 22310, 7, 11, 0, 0, 22310, 22311, 7, 5, 0, 0, 22311, + 3230, 1, 0, 0, 0, 22312, 22313, 7, 5, 0, 0, 22313, 22314, 7, 0, 0, 0, 22314, + 22315, 7, 13, 0, 0, 22315, 22316, 7, 6, 0, 0, 22316, 22317, 7, 15, 0, 0, + 22317, 22318, 7, 2, 0, 0, 22318, 22319, 7, 10, 0, 0, 22319, 22320, 7, 7, + 0, 0, 22320, 22321, 7, 4, 0, 0, 22321, 3232, 1, 0, 0, 0, 22322, 22323, + 7, 5, 0, 0, 22323, 22324, 7, 0, 0, 0, 22324, 22325, 7, 13, 0, 0, 22325, + 22326, 7, 6, 0, 0, 22326, 3234, 1, 0, 0, 0, 22327, 22328, 7, 5, 0, 0, 22328, + 22329, 7, 1, 0, 0, 22329, 22330, 5, 52, 0, 0, 22330, 3236, 1, 0, 0, 0, + 22331, 22332, 7, 5, 0, 0, 22332, 22333, 7, 8, 0, 0, 22333, 22334, 7, 0, + 0, 0, 22334, 22335, 7, 11, 0, 0, 22335, 22336, 7, 6, 0, 0, 22336, 22337, + 5, 95, 0, 0, 22337, 22338, 7, 3, 0, 0, 22338, 22339, 7, 2, 0, 0, 22339, + 22340, 7, 22, 0, 0, 22340, 22341, 7, 5, 0, 0, 22341, 3238, 1, 0, 0, 0, + 22342, 22343, 7, 5, 0, 0, 22343, 22344, 7, 8, 0, 0, 22344, 22345, 7, 0, + 0, 0, 22345, 22346, 7, 11, 0, 0, 22346, 22347, 7, 6, 0, 0, 22347, 3240, + 1, 0, 0, 0, 22348, 22349, 7, 5, 0, 0, 22349, 22350, 7, 8, 0, 0, 22350, + 22351, 7, 0, 0, 0, 22351, 22352, 7, 7, 0, 0, 22352, 22353, 5, 95, 0, 0, + 22353, 22354, 7, 10, 0, 0, 22354, 22355, 7, 7, 0, 0, 22355, 22356, 7, 5, + 0, 0, 22356, 22357, 7, 4, 0, 0, 22357, 22358, 7, 0, 0, 0, 22358, 22359, + 7, 7, 0, 0, 22359, 22360, 7, 8, 0, 0, 22360, 22361, 7, 6, 0, 0, 22361, + 22362, 7, 5, 0, 0, 22362, 3242, 1, 0, 0, 0, 22363, 22364, 7, 5, 0, 0, 22364, + 22365, 7, 8, 0, 0, 22365, 22366, 7, 0, 0, 0, 22366, 22367, 7, 7, 0, 0, + 22367, 3244, 1, 0, 0, 0, 22368, 22369, 7, 5, 0, 0, 22369, 22370, 7, 8, + 0, 0, 22370, 22371, 7, 19, 0, 0, 22371, 22372, 7, 6, 0, 0, 22372, 22373, + 7, 9, 0, 0, 22373, 22374, 7, 12, 0, 0, 22374, 22375, 7, 11, 0, 0, 22375, + 22376, 7, 6, 0, 0, 22376, 22377, 7, 3, 0, 0, 22377, 3246, 1, 0, 0, 0, 22378, + 22379, 7, 5, 0, 0, 22379, 22380, 7, 8, 0, 0, 22380, 22381, 7, 19, 0, 0, + 22381, 22382, 7, 6, 0, 0, 22382, 22383, 7, 14, 0, 0, 22383, 22384, 7, 0, + 0, 0, 22384, 22385, 7, 8, 0, 0, 22385, 22386, 7, 19, 0, 0, 22386, 22387, + 7, 6, 0, 0, 22387, 22388, 7, 8, 0, 0, 22388, 22389, 7, 21, 0, 0, 22389, + 3248, 1, 0, 0, 0, 22390, 22391, 7, 5, 0, 0, 22391, 22392, 7, 8, 0, 0, 22392, + 22393, 7, 19, 0, 0, 22393, 22394, 7, 6, 0, 0, 22394, 22395, 7, 14, 0, 0, + 22395, 22396, 7, 0, 0, 0, 22396, 3250, 1, 0, 0, 0, 22397, 22398, 7, 5, + 0, 0, 22398, 22399, 7, 8, 0, 0, 22399, 22400, 7, 7, 0, 0, 22400, 22401, + 5, 95, 0, 0, 22401, 22402, 7, 0, 0, 0, 22402, 22403, 7, 5, 0, 0, 22403, + 22404, 7, 8, 0, 0, 22404, 22405, 7, 6, 0, 0, 22405, 22406, 7, 7, 0, 0, + 22406, 22407, 7, 9, 0, 0, 22407, 22408, 7, 10, 0, 0, 22408, 22409, 7, 7, + 0, 0, 22409, 22410, 7, 17, 0, 0, 22410, 3252, 1, 0, 0, 0, 22411, 22412, + 7, 5, 0, 0, 22412, 22413, 7, 8, 0, 0, 22413, 22414, 7, 7, 0, 0, 22414, + 3254, 1, 0, 0, 0, 22415, 22416, 7, 5, 0, 0, 22416, 22417, 7, 8, 0, 0, 22417, + 22418, 7, 2, 0, 0, 22418, 22419, 7, 15, 0, 0, 22419, 22420, 7, 6, 0, 0, + 22420, 3256, 1, 0, 0, 0, 22421, 22422, 7, 5, 0, 0, 22422, 22423, 7, 8, + 0, 0, 22423, 22424, 7, 3, 0, 0, 22424, 22425, 7, 12, 0, 0, 22425, 22426, + 7, 1, 0, 0, 22426, 3258, 1, 0, 0, 0, 22427, 22428, 7, 5, 0, 0, 22428, 22429, + 7, 9, 0, 0, 22429, 22430, 5, 95, 0, 0, 22430, 22431, 7, 0, 0, 0, 22431, + 22432, 7, 11, 0, 0, 22432, 22433, 7, 11, 0, 0, 22433, 3260, 1, 0, 0, 0, + 22434, 22435, 7, 5, 0, 0, 22435, 22436, 7, 9, 0, 0, 22436, 22437, 5, 95, + 0, 0, 22437, 22438, 7, 10, 0, 0, 22438, 22439, 7, 7, 0, 0, 22439, 22440, + 7, 19, 0, 0, 22440, 22441, 7, 10, 0, 0, 22441, 22442, 7, 1, 0, 0, 22442, + 22443, 7, 10, 0, 0, 22443, 22444, 7, 4, 0, 0, 22444, 3262, 1, 0, 0, 0, + 22445, 22446, 7, 5, 0, 0, 22446, 22447, 7, 9, 0, 0, 22447, 22448, 7, 2, + 0, 0, 22448, 22449, 5, 95, 0, 0, 22449, 22450, 7, 17, 0, 0, 22450, 22451, + 7, 6, 0, 0, 22451, 22452, 7, 2, 0, 0, 22452, 22453, 7, 14, 0, 0, 22453, + 22454, 5, 95, 0, 0, 22454, 22455, 7, 14, 0, 0, 22455, 22456, 7, 1, 0, 0, + 22456, 22457, 7, 3, 0, 0, 22457, 3264, 1, 0, 0, 0, 22458, 22459, 7, 5, + 0, 0, 22459, 22460, 7, 9, 0, 0, 22460, 22461, 7, 2, 0, 0, 22461, 22462, + 5, 95, 0, 0, 22462, 22463, 7, 17, 0, 0, 22463, 22464, 7, 6, 0, 0, 22464, + 22465, 7, 2, 0, 0, 22465, 22466, 7, 14, 0, 0, 22466, 22467, 7, 6, 0, 0, + 22467, 22468, 7, 4, 0, 0, 22468, 22469, 7, 3, 0, 0, 22469, 22470, 7, 18, + 0, 0, 22470, 3266, 1, 0, 0, 0, 22471, 22472, 7, 5, 0, 0, 22472, 22473, + 7, 9, 0, 0, 22473, 22474, 5, 95, 0, 0, 22474, 22475, 7, 5, 0, 0, 22475, + 22476, 7, 19, 0, 0, 22476, 22477, 7, 2, 0, 0, 22477, 22478, 7, 22, 0, 0, + 22478, 3268, 1, 0, 0, 0, 22479, 22480, 7, 5, 0, 0, 22480, 22481, 7, 6, + 0, 0, 22481, 22482, 7, 0, 0, 0, 22482, 22483, 7, 3, 0, 0, 22483, 22484, + 7, 8, 0, 0, 22484, 22485, 7, 19, 0, 0, 22485, 3270, 1, 0, 0, 0, 22486, + 22487, 7, 5, 0, 0, 22487, 22488, 7, 6, 0, 0, 22488, 22489, 7, 8, 0, 0, + 22489, 22490, 7, 2, 0, 0, 22490, 22491, 7, 7, 0, 0, 22491, 22492, 7, 9, + 0, 0, 22492, 3272, 1, 0, 0, 0, 22493, 22494, 7, 5, 0, 0, 22494, 22495, + 7, 6, 0, 0, 22495, 22496, 7, 8, 0, 0, 22496, 22497, 7, 2, 0, 0, 22497, + 22498, 7, 7, 0, 0, 22498, 22499, 7, 9, 0, 0, 22499, 22500, 7, 5, 0, 0, + 22500, 3274, 1, 0, 0, 0, 22501, 22502, 7, 5, 0, 0, 22502, 22503, 7, 6, + 0, 0, 22503, 22504, 7, 8, 0, 0, 22504, 22505, 7, 3, 0, 0, 22505, 22506, + 7, 6, 0, 0, 22506, 22507, 7, 4, 0, 0, 22507, 3276, 1, 0, 0, 0, 22508, 22509, + 7, 5, 0, 0, 22509, 22510, 7, 6, 0, 0, 22510, 22511, 7, 8, 0, 0, 22511, + 22512, 7, 12, 0, 0, 22512, 22513, 7, 3, 0, 0, 22513, 22514, 7, 6, 0, 0, + 22514, 22515, 7, 16, 0, 0, 22515, 22516, 7, 10, 0, 0, 22516, 22517, 7, + 11, 0, 0, 22517, 22518, 7, 6, 0, 0, 22518, 22519, 5, 95, 0, 0, 22519, 22520, + 7, 9, 0, 0, 22520, 22521, 7, 1, 0, 0, 22521, 22522, 7, 0, 0, 0, 22522, + 3278, 1, 0, 0, 0, 22523, 22524, 7, 5, 0, 0, 22524, 22525, 7, 6, 0, 0, 22525, + 22526, 7, 8, 0, 0, 22526, 22527, 7, 12, 0, 0, 22527, 22528, 7, 3, 0, 0, + 22528, 22529, 7, 6, 0, 0, 22529, 22530, 7, 16, 0, 0, 22530, 22531, 7, 10, + 0, 0, 22531, 22532, 7, 11, 0, 0, 22532, 22533, 7, 6, 0, 0, 22533, 3280, + 1, 0, 0, 0, 22534, 22535, 7, 5, 0, 0, 22535, 22536, 7, 6, 0, 0, 22536, + 22537, 7, 8, 0, 0, 22537, 22538, 7, 12, 0, 0, 22538, 22539, 7, 3, 0, 0, + 22539, 22540, 7, 10, 0, 0, 22540, 22541, 7, 4, 0, 0, 22541, 22542, 7, 18, + 0, 0, 22542, 3282, 1, 0, 0, 0, 22543, 22544, 7, 5, 0, 0, 22544, 22545, + 7, 6, 0, 0, 22545, 22546, 7, 6, 0, 0, 22546, 22547, 7, 9, 0, 0, 22547, + 3284, 1, 0, 0, 0, 22548, 22549, 7, 5, 0, 0, 22549, 22550, 7, 6, 0, 0, 22550, + 22551, 7, 17, 0, 0, 22551, 22552, 5, 95, 0, 0, 22552, 22553, 7, 1, 0, 0, + 22553, 22554, 7, 11, 0, 0, 22554, 22555, 7, 2, 0, 0, 22555, 22556, 7, 8, + 0, 0, 22556, 22557, 7, 21, 0, 0, 22557, 3286, 1, 0, 0, 0, 22558, 22559, + 7, 5, 0, 0, 22559, 22560, 7, 6, 0, 0, 22560, 22561, 7, 17, 0, 0, 22561, + 22562, 5, 95, 0, 0, 22562, 22563, 7, 16, 0, 0, 22563, 22564, 7, 10, 0, + 0, 22564, 22565, 7, 11, 0, 0, 22565, 22566, 7, 6, 0, 0, 22566, 3288, 1, + 0, 0, 0, 22567, 22568, 7, 5, 0, 0, 22568, 22569, 7, 6, 0, 0, 22569, 22570, + 7, 17, 0, 0, 22570, 22571, 7, 14, 0, 0, 22571, 22572, 7, 6, 0, 0, 22572, + 22573, 7, 7, 0, 0, 22573, 22574, 7, 4, 0, 0, 22574, 3290, 1, 0, 0, 0, 22575, + 22576, 7, 5, 0, 0, 22576, 22577, 7, 6, 0, 0, 22577, 22578, 7, 11, 0, 0, + 22578, 22579, 7, 6, 0, 0, 22579, 22580, 7, 8, 0, 0, 22580, 22581, 7, 4, + 0, 0, 22581, 22582, 7, 10, 0, 0, 22582, 22583, 7, 13, 0, 0, 22583, 22584, + 7, 10, 0, 0, 22584, 22585, 7, 4, 0, 0, 22585, 22586, 7, 18, 0, 0, 22586, + 3292, 1, 0, 0, 0, 22587, 22588, 7, 5, 0, 0, 22588, 22589, 7, 6, 0, 0, 22589, + 22590, 7, 11, 0, 0, 22590, 22591, 7, 6, 0, 0, 22591, 22592, 7, 8, 0, 0, + 22592, 22593, 7, 4, 0, 0, 22593, 3294, 1, 0, 0, 0, 22594, 22595, 7, 5, + 0, 0, 22595, 22596, 7, 6, 0, 0, 22596, 22597, 7, 11, 0, 0, 22597, 22598, + 7, 16, 0, 0, 22598, 3296, 1, 0, 0, 0, 22599, 22600, 7, 5, 0, 0, 22600, + 22601, 7, 6, 0, 0, 22601, 22602, 7, 14, 0, 0, 22602, 22603, 7, 10, 0, 0, + 22603, 22604, 7, 20, 0, 0, 22604, 22605, 7, 2, 0, 0, 22605, 22606, 7, 10, + 0, 0, 22606, 22607, 7, 7, 0, 0, 22607, 22608, 5, 95, 0, 0, 22608, 22609, + 7, 9, 0, 0, 22609, 22610, 7, 3, 0, 0, 22610, 22611, 7, 10, 0, 0, 22611, + 22612, 7, 13, 0, 0, 22612, 22613, 7, 6, 0, 0, 22613, 22614, 7, 3, 0, 0, + 22614, 3298, 1, 0, 0, 0, 22615, 22616, 7, 5, 0, 0, 22616, 22617, 7, 6, + 0, 0, 22617, 22618, 7, 14, 0, 0, 22618, 22619, 7, 10, 0, 0, 22619, 22620, + 7, 20, 0, 0, 22620, 22621, 7, 2, 0, 0, 22621, 22622, 7, 10, 0, 0, 22622, + 22623, 7, 7, 0, 0, 22623, 3300, 1, 0, 0, 0, 22624, 22625, 7, 5, 0, 0, 22625, + 22626, 7, 6, 0, 0, 22626, 22627, 7, 14, 0, 0, 22627, 22628, 7, 10, 0, 0, + 22628, 22629, 5, 95, 0, 0, 22629, 22630, 7, 4, 0, 0, 22630, 22631, 7, 2, + 0, 0, 22631, 22632, 5, 95, 0, 0, 22632, 22633, 7, 10, 0, 0, 22633, 22634, + 7, 7, 0, 0, 22634, 22635, 7, 7, 0, 0, 22635, 22636, 7, 6, 0, 0, 22636, + 22637, 7, 3, 0, 0, 22637, 3302, 1, 0, 0, 0, 22638, 22639, 7, 5, 0, 0, 22639, + 22640, 7, 6, 0, 0, 22640, 22641, 7, 24, 0, 0, 22641, 22642, 7, 12, 0, 0, + 22642, 22643, 7, 6, 0, 0, 22643, 22644, 7, 7, 0, 0, 22644, 22645, 7, 8, + 0, 0, 22645, 22646, 7, 6, 0, 0, 22646, 22647, 7, 9, 0, 0, 22647, 3304, + 1, 0, 0, 0, 22648, 22649, 7, 5, 0, 0, 22649, 22650, 7, 6, 0, 0, 22650, + 22651, 7, 24, 0, 0, 22651, 22652, 7, 12, 0, 0, 22652, 22653, 7, 6, 0, 0, + 22653, 22654, 7, 7, 0, 0, 22654, 22655, 7, 8, 0, 0, 22655, 22656, 7, 6, + 0, 0, 22656, 3306, 1, 0, 0, 0, 22657, 22658, 7, 5, 0, 0, 22658, 22659, + 7, 6, 0, 0, 22659, 22660, 7, 24, 0, 0, 22660, 22661, 7, 12, 0, 0, 22661, + 22662, 7, 6, 0, 0, 22662, 22663, 7, 7, 0, 0, 22663, 22664, 7, 8, 0, 0, + 22664, 22665, 7, 6, 0, 0, 22665, 22666, 7, 16, 0, 0, 22666, 22667, 7, 10, + 0, 0, 22667, 22668, 7, 11, 0, 0, 22668, 22669, 7, 6, 0, 0, 22669, 3308, + 1, 0, 0, 0, 22670, 22671, 7, 5, 0, 0, 22671, 22672, 7, 6, 0, 0, 22672, + 22673, 7, 24, 0, 0, 22673, 22674, 7, 12, 0, 0, 22674, 22675, 7, 6, 0, 0, + 22675, 22676, 7, 7, 0, 0, 22676, 22677, 7, 4, 0, 0, 22677, 22678, 7, 10, + 0, 0, 22678, 22679, 7, 0, 0, 0, 22679, 22680, 7, 11, 0, 0, 22680, 3310, + 1, 0, 0, 0, 22681, 22682, 7, 5, 0, 0, 22682, 22683, 7, 6, 0, 0, 22683, + 22684, 7, 24, 0, 0, 22684, 3312, 1, 0, 0, 0, 22685, 22686, 7, 5, 0, 0, + 22686, 22687, 7, 6, 0, 0, 22687, 22688, 7, 3, 0, 0, 22688, 22689, 7, 9, + 0, 0, 22689, 22690, 7, 6, 0, 0, 22690, 3314, 1, 0, 0, 0, 22691, 22692, + 7, 5, 0, 0, 22692, 22693, 7, 6, 0, 0, 22693, 22694, 7, 3, 0, 0, 22694, + 22695, 7, 9, 0, 0, 22695, 22696, 7, 6, 0, 0, 22696, 22697, 7, 15, 0, 0, + 22697, 22698, 7, 3, 0, 0, 22698, 22699, 7, 2, 0, 0, 22699, 22700, 7, 15, + 0, 0, 22700, 22701, 7, 6, 0, 0, 22701, 22702, 7, 3, 0, 0, 22702, 22703, + 7, 4, 0, 0, 22703, 22704, 7, 10, 0, 0, 22704, 22705, 7, 6, 0, 0, 22705, + 22706, 7, 5, 0, 0, 22706, 3316, 1, 0, 0, 0, 22707, 22708, 7, 5, 0, 0, 22708, + 22709, 7, 6, 0, 0, 22709, 22710, 7, 3, 0, 0, 22710, 22711, 7, 10, 0, 0, + 22711, 22712, 7, 0, 0, 0, 22712, 22713, 7, 11, 0, 0, 22713, 22714, 7, 10, + 0, 0, 22714, 22715, 7, 23, 0, 0, 22715, 22716, 7, 0, 0, 0, 22716, 22717, + 7, 1, 0, 0, 22717, 22718, 7, 11, 0, 0, 22718, 22719, 7, 6, 0, 0, 22719, + 3318, 1, 0, 0, 0, 22720, 22721, 7, 5, 0, 0, 22721, 22722, 7, 6, 0, 0, 22722, + 22723, 7, 3, 0, 0, 22723, 22724, 7, 10, 0, 0, 22724, 22725, 7, 0, 0, 0, + 22725, 22726, 7, 11, 0, 0, 22726, 22727, 7, 11, 0, 0, 22727, 22728, 7, + 18, 0, 0, 22728, 22729, 5, 95, 0, 0, 22729, 22730, 7, 3, 0, 0, 22730, 22731, + 7, 6, 0, 0, 22731, 22732, 7, 12, 0, 0, 22732, 22733, 7, 5, 0, 0, 22733, + 22734, 7, 0, 0, 0, 22734, 22735, 7, 1, 0, 0, 22735, 22736, 7, 11, 0, 0, + 22736, 22737, 7, 6, 0, 0, 22737, 3320, 1, 0, 0, 0, 22738, 22739, 7, 5, + 0, 0, 22739, 22740, 7, 6, 0, 0, 22740, 22741, 7, 3, 0, 0, 22741, 22742, + 7, 10, 0, 0, 22742, 22743, 7, 0, 0, 0, 22743, 22744, 7, 11, 0, 0, 22744, + 3322, 1, 0, 0, 0, 22745, 22746, 7, 5, 0, 0, 22746, 22747, 7, 6, 0, 0, 22747, + 22748, 7, 3, 0, 0, 22748, 22749, 7, 13, 0, 0, 22749, 22750, 7, 6, 0, 0, + 22750, 22751, 7, 3, 0, 0, 22751, 22752, 7, 6, 0, 0, 22752, 22753, 7, 3, + 0, 0, 22753, 22754, 7, 3, 0, 0, 22754, 22755, 7, 2, 0, 0, 22755, 22756, + 7, 3, 0, 0, 22756, 3324, 1, 0, 0, 0, 22757, 22758, 7, 5, 0, 0, 22758, 22759, + 7, 6, 0, 0, 22759, 22760, 7, 3, 0, 0, 22760, 22761, 7, 13, 0, 0, 22761, + 22762, 7, 10, 0, 0, 22762, 22763, 7, 8, 0, 0, 22763, 22764, 7, 6, 0, 0, + 22764, 22765, 5, 95, 0, 0, 22765, 22766, 7, 7, 0, 0, 22766, 22767, 7, 0, + 0, 0, 22767, 22768, 7, 14, 0, 0, 22768, 22769, 7, 6, 0, 0, 22769, 22770, + 5, 95, 0, 0, 22770, 22771, 7, 8, 0, 0, 22771, 22772, 7, 2, 0, 0, 22772, + 22773, 7, 7, 0, 0, 22773, 22774, 7, 13, 0, 0, 22774, 22775, 7, 6, 0, 0, + 22775, 22776, 7, 3, 0, 0, 22776, 22777, 7, 4, 0, 0, 22777, 3326, 1, 0, + 0, 0, 22778, 22779, 7, 5, 0, 0, 22779, 22780, 7, 6, 0, 0, 22780, 22781, + 7, 3, 0, 0, 22781, 22782, 7, 13, 0, 0, 22782, 22783, 7, 10, 0, 0, 22783, + 22784, 7, 8, 0, 0, 22784, 22785, 7, 6, 0, 0, 22785, 3328, 1, 0, 0, 0, 22786, + 22787, 7, 5, 0, 0, 22787, 22788, 7, 6, 0, 0, 22788, 22789, 7, 3, 0, 0, + 22789, 22790, 7, 13, 0, 0, 22790, 22791, 7, 10, 0, 0, 22791, 22792, 7, + 8, 0, 0, 22792, 22793, 7, 6, 0, 0, 22793, 22794, 7, 5, 0, 0, 22794, 3330, + 1, 0, 0, 0, 22795, 22796, 7, 5, 0, 0, 22796, 22797, 7, 6, 0, 0, 22797, + 22798, 7, 5, 0, 0, 22798, 22799, 7, 5, 0, 0, 22799, 22800, 7, 10, 0, 0, + 22800, 22801, 7, 2, 0, 0, 22801, 22802, 7, 7, 0, 0, 22802, 22803, 5, 95, + 0, 0, 22803, 22804, 7, 8, 0, 0, 22804, 22805, 7, 0, 0, 0, 22805, 22806, + 7, 8, 0, 0, 22806, 22807, 7, 19, 0, 0, 22807, 22808, 7, 6, 0, 0, 22808, + 22809, 7, 9, 0, 0, 22809, 22810, 5, 95, 0, 0, 22810, 22811, 7, 8, 0, 0, + 22811, 22812, 7, 12, 0, 0, 22812, 22813, 7, 3, 0, 0, 22813, 22814, 7, 5, + 0, 0, 22814, 22815, 7, 2, 0, 0, 22815, 22816, 7, 3, 0, 0, 22816, 22817, + 7, 5, 0, 0, 22817, 3332, 1, 0, 0, 0, 22818, 22819, 7, 5, 0, 0, 22819, 22820, + 7, 6, 0, 0, 22820, 22821, 7, 5, 0, 0, 22821, 22822, 7, 5, 0, 0, 22822, + 22823, 7, 10, 0, 0, 22823, 22824, 7, 2, 0, 0, 22824, 22825, 7, 7, 0, 0, + 22825, 3334, 1, 0, 0, 0, 22826, 22827, 7, 5, 0, 0, 22827, 22828, 7, 6, + 0, 0, 22828, 22829, 7, 5, 0, 0, 22829, 22830, 7, 5, 0, 0, 22830, 22831, + 7, 10, 0, 0, 22831, 22832, 7, 2, 0, 0, 22832, 22833, 7, 7, 0, 0, 22833, + 22834, 7, 5, 0, 0, 22834, 22835, 5, 95, 0, 0, 22835, 22836, 7, 15, 0, 0, + 22836, 22837, 7, 6, 0, 0, 22837, 22838, 7, 3, 0, 0, 22838, 22839, 5, 95, + 0, 0, 22839, 22840, 7, 12, 0, 0, 22840, 22841, 7, 5, 0, 0, 22841, 22842, + 7, 6, 0, 0, 22842, 22843, 7, 3, 0, 0, 22843, 3336, 1, 0, 0, 0, 22844, 22845, + 7, 5, 0, 0, 22845, 22846, 7, 6, 0, 0, 22846, 22847, 7, 5, 0, 0, 22847, + 22848, 7, 5, 0, 0, 22848, 22849, 7, 10, 0, 0, 22849, 22850, 7, 2, 0, 0, + 22850, 22851, 7, 7, 0, 0, 22851, 22852, 7, 4, 0, 0, 22852, 22853, 7, 10, + 0, 0, 22853, 22854, 7, 14, 0, 0, 22854, 22855, 7, 6, 0, 0, 22855, 22856, + 7, 23, 0, 0, 22856, 22857, 7, 2, 0, 0, 22857, 22858, 7, 7, 0, 0, 22858, + 22859, 7, 6, 0, 0, 22859, 3338, 1, 0, 0, 0, 22860, 22861, 7, 5, 0, 0, 22861, + 22862, 7, 6, 0, 0, 22862, 22863, 7, 5, 0, 0, 22863, 22864, 7, 5, 0, 0, + 22864, 22865, 7, 10, 0, 0, 22865, 22866, 7, 2, 0, 0, 22866, 22867, 7, 7, + 0, 0, 22867, 22868, 7, 4, 0, 0, 22868, 22869, 7, 23, 0, 0, 22869, 22870, + 7, 7, 0, 0, 22870, 22871, 7, 0, 0, 0, 22871, 22872, 7, 14, 0, 0, 22872, + 22873, 7, 6, 0, 0, 22873, 3340, 1, 0, 0, 0, 22874, 22875, 7, 5, 0, 0, 22875, + 22876, 7, 6, 0, 0, 22876, 22877, 7, 4, 0, 0, 22877, 3342, 1, 0, 0, 0, 22878, + 22879, 7, 5, 0, 0, 22879, 22880, 7, 6, 0, 0, 22880, 22881, 7, 4, 0, 0, + 22881, 22882, 7, 5, 0, 0, 22882, 3344, 1, 0, 0, 0, 22883, 22884, 7, 5, + 0, 0, 22884, 22885, 7, 6, 0, 0, 22885, 22886, 7, 4, 0, 0, 22886, 22887, + 7, 4, 0, 0, 22887, 22888, 7, 10, 0, 0, 22888, 22889, 7, 7, 0, 0, 22889, + 22890, 7, 17, 0, 0, 22890, 22891, 7, 5, 0, 0, 22891, 3346, 1, 0, 0, 0, + 22892, 22893, 7, 5, 0, 0, 22893, 22894, 7, 6, 0, 0, 22894, 22895, 7, 4, + 0, 0, 22895, 22896, 5, 95, 0, 0, 22896, 22897, 7, 4, 0, 0, 22897, 22898, + 7, 2, 0, 0, 22898, 22899, 5, 95, 0, 0, 22899, 22900, 7, 20, 0, 0, 22900, + 22901, 7, 2, 0, 0, 22901, 22902, 7, 10, 0, 0, 22902, 22903, 7, 7, 0, 0, + 22903, 3348, 1, 0, 0, 0, 22904, 22905, 7, 5, 0, 0, 22905, 22906, 7, 6, + 0, 0, 22906, 22907, 7, 13, 0, 0, 22907, 22908, 7, 6, 0, 0, 22908, 22909, + 7, 3, 0, 0, 22909, 22910, 7, 6, 0, 0, 22910, 3350, 1, 0, 0, 0, 22911, 22912, + 7, 5, 0, 0, 22912, 22913, 7, 19, 0, 0, 22913, 22914, 7, 0, 0, 0, 22914, + 22915, 7, 3, 0, 0, 22915, 22916, 7, 9, 0, 0, 22916, 3352, 1, 0, 0, 0, 22917, + 22918, 7, 5, 0, 0, 22918, 22919, 7, 19, 0, 0, 22919, 22920, 7, 0, 0, 0, + 22920, 22921, 7, 3, 0, 0, 22921, 22922, 7, 9, 0, 0, 22922, 22923, 7, 5, + 0, 0, 22923, 22924, 7, 15, 0, 0, 22924, 22925, 7, 0, 0, 0, 22925, 22926, + 7, 8, 0, 0, 22926, 22927, 7, 6, 0, 0, 22927, 3354, 1, 0, 0, 0, 22928, 22929, + 7, 5, 0, 0, 22929, 22930, 7, 19, 0, 0, 22930, 22931, 7, 0, 0, 0, 22931, + 22932, 7, 3, 0, 0, 22932, 22933, 7, 6, 0, 0, 22933, 22934, 7, 9, 0, 0, + 22934, 22935, 5, 95, 0, 0, 22935, 22936, 7, 15, 0, 0, 22936, 22937, 7, + 2, 0, 0, 22937, 22938, 7, 2, 0, 0, 22938, 22939, 7, 11, 0, 0, 22939, 3356, + 1, 0, 0, 0, 22940, 22941, 7, 5, 0, 0, 22941, 22942, 7, 19, 0, 0, 22942, + 22943, 7, 0, 0, 0, 22943, 22944, 7, 3, 0, 0, 22944, 22945, 7, 6, 0, 0, + 22945, 22946, 7, 9, 0, 0, 22946, 3358, 1, 0, 0, 0, 22947, 22948, 7, 5, + 0, 0, 22948, 22949, 7, 19, 0, 0, 22949, 22950, 7, 0, 0, 0, 22950, 22951, + 7, 3, 0, 0, 22951, 22952, 7, 6, 0, 0, 22952, 3360, 1, 0, 0, 0, 22953, 22954, + 7, 5, 0, 0, 22954, 22955, 7, 19, 0, 0, 22955, 22956, 7, 0, 0, 0, 22956, + 22957, 7, 3, 0, 0, 22957, 22958, 7, 10, 0, 0, 22958, 22959, 7, 7, 0, 0, + 22959, 22960, 7, 17, 0, 0, 22960, 3362, 1, 0, 0, 0, 22961, 22962, 7, 5, + 0, 0, 22962, 22963, 7, 19, 0, 0, 22963, 22964, 7, 6, 0, 0, 22964, 22965, + 7, 11, 0, 0, 22965, 22966, 7, 16, 0, 0, 22966, 22967, 7, 11, 0, 0, 22967, + 22968, 7, 10, 0, 0, 22968, 22969, 7, 16, 0, 0, 22969, 22970, 7, 6, 0, 0, + 22970, 3364, 1, 0, 0, 0, 22971, 22972, 7, 5, 0, 0, 22972, 22973, 7, 19, + 0, 0, 22973, 22974, 7, 2, 0, 0, 22974, 22975, 7, 22, 0, 0, 22975, 3366, + 1, 0, 0, 0, 22976, 22977, 7, 5, 0, 0, 22977, 22978, 7, 19, 0, 0, 22978, + 22979, 7, 3, 0, 0, 22979, 22980, 7, 10, 0, 0, 22980, 22981, 7, 7, 0, 0, + 22981, 22982, 7, 21, 0, 0, 22982, 3368, 1, 0, 0, 0, 22983, 22984, 7, 5, + 0, 0, 22984, 22985, 7, 19, 0, 0, 22985, 22986, 7, 12, 0, 0, 22986, 22987, + 7, 4, 0, 0, 22987, 22988, 7, 9, 0, 0, 22988, 22989, 7, 2, 0, 0, 22989, + 22990, 7, 22, 0, 0, 22990, 22991, 7, 7, 0, 0, 22991, 3370, 1, 0, 0, 0, + 22992, 22993, 7, 5, 0, 0, 22993, 22994, 7, 10, 0, 0, 22994, 22995, 7, 1, + 0, 0, 22995, 22996, 7, 11, 0, 0, 22996, 22997, 7, 10, 0, 0, 22997, 22998, + 7, 7, 0, 0, 22998, 22999, 7, 17, 0, 0, 22999, 23000, 7, 5, 0, 0, 23000, + 3372, 1, 0, 0, 0, 23001, 23002, 7, 5, 0, 0, 23002, 23003, 7, 10, 0, 0, + 23003, 23004, 7, 9, 0, 0, 23004, 3374, 1, 0, 0, 0, 23005, 23006, 7, 5, + 0, 0, 23006, 23007, 7, 10, 0, 0, 23007, 23008, 7, 4, 0, 0, 23008, 23009, + 7, 6, 0, 0, 23009, 3376, 1, 0, 0, 0, 23010, 23011, 7, 5, 0, 0, 23011, 23012, + 7, 10, 0, 0, 23012, 23013, 7, 17, 0, 0, 23013, 23014, 7, 7, 0, 0, 23014, + 23015, 7, 0, 0, 0, 23015, 23016, 7, 11, 0, 0, 23016, 23017, 5, 95, 0, 0, + 23017, 23018, 7, 8, 0, 0, 23018, 23019, 7, 2, 0, 0, 23019, 23020, 7, 14, + 0, 0, 23020, 23021, 7, 15, 0, 0, 23021, 23022, 7, 2, 0, 0, 23022, 23023, + 7, 7, 0, 0, 23023, 23024, 7, 6, 0, 0, 23024, 23025, 7, 7, 0, 0, 23025, + 23026, 7, 4, 0, 0, 23026, 3378, 1, 0, 0, 0, 23027, 23028, 7, 5, 0, 0, 23028, + 23029, 7, 10, 0, 0, 23029, 23030, 7, 17, 0, 0, 23030, 23031, 7, 7, 0, 0, + 23031, 23032, 7, 0, 0, 0, 23032, 23033, 7, 11, 0, 0, 23033, 23034, 5, 95, + 0, 0, 23034, 23035, 7, 16, 0, 0, 23035, 23036, 7, 12, 0, 0, 23036, 23037, + 7, 7, 0, 0, 23037, 23038, 7, 8, 0, 0, 23038, 23039, 7, 4, 0, 0, 23039, + 23040, 7, 10, 0, 0, 23040, 23041, 7, 2, 0, 0, 23041, 23042, 7, 7, 0, 0, + 23042, 3380, 1, 0, 0, 0, 23043, 23044, 7, 5, 0, 0, 23044, 23045, 7, 10, + 0, 0, 23045, 23046, 7, 17, 0, 0, 23046, 23047, 7, 7, 0, 0, 23047, 3382, + 1, 0, 0, 0, 23048, 23049, 7, 5, 0, 0, 23049, 23050, 7, 10, 0, 0, 23050, + 23051, 7, 17, 0, 0, 23051, 23052, 7, 7, 0, 0, 23052, 23053, 7, 4, 0, 0, + 23053, 23054, 7, 18, 0, 0, 23054, 23055, 7, 15, 0, 0, 23055, 23056, 7, + 6, 0, 0, 23056, 3384, 1, 0, 0, 0, 23057, 23058, 7, 5, 0, 0, 23058, 23059, + 7, 10, 0, 0, 23059, 23060, 7, 14, 0, 0, 23060, 23061, 7, 15, 0, 0, 23061, + 23062, 7, 11, 0, 0, 23062, 23063, 7, 6, 0, 0, 23063, 23064, 5, 95, 0, 0, + 23064, 23065, 7, 10, 0, 0, 23065, 23066, 7, 7, 0, 0, 23066, 23067, 7, 4, + 0, 0, 23067, 23068, 7, 6, 0, 0, 23068, 23069, 7, 17, 0, 0, 23069, 23070, + 7, 6, 0, 0, 23070, 23071, 7, 3, 0, 0, 23071, 3386, 1, 0, 0, 0, 23072, 23073, + 7, 5, 0, 0, 23073, 23074, 7, 10, 0, 0, 23074, 23075, 7, 14, 0, 0, 23075, + 23076, 7, 15, 0, 0, 23076, 23077, 7, 11, 0, 0, 23077, 23078, 7, 6, 0, 0, + 23078, 3388, 1, 0, 0, 0, 23079, 23080, 7, 5, 0, 0, 23080, 23081, 7, 10, + 0, 0, 23081, 23082, 7, 7, 0, 0, 23082, 23083, 7, 17, 0, 0, 23083, 23084, + 7, 11, 0, 0, 23084, 23085, 7, 6, 0, 0, 23085, 3390, 1, 0, 0, 0, 23086, + 23087, 7, 5, 0, 0, 23087, 23088, 7, 10, 0, 0, 23088, 23089, 7, 7, 0, 0, + 23089, 23090, 7, 17, 0, 0, 23090, 23091, 7, 11, 0, 0, 23091, 23092, 7, + 6, 0, 0, 23092, 23093, 7, 4, 0, 0, 23093, 23094, 7, 0, 0, 0, 23094, 23095, + 7, 5, 0, 0, 23095, 23096, 7, 21, 0, 0, 23096, 3392, 1, 0, 0, 0, 23097, + 23098, 7, 5, 0, 0, 23098, 23099, 7, 10, 0, 0, 23099, 23100, 7, 7, 0, 0, + 23100, 23101, 7, 19, 0, 0, 23101, 3394, 1, 0, 0, 0, 23102, 23103, 7, 5, + 0, 0, 23103, 23104, 7, 10, 0, 0, 23104, 23105, 7, 7, 0, 0, 23105, 3396, + 1, 0, 0, 0, 23106, 23107, 7, 5, 0, 0, 23107, 23108, 7, 10, 0, 0, 23108, + 23109, 7, 23, 0, 0, 23109, 23110, 7, 6, 0, 0, 23110, 3398, 1, 0, 0, 0, + 23111, 23112, 7, 5, 0, 0, 23112, 23113, 7, 10, 0, 0, 23113, 23114, 7, 23, + 0, 0, 23114, 23115, 7, 6, 0, 0, 23115, 23116, 7, 5, 0, 0, 23116, 3400, + 1, 0, 0, 0, 23117, 23118, 7, 5, 0, 0, 23118, 23119, 7, 21, 0, 0, 23119, + 23120, 7, 10, 0, 0, 23120, 23121, 7, 15, 0, 0, 23121, 23122, 5, 95, 0, + 0, 23122, 23123, 7, 6, 0, 0, 23123, 23124, 7, 25, 0, 0, 23124, 23125, 7, + 4, 0, 0, 23125, 23126, 5, 95, 0, 0, 23126, 23127, 7, 2, 0, 0, 23127, 23128, + 7, 15, 0, 0, 23128, 23129, 7, 4, 0, 0, 23129, 23130, 7, 10, 0, 0, 23130, + 23131, 7, 14, 0, 0, 23131, 23132, 7, 10, 0, 0, 23132, 23133, 7, 23, 0, + 0, 23133, 23134, 7, 6, 0, 0, 23134, 23135, 7, 3, 0, 0, 23135, 3402, 1, + 0, 0, 0, 23136, 23137, 7, 5, 0, 0, 23137, 23138, 7, 21, 0, 0, 23138, 23139, + 7, 10, 0, 0, 23139, 23140, 7, 15, 0, 0, 23140, 3404, 1, 0, 0, 0, 23141, + 23142, 7, 5, 0, 0, 23142, 23143, 7, 21, 0, 0, 23143, 23144, 7, 10, 0, 0, + 23144, 23145, 7, 15, 0, 0, 23145, 23146, 5, 95, 0, 0, 23146, 23147, 7, + 12, 0, 0, 23147, 23148, 7, 7, 0, 0, 23148, 23149, 7, 24, 0, 0, 23149, 23150, + 5, 95, 0, 0, 23150, 23151, 7, 12, 0, 0, 23151, 23152, 7, 7, 0, 0, 23152, + 23153, 7, 12, 0, 0, 23153, 23154, 7, 5, 0, 0, 23154, 23155, 7, 0, 0, 0, + 23155, 23156, 7, 1, 0, 0, 23156, 23157, 7, 11, 0, 0, 23157, 23158, 7, 6, + 0, 0, 23158, 23159, 5, 95, 0, 0, 23159, 23160, 7, 10, 0, 0, 23160, 23161, + 7, 9, 0, 0, 23161, 23162, 7, 25, 0, 0, 23162, 3406, 1, 0, 0, 0, 23163, + 23164, 7, 5, 0, 0, 23164, 23165, 7, 21, 0, 0, 23165, 23166, 7, 10, 0, 0, + 23166, 23167, 7, 15, 0, 0, 23167, 23168, 5, 95, 0, 0, 23168, 23169, 7, + 12, 0, 0, 23169, 23170, 7, 7, 0, 0, 23170, 23171, 7, 12, 0, 0, 23171, 23172, + 7, 5, 0, 0, 23172, 23173, 7, 0, 0, 0, 23173, 23174, 7, 1, 0, 0, 23174, + 23175, 7, 11, 0, 0, 23175, 23176, 7, 6, 0, 0, 23176, 23177, 5, 95, 0, 0, + 23177, 23178, 7, 10, 0, 0, 23178, 23179, 7, 7, 0, 0, 23179, 23180, 7, 9, + 0, 0, 23180, 23181, 7, 6, 0, 0, 23181, 23182, 7, 25, 0, 0, 23182, 23183, + 7, 6, 0, 0, 23183, 23184, 7, 5, 0, 0, 23184, 3408, 1, 0, 0, 0, 23185, 23186, + 7, 5, 0, 0, 23186, 23187, 7, 14, 0, 0, 23187, 23188, 7, 0, 0, 0, 23188, + 23189, 7, 11, 0, 0, 23189, 23190, 7, 11, 0, 0, 23190, 23191, 7, 16, 0, + 0, 23191, 23192, 7, 10, 0, 0, 23192, 23193, 7, 11, 0, 0, 23193, 23194, + 7, 6, 0, 0, 23194, 3410, 1, 0, 0, 0, 23195, 23196, 7, 5, 0, 0, 23196, 23197, + 7, 14, 0, 0, 23197, 23198, 7, 0, 0, 0, 23198, 23199, 7, 11, 0, 0, 23199, + 23200, 7, 11, 0, 0, 23200, 23201, 7, 10, 0, 0, 23201, 23202, 7, 7, 0, 0, + 23202, 23203, 7, 4, 0, 0, 23203, 3412, 1, 0, 0, 0, 23204, 23205, 7, 5, + 0, 0, 23205, 23206, 7, 7, 0, 0, 23206, 23207, 7, 0, 0, 0, 23207, 23208, + 7, 15, 0, 0, 23208, 23209, 7, 5, 0, 0, 23209, 23210, 7, 19, 0, 0, 23210, + 23211, 7, 2, 0, 0, 23211, 23212, 7, 4, 0, 0, 23212, 3414, 1, 0, 0, 0, 23213, + 23214, 7, 5, 0, 0, 23214, 23215, 7, 2, 0, 0, 23215, 23216, 7, 14, 0, 0, + 23216, 23217, 7, 6, 0, 0, 23217, 3416, 1, 0, 0, 0, 23218, 23219, 7, 5, + 0, 0, 23219, 23220, 7, 2, 0, 0, 23220, 23221, 7, 3, 0, 0, 23221, 23222, + 7, 4, 0, 0, 23222, 3418, 1, 0, 0, 0, 23223, 23224, 7, 5, 0, 0, 23224, 23225, + 7, 2, 0, 0, 23225, 23226, 7, 12, 0, 0, 23226, 23227, 7, 7, 0, 0, 23227, + 23228, 7, 9, 0, 0, 23228, 23229, 7, 6, 0, 0, 23229, 23230, 7, 25, 0, 0, + 23230, 3420, 1, 0, 0, 0, 23231, 23232, 7, 5, 0, 0, 23232, 23233, 7, 2, + 0, 0, 23233, 23234, 7, 12, 0, 0, 23234, 23235, 7, 3, 0, 0, 23235, 23236, + 7, 8, 0, 0, 23236, 23237, 7, 6, 0, 0, 23237, 23238, 5, 95, 0, 0, 23238, + 23239, 7, 16, 0, 0, 23239, 23240, 7, 10, 0, 0, 23240, 23241, 7, 11, 0, + 0, 23241, 23242, 7, 6, 0, 0, 23242, 23243, 5, 95, 0, 0, 23243, 23244, 7, + 9, 0, 0, 23244, 23245, 7, 10, 0, 0, 23245, 23246, 7, 3, 0, 0, 23246, 23247, + 7, 6, 0, 0, 23247, 23248, 7, 8, 0, 0, 23248, 23249, 7, 4, 0, 0, 23249, + 23250, 7, 2, 0, 0, 23250, 23251, 7, 3, 0, 0, 23251, 23252, 7, 18, 0, 0, + 23252, 3422, 1, 0, 0, 0, 23253, 23254, 7, 5, 0, 0, 23254, 23255, 7, 2, + 0, 0, 23255, 23256, 7, 12, 0, 0, 23256, 23257, 7, 3, 0, 0, 23257, 23258, + 7, 8, 0, 0, 23258, 23259, 7, 6, 0, 0, 23259, 23260, 5, 95, 0, 0, 23260, + 23261, 7, 16, 0, 0, 23261, 23262, 7, 10, 0, 0, 23262, 23263, 7, 11, 0, + 0, 23263, 23264, 7, 6, 0, 0, 23264, 23265, 5, 95, 0, 0, 23265, 23266, 7, + 7, 0, 0, 23266, 23267, 7, 0, 0, 0, 23267, 23268, 7, 14, 0, 0, 23268, 23269, + 7, 6, 0, 0, 23269, 23270, 5, 95, 0, 0, 23270, 23271, 7, 8, 0, 0, 23271, + 23272, 7, 2, 0, 0, 23272, 23273, 7, 7, 0, 0, 23273, 23274, 7, 13, 0, 0, + 23274, 23275, 7, 6, 0, 0, 23275, 23276, 7, 3, 0, 0, 23276, 23277, 7, 4, + 0, 0, 23277, 3424, 1, 0, 0, 0, 23278, 23279, 7, 5, 0, 0, 23279, 23280, + 7, 2, 0, 0, 23280, 23281, 7, 12, 0, 0, 23281, 23282, 7, 3, 0, 0, 23282, + 23283, 7, 8, 0, 0, 23283, 23284, 7, 6, 0, 0, 23284, 3426, 1, 0, 0, 0, 23285, + 23286, 7, 5, 0, 0, 23286, 23287, 7, 15, 0, 0, 23287, 23288, 7, 0, 0, 0, + 23288, 23289, 7, 8, 0, 0, 23289, 23290, 7, 6, 0, 0, 23290, 3428, 1, 0, + 0, 0, 23291, 23292, 7, 5, 0, 0, 23292, 23293, 7, 15, 0, 0, 23293, 23294, + 7, 6, 0, 0, 23294, 23295, 7, 8, 0, 0, 23295, 23296, 7, 10, 0, 0, 23296, + 23297, 7, 16, 0, 0, 23297, 23298, 7, 10, 0, 0, 23298, 23299, 7, 8, 0, 0, + 23299, 23300, 7, 0, 0, 0, 23300, 23301, 7, 4, 0, 0, 23301, 23302, 7, 10, + 0, 0, 23302, 23303, 7, 2, 0, 0, 23303, 23304, 7, 7, 0, 0, 23304, 3430, + 1, 0, 0, 0, 23305, 23306, 7, 5, 0, 0, 23306, 23307, 7, 15, 0, 0, 23307, + 23308, 7, 16, 0, 0, 23308, 23309, 7, 10, 0, 0, 23309, 23310, 7, 11, 0, + 0, 23310, 23311, 7, 6, 0, 0, 23311, 3432, 1, 0, 0, 0, 23312, 23313, 7, + 5, 0, 0, 23313, 23314, 7, 15, 0, 0, 23314, 23315, 7, 11, 0, 0, 23315, 23316, + 7, 10, 0, 0, 23316, 23317, 7, 4, 0, 0, 23317, 3434, 1, 0, 0, 0, 23318, + 23319, 7, 5, 0, 0, 23319, 23320, 7, 15, 0, 0, 23320, 23321, 7, 3, 0, 0, + 23321, 23322, 7, 6, 0, 0, 23322, 23323, 7, 0, 0, 0, 23323, 23324, 7, 9, + 0, 0, 23324, 23325, 7, 5, 0, 0, 23325, 23326, 7, 19, 0, 0, 23326, 23327, + 7, 6, 0, 0, 23327, 23328, 7, 6, 0, 0, 23328, 23329, 7, 4, 0, 0, 23329, + 3436, 1, 0, 0, 0, 23330, 23331, 7, 5, 0, 0, 23331, 23332, 7, 24, 0, 0, + 23332, 23333, 7, 11, 0, 0, 23333, 23334, 7, 9, 0, 0, 23334, 23335, 7, 0, + 0, 0, 23335, 23336, 7, 4, 0, 0, 23336, 23337, 7, 0, 0, 0, 23337, 3438, + 1, 0, 0, 0, 23338, 23339, 7, 5, 0, 0, 23339, 23340, 7, 24, 0, 0, 23340, + 23341, 7, 11, 0, 0, 23341, 23342, 7, 6, 0, 0, 23342, 23343, 7, 3, 0, 0, + 23343, 23344, 7, 3, 0, 0, 23344, 23345, 7, 2, 0, 0, 23345, 23346, 7, 3, + 0, 0, 23346, 3440, 1, 0, 0, 0, 23347, 23348, 7, 5, 0, 0, 23348, 23349, + 7, 24, 0, 0, 23349, 23350, 7, 11, 0, 0, 23350, 23351, 7, 11, 0, 0, 23351, + 23352, 7, 9, 0, 0, 23352, 23353, 7, 3, 0, 0, 23353, 3442, 1, 0, 0, 0, 23354, + 23355, 7, 5, 0, 0, 23355, 23356, 7, 24, 0, 0, 23356, 23357, 7, 11, 0, 0, + 23357, 3444, 1, 0, 0, 0, 23358, 23359, 7, 16, 0, 0, 23359, 23360, 7, 7, + 0, 0, 23360, 23376, 7, 8, 0, 0, 23361, 23362, 7, 15, 0, 0, 23362, 23363, + 7, 21, 0, 0, 23363, 23376, 7, 1, 0, 0, 23364, 23365, 7, 15, 0, 0, 23365, + 23366, 7, 21, 0, 0, 23366, 23376, 7, 5, 0, 0, 23367, 23368, 7, 15, 0, 0, + 23368, 23369, 7, 3, 0, 0, 23369, 23376, 7, 8, 0, 0, 23370, 23371, 7, 4, + 0, 0, 23371, 23372, 7, 3, 0, 0, 23372, 23376, 7, 17, 0, 0, 23373, 23374, + 7, 13, 0, 0, 23374, 23376, 7, 22, 0, 0, 23375, 23358, 1, 0, 0, 0, 23375, + 23361, 1, 0, 0, 0, 23375, 23364, 1, 0, 0, 0, 23375, 23367, 1, 0, 0, 0, + 23375, 23370, 1, 0, 0, 0, 23375, 23373, 1, 0, 0, 0, 23376, 3446, 1, 0, + 0, 0, 23377, 23378, 7, 5, 0, 0, 23378, 23379, 7, 24, 0, 0, 23379, 23380, + 7, 11, 0, 0, 23380, 23381, 5, 95, 0, 0, 23381, 23382, 7, 14, 0, 0, 23382, + 23383, 7, 0, 0, 0, 23383, 23384, 7, 8, 0, 0, 23384, 23385, 7, 3, 0, 0, + 23385, 23386, 7, 2, 0, 0, 23386, 3448, 1, 0, 0, 0, 23387, 23388, 7, 5, + 0, 0, 23388, 23389, 7, 24, 0, 0, 23389, 23390, 7, 11, 0, 0, 23390, 23391, + 5, 95, 0, 0, 23391, 23392, 7, 4, 0, 0, 23392, 23393, 7, 3, 0, 0, 23393, + 23394, 7, 0, 0, 0, 23394, 23395, 7, 8, 0, 0, 23395, 23396, 7, 6, 0, 0, + 23396, 3450, 1, 0, 0, 0, 23397, 23398, 7, 5, 0, 0, 23398, 23399, 7, 24, + 0, 0, 23399, 23400, 7, 11, 0, 0, 23400, 23401, 5, 95, 0, 0, 23401, 23402, + 7, 4, 0, 0, 23402, 23403, 7, 3, 0, 0, 23403, 23404, 7, 0, 0, 0, 23404, + 23405, 7, 7, 0, 0, 23405, 23406, 7, 5, 0, 0, 23406, 23407, 7, 11, 0, 0, + 23407, 23408, 7, 0, 0, 0, 23408, 23409, 7, 4, 0, 0, 23409, 23410, 7, 10, + 0, 0, 23410, 23411, 7, 2, 0, 0, 23411, 23412, 7, 7, 0, 0, 23412, 23413, + 5, 95, 0, 0, 23413, 23414, 7, 15, 0, 0, 23414, 23415, 7, 3, 0, 0, 23415, + 23416, 7, 2, 0, 0, 23416, 23417, 7, 16, 0, 0, 23417, 23418, 7, 10, 0, 0, + 23418, 23419, 7, 11, 0, 0, 23419, 23420, 7, 6, 0, 0, 23420, 3452, 1, 0, + 0, 0, 23421, 23422, 7, 5, 0, 0, 23422, 23423, 7, 24, 0, 0, 23423, 23424, + 7, 3, 0, 0, 23424, 23425, 7, 4, 0, 0, 23425, 3454, 1, 0, 0, 0, 23426, 23427, + 7, 5, 0, 0, 23427, 23428, 7, 4, 0, 0, 23428, 23429, 7, 0, 0, 0, 23429, + 23430, 7, 11, 0, 0, 23430, 23431, 7, 6, 0, 0, 23431, 3456, 1, 0, 0, 0, + 23432, 23433, 7, 5, 0, 0, 23433, 23434, 7, 4, 0, 0, 23434, 23435, 7, 0, + 0, 0, 23435, 23436, 7, 7, 0, 0, 23436, 23437, 7, 9, 0, 0, 23437, 23438, + 7, 0, 0, 0, 23438, 23439, 7, 11, 0, 0, 23439, 23440, 7, 2, 0, 0, 23440, + 23441, 7, 7, 0, 0, 23441, 23442, 7, 6, 0, 0, 23442, 3458, 1, 0, 0, 0, 23443, + 23444, 7, 5, 0, 0, 23444, 23445, 7, 4, 0, 0, 23445, 23446, 7, 0, 0, 0, + 23446, 23447, 7, 7, 0, 0, 23447, 23448, 7, 9, 0, 0, 23448, 23449, 7, 0, + 0, 0, 23449, 23450, 7, 3, 0, 0, 23450, 23451, 7, 9, 0, 0, 23451, 3460, + 1, 0, 0, 0, 23452, 23453, 7, 5, 0, 0, 23453, 23454, 7, 4, 0, 0, 23454, + 23455, 7, 0, 0, 0, 23455, 23456, 7, 7, 0, 0, 23456, 23457, 7, 9, 0, 0, + 23457, 23458, 7, 0, 0, 0, 23458, 23459, 7, 3, 0, 0, 23459, 23460, 7, 9, + 0, 0, 23460, 23461, 5, 95, 0, 0, 23461, 23462, 7, 19, 0, 0, 23462, 23463, + 7, 0, 0, 0, 23463, 23464, 7, 5, 0, 0, 23464, 23465, 7, 19, 0, 0, 23465, + 3462, 1, 0, 0, 0, 23466, 23467, 7, 5, 0, 0, 23467, 23468, 7, 4, 0, 0, 23468, + 23469, 7, 0, 0, 0, 23469, 23470, 7, 7, 0, 0, 23470, 23471, 7, 9, 0, 0, + 23471, 23472, 7, 1, 0, 0, 23472, 23473, 7, 18, 0, 0, 23473, 23474, 5, 95, + 0, 0, 23474, 23475, 7, 14, 0, 0, 23475, 23476, 7, 0, 0, 0, 23476, 23477, + 7, 25, 0, 0, 23477, 23478, 5, 95, 0, 0, 23478, 23479, 7, 9, 0, 0, 23479, + 23480, 7, 0, 0, 0, 23480, 23481, 7, 4, 0, 0, 23481, 23482, 7, 0, 0, 0, + 23482, 23483, 5, 95, 0, 0, 23483, 23484, 7, 9, 0, 0, 23484, 23485, 7, 6, + 0, 0, 23485, 23486, 7, 11, 0, 0, 23486, 23487, 7, 0, 0, 0, 23487, 23488, + 7, 18, 0, 0, 23488, 3464, 1, 0, 0, 0, 23489, 23490, 7, 5, 0, 0, 23490, + 23491, 7, 4, 0, 0, 23491, 23492, 7, 0, 0, 0, 23492, 23493, 7, 7, 0, 0, + 23493, 23494, 7, 9, 0, 0, 23494, 23495, 7, 1, 0, 0, 23495, 23496, 7, 18, + 0, 0, 23496, 23497, 7, 5, 0, 0, 23497, 3466, 1, 0, 0, 0, 23498, 23499, + 7, 5, 0, 0, 23499, 23500, 7, 4, 0, 0, 23500, 23501, 7, 0, 0, 0, 23501, + 23502, 7, 7, 0, 0, 23502, 23503, 7, 9, 0, 0, 23503, 23504, 7, 1, 0, 0, + 23504, 23505, 7, 18, 0, 0, 23505, 3468, 1, 0, 0, 0, 23506, 23507, 7, 5, + 0, 0, 23507, 23508, 7, 4, 0, 0, 23508, 23509, 7, 0, 0, 0, 23509, 23510, + 7, 3, 0, 0, 23510, 3470, 1, 0, 0, 0, 23511, 23512, 7, 5, 0, 0, 23512, 23513, + 7, 4, 0, 0, 23513, 23514, 7, 0, 0, 0, 23514, 23515, 7, 3, 0, 0, 23515, + 23516, 5, 95, 0, 0, 23516, 23517, 7, 4, 0, 0, 23517, 23518, 7, 3, 0, 0, + 23518, 23519, 7, 0, 0, 0, 23519, 23520, 7, 7, 0, 0, 23520, 23521, 7, 5, + 0, 0, 23521, 23522, 7, 16, 0, 0, 23522, 23523, 7, 2, 0, 0, 23523, 23524, + 7, 3, 0, 0, 23524, 23525, 7, 14, 0, 0, 23525, 23526, 7, 0, 0, 0, 23526, + 23527, 7, 4, 0, 0, 23527, 23528, 7, 10, 0, 0, 23528, 23529, 7, 2, 0, 0, + 23529, 23530, 7, 7, 0, 0, 23530, 3472, 1, 0, 0, 0, 23531, 23532, 7, 5, + 0, 0, 23532, 23533, 7, 4, 0, 0, 23533, 23534, 7, 0, 0, 0, 23534, 23535, + 7, 3, 0, 0, 23535, 23536, 7, 4, 0, 0, 23536, 3474, 1, 0, 0, 0, 23537, 23538, + 7, 5, 0, 0, 23538, 23539, 7, 4, 0, 0, 23539, 23540, 7, 0, 0, 0, 23540, + 23541, 7, 3, 0, 0, 23541, 23542, 7, 4, 0, 0, 23542, 23543, 7, 2, 0, 0, + 23543, 23544, 7, 16, 0, 0, 23544, 3476, 1, 0, 0, 0, 23545, 23546, 7, 5, + 0, 0, 23546, 23547, 7, 4, 0, 0, 23547, 23548, 7, 0, 0, 0, 23548, 23549, + 7, 3, 0, 0, 23549, 23550, 7, 4, 0, 0, 23550, 23551, 7, 12, 0, 0, 23551, + 23552, 7, 15, 0, 0, 23552, 3478, 1, 0, 0, 0, 23553, 23554, 7, 5, 0, 0, + 23554, 23555, 7, 4, 0, 0, 23555, 23556, 7, 0, 0, 0, 23556, 23557, 7, 4, + 0, 0, 23557, 23558, 7, 6, 0, 0, 23558, 23559, 7, 14, 0, 0, 23559, 23560, + 7, 6, 0, 0, 23560, 23561, 7, 7, 0, 0, 23561, 23562, 7, 4, 0, 0, 23562, + 23563, 5, 95, 0, 0, 23563, 23564, 7, 10, 0, 0, 23564, 23565, 7, 9, 0, 0, + 23565, 3480, 1, 0, 0, 0, 23566, 23567, 7, 5, 0, 0, 23567, 23568, 7, 4, + 0, 0, 23568, 23569, 7, 0, 0, 0, 23569, 23570, 7, 4, 0, 0, 23570, 23571, + 7, 6, 0, 0, 23571, 23572, 7, 14, 0, 0, 23572, 23573, 7, 6, 0, 0, 23573, + 23574, 7, 7, 0, 0, 23574, 23575, 7, 4, 0, 0, 23575, 23576, 5, 95, 0, 0, + 23576, 23577, 7, 24, 0, 0, 23577, 23578, 7, 12, 0, 0, 23578, 23579, 7, + 6, 0, 0, 23579, 23580, 7, 12, 0, 0, 23580, 23581, 7, 10, 0, 0, 23581, 23582, + 7, 7, 0, 0, 23582, 23583, 7, 17, 0, 0, 23583, 3482, 1, 0, 0, 0, 23584, + 23585, 7, 5, 0, 0, 23585, 23586, 7, 4, 0, 0, 23586, 23587, 7, 0, 0, 0, + 23587, 23588, 7, 4, 0, 0, 23588, 23589, 7, 6, 0, 0, 23589, 23590, 7, 14, + 0, 0, 23590, 23591, 7, 6, 0, 0, 23591, 23592, 7, 7, 0, 0, 23592, 23593, + 7, 4, 0, 0, 23593, 23594, 7, 5, 0, 0, 23594, 3484, 1, 0, 0, 0, 23595, 23596, + 7, 5, 0, 0, 23596, 23597, 7, 4, 0, 0, 23597, 23598, 7, 0, 0, 0, 23598, + 23599, 7, 4, 0, 0, 23599, 23600, 7, 6, 0, 0, 23600, 23601, 7, 14, 0, 0, + 23601, 23602, 7, 6, 0, 0, 23602, 23603, 7, 7, 0, 0, 23603, 23604, 7, 4, + 0, 0, 23604, 3486, 1, 0, 0, 0, 23605, 23606, 7, 5, 0, 0, 23606, 23607, + 7, 4, 0, 0, 23607, 23608, 7, 0, 0, 0, 23608, 23609, 7, 4, 0, 0, 23609, + 23610, 7, 6, 0, 0, 23610, 3488, 1, 0, 0, 0, 23611, 23612, 7, 5, 0, 0, 23612, + 23613, 7, 4, 0, 0, 23613, 23614, 7, 0, 0, 0, 23614, 23615, 7, 4, 0, 0, + 23615, 23616, 7, 10, 0, 0, 23616, 23617, 7, 8, 0, 0, 23617, 3490, 1, 0, + 0, 0, 23618, 23619, 7, 5, 0, 0, 23619, 23620, 7, 4, 0, 0, 23620, 23621, + 7, 0, 0, 0, 23621, 23622, 7, 4, 0, 0, 23622, 23623, 7, 10, 0, 0, 23623, + 23624, 7, 5, 0, 0, 23624, 23625, 7, 4, 0, 0, 23625, 23626, 7, 10, 0, 0, + 23626, 23627, 7, 8, 0, 0, 23627, 23628, 7, 5, 0, 0, 23628, 3492, 1, 0, + 0, 0, 23629, 23630, 7, 5, 0, 0, 23630, 23631, 7, 4, 0, 0, 23631, 23632, + 7, 0, 0, 0, 23632, 23633, 7, 4, 0, 0, 23633, 23634, 7, 5, 0, 0, 23634, + 23635, 5, 95, 0, 0, 23635, 23636, 7, 1, 0, 0, 23636, 23637, 7, 10, 0, 0, + 23637, 23638, 7, 7, 0, 0, 23638, 23639, 7, 2, 0, 0, 23639, 23640, 7, 14, + 0, 0, 23640, 23641, 7, 10, 0, 0, 23641, 23642, 7, 0, 0, 0, 23642, 23643, + 7, 11, 0, 0, 23643, 23644, 5, 95, 0, 0, 23644, 23645, 7, 4, 0, 0, 23645, + 23646, 7, 6, 0, 0, 23646, 23647, 7, 5, 0, 0, 23647, 23648, 7, 4, 0, 0, + 23648, 3494, 1, 0, 0, 0, 23649, 23650, 7, 5, 0, 0, 23650, 23651, 7, 4, + 0, 0, 23651, 23652, 7, 0, 0, 0, 23652, 23653, 7, 4, 0, 0, 23653, 23654, + 7, 5, 0, 0, 23654, 23655, 5, 95, 0, 0, 23655, 23656, 7, 8, 0, 0, 23656, + 23657, 7, 3, 0, 0, 23657, 23658, 7, 2, 0, 0, 23658, 23659, 7, 5, 0, 0, + 23659, 23660, 7, 5, 0, 0, 23660, 23661, 7, 4, 0, 0, 23661, 23662, 7, 0, + 0, 0, 23662, 23663, 7, 1, 0, 0, 23663, 3496, 1, 0, 0, 0, 23664, 23665, + 7, 5, 0, 0, 23665, 23666, 7, 4, 0, 0, 23666, 23667, 7, 0, 0, 0, 23667, + 23668, 7, 4, 0, 0, 23668, 23669, 7, 5, 0, 0, 23669, 23670, 5, 95, 0, 0, + 23670, 23671, 7, 16, 0, 0, 23671, 23672, 5, 95, 0, 0, 23672, 23673, 7, + 4, 0, 0, 23673, 23674, 7, 6, 0, 0, 23674, 23675, 7, 5, 0, 0, 23675, 23676, + 7, 4, 0, 0, 23676, 3498, 1, 0, 0, 0, 23677, 23678, 7, 5, 0, 0, 23678, 23679, + 7, 4, 0, 0, 23679, 23680, 7, 0, 0, 0, 23680, 23681, 7, 4, 0, 0, 23681, + 23682, 7, 5, 0, 0, 23682, 23683, 5, 95, 0, 0, 23683, 23684, 7, 21, 0, 0, + 23684, 23685, 7, 5, 0, 0, 23685, 23686, 5, 95, 0, 0, 23686, 23687, 7, 4, + 0, 0, 23687, 23688, 7, 6, 0, 0, 23688, 23689, 7, 5, 0, 0, 23689, 23690, + 7, 4, 0, 0, 23690, 3500, 1, 0, 0, 0, 23691, 23692, 7, 5, 0, 0, 23692, 23693, + 7, 4, 0, 0, 23693, 23694, 7, 0, 0, 0, 23694, 23695, 7, 4, 0, 0, 23695, + 23696, 7, 5, 0, 0, 23696, 23697, 5, 95, 0, 0, 23697, 23698, 7, 14, 0, 0, + 23698, 23699, 7, 2, 0, 0, 23699, 23700, 7, 9, 0, 0, 23700, 23701, 7, 6, + 0, 0, 23701, 3502, 1, 0, 0, 0, 23702, 23703, 7, 5, 0, 0, 23703, 23704, + 7, 4, 0, 0, 23704, 23705, 7, 0, 0, 0, 23705, 23706, 7, 4, 0, 0, 23706, + 23707, 7, 5, 0, 0, 23707, 23708, 5, 95, 0, 0, 23708, 23709, 7, 14, 0, 0, + 23709, 23710, 7, 22, 0, 0, 23710, 23711, 5, 95, 0, 0, 23711, 23712, 7, + 4, 0, 0, 23712, 23713, 7, 6, 0, 0, 23713, 23714, 7, 5, 0, 0, 23714, 23715, + 7, 4, 0, 0, 23715, 3504, 1, 0, 0, 0, 23716, 23717, 7, 5, 0, 0, 23717, 23718, + 7, 4, 0, 0, 23718, 23719, 7, 0, 0, 0, 23719, 23720, 7, 4, 0, 0, 23720, + 23721, 7, 5, 0, 0, 23721, 23722, 5, 95, 0, 0, 23722, 23723, 7, 2, 0, 0, + 23723, 23724, 7, 7, 0, 0, 23724, 23725, 7, 6, 0, 0, 23725, 23726, 5, 95, + 0, 0, 23726, 23727, 7, 22, 0, 0, 23727, 23728, 7, 0, 0, 0, 23728, 23729, + 7, 18, 0, 0, 23729, 23730, 5, 95, 0, 0, 23730, 23731, 7, 0, 0, 0, 23731, + 23732, 7, 7, 0, 0, 23732, 23733, 7, 2, 0, 0, 23733, 23734, 7, 13, 0, 0, + 23734, 23735, 7, 0, 0, 0, 23735, 3506, 1, 0, 0, 0, 23736, 23737, 7, 5, + 0, 0, 23737, 23738, 7, 4, 0, 0, 23738, 23739, 7, 0, 0, 0, 23739, 23740, + 7, 4, 0, 0, 23740, 23741, 7, 5, 0, 0, 23741, 23742, 5, 95, 0, 0, 23742, + 23743, 7, 4, 0, 0, 23743, 23744, 5, 95, 0, 0, 23744, 23745, 7, 4, 0, 0, + 23745, 23746, 7, 6, 0, 0, 23746, 23747, 7, 5, 0, 0, 23747, 23748, 7, 4, + 0, 0, 23748, 23749, 5, 95, 0, 0, 23749, 23750, 7, 10, 0, 0, 23750, 23751, + 7, 7, 0, 0, 23751, 23752, 7, 9, 0, 0, 23752, 23753, 7, 6, 0, 0, 23753, + 23754, 7, 15, 0, 0, 23754, 3508, 1, 0, 0, 0, 23755, 23756, 7, 5, 0, 0, + 23756, 23757, 7, 4, 0, 0, 23757, 23758, 7, 0, 0, 0, 23758, 23759, 7, 4, + 0, 0, 23759, 23760, 7, 5, 0, 0, 23760, 23761, 5, 95, 0, 0, 23761, 23762, + 7, 4, 0, 0, 23762, 23763, 5, 95, 0, 0, 23763, 23764, 7, 4, 0, 0, 23764, + 23765, 7, 6, 0, 0, 23765, 23766, 7, 5, 0, 0, 23766, 23767, 7, 4, 0, 0, + 23767, 23768, 5, 95, 0, 0, 23768, 23769, 7, 10, 0, 0, 23769, 23770, 7, + 7, 0, 0, 23770, 23771, 7, 9, 0, 0, 23771, 23772, 7, 6, 0, 0, 23772, 23773, + 7, 15, 0, 0, 23773, 23774, 7, 12, 0, 0, 23774, 3510, 1, 0, 0, 0, 23775, + 23776, 7, 5, 0, 0, 23776, 23777, 7, 4, 0, 0, 23777, 23778, 7, 0, 0, 0, + 23778, 23779, 7, 4, 0, 0, 23779, 23780, 7, 5, 0, 0, 23780, 23781, 5, 95, + 0, 0, 23781, 23782, 7, 4, 0, 0, 23782, 23783, 5, 95, 0, 0, 23783, 23784, + 7, 4, 0, 0, 23784, 23785, 7, 6, 0, 0, 23785, 23786, 7, 5, 0, 0, 23786, + 23787, 7, 4, 0, 0, 23787, 23788, 5, 95, 0, 0, 23788, 23789, 7, 2, 0, 0, + 23789, 23790, 7, 7, 0, 0, 23790, 23791, 7, 6, 0, 0, 23791, 3512, 1, 0, + 0, 0, 23792, 23793, 7, 5, 0, 0, 23793, 23794, 7, 4, 0, 0, 23794, 23795, + 7, 0, 0, 0, 23795, 23796, 7, 4, 0, 0, 23796, 23797, 7, 5, 0, 0, 23797, + 23798, 5, 95, 0, 0, 23798, 23799, 7, 4, 0, 0, 23799, 23800, 5, 95, 0, 0, + 23800, 23801, 7, 4, 0, 0, 23801, 23802, 7, 6, 0, 0, 23802, 23803, 7, 5, + 0, 0, 23803, 23804, 7, 4, 0, 0, 23804, 23805, 5, 95, 0, 0, 23805, 23806, + 7, 15, 0, 0, 23806, 23807, 7, 0, 0, 0, 23807, 23808, 7, 10, 0, 0, 23808, + 23809, 7, 3, 0, 0, 23809, 23810, 7, 6, 0, 0, 23810, 23811, 7, 9, 0, 0, + 23811, 3514, 1, 0, 0, 0, 23812, 23813, 7, 5, 0, 0, 23813, 23814, 7, 4, + 0, 0, 23814, 23815, 7, 0, 0, 0, 23815, 23816, 7, 4, 0, 0, 23816, 23817, + 7, 5, 0, 0, 23817, 23818, 5, 95, 0, 0, 23818, 23819, 7, 22, 0, 0, 23819, + 23820, 7, 5, 0, 0, 23820, 23821, 7, 3, 0, 0, 23821, 23822, 5, 95, 0, 0, + 23822, 23823, 7, 4, 0, 0, 23823, 23824, 7, 6, 0, 0, 23824, 23825, 7, 5, + 0, 0, 23825, 23826, 7, 4, 0, 0, 23826, 3516, 1, 0, 0, 0, 23827, 23828, + 7, 5, 0, 0, 23828, 23829, 7, 4, 0, 0, 23829, 23830, 7, 9, 0, 0, 23830, + 23831, 7, 9, 0, 0, 23831, 23832, 7, 6, 0, 0, 23832, 23833, 7, 13, 0, 0, + 23833, 23834, 5, 95, 0, 0, 23834, 23835, 7, 15, 0, 0, 23835, 23836, 7, + 2, 0, 0, 23836, 23837, 7, 15, 0, 0, 23837, 3518, 1, 0, 0, 0, 23838, 23839, + 7, 5, 0, 0, 23839, 23840, 7, 4, 0, 0, 23840, 23841, 7, 9, 0, 0, 23841, + 23842, 7, 9, 0, 0, 23842, 23843, 7, 6, 0, 0, 23843, 23844, 7, 13, 0, 0, + 23844, 23845, 5, 95, 0, 0, 23845, 23846, 7, 5, 0, 0, 23846, 23847, 7, 0, + 0, 0, 23847, 23848, 7, 14, 0, 0, 23848, 23849, 7, 15, 0, 0, 23849, 3520, + 1, 0, 0, 0, 23850, 23851, 7, 5, 0, 0, 23851, 23852, 7, 4, 0, 0, 23852, + 23853, 7, 2, 0, 0, 23853, 23854, 7, 15, 0, 0, 23854, 3522, 1, 0, 0, 0, + 23855, 23856, 7, 5, 0, 0, 23856, 23857, 7, 4, 0, 0, 23857, 23858, 7, 2, + 0, 0, 23858, 23859, 7, 3, 0, 0, 23859, 23860, 7, 0, 0, 0, 23860, 23861, + 7, 17, 0, 0, 23861, 23862, 7, 6, 0, 0, 23862, 3524, 1, 0, 0, 0, 23863, + 23864, 7, 5, 0, 0, 23864, 23865, 7, 4, 0, 0, 23865, 23866, 7, 2, 0, 0, + 23866, 23867, 7, 3, 0, 0, 23867, 23868, 7, 6, 0, 0, 23868, 3526, 1, 0, + 0, 0, 23869, 23870, 7, 5, 0, 0, 23870, 23871, 7, 4, 0, 0, 23871, 23872, + 7, 3, 0, 0, 23872, 23873, 7, 6, 0, 0, 23873, 23874, 7, 0, 0, 0, 23874, + 23875, 7, 14, 0, 0, 23875, 23876, 7, 5, 0, 0, 23876, 3528, 1, 0, 0, 0, + 23877, 23878, 7, 5, 0, 0, 23878, 23879, 7, 4, 0, 0, 23879, 23880, 7, 3, + 0, 0, 23880, 23881, 7, 6, 0, 0, 23881, 23882, 7, 0, 0, 0, 23882, 23883, + 7, 14, 0, 0, 23883, 3530, 1, 0, 0, 0, 23884, 23885, 7, 5, 0, 0, 23885, + 23886, 7, 4, 0, 0, 23886, 23887, 7, 3, 0, 0, 23887, 23888, 7, 10, 0, 0, + 23888, 23889, 7, 8, 0, 0, 23889, 23890, 7, 4, 0, 0, 23890, 3532, 1, 0, + 0, 0, 23891, 23892, 7, 5, 0, 0, 23892, 23893, 7, 4, 0, 0, 23893, 23894, + 7, 3, 0, 0, 23894, 23895, 7, 10, 0, 0, 23895, 23896, 7, 7, 0, 0, 23896, + 23897, 7, 17, 0, 0, 23897, 3534, 1, 0, 0, 0, 23898, 23899, 7, 5, 0, 0, + 23899, 23900, 7, 4, 0, 0, 23900, 23901, 7, 3, 0, 0, 23901, 23902, 7, 10, + 0, 0, 23902, 23903, 7, 15, 0, 0, 23903, 23904, 7, 6, 0, 0, 23904, 23905, + 5, 95, 0, 0, 23905, 23906, 7, 8, 0, 0, 23906, 23907, 7, 2, 0, 0, 23907, + 23908, 7, 11, 0, 0, 23908, 23909, 7, 12, 0, 0, 23909, 23910, 7, 14, 0, + 0, 23910, 23911, 7, 7, 0, 0, 23911, 23912, 7, 5, 0, 0, 23912, 3536, 1, + 0, 0, 0, 23913, 23914, 7, 5, 0, 0, 23914, 23915, 7, 4, 0, 0, 23915, 23916, + 7, 3, 0, 0, 23916, 23917, 7, 10, 0, 0, 23917, 23918, 7, 15, 0, 0, 23918, + 23919, 7, 6, 0, 0, 23919, 23920, 5, 95, 0, 0, 23920, 23921, 7, 22, 0, 0, + 23921, 23922, 7, 10, 0, 0, 23922, 23923, 7, 9, 0, 0, 23923, 23924, 7, 4, + 0, 0, 23924, 23925, 7, 19, 0, 0, 23925, 3538, 1, 0, 0, 0, 23926, 23927, + 7, 5, 0, 0, 23927, 23928, 7, 4, 0, 0, 23928, 23929, 7, 3, 0, 0, 23929, + 23930, 7, 10, 0, 0, 23930, 23931, 7, 15, 0, 0, 23931, 3540, 1, 0, 0, 0, + 23932, 23933, 7, 5, 0, 0, 23933, 23934, 7, 4, 0, 0, 23934, 23935, 7, 3, + 0, 0, 23935, 23936, 7, 12, 0, 0, 23936, 23937, 7, 8, 0, 0, 23937, 23938, + 7, 4, 0, 0, 23938, 23939, 7, 12, 0, 0, 23939, 23940, 7, 3, 0, 0, 23940, + 23941, 7, 6, 0, 0, 23941, 3542, 1, 0, 0, 0, 23942, 23943, 7, 5, 0, 0, 23943, + 23944, 7, 12, 0, 0, 23944, 23945, 7, 1, 0, 0, 23945, 23946, 7, 14, 0, 0, + 23946, 23947, 7, 12, 0, 0, 23947, 23948, 7, 11, 0, 0, 23948, 23949, 7, + 4, 0, 0, 23949, 23950, 7, 10, 0, 0, 23950, 23951, 7, 5, 0, 0, 23951, 23952, + 7, 6, 0, 0, 23952, 23953, 7, 4, 0, 0, 23953, 3544, 1, 0, 0, 0, 23954, 23955, + 7, 5, 0, 0, 23955, 23956, 7, 12, 0, 0, 23956, 23957, 7, 1, 0, 0, 23957, + 23958, 7, 15, 0, 0, 23958, 23959, 7, 0, 0, 0, 23959, 23960, 7, 3, 0, 0, + 23960, 23961, 7, 4, 0, 0, 23961, 23962, 7, 10, 0, 0, 23962, 23963, 7, 4, + 0, 0, 23963, 23964, 7, 10, 0, 0, 23964, 23965, 7, 2, 0, 0, 23965, 23966, + 7, 7, 0, 0, 23966, 23967, 5, 95, 0, 0, 23967, 23968, 7, 3, 0, 0, 23968, + 23969, 7, 6, 0, 0, 23969, 23970, 7, 11, 0, 0, 23970, 3546, 1, 0, 0, 0, + 23971, 23972, 7, 5, 0, 0, 23972, 23973, 7, 12, 0, 0, 23973, 23974, 7, 1, + 0, 0, 23974, 23975, 7, 15, 0, 0, 23975, 23976, 7, 0, 0, 0, 23976, 23977, + 7, 3, 0, 0, 23977, 23978, 7, 4, 0, 0, 23978, 23979, 7, 10, 0, 0, 23979, + 23980, 7, 4, 0, 0, 23980, 23981, 7, 10, 0, 0, 23981, 23982, 7, 2, 0, 0, + 23982, 23983, 7, 7, 0, 0, 23983, 23984, 7, 5, 0, 0, 23984, 3548, 1, 0, + 0, 0, 23985, 23986, 7, 5, 0, 0, 23986, 23987, 7, 12, 0, 0, 23987, 23988, + 7, 1, 0, 0, 23988, 23989, 7, 15, 0, 0, 23989, 23990, 7, 0, 0, 0, 23990, + 23991, 7, 3, 0, 0, 23991, 23992, 7, 4, 0, 0, 23992, 23993, 7, 10, 0, 0, + 23993, 23994, 7, 4, 0, 0, 23994, 23995, 7, 10, 0, 0, 23995, 23996, 7, 2, + 0, 0, 23996, 23997, 7, 7, 0, 0, 23997, 3550, 1, 0, 0, 0, 23998, 23999, + 7, 5, 0, 0, 23999, 24000, 7, 12, 0, 0, 24000, 24001, 7, 1, 0, 0, 24001, + 24002, 7, 24, 0, 0, 24002, 24003, 7, 12, 0, 0, 24003, 24004, 7, 6, 0, 0, + 24004, 24005, 7, 3, 0, 0, 24005, 24006, 7, 10, 0, 0, 24006, 24007, 7, 6, + 0, 0, 24007, 24008, 7, 5, 0, 0, 24008, 3552, 1, 0, 0, 0, 24009, 24010, + 7, 5, 0, 0, 24010, 24011, 7, 12, 0, 0, 24011, 24012, 7, 1, 0, 0, 24012, + 24013, 7, 24, 0, 0, 24013, 24014, 7, 12, 0, 0, 24014, 24015, 7, 6, 0, 0, + 24015, 24016, 7, 3, 0, 0, 24016, 24017, 7, 18, 0, 0, 24017, 24018, 5, 95, + 0, 0, 24018, 24019, 7, 15, 0, 0, 24019, 24020, 7, 3, 0, 0, 24020, 24021, + 7, 12, 0, 0, 24021, 24022, 7, 7, 0, 0, 24022, 24023, 7, 10, 0, 0, 24023, + 24024, 7, 7, 0, 0, 24024, 24025, 7, 17, 0, 0, 24025, 3554, 1, 0, 0, 0, + 24026, 24027, 7, 5, 0, 0, 24027, 24028, 7, 12, 0, 0, 24028, 24029, 7, 1, + 0, 0, 24029, 24030, 7, 5, 0, 0, 24030, 24031, 7, 8, 0, 0, 24031, 24032, + 7, 3, 0, 0, 24032, 24033, 7, 10, 0, 0, 24033, 24034, 7, 1, 0, 0, 24034, + 24035, 7, 6, 0, 0, 24035, 3556, 1, 0, 0, 0, 24036, 24037, 7, 5, 0, 0, 24037, + 24038, 7, 12, 0, 0, 24038, 24039, 7, 1, 0, 0, 24039, 24040, 7, 5, 0, 0, + 24040, 24041, 7, 6, 0, 0, 24041, 24042, 7, 4, 0, 0, 24042, 3558, 1, 0, + 0, 0, 24043, 24044, 7, 5, 0, 0, 24044, 24045, 7, 12, 0, 0, 24045, 24046, + 7, 1, 0, 0, 24046, 24047, 7, 5, 0, 0, 24047, 24048, 7, 4, 0, 0, 24048, + 24049, 7, 10, 0, 0, 24049, 24050, 7, 4, 0, 0, 24050, 24051, 7, 12, 0, 0, + 24051, 24052, 7, 4, 0, 0, 24052, 24053, 7, 0, 0, 0, 24053, 24054, 7, 1, + 0, 0, 24054, 24055, 7, 11, 0, 0, 24055, 24056, 7, 6, 0, 0, 24056, 3560, + 1, 0, 0, 0, 24057, 24058, 7, 5, 0, 0, 24058, 24059, 7, 12, 0, 0, 24059, + 24060, 7, 1, 0, 0, 24060, 24061, 7, 5, 0, 0, 24061, 24062, 7, 4, 0, 0, + 24062, 24063, 7, 3, 0, 0, 24063, 24064, 5, 50, 0, 0, 24064, 3562, 1, 0, + 0, 0, 24065, 24066, 7, 5, 0, 0, 24066, 24067, 7, 12, 0, 0, 24067, 24068, + 7, 1, 0, 0, 24068, 24069, 7, 5, 0, 0, 24069, 24070, 7, 4, 0, 0, 24070, + 24071, 7, 3, 0, 0, 24071, 24072, 5, 52, 0, 0, 24072, 3564, 1, 0, 0, 0, + 24073, 24074, 7, 5, 0, 0, 24074, 24075, 7, 12, 0, 0, 24075, 24076, 7, 1, + 0, 0, 24076, 24077, 7, 5, 0, 0, 24077, 24078, 7, 4, 0, 0, 24078, 24079, + 7, 3, 0, 0, 24079, 24080, 7, 1, 0, 0, 24080, 3566, 1, 0, 0, 0, 24081, 24082, + 7, 5, 0, 0, 24082, 24083, 7, 12, 0, 0, 24083, 24084, 7, 1, 0, 0, 24084, + 24085, 7, 5, 0, 0, 24085, 24086, 7, 4, 0, 0, 24086, 24087, 7, 3, 0, 0, + 24087, 24088, 7, 8, 0, 0, 24088, 3568, 1, 0, 0, 0, 24089, 24090, 7, 5, + 0, 0, 24090, 24091, 7, 12, 0, 0, 24091, 24092, 7, 1, 0, 0, 24092, 24093, + 7, 4, 0, 0, 24093, 24094, 7, 18, 0, 0, 24094, 24095, 7, 15, 0, 0, 24095, + 24096, 7, 6, 0, 0, 24096, 3570, 1, 0, 0, 0, 24097, 24098, 7, 5, 0, 0, 24098, + 24099, 7, 12, 0, 0, 24099, 24100, 7, 8, 0, 0, 24100, 24101, 7, 8, 0, 0, + 24101, 24102, 7, 6, 0, 0, 24102, 24103, 7, 5, 0, 0, 24103, 24104, 7, 5, + 0, 0, 24104, 24105, 7, 16, 0, 0, 24105, 24106, 7, 12, 0, 0, 24106, 24107, + 7, 11, 0, 0, 24107, 3572, 1, 0, 0, 0, 24108, 24109, 7, 5, 0, 0, 24109, + 24110, 7, 12, 0, 0, 24110, 24111, 7, 8, 0, 0, 24111, 24112, 7, 8, 0, 0, + 24112, 24113, 7, 6, 0, 0, 24113, 24114, 7, 5, 0, 0, 24114, 24115, 7, 5, + 0, 0, 24115, 3574, 1, 0, 0, 0, 24116, 24117, 7, 5, 0, 0, 24117, 24118, + 7, 12, 0, 0, 24118, 24119, 7, 14, 0, 0, 24119, 24120, 7, 14, 0, 0, 24120, + 24121, 7, 0, 0, 0, 24121, 24122, 7, 3, 0, 0, 24122, 24123, 7, 18, 0, 0, + 24123, 3576, 1, 0, 0, 0, 24124, 24125, 7, 5, 0, 0, 24125, 24126, 7, 12, + 0, 0, 24126, 24127, 7, 15, 0, 0, 24127, 24128, 7, 15, 0, 0, 24128, 24129, + 7, 11, 0, 0, 24129, 24130, 7, 6, 0, 0, 24130, 24131, 7, 14, 0, 0, 24131, + 24132, 7, 6, 0, 0, 24132, 24133, 7, 7, 0, 0, 24133, 24134, 7, 4, 0, 0, + 24134, 24135, 7, 0, 0, 0, 24135, 24136, 7, 11, 0, 0, 24136, 3578, 1, 0, + 0, 0, 24137, 24138, 7, 5, 0, 0, 24138, 24139, 7, 12, 0, 0, 24139, 24140, + 7, 5, 0, 0, 24140, 24141, 7, 15, 0, 0, 24141, 24142, 7, 6, 0, 0, 24142, + 24143, 7, 7, 0, 0, 24143, 24144, 7, 9, 0, 0, 24144, 3580, 1, 0, 0, 0, 24145, + 24146, 7, 5, 0, 0, 24146, 24147, 7, 22, 0, 0, 24147, 24148, 7, 0, 0, 0, + 24148, 24149, 7, 15, 0, 0, 24149, 24150, 5, 95, 0, 0, 24150, 24151, 7, + 20, 0, 0, 24151, 24152, 7, 2, 0, 0, 24152, 24153, 7, 10, 0, 0, 24153, 24154, + 7, 7, 0, 0, 24154, 24155, 5, 95, 0, 0, 24155, 24156, 7, 10, 0, 0, 24156, + 24157, 7, 7, 0, 0, 24157, 24158, 7, 15, 0, 0, 24158, 24159, 7, 12, 0, 0, + 24159, 24160, 7, 4, 0, 0, 24160, 24161, 7, 5, 0, 0, 24161, 3582, 1, 0, + 0, 0, 24162, 24163, 7, 5, 0, 0, 24163, 24164, 7, 22, 0, 0, 24164, 24165, + 7, 10, 0, 0, 24165, 24166, 7, 4, 0, 0, 24166, 24167, 7, 8, 0, 0, 24167, + 24168, 7, 19, 0, 0, 24168, 24169, 7, 2, 0, 0, 24169, 24170, 7, 13, 0, 0, + 24170, 24171, 7, 6, 0, 0, 24171, 24172, 7, 3, 0, 0, 24172, 3584, 1, 0, + 0, 0, 24173, 24174, 7, 5, 0, 0, 24174, 24175, 7, 22, 0, 0, 24175, 24176, + 7, 10, 0, 0, 24176, 24177, 7, 4, 0, 0, 24177, 24178, 7, 8, 0, 0, 24178, + 24179, 7, 19, 0, 0, 24179, 3586, 1, 0, 0, 0, 24180, 24181, 7, 5, 0, 0, + 24181, 24182, 7, 18, 0, 0, 24182, 24183, 7, 7, 0, 0, 24183, 24184, 7, 8, + 0, 0, 24184, 24185, 7, 19, 0, 0, 24185, 24186, 7, 3, 0, 0, 24186, 24187, + 7, 2, 0, 0, 24187, 24188, 7, 7, 0, 0, 24188, 24189, 7, 2, 0, 0, 24189, + 24190, 7, 12, 0, 0, 24190, 24191, 7, 5, 0, 0, 24191, 3588, 1, 0, 0, 0, + 24192, 24193, 7, 5, 0, 0, 24193, 24194, 7, 18, 0, 0, 24194, 24195, 7, 7, + 0, 0, 24195, 24196, 7, 8, 0, 0, 24196, 3590, 1, 0, 0, 0, 24197, 24198, + 7, 5, 0, 0, 24198, 24199, 7, 18, 0, 0, 24199, 24200, 7, 7, 0, 0, 24200, + 24201, 7, 2, 0, 0, 24201, 24202, 7, 7, 0, 0, 24202, 24203, 7, 18, 0, 0, + 24203, 24204, 7, 14, 0, 0, 24204, 3592, 1, 0, 0, 0, 24205, 24206, 7, 5, + 0, 0, 24206, 24207, 7, 18, 0, 0, 24207, 24208, 7, 5, 0, 0, 24208, 3594, + 1, 0, 0, 0, 24209, 24210, 7, 5, 0, 0, 24210, 24211, 7, 18, 0, 0, 24211, + 24212, 7, 5, 0, 0, 24212, 24213, 7, 0, 0, 0, 24213, 24214, 7, 5, 0, 0, + 24214, 24215, 7, 14, 0, 0, 24215, 3596, 1, 0, 0, 0, 24216, 24217, 7, 5, + 0, 0, 24217, 24218, 7, 18, 0, 0, 24218, 24219, 7, 5, 0, 0, 24219, 24220, + 5, 95, 0, 0, 24220, 24221, 7, 0, 0, 0, 24221, 24222, 7, 12, 0, 0, 24222, + 24223, 7, 9, 0, 0, 24223, 24224, 7, 10, 0, 0, 24224, 24225, 7, 4, 0, 0, + 24225, 3598, 1, 0, 0, 0, 24226, 24227, 7, 5, 0, 0, 24227, 24228, 7, 18, + 0, 0, 24228, 24229, 7, 5, 0, 0, 24229, 24230, 7, 0, 0, 0, 24230, 24231, + 7, 12, 0, 0, 24231, 24232, 7, 25, 0, 0, 24232, 3600, 1, 0, 0, 0, 24233, + 24234, 7, 5, 0, 0, 24234, 24235, 7, 18, 0, 0, 24235, 24236, 7, 5, 0, 0, + 24236, 24237, 7, 1, 0, 0, 24237, 24238, 7, 0, 0, 0, 24238, 24239, 7, 8, + 0, 0, 24239, 24240, 7, 21, 0, 0, 24240, 24241, 7, 12, 0, 0, 24241, 24242, + 7, 15, 0, 0, 24242, 3602, 1, 0, 0, 0, 24243, 24244, 7, 5, 0, 0, 24244, + 24245, 7, 18, 0, 0, 24245, 24246, 7, 5, 0, 0, 24246, 24247, 5, 95, 0, 0, + 24247, 24248, 7, 8, 0, 0, 24248, 24249, 7, 19, 0, 0, 24249, 24250, 7, 6, + 0, 0, 24250, 24251, 7, 8, 0, 0, 24251, 24252, 7, 21, 0, 0, 24252, 24253, + 7, 0, 0, 0, 24253, 24254, 7, 8, 0, 0, 24254, 24255, 7, 11, 0, 0, 24255, + 3604, 1, 0, 0, 0, 24256, 24257, 7, 5, 0, 0, 24257, 24258, 7, 18, 0, 0, + 24258, 24259, 7, 5, 0, 0, 24259, 24260, 5, 95, 0, 0, 24260, 24261, 7, 8, + 0, 0, 24261, 24262, 7, 19, 0, 0, 24262, 24263, 7, 6, 0, 0, 24263, 24264, + 7, 8, 0, 0, 24264, 24265, 7, 21, 0, 0, 24265, 24266, 5, 95, 0, 0, 24266, + 24267, 7, 15, 0, 0, 24267, 24268, 7, 3, 0, 0, 24268, 24269, 7, 10, 0, 0, + 24269, 24270, 7, 13, 0, 0, 24270, 24271, 7, 10, 0, 0, 24271, 24272, 7, + 11, 0, 0, 24272, 24273, 7, 6, 0, 0, 24273, 24274, 7, 17, 0, 0, 24274, 24275, + 7, 6, 0, 0, 24275, 3606, 1, 0, 0, 0, 24276, 24277, 7, 5, 0, 0, 24277, 24278, + 7, 18, 0, 0, 24278, 24279, 7, 5, 0, 0, 24279, 24280, 5, 95, 0, 0, 24280, + 24281, 7, 8, 0, 0, 24281, 24282, 7, 2, 0, 0, 24282, 24283, 7, 7, 0, 0, + 24283, 24284, 7, 7, 0, 0, 24284, 24285, 7, 6, 0, 0, 24285, 24286, 7, 8, + 0, 0, 24286, 24287, 7, 4, 0, 0, 24287, 24288, 5, 95, 0, 0, 24288, 24289, + 7, 1, 0, 0, 24289, 24290, 7, 18, 0, 0, 24290, 24291, 5, 95, 0, 0, 24291, + 24292, 7, 15, 0, 0, 24292, 24293, 7, 0, 0, 0, 24293, 24294, 7, 4, 0, 0, + 24294, 24295, 7, 19, 0, 0, 24295, 3608, 1, 0, 0, 0, 24296, 24297, 7, 5, + 0, 0, 24297, 24298, 7, 18, 0, 0, 24298, 24299, 7, 5, 0, 0, 24299, 24300, + 5, 95, 0, 0, 24300, 24301, 7, 8, 0, 0, 24301, 24302, 7, 2, 0, 0, 24302, + 24303, 7, 7, 0, 0, 24303, 24304, 7, 4, 0, 0, 24304, 24305, 7, 6, 0, 0, + 24305, 24306, 7, 25, 0, 0, 24306, 24307, 7, 4, 0, 0, 24307, 3610, 1, 0, + 0, 0, 24308, 24309, 7, 5, 0, 0, 24309, 24310, 7, 18, 0, 0, 24310, 24311, + 7, 5, 0, 0, 24311, 24312, 7, 9, 0, 0, 24312, 24313, 7, 0, 0, 0, 24313, + 24314, 7, 4, 0, 0, 24314, 24315, 7, 6, 0, 0, 24315, 3612, 1, 0, 0, 0, 24316, + 24317, 7, 5, 0, 0, 24317, 24318, 7, 18, 0, 0, 24318, 24319, 7, 5, 0, 0, + 24319, 24320, 7, 9, 0, 0, 24320, 24321, 7, 1, 0, 0, 24321, 24322, 7, 0, + 0, 0, 24322, 3614, 1, 0, 0, 0, 24323, 24324, 7, 5, 0, 0, 24324, 24325, + 7, 18, 0, 0, 24325, 24326, 7, 5, 0, 0, 24326, 24327, 5, 95, 0, 0, 24327, + 24328, 7, 9, 0, 0, 24328, 24329, 7, 1, 0, 0, 24329, 24330, 7, 12, 0, 0, + 24330, 24331, 7, 3, 0, 0, 24331, 24332, 7, 10, 0, 0, 24332, 24333, 7, 17, + 0, 0, 24333, 24334, 7, 6, 0, 0, 24334, 24335, 7, 7, 0, 0, 24335, 3616, + 1, 0, 0, 0, 24336, 24337, 7, 5, 0, 0, 24337, 24338, 7, 18, 0, 0, 24338, + 24339, 7, 5, 0, 0, 24339, 24340, 7, 9, 0, 0, 24340, 24341, 7, 17, 0, 0, + 24341, 3618, 1, 0, 0, 0, 24342, 24343, 7, 5, 0, 0, 24343, 24344, 7, 18, + 0, 0, 24344, 24345, 7, 5, 0, 0, 24345, 24346, 5, 95, 0, 0, 24346, 24347, + 7, 9, 0, 0, 24347, 24348, 7, 11, 0, 0, 24348, 24349, 5, 95, 0, 0, 24349, + 24350, 7, 8, 0, 0, 24350, 24351, 7, 12, 0, 0, 24351, 24352, 7, 3, 0, 0, + 24352, 24353, 7, 5, 0, 0, 24353, 24354, 7, 2, 0, 0, 24354, 24355, 7, 3, + 0, 0, 24355, 3620, 1, 0, 0, 0, 24356, 24357, 7, 5, 0, 0, 24357, 24358, + 7, 18, 0, 0, 24358, 24359, 7, 5, 0, 0, 24359, 24360, 5, 95, 0, 0, 24360, + 24361, 7, 9, 0, 0, 24361, 24362, 7, 14, 0, 0, 24362, 24363, 5, 95, 0, 0, + 24363, 24364, 7, 3, 0, 0, 24364, 24365, 7, 25, 0, 0, 24365, 24366, 7, 16, + 0, 0, 24366, 24367, 7, 2, 0, 0, 24367, 24368, 7, 3, 0, 0, 24368, 24369, + 7, 14, 0, 0, 24369, 24370, 5, 95, 0, 0, 24370, 24371, 7, 8, 0, 0, 24371, + 24372, 7, 19, 0, 0, 24372, 24373, 7, 3, 0, 0, 24373, 3622, 1, 0, 0, 0, + 24374, 24375, 7, 5, 0, 0, 24375, 24376, 7, 18, 0, 0, 24376, 24377, 7, 5, + 0, 0, 24377, 24378, 5, 95, 0, 0, 24378, 24379, 7, 9, 0, 0, 24379, 24380, + 7, 14, 0, 0, 24380, 24381, 5, 95, 0, 0, 24381, 24382, 7, 3, 0, 0, 24382, + 24383, 7, 25, 0, 0, 24383, 24384, 7, 16, 0, 0, 24384, 24385, 7, 2, 0, 0, + 24385, 24386, 7, 3, 0, 0, 24386, 24387, 7, 14, 0, 0, 24387, 24388, 5, 95, + 0, 0, 24388, 24389, 7, 7, 0, 0, 24389, 24390, 7, 12, 0, 0, 24390, 24391, + 7, 14, 0, 0, 24391, 3624, 1, 0, 0, 0, 24392, 24393, 7, 5, 0, 0, 24393, + 24394, 7, 18, 0, 0, 24394, 24395, 7, 5, 0, 0, 24395, 24396, 5, 95, 0, 0, + 24396, 24397, 7, 9, 0, 0, 24397, 24398, 7, 2, 0, 0, 24398, 24399, 7, 14, + 0, 0, 24399, 24400, 5, 95, 0, 0, 24400, 24401, 7, 8, 0, 0, 24401, 24402, + 7, 2, 0, 0, 24402, 24403, 7, 14, 0, 0, 24403, 24404, 7, 15, 0, 0, 24404, + 24405, 7, 0, 0, 0, 24405, 24406, 7, 3, 0, 0, 24406, 24407, 7, 6, 0, 0, + 24407, 3626, 1, 0, 0, 0, 24408, 24409, 7, 5, 0, 0, 24409, 24410, 7, 18, + 0, 0, 24410, 24411, 7, 5, 0, 0, 24411, 24412, 5, 95, 0, 0, 24412, 24413, + 7, 9, 0, 0, 24413, 24414, 7, 5, 0, 0, 24414, 24415, 7, 4, 0, 0, 24415, + 24416, 5, 95, 0, 0, 24416, 24417, 7, 15, 0, 0, 24417, 24418, 7, 3, 0, 0, + 24418, 24419, 7, 10, 0, 0, 24419, 24420, 7, 14, 0, 0, 24420, 24421, 5, + 50, 0, 0, 24421, 24422, 7, 5, 0, 0, 24422, 24423, 7, 6, 0, 0, 24423, 24424, + 7, 8, 0, 0, 24424, 3628, 1, 0, 0, 0, 24425, 24426, 7, 5, 0, 0, 24426, 24427, + 7, 18, 0, 0, 24427, 24428, 7, 5, 0, 0, 24428, 24429, 5, 95, 0, 0, 24429, + 24430, 7, 9, 0, 0, 24430, 24431, 7, 5, 0, 0, 24431, 24432, 7, 4, 0, 0, + 24432, 24433, 5, 95, 0, 0, 24433, 24434, 7, 5, 0, 0, 24434, 24435, 7, 6, + 0, 0, 24435, 24436, 7, 8, 0, 0, 24436, 24437, 5, 50, 0, 0, 24437, 24438, + 7, 15, 0, 0, 24438, 24439, 7, 3, 0, 0, 24439, 24440, 7, 10, 0, 0, 24440, + 24441, 7, 14, 0, 0, 24441, 3630, 1, 0, 0, 0, 24442, 24443, 7, 5, 0, 0, + 24443, 24444, 7, 18, 0, 0, 24444, 24445, 7, 5, 0, 0, 24445, 24446, 5, 95, + 0, 0, 24446, 24447, 7, 6, 0, 0, 24447, 24448, 7, 4, 0, 0, 24448, 24449, + 5, 95, 0, 0, 24449, 24450, 7, 1, 0, 0, 24450, 24451, 7, 16, 0, 0, 24451, + 24452, 7, 10, 0, 0, 24452, 24453, 7, 11, 0, 0, 24453, 24454, 7, 6, 0, 0, + 24454, 24455, 5, 95, 0, 0, 24455, 24456, 7, 4, 0, 0, 24456, 24457, 7, 2, + 0, 0, 24457, 24458, 5, 95, 0, 0, 24458, 24459, 7, 3, 0, 0, 24459, 24460, + 7, 0, 0, 0, 24460, 24461, 7, 22, 0, 0, 24461, 3632, 1, 0, 0, 0, 24462, + 24463, 7, 5, 0, 0, 24463, 24464, 7, 18, 0, 0, 24464, 24465, 7, 5, 0, 0, + 24465, 24466, 5, 95, 0, 0, 24466, 24467, 7, 6, 0, 0, 24467, 24468, 7, 4, + 0, 0, 24468, 24469, 5, 95, 0, 0, 24469, 24470, 7, 1, 0, 0, 24470, 24471, + 7, 11, 0, 0, 24471, 24472, 7, 2, 0, 0, 24472, 24473, 7, 1, 0, 0, 24473, + 24474, 5, 95, 0, 0, 24474, 24475, 7, 4, 0, 0, 24475, 24476, 7, 2, 0, 0, + 24476, 24477, 5, 95, 0, 0, 24477, 24478, 7, 10, 0, 0, 24478, 24479, 7, + 14, 0, 0, 24479, 24480, 7, 0, 0, 0, 24480, 24481, 7, 17, 0, 0, 24481, 24482, + 7, 6, 0, 0, 24482, 3634, 1, 0, 0, 0, 24483, 24484, 7, 5, 0, 0, 24484, 24485, + 7, 18, 0, 0, 24485, 24486, 7, 5, 0, 0, 24486, 24487, 5, 95, 0, 0, 24487, + 24488, 7, 6, 0, 0, 24488, 24489, 7, 4, 0, 0, 24489, 24490, 5, 95, 0, 0, + 24490, 24491, 7, 10, 0, 0, 24491, 24492, 7, 14, 0, 0, 24492, 24493, 7, + 0, 0, 0, 24493, 24494, 7, 17, 0, 0, 24494, 24495, 7, 6, 0, 0, 24495, 24496, + 5, 95, 0, 0, 24496, 24497, 7, 4, 0, 0, 24497, 24498, 7, 2, 0, 0, 24498, + 24499, 5, 95, 0, 0, 24499, 24500, 7, 1, 0, 0, 24500, 24501, 7, 11, 0, 0, + 24501, 24502, 7, 2, 0, 0, 24502, 24503, 7, 1, 0, 0, 24503, 3636, 1, 0, + 0, 0, 24504, 24505, 7, 5, 0, 0, 24505, 24506, 7, 18, 0, 0, 24506, 24507, + 7, 5, 0, 0, 24507, 24508, 5, 95, 0, 0, 24508, 24509, 7, 6, 0, 0, 24509, + 24510, 7, 4, 0, 0, 24510, 24511, 5, 95, 0, 0, 24511, 24512, 7, 3, 0, 0, + 24512, 24513, 7, 0, 0, 0, 24513, 24514, 7, 22, 0, 0, 24514, 24515, 5, 95, + 0, 0, 24515, 24516, 7, 4, 0, 0, 24516, 24517, 7, 2, 0, 0, 24517, 24518, + 5, 95, 0, 0, 24518, 24519, 7, 1, 0, 0, 24519, 24520, 7, 16, 0, 0, 24520, + 24521, 7, 10, 0, 0, 24521, 24522, 7, 11, 0, 0, 24522, 24523, 7, 6, 0, 0, + 24523, 3638, 1, 0, 0, 0, 24524, 24525, 7, 5, 0, 0, 24525, 24526, 7, 18, + 0, 0, 24526, 24527, 7, 5, 0, 0, 24527, 24528, 5, 95, 0, 0, 24528, 24529, + 7, 6, 0, 0, 24529, 24530, 7, 25, 0, 0, 24530, 24531, 7, 4, 0, 0, 24531, + 24532, 7, 15, 0, 0, 24532, 24533, 7, 9, 0, 0, 24533, 24534, 7, 4, 0, 0, + 24534, 24535, 7, 25, 0, 0, 24535, 24536, 7, 4, 0, 0, 24536, 3640, 1, 0, + 0, 0, 24537, 24538, 7, 5, 0, 0, 24538, 24539, 7, 18, 0, 0, 24539, 24540, + 7, 5, 0, 0, 24540, 24541, 5, 95, 0, 0, 24541, 24542, 7, 6, 0, 0, 24542, + 24543, 7, 25, 0, 0, 24543, 24544, 7, 4, 0, 0, 24544, 24545, 7, 3, 0, 0, + 24545, 24546, 7, 0, 0, 0, 24546, 24547, 7, 8, 0, 0, 24547, 24548, 7, 4, + 0, 0, 24548, 24549, 5, 95, 0, 0, 24549, 24550, 7, 12, 0, 0, 24550, 24551, + 7, 4, 0, 0, 24551, 24552, 7, 8, 0, 0, 24552, 3642, 1, 0, 0, 0, 24553, 24554, + 7, 5, 0, 0, 24554, 24555, 7, 18, 0, 0, 24555, 24556, 7, 5, 0, 0, 24556, + 24557, 5, 95, 0, 0, 24557, 24558, 7, 16, 0, 0, 24558, 24559, 7, 1, 0, 0, + 24559, 24560, 7, 4, 0, 0, 24560, 24561, 5, 95, 0, 0, 24561, 24562, 7, 10, + 0, 0, 24562, 24563, 7, 7, 0, 0, 24563, 24564, 7, 5, 0, 0, 24564, 24565, + 7, 9, 0, 0, 24565, 24566, 7, 6, 0, 0, 24566, 24567, 7, 11, 0, 0, 24567, + 3644, 1, 0, 0, 0, 24568, 24569, 7, 5, 0, 0, 24569, 24570, 7, 18, 0, 0, + 24570, 24571, 7, 5, 0, 0, 24571, 24572, 5, 95, 0, 0, 24572, 24573, 7, 16, + 0, 0, 24573, 24574, 7, 10, 0, 0, 24574, 24575, 7, 11, 0, 0, 24575, 24576, + 7, 4, 0, 0, 24576, 24577, 7, 6, 0, 0, 24577, 24578, 7, 3, 0, 0, 24578, + 24579, 5, 95, 0, 0, 24579, 24580, 7, 0, 0, 0, 24580, 24581, 7, 8, 0, 0, + 24581, 24582, 7, 11, 0, 0, 24582, 24583, 7, 5, 0, 0, 24583, 3646, 1, 0, + 0, 0, 24584, 24585, 7, 5, 0, 0, 24585, 24586, 7, 18, 0, 0, 24586, 24587, + 7, 5, 0, 0, 24587, 24588, 5, 95, 0, 0, 24588, 24589, 7, 16, 0, 0, 24589, + 24590, 7, 7, 0, 0, 24590, 24591, 7, 14, 0, 0, 24591, 24592, 7, 0, 0, 0, + 24592, 24593, 7, 4, 0, 0, 24593, 24594, 7, 8, 0, 0, 24594, 24595, 7, 19, + 0, 0, 24595, 24596, 7, 6, 0, 0, 24596, 24597, 7, 5, 0, 0, 24597, 3648, + 1, 0, 0, 0, 24598, 24599, 7, 5, 0, 0, 24599, 24600, 7, 18, 0, 0, 24600, + 24601, 7, 5, 0, 0, 24601, 24602, 5, 95, 0, 0, 24602, 24603, 7, 16, 0, 0, + 24603, 24604, 7, 7, 0, 0, 24604, 24605, 7, 3, 0, 0, 24605, 24606, 7, 6, + 0, 0, 24606, 24607, 7, 15, 0, 0, 24607, 24608, 7, 11, 0, 0, 24608, 24609, + 7, 0, 0, 0, 24609, 24610, 7, 8, 0, 0, 24610, 24611, 7, 6, 0, 0, 24611, + 3650, 1, 0, 0, 0, 24612, 24613, 7, 5, 0, 0, 24613, 24614, 7, 18, 0, 0, + 24614, 24615, 7, 5, 0, 0, 24615, 24616, 5, 95, 0, 0, 24616, 24617, 7, 17, + 0, 0, 24617, 24618, 7, 6, 0, 0, 24618, 24619, 7, 4, 0, 0, 24619, 24620, + 5, 95, 0, 0, 24620, 24621, 7, 0, 0, 0, 24621, 24622, 7, 8, 0, 0, 24622, + 24623, 7, 11, 0, 0, 24623, 24624, 7, 10, 0, 0, 24624, 24625, 7, 9, 0, 0, + 24625, 24626, 7, 5, 0, 0, 24626, 3652, 1, 0, 0, 0, 24627, 24628, 7, 5, + 0, 0, 24628, 24629, 7, 18, 0, 0, 24629, 24630, 7, 5, 0, 0, 24630, 24631, + 5, 95, 0, 0, 24631, 24632, 7, 17, 0, 0, 24632, 24633, 7, 6, 0, 0, 24633, + 24634, 7, 4, 0, 0, 24634, 24635, 5, 95, 0, 0, 24635, 24636, 7, 8, 0, 0, + 24636, 24637, 7, 2, 0, 0, 24637, 24638, 7, 11, 0, 0, 24638, 24639, 5, 95, + 0, 0, 24639, 24640, 7, 0, 0, 0, 24640, 24641, 7, 8, 0, 0, 24641, 24642, + 7, 11, 0, 0, 24642, 24643, 7, 10, 0, 0, 24643, 24644, 7, 9, 0, 0, 24644, + 24645, 7, 5, 0, 0, 24645, 3654, 1, 0, 0, 0, 24646, 24647, 7, 5, 0, 0, 24647, + 24648, 7, 18, 0, 0, 24648, 24649, 7, 5, 0, 0, 24649, 24650, 5, 95, 0, 0, + 24650, 24651, 7, 17, 0, 0, 24651, 24652, 7, 6, 0, 0, 24652, 24653, 7, 4, + 0, 0, 24653, 24654, 5, 95, 0, 0, 24654, 24655, 7, 15, 0, 0, 24655, 24656, + 7, 3, 0, 0, 24656, 24657, 7, 10, 0, 0, 24657, 24658, 7, 13, 0, 0, 24658, + 24659, 7, 10, 0, 0, 24659, 24660, 7, 11, 0, 0, 24660, 24661, 7, 6, 0, 0, + 24661, 24662, 7, 17, 0, 0, 24662, 24663, 7, 6, 0, 0, 24663, 24664, 7, 5, + 0, 0, 24664, 3656, 1, 0, 0, 0, 24665, 24666, 7, 5, 0, 0, 24666, 24667, + 7, 18, 0, 0, 24667, 24668, 7, 5, 0, 0, 24668, 24669, 5, 95, 0, 0, 24669, + 24670, 7, 17, 0, 0, 24670, 24671, 7, 6, 0, 0, 24671, 24672, 7, 4, 0, 0, + 24672, 24673, 7, 4, 0, 0, 24673, 24674, 7, 2, 0, 0, 24674, 24675, 7, 21, + 0, 0, 24675, 24676, 7, 6, 0, 0, 24676, 24677, 7, 7, 0, 0, 24677, 24678, + 7, 10, 0, 0, 24678, 24679, 7, 9, 0, 0, 24679, 3658, 1, 0, 0, 0, 24680, + 24681, 7, 5, 0, 0, 24681, 24682, 7, 18, 0, 0, 24682, 24683, 7, 5, 0, 0, + 24683, 24684, 5, 95, 0, 0, 24684, 24685, 7, 17, 0, 0, 24685, 24686, 7, + 6, 0, 0, 24686, 24687, 7, 4, 0, 0, 24687, 24688, 7, 25, 0, 0, 24688, 24689, + 7, 4, 0, 0, 24689, 24690, 7, 10, 0, 0, 24690, 24691, 7, 13, 0, 0, 24691, + 24692, 7, 0, 0, 0, 24692, 24693, 7, 11, 0, 0, 24693, 3660, 1, 0, 0, 0, + 24694, 24695, 7, 5, 0, 0, 24695, 24696, 7, 18, 0, 0, 24696, 24697, 7, 5, + 0, 0, 24697, 24698, 5, 95, 0, 0, 24698, 24699, 7, 17, 0, 0, 24699, 24700, + 7, 12, 0, 0, 24700, 24701, 7, 10, 0, 0, 24701, 24702, 7, 9, 0, 0, 24702, + 3662, 1, 0, 0, 0, 24703, 24704, 7, 5, 0, 0, 24704, 24705, 7, 18, 0, 0, + 24705, 24706, 7, 5, 0, 0, 24706, 24707, 7, 17, 0, 0, 24707, 24708, 7, 12, + 0, 0, 24708, 24709, 7, 10, 0, 0, 24709, 24710, 7, 9, 0, 0, 24710, 3664, + 1, 0, 0, 0, 24711, 24712, 7, 5, 0, 0, 24712, 24713, 7, 18, 0, 0, 24713, + 24714, 7, 5, 0, 0, 24714, 24715, 7, 21, 0, 0, 24715, 24716, 7, 14, 0, 0, + 24716, 3666, 1, 0, 0, 0, 24717, 24718, 7, 5, 0, 0, 24718, 24719, 7, 18, + 0, 0, 24719, 24720, 7, 5, 0, 0, 24720, 24721, 5, 95, 0, 0, 24721, 24722, + 7, 14, 0, 0, 24722, 24723, 7, 0, 0, 0, 24723, 24724, 7, 21, 0, 0, 24724, + 24725, 7, 6, 0, 0, 24725, 24726, 5, 95, 0, 0, 24726, 24727, 7, 25, 0, 0, + 24727, 24728, 7, 14, 0, 0, 24728, 24729, 7, 11, 0, 0, 24729, 24730, 7, + 7, 0, 0, 24730, 24731, 7, 2, 0, 0, 24731, 24732, 7, 9, 0, 0, 24732, 24733, + 7, 6, 0, 0, 24733, 24734, 7, 10, 0, 0, 24734, 24735, 7, 9, 0, 0, 24735, + 3668, 1, 0, 0, 0, 24736, 24737, 7, 5, 0, 0, 24737, 24738, 7, 18, 0, 0, + 24738, 24739, 7, 5, 0, 0, 24739, 24740, 5, 95, 0, 0, 24740, 24741, 7, 14, + 0, 0, 24741, 24742, 7, 0, 0, 0, 24742, 24743, 7, 21, 0, 0, 24743, 24744, + 7, 6, 0, 0, 24744, 24745, 7, 25, 0, 0, 24745, 24746, 7, 14, 0, 0, 24746, + 24747, 7, 11, 0, 0, 24747, 3670, 1, 0, 0, 0, 24748, 24749, 7, 5, 0, 0, + 24749, 24750, 7, 18, 0, 0, 24750, 24751, 7, 5, 0, 0, 24751, 24752, 5, 95, + 0, 0, 24752, 24753, 7, 14, 0, 0, 24753, 24754, 7, 21, 0, 0, 24754, 24755, + 7, 25, 0, 0, 24755, 24756, 7, 14, 0, 0, 24756, 24757, 7, 11, 0, 0, 24757, + 24758, 7, 0, 0, 0, 24758, 24759, 7, 4, 0, 0, 24759, 24760, 7, 4, 0, 0, + 24760, 24761, 7, 3, 0, 0, 24761, 3672, 1, 0, 0, 0, 24762, 24763, 7, 5, + 0, 0, 24763, 24764, 7, 18, 0, 0, 24764, 24765, 7, 5, 0, 0, 24765, 24766, + 5, 95, 0, 0, 24766, 24767, 7, 14, 0, 0, 24767, 24768, 7, 21, 0, 0, 24768, + 24769, 7, 25, 0, 0, 24769, 24770, 7, 4, 0, 0, 24770, 24771, 7, 10, 0, 0, + 24771, 3674, 1, 0, 0, 0, 24772, 24773, 7, 5, 0, 0, 24773, 24774, 7, 18, + 0, 0, 24774, 24775, 7, 5, 0, 0, 24775, 24776, 7, 2, 0, 0, 24776, 24777, + 7, 1, 0, 0, 24777, 24778, 7, 20, 0, 0, 24778, 3676, 1, 0, 0, 0, 24779, + 24780, 7, 5, 0, 0, 24780, 24781, 7, 18, 0, 0, 24781, 24782, 7, 5, 0, 0, + 24782, 24783, 5, 95, 0, 0, 24783, 24784, 7, 2, 0, 0, 24784, 24785, 7, 15, + 0, 0, 24785, 24786, 5, 95, 0, 0, 24786, 24787, 7, 0, 0, 0, 24787, 24788, + 7, 9, 0, 0, 24788, 24789, 7, 4, 0, 0, 24789, 24790, 5, 50, 0, 0, 24790, + 24791, 7, 1, 0, 0, 24791, 24792, 7, 10, 0, 0, 24792, 24793, 7, 7, 0, 0, + 24793, 3678, 1, 0, 0, 0, 24794, 24795, 7, 5, 0, 0, 24795, 24796, 7, 18, + 0, 0, 24796, 24797, 7, 5, 0, 0, 24797, 24798, 5, 95, 0, 0, 24798, 24799, + 7, 2, 0, 0, 24799, 24800, 7, 15, 0, 0, 24800, 24801, 5, 95, 0, 0, 24801, + 24802, 7, 0, 0, 0, 24802, 24803, 7, 9, 0, 0, 24803, 24804, 7, 4, 0, 0, + 24804, 24805, 7, 8, 0, 0, 24805, 24806, 7, 2, 0, 0, 24806, 24807, 7, 7, + 0, 0, 24807, 24808, 7, 5, 0, 0, 24808, 3680, 1, 0, 0, 0, 24809, 24810, + 7, 5, 0, 0, 24810, 24811, 7, 18, 0, 0, 24811, 24812, 7, 5, 0, 0, 24812, + 24813, 5, 95, 0, 0, 24813, 24814, 7, 2, 0, 0, 24814, 24815, 7, 15, 0, 0, + 24815, 24816, 5, 95, 0, 0, 24816, 24817, 7, 0, 0, 0, 24817, 24818, 7, 11, + 0, 0, 24818, 24819, 7, 5, 0, 0, 24819, 24820, 7, 8, 0, 0, 24820, 24821, + 7, 3, 0, 0, 24821, 24822, 7, 13, 0, 0, 24822, 24823, 7, 0, 0, 0, 24823, + 24824, 7, 11, 0, 0, 24824, 3682, 1, 0, 0, 0, 24825, 24826, 7, 5, 0, 0, + 24826, 24827, 7, 18, 0, 0, 24827, 24828, 7, 5, 0, 0, 24828, 24829, 5, 95, + 0, 0, 24829, 24830, 7, 2, 0, 0, 24830, 24831, 7, 15, 0, 0, 24831, 24832, + 5, 95, 0, 0, 24832, 24833, 7, 0, 0, 0, 24833, 24834, 7, 4, 0, 0, 24834, + 24835, 7, 17, 0, 0, 24835, 3684, 1, 0, 0, 0, 24836, 24837, 7, 5, 0, 0, + 24837, 24838, 7, 18, 0, 0, 24838, 24839, 7, 5, 0, 0, 24839, 24840, 5, 95, + 0, 0, 24840, 24841, 7, 2, 0, 0, 24841, 24842, 7, 15, 0, 0, 24842, 24843, + 5, 95, 0, 0, 24843, 24844, 7, 1, 0, 0, 24844, 24845, 7, 10, 0, 0, 24845, + 24846, 7, 7, 0, 0, 24846, 24847, 5, 50, 0, 0, 24847, 24848, 7, 0, 0, 0, + 24848, 24849, 7, 9, 0, 0, 24849, 24850, 7, 4, 0, 0, 24850, 3686, 1, 0, + 0, 0, 24851, 24852, 7, 5, 0, 0, 24852, 24853, 7, 18, 0, 0, 24853, 24854, + 7, 5, 0, 0, 24854, 24855, 5, 95, 0, 0, 24855, 24856, 7, 2, 0, 0, 24856, + 24857, 7, 15, 0, 0, 24857, 24858, 5, 95, 0, 0, 24858, 24859, 7, 1, 0, 0, + 24859, 24860, 7, 10, 0, 0, 24860, 24861, 7, 4, 0, 0, 24861, 24862, 7, 13, + 0, 0, 24862, 24863, 7, 6, 0, 0, 24863, 24864, 7, 8, 0, 0, 24864, 3688, + 1, 0, 0, 0, 24865, 24866, 7, 5, 0, 0, 24866, 24867, 7, 18, 0, 0, 24867, + 24868, 7, 5, 0, 0, 24868, 24869, 5, 95, 0, 0, 24869, 24870, 7, 2, 0, 0, + 24870, 24871, 7, 15, 0, 0, 24871, 24872, 5, 95, 0, 0, 24872, 24873, 7, + 1, 0, 0, 24873, 24874, 7, 11, 0, 0, 24874, 24875, 5, 50, 0, 0, 24875, 24876, + 7, 3, 0, 0, 24876, 3690, 1, 0, 0, 0, 24877, 24878, 7, 5, 0, 0, 24878, 24879, + 7, 18, 0, 0, 24879, 24880, 7, 5, 0, 0, 24880, 24881, 5, 95, 0, 0, 24881, + 24882, 7, 2, 0, 0, 24882, 24883, 7, 15, 0, 0, 24883, 24884, 5, 95, 0, 0, + 24884, 24885, 7, 1, 0, 0, 24885, 24886, 7, 11, 0, 0, 24886, 24887, 7, 2, + 0, 0, 24887, 24888, 7, 2, 0, 0, 24888, 24889, 7, 14, 0, 0, 24889, 24890, + 5, 95, 0, 0, 24890, 24891, 7, 16, 0, 0, 24891, 24892, 7, 10, 0, 0, 24892, + 24893, 7, 11, 0, 0, 24893, 24894, 7, 4, 0, 0, 24894, 24895, 7, 6, 0, 0, + 24895, 24896, 7, 3, 0, 0, 24896, 24897, 5, 95, 0, 0, 24897, 24898, 7, 11, + 0, 0, 24898, 24899, 7, 10, 0, 0, 24899, 24900, 7, 5, 0, 0, 24900, 24901, + 7, 4, 0, 0, 24901, 3692, 1, 0, 0, 0, 24902, 24903, 7, 5, 0, 0, 24903, 24904, + 7, 18, 0, 0, 24904, 24905, 7, 5, 0, 0, 24905, 24906, 5, 95, 0, 0, 24906, + 24907, 7, 2, 0, 0, 24907, 24908, 7, 15, 0, 0, 24908, 24909, 5, 95, 0, 0, + 24909, 24910, 7, 1, 0, 0, 24910, 24911, 7, 11, 0, 0, 24911, 24912, 7, 2, + 0, 0, 24912, 24913, 7, 2, 0, 0, 24913, 24914, 7, 14, 0, 0, 24914, 24915, + 5, 95, 0, 0, 24915, 24916, 7, 16, 0, 0, 24916, 24917, 7, 10, 0, 0, 24917, + 24918, 7, 11, 0, 0, 24918, 24919, 7, 4, 0, 0, 24919, 24920, 7, 6, 0, 0, + 24920, 24921, 7, 3, 0, 0, 24921, 3694, 1, 0, 0, 0, 24922, 24923, 7, 5, + 0, 0, 24923, 24924, 7, 18, 0, 0, 24924, 24925, 7, 5, 0, 0, 24925, 24926, + 5, 95, 0, 0, 24926, 24927, 7, 2, 0, 0, 24927, 24928, 7, 15, 0, 0, 24928, + 24929, 5, 95, 0, 0, 24929, 24930, 7, 8, 0, 0, 24930, 24931, 5, 50, 0, 0, + 24931, 24932, 7, 8, 0, 0, 24932, 3696, 1, 0, 0, 0, 24933, 24934, 7, 5, + 0, 0, 24934, 24935, 7, 18, 0, 0, 24935, 24936, 7, 5, 0, 0, 24936, 24937, + 5, 95, 0, 0, 24937, 24938, 7, 2, 0, 0, 24938, 24939, 7, 15, 0, 0, 24939, + 24940, 5, 95, 0, 0, 24940, 24941, 7, 8, 0, 0, 24941, 24942, 7, 0, 0, 0, + 24942, 24943, 7, 5, 0, 0, 24943, 24944, 7, 4, 0, 0, 24944, 3698, 1, 0, + 0, 0, 24945, 24946, 7, 5, 0, 0, 24946, 24947, 7, 18, 0, 0, 24947, 24948, + 7, 5, 0, 0, 24948, 24949, 5, 95, 0, 0, 24949, 24950, 7, 2, 0, 0, 24950, + 24951, 7, 15, 0, 0, 24951, 24952, 5, 95, 0, 0, 24952, 24953, 7, 8, 0, 0, + 24953, 24954, 7, 6, 0, 0, 24954, 24955, 7, 17, 0, 0, 24955, 3700, 1, 0, + 0, 0, 24956, 24957, 7, 5, 0, 0, 24957, 24958, 7, 18, 0, 0, 24958, 24959, + 7, 5, 0, 0, 24959, 24960, 5, 95, 0, 0, 24960, 24961, 7, 2, 0, 0, 24961, + 24962, 7, 15, 0, 0, 24962, 24963, 5, 95, 0, 0, 24963, 24964, 7, 8, 0, 0, + 24964, 24965, 7, 11, 0, 0, 24965, 24966, 5, 50, 0, 0, 24966, 24967, 7, + 8, 0, 0, 24967, 3702, 1, 0, 0, 0, 24968, 24969, 7, 5, 0, 0, 24969, 24970, + 7, 18, 0, 0, 24970, 24971, 7, 5, 0, 0, 24971, 24972, 5, 95, 0, 0, 24972, + 24973, 7, 2, 0, 0, 24973, 24974, 7, 15, 0, 0, 24974, 24975, 5, 95, 0, 0, + 24975, 24976, 7, 8, 0, 0, 24976, 24977, 7, 2, 0, 0, 24977, 24978, 7, 14, + 0, 0, 24978, 24979, 7, 1, 0, 0, 24979, 24980, 7, 10, 0, 0, 24980, 24981, + 7, 7, 0, 0, 24981, 24982, 7, 6, 0, 0, 24982, 24983, 7, 9, 0, 0, 24983, + 24984, 5, 95, 0, 0, 24984, 24985, 7, 19, 0, 0, 24985, 24986, 7, 0, 0, 0, + 24986, 24987, 7, 5, 0, 0, 24987, 24988, 7, 19, 0, 0, 24988, 3704, 1, 0, + 0, 0, 24989, 24990, 7, 5, 0, 0, 24990, 24991, 7, 18, 0, 0, 24991, 24992, + 7, 5, 0, 0, 24992, 24993, 5, 95, 0, 0, 24993, 24994, 7, 2, 0, 0, 24994, + 24995, 7, 15, 0, 0, 24995, 24996, 5, 95, 0, 0, 24996, 24997, 7, 8, 0, 0, + 24997, 24998, 7, 2, 0, 0, 24998, 24999, 7, 14, 0, 0, 24999, 25000, 7, 15, + 0, 0, 25000, 3706, 1, 0, 0, 0, 25001, 25002, 7, 5, 0, 0, 25002, 25003, + 7, 18, 0, 0, 25003, 25004, 7, 5, 0, 0, 25004, 25005, 5, 95, 0, 0, 25005, + 25006, 7, 2, 0, 0, 25006, 25007, 7, 15, 0, 0, 25007, 25008, 5, 95, 0, 0, + 25008, 25009, 7, 8, 0, 0, 25009, 25010, 7, 2, 0, 0, 25010, 25011, 7, 7, + 0, 0, 25011, 25012, 7, 13, 0, 0, 25012, 25013, 7, 6, 0, 0, 25013, 25014, + 7, 3, 0, 0, 25014, 25015, 7, 4, 0, 0, 25015, 3708, 1, 0, 0, 0, 25016, 25017, + 7, 5, 0, 0, 25017, 25018, 7, 18, 0, 0, 25018, 25019, 7, 5, 0, 0, 25019, + 25020, 5, 95, 0, 0, 25020, 25021, 7, 2, 0, 0, 25021, 25022, 7, 15, 0, 0, + 25022, 25023, 5, 95, 0, 0, 25023, 25024, 7, 8, 0, 0, 25024, 25025, 7, 2, + 0, 0, 25025, 25026, 7, 12, 0, 0, 25026, 25027, 7, 7, 0, 0, 25027, 25028, + 7, 4, 0, 0, 25028, 25029, 7, 8, 0, 0, 25029, 25030, 7, 19, 0, 0, 25030, + 25031, 7, 17, 0, 0, 25031, 3710, 1, 0, 0, 0, 25032, 25033, 7, 5, 0, 0, + 25033, 25034, 7, 18, 0, 0, 25034, 25035, 7, 5, 0, 0, 25035, 25036, 5, 95, + 0, 0, 25036, 25037, 7, 2, 0, 0, 25037, 25038, 7, 15, 0, 0, 25038, 25039, + 5, 95, 0, 0, 25039, 25040, 7, 8, 0, 0, 25040, 25041, 7, 5, 0, 0, 25041, + 25042, 7, 8, 0, 0, 25042, 25043, 7, 2, 0, 0, 25043, 25044, 7, 7, 0, 0, + 25044, 25045, 7, 13, 0, 0, 25045, 3712, 1, 0, 0, 0, 25046, 25047, 7, 5, + 0, 0, 25047, 25048, 7, 18, 0, 0, 25048, 25049, 7, 5, 0, 0, 25049, 25050, + 5, 95, 0, 0, 25050, 25051, 7, 2, 0, 0, 25051, 25052, 7, 15, 0, 0, 25052, + 25053, 5, 95, 0, 0, 25053, 25054, 7, 8, 0, 0, 25054, 25055, 7, 5, 0, 0, + 25055, 25056, 7, 8, 0, 0, 25056, 25057, 7, 2, 0, 0, 25057, 25058, 7, 7, + 0, 0, 25058, 25059, 7, 13, 0, 0, 25059, 25060, 7, 4, 0, 0, 25060, 25061, + 7, 6, 0, 0, 25061, 25062, 7, 5, 0, 0, 25062, 25063, 7, 4, 0, 0, 25063, + 3714, 1, 0, 0, 0, 25064, 25065, 7, 5, 0, 0, 25065, 25066, 7, 18, 0, 0, + 25066, 25067, 7, 5, 0, 0, 25067, 25068, 5, 95, 0, 0, 25068, 25069, 7, 2, + 0, 0, 25069, 25070, 7, 15, 0, 0, 25070, 25071, 5, 95, 0, 0, 25071, 25072, + 7, 8, 0, 0, 25072, 25073, 7, 5, 0, 0, 25073, 25074, 7, 3, 0, 0, 25074, + 3716, 1, 0, 0, 0, 25075, 25076, 7, 5, 0, 0, 25076, 25077, 7, 18, 0, 0, + 25077, 25078, 7, 5, 0, 0, 25078, 25079, 5, 95, 0, 0, 25079, 25080, 7, 2, + 0, 0, 25080, 25081, 7, 15, 0, 0, 25081, 25082, 5, 95, 0, 0, 25082, 25083, + 7, 8, 0, 0, 25083, 25084, 7, 5, 0, 0, 25084, 25085, 7, 25, 0, 0, 25085, + 25086, 5, 95, 0, 0, 25086, 25087, 7, 15, 0, 0, 25087, 25088, 7, 0, 0, 0, + 25088, 25089, 7, 4, 0, 0, 25089, 25090, 7, 8, 0, 0, 25090, 25091, 7, 19, + 0, 0, 25091, 3718, 1, 0, 0, 0, 25092, 25093, 7, 5, 0, 0, 25093, 25094, + 7, 18, 0, 0, 25094, 25095, 7, 5, 0, 0, 25095, 25096, 5, 95, 0, 0, 25096, + 25097, 7, 2, 0, 0, 25097, 25098, 7, 15, 0, 0, 25098, 25099, 5, 95, 0, 0, + 25099, 25100, 7, 8, 0, 0, 25100, 25101, 7, 18, 0, 0, 25101, 25102, 7, 8, + 0, 0, 25102, 25103, 7, 11, 0, 0, 25103, 25104, 7, 6, 0, 0, 25104, 25105, + 7, 9, 0, 0, 25105, 25106, 5, 95, 0, 0, 25106, 25107, 7, 5, 0, 0, 25107, + 25108, 7, 6, 0, 0, 25108, 25109, 7, 24, 0, 0, 25109, 3720, 1, 0, 0, 0, + 25110, 25111, 7, 5, 0, 0, 25111, 25112, 7, 18, 0, 0, 25112, 25113, 7, 5, + 0, 0, 25113, 25114, 5, 95, 0, 0, 25114, 25115, 7, 2, 0, 0, 25115, 25116, + 7, 15, 0, 0, 25116, 25117, 5, 95, 0, 0, 25117, 25118, 7, 9, 0, 0, 25118, + 25119, 7, 6, 0, 0, 25119, 25120, 7, 8, 0, 0, 25120, 25121, 7, 2, 0, 0, + 25121, 25122, 7, 14, 0, 0, 25122, 25123, 7, 15, 0, 0, 25123, 3722, 1, 0, + 0, 0, 25124, 25125, 7, 5, 0, 0, 25125, 25126, 7, 18, 0, 0, 25126, 25127, + 7, 5, 0, 0, 25127, 25128, 5, 95, 0, 0, 25128, 25129, 7, 2, 0, 0, 25129, + 25130, 7, 15, 0, 0, 25130, 25131, 5, 95, 0, 0, 25131, 25132, 7, 9, 0, 0, + 25132, 25133, 7, 6, 0, 0, 25133, 25134, 7, 5, 0, 0, 25134, 25135, 7, 8, + 0, 0, 25135, 25136, 7, 6, 0, 0, 25136, 25137, 7, 7, 0, 0, 25137, 25138, + 7, 9, 0, 0, 25138, 3724, 1, 0, 0, 0, 25139, 25140, 7, 5, 0, 0, 25140, 25141, + 7, 18, 0, 0, 25141, 25142, 7, 5, 0, 0, 25142, 25143, 5, 95, 0, 0, 25143, + 25144, 7, 2, 0, 0, 25144, 25145, 7, 15, 0, 0, 25145, 25146, 5, 95, 0, 0, + 25146, 25147, 7, 9, 0, 0, 25147, 25148, 7, 10, 0, 0, 25148, 25149, 7, 5, + 0, 0, 25149, 25150, 7, 4, 0, 0, 25150, 25151, 7, 10, 0, 0, 25151, 25152, + 7, 7, 0, 0, 25152, 25153, 7, 8, 0, 0, 25153, 25154, 7, 4, 0, 0, 25154, + 3726, 1, 0, 0, 0, 25155, 25156, 7, 5, 0, 0, 25156, 25157, 7, 18, 0, 0, + 25157, 25158, 7, 5, 0, 0, 25158, 25159, 5, 95, 0, 0, 25159, 25160, 7, 2, + 0, 0, 25160, 25161, 7, 15, 0, 0, 25161, 25162, 5, 95, 0, 0, 25162, 25163, + 7, 9, 0, 0, 25163, 25164, 7, 3, 0, 0, 25164, 25165, 7, 0, 0, 0, 25165, + 3728, 1, 0, 0, 0, 25166, 25167, 7, 5, 0, 0, 25167, 25168, 7, 18, 0, 0, + 25168, 25169, 7, 5, 0, 0, 25169, 25170, 5, 95, 0, 0, 25170, 25171, 7, 2, + 0, 0, 25171, 25172, 7, 15, 0, 0, 25172, 25173, 5, 95, 0, 0, 25173, 25174, + 7, 9, 0, 0, 25174, 25175, 7, 12, 0, 0, 25175, 25176, 7, 14, 0, 0, 25176, + 25177, 7, 15, 0, 0, 25177, 3730, 1, 0, 0, 0, 25178, 25179, 7, 5, 0, 0, + 25179, 25180, 7, 18, 0, 0, 25180, 25181, 7, 5, 0, 0, 25181, 25182, 5, 95, + 0, 0, 25182, 25183, 7, 2, 0, 0, 25183, 25184, 7, 15, 0, 0, 25184, 25185, + 5, 95, 0, 0, 25185, 25186, 7, 9, 0, 0, 25186, 25187, 7, 13, 0, 0, 25187, + 25188, 5, 95, 0, 0, 25188, 25189, 7, 8, 0, 0, 25189, 25190, 7, 19, 0, 0, + 25190, 25191, 7, 6, 0, 0, 25191, 25192, 7, 8, 0, 0, 25192, 25193, 7, 21, + 0, 0, 25193, 3732, 1, 0, 0, 0, 25194, 25195, 7, 5, 0, 0, 25195, 25196, + 7, 18, 0, 0, 25196, 25197, 7, 5, 0, 0, 25197, 25198, 5, 95, 0, 0, 25198, + 25199, 7, 2, 0, 0, 25199, 25200, 7, 15, 0, 0, 25200, 25201, 5, 95, 0, 0, + 25201, 25202, 7, 6, 0, 0, 25202, 25203, 7, 7, 0, 0, 25203, 25204, 7, 16, + 0, 0, 25204, 25205, 7, 2, 0, 0, 25205, 25206, 7, 3, 0, 0, 25206, 25207, + 7, 8, 0, 0, 25207, 25208, 7, 6, 0, 0, 25208, 25209, 5, 95, 0, 0, 25209, + 25210, 7, 7, 0, 0, 25210, 25211, 7, 2, 0, 0, 25211, 25212, 7, 4, 0, 0, + 25212, 25213, 5, 95, 0, 0, 25213, 25214, 7, 7, 0, 0, 25214, 25215, 7, 12, + 0, 0, 25215, 25216, 7, 11, 0, 0, 25216, 25217, 7, 11, 0, 0, 25217, 25218, + 5, 36, 0, 0, 25218, 3734, 1, 0, 0, 0, 25219, 25220, 7, 5, 0, 0, 25220, + 25221, 7, 18, 0, 0, 25221, 25222, 7, 5, 0, 0, 25222, 25223, 7, 2, 0, 0, + 25223, 25224, 7, 15, 0, 0, 25224, 25225, 7, 6, 0, 0, 25225, 25226, 7, 3, + 0, 0, 25226, 3736, 1, 0, 0, 0, 25227, 25228, 7, 5, 0, 0, 25228, 25229, + 7, 18, 0, 0, 25229, 25230, 7, 5, 0, 0, 25230, 25231, 5, 95, 0, 0, 25231, + 25232, 7, 2, 0, 0, 25232, 25233, 7, 15, 0, 0, 25233, 25234, 5, 95, 0, 0, + 25234, 25235, 7, 6, 0, 0, 25235, 25236, 7, 25, 0, 0, 25236, 25237, 7, 4, + 0, 0, 25237, 25238, 7, 3, 0, 0, 25238, 25239, 7, 0, 0, 0, 25239, 25240, + 7, 8, 0, 0, 25240, 25241, 7, 4, 0, 0, 25241, 3738, 1, 0, 0, 0, 25242, 25243, + 7, 5, 0, 0, 25243, 25244, 7, 18, 0, 0, 25244, 25245, 7, 5, 0, 0, 25245, + 25246, 5, 95, 0, 0, 25246, 25247, 7, 2, 0, 0, 25247, 25248, 7, 15, 0, 0, + 25248, 25249, 5, 95, 0, 0, 25249, 25250, 7, 17, 0, 0, 25250, 25251, 7, + 3, 0, 0, 25251, 25252, 7, 2, 0, 0, 25252, 25253, 7, 12, 0, 0, 25253, 25254, + 7, 15, 0, 0, 25254, 25255, 7, 10, 0, 0, 25255, 25256, 7, 7, 0, 0, 25256, + 25257, 7, 17, 0, 0, 25257, 3740, 1, 0, 0, 0, 25258, 25259, 7, 5, 0, 0, + 25259, 25260, 7, 18, 0, 0, 25260, 25261, 7, 5, 0, 0, 25261, 25262, 5, 95, + 0, 0, 25262, 25263, 7, 2, 0, 0, 25263, 25264, 7, 15, 0, 0, 25264, 25265, + 5, 95, 0, 0, 25265, 25266, 7, 17, 0, 0, 25266, 25267, 7, 12, 0, 0, 25267, + 25268, 7, 10, 0, 0, 25268, 25269, 7, 9, 0, 0, 25269, 3742, 1, 0, 0, 0, + 25270, 25271, 7, 5, 0, 0, 25271, 25272, 7, 18, 0, 0, 25272, 25273, 7, 5, + 0, 0, 25273, 25274, 5, 95, 0, 0, 25274, 25275, 7, 2, 0, 0, 25275, 25276, + 7, 15, 0, 0, 25276, 25277, 5, 95, 0, 0, 25277, 25278, 7, 19, 0, 0, 25278, + 25279, 7, 0, 0, 0, 25279, 25280, 7, 5, 0, 0, 25280, 25281, 7, 19, 0, 0, + 25281, 3744, 1, 0, 0, 0, 25282, 25283, 7, 5, 0, 0, 25283, 25284, 7, 18, + 0, 0, 25284, 25285, 7, 5, 0, 0, 25285, 25286, 5, 95, 0, 0, 25286, 25287, + 7, 2, 0, 0, 25287, 25288, 7, 15, 0, 0, 25288, 25289, 5, 95, 0, 0, 25289, + 25290, 7, 10, 0, 0, 25290, 25291, 7, 10, 0, 0, 25291, 25292, 7, 25, 0, + 0, 25292, 3746, 1, 0, 0, 0, 25293, 25294, 7, 5, 0, 0, 25294, 25295, 7, + 18, 0, 0, 25295, 25296, 7, 5, 0, 0, 25296, 25297, 5, 95, 0, 0, 25297, 25298, + 7, 2, 0, 0, 25298, 25299, 7, 15, 0, 0, 25299, 25300, 5, 95, 0, 0, 25300, + 25301, 7, 10, 0, 0, 25301, 25302, 7, 4, 0, 0, 25302, 25303, 7, 3, 0, 0, + 25303, 3748, 1, 0, 0, 0, 25304, 25305, 7, 5, 0, 0, 25305, 25306, 7, 18, + 0, 0, 25306, 25307, 7, 5, 0, 0, 25307, 25308, 5, 95, 0, 0, 25308, 25309, + 7, 2, 0, 0, 25309, 25310, 7, 15, 0, 0, 25310, 25311, 5, 95, 0, 0, 25311, + 25312, 7, 21, 0, 0, 25312, 25313, 7, 6, 0, 0, 25313, 25314, 7, 18, 0, 0, + 25314, 25315, 5, 95, 0, 0, 25315, 25316, 7, 13, 0, 0, 25316, 25317, 7, + 6, 0, 0, 25317, 25318, 7, 8, 0, 0, 25318, 25319, 7, 4, 0, 0, 25319, 25320, + 7, 2, 0, 0, 25320, 25321, 7, 3, 0, 0, 25321, 25322, 5, 95, 0, 0, 25322, + 25323, 7, 8, 0, 0, 25323, 25324, 7, 3, 0, 0, 25324, 25325, 7, 6, 0, 0, + 25325, 25326, 7, 0, 0, 0, 25326, 25327, 7, 4, 0, 0, 25327, 25328, 7, 6, + 0, 0, 25328, 3750, 1, 0, 0, 0, 25329, 25330, 7, 5, 0, 0, 25330, 25331, + 7, 18, 0, 0, 25331, 25332, 7, 5, 0, 0, 25332, 25333, 5, 95, 0, 0, 25333, + 25334, 7, 2, 0, 0, 25334, 25335, 7, 15, 0, 0, 25335, 25336, 5, 95, 0, 0, + 25336, 25337, 7, 21, 0, 0, 25337, 25338, 7, 6, 0, 0, 25338, 25339, 7, 18, + 0, 0, 25339, 25340, 5, 95, 0, 0, 25340, 25341, 7, 13, 0, 0, 25341, 25342, + 7, 6, 0, 0, 25342, 25343, 7, 8, 0, 0, 25343, 25344, 7, 4, 0, 0, 25344, + 25345, 7, 2, 0, 0, 25345, 25346, 7, 3, 0, 0, 25346, 25347, 5, 95, 0, 0, + 25347, 25348, 7, 16, 0, 0, 25348, 25349, 7, 10, 0, 0, 25349, 25350, 7, + 11, 0, 0, 25350, 25351, 7, 4, 0, 0, 25351, 25352, 7, 6, 0, 0, 25352, 25353, + 7, 3, 0, 0, 25353, 25354, 5, 95, 0, 0, 25354, 25355, 7, 11, 0, 0, 25355, + 25356, 7, 10, 0, 0, 25356, 25357, 7, 5, 0, 0, 25357, 25358, 7, 4, 0, 0, + 25358, 3752, 1, 0, 0, 0, 25359, 25360, 7, 5, 0, 0, 25360, 25361, 7, 18, + 0, 0, 25361, 25362, 7, 5, 0, 0, 25362, 25363, 5, 95, 0, 0, 25363, 25364, + 7, 2, 0, 0, 25364, 25365, 7, 15, 0, 0, 25365, 25366, 5, 95, 0, 0, 25366, + 25367, 7, 21, 0, 0, 25367, 25368, 7, 6, 0, 0, 25368, 25369, 7, 18, 0, 0, + 25369, 25370, 5, 95, 0, 0, 25370, 25371, 7, 13, 0, 0, 25371, 25372, 7, + 6, 0, 0, 25372, 25373, 7, 8, 0, 0, 25373, 25374, 7, 4, 0, 0, 25374, 25375, + 7, 2, 0, 0, 25375, 25376, 7, 3, 0, 0, 25376, 25377, 5, 95, 0, 0, 25377, + 25378, 7, 16, 0, 0, 25378, 25379, 7, 10, 0, 0, 25379, 25380, 7, 11, 0, + 0, 25380, 25381, 7, 4, 0, 0, 25381, 25382, 7, 6, 0, 0, 25382, 25383, 7, + 3, 0, 0, 25383, 3754, 1, 0, 0, 0, 25384, 25385, 7, 5, 0, 0, 25385, 25386, + 7, 18, 0, 0, 25386, 25387, 7, 5, 0, 0, 25387, 25388, 5, 95, 0, 0, 25388, + 25389, 7, 2, 0, 0, 25389, 25390, 7, 15, 0, 0, 25390, 25391, 5, 95, 0, 0, + 25391, 25392, 7, 21, 0, 0, 25392, 25393, 7, 6, 0, 0, 25393, 25394, 7, 18, + 0, 0, 25394, 25395, 5, 95, 0, 0, 25395, 25396, 7, 13, 0, 0, 25396, 25397, + 7, 6, 0, 0, 25397, 25398, 7, 8, 0, 0, 25398, 25399, 7, 4, 0, 0, 25399, + 25400, 7, 2, 0, 0, 25400, 25401, 7, 3, 0, 0, 25401, 25402, 5, 95, 0, 0, + 25402, 25403, 7, 5, 0, 0, 25403, 25404, 7, 12, 0, 0, 25404, 25405, 7, 8, + 0, 0, 25405, 25406, 7, 8, 0, 0, 25406, 25407, 7, 6, 0, 0, 25407, 25408, + 7, 6, 0, 0, 25408, 25409, 7, 9, 0, 0, 25409, 25410, 7, 6, 0, 0, 25410, + 25411, 7, 9, 0, 0, 25411, 3756, 1, 0, 0, 0, 25412, 25413, 7, 5, 0, 0, 25413, + 25414, 7, 18, 0, 0, 25414, 25415, 7, 5, 0, 0, 25415, 25416, 5, 95, 0, 0, + 25416, 25417, 7, 2, 0, 0, 25417, 25418, 7, 15, 0, 0, 25418, 25419, 5, 95, + 0, 0, 25419, 25420, 7, 21, 0, 0, 25420, 25421, 7, 6, 0, 0, 25421, 25422, + 7, 18, 0, 0, 25422, 25423, 5, 95, 0, 0, 25423, 25424, 7, 13, 0, 0, 25424, + 25425, 7, 6, 0, 0, 25425, 25426, 7, 8, 0, 0, 25426, 25427, 7, 4, 0, 0, + 25427, 25428, 7, 2, 0, 0, 25428, 25429, 7, 3, 0, 0, 25429, 25430, 5, 95, + 0, 0, 25430, 25431, 7, 12, 0, 0, 25431, 25432, 7, 5, 0, 0, 25432, 25433, + 7, 6, 0, 0, 25433, 3758, 1, 0, 0, 0, 25434, 25435, 7, 5, 0, 0, 25435, 25436, + 7, 18, 0, 0, 25436, 25437, 7, 5, 0, 0, 25437, 25438, 5, 95, 0, 0, 25438, + 25439, 7, 2, 0, 0, 25439, 25440, 7, 15, 0, 0, 25440, 25441, 5, 95, 0, 0, + 25441, 25442, 7, 11, 0, 0, 25442, 25443, 7, 1, 0, 0, 25443, 25444, 7, 10, + 0, 0, 25444, 25445, 7, 9, 0, 0, 25445, 3760, 1, 0, 0, 0, 25446, 25447, + 7, 5, 0, 0, 25447, 25448, 7, 18, 0, 0, 25448, 25449, 7, 5, 0, 0, 25449, + 25450, 5, 95, 0, 0, 25450, 25451, 7, 2, 0, 0, 25451, 25452, 7, 15, 0, 0, + 25452, 25453, 5, 95, 0, 0, 25453, 25454, 7, 11, 0, 0, 25454, 25455, 7, + 2, 0, 0, 25455, 25456, 7, 1, 0, 0, 25456, 25457, 7, 11, 0, 0, 25457, 25458, + 7, 2, 0, 0, 25458, 25459, 7, 8, 0, 0, 25459, 25460, 5, 50, 0, 0, 25460, + 25461, 7, 1, 0, 0, 25461, 25462, 7, 11, 0, 0, 25462, 25463, 7, 2, 0, 0, + 25463, 25464, 7, 1, 0, 0, 25464, 3762, 1, 0, 0, 0, 25465, 25466, 7, 5, + 0, 0, 25466, 25467, 7, 18, 0, 0, 25467, 25468, 7, 5, 0, 0, 25468, 25469, + 5, 95, 0, 0, 25469, 25470, 7, 2, 0, 0, 25470, 25471, 7, 15, 0, 0, 25471, + 25472, 5, 95, 0, 0, 25472, 25473, 7, 11, 0, 0, 25473, 25474, 7, 2, 0, 0, + 25474, 25475, 7, 1, 0, 0, 25475, 25476, 7, 11, 0, 0, 25476, 25477, 7, 2, + 0, 0, 25477, 25478, 7, 8, 0, 0, 25478, 25479, 5, 50, 0, 0, 25479, 25480, + 7, 8, 0, 0, 25480, 25481, 7, 11, 0, 0, 25481, 25482, 7, 2, 0, 0, 25482, + 25483, 7, 1, 0, 0, 25483, 3764, 1, 0, 0, 0, 25484, 25485, 7, 5, 0, 0, 25485, + 25486, 7, 18, 0, 0, 25486, 25487, 7, 5, 0, 0, 25487, 25488, 5, 95, 0, 0, + 25488, 25489, 7, 2, 0, 0, 25489, 25490, 7, 15, 0, 0, 25490, 25491, 5, 95, + 0, 0, 25491, 25492, 7, 11, 0, 0, 25492, 25493, 7, 2, 0, 0, 25493, 25494, + 7, 1, 0, 0, 25494, 25495, 7, 11, 0, 0, 25495, 25496, 7, 2, 0, 0, 25496, + 25497, 7, 8, 0, 0, 25497, 25498, 5, 50, 0, 0, 25498, 25499, 7, 10, 0, 0, + 25499, 25500, 7, 9, 0, 0, 25500, 3766, 1, 0, 0, 0, 25501, 25502, 7, 5, + 0, 0, 25502, 25503, 7, 18, 0, 0, 25503, 25504, 7, 5, 0, 0, 25504, 25505, + 5, 95, 0, 0, 25505, 25506, 7, 2, 0, 0, 25506, 25507, 7, 15, 0, 0, 25507, + 25508, 5, 95, 0, 0, 25508, 25509, 7, 11, 0, 0, 25509, 25510, 7, 2, 0, 0, + 25510, 25511, 7, 1, 0, 0, 25511, 25512, 7, 11, 0, 0, 25512, 25513, 7, 2, + 0, 0, 25513, 25514, 7, 8, 0, 0, 25514, 25515, 5, 50, 0, 0, 25515, 25516, + 7, 7, 0, 0, 25516, 25517, 7, 8, 0, 0, 25517, 25518, 7, 11, 0, 0, 25518, + 25519, 7, 2, 0, 0, 25519, 25520, 7, 1, 0, 0, 25520, 3768, 1, 0, 0, 0, 25521, + 25522, 7, 5, 0, 0, 25522, 25523, 7, 18, 0, 0, 25523, 25524, 7, 5, 0, 0, + 25524, 25525, 5, 95, 0, 0, 25525, 25526, 7, 2, 0, 0, 25526, 25527, 7, 15, + 0, 0, 25527, 25528, 5, 95, 0, 0, 25528, 25529, 7, 11, 0, 0, 25529, 25530, + 7, 2, 0, 0, 25530, 25531, 7, 1, 0, 0, 25531, 25532, 7, 11, 0, 0, 25532, + 25533, 7, 2, 0, 0, 25533, 25534, 7, 8, 0, 0, 25534, 25535, 5, 50, 0, 0, + 25535, 25536, 7, 4, 0, 0, 25536, 25537, 7, 18, 0, 0, 25537, 25538, 7, 15, + 0, 0, 25538, 3770, 1, 0, 0, 0, 25539, 25540, 7, 5, 0, 0, 25540, 25541, + 7, 18, 0, 0, 25541, 25542, 7, 5, 0, 0, 25542, 25543, 5, 95, 0, 0, 25543, + 25544, 7, 2, 0, 0, 25544, 25545, 7, 15, 0, 0, 25545, 25546, 5, 95, 0, 0, + 25546, 25547, 7, 11, 0, 0, 25547, 25548, 7, 5, 0, 0, 25548, 25549, 7, 13, + 0, 0, 25549, 25550, 7, 10, 0, 0, 25550, 3772, 1, 0, 0, 0, 25551, 25552, + 7, 5, 0, 0, 25552, 25553, 7, 18, 0, 0, 25553, 25554, 7, 5, 0, 0, 25554, + 25555, 5, 95, 0, 0, 25555, 25556, 7, 2, 0, 0, 25556, 25557, 7, 15, 0, 0, + 25557, 25558, 5, 95, 0, 0, 25558, 25559, 7, 11, 0, 0, 25559, 25560, 7, + 13, 0, 0, 25560, 25561, 7, 11, 0, 0, 25561, 3774, 1, 0, 0, 0, 25562, 25563, + 7, 5, 0, 0, 25563, 25564, 7, 18, 0, 0, 25564, 25565, 7, 5, 0, 0, 25565, + 25566, 5, 95, 0, 0, 25566, 25567, 7, 2, 0, 0, 25567, 25568, 7, 15, 0, 0, + 25568, 25569, 5, 95, 0, 0, 25569, 25570, 7, 14, 0, 0, 25570, 25571, 7, + 0, 0, 0, 25571, 25572, 7, 21, 0, 0, 25572, 25573, 7, 6, 0, 0, 25573, 25574, + 7, 2, 0, 0, 25574, 25575, 7, 10, 0, 0, 25575, 25576, 7, 9, 0, 0, 25576, + 3776, 1, 0, 0, 0, 25577, 25578, 7, 5, 0, 0, 25578, 25579, 7, 18, 0, 0, + 25579, 25580, 7, 5, 0, 0, 25580, 25581, 5, 95, 0, 0, 25581, 25582, 7, 2, + 0, 0, 25582, 25583, 7, 15, 0, 0, 25583, 25584, 5, 95, 0, 0, 25584, 25585, + 7, 14, 0, 0, 25585, 25586, 7, 0, 0, 0, 25586, 25587, 7, 15, 0, 0, 25587, + 25588, 5, 95, 0, 0, 25588, 25589, 7, 7, 0, 0, 25589, 25590, 7, 2, 0, 0, + 25590, 25591, 7, 7, 0, 0, 25591, 25592, 7, 7, 0, 0, 25592, 25593, 7, 12, + 0, 0, 25593, 25594, 7, 11, 0, 0, 25594, 25595, 7, 11, 0, 0, 25595, 3778, + 1, 0, 0, 0, 25596, 25597, 7, 5, 0, 0, 25597, 25598, 7, 18, 0, 0, 25598, + 25599, 7, 5, 0, 0, 25599, 25600, 5, 95, 0, 0, 25600, 25601, 7, 2, 0, 0, + 25601, 25602, 7, 15, 0, 0, 25602, 25603, 5, 95, 0, 0, 25603, 25604, 7, + 14, 0, 0, 25604, 25605, 7, 5, 0, 0, 25605, 25606, 7, 3, 0, 0, 25606, 3780, + 1, 0, 0, 0, 25607, 25608, 7, 5, 0, 0, 25608, 25609, 7, 18, 0, 0, 25609, + 25610, 7, 5, 0, 0, 25610, 25611, 5, 95, 0, 0, 25611, 25612, 7, 2, 0, 0, + 25612, 25613, 7, 15, 0, 0, 25613, 25614, 5, 95, 0, 0, 25614, 25615, 7, + 7, 0, 0, 25615, 25616, 7, 10, 0, 0, 25616, 25617, 7, 8, 0, 0, 25617, 25618, + 7, 2, 0, 0, 25618, 25619, 7, 14, 0, 0, 25619, 25620, 7, 1, 0, 0, 25620, + 25621, 7, 10, 0, 0, 25621, 25622, 7, 7, 0, 0, 25622, 25623, 7, 6, 0, 0, + 25623, 3782, 1, 0, 0, 0, 25624, 25625, 7, 5, 0, 0, 25625, 25626, 7, 18, + 0, 0, 25626, 25627, 7, 5, 0, 0, 25627, 25628, 5, 95, 0, 0, 25628, 25629, + 7, 2, 0, 0, 25629, 25630, 7, 15, 0, 0, 25630, 25631, 5, 95, 0, 0, 25631, + 25632, 7, 7, 0, 0, 25632, 25633, 7, 10, 0, 0, 25633, 25634, 7, 6, 0, 0, + 25634, 25635, 7, 25, 0, 0, 25635, 25636, 7, 4, 0, 0, 25636, 25637, 7, 3, + 0, 0, 25637, 25638, 7, 0, 0, 0, 25638, 25639, 7, 8, 0, 0, 25639, 25640, + 7, 4, 0, 0, 25640, 3784, 1, 0, 0, 0, 25641, 25642, 7, 5, 0, 0, 25642, 25643, + 7, 18, 0, 0, 25643, 25644, 7, 5, 0, 0, 25644, 25645, 5, 95, 0, 0, 25645, + 25646, 7, 2, 0, 0, 25646, 25647, 7, 15, 0, 0, 25647, 25648, 5, 95, 0, 0, + 25648, 25649, 7, 7, 0, 0, 25649, 25650, 7, 10, 0, 0, 25650, 25651, 7, 10, + 0, 0, 25651, 3786, 1, 0, 0, 0, 25652, 25653, 7, 5, 0, 0, 25653, 25654, + 7, 18, 0, 0, 25654, 25655, 7, 5, 0, 0, 25655, 25656, 5, 95, 0, 0, 25656, + 25657, 7, 2, 0, 0, 25657, 25658, 7, 15, 0, 0, 25658, 25659, 5, 95, 0, 0, + 25659, 25660, 7, 7, 0, 0, 25660, 25661, 7, 10, 0, 0, 25661, 25662, 7, 25, + 0, 0, 25662, 3788, 1, 0, 0, 0, 25663, 25664, 7, 5, 0, 0, 25664, 25665, + 7, 18, 0, 0, 25665, 25666, 7, 5, 0, 0, 25666, 25667, 5, 95, 0, 0, 25667, + 25668, 7, 2, 0, 0, 25668, 25669, 7, 15, 0, 0, 25669, 25670, 5, 95, 0, 0, + 25670, 25671, 7, 7, 0, 0, 25671, 25672, 7, 2, 0, 0, 25672, 25673, 7, 6, + 0, 0, 25673, 25674, 7, 25, 0, 0, 25674, 25675, 7, 15, 0, 0, 25675, 25676, + 7, 0, 0, 0, 25676, 25677, 7, 7, 0, 0, 25677, 25678, 7, 9, 0, 0, 25678, + 3790, 1, 0, 0, 0, 25679, 25680, 7, 5, 0, 0, 25680, 25681, 7, 18, 0, 0, + 25681, 25682, 7, 5, 0, 0, 25682, 25683, 5, 95, 0, 0, 25683, 25684, 7, 2, + 0, 0, 25684, 25685, 7, 15, 0, 0, 25685, 25686, 5, 95, 0, 0, 25686, 25687, + 7, 7, 0, 0, 25687, 25688, 7, 4, 0, 0, 25688, 25689, 7, 8, 0, 0, 25689, + 25690, 7, 10, 0, 0, 25690, 25691, 7, 14, 0, 0, 25691, 25692, 7, 17, 0, + 0, 25692, 25693, 5, 36, 0, 0, 25693, 3792, 1, 0, 0, 0, 25694, 25695, 7, + 5, 0, 0, 25695, 25696, 7, 18, 0, 0, 25696, 25697, 7, 5, 0, 0, 25697, 25698, + 5, 95, 0, 0, 25698, 25699, 7, 2, 0, 0, 25699, 25700, 7, 15, 0, 0, 25700, + 25701, 5, 95, 0, 0, 25701, 25702, 7, 7, 0, 0, 25702, 25703, 7, 12, 0, 0, + 25703, 25704, 7, 14, 0, 0, 25704, 25705, 7, 4, 0, 0, 25705, 25706, 7, 2, + 0, 0, 25706, 25707, 7, 3, 0, 0, 25707, 25708, 7, 0, 0, 0, 25708, 25709, + 7, 22, 0, 0, 25709, 3794, 1, 0, 0, 0, 25710, 25711, 7, 5, 0, 0, 25711, + 25712, 7, 18, 0, 0, 25712, 25713, 7, 5, 0, 0, 25713, 25714, 5, 95, 0, 0, + 25714, 25715, 7, 2, 0, 0, 25715, 25716, 7, 15, 0, 0, 25716, 25717, 5, 95, + 0, 0, 25717, 25718, 7, 2, 0, 0, 25718, 25719, 7, 10, 0, 0, 25719, 25720, + 7, 9, 0, 0, 25720, 25721, 7, 13, 0, 0, 25721, 25722, 7, 0, 0, 0, 25722, + 25723, 7, 11, 0, 0, 25723, 25724, 7, 12, 0, 0, 25724, 25725, 7, 6, 0, 0, + 25725, 3796, 1, 0, 0, 0, 25726, 25727, 7, 5, 0, 0, 25727, 25728, 7, 18, + 0, 0, 25728, 25729, 7, 5, 0, 0, 25729, 25730, 5, 95, 0, 0, 25730, 25731, + 7, 2, 0, 0, 25731, 25732, 7, 15, 0, 0, 25732, 25733, 5, 95, 0, 0, 25733, + 25734, 7, 2, 0, 0, 25734, 25735, 7, 15, 0, 0, 25735, 25736, 7, 7, 0, 0, + 25736, 25737, 7, 5, 0, 0, 25737, 25738, 7, 10, 0, 0, 25738, 25739, 7, 23, + 0, 0, 25739, 25740, 7, 6, 0, 0, 25740, 3798, 1, 0, 0, 0, 25741, 25742, + 7, 5, 0, 0, 25742, 25743, 7, 18, 0, 0, 25743, 25744, 7, 5, 0, 0, 25744, + 25745, 5, 95, 0, 0, 25745, 25746, 7, 2, 0, 0, 25746, 25747, 7, 15, 0, 0, + 25747, 25748, 5, 95, 0, 0, 25748, 25749, 7, 15, 0, 0, 25749, 25750, 7, + 0, 0, 0, 25750, 25751, 7, 3, 0, 0, 25751, 25752, 5, 95, 0, 0, 25752, 25753, + 5, 49, 0, 0, 25753, 3800, 1, 0, 0, 0, 25754, 25755, 7, 5, 0, 0, 25755, + 25756, 7, 18, 0, 0, 25756, 25757, 7, 5, 0, 0, 25757, 25758, 5, 95, 0, 0, + 25758, 25759, 7, 2, 0, 0, 25759, 25760, 7, 15, 0, 0, 25760, 25761, 5, 95, + 0, 0, 25761, 25762, 7, 15, 0, 0, 25762, 25763, 7, 0, 0, 0, 25763, 25764, + 7, 3, 0, 0, 25764, 25765, 7, 17, 0, 0, 25765, 25766, 7, 10, 0, 0, 25766, + 25767, 7, 9, 0, 0, 25767, 25768, 5, 95, 0, 0, 25768, 25769, 5, 49, 0, 0, + 25769, 3802, 1, 0, 0, 0, 25770, 25771, 7, 5, 0, 0, 25771, 25772, 7, 18, + 0, 0, 25772, 25773, 7, 5, 0, 0, 25773, 25774, 5, 95, 0, 0, 25774, 25775, + 7, 2, 0, 0, 25775, 25776, 7, 15, 0, 0, 25776, 25777, 5, 95, 0, 0, 25777, + 25778, 7, 15, 0, 0, 25778, 25779, 7, 0, 0, 0, 25779, 25780, 7, 3, 0, 0, + 25780, 25781, 7, 17, 0, 0, 25781, 25782, 7, 10, 0, 0, 25782, 25783, 7, + 9, 0, 0, 25783, 3804, 1, 0, 0, 0, 25784, 25785, 7, 5, 0, 0, 25785, 25786, + 7, 18, 0, 0, 25786, 25787, 7, 5, 0, 0, 25787, 25788, 5, 95, 0, 0, 25788, + 25789, 7, 2, 0, 0, 25789, 25790, 7, 15, 0, 0, 25790, 25791, 5, 95, 0, 0, + 25791, 25792, 7, 15, 0, 0, 25792, 25793, 7, 0, 0, 0, 25793, 25794, 7, 3, + 0, 0, 25794, 3806, 1, 0, 0, 0, 25795, 25796, 7, 5, 0, 0, 25796, 25797, + 7, 18, 0, 0, 25797, 25798, 7, 5, 0, 0, 25798, 25799, 5, 95, 0, 0, 25799, + 25800, 7, 2, 0, 0, 25800, 25801, 7, 15, 0, 0, 25801, 25802, 5, 95, 0, 0, + 25802, 25803, 7, 15, 0, 0, 25803, 25804, 7, 0, 0, 0, 25804, 25805, 7, 3, + 0, 0, 25805, 25806, 7, 4, 0, 0, 25806, 25807, 5, 95, 0, 0, 25807, 25808, + 7, 10, 0, 0, 25808, 25809, 7, 9, 0, 0, 25809, 3808, 1, 0, 0, 0, 25810, + 25811, 7, 5, 0, 0, 25811, 25812, 7, 18, 0, 0, 25812, 25813, 7, 5, 0, 0, + 25813, 25814, 5, 95, 0, 0, 25814, 25815, 7, 2, 0, 0, 25815, 25816, 7, 15, + 0, 0, 25816, 25817, 5, 95, 0, 0, 25817, 25818, 7, 15, 0, 0, 25818, 25819, + 7, 10, 0, 0, 25819, 25820, 7, 13, 0, 0, 25820, 25821, 7, 2, 0, 0, 25821, + 25822, 7, 4, 0, 0, 25822, 3810, 1, 0, 0, 0, 25823, 25824, 7, 5, 0, 0, 25824, + 25825, 7, 18, 0, 0, 25825, 25826, 7, 5, 0, 0, 25826, 25827, 5, 95, 0, 0, + 25827, 25828, 7, 2, 0, 0, 25828, 25829, 7, 15, 0, 0, 25829, 25830, 5, 95, + 0, 0, 25830, 25831, 7, 3, 0, 0, 25831, 25832, 5, 50, 0, 0, 25832, 25833, + 7, 2, 0, 0, 25833, 3812, 1, 0, 0, 0, 25834, 25835, 7, 5, 0, 0, 25835, 25836, + 7, 18, 0, 0, 25836, 25837, 7, 5, 0, 0, 25837, 25838, 5, 95, 0, 0, 25838, + 25839, 7, 2, 0, 0, 25839, 25840, 7, 15, 0, 0, 25840, 25841, 5, 95, 0, 0, + 25841, 25842, 7, 3, 0, 0, 25842, 25843, 7, 0, 0, 0, 25843, 25844, 7, 22, + 0, 0, 25844, 25845, 7, 4, 0, 0, 25845, 25846, 7, 2, 0, 0, 25846, 25847, + 7, 7, 0, 0, 25847, 25848, 7, 12, 0, 0, 25848, 25849, 7, 14, 0, 0, 25849, + 3814, 1, 0, 0, 0, 25850, 25851, 7, 5, 0, 0, 25851, 25852, 7, 18, 0, 0, + 25852, 25853, 7, 5, 0, 0, 25853, 25854, 5, 95, 0, 0, 25854, 25855, 7, 2, + 0, 0, 25855, 25856, 7, 15, 0, 0, 25856, 25857, 5, 95, 0, 0, 25857, 25858, + 7, 3, 0, 0, 25858, 25859, 7, 9, 0, 0, 25859, 25860, 7, 4, 0, 0, 25860, + 25861, 7, 14, 0, 0, 25861, 3816, 1, 0, 0, 0, 25862, 25863, 7, 5, 0, 0, + 25863, 25864, 7, 18, 0, 0, 25864, 25865, 7, 5, 0, 0, 25865, 25866, 5, 95, + 0, 0, 25866, 25867, 7, 2, 0, 0, 25867, 25868, 7, 15, 0, 0, 25868, 25869, + 5, 95, 0, 0, 25869, 25870, 7, 3, 0, 0, 25870, 25871, 7, 6, 0, 0, 25871, + 25872, 7, 16, 0, 0, 25872, 3818, 1, 0, 0, 0, 25873, 25874, 7, 5, 0, 0, + 25874, 25875, 7, 18, 0, 0, 25875, 25876, 7, 5, 0, 0, 25876, 25877, 5, 95, + 0, 0, 25877, 25878, 7, 2, 0, 0, 25878, 25879, 7, 15, 0, 0, 25879, 25880, + 5, 95, 0, 0, 25880, 25881, 7, 3, 0, 0, 25881, 25882, 7, 14, 0, 0, 25882, + 25883, 7, 4, 0, 0, 25883, 25884, 7, 9, 0, 0, 25884, 3820, 1, 0, 0, 0, 25885, + 25886, 7, 5, 0, 0, 25886, 25887, 7, 18, 0, 0, 25887, 25888, 7, 5, 0, 0, + 25888, 25889, 5, 95, 0, 0, 25889, 25890, 7, 2, 0, 0, 25890, 25891, 7, 15, + 0, 0, 25891, 25892, 5, 95, 0, 0, 25892, 25893, 7, 3, 0, 0, 25893, 25894, + 7, 2, 0, 0, 25894, 25895, 7, 22, 0, 0, 25895, 25896, 7, 10, 0, 0, 25896, + 25897, 7, 9, 0, 0, 25897, 25898, 7, 4, 0, 0, 25898, 25899, 7, 2, 0, 0, + 25899, 25900, 7, 2, 0, 0, 25900, 25901, 7, 1, 0, 0, 25901, 25902, 7, 20, + 0, 0, 25902, 3822, 1, 0, 0, 0, 25903, 25904, 7, 5, 0, 0, 25904, 25905, + 7, 18, 0, 0, 25905, 25906, 7, 5, 0, 0, 25906, 25907, 5, 95, 0, 0, 25907, + 25908, 7, 2, 0, 0, 25908, 25909, 7, 15, 0, 0, 25909, 25910, 5, 95, 0, 0, + 25910, 25911, 7, 3, 0, 0, 25911, 25912, 7, 15, 0, 0, 25912, 25913, 7, 1, + 0, 0, 25913, 3824, 1, 0, 0, 0, 25914, 25915, 7, 5, 0, 0, 25915, 25916, + 7, 18, 0, 0, 25916, 25917, 7, 5, 0, 0, 25917, 25918, 5, 95, 0, 0, 25918, + 25919, 7, 2, 0, 0, 25919, 25920, 7, 15, 0, 0, 25920, 25921, 7, 4, 0, 0, + 25921, 25922, 7, 11, 0, 0, 25922, 25923, 7, 2, 0, 0, 25923, 25924, 7, 1, + 0, 0, 25924, 25925, 7, 15, 0, 0, 25925, 25926, 7, 3, 0, 0, 25926, 25927, + 7, 1, 0, 0, 25927, 25928, 7, 5, 0, 0, 25928, 25929, 7, 8, 0, 0, 25929, + 3826, 1, 0, 0, 0, 25930, 25931, 7, 5, 0, 0, 25931, 25932, 7, 18, 0, 0, + 25932, 25933, 7, 5, 0, 0, 25933, 25934, 5, 95, 0, 0, 25934, 25935, 7, 2, + 0, 0, 25935, 25936, 7, 15, 0, 0, 25936, 25937, 5, 95, 0, 0, 25937, 25938, + 7, 4, 0, 0, 25938, 25939, 7, 2, 0, 0, 25939, 25940, 7, 5, 0, 0, 25940, + 25941, 7, 6, 0, 0, 25941, 25942, 7, 4, 0, 0, 25942, 25943, 7, 10, 0, 0, + 25943, 25944, 7, 9, 0, 0, 25944, 3828, 1, 0, 0, 0, 25945, 25946, 7, 5, + 0, 0, 25946, 25947, 7, 18, 0, 0, 25947, 25948, 7, 5, 0, 0, 25948, 25949, + 5, 95, 0, 0, 25949, 25950, 7, 2, 0, 0, 25950, 25951, 7, 15, 0, 0, 25951, + 25952, 5, 95, 0, 0, 25952, 25953, 7, 4, 0, 0, 25953, 25954, 7, 15, 0, 0, + 25954, 25955, 7, 3, 0, 0, 25955, 3830, 1, 0, 0, 0, 25956, 25957, 7, 5, + 0, 0, 25957, 25958, 7, 18, 0, 0, 25958, 25959, 7, 5, 0, 0, 25959, 25960, + 5, 95, 0, 0, 25960, 25961, 7, 2, 0, 0, 25961, 25962, 7, 15, 0, 0, 25962, + 25963, 5, 95, 0, 0, 25963, 25964, 7, 4, 0, 0, 25964, 25965, 7, 3, 0, 0, + 25965, 25966, 7, 4, 0, 0, 25966, 25967, 7, 1, 0, 0, 25967, 3832, 1, 0, + 0, 0, 25968, 25969, 7, 5, 0, 0, 25969, 25970, 7, 18, 0, 0, 25970, 25971, + 7, 5, 0, 0, 25971, 25972, 5, 95, 0, 0, 25972, 25973, 7, 2, 0, 0, 25973, + 25974, 7, 15, 0, 0, 25974, 25975, 7, 4, 0, 0, 25975, 25976, 7, 25, 0, 0, + 25976, 25977, 7, 10, 0, 0, 25977, 25978, 7, 8, 0, 0, 25978, 25979, 7, 14, + 0, 0, 25979, 25980, 7, 15, 0, 0, 25980, 3834, 1, 0, 0, 0, 25981, 25982, + 7, 5, 0, 0, 25982, 25983, 7, 18, 0, 0, 25983, 25984, 7, 5, 0, 0, 25984, + 25985, 5, 95, 0, 0, 25985, 25986, 7, 2, 0, 0, 25986, 25987, 7, 15, 0, 0, + 25987, 25988, 7, 4, 0, 0, 25988, 25989, 7, 25, 0, 0, 25989, 25990, 7, 24, + 0, 0, 25990, 25991, 7, 8, 0, 0, 25991, 25992, 7, 0, 0, 0, 25992, 25993, + 7, 5, 0, 0, 25993, 25994, 7, 4, 0, 0, 25994, 25995, 7, 0, 0, 0, 25995, + 25996, 7, 5, 0, 0, 25996, 25997, 7, 7, 0, 0, 25997, 25998, 7, 24, 0, 0, + 25998, 3836, 1, 0, 0, 0, 25999, 26000, 7, 5, 0, 0, 26000, 26001, 7, 18, + 0, 0, 26001, 26002, 7, 5, 0, 0, 26002, 26003, 5, 95, 0, 0, 26003, 26004, + 7, 2, 0, 0, 26004, 26005, 7, 15, 0, 0, 26005, 26006, 5, 95, 0, 0, 26006, + 26007, 7, 12, 0, 0, 26007, 26008, 7, 7, 0, 0, 26008, 26009, 7, 9, 0, 0, + 26009, 26010, 7, 6, 0, 0, 26010, 26011, 7, 5, 0, 0, 26011, 26012, 7, 8, + 0, 0, 26012, 26013, 7, 6, 0, 0, 26013, 26014, 7, 7, 0, 0, 26014, 26015, + 7, 9, 0, 0, 26015, 3838, 1, 0, 0, 0, 26016, 26017, 7, 5, 0, 0, 26017, 26018, + 7, 18, 0, 0, 26018, 26019, 7, 5, 0, 0, 26019, 26020, 5, 95, 0, 0, 26020, + 26021, 7, 2, 0, 0, 26021, 26022, 7, 15, 0, 0, 26022, 26023, 5, 95, 0, 0, + 26023, 26024, 7, 13, 0, 0, 26024, 26025, 7, 6, 0, 0, 26025, 26026, 7, 8, + 0, 0, 26026, 26027, 7, 0, 0, 0, 26027, 26028, 7, 7, 0, 0, 26028, 26029, + 7, 9, 0, 0, 26029, 3840, 1, 0, 0, 0, 26030, 26031, 7, 5, 0, 0, 26031, 26032, + 7, 18, 0, 0, 26032, 26033, 7, 5, 0, 0, 26033, 26034, 5, 95, 0, 0, 26034, + 26035, 7, 2, 0, 0, 26035, 26036, 7, 15, 0, 0, 26036, 26037, 5, 95, 0, 0, + 26037, 26038, 7, 13, 0, 0, 26038, 26039, 7, 6, 0, 0, 26039, 26040, 7, 8, + 0, 0, 26040, 26041, 7, 1, 0, 0, 26041, 26042, 7, 10, 0, 0, 26042, 26043, + 7, 4, 0, 0, 26043, 3842, 1, 0, 0, 0, 26044, 26045, 7, 5, 0, 0, 26045, 26046, + 7, 18, 0, 0, 26046, 26047, 7, 5, 0, 0, 26047, 26048, 5, 95, 0, 0, 26048, + 26049, 7, 2, 0, 0, 26049, 26050, 7, 15, 0, 0, 26050, 26051, 5, 95, 0, 0, + 26051, 26052, 7, 13, 0, 0, 26052, 26053, 7, 6, 0, 0, 26053, 26054, 7, 8, + 0, 0, 26054, 26055, 7, 2, 0, 0, 26055, 26056, 7, 3, 0, 0, 26056, 3844, + 1, 0, 0, 0, 26057, 26058, 7, 5, 0, 0, 26058, 26059, 7, 18, 0, 0, 26059, + 26060, 7, 5, 0, 0, 26060, 26061, 5, 95, 0, 0, 26061, 26062, 7, 2, 0, 0, + 26062, 26063, 7, 15, 0, 0, 26063, 26064, 5, 95, 0, 0, 26064, 26065, 7, + 13, 0, 0, 26065, 26066, 7, 6, 0, 0, 26066, 26067, 7, 8, 0, 0, 26067, 26068, + 7, 25, 0, 0, 26068, 26069, 7, 2, 0, 0, 26069, 26070, 7, 3, 0, 0, 26070, + 3846, 1, 0, 0, 0, 26071, 26072, 7, 5, 0, 0, 26072, 26073, 7, 18, 0, 0, + 26073, 26074, 7, 5, 0, 0, 26074, 26075, 5, 95, 0, 0, 26075, 26076, 7, 2, + 0, 0, 26076, 26077, 7, 15, 0, 0, 26077, 26078, 5, 95, 0, 0, 26078, 26079, + 7, 13, 0, 0, 26079, 26080, 7, 6, 0, 0, 26080, 26081, 7, 3, 0, 0, 26081, + 26082, 7, 5, 0, 0, 26082, 26083, 7, 10, 0, 0, 26083, 26084, 7, 2, 0, 0, + 26084, 26085, 7, 7, 0, 0, 26085, 3848, 1, 0, 0, 0, 26086, 26087, 7, 5, + 0, 0, 26087, 26088, 7, 18, 0, 0, 26088, 26089, 7, 5, 0, 0, 26089, 26090, + 5, 95, 0, 0, 26090, 26091, 7, 2, 0, 0, 26091, 26092, 7, 15, 0, 0, 26092, + 26093, 5, 95, 0, 0, 26093, 26094, 7, 13, 0, 0, 26094, 26095, 7, 3, 0, 0, + 26095, 26096, 7, 6, 0, 0, 26096, 26097, 7, 16, 0, 0, 26097, 3850, 1, 0, + 0, 0, 26098, 26099, 7, 5, 0, 0, 26099, 26100, 7, 18, 0, 0, 26100, 26101, + 7, 5, 0, 0, 26101, 26102, 5, 95, 0, 0, 26102, 26103, 7, 2, 0, 0, 26103, + 26104, 7, 15, 0, 0, 26104, 26105, 5, 95, 0, 0, 26105, 26106, 7, 13, 0, + 0, 26106, 26107, 7, 13, 0, 0, 26107, 26108, 7, 9, 0, 0, 26108, 3852, 1, + 0, 0, 0, 26109, 26110, 7, 5, 0, 0, 26110, 26111, 7, 18, 0, 0, 26111, 26112, + 7, 5, 0, 0, 26112, 26113, 5, 95, 0, 0, 26113, 26114, 7, 2, 0, 0, 26114, + 26115, 7, 15, 0, 0, 26115, 26116, 5, 95, 0, 0, 26116, 26117, 7, 25, 0, + 0, 26117, 26118, 7, 14, 0, 0, 26118, 26119, 7, 11, 0, 0, 26119, 26120, + 7, 8, 0, 0, 26120, 26121, 7, 2, 0, 0, 26121, 26122, 7, 7, 0, 0, 26122, + 26123, 7, 5, 0, 0, 26123, 26124, 5, 95, 0, 0, 26124, 26125, 7, 16, 0, 0, + 26125, 26126, 7, 2, 0, 0, 26126, 26127, 7, 3, 0, 0, 26127, 26128, 5, 95, + 0, 0, 26128, 26129, 7, 8, 0, 0, 26129, 26130, 7, 5, 0, 0, 26130, 26131, + 7, 25, 0, 0, 26131, 3854, 1, 0, 0, 0, 26132, 26133, 7, 5, 0, 0, 26133, + 26134, 7, 18, 0, 0, 26134, 26135, 7, 5, 0, 0, 26135, 26136, 5, 95, 0, 0, + 26136, 26137, 7, 2, 0, 0, 26137, 26138, 7, 15, 0, 0, 26138, 26139, 5, 95, + 0, 0, 26139, 26140, 7, 25, 0, 0, 26140, 26141, 7, 15, 0, 0, 26141, 26142, + 7, 4, 0, 0, 26142, 26143, 7, 19, 0, 0, 26143, 26144, 7, 0, 0, 0, 26144, + 26145, 7, 4, 0, 0, 26145, 26146, 7, 17, 0, 0, 26146, 3856, 1, 0, 0, 0, + 26147, 26148, 7, 5, 0, 0, 26148, 26149, 7, 18, 0, 0, 26149, 26150, 7, 5, + 0, 0, 26150, 26151, 5, 95, 0, 0, 26151, 26152, 7, 2, 0, 0, 26152, 26153, + 7, 15, 0, 0, 26153, 26154, 5, 95, 0, 0, 26154, 26155, 7, 25, 0, 0, 26155, + 26156, 7, 15, 0, 0, 26156, 26157, 7, 4, 0, 0, 26157, 26158, 7, 19, 0, 0, + 26158, 26159, 7, 10, 0, 0, 26159, 26160, 7, 9, 0, 0, 26160, 26161, 7, 25, + 0, 0, 26161, 3858, 1, 0, 0, 0, 26162, 26163, 7, 5, 0, 0, 26163, 26164, + 7, 18, 0, 0, 26164, 26165, 7, 5, 0, 0, 26165, 26166, 5, 95, 0, 0, 26166, + 26167, 7, 2, 0, 0, 26167, 26168, 7, 15, 0, 0, 26168, 26169, 5, 95, 0, 0, + 26169, 26170, 7, 25, 0, 0, 26170, 26171, 7, 15, 0, 0, 26171, 26172, 7, + 4, 0, 0, 26172, 26173, 7, 19, 0, 0, 26173, 26174, 7, 2, 0, 0, 26174, 26175, + 7, 15, 0, 0, 26175, 3860, 1, 0, 0, 0, 26176, 26177, 7, 5, 0, 0, 26177, + 26178, 7, 18, 0, 0, 26178, 26179, 7, 5, 0, 0, 26179, 26180, 5, 95, 0, 0, + 26180, 26181, 7, 2, 0, 0, 26181, 26182, 7, 15, 0, 0, 26182, 26183, 5, 95, + 0, 0, 26183, 26184, 7, 25, 0, 0, 26184, 26185, 7, 4, 0, 0, 26185, 26186, + 7, 25, 0, 0, 26186, 26187, 7, 4, 0, 0, 26187, 26188, 5, 50, 0, 0, 26188, + 26189, 7, 5, 0, 0, 26189, 26190, 7, 24, 0, 0, 26190, 26191, 7, 11, 0, 0, + 26191, 26192, 7, 4, 0, 0, 26192, 3862, 1, 0, 0, 0, 26193, 26194, 7, 5, + 0, 0, 26194, 26195, 7, 18, 0, 0, 26195, 26196, 7, 5, 0, 0, 26196, 26197, + 5, 95, 0, 0, 26197, 26198, 7, 2, 0, 0, 26198, 26199, 7, 15, 0, 0, 26199, + 26200, 5, 95, 0, 0, 26200, 26201, 7, 23, 0, 0, 26201, 26202, 7, 2, 0, 0, + 26202, 26203, 7, 7, 0, 0, 26203, 26204, 7, 6, 0, 0, 26204, 26205, 5, 95, + 0, 0, 26205, 26206, 7, 10, 0, 0, 26206, 26207, 7, 9, 0, 0, 26207, 3864, + 1, 0, 0, 0, 26208, 26209, 7, 5, 0, 0, 26209, 26210, 7, 18, 0, 0, 26210, + 26211, 7, 5, 0, 0, 26211, 26212, 5, 95, 0, 0, 26212, 26213, 7, 2, 0, 0, + 26213, 26214, 7, 3, 0, 0, 26214, 26215, 7, 9, 0, 0, 26215, 26216, 7, 6, + 0, 0, 26216, 26217, 7, 3, 0, 0, 26217, 26218, 7, 21, 0, 0, 26218, 26219, + 7, 6, 0, 0, 26219, 26220, 7, 18, 0, 0, 26220, 26221, 5, 95, 0, 0, 26221, + 26222, 7, 9, 0, 0, 26222, 26223, 7, 6, 0, 0, 26223, 26224, 7, 15, 0, 0, + 26224, 26225, 7, 4, 0, 0, 26225, 26226, 7, 19, 0, 0, 26226, 3866, 1, 0, + 0, 0, 26227, 26228, 7, 5, 0, 0, 26228, 26229, 7, 18, 0, 0, 26229, 26230, + 7, 5, 0, 0, 26230, 26231, 5, 95, 0, 0, 26231, 26232, 7, 2, 0, 0, 26232, + 26233, 7, 3, 0, 0, 26233, 26234, 7, 9, 0, 0, 26234, 26235, 7, 6, 0, 0, + 26235, 26236, 7, 3, 0, 0, 26236, 26237, 7, 21, 0, 0, 26237, 26238, 7, 6, + 0, 0, 26238, 26239, 7, 18, 0, 0, 26239, 26240, 5, 95, 0, 0, 26240, 26241, + 7, 14, 0, 0, 26241, 26242, 7, 0, 0, 0, 26242, 26243, 7, 25, 0, 0, 26243, + 26244, 7, 8, 0, 0, 26244, 26245, 7, 19, 0, 0, 26245, 26246, 7, 10, 0, 0, + 26246, 26247, 7, 11, 0, 0, 26247, 26248, 7, 9, 0, 0, 26248, 3868, 1, 0, + 0, 0, 26249, 26250, 7, 5, 0, 0, 26250, 26251, 7, 18, 0, 0, 26251, 26252, + 7, 5, 0, 0, 26252, 26253, 5, 95, 0, 0, 26253, 26254, 7, 2, 0, 0, 26254, + 26255, 7, 3, 0, 0, 26255, 26256, 7, 9, 0, 0, 26256, 26257, 7, 6, 0, 0, + 26257, 26258, 7, 3, 0, 0, 26258, 26259, 7, 21, 0, 0, 26259, 26260, 7, 6, + 0, 0, 26260, 26261, 7, 18, 0, 0, 26261, 26262, 5, 95, 0, 0, 26262, 26263, + 7, 15, 0, 0, 26263, 26264, 7, 0, 0, 0, 26264, 26265, 7, 3, 0, 0, 26265, + 26266, 7, 6, 0, 0, 26266, 26267, 7, 7, 0, 0, 26267, 26268, 7, 4, 0, 0, + 26268, 3870, 1, 0, 0, 0, 26269, 26270, 7, 5, 0, 0, 26270, 26271, 7, 18, + 0, 0, 26271, 26272, 7, 5, 0, 0, 26272, 26273, 5, 95, 0, 0, 26273, 26274, + 7, 15, 0, 0, 26274, 26275, 7, 0, 0, 0, 26275, 26276, 7, 3, 0, 0, 26276, + 26277, 7, 0, 0, 0, 26277, 26278, 7, 11, 0, 0, 26278, 26279, 7, 11, 0, 0, + 26279, 26280, 7, 6, 0, 0, 26280, 26281, 7, 11, 0, 0, 26281, 26282, 5, 95, + 0, 0, 26282, 26283, 7, 4, 0, 0, 26283, 26284, 7, 25, 0, 0, 26284, 26285, + 7, 7, 0, 0, 26285, 3872, 1, 0, 0, 0, 26286, 26287, 7, 5, 0, 0, 26287, 26288, + 7, 18, 0, 0, 26288, 26289, 7, 5, 0, 0, 26289, 26290, 5, 95, 0, 0, 26290, + 26291, 7, 15, 0, 0, 26291, 26292, 7, 0, 0, 0, 26292, 26293, 7, 4, 0, 0, + 26293, 26294, 7, 19, 0, 0, 26294, 26295, 7, 10, 0, 0, 26295, 26296, 7, + 9, 0, 0, 26296, 26297, 5, 95, 0, 0, 26297, 26298, 7, 10, 0, 0, 26298, 26299, + 7, 5, 0, 0, 26299, 26300, 5, 95, 0, 0, 26300, 26301, 7, 0, 0, 0, 26301, + 26302, 7, 4, 0, 0, 26302, 26303, 7, 4, 0, 0, 26303, 26304, 7, 3, 0, 0, + 26304, 3874, 1, 0, 0, 0, 26305, 26306, 7, 5, 0, 0, 26306, 26307, 7, 18, + 0, 0, 26307, 26308, 7, 5, 0, 0, 26308, 26309, 5, 95, 0, 0, 26309, 26310, + 7, 15, 0, 0, 26310, 26311, 7, 0, 0, 0, 26311, 26312, 7, 4, 0, 0, 26312, + 26313, 7, 19, 0, 0, 26313, 26314, 7, 10, 0, 0, 26314, 26315, 7, 9, 0, 0, + 26315, 26316, 5, 95, 0, 0, 26316, 26317, 7, 10, 0, 0, 26317, 26318, 7, + 5, 0, 0, 26318, 26319, 5, 95, 0, 0, 26319, 26320, 7, 7, 0, 0, 26320, 26321, + 7, 14, 0, 0, 26321, 26322, 7, 5, 0, 0, 26322, 26323, 7, 15, 0, 0, 26323, + 26324, 7, 8, 0, 0, 26324, 3876, 1, 0, 0, 0, 26325, 26326, 7, 5, 0, 0, 26326, + 26327, 7, 18, 0, 0, 26327, 26328, 7, 5, 0, 0, 26328, 26329, 5, 95, 0, 0, + 26329, 26330, 7, 15, 0, 0, 26330, 26331, 7, 0, 0, 0, 26331, 26332, 7, 4, + 0, 0, 26332, 26333, 7, 19, 0, 0, 26333, 26334, 7, 10, 0, 0, 26334, 26335, + 7, 9, 0, 0, 26335, 26336, 5, 95, 0, 0, 26336, 26337, 7, 11, 0, 0, 26337, + 26338, 7, 0, 0, 0, 26338, 26339, 7, 5, 0, 0, 26339, 26340, 7, 4, 0, 0, + 26340, 26341, 7, 7, 0, 0, 26341, 26342, 7, 0, 0, 0, 26342, 26343, 7, 14, + 0, 0, 26343, 26344, 7, 6, 0, 0, 26344, 3878, 1, 0, 0, 0, 26345, 26346, + 7, 5, 0, 0, 26346, 26347, 7, 18, 0, 0, 26347, 26348, 7, 5, 0, 0, 26348, + 26349, 5, 95, 0, 0, 26349, 26350, 7, 15, 0, 0, 26350, 26351, 7, 0, 0, 0, + 26351, 26352, 7, 4, 0, 0, 26352, 26353, 7, 19, 0, 0, 26353, 26354, 7, 10, + 0, 0, 26354, 26355, 7, 9, 0, 0, 26355, 26356, 5, 95, 0, 0, 26356, 26357, + 7, 11, 0, 0, 26357, 26358, 7, 0, 0, 0, 26358, 26359, 7, 5, 0, 0, 26359, + 26360, 7, 4, 0, 0, 26360, 26361, 7, 7, 0, 0, 26361, 26362, 7, 14, 0, 0, + 26362, 26363, 7, 5, 0, 0, 26363, 26364, 7, 15, 0, 0, 26364, 26365, 7, 8, + 0, 0, 26365, 3880, 1, 0, 0, 0, 26366, 26367, 7, 5, 0, 0, 26367, 26368, + 7, 18, 0, 0, 26368, 26369, 7, 5, 0, 0, 26369, 26370, 5, 95, 0, 0, 26370, + 26371, 7, 15, 0, 0, 26371, 26372, 7, 0, 0, 0, 26372, 26373, 7, 4, 0, 0, + 26373, 26374, 7, 19, 0, 0, 26374, 26375, 5, 95, 0, 0, 26375, 26376, 7, + 3, 0, 0, 26376, 26377, 7, 6, 0, 0, 26377, 26378, 7, 13, 0, 0, 26378, 26379, + 7, 6, 0, 0, 26379, 26380, 7, 3, 0, 0, 26380, 26381, 7, 5, 0, 0, 26381, + 26382, 7, 6, 0, 0, 26382, 3882, 1, 0, 0, 0, 26383, 26384, 7, 5, 0, 0, 26384, + 26385, 7, 18, 0, 0, 26385, 26386, 7, 5, 0, 0, 26386, 26387, 5, 95, 0, 0, + 26387, 26388, 7, 15, 0, 0, 26388, 26389, 7, 25, 0, 0, 26389, 26390, 7, + 24, 0, 0, 26390, 26391, 7, 6, 0, 0, 26391, 26392, 7, 25, 0, 0, 26392, 26393, + 7, 4, 0, 0, 26393, 26394, 7, 3, 0, 0, 26394, 26395, 7, 0, 0, 0, 26395, + 26396, 7, 8, 0, 0, 26396, 26397, 7, 4, 0, 0, 26397, 3884, 1, 0, 0, 0, 26398, + 26399, 7, 5, 0, 0, 26399, 26400, 7, 18, 0, 0, 26400, 26401, 7, 5, 0, 0, + 26401, 26402, 5, 95, 0, 0, 26402, 26403, 7, 3, 0, 0, 26403, 26404, 7, 0, + 0, 0, 26404, 26405, 7, 22, 0, 0, 26405, 26406, 5, 95, 0, 0, 26406, 26407, + 7, 4, 0, 0, 26407, 26408, 7, 2, 0, 0, 26408, 26409, 5, 95, 0, 0, 26409, + 26410, 7, 25, 0, 0, 26410, 26411, 7, 5, 0, 0, 26411, 26412, 7, 10, 0, 0, + 26412, 26413, 7, 9, 0, 0, 26413, 3886, 1, 0, 0, 0, 26414, 26415, 7, 5, + 0, 0, 26415, 26416, 7, 18, 0, 0, 26416, 26417, 7, 5, 0, 0, 26417, 26418, + 5, 95, 0, 0, 26418, 26419, 7, 3, 0, 0, 26419, 26420, 7, 10, 0, 0, 26420, + 26421, 7, 9, 0, 0, 26421, 26422, 5, 95, 0, 0, 26422, 26423, 7, 2, 0, 0, + 26423, 26424, 7, 3, 0, 0, 26424, 26425, 7, 9, 0, 0, 26425, 26426, 7, 6, + 0, 0, 26426, 26427, 7, 3, 0, 0, 26427, 3888, 1, 0, 0, 0, 26428, 26429, + 7, 5, 0, 0, 26429, 26430, 7, 18, 0, 0, 26430, 26431, 7, 5, 0, 0, 26431, + 26432, 5, 95, 0, 0, 26432, 26433, 7, 3, 0, 0, 26433, 26434, 7, 2, 0, 0, + 26434, 26435, 7, 22, 0, 0, 26435, 26436, 5, 95, 0, 0, 26436, 26437, 7, + 9, 0, 0, 26437, 26438, 7, 6, 0, 0, 26438, 26439, 7, 11, 0, 0, 26439, 26440, + 7, 4, 0, 0, 26440, 26441, 7, 0, 0, 0, 26441, 3890, 1, 0, 0, 0, 26442, 26443, + 7, 5, 0, 0, 26443, 26444, 7, 18, 0, 0, 26444, 26445, 7, 5, 0, 0, 26445, + 26446, 5, 95, 0, 0, 26446, 26447, 7, 5, 0, 0, 26447, 26448, 7, 8, 0, 0, + 26448, 26449, 5, 95, 0, 0, 26449, 26450, 5, 50, 0, 0, 26450, 26451, 5, + 95, 0, 0, 26451, 26452, 7, 25, 0, 0, 26452, 26453, 7, 14, 0, 0, 26453, + 26454, 7, 11, 0, 0, 26454, 26455, 7, 4, 0, 0, 26455, 3892, 1, 0, 0, 0, + 26456, 26457, 7, 5, 0, 0, 26457, 26458, 7, 18, 0, 0, 26458, 26459, 7, 5, + 0, 0, 26459, 26460, 5, 95, 0, 0, 26460, 26461, 7, 5, 0, 0, 26461, 26462, + 7, 18, 0, 0, 26462, 26463, 7, 7, 0, 0, 26463, 26464, 7, 3, 0, 0, 26464, + 26465, 7, 8, 0, 0, 26465, 26466, 7, 10, 0, 0, 26466, 26467, 7, 3, 0, 0, + 26467, 26468, 7, 6, 0, 0, 26468, 26469, 7, 9, 0, 0, 26469, 26470, 7, 2, + 0, 0, 26470, 3894, 1, 0, 0, 0, 26471, 26472, 7, 5, 0, 0, 26472, 26473, + 7, 18, 0, 0, 26473, 26474, 7, 5, 0, 0, 26474, 26475, 7, 4, 0, 0, 26475, + 26476, 7, 6, 0, 0, 26476, 26477, 7, 14, 0, 0, 26477, 26478, 5, 95, 0, 0, + 26478, 26479, 7, 9, 0, 0, 26479, 26480, 7, 6, 0, 0, 26480, 26481, 7, 16, + 0, 0, 26481, 26482, 7, 10, 0, 0, 26482, 26483, 7, 7, 0, 0, 26483, 26484, + 7, 6, 0, 0, 26484, 26485, 7, 9, 0, 0, 26485, 3896, 1, 0, 0, 0, 26486, 26487, + 7, 5, 0, 0, 26487, 26488, 7, 18, 0, 0, 26488, 26489, 7, 5, 0, 0, 26489, + 26490, 7, 4, 0, 0, 26490, 26491, 7, 6, 0, 0, 26491, 26492, 7, 14, 0, 0, + 26492, 3898, 1, 0, 0, 0, 26493, 26494, 7, 5, 0, 0, 26494, 26495, 7, 18, + 0, 0, 26495, 26496, 7, 5, 0, 0, 26496, 26497, 7, 4, 0, 0, 26497, 26498, + 7, 10, 0, 0, 26498, 26499, 7, 14, 0, 0, 26499, 26500, 7, 6, 0, 0, 26500, + 26501, 7, 5, 0, 0, 26501, 26502, 7, 4, 0, 0, 26502, 26503, 7, 0, 0, 0, + 26503, 26504, 7, 14, 0, 0, 26504, 26505, 7, 15, 0, 0, 26505, 3900, 1, 0, + 0, 0, 26506, 26507, 7, 5, 0, 0, 26507, 26508, 7, 18, 0, 0, 26508, 26509, + 7, 5, 0, 0, 26509, 26510, 5, 95, 0, 0, 26510, 26511, 7, 4, 0, 0, 26511, + 26512, 7, 18, 0, 0, 26512, 26513, 7, 15, 0, 0, 26513, 26514, 7, 6, 0, 0, + 26514, 26515, 7, 10, 0, 0, 26515, 26516, 7, 9, 0, 0, 26516, 3902, 1, 0, + 0, 0, 26517, 26518, 7, 5, 0, 0, 26518, 26519, 7, 18, 0, 0, 26519, 26520, + 7, 5, 0, 0, 26520, 26521, 5, 95, 0, 0, 26521, 26522, 7, 12, 0, 0, 26522, + 26523, 7, 14, 0, 0, 26523, 26524, 7, 0, 0, 0, 26524, 26525, 7, 21, 0, 0, + 26525, 26526, 7, 6, 0, 0, 26526, 26527, 7, 25, 0, 0, 26527, 26528, 7, 14, + 0, 0, 26528, 26529, 7, 11, 0, 0, 26529, 3904, 1, 0, 0, 0, 26530, 26531, + 7, 5, 0, 0, 26531, 26532, 7, 18, 0, 0, 26532, 26533, 7, 5, 0, 0, 26533, + 26534, 5, 95, 0, 0, 26534, 26535, 7, 25, 0, 0, 26535, 26536, 7, 14, 0, + 0, 26536, 26537, 7, 11, 0, 0, 26537, 26538, 7, 0, 0, 0, 26538, 26539, 7, + 7, 0, 0, 26539, 26540, 7, 0, 0, 0, 26540, 26541, 7, 11, 0, 0, 26541, 26542, + 7, 18, 0, 0, 26542, 26543, 7, 23, 0, 0, 26543, 26544, 7, 6, 0, 0, 26544, + 3906, 1, 0, 0, 0, 26545, 26546, 7, 5, 0, 0, 26546, 26547, 7, 18, 0, 0, + 26547, 26548, 7, 5, 0, 0, 26548, 26549, 5, 95, 0, 0, 26549, 26550, 7, 25, + 0, 0, 26550, 26551, 7, 14, 0, 0, 26551, 26552, 7, 11, 0, 0, 26552, 26553, + 7, 8, 0, 0, 26553, 26554, 7, 2, 0, 0, 26554, 26555, 7, 7, 0, 0, 26555, + 26556, 7, 4, 0, 0, 26556, 26557, 7, 0, 0, 0, 26557, 26558, 7, 10, 0, 0, + 26558, 26559, 7, 7, 0, 0, 26559, 26560, 7, 5, 0, 0, 26560, 3908, 1, 0, + 0, 0, 26561, 26562, 7, 5, 0, 0, 26562, 26563, 7, 18, 0, 0, 26563, 26564, + 7, 5, 0, 0, 26564, 26565, 5, 95, 0, 0, 26565, 26566, 7, 25, 0, 0, 26566, + 26567, 7, 14, 0, 0, 26567, 26568, 7, 11, 0, 0, 26568, 26569, 7, 8, 0, 0, + 26569, 26570, 7, 2, 0, 0, 26570, 26571, 7, 7, 0, 0, 26571, 26572, 7, 13, + 0, 0, 26572, 3910, 1, 0, 0, 0, 26573, 26574, 7, 5, 0, 0, 26574, 26575, + 7, 18, 0, 0, 26575, 26576, 7, 5, 0, 0, 26576, 26577, 5, 95, 0, 0, 26577, + 26578, 7, 25, 0, 0, 26578, 26579, 7, 14, 0, 0, 26579, 26580, 7, 11, 0, + 0, 26580, 26581, 7, 6, 0, 0, 26581, 26582, 7, 25, 0, 0, 26582, 26583, 7, + 7, 0, 0, 26583, 26584, 7, 5, 0, 0, 26584, 26585, 7, 12, 0, 0, 26585, 26586, + 7, 3, 0, 0, 26586, 26587, 7, 10, 0, 0, 26587, 3912, 1, 0, 0, 0, 26588, + 26589, 7, 5, 0, 0, 26589, 26590, 7, 18, 0, 0, 26590, 26591, 7, 5, 0, 0, + 26591, 26592, 5, 95, 0, 0, 26592, 26593, 7, 25, 0, 0, 26593, 26594, 7, + 14, 0, 0, 26594, 26595, 7, 11, 0, 0, 26595, 26596, 7, 17, 0, 0, 26596, + 26597, 7, 6, 0, 0, 26597, 26598, 7, 7, 0, 0, 26598, 3914, 1, 0, 0, 0, 26599, + 26600, 7, 5, 0, 0, 26600, 26601, 7, 18, 0, 0, 26601, 26602, 7, 5, 0, 0, + 26602, 26603, 5, 95, 0, 0, 26603, 26604, 7, 25, 0, 0, 26604, 26605, 7, + 14, 0, 0, 26605, 26606, 7, 11, 0, 0, 26606, 26607, 7, 10, 0, 0, 26607, + 26608, 5, 95, 0, 0, 26608, 26609, 7, 11, 0, 0, 26609, 26610, 7, 2, 0, 0, + 26610, 26611, 7, 8, 0, 0, 26611, 26612, 5, 95, 0, 0, 26612, 26613, 7, 10, + 0, 0, 26613, 26614, 7, 5, 0, 0, 26614, 26615, 7, 7, 0, 0, 26615, 26616, + 7, 2, 0, 0, 26616, 26617, 7, 9, 0, 0, 26617, 26618, 7, 6, 0, 0, 26618, + 3916, 1, 0, 0, 0, 26619, 26620, 7, 5, 0, 0, 26620, 26621, 7, 18, 0, 0, + 26621, 26622, 7, 5, 0, 0, 26622, 26623, 5, 95, 0, 0, 26623, 26624, 7, 25, + 0, 0, 26624, 26625, 7, 14, 0, 0, 26625, 26626, 7, 11, 0, 0, 26626, 26627, + 7, 10, 0, 0, 26627, 26628, 5, 95, 0, 0, 26628, 26629, 7, 11, 0, 0, 26629, + 26630, 7, 2, 0, 0, 26630, 26631, 7, 8, 0, 0, 26631, 26632, 5, 95, 0, 0, + 26632, 26633, 7, 10, 0, 0, 26633, 26634, 7, 5, 0, 0, 26634, 26635, 7, 4, + 0, 0, 26635, 26636, 7, 6, 0, 0, 26636, 26637, 7, 25, 0, 0, 26637, 26638, + 7, 4, 0, 0, 26638, 3918, 1, 0, 0, 0, 26639, 26640, 7, 5, 0, 0, 26640, 26641, + 7, 18, 0, 0, 26641, 26642, 7, 5, 0, 0, 26642, 26643, 5, 95, 0, 0, 26643, + 26644, 7, 25, 0, 0, 26644, 26645, 7, 14, 0, 0, 26645, 26646, 7, 11, 0, + 0, 26646, 26647, 7, 10, 0, 0, 26647, 26648, 7, 7, 0, 0, 26648, 26649, 7, + 5, 0, 0, 26649, 26650, 7, 4, 0, 0, 26650, 26651, 7, 3, 0, 0, 26651, 3920, + 1, 0, 0, 0, 26652, 26653, 7, 5, 0, 0, 26653, 26654, 7, 18, 0, 0, 26654, + 26655, 7, 5, 0, 0, 26655, 26656, 5, 95, 0, 0, 26656, 26657, 7, 25, 0, 0, + 26657, 26658, 7, 14, 0, 0, 26658, 26659, 7, 11, 0, 0, 26659, 26660, 7, + 11, 0, 0, 26660, 26661, 7, 2, 0, 0, 26661, 26662, 7, 8, 0, 0, 26662, 26663, + 7, 0, 0, 0, 26663, 26664, 7, 4, 0, 0, 26664, 26665, 7, 2, 0, 0, 26665, + 26666, 7, 3, 0, 0, 26666, 26667, 5, 95, 0, 0, 26667, 26668, 7, 17, 0, 0, + 26668, 26669, 7, 6, 0, 0, 26669, 26670, 7, 4, 0, 0, 26670, 26671, 7, 5, + 0, 0, 26671, 26672, 7, 13, 0, 0, 26672, 26673, 7, 0, 0, 0, 26673, 26674, + 7, 11, 0, 0, 26674, 3922, 1, 0, 0, 0, 26675, 26676, 7, 5, 0, 0, 26676, + 26677, 7, 18, 0, 0, 26677, 26678, 7, 5, 0, 0, 26678, 26679, 5, 95, 0, 0, + 26679, 26680, 7, 25, 0, 0, 26680, 26681, 7, 14, 0, 0, 26681, 26682, 7, + 11, 0, 0, 26682, 26683, 7, 7, 0, 0, 26683, 26684, 7, 2, 0, 0, 26684, 26685, + 7, 9, 0, 0, 26685, 26686, 7, 6, 0, 0, 26686, 26687, 7, 10, 0, 0, 26687, + 26688, 7, 9, 0, 0, 26688, 26689, 5, 95, 0, 0, 26689, 26690, 7, 17, 0, 0, + 26690, 26691, 7, 6, 0, 0, 26691, 26692, 7, 4, 0, 0, 26692, 26693, 7, 8, + 0, 0, 26693, 26694, 7, 10, 0, 0, 26694, 26695, 7, 9, 0, 0, 26695, 3924, + 1, 0, 0, 0, 26696, 26697, 7, 5, 0, 0, 26697, 26698, 7, 18, 0, 0, 26698, + 26699, 7, 5, 0, 0, 26699, 26700, 5, 95, 0, 0, 26700, 26701, 7, 25, 0, 0, + 26701, 26702, 7, 14, 0, 0, 26702, 26703, 7, 11, 0, 0, 26703, 26704, 7, + 7, 0, 0, 26704, 26705, 7, 2, 0, 0, 26705, 26706, 7, 9, 0, 0, 26706, 26707, + 7, 6, 0, 0, 26707, 26708, 7, 10, 0, 0, 26708, 26709, 7, 9, 0, 0, 26709, + 26710, 5, 95, 0, 0, 26710, 26711, 7, 17, 0, 0, 26711, 26712, 7, 6, 0, 0, + 26712, 26713, 7, 4, 0, 0, 26713, 26714, 7, 11, 0, 0, 26714, 26715, 7, 2, + 0, 0, 26715, 26716, 7, 8, 0, 0, 26716, 26717, 7, 0, 0, 0, 26717, 26718, + 7, 4, 0, 0, 26718, 26719, 7, 2, 0, 0, 26719, 26720, 7, 3, 0, 0, 26720, + 3926, 1, 0, 0, 0, 26721, 26722, 7, 5, 0, 0, 26722, 26723, 7, 18, 0, 0, + 26723, 26724, 7, 5, 0, 0, 26724, 26725, 5, 95, 0, 0, 26725, 26726, 7, 25, + 0, 0, 26726, 26727, 7, 14, 0, 0, 26727, 26728, 7, 11, 0, 0, 26728, 26729, + 7, 7, 0, 0, 26729, 26730, 7, 2, 0, 0, 26730, 26731, 7, 9, 0, 0, 26731, + 26732, 7, 6, 0, 0, 26732, 26733, 7, 10, 0, 0, 26733, 26734, 7, 9, 0, 0, + 26734, 26735, 5, 95, 0, 0, 26735, 26736, 7, 17, 0, 0, 26736, 26737, 7, + 6, 0, 0, 26737, 26738, 7, 4, 0, 0, 26738, 26739, 7, 2, 0, 0, 26739, 26740, + 7, 21, 0, 0, 26740, 26741, 7, 6, 0, 0, 26741, 26742, 7, 18, 0, 0, 26742, + 3928, 1, 0, 0, 0, 26743, 26744, 7, 5, 0, 0, 26744, 26745, 7, 18, 0, 0, + 26745, 26746, 7, 5, 0, 0, 26746, 26747, 5, 95, 0, 0, 26747, 26748, 7, 25, + 0, 0, 26748, 26749, 7, 14, 0, 0, 26749, 26750, 7, 11, 0, 0, 26750, 26751, + 7, 7, 0, 0, 26751, 26752, 7, 2, 0, 0, 26752, 26753, 7, 9, 0, 0, 26753, + 26754, 7, 6, 0, 0, 26754, 26755, 7, 10, 0, 0, 26755, 26756, 7, 9, 0, 0, + 26756, 26757, 5, 95, 0, 0, 26757, 26758, 7, 17, 0, 0, 26758, 26759, 7, + 6, 0, 0, 26759, 26760, 7, 4, 0, 0, 26760, 26761, 7, 15, 0, 0, 26761, 26762, + 7, 0, 0, 0, 26762, 26763, 7, 4, 0, 0, 26763, 26764, 7, 19, 0, 0, 26764, + 26765, 7, 10, 0, 0, 26765, 26766, 7, 9, 0, 0, 26766, 3930, 1, 0, 0, 0, + 26767, 26768, 7, 5, 0, 0, 26768, 26769, 7, 18, 0, 0, 26769, 26770, 7, 5, + 0, 0, 26770, 26771, 5, 95, 0, 0, 26771, 26772, 7, 25, 0, 0, 26772, 26773, + 7, 14, 0, 0, 26773, 26774, 7, 11, 0, 0, 26774, 26775, 7, 7, 0, 0, 26775, + 26776, 7, 2, 0, 0, 26776, 26777, 7, 9, 0, 0, 26777, 26778, 7, 6, 0, 0, + 26778, 26779, 7, 10, 0, 0, 26779, 26780, 7, 9, 0, 0, 26780, 26781, 5, 95, + 0, 0, 26781, 26782, 7, 17, 0, 0, 26782, 26783, 7, 6, 0, 0, 26783, 26784, + 7, 4, 0, 0, 26784, 26785, 7, 15, 0, 0, 26785, 26786, 7, 4, 0, 0, 26786, + 26787, 7, 3, 0, 0, 26787, 26788, 7, 10, 0, 0, 26788, 26789, 7, 9, 0, 0, + 26789, 3932, 1, 0, 0, 0, 26790, 26791, 7, 5, 0, 0, 26791, 26792, 7, 18, + 0, 0, 26792, 26793, 7, 5, 0, 0, 26793, 26794, 5, 95, 0, 0, 26794, 26795, + 7, 25, 0, 0, 26795, 26796, 7, 14, 0, 0, 26796, 26797, 7, 11, 0, 0, 26797, + 26798, 7, 7, 0, 0, 26798, 26799, 7, 2, 0, 0, 26799, 26800, 7, 9, 0, 0, + 26800, 26801, 7, 6, 0, 0, 26801, 26802, 7, 10, 0, 0, 26802, 26803, 7, 9, + 0, 0, 26803, 26804, 5, 95, 0, 0, 26804, 26805, 7, 17, 0, 0, 26805, 26806, + 7, 6, 0, 0, 26806, 26807, 7, 4, 0, 0, 26807, 26808, 7, 3, 0, 0, 26808, + 26809, 7, 10, 0, 0, 26809, 26810, 7, 9, 0, 0, 26810, 3934, 1, 0, 0, 0, + 26811, 26812, 7, 5, 0, 0, 26812, 26813, 7, 18, 0, 0, 26813, 26814, 7, 5, + 0, 0, 26814, 26815, 5, 95, 0, 0, 26815, 26816, 7, 25, 0, 0, 26816, 26817, + 7, 14, 0, 0, 26817, 26818, 7, 11, 0, 0, 26818, 26819, 7, 7, 0, 0, 26819, + 26820, 7, 2, 0, 0, 26820, 26821, 7, 9, 0, 0, 26821, 26822, 7, 6, 0, 0, + 26822, 26823, 7, 10, 0, 0, 26823, 26824, 7, 9, 0, 0, 26824, 26825, 5, 95, + 0, 0, 26825, 26826, 7, 17, 0, 0, 26826, 26827, 7, 6, 0, 0, 26827, 26828, + 7, 4, 0, 0, 26828, 26829, 7, 5, 0, 0, 26829, 26830, 7, 13, 0, 0, 26830, + 26831, 7, 0, 0, 0, 26831, 26832, 7, 11, 0, 0, 26832, 3936, 1, 0, 0, 0, + 26833, 26834, 7, 5, 0, 0, 26834, 26835, 7, 18, 0, 0, 26835, 26836, 7, 5, + 0, 0, 26836, 26837, 5, 95, 0, 0, 26837, 26838, 7, 25, 0, 0, 26838, 26839, + 7, 14, 0, 0, 26839, 26840, 7, 11, 0, 0, 26840, 26841, 7, 7, 0, 0, 26841, + 26842, 7, 2, 0, 0, 26842, 26843, 7, 9, 0, 0, 26843, 26844, 7, 6, 0, 0, + 26844, 26845, 7, 10, 0, 0, 26845, 26846, 7, 9, 0, 0, 26846, 26847, 5, 95, + 0, 0, 26847, 26848, 7, 17, 0, 0, 26848, 26849, 7, 6, 0, 0, 26849, 26850, + 7, 4, 0, 0, 26850, 26851, 7, 4, 0, 0, 26851, 26852, 7, 10, 0, 0, 26852, + 26853, 7, 9, 0, 0, 26853, 3938, 1, 0, 0, 0, 26854, 26855, 7, 5, 0, 0, 26855, + 26856, 7, 18, 0, 0, 26856, 26857, 7, 5, 0, 0, 26857, 26858, 5, 95, 0, 0, + 26858, 26859, 7, 25, 0, 0, 26859, 26860, 7, 14, 0, 0, 26860, 26861, 7, + 11, 0, 0, 26861, 26862, 7, 7, 0, 0, 26862, 26863, 7, 2, 0, 0, 26863, 26864, + 7, 9, 0, 0, 26864, 26865, 7, 6, 0, 0, 26865, 26866, 7, 10, 0, 0, 26866, + 26867, 7, 9, 0, 0, 26867, 3940, 1, 0, 0, 0, 26868, 26869, 7, 5, 0, 0, 26869, + 26870, 7, 18, 0, 0, 26870, 26871, 7, 5, 0, 0, 26871, 26872, 5, 95, 0, 0, + 26872, 26873, 7, 25, 0, 0, 26873, 26874, 7, 14, 0, 0, 26874, 26875, 7, + 11, 0, 0, 26875, 26876, 7, 4, 0, 0, 26876, 26877, 5, 95, 0, 0, 26877, 26878, + 5, 50, 0, 0, 26878, 26879, 5, 95, 0, 0, 26879, 26880, 7, 5, 0, 0, 26880, + 26881, 7, 8, 0, 0, 26881, 3942, 1, 0, 0, 0, 26882, 26883, 7, 5, 0, 0, 26883, + 26884, 7, 18, 0, 0, 26884, 26885, 7, 5, 0, 0, 26885, 26886, 5, 95, 0, 0, + 26886, 26887, 7, 25, 0, 0, 26887, 26888, 7, 14, 0, 0, 26888, 26889, 7, + 11, 0, 0, 26889, 26890, 7, 4, 0, 0, 26890, 26891, 7, 3, 0, 0, 26891, 26892, + 7, 0, 0, 0, 26892, 26893, 7, 7, 0, 0, 26893, 26894, 7, 5, 0, 0, 26894, + 26895, 7, 11, 0, 0, 26895, 26896, 7, 0, 0, 0, 26896, 26897, 7, 4, 0, 0, + 26897, 26898, 7, 6, 0, 0, 26898, 3944, 1, 0, 0, 0, 26899, 26900, 7, 5, + 0, 0, 26900, 26901, 7, 18, 0, 0, 26901, 26902, 7, 5, 0, 0, 26902, 26903, + 5, 95, 0, 0, 26903, 26904, 7, 25, 0, 0, 26904, 26905, 7, 14, 0, 0, 26905, + 26906, 7, 11, 0, 0, 26906, 26907, 7, 4, 0, 0, 26907, 26908, 7, 18, 0, 0, + 26908, 26909, 7, 15, 0, 0, 26909, 26910, 7, 6, 0, 0, 26910, 26911, 5, 50, + 0, 0, 26911, 26912, 7, 5, 0, 0, 26912, 26913, 7, 24, 0, 0, 26913, 26914, + 7, 11, 0, 0, 26914, 3946, 1, 0, 0, 0, 26915, 26916, 7, 5, 0, 0, 26916, + 26917, 7, 18, 0, 0, 26917, 26918, 7, 5, 0, 0, 26918, 26919, 5, 95, 0, 0, + 26919, 26920, 7, 25, 0, 0, 26920, 26921, 7, 24, 0, 0, 26921, 26922, 5, + 95, 0, 0, 26922, 26923, 7, 0, 0, 0, 26923, 26924, 7, 5, 0, 0, 26924, 26925, + 7, 24, 0, 0, 26925, 26926, 7, 11, 0, 0, 26926, 26927, 7, 8, 0, 0, 26927, + 26928, 7, 7, 0, 0, 26928, 26929, 7, 13, 0, 0, 26929, 3948, 1, 0, 0, 0, + 26930, 26931, 7, 5, 0, 0, 26931, 26932, 7, 18, 0, 0, 26932, 26933, 7, 5, + 0, 0, 26933, 26934, 5, 95, 0, 0, 26934, 26935, 7, 25, 0, 0, 26935, 26936, + 7, 24, 0, 0, 26936, 26937, 5, 95, 0, 0, 26937, 26938, 7, 0, 0, 0, 26938, + 26939, 7, 4, 0, 0, 26939, 26940, 7, 2, 0, 0, 26940, 26941, 7, 14, 0, 0, + 26941, 26942, 7, 8, 0, 0, 26942, 26943, 7, 7, 0, 0, 26943, 26944, 7, 13, + 0, 0, 26944, 26945, 7, 8, 0, 0, 26945, 26946, 7, 19, 0, 0, 26946, 26947, + 7, 21, 0, 0, 26947, 3950, 1, 0, 0, 0, 26948, 26949, 7, 5, 0, 0, 26949, + 26950, 7, 18, 0, 0, 26950, 26951, 7, 5, 0, 0, 26951, 26952, 5, 95, 0, 0, + 26952, 26953, 7, 25, 0, 0, 26953, 26954, 7, 24, 0, 0, 26954, 26955, 7, + 1, 0, 0, 26955, 26956, 7, 0, 0, 0, 26956, 26957, 7, 5, 0, 0, 26957, 26958, + 7, 6, 0, 0, 26958, 26959, 7, 12, 0, 0, 26959, 26960, 7, 3, 0, 0, 26960, + 26961, 7, 10, 0, 0, 26961, 3952, 1, 0, 0, 0, 26962, 26963, 7, 5, 0, 0, + 26963, 26964, 7, 18, 0, 0, 26964, 26965, 7, 5, 0, 0, 26965, 26966, 5, 95, + 0, 0, 26966, 26967, 7, 25, 0, 0, 26967, 26968, 7, 24, 0, 0, 26968, 26969, + 7, 8, 0, 0, 26969, 26970, 7, 0, 0, 0, 26970, 26971, 7, 5, 0, 0, 26971, + 26972, 7, 4, 0, 0, 26972, 26973, 7, 0, 0, 0, 26973, 26974, 7, 1, 0, 0, + 26974, 26975, 7, 11, 0, 0, 26975, 26976, 7, 6, 0, 0, 26976, 26977, 7, 6, + 0, 0, 26977, 26978, 7, 3, 0, 0, 26978, 26979, 7, 3, 0, 0, 26979, 26980, + 7, 19, 0, 0, 26980, 3954, 1, 0, 0, 0, 26981, 26982, 7, 5, 0, 0, 26982, + 26983, 7, 18, 0, 0, 26983, 26984, 7, 5, 0, 0, 26984, 26985, 5, 95, 0, 0, + 26985, 26986, 7, 25, 0, 0, 26986, 26987, 7, 24, 0, 0, 26987, 26988, 7, + 8, 0, 0, 26988, 26989, 7, 2, 0, 0, 26989, 26990, 7, 9, 0, 0, 26990, 26991, + 7, 6, 0, 0, 26991, 26992, 7, 15, 0, 0, 26992, 26993, 5, 50, 0, 0, 26993, + 26994, 7, 5, 0, 0, 26994, 26995, 7, 4, 0, 0, 26995, 26996, 7, 3, 0, 0, + 26996, 3956, 1, 0, 0, 0, 26997, 26998, 7, 5, 0, 0, 26998, 26999, 7, 18, + 0, 0, 26999, 27000, 7, 5, 0, 0, 27000, 27001, 5, 95, 0, 0, 27001, 27002, + 7, 25, 0, 0, 27002, 27003, 7, 24, 0, 0, 27003, 27004, 7, 8, 0, 0, 27004, + 27005, 7, 2, 0, 0, 27005, 27006, 7, 9, 0, 0, 27006, 27007, 7, 6, 0, 0, + 27007, 27008, 7, 15, 0, 0, 27008, 27009, 7, 6, 0, 0, 27009, 27010, 7, 24, + 0, 0, 27010, 3958, 1, 0, 0, 0, 27011, 27012, 7, 5, 0, 0, 27012, 27013, + 7, 18, 0, 0, 27013, 27014, 7, 5, 0, 0, 27014, 27015, 5, 95, 0, 0, 27015, + 27016, 7, 25, 0, 0, 27016, 27017, 7, 24, 0, 0, 27017, 27018, 7, 8, 0, 0, + 27018, 27019, 7, 2, 0, 0, 27019, 27020, 7, 7, 0, 0, 27020, 27021, 5, 50, + 0, 0, 27021, 27022, 7, 5, 0, 0, 27022, 27023, 7, 6, 0, 0, 27023, 27024, + 7, 24, 0, 0, 27024, 3960, 1, 0, 0, 0, 27025, 27026, 7, 5, 0, 0, 27026, + 27027, 7, 18, 0, 0, 27027, 27028, 7, 5, 0, 0, 27028, 27029, 5, 95, 0, 0, + 27029, 27030, 7, 25, 0, 0, 27030, 27031, 7, 24, 0, 0, 27031, 27032, 7, + 8, 0, 0, 27032, 27033, 7, 2, 0, 0, 27033, 27034, 7, 7, 0, 0, 27034, 27035, + 7, 8, 0, 0, 27035, 27036, 7, 0, 0, 0, 27036, 27037, 7, 4, 0, 0, 27037, + 3962, 1, 0, 0, 0, 27038, 27039, 7, 5, 0, 0, 27039, 27040, 7, 18, 0, 0, + 27040, 27041, 7, 5, 0, 0, 27041, 27042, 5, 95, 0, 0, 27042, 27043, 7, 25, + 0, 0, 27043, 27044, 7, 24, 0, 0, 27044, 27045, 7, 9, 0, 0, 27045, 27046, + 7, 6, 0, 0, 27046, 27047, 7, 11, 0, 0, 27047, 27048, 7, 6, 0, 0, 27048, + 27049, 7, 4, 0, 0, 27049, 27050, 7, 6, 0, 0, 27050, 3964, 1, 0, 0, 0, 27051, + 27052, 7, 5, 0, 0, 27052, 27053, 7, 18, 0, 0, 27053, 27054, 7, 5, 0, 0, + 27054, 27055, 5, 95, 0, 0, 27055, 27056, 7, 25, 0, 0, 27056, 27057, 7, + 24, 0, 0, 27057, 27058, 7, 9, 0, 0, 27058, 27059, 7, 16, 0, 0, 27059, 27060, + 7, 11, 0, 0, 27060, 27061, 7, 4, 0, 0, 27061, 27062, 7, 8, 0, 0, 27062, + 27063, 7, 2, 0, 0, 27063, 27064, 7, 11, 0, 0, 27064, 27065, 7, 0, 0, 0, + 27065, 27066, 7, 4, 0, 0, 27066, 27067, 7, 10, 0, 0, 27067, 27068, 7, 2, + 0, 0, 27068, 27069, 7, 7, 0, 0, 27069, 3966, 1, 0, 0, 0, 27070, 27071, + 7, 5, 0, 0, 27071, 27072, 7, 18, 0, 0, 27072, 27073, 7, 5, 0, 0, 27073, + 27074, 5, 95, 0, 0, 27074, 27075, 7, 25, 0, 0, 27075, 27076, 7, 24, 0, + 0, 27076, 27077, 7, 9, 0, 0, 27077, 27078, 7, 2, 0, 0, 27078, 27079, 7, + 8, 0, 0, 27079, 3968, 1, 0, 0, 0, 27080, 27081, 7, 5, 0, 0, 27081, 27082, + 7, 18, 0, 0, 27082, 27083, 7, 5, 0, 0, 27083, 27084, 5, 95, 0, 0, 27084, + 27085, 7, 25, 0, 0, 27085, 27086, 7, 24, 0, 0, 27086, 27087, 7, 9, 0, 0, + 27087, 27088, 7, 2, 0, 0, 27088, 27089, 7, 8, 0, 0, 27089, 27090, 7, 12, + 0, 0, 27090, 27091, 7, 3, 0, 0, 27091, 27092, 7, 10, 0, 0, 27092, 3970, + 1, 0, 0, 0, 27093, 27094, 7, 5, 0, 0, 27094, 27095, 7, 18, 0, 0, 27095, + 27096, 7, 5, 0, 0, 27096, 27097, 5, 95, 0, 0, 27097, 27098, 7, 25, 0, 0, + 27098, 27099, 7, 24, 0, 0, 27099, 27100, 7, 9, 0, 0, 27100, 27101, 7, 12, + 0, 0, 27101, 27102, 7, 3, 0, 0, 27102, 27103, 7, 9, 0, 0, 27103, 27104, + 7, 10, 0, 0, 27104, 27105, 7, 13, 0, 0, 27105, 3972, 1, 0, 0, 0, 27106, + 27107, 7, 5, 0, 0, 27107, 27108, 7, 18, 0, 0, 27108, 27109, 7, 5, 0, 0, + 27109, 27110, 5, 95, 0, 0, 27110, 27111, 7, 25, 0, 0, 27111, 27112, 7, + 24, 0, 0, 27112, 27113, 7, 6, 0, 0, 27113, 27114, 7, 9, 0, 0, 27114, 27115, + 5, 52, 0, 0, 27115, 27116, 7, 12, 0, 0, 27116, 27117, 7, 3, 0, 0, 27117, + 27118, 7, 10, 0, 0, 27118, 3974, 1, 0, 0, 0, 27119, 27120, 7, 5, 0, 0, + 27120, 27121, 7, 18, 0, 0, 27121, 27122, 7, 5, 0, 0, 27122, 27123, 5, 95, + 0, 0, 27123, 27124, 7, 25, 0, 0, 27124, 27125, 7, 24, 0, 0, 27125, 27126, + 7, 6, 0, 0, 27126, 27127, 7, 7, 0, 0, 27127, 27128, 7, 9, 0, 0, 27128, + 27129, 7, 5, 0, 0, 27129, 27130, 7, 22, 0, 0, 27130, 27131, 7, 10, 0, 0, + 27131, 27132, 7, 4, 0, 0, 27132, 27133, 7, 19, 0, 0, 27133, 3976, 1, 0, + 0, 0, 27134, 27135, 7, 5, 0, 0, 27135, 27136, 7, 18, 0, 0, 27136, 27137, + 7, 5, 0, 0, 27137, 27138, 5, 95, 0, 0, 27138, 27139, 7, 25, 0, 0, 27139, + 27140, 7, 24, 0, 0, 27140, 27141, 7, 6, 0, 0, 27141, 27142, 7, 3, 0, 0, + 27142, 27143, 7, 3, 0, 0, 27143, 27144, 7, 19, 0, 0, 27144, 3978, 1, 0, + 0, 0, 27145, 27146, 7, 5, 0, 0, 27146, 27147, 7, 18, 0, 0, 27147, 27148, + 7, 5, 0, 0, 27148, 27149, 5, 95, 0, 0, 27149, 27150, 7, 25, 0, 0, 27150, + 27151, 7, 24, 0, 0, 27151, 27152, 7, 6, 0, 0, 27152, 27153, 7, 3, 0, 0, + 27153, 27154, 7, 3, 0, 0, 27154, 3980, 1, 0, 0, 0, 27155, 27156, 7, 5, + 0, 0, 27156, 27157, 7, 18, 0, 0, 27157, 27158, 7, 5, 0, 0, 27158, 27159, + 5, 95, 0, 0, 27159, 27160, 7, 25, 0, 0, 27160, 27161, 7, 24, 0, 0, 27161, + 27162, 7, 6, 0, 0, 27162, 27163, 7, 5, 0, 0, 27163, 27164, 7, 19, 0, 0, + 27164, 27165, 7, 4, 0, 0, 27165, 27166, 7, 14, 0, 0, 27166, 27167, 7, 11, + 0, 0, 27167, 27168, 7, 12, 0, 0, 27168, 27169, 7, 3, 0, 0, 27169, 27170, + 7, 10, 0, 0, 27170, 3982, 1, 0, 0, 0, 27171, 27172, 7, 5, 0, 0, 27172, + 27173, 7, 18, 0, 0, 27173, 27174, 7, 5, 0, 0, 27174, 27175, 5, 95, 0, 0, + 27175, 27176, 7, 25, 0, 0, 27176, 27177, 7, 24, 0, 0, 27177, 27178, 7, + 6, 0, 0, 27178, 27179, 7, 25, 0, 0, 27179, 27180, 7, 11, 0, 0, 27180, 27181, + 7, 2, 0, 0, 27181, 27182, 7, 1, 0, 0, 27182, 27183, 7, 13, 0, 0, 27183, + 27184, 7, 0, 0, 0, 27184, 27185, 7, 11, 0, 0, 27185, 3984, 1, 0, 0, 0, + 27186, 27187, 7, 5, 0, 0, 27187, 27188, 7, 18, 0, 0, 27188, 27189, 7, 5, + 0, 0, 27189, 27190, 5, 95, 0, 0, 27190, 27191, 7, 25, 0, 0, 27191, 27192, + 7, 24, 0, 0, 27192, 27193, 7, 6, 0, 0, 27193, 27194, 7, 25, 0, 0, 27194, + 27195, 7, 5, 0, 0, 27195, 27196, 7, 4, 0, 0, 27196, 27197, 7, 22, 0, 0, + 27197, 27198, 7, 3, 0, 0, 27198, 27199, 7, 15, 0, 0, 27199, 3986, 1, 0, + 0, 0, 27200, 27201, 7, 5, 0, 0, 27201, 27202, 7, 18, 0, 0, 27202, 27203, + 7, 5, 0, 0, 27203, 27204, 5, 95, 0, 0, 27204, 27205, 7, 25, 0, 0, 27205, + 27206, 7, 24, 0, 0, 27206, 27207, 7, 6, 0, 0, 27207, 27208, 7, 25, 0, 0, + 27208, 27209, 7, 4, 0, 0, 27209, 27210, 7, 3, 0, 0, 27210, 27211, 7, 0, + 0, 0, 27211, 27212, 7, 8, 0, 0, 27212, 27213, 7, 4, 0, 0, 27213, 3988, + 1, 0, 0, 0, 27214, 27215, 7, 5, 0, 0, 27215, 27216, 7, 18, 0, 0, 27216, + 27217, 7, 5, 0, 0, 27217, 27218, 5, 95, 0, 0, 27218, 27219, 7, 25, 0, 0, + 27219, 27220, 7, 24, 0, 0, 27220, 27221, 7, 6, 0, 0, 27221, 27222, 7, 25, + 0, 0, 27222, 27223, 7, 4, 0, 0, 27223, 27224, 7, 3, 0, 0, 27224, 27225, + 7, 3, 0, 0, 27225, 27226, 7, 6, 0, 0, 27226, 27227, 7, 16, 0, 0, 27227, + 3990, 1, 0, 0, 0, 27228, 27229, 7, 5, 0, 0, 27229, 27230, 7, 18, 0, 0, + 27230, 27231, 7, 5, 0, 0, 27231, 27232, 5, 95, 0, 0, 27232, 27233, 7, 25, + 0, 0, 27233, 27234, 7, 24, 0, 0, 27234, 27235, 7, 6, 0, 0, 27235, 27236, + 7, 25, 0, 0, 27236, 27237, 7, 13, 0, 0, 27237, 27238, 7, 0, 0, 0, 27238, + 27239, 7, 11, 0, 0, 27239, 3992, 1, 0, 0, 0, 27240, 27241, 7, 5, 0, 0, + 27241, 27242, 7, 18, 0, 0, 27242, 27243, 7, 5, 0, 0, 27243, 27244, 5, 95, + 0, 0, 27244, 27245, 7, 25, 0, 0, 27245, 27246, 7, 24, 0, 0, 27246, 27247, + 7, 16, 0, 0, 27247, 27248, 7, 1, 0, 0, 27248, 27249, 5, 50, 0, 0, 27249, + 27250, 7, 5, 0, 0, 27250, 27251, 7, 4, 0, 0, 27251, 27252, 7, 3, 0, 0, + 27252, 3994, 1, 0, 0, 0, 27253, 27254, 7, 5, 0, 0, 27254, 27255, 7, 18, + 0, 0, 27255, 27256, 7, 5, 0, 0, 27256, 27257, 5, 95, 0, 0, 27257, 27258, + 7, 25, 0, 0, 27258, 27259, 7, 24, 0, 0, 27259, 27260, 7, 16, 0, 0, 27260, + 27261, 7, 7, 0, 0, 27261, 27262, 7, 1, 0, 0, 27262, 27263, 7, 2, 0, 0, + 27263, 27264, 7, 2, 0, 0, 27264, 27265, 7, 11, 0, 0, 27265, 3996, 1, 0, + 0, 0, 27266, 27267, 7, 5, 0, 0, 27267, 27268, 7, 18, 0, 0, 27268, 27269, + 7, 5, 0, 0, 27269, 27270, 5, 95, 0, 0, 27270, 27271, 7, 25, 0, 0, 27271, + 27272, 7, 24, 0, 0, 27272, 27273, 7, 16, 0, 0, 27273, 27274, 7, 7, 0, 0, + 27274, 27275, 7, 8, 0, 0, 27275, 27276, 7, 14, 0, 0, 27276, 27277, 7, 15, + 0, 0, 27277, 3998, 1, 0, 0, 0, 27278, 27279, 7, 5, 0, 0, 27279, 27280, + 7, 18, 0, 0, 27280, 27281, 7, 5, 0, 0, 27281, 27282, 5, 95, 0, 0, 27282, + 27283, 7, 25, 0, 0, 27283, 27284, 7, 24, 0, 0, 27284, 27285, 7, 16, 0, + 0, 27285, 27286, 7, 7, 0, 0, 27286, 27287, 7, 9, 0, 0, 27287, 27288, 7, + 0, 0, 0, 27288, 27289, 7, 4, 0, 0, 27289, 27290, 7, 10, 0, 0, 27290, 27291, + 7, 14, 0, 0, 27291, 4000, 1, 0, 0, 0, 27292, 27293, 7, 5, 0, 0, 27293, + 27294, 7, 18, 0, 0, 27294, 27295, 7, 5, 0, 0, 27295, 27296, 5, 95, 0, 0, + 27296, 27297, 7, 25, 0, 0, 27297, 27298, 7, 24, 0, 0, 27298, 27299, 7, + 16, 0, 0, 27299, 27300, 7, 7, 0, 0, 27300, 27301, 7, 11, 0, 0, 27301, 27302, + 7, 7, 0, 0, 27302, 27303, 7, 0, 0, 0, 27303, 27304, 7, 14, 0, 0, 27304, + 27305, 7, 6, 0, 0, 27305, 4002, 1, 0, 0, 0, 27306, 27307, 7, 5, 0, 0, 27307, + 27308, 7, 18, 0, 0, 27308, 27309, 7, 5, 0, 0, 27309, 27310, 5, 95, 0, 0, + 27310, 27311, 7, 25, 0, 0, 27311, 27312, 7, 24, 0, 0, 27312, 27313, 7, + 16, 0, 0, 27313, 27314, 7, 7, 0, 0, 27314, 27315, 7, 7, 0, 0, 27315, 27316, + 7, 14, 0, 0, 27316, 4004, 1, 0, 0, 0, 27317, 27318, 7, 5, 0, 0, 27318, + 27319, 7, 18, 0, 0, 27319, 27320, 7, 5, 0, 0, 27320, 27321, 5, 95, 0, 0, + 27321, 27322, 7, 25, 0, 0, 27322, 27323, 7, 24, 0, 0, 27323, 27324, 7, + 16, 0, 0, 27324, 27325, 7, 7, 0, 0, 27325, 27326, 7, 7, 0, 0, 27326, 27327, + 7, 5, 0, 0, 27327, 27328, 7, 12, 0, 0, 27328, 27329, 7, 3, 0, 0, 27329, + 27330, 7, 10, 0, 0, 27330, 4006, 1, 0, 0, 0, 27331, 27332, 7, 5, 0, 0, + 27332, 27333, 7, 18, 0, 0, 27333, 27334, 7, 5, 0, 0, 27334, 27335, 5, 95, + 0, 0, 27335, 27336, 7, 25, 0, 0, 27336, 27337, 7, 24, 0, 0, 27337, 27338, + 7, 16, 0, 0, 27338, 27339, 7, 7, 0, 0, 27339, 27340, 7, 15, 0, 0, 27340, + 27341, 7, 3, 0, 0, 27341, 27342, 7, 6, 0, 0, 27342, 27343, 7, 9, 0, 0, + 27343, 27344, 7, 4, 0, 0, 27344, 27345, 7, 3, 0, 0, 27345, 27346, 7, 12, + 0, 0, 27346, 27347, 7, 4, 0, 0, 27347, 27348, 7, 19, 0, 0, 27348, 4008, + 1, 0, 0, 0, 27349, 27350, 7, 5, 0, 0, 27350, 27351, 7, 18, 0, 0, 27351, + 27352, 7, 5, 0, 0, 27352, 27353, 5, 95, 0, 0, 27353, 27354, 7, 25, 0, 0, + 27354, 27355, 7, 24, 0, 0, 27355, 27356, 7, 16, 0, 0, 27356, 27357, 7, + 7, 0, 0, 27357, 27358, 7, 24, 0, 0, 27358, 27359, 7, 7, 0, 0, 27359, 27360, + 7, 14, 0, 0, 27360, 4010, 1, 0, 0, 0, 27361, 27362, 7, 5, 0, 0, 27362, + 27363, 7, 18, 0, 0, 27363, 27364, 7, 5, 0, 0, 27364, 27365, 5, 95, 0, 0, + 27365, 27366, 7, 25, 0, 0, 27366, 27367, 7, 24, 0, 0, 27367, 27368, 7, + 16, 0, 0, 27368, 27369, 7, 7, 0, 0, 27369, 27370, 7, 3, 0, 0, 27370, 27371, + 7, 2, 0, 0, 27371, 27372, 7, 2, 0, 0, 27372, 27373, 7, 4, 0, 0, 27373, + 4012, 1, 0, 0, 0, 27374, 27375, 7, 5, 0, 0, 27375, 27376, 7, 18, 0, 0, + 27376, 27377, 7, 5, 0, 0, 27377, 27378, 5, 95, 0, 0, 27378, 27379, 7, 25, + 0, 0, 27379, 27380, 7, 24, 0, 0, 27380, 27381, 7, 16, 0, 0, 27381, 27382, + 7, 2, 0, 0, 27382, 27383, 7, 3, 0, 0, 27383, 27384, 7, 14, 0, 0, 27384, + 27385, 7, 0, 0, 0, 27385, 27386, 7, 4, 0, 0, 27386, 27387, 7, 7, 0, 0, + 27387, 27388, 7, 12, 0, 0, 27388, 27389, 7, 14, 0, 0, 27389, 4014, 1, 0, + 0, 0, 27390, 27391, 7, 5, 0, 0, 27391, 27392, 7, 18, 0, 0, 27392, 27393, + 7, 5, 0, 0, 27393, 27394, 5, 95, 0, 0, 27394, 27395, 7, 25, 0, 0, 27395, + 27396, 7, 24, 0, 0, 27396, 27397, 7, 16, 0, 0, 27397, 27398, 7, 4, 0, 0, + 27398, 27399, 7, 8, 0, 0, 27399, 27400, 7, 2, 0, 0, 27400, 27401, 7, 7, + 0, 0, 27401, 27402, 7, 4, 0, 0, 27402, 27403, 7, 0, 0, 0, 27403, 27404, + 7, 10, 0, 0, 27404, 27405, 7, 7, 0, 0, 27405, 4016, 1, 0, 0, 0, 27406, + 27407, 7, 5, 0, 0, 27407, 27408, 7, 18, 0, 0, 27408, 27409, 7, 5, 0, 0, + 27409, 27410, 5, 95, 0, 0, 27410, 27411, 7, 25, 0, 0, 27411, 27412, 7, + 24, 0, 0, 27412, 27413, 7, 16, 0, 0, 27413, 27414, 7, 12, 0, 0, 27414, + 27415, 7, 7, 0, 0, 27415, 27416, 7, 8, 0, 0, 27416, 27417, 7, 3, 0, 0, + 27417, 4018, 1, 0, 0, 0, 27418, 27419, 7, 5, 0, 0, 27419, 27420, 7, 18, + 0, 0, 27420, 27421, 7, 5, 0, 0, 27421, 27422, 5, 95, 0, 0, 27422, 27423, + 7, 25, 0, 0, 27423, 27424, 7, 24, 0, 0, 27424, 27425, 7, 17, 0, 0, 27425, + 27426, 7, 6, 0, 0, 27426, 27427, 7, 4, 0, 0, 27427, 27428, 7, 8, 0, 0, + 27428, 27429, 7, 2, 0, 0, 27429, 27430, 7, 7, 0, 0, 27430, 27431, 7, 4, + 0, 0, 27431, 27432, 7, 6, 0, 0, 27432, 27433, 7, 7, 0, 0, 27433, 27434, + 7, 4, 0, 0, 27434, 4020, 1, 0, 0, 0, 27435, 27436, 7, 5, 0, 0, 27436, 27437, + 7, 18, 0, 0, 27437, 27438, 7, 5, 0, 0, 27438, 27439, 5, 95, 0, 0, 27439, + 27440, 7, 25, 0, 0, 27440, 27441, 7, 24, 0, 0, 27441, 27442, 7, 10, 0, + 0, 27442, 27443, 7, 7, 0, 0, 27443, 27444, 7, 9, 0, 0, 27444, 27445, 7, + 25, 0, 0, 27445, 27446, 7, 2, 0, 0, 27446, 27447, 7, 16, 0, 0, 27447, 4022, + 1, 0, 0, 0, 27448, 27449, 7, 5, 0, 0, 27449, 27450, 7, 18, 0, 0, 27450, + 27451, 7, 5, 0, 0, 27451, 27452, 5, 95, 0, 0, 27452, 27453, 7, 25, 0, 0, + 27453, 27454, 7, 24, 0, 0, 27454, 27455, 7, 10, 0, 0, 27455, 27456, 7, + 7, 0, 0, 27456, 27457, 7, 5, 0, 0, 27457, 27458, 7, 6, 0, 0, 27458, 27459, + 7, 3, 0, 0, 27459, 27460, 7, 4, 0, 0, 27460, 4024, 1, 0, 0, 0, 27461, 27462, + 7, 5, 0, 0, 27462, 27463, 7, 18, 0, 0, 27463, 27464, 7, 5, 0, 0, 27464, + 27465, 5, 95, 0, 0, 27465, 27466, 7, 25, 0, 0, 27466, 27467, 7, 24, 0, + 0, 27467, 27468, 7, 10, 0, 0, 27468, 27469, 7, 7, 0, 0, 27469, 27470, 7, + 5, 0, 0, 27470, 27471, 7, 15, 0, 0, 27471, 27472, 7, 16, 0, 0, 27472, 27473, + 7, 25, 0, 0, 27473, 4026, 1, 0, 0, 0, 27474, 27475, 7, 5, 0, 0, 27475, + 27476, 7, 18, 0, 0, 27476, 27477, 7, 5, 0, 0, 27477, 27478, 5, 95, 0, 0, + 27478, 27479, 7, 25, 0, 0, 27479, 27480, 7, 24, 0, 0, 27480, 27481, 7, + 10, 0, 0, 27481, 27482, 7, 3, 0, 0, 27482, 27483, 7, 10, 0, 0, 27483, 27484, + 5, 50, 0, 0, 27484, 27485, 7, 12, 0, 0, 27485, 27486, 7, 3, 0, 0, 27486, + 27487, 7, 10, 0, 0, 27487, 4028, 1, 0, 0, 0, 27488, 27489, 7, 5, 0, 0, + 27489, 27490, 7, 18, 0, 0, 27490, 27491, 7, 5, 0, 0, 27491, 27492, 5, 95, + 0, 0, 27492, 27493, 7, 25, 0, 0, 27493, 27494, 7, 24, 0, 0, 27494, 27495, + 7, 11, 0, 0, 27495, 27496, 7, 0, 0, 0, 27496, 27497, 7, 7, 0, 0, 27497, + 27498, 7, 17, 0, 0, 27498, 4030, 1, 0, 0, 0, 27499, 27500, 7, 5, 0, 0, + 27500, 27501, 7, 18, 0, 0, 27501, 27502, 7, 5, 0, 0, 27502, 27503, 5, 95, + 0, 0, 27503, 27504, 7, 25, 0, 0, 27504, 27505, 7, 24, 0, 0, 27505, 27506, + 7, 11, 0, 0, 27506, 27507, 7, 11, 0, 0, 27507, 27508, 7, 7, 0, 0, 27508, + 27509, 7, 14, 0, 0, 27509, 27510, 7, 16, 0, 0, 27510, 27511, 7, 3, 0, 0, + 27511, 27512, 7, 14, 0, 0, 27512, 27513, 7, 24, 0, 0, 27513, 27514, 7, + 7, 0, 0, 27514, 27515, 7, 14, 0, 0, 27515, 4032, 1, 0, 0, 0, 27516, 27517, + 7, 5, 0, 0, 27517, 27518, 7, 18, 0, 0, 27518, 27519, 7, 5, 0, 0, 27519, + 27520, 5, 95, 0, 0, 27520, 27521, 7, 25, 0, 0, 27521, 27522, 7, 24, 0, + 0, 27522, 27523, 7, 14, 0, 0, 27523, 27524, 7, 21, 0, 0, 27524, 27525, + 7, 7, 0, 0, 27525, 27526, 7, 2, 0, 0, 27526, 27527, 7, 9, 0, 0, 27527, + 27528, 7, 6, 0, 0, 27528, 27529, 7, 3, 0, 0, 27529, 27530, 7, 6, 0, 0, + 27530, 27531, 7, 16, 0, 0, 27531, 4034, 1, 0, 0, 0, 27532, 27533, 7, 5, + 0, 0, 27533, 27534, 7, 18, 0, 0, 27534, 27535, 7, 5, 0, 0, 27535, 27536, + 5, 95, 0, 0, 27536, 27537, 7, 25, 0, 0, 27537, 27538, 7, 24, 0, 0, 27538, + 27539, 7, 7, 0, 0, 27539, 27540, 7, 10, 0, 0, 27540, 27541, 7, 11, 0, 0, + 27541, 27542, 7, 11, 0, 0, 27542, 27543, 7, 6, 0, 0, 27543, 27544, 7, 9, + 0, 0, 27544, 4036, 1, 0, 0, 0, 27545, 27546, 7, 5, 0, 0, 27546, 27547, + 7, 18, 0, 0, 27547, 27548, 7, 5, 0, 0, 27548, 27549, 5, 95, 0, 0, 27549, + 27550, 7, 25, 0, 0, 27550, 27551, 7, 24, 0, 0, 27551, 27552, 7, 7, 0, 0, + 27552, 27553, 7, 2, 0, 0, 27553, 27554, 7, 9, 0, 0, 27554, 27555, 7, 6, + 0, 0, 27555, 27556, 7, 7, 0, 0, 27556, 27557, 7, 0, 0, 0, 27557, 27558, + 7, 14, 0, 0, 27558, 27559, 7, 6, 0, 0, 27559, 4038, 1, 0, 0, 0, 27560, + 27561, 7, 5, 0, 0, 27561, 27562, 7, 18, 0, 0, 27562, 27563, 7, 5, 0, 0, + 27563, 27564, 5, 95, 0, 0, 27564, 27565, 7, 25, 0, 0, 27565, 27566, 7, + 24, 0, 0, 27566, 27567, 7, 7, 0, 0, 27567, 27568, 7, 2, 0, 0, 27568, 27569, + 7, 3, 0, 0, 27569, 27570, 7, 14, 0, 0, 27570, 27571, 7, 5, 0, 0, 27571, + 27572, 7, 15, 0, 0, 27572, 27573, 7, 0, 0, 0, 27573, 27574, 7, 8, 0, 0, + 27574, 27575, 7, 6, 0, 0, 27575, 4040, 1, 0, 0, 0, 27576, 27577, 7, 5, + 0, 0, 27577, 27578, 7, 18, 0, 0, 27578, 27579, 7, 5, 0, 0, 27579, 27580, + 5, 95, 0, 0, 27580, 27581, 7, 25, 0, 0, 27581, 27582, 7, 24, 0, 0, 27582, + 27583, 7, 7, 0, 0, 27583, 27584, 7, 2, 0, 0, 27584, 27585, 7, 3, 0, 0, + 27585, 27586, 7, 14, 0, 0, 27586, 27587, 7, 12, 0, 0, 27587, 27588, 7, + 8, 0, 0, 27588, 27589, 7, 2, 0, 0, 27589, 27590, 7, 9, 0, 0, 27590, 27591, + 7, 6, 0, 0, 27591, 4042, 1, 0, 0, 0, 27592, 27593, 7, 5, 0, 0, 27593, 27594, + 7, 18, 0, 0, 27594, 27595, 7, 5, 0, 0, 27595, 27596, 5, 95, 0, 0, 27596, + 27597, 7, 25, 0, 0, 27597, 27598, 7, 24, 0, 0, 27598, 27599, 5, 95, 0, + 0, 27599, 27600, 7, 7, 0, 0, 27600, 27601, 7, 3, 0, 0, 27601, 27602, 7, + 7, 0, 0, 27602, 27603, 7, 17, 0, 0, 27603, 4044, 1, 0, 0, 0, 27604, 27605, + 7, 5, 0, 0, 27605, 27606, 7, 18, 0, 0, 27606, 27607, 7, 5, 0, 0, 27607, + 27608, 5, 95, 0, 0, 27608, 27609, 7, 25, 0, 0, 27609, 27610, 7, 24, 0, + 0, 27610, 27611, 7, 7, 0, 0, 27611, 27612, 7, 5, 0, 0, 27612, 27613, 7, + 15, 0, 0, 27613, 27614, 5, 52, 0, 0, 27614, 27615, 7, 15, 0, 0, 27615, + 27616, 7, 16, 0, 0, 27616, 27617, 7, 25, 0, 0, 27617, 4046, 1, 0, 0, 0, + 27618, 27619, 7, 5, 0, 0, 27619, 27620, 7, 18, 0, 0, 27620, 27621, 7, 5, + 0, 0, 27621, 27622, 5, 95, 0, 0, 27622, 27623, 7, 25, 0, 0, 27623, 27624, + 7, 24, 0, 0, 27624, 27625, 7, 7, 0, 0, 27625, 27626, 7, 5, 0, 0, 27626, + 27627, 7, 15, 0, 0, 27627, 27628, 7, 16, 0, 0, 27628, 27629, 7, 3, 0, 0, + 27629, 27630, 7, 14, 0, 0, 27630, 27631, 7, 24, 0, 0, 27631, 27632, 7, + 7, 0, 0, 27632, 27633, 7, 14, 0, 0, 27633, 4048, 1, 0, 0, 0, 27634, 27635, + 7, 5, 0, 0, 27635, 27636, 7, 18, 0, 0, 27636, 27637, 7, 5, 0, 0, 27637, + 27638, 5, 95, 0, 0, 27638, 27639, 7, 25, 0, 0, 27639, 27640, 7, 24, 0, + 0, 27640, 27641, 7, 15, 0, 0, 27641, 27642, 7, 16, 0, 0, 27642, 27643, + 7, 25, 0, 0, 27643, 27644, 7, 16, 0, 0, 27644, 27645, 7, 3, 0, 0, 27645, + 27646, 7, 14, 0, 0, 27646, 27647, 7, 24, 0, 0, 27647, 27648, 7, 7, 0, 0, + 27648, 27649, 7, 14, 0, 0, 27649, 4050, 1, 0, 0, 0, 27650, 27651, 7, 5, + 0, 0, 27651, 27652, 7, 18, 0, 0, 27652, 27653, 7, 5, 0, 0, 27653, 27654, + 5, 95, 0, 0, 27654, 27655, 7, 25, 0, 0, 27655, 27656, 7, 24, 0, 0, 27656, + 27657, 5, 95, 0, 0, 27657, 27658, 7, 15, 0, 0, 27658, 27659, 7, 21, 0, + 0, 27659, 27660, 7, 5, 0, 0, 27660, 27661, 7, 24, 0, 0, 27661, 27662, 7, + 11, 0, 0, 27662, 27663, 5, 50, 0, 0, 27663, 27664, 7, 25, 0, 0, 27664, + 27665, 7, 14, 0, 0, 27665, 27666, 7, 11, 0, 0, 27666, 4052, 1, 0, 0, 0, + 27667, 27668, 7, 5, 0, 0, 27668, 27669, 7, 18, 0, 0, 27669, 27670, 7, 5, + 0, 0, 27670, 27671, 5, 95, 0, 0, 27671, 27672, 7, 25, 0, 0, 27672, 27673, + 7, 24, 0, 0, 27673, 27674, 7, 15, 0, 0, 27674, 27675, 7, 2, 0, 0, 27675, + 27676, 7, 11, 0, 0, 27676, 27677, 7, 18, 0, 0, 27677, 27678, 7, 0, 0, 0, + 27678, 27679, 7, 1, 0, 0, 27679, 27680, 7, 5, 0, 0, 27680, 4054, 1, 0, + 0, 0, 27681, 27682, 7, 5, 0, 0, 27682, 27683, 7, 18, 0, 0, 27683, 27684, + 7, 5, 0, 0, 27684, 27685, 5, 95, 0, 0, 27685, 27686, 7, 25, 0, 0, 27686, + 27687, 7, 24, 0, 0, 27687, 27688, 7, 15, 0, 0, 27688, 27689, 7, 2, 0, 0, + 27689, 27690, 7, 11, 0, 0, 27690, 27691, 7, 18, 0, 0, 27691, 27692, 7, + 0, 0, 0, 27692, 27693, 7, 9, 0, 0, 27693, 27694, 7, 9, 0, 0, 27694, 4056, + 1, 0, 0, 0, 27695, 27696, 7, 5, 0, 0, 27696, 27697, 7, 18, 0, 0, 27697, + 27698, 7, 5, 0, 0, 27698, 27699, 5, 95, 0, 0, 27699, 27700, 7, 25, 0, 0, + 27700, 27701, 7, 24, 0, 0, 27701, 27702, 7, 15, 0, 0, 27702, 27703, 7, + 2, 0, 0, 27703, 27704, 7, 11, 0, 0, 27704, 27705, 7, 18, 0, 0, 27705, 27706, + 7, 8, 0, 0, 27706, 27707, 7, 6, 0, 0, 27707, 27708, 7, 11, 0, 0, 27708, + 4058, 1, 0, 0, 0, 27709, 27710, 7, 5, 0, 0, 27710, 27711, 7, 18, 0, 0, + 27711, 27712, 7, 5, 0, 0, 27712, 27713, 5, 95, 0, 0, 27713, 27714, 7, 25, + 0, 0, 27714, 27715, 7, 24, 0, 0, 27715, 27716, 7, 15, 0, 0, 27716, 27717, + 7, 2, 0, 0, 27717, 27718, 7, 11, 0, 0, 27718, 27719, 7, 18, 0, 0, 27719, + 27720, 7, 8, 0, 0, 27720, 27721, 7, 5, 0, 0, 27721, 27722, 7, 4, 0, 0, + 27722, 27723, 7, 1, 0, 0, 27723, 27724, 7, 11, 0, 0, 27724, 4060, 1, 0, + 0, 0, 27725, 27726, 7, 5, 0, 0, 27726, 27727, 7, 18, 0, 0, 27727, 27728, + 7, 5, 0, 0, 27728, 27729, 5, 95, 0, 0, 27729, 27730, 7, 25, 0, 0, 27730, + 27731, 7, 24, 0, 0, 27731, 27732, 7, 15, 0, 0, 27732, 27733, 7, 2, 0, 0, + 27733, 27734, 7, 11, 0, 0, 27734, 27735, 7, 18, 0, 0, 27735, 27736, 7, + 8, 0, 0, 27736, 27737, 7, 5, 0, 0, 27737, 27738, 7, 4, 0, 0, 27738, 4062, + 1, 0, 0, 0, 27739, 27740, 7, 5, 0, 0, 27740, 27741, 7, 18, 0, 0, 27741, + 27742, 7, 5, 0, 0, 27742, 27743, 5, 95, 0, 0, 27743, 27744, 7, 25, 0, 0, + 27744, 27745, 7, 24, 0, 0, 27745, 27746, 7, 15, 0, 0, 27746, 27747, 7, + 2, 0, 0, 27747, 27748, 7, 11, 0, 0, 27748, 27749, 7, 18, 0, 0, 27749, 27750, + 7, 9, 0, 0, 27750, 27751, 7, 10, 0, 0, 27751, 27752, 7, 13, 0, 0, 27752, + 4064, 1, 0, 0, 0, 27753, 27754, 7, 5, 0, 0, 27754, 27755, 7, 18, 0, 0, + 27755, 27756, 7, 5, 0, 0, 27756, 27757, 5, 95, 0, 0, 27757, 27758, 7, 25, + 0, 0, 27758, 27759, 7, 24, 0, 0, 27759, 27760, 7, 15, 0, 0, 27760, 27761, + 7, 2, 0, 0, 27761, 27762, 7, 11, 0, 0, 27762, 27763, 7, 18, 0, 0, 27763, + 27764, 7, 16, 0, 0, 27764, 27765, 7, 11, 0, 0, 27765, 27766, 7, 3, 0, 0, + 27766, 4066, 1, 0, 0, 0, 27767, 27768, 7, 5, 0, 0, 27768, 27769, 7, 18, + 0, 0, 27769, 27770, 7, 5, 0, 0, 27770, 27771, 5, 95, 0, 0, 27771, 27772, + 7, 25, 0, 0, 27772, 27773, 7, 24, 0, 0, 27773, 27774, 7, 15, 0, 0, 27774, + 27775, 7, 2, 0, 0, 27775, 27776, 7, 11, 0, 0, 27776, 27777, 7, 18, 0, 0, + 27777, 27778, 7, 14, 0, 0, 27778, 27779, 7, 2, 0, 0, 27779, 27780, 7, 9, + 0, 0, 27780, 4068, 1, 0, 0, 0, 27781, 27782, 7, 5, 0, 0, 27782, 27783, + 7, 18, 0, 0, 27783, 27784, 7, 5, 0, 0, 27784, 27785, 5, 95, 0, 0, 27785, + 27786, 7, 25, 0, 0, 27786, 27787, 7, 24, 0, 0, 27787, 27788, 7, 15, 0, + 0, 27788, 27789, 7, 2, 0, 0, 27789, 27790, 7, 11, 0, 0, 27790, 27791, 7, + 18, 0, 0, 27791, 27792, 7, 14, 0, 0, 27792, 27793, 7, 12, 0, 0, 27793, + 27794, 7, 11, 0, 0, 27794, 4070, 1, 0, 0, 0, 27795, 27796, 7, 5, 0, 0, + 27796, 27797, 7, 18, 0, 0, 27797, 27798, 7, 5, 0, 0, 27798, 27799, 5, 95, + 0, 0, 27799, 27800, 7, 25, 0, 0, 27800, 27801, 7, 24, 0, 0, 27801, 27802, + 7, 15, 0, 0, 27802, 27803, 7, 2, 0, 0, 27803, 27804, 7, 11, 0, 0, 27804, + 27805, 7, 18, 0, 0, 27805, 27806, 7, 3, 0, 0, 27806, 27807, 7, 7, 0, 0, + 27807, 27808, 7, 9, 0, 0, 27808, 4072, 1, 0, 0, 0, 27809, 27810, 7, 5, + 0, 0, 27810, 27811, 7, 18, 0, 0, 27811, 27812, 7, 5, 0, 0, 27812, 27813, + 5, 95, 0, 0, 27813, 27814, 7, 25, 0, 0, 27814, 27815, 7, 24, 0, 0, 27815, + 27816, 7, 15, 0, 0, 27816, 27817, 7, 2, 0, 0, 27817, 27818, 7, 11, 0, 0, + 27818, 27819, 7, 18, 0, 0, 27819, 27820, 7, 5, 0, 0, 27820, 27821, 7, 24, + 0, 0, 27821, 27822, 7, 3, 0, 0, 27822, 27823, 7, 4, 0, 0, 27823, 4074, + 1, 0, 0, 0, 27824, 27825, 7, 5, 0, 0, 27825, 27826, 7, 18, 0, 0, 27826, + 27827, 7, 5, 0, 0, 27827, 27828, 5, 95, 0, 0, 27828, 27829, 7, 25, 0, 0, + 27829, 27830, 7, 24, 0, 0, 27830, 27831, 7, 15, 0, 0, 27831, 27832, 7, + 2, 0, 0, 27832, 27833, 7, 11, 0, 0, 27833, 27834, 7, 18, 0, 0, 27834, 27835, + 7, 5, 0, 0, 27835, 27836, 7, 12, 0, 0, 27836, 27837, 7, 1, 0, 0, 27837, + 4076, 1, 0, 0, 0, 27838, 27839, 7, 5, 0, 0, 27839, 27840, 7, 18, 0, 0, + 27840, 27841, 7, 5, 0, 0, 27841, 27842, 5, 95, 0, 0, 27842, 27843, 7, 25, + 0, 0, 27843, 27844, 7, 24, 0, 0, 27844, 27845, 7, 15, 0, 0, 27845, 27846, + 7, 2, 0, 0, 27846, 27847, 7, 11, 0, 0, 27847, 27848, 7, 18, 0, 0, 27848, + 27849, 7, 12, 0, 0, 27849, 27850, 7, 14, 0, 0, 27850, 27851, 7, 12, 0, + 0, 27851, 27852, 7, 5, 0, 0, 27852, 4078, 1, 0, 0, 0, 27853, 27854, 7, + 5, 0, 0, 27854, 27855, 7, 18, 0, 0, 27855, 27856, 7, 5, 0, 0, 27856, 27857, + 5, 95, 0, 0, 27857, 27858, 7, 25, 0, 0, 27858, 27859, 7, 24, 0, 0, 27859, + 27860, 7, 15, 0, 0, 27860, 27861, 7, 2, 0, 0, 27861, 27862, 7, 11, 0, 0, + 27862, 27863, 7, 18, 0, 0, 27863, 27864, 7, 12, 0, 0, 27864, 27865, 7, + 15, 0, 0, 27865, 27866, 7, 11, 0, 0, 27866, 27867, 7, 5, 0, 0, 27867, 4080, + 1, 0, 0, 0, 27868, 27869, 7, 5, 0, 0, 27869, 27870, 7, 18, 0, 0, 27870, + 27871, 7, 5, 0, 0, 27871, 27872, 5, 95, 0, 0, 27872, 27873, 7, 25, 0, 0, + 27873, 27874, 7, 24, 0, 0, 27874, 27875, 7, 15, 0, 0, 27875, 27876, 7, + 2, 0, 0, 27876, 27877, 7, 11, 0, 0, 27877, 27878, 7, 18, 0, 0, 27878, 27879, + 7, 13, 0, 0, 27879, 27880, 7, 6, 0, 0, 27880, 27881, 7, 24, 0, 0, 27881, + 4082, 1, 0, 0, 0, 27882, 27883, 7, 5, 0, 0, 27883, 27884, 7, 18, 0, 0, + 27884, 27885, 7, 5, 0, 0, 27885, 27886, 5, 95, 0, 0, 27886, 27887, 7, 25, + 0, 0, 27887, 27888, 7, 24, 0, 0, 27888, 27889, 7, 15, 0, 0, 27889, 27890, + 7, 2, 0, 0, 27890, 27891, 7, 11, 0, 0, 27891, 27892, 7, 18, 0, 0, 27892, + 27893, 7, 13, 0, 0, 27893, 27894, 7, 17, 0, 0, 27894, 27895, 7, 6, 0, 0, + 27895, 4084, 1, 0, 0, 0, 27896, 27897, 7, 5, 0, 0, 27897, 27898, 7, 18, + 0, 0, 27898, 27899, 7, 5, 0, 0, 27899, 27900, 5, 95, 0, 0, 27900, 27901, + 7, 25, 0, 0, 27901, 27902, 7, 24, 0, 0, 27902, 27903, 7, 15, 0, 0, 27903, + 27904, 7, 2, 0, 0, 27904, 27905, 7, 11, 0, 0, 27905, 27906, 7, 18, 0, 0, + 27906, 27907, 7, 13, 0, 0, 27907, 27908, 7, 17, 0, 0, 27908, 27909, 7, + 4, 0, 0, 27909, 4086, 1, 0, 0, 0, 27910, 27911, 7, 5, 0, 0, 27911, 27912, + 7, 18, 0, 0, 27912, 27913, 7, 5, 0, 0, 27913, 27914, 5, 95, 0, 0, 27914, + 27915, 7, 25, 0, 0, 27915, 27916, 7, 24, 0, 0, 27916, 27917, 7, 15, 0, + 0, 27917, 27918, 7, 2, 0, 0, 27918, 27919, 7, 11, 0, 0, 27919, 27920, 7, + 18, 0, 0, 27920, 27921, 7, 13, 0, 0, 27921, 27922, 7, 11, 0, 0, 27922, + 27923, 7, 6, 0, 0, 27923, 4088, 1, 0, 0, 0, 27924, 27925, 7, 5, 0, 0, 27925, + 27926, 7, 18, 0, 0, 27926, 27927, 7, 5, 0, 0, 27927, 27928, 5, 95, 0, 0, + 27928, 27929, 7, 25, 0, 0, 27929, 27930, 7, 24, 0, 0, 27930, 27931, 7, + 15, 0, 0, 27931, 27932, 7, 2, 0, 0, 27932, 27933, 7, 11, 0, 0, 27933, 27934, + 7, 18, 0, 0, 27934, 27935, 7, 13, 0, 0, 27935, 27936, 7, 11, 0, 0, 27936, + 27937, 7, 4, 0, 0, 27937, 4090, 1, 0, 0, 0, 27938, 27939, 7, 5, 0, 0, 27939, + 27940, 7, 18, 0, 0, 27940, 27941, 7, 5, 0, 0, 27941, 27942, 5, 95, 0, 0, + 27942, 27943, 7, 25, 0, 0, 27943, 27944, 7, 24, 0, 0, 27944, 27945, 7, + 15, 0, 0, 27945, 27946, 7, 2, 0, 0, 27946, 27947, 7, 11, 0, 0, 27947, 27948, + 7, 18, 0, 0, 27948, 27949, 7, 13, 0, 0, 27949, 27950, 7, 7, 0, 0, 27950, + 27951, 7, 6, 0, 0, 27951, 4092, 1, 0, 0, 0, 27952, 27953, 7, 5, 0, 0, 27953, + 27954, 7, 18, 0, 0, 27954, 27955, 7, 5, 0, 0, 27955, 27956, 5, 95, 0, 0, + 27956, 27957, 7, 25, 0, 0, 27957, 27958, 7, 24, 0, 0, 27958, 27959, 7, + 3, 0, 0, 27959, 27960, 7, 6, 0, 0, 27960, 27961, 7, 16, 0, 0, 27961, 27962, + 5, 50, 0, 0, 27962, 27963, 7, 13, 0, 0, 27963, 27964, 7, 0, 0, 0, 27964, + 27965, 7, 11, 0, 0, 27965, 4094, 1, 0, 0, 0, 27966, 27967, 7, 5, 0, 0, + 27967, 27968, 7, 18, 0, 0, 27968, 27969, 7, 5, 0, 0, 27969, 27970, 5, 95, + 0, 0, 27970, 27971, 7, 25, 0, 0, 27971, 27972, 7, 24, 0, 0, 27972, 27973, + 7, 3, 0, 0, 27973, 27974, 7, 6, 0, 0, 27974, 27975, 7, 7, 0, 0, 27975, + 27976, 7, 0, 0, 0, 27976, 27977, 7, 14, 0, 0, 27977, 27978, 7, 6, 0, 0, + 27978, 4096, 1, 0, 0, 0, 27979, 27980, 7, 5, 0, 0, 27980, 27981, 7, 18, + 0, 0, 27981, 27982, 7, 5, 0, 0, 27982, 27983, 5, 95, 0, 0, 27983, 27984, + 7, 25, 0, 0, 27984, 27985, 7, 24, 0, 0, 27985, 27986, 7, 3, 0, 0, 27986, + 27987, 7, 6, 0, 0, 27987, 27988, 7, 15, 0, 0, 27988, 27989, 7, 11, 0, 0, + 27989, 27990, 7, 0, 0, 0, 27990, 27991, 7, 8, 0, 0, 27991, 27992, 7, 6, + 0, 0, 27992, 4098, 1, 0, 0, 0, 27993, 27994, 7, 5, 0, 0, 27994, 27995, + 7, 18, 0, 0, 27995, 27996, 7, 5, 0, 0, 27996, 27997, 5, 95, 0, 0, 27997, + 27998, 7, 25, 0, 0, 27998, 27999, 7, 24, 0, 0, 27999, 28000, 7, 3, 0, 0, + 28000, 28001, 7, 6, 0, 0, 28001, 28002, 7, 5, 0, 0, 28002, 28003, 7, 13, + 0, 0, 28003, 28004, 7, 12, 0, 0, 28004, 28005, 7, 3, 0, 0, 28005, 28006, + 7, 10, 0, 0, 28006, 4100, 1, 0, 0, 0, 28007, 28008, 7, 5, 0, 0, 28008, + 28009, 7, 18, 0, 0, 28009, 28010, 7, 5, 0, 0, 28010, 28011, 5, 95, 0, 0, + 28011, 28012, 7, 25, 0, 0, 28012, 28013, 7, 24, 0, 0, 28013, 28014, 7, + 3, 0, 0, 28014, 28015, 7, 7, 0, 0, 28015, 28016, 7, 9, 0, 0, 28016, 28017, + 7, 19, 0, 0, 28017, 28018, 7, 0, 0, 0, 28018, 28019, 7, 11, 0, 0, 28019, + 28020, 7, 16, 0, 0, 28020, 28021, 5, 50, 0, 0, 28021, 28022, 7, 6, 0, 0, + 28022, 28023, 7, 13, 0, 0, 28023, 28024, 7, 7, 0, 0, 28024, 4102, 1, 0, + 0, 0, 28025, 28026, 7, 5, 0, 0, 28026, 28027, 7, 18, 0, 0, 28027, 28028, + 7, 5, 0, 0, 28028, 28029, 5, 95, 0, 0, 28029, 28030, 7, 25, 0, 0, 28030, + 28031, 7, 24, 0, 0, 28031, 28032, 7, 3, 0, 0, 28032, 28033, 7, 5, 0, 0, + 28033, 28034, 7, 11, 0, 0, 28034, 28035, 7, 13, 0, 0, 28035, 28036, 7, + 24, 0, 0, 28036, 28037, 7, 7, 0, 0, 28037, 28038, 7, 14, 0, 0, 28038, 4104, + 1, 0, 0, 0, 28039, 28040, 7, 5, 0, 0, 28040, 28041, 7, 18, 0, 0, 28041, + 28042, 7, 5, 0, 0, 28042, 28043, 5, 95, 0, 0, 28043, 28044, 7, 25, 0, 0, + 28044, 28045, 7, 24, 0, 0, 28045, 28046, 7, 3, 0, 0, 28046, 28047, 7, 18, + 0, 0, 28047, 28048, 7, 6, 0, 0, 28048, 28049, 7, 7, 0, 0, 28049, 28050, + 7, 13, 0, 0, 28050, 28051, 7, 15, 0, 0, 28051, 28052, 7, 17, 0, 0, 28052, + 28053, 7, 6, 0, 0, 28053, 28054, 7, 4, 0, 0, 28054, 4106, 1, 0, 0, 0, 28055, + 28056, 7, 5, 0, 0, 28056, 28057, 7, 18, 0, 0, 28057, 28058, 7, 5, 0, 0, + 28058, 28059, 5, 95, 0, 0, 28059, 28060, 7, 25, 0, 0, 28060, 28061, 7, + 24, 0, 0, 28061, 28062, 7, 3, 0, 0, 28062, 28063, 7, 18, 0, 0, 28063, 28064, + 7, 13, 0, 0, 28064, 28065, 7, 0, 0, 0, 28065, 28066, 7, 3, 0, 0, 28066, + 28067, 7, 17, 0, 0, 28067, 28068, 7, 6, 0, 0, 28068, 28069, 7, 4, 0, 0, + 28069, 4108, 1, 0, 0, 0, 28070, 28071, 7, 5, 0, 0, 28071, 28072, 7, 18, + 0, 0, 28072, 28073, 7, 5, 0, 0, 28073, 28074, 5, 95, 0, 0, 28074, 28075, + 7, 25, 0, 0, 28075, 28076, 7, 24, 0, 0, 28076, 28077, 7, 3, 0, 0, 28077, + 28078, 7, 18, 0, 0, 28078, 28079, 7, 22, 0, 0, 28079, 28080, 7, 3, 0, 0, + 28080, 28081, 7, 15, 0, 0, 28081, 4110, 1, 0, 0, 0, 28082, 28083, 7, 5, + 0, 0, 28083, 28084, 7, 18, 0, 0, 28084, 28085, 7, 5, 0, 0, 28085, 28086, + 5, 95, 0, 0, 28086, 28087, 7, 25, 0, 0, 28087, 28088, 7, 24, 0, 0, 28088, + 28089, 7, 5, 0, 0, 28089, 28090, 7, 6, 0, 0, 28090, 28091, 7, 24, 0, 0, + 28091, 28092, 5, 50, 0, 0, 28092, 28093, 7, 8, 0, 0, 28093, 28094, 7, 2, + 0, 0, 28094, 28095, 7, 7, 0, 0, 28095, 28096, 5, 52, 0, 0, 28096, 28097, + 7, 25, 0, 0, 28097, 28098, 7, 8, 0, 0, 28098, 4112, 1, 0, 0, 0, 28099, + 28100, 7, 5, 0, 0, 28100, 28101, 7, 18, 0, 0, 28101, 28102, 7, 5, 0, 0, + 28102, 28103, 5, 95, 0, 0, 28103, 28104, 7, 25, 0, 0, 28104, 28105, 7, + 24, 0, 0, 28105, 28106, 7, 5, 0, 0, 28106, 28107, 7, 6, 0, 0, 28107, 28108, + 7, 24, 0, 0, 28108, 28109, 5, 50, 0, 0, 28109, 28110, 7, 8, 0, 0, 28110, + 28111, 7, 2, 0, 0, 28111, 28112, 7, 7, 0, 0, 28112, 4114, 1, 0, 0, 0, 28113, + 28114, 7, 5, 0, 0, 28114, 28115, 7, 18, 0, 0, 28115, 28116, 7, 5, 0, 0, + 28116, 28117, 5, 95, 0, 0, 28117, 28118, 7, 25, 0, 0, 28118, 28119, 7, + 24, 0, 0, 28119, 28120, 7, 5, 0, 0, 28120, 28121, 7, 6, 0, 0, 28121, 28122, + 7, 24, 0, 0, 28122, 28123, 7, 9, 0, 0, 28123, 28124, 7, 6, 0, 0, 28124, + 28125, 7, 6, 0, 0, 28125, 28126, 7, 15, 0, 0, 28126, 28127, 7, 6, 0, 0, + 28127, 28128, 7, 24, 0, 0, 28128, 4116, 1, 0, 0, 0, 28129, 28130, 7, 5, + 0, 0, 28130, 28131, 7, 18, 0, 0, 28131, 28132, 7, 5, 0, 0, 28132, 28133, + 5, 95, 0, 0, 28133, 28134, 7, 25, 0, 0, 28134, 28135, 7, 24, 0, 0, 28135, + 28136, 7, 5, 0, 0, 28136, 28137, 7, 6, 0, 0, 28137, 28138, 7, 24, 0, 0, + 28138, 28139, 7, 10, 0, 0, 28139, 28140, 7, 7, 0, 0, 28140, 28141, 7, 5, + 0, 0, 28141, 28142, 7, 1, 0, 0, 28142, 4118, 1, 0, 0, 0, 28143, 28144, + 7, 5, 0, 0, 28144, 28145, 7, 18, 0, 0, 28145, 28146, 7, 5, 0, 0, 28146, + 28147, 5, 95, 0, 0, 28147, 28148, 7, 25, 0, 0, 28148, 28149, 7, 24, 0, + 0, 28149, 28150, 7, 5, 0, 0, 28150, 28151, 7, 6, 0, 0, 28151, 28152, 7, + 24, 0, 0, 28152, 28153, 7, 3, 0, 0, 28153, 28154, 7, 14, 0, 0, 28154, 4120, + 1, 0, 0, 0, 28155, 28156, 7, 5, 0, 0, 28156, 28157, 7, 18, 0, 0, 28157, + 28158, 7, 5, 0, 0, 28158, 28159, 5, 95, 0, 0, 28159, 28160, 7, 25, 0, 0, + 28160, 28161, 7, 24, 0, 0, 28161, 28162, 7, 5, 0, 0, 28162, 28163, 7, 6, + 0, 0, 28163, 28164, 7, 24, 0, 0, 28164, 28165, 7, 3, 0, 0, 28165, 28166, + 7, 13, 0, 0, 28166, 28167, 7, 5, 0, 0, 28167, 4122, 1, 0, 0, 0, 28168, + 28169, 7, 5, 0, 0, 28169, 28170, 7, 18, 0, 0, 28170, 28171, 7, 5, 0, 0, + 28171, 28172, 5, 95, 0, 0, 28172, 28173, 7, 25, 0, 0, 28173, 28174, 7, + 24, 0, 0, 28174, 28175, 7, 5, 0, 0, 28175, 28176, 7, 6, 0, 0, 28176, 28177, + 7, 24, 0, 0, 28177, 28178, 7, 5, 0, 0, 28178, 28179, 7, 12, 0, 0, 28179, + 28180, 7, 1, 0, 0, 28180, 4124, 1, 0, 0, 0, 28181, 28182, 7, 5, 0, 0, 28182, + 28183, 7, 18, 0, 0, 28183, 28184, 7, 5, 0, 0, 28184, 28185, 5, 95, 0, 0, + 28185, 28186, 7, 25, 0, 0, 28186, 28187, 7, 24, 0, 0, 28187, 28188, 7, + 5, 0, 0, 28188, 28189, 7, 6, 0, 0, 28189, 28190, 7, 24, 0, 0, 28190, 28191, + 7, 4, 0, 0, 28191, 28192, 7, 18, 0, 0, 28192, 28193, 7, 15, 0, 0, 28193, + 28194, 7, 14, 0, 0, 28194, 28195, 7, 0, 0, 0, 28195, 28196, 7, 4, 0, 0, + 28196, 28197, 7, 8, 0, 0, 28197, 28198, 7, 19, 0, 0, 28198, 4126, 1, 0, + 0, 0, 28199, 28200, 7, 5, 0, 0, 28200, 28201, 7, 18, 0, 0, 28201, 28202, + 7, 5, 0, 0, 28202, 28203, 5, 95, 0, 0, 28203, 28204, 7, 25, 0, 0, 28204, + 28205, 7, 24, 0, 0, 28205, 28206, 7, 5, 0, 0, 28206, 28207, 7, 4, 0, 0, + 28207, 28208, 7, 0, 0, 0, 28208, 28209, 7, 3, 0, 0, 28209, 28210, 7, 4, + 0, 0, 28210, 28211, 7, 5, 0, 0, 28211, 28212, 7, 22, 0, 0, 28212, 28213, + 7, 10, 0, 0, 28213, 28214, 7, 4, 0, 0, 28214, 28215, 7, 19, 0, 0, 28215, + 4128, 1, 0, 0, 0, 28216, 28217, 7, 5, 0, 0, 28217, 28218, 7, 18, 0, 0, + 28218, 28219, 7, 5, 0, 0, 28219, 28220, 5, 95, 0, 0, 28220, 28221, 7, 25, + 0, 0, 28221, 28222, 7, 24, 0, 0, 28222, 28223, 7, 5, 0, 0, 28223, 28224, + 7, 4, 0, 0, 28224, 28225, 7, 0, 0, 0, 28225, 28226, 7, 4, 0, 0, 28226, + 28227, 7, 1, 0, 0, 28227, 28228, 7, 12, 0, 0, 28228, 28229, 7, 3, 0, 0, + 28229, 28230, 7, 10, 0, 0, 28230, 4130, 1, 0, 0, 0, 28231, 28232, 7, 5, + 0, 0, 28232, 28233, 7, 18, 0, 0, 28233, 28234, 7, 5, 0, 0, 28234, 28235, + 5, 95, 0, 0, 28235, 28236, 7, 25, 0, 0, 28236, 28237, 7, 24, 0, 0, 28237, + 28238, 7, 5, 0, 0, 28238, 28239, 7, 4, 0, 0, 28239, 28240, 7, 3, 0, 0, + 28240, 28241, 5, 50, 0, 0, 28241, 28242, 7, 8, 0, 0, 28242, 28243, 7, 2, + 0, 0, 28243, 28244, 7, 9, 0, 0, 28244, 28245, 7, 6, 0, 0, 28245, 28246, + 7, 15, 0, 0, 28246, 4132, 1, 0, 0, 0, 28247, 28248, 7, 5, 0, 0, 28248, + 28249, 7, 18, 0, 0, 28249, 28250, 7, 5, 0, 0, 28250, 28251, 5, 95, 0, 0, + 28251, 28252, 7, 25, 0, 0, 28252, 28253, 7, 24, 0, 0, 28253, 28254, 7, + 5, 0, 0, 28254, 28255, 7, 4, 0, 0, 28255, 28256, 7, 3, 0, 0, 28256, 28257, + 7, 20, 0, 0, 28257, 28258, 7, 2, 0, 0, 28258, 28259, 7, 10, 0, 0, 28259, + 28260, 7, 7, 0, 0, 28260, 4134, 1, 0, 0, 0, 28261, 28262, 7, 5, 0, 0, 28262, + 28263, 7, 18, 0, 0, 28263, 28264, 7, 5, 0, 0, 28264, 28265, 5, 95, 0, 0, + 28265, 28266, 7, 25, 0, 0, 28266, 28267, 7, 24, 0, 0, 28267, 28268, 7, + 5, 0, 0, 28268, 28269, 7, 12, 0, 0, 28269, 28270, 7, 1, 0, 0, 28270, 28271, + 7, 5, 0, 0, 28271, 28272, 7, 4, 0, 0, 28272, 28273, 7, 3, 0, 0, 28273, + 28274, 7, 0, 0, 0, 28274, 28275, 7, 16, 0, 0, 28275, 28276, 7, 4, 0, 0, + 28276, 4136, 1, 0, 0, 0, 28277, 28278, 7, 5, 0, 0, 28278, 28279, 7, 18, + 0, 0, 28279, 28280, 7, 5, 0, 0, 28280, 28281, 5, 95, 0, 0, 28281, 28282, + 7, 25, 0, 0, 28282, 28283, 7, 24, 0, 0, 28283, 28284, 7, 5, 0, 0, 28284, + 28285, 7, 12, 0, 0, 28285, 28286, 7, 1, 0, 0, 28286, 28287, 7, 5, 0, 0, + 28287, 28288, 7, 4, 0, 0, 28288, 28289, 7, 3, 0, 0, 28289, 28290, 7, 1, + 0, 0, 28290, 28291, 7, 6, 0, 0, 28291, 28292, 7, 16, 0, 0, 28292, 4138, + 1, 0, 0, 0, 28293, 28294, 7, 5, 0, 0, 28294, 28295, 7, 18, 0, 0, 28295, + 28296, 7, 5, 0, 0, 28296, 28297, 5, 95, 0, 0, 28297, 28298, 7, 25, 0, 0, + 28298, 28299, 7, 24, 0, 0, 28299, 28300, 7, 4, 0, 0, 28300, 28301, 7, 2, + 0, 0, 28301, 28302, 7, 21, 0, 0, 28302, 28303, 7, 6, 0, 0, 28303, 28304, + 7, 7, 0, 0, 28304, 28305, 7, 10, 0, 0, 28305, 28306, 7, 23, 0, 0, 28306, + 28307, 7, 6, 0, 0, 28307, 4140, 1, 0, 0, 0, 28308, 28309, 7, 5, 0, 0, 28309, + 28310, 7, 18, 0, 0, 28310, 28311, 7, 5, 0, 0, 28311, 28312, 5, 95, 0, 0, + 28312, 28313, 7, 25, 0, 0, 28313, 28314, 7, 24, 0, 0, 28314, 28315, 7, + 4, 0, 0, 28315, 28316, 7, 3, 0, 0, 28316, 28317, 7, 6, 0, 0, 28317, 28318, + 7, 0, 0, 0, 28318, 28319, 7, 4, 0, 0, 28319, 28320, 7, 0, 0, 0, 28320, + 28321, 7, 5, 0, 0, 28321, 4142, 1, 0, 0, 0, 28322, 28323, 7, 5, 0, 0, 28323, + 28324, 7, 18, 0, 0, 28324, 28325, 7, 5, 0, 0, 28325, 28326, 5, 95, 0, 0, + 28326, 28327, 7, 25, 0, 0, 28327, 28328, 7, 24, 0, 0, 28328, 28329, 5, + 95, 0, 0, 28329, 28330, 7, 12, 0, 0, 28330, 28331, 7, 15, 0, 0, 28331, + 28332, 7, 21, 0, 0, 28332, 28333, 7, 25, 0, 0, 28333, 28334, 7, 14, 0, + 0, 28334, 28335, 7, 11, 0, 0, 28335, 28336, 5, 50, 0, 0, 28336, 28337, + 7, 5, 0, 0, 28337, 28338, 7, 24, 0, 0, 28338, 28339, 7, 11, 0, 0, 28339, + 4144, 1, 0, 0, 0, 28340, 28341, 7, 5, 0, 0, 28341, 28342, 7, 18, 0, 0, + 28342, 28343, 7, 5, 0, 0, 28343, 28344, 5, 95, 0, 0, 28344, 28345, 7, 25, + 0, 0, 28345, 28346, 7, 24, 0, 0, 28346, 28347, 7, 25, 0, 0, 28347, 28348, + 7, 16, 0, 0, 28348, 28349, 7, 2, 0, 0, 28349, 28350, 7, 3, 0, 0, 28350, + 28351, 7, 14, 0, 0, 28351, 4146, 1, 0, 0, 0, 28352, 28353, 7, 5, 0, 0, + 28353, 28354, 7, 18, 0, 0, 28354, 28355, 7, 5, 0, 0, 28355, 28356, 5, 95, + 0, 0, 28356, 28357, 7, 25, 0, 0, 28357, 28358, 7, 5, 0, 0, 28358, 28359, + 7, 10, 0, 0, 28359, 28360, 7, 9, 0, 0, 28360, 28361, 5, 95, 0, 0, 28361, + 28362, 7, 4, 0, 0, 28362, 28363, 7, 2, 0, 0, 28363, 28364, 5, 95, 0, 0, + 28364, 28365, 7, 3, 0, 0, 28365, 28366, 7, 0, 0, 0, 28366, 28367, 7, 22, + 0, 0, 28367, 4148, 1, 0, 0, 0, 28368, 28369, 7, 5, 0, 0, 28369, 28370, + 7, 18, 0, 0, 28370, 28371, 7, 5, 0, 0, 28371, 28372, 5, 95, 0, 0, 28372, + 28373, 7, 23, 0, 0, 28373, 28374, 7, 14, 0, 0, 28374, 28375, 7, 0, 0, 0, + 28375, 28376, 7, 15, 0, 0, 28376, 28377, 5, 95, 0, 0, 28377, 28378, 7, + 16, 0, 0, 28378, 28379, 7, 10, 0, 0, 28379, 28380, 7, 11, 0, 0, 28380, + 28381, 7, 4, 0, 0, 28381, 28382, 7, 6, 0, 0, 28382, 28383, 7, 3, 0, 0, + 28383, 4150, 1, 0, 0, 0, 28384, 28385, 7, 5, 0, 0, 28385, 28386, 7, 18, + 0, 0, 28386, 28387, 7, 5, 0, 0, 28387, 28388, 5, 95, 0, 0, 28388, 28389, + 7, 23, 0, 0, 28389, 28390, 7, 14, 0, 0, 28390, 28391, 7, 0, 0, 0, 28391, + 28392, 7, 15, 0, 0, 28392, 28393, 5, 95, 0, 0, 28393, 28394, 7, 3, 0, 0, + 28394, 28395, 7, 6, 0, 0, 28395, 28396, 7, 16, 0, 0, 28396, 28397, 7, 3, + 0, 0, 28397, 28398, 7, 6, 0, 0, 28398, 28399, 7, 5, 0, 0, 28399, 28400, + 7, 19, 0, 0, 28400, 4152, 1, 0, 0, 0, 28401, 28402, 7, 4, 0, 0, 28402, + 4154, 1, 0, 0, 0, 28403, 28404, 7, 4, 0, 0, 28404, 28405, 7, 0, 0, 0, 28405, + 28406, 7, 1, 0, 0, 28406, 28407, 7, 11, 0, 0, 28407, 28408, 7, 6, 0, 0, + 28408, 28409, 5, 95, 0, 0, 28409, 28410, 7, 11, 0, 0, 28410, 28411, 7, + 2, 0, 0, 28411, 28412, 7, 2, 0, 0, 28412, 28413, 7, 21, 0, 0, 28413, 28414, + 7, 12, 0, 0, 28414, 28415, 7, 15, 0, 0, 28415, 28416, 5, 95, 0, 0, 28416, + 28417, 7, 1, 0, 0, 28417, 28418, 7, 18, 0, 0, 28418, 28419, 5, 95, 0, 0, + 28419, 28420, 7, 7, 0, 0, 28420, 28421, 7, 11, 0, 0, 28421, 4156, 1, 0, + 0, 0, 28422, 28423, 7, 4, 0, 0, 28423, 28424, 7, 0, 0, 0, 28424, 28425, + 7, 1, 0, 0, 28425, 28426, 7, 11, 0, 0, 28426, 28427, 7, 6, 0, 0, 28427, + 28428, 7, 5, 0, 0, 28428, 28429, 7, 15, 0, 0, 28429, 28430, 7, 0, 0, 0, + 28430, 28431, 7, 8, 0, 0, 28431, 28432, 7, 6, 0, 0, 28432, 28433, 5, 95, + 0, 0, 28433, 28434, 7, 7, 0, 0, 28434, 28435, 7, 2, 0, 0, 28435, 4158, + 1, 0, 0, 0, 28436, 28437, 7, 4, 0, 0, 28437, 28438, 7, 0, 0, 0, 28438, + 28439, 7, 1, 0, 0, 28439, 28440, 7, 11, 0, 0, 28440, 28441, 7, 6, 0, 0, + 28441, 28442, 7, 5, 0, 0, 28442, 28443, 7, 15, 0, 0, 28443, 28444, 7, 0, + 0, 0, 28444, 28445, 7, 8, 0, 0, 28445, 28446, 7, 6, 0, 0, 28446, 4160, + 1, 0, 0, 0, 28447, 28448, 7, 4, 0, 0, 28448, 28449, 7, 0, 0, 0, 28449, + 28450, 7, 1, 0, 0, 28450, 28451, 7, 11, 0, 0, 28451, 28452, 7, 6, 0, 0, + 28452, 28453, 7, 5, 0, 0, 28453, 4162, 1, 0, 0, 0, 28454, 28455, 7, 4, + 0, 0, 28455, 28456, 7, 0, 0, 0, 28456, 28457, 7, 1, 0, 0, 28457, 28458, + 7, 11, 0, 0, 28458, 28459, 7, 6, 0, 0, 28459, 28460, 5, 95, 0, 0, 28460, + 28461, 7, 5, 0, 0, 28461, 28462, 7, 4, 0, 0, 28462, 28463, 7, 0, 0, 0, + 28463, 28464, 7, 4, 0, 0, 28464, 28465, 7, 5, 0, 0, 28465, 4164, 1, 0, + 0, 0, 28466, 28467, 7, 4, 0, 0, 28467, 28468, 7, 0, 0, 0, 28468, 28469, + 7, 1, 0, 0, 28469, 28470, 7, 11, 0, 0, 28470, 28471, 7, 6, 0, 0, 28471, + 4166, 1, 0, 0, 0, 28472, 28473, 7, 4, 0, 0, 28473, 28474, 7, 0, 0, 0, 28474, + 28475, 7, 1, 0, 0, 28475, 28476, 7, 7, 0, 0, 28476, 28477, 7, 2, 0, 0, + 28477, 4168, 1, 0, 0, 0, 28478, 28479, 7, 4, 0, 0, 28479, 28480, 7, 0, + 0, 0, 28480, 28481, 7, 17, 0, 0, 28481, 4170, 1, 0, 0, 0, 28482, 28483, + 7, 4, 0, 0, 28483, 28484, 7, 0, 0, 0, 28484, 28485, 7, 7, 0, 0, 28485, + 28486, 7, 19, 0, 0, 28486, 4172, 1, 0, 0, 0, 28487, 28488, 7, 4, 0, 0, + 28488, 28489, 7, 0, 0, 0, 28489, 28490, 7, 7, 0, 0, 28490, 4174, 1, 0, + 0, 0, 28491, 28492, 7, 4, 0, 0, 28492, 28493, 7, 1, 0, 0, 28493, 28494, + 7, 11, 0, 0, 28494, 28495, 5, 36, 0, 0, 28495, 28496, 7, 2, 0, 0, 28496, + 28497, 7, 3, 0, 0, 28497, 28498, 5, 36, 0, 0, 28498, 28499, 7, 10, 0, 0, + 28499, 28500, 7, 9, 0, 0, 28500, 28501, 7, 25, 0, 0, 28501, 28502, 5, 36, + 0, 0, 28502, 28503, 7, 15, 0, 0, 28503, 28504, 7, 0, 0, 0, 28504, 28505, + 7, 3, 0, 0, 28505, 28506, 7, 4, 0, 0, 28506, 28507, 5, 36, 0, 0, 28507, + 28508, 7, 7, 0, 0, 28508, 28509, 7, 12, 0, 0, 28509, 28510, 7, 14, 0, 0, + 28510, 4176, 1, 0, 0, 0, 28511, 28512, 7, 4, 0, 0, 28512, 28513, 7, 6, + 0, 0, 28513, 28514, 7, 14, 0, 0, 28514, 28515, 7, 15, 0, 0, 28515, 28516, + 7, 16, 0, 0, 28516, 28517, 7, 10, 0, 0, 28517, 28518, 7, 11, 0, 0, 28518, + 28519, 7, 6, 0, 0, 28519, 4178, 1, 0, 0, 0, 28520, 28521, 7, 4, 0, 0, 28521, + 28522, 7, 6, 0, 0, 28522, 28523, 7, 14, 0, 0, 28523, 28524, 7, 15, 0, 0, + 28524, 28525, 7, 11, 0, 0, 28525, 28526, 7, 0, 0, 0, 28526, 28527, 7, 4, + 0, 0, 28527, 28528, 7, 6, 0, 0, 28528, 4180, 1, 0, 0, 0, 28529, 28530, + 7, 4, 0, 0, 28530, 28531, 7, 6, 0, 0, 28531, 28532, 7, 14, 0, 0, 28532, + 28533, 7, 15, 0, 0, 28533, 28534, 7, 11, 0, 0, 28534, 28535, 7, 0, 0, 0, + 28535, 28536, 7, 4, 0, 0, 28536, 28537, 7, 6, 0, 0, 28537, 28538, 5, 95, + 0, 0, 28538, 28539, 7, 4, 0, 0, 28539, 28540, 7, 0, 0, 0, 28540, 28541, + 7, 1, 0, 0, 28541, 28542, 7, 11, 0, 0, 28542, 28543, 7, 6, 0, 0, 28543, + 4182, 1, 0, 0, 0, 28544, 28545, 7, 4, 0, 0, 28545, 28546, 7, 6, 0, 0, 28546, + 28547, 7, 14, 0, 0, 28547, 28548, 7, 15, 0, 0, 28548, 28549, 7, 2, 0, 0, + 28549, 28550, 7, 3, 0, 0, 28550, 28551, 7, 0, 0, 0, 28551, 28552, 7, 3, + 0, 0, 28552, 28553, 7, 18, 0, 0, 28553, 4184, 1, 0, 0, 0, 28554, 28555, + 7, 4, 0, 0, 28555, 28556, 7, 6, 0, 0, 28556, 28557, 7, 14, 0, 0, 28557, + 28558, 7, 15, 0, 0, 28558, 28559, 5, 95, 0, 0, 28559, 28560, 7, 4, 0, 0, + 28560, 28561, 7, 0, 0, 0, 28561, 28562, 7, 1, 0, 0, 28562, 28563, 7, 11, + 0, 0, 28563, 28564, 7, 6, 0, 0, 28564, 4186, 1, 0, 0, 0, 28565, 28566, + 7, 4, 0, 0, 28566, 28567, 7, 6, 0, 0, 28567, 28568, 7, 3, 0, 0, 28568, + 28569, 7, 14, 0, 0, 28569, 28570, 7, 10, 0, 0, 28570, 28571, 7, 7, 0, 0, + 28571, 28572, 7, 0, 0, 0, 28572, 28573, 7, 4, 0, 0, 28573, 28574, 7, 6, + 0, 0, 28574, 28575, 7, 9, 0, 0, 28575, 4188, 1, 0, 0, 0, 28576, 28577, + 7, 4, 0, 0, 28577, 28578, 7, 6, 0, 0, 28578, 28579, 7, 5, 0, 0, 28579, + 28580, 7, 4, 0, 0, 28580, 4190, 1, 0, 0, 0, 28581, 28582, 7, 4, 0, 0, 28582, + 28583, 7, 6, 0, 0, 28583, 28584, 7, 25, 0, 0, 28584, 28585, 7, 4, 0, 0, + 28585, 4192, 1, 0, 0, 0, 28586, 28587, 7, 4, 0, 0, 28587, 28588, 7, 6, + 0, 0, 28588, 28589, 7, 25, 0, 0, 28589, 28590, 7, 4, 0, 0, 28590, 28591, + 7, 16, 0, 0, 28591, 28592, 7, 10, 0, 0, 28592, 28593, 7, 11, 0, 0, 28593, + 28594, 7, 6, 0, 0, 28594, 4194, 1, 0, 0, 0, 28595, 28596, 7, 4, 0, 0, 28596, + 28597, 7, 19, 0, 0, 28597, 28598, 7, 0, 0, 0, 28598, 28599, 7, 7, 0, 0, + 28599, 4196, 1, 0, 0, 0, 28600, 28601, 7, 4, 0, 0, 28601, 28602, 7, 19, + 0, 0, 28602, 28603, 7, 6, 0, 0, 28603, 28604, 7, 7, 0, 0, 28604, 4198, + 1, 0, 0, 0, 28605, 28606, 7, 4, 0, 0, 28606, 28607, 7, 19, 0, 0, 28607, + 28608, 7, 6, 0, 0, 28608, 4200, 1, 0, 0, 0, 28609, 28610, 7, 4, 0, 0, 28610, + 28611, 7, 19, 0, 0, 28611, 28612, 7, 6, 0, 0, 28612, 28613, 7, 5, 0, 0, + 28613, 28614, 7, 6, 0, 0, 28614, 4202, 1, 0, 0, 0, 28615, 28616, 7, 4, + 0, 0, 28616, 28617, 7, 19, 0, 0, 28617, 28618, 7, 3, 0, 0, 28618, 28619, + 7, 6, 0, 0, 28619, 28620, 7, 0, 0, 0, 28620, 28621, 7, 9, 0, 0, 28621, + 4204, 1, 0, 0, 0, 28622, 28623, 7, 4, 0, 0, 28623, 28624, 7, 19, 0, 0, + 28624, 28625, 7, 3, 0, 0, 28625, 28626, 7, 2, 0, 0, 28626, 28627, 7, 12, + 0, 0, 28627, 28628, 7, 17, 0, 0, 28628, 28629, 7, 19, 0, 0, 28629, 4206, + 1, 0, 0, 0, 28630, 28631, 7, 4, 0, 0, 28631, 28632, 7, 10, 0, 0, 28632, + 28633, 7, 6, 0, 0, 28633, 28634, 7, 3, 0, 0, 28634, 4208, 1, 0, 0, 0, 28635, + 28636, 7, 4, 0, 0, 28636, 28637, 7, 10, 0, 0, 28637, 28638, 7, 6, 0, 0, + 28638, 28639, 7, 5, 0, 0, 28639, 4210, 1, 0, 0, 0, 28640, 28641, 7, 4, + 0, 0, 28641, 28642, 7, 10, 0, 0, 28642, 28643, 7, 14, 0, 0, 28643, 28644, + 7, 6, 0, 0, 28644, 28645, 7, 2, 0, 0, 28645, 28646, 7, 12, 0, 0, 28646, + 28647, 7, 4, 0, 0, 28647, 4212, 1, 0, 0, 0, 28648, 28649, 7, 4, 0, 0, 28649, + 28650, 7, 10, 0, 0, 28650, 28651, 7, 14, 0, 0, 28651, 28652, 7, 6, 0, 0, + 28652, 28653, 7, 5, 0, 0, 28653, 28654, 7, 4, 0, 0, 28654, 28655, 7, 0, + 0, 0, 28655, 28656, 7, 14, 0, 0, 28656, 28657, 7, 15, 0, 0, 28657, 28658, + 5, 95, 0, 0, 28658, 28659, 7, 11, 0, 0, 28659, 28660, 7, 4, 0, 0, 28660, + 28661, 7, 23, 0, 0, 28661, 28662, 5, 95, 0, 0, 28662, 28663, 7, 12, 0, + 0, 28663, 28664, 7, 7, 0, 0, 28664, 28665, 7, 8, 0, 0, 28665, 28666, 7, + 2, 0, 0, 28666, 28667, 7, 7, 0, 0, 28667, 28668, 7, 5, 0, 0, 28668, 28669, + 7, 4, 0, 0, 28669, 28670, 7, 3, 0, 0, 28670, 28671, 7, 0, 0, 0, 28671, + 28672, 7, 10, 0, 0, 28672, 28673, 7, 7, 0, 0, 28673, 28674, 7, 6, 0, 0, + 28674, 28675, 7, 9, 0, 0, 28675, 4214, 1, 0, 0, 0, 28676, 28677, 7, 4, + 0, 0, 28677, 28678, 7, 10, 0, 0, 28678, 28679, 7, 14, 0, 0, 28679, 28680, + 7, 6, 0, 0, 28680, 28681, 7, 5, 0, 0, 28681, 28682, 7, 4, 0, 0, 28682, + 28683, 7, 0, 0, 0, 28683, 28684, 7, 14, 0, 0, 28684, 28685, 7, 15, 0, 0, + 28685, 4216, 1, 0, 0, 0, 28686, 28687, 7, 4, 0, 0, 28687, 28688, 7, 10, + 0, 0, 28688, 28689, 7, 14, 0, 0, 28689, 28690, 7, 6, 0, 0, 28690, 28691, + 7, 5, 0, 0, 28691, 28692, 7, 4, 0, 0, 28692, 28693, 7, 0, 0, 0, 28693, + 28694, 7, 14, 0, 0, 28694, 28695, 7, 15, 0, 0, 28695, 28696, 5, 95, 0, + 0, 28696, 28697, 7, 4, 0, 0, 28697, 28698, 7, 23, 0, 0, 28698, 28699, 5, + 95, 0, 0, 28699, 28700, 7, 12, 0, 0, 28700, 28701, 7, 7, 0, 0, 28701, 28702, + 7, 8, 0, 0, 28702, 28703, 7, 2, 0, 0, 28703, 28704, 7, 7, 0, 0, 28704, + 28705, 7, 5, 0, 0, 28705, 28706, 7, 4, 0, 0, 28706, 28707, 7, 3, 0, 0, + 28707, 28708, 7, 0, 0, 0, 28708, 28709, 7, 10, 0, 0, 28709, 28710, 7, 7, + 0, 0, 28710, 28711, 7, 6, 0, 0, 28711, 28712, 7, 9, 0, 0, 28712, 4218, + 1, 0, 0, 0, 28713, 28714, 7, 4, 0, 0, 28714, 28715, 7, 10, 0, 0, 28715, + 28716, 7, 14, 0, 0, 28716, 28717, 7, 6, 0, 0, 28717, 28718, 7, 5, 0, 0, + 28718, 28719, 7, 4, 0, 0, 28719, 28720, 7, 0, 0, 0, 28720, 28721, 7, 14, + 0, 0, 28721, 28722, 7, 15, 0, 0, 28722, 28723, 5, 95, 0, 0, 28723, 28724, + 7, 12, 0, 0, 28724, 28725, 7, 7, 0, 0, 28725, 28726, 7, 8, 0, 0, 28726, + 28727, 7, 2, 0, 0, 28727, 28728, 7, 7, 0, 0, 28728, 28729, 7, 5, 0, 0, + 28729, 28730, 7, 4, 0, 0, 28730, 28731, 7, 3, 0, 0, 28731, 28732, 7, 0, + 0, 0, 28732, 28733, 7, 10, 0, 0, 28733, 28734, 7, 7, 0, 0, 28734, 28735, + 7, 6, 0, 0, 28735, 28736, 7, 9, 0, 0, 28736, 4220, 1, 0, 0, 0, 28737, 28738, + 7, 4, 0, 0, 28738, 28739, 7, 10, 0, 0, 28739, 28740, 7, 14, 0, 0, 28740, + 28741, 7, 6, 0, 0, 28741, 28742, 7, 5, 0, 0, 28742, 4222, 1, 0, 0, 0, 28743, + 28744, 7, 4, 0, 0, 28744, 28745, 7, 10, 0, 0, 28745, 28746, 7, 14, 0, 0, + 28746, 28747, 7, 6, 0, 0, 28747, 4224, 1, 0, 0, 0, 28748, 28749, 7, 4, + 0, 0, 28749, 28750, 7, 10, 0, 0, 28750, 28751, 7, 14, 0, 0, 28751, 28752, + 7, 6, 0, 0, 28752, 28753, 7, 23, 0, 0, 28753, 28754, 7, 2, 0, 0, 28754, + 28755, 7, 7, 0, 0, 28755, 28756, 7, 6, 0, 0, 28756, 4226, 1, 0, 0, 0, 28757, + 28758, 7, 4, 0, 0, 28758, 28759, 7, 10, 0, 0, 28759, 28760, 7, 14, 0, 0, + 28760, 28761, 7, 6, 0, 0, 28761, 28762, 7, 23, 0, 0, 28762, 28763, 7, 2, + 0, 0, 28763, 28764, 7, 7, 0, 0, 28764, 28765, 7, 6, 0, 0, 28765, 28766, + 5, 95, 0, 0, 28766, 28767, 7, 0, 0, 0, 28767, 28768, 7, 1, 0, 0, 28768, + 28769, 7, 1, 0, 0, 28769, 28770, 7, 3, 0, 0, 28770, 4228, 1, 0, 0, 0, 28771, + 28772, 7, 4, 0, 0, 28772, 28773, 7, 10, 0, 0, 28773, 28774, 7, 14, 0, 0, + 28774, 28775, 7, 6, 0, 0, 28775, 28776, 7, 23, 0, 0, 28776, 28777, 7, 2, + 0, 0, 28777, 28778, 7, 7, 0, 0, 28778, 28779, 7, 6, 0, 0, 28779, 28780, + 5, 95, 0, 0, 28780, 28781, 7, 19, 0, 0, 28781, 28782, 7, 2, 0, 0, 28782, + 28783, 7, 12, 0, 0, 28783, 28784, 7, 3, 0, 0, 28784, 4230, 1, 0, 0, 0, + 28785, 28786, 7, 4, 0, 0, 28786, 28787, 7, 10, 0, 0, 28787, 28788, 7, 14, + 0, 0, 28788, 28789, 7, 6, 0, 0, 28789, 28790, 7, 23, 0, 0, 28790, 28791, + 7, 2, 0, 0, 28791, 28792, 7, 7, 0, 0, 28792, 28793, 7, 6, 0, 0, 28793, + 28794, 5, 95, 0, 0, 28794, 28795, 7, 14, 0, 0, 28795, 28796, 7, 10, 0, + 0, 28796, 28797, 7, 7, 0, 0, 28797, 28798, 7, 12, 0, 0, 28798, 28799, 7, + 4, 0, 0, 28799, 28800, 7, 6, 0, 0, 28800, 4232, 1, 0, 0, 0, 28801, 28802, + 7, 4, 0, 0, 28802, 28803, 7, 10, 0, 0, 28803, 28804, 7, 14, 0, 0, 28804, + 28805, 7, 6, 0, 0, 28805, 28806, 7, 23, 0, 0, 28806, 28807, 7, 2, 0, 0, + 28807, 28808, 7, 7, 0, 0, 28808, 28809, 7, 6, 0, 0, 28809, 28810, 5, 95, + 0, 0, 28810, 28811, 7, 2, 0, 0, 28811, 28812, 7, 16, 0, 0, 28812, 28813, + 7, 16, 0, 0, 28813, 28814, 7, 5, 0, 0, 28814, 28815, 7, 6, 0, 0, 28815, + 28816, 7, 4, 0, 0, 28816, 4234, 1, 0, 0, 0, 28817, 28818, 7, 4, 0, 0, 28818, + 28819, 7, 10, 0, 0, 28819, 28820, 7, 14, 0, 0, 28820, 28821, 7, 6, 0, 0, + 28821, 28822, 7, 23, 0, 0, 28822, 28823, 7, 2, 0, 0, 28823, 28824, 7, 7, + 0, 0, 28824, 28825, 7, 6, 0, 0, 28825, 28826, 5, 95, 0, 0, 28826, 28827, + 7, 3, 0, 0, 28827, 28828, 7, 6, 0, 0, 28828, 28829, 7, 17, 0, 0, 28829, + 28830, 7, 10, 0, 0, 28830, 28831, 7, 2, 0, 0, 28831, 28832, 7, 7, 0, 0, + 28832, 4236, 1, 0, 0, 0, 28833, 28834, 7, 4, 0, 0, 28834, 28835, 7, 10, + 0, 0, 28835, 28836, 7, 14, 0, 0, 28836, 28837, 7, 6, 0, 0, 28837, 28838, + 5, 95, 0, 0, 28838, 28839, 7, 23, 0, 0, 28839, 28840, 7, 2, 0, 0, 28840, + 28841, 7, 7, 0, 0, 28841, 28842, 7, 6, 0, 0, 28842, 4238, 1, 0, 0, 0, 28843, + 28844, 7, 4, 0, 0, 28844, 28845, 7, 10, 0, 0, 28845, 28846, 7, 14, 0, 0, + 28846, 28847, 7, 10, 0, 0, 28847, 28848, 7, 7, 0, 0, 28848, 28849, 7, 17, + 0, 0, 28849, 4240, 1, 0, 0, 0, 28850, 28851, 7, 4, 0, 0, 28851, 28852, + 7, 10, 0, 0, 28852, 28853, 7, 7, 0, 0, 28853, 28854, 7, 18, 0, 0, 28854, + 28855, 7, 10, 0, 0, 28855, 28856, 7, 7, 0, 0, 28856, 28857, 7, 4, 0, 0, + 28857, 4242, 1, 0, 0, 0, 28858, 28859, 7, 4, 0, 0, 28859, 28860, 7, 10, + 0, 0, 28860, 28861, 7, 13, 0, 0, 28861, 28862, 5, 95, 0, 0, 28862, 28863, + 7, 17, 0, 0, 28863, 28864, 7, 1, 0, 0, 28864, 4244, 1, 0, 0, 0, 28865, + 28866, 7, 4, 0, 0, 28866, 28867, 7, 10, 0, 0, 28867, 28868, 7, 13, 0, 0, + 28868, 28869, 5, 95, 0, 0, 28869, 28870, 7, 5, 0, 0, 28870, 28871, 7, 5, + 0, 0, 28871, 28872, 7, 16, 0, 0, 28872, 4246, 1, 0, 0, 0, 28873, 28874, + 7, 4, 0, 0, 28874, 28875, 7, 2, 0, 0, 28875, 28876, 5, 95, 0, 0, 28876, + 28877, 7, 0, 0, 0, 28877, 28878, 7, 8, 0, 0, 28878, 28879, 7, 11, 0, 0, + 28879, 28880, 7, 10, 0, 0, 28880, 28881, 7, 9, 0, 0, 28881, 4248, 1, 0, + 0, 0, 28882, 28883, 7, 4, 0, 0, 28883, 28884, 7, 2, 0, 0, 28884, 28885, + 5, 95, 0, 0, 28885, 28886, 7, 1, 0, 0, 28886, 28887, 7, 10, 0, 0, 28887, + 28888, 7, 7, 0, 0, 28888, 28889, 7, 0, 0, 0, 28889, 28890, 7, 3, 0, 0, + 28890, 28891, 7, 18, 0, 0, 28891, 28892, 5, 95, 0, 0, 28892, 28893, 7, + 9, 0, 0, 28893, 28894, 7, 2, 0, 0, 28894, 28895, 7, 12, 0, 0, 28895, 28896, + 7, 1, 0, 0, 28896, 28897, 7, 11, 0, 0, 28897, 28898, 7, 6, 0, 0, 28898, + 4250, 1, 0, 0, 0, 28899, 28900, 7, 4, 0, 0, 28900, 28901, 7, 2, 0, 0, 28901, + 28902, 5, 95, 0, 0, 28902, 28903, 7, 1, 0, 0, 28903, 28904, 7, 10, 0, 0, + 28904, 28905, 7, 7, 0, 0, 28905, 28906, 7, 0, 0, 0, 28906, 28907, 7, 3, + 0, 0, 28907, 28908, 7, 18, 0, 0, 28908, 28909, 5, 95, 0, 0, 28909, 28910, + 7, 16, 0, 0, 28910, 28911, 7, 11, 0, 0, 28911, 28912, 7, 2, 0, 0, 28912, + 28913, 7, 0, 0, 0, 28913, 28914, 7, 4, 0, 0, 28914, 4252, 1, 0, 0, 0, 28915, + 28916, 7, 4, 0, 0, 28916, 28917, 7, 2, 0, 0, 28917, 28918, 5, 95, 0, 0, + 28918, 28919, 7, 1, 0, 0, 28919, 28920, 7, 11, 0, 0, 28920, 28921, 7, 2, + 0, 0, 28921, 28922, 7, 1, 0, 0, 28922, 4254, 1, 0, 0, 0, 28923, 28924, + 7, 4, 0, 0, 28924, 28925, 7, 2, 0, 0, 28925, 28926, 5, 95, 0, 0, 28926, + 28927, 7, 8, 0, 0, 28927, 28928, 7, 11, 0, 0, 28928, 28929, 7, 2, 0, 0, + 28929, 28930, 7, 1, 0, 0, 28930, 4256, 1, 0, 0, 0, 28931, 28932, 7, 4, + 0, 0, 28932, 28933, 7, 2, 0, 0, 28933, 28934, 5, 95, 0, 0, 28934, 28935, + 7, 9, 0, 0, 28935, 28936, 7, 5, 0, 0, 28936, 28937, 7, 10, 0, 0, 28937, + 28938, 7, 7, 0, 0, 28938, 28939, 7, 4, 0, 0, 28939, 28940, 7, 6, 0, 0, + 28940, 28941, 7, 3, 0, 0, 28941, 28942, 7, 13, 0, 0, 28942, 28943, 7, 0, + 0, 0, 28943, 28944, 7, 11, 0, 0, 28944, 4258, 1, 0, 0, 0, 28945, 28946, + 7, 4, 0, 0, 28946, 28947, 7, 2, 0, 0, 28947, 28948, 5, 95, 0, 0, 28948, + 28949, 7, 11, 0, 0, 28949, 28950, 7, 2, 0, 0, 28950, 28951, 7, 1, 0, 0, + 28951, 4260, 1, 0, 0, 0, 28952, 28953, 7, 4, 0, 0, 28953, 28954, 7, 2, + 0, 0, 28954, 28955, 5, 95, 0, 0, 28955, 28956, 7, 14, 0, 0, 28956, 28957, + 7, 12, 0, 0, 28957, 28958, 7, 11, 0, 0, 28958, 28959, 7, 4, 0, 0, 28959, + 28960, 7, 10, 0, 0, 28960, 28961, 5, 95, 0, 0, 28961, 28962, 7, 1, 0, 0, + 28962, 28963, 7, 18, 0, 0, 28963, 28964, 7, 4, 0, 0, 28964, 28965, 7, 6, + 0, 0, 28965, 4262, 1, 0, 0, 0, 28966, 28967, 7, 4, 0, 0, 28967, 28968, + 7, 2, 0, 0, 28968, 28969, 5, 95, 0, 0, 28969, 28970, 7, 7, 0, 0, 28970, + 28971, 7, 8, 0, 0, 28971, 28972, 7, 19, 0, 0, 28972, 28973, 7, 0, 0, 0, + 28973, 28974, 7, 3, 0, 0, 28974, 4264, 1, 0, 0, 0, 28975, 28976, 7, 4, + 0, 0, 28976, 28977, 7, 2, 0, 0, 28977, 28978, 5, 95, 0, 0, 28978, 28979, + 7, 7, 0, 0, 28979, 28980, 7, 8, 0, 0, 28980, 28981, 7, 11, 0, 0, 28981, + 28982, 7, 2, 0, 0, 28982, 28983, 7, 1, 0, 0, 28983, 4266, 1, 0, 0, 0, 28984, + 28985, 7, 4, 0, 0, 28985, 28986, 7, 2, 0, 0, 28986, 28987, 5, 95, 0, 0, + 28987, 28988, 7, 7, 0, 0, 28988, 28989, 7, 12, 0, 0, 28989, 28990, 7, 14, + 0, 0, 28990, 28991, 7, 1, 0, 0, 28991, 28992, 7, 6, 0, 0, 28992, 28993, + 7, 3, 0, 0, 28993, 4268, 1, 0, 0, 0, 28994, 28995, 7, 4, 0, 0, 28995, 28996, + 7, 2, 0, 0, 28996, 28997, 7, 15, 0, 0, 28997, 28998, 7, 11, 0, 0, 28998, + 28999, 7, 6, 0, 0, 28999, 29000, 7, 13, 0, 0, 29000, 29001, 7, 6, 0, 0, + 29001, 29002, 7, 11, 0, 0, 29002, 4270, 1, 0, 0, 0, 29003, 29004, 7, 4, + 0, 0, 29004, 29005, 7, 2, 0, 0, 29005, 29006, 5, 95, 0, 0, 29006, 29007, + 7, 5, 0, 0, 29007, 29008, 7, 10, 0, 0, 29008, 29009, 7, 7, 0, 0, 29009, + 29010, 7, 17, 0, 0, 29010, 29011, 7, 11, 0, 0, 29011, 29012, 7, 6, 0, 0, + 29012, 29013, 5, 95, 0, 0, 29013, 29014, 7, 1, 0, 0, 29014, 29015, 7, 18, + 0, 0, 29015, 29016, 7, 4, 0, 0, 29016, 29017, 7, 6, 0, 0, 29017, 4272, + 1, 0, 0, 0, 29018, 29019, 7, 4, 0, 0, 29019, 29020, 7, 2, 0, 0, 29020, + 29021, 5, 95, 0, 0, 29021, 29022, 7, 4, 0, 0, 29022, 29023, 7, 10, 0, 0, + 29023, 29024, 7, 14, 0, 0, 29024, 29025, 7, 6, 0, 0, 29025, 29026, 7, 5, + 0, 0, 29026, 29027, 7, 4, 0, 0, 29027, 29028, 7, 0, 0, 0, 29028, 29029, + 7, 14, 0, 0, 29029, 29030, 7, 15, 0, 0, 29030, 4274, 1, 0, 0, 0, 29031, + 29032, 7, 4, 0, 0, 29032, 29033, 7, 2, 0, 0, 29033, 29034, 5, 95, 0, 0, + 29034, 29035, 7, 4, 0, 0, 29035, 29036, 7, 10, 0, 0, 29036, 29037, 7, 14, + 0, 0, 29037, 29038, 7, 6, 0, 0, 29038, 29039, 7, 5, 0, 0, 29039, 29040, + 7, 4, 0, 0, 29040, 29041, 7, 0, 0, 0, 29041, 29042, 7, 14, 0, 0, 29042, + 29043, 7, 15, 0, 0, 29043, 29044, 5, 95, 0, 0, 29044, 29045, 7, 4, 0, 0, + 29045, 29046, 7, 23, 0, 0, 29046, 4276, 1, 0, 0, 0, 29047, 29048, 7, 4, + 0, 0, 29048, 29049, 7, 2, 0, 0, 29049, 29050, 5, 95, 0, 0, 29050, 29051, + 7, 4, 0, 0, 29051, 29052, 7, 10, 0, 0, 29052, 29053, 7, 14, 0, 0, 29053, + 29054, 7, 6, 0, 0, 29054, 4278, 1, 0, 0, 0, 29055, 29056, 7, 4, 0, 0, 29056, + 29057, 7, 2, 0, 0, 29057, 29058, 5, 95, 0, 0, 29058, 29059, 7, 4, 0, 0, + 29059, 29060, 7, 10, 0, 0, 29060, 29061, 7, 14, 0, 0, 29061, 29062, 7, + 6, 0, 0, 29062, 29063, 5, 95, 0, 0, 29063, 29064, 7, 4, 0, 0, 29064, 29065, + 7, 23, 0, 0, 29065, 4280, 1, 0, 0, 0, 29066, 29067, 7, 4, 0, 0, 29067, + 29068, 7, 2, 0, 0, 29068, 4282, 1, 0, 0, 0, 29069, 29070, 7, 4, 0, 0, 29070, + 29071, 7, 2, 0, 0, 29071, 29072, 5, 95, 0, 0, 29072, 29073, 7, 18, 0, 0, + 29073, 29074, 7, 14, 0, 0, 29074, 29075, 7, 10, 0, 0, 29075, 29076, 7, + 7, 0, 0, 29076, 29077, 7, 4, 0, 0, 29077, 29078, 7, 6, 0, 0, 29078, 29079, + 7, 3, 0, 0, 29079, 29080, 7, 13, 0, 0, 29080, 29081, 7, 0, 0, 0, 29081, + 29082, 7, 11, 0, 0, 29082, 4284, 1, 0, 0, 0, 29083, 29084, 7, 4, 0, 0, + 29084, 29085, 7, 3, 0, 0, 29085, 29086, 7, 0, 0, 0, 29086, 29087, 7, 8, + 0, 0, 29087, 29088, 7, 6, 0, 0, 29088, 4286, 1, 0, 0, 0, 29089, 29090, + 7, 4, 0, 0, 29090, 29091, 7, 3, 0, 0, 29091, 29092, 7, 0, 0, 0, 29092, + 29093, 7, 8, 0, 0, 29093, 29094, 7, 10, 0, 0, 29094, 29095, 7, 7, 0, 0, + 29095, 29096, 7, 17, 0, 0, 29096, 4288, 1, 0, 0, 0, 29097, 29098, 7, 4, + 0, 0, 29098, 29099, 7, 3, 0, 0, 29099, 29100, 7, 0, 0, 0, 29100, 29101, + 7, 8, 0, 0, 29101, 29102, 7, 21, 0, 0, 29102, 29103, 7, 10, 0, 0, 29103, + 29104, 7, 7, 0, 0, 29104, 29105, 7, 17, 0, 0, 29105, 4290, 1, 0, 0, 0, + 29106, 29107, 7, 4, 0, 0, 29107, 29108, 7, 3, 0, 0, 29108, 29109, 7, 0, + 0, 0, 29109, 29110, 7, 10, 0, 0, 29110, 29111, 7, 11, 0, 0, 29111, 29112, + 7, 10, 0, 0, 29112, 29113, 7, 7, 0, 0, 29113, 29114, 7, 17, 0, 0, 29114, + 4292, 1, 0, 0, 0, 29115, 29116, 7, 4, 0, 0, 29116, 29117, 7, 3, 0, 0, 29117, + 29118, 7, 0, 0, 0, 29118, 29119, 7, 7, 0, 0, 29119, 29120, 7, 5, 0, 0, + 29120, 29121, 7, 0, 0, 0, 29121, 29122, 7, 8, 0, 0, 29122, 29123, 7, 4, + 0, 0, 29123, 29124, 7, 10, 0, 0, 29124, 29125, 7, 2, 0, 0, 29125, 29126, + 7, 7, 0, 0, 29126, 4294, 1, 0, 0, 0, 29127, 29128, 7, 4, 0, 0, 29128, 29129, + 7, 3, 0, 0, 29129, 29130, 7, 0, 0, 0, 29130, 29131, 7, 7, 0, 0, 29131, + 29132, 7, 5, 0, 0, 29132, 29133, 7, 16, 0, 0, 29133, 29134, 7, 2, 0, 0, + 29134, 29135, 7, 3, 0, 0, 29135, 29136, 7, 14, 0, 0, 29136, 4296, 1, 0, + 0, 0, 29137, 29138, 7, 4, 0, 0, 29138, 29139, 7, 3, 0, 0, 29139, 29140, + 7, 0, 0, 0, 29140, 29141, 7, 7, 0, 0, 29141, 29142, 7, 5, 0, 0, 29142, + 29143, 7, 16, 0, 0, 29143, 29144, 7, 2, 0, 0, 29144, 29145, 7, 3, 0, 0, + 29145, 29146, 7, 14, 0, 0, 29146, 29147, 7, 5, 0, 0, 29147, 4298, 1, 0, + 0, 0, 29148, 29149, 7, 4, 0, 0, 29149, 29150, 7, 3, 0, 0, 29150, 29151, + 7, 0, 0, 0, 29151, 29152, 7, 7, 0, 0, 29152, 29153, 7, 5, 0, 0, 29153, + 29154, 7, 16, 0, 0, 29154, 29155, 7, 2, 0, 0, 29155, 29156, 7, 3, 0, 0, + 29156, 29157, 7, 14, 0, 0, 29157, 29158, 5, 95, 0, 0, 29158, 29159, 7, + 9, 0, 0, 29159, 29160, 7, 10, 0, 0, 29160, 29161, 7, 5, 0, 0, 29161, 29162, + 7, 4, 0, 0, 29162, 29163, 7, 10, 0, 0, 29163, 29164, 7, 7, 0, 0, 29164, + 29165, 7, 8, 0, 0, 29165, 29166, 7, 4, 0, 0, 29166, 29167, 5, 95, 0, 0, + 29167, 29168, 7, 0, 0, 0, 29168, 29169, 7, 17, 0, 0, 29169, 29170, 7, 17, + 0, 0, 29170, 4300, 1, 0, 0, 0, 29171, 29172, 7, 4, 0, 0, 29172, 29173, + 7, 3, 0, 0, 29173, 29174, 7, 0, 0, 0, 29174, 29175, 7, 7, 0, 0, 29175, + 29176, 7, 5, 0, 0, 29176, 29177, 7, 10, 0, 0, 29177, 29178, 7, 4, 0, 0, + 29178, 29179, 7, 10, 0, 0, 29179, 29180, 7, 2, 0, 0, 29180, 29181, 7, 7, + 0, 0, 29181, 29182, 7, 0, 0, 0, 29182, 29183, 7, 11, 0, 0, 29183, 4302, + 1, 0, 0, 0, 29184, 29185, 7, 4, 0, 0, 29185, 29186, 7, 3, 0, 0, 29186, + 29187, 7, 0, 0, 0, 29187, 29188, 7, 7, 0, 0, 29188, 29189, 7, 5, 0, 0, + 29189, 29190, 7, 10, 0, 0, 29190, 29191, 7, 4, 0, 0, 29191, 29192, 7, 10, + 0, 0, 29192, 29193, 7, 2, 0, 0, 29193, 29194, 7, 7, 0, 0, 29194, 4304, + 1, 0, 0, 0, 29195, 29196, 7, 4, 0, 0, 29196, 29197, 7, 3, 0, 0, 29197, + 29198, 7, 0, 0, 0, 29198, 29199, 7, 7, 0, 0, 29199, 29200, 7, 5, 0, 0, + 29200, 29201, 7, 11, 0, 0, 29201, 29202, 7, 0, 0, 0, 29202, 29203, 7, 4, + 0, 0, 29203, 29204, 7, 6, 0, 0, 29204, 4306, 1, 0, 0, 0, 29205, 29206, + 7, 4, 0, 0, 29206, 29207, 7, 3, 0, 0, 29207, 29208, 7, 0, 0, 0, 29208, + 29209, 7, 7, 0, 0, 29209, 29210, 7, 5, 0, 0, 29210, 29211, 7, 11, 0, 0, + 29211, 29212, 7, 0, 0, 0, 29212, 29213, 7, 4, 0, 0, 29213, 29214, 7, 10, + 0, 0, 29214, 29215, 7, 2, 0, 0, 29215, 29216, 7, 7, 0, 0, 29216, 4308, + 1, 0, 0, 0, 29217, 29218, 7, 4, 0, 0, 29218, 29219, 7, 3, 0, 0, 29219, + 29220, 7, 6, 0, 0, 29220, 29221, 7, 0, 0, 0, 29221, 29222, 7, 4, 0, 0, + 29222, 4310, 1, 0, 0, 0, 29223, 29224, 7, 4, 0, 0, 29224, 29225, 7, 3, + 0, 0, 29225, 29226, 7, 10, 0, 0, 29226, 29227, 7, 17, 0, 0, 29227, 29228, + 7, 17, 0, 0, 29228, 29229, 7, 6, 0, 0, 29229, 29230, 7, 3, 0, 0, 29230, + 29231, 7, 5, 0, 0, 29231, 4312, 1, 0, 0, 0, 29232, 29233, 7, 4, 0, 0, 29233, + 29234, 7, 3, 0, 0, 29234, 29235, 7, 10, 0, 0, 29235, 29236, 7, 17, 0, 0, + 29236, 29237, 7, 17, 0, 0, 29237, 29238, 7, 6, 0, 0, 29238, 29239, 7, 3, + 0, 0, 29239, 4314, 1, 0, 0, 0, 29240, 29241, 7, 4, 0, 0, 29241, 29242, + 7, 3, 0, 0, 29242, 29243, 7, 12, 0, 0, 29243, 29244, 7, 6, 0, 0, 29244, + 4316, 1, 0, 0, 0, 29245, 29246, 7, 4, 0, 0, 29246, 29247, 7, 3, 0, 0, 29247, + 29248, 7, 12, 0, 0, 29248, 29249, 7, 7, 0, 0, 29249, 29250, 7, 8, 0, 0, + 29250, 29251, 7, 0, 0, 0, 29251, 29252, 7, 4, 0, 0, 29252, 29253, 7, 6, + 0, 0, 29253, 4318, 1, 0, 0, 0, 29254, 29255, 7, 4, 0, 0, 29255, 29256, + 7, 3, 0, 0, 29256, 29257, 7, 12, 0, 0, 29257, 29258, 7, 7, 0, 0, 29258, + 29259, 7, 8, 0, 0, 29259, 4320, 1, 0, 0, 0, 29260, 29261, 7, 4, 0, 0, 29261, + 29262, 7, 3, 0, 0, 29262, 29263, 7, 12, 0, 0, 29263, 29264, 7, 5, 0, 0, + 29264, 29265, 7, 4, 0, 0, 29265, 29266, 7, 6, 0, 0, 29266, 29267, 7, 9, + 0, 0, 29267, 4322, 1, 0, 0, 0, 29268, 29269, 7, 4, 0, 0, 29269, 29270, + 7, 3, 0, 0, 29270, 29271, 7, 12, 0, 0, 29271, 29272, 7, 5, 0, 0, 29272, + 29273, 7, 4, 0, 0, 29273, 4324, 1, 0, 0, 0, 29274, 29275, 7, 4, 0, 0, 29275, + 29276, 7, 12, 0, 0, 29276, 29277, 7, 7, 0, 0, 29277, 29278, 7, 10, 0, 0, + 29278, 29279, 7, 7, 0, 0, 29279, 29280, 7, 17, 0, 0, 29280, 4326, 1, 0, + 0, 0, 29281, 29282, 7, 4, 0, 0, 29282, 29283, 7, 25, 0, 0, 29283, 4328, + 1, 0, 0, 0, 29284, 29285, 7, 4, 0, 0, 29285, 29286, 7, 18, 0, 0, 29286, + 29287, 7, 15, 0, 0, 29287, 29288, 7, 6, 0, 0, 29288, 29289, 7, 5, 0, 0, + 29289, 4330, 1, 0, 0, 0, 29290, 29291, 7, 4, 0, 0, 29291, 29292, 7, 18, + 0, 0, 29292, 29293, 7, 15, 0, 0, 29293, 29294, 7, 6, 0, 0, 29294, 4332, + 1, 0, 0, 0, 29295, 29296, 7, 4, 0, 0, 29296, 29297, 7, 23, 0, 0, 29297, + 29298, 5, 95, 0, 0, 29298, 29299, 7, 2, 0, 0, 29299, 29300, 7, 16, 0, 0, + 29300, 29301, 7, 16, 0, 0, 29301, 29302, 7, 5, 0, 0, 29302, 29303, 7, 6, + 0, 0, 29303, 29304, 7, 4, 0, 0, 29304, 4334, 1, 0, 0, 0, 29305, 29306, + 7, 12, 0, 0, 29306, 29307, 7, 1, 0, 0, 29307, 29308, 5, 50, 0, 0, 29308, + 4336, 1, 0, 0, 0, 29309, 29310, 7, 12, 0, 0, 29310, 29311, 7, 1, 0, 0, + 29311, 29312, 7, 0, 0, 0, 29312, 4338, 1, 0, 0, 0, 29313, 29314, 7, 12, + 0, 0, 29314, 29315, 7, 8, 0, 0, 29315, 29316, 7, 5, 0, 0, 29316, 29317, + 5, 50, 0, 0, 29317, 4340, 1, 0, 0, 0, 29318, 29319, 7, 12, 0, 0, 29319, + 29320, 7, 9, 0, 0, 29320, 29321, 7, 16, 0, 0, 29321, 4342, 1, 0, 0, 0, + 29322, 29323, 7, 12, 0, 0, 29323, 29324, 7, 10, 0, 0, 29324, 29325, 7, + 9, 0, 0, 29325, 4344, 1, 0, 0, 0, 29326, 29327, 7, 12, 0, 0, 29327, 29328, + 7, 7, 0, 0, 29328, 29329, 7, 0, 0, 0, 29329, 29330, 7, 3, 0, 0, 29330, + 29331, 7, 8, 0, 0, 29331, 29332, 7, 19, 0, 0, 29332, 29333, 7, 10, 0, 0, + 29333, 29334, 7, 13, 0, 0, 29334, 29335, 7, 6, 0, 0, 29335, 29336, 7, 9, + 0, 0, 29336, 4346, 1, 0, 0, 0, 29337, 29338, 7, 12, 0, 0, 29338, 29339, + 7, 7, 0, 0, 29339, 29340, 7, 1, 0, 0, 29340, 29341, 7, 2, 0, 0, 29341, + 29342, 7, 12, 0, 0, 29342, 29343, 7, 7, 0, 0, 29343, 29344, 7, 9, 0, 0, + 29344, 29345, 7, 6, 0, 0, 29345, 29346, 7, 9, 0, 0, 29346, 4348, 1, 0, + 0, 0, 29347, 29348, 7, 12, 0, 0, 29348, 29349, 7, 7, 0, 0, 29349, 29350, + 7, 1, 0, 0, 29350, 29351, 7, 2, 0, 0, 29351, 29352, 7, 12, 0, 0, 29352, + 29353, 7, 7, 0, 0, 29353, 29354, 7, 9, 0, 0, 29354, 4350, 1, 0, 0, 0, 29355, + 29356, 7, 12, 0, 0, 29356, 29357, 7, 7, 0, 0, 29357, 29358, 7, 8, 0, 0, + 29358, 29359, 7, 2, 0, 0, 29359, 29360, 7, 7, 0, 0, 29360, 29361, 7, 9, + 0, 0, 29361, 29362, 7, 10, 0, 0, 29362, 29363, 7, 4, 0, 0, 29363, 29364, + 7, 10, 0, 0, 29364, 29365, 7, 2, 0, 0, 29365, 29366, 7, 7, 0, 0, 29366, + 29367, 7, 0, 0, 0, 29367, 29368, 7, 11, 0, 0, 29368, 4352, 1, 0, 0, 0, + 29369, 29370, 7, 12, 0, 0, 29370, 29371, 7, 7, 0, 0, 29371, 29372, 7, 9, + 0, 0, 29372, 29373, 7, 6, 0, 0, 29373, 29374, 7, 3, 0, 0, 29374, 4354, + 1, 0, 0, 0, 29375, 29376, 7, 12, 0, 0, 29376, 29377, 7, 7, 0, 0, 29377, + 29378, 7, 9, 0, 0, 29378, 29379, 7, 2, 0, 0, 29379, 4356, 1, 0, 0, 0, 29380, + 29381, 7, 12, 0, 0, 29381, 29382, 7, 7, 0, 0, 29382, 29383, 7, 9, 0, 0, + 29383, 29384, 7, 3, 0, 0, 29384, 29385, 7, 2, 0, 0, 29385, 29386, 7, 15, + 0, 0, 29386, 4358, 1, 0, 0, 0, 29387, 29388, 7, 12, 0, 0, 29388, 29389, + 7, 7, 0, 0, 29389, 29390, 7, 10, 0, 0, 29390, 29391, 7, 16, 0, 0, 29391, + 29392, 7, 2, 0, 0, 29392, 29393, 7, 3, 0, 0, 29393, 29394, 7, 14, 0, 0, + 29394, 4360, 1, 0, 0, 0, 29395, 29396, 7, 12, 0, 0, 29396, 29397, 7, 7, + 0, 0, 29397, 29398, 7, 10, 0, 0, 29398, 29399, 7, 2, 0, 0, 29399, 29400, + 7, 7, 0, 0, 29400, 4362, 1, 0, 0, 0, 29401, 29402, 7, 12, 0, 0, 29402, + 29403, 7, 7, 0, 0, 29403, 29404, 7, 10, 0, 0, 29404, 29405, 7, 2, 0, 0, + 29405, 29406, 7, 7, 0, 0, 29406, 29407, 7, 4, 0, 0, 29407, 29408, 7, 18, + 0, 0, 29408, 29409, 7, 15, 0, 0, 29409, 29410, 7, 6, 0, 0, 29410, 4364, + 1, 0, 0, 0, 29411, 29412, 7, 12, 0, 0, 29412, 29413, 7, 7, 0, 0, 29413, + 29414, 7, 10, 0, 0, 29414, 29415, 7, 24, 0, 0, 29415, 29416, 7, 12, 0, + 0, 29416, 29417, 7, 6, 0, 0, 29417, 4366, 1, 0, 0, 0, 29418, 29419, 7, + 12, 0, 0, 29419, 29420, 7, 7, 0, 0, 29420, 29421, 7, 10, 0, 0, 29421, 29422, + 7, 5, 0, 0, 29422, 29423, 7, 4, 0, 0, 29423, 29424, 7, 3, 0, 0, 29424, + 4368, 1, 0, 0, 0, 29425, 29426, 7, 12, 0, 0, 29426, 29427, 7, 7, 0, 0, + 29427, 29428, 7, 11, 0, 0, 29428, 29429, 7, 10, 0, 0, 29429, 29430, 7, + 14, 0, 0, 29430, 29431, 7, 10, 0, 0, 29431, 29432, 7, 4, 0, 0, 29432, 29433, + 7, 6, 0, 0, 29433, 29434, 7, 9, 0, 0, 29434, 4370, 1, 0, 0, 0, 29435, 29436, + 7, 12, 0, 0, 29436, 29437, 7, 7, 0, 0, 29437, 29438, 7, 11, 0, 0, 29438, + 29439, 7, 2, 0, 0, 29439, 29440, 7, 0, 0, 0, 29440, 29441, 7, 9, 0, 0, + 29441, 4372, 1, 0, 0, 0, 29442, 29443, 7, 12, 0, 0, 29443, 29444, 7, 7, + 0, 0, 29444, 29445, 7, 11, 0, 0, 29445, 29446, 7, 2, 0, 0, 29446, 29447, + 7, 8, 0, 0, 29447, 29448, 7, 21, 0, 0, 29448, 4374, 1, 0, 0, 0, 29449, + 29450, 7, 12, 0, 0, 29450, 29451, 7, 7, 0, 0, 29451, 29452, 7, 14, 0, 0, + 29452, 29453, 7, 0, 0, 0, 29453, 29454, 7, 4, 0, 0, 29454, 29455, 7, 8, + 0, 0, 29455, 29456, 7, 19, 0, 0, 29456, 29457, 7, 6, 0, 0, 29457, 29458, + 7, 9, 0, 0, 29458, 4376, 1, 0, 0, 0, 29459, 29460, 7, 12, 0, 0, 29460, + 29461, 7, 7, 0, 0, 29461, 29462, 7, 7, 0, 0, 29462, 29463, 7, 6, 0, 0, + 29463, 29464, 7, 5, 0, 0, 29464, 29465, 7, 4, 0, 0, 29465, 29466, 5, 95, + 0, 0, 29466, 29467, 7, 10, 0, 0, 29467, 29468, 7, 7, 0, 0, 29468, 29469, + 7, 7, 0, 0, 29469, 29470, 7, 6, 0, 0, 29470, 29471, 7, 3, 0, 0, 29471, + 29472, 7, 20, 0, 0, 29472, 29473, 5, 95, 0, 0, 29473, 29474, 7, 9, 0, 0, + 29474, 29475, 7, 10, 0, 0, 29475, 29476, 7, 5, 0, 0, 29476, 29477, 7, 4, + 0, 0, 29477, 29478, 7, 10, 0, 0, 29478, 29479, 7, 7, 0, 0, 29479, 29480, + 7, 8, 0, 0, 29480, 29481, 7, 4, 0, 0, 29481, 29482, 5, 95, 0, 0, 29482, + 29483, 7, 13, 0, 0, 29483, 29484, 7, 10, 0, 0, 29484, 29485, 7, 6, 0, 0, + 29485, 29486, 7, 22, 0, 0, 29486, 4378, 1, 0, 0, 0, 29487, 29488, 7, 12, + 0, 0, 29488, 29489, 7, 7, 0, 0, 29489, 29490, 7, 7, 0, 0, 29490, 29491, + 7, 6, 0, 0, 29491, 29492, 7, 5, 0, 0, 29492, 29493, 7, 4, 0, 0, 29493, + 29494, 5, 95, 0, 0, 29494, 29495, 7, 7, 0, 0, 29495, 29496, 7, 2, 0, 0, + 29496, 29497, 7, 5, 0, 0, 29497, 29498, 7, 6, 0, 0, 29498, 29499, 7, 14, + 0, 0, 29499, 29500, 7, 10, 0, 0, 29500, 29501, 7, 20, 0, 0, 29501, 29502, + 5, 95, 0, 0, 29502, 29503, 7, 7, 0, 0, 29503, 29504, 7, 2, 0, 0, 29504, + 29505, 7, 9, 0, 0, 29505, 29506, 7, 10, 0, 0, 29506, 29507, 7, 5, 0, 0, + 29507, 29508, 7, 4, 0, 0, 29508, 29509, 7, 10, 0, 0, 29509, 29510, 7, 7, + 0, 0, 29510, 29511, 7, 8, 0, 0, 29511, 29512, 7, 4, 0, 0, 29512, 29513, + 7, 13, 0, 0, 29513, 29514, 7, 10, 0, 0, 29514, 29515, 7, 6, 0, 0, 29515, + 29516, 7, 22, 0, 0, 29516, 4380, 1, 0, 0, 0, 29517, 29518, 7, 12, 0, 0, + 29518, 29519, 7, 7, 0, 0, 29519, 29520, 7, 7, 0, 0, 29520, 29521, 7, 6, + 0, 0, 29521, 29522, 7, 5, 0, 0, 29522, 29523, 7, 4, 0, 0, 29523, 29524, + 5, 95, 0, 0, 29524, 29525, 7, 5, 0, 0, 29525, 29526, 7, 6, 0, 0, 29526, + 29527, 7, 14, 0, 0, 29527, 29528, 7, 10, 0, 0, 29528, 29529, 7, 20, 0, + 0, 29529, 29530, 5, 95, 0, 0, 29530, 29531, 7, 13, 0, 0, 29531, 29532, + 7, 10, 0, 0, 29532, 29533, 7, 6, 0, 0, 29533, 29534, 7, 22, 0, 0, 29534, + 4382, 1, 0, 0, 0, 29535, 29536, 7, 12, 0, 0, 29536, 29537, 7, 7, 0, 0, + 29537, 29538, 7, 7, 0, 0, 29538, 29539, 7, 6, 0, 0, 29539, 29540, 7, 5, + 0, 0, 29540, 29541, 7, 4, 0, 0, 29541, 4384, 1, 0, 0, 0, 29542, 29543, + 7, 12, 0, 0, 29543, 29544, 7, 7, 0, 0, 29544, 29545, 7, 15, 0, 0, 29545, + 29546, 7, 0, 0, 0, 29546, 29547, 7, 8, 0, 0, 29547, 29548, 7, 21, 0, 0, + 29548, 29549, 7, 6, 0, 0, 29549, 29550, 7, 9, 0, 0, 29550, 4386, 1, 0, + 0, 0, 29551, 29552, 7, 12, 0, 0, 29552, 29553, 7, 7, 0, 0, 29553, 29554, + 7, 15, 0, 0, 29554, 29555, 7, 10, 0, 0, 29555, 29556, 7, 13, 0, 0, 29556, + 29557, 7, 2, 0, 0, 29557, 29558, 7, 4, 0, 0, 29558, 4388, 1, 0, 0, 0, 29559, + 29560, 7, 12, 0, 0, 29560, 29561, 7, 7, 0, 0, 29561, 29562, 7, 15, 0, 0, + 29562, 29563, 7, 11, 0, 0, 29563, 29564, 7, 12, 0, 0, 29564, 29565, 7, + 17, 0, 0, 29565, 4390, 1, 0, 0, 0, 29566, 29567, 7, 12, 0, 0, 29567, 29568, + 7, 7, 0, 0, 29568, 29569, 7, 15, 0, 0, 29569, 29570, 7, 3, 0, 0, 29570, + 29571, 7, 2, 0, 0, 29571, 29572, 7, 4, 0, 0, 29572, 29573, 7, 6, 0, 0, + 29573, 29574, 7, 8, 0, 0, 29574, 29575, 7, 4, 0, 0, 29575, 29576, 7, 6, + 0, 0, 29576, 29577, 7, 9, 0, 0, 29577, 4392, 1, 0, 0, 0, 29578, 29579, + 7, 12, 0, 0, 29579, 29580, 7, 7, 0, 0, 29580, 29581, 7, 24, 0, 0, 29581, + 29582, 7, 12, 0, 0, 29582, 29583, 7, 10, 0, 0, 29583, 29584, 7, 6, 0, 0, + 29584, 29585, 7, 5, 0, 0, 29585, 29586, 7, 8, 0, 0, 29586, 29587, 7, 6, + 0, 0, 29587, 4394, 1, 0, 0, 0, 29588, 29589, 7, 12, 0, 0, 29589, 29590, + 7, 7, 0, 0, 29590, 29591, 7, 3, 0, 0, 29591, 29592, 7, 6, 0, 0, 29592, + 29593, 7, 8, 0, 0, 29593, 29594, 7, 2, 0, 0, 29594, 29595, 7, 13, 0, 0, + 29595, 29596, 7, 6, 0, 0, 29596, 29597, 7, 3, 0, 0, 29597, 29598, 7, 0, + 0, 0, 29598, 29599, 7, 1, 0, 0, 29599, 29600, 7, 11, 0, 0, 29600, 29601, + 7, 6, 0, 0, 29601, 4396, 1, 0, 0, 0, 29602, 29603, 7, 12, 0, 0, 29603, + 29604, 7, 7, 0, 0, 29604, 29605, 7, 3, 0, 0, 29605, 29606, 7, 6, 0, 0, + 29606, 29607, 7, 5, 0, 0, 29607, 29608, 7, 4, 0, 0, 29608, 29609, 7, 3, + 0, 0, 29609, 29610, 7, 10, 0, 0, 29610, 29611, 7, 8, 0, 0, 29611, 29612, + 7, 4, 0, 0, 29612, 29613, 7, 6, 0, 0, 29613, 29614, 7, 9, 0, 0, 29614, + 4398, 1, 0, 0, 0, 29615, 29616, 7, 12, 0, 0, 29616, 29617, 7, 7, 0, 0, + 29617, 29618, 7, 5, 0, 0, 29618, 29619, 7, 10, 0, 0, 29619, 29620, 7, 17, + 0, 0, 29620, 29621, 7, 7, 0, 0, 29621, 29622, 7, 6, 0, 0, 29622, 29623, + 7, 9, 0, 0, 29623, 4400, 1, 0, 0, 0, 29624, 29625, 7, 12, 0, 0, 29625, + 29626, 7, 7, 0, 0, 29626, 29627, 7, 5, 0, 0, 29627, 29628, 7, 12, 0, 0, + 29628, 29629, 7, 1, 0, 0, 29629, 29630, 7, 5, 0, 0, 29630, 29631, 7, 8, + 0, 0, 29631, 29632, 7, 3, 0, 0, 29632, 29633, 7, 10, 0, 0, 29633, 29634, + 7, 1, 0, 0, 29634, 29635, 7, 6, 0, 0, 29635, 4402, 1, 0, 0, 0, 29636, 29637, + 7, 12, 0, 0, 29637, 29638, 7, 7, 0, 0, 29638, 29639, 7, 4, 0, 0, 29639, + 29640, 7, 10, 0, 0, 29640, 29641, 7, 11, 0, 0, 29641, 4404, 1, 0, 0, 0, + 29642, 29643, 7, 12, 0, 0, 29643, 29644, 7, 7, 0, 0, 29644, 29645, 7, 12, + 0, 0, 29645, 29646, 7, 5, 0, 0, 29646, 29647, 7, 0, 0, 0, 29647, 29648, + 7, 1, 0, 0, 29648, 29649, 7, 11, 0, 0, 29649, 29650, 7, 6, 0, 0, 29650, + 4406, 1, 0, 0, 0, 29651, 29652, 7, 12, 0, 0, 29652, 29653, 7, 7, 0, 0, + 29653, 29654, 7, 12, 0, 0, 29654, 29655, 7, 5, 0, 0, 29655, 29656, 7, 6, + 0, 0, 29656, 29657, 7, 9, 0, 0, 29657, 4408, 1, 0, 0, 0, 29658, 29659, + 7, 12, 0, 0, 29659, 29660, 7, 15, 0, 0, 29660, 29661, 7, 9, 0, 0, 29661, + 29662, 7, 0, 0, 0, 29662, 29663, 7, 4, 0, 0, 29663, 29664, 7, 0, 0, 0, + 29664, 29665, 7, 1, 0, 0, 29665, 29666, 7, 11, 0, 0, 29666, 29667, 7, 6, + 0, 0, 29667, 4410, 1, 0, 0, 0, 29668, 29669, 7, 12, 0, 0, 29669, 29670, + 7, 15, 0, 0, 29670, 29671, 7, 9, 0, 0, 29671, 29672, 7, 0, 0, 0, 29672, + 29673, 7, 4, 0, 0, 29673, 29674, 7, 6, 0, 0, 29674, 29675, 7, 9, 0, 0, + 29675, 4412, 1, 0, 0, 0, 29676, 29677, 7, 12, 0, 0, 29677, 29678, 7, 15, + 0, 0, 29678, 29679, 7, 9, 0, 0, 29679, 29680, 7, 0, 0, 0, 29680, 29681, + 7, 4, 0, 0, 29681, 29682, 7, 6, 0, 0, 29682, 4414, 1, 0, 0, 0, 29683, 29684, + 7, 12, 0, 0, 29684, 29685, 7, 15, 0, 0, 29685, 29686, 7, 9, 0, 0, 29686, + 29687, 7, 0, 0, 0, 29687, 29688, 7, 4, 0, 0, 29688, 29689, 7, 6, 0, 0, + 29689, 29690, 7, 25, 0, 0, 29690, 29691, 7, 14, 0, 0, 29691, 29692, 7, + 11, 0, 0, 29692, 4416, 1, 0, 0, 0, 29693, 29694, 7, 12, 0, 0, 29694, 29695, + 7, 15, 0, 0, 29695, 29696, 7, 9, 0, 0, 29696, 29697, 5, 95, 0, 0, 29697, + 29698, 7, 10, 0, 0, 29698, 29699, 7, 7, 0, 0, 29699, 29700, 7, 9, 0, 0, + 29700, 29701, 7, 6, 0, 0, 29701, 29702, 7, 25, 0, 0, 29702, 29703, 7, 6, + 0, 0, 29703, 29704, 7, 5, 0, 0, 29704, 4418, 1, 0, 0, 0, 29705, 29706, + 7, 12, 0, 0, 29706, 29707, 7, 15, 0, 0, 29707, 29708, 7, 9, 0, 0, 29708, + 29709, 5, 95, 0, 0, 29709, 29710, 7, 20, 0, 0, 29710, 29711, 7, 2, 0, 0, + 29711, 29712, 7, 10, 0, 0, 29712, 29713, 7, 7, 0, 0, 29713, 29714, 7, 10, + 0, 0, 29714, 29715, 7, 7, 0, 0, 29715, 29716, 7, 9, 0, 0, 29716, 29717, + 7, 6, 0, 0, 29717, 29718, 7, 25, 0, 0, 29718, 4420, 1, 0, 0, 0, 29719, + 29720, 7, 12, 0, 0, 29720, 29721, 7, 15, 0, 0, 29721, 29722, 7, 17, 0, + 0, 29722, 29723, 7, 3, 0, 0, 29723, 29724, 7, 0, 0, 0, 29724, 29725, 7, + 9, 0, 0, 29725, 29726, 7, 6, 0, 0, 29726, 4422, 1, 0, 0, 0, 29727, 29728, + 7, 12, 0, 0, 29728, 29729, 7, 15, 0, 0, 29729, 29730, 7, 15, 0, 0, 29730, + 29731, 7, 6, 0, 0, 29731, 29732, 7, 3, 0, 0, 29732, 4424, 1, 0, 0, 0, 29733, + 29734, 7, 12, 0, 0, 29734, 29735, 7, 15, 0, 0, 29735, 29736, 7, 5, 0, 0, + 29736, 29737, 7, 6, 0, 0, 29737, 29738, 7, 3, 0, 0, 29738, 29739, 7, 4, + 0, 0, 29739, 4426, 1, 0, 0, 0, 29740, 29741, 7, 12, 0, 0, 29741, 29742, + 7, 3, 0, 0, 29742, 29743, 7, 2, 0, 0, 29743, 29744, 7, 22, 0, 0, 29744, + 29745, 7, 10, 0, 0, 29745, 29746, 7, 9, 0, 0, 29746, 4428, 1, 0, 0, 0, + 29747, 29748, 7, 12, 0, 0, 29748, 29749, 7, 5, 0, 0, 29749, 29750, 7, 0, + 0, 0, 29750, 29751, 7, 1, 0, 0, 29751, 29752, 7, 11, 0, 0, 29752, 29753, + 7, 6, 0, 0, 29753, 4430, 1, 0, 0, 0, 29754, 29755, 7, 12, 0, 0, 29755, + 29756, 7, 5, 0, 0, 29756, 29757, 7, 0, 0, 0, 29757, 29758, 7, 17, 0, 0, + 29758, 29759, 7, 6, 0, 0, 29759, 4432, 1, 0, 0, 0, 29760, 29761, 7, 12, + 0, 0, 29761, 29762, 7, 5, 0, 0, 29762, 29763, 7, 6, 0, 0, 29763, 29764, + 5, 95, 0, 0, 29764, 29765, 7, 0, 0, 0, 29765, 29766, 7, 7, 0, 0, 29766, + 29767, 7, 4, 0, 0, 29767, 29768, 7, 10, 0, 0, 29768, 4434, 1, 0, 0, 0, + 29769, 29770, 7, 12, 0, 0, 29770, 29771, 7, 5, 0, 0, 29771, 29772, 7, 6, + 0, 0, 29772, 29773, 5, 95, 0, 0, 29773, 29774, 7, 8, 0, 0, 29774, 29775, + 7, 2, 0, 0, 29775, 29776, 7, 7, 0, 0, 29776, 29777, 7, 8, 0, 0, 29777, + 29778, 7, 0, 0, 0, 29778, 29779, 7, 4, 0, 0, 29779, 4436, 1, 0, 0, 0, 29780, + 29781, 7, 12, 0, 0, 29781, 29782, 7, 5, 0, 0, 29782, 29783, 7, 6, 0, 0, + 29783, 29784, 5, 95, 0, 0, 29784, 29785, 7, 8, 0, 0, 29785, 29786, 7, 12, + 0, 0, 29786, 29787, 7, 1, 0, 0, 29787, 29788, 7, 6, 0, 0, 29788, 4438, + 1, 0, 0, 0, 29789, 29790, 7, 12, 0, 0, 29790, 29791, 7, 5, 0, 0, 29791, + 29792, 7, 6, 0, 0, 29792, 29793, 5, 95, 0, 0, 29793, 29794, 7, 19, 0, 0, + 29794, 29795, 7, 0, 0, 0, 29795, 29796, 7, 5, 0, 0, 29796, 29797, 7, 19, + 0, 0, 29797, 29798, 5, 95, 0, 0, 29798, 29799, 7, 0, 0, 0, 29799, 29800, + 7, 17, 0, 0, 29800, 29801, 7, 17, 0, 0, 29801, 29802, 7, 3, 0, 0, 29802, + 29803, 7, 6, 0, 0, 29803, 29804, 7, 17, 0, 0, 29804, 29805, 7, 0, 0, 0, + 29805, 29806, 7, 4, 0, 0, 29806, 29807, 7, 10, 0, 0, 29807, 29808, 7, 2, + 0, 0, 29808, 29809, 7, 7, 0, 0, 29809, 4440, 1, 0, 0, 0, 29810, 29811, + 7, 12, 0, 0, 29811, 29812, 7, 5, 0, 0, 29812, 29813, 7, 6, 0, 0, 29813, + 29814, 5, 95, 0, 0, 29814, 29815, 7, 19, 0, 0, 29815, 29816, 7, 0, 0, 0, + 29816, 29817, 7, 5, 0, 0, 29817, 29818, 7, 19, 0, 0, 29818, 29819, 5, 95, + 0, 0, 29819, 29820, 7, 17, 0, 0, 29820, 29821, 7, 1, 0, 0, 29821, 29822, + 7, 18, 0, 0, 29822, 29823, 5, 95, 0, 0, 29823, 29824, 7, 16, 0, 0, 29824, + 29825, 7, 2, 0, 0, 29825, 29826, 7, 3, 0, 0, 29826, 29827, 5, 95, 0, 0, + 29827, 29828, 7, 15, 0, 0, 29828, 29829, 7, 12, 0, 0, 29829, 29830, 7, + 5, 0, 0, 29830, 29831, 7, 19, 0, 0, 29831, 29832, 7, 9, 0, 0, 29832, 29833, + 7, 2, 0, 0, 29833, 29834, 7, 22, 0, 0, 29834, 29835, 7, 7, 0, 0, 29835, + 4442, 1, 0, 0, 0, 29836, 29837, 7, 12, 0, 0, 29837, 29838, 7, 5, 0, 0, + 29838, 29839, 7, 6, 0, 0, 29839, 29840, 5, 95, 0, 0, 29840, 29841, 7, 19, + 0, 0, 29841, 29842, 7, 0, 0, 0, 29842, 29843, 7, 5, 0, 0, 29843, 29844, + 7, 19, 0, 0, 29844, 4444, 1, 0, 0, 0, 29845, 29846, 7, 12, 0, 0, 29846, + 29847, 7, 5, 0, 0, 29847, 29848, 7, 6, 0, 0, 29848, 29849, 5, 95, 0, 0, + 29849, 29850, 7, 19, 0, 0, 29850, 29851, 7, 10, 0, 0, 29851, 29852, 7, + 9, 0, 0, 29852, 29853, 7, 9, 0, 0, 29853, 29854, 7, 6, 0, 0, 29854, 29855, + 7, 7, 0, 0, 29855, 29856, 5, 95, 0, 0, 29856, 29857, 7, 15, 0, 0, 29857, + 29858, 7, 0, 0, 0, 29858, 29859, 7, 3, 0, 0, 29859, 29860, 7, 4, 0, 0, + 29860, 29861, 7, 10, 0, 0, 29861, 29862, 7, 4, 0, 0, 29862, 29863, 7, 10, + 0, 0, 29863, 29864, 7, 2, 0, 0, 29864, 29865, 7, 7, 0, 0, 29865, 29866, + 7, 5, 0, 0, 29866, 4446, 1, 0, 0, 0, 29867, 29868, 7, 12, 0, 0, 29868, + 29869, 7, 5, 0, 0, 29869, 29870, 7, 6, 0, 0, 29870, 29871, 5, 95, 0, 0, + 29871, 29872, 7, 10, 0, 0, 29872, 29873, 7, 7, 0, 0, 29873, 29874, 7, 13, + 0, 0, 29874, 29875, 7, 10, 0, 0, 29875, 29876, 7, 5, 0, 0, 29876, 29877, + 7, 10, 0, 0, 29877, 29878, 7, 1, 0, 0, 29878, 29879, 7, 11, 0, 0, 29879, + 29880, 7, 6, 0, 0, 29880, 29881, 5, 95, 0, 0, 29881, 29882, 7, 10, 0, 0, + 29882, 29883, 7, 7, 0, 0, 29883, 29884, 7, 9, 0, 0, 29884, 29885, 7, 6, + 0, 0, 29885, 29886, 7, 25, 0, 0, 29886, 29887, 7, 6, 0, 0, 29887, 29888, + 7, 5, 0, 0, 29888, 4448, 1, 0, 0, 0, 29889, 29890, 7, 12, 0, 0, 29890, + 29891, 7, 5, 0, 0, 29891, 29892, 7, 6, 0, 0, 29892, 29893, 5, 95, 0, 0, + 29893, 29894, 7, 14, 0, 0, 29894, 29895, 7, 6, 0, 0, 29895, 29896, 7, 3, + 0, 0, 29896, 29897, 7, 17, 0, 0, 29897, 29898, 7, 6, 0, 0, 29898, 29899, + 5, 95, 0, 0, 29899, 29900, 7, 8, 0, 0, 29900, 29901, 7, 0, 0, 0, 29901, + 29902, 7, 3, 0, 0, 29902, 29903, 7, 4, 0, 0, 29903, 29904, 7, 6, 0, 0, + 29904, 29905, 7, 5, 0, 0, 29905, 29906, 7, 10, 0, 0, 29906, 29907, 7, 0, + 0, 0, 29907, 29908, 7, 7, 0, 0, 29908, 4450, 1, 0, 0, 0, 29909, 29910, + 7, 12, 0, 0, 29910, 29911, 7, 5, 0, 0, 29911, 29912, 7, 6, 0, 0, 29912, + 29913, 5, 95, 0, 0, 29913, 29914, 7, 14, 0, 0, 29914, 29915, 7, 6, 0, 0, + 29915, 29916, 7, 3, 0, 0, 29916, 29917, 7, 17, 0, 0, 29917, 29918, 7, 6, + 0, 0, 29918, 4452, 1, 0, 0, 0, 29919, 29920, 7, 12, 0, 0, 29920, 29921, + 7, 5, 0, 0, 29921, 29922, 7, 6, 0, 0, 29922, 29923, 5, 95, 0, 0, 29923, + 29924, 7, 7, 0, 0, 29924, 29925, 7, 11, 0, 0, 29925, 4454, 1, 0, 0, 0, + 29926, 29927, 7, 12, 0, 0, 29927, 29928, 7, 5, 0, 0, 29928, 29929, 7, 6, + 0, 0, 29929, 29930, 5, 95, 0, 0, 29930, 29931, 7, 7, 0, 0, 29931, 29932, + 7, 11, 0, 0, 29932, 29933, 5, 95, 0, 0, 29933, 29934, 7, 22, 0, 0, 29934, + 29935, 7, 10, 0, 0, 29935, 29936, 7, 4, 0, 0, 29936, 29937, 7, 19, 0, 0, + 29937, 29938, 5, 95, 0, 0, 29938, 29939, 7, 10, 0, 0, 29939, 29940, 7, + 7, 0, 0, 29940, 29941, 7, 9, 0, 0, 29941, 29942, 7, 6, 0, 0, 29942, 29943, + 7, 25, 0, 0, 29943, 4456, 1, 0, 0, 0, 29944, 29945, 7, 12, 0, 0, 29945, + 29946, 7, 5, 0, 0, 29946, 29947, 7, 6, 0, 0, 29947, 29948, 5, 95, 0, 0, + 29948, 29949, 7, 15, 0, 0, 29949, 29950, 7, 3, 0, 0, 29950, 29951, 7, 10, + 0, 0, 29951, 29952, 7, 13, 0, 0, 29952, 29953, 7, 0, 0, 0, 29953, 29954, + 7, 4, 0, 0, 29954, 29955, 7, 6, 0, 0, 29955, 29956, 5, 95, 0, 0, 29956, + 29957, 7, 2, 0, 0, 29957, 29958, 7, 12, 0, 0, 29958, 29959, 7, 4, 0, 0, + 29959, 29960, 7, 11, 0, 0, 29960, 29961, 7, 10, 0, 0, 29961, 29962, 7, + 7, 0, 0, 29962, 29963, 7, 6, 0, 0, 29963, 29964, 7, 5, 0, 0, 29964, 4458, + 1, 0, 0, 0, 29965, 29966, 7, 12, 0, 0, 29966, 29967, 7, 5, 0, 0, 29967, + 29968, 7, 6, 0, 0, 29968, 29969, 7, 3, 0, 0, 29969, 29970, 5, 95, 0, 0, + 29970, 29971, 7, 9, 0, 0, 29971, 29972, 7, 0, 0, 0, 29972, 29973, 7, 4, + 0, 0, 29973, 29974, 7, 0, 0, 0, 29974, 4460, 1, 0, 0, 0, 29975, 29976, + 7, 12, 0, 0, 29976, 29977, 7, 5, 0, 0, 29977, 29978, 7, 6, 0, 0, 29978, + 29979, 7, 3, 0, 0, 29979, 29980, 5, 95, 0, 0, 29980, 29981, 7, 9, 0, 0, + 29981, 29982, 7, 6, 0, 0, 29982, 29983, 7, 16, 0, 0, 29983, 29984, 7, 10, + 0, 0, 29984, 29985, 7, 7, 0, 0, 29985, 29986, 7, 6, 0, 0, 29986, 29987, + 7, 9, 0, 0, 29987, 4462, 1, 0, 0, 0, 29988, 29989, 7, 12, 0, 0, 29989, + 29990, 7, 5, 0, 0, 29990, 29991, 7, 6, 0, 0, 29991, 29992, 7, 3, 0, 0, + 29992, 29993, 7, 6, 0, 0, 29993, 29994, 7, 7, 0, 0, 29994, 29995, 7, 13, + 0, 0, 29995, 4464, 1, 0, 0, 0, 29996, 29997, 7, 12, 0, 0, 29997, 29998, + 7, 5, 0, 0, 29998, 29999, 7, 6, 0, 0, 29999, 30000, 7, 3, 0, 0, 30000, + 30001, 7, 17, 0, 0, 30001, 30002, 7, 3, 0, 0, 30002, 30003, 7, 2, 0, 0, + 30003, 30004, 7, 12, 0, 0, 30004, 30005, 7, 15, 0, 0, 30005, 4466, 1, 0, + 0, 0, 30006, 30007, 7, 12, 0, 0, 30007, 30008, 7, 5, 0, 0, 30008, 30009, + 7, 6, 0, 0, 30009, 30010, 7, 3, 0, 0, 30010, 30011, 5, 95, 0, 0, 30011, + 30012, 7, 3, 0, 0, 30012, 30013, 7, 6, 0, 0, 30013, 30014, 7, 8, 0, 0, + 30014, 30015, 7, 18, 0, 0, 30015, 30016, 7, 8, 0, 0, 30016, 30017, 7, 11, + 0, 0, 30017, 30018, 7, 6, 0, 0, 30018, 30019, 7, 1, 0, 0, 30019, 30020, + 7, 10, 0, 0, 30020, 30021, 7, 7, 0, 0, 30021, 4468, 1, 0, 0, 0, 30022, + 30023, 7, 12, 0, 0, 30023, 30024, 7, 5, 0, 0, 30024, 30025, 7, 6, 0, 0, + 30025, 30026, 7, 3, 0, 0, 30026, 30027, 7, 5, 0, 0, 30027, 4470, 1, 0, + 0, 0, 30028, 30029, 7, 12, 0, 0, 30029, 30030, 7, 5, 0, 0, 30030, 30031, + 7, 6, 0, 0, 30031, 30032, 7, 3, 0, 0, 30032, 30033, 5, 95, 0, 0, 30033, + 30034, 7, 4, 0, 0, 30034, 30035, 7, 0, 0, 0, 30035, 30036, 7, 1, 0, 0, + 30036, 30037, 7, 11, 0, 0, 30037, 30038, 7, 6, 0, 0, 30038, 30039, 7, 5, + 0, 0, 30039, 30040, 7, 15, 0, 0, 30040, 30041, 7, 0, 0, 0, 30041, 30042, + 7, 8, 0, 0, 30042, 30043, 7, 6, 0, 0, 30043, 30044, 7, 5, 0, 0, 30044, + 4472, 1, 0, 0, 0, 30045, 30046, 7, 12, 0, 0, 30046, 30047, 7, 5, 0, 0, + 30047, 30048, 7, 6, 0, 0, 30048, 30049, 7, 3, 0, 0, 30049, 4474, 1, 0, + 0, 0, 30050, 30051, 7, 12, 0, 0, 30051, 30052, 7, 5, 0, 0, 30052, 30053, + 7, 6, 0, 0, 30053, 30054, 5, 95, 0, 0, 30054, 30055, 7, 5, 0, 0, 30055, + 30056, 7, 6, 0, 0, 30056, 30057, 7, 14, 0, 0, 30057, 30058, 7, 10, 0, 0, + 30058, 4476, 1, 0, 0, 0, 30059, 30060, 7, 12, 0, 0, 30060, 30061, 7, 5, + 0, 0, 30061, 30062, 7, 6, 0, 0, 30062, 30063, 5, 95, 0, 0, 30063, 30064, + 7, 5, 0, 0, 30064, 30065, 7, 4, 0, 0, 30065, 30066, 7, 2, 0, 0, 30066, + 30067, 7, 3, 0, 0, 30067, 30068, 7, 6, 0, 0, 30068, 30069, 7, 9, 0, 0, + 30069, 30070, 5, 95, 0, 0, 30070, 30071, 7, 2, 0, 0, 30071, 30072, 7, 12, + 0, 0, 30072, 30073, 7, 4, 0, 0, 30073, 30074, 7, 11, 0, 0, 30074, 30075, + 7, 10, 0, 0, 30075, 30076, 7, 7, 0, 0, 30076, 30077, 7, 6, 0, 0, 30077, + 30078, 7, 5, 0, 0, 30078, 4478, 1, 0, 0, 0, 30079, 30080, 7, 12, 0, 0, + 30080, 30081, 7, 5, 0, 0, 30081, 30082, 7, 6, 0, 0, 30082, 30083, 5, 95, + 0, 0, 30083, 30084, 7, 4, 0, 0, 30084, 30085, 7, 4, 0, 0, 30085, 30086, + 7, 4, 0, 0, 30086, 30087, 5, 95, 0, 0, 30087, 30088, 7, 16, 0, 0, 30088, + 30089, 7, 2, 0, 0, 30089, 30090, 7, 3, 0, 0, 30090, 30091, 5, 95, 0, 0, + 30091, 30092, 7, 17, 0, 0, 30092, 30093, 7, 5, 0, 0, 30093, 30094, 7, 6, + 0, 0, 30094, 30095, 7, 4, 0, 0, 30095, 30096, 7, 5, 0, 0, 30096, 4480, + 1, 0, 0, 0, 30097, 30098, 7, 12, 0, 0, 30098, 30099, 7, 5, 0, 0, 30099, + 30100, 7, 6, 0, 0, 30100, 4482, 1, 0, 0, 0, 30101, 30102, 7, 12, 0, 0, + 30102, 30103, 7, 5, 0, 0, 30103, 30104, 7, 6, 0, 0, 30104, 30105, 5, 95, + 0, 0, 30105, 30106, 7, 13, 0, 0, 30106, 30107, 7, 6, 0, 0, 30107, 30108, + 7, 8, 0, 0, 30108, 30109, 7, 4, 0, 0, 30109, 30110, 7, 2, 0, 0, 30110, + 30111, 7, 3, 0, 0, 30111, 30112, 5, 95, 0, 0, 30112, 30113, 7, 0, 0, 0, + 30113, 30114, 7, 17, 0, 0, 30114, 30115, 7, 17, 0, 0, 30115, 30116, 7, + 3, 0, 0, 30116, 30117, 7, 6, 0, 0, 30117, 30118, 7, 17, 0, 0, 30118, 30119, + 7, 0, 0, 0, 30119, 30120, 7, 4, 0, 0, 30120, 30121, 7, 10, 0, 0, 30121, + 30122, 7, 2, 0, 0, 30122, 30123, 7, 7, 0, 0, 30123, 4484, 1, 0, 0, 0, 30124, + 30125, 7, 12, 0, 0, 30125, 30126, 7, 5, 0, 0, 30126, 30127, 7, 6, 0, 0, + 30127, 30128, 5, 95, 0, 0, 30128, 30129, 7, 22, 0, 0, 30129, 30130, 7, + 6, 0, 0, 30130, 30131, 7, 0, 0, 0, 30131, 30132, 7, 21, 0, 0, 30132, 30133, + 5, 95, 0, 0, 30133, 30134, 7, 7, 0, 0, 30134, 30135, 7, 0, 0, 0, 30135, + 30136, 7, 14, 0, 0, 30136, 30137, 7, 6, 0, 0, 30137, 30138, 5, 95, 0, 0, + 30138, 30139, 7, 3, 0, 0, 30139, 30140, 7, 6, 0, 0, 30140, 30141, 7, 5, + 0, 0, 30141, 30142, 7, 11, 0, 0, 30142, 4486, 1, 0, 0, 0, 30143, 30144, + 7, 12, 0, 0, 30144, 30145, 7, 5, 0, 0, 30145, 30146, 7, 10, 0, 0, 30146, + 30147, 7, 7, 0, 0, 30147, 30148, 7, 17, 0, 0, 30148, 30149, 5, 95, 0, 0, + 30149, 30150, 7, 7, 0, 0, 30150, 30151, 7, 2, 0, 0, 30151, 30152, 5, 95, + 0, 0, 30152, 30153, 7, 6, 0, 0, 30153, 30154, 7, 25, 0, 0, 30154, 30155, + 7, 15, 0, 0, 30155, 30156, 7, 0, 0, 0, 30156, 30157, 7, 7, 0, 0, 30157, + 30158, 7, 9, 0, 0, 30158, 4488, 1, 0, 0, 0, 30159, 30160, 7, 12, 0, 0, + 30160, 30161, 7, 5, 0, 0, 30161, 30162, 7, 10, 0, 0, 30162, 30163, 7, 7, + 0, 0, 30163, 30164, 7, 17, 0, 0, 30164, 30165, 5, 95, 0, 0, 30165, 30166, + 7, 7, 0, 0, 30166, 30167, 7, 11, 0, 0, 30167, 30168, 7, 5, 0, 0, 30168, + 30169, 5, 95, 0, 0, 30169, 30170, 7, 8, 0, 0, 30170, 30171, 7, 2, 0, 0, + 30171, 30172, 7, 14, 0, 0, 30172, 30173, 7, 15, 0, 0, 30173, 4490, 1, 0, + 0, 0, 30174, 30175, 7, 12, 0, 0, 30175, 30176, 7, 5, 0, 0, 30176, 30177, + 7, 10, 0, 0, 30177, 30178, 7, 7, 0, 0, 30178, 30179, 7, 17, 0, 0, 30179, + 4492, 1, 0, 0, 0, 30180, 30181, 7, 12, 0, 0, 30181, 30182, 7, 4, 0, 0, + 30182, 30183, 7, 16, 0, 0, 30183, 30184, 5, 49, 0, 0, 30184, 30185, 5, + 54, 0, 0, 30185, 30186, 7, 1, 0, 0, 30186, 30187, 7, 6, 0, 0, 30187, 4494, + 1, 0, 0, 0, 30188, 30189, 7, 12, 0, 0, 30189, 30190, 7, 4, 0, 0, 30190, + 30191, 7, 16, 0, 0, 30191, 30192, 5, 49, 0, 0, 30192, 30193, 5, 54, 0, + 0, 30193, 30194, 7, 11, 0, 0, 30194, 30195, 7, 6, 0, 0, 30195, 4496, 1, + 0, 0, 0, 30196, 30197, 7, 12, 0, 0, 30197, 30198, 7, 4, 0, 0, 30198, 30199, + 7, 16, 0, 0, 30199, 30200, 5, 51, 0, 0, 30200, 30201, 5, 50, 0, 0, 30201, + 4498, 1, 0, 0, 0, 30202, 30203, 7, 12, 0, 0, 30203, 30204, 7, 4, 0, 0, + 30204, 30205, 7, 16, 0, 0, 30205, 30206, 5, 56, 0, 0, 30206, 4500, 1, 0, + 0, 0, 30207, 30208, 7, 13, 0, 0, 30208, 30209, 5, 49, 0, 0, 30209, 4502, + 1, 0, 0, 0, 30210, 30211, 7, 13, 0, 0, 30211, 30212, 5, 50, 0, 0, 30212, + 4504, 1, 0, 0, 0, 30213, 30214, 7, 13, 0, 0, 30214, 30215, 7, 0, 0, 0, + 30215, 30216, 7, 11, 0, 0, 30216, 30217, 7, 10, 0, 0, 30217, 30218, 7, + 9, 0, 0, 30218, 30219, 7, 0, 0, 0, 30219, 30220, 7, 4, 0, 0, 30220, 30221, + 7, 6, 0, 0, 30221, 4506, 1, 0, 0, 0, 30222, 30223, 7, 13, 0, 0, 30223, + 30224, 7, 0, 0, 0, 30224, 30225, 7, 11, 0, 0, 30225, 30226, 7, 10, 0, 0, + 30226, 30227, 7, 9, 0, 0, 30227, 30228, 7, 0, 0, 0, 30228, 30229, 7, 4, + 0, 0, 30229, 30230, 7, 6, 0, 0, 30230, 30231, 5, 95, 0, 0, 30231, 30232, + 7, 8, 0, 0, 30232, 30233, 7, 2, 0, 0, 30233, 30234, 7, 7, 0, 0, 30234, + 30235, 7, 13, 0, 0, 30235, 30236, 7, 6, 0, 0, 30236, 30237, 7, 3, 0, 0, + 30237, 30238, 7, 5, 0, 0, 30238, 30239, 7, 10, 0, 0, 30239, 30240, 7, 2, + 0, 0, 30240, 30241, 7, 7, 0, 0, 30241, 4508, 1, 0, 0, 0, 30242, 30243, + 7, 13, 0, 0, 30243, 30244, 7, 0, 0, 0, 30244, 30245, 7, 11, 0, 0, 30245, + 30246, 7, 10, 0, 0, 30246, 30247, 7, 9, 0, 0, 30247, 30248, 7, 0, 0, 0, + 30248, 30249, 7, 4, 0, 0, 30249, 30250, 7, 10, 0, 0, 30250, 30251, 7, 2, + 0, 0, 30251, 30252, 7, 7, 0, 0, 30252, 4510, 1, 0, 0, 0, 30253, 30254, + 7, 13, 0, 0, 30254, 30255, 7, 0, 0, 0, 30255, 30256, 7, 11, 0, 0, 30256, + 30257, 7, 10, 0, 0, 30257, 30258, 7, 9, 0, 0, 30258, 30259, 5, 95, 0, 0, + 30259, 30260, 7, 4, 0, 0, 30260, 30261, 7, 10, 0, 0, 30261, 30262, 7, 14, + 0, 0, 30262, 30263, 7, 6, 0, 0, 30263, 30264, 5, 95, 0, 0, 30264, 30265, + 7, 6, 0, 0, 30265, 30266, 7, 7, 0, 0, 30266, 30267, 7, 9, 0, 0, 30267, + 4512, 1, 0, 0, 0, 30268, 30269, 7, 13, 0, 0, 30269, 30270, 7, 0, 0, 0, + 30270, 30271, 7, 11, 0, 0, 30271, 30272, 7, 12, 0, 0, 30272, 30273, 7, + 6, 0, 0, 30273, 30274, 7, 5, 0, 0, 30274, 4514, 1, 0, 0, 0, 30275, 30276, + 7, 13, 0, 0, 30276, 30277, 7, 0, 0, 0, 30277, 30278, 7, 11, 0, 0, 30278, + 30279, 7, 12, 0, 0, 30279, 30280, 7, 6, 0, 0, 30280, 4516, 1, 0, 0, 0, + 30281, 30282, 7, 13, 0, 0, 30282, 30283, 7, 0, 0, 0, 30283, 30284, 7, 3, + 0, 0, 30284, 30285, 7, 8, 0, 0, 30285, 30286, 7, 19, 0, 0, 30286, 30287, + 7, 0, 0, 0, 30287, 30288, 7, 3, 0, 0, 30288, 30289, 5, 50, 0, 0, 30289, + 4518, 1, 0, 0, 0, 30290, 30291, 7, 13, 0, 0, 30291, 30292, 7, 0, 0, 0, + 30292, 30293, 7, 3, 0, 0, 30293, 30294, 7, 8, 0, 0, 30294, 30295, 7, 19, + 0, 0, 30295, 30296, 7, 0, 0, 0, 30296, 30297, 7, 3, 0, 0, 30297, 4520, + 1, 0, 0, 0, 30298, 30299, 7, 13, 0, 0, 30299, 30300, 7, 0, 0, 0, 30300, + 30301, 7, 3, 0, 0, 30301, 30302, 7, 8, 0, 0, 30302, 30303, 7, 19, 0, 0, + 30303, 30304, 7, 0, 0, 0, 30304, 30305, 7, 3, 0, 0, 30305, 30306, 7, 8, + 0, 0, 30306, 4522, 1, 0, 0, 0, 30307, 30308, 7, 13, 0, 0, 30308, 30309, + 7, 0, 0, 0, 30309, 30310, 7, 3, 0, 0, 30310, 30311, 7, 10, 0, 0, 30311, + 30312, 7, 0, 0, 0, 30312, 30313, 7, 1, 0, 0, 30313, 30314, 7, 11, 0, 0, + 30314, 30315, 7, 6, 0, 0, 30315, 4524, 1, 0, 0, 0, 30316, 30317, 7, 13, + 0, 0, 30317, 30318, 7, 0, 0, 0, 30318, 30319, 7, 3, 0, 0, 30319, 30320, + 7, 3, 0, 0, 30320, 30321, 7, 0, 0, 0, 30321, 30322, 7, 22, 0, 0, 30322, + 4526, 1, 0, 0, 0, 30323, 30324, 7, 13, 0, 0, 30324, 30325, 7, 0, 0, 0, + 30325, 30326, 7, 3, 0, 0, 30326, 30327, 7, 3, 0, 0, 30327, 30328, 7, 0, + 0, 0, 30328, 30329, 7, 22, 0, 0, 30329, 30330, 7, 8, 0, 0, 30330, 4528, + 1, 0, 0, 0, 30331, 30332, 7, 13, 0, 0, 30332, 30333, 7, 0, 0, 0, 30333, + 30334, 7, 3, 0, 0, 30334, 30335, 5, 95, 0, 0, 30335, 30336, 7, 15, 0, 0, + 30336, 30337, 7, 2, 0, 0, 30337, 30338, 7, 15, 0, 0, 30338, 4530, 1, 0, + 0, 0, 30339, 30340, 7, 13, 0, 0, 30340, 30341, 7, 0, 0, 0, 30341, 30342, + 7, 3, 0, 0, 30342, 30343, 7, 3, 0, 0, 30343, 30344, 7, 0, 0, 0, 30344, + 30345, 7, 18, 0, 0, 30345, 30346, 7, 5, 0, 0, 30346, 4532, 1, 0, 0, 0, + 30347, 30348, 7, 13, 0, 0, 30348, 30349, 7, 0, 0, 0, 30349, 30350, 7, 3, + 0, 0, 30350, 30351, 7, 3, 0, 0, 30351, 30352, 7, 0, 0, 0, 30352, 30353, + 7, 18, 0, 0, 30353, 4534, 1, 0, 0, 0, 30354, 30355, 7, 13, 0, 0, 30355, + 30356, 7, 0, 0, 0, 30356, 30357, 7, 3, 0, 0, 30357, 30358, 5, 95, 0, 0, + 30358, 30359, 7, 5, 0, 0, 30359, 30360, 7, 0, 0, 0, 30360, 30361, 7, 14, + 0, 0, 30361, 30362, 7, 15, 0, 0, 30362, 4536, 1, 0, 0, 0, 30363, 30364, + 7, 13, 0, 0, 30364, 30365, 7, 0, 0, 0, 30365, 30366, 7, 3, 0, 0, 30366, + 30367, 7, 18, 0, 0, 30367, 30368, 7, 10, 0, 0, 30368, 30369, 7, 7, 0, 0, + 30369, 30370, 7, 17, 0, 0, 30370, 4538, 1, 0, 0, 0, 30371, 30372, 7, 13, + 0, 0, 30372, 30373, 7, 6, 0, 0, 30373, 30374, 7, 8, 0, 0, 30374, 30375, + 7, 4, 0, 0, 30375, 30376, 7, 2, 0, 0, 30376, 30377, 7, 3, 0, 0, 30377, + 30378, 5, 95, 0, 0, 30378, 30379, 7, 3, 0, 0, 30379, 30380, 7, 6, 0, 0, + 30380, 30381, 7, 0, 0, 0, 30381, 30382, 7, 9, 0, 0, 30382, 30383, 5, 95, + 0, 0, 30383, 30384, 7, 4, 0, 0, 30384, 30385, 7, 3, 0, 0, 30385, 30386, + 7, 0, 0, 0, 30386, 30387, 7, 8, 0, 0, 30387, 30388, 7, 6, 0, 0, 30388, + 4540, 1, 0, 0, 0, 30389, 30390, 7, 13, 0, 0, 30390, 30391, 7, 6, 0, 0, + 30391, 30392, 7, 8, 0, 0, 30392, 30393, 7, 4, 0, 0, 30393, 30394, 7, 2, + 0, 0, 30394, 30395, 7, 3, 0, 0, 30395, 30396, 5, 95, 0, 0, 30396, 30397, + 7, 3, 0, 0, 30397, 30398, 7, 6, 0, 0, 30398, 30399, 7, 0, 0, 0, 30399, + 30400, 7, 9, 0, 0, 30400, 4542, 1, 0, 0, 0, 30401, 30402, 7, 13, 0, 0, + 30402, 30403, 7, 6, 0, 0, 30403, 30404, 7, 8, 0, 0, 30404, 30405, 7, 4, + 0, 0, 30405, 30406, 7, 2, 0, 0, 30406, 30407, 7, 3, 0, 0, 30407, 30408, + 5, 95, 0, 0, 30408, 30409, 7, 4, 0, 0, 30409, 30410, 7, 3, 0, 0, 30410, + 30411, 7, 0, 0, 0, 30411, 30412, 7, 7, 0, 0, 30412, 30413, 7, 5, 0, 0, + 30413, 30414, 7, 16, 0, 0, 30414, 30415, 7, 2, 0, 0, 30415, 30416, 7, 3, + 0, 0, 30416, 30417, 7, 14, 0, 0, 30417, 30418, 5, 95, 0, 0, 30418, 30419, + 7, 9, 0, 0, 30419, 30420, 7, 10, 0, 0, 30420, 30421, 7, 14, 0, 0, 30421, + 30422, 7, 5, 0, 0, 30422, 4544, 1, 0, 0, 0, 30423, 30424, 7, 13, 0, 0, + 30424, 30425, 7, 6, 0, 0, 30425, 30426, 7, 8, 0, 0, 30426, 30427, 7, 4, + 0, 0, 30427, 30428, 7, 2, 0, 0, 30428, 30429, 7, 3, 0, 0, 30429, 30430, + 5, 95, 0, 0, 30430, 30431, 7, 4, 0, 0, 30431, 30432, 7, 3, 0, 0, 30432, + 30433, 7, 0, 0, 0, 30433, 30434, 7, 7, 0, 0, 30434, 30435, 7, 5, 0, 0, + 30435, 30436, 7, 16, 0, 0, 30436, 30437, 7, 2, 0, 0, 30437, 30438, 7, 3, + 0, 0, 30438, 30439, 7, 14, 0, 0, 30439, 30440, 5, 95, 0, 0, 30440, 30441, + 7, 16, 0, 0, 30441, 30442, 7, 0, 0, 0, 30442, 30443, 7, 8, 0, 0, 30443, + 30444, 7, 4, 0, 0, 30444, 4546, 1, 0, 0, 0, 30445, 30446, 7, 13, 0, 0, + 30446, 30447, 7, 6, 0, 0, 30447, 30448, 7, 8, 0, 0, 30448, 30449, 7, 4, + 0, 0, 30449, 30450, 7, 2, 0, 0, 30450, 30451, 7, 3, 0, 0, 30451, 30452, + 5, 95, 0, 0, 30452, 30453, 7, 4, 0, 0, 30453, 30454, 7, 3, 0, 0, 30454, + 30455, 7, 0, 0, 0, 30455, 30456, 7, 7, 0, 0, 30456, 30457, 7, 5, 0, 0, + 30457, 30458, 7, 16, 0, 0, 30458, 30459, 7, 2, 0, 0, 30459, 30460, 7, 3, + 0, 0, 30460, 30461, 7, 14, 0, 0, 30461, 4548, 1, 0, 0, 0, 30462, 30463, + 7, 13, 0, 0, 30463, 30464, 7, 6, 0, 0, 30464, 30465, 7, 3, 0, 0, 30465, + 30466, 7, 10, 0, 0, 30466, 30467, 7, 16, 0, 0, 30467, 30468, 7, 10, 0, + 0, 30468, 30469, 7, 6, 0, 0, 30469, 30470, 7, 3, 0, 0, 30470, 4550, 1, + 0, 0, 0, 30471, 30472, 7, 13, 0, 0, 30472, 30473, 7, 6, 0, 0, 30473, 30474, + 7, 3, 0, 0, 30474, 30475, 7, 10, 0, 0, 30475, 30476, 7, 16, 0, 0, 30476, + 30477, 7, 18, 0, 0, 30477, 4552, 1, 0, 0, 0, 30478, 30479, 7, 13, 0, 0, + 30479, 30480, 7, 6, 0, 0, 30480, 30481, 7, 3, 0, 0, 30481, 30482, 7, 5, + 0, 0, 30482, 30483, 7, 10, 0, 0, 30483, 30484, 7, 2, 0, 0, 30484, 30485, + 7, 7, 0, 0, 30485, 30486, 7, 10, 0, 0, 30486, 30487, 7, 7, 0, 0, 30487, + 30488, 7, 17, 0, 0, 30488, 4554, 1, 0, 0, 0, 30489, 30490, 7, 13, 0, 0, + 30490, 30491, 7, 6, 0, 0, 30491, 30492, 7, 3, 0, 0, 30492, 30493, 7, 5, + 0, 0, 30493, 30494, 7, 10, 0, 0, 30494, 30495, 7, 2, 0, 0, 30495, 30496, + 7, 7, 0, 0, 30496, 30497, 7, 5, 0, 0, 30497, 30498, 5, 95, 0, 0, 30498, + 30499, 7, 6, 0, 0, 30499, 30500, 7, 7, 0, 0, 30500, 30501, 7, 9, 0, 0, + 30501, 30502, 7, 5, 0, 0, 30502, 30503, 7, 8, 0, 0, 30503, 30504, 7, 7, + 0, 0, 30504, 4556, 1, 0, 0, 0, 30505, 30506, 7, 13, 0, 0, 30506, 30507, + 7, 6, 0, 0, 30507, 30508, 7, 3, 0, 0, 30508, 30509, 7, 5, 0, 0, 30509, + 30510, 7, 10, 0, 0, 30510, 30511, 7, 2, 0, 0, 30511, 30512, 7, 7, 0, 0, + 30512, 30513, 7, 5, 0, 0, 30513, 30514, 5, 95, 0, 0, 30514, 30515, 7, 6, + 0, 0, 30515, 30516, 7, 7, 0, 0, 30516, 30517, 7, 9, 0, 0, 30517, 30518, + 7, 4, 0, 0, 30518, 30519, 7, 10, 0, 0, 30519, 30520, 7, 14, 0, 0, 30520, + 30521, 7, 6, 0, 0, 30521, 4558, 1, 0, 0, 0, 30522, 30523, 7, 13, 0, 0, + 30523, 30524, 7, 6, 0, 0, 30524, 30525, 7, 3, 0, 0, 30525, 30526, 7, 5, + 0, 0, 30526, 30527, 7, 10, 0, 0, 30527, 30528, 7, 2, 0, 0, 30528, 30529, + 7, 7, 0, 0, 30529, 30530, 7, 5, 0, 0, 30530, 30531, 5, 95, 0, 0, 30531, + 30532, 7, 2, 0, 0, 30532, 30533, 7, 15, 0, 0, 30533, 30534, 7, 6, 0, 0, + 30534, 30535, 7, 3, 0, 0, 30535, 30536, 7, 0, 0, 0, 30536, 30537, 7, 4, + 0, 0, 30537, 30538, 7, 10, 0, 0, 30538, 30539, 7, 2, 0, 0, 30539, 30540, + 7, 7, 0, 0, 30540, 4560, 1, 0, 0, 0, 30541, 30542, 7, 13, 0, 0, 30542, + 30543, 7, 6, 0, 0, 30543, 30544, 7, 3, 0, 0, 30544, 30545, 7, 5, 0, 0, + 30545, 30546, 7, 10, 0, 0, 30546, 30547, 7, 2, 0, 0, 30547, 30548, 7, 7, + 0, 0, 30548, 30549, 7, 5, 0, 0, 30549, 30550, 5, 95, 0, 0, 30550, 30551, + 7, 5, 0, 0, 30551, 30552, 7, 4, 0, 0, 30552, 30553, 7, 0, 0, 0, 30553, + 30554, 7, 3, 0, 0, 30554, 30555, 7, 4, 0, 0, 30555, 30556, 7, 5, 0, 0, + 30556, 30557, 7, 8, 0, 0, 30557, 30558, 7, 7, 0, 0, 30558, 4562, 1, 0, + 0, 0, 30559, 30560, 7, 13, 0, 0, 30560, 30561, 7, 6, 0, 0, 30561, 30562, + 7, 3, 0, 0, 30562, 30563, 7, 5, 0, 0, 30563, 30564, 7, 10, 0, 0, 30564, + 30565, 7, 2, 0, 0, 30565, 30566, 7, 7, 0, 0, 30566, 30567, 7, 5, 0, 0, + 30567, 30568, 5, 95, 0, 0, 30568, 30569, 7, 5, 0, 0, 30569, 30570, 7, 4, + 0, 0, 30570, 30571, 7, 0, 0, 0, 30571, 30572, 7, 3, 0, 0, 30572, 30573, + 7, 4, 0, 0, 30573, 30574, 7, 4, 0, 0, 30574, 30575, 7, 10, 0, 0, 30575, + 30576, 7, 14, 0, 0, 30576, 30577, 7, 6, 0, 0, 30577, 4564, 1, 0, 0, 0, + 30578, 30579, 7, 13, 0, 0, 30579, 30580, 7, 6, 0, 0, 30580, 30581, 7, 3, + 0, 0, 30581, 30582, 7, 5, 0, 0, 30582, 30583, 7, 10, 0, 0, 30583, 30584, + 7, 2, 0, 0, 30584, 30585, 7, 7, 0, 0, 30585, 30586, 7, 5, 0, 0, 30586, + 4566, 1, 0, 0, 0, 30587, 30588, 7, 13, 0, 0, 30588, 30589, 7, 6, 0, 0, + 30589, 30590, 7, 3, 0, 0, 30590, 30591, 7, 5, 0, 0, 30591, 30592, 7, 10, + 0, 0, 30592, 30593, 7, 2, 0, 0, 30593, 30594, 7, 7, 0, 0, 30594, 30595, + 7, 5, 0, 0, 30595, 30596, 5, 95, 0, 0, 30596, 30597, 7, 25, 0, 0, 30597, + 30598, 7, 10, 0, 0, 30598, 30599, 7, 9, 0, 0, 30599, 4568, 1, 0, 0, 0, + 30600, 30601, 7, 13, 0, 0, 30601, 30602, 7, 6, 0, 0, 30602, 30603, 7, 3, + 0, 0, 30603, 30604, 7, 5, 0, 0, 30604, 30605, 7, 10, 0, 0, 30605, 30606, + 7, 2, 0, 0, 30606, 30607, 7, 7, 0, 0, 30607, 4570, 1, 0, 0, 0, 30608, 30609, + 7, 13, 0, 0, 30609, 30610, 7, 10, 0, 0, 30610, 30611, 7, 6, 0, 0, 30611, + 30612, 7, 22, 0, 0, 30612, 4572, 1, 0, 0, 0, 30613, 30614, 7, 13, 0, 0, + 30614, 30615, 7, 10, 0, 0, 30615, 30616, 7, 2, 0, 0, 30616, 30617, 7, 11, + 0, 0, 30617, 30618, 7, 0, 0, 0, 30618, 30619, 7, 4, 0, 0, 30619, 30620, + 7, 10, 0, 0, 30620, 30621, 7, 2, 0, 0, 30621, 30622, 7, 7, 0, 0, 30622, + 4574, 1, 0, 0, 0, 30623, 30624, 7, 13, 0, 0, 30624, 30625, 7, 10, 0, 0, + 30625, 30626, 7, 3, 0, 0, 30626, 30627, 7, 4, 0, 0, 30627, 30628, 7, 12, + 0, 0, 30628, 30629, 7, 0, 0, 0, 30629, 30630, 7, 11, 0, 0, 30630, 4576, + 1, 0, 0, 0, 30631, 30632, 7, 13, 0, 0, 30632, 30633, 7, 10, 0, 0, 30633, + 30634, 7, 5, 0, 0, 30634, 30635, 7, 10, 0, 0, 30635, 30636, 7, 1, 0, 0, + 30636, 30637, 7, 10, 0, 0, 30637, 30638, 7, 11, 0, 0, 30638, 30639, 7, + 10, 0, 0, 30639, 30640, 7, 4, 0, 0, 30640, 30641, 7, 18, 0, 0, 30641, 4578, + 1, 0, 0, 0, 30642, 30643, 7, 13, 0, 0, 30643, 30644, 7, 10, 0, 0, 30644, + 30645, 7, 5, 0, 0, 30645, 30646, 7, 10, 0, 0, 30646, 30647, 7, 1, 0, 0, + 30647, 30648, 7, 11, 0, 0, 30648, 30649, 7, 6, 0, 0, 30649, 4580, 1, 0, + 0, 0, 30650, 30651, 7, 13, 0, 0, 30651, 30652, 7, 2, 0, 0, 30652, 30653, + 7, 11, 0, 0, 30653, 30654, 7, 12, 0, 0, 30654, 30655, 7, 14, 0, 0, 30655, + 30656, 7, 6, 0, 0, 30656, 4582, 1, 0, 0, 0, 30657, 30658, 7, 13, 0, 0, + 30658, 30659, 7, 5, 0, 0, 30659, 30660, 7, 10, 0, 0, 30660, 30661, 7, 23, + 0, 0, 30661, 30662, 7, 6, 0, 0, 30662, 4584, 1, 0, 0, 0, 30663, 30664, + 7, 22, 0, 0, 30664, 30665, 7, 0, 0, 0, 30665, 30666, 7, 10, 0, 0, 30666, + 30667, 7, 4, 0, 0, 30667, 4586, 1, 0, 0, 0, 30668, 30669, 7, 22, 0, 0, + 30669, 30670, 7, 0, 0, 0, 30670, 30671, 7, 11, 0, 0, 30671, 30672, 7, 11, + 0, 0, 30672, 30673, 7, 6, 0, 0, 30673, 30674, 7, 4, 0, 0, 30674, 4588, + 1, 0, 0, 0, 30675, 30676, 7, 22, 0, 0, 30676, 30677, 7, 0, 0, 0, 30677, + 30678, 7, 3, 0, 0, 30678, 30679, 7, 7, 0, 0, 30679, 30680, 7, 10, 0, 0, + 30680, 30681, 7, 7, 0, 0, 30681, 30682, 7, 17, 0, 0, 30682, 4590, 1, 0, + 0, 0, 30683, 30684, 7, 22, 0, 0, 30684, 30685, 7, 6, 0, 0, 30685, 30686, + 7, 6, 0, 0, 30686, 30687, 7, 21, 0, 0, 30687, 30688, 7, 5, 0, 0, 30688, + 4592, 1, 0, 0, 0, 30689, 30690, 7, 22, 0, 0, 30690, 30691, 7, 6, 0, 0, + 30691, 30692, 7, 6, 0, 0, 30692, 30693, 7, 21, 0, 0, 30693, 4594, 1, 0, + 0, 0, 30694, 30695, 7, 22, 0, 0, 30695, 30696, 7, 6, 0, 0, 30696, 30697, + 7, 11, 0, 0, 30697, 30698, 7, 11, 0, 0, 30698, 30699, 7, 16, 0, 0, 30699, + 30700, 7, 2, 0, 0, 30700, 30701, 7, 3, 0, 0, 30701, 30702, 7, 14, 0, 0, + 30702, 30703, 7, 6, 0, 0, 30703, 30704, 7, 9, 0, 0, 30704, 4596, 1, 0, + 0, 0, 30705, 30706, 7, 22, 0, 0, 30706, 30707, 7, 19, 0, 0, 30707, 30708, + 7, 6, 0, 0, 30708, 30709, 7, 7, 0, 0, 30709, 30710, 7, 6, 0, 0, 30710, + 30711, 7, 13, 0, 0, 30711, 30712, 7, 6, 0, 0, 30712, 30713, 7, 3, 0, 0, + 30713, 4598, 1, 0, 0, 0, 30714, 30715, 7, 22, 0, 0, 30715, 30716, 7, 19, + 0, 0, 30716, 30717, 7, 6, 0, 0, 30717, 30718, 7, 7, 0, 0, 30718, 4600, + 1, 0, 0, 0, 30719, 30720, 7, 22, 0, 0, 30720, 30721, 7, 19, 0, 0, 30721, + 30722, 7, 6, 0, 0, 30722, 30723, 7, 3, 0, 0, 30723, 30724, 7, 6, 0, 0, + 30724, 4602, 1, 0, 0, 0, 30725, 30726, 7, 22, 0, 0, 30726, 30727, 7, 19, + 0, 0, 30727, 30728, 7, 10, 0, 0, 30728, 30729, 7, 11, 0, 0, 30729, 30730, + 7, 6, 0, 0, 30730, 4604, 1, 0, 0, 0, 30731, 30732, 7, 22, 0, 0, 30732, + 30733, 7, 19, 0, 0, 30733, 30734, 7, 10, 0, 0, 30734, 30735, 7, 4, 0, 0, + 30735, 30736, 7, 6, 0, 0, 30736, 30737, 7, 5, 0, 0, 30737, 30738, 7, 15, + 0, 0, 30738, 30739, 7, 0, 0, 0, 30739, 30740, 7, 8, 0, 0, 30740, 30741, + 7, 6, 0, 0, 30741, 4606, 1, 0, 0, 0, 30742, 30743, 7, 22, 0, 0, 30743, + 30744, 7, 10, 0, 0, 30744, 30745, 7, 9, 0, 0, 30745, 30746, 7, 4, 0, 0, + 30746, 30747, 7, 19, 0, 0, 30747, 30748, 5, 95, 0, 0, 30748, 30749, 7, + 1, 0, 0, 30749, 30750, 7, 12, 0, 0, 30750, 30751, 7, 8, 0, 0, 30751, 30752, + 7, 21, 0, 0, 30752, 30753, 7, 6, 0, 0, 30753, 30754, 7, 4, 0, 0, 30754, + 4608, 1, 0, 0, 0, 30755, 30756, 7, 22, 0, 0, 30756, 30757, 7, 10, 0, 0, + 30757, 30758, 7, 4, 0, 0, 30758, 30759, 7, 19, 0, 0, 30759, 30760, 7, 10, + 0, 0, 30760, 30761, 7, 7, 0, 0, 30761, 4610, 1, 0, 0, 0, 30762, 30763, + 7, 22, 0, 0, 30763, 30764, 7, 10, 0, 0, 30764, 30765, 7, 4, 0, 0, 30765, + 30766, 7, 19, 0, 0, 30766, 30767, 7, 2, 0, 0, 30767, 30768, 7, 12, 0, 0, + 30768, 30769, 7, 4, 0, 0, 30769, 4612, 1, 0, 0, 0, 30770, 30771, 7, 22, + 0, 0, 30771, 30772, 7, 10, 0, 0, 30772, 30773, 7, 4, 0, 0, 30773, 30774, + 7, 19, 0, 0, 30774, 30775, 5, 95, 0, 0, 30775, 30776, 7, 15, 0, 0, 30776, + 30777, 7, 11, 0, 0, 30777, 30778, 7, 5, 0, 0, 30778, 30779, 7, 24, 0, 0, + 30779, 30780, 7, 11, 0, 0, 30780, 4614, 1, 0, 0, 0, 30781, 30782, 7, 22, + 0, 0, 30782, 30783, 7, 10, 0, 0, 30783, 30784, 7, 4, 0, 0, 30784, 30785, + 7, 19, 0, 0, 30785, 4616, 1, 0, 0, 0, 30786, 30787, 7, 22, 0, 0, 30787, + 30788, 7, 2, 0, 0, 30788, 30789, 7, 3, 0, 0, 30789, 30790, 7, 21, 0, 0, + 30790, 4618, 1, 0, 0, 0, 30791, 30792, 7, 22, 0, 0, 30792, 30793, 7, 2, + 0, 0, 30793, 30794, 7, 3, 0, 0, 30794, 30795, 7, 21, 0, 0, 30795, 30796, + 7, 6, 0, 0, 30796, 30797, 7, 3, 0, 0, 30797, 30798, 7, 10, 0, 0, 30798, + 30799, 7, 9, 0, 0, 30799, 4620, 1, 0, 0, 0, 30800, 30801, 7, 22, 0, 0, + 30801, 30802, 7, 3, 0, 0, 30802, 30803, 7, 0, 0, 0, 30803, 30804, 7, 15, + 0, 0, 30804, 30805, 7, 15, 0, 0, 30805, 30806, 7, 6, 0, 0, 30806, 30807, + 7, 9, 0, 0, 30807, 4622, 1, 0, 0, 0, 30808, 30809, 7, 22, 0, 0, 30809, + 30810, 7, 3, 0, 0, 30810, 30811, 7, 0, 0, 0, 30811, 30812, 7, 15, 0, 0, + 30812, 30813, 7, 15, 0, 0, 30813, 30814, 7, 6, 0, 0, 30814, 30815, 7, 3, + 0, 0, 30815, 4624, 1, 0, 0, 0, 30816, 30817, 7, 22, 0, 0, 30817, 30818, + 7, 3, 0, 0, 30818, 30819, 7, 10, 0, 0, 30819, 30820, 7, 4, 0, 0, 30820, + 30821, 7, 6, 0, 0, 30821, 4626, 1, 0, 0, 0, 30822, 30823, 7, 25, 0, 0, + 30823, 30824, 7, 9, 0, 0, 30824, 30825, 7, 1, 0, 0, 30825, 30826, 5, 95, + 0, 0, 30826, 30827, 7, 16, 0, 0, 30827, 30828, 7, 0, 0, 0, 30828, 30829, + 7, 5, 0, 0, 30829, 30830, 7, 4, 0, 0, 30830, 30831, 7, 15, 0, 0, 30831, + 30832, 7, 0, 0, 0, 30832, 30833, 7, 4, 0, 0, 30833, 30834, 7, 19, 0, 0, + 30834, 30835, 5, 95, 0, 0, 30835, 30836, 7, 10, 0, 0, 30836, 30837, 7, + 7, 0, 0, 30837, 30838, 7, 5, 0, 0, 30838, 30839, 7, 6, 0, 0, 30839, 30840, + 7, 3, 0, 0, 30840, 30841, 7, 4, 0, 0, 30841, 4628, 1, 0, 0, 0, 30842, 30843, + 7, 25, 0, 0, 30843, 30844, 7, 9, 0, 0, 30844, 30845, 7, 1, 0, 0, 30845, + 4630, 1, 0, 0, 0, 30846, 30847, 7, 25, 0, 0, 30847, 30848, 5, 95, 0, 0, + 30848, 30849, 7, 9, 0, 0, 30849, 30850, 7, 18, 0, 0, 30850, 30851, 7, 7, + 0, 0, 30851, 30852, 5, 95, 0, 0, 30852, 30853, 7, 15, 0, 0, 30853, 30854, + 7, 3, 0, 0, 30854, 30855, 7, 12, 0, 0, 30855, 30856, 7, 7, 0, 0, 30856, + 30857, 7, 6, 0, 0, 30857, 4632, 1, 0, 0, 0, 30858, 30859, 7, 25, 0, 0, + 30859, 30860, 7, 10, 0, 0, 30860, 30861, 7, 9, 0, 0, 30861, 4634, 1, 0, + 0, 0, 30862, 30863, 7, 25, 0, 0, 30863, 30864, 7, 14, 0, 0, 30864, 30865, + 7, 11, 0, 0, 30865, 30866, 5, 50, 0, 0, 30866, 30867, 7, 2, 0, 0, 30867, + 30868, 7, 1, 0, 0, 30868, 30869, 7, 20, 0, 0, 30869, 30870, 7, 6, 0, 0, + 30870, 30871, 7, 8, 0, 0, 30871, 30872, 7, 4, 0, 0, 30872, 4636, 1, 0, + 0, 0, 30873, 30874, 7, 25, 0, 0, 30874, 30875, 7, 14, 0, 0, 30875, 30876, + 7, 11, 0, 0, 30876, 30877, 7, 0, 0, 0, 30877, 30878, 7, 17, 0, 0, 30878, + 30879, 7, 17, 0, 0, 30879, 4638, 1, 0, 0, 0, 30880, 30881, 7, 25, 0, 0, + 30881, 30882, 7, 14, 0, 0, 30882, 30883, 7, 11, 0, 0, 30883, 30884, 7, + 0, 0, 0, 30884, 30885, 7, 4, 0, 0, 30885, 30886, 7, 4, 0, 0, 30886, 30887, + 7, 3, 0, 0, 30887, 30888, 7, 10, 0, 0, 30888, 30889, 7, 1, 0, 0, 30889, + 30890, 7, 12, 0, 0, 30890, 30891, 7, 4, 0, 0, 30891, 30892, 7, 6, 0, 0, + 30892, 30893, 7, 5, 0, 0, 30893, 4640, 1, 0, 0, 0, 30894, 30895, 7, 25, + 0, 0, 30895, 30896, 7, 14, 0, 0, 30896, 30897, 7, 11, 0, 0, 30897, 30898, + 7, 8, 0, 0, 30898, 30899, 7, 0, 0, 0, 30899, 30900, 7, 5, 0, 0, 30900, + 30901, 7, 4, 0, 0, 30901, 4642, 1, 0, 0, 0, 30902, 30903, 7, 25, 0, 0, + 30903, 30904, 7, 14, 0, 0, 30904, 30905, 7, 11, 0, 0, 30905, 30906, 7, + 8, 0, 0, 30906, 30907, 7, 9, 0, 0, 30907, 30908, 7, 0, 0, 0, 30908, 30909, + 7, 4, 0, 0, 30909, 30910, 7, 0, 0, 0, 30910, 4644, 1, 0, 0, 0, 30911, 30912, + 7, 25, 0, 0, 30912, 30913, 7, 14, 0, 0, 30913, 30914, 7, 11, 0, 0, 30914, + 30915, 7, 8, 0, 0, 30915, 30916, 7, 2, 0, 0, 30916, 30917, 7, 11, 0, 0, + 30917, 30918, 7, 0, 0, 0, 30918, 30919, 7, 4, 0, 0, 30919, 30920, 7, 4, + 0, 0, 30920, 30921, 7, 13, 0, 0, 30921, 30922, 7, 0, 0, 0, 30922, 30923, + 7, 11, 0, 0, 30923, 4646, 1, 0, 0, 0, 30924, 30925, 7, 25, 0, 0, 30925, + 30926, 7, 14, 0, 0, 30926, 30927, 7, 11, 0, 0, 30927, 30928, 7, 8, 0, 0, + 30928, 30929, 7, 2, 0, 0, 30929, 30930, 7, 14, 0, 0, 30930, 30931, 7, 14, + 0, 0, 30931, 30932, 7, 6, 0, 0, 30932, 30933, 7, 7, 0, 0, 30933, 30934, + 7, 4, 0, 0, 30934, 4648, 1, 0, 0, 0, 30935, 30936, 7, 25, 0, 0, 30936, + 30937, 7, 14, 0, 0, 30937, 30938, 7, 11, 0, 0, 30938, 30939, 7, 8, 0, 0, + 30939, 30940, 7, 2, 0, 0, 30940, 30941, 7, 7, 0, 0, 30941, 30942, 7, 8, + 0, 0, 30942, 30943, 7, 0, 0, 0, 30943, 30944, 7, 4, 0, 0, 30944, 4650, + 1, 0, 0, 0, 30945, 30946, 7, 25, 0, 0, 30946, 30947, 7, 14, 0, 0, 30947, + 30948, 7, 11, 0, 0, 30948, 30949, 7, 9, 0, 0, 30949, 30950, 7, 10, 0, 0, + 30950, 30951, 7, 16, 0, 0, 30951, 30952, 7, 16, 0, 0, 30952, 4652, 1, 0, + 0, 0, 30953, 30954, 7, 25, 0, 0, 30954, 30955, 7, 14, 0, 0, 30955, 30956, + 7, 11, 0, 0, 30956, 30957, 5, 95, 0, 0, 30957, 30958, 7, 9, 0, 0, 30958, + 30959, 7, 14, 0, 0, 30959, 30960, 7, 11, 0, 0, 30960, 30961, 5, 95, 0, + 0, 30961, 30962, 7, 3, 0, 0, 30962, 30963, 7, 22, 0, 0, 30963, 30964, 7, + 4, 0, 0, 30964, 30965, 5, 95, 0, 0, 30965, 30966, 7, 5, 0, 0, 30966, 30967, + 7, 4, 0, 0, 30967, 30968, 7, 14, 0, 0, 30968, 30969, 7, 4, 0, 0, 30969, + 4654, 1, 0, 0, 0, 30970, 30971, 7, 25, 0, 0, 30971, 30972, 7, 14, 0, 0, + 30972, 30973, 7, 11, 0, 0, 30973, 30974, 7, 6, 0, 0, 30974, 30975, 7, 11, + 0, 0, 30975, 30976, 7, 6, 0, 0, 30976, 30977, 7, 14, 0, 0, 30977, 30978, + 7, 6, 0, 0, 30978, 30979, 7, 7, 0, 0, 30979, 30980, 7, 4, 0, 0, 30980, + 4656, 1, 0, 0, 0, 30981, 30982, 7, 25, 0, 0, 30982, 30983, 7, 14, 0, 0, + 30983, 30984, 7, 11, 0, 0, 30984, 30985, 7, 6, 0, 0, 30985, 30986, 7, 25, + 0, 0, 30986, 30987, 7, 10, 0, 0, 30987, 30988, 7, 5, 0, 0, 30988, 30989, + 7, 4, 0, 0, 30989, 30990, 7, 5, 0, 0, 30990, 30991, 5, 50, 0, 0, 30991, + 4658, 1, 0, 0, 0, 30992, 30993, 7, 25, 0, 0, 30993, 30994, 7, 14, 0, 0, + 30994, 30995, 7, 11, 0, 0, 30995, 30996, 7, 6, 0, 0, 30996, 30997, 7, 25, + 0, 0, 30997, 30998, 7, 10, 0, 0, 30998, 30999, 7, 5, 0, 0, 30999, 31000, + 7, 4, 0, 0, 31000, 31001, 7, 5, 0, 0, 31001, 4660, 1, 0, 0, 0, 31002, 31003, + 7, 25, 0, 0, 31003, 31004, 7, 14, 0, 0, 31004, 31005, 7, 11, 0, 0, 31005, + 31006, 7, 16, 0, 0, 31006, 31007, 7, 2, 0, 0, 31007, 31008, 7, 3, 0, 0, + 31008, 31009, 7, 6, 0, 0, 31009, 31010, 7, 5, 0, 0, 31010, 31011, 7, 4, + 0, 0, 31011, 4662, 1, 0, 0, 0, 31012, 31013, 7, 25, 0, 0, 31013, 31014, + 7, 14, 0, 0, 31014, 31015, 7, 11, 0, 0, 31015, 31016, 7, 10, 0, 0, 31016, + 31017, 7, 7, 0, 0, 31017, 31018, 7, 9, 0, 0, 31018, 31019, 7, 6, 0, 0, + 31019, 31020, 7, 25, 0, 0, 31020, 4664, 1, 0, 0, 0, 31021, 31022, 7, 25, + 0, 0, 31022, 31023, 7, 14, 0, 0, 31023, 31024, 7, 11, 0, 0, 31024, 31025, + 7, 10, 0, 0, 31025, 31026, 7, 7, 0, 0, 31026, 31027, 7, 9, 0, 0, 31027, + 31028, 7, 6, 0, 0, 31028, 31029, 7, 25, 0, 0, 31029, 31030, 5, 95, 0, 0, + 31030, 31031, 7, 3, 0, 0, 31031, 31032, 7, 6, 0, 0, 31032, 31033, 7, 22, + 0, 0, 31033, 31034, 7, 3, 0, 0, 31034, 31035, 7, 10, 0, 0, 31035, 31036, + 7, 4, 0, 0, 31036, 31037, 7, 6, 0, 0, 31037, 31038, 5, 95, 0, 0, 31038, + 31039, 7, 10, 0, 0, 31039, 31040, 7, 7, 0, 0, 31040, 31041, 5, 95, 0, 0, + 31041, 31042, 7, 5, 0, 0, 31042, 31043, 7, 6, 0, 0, 31043, 31044, 7, 11, + 0, 0, 31044, 31045, 7, 6, 0, 0, 31045, 31046, 7, 8, 0, 0, 31046, 31047, + 7, 4, 0, 0, 31047, 4666, 1, 0, 0, 0, 31048, 31049, 7, 25, 0, 0, 31049, + 31050, 7, 14, 0, 0, 31050, 31051, 7, 11, 0, 0, 31051, 31052, 7, 10, 0, + 0, 31052, 31053, 7, 7, 0, 0, 31053, 31054, 7, 9, 0, 0, 31054, 31055, 7, + 6, 0, 0, 31055, 31056, 7, 25, 0, 0, 31056, 31057, 5, 95, 0, 0, 31057, 31058, + 7, 3, 0, 0, 31058, 31059, 7, 6, 0, 0, 31059, 31060, 7, 22, 0, 0, 31060, + 31061, 7, 3, 0, 0, 31061, 31062, 7, 10, 0, 0, 31062, 31063, 7, 4, 0, 0, + 31063, 31064, 7, 6, 0, 0, 31064, 4668, 1, 0, 0, 0, 31065, 31066, 7, 25, + 0, 0, 31066, 31067, 7, 14, 0, 0, 31067, 31068, 7, 11, 0, 0, 31068, 31069, + 7, 10, 0, 0, 31069, 31070, 7, 7, 0, 0, 31070, 31071, 7, 9, 0, 0, 31071, + 31072, 7, 6, 0, 0, 31072, 31073, 7, 25, 0, 0, 31073, 31074, 5, 95, 0, 0, + 31074, 31075, 7, 5, 0, 0, 31075, 31076, 7, 6, 0, 0, 31076, 31077, 7, 11, + 0, 0, 31077, 31078, 5, 95, 0, 0, 31078, 31079, 7, 10, 0, 0, 31079, 31080, + 7, 9, 0, 0, 31080, 31081, 7, 25, 0, 0, 31081, 31082, 5, 95, 0, 0, 31082, + 31083, 7, 4, 0, 0, 31083, 31084, 7, 1, 0, 0, 31084, 31085, 7, 11, 0, 0, + 31085, 4670, 1, 0, 0, 0, 31086, 31087, 7, 25, 0, 0, 31087, 31088, 7, 14, + 0, 0, 31088, 31089, 7, 11, 0, 0, 31089, 31090, 7, 10, 0, 0, 31090, 31091, + 7, 5, 0, 0, 31091, 31092, 7, 7, 0, 0, 31092, 31093, 7, 2, 0, 0, 31093, + 31094, 7, 9, 0, 0, 31094, 31095, 7, 6, 0, 0, 31095, 4672, 1, 0, 0, 0, 31096, + 31097, 7, 25, 0, 0, 31097, 31098, 7, 14, 0, 0, 31098, 31099, 7, 11, 0, + 0, 31099, 31100, 7, 10, 0, 0, 31100, 31101, 7, 5, 0, 0, 31101, 31102, 7, + 13, 0, 0, 31102, 31103, 7, 0, 0, 0, 31103, 31104, 7, 11, 0, 0, 31104, 31105, + 7, 10, 0, 0, 31105, 31106, 7, 9, 0, 0, 31106, 4674, 1, 0, 0, 0, 31107, + 31108, 7, 25, 0, 0, 31108, 31109, 7, 14, 0, 0, 31109, 31110, 7, 11, 0, + 0, 31110, 31111, 7, 7, 0, 0, 31111, 31112, 7, 0, 0, 0, 31112, 31113, 7, + 14, 0, 0, 31113, 31114, 7, 6, 0, 0, 31114, 31115, 7, 5, 0, 0, 31115, 31116, + 7, 15, 0, 0, 31116, 31117, 7, 0, 0, 0, 31117, 31118, 7, 8, 0, 0, 31118, + 31119, 7, 6, 0, 0, 31119, 31120, 7, 5, 0, 0, 31120, 4676, 1, 0, 0, 0, 31121, + 31122, 7, 25, 0, 0, 31122, 31123, 7, 14, 0, 0, 31123, 31124, 7, 11, 0, + 0, 31124, 31125, 7, 15, 0, 0, 31125, 31126, 7, 0, 0, 0, 31126, 31127, 7, + 3, 0, 0, 31127, 31128, 7, 5, 0, 0, 31128, 31129, 7, 6, 0, 0, 31129, 4678, + 1, 0, 0, 0, 31130, 31131, 7, 25, 0, 0, 31131, 31132, 7, 14, 0, 0, 31132, + 31133, 7, 11, 0, 0, 31133, 31134, 7, 15, 0, 0, 31134, 31135, 7, 0, 0, 0, + 31135, 31136, 7, 4, 0, 0, 31136, 31137, 7, 8, 0, 0, 31137, 31138, 7, 19, + 0, 0, 31138, 4680, 1, 0, 0, 0, 31139, 31140, 7, 25, 0, 0, 31140, 31141, + 7, 14, 0, 0, 31141, 31142, 7, 11, 0, 0, 31142, 31143, 7, 15, 0, 0, 31143, + 31144, 7, 10, 0, 0, 31144, 4682, 1, 0, 0, 0, 31145, 31146, 7, 25, 0, 0, + 31146, 31147, 7, 14, 0, 0, 31147, 31148, 7, 11, 0, 0, 31148, 31149, 7, + 24, 0, 0, 31149, 31150, 7, 12, 0, 0, 31150, 31151, 7, 6, 0, 0, 31151, 31152, + 7, 3, 0, 0, 31152, 31153, 7, 18, 0, 0, 31153, 31154, 7, 13, 0, 0, 31154, + 31155, 7, 0, 0, 0, 31155, 31156, 7, 11, 0, 0, 31156, 4684, 1, 0, 0, 0, + 31157, 31158, 7, 25, 0, 0, 31158, 31159, 7, 14, 0, 0, 31159, 31160, 7, + 11, 0, 0, 31160, 31161, 7, 24, 0, 0, 31161, 31162, 7, 12, 0, 0, 31162, + 31163, 7, 6, 0, 0, 31163, 31164, 7, 3, 0, 0, 31164, 31165, 7, 18, 0, 0, + 31165, 4686, 1, 0, 0, 0, 31166, 31167, 7, 25, 0, 0, 31167, 31168, 7, 14, + 0, 0, 31168, 31169, 7, 11, 0, 0, 31169, 31170, 7, 3, 0, 0, 31170, 31171, + 7, 2, 0, 0, 31171, 31172, 7, 2, 0, 0, 31172, 31173, 7, 4, 0, 0, 31173, + 4688, 1, 0, 0, 0, 31174, 31175, 7, 25, 0, 0, 31175, 31176, 7, 14, 0, 0, + 31176, 31177, 7, 11, 0, 0, 31177, 31178, 7, 5, 0, 0, 31178, 31179, 7, 8, + 0, 0, 31179, 31180, 7, 19, 0, 0, 31180, 31181, 7, 6, 0, 0, 31181, 31182, + 7, 14, 0, 0, 31182, 31183, 7, 0, 0, 0, 31183, 4690, 1, 0, 0, 0, 31184, + 31185, 7, 25, 0, 0, 31185, 31186, 7, 14, 0, 0, 31186, 31187, 7, 11, 0, + 0, 31187, 31188, 7, 5, 0, 0, 31188, 31189, 7, 6, 0, 0, 31189, 31190, 7, + 3, 0, 0, 31190, 31191, 7, 10, 0, 0, 31191, 31192, 7, 0, 0, 0, 31192, 31193, + 7, 11, 0, 0, 31193, 31194, 7, 10, 0, 0, 31194, 31195, 7, 23, 0, 0, 31195, + 31196, 7, 6, 0, 0, 31196, 4692, 1, 0, 0, 0, 31197, 31198, 7, 25, 0, 0, + 31198, 31199, 7, 14, 0, 0, 31199, 31200, 7, 11, 0, 0, 31200, 31201, 7, + 4, 0, 0, 31201, 31202, 7, 0, 0, 0, 31202, 31203, 7, 1, 0, 0, 31203, 31204, + 7, 11, 0, 0, 31204, 31205, 7, 6, 0, 0, 31205, 4694, 1, 0, 0, 0, 31206, + 31207, 7, 25, 0, 0, 31207, 31208, 7, 14, 0, 0, 31208, 31209, 7, 11, 0, + 0, 31209, 31210, 7, 4, 0, 0, 31210, 31211, 7, 0, 0, 0, 31211, 31212, 7, + 17, 0, 0, 31212, 4696, 1, 0, 0, 0, 31213, 31214, 7, 25, 0, 0, 31214, 31215, + 7, 14, 0, 0, 31215, 31216, 7, 11, 0, 0, 31216, 31217, 7, 4, 0, 0, 31217, + 31218, 7, 3, 0, 0, 31218, 31219, 7, 0, 0, 0, 31219, 31220, 7, 7, 0, 0, + 31220, 31221, 7, 5, 0, 0, 31221, 31222, 7, 16, 0, 0, 31222, 31223, 7, 2, + 0, 0, 31223, 31224, 7, 3, 0, 0, 31224, 31225, 7, 14, 0, 0, 31225, 31226, + 7, 1, 0, 0, 31226, 31227, 7, 11, 0, 0, 31227, 31228, 7, 2, 0, 0, 31228, + 31229, 7, 1, 0, 0, 31229, 4698, 1, 0, 0, 0, 31230, 31231, 7, 25, 0, 0, + 31231, 31232, 7, 14, 0, 0, 31232, 31233, 7, 11, 0, 0, 31233, 31234, 7, + 4, 0, 0, 31234, 31235, 7, 3, 0, 0, 31235, 31236, 7, 0, 0, 0, 31236, 31237, + 7, 7, 0, 0, 31237, 31238, 7, 5, 0, 0, 31238, 31239, 7, 16, 0, 0, 31239, + 31240, 7, 2, 0, 0, 31240, 31241, 7, 3, 0, 0, 31241, 31242, 7, 14, 0, 0, + 31242, 4700, 1, 0, 0, 0, 31243, 31244, 7, 25, 0, 0, 31244, 31245, 7, 14, + 0, 0, 31245, 31246, 7, 11, 0, 0, 31246, 31247, 7, 4, 0, 0, 31247, 31248, + 7, 18, 0, 0, 31248, 31249, 7, 15, 0, 0, 31249, 31250, 7, 6, 0, 0, 31250, + 4702, 1, 0, 0, 0, 31251, 31252, 7, 25, 0, 0, 31252, 31253, 7, 14, 0, 0, + 31253, 31254, 7, 11, 0, 0, 31254, 4704, 1, 0, 0, 0, 31255, 31256, 7, 25, + 0, 0, 31256, 31257, 7, 15, 0, 0, 31257, 31258, 7, 0, 0, 0, 31258, 31259, + 7, 4, 0, 0, 31259, 31260, 7, 19, 0, 0, 31260, 31261, 7, 4, 0, 0, 31261, + 31262, 7, 0, 0, 0, 31262, 31263, 7, 1, 0, 0, 31263, 31264, 7, 11, 0, 0, + 31264, 31265, 7, 6, 0, 0, 31265, 4706, 1, 0, 0, 0, 31266, 31267, 7, 25, + 0, 0, 31267, 31268, 7, 5, 0, 0, 31268, 31269, 5, 95, 0, 0, 31269, 31270, + 7, 5, 0, 0, 31270, 31271, 7, 18, 0, 0, 31271, 31272, 7, 5, 0, 0, 31272, + 31273, 5, 95, 0, 0, 31273, 31274, 7, 8, 0, 0, 31274, 31275, 7, 2, 0, 0, + 31275, 31276, 7, 7, 0, 0, 31276, 31277, 7, 4, 0, 0, 31277, 31278, 7, 6, + 0, 0, 31278, 31279, 7, 25, 0, 0, 31279, 31280, 7, 4, 0, 0, 31280, 4708, + 1, 0, 0, 0, 31281, 31282, 7, 25, 0, 0, 31282, 31283, 7, 5, 0, 0, 31283, + 4710, 1, 0, 0, 0, 31284, 31285, 7, 25, 0, 0, 31285, 31286, 7, 4, 0, 0, + 31286, 31287, 7, 3, 0, 0, 31287, 31288, 7, 0, 0, 0, 31288, 31289, 7, 7, + 0, 0, 31289, 31290, 7, 5, 0, 0, 31290, 31291, 7, 15, 0, 0, 31291, 31292, + 7, 2, 0, 0, 31292, 31293, 7, 3, 0, 0, 31293, 31294, 7, 4, 0, 0, 31294, + 4712, 1, 0, 0, 0, 31295, 31296, 7, 18, 0, 0, 31296, 31297, 7, 6, 0, 0, + 31297, 31298, 7, 0, 0, 0, 31298, 31299, 7, 3, 0, 0, 31299, 31300, 7, 5, + 0, 0, 31300, 4714, 1, 0, 0, 0, 31301, 31302, 7, 18, 0, 0, 31302, 31303, + 7, 6, 0, 0, 31303, 31304, 7, 0, 0, 0, 31304, 31305, 7, 3, 0, 0, 31305, + 4716, 1, 0, 0, 0, 31306, 31307, 7, 18, 0, 0, 31307, 31308, 7, 6, 0, 0, + 31308, 31309, 7, 0, 0, 0, 31309, 31310, 7, 3, 0, 0, 31310, 31311, 5, 95, + 0, 0, 31311, 31312, 7, 4, 0, 0, 31312, 31313, 7, 2, 0, 0, 31313, 31314, + 5, 95, 0, 0, 31314, 31315, 7, 14, 0, 0, 31315, 31316, 7, 2, 0, 0, 31316, + 31317, 7, 7, 0, 0, 31317, 31318, 7, 4, 0, 0, 31318, 31319, 7, 19, 0, 0, + 31319, 4718, 1, 0, 0, 0, 31320, 31321, 7, 18, 0, 0, 31321, 31322, 7, 6, + 0, 0, 31322, 31323, 7, 5, 0, 0, 31323, 4720, 1, 0, 0, 0, 31324, 31325, + 7, 18, 0, 0, 31325, 31326, 7, 14, 0, 0, 31326, 31327, 7, 10, 0, 0, 31327, + 31328, 7, 7, 0, 0, 31328, 31329, 7, 4, 0, 0, 31329, 31330, 7, 6, 0, 0, + 31330, 31331, 7, 3, 0, 0, 31331, 31332, 7, 13, 0, 0, 31332, 31333, 7, 0, + 0, 0, 31333, 31334, 7, 11, 0, 0, 31334, 31335, 5, 95, 0, 0, 31335, 31336, + 7, 12, 0, 0, 31336, 31337, 7, 7, 0, 0, 31337, 31338, 7, 8, 0, 0, 31338, + 31339, 7, 2, 0, 0, 31339, 31340, 7, 7, 0, 0, 31340, 31341, 7, 5, 0, 0, + 31341, 31342, 7, 4, 0, 0, 31342, 31343, 7, 3, 0, 0, 31343, 31344, 7, 0, + 0, 0, 31344, 31345, 7, 10, 0, 0, 31345, 31346, 7, 7, 0, 0, 31346, 31347, + 7, 6, 0, 0, 31347, 31348, 7, 9, 0, 0, 31348, 4722, 1, 0, 0, 0, 31349, 31350, + 7, 23, 0, 0, 31350, 31351, 7, 2, 0, 0, 31351, 31352, 7, 7, 0, 0, 31352, + 31353, 7, 6, 0, 0, 31353, 31354, 7, 14, 0, 0, 31354, 31355, 7, 0, 0, 0, + 31355, 31356, 7, 15, 0, 0, 31356, 4724, 1, 0, 0, 0, 31357, 31358, 7, 23, + 0, 0, 31358, 31359, 7, 2, 0, 0, 31359, 31360, 7, 7, 0, 0, 31360, 31361, + 7, 6, 0, 0, 31361, 4726, 1, 0, 0, 0, 31362, 31363, 7, 23, 0, 0, 31363, + 31364, 7, 2, 0, 0, 31364, 31365, 7, 7, 0, 0, 31365, 31366, 7, 6, 0, 0, + 31366, 31367, 7, 9, 0, 0, 31367, 4728, 1, 0, 0, 0, 31368, 31369, 7, 15, + 0, 0, 31369, 31370, 7, 3, 0, 0, 31370, 31371, 7, 6, 0, 0, 31371, 31372, + 7, 9, 0, 0, 31372, 31373, 7, 10, 0, 0, 31373, 31374, 7, 8, 0, 0, 31374, + 31375, 7, 4, 0, 0, 31375, 31376, 7, 10, 0, 0, 31376, 31377, 7, 2, 0, 0, + 31377, 31378, 7, 7, 0, 0, 31378, 4730, 1, 0, 0, 0, 31379, 31380, 7, 15, + 0, 0, 31380, 31381, 7, 3, 0, 0, 31381, 31382, 7, 6, 0, 0, 31382, 31383, + 7, 9, 0, 0, 31383, 31384, 7, 10, 0, 0, 31384, 31385, 7, 8, 0, 0, 31385, + 31386, 7, 4, 0, 0, 31386, 31387, 7, 10, 0, 0, 31387, 31388, 7, 2, 0, 0, + 31388, 31389, 7, 7, 0, 0, 31389, 31390, 5, 95, 0, 0, 31390, 31391, 7, 1, + 0, 0, 31391, 31392, 7, 2, 0, 0, 31392, 31393, 7, 12, 0, 0, 31393, 31394, + 7, 7, 0, 0, 31394, 31395, 7, 9, 0, 0, 31395, 31396, 7, 5, 0, 0, 31396, + 4732, 1, 0, 0, 0, 31397, 31398, 7, 15, 0, 0, 31398, 31399, 7, 3, 0, 0, + 31399, 31400, 7, 6, 0, 0, 31400, 31401, 7, 9, 0, 0, 31401, 31402, 7, 10, + 0, 0, 31402, 31403, 7, 8, 0, 0, 31403, 31404, 7, 4, 0, 0, 31404, 31405, + 7, 10, 0, 0, 31405, 31406, 7, 2, 0, 0, 31406, 31407, 7, 7, 0, 0, 31407, + 31408, 5, 95, 0, 0, 31408, 31409, 7, 8, 0, 0, 31409, 31410, 7, 2, 0, 0, + 31410, 31411, 7, 5, 0, 0, 31411, 31412, 7, 4, 0, 0, 31412, 4734, 1, 0, + 0, 0, 31413, 31414, 7, 15, 0, 0, 31414, 31415, 7, 3, 0, 0, 31415, 31416, + 7, 6, 0, 0, 31416, 31417, 7, 9, 0, 0, 31417, 31418, 7, 10, 0, 0, 31418, + 31419, 7, 8, 0, 0, 31419, 31420, 7, 4, 0, 0, 31420, 31421, 7, 10, 0, 0, + 31421, 31422, 7, 2, 0, 0, 31422, 31423, 7, 7, 0, 0, 31423, 31424, 5, 95, + 0, 0, 31424, 31425, 7, 9, 0, 0, 31425, 31426, 7, 6, 0, 0, 31426, 31427, + 7, 4, 0, 0, 31427, 31428, 7, 0, 0, 0, 31428, 31429, 7, 10, 0, 0, 31429, + 31430, 7, 11, 0, 0, 31430, 31431, 7, 5, 0, 0, 31431, 4736, 1, 0, 0, 0, + 31432, 31433, 7, 15, 0, 0, 31433, 31434, 7, 3, 0, 0, 31434, 31435, 7, 6, + 0, 0, 31435, 31436, 7, 9, 0, 0, 31436, 31437, 7, 10, 0, 0, 31437, 31438, + 7, 8, 0, 0, 31438, 31439, 7, 4, 0, 0, 31439, 31440, 7, 10, 0, 0, 31440, + 31441, 7, 2, 0, 0, 31441, 31442, 7, 7, 0, 0, 31442, 31443, 5, 95, 0, 0, + 31443, 31444, 7, 15, 0, 0, 31444, 31445, 7, 3, 0, 0, 31445, 31446, 7, 2, + 0, 0, 31446, 31447, 7, 1, 0, 0, 31447, 31448, 7, 0, 0, 0, 31448, 31449, + 7, 1, 0, 0, 31449, 31450, 7, 10, 0, 0, 31450, 31451, 7, 11, 0, 0, 31451, + 31452, 7, 10, 0, 0, 31452, 31453, 7, 4, 0, 0, 31453, 31454, 7, 18, 0, 0, + 31454, 4738, 1, 0, 0, 0, 31455, 31456, 7, 15, 0, 0, 31456, 31457, 7, 3, + 0, 0, 31457, 31458, 7, 6, 0, 0, 31458, 31459, 7, 9, 0, 0, 31459, 31460, + 7, 10, 0, 0, 31460, 31461, 7, 8, 0, 0, 31461, 31462, 7, 4, 0, 0, 31462, + 31463, 7, 10, 0, 0, 31463, 31464, 7, 2, 0, 0, 31464, 31465, 7, 7, 0, 0, + 31465, 31466, 5, 95, 0, 0, 31466, 31467, 7, 5, 0, 0, 31467, 31468, 7, 6, + 0, 0, 31468, 31469, 7, 4, 0, 0, 31469, 4740, 1, 0, 0, 0, 31470, 31471, + 7, 1, 0, 0, 31471, 31472, 7, 11, 0, 0, 31472, 31473, 7, 2, 0, 0, 31473, + 31474, 7, 8, 0, 0, 31474, 31475, 7, 21, 0, 0, 31475, 31476, 7, 8, 0, 0, + 31476, 31477, 7, 19, 0, 0, 31477, 31478, 7, 0, 0, 0, 31478, 31479, 7, 10, + 0, 0, 31479, 31480, 7, 7, 0, 0, 31480, 4742, 1, 0, 0, 0, 31481, 31482, + 7, 8, 0, 0, 31482, 31483, 7, 2, 0, 0, 31483, 31484, 7, 11, 0, 0, 31484, + 31485, 7, 11, 0, 0, 31485, 31486, 7, 0, 0, 0, 31486, 31487, 7, 4, 0, 0, + 31487, 31488, 7, 6, 0, 0, 31488, 4744, 1, 0, 0, 0, 31489, 31490, 7, 8, + 0, 0, 31490, 31491, 7, 2, 0, 0, 31491, 31492, 7, 11, 0, 0, 31492, 31493, + 7, 11, 0, 0, 31493, 31494, 7, 0, 0, 0, 31494, 31495, 7, 4, 0, 0, 31495, + 31496, 7, 10, 0, 0, 31496, 31497, 7, 2, 0, 0, 31497, 31498, 7, 7, 0, 0, + 31498, 4746, 1, 0, 0, 0, 31499, 31500, 7, 9, 0, 0, 31500, 31501, 7, 6, + 0, 0, 31501, 31502, 7, 16, 0, 0, 31502, 31503, 7, 10, 0, 0, 31503, 31504, + 7, 7, 0, 0, 31504, 31505, 7, 10, 0, 0, 31505, 31506, 7, 4, 0, 0, 31506, + 31507, 7, 10, 0, 0, 31507, 31508, 7, 2, 0, 0, 31508, 31509, 7, 7, 0, 0, + 31509, 4748, 1, 0, 0, 0, 31510, 31511, 7, 9, 0, 0, 31511, 31512, 7, 12, + 0, 0, 31512, 31513, 7, 15, 0, 0, 31513, 31514, 7, 11, 0, 0, 31514, 31515, + 7, 10, 0, 0, 31515, 31516, 7, 8, 0, 0, 31516, 31517, 7, 0, 0, 0, 31517, + 31518, 7, 4, 0, 0, 31518, 31519, 7, 6, 0, 0, 31519, 31520, 7, 9, 0, 0, + 31520, 4750, 1, 0, 0, 0, 31521, 31522, 7, 6, 0, 0, 31522, 31523, 7, 25, + 0, 0, 31523, 31524, 7, 4, 0, 0, 31524, 31525, 7, 6, 0, 0, 31525, 31526, + 7, 7, 0, 0, 31526, 31527, 7, 9, 0, 0, 31527, 31528, 7, 6, 0, 0, 31528, + 31529, 7, 9, 0, 0, 31529, 4752, 1, 0, 0, 0, 31530, 31531, 7, 19, 0, 0, + 31531, 31532, 7, 0, 0, 0, 31532, 31533, 7, 5, 0, 0, 31533, 31534, 7, 19, + 0, 0, 31534, 31535, 7, 10, 0, 0, 31535, 31536, 7, 7, 0, 0, 31536, 31537, + 7, 17, 0, 0, 31537, 4754, 1, 0, 0, 0, 31538, 31539, 7, 10, 0, 0, 31539, + 31540, 7, 9, 0, 0, 31540, 31541, 7, 11, 0, 0, 31541, 31542, 7, 6, 0, 0, + 31542, 4756, 1, 0, 0, 0, 31543, 31544, 7, 10, 0, 0, 31544, 31545, 7, 14, + 0, 0, 31545, 31546, 7, 14, 0, 0, 31546, 31547, 7, 12, 0, 0, 31547, 31548, + 7, 4, 0, 0, 31548, 31549, 7, 0, 0, 0, 31549, 31550, 7, 1, 0, 0, 31550, + 31551, 7, 11, 0, 0, 31551, 31552, 7, 6, 0, 0, 31552, 4758, 1, 0, 0, 0, + 31553, 31554, 7, 2, 0, 0, 31554, 31555, 7, 3, 0, 0, 31555, 31556, 7, 0, + 0, 0, 31556, 31557, 7, 8, 0, 0, 31557, 31558, 7, 11, 0, 0, 31558, 31559, + 7, 6, 0, 0, 31559, 31560, 5, 95, 0, 0, 31560, 31561, 7, 9, 0, 0, 31561, + 31562, 7, 0, 0, 0, 31562, 31563, 7, 4, 0, 0, 31563, 31564, 7, 0, 0, 0, + 31564, 31565, 7, 15, 0, 0, 31565, 31566, 7, 12, 0, 0, 31566, 31567, 7, + 14, 0, 0, 31567, 31568, 7, 15, 0, 0, 31568, 4760, 1, 0, 0, 0, 31569, 31570, + 7, 2, 0, 0, 31570, 31571, 7, 3, 0, 0, 31571, 31572, 7, 0, 0, 0, 31572, + 31573, 7, 8, 0, 0, 31573, 31574, 7, 11, 0, 0, 31574, 31575, 7, 6, 0, 0, + 31575, 31576, 5, 95, 0, 0, 31576, 31577, 7, 19, 0, 0, 31577, 31578, 7, + 9, 0, 0, 31578, 31579, 7, 16, 0, 0, 31579, 31580, 7, 5, 0, 0, 31580, 4762, + 1, 0, 0, 0, 31581, 31582, 7, 2, 0, 0, 31582, 31583, 7, 3, 0, 0, 31583, + 31584, 7, 0, 0, 0, 31584, 31585, 7, 8, 0, 0, 31585, 31586, 7, 11, 0, 0, + 31586, 31587, 7, 6, 0, 0, 31587, 31588, 5, 95, 0, 0, 31588, 31589, 7, 19, + 0, 0, 31589, 31590, 7, 10, 0, 0, 31590, 31591, 7, 13, 0, 0, 31591, 31592, + 7, 6, 0, 0, 31592, 4764, 1, 0, 0, 0, 31593, 31594, 7, 2, 0, 0, 31594, 31595, + 7, 3, 0, 0, 31595, 31596, 7, 0, 0, 0, 31596, 31597, 7, 8, 0, 0, 31597, + 31598, 7, 11, 0, 0, 31598, 31599, 7, 6, 0, 0, 31599, 31600, 5, 95, 0, 0, + 31600, 31601, 7, 11, 0, 0, 31601, 31602, 7, 2, 0, 0, 31602, 31603, 7, 0, + 0, 0, 31603, 31604, 7, 9, 0, 0, 31604, 31605, 7, 6, 0, 0, 31605, 31606, + 7, 3, 0, 0, 31606, 4766, 1, 0, 0, 0, 31607, 31608, 5, 34, 0, 0, 31608, + 31609, 7, 5, 0, 0, 31609, 31610, 7, 19, 0, 0, 31610, 31611, 7, 0, 0, 0, + 31611, 31612, 5, 50, 0, 0, 31612, 31613, 5, 95, 0, 0, 31613, 31614, 5, + 53, 0, 0, 31614, 31615, 5, 49, 0, 0, 31615, 31616, 5, 50, 0, 0, 31616, + 31617, 5, 34, 0, 0, 31617, 4768, 1, 0, 0, 0, 31618, 31619, 7, 5, 0, 0, + 31619, 31620, 7, 19, 0, 0, 31620, 31621, 7, 0, 0, 0, 31621, 31622, 7, 3, + 0, 0, 31622, 31623, 7, 9, 0, 0, 31623, 31624, 7, 6, 0, 0, 31624, 31625, + 7, 9, 0, 0, 31625, 4770, 1, 0, 0, 0, 31626, 31627, 5, 34, 0, 0, 31627, + 31628, 7, 13, 0, 0, 31628, 31629, 5, 49, 0, 0, 31629, 31630, 5, 34, 0, + 0, 31630, 4772, 1, 0, 0, 0, 31631, 31632, 7, 10, 0, 0, 31632, 31633, 7, + 5, 0, 0, 31633, 31634, 7, 2, 0, 0, 31634, 31635, 7, 11, 0, 0, 31635, 31636, + 7, 0, 0, 0, 31636, 31637, 7, 4, 0, 0, 31637, 31638, 7, 6, 0, 0, 31638, + 4774, 1, 0, 0, 0, 31639, 31640, 7, 3, 0, 0, 31640, 31641, 7, 2, 0, 0, 31641, + 31642, 7, 2, 0, 0, 31642, 31643, 7, 4, 0, 0, 31643, 4776, 1, 0, 0, 0, 31644, + 31645, 7, 12, 0, 0, 31645, 31646, 7, 7, 0, 0, 31646, 31647, 7, 10, 0, 0, + 31647, 31648, 7, 4, 0, 0, 31648, 31649, 7, 6, 0, 0, 31649, 4778, 1, 0, + 0, 0, 31650, 31651, 7, 0, 0, 0, 31651, 31652, 7, 11, 0, 0, 31652, 31653, + 7, 17, 0, 0, 31653, 31654, 7, 2, 0, 0, 31654, 31655, 7, 3, 0, 0, 31655, + 31656, 7, 10, 0, 0, 31656, 31657, 7, 4, 0, 0, 31657, 31658, 7, 19, 0, 0, + 31658, 31659, 7, 14, 0, 0, 31659, 4780, 1, 0, 0, 0, 31660, 31661, 7, 8, + 0, 0, 31661, 31662, 7, 12, 0, 0, 31662, 31663, 7, 14, 0, 0, 31663, 31664, + 7, 6, 0, 0, 31664, 31665, 5, 95, 0, 0, 31665, 31666, 7, 9, 0, 0, 31666, + 31667, 7, 10, 0, 0, 31667, 31668, 7, 5, 0, 0, 31668, 31669, 7, 4, 0, 0, + 31669, 4782, 1, 0, 0, 0, 31670, 31671, 7, 9, 0, 0, 31671, 31672, 7, 6, + 0, 0, 31672, 31673, 7, 7, 0, 0, 31673, 31674, 7, 5, 0, 0, 31674, 31675, + 7, 6, 0, 0, 31675, 31676, 5, 95, 0, 0, 31676, 31677, 7, 3, 0, 0, 31677, + 31678, 7, 0, 0, 0, 31678, 31679, 7, 7, 0, 0, 31679, 31680, 7, 21, 0, 0, + 31680, 4784, 1, 0, 0, 0, 31681, 31682, 7, 11, 0, 0, 31682, 31683, 7, 10, + 0, 0, 31683, 31684, 7, 5, 0, 0, 31684, 31685, 7, 4, 0, 0, 31685, 31686, + 7, 0, 0, 0, 31686, 31687, 7, 17, 0, 0, 31687, 31688, 7, 17, 0, 0, 31688, + 4786, 1, 0, 0, 0, 31689, 31690, 7, 15, 0, 0, 31690, 31691, 7, 6, 0, 0, + 31691, 31692, 7, 3, 0, 0, 31692, 31693, 7, 8, 0, 0, 31693, 31694, 7, 6, + 0, 0, 31694, 31695, 7, 7, 0, 0, 31695, 31696, 7, 4, 0, 0, 31696, 31697, + 5, 95, 0, 0, 31697, 31698, 7, 3, 0, 0, 31698, 31699, 7, 0, 0, 0, 31699, + 31700, 7, 7, 0, 0, 31700, 31701, 7, 21, 0, 0, 31701, 4788, 1, 0, 0, 0, + 31702, 31703, 7, 15, 0, 0, 31703, 31704, 7, 6, 0, 0, 31704, 31705, 7, 3, + 0, 0, 31705, 31706, 7, 8, 0, 0, 31706, 31707, 7, 6, 0, 0, 31707, 31708, + 7, 7, 0, 0, 31708, 31709, 7, 4, 0, 0, 31709, 31710, 7, 10, 0, 0, 31710, + 31711, 7, 11, 0, 0, 31711, 31712, 7, 6, 0, 0, 31712, 31713, 5, 95, 0, 0, + 31713, 31714, 7, 8, 0, 0, 31714, 31715, 7, 2, 0, 0, 31715, 31716, 7, 7, + 0, 0, 31716, 31717, 7, 4, 0, 0, 31717, 4790, 1, 0, 0, 0, 31718, 31719, + 7, 15, 0, 0, 31719, 31720, 7, 6, 0, 0, 31720, 31721, 7, 3, 0, 0, 31721, + 31722, 7, 8, 0, 0, 31722, 31723, 7, 6, 0, 0, 31723, 31724, 7, 7, 0, 0, + 31724, 31725, 7, 4, 0, 0, 31725, 31726, 7, 10, 0, 0, 31726, 31727, 7, 11, + 0, 0, 31727, 31728, 7, 6, 0, 0, 31728, 31729, 5, 95, 0, 0, 31729, 31730, + 7, 9, 0, 0, 31730, 31731, 7, 10, 0, 0, 31731, 31732, 7, 5, 0, 0, 31732, + 31733, 7, 8, 0, 0, 31733, 4792, 1, 0, 0, 0, 31734, 31735, 7, 3, 0, 0, 31735, + 31736, 7, 0, 0, 0, 31736, 31737, 7, 7, 0, 0, 31737, 31738, 7, 21, 0, 0, + 31738, 4794, 1, 0, 0, 0, 31739, 31740, 7, 0, 0, 0, 31740, 31741, 7, 13, + 0, 0, 31741, 31742, 7, 17, 0, 0, 31742, 4796, 1, 0, 0, 0, 31743, 31744, + 7, 8, 0, 0, 31744, 31745, 7, 2, 0, 0, 31745, 31746, 7, 3, 0, 0, 31746, + 31747, 7, 3, 0, 0, 31747, 4798, 1, 0, 0, 0, 31748, 31749, 7, 8, 0, 0, 31749, + 31750, 7, 2, 0, 0, 31750, 31751, 7, 13, 0, 0, 31751, 31752, 7, 0, 0, 0, + 31752, 31753, 7, 3, 0, 0, 31753, 31754, 5, 95, 0, 0, 31754, 4800, 1, 0, + 0, 0, 31755, 31756, 7, 9, 0, 0, 31756, 31757, 7, 6, 0, 0, 31757, 31758, + 7, 8, 0, 0, 31758, 31759, 7, 2, 0, 0, 31759, 31760, 7, 9, 0, 0, 31760, + 31761, 7, 6, 0, 0, 31761, 4802, 1, 0, 0, 0, 31762, 31763, 7, 11, 0, 0, + 31763, 31764, 7, 0, 0, 0, 31764, 31765, 7, 17, 0, 0, 31765, 4804, 1, 0, + 0, 0, 31766, 31767, 7, 11, 0, 0, 31767, 31768, 7, 0, 0, 0, 31768, 31769, + 7, 17, 0, 0, 31769, 31770, 5, 95, 0, 0, 31770, 31771, 7, 9, 0, 0, 31771, + 31772, 7, 10, 0, 0, 31772, 31773, 7, 16, 0, 0, 31773, 31774, 7, 16, 0, + 0, 31774, 4806, 1, 0, 0, 0, 31775, 31776, 7, 11, 0, 0, 31776, 31777, 7, + 0, 0, 0, 31777, 31778, 7, 17, 0, 0, 31778, 31779, 5, 95, 0, 0, 31779, 31780, + 7, 9, 0, 0, 31780, 31781, 7, 10, 0, 0, 31781, 31782, 7, 16, 0, 0, 31782, + 31783, 7, 16, 0, 0, 31783, 31784, 5, 95, 0, 0, 31784, 31785, 7, 15, 0, + 0, 31785, 31786, 7, 6, 0, 0, 31786, 31787, 7, 3, 0, 0, 31787, 31788, 7, + 8, 0, 0, 31788, 31789, 7, 6, 0, 0, 31789, 31790, 7, 7, 0, 0, 31790, 31791, + 7, 4, 0, 0, 31791, 4808, 1, 0, 0, 0, 31792, 31793, 7, 11, 0, 0, 31793, + 31794, 7, 6, 0, 0, 31794, 31795, 7, 0, 0, 0, 31795, 31796, 7, 9, 0, 0, + 31796, 4810, 1, 0, 0, 0, 31797, 31798, 7, 14, 0, 0, 31798, 31799, 7, 0, + 0, 0, 31799, 31800, 7, 25, 0, 0, 31800, 4812, 1, 0, 0, 0, 31801, 31802, + 7, 14, 0, 0, 31802, 31803, 7, 6, 0, 0, 31803, 31804, 7, 9, 0, 0, 31804, + 31805, 7, 10, 0, 0, 31805, 31806, 7, 0, 0, 0, 31806, 31807, 7, 7, 0, 0, + 31807, 4814, 1, 0, 0, 0, 31808, 31809, 7, 14, 0, 0, 31809, 31810, 7, 6, + 0, 0, 31810, 31811, 7, 14, 0, 0, 31811, 31812, 7, 2, 0, 0, 31812, 31813, + 7, 15, 0, 0, 31813, 31814, 7, 4, 0, 0, 31814, 31815, 7, 10, 0, 0, 31815, + 31816, 7, 14, 0, 0, 31816, 31817, 7, 10, 0, 0, 31817, 31818, 7, 23, 0, + 0, 31818, 31819, 7, 6, 0, 0, 31819, 4816, 1, 0, 0, 0, 31820, 31821, 7, + 14, 0, 0, 31821, 31822, 7, 10, 0, 0, 31822, 31823, 7, 7, 0, 0, 31823, 4818, + 1, 0, 0, 0, 31824, 31825, 7, 7, 0, 0, 31825, 31826, 7, 4, 0, 0, 31826, + 31827, 7, 10, 0, 0, 31827, 31828, 7, 11, 0, 0, 31828, 31829, 7, 6, 0, 0, + 31829, 4820, 1, 0, 0, 0, 31830, 31831, 7, 7, 0, 0, 31831, 31832, 7, 13, + 0, 0, 31832, 31833, 7, 11, 0, 0, 31833, 4822, 1, 0, 0, 0, 31834, 31835, + 7, 3, 0, 0, 31835, 31836, 7, 0, 0, 0, 31836, 31837, 7, 4, 0, 0, 31837, + 31838, 7, 10, 0, 0, 31838, 31839, 7, 2, 0, 0, 31839, 31840, 5, 95, 0, 0, + 31840, 31841, 7, 4, 0, 0, 31841, 31842, 7, 2, 0, 0, 31842, 31843, 5, 95, + 0, 0, 31843, 31844, 7, 3, 0, 0, 31844, 31845, 7, 6, 0, 0, 31845, 31846, + 7, 15, 0, 0, 31846, 31847, 7, 2, 0, 0, 31847, 31848, 7, 3, 0, 0, 31848, + 31849, 7, 4, 0, 0, 31849, 4824, 1, 0, 0, 0, 31850, 31851, 7, 3, 0, 0, 31851, + 31852, 7, 6, 0, 0, 31852, 31853, 7, 17, 0, 0, 31853, 31854, 7, 3, 0, 0, + 31854, 31855, 5, 95, 0, 0, 31855, 4826, 1, 0, 0, 0, 31856, 31857, 7, 3, + 0, 0, 31857, 31858, 7, 2, 0, 0, 31858, 31859, 7, 12, 0, 0, 31859, 31860, + 7, 7, 0, 0, 31860, 31861, 7, 9, 0, 0, 31861, 4828, 1, 0, 0, 0, 31862, 31863, + 7, 3, 0, 0, 31863, 31864, 7, 2, 0, 0, 31864, 31865, 7, 22, 0, 0, 31865, + 31866, 5, 95, 0, 0, 31866, 31867, 7, 7, 0, 0, 31867, 31868, 7, 12, 0, 0, + 31868, 31869, 7, 14, 0, 0, 31869, 31870, 7, 1, 0, 0, 31870, 31871, 7, 6, + 0, 0, 31871, 31872, 7, 3, 0, 0, 31872, 4830, 1, 0, 0, 0, 31873, 31874, + 7, 5, 0, 0, 31874, 31875, 7, 12, 0, 0, 31875, 31876, 7, 1, 0, 0, 31876, + 31877, 7, 5, 0, 0, 31877, 31878, 7, 4, 0, 0, 31878, 31879, 7, 3, 0, 0, + 31879, 4832, 1, 0, 0, 0, 31880, 31881, 7, 4, 0, 0, 31881, 31882, 7, 2, + 0, 0, 31882, 31883, 5, 95, 0, 0, 31883, 31884, 7, 8, 0, 0, 31884, 31885, + 7, 19, 0, 0, 31885, 31886, 7, 0, 0, 0, 31886, 31887, 7, 3, 0, 0, 31887, + 4834, 1, 0, 0, 0, 31888, 31889, 7, 4, 0, 0, 31889, 31890, 7, 3, 0, 0, 31890, + 31891, 7, 10, 0, 0, 31891, 31892, 7, 14, 0, 0, 31892, 4836, 1, 0, 0, 0, + 31893, 31894, 7, 5, 0, 0, 31894, 31895, 7, 12, 0, 0, 31895, 31896, 7, 14, + 0, 0, 31896, 4838, 1, 0, 0, 0, 31897, 31898, 7, 5, 0, 0, 31898, 31899, + 7, 4, 0, 0, 31899, 31900, 7, 9, 0, 0, 31900, 31901, 7, 9, 0, 0, 31901, + 31902, 7, 6, 0, 0, 31902, 31903, 7, 13, 0, 0, 31903, 4840, 1, 0, 0, 0, + 31904, 31905, 7, 13, 0, 0, 31905, 31906, 7, 0, 0, 0, 31906, 31907, 7, 3, + 0, 0, 31907, 31908, 5, 95, 0, 0, 31908, 4842, 1, 0, 0, 0, 31909, 31910, + 7, 13, 0, 0, 31910, 31911, 7, 0, 0, 0, 31911, 31912, 7, 3, 0, 0, 31912, + 31913, 7, 10, 0, 0, 31913, 31914, 7, 0, 0, 0, 31914, 31915, 7, 7, 0, 0, + 31915, 31916, 7, 8, 0, 0, 31916, 31917, 7, 6, 0, 0, 31917, 4844, 1, 0, + 0, 0, 31918, 31919, 7, 11, 0, 0, 31919, 31920, 7, 6, 0, 0, 31920, 31921, + 7, 0, 0, 0, 31921, 31922, 7, 5, 0, 0, 31922, 31923, 7, 4, 0, 0, 31923, + 4846, 1, 0, 0, 0, 31924, 31925, 7, 17, 0, 0, 31925, 31926, 7, 3, 0, 0, + 31926, 31927, 7, 6, 0, 0, 31927, 31928, 7, 0, 0, 0, 31928, 31929, 7, 4, + 0, 0, 31929, 31930, 7, 6, 0, 0, 31930, 31931, 7, 5, 0, 0, 31931, 31932, + 7, 4, 0, 0, 31932, 4848, 1, 0, 0, 0, 31933, 31934, 7, 4, 0, 0, 31934, 31935, + 7, 2, 0, 0, 31935, 31936, 5, 95, 0, 0, 31936, 31937, 7, 9, 0, 0, 31937, + 31938, 7, 0, 0, 0, 31938, 31939, 7, 4, 0, 0, 31939, 31940, 7, 6, 0, 0, + 31940, 4850, 1, 0, 0, 0, 31941, 31942, 7, 8, 0, 0, 31942, 31943, 7, 19, + 0, 0, 31943, 31944, 7, 0, 0, 0, 31944, 31945, 7, 3, 0, 0, 31945, 31946, + 7, 5, 0, 0, 31946, 31947, 7, 6, 0, 0, 31947, 31948, 7, 4, 0, 0, 31948, + 31949, 7, 10, 0, 0, 31949, 31950, 7, 9, 0, 0, 31950, 4852, 1, 0, 0, 0, + 31951, 31952, 7, 8, 0, 0, 31952, 31953, 7, 19, 0, 0, 31953, 31954, 7, 0, + 0, 0, 31954, 31955, 7, 3, 0, 0, 31955, 31956, 7, 5, 0, 0, 31956, 31957, + 7, 6, 0, 0, 31957, 31958, 7, 4, 0, 0, 31958, 31959, 7, 16, 0, 0, 31959, + 31960, 7, 2, 0, 0, 31960, 31961, 7, 3, 0, 0, 31961, 31962, 7, 14, 0, 0, + 31962, 4854, 1, 0, 0, 0, 31963, 31964, 7, 9, 0, 0, 31964, 31965, 7, 12, + 0, 0, 31965, 31966, 7, 3, 0, 0, 31966, 31967, 7, 0, 0, 0, 31967, 31968, + 7, 4, 0, 0, 31968, 31969, 7, 10, 0, 0, 31969, 31970, 7, 2, 0, 0, 31970, + 31971, 7, 7, 0, 0, 31971, 4856, 1, 0, 0, 0, 31972, 31973, 7, 6, 0, 0, 31973, + 31974, 7, 25, 0, 0, 31974, 31975, 7, 4, 0, 0, 31975, 31976, 7, 6, 0, 0, + 31976, 31977, 7, 7, 0, 0, 31977, 31978, 7, 9, 0, 0, 31978, 4858, 1, 0, + 0, 0, 31979, 31980, 7, 14, 0, 0, 31980, 31981, 7, 0, 0, 0, 31981, 31982, + 7, 25, 0, 0, 31982, 31983, 7, 11, 0, 0, 31983, 31984, 7, 6, 0, 0, 31984, + 31985, 7, 7, 0, 0, 31985, 4860, 1, 0, 0, 0, 31986, 31987, 7, 15, 0, 0, + 31987, 31988, 7, 6, 0, 0, 31988, 31989, 7, 3, 0, 0, 31989, 31990, 7, 5, + 0, 0, 31990, 31991, 7, 10, 0, 0, 31991, 31992, 7, 5, 0, 0, 31992, 31993, + 7, 4, 0, 0, 31993, 31994, 7, 0, 0, 0, 31994, 31995, 7, 1, 0, 0, 31995, + 31996, 7, 11, 0, 0, 31996, 31997, 7, 6, 0, 0, 31997, 4862, 1, 0, 0, 0, + 31998, 31999, 7, 15, 0, 0, 31999, 32000, 7, 2, 0, 0, 32000, 32001, 7, 11, + 0, 0, 32001, 32002, 7, 18, 0, 0, 32002, 32003, 7, 14, 0, 0, 32003, 32004, + 7, 2, 0, 0, 32004, 32005, 7, 3, 0, 0, 32005, 32006, 7, 15, 0, 0, 32006, + 32007, 7, 19, 0, 0, 32007, 32008, 7, 10, 0, 0, 32008, 32009, 7, 8, 0, 0, + 32009, 4864, 1, 0, 0, 0, 32010, 32011, 7, 5, 0, 0, 32011, 32012, 7, 4, + 0, 0, 32012, 32013, 7, 3, 0, 0, 32013, 32014, 7, 12, 0, 0, 32014, 32015, + 7, 8, 0, 0, 32015, 32016, 7, 4, 0, 0, 32016, 4866, 1, 0, 0, 0, 32017, 32018, + 7, 4, 0, 0, 32018, 32019, 7, 9, 0, 0, 32019, 32020, 7, 2, 0, 0, 32020, + 4868, 1, 0, 0, 0, 32021, 32022, 7, 22, 0, 0, 32022, 32023, 7, 14, 0, 0, + 32023, 32024, 5, 95, 0, 0, 32024, 32025, 7, 8, 0, 0, 32025, 32026, 7, 2, + 0, 0, 32026, 32027, 7, 7, 0, 0, 32027, 32028, 7, 8, 0, 0, 32028, 32029, + 7, 0, 0, 0, 32029, 32030, 7, 4, 0, 0, 32030, 4870, 1, 0, 0, 0, 32031, 32032, + 7, 7, 0, 0, 32032, 32039, 5, 39, 0, 0, 32033, 32038, 8, 26, 0, 0, 32034, + 32035, 5, 39, 0, 0, 32035, 32038, 5, 39, 0, 0, 32036, 32038, 3, 4997, 2498, + 0, 32037, 32033, 1, 0, 0, 0, 32037, 32034, 1, 0, 0, 0, 32037, 32036, 1, + 0, 0, 0, 32038, 32041, 1, 0, 0, 0, 32039, 32037, 1, 0, 0, 0, 32039, 32040, + 1, 0, 0, 0, 32040, 32042, 1, 0, 0, 0, 32041, 32039, 1, 0, 0, 0, 32042, + 32043, 5, 39, 0, 0, 32043, 4872, 1, 0, 0, 0, 32044, 32053, 7, 1, 0, 0, + 32045, 32049, 5, 39, 0, 0, 32046, 32048, 7, 27, 0, 0, 32047, 32046, 1, + 0, 0, 0, 32048, 32051, 1, 0, 0, 0, 32049, 32047, 1, 0, 0, 0, 32049, 32050, + 1, 0, 0, 0, 32050, 32052, 1, 0, 0, 0, 32051, 32049, 1, 0, 0, 0, 32052, + 32054, 5, 39, 0, 0, 32053, 32045, 1, 0, 0, 0, 32054, 32055, 1, 0, 0, 0, + 32055, 32053, 1, 0, 0, 0, 32055, 32056, 1, 0, 0, 0, 32056, 4874, 1, 0, + 0, 0, 32057, 32061, 7, 25, 0, 0, 32058, 32059, 5, 48, 0, 0, 32059, 32061, + 7, 25, 0, 0, 32060, 32057, 1, 0, 0, 0, 32060, 32058, 1, 0, 0, 0, 32061, + 32070, 1, 0, 0, 0, 32062, 32066, 5, 39, 0, 0, 32063, 32065, 7, 28, 0, 0, + 32064, 32063, 1, 0, 0, 0, 32065, 32068, 1, 0, 0, 0, 32066, 32064, 1, 0, + 0, 0, 32066, 32067, 1, 0, 0, 0, 32067, 32069, 1, 0, 0, 0, 32068, 32066, + 1, 0, 0, 0, 32069, 32071, 5, 39, 0, 0, 32070, 32062, 1, 0, 0, 0, 32071, + 32072, 1, 0, 0, 0, 32072, 32070, 1, 0, 0, 0, 32072, 32073, 1, 0, 0, 0, + 32073, 4876, 1, 0, 0, 0, 32074, 32075, 5, 46, 0, 0, 32075, 32076, 5, 46, + 0, 0, 32076, 4878, 1, 0, 0, 0, 32077, 32078, 5, 46, 0, 0, 32078, 4880, + 1, 0, 0, 0, 32079, 32081, 7, 29, 0, 0, 32080, 32079, 1, 0, 0, 0, 32081, + 32082, 1, 0, 0, 0, 32082, 32080, 1, 0, 0, 0, 32082, 32083, 1, 0, 0, 0, + 32083, 4882, 1, 0, 0, 0, 32084, 32097, 3, 4995, 2497, 0, 32085, 32087, + 7, 6, 0, 0, 32086, 32088, 7, 30, 0, 0, 32087, 32086, 1, 0, 0, 0, 32087, + 32088, 1, 0, 0, 0, 32088, 32095, 1, 0, 0, 0, 32089, 32096, 3, 4995, 2497, + 0, 32090, 32092, 7, 29, 0, 0, 32091, 32090, 1, 0, 0, 0, 32092, 32093, 1, + 0, 0, 0, 32093, 32091, 1, 0, 0, 0, 32093, 32094, 1, 0, 0, 0, 32094, 32096, + 1, 0, 0, 0, 32095, 32089, 1, 0, 0, 0, 32095, 32091, 1, 0, 0, 0, 32096, + 32098, 1, 0, 0, 0, 32097, 32085, 1, 0, 0, 0, 32097, 32098, 1, 0, 0, 0, + 32098, 32100, 1, 0, 0, 0, 32099, 32101, 7, 31, 0, 0, 32100, 32099, 1, 0, + 0, 0, 32100, 32101, 1, 0, 0, 0, 32101, 4884, 1, 0, 0, 0, 32102, 32109, + 5, 39, 0, 0, 32103, 32108, 8, 26, 0, 0, 32104, 32105, 5, 39, 0, 0, 32105, + 32108, 5, 39, 0, 0, 32106, 32108, 3, 4997, 2498, 0, 32107, 32103, 1, 0, + 0, 0, 32107, 32104, 1, 0, 0, 0, 32107, 32106, 1, 0, 0, 0, 32108, 32111, + 1, 0, 0, 0, 32109, 32107, 1, 0, 0, 0, 32109, 32110, 1, 0, 0, 0, 32110, + 32112, 1, 0, 0, 0, 32111, 32109, 1, 0, 0, 0, 32112, 32113, 5, 39, 0, 0, + 32113, 4886, 1, 0, 0, 0, 32114, 32115, 7, 24, 0, 0, 32115, 32127, 5, 39, + 0, 0, 32116, 32128, 3, 4889, 2444, 0, 32117, 32128, 3, 4891, 2445, 0, 32118, + 32128, 3, 4893, 2446, 0, 32119, 32128, 3, 4895, 2447, 0, 32120, 32128, + 3, 4897, 2448, 0, 32121, 32128, 3, 4899, 2449, 0, 32122, 32128, 3, 4901, + 2450, 0, 32123, 32128, 3, 4903, 2451, 0, 32124, 32128, 3, 4905, 2452, 0, + 32125, 32128, 3, 4907, 2453, 0, 32126, 32128, 3, 4909, 2454, 0, 32127, + 32116, 1, 0, 0, 0, 32127, 32117, 1, 0, 0, 0, 32127, 32118, 1, 0, 0, 0, + 32127, 32119, 1, 0, 0, 0, 32127, 32120, 1, 0, 0, 0, 32127, 32121, 1, 0, + 0, 0, 32127, 32122, 1, 0, 0, 0, 32127, 32123, 1, 0, 0, 0, 32127, 32124, + 1, 0, 0, 0, 32127, 32125, 1, 0, 0, 0, 32127, 32126, 1, 0, 0, 0, 32128, + 32129, 1, 0, 0, 0, 32129, 32130, 5, 39, 0, 0, 32130, 32131, 1, 0, 0, 0, + 32131, 32132, 6, 2443, 0, 0, 32132, 4888, 1, 0, 0, 0, 32133, 32137, 5, + 60, 0, 0, 32134, 32136, 9, 0, 0, 0, 32135, 32134, 1, 0, 0, 0, 32136, 32139, + 1, 0, 0, 0, 32137, 32138, 1, 0, 0, 0, 32137, 32135, 1, 0, 0, 0, 32138, + 32140, 1, 0, 0, 0, 32139, 32137, 1, 0, 0, 0, 32140, 32141, 5, 62, 0, 0, + 32141, 4890, 1, 0, 0, 0, 32142, 32146, 5, 123, 0, 0, 32143, 32145, 9, 0, + 0, 0, 32144, 32143, 1, 0, 0, 0, 32145, 32148, 1, 0, 0, 0, 32146, 32147, + 1, 0, 0, 0, 32146, 32144, 1, 0, 0, 0, 32147, 32149, 1, 0, 0, 0, 32148, + 32146, 1, 0, 0, 0, 32149, 32150, 5, 125, 0, 0, 32150, 4892, 1, 0, 0, 0, + 32151, 32155, 5, 91, 0, 0, 32152, 32154, 9, 0, 0, 0, 32153, 32152, 1, 0, + 0, 0, 32154, 32157, 1, 0, 0, 0, 32155, 32156, 1, 0, 0, 0, 32155, 32153, + 1, 0, 0, 0, 32156, 32158, 1, 0, 0, 0, 32157, 32155, 1, 0, 0, 0, 32158, + 32159, 5, 93, 0, 0, 32159, 4894, 1, 0, 0, 0, 32160, 32164, 5, 40, 0, 0, + 32161, 32163, 9, 0, 0, 0, 32162, 32161, 1, 0, 0, 0, 32163, 32166, 1, 0, + 0, 0, 32164, 32165, 1, 0, 0, 0, 32164, 32162, 1, 0, 0, 0, 32165, 32167, + 1, 0, 0, 0, 32166, 32164, 1, 0, 0, 0, 32167, 32168, 5, 41, 0, 0, 32168, + 4896, 1, 0, 0, 0, 32169, 32173, 5, 33, 0, 0, 32170, 32172, 9, 0, 0, 0, + 32171, 32170, 1, 0, 0, 0, 32172, 32175, 1, 0, 0, 0, 32173, 32174, 1, 0, + 0, 0, 32173, 32171, 1, 0, 0, 0, 32174, 32176, 1, 0, 0, 0, 32175, 32173, + 1, 0, 0, 0, 32176, 32177, 5, 33, 0, 0, 32177, 4898, 1, 0, 0, 0, 32178, + 32182, 5, 35, 0, 0, 32179, 32181, 9, 0, 0, 0, 32180, 32179, 1, 0, 0, 0, + 32181, 32184, 1, 0, 0, 0, 32182, 32183, 1, 0, 0, 0, 32182, 32180, 1, 0, + 0, 0, 32183, 32185, 1, 0, 0, 0, 32184, 32182, 1, 0, 0, 0, 32185, 32186, + 5, 35, 0, 0, 32186, 4900, 1, 0, 0, 0, 32187, 32191, 5, 39, 0, 0, 32188, + 32190, 9, 0, 0, 0, 32189, 32188, 1, 0, 0, 0, 32190, 32193, 1, 0, 0, 0, + 32191, 32192, 1, 0, 0, 0, 32191, 32189, 1, 0, 0, 0, 32192, 32194, 1, 0, + 0, 0, 32193, 32191, 1, 0, 0, 0, 32194, 32195, 5, 39, 0, 0, 32195, 4902, + 1, 0, 0, 0, 32196, 32200, 5, 34, 0, 0, 32197, 32199, 9, 0, 0, 0, 32198, + 32197, 1, 0, 0, 0, 32199, 32202, 1, 0, 0, 0, 32200, 32201, 1, 0, 0, 0, + 32200, 32198, 1, 0, 0, 0, 32201, 32203, 1, 0, 0, 0, 32202, 32200, 1, 0, + 0, 0, 32203, 32204, 5, 34, 0, 0, 32204, 4904, 1, 0, 0, 0, 32205, 32209, + 5, 126, 0, 0, 32206, 32208, 9, 0, 0, 0, 32207, 32206, 1, 0, 0, 0, 32208, + 32211, 1, 0, 0, 0, 32209, 32210, 1, 0, 0, 0, 32209, 32207, 1, 0, 0, 0, + 32210, 32212, 1, 0, 0, 0, 32211, 32209, 1, 0, 0, 0, 32212, 32213, 5, 126, + 0, 0, 32213, 4906, 1, 0, 0, 0, 32214, 32218, 5, 47, 0, 0, 32215, 32217, + 9, 0, 0, 0, 32216, 32215, 1, 0, 0, 0, 32217, 32220, 1, 0, 0, 0, 32218, + 32219, 1, 0, 0, 0, 32218, 32216, 1, 0, 0, 0, 32219, 32221, 1, 0, 0, 0, + 32220, 32218, 1, 0, 0, 0, 32221, 32222, 5, 47, 0, 0, 32222, 4908, 1, 0, + 0, 0, 32223, 32227, 5, 92, 0, 0, 32224, 32226, 9, 0, 0, 0, 32225, 32224, + 1, 0, 0, 0, 32226, 32229, 1, 0, 0, 0, 32227, 32228, 1, 0, 0, 0, 32227, + 32225, 1, 0, 0, 0, 32228, 32230, 1, 0, 0, 0, 32229, 32227, 1, 0, 0, 0, + 32230, 32231, 5, 92, 0, 0, 32231, 4910, 1, 0, 0, 0, 32232, 32236, 5, 34, + 0, 0, 32233, 32237, 8, 32, 0, 0, 32234, 32235, 5, 34, 0, 0, 32235, 32237, + 5, 34, 0, 0, 32236, 32233, 1, 0, 0, 0, 32236, 32234, 1, 0, 0, 0, 32237, + 32238, 1, 0, 0, 0, 32238, 32236, 1, 0, 0, 0, 32238, 32239, 1, 0, 0, 0, + 32239, 32240, 1, 0, 0, 0, 32240, 32241, 5, 34, 0, 0, 32241, 4912, 1, 0, + 0, 0, 32242, 32243, 5, 37, 0, 0, 32243, 4914, 1, 0, 0, 0, 32244, 32245, + 5, 38, 0, 0, 32245, 4916, 1, 0, 0, 0, 32246, 32247, 5, 40, 0, 0, 32247, + 4918, 1, 0, 0, 0, 32248, 32249, 5, 41, 0, 0, 32249, 4920, 1, 0, 0, 0, 32250, + 32251, 5, 42, 0, 0, 32251, 32252, 5, 42, 0, 0, 32252, 4922, 1, 0, 0, 0, + 32253, 32254, 5, 42, 0, 0, 32254, 4924, 1, 0, 0, 0, 32255, 32256, 5, 43, + 0, 0, 32256, 4926, 1, 0, 0, 0, 32257, 32258, 5, 45, 0, 0, 32258, 4928, + 1, 0, 0, 0, 32259, 32260, 5, 44, 0, 0, 32260, 4930, 1, 0, 0, 0, 32261, + 32262, 5, 47, 0, 0, 32262, 4932, 1, 0, 0, 0, 32263, 32264, 5, 92, 0, 0, + 32264, 4934, 1, 0, 0, 0, 32265, 32266, 5, 64, 0, 0, 32266, 4936, 1, 0, + 0, 0, 32267, 32268, 5, 58, 0, 0, 32268, 32269, 5, 61, 0, 0, 32269, 4938, + 1, 0, 0, 0, 32270, 32271, 5, 35, 0, 0, 32271, 4940, 1, 0, 0, 0, 32272, + 32273, 5, 123, 0, 0, 32273, 4942, 1, 0, 0, 0, 32274, 32275, 5, 125, 0, + 0, 32275, 4944, 1, 0, 0, 0, 32276, 32277, 5, 39, 0, 0, 32277, 4946, 1, + 0, 0, 0, 32278, 32279, 5, 58, 0, 0, 32279, 32284, 3, 4993, 2496, 0, 32280, + 32283, 3, 4993, 2496, 0, 32281, 32283, 7, 33, 0, 0, 32282, 32280, 1, 0, + 0, 0, 32282, 32281, 1, 0, 0, 0, 32283, 32286, 1, 0, 0, 0, 32284, 32282, + 1, 0, 0, 0, 32284, 32285, 1, 0, 0, 0, 32285, 32293, 1, 0, 0, 0, 32286, + 32284, 1, 0, 0, 0, 32287, 32288, 5, 58, 0, 0, 32288, 32293, 3, 4911, 2455, + 0, 32289, 32290, 5, 58, 0, 0, 32290, 32293, 3, 4881, 2440, 0, 32291, 32293, + 3, 4991, 2495, 0, 32292, 32278, 1, 0, 0, 0, 32292, 32287, 1, 0, 0, 0, 32292, + 32289, 1, 0, 0, 0, 32292, 32291, 1, 0, 0, 0, 32293, 4948, 1, 0, 0, 0, 32294, + 32295, 5, 33, 0, 0, 32295, 32303, 5, 61, 0, 0, 32296, 32297, 5, 60, 0, + 0, 32297, 32303, 5, 62, 0, 0, 32298, 32299, 5, 94, 0, 0, 32299, 32303, + 5, 61, 0, 0, 32300, 32301, 5, 126, 0, 0, 32301, 32303, 5, 61, 0, 0, 32302, + 32294, 1, 0, 0, 0, 32302, 32296, 1, 0, 0, 0, 32302, 32298, 1, 0, 0, 0, + 32302, 32300, 1, 0, 0, 0, 32303, 4950, 1, 0, 0, 0, 32304, 32305, 5, 94, + 0, 0, 32305, 4952, 1, 0, 0, 0, 32306, 32307, 5, 126, 0, 0, 32307, 4954, + 1, 0, 0, 0, 32308, 32309, 5, 33, 0, 0, 32309, 4956, 1, 0, 0, 0, 32310, + 32311, 5, 62, 0, 0, 32311, 4958, 1, 0, 0, 0, 32312, 32313, 5, 60, 0, 0, + 32313, 4960, 1, 0, 0, 0, 32314, 32315, 5, 58, 0, 0, 32315, 4962, 1, 0, + 0, 0, 32316, 32317, 5, 59, 0, 0, 32317, 4964, 1, 0, 0, 0, 32318, 32319, + 5, 124, 0, 0, 32319, 4966, 1, 0, 0, 0, 32320, 32321, 5, 61, 0, 0, 32321, + 4968, 1, 0, 0, 0, 32322, 32323, 5, 91, 0, 0, 32323, 4970, 1, 0, 0, 0, 32324, + 32325, 5, 93, 0, 0, 32325, 4972, 1, 0, 0, 0, 32326, 32327, 5, 95, 0, 0, + 32327, 4974, 1, 0, 0, 0, 32328, 32329, 5, 45, 0, 0, 32329, 32330, 5, 45, + 0, 0, 32330, 32334, 1, 0, 0, 0, 32331, 32333, 8, 34, 0, 0, 32332, 32331, + 1, 0, 0, 0, 32333, 32336, 1, 0, 0, 0, 32334, 32332, 1, 0, 0, 0, 32334, + 32335, 1, 0, 0, 0, 32335, 32337, 1, 0, 0, 0, 32336, 32334, 1, 0, 0, 0, + 32337, 32338, 3, 4989, 2494, 0, 32338, 32339, 1, 0, 0, 0, 32339, 32340, + 6, 2487, 1, 0, 32340, 4976, 1, 0, 0, 0, 32341, 32342, 5, 47, 0, 0, 32342, + 32343, 5, 42, 0, 0, 32343, 32347, 1, 0, 0, 0, 32344, 32346, 9, 0, 0, 0, + 32345, 32344, 1, 0, 0, 0, 32346, 32349, 1, 0, 0, 0, 32347, 32348, 1, 0, + 0, 0, 32347, 32345, 1, 0, 0, 0, 32348, 32350, 1, 0, 0, 0, 32349, 32347, + 1, 0, 0, 0, 32350, 32351, 5, 42, 0, 0, 32351, 32352, 5, 47, 0, 0, 32352, + 32353, 1, 0, 0, 0, 32353, 32354, 6, 2488, 1, 0, 32354, 4978, 1, 0, 0, 0, + 32355, 32356, 7, 3, 0, 0, 32356, 32357, 7, 6, 0, 0, 32357, 32358, 7, 14, + 0, 0, 32358, 32359, 1, 0, 0, 0, 32359, 32363, 4, 2489, 0, 0, 32360, 32361, + 7, 0, 0, 0, 32361, 32362, 7, 3, 0, 0, 32362, 32364, 7, 21, 0, 0, 32363, + 32360, 1, 0, 0, 0, 32363, 32364, 1, 0, 0, 0, 32364, 32372, 1, 0, 0, 0, + 32365, 32369, 5, 32, 0, 0, 32366, 32368, 8, 34, 0, 0, 32367, 32366, 1, + 0, 0, 0, 32368, 32371, 1, 0, 0, 0, 32369, 32367, 1, 0, 0, 0, 32369, 32370, + 1, 0, 0, 0, 32370, 32373, 1, 0, 0, 0, 32371, 32369, 1, 0, 0, 0, 32372, + 32365, 1, 0, 0, 0, 32372, 32373, 1, 0, 0, 0, 32373, 32374, 1, 0, 0, 0, + 32374, 32375, 3, 4989, 2494, 0, 32375, 32376, 1, 0, 0, 0, 32376, 32377, + 6, 2489, 1, 0, 32377, 4980, 1, 0, 0, 0, 32378, 32379, 7, 15, 0, 0, 32379, + 32380, 7, 3, 0, 0, 32380, 32381, 7, 2, 0, 0, 32381, 32382, 1, 0, 0, 0, + 32382, 32386, 4, 2490, 1, 0, 32383, 32384, 7, 14, 0, 0, 32384, 32385, 7, + 15, 0, 0, 32385, 32387, 7, 4, 0, 0, 32386, 32383, 1, 0, 0, 0, 32386, 32387, + 1, 0, 0, 0, 32387, 32395, 1, 0, 0, 0, 32388, 32392, 5, 32, 0, 0, 32389, + 32391, 8, 34, 0, 0, 32390, 32389, 1, 0, 0, 0, 32391, 32394, 1, 0, 0, 0, + 32392, 32390, 1, 0, 0, 0, 32392, 32393, 1, 0, 0, 0, 32393, 32396, 1, 0, + 0, 0, 32394, 32392, 1, 0, 0, 0, 32395, 32388, 1, 0, 0, 0, 32395, 32396, + 1, 0, 0, 0, 32396, 32397, 1, 0, 0, 0, 32397, 32398, 3, 4989, 2494, 0, 32398, + 4982, 1, 0, 0, 0, 32399, 32404, 3, 4993, 2496, 0, 32400, 32403, 3, 4993, + 2496, 0, 32401, 32403, 7, 35, 0, 0, 32402, 32400, 1, 0, 0, 0, 32402, 32401, + 1, 0, 0, 0, 32403, 32406, 1, 0, 0, 0, 32404, 32402, 1, 0, 0, 0, 32404, + 32405, 1, 0, 0, 0, 32405, 4984, 1, 0, 0, 0, 32406, 32404, 1, 0, 0, 0, 32407, + 32408, 5, 36, 0, 0, 32408, 32409, 5, 36, 0, 0, 32409, 32412, 1, 0, 0, 0, + 32410, 32413, 3, 4993, 2496, 0, 32411, 32413, 5, 95, 0, 0, 32412, 32410, + 1, 0, 0, 0, 32412, 32411, 1, 0, 0, 0, 32413, 32414, 1, 0, 0, 0, 32414, + 32412, 1, 0, 0, 0, 32414, 32415, 1, 0, 0, 0, 32415, 4986, 1, 0, 0, 0, 32416, + 32418, 7, 36, 0, 0, 32417, 32416, 1, 0, 0, 0, 32418, 32419, 1, 0, 0, 0, + 32419, 32417, 1, 0, 0, 0, 32419, 32420, 1, 0, 0, 0, 32420, 32421, 1, 0, + 0, 0, 32421, 32422, 6, 2493, 1, 0, 32422, 4988, 1, 0, 0, 0, 32423, 32426, + 3, 4997, 2498, 0, 32424, 32426, 5, 0, 0, 1, 32425, 32423, 1, 0, 0, 0, 32425, + 32424, 1, 0, 0, 0, 32426, 4990, 1, 0, 0, 0, 32427, 32428, 5, 63, 0, 0, + 32428, 4992, 1, 0, 0, 0, 32429, 32430, 7, 37, 0, 0, 32430, 4994, 1, 0, + 0, 0, 32431, 32433, 3, 4881, 2440, 0, 32432, 32431, 1, 0, 0, 0, 32433, + 32436, 1, 0, 0, 0, 32434, 32432, 1, 0, 0, 0, 32434, 32435, 1, 0, 0, 0, + 32435, 32438, 1, 0, 0, 0, 32436, 32434, 1, 0, 0, 0, 32437, 32439, 5, 46, + 0, 0, 32438, 32437, 1, 0, 0, 0, 32438, 32439, 1, 0, 0, 0, 32439, 32441, + 1, 0, 0, 0, 32440, 32442, 3, 4881, 2440, 0, 32441, 32440, 1, 0, 0, 0, 32442, + 32443, 1, 0, 0, 0, 32443, 32441, 1, 0, 0, 0, 32443, 32444, 1, 0, 0, 0, + 32444, 4996, 1, 0, 0, 0, 32445, 32447, 5, 13, 0, 0, 32446, 32445, 1, 0, + 0, 0, 32446, 32447, 1, 0, 0, 0, 32447, 32448, 1, 0, 0, 0, 32448, 32449, + 5, 10, 0, 0, 32449, 4998, 1, 0, 0, 0, 32450, 32451, 7, 38, 0, 0, 32451, + 5000, 1, 0, 0, 0, 61, 0, 19918, 19931, 19945, 19983, 19999, 20014, 20026, + 20049, 23375, 32037, 32039, 32049, 32055, 32060, 32066, 32072, 32082, 32087, + 32093, 32095, 32097, 32100, 32107, 32109, 32127, 32137, 32146, 32155, 32164, + 32173, 32182, 32191, 32200, 32209, 32218, 32227, 32236, 32238, 32282, 32284, + 32292, 32302, 32334, 32347, 32363, 32369, 32372, 32386, 32392, 32395, 32402, + 32404, 32412, 32414, 32419, 32425, 32434, 32438, 32443, 32446, 2, 7, 2443, + 0, 0, 1, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// PlSqlLexerInit initializes any static state used to implement PlSqlLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewPlSqlLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func PlSqlLexerInit() { + staticData := &PlSqlLexerLexerStaticData + staticData.once.Do(plsqllexerLexerInit) +} + +// NewPlSqlLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewPlSqlLexer(input antlr.CharStream) *PlSqlLexer { + PlSqlLexerInit() + l := new(PlSqlLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &PlSqlLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "PlSqlLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// PlSqlLexer tokens. +const ( + PlSqlLexerABORT = 1 + PlSqlLexerABS = 2 + PlSqlLexerABSENT = 3 + PlSqlLexerACCESS = 4 + PlSqlLexerACCESSED = 5 + PlSqlLexerACCESSIBLE = 6 + PlSqlLexerACCOUNT = 7 + PlSqlLexerACL = 8 + PlSqlLexerACOS = 9 + PlSqlLexerACROSS = 10 + PlSqlLexerACTION = 11 + PlSqlLexerACTIONS = 12 + PlSqlLexerACTIVATE = 13 + PlSqlLexerACTIVE = 14 + PlSqlLexerACTIVE_COMPONENT = 15 + PlSqlLexerACTIVE_DATA = 16 + PlSqlLexerACTIVE_FUNCTION = 17 + PlSqlLexerACTIVE_TAG = 18 + PlSqlLexerACTIVITY = 19 + PlSqlLexerADAPTIVE_PLAN = 20 + PlSqlLexerADD = 21 + PlSqlLexerADD_COLUMN = 22 + PlSqlLexerADD_GROUP = 23 + PlSqlLexerADD_MONTHS = 24 + PlSqlLexerADJ_DATE = 25 + PlSqlLexerADMIN = 26 + PlSqlLexerADMINISTER = 27 + PlSqlLexerADMINISTRATOR = 28 + PlSqlLexerADVANCED = 29 + PlSqlLexerADVISE = 30 + PlSqlLexerADVISOR = 31 + PlSqlLexerAFD_DISKSTRING = 32 + PlSqlLexerAFTER = 33 + PlSqlLexerAGENT = 34 + PlSqlLexerAGGREGATE = 35 + PlSqlLexerA_LETTER = 36 + PlSqlLexerALIAS = 37 + PlSqlLexerALL = 38 + PlSqlLexerALLOCATE = 39 + PlSqlLexerALLOW = 40 + PlSqlLexerALL_ROWS = 41 + PlSqlLexerALTER = 42 + PlSqlLexerALTERNATE = 43 + PlSqlLexerALWAYS = 44 + PlSqlLexerANALYTIC = 45 + PlSqlLexerANALYZE = 46 + PlSqlLexerANCESTOR = 47 + PlSqlLexerANCILLARY = 48 + PlSqlLexerAND = 49 + PlSqlLexerAND_EQUAL = 50 + PlSqlLexerANNOTATIONS = 51 + PlSqlLexerANOMALY = 52 + PlSqlLexerANSI_REARCH = 53 + PlSqlLexerANTIJOIN = 54 + PlSqlLexerANY = 55 + PlSqlLexerANYSCHEMA = 56 + PlSqlLexerAPPEND = 57 + PlSqlLexerAPPENDCHILDXML = 58 + PlSqlLexerAPPEND_VALUES = 59 + PlSqlLexerAPPLICATION = 60 + PlSqlLexerAPPLY = 61 + PlSqlLexerAPPROX_COUNT_DISTINCT = 62 + PlSqlLexerARCHIVAL = 63 + PlSqlLexerARCHIVE = 64 + PlSqlLexerARCHIVED = 65 + PlSqlLexerARCHIVELOG = 66 + PlSqlLexerARE = 67 + PlSqlLexerARRAY = 68 + PlSqlLexerAS = 69 + PlSqlLexerASC = 70 + PlSqlLexerASCII = 71 + PlSqlLexerASCIISTR = 72 + PlSqlLexerASIN = 73 + PlSqlLexerASIS = 74 + PlSqlLexerASSEMBLY = 75 + PlSqlLexerASSIGN = 76 + PlSqlLexerASSOCIATE = 77 + PlSqlLexerASYNC = 78 + PlSqlLexerASYNCHRONOUS = 79 + PlSqlLexerATAN2 = 80 + PlSqlLexerATAN = 81 + PlSqlLexerAT = 82 + PlSqlLexerATTRIBUTE = 83 + PlSqlLexerATTRIBUTES = 84 + PlSqlLexerAUDIT = 85 + PlSqlLexerAUTHENTICATED = 86 + PlSqlLexerAUTHENTICATION = 87 + PlSqlLexerAUTHID = 88 + PlSqlLexerAUTHORIZATION = 89 + PlSqlLexerAUTOALLOCATE = 90 + PlSqlLexerAUTO = 91 + PlSqlLexerAUTOBACKUP = 92 + PlSqlLexerAUTOEXTEND = 93 + PlSqlLexerAUTO_LOGIN = 94 + PlSqlLexerAUTOMATIC = 95 + PlSqlLexerAUTONOMOUS_TRANSACTION = 96 + PlSqlLexerAUTO_REOPTIMIZE = 97 + PlSqlLexerAVAILABILITY = 98 + PlSqlLexerAVRO = 99 + PlSqlLexerBACKGROUND = 100 + PlSqlLexerBACKINGFILE = 101 + PlSqlLexerBACKUP = 102 + PlSqlLexerBACKUPS = 103 + PlSqlLexerBACKUPSET = 104 + PlSqlLexerBADFILE = 105 + PlSqlLexerBASIC = 106 + PlSqlLexerBASICFILE = 107 + PlSqlLexerBATCH = 108 + PlSqlLexerBATCHSIZE = 109 + PlSqlLexerBATCH_TABLE_ACCESS_BY_ROWID = 110 + PlSqlLexerBECOME = 111 + PlSqlLexerBEFORE = 112 + PlSqlLexerBEGIN = 113 + PlSqlLexerBEGINNING = 114 + PlSqlLexerBEGIN_OUTLINE_DATA = 115 + PlSqlLexerBEHALF = 116 + PlSqlLexerBEQUEATH = 117 + PlSqlLexerBETWEEN = 118 + PlSqlLexerBFILE = 119 + PlSqlLexerBFILENAME = 120 + PlSqlLexerBIG = 121 + PlSqlLexerBIGFILE = 122 + PlSqlLexerBIGINT = 123 + PlSqlLexerBINARY = 124 + PlSqlLexerBINARY_DOUBLE = 125 + PlSqlLexerBINARY_DOUBLE_INFINITY = 126 + PlSqlLexerBINARY_DOUBLE_NAN = 127 + PlSqlLexerBINARY_FLOAT = 128 + PlSqlLexerBINARY_FLOAT_INFINITY = 129 + PlSqlLexerBINARY_FLOAT_NAN = 130 + PlSqlLexerBINARY_INTEGER = 131 + PlSqlLexerBIND_AWARE = 132 + PlSqlLexerBINDING = 133 + PlSqlLexerBIN_TO_NUM = 134 + PlSqlLexerBITAND = 135 + PlSqlLexerBITMAP_AND = 136 + PlSqlLexerBITMAP = 137 + PlSqlLexerBITMAPS = 138 + PlSqlLexerBITMAP_TREE = 139 + PlSqlLexerBITS = 140 + PlSqlLexerBLANKS = 141 + PlSqlLexerBLOB = 142 + PlSqlLexerBLOCK = 143 + PlSqlLexerBLOCK_RANGE = 144 + PlSqlLexerBLOCKS = 145 + PlSqlLexerBLOCKSIZE = 146 + PlSqlLexerBODY = 147 + PlSqlLexerBOOLEAN = 148 + PlSqlLexerBOTH = 149 + PlSqlLexerBOUND = 150 + PlSqlLexerBRANCH = 151 + PlSqlLexerBREADTH = 152 + PlSqlLexerBROADCAST = 153 + PlSqlLexerBSON = 154 + PlSqlLexerBUFFER = 155 + PlSqlLexerBUFFER_CACHE = 156 + PlSqlLexerBUFFER_POOL = 157 + PlSqlLexerBUILD = 158 + PlSqlLexerBULK = 159 + PlSqlLexerBY = 160 + PlSqlLexerBYPASS_RECURSIVE_CHECK = 161 + PlSqlLexerBYPASS_UJVC = 162 + PlSqlLexerBYTE = 163 + PlSqlLexerBYTES = 164 + PlSqlLexerBYTEORDERMARK = 165 + PlSqlLexerCACHE = 166 + PlSqlLexerCACHE_CB = 167 + PlSqlLexerCACHE_INSTANCES = 168 + PlSqlLexerCACHE_TEMP_TABLE = 169 + PlSqlLexerCACHING = 170 + PlSqlLexerCALCULATED = 171 + PlSqlLexerCALLBACK = 172 + PlSqlLexerCALL = 173 + PlSqlLexerCANCEL = 174 + PlSqlLexerCANONICAL = 175 + PlSqlLexerCAPACITY = 176 + PlSqlLexerCAPTION = 177 + PlSqlLexerCARDINALITY = 178 + PlSqlLexerCASCADE = 179 + PlSqlLexerCASE = 180 + PlSqlLexerCAST = 181 + PlSqlLexerCASESENSITIVE = 182 + PlSqlLexerCATEGORY = 183 + PlSqlLexerCDBDEFAULT = 184 + PlSqlLexerCEIL = 185 + PlSqlLexerCELL_FLASH_CACHE = 186 + PlSqlLexerCERTIFICATE = 187 + PlSqlLexerCFILE = 188 + PlSqlLexerCHAINED = 189 + PlSqlLexerCHANGE = 190 + PlSqlLexerCHANGETRACKING = 191 + PlSqlLexerCHANGE_DUPKEY_ERROR_INDEX = 192 + PlSqlLexerCHARACTER = 193 + PlSqlLexerCHARACTERS = 194 + PlSqlLexerCHARACTERSET = 195 + PlSqlLexerCHAR = 196 + PlSqlLexerCHAR_CS = 197 + PlSqlLexerCHARTOROWID = 198 + PlSqlLexerCHECK_ACL_REWRITE = 199 + PlSqlLexerCHECK = 200 + PlSqlLexerCHECKPOINT = 201 + PlSqlLexerCHILD = 202 + PlSqlLexerCHOOSE = 203 + PlSqlLexerCHR = 204 + PlSqlLexerCHUNK = 205 + PlSqlLexerCLASS = 206 + PlSqlLexerCLASSIFICATION = 207 + PlSqlLexerCLASSIFIER = 208 + PlSqlLexerCLAUSE = 209 + PlSqlLexerCLEAN = 210 + PlSqlLexerCLEANUP = 211 + PlSqlLexerCLEAR = 212 + PlSqlLexerC_LETTER = 213 + PlSqlLexerCLIENT = 214 + PlSqlLexerCLOB = 215 + PlSqlLexerCLONE = 216 + PlSqlLexerCLOSE_CACHED_OPEN_CURSORS = 217 + PlSqlLexerCLOSE = 218 + PlSqlLexerCLUSTER_BY_ROWID = 219 + PlSqlLexerCLUSTER = 220 + PlSqlLexerCLUSTER_DETAILS = 221 + PlSqlLexerCLUSTER_DISTANCE = 222 + PlSqlLexerCLUSTER_ID = 223 + PlSqlLexerCLUSTERING = 224 + PlSqlLexerCLUSTERING_FACTOR = 225 + PlSqlLexerCLUSTER_PROBABILITY = 226 + PlSqlLexerCLUSTER_SET = 227 + PlSqlLexerCOALESCE = 228 + PlSqlLexerCOALESCE_SQ = 229 + PlSqlLexerCOARSE = 230 + PlSqlLexerCO_AUTH_IND = 231 + PlSqlLexerCOLD = 232 + PlSqlLexerCOLLECT = 233 + PlSqlLexerCOLLECTION = 234 + PlSqlLexerCOLUMNAR = 235 + PlSqlLexerCOLUMN_AUTH_INDICATOR = 236 + PlSqlLexerCOLUMN = 237 + PlSqlLexerCOLUMNS = 238 + PlSqlLexerCOLUMN_STATS = 239 + PlSqlLexerCOLUMN_VALUE = 240 + PlSqlLexerCOMMENT = 241 + PlSqlLexerCOMMIT = 242 + PlSqlLexerCOMMITTED = 243 + PlSqlLexerCOMMON = 244 + PlSqlLexerCOMMON_DATA = 245 + PlSqlLexerCOMPACT = 246 + PlSqlLexerCOMPATIBLE = 247 + PlSqlLexerCOMPATIBILITY = 248 + PlSqlLexerCOMPILE = 249 + PlSqlLexerCOMPLETE = 250 + PlSqlLexerCOMPLIANCE = 251 + PlSqlLexerCOMPONENT = 252 + PlSqlLexerCOMPONENTS = 253 + PlSqlLexerCOMPOSE = 254 + PlSqlLexerCOMPOSITE = 255 + PlSqlLexerCOMPOSITE_LIMIT = 256 + PlSqlLexerCOMPOUND = 257 + PlSqlLexerCOMPRESS = 258 + PlSqlLexerCOMPRESSION = 259 + PlSqlLexerCOMPUTE = 260 + PlSqlLexerCOMPUTATION = 261 + PlSqlLexerCONCAT = 262 + PlSqlLexerCONCURRENT = 263 + PlSqlLexerCON_DBID_TO_ID = 264 + PlSqlLexerCONDITIONAL = 265 + PlSqlLexerCONDITION = 266 + PlSqlLexerCONFIRM = 267 + PlSqlLexerCONFORMING = 268 + PlSqlLexerCON_GUID_TO_ID = 269 + PlSqlLexerCON_ID = 270 + PlSqlLexerCON_NAME_TO_ID = 271 + PlSqlLexerCONNECT_BY_CB_WHR_ONLY = 272 + PlSqlLexerCONNECT_BY_COMBINE_SW = 273 + PlSqlLexerCONNECT_BY_COST_BASED = 274 + PlSqlLexerCONNECT_BY_ELIM_DUPS = 275 + PlSqlLexerCONNECT_BY_FILTERING = 276 + PlSqlLexerCONNECT_BY_ISCYCLE = 277 + PlSqlLexerCONNECT_BY_ISLEAF = 278 + PlSqlLexerCONNECT_BY_ROOT = 279 + PlSqlLexerCONNECT = 280 + PlSqlLexerCONNECT_TIME = 281 + PlSqlLexerCONSIDER = 282 + PlSqlLexerCONSISTENT = 283 + PlSqlLexerCONSTANT = 284 + PlSqlLexerCONST = 285 + PlSqlLexerCONSTRAINT = 286 + PlSqlLexerCONSTRAINTS = 287 + PlSqlLexerCONSTRUCTOR = 288 + PlSqlLexerCONTAINER = 289 + PlSqlLexerCONTAINERS = 290 + PlSqlLexerCONTAINERS_DEFAULT = 291 + PlSqlLexerCONTAINER_DATA = 292 + PlSqlLexerCONTAINER_MAP = 293 + PlSqlLexerCONTENT = 294 + PlSqlLexerCONTENTS = 295 + PlSqlLexerCONTEXT = 296 + PlSqlLexerCONTINUE = 297 + PlSqlLexerCONTROLFILE = 298 + PlSqlLexerCON_UID_TO_ID = 299 + PlSqlLexerCONVERT = 300 + PlSqlLexerCONVERSION = 301 + PlSqlLexerCOOKIE = 302 + PlSqlLexerCOPY = 303 + PlSqlLexerCORR_K = 304 + PlSqlLexerCORR_S = 305 + PlSqlLexerCORRUPTION = 306 + PlSqlLexerCORRUPT_XID_ALL = 307 + PlSqlLexerCORRUPT_XID = 308 + PlSqlLexerCOS = 309 + PlSqlLexerCOSH = 310 + PlSqlLexerCOST = 311 + PlSqlLexerCOST_XML_QUERY_REWRITE = 312 + PlSqlLexerCOUNT = 313 + PlSqlLexerCOUNTED = 314 + PlSqlLexerCOVAR_POP = 315 + PlSqlLexerCOVAR_SAMP = 316 + PlSqlLexerCPU_COSTING = 317 + PlSqlLexerCPU_PER_CALL = 318 + PlSqlLexerCPU_PER_SESSION = 319 + PlSqlLexerCRASH = 320 + PlSqlLexerCREATE = 321 + PlSqlLexerCREATE_FILE_DEST = 322 + PlSqlLexerCREATE_STORED_OUTLINES = 323 + PlSqlLexerCREATION = 324 + PlSqlLexerCREDENTIAL = 325 + PlSqlLexerCRITICAL = 326 + PlSqlLexerCROSS = 327 + PlSqlLexerCROSSEDITION = 328 + PlSqlLexerCSCONVERT = 329 + PlSqlLexerCSV = 330 + PlSqlLexerCUBE_AJ = 331 + PlSqlLexerCUBE = 332 + PlSqlLexerCUBE_GB = 333 + PlSqlLexerCUBE_SJ = 334 + PlSqlLexerCUME_DISTM = 335 + PlSqlLexerCURRENT = 336 + PlSqlLexerCURRENT_DATE = 337 + PlSqlLexerCURRENT_SCHEMA = 338 + PlSqlLexerCURRENT_TIME = 339 + PlSqlLexerCURRENT_TIMESTAMP = 340 + PlSqlLexerCURRENT_USER = 341 + PlSqlLexerCURRENTV = 342 + PlSqlLexerCURSOR = 343 + PlSqlLexerCURSOR_SHARING_EXACT = 344 + PlSqlLexerCURSOR_SPECIFIC_SEGMENT = 345 + PlSqlLexerCUSTOMDATUM = 346 + PlSqlLexerCV = 347 + PlSqlLexerCYCLE = 348 + PlSqlLexerDANGLING = 349 + PlSqlLexerDATABASE = 350 + PlSqlLexerDATA = 351 + PlSqlLexerDATAFILE = 352 + PlSqlLexerDATAFILES = 353 + PlSqlLexerDATAGUARDCONFIG = 354 + PlSqlLexerDATAMOVEMENT = 355 + PlSqlLexerDATAOBJNO = 356 + PlSqlLexerDATAOBJ_TO_MAT_PARTITION = 357 + PlSqlLexerDATAOBJ_TO_PARTITION = 358 + PlSqlLexerDATAPUMP = 359 + PlSqlLexerDATA_SECURITY_REWRITE_LIMIT = 360 + PlSqlLexerDATE = 361 + PlSqlLexerDATE_CACHE = 362 + PlSqlLexerDATE_FORMAT = 363 + PlSqlLexerDATE_MODE = 364 + PlSqlLexerDAY = 365 + PlSqlLexerDAYS = 366 + PlSqlLexerDAY_TO_SECOND = 367 + PlSqlLexerDBA = 368 + PlSqlLexerDBA_RECYCLEBIN = 369 + PlSqlLexerDBLINK = 370 + PlSqlLexerDBMS_STATS = 371 + PlSqlLexerDB_ROLE_CHANGE = 372 + PlSqlLexerDBTIMEZONE = 373 + PlSqlLexerDB_UNIQUE_NAME = 374 + PlSqlLexerDB_VERSION = 375 + PlSqlLexerDDL = 376 + PlSqlLexerDEALLOCATE = 377 + PlSqlLexerDEBUG = 378 + PlSqlLexerDEBUGGER = 379 + PlSqlLexerDEC = 380 + PlSqlLexerDECIMAL = 381 + PlSqlLexerDECLARE = 382 + PlSqlLexerDECOMPOSE = 383 + PlSqlLexerDECORRELATE = 384 + PlSqlLexerDECR = 385 + PlSqlLexerDECREMENT = 386 + PlSqlLexerDECRYPT = 387 + PlSqlLexerDEDUPLICATE = 388 + PlSqlLexerDEFAULT = 389 + PlSqlLexerDEFAULTIF = 390 + PlSqlLexerDEFAULTS = 391 + PlSqlLexerDEFAULT_COLLATION = 392 + PlSqlLexerDEFAULT_CREDENTIAL = 393 + PlSqlLexerDEFERRABLE = 394 + PlSqlLexerDEFERRED = 395 + PlSqlLexerDEFINED = 396 + PlSqlLexerDEFINE = 397 + PlSqlLexerDEFINER = 398 + PlSqlLexerDEGREE = 399 + PlSqlLexerDELAY = 400 + PlSqlLexerDELEGATE = 401 + PlSqlLexerDELETE_ALL = 402 + PlSqlLexerDELETE = 403 + PlSqlLexerDELETEXML = 404 + PlSqlLexerDELIMITED = 405 + PlSqlLexerDEMAND = 406 + PlSqlLexerDENSE_RANKM = 407 + PlSqlLexerDEPENDENT = 408 + PlSqlLexerDEPRECATE = 409 + PlSqlLexerDEPTH = 410 + PlSqlLexerDEQUEUE = 411 + PlSqlLexerDEREF = 412 + PlSqlLexerDEREF_NO_REWRITE = 413 + PlSqlLexerDESC = 414 + PlSqlLexerDESCRIPTION = 415 + PlSqlLexerDESTROY = 416 + PlSqlLexerDETACHED = 417 + PlSqlLexerDETECTED = 418 + PlSqlLexerDETERMINES = 419 + PlSqlLexerDETERMINISTIC = 420 + PlSqlLexerDICTIONARY = 421 + PlSqlLexerDIMENSION = 422 + PlSqlLexerDIMENSIONS = 423 + PlSqlLexerDIRECTIO = 424 + PlSqlLexerDIRECT_LOAD = 425 + PlSqlLexerDIRECTORY = 426 + PlSqlLexerDIRECT_PATH = 427 + PlSqlLexerDISABLE_ALL = 428 + PlSqlLexerDISABLE = 429 + PlSqlLexerDISABLED = 430 + PlSqlLexerDISABLE_DIRECTORY_LINK_CHECK = 431 + PlSqlLexerDISABLE_PARALLEL_DML = 432 + PlSqlLexerDISABLE_PRESET = 433 + PlSqlLexerDISABLE_RPKE = 434 + PlSqlLexerDISALLOW = 435 + PlSqlLexerDISASSOCIATE = 436 + PlSqlLexerDISCARD = 437 + PlSqlLexerDISCARDFILE = 438 + PlSqlLexerDISCONNECT = 439 + PlSqlLexerDISK = 440 + PlSqlLexerDISKGROUP = 441 + PlSqlLexerDISKGROUP_PLUS = 442 + PlSqlLexerDISKS = 443 + PlSqlLexerDISMOUNT = 444 + PlSqlLexerDISTINCT = 445 + PlSqlLexerDISTINGUISHED = 446 + PlSqlLexerDISTRIBUTED = 447 + PlSqlLexerDISTRIBUTE = 448 + PlSqlLexerDML = 449 + PlSqlLexerDML_UPDATE = 450 + PlSqlLexerDNFS_DISABLE = 451 + PlSqlLexerDNFS_ENABLE = 452 + PlSqlLexerDNFS_READBUFFERS = 453 + PlSqlLexerDOCFIDELITY = 454 + PlSqlLexerDOCUMENT = 455 + PlSqlLexerDOLLAR_ELSE = 456 + PlSqlLexerDOLLAR_ELSIF = 457 + PlSqlLexerDOLLAR_END = 458 + PlSqlLexerDOLLAR_ERROR = 459 + PlSqlLexerDOLLAR_IF = 460 + PlSqlLexerDOLLAR_THEN = 461 + PlSqlLexerDOMAIN_INDEX_FILTER = 462 + PlSqlLexerDOMAIN_INDEX_NO_SORT = 463 + PlSqlLexerDOMAIN_INDEX_SORT = 464 + PlSqlLexerDOUBLE = 465 + PlSqlLexerDOWNGRADE = 466 + PlSqlLexerDRIVING_SITE = 467 + PlSqlLexerDROP_COLUMN = 468 + PlSqlLexerDROP = 469 + PlSqlLexerDROP_GROUP = 470 + PlSqlLexerDSINTERVAL_UNCONSTRAINED = 471 + PlSqlLexerDST_UPGRADE_INSERT_CONV = 472 + PlSqlLexerDUMP = 473 + PlSqlLexerDUMPSET = 474 + PlSqlLexerDUPLICATE = 475 + PlSqlLexerDV = 476 + PlSqlLexerDYNAMIC = 477 + PlSqlLexerDYNAMIC_SAMPLING = 478 + PlSqlLexerDYNAMIC_SAMPLING_EST_CDN = 479 + PlSqlLexerE_LETTER = 480 + PlSqlLexerEACH = 481 + PlSqlLexerEDITIONABLE = 482 + PlSqlLexerEDITION = 483 + PlSqlLexerEDITIONING = 484 + PlSqlLexerEDITIONS = 485 + PlSqlLexerELEMENT = 486 + PlSqlLexerELIM_GROUPBY = 487 + PlSqlLexerELIMINATE_JOIN = 488 + PlSqlLexerELIMINATE_OBY = 489 + PlSqlLexerELIMINATE_OUTER_JOIN = 490 + PlSqlLexerELSE = 491 + PlSqlLexerELSIF = 492 + PlSqlLexerEM = 493 + PlSqlLexerEMBEDDED = 494 + PlSqlLexerEMPTY_BLOB = 495 + PlSqlLexerEMPTY_CLOB = 496 + PlSqlLexerEMPTY_ = 497 + PlSqlLexerENABLE_ALL = 498 + PlSqlLexerENABLE = 499 + PlSqlLexerENABLED = 500 + PlSqlLexerENABLE_PARALLEL_DML = 501 + PlSqlLexerENABLE_PRESET = 502 + PlSqlLexerENCLOSED = 503 + PlSqlLexerENCODING = 504 + PlSqlLexerENCRYPT = 505 + PlSqlLexerENCRYPTION = 506 + PlSqlLexerENCRYPTPASSWORDISNULL = 507 + PlSqlLexerEND = 508 + PlSqlLexerEND_OUTLINE_DATA = 509 + PlSqlLexerENDIAN = 510 + PlSqlLexerENFORCED = 511 + PlSqlLexerENFORCE = 512 + PlSqlLexerENQUEUE = 513 + PlSqlLexerENTERPRISE = 514 + PlSqlLexerENTITYESCAPING = 515 + PlSqlLexerENTRY = 516 + PlSqlLexerEQUIPART = 517 + PlSqlLexerERR = 518 + PlSqlLexerERROR_ARGUMENT = 519 + PlSqlLexerERROR = 520 + PlSqlLexerERROR_ON_OVERLAP_TIME = 521 + PlSqlLexerERRORS = 522 + PlSqlLexerERROR_INDEX = 523 + PlSqlLexerERROR_CODE = 524 + PlSqlLexerESCAPE = 525 + PlSqlLexerESCAPED = 526 + PlSqlLexerESTIMATE = 527 + PlSqlLexerEVAL = 528 + PlSqlLexerEVALNAME = 529 + PlSqlLexerEVALUATE = 530 + PlSqlLexerEVALUATION = 531 + PlSqlLexerEVENTS = 532 + PlSqlLexerEVERY = 533 + PlSqlLexerEXCEPT = 534 + PlSqlLexerEXCEPTION = 535 + PlSqlLexerEXCEPTION_INIT = 536 + PlSqlLexerEXCEPTIONS = 537 + PlSqlLexerEXCHANGE = 538 + PlSqlLexerEXCLUDE = 539 + PlSqlLexerEXCLUDING = 540 + PlSqlLexerEXCLUSIVE = 541 + PlSqlLexerEXECUTE = 542 + PlSqlLexerEXEMPT = 543 + PlSqlLexerEXISTING = 544 + PlSqlLexerEXISTS = 545 + PlSqlLexerEXISTSNODE = 546 + PlSqlLexerEXIT = 547 + PlSqlLexerEXPAND_GSET_TO_UNION = 548 + PlSqlLexerEXPAND_TABLE = 549 + PlSqlLexerEXP = 550 + PlSqlLexerEXPIRE = 551 + PlSqlLexerEXPLAIN = 552 + PlSqlLexerEXPLOSION = 553 + PlSqlLexerEXPORT = 554 + PlSqlLexerEXPR_CORR_CHECK = 555 + PlSqlLexerEXPRESS = 556 + PlSqlLexerEXTENDS = 557 + PlSqlLexerEXTENT = 558 + PlSqlLexerEXTENTS = 559 + PlSqlLexerEXTERNAL = 560 + PlSqlLexerEXTERNALLY = 561 + PlSqlLexerEXTRACTCLOBXML = 562 + PlSqlLexerEXTRACT = 563 + PlSqlLexerEXTRACTVALUE = 564 + PlSqlLexerEXTRA = 565 + PlSqlLexerFACILITY = 566 + PlSqlLexerFACT = 567 + PlSqlLexerFACTOR = 568 + PlSqlLexerFACTORIZE_JOIN = 569 + PlSqlLexerFAILED = 570 + PlSqlLexerFAILED_LOGIN_ATTEMPTS = 571 + PlSqlLexerFAILGROUP = 572 + PlSqlLexerFAILOVER = 573 + PlSqlLexerFAILURE = 574 + PlSqlLexerFALSE = 575 + PlSqlLexerFAMILY = 576 + PlSqlLexerFAR = 577 + PlSqlLexerFAST = 578 + PlSqlLexerFASTSTART = 579 + PlSqlLexerFBTSCAN = 580 + PlSqlLexerFEATURE = 581 + PlSqlLexerFEATURE_DETAILS = 582 + PlSqlLexerFEATURE_ID = 583 + PlSqlLexerFEATURE_SET = 584 + PlSqlLexerFEATURE_VALUE = 585 + PlSqlLexerFETCH = 586 + PlSqlLexerFIELD = 587 + PlSqlLexerFIELDS = 588 + PlSqlLexerFILE = 589 + PlSqlLexerFILE_NAME_CONVERT = 590 + PlSqlLexerFILEGROUP = 591 + PlSqlLexerFILESTORE = 592 + PlSqlLexerFILESYSTEM_LIKE_LOGGING = 593 + PlSqlLexerFILTER = 594 + PlSqlLexerFINAL = 595 + PlSqlLexerFINE = 596 + PlSqlLexerFINISH = 597 + PlSqlLexerFIRST = 598 + PlSqlLexerFIRSTM = 599 + PlSqlLexerFIRST_ROWS = 600 + PlSqlLexerFIRST_VALUE = 601 + PlSqlLexerFIXED = 602 + PlSqlLexerFIXED_VIEW_DATA = 603 + PlSqlLexerFLAGGER = 604 + PlSqlLexerFLASHBACK = 605 + PlSqlLexerFLASH_CACHE = 606 + PlSqlLexerFLOAT = 607 + PlSqlLexerFLOB = 608 + PlSqlLexerFLEX = 609 + PlSqlLexerFLOOR = 610 + PlSqlLexerFLUSH = 611 + PlSqlLexerFOLDER = 612 + PlSqlLexerFOLLOWING = 613 + PlSqlLexerFOLLOWS = 614 + PlSqlLexerFORALL = 615 + PlSqlLexerFORCE = 616 + PlSqlLexerFORCE_XML_QUERY_REWRITE = 617 + PlSqlLexerFOREIGN = 618 + PlSqlLexerFOREVER = 619 + PlSqlLexerFOR = 620 + PlSqlLexerFORMAT = 621 + PlSqlLexerFORWARD = 622 + PlSqlLexerFRAGMENT_NUMBER = 623 + PlSqlLexerFREELIST = 624 + PlSqlLexerFREELISTS = 625 + PlSqlLexerFREEPOOLS = 626 + PlSqlLexerFRESH = 627 + PlSqlLexerFROM = 628 + PlSqlLexerFROM_TZ = 629 + PlSqlLexerFULL = 630 + PlSqlLexerFULL_OUTER_JOIN_TO_OUTER = 631 + PlSqlLexerFUNCTION = 632 + PlSqlLexerFUNCTIONS = 633 + PlSqlLexerFTP = 634 + PlSqlLexerG_LETTER = 635 + PlSqlLexerGATHER_OPTIMIZER_STATISTICS = 636 + PlSqlLexerGATHER_PLAN_STATISTICS = 637 + PlSqlLexerGBY_CONC_ROLLUP = 638 + PlSqlLexerGBY_PUSHDOWN = 639 + PlSqlLexerGENERATED = 640 + PlSqlLexerGET = 641 + PlSqlLexerGLOBAL = 642 + PlSqlLexerGLOBALLY = 643 + PlSqlLexerGLOBAL_NAME = 644 + PlSqlLexerGLOBAL_TOPIC_ENABLED = 645 + PlSqlLexerGOTO = 646 + PlSqlLexerGRANT = 647 + PlSqlLexerGROUP_BY = 648 + PlSqlLexerGROUP = 649 + PlSqlLexerGROUP_ID = 650 + PlSqlLexerGROUPING = 651 + PlSqlLexerGROUPING_ID = 652 + PlSqlLexerGROUPS = 653 + PlSqlLexerGUARANTEED = 654 + PlSqlLexerGUARANTEE = 655 + PlSqlLexerGUARD = 656 + PlSqlLexerHADOOP_TRAILERS = 657 + PlSqlLexerHALF_YEARS = 658 + PlSqlLexerHASH_AJ = 659 + PlSqlLexerHASH = 660 + PlSqlLexerHASHKEYS = 661 + PlSqlLexerHASH_SJ = 662 + PlSqlLexerHAVING = 663 + PlSqlLexerHEADER = 664 + PlSqlLexerHEAP = 665 + PlSqlLexerHELP = 666 + PlSqlLexerHEXTORAW = 667 + PlSqlLexerHEXTOREF = 668 + PlSqlLexerHIDDEN_KEYWORD = 669 + PlSqlLexerHIDE = 670 + PlSqlLexerHIER_ORDER = 671 + PlSqlLexerHIERARCHICAL = 672 + PlSqlLexerHIERARCHIES = 673 + PlSqlLexerHIERARCHY = 674 + PlSqlLexerHIGH = 675 + PlSqlLexerHINTSET_BEGIN = 676 + PlSqlLexerHINTSET_END = 677 + PlSqlLexerHOT = 678 + PlSqlLexerHOUR = 679 + PlSqlLexerHOURS = 680 + PlSqlLexerHTTP = 681 + PlSqlLexerHWM_BROKERED = 682 + PlSqlLexerHYBRID = 683 + PlSqlLexerH_LETTER = 684 + PlSqlLexerIDENTIFIED = 685 + PlSqlLexerIDENTIFIER = 686 + PlSqlLexerIDENTITY = 687 + PlSqlLexerIDGENERATORS = 688 + PlSqlLexerID = 689 + PlSqlLexerIDLE_TIME = 690 + PlSqlLexerIF = 691 + PlSqlLexerIGNORE = 692 + PlSqlLexerIGNORE_CHARS_AFTER_EOR = 693 + PlSqlLexerIGNORE_OPTIM_EMBEDDED_HINTS = 694 + PlSqlLexerIGNORE_ROW_ON_DUPKEY_INDEX = 695 + PlSqlLexerIGNORE_WHERE_CLAUSE = 696 + PlSqlLexerILM = 697 + PlSqlLexerIMMEDIATE = 698 + PlSqlLexerIMPACT = 699 + PlSqlLexerIMPORT = 700 + PlSqlLexerINACTIVE = 701 + PlSqlLexerINACTIVE_ACCOUNT_TIME = 702 + PlSqlLexerINCLUDE = 703 + PlSqlLexerINCLUDE_VERSION = 704 + PlSqlLexerINCLUDING = 705 + PlSqlLexerINCREMENTAL = 706 + PlSqlLexerINCREMENT = 707 + PlSqlLexerINCR = 708 + PlSqlLexerINDENT = 709 + PlSqlLexerINDEX_ASC = 710 + PlSqlLexerINDEX_COMBINE = 711 + PlSqlLexerINDEX_DESC = 712 + PlSqlLexerINDEXED = 713 + PlSqlLexerINDEXES = 714 + PlSqlLexerINDEX_FFS = 715 + PlSqlLexerINDEX_FILTER = 716 + PlSqlLexerINDEX = 717 + PlSqlLexerINDEXING = 718 + PlSqlLexerINDEX_JOIN = 719 + PlSqlLexerINDEX_ROWS = 720 + PlSqlLexerINDEX_RRS = 721 + PlSqlLexerINDEX_RS_ASC = 722 + PlSqlLexerINDEX_RS_DESC = 723 + PlSqlLexerINDEX_RS = 724 + PlSqlLexerINDEX_SCAN = 725 + PlSqlLexerINDEX_SKIP_SCAN = 726 + PlSqlLexerINDEX_SS_ASC = 727 + PlSqlLexerINDEX_SS_DESC = 728 + PlSqlLexerINDEX_SS = 729 + PlSqlLexerINDEX_STATS = 730 + PlSqlLexerINDEXTYPE = 731 + PlSqlLexerINDEXTYPES = 732 + PlSqlLexerINDICATOR = 733 + PlSqlLexerINDICES = 734 + PlSqlLexerINFINITE = 735 + PlSqlLexerINFORMATIONAL = 736 + PlSqlLexerINHERIT = 737 + PlSqlLexerIN = 738 + PlSqlLexerINITCAP = 739 + PlSqlLexerINITIAL = 740 + PlSqlLexerINITIALIZED = 741 + PlSqlLexerINITIALLY = 742 + PlSqlLexerINITRANS = 743 + PlSqlLexerINLINE = 744 + PlSqlLexerINLINE_XMLTYPE_NT = 745 + PlSqlLexerINMEMORY = 746 + PlSqlLexerIN_MEMORY_METADATA = 747 + PlSqlLexerINMEMORY_PRUNING = 748 + PlSqlLexerINNER = 749 + PlSqlLexerINOUT = 750 + PlSqlLexerINPLACE = 751 + PlSqlLexerINPUTFORMAT = 752 + PlSqlLexerINSERTCHILDXMLAFTER = 753 + PlSqlLexerINSERTCHILDXMLBEFORE = 754 + PlSqlLexerINSERTCHILDXML = 755 + PlSqlLexerINSERT = 756 + PlSqlLexerINSERTXMLAFTER = 757 + PlSqlLexerINSERTXMLBEFORE = 758 + PlSqlLexerINSTANCE = 759 + PlSqlLexerINSTANCES = 760 + PlSqlLexerINSTANTIABLE = 761 + PlSqlLexerINSTANTLY = 762 + PlSqlLexerINSTEAD = 763 + PlSqlLexerINSTR2 = 764 + PlSqlLexerINSTR4 = 765 + PlSqlLexerINSTRB = 766 + PlSqlLexerINSTRC = 767 + PlSqlLexerINSTR = 768 + PlSqlLexerINTEGER = 769 + PlSqlLexerINTERLEAVED = 770 + PlSqlLexerINTERMEDIATE = 771 + PlSqlLexerINTERNAL_CONVERT = 772 + PlSqlLexerINTERNAL_USE = 773 + PlSqlLexerINTERPRETED = 774 + PlSqlLexerINTERSECT = 775 + PlSqlLexerINTERVAL = 776 + PlSqlLexerINT = 777 + PlSqlLexerINTERNAL = 778 + PlSqlLexerINTO = 779 + PlSqlLexerINVALIDATE = 780 + PlSqlLexerINVALIDATION = 781 + PlSqlLexerINVISIBLE = 782 + PlSqlLexerIN_XQUERY = 783 + PlSqlLexerIO_OPTIONS = 784 + PlSqlLexerIS = 785 + PlSqlLexerIS_LEAF = 786 + PlSqlLexerISOLATION = 787 + PlSqlLexerISOLATION_LEVEL = 788 + PlSqlLexerITEMS = 789 + PlSqlLexerITERATE = 790 + PlSqlLexerITERATION_NUMBER = 791 + PlSqlLexerJAVA = 792 + PlSqlLexerJOB = 793 + PlSqlLexerJOIN = 794 + PlSqlLexerJSON_ARRAYAGG = 795 + PlSqlLexerJSON_ARRAY = 796 + PlSqlLexerJSON_EQUAL = 797 + PlSqlLexerJSON_EXISTS2 = 798 + PlSqlLexerJSON_EXISTS = 799 + PlSqlLexerJSONGET = 800 + PlSqlLexerJSON = 801 + PlSqlLexerJSON_OBJECTAGG = 802 + PlSqlLexerJSON_OBJECT = 803 + PlSqlLexerJSONPARSE = 804 + PlSqlLexerJSON_QUERY = 805 + PlSqlLexerJSON_SERIALIZE = 806 + PlSqlLexerJSON_TABLE = 807 + PlSqlLexerJSON_TEXTCONTAINS2 = 808 + PlSqlLexerJSON_TEXTCONTAINS = 809 + PlSqlLexerJSON_TRANSFORM = 810 + PlSqlLexerJSON_VALUE = 811 + PlSqlLexerK_LETTER = 812 + PlSqlLexerKEEP_DUPLICATES = 813 + PlSqlLexerKEEP = 814 + PlSqlLexerKERBEROS = 815 + PlSqlLexerKEY = 816 + PlSqlLexerKEY_LENGTH = 817 + PlSqlLexerKEYSIZE = 818 + PlSqlLexerKEYS = 819 + PlSqlLexerKEYSTORE = 820 + PlSqlLexerKILL = 821 + PlSqlLexerLABEL = 822 + PlSqlLexerLANGUAGE = 823 + PlSqlLexerLAST_DAY = 824 + PlSqlLexerLAST = 825 + PlSqlLexerLAST_VALUE = 826 + PlSqlLexerLATERAL = 827 + PlSqlLexerLATEST = 828 + PlSqlLexerLAX = 829 + PlSqlLexerLAYER = 830 + PlSqlLexerLDAP_REGISTRATION_ENABLED = 831 + PlSqlLexerLDAP_REGISTRATION = 832 + PlSqlLexerLDAP_REG_SYNC_INTERVAL = 833 + PlSqlLexerLDRTRIM = 834 + PlSqlLexerLEAF = 835 + PlSqlLexerLEAD_CDB = 836 + PlSqlLexerLEAD_CDB_URI = 837 + PlSqlLexerLEADING = 838 + PlSqlLexerLEFT = 839 + PlSqlLexerLENGTH2 = 840 + PlSqlLexerLENGTH4 = 841 + PlSqlLexerLENGTHB = 842 + PlSqlLexerLENGTHC = 843 + PlSqlLexerLENGTH = 844 + PlSqlLexerLESS = 845 + PlSqlLexerLEVEL = 846 + PlSqlLexerLEVEL_NAME = 847 + PlSqlLexerLEVELS = 848 + PlSqlLexerLIBRARY = 849 + PlSqlLexerLIFECYCLE = 850 + PlSqlLexerLIFE = 851 + PlSqlLexerLIFETIME = 852 + PlSqlLexerLIKE2 = 853 + PlSqlLexerLIKE4 = 854 + PlSqlLexerLIKEC = 855 + PlSqlLexerLIKE_EXPAND = 856 + PlSqlLexerLIKE = 857 + PlSqlLexerLIMIT = 858 + PlSqlLexerLINEAR = 859 + PlSqlLexerLINES = 860 + PlSqlLexerLINK = 861 + PlSqlLexerLIST = 862 + PlSqlLexerLITTLE = 863 + PlSqlLexerLLS = 864 + PlSqlLexerLN = 865 + PlSqlLexerLNNVL = 866 + PlSqlLexerLOAD = 867 + PlSqlLexerLOB = 868 + PlSqlLexerLOBFILE = 869 + PlSqlLexerLOBNVL = 870 + PlSqlLexerLOBS = 871 + PlSqlLexerLOCAL_INDEXES = 872 + PlSqlLexerLOCAL = 873 + PlSqlLexerLOCALTIME = 874 + PlSqlLexerLOCALTIMESTAMP = 875 + PlSqlLexerLOCATION = 876 + PlSqlLexerLOCATOR = 877 + PlSqlLexerLOCKDOWN = 878 + PlSqlLexerLOCKED = 879 + PlSqlLexerLOCKING = 880 + PlSqlLexerLOCK = 881 + PlSqlLexerLOGFILE = 882 + PlSqlLexerLOGFILES = 883 + PlSqlLexerLOGGING = 884 + PlSqlLexerLOGICAL = 885 + PlSqlLexerLOGICAL_READS_PER_CALL = 886 + PlSqlLexerLOGICAL_READS_PER_SESSION = 887 + PlSqlLexerLOG = 888 + PlSqlLexerLOGMINING = 889 + PlSqlLexerLOGOFF = 890 + PlSqlLexerLOGON = 891 + PlSqlLexerLOG_READ_ONLY_VIOLATIONS = 892 + PlSqlLexerLONG = 893 + PlSqlLexerLOOP = 894 + PlSqlLexerLOST = 895 + PlSqlLexerLOWER = 896 + PlSqlLexerLOW = 897 + PlSqlLexerLPAD = 898 + PlSqlLexerLRTRIM = 899 + PlSqlLexerLTRIM = 900 + PlSqlLexerM_LETTER = 901 + PlSqlLexerMAIN = 902 + PlSqlLexerMAKE_REF = 903 + PlSqlLexerMANAGED = 904 + PlSqlLexerMANAGE = 905 + PlSqlLexerMANAGEMENT = 906 + PlSqlLexerMANAGER = 907 + PlSqlLexerMANDATORY = 908 + PlSqlLexerMANUAL = 909 + PlSqlLexerMAP = 910 + PlSqlLexerMAPPING = 911 + PlSqlLexerMASK = 912 + PlSqlLexerMASTER = 913 + PlSqlLexerMATCHED = 914 + PlSqlLexerMATCHES = 915 + PlSqlLexerMATCH = 916 + PlSqlLexerMATCH_NUMBER = 917 + PlSqlLexerMATCH_RECOGNIZE = 918 + PlSqlLexerMATERIALIZED = 919 + PlSqlLexerMATERIALIZE = 920 + PlSqlLexerMAXARCHLOGS = 921 + PlSqlLexerMAXDATAFILES = 922 + PlSqlLexerMAXEXTENTS = 923 + PlSqlLexerMAXIMIZE = 924 + PlSqlLexerMAXINSTANCES = 925 + PlSqlLexerMAXLOGFILES = 926 + PlSqlLexerMAXLOGHISTORY = 927 + PlSqlLexerMAXLOGMEMBERS = 928 + PlSqlLexerMAX_SHARED_TEMP_SIZE = 929 + PlSqlLexerMAXSIZE = 930 + PlSqlLexerMAXTRANS = 931 + PlSqlLexerMAXVALUE = 932 + PlSqlLexerMEASURE = 933 + PlSqlLexerMEASURES = 934 + PlSqlLexerMEDIUM = 935 + PlSqlLexerMEMBER = 936 + PlSqlLexerMEMBER_CAPTION = 937 + PlSqlLexerMEMBER_DESCRIPTION = 938 + PlSqlLexerMEMBER_NAME = 939 + PlSqlLexerMEMBER_UNIQUE_NAME = 940 + PlSqlLexerMEMCOMPRESS = 941 + PlSqlLexerMEMORY = 942 + PlSqlLexerMERGEACTIONS = 943 + PlSqlLexerMERGE_AJ = 944 + PlSqlLexerMERGE_CONST_ON = 945 + PlSqlLexerMERGE = 946 + PlSqlLexerMERGE_SJ = 947 + PlSqlLexerMETADATA = 948 + PlSqlLexerMETHOD = 949 + PlSqlLexerMIGRATE = 950 + PlSqlLexerMIGRATION = 951 + PlSqlLexerMINEXTENTS = 952 + PlSqlLexerMINIMIZE = 953 + PlSqlLexerMINIMUM = 954 + PlSqlLexerMINING = 955 + PlSqlLexerMINUS = 956 + PlSqlLexerMINUS_NULL = 957 + PlSqlLexerMINUTE = 958 + PlSqlLexerMINUTES = 959 + PlSqlLexerMINVALUE = 960 + PlSqlLexerMIRRORCOLD = 961 + PlSqlLexerMIRRORHOT = 962 + PlSqlLexerMIRROR = 963 + PlSqlLexerMISSING = 964 + PlSqlLexerMISMATCH = 965 + PlSqlLexerMLSLABEL = 966 + PlSqlLexerMODEL_COMPILE_SUBQUERY = 967 + PlSqlLexerMODEL_DONTVERIFY_UNIQUENESS = 968 + PlSqlLexerMODEL_DYNAMIC_SUBQUERY = 969 + PlSqlLexerMODEL_MIN_ANALYSIS = 970 + PlSqlLexerMODEL = 971 + PlSqlLexerMODEL_NB = 972 + PlSqlLexerMODEL_NO_ANALYSIS = 973 + PlSqlLexerMODEL_PBY = 974 + PlSqlLexerMODEL_PUSH_REF = 975 + PlSqlLexerMODEL_SV = 976 + PlSqlLexerMODE = 977 + PlSqlLexerMODIFICATION = 978 + PlSqlLexerMODIFY_COLUMN_TYPE = 979 + PlSqlLexerMODIFY = 980 + PlSqlLexerMOD = 981 + PlSqlLexerMODULE = 982 + PlSqlLexerMONITORING = 983 + PlSqlLexerMONITOR = 984 + PlSqlLexerMONTH = 985 + PlSqlLexerMONTHS_BETWEEN = 986 + PlSqlLexerMONTHS = 987 + PlSqlLexerMOUNT = 988 + PlSqlLexerMOUNTPATH = 989 + PlSqlLexerMOUNTPOINT = 990 + PlSqlLexerMOVEMENT = 991 + PlSqlLexerMOVE = 992 + PlSqlLexerMULTIDIMENSIONAL = 993 + PlSqlLexerMULTISET = 994 + PlSqlLexerMV_MERGE = 995 + PlSqlLexerNAMED = 996 + PlSqlLexerNAME = 997 + PlSqlLexerNAMESPACE = 998 + PlSqlLexerNAN_ = 999 + PlSqlLexerNANVL = 1000 + PlSqlLexerNATIONAL = 1001 + PlSqlLexerNATIVE_FULL_OUTER_JOIN = 1002 + PlSqlLexerNATIVE = 1003 + PlSqlLexerNATURAL = 1004 + PlSqlLexerNATURALN = 1005 + PlSqlLexerNAV = 1006 + PlSqlLexerNCHAR_CS = 1007 + PlSqlLexerNCHAR = 1008 + PlSqlLexerNCHR = 1009 + PlSqlLexerNCLOB = 1010 + PlSqlLexerNEEDED = 1011 + PlSqlLexerNEG = 1012 + PlSqlLexerNESTED = 1013 + PlSqlLexerNESTED_TABLE_FAST_INSERT = 1014 + PlSqlLexerNESTED_TABLE_GET_REFS = 1015 + PlSqlLexerNESTED_TABLE_ID = 1016 + PlSqlLexerNESTED_TABLE_SET_REFS = 1017 + PlSqlLexerNESTED_TABLE_SET_SETID = 1018 + PlSqlLexerNETWORK = 1019 + PlSqlLexerNEVER = 1020 + PlSqlLexerNEW = 1021 + PlSqlLexerNEWLINE_ = 1022 + PlSqlLexerNEW_TIME = 1023 + PlSqlLexerNEXT_DAY = 1024 + PlSqlLexerNEXT = 1025 + PlSqlLexerNL_AJ = 1026 + PlSqlLexerNLJ_BATCHING = 1027 + PlSqlLexerNLJ_INDEX_FILTER = 1028 + PlSqlLexerNLJ_INDEX_SCAN = 1029 + PlSqlLexerNLJ_PREFETCH = 1030 + PlSqlLexerNLS_CALENDAR = 1031 + PlSqlLexerNLS_CHARACTERSET = 1032 + PlSqlLexerNLS_CHARSET_DECL_LEN = 1033 + PlSqlLexerNLS_CHARSET_ID = 1034 + PlSqlLexerNLS_CHARSET_NAME = 1035 + PlSqlLexerNLS_COMP = 1036 + PlSqlLexerNLS_CURRENCY = 1037 + PlSqlLexerNLS_DATE_FORMAT = 1038 + PlSqlLexerNLS_DATE_LANGUAGE = 1039 + PlSqlLexerNLS_INITCAP = 1040 + PlSqlLexerNLS_ISO_CURRENCY = 1041 + PlSqlLexerNL_SJ = 1042 + PlSqlLexerNLS_LANG = 1043 + PlSqlLexerNLS_LANGUAGE = 1044 + PlSqlLexerNLS_LENGTH_SEMANTICS = 1045 + PlSqlLexerNLS_LOWER = 1046 + PlSqlLexerNLS_NCHAR_CONV_EXCP = 1047 + PlSqlLexerNLS_NUMERIC_CHARACTERS = 1048 + PlSqlLexerNLS_SORT = 1049 + PlSqlLexerNLSSORT = 1050 + PlSqlLexerNLS_SPECIAL_CHARS = 1051 + PlSqlLexerNLS_TERRITORY = 1052 + PlSqlLexerNLS_UPPER = 1053 + PlSqlLexerNO_ACCESS = 1054 + PlSqlLexerNO_ADAPTIVE_PLAN = 1055 + PlSqlLexerNO_ANSI_REARCH = 1056 + PlSqlLexerNOAPPEND = 1057 + PlSqlLexerNOARCHIVELOG = 1058 + PlSqlLexerNOAUDIT = 1059 + PlSqlLexerNOBADFILE = 1060 + PlSqlLexerNO_AUTO_REOPTIMIZE = 1061 + PlSqlLexerNO_BASETABLE_MULTIMV_REWRITE = 1062 + PlSqlLexerNO_BATCH_TABLE_ACCESS_BY_ROWID = 1063 + PlSqlLexerNO_BIND_AWARE = 1064 + PlSqlLexerNO_BUFFER = 1065 + PlSqlLexerNOCACHE = 1066 + PlSqlLexerNOCHECK = 1067 + PlSqlLexerNO_CARTESIAN = 1068 + PlSqlLexerNO_CHECK_ACL_REWRITE = 1069 + PlSqlLexerNO_CLUSTER_BY_ROWID = 1070 + PlSqlLexerNO_CLUSTERING = 1071 + PlSqlLexerNO_COALESCE_SQ = 1072 + PlSqlLexerNO_COMMON_DATA = 1073 + PlSqlLexerNOCOMPRESS = 1074 + PlSqlLexerNO_CONNECT_BY_CB_WHR_ONLY = 1075 + PlSqlLexerNO_CONNECT_BY_COMBINE_SW = 1076 + PlSqlLexerNO_CONNECT_BY_COST_BASED = 1077 + PlSqlLexerNO_CONNECT_BY_ELIM_DUPS = 1078 + PlSqlLexerNO_CONNECT_BY_FILTERING = 1079 + PlSqlLexerNOCOPY = 1080 + PlSqlLexerNO_COST_XML_QUERY_REWRITE = 1081 + PlSqlLexerNO_CPU_COSTING = 1082 + PlSqlLexerNOCPU_COSTING = 1083 + PlSqlLexerNOCYCLE = 1084 + PlSqlLexerNO_DATA_SECURITY_REWRITE = 1085 + PlSqlLexerNO_DECORRELATE = 1086 + PlSqlLexerNODELAY = 1087 + PlSqlLexerNODIRECTIO = 1088 + PlSqlLexerNODISCARDFILE = 1089 + PlSqlLexerNO_DOMAIN_INDEX_FILTER = 1090 + PlSqlLexerNO_DST_UPGRADE_INSERT_CONV = 1091 + PlSqlLexerNO_ELIM_GROUPBY = 1092 + PlSqlLexerNO_ELIMINATE_JOIN = 1093 + PlSqlLexerNO_ELIMINATE_OBY = 1094 + PlSqlLexerNO_ELIMINATE_OUTER_JOIN = 1095 + PlSqlLexerNOENTITYESCAPING = 1096 + PlSqlLexerNO_EXPAND_GSET_TO_UNION = 1097 + PlSqlLexerNO_EXPAND = 1098 + PlSqlLexerNO_EXPAND_TABLE = 1099 + PlSqlLexerNOEXTEND = 1100 + PlSqlLexerNO_FACT = 1101 + PlSqlLexerNO_FACTORIZE_JOIN = 1102 + PlSqlLexerNO_FILTERING = 1103 + PlSqlLexerNOFORCE = 1104 + PlSqlLexerNO_FULL_OUTER_JOIN_TO_OUTER = 1105 + PlSqlLexerNO_GATHER_OPTIMIZER_STATISTICS = 1106 + PlSqlLexerNO_GBY_PUSHDOWN = 1107 + PlSqlLexerNOGUARANTEE = 1108 + PlSqlLexerNO_INDEX_FFS = 1109 + PlSqlLexerNO_INDEX = 1110 + PlSqlLexerNO_INDEX_SS = 1111 + PlSqlLexerNO_INMEMORY = 1112 + PlSqlLexerNO_INMEMORY_PRUNING = 1113 + PlSqlLexerNOKEEP = 1114 + PlSqlLexerNO_LOAD = 1115 + PlSqlLexerNOLOCAL = 1116 + PlSqlLexerNOLOG = 1117 + PlSqlLexerNOLOGFILE = 1118 + PlSqlLexerNOLOGGING = 1119 + PlSqlLexerNOMAPPING = 1120 + PlSqlLexerNOMAXVALUE = 1121 + PlSqlLexerNO_MERGE = 1122 + PlSqlLexerNOMINIMIZE = 1123 + PlSqlLexerNOMINVALUE = 1124 + PlSqlLexerNO_MODEL_PUSH_REF = 1125 + PlSqlLexerNO_MONITORING = 1126 + PlSqlLexerNOMONITORING = 1127 + PlSqlLexerNO_MONITOR = 1128 + PlSqlLexerNO_MULTIMV_REWRITE = 1129 + PlSqlLexerNO_NATIVE_FULL_OUTER_JOIN = 1130 + PlSqlLexerNONBLOCKING = 1131 + PlSqlLexerNONEDITIONABLE = 1132 + PlSqlLexerNONE = 1133 + PlSqlLexerNONULLIF = 1134 + PlSqlLexerNO_NLJ_BATCHING = 1135 + PlSqlLexerNO_NLJ_PREFETCH = 1136 + PlSqlLexerNO = 1137 + PlSqlLexerNONSCHEMA = 1138 + PlSqlLexerNO_OBJECT_LINK = 1139 + PlSqlLexerNOORDER = 1140 + PlSqlLexerNO_ORDER_ROLLUPS = 1141 + PlSqlLexerNO_OUTER_JOIN_TO_ANTI = 1142 + PlSqlLexerNO_OUTER_JOIN_TO_INNER = 1143 + PlSqlLexerNOOVERRIDE = 1144 + PlSqlLexerNO_PARALLEL_INDEX = 1145 + PlSqlLexerNOPARALLEL_INDEX = 1146 + PlSqlLexerNO_PARALLEL = 1147 + PlSqlLexerNOPARALLEL = 1148 + PlSqlLexerNO_PARTIAL_COMMIT = 1149 + PlSqlLexerNO_PARTIAL_JOIN = 1150 + PlSqlLexerNO_PARTIAL_ROLLUP_PUSHDOWN = 1151 + PlSqlLexerNOPARTITION = 1152 + PlSqlLexerNO_PLACE_DISTINCT = 1153 + PlSqlLexerNO_PLACE_GROUP_BY = 1154 + PlSqlLexerNO_PQ_CONCURRENT_UNION = 1155 + PlSqlLexerNO_PQ_MAP = 1156 + PlSqlLexerNOPROMPT = 1157 + PlSqlLexerNO_PQ_REPLICATE = 1158 + PlSqlLexerNO_PQ_SKEW = 1159 + PlSqlLexerNO_PRUNE_GSETS = 1160 + PlSqlLexerNO_PULL_PRED = 1161 + PlSqlLexerNO_PUSH_PRED = 1162 + PlSqlLexerNO_PUSH_SUBQ = 1163 + PlSqlLexerNO_PX_FAULT_TOLERANCE = 1164 + PlSqlLexerNO_PX_JOIN_FILTER = 1165 + PlSqlLexerNO_QKN_BUFF = 1166 + PlSqlLexerNO_QUERY_TRANSFORMATION = 1167 + PlSqlLexerNO_REF_CASCADE = 1168 + PlSqlLexerNORELOCATE = 1169 + PlSqlLexerNORELY = 1170 + PlSqlLexerNOREPAIR = 1171 + PlSqlLexerNOREPLAY = 1172 + PlSqlLexerNORESETLOGS = 1173 + PlSqlLexerNO_RESULT_CACHE = 1174 + PlSqlLexerNOREVERSE = 1175 + PlSqlLexerNO_REWRITE = 1176 + PlSqlLexerNOREWRITE = 1177 + PlSqlLexerNORMAL = 1178 + PlSqlLexerNO_ROOT_SW_FOR_LOCAL = 1179 + PlSqlLexerNOROWDEPENDENCIES = 1180 + PlSqlLexerNOSCALE = 1181 + PlSqlLexerNOSCHEMACHECK = 1182 + PlSqlLexerNOSEGMENT = 1183 + PlSqlLexerNO_SEMIJOIN = 1184 + PlSqlLexerNO_SEMI_TO_INNER = 1185 + PlSqlLexerNO_SET_TO_JOIN = 1186 + PlSqlLexerNOSHARD = 1187 + PlSqlLexerNOSORT = 1188 + PlSqlLexerNO_SQL_TRANSLATION = 1189 + PlSqlLexerNO_SQL_TUNE = 1190 + PlSqlLexerNO_STAR_TRANSFORMATION = 1191 + PlSqlLexerNO_STATEMENT_QUEUING = 1192 + PlSqlLexerNO_STATS_GSETS = 1193 + PlSqlLexerNOSTRICT = 1194 + PlSqlLexerNO_SUBQUERY_PRUNING = 1195 + PlSqlLexerNO_SUBSTRB_PAD = 1196 + PlSqlLexerNO_SWAP_JOIN_INPUTS = 1197 + PlSqlLexerNOSWITCH = 1198 + PlSqlLexerNO_TABLE_LOOKUP_BY_NL = 1199 + PlSqlLexerNO_TEMP_TABLE = 1200 + PlSqlLexerNOTHING = 1201 + PlSqlLexerNOTIFICATION = 1202 + PlSqlLexerNOTRIM = 1203 + PlSqlLexerNOT = 1204 + PlSqlLexerNO_TRANSFORM_DISTINCT_AGG = 1205 + PlSqlLexerNO_UNNEST = 1206 + PlSqlLexerNO_USE_CUBE = 1207 + PlSqlLexerNO_USE_HASH_AGGREGATION = 1208 + PlSqlLexerNO_USE_HASH_GBY_FOR_PUSHDOWN = 1209 + PlSqlLexerNO_USE_HASH = 1210 + PlSqlLexerNO_USE_INVISIBLE_INDEXES = 1211 + PlSqlLexerNO_USE_MERGE = 1212 + PlSqlLexerNO_USE_NL = 1213 + PlSqlLexerNO_USE_VECTOR_AGGREGATION = 1214 + PlSqlLexerNOVALIDATE = 1215 + PlSqlLexerNO_VECTOR_TRANSFORM_DIMS = 1216 + PlSqlLexerNO_VECTOR_TRANSFORM_FACT = 1217 + PlSqlLexerNO_VECTOR_TRANSFORM = 1218 + PlSqlLexerNOWAIT = 1219 + PlSqlLexerNO_XDB_FASTPATH_INSERT = 1220 + PlSqlLexerNO_XML_DML_REWRITE = 1221 + PlSqlLexerNO_XMLINDEX_REWRITE_IN_SELECT = 1222 + PlSqlLexerNO_XMLINDEX_REWRITE = 1223 + PlSqlLexerNO_XML_QUERY_REWRITE = 1224 + PlSqlLexerNO_ZONEMAP = 1225 + PlSqlLexerNTH_VALUE = 1226 + PlSqlLexerNULLIF = 1227 + PlSqlLexerNULL_ = 1228 + PlSqlLexerNULLS = 1229 + PlSqlLexerNUMBER = 1230 + PlSqlLexerNUMERIC = 1231 + PlSqlLexerNUM_INDEX_KEYS = 1232 + PlSqlLexerNUMTODSINTERVAL = 1233 + PlSqlLexerNUMTOYMINTERVAL = 1234 + PlSqlLexerNVARCHAR2 = 1235 + PlSqlLexerNVL2 = 1236 + PlSqlLexerOBJECT2XML = 1237 + PlSqlLexerOBJECT = 1238 + PlSqlLexerOBJ_ID = 1239 + PlSqlLexerOBJNO = 1240 + PlSqlLexerOBJNO_REUSE = 1241 + PlSqlLexerOCCURENCES = 1242 + PlSqlLexerOFFLINE = 1243 + PlSqlLexerOFF = 1244 + PlSqlLexerOFFSET = 1245 + PlSqlLexerOF = 1246 + PlSqlLexerOIDINDEX = 1247 + PlSqlLexerOID = 1248 + PlSqlLexerOLAP = 1249 + PlSqlLexerOLD = 1250 + PlSqlLexerOLD_PUSH_PRED = 1251 + PlSqlLexerOLS = 1252 + PlSqlLexerOLTP = 1253 + PlSqlLexerOMIT = 1254 + PlSqlLexerONE = 1255 + PlSqlLexerONLINE = 1256 + PlSqlLexerONLINELOG = 1257 + PlSqlLexerONLY = 1258 + PlSqlLexerON = 1259 + PlSqlLexerOPAQUE = 1260 + PlSqlLexerOPAQUE_TRANSFORM = 1261 + PlSqlLexerOPAQUE_XCANONICAL = 1262 + PlSqlLexerOPCODE = 1263 + PlSqlLexerOPEN = 1264 + PlSqlLexerOPERATIONS = 1265 + PlSqlLexerOPERATOR = 1266 + PlSqlLexerOPT_ESTIMATE = 1267 + PlSqlLexerOPTIMAL = 1268 + PlSqlLexerOPTIMIZE = 1269 + PlSqlLexerOPTIMIZER_FEATURES_ENABLE = 1270 + PlSqlLexerOPTIMIZER_GOAL = 1271 + PlSqlLexerOPTION = 1272 + PlSqlLexerOPTIONALLY = 1273 + PlSqlLexerOPT_PARAM = 1274 + PlSqlLexerORA_BRANCH = 1275 + PlSqlLexerORA_CHECK_ACL = 1276 + PlSqlLexerORA_CHECK_PRIVILEGE = 1277 + PlSqlLexerORA_CLUSTERING = 1278 + PlSqlLexerORADATA = 1279 + PlSqlLexerORC = 1280 + PlSqlLexerORACLE_DATE = 1281 + PlSqlLexerORACLE_NUMBER = 1282 + PlSqlLexerORADEBUG = 1283 + PlSqlLexerORA_DST_AFFECTED = 1284 + PlSqlLexerORA_DST_CONVERT = 1285 + PlSqlLexerORA_DST_ERROR = 1286 + PlSqlLexerORA_GET_ACLIDS = 1287 + PlSqlLexerORA_GET_PRIVILEGES = 1288 + PlSqlLexerORA_HASH = 1289 + PlSqlLexerORA_INVOKING_USERID = 1290 + PlSqlLexerORA_INVOKING_USER = 1291 + PlSqlLexerORA_INVOKING_XS_USER_GUID = 1292 + PlSqlLexerORA_INVOKING_XS_USER = 1293 + PlSqlLexerORA_RAWCOMPARE = 1294 + PlSqlLexerORA_RAWCONCAT = 1295 + PlSqlLexerORA_ROWSCN = 1296 + PlSqlLexerORA_ROWSCN_RAW = 1297 + PlSqlLexerORA_ROWVERSION = 1298 + PlSqlLexerORA_TABVERSION = 1299 + PlSqlLexerORA_WRITE_TIME = 1300 + PlSqlLexerORDERED = 1301 + PlSqlLexerORDERED_PREDICATES = 1302 + PlSqlLexerORDER = 1303 + PlSqlLexerORDINALITY = 1304 + PlSqlLexerOR_EXPAND = 1305 + PlSqlLexerORGANIZATION = 1306 + PlSqlLexerOR = 1307 + PlSqlLexerOR_PREDICATES = 1308 + PlSqlLexerOSERROR = 1309 + PlSqlLexerOTHER = 1310 + PlSqlLexerOUTER_JOIN_TO_ANTI = 1311 + PlSqlLexerOUTER_JOIN_TO_INNER = 1312 + PlSqlLexerOUTER = 1313 + PlSqlLexerOUTLINE_LEAF = 1314 + PlSqlLexerOUTLINE = 1315 + PlSqlLexerOUTPUTFORMAT = 1316 + PlSqlLexerOUT_OF_LINE = 1317 + PlSqlLexerOUT = 1318 + PlSqlLexerOVERFLOW_NOMOVE = 1319 + PlSqlLexerOVERFLOW_ = 1320 + PlSqlLexerOVERLAPS = 1321 + PlSqlLexerOVER = 1322 + PlSqlLexerOVERRIDE = 1323 + PlSqlLexerOVERRIDING = 1324 + PlSqlLexerOWNER = 1325 + PlSqlLexerOWNERSHIP = 1326 + PlSqlLexerOWN = 1327 + PlSqlLexerP_LETTER = 1328 + PlSqlLexerPACKAGE = 1329 + PlSqlLexerPACKAGES = 1330 + PlSqlLexerPARALLEL_ENABLE = 1331 + PlSqlLexerPARALLEL_INDEX = 1332 + PlSqlLexerPARALLEL = 1333 + PlSqlLexerPARAMETERFILE = 1334 + PlSqlLexerPARAMETERS = 1335 + PlSqlLexerPARAM = 1336 + PlSqlLexerPARENT = 1337 + PlSqlLexerPARENT_LEVEL_NAME = 1338 + PlSqlLexerPARENT_UNIQUE_NAME = 1339 + PlSqlLexerPARITY = 1340 + PlSqlLexerPARQUET = 1341 + PlSqlLexerPARTIAL_JOIN = 1342 + PlSqlLexerPARTIALLY = 1343 + PlSqlLexerPARTIAL = 1344 + PlSqlLexerPARTIAL_ROLLUP_PUSHDOWN = 1345 + PlSqlLexerPARTITION_HASH = 1346 + PlSqlLexerPARTITION_LIST = 1347 + PlSqlLexerPARTITION = 1348 + PlSqlLexerPARTITION_RANGE = 1349 + PlSqlLexerPARTITIONS = 1350 + PlSqlLexerPARTNUMINST = 1351 + PlSqlLexerPASSING = 1352 + PlSqlLexerPASSWORD_GRACE_TIME = 1353 + PlSqlLexerPASSWORD_LIFE_TIME = 1354 + PlSqlLexerPASSWORD_LOCK_TIME = 1355 + PlSqlLexerPASSWORD = 1356 + PlSqlLexerPASSWORD_REUSE_MAX = 1357 + PlSqlLexerPASSWORD_REUSE_TIME = 1358 + PlSqlLexerPASSWORD_ROLLOVER_TIME = 1359 + PlSqlLexerPASSWORD_VERIFY_FUNCTION = 1360 + PlSqlLexerPAST = 1361 + PlSqlLexerPATCH = 1362 + PlSqlLexerPATH = 1363 + PlSqlLexerPATH_PREFIX = 1364 + PlSqlLexerPATHS = 1365 + PlSqlLexerPATTERN = 1366 + PlSqlLexerPBL_HS_BEGIN = 1367 + PlSqlLexerPBL_HS_END = 1368 + PlSqlLexerPCTFREE = 1369 + PlSqlLexerPCTINCREASE = 1370 + PlSqlLexerPCTTHRESHOLD = 1371 + PlSqlLexerPCTUSED = 1372 + PlSqlLexerPCTVERSION = 1373 + PlSqlLexerPENDING = 1374 + PlSqlLexerPERCENT_FOUND = 1375 + PlSqlLexerPERCENT_ISOPEN = 1376 + PlSqlLexerPERCENT_NOTFOUND = 1377 + PlSqlLexerPERCENT_KEYWORD = 1378 + PlSqlLexerPERCENT_RANKM = 1379 + PlSqlLexerPERCENT_ROWCOUNT = 1380 + PlSqlLexerPERCENT_ROWTYPE = 1381 + PlSqlLexerPERCENT_TYPE = 1382 + PlSqlLexerPERCENT_BULK_EXCEPTIONS = 1383 + PlSqlLexerPERCENT_BULK_ROWCOUNT = 1384 + PlSqlLexerPERFORMANCE = 1385 + PlSqlLexerPERIOD_KEYWORD = 1386 + PlSqlLexerPERMANENT = 1387 + PlSqlLexerPERMISSION = 1388 + PlSqlLexerPERMUTE = 1389 + PlSqlLexerPER = 1390 + PlSqlLexerPFILE = 1391 + PlSqlLexerPHYSICAL = 1392 + PlSqlLexerPIKEY = 1393 + PlSqlLexerPIPELINED = 1394 + PlSqlLexerPIPE = 1395 + PlSqlLexerPIV_GB = 1396 + PlSqlLexerPIVOT = 1397 + PlSqlLexerPIV_SSF = 1398 + PlSqlLexerPLACE_DISTINCT = 1399 + PlSqlLexerPLACE_GROUP_BY = 1400 + PlSqlLexerPLAN = 1401 + PlSqlLexerPLSCOPE_SETTINGS = 1402 + PlSqlLexerPLS_INTEGER = 1403 + PlSqlLexerPLSQL_CCFLAGS = 1404 + PlSqlLexerPLSQL_CODE_TYPE = 1405 + PlSqlLexerPLSQL_DEBUG = 1406 + PlSqlLexerPLSQL_OPTIMIZE_LEVEL = 1407 + PlSqlLexerPLSQL_WARNINGS = 1408 + PlSqlLexerPLUGGABLE = 1409 + PlSqlLexerPMEM = 1410 + PlSqlLexerPOINT = 1411 + PlSqlLexerPOLICY = 1412 + PlSqlLexerPOOL_16K = 1413 + PlSqlLexerPOOL_2K = 1414 + PlSqlLexerPOOL_32K = 1415 + PlSqlLexerPOOL_4K = 1416 + PlSqlLexerPOOL_8K = 1417 + PlSqlLexerPOSITION = 1418 + PlSqlLexerPOSITIVEN = 1419 + PlSqlLexerPOSITIVE = 1420 + PlSqlLexerPOST_TRANSACTION = 1421 + PlSqlLexerPOWERMULTISET_BY_CARDINALITY = 1422 + PlSqlLexerPOWERMULTISET = 1423 + PlSqlLexerPOWER = 1424 + PlSqlLexerPQ_CONCURRENT_UNION = 1425 + PlSqlLexerPQ_DISTRIBUTE = 1426 + PlSqlLexerPQ_DISTRIBUTE_WINDOW = 1427 + PlSqlLexerPQ_FILTER = 1428 + PlSqlLexerPQ_MAP = 1429 + PlSqlLexerPQ_NOMAP = 1430 + PlSqlLexerPQ_REPLICATE = 1431 + PlSqlLexerPQ_SKEW = 1432 + PlSqlLexerPRAGMA = 1433 + PlSqlLexerPREBUILT = 1434 + PlSqlLexerPRECEDES = 1435 + PlSqlLexerPRECEDING = 1436 + PlSqlLexerPRECISION = 1437 + PlSqlLexerPRECOMPUTE_SUBQUERY = 1438 + PlSqlLexerPREDICATE_REORDERS = 1439 + PlSqlLexerPRELOAD = 1440 + PlSqlLexerPREPARE = 1441 + PlSqlLexerPREPROCESSOR = 1442 + PlSqlLexerPRESENTNNV = 1443 + PlSqlLexerPRESENT = 1444 + PlSqlLexerPRESENTV = 1445 + PlSqlLexerPRESERVE_OID = 1446 + PlSqlLexerPRESERVE = 1447 + PlSqlLexerPRETTY = 1448 + PlSqlLexerPREVIOUS = 1449 + PlSqlLexerPREV = 1450 + PlSqlLexerPRIMARY = 1451 + PlSqlLexerPRINTBLOBTOCLOB = 1452 + PlSqlLexerPRIORITY = 1453 + PlSqlLexerPRIOR = 1454 + PlSqlLexerPRIVATE = 1455 + PlSqlLexerPRIVATE_SGA = 1456 + PlSqlLexerPRIVILEGED = 1457 + PlSqlLexerPRIVILEGE = 1458 + PlSqlLexerPRIVILEGES = 1459 + PlSqlLexerPROCEDURAL = 1460 + PlSqlLexerPROCEDURE = 1461 + PlSqlLexerPROCESS = 1462 + PlSqlLexerPROFILE = 1463 + PlSqlLexerPROGRAM = 1464 + PlSqlLexerPROJECT = 1465 + PlSqlLexerPROPAGATE = 1466 + PlSqlLexerPROPERTY = 1467 + PlSqlLexerPROTECTED = 1468 + PlSqlLexerPROTECTION = 1469 + PlSqlLexerPROTOCOL = 1470 + PlSqlLexerPROXY = 1471 + PlSqlLexerPRUNING = 1472 + PlSqlLexerPUBLIC = 1473 + PlSqlLexerPULL_PRED = 1474 + PlSqlLexerPURGE = 1475 + PlSqlLexerPUSH_PRED = 1476 + PlSqlLexerPUSH_SUBQ = 1477 + PlSqlLexerPX_FAULT_TOLERANCE = 1478 + PlSqlLexerPX_GRANULE = 1479 + PlSqlLexerPX_JOIN_FILTER = 1480 + PlSqlLexerQB_NAME = 1481 + PlSqlLexerQUARTERS = 1482 + PlSqlLexerQUERY_BLOCK = 1483 + PlSqlLexerQUERY = 1484 + PlSqlLexerQUEUE_CURR = 1485 + PlSqlLexerQUEUE = 1486 + PlSqlLexerQUEUE_ROWP = 1487 + PlSqlLexerQUIESCE = 1488 + PlSqlLexerQUORUM = 1489 + PlSqlLexerQUOTA = 1490 + PlSqlLexerQUOTAGROUP = 1491 + PlSqlLexerRAISE = 1492 + PlSqlLexerRANDOM_LOCAL = 1493 + PlSqlLexerRANDOM = 1494 + PlSqlLexerRANGE = 1495 + PlSqlLexerRANKM = 1496 + PlSqlLexerRAPIDLY = 1497 + PlSqlLexerRAW = 1498 + PlSqlLexerRAWTOHEX = 1499 + PlSqlLexerRAWTONHEX = 1500 + PlSqlLexerRBA = 1501 + PlSqlLexerRBO_OUTLINE = 1502 + PlSqlLexerRCFILE = 1503 + PlSqlLexerRDBA = 1504 + PlSqlLexerREAD = 1505 + PlSqlLexerREADS = 1506 + PlSqlLexerREADSIZE = 1507 + PlSqlLexerREALM = 1508 + PlSqlLexerREAL = 1509 + PlSqlLexerREBALANCE = 1510 + PlSqlLexerREBUILD = 1511 + PlSqlLexerRECORD = 1512 + PlSqlLexerRECORDS = 1513 + PlSqlLexerRECORDS_PER_BLOCK = 1514 + PlSqlLexerRECOVERABLE = 1515 + PlSqlLexerRECOVER = 1516 + PlSqlLexerRECOVERY = 1517 + PlSqlLexerRECYCLEBIN = 1518 + PlSqlLexerRECYCLE = 1519 + PlSqlLexerREDACTION = 1520 + PlSqlLexerREDEFINE = 1521 + PlSqlLexerREDO = 1522 + PlSqlLexerREDUCED = 1523 + PlSqlLexerREDUNDANCY = 1524 + PlSqlLexerREF_CASCADE_CURSOR = 1525 + PlSqlLexerREFERENCED = 1526 + PlSqlLexerREFERENCE = 1527 + PlSqlLexerREFERENCES = 1528 + PlSqlLexerREFERENCING = 1529 + PlSqlLexerREF = 1530 + PlSqlLexerREFRESH = 1531 + PlSqlLexerREFTOHEX = 1532 + PlSqlLexerREGEXP_COUNT = 1533 + PlSqlLexerREGEXP_INSTR = 1534 + PlSqlLexerREGEXP_LIKE = 1535 + PlSqlLexerREGEXP_REPLACE = 1536 + PlSqlLexerREGEXP_SUBSTR = 1537 + PlSqlLexerREGISTER = 1538 + PlSqlLexerREGR_AVGX = 1539 + PlSqlLexerREGR_AVGY = 1540 + PlSqlLexerREGR_COUNT = 1541 + PlSqlLexerREGR_INTERCEPT = 1542 + PlSqlLexerREGR_R2 = 1543 + PlSqlLexerREGR_SLOPE = 1544 + PlSqlLexerREGR_SXX = 1545 + PlSqlLexerREGR_SXY = 1546 + PlSqlLexerREGR_SYY = 1547 + PlSqlLexerREGULAR = 1548 + PlSqlLexerREJECT = 1549 + PlSqlLexerREKEY = 1550 + PlSqlLexerRELATIONAL = 1551 + PlSqlLexerRELIES_ON = 1552 + PlSqlLexerRELOCATE = 1553 + PlSqlLexerRELY = 1554 + PlSqlLexerREMAINDER = 1555 + PlSqlLexerREMOTE = 1556 + PlSqlLexerREMOTE_MAPPED = 1557 + PlSqlLexerREMOVE = 1558 + PlSqlLexerRENAME = 1559 + PlSqlLexerREPAIR = 1560 + PlSqlLexerREPEAT = 1561 + PlSqlLexerREPLACE = 1562 + PlSqlLexerREPLICATION = 1563 + PlSqlLexerREQUIRED = 1564 + PlSqlLexerRESETLOGS = 1565 + PlSqlLexerRESET = 1566 + PlSqlLexerRESIZE = 1567 + PlSqlLexerRESOLVE = 1568 + PlSqlLexerRESOLVER = 1569 + PlSqlLexerRESOURCE = 1570 + PlSqlLexerRESPECT = 1571 + PlSqlLexerRESTART = 1572 + PlSqlLexerRESTORE_AS_INTERVALS = 1573 + PlSqlLexerRESTORE = 1574 + PlSqlLexerRESTRICT_ALL_REF_CONS = 1575 + PlSqlLexerRESTRICTED = 1576 + PlSqlLexerRESTRICT_REFERENCES = 1577 + PlSqlLexerRESTRICT = 1578 + PlSqlLexerRESULT_CACHE = 1579 + PlSqlLexerRESULT = 1580 + PlSqlLexerRESUMABLE = 1581 + PlSqlLexerRESUME = 1582 + PlSqlLexerRETENTION = 1583 + PlSqlLexerRETRY_ON_ROW_CHANGE = 1584 + PlSqlLexerRETURNING = 1585 + PlSqlLexerRETURN = 1586 + PlSqlLexerREUSE = 1587 + PlSqlLexerREVERSE = 1588 + PlSqlLexerREVOKE = 1589 + PlSqlLexerREWRITE_OR_ERROR = 1590 + PlSqlLexerREWRITE = 1591 + PlSqlLexerRIGHT = 1592 + PlSqlLexerROLE = 1593 + PlSqlLexerROLESET = 1594 + PlSqlLexerROLES = 1595 + PlSqlLexerROLLBACK = 1596 + PlSqlLexerROLLING = 1597 + PlSqlLexerROLLUP = 1598 + PlSqlLexerROWDEPENDENCIES = 1599 + PlSqlLexerROWID_MAPPING_TABLE = 1600 + PlSqlLexerROWID = 1601 + PlSqlLexerROWIDTOCHAR = 1602 + PlSqlLexerROWIDTONCHAR = 1603 + PlSqlLexerROW_LENGTH = 1604 + PlSqlLexerROWNUM = 1605 + PlSqlLexerROW = 1606 + PlSqlLexerROWS = 1607 + PlSqlLexerRPAD = 1608 + PlSqlLexerRTRIM = 1609 + PlSqlLexerRULE = 1610 + PlSqlLexerRULES = 1611 + PlSqlLexerRUNNING = 1612 + PlSqlLexerSALT = 1613 + PlSqlLexerSAMPLE = 1614 + PlSqlLexerSAVE_AS_INTERVALS = 1615 + PlSqlLexerSAVEPOINT = 1616 + PlSqlLexerSAVE = 1617 + PlSqlLexerSB4 = 1618 + PlSqlLexerSCALE_ROWS = 1619 + PlSqlLexerSCALE = 1620 + PlSqlLexerSCAN_INSTANCES = 1621 + PlSqlLexerSCAN = 1622 + PlSqlLexerSCHEDULER = 1623 + PlSqlLexerSCHEMACHECK = 1624 + PlSqlLexerSCHEMA = 1625 + PlSqlLexerSCN_ASCENDING = 1626 + PlSqlLexerSCN = 1627 + PlSqlLexerSCOPE = 1628 + PlSqlLexerSCRUB = 1629 + PlSqlLexerSD_ALL = 1630 + PlSqlLexerSD_INHIBIT = 1631 + PlSqlLexerSDO_GEOM_MBR = 1632 + PlSqlLexerSDO_GEOMETRY = 1633 + PlSqlLexerSD_SHOW = 1634 + PlSqlLexerSEARCH = 1635 + PlSqlLexerSECOND = 1636 + PlSqlLexerSECONDS = 1637 + PlSqlLexerSECRET = 1638 + PlSqlLexerSECUREFILE_DBA = 1639 + PlSqlLexerSECUREFILE = 1640 + PlSqlLexerSECURITY = 1641 + PlSqlLexerSEED = 1642 + PlSqlLexerSEG_BLOCK = 1643 + PlSqlLexerSEG_FILE = 1644 + PlSqlLexerSEGMENT = 1645 + PlSqlLexerSELECTIVITY = 1646 + PlSqlLexerSELECT = 1647 + PlSqlLexerSELF = 1648 + PlSqlLexerSEMIJOIN_DRIVER = 1649 + PlSqlLexerSEMIJOIN = 1650 + PlSqlLexerSEMI_TO_INNER = 1651 + PlSqlLexerSEQUENCED = 1652 + PlSqlLexerSEQUENCE = 1653 + PlSqlLexerSEQUENCEFILE = 1654 + PlSqlLexerSEQUENTIAL = 1655 + PlSqlLexerSEQ = 1656 + PlSqlLexerSERDE = 1657 + PlSqlLexerSERDEPROPERTIES = 1658 + PlSqlLexerSERIALIZABLE = 1659 + PlSqlLexerSERIALLY_REUSABLE = 1660 + PlSqlLexerSERIAL = 1661 + PlSqlLexerSERVERERROR = 1662 + PlSqlLexerSERVICE_NAME_CONVERT = 1663 + PlSqlLexerSERVICE = 1664 + PlSqlLexerSERVICES = 1665 + PlSqlLexerSESSION_CACHED_CURSORS = 1666 + PlSqlLexerSESSION = 1667 + PlSqlLexerSESSIONS_PER_USER = 1668 + PlSqlLexerSESSIONTIMEZONE = 1669 + PlSqlLexerSESSIONTZNAME = 1670 + PlSqlLexerSET = 1671 + PlSqlLexerSETS = 1672 + PlSqlLexerSETTINGS = 1673 + PlSqlLexerSET_TO_JOIN = 1674 + PlSqlLexerSEVERE = 1675 + PlSqlLexerSHARD = 1676 + PlSqlLexerSHARDSPACE = 1677 + PlSqlLexerSHARED_POOL = 1678 + PlSqlLexerSHARED = 1679 + PlSqlLexerSHARE = 1680 + PlSqlLexerSHARING = 1681 + PlSqlLexerSHELFLIFE = 1682 + PlSqlLexerSHOW = 1683 + PlSqlLexerSHRINK = 1684 + PlSqlLexerSHUTDOWN = 1685 + PlSqlLexerSIBLINGS = 1686 + PlSqlLexerSID = 1687 + PlSqlLexerSITE = 1688 + PlSqlLexerSIGNAL_COMPONENT = 1689 + PlSqlLexerSIGNAL_FUNCTION = 1690 + PlSqlLexerSIGN = 1691 + PlSqlLexerSIGNTYPE = 1692 + PlSqlLexerSIMPLE_INTEGER = 1693 + PlSqlLexerSIMPLE = 1694 + PlSqlLexerSINGLE = 1695 + PlSqlLexerSINGLETASK = 1696 + PlSqlLexerSINH = 1697 + PlSqlLexerSIN = 1698 + PlSqlLexerSIZE = 1699 + PlSqlLexerSIZES = 1700 + PlSqlLexerSKIP_EXT_OPTIMIZER = 1701 + PlSqlLexerSKIP_ = 1702 + PlSqlLexerSKIP_UNQ_UNUSABLE_IDX = 1703 + PlSqlLexerSKIP_UNUSABLE_INDEXES = 1704 + PlSqlLexerSMALLFILE = 1705 + PlSqlLexerSMALLINT = 1706 + PlSqlLexerSNAPSHOT = 1707 + PlSqlLexerSOME = 1708 + PlSqlLexerSORT = 1709 + PlSqlLexerSOUNDEX = 1710 + PlSqlLexerSOURCE_FILE_DIRECTORY = 1711 + PlSqlLexerSOURCE_FILE_NAME_CONVERT = 1712 + PlSqlLexerSOURCE = 1713 + PlSqlLexerSPACE_KEYWORD = 1714 + PlSqlLexerSPECIFICATION = 1715 + PlSqlLexerSPFILE = 1716 + PlSqlLexerSPLIT = 1717 + PlSqlLexerSPREADSHEET = 1718 + PlSqlLexerSQLDATA = 1719 + PlSqlLexerSQLERROR = 1720 + PlSqlLexerSQLLDR = 1721 + PlSqlLexerSQL = 1722 + PlSqlLexerFILE_EXT = 1723 + PlSqlLexerSQL_MACRO = 1724 + PlSqlLexerSQL_TRACE = 1725 + PlSqlLexerSQL_TRANSLATION_PROFILE = 1726 + PlSqlLexerSQRT = 1727 + PlSqlLexerSTALE = 1728 + PlSqlLexerSTANDALONE = 1729 + PlSqlLexerSTANDARD = 1730 + PlSqlLexerSTANDARD_HASH = 1731 + PlSqlLexerSTANDBY_MAX_DATA_DELAY = 1732 + PlSqlLexerSTANDBYS = 1733 + PlSqlLexerSTANDBY = 1734 + PlSqlLexerSTAR = 1735 + PlSqlLexerSTAR_TRANSFORMATION = 1736 + PlSqlLexerSTART = 1737 + PlSqlLexerSTARTOF = 1738 + PlSqlLexerSTARTUP = 1739 + PlSqlLexerSTATEMENT_ID = 1740 + PlSqlLexerSTATEMENT_QUEUING = 1741 + PlSqlLexerSTATEMENTS = 1742 + PlSqlLexerSTATEMENT = 1743 + PlSqlLexerSTATE = 1744 + PlSqlLexerSTATIC = 1745 + PlSqlLexerSTATISTICS = 1746 + PlSqlLexerSTATS_BINOMIAL_TEST = 1747 + PlSqlLexerSTATS_CROSSTAB = 1748 + PlSqlLexerSTATS_F_TEST = 1749 + PlSqlLexerSTATS_KS_TEST = 1750 + PlSqlLexerSTATS_MODE = 1751 + PlSqlLexerSTATS_MW_TEST = 1752 + PlSqlLexerSTATS_ONE_WAY_ANOVA = 1753 + PlSqlLexerSTATS_T_TEST_INDEP = 1754 + PlSqlLexerSTATS_T_TEST_INDEPU = 1755 + PlSqlLexerSTATS_T_TEST_ONE = 1756 + PlSqlLexerSTATS_T_TEST_PAIRED = 1757 + PlSqlLexerSTATS_WSR_TEST = 1758 + PlSqlLexerSTDDEV_POP = 1759 + PlSqlLexerSTDDEV_SAMP = 1760 + PlSqlLexerSTOP = 1761 + PlSqlLexerSTORAGE = 1762 + PlSqlLexerSTORE = 1763 + PlSqlLexerSTREAMS = 1764 + PlSqlLexerSTREAM = 1765 + PlSqlLexerSTRICT = 1766 + PlSqlLexerSTRING = 1767 + PlSqlLexerSTRIPE_COLUMNS = 1768 + PlSqlLexerSTRIPE_WIDTH = 1769 + PlSqlLexerSTRIP = 1770 + PlSqlLexerSTRUCTURE = 1771 + PlSqlLexerSUBMULTISET = 1772 + PlSqlLexerSUBPARTITION_REL = 1773 + PlSqlLexerSUBPARTITIONS = 1774 + PlSqlLexerSUBPARTITION = 1775 + PlSqlLexerSUBQUERIES = 1776 + PlSqlLexerSUBQUERY_PRUNING = 1777 + PlSqlLexerSUBSCRIBE = 1778 + PlSqlLexerSUBSET = 1779 + PlSqlLexerSUBSTITUTABLE = 1780 + PlSqlLexerSUBSTR2 = 1781 + PlSqlLexerSUBSTR4 = 1782 + PlSqlLexerSUBSTRB = 1783 + PlSqlLexerSUBSTRC = 1784 + PlSqlLexerSUBTYPE = 1785 + PlSqlLexerSUCCESSFUL = 1786 + PlSqlLexerSUCCESS = 1787 + PlSqlLexerSUMMARY = 1788 + PlSqlLexerSUPPLEMENTAL = 1789 + PlSqlLexerSUSPEND = 1790 + PlSqlLexerSWAP_JOIN_INPUTS = 1791 + PlSqlLexerSWITCHOVER = 1792 + PlSqlLexerSWITCH = 1793 + PlSqlLexerSYNCHRONOUS = 1794 + PlSqlLexerSYNC = 1795 + PlSqlLexerSYNONYM = 1796 + PlSqlLexerSYS = 1797 + PlSqlLexerSYSASM = 1798 + PlSqlLexerSYS_AUDIT = 1799 + PlSqlLexerSYSAUX = 1800 + PlSqlLexerSYSBACKUP = 1801 + PlSqlLexerSYS_CHECKACL = 1802 + PlSqlLexerSYS_CHECK_PRIVILEGE = 1803 + PlSqlLexerSYS_CONNECT_BY_PATH = 1804 + PlSqlLexerSYS_CONTEXT = 1805 + PlSqlLexerSYSDATE = 1806 + PlSqlLexerSYSDBA = 1807 + PlSqlLexerSYS_DBURIGEN = 1808 + PlSqlLexerSYSDG = 1809 + PlSqlLexerSYS_DL_CURSOR = 1810 + PlSqlLexerSYS_DM_RXFORM_CHR = 1811 + PlSqlLexerSYS_DM_RXFORM_NUM = 1812 + PlSqlLexerSYS_DOM_COMPARE = 1813 + PlSqlLexerSYS_DST_PRIM2SEC = 1814 + PlSqlLexerSYS_DST_SEC2PRIM = 1815 + PlSqlLexerSYS_ET_BFILE_TO_RAW = 1816 + PlSqlLexerSYS_ET_BLOB_TO_IMAGE = 1817 + PlSqlLexerSYS_ET_IMAGE_TO_BLOB = 1818 + PlSqlLexerSYS_ET_RAW_TO_BFILE = 1819 + PlSqlLexerSYS_EXTPDTXT = 1820 + PlSqlLexerSYS_EXTRACT_UTC = 1821 + PlSqlLexerSYS_FBT_INSDEL = 1822 + PlSqlLexerSYS_FILTER_ACLS = 1823 + PlSqlLexerSYS_FNMATCHES = 1824 + PlSqlLexerSYS_FNREPLACE = 1825 + PlSqlLexerSYS_GET_ACLIDS = 1826 + PlSqlLexerSYS_GET_COL_ACLIDS = 1827 + PlSqlLexerSYS_GET_PRIVILEGES = 1828 + PlSqlLexerSYS_GETTOKENID = 1829 + PlSqlLexerSYS_GETXTIVAL = 1830 + PlSqlLexerSYS_GUID = 1831 + PlSqlLexerSYSGUID = 1832 + PlSqlLexerSYSKM = 1833 + PlSqlLexerSYS_MAKE_XMLNODEID = 1834 + PlSqlLexerSYS_MAKEXML = 1835 + PlSqlLexerSYS_MKXMLATTR = 1836 + PlSqlLexerSYS_MKXTI = 1837 + PlSqlLexerSYSOBJ = 1838 + PlSqlLexerSYS_OP_ADT2BIN = 1839 + PlSqlLexerSYS_OP_ADTCONS = 1840 + PlSqlLexerSYS_OP_ALSCRVAL = 1841 + PlSqlLexerSYS_OP_ATG = 1842 + PlSqlLexerSYS_OP_BIN2ADT = 1843 + PlSqlLexerSYS_OP_BITVEC = 1844 + PlSqlLexerSYS_OP_BL2R = 1845 + PlSqlLexerSYS_OP_BLOOM_FILTER_LIST = 1846 + PlSqlLexerSYS_OP_BLOOM_FILTER = 1847 + PlSqlLexerSYS_OP_C2C = 1848 + PlSqlLexerSYS_OP_CAST = 1849 + PlSqlLexerSYS_OP_CEG = 1850 + PlSqlLexerSYS_OP_CL2C = 1851 + PlSqlLexerSYS_OP_COMBINED_HASH = 1852 + PlSqlLexerSYS_OP_COMP = 1853 + PlSqlLexerSYS_OP_CONVERT = 1854 + PlSqlLexerSYS_OP_COUNTCHG = 1855 + PlSqlLexerSYS_OP_CSCONV = 1856 + PlSqlLexerSYS_OP_CSCONVTEST = 1857 + PlSqlLexerSYS_OP_CSR = 1858 + PlSqlLexerSYS_OP_CSX_PATCH = 1859 + PlSqlLexerSYS_OP_CYCLED_SEQ = 1860 + PlSqlLexerSYS_OP_DECOMP = 1861 + PlSqlLexerSYS_OP_DESCEND = 1862 + PlSqlLexerSYS_OP_DISTINCT = 1863 + PlSqlLexerSYS_OP_DRA = 1864 + PlSqlLexerSYS_OP_DUMP = 1865 + PlSqlLexerSYS_OP_DV_CHECK = 1866 + PlSqlLexerSYS_OP_ENFORCE_NOT_NULL = 1867 + PlSqlLexerSYSOPER = 1868 + PlSqlLexerSYS_OP_EXTRACT = 1869 + PlSqlLexerSYS_OP_GROUPING = 1870 + PlSqlLexerSYS_OP_GUID = 1871 + PlSqlLexerSYS_OP_HASH = 1872 + PlSqlLexerSYS_OP_IIX = 1873 + PlSqlLexerSYS_OP_ITR = 1874 + PlSqlLexerSYS_OP_KEY_VECTOR_CREATE = 1875 + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER_LIST = 1876 + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER = 1877 + PlSqlLexerSYS_OP_KEY_VECTOR_SUCCEEDED = 1878 + PlSqlLexerSYS_OP_KEY_VECTOR_USE = 1879 + PlSqlLexerSYS_OP_LBID = 1880 + PlSqlLexerSYS_OP_LOBLOC2BLOB = 1881 + PlSqlLexerSYS_OP_LOBLOC2CLOB = 1882 + PlSqlLexerSYS_OP_LOBLOC2ID = 1883 + PlSqlLexerSYS_OP_LOBLOC2NCLOB = 1884 + PlSqlLexerSYS_OP_LOBLOC2TYP = 1885 + PlSqlLexerSYS_OP_LSVI = 1886 + PlSqlLexerSYS_OP_LVL = 1887 + PlSqlLexerSYS_OP_MAKEOID = 1888 + PlSqlLexerSYS_OP_MAP_NONNULL = 1889 + PlSqlLexerSYS_OP_MSR = 1890 + PlSqlLexerSYS_OP_NICOMBINE = 1891 + PlSqlLexerSYS_OP_NIEXTRACT = 1892 + PlSqlLexerSYS_OP_NII = 1893 + PlSqlLexerSYS_OP_NIX = 1894 + PlSqlLexerSYS_OP_NOEXPAND = 1895 + PlSqlLexerSYS_OP_NTCIMG = 1896 + PlSqlLexerSYS_OP_NUMTORAW = 1897 + PlSqlLexerSYS_OP_OIDVALUE = 1898 + PlSqlLexerSYS_OP_OPNSIZE = 1899 + PlSqlLexerSYS_OP_PAR_1 = 1900 + PlSqlLexerSYS_OP_PARGID_1 = 1901 + PlSqlLexerSYS_OP_PARGID = 1902 + PlSqlLexerSYS_OP_PAR = 1903 + PlSqlLexerSYS_OP_PART_ID = 1904 + PlSqlLexerSYS_OP_PIVOT = 1905 + PlSqlLexerSYS_OP_R2O = 1906 + PlSqlLexerSYS_OP_RAWTONUM = 1907 + PlSqlLexerSYS_OP_RDTM = 1908 + PlSqlLexerSYS_OP_REF = 1909 + PlSqlLexerSYS_OP_RMTD = 1910 + PlSqlLexerSYS_OP_ROWIDTOOBJ = 1911 + PlSqlLexerSYS_OP_RPB = 1912 + PlSqlLexerSYS_OPTLOBPRBSC = 1913 + PlSqlLexerSYS_OP_TOSETID = 1914 + PlSqlLexerSYS_OP_TPR = 1915 + PlSqlLexerSYS_OP_TRTB = 1916 + PlSqlLexerSYS_OPTXICMP = 1917 + PlSqlLexerSYS_OPTXQCASTASNQ = 1918 + PlSqlLexerSYS_OP_UNDESCEND = 1919 + PlSqlLexerSYS_OP_VECAND = 1920 + PlSqlLexerSYS_OP_VECBIT = 1921 + PlSqlLexerSYS_OP_VECOR = 1922 + PlSqlLexerSYS_OP_VECXOR = 1923 + PlSqlLexerSYS_OP_VERSION = 1924 + PlSqlLexerSYS_OP_VREF = 1925 + PlSqlLexerSYS_OP_VVD = 1926 + PlSqlLexerSYS_OP_XMLCONS_FOR_CSX = 1927 + PlSqlLexerSYS_OP_XPTHATG = 1928 + PlSqlLexerSYS_OP_XPTHIDX = 1929 + PlSqlLexerSYS_OP_XPTHOP = 1930 + PlSqlLexerSYS_OP_XTXT2SQLT = 1931 + PlSqlLexerSYS_OP_ZONE_ID = 1932 + PlSqlLexerSYS_ORDERKEY_DEPTH = 1933 + PlSqlLexerSYS_ORDERKEY_MAXCHILD = 1934 + PlSqlLexerSYS_ORDERKEY_PARENT = 1935 + PlSqlLexerSYS_PARALLEL_TXN = 1936 + PlSqlLexerSYS_PATHID_IS_ATTR = 1937 + PlSqlLexerSYS_PATHID_IS_NMSPC = 1938 + PlSqlLexerSYS_PATHID_LASTNAME = 1939 + PlSqlLexerSYS_PATHID_LASTNMSPC = 1940 + PlSqlLexerSYS_PATH_REVERSE = 1941 + PlSqlLexerSYS_PXQEXTRACT = 1942 + PlSqlLexerSYS_RAW_TO_XSID = 1943 + PlSqlLexerSYS_RID_ORDER = 1944 + PlSqlLexerSYS_ROW_DELTA = 1945 + PlSqlLexerSYS_SC_2_XMLT = 1946 + PlSqlLexerSYS_SYNRCIREDO = 1947 + PlSqlLexerSYSTEM_DEFINED = 1948 + PlSqlLexerSYSTEM = 1949 + PlSqlLexerSYSTIMESTAMP = 1950 + PlSqlLexerSYS_TYPEID = 1951 + PlSqlLexerSYS_UMAKEXML = 1952 + PlSqlLexerSYS_XMLANALYZE = 1953 + PlSqlLexerSYS_XMLCONTAINS = 1954 + PlSqlLexerSYS_XMLCONV = 1955 + PlSqlLexerSYS_XMLEXNSURI = 1956 + PlSqlLexerSYS_XMLGEN = 1957 + PlSqlLexerSYS_XMLI_LOC_ISNODE = 1958 + PlSqlLexerSYS_XMLI_LOC_ISTEXT = 1959 + PlSqlLexerSYS_XMLINSTR = 1960 + PlSqlLexerSYS_XMLLOCATOR_GETSVAL = 1961 + PlSqlLexerSYS_XMLNODEID_GETCID = 1962 + PlSqlLexerSYS_XMLNODEID_GETLOCATOR = 1963 + PlSqlLexerSYS_XMLNODEID_GETOKEY = 1964 + PlSqlLexerSYS_XMLNODEID_GETPATHID = 1965 + PlSqlLexerSYS_XMLNODEID_GETPTRID = 1966 + PlSqlLexerSYS_XMLNODEID_GETRID = 1967 + PlSqlLexerSYS_XMLNODEID_GETSVAL = 1968 + PlSqlLexerSYS_XMLNODEID_GETTID = 1969 + PlSqlLexerSYS_XMLNODEID = 1970 + PlSqlLexerSYS_XMLT_2_SC = 1971 + PlSqlLexerSYS_XMLTRANSLATE = 1972 + PlSqlLexerSYS_XMLTYPE2SQL = 1973 + PlSqlLexerSYS_XQ_ASQLCNV = 1974 + PlSqlLexerSYS_XQ_ATOMCNVCHK = 1975 + PlSqlLexerSYS_XQBASEURI = 1976 + PlSqlLexerSYS_XQCASTABLEERRH = 1977 + PlSqlLexerSYS_XQCODEP2STR = 1978 + PlSqlLexerSYS_XQCODEPEQ = 1979 + PlSqlLexerSYS_XQCON2SEQ = 1980 + PlSqlLexerSYS_XQCONCAT = 1981 + PlSqlLexerSYS_XQDELETE = 1982 + PlSqlLexerSYS_XQDFLTCOLATION = 1983 + PlSqlLexerSYS_XQDOC = 1984 + PlSqlLexerSYS_XQDOCURI = 1985 + PlSqlLexerSYS_XQDURDIV = 1986 + PlSqlLexerSYS_XQED4URI = 1987 + PlSqlLexerSYS_XQENDSWITH = 1988 + PlSqlLexerSYS_XQERRH = 1989 + PlSqlLexerSYS_XQERR = 1990 + PlSqlLexerSYS_XQESHTMLURI = 1991 + PlSqlLexerSYS_XQEXLOBVAL = 1992 + PlSqlLexerSYS_XQEXSTWRP = 1993 + PlSqlLexerSYS_XQEXTRACT = 1994 + PlSqlLexerSYS_XQEXTRREF = 1995 + PlSqlLexerSYS_XQEXVAL = 1996 + PlSqlLexerSYS_XQFB2STR = 1997 + PlSqlLexerSYS_XQFNBOOL = 1998 + PlSqlLexerSYS_XQFNCMP = 1999 + PlSqlLexerSYS_XQFNDATIM = 2000 + PlSqlLexerSYS_XQFNLNAME = 2001 + PlSqlLexerSYS_XQFNNM = 2002 + PlSqlLexerSYS_XQFNNSURI = 2003 + PlSqlLexerSYS_XQFNPREDTRUTH = 2004 + PlSqlLexerSYS_XQFNQNM = 2005 + PlSqlLexerSYS_XQFNROOT = 2006 + PlSqlLexerSYS_XQFORMATNUM = 2007 + PlSqlLexerSYS_XQFTCONTAIN = 2008 + PlSqlLexerSYS_XQFUNCR = 2009 + PlSqlLexerSYS_XQGETCONTENT = 2010 + PlSqlLexerSYS_XQINDXOF = 2011 + PlSqlLexerSYS_XQINSERT = 2012 + PlSqlLexerSYS_XQINSPFX = 2013 + PlSqlLexerSYS_XQIRI2URI = 2014 + PlSqlLexerSYS_XQLANG = 2015 + PlSqlLexerSYS_XQLLNMFRMQNM = 2016 + PlSqlLexerSYS_XQMKNODEREF = 2017 + PlSqlLexerSYS_XQNILLED = 2018 + PlSqlLexerSYS_XQNODENAME = 2019 + PlSqlLexerSYS_XQNORMSPACE = 2020 + PlSqlLexerSYS_XQNORMUCODE = 2021 + PlSqlLexerSYS_XQ_NRNG = 2022 + PlSqlLexerSYS_XQNSP4PFX = 2023 + PlSqlLexerSYS_XQNSPFRMQNM = 2024 + PlSqlLexerSYS_XQPFXFRMQNM = 2025 + PlSqlLexerSYS_XQ_PKSQL2XML = 2026 + PlSqlLexerSYS_XQPOLYABS = 2027 + PlSqlLexerSYS_XQPOLYADD = 2028 + PlSqlLexerSYS_XQPOLYCEL = 2029 + PlSqlLexerSYS_XQPOLYCSTBL = 2030 + PlSqlLexerSYS_XQPOLYCST = 2031 + PlSqlLexerSYS_XQPOLYDIV = 2032 + PlSqlLexerSYS_XQPOLYFLR = 2033 + PlSqlLexerSYS_XQPOLYMOD = 2034 + PlSqlLexerSYS_XQPOLYMUL = 2035 + PlSqlLexerSYS_XQPOLYRND = 2036 + PlSqlLexerSYS_XQPOLYSQRT = 2037 + PlSqlLexerSYS_XQPOLYSUB = 2038 + PlSqlLexerSYS_XQPOLYUMUS = 2039 + PlSqlLexerSYS_XQPOLYUPLS = 2040 + PlSqlLexerSYS_XQPOLYVEQ = 2041 + PlSqlLexerSYS_XQPOLYVGE = 2042 + PlSqlLexerSYS_XQPOLYVGT = 2043 + PlSqlLexerSYS_XQPOLYVLE = 2044 + PlSqlLexerSYS_XQPOLYVLT = 2045 + PlSqlLexerSYS_XQPOLYVNE = 2046 + PlSqlLexerSYS_XQREF2VAL = 2047 + PlSqlLexerSYS_XQRENAME = 2048 + PlSqlLexerSYS_XQREPLACE = 2049 + PlSqlLexerSYS_XQRESVURI = 2050 + PlSqlLexerSYS_XQRNDHALF2EVN = 2051 + PlSqlLexerSYS_XQRSLVQNM = 2052 + PlSqlLexerSYS_XQRYENVPGET = 2053 + PlSqlLexerSYS_XQRYVARGET = 2054 + PlSqlLexerSYS_XQRYWRP = 2055 + PlSqlLexerSYS_XQSEQ2CON4XC = 2056 + PlSqlLexerSYS_XQSEQ2CON = 2057 + PlSqlLexerSYS_XQSEQDEEPEQ = 2058 + PlSqlLexerSYS_XQSEQINSB = 2059 + PlSqlLexerSYS_XQSEQRM = 2060 + PlSqlLexerSYS_XQSEQRVS = 2061 + PlSqlLexerSYS_XQSEQSUB = 2062 + PlSqlLexerSYS_XQSEQTYPMATCH = 2063 + PlSqlLexerSYS_XQSTARTSWITH = 2064 + PlSqlLexerSYS_XQSTATBURI = 2065 + PlSqlLexerSYS_XQSTR2CODEP = 2066 + PlSqlLexerSYS_XQSTRJOIN = 2067 + PlSqlLexerSYS_XQSUBSTRAFT = 2068 + PlSqlLexerSYS_XQSUBSTRBEF = 2069 + PlSqlLexerSYS_XQTOKENIZE = 2070 + PlSqlLexerSYS_XQTREATAS = 2071 + PlSqlLexerSYS_XQ_UPKXML2SQL = 2072 + PlSqlLexerSYS_XQXFORM = 2073 + PlSqlLexerSYS_XSID_TO_RAW = 2074 + PlSqlLexerSYS_ZMAP_FILTER = 2075 + PlSqlLexerSYS_ZMAP_REFRESH = 2076 + PlSqlLexerT_LETTER = 2077 + PlSqlLexerTABLE_LOOKUP_BY_NL = 2078 + PlSqlLexerTABLESPACE_NO = 2079 + PlSqlLexerTABLESPACE = 2080 + PlSqlLexerTABLES = 2081 + PlSqlLexerTABLE_STATS = 2082 + PlSqlLexerTABLE = 2083 + PlSqlLexerTABNO = 2084 + PlSqlLexerTAG = 2085 + PlSqlLexerTANH = 2086 + PlSqlLexerTAN = 2087 + PlSqlLexerTBLORIDXPARTNUM = 2088 + PlSqlLexerTEMPFILE = 2089 + PlSqlLexerTEMPLATE = 2090 + PlSqlLexerTEMPLATE_TABLE = 2091 + PlSqlLexerTEMPORARY = 2092 + PlSqlLexerTEMP_TABLE = 2093 + PlSqlLexerTERMINATED = 2094 + PlSqlLexerTEST = 2095 + PlSqlLexerTEXT = 2096 + PlSqlLexerTEXTFILE = 2097 + PlSqlLexerTHAN = 2098 + PlSqlLexerTHEN = 2099 + PlSqlLexerTHE = 2100 + PlSqlLexerTHESE = 2101 + PlSqlLexerTHREAD = 2102 + PlSqlLexerTHROUGH = 2103 + PlSqlLexerTIER = 2104 + PlSqlLexerTIES = 2105 + PlSqlLexerTIMEOUT = 2106 + PlSqlLexerTIMESTAMP_LTZ_UNCONSTRAINED = 2107 + PlSqlLexerTIMESTAMP = 2108 + PlSqlLexerTIMESTAMP_TZ_UNCONSTRAINED = 2109 + PlSqlLexerTIMESTAMP_UNCONSTRAINED = 2110 + PlSqlLexerTIMES = 2111 + PlSqlLexerTIME = 2112 + PlSqlLexerTIMEZONE = 2113 + PlSqlLexerTIMEZONE_ABBR = 2114 + PlSqlLexerTIMEZONE_HOUR = 2115 + PlSqlLexerTIMEZONE_MINUTE = 2116 + PlSqlLexerTIMEZONE_OFFSET = 2117 + PlSqlLexerTIMEZONE_REGION = 2118 + PlSqlLexerTIME_ZONE = 2119 + PlSqlLexerTIMING = 2120 + PlSqlLexerTINYINT = 2121 + PlSqlLexerTIV_GB = 2122 + PlSqlLexerTIV_SSF = 2123 + PlSqlLexerTO_ACLID = 2124 + PlSqlLexerTO_BINARY_DOUBLE = 2125 + PlSqlLexerTO_BINARY_FLOAT = 2126 + PlSqlLexerTO_BLOB = 2127 + PlSqlLexerTO_CLOB = 2128 + PlSqlLexerTO_DSINTERVAL = 2129 + PlSqlLexerTO_LOB = 2130 + PlSqlLexerTO_MULTI_BYTE = 2131 + PlSqlLexerTO_NCHAR = 2132 + PlSqlLexerTO_NCLOB = 2133 + PlSqlLexerTO_NUMBER = 2134 + PlSqlLexerTOPLEVEL = 2135 + PlSqlLexerTO_SINGLE_BYTE = 2136 + PlSqlLexerTO_TIMESTAMP = 2137 + PlSqlLexerTO_TIMESTAMP_TZ = 2138 + PlSqlLexerTO_TIME = 2139 + PlSqlLexerTO_TIME_TZ = 2140 + PlSqlLexerTO = 2141 + PlSqlLexerTO_YMINTERVAL = 2142 + PlSqlLexerTRACE = 2143 + PlSqlLexerTRACING = 2144 + PlSqlLexerTRACKING = 2145 + PlSqlLexerTRAILING = 2146 + PlSqlLexerTRANSACTION = 2147 + PlSqlLexerTRANSFORM = 2148 + PlSqlLexerTRANSFORMS = 2149 + PlSqlLexerTRANSFORM_DISTINCT_AGG = 2150 + PlSqlLexerTRANSITIONAL = 2151 + PlSqlLexerTRANSITION = 2152 + PlSqlLexerTRANSLATE = 2153 + PlSqlLexerTRANSLATION = 2154 + PlSqlLexerTREAT = 2155 + PlSqlLexerTRIGGERS = 2156 + PlSqlLexerTRIGGER = 2157 + PlSqlLexerTRUE = 2158 + PlSqlLexerTRUNCATE = 2159 + PlSqlLexerTRUNC = 2160 + PlSqlLexerTRUSTED = 2161 + PlSqlLexerTRUST = 2162 + PlSqlLexerTUNING = 2163 + PlSqlLexerTX = 2164 + PlSqlLexerTYPES = 2165 + PlSqlLexerTYPE = 2166 + PlSqlLexerTZ_OFFSET = 2167 + PlSqlLexerUB2 = 2168 + PlSqlLexerUBA = 2169 + PlSqlLexerUCS2 = 2170 + PlSqlLexerUDF = 2171 + PlSqlLexerUID = 2172 + PlSqlLexerUNARCHIVED = 2173 + PlSqlLexerUNBOUNDED = 2174 + PlSqlLexerUNBOUND = 2175 + PlSqlLexerUNCONDITIONAL = 2176 + PlSqlLexerUNDER = 2177 + PlSqlLexerUNDO = 2178 + PlSqlLexerUNDROP = 2179 + PlSqlLexerUNIFORM = 2180 + PlSqlLexerUNION = 2181 + PlSqlLexerUNIONTYPE = 2182 + PlSqlLexerUNIQUE = 2183 + PlSqlLexerUNISTR = 2184 + PlSqlLexerUNLIMITED = 2185 + PlSqlLexerUNLOAD = 2186 + PlSqlLexerUNLOCK = 2187 + PlSqlLexerUNMATCHED = 2188 + PlSqlLexerUNNEST_INNERJ_DISTINCT_VIEW = 2189 + PlSqlLexerUNNEST_NOSEMIJ_NODISTINCTVIEW = 2190 + PlSqlLexerUNNEST_SEMIJ_VIEW = 2191 + PlSqlLexerUNNEST = 2192 + PlSqlLexerUNPACKED = 2193 + PlSqlLexerUNPIVOT = 2194 + PlSqlLexerUNPLUG = 2195 + PlSqlLexerUNPROTECTED = 2196 + PlSqlLexerUNQUIESCE = 2197 + PlSqlLexerUNRECOVERABLE = 2198 + PlSqlLexerUNRESTRICTED = 2199 + PlSqlLexerUNSIGNED = 2200 + PlSqlLexerUNSUBSCRIBE = 2201 + PlSqlLexerUNTIL = 2202 + PlSqlLexerUNUSABLE = 2203 + PlSqlLexerUNUSED = 2204 + PlSqlLexerUPDATABLE = 2205 + PlSqlLexerUPDATED = 2206 + PlSqlLexerUPDATE = 2207 + PlSqlLexerUPDATEXML = 2208 + PlSqlLexerUPD_INDEXES = 2209 + PlSqlLexerUPD_JOININDEX = 2210 + PlSqlLexerUPGRADE = 2211 + PlSqlLexerUPPER = 2212 + PlSqlLexerUPSERT = 2213 + PlSqlLexerUROWID = 2214 + PlSqlLexerUSABLE = 2215 + PlSqlLexerUSAGE = 2216 + PlSqlLexerUSE_ANTI = 2217 + PlSqlLexerUSE_CONCAT = 2218 + PlSqlLexerUSE_CUBE = 2219 + PlSqlLexerUSE_HASH_AGGREGATION = 2220 + PlSqlLexerUSE_HASH_GBY_FOR_PUSHDOWN = 2221 + PlSqlLexerUSE_HASH = 2222 + PlSqlLexerUSE_HIDDEN_PARTITIONS = 2223 + PlSqlLexerUSE_INVISIBLE_INDEXES = 2224 + PlSqlLexerUSE_MERGE_CARTESIAN = 2225 + PlSqlLexerUSE_MERGE = 2226 + PlSqlLexerUSE_NL = 2227 + PlSqlLexerUSE_NL_WITH_INDEX = 2228 + PlSqlLexerUSE_PRIVATE_OUTLINES = 2229 + PlSqlLexerUSER_DATA = 2230 + PlSqlLexerUSER_DEFINED = 2231 + PlSqlLexerUSERENV = 2232 + PlSqlLexerUSERGROUP = 2233 + PlSqlLexerUSER_RECYCLEBIN = 2234 + PlSqlLexerUSERS = 2235 + PlSqlLexerUSER_TABLESPACES = 2236 + PlSqlLexerUSER = 2237 + PlSqlLexerUSE_SEMI = 2238 + PlSqlLexerUSE_STORED_OUTLINES = 2239 + PlSqlLexerUSE_TTT_FOR_GSETS = 2240 + PlSqlLexerUSE = 2241 + PlSqlLexerUSE_VECTOR_AGGREGATION = 2242 + PlSqlLexerUSE_WEAK_NAME_RESL = 2243 + PlSqlLexerUSING_NO_EXPAND = 2244 + PlSqlLexerUSING_NLS_COMP = 2245 + PlSqlLexerUSING = 2246 + PlSqlLexerUTF16BE = 2247 + PlSqlLexerUTF16LE = 2248 + PlSqlLexerUTF32 = 2249 + PlSqlLexerUTF8 = 2250 + PlSqlLexerV1 = 2251 + PlSqlLexerV2 = 2252 + PlSqlLexerVALIDATE = 2253 + PlSqlLexerVALIDATE_CONVERSION = 2254 + PlSqlLexerVALIDATION = 2255 + PlSqlLexerVALID_TIME_END = 2256 + PlSqlLexerVALUES = 2257 + PlSqlLexerVALUE = 2258 + PlSqlLexerVARCHAR2 = 2259 + PlSqlLexerVARCHAR = 2260 + PlSqlLexerVARCHARC = 2261 + PlSqlLexerVARIABLE = 2262 + PlSqlLexerVARRAW = 2263 + PlSqlLexerVARRAWC = 2264 + PlSqlLexerVAR_POP = 2265 + PlSqlLexerVARRAYS = 2266 + PlSqlLexerVARRAY = 2267 + PlSqlLexerVAR_SAMP = 2268 + PlSqlLexerVARYING = 2269 + PlSqlLexerVECTOR_READ_TRACE = 2270 + PlSqlLexerVECTOR_READ = 2271 + PlSqlLexerVECTOR_TRANSFORM_DIMS = 2272 + PlSqlLexerVECTOR_TRANSFORM_FACT = 2273 + PlSqlLexerVECTOR_TRANSFORM = 2274 + PlSqlLexerVERIFIER = 2275 + PlSqlLexerVERIFY = 2276 + PlSqlLexerVERSIONING = 2277 + PlSqlLexerVERSIONS_ENDSCN = 2278 + PlSqlLexerVERSIONS_ENDTIME = 2279 + PlSqlLexerVERSIONS_OPERATION = 2280 + PlSqlLexerVERSIONS_STARTSCN = 2281 + PlSqlLexerVERSIONS_STARTTIME = 2282 + PlSqlLexerVERSIONS = 2283 + PlSqlLexerVERSIONS_XID = 2284 + PlSqlLexerVERSION = 2285 + PlSqlLexerVIEW = 2286 + PlSqlLexerVIOLATION = 2287 + PlSqlLexerVIRTUAL = 2288 + PlSqlLexerVISIBILITY = 2289 + PlSqlLexerVISIBLE = 2290 + PlSqlLexerVOLUME = 2291 + PlSqlLexerVSIZE = 2292 + PlSqlLexerWAIT = 2293 + PlSqlLexerWALLET = 2294 + PlSqlLexerWARNING = 2295 + PlSqlLexerWEEKS = 2296 + PlSqlLexerWEEK = 2297 + PlSqlLexerWELLFORMED = 2298 + PlSqlLexerWHENEVER = 2299 + PlSqlLexerWHEN = 2300 + PlSqlLexerWHERE = 2301 + PlSqlLexerWHILE = 2302 + PlSqlLexerWHITESPACE = 2303 + PlSqlLexerWIDTH_BUCKET = 2304 + PlSqlLexerWITHIN = 2305 + PlSqlLexerWITHOUT = 2306 + PlSqlLexerWITH_PLSQL = 2307 + PlSqlLexerWITH = 2308 + PlSqlLexerWORK = 2309 + PlSqlLexerWORKERID = 2310 + PlSqlLexerWRAPPED = 2311 + PlSqlLexerWRAPPER = 2312 + PlSqlLexerWRITE = 2313 + PlSqlLexerXDB_FASTPATH_INSERT = 2314 + PlSqlLexerXDB = 2315 + PlSqlLexerX_DYN_PRUNE = 2316 + PlSqlLexerXID = 2317 + PlSqlLexerXML2OBJECT = 2318 + PlSqlLexerXMLAGG = 2319 + PlSqlLexerXMLATTRIBUTES = 2320 + PlSqlLexerXMLCAST = 2321 + PlSqlLexerXMLCDATA = 2322 + PlSqlLexerXMLCOLATTVAL = 2323 + PlSqlLexerXMLCOMMENT = 2324 + PlSqlLexerXMLCONCAT = 2325 + PlSqlLexerXMLDIFF = 2326 + PlSqlLexerXML_DML_RWT_STMT = 2327 + PlSqlLexerXMLELEMENT = 2328 + PlSqlLexerXMLEXISTS2 = 2329 + PlSqlLexerXMLEXISTS = 2330 + PlSqlLexerXMLFOREST = 2331 + PlSqlLexerXMLINDEX = 2332 + PlSqlLexerXMLINDEX_REWRITE_IN_SELECT = 2333 + PlSqlLexerXMLINDEX_REWRITE = 2334 + PlSqlLexerXMLINDEX_SEL_IDX_TBL = 2335 + PlSqlLexerXMLISNODE = 2336 + PlSqlLexerXMLISVALID = 2337 + PlSqlLexerXMLNAMESPACES = 2338 + PlSqlLexerXMLPARSE = 2339 + PlSqlLexerXMLPATCH = 2340 + PlSqlLexerXMLPI = 2341 + PlSqlLexerXMLQUERYVAL = 2342 + PlSqlLexerXMLQUERY = 2343 + PlSqlLexerXMLROOT = 2344 + PlSqlLexerXMLSCHEMA = 2345 + PlSqlLexerXMLSERIALIZE = 2346 + PlSqlLexerXMLTABLE = 2347 + PlSqlLexerXMLTAG = 2348 + PlSqlLexerXMLTRANSFORMBLOB = 2349 + PlSqlLexerXMLTRANSFORM = 2350 + PlSqlLexerXMLTYPE = 2351 + PlSqlLexerXML = 2352 + PlSqlLexerXPATHTABLE = 2353 + PlSqlLexerXS_SYS_CONTEXT = 2354 + PlSqlLexerXS = 2355 + PlSqlLexerXTRANSPORT = 2356 + PlSqlLexerYEARS = 2357 + PlSqlLexerYEAR = 2358 + PlSqlLexerYEAR_TO_MONTH = 2359 + PlSqlLexerYES = 2360 + PlSqlLexerYMINTERVAL_UNCONSTRAINED = 2361 + PlSqlLexerZONEMAP = 2362 + PlSqlLexerZONE = 2363 + PlSqlLexerZONED = 2364 + PlSqlLexerPREDICTION = 2365 + PlSqlLexerPREDICTION_BOUNDS = 2366 + PlSqlLexerPREDICTION_COST = 2367 + PlSqlLexerPREDICTION_DETAILS = 2368 + PlSqlLexerPREDICTION_PROBABILITY = 2369 + PlSqlLexerPREDICTION_SET = 2370 + PlSqlLexerBLOCKCHAIN = 2371 + PlSqlLexerCOLLATE = 2372 + PlSqlLexerCOLLATION = 2373 + PlSqlLexerDEFINITION = 2374 + PlSqlLexerDUPLICATED = 2375 + PlSqlLexerEXTENDED = 2376 + PlSqlLexerHASHING = 2377 + PlSqlLexerIDLE = 2378 + PlSqlLexerIMMUTABLE = 2379 + PlSqlLexerORACLE_DATAPUMP = 2380 + PlSqlLexerORACLE_HDFS = 2381 + PlSqlLexerORACLE_HIVE = 2382 + PlSqlLexerORACLE_LOADER = 2383 + PlSqlLexerSHA2_512_Q = 2384 + PlSqlLexerSHARDED = 2385 + PlSqlLexerV1_Q = 2386 + PlSqlLexerISOLATE = 2387 + PlSqlLexerROOT = 2388 + PlSqlLexerUNITE = 2389 + PlSqlLexerALGORITHM = 2390 + PlSqlLexerCUME_DIST = 2391 + PlSqlLexerDENSE_RANK = 2392 + PlSqlLexerLISTAGG = 2393 + PlSqlLexerPERCENT_RANK = 2394 + PlSqlLexerPERCENTILE_CONT = 2395 + PlSqlLexerPERCENTILE_DISC = 2396 + PlSqlLexerRANK = 2397 + PlSqlLexerAVG = 2398 + PlSqlLexerCORR = 2399 + PlSqlLexerCOVAR_ = 2400 + PlSqlLexerDECODE = 2401 + PlSqlLexerLAG = 2402 + PlSqlLexerLAG_DIFF = 2403 + PlSqlLexerLAG_DIFF_PERCENT = 2404 + PlSqlLexerLEAD = 2405 + PlSqlLexerMAX = 2406 + PlSqlLexerMEDIAN = 2407 + PlSqlLexerMEMOPTIMIZE = 2408 + PlSqlLexerMIN = 2409 + PlSqlLexerNTILE = 2410 + PlSqlLexerNVL = 2411 + PlSqlLexerRATIO_TO_REPORT = 2412 + PlSqlLexerREGR_ = 2413 + PlSqlLexerROUND = 2414 + PlSqlLexerROW_NUMBER = 2415 + PlSqlLexerSUBSTR = 2416 + PlSqlLexerTO_CHAR = 2417 + PlSqlLexerTRIM = 2418 + PlSqlLexerSUM = 2419 + PlSqlLexerSTDDEV = 2420 + PlSqlLexerVAR_ = 2421 + PlSqlLexerVARIANCE = 2422 + PlSqlLexerLEAST = 2423 + PlSqlLexerGREATEST = 2424 + PlSqlLexerTO_DATE = 2425 + PlSqlLexerCHARSETID = 2426 + PlSqlLexerCHARSETFORM = 2427 + PlSqlLexerDURATION = 2428 + PlSqlLexerEXTEND = 2429 + PlSqlLexerMAXLEN = 2430 + PlSqlLexerPERSISTABLE = 2431 + PlSqlLexerPOLYMORPHIC = 2432 + PlSqlLexerSTRUCT = 2433 + PlSqlLexerTDO = 2434 + PlSqlLexerWM_CONCAT = 2435 + PlSqlLexerNATIONAL_CHAR_STRING_LIT = 2436 + PlSqlLexerBIT_STRING_LIT = 2437 + PlSqlLexerHEX_STRING_LIT = 2438 + PlSqlLexerDOUBLE_PERIOD = 2439 + PlSqlLexerPERIOD = 2440 + PlSqlLexerUNSIGNED_INTEGER = 2441 + PlSqlLexerAPPROXIMATE_NUM_LIT = 2442 + PlSqlLexerCHAR_STRING = 2443 + PlSqlLexerDELIMITED_ID = 2444 + PlSqlLexerPERCENT = 2445 + PlSqlLexerAMPERSAND = 2446 + PlSqlLexerLEFT_PAREN = 2447 + PlSqlLexerRIGHT_PAREN = 2448 + PlSqlLexerDOUBLE_ASTERISK = 2449 + PlSqlLexerASTERISK = 2450 + PlSqlLexerPLUS_SIGN = 2451 + PlSqlLexerMINUS_SIGN = 2452 + PlSqlLexerCOMMA = 2453 + PlSqlLexerSOLIDUS = 2454 + PlSqlLexerRSOLIDUS = 2455 + PlSqlLexerAT_SIGN = 2456 + PlSqlLexerASSIGN_OP = 2457 + PlSqlLexerHASH_OP = 2458 + PlSqlLexerLEFT_CURLY_PAREN = 2459 + PlSqlLexerRIGHT_CURLY_PAREN = 2460 + PlSqlLexerSQ = 2461 + PlSqlLexerBINDVAR = 2462 + PlSqlLexerNOT_EQUAL_OP = 2463 + PlSqlLexerCARRET_OPERATOR_PART = 2464 + PlSqlLexerTILDE_OPERATOR_PART = 2465 + PlSqlLexerEXCLAMATION_OPERATOR_PART = 2466 + PlSqlLexerGREATER_THAN_OP = 2467 + PlSqlLexerLESS_THAN_OP = 2468 + PlSqlLexerCOLON = 2469 + PlSqlLexerSEMICOLON = 2470 + PlSqlLexerBAR = 2471 + PlSqlLexerEQUALS_OP = 2472 + PlSqlLexerLEFT_BRACKET = 2473 + PlSqlLexerRIGHT_BRACKET = 2474 + PlSqlLexerINTRODUCER = 2475 + PlSqlLexerSINGLE_LINE_COMMENT = 2476 + PlSqlLexerMULTI_LINE_COMMENT = 2477 + PlSqlLexerREMARK_COMMENT = 2478 + PlSqlLexerPROMPT_MESSAGE = 2479 + PlSqlLexerREGULAR_ID = 2480 + PlSqlLexerINQUIRY_DIRECTIVE = 2481 + PlSqlLexerSPACES = 2482 +) + +func (l *PlSqlLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 2489: + return l.REMARK_COMMENT_Sempred(localctx, predIndex) + + case 2490: + return l.PROMPT_MESSAGE_Sempred(localctx, predIndex) + + default: + panic("No registered predicate for: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *PlSqlLexer) REMARK_COMMENT_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.IsNewlineAtPos(-4) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlLexer) PROMPT_MESSAGE_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.IsNewlineAtPos(-4) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/internal/engine/oracle/parser/plsql_lexer_base.go b/internal/engine/oracle/parser/plsql_lexer_base.go new file mode 100644 index 0000000000..b5e52e0d1b --- /dev/null +++ b/internal/engine/oracle/parser/plsql_lexer_base.go @@ -0,0 +1,15 @@ +package parser + +import ( + "github.com/antlr4-go/antlr/v4" +) + +// PlSqlLexerBase state +type PlSqlLexerBase struct { + *antlr.BaseLexer +} + +func (l *PlSqlLexerBase) IsNewlineAtPos(pos int) bool { + la := l.GetInputStream().LA(pos) + return la == -1 || la == '\n' +} diff --git a/internal/engine/oracle/parser/plsql_parser.go b/internal/engine/oracle/parser/plsql_parser.go new file mode 100644 index 0000000000..586f294fd5 --- /dev/null +++ b/internal/engine/oracle/parser/plsql_parser.go @@ -0,0 +1,354018 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.1. DO NOT EDIT. + +package parser // PlSqlParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type PlSqlParser struct { + PlSqlParserBase +} + +var PlSqlParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func plsqlparserParserInit() { + staticData := &PlSqlParserParserStaticData + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", "'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'", "'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'", "'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'", + "", "", "", "'PERCENT'", "'PERCENT_RANKM'", "", "", "", "", "", "'PERFORMANCE'", + "'PERIOD'", "'PERMANENT'", "'PERMISSION'", "'PERMUTE'", "'PER'", "'PFILE'", + "'PHYSICAL'", "'PIKEY'", "'PIPELINED'", "'PIPE'", "'PIV_GB'", "'PIVOT'", + "'PIV_SSF'", "'PLACE_DISTINCT'", "'PLACE_GROUP_BY'", "'PLAN'", "'PLSCOPE_SETTINGS'", + "'PLS_INTEGER'", "'PLSQL_CCFLAGS'", "'PLSQL_CODE_TYPE'", "'PLSQL_DEBUG'", + "'PLSQL_OPTIMIZE_LEVEL'", "'PLSQL_WARNINGS'", "'PLUGGABLE'", "'PMEM'", + "'POINT'", "'POLICY'", "'POOL_16K'", "'POOL_2K'", "'POOL_32K'", "'POOL_4K'", + "'POOL_8K'", "'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'", "", "'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'", "", "", "", "'..'", "'.'", "", "", + "", "", "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", "','", + "'/'", "'\\'", "'@'", "':='", "'#'", "'{'", "'}'", "'''", "", "", "'^'", + "'~'", "'!'", "'>'", "'<'", "':'", "';'", "'|'", "'='", "'['", "']'", + "'_'", + } + staticData.SymbolicNames = []string{ + "", "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", "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", "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", + } + staticData.RuleNames = []string{ + "sql_script", "unit_statement", "alter_diskgroup", "add_disk_clause", + "drop_disk_clause", "resize_disk_clause", "replace_disk_clause", "wait_nowait", + "rename_disk_clause", "disk_online_clause", "disk_offline_clause", "timeout_clause", + "rebalance_diskgroup_clause", "phase", "check_diskgroup_clause", "diskgroup_template_clauses", + "qualified_template_clause", "redundancy_clause", "striping_clause", + "force_noforce", "diskgroup_directory_clauses", "dir_name", "diskgroup_alias_clauses", + "diskgroup_volume_clauses", "add_volume_clause", "modify_volume_clause", + "diskgroup_attributes", "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_collection_clauses", "dependent_handling_clause", "dependent_exceptions_part", + "create_type", "type_definition", "object_type_def", "object_as_part", + "object_under_part", "nested_table_type_def", "sqlj_object_type", "type_body", + "type_body_elements", "map_order_func_declaration", "subprog_decl_in_type", + "proc_decl_in_type", "func_decl_in_type", "constructor_declaration", + "modifier_clause", "object_member_spec", "sqlj_object_type_attr", "element_spec", + "element_spec_options", "subprogram_spec", "overriding_subprogram_spec", + "overriding_function_spec", "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", "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", "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_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", "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", "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", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 2482, 21417, 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, 1, 0, 1, 0, 3, 0, 2421, 8, 0, 5, 0, 2423, 8, 0, + 10, 0, 12, 0, 2426, 9, 0, 1, 0, 1, 0, 3, 0, 2430, 8, 0, 1, 0, 1, 0, 3, + 0, 2434, 8, 0, 1, 0, 1, 0, 3, 0, 2438, 8, 0, 5, 0, 2440, 8, 0, 10, 0, 12, + 0, 2443, 9, 0, 1, 0, 3, 0, 2446, 8, 0, 1, 0, 3, 0, 2449, 8, 0, 1, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2594, 8, + 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 2, 2601, 8, 2, 11, 2, 12, 2, 2602, + 1, 2, 3, 2, 2606, 8, 2, 1, 2, 3, 2, 2609, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2631, 8, 2, 3, 2, 2633, 8, 2, 1, 2, 1, 2, + 1, 2, 5, 2, 2638, 8, 2, 10, 2, 12, 2, 2641, 9, 2, 1, 2, 3, 2, 2644, 8, + 2, 1, 2, 1, 2, 1, 2, 3, 2, 2649, 8, 2, 3, 2, 2651, 8, 2, 1, 3, 1, 3, 1, + 3, 3, 3, 2656, 8, 3, 1, 3, 3, 3, 2659, 8, 3, 1, 3, 1, 3, 3, 3, 2663, 8, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 2669, 8, 3, 10, 3, 12, 3, 2672, 9, 3, + 4, 3, 2674, 8, 3, 11, 3, 12, 3, 2675, 1, 4, 1, 4, 3, 4, 2680, 8, 4, 1, + 4, 1, 4, 1, 4, 3, 4, 2685, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2690, 8, 4, 5, + 4, 2692, 8, 4, 10, 4, 12, 4, 2695, 9, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2700, + 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2705, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2710, + 8, 4, 5, 4, 2712, 8, 4, 10, 4, 12, 4, 2715, 9, 4, 3, 4, 2717, 8, 4, 1, + 5, 1, 5, 1, 5, 1, 5, 3, 5, 2723, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, + 6, 3, 6, 2731, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 2738, 8, 6, 5, + 6, 2740, 8, 6, 10, 6, 12, 6, 2743, 9, 6, 1, 6, 1, 6, 3, 6, 2747, 8, 6, + 1, 6, 3, 6, 2750, 8, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, + 1, 8, 1, 8, 1, 8, 1, 8, 5, 8, 2764, 8, 8, 10, 8, 12, 8, 2767, 9, 8, 1, + 8, 1, 8, 3, 8, 2771, 8, 8, 1, 9, 1, 9, 3, 9, 2775, 8, 9, 1, 9, 1, 9, 1, + 9, 1, 9, 5, 9, 2781, 8, 9, 10, 9, 12, 9, 2784, 9, 9, 1, 9, 1, 9, 1, 9, + 3, 9, 2789, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 2795, 8, 9, 10, 9, 12, + 9, 2798, 9, 9, 4, 9, 2800, 8, 9, 11, 9, 12, 9, 2801, 1, 9, 3, 9, 2805, + 8, 9, 1, 9, 1, 9, 3, 9, 2809, 8, 9, 1, 9, 3, 9, 2812, 8, 9, 1, 10, 1, 10, + 3, 10, 2816, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 2822, 8, 10, 10, + 10, 12, 10, 2825, 9, 10, 1, 10, 1, 10, 1, 10, 3, 10, 2830, 8, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 5, 10, 2836, 8, 10, 10, 10, 12, 10, 2839, 9, 10, 3, + 10, 2841, 8, 10, 1, 10, 3, 10, 2844, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, + 1, 11, 1, 12, 1, 12, 1, 12, 4, 12, 2854, 8, 12, 11, 12, 12, 12, 2855, 3, + 12, 2858, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2864, 8, 12, 1, 12, + 1, 12, 1, 12, 3, 12, 2869, 8, 12, 3, 12, 2871, 8, 12, 1, 13, 1, 13, 1, + 14, 1, 14, 3, 14, 2877, 8, 14, 1, 14, 3, 14, 2880, 8, 14, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 2890, 8, 15, 10, 15, 12, + 15, 2893, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 2900, 8, 15, + 10, 15, 12, 15, 2903, 9, 15, 3, 15, 2905, 8, 15, 1, 16, 1, 16, 1, 16, 3, + 16, 2910, 8, 16, 1, 16, 3, 16, 2913, 8, 16, 1, 16, 1, 16, 1, 17, 1, 17, + 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2928, + 8, 20, 10, 20, 12, 20, 2931, 9, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, + 2937, 8, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2942, 8, 20, 5, 20, 2944, 8, 20, + 10, 20, 12, 20, 2947, 9, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2959, 8, 20, 10, 20, 12, 20, 2962, 9, + 20, 3, 20, 2964, 8, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, + 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2977, 8, 22, 10, 22, 12, 22, 2980, 9, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2987, 8, 22, 10, 22, 12, + 22, 2990, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, + 1, 22, 5, 22, 3001, 8, 22, 10, 22, 12, 22, 3004, 9, 22, 3, 22, 3006, 8, + 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 23, 3, 23, 3019, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, + 24, 3027, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 3033, 8, 24, 1, 24, + 1, 24, 3, 24, 3037, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 3044, + 8, 25, 1, 25, 1, 25, 3, 25, 3048, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 3061, 8, 27, 10, 27, + 12, 27, 3064, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 3079, 8, 29, 10, 29, 12, + 29, 3082, 9, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, + 5, 29, 3092, 8, 29, 10, 29, 12, 29, 3095, 9, 29, 1, 29, 1, 29, 1, 29, 3, + 29, 3100, 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3107, 8, 30, + 10, 30, 12, 30, 3110, 9, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, + 3117, 8, 30, 10, 30, 12, 30, 3120, 9, 30, 1, 30, 3, 30, 3123, 8, 30, 1, + 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 3134, + 8, 30, 10, 30, 12, 30, 3137, 9, 30, 3, 30, 3139, 8, 30, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 3148, 8, 31, 1, 31, 1, 31, 1, 31, + 1, 31, 1, 31, 1, 31, 3, 31, 3156, 8, 31, 5, 31, 3158, 8, 31, 10, 31, 12, + 31, 3161, 9, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 3168, 8, 31, + 10, 31, 12, 31, 3171, 9, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, + 1, 32, 1, 32, 1, 32, 5, 32, 3182, 8, 32, 10, 32, 12, 32, 3185, 9, 32, 1, + 32, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 3192, 8, 32, 10, 32, 12, 32, 3195, + 9, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3202, 8, 33, 1, 33, 3, + 33, 3205, 8, 33, 1, 33, 1, 33, 3, 33, 3209, 8, 33, 1, 33, 3, 33, 3212, + 8, 33, 1, 33, 3, 33, 3215, 8, 33, 1, 33, 3, 33, 3218, 8, 33, 1, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3228, 8, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 3247, 8, 34, 1, 35, 1, 35, + 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 3257, 8, 37, 1, 38, 1, + 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 3265, 8, 38, 1, 38, 1, 38, 1, 38, + 3, 38, 3270, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 3276, 8, 38, 1, + 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 3297, 8, + 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 3306, 8, 44, + 1, 44, 3, 44, 3309, 8, 44, 1, 44, 1, 44, 3, 44, 3313, 8, 44, 3, 44, 3315, + 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 3322, 8, 45, 10, 45, 12, + 45, 3325, 9, 45, 1, 45, 3, 45, 3328, 8, 45, 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, 3, + 47, 3344, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 3358, 8, 47, 3, 47, 3360, 8, 47, 1, + 47, 3, 47, 3363, 8, 47, 1, 47, 1, 47, 3, 47, 3367, 8, 47, 1, 48, 1, 48, + 1, 48, 1, 48, 1, 48, 3, 48, 3374, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 3, 48, 3381, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 3, 49, 3390, 8, 49, 1, 49, 5, 49, 3393, 8, 49, 10, 49, 12, 49, 3396, 9, + 49, 1, 49, 1, 49, 3, 49, 3400, 8, 49, 3, 49, 3402, 8, 49, 1, 50, 1, 50, + 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3410, 8, 50, 1, 50, 1, 50, 1, 50, 1, + 50, 1, 50, 1, 50, 3, 50, 3418, 8, 50, 1, 50, 1, 50, 3, 50, 3422, 8, 50, + 1, 50, 1, 50, 4, 50, 3426, 8, 50, 11, 50, 12, 50, 3427, 1, 50, 1, 50, 3, + 50, 3432, 8, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3437, 8, 50, 1, 51, 1, 51, + 1, 52, 1, 52, 1, 52, 3, 52, 3444, 8, 52, 1, 52, 3, 52, 3447, 8, 52, 1, + 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 5, 52, 3455, 8, 52, 10, 52, 12, + 52, 3458, 9, 52, 1, 52, 1, 52, 3, 52, 3462, 8, 52, 1, 52, 1, 52, 1, 52, + 1, 52, 1, 52, 3, 52, 3469, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, + 52, 1, 52, 5, 52, 3478, 8, 52, 10, 52, 12, 52, 3481, 9, 52, 1, 52, 1, 52, + 3, 52, 3485, 8, 52, 1, 52, 3, 52, 3488, 8, 52, 1, 52, 1, 52, 3, 52, 3492, + 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 3497, 8, 52, 1, 53, 1, 53, 1, 53, 1, + 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 3, 54, 3509, 8, 54, 1, 55, + 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 3518, 8, 55, 1, 55, 3, + 55, 3521, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, 3, 56, 3527, 8, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 3, 56, 3533, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 5, 57, 3541, 8, 57, 10, 57, 12, 57, 3544, 9, 57, 1, 57, 1, 57, + 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, + 60, 3, 60, 3559, 8, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 3572, 8, 62, 10, 62, 12, 62, 3575, 9, + 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, + 3, 64, 3587, 8, 64, 1, 64, 1, 64, 4, 64, 3591, 8, 64, 11, 64, 12, 64, 3592, + 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, + 65, 3605, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, + 3614, 8, 66, 1, 66, 1, 66, 1, 66, 3, 66, 3619, 8, 66, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 3, 67, 3635, 8, 67, 3, 67, 3637, 8, 67, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, + 3, 68, 3653, 8, 68, 3, 68, 3655, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, + 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 3676, 8, 69, 3, 69, 3678, 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, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 3698, 8, 70, 3, + 70, 3700, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, + 1, 71, 1, 71, 1, 71, 4, 71, 3713, 8, 71, 11, 71, 12, 71, 3714, 1, 71, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 3724, 8, 71, 3, 71, 3726, + 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, + 72, 3737, 8, 72, 1, 73, 1, 73, 1, 73, 5, 73, 3742, 8, 73, 10, 73, 12, 73, + 3745, 9, 73, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, + 76, 1, 76, 3, 76, 3757, 8, 76, 1, 76, 1, 76, 1, 76, 3, 76, 3762, 8, 76, + 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3771, 8, 77, 1, + 77, 3, 77, 3774, 8, 77, 1, 77, 5, 77, 3777, 8, 77, 10, 77, 12, 77, 3780, + 9, 77, 1, 77, 1, 77, 3, 77, 3784, 8, 77, 1, 78, 1, 78, 1, 78, 3, 78, 3789, + 8, 78, 1, 78, 3, 78, 3792, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3798, + 8, 78, 1, 78, 1, 78, 3, 78, 3802, 8, 78, 1, 78, 1, 78, 5, 78, 3806, 8, + 78, 10, 78, 12, 78, 3809, 9, 78, 1, 78, 1, 78, 3, 78, 3813, 8, 78, 1, 79, + 1, 79, 1, 79, 3, 79, 3818, 8, 79, 1, 79, 3, 79, 3821, 8, 79, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 79, 3, 79, 3828, 8, 79, 1, 79, 1, 79, 1, 79, 5, 79, + 3833, 8, 79, 10, 79, 12, 79, 3836, 9, 79, 1, 79, 1, 79, 1, 79, 1, 79, 4, + 79, 3842, 8, 79, 11, 79, 12, 79, 3843, 3, 79, 3846, 8, 79, 3, 79, 3848, + 8, 79, 1, 79, 1, 79, 3, 79, 3852, 8, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 80, 3, 80, 3862, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 5, 81, 3870, 8, 81, 10, 81, 12, 81, 3873, 9, 81, 1, 81, 1, + 81, 3, 81, 3877, 8, 81, 1, 81, 1, 81, 1, 81, 5, 81, 3882, 8, 81, 10, 81, + 12, 81, 3885, 9, 81, 1, 81, 1, 81, 3, 81, 3889, 8, 81, 1, 81, 1, 81, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 3899, 8, 82, 10, 82, 12, + 82, 3902, 9, 82, 1, 82, 1, 82, 3, 82, 3906, 8, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 5, 82, 3915, 8, 82, 10, 82, 12, 82, 3918, 9, + 82, 1, 82, 1, 82, 3, 82, 3922, 8, 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, 3, 83, 3937, 8, + 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, + 3, 84, 3949, 8, 84, 1, 84, 1, 84, 3, 84, 3953, 8, 84, 1, 84, 3, 84, 3956, + 8, 84, 1, 84, 3, 84, 3959, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, + 85, 3966, 8, 85, 1, 85, 1, 85, 3, 85, 3970, 8, 85, 1, 85, 3, 85, 3973, + 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, + 87, 3984, 8, 87, 1, 87, 5, 87, 3987, 8, 87, 10, 87, 12, 87, 3990, 9, 87, + 1, 87, 1, 87, 3, 87, 3994, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 5, 88, 4002, 8, 88, 10, 88, 12, 88, 4005, 9, 88, 1, 88, 1, 88, 3, 88, + 4009, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 5, + 88, 4019, 8, 88, 10, 88, 12, 88, 4022, 9, 88, 1, 88, 1, 88, 3, 88, 4026, + 8, 88, 1, 88, 3, 88, 4029, 8, 88, 1, 88, 1, 88, 3, 88, 4033, 8, 88, 1, + 88, 1, 88, 1, 88, 3, 88, 4038, 8, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 5, 89, 4048, 8, 89, 10, 89, 12, 89, 4051, 9, 89, 1, + 89, 1, 89, 3, 89, 4055, 8, 89, 1, 89, 1, 89, 1, 89, 5, 89, 4060, 8, 89, + 10, 89, 12, 89, 4063, 9, 89, 1, 89, 1, 89, 3, 89, 4067, 8, 89, 1, 89, 3, + 89, 4070, 8, 89, 1, 89, 1, 89, 1, 89, 3, 89, 4075, 8, 89, 1, 89, 1, 89, + 1, 90, 1, 90, 1, 90, 3, 90, 4082, 8, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 90, 5, 90, 4090, 8, 90, 10, 90, 12, 90, 4093, 9, 90, 1, 90, 1, 90, + 3, 90, 4097, 8, 90, 1, 90, 3, 90, 4100, 8, 90, 1, 90, 5, 90, 4103, 8, 90, + 10, 90, 12, 90, 4106, 9, 90, 1, 90, 1, 90, 3, 90, 4110, 8, 90, 1, 90, 3, + 90, 4113, 8, 90, 1, 90, 1, 90, 1, 90, 3, 90, 4118, 8, 90, 1, 91, 1, 91, + 1, 91, 1, 91, 1, 91, 4, 91, 4125, 8, 91, 11, 91, 12, 91, 4126, 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, 3, 93, 4143, 8, 93, 3, 93, 4145, 8, 93, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 4155, 8, 94, 1, 95, 1, 95, + 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 97, 4, 97, 4171, 8, 97, 11, 97, 12, 97, 4172, 1, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 3, 98, 4180, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 4185, 8, + 98, 1, 99, 1, 99, 1, 100, 1, 100, 3, 100, 4191, 8, 100, 1, 100, 1, 100, + 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 4199, 8, 100, 10, 100, 12, 100, + 4202, 9, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, + 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 4217, 8, 102, 1, 102, + 5, 102, 4220, 8, 102, 10, 102, 12, 102, 4223, 9, 102, 1, 102, 1, 102, 3, + 102, 4227, 8, 102, 3, 102, 4229, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, + 4234, 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 4241, 8, + 103, 1, 103, 3, 103, 4244, 8, 103, 1, 103, 3, 103, 4247, 8, 103, 1, 103, + 3, 103, 4250, 8, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 5, + 104, 4258, 8, 104, 10, 104, 12, 104, 4261, 9, 104, 1, 105, 1, 105, 1, 105, + 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 4272, 8, 106, 1, + 106, 1, 106, 3, 106, 4276, 8, 106, 1, 106, 3, 106, 4279, 8, 106, 1, 107, + 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 3, 108, 4288, 8, 108, 1, + 109, 1, 109, 1, 109, 1, 109, 5, 109, 4294, 8, 109, 10, 109, 12, 109, 4297, + 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 4304, 8, 109, 1, + 109, 3, 109, 4307, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 4313, + 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 4318, 8, 111, 1, 111, 4, 111, 4321, + 8, 111, 11, 111, 12, 111, 4322, 1, 111, 1, 111, 3, 111, 4327, 8, 111, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, + 112, 4365, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 3, 113, 4393, 8, 113, 1, 114, 1, 114, 1, 114, 5, 114, 4398, 8, + 114, 10, 114, 12, 114, 4401, 9, 114, 1, 114, 1, 114, 3, 114, 4405, 8, 114, + 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 3, 115, 4412, 8, 115, 1, 116, 1, + 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 3, 117, 4422, 8, 117, + 1, 117, 5, 117, 4425, 8, 117, 10, 117, 12, 117, 4428, 9, 117, 1, 118, 1, + 118, 1, 118, 1, 119, 1, 119, 1, 119, 3, 119, 4436, 8, 119, 1, 119, 1, 119, + 3, 119, 4440, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 3, 120, 4451, 8, 120, 1, 120, 3, 120, 4454, 8, 120, + 1, 121, 1, 121, 3, 121, 4458, 8, 121, 1, 121, 3, 121, 4461, 8, 121, 1, + 121, 5, 121, 4464, 8, 121, 10, 121, 12, 121, 4467, 9, 121, 1, 121, 1, 121, + 3, 121, 4471, 8, 121, 1, 122, 1, 122, 3, 122, 4475, 8, 122, 1, 122, 1, + 122, 1, 122, 1, 122, 1, 122, 1, 122, 5, 122, 4483, 8, 122, 10, 122, 12, + 122, 4486, 9, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 4493, + 8, 123, 10, 123, 12, 123, 4496, 9, 123, 1, 124, 1, 124, 1, 124, 3, 124, + 4501, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4509, + 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 4517, 8, + 126, 1, 126, 1, 126, 1, 126, 3, 126, 4522, 8, 126, 1, 126, 3, 126, 4525, + 8, 126, 3, 126, 4527, 8, 126, 1, 127, 3, 127, 4530, 8, 127, 1, 127, 1, + 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 3, 128, 4539, 8, 128, 1, 128, + 3, 128, 4542, 8, 128, 1, 128, 1, 128, 1, 128, 3, 128, 4547, 8, 128, 1, + 129, 1, 129, 1, 129, 3, 129, 4552, 8, 129, 1, 129, 3, 129, 4555, 8, 129, + 1, 129, 3, 129, 4558, 8, 129, 1, 130, 3, 130, 4561, 8, 130, 1, 130, 1, + 130, 3, 130, 4565, 8, 130, 1, 130, 3, 130, 4568, 8, 130, 1, 130, 1, 130, + 1, 130, 1, 130, 5, 130, 4574, 8, 130, 10, 130, 12, 130, 4577, 9, 130, 1, + 130, 1, 130, 3, 130, 4581, 8, 130, 1, 130, 5, 130, 4584, 8, 130, 10, 130, + 12, 130, 4587, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 4593, 8, + 131, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, + 133, 4603, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, + 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 4, 135, 4617, 8, 135, 11, 135, + 12, 135, 4618, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 3, 136, 4626, 8, + 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 3, 138, 4633, 8, 138, 1, 138, + 1, 138, 1, 138, 3, 138, 4638, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 5, 139, 4646, 8, 139, 10, 139, 12, 139, 4649, 9, 139, 1, 139, + 1, 139, 3, 139, 4653, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 4658, 8, + 139, 1, 139, 3, 139, 4661, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 4666, + 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 4674, 8, + 140, 10, 140, 12, 140, 4677, 9, 140, 1, 140, 1, 140, 3, 140, 4681, 8, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4688, 8, 140, 1, 140, 3, + 140, 4691, 8, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4696, 8, 140, 1, 141, + 3, 141, 4699, 8, 141, 1, 141, 3, 141, 4702, 8, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4714, + 8, 141, 1, 141, 1, 141, 1, 141, 5, 141, 4719, 8, 141, 10, 141, 12, 141, + 4722, 9, 141, 3, 141, 4724, 8, 141, 1, 141, 3, 141, 4727, 8, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4736, 8, 141, 1, + 141, 3, 141, 4739, 8, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4744, 8, 141, + 1, 142, 3, 142, 4747, 8, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, + 143, 4754, 8, 143, 1, 143, 3, 143, 4757, 8, 143, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 145, 3, 145, 4764, 8, 145, 1, 145, 4, 145, 4767, 8, 145, 11, + 145, 12, 145, 4768, 1, 145, 1, 145, 3, 145, 4773, 8, 145, 1, 146, 1, 146, + 1, 146, 3, 146, 4778, 8, 146, 1, 147, 1, 147, 1, 147, 3, 147, 4783, 8, + 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 4791, 8, 148, + 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 5, 149, 4799, 8, 149, 10, + 149, 12, 149, 4802, 9, 149, 1, 149, 1, 149, 3, 149, 4806, 8, 149, 1, 149, + 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 4813, 8, 149, 1, 149, 3, 149, 4816, + 8, 149, 1, 149, 1, 149, 3, 149, 4820, 8, 149, 1, 149, 3, 149, 4823, 8, + 149, 1, 149, 3, 149, 4826, 8, 149, 1, 149, 3, 149, 4829, 8, 149, 1, 150, + 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 4837, 8, 150, 10, 150, + 12, 150, 4840, 9, 150, 1, 150, 1, 150, 3, 150, 4844, 8, 150, 1, 150, 1, + 150, 1, 150, 3, 150, 4849, 8, 150, 1, 150, 3, 150, 4852, 8, 150, 1, 150, + 1, 150, 1, 150, 3, 150, 4857, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 151, 5, 151, 4865, 8, 151, 10, 151, 12, 151, 4868, 9, 151, 1, 151, + 1, 151, 3, 151, 4872, 8, 151, 1, 151, 1, 151, 3, 151, 4876, 8, 151, 1, + 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 4884, 8, 152, 10, + 152, 12, 152, 4887, 9, 152, 1, 152, 1, 152, 3, 152, 4891, 8, 152, 1, 152, + 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 4898, 8, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 3, 152, 4904, 8, 152, 1, 152, 1, 152, 3, 152, 4908, 8, 152, + 1, 153, 3, 153, 4911, 8, 153, 1, 153, 3, 153, 4914, 8, 153, 1, 153, 1, + 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, + 153, 4926, 8, 153, 1, 153, 1, 153, 1, 153, 5, 153, 4931, 8, 153, 10, 153, + 12, 153, 4934, 9, 153, 3, 153, 4936, 8, 153, 1, 153, 3, 153, 4939, 8, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 4947, 8, 153, 1, + 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 5, 155, 4959, 8, 155, 10, 155, 12, 155, 4962, 9, 155, 1, 155, 1, 155, + 1, 156, 1, 156, 3, 156, 4968, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 4980, 8, 157, 1, 157, + 1, 157, 1, 157, 3, 157, 4985, 8, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, + 159, 1, 159, 1, 159, 1, 159, 4, 159, 4995, 8, 159, 11, 159, 12, 159, 4996, + 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, + 3, 160, 5017, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 5024, + 8, 160, 3, 160, 5026, 8, 160, 1, 160, 1, 160, 3, 160, 5030, 8, 160, 1, + 161, 1, 161, 1, 161, 1, 161, 4, 161, 5036, 8, 161, 11, 161, 12, 161, 5037, + 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, + 3, 161, 5049, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, + 161, 1, 161, 1, 161, 3, 161, 5060, 8, 161, 3, 161, 5062, 8, 161, 1, 162, + 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 5069, 8, 162, 1, 162, 1, 162, 5, + 162, 5073, 8, 162, 10, 162, 12, 162, 5076, 9, 162, 1, 162, 1, 162, 1, 162, + 3, 162, 5081, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 5104, 8, 163, 1, 163, + 1, 163, 1, 163, 3, 163, 5109, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 5114, + 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 3, 165, + 5123, 8, 165, 1, 165, 3, 165, 5126, 8, 165, 1, 165, 1, 165, 1, 165, 1, + 165, 1, 165, 1, 165, 3, 165, 5134, 8, 165, 1, 165, 5, 165, 5137, 8, 165, + 10, 165, 12, 165, 5140, 9, 165, 1, 165, 3, 165, 5143, 8, 165, 1, 165, 3, + 165, 5146, 8, 165, 1, 165, 3, 165, 5149, 8, 165, 1, 165, 3, 165, 5152, + 8, 165, 1, 165, 3, 165, 5155, 8, 165, 1, 165, 3, 165, 5158, 8, 165, 1, + 165, 3, 165, 5161, 8, 165, 1, 165, 3, 165, 5164, 8, 165, 1, 166, 1, 166, + 3, 166, 5168, 8, 166, 1, 166, 3, 166, 5171, 8, 166, 1, 166, 3, 166, 5174, + 8, 166, 1, 166, 5, 166, 5177, 8, 166, 10, 166, 12, 166, 5180, 9, 166, 1, + 166, 3, 166, 5183, 8, 166, 1, 166, 3, 166, 5186, 8, 166, 1, 166, 4, 166, + 5189, 8, 166, 11, 166, 12, 166, 5190, 3, 166, 5193, 8, 166, 1, 167, 1, + 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, + 169, 5205, 8, 169, 1, 169, 1, 169, 3, 169, 5209, 8, 169, 1, 170, 1, 170, + 3, 170, 5213, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 5219, 8, + 171, 1, 171, 1, 171, 3, 171, 5223, 8, 171, 1, 171, 3, 171, 5226, 8, 171, + 1, 171, 3, 171, 5229, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, + 172, 5, 172, 5237, 8, 172, 10, 172, 12, 172, 5240, 9, 172, 1, 172, 1, 172, + 1, 173, 1, 173, 5, 173, 5246, 8, 173, 10, 173, 12, 173, 5249, 9, 173, 1, + 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 5256, 8, 173, 1, 173, 1, 173, + 1, 173, 1, 173, 1, 173, 3, 173, 5263, 8, 173, 1, 173, 5, 173, 5266, 8, + 173, 10, 173, 12, 173, 5269, 9, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 3, 173, 5276, 8, 173, 1, 173, 3, 173, 5279, 8, 173, 1, 173, 1, 173, + 3, 173, 5283, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 5293, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, + 5, 173, 5300, 8, 173, 10, 173, 12, 173, 5303, 9, 173, 1, 173, 1, 173, 1, + 174, 1, 174, 1, 174, 3, 174, 5310, 8, 174, 1, 174, 1, 174, 3, 174, 5314, + 8, 174, 1, 174, 3, 174, 5317, 8, 174, 1, 175, 1, 175, 1, 175, 3, 175, 5322, + 8, 175, 1, 175, 1, 175, 3, 175, 5326, 8, 175, 1, 175, 3, 175, 5329, 8, + 175, 1, 175, 3, 175, 5332, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, + 5, 176, 5339, 8, 176, 10, 176, 12, 176, 5342, 9, 176, 1, 176, 1, 176, 1, + 177, 1, 177, 1, 177, 3, 177, 5349, 8, 177, 1, 178, 1, 178, 1, 178, 3, 178, + 5354, 8, 178, 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, 182, 1, 182, 1, 182, 1, + 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 5, 183, 5378, 8, 183, 10, + 183, 12, 183, 5381, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, + 184, 1, 184, 5, 184, 5390, 8, 184, 10, 184, 12, 184, 5393, 9, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 5, 184, 5399, 8, 184, 10, 184, 12, 184, 5402, 9, + 184, 3, 184, 5404, 8, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 5, 185, + 5411, 8, 185, 10, 185, 12, 185, 5414, 9, 185, 1, 185, 1, 185, 1, 185, 1, + 186, 1, 186, 1, 186, 1, 186, 3, 186, 5423, 8, 186, 1, 186, 1, 186, 1, 186, + 3, 186, 5428, 8, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, + 187, 1, 187, 1, 187, 3, 187, 5439, 8, 187, 1, 187, 3, 187, 5442, 8, 187, + 3, 187, 5444, 8, 187, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 5450, 8, + 188, 1, 188, 1, 188, 1, 188, 3, 188, 5455, 8, 188, 1, 188, 5, 188, 5458, + 8, 188, 10, 188, 12, 188, 5461, 9, 188, 3, 188, 5463, 8, 188, 1, 189, 1, + 189, 1, 189, 1, 189, 3, 189, 5469, 8, 189, 1, 190, 1, 190, 1, 190, 3, 190, + 5474, 8, 190, 1, 190, 3, 190, 5477, 8, 190, 1, 190, 1, 190, 1, 190, 1, + 190, 1, 190, 3, 190, 5484, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, + 5490, 8, 190, 1, 190, 5, 190, 5493, 8, 190, 10, 190, 12, 190, 5496, 9, + 190, 1, 190, 1, 190, 1, 190, 3, 190, 5501, 8, 190, 1, 190, 1, 190, 1, 190, + 4, 190, 5506, 8, 190, 11, 190, 12, 190, 5507, 1, 190, 3, 190, 5511, 8, + 190, 1, 191, 1, 191, 1, 191, 1, 191, 5, 191, 5517, 8, 191, 10, 191, 12, + 191, 5520, 9, 191, 1, 191, 5, 191, 5523, 8, 191, 10, 191, 12, 191, 5526, + 9, 191, 1, 192, 1, 192, 1, 192, 3, 192, 5531, 8, 192, 1, 192, 1, 192, 3, + 192, 5535, 8, 192, 1, 192, 3, 192, 5538, 8, 192, 1, 192, 3, 192, 5541, + 8, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, + 1, 194, 5, 194, 5552, 8, 194, 10, 194, 12, 194, 5555, 9, 194, 1, 195, 1, + 195, 1, 195, 3, 195, 5560, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, + 3, 195, 5567, 8, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, + 196, 5, 196, 5576, 8, 196, 10, 196, 12, 196, 5579, 9, 196, 1, 196, 1, 196, + 1, 197, 1, 197, 1, 197, 3, 197, 5586, 8, 197, 1, 197, 1, 197, 3, 197, 5590, + 8, 197, 1, 197, 3, 197, 5593, 8, 197, 1, 197, 5, 197, 5596, 8, 197, 10, + 197, 12, 197, 5599, 9, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 3, 198, 5608, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5613, + 8, 198, 1, 198, 5, 198, 5616, 8, 198, 10, 198, 12, 198, 5619, 9, 198, 1, + 198, 1, 198, 3, 198, 5623, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5628, + 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5633, 8, 198, 1, 198, 1, 198, 1, + 198, 3, 198, 5638, 8, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5643, 8, 198, + 1, 198, 1, 198, 1, 198, 3, 198, 5648, 8, 198, 1, 198, 5, 198, 5651, 8, + 198, 10, 198, 12, 198, 5654, 9, 198, 3, 198, 5656, 8, 198, 1, 198, 1, 198, + 1, 198, 1, 198, 1, 198, 5, 198, 5663, 8, 198, 10, 198, 12, 198, 5666, 9, + 198, 1, 198, 1, 198, 3, 198, 5670, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 1, 199, 5, 199, 5678, 8, 199, 10, 199, 12, 199, 5681, 9, 199, 1, + 199, 1, 199, 3, 199, 5685, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, + 3, 201, 5692, 8, 201, 1, 201, 1, 201, 3, 201, 5696, 8, 201, 1, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5705, 8, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5712, 8, 202, 1, 202, 1, 202, 3, + 202, 5716, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 5723, + 8, 203, 1, 203, 3, 203, 5726, 8, 203, 1, 203, 3, 203, 5729, 8, 203, 1, + 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 5737, 8, 203, 1, 203, + 1, 203, 3, 203, 5741, 8, 203, 1, 203, 3, 203, 5744, 8, 203, 1, 204, 1, + 204, 1, 204, 1, 204, 5, 204, 5750, 8, 204, 10, 204, 12, 204, 5753, 9, 204, + 1, 205, 1, 205, 1, 205, 4, 205, 5758, 8, 205, 11, 205, 12, 205, 5759, 1, + 206, 1, 206, 1, 206, 1, 206, 5, 206, 5766, 8, 206, 10, 206, 12, 206, 5769, + 9, 206, 1, 207, 1, 207, 1, 207, 1, 207, 5, 207, 5775, 8, 207, 10, 207, + 12, 207, 5778, 9, 207, 1, 208, 1, 208, 3, 208, 5782, 8, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 3, 208, 5789, 8, 208, 1, 208, 1, 208, 1, 208, + 3, 208, 5794, 8, 208, 1, 208, 3, 208, 5797, 8, 208, 1, 208, 1, 208, 3, + 208, 5801, 8, 208, 3, 208, 5803, 8, 208, 1, 209, 1, 209, 1, 210, 1, 210, + 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 5814, 8, 210, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 5, 211, 5823, 8, 211, 10, + 211, 12, 211, 5826, 9, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 5, 211, 5837, 8, 211, 10, 211, 12, 211, 5840, + 9, 211, 1, 211, 1, 211, 3, 211, 5844, 8, 211, 1, 212, 1, 212, 1, 213, 1, + 213, 1, 213, 1, 213, 5, 213, 5852, 8, 213, 10, 213, 12, 213, 5855, 9, 213, + 1, 214, 1, 214, 1, 214, 3, 214, 5860, 8, 214, 1, 214, 3, 214, 5863, 8, + 214, 1, 214, 1, 214, 1, 214, 3, 214, 5868, 8, 214, 1, 214, 1, 214, 1, 214, + 1, 214, 1, 214, 5, 214, 5875, 8, 214, 10, 214, 12, 214, 5878, 9, 214, 3, + 214, 5880, 8, 214, 1, 214, 5, 214, 5883, 8, 214, 10, 214, 12, 214, 5886, + 9, 214, 1, 214, 3, 214, 5889, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, + 215, 5913, 8, 215, 3, 215, 5915, 8, 215, 1, 216, 1, 216, 3, 216, 5919, + 8, 216, 1, 216, 3, 216, 5922, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5927, + 8, 216, 1, 216, 3, 216, 5930, 8, 216, 1, 216, 5, 216, 5933, 8, 216, 10, + 216, 12, 216, 5936, 9, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, + 218, 3, 218, 5944, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 3, 219, 5955, 8, 219, 1, 219, 3, 219, 5958, 8, + 219, 1, 219, 3, 219, 5961, 8, 219, 1, 219, 3, 219, 5964, 8, 219, 1, 219, + 1, 219, 3, 219, 5968, 8, 219, 1, 219, 1, 219, 1, 219, 1, 219, 5, 219, 5974, + 8, 219, 10, 219, 12, 219, 5977, 9, 219, 4, 219, 5979, 8, 219, 11, 219, + 12, 219, 5980, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 5, 219, 5991, 8, 219, 10, 219, 12, 219, 5994, 9, 219, 3, 219, 5996, + 8, 219, 1, 220, 1, 220, 1, 220, 3, 220, 6001, 8, 220, 1, 220, 1, 220, 3, + 220, 6005, 8, 220, 1, 220, 3, 220, 6008, 8, 220, 1, 221, 1, 221, 1, 221, + 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 6017, 8, 221, 1, 222, 1, 222, 1, + 222, 1, 222, 3, 222, 6023, 8, 222, 1, 222, 1, 222, 1, 222, 1, 222, 3, 222, + 6029, 8, 222, 1, 222, 3, 222, 6032, 8, 222, 1, 222, 1, 222, 3, 222, 6036, + 8, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 3, 225, 6051, 8, 225, 1, 225, 3, + 225, 6054, 8, 225, 1, 225, 3, 225, 6057, 8, 225, 1, 225, 1, 225, 1, 225, + 1, 225, 3, 225, 6063, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6069, + 8, 225, 1, 225, 5, 225, 6072, 8, 225, 10, 225, 12, 225, 6075, 9, 225, 1, + 225, 1, 225, 1, 225, 3, 225, 6080, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, + 3, 226, 6086, 8, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 3, + 227, 6094, 8, 227, 4, 227, 6096, 8, 227, 11, 227, 12, 227, 6097, 1, 227, + 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, + 5, 229, 6110, 8, 229, 10, 229, 12, 229, 6113, 9, 229, 1, 230, 1, 230, 1, + 231, 1, 231, 3, 231, 6119, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 3, 231, 6126, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 6132, 8, + 231, 1, 231, 3, 231, 6135, 8, 231, 1, 231, 1, 231, 3, 231, 6139, 8, 231, + 1, 232, 1, 232, 1, 232, 3, 232, 6144, 8, 232, 1, 233, 1, 233, 1, 233, 3, + 233, 6149, 8, 233, 1, 233, 1, 233, 1, 234, 1, 234, 3, 234, 6155, 8, 234, + 1, 234, 1, 234, 1, 234, 3, 234, 6160, 8, 234, 1, 234, 1, 234, 1, 234, 3, + 234, 6165, 8, 234, 5, 234, 6167, 8, 234, 10, 234, 12, 234, 6170, 9, 234, + 1, 234, 1, 234, 3, 234, 6174, 8, 234, 1, 235, 1, 235, 1, 235, 1, 235, 3, + 235, 6180, 8, 235, 1, 235, 1, 235, 3, 235, 6184, 8, 235, 1, 235, 1, 235, + 1, 235, 3, 235, 6189, 8, 235, 1, 235, 1, 235, 3, 235, 6193, 8, 235, 5, + 235, 6195, 8, 235, 10, 235, 12, 235, 6198, 9, 235, 1, 235, 1, 235, 1, 235, + 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 5, 235, 6208, 8, 235, 10, 235, + 12, 235, 6211, 9, 235, 1, 235, 1, 235, 3, 235, 6215, 8, 235, 1, 235, 3, + 235, 6218, 8, 235, 1, 236, 1, 236, 3, 236, 6222, 8, 236, 1, 237, 1, 237, + 1, 237, 4, 237, 6227, 8, 237, 11, 237, 12, 237, 6228, 1, 237, 1, 237, 1, + 237, 1, 237, 3, 237, 6235, 8, 237, 3, 237, 6237, 8, 237, 1, 238, 1, 238, + 3, 238, 6241, 8, 238, 1, 238, 3, 238, 6244, 8, 238, 1, 238, 1, 238, 1, + 238, 1, 238, 1, 238, 3, 238, 6251, 8, 238, 1, 239, 1, 239, 1, 239, 1, 239, + 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 6262, 8, 239, 1, 239, 1, + 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 6272, 8, 239, + 5, 239, 6274, 8, 239, 10, 239, 12, 239, 6277, 9, 239, 1, 239, 1, 239, 3, + 239, 6281, 8, 239, 1, 240, 1, 240, 3, 240, 6285, 8, 240, 1, 240, 1, 240, + 3, 240, 6289, 8, 240, 1, 240, 3, 240, 6292, 8, 240, 1, 241, 1, 241, 1, + 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 6301, 8, 241, 10, 241, 12, + 241, 6304, 9, 241, 1, 241, 1, 241, 3, 241, 6308, 8, 241, 1, 242, 1, 242, + 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, 242, 6318, 8, 242, 10, + 242, 12, 242, 6321, 9, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, + 242, 6328, 8, 242, 10, 242, 12, 242, 6331, 9, 242, 1, 242, 1, 242, 1, 242, + 1, 242, 1, 242, 1, 242, 1, 242, 5, 242, 6340, 8, 242, 10, 242, 12, 242, + 6343, 9, 242, 1, 242, 1, 242, 1, 242, 3, 242, 6348, 8, 242, 3, 242, 6350, + 8, 242, 1, 243, 1, 243, 3, 243, 6354, 8, 243, 1, 243, 1, 243, 1, 243, 1, + 243, 1, 243, 1, 243, 1, 243, 3, 243, 6363, 8, 243, 1, 244, 1, 244, 1, 244, + 5, 244, 6368, 8, 244, 10, 244, 12, 244, 6371, 9, 244, 1, 244, 1, 244, 1, + 244, 1, 244, 1, 244, 5, 244, 6378, 8, 244, 10, 244, 12, 244, 6381, 9, 244, + 3, 244, 6383, 8, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 6390, + 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 5, 246, 6396, 8, 246, 10, 246, + 12, 246, 6399, 9, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, + 5, 247, 6407, 8, 247, 10, 247, 12, 247, 6410, 9, 247, 1, 247, 1, 247, 1, + 248, 1, 248, 3, 248, 6416, 8, 248, 1, 248, 1, 248, 5, 248, 6420, 8, 248, + 10, 248, 12, 248, 6423, 9, 248, 1, 248, 3, 248, 6426, 8, 248, 1, 249, 1, + 249, 1, 249, 1, 249, 1, 249, 1, 249, 5, 249, 6434, 8, 249, 10, 249, 12, + 249, 6437, 9, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 5, 249, + 6445, 8, 249, 10, 249, 12, 249, 6448, 9, 249, 1, 249, 1, 249, 3, 249, 6452, + 8, 249, 1, 250, 1, 250, 3, 250, 6456, 8, 250, 1, 250, 1, 250, 3, 250, 6460, + 8, 250, 1, 250, 3, 250, 6463, 8, 250, 1, 250, 3, 250, 6466, 8, 250, 1, + 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 6474, 8, 251, 10, + 251, 12, 251, 6477, 9, 251, 1, 251, 1, 251, 3, 251, 6481, 8, 251, 1, 251, + 1, 251, 1, 251, 1, 251, 5, 251, 6487, 8, 251, 10, 251, 12, 251, 6490, 9, + 251, 1, 251, 1, 251, 1, 252, 1, 252, 3, 252, 6496, 8, 252, 1, 252, 1, 252, + 5, 252, 6500, 8, 252, 10, 252, 12, 252, 6503, 9, 252, 1, 252, 3, 252, 6506, + 8, 252, 1, 252, 3, 252, 6509, 8, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, + 253, 1, 253, 5, 253, 6517, 8, 253, 10, 253, 12, 253, 6520, 9, 253, 1, 253, + 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 6528, 8, 253, 10, 253, + 12, 253, 6531, 9, 253, 1, 253, 1, 253, 3, 253, 6535, 8, 253, 1, 254, 1, + 254, 3, 254, 6539, 8, 254, 1, 254, 1, 254, 3, 254, 6543, 8, 254, 1, 254, + 3, 254, 6546, 8, 254, 1, 254, 3, 254, 6549, 8, 254, 1, 255, 1, 255, 1, + 256, 1, 256, 1, 256, 3, 256, 6556, 8, 256, 1, 256, 1, 256, 1, 257, 1, 257, + 1, 257, 1, 257, 1, 257, 3, 257, 6565, 8, 257, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 258, 1, 258, 4, 258, 6573, 8, 258, 11, 258, 12, 258, 6574, 1, 259, + 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, + 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, + 1, 259, 1, 259, 3, 259, 6598, 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6611, 8, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, + 1, 262, 1, 262, 1, 262, 5, 262, 6625, 8, 262, 10, 262, 12, 262, 6628, 9, + 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 3, + 263, 6638, 8, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, + 6646, 8, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 6652, 8, 264, 1, + 264, 3, 264, 6655, 8, 264, 1, 265, 1, 265, 1, 265, 3, 265, 6660, 8, 265, + 1, 265, 1, 265, 3, 265, 6664, 8, 265, 1, 265, 3, 265, 6667, 8, 265, 1, + 265, 3, 265, 6670, 8, 265, 1, 266, 1, 266, 1, 266, 3, 266, 6675, 8, 266, + 1, 267, 1, 267, 1, 267, 1, 267, 4, 267, 6681, 8, 267, 11, 267, 12, 267, + 6682, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 3, 267, 6695, 8, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, + 1, 268, 3, 268, 6703, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, + 269, 6710, 8, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, + 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 5, 271, + 6727, 8, 271, 10, 271, 12, 271, 6730, 9, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 6740, 8, 271, 1, 271, 3, 271, + 6743, 8, 271, 1, 272, 1, 272, 1, 272, 1, 272, 4, 272, 6749, 8, 272, 11, + 272, 12, 272, 6750, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 3, 272, 6758, + 8, 272, 1, 272, 3, 272, 6761, 8, 272, 3, 272, 6763, 8, 272, 1, 273, 1, + 273, 1, 273, 1, 273, 1, 273, 3, 273, 6770, 8, 273, 1, 274, 1, 274, 1, 275, + 1, 275, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, + 1, 277, 3, 277, 6785, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, + 277, 3, 277, 6793, 8, 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, 3, 278, 6807, 8, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 4, + 278, 6818, 8, 278, 11, 278, 12, 278, 6819, 1, 279, 1, 279, 1, 279, 1, 279, + 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, + 1, 279, 4, 279, 6836, 8, 279, 11, 279, 12, 279, 6837, 1, 279, 1, 279, 1, + 279, 5, 279, 6843, 8, 279, 10, 279, 12, 279, 6846, 9, 279, 1, 279, 1, 279, + 3, 279, 6850, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 6857, + 8, 280, 1, 280, 3, 280, 6860, 8, 280, 1, 281, 1, 281, 1, 281, 3, 281, 6865, + 8, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, + 3, 283, 6875, 8, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, + 285, 3, 285, 6884, 8, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, + 1, 287, 1, 287, 1, 287, 5, 287, 6895, 8, 287, 10, 287, 12, 287, 6898, 9, + 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 5, 287, 6905, 8, 287, 10, + 287, 12, 287, 6908, 9, 287, 5, 287, 6910, 8, 287, 10, 287, 12, 287, 6913, + 9, 287, 3, 287, 6915, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 6921, + 8, 288, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, + 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 5, 292, 6937, 8, 292, 10, + 292, 12, 292, 6940, 9, 292, 3, 292, 6942, 8, 292, 1, 292, 3, 292, 6945, + 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6953, 8, + 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 3, 293, 6966, 8, 293, 3, 293, 6968, 8, 293, 1, 293, + 1, 293, 3, 293, 6972, 8, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 3, 293, 6980, 8, 293, 3, 293, 6982, 8, 293, 3, 293, 6984, 8, 293, + 3, 293, 6986, 8, 293, 1, 294, 1, 294, 1, 294, 1, 294, 5, 294, 6992, 8, + 294, 10, 294, 12, 294, 6995, 9, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, + 295, 1, 295, 1, 295, 1, 295, 3, 295, 7005, 8, 295, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 7016, 8, 297, 3, + 297, 7018, 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, + 3, 298, 7027, 8, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, + 299, 1, 299, 1, 299, 3, 299, 7038, 8, 299, 1, 300, 1, 300, 1, 300, 1, 300, + 3, 300, 7044, 8, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 7051, + 8, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, + 3, 301, 7061, 8, 301, 1, 301, 1, 301, 3, 301, 7065, 8, 301, 1, 302, 1, + 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 7074, 8, 303, 1, 303, + 3, 303, 7077, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, 7083, 8, + 304, 1, 304, 3, 304, 7086, 8, 304, 1, 304, 1, 304, 1, 304, 3, 304, 7091, + 8, 304, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 7097, 8, 305, 1, 305, 1, + 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 7105, 8, 305, 1, 306, 1, 306, + 1, 306, 1, 306, 3, 306, 7111, 8, 306, 1, 306, 1, 306, 1, 306, 1, 306, 3, + 306, 7117, 8, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, + 1, 307, 1, 307, 1, 307, 3, 307, 7129, 8, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 3, 307, 7137, 8, 307, 1, 308, 3, 308, 7140, 8, 308, + 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, + 3, 308, 7151, 8, 308, 1, 308, 1, 308, 3, 308, 7155, 8, 308, 1, 309, 1, + 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 7166, + 8, 309, 1, 309, 1, 309, 3, 309, 7170, 8, 309, 1, 310, 1, 310, 1, 310, 1, + 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 3, 310, 7181, 8, 310, 1, 311, + 1, 311, 3, 311, 7185, 8, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 7191, + 8, 311, 1, 311, 3, 311, 7194, 8, 311, 1, 311, 3, 311, 7197, 8, 311, 1, + 311, 3, 311, 7200, 8, 311, 1, 311, 3, 311, 7203, 8, 311, 1, 311, 1, 311, + 3, 311, 7207, 8, 311, 1, 311, 3, 311, 7210, 8, 311, 1, 312, 1, 312, 3, + 312, 7214, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 7220, 8, 312, + 1, 312, 3, 312, 7223, 8, 312, 1, 312, 3, 312, 7226, 8, 312, 1, 312, 3, + 312, 7229, 8, 312, 1, 312, 3, 312, 7232, 8, 312, 1, 312, 1, 312, 3, 312, + 7236, 8, 312, 1, 312, 3, 312, 7239, 8, 312, 1, 313, 1, 313, 1, 314, 1, + 314, 1, 315, 1, 315, 3, 315, 7247, 8, 315, 1, 315, 1, 315, 1, 315, 3, 315, + 7252, 8, 315, 1, 315, 3, 315, 7255, 8, 315, 1, 315, 1, 315, 3, 315, 7259, + 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 7267, 8, + 316, 1, 316, 1, 316, 3, 316, 7271, 8, 316, 1, 317, 1, 317, 3, 317, 7275, + 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, + 7284, 8, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 5, + 317, 7293, 8, 317, 10, 317, 12, 317, 7296, 9, 317, 1, 317, 1, 317, 1, 317, + 1, 317, 3, 317, 7302, 8, 317, 3, 317, 7304, 8, 317, 1, 318, 1, 318, 3, + 318, 7308, 8, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, + 3, 318, 7317, 8, 318, 1, 318, 1, 318, 3, 318, 7321, 8, 318, 1, 319, 1, + 319, 3, 319, 7325, 8, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 3, 319, + 7332, 8, 319, 1, 319, 1, 319, 1, 319, 1, 319, 3, 319, 7338, 8, 319, 1, + 320, 1, 320, 3, 320, 7342, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, + 3, 320, 7349, 8, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, + 321, 3, 321, 7358, 8, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, + 1, 321, 1, 321, 1, 321, 1, 321, 3, 321, 7370, 8, 321, 1, 321, 1, 321, 1, + 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 5, 321, 7382, + 8, 321, 10, 321, 12, 321, 7385, 9, 321, 1, 321, 3, 321, 7388, 8, 321, 3, + 321, 7390, 8, 321, 1, 321, 3, 321, 7393, 8, 321, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 3, 322, 7400, 8, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, + 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 7414, + 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, + 7423, 8, 326, 1, 326, 3, 326, 7426, 8, 326, 1, 326, 3, 326, 7429, 8, 326, + 1, 326, 3, 326, 7432, 8, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, + 327, 3, 327, 7440, 8, 327, 1, 327, 1, 327, 3, 327, 7444, 8, 327, 1, 328, + 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 7453, 8, 328, 1, + 328, 1, 328, 3, 328, 7457, 8, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, + 7472, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 3, 330, 7480, + 8, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, + 1, 331, 1, 331, 3, 331, 7492, 8, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, + 333, 1, 333, 1, 334, 1, 334, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, + 336, 1, 336, 3, 336, 7509, 8, 336, 1, 336, 3, 336, 7512, 8, 336, 1, 336, + 1, 336, 1, 336, 3, 336, 7517, 8, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, + 336, 7523, 8, 336, 1, 336, 1, 336, 3, 336, 7527, 8, 336, 1, 336, 1, 336, + 1, 336, 3, 336, 7532, 8, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7538, + 8, 336, 1, 336, 1, 336, 3, 336, 7542, 8, 336, 1, 336, 3, 336, 7545, 8, + 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, + 337, 1, 337, 5, 337, 7557, 8, 337, 10, 337, 12, 337, 7560, 9, 337, 1, 337, + 1, 337, 3, 337, 7564, 8, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, + 337, 1, 337, 1, 337, 1, 337, 1, 337, 5, 337, 7576, 8, 337, 10, 337, 12, + 337, 7579, 9, 337, 1, 337, 1, 337, 3, 337, 7583, 8, 337, 3, 337, 7585, + 8, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, + 7594, 8, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 3, 338, 7602, + 8, 338, 1, 338, 3, 338, 7605, 8, 338, 1, 338, 3, 338, 7608, 8, 338, 1, + 338, 3, 338, 7611, 8, 338, 1, 338, 3, 338, 7614, 8, 338, 3, 338, 7616, + 8, 338, 1, 339, 1, 339, 3, 339, 7620, 8, 339, 1, 339, 1, 339, 3, 339, 7624, + 8, 339, 1, 340, 1, 340, 1, 340, 5, 340, 7629, 8, 340, 10, 340, 12, 340, + 7632, 9, 340, 1, 340, 1, 340, 3, 340, 7636, 8, 340, 1, 340, 1, 340, 1, + 340, 3, 340, 7641, 8, 340, 1, 340, 5, 340, 7644, 8, 340, 10, 340, 12, 340, + 7647, 9, 340, 1, 340, 3, 340, 7650, 8, 340, 1, 340, 3, 340, 7653, 8, 340, + 1, 340, 1, 340, 1, 340, 3, 340, 7658, 8, 340, 1, 340, 1, 340, 1, 340, 1, + 340, 4, 340, 7664, 8, 340, 11, 340, 12, 340, 7665, 1, 340, 5, 340, 7669, + 8, 340, 10, 340, 12, 340, 7672, 9, 340, 3, 340, 7674, 8, 340, 1, 341, 1, + 341, 1, 342, 1, 342, 3, 342, 7680, 8, 342, 1, 343, 1, 343, 1, 343, 3, 343, + 7685, 8, 343, 1, 344, 1, 344, 1, 344, 3, 344, 7690, 8, 344, 1, 345, 1, + 345, 1, 345, 1, 345, 1, 345, 3, 345, 7697, 8, 345, 1, 345, 3, 345, 7700, + 8, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 5, 346, 7711, 8, 346, 10, 346, 12, 346, 7714, 9, 346, 1, 346, 1, + 346, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7722, 8, 347, 10, 347, 12, + 347, 7725, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 7731, 8, 347, + 10, 347, 12, 347, 7734, 9, 347, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, + 7740, 8, 347, 10, 347, 12, 347, 7743, 9, 347, 1, 347, 1, 347, 1, 347, 1, + 347, 5, 347, 7749, 8, 347, 10, 347, 12, 347, 7752, 9, 347, 1, 347, 1, 347, + 1, 347, 1, 347, 5, 347, 7758, 8, 347, 10, 347, 12, 347, 7761, 9, 347, 3, + 347, 7763, 8, 347, 1, 347, 1, 347, 1, 347, 1, 347, 3, 347, 7769, 8, 347, + 1, 347, 1, 347, 1, 347, 3, 347, 7774, 8, 347, 3, 347, 7776, 8, 347, 1, + 348, 1, 348, 1, 349, 1, 349, 1, 349, 3, 349, 7783, 8, 349, 1, 350, 1, 350, + 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, + 1, 351, 1, 352, 1, 352, 1, 353, 1, 353, 1, 354, 1, 354, 1, 355, 1, 355, + 1, 355, 1, 355, 1, 356, 1, 356, 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, + 5, 358, 7823, 8, 358, 10, 358, 12, 358, 7826, 9, 358, 3, 358, 7828, 8, + 358, 1, 358, 1, 358, 3, 358, 7832, 8, 358, 1, 358, 3, 358, 7835, 8, 358, + 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 5, 358, 7844, 8, + 358, 10, 358, 12, 358, 7847, 9, 358, 1, 358, 1, 358, 1, 358, 1, 358, 5, + 358, 7853, 8, 358, 10, 358, 12, 358, 7856, 9, 358, 3, 358, 7858, 8, 358, + 3, 358, 7860, 8, 358, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, + 360, 1, 360, 3, 360, 7870, 8, 360, 1, 360, 1, 360, 1, 360, 3, 360, 7875, + 8, 360, 1, 360, 1, 360, 3, 360, 7879, 8, 360, 1, 360, 1, 360, 3, 360, 7883, + 8, 360, 1, 360, 3, 360, 7886, 8, 360, 1, 360, 3, 360, 7889, 8, 360, 1, + 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, + 363, 1, 363, 1, 363, 3, 363, 7903, 8, 363, 3, 363, 7905, 8, 363, 1, 363, + 1, 363, 1, 363, 1, 363, 3, 363, 7911, 8, 363, 3, 363, 7913, 8, 363, 5, + 363, 7915, 8, 363, 10, 363, 12, 363, 7918, 9, 363, 1, 363, 1, 363, 1, 363, + 3, 363, 7923, 8, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7929, 8, + 363, 5, 363, 7931, 8, 363, 10, 363, 12, 363, 7934, 9, 363, 3, 363, 7936, + 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, 5, 364, 7942, 8, 364, 10, 364, + 12, 364, 7945, 9, 364, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 5, 366, + 7952, 8, 366, 10, 366, 12, 366, 7955, 9, 366, 1, 366, 3, 366, 7958, 8, + 366, 1, 366, 1, 366, 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, 3, + 368, 7977, 8, 368, 1, 369, 1, 369, 1, 369, 3, 369, 7982, 8, 369, 1, 369, + 1, 369, 1, 370, 1, 370, 1, 370, 3, 370, 7989, 8, 370, 1, 370, 1, 370, 1, + 371, 1, 371, 1, 371, 3, 371, 7996, 8, 371, 1, 371, 1, 371, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 8070, 8, 372, 1, 373, 1, + 373, 1, 373, 1, 373, 1, 373, 3, 373, 8077, 8, 373, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8086, 8, 374, 1, 374, 1, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8095, 8, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 5, 374, 8101, 8, 374, 10, 374, 12, 374, 8104, 9, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 3, 374, 8110, 8, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 3, 374, 8117, 8, 374, 1, 374, 5, 374, 8120, 8, 374, 10, + 374, 12, 374, 8123, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8129, + 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8136, 8, 374, 1, + 374, 5, 374, 8139, 8, 374, 10, 374, 12, 374, 8142, 9, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 3, 374, 8148, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, + 374, 3, 374, 8155, 8, 374, 1, 374, 5, 374, 8158, 8, 374, 10, 374, 12, 374, + 8161, 9, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8167, 8, 374, 1, + 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8174, 8, 374, 1, 374, 5, 374, + 8177, 8, 374, 10, 374, 12, 374, 8180, 9, 374, 1, 374, 1, 374, 1, 374, 1, + 374, 3, 374, 8186, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, + 8193, 8, 374, 1, 374, 5, 374, 8196, 8, 374, 10, 374, 12, 374, 8199, 9, + 374, 3, 374, 8201, 8, 374, 1, 374, 3, 374, 8204, 8, 374, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 3, 375, 8211, 8, 375, 1, 375, 1, 375, 3, 375, 8215, + 8, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 3, 376, + 8224, 8, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 5, + 377, 8233, 8, 377, 10, 377, 12, 377, 8236, 9, 377, 1, 377, 1, 377, 1, 377, + 1, 377, 1, 377, 1, 377, 3, 377, 8244, 8, 377, 1, 377, 1, 377, 3, 377, 8248, + 8, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, 8255, 8, 377, 3, + 377, 8257, 8, 377, 1, 378, 1, 378, 1, 378, 5, 378, 8262, 8, 378, 10, 378, + 12, 378, 8265, 9, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, + 8272, 8, 379, 1, 379, 1, 379, 1, 379, 3, 379, 8277, 8, 379, 1, 379, 1, + 379, 3, 379, 8281, 8, 379, 1, 380, 1, 380, 1, 380, 3, 380, 8286, 8, 380, + 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 8293, 8, 380, 3, 380, 8295, + 8, 380, 1, 380, 1, 380, 3, 380, 8299, 8, 380, 1, 380, 3, 380, 8302, 8, + 380, 1, 380, 3, 380, 8305, 8, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, + 1, 382, 1, 382, 3, 382, 8314, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, + 382, 8320, 8, 382, 3, 382, 8322, 8, 382, 4, 382, 8324, 8, 382, 11, 382, + 12, 382, 8325, 1, 382, 1, 382, 3, 382, 8330, 8, 382, 1, 382, 1, 382, 1, + 382, 3, 382, 8335, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8340, 8, 382, + 5, 382, 8342, 8, 382, 10, 382, 12, 382, 8345, 9, 382, 1, 382, 1, 382, 1, + 382, 3, 382, 8350, 8, 382, 1, 382, 1, 382, 1, 382, 3, 382, 8355, 8, 382, + 1, 382, 1, 382, 1, 382, 3, 382, 8360, 8, 382, 1, 382, 3, 382, 8363, 8, + 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 3, 384, 8372, + 8, 384, 1, 384, 3, 384, 8375, 8, 384, 1, 384, 3, 384, 8378, 8, 384, 1, + 385, 1, 385, 1, 385, 1, 385, 3, 385, 8384, 8, 385, 1, 385, 1, 385, 1, 385, + 1, 386, 1, 386, 3, 386, 8391, 8, 386, 1, 386, 1, 386, 1, 386, 3, 386, 8396, + 8, 386, 5, 386, 8398, 8, 386, 10, 386, 12, 386, 8401, 9, 386, 1, 387, 1, + 387, 1, 387, 3, 387, 8406, 8, 387, 3, 387, 8408, 8, 387, 1, 387, 1, 387, + 1, 387, 1, 387, 3, 387, 8414, 8, 387, 3, 387, 8416, 8, 387, 5, 387, 8418, + 8, 387, 10, 387, 12, 387, 8421, 9, 387, 1, 387, 1, 387, 1, 387, 1, 387, + 1, 387, 1, 387, 3, 387, 8429, 8, 387, 1, 388, 1, 388, 1, 388, 1, 388, 3, + 388, 8435, 8, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 5, 388, 8442, + 8, 388, 10, 388, 12, 388, 8445, 9, 388, 1, 388, 1, 388, 1, 388, 1, 388, + 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8456, 8, 388, 1, 388, 1, + 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8464, 8, 388, 1, 388, 1, 388, + 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8473, 8, 388, 1, 388, 3, + 388, 8476, 8, 388, 1, 389, 1, 389, 1, 389, 5, 389, 8481, 8, 389, 10, 389, + 12, 389, 8484, 9, 389, 1, 389, 3, 389, 8487, 8, 389, 1, 389, 1, 389, 1, + 389, 1, 389, 5, 389, 8493, 8, 389, 10, 389, 12, 389, 8496, 9, 389, 1, 390, + 1, 390, 1, 390, 1, 390, 3, 390, 8502, 8, 390, 1, 390, 1, 390, 1, 391, 1, + 391, 1, 391, 1, 391, 4, 391, 8510, 8, 391, 11, 391, 12, 391, 8511, 1, 391, + 1, 391, 1, 391, 4, 391, 8517, 8, 391, 11, 391, 12, 391, 8518, 1, 392, 1, + 392, 1, 392, 3, 392, 8524, 8, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, + 3, 392, 8531, 8, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 394, 1, + 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8547, + 8, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8554, 8, 395, 1, + 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8564, + 8, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 4, 395, 8571, 8, 395, 11, + 395, 12, 395, 8572, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, + 396, 3, 396, 8582, 8, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 3, 397, 8591, 8, 397, 1, 397, 5, 397, 8594, 8, 397, 10, 397, 12, + 397, 8597, 9, 397, 1, 397, 1, 397, 3, 397, 8601, 8, 397, 1, 397, 3, 397, + 8604, 8, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 8612, + 8, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, + 1, 400, 3, 400, 8623, 8, 400, 1, 400, 1, 400, 3, 400, 8627, 8, 400, 1, + 400, 3, 400, 8630, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, + 3, 400, 8638, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8644, 8, + 400, 3, 400, 8646, 8, 400, 1, 400, 1, 400, 1, 400, 3, 400, 8651, 8, 400, + 1, 400, 3, 400, 8654, 8, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, + 400, 8661, 8, 400, 1, 400, 1, 400, 3, 400, 8665, 8, 400, 1, 400, 4, 400, + 8668, 8, 400, 11, 400, 12, 400, 8669, 1, 400, 3, 400, 8673, 8, 400, 1, + 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, + 400, 1, 400, 3, 400, 8686, 8, 400, 1, 400, 1, 400, 3, 400, 8690, 8, 400, + 1, 401, 1, 401, 1, 401, 3, 401, 8695, 8, 401, 1, 401, 3, 401, 8698, 8, + 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 3, + 402, 8708, 8, 402, 1, 402, 1, 402, 3, 402, 8712, 8, 402, 1, 402, 1, 402, + 3, 402, 8716, 8, 402, 1, 403, 1, 403, 1, 403, 3, 403, 8721, 8, 403, 1, + 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 406, 1, + 406, 1, 406, 1, 406, 1, 407, 1, 407, 3, 407, 8737, 8, 407, 1, 408, 1, 408, + 1, 408, 3, 408, 8742, 8, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, + 409, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, 8754, 8, 409, 4, 409, 8756, + 8, 409, 11, 409, 12, 409, 8757, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, + 8764, 8, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, + 409, 1, 409, 1, 409, 1, 409, 5, 409, 8777, 8, 409, 10, 409, 12, 409, 8780, + 9, 409, 3, 409, 8782, 8, 409, 3, 409, 8784, 8, 409, 3, 409, 8786, 8, 409, + 4, 409, 8788, 8, 409, 11, 409, 12, 409, 8789, 1, 409, 3, 409, 8793, 8, + 409, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, + 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 5, 410, 8811, + 8, 410, 10, 410, 12, 410, 8814, 9, 410, 1, 410, 1, 410, 3, 410, 8818, 8, + 410, 1, 410, 1, 410, 1, 410, 3, 410, 8823, 8, 410, 1, 411, 1, 411, 1, 411, + 1, 411, 1, 411, 1, 411, 1, 411, 4, 411, 8832, 8, 411, 11, 411, 12, 411, + 8833, 1, 411, 3, 411, 8837, 8, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, + 412, 1, 412, 1, 412, 1, 412, 4, 412, 8847, 8, 412, 11, 412, 12, 412, 8848, + 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 4, 413, 8856, 8, 413, 11, 413, + 12, 413, 8857, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, + 4, 414, 8867, 8, 414, 11, 414, 12, 414, 8868, 1, 415, 1, 415, 1, 415, 1, + 415, 1, 415, 5, 415, 8876, 8, 415, 10, 415, 12, 415, 8879, 9, 415, 1, 415, + 1, 415, 3, 415, 8883, 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, 1, 416, 1, 416, 1, 416, 1, 416, 5, 416, 8905, 8, 416, 10, + 416, 12, 416, 8908, 9, 416, 1, 416, 1, 416, 3, 416, 8912, 8, 416, 1, 416, + 1, 416, 1, 416, 1, 416, 3, 416, 8918, 8, 416, 3, 416, 8920, 8, 416, 1, + 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 3, 418, 8928, 8, 418, 1, 418, + 3, 418, 8931, 8, 418, 1, 418, 3, 418, 8934, 8, 418, 1, 418, 3, 418, 8937, + 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8943, 8, 418, 1, 418, 1, + 418, 1, 418, 1, 418, 3, 418, 8949, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, + 3, 418, 8955, 8, 418, 1, 418, 1, 418, 3, 418, 8959, 8, 418, 3, 418, 8961, + 8, 418, 1, 418, 3, 418, 8964, 8, 418, 1, 418, 1, 418, 1, 418, 3, 418, 8969, + 8, 418, 1, 418, 1, 418, 3, 418, 8973, 8, 418, 1, 418, 1, 418, 1, 418, 3, + 418, 8978, 8, 418, 1, 418, 3, 418, 8981, 8, 418, 1, 419, 1, 419, 1, 419, + 3, 419, 8986, 8, 419, 1, 419, 3, 419, 8989, 8, 419, 1, 420, 1, 420, 1, + 420, 3, 420, 8994, 8, 420, 1, 421, 1, 421, 3, 421, 8998, 8, 421, 1, 421, + 1, 421, 5, 421, 9002, 8, 421, 10, 421, 12, 421, 9005, 9, 421, 1, 421, 3, + 421, 9008, 8, 421, 4, 421, 9010, 8, 421, 11, 421, 12, 421, 9011, 1, 421, + 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 9020, 8, 422, 1, 422, 1, + 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 5, 422, 9031, + 8, 422, 10, 422, 12, 422, 9034, 9, 422, 1, 422, 3, 422, 9037, 8, 422, 1, + 422, 1, 422, 1, 422, 1, 422, 3, 422, 9043, 8, 422, 1, 422, 3, 422, 9046, + 8, 422, 1, 422, 1, 422, 3, 422, 9050, 8, 422, 1, 422, 1, 422, 1, 422, 3, + 422, 9055, 8, 422, 4, 422, 9057, 8, 422, 11, 422, 12, 422, 9058, 1, 422, + 1, 422, 5, 422, 9063, 8, 422, 10, 422, 12, 422, 9066, 9, 422, 1, 423, 1, + 423, 3, 423, 9070, 8, 423, 1, 423, 3, 423, 9073, 8, 423, 1, 423, 1, 423, + 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 9081, 8, 423, 1, 423, 3, 423, 9084, + 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, + 9093, 8, 424, 1, 424, 1, 424, 3, 424, 9097, 8, 424, 3, 424, 9099, 8, 424, + 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, + 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, + 9118, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 9124, 8, 425, 1, + 425, 4, 425, 9127, 8, 425, 11, 425, 12, 425, 9128, 1, 425, 1, 425, 1, 425, + 3, 425, 9134, 8, 425, 3, 425, 9136, 8, 425, 1, 426, 1, 426, 3, 426, 9140, + 8, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 5, 426, 9147, 8, 426, 10, + 426, 12, 426, 9150, 9, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, + 426, 1, 426, 1, 426, 5, 426, 9160, 8, 426, 10, 426, 12, 426, 9163, 9, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, + 9173, 8, 426, 1, 426, 3, 426, 9176, 8, 426, 1, 426, 3, 426, 9179, 8, 426, + 1, 427, 3, 427, 9182, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, + 427, 1, 427, 4, 427, 9191, 8, 427, 11, 427, 12, 427, 9192, 1, 428, 1, 428, + 1, 428, 3, 428, 9198, 8, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 428, 1, 428, 1, 428, 5, 428, 9208, 8, 428, 10, 428, 12, 428, 9211, 9, 428, + 1, 428, 1, 428, 3, 428, 9215, 8, 428, 1, 429, 1, 429, 3, 429, 9219, 8, + 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9227, 8, 429, + 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9234, 8, 429, 1, 429, 1, + 429, 1, 429, 3, 429, 9239, 8, 429, 1, 429, 1, 429, 1, 429, 3, 429, 9244, + 8, 429, 1, 430, 1, 430, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, + 1, 432, 3, 432, 9255, 8, 432, 1, 432, 3, 432, 9258, 8, 432, 1, 432, 1, + 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 3, + 432, 9270, 8, 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, 3, 432, 9285, 8, 432, 1, + 433, 1, 433, 1, 433, 3, 433, 9290, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, + 3, 433, 9296, 8, 433, 1, 433, 1, 433, 3, 433, 9300, 8, 433, 1, 433, 1, + 433, 1, 433, 1, 433, 3, 433, 9306, 8, 433, 1, 433, 1, 433, 3, 433, 9310, + 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 5, 433, 9317, 8, 433, 10, + 433, 12, 433, 9320, 9, 433, 1, 433, 1, 433, 1, 433, 1, 433, 5, 433, 9326, + 8, 433, 10, 433, 12, 433, 9329, 9, 433, 1, 433, 1, 433, 3, 433, 9333, 8, + 433, 1, 434, 1, 434, 3, 434, 9337, 8, 434, 1, 434, 1, 434, 3, 434, 9341, + 8, 434, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 9347, 8, 435, 1, 436, 1, + 436, 1, 437, 1, 437, 1, 437, 3, 437, 9354, 8, 437, 1, 437, 1, 437, 1, 437, + 1, 437, 3, 437, 9360, 8, 437, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, + 440, 1, 440, 3, 440, 9369, 8, 440, 1, 440, 1, 440, 1, 440, 3, 440, 9374, + 8, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 9381, 8, 441, 1, + 441, 3, 441, 9384, 8, 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, 441, 1, 441, 1, 441, + 5, 441, 9401, 8, 441, 10, 441, 12, 441, 9404, 9, 441, 1, 442, 1, 442, 1, + 442, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, + 444, 3, 444, 9418, 8, 444, 3, 444, 9420, 8, 444, 1, 445, 1, 445, 1, 445, + 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 3, 446, + 9433, 8, 446, 1, 446, 3, 446, 9436, 8, 446, 1, 446, 3, 446, 9439, 8, 446, + 1, 446, 3, 446, 9442, 8, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, + 447, 3, 447, 9450, 8, 447, 1, 447, 3, 447, 9453, 8, 447, 1, 447, 3, 447, + 9456, 8, 447, 1, 447, 3, 447, 9459, 8, 447, 1, 448, 1, 448, 1, 448, 1, + 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 3, 449, 9471, 8, 449, + 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 5, 449, 9480, 8, + 449, 10, 449, 12, 449, 9483, 9, 449, 3, 449, 9485, 8, 449, 1, 449, 4, 449, + 9488, 8, 449, 11, 449, 12, 449, 9489, 1, 449, 1, 449, 3, 449, 9494, 8, + 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 9502, 8, 450, + 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, + 1, 450, 1, 450, 3, 450, 9515, 8, 450, 1, 451, 1, 451, 3, 451, 9519, 8, + 451, 1, 451, 1, 451, 3, 451, 9523, 8, 451, 1, 452, 1, 452, 3, 452, 9527, + 8, 452, 1, 452, 3, 452, 9530, 8, 452, 1, 452, 3, 452, 9533, 8, 452, 1, + 452, 3, 452, 9536, 8, 452, 1, 452, 3, 452, 9539, 8, 452, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 9549, 8, 453, 1, + 453, 3, 453, 9552, 8, 453, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 3, 455, 9561, 8, 455, 1, 456, 1, 456, 3, 456, 9565, 8, 456, 1, + 456, 1, 456, 1, 456, 1, 456, 5, 456, 9571, 8, 456, 10, 456, 12, 456, 9574, + 9, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 5, 456, 9584, 8, 456, 10, 456, 12, 456, 9587, 9, 456, 3, 456, 9589, 8, + 456, 3, 456, 9591, 8, 456, 1, 456, 1, 456, 3, 456, 9595, 8, 456, 1, 457, + 1, 457, 3, 457, 9599, 8, 457, 1, 457, 1, 457, 1, 458, 1, 458, 3, 458, 9605, + 8, 458, 1, 458, 1, 458, 1, 459, 3, 459, 9610, 8, 459, 1, 459, 1, 459, 3, + 459, 9614, 8, 459, 1, 459, 3, 459, 9617, 8, 459, 1, 459, 3, 459, 9620, + 8, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 5, 460, 9627, 8, 460, 10, + 460, 12, 460, 9630, 9, 460, 1, 460, 1, 460, 3, 460, 9634, 8, 460, 1, 460, + 1, 460, 3, 460, 9638, 8, 460, 1, 460, 1, 460, 3, 460, 9642, 8, 460, 1, + 460, 3, 460, 9645, 8, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 3, 461, + 9652, 8, 461, 1, 461, 3, 461, 9655, 8, 461, 3, 461, 9657, 8, 461, 1, 462, + 1, 462, 1, 462, 3, 462, 9662, 8, 462, 1, 463, 1, 463, 1, 463, 1, 464, 1, + 464, 1, 464, 1, 464, 3, 464, 9671, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, + 3, 464, 9677, 8, 464, 1, 464, 3, 464, 9680, 8, 464, 3, 464, 9682, 8, 464, + 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, 5, 466, 9697, 8, 466, 10, 466, 12, 466, + 9700, 9, 466, 1, 466, 1, 466, 1, 466, 5, 466, 9705, 8, 466, 10, 466, 12, + 466, 9708, 9, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 3, 466, + 9716, 8, 466, 1, 466, 3, 466, 9719, 8, 466, 1, 466, 1, 466, 1, 466, 3, + 466, 9724, 8, 466, 1, 466, 3, 466, 9727, 8, 466, 1, 466, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 1, 466, 3, 466, 9736, 8, 466, 1, 467, 1, 467, 1, + 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, + 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 9756, 8, 468, + 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 9762, 8, 468, 1, 468, 1, 468, 1, + 468, 4, 468, 9767, 8, 468, 11, 468, 12, 468, 9768, 1, 469, 1, 469, 1, 470, + 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 3, 470, 9779, 8, 470, 1, 470, 1, + 470, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 9788, 8, 471, 1, 471, + 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, + 3, 471, 9800, 8, 471, 1, 471, 3, 471, 9803, 8, 471, 1, 471, 3, 471, 9806, + 8, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, + 3, 473, 9816, 8, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, + 474, 3, 474, 9825, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 5, 474, 9831, + 8, 474, 10, 474, 12, 474, 9834, 9, 474, 1, 474, 1, 474, 3, 474, 9838, 8, + 474, 1, 474, 1, 474, 1, 474, 1, 474, 5, 474, 9844, 8, 474, 10, 474, 12, + 474, 9847, 9, 474, 1, 474, 1, 474, 3, 474, 9851, 8, 474, 1, 474, 3, 474, + 9854, 8, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, + 475, 1, 475, 1, 475, 1, 475, 4, 475, 9867, 8, 475, 11, 475, 12, 475, 9868, + 3, 475, 9871, 8, 475, 1, 475, 3, 475, 9874, 8, 475, 1, 475, 1, 475, 3, + 475, 9878, 8, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 3, 475, 9888, 8, 475, 5, 475, 9890, 8, 475, 10, 475, 12, 475, 9893, + 9, 475, 1, 475, 1, 475, 3, 475, 9897, 8, 475, 1, 475, 4, 475, 9900, 8, + 475, 11, 475, 12, 475, 9901, 1, 475, 1, 475, 3, 475, 9906, 8, 475, 3, 475, + 9908, 8, 475, 1, 475, 3, 475, 9911, 8, 475, 5, 475, 9913, 8, 475, 10, 475, + 12, 475, 9916, 9, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, + 1, 477, 3, 477, 9925, 8, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, + 478, 1, 478, 1, 478, 3, 478, 9935, 8, 478, 1, 478, 3, 478, 9938, 8, 478, + 1, 478, 3, 478, 9941, 8, 478, 1, 478, 1, 478, 3, 478, 9945, 8, 478, 1, + 478, 1, 478, 3, 478, 9949, 8, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 3, 479, 9962, 8, 479, 1, + 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 3, 481, 9971, 8, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 3, 481, 9982, 8, 481, 3, 481, 9984, 8, 481, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 4, 482, 9995, 8, 482, 11, + 482, 12, 482, 9996, 1, 483, 1, 483, 1, 483, 3, 483, 10002, 8, 483, 1, 484, + 1, 484, 1, 484, 3, 484, 10007, 8, 484, 1, 485, 1, 485, 1, 485, 5, 485, + 10012, 8, 485, 10, 485, 12, 485, 10015, 9, 485, 1, 486, 1, 486, 1, 486, + 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, + 1, 488, 1, 488, 1, 488, 3, 488, 10032, 8, 488, 1, 489, 1, 489, 1, 489, + 1, 489, 3, 489, 10038, 8, 489, 1, 490, 1, 490, 1, 490, 3, 490, 10043, 8, + 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 5, 490, 10051, 8, + 490, 10, 490, 12, 490, 10054, 9, 490, 1, 490, 1, 490, 1, 490, 3, 490, 10059, + 8, 490, 1, 491, 1, 491, 1, 491, 1, 491, 5, 491, 10065, 8, 491, 10, 491, + 12, 491, 10068, 9, 491, 1, 491, 1, 491, 1, 491, 3, 491, 10073, 8, 491, + 1, 491, 1, 491, 3, 491, 10077, 8, 491, 1, 491, 3, 491, 10080, 8, 491, 1, + 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, + 493, 3, 493, 10092, 8, 493, 1, 494, 1, 494, 1, 494, 5, 494, 10097, 8, 494, + 10, 494, 12, 494, 10100, 9, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, + 5, 495, 10107, 8, 495, 10, 495, 12, 495, 10110, 9, 495, 1, 495, 1, 495, + 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, + 1, 496, 3, 496, 10124, 8, 496, 1, 496, 1, 496, 1, 496, 3, 496, 10129, 8, + 496, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, + 498, 5, 498, 10140, 8, 498, 10, 498, 12, 498, 10143, 9, 498, 1, 498, 1, + 498, 3, 498, 10147, 8, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, + 499, 3, 499, 10155, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10160, 8, 499, + 1, 499, 1, 499, 1, 499, 3, 499, 10165, 8, 499, 1, 499, 1, 499, 1, 499, + 3, 499, 10170, 8, 499, 5, 499, 10172, 8, 499, 10, 499, 12, 499, 10175, + 9, 499, 1, 499, 1, 499, 3, 499, 10179, 8, 499, 1, 499, 1, 499, 1, 499, + 1, 499, 1, 499, 1, 499, 3, 499, 10187, 8, 499, 1, 499, 3, 499, 10190, 8, + 499, 1, 499, 3, 499, 10193, 8, 499, 1, 499, 3, 499, 10196, 8, 499, 1, 499, + 3, 499, 10199, 8, 499, 3, 499, 10201, 8, 499, 1, 499, 1, 499, 1, 499, 1, + 499, 1, 499, 4, 499, 10208, 8, 499, 11, 499, 12, 499, 10209, 5, 499, 10212, + 8, 499, 10, 499, 12, 499, 10215, 9, 499, 1, 499, 1, 499, 1, 499, 3, 499, + 10220, 8, 499, 1, 499, 3, 499, 10223, 8, 499, 1, 499, 3, 499, 10226, 8, + 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10232, 8, 499, 1, 499, 3, + 499, 10235, 8, 499, 1, 499, 1, 499, 1, 499, 3, 499, 10240, 8, 499, 1, 499, + 3, 499, 10243, 8, 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, 3, 500, 10257, 8, 500, + 1, 500, 1, 500, 1, 501, 1, 501, 3, 501, 10263, 8, 501, 1, 501, 1, 501, + 3, 501, 10267, 8, 501, 1, 501, 1, 501, 3, 501, 10271, 8, 501, 1, 502, 1, + 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10282, + 8, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10289, 8, 502, + 1, 502, 1, 502, 1, 502, 3, 502, 10294, 8, 502, 1, 502, 1, 502, 1, 502, + 3, 502, 10299, 8, 502, 1, 502, 1, 502, 1, 502, 3, 502, 10304, 8, 502, 1, + 502, 1, 502, 1, 502, 4, 502, 10309, 8, 502, 11, 502, 12, 502, 10310, 3, + 502, 10313, 8, 502, 1, 503, 1, 503, 1, 503, 1, 503, 3, 503, 10319, 8, 503, + 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10325, 8, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 3, 504, 10332, 8, 504, 1, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 3, 504, 10340, 8, 504, 1, 505, 1, 505, 1, 505, + 1, 505, 1, 505, 1, 505, 3, 505, 10348, 8, 505, 1, 506, 1, 506, 1, 506, + 1, 506, 1, 506, 1, 506, 3, 506, 10356, 8, 506, 1, 506, 1, 506, 1, 506, + 1, 507, 1, 507, 1, 507, 3, 507, 10364, 8, 507, 1, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 1, 507, 3, 507, 10372, 8, 507, 1, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 3, 507, 10379, 8, 507, 1, 508, 1, 508, 1, 509, 1, 509, + 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 10390, 8, 509, 1, 509, + 1, 509, 1, 509, 1, 509, 3, 509, 10396, 8, 509, 5, 509, 10398, 8, 509, 10, + 509, 12, 509, 10401, 9, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, + 509, 1, 509, 1, 509, 1, 509, 3, 509, 10412, 8, 509, 1, 509, 1, 509, 1, + 509, 1, 509, 1, 509, 3, 509, 10419, 8, 509, 5, 509, 10421, 8, 509, 10, + 509, 12, 509, 10424, 9, 509, 1, 509, 3, 509, 10427, 8, 509, 1, 509, 3, + 509, 10430, 8, 509, 1, 509, 3, 509, 10433, 8, 509, 1, 510, 1, 510, 3, 510, + 10437, 8, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 4, 510, 10444, 8, + 510, 11, 510, 12, 510, 10445, 1, 510, 3, 510, 10449, 8, 510, 1, 511, 1, + 511, 1, 511, 1, 511, 1, 511, 1, 511, 3, 511, 10457, 8, 511, 3, 511, 10459, + 8, 511, 1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 10465, 8, 512, 1, 512, + 1, 512, 1, 512, 1, 512, 3, 512, 10471, 8, 512, 1, 512, 1, 512, 1, 512, + 3, 512, 10476, 8, 512, 3, 512, 10478, 8, 512, 1, 513, 1, 513, 1, 513, 1, + 513, 1, 513, 1, 513, 3, 513, 10486, 8, 513, 1, 514, 1, 514, 1, 514, 1, + 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 3, 516, 10497, 8, 516, 1, + 516, 3, 516, 10500, 8, 516, 1, 516, 1, 516, 3, 516, 10504, 8, 516, 1, 516, + 1, 516, 3, 516, 10508, 8, 516, 1, 516, 3, 516, 10511, 8, 516, 1, 516, 1, + 516, 1, 516, 3, 516, 10516, 8, 516, 1, 516, 1, 516, 3, 516, 10520, 8, 516, + 1, 517, 1, 517, 3, 517, 10524, 8, 517, 1, 517, 1, 517, 1, 517, 1, 517, + 1, 517, 1, 517, 1, 517, 3, 517, 10533, 8, 517, 1, 517, 1, 517, 1, 517, + 1, 517, 3, 517, 10539, 8, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, + 10545, 8, 517, 1, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10551, 8, 518, 1, + 518, 3, 518, 10554, 8, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, + 519, 3, 519, 10562, 8, 519, 1, 519, 1, 519, 3, 519, 10566, 8, 519, 1, 519, + 1, 519, 1, 519, 1, 519, 3, 519, 10572, 8, 519, 1, 519, 1, 519, 1, 519, + 1, 519, 3, 519, 10578, 8, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, + 10584, 8, 519, 1, 519, 1, 519, 3, 519, 10588, 8, 519, 3, 519, 10590, 8, + 519, 1, 519, 1, 519, 1, 519, 3, 519, 10595, 8, 519, 1, 519, 3, 519, 10598, + 8, 519, 1, 519, 1, 519, 3, 519, 10602, 8, 519, 1, 519, 1, 519, 3, 519, + 10606, 8, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 3, 520, + 10614, 8, 520, 1, 520, 1, 520, 3, 520, 10618, 8, 520, 1, 520, 3, 520, 10621, + 8, 520, 1, 520, 3, 520, 10624, 8, 520, 1, 520, 1, 520, 1, 520, 1, 520, + 3, 520, 10630, 8, 520, 1, 520, 3, 520, 10633, 8, 520, 1, 520, 3, 520, 10636, + 8, 520, 1, 520, 3, 520, 10639, 8, 520, 1, 520, 3, 520, 10642, 8, 520, 1, + 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, + 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 5, 521, 10659, 8, 521, 10, + 521, 12, 521, 10662, 9, 521, 1, 521, 1, 521, 1, 522, 1, 522, 3, 522, 10668, + 8, 522, 1, 522, 1, 522, 3, 522, 10672, 8, 522, 1, 522, 3, 522, 10675, 8, + 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10682, 8, 523, 1, + 523, 1, 523, 1, 523, 3, 523, 10687, 8, 523, 1, 523, 1, 523, 1, 523, 1, + 523, 1, 523, 3, 523, 10694, 8, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, + 523, 10700, 8, 523, 3, 523, 10702, 8, 523, 1, 523, 1, 523, 1, 523, 1, 523, + 3, 523, 10708, 8, 523, 1, 524, 1, 524, 3, 524, 10712, 8, 524, 1, 524, 1, + 524, 1, 524, 1, 524, 1, 524, 3, 524, 10719, 8, 524, 1, 524, 1, 524, 1, + 524, 3, 524, 10724, 8, 524, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 10730, + 8, 525, 1, 525, 1, 525, 3, 525, 10734, 8, 525, 1, 525, 1, 525, 1, 525, + 1, 525, 5, 525, 10740, 8, 525, 10, 525, 12, 525, 10743, 9, 525, 1, 525, + 1, 525, 3, 525, 10747, 8, 525, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, + 10753, 8, 525, 1, 525, 3, 525, 10756, 8, 525, 1, 525, 3, 525, 10759, 8, + 525, 1, 525, 3, 525, 10762, 8, 525, 1, 525, 3, 525, 10765, 8, 525, 1, 526, + 1, 526, 1, 527, 1, 527, 3, 527, 10771, 8, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 4, 527, 10777, 8, 527, 11, 527, 12, 527, 10778, 1, 527, 1, 527, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 3, 528, 10790, + 8, 528, 1, 529, 1, 529, 3, 529, 10794, 8, 529, 1, 529, 1, 529, 3, 529, + 10798, 8, 529, 1, 529, 1, 529, 1, 529, 5, 529, 10803, 8, 529, 10, 529, + 12, 529, 10806, 9, 529, 1, 529, 3, 529, 10809, 8, 529, 1, 529, 1, 529, + 1, 529, 3, 529, 10814, 8, 529, 1, 530, 3, 530, 10817, 8, 530, 1, 530, 1, + 530, 1, 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 5, 531, 10828, + 8, 531, 10, 531, 12, 531, 10831, 9, 531, 1, 531, 1, 531, 3, 531, 10835, + 8, 531, 1, 531, 3, 531, 10838, 8, 531, 1, 532, 4, 532, 10841, 8, 532, 11, + 532, 12, 532, 10842, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, + 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 10856, 8, 533, 1, 533, 1, + 533, 3, 533, 10860, 8, 533, 1, 534, 1, 534, 3, 534, 10864, 8, 534, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 10873, 8, 535, + 1, 536, 1, 536, 1, 536, 3, 536, 10878, 8, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 3, 536, 10886, 8, 536, 3, 536, 10888, 8, 536, 1, + 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, + 538, 1, 538, 3, 538, 10901, 8, 538, 1, 539, 1, 539, 1, 539, 3, 539, 10906, + 8, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 10914, + 8, 539, 3, 539, 10916, 8, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 540, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, + 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, + 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, + 1, 542, 1, 542, 3, 542, 10952, 8, 542, 1, 542, 1, 542, 3, 542, 10956, 8, + 542, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 3, + 545, 10966, 8, 545, 1, 545, 1, 545, 3, 545, 10970, 8, 545, 1, 545, 1, 545, + 3, 545, 10974, 8, 545, 1, 545, 3, 545, 10977, 8, 545, 1, 545, 1, 545, 1, + 545, 3, 545, 10982, 8, 545, 1, 545, 3, 545, 10985, 8, 545, 1, 546, 1, 546, + 1, 546, 3, 546, 10990, 8, 546, 1, 546, 1, 546, 1, 546, 1, 546, 5, 546, + 10996, 8, 546, 10, 546, 12, 546, 10999, 9, 546, 1, 547, 1, 547, 1, 547, + 1, 547, 3, 547, 11005, 8, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, + 1, 547, 1, 548, 1, 548, 1, 549, 1, 549, 3, 549, 11017, 8, 549, 1, 549, + 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 5, 550, 11027, + 8, 550, 10, 550, 12, 550, 11030, 9, 550, 1, 550, 1, 550, 3, 550, 11034, + 8, 550, 1, 551, 1, 551, 1, 551, 1, 551, 5, 551, 11040, 8, 551, 10, 551, + 12, 551, 11043, 9, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 553, 1, 553, + 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 11056, 8, 553, 1, 553, + 1, 553, 1, 553, 3, 553, 11061, 8, 553, 1, 554, 1, 554, 1, 554, 1, 554, + 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 11072, 8, 554, 1, 554, + 1, 554, 3, 554, 11076, 8, 554, 1, 554, 1, 554, 3, 554, 11080, 8, 554, 3, + 554, 11082, 8, 554, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 556, 1, + 556, 1, 556, 3, 556, 11092, 8, 556, 1, 557, 1, 557, 1, 557, 1, 557, 1, + 557, 1, 557, 1, 557, 1, 557, 3, 557, 11102, 8, 557, 1, 558, 1, 558, 1, + 558, 1, 558, 1, 558, 1, 558, 1, 558, 5, 558, 11111, 8, 558, 10, 558, 12, + 558, 11114, 9, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, + 558, 1, 558, 1, 558, 1, 558, 1, 558, 5, 558, 11127, 8, 558, 10, 558, 12, + 558, 11130, 9, 558, 1, 558, 1, 558, 3, 558, 11134, 8, 558, 3, 558, 11136, + 8, 558, 1, 558, 1, 558, 1, 558, 3, 558, 11141, 8, 558, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 558, 3, 558, 11148, 8, 558, 1, 558, 1, 558, 1, 558, + 5, 558, 11153, 8, 558, 10, 558, 12, 558, 11156, 9, 558, 1, 558, 1, 558, + 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, + 1, 559, 1, 559, 1, 559, 1, 559, 5, 559, 11173, 8, 559, 10, 559, 12, 559, + 11176, 9, 559, 1, 559, 1, 559, 3, 559, 11180, 8, 559, 3, 559, 11182, 8, + 559, 1, 559, 1, 559, 1, 559, 3, 559, 11187, 8, 559, 1, 559, 1, 559, 1, + 559, 1, 559, 1, 559, 3, 559, 11194, 8, 559, 1, 559, 1, 559, 1, 559, 5, + 559, 11199, 8, 559, 10, 559, 12, 559, 11202, 9, 559, 1, 559, 1, 559, 3, + 559, 11206, 8, 559, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, + 560, 5, 560, 11215, 8, 560, 10, 560, 12, 560, 11218, 9, 560, 1, 560, 1, + 560, 1, 560, 3, 560, 11223, 8, 560, 1, 561, 1, 561, 1, 561, 3, 561, 11228, + 8, 561, 1, 561, 3, 561, 11231, 8, 561, 1, 561, 1, 561, 1, 561, 3, 561, + 11236, 8, 561, 1, 561, 3, 561, 11239, 8, 561, 5, 561, 11241, 8, 561, 10, + 561, 12, 561, 11244, 9, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, + 562, 1, 562, 1, 562, 1, 562, 1, 562, 5, 562, 11256, 8, 562, 10, 562, 12, + 562, 11259, 9, 562, 1, 562, 1, 562, 3, 562, 11263, 8, 562, 1, 562, 1, 562, + 3, 562, 11267, 8, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, + 1, 562, 5, 562, 11276, 8, 562, 10, 562, 12, 562, 11279, 9, 562, 1, 562, + 1, 562, 3, 562, 11283, 8, 562, 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 5, 564, 11294, 8, 564, 10, 564, 12, 564, + 11297, 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, 11310, 8, 564, 10, 564, 12, 564, + 11313, 9, 564, 1, 564, 1, 564, 3, 564, 11317, 8, 564, 3, 564, 11319, 8, + 564, 1, 564, 1, 564, 1, 564, 3, 564, 11324, 8, 564, 1, 564, 1, 564, 1, + 564, 1, 564, 5, 564, 11330, 8, 564, 10, 564, 12, 564, 11333, 9, 564, 1, + 564, 1, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, + 565, 1, 565, 3, 565, 11346, 8, 565, 1, 565, 1, 565, 1, 565, 1, 565, 5, + 565, 11352, 8, 565, 10, 565, 12, 565, 11355, 9, 565, 1, 565, 1, 565, 1, + 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 4, 566, 11365, 8, 566, 11, + 566, 12, 566, 11366, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 11373, 8, + 566, 1, 566, 1, 566, 3, 566, 11377, 8, 566, 1, 567, 1, 567, 1, 567, 1, + 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 5, 567, 11389, 8, + 567, 10, 567, 12, 567, 11392, 9, 567, 1, 567, 1, 567, 3, 567, 11396, 8, + 567, 1, 568, 1, 568, 3, 568, 11400, 8, 568, 1, 568, 1, 568, 1, 569, 1, + 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 5, 569, 11412, 8, + 569, 10, 569, 12, 569, 11415, 9, 569, 3, 569, 11417, 8, 569, 1, 570, 1, + 570, 3, 570, 11421, 8, 570, 1, 570, 3, 570, 11424, 8, 570, 1, 570, 1, 570, + 1, 570, 1, 570, 1, 570, 5, 570, 11431, 8, 570, 10, 570, 12, 570, 11434, + 9, 570, 1, 570, 1, 570, 1, 570, 5, 570, 11439, 8, 570, 10, 570, 12, 570, + 11442, 9, 570, 1, 570, 1, 570, 1, 570, 5, 570, 11447, 8, 570, 10, 570, + 12, 570, 11450, 9, 570, 3, 570, 11452, 8, 570, 1, 570, 1, 570, 1, 570, + 3, 570, 11457, 8, 570, 3, 570, 11459, 8, 570, 1, 571, 1, 571, 3, 571, 11463, + 8, 571, 1, 571, 3, 571, 11466, 8, 571, 1, 571, 1, 571, 1, 571, 1, 571, + 1, 571, 5, 571, 11473, 8, 571, 10, 571, 12, 571, 11476, 9, 571, 1, 571, + 1, 571, 1, 571, 5, 571, 11481, 8, 571, 10, 571, 12, 571, 11484, 9, 571, + 1, 571, 1, 571, 1, 571, 5, 571, 11489, 8, 571, 10, 571, 12, 571, 11492, + 9, 571, 3, 571, 11494, 8, 571, 1, 571, 1, 571, 1, 571, 3, 571, 11499, 8, + 571, 3, 571, 11501, 8, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, + 572, 5, 572, 11509, 8, 572, 10, 572, 12, 572, 11512, 9, 572, 1, 572, 1, + 572, 1, 572, 5, 572, 11517, 8, 572, 10, 572, 12, 572, 11520, 9, 572, 1, + 572, 1, 572, 1, 572, 5, 572, 11525, 8, 572, 10, 572, 12, 572, 11528, 9, + 572, 3, 572, 11530, 8, 572, 1, 572, 1, 572, 1, 572, 3, 572, 11535, 8, 572, + 1, 573, 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 5, 574, 11546, 8, 574, 10, 574, 12, 574, 11549, 9, 574, 1, 574, 1, 574, + 3, 574, 11553, 8, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 3, 575, 11562, 8, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, + 1, 576, 1, 576, 5, 576, 11571, 8, 576, 10, 576, 12, 576, 11574, 9, 576, + 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, + 5, 576, 11585, 8, 576, 10, 576, 12, 576, 11588, 9, 576, 1, 576, 1, 576, + 3, 576, 11592, 8, 576, 1, 576, 3, 576, 11595, 8, 576, 1, 577, 1, 577, 1, + 578, 1, 578, 3, 578, 11601, 8, 578, 1, 578, 1, 578, 3, 578, 11605, 8, 578, + 1, 579, 1, 579, 3, 579, 11609, 8, 579, 1, 579, 1, 579, 3, 579, 11613, 8, + 579, 1, 580, 1, 580, 3, 580, 11617, 8, 580, 1, 580, 3, 580, 11620, 8, 580, + 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 5, 581, + 11630, 8, 581, 10, 581, 12, 581, 11633, 9, 581, 1, 581, 1, 581, 3, 581, + 11637, 8, 581, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, + 1, 583, 1, 583, 1, 583, 5, 583, 11649, 8, 583, 10, 583, 12, 583, 11652, + 9, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 5, 583, 11659, 8, 583, + 10, 583, 12, 583, 11662, 9, 583, 3, 583, 11664, 8, 583, 1, 584, 1, 584, + 1, 584, 1, 584, 1, 584, 5, 584, 11671, 8, 584, 10, 584, 12, 584, 11674, + 9, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 5, 584, 11681, 8, 584, + 10, 584, 12, 584, 11684, 9, 584, 1, 584, 3, 584, 11687, 8, 584, 1, 584, + 1, 584, 1, 585, 3, 585, 11692, 8, 585, 1, 585, 3, 585, 11695, 8, 585, 1, + 585, 3, 585, 11698, 8, 585, 1, 585, 3, 585, 11701, 8, 585, 1, 585, 3, 585, + 11704, 8, 585, 1, 585, 1, 585, 3, 585, 11708, 8, 585, 1, 585, 3, 585, 11711, + 8, 585, 1, 585, 3, 585, 11714, 8, 585, 1, 585, 1, 585, 3, 585, 11718, 8, + 585, 3, 585, 11720, 8, 585, 1, 585, 1, 585, 1, 585, 5, 585, 11725, 8, 585, + 10, 585, 12, 585, 11728, 9, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 3, 586, 11735, 8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 1, 586, 1, 586, 1, 586, 3, 586, 11746, 8, 586, 1, 586, 1, 586, 1, 586, + 4, 586, 11751, 8, 586, 11, 586, 12, 586, 11752, 1, 587, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 11762, 8, 587, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 11770, 8, 587, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 587, 3, 587, 11777, 8, 587, 1, 588, 1, 588, 3, 588, + 11781, 8, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, + 11789, 8, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11795, 8, 589, 3, + 589, 11797, 8, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11803, 8, 589, + 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 3, 589, 11811, 8, 589, + 3, 589, 11813, 8, 589, 1, 589, 3, 589, 11816, 8, 589, 1, 589, 1, 589, 1, + 589, 3, 589, 11821, 8, 589, 1, 589, 3, 589, 11824, 8, 589, 1, 590, 4, 590, + 11827, 8, 590, 11, 590, 12, 590, 11828, 1, 590, 1, 590, 3, 590, 11833, + 8, 590, 1, 590, 1, 590, 3, 590, 11837, 8, 590, 1, 590, 5, 590, 11840, 8, + 590, 10, 590, 12, 590, 11843, 9, 590, 3, 590, 11845, 8, 590, 1, 591, 1, + 591, 1, 591, 1, 591, 4, 591, 11851, 8, 591, 11, 591, 12, 591, 11852, 1, + 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 11860, 8, 592, 3, 592, 11862, + 8, 592, 1, 592, 1, 592, 3, 592, 11866, 8, 592, 1, 593, 1, 593, 1, 593, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 3, 594, 11878, + 8, 594, 3, 594, 11880, 8, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 3, 594, 11888, 8, 594, 3, 594, 11890, 8, 594, 1, 595, 1, 595, 3, + 595, 11894, 8, 595, 1, 595, 1, 595, 3, 595, 11898, 8, 595, 1, 596, 1, 596, + 3, 596, 11902, 8, 596, 1, 596, 1, 596, 3, 596, 11906, 8, 596, 1, 596, 1, + 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, + 597, 1, 597, 1, 597, 1, 597, 4, 597, 11922, 8, 597, 11, 597, 12, 597, 11923, + 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 3, 598, 11946, 8, 598, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 1, 598, 4, 598, 11955, 8, 598, 11, 598, 12, 598, 11956, + 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 600, 1, 600, 1, 600, + 1, 600, 3, 600, 11969, 8, 600, 1, 600, 3, 600, 11972, 8, 600, 1, 600, 1, + 600, 4, 600, 11976, 8, 600, 11, 600, 12, 600, 11977, 1, 601, 1, 601, 1, + 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 3, 601, 11988, 8, 601, 1, + 601, 1, 601, 1, 601, 3, 601, 11993, 8, 601, 1, 601, 3, 601, 11996, 8, 601, + 1, 601, 1, 601, 3, 601, 12000, 8, 601, 1, 601, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 601, 3, 601, 12008, 8, 601, 1, 601, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 601, 5, 601, 12016, 8, 601, 10, 601, 12, 601, 12019, 9, 601, + 1, 601, 1, 601, 3, 601, 12023, 8, 601, 1, 602, 1, 602, 1, 602, 1, 602, + 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 12035, 8, 602, + 1, 603, 1, 603, 1, 603, 3, 603, 12040, 8, 603, 1, 604, 1, 604, 1, 604, + 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 3, 604, 12052, + 8, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 3, 604, + 12061, 8, 604, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 12067, 8, 605, 1, + 605, 1, 605, 3, 605, 12071, 8, 605, 1, 605, 1, 605, 1, 605, 3, 605, 12076, + 8, 605, 1, 605, 3, 605, 12079, 8, 605, 1, 606, 1, 606, 1, 606, 1, 606, + 1, 606, 1, 606, 3, 606, 12087, 8, 606, 1, 606, 1, 606, 3, 606, 12091, 8, + 606, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 3, 608, 12098, 8, 608, 1, + 608, 1, 608, 1, 608, 1, 608, 1, 608, 3, 608, 12105, 8, 608, 1, 608, 3, + 608, 12108, 8, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 610, 3, + 610, 12116, 8, 610, 1, 610, 3, 610, 12119, 8, 610, 1, 610, 3, 610, 12122, + 8, 610, 1, 611, 1, 611, 1, 611, 3, 611, 12127, 8, 611, 1, 611, 1, 611, + 1, 611, 3, 611, 12132, 8, 611, 1, 611, 1, 611, 1, 611, 1, 611, 3, 611, + 12138, 8, 611, 3, 611, 12140, 8, 611, 1, 611, 3, 611, 12143, 8, 611, 1, + 612, 1, 612, 1, 613, 1, 613, 1, 613, 3, 613, 12150, 8, 613, 1, 613, 1, + 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 4, 613, 12159, 8, 613, 11, + 613, 12, 613, 12160, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 3, 613, 12168, + 8, 613, 3, 613, 12170, 8, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, + 5, 613, 12177, 8, 613, 10, 613, 12, 613, 12180, 9, 613, 1, 613, 1, 613, + 3, 613, 12184, 8, 613, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, + 1, 614, 1, 614, 1, 614, 1, 614, 5, 614, 12196, 8, 614, 10, 614, 12, 614, + 12199, 9, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 3, 614, + 12207, 8, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 3, 615, 12218, 8, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 5, 615, 12225, 8, 615, 10, 615, 12, 615, 12228, 9, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12237, 8, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12245, 8, 615, + 1, 616, 1, 616, 3, 616, 12249, 8, 616, 1, 616, 1, 616, 3, 616, 12253, 8, + 616, 1, 616, 3, 616, 12256, 8, 616, 1, 617, 1, 617, 1, 617, 5, 617, 12261, + 8, 617, 10, 617, 12, 617, 12264, 9, 617, 1, 618, 1, 618, 1, 618, 1, 618, + 1, 618, 5, 618, 12271, 8, 618, 10, 618, 12, 618, 12274, 9, 618, 1, 619, + 3, 619, 12277, 8, 619, 1, 619, 1, 619, 3, 619, 12281, 8, 619, 1, 619, 3, + 619, 12284, 8, 619, 1, 619, 3, 619, 12287, 8, 619, 1, 619, 1, 619, 1, 619, + 3, 619, 12292, 8, 619, 1, 619, 3, 619, 12295, 8, 619, 1, 619, 1, 619, 1, + 620, 3, 620, 12300, 8, 620, 1, 620, 1, 620, 3, 620, 12304, 8, 620, 1, 620, + 3, 620, 12307, 8, 620, 1, 620, 3, 620, 12310, 8, 620, 1, 620, 1, 620, 1, + 620, 1, 620, 1, 620, 3, 620, 12317, 8, 620, 1, 620, 1, 620, 1, 620, 1, + 620, 1, 620, 3, 620, 12324, 8, 620, 1, 620, 3, 620, 12327, 8, 620, 3, 620, + 12329, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12334, 8, 620, 1, 620, 1, + 620, 3, 620, 12338, 8, 620, 1, 620, 3, 620, 12341, 8, 620, 1, 620, 3, 620, + 12344, 8, 620, 1, 620, 1, 620, 1, 620, 3, 620, 12349, 8, 620, 1, 620, 3, + 620, 12352, 8, 620, 1, 620, 3, 620, 12355, 8, 620, 1, 620, 1, 620, 1, 620, + 3, 620, 12360, 8, 620, 1, 620, 1, 620, 3, 620, 12364, 8, 620, 1, 620, 1, + 620, 1, 620, 3, 620, 12369, 8, 620, 1, 620, 3, 620, 12372, 8, 620, 1, 620, + 3, 620, 12375, 8, 620, 1, 620, 3, 620, 12378, 8, 620, 1, 620, 1, 620, 1, + 620, 1, 620, 3, 620, 12384, 8, 620, 1, 620, 1, 620, 3, 620, 12388, 8, 620, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 12395, 8, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 3, 621, 12401, 8, 621, 1, 621, 3, 621, 12404, 8, + 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 12411, 8, 621, 3, + 621, 12413, 8, 621, 3, 621, 12415, 8, 621, 1, 622, 1, 622, 1, 623, 3, 623, + 12420, 8, 623, 1, 623, 1, 623, 1, 623, 1, 623, 3, 623, 12426, 8, 623, 1, + 623, 1, 623, 3, 623, 12430, 8, 623, 1, 623, 1, 623, 1, 623, 1, 623, 3, + 623, 12436, 8, 623, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, + 625, 1, 625, 1, 625, 3, 625, 12447, 8, 625, 1, 625, 1, 625, 1, 625, 1, + 625, 3, 625, 12453, 8, 625, 1, 625, 1, 625, 1, 625, 5, 625, 12458, 8, 625, + 10, 625, 12, 625, 12461, 9, 625, 1, 626, 1, 626, 1, 626, 1, 627, 1, 627, + 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 12474, 8, 627, + 1, 627, 1, 627, 3, 627, 12478, 8, 627, 1, 627, 1, 627, 3, 627, 12482, 8, + 627, 1, 627, 1, 627, 1, 627, 5, 627, 12487, 8, 627, 10, 627, 12, 627, 12490, + 9, 627, 1, 627, 3, 627, 12493, 8, 627, 3, 627, 12495, 8, 627, 1, 627, 5, + 627, 12498, 8, 627, 10, 627, 12, 627, 12501, 9, 627, 1, 627, 4, 627, 12504, + 8, 627, 11, 627, 12, 627, 12505, 3, 627, 12508, 8, 627, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 12534, 8, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 3, 628, 12547, 8, 628, 1, 629, 1, 629, 1, 629, 3, 629, 12552, 8, 629, 1, + 629, 3, 629, 12555, 8, 629, 1, 630, 1, 630, 3, 630, 12559, 8, 630, 1, 630, + 1, 630, 1, 630, 3, 630, 12564, 8, 630, 1, 630, 3, 630, 12567, 8, 630, 1, + 630, 3, 630, 12570, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, + 630, 12577, 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12584, + 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12592, + 8, 630, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12598, 8, 630, 1, 630, + 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 12605, 8, 630, 1, 630, 3, 630, + 12608, 8, 630, 1, 630, 3, 630, 12611, 8, 630, 1, 630, 3, 630, 12614, 8, + 630, 1, 630, 3, 630, 12617, 8, 630, 1, 631, 1, 631, 1, 631, 1, 631, 1, + 631, 3, 631, 12624, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12630, + 8, 631, 1, 631, 3, 631, 12633, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, + 1, 631, 1, 631, 3, 631, 12641, 8, 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, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, + 1, 631, 3, 631, 12675, 8, 631, 1, 632, 1, 632, 1, 632, 5, 632, 12680, 8, + 632, 10, 632, 12, 632, 12683, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, + 632, 1, 632, 1, 632, 5, 632, 12692, 8, 632, 10, 632, 12, 632, 12695, 9, + 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12703, 8, + 632, 1, 632, 1, 632, 1, 632, 5, 632, 12708, 8, 632, 10, 632, 12, 632, 12711, + 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 12725, 8, 632, 1, 632, 1, 632, + 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 3, 632, 12739, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 1, 632, 3, 632, 12748, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 5, 632, + 12762, 8, 632, 10, 632, 12, 632, 12765, 9, 632, 3, 632, 12767, 8, 632, + 3, 632, 12769, 8, 632, 1, 632, 3, 632, 12772, 8, 632, 1, 633, 1, 633, 1, + 633, 1, 633, 5, 633, 12778, 8, 633, 10, 633, 12, 633, 12781, 9, 633, 1, + 633, 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, + 634, 1, 634, 5, 634, 12794, 8, 634, 10, 634, 12, 634, 12797, 9, 634, 1, + 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 5, 634, 12805, 8, 634, 10, + 634, 12, 634, 12808, 9, 634, 1, 634, 1, 634, 3, 634, 12812, 8, 634, 1, + 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 12820, 8, 635, 1, + 635, 1, 635, 3, 635, 12824, 8, 635, 1, 635, 1, 635, 1, 635, 3, 635, 12829, + 8, 635, 1, 636, 3, 636, 12832, 8, 636, 1, 636, 1, 636, 1, 636, 1, 637, + 1, 637, 1, 637, 3, 637, 12840, 8, 637, 1, 637, 1, 637, 1, 637, 3, 637, + 12845, 8, 637, 1, 638, 1, 638, 3, 638, 12849, 8, 638, 1, 639, 1, 639, 1, + 639, 1, 639, 1, 639, 3, 639, 12856, 8, 639, 1, 639, 1, 639, 1, 639, 1, + 639, 1, 639, 3, 639, 12863, 8, 639, 5, 639, 12865, 8, 639, 10, 639, 12, + 639, 12868, 9, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, + 639, 12876, 8, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 3, + 639, 12884, 8, 639, 5, 639, 12886, 8, 639, 10, 639, 12, 639, 12889, 9, + 639, 3, 639, 12891, 8, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, + 640, 3, 640, 12899, 8, 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 12905, + 8, 640, 5, 640, 12907, 8, 640, 10, 640, 12, 640, 12910, 9, 640, 1, 640, + 1, 640, 3, 640, 12914, 8, 640, 1, 641, 1, 641, 1, 641, 3, 641, 12919, 8, + 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 3, 641, 12926, 8, 641, 1, + 641, 1, 641, 3, 641, 12930, 8, 641, 4, 641, 12932, 8, 641, 11, 641, 12, + 641, 12933, 1, 641, 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, + 642, 1, 642, 1, 642, 1, 642, 1, 642, 4, 642, 12948, 8, 642, 11, 642, 12, + 642, 12949, 1, 642, 3, 642, 12953, 8, 642, 1, 643, 1, 643, 1, 643, 1, 643, + 3, 643, 12959, 8, 643, 1, 644, 1, 644, 1, 644, 3, 644, 12964, 8, 644, 1, + 644, 3, 644, 12967, 8, 644, 1, 644, 3, 644, 12970, 8, 644, 1, 645, 3, 645, + 12973, 8, 645, 1, 645, 1, 645, 1, 646, 1, 646, 3, 646, 12979, 8, 646, 1, + 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, + 647, 1, 647, 1, 647, 3, 647, 12993, 8, 647, 3, 647, 12995, 8, 647, 1, 647, + 1, 647, 3, 647, 12999, 8, 647, 1, 647, 3, 647, 13002, 8, 647, 1, 647, 3, + 647, 13005, 8, 647, 1, 647, 3, 647, 13008, 8, 647, 1, 648, 1, 648, 1, 648, + 1, 648, 1, 648, 3, 648, 13015, 8, 648, 1, 648, 1, 648, 3, 648, 13019, 8, + 648, 1, 648, 1, 648, 3, 648, 13023, 8, 648, 1, 648, 3, 648, 13026, 8, 648, + 1, 648, 1, 648, 3, 648, 13030, 8, 648, 1, 648, 3, 648, 13033, 8, 648, 1, + 649, 1, 649, 1, 649, 1, 649, 1, 649, 3, 649, 13040, 8, 649, 1, 649, 1, + 649, 3, 649, 13044, 8, 649, 3, 649, 13046, 8, 649, 1, 649, 3, 649, 13049, + 8, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 3, 650, 13056, 8, 650, + 1, 651, 1, 651, 1, 651, 1, 651, 3, 651, 13062, 8, 651, 1, 651, 1, 651, + 3, 651, 13066, 8, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 3, 652, + 13073, 8, 652, 1, 652, 1, 652, 3, 652, 13077, 8, 652, 1, 653, 1, 653, 1, + 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 654, 1, 654, 1, 655, 1, 655, 1, + 656, 1, 656, 3, 656, 13092, 8, 656, 1, 656, 1, 656, 1, 656, 1, 656, 3, + 656, 13098, 8, 656, 1, 656, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 3, + 657, 13106, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, + 657, 3, 657, 13115, 8, 657, 1, 657, 1, 657, 1, 657, 3, 657, 13120, 8, 657, + 1, 657, 1, 657, 1, 657, 3, 657, 13125, 8, 657, 1, 657, 1, 657, 1, 657, + 1, 657, 3, 657, 13131, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, + 3, 657, 13138, 8, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 3, 657, + 13145, 8, 657, 1, 657, 3, 657, 13148, 8, 657, 3, 657, 13150, 8, 657, 1, + 658, 1, 658, 3, 658, 13154, 8, 658, 1, 658, 1, 658, 1, 658, 1, 658, 3, + 658, 13160, 8, 658, 1, 658, 1, 658, 3, 658, 13164, 8, 658, 1, 659, 1, 659, + 1, 659, 1, 659, 3, 659, 13170, 8, 659, 1, 659, 1, 659, 1, 659, 1, 659, + 3, 659, 13176, 8, 659, 1, 659, 1, 659, 3, 659, 13180, 8, 659, 1, 659, 3, + 659, 13183, 8, 659, 1, 660, 1, 660, 1, 661, 1, 661, 1, 662, 1, 662, 1, + 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 663, 1, 663, 1, 663, 1, 663, 1, + 663, 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, + 664, 3, 664, 13210, 8, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, + 664, 1, 664, 3, 664, 13219, 8, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, + 665, 1, 665, 1, 665, 3, 665, 13228, 8, 665, 1, 665, 1, 665, 1, 665, 1, + 665, 1, 665, 1, 665, 5, 665, 13236, 8, 665, 10, 665, 12, 665, 13239, 9, + 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 3, 666, 13246, 8, 666, 1, + 666, 1, 666, 1, 666, 3, 666, 13251, 8, 666, 1, 666, 1, 666, 1, 667, 1, + 667, 1, 667, 5, 667, 13258, 8, 667, 10, 667, 12, 667, 13261, 9, 667, 1, + 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 3, 668, 13270, 8, + 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 5, 668, 13278, 8, + 668, 10, 668, 12, 668, 13281, 9, 668, 1, 668, 1, 668, 1, 669, 1, 669, 1, + 669, 1, 669, 1, 669, 1, 669, 3, 669, 13291, 8, 669, 1, 669, 1, 669, 1, + 669, 1, 669, 1, 669, 3, 669, 13298, 8, 669, 1, 670, 1, 670, 1, 670, 1, + 670, 1, 670, 3, 670, 13305, 8, 670, 1, 670, 3, 670, 13308, 8, 670, 1, 670, + 3, 670, 13311, 8, 670, 1, 670, 3, 670, 13314, 8, 670, 1, 670, 1, 670, 3, + 670, 13318, 8, 670, 3, 670, 13320, 8, 670, 1, 670, 3, 670, 13323, 8, 670, + 1, 670, 3, 670, 13326, 8, 670, 1, 670, 3, 670, 13329, 8, 670, 1, 670, 3, + 670, 13332, 8, 670, 1, 670, 1, 670, 3, 670, 13336, 8, 670, 3, 670, 13338, + 8, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 3, 670, 13346, + 8, 670, 3, 670, 13348, 8, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 1, 671, 4, 671, 13359, 8, 671, 11, 671, 12, 671, + 13360, 1, 671, 3, 671, 13364, 8, 671, 1, 672, 1, 672, 1, 672, 1, 672, 1, + 672, 1, 672, 3, 672, 13372, 8, 672, 1, 672, 1, 672, 1, 673, 1, 673, 1, + 673, 1, 673, 1, 673, 1, 673, 3, 673, 13382, 8, 673, 1, 673, 1, 673, 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, 3, 676, 13403, + 8, 676, 3, 676, 13405, 8, 676, 1, 677, 1, 677, 1, 677, 1, 677, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 3, 679, 13419, + 8, 679, 1, 679, 1, 679, 3, 679, 13423, 8, 679, 1, 679, 3, 679, 13426, 8, + 679, 1, 680, 1, 680, 1, 680, 1, 680, 3, 680, 13432, 8, 680, 1, 681, 1, + 681, 1, 681, 1, 681, 1, 681, 3, 681, 13439, 8, 681, 1, 682, 1, 682, 1, + 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, + 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, + 684, 3, 684, 13462, 8, 684, 1, 685, 3, 685, 13465, 8, 685, 1, 685, 1, 685, + 3, 685, 13469, 8, 685, 1, 686, 1, 686, 1, 686, 3, 686, 13474, 8, 686, 1, + 686, 1, 686, 1, 686, 3, 686, 13479, 8, 686, 1, 686, 3, 686, 13482, 8, 686, + 1, 686, 3, 686, 13485, 8, 686, 1, 686, 1, 686, 1, 686, 3, 686, 13490, 8, + 686, 1, 687, 1, 687, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, + 689, 3, 689, 13501, 8, 689, 1, 690, 1, 690, 1, 691, 1, 691, 3, 691, 13507, + 8, 691, 1, 691, 1, 691, 3, 691, 13511, 8, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 3, 691, 13517, 8, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 4, 691, 13524, 8, 691, 11, 691, 12, 691, 13525, 3, 691, 13528, 8, 691, + 1, 691, 1, 691, 3, 691, 13532, 8, 691, 1, 691, 3, 691, 13535, 8, 691, 1, + 692, 3, 692, 13538, 8, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, + 692, 1, 692, 1, 692, 3, 692, 13548, 8, 692, 1, 692, 1, 692, 1, 692, 1, + 692, 1, 692, 1, 692, 4, 692, 13556, 8, 692, 11, 692, 12, 692, 13557, 3, + 692, 13560, 8, 692, 1, 693, 1, 693, 1, 693, 1, 693, 5, 693, 13566, 8, 693, + 10, 693, 12, 693, 13569, 9, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 5, 693, 13577, 8, 693, 10, 693, 12, 693, 13580, 9, 693, 1, 693, + 3, 693, 13583, 8, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, + 5, 694, 13591, 8, 694, 10, 694, 12, 694, 13594, 9, 694, 1, 694, 1, 694, + 1, 694, 1, 694, 1, 694, 1, 694, 5, 694, 13602, 8, 694, 10, 694, 12, 694, + 13605, 9, 694, 3, 694, 13607, 8, 694, 1, 694, 1, 694, 1, 694, 3, 694, 13612, + 8, 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, 3, 695, 13626, 8, 695, 1, 695, 1, 695, + 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 4, 695, 13635, 8, 695, 11, 695, + 12, 695, 13636, 1, 695, 1, 695, 3, 695, 13641, 8, 695, 1, 695, 1, 695, + 1, 695, 1, 695, 1, 695, 1, 695, 3, 695, 13649, 8, 695, 3, 695, 13651, 8, + 695, 1, 696, 1, 696, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 5, 697, 13660, + 8, 697, 10, 697, 12, 697, 13663, 9, 697, 1, 697, 1, 697, 1, 697, 1, 697, + 1, 697, 1, 697, 1, 697, 3, 697, 13672, 8, 697, 1, 698, 1, 698, 1, 698, + 1, 698, 3, 698, 13678, 8, 698, 1, 698, 1, 698, 1, 698, 3, 698, 13683, 8, + 698, 5, 698, 13685, 8, 698, 10, 698, 12, 698, 13688, 9, 698, 1, 698, 1, + 698, 3, 698, 13692, 8, 698, 1, 699, 1, 699, 1, 699, 3, 699, 13697, 8, 699, + 1, 699, 1, 699, 1, 699, 3, 699, 13702, 8, 699, 5, 699, 13704, 8, 699, 10, + 699, 12, 699, 13707, 9, 699, 1, 699, 1, 699, 1, 699, 1, 699, 3, 699, 13713, + 8, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 3, 699, 13720, 8, 699, + 1, 700, 1, 700, 1, 700, 3, 700, 13725, 8, 700, 1, 700, 1, 700, 1, 700, + 3, 700, 13730, 8, 700, 5, 700, 13732, 8, 700, 10, 700, 12, 700, 13735, + 9, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, + 3, 700, 13745, 8, 700, 1, 701, 1, 701, 1, 701, 1, 701, 3, 701, 13751, 8, + 701, 1, 701, 1, 701, 1, 701, 3, 701, 13756, 8, 701, 5, 701, 13758, 8, 701, + 10, 701, 12, 701, 13761, 9, 701, 1, 701, 1, 701, 3, 701, 13765, 8, 701, + 1, 701, 3, 701, 13768, 8, 701, 1, 701, 3, 701, 13771, 8, 701, 1, 702, 1, + 702, 3, 702, 13775, 8, 702, 1, 702, 3, 702, 13778, 8, 702, 1, 702, 3, 702, + 13781, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 1, 702, 3, 702, 13793, 8, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 5, 702, 13800, 8, 702, 10, 702, 12, 702, 13803, 9, 702, + 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 3, 702, 13810, 8, 702, 1, 702, + 1, 702, 1, 702, 1, 702, 5, 702, 13816, 8, 702, 10, 702, 12, 702, 13819, + 9, 702, 1, 702, 1, 702, 3, 702, 13823, 8, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 3, 702, 13829, 8, 702, 1, 703, 1, 703, 3, 703, 13833, 8, 703, 1, + 703, 1, 703, 1, 703, 1, 703, 1, 703, 3, 703, 13840, 8, 703, 1, 703, 4, + 703, 13843, 8, 703, 11, 703, 12, 703, 13844, 1, 703, 1, 703, 1, 703, 3, + 703, 13850, 8, 703, 1, 703, 1, 703, 1, 703, 3, 703, 13855, 8, 703, 5, 703, + 13857, 8, 703, 10, 703, 12, 703, 13860, 9, 703, 1, 703, 1, 703, 1, 703, + 1, 703, 5, 703, 13866, 8, 703, 10, 703, 12, 703, 13869, 9, 703, 3, 703, + 13871, 8, 703, 1, 704, 1, 704, 3, 704, 13875, 8, 704, 1, 704, 1, 704, 1, + 705, 1, 705, 3, 705, 13881, 8, 705, 1, 705, 1, 705, 1, 705, 1, 705, 5, + 705, 13887, 8, 705, 10, 705, 12, 705, 13890, 9, 705, 1, 705, 1, 705, 1, + 705, 1, 705, 5, 705, 13896, 8, 705, 10, 705, 12, 705, 13899, 9, 705, 3, + 705, 13901, 8, 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, + 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 3, 707, 13916, 8, + 707, 1, 708, 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 710, 1, + 710, 1, 710, 1, 710, 1, 710, 1, 710, 5, 710, 13931, 8, 710, 10, 710, 12, + 710, 13934, 9, 710, 1, 710, 1, 710, 1, 710, 3, 710, 13939, 8, 710, 1, 711, + 1, 711, 3, 711, 13943, 8, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, + 3, 711, 13950, 8, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 3, 711, + 13957, 8, 711, 1, 711, 3, 711, 13960, 8, 711, 3, 711, 13962, 8, 711, 1, + 712, 1, 712, 1, 712, 1, 712, 3, 712, 13968, 8, 712, 3, 712, 13970, 8, 712, + 1, 712, 3, 712, 13973, 8, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, + 1, 713, 1, 713, 3, 713, 13982, 8, 713, 1, 713, 3, 713, 13985, 8, 713, 1, + 714, 1, 714, 3, 714, 13989, 8, 714, 1, 714, 1, 714, 1, 714, 1, 714, 3, + 714, 13995, 8, 714, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, + 715, 1, 716, 1, 716, 1, 716, 3, 716, 14007, 8, 716, 1, 716, 1, 716, 1, + 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 3, 717, 14017, 8, 717, 1, + 717, 1, 717, 3, 717, 14021, 8, 717, 1, 717, 3, 717, 14024, 8, 717, 1, 717, + 3, 717, 14027, 8, 717, 1, 717, 1, 717, 1, 717, 3, 717, 14032, 8, 717, 1, + 717, 1, 717, 3, 717, 14036, 8, 717, 1, 717, 1, 717, 3, 717, 14040, 8, 717, + 1, 717, 3, 717, 14043, 8, 717, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, + 3, 718, 14050, 8, 718, 1, 718, 3, 718, 14053, 8, 718, 1, 718, 1, 718, 1, + 718, 1, 718, 1, 718, 3, 718, 14060, 8, 718, 1, 718, 1, 718, 1, 718, 1, + 718, 3, 718, 14066, 8, 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 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, 721, 1, 721, 1, 721, 1, + 721, 1, 721, 1, 721, 3, 721, 14094, 8, 721, 1, 721, 1, 721, 1, 721, 1, + 721, 1, 721, 1, 721, 4, 721, 14102, 8, 721, 11, 721, 12, 721, 14103, 1, + 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 14114, + 8, 721, 3, 721, 14116, 8, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, + 1, 721, 3, 721, 14124, 8, 721, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, + 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, + 1, 726, 1, 726, 1, 727, 1, 727, 1, 728, 1, 728, 1, 729, 1, 729, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 3, 730, 14155, 8, 730, + 1, 730, 1, 730, 1, 730, 3, 730, 14160, 8, 730, 1, 731, 1, 731, 1, 731, + 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, + 3, 733, 14174, 8, 733, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 735, + 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 3, 738, 14198, + 8, 738, 1, 738, 3, 738, 14201, 8, 738, 1, 738, 1, 738, 1, 738, 1, 738, + 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 3, 738, 14213, 8, 738, + 1, 738, 3, 738, 14216, 8, 738, 1, 739, 1, 739, 1, 739, 1, 739, 3, 739, + 14222, 8, 739, 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, 5, 741, 14238, + 8, 741, 10, 741, 12, 741, 14241, 9, 741, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, + 3, 742, 14256, 8, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 3, 742, 14269, 8, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 5, 742, 14278, 8, 742, + 10, 742, 12, 742, 14281, 9, 742, 1, 742, 4, 742, 14284, 8, 742, 11, 742, + 12, 742, 14285, 1, 743, 1, 743, 1, 743, 1, 743, 5, 743, 14292, 8, 743, + 10, 743, 12, 743, 14295, 9, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, + 1, 743, 3, 743, 14303, 8, 743, 1, 744, 1, 744, 3, 744, 14307, 8, 744, 1, + 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 3, 745, 14315, 8, 745, 1, + 745, 1, 745, 1, 745, 1, 745, 5, 745, 14321, 8, 745, 10, 745, 12, 745, 14324, + 9, 745, 1, 745, 1, 745, 1, 745, 3, 745, 14329, 8, 745, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 3, 746, 14336, 8, 746, 1, 746, 1, 746, 3, 746, + 14340, 8, 746, 1, 746, 1, 746, 3, 746, 14344, 8, 746, 3, 746, 14346, 8, + 746, 1, 746, 3, 746, 14349, 8, 746, 1, 747, 1, 747, 1, 747, 1, 747, 1, + 747, 1, 747, 5, 747, 14357, 8, 747, 10, 747, 12, 747, 14360, 9, 747, 1, + 747, 1, 747, 1, 747, 3, 747, 14365, 8, 747, 1, 748, 1, 748, 1, 748, 3, + 748, 14370, 8, 748, 1, 749, 1, 749, 1, 749, 1, 749, 4, 749, 14376, 8, 749, + 11, 749, 12, 749, 14377, 1, 750, 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, + 1, 751, 1, 751, 1, 751, 3, 751, 14389, 8, 751, 1, 751, 3, 751, 14392, 8, + 751, 1, 752, 3, 752, 14395, 8, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, + 752, 1, 752, 1, 752, 1, 752, 3, 752, 14405, 8, 752, 1, 752, 1, 752, 1, + 752, 1, 752, 1, 752, 5, 752, 14412, 8, 752, 10, 752, 12, 752, 14415, 9, + 752, 3, 752, 14417, 8, 752, 1, 752, 3, 752, 14420, 8, 752, 1, 753, 3, 753, + 14423, 8, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, + 5, 753, 14432, 8, 753, 10, 753, 12, 753, 14435, 9, 753, 3, 753, 14437, + 8, 753, 1, 754, 1, 754, 1, 754, 1, 754, 3, 754, 14443, 8, 754, 1, 754, + 3, 754, 14446, 8, 754, 1, 755, 1, 755, 3, 755, 14450, 8, 755, 1, 755, 3, + 755, 14453, 8, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, + 755, 1, 755, 1, 755, 1, 755, 1, 755, 3, 755, 14466, 8, 755, 3, 755, 14468, + 8, 755, 1, 755, 5, 755, 14471, 8, 755, 10, 755, 12, 755, 14474, 9, 755, + 1, 755, 1, 755, 3, 755, 14478, 8, 755, 1, 756, 1, 756, 3, 756, 14482, 8, + 756, 1, 756, 1, 756, 1, 756, 1, 756, 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, 3, 758, 14505, 8, 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, 3, 758, 14521, 8, 758, 1, 759, 1, 759, 1, 759, 3, + 759, 14526, 8, 759, 1, 759, 1, 759, 3, 759, 14530, 8, 759, 1, 759, 1, 759, + 3, 759, 14534, 8, 759, 1, 759, 1, 759, 3, 759, 14538, 8, 759, 1, 759, 3, + 759, 14541, 8, 759, 1, 759, 1, 759, 1, 759, 3, 759, 14546, 8, 759, 3, 759, + 14548, 8, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, + 1, 760, 1, 760, 1, 760, 5, 760, 14560, 8, 760, 10, 760, 12, 760, 14563, + 9, 760, 1, 760, 1, 760, 3, 760, 14567, 8, 760, 1, 761, 1, 761, 1, 761, + 1, 761, 1, 761, 3, 761, 14574, 8, 761, 1, 762, 1, 762, 1, 762, 1, 762, + 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 3, 762, 14585, 8, 762, 1, 762, + 1, 762, 1, 762, 1, 762, 3, 762, 14591, 8, 762, 3, 762, 14593, 8, 762, 3, + 762, 14595, 8, 762, 1, 763, 1, 763, 1, 763, 1, 763, 5, 763, 14601, 8, 763, + 10, 763, 12, 763, 14604, 9, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, + 1, 763, 3, 763, 14612, 8, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, + 1, 763, 3, 763, 14620, 8, 763, 4, 763, 14622, 8, 763, 11, 763, 12, 763, + 14623, 3, 763, 14626, 8, 763, 1, 764, 3, 764, 14629, 8, 764, 1, 764, 1, + 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, + 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 3, 765, 14647, 8, 765, 1, + 765, 1, 765, 1, 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, 1, 766, 3, 766, 14665, + 8, 766, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 3, 767, 14672, 8, 767, + 1, 767, 1, 767, 3, 767, 14676, 8, 767, 1, 767, 3, 767, 14679, 8, 767, 1, + 767, 3, 767, 14682, 8, 767, 3, 767, 14684, 8, 767, 1, 768, 1, 768, 1, 768, + 3, 768, 14689, 8, 768, 1, 768, 1, 768, 3, 768, 14693, 8, 768, 3, 768, 14695, + 8, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, + 1, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 3, 770, 14711, 8, 770, + 1, 770, 1, 770, 3, 770, 14715, 8, 770, 1, 770, 3, 770, 14718, 8, 770, 1, + 770, 1, 770, 1, 770, 3, 770, 14723, 8, 770, 1, 770, 3, 770, 14726, 8, 770, + 1, 770, 3, 770, 14729, 8, 770, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, + 1, 771, 1, 771, 5, 771, 14738, 8, 771, 10, 771, 12, 771, 14741, 9, 771, + 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 5, 771, 14749, 8, 771, + 10, 771, 12, 771, 14752, 9, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, + 1, 771, 1, 771, 5, 771, 14761, 8, 771, 10, 771, 12, 771, 14764, 9, 771, + 1, 771, 1, 771, 1, 771, 5, 771, 14769, 8, 771, 10, 771, 12, 771, 14772, + 9, 771, 3, 771, 14774, 8, 771, 1, 771, 1, 771, 3, 771, 14778, 8, 771, 1, + 771, 1, 771, 1, 771, 3, 771, 14783, 8, 771, 1, 772, 1, 772, 1, 772, 3, + 772, 14788, 8, 772, 1, 772, 1, 772, 3, 772, 14792, 8, 772, 1, 772, 3, 772, + 14795, 8, 772, 1, 772, 3, 772, 14798, 8, 772, 1, 772, 3, 772, 14801, 8, + 772, 1, 772, 1, 772, 3, 772, 14805, 8, 772, 3, 772, 14807, 8, 772, 1, 773, + 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 3, 773, 14817, + 8, 773, 1, 773, 1, 773, 3, 773, 14821, 8, 773, 1, 774, 1, 774, 1, 774, + 3, 774, 14826, 8, 774, 1, 774, 1, 774, 1, 774, 3, 774, 14831, 8, 774, 1, + 775, 1, 775, 1, 775, 1, 775, 1, 775, 3, 775, 14838, 8, 775, 1, 775, 1, + 775, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 14846, 8, 776, 1, 776, 1, + 776, 1, 776, 1, 776, 3, 776, 14852, 8, 776, 1, 776, 3, 776, 14855, 8, 776, + 3, 776, 14857, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 5, 776, 14866, 8, 776, 10, 776, 12, 776, 14869, 9, 776, 1, 777, + 1, 777, 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 3, 778, 14878, 8, 778, + 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, 5, 779, 14887, + 8, 779, 10, 779, 12, 779, 14890, 9, 779, 1, 779, 1, 779, 1, 779, 1, 779, + 5, 779, 14896, 8, 779, 10, 779, 12, 779, 14899, 9, 779, 1, 779, 1, 779, + 1, 779, 1, 779, 3, 779, 14905, 8, 779, 1, 779, 1, 779, 1, 779, 5, 779, + 14910, 8, 779, 10, 779, 12, 779, 14913, 9, 779, 1, 779, 3, 779, 14916, + 8, 779, 3, 779, 14918, 8, 779, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, + 14924, 8, 780, 1, 780, 1, 780, 1, 780, 1, 780, 5, 780, 14930, 8, 780, 10, + 780, 12, 780, 14933, 9, 780, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 14939, + 8, 780, 1, 780, 1, 780, 1, 780, 5, 780, 14944, 8, 780, 10, 780, 12, 780, + 14947, 9, 780, 1, 780, 3, 780, 14950, 8, 780, 3, 780, 14952, 8, 780, 1, + 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, + 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, + 781, 4, 781, 14973, 8, 781, 11, 781, 12, 781, 14974, 1, 781, 3, 781, 14978, + 8, 781, 1, 782, 1, 782, 1, 782, 1, 782, 3, 782, 14984, 8, 782, 1, 783, + 1, 783, 1, 783, 1, 783, 3, 783, 14990, 8, 783, 1, 784, 1, 784, 1, 784, + 1, 784, 1, 784, 1, 784, 4, 784, 14998, 8, 784, 11, 784, 12, 784, 14999, + 3, 784, 15002, 8, 784, 1, 785, 1, 785, 1, 785, 3, 785, 15007, 8, 785, 1, + 785, 1, 785, 1, 785, 3, 785, 15012, 8, 785, 1, 785, 1, 785, 1, 785, 3, + 785, 15017, 8, 785, 5, 785, 15019, 8, 785, 10, 785, 12, 785, 15022, 9, + 785, 1, 785, 3, 785, 15025, 8, 785, 1, 786, 1, 786, 3, 786, 15029, 8, 786, + 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 3, 788, 15041, 8, 788, 1, 789, 1, 789, 1, 789, 1, 789, 3, 789, + 15047, 8, 789, 1, 789, 1, 789, 1, 789, 5, 789, 15052, 8, 789, 10, 789, + 12, 789, 15055, 9, 789, 1, 790, 1, 790, 3, 790, 15059, 8, 790, 1, 790, + 1, 790, 5, 790, 15063, 8, 790, 10, 790, 12, 790, 15066, 9, 790, 1, 791, + 1, 791, 3, 791, 15070, 8, 791, 1, 791, 1, 791, 3, 791, 15074, 8, 791, 1, + 791, 1, 791, 5, 791, 15078, 8, 791, 10, 791, 12, 791, 15081, 9, 791, 1, + 792, 1, 792, 3, 792, 15085, 8, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, + 792, 5, 792, 15092, 8, 792, 10, 792, 12, 792, 15095, 9, 792, 1, 792, 1, + 792, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 15103, 8, 792, 1, 792, 3, + 792, 15106, 8, 792, 1, 792, 3, 792, 15109, 8, 792, 1, 792, 3, 792, 15112, + 8, 792, 1, 792, 1, 792, 3, 792, 15116, 8, 792, 1, 793, 1, 793, 1, 793, + 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 3, 793, 15126, 8, 793, 1, 794, + 1, 794, 1, 794, 1, 794, 1, 794, 3, 794, 15133, 8, 794, 1, 794, 1, 794, + 1, 794, 1, 794, 1, 794, 4, 794, 15140, 8, 794, 11, 794, 12, 794, 15141, + 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, 3, 797, + 15152, 8, 797, 1, 797, 3, 797, 15155, 8, 797, 1, 797, 3, 797, 15158, 8, + 797, 1, 797, 3, 797, 15161, 8, 797, 1, 797, 1, 797, 5, 797, 15165, 8, 797, + 10, 797, 12, 797, 15168, 9, 797, 1, 797, 3, 797, 15171, 8, 797, 1, 798, + 1, 798, 1, 798, 1, 798, 4, 798, 15177, 8, 798, 11, 798, 12, 798, 15178, + 1, 798, 3, 798, 15182, 8, 798, 1, 798, 3, 798, 15185, 8, 798, 1, 799, 1, + 799, 1, 799, 3, 799, 15190, 8, 799, 1, 800, 1, 800, 1, 800, 3, 800, 15195, + 8, 800, 1, 801, 1, 801, 3, 801, 15199, 8, 801, 1, 801, 1, 801, 3, 801, + 15203, 8, 801, 1, 802, 1, 802, 1, 802, 1, 802, 3, 802, 15209, 8, 802, 1, + 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, + 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 806, 1, 806, 1, + 807, 1, 807, 1, 808, 1, 808, 1, 808, 1, 808, 4, 808, 15235, 8, 808, 11, + 808, 12, 808, 15236, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, + 809, 1, 809, 5, 809, 15247, 8, 809, 10, 809, 12, 809, 15250, 9, 809, 1, + 809, 1, 809, 3, 809, 15254, 8, 809, 1, 809, 1, 809, 1, 809, 5, 809, 15259, + 8, 809, 10, 809, 12, 809, 15262, 9, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 809, 5, 809, 15271, 8, 809, 10, 809, 12, 809, 15274, + 9, 809, 1, 809, 1, 809, 3, 809, 15278, 8, 809, 1, 809, 1, 809, 1, 809, + 5, 809, 15283, 8, 809, 10, 809, 12, 809, 15286, 9, 809, 1, 809, 1, 809, + 3, 809, 15290, 8, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 3, 809, + 15297, 8, 809, 1, 809, 1, 809, 3, 809, 15301, 8, 809, 1, 810, 1, 810, 1, + 810, 1, 810, 1, 810, 5, 810, 15308, 8, 810, 10, 810, 12, 810, 15311, 9, + 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 5, 810, 15319, 8, + 810, 10, 810, 12, 810, 15322, 9, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, + 810, 3, 810, 15329, 8, 810, 1, 811, 1, 811, 3, 811, 15333, 8, 811, 1, 811, + 1, 811, 1, 811, 3, 811, 15338, 8, 811, 1, 811, 3, 811, 15341, 8, 811, 1, + 811, 1, 811, 1, 811, 3, 811, 15346, 8, 811, 1, 811, 5, 811, 15349, 8, 811, + 10, 811, 12, 811, 15352, 9, 811, 1, 811, 3, 811, 15355, 8, 811, 1, 811, + 3, 811, 15358, 8, 811, 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, + 3, 813, 15366, 8, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 3, 813, + 15373, 8, 813, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 15379, 8, 814, 1, + 814, 1, 814, 1, 814, 3, 814, 15384, 8, 814, 5, 814, 15386, 8, 814, 10, + 814, 12, 814, 15389, 9, 814, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 15395, + 8, 814, 3, 814, 15397, 8, 814, 1, 814, 3, 814, 15400, 8, 814, 1, 815, 1, + 815, 1, 815, 3, 815, 15405, 8, 815, 1, 815, 1, 815, 3, 815, 15409, 8, 815, + 1, 816, 1, 816, 1, 816, 3, 816, 15414, 8, 816, 1, 816, 1, 816, 3, 816, + 15418, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 15425, 8, + 816, 1, 817, 1, 817, 3, 817, 15429, 8, 817, 1, 818, 1, 818, 1, 818, 3, + 818, 15434, 8, 818, 1, 819, 1, 819, 1, 819, 1, 819, 3, 819, 15440, 8, 819, + 1, 819, 3, 819, 15443, 8, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, + 5, 820, 15450, 8, 820, 10, 820, 12, 820, 15453, 9, 820, 1, 820, 1, 820, + 1, 820, 1, 820, 1, 820, 1, 820, 5, 820, 15461, 8, 820, 10, 820, 12, 820, + 15464, 9, 820, 1, 820, 4, 820, 15467, 8, 820, 11, 820, 12, 820, 15468, + 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, + 5, 820, 15480, 8, 820, 10, 820, 12, 820, 15483, 9, 820, 1, 820, 4, 820, + 15486, 8, 820, 11, 820, 12, 820, 15487, 3, 820, 15490, 8, 820, 1, 821, + 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 822, + 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, + 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 3, 822, 15517, 8, 822, + 1, 822, 3, 822, 15520, 8, 822, 1, 822, 1, 822, 1, 822, 4, 822, 15525, 8, + 822, 11, 822, 12, 822, 15526, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, + 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, + 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 3, 823, 15549, 8, 823, 1, + 823, 3, 823, 15552, 8, 823, 4, 823, 15554, 8, 823, 11, 823, 12, 823, 15555, + 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 3, 825, 15563, 8, 825, 3, 825, + 15565, 8, 825, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 3, 826, + 15573, 8, 826, 1, 827, 1, 827, 3, 827, 15577, 8, 827, 1, 827, 1, 827, 1, + 827, 3, 827, 15582, 8, 827, 1, 827, 3, 827, 15585, 8, 827, 1, 827, 3, 827, + 15588, 8, 827, 1, 827, 3, 827, 15591, 8, 827, 1, 828, 1, 828, 1, 829, 1, + 829, 1, 829, 3, 829, 15598, 8, 829, 1, 829, 1, 829, 1, 829, 3, 829, 15603, + 8, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 15611, + 8, 830, 1, 830, 1, 830, 1, 830, 1, 830, 5, 830, 15617, 8, 830, 10, 830, + 12, 830, 15620, 9, 830, 1, 830, 1, 830, 3, 830, 15624, 8, 830, 1, 830, + 4, 830, 15627, 8, 830, 11, 830, 12, 830, 15628, 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, 4, 831, 15645, 8, 831, 11, 831, 12, 831, 15646, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, + 1, 831, 4, 831, 15660, 8, 831, 11, 831, 12, 831, 15661, 3, 831, 15664, + 8, 831, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, + 1, 832, 1, 832, 3, 832, 15676, 8, 832, 1, 833, 1, 833, 1, 834, 1, 834, + 1, 835, 1, 835, 1, 835, 3, 835, 15685, 8, 835, 1, 835, 1, 835, 3, 835, + 15689, 8, 835, 3, 835, 15691, 8, 835, 1, 835, 3, 835, 15694, 8, 835, 1, + 835, 3, 835, 15697, 8, 835, 1, 835, 1, 835, 1, 835, 3, 835, 15702, 8, 835, + 1, 835, 1, 835, 3, 835, 15706, 8, 835, 1, 835, 1, 835, 3, 835, 15710, 8, + 835, 1, 835, 4, 835, 15713, 8, 835, 11, 835, 12, 835, 15714, 1, 835, 3, + 835, 15718, 8, 835, 1, 835, 3, 835, 15721, 8, 835, 1, 836, 1, 836, 1, 837, + 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 3, 837, 15731, 8, 837, 3, 837, + 15733, 8, 837, 1, 837, 1, 837, 1, 837, 3, 837, 15738, 8, 837, 1, 838, 4, + 838, 15741, 8, 838, 11, 838, 12, 838, 15742, 1, 838, 1, 838, 4, 838, 15747, + 8, 838, 11, 838, 12, 838, 15748, 1, 838, 1, 838, 3, 838, 15753, 8, 838, + 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 15760, 8, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, + 1, 839, 1, 839, 3, 839, 15783, 8, 839, 1, 840, 1, 840, 1, 840, 1, 840, + 3, 840, 15789, 8, 840, 3, 840, 15791, 8, 840, 1, 840, 3, 840, 15794, 8, + 840, 1, 840, 3, 840, 15797, 8, 840, 1, 840, 3, 840, 15800, 8, 840, 1, 840, + 3, 840, 15803, 8, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, + 3, 840, 15811, 8, 840, 3, 840, 15813, 8, 840, 1, 840, 1, 840, 1, 840, 1, + 840, 1, 840, 1, 840, 1, 840, 3, 840, 15822, 8, 840, 3, 840, 15824, 8, 840, + 1, 840, 5, 840, 15827, 8, 840, 10, 840, 12, 840, 15830, 9, 840, 1, 840, + 3, 840, 15833, 8, 840, 1, 841, 1, 841, 1, 841, 3, 841, 15838, 8, 841, 3, + 841, 15840, 8, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 3, 841, 15847, + 8, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 3, 842, 15855, + 8, 842, 3, 842, 15857, 8, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, + 5, 842, 15864, 8, 842, 10, 842, 12, 842, 15867, 9, 842, 1, 842, 3, 842, + 15870, 8, 842, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, + 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 15883, 8, 844, 1, 845, 1, 845, + 1, 845, 1, 845, 3, 845, 15889, 8, 845, 1, 845, 3, 845, 15892, 8, 845, 1, + 845, 3, 845, 15895, 8, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, + 845, 1, 845, 1, 845, 1, 845, 1, 845, 4, 845, 15907, 8, 845, 11, 845, 12, + 845, 15908, 1, 845, 1, 845, 3, 845, 15913, 8, 845, 1, 845, 1, 845, 3, 845, + 15917, 8, 845, 1, 845, 3, 845, 15920, 8, 845, 1, 846, 1, 846, 1, 847, 3, + 847, 15925, 8, 847, 1, 847, 1, 847, 1, 847, 3, 847, 15930, 8, 847, 1, 847, + 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 15937, 8, 847, 1, 847, 1, 847, + 1, 847, 1, 847, 3, 847, 15943, 8, 847, 1, 848, 1, 848, 3, 848, 15947, 8, + 848, 1, 849, 1, 849, 1, 849, 1, 849, 3, 849, 15953, 8, 849, 1, 850, 1, + 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 5, 851, 15964, + 8, 851, 10, 851, 12, 851, 15967, 9, 851, 1, 851, 3, 851, 15970, 8, 851, + 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 3, 851, 15977, 8, 851, 1, 851, + 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, + 5, 851, 15989, 8, 851, 10, 851, 12, 851, 15992, 9, 851, 1, 851, 1, 851, + 3, 851, 15996, 8, 851, 1, 851, 1, 851, 3, 851, 16000, 8, 851, 1, 851, 1, + 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 4, 851, 16009, 8, 851, 11, + 851, 12, 851, 16010, 3, 851, 16013, 8, 851, 1, 852, 1, 852, 1, 853, 1, + 853, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 5, + 854, 16027, 8, 854, 10, 854, 12, 854, 16030, 9, 854, 1, 854, 1, 854, 1, + 854, 1, 854, 3, 854, 16036, 8, 854, 1, 854, 3, 854, 16039, 8, 854, 1, 854, + 1, 854, 3, 854, 16043, 8, 854, 1, 854, 3, 854, 16046, 8, 854, 1, 855, 1, + 855, 1, 855, 1, 855, 1, 855, 3, 855, 16053, 8, 855, 1, 856, 1, 856, 1, + 856, 1, 856, 1, 856, 3, 856, 16060, 8, 856, 1, 857, 1, 857, 1, 857, 3, + 857, 16065, 8, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 3, 857, 16072, + 8, 857, 3, 857, 16074, 8, 857, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, + 3, 858, 16081, 8, 858, 1, 859, 1, 859, 3, 859, 16085, 8, 859, 3, 859, 16087, + 8, 859, 1, 859, 1, 859, 1, 859, 1, 859, 4, 859, 16093, 8, 859, 11, 859, + 12, 859, 16094, 3, 859, 16097, 8, 859, 1, 859, 1, 859, 1, 860, 1, 860, + 1, 860, 1, 861, 1, 861, 3, 861, 16106, 8, 861, 1, 862, 1, 862, 1, 862, + 1, 862, 1, 862, 1, 863, 1, 863, 1, 863, 3, 863, 16116, 8, 863, 1, 863, + 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 3, 863, + 16127, 8, 863, 3, 863, 16129, 8, 863, 1, 863, 3, 863, 16132, 8, 863, 1, + 863, 1, 863, 3, 863, 16136, 8, 863, 1, 863, 3, 863, 16139, 8, 863, 1, 864, + 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, + 1, 865, 5, 865, 16152, 8, 865, 10, 865, 12, 865, 16155, 9, 865, 1, 865, + 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 3, 866, 16163, 8, 866, 1, 866, + 1, 866, 3, 866, 16167, 8, 866, 1, 866, 3, 866, 16170, 8, 866, 1, 866, 1, + 866, 3, 866, 16174, 8, 866, 1, 866, 3, 866, 16177, 8, 866, 3, 866, 16179, + 8, 866, 1, 867, 1, 867, 3, 867, 16183, 8, 867, 1, 867, 1, 867, 1, 867, + 1, 867, 1, 867, 3, 867, 16190, 8, 867, 1, 868, 1, 868, 5, 868, 16194, 8, + 868, 10, 868, 12, 868, 16197, 9, 868, 1, 868, 3, 868, 16200, 8, 868, 1, + 868, 3, 868, 16203, 8, 868, 1, 869, 1, 869, 1, 869, 1, 870, 4, 870, 16209, + 8, 870, 11, 870, 12, 870, 16210, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, + 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 3, 871, 16224, 8, 871, + 1, 872, 1, 872, 3, 872, 16228, 8, 872, 1, 872, 1, 872, 3, 872, 16232, 8, + 872, 1, 872, 3, 872, 16235, 8, 872, 1, 872, 3, 872, 16238, 8, 872, 1, 872, + 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, + 1, 873, 3, 873, 16251, 8, 873, 1, 873, 1, 873, 3, 873, 16255, 8, 873, 1, + 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 5, 874, 16265, + 8, 874, 10, 874, 12, 874, 16268, 9, 874, 1, 874, 1, 874, 3, 874, 16272, + 8, 874, 1, 874, 1, 874, 3, 874, 16276, 8, 874, 1, 874, 1, 874, 3, 874, + 16280, 8, 874, 1, 874, 1, 874, 1, 875, 1, 875, 3, 875, 16286, 8, 875, 1, + 875, 3, 875, 16289, 8, 875, 1, 875, 3, 875, 16292, 8, 875, 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, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, + 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 16319, 8, 877, 1, 877, + 1, 877, 4, 877, 16323, 8, 877, 11, 877, 12, 877, 16324, 1, 877, 1, 877, + 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 16334, 8, 877, 1, 877, + 1, 877, 1, 877, 3, 877, 16339, 8, 877, 1, 877, 1, 877, 1, 878, 1, 878, + 1, 878, 1, 878, 1, 878, 5, 878, 16348, 8, 878, 10, 878, 12, 878, 16351, + 9, 878, 1, 878, 1, 878, 1, 879, 1, 879, 3, 879, 16357, 8, 879, 1, 879, + 1, 879, 3, 879, 16361, 8, 879, 1, 879, 3, 879, 16364, 8, 879, 1, 880, 1, + 880, 1, 880, 1, 880, 3, 880, 16370, 8, 880, 1, 881, 1, 881, 1, 881, 1, + 881, 1, 881, 1, 881, 1, 881, 3, 881, 16379, 8, 881, 1, 881, 1, 881, 1, + 882, 1, 882, 1, 882, 1, 882, 1, 882, 3, 882, 16388, 8, 882, 1, 882, 3, + 882, 16391, 8, 882, 1, 883, 1, 883, 3, 883, 16395, 8, 883, 1, 883, 1, 883, + 1, 883, 1, 884, 1, 884, 3, 884, 16402, 8, 884, 1, 884, 3, 884, 16405, 8, + 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 3, 884, 16414, + 8, 884, 1, 885, 5, 885, 16417, 8, 885, 10, 885, 12, 885, 16420, 9, 885, + 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 4, 885, 16427, 8, 885, 11, 885, + 12, 885, 16428, 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, 3, 887, 16454, + 8, 887, 1, 888, 1, 888, 3, 888, 16458, 8, 888, 1, 888, 1, 888, 1, 888, + 1, 889, 1, 889, 3, 889, 16465, 8, 889, 1, 889, 1, 889, 3, 889, 16469, 8, + 889, 1, 890, 1, 890, 3, 890, 16473, 8, 890, 1, 890, 1, 890, 3, 890, 16477, + 8, 890, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, + 5, 892, 16487, 8, 892, 10, 892, 12, 892, 16490, 9, 892, 1, 892, 3, 892, + 16493, 8, 892, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, + 1, 893, 1, 894, 1, 894, 1, 894, 1, 895, 3, 895, 16507, 8, 895, 1, 895, + 1, 895, 1, 895, 1, 895, 3, 895, 16513, 8, 895, 1, 895, 1, 895, 1, 895, + 1, 895, 1, 895, 3, 895, 16520, 8, 895, 1, 896, 1, 896, 1, 896, 3, 896, + 16525, 8, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 896, 3, 896, 16536, 8, 896, 1, 896, 3, 896, 16539, 8, 896, 1, + 896, 1, 896, 1, 896, 1, 896, 3, 896, 16545, 8, 896, 3, 896, 16547, 8, 896, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 3, 897, 16555, 8, 897, + 1, 897, 1, 897, 3, 897, 16559, 8, 897, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 898, 3, 898, 16569, 8, 898, 1, 898, 1, 898, + 1, 898, 3, 898, 16574, 8, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, + 1, 900, 1, 900, 1, 901, 1, 901, 1, 902, 1, 902, 1, 903, 1, 903, 3, 903, + 16589, 8, 903, 1, 904, 1, 904, 3, 904, 16593, 8, 904, 1, 905, 3, 905, 16596, + 8, 905, 1, 905, 1, 905, 3, 905, 16600, 8, 905, 1, 905, 1, 905, 1, 905, + 3, 905, 16605, 8, 905, 5, 905, 16607, 8, 905, 10, 905, 12, 905, 16610, + 9, 905, 1, 905, 1, 905, 3, 905, 16614, 8, 905, 1, 906, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, + 5, 907, 16628, 8, 907, 10, 907, 12, 907, 16631, 9, 907, 1, 907, 1, 907, + 3, 907, 16635, 8, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 909, 3, 909, 16644, 8, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, + 1, 909, 1, 909, 4, 909, 16653, 8, 909, 11, 909, 12, 909, 16654, 1, 910, + 1, 910, 1, 910, 1, 910, 4, 910, 16661, 8, 910, 11, 910, 12, 910, 16662, + 3, 910, 16665, 8, 910, 1, 910, 1, 910, 3, 910, 16669, 8, 910, 1, 911, 1, + 911, 1, 911, 1, 911, 5, 911, 16675, 8, 911, 10, 911, 12, 911, 16678, 9, + 911, 1, 911, 1, 911, 1, 911, 1, 912, 1, 912, 5, 912, 16685, 8, 912, 10, + 912, 12, 912, 16688, 9, 912, 3, 912, 16690, 8, 912, 1, 912, 1, 912, 1, + 913, 5, 913, 16695, 8, 913, 10, 913, 12, 913, 16698, 9, 913, 1, 913, 1, + 913, 1, 914, 1, 914, 5, 914, 16704, 8, 914, 10, 914, 12, 914, 16707, 9, + 914, 3, 914, 16709, 8, 914, 1, 914, 1, 914, 1, 915, 1, 915, 1, 915, 1, + 915, 1, 915, 3, 915, 16718, 8, 915, 1, 916, 1, 916, 1, 916, 1, 916, 1, + 916, 3, 916, 16725, 8, 916, 1, 916, 1, 916, 3, 916, 16729, 8, 916, 1, 916, + 3, 916, 16732, 8, 916, 1, 917, 1, 917, 1, 917, 1, 918, 1, 918, 1, 918, + 1, 918, 1, 918, 1, 918, 1, 918, 3, 918, 16744, 8, 918, 1, 919, 1, 919, + 1, 919, 1, 919, 3, 919, 16750, 8, 919, 1, 920, 1, 920, 1, 920, 1, 921, + 1, 921, 1, 921, 1, 921, 3, 921, 16759, 8, 921, 1, 921, 3, 921, 16762, 8, + 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 5, 922, 16770, 8, + 922, 10, 922, 12, 922, 16773, 9, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, + 922, 1, 922, 5, 922, 16781, 8, 922, 10, 922, 12, 922, 16784, 9, 922, 1, + 922, 1, 922, 1, 922, 3, 922, 16789, 8, 922, 3, 922, 16791, 8, 922, 3, 922, + 16793, 8, 922, 1, 923, 1, 923, 3, 923, 16797, 8, 923, 1, 924, 1, 924, 1, + 924, 1, 924, 1, 924, 3, 924, 16804, 8, 924, 1, 924, 3, 924, 16807, 8, 924, + 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 3, 925, 16814, 8, 925, 1, 926, + 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 3, 926, + 16825, 8, 926, 1, 926, 1, 926, 1, 926, 1, 926, 3, 926, 16831, 8, 926, 1, + 926, 1, 926, 3, 926, 16835, 8, 926, 1, 927, 1, 927, 1, 927, 1, 927, 1, + 927, 1, 927, 5, 927, 16843, 8, 927, 10, 927, 12, 927, 16846, 9, 927, 3, + 927, 16848, 8, 927, 1, 927, 1, 927, 1, 928, 1, 928, 3, 928, 16854, 8, 928, + 1, 928, 3, 928, 16857, 8, 928, 1, 928, 1, 928, 1, 928, 3, 928, 16862, 8, + 928, 1, 928, 1, 928, 1, 928, 1, 928, 3, 928, 16868, 8, 928, 1, 928, 1, + 928, 1, 928, 3, 928, 16873, 8, 928, 3, 928, 16875, 8, 928, 1, 929, 1, 929, + 1, 929, 5, 929, 16880, 8, 929, 10, 929, 12, 929, 16883, 9, 929, 1, 930, + 1, 930, 3, 930, 16887, 8, 930, 1, 930, 1, 930, 3, 930, 16891, 8, 930, 1, + 930, 1, 930, 1, 930, 3, 930, 16896, 8, 930, 1, 931, 1, 931, 1, 931, 1, + 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 5, 932, 16908, 8, + 932, 10, 932, 12, 932, 16911, 9, 932, 1, 932, 1, 932, 3, 932, 16915, 8, + 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 3, 932, 16922, 8, 932, 3, + 932, 16924, 8, 932, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 3, + 933, 16932, 8, 933, 1, 933, 1, 933, 3, 933, 16936, 8, 933, 1, 933, 1, 933, + 1, 933, 1, 933, 1, 933, 1, 933, 3, 933, 16944, 8, 933, 1, 934, 3, 934, + 16947, 8, 934, 1, 934, 1, 934, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, + 5, 935, 16956, 8, 935, 10, 935, 12, 935, 16959, 9, 935, 1, 936, 1, 936, + 1, 936, 5, 936, 16964, 8, 936, 10, 936, 12, 936, 16967, 9, 936, 1, 936, + 1, 936, 1, 936, 5, 936, 16972, 8, 936, 10, 936, 12, 936, 16975, 9, 936, + 1, 936, 1, 936, 1, 936, 4, 936, 16980, 8, 936, 11, 936, 12, 936, 16981, + 1, 936, 1, 936, 1, 936, 5, 936, 16987, 8, 936, 10, 936, 12, 936, 16990, + 9, 936, 3, 936, 16992, 8, 936, 3, 936, 16994, 8, 936, 1, 937, 1, 937, 3, + 937, 16998, 8, 937, 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, 3, 938, 17012, 8, + 938, 1, 938, 3, 938, 17015, 8, 938, 1, 939, 1, 939, 1, 939, 1, 939, 1, + 939, 1, 939, 3, 939, 17023, 8, 939, 1, 939, 3, 939, 17026, 8, 939, 1, 939, + 1, 939, 3, 939, 17030, 8, 939, 1, 939, 1, 939, 3, 939, 17034, 8, 939, 1, + 939, 1, 939, 1, 939, 3, 939, 17039, 8, 939, 1, 939, 3, 939, 17042, 8, 939, + 1, 939, 1, 939, 3, 939, 17046, 8, 939, 1, 939, 1, 939, 3, 939, 17050, 8, + 939, 5, 939, 17052, 8, 939, 10, 939, 12, 939, 17055, 9, 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, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, + 941, 1, 942, 1, 942, 1, 942, 3, 942, 17080, 8, 942, 1, 942, 3, 942, 17083, + 8, 942, 1, 942, 3, 942, 17086, 8, 942, 1, 943, 1, 943, 1, 943, 1, 943, + 1, 943, 5, 943, 17093, 8, 943, 10, 943, 12, 943, 17096, 9, 943, 1, 943, + 1, 943, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 5, 944, 17106, + 8, 944, 10, 944, 12, 944, 17109, 9, 944, 1, 944, 1, 944, 1, 945, 1, 945, + 3, 945, 17115, 8, 945, 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, 946, + 1, 946, 1, 946, 1, 946, 5, 946, 17126, 8, 946, 10, 946, 12, 946, 17129, + 9, 946, 1, 946, 1, 946, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, + 1, 948, 1, 948, 5, 948, 17141, 8, 948, 10, 948, 12, 948, 17144, 9, 948, + 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 3, 949, 17151, 8, 949, 1, 950, + 1, 950, 3, 950, 17155, 8, 950, 1, 950, 1, 950, 3, 950, 17159, 8, 950, 1, + 950, 1, 950, 1, 951, 1, 951, 3, 951, 17165, 8, 951, 1, 951, 1, 951, 3, + 951, 17169, 8, 951, 1, 951, 3, 951, 17172, 8, 951, 1, 951, 3, 951, 17175, + 8, 951, 1, 951, 1, 951, 5, 951, 17179, 8, 951, 10, 951, 12, 951, 17182, + 9, 951, 1, 951, 3, 951, 17185, 8, 951, 1, 951, 3, 951, 17188, 8, 951, 1, + 951, 3, 951, 17191, 8, 951, 1, 951, 3, 951, 17194, 8, 951, 1, 952, 1, 952, + 1, 952, 1, 952, 5, 952, 17200, 8, 952, 10, 952, 12, 952, 17203, 9, 952, + 3, 952, 17205, 8, 952, 1, 953, 1, 953, 1, 953, 1, 954, 1, 954, 1, 954, + 1, 954, 1, 954, 1, 954, 3, 954, 17216, 8, 954, 3, 954, 17218, 8, 954, 1, + 955, 1, 955, 1, 955, 5, 955, 17223, 8, 955, 10, 955, 12, 955, 17226, 9, + 955, 1, 956, 1, 956, 5, 956, 17230, 8, 956, 10, 956, 12, 956, 17233, 9, + 956, 1, 956, 1, 956, 3, 956, 17237, 8, 956, 1, 957, 1, 957, 5, 957, 17241, + 8, 957, 10, 957, 12, 957, 17244, 9, 957, 1, 957, 1, 957, 3, 957, 17248, + 8, 957, 1, 958, 1, 958, 1, 958, 3, 958, 17253, 8, 958, 1, 958, 1, 958, + 1, 958, 5, 958, 17258, 8, 958, 10, 958, 12, 958, 17261, 9, 958, 1, 958, + 1, 958, 1, 958, 3, 958, 17266, 8, 958, 1, 958, 1, 958, 1, 958, 1, 958, + 1, 958, 3, 958, 17273, 8, 958, 1, 959, 3, 959, 17276, 8, 959, 1, 959, 3, + 959, 17279, 8, 959, 1, 959, 1, 959, 3, 959, 17283, 8, 959, 1, 959, 1, 959, + 1, 959, 3, 959, 17288, 8, 959, 1, 959, 1, 959, 5, 959, 17292, 8, 959, 10, + 959, 12, 959, 17295, 9, 959, 1, 959, 1, 959, 1, 959, 3, 959, 17300, 8, + 959, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, 961, 1, 962, 1, 962, 3, + 962, 17310, 8, 962, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 3, 963, 17317, + 8, 963, 1, 963, 1, 963, 3, 963, 17321, 8, 963, 1, 964, 1, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 3, 964, 17331, 8, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 3, 964, 17346, 8, 964, 3, 964, 17348, 8, 964, 1, + 965, 1, 965, 3, 965, 17352, 8, 965, 1, 965, 1, 965, 1, 965, 1, 965, 5, + 965, 17358, 8, 965, 10, 965, 12, 965, 17361, 9, 965, 1, 965, 1, 965, 1, + 965, 1, 965, 3, 965, 17367, 8, 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, + 966, 1, 966, 3, 966, 17375, 8, 966, 1, 966, 3, 966, 17378, 8, 966, 1, 967, + 1, 967, 1, 967, 3, 967, 17383, 8, 967, 1, 968, 1, 968, 1, 968, 1, 968, + 1, 968, 1, 968, 5, 968, 17391, 8, 968, 10, 968, 12, 968, 17394, 9, 968, + 1, 968, 1, 968, 1, 968, 5, 968, 17399, 8, 968, 10, 968, 12, 968, 17402, + 9, 968, 3, 968, 17404, 8, 968, 1, 968, 1, 968, 1, 969, 1, 969, 3, 969, + 17410, 8, 969, 1, 970, 1, 970, 1, 970, 3, 970, 17415, 8, 970, 1, 970, 3, + 970, 17418, 8, 970, 1, 971, 1, 971, 1, 971, 3, 971, 17423, 8, 971, 1, 971, + 1, 971, 1, 971, 3, 971, 17428, 8, 971, 1, 971, 1, 971, 1, 971, 1, 971, + 3, 971, 17434, 8, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 5, 972, + 17441, 8, 972, 10, 972, 12, 972, 17444, 9, 972, 1, 972, 1, 972, 1, 973, + 1, 973, 3, 973, 17450, 8, 973, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, + 1, 973, 5, 973, 17458, 8, 973, 10, 973, 12, 973, 17461, 9, 973, 1, 973, + 1, 973, 3, 973, 17465, 8, 973, 3, 973, 17467, 8, 973, 1, 974, 1, 974, 1, + 974, 3, 974, 17472, 8, 974, 1, 974, 1, 974, 3, 974, 17476, 8, 974, 1, 974, + 1, 974, 1, 974, 1, 974, 3, 974, 17482, 8, 974, 1, 974, 1, 974, 3, 974, + 17486, 8, 974, 1, 975, 1, 975, 1, 975, 1, 975, 1, 976, 1, 976, 1, 976, + 1, 976, 1, 976, 5, 976, 17497, 8, 976, 10, 976, 12, 976, 17500, 9, 976, + 1, 976, 3, 976, 17503, 8, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, + 1, 976, 5, 976, 17511, 8, 976, 10, 976, 12, 976, 17514, 9, 976, 3, 976, + 17516, 8, 976, 3, 976, 17518, 8, 976, 1, 977, 1, 977, 1, 977, 3, 977, 17523, + 8, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 5, 978, 17530, 8, 978, + 10, 978, 12, 978, 17533, 9, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, + 1, 979, 1, 979, 1, 979, 5, 979, 17543, 8, 979, 10, 979, 12, 979, 17546, + 9, 979, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 3, 980, 17553, 8, 980, + 1, 980, 1, 980, 3, 980, 17557, 8, 980, 1, 981, 1, 981, 1, 981, 1, 982, + 1, 982, 5, 982, 17564, 8, 982, 10, 982, 12, 982, 17567, 9, 982, 1, 982, + 3, 982, 17570, 8, 982, 1, 982, 5, 982, 17573, 8, 982, 10, 982, 12, 982, + 17576, 9, 982, 1, 982, 1, 982, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, + 1, 983, 3, 983, 17586, 8, 983, 3, 983, 17588, 8, 983, 1, 984, 1, 984, 1, + 984, 1, 984, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, + 985, 5, 985, 17602, 8, 985, 10, 985, 12, 985, 17605, 9, 985, 1, 986, 1, + 986, 3, 986, 17609, 8, 986, 1, 986, 1, 986, 5, 986, 17613, 8, 986, 10, + 986, 12, 986, 17616, 9, 986, 1, 986, 1, 986, 1, 987, 3, 987, 17621, 8, + 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 988, 1, 988, 1, + 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 5, 989, 17637, 8, 989, 10, + 989, 12, 989, 17640, 9, 989, 1, 989, 1, 989, 1, 990, 1, 990, 3, 990, 17646, + 8, 990, 1, 990, 3, 990, 17649, 8, 990, 1, 991, 3, 991, 17652, 8, 991, 1, + 991, 1, 991, 1, 991, 1, 991, 5, 991, 17658, 8, 991, 10, 991, 12, 991, 17661, + 9, 991, 3, 991, 17663, 8, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 992, + 1, 992, 3, 992, 17671, 8, 992, 3, 992, 17673, 8, 992, 1, 992, 1, 992, 3, + 992, 17677, 8, 992, 1, 992, 3, 992, 17680, 8, 992, 1, 993, 1, 993, 1, 993, + 3, 993, 17685, 8, 993, 3, 993, 17687, 8, 993, 1, 993, 1, 993, 3, 993, 17691, + 8, 993, 1, 993, 1, 993, 1, 993, 1, 994, 1, 994, 1, 995, 1, 995, 1, 995, + 1, 995, 1, 995, 3, 995, 17703, 8, 995, 1, 996, 1, 996, 1, 996, 1, 996, + 1, 996, 1, 997, 1, 997, 3, 997, 17712, 8, 997, 1, 997, 1, 997, 1, 997, + 1, 997, 5, 997, 17718, 8, 997, 10, 997, 12, 997, 17721, 9, 997, 1, 998, + 1, 998, 3, 998, 17725, 8, 998, 1, 998, 1, 998, 3, 998, 17729, 8, 998, 1, + 999, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 3, 1000, + 17739, 8, 1000, 3, 1000, 17741, 8, 1000, 1, 1000, 1, 1000, 1, 1000, 1, + 1000, 3, 1000, 17747, 8, 1000, 1, 1001, 1, 1001, 1, 1001, 3, 1001, 17752, + 8, 1001, 1, 1001, 3, 1001, 17755, 8, 1001, 1, 1002, 1, 1002, 1, 1002, 1, + 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 3, 1003, 17765, 8, 1003, 1, 1004, + 1, 1004, 1, 1004, 1, 1004, 3, 1004, 17771, 8, 1004, 1, 1004, 3, 1004, 17774, + 8, 1004, 1, 1004, 3, 1004, 17777, 8, 1004, 1, 1005, 1, 1005, 1, 1005, 1, + 1005, 5, 1005, 17783, 8, 1005, 10, 1005, 12, 1005, 17786, 9, 1005, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 17795, 8, + 1005, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, + 1006, 3, 1006, 17805, 8, 1006, 1, 1007, 1, 1007, 3, 1007, 17809, 8, 1007, + 1, 1007, 1, 1007, 3, 1007, 17813, 8, 1007, 1, 1007, 3, 1007, 17816, 8, + 1007, 1, 1007, 3, 1007, 17819, 8, 1007, 1, 1008, 1, 1008, 1, 1008, 3, 1008, + 17824, 8, 1008, 1, 1009, 1, 1009, 1, 1009, 3, 1009, 17829, 8, 1009, 1, + 1009, 3, 1009, 17832, 8, 1009, 1, 1009, 3, 1009, 17835, 8, 1009, 1, 1010, + 1, 1010, 4, 1010, 17839, 8, 1010, 11, 1010, 12, 1010, 17840, 1, 1010, 3, + 1010, 17844, 8, 1010, 1, 1010, 1, 1010, 1, 1011, 1, 1011, 3, 1011, 17850, + 8, 1011, 1, 1011, 3, 1011, 17853, 8, 1011, 1, 1012, 3, 1012, 17856, 8, + 1012, 1, 1012, 4, 1012, 17859, 8, 1012, 11, 1012, 12, 1012, 17860, 1, 1012, + 3, 1012, 17864, 8, 1012, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 4, 1013, 17870, + 8, 1013, 11, 1013, 12, 1013, 17871, 1, 1014, 1, 1014, 4, 1014, 17876, 8, + 1014, 11, 1014, 12, 1014, 17877, 1, 1015, 1, 1015, 1, 1015, 3, 1015, 17883, + 8, 1015, 1, 1015, 3, 1015, 17886, 8, 1015, 1, 1016, 1, 1016, 1, 1016, 1, + 1016, 1, 1016, 1, 1016, 1, 1016, 3, 1016, 17895, 8, 1016, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, + 1, 1017, 3, 1017, 17908, 8, 1017, 1, 1017, 1, 1017, 3, 1017, 17912, 8, + 1017, 3, 1017, 17914, 8, 1017, 1, 1017, 3, 1017, 17917, 8, 1017, 1, 1017, + 3, 1017, 17920, 8, 1017, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, + 1018, 1, 1018, 1, 1018, 5, 1018, 17930, 8, 1018, 10, 1018, 12, 1018, 17933, + 9, 1018, 1, 1018, 3, 1018, 17936, 8, 1018, 1, 1018, 3, 1018, 17939, 8, + 1018, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1020, 1, 1020, 1, 1020, 1, + 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 3, 1021, 17954, 8, 1021, + 1, 1021, 1, 1021, 3, 1021, 17958, 8, 1021, 1, 1022, 1, 1022, 1, 1022, 1, + 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 3, 1022, 17970, + 8, 1022, 1, 1022, 3, 1022, 17973, 8, 1022, 1, 1023, 1, 1023, 1, 1023, 1, + 1023, 1, 1023, 5, 1023, 17980, 8, 1023, 10, 1023, 12, 1023, 17983, 9, 1023, + 1, 1023, 1, 1023, 1, 1023, 1, 1023, 3, 1023, 17989, 8, 1023, 1, 1024, 1, + 1024, 1, 1024, 3, 1024, 17994, 8, 1024, 1, 1025, 1, 1025, 3, 1025, 17998, + 8, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, + 18006, 8, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 18012, 8, + 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 3, 1027, 18020, + 8, 1027, 1, 1027, 3, 1027, 18023, 8, 1027, 1, 1028, 1, 1028, 1, 1028, 1, + 1028, 1, 1029, 1, 1029, 1, 1029, 3, 1029, 18032, 8, 1029, 1, 1029, 3, 1029, + 18035, 8, 1029, 1, 1029, 3, 1029, 18038, 8, 1029, 1, 1030, 1, 1030, 1, + 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 3, 1031, 18047, 8, 1031, 1, 1032, + 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18053, 8, 1032, 1, 1032, 1, 1032, 1, + 1032, 1, 1032, 3, 1032, 18059, 8, 1032, 1, 1032, 3, 1032, 18062, 8, 1032, + 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18067, 8, 1032, 1, 1032, 1, 1032, 1, + 1032, 1, 1032, 3, 1032, 18073, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, + 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 18085, 8, + 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, + 1033, 1, 1033, 3, 1033, 18096, 8, 1033, 3, 1033, 18098, 8, 1033, 1, 1034, + 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 3, 1034, 18107, 8, + 1034, 3, 1034, 18109, 8, 1034, 1, 1035, 1, 1035, 3, 1035, 18113, 8, 1035, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 3, 1035, 18119, 8, 1035, 1, 1035, 1, + 1035, 3, 1035, 18123, 8, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, + 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 3, 1037, 18136, 8, + 1037, 1, 1038, 1, 1038, 1, 1038, 5, 1038, 18141, 8, 1038, 10, 1038, 12, + 1038, 18144, 9, 1038, 1, 1039, 1, 1039, 3, 1039, 18148, 8, 1039, 1, 1040, + 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, + 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 5, 1041, 18164, 8, 1041, 10, + 1041, 12, 1041, 18167, 9, 1041, 1, 1042, 3, 1042, 18170, 8, 1042, 1, 1042, + 1, 1042, 3, 1042, 18174, 8, 1042, 1, 1043, 1, 1043, 3, 1043, 18178, 8, + 1043, 1, 1043, 1, 1043, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, + 1044, 1, 1044, 1, 1044, 1, 1044, 3, 1044, 18191, 8, 1044, 1, 1044, 1, 1044, + 3, 1044, 18195, 8, 1044, 1, 1044, 1, 1044, 1, 1044, 5, 1044, 18200, 8, + 1044, 10, 1044, 12, 1044, 18203, 9, 1044, 1, 1044, 1, 1044, 1, 1044, 1, + 1044, 1, 1044, 3, 1044, 18210, 8, 1044, 1, 1044, 3, 1044, 18213, 8, 1044, + 1, 1044, 1, 1044, 1, 1044, 3, 1044, 18218, 8, 1044, 3, 1044, 18220, 8, + 1044, 1, 1045, 1, 1045, 1, 1045, 3, 1045, 18225, 8, 1045, 1, 1045, 1, 1045, + 3, 1045, 18229, 8, 1045, 1, 1045, 3, 1045, 18232, 8, 1045, 1, 1045, 1, + 1045, 1, 1045, 1, 1045, 3, 1045, 18238, 8, 1045, 1, 1045, 5, 1045, 18241, + 8, 1045, 10, 1045, 12, 1045, 18244, 9, 1045, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 3, 1046, 18255, 8, + 1046, 1, 1046, 1, 1046, 5, 1046, 18259, 8, 1046, 10, 1046, 12, 1046, 18262, + 9, 1046, 1, 1047, 1, 1047, 3, 1047, 18266, 8, 1047, 1, 1047, 1, 1047, 1, + 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 3, 1047, 18276, 8, 1047, + 3, 1047, 18278, 8, 1047, 3, 1047, 18280, 8, 1047, 1, 1048, 1, 1048, 1, + 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 3, 1048, 18290, 8, 1048, + 1, 1048, 1, 1048, 3, 1048, 18294, 8, 1048, 3, 1048, 18296, 8, 1048, 1, + 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 5, + 1049, 18306, 8, 1049, 10, 1049, 12, 1049, 18309, 9, 1049, 1, 1049, 1, 1049, + 1, 1049, 1, 1049, 1, 1049, 3, 1049, 18316, 8, 1049, 1, 1050, 1, 1050, 1, + 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, + 1051, 3, 1051, 18329, 8, 1051, 1, 1051, 3, 1051, 18332, 8, 1051, 1, 1051, + 1, 1051, 1, 1051, 3, 1051, 18337, 8, 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, 5, 1051, 18355, 8, 1051, 10, + 1051, 12, 1051, 18358, 9, 1051, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, + 1052, 3, 1052, 18365, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 3, 1052, 18373, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, + 1052, 3, 1052, 18380, 8, 1052, 1, 1052, 1, 1052, 3, 1052, 18384, 8, 1052, + 1, 1053, 3, 1053, 18387, 8, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, + 1053, 3, 1053, 18394, 8, 1053, 1, 1054, 1, 1054, 3, 1054, 18398, 8, 1054, + 1, 1054, 1, 1054, 1, 1054, 3, 1054, 18403, 8, 1054, 5, 1054, 18405, 8, + 1054, 10, 1054, 12, 1054, 18408, 9, 1054, 1, 1054, 1, 1054, 1, 1054, 5, + 1054, 18413, 8, 1054, 10, 1054, 12, 1054, 18416, 9, 1054, 1, 1054, 3, 1054, + 18419, 8, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18426, + 8, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18431, 8, 1055, 1, 1055, 1, + 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 3, 1055, 18440, 8, 1055, + 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 3, 1056, + 18449, 8, 1056, 1, 1056, 3, 1056, 18452, 8, 1056, 1, 1056, 1, 1056, 1, + 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, + 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 3, + 1057, 18472, 8, 1057, 3, 1057, 18474, 8, 1057, 3, 1057, 18476, 8, 1057, + 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 3, 1058, 18484, 8, + 1058, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, + 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 3, + 1059, 18501, 8, 1059, 3, 1059, 18503, 8, 1059, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 5, 1060, 18511, 8, 1060, 10, 1060, 12, 1060, + 18514, 9, 1060, 1, 1061, 1, 1061, 3, 1061, 18518, 8, 1061, 1, 1062, 3, + 1062, 18521, 8, 1062, 1, 1062, 1, 1062, 1, 1062, 4, 1062, 18526, 8, 1062, + 11, 1062, 12, 1062, 18527, 1, 1062, 3, 1062, 18531, 8, 1062, 1, 1062, 1, + 1062, 3, 1062, 18535, 8, 1062, 1, 1062, 3, 1062, 18538, 8, 1062, 1, 1063, + 3, 1063, 18541, 8, 1063, 1, 1063, 1, 1063, 4, 1063, 18545, 8, 1063, 11, + 1063, 12, 1063, 18546, 1, 1063, 3, 1063, 18550, 8, 1063, 1, 1063, 1, 1063, + 3, 1063, 18554, 8, 1063, 1, 1063, 3, 1063, 18557, 8, 1063, 1, 1064, 1, + 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1065, 1, 1065, 1, 1065, 1, 1066, 1, + 1066, 3, 1066, 18569, 8, 1066, 1, 1067, 1, 1067, 1, 1067, 4, 1067, 18574, + 8, 1067, 11, 1067, 12, 1067, 18575, 1, 1067, 3, 1067, 18579, 8, 1067, 1, + 1067, 1, 1067, 3, 1067, 18583, 8, 1067, 1, 1068, 1, 1068, 4, 1068, 18587, + 8, 1068, 11, 1068, 12, 1068, 18588, 1, 1068, 3, 1068, 18592, 8, 1068, 1, + 1068, 1, 1068, 3, 1068, 18596, 8, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, 1, 1071, 1, 1071, + 1, 1071, 3, 1071, 18611, 8, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 5, + 1071, 18617, 8, 1071, 10, 1071, 12, 1071, 18620, 9, 1071, 1, 1071, 1, 1071, + 1, 1071, 1, 1071, 3, 1071, 18626, 8, 1071, 1, 1072, 1, 1072, 1, 1072, 1, + 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 5, 1072, 18637, 8, 1072, + 10, 1072, 12, 1072, 18640, 9, 1072, 1, 1072, 1, 1072, 3, 1072, 18644, 8, + 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, + 1073, 18653, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 3, 1073, 18662, 8, 1073, 1, 1073, 1, 1073, 3, 1073, 18666, 8, + 1073, 1, 1073, 1, 1073, 3, 1073, 18670, 8, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18696, 8, 1073, 1, + 1073, 3, 1073, 18699, 8, 1073, 1, 1073, 3, 1073, 18702, 8, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, + 18712, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, + 1073, 18720, 8, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 3, 1073, 18726, + 8, 1073, 3, 1073, 18728, 8, 1073, 1, 1073, 1, 1073, 3, 1073, 18732, 8, + 1073, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18739, 8, 1074, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 5, 1075, 18746, 8, 1075, 10, + 1075, 12, 1075, 18749, 9, 1075, 1, 1075, 3, 1075, 18752, 8, 1075, 1, 1075, + 3, 1075, 18755, 8, 1075, 1, 1075, 3, 1075, 18758, 8, 1075, 1, 1075, 1, + 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18767, 8, 1075, + 1, 1075, 3, 1075, 18770, 8, 1075, 1, 1075, 3, 1075, 18773, 8, 1075, 1, + 1075, 3, 1075, 18776, 8, 1075, 1, 1075, 3, 1075, 18779, 8, 1075, 1, 1075, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 3, 1075, 18791, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, + 1075, 1, 1075, 3, 1075, 18799, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 3, 1075, 18806, 8, 1075, 1, 1075, 3, 1075, 18809, 8, 1075, 1, + 1075, 1, 1075, 3, 1075, 18813, 8, 1075, 3, 1075, 18815, 8, 1075, 1, 1075, + 3, 1075, 18818, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18823, 8, + 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, + 1075, 18832, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18838, + 8, 1075, 1, 1075, 3, 1075, 18841, 8, 1075, 1, 1075, 3, 1075, 18844, 8, + 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, + 1075, 18853, 8, 1075, 1, 1075, 3, 1075, 18856, 8, 1075, 1, 1075, 3, 1075, + 18859, 8, 1075, 1, 1075, 3, 1075, 18862, 8, 1075, 1, 1075, 1, 1075, 1, + 1075, 1, 1075, 3, 1075, 18868, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18872, + 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 5, 1075, 18882, 8, 1075, 10, 1075, 12, 1075, 18885, 9, 1075, 1, + 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18894, + 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18898, 8, 1075, 1, 1075, 3, 1075, 18901, + 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 3, 1075, 18907, 8, 1075, 1, + 1075, 1, 1075, 3, 1075, 18911, 8, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 3, 1075, 18917, 8, 1075, 1, 1075, 1, 1075, 3, 1075, 18921, 8, 1075, 1, + 1075, 3, 1075, 18924, 8, 1075, 1, 1075, 3, 1075, 18927, 8, 1075, 3, 1075, + 18929, 8, 1075, 1, 1076, 1, 1076, 1, 1076, 5, 1076, 18934, 8, 1076, 10, + 1076, 12, 1076, 18937, 9, 1076, 1, 1076, 3, 1076, 18940, 8, 1076, 1, 1076, + 3, 1076, 18943, 8, 1076, 1, 1076, 3, 1076, 18946, 8, 1076, 1, 1076, 3, + 1076, 18949, 8, 1076, 1, 1076, 1, 1076, 1, 1076, 3, 1076, 18954, 8, 1076, + 1, 1077, 3, 1077, 18957, 8, 1077, 1, 1077, 1, 1077, 3, 1077, 18961, 8, + 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 3, + 1077, 18970, 8, 1077, 1, 1077, 1, 1077, 3, 1077, 18974, 8, 1077, 1, 1078, + 1, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18981, 8, 1078, 1, 1078, 1, + 1078, 3, 1078, 18985, 8, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18990, + 8, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18995, 8, 1078, 1, 1078, 3, + 1078, 18998, 8, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 3, 1079, 19007, 8, 1079, 1, 1079, 1, 1079, 3, 1079, 19011, 8, + 1079, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, 1, 1081, 1, + 1081, 1, 1081, 3, 1081, 19022, 8, 1081, 1, 1081, 3, 1081, 19025, 8, 1081, + 1, 1081, 1, 1081, 3, 1081, 19029, 8, 1081, 1, 1082, 1, 1082, 1, 1082, 3, + 1082, 19034, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19038, 8, 1082, 1, 1082, + 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19047, 8, + 1082, 1, 1082, 3, 1082, 19050, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19054, + 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, + 3, 1082, 19063, 8, 1082, 1, 1082, 3, 1082, 19066, 8, 1082, 1, 1082, 1, + 1082, 3, 1082, 19070, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19075, + 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, + 3, 1082, 19084, 8, 1082, 1, 1082, 3, 1082, 19087, 8, 1082, 1, 1082, 1, + 1082, 3, 1082, 19091, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, + 1, 1082, 3, 1082, 19099, 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19104, + 8, 1082, 1, 1082, 1, 1082, 1, 1082, 3, 1082, 19109, 8, 1082, 1, 1082, 3, + 1082, 19112, 8, 1082, 1, 1082, 1, 1082, 3, 1082, 19116, 8, 1082, 3, 1082, + 19118, 8, 1082, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 5, 1083, 19125, + 8, 1083, 10, 1083, 12, 1083, 19128, 9, 1083, 1, 1083, 1, 1083, 1, 1084, + 1, 1084, 3, 1084, 19134, 8, 1084, 1, 1084, 3, 1084, 19137, 8, 1084, 1, + 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19144, 8, 1084, 3, 1084, + 19146, 8, 1084, 1, 1084, 3, 1084, 19149, 8, 1084, 1, 1084, 3, 1084, 19152, + 8, 1084, 1, 1084, 1, 1084, 3, 1084, 19156, 8, 1084, 1, 1084, 3, 1084, 19159, + 8, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19164, 8, 1084, 1, 1084, 1, + 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 19171, 8, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 3, 1084, 19177, 8, 1084, 1, 1084, 1, 1084, 1, 1084, 1, + 1084, 1, 1084, 1, 1084, 3, 1084, 19185, 8, 1084, 1, 1085, 1, 1085, 3, 1085, + 19189, 8, 1085, 1, 1085, 3, 1085, 19192, 8, 1085, 1, 1085, 3, 1085, 19195, + 8, 1085, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 3, 1086, 19201, 8, 1086, 1, + 1086, 3, 1086, 19204, 8, 1086, 1, 1086, 1, 1086, 3, 1086, 19208, 8, 1086, + 1, 1087, 1, 1087, 3, 1087, 19212, 8, 1087, 1, 1087, 1, 1087, 1, 1087, 3, + 1087, 19217, 8, 1087, 1, 1087, 3, 1087, 19220, 8, 1087, 1, 1087, 3, 1087, + 19223, 8, 1087, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, + 1088, 3, 1088, 19232, 8, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 19244, 8, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1090, 1, 1090, 3, 1090, 19251, 8, 1090, 1, 1090, + 3, 1090, 19254, 8, 1090, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 3, 1091, 19260, + 8, 1091, 1, 1091, 3, 1091, 19263, 8, 1091, 1, 1091, 3, 1091, 19266, 8, + 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 3, + 1091, 19275, 8, 1091, 1, 1091, 3, 1091, 19278, 8, 1091, 1, 1091, 1, 1091, + 1, 1091, 3, 1091, 19283, 8, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, + 1091, 3, 1091, 19290, 8, 1091, 3, 1091, 19292, 8, 1091, 1, 1092, 1, 1092, + 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, + 1, 1092, 3, 1092, 19305, 8, 1092, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, + 1093, 3, 1093, 19312, 8, 1093, 1, 1094, 1, 1094, 1, 1094, 3, 1094, 19317, + 8, 1094, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19322, 8, 1095, 1, 1095, 1, + 1095, 1, 1095, 1, 1095, 3, 1095, 19328, 8, 1095, 1, 1095, 1, 1095, 1, 1095, + 1, 1095, 3, 1095, 19334, 8, 1095, 1, 1095, 3, 1095, 19337, 8, 1095, 3, + 1095, 19339, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19344, 8, 1095, + 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19352, 8, + 1095, 3, 1095, 19354, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, + 3, 1095, 19361, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19367, + 8, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19372, 8, 1095, 1, 1095, 1, + 1095, 1, 1095, 1, 1095, 3, 1095, 19378, 8, 1095, 1, 1095, 1, 1095, 1, 1095, + 3, 1095, 19383, 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19389, + 8, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, + 1, 1095, 1, 1095, 1, 1095, 3, 1095, 19401, 8, 1095, 1, 1096, 1, 1096, 1, + 1096, 1, 1096, 3, 1096, 19407, 8, 1096, 1, 1096, 1, 1096, 3, 1096, 19411, + 8, 1096, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19416, 8, 1097, 1, 1097, 1, + 1097, 1, 1097, 3, 1097, 19421, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19427, 8, 1097, 1, 1097, 3, 1097, 19430, 8, 1097, 1, 1097, 1, + 1097, 3, 1097, 19434, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19444, 8, 1097, 1, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19454, 8, 1097, + 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19460, 8, 1097, 3, 1097, 19462, + 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1097, 3, 1097, 19472, 8, 1097, 3, 1097, 19474, 8, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19481, 8, 1097, 1, 1097, 1, 1097, + 3, 1097, 19485, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 4, + 1097, 19492, 8, 1097, 11, 1097, 12, 1097, 19493, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19499, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19504, 8, + 1097, 1, 1097, 3, 1097, 19507, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19516, 8, 1097, 1, 1097, 3, 1097, 19519, + 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19528, 8, 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, 3, 1097, 19542, + 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19549, 8, + 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19557, + 8, 1097, 1, 1097, 3, 1097, 19560, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, + 1097, 19573, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19579, + 8, 1097, 3, 1097, 19581, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19594, + 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19603, 8, 1097, 1, 1097, 1, 1097, 5, 1097, 19607, 8, 1097, 10, + 1097, 12, 1097, 19610, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 3, 1097, 19619, 8, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1097, 5, 1097, 19625, 8, 1097, 10, 1097, 12, 1097, 19628, 9, 1097, 1, + 1097, 1, 1097, 1, 1097, 3, 1097, 19633, 8, 1097, 1, 1097, 3, 1097, 19636, + 8, 1097, 1, 1097, 3, 1097, 19639, 8, 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, 3, 1097, 19653, 8, 1097, 3, 1097, 19655, 8, 1097, 1, 1097, 1, 1097, + 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19663, 8, 1097, 1, 1097, 1, + 1097, 1, 1097, 5, 1097, 19668, 8, 1097, 10, 1097, 12, 1097, 19671, 9, 1097, + 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19678, 8, 1097, 10, + 1097, 12, 1097, 19681, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19686, + 8, 1097, 10, 1097, 12, 1097, 19689, 9, 1097, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19694, 8, 1097, 1, 1097, 3, 1097, 19697, 8, 1097, 1, 1097, 1, + 1097, 1, 1097, 3, 1097, 19702, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, + 19707, 8, 1097, 5, 1097, 19709, 8, 1097, 10, 1097, 12, 1097, 19712, 9, + 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19717, 8, 1097, 10, 1097, 12, + 1097, 19720, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19726, + 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 3, 1097, 19735, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19740, 8, + 1097, 10, 1097, 12, 1097, 19743, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, + 1097, 1, 1097, 1, 1097, 3, 1097, 19751, 8, 1097, 1, 1097, 1, 1097, 3, 1097, + 19755, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19760, 8, 1097, 10, + 1097, 12, 1097, 19763, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, + 1097, 19769, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, + 19776, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19781, 8, 1097, 10, + 1097, 12, 1097, 19784, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, + 1097, 3, 1097, 19791, 8, 1097, 1, 1097, 1, 1097, 3, 1097, 19795, 8, 1097, + 1, 1097, 1, 1097, 1, 1097, 5, 1097, 19800, 8, 1097, 10, 1097, 12, 1097, + 19803, 9, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 3, + 1097, 19811, 8, 1097, 1, 1097, 3, 1097, 19814, 8, 1097, 1, 1097, 3, 1097, + 19817, 8, 1097, 1, 1097, 3, 1097, 19820, 8, 1097, 1, 1097, 1, 1097, 3, + 1097, 19824, 8, 1097, 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19829, 8, 1097, + 1, 1097, 1, 1097, 1, 1097, 3, 1097, 19834, 8, 1097, 1, 1098, 1, 1098, 1, + 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1101, 1, 1101, 1, 1101, 3, 1101, 19845, + 8, 1101, 1, 1101, 1, 1101, 3, 1101, 19849, 8, 1101, 3, 1101, 19851, 8, + 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, + 1101, 1, 1101, 3, 1101, 19862, 8, 1101, 3, 1101, 19864, 8, 1101, 1, 1101, + 1, 1101, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, + 3, 1102, 19875, 8, 1102, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, + 1104, 1, 1104, 1, 1104, 1, 1104, 3, 1104, 19886, 8, 1104, 1, 1105, 1, 1105, + 1, 1105, 1, 1105, 1, 1105, 5, 1105, 19893, 8, 1105, 10, 1105, 12, 1105, + 19896, 9, 1105, 3, 1105, 19898, 8, 1105, 1, 1106, 1, 1106, 1, 1106, 1, + 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 3, 1106, 19908, 8, 1106, 1, 1107, + 1, 1107, 3, 1107, 19912, 8, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, + 1108, 5, 1108, 19919, 8, 1108, 10, 1108, 12, 1108, 19922, 9, 1108, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 3, 1109, 19931, 8, + 1109, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, + 1110, 3, 1110, 19941, 8, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 5, 1110, + 19947, 8, 1110, 10, 1110, 12, 1110, 19950, 9, 1110, 1, 1111, 1, 1111, 1, + 1111, 3, 1111, 19955, 8, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 5, 1111, + 19961, 8, 1111, 10, 1111, 12, 1111, 19964, 9, 1111, 1, 1111, 1, 1111, 1, + 1111, 1, 1111, 3, 1111, 19970, 8, 1111, 1, 1111, 1, 1111, 3, 1111, 19974, + 8, 1111, 1, 1112, 1, 1112, 1, 1112, 3, 1112, 19979, 8, 1112, 1, 1112, 1, + 1112, 3, 1112, 19983, 8, 1112, 1, 1112, 1, 1112, 1, 1112, 3, 1112, 19988, + 8, 1112, 5, 1112, 19990, 8, 1112, 10, 1112, 12, 1112, 19993, 9, 1112, 1, + 1113, 1, 1113, 1, 1113, 3, 1113, 19998, 8, 1113, 1, 1113, 3, 1113, 20001, + 8, 1113, 1, 1113, 1, 1113, 1, 1113, 5, 1113, 20006, 8, 1113, 10, 1113, + 12, 1113, 20009, 9, 1113, 1, 1113, 1, 1113, 1, 1114, 1, 1114, 1, 1114, + 1, 1114, 1, 1114, 3, 1114, 20018, 8, 1114, 1, 1114, 1, 1114, 1, 1114, 1, + 1114, 5, 1114, 20024, 8, 1114, 10, 1114, 12, 1114, 20027, 9, 1114, 1, 1114, + 3, 1114, 20030, 8, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, + 1115, 1, 1115, 1, 1115, 3, 1115, 20040, 8, 1115, 1, 1115, 3, 1115, 20043, + 8, 1115, 3, 1115, 20045, 8, 1115, 1, 1116, 1, 1116, 1, 1116, 1, 1117, 1, + 1117, 3, 1117, 20052, 8, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 3, 1117, + 20058, 8, 1117, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 3, 1118, 20064, 8, + 1118, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 3, 1119, 20070, 8, 1119, 3, 1119, + 20072, 8, 1119, 1, 1120, 1, 1120, 1, 1120, 1, 1121, 1, 1121, 1, 1121, 1, + 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 3, 1122, 20086, 8, 1122, + 3, 1122, 20088, 8, 1122, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, + 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 3, 1124, 20101, 8, 1124, + 1, 1124, 1, 1124, 1, 1124, 3, 1124, 20106, 8, 1124, 1, 1124, 3, 1124, 20109, + 8, 1124, 1, 1124, 1, 1124, 1, 1124, 5, 1124, 20114, 8, 1124, 10, 1124, + 12, 1124, 20117, 9, 1124, 1, 1125, 1, 1125, 3, 1125, 20121, 8, 1125, 1, + 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, + 1126, 3, 1126, 20132, 8, 1126, 1, 1127, 1, 1127, 1, 1127, 3, 1127, 20137, + 8, 1127, 3, 1127, 20139, 8, 1127, 1, 1127, 1, 1127, 1, 1128, 1, 1128, 1, + 1128, 3, 1128, 20146, 8, 1128, 1, 1128, 3, 1128, 20149, 8, 1128, 1, 1128, + 1, 1128, 1, 1128, 5, 1128, 20154, 8, 1128, 10, 1128, 12, 1128, 20157, 9, + 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, 3, 1129, 20171, 8, 1129, 1, 1129, + 3, 1129, 20174, 8, 1129, 1, 1129, 1, 1129, 3, 1129, 20178, 8, 1129, 3, + 1129, 20180, 8, 1129, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 4, 1130, 20186, + 8, 1130, 11, 1130, 12, 1130, 20187, 1, 1130, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 3, 1130, 20196, 8, 1130, 3, 1130, 20198, 8, 1130, 1, + 1131, 1, 1131, 1, 1131, 5, 1131, 20203, 8, 1131, 10, 1131, 12, 1131, 20206, + 9, 1131, 1, 1131, 1, 1131, 3, 1131, 20210, 8, 1131, 1, 1132, 1, 1132, 3, + 1132, 20214, 8, 1132, 1, 1132, 1, 1132, 3, 1132, 20218, 8, 1132, 1, 1133, + 1, 1133, 3, 1133, 20222, 8, 1133, 1, 1133, 1, 1133, 3, 1133, 20226, 8, + 1133, 1, 1133, 1, 1133, 1, 1134, 3, 1134, 20231, 8, 1134, 1, 1134, 1, 1134, + 3, 1134, 20235, 8, 1134, 1, 1134, 3, 1134, 20238, 8, 1134, 1, 1135, 1, + 1135, 3, 1135, 20242, 8, 1135, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, + 3, 1136, 20249, 8, 1136, 1, 1137, 1, 1137, 3, 1137, 20253, 8, 1137, 1, + 1137, 1, 1137, 1, 1137, 3, 1137, 20258, 8, 1137, 1, 1137, 1, 1137, 1, 1137, + 3, 1137, 20263, 8, 1137, 5, 1137, 20265, 8, 1137, 10, 1137, 12, 1137, 20268, + 9, 1137, 1, 1138, 1, 1138, 3, 1138, 20272, 8, 1138, 1, 1139, 1, 1139, 1, + 1140, 1, 1140, 1, 1141, 1, 1141, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, + 1144, 1, 1144, 1, 1144, 5, 1144, 20287, 8, 1144, 10, 1144, 12, 1144, 20290, + 9, 1144, 1, 1144, 1, 1144, 3, 1144, 20294, 8, 1144, 1, 1145, 1, 1145, 1, + 1146, 1, 1146, 1, 1146, 3, 1146, 20301, 8, 1146, 1, 1147, 1, 1147, 1, 1148, + 1, 1148, 1, 1149, 1, 1149, 1, 1150, 1, 1150, 1, 1150, 3, 1150, 20312, 8, + 1150, 1, 1151, 1, 1151, 1, 1151, 5, 1151, 20317, 8, 1151, 10, 1151, 12, + 1151, 20320, 9, 1151, 1, 1152, 1, 1152, 1, 1153, 1, 1153, 3, 1153, 20326, + 8, 1153, 1, 1154, 1, 1154, 3, 1154, 20330, 8, 1154, 1, 1155, 1, 1155, 1, + 1155, 5, 1155, 20335, 8, 1155, 10, 1155, 12, 1155, 20338, 9, 1155, 1, 1155, + 1, 1155, 3, 1155, 20342, 8, 1155, 1, 1156, 1, 1156, 1, 1157, 1, 1157, 1, + 1157, 5, 1157, 20349, 8, 1157, 10, 1157, 12, 1157, 20352, 9, 1157, 1, 1158, + 1, 1158, 1, 1158, 5, 1158, 20357, 8, 1158, 10, 1158, 12, 1158, 20360, 9, + 1158, 1, 1159, 1, 1159, 1, 1159, 5, 1159, 20365, 8, 1159, 10, 1159, 12, + 1159, 20368, 9, 1159, 1, 1160, 1, 1160, 1, 1160, 3, 1160, 20373, 8, 1160, + 1, 1161, 1, 1161, 1, 1161, 3, 1161, 20378, 8, 1161, 1, 1162, 1, 1162, 1, + 1162, 3, 1162, 20383, 8, 1162, 1, 1163, 1, 1163, 3, 1163, 20387, 8, 1163, + 1, 1163, 1, 1163, 1, 1163, 3, 1163, 20392, 8, 1163, 1, 1163, 3, 1163, 20395, + 8, 1163, 1, 1164, 1, 1164, 1, 1164, 3, 1164, 20400, 8, 1164, 1, 1165, 1, + 1165, 3, 1165, 20404, 8, 1165, 1, 1166, 1, 1166, 3, 1166, 20408, 8, 1166, + 1, 1167, 1, 1167, 1, 1167, 5, 1167, 20413, 8, 1167, 10, 1167, 12, 1167, + 20416, 9, 1167, 1, 1167, 1, 1167, 3, 1167, 20420, 8, 1167, 1, 1168, 1, + 1168, 1, 1169, 1, 1169, 1, 1170, 1, 1170, 1, 1170, 5, 1170, 20429, 8, 1170, + 10, 1170, 12, 1170, 20432, 9, 1170, 1, 1171, 1, 1171, 1, 1171, 3, 1171, + 20437, 8, 1171, 1, 1171, 1, 1171, 1, 1171, 3, 1171, 20442, 8, 1171, 1, + 1171, 1, 1171, 3, 1171, 20446, 8, 1171, 3, 1171, 20448, 8, 1171, 1, 1172, + 1, 1172, 1, 1172, 1, 1172, 1, 1172, 3, 1172, 20455, 8, 1172, 1, 1172, 1, + 1172, 3, 1172, 20459, 8, 1172, 1, 1172, 1, 1172, 1, 1172, 1, 1172, 5, 1172, + 20465, 8, 1172, 10, 1172, 12, 1172, 20468, 9, 1172, 3, 1172, 20470, 8, + 1172, 1, 1172, 1, 1172, 1, 1172, 3, 1172, 20475, 8, 1172, 1, 1173, 1, 1173, + 1, 1173, 5, 1173, 20480, 8, 1173, 10, 1173, 12, 1173, 20483, 9, 1173, 1, + 1174, 1, 1174, 1, 1175, 1, 1175, 1, 1176, 1, 1176, 1, 1177, 1, 1177, 1, + 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 5, 1178, 20498, 8, 1178, 10, + 1178, 12, 1178, 20501, 9, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, + 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, + 1178, 1, 1178, 3, 1178, 20517, 8, 1178, 1, 1179, 1, 1179, 1, 1179, 5, 1179, + 20522, 8, 1179, 10, 1179, 12, 1179, 20525, 9, 1179, 1, 1180, 1, 1180, 1, + 1180, 1, 1180, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, + 1181, 20537, 8, 1181, 1, 1181, 1, 1181, 3, 1181, 20541, 8, 1181, 1, 1182, + 1, 1182, 1, 1182, 1, 1182, 5, 1182, 20547, 8, 1182, 10, 1182, 12, 1182, + 20550, 9, 1182, 3, 1182, 20552, 8, 1182, 1, 1182, 1, 1182, 3, 1182, 20556, + 8, 1182, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20561, 8, 1183, 1, 1183, 1, + 1183, 1, 1183, 3, 1183, 20566, 8, 1183, 5, 1183, 20568, 8, 1183, 10, 1183, + 12, 1183, 20571, 9, 1183, 3, 1183, 20573, 8, 1183, 1, 1183, 1, 1183, 3, + 1183, 20577, 8, 1183, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, + 20584, 8, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20589, 8, 1184, 3, + 1184, 20591, 8, 1184, 3, 1184, 20593, 8, 1184, 1, 1184, 1, 1184, 1, 1184, + 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 3, 1184, 20603, 8, 1184, 1, + 1184, 1, 1184, 1, 1184, 3, 1184, 20608, 8, 1184, 5, 1184, 20610, 8, 1184, + 10, 1184, 12, 1184, 20613, 9, 1184, 3, 1184, 20615, 8, 1184, 1, 1184, 1, + 1184, 3, 1184, 20619, 8, 1184, 1, 1185, 1, 1185, 1, 1185, 1, 1186, 1, 1186, + 1, 1186, 1, 1186, 3, 1186, 20628, 8, 1186, 1, 1186, 1, 1186, 1, 1187, 1, + 1187, 3, 1187, 20634, 8, 1187, 1, 1187, 1, 1187, 3, 1187, 20638, 8, 1187, + 3, 1187, 20640, 8, 1187, 1, 1188, 1, 1188, 3, 1188, 20644, 8, 1188, 1, + 1188, 1, 1188, 3, 1188, 20648, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, + 1, 1188, 3, 1188, 20655, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, + 1188, 1, 1188, 3, 1188, 20663, 8, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, + 1, 1188, 1, 1188, 3, 1188, 20671, 8, 1188, 3, 1188, 20673, 8, 1188, 1, + 1189, 1, 1189, 1, 1189, 3, 1189, 20678, 8, 1189, 1, 1189, 1, 1189, 1, 1189, + 3, 1189, 20683, 8, 1189, 3, 1189, 20685, 8, 1189, 1, 1189, 3, 1189, 20688, + 8, 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, 1190, 3, 1190, + 20712, 8, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 3, 1190, 20719, + 8, 1190, 1, 1190, 1, 1190, 1, 1190, 3, 1190, 20724, 8, 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, 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, 3, 1190, 20757, 8, 1190, + 1, 1191, 1, 1191, 1, 1191, 3, 1191, 20762, 8, 1191, 1, 1191, 3, 1191, 20765, + 8, 1191, 1, 1191, 1, 1191, 1, 1191, 3, 1191, 20770, 8, 1191, 3, 1191, 20772, + 8, 1191, 1, 1191, 1, 1191, 5, 1191, 20776, 8, 1191, 10, 1191, 12, 1191, + 20779, 9, 1191, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 3, + 1192, 20787, 8, 1192, 1, 1192, 1, 1192, 1, 1192, 4, 1192, 20792, 8, 1192, + 11, 1192, 12, 1192, 20793, 5, 1192, 20796, 8, 1192, 10, 1192, 12, 1192, + 20799, 9, 1192, 1, 1193, 1, 1193, 3, 1193, 20803, 8, 1193, 1, 1193, 1, + 1193, 1, 1193, 3, 1193, 20808, 8, 1193, 1, 1193, 5, 1193, 20811, 8, 1193, + 10, 1193, 12, 1193, 20814, 9, 1193, 1, 1194, 1, 1194, 3, 1194, 20818, 8, + 1194, 1, 1194, 1, 1194, 1, 1194, 5, 1194, 20823, 8, 1194, 10, 1194, 12, + 1194, 20826, 9, 1194, 1, 1195, 1, 1195, 3, 1195, 20830, 8, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 3, 1195, + 20864, 8, 1195, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20871, + 8, 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, 3, 1196, 20886, 8, + 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, 3, 1196, 20902, + 8, 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, 3, 1196, 20921, 8, 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, 3, 1196, 20938, 8, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20945, 8, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20953, 8, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 3, 1196, 20966, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 3, 1196, 20975, 8, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20984, 8, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 20993, 8, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 3, 1196, 21003, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, + 1196, 3, 1196, 21011, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21021, 8, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21031, 8, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 3, 1196, 21043, 8, 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, 3, 1196, 21059, 8, 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, 3, 1196, 21077, 8, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 3, 1196, 21090, 8, 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, 3, 1196, 21105, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21116, 8, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 3, 1196, 21126, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, + 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21137, 8, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21147, 8, + 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, 3, + 1196, 21164, 8, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 3, 1196, 21170, + 8, 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, 1196, 3, 1196, 21192, 8, 1196, 1, + 1197, 1, 1197, 1, 1197, 3, 1197, 21197, 8, 1197, 1, 1197, 1, 1197, 1, 1197, + 1, 1197, 3, 1197, 21203, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, + 1197, 21209, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21215, + 8, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21220, 8, 1197, 3, 1197, 21222, + 8, 1197, 1, 1197, 3, 1197, 21225, 8, 1197, 1, 1197, 1, 1197, 1, 1197, 1, + 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 3, 1197, 21236, 8, 1197, + 1, 1197, 3, 1197, 21239, 8, 1197, 3, 1197, 21241, 8, 1197, 3, 1197, 21243, + 8, 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, 3, 1197, 21257, 8, 1197, 1, + 1198, 1, 1198, 3, 1198, 21261, 8, 1198, 1, 1198, 3, 1198, 21264, 8, 1198, + 1, 1199, 1, 1199, 1, 1199, 1, 1200, 1, 1200, 1, 1201, 1, 1201, 3, 1201, + 21273, 8, 1201, 1, 1201, 1, 1201, 1, 1202, 1, 1202, 3, 1202, 21279, 8, + 1202, 1, 1203, 1, 1203, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, + 1205, 3, 1205, 21409, 8, 1205, 1, 1206, 1, 1206, 1, 1207, 1, 1207, 1, 1208, + 1, 1208, 1, 1208, 1, 3834, 7, 1250, 2082, 2090, 2092, 2102, 2220, 2384, + 1209, 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, 0, 305, + 2, 0, 1219, 1219, 2293, 2293, 2, 0, 684, 684, 901, 901, 2, 0, 2306, 2306, + 2308, 2308, 2, 0, 1171, 1171, 1560, 1560, 2, 0, 21, 21, 980, 980, 5, 0, + 465, 465, 675, 675, 963, 963, 1340, 1340, 2196, 2196, 2, 0, 230, 230, 596, + 596, 2, 0, 616, 616, 1104, 1104, 2, 0, 812, 812, 901, 901, 2, 0, 21, 21, + 469, 469, 3, 0, 649, 649, 1310, 1310, 1325, 1325, 2, 0, 1258, 1258, 2313, + 2313, 2, 0, 649, 649, 1325, 1325, 4, 0, 91, 91, 675, 675, 897, 897, 2406, + 2406, 3, 0, 220, 220, 350, 350, 2291, 2291, 2, 0, 1489, 1489, 1548, 1548, + 2, 0, 1178, 1178, 1576, 1576, 2, 0, 429, 429, 499, 499, 2, 0, 206, 206, + 1713, 1713, 2, 0, 2444, 2444, 2450, 2450, 2, 0, 482, 482, 1132, 1132, 2, + 0, 948, 948, 1133, 1133, 2, 0, 69, 69, 785, 785, 3, 0, 660, 660, 862, 862, + 1495, 1495, 2, 0, 389, 389, 616, 616, 2, 0, 1606, 1606, 2083, 2083, 5, + 0, 632, 632, 1329, 1329, 1461, 1461, 2157, 2157, 2166, 2166, 2, 0, 220, + 220, 1303, 1303, 2, 0, 1455, 1455, 1473, 1473, 3, 0, 38, 38, 244, 244, + 873, 873, 2, 0, 932, 932, 960, 960, 3, 0, 147, 147, 1329, 1329, 1715, 1715, + 2, 0, 35, 35, 1394, 1394, 2, 0, 420, 420, 1331, 1331, 4, 0, 281, 281, 319, + 319, 887, 887, 1456, 1456, 2, 0, 146, 146, 1699, 1699, 2, 0, 33, 33, 112, + 112, 3, 0, 403, 403, 756, 756, 2207, 2207, 3, 0, 1021, 1021, 1250, 1250, + 1337, 1337, 2, 0, 616, 616, 2253, 2253, 2, 0, 147, 147, 1715, 1715, 3, + 0, 346, 346, 1279, 1279, 1719, 1719, 2, 0, 910, 910, 1303, 1303, 2, 0, + 936, 936, 1745, 1745, 3, 0, 595, 595, 761, 761, 1324, 1324, 3, 0, 242, + 242, 1201, 1201, 1596, 1596, 3, 0, 376, 376, 449, 449, 1484, 1484, 2, 0, + 14, 14, 38, 38, 3, 0, 351, 351, 948, 948, 1133, 1133, 2, 0, 1100, 1100, + 2429, 2429, 1, 0, 2441, 2442, 2, 0, 1170, 1170, 1554, 1554, 2, 0, 1730, + 1730, 2112, 2112, 10, 0, 366, 366, 658, 658, 680, 680, 959, 959, 987, 987, + 1482, 1482, 1637, 1637, 1730, 1730, 2296, 2296, 2357, 2357, 2, 0, 2406, + 2406, 2409, 2409, 2, 0, 70, 70, 414, 414, 2, 0, 598, 598, 825, 825, 3, + 0, 759, 759, 1667, 1667, 1743, 1743, 14, 0, 42, 42, 85, 85, 241, 241, 403, + 403, 542, 542, 605, 605, 647, 647, 717, 717, 756, 756, 881, 881, 1505, + 1505, 1559, 1559, 1647, 1647, 2207, 2207, 3, 0, 42, 42, 321, 321, 469, + 469, 3, 0, 542, 542, 1505, 1505, 2313, 2313, 4, 0, 359, 359, 425, 425, + 1252, 1252, 2355, 2355, 3, 0, 87, 87, 634, 634, 681, 681, 2, 0, 1173, 1173, + 1565, 1565, 5, 0, 480, 480, 635, 635, 901, 901, 1328, 1328, 2077, 2077, + 3, 0, 365, 365, 985, 985, 2358, 2358, 6, 0, 410, 410, 671, 671, 786, 786, + 847, 847, 937, 940, 1338, 1339, 2, 0, 137, 137, 2183, 2183, 2, 0, 2203, + 2203, 2215, 2215, 2, 0, 395, 395, 698, 698, 2, 0, 782, 782, 2290, 2290, + 2, 0, 983, 983, 1127, 1127, 2, 0, 21, 21, 1558, 1558, 2, 0, 561, 561, 643, + 643, 2, 0, 389, 389, 2092, 2092, 2, 0, 881, 881, 2187, 2187, 2, 0, 21, + 21, 2207, 2207, 2, 0, 1378, 1378, 1607, 1607, 2, 0, 1243, 1243, 1256, 1256, + 2, 0, 1949, 1949, 2237, 2237, 2, 0, 160, 160, 534, 534, 2, 0, 4, 4, 1667, + 1667, 2, 0, 38, 38, 336, 336, 2, 0, 1627, 1627, 2108, 2108, 2, 0, 717, + 717, 2083, 2083, 2, 0, 26, 26, 401, 401, 2, 0, 1570, 1570, 1713, 1713, + 3, 0, 632, 632, 1329, 1329, 1461, 1461, 3, 0, 206, 206, 1570, 1570, 1713, + 1713, 2, 0, 249, 249, 1568, 1568, 3, 0, 119, 119, 142, 142, 215, 215, 2, + 0, 179, 179, 1578, 1578, 2, 0, 341, 341, 398, 398, 2, 0, 291, 291, 293, + 293, 2, 0, 686, 686, 689, 689, 1, 0, 286, 287, 2, 0, 1215, 1215, 2253, + 2253, 2, 0, 871, 871, 2081, 2081, 2, 0, 352, 352, 2089, 2089, 3, 0, 698, + 698, 1178, 1178, 2092, 2092, 2, 0, 1244, 1244, 1259, 1259, 2, 0, 122, 122, + 1705, 1705, 3, 0, 593, 593, 884, 884, 1119, 1119, 2, 0, 91, 91, 909, 909, + 2, 0, 655, 655, 1108, 1108, 2, 0, 675, 675, 897, 897, 2, 0, 389, 389, 2441, + 2441, 2, 0, 242, 242, 406, 406, 2, 0, 511, 511, 2161, 2161, 2, 0, 166, + 166, 1066, 1066, 2, 0, 540, 540, 705, 705, 2, 0, 79, 79, 1794, 1794, 3, + 0, 249, 249, 578, 578, 616, 616, 3, 0, 250, 250, 578, 578, 616, 616, 3, + 0, 242, 242, 406, 406, 1743, 1743, 2, 0, 873, 873, 913, 913, 2, 0, 1180, + 1180, 1599, 1599, 6, 0, 256, 256, 281, 281, 318, 319, 690, 690, 886, 887, + 1668, 1668, 3, 0, 389, 389, 2185, 2185, 2441, 2441, 4, 0, 571, 571, 702, + 702, 1353, 1355, 1357, 1358, 2, 0, 642, 642, 1455, 1455, 2, 0, 403, 403, + 1447, 1447, 2, 0, 107, 107, 1640, 1640, 2, 0, 469, 469, 1447, 1447, 2, + 0, 770, 770, 859, 859, 2, 0, 1137, 1137, 2360, 2360, 2, 0, 560, 560, 778, + 778, 6, 0, 480, 480, 635, 635, 812, 812, 901, 901, 1328, 1328, 2077, 2077, + 2, 0, 64, 64, 1484, 1484, 2, 0, 29, 29, 106, 106, 2, 0, 176, 176, 1484, + 1484, 5, 0, 326, 326, 675, 675, 897, 897, 935, 935, 1133, 1133, 2, 0, 2185, + 2185, 2441, 2441, 3, 0, 389, 389, 814, 814, 1519, 1519, 3, 0, 389, 389, + 814, 814, 1133, 1133, 3, 0, 403, 403, 429, 429, 499, 499, 2, 0, 237, 237, + 1606, 1606, 2, 0, 4, 4, 978, 978, 2, 0, 649, 649, 1645, 1645, 4, 0, 365, + 366, 985, 985, 987, 987, 2357, 2358, 1, 0, 2380, 2383, 2, 0, 262, 262, + 869, 869, 1, 0, 2451, 2452, 2, 0, 381, 381, 2364, 2364, 2, 0, 2260, 2261, + 2263, 2264, 4, 0, 834, 834, 899, 900, 1203, 1203, 1609, 1609, 2, 0, 367, + 367, 2359, 2359, 2, 0, 390, 390, 1227, 1227, 2, 0, 49, 49, 1307, 1307, + 2, 0, 121, 121, 863, 863, 2, 0, 200, 200, 1067, 1067, 2, 0, 164, 164, 194, + 194, 2, 0, 424, 424, 1088, 1088, 1, 0, 451, 452, 3, 0, 1060, 1060, 1089, + 1089, 1118, 1118, 3, 0, 105, 105, 438, 438, 882, 882, 2, 0, 361, 361, 2108, + 2108, 2, 0, 2463, 2463, 2472, 2472, 2, 0, 430, 430, 499, 499, 4, 0, 106, + 106, 675, 675, 897, 897, 935, 935, 2, 0, 430, 430, 500, 500, 2, 0, 2469, + 2469, 2472, 2472, 2, 0, 953, 953, 1123, 1123, 2, 0, 1447, 1447, 1475, 1475, + 2, 0, 469, 469, 814, 814, 2, 0, 49, 49, 814, 814, 2, 0, 40, 40, 435, 435, + 3, 0, 249, 249, 482, 482, 1132, 1132, 2, 0, 469, 469, 1587, 1587, 2, 0, + 216, 216, 1734, 1734, 2, 0, 466, 466, 2211, 2211, 2, 0, 113, 113, 508, + 508, 2, 0, 885, 885, 1392, 1392, 3, 0, 98, 98, 1385, 1385, 1469, 1469, + 2, 0, 242, 242, 1441, 1441, 2, 0, 1, 1, 1761, 1761, 2, 0, 1392, 1392, 1707, + 1707, 3, 0, 38, 38, 1133, 1133, 1734, 1734, 3, 0, 675, 675, 963, 963, 2196, + 2196, 4, 0, 429, 429, 499, 499, 1558, 1558, 1790, 1790, 2, 0, 575, 575, + 2158, 2158, 2, 0, 1558, 1558, 1671, 1671, 2, 0, 1797, 1797, 1949, 1949, + 2, 0, 922, 922, 925, 925, 1, 0, 926, 928, 2, 0, 38, 38, 835, 835, 2, 0, + 505, 505, 1550, 1550, 3, 0, 387, 387, 505, 505, 1550, 1550, 2, 0, 1505, + 1505, 2313, 2313, 2, 0, 1348, 1348, 1775, 1775, 2, 0, 1348, 1348, 1350, + 1350, 1, 0, 1774, 1775, 2, 0, 780, 780, 2207, 2207, 2, 0, 1188, 1188, 1709, + 1709, 2, 0, 877, 877, 2258, 2258, 2, 0, 626, 626, 1373, 1373, 2, 0, 388, + 388, 813, 813, 3, 0, 675, 675, 897, 897, 935, 935, 2, 0, 336, 336, 1228, + 1228, 2, 0, 642, 642, 873, 873, 2, 0, 469, 469, 816, 816, 1, 0, 2433, 2434, + 4, 0, 738, 738, 750, 750, 1080, 1080, 1318, 1318, 2, 0, 389, 389, 2457, + 2457, 1, 1, 2470, 2470, 1, 0, 1585, 1586, 2, 0, 108, 108, 698, 698, 2, + 0, 403, 403, 2429, 2429, 2, 0, 152, 152, 410, 410, 3, 0, 38, 38, 445, 445, + 2183, 2183, 2, 0, 327, 327, 1004, 1004, 2, 0, 327, 327, 1313, 1313, 3, + 0, 630, 630, 839, 839, 1592, 1592, 3, 0, 1627, 1627, 1707, 1707, 2108, + 2108, 2, 0, 539, 539, 703, 703, 2, 0, 332, 332, 1598, 1598, 2, 0, 692, + 692, 814, 814, 2, 0, 38, 38, 2206, 2206, 2, 0, 95, 95, 1655, 1655, 1, 0, + 1606, 1607, 2, 0, 598, 598, 1025, 1025, 2, 0, 38, 38, 598, 598, 2, 0, 2083, + 2083, 2100, 2100, 2, 0, 829, 829, 1766, 1766, 2, 0, 936, 936, 1772, 1772, + 3, 0, 534, 534, 775, 775, 2181, 2181, 2, 0, 38, 38, 445, 445, 2, 0, 853, + 855, 857, 857, 1, 0, 2467, 2468, 2, 0, 520, 520, 2159, 2159, 3, 0, 981, + 981, 2450, 2450, 2454, 2454, 2, 0, 386, 386, 707, 707, 4, 0, 313, 313, + 598, 598, 825, 825, 858, 858, 3, 0, 545, 545, 1025, 1025, 1454, 1454, 1, + 0, 523, 524, 4, 0, 38, 38, 55, 55, 545, 545, 1708, 1708, 3, 0, 149, 149, + 838, 838, 2146, 2146, 2, 0, 3, 3, 1228, 1228, 2, 0, 163, 163, 196, 196, + 2, 0, 68, 68, 1238, 1238, 2, 0, 785, 785, 2258, 2258, 2, 0, 520, 520, 1228, + 1228, 2, 0, 497, 497, 1228, 1228, 2, 0, 520, 520, 692, 692, 3, 0, 520, + 520, 692, 692, 1562, 1562, 4, 0, 520, 520, 692, 692, 1228, 1228, 1558, + 1558, 3, 0, 321, 321, 520, 520, 692, 692, 3, 0, 520, 520, 692, 692, 1228, + 1228, 2, 0, 265, 265, 2176, 2176, 2, 0, 181, 181, 2321, 2321, 2, 0, 445, + 445, 2183, 2183, 2, 0, 1375, 1377, 1380, 1380, 2, 0, 175, 175, 248, 248, + 2, 0, 601, 601, 826, 826, 2, 0, 2402, 2402, 2405, 2405, 3, 0, 2125, 2126, + 2134, 2134, 2137, 2138, 2, 0, 2129, 2129, 2142, 2142, 2, 0, 197, 197, 1007, + 1007, 2, 0, 2323, 2323, 2331, 2331, 2, 0, 515, 515, 1096, 1096, 2, 0, 529, + 529, 997, 997, 2, 0, 294, 294, 455, 455, 2, 0, 670, 670, 1683, 1683, 10, + 0, 1226, 1226, 2265, 2265, 2398, 2400, 2403, 2404, 2406, 2407, 2409, 2410, + 2412, 2413, 2415, 2415, 2419, 2422, 2435, 2435, 2, 0, 2391, 2392, 2394, + 2397, 1, 0, 2365, 2370, 2, 0, 1495, 1495, 1607, 1607, 2, 0, 613, 613, 1436, + 1436, 2, 0, 1182, 1182, 1624, 1624, 2, 0, 518, 518, 522, 522, 1, 0, 2454, + 2455, 1, 0, 1722, 1723, 2, 0, 1309, 1309, 1720, 1720, 2, 0, 242, 242, 1596, + 1596, 3, 0, 242, 242, 1133, 1133, 1596, 1596, 2, 0, 692, 692, 1571, 1571, + 1, 0, 1381, 1382, 2, 0, 365, 365, 2358, 2358, 2, 0, 985, 985, 1636, 1636, + 2, 0, 42, 42, 469, 469, 2, 0, 321, 321, 469, 469, 2, 0, 42, 42, 321, 321, + 3, 0, 42, 42, 469, 469, 542, 542, 2, 0, 55, 55, 560, 560, 2, 0, 206, 206, + 1464, 1464, 4, 0, 42, 42, 241, 241, 469, 469, 1647, 1647, 4, 0, 42, 42, + 469, 469, 1647, 1647, 2207, 2207, 3, 0, 403, 403, 469, 469, 756, 756, 6, + 0, 42, 42, 403, 403, 469, 469, 756, 756, 1647, 1647, 2207, 2207, 2, 0, + 469, 469, 2207, 2207, 3, 0, 42, 42, 469, 469, 647, 647, 3, 0, 42, 42, 469, + 469, 1647, 1647, 3, 0, 42, 42, 321, 321, 1576, 1576, 3, 0, 42, 42, 469, + 469, 2241, 2241, 10, 0, 42, 42, 102, 102, 241, 241, 403, 403, 469, 469, + 756, 756, 881, 881, 1505, 1505, 1647, 1647, 2207, 2207, 5, 0, 42, 42, 321, + 321, 469, 469, 905, 905, 2185, 2185, 4, 0, 42, 42, 469, 469, 542, 542, + 2177, 2177, 3, 0, 469, 469, 946, 946, 2177, 2177, 2, 0, 46, 46, 85, 85, + 2, 0, 421, 421, 2147, 2147, 6, 0, 365, 365, 679, 679, 958, 958, 985, 985, + 1636, 1636, 2358, 2358, 2, 0, 2436, 2436, 2443, 2443, 1, 0, 2431, 2432, + 256, 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, 544, 544, 556, 556, + 562, 562, 568, 568, 573, 574, 576, 577, 579, 579, 581, 582, 586, 586, 590, + 591, 603, 603, 609, 609, 621, 621, 634, 634, 636, 636, 641, 641, 658, 658, + 671, 672, 680, 681, 684, 684, 697, 697, 701, 702, 718, 718, 737, 737, 746, + 746, 748, 748, 751, 751, 770, 770, 781, 781, 786, 786, 795, 809, 811, 811, + 820, 820, 822, 822, 829, 829, 836, 837, 847, 847, 850, 850, 859, 859, 878, + 878, 880, 880, 889, 889, 895, 895, 908, 908, 910, 910, 915, 918, 929, 929, + 937, 941, 948, 948, 959, 959, 972, 972, 976, 976, 978, 978, 982, 982, 987, + 987, 993, 993, 1012, 1012, 1055, 1056, 1061, 1061, 1063, 1063, 1071, 1071, + 1073, 1073, 1080, 1080, 1085, 1086, 1092, 1092, 1106, 1106, 1112, 1114, + 1132, 1132, 1139, 1139, 1150, 1152, 1155, 1155, 1157, 1159, 1164, 1164, + 1169, 1169, 1172, 1172, 1179, 1179, 1189, 1189, 1207, 1207, 1214, 1214, + 1216, 1218, 1225, 1225, 1239, 1239, 1245, 1245, 1252, 1252, 1254, 1255, + 1276, 1278, 1290, 1295, 1300, 1300, 1338, 1339, 1342, 1342, 1344, 1345, + 1359, 1359, 1361, 1362, 1364, 1364, 1366, 1366, 1386, 1386, 1389, 1390, + 1409, 1409, 1413, 1417, 1425, 1425, 1427, 1428, 1431, 1432, 1440, 1440, + 1448, 1448, 1450, 1450, 1452, 1453, 1457, 1457, 1467, 1467, 1470, 1472, + 1478, 1478, 1482, 1482, 1491, 1491, 1508, 1508, 1521, 1521, 1553, 1553, + 1556, 1556, 1572, 1572, 1594, 1594, 1600, 1600, 1612, 1612, 1617, 1617, + 1629, 1629, 1632, 1632, 1637, 1638, 1661, 1661, 1663, 1663, 1665, 1665, + 1681, 1682, 1688, 1688, 1711, 1712, 1726, 1726, 1730, 1731, 1733, 1733, + 1743, 1744, 1765, 1765, 1778, 1779, 1787, 1787, 1797, 1797, 1801, 1801, + 1803, 1803, 1809, 1809, 1827, 1827, 1832, 1833, 1837, 1838, 1860, 1860, + 1872, 1872, 1875, 1879, 1904, 1904, 1932, 1932, 1943, 1943, 2074, 2076, + 2085, 2085, 2096, 2096, 2104, 2105, 2124, 2124, 2148, 2148, 2154, 2154, + 2162, 2162, 2170, 2170, 2176, 2176, 2188, 2188, 2195, 2195, 2201, 2201, + 2215, 2215, 2219, 2219, 2223, 2223, 2230, 2230, 2236, 2236, 2242, 2242, + 2244, 2245, 2247, 2252, 2254, 2254, 2256, 2256, 2272, 2275, 2287, 2287, + 2289, 2289, 2296, 2297, 2307, 2307, 2312, 2312, 2355, 2355, 2357, 2357, + 2362, 2362, 2371, 2383, 2385, 2385, 2387, 2387, 2389, 2390, 2408, 2408, + 2440, 2440, 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, + 542, 543, 546, 546, 548, 555, 557, 561, 563, 567, 569, 572, 575, 575, 578, + 578, 580, 580, 583, 585, 589, 589, 593, 601, 604, 606, 608, 608, 610, 614, + 616, 619, 622, 627, 629, 633, 637, 640, 642, 645, 648, 648, 650, 656, 659, + 662, 664, 670, 674, 679, 682, 683, 686, 692, 694, 696, 698, 700, 703, 716, + 719, 733, 735, 736, 739, 745, 747, 747, 749, 749, 753, 755, 757, 768, 771, + 774, 776, 777, 780, 780, 782, 783, 787, 788, 790, 794, 813, 819, 821, 821, + 824, 827, 830, 833, 835, 835, 838, 846, 848, 849, 851, 856, 858, 858, 861, + 862, 865, 868, 870, 877, 879, 879, 882, 888, 890, 892, 896, 898, 900, 900, + 902, 907, 909, 909, 911, 911, 913, 914, 919, 928, 930, 936, 942, 947, 949, + 955, 957, 958, 960, 963, 966, 971, 973, 975, 979, 981, 983, 986, 988, 989, + 991, 992, 994, 1004, 1006, 1011, 1013, 1021, 1023, 1054, 1057, 1059, 1062, + 1062, 1064, 1066, 1068, 1070, 1072, 1072, 1075, 1079, 1081, 1084, 1087, + 1087, 1090, 1091, 1093, 1099, 1101, 1105, 1107, 1111, 1115, 1116, 1119, + 1131, 1133, 1133, 1135, 1138, 1140, 1149, 1153, 1154, 1156, 1156, 1160, + 1163, 1165, 1168, 1170, 1171, 1173, 1178, 1180, 1180, 1182, 1186, 1188, + 1188, 1190, 1202, 1205, 1206, 1208, 1213, 1215, 1215, 1220, 1224, 1226, + 1227, 1229, 1229, 1231, 1238, 1240, 1244, 1247, 1251, 1253, 1253, 1256, + 1256, 1258, 1258, 1260, 1271, 1274, 1275, 1283, 1289, 1296, 1299, 1301, + 1302, 1304, 1306, 1308, 1308, 1310, 1315, 1317, 1317, 1319, 1323, 1325, + 1327, 1329, 1330, 1332, 1333, 1335, 1337, 1340, 1340, 1343, 1343, 1346, + 1358, 1360, 1360, 1363, 1363, 1365, 1365, 1367, 1368, 1370, 1374, 1378, + 1379, 1385, 1385, 1387, 1388, 1391, 1393, 1396, 1402, 1404, 1408, 1411, + 1412, 1418, 1418, 1421, 1424, 1426, 1426, 1429, 1430, 1434, 1439, 1441, + 1441, 1443, 1447, 1449, 1449, 1451, 1451, 1455, 1456, 1458, 1466, 1468, + 1469, 1474, 1477, 1479, 1481, 1483, 1490, 1493, 1497, 1499, 1502, 1504, + 1506, 1509, 1511, 1514, 1520, 1522, 1551, 1554, 1555, 1557, 1558, 1560, + 1569, 1571, 1571, 1573, 1576, 1578, 1579, 1581, 1588, 1590, 1593, 1595, + 1599, 1601, 1611, 1613, 1616, 1618, 1628, 1630, 1631, 1634, 1636, 1639, + 1646, 1649, 1653, 1655, 1655, 1659, 1659, 1662, 1662, 1664, 1664, 1666, + 1670, 1672, 1675, 1678, 1679, 1683, 1687, 1689, 1691, 1694, 1698, 1701, + 1705, 1707, 1710, 1713, 1718, 1721, 1722, 1724, 1725, 1727, 1729, 1732, + 1732, 1734, 1736, 1739, 1742, 1745, 1764, 1766, 1777, 1780, 1784, 1786, + 1786, 1788, 1795, 1797, 1800, 1802, 1802, 1804, 1808, 1810, 1826, 1828, + 1831, 1834, 1836, 1839, 1859, 1861, 1871, 1873, 1874, 1880, 1903, 1905, + 1931, 1933, 1942, 1944, 2073, 2078, 2084, 2086, 2093, 2095, 2095, 2098, + 2100, 2102, 2103, 2106, 2106, 2108, 2108, 2111, 2120, 2122, 2123, 2125, + 2140, 2142, 2147, 2150, 2153, 2155, 2156, 2158, 2161, 2163, 2169, 2172, + 2175, 2177, 2180, 2184, 2187, 2189, 2194, 2196, 2199, 2202, 2206, 2208, + 2214, 2216, 2218, 2220, 2222, 2224, 2229, 2231, 2235, 2237, 2241, 2243, + 2243, 2246, 2246, 2253, 2253, 2255, 2255, 2258, 2258, 2265, 2271, 2276, + 2285, 2288, 2288, 2290, 2294, 2298, 2300, 2303, 2306, 2309, 2309, 2311, + 2311, 2313, 2314, 2316, 2318, 2320, 2331, 2333, 2347, 2349, 2354, 2358, + 2358, 2360, 2360, 2363, 2363, 2365, 2370, 2388, 2388, 2391, 2399, 2402, + 2402, 2405, 2412, 2414, 2420, 2422, 2425, 24746, 0, 2424, 1, 0, 0, 0, 2, + 2593, 1, 0, 0, 0, 4, 2595, 1, 0, 0, 0, 6, 2652, 1, 0, 0, 0, 8, 2677, 1, + 0, 0, 0, 10, 2718, 1, 0, 0, 0, 12, 2724, 1, 0, 0, 0, 14, 2751, 1, 0, 0, + 0, 16, 2753, 1, 0, 0, 0, 18, 2772, 1, 0, 0, 0, 20, 2813, 1, 0, 0, 0, 22, + 2845, 1, 0, 0, 0, 24, 2850, 1, 0, 0, 0, 26, 2872, 1, 0, 0, 0, 28, 2874, + 1, 0, 0, 0, 30, 2904, 1, 0, 0, 0, 32, 2906, 1, 0, 0, 0, 34, 2916, 1, 0, + 0, 0, 36, 2918, 1, 0, 0, 0, 38, 2920, 1, 0, 0, 0, 40, 2963, 1, 0, 0, 0, + 42, 2965, 1, 0, 0, 0, 44, 3005, 1, 0, 0, 0, 46, 3018, 1, 0, 0, 0, 48, 3020, + 1, 0, 0, 0, 50, 3038, 1, 0, 0, 0, 52, 3049, 1, 0, 0, 0, 54, 3055, 1, 0, + 0, 0, 56, 3065, 1, 0, 0, 0, 58, 3099, 1, 0, 0, 0, 60, 3138, 1, 0, 0, 0, + 62, 3140, 1, 0, 0, 0, 64, 3172, 1, 0, 0, 0, 66, 3196, 1, 0, 0, 0, 68, 3246, + 1, 0, 0, 0, 70, 3248, 1, 0, 0, 0, 72, 3250, 1, 0, 0, 0, 74, 3256, 1, 0, + 0, 0, 76, 3258, 1, 0, 0, 0, 78, 3277, 1, 0, 0, 0, 80, 3285, 1, 0, 0, 0, + 82, 3292, 1, 0, 0, 0, 84, 3298, 1, 0, 0, 0, 86, 3300, 1, 0, 0, 0, 88, 3314, + 1, 0, 0, 0, 90, 3316, 1, 0, 0, 0, 92, 3329, 1, 0, 0, 0, 94, 3333, 1, 0, + 0, 0, 96, 3368, 1, 0, 0, 0, 98, 3382, 1, 0, 0, 0, 100, 3403, 1, 0, 0, 0, + 102, 3438, 1, 0, 0, 0, 104, 3440, 1, 0, 0, 0, 106, 3498, 1, 0, 0, 0, 108, + 3506, 1, 0, 0, 0, 110, 3510, 1, 0, 0, 0, 112, 3524, 1, 0, 0, 0, 114, 3534, + 1, 0, 0, 0, 116, 3547, 1, 0, 0, 0, 118, 3551, 1, 0, 0, 0, 120, 3555, 1, + 0, 0, 0, 122, 3563, 1, 0, 0, 0, 124, 3566, 1, 0, 0, 0, 126, 3578, 1, 0, + 0, 0, 128, 3583, 1, 0, 0, 0, 130, 3604, 1, 0, 0, 0, 132, 3606, 1, 0, 0, + 0, 134, 3620, 1, 0, 0, 0, 136, 3638, 1, 0, 0, 0, 138, 3656, 1, 0, 0, 0, + 140, 3679, 1, 0, 0, 0, 142, 3701, 1, 0, 0, 0, 144, 3736, 1, 0, 0, 0, 146, + 3738, 1, 0, 0, 0, 148, 3746, 1, 0, 0, 0, 150, 3748, 1, 0, 0, 0, 152, 3753, + 1, 0, 0, 0, 154, 3765, 1, 0, 0, 0, 156, 3785, 1, 0, 0, 0, 158, 3814, 1, + 0, 0, 0, 160, 3861, 1, 0, 0, 0, 162, 3863, 1, 0, 0, 0, 164, 3892, 1, 0, + 0, 0, 166, 3936, 1, 0, 0, 0, 168, 3938, 1, 0, 0, 0, 170, 3960, 1, 0, 0, + 0, 172, 3974, 1, 0, 0, 0, 174, 3978, 1, 0, 0, 0, 176, 3995, 1, 0, 0, 0, + 178, 4041, 1, 0, 0, 0, 180, 4078, 1, 0, 0, 0, 182, 4119, 1, 0, 0, 0, 184, + 4128, 1, 0, 0, 0, 186, 4132, 1, 0, 0, 0, 188, 4146, 1, 0, 0, 0, 190, 4156, + 1, 0, 0, 0, 192, 4161, 1, 0, 0, 0, 194, 4165, 1, 0, 0, 0, 196, 4184, 1, + 0, 0, 0, 198, 4186, 1, 0, 0, 0, 200, 4188, 1, 0, 0, 0, 202, 4203, 1, 0, + 0, 0, 204, 4207, 1, 0, 0, 0, 206, 4230, 1, 0, 0, 0, 208, 4253, 1, 0, 0, + 0, 210, 4262, 1, 0, 0, 0, 212, 4271, 1, 0, 0, 0, 214, 4280, 1, 0, 0, 0, + 216, 4284, 1, 0, 0, 0, 218, 4289, 1, 0, 0, 0, 220, 4312, 1, 0, 0, 0, 222, + 4314, 1, 0, 0, 0, 224, 4364, 1, 0, 0, 0, 226, 4392, 1, 0, 0, 0, 228, 4394, + 1, 0, 0, 0, 230, 4408, 1, 0, 0, 0, 232, 4413, 1, 0, 0, 0, 234, 4421, 1, + 0, 0, 0, 236, 4429, 1, 0, 0, 0, 238, 4432, 1, 0, 0, 0, 240, 4441, 1, 0, + 0, 0, 242, 4455, 1, 0, 0, 0, 244, 4472, 1, 0, 0, 0, 246, 4489, 1, 0, 0, + 0, 248, 4497, 1, 0, 0, 0, 250, 4502, 1, 0, 0, 0, 252, 4526, 1, 0, 0, 0, + 254, 4529, 1, 0, 0, 0, 256, 4535, 1, 0, 0, 0, 258, 4548, 1, 0, 0, 0, 260, + 4560, 1, 0, 0, 0, 262, 4588, 1, 0, 0, 0, 264, 4594, 1, 0, 0, 0, 266, 4597, + 1, 0, 0, 0, 268, 4604, 1, 0, 0, 0, 270, 4612, 1, 0, 0, 0, 272, 4625, 1, + 0, 0, 0, 274, 4627, 1, 0, 0, 0, 276, 4632, 1, 0, 0, 0, 278, 4639, 1, 0, + 0, 0, 280, 4667, 1, 0, 0, 0, 282, 4698, 1, 0, 0, 0, 284, 4746, 1, 0, 0, + 0, 286, 4756, 1, 0, 0, 0, 288, 4758, 1, 0, 0, 0, 290, 4763, 1, 0, 0, 0, + 292, 4777, 1, 0, 0, 0, 294, 4779, 1, 0, 0, 0, 296, 4790, 1, 0, 0, 0, 298, + 4792, 1, 0, 0, 0, 300, 4830, 1, 0, 0, 0, 302, 4858, 1, 0, 0, 0, 304, 4877, + 1, 0, 0, 0, 306, 4910, 1, 0, 0, 0, 308, 4948, 1, 0, 0, 0, 310, 4952, 1, + 0, 0, 0, 312, 4967, 1, 0, 0, 0, 314, 4969, 1, 0, 0, 0, 316, 4986, 1, 0, + 0, 0, 318, 4990, 1, 0, 0, 0, 320, 4998, 1, 0, 0, 0, 322, 5061, 1, 0, 0, + 0, 324, 5063, 1, 0, 0, 0, 326, 5113, 1, 0, 0, 0, 328, 5115, 1, 0, 0, 0, + 330, 5119, 1, 0, 0, 0, 332, 5192, 1, 0, 0, 0, 334, 5194, 1, 0, 0, 0, 336, + 5197, 1, 0, 0, 0, 338, 5200, 1, 0, 0, 0, 340, 5212, 1, 0, 0, 0, 342, 5214, + 1, 0, 0, 0, 344, 5230, 1, 0, 0, 0, 346, 5243, 1, 0, 0, 0, 348, 5309, 1, + 0, 0, 0, 350, 5321, 1, 0, 0, 0, 352, 5333, 1, 0, 0, 0, 354, 5345, 1, 0, + 0, 0, 356, 5350, 1, 0, 0, 0, 358, 5355, 1, 0, 0, 0, 360, 5359, 1, 0, 0, + 0, 362, 5364, 1, 0, 0, 0, 364, 5368, 1, 0, 0, 0, 366, 5373, 1, 0, 0, 0, + 368, 5382, 1, 0, 0, 0, 370, 5405, 1, 0, 0, 0, 372, 5418, 1, 0, 0, 0, 374, + 5443, 1, 0, 0, 0, 376, 5445, 1, 0, 0, 0, 378, 5464, 1, 0, 0, 0, 380, 5470, + 1, 0, 0, 0, 382, 5512, 1, 0, 0, 0, 384, 5530, 1, 0, 0, 0, 386, 5542, 1, + 0, 0, 0, 388, 5548, 1, 0, 0, 0, 390, 5559, 1, 0, 0, 0, 392, 5570, 1, 0, + 0, 0, 394, 5585, 1, 0, 0, 0, 396, 5600, 1, 0, 0, 0, 398, 5671, 1, 0, 0, + 0, 400, 5686, 1, 0, 0, 0, 402, 5689, 1, 0, 0, 0, 404, 5697, 1, 0, 0, 0, + 406, 5717, 1, 0, 0, 0, 408, 5745, 1, 0, 0, 0, 410, 5757, 1, 0, 0, 0, 412, + 5761, 1, 0, 0, 0, 414, 5770, 1, 0, 0, 0, 416, 5802, 1, 0, 0, 0, 418, 5804, + 1, 0, 0, 0, 420, 5813, 1, 0, 0, 0, 422, 5815, 1, 0, 0, 0, 424, 5845, 1, + 0, 0, 0, 426, 5847, 1, 0, 0, 0, 428, 5856, 1, 0, 0, 0, 430, 5914, 1, 0, + 0, 0, 432, 5916, 1, 0, 0, 0, 434, 5937, 1, 0, 0, 0, 436, 5943, 1, 0, 0, + 0, 438, 5945, 1, 0, 0, 0, 440, 5997, 1, 0, 0, 0, 442, 6009, 1, 0, 0, 0, + 444, 6018, 1, 0, 0, 0, 446, 6039, 1, 0, 0, 0, 448, 6043, 1, 0, 0, 0, 450, + 6047, 1, 0, 0, 0, 452, 6081, 1, 0, 0, 0, 454, 6089, 1, 0, 0, 0, 456, 6101, + 1, 0, 0, 0, 458, 6107, 1, 0, 0, 0, 460, 6114, 1, 0, 0, 0, 462, 6116, 1, + 0, 0, 0, 464, 6140, 1, 0, 0, 0, 466, 6148, 1, 0, 0, 0, 468, 6152, 1, 0, + 0, 0, 470, 6175, 1, 0, 0, 0, 472, 6221, 1, 0, 0, 0, 474, 6236, 1, 0, 0, + 0, 476, 6238, 1, 0, 0, 0, 478, 6252, 1, 0, 0, 0, 480, 6284, 1, 0, 0, 0, + 482, 6293, 1, 0, 0, 0, 484, 6309, 1, 0, 0, 0, 486, 6351, 1, 0, 0, 0, 488, + 6382, 1, 0, 0, 0, 490, 6384, 1, 0, 0, 0, 492, 6391, 1, 0, 0, 0, 494, 6402, + 1, 0, 0, 0, 496, 6413, 1, 0, 0, 0, 498, 6451, 1, 0, 0, 0, 500, 6453, 1, + 0, 0, 0, 502, 6480, 1, 0, 0, 0, 504, 6493, 1, 0, 0, 0, 506, 6534, 1, 0, + 0, 0, 508, 6536, 1, 0, 0, 0, 510, 6550, 1, 0, 0, 0, 512, 6555, 1, 0, 0, + 0, 514, 6559, 1, 0, 0, 0, 516, 6572, 1, 0, 0, 0, 518, 6597, 1, 0, 0, 0, + 520, 6599, 1, 0, 0, 0, 522, 6601, 1, 0, 0, 0, 524, 6603, 1, 0, 0, 0, 526, + 6637, 1, 0, 0, 0, 528, 6639, 1, 0, 0, 0, 530, 6656, 1, 0, 0, 0, 532, 6671, + 1, 0, 0, 0, 534, 6676, 1, 0, 0, 0, 536, 6702, 1, 0, 0, 0, 538, 6704, 1, + 0, 0, 0, 540, 6714, 1, 0, 0, 0, 542, 6718, 1, 0, 0, 0, 544, 6744, 1, 0, + 0, 0, 546, 6764, 1, 0, 0, 0, 548, 6771, 1, 0, 0, 0, 550, 6773, 1, 0, 0, + 0, 552, 6775, 1, 0, 0, 0, 554, 6777, 1, 0, 0, 0, 556, 6800, 1, 0, 0, 0, + 558, 6849, 1, 0, 0, 0, 560, 6851, 1, 0, 0, 0, 562, 6861, 1, 0, 0, 0, 564, + 6866, 1, 0, 0, 0, 566, 6870, 1, 0, 0, 0, 568, 6876, 1, 0, 0, 0, 570, 6880, + 1, 0, 0, 0, 572, 6888, 1, 0, 0, 0, 574, 6914, 1, 0, 0, 0, 576, 6916, 1, + 0, 0, 0, 578, 6922, 1, 0, 0, 0, 580, 6925, 1, 0, 0, 0, 582, 6928, 1, 0, + 0, 0, 584, 6931, 1, 0, 0, 0, 586, 6985, 1, 0, 0, 0, 588, 6987, 1, 0, 0, + 0, 590, 6998, 1, 0, 0, 0, 592, 7006, 1, 0, 0, 0, 594, 7017, 1, 0, 0, 0, + 596, 7019, 1, 0, 0, 0, 598, 7037, 1, 0, 0, 0, 600, 7039, 1, 0, 0, 0, 602, + 7056, 1, 0, 0, 0, 604, 7066, 1, 0, 0, 0, 606, 7069, 1, 0, 0, 0, 608, 7078, + 1, 0, 0, 0, 610, 7092, 1, 0, 0, 0, 612, 7106, 1, 0, 0, 0, 614, 7124, 1, + 0, 0, 0, 616, 7139, 1, 0, 0, 0, 618, 7156, 1, 0, 0, 0, 620, 7180, 1, 0, + 0, 0, 622, 7182, 1, 0, 0, 0, 624, 7211, 1, 0, 0, 0, 626, 7240, 1, 0, 0, + 0, 628, 7242, 1, 0, 0, 0, 630, 7244, 1, 0, 0, 0, 632, 7260, 1, 0, 0, 0, + 634, 7272, 1, 0, 0, 0, 636, 7305, 1, 0, 0, 0, 638, 7322, 1, 0, 0, 0, 640, + 7339, 1, 0, 0, 0, 642, 7355, 1, 0, 0, 0, 644, 7394, 1, 0, 0, 0, 646, 7401, + 1, 0, 0, 0, 648, 7405, 1, 0, 0, 0, 650, 7413, 1, 0, 0, 0, 652, 7415, 1, + 0, 0, 0, 654, 7433, 1, 0, 0, 0, 656, 7445, 1, 0, 0, 0, 658, 7462, 1, 0, + 0, 0, 660, 7477, 1, 0, 0, 0, 662, 7487, 1, 0, 0, 0, 664, 7493, 1, 0, 0, + 0, 666, 7497, 1, 0, 0, 0, 668, 7499, 1, 0, 0, 0, 670, 7501, 1, 0, 0, 0, + 672, 7516, 1, 0, 0, 0, 674, 7584, 1, 0, 0, 0, 676, 7615, 1, 0, 0, 0, 678, + 7617, 1, 0, 0, 0, 680, 7625, 1, 0, 0, 0, 682, 7675, 1, 0, 0, 0, 684, 7677, + 1, 0, 0, 0, 686, 7684, 1, 0, 0, 0, 688, 7689, 1, 0, 0, 0, 690, 7691, 1, + 0, 0, 0, 692, 7701, 1, 0, 0, 0, 694, 7762, 1, 0, 0, 0, 696, 7777, 1, 0, + 0, 0, 698, 7779, 1, 0, 0, 0, 700, 7784, 1, 0, 0, 0, 702, 7786, 1, 0, 0, + 0, 704, 7796, 1, 0, 0, 0, 706, 7798, 1, 0, 0, 0, 708, 7800, 1, 0, 0, 0, + 710, 7802, 1, 0, 0, 0, 712, 7806, 1, 0, 0, 0, 714, 7808, 1, 0, 0, 0, 716, + 7814, 1, 0, 0, 0, 718, 7861, 1, 0, 0, 0, 720, 7863, 1, 0, 0, 0, 722, 7890, + 1, 0, 0, 0, 724, 7894, 1, 0, 0, 0, 726, 7935, 1, 0, 0, 0, 728, 7937, 1, + 0, 0, 0, 730, 7946, 1, 0, 0, 0, 732, 7957, 1, 0, 0, 0, 734, 7961, 1, 0, + 0, 0, 736, 7963, 1, 0, 0, 0, 738, 7981, 1, 0, 0, 0, 740, 7988, 1, 0, 0, + 0, 742, 7995, 1, 0, 0, 0, 744, 8069, 1, 0, 0, 0, 746, 8071, 1, 0, 0, 0, + 748, 8078, 1, 0, 0, 0, 750, 8205, 1, 0, 0, 0, 752, 8216, 1, 0, 0, 0, 754, + 8227, 1, 0, 0, 0, 756, 8258, 1, 0, 0, 0, 758, 8266, 1, 0, 0, 0, 760, 8282, + 1, 0, 0, 0, 762, 8306, 1, 0, 0, 0, 764, 8311, 1, 0, 0, 0, 766, 8364, 1, + 0, 0, 0, 768, 8368, 1, 0, 0, 0, 770, 8383, 1, 0, 0, 0, 772, 8390, 1, 0, + 0, 0, 774, 8407, 1, 0, 0, 0, 776, 8430, 1, 0, 0, 0, 778, 8486, 1, 0, 0, + 0, 780, 8497, 1, 0, 0, 0, 782, 8505, 1, 0, 0, 0, 784, 8520, 1, 0, 0, 0, + 786, 8535, 1, 0, 0, 0, 788, 8537, 1, 0, 0, 0, 790, 8539, 1, 0, 0, 0, 792, + 8576, 1, 0, 0, 0, 794, 8585, 1, 0, 0, 0, 796, 8605, 1, 0, 0, 0, 798, 8615, + 1, 0, 0, 0, 800, 8619, 1, 0, 0, 0, 802, 8691, 1, 0, 0, 0, 804, 8702, 1, + 0, 0, 0, 806, 8720, 1, 0, 0, 0, 808, 8724, 1, 0, 0, 0, 810, 8727, 1, 0, + 0, 0, 812, 8730, 1, 0, 0, 0, 814, 8736, 1, 0, 0, 0, 816, 8741, 1, 0, 0, + 0, 818, 8745, 1, 0, 0, 0, 820, 8794, 1, 0, 0, 0, 822, 8824, 1, 0, 0, 0, + 824, 8846, 1, 0, 0, 0, 826, 8855, 1, 0, 0, 0, 828, 8859, 1, 0, 0, 0, 830, + 8882, 1, 0, 0, 0, 832, 8884, 1, 0, 0, 0, 834, 8921, 1, 0, 0, 0, 836, 8924, + 1, 0, 0, 0, 838, 8988, 1, 0, 0, 0, 840, 8993, 1, 0, 0, 0, 842, 8995, 1, + 0, 0, 0, 844, 9015, 1, 0, 0, 0, 846, 9069, 1, 0, 0, 0, 848, 9098, 1, 0, + 0, 0, 850, 9135, 1, 0, 0, 0, 852, 9139, 1, 0, 0, 0, 854, 9190, 1, 0, 0, + 0, 856, 9194, 1, 0, 0, 0, 858, 9218, 1, 0, 0, 0, 860, 9245, 1, 0, 0, 0, + 862, 9247, 1, 0, 0, 0, 864, 9249, 1, 0, 0, 0, 866, 9332, 1, 0, 0, 0, 868, + 9340, 1, 0, 0, 0, 870, 9342, 1, 0, 0, 0, 872, 9348, 1, 0, 0, 0, 874, 9359, + 1, 0, 0, 0, 876, 9361, 1, 0, 0, 0, 878, 9364, 1, 0, 0, 0, 880, 9366, 1, + 0, 0, 0, 882, 9375, 1, 0, 0, 0, 884, 9405, 1, 0, 0, 0, 886, 9408, 1, 0, + 0, 0, 888, 9410, 1, 0, 0, 0, 890, 9421, 1, 0, 0, 0, 892, 9426, 1, 0, 0, + 0, 894, 9443, 1, 0, 0, 0, 896, 9460, 1, 0, 0, 0, 898, 9463, 1, 0, 0, 0, + 900, 9514, 1, 0, 0, 0, 902, 9516, 1, 0, 0, 0, 904, 9524, 1, 0, 0, 0, 906, + 9540, 1, 0, 0, 0, 908, 9553, 1, 0, 0, 0, 910, 9555, 1, 0, 0, 0, 912, 9594, + 1, 0, 0, 0, 914, 9596, 1, 0, 0, 0, 916, 9602, 1, 0, 0, 0, 918, 9609, 1, + 0, 0, 0, 920, 9633, 1, 0, 0, 0, 922, 9646, 1, 0, 0, 0, 924, 9658, 1, 0, + 0, 0, 926, 9663, 1, 0, 0, 0, 928, 9681, 1, 0, 0, 0, 930, 9683, 1, 0, 0, + 0, 932, 9686, 1, 0, 0, 0, 934, 9737, 1, 0, 0, 0, 936, 9739, 1, 0, 0, 0, + 938, 9770, 1, 0, 0, 0, 940, 9772, 1, 0, 0, 0, 942, 9782, 1, 0, 0, 0, 944, + 9807, 1, 0, 0, 0, 946, 9812, 1, 0, 0, 0, 948, 9817, 1, 0, 0, 0, 950, 9855, + 1, 0, 0, 0, 952, 9917, 1, 0, 0, 0, 954, 9921, 1, 0, 0, 0, 956, 9926, 1, + 0, 0, 0, 958, 9950, 1, 0, 0, 0, 960, 9963, 1, 0, 0, 0, 962, 9968, 1, 0, + 0, 0, 964, 9994, 1, 0, 0, 0, 966, 9998, 1, 0, 0, 0, 968, 10003, 1, 0, 0, + 0, 970, 10008, 1, 0, 0, 0, 972, 10016, 1, 0, 0, 0, 974, 10022, 1, 0, 0, + 0, 976, 10025, 1, 0, 0, 0, 978, 10033, 1, 0, 0, 0, 980, 10039, 1, 0, 0, + 0, 982, 10060, 1, 0, 0, 0, 984, 10083, 1, 0, 0, 0, 986, 10091, 1, 0, 0, + 0, 988, 10093, 1, 0, 0, 0, 990, 10101, 1, 0, 0, 0, 992, 10113, 1, 0, 0, + 0, 994, 10130, 1, 0, 0, 0, 996, 10133, 1, 0, 0, 0, 998, 10148, 1, 0, 0, + 0, 1000, 10247, 1, 0, 0, 0, 1002, 10262, 1, 0, 0, 0, 1004, 10312, 1, 0, + 0, 0, 1006, 10314, 1, 0, 0, 0, 1008, 10320, 1, 0, 0, 0, 1010, 10341, 1, + 0, 0, 0, 1012, 10349, 1, 0, 0, 0, 1014, 10360, 1, 0, 0, 0, 1016, 10380, + 1, 0, 0, 0, 1018, 10382, 1, 0, 0, 0, 1020, 10434, 1, 0, 0, 0, 1022, 10458, + 1, 0, 0, 0, 1024, 10477, 1, 0, 0, 0, 1026, 10479, 1, 0, 0, 0, 1028, 10487, + 1, 0, 0, 0, 1030, 10490, 1, 0, 0, 0, 1032, 10493, 1, 0, 0, 0, 1034, 10521, + 1, 0, 0, 0, 1036, 10546, 1, 0, 0, 0, 1038, 10555, 1, 0, 0, 0, 1040, 10607, + 1, 0, 0, 0, 1042, 10643, 1, 0, 0, 0, 1044, 10665, 1, 0, 0, 0, 1046, 10707, + 1, 0, 0, 0, 1048, 10711, 1, 0, 0, 0, 1050, 10725, 1, 0, 0, 0, 1052, 10766, + 1, 0, 0, 0, 1054, 10768, 1, 0, 0, 0, 1056, 10782, 1, 0, 0, 0, 1058, 10813, + 1, 0, 0, 0, 1060, 10816, 1, 0, 0, 0, 1062, 10834, 1, 0, 0, 0, 1064, 10840, + 1, 0, 0, 0, 1066, 10859, 1, 0, 0, 0, 1068, 10863, 1, 0, 0, 0, 1070, 10865, + 1, 0, 0, 0, 1072, 10874, 1, 0, 0, 0, 1074, 10889, 1, 0, 0, 0, 1076, 10893, + 1, 0, 0, 0, 1078, 10902, 1, 0, 0, 0, 1080, 10917, 1, 0, 0, 0, 1082, 10923, + 1, 0, 0, 0, 1084, 10955, 1, 0, 0, 0, 1086, 10957, 1, 0, 0, 0, 1088, 10960, + 1, 0, 0, 0, 1090, 10963, 1, 0, 0, 0, 1092, 10989, 1, 0, 0, 0, 1094, 11000, + 1, 0, 0, 0, 1096, 11012, 1, 0, 0, 0, 1098, 11014, 1, 0, 0, 0, 1100, 11033, + 1, 0, 0, 0, 1102, 11035, 1, 0, 0, 0, 1104, 11046, 1, 0, 0, 0, 1106, 11060, + 1, 0, 0, 0, 1108, 11081, 1, 0, 0, 0, 1110, 11083, 1, 0, 0, 0, 1112, 11091, + 1, 0, 0, 0, 1114, 11101, 1, 0, 0, 0, 1116, 11103, 1, 0, 0, 0, 1118, 11159, + 1, 0, 0, 0, 1120, 11207, 1, 0, 0, 0, 1122, 11224, 1, 0, 0, 0, 1124, 11247, + 1, 0, 0, 0, 1126, 11284, 1, 0, 0, 0, 1128, 11286, 1, 0, 0, 0, 1130, 11336, + 1, 0, 0, 0, 1132, 11358, 1, 0, 0, 0, 1134, 11378, 1, 0, 0, 0, 1136, 11397, + 1, 0, 0, 0, 1138, 11403, 1, 0, 0, 0, 1140, 11418, 1, 0, 0, 0, 1142, 11460, + 1, 0, 0, 0, 1144, 11502, 1, 0, 0, 0, 1146, 11536, 1, 0, 0, 0, 1148, 11538, + 1, 0, 0, 0, 1150, 11554, 1, 0, 0, 0, 1152, 11563, 1, 0, 0, 0, 1154, 11596, + 1, 0, 0, 0, 1156, 11598, 1, 0, 0, 0, 1158, 11606, 1, 0, 0, 0, 1160, 11614, + 1, 0, 0, 0, 1162, 11621, 1, 0, 0, 0, 1164, 11638, 1, 0, 0, 0, 1166, 11663, + 1, 0, 0, 0, 1168, 11665, 1, 0, 0, 0, 1170, 11691, 1, 0, 0, 0, 1172, 11750, + 1, 0, 0, 0, 1174, 11754, 1, 0, 0, 0, 1176, 11778, 1, 0, 0, 0, 1178, 11823, + 1, 0, 0, 0, 1180, 11844, 1, 0, 0, 0, 1182, 11850, 1, 0, 0, 0, 1184, 11865, + 1, 0, 0, 0, 1186, 11867, 1, 0, 0, 0, 1188, 11870, 1, 0, 0, 0, 1190, 11897, + 1, 0, 0, 0, 1192, 11905, 1, 0, 0, 0, 1194, 11921, 1, 0, 0, 0, 1196, 11925, + 1, 0, 0, 0, 1198, 11960, 1, 0, 0, 0, 1200, 11975, 1, 0, 0, 0, 1202, 12022, + 1, 0, 0, 0, 1204, 12024, 1, 0, 0, 0, 1206, 12039, 1, 0, 0, 0, 1208, 12060, + 1, 0, 0, 0, 1210, 12062, 1, 0, 0, 0, 1212, 12090, 1, 0, 0, 0, 1214, 12092, + 1, 0, 0, 0, 1216, 12104, 1, 0, 0, 0, 1218, 12111, 1, 0, 0, 0, 1220, 12115, + 1, 0, 0, 0, 1222, 12123, 1, 0, 0, 0, 1224, 12144, 1, 0, 0, 0, 1226, 12149, + 1, 0, 0, 0, 1228, 12206, 1, 0, 0, 0, 1230, 12208, 1, 0, 0, 0, 1232, 12246, + 1, 0, 0, 0, 1234, 12257, 1, 0, 0, 0, 1236, 12265, 1, 0, 0, 0, 1238, 12276, + 1, 0, 0, 0, 1240, 12387, 1, 0, 0, 0, 1242, 12414, 1, 0, 0, 0, 1244, 12416, + 1, 0, 0, 0, 1246, 12419, 1, 0, 0, 0, 1248, 12437, 1, 0, 0, 0, 1250, 12440, + 1, 0, 0, 0, 1252, 12462, 1, 0, 0, 0, 1254, 12507, 1, 0, 0, 0, 1256, 12546, + 1, 0, 0, 0, 1258, 12554, 1, 0, 0, 0, 1260, 12556, 1, 0, 0, 0, 1262, 12674, + 1, 0, 0, 0, 1264, 12676, 1, 0, 0, 0, 1266, 12773, 1, 0, 0, 0, 1268, 12811, + 1, 0, 0, 0, 1270, 12828, 1, 0, 0, 0, 1272, 12831, 1, 0, 0, 0, 1274, 12844, + 1, 0, 0, 0, 1276, 12848, 1, 0, 0, 0, 1278, 12890, 1, 0, 0, 0, 1280, 12892, + 1, 0, 0, 0, 1282, 12915, 1, 0, 0, 0, 1284, 12938, 1, 0, 0, 0, 1286, 12954, + 1, 0, 0, 0, 1288, 12960, 1, 0, 0, 0, 1290, 12972, 1, 0, 0, 0, 1292, 12976, + 1, 0, 0, 0, 1294, 12985, 1, 0, 0, 0, 1296, 13009, 1, 0, 0, 0, 1298, 13034, + 1, 0, 0, 0, 1300, 13050, 1, 0, 0, 0, 1302, 13057, 1, 0, 0, 0, 1304, 13067, + 1, 0, 0, 0, 1306, 13078, 1, 0, 0, 0, 1308, 13085, 1, 0, 0, 0, 1310, 13087, + 1, 0, 0, 0, 1312, 13089, 1, 0, 0, 0, 1314, 13149, 1, 0, 0, 0, 1316, 13151, + 1, 0, 0, 0, 1318, 13165, 1, 0, 0, 0, 1320, 13184, 1, 0, 0, 0, 1322, 13186, + 1, 0, 0, 0, 1324, 13188, 1, 0, 0, 0, 1326, 13195, 1, 0, 0, 0, 1328, 13203, + 1, 0, 0, 0, 1330, 13220, 1, 0, 0, 0, 1332, 13250, 1, 0, 0, 0, 1334, 13254, + 1, 0, 0, 0, 1336, 13262, 1, 0, 0, 0, 1338, 13284, 1, 0, 0, 0, 1340, 13299, + 1, 0, 0, 0, 1342, 13349, 1, 0, 0, 0, 1344, 13365, 1, 0, 0, 0, 1346, 13375, + 1, 0, 0, 0, 1348, 13385, 1, 0, 0, 0, 1350, 13390, 1, 0, 0, 0, 1352, 13395, + 1, 0, 0, 0, 1354, 13406, 1, 0, 0, 0, 1356, 13410, 1, 0, 0, 0, 1358, 13414, + 1, 0, 0, 0, 1360, 13427, 1, 0, 0, 0, 1362, 13433, 1, 0, 0, 0, 1364, 13440, + 1, 0, 0, 0, 1366, 13442, 1, 0, 0, 0, 1368, 13444, 1, 0, 0, 0, 1370, 13464, + 1, 0, 0, 0, 1372, 13489, 1, 0, 0, 0, 1374, 13491, 1, 0, 0, 0, 1376, 13493, + 1, 0, 0, 0, 1378, 13500, 1, 0, 0, 0, 1380, 13502, 1, 0, 0, 0, 1382, 13504, + 1, 0, 0, 0, 1384, 13537, 1, 0, 0, 0, 1386, 13582, 1, 0, 0, 0, 1388, 13584, + 1, 0, 0, 0, 1390, 13615, 1, 0, 0, 0, 1392, 13652, 1, 0, 0, 0, 1394, 13671, + 1, 0, 0, 0, 1396, 13673, 1, 0, 0, 0, 1398, 13693, 1, 0, 0, 0, 1400, 13721, + 1, 0, 0, 0, 1402, 13746, 1, 0, 0, 0, 1404, 13828, 1, 0, 0, 0, 1406, 13830, + 1, 0, 0, 0, 1408, 13874, 1, 0, 0, 0, 1410, 13878, 1, 0, 0, 0, 1412, 13902, + 1, 0, 0, 0, 1414, 13909, 1, 0, 0, 0, 1416, 13917, 1, 0, 0, 0, 1418, 13919, + 1, 0, 0, 0, 1420, 13938, 1, 0, 0, 0, 1422, 13961, 1, 0, 0, 0, 1424, 13963, + 1, 0, 0, 0, 1426, 13981, 1, 0, 0, 0, 1428, 13986, 1, 0, 0, 0, 1430, 13996, + 1, 0, 0, 0, 1432, 14003, 1, 0, 0, 0, 1434, 14011, 1, 0, 0, 0, 1436, 14044, + 1, 0, 0, 0, 1438, 14067, 1, 0, 0, 0, 1440, 14072, 1, 0, 0, 0, 1442, 14123, + 1, 0, 0, 0, 1444, 14125, 1, 0, 0, 0, 1446, 14130, 1, 0, 0, 0, 1448, 14134, + 1, 0, 0, 0, 1450, 14137, 1, 0, 0, 0, 1452, 14139, 1, 0, 0, 0, 1454, 14141, + 1, 0, 0, 0, 1456, 14143, 1, 0, 0, 0, 1458, 14145, 1, 0, 0, 0, 1460, 14147, + 1, 0, 0, 0, 1462, 14161, 1, 0, 0, 0, 1464, 14166, 1, 0, 0, 0, 1466, 14173, + 1, 0, 0, 0, 1468, 14175, 1, 0, 0, 0, 1470, 14180, 1, 0, 0, 0, 1472, 14185, + 1, 0, 0, 0, 1474, 14191, 1, 0, 0, 0, 1476, 14195, 1, 0, 0, 0, 1478, 14221, + 1, 0, 0, 0, 1480, 14223, 1, 0, 0, 0, 1482, 14230, 1, 0, 0, 0, 1484, 14242, + 1, 0, 0, 0, 1486, 14302, 1, 0, 0, 0, 1488, 14306, 1, 0, 0, 0, 1490, 14328, + 1, 0, 0, 0, 1492, 14330, 1, 0, 0, 0, 1494, 14350, 1, 0, 0, 0, 1496, 14366, + 1, 0, 0, 0, 1498, 14371, 1, 0, 0, 0, 1500, 14379, 1, 0, 0, 0, 1502, 14383, + 1, 0, 0, 0, 1504, 14394, 1, 0, 0, 0, 1506, 14422, 1, 0, 0, 0, 1508, 14438, + 1, 0, 0, 0, 1510, 14447, 1, 0, 0, 0, 1512, 14479, 1, 0, 0, 0, 1514, 14487, + 1, 0, 0, 0, 1516, 14520, 1, 0, 0, 0, 1518, 14522, 1, 0, 0, 0, 1520, 14549, + 1, 0, 0, 0, 1522, 14568, 1, 0, 0, 0, 1524, 14594, 1, 0, 0, 0, 1526, 14596, + 1, 0, 0, 0, 1528, 14628, 1, 0, 0, 0, 1530, 14651, 1, 0, 0, 0, 1532, 14664, + 1, 0, 0, 0, 1534, 14666, 1, 0, 0, 0, 1536, 14685, 1, 0, 0, 0, 1538, 14696, + 1, 0, 0, 0, 1540, 14705, 1, 0, 0, 0, 1542, 14730, 1, 0, 0, 0, 1544, 14784, + 1, 0, 0, 0, 1546, 14808, 1, 0, 0, 0, 1548, 14822, 1, 0, 0, 0, 1550, 14832, + 1, 0, 0, 0, 1552, 14841, 1, 0, 0, 0, 1554, 14870, 1, 0, 0, 0, 1556, 14874, + 1, 0, 0, 0, 1558, 14882, 1, 0, 0, 0, 1560, 14919, 1, 0, 0, 0, 1562, 14972, + 1, 0, 0, 0, 1564, 14983, 1, 0, 0, 0, 1566, 14985, 1, 0, 0, 0, 1568, 15001, + 1, 0, 0, 0, 1570, 15003, 1, 0, 0, 0, 1572, 15028, 1, 0, 0, 0, 1574, 15030, + 1, 0, 0, 0, 1576, 15034, 1, 0, 0, 0, 1578, 15042, 1, 0, 0, 0, 1580, 15056, + 1, 0, 0, 0, 1582, 15067, 1, 0, 0, 0, 1584, 15082, 1, 0, 0, 0, 1586, 15117, + 1, 0, 0, 0, 1588, 15139, 1, 0, 0, 0, 1590, 15143, 1, 0, 0, 0, 1592, 15145, + 1, 0, 0, 0, 1594, 15149, 1, 0, 0, 0, 1596, 15184, 1, 0, 0, 0, 1598, 15189, + 1, 0, 0, 0, 1600, 15194, 1, 0, 0, 0, 1602, 15198, 1, 0, 0, 0, 1604, 15208, + 1, 0, 0, 0, 1606, 15210, 1, 0, 0, 0, 1608, 15218, 1, 0, 0, 0, 1610, 15220, + 1, 0, 0, 0, 1612, 15226, 1, 0, 0, 0, 1614, 15228, 1, 0, 0, 0, 1616, 15234, + 1, 0, 0, 0, 1618, 15300, 1, 0, 0, 0, 1620, 15302, 1, 0, 0, 0, 1622, 15330, + 1, 0, 0, 0, 1624, 15359, 1, 0, 0, 0, 1626, 15362, 1, 0, 0, 0, 1628, 15374, + 1, 0, 0, 0, 1630, 15401, 1, 0, 0, 0, 1632, 15410, 1, 0, 0, 0, 1634, 15428, + 1, 0, 0, 0, 1636, 15433, 1, 0, 0, 0, 1638, 15442, 1, 0, 0, 0, 1640, 15444, + 1, 0, 0, 0, 1642, 15491, 1, 0, 0, 0, 1644, 15524, 1, 0, 0, 0, 1646, 15553, + 1, 0, 0, 0, 1648, 15557, 1, 0, 0, 0, 1650, 15564, 1, 0, 0, 0, 1652, 15566, + 1, 0, 0, 0, 1654, 15576, 1, 0, 0, 0, 1656, 15592, 1, 0, 0, 0, 1658, 15597, + 1, 0, 0, 0, 1660, 15626, 1, 0, 0, 0, 1662, 15630, 1, 0, 0, 0, 1664, 15665, + 1, 0, 0, 0, 1666, 15677, 1, 0, 0, 0, 1668, 15679, 1, 0, 0, 0, 1670, 15681, + 1, 0, 0, 0, 1672, 15722, 1, 0, 0, 0, 1674, 15724, 1, 0, 0, 0, 1676, 15752, + 1, 0, 0, 0, 1678, 15782, 1, 0, 0, 0, 1680, 15784, 1, 0, 0, 0, 1682, 15846, + 1, 0, 0, 0, 1684, 15848, 1, 0, 0, 0, 1686, 15871, 1, 0, 0, 0, 1688, 15876, + 1, 0, 0, 0, 1690, 15884, 1, 0, 0, 0, 1692, 15921, 1, 0, 0, 0, 1694, 15942, + 1, 0, 0, 0, 1696, 15946, 1, 0, 0, 0, 1698, 15948, 1, 0, 0, 0, 1700, 15954, + 1, 0, 0, 0, 1702, 16012, 1, 0, 0, 0, 1704, 16014, 1, 0, 0, 0, 1706, 16016, + 1, 0, 0, 0, 1708, 16018, 1, 0, 0, 0, 1710, 16047, 1, 0, 0, 0, 1712, 16054, + 1, 0, 0, 0, 1714, 16061, 1, 0, 0, 0, 1716, 16075, 1, 0, 0, 0, 1718, 16086, + 1, 0, 0, 0, 1720, 16100, 1, 0, 0, 0, 1722, 16105, 1, 0, 0, 0, 1724, 16107, + 1, 0, 0, 0, 1726, 16115, 1, 0, 0, 0, 1728, 16140, 1, 0, 0, 0, 1730, 16146, + 1, 0, 0, 0, 1732, 16178, 1, 0, 0, 0, 1734, 16189, 1, 0, 0, 0, 1736, 16191, + 1, 0, 0, 0, 1738, 16204, 1, 0, 0, 0, 1740, 16208, 1, 0, 0, 0, 1742, 16223, + 1, 0, 0, 0, 1744, 16225, 1, 0, 0, 0, 1746, 16241, 1, 0, 0, 0, 1748, 16258, + 1, 0, 0, 0, 1750, 16283, 1, 0, 0, 0, 1752, 16293, 1, 0, 0, 0, 1754, 16297, + 1, 0, 0, 0, 1756, 16342, 1, 0, 0, 0, 1758, 16354, 1, 0, 0, 0, 1760, 16365, + 1, 0, 0, 0, 1762, 16371, 1, 0, 0, 0, 1764, 16382, 1, 0, 0, 0, 1766, 16394, + 1, 0, 0, 0, 1768, 16404, 1, 0, 0, 0, 1770, 16426, 1, 0, 0, 0, 1772, 16430, + 1, 0, 0, 0, 1774, 16453, 1, 0, 0, 0, 1776, 16457, 1, 0, 0, 0, 1778, 16462, + 1, 0, 0, 0, 1780, 16470, 1, 0, 0, 0, 1782, 16478, 1, 0, 0, 0, 1784, 16481, + 1, 0, 0, 0, 1786, 16497, 1, 0, 0, 0, 1788, 16502, 1, 0, 0, 0, 1790, 16506, + 1, 0, 0, 0, 1792, 16546, 1, 0, 0, 0, 1794, 16548, 1, 0, 0, 0, 1796, 16573, + 1, 0, 0, 0, 1798, 16575, 1, 0, 0, 0, 1800, 16580, 1, 0, 0, 0, 1802, 16582, + 1, 0, 0, 0, 1804, 16584, 1, 0, 0, 0, 1806, 16586, 1, 0, 0, 0, 1808, 16590, + 1, 0, 0, 0, 1810, 16595, 1, 0, 0, 0, 1812, 16615, 1, 0, 0, 0, 1814, 16621, + 1, 0, 0, 0, 1816, 16638, 1, 0, 0, 0, 1818, 16652, 1, 0, 0, 0, 1820, 16656, + 1, 0, 0, 0, 1822, 16670, 1, 0, 0, 0, 1824, 16689, 1, 0, 0, 0, 1826, 16696, + 1, 0, 0, 0, 1828, 16708, 1, 0, 0, 0, 1830, 16717, 1, 0, 0, 0, 1832, 16719, + 1, 0, 0, 0, 1834, 16733, 1, 0, 0, 0, 1836, 16743, 1, 0, 0, 0, 1838, 16749, + 1, 0, 0, 0, 1840, 16751, 1, 0, 0, 0, 1842, 16754, 1, 0, 0, 0, 1844, 16763, + 1, 0, 0, 0, 1846, 16796, 1, 0, 0, 0, 1848, 16798, 1, 0, 0, 0, 1850, 16813, + 1, 0, 0, 0, 1852, 16815, 1, 0, 0, 0, 1854, 16836, 1, 0, 0, 0, 1856, 16851, + 1, 0, 0, 0, 1858, 16876, 1, 0, 0, 0, 1860, 16884, 1, 0, 0, 0, 1862, 16897, + 1, 0, 0, 0, 1864, 16900, 1, 0, 0, 0, 1866, 16925, 1, 0, 0, 0, 1868, 16946, + 1, 0, 0, 0, 1870, 16950, 1, 0, 0, 0, 1872, 16993, 1, 0, 0, 0, 1874, 16997, + 1, 0, 0, 0, 1876, 16999, 1, 0, 0, 0, 1878, 17016, 1, 0, 0, 0, 1880, 17059, + 1, 0, 0, 0, 1882, 17068, 1, 0, 0, 0, 1884, 17076, 1, 0, 0, 0, 1886, 17087, + 1, 0, 0, 0, 1888, 17099, 1, 0, 0, 0, 1890, 17114, 1, 0, 0, 0, 1892, 17119, + 1, 0, 0, 0, 1894, 17132, 1, 0, 0, 0, 1896, 17138, 1, 0, 0, 0, 1898, 17150, + 1, 0, 0, 0, 1900, 17158, 1, 0, 0, 0, 1902, 17162, 1, 0, 0, 0, 1904, 17204, + 1, 0, 0, 0, 1906, 17206, 1, 0, 0, 0, 1908, 17217, 1, 0, 0, 0, 1910, 17219, + 1, 0, 0, 0, 1912, 17227, 1, 0, 0, 0, 1914, 17238, 1, 0, 0, 0, 1916, 17272, + 1, 0, 0, 0, 1918, 17299, 1, 0, 0, 0, 1920, 17301, 1, 0, 0, 0, 1922, 17304, + 1, 0, 0, 0, 1924, 17307, 1, 0, 0, 0, 1926, 17311, 1, 0, 0, 0, 1928, 17347, + 1, 0, 0, 0, 1930, 17349, 1, 0, 0, 0, 1932, 17374, 1, 0, 0, 0, 1934, 17379, + 1, 0, 0, 0, 1936, 17384, 1, 0, 0, 0, 1938, 17407, 1, 0, 0, 0, 1940, 17417, + 1, 0, 0, 0, 1942, 17419, 1, 0, 0, 0, 1944, 17435, 1, 0, 0, 0, 1946, 17449, + 1, 0, 0, 0, 1948, 17485, 1, 0, 0, 0, 1950, 17487, 1, 0, 0, 0, 1952, 17517, + 1, 0, 0, 0, 1954, 17522, 1, 0, 0, 0, 1956, 17524, 1, 0, 0, 0, 1958, 17536, + 1, 0, 0, 0, 1960, 17556, 1, 0, 0, 0, 1962, 17558, 1, 0, 0, 0, 1964, 17561, + 1, 0, 0, 0, 1966, 17587, 1, 0, 0, 0, 1968, 17589, 1, 0, 0, 0, 1970, 17593, + 1, 0, 0, 0, 1972, 17608, 1, 0, 0, 0, 1974, 17620, 1, 0, 0, 0, 1976, 17628, + 1, 0, 0, 0, 1978, 17632, 1, 0, 0, 0, 1980, 17645, 1, 0, 0, 0, 1982, 17651, + 1, 0, 0, 0, 1984, 17666, 1, 0, 0, 0, 1986, 17686, 1, 0, 0, 0, 1988, 17695, + 1, 0, 0, 0, 1990, 17697, 1, 0, 0, 0, 1992, 17704, 1, 0, 0, 0, 1994, 17709, + 1, 0, 0, 0, 1996, 17722, 1, 0, 0, 0, 1998, 17730, 1, 0, 0, 0, 2000, 17734, + 1, 0, 0, 0, 2002, 17748, 1, 0, 0, 0, 2004, 17756, 1, 0, 0, 0, 2006, 17764, + 1, 0, 0, 0, 2008, 17766, 1, 0, 0, 0, 2010, 17778, 1, 0, 0, 0, 2012, 17804, + 1, 0, 0, 0, 2014, 17806, 1, 0, 0, 0, 2016, 17820, 1, 0, 0, 0, 2018, 17825, + 1, 0, 0, 0, 2020, 17843, 1, 0, 0, 0, 2022, 17847, 1, 0, 0, 0, 2024, 17855, + 1, 0, 0, 0, 2026, 17865, 1, 0, 0, 0, 2028, 17873, 1, 0, 0, 0, 2030, 17879, + 1, 0, 0, 0, 2032, 17887, 1, 0, 0, 0, 2034, 17896, 1, 0, 0, 0, 2036, 17921, + 1, 0, 0, 0, 2038, 17940, 1, 0, 0, 0, 2040, 17944, 1, 0, 0, 0, 2042, 17947, + 1, 0, 0, 0, 2044, 17969, 1, 0, 0, 0, 2046, 17974, 1, 0, 0, 0, 2048, 17993, + 1, 0, 0, 0, 2050, 17995, 1, 0, 0, 0, 2052, 18011, 1, 0, 0, 0, 2054, 18019, + 1, 0, 0, 0, 2056, 18024, 1, 0, 0, 0, 2058, 18028, 1, 0, 0, 0, 2060, 18039, + 1, 0, 0, 0, 2062, 18042, 1, 0, 0, 0, 2064, 18084, 1, 0, 0, 0, 2066, 18086, + 1, 0, 0, 0, 2068, 18099, 1, 0, 0, 0, 2070, 18110, 1, 0, 0, 0, 2072, 18124, + 1, 0, 0, 0, 2074, 18135, 1, 0, 0, 0, 2076, 18137, 1, 0, 0, 0, 2078, 18147, + 1, 0, 0, 0, 2080, 18149, 1, 0, 0, 0, 2082, 18154, 1, 0, 0, 0, 2084, 18169, + 1, 0, 0, 0, 2086, 18175, 1, 0, 0, 0, 2088, 18219, 1, 0, 0, 0, 2090, 18221, + 1, 0, 0, 0, 2092, 18245, 1, 0, 0, 0, 2094, 18263, 1, 0, 0, 0, 2096, 18295, + 1, 0, 0, 0, 2098, 18315, 1, 0, 0, 0, 2100, 18317, 1, 0, 0, 0, 2102, 18321, + 1, 0, 0, 0, 2104, 18383, 1, 0, 0, 0, 2106, 18386, 1, 0, 0, 0, 2108, 18418, + 1, 0, 0, 0, 2110, 18420, 1, 0, 0, 0, 2112, 18441, 1, 0, 0, 0, 2114, 18475, + 1, 0, 0, 0, 2116, 18483, 1, 0, 0, 0, 2118, 18485, 1, 0, 0, 0, 2120, 18504, + 1, 0, 0, 0, 2122, 18517, 1, 0, 0, 0, 2124, 18520, 1, 0, 0, 0, 2126, 18540, + 1, 0, 0, 0, 2128, 18558, 1, 0, 0, 0, 2130, 18563, 1, 0, 0, 0, 2132, 18568, + 1, 0, 0, 0, 2134, 18570, 1, 0, 0, 0, 2136, 18584, 1, 0, 0, 0, 2138, 18597, + 1, 0, 0, 0, 2140, 18602, 1, 0, 0, 0, 2142, 18625, 1, 0, 0, 0, 2144, 18627, + 1, 0, 0, 0, 2146, 18731, 1, 0, 0, 0, 2148, 18738, 1, 0, 0, 0, 2150, 18928, + 1, 0, 0, 0, 2152, 18939, 1, 0, 0, 0, 2154, 18969, 1, 0, 0, 0, 2156, 18975, + 1, 0, 0, 0, 2158, 19006, 1, 0, 0, 0, 2160, 19012, 1, 0, 0, 0, 2162, 19016, + 1, 0, 0, 0, 2164, 19117, 1, 0, 0, 0, 2166, 19119, 1, 0, 0, 0, 2168, 19184, + 1, 0, 0, 0, 2170, 19188, 1, 0, 0, 0, 2172, 19207, 1, 0, 0, 0, 2174, 19222, + 1, 0, 0, 0, 2176, 19231, 1, 0, 0, 0, 2178, 19243, 1, 0, 0, 0, 2180, 19248, + 1, 0, 0, 0, 2182, 19291, 1, 0, 0, 0, 2184, 19293, 1, 0, 0, 0, 2186, 19311, + 1, 0, 0, 0, 2188, 19313, 1, 0, 0, 0, 2190, 19400, 1, 0, 0, 0, 2192, 19402, + 1, 0, 0, 0, 2194, 19833, 1, 0, 0, 0, 2196, 19835, 1, 0, 0, 0, 2198, 19837, + 1, 0, 0, 0, 2200, 19839, 1, 0, 0, 0, 2202, 19841, 1, 0, 0, 0, 2204, 19867, + 1, 0, 0, 0, 2206, 19876, 1, 0, 0, 0, 2208, 19885, 1, 0, 0, 0, 2210, 19887, + 1, 0, 0, 0, 2212, 19907, 1, 0, 0, 0, 2214, 19911, 1, 0, 0, 0, 2216, 19913, + 1, 0, 0, 0, 2218, 19930, 1, 0, 0, 0, 2220, 19940, 1, 0, 0, 0, 2222, 19951, + 1, 0, 0, 0, 2224, 19975, 1, 0, 0, 0, 2226, 19994, 1, 0, 0, 0, 2228, 20012, + 1, 0, 0, 0, 2230, 20033, 1, 0, 0, 0, 2232, 20046, 1, 0, 0, 0, 2234, 20049, + 1, 0, 0, 0, 2236, 20059, 1, 0, 0, 0, 2238, 20065, 1, 0, 0, 0, 2240, 20073, + 1, 0, 0, 0, 2242, 20076, 1, 0, 0, 0, 2244, 20087, 1, 0, 0, 0, 2246, 20089, + 1, 0, 0, 0, 2248, 20108, 1, 0, 0, 0, 2250, 20118, 1, 0, 0, 0, 2252, 20131, + 1, 0, 0, 0, 2254, 20138, 1, 0, 0, 0, 2256, 20145, 1, 0, 0, 0, 2258, 20162, + 1, 0, 0, 0, 2260, 20181, 1, 0, 0, 0, 2262, 20199, 1, 0, 0, 0, 2264, 20217, + 1, 0, 0, 0, 2266, 20219, 1, 0, 0, 0, 2268, 20237, 1, 0, 0, 0, 2270, 20241, + 1, 0, 0, 0, 2272, 20243, 1, 0, 0, 0, 2274, 20252, 1, 0, 0, 0, 2276, 20271, + 1, 0, 0, 0, 2278, 20273, 1, 0, 0, 0, 2280, 20275, 1, 0, 0, 0, 2282, 20277, + 1, 0, 0, 0, 2284, 20279, 1, 0, 0, 0, 2286, 20281, 1, 0, 0, 0, 2288, 20283, + 1, 0, 0, 0, 2290, 20295, 1, 0, 0, 0, 2292, 20297, 1, 0, 0, 0, 2294, 20302, + 1, 0, 0, 0, 2296, 20304, 1, 0, 0, 0, 2298, 20306, 1, 0, 0, 0, 2300, 20308, + 1, 0, 0, 0, 2302, 20313, 1, 0, 0, 0, 2304, 20321, 1, 0, 0, 0, 2306, 20323, + 1, 0, 0, 0, 2308, 20329, 1, 0, 0, 0, 2310, 20331, 1, 0, 0, 0, 2312, 20343, + 1, 0, 0, 0, 2314, 20345, 1, 0, 0, 0, 2316, 20353, 1, 0, 0, 0, 2318, 20361, + 1, 0, 0, 0, 2320, 20369, 1, 0, 0, 0, 2322, 20374, 1, 0, 0, 0, 2324, 20379, + 1, 0, 0, 0, 2326, 20394, 1, 0, 0, 0, 2328, 20396, 1, 0, 0, 0, 2330, 20403, + 1, 0, 0, 0, 2332, 20407, 1, 0, 0, 0, 2334, 20409, 1, 0, 0, 0, 2336, 20421, + 1, 0, 0, 0, 2338, 20423, 1, 0, 0, 0, 2340, 20425, 1, 0, 0, 0, 2342, 20447, + 1, 0, 0, 0, 2344, 20449, 1, 0, 0, 0, 2346, 20476, 1, 0, 0, 0, 2348, 20484, + 1, 0, 0, 0, 2350, 20486, 1, 0, 0, 0, 2352, 20488, 1, 0, 0, 0, 2354, 20490, + 1, 0, 0, 0, 2356, 20516, 1, 0, 0, 0, 2358, 20518, 1, 0, 0, 0, 2360, 20526, + 1, 0, 0, 0, 2362, 20530, 1, 0, 0, 0, 2364, 20542, 1, 0, 0, 0, 2366, 20557, + 1, 0, 0, 0, 2368, 20578, 1, 0, 0, 0, 2370, 20620, 1, 0, 0, 0, 2372, 20627, + 1, 0, 0, 0, 2374, 20639, 1, 0, 0, 0, 2376, 20672, 1, 0, 0, 0, 2378, 20674, + 1, 0, 0, 0, 2380, 20756, 1, 0, 0, 0, 2382, 20761, 1, 0, 0, 0, 2384, 20786, + 1, 0, 0, 0, 2386, 20802, 1, 0, 0, 0, 2388, 20817, 1, 0, 0, 0, 2390, 20863, + 1, 0, 0, 0, 2392, 21191, 1, 0, 0, 0, 2394, 21256, 1, 0, 0, 0, 2396, 21263, + 1, 0, 0, 0, 2398, 21265, 1, 0, 0, 0, 2400, 21268, 1, 0, 0, 0, 2402, 21272, + 1, 0, 0, 0, 2404, 21278, 1, 0, 0, 0, 2406, 21280, 1, 0, 0, 0, 2408, 21282, + 1, 0, 0, 0, 2410, 21408, 1, 0, 0, 0, 2412, 21410, 1, 0, 0, 0, 2414, 21412, + 1, 0, 0, 0, 2416, 21414, 1, 0, 0, 0, 2418, 2420, 3, 2252, 1126, 0, 2419, + 2421, 5, 2470, 0, 0, 2420, 2419, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, + 2423, 1, 0, 0, 0, 2422, 2418, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, + 2422, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2429, 1, 0, 0, 0, 2426, + 2424, 1, 0, 0, 0, 2427, 2430, 3, 2252, 1126, 0, 2428, 2430, 3, 2, 1, 0, + 2429, 2427, 1, 0, 0, 0, 2429, 2428, 1, 0, 0, 0, 2430, 2441, 1, 0, 0, 0, + 2431, 2433, 5, 2470, 0, 0, 2432, 2434, 5, 2454, 0, 0, 2433, 2432, 1, 0, + 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2438, 3, 2252, + 1126, 0, 2436, 2438, 3, 2, 1, 0, 2437, 2435, 1, 0, 0, 0, 2437, 2436, 1, + 0, 0, 0, 2438, 2440, 1, 0, 0, 0, 2439, 2431, 1, 0, 0, 0, 2440, 2443, 1, + 0, 0, 0, 2441, 2439, 1, 0, 0, 0, 2441, 2442, 1, 0, 0, 0, 2442, 2445, 1, + 0, 0, 0, 2443, 2441, 1, 0, 0, 0, 2444, 2446, 5, 2470, 0, 0, 2445, 2444, + 1, 0, 0, 0, 2445, 2446, 1, 0, 0, 0, 2446, 2448, 1, 0, 0, 0, 2447, 2449, + 5, 2454, 0, 0, 2448, 2447, 1, 0, 0, 0, 2448, 2449, 1, 0, 0, 0, 2449, 2450, + 1, 0, 0, 0, 2450, 2451, 5, 0, 0, 1, 2451, 1, 1, 0, 0, 0, 2452, 2594, 3, + 1328, 664, 0, 2453, 2594, 3, 1338, 669, 0, 2454, 2594, 3, 1340, 670, 0, + 2455, 2594, 3, 1342, 671, 0, 2456, 2594, 3, 1368, 684, 0, 2457, 2594, 3, + 1476, 738, 0, 2458, 2594, 3, 818, 409, 0, 2459, 2594, 3, 4, 2, 0, 2460, + 2594, 3, 94, 47, 0, 2461, 2594, 3, 98, 49, 0, 2462, 2594, 3, 96, 48, 0, + 2463, 2594, 3, 514, 257, 0, 2464, 2594, 3, 554, 277, 0, 2465, 2594, 3, + 100, 50, 0, 2466, 2594, 3, 794, 397, 0, 2467, 2594, 3, 132, 66, 0, 2468, + 2594, 3, 932, 466, 0, 2469, 2594, 3, 942, 471, 0, 2470, 2594, 3, 958, 479, + 0, 2471, 2594, 3, 976, 488, 0, 2472, 2594, 3, 128, 64, 0, 2473, 2594, 3, + 154, 77, 0, 2474, 2594, 3, 168, 84, 0, 2475, 2594, 3, 174, 87, 0, 2476, + 2594, 3, 182, 91, 0, 2477, 2594, 3, 1522, 761, 0, 2478, 2594, 3, 186, 93, + 0, 2479, 2594, 3, 318, 159, 0, 2480, 2594, 3, 320, 160, 0, 2481, 2594, + 3, 1312, 656, 0, 2482, 2594, 3, 1526, 763, 0, 2483, 2594, 3, 864, 432, + 0, 2484, 2594, 3, 1514, 757, 0, 2485, 2594, 3, 204, 102, 0, 2486, 2594, + 3, 240, 120, 0, 2487, 2594, 3, 558, 279, 0, 2488, 2594, 3, 832, 416, 0, + 2489, 2594, 3, 1718, 859, 0, 2490, 2594, 3, 1810, 905, 0, 2491, 2594, 3, + 330, 165, 0, 2492, 2594, 3, 380, 190, 0, 2493, 2594, 3, 406, 203, 0, 2494, + 2594, 3, 1018, 509, 0, 2495, 2594, 3, 1014, 507, 0, 2496, 2594, 3, 428, + 214, 0, 2497, 2594, 3, 1482, 741, 0, 2498, 2594, 3, 1484, 742, 0, 2499, + 2594, 3, 1510, 755, 0, 2500, 2594, 3, 782, 391, 0, 2501, 2594, 3, 784, + 392, 0, 2502, 2594, 3, 438, 219, 0, 2503, 2594, 3, 442, 221, 0, 2504, 2594, + 3, 444, 222, 0, 2505, 2594, 3, 104, 52, 0, 2506, 2594, 3, 450, 225, 0, + 2507, 2594, 3, 462, 231, 0, 2508, 2594, 3, 790, 395, 0, 2509, 2594, 3, + 800, 400, 0, 2510, 2594, 3, 802, 401, 0, 2511, 2594, 3, 1026, 513, 0, 2512, + 2594, 3, 998, 499, 0, 2513, 2594, 3, 950, 475, 0, 2514, 2594, 3, 956, 478, + 0, 2515, 2594, 3, 980, 490, 0, 2516, 2594, 3, 1032, 516, 0, 2517, 2594, + 3, 156, 78, 0, 2518, 2594, 3, 158, 79, 0, 2519, 2594, 3, 194, 97, 0, 2520, + 2594, 3, 180, 90, 0, 2521, 2594, 3, 1020, 510, 0, 2522, 2594, 3, 1034, + 517, 0, 2523, 2594, 3, 1036, 518, 0, 2524, 2594, 3, 200, 100, 0, 2525, + 2594, 3, 324, 162, 0, 2526, 2594, 3, 1318, 659, 0, 2527, 2594, 3, 1314, + 657, 0, 2528, 2594, 3, 1038, 519, 0, 2529, 2594, 3, 880, 440, 0, 2530, + 2594, 3, 898, 449, 0, 2531, 2594, 3, 206, 103, 0, 2532, 2594, 3, 256, 128, + 0, 2533, 2594, 3, 556, 278, 0, 2534, 2594, 3, 836, 418, 0, 2535, 2594, + 3, 1344, 672, 0, 2536, 2594, 3, 1346, 673, 0, 2537, 2594, 3, 1348, 674, + 0, 2538, 2594, 3, 1352, 676, 0, 2539, 2594, 3, 1354, 677, 0, 2540, 2594, + 3, 1508, 754, 0, 2541, 2594, 3, 1512, 756, 0, 2542, 2594, 3, 1356, 678, + 0, 2543, 2594, 3, 1358, 679, 0, 2544, 2594, 3, 1360, 680, 0, 2545, 2594, + 3, 1350, 675, 0, 2546, 2594, 3, 92, 46, 0, 2547, 2594, 3, 792, 396, 0, + 2548, 2594, 3, 746, 373, 0, 2549, 2594, 3, 750, 375, 0, 2550, 2594, 3, + 752, 376, 0, 2551, 2594, 3, 796, 398, 0, 2552, 2594, 3, 798, 399, 0, 2553, + 2594, 3, 150, 75, 0, 2554, 2594, 3, 1010, 505, 0, 2555, 2594, 3, 1012, + 506, 0, 2556, 2594, 3, 960, 480, 0, 2557, 2594, 3, 978, 489, 0, 2558, 2594, + 3, 184, 92, 0, 2559, 2594, 3, 152, 76, 0, 2560, 2594, 3, 170, 85, 0, 2561, + 2594, 3, 172, 86, 0, 2562, 2594, 3, 188, 94, 0, 2563, 2594, 3, 192, 96, + 0, 2564, 2594, 3, 190, 95, 0, 2565, 2594, 3, 316, 158, 0, 2566, 2594, 3, + 1316, 658, 0, 2567, 2594, 3, 1296, 648, 0, 2568, 2594, 3, 1298, 649, 0, + 2569, 2594, 3, 1300, 650, 0, 2570, 2594, 3, 202, 101, 0, 2571, 2594, 3, + 238, 119, 0, 2572, 2594, 3, 560, 280, 0, 2573, 2594, 3, 1304, 652, 0, 2574, + 2594, 3, 596, 298, 0, 2575, 2594, 3, 672, 336, 0, 2576, 2594, 3, 690, 345, + 0, 2577, 2594, 3, 720, 360, 0, 2578, 2594, 3, 1306, 653, 0, 2579, 2594, + 3, 1326, 663, 0, 2580, 2594, 3, 1324, 662, 0, 2581, 2594, 3, 1836, 918, + 0, 2582, 2594, 3, 748, 374, 0, 2583, 2594, 3, 754, 377, 0, 2584, 2594, + 3, 764, 382, 0, 2585, 2594, 3, 760, 380, 0, 2586, 2594, 3, 758, 379, 0, + 2587, 2594, 3, 762, 381, 0, 2588, 2594, 3, 768, 384, 0, 2589, 2594, 3, + 1850, 925, 0, 2590, 2594, 3, 1362, 681, 0, 2591, 2594, 3, 1294, 647, 0, + 2592, 2594, 3, 716, 358, 0, 2593, 2452, 1, 0, 0, 0, 2593, 2453, 1, 0, 0, + 0, 2593, 2454, 1, 0, 0, 0, 2593, 2455, 1, 0, 0, 0, 2593, 2456, 1, 0, 0, + 0, 2593, 2457, 1, 0, 0, 0, 2593, 2458, 1, 0, 0, 0, 2593, 2459, 1, 0, 0, + 0, 2593, 2460, 1, 0, 0, 0, 2593, 2461, 1, 0, 0, 0, 2593, 2462, 1, 0, 0, + 0, 2593, 2463, 1, 0, 0, 0, 2593, 2464, 1, 0, 0, 0, 2593, 2465, 1, 0, 0, + 0, 2593, 2466, 1, 0, 0, 0, 2593, 2467, 1, 0, 0, 0, 2593, 2468, 1, 0, 0, + 0, 2593, 2469, 1, 0, 0, 0, 2593, 2470, 1, 0, 0, 0, 2593, 2471, 1, 0, 0, + 0, 2593, 2472, 1, 0, 0, 0, 2593, 2473, 1, 0, 0, 0, 2593, 2474, 1, 0, 0, + 0, 2593, 2475, 1, 0, 0, 0, 2593, 2476, 1, 0, 0, 0, 2593, 2477, 1, 0, 0, + 0, 2593, 2478, 1, 0, 0, 0, 2593, 2479, 1, 0, 0, 0, 2593, 2480, 1, 0, 0, + 0, 2593, 2481, 1, 0, 0, 0, 2593, 2482, 1, 0, 0, 0, 2593, 2483, 1, 0, 0, + 0, 2593, 2484, 1, 0, 0, 0, 2593, 2485, 1, 0, 0, 0, 2593, 2486, 1, 0, 0, + 0, 2593, 2487, 1, 0, 0, 0, 2593, 2488, 1, 0, 0, 0, 2593, 2489, 1, 0, 0, + 0, 2593, 2490, 1, 0, 0, 0, 2593, 2491, 1, 0, 0, 0, 2593, 2492, 1, 0, 0, + 0, 2593, 2493, 1, 0, 0, 0, 2593, 2494, 1, 0, 0, 0, 2593, 2495, 1, 0, 0, + 0, 2593, 2496, 1, 0, 0, 0, 2593, 2497, 1, 0, 0, 0, 2593, 2498, 1, 0, 0, + 0, 2593, 2499, 1, 0, 0, 0, 2593, 2500, 1, 0, 0, 0, 2593, 2501, 1, 0, 0, + 0, 2593, 2502, 1, 0, 0, 0, 2593, 2503, 1, 0, 0, 0, 2593, 2504, 1, 0, 0, + 0, 2593, 2505, 1, 0, 0, 0, 2593, 2506, 1, 0, 0, 0, 2593, 2507, 1, 0, 0, + 0, 2593, 2508, 1, 0, 0, 0, 2593, 2509, 1, 0, 0, 0, 2593, 2510, 1, 0, 0, + 0, 2593, 2511, 1, 0, 0, 0, 2593, 2512, 1, 0, 0, 0, 2593, 2513, 1, 0, 0, + 0, 2593, 2514, 1, 0, 0, 0, 2593, 2515, 1, 0, 0, 0, 2593, 2516, 1, 0, 0, + 0, 2593, 2517, 1, 0, 0, 0, 2593, 2518, 1, 0, 0, 0, 2593, 2519, 1, 0, 0, + 0, 2593, 2520, 1, 0, 0, 0, 2593, 2521, 1, 0, 0, 0, 2593, 2522, 1, 0, 0, + 0, 2593, 2523, 1, 0, 0, 0, 2593, 2524, 1, 0, 0, 0, 2593, 2525, 1, 0, 0, + 0, 2593, 2526, 1, 0, 0, 0, 2593, 2527, 1, 0, 0, 0, 2593, 2528, 1, 0, 0, + 0, 2593, 2529, 1, 0, 0, 0, 2593, 2530, 1, 0, 0, 0, 2593, 2531, 1, 0, 0, + 0, 2593, 2532, 1, 0, 0, 0, 2593, 2533, 1, 0, 0, 0, 2593, 2534, 1, 0, 0, + 0, 2593, 2535, 1, 0, 0, 0, 2593, 2536, 1, 0, 0, 0, 2593, 2537, 1, 0, 0, + 0, 2593, 2538, 1, 0, 0, 0, 2593, 2539, 1, 0, 0, 0, 2593, 2540, 1, 0, 0, + 0, 2593, 2541, 1, 0, 0, 0, 2593, 2542, 1, 0, 0, 0, 2593, 2543, 1, 0, 0, + 0, 2593, 2544, 1, 0, 0, 0, 2593, 2545, 1, 0, 0, 0, 2593, 2546, 1, 0, 0, + 0, 2593, 2547, 1, 0, 0, 0, 2593, 2548, 1, 0, 0, 0, 2593, 2549, 1, 0, 0, + 0, 2593, 2550, 1, 0, 0, 0, 2593, 2551, 1, 0, 0, 0, 2593, 2552, 1, 0, 0, + 0, 2593, 2553, 1, 0, 0, 0, 2593, 2554, 1, 0, 0, 0, 2593, 2555, 1, 0, 0, + 0, 2593, 2556, 1, 0, 0, 0, 2593, 2557, 1, 0, 0, 0, 2593, 2558, 1, 0, 0, + 0, 2593, 2559, 1, 0, 0, 0, 2593, 2560, 1, 0, 0, 0, 2593, 2561, 1, 0, 0, + 0, 2593, 2562, 1, 0, 0, 0, 2593, 2563, 1, 0, 0, 0, 2593, 2564, 1, 0, 0, + 0, 2593, 2565, 1, 0, 0, 0, 2593, 2566, 1, 0, 0, 0, 2593, 2567, 1, 0, 0, + 0, 2593, 2568, 1, 0, 0, 0, 2593, 2569, 1, 0, 0, 0, 2593, 2570, 1, 0, 0, + 0, 2593, 2571, 1, 0, 0, 0, 2593, 2572, 1, 0, 0, 0, 2593, 2573, 1, 0, 0, + 0, 2593, 2574, 1, 0, 0, 0, 2593, 2575, 1, 0, 0, 0, 2593, 2576, 1, 0, 0, + 0, 2593, 2577, 1, 0, 0, 0, 2593, 2578, 1, 0, 0, 0, 2593, 2579, 1, 0, 0, + 0, 2593, 2580, 1, 0, 0, 0, 2593, 2581, 1, 0, 0, 0, 2593, 2582, 1, 0, 0, + 0, 2593, 2583, 1, 0, 0, 0, 2593, 2584, 1, 0, 0, 0, 2593, 2585, 1, 0, 0, + 0, 2593, 2586, 1, 0, 0, 0, 2593, 2587, 1, 0, 0, 0, 2593, 2588, 1, 0, 0, + 0, 2593, 2589, 1, 0, 0, 0, 2593, 2590, 1, 0, 0, 0, 2593, 2591, 1, 0, 0, + 0, 2593, 2592, 1, 0, 0, 0, 2594, 3, 1, 0, 0, 0, 2595, 2596, 5, 42, 0, 0, + 2596, 2650, 5, 441, 0, 0, 2597, 2632, 3, 2404, 1202, 0, 2598, 2601, 3, + 6, 3, 0, 2599, 2601, 3, 8, 4, 0, 2600, 2598, 1, 0, 0, 0, 2600, 2599, 1, + 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2600, 1, 0, 0, 0, 2602, 2603, 1, + 0, 0, 0, 2603, 2606, 1, 0, 0, 0, 2604, 2606, 3, 10, 5, 0, 2605, 2600, 1, + 0, 0, 0, 2605, 2604, 1, 0, 0, 0, 2606, 2608, 1, 0, 0, 0, 2607, 2609, 3, + 24, 12, 0, 2608, 2607, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2633, + 1, 0, 0, 0, 2610, 2631, 3, 12, 6, 0, 2611, 2631, 3, 16, 8, 0, 2612, 2631, + 3, 18, 9, 0, 2613, 2631, 3, 20, 10, 0, 2614, 2631, 3, 24, 12, 0, 2615, + 2631, 3, 28, 14, 0, 2616, 2631, 3, 30, 15, 0, 2617, 2631, 3, 40, 20, 0, + 2618, 2631, 3, 44, 22, 0, 2619, 2631, 3, 46, 23, 0, 2620, 2631, 3, 52, + 26, 0, 2621, 2631, 3, 54, 27, 0, 2622, 2631, 3, 56, 28, 0, 2623, 2631, + 3, 58, 29, 0, 2624, 2631, 3, 60, 30, 0, 2625, 2631, 3, 62, 31, 0, 2626, + 2631, 3, 64, 32, 0, 2627, 2631, 3, 66, 33, 0, 2628, 2631, 3, 68, 34, 0, + 2629, 2631, 3, 74, 37, 0, 2630, 2610, 1, 0, 0, 0, 2630, 2611, 1, 0, 0, + 0, 2630, 2612, 1, 0, 0, 0, 2630, 2613, 1, 0, 0, 0, 2630, 2614, 1, 0, 0, + 0, 2630, 2615, 1, 0, 0, 0, 2630, 2616, 1, 0, 0, 0, 2630, 2617, 1, 0, 0, + 0, 2630, 2618, 1, 0, 0, 0, 2630, 2619, 1, 0, 0, 0, 2630, 2620, 1, 0, 0, + 0, 2630, 2621, 1, 0, 0, 0, 2630, 2622, 1, 0, 0, 0, 2630, 2623, 1, 0, 0, + 0, 2630, 2624, 1, 0, 0, 0, 2630, 2625, 1, 0, 0, 0, 2630, 2626, 1, 0, 0, + 0, 2630, 2627, 1, 0, 0, 0, 2630, 2628, 1, 0, 0, 0, 2630, 2629, 1, 0, 0, + 0, 2631, 2633, 1, 0, 0, 0, 2632, 2605, 1, 0, 0, 0, 2632, 2630, 1, 0, 0, + 0, 2633, 2651, 1, 0, 0, 0, 2634, 2639, 3, 2404, 1202, 0, 2635, 2636, 5, + 2453, 0, 0, 2636, 2638, 3, 2404, 1202, 0, 2637, 2635, 1, 0, 0, 0, 2638, + 2641, 1, 0, 0, 0, 2639, 2637, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, + 2644, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2642, 2644, 5, 38, 0, 0, 2643, + 2634, 1, 0, 0, 0, 2643, 2642, 1, 0, 0, 0, 2644, 2648, 1, 0, 0, 0, 2645, + 2649, 3, 86, 43, 0, 2646, 2649, 3, 88, 44, 0, 2647, 2649, 3, 90, 45, 0, + 2648, 2645, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, 0, 2648, 2647, 1, 0, 0, 0, + 2649, 2651, 1, 0, 0, 0, 2650, 2597, 1, 0, 0, 0, 2650, 2643, 1, 0, 0, 0, + 2651, 5, 1, 0, 0, 0, 2652, 2673, 5, 21, 0, 0, 2653, 2654, 5, 1688, 0, 0, + 2654, 2656, 3, 2404, 1202, 0, 2655, 2653, 1, 0, 0, 0, 2655, 2656, 1, 0, + 0, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2659, 3, 84, 42, 0, 2658, 2657, 1, + 0, 0, 0, 2658, 2659, 1, 0, 0, 0, 2659, 2662, 1, 0, 0, 0, 2660, 2661, 5, + 572, 0, 0, 2661, 2663, 3, 2404, 1202, 0, 2662, 2660, 1, 0, 0, 0, 2662, + 2663, 1, 0, 0, 0, 2663, 2664, 1, 0, 0, 0, 2664, 2665, 5, 440, 0, 0, 2665, + 2670, 3, 440, 220, 0, 2666, 2667, 5, 2453, 0, 0, 2667, 2669, 3, 440, 220, + 0, 2668, 2666, 1, 0, 0, 0, 2669, 2672, 1, 0, 0, 0, 2670, 2668, 1, 0, 0, + 0, 2670, 2671, 1, 0, 0, 0, 2671, 2674, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, + 0, 2673, 2655, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 2673, 1, 0, 0, + 0, 2675, 2676, 1, 0, 0, 0, 2676, 7, 1, 0, 0, 0, 2677, 2716, 5, 469, 0, + 0, 2678, 2680, 3, 84, 42, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, 1, 0, + 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2682, 5, 440, 0, 0, 2682, 2684, 3, + 2404, 1202, 0, 2683, 2685, 3, 38, 19, 0, 2684, 2683, 1, 0, 0, 0, 2684, + 2685, 1, 0, 0, 0, 2685, 2693, 1, 0, 0, 0, 2686, 2687, 5, 2453, 0, 0, 2687, + 2689, 3, 2404, 1202, 0, 2688, 2690, 3, 38, 19, 0, 2689, 2688, 1, 0, 0, + 0, 2689, 2690, 1, 0, 0, 0, 2690, 2692, 1, 0, 0, 0, 2691, 2686, 1, 0, 0, + 0, 2692, 2695, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, + 0, 2694, 2717, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2696, 2697, 5, 443, + 0, 0, 2697, 2699, 5, 738, 0, 0, 2698, 2700, 3, 84, 42, 0, 2699, 2698, 1, + 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2702, 5, + 572, 0, 0, 2702, 2704, 3, 2404, 1202, 0, 2703, 2705, 3, 38, 19, 0, 2704, + 2703, 1, 0, 0, 0, 2704, 2705, 1, 0, 0, 0, 2705, 2713, 1, 0, 0, 0, 2706, + 2707, 5, 2453, 0, 0, 2707, 2709, 3, 2404, 1202, 0, 2708, 2710, 3, 38, 19, + 0, 2709, 2708, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 2712, 1, 0, 0, + 0, 2711, 2706, 1, 0, 0, 0, 2712, 2715, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, + 0, 2713, 2714, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, + 0, 2716, 2679, 1, 0, 0, 0, 2716, 2696, 1, 0, 0, 0, 2717, 9, 1, 0, 0, 0, + 2718, 2719, 5, 1567, 0, 0, 2719, 2722, 5, 38, 0, 0, 2720, 2721, 5, 1699, + 0, 0, 2721, 2723, 3, 1176, 588, 0, 2722, 2720, 1, 0, 0, 0, 2722, 2723, + 1, 0, 0, 0, 2723, 11, 1, 0, 0, 0, 2724, 2725, 5, 1562, 0, 0, 2725, 2726, + 5, 440, 0, 0, 2726, 2727, 3, 2404, 1202, 0, 2727, 2728, 5, 2308, 0, 0, + 2728, 2730, 5, 2443, 0, 0, 2729, 2731, 3, 38, 19, 0, 2730, 2729, 1, 0, + 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 2741, 1, 0, 0, 0, 2732, 2733, 5, 2453, + 0, 0, 2733, 2734, 3, 2404, 1202, 0, 2734, 2735, 5, 2308, 0, 0, 2735, 2737, + 5, 2443, 0, 0, 2736, 2738, 3, 38, 19, 0, 2737, 2736, 1, 0, 0, 0, 2737, + 2738, 1, 0, 0, 0, 2738, 2740, 1, 0, 0, 0, 2739, 2732, 1, 0, 0, 0, 2740, + 2743, 1, 0, 0, 0, 2741, 2739, 1, 0, 0, 0, 2741, 2742, 1, 0, 0, 0, 2742, + 2746, 1, 0, 0, 0, 2743, 2741, 1, 0, 0, 0, 2744, 2745, 5, 1424, 0, 0, 2745, + 2747, 3, 2396, 1198, 0, 2746, 2744, 1, 0, 0, 0, 2746, 2747, 1, 0, 0, 0, + 2747, 2749, 1, 0, 0, 0, 2748, 2750, 3, 14, 7, 0, 2749, 2748, 1, 0, 0, 0, + 2749, 2750, 1, 0, 0, 0, 2750, 13, 1, 0, 0, 0, 2751, 2752, 7, 0, 0, 0, 2752, + 15, 1, 0, 0, 0, 2753, 2770, 5, 1559, 0, 0, 2754, 2755, 5, 440, 0, 0, 2755, + 2756, 3, 2404, 1202, 0, 2756, 2757, 5, 2141, 0, 0, 2757, 2765, 3, 2404, + 1202, 0, 2758, 2759, 5, 2453, 0, 0, 2759, 2760, 3, 2404, 1202, 0, 2760, + 2761, 5, 2141, 0, 0, 2761, 2762, 3, 2404, 1202, 0, 2762, 2764, 1, 0, 0, + 0, 2763, 2758, 1, 0, 0, 0, 2764, 2767, 1, 0, 0, 0, 2765, 2763, 1, 0, 0, + 0, 2765, 2766, 1, 0, 0, 0, 2766, 2771, 1, 0, 0, 0, 2767, 2765, 1, 0, 0, + 0, 2768, 2769, 5, 443, 0, 0, 2769, 2771, 5, 38, 0, 0, 2770, 2754, 1, 0, + 0, 0, 2770, 2768, 1, 0, 0, 0, 2771, 17, 1, 0, 0, 0, 2772, 2804, 5, 1256, + 0, 0, 2773, 2775, 3, 84, 42, 0, 2774, 2773, 1, 0, 0, 0, 2774, 2775, 1, + 0, 0, 0, 2775, 2776, 1, 0, 0, 0, 2776, 2777, 5, 440, 0, 0, 2777, 2782, + 3, 2404, 1202, 0, 2778, 2779, 5, 2453, 0, 0, 2779, 2781, 3, 2404, 1202, + 0, 2780, 2778, 1, 0, 0, 0, 2781, 2784, 1, 0, 0, 0, 2782, 2780, 1, 0, 0, + 0, 2782, 2783, 1, 0, 0, 0, 2783, 2800, 1, 0, 0, 0, 2784, 2782, 1, 0, 0, + 0, 2785, 2786, 5, 443, 0, 0, 2786, 2788, 5, 738, 0, 0, 2787, 2789, 3, 84, + 42, 0, 2788, 2787, 1, 0, 0, 0, 2788, 2789, 1, 0, 0, 0, 2789, 2790, 1, 0, + 0, 0, 2790, 2791, 5, 572, 0, 0, 2791, 2796, 3, 2404, 1202, 0, 2792, 2793, + 5, 2453, 0, 0, 2793, 2795, 3, 2404, 1202, 0, 2794, 2792, 1, 0, 0, 0, 2795, + 2798, 1, 0, 0, 0, 2796, 2794, 1, 0, 0, 0, 2796, 2797, 1, 0, 0, 0, 2797, + 2800, 1, 0, 0, 0, 2798, 2796, 1, 0, 0, 0, 2799, 2774, 1, 0, 0, 0, 2799, + 2785, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2801, + 2802, 1, 0, 0, 0, 2802, 2805, 1, 0, 0, 0, 2803, 2805, 5, 38, 0, 0, 2804, + 2799, 1, 0, 0, 0, 2804, 2803, 1, 0, 0, 0, 2805, 2808, 1, 0, 0, 0, 2806, + 2807, 5, 1424, 0, 0, 2807, 2809, 3, 2396, 1198, 0, 2808, 2806, 1, 0, 0, + 0, 2808, 2809, 1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2812, 3, 14, 7, + 0, 2811, 2810, 1, 0, 0, 0, 2811, 2812, 1, 0, 0, 0, 2812, 19, 1, 0, 0, 0, + 2813, 2840, 5, 1243, 0, 0, 2814, 2816, 3, 84, 42, 0, 2815, 2814, 1, 0, + 0, 0, 2815, 2816, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, 2818, 5, 440, + 0, 0, 2818, 2823, 3, 2404, 1202, 0, 2819, 2820, 5, 2453, 0, 0, 2820, 2822, + 3, 2404, 1202, 0, 2821, 2819, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, + 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2841, 1, 0, 0, 0, 2825, + 2823, 1, 0, 0, 0, 2826, 2827, 5, 443, 0, 0, 2827, 2829, 5, 738, 0, 0, 2828, + 2830, 3, 84, 42, 0, 2829, 2828, 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, + 2831, 1, 0, 0, 0, 2831, 2832, 5, 572, 0, 0, 2832, 2837, 3, 2404, 1202, + 0, 2833, 2834, 5, 2453, 0, 0, 2834, 2836, 3, 2404, 1202, 0, 2835, 2833, + 1, 0, 0, 0, 2836, 2839, 1, 0, 0, 0, 2837, 2835, 1, 0, 0, 0, 2837, 2838, + 1, 0, 0, 0, 2838, 2841, 1, 0, 0, 0, 2839, 2837, 1, 0, 0, 0, 2840, 2815, + 1, 0, 0, 0, 2840, 2826, 1, 0, 0, 0, 2841, 2843, 1, 0, 0, 0, 2842, 2844, + 3, 22, 11, 0, 2843, 2842, 1, 0, 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 21, + 1, 0, 0, 0, 2845, 2846, 5, 469, 0, 0, 2846, 2847, 5, 33, 0, 0, 2847, 2848, + 3, 2396, 1198, 0, 2848, 2849, 7, 1, 0, 0, 2849, 23, 1, 0, 0, 0, 2850, 2870, + 5, 1510, 0, 0, 2851, 2853, 7, 2, 0, 0, 2852, 2854, 3, 26, 13, 0, 2853, + 2852, 1, 0, 0, 0, 2854, 2855, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, + 2856, 1, 0, 0, 0, 2856, 2858, 1, 0, 0, 0, 2857, 2851, 1, 0, 0, 0, 2857, + 2858, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859, 2860, 5, 1424, 0, 0, 2860, + 2861, 3, 2396, 1198, 0, 2861, 2863, 1, 0, 0, 0, 2862, 2864, 7, 0, 0, 0, + 2863, 2862, 1, 0, 0, 0, 2863, 2864, 1, 0, 0, 0, 2864, 2871, 1, 0, 0, 0, + 2865, 2866, 5, 980, 0, 0, 2866, 2868, 5, 1424, 0, 0, 2867, 2869, 3, 2396, + 1198, 0, 2868, 2867, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2871, 1, + 0, 0, 0, 2870, 2857, 1, 0, 0, 0, 2870, 2865, 1, 0, 0, 0, 2871, 25, 1, 0, + 0, 0, 2872, 2873, 3, 2404, 1202, 0, 2873, 27, 1, 0, 0, 0, 2874, 2876, 5, + 200, 0, 0, 2875, 2877, 5, 38, 0, 0, 2876, 2875, 1, 0, 0, 0, 2876, 2877, + 1, 0, 0, 0, 2877, 2879, 1, 0, 0, 0, 2878, 2880, 7, 3, 0, 0, 2879, 2878, + 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 29, 1, 0, 0, 0, 2881, 2882, 7, + 4, 0, 0, 2882, 2883, 5, 2090, 0, 0, 2883, 2884, 3, 2404, 1202, 0, 2884, + 2891, 3, 32, 16, 0, 2885, 2886, 5, 2453, 0, 0, 2886, 2887, 3, 2404, 1202, + 0, 2887, 2888, 3, 32, 16, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2885, 1, 0, + 0, 0, 2890, 2893, 1, 0, 0, 0, 2891, 2889, 1, 0, 0, 0, 2891, 2892, 1, 0, + 0, 0, 2892, 2905, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2894, 2895, 5, 469, + 0, 0, 2895, 2896, 5, 2090, 0, 0, 2896, 2901, 3, 2404, 1202, 0, 2897, 2898, + 5, 2453, 0, 0, 2898, 2900, 3, 2404, 1202, 0, 2899, 2897, 1, 0, 0, 0, 2900, + 2903, 1, 0, 0, 0, 2901, 2899, 1, 0, 0, 0, 2901, 2902, 1, 0, 0, 0, 2902, + 2905, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2904, 2881, 1, 0, 0, 0, 2904, + 2894, 1, 0, 0, 0, 2905, 31, 1, 0, 0, 0, 2906, 2907, 5, 84, 0, 0, 2907, + 2909, 5, 2447, 0, 0, 2908, 2910, 3, 34, 17, 0, 2909, 2908, 1, 0, 0, 0, + 2909, 2910, 1, 0, 0, 0, 2910, 2912, 1, 0, 0, 0, 2911, 2913, 3, 36, 18, + 0, 2912, 2911, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2914, 1, 0, 0, + 0, 2914, 2915, 5, 2448, 0, 0, 2915, 33, 1, 0, 0, 0, 2916, 2917, 7, 5, 0, + 0, 2917, 35, 1, 0, 0, 0, 2918, 2919, 7, 6, 0, 0, 2919, 37, 1, 0, 0, 0, + 2920, 2921, 7, 7, 0, 0, 2921, 39, 1, 0, 0, 0, 2922, 2923, 5, 21, 0, 0, + 2923, 2924, 5, 426, 0, 0, 2924, 2929, 3, 1458, 729, 0, 2925, 2926, 5, 2453, + 0, 0, 2926, 2928, 3, 1458, 729, 0, 2927, 2925, 1, 0, 0, 0, 2928, 2931, + 1, 0, 0, 0, 2929, 2927, 1, 0, 0, 0, 2929, 2930, 1, 0, 0, 0, 2930, 2964, + 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2932, 2933, 5, 469, 0, 0, 2933, 2934, + 5, 426, 0, 0, 2934, 2936, 3, 1458, 729, 0, 2935, 2937, 3, 38, 19, 0, 2936, + 2935, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2945, 1, 0, 0, 0, 2938, + 2939, 5, 2453, 0, 0, 2939, 2941, 3, 1458, 729, 0, 2940, 2942, 3, 38, 19, + 0, 2941, 2940, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2944, 1, 0, 0, + 0, 2943, 2938, 1, 0, 0, 0, 2944, 2947, 1, 0, 0, 0, 2945, 2943, 1, 0, 0, + 0, 2945, 2946, 1, 0, 0, 0, 2946, 2964, 1, 0, 0, 0, 2947, 2945, 1, 0, 0, + 0, 2948, 2949, 5, 1559, 0, 0, 2949, 2950, 5, 426, 0, 0, 2950, 2951, 3, + 42, 21, 0, 2951, 2952, 5, 2141, 0, 0, 2952, 2960, 3, 42, 21, 0, 2953, 2954, + 5, 2453, 0, 0, 2954, 2955, 3, 42, 21, 0, 2955, 2956, 5, 2141, 0, 0, 2956, + 2957, 3, 42, 21, 0, 2957, 2959, 1, 0, 0, 0, 2958, 2953, 1, 0, 0, 0, 2959, + 2962, 1, 0, 0, 0, 2960, 2958, 1, 0, 0, 0, 2960, 2961, 1, 0, 0, 0, 2961, + 2964, 1, 0, 0, 0, 2962, 2960, 1, 0, 0, 0, 2963, 2922, 1, 0, 0, 0, 2963, + 2932, 1, 0, 0, 0, 2963, 2948, 1, 0, 0, 0, 2964, 41, 1, 0, 0, 0, 2965, 2966, + 5, 2443, 0, 0, 2966, 43, 1, 0, 0, 0, 2967, 2968, 5, 21, 0, 0, 2968, 2969, + 5, 37, 0, 0, 2969, 2970, 5, 2443, 0, 0, 2970, 2971, 5, 620, 0, 0, 2971, + 2978, 5, 2443, 0, 0, 2972, 2973, 5, 2453, 0, 0, 2973, 2974, 5, 2443, 0, + 0, 2974, 2975, 5, 620, 0, 0, 2975, 2977, 5, 2443, 0, 0, 2976, 2972, 1, + 0, 0, 0, 2977, 2980, 1, 0, 0, 0, 2978, 2976, 1, 0, 0, 0, 2978, 2979, 1, + 0, 0, 0, 2979, 3006, 1, 0, 0, 0, 2980, 2978, 1, 0, 0, 0, 2981, 2982, 5, + 469, 0, 0, 2982, 2983, 5, 37, 0, 0, 2983, 2988, 5, 2443, 0, 0, 2984, 2985, + 5, 2453, 0, 0, 2985, 2987, 5, 2443, 0, 0, 2986, 2984, 1, 0, 0, 0, 2987, + 2990, 1, 0, 0, 0, 2988, 2986, 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, + 3006, 1, 0, 0, 0, 2990, 2988, 1, 0, 0, 0, 2991, 2992, 5, 1559, 0, 0, 2992, + 2993, 5, 37, 0, 0, 2993, 2994, 5, 2443, 0, 0, 2994, 2995, 5, 2141, 0, 0, + 2995, 3002, 5, 2443, 0, 0, 2996, 2997, 5, 2453, 0, 0, 2997, 2998, 5, 2443, + 0, 0, 2998, 2999, 5, 2141, 0, 0, 2999, 3001, 5, 2443, 0, 0, 3000, 2996, + 1, 0, 0, 0, 3001, 3004, 1, 0, 0, 0, 3002, 3000, 1, 0, 0, 0, 3002, 3003, + 1, 0, 0, 0, 3003, 3006, 1, 0, 0, 0, 3004, 3002, 1, 0, 0, 0, 3005, 2967, + 1, 0, 0, 0, 3005, 2981, 1, 0, 0, 0, 3005, 2991, 1, 0, 0, 0, 3006, 45, 1, + 0, 0, 0, 3007, 3019, 3, 48, 24, 0, 3008, 3019, 3, 50, 25, 0, 3009, 3010, + 5, 1567, 0, 0, 3010, 3011, 5, 2291, 0, 0, 3011, 3012, 3, 2404, 1202, 0, + 3012, 3013, 5, 1699, 0, 0, 3013, 3014, 3, 1176, 588, 0, 3014, 3019, 1, + 0, 0, 0, 3015, 3016, 5, 469, 0, 0, 3016, 3017, 5, 2291, 0, 0, 3017, 3019, + 3, 2404, 1202, 0, 3018, 3007, 1, 0, 0, 0, 3018, 3008, 1, 0, 0, 0, 3018, + 3009, 1, 0, 0, 0, 3018, 3015, 1, 0, 0, 0, 3019, 47, 1, 0, 0, 0, 3020, 3021, + 5, 21, 0, 0, 3021, 3022, 5, 2291, 0, 0, 3022, 3023, 3, 2404, 1202, 0, 3023, + 3024, 5, 1699, 0, 0, 3024, 3026, 3, 1176, 588, 0, 3025, 3027, 3, 34, 17, + 0, 3026, 3025, 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 3032, 1, 0, 0, + 0, 3028, 3029, 5, 1769, 0, 0, 3029, 3030, 3, 2396, 1198, 0, 3030, 3031, + 7, 8, 0, 0, 3031, 3033, 1, 0, 0, 0, 3032, 3028, 1, 0, 0, 0, 3032, 3033, + 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3035, 5, 1768, 0, 0, 3035, 3037, + 3, 2396, 1198, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, + 49, 1, 0, 0, 0, 3038, 3039, 5, 980, 0, 0, 3039, 3040, 5, 2291, 0, 0, 3040, + 3043, 3, 2404, 1202, 0, 3041, 3042, 5, 989, 0, 0, 3042, 3044, 5, 2443, + 0, 0, 3043, 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3047, 1, 0, + 0, 0, 3045, 3046, 5, 2216, 0, 0, 3046, 3048, 5, 2443, 0, 0, 3047, 3045, + 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 51, 1, 0, 0, 0, 3049, 3050, 5, + 1671, 0, 0, 3050, 3051, 5, 83, 0, 0, 3051, 3052, 5, 2443, 0, 0, 3052, 3053, + 5, 2472, 0, 0, 3053, 3054, 5, 2443, 0, 0, 3054, 53, 1, 0, 0, 0, 3055, 3056, + 5, 469, 0, 0, 3056, 3057, 5, 589, 0, 0, 3057, 3062, 3, 1458, 729, 0, 3058, + 3059, 5, 2453, 0, 0, 3059, 3061, 3, 1458, 729, 0, 3060, 3058, 1, 0, 0, + 0, 3061, 3064, 1, 0, 0, 0, 3062, 3060, 1, 0, 0, 0, 3062, 3063, 1, 0, 0, + 0, 3063, 55, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3065, 3066, 5, 300, 0, + 0, 3066, 3067, 5, 1524, 0, 0, 3067, 3068, 5, 2141, 0, 0, 3068, 3069, 5, + 609, 0, 0, 3069, 57, 1, 0, 0, 0, 3070, 3071, 5, 21, 0, 0, 3071, 3072, 5, + 2233, 0, 0, 3072, 3073, 5, 2443, 0, 0, 3073, 3074, 5, 2308, 0, 0, 3074, + 3075, 5, 936, 0, 0, 3075, 3080, 5, 2443, 0, 0, 3076, 3077, 5, 2453, 0, + 0, 3077, 3079, 5, 2443, 0, 0, 3078, 3076, 1, 0, 0, 0, 3079, 3082, 1, 0, + 0, 0, 3080, 3078, 1, 0, 0, 0, 3080, 3081, 1, 0, 0, 0, 3081, 3100, 1, 0, + 0, 0, 3082, 3080, 1, 0, 0, 0, 3083, 3084, 5, 980, 0, 0, 3084, 3085, 5, + 2233, 0, 0, 3085, 3086, 5, 2443, 0, 0, 3086, 3087, 7, 9, 0, 0, 3087, 3088, + 5, 936, 0, 0, 3088, 3093, 5, 2443, 0, 0, 3089, 3090, 5, 2453, 0, 0, 3090, + 3092, 5, 2443, 0, 0, 3091, 3089, 1, 0, 0, 0, 3092, 3095, 1, 0, 0, 0, 3093, + 3091, 1, 0, 0, 0, 3093, 3094, 1, 0, 0, 0, 3094, 3100, 1, 0, 0, 0, 3095, + 3093, 1, 0, 0, 0, 3096, 3097, 5, 469, 0, 0, 3097, 3098, 5, 2233, 0, 0, + 3098, 3100, 5, 2443, 0, 0, 3099, 3070, 1, 0, 0, 0, 3099, 3083, 1, 0, 0, + 0, 3099, 3096, 1, 0, 0, 0, 3100, 59, 1, 0, 0, 0, 3101, 3102, 5, 21, 0, + 0, 3102, 3103, 5, 2237, 0, 0, 3103, 3108, 5, 2443, 0, 0, 3104, 3105, 5, + 2453, 0, 0, 3105, 3107, 5, 2443, 0, 0, 3106, 3104, 1, 0, 0, 0, 3107, 3110, + 1, 0, 0, 0, 3108, 3106, 1, 0, 0, 0, 3108, 3109, 1, 0, 0, 0, 3109, 3139, + 1, 0, 0, 0, 3110, 3108, 1, 0, 0, 0, 3111, 3112, 5, 469, 0, 0, 3112, 3113, + 5, 2237, 0, 0, 3113, 3118, 5, 2443, 0, 0, 3114, 3115, 5, 2453, 0, 0, 3115, + 3117, 5, 2443, 0, 0, 3116, 3114, 1, 0, 0, 0, 3117, 3120, 1, 0, 0, 0, 3118, + 3116, 1, 0, 0, 0, 3118, 3119, 1, 0, 0, 0, 3119, 3122, 1, 0, 0, 0, 3120, + 3118, 1, 0, 0, 0, 3121, 3123, 5, 179, 0, 0, 3122, 3121, 1, 0, 0, 0, 3122, + 3123, 1, 0, 0, 0, 3123, 3139, 1, 0, 0, 0, 3124, 3125, 5, 1562, 0, 0, 3125, + 3126, 5, 2237, 0, 0, 3126, 3127, 5, 2443, 0, 0, 3127, 3128, 5, 2308, 0, + 0, 3128, 3135, 5, 2443, 0, 0, 3129, 3130, 5, 2453, 0, 0, 3130, 3131, 5, + 2443, 0, 0, 3131, 3132, 5, 2308, 0, 0, 3132, 3134, 5, 2443, 0, 0, 3133, + 3129, 1, 0, 0, 0, 3134, 3137, 1, 0, 0, 0, 3135, 3133, 1, 0, 0, 0, 3135, + 3136, 1, 0, 0, 0, 3136, 3139, 1, 0, 0, 0, 3137, 3135, 1, 0, 0, 0, 3138, + 3101, 1, 0, 0, 0, 3138, 3111, 1, 0, 0, 0, 3138, 3124, 1, 0, 0, 0, 3139, + 61, 1, 0, 0, 0, 3140, 3141, 5, 1671, 0, 0, 3141, 3142, 5, 1388, 0, 0, 3142, + 3143, 7, 10, 0, 0, 3143, 3147, 5, 2472, 0, 0, 3144, 3148, 5, 1133, 0, 0, + 3145, 3146, 5, 1505, 0, 0, 3146, 3148, 7, 11, 0, 0, 3147, 3144, 1, 0, 0, + 0, 3147, 3145, 1, 0, 0, 0, 3148, 3159, 1, 0, 0, 0, 3149, 3150, 5, 2453, + 0, 0, 3150, 3151, 7, 10, 0, 0, 3151, 3155, 5, 2472, 0, 0, 3152, 3156, 5, + 1133, 0, 0, 3153, 3154, 5, 1505, 0, 0, 3154, 3156, 7, 11, 0, 0, 3155, 3152, + 1, 0, 0, 0, 3155, 3153, 1, 0, 0, 0, 3156, 3158, 1, 0, 0, 0, 3157, 3149, + 1, 0, 0, 0, 3158, 3161, 1, 0, 0, 0, 3159, 3157, 1, 0, 0, 0, 3159, 3160, + 1, 0, 0, 0, 3160, 3162, 1, 0, 0, 0, 3161, 3159, 1, 0, 0, 0, 3162, 3163, + 5, 620, 0, 0, 3163, 3164, 5, 589, 0, 0, 3164, 3169, 5, 2443, 0, 0, 3165, + 3166, 5, 2453, 0, 0, 3166, 3168, 5, 2443, 0, 0, 3167, 3165, 1, 0, 0, 0, + 3168, 3171, 1, 0, 0, 0, 3169, 3167, 1, 0, 0, 0, 3169, 3170, 1, 0, 0, 0, + 3170, 63, 1, 0, 0, 0, 3171, 3169, 1, 0, 0, 0, 3172, 3173, 5, 1671, 0, 0, + 3173, 3174, 5, 1326, 0, 0, 3174, 3175, 7, 12, 0, 0, 3175, 3176, 5, 2472, + 0, 0, 3176, 3183, 5, 2443, 0, 0, 3177, 3178, 5, 2453, 0, 0, 3178, 3179, + 7, 12, 0, 0, 3179, 3180, 5, 2472, 0, 0, 3180, 3182, 5, 2443, 0, 0, 3181, + 3177, 1, 0, 0, 0, 3182, 3185, 1, 0, 0, 0, 3183, 3181, 1, 0, 0, 0, 3183, + 3184, 1, 0, 0, 0, 3184, 3186, 1, 0, 0, 0, 3185, 3183, 1, 0, 0, 0, 3186, + 3187, 5, 620, 0, 0, 3187, 3188, 5, 589, 0, 0, 3188, 3193, 5, 2443, 0, 0, + 3189, 3190, 5, 2453, 0, 0, 3190, 3192, 5, 2443, 0, 0, 3191, 3189, 1, 0, + 0, 0, 3192, 3195, 1, 0, 0, 0, 3193, 3191, 1, 0, 0, 0, 3193, 3194, 1, 0, + 0, 0, 3194, 65, 1, 0, 0, 0, 3195, 3193, 1, 0, 0, 0, 3196, 3201, 5, 1629, + 0, 0, 3197, 3198, 5, 589, 0, 0, 3198, 3202, 5, 2443, 0, 0, 3199, 3200, + 5, 440, 0, 0, 3200, 3202, 3, 2404, 1202, 0, 3201, 3197, 1, 0, 0, 0, 3201, + 3199, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202, 3204, 1, 0, 0, 0, 3203, + 3205, 7, 3, 0, 0, 3204, 3203, 1, 0, 0, 0, 3204, 3205, 1, 0, 0, 0, 3205, + 3208, 1, 0, 0, 0, 3206, 3207, 5, 1424, 0, 0, 3207, 3209, 7, 13, 0, 0, 3208, + 3206, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, 3211, 1, 0, 0, 0, 3210, + 3212, 3, 14, 7, 0, 3211, 3210, 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, + 3214, 1, 0, 0, 0, 3213, 3215, 3, 38, 19, 0, 3214, 3213, 1, 0, 0, 0, 3214, + 3215, 1, 0, 0, 0, 3215, 3217, 1, 0, 0, 0, 3216, 3218, 5, 1761, 0, 0, 3217, + 3216, 1, 0, 0, 0, 3217, 3218, 1, 0, 0, 0, 3218, 67, 1, 0, 0, 0, 3219, 3220, + 5, 21, 0, 0, 3220, 3221, 5, 1491, 0, 0, 3221, 3227, 3, 2404, 1202, 0, 3222, + 3223, 5, 1671, 0, 0, 3223, 3224, 3, 70, 35, 0, 3224, 3225, 5, 2472, 0, + 0, 3225, 3226, 3, 72, 36, 0, 3226, 3228, 1, 0, 0, 0, 3227, 3222, 1, 0, + 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 3247, 1, 0, 0, 0, 3229, 3230, 5, 980, + 0, 0, 3230, 3231, 5, 1491, 0, 0, 3231, 3232, 3, 2404, 1202, 0, 3232, 3233, + 5, 1671, 0, 0, 3233, 3234, 3, 70, 35, 0, 3234, 3235, 5, 2472, 0, 0, 3235, + 3236, 3, 72, 36, 0, 3236, 3247, 1, 0, 0, 0, 3237, 3238, 5, 992, 0, 0, 3238, + 3239, 5, 1491, 0, 0, 3239, 3240, 3, 2404, 1202, 0, 3240, 3241, 5, 2141, + 0, 0, 3241, 3242, 3, 2404, 1202, 0, 3242, 3247, 1, 0, 0, 0, 3243, 3244, + 5, 469, 0, 0, 3244, 3245, 5, 1491, 0, 0, 3245, 3247, 3, 2404, 1202, 0, + 3246, 3219, 1, 0, 0, 0, 3246, 3229, 1, 0, 0, 0, 3246, 3237, 1, 0, 0, 0, + 3246, 3243, 1, 0, 0, 0, 3247, 69, 1, 0, 0, 0, 3248, 3249, 3, 2404, 1202, + 0, 3249, 71, 1, 0, 0, 0, 3250, 3251, 3, 2404, 1202, 0, 3251, 73, 1, 0, + 0, 0, 3252, 3257, 3, 76, 38, 0, 3253, 3257, 3, 78, 39, 0, 3254, 3257, 3, + 80, 40, 0, 3255, 3257, 3, 82, 41, 0, 3256, 3252, 1, 0, 0, 0, 3256, 3253, + 1, 0, 0, 0, 3256, 3254, 1, 0, 0, 0, 3256, 3255, 1, 0, 0, 0, 3257, 75, 1, + 0, 0, 0, 3258, 3259, 5, 21, 0, 0, 3259, 3260, 5, 591, 0, 0, 3260, 3264, + 3, 2404, 1202, 0, 3261, 3262, 7, 14, 0, 0, 3262, 3265, 3, 2404, 1202, 0, + 3263, 3265, 5, 2090, 0, 0, 3264, 3261, 1, 0, 0, 0, 3264, 3263, 1, 0, 0, + 0, 3265, 3269, 1, 0, 0, 0, 3266, 3267, 5, 628, 0, 0, 3267, 3268, 5, 2090, + 0, 0, 3268, 3270, 3, 2404, 1202, 0, 3269, 3266, 1, 0, 0, 0, 3269, 3270, + 1, 0, 0, 0, 3270, 3275, 1, 0, 0, 0, 3271, 3272, 5, 1671, 0, 0, 3272, 3273, + 5, 2443, 0, 0, 3273, 3274, 5, 2472, 0, 0, 3274, 3276, 5, 2443, 0, 0, 3275, + 3271, 1, 0, 0, 0, 3275, 3276, 1, 0, 0, 0, 3276, 77, 1, 0, 0, 0, 3277, 3278, + 5, 980, 0, 0, 3278, 3279, 5, 591, 0, 0, 3279, 3280, 3, 2404, 1202, 0, 3280, + 3281, 5, 1671, 0, 0, 3281, 3282, 5, 2443, 0, 0, 3282, 3283, 5, 2472, 0, + 0, 3283, 3284, 5, 2443, 0, 0, 3284, 79, 1, 0, 0, 0, 3285, 3286, 5, 992, + 0, 0, 3286, 3287, 5, 589, 0, 0, 3287, 3288, 5, 2443, 0, 0, 3288, 3289, + 5, 2141, 0, 0, 3289, 3290, 5, 591, 0, 0, 3290, 3291, 3, 2404, 1202, 0, + 3291, 81, 1, 0, 0, 0, 3292, 3293, 5, 469, 0, 0, 3293, 3294, 5, 591, 0, + 0, 3294, 3296, 3, 2404, 1202, 0, 3295, 3297, 5, 179, 0, 0, 3296, 3295, + 1, 0, 0, 0, 3296, 3297, 1, 0, 0, 0, 3297, 83, 1, 0, 0, 0, 3298, 3299, 7, + 15, 0, 0, 3299, 85, 1, 0, 0, 0, 3300, 3301, 5, 2179, 0, 0, 3301, 3302, + 5, 443, 0, 0, 3302, 87, 1, 0, 0, 0, 3303, 3305, 5, 988, 0, 0, 3304, 3306, + 7, 16, 0, 0, 3305, 3304, 1, 0, 0, 0, 3305, 3306, 1, 0, 0, 0, 3306, 3308, + 1, 0, 0, 0, 3307, 3309, 7, 7, 0, 0, 3308, 3307, 1, 0, 0, 0, 3308, 3309, + 1, 0, 0, 0, 3309, 3315, 1, 0, 0, 0, 3310, 3312, 5, 444, 0, 0, 3311, 3313, + 7, 7, 0, 0, 3312, 3311, 1, 0, 0, 0, 3312, 3313, 1, 0, 0, 0, 3313, 3315, + 1, 0, 0, 0, 3314, 3303, 1, 0, 0, 0, 3314, 3310, 1, 0, 0, 0, 3315, 89, 1, + 0, 0, 0, 3316, 3317, 7, 17, 0, 0, 3317, 3327, 5, 2291, 0, 0, 3318, 3323, + 3, 2404, 1202, 0, 3319, 3320, 5, 2453, 0, 0, 3320, 3322, 3, 2404, 1202, + 0, 3321, 3319, 1, 0, 0, 0, 3322, 3325, 1, 0, 0, 0, 3323, 3321, 1, 0, 0, + 0, 3323, 3324, 1, 0, 0, 0, 3324, 3328, 1, 0, 0, 0, 3325, 3323, 1, 0, 0, + 0, 3326, 3328, 5, 38, 0, 0, 3327, 3318, 1, 0, 0, 0, 3327, 3326, 1, 0, 0, + 0, 3328, 91, 1, 0, 0, 0, 3329, 3330, 5, 469, 0, 0, 3330, 3331, 5, 632, + 0, 0, 3331, 3332, 3, 2320, 1160, 0, 3332, 93, 1, 0, 0, 0, 3333, 3334, 5, + 42, 0, 0, 3334, 3335, 5, 605, 0, 0, 3335, 3336, 5, 64, 0, 0, 3336, 3366, + 3, 2404, 1202, 0, 3337, 3338, 5, 1671, 0, 0, 3338, 3367, 5, 389, 0, 0, + 3339, 3340, 7, 4, 0, 0, 3340, 3341, 5, 2080, 0, 0, 3341, 3343, 3, 2404, + 1202, 0, 3342, 3344, 3, 446, 223, 0, 3343, 3342, 1, 0, 0, 0, 3343, 3344, + 1, 0, 0, 0, 3344, 3367, 1, 0, 0, 0, 3345, 3346, 5, 1558, 0, 0, 3346, 3347, + 5, 2080, 0, 0, 3347, 3367, 3, 2404, 1202, 0, 3348, 3349, 5, 980, 0, 0, + 3349, 3367, 3, 448, 224, 0, 3350, 3359, 5, 1475, 0, 0, 3351, 3360, 5, 38, + 0, 0, 3352, 3357, 5, 112, 0, 0, 3353, 3354, 5, 1627, 0, 0, 3354, 3358, + 3, 2078, 1039, 0, 3355, 3356, 5, 2108, 0, 0, 3356, 3358, 3, 2078, 1039, + 0, 3357, 3353, 1, 0, 0, 0, 3357, 3355, 1, 0, 0, 0, 3358, 3360, 1, 0, 0, + 0, 3359, 3351, 1, 0, 0, 0, 3359, 3352, 1, 0, 0, 0, 3360, 3367, 1, 0, 0, + 0, 3361, 3363, 5, 1137, 0, 0, 3362, 3361, 1, 0, 0, 0, 3362, 3363, 1, 0, + 0, 0, 3363, 3364, 1, 0, 0, 0, 3364, 3365, 5, 1269, 0, 0, 3365, 3367, 5, + 351, 0, 0, 3366, 3337, 1, 0, 0, 0, 3366, 3339, 1, 0, 0, 0, 3366, 3345, + 1, 0, 0, 0, 3366, 3348, 1, 0, 0, 0, 3366, 3350, 1, 0, 0, 0, 3366, 3362, + 1, 0, 0, 0, 3367, 95, 1, 0, 0, 0, 3368, 3369, 5, 42, 0, 0, 3369, 3373, + 5, 674, 0, 0, 3370, 3371, 3, 2286, 1143, 0, 3371, 3372, 5, 2440, 0, 0, + 3372, 3374, 1, 0, 0, 0, 3373, 3370, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, + 3374, 3375, 1, 0, 0, 0, 3375, 3380, 3, 2404, 1202, 0, 3376, 3377, 5, 1559, + 0, 0, 3377, 3378, 5, 2141, 0, 0, 3378, 3381, 3, 2404, 1202, 0, 3379, 3381, + 5, 249, 0, 0, 3380, 3376, 1, 0, 0, 0, 3380, 3379, 1, 0, 0, 0, 3381, 97, + 1, 0, 0, 0, 3382, 3383, 5, 42, 0, 0, 3383, 3384, 5, 632, 0, 0, 3384, 3401, + 3, 2320, 1160, 0, 3385, 3402, 5, 482, 0, 0, 3386, 3402, 5, 1132, 0, 0, + 3387, 3389, 5, 249, 0, 0, 3388, 3390, 5, 378, 0, 0, 3389, 3388, 1, 0, 0, + 0, 3389, 3390, 1, 0, 0, 0, 3390, 3394, 1, 0, 0, 0, 3391, 3393, 3, 812, + 406, 0, 3392, 3391, 1, 0, 0, 0, 3393, 3396, 1, 0, 0, 0, 3394, 3392, 1, + 0, 0, 0, 3394, 3395, 1, 0, 0, 0, 3395, 3399, 1, 0, 0, 0, 3396, 3394, 1, + 0, 0, 0, 3397, 3398, 5, 1587, 0, 0, 3398, 3400, 5, 1673, 0, 0, 3399, 3397, + 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 3402, 1, 0, 0, 0, 3401, 3385, + 1, 0, 0, 0, 3401, 3386, 1, 0, 0, 0, 3401, 3387, 1, 0, 0, 0, 3402, 99, 1, + 0, 0, 0, 3403, 3404, 5, 42, 0, 0, 3404, 3405, 5, 792, 0, 0, 3405, 3409, + 7, 18, 0, 0, 3406, 3407, 3, 2286, 1143, 0, 3407, 3408, 5, 2440, 0, 0, 3408, + 3410, 1, 0, 0, 0, 3409, 3406, 1, 0, 0, 0, 3409, 3410, 1, 0, 0, 0, 3410, + 3411, 1, 0, 0, 0, 3411, 3431, 3, 2404, 1202, 0, 3412, 3413, 5, 1569, 0, + 0, 3413, 3425, 5, 2447, 0, 0, 3414, 3415, 5, 2447, 0, 0, 3415, 3417, 3, + 102, 51, 0, 3416, 3418, 5, 2453, 0, 0, 3417, 3416, 1, 0, 0, 0, 3417, 3418, + 1, 0, 0, 0, 3418, 3421, 1, 0, 0, 0, 3419, 3422, 3, 2286, 1143, 0, 3420, + 3422, 5, 2452, 0, 0, 3421, 3419, 1, 0, 0, 0, 3421, 3420, 1, 0, 0, 0, 3422, + 3423, 1, 0, 0, 0, 3423, 3424, 5, 2448, 0, 0, 3424, 3426, 1, 0, 0, 0, 3425, + 3414, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3427, + 3428, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3430, 5, 2448, 0, 0, 3430, + 3432, 1, 0, 0, 0, 3431, 3412, 1, 0, 0, 0, 3431, 3432, 1, 0, 0, 0, 3432, + 3436, 1, 0, 0, 0, 3433, 3437, 5, 249, 0, 0, 3434, 3437, 5, 1568, 0, 0, + 3435, 3437, 3, 1720, 860, 0, 3436, 3433, 1, 0, 0, 0, 3436, 3434, 1, 0, + 0, 0, 3436, 3435, 1, 0, 0, 0, 3437, 101, 1, 0, 0, 0, 3438, 3439, 7, 19, + 0, 0, 3439, 103, 1, 0, 0, 0, 3440, 3443, 5, 321, 0, 0, 3441, 3442, 5, 1307, + 0, 0, 3442, 3444, 5, 1562, 0, 0, 3443, 3441, 1, 0, 0, 0, 3443, 3444, 1, + 0, 0, 0, 3444, 3446, 1, 0, 0, 0, 3445, 3447, 7, 20, 0, 0, 3446, 3445, 1, + 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3448, 1, 0, 0, 0, 3448, 3449, 5, + 632, 0, 0, 3449, 3461, 3, 2320, 1160, 0, 3450, 3451, 5, 2447, 0, 0, 3451, + 3456, 3, 1736, 868, 0, 3452, 3453, 5, 2453, 0, 0, 3453, 3455, 3, 1736, + 868, 0, 3454, 3452, 1, 0, 0, 0, 3455, 3458, 1, 0, 0, 0, 3456, 3454, 1, + 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 1, 0, 0, 0, 3458, 3456, 1, + 0, 0, 0, 3459, 3460, 5, 2448, 0, 0, 3460, 3462, 1, 0, 0, 0, 3461, 3450, + 1, 0, 0, 0, 3461, 3462, 1, 0, 0, 0, 3462, 3463, 1, 0, 0, 0, 3463, 3464, + 5, 1586, 0, 0, 3464, 3468, 3, 2374, 1187, 0, 3465, 3466, 5, 1681, 0, 0, + 3466, 3467, 5, 2472, 0, 0, 3467, 3469, 7, 21, 0, 0, 3468, 3465, 1, 0, 0, + 0, 3468, 3469, 1, 0, 0, 0, 3469, 3479, 1, 0, 0, 0, 3470, 3478, 3, 1720, + 860, 0, 3471, 3478, 3, 114, 57, 0, 3472, 3478, 3, 116, 58, 0, 3473, 3478, + 3, 108, 54, 0, 3474, 3478, 3, 112, 56, 0, 3475, 3478, 5, 1394, 0, 0, 3476, + 3478, 5, 420, 0, 0, 3477, 3470, 1, 0, 0, 0, 3477, 3471, 1, 0, 0, 0, 3477, + 3472, 1, 0, 0, 0, 3477, 3473, 1, 0, 0, 0, 3477, 3474, 1, 0, 0, 0, 3477, + 3475, 1, 0, 0, 0, 3477, 3476, 1, 0, 0, 0, 3478, 3481, 1, 0, 0, 0, 3479, + 3477, 1, 0, 0, 0, 3479, 3480, 1, 0, 0, 0, 3480, 3496, 1, 0, 0, 0, 3481, + 3479, 1, 0, 0, 0, 3482, 3491, 7, 22, 0, 0, 3483, 3485, 5, 382, 0, 0, 3484, + 3483, 1, 0, 0, 0, 3484, 3485, 1, 0, 0, 0, 3485, 3487, 1, 0, 0, 0, 3486, + 3488, 3, 1740, 870, 0, 3487, 3486, 1, 0, 0, 0, 3487, 3488, 1, 0, 0, 0, + 3488, 3489, 1, 0, 0, 0, 3489, 3492, 3, 1820, 910, 0, 3490, 3492, 3, 1722, + 861, 0, 3491, 3484, 1, 0, 0, 0, 3491, 3490, 1, 0, 0, 0, 3492, 3497, 1, + 0, 0, 0, 3493, 3497, 3, 118, 59, 0, 3494, 3497, 3, 120, 60, 0, 3495, 3497, + 3, 106, 53, 0, 3496, 3482, 1, 0, 0, 0, 3496, 3493, 1, 0, 0, 0, 3496, 3494, + 1, 0, 0, 0, 3496, 3495, 1, 0, 0, 0, 3497, 105, 1, 0, 0, 0, 3498, 3499, + 5, 1724, 0, 0, 3499, 3500, 5, 785, 0, 0, 3500, 3501, 5, 113, 0, 0, 3501, + 3502, 5, 1586, 0, 0, 3502, 3503, 3, 2400, 1200, 0, 3503, 3504, 5, 2470, + 0, 0, 3504, 3505, 5, 508, 0, 0, 3505, 107, 1, 0, 0, 0, 3506, 3508, 5, 1331, + 0, 0, 3507, 3509, 3, 110, 55, 0, 3508, 3507, 1, 0, 0, 0, 3508, 3509, 1, + 0, 0, 0, 3509, 109, 1, 0, 0, 0, 3510, 3511, 5, 2447, 0, 0, 3511, 3512, + 5, 1348, 0, 0, 3512, 3513, 3, 2078, 1039, 0, 3513, 3517, 5, 160, 0, 0, + 3514, 3518, 5, 55, 0, 0, 3515, 3516, 7, 23, 0, 0, 3516, 3518, 3, 2360, + 1180, 0, 3517, 3514, 1, 0, 0, 0, 3517, 3515, 1, 0, 0, 0, 3518, 3520, 1, + 0, 0, 0, 3519, 3521, 3, 126, 63, 0, 3520, 3519, 1, 0, 0, 0, 3520, 3521, + 1, 0, 0, 0, 3521, 3522, 1, 0, 0, 0, 3522, 3523, 5, 2448, 0, 0, 3523, 111, + 1, 0, 0, 0, 3524, 3526, 5, 1579, 0, 0, 3525, 3527, 3, 124, 62, 0, 3526, + 3525, 1, 0, 0, 0, 3526, 3527, 1, 0, 0, 0, 3527, 3532, 1, 0, 0, 0, 3528, + 3529, 5, 2447, 0, 0, 3529, 3530, 5, 977, 0, 0, 3530, 3531, 7, 24, 0, 0, + 3531, 3533, 5, 2448, 0, 0, 3532, 3528, 1, 0, 0, 0, 3532, 3533, 1, 0, 0, + 0, 3533, 113, 1, 0, 0, 0, 3534, 3535, 5, 6, 0, 0, 3535, 3536, 5, 160, 0, + 0, 3536, 3537, 5, 2447, 0, 0, 3537, 3542, 3, 122, 61, 0, 3538, 3539, 5, + 2453, 0, 0, 3539, 3541, 3, 122, 61, 0, 3540, 3538, 1, 0, 0, 0, 3541, 3544, + 1, 0, 0, 0, 3542, 3540, 1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3545, + 1, 0, 0, 0, 3544, 3542, 1, 0, 0, 0, 3545, 3546, 5, 2448, 0, 0, 3546, 115, + 1, 0, 0, 0, 3547, 3548, 5, 389, 0, 0, 3548, 3549, 5, 2373, 0, 0, 3549, + 3550, 5, 2245, 0, 0, 3550, 117, 1, 0, 0, 0, 3551, 3552, 5, 35, 0, 0, 3552, + 3553, 5, 2246, 0, 0, 3553, 3554, 3, 2292, 1146, 0, 3554, 119, 1, 0, 0, + 0, 3555, 3558, 5, 1394, 0, 0, 3556, 3557, 7, 25, 0, 0, 3557, 3559, 5, 2432, + 0, 0, 3558, 3556, 1, 0, 0, 0, 3558, 3559, 1, 0, 0, 0, 3559, 3560, 1, 0, + 0, 0, 3560, 3561, 5, 2246, 0, 0, 3561, 3562, 3, 2292, 1146, 0, 3562, 121, + 1, 0, 0, 0, 3563, 3564, 7, 26, 0, 0, 3564, 3565, 3, 2320, 1160, 0, 3565, + 123, 1, 0, 0, 0, 3566, 3567, 5, 1552, 0, 0, 3567, 3568, 5, 2447, 0, 0, + 3568, 3573, 3, 2342, 1171, 0, 3569, 3570, 5, 2453, 0, 0, 3570, 3572, 3, + 2342, 1171, 0, 3571, 3569, 1, 0, 0, 0, 3572, 3575, 1, 0, 0, 0, 3573, 3571, + 1, 0, 0, 0, 3573, 3574, 1, 0, 0, 0, 3574, 3576, 1, 0, 0, 0, 3575, 3573, + 1, 0, 0, 0, 3576, 3577, 5, 2448, 0, 0, 3577, 125, 1, 0, 0, 0, 3578, 3579, + 7, 27, 0, 0, 3579, 3580, 3, 2078, 1039, 0, 3580, 3581, 5, 160, 0, 0, 3581, + 3582, 3, 2360, 1180, 0, 3582, 127, 1, 0, 0, 0, 3583, 3584, 5, 42, 0, 0, + 3584, 3586, 5, 1315, 0, 0, 3585, 3587, 7, 28, 0, 0, 3586, 3585, 1, 0, 0, + 0, 3586, 3587, 1, 0, 0, 0, 3587, 3588, 1, 0, 0, 0, 3588, 3590, 3, 2404, + 1202, 0, 3589, 3591, 3, 130, 65, 0, 3590, 3589, 1, 0, 0, 0, 3591, 3592, + 1, 0, 0, 0, 3592, 3590, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 129, + 1, 0, 0, 0, 3594, 3605, 5, 1511, 0, 0, 3595, 3596, 5, 1559, 0, 0, 3596, + 3597, 5, 2141, 0, 0, 3597, 3605, 3, 2404, 1202, 0, 3598, 3599, 5, 190, + 0, 0, 3599, 3600, 5, 183, 0, 0, 3600, 3601, 5, 2141, 0, 0, 3601, 3605, + 3, 2404, 1202, 0, 3602, 3605, 5, 499, 0, 0, 3603, 3605, 5, 429, 0, 0, 3604, + 3594, 1, 0, 0, 0, 3604, 3595, 1, 0, 0, 0, 3604, 3598, 1, 0, 0, 0, 3604, + 3602, 1, 0, 0, 0, 3604, 3603, 1, 0, 0, 0, 3605, 131, 1, 0, 0, 0, 3606, + 3607, 5, 42, 0, 0, 3607, 3608, 5, 878, 0, 0, 3608, 3609, 5, 1463, 0, 0, + 3609, 3613, 3, 2404, 1202, 0, 3610, 3614, 3, 134, 67, 0, 3611, 3614, 3, + 136, 68, 0, 3612, 3614, 3, 138, 69, 0, 3613, 3610, 1, 0, 0, 0, 3613, 3611, + 1, 0, 0, 0, 3613, 3612, 1, 0, 0, 0, 3614, 3618, 1, 0, 0, 0, 3615, 3616, + 5, 2235, 0, 0, 3616, 3617, 5, 2472, 0, 0, 3617, 3619, 7, 29, 0, 0, 3618, + 3615, 1, 0, 0, 0, 3618, 3619, 1, 0, 0, 0, 3619, 133, 1, 0, 0, 0, 3620, + 3621, 3, 148, 74, 0, 3621, 3636, 5, 581, 0, 0, 3622, 3623, 5, 2472, 0, + 0, 3623, 3624, 5, 2447, 0, 0, 3624, 3625, 3, 146, 73, 0, 3625, 3626, 5, + 2448, 0, 0, 3626, 3637, 1, 0, 0, 0, 3627, 3634, 5, 38, 0, 0, 3628, 3629, + 5, 534, 0, 0, 3629, 3630, 5, 2472, 0, 0, 3630, 3631, 5, 2447, 0, 0, 3631, + 3632, 3, 146, 73, 0, 3632, 3633, 5, 2448, 0, 0, 3633, 3635, 1, 0, 0, 0, + 3634, 3628, 1, 0, 0, 0, 3634, 3635, 1, 0, 0, 0, 3635, 3637, 1, 0, 0, 0, + 3636, 3622, 1, 0, 0, 0, 3636, 3627, 1, 0, 0, 0, 3637, 135, 1, 0, 0, 0, + 3638, 3639, 3, 148, 74, 0, 3639, 3654, 5, 1272, 0, 0, 3640, 3641, 5, 2472, + 0, 0, 3641, 3642, 5, 2447, 0, 0, 3642, 3643, 3, 146, 73, 0, 3643, 3644, + 5, 2448, 0, 0, 3644, 3655, 1, 0, 0, 0, 3645, 3652, 5, 38, 0, 0, 3646, 3647, + 5, 534, 0, 0, 3647, 3648, 5, 2472, 0, 0, 3648, 3649, 5, 2447, 0, 0, 3649, + 3650, 3, 146, 73, 0, 3650, 3651, 5, 2448, 0, 0, 3651, 3653, 1, 0, 0, 0, + 3652, 3646, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3655, 1, 0, 0, 0, + 3654, 3640, 1, 0, 0, 0, 3654, 3645, 1, 0, 0, 0, 3655, 137, 1, 0, 0, 0, + 3656, 3657, 3, 148, 74, 0, 3657, 3677, 5, 1743, 0, 0, 3658, 3659, 5, 2472, + 0, 0, 3659, 3660, 5, 2447, 0, 0, 3660, 3661, 3, 146, 73, 0, 3661, 3662, + 5, 2448, 0, 0, 3662, 3678, 1, 0, 0, 0, 3663, 3664, 5, 2472, 0, 0, 3664, + 3665, 5, 2447, 0, 0, 3665, 3666, 5, 2443, 0, 0, 3666, 3667, 5, 2448, 0, + 0, 3667, 3678, 3, 140, 70, 0, 3668, 3675, 5, 38, 0, 0, 3669, 3670, 5, 534, + 0, 0, 3670, 3671, 5, 2472, 0, 0, 3671, 3672, 5, 2447, 0, 0, 3672, 3673, + 3, 146, 73, 0, 3673, 3674, 5, 2448, 0, 0, 3674, 3676, 1, 0, 0, 0, 3675, + 3669, 1, 0, 0, 0, 3675, 3676, 1, 0, 0, 0, 3676, 3678, 1, 0, 0, 0, 3677, + 3658, 1, 0, 0, 0, 3677, 3663, 1, 0, 0, 0, 3677, 3668, 1, 0, 0, 0, 3678, + 139, 1, 0, 0, 0, 3679, 3699, 5, 209, 0, 0, 3680, 3681, 5, 2472, 0, 0, 3681, + 3682, 5, 2447, 0, 0, 3682, 3683, 3, 146, 73, 0, 3683, 3684, 5, 2448, 0, + 0, 3684, 3700, 1, 0, 0, 0, 3685, 3686, 5, 2472, 0, 0, 3686, 3687, 5, 2447, + 0, 0, 3687, 3688, 5, 2443, 0, 0, 3688, 3689, 5, 2448, 0, 0, 3689, 3700, + 3, 142, 71, 0, 3690, 3697, 5, 38, 0, 0, 3691, 3692, 5, 534, 0, 0, 3692, + 3693, 5, 2472, 0, 0, 3693, 3694, 5, 2447, 0, 0, 3694, 3695, 3, 146, 73, + 0, 3695, 3696, 5, 2448, 0, 0, 3696, 3698, 1, 0, 0, 0, 3697, 3691, 1, 0, + 0, 0, 3697, 3698, 1, 0, 0, 0, 3698, 3700, 1, 0, 0, 0, 3699, 3680, 1, 0, + 0, 0, 3699, 3685, 1, 0, 0, 0, 3699, 3690, 1, 0, 0, 0, 3700, 141, 1, 0, + 0, 0, 3701, 3725, 5, 1272, 0, 0, 3702, 3703, 5, 2472, 0, 0, 3703, 3704, + 5, 2447, 0, 0, 3704, 3705, 3, 146, 73, 0, 3705, 3706, 5, 2448, 0, 0, 3706, + 3726, 1, 0, 0, 0, 3707, 3708, 5, 2472, 0, 0, 3708, 3709, 5, 2447, 0, 0, + 3709, 3710, 5, 2443, 0, 0, 3710, 3712, 5, 2448, 0, 0, 3711, 3713, 3, 144, + 72, 0, 3712, 3711, 1, 0, 0, 0, 3713, 3714, 1, 0, 0, 0, 3714, 3712, 1, 0, + 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3726, 1, 0, 0, 0, 3716, 3723, 5, 38, + 0, 0, 3717, 3718, 5, 534, 0, 0, 3718, 3719, 5, 2472, 0, 0, 3719, 3720, + 5, 2447, 0, 0, 3720, 3721, 3, 146, 73, 0, 3721, 3722, 5, 2448, 0, 0, 3722, + 3724, 1, 0, 0, 0, 3723, 3717, 1, 0, 0, 0, 3723, 3724, 1, 0, 0, 0, 3724, + 3726, 1, 0, 0, 0, 3725, 3702, 1, 0, 0, 0, 3725, 3707, 1, 0, 0, 0, 3725, + 3716, 1, 0, 0, 0, 3726, 143, 1, 0, 0, 0, 3727, 3728, 5, 2258, 0, 0, 3728, + 3729, 5, 2472, 0, 0, 3729, 3730, 5, 2447, 0, 0, 3730, 3731, 3, 146, 73, + 0, 3731, 3732, 5, 2448, 0, 0, 3732, 3737, 1, 0, 0, 0, 3733, 3734, 7, 30, + 0, 0, 3734, 3735, 5, 2472, 0, 0, 3735, 3737, 5, 2443, 0, 0, 3736, 3727, + 1, 0, 0, 0, 3736, 3733, 1, 0, 0, 0, 3737, 145, 1, 0, 0, 0, 3738, 3743, + 5, 2443, 0, 0, 3739, 3740, 5, 2453, 0, 0, 3740, 3742, 5, 2443, 0, 0, 3741, + 3739, 1, 0, 0, 0, 3742, 3745, 1, 0, 0, 0, 3743, 3741, 1, 0, 0, 0, 3743, + 3744, 1, 0, 0, 0, 3744, 147, 1, 0, 0, 0, 3745, 3743, 1, 0, 0, 0, 3746, + 3747, 7, 17, 0, 0, 3747, 149, 1, 0, 0, 0, 3748, 3749, 5, 469, 0, 0, 3749, + 3750, 5, 878, 0, 0, 3750, 3751, 5, 1463, 0, 0, 3751, 3752, 3, 2404, 1202, + 0, 3752, 151, 1, 0, 0, 0, 3753, 3754, 5, 469, 0, 0, 3754, 3756, 5, 1329, + 0, 0, 3755, 3757, 5, 147, 0, 0, 3756, 3755, 1, 0, 0, 0, 3756, 3757, 1, + 0, 0, 0, 3757, 3761, 1, 0, 0, 0, 3758, 3759, 3, 2350, 1175, 0, 3759, 3760, + 5, 2440, 0, 0, 3760, 3762, 1, 0, 0, 0, 3761, 3758, 1, 0, 0, 0, 3761, 3762, + 1, 0, 0, 0, 3762, 3763, 1, 0, 0, 0, 3763, 3764, 3, 2290, 1145, 0, 3764, + 153, 1, 0, 0, 0, 3765, 3766, 5, 42, 0, 0, 3766, 3767, 5, 1329, 0, 0, 3767, + 3768, 3, 2290, 1145, 0, 3768, 3770, 5, 249, 0, 0, 3769, 3771, 5, 378, 0, + 0, 3770, 3769, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 3773, 1, 0, 0, + 0, 3772, 3774, 7, 31, 0, 0, 3773, 3772, 1, 0, 0, 0, 3773, 3774, 1, 0, 0, + 0, 3774, 3778, 1, 0, 0, 0, 3775, 3777, 3, 812, 406, 0, 3776, 3775, 1, 0, + 0, 0, 3777, 3780, 1, 0, 0, 0, 3778, 3776, 1, 0, 0, 0, 3778, 3779, 1, 0, + 0, 0, 3779, 3783, 1, 0, 0, 0, 3780, 3778, 1, 0, 0, 0, 3781, 3782, 5, 1587, + 0, 0, 3782, 3784, 5, 1673, 0, 0, 3783, 3781, 1, 0, 0, 0, 3783, 3784, 1, + 0, 0, 0, 3784, 155, 1, 0, 0, 0, 3785, 3788, 5, 321, 0, 0, 3786, 3787, 5, + 1307, 0, 0, 3787, 3789, 5, 1562, 0, 0, 3788, 3786, 1, 0, 0, 0, 3788, 3789, + 1, 0, 0, 0, 3789, 3791, 1, 0, 0, 0, 3790, 3792, 7, 20, 0, 0, 3791, 3790, + 1, 0, 0, 0, 3791, 3792, 1, 0, 0, 0, 3792, 3793, 1, 0, 0, 0, 3793, 3797, + 5, 1329, 0, 0, 3794, 3795, 3, 2350, 1175, 0, 3795, 3796, 5, 2440, 0, 0, + 3796, 3798, 1, 0, 0, 0, 3797, 3794, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, + 3798, 3799, 1, 0, 0, 0, 3799, 3801, 3, 2290, 1145, 0, 3800, 3802, 3, 1720, + 860, 0, 3801, 3800, 1, 0, 0, 0, 3801, 3802, 1, 0, 0, 0, 3802, 3803, 1, + 0, 0, 0, 3803, 3807, 7, 22, 0, 0, 3804, 3806, 3, 160, 80, 0, 3805, 3804, + 1, 0, 0, 0, 3806, 3809, 1, 0, 0, 0, 3807, 3805, 1, 0, 0, 0, 3807, 3808, + 1, 0, 0, 0, 3808, 3810, 1, 0, 0, 0, 3809, 3807, 1, 0, 0, 0, 3810, 3812, + 5, 508, 0, 0, 3811, 3813, 3, 2290, 1145, 0, 3812, 3811, 1, 0, 0, 0, 3812, + 3813, 1, 0, 0, 0, 3813, 157, 1, 0, 0, 0, 3814, 3817, 5, 321, 0, 0, 3815, + 3816, 5, 1307, 0, 0, 3816, 3818, 5, 1562, 0, 0, 3817, 3815, 1, 0, 0, 0, + 3817, 3818, 1, 0, 0, 0, 3818, 3820, 1, 0, 0, 0, 3819, 3821, 7, 20, 0, 0, + 3820, 3819, 1, 0, 0, 0, 3820, 3821, 1, 0, 0, 0, 3821, 3822, 1, 0, 0, 0, + 3822, 3823, 5, 1329, 0, 0, 3823, 3827, 5, 147, 0, 0, 3824, 3825, 3, 2350, + 1175, 0, 3825, 3826, 5, 2440, 0, 0, 3826, 3828, 1, 0, 0, 0, 3827, 3824, + 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, 3830, + 3, 2290, 1145, 0, 3830, 3834, 7, 22, 0, 0, 3831, 3833, 3, 166, 83, 0, 3832, + 3831, 1, 0, 0, 0, 3833, 3836, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3834, + 3832, 1, 0, 0, 0, 3835, 3847, 1, 0, 0, 0, 3836, 3834, 1, 0, 0, 0, 3837, + 3838, 5, 113, 0, 0, 3838, 3845, 3, 1770, 885, 0, 3839, 3841, 5, 535, 0, + 0, 3840, 3842, 3, 1822, 911, 0, 3841, 3840, 1, 0, 0, 0, 3842, 3843, 1, + 0, 0, 0, 3843, 3841, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, 3846, 1, + 0, 0, 0, 3845, 3839, 1, 0, 0, 0, 3845, 3846, 1, 0, 0, 0, 3846, 3848, 1, + 0, 0, 0, 3847, 3837, 1, 0, 0, 0, 3847, 3848, 1, 0, 0, 0, 3848, 3849, 1, + 0, 0, 0, 3849, 3851, 5, 508, 0, 0, 3850, 3852, 3, 2290, 1145, 0, 3851, + 3850, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, 0, 3852, 159, 1, 0, 0, 0, 3853, + 3862, 3, 1754, 877, 0, 3854, 3862, 3, 1752, 876, 0, 3855, 3862, 3, 162, + 81, 0, 3856, 3862, 3, 164, 82, 0, 3857, 3862, 3, 1744, 872, 0, 3858, 3862, + 3, 1746, 873, 0, 3859, 3862, 3, 1748, 874, 0, 3860, 3862, 3, 1762, 881, + 0, 3861, 3853, 1, 0, 0, 0, 3861, 3854, 1, 0, 0, 0, 3861, 3855, 1, 0, 0, + 0, 3861, 3856, 1, 0, 0, 0, 3861, 3857, 1, 0, 0, 0, 3861, 3858, 1, 0, 0, + 0, 3861, 3859, 1, 0, 0, 0, 3861, 3860, 1, 0, 0, 0, 3862, 161, 1, 0, 0, + 0, 3863, 3864, 5, 1461, 0, 0, 3864, 3876, 3, 2402, 1201, 0, 3865, 3866, + 5, 2447, 0, 0, 3866, 3871, 3, 1736, 868, 0, 3867, 3868, 5, 2453, 0, 0, + 3868, 3870, 3, 1736, 868, 0, 3869, 3867, 1, 0, 0, 0, 3870, 3873, 1, 0, + 0, 0, 3871, 3869, 1, 0, 0, 0, 3871, 3872, 1, 0, 0, 0, 3872, 3874, 1, 0, + 0, 0, 3873, 3871, 1, 0, 0, 0, 3874, 3875, 5, 2448, 0, 0, 3875, 3877, 1, + 0, 0, 0, 3876, 3865, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 3883, 1, + 0, 0, 0, 3878, 3882, 3, 114, 57, 0, 3879, 3882, 5, 1331, 0, 0, 3880, 3882, + 5, 420, 0, 0, 3881, 3878, 1, 0, 0, 0, 3881, 3879, 1, 0, 0, 0, 3881, 3880, + 1, 0, 0, 0, 3882, 3885, 1, 0, 0, 0, 3883, 3881, 1, 0, 0, 0, 3883, 3884, + 1, 0, 0, 0, 3884, 3888, 1, 0, 0, 0, 3885, 3883, 1, 0, 0, 0, 3886, 3887, + 5, 69, 0, 0, 3887, 3889, 3, 1722, 861, 0, 3888, 3886, 1, 0, 0, 0, 3888, + 3889, 1, 0, 0, 0, 3889, 3890, 1, 0, 0, 0, 3890, 3891, 5, 2470, 0, 0, 3891, + 163, 1, 0, 0, 0, 3892, 3893, 5, 632, 0, 0, 3893, 3905, 3, 2402, 1201, 0, + 3894, 3895, 5, 2447, 0, 0, 3895, 3900, 3, 1736, 868, 0, 3896, 3897, 5, + 2453, 0, 0, 3897, 3899, 3, 1736, 868, 0, 3898, 3896, 1, 0, 0, 0, 3899, + 3902, 1, 0, 0, 0, 3900, 3898, 1, 0, 0, 0, 3900, 3901, 1, 0, 0, 0, 3901, + 3903, 1, 0, 0, 0, 3902, 3900, 1, 0, 0, 0, 3903, 3904, 5, 2448, 0, 0, 3904, + 3906, 1, 0, 0, 0, 3905, 3894, 1, 0, 0, 0, 3905, 3906, 1, 0, 0, 0, 3906, + 3907, 1, 0, 0, 0, 3907, 3908, 5, 1586, 0, 0, 3908, 3916, 3, 2374, 1187, + 0, 3909, 3915, 5, 420, 0, 0, 3910, 3915, 5, 1394, 0, 0, 3911, 3915, 3, + 108, 54, 0, 3912, 3915, 5, 1579, 0, 0, 3913, 3915, 3, 126, 63, 0, 3914, + 3909, 1, 0, 0, 0, 3914, 3910, 1, 0, 0, 0, 3914, 3911, 1, 0, 0, 0, 3914, + 3912, 1, 0, 0, 0, 3914, 3913, 1, 0, 0, 0, 3915, 3918, 1, 0, 0, 0, 3916, + 3914, 1, 0, 0, 0, 3916, 3917, 1, 0, 0, 0, 3917, 3921, 1, 0, 0, 0, 3918, + 3916, 1, 0, 0, 0, 3919, 3920, 5, 69, 0, 0, 3920, 3922, 3, 1722, 861, 0, + 3921, 3919, 1, 0, 0, 0, 3921, 3922, 1, 0, 0, 0, 3922, 3923, 1, 0, 0, 0, + 3923, 3924, 5, 2470, 0, 0, 3924, 165, 1, 0, 0, 0, 3925, 3937, 3, 1754, + 877, 0, 3926, 3937, 3, 1752, 876, 0, 3927, 3937, 3, 162, 81, 0, 3928, 3937, + 3, 164, 82, 0, 3929, 3937, 3, 1746, 873, 0, 3930, 3937, 3, 1748, 874, 0, + 3931, 3937, 3, 1744, 872, 0, 3932, 3937, 3, 1762, 881, 0, 3933, 3937, 3, + 178, 89, 0, 3934, 3937, 3, 176, 88, 0, 3935, 3937, 3, 1814, 907, 0, 3936, + 3925, 1, 0, 0, 0, 3936, 3926, 1, 0, 0, 0, 3936, 3927, 1, 0, 0, 0, 3936, + 3928, 1, 0, 0, 0, 3936, 3929, 1, 0, 0, 0, 3936, 3930, 1, 0, 0, 0, 3936, + 3931, 1, 0, 0, 0, 3936, 3932, 1, 0, 0, 0, 3936, 3933, 1, 0, 0, 0, 3936, + 3934, 1, 0, 0, 0, 3936, 3935, 1, 0, 0, 0, 3937, 167, 1, 0, 0, 0, 3938, + 3939, 5, 42, 0, 0, 3939, 3940, 5, 1410, 0, 0, 3940, 3941, 5, 592, 0, 0, + 3941, 3958, 3, 2404, 1202, 0, 3942, 3943, 5, 1567, 0, 0, 3943, 3959, 3, + 1176, 588, 0, 3944, 3959, 3, 922, 461, 0, 3945, 3948, 5, 988, 0, 0, 3946, + 3947, 5, 990, 0, 0, 3947, 3949, 3, 198, 99, 0, 3948, 3946, 1, 0, 0, 0, + 3948, 3949, 1, 0, 0, 0, 3949, 3952, 1, 0, 0, 0, 3950, 3951, 5, 101, 0, + 0, 3951, 3953, 3, 1458, 729, 0, 3952, 3950, 1, 0, 0, 0, 3952, 3953, 1, + 0, 0, 0, 3953, 3955, 1, 0, 0, 0, 3954, 3956, 5, 616, 0, 0, 3955, 3954, + 1, 0, 0, 0, 3955, 3956, 1, 0, 0, 0, 3956, 3959, 1, 0, 0, 0, 3957, 3959, + 5, 444, 0, 0, 3958, 3942, 1, 0, 0, 0, 3958, 3944, 1, 0, 0, 0, 3958, 3945, + 1, 0, 0, 0, 3958, 3957, 1, 0, 0, 0, 3959, 169, 1, 0, 0, 0, 3960, 3961, + 5, 469, 0, 0, 3961, 3962, 5, 1410, 0, 0, 3962, 3963, 5, 592, 0, 0, 3963, + 3972, 3, 2404, 1202, 0, 3964, 3966, 5, 616, 0, 0, 3965, 3964, 1, 0, 0, + 0, 3965, 3966, 1, 0, 0, 0, 3966, 3967, 1, 0, 0, 0, 3967, 3970, 5, 705, + 0, 0, 3968, 3970, 5, 540, 0, 0, 3969, 3965, 1, 0, 0, 0, 3969, 3968, 1, + 0, 0, 0, 3970, 3971, 1, 0, 0, 0, 3971, 3973, 5, 295, 0, 0, 3972, 3969, + 1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, 171, 1, 0, 0, 0, 3974, 3975, + 5, 469, 0, 0, 3975, 3976, 5, 1461, 0, 0, 3976, 3977, 3, 2322, 1161, 0, + 3977, 173, 1, 0, 0, 0, 3978, 3979, 5, 42, 0, 0, 3979, 3980, 5, 1461, 0, + 0, 3980, 3981, 3, 2322, 1161, 0, 3981, 3983, 5, 249, 0, 0, 3982, 3984, + 5, 378, 0, 0, 3983, 3982, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, 3984, 3988, + 1, 0, 0, 0, 3985, 3987, 3, 812, 406, 0, 3986, 3985, 1, 0, 0, 0, 3987, 3990, + 1, 0, 0, 0, 3988, 3986, 1, 0, 0, 0, 3988, 3989, 1, 0, 0, 0, 3989, 3993, + 1, 0, 0, 0, 3990, 3988, 1, 0, 0, 0, 3991, 3992, 5, 1587, 0, 0, 3992, 3994, + 5, 1673, 0, 0, 3993, 3991, 1, 0, 0, 0, 3993, 3994, 1, 0, 0, 0, 3994, 175, + 1, 0, 0, 0, 3995, 3996, 5, 632, 0, 0, 3996, 4008, 3, 2402, 1201, 0, 3997, + 3998, 5, 2447, 0, 0, 3998, 4003, 3, 1736, 868, 0, 3999, 4000, 5, 2453, + 0, 0, 4000, 4002, 3, 1736, 868, 0, 4001, 3999, 1, 0, 0, 0, 4002, 4005, + 1, 0, 0, 0, 4003, 4001, 1, 0, 0, 0, 4003, 4004, 1, 0, 0, 0, 4004, 4006, + 1, 0, 0, 0, 4005, 4003, 1, 0, 0, 0, 4006, 4007, 5, 2448, 0, 0, 4007, 4009, + 1, 0, 0, 0, 4008, 3997, 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 4010, + 1, 0, 0, 0, 4010, 4011, 5, 1586, 0, 0, 4011, 4020, 3, 2374, 1187, 0, 4012, + 4019, 5, 1394, 0, 0, 4013, 4019, 5, 420, 0, 0, 4014, 4019, 3, 1720, 860, + 0, 4015, 4019, 3, 108, 54, 0, 4016, 4019, 3, 112, 56, 0, 4017, 4019, 3, + 126, 63, 0, 4018, 4012, 1, 0, 0, 0, 4018, 4013, 1, 0, 0, 0, 4018, 4014, + 1, 0, 0, 0, 4018, 4015, 1, 0, 0, 0, 4018, 4016, 1, 0, 0, 0, 4018, 4017, + 1, 0, 0, 0, 4019, 4022, 1, 0, 0, 0, 4020, 4018, 1, 0, 0, 0, 4020, 4021, + 1, 0, 0, 0, 4021, 4037, 1, 0, 0, 0, 4022, 4020, 1, 0, 0, 0, 4023, 4032, + 7, 22, 0, 0, 4024, 4026, 5, 382, 0, 0, 4025, 4024, 1, 0, 0, 0, 4025, 4026, + 1, 0, 0, 0, 4026, 4028, 1, 0, 0, 0, 4027, 4029, 3, 1740, 870, 0, 4028, + 4027, 1, 0, 0, 0, 4028, 4029, 1, 0, 0, 0, 4029, 4030, 1, 0, 0, 0, 4030, + 4033, 3, 1820, 910, 0, 4031, 4033, 3, 1722, 861, 0, 4032, 4025, 1, 0, 0, + 0, 4032, 4031, 1, 0, 0, 0, 4033, 4038, 1, 0, 0, 0, 4034, 4035, 7, 32, 0, + 0, 4035, 4036, 5, 2246, 0, 0, 4036, 4038, 3, 2292, 1146, 0, 4037, 4023, + 1, 0, 0, 0, 4037, 4034, 1, 0, 0, 0, 4038, 4039, 1, 0, 0, 0, 4039, 4040, + 5, 2470, 0, 0, 4040, 177, 1, 0, 0, 0, 4041, 4042, 5, 1461, 0, 0, 4042, + 4054, 3, 2402, 1201, 0, 4043, 4044, 5, 2447, 0, 0, 4044, 4049, 3, 1736, + 868, 0, 4045, 4046, 5, 2453, 0, 0, 4046, 4048, 3, 1736, 868, 0, 4047, 4045, + 1, 0, 0, 0, 4048, 4051, 1, 0, 0, 0, 4049, 4047, 1, 0, 0, 0, 4049, 4050, + 1, 0, 0, 0, 4050, 4052, 1, 0, 0, 0, 4051, 4049, 1, 0, 0, 0, 4052, 4053, + 5, 2448, 0, 0, 4053, 4055, 1, 0, 0, 0, 4054, 4043, 1, 0, 0, 0, 4054, 4055, + 1, 0, 0, 0, 4055, 4061, 1, 0, 0, 0, 4056, 4060, 3, 114, 57, 0, 4057, 4060, + 5, 1331, 0, 0, 4058, 4060, 5, 420, 0, 0, 4059, 4056, 1, 0, 0, 0, 4059, + 4057, 1, 0, 0, 0, 4059, 4058, 1, 0, 0, 0, 4060, 4063, 1, 0, 0, 0, 4061, + 4059, 1, 0, 0, 0, 4061, 4062, 1, 0, 0, 0, 4062, 4064, 1, 0, 0, 0, 4063, + 4061, 1, 0, 0, 0, 4064, 4074, 7, 22, 0, 0, 4065, 4067, 5, 382, 0, 0, 4066, + 4065, 1, 0, 0, 0, 4066, 4067, 1, 0, 0, 0, 4067, 4069, 1, 0, 0, 0, 4068, + 4070, 3, 1740, 870, 0, 4069, 4068, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, + 4070, 4071, 1, 0, 0, 0, 4071, 4075, 3, 1820, 910, 0, 4072, 4075, 3, 1722, + 861, 0, 4073, 4075, 5, 560, 0, 0, 4074, 4066, 1, 0, 0, 0, 4074, 4072, 1, + 0, 0, 0, 4074, 4073, 1, 0, 0, 0, 4075, 4076, 1, 0, 0, 0, 4076, 4077, 5, + 2470, 0, 0, 4077, 179, 1, 0, 0, 0, 4078, 4081, 5, 321, 0, 0, 4079, 4080, + 5, 1307, 0, 0, 4080, 4082, 5, 1562, 0, 0, 4081, 4079, 1, 0, 0, 0, 4081, + 4082, 1, 0, 0, 0, 4082, 4083, 1, 0, 0, 0, 4083, 4084, 5, 1461, 0, 0, 4084, + 4096, 3, 2322, 1161, 0, 4085, 4086, 5, 2447, 0, 0, 4086, 4091, 3, 1736, + 868, 0, 4087, 4088, 5, 2453, 0, 0, 4088, 4090, 3, 1736, 868, 0, 4089, 4087, + 1, 0, 0, 0, 4090, 4093, 1, 0, 0, 0, 4091, 4089, 1, 0, 0, 0, 4091, 4092, + 1, 0, 0, 0, 4092, 4094, 1, 0, 0, 0, 4093, 4091, 1, 0, 0, 0, 4094, 4095, + 5, 2448, 0, 0, 4095, 4097, 1, 0, 0, 0, 4096, 4085, 1, 0, 0, 0, 4096, 4097, + 1, 0, 0, 0, 4097, 4099, 1, 0, 0, 0, 4098, 4100, 3, 1720, 860, 0, 4099, + 4098, 1, 0, 0, 0, 4099, 4100, 1, 0, 0, 0, 4100, 4104, 1, 0, 0, 0, 4101, + 4103, 7, 33, 0, 0, 4102, 4101, 1, 0, 0, 0, 4103, 4106, 1, 0, 0, 0, 4104, + 4102, 1, 0, 0, 0, 4104, 4105, 1, 0, 0, 0, 4105, 4107, 1, 0, 0, 0, 4106, + 4104, 1, 0, 0, 0, 4107, 4117, 7, 22, 0, 0, 4108, 4110, 5, 382, 0, 0, 4109, + 4108, 1, 0, 0, 0, 4109, 4110, 1, 0, 0, 0, 4110, 4112, 1, 0, 0, 0, 4111, + 4113, 3, 1740, 870, 0, 4112, 4111, 1, 0, 0, 0, 4112, 4113, 1, 0, 0, 0, + 4113, 4114, 1, 0, 0, 0, 4114, 4118, 3, 1820, 910, 0, 4115, 4118, 3, 1722, + 861, 0, 4116, 4118, 5, 560, 0, 0, 4117, 4109, 1, 0, 0, 0, 4117, 4115, 1, + 0, 0, 0, 4117, 4116, 1, 0, 0, 0, 4118, 181, 1, 0, 0, 0, 4119, 4120, 5, + 42, 0, 0, 4120, 4121, 5, 1570, 0, 0, 4121, 4124, 5, 311, 0, 0, 4122, 4123, + 7, 34, 0, 0, 4123, 4125, 5, 2441, 0, 0, 4124, 4122, 1, 0, 0, 0, 4125, 4126, + 1, 0, 0, 0, 4126, 4124, 1, 0, 0, 0, 4126, 4127, 1, 0, 0, 0, 4127, 183, + 1, 0, 0, 0, 4128, 4129, 5, 469, 0, 0, 4129, 4130, 5, 1315, 0, 0, 4130, + 4131, 3, 2404, 1202, 0, 4131, 185, 1, 0, 0, 0, 4132, 4133, 5, 42, 0, 0, + 4133, 4134, 5, 1596, 0, 0, 4134, 4135, 5, 1645, 0, 0, 4135, 4144, 3, 2284, + 1142, 0, 4136, 4145, 5, 1256, 0, 0, 4137, 4145, 5, 1243, 0, 0, 4138, 4145, + 3, 1196, 598, 0, 4139, 4142, 5, 1684, 0, 0, 4140, 4141, 5, 2141, 0, 0, + 4141, 4143, 3, 1176, 588, 0, 4142, 4140, 1, 0, 0, 0, 4142, 4143, 1, 0, + 0, 0, 4143, 4145, 1, 0, 0, 0, 4144, 4136, 1, 0, 0, 0, 4144, 4137, 1, 0, + 0, 0, 4144, 4138, 1, 0, 0, 0, 4144, 4139, 1, 0, 0, 0, 4145, 187, 1, 0, + 0, 0, 4146, 4147, 5, 469, 0, 0, 4147, 4148, 5, 1574, 0, 0, 4148, 4149, + 5, 1411, 0, 0, 4149, 4154, 3, 2404, 1202, 0, 4150, 4151, 5, 620, 0, 0, + 4151, 4152, 5, 1409, 0, 0, 4152, 4153, 5, 350, 0, 0, 4153, 4155, 3, 2404, + 1202, 0, 4154, 4150, 1, 0, 0, 0, 4154, 4155, 1, 0, 0, 0, 4155, 189, 1, + 0, 0, 0, 4156, 4157, 5, 469, 0, 0, 4157, 4158, 5, 1596, 0, 0, 4158, 4159, + 5, 1645, 0, 0, 4159, 4160, 3, 2284, 1142, 0, 4160, 191, 1, 0, 0, 0, 4161, + 4162, 5, 469, 0, 0, 4162, 4163, 5, 1593, 0, 0, 4163, 4164, 3, 2308, 1154, + 0, 4164, 193, 1, 0, 0, 0, 4165, 4166, 5, 321, 0, 0, 4166, 4167, 5, 1410, + 0, 0, 4167, 4168, 5, 592, 0, 0, 4168, 4170, 3, 2404, 1202, 0, 4169, 4171, + 3, 196, 98, 0, 4170, 4169, 1, 0, 0, 0, 4171, 4172, 1, 0, 0, 0, 4172, 4170, + 1, 0, 0, 0, 4172, 4173, 1, 0, 0, 0, 4173, 195, 1, 0, 0, 0, 4174, 4175, + 5, 990, 0, 0, 4175, 4185, 3, 198, 99, 0, 4176, 4177, 5, 101, 0, 0, 4177, + 4179, 3, 1458, 729, 0, 4178, 4180, 5, 1587, 0, 0, 4179, 4178, 1, 0, 0, + 0, 4179, 4180, 1, 0, 0, 0, 4180, 4185, 1, 0, 0, 0, 4181, 4182, 7, 35, 0, + 0, 4182, 4185, 3, 1176, 588, 0, 4183, 4185, 3, 922, 461, 0, 4184, 4174, + 1, 0, 0, 0, 4184, 4176, 1, 0, 0, 0, 4184, 4181, 1, 0, 0, 0, 4184, 4183, + 1, 0, 0, 0, 4185, 197, 1, 0, 0, 0, 4186, 4187, 5, 2443, 0, 0, 4187, 199, + 1, 0, 0, 0, 4188, 4190, 5, 321, 0, 0, 4189, 4191, 5, 1473, 0, 0, 4190, + 4189, 1, 0, 0, 0, 4190, 4191, 1, 0, 0, 0, 4191, 4192, 1, 0, 0, 0, 4192, + 4193, 5, 1596, 0, 0, 4193, 4194, 5, 1645, 0, 0, 4194, 4200, 3, 2284, 1142, + 0, 4195, 4196, 5, 2080, 0, 0, 4196, 4199, 3, 1656, 828, 0, 4197, 4199, + 3, 1196, 598, 0, 4198, 4195, 1, 0, 0, 0, 4198, 4197, 1, 0, 0, 0, 4199, + 4202, 1, 0, 0, 0, 4200, 4198, 1, 0, 0, 0, 4200, 4201, 1, 0, 0, 0, 4201, + 201, 1, 0, 0, 0, 4202, 4200, 1, 0, 0, 0, 4203, 4204, 5, 469, 0, 0, 4204, + 4205, 5, 2157, 0, 0, 4205, 4206, 3, 2324, 1162, 0, 4206, 203, 1, 0, 0, + 0, 4207, 4208, 5, 42, 0, 0, 4208, 4209, 5, 2157, 0, 0, 4209, 4228, 3, 2324, + 1162, 0, 4210, 4229, 7, 17, 0, 0, 4211, 4212, 5, 1559, 0, 0, 4212, 4213, + 5, 2141, 0, 0, 4213, 4229, 3, 2324, 1162, 0, 4214, 4216, 5, 249, 0, 0, + 4215, 4217, 5, 378, 0, 0, 4216, 4215, 1, 0, 0, 0, 4216, 4217, 1, 0, 0, + 0, 4217, 4221, 1, 0, 0, 0, 4218, 4220, 3, 812, 406, 0, 4219, 4218, 1, 0, + 0, 0, 4220, 4223, 1, 0, 0, 0, 4221, 4219, 1, 0, 0, 0, 4221, 4222, 1, 0, + 0, 0, 4222, 4226, 1, 0, 0, 0, 4223, 4221, 1, 0, 0, 0, 4224, 4225, 5, 1587, + 0, 0, 4225, 4227, 5, 1673, 0, 0, 4226, 4224, 1, 0, 0, 0, 4226, 4227, 1, + 0, 0, 0, 4227, 4229, 1, 0, 0, 0, 4228, 4210, 1, 0, 0, 0, 4228, 4211, 1, + 0, 0, 0, 4228, 4214, 1, 0, 0, 0, 4229, 205, 1, 0, 0, 0, 4230, 4233, 5, + 321, 0, 0, 4231, 4232, 5, 1307, 0, 0, 4232, 4234, 5, 1562, 0, 0, 4233, + 4231, 1, 0, 0, 0, 4233, 4234, 1, 0, 0, 0, 4234, 4235, 1, 0, 0, 0, 4235, + 4236, 5, 2157, 0, 0, 4236, 4240, 3, 2324, 1162, 0, 4237, 4241, 3, 212, + 106, 0, 4238, 4241, 3, 216, 108, 0, 4239, 4241, 3, 218, 109, 0, 4240, 4237, + 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4240, 4239, 1, 0, 0, 0, 4241, 4243, + 1, 0, 0, 0, 4242, 4244, 3, 208, 104, 0, 4243, 4242, 1, 0, 0, 0, 4243, 4244, + 1, 0, 0, 0, 4244, 4246, 1, 0, 0, 0, 4245, 4247, 7, 17, 0, 0, 4246, 4245, + 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, 1, 0, 0, 0, 4248, 4250, + 3, 210, 105, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 4251, + 1, 0, 0, 0, 4251, 4252, 3, 220, 110, 0, 4252, 207, 1, 0, 0, 0, 4253, 4254, + 5, 614, 0, 0, 4254, 4259, 3, 2324, 1162, 0, 4255, 4256, 5, 2453, 0, 0, + 4256, 4258, 3, 2324, 1162, 0, 4257, 4255, 1, 0, 0, 0, 4258, 4261, 1, 0, + 0, 0, 4259, 4257, 1, 0, 0, 0, 4259, 4260, 1, 0, 0, 0, 4260, 209, 1, 0, + 0, 0, 4261, 4259, 1, 0, 0, 0, 4262, 4263, 5, 2300, 0, 0, 4263, 4264, 5, + 2447, 0, 0, 4264, 4265, 3, 2074, 1037, 0, 4265, 4266, 5, 2448, 0, 0, 4266, + 211, 1, 0, 0, 0, 4267, 4272, 5, 112, 0, 0, 4268, 4272, 5, 33, 0, 0, 4269, + 4270, 5, 763, 0, 0, 4270, 4272, 5, 1246, 0, 0, 4271, 4267, 1, 0, 0, 0, + 4271, 4268, 1, 0, 0, 0, 4271, 4269, 1, 0, 0, 0, 4272, 4273, 1, 0, 0, 0, + 4273, 4275, 3, 228, 114, 0, 4274, 4276, 3, 234, 117, 0, 4275, 4274, 1, + 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4278, 1, 0, 0, 0, 4277, 4279, 3, + 214, 107, 0, 4278, 4277, 1, 0, 0, 0, 4278, 4279, 1, 0, 0, 0, 4279, 213, + 1, 0, 0, 0, 4280, 4281, 5, 620, 0, 0, 4281, 4282, 5, 481, 0, 0, 4282, 4283, + 5, 1606, 0, 0, 4283, 215, 1, 0, 0, 0, 4284, 4285, 5, 620, 0, 0, 4285, 4287, + 3, 228, 114, 0, 4286, 4288, 3, 234, 117, 0, 4287, 4286, 1, 0, 0, 0, 4287, + 4288, 1, 0, 0, 0, 4288, 217, 1, 0, 0, 0, 4289, 4290, 7, 36, 0, 0, 4290, + 4295, 3, 226, 113, 0, 4291, 4292, 5, 1307, 0, 0, 4292, 4294, 3, 226, 113, + 0, 4293, 4291, 1, 0, 0, 0, 4294, 4297, 1, 0, 0, 0, 4295, 4293, 1, 0, 0, + 0, 4295, 4296, 1, 0, 0, 0, 4296, 4298, 1, 0, 0, 0, 4297, 4295, 1, 0, 0, + 0, 4298, 4306, 5, 1259, 0, 0, 4299, 4307, 5, 350, 0, 0, 4300, 4301, 3, + 2286, 1143, 0, 4301, 4302, 5, 2440, 0, 0, 4302, 4304, 1, 0, 0, 0, 4303, + 4300, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4305, 1, 0, 0, 0, 4305, + 4307, 5, 1625, 0, 0, 4306, 4299, 1, 0, 0, 0, 4306, 4303, 1, 0, 0, 0, 4307, + 219, 1, 0, 0, 0, 4308, 4313, 3, 222, 111, 0, 4309, 4310, 5, 173, 0, 0, + 4310, 4313, 3, 2402, 1201, 0, 4311, 4313, 3, 1824, 912, 0, 4312, 4308, + 1, 0, 0, 0, 4312, 4309, 1, 0, 0, 0, 4312, 4311, 1, 0, 0, 0, 4313, 221, + 1, 0, 0, 0, 4314, 4315, 5, 257, 0, 0, 4315, 4317, 5, 2157, 0, 0, 4316, + 4318, 3, 1740, 870, 0, 4317, 4316, 1, 0, 0, 0, 4317, 4318, 1, 0, 0, 0, + 4318, 4320, 1, 0, 0, 0, 4319, 4321, 3, 224, 112, 0, 4320, 4319, 1, 0, 0, + 0, 4321, 4322, 1, 0, 0, 0, 4322, 4320, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, + 0, 4323, 4324, 1, 0, 0, 0, 4324, 4326, 5, 508, 0, 0, 4325, 4327, 3, 2324, + 1162, 0, 4326, 4325, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 223, 1, + 0, 0, 0, 4328, 4329, 5, 112, 0, 0, 4329, 4330, 5, 1743, 0, 0, 4330, 4331, + 5, 785, 0, 0, 4331, 4332, 3, 1826, 913, 0, 4332, 4333, 5, 112, 0, 0, 4333, + 4334, 5, 1743, 0, 0, 4334, 4335, 5, 2470, 0, 0, 4335, 4365, 1, 0, 0, 0, + 4336, 4337, 5, 112, 0, 0, 4337, 4338, 5, 481, 0, 0, 4338, 4339, 5, 1606, + 0, 0, 4339, 4340, 5, 785, 0, 0, 4340, 4341, 3, 1826, 913, 0, 4341, 4342, + 5, 112, 0, 0, 4342, 4343, 5, 481, 0, 0, 4343, 4344, 5, 1606, 0, 0, 4344, + 4345, 5, 2470, 0, 0, 4345, 4365, 1, 0, 0, 0, 4346, 4347, 5, 33, 0, 0, 4347, + 4348, 5, 1743, 0, 0, 4348, 4349, 5, 785, 0, 0, 4349, 4350, 3, 1826, 913, + 0, 4350, 4351, 5, 33, 0, 0, 4351, 4352, 5, 1743, 0, 0, 4352, 4353, 5, 2470, + 0, 0, 4353, 4365, 1, 0, 0, 0, 4354, 4355, 5, 33, 0, 0, 4355, 4356, 5, 481, + 0, 0, 4356, 4357, 5, 1606, 0, 0, 4357, 4358, 5, 785, 0, 0, 4358, 4359, + 3, 1826, 913, 0, 4359, 4360, 5, 33, 0, 0, 4360, 4361, 5, 481, 0, 0, 4361, + 4362, 5, 1606, 0, 0, 4362, 4363, 5, 2470, 0, 0, 4363, 4365, 1, 0, 0, 0, + 4364, 4328, 1, 0, 0, 0, 4364, 4336, 1, 0, 0, 0, 4364, 4346, 1, 0, 0, 0, + 4364, 4354, 1, 0, 0, 0, 4365, 225, 1, 0, 0, 0, 4366, 4393, 5, 42, 0, 0, + 4367, 4393, 5, 46, 0, 0, 4368, 4369, 5, 77, 0, 0, 4369, 4393, 5, 1746, + 0, 0, 4370, 4393, 5, 85, 0, 0, 4371, 4393, 5, 241, 0, 0, 4372, 4393, 5, + 321, 0, 0, 4373, 4374, 5, 436, 0, 0, 4374, 4393, 5, 1746, 0, 0, 4375, 4393, + 5, 469, 0, 0, 4376, 4393, 5, 647, 0, 0, 4377, 4393, 5, 1059, 0, 0, 4378, + 4393, 5, 1559, 0, 0, 4379, 4393, 5, 1589, 0, 0, 4380, 4393, 5, 2159, 0, + 0, 4381, 4393, 5, 376, 0, 0, 4382, 4393, 5, 1739, 0, 0, 4383, 4393, 5, + 1685, 0, 0, 4384, 4393, 5, 372, 0, 0, 4385, 4393, 5, 891, 0, 0, 4386, 4393, + 5, 890, 0, 0, 4387, 4393, 5, 1662, 0, 0, 4388, 4393, 5, 1790, 0, 0, 4389, + 4393, 5, 350, 0, 0, 4390, 4393, 5, 1625, 0, 0, 4391, 4393, 5, 614, 0, 0, + 4392, 4366, 1, 0, 0, 0, 4392, 4367, 1, 0, 0, 0, 4392, 4368, 1, 0, 0, 0, + 4392, 4370, 1, 0, 0, 0, 4392, 4371, 1, 0, 0, 0, 4392, 4372, 1, 0, 0, 0, + 4392, 4373, 1, 0, 0, 0, 4392, 4375, 1, 0, 0, 0, 4392, 4376, 1, 0, 0, 0, + 4392, 4377, 1, 0, 0, 0, 4392, 4378, 1, 0, 0, 0, 4392, 4379, 1, 0, 0, 0, + 4392, 4380, 1, 0, 0, 0, 4392, 4381, 1, 0, 0, 0, 4392, 4382, 1, 0, 0, 0, + 4392, 4383, 1, 0, 0, 0, 4392, 4384, 1, 0, 0, 0, 4392, 4385, 1, 0, 0, 0, + 4392, 4386, 1, 0, 0, 0, 4392, 4387, 1, 0, 0, 0, 4392, 4388, 1, 0, 0, 0, + 4392, 4389, 1, 0, 0, 0, 4392, 4390, 1, 0, 0, 0, 4392, 4391, 1, 0, 0, 0, + 4393, 227, 1, 0, 0, 0, 4394, 4399, 3, 230, 115, 0, 4395, 4396, 5, 1307, + 0, 0, 4396, 4398, 3, 230, 115, 0, 4397, 4395, 1, 0, 0, 0, 4398, 4401, 1, + 0, 0, 0, 4399, 4397, 1, 0, 0, 0, 4399, 4400, 1, 0, 0, 0, 4400, 4402, 1, + 0, 0, 0, 4401, 4399, 1, 0, 0, 0, 4402, 4404, 5, 1259, 0, 0, 4403, 4405, + 3, 232, 116, 0, 4404, 4403, 1, 0, 0, 0, 4404, 4405, 1, 0, 0, 0, 4405, 4406, + 1, 0, 0, 0, 4406, 4407, 3, 2342, 1171, 0, 4407, 229, 1, 0, 0, 0, 4408, + 4411, 7, 37, 0, 0, 4409, 4410, 5, 1246, 0, 0, 4410, 4412, 3, 2358, 1179, + 0, 4411, 4409, 1, 0, 0, 0, 4411, 4412, 1, 0, 0, 0, 4412, 231, 1, 0, 0, + 0, 4413, 4414, 5, 1013, 0, 0, 4414, 4415, 5, 2083, 0, 0, 4415, 4416, 3, + 2342, 1171, 0, 4416, 4417, 5, 1246, 0, 0, 4417, 233, 1, 0, 0, 0, 4418, + 4419, 5, 1529, 0, 0, 4419, 4422, 3, 236, 118, 0, 4420, 4422, 5, 1528, 0, + 0, 4421, 4418, 1, 0, 0, 0, 4421, 4420, 1, 0, 0, 0, 4422, 4426, 1, 0, 0, + 0, 4423, 4425, 3, 236, 118, 0, 4424, 4423, 1, 0, 0, 0, 4425, 4428, 1, 0, + 0, 0, 4426, 4424, 1, 0, 0, 0, 4426, 4427, 1, 0, 0, 0, 4427, 235, 1, 0, + 0, 0, 4428, 4426, 1, 0, 0, 0, 4429, 4430, 7, 38, 0, 0, 4430, 4431, 3, 2268, + 1134, 0, 4431, 237, 1, 0, 0, 0, 4432, 4433, 5, 469, 0, 0, 4433, 4435, 5, + 2166, 0, 0, 4434, 4436, 5, 147, 0, 0, 4435, 4434, 1, 0, 0, 0, 4435, 4436, + 1, 0, 0, 0, 4436, 4437, 1, 0, 0, 0, 4437, 4439, 3, 2314, 1157, 0, 4438, + 4440, 7, 39, 0, 0, 4439, 4438, 1, 0, 0, 0, 4439, 4440, 1, 0, 0, 0, 4440, + 239, 1, 0, 0, 0, 4441, 4442, 5, 42, 0, 0, 4442, 4443, 5, 2166, 0, 0, 4443, + 4450, 3, 2314, 1157, 0, 4444, 4451, 3, 242, 121, 0, 4445, 4451, 3, 244, + 122, 0, 4446, 4451, 3, 246, 123, 0, 4447, 4451, 3, 250, 125, 0, 4448, 4451, + 3, 284, 142, 0, 4449, 4451, 3, 296, 148, 0, 4450, 4444, 1, 0, 0, 0, 4450, + 4445, 1, 0, 0, 0, 4450, 4446, 1, 0, 0, 0, 4450, 4447, 1, 0, 0, 0, 4450, + 4448, 1, 0, 0, 0, 4450, 4449, 1, 0, 0, 0, 4451, 4453, 1, 0, 0, 0, 4452, + 4454, 3, 252, 126, 0, 4453, 4452, 1, 0, 0, 0, 4453, 4454, 1, 0, 0, 0, 4454, + 241, 1, 0, 0, 0, 4455, 4457, 5, 249, 0, 0, 4456, 4458, 5, 378, 0, 0, 4457, + 4456, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458, 4460, 1, 0, 0, 0, 4459, + 4461, 7, 40, 0, 0, 4460, 4459, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, + 4465, 1, 0, 0, 0, 4462, 4464, 3, 812, 406, 0, 4463, 4462, 1, 0, 0, 0, 4464, + 4467, 1, 0, 0, 0, 4465, 4463, 1, 0, 0, 0, 4465, 4466, 1, 0, 0, 0, 4466, + 4470, 1, 0, 0, 0, 4467, 4465, 1, 0, 0, 0, 4468, 4469, 5, 1587, 0, 0, 4469, + 4471, 5, 1673, 0, 0, 4470, 4468, 1, 0, 0, 0, 4470, 4471, 1, 0, 0, 0, 4471, + 243, 1, 0, 0, 0, 4472, 4474, 5, 1562, 0, 0, 4473, 4475, 3, 1720, 860, 0, + 4474, 4473, 1, 0, 0, 0, 4474, 4475, 1, 0, 0, 0, 4475, 4476, 1, 0, 0, 0, + 4476, 4477, 5, 69, 0, 0, 4477, 4478, 5, 1238, 0, 0, 4478, 4479, 5, 2447, + 0, 0, 4479, 4484, 3, 286, 143, 0, 4480, 4481, 5, 2453, 0, 0, 4481, 4483, + 3, 286, 143, 0, 4482, 4480, 1, 0, 0, 0, 4483, 4486, 1, 0, 0, 0, 4484, 4482, + 1, 0, 0, 0, 4484, 4485, 1, 0, 0, 0, 4485, 4487, 1, 0, 0, 0, 4486, 4484, + 1, 0, 0, 0, 4487, 4488, 5, 2448, 0, 0, 4488, 245, 1, 0, 0, 0, 4489, 4494, + 3, 248, 124, 0, 4490, 4491, 5, 2453, 0, 0, 4491, 4493, 3, 248, 124, 0, + 4492, 4490, 1, 0, 0, 0, 4493, 4496, 1, 0, 0, 0, 4494, 4492, 1, 0, 0, 0, + 4494, 4495, 1, 0, 0, 0, 4495, 247, 1, 0, 0, 0, 4496, 4494, 1, 0, 0, 0, + 4497, 4500, 7, 9, 0, 0, 4498, 4501, 3, 308, 154, 0, 4499, 4501, 3, 294, + 147, 0, 4500, 4498, 1, 0, 0, 0, 4500, 4499, 1, 0, 0, 0, 4501, 249, 1, 0, + 0, 0, 4502, 4508, 5, 980, 0, 0, 4503, 4504, 5, 858, 0, 0, 4504, 4509, 3, + 2078, 1039, 0, 4505, 4506, 5, 486, 0, 0, 4506, 4507, 5, 2166, 0, 0, 4507, + 4509, 3, 2374, 1187, 0, 4508, 4503, 1, 0, 0, 0, 4508, 4505, 1, 0, 0, 0, + 4509, 251, 1, 0, 0, 0, 4510, 4527, 5, 780, 0, 0, 4511, 4521, 5, 179, 0, + 0, 4512, 4513, 5, 300, 0, 0, 4513, 4514, 5, 2141, 0, 0, 4514, 4522, 5, + 1780, 0, 0, 4515, 4517, 5, 1204, 0, 0, 4516, 4515, 1, 0, 0, 0, 4516, 4517, + 1, 0, 0, 0, 4517, 4518, 1, 0, 0, 0, 4518, 4519, 5, 705, 0, 0, 4519, 4520, + 5, 2083, 0, 0, 4520, 4522, 5, 351, 0, 0, 4521, 4512, 1, 0, 0, 0, 4521, + 4516, 1, 0, 0, 0, 4521, 4522, 1, 0, 0, 0, 4522, 4524, 1, 0, 0, 0, 4523, + 4525, 3, 254, 127, 0, 4524, 4523, 1, 0, 0, 0, 4524, 4525, 1, 0, 0, 0, 4525, + 4527, 1, 0, 0, 0, 4526, 4510, 1, 0, 0, 0, 4526, 4511, 1, 0, 0, 0, 4527, + 253, 1, 0, 0, 0, 4528, 4530, 5, 616, 0, 0, 4529, 4528, 1, 0, 0, 0, 4529, + 4530, 1, 0, 0, 0, 4530, 4531, 1, 0, 0, 0, 4531, 4532, 5, 537, 0, 0, 4532, + 4533, 5, 779, 0, 0, 4533, 4534, 3, 2342, 1171, 0, 4534, 255, 1, 0, 0, 0, + 4535, 4538, 5, 321, 0, 0, 4536, 4537, 5, 1307, 0, 0, 4537, 4539, 5, 1562, + 0, 0, 4538, 4536, 1, 0, 0, 0, 4538, 4539, 1, 0, 0, 0, 4539, 4541, 1, 0, + 0, 0, 4540, 4542, 7, 20, 0, 0, 4541, 4540, 1, 0, 0, 0, 4541, 4542, 1, 0, + 0, 0, 4542, 4543, 1, 0, 0, 0, 4543, 4546, 5, 2166, 0, 0, 4544, 4547, 3, + 258, 129, 0, 4545, 4547, 3, 270, 135, 0, 4546, 4544, 1, 0, 0, 0, 4546, + 4545, 1, 0, 0, 0, 4547, 257, 1, 0, 0, 0, 4548, 4551, 3, 2314, 1157, 0, + 4549, 4550, 5, 1248, 0, 0, 4550, 4552, 5, 2443, 0, 0, 4551, 4549, 1, 0, + 0, 0, 4551, 4552, 1, 0, 0, 0, 4552, 4554, 1, 0, 0, 0, 4553, 4555, 5, 616, + 0, 0, 4554, 4553, 1, 0, 0, 0, 4554, 4555, 1, 0, 0, 0, 4555, 4557, 1, 0, + 0, 0, 4556, 4558, 3, 260, 130, 0, 4557, 4556, 1, 0, 0, 0, 4557, 4558, 1, + 0, 0, 0, 4558, 259, 1, 0, 0, 0, 4559, 4561, 3, 1720, 860, 0, 4560, 4559, + 1, 0, 0, 0, 4560, 4561, 1, 0, 0, 0, 4561, 4564, 1, 0, 0, 0, 4562, 4565, + 3, 262, 131, 0, 4563, 4565, 3, 264, 132, 0, 4564, 4562, 1, 0, 0, 0, 4564, + 4563, 1, 0, 0, 0, 4565, 4567, 1, 0, 0, 0, 4566, 4568, 3, 268, 134, 0, 4567, + 4566, 1, 0, 0, 0, 4567, 4568, 1, 0, 0, 0, 4568, 4580, 1, 0, 0, 0, 4569, + 4570, 5, 2447, 0, 0, 4570, 4575, 3, 286, 143, 0, 4571, 4572, 5, 2453, 0, + 0, 4572, 4574, 3, 286, 143, 0, 4573, 4571, 1, 0, 0, 0, 4574, 4577, 1, 0, + 0, 0, 4575, 4573, 1, 0, 0, 0, 4575, 4576, 1, 0, 0, 0, 4576, 4578, 1, 0, + 0, 0, 4577, 4575, 1, 0, 0, 0, 4578, 4579, 5, 2448, 0, 0, 4579, 4581, 1, + 0, 0, 0, 4580, 4569, 1, 0, 0, 0, 4580, 4581, 1, 0, 0, 0, 4581, 4585, 1, + 0, 0, 0, 4582, 4584, 3, 284, 142, 0, 4583, 4582, 1, 0, 0, 0, 4584, 4587, + 1, 0, 0, 0, 4585, 4583, 1, 0, 0, 0, 4585, 4586, 1, 0, 0, 0, 4586, 261, + 1, 0, 0, 0, 4587, 4585, 1, 0, 0, 0, 4588, 4592, 7, 22, 0, 0, 4589, 4593, + 5, 1238, 0, 0, 4590, 4593, 3, 1768, 884, 0, 4591, 4593, 3, 266, 133, 0, + 4592, 4589, 1, 0, 0, 0, 4592, 4590, 1, 0, 0, 0, 4592, 4591, 1, 0, 0, 0, + 4593, 263, 1, 0, 0, 0, 4594, 4595, 5, 2177, 0, 0, 4595, 4596, 3, 2374, + 1187, 0, 4596, 265, 1, 0, 0, 0, 4597, 4598, 5, 2083, 0, 0, 4598, 4599, + 5, 1246, 0, 0, 4599, 4602, 3, 2374, 1187, 0, 4600, 4601, 5, 1204, 0, 0, + 4601, 4603, 5, 1228, 0, 0, 4602, 4600, 1, 0, 0, 0, 4602, 4603, 1, 0, 0, + 0, 4603, 267, 1, 0, 0, 0, 4604, 4605, 5, 560, 0, 0, 4605, 4606, 5, 997, + 0, 0, 4606, 4607, 3, 2078, 1039, 0, 4607, 4608, 5, 823, 0, 0, 4608, 4609, + 5, 792, 0, 0, 4609, 4610, 5, 2246, 0, 0, 4610, 4611, 7, 41, 0, 0, 4611, + 269, 1, 0, 0, 0, 4612, 4613, 5, 147, 0, 0, 4613, 4614, 3, 2314, 1157, 0, + 4614, 4616, 7, 22, 0, 0, 4615, 4617, 3, 272, 136, 0, 4616, 4615, 1, 0, + 0, 0, 4617, 4618, 1, 0, 0, 0, 4618, 4616, 1, 0, 0, 0, 4618, 4619, 1, 0, + 0, 0, 4619, 4620, 1, 0, 0, 0, 4620, 4621, 5, 508, 0, 0, 4621, 271, 1, 0, + 0, 0, 4622, 4626, 3, 274, 137, 0, 4623, 4626, 3, 276, 138, 0, 4624, 4626, + 3, 296, 148, 0, 4625, 4622, 1, 0, 0, 0, 4625, 4623, 1, 0, 0, 0, 4625, 4624, + 1, 0, 0, 0, 4626, 273, 1, 0, 0, 0, 4627, 4628, 7, 42, 0, 0, 4628, 4629, + 5, 936, 0, 0, 4629, 4630, 3, 280, 140, 0, 4630, 275, 1, 0, 0, 0, 4631, + 4633, 7, 43, 0, 0, 4632, 4631, 1, 0, 0, 0, 4632, 4633, 1, 0, 0, 0, 4633, + 4637, 1, 0, 0, 0, 4634, 4638, 3, 278, 139, 0, 4635, 4638, 3, 280, 140, + 0, 4636, 4638, 3, 282, 141, 0, 4637, 4634, 1, 0, 0, 0, 4637, 4635, 1, 0, + 0, 0, 4637, 4636, 1, 0, 0, 0, 4638, 277, 1, 0, 0, 0, 4639, 4640, 5, 1461, + 0, 0, 4640, 4652, 3, 2322, 1161, 0, 4641, 4642, 5, 2447, 0, 0, 4642, 4647, + 3, 314, 157, 0, 4643, 4644, 5, 2453, 0, 0, 4644, 4646, 3, 314, 157, 0, + 4645, 4643, 1, 0, 0, 0, 4646, 4649, 1, 0, 0, 0, 4647, 4645, 1, 0, 0, 0, + 4647, 4648, 1, 0, 0, 0, 4648, 4650, 1, 0, 0, 0, 4649, 4647, 1, 0, 0, 0, + 4650, 4651, 5, 2448, 0, 0, 4651, 4653, 1, 0, 0, 0, 4652, 4641, 1, 0, 0, + 0, 4652, 4653, 1, 0, 0, 0, 4653, 4654, 1, 0, 0, 0, 4654, 4665, 7, 22, 0, + 0, 4655, 4666, 3, 1722, 861, 0, 4656, 4658, 5, 382, 0, 0, 4657, 4656, 1, + 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4660, 1, 0, 0, 0, 4659, 4661, 3, + 1740, 870, 0, 4660, 4659, 1, 0, 0, 0, 4660, 4661, 1, 0, 0, 0, 4661, 4662, + 1, 0, 0, 0, 4662, 4663, 3, 1820, 910, 0, 4663, 4664, 5, 2470, 0, 0, 4664, + 4666, 1, 0, 0, 0, 4665, 4655, 1, 0, 0, 0, 4665, 4657, 1, 0, 0, 0, 4666, + 279, 1, 0, 0, 0, 4667, 4668, 5, 632, 0, 0, 4668, 4680, 3, 2320, 1160, 0, + 4669, 4670, 5, 2447, 0, 0, 4670, 4675, 3, 314, 157, 0, 4671, 4672, 5, 2453, + 0, 0, 4672, 4674, 3, 314, 157, 0, 4673, 4671, 1, 0, 0, 0, 4674, 4677, 1, + 0, 0, 0, 4675, 4673, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4678, 1, + 0, 0, 0, 4677, 4675, 1, 0, 0, 0, 4678, 4679, 5, 2448, 0, 0, 4679, 4681, + 1, 0, 0, 0, 4680, 4669, 1, 0, 0, 0, 4680, 4681, 1, 0, 0, 0, 4681, 4682, + 1, 0, 0, 0, 4682, 4683, 5, 1586, 0, 0, 4683, 4684, 3, 2374, 1187, 0, 4684, + 4695, 7, 22, 0, 0, 4685, 4696, 3, 1722, 861, 0, 4686, 4688, 5, 382, 0, + 0, 4687, 4686, 1, 0, 0, 0, 4687, 4688, 1, 0, 0, 0, 4688, 4690, 1, 0, 0, + 0, 4689, 4691, 3, 1740, 870, 0, 4690, 4689, 1, 0, 0, 0, 4690, 4691, 1, + 0, 0, 0, 4691, 4692, 1, 0, 0, 0, 4692, 4693, 3, 1820, 910, 0, 4693, 4694, + 5, 2470, 0, 0, 4694, 4696, 1, 0, 0, 0, 4695, 4685, 1, 0, 0, 0, 4695, 4687, + 1, 0, 0, 0, 4696, 281, 1, 0, 0, 0, 4697, 4699, 5, 595, 0, 0, 4698, 4697, + 1, 0, 0, 0, 4698, 4699, 1, 0, 0, 0, 4699, 4701, 1, 0, 0, 0, 4700, 4702, + 5, 761, 0, 0, 4701, 4700, 1, 0, 0, 0, 4701, 4702, 1, 0, 0, 0, 4702, 4703, + 1, 0, 0, 0, 4703, 4704, 5, 288, 0, 0, 4704, 4705, 5, 632, 0, 0, 4705, 4726, + 3, 2320, 1160, 0, 4706, 4713, 5, 2447, 0, 0, 4707, 4708, 5, 1648, 0, 0, + 4708, 4709, 5, 738, 0, 0, 4709, 4710, 5, 1318, 0, 0, 4710, 4711, 3, 2374, + 1187, 0, 4711, 4712, 5, 2453, 0, 0, 4712, 4714, 1, 0, 0, 0, 4713, 4707, + 1, 0, 0, 0, 4713, 4714, 1, 0, 0, 0, 4714, 4723, 1, 0, 0, 0, 4715, 4720, + 3, 314, 157, 0, 4716, 4717, 5, 2453, 0, 0, 4717, 4719, 3, 314, 157, 0, + 4718, 4716, 1, 0, 0, 0, 4719, 4722, 1, 0, 0, 0, 4720, 4718, 1, 0, 0, 0, + 4720, 4721, 1, 0, 0, 0, 4721, 4724, 1, 0, 0, 0, 4722, 4720, 1, 0, 0, 0, + 4723, 4715, 1, 0, 0, 0, 4723, 4724, 1, 0, 0, 0, 4724, 4725, 1, 0, 0, 0, + 4725, 4727, 5, 2448, 0, 0, 4726, 4706, 1, 0, 0, 0, 4726, 4727, 1, 0, 0, + 0, 4727, 4728, 1, 0, 0, 0, 4728, 4729, 5, 1586, 0, 0, 4729, 4730, 5, 1648, + 0, 0, 4730, 4731, 5, 69, 0, 0, 4731, 4732, 5, 1580, 0, 0, 4732, 4743, 7, + 22, 0, 0, 4733, 4744, 3, 1722, 861, 0, 4734, 4736, 5, 382, 0, 0, 4735, + 4734, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4738, 1, 0, 0, 0, 4737, + 4739, 3, 1740, 870, 0, 4738, 4737, 1, 0, 0, 0, 4738, 4739, 1, 0, 0, 0, + 4739, 4740, 1, 0, 0, 0, 4740, 4741, 3, 1820, 910, 0, 4741, 4742, 5, 2470, + 0, 0, 4742, 4744, 1, 0, 0, 0, 4743, 4733, 1, 0, 0, 0, 4743, 4735, 1, 0, + 0, 0, 4744, 283, 1, 0, 0, 0, 4745, 4747, 5, 1204, 0, 0, 4746, 4745, 1, + 0, 0, 0, 4746, 4747, 1, 0, 0, 0, 4747, 4748, 1, 0, 0, 0, 4748, 4749, 7, + 44, 0, 0, 4749, 285, 1, 0, 0, 0, 4750, 4751, 3, 2402, 1201, 0, 4751, 4753, + 3, 2374, 1187, 0, 4752, 4754, 3, 288, 144, 0, 4753, 4752, 1, 0, 0, 0, 4753, + 4754, 1, 0, 0, 0, 4754, 4757, 1, 0, 0, 0, 4755, 4757, 3, 290, 145, 0, 4756, + 4750, 1, 0, 0, 0, 4756, 4755, 1, 0, 0, 0, 4757, 287, 1, 0, 0, 0, 4758, + 4759, 5, 560, 0, 0, 4759, 4760, 5, 997, 0, 0, 4760, 4761, 3, 2078, 1039, + 0, 4761, 289, 1, 0, 0, 0, 4762, 4764, 3, 284, 142, 0, 4763, 4762, 1, 0, + 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4766, 1, 0, 0, 0, 4765, 4767, 3, 292, + 146, 0, 4766, 4765, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4766, 1, + 0, 0, 0, 4768, 4769, 1, 0, 0, 0, 4769, 4772, 1, 0, 0, 0, 4770, 4771, 5, + 2453, 0, 0, 4771, 4773, 3, 310, 155, 0, 4772, 4770, 1, 0, 0, 0, 4772, 4773, + 1, 0, 0, 0, 4773, 291, 1, 0, 0, 0, 4774, 4778, 3, 294, 147, 0, 4775, 4778, + 3, 306, 153, 0, 4776, 4778, 3, 308, 154, 0, 4777, 4774, 1, 0, 0, 0, 4777, + 4775, 1, 0, 0, 0, 4777, 4776, 1, 0, 0, 0, 4778, 293, 1, 0, 0, 0, 4779, + 4782, 7, 43, 0, 0, 4780, 4783, 3, 302, 151, 0, 4781, 4783, 3, 304, 152, + 0, 4782, 4780, 1, 0, 0, 0, 4782, 4781, 1, 0, 0, 0, 4783, 295, 1, 0, 0, + 0, 4784, 4785, 5, 1324, 0, 0, 4785, 4786, 5, 936, 0, 0, 4786, 4791, 3, + 298, 149, 0, 4787, 4788, 5, 1324, 0, 0, 4788, 4789, 5, 936, 0, 0, 4789, + 4791, 3, 300, 150, 0, 4790, 4784, 1, 0, 0, 0, 4790, 4787, 1, 0, 0, 0, 4791, + 297, 1, 0, 0, 0, 4792, 4793, 5, 632, 0, 0, 4793, 4805, 3, 2320, 1160, 0, + 4794, 4795, 5, 2447, 0, 0, 4795, 4800, 3, 314, 157, 0, 4796, 4797, 5, 2453, + 0, 0, 4797, 4799, 3, 314, 157, 0, 4798, 4796, 1, 0, 0, 0, 4799, 4802, 1, + 0, 0, 0, 4800, 4798, 1, 0, 0, 0, 4800, 4801, 1, 0, 0, 0, 4801, 4803, 1, + 0, 0, 0, 4802, 4800, 1, 0, 0, 0, 4803, 4804, 5, 2448, 0, 0, 4804, 4806, + 1, 0, 0, 0, 4805, 4794, 1, 0, 0, 0, 4805, 4806, 1, 0, 0, 0, 4806, 4807, + 1, 0, 0, 0, 4807, 4812, 5, 1586, 0, 0, 4808, 4813, 3, 2374, 1187, 0, 4809, + 4810, 5, 1648, 0, 0, 4810, 4811, 5, 69, 0, 0, 4811, 4813, 5, 1580, 0, 0, + 4812, 4808, 1, 0, 0, 0, 4812, 4809, 1, 0, 0, 0, 4813, 4825, 1, 0, 0, 0, + 4814, 4816, 5, 1394, 0, 0, 4815, 4814, 1, 0, 0, 0, 4815, 4816, 1, 0, 0, + 0, 4816, 4817, 1, 0, 0, 0, 4817, 4819, 7, 22, 0, 0, 4818, 4820, 5, 382, + 0, 0, 4819, 4818, 1, 0, 0, 0, 4819, 4820, 1, 0, 0, 0, 4820, 4822, 1, 0, + 0, 0, 4821, 4823, 3, 1740, 870, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, + 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 3, 1820, 910, 0, 4825, + 4815, 1, 0, 0, 0, 4825, 4826, 1, 0, 0, 0, 4826, 4828, 1, 0, 0, 0, 4827, + 4829, 5, 2470, 0, 0, 4828, 4827, 1, 0, 0, 0, 4828, 4829, 1, 0, 0, 0, 4829, + 299, 1, 0, 0, 0, 4830, 4831, 5, 1461, 0, 0, 4831, 4843, 3, 2322, 1161, + 0, 4832, 4833, 5, 2447, 0, 0, 4833, 4838, 3, 314, 157, 0, 4834, 4835, 5, + 2453, 0, 0, 4835, 4837, 3, 314, 157, 0, 4836, 4834, 1, 0, 0, 0, 4837, 4840, + 1, 0, 0, 0, 4838, 4836, 1, 0, 0, 0, 4838, 4839, 1, 0, 0, 0, 4839, 4841, + 1, 0, 0, 0, 4840, 4838, 1, 0, 0, 0, 4841, 4842, 5, 2448, 0, 0, 4842, 4844, + 1, 0, 0, 0, 4843, 4832, 1, 0, 0, 0, 4843, 4844, 1, 0, 0, 0, 4844, 4845, + 1, 0, 0, 0, 4845, 4856, 7, 22, 0, 0, 4846, 4857, 3, 1722, 861, 0, 4847, + 4849, 5, 382, 0, 0, 4848, 4847, 1, 0, 0, 0, 4848, 4849, 1, 0, 0, 0, 4849, + 4851, 1, 0, 0, 0, 4850, 4852, 3, 1740, 870, 0, 4851, 4850, 1, 0, 0, 0, + 4851, 4852, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4854, 3, 1820, 910, + 0, 4854, 4855, 5, 2470, 0, 0, 4855, 4857, 1, 0, 0, 0, 4856, 4846, 1, 0, + 0, 0, 4856, 4848, 1, 0, 0, 0, 4857, 301, 1, 0, 0, 0, 4858, 4859, 5, 1461, + 0, 0, 4859, 4871, 3, 2322, 1161, 0, 4860, 4861, 5, 2447, 0, 0, 4861, 4866, + 3, 314, 157, 0, 4862, 4863, 5, 2453, 0, 0, 4863, 4865, 3, 314, 157, 0, + 4864, 4862, 1, 0, 0, 0, 4865, 4868, 1, 0, 0, 0, 4866, 4864, 1, 0, 0, 0, + 4866, 4867, 1, 0, 0, 0, 4867, 4869, 1, 0, 0, 0, 4868, 4866, 1, 0, 0, 0, + 4869, 4870, 5, 2448, 0, 0, 4870, 4872, 1, 0, 0, 0, 4871, 4860, 1, 0, 0, + 0, 4871, 4872, 1, 0, 0, 0, 4872, 4875, 1, 0, 0, 0, 4873, 4874, 7, 22, 0, + 0, 4874, 4876, 3, 1722, 861, 0, 4875, 4873, 1, 0, 0, 0, 4875, 4876, 1, + 0, 0, 0, 4876, 303, 1, 0, 0, 0, 4877, 4878, 5, 632, 0, 0, 4878, 4890, 3, + 2320, 1160, 0, 4879, 4880, 5, 2447, 0, 0, 4880, 4885, 3, 314, 157, 0, 4881, + 4882, 5, 2453, 0, 0, 4882, 4884, 3, 314, 157, 0, 4883, 4881, 1, 0, 0, 0, + 4884, 4887, 1, 0, 0, 0, 4885, 4883, 1, 0, 0, 0, 4885, 4886, 1, 0, 0, 0, + 4886, 4888, 1, 0, 0, 0, 4887, 4885, 1, 0, 0, 0, 4888, 4889, 5, 2448, 0, + 0, 4889, 4891, 1, 0, 0, 0, 4890, 4879, 1, 0, 0, 0, 4890, 4891, 1, 0, 0, + 0, 4891, 4892, 1, 0, 0, 0, 4892, 4897, 5, 1586, 0, 0, 4893, 4898, 3, 2374, + 1187, 0, 4894, 4895, 5, 1648, 0, 0, 4895, 4896, 5, 69, 0, 0, 4896, 4898, + 5, 1580, 0, 0, 4897, 4893, 1, 0, 0, 0, 4897, 4894, 1, 0, 0, 0, 4898, 4907, + 1, 0, 0, 0, 4899, 4900, 7, 22, 0, 0, 4900, 4908, 3, 1722, 861, 0, 4901, + 4903, 5, 560, 0, 0, 4902, 4904, 5, 2262, 0, 0, 4903, 4902, 1, 0, 0, 0, + 4903, 4904, 1, 0, 0, 0, 4904, 4905, 1, 0, 0, 0, 4905, 4906, 5, 997, 0, + 0, 4906, 4908, 3, 2078, 1039, 0, 4907, 4899, 1, 0, 0, 0, 4907, 4901, 1, + 0, 0, 0, 4907, 4908, 1, 0, 0, 0, 4908, 305, 1, 0, 0, 0, 4909, 4911, 5, + 595, 0, 0, 4910, 4909, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4913, + 1, 0, 0, 0, 4912, 4914, 5, 761, 0, 0, 4913, 4912, 1, 0, 0, 0, 4913, 4914, + 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4916, 5, 288, 0, 0, 4916, 4917, + 5, 632, 0, 0, 4917, 4938, 3, 2374, 1187, 0, 4918, 4925, 5, 2447, 0, 0, + 4919, 4920, 5, 1648, 0, 0, 4920, 4921, 5, 738, 0, 0, 4921, 4922, 5, 1318, + 0, 0, 4922, 4923, 3, 2374, 1187, 0, 4923, 4924, 5, 2453, 0, 0, 4924, 4926, + 1, 0, 0, 0, 4925, 4919, 1, 0, 0, 0, 4925, 4926, 1, 0, 0, 0, 4926, 4935, + 1, 0, 0, 0, 4927, 4932, 3, 314, 157, 0, 4928, 4929, 5, 2453, 0, 0, 4929, + 4931, 3, 314, 157, 0, 4930, 4928, 1, 0, 0, 0, 4931, 4934, 1, 0, 0, 0, 4932, + 4930, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 4936, 1, 0, 0, 0, 4934, + 4932, 1, 0, 0, 0, 4935, 4927, 1, 0, 0, 0, 4935, 4936, 1, 0, 0, 0, 4936, + 4937, 1, 0, 0, 0, 4937, 4939, 5, 2448, 0, 0, 4938, 4918, 1, 0, 0, 0, 4938, + 4939, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4941, 5, 1586, 0, 0, 4941, + 4942, 5, 1648, 0, 0, 4942, 4943, 5, 69, 0, 0, 4943, 4946, 5, 1580, 0, 0, + 4944, 4945, 7, 22, 0, 0, 4945, 4947, 3, 1722, 861, 0, 4946, 4944, 1, 0, + 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 307, 1, 0, 0, 0, 4948, 4949, 7, 42, + 0, 0, 4949, 4950, 5, 936, 0, 0, 4950, 4951, 3, 304, 152, 0, 4951, 309, + 1, 0, 0, 0, 4952, 4953, 5, 1433, 0, 0, 4953, 4954, 5, 1577, 0, 0, 4954, + 4955, 5, 2447, 0, 0, 4955, 4960, 3, 312, 156, 0, 4956, 4957, 5, 2453, 0, + 0, 4957, 4959, 3, 312, 156, 0, 4958, 4956, 1, 0, 0, 0, 4959, 4962, 1, 0, + 0, 0, 4960, 4958, 1, 0, 0, 0, 4960, 4961, 1, 0, 0, 0, 4961, 4963, 1, 0, + 0, 0, 4962, 4960, 1, 0, 0, 0, 4963, 4964, 5, 2448, 0, 0, 4964, 311, 1, + 0, 0, 0, 4965, 4968, 3, 2402, 1201, 0, 4966, 4968, 5, 389, 0, 0, 4967, + 4965, 1, 0, 0, 0, 4967, 4966, 1, 0, 0, 0, 4968, 313, 1, 0, 0, 0, 4969, + 4979, 3, 2294, 1147, 0, 4970, 4971, 5, 738, 0, 0, 4971, 4972, 5, 1318, + 0, 0, 4972, 4980, 5, 1080, 0, 0, 4973, 4974, 5, 738, 0, 0, 4974, 4980, + 5, 1318, 0, 0, 4975, 4976, 5, 1318, 0, 0, 4976, 4980, 5, 1080, 0, 0, 4977, + 4980, 5, 1318, 0, 0, 4978, 4980, 5, 738, 0, 0, 4979, 4970, 1, 0, 0, 0, + 4979, 4973, 1, 0, 0, 0, 4979, 4975, 1, 0, 0, 0, 4979, 4977, 1, 0, 0, 0, + 4979, 4978, 1, 0, 0, 0, 4979, 4980, 1, 0, 0, 0, 4980, 4981, 1, 0, 0, 0, + 4981, 4984, 3, 2374, 1187, 0, 4982, 4983, 5, 2457, 0, 0, 4983, 4985, 3, + 2394, 1197, 0, 4984, 4982, 1, 0, 0, 0, 4984, 4985, 1, 0, 0, 0, 4985, 315, + 1, 0, 0, 0, 4986, 4987, 5, 469, 0, 0, 4987, 4988, 5, 1653, 0, 0, 4988, + 4989, 3, 2316, 1158, 0, 4989, 317, 1, 0, 0, 0, 4990, 4991, 5, 42, 0, 0, + 4991, 4992, 5, 1653, 0, 0, 4992, 4994, 3, 2316, 1158, 0, 4993, 4995, 3, + 326, 163, 0, 4994, 4993, 1, 0, 0, 0, 4995, 4996, 1, 0, 0, 0, 4996, 4994, + 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, 319, 1, 0, 0, 0, 4998, 4999, + 5, 42, 0, 0, 4999, 5029, 5, 1667, 0, 0, 5000, 5001, 5, 30, 0, 0, 5001, + 5030, 7, 45, 0, 0, 5002, 5003, 5, 218, 0, 0, 5003, 5004, 5, 350, 0, 0, + 5004, 5005, 5, 861, 0, 0, 5005, 5030, 3, 2294, 1147, 0, 5006, 5007, 3, + 1308, 654, 0, 5007, 5008, 5, 242, 0, 0, 5008, 5009, 5, 738, 0, 0, 5009, + 5010, 5, 1461, 0, 0, 5010, 5030, 1, 0, 0, 0, 5011, 5012, 3, 1308, 654, + 0, 5012, 5013, 5, 656, 0, 0, 5013, 5030, 1, 0, 0, 0, 5014, 5017, 3, 1308, + 654, 0, 5015, 5017, 5, 616, 0, 0, 5016, 5014, 1, 0, 0, 0, 5016, 5015, 1, + 0, 0, 0, 5017, 5018, 1, 0, 0, 0, 5018, 5019, 5, 1333, 0, 0, 5019, 5025, + 7, 46, 0, 0, 5020, 5023, 5, 1333, 0, 0, 5021, 5024, 3, 2186, 1093, 0, 5022, + 5024, 3, 2294, 1147, 0, 5023, 5021, 1, 0, 0, 0, 5023, 5022, 1, 0, 0, 0, + 5024, 5026, 1, 0, 0, 0, 5025, 5020, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, + 5026, 5030, 1, 0, 0, 0, 5027, 5028, 5, 1671, 0, 0, 5028, 5030, 3, 322, + 161, 0, 5029, 5000, 1, 0, 0, 0, 5029, 5002, 1, 0, 0, 0, 5029, 5006, 1, + 0, 0, 0, 5029, 5011, 1, 0, 0, 0, 5029, 5016, 1, 0, 0, 0, 5029, 5027, 1, + 0, 0, 0, 5030, 321, 1, 0, 0, 0, 5031, 5032, 3, 2294, 1147, 0, 5032, 5033, + 5, 2472, 0, 0, 5033, 5034, 3, 814, 407, 0, 5034, 5036, 1, 0, 0, 0, 5035, + 5031, 1, 0, 0, 0, 5036, 5037, 1, 0, 0, 0, 5037, 5035, 1, 0, 0, 0, 5037, + 5038, 1, 0, 0, 0, 5038, 5062, 1, 0, 0, 0, 5039, 5040, 5, 483, 0, 0, 5040, + 5041, 5, 2472, 0, 0, 5041, 5062, 3, 2404, 1202, 0, 5042, 5043, 5, 289, + 0, 0, 5043, 5044, 5, 2472, 0, 0, 5044, 5048, 3, 2404, 1202, 0, 5045, 5046, + 5, 1664, 0, 0, 5046, 5047, 5, 2472, 0, 0, 5047, 5049, 3, 2404, 1202, 0, + 5048, 5045, 1, 0, 0, 0, 5048, 5049, 1, 0, 0, 0, 5049, 5062, 1, 0, 0, 0, + 5050, 5051, 5, 1606, 0, 0, 5051, 5052, 5, 63, 0, 0, 5052, 5053, 5, 2289, + 0, 0, 5053, 5054, 5, 2472, 0, 0, 5054, 5062, 7, 47, 0, 0, 5055, 5056, 5, + 392, 0, 0, 5056, 5059, 5, 2472, 0, 0, 5057, 5060, 3, 2404, 1202, 0, 5058, + 5060, 5, 1133, 0, 0, 5059, 5057, 1, 0, 0, 0, 5059, 5058, 1, 0, 0, 0, 5060, + 5062, 1, 0, 0, 0, 5061, 5035, 1, 0, 0, 0, 5061, 5039, 1, 0, 0, 0, 5061, + 5042, 1, 0, 0, 0, 5061, 5050, 1, 0, 0, 0, 5061, 5055, 1, 0, 0, 0, 5062, + 323, 1, 0, 0, 0, 5063, 5064, 5, 321, 0, 0, 5064, 5068, 5, 1653, 0, 0, 5065, + 5066, 5, 691, 0, 0, 5066, 5067, 5, 1204, 0, 0, 5067, 5069, 5, 545, 0, 0, + 5068, 5065, 1, 0, 0, 0, 5068, 5069, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, + 5070, 5074, 3, 2316, 1158, 0, 5071, 5073, 3, 326, 163, 0, 5072, 5071, 1, + 0, 0, 0, 5073, 5076, 1, 0, 0, 0, 5074, 5072, 1, 0, 0, 0, 5074, 5075, 1, + 0, 0, 0, 5075, 5080, 1, 0, 0, 0, 5076, 5074, 1, 0, 0, 0, 5077, 5078, 5, + 1681, 0, 0, 5078, 5079, 5, 2472, 0, 0, 5079, 5081, 7, 48, 0, 0, 5080, 5077, + 1, 0, 0, 0, 5080, 5081, 1, 0, 0, 0, 5081, 325, 1, 0, 0, 0, 5082, 5083, + 5, 707, 0, 0, 5083, 5084, 5, 160, 0, 0, 5084, 5114, 5, 2441, 0, 0, 5085, + 5114, 3, 328, 164, 0, 5086, 5087, 5, 932, 0, 0, 5087, 5114, 5, 2441, 0, + 0, 5088, 5114, 5, 1121, 0, 0, 5089, 5090, 5, 960, 0, 0, 5090, 5114, 5, + 2441, 0, 0, 5091, 5114, 5, 1124, 0, 0, 5092, 5114, 5, 348, 0, 0, 5093, + 5114, 5, 1084, 0, 0, 5094, 5095, 5, 166, 0, 0, 5095, 5114, 5, 2441, 0, + 0, 5096, 5114, 5, 1066, 0, 0, 5097, 5114, 5, 1303, 0, 0, 5098, 5114, 5, + 1140, 0, 0, 5099, 5114, 5, 814, 0, 0, 5100, 5114, 5, 1114, 0, 0, 5101, + 5103, 5, 1620, 0, 0, 5102, 5104, 7, 49, 0, 0, 5103, 5102, 1, 0, 0, 0, 5103, + 5104, 1, 0, 0, 0, 5104, 5114, 1, 0, 0, 0, 5105, 5114, 5, 1181, 0, 0, 5106, + 5108, 5, 1676, 0, 0, 5107, 5109, 7, 49, 0, 0, 5108, 5107, 1, 0, 0, 0, 5108, + 5109, 1, 0, 0, 0, 5109, 5114, 1, 0, 0, 0, 5110, 5114, 5, 1187, 0, 0, 5111, + 5114, 5, 1667, 0, 0, 5112, 5114, 5, 642, 0, 0, 5113, 5082, 1, 0, 0, 0, + 5113, 5085, 1, 0, 0, 0, 5113, 5086, 1, 0, 0, 0, 5113, 5088, 1, 0, 0, 0, + 5113, 5089, 1, 0, 0, 0, 5113, 5091, 1, 0, 0, 0, 5113, 5092, 1, 0, 0, 0, + 5113, 5093, 1, 0, 0, 0, 5113, 5094, 1, 0, 0, 0, 5113, 5096, 1, 0, 0, 0, + 5113, 5097, 1, 0, 0, 0, 5113, 5098, 1, 0, 0, 0, 5113, 5099, 1, 0, 0, 0, + 5113, 5100, 1, 0, 0, 0, 5113, 5101, 1, 0, 0, 0, 5113, 5105, 1, 0, 0, 0, + 5113, 5106, 1, 0, 0, 0, 5113, 5110, 1, 0, 0, 0, 5113, 5111, 1, 0, 0, 0, + 5113, 5112, 1, 0, 0, 0, 5114, 327, 1, 0, 0, 0, 5115, 5116, 5, 1737, 0, + 0, 5116, 5117, 5, 2308, 0, 0, 5117, 5118, 7, 50, 0, 0, 5118, 329, 1, 0, + 0, 0, 5119, 5122, 5, 321, 0, 0, 5120, 5121, 5, 1307, 0, 0, 5121, 5123, + 5, 1562, 0, 0, 5122, 5120, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, 0, 5123, 5125, + 1, 0, 0, 0, 5124, 5126, 7, 7, 0, 0, 5125, 5124, 1, 0, 0, 0, 5125, 5126, + 1, 0, 0, 0, 5126, 5127, 1, 0, 0, 0, 5127, 5128, 5, 45, 0, 0, 5128, 5129, + 5, 2286, 0, 0, 5129, 5133, 3, 2404, 1202, 0, 5130, 5131, 5, 1681, 0, 0, + 5131, 5132, 5, 2472, 0, 0, 5132, 5134, 7, 21, 0, 0, 5133, 5130, 1, 0, 0, + 0, 5133, 5134, 1, 0, 0, 0, 5134, 5138, 1, 0, 0, 0, 5135, 5137, 3, 332, + 166, 0, 5136, 5135, 1, 0, 0, 0, 5137, 5140, 1, 0, 0, 0, 5138, 5136, 1, + 0, 0, 0, 5138, 5139, 1, 0, 0, 0, 5139, 5142, 1, 0, 0, 0, 5140, 5138, 1, + 0, 0, 0, 5141, 5143, 3, 342, 171, 0, 5142, 5141, 1, 0, 0, 0, 5142, 5143, + 1, 0, 0, 0, 5143, 5145, 1, 0, 0, 0, 5144, 5146, 3, 344, 172, 0, 5145, 5144, + 1, 0, 0, 0, 5145, 5146, 1, 0, 0, 0, 5146, 5148, 1, 0, 0, 0, 5147, 5149, + 3, 352, 176, 0, 5148, 5147, 1, 0, 0, 0, 5148, 5149, 1, 0, 0, 0, 5149, 5151, + 1, 0, 0, 0, 5150, 5152, 3, 362, 181, 0, 5151, 5150, 1, 0, 0, 0, 5151, 5152, + 1, 0, 0, 0, 5152, 5154, 1, 0, 0, 0, 5153, 5155, 3, 364, 182, 0, 5154, 5153, + 1, 0, 0, 0, 5154, 5155, 1, 0, 0, 0, 5155, 5157, 1, 0, 0, 0, 5156, 5158, + 3, 366, 183, 0, 5157, 5156, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, 0, 5158, 5160, + 1, 0, 0, 0, 5159, 5161, 3, 376, 188, 0, 5160, 5159, 1, 0, 0, 0, 5160, 5161, + 1, 0, 0, 0, 5161, 5163, 1, 0, 0, 0, 5162, 5164, 3, 378, 189, 0, 5163, 5162, + 1, 0, 0, 0, 5163, 5164, 1, 0, 0, 0, 5164, 331, 1, 0, 0, 0, 5165, 5167, + 3, 334, 167, 0, 5166, 5168, 3, 336, 168, 0, 5167, 5166, 1, 0, 0, 0, 5167, + 5168, 1, 0, 0, 0, 5168, 5174, 1, 0, 0, 0, 5169, 5171, 3, 334, 167, 0, 5170, + 5169, 1, 0, 0, 0, 5170, 5171, 1, 0, 0, 0, 5171, 5172, 1, 0, 0, 0, 5172, + 5174, 3, 336, 168, 0, 5173, 5165, 1, 0, 0, 0, 5173, 5170, 1, 0, 0, 0, 5174, + 5178, 1, 0, 0, 0, 5175, 5177, 3, 338, 169, 0, 5176, 5175, 1, 0, 0, 0, 5177, + 5180, 1, 0, 0, 0, 5178, 5176, 1, 0, 0, 0, 5178, 5179, 1, 0, 0, 0, 5179, + 5193, 1, 0, 0, 0, 5180, 5178, 1, 0, 0, 0, 5181, 5183, 3, 334, 167, 0, 5182, + 5181, 1, 0, 0, 0, 5182, 5183, 1, 0, 0, 0, 5183, 5185, 1, 0, 0, 0, 5184, + 5186, 3, 336, 168, 0, 5185, 5184, 1, 0, 0, 0, 5185, 5186, 1, 0, 0, 0, 5186, + 5188, 1, 0, 0, 0, 5187, 5189, 3, 338, 169, 0, 5188, 5187, 1, 0, 0, 0, 5189, + 5190, 1, 0, 0, 0, 5190, 5188, 1, 0, 0, 0, 5190, 5191, 1, 0, 0, 0, 5191, + 5193, 1, 0, 0, 0, 5192, 5173, 1, 0, 0, 0, 5192, 5182, 1, 0, 0, 0, 5193, + 333, 1, 0, 0, 0, 5194, 5195, 5, 177, 0, 0, 5195, 5196, 3, 2400, 1200, 0, + 5196, 335, 1, 0, 0, 0, 5197, 5198, 5, 415, 0, 0, 5198, 5199, 3, 2400, 1200, + 0, 5199, 337, 1, 0, 0, 0, 5200, 5201, 5, 207, 0, 0, 5201, 5204, 3, 2404, + 1202, 0, 5202, 5203, 5, 2258, 0, 0, 5203, 5205, 3, 2400, 1200, 0, 5204, + 5202, 1, 0, 0, 0, 5204, 5205, 1, 0, 0, 0, 5205, 5208, 1, 0, 0, 0, 5206, + 5207, 5, 823, 0, 0, 5207, 5209, 3, 340, 170, 0, 5208, 5206, 1, 0, 0, 0, + 5208, 5209, 1, 0, 0, 0, 5209, 339, 1, 0, 0, 0, 5210, 5213, 5, 1228, 0, + 0, 5211, 5213, 3, 2404, 1202, 0, 5212, 5210, 1, 0, 0, 0, 5212, 5211, 1, + 0, 0, 0, 5213, 341, 1, 0, 0, 0, 5214, 5218, 5, 2246, 0, 0, 5215, 5216, + 3, 2286, 1143, 0, 5216, 5217, 5, 2440, 0, 0, 5217, 5219, 1, 0, 0, 0, 5218, + 5215, 1, 0, 0, 0, 5218, 5219, 1, 0, 0, 0, 5219, 5220, 1, 0, 0, 0, 5220, + 5222, 3, 2404, 1202, 0, 5221, 5223, 5, 1556, 0, 0, 5222, 5221, 1, 0, 0, + 0, 5222, 5223, 1, 0, 0, 0, 5223, 5228, 1, 0, 0, 0, 5224, 5226, 5, 69, 0, + 0, 5225, 5224, 1, 0, 0, 0, 5225, 5226, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, + 0, 5227, 5229, 3, 2404, 1202, 0, 5228, 5225, 1, 0, 0, 0, 5228, 5229, 1, + 0, 0, 0, 5229, 343, 1, 0, 0, 0, 5230, 5231, 5, 422, 0, 0, 5231, 5232, 5, + 160, 0, 0, 5232, 5233, 5, 2447, 0, 0, 5233, 5238, 3, 346, 173, 0, 5234, + 5235, 5, 2453, 0, 0, 5235, 5237, 3, 346, 173, 0, 5236, 5234, 1, 0, 0, 0, + 5237, 5240, 1, 0, 0, 0, 5238, 5236, 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, + 5239, 5241, 1, 0, 0, 0, 5240, 5238, 1, 0, 0, 0, 5241, 5242, 5, 2448, 0, + 0, 5242, 345, 1, 0, 0, 0, 5243, 5247, 3, 348, 174, 0, 5244, 5246, 3, 332, + 166, 0, 5245, 5244, 1, 0, 0, 0, 5246, 5249, 1, 0, 0, 0, 5247, 5245, 1, + 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, 5250, 1, 0, 0, 0, 5249, 5247, 1, + 0, 0, 0, 5250, 5278, 5, 816, 0, 0, 5251, 5255, 5, 2447, 0, 0, 5252, 5253, + 3, 2404, 1202, 0, 5253, 5254, 5, 2440, 0, 0, 5254, 5256, 1, 0, 0, 0, 5255, + 5252, 1, 0, 0, 0, 5255, 5256, 1, 0, 0, 0, 5256, 5257, 1, 0, 0, 0, 5257, + 5267, 3, 2340, 1170, 0, 5258, 5262, 5, 2453, 0, 0, 5259, 5260, 3, 2404, + 1202, 0, 5260, 5261, 5, 2440, 0, 0, 5261, 5263, 1, 0, 0, 0, 5262, 5259, + 1, 0, 0, 0, 5262, 5263, 1, 0, 0, 0, 5263, 5264, 1, 0, 0, 0, 5264, 5266, + 3, 2340, 1170, 0, 5265, 5258, 1, 0, 0, 0, 5266, 5269, 1, 0, 0, 0, 5267, + 5265, 1, 0, 0, 0, 5267, 5268, 1, 0, 0, 0, 5268, 5270, 1, 0, 0, 0, 5269, + 5267, 1, 0, 0, 0, 5270, 5271, 5, 2448, 0, 0, 5271, 5279, 1, 0, 0, 0, 5272, + 5273, 3, 2404, 1202, 0, 5273, 5274, 5, 2440, 0, 0, 5274, 5276, 1, 0, 0, + 0, 5275, 5272, 1, 0, 0, 0, 5275, 5276, 1, 0, 0, 0, 5276, 5277, 1, 0, 0, + 0, 5277, 5279, 3, 2340, 1170, 0, 5278, 5251, 1, 0, 0, 0, 5278, 5275, 1, + 0, 0, 0, 5279, 5280, 1, 0, 0, 0, 5280, 5282, 5, 1528, 0, 0, 5281, 5283, + 5, 445, 0, 0, 5282, 5281, 1, 0, 0, 0, 5282, 5283, 1, 0, 0, 0, 5283, 5292, + 1, 0, 0, 0, 5284, 5285, 5, 2447, 0, 0, 5285, 5286, 3, 2280, 1140, 0, 5286, + 5287, 5, 2453, 0, 0, 5287, 5288, 3, 2280, 1140, 0, 5288, 5289, 1, 0, 0, + 0, 5289, 5290, 5, 2448, 0, 0, 5290, 5293, 1, 0, 0, 0, 5291, 5293, 3, 2280, + 1140, 0, 5292, 5284, 1, 0, 0, 0, 5292, 5291, 1, 0, 0, 0, 5293, 5294, 1, + 0, 0, 0, 5294, 5295, 5, 673, 0, 0, 5295, 5296, 5, 2447, 0, 0, 5296, 5301, + 3, 350, 175, 0, 5297, 5298, 5, 2453, 0, 0, 5298, 5300, 3, 350, 175, 0, + 5299, 5297, 1, 0, 0, 0, 5300, 5303, 1, 0, 0, 0, 5301, 5299, 1, 0, 0, 0, + 5301, 5302, 1, 0, 0, 0, 5302, 5304, 1, 0, 0, 0, 5303, 5301, 1, 0, 0, 0, + 5304, 5305, 5, 2448, 0, 0, 5305, 347, 1, 0, 0, 0, 5306, 5307, 3, 2286, + 1143, 0, 5307, 5308, 5, 2440, 0, 0, 5308, 5310, 1, 0, 0, 0, 5309, 5306, + 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 5311, 1, 0, 0, 0, 5311, 5316, + 3, 2404, 1202, 0, 5312, 5314, 5, 69, 0, 0, 5313, 5312, 1, 0, 0, 0, 5313, + 5314, 1, 0, 0, 0, 5314, 5315, 1, 0, 0, 0, 5315, 5317, 3, 2404, 1202, 0, + 5316, 5313, 1, 0, 0, 0, 5316, 5317, 1, 0, 0, 0, 5317, 349, 1, 0, 0, 0, + 5318, 5319, 3, 2286, 1143, 0, 5319, 5320, 5, 2440, 0, 0, 5320, 5322, 1, + 0, 0, 0, 5321, 5318, 1, 0, 0, 0, 5321, 5322, 1, 0, 0, 0, 5322, 5323, 1, + 0, 0, 0, 5323, 5328, 3, 2404, 1202, 0, 5324, 5326, 5, 69, 0, 0, 5325, 5324, + 1, 0, 0, 0, 5325, 5326, 1, 0, 0, 0, 5326, 5327, 1, 0, 0, 0, 5327, 5329, + 3, 2404, 1202, 0, 5328, 5325, 1, 0, 0, 0, 5328, 5329, 1, 0, 0, 0, 5329, + 5331, 1, 0, 0, 0, 5330, 5332, 5, 389, 0, 0, 5331, 5330, 1, 0, 0, 0, 5331, + 5332, 1, 0, 0, 0, 5332, 351, 1, 0, 0, 0, 5333, 5334, 5, 934, 0, 0, 5334, + 5335, 5, 2447, 0, 0, 5335, 5340, 3, 354, 177, 0, 5336, 5337, 5, 2453, 0, + 0, 5337, 5339, 3, 354, 177, 0, 5338, 5336, 1, 0, 0, 0, 5339, 5342, 1, 0, + 0, 0, 5340, 5338, 1, 0, 0, 0, 5340, 5341, 1, 0, 0, 0, 5341, 5343, 1, 0, + 0, 0, 5342, 5340, 1, 0, 0, 0, 5343, 5344, 5, 2448, 0, 0, 5344, 353, 1, + 0, 0, 0, 5345, 5348, 3, 2404, 1202, 0, 5346, 5349, 3, 356, 178, 0, 5347, + 5349, 3, 360, 180, 0, 5348, 5346, 1, 0, 0, 0, 5348, 5347, 1, 0, 0, 0, 5348, + 5349, 1, 0, 0, 0, 5349, 355, 1, 0, 0, 0, 5350, 5351, 5, 567, 0, 0, 5351, + 5353, 3, 2404, 1202, 0, 5352, 5354, 3, 358, 179, 0, 5353, 5352, 1, 0, 0, + 0, 5353, 5354, 1, 0, 0, 0, 5354, 357, 1, 0, 0, 0, 5355, 5356, 5, 35, 0, + 0, 5356, 5357, 5, 160, 0, 0, 5357, 5358, 3, 2302, 1151, 0, 5358, 359, 1, + 0, 0, 0, 5359, 5360, 5, 69, 0, 0, 5360, 5361, 5, 2447, 0, 0, 5361, 5362, + 3, 2078, 1039, 0, 5362, 5363, 5, 2448, 0, 0, 5363, 361, 1, 0, 0, 0, 5364, + 5365, 5, 389, 0, 0, 5365, 5366, 5, 933, 0, 0, 5366, 5367, 3, 2404, 1202, + 0, 5367, 363, 1, 0, 0, 0, 5368, 5369, 5, 389, 0, 0, 5369, 5370, 5, 35, + 0, 0, 5370, 5371, 5, 160, 0, 0, 5371, 5372, 3, 2302, 1151, 0, 5372, 365, + 1, 0, 0, 0, 5373, 5374, 5, 166, 0, 0, 5374, 5379, 3, 368, 184, 0, 5375, + 5376, 5, 2453, 0, 0, 5376, 5378, 3, 368, 184, 0, 5377, 5375, 1, 0, 0, 0, + 5378, 5381, 1, 0, 0, 0, 5379, 5377, 1, 0, 0, 0, 5379, 5380, 1, 0, 0, 0, + 5380, 367, 1, 0, 0, 0, 5381, 5379, 1, 0, 0, 0, 5382, 5383, 5, 933, 0, 0, + 5383, 5403, 5, 649, 0, 0, 5384, 5404, 5, 38, 0, 0, 5385, 5386, 5, 2447, + 0, 0, 5386, 5391, 3, 2404, 1202, 0, 5387, 5388, 5, 2453, 0, 0, 5388, 5390, + 3, 2404, 1202, 0, 5389, 5387, 1, 0, 0, 0, 5390, 5393, 1, 0, 0, 0, 5391, + 5389, 1, 0, 0, 0, 5391, 5392, 1, 0, 0, 0, 5392, 5394, 1, 0, 0, 0, 5393, + 5391, 1, 0, 0, 0, 5394, 5395, 5, 2448, 0, 0, 5395, 5400, 3, 370, 185, 0, + 5396, 5397, 5, 2453, 0, 0, 5397, 5399, 3, 370, 185, 0, 5398, 5396, 1, 0, + 0, 0, 5399, 5402, 1, 0, 0, 0, 5400, 5398, 1, 0, 0, 0, 5400, 5401, 1, 0, + 0, 0, 5401, 5404, 1, 0, 0, 0, 5402, 5400, 1, 0, 0, 0, 5403, 5384, 1, 0, + 0, 0, 5403, 5385, 1, 0, 0, 0, 5404, 369, 1, 0, 0, 0, 5405, 5406, 5, 848, + 0, 0, 5406, 5407, 5, 2447, 0, 0, 5407, 5412, 3, 372, 186, 0, 5408, 5409, + 5, 2453, 0, 0, 5409, 5411, 3, 372, 186, 0, 5410, 5408, 1, 0, 0, 0, 5411, + 5414, 1, 0, 0, 0, 5412, 5410, 1, 0, 0, 0, 5412, 5413, 1, 0, 0, 0, 5413, + 5415, 1, 0, 0, 0, 5414, 5412, 1, 0, 0, 0, 5415, 5416, 5, 2448, 0, 0, 5416, + 5417, 3, 374, 187, 0, 5417, 371, 1, 0, 0, 0, 5418, 5427, 5, 2447, 0, 0, + 5419, 5420, 3, 2404, 1202, 0, 5420, 5421, 5, 2440, 0, 0, 5421, 5423, 1, + 0, 0, 0, 5422, 5419, 1, 0, 0, 0, 5422, 5423, 1, 0, 0, 0, 5423, 5424, 1, + 0, 0, 0, 5424, 5425, 3, 2404, 1202, 0, 5425, 5426, 5, 2440, 0, 0, 5426, + 5428, 1, 0, 0, 0, 5427, 5422, 1, 0, 0, 0, 5427, 5428, 1, 0, 0, 0, 5428, + 5429, 1, 0, 0, 0, 5429, 5430, 3, 2404, 1202, 0, 5430, 5431, 5, 2448, 0, + 0, 5431, 373, 1, 0, 0, 0, 5432, 5444, 5, 477, 0, 0, 5433, 5441, 5, 919, + 0, 0, 5434, 5438, 5, 2246, 0, 0, 5435, 5436, 3, 2286, 1143, 0, 5436, 5437, + 5, 2440, 0, 0, 5437, 5439, 1, 0, 0, 0, 5438, 5435, 1, 0, 0, 0, 5438, 5439, + 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5442, 3, 2404, 1202, 0, 5441, + 5434, 1, 0, 0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5444, 1, 0, 0, 0, 5443, + 5432, 1, 0, 0, 0, 5443, 5433, 1, 0, 0, 0, 5444, 375, 1, 0, 0, 0, 5445, + 5446, 5, 567, 0, 0, 5446, 5447, 5, 237, 0, 0, 5447, 5462, 3, 2340, 1170, + 0, 5448, 5450, 5, 69, 0, 0, 5449, 5448, 1, 0, 0, 0, 5449, 5450, 1, 0, 0, + 0, 5450, 5451, 1, 0, 0, 0, 5451, 5459, 3, 2404, 1202, 0, 5452, 5454, 5, + 2453, 0, 0, 5453, 5455, 5, 69, 0, 0, 5454, 5453, 1, 0, 0, 0, 5454, 5455, + 1, 0, 0, 0, 5455, 5456, 1, 0, 0, 0, 5456, 5458, 3, 2404, 1202, 0, 5457, + 5452, 1, 0, 0, 0, 5458, 5461, 1, 0, 0, 0, 5459, 5457, 1, 0, 0, 0, 5459, + 5460, 1, 0, 0, 0, 5460, 5463, 1, 0, 0, 0, 5461, 5459, 1, 0, 0, 0, 5462, + 5449, 1, 0, 0, 0, 5462, 5463, 1, 0, 0, 0, 5463, 377, 1, 0, 0, 0, 5464, + 5465, 5, 499, 0, 0, 5465, 5466, 5, 1484, 0, 0, 5466, 5468, 5, 2148, 0, + 0, 5467, 5469, 7, 51, 0, 0, 5468, 5467, 1, 0, 0, 0, 5468, 5469, 1, 0, 0, + 0, 5469, 379, 1, 0, 0, 0, 5470, 5473, 5, 321, 0, 0, 5471, 5472, 5, 1307, + 0, 0, 5472, 5474, 5, 1562, 0, 0, 5473, 5471, 1, 0, 0, 0, 5473, 5474, 1, + 0, 0, 0, 5474, 5476, 1, 0, 0, 0, 5475, 5477, 7, 7, 0, 0, 5476, 5475, 1, + 0, 0, 0, 5476, 5477, 1, 0, 0, 0, 5477, 5478, 1, 0, 0, 0, 5478, 5479, 5, + 83, 0, 0, 5479, 5483, 5, 422, 0, 0, 5480, 5481, 3, 2286, 1143, 0, 5481, + 5482, 5, 2440, 0, 0, 5482, 5484, 1, 0, 0, 0, 5483, 5480, 1, 0, 0, 0, 5483, + 5484, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 5489, 3, 2404, 1202, 0, + 5486, 5487, 5, 1681, 0, 0, 5487, 5488, 5, 2472, 0, 0, 5488, 5490, 7, 21, + 0, 0, 5489, 5486, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 5494, 1, 0, + 0, 0, 5491, 5493, 3, 332, 166, 0, 5492, 5491, 1, 0, 0, 0, 5493, 5496, 1, + 0, 0, 0, 5494, 5492, 1, 0, 0, 0, 5494, 5495, 1, 0, 0, 0, 5495, 5500, 1, + 0, 0, 0, 5496, 5494, 1, 0, 0, 0, 5497, 5498, 5, 422, 0, 0, 5498, 5499, + 5, 2166, 0, 0, 5499, 5501, 7, 52, 0, 0, 5500, 5497, 1, 0, 0, 0, 5500, 5501, + 1, 0, 0, 0, 5501, 5502, 1, 0, 0, 0, 5502, 5503, 3, 382, 191, 0, 5503, 5505, + 3, 392, 196, 0, 5504, 5506, 3, 396, 198, 0, 5505, 5504, 1, 0, 0, 0, 5506, + 5507, 1, 0, 0, 0, 5507, 5505, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, + 5510, 1, 0, 0, 0, 5509, 5511, 3, 404, 202, 0, 5510, 5509, 1, 0, 0, 0, 5510, + 5511, 1, 0, 0, 0, 5511, 381, 1, 0, 0, 0, 5512, 5513, 5, 2246, 0, 0, 5513, + 5518, 3, 384, 192, 0, 5514, 5515, 5, 2453, 0, 0, 5515, 5517, 3, 384, 192, + 0, 5516, 5514, 1, 0, 0, 0, 5517, 5520, 1, 0, 0, 0, 5518, 5516, 1, 0, 0, + 0, 5518, 5519, 1, 0, 0, 0, 5519, 5524, 1, 0, 0, 0, 5520, 5518, 1, 0, 0, + 0, 5521, 5523, 3, 386, 193, 0, 5522, 5521, 1, 0, 0, 0, 5523, 5526, 1, 0, + 0, 0, 5524, 5522, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 383, 1, 0, + 0, 0, 5526, 5524, 1, 0, 0, 0, 5527, 5528, 3, 2286, 1143, 0, 5528, 5529, + 5, 2440, 0, 0, 5529, 5531, 1, 0, 0, 0, 5530, 5527, 1, 0, 0, 0, 5530, 5531, + 1, 0, 0, 0, 5531, 5532, 1, 0, 0, 0, 5532, 5534, 3, 2404, 1202, 0, 5533, + 5535, 5, 1556, 0, 0, 5534, 5533, 1, 0, 0, 0, 5534, 5535, 1, 0, 0, 0, 5535, + 5540, 1, 0, 0, 0, 5536, 5538, 5, 69, 0, 0, 5537, 5536, 1, 0, 0, 0, 5537, + 5538, 1, 0, 0, 0, 5538, 5539, 1, 0, 0, 0, 5539, 5541, 3, 2404, 1202, 0, + 5540, 5537, 1, 0, 0, 0, 5540, 5541, 1, 0, 0, 0, 5541, 385, 1, 0, 0, 0, + 5542, 5543, 5, 794, 0, 0, 5543, 5544, 5, 1363, 0, 0, 5544, 5545, 3, 2404, + 1202, 0, 5545, 5546, 5, 1259, 0, 0, 5546, 5547, 3, 388, 194, 0, 5547, 387, + 1, 0, 0, 0, 5548, 5553, 3, 390, 195, 0, 5549, 5550, 5, 49, 0, 0, 5550, + 5552, 3, 390, 195, 0, 5551, 5549, 1, 0, 0, 0, 5552, 5555, 1, 0, 0, 0, 5553, + 5551, 1, 0, 0, 0, 5553, 5554, 1, 0, 0, 0, 5554, 389, 1, 0, 0, 0, 5555, + 5553, 1, 0, 0, 0, 5556, 5557, 3, 2404, 1202, 0, 5557, 5558, 5, 2440, 0, + 0, 5558, 5560, 1, 0, 0, 0, 5559, 5556, 1, 0, 0, 0, 5559, 5560, 1, 0, 0, + 0, 5560, 5561, 1, 0, 0, 0, 5561, 5562, 3, 2340, 1170, 0, 5562, 5566, 5, + 2472, 0, 0, 5563, 5564, 3, 2404, 1202, 0, 5564, 5565, 5, 2440, 0, 0, 5565, + 5567, 1, 0, 0, 0, 5566, 5563, 1, 0, 0, 0, 5566, 5567, 1, 0, 0, 0, 5567, + 5568, 1, 0, 0, 0, 5568, 5569, 3, 2340, 1170, 0, 5569, 391, 1, 0, 0, 0, + 5570, 5571, 5, 84, 0, 0, 5571, 5572, 5, 2447, 0, 0, 5572, 5577, 3, 394, + 197, 0, 5573, 5574, 5, 2453, 0, 0, 5574, 5576, 3, 394, 197, 0, 5575, 5573, + 1, 0, 0, 0, 5576, 5579, 1, 0, 0, 0, 5577, 5575, 1, 0, 0, 0, 5577, 5578, + 1, 0, 0, 0, 5578, 5580, 1, 0, 0, 0, 5579, 5577, 1, 0, 0, 0, 5580, 5581, + 5, 2448, 0, 0, 5581, 393, 1, 0, 0, 0, 5582, 5583, 3, 2404, 1202, 0, 5583, + 5584, 5, 2440, 0, 0, 5584, 5586, 1, 0, 0, 0, 5585, 5582, 1, 0, 0, 0, 5585, + 5586, 1, 0, 0, 0, 5586, 5587, 1, 0, 0, 0, 5587, 5592, 3, 2340, 1170, 0, + 5588, 5590, 5, 69, 0, 0, 5589, 5588, 1, 0, 0, 0, 5589, 5590, 1, 0, 0, 0, + 5590, 5591, 1, 0, 0, 0, 5591, 5593, 3, 2404, 1202, 0, 5592, 5589, 1, 0, + 0, 0, 5592, 5593, 1, 0, 0, 0, 5593, 5597, 1, 0, 0, 0, 5594, 5596, 3, 332, + 166, 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, 395, 1, 0, 0, 0, 5599, 5597, 1, + 0, 0, 0, 5600, 5601, 5, 846, 0, 0, 5601, 5607, 3, 2404, 1202, 0, 5602, + 5603, 5, 1204, 0, 0, 5603, 5608, 5, 1228, 0, 0, 5604, 5605, 5, 1702, 0, + 0, 5605, 5606, 5, 2300, 0, 0, 5606, 5608, 5, 1228, 0, 0, 5607, 5602, 1, + 0, 0, 0, 5607, 5604, 1, 0, 0, 0, 5607, 5608, 1, 0, 0, 0, 5608, 5612, 1, + 0, 0, 0, 5609, 5610, 5, 846, 0, 0, 5610, 5611, 5, 2166, 0, 0, 5611, 5613, + 7, 53, 0, 0, 5612, 5609, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, 5613, 5617, + 1, 0, 0, 0, 5614, 5616, 3, 332, 166, 0, 5615, 5614, 1, 0, 0, 0, 5616, 5619, + 1, 0, 0, 0, 5617, 5615, 1, 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5620, + 1, 0, 0, 0, 5619, 5617, 1, 0, 0, 0, 5620, 5622, 3, 398, 199, 0, 5621, 5623, + 3, 400, 200, 0, 5622, 5621, 1, 0, 0, 0, 5622, 5623, 1, 0, 0, 0, 5623, 5627, + 1, 0, 0, 0, 5624, 5625, 5, 936, 0, 0, 5625, 5626, 5, 997, 0, 0, 5626, 5628, + 3, 2078, 1039, 0, 5627, 5624, 1, 0, 0, 0, 5627, 5628, 1, 0, 0, 0, 5628, + 5632, 1, 0, 0, 0, 5629, 5630, 5, 936, 0, 0, 5630, 5631, 5, 177, 0, 0, 5631, + 5633, 3, 2078, 1039, 0, 5632, 5629, 1, 0, 0, 0, 5632, 5633, 1, 0, 0, 0, + 5633, 5637, 1, 0, 0, 0, 5634, 5635, 5, 936, 0, 0, 5635, 5636, 5, 415, 0, + 0, 5636, 5638, 3, 2078, 1039, 0, 5637, 5634, 1, 0, 0, 0, 5637, 5638, 1, + 0, 0, 0, 5638, 5655, 1, 0, 0, 0, 5639, 5640, 5, 1303, 0, 0, 5640, 5642, + 5, 160, 0, 0, 5641, 5643, 7, 54, 0, 0, 5642, 5641, 1, 0, 0, 0, 5642, 5643, + 1, 0, 0, 0, 5643, 5644, 1, 0, 0, 0, 5644, 5652, 3, 402, 201, 0, 5645, 5647, + 5, 2453, 0, 0, 5646, 5648, 7, 54, 0, 0, 5647, 5646, 1, 0, 0, 0, 5647, 5648, + 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 5651, 3, 402, 201, 0, 5650, 5645, + 1, 0, 0, 0, 5651, 5654, 1, 0, 0, 0, 5652, 5650, 1, 0, 0, 0, 5652, 5653, + 1, 0, 0, 0, 5653, 5656, 1, 0, 0, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5639, + 1, 0, 0, 0, 5655, 5656, 1, 0, 0, 0, 5656, 5669, 1, 0, 0, 0, 5657, 5658, + 5, 419, 0, 0, 5658, 5659, 5, 2447, 0, 0, 5659, 5664, 3, 2404, 1202, 0, + 5660, 5661, 5, 2453, 0, 0, 5661, 5663, 3, 2404, 1202, 0, 5662, 5660, 1, + 0, 0, 0, 5663, 5666, 1, 0, 0, 0, 5664, 5662, 1, 0, 0, 0, 5664, 5665, 1, + 0, 0, 0, 5665, 5667, 1, 0, 0, 0, 5666, 5664, 1, 0, 0, 0, 5667, 5668, 5, + 2448, 0, 0, 5668, 5670, 1, 0, 0, 0, 5669, 5657, 1, 0, 0, 0, 5669, 5670, + 1, 0, 0, 0, 5670, 397, 1, 0, 0, 0, 5671, 5684, 5, 816, 0, 0, 5672, 5685, + 3, 2404, 1202, 0, 5673, 5674, 5, 2447, 0, 0, 5674, 5679, 3, 2404, 1202, + 0, 5675, 5676, 5, 2453, 0, 0, 5676, 5678, 3, 2404, 1202, 0, 5677, 5675, + 1, 0, 0, 0, 5678, 5681, 1, 0, 0, 0, 5679, 5677, 1, 0, 0, 0, 5679, 5680, + 1, 0, 0, 0, 5680, 5682, 1, 0, 0, 0, 5681, 5679, 1, 0, 0, 0, 5682, 5683, + 5, 2448, 0, 0, 5683, 5685, 1, 0, 0, 0, 5684, 5672, 1, 0, 0, 0, 5684, 5673, + 1, 0, 0, 0, 5685, 399, 1, 0, 0, 0, 5686, 5687, 5, 43, 0, 0, 5687, 5688, + 3, 398, 199, 0, 5688, 401, 1, 0, 0, 0, 5689, 5691, 3, 2404, 1202, 0, 5690, + 5692, 7, 55, 0, 0, 5691, 5690, 1, 0, 0, 0, 5691, 5692, 1, 0, 0, 0, 5692, + 5695, 1, 0, 0, 0, 5693, 5694, 5, 1229, 0, 0, 5694, 5696, 7, 56, 0, 0, 5695, + 5693, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 403, 1, 0, 0, 0, 5697, + 5698, 5, 38, 0, 0, 5698, 5715, 5, 936, 0, 0, 5699, 5700, 5, 997, 0, 0, + 5700, 5704, 3, 2078, 1039, 0, 5701, 5702, 5, 936, 0, 0, 5702, 5703, 5, + 177, 0, 0, 5703, 5705, 3, 2078, 1039, 0, 5704, 5701, 1, 0, 0, 0, 5704, + 5705, 1, 0, 0, 0, 5705, 5716, 1, 0, 0, 0, 5706, 5707, 5, 177, 0, 0, 5707, + 5711, 3, 2078, 1039, 0, 5708, 5709, 5, 936, 0, 0, 5709, 5710, 5, 415, 0, + 0, 5710, 5712, 3, 2078, 1039, 0, 5711, 5708, 1, 0, 0, 0, 5711, 5712, 1, + 0, 0, 0, 5712, 5716, 1, 0, 0, 0, 5713, 5714, 5, 415, 0, 0, 5714, 5716, + 3, 2078, 1039, 0, 5715, 5699, 1, 0, 0, 0, 5715, 5706, 1, 0, 0, 0, 5715, + 5713, 1, 0, 0, 0, 5716, 405, 1, 0, 0, 0, 5717, 5718, 5, 321, 0, 0, 5718, + 5719, 5, 85, 0, 0, 5719, 5720, 5, 1412, 0, 0, 5720, 5722, 3, 2404, 1202, + 0, 5721, 5723, 3, 408, 204, 0, 5722, 5721, 1, 0, 0, 0, 5722, 5723, 1, 0, + 0, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5726, 3, 410, 205, 0, 5725, 5724, 1, + 0, 0, 0, 5725, 5726, 1, 0, 0, 0, 5726, 5728, 1, 0, 0, 0, 5727, 5729, 3, + 426, 213, 0, 5728, 5727, 1, 0, 0, 0, 5728, 5729, 1, 0, 0, 0, 5729, 5736, + 1, 0, 0, 0, 5730, 5731, 5, 2300, 0, 0, 5731, 5732, 3, 2400, 1200, 0, 5732, + 5733, 5, 530, 0, 0, 5733, 5734, 5, 1390, 0, 0, 5734, 5735, 7, 57, 0, 0, + 5735, 5737, 1, 0, 0, 0, 5736, 5730, 1, 0, 0, 0, 5736, 5737, 1, 0, 0, 0, + 5737, 5740, 1, 0, 0, 0, 5738, 5739, 5, 1258, 0, 0, 5739, 5741, 5, 2135, + 0, 0, 5740, 5738, 1, 0, 0, 0, 5740, 5741, 1, 0, 0, 0, 5741, 5743, 1, 0, + 0, 0, 5742, 5744, 3, 766, 383, 0, 5743, 5742, 1, 0, 0, 0, 5743, 5744, 1, + 0, 0, 0, 5744, 407, 1, 0, 0, 0, 5745, 5746, 5, 1459, 0, 0, 5746, 5751, + 3, 2392, 1196, 0, 5747, 5748, 5, 2453, 0, 0, 5748, 5750, 3, 2392, 1196, + 0, 5749, 5747, 1, 0, 0, 0, 5750, 5753, 1, 0, 0, 0, 5751, 5749, 1, 0, 0, + 0, 5751, 5752, 1, 0, 0, 0, 5752, 409, 1, 0, 0, 0, 5753, 5751, 1, 0, 0, + 0, 5754, 5758, 3, 414, 207, 0, 5755, 5758, 3, 422, 211, 0, 5756, 5758, + 3, 412, 206, 0, 5757, 5754, 1, 0, 0, 0, 5757, 5755, 1, 0, 0, 0, 5757, 5756, + 1, 0, 0, 0, 5758, 5759, 1, 0, 0, 0, 5759, 5757, 1, 0, 0, 0, 5759, 5760, + 1, 0, 0, 0, 5760, 411, 1, 0, 0, 0, 5761, 5762, 5, 12, 0, 0, 5762, 5767, + 3, 2392, 1196, 0, 5763, 5764, 5, 2453, 0, 0, 5764, 5766, 3, 2392, 1196, + 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, 413, 1, 0, 0, 0, 5769, 5767, 1, 0, 0, + 0, 5770, 5771, 5, 12, 0, 0, 5771, 5776, 3, 416, 208, 0, 5772, 5773, 5, + 2453, 0, 0, 5773, 5775, 3, 416, 208, 0, 5774, 5772, 1, 0, 0, 0, 5775, 5778, + 1, 0, 0, 0, 5776, 5774, 1, 0, 0, 0, 5776, 5777, 1, 0, 0, 0, 5777, 415, + 1, 0, 0, 0, 5778, 5776, 1, 0, 0, 0, 5779, 5782, 3, 418, 209, 0, 5780, 5782, + 5, 38, 0, 0, 5781, 5779, 1, 0, 0, 0, 5781, 5780, 1, 0, 0, 0, 5782, 5783, + 1, 0, 0, 0, 5783, 5796, 5, 1259, 0, 0, 5784, 5785, 5, 426, 0, 0, 5785, + 5797, 3, 786, 393, 0, 5786, 5787, 5, 955, 0, 0, 5787, 5789, 5, 971, 0, + 0, 5788, 5786, 1, 0, 0, 0, 5788, 5789, 1, 0, 0, 0, 5789, 5793, 1, 0, 0, + 0, 5790, 5791, 3, 2286, 1143, 0, 5791, 5792, 5, 2440, 0, 0, 5792, 5794, + 1, 0, 0, 0, 5793, 5790, 1, 0, 0, 0, 5793, 5794, 1, 0, 0, 0, 5794, 5795, + 1, 0, 0, 0, 5795, 5797, 3, 2404, 1202, 0, 5796, 5784, 1, 0, 0, 0, 5796, + 5788, 1, 0, 0, 0, 5797, 5803, 1, 0, 0, 0, 5798, 5801, 3, 420, 210, 0, 5799, + 5801, 5, 38, 0, 0, 5800, 5798, 1, 0, 0, 0, 5800, 5799, 1, 0, 0, 0, 5801, + 5803, 1, 0, 0, 0, 5802, 5781, 1, 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5803, + 417, 1, 0, 0, 0, 5804, 5805, 7, 58, 0, 0, 5805, 419, 1, 0, 0, 0, 5806, + 5814, 3, 2404, 1202, 0, 5807, 5808, 7, 59, 0, 0, 5808, 5814, 5, 792, 0, + 0, 5809, 5810, 5, 881, 0, 0, 5810, 5814, 5, 2083, 0, 0, 5811, 5812, 7, + 60, 0, 0, 5812, 5814, 5, 426, 0, 0, 5813, 5806, 1, 0, 0, 0, 5813, 5807, + 1, 0, 0, 0, 5813, 5809, 1, 0, 0, 0, 5813, 5811, 1, 0, 0, 0, 5814, 421, + 1, 0, 0, 0, 5815, 5816, 5, 12, 0, 0, 5816, 5817, 5, 252, 0, 0, 5817, 5843, + 5, 2472, 0, 0, 5818, 5819, 7, 61, 0, 0, 5819, 5824, 3, 424, 212, 0, 5820, + 5821, 5, 2453, 0, 0, 5821, 5823, 3, 424, 212, 0, 5822, 5820, 1, 0, 0, 0, + 5823, 5826, 1, 0, 0, 0, 5824, 5822, 1, 0, 0, 0, 5824, 5825, 1, 0, 0, 0, + 5825, 5844, 1, 0, 0, 0, 5826, 5824, 1, 0, 0, 0, 5827, 5828, 5, 476, 0, + 0, 5828, 5829, 3, 424, 212, 0, 5829, 5830, 5, 1259, 0, 0, 5830, 5838, 3, + 2404, 1202, 0, 5831, 5832, 5, 2453, 0, 0, 5832, 5833, 3, 424, 212, 0, 5833, + 5834, 5, 1259, 0, 0, 5834, 5835, 3, 2404, 1202, 0, 5835, 5837, 1, 0, 0, + 0, 5836, 5831, 1, 0, 0, 0, 5837, 5840, 1, 0, 0, 0, 5838, 5836, 1, 0, 0, + 0, 5838, 5839, 1, 0, 0, 0, 5839, 5844, 1, 0, 0, 0, 5840, 5838, 1, 0, 0, + 0, 5841, 5842, 5, 1470, 0, 0, 5842, 5844, 7, 62, 0, 0, 5843, 5818, 1, 0, + 0, 0, 5843, 5827, 1, 0, 0, 0, 5843, 5841, 1, 0, 0, 0, 5844, 423, 1, 0, + 0, 0, 5845, 5846, 3, 2404, 1202, 0, 5846, 425, 1, 0, 0, 0, 5847, 5848, + 5, 1595, 0, 0, 5848, 5853, 3, 2308, 1154, 0, 5849, 5850, 5, 2453, 0, 0, + 5850, 5852, 3, 2308, 1154, 0, 5851, 5849, 1, 0, 0, 0, 5852, 5855, 1, 0, + 0, 0, 5853, 5851, 1, 0, 0, 0, 5853, 5854, 1, 0, 0, 0, 5854, 427, 1, 0, + 0, 0, 5855, 5853, 1, 0, 0, 0, 5856, 5857, 5, 321, 0, 0, 5857, 5859, 5, + 298, 0, 0, 5858, 5860, 5, 1587, 0, 0, 5859, 5858, 1, 0, 0, 0, 5859, 5860, + 1, 0, 0, 0, 5860, 5862, 1, 0, 0, 0, 5861, 5863, 5, 1671, 0, 0, 5862, 5861, + 1, 0, 0, 0, 5862, 5863, 1, 0, 0, 0, 5863, 5864, 1, 0, 0, 0, 5864, 5865, + 5, 350, 0, 0, 5865, 5867, 3, 2404, 1202, 0, 5866, 5868, 3, 432, 216, 0, + 5867, 5866, 1, 0, 0, 0, 5867, 5868, 1, 0, 0, 0, 5868, 5869, 1, 0, 0, 0, + 5869, 5879, 7, 63, 0, 0, 5870, 5871, 5, 352, 0, 0, 5871, 5876, 3, 436, + 218, 0, 5872, 5873, 5, 2453, 0, 0, 5873, 5875, 3, 436, 218, 0, 5874, 5872, + 1, 0, 0, 0, 5875, 5878, 1, 0, 0, 0, 5876, 5874, 1, 0, 0, 0, 5876, 5877, + 1, 0, 0, 0, 5877, 5880, 1, 0, 0, 0, 5878, 5876, 1, 0, 0, 0, 5879, 5870, + 1, 0, 0, 0, 5879, 5880, 1, 0, 0, 0, 5880, 5884, 1, 0, 0, 0, 5881, 5883, + 3, 430, 215, 0, 5882, 5881, 1, 0, 0, 0, 5883, 5886, 1, 0, 0, 0, 5884, 5882, + 1, 0, 0, 0, 5884, 5885, 1, 0, 0, 0, 5885, 5888, 1, 0, 0, 0, 5886, 5884, + 1, 0, 0, 0, 5887, 5889, 3, 434, 217, 0, 5888, 5887, 1, 0, 0, 0, 5888, 5889, + 1, 0, 0, 0, 5889, 429, 1, 0, 0, 0, 5890, 5891, 5, 926, 0, 0, 5891, 5915, + 3, 2396, 1198, 0, 5892, 5893, 5, 928, 0, 0, 5893, 5915, 3, 2396, 1198, + 0, 5894, 5895, 5, 927, 0, 0, 5895, 5915, 3, 2396, 1198, 0, 5896, 5897, + 5, 922, 0, 0, 5897, 5915, 3, 2396, 1198, 0, 5898, 5899, 5, 925, 0, 0, 5899, + 5915, 3, 2396, 1198, 0, 5900, 5915, 5, 66, 0, 0, 5901, 5915, 5, 1058, 0, + 0, 5902, 5903, 5, 616, 0, 0, 5903, 5915, 5, 884, 0, 0, 5904, 5905, 5, 1671, + 0, 0, 5905, 5906, 5, 1734, 0, 0, 5906, 5907, 5, 1119, 0, 0, 5907, 5912, + 5, 620, 0, 0, 5908, 5909, 5, 351, 0, 0, 5909, 5913, 5, 98, 0, 0, 5910, + 5911, 5, 867, 0, 0, 5911, 5913, 5, 1385, 0, 0, 5912, 5908, 1, 0, 0, 0, + 5912, 5910, 1, 0, 0, 0, 5913, 5915, 1, 0, 0, 0, 5914, 5890, 1, 0, 0, 0, + 5914, 5892, 1, 0, 0, 0, 5914, 5894, 1, 0, 0, 0, 5914, 5896, 1, 0, 0, 0, + 5914, 5898, 1, 0, 0, 0, 5914, 5900, 1, 0, 0, 0, 5914, 5901, 1, 0, 0, 0, + 5914, 5902, 1, 0, 0, 0, 5914, 5904, 1, 0, 0, 0, 5915, 431, 1, 0, 0, 0, + 5916, 5921, 5, 882, 0, 0, 5917, 5919, 5, 649, 0, 0, 5918, 5917, 1, 0, 0, + 0, 5918, 5919, 1, 0, 0, 0, 5919, 5920, 1, 0, 0, 0, 5920, 5922, 3, 2396, + 1198, 0, 5921, 5918, 1, 0, 0, 0, 5921, 5922, 1, 0, 0, 0, 5922, 5923, 1, + 0, 0, 0, 5923, 5934, 3, 436, 218, 0, 5924, 5929, 5, 2453, 0, 0, 5925, 5927, + 5, 649, 0, 0, 5926, 5925, 1, 0, 0, 0, 5926, 5927, 1, 0, 0, 0, 5927, 5928, + 1, 0, 0, 0, 5928, 5930, 3, 2396, 1198, 0, 5929, 5926, 1, 0, 0, 0, 5929, + 5930, 1, 0, 0, 0, 5930, 5931, 1, 0, 0, 0, 5931, 5933, 3, 436, 218, 0, 5932, + 5924, 1, 0, 0, 0, 5933, 5936, 1, 0, 0, 0, 5934, 5932, 1, 0, 0, 0, 5934, + 5935, 1, 0, 0, 0, 5935, 433, 1, 0, 0, 0, 5936, 5934, 1, 0, 0, 0, 5937, + 5938, 5, 193, 0, 0, 5938, 5939, 5, 1671, 0, 0, 5939, 5940, 3, 2404, 1202, + 0, 5940, 435, 1, 0, 0, 0, 5941, 5944, 3, 918, 459, 0, 5942, 5944, 3, 920, + 460, 0, 5943, 5941, 1, 0, 0, 0, 5943, 5942, 1, 0, 0, 0, 5944, 437, 1, 0, + 0, 0, 5945, 5946, 5, 321, 0, 0, 5946, 5947, 5, 441, 0, 0, 5947, 5960, 3, + 2404, 1202, 0, 5948, 5958, 5, 675, 0, 0, 5949, 5958, 5, 1178, 0, 0, 5950, + 5958, 5, 609, 0, 0, 5951, 5954, 5, 2376, 0, 0, 5952, 5953, 5, 1688, 0, + 0, 5953, 5955, 3, 2404, 1202, 0, 5954, 5952, 1, 0, 0, 0, 5954, 5955, 1, + 0, 0, 0, 5955, 5958, 1, 0, 0, 0, 5956, 5958, 5, 560, 0, 0, 5957, 5948, + 1, 0, 0, 0, 5957, 5949, 1, 0, 0, 0, 5957, 5950, 1, 0, 0, 0, 5957, 5951, + 1, 0, 0, 0, 5957, 5956, 1, 0, 0, 0, 5958, 5959, 1, 0, 0, 0, 5959, 5961, + 5, 1524, 0, 0, 5960, 5957, 1, 0, 0, 0, 5960, 5961, 1, 0, 0, 0, 5961, 5978, + 1, 0, 0, 0, 5962, 5964, 3, 84, 42, 0, 5963, 5962, 1, 0, 0, 0, 5963, 5964, + 1, 0, 0, 0, 5964, 5967, 1, 0, 0, 0, 5965, 5966, 5, 572, 0, 0, 5966, 5968, + 3, 2404, 1202, 0, 5967, 5965, 1, 0, 0, 0, 5967, 5968, 1, 0, 0, 0, 5968, + 5969, 1, 0, 0, 0, 5969, 5970, 5, 440, 0, 0, 5970, 5975, 3, 440, 220, 0, + 5971, 5972, 5, 2453, 0, 0, 5972, 5974, 3, 440, 220, 0, 5973, 5971, 1, 0, + 0, 0, 5974, 5977, 1, 0, 0, 0, 5975, 5973, 1, 0, 0, 0, 5975, 5976, 1, 0, + 0, 0, 5976, 5979, 1, 0, 0, 0, 5977, 5975, 1, 0, 0, 0, 5978, 5963, 1, 0, + 0, 0, 5979, 5980, 1, 0, 0, 0, 5980, 5978, 1, 0, 0, 0, 5980, 5981, 1, 0, + 0, 0, 5981, 5995, 1, 0, 0, 0, 5982, 5983, 5, 83, 0, 0, 5983, 5984, 5, 2443, + 0, 0, 5984, 5985, 5, 2472, 0, 0, 5985, 5992, 5, 2443, 0, 0, 5986, 5987, + 5, 2453, 0, 0, 5987, 5988, 5, 2443, 0, 0, 5988, 5989, 5, 2472, 0, 0, 5989, + 5991, 5, 2443, 0, 0, 5990, 5986, 1, 0, 0, 0, 5991, 5994, 1, 0, 0, 0, 5992, + 5990, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5996, 1, 0, 0, 0, 5994, + 5992, 1, 0, 0, 0, 5995, 5982, 1, 0, 0, 0, 5995, 5996, 1, 0, 0, 0, 5996, + 439, 1, 0, 0, 0, 5997, 6000, 5, 2443, 0, 0, 5998, 5999, 5, 997, 0, 0, 5999, + 6001, 3, 2404, 1202, 0, 6000, 5998, 1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, + 6001, 6004, 1, 0, 0, 0, 6002, 6003, 5, 1699, 0, 0, 6003, 6005, 3, 1176, + 588, 0, 6004, 6002, 1, 0, 0, 0, 6004, 6005, 1, 0, 0, 0, 6005, 6007, 1, + 0, 0, 0, 6006, 6008, 3, 38, 19, 0, 6007, 6006, 1, 0, 0, 0, 6007, 6008, + 1, 0, 0, 0, 6008, 441, 1, 0, 0, 0, 6009, 6010, 5, 321, 0, 0, 6010, 6011, + 5, 483, 0, 0, 6011, 6016, 3, 2404, 1202, 0, 6012, 6013, 5, 69, 0, 0, 6013, + 6014, 5, 202, 0, 0, 6014, 6015, 5, 1246, 0, 0, 6015, 6017, 3, 2404, 1202, + 0, 6016, 6012, 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 443, 1, 0, 0, + 0, 6018, 6019, 5, 321, 0, 0, 6019, 6020, 5, 605, 0, 0, 6020, 6022, 5, 64, + 0, 0, 6021, 6023, 5, 389, 0, 0, 6022, 6021, 1, 0, 0, 0, 6022, 6023, 1, + 0, 0, 0, 6023, 6024, 1, 0, 0, 0, 6024, 6025, 3, 2404, 1202, 0, 6025, 6026, + 5, 2080, 0, 0, 6026, 6028, 3, 2404, 1202, 0, 6027, 6029, 3, 446, 223, 0, + 6028, 6027, 1, 0, 0, 0, 6028, 6029, 1, 0, 0, 0, 6029, 6035, 1, 0, 0, 0, + 6030, 6032, 5, 1137, 0, 0, 6031, 6030, 1, 0, 0, 0, 6031, 6032, 1, 0, 0, + 0, 6032, 6033, 1, 0, 0, 0, 6033, 6034, 5, 1269, 0, 0, 6034, 6036, 5, 351, + 0, 0, 6035, 6031, 1, 0, 0, 0, 6035, 6036, 1, 0, 0, 0, 6036, 6037, 1, 0, + 0, 0, 6037, 6038, 3, 448, 224, 0, 6038, 445, 1, 0, 0, 0, 6039, 6040, 5, + 1490, 0, 0, 6040, 6041, 5, 2441, 0, 0, 6041, 6042, 7, 64, 0, 0, 6042, 447, + 1, 0, 0, 0, 6043, 6044, 5, 1583, 0, 0, 6044, 6045, 5, 2441, 0, 0, 6045, + 6046, 7, 65, 0, 0, 6046, 449, 1, 0, 0, 0, 6047, 6050, 5, 321, 0, 0, 6048, + 6049, 5, 1307, 0, 0, 6049, 6051, 5, 1562, 0, 0, 6050, 6048, 1, 0, 0, 0, + 6050, 6051, 1, 0, 0, 0, 6051, 6056, 1, 0, 0, 0, 6052, 6054, 5, 1137, 0, + 0, 6053, 6052, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, 0, 6054, 6055, 1, 0, 0, + 0, 6055, 6057, 5, 616, 0, 0, 6056, 6053, 1, 0, 0, 0, 6056, 6057, 1, 0, + 0, 0, 6057, 6058, 1, 0, 0, 0, 6058, 6062, 5, 674, 0, 0, 6059, 6060, 3, + 2286, 1143, 0, 6060, 6061, 5, 2440, 0, 0, 6061, 6063, 1, 0, 0, 0, 6062, + 6059, 1, 0, 0, 0, 6062, 6063, 1, 0, 0, 0, 6063, 6064, 1, 0, 0, 0, 6064, + 6068, 3, 2404, 1202, 0, 6065, 6066, 5, 1681, 0, 0, 6066, 6067, 5, 2472, + 0, 0, 6067, 6069, 7, 21, 0, 0, 6068, 6065, 1, 0, 0, 0, 6068, 6069, 1, 0, + 0, 0, 6069, 6073, 1, 0, 0, 0, 6070, 6072, 3, 332, 166, 0, 6071, 6070, 1, + 0, 0, 0, 6072, 6075, 1, 0, 0, 0, 6073, 6071, 1, 0, 0, 0, 6073, 6074, 1, + 0, 0, 0, 6074, 6076, 1, 0, 0, 0, 6075, 6073, 1, 0, 0, 0, 6076, 6077, 3, + 452, 226, 0, 6077, 6079, 3, 454, 227, 0, 6078, 6080, 3, 456, 228, 0, 6079, + 6078, 1, 0, 0, 0, 6079, 6080, 1, 0, 0, 0, 6080, 451, 1, 0, 0, 0, 6081, + 6085, 5, 2246, 0, 0, 6082, 6083, 3, 2286, 1143, 0, 6083, 6084, 5, 2440, + 0, 0, 6084, 6086, 1, 0, 0, 0, 6085, 6082, 1, 0, 0, 0, 6085, 6086, 1, 0, + 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6088, 3, 2404, 1202, 0, 6088, 453, + 1, 0, 0, 0, 6089, 6095, 5, 2447, 0, 0, 6090, 6093, 3, 2404, 1202, 0, 6091, + 6092, 5, 202, 0, 0, 6092, 6094, 5, 1246, 0, 0, 6093, 6091, 1, 0, 0, 0, + 6093, 6094, 1, 0, 0, 0, 6094, 6096, 1, 0, 0, 0, 6095, 6090, 1, 0, 0, 0, + 6096, 6097, 1, 0, 0, 0, 6097, 6095, 1, 0, 0, 0, 6097, 6098, 1, 0, 0, 0, + 6098, 6099, 1, 0, 0, 0, 6099, 6100, 5, 2448, 0, 0, 6100, 455, 1, 0, 0, + 0, 6101, 6102, 5, 672, 0, 0, 6102, 6103, 5, 84, 0, 0, 6103, 6104, 5, 2447, + 0, 0, 6104, 6105, 3, 458, 229, 0, 6105, 6106, 5, 2448, 0, 0, 6106, 457, + 1, 0, 0, 0, 6107, 6111, 3, 460, 230, 0, 6108, 6110, 3, 332, 166, 0, 6109, + 6108, 1, 0, 0, 0, 6110, 6113, 1, 0, 0, 0, 6111, 6109, 1, 0, 0, 0, 6111, + 6112, 1, 0, 0, 0, 6112, 459, 1, 0, 0, 0, 6113, 6111, 1, 0, 0, 0, 6114, + 6115, 7, 66, 0, 0, 6115, 461, 1, 0, 0, 0, 6116, 6118, 5, 321, 0, 0, 6117, + 6119, 7, 67, 0, 0, 6118, 6117, 1, 0, 0, 0, 6118, 6119, 1, 0, 0, 0, 6119, + 6120, 1, 0, 0, 0, 6120, 6121, 5, 717, 0, 0, 6121, 6125, 3, 2328, 1164, + 0, 6122, 6123, 5, 691, 0, 0, 6123, 6124, 5, 1204, 0, 0, 6124, 6126, 5, + 545, 0, 0, 6125, 6122, 1, 0, 0, 0, 6125, 6126, 1, 0, 0, 0, 6126, 6127, + 1, 0, 0, 0, 6127, 6131, 5, 1259, 0, 0, 6128, 6132, 3, 464, 232, 0, 6129, + 6132, 3, 468, 234, 0, 6130, 6132, 3, 470, 235, 0, 6131, 6128, 1, 0, 0, + 0, 6131, 6129, 1, 0, 0, 0, 6131, 6130, 1, 0, 0, 0, 6132, 6134, 1, 0, 0, + 0, 6133, 6135, 7, 68, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, + 0, 6135, 6138, 1, 0, 0, 0, 6136, 6137, 7, 69, 0, 0, 6137, 6139, 5, 781, + 0, 0, 6138, 6136, 1, 0, 0, 0, 6138, 6139, 1, 0, 0, 0, 6139, 463, 1, 0, + 0, 0, 6140, 6141, 5, 220, 0, 0, 6141, 6143, 3, 466, 233, 0, 6142, 6144, + 3, 1588, 794, 0, 6143, 6142, 1, 0, 0, 0, 6143, 6144, 1, 0, 0, 0, 6144, + 465, 1, 0, 0, 0, 6145, 6146, 3, 2404, 1202, 0, 6146, 6147, 5, 2440, 0, + 0, 6147, 6149, 1, 0, 0, 0, 6148, 6145, 1, 0, 0, 0, 6148, 6149, 1, 0, 0, + 0, 6149, 6150, 1, 0, 0, 0, 6150, 6151, 3, 2404, 1202, 0, 6151, 467, 1, + 0, 0, 0, 6152, 6154, 3, 2342, 1171, 0, 6153, 6155, 3, 2270, 1135, 0, 6154, + 6153, 1, 0, 0, 0, 6154, 6155, 1, 0, 0, 0, 6155, 6156, 1, 0, 0, 0, 6156, + 6157, 5, 2447, 0, 0, 6157, 6159, 3, 472, 236, 0, 6158, 6160, 7, 55, 0, + 0, 6159, 6158, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6168, 1, 0, 0, + 0, 6161, 6162, 5, 2453, 0, 0, 6162, 6164, 3, 472, 236, 0, 6163, 6165, 7, + 55, 0, 0, 6164, 6163, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 6167, 1, + 0, 0, 0, 6166, 6161, 1, 0, 0, 0, 6167, 6170, 1, 0, 0, 0, 6168, 6166, 1, + 0, 0, 0, 6168, 6169, 1, 0, 0, 0, 6169, 6171, 1, 0, 0, 0, 6170, 6168, 1, + 0, 0, 0, 6171, 6173, 5, 2448, 0, 0, 6172, 6174, 3, 474, 237, 0, 6173, 6172, + 1, 0, 0, 0, 6173, 6174, 1, 0, 0, 0, 6174, 469, 1, 0, 0, 0, 6175, 6176, + 3, 2342, 1171, 0, 6176, 6179, 5, 2447, 0, 0, 6177, 6180, 3, 2342, 1171, + 0, 6178, 6180, 3, 2270, 1135, 0, 6179, 6177, 1, 0, 0, 0, 6179, 6178, 1, + 0, 0, 0, 6179, 6180, 1, 0, 0, 0, 6180, 6181, 1, 0, 0, 0, 6181, 6183, 3, + 2340, 1170, 0, 6182, 6184, 7, 55, 0, 0, 6183, 6182, 1, 0, 0, 0, 6183, 6184, + 1, 0, 0, 0, 6184, 6196, 1, 0, 0, 0, 6185, 6188, 5, 2453, 0, 0, 6186, 6189, + 3, 2342, 1171, 0, 6187, 6189, 3, 2270, 1135, 0, 6188, 6186, 1, 0, 0, 0, + 6188, 6187, 1, 0, 0, 0, 6188, 6189, 1, 0, 0, 0, 6189, 6190, 1, 0, 0, 0, + 6190, 6192, 3, 2340, 1170, 0, 6191, 6193, 7, 55, 0, 0, 6192, 6191, 1, 0, + 0, 0, 6192, 6193, 1, 0, 0, 0, 6193, 6195, 1, 0, 0, 0, 6194, 6185, 1, 0, + 0, 0, 6195, 6198, 1, 0, 0, 0, 6196, 6194, 1, 0, 0, 0, 6196, 6197, 1, 0, + 0, 0, 6197, 6199, 1, 0, 0, 0, 6198, 6196, 1, 0, 0, 0, 6199, 6200, 5, 2448, + 0, 0, 6200, 6201, 5, 628, 0, 0, 6201, 6202, 3, 2342, 1171, 0, 6202, 6209, + 3, 2270, 1135, 0, 6203, 6204, 5, 2453, 0, 0, 6204, 6205, 3, 2342, 1171, + 0, 6205, 6206, 3, 2270, 1135, 0, 6206, 6208, 1, 0, 0, 0, 6207, 6203, 1, + 0, 0, 0, 6208, 6211, 1, 0, 0, 0, 6209, 6207, 1, 0, 0, 0, 6209, 6210, 1, + 0, 0, 0, 6210, 6212, 1, 0, 0, 0, 6211, 6209, 1, 0, 0, 0, 6212, 6214, 3, + 2272, 1136, 0, 6213, 6215, 3, 490, 245, 0, 6214, 6213, 1, 0, 0, 0, 6214, + 6215, 1, 0, 0, 0, 6215, 6217, 1, 0, 0, 0, 6216, 6218, 3, 1588, 794, 0, + 6217, 6216, 1, 0, 0, 0, 6217, 6218, 1, 0, 0, 0, 6218, 471, 1, 0, 0, 0, + 6219, 6222, 3, 2340, 1170, 0, 6220, 6222, 3, 2078, 1039, 0, 6221, 6219, + 1, 0, 0, 0, 6221, 6220, 1, 0, 0, 0, 6222, 473, 1, 0, 0, 0, 6223, 6227, + 3, 484, 242, 0, 6224, 6227, 3, 490, 245, 0, 6225, 6227, 3, 1588, 794, 0, + 6226, 6223, 1, 0, 0, 0, 6226, 6224, 1, 0, 0, 0, 6226, 6225, 1, 0, 0, 0, + 6227, 6228, 1, 0, 0, 0, 6228, 6226, 1, 0, 0, 0, 6228, 6229, 1, 0, 0, 0, + 6229, 6237, 1, 0, 0, 0, 6230, 6231, 5, 731, 0, 0, 6231, 6234, 5, 785, 0, + 0, 6232, 6235, 3, 476, 238, 0, 6233, 6235, 3, 480, 240, 0, 6234, 6232, + 1, 0, 0, 0, 6234, 6233, 1, 0, 0, 0, 6235, 6237, 1, 0, 0, 0, 6236, 6226, + 1, 0, 0, 0, 6236, 6230, 1, 0, 0, 0, 6237, 475, 1, 0, 0, 0, 6238, 6240, + 3, 512, 256, 0, 6239, 6241, 3, 478, 239, 0, 6240, 6239, 1, 0, 0, 0, 6240, + 6241, 1, 0, 0, 0, 6241, 6243, 1, 0, 0, 0, 6242, 6244, 3, 928, 464, 0, 6243, + 6242, 1, 0, 0, 0, 6243, 6244, 1, 0, 0, 0, 6244, 6250, 1, 0, 0, 0, 6245, + 6246, 5, 1335, 0, 0, 6246, 6247, 5, 2447, 0, 0, 6247, 6248, 3, 510, 255, + 0, 6248, 6249, 5, 2448, 0, 0, 6249, 6251, 1, 0, 0, 0, 6250, 6245, 1, 0, + 0, 0, 6250, 6251, 1, 0, 0, 0, 6251, 477, 1, 0, 0, 0, 6252, 6280, 5, 873, + 0, 0, 6253, 6254, 5, 2447, 0, 0, 6254, 6255, 5, 1348, 0, 0, 6255, 6261, + 3, 1696, 848, 0, 6256, 6257, 5, 1335, 0, 0, 6257, 6258, 5, 2447, 0, 0, + 6258, 6259, 3, 510, 255, 0, 6259, 6260, 5, 2448, 0, 0, 6260, 6262, 1, 0, + 0, 0, 6261, 6256, 1, 0, 0, 0, 6261, 6262, 1, 0, 0, 0, 6262, 6275, 1, 0, + 0, 0, 6263, 6264, 5, 2453, 0, 0, 6264, 6265, 5, 1348, 0, 0, 6265, 6271, + 3, 1696, 848, 0, 6266, 6267, 5, 1335, 0, 0, 6267, 6268, 5, 2447, 0, 0, + 6268, 6269, 3, 510, 255, 0, 6269, 6270, 5, 2448, 0, 0, 6270, 6272, 1, 0, + 0, 0, 6271, 6266, 1, 0, 0, 0, 6271, 6272, 1, 0, 0, 0, 6272, 6274, 1, 0, + 0, 0, 6273, 6263, 1, 0, 0, 0, 6274, 6277, 1, 0, 0, 0, 6275, 6273, 1, 0, + 0, 0, 6275, 6276, 1, 0, 0, 0, 6276, 6278, 1, 0, 0, 0, 6277, 6275, 1, 0, + 0, 0, 6278, 6279, 5, 2448, 0, 0, 6279, 6281, 1, 0, 0, 0, 6280, 6253, 1, + 0, 0, 0, 6280, 6281, 1, 0, 0, 0, 6281, 479, 1, 0, 0, 0, 6282, 6283, 5, + 2315, 0, 0, 6283, 6285, 5, 2440, 0, 0, 6284, 6282, 1, 0, 0, 0, 6284, 6285, + 1, 0, 0, 0, 6285, 6286, 1, 0, 0, 0, 6286, 6288, 5, 2332, 0, 0, 6287, 6289, + 3, 482, 241, 0, 6288, 6287, 1, 0, 0, 0, 6288, 6289, 1, 0, 0, 0, 6289, 6291, + 1, 0, 0, 0, 6290, 6292, 3, 928, 464, 0, 6291, 6290, 1, 0, 0, 0, 6291, 6292, + 1, 0, 0, 0, 6292, 481, 1, 0, 0, 0, 6293, 6307, 5, 873, 0, 0, 6294, 6295, + 5, 2447, 0, 0, 6295, 6296, 5, 1348, 0, 0, 6296, 6302, 3, 1696, 848, 0, + 6297, 6298, 5, 2453, 0, 0, 6298, 6299, 5, 1348, 0, 0, 6299, 6301, 3, 1696, + 848, 0, 6300, 6297, 1, 0, 0, 0, 6301, 6304, 1, 0, 0, 0, 6302, 6300, 1, + 0, 0, 0, 6302, 6303, 1, 0, 0, 0, 6303, 6305, 1, 0, 0, 0, 6304, 6302, 1, + 0, 0, 0, 6305, 6306, 5, 2448, 0, 0, 6306, 6308, 1, 0, 0, 0, 6307, 6294, + 1, 0, 0, 0, 6307, 6308, 1, 0, 0, 0, 6308, 483, 1, 0, 0, 0, 6309, 6310, + 5, 642, 0, 0, 6310, 6311, 5, 1348, 0, 0, 6311, 6349, 5, 160, 0, 0, 6312, + 6313, 5, 1495, 0, 0, 6313, 6314, 5, 2447, 0, 0, 6314, 6319, 3, 2340, 1170, + 0, 6315, 6316, 5, 2453, 0, 0, 6316, 6318, 3, 2340, 1170, 0, 6317, 6315, + 1, 0, 0, 0, 6318, 6321, 1, 0, 0, 0, 6319, 6317, 1, 0, 0, 0, 6319, 6320, + 1, 0, 0, 0, 6320, 6322, 1, 0, 0, 0, 6321, 6319, 1, 0, 0, 0, 6322, 6323, + 5, 2448, 0, 0, 6323, 6324, 5, 2447, 0, 0, 6324, 6329, 3, 486, 243, 0, 6325, + 6326, 5, 2453, 0, 0, 6326, 6328, 3, 486, 243, 0, 6327, 6325, 1, 0, 0, 0, + 6328, 6331, 1, 0, 0, 0, 6329, 6327, 1, 0, 0, 0, 6329, 6330, 1, 0, 0, 0, + 6330, 6332, 1, 0, 0, 0, 6331, 6329, 1, 0, 0, 0, 6332, 6333, 5, 2448, 0, + 0, 6333, 6350, 1, 0, 0, 0, 6334, 6335, 5, 660, 0, 0, 6335, 6336, 5, 2447, + 0, 0, 6336, 6341, 3, 2340, 1170, 0, 6337, 6338, 5, 2453, 0, 0, 6338, 6340, + 3, 2340, 1170, 0, 6339, 6337, 1, 0, 0, 0, 6340, 6343, 1, 0, 0, 0, 6341, + 6339, 1, 0, 0, 0, 6341, 6342, 1, 0, 0, 0, 6342, 6344, 1, 0, 0, 0, 6343, + 6341, 1, 0, 0, 0, 6344, 6347, 5, 2448, 0, 0, 6345, 6348, 3, 1122, 561, + 0, 6346, 6348, 3, 1124, 562, 0, 6347, 6345, 1, 0, 0, 0, 6347, 6346, 1, + 0, 0, 0, 6348, 6350, 1, 0, 0, 0, 6349, 6312, 1, 0, 0, 0, 6349, 6334, 1, + 0, 0, 0, 6350, 485, 1, 0, 0, 0, 6351, 6353, 5, 1348, 0, 0, 6352, 6354, + 3, 1696, 848, 0, 6353, 6352, 1, 0, 0, 0, 6353, 6354, 1, 0, 0, 0, 6354, + 6355, 1, 0, 0, 0, 6355, 6356, 5, 2257, 0, 0, 6356, 6357, 5, 845, 0, 0, + 6357, 6358, 5, 2098, 0, 0, 6358, 6359, 5, 2447, 0, 0, 6359, 6360, 3, 488, + 244, 0, 6360, 6362, 5, 2448, 0, 0, 6361, 6363, 3, 1200, 600, 0, 6362, 6361, + 1, 0, 0, 0, 6362, 6363, 1, 0, 0, 0, 6363, 487, 1, 0, 0, 0, 6364, 6369, + 3, 2186, 1093, 0, 6365, 6366, 5, 2453, 0, 0, 6366, 6368, 3, 2186, 1093, + 0, 6367, 6365, 1, 0, 0, 0, 6368, 6371, 1, 0, 0, 0, 6369, 6367, 1, 0, 0, + 0, 6369, 6370, 1, 0, 0, 0, 6370, 6383, 1, 0, 0, 0, 6371, 6369, 1, 0, 0, + 0, 6372, 6373, 5, 2108, 0, 0, 6373, 6379, 3, 2186, 1093, 0, 6374, 6375, + 5, 2453, 0, 0, 6375, 6376, 5, 2108, 0, 0, 6376, 6378, 3, 2186, 1093, 0, + 6377, 6374, 1, 0, 0, 0, 6378, 6381, 1, 0, 0, 0, 6379, 6377, 1, 0, 0, 0, + 6379, 6380, 1, 0, 0, 0, 6380, 6383, 1, 0, 0, 0, 6381, 6379, 1, 0, 0, 0, + 6382, 6364, 1, 0, 0, 0, 6382, 6372, 1, 0, 0, 0, 6383, 489, 1, 0, 0, 0, + 6384, 6389, 5, 873, 0, 0, 6385, 6390, 3, 492, 246, 0, 6386, 6390, 3, 494, + 247, 0, 6387, 6390, 3, 498, 249, 0, 6388, 6390, 3, 502, 251, 0, 6389, 6385, + 1, 0, 0, 0, 6389, 6386, 1, 0, 0, 0, 6389, 6387, 1, 0, 0, 0, 6389, 6388, + 1, 0, 0, 0, 6389, 6390, 1, 0, 0, 0, 6390, 491, 1, 0, 0, 0, 6391, 6392, + 5, 2447, 0, 0, 6392, 6397, 3, 496, 248, 0, 6393, 6394, 5, 2453, 0, 0, 6394, + 6396, 3, 496, 248, 0, 6395, 6393, 1, 0, 0, 0, 6396, 6399, 1, 0, 0, 0, 6397, + 6395, 1, 0, 0, 0, 6397, 6398, 1, 0, 0, 0, 6398, 6400, 1, 0, 0, 0, 6399, + 6397, 1, 0, 0, 0, 6400, 6401, 5, 2448, 0, 0, 6401, 493, 1, 0, 0, 0, 6402, + 6403, 5, 2447, 0, 0, 6403, 6408, 3, 496, 248, 0, 6404, 6405, 5, 2453, 0, + 0, 6405, 6407, 3, 496, 248, 0, 6406, 6404, 1, 0, 0, 0, 6407, 6410, 1, 0, + 0, 0, 6408, 6406, 1, 0, 0, 0, 6408, 6409, 1, 0, 0, 0, 6409, 6411, 1, 0, + 0, 0, 6410, 6408, 1, 0, 0, 0, 6411, 6412, 5, 2448, 0, 0, 6412, 495, 1, + 0, 0, 0, 6413, 6415, 5, 1348, 0, 0, 6414, 6416, 3, 1696, 848, 0, 6415, + 6414, 1, 0, 0, 0, 6415, 6416, 1, 0, 0, 0, 6416, 6421, 1, 0, 0, 0, 6417, + 6420, 3, 1200, 600, 0, 6418, 6420, 3, 1600, 800, 0, 6419, 6417, 1, 0, 0, + 0, 6419, 6418, 1, 0, 0, 0, 6420, 6423, 1, 0, 0, 0, 6421, 6419, 1, 0, 0, + 0, 6421, 6422, 1, 0, 0, 0, 6422, 6425, 1, 0, 0, 0, 6423, 6421, 1, 0, 0, + 0, 6424, 6426, 5, 2203, 0, 0, 6425, 6424, 1, 0, 0, 0, 6425, 6426, 1, 0, + 0, 0, 6426, 497, 1, 0, 0, 0, 6427, 6428, 5, 1763, 0, 0, 6428, 6429, 5, + 738, 0, 0, 6429, 6430, 5, 2447, 0, 0, 6430, 6435, 3, 1656, 828, 0, 6431, + 6432, 5, 2453, 0, 0, 6432, 6434, 3, 1656, 828, 0, 6433, 6431, 1, 0, 0, + 0, 6434, 6437, 1, 0, 0, 0, 6435, 6433, 1, 0, 0, 0, 6435, 6436, 1, 0, 0, + 0, 6436, 6438, 1, 0, 0, 0, 6437, 6435, 1, 0, 0, 0, 6438, 6439, 5, 2448, + 0, 0, 6439, 6452, 1, 0, 0, 0, 6440, 6441, 5, 2447, 0, 0, 6441, 6446, 3, + 500, 250, 0, 6442, 6443, 5, 2453, 0, 0, 6443, 6445, 3, 500, 250, 0, 6444, + 6442, 1, 0, 0, 0, 6445, 6448, 1, 0, 0, 0, 6446, 6444, 1, 0, 0, 0, 6446, + 6447, 1, 0, 0, 0, 6447, 6449, 1, 0, 0, 0, 6448, 6446, 1, 0, 0, 0, 6449, + 6450, 5, 2448, 0, 0, 6450, 6452, 1, 0, 0, 0, 6451, 6427, 1, 0, 0, 0, 6451, + 6440, 1, 0, 0, 0, 6452, 499, 1, 0, 0, 0, 6453, 6455, 5, 1348, 0, 0, 6454, + 6456, 3, 1696, 848, 0, 6455, 6454, 1, 0, 0, 0, 6455, 6456, 1, 0, 0, 0, + 6456, 6459, 1, 0, 0, 0, 6457, 6458, 5, 2080, 0, 0, 6458, 6460, 3, 1656, + 828, 0, 6459, 6457, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, 6460, 6462, 1, + 0, 0, 0, 6461, 6463, 3, 1600, 800, 0, 6462, 6461, 1, 0, 0, 0, 6462, 6463, + 1, 0, 0, 0, 6463, 6465, 1, 0, 0, 0, 6464, 6466, 5, 2203, 0, 0, 6465, 6464, + 1, 0, 0, 0, 6465, 6466, 1, 0, 0, 0, 6466, 501, 1, 0, 0, 0, 6467, 6468, + 5, 1763, 0, 0, 6468, 6469, 5, 738, 0, 0, 6469, 6470, 5, 2447, 0, 0, 6470, + 6475, 3, 1656, 828, 0, 6471, 6472, 5, 2453, 0, 0, 6472, 6474, 3, 1656, + 828, 0, 6473, 6471, 1, 0, 0, 0, 6474, 6477, 1, 0, 0, 0, 6475, 6473, 1, + 0, 0, 0, 6475, 6476, 1, 0, 0, 0, 6476, 6478, 1, 0, 0, 0, 6477, 6475, 1, + 0, 0, 0, 6478, 6479, 5, 2448, 0, 0, 6479, 6481, 1, 0, 0, 0, 6480, 6467, + 1, 0, 0, 0, 6480, 6481, 1, 0, 0, 0, 6481, 6482, 1, 0, 0, 0, 6482, 6483, + 5, 2447, 0, 0, 6483, 6488, 3, 504, 252, 0, 6484, 6485, 5, 2453, 0, 0, 6485, + 6487, 3, 504, 252, 0, 6486, 6484, 1, 0, 0, 0, 6487, 6490, 1, 0, 0, 0, 6488, + 6486, 1, 0, 0, 0, 6488, 6489, 1, 0, 0, 0, 6489, 6491, 1, 0, 0, 0, 6490, + 6488, 1, 0, 0, 0, 6491, 6492, 5, 2448, 0, 0, 6492, 503, 1, 0, 0, 0, 6493, + 6495, 5, 1348, 0, 0, 6494, 6496, 3, 1696, 848, 0, 6495, 6494, 1, 0, 0, + 0, 6495, 6496, 1, 0, 0, 0, 6496, 6501, 1, 0, 0, 0, 6497, 6500, 3, 1200, + 600, 0, 6498, 6500, 3, 1600, 800, 0, 6499, 6497, 1, 0, 0, 0, 6499, 6498, + 1, 0, 0, 0, 6500, 6503, 1, 0, 0, 0, 6501, 6499, 1, 0, 0, 0, 6501, 6502, + 1, 0, 0, 0, 6502, 6505, 1, 0, 0, 0, 6503, 6501, 1, 0, 0, 0, 6504, 6506, + 5, 2203, 0, 0, 6505, 6504, 1, 0, 0, 0, 6505, 6506, 1, 0, 0, 0, 6506, 6508, + 1, 0, 0, 0, 6507, 6509, 3, 506, 253, 0, 6508, 6507, 1, 0, 0, 0, 6508, 6509, + 1, 0, 0, 0, 6509, 505, 1, 0, 0, 0, 6510, 6511, 5, 1763, 0, 0, 6511, 6512, + 5, 738, 0, 0, 6512, 6513, 5, 2447, 0, 0, 6513, 6518, 3, 1656, 828, 0, 6514, + 6515, 5, 2453, 0, 0, 6515, 6517, 3, 1656, 828, 0, 6516, 6514, 1, 0, 0, + 0, 6517, 6520, 1, 0, 0, 0, 6518, 6516, 1, 0, 0, 0, 6518, 6519, 1, 0, 0, + 0, 6519, 6521, 1, 0, 0, 0, 6520, 6518, 1, 0, 0, 0, 6521, 6522, 5, 2448, + 0, 0, 6522, 6535, 1, 0, 0, 0, 6523, 6524, 5, 2447, 0, 0, 6524, 6529, 3, + 508, 254, 0, 6525, 6526, 5, 2453, 0, 0, 6526, 6528, 3, 508, 254, 0, 6527, + 6525, 1, 0, 0, 0, 6528, 6531, 1, 0, 0, 0, 6529, 6527, 1, 0, 0, 0, 6529, + 6530, 1, 0, 0, 0, 6530, 6532, 1, 0, 0, 0, 6531, 6529, 1, 0, 0, 0, 6532, + 6533, 5, 2448, 0, 0, 6533, 6535, 1, 0, 0, 0, 6534, 6510, 1, 0, 0, 0, 6534, + 6523, 1, 0, 0, 0, 6535, 507, 1, 0, 0, 0, 6536, 6538, 5, 1775, 0, 0, 6537, + 6539, 3, 1154, 577, 0, 6538, 6537, 1, 0, 0, 0, 6538, 6539, 1, 0, 0, 0, + 6539, 6542, 1, 0, 0, 0, 6540, 6541, 5, 2080, 0, 0, 6541, 6543, 3, 1656, + 828, 0, 6542, 6540, 1, 0, 0, 0, 6542, 6543, 1, 0, 0, 0, 6543, 6545, 1, + 0, 0, 0, 6544, 6546, 3, 1600, 800, 0, 6545, 6544, 1, 0, 0, 0, 6545, 6546, + 1, 0, 0, 0, 6546, 6548, 1, 0, 0, 0, 6547, 6549, 5, 2203, 0, 0, 6548, 6547, + 1, 0, 0, 0, 6548, 6549, 1, 0, 0, 0, 6549, 509, 1, 0, 0, 0, 6550, 6551, + 5, 2443, 0, 0, 6551, 511, 1, 0, 0, 0, 6552, 6553, 3, 2404, 1202, 0, 6553, + 6554, 5, 2440, 0, 0, 6554, 6556, 1, 0, 0, 0, 6555, 6552, 1, 0, 0, 0, 6555, + 6556, 1, 0, 0, 0, 6556, 6557, 1, 0, 0, 0, 6557, 6558, 3, 2404, 1202, 0, + 6558, 513, 1, 0, 0, 0, 6559, 6560, 5, 42, 0, 0, 6560, 6561, 5, 717, 0, + 0, 6561, 6564, 3, 2328, 1164, 0, 6562, 6565, 3, 516, 258, 0, 6563, 6565, + 3, 518, 259, 0, 6564, 6562, 1, 0, 0, 0, 6564, 6563, 1, 0, 0, 0, 6565, 515, + 1, 0, 0, 0, 6566, 6573, 3, 1286, 643, 0, 6567, 6573, 3, 1284, 642, 0, 6568, + 6573, 3, 1288, 644, 0, 6569, 6573, 3, 928, 464, 0, 6570, 6573, 3, 1194, + 597, 0, 6571, 6573, 3, 886, 443, 0, 6572, 6566, 1, 0, 0, 0, 6572, 6567, + 1, 0, 0, 0, 6572, 6568, 1, 0, 0, 0, 6572, 6569, 1, 0, 0, 0, 6572, 6570, + 1, 0, 0, 0, 6572, 6571, 1, 0, 0, 0, 6573, 6574, 1, 0, 0, 0, 6574, 6572, + 1, 0, 0, 0, 6574, 6575, 1, 0, 0, 0, 6575, 517, 1, 0, 0, 0, 6576, 6598, + 3, 524, 262, 0, 6577, 6578, 5, 1335, 0, 0, 6578, 6579, 5, 2447, 0, 0, 6579, + 6580, 3, 510, 255, 0, 6580, 6581, 5, 2448, 0, 0, 6581, 6598, 1, 0, 0, 0, + 6582, 6598, 5, 249, 0, 0, 6583, 6598, 3, 1308, 654, 0, 6584, 6598, 5, 2203, + 0, 0, 6585, 6598, 3, 520, 260, 0, 6586, 6587, 5, 1559, 0, 0, 6587, 6588, + 5, 2141, 0, 0, 6588, 6598, 3, 552, 276, 0, 6589, 6598, 5, 228, 0, 0, 6590, + 6591, 3, 522, 261, 0, 6591, 6592, 5, 2216, 0, 0, 6592, 6598, 1, 0, 0, 0, + 6593, 6594, 5, 2207, 0, 0, 6594, 6595, 5, 143, 0, 0, 6595, 6598, 5, 1528, + 0, 0, 6596, 6598, 3, 526, 263, 0, 6597, 6576, 1, 0, 0, 0, 6597, 6577, 1, + 0, 0, 0, 6597, 6582, 1, 0, 0, 0, 6597, 6583, 1, 0, 0, 0, 6597, 6584, 1, + 0, 0, 0, 6597, 6585, 1, 0, 0, 0, 6597, 6586, 1, 0, 0, 0, 6597, 6589, 1, + 0, 0, 0, 6597, 6590, 1, 0, 0, 0, 6597, 6593, 1, 0, 0, 0, 6597, 6596, 1, + 0, 0, 0, 6598, 519, 1, 0, 0, 0, 6599, 6600, 7, 70, 0, 0, 6600, 521, 1, + 0, 0, 0, 6601, 6602, 7, 71, 0, 0, 6602, 523, 1, 0, 0, 0, 6603, 6610, 5, + 1511, 0, 0, 6604, 6605, 5, 1348, 0, 0, 6605, 6611, 3, 1696, 848, 0, 6606, + 6607, 5, 1775, 0, 0, 6607, 6611, 3, 1154, 577, 0, 6608, 6611, 5, 1588, + 0, 0, 6609, 6611, 5, 1175, 0, 0, 6610, 6604, 1, 0, 0, 0, 6610, 6606, 1, + 0, 0, 0, 6610, 6608, 1, 0, 0, 0, 6610, 6609, 1, 0, 0, 0, 6610, 6611, 1, + 0, 0, 0, 6611, 6626, 1, 0, 0, 0, 6612, 6625, 3, 928, 464, 0, 6613, 6614, + 5, 2080, 0, 0, 6614, 6625, 3, 1656, 828, 0, 6615, 6616, 5, 1335, 0, 0, + 6616, 6617, 5, 2447, 0, 0, 6617, 6618, 3, 510, 255, 0, 6618, 6619, 5, 2448, + 0, 0, 6619, 6625, 1, 0, 0, 0, 6620, 6625, 5, 1256, 0, 0, 6621, 6625, 3, + 1194, 597, 0, 6622, 6625, 3, 1600, 800, 0, 6623, 6625, 3, 886, 443, 0, + 6624, 6612, 1, 0, 0, 0, 6624, 6613, 1, 0, 0, 0, 6624, 6615, 1, 0, 0, 0, + 6624, 6620, 1, 0, 0, 0, 6624, 6621, 1, 0, 0, 0, 6624, 6622, 1, 0, 0, 0, + 6624, 6623, 1, 0, 0, 0, 6625, 6628, 1, 0, 0, 0, 6626, 6624, 1, 0, 0, 0, + 6626, 6627, 1, 0, 0, 0, 6627, 525, 1, 0, 0, 0, 6628, 6626, 1, 0, 0, 0, + 6629, 6638, 3, 528, 264, 0, 6630, 6638, 3, 530, 265, 0, 6631, 6638, 3, + 534, 267, 0, 6632, 6638, 3, 538, 269, 0, 6633, 6638, 3, 540, 270, 0, 6634, + 6638, 3, 542, 271, 0, 6635, 6638, 3, 532, 266, 0, 6636, 6638, 3, 546, 273, + 0, 6637, 6629, 1, 0, 0, 0, 6637, 6630, 1, 0, 0, 0, 6637, 6631, 1, 0, 0, + 0, 6637, 6632, 1, 0, 0, 0, 6637, 6633, 1, 0, 0, 0, 6637, 6634, 1, 0, 0, + 0, 6637, 6635, 1, 0, 0, 0, 6637, 6636, 1, 0, 0, 0, 6638, 527, 1, 0, 0, + 0, 6639, 6640, 5, 980, 0, 0, 6640, 6641, 5, 389, 0, 0, 6641, 6645, 5, 84, + 0, 0, 6642, 6643, 5, 620, 0, 0, 6643, 6644, 5, 1348, 0, 0, 6644, 6646, + 3, 1696, 848, 0, 6645, 6642, 1, 0, 0, 0, 6645, 6646, 1, 0, 0, 0, 6646, + 6654, 1, 0, 0, 0, 6647, 6655, 3, 1194, 597, 0, 6648, 6651, 5, 2080, 0, + 0, 6649, 6652, 3, 1656, 828, 0, 6650, 6652, 5, 389, 0, 0, 6651, 6649, 1, + 0, 0, 0, 6651, 6650, 1, 0, 0, 0, 6652, 6655, 1, 0, 0, 0, 6653, 6655, 3, + 886, 443, 0, 6654, 6647, 1, 0, 0, 0, 6654, 6648, 1, 0, 0, 0, 6654, 6653, + 1, 0, 0, 0, 6655, 529, 1, 0, 0, 0, 6656, 6657, 5, 21, 0, 0, 6657, 6659, + 5, 1348, 0, 0, 6658, 6660, 3, 1696, 848, 0, 6659, 6658, 1, 0, 0, 0, 6659, + 6660, 1, 0, 0, 0, 6660, 6663, 1, 0, 0, 0, 6661, 6662, 5, 2080, 0, 0, 6662, + 6664, 3, 1656, 828, 0, 6663, 6661, 1, 0, 0, 0, 6663, 6664, 1, 0, 0, 0, + 6664, 6666, 1, 0, 0, 0, 6665, 6667, 3, 1600, 800, 0, 6666, 6665, 1, 0, + 0, 0, 6666, 6667, 1, 0, 0, 0, 6667, 6669, 1, 0, 0, 0, 6668, 6670, 3, 928, + 464, 0, 6669, 6668, 1, 0, 0, 0, 6669, 6670, 1, 0, 0, 0, 6670, 531, 1, 0, + 0, 0, 6671, 6672, 5, 228, 0, 0, 6672, 6674, 5, 1348, 0, 0, 6673, 6675, + 3, 928, 464, 0, 6674, 6673, 1, 0, 0, 0, 6674, 6675, 1, 0, 0, 0, 6675, 533, + 1, 0, 0, 0, 6676, 6677, 5, 980, 0, 0, 6677, 6678, 5, 1348, 0, 0, 6678, + 6694, 3, 1696, 848, 0, 6679, 6681, 3, 536, 268, 0, 6680, 6679, 1, 0, 0, + 0, 6681, 6682, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, + 0, 6683, 6695, 1, 0, 0, 0, 6684, 6685, 5, 1335, 0, 0, 6685, 6686, 5, 2447, + 0, 0, 6686, 6687, 3, 510, 255, 0, 6687, 6688, 5, 2448, 0, 0, 6688, 6695, + 1, 0, 0, 0, 6689, 6695, 5, 228, 0, 0, 6690, 6691, 5, 2207, 0, 0, 6691, + 6692, 5, 143, 0, 0, 6692, 6695, 5, 1528, 0, 0, 6693, 6695, 5, 2203, 0, + 0, 6694, 6680, 1, 0, 0, 0, 6694, 6684, 1, 0, 0, 0, 6694, 6689, 1, 0, 0, + 0, 6694, 6690, 1, 0, 0, 0, 6694, 6693, 1, 0, 0, 0, 6695, 535, 1, 0, 0, + 0, 6696, 6703, 3, 1286, 643, 0, 6697, 6703, 3, 1284, 642, 0, 6698, 6703, + 3, 1194, 597, 0, 6699, 6703, 3, 886, 443, 0, 6700, 6703, 3, 1600, 800, + 0, 6701, 6703, 3, 1288, 644, 0, 6702, 6696, 1, 0, 0, 0, 6702, 6697, 1, + 0, 0, 0, 6702, 6698, 1, 0, 0, 0, 6702, 6699, 1, 0, 0, 0, 6702, 6700, 1, + 0, 0, 0, 6702, 6701, 1, 0, 0, 0, 6703, 537, 1, 0, 0, 0, 6704, 6709, 5, + 1559, 0, 0, 6705, 6706, 5, 1348, 0, 0, 6706, 6710, 3, 1696, 848, 0, 6707, + 6708, 5, 1775, 0, 0, 6708, 6710, 3, 1154, 577, 0, 6709, 6705, 1, 0, 0, + 0, 6709, 6707, 1, 0, 0, 0, 6710, 6711, 1, 0, 0, 0, 6711, 6712, 5, 2141, + 0, 0, 6712, 6713, 3, 550, 275, 0, 6713, 539, 1, 0, 0, 0, 6714, 6715, 5, + 469, 0, 0, 6715, 6716, 5, 1348, 0, 0, 6716, 6717, 3, 1696, 848, 0, 6717, + 541, 1, 0, 0, 0, 6718, 6719, 5, 1717, 0, 0, 6719, 6720, 5, 1348, 0, 0, + 6720, 6721, 3, 548, 274, 0, 6721, 6722, 5, 82, 0, 0, 6722, 6723, 5, 2447, + 0, 0, 6723, 6728, 3, 2186, 1093, 0, 6724, 6725, 5, 2453, 0, 0, 6725, 6727, + 3, 2186, 1093, 0, 6726, 6724, 1, 0, 0, 0, 6727, 6730, 1, 0, 0, 0, 6728, + 6726, 1, 0, 0, 0, 6728, 6729, 1, 0, 0, 0, 6729, 6731, 1, 0, 0, 0, 6730, + 6728, 1, 0, 0, 0, 6731, 6739, 5, 2448, 0, 0, 6732, 6733, 5, 779, 0, 0, + 6733, 6734, 5, 2447, 0, 0, 6734, 6735, 3, 544, 272, 0, 6735, 6736, 5, 2453, + 0, 0, 6736, 6737, 3, 544, 272, 0, 6737, 6738, 5, 2448, 0, 0, 6738, 6740, + 1, 0, 0, 0, 6739, 6732, 1, 0, 0, 0, 6739, 6740, 1, 0, 0, 0, 6740, 6742, + 1, 0, 0, 0, 6741, 6743, 3, 928, 464, 0, 6742, 6741, 1, 0, 0, 0, 6742, 6743, + 1, 0, 0, 0, 6743, 543, 1, 0, 0, 0, 6744, 6762, 5, 1348, 0, 0, 6745, 6757, + 3, 1696, 848, 0, 6746, 6749, 3, 1200, 600, 0, 6747, 6749, 3, 1600, 800, + 0, 6748, 6746, 1, 0, 0, 0, 6748, 6747, 1, 0, 0, 0, 6749, 6750, 1, 0, 0, + 0, 6750, 6748, 1, 0, 0, 0, 6750, 6751, 1, 0, 0, 0, 6751, 6758, 1, 0, 0, + 0, 6752, 6753, 5, 1335, 0, 0, 6753, 6754, 5, 2447, 0, 0, 6754, 6755, 3, + 510, 255, 0, 6755, 6756, 5, 2448, 0, 0, 6756, 6758, 1, 0, 0, 0, 6757, 6748, + 1, 0, 0, 0, 6757, 6752, 1, 0, 0, 0, 6758, 6760, 1, 0, 0, 0, 6759, 6761, + 5, 2203, 0, 0, 6760, 6759, 1, 0, 0, 0, 6760, 6761, 1, 0, 0, 0, 6761, 6763, + 1, 0, 0, 0, 6762, 6745, 1, 0, 0, 0, 6762, 6763, 1, 0, 0, 0, 6763, 545, + 1, 0, 0, 0, 6764, 6765, 5, 980, 0, 0, 6765, 6766, 5, 1775, 0, 0, 6766, + 6769, 3, 1154, 577, 0, 6767, 6770, 5, 2203, 0, 0, 6768, 6770, 3, 536, 268, + 0, 6769, 6767, 1, 0, 0, 0, 6769, 6768, 1, 0, 0, 0, 6770, 547, 1, 0, 0, + 0, 6771, 6772, 3, 1696, 848, 0, 6772, 549, 1, 0, 0, 0, 6773, 6774, 3, 1696, + 848, 0, 6774, 551, 1, 0, 0, 0, 6775, 6776, 3, 2328, 1164, 0, 6776, 553, + 1, 0, 0, 0, 6777, 6778, 5, 42, 0, 0, 6778, 6779, 5, 746, 0, 0, 6779, 6780, + 5, 794, 0, 0, 6780, 6784, 5, 649, 0, 0, 6781, 6782, 3, 2286, 1143, 0, 6782, + 6783, 5, 2440, 0, 0, 6783, 6785, 1, 0, 0, 0, 6784, 6781, 1, 0, 0, 0, 6784, + 6785, 1, 0, 0, 0, 6785, 6786, 1, 0, 0, 0, 6786, 6787, 3, 2404, 1202, 0, + 6787, 6788, 7, 72, 0, 0, 6788, 6792, 5, 2447, 0, 0, 6789, 6790, 3, 2286, + 1143, 0, 6790, 6791, 5, 2440, 0, 0, 6791, 6793, 1, 0, 0, 0, 6792, 6789, + 1, 0, 0, 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, 1, 0, 0, 0, 6794, 6795, + 3, 2404, 1202, 0, 6795, 6796, 5, 2447, 0, 0, 6796, 6797, 3, 2404, 1202, + 0, 6797, 6798, 5, 2448, 0, 0, 6798, 6799, 5, 2448, 0, 0, 6799, 555, 1, + 0, 0, 0, 6800, 6801, 5, 321, 0, 0, 6801, 6802, 5, 2237, 0, 0, 6802, 6806, + 3, 2354, 1177, 0, 6803, 6804, 5, 691, 0, 0, 6804, 6805, 5, 1204, 0, 0, + 6805, 6807, 5, 545, 0, 0, 6806, 6803, 1, 0, 0, 0, 6806, 6807, 1, 0, 0, + 0, 6807, 6817, 1, 0, 0, 0, 6808, 6818, 3, 564, 282, 0, 6809, 6818, 3, 566, + 283, 0, 6810, 6818, 3, 568, 284, 0, 6811, 6818, 3, 570, 285, 0, 6812, 6818, + 3, 572, 286, 0, 6813, 6818, 3, 578, 289, 0, 6814, 6818, 3, 580, 290, 0, + 6815, 6818, 3, 582, 291, 0, 6816, 6818, 3, 766, 383, 0, 6817, 6808, 1, + 0, 0, 0, 6817, 6809, 1, 0, 0, 0, 6817, 6810, 1, 0, 0, 0, 6817, 6811, 1, + 0, 0, 0, 6817, 6812, 1, 0, 0, 0, 6817, 6813, 1, 0, 0, 0, 6817, 6814, 1, + 0, 0, 0, 6817, 6815, 1, 0, 0, 0, 6817, 6816, 1, 0, 0, 0, 6818, 6819, 1, + 0, 0, 0, 6819, 6817, 1, 0, 0, 0, 6819, 6820, 1, 0, 0, 0, 6820, 557, 1, + 0, 0, 0, 6821, 6822, 5, 42, 0, 0, 6822, 6823, 5, 2237, 0, 0, 6823, 6835, + 3, 2354, 1177, 0, 6824, 6836, 3, 562, 281, 0, 6825, 6836, 3, 566, 283, + 0, 6826, 6836, 3, 568, 284, 0, 6827, 6836, 3, 570, 285, 0, 6828, 6836, + 3, 572, 286, 0, 6829, 6836, 3, 576, 288, 0, 6830, 6836, 3, 578, 289, 0, + 6831, 6836, 3, 580, 290, 0, 6832, 6836, 3, 584, 292, 0, 6833, 6836, 3, + 766, 383, 0, 6834, 6836, 3, 594, 297, 0, 6835, 6824, 1, 0, 0, 0, 6835, + 6825, 1, 0, 0, 0, 6835, 6826, 1, 0, 0, 0, 6835, 6827, 1, 0, 0, 0, 6835, + 6828, 1, 0, 0, 0, 6835, 6829, 1, 0, 0, 0, 6835, 6830, 1, 0, 0, 0, 6835, + 6831, 1, 0, 0, 0, 6835, 6832, 1, 0, 0, 0, 6835, 6833, 1, 0, 0, 0, 6835, + 6834, 1, 0, 0, 0, 6836, 6837, 1, 0, 0, 0, 6837, 6835, 1, 0, 0, 0, 6837, + 6838, 1, 0, 0, 0, 6838, 6850, 1, 0, 0, 0, 6839, 6844, 3, 2354, 1177, 0, + 6840, 6841, 5, 2453, 0, 0, 6841, 6843, 3, 2354, 1177, 0, 6842, 6840, 1, + 0, 0, 0, 6843, 6846, 1, 0, 0, 0, 6844, 6842, 1, 0, 0, 0, 6844, 6845, 1, + 0, 0, 0, 6845, 6847, 1, 0, 0, 0, 6846, 6844, 1, 0, 0, 0, 6847, 6848, 3, + 586, 293, 0, 6848, 6850, 1, 0, 0, 0, 6849, 6821, 1, 0, 0, 0, 6849, 6839, + 1, 0, 0, 0, 6850, 559, 1, 0, 0, 0, 6851, 6852, 5, 469, 0, 0, 6852, 6853, + 5, 2237, 0, 0, 6853, 6856, 3, 2354, 1177, 0, 6854, 6855, 5, 691, 0, 0, + 6855, 6857, 5, 545, 0, 0, 6856, 6854, 1, 0, 0, 0, 6856, 6857, 1, 0, 0, + 0, 6857, 6859, 1, 0, 0, 0, 6858, 6860, 5, 179, 0, 0, 6859, 6858, 1, 0, + 0, 0, 6859, 6860, 1, 0, 0, 0, 6860, 561, 1, 0, 0, 0, 6861, 6864, 3, 564, + 282, 0, 6862, 6863, 5, 1562, 0, 0, 6863, 6865, 3, 2404, 1202, 0, 6864, + 6862, 1, 0, 0, 0, 6864, 6865, 1, 0, 0, 0, 6865, 563, 1, 0, 0, 0, 6866, + 6867, 5, 685, 0, 0, 6867, 6868, 5, 160, 0, 0, 6868, 6869, 3, 2404, 1202, + 0, 6869, 565, 1, 0, 0, 0, 6870, 6871, 5, 685, 0, 0, 6871, 6874, 7, 73, + 0, 0, 6872, 6873, 5, 69, 0, 0, 6873, 6875, 3, 2400, 1200, 0, 6874, 6872, + 1, 0, 0, 0, 6874, 6875, 1, 0, 0, 0, 6875, 567, 1, 0, 0, 0, 6876, 6877, + 7, 74, 0, 0, 6877, 6878, 5, 2080, 0, 0, 6878, 6879, 3, 2404, 1202, 0, 6879, + 569, 1, 0, 0, 0, 6880, 6883, 5, 1490, 0, 0, 6881, 6884, 3, 1176, 588, 0, + 6882, 6884, 5, 2185, 0, 0, 6883, 6881, 1, 0, 0, 0, 6883, 6882, 1, 0, 0, + 0, 6884, 6885, 1, 0, 0, 0, 6885, 6886, 5, 1259, 0, 0, 6886, 6887, 3, 2404, + 1202, 0, 6887, 571, 1, 0, 0, 0, 6888, 6889, 5, 1463, 0, 0, 6889, 6890, + 3, 2404, 1202, 0, 6890, 573, 1, 0, 0, 0, 6891, 6896, 3, 2308, 1154, 0, + 6892, 6893, 5, 2453, 0, 0, 6893, 6895, 3, 2308, 1154, 0, 6894, 6892, 1, + 0, 0, 0, 6895, 6898, 1, 0, 0, 0, 6896, 6894, 1, 0, 0, 0, 6896, 6897, 1, + 0, 0, 0, 6897, 6915, 1, 0, 0, 0, 6898, 6896, 1, 0, 0, 0, 6899, 6911, 5, + 38, 0, 0, 6900, 6901, 5, 534, 0, 0, 6901, 6906, 3, 2308, 1154, 0, 6902, + 6903, 5, 2453, 0, 0, 6903, 6905, 3, 2308, 1154, 0, 6904, 6902, 1, 0, 0, + 0, 6905, 6908, 1, 0, 0, 0, 6906, 6904, 1, 0, 0, 0, 6906, 6907, 1, 0, 0, + 0, 6907, 6910, 1, 0, 0, 0, 6908, 6906, 1, 0, 0, 0, 6909, 6900, 1, 0, 0, + 0, 6910, 6913, 1, 0, 0, 0, 6911, 6909, 1, 0, 0, 0, 6911, 6912, 1, 0, 0, + 0, 6912, 6915, 1, 0, 0, 0, 6913, 6911, 1, 0, 0, 0, 6914, 6891, 1, 0, 0, + 0, 6914, 6899, 1, 0, 0, 0, 6915, 575, 1, 0, 0, 0, 6916, 6917, 5, 389, 0, + 0, 6917, 6920, 5, 1593, 0, 0, 6918, 6921, 5, 1133, 0, 0, 6919, 6921, 3, + 574, 287, 0, 6920, 6918, 1, 0, 0, 0, 6920, 6919, 1, 0, 0, 0, 6921, 577, + 1, 0, 0, 0, 6922, 6923, 5, 1356, 0, 0, 6923, 6924, 5, 551, 0, 0, 6924, + 579, 1, 0, 0, 0, 6925, 6926, 5, 7, 0, 0, 6926, 6927, 7, 75, 0, 0, 6927, + 581, 1, 0, 0, 0, 6928, 6929, 5, 499, 0, 0, 6929, 6930, 5, 485, 0, 0, 6930, + 583, 1, 0, 0, 0, 6931, 6941, 3, 582, 291, 0, 6932, 6933, 5, 620, 0, 0, + 6933, 6938, 3, 2410, 1205, 0, 6934, 6935, 5, 2453, 0, 0, 6935, 6937, 3, + 2410, 1205, 0, 6936, 6934, 1, 0, 0, 0, 6937, 6940, 1, 0, 0, 0, 6938, 6936, + 1, 0, 0, 0, 6938, 6939, 1, 0, 0, 0, 6939, 6942, 1, 0, 0, 0, 6940, 6938, + 1, 0, 0, 0, 6941, 6932, 1, 0, 0, 0, 6941, 6942, 1, 0, 0, 0, 6942, 6944, + 1, 0, 0, 0, 6943, 6945, 5, 616, 0, 0, 6944, 6943, 1, 0, 0, 0, 6944, 6945, + 1, 0, 0, 0, 6945, 585, 1, 0, 0, 0, 6946, 6947, 5, 1589, 0, 0, 6947, 6948, + 5, 280, 0, 0, 6948, 6952, 5, 2103, 0, 0, 6949, 6950, 5, 514, 0, 0, 6950, + 6953, 5, 2235, 0, 0, 6951, 6953, 3, 2354, 1177, 0, 6952, 6949, 1, 0, 0, + 0, 6952, 6951, 1, 0, 0, 0, 6953, 6986, 1, 0, 0, 0, 6954, 6955, 5, 647, + 0, 0, 6955, 6956, 5, 280, 0, 0, 6956, 6983, 5, 2103, 0, 0, 6957, 6958, + 5, 514, 0, 0, 6958, 6984, 5, 2235, 0, 0, 6959, 6967, 3, 2354, 1177, 0, + 6960, 6965, 5, 2308, 0, 0, 6961, 6962, 5, 1137, 0, 0, 6962, 6966, 5, 1595, + 0, 0, 6963, 6964, 5, 1593, 0, 0, 6964, 6966, 3, 574, 287, 0, 6965, 6961, + 1, 0, 0, 0, 6965, 6963, 1, 0, 0, 0, 6966, 6968, 1, 0, 0, 0, 6967, 6960, + 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 6971, 1, 0, 0, 0, 6969, 6970, + 5, 87, 0, 0, 6970, 6972, 5, 1564, 0, 0, 6971, 6969, 1, 0, 0, 0, 6971, 6972, + 1, 0, 0, 0, 6972, 6981, 1, 0, 0, 0, 6973, 6974, 5, 86, 0, 0, 6974, 6979, + 5, 2246, 0, 0, 6975, 6980, 5, 1356, 0, 0, 6976, 6980, 5, 187, 0, 0, 6977, + 6978, 5, 446, 0, 0, 6978, 6980, 5, 997, 0, 0, 6979, 6975, 1, 0, 0, 0, 6979, + 6976, 1, 0, 0, 0, 6979, 6977, 1, 0, 0, 0, 6980, 6982, 1, 0, 0, 0, 6981, + 6973, 1, 0, 0, 0, 6981, 6982, 1, 0, 0, 0, 6982, 6984, 1, 0, 0, 0, 6983, + 6957, 1, 0, 0, 0, 6983, 6959, 1, 0, 0, 0, 6984, 6986, 1, 0, 0, 0, 6985, + 6946, 1, 0, 0, 0, 6985, 6954, 1, 0, 0, 0, 6986, 587, 1, 0, 0, 0, 6987, + 6988, 5, 2447, 0, 0, 6988, 6993, 3, 2404, 1202, 0, 6989, 6990, 5, 2453, + 0, 0, 6990, 6992, 3, 2404, 1202, 0, 6991, 6989, 1, 0, 0, 0, 6992, 6995, + 1, 0, 0, 0, 6993, 6991, 1, 0, 0, 0, 6993, 6994, 1, 0, 0, 0, 6994, 6996, + 1, 0, 0, 0, 6995, 6993, 1, 0, 0, 0, 6996, 6997, 5, 2448, 0, 0, 6997, 589, + 1, 0, 0, 0, 6998, 6999, 5, 1671, 0, 0, 6999, 7000, 5, 292, 0, 0, 7000, + 7004, 5, 2472, 0, 0, 7001, 7005, 5, 38, 0, 0, 7002, 7005, 5, 389, 0, 0, + 7003, 7005, 3, 588, 294, 0, 7004, 7001, 1, 0, 0, 0, 7004, 7002, 1, 0, 0, + 0, 7004, 7003, 1, 0, 0, 0, 7005, 591, 1, 0, 0, 0, 7006, 7007, 7, 72, 0, + 0, 7007, 7008, 5, 292, 0, 0, 7008, 7009, 5, 2472, 0, 0, 7009, 7010, 3, + 588, 294, 0, 7010, 593, 1, 0, 0, 0, 7011, 7018, 3, 590, 295, 0, 7012, 7015, + 3, 592, 296, 0, 7013, 7014, 5, 620, 0, 0, 7014, 7016, 3, 2300, 1150, 0, + 7015, 7013, 1, 0, 0, 0, 7015, 7016, 1, 0, 0, 0, 7016, 7018, 1, 0, 0, 0, + 7017, 7011, 1, 0, 0, 0, 7017, 7012, 1, 0, 0, 0, 7018, 595, 1, 0, 0, 0, + 7019, 7020, 5, 27, 0, 0, 7020, 7021, 5, 816, 0, 0, 7021, 7026, 5, 906, + 0, 0, 7022, 7027, 3, 598, 299, 0, 7023, 7027, 3, 620, 310, 0, 7024, 7027, + 3, 650, 325, 0, 7025, 7027, 3, 660, 330, 0, 7026, 7022, 1, 0, 0, 0, 7026, + 7023, 1, 0, 0, 0, 7026, 7024, 1, 0, 0, 0, 7026, 7025, 1, 0, 0, 0, 7027, + 597, 1, 0, 0, 0, 7028, 7038, 3, 600, 300, 0, 7029, 7038, 3, 602, 301, 0, + 7030, 7038, 3, 606, 303, 0, 7031, 7038, 3, 608, 304, 0, 7032, 7038, 3, + 610, 305, 0, 7033, 7038, 3, 612, 306, 0, 7034, 7038, 3, 614, 307, 0, 7035, + 7038, 3, 616, 308, 0, 7036, 7038, 3, 618, 309, 0, 7037, 7028, 1, 0, 0, + 0, 7037, 7029, 1, 0, 0, 0, 7037, 7030, 1, 0, 0, 0, 7037, 7031, 1, 0, 0, + 0, 7037, 7032, 1, 0, 0, 0, 7037, 7033, 1, 0, 0, 0, 7037, 7034, 1, 0, 0, + 0, 7037, 7035, 1, 0, 0, 0, 7037, 7036, 1, 0, 0, 0, 7038, 599, 1, 0, 0, + 0, 7039, 7050, 5, 321, 0, 0, 7040, 7041, 5, 820, 0, 0, 7041, 7051, 5, 2443, + 0, 0, 7042, 7044, 5, 873, 0, 0, 7043, 7042, 1, 0, 0, 0, 7043, 7044, 1, + 0, 0, 0, 7044, 7045, 1, 0, 0, 0, 7045, 7046, 5, 94, 0, 0, 7046, 7047, 5, + 820, 0, 0, 7047, 7048, 5, 628, 0, 0, 7048, 7049, 5, 820, 0, 0, 7049, 7051, + 5, 2443, 0, 0, 7050, 7040, 1, 0, 0, 0, 7050, 7043, 1, 0, 0, 0, 7051, 7052, + 1, 0, 0, 0, 7052, 7053, 5, 685, 0, 0, 7053, 7054, 5, 160, 0, 0, 7054, 7055, + 3, 666, 333, 0, 7055, 601, 1, 0, 0, 0, 7056, 7057, 5, 1671, 0, 0, 7057, + 7058, 5, 820, 0, 0, 7058, 7060, 5, 1264, 0, 0, 7059, 7061, 3, 604, 302, + 0, 7060, 7059, 1, 0, 0, 0, 7060, 7061, 1, 0, 0, 0, 7061, 7062, 1, 0, 0, + 0, 7062, 7064, 3, 644, 322, 0, 7063, 7065, 3, 766, 383, 0, 7064, 7063, + 1, 0, 0, 0, 7064, 7065, 1, 0, 0, 0, 7065, 603, 1, 0, 0, 0, 7066, 7067, + 5, 616, 0, 0, 7067, 7068, 5, 820, 0, 0, 7068, 605, 1, 0, 0, 0, 7069, 7070, + 5, 1671, 0, 0, 7070, 7071, 5, 820, 0, 0, 7071, 7073, 5, 218, 0, 0, 7072, + 7074, 3, 644, 322, 0, 7073, 7072, 1, 0, 0, 0, 7073, 7074, 1, 0, 0, 0, 7074, + 7076, 1, 0, 0, 0, 7075, 7077, 3, 766, 383, 0, 7076, 7075, 1, 0, 0, 0, 7076, + 7077, 1, 0, 0, 0, 7077, 607, 1, 0, 0, 0, 7078, 7079, 5, 102, 0, 0, 7079, + 7082, 5, 820, 0, 0, 7080, 7081, 5, 2246, 0, 0, 7081, 7083, 5, 2443, 0, + 0, 7082, 7080, 1, 0, 0, 0, 7082, 7083, 1, 0, 0, 0, 7083, 7085, 1, 0, 0, + 0, 7084, 7086, 3, 604, 302, 0, 7085, 7084, 1, 0, 0, 0, 7085, 7086, 1, 0, + 0, 0, 7086, 7087, 1, 0, 0, 0, 7087, 7090, 3, 644, 322, 0, 7088, 7089, 5, + 2141, 0, 0, 7089, 7091, 5, 2443, 0, 0, 7090, 7088, 1, 0, 0, 0, 7090, 7091, + 1, 0, 0, 0, 7091, 609, 1, 0, 0, 0, 7092, 7093, 5, 42, 0, 0, 7093, 7094, + 5, 820, 0, 0, 7094, 7096, 5, 1356, 0, 0, 7095, 7097, 3, 604, 302, 0, 7096, + 7095, 1, 0, 0, 0, 7096, 7097, 1, 0, 0, 0, 7097, 7098, 1, 0, 0, 0, 7098, + 7099, 5, 685, 0, 0, 7099, 7100, 5, 160, 0, 0, 7100, 7101, 3, 666, 333, + 0, 7101, 7102, 5, 1671, 0, 0, 7102, 7104, 3, 666, 333, 0, 7103, 7105, 3, + 662, 331, 0, 7104, 7103, 1, 0, 0, 0, 7104, 7105, 1, 0, 0, 0, 7105, 611, + 1, 0, 0, 0, 7106, 7107, 5, 946, 0, 0, 7107, 7108, 5, 820, 0, 0, 7108, 7110, + 5, 2443, 0, 0, 7109, 7111, 3, 664, 332, 0, 7110, 7109, 1, 0, 0, 0, 7110, + 7111, 1, 0, 0, 0, 7111, 7112, 1, 0, 0, 0, 7112, 7113, 5, 49, 0, 0, 7113, + 7114, 5, 820, 0, 0, 7114, 7116, 5, 2443, 0, 0, 7115, 7117, 3, 664, 332, + 0, 7116, 7115, 1, 0, 0, 0, 7116, 7117, 1, 0, 0, 0, 7117, 7118, 1, 0, 0, + 0, 7118, 7119, 5, 779, 0, 0, 7119, 7120, 5, 1021, 0, 0, 7120, 7121, 5, + 820, 0, 0, 7121, 7122, 5, 2443, 0, 0, 7122, 7123, 3, 664, 332, 0, 7123, + 613, 1, 0, 0, 0, 7124, 7125, 5, 946, 0, 0, 7125, 7126, 5, 820, 0, 0, 7126, + 7128, 5, 2443, 0, 0, 7127, 7129, 3, 664, 332, 0, 7128, 7127, 1, 0, 0, 0, + 7128, 7129, 1, 0, 0, 0, 7129, 7130, 1, 0, 0, 0, 7130, 7131, 5, 779, 0, + 0, 7131, 7132, 5, 544, 0, 0, 7132, 7133, 5, 820, 0, 0, 7133, 7134, 5, 2443, + 0, 0, 7134, 7136, 3, 664, 332, 0, 7135, 7137, 3, 662, 331, 0, 7136, 7135, + 1, 0, 0, 0, 7136, 7137, 1, 0, 0, 0, 7137, 615, 1, 0, 0, 0, 7138, 7140, + 5, 616, 0, 0, 7139, 7138, 1, 0, 0, 0, 7139, 7140, 1, 0, 0, 0, 7140, 7141, + 1, 0, 0, 0, 7141, 7142, 5, 2387, 0, 0, 7142, 7143, 5, 820, 0, 0, 7143, + 7144, 5, 685, 0, 0, 7144, 7145, 5, 160, 0, 0, 7145, 7146, 3, 666, 333, + 0, 7146, 7147, 5, 628, 0, 0, 7147, 7148, 5, 2388, 0, 0, 7148, 7150, 5, + 820, 0, 0, 7149, 7151, 3, 604, 302, 0, 7150, 7149, 1, 0, 0, 0, 7150, 7151, + 1, 0, 0, 0, 7151, 7152, 1, 0, 0, 0, 7152, 7154, 3, 644, 322, 0, 7153, 7155, + 3, 662, 331, 0, 7154, 7153, 1, 0, 0, 0, 7154, 7155, 1, 0, 0, 0, 7155, 617, + 1, 0, 0, 0, 7156, 7157, 5, 2389, 0, 0, 7157, 7158, 5, 820, 0, 0, 7158, + 7159, 5, 685, 0, 0, 7159, 7160, 5, 160, 0, 0, 7160, 7161, 3, 666, 333, + 0, 7161, 7162, 5, 2308, 0, 0, 7162, 7163, 5, 2388, 0, 0, 7163, 7165, 5, + 820, 0, 0, 7164, 7166, 3, 604, 302, 0, 7165, 7164, 1, 0, 0, 0, 7165, 7166, + 1, 0, 0, 0, 7166, 7167, 1, 0, 0, 0, 7167, 7169, 3, 644, 322, 0, 7168, 7170, + 3, 662, 331, 0, 7169, 7168, 1, 0, 0, 0, 7169, 7170, 1, 0, 0, 0, 7170, 619, + 1, 0, 0, 0, 7171, 7181, 3, 622, 311, 0, 7172, 7181, 3, 624, 312, 0, 7173, + 7181, 3, 630, 315, 0, 7174, 7181, 3, 632, 316, 0, 7175, 7181, 3, 634, 317, + 0, 7176, 7181, 3, 636, 318, 0, 7177, 7181, 3, 638, 319, 0, 7178, 7181, + 3, 640, 320, 0, 7179, 7181, 3, 642, 321, 0, 7180, 7171, 1, 0, 0, 0, 7180, + 7172, 1, 0, 0, 0, 7180, 7173, 1, 0, 0, 0, 7180, 7174, 1, 0, 0, 0, 7180, + 7175, 1, 0, 0, 0, 7180, 7176, 1, 0, 0, 0, 7180, 7177, 1, 0, 0, 0, 7180, + 7178, 1, 0, 0, 0, 7180, 7179, 1, 0, 0, 0, 7181, 621, 1, 0, 0, 0, 7182, + 7184, 5, 1671, 0, 0, 7183, 7185, 5, 506, 0, 0, 7184, 7183, 1, 0, 0, 0, + 7184, 7185, 1, 0, 0, 0, 7185, 7186, 1, 0, 0, 0, 7186, 7193, 5, 816, 0, + 0, 7187, 7188, 3, 626, 313, 0, 7188, 7189, 5, 2469, 0, 0, 7189, 7191, 1, + 0, 0, 0, 7190, 7187, 1, 0, 0, 0, 7190, 7191, 1, 0, 0, 0, 7191, 7192, 1, + 0, 0, 0, 7192, 7194, 3, 628, 314, 0, 7193, 7190, 1, 0, 0, 0, 7193, 7194, + 1, 0, 0, 0, 7194, 7196, 1, 0, 0, 0, 7195, 7197, 3, 648, 324, 0, 7196, 7195, + 1, 0, 0, 0, 7196, 7197, 1, 0, 0, 0, 7197, 7199, 1, 0, 0, 0, 7198, 7200, + 3, 646, 323, 0, 7199, 7198, 1, 0, 0, 0, 7199, 7200, 1, 0, 0, 0, 7200, 7202, + 1, 0, 0, 0, 7201, 7203, 3, 604, 302, 0, 7202, 7201, 1, 0, 0, 0, 7202, 7203, + 1, 0, 0, 0, 7203, 7204, 1, 0, 0, 0, 7204, 7206, 3, 644, 322, 0, 7205, 7207, + 3, 662, 331, 0, 7206, 7205, 1, 0, 0, 0, 7206, 7207, 1, 0, 0, 0, 7207, 7209, + 1, 0, 0, 0, 7208, 7210, 3, 766, 383, 0, 7209, 7208, 1, 0, 0, 0, 7209, 7210, + 1, 0, 0, 0, 7210, 623, 1, 0, 0, 0, 7211, 7213, 5, 321, 0, 0, 7212, 7214, + 5, 506, 0, 0, 7213, 7212, 1, 0, 0, 0, 7213, 7214, 1, 0, 0, 0, 7214, 7215, + 1, 0, 0, 0, 7215, 7222, 5, 816, 0, 0, 7216, 7217, 3, 626, 313, 0, 7217, + 7218, 5, 2469, 0, 0, 7218, 7220, 1, 0, 0, 0, 7219, 7216, 1, 0, 0, 0, 7219, + 7220, 1, 0, 0, 0, 7220, 7221, 1, 0, 0, 0, 7221, 7223, 3, 628, 314, 0, 7222, + 7219, 1, 0, 0, 0, 7222, 7223, 1, 0, 0, 0, 7223, 7225, 1, 0, 0, 0, 7224, + 7226, 3, 648, 324, 0, 7225, 7224, 1, 0, 0, 0, 7225, 7226, 1, 0, 0, 0, 7226, + 7228, 1, 0, 0, 0, 7227, 7229, 3, 646, 323, 0, 7228, 7227, 1, 0, 0, 0, 7228, + 7229, 1, 0, 0, 0, 7229, 7231, 1, 0, 0, 0, 7230, 7232, 3, 604, 302, 0, 7231, + 7230, 1, 0, 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7233, 1, 0, 0, 0, 7233, + 7235, 3, 644, 322, 0, 7234, 7236, 3, 662, 331, 0, 7235, 7234, 1, 0, 0, + 0, 7235, 7236, 1, 0, 0, 0, 7236, 7238, 1, 0, 0, 0, 7237, 7239, 3, 766, + 383, 0, 7238, 7237, 1, 0, 0, 0, 7238, 7239, 1, 0, 0, 0, 7239, 625, 1, 0, + 0, 0, 7240, 7241, 5, 2443, 0, 0, 7241, 627, 1, 0, 0, 0, 7242, 7243, 5, + 2443, 0, 0, 7243, 629, 1, 0, 0, 0, 7244, 7246, 5, 2241, 0, 0, 7245, 7247, + 5, 506, 0, 0, 7246, 7245, 1, 0, 0, 0, 7246, 7247, 1, 0, 0, 0, 7247, 7248, + 1, 0, 0, 0, 7248, 7249, 5, 816, 0, 0, 7249, 7251, 5, 2443, 0, 0, 7250, + 7252, 3, 648, 324, 0, 7251, 7250, 1, 0, 0, 0, 7251, 7252, 1, 0, 0, 0, 7252, + 7254, 1, 0, 0, 0, 7253, 7255, 3, 604, 302, 0, 7254, 7253, 1, 0, 0, 0, 7254, + 7255, 1, 0, 0, 0, 7255, 7256, 1, 0, 0, 0, 7256, 7258, 3, 644, 322, 0, 7257, + 7259, 3, 662, 331, 0, 7258, 7257, 1, 0, 0, 0, 7258, 7259, 1, 0, 0, 0, 7259, + 631, 1, 0, 0, 0, 7260, 7261, 5, 1671, 0, 0, 7261, 7262, 5, 2085, 0, 0, + 7262, 7263, 5, 2443, 0, 0, 7263, 7264, 5, 620, 0, 0, 7264, 7266, 5, 2443, + 0, 0, 7265, 7267, 3, 604, 302, 0, 7266, 7265, 1, 0, 0, 0, 7266, 7267, 1, + 0, 0, 0, 7267, 7268, 1, 0, 0, 0, 7268, 7270, 3, 644, 322, 0, 7269, 7271, + 3, 662, 331, 0, 7270, 7269, 1, 0, 0, 0, 7270, 7271, 1, 0, 0, 0, 7271, 633, + 1, 0, 0, 0, 7272, 7274, 5, 554, 0, 0, 7273, 7275, 5, 506, 0, 0, 7274, 7273, + 1, 0, 0, 0, 7274, 7275, 1, 0, 0, 0, 7275, 7276, 1, 0, 0, 0, 7276, 7277, + 5, 819, 0, 0, 7277, 7278, 5, 2308, 0, 0, 7278, 7279, 5, 1638, 0, 0, 7279, + 7280, 3, 670, 335, 0, 7280, 7281, 5, 2141, 0, 0, 7281, 7283, 3, 1458, 729, + 0, 7282, 7284, 3, 604, 302, 0, 7283, 7282, 1, 0, 0, 0, 7283, 7284, 1, 0, + 0, 0, 7284, 7285, 1, 0, 0, 0, 7285, 7303, 3, 644, 322, 0, 7286, 7287, 5, + 2308, 0, 0, 7287, 7288, 5, 686, 0, 0, 7288, 7301, 5, 738, 0, 0, 7289, 7294, + 5, 2443, 0, 0, 7290, 7291, 5, 2453, 0, 0, 7291, 7293, 5, 2443, 0, 0, 7292, + 7290, 1, 0, 0, 0, 7293, 7296, 1, 0, 0, 0, 7294, 7292, 1, 0, 0, 0, 7294, + 7295, 1, 0, 0, 0, 7295, 7302, 1, 0, 0, 0, 7296, 7294, 1, 0, 0, 0, 7297, + 7298, 5, 2447, 0, 0, 7298, 7299, 3, 1896, 948, 0, 7299, 7300, 5, 2448, + 0, 0, 7300, 7302, 1, 0, 0, 0, 7301, 7289, 1, 0, 0, 0, 7301, 7297, 1, 0, + 0, 0, 7302, 7304, 1, 0, 0, 0, 7303, 7286, 1, 0, 0, 0, 7303, 7304, 1, 0, + 0, 0, 7304, 635, 1, 0, 0, 0, 7305, 7307, 5, 700, 0, 0, 7306, 7308, 5, 506, + 0, 0, 7307, 7306, 1, 0, 0, 0, 7307, 7308, 1, 0, 0, 0, 7308, 7309, 1, 0, + 0, 0, 7309, 7310, 5, 819, 0, 0, 7310, 7311, 5, 2308, 0, 0, 7311, 7312, + 5, 1638, 0, 0, 7312, 7313, 3, 670, 335, 0, 7313, 7314, 5, 628, 0, 0, 7314, + 7316, 3, 1458, 729, 0, 7315, 7317, 3, 604, 302, 0, 7316, 7315, 1, 0, 0, + 0, 7316, 7317, 1, 0, 0, 0, 7317, 7318, 1, 0, 0, 0, 7318, 7320, 3, 644, + 322, 0, 7319, 7321, 3, 662, 331, 0, 7320, 7319, 1, 0, 0, 0, 7320, 7321, + 1, 0, 0, 0, 7321, 637, 1, 0, 0, 0, 7322, 7324, 5, 1671, 0, 0, 7323, 7325, + 5, 506, 0, 0, 7324, 7323, 1, 0, 0, 0, 7324, 7325, 1, 0, 0, 0, 7325, 7326, + 1, 0, 0, 0, 7326, 7327, 5, 816, 0, 0, 7327, 7328, 5, 685, 0, 0, 7328, 7329, + 5, 160, 0, 0, 7329, 7331, 3, 670, 335, 0, 7330, 7332, 3, 604, 302, 0, 7331, + 7330, 1, 0, 0, 0, 7331, 7332, 1, 0, 0, 0, 7332, 7333, 1, 0, 0, 0, 7333, + 7334, 5, 950, 0, 0, 7334, 7335, 5, 2246, 0, 0, 7335, 7337, 3, 666, 333, + 0, 7336, 7338, 3, 662, 331, 0, 7337, 7336, 1, 0, 0, 0, 7337, 7338, 1, 0, + 0, 0, 7338, 639, 1, 0, 0, 0, 7339, 7341, 5, 1671, 0, 0, 7340, 7342, 5, + 506, 0, 0, 7341, 7340, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7343, + 1, 0, 0, 0, 7343, 7344, 5, 816, 0, 0, 7344, 7345, 5, 685, 0, 0, 7345, 7346, + 5, 160, 0, 0, 7346, 7348, 3, 670, 335, 0, 7347, 7349, 3, 604, 302, 0, 7348, + 7347, 1, 0, 0, 0, 7348, 7349, 1, 0, 0, 0, 7349, 7350, 1, 0, 0, 0, 7350, + 7351, 5, 1588, 0, 0, 7351, 7352, 5, 950, 0, 0, 7352, 7353, 5, 2246, 0, + 0, 7353, 7354, 3, 670, 335, 0, 7354, 641, 1, 0, 0, 0, 7355, 7357, 5, 992, + 0, 0, 7356, 7358, 5, 506, 0, 0, 7357, 7356, 1, 0, 0, 0, 7357, 7358, 1, + 0, 0, 0, 7358, 7359, 1, 0, 0, 0, 7359, 7360, 5, 819, 0, 0, 7360, 7361, + 5, 2141, 0, 0, 7361, 7362, 5, 1021, 0, 0, 7362, 7363, 5, 820, 0, 0, 7363, + 7364, 5, 2443, 0, 0, 7364, 7365, 5, 685, 0, 0, 7365, 7366, 5, 160, 0, 0, + 7366, 7367, 3, 666, 333, 0, 7367, 7369, 5, 628, 0, 0, 7368, 7370, 5, 616, + 0, 0, 7369, 7368, 1, 0, 0, 0, 7369, 7370, 1, 0, 0, 0, 7370, 7371, 1, 0, + 0, 0, 7371, 7372, 5, 820, 0, 0, 7372, 7373, 5, 685, 0, 0, 7373, 7374, 5, + 160, 0, 0, 7374, 7389, 3, 666, 333, 0, 7375, 7376, 5, 2308, 0, 0, 7376, + 7377, 5, 686, 0, 0, 7377, 7387, 5, 738, 0, 0, 7378, 7383, 5, 2443, 0, 0, + 7379, 7380, 5, 2453, 0, 0, 7380, 7382, 5, 2443, 0, 0, 7381, 7379, 1, 0, + 0, 0, 7382, 7385, 1, 0, 0, 0, 7383, 7381, 1, 0, 0, 0, 7383, 7384, 1, 0, + 0, 0, 7384, 7388, 1, 0, 0, 0, 7385, 7383, 1, 0, 0, 0, 7386, 7388, 3, 1896, + 948, 0, 7387, 7378, 1, 0, 0, 0, 7387, 7386, 1, 0, 0, 0, 7388, 7390, 1, + 0, 0, 0, 7389, 7375, 1, 0, 0, 0, 7389, 7390, 1, 0, 0, 0, 7390, 7392, 1, + 0, 0, 0, 7391, 7393, 3, 662, 331, 0, 7392, 7391, 1, 0, 0, 0, 7392, 7393, + 1, 0, 0, 0, 7393, 643, 1, 0, 0, 0, 7394, 7395, 5, 685, 0, 0, 7395, 7399, + 5, 160, 0, 0, 7396, 7397, 5, 560, 0, 0, 7397, 7400, 5, 1763, 0, 0, 7398, + 7400, 3, 666, 333, 0, 7399, 7396, 1, 0, 0, 0, 7399, 7398, 1, 0, 0, 0, 7400, + 645, 1, 0, 0, 0, 7401, 7402, 5, 2246, 0, 0, 7402, 7403, 5, 2390, 0, 0, + 7403, 7404, 5, 2443, 0, 0, 7404, 647, 1, 0, 0, 0, 7405, 7406, 5, 2246, + 0, 0, 7406, 7407, 5, 2085, 0, 0, 7407, 7408, 5, 2443, 0, 0, 7408, 649, + 1, 0, 0, 0, 7409, 7414, 3, 652, 326, 0, 7410, 7414, 3, 654, 327, 0, 7411, + 7414, 3, 656, 328, 0, 7412, 7414, 3, 658, 329, 0, 7413, 7409, 1, 0, 0, + 0, 7413, 7410, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7413, 7412, 1, 0, 0, + 0, 7414, 651, 1, 0, 0, 0, 7415, 7416, 7, 76, 0, 0, 7416, 7417, 5, 1638, + 0, 0, 7417, 7418, 5, 2443, 0, 0, 7418, 7419, 5, 620, 0, 0, 7419, 7420, + 5, 214, 0, 0, 7420, 7422, 5, 2443, 0, 0, 7421, 7423, 3, 648, 324, 0, 7422, + 7421, 1, 0, 0, 0, 7422, 7423, 1, 0, 0, 0, 7423, 7425, 1, 0, 0, 0, 7424, + 7426, 3, 604, 302, 0, 7425, 7424, 1, 0, 0, 0, 7425, 7426, 1, 0, 0, 0, 7426, + 7428, 1, 0, 0, 0, 7427, 7429, 3, 644, 322, 0, 7428, 7427, 1, 0, 0, 0, 7428, + 7429, 1, 0, 0, 0, 7429, 7431, 1, 0, 0, 0, 7430, 7432, 3, 662, 331, 0, 7431, + 7430, 1, 0, 0, 0, 7431, 7432, 1, 0, 0, 0, 7432, 653, 1, 0, 0, 0, 7433, + 7434, 5, 403, 0, 0, 7434, 7435, 5, 1638, 0, 0, 7435, 7436, 5, 620, 0, 0, + 7436, 7437, 5, 214, 0, 0, 7437, 7439, 5, 2443, 0, 0, 7438, 7440, 3, 604, + 302, 0, 7439, 7438, 1, 0, 0, 0, 7439, 7440, 1, 0, 0, 0, 7440, 7441, 1, + 0, 0, 0, 7441, 7443, 3, 644, 322, 0, 7442, 7444, 3, 662, 331, 0, 7443, + 7442, 1, 0, 0, 0, 7443, 7444, 1, 0, 0, 0, 7444, 655, 1, 0, 0, 0, 7445, + 7446, 7, 76, 0, 0, 7446, 7447, 5, 1638, 0, 0, 7447, 7448, 5, 2443, 0, 0, + 7448, 7449, 5, 620, 0, 0, 7449, 7450, 5, 214, 0, 0, 7450, 7452, 5, 2443, + 0, 0, 7451, 7453, 3, 648, 324, 0, 7452, 7451, 1, 0, 0, 0, 7452, 7453, 1, + 0, 0, 0, 7453, 7454, 1, 0, 0, 0, 7454, 7456, 5, 2141, 0, 0, 7455, 7457, + 5, 873, 0, 0, 7456, 7455, 1, 0, 0, 0, 7456, 7457, 1, 0, 0, 0, 7457, 7458, + 1, 0, 0, 0, 7458, 7459, 5, 94, 0, 0, 7459, 7460, 5, 820, 0, 0, 7460, 7461, + 3, 788, 394, 0, 7461, 657, 1, 0, 0, 0, 7462, 7463, 5, 403, 0, 0, 7463, + 7464, 5, 1638, 0, 0, 7464, 7465, 5, 2443, 0, 0, 7465, 7466, 5, 2461, 0, + 0, 7466, 7467, 5, 620, 0, 0, 7467, 7468, 5, 214, 0, 0, 7468, 7469, 5, 2443, + 0, 0, 7469, 7471, 5, 628, 0, 0, 7470, 7472, 5, 873, 0, 0, 7471, 7470, 1, + 0, 0, 0, 7471, 7472, 1, 0, 0, 0, 7472, 7473, 1, 0, 0, 0, 7473, 7474, 5, + 94, 0, 0, 7474, 7475, 5, 820, 0, 0, 7475, 7476, 3, 788, 394, 0, 7476, 659, + 1, 0, 0, 0, 7477, 7479, 5, 1792, 0, 0, 7478, 7480, 5, 2141, 0, 0, 7479, + 7478, 1, 0, 0, 0, 7479, 7480, 1, 0, 0, 0, 7480, 7481, 1, 0, 0, 0, 7481, + 7482, 5, 849, 0, 0, 7482, 7483, 3, 668, 334, 0, 7483, 7484, 5, 620, 0, + 0, 7484, 7485, 5, 38, 0, 0, 7485, 7486, 5, 290, 0, 0, 7486, 661, 1, 0, + 0, 0, 7487, 7488, 5, 2308, 0, 0, 7488, 7491, 5, 102, 0, 0, 7489, 7490, + 5, 2246, 0, 0, 7490, 7492, 5, 2443, 0, 0, 7491, 7489, 1, 0, 0, 0, 7491, + 7492, 1, 0, 0, 0, 7492, 663, 1, 0, 0, 0, 7493, 7494, 5, 685, 0, 0, 7494, + 7495, 5, 160, 0, 0, 7495, 7496, 3, 666, 333, 0, 7496, 665, 1, 0, 0, 0, + 7497, 7498, 5, 2444, 0, 0, 7498, 667, 1, 0, 0, 0, 7499, 7500, 5, 2443, + 0, 0, 7500, 669, 1, 0, 0, 0, 7501, 7502, 5, 2444, 0, 0, 7502, 671, 1, 0, + 0, 0, 7503, 7508, 5, 46, 0, 0, 7504, 7505, 5, 2083, 0, 0, 7505, 7509, 3, + 2342, 1171, 0, 7506, 7507, 5, 717, 0, 0, 7507, 7509, 3, 2328, 1164, 0, + 7508, 7504, 1, 0, 0, 0, 7508, 7506, 1, 0, 0, 0, 7509, 7511, 1, 0, 0, 0, + 7510, 7512, 3, 674, 337, 0, 7511, 7510, 1, 0, 0, 0, 7511, 7512, 1, 0, 0, + 0, 7512, 7517, 1, 0, 0, 0, 7513, 7514, 5, 46, 0, 0, 7514, 7515, 5, 220, + 0, 0, 7515, 7517, 3, 466, 233, 0, 7516, 7503, 1, 0, 0, 0, 7516, 7513, 1, + 0, 0, 0, 7517, 7544, 1, 0, 0, 0, 7518, 7545, 3, 676, 338, 0, 7519, 7545, + 3, 678, 339, 0, 7520, 7522, 5, 527, 0, 0, 7521, 7523, 5, 1949, 0, 0, 7522, + 7521, 1, 0, 0, 0, 7522, 7523, 1, 0, 0, 0, 7523, 7524, 1, 0, 0, 0, 7524, + 7526, 5, 1746, 0, 0, 7525, 7527, 3, 680, 340, 0, 7526, 7525, 1, 0, 0, 0, + 7526, 7527, 1, 0, 0, 0, 7527, 7531, 1, 0, 0, 0, 7528, 7529, 5, 1614, 0, + 0, 7529, 7530, 5, 2441, 0, 0, 7530, 7532, 7, 77, 0, 0, 7531, 7528, 1, 0, + 0, 0, 7531, 7532, 1, 0, 0, 0, 7532, 7545, 1, 0, 0, 0, 7533, 7534, 5, 862, + 0, 0, 7534, 7535, 5, 189, 0, 0, 7535, 7537, 5, 1607, 0, 0, 7536, 7538, + 3, 684, 342, 0, 7537, 7536, 1, 0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 7545, + 1, 0, 0, 0, 7539, 7541, 5, 403, 0, 0, 7540, 7542, 5, 1949, 0, 0, 7541, + 7540, 1, 0, 0, 0, 7541, 7542, 1, 0, 0, 0, 7542, 7543, 1, 0, 0, 0, 7543, + 7545, 5, 1746, 0, 0, 7544, 7518, 1, 0, 0, 0, 7544, 7519, 1, 0, 0, 0, 7544, + 7520, 1, 0, 0, 0, 7544, 7533, 1, 0, 0, 0, 7544, 7539, 1, 0, 0, 0, 7545, + 673, 1, 0, 0, 0, 7546, 7563, 5, 1348, 0, 0, 7547, 7548, 5, 2447, 0, 0, + 7548, 7549, 3, 1696, 848, 0, 7549, 7550, 5, 2448, 0, 0, 7550, 7564, 1, + 0, 0, 0, 7551, 7552, 5, 620, 0, 0, 7552, 7553, 5, 2447, 0, 0, 7553, 7558, + 3, 686, 343, 0, 7554, 7555, 5, 2453, 0, 0, 7555, 7557, 3, 686, 343, 0, + 7556, 7554, 1, 0, 0, 0, 7557, 7560, 1, 0, 0, 0, 7558, 7556, 1, 0, 0, 0, + 7558, 7559, 1, 0, 0, 0, 7559, 7561, 1, 0, 0, 0, 7560, 7558, 1, 0, 0, 0, + 7561, 7562, 5, 2448, 0, 0, 7562, 7564, 1, 0, 0, 0, 7563, 7547, 1, 0, 0, + 0, 7563, 7551, 1, 0, 0, 0, 7564, 7585, 1, 0, 0, 0, 7565, 7582, 5, 1775, + 0, 0, 7566, 7567, 5, 2447, 0, 0, 7567, 7568, 3, 1154, 577, 0, 7568, 7569, + 5, 2448, 0, 0, 7569, 7583, 1, 0, 0, 0, 7570, 7571, 5, 620, 0, 0, 7571, + 7572, 5, 2447, 0, 0, 7572, 7577, 3, 688, 344, 0, 7573, 7574, 5, 2453, 0, + 0, 7574, 7576, 3, 688, 344, 0, 7575, 7573, 1, 0, 0, 0, 7576, 7579, 1, 0, + 0, 0, 7577, 7575, 1, 0, 0, 0, 7577, 7578, 1, 0, 0, 0, 7578, 7580, 1, 0, + 0, 0, 7579, 7577, 1, 0, 0, 0, 7580, 7581, 5, 2448, 0, 0, 7581, 7583, 1, + 0, 0, 0, 7582, 7566, 1, 0, 0, 0, 7582, 7570, 1, 0, 0, 0, 7583, 7585, 1, + 0, 0, 0, 7584, 7546, 1, 0, 0, 0, 7584, 7565, 1, 0, 0, 0, 7585, 675, 1, + 0, 0, 0, 7586, 7587, 5, 2253, 0, 0, 7587, 7588, 5, 1530, 0, 0, 7588, 7593, + 5, 2207, 0, 0, 7589, 7590, 5, 1671, 0, 0, 7590, 7591, 5, 349, 0, 0, 7591, + 7592, 5, 2141, 0, 0, 7592, 7594, 5, 1228, 0, 0, 7593, 7589, 1, 0, 0, 0, + 7593, 7594, 1, 0, 0, 0, 7594, 7616, 1, 0, 0, 0, 7595, 7596, 5, 2253, 0, + 0, 7596, 7607, 5, 1771, 0, 0, 7597, 7598, 5, 179, 0, 0, 7598, 7608, 5, + 578, 0, 0, 7599, 7601, 5, 179, 0, 0, 7600, 7602, 3, 682, 341, 0, 7601, + 7600, 1, 0, 0, 0, 7601, 7602, 1, 0, 0, 0, 7602, 7604, 1, 0, 0, 0, 7603, + 7605, 3, 2274, 1137, 0, 7604, 7603, 1, 0, 0, 0, 7604, 7605, 1, 0, 0, 0, + 7605, 7608, 1, 0, 0, 0, 7606, 7608, 5, 179, 0, 0, 7607, 7597, 1, 0, 0, + 0, 7607, 7599, 1, 0, 0, 0, 7607, 7606, 1, 0, 0, 0, 7607, 7608, 1, 0, 0, + 0, 7608, 7610, 1, 0, 0, 0, 7609, 7611, 3, 682, 341, 0, 7610, 7609, 1, 0, + 0, 0, 7610, 7611, 1, 0, 0, 0, 7611, 7613, 1, 0, 0, 0, 7612, 7614, 3, 2274, + 1137, 0, 7613, 7612, 1, 0, 0, 0, 7613, 7614, 1, 0, 0, 0, 7614, 7616, 1, + 0, 0, 0, 7615, 7586, 1, 0, 0, 0, 7615, 7595, 1, 0, 0, 0, 7616, 677, 1, + 0, 0, 0, 7617, 7619, 5, 260, 0, 0, 7618, 7620, 5, 1949, 0, 0, 7619, 7618, + 1, 0, 0, 0, 7619, 7620, 1, 0, 0, 0, 7620, 7621, 1, 0, 0, 0, 7621, 7623, + 5, 1746, 0, 0, 7622, 7624, 3, 680, 340, 0, 7623, 7622, 1, 0, 0, 0, 7623, + 7624, 1, 0, 0, 0, 7624, 679, 1, 0, 0, 0, 7625, 7673, 5, 620, 0, 0, 7626, + 7630, 5, 2083, 0, 0, 7627, 7629, 3, 680, 340, 0, 7628, 7627, 1, 0, 0, 0, + 7629, 7632, 1, 0, 0, 0, 7630, 7628, 1, 0, 0, 0, 7630, 7631, 1, 0, 0, 0, + 7631, 7674, 1, 0, 0, 0, 7632, 7630, 1, 0, 0, 0, 7633, 7652, 5, 38, 0, 0, + 7634, 7636, 5, 713, 0, 0, 7635, 7634, 1, 0, 0, 0, 7635, 7636, 1, 0, 0, + 0, 7636, 7637, 1, 0, 0, 0, 7637, 7640, 5, 238, 0, 0, 7638, 7639, 5, 1699, + 0, 0, 7639, 7641, 5, 2441, 0, 0, 7640, 7638, 1, 0, 0, 0, 7640, 7641, 1, + 0, 0, 0, 7641, 7645, 1, 0, 0, 0, 7642, 7644, 3, 680, 340, 0, 7643, 7642, + 1, 0, 0, 0, 7644, 7647, 1, 0, 0, 0, 7645, 7643, 1, 0, 0, 0, 7645, 7646, + 1, 0, 0, 0, 7646, 7653, 1, 0, 0, 0, 7647, 7645, 1, 0, 0, 0, 7648, 7650, + 5, 873, 0, 0, 7649, 7648, 1, 0, 0, 0, 7649, 7650, 1, 0, 0, 0, 7650, 7651, + 1, 0, 0, 0, 7651, 7653, 5, 714, 0, 0, 7652, 7635, 1, 0, 0, 0, 7652, 7649, + 1, 0, 0, 0, 7653, 7674, 1, 0, 0, 0, 7654, 7657, 5, 238, 0, 0, 7655, 7656, + 5, 1699, 0, 0, 7656, 7658, 5, 2441, 0, 0, 7657, 7655, 1, 0, 0, 0, 7657, + 7658, 1, 0, 0, 0, 7658, 7663, 1, 0, 0, 0, 7659, 7660, 3, 2340, 1170, 0, + 7660, 7661, 5, 1699, 0, 0, 7661, 7662, 5, 2441, 0, 0, 7662, 7664, 1, 0, + 0, 0, 7663, 7659, 1, 0, 0, 0, 7664, 7665, 1, 0, 0, 0, 7665, 7663, 1, 0, + 0, 0, 7665, 7666, 1, 0, 0, 0, 7666, 7670, 1, 0, 0, 0, 7667, 7669, 3, 680, + 340, 0, 7668, 7667, 1, 0, 0, 0, 7669, 7672, 1, 0, 0, 0, 7670, 7668, 1, + 0, 0, 0, 7670, 7671, 1, 0, 0, 0, 7671, 7674, 1, 0, 0, 0, 7672, 7670, 1, + 0, 0, 0, 7673, 7626, 1, 0, 0, 0, 7673, 7633, 1, 0, 0, 0, 7673, 7654, 1, + 0, 0, 0, 7674, 681, 1, 0, 0, 0, 7675, 7676, 7, 78, 0, 0, 7676, 683, 1, + 0, 0, 0, 7677, 7679, 5, 779, 0, 0, 7678, 7680, 3, 2342, 1171, 0, 7679, + 7678, 1, 0, 0, 0, 7679, 7680, 1, 0, 0, 0, 7680, 685, 1, 0, 0, 0, 7681, + 7685, 3, 2186, 1093, 0, 7682, 7683, 5, 2108, 0, 0, 7683, 7685, 3, 2400, + 1200, 0, 7684, 7681, 1, 0, 0, 0, 7684, 7682, 1, 0, 0, 0, 7685, 687, 1, + 0, 0, 0, 7686, 7690, 3, 2186, 1093, 0, 7687, 7688, 5, 2108, 0, 0, 7688, + 7690, 3, 2400, 1200, 0, 7689, 7686, 1, 0, 0, 0, 7689, 7687, 1, 0, 0, 0, + 7690, 689, 1, 0, 0, 0, 7691, 7692, 5, 77, 0, 0, 7692, 7693, 5, 1746, 0, + 0, 7693, 7696, 5, 2308, 0, 0, 7694, 7697, 3, 692, 346, 0, 7695, 7697, 3, + 694, 347, 0, 7696, 7694, 1, 0, 0, 0, 7696, 7695, 1, 0, 0, 0, 7697, 7699, + 1, 0, 0, 0, 7698, 7700, 3, 714, 357, 0, 7699, 7698, 1, 0, 0, 0, 7699, 7700, + 1, 0, 0, 0, 7700, 691, 1, 0, 0, 0, 7701, 7702, 5, 238, 0, 0, 7702, 7703, + 3, 2342, 1171, 0, 7703, 7704, 5, 2440, 0, 0, 7704, 7712, 3, 2340, 1170, + 0, 7705, 7706, 5, 2453, 0, 0, 7706, 7707, 3, 2342, 1171, 0, 7707, 7708, + 5, 2440, 0, 0, 7708, 7709, 3, 2340, 1170, 0, 7709, 7711, 1, 0, 0, 0, 7710, + 7705, 1, 0, 0, 0, 7711, 7714, 1, 0, 0, 0, 7712, 7710, 1, 0, 0, 0, 7712, + 7713, 1, 0, 0, 0, 7713, 7715, 1, 0, 0, 0, 7714, 7712, 1, 0, 0, 0, 7715, + 7716, 3, 698, 349, 0, 7716, 693, 1, 0, 0, 0, 7717, 7718, 5, 633, 0, 0, + 7718, 7723, 3, 2320, 1160, 0, 7719, 7720, 5, 2453, 0, 0, 7720, 7722, 3, + 2320, 1160, 0, 7721, 7719, 1, 0, 0, 0, 7722, 7725, 1, 0, 0, 0, 7723, 7721, + 1, 0, 0, 0, 7723, 7724, 1, 0, 0, 0, 7724, 7763, 1, 0, 0, 0, 7725, 7723, + 1, 0, 0, 0, 7726, 7727, 5, 1330, 0, 0, 7727, 7732, 3, 2290, 1145, 0, 7728, + 7729, 5, 2453, 0, 0, 7729, 7731, 3, 2290, 1145, 0, 7730, 7728, 1, 0, 0, + 0, 7731, 7734, 1, 0, 0, 0, 7732, 7730, 1, 0, 0, 0, 7732, 7733, 1, 0, 0, + 0, 7733, 7763, 1, 0, 0, 0, 7734, 7732, 1, 0, 0, 0, 7735, 7736, 5, 2165, + 0, 0, 7736, 7741, 3, 2314, 1157, 0, 7737, 7738, 5, 2453, 0, 0, 7738, 7740, + 3, 2314, 1157, 0, 7739, 7737, 1, 0, 0, 0, 7740, 7743, 1, 0, 0, 0, 7741, + 7739, 1, 0, 0, 0, 7741, 7742, 1, 0, 0, 0, 7742, 7763, 1, 0, 0, 0, 7743, + 7741, 1, 0, 0, 0, 7744, 7745, 5, 714, 0, 0, 7745, 7750, 3, 2328, 1164, + 0, 7746, 7747, 5, 2453, 0, 0, 7747, 7749, 3, 2328, 1164, 0, 7748, 7746, + 1, 0, 0, 0, 7749, 7752, 1, 0, 0, 0, 7750, 7748, 1, 0, 0, 0, 7750, 7751, + 1, 0, 0, 0, 7751, 7763, 1, 0, 0, 0, 7752, 7750, 1, 0, 0, 0, 7753, 7754, + 5, 732, 0, 0, 7754, 7759, 3, 696, 348, 0, 7755, 7756, 5, 2453, 0, 0, 7756, + 7758, 3, 696, 348, 0, 7757, 7755, 1, 0, 0, 0, 7758, 7761, 1, 0, 0, 0, 7759, + 7757, 1, 0, 0, 0, 7759, 7760, 1, 0, 0, 0, 7760, 7763, 1, 0, 0, 0, 7761, + 7759, 1, 0, 0, 0, 7762, 7717, 1, 0, 0, 0, 7762, 7726, 1, 0, 0, 0, 7762, + 7735, 1, 0, 0, 0, 7762, 7744, 1, 0, 0, 0, 7762, 7753, 1, 0, 0, 0, 7763, + 7775, 1, 0, 0, 0, 7764, 7776, 3, 698, 349, 0, 7765, 7768, 3, 702, 351, + 0, 7766, 7767, 5, 2453, 0, 0, 7767, 7769, 3, 710, 355, 0, 7768, 7766, 1, + 0, 0, 0, 7768, 7769, 1, 0, 0, 0, 7769, 7776, 1, 0, 0, 0, 7770, 7773, 3, + 710, 355, 0, 7771, 7772, 5, 2453, 0, 0, 7772, 7774, 3, 702, 351, 0, 7773, + 7771, 1, 0, 0, 0, 7773, 7774, 1, 0, 0, 0, 7774, 7776, 1, 0, 0, 0, 7775, + 7764, 1, 0, 0, 0, 7775, 7765, 1, 0, 0, 0, 7775, 7770, 1, 0, 0, 0, 7776, + 695, 1, 0, 0, 0, 7777, 7778, 3, 2404, 1202, 0, 7778, 697, 1, 0, 0, 0, 7779, + 7782, 5, 2246, 0, 0, 7780, 7783, 3, 700, 350, 0, 7781, 7783, 5, 1228, 0, + 0, 7782, 7780, 1, 0, 0, 0, 7782, 7781, 1, 0, 0, 0, 7783, 699, 1, 0, 0, + 0, 7784, 7785, 3, 2410, 1205, 0, 7785, 701, 1, 0, 0, 0, 7786, 7787, 5, + 389, 0, 0, 7787, 7788, 5, 311, 0, 0, 7788, 7789, 5, 2447, 0, 0, 7789, 7790, + 3, 704, 352, 0, 7790, 7791, 5, 2453, 0, 0, 7791, 7792, 3, 706, 353, 0, + 7792, 7793, 5, 2453, 0, 0, 7793, 7794, 3, 708, 354, 0, 7794, 7795, 5, 2448, + 0, 0, 7795, 703, 1, 0, 0, 0, 7796, 7797, 5, 2441, 0, 0, 7797, 705, 1, 0, + 0, 0, 7798, 7799, 5, 2441, 0, 0, 7799, 707, 1, 0, 0, 0, 7800, 7801, 5, + 2441, 0, 0, 7801, 709, 1, 0, 0, 0, 7802, 7803, 5, 389, 0, 0, 7803, 7804, + 5, 1646, 0, 0, 7804, 7805, 3, 712, 356, 0, 7805, 711, 1, 0, 0, 0, 7806, + 7807, 5, 2441, 0, 0, 7807, 713, 1, 0, 0, 0, 7808, 7809, 5, 2308, 0, 0, + 7809, 7810, 7, 79, 0, 0, 7810, 7811, 5, 904, 0, 0, 7811, 7812, 5, 1762, + 0, 0, 7812, 7813, 5, 2081, 0, 0, 7813, 715, 1, 0, 0, 0, 7814, 7815, 4, + 358, 0, 0, 7815, 7859, 5, 85, 0, 0, 7816, 7817, 5, 1412, 0, 0, 7817, 7827, + 3, 718, 359, 0, 7818, 7819, 7, 80, 0, 0, 7819, 7824, 3, 730, 365, 0, 7820, + 7821, 5, 2453, 0, 0, 7821, 7823, 3, 730, 365, 0, 7822, 7820, 1, 0, 0, 0, + 7823, 7826, 1, 0, 0, 0, 7824, 7822, 1, 0, 0, 0, 7824, 7825, 1, 0, 0, 0, + 7825, 7828, 1, 0, 0, 0, 7826, 7824, 1, 0, 0, 0, 7827, 7818, 1, 0, 0, 0, + 7827, 7828, 1, 0, 0, 0, 7828, 7834, 1, 0, 0, 0, 7829, 7831, 5, 2299, 0, + 0, 7830, 7832, 5, 1204, 0, 0, 7831, 7830, 1, 0, 0, 0, 7831, 7832, 1, 0, + 0, 0, 7832, 7833, 1, 0, 0, 0, 7833, 7835, 5, 1786, 0, 0, 7834, 7829, 1, + 0, 0, 0, 7834, 7835, 1, 0, 0, 0, 7835, 7860, 1, 0, 0, 0, 7836, 7837, 5, + 296, 0, 0, 7837, 7838, 5, 998, 0, 0, 7838, 7839, 3, 1016, 508, 0, 7839, + 7840, 5, 84, 0, 0, 7840, 7845, 3, 2280, 1140, 0, 7841, 7842, 5, 2453, 0, + 0, 7842, 7844, 3, 2280, 1140, 0, 7843, 7841, 1, 0, 0, 0, 7844, 7847, 1, + 0, 0, 0, 7845, 7843, 1, 0, 0, 0, 7845, 7846, 1, 0, 0, 0, 7846, 7857, 1, + 0, 0, 0, 7847, 7845, 1, 0, 0, 0, 7848, 7849, 5, 160, 0, 0, 7849, 7854, + 3, 730, 365, 0, 7850, 7851, 5, 2453, 0, 0, 7851, 7853, 3, 730, 365, 0, + 7852, 7850, 1, 0, 0, 0, 7853, 7856, 1, 0, 0, 0, 7854, 7852, 1, 0, 0, 0, + 7854, 7855, 1, 0, 0, 0, 7855, 7858, 1, 0, 0, 0, 7856, 7854, 1, 0, 0, 0, + 7857, 7848, 1, 0, 0, 0, 7857, 7858, 1, 0, 0, 0, 7858, 7860, 1, 0, 0, 0, + 7859, 7816, 1, 0, 0, 0, 7859, 7836, 1, 0, 0, 0, 7860, 717, 1, 0, 0, 0, + 7861, 7862, 3, 2402, 1201, 0, 7862, 719, 1, 0, 0, 0, 7863, 7874, 5, 85, + 0, 0, 7864, 7869, 3, 726, 363, 0, 7865, 7870, 3, 728, 364, 0, 7866, 7867, + 5, 738, 0, 0, 7867, 7868, 5, 1667, 0, 0, 7868, 7870, 5, 336, 0, 0, 7869, + 7865, 1, 0, 0, 0, 7869, 7866, 1, 0, 0, 0, 7869, 7870, 1, 0, 0, 0, 7870, + 7875, 1, 0, 0, 0, 7871, 7875, 3, 732, 366, 0, 7872, 7875, 5, 1019, 0, 0, + 7873, 7875, 3, 722, 361, 0, 7874, 7864, 1, 0, 0, 0, 7874, 7871, 1, 0, 0, + 0, 7874, 7872, 1, 0, 0, 0, 7874, 7873, 1, 0, 0, 0, 7875, 7878, 1, 0, 0, + 0, 7876, 7877, 5, 160, 0, 0, 7877, 7879, 7, 81, 0, 0, 7878, 7876, 1, 0, + 0, 0, 7878, 7879, 1, 0, 0, 0, 7879, 7885, 1, 0, 0, 0, 7880, 7882, 5, 2299, + 0, 0, 7881, 7883, 5, 1204, 0, 0, 7882, 7881, 1, 0, 0, 0, 7882, 7883, 1, + 0, 0, 0, 7883, 7884, 1, 0, 0, 0, 7884, 7886, 5, 1786, 0, 0, 7885, 7880, + 1, 0, 0, 0, 7885, 7886, 1, 0, 0, 0, 7886, 7888, 1, 0, 0, 0, 7887, 7889, + 3, 724, 362, 0, 7888, 7887, 1, 0, 0, 0, 7888, 7889, 1, 0, 0, 0, 7889, 721, + 1, 0, 0, 0, 7890, 7891, 4, 361, 1, 0, 7891, 7892, 5, 427, 0, 0, 7892, 7893, + 3, 728, 364, 0, 7893, 723, 1, 0, 0, 0, 7894, 7895, 4, 362, 2, 0, 7895, + 7896, 5, 289, 0, 0, 7896, 7897, 5, 2472, 0, 0, 7897, 7898, 7, 82, 0, 0, + 7898, 725, 1, 0, 0, 0, 7899, 7905, 3, 744, 372, 0, 7900, 7902, 5, 38, 0, + 0, 7901, 7903, 5, 1742, 0, 0, 7902, 7901, 1, 0, 0, 0, 7902, 7903, 1, 0, + 0, 0, 7903, 7905, 1, 0, 0, 0, 7904, 7899, 1, 0, 0, 0, 7904, 7900, 1, 0, + 0, 0, 7905, 7916, 1, 0, 0, 0, 7906, 7912, 5, 2453, 0, 0, 7907, 7913, 3, + 744, 372, 0, 7908, 7910, 5, 38, 0, 0, 7909, 7911, 5, 1742, 0, 0, 7910, + 7909, 1, 0, 0, 0, 7910, 7911, 1, 0, 0, 0, 7911, 7913, 1, 0, 0, 0, 7912, + 7907, 1, 0, 0, 0, 7912, 7908, 1, 0, 0, 0, 7913, 7915, 1, 0, 0, 0, 7914, + 7906, 1, 0, 0, 0, 7915, 7918, 1, 0, 0, 0, 7916, 7914, 1, 0, 0, 0, 7916, + 7917, 1, 0, 0, 0, 7917, 7936, 1, 0, 0, 0, 7918, 7916, 1, 0, 0, 0, 7919, + 7923, 3, 2392, 1196, 0, 7920, 7921, 5, 38, 0, 0, 7921, 7923, 5, 1459, 0, + 0, 7922, 7919, 1, 0, 0, 0, 7922, 7920, 1, 0, 0, 0, 7923, 7932, 1, 0, 0, + 0, 7924, 7928, 5, 2453, 0, 0, 7925, 7929, 3, 2392, 1196, 0, 7926, 7927, + 5, 38, 0, 0, 7927, 7929, 5, 1459, 0, 0, 7928, 7925, 1, 0, 0, 0, 7928, 7926, + 1, 0, 0, 0, 7929, 7931, 1, 0, 0, 0, 7930, 7924, 1, 0, 0, 0, 7931, 7934, + 1, 0, 0, 0, 7932, 7930, 1, 0, 0, 0, 7932, 7933, 1, 0, 0, 0, 7933, 7936, + 1, 0, 0, 0, 7934, 7932, 1, 0, 0, 0, 7935, 7904, 1, 0, 0, 0, 7935, 7922, + 1, 0, 0, 0, 7936, 727, 1, 0, 0, 0, 7937, 7938, 5, 160, 0, 0, 7938, 7943, + 3, 730, 365, 0, 7939, 7940, 5, 2453, 0, 0, 7940, 7942, 3, 730, 365, 0, + 7941, 7939, 1, 0, 0, 0, 7942, 7945, 1, 0, 0, 0, 7943, 7941, 1, 0, 0, 0, + 7943, 7944, 1, 0, 0, 0, 7944, 729, 1, 0, 0, 0, 7945, 7943, 1, 0, 0, 0, + 7946, 7947, 3, 2410, 1205, 0, 7947, 731, 1, 0, 0, 0, 7948, 7953, 3, 734, + 367, 0, 7949, 7950, 5, 2453, 0, 0, 7950, 7952, 3, 734, 367, 0, 7951, 7949, + 1, 0, 0, 0, 7952, 7955, 1, 0, 0, 0, 7953, 7951, 1, 0, 0, 0, 7953, 7954, + 1, 0, 0, 0, 7954, 7958, 1, 0, 0, 0, 7955, 7953, 1, 0, 0, 0, 7956, 7958, + 5, 38, 0, 0, 7957, 7948, 1, 0, 0, 0, 7957, 7956, 1, 0, 0, 0, 7958, 7959, + 1, 0, 0, 0, 7959, 7960, 3, 736, 368, 0, 7960, 733, 1, 0, 0, 0, 7961, 7962, + 7, 58, 0, 0, 7962, 735, 1, 0, 0, 0, 7963, 7976, 5, 1259, 0, 0, 7964, 7977, + 3, 740, 370, 0, 7965, 7966, 5, 426, 0, 0, 7966, 7977, 3, 2410, 1205, 0, + 7967, 7968, 5, 955, 0, 0, 7968, 7969, 5, 971, 0, 0, 7969, 7977, 3, 738, + 369, 0, 7970, 7971, 4, 368, 3, 0, 7971, 7972, 5, 1722, 0, 0, 7972, 7973, + 5, 2154, 0, 0, 7973, 7974, 5, 1463, 0, 0, 7974, 7977, 3, 742, 371, 0, 7975, + 7977, 5, 389, 0, 0, 7976, 7964, 1, 0, 0, 0, 7976, 7965, 1, 0, 0, 0, 7976, + 7967, 1, 0, 0, 0, 7976, 7970, 1, 0, 0, 0, 7976, 7975, 1, 0, 0, 0, 7977, + 737, 1, 0, 0, 0, 7978, 7979, 3, 2404, 1202, 0, 7979, 7980, 5, 2440, 0, + 0, 7980, 7982, 1, 0, 0, 0, 7981, 7978, 1, 0, 0, 0, 7981, 7982, 1, 0, 0, + 0, 7982, 7983, 1, 0, 0, 0, 7983, 7984, 3, 2404, 1202, 0, 7984, 739, 1, + 0, 0, 0, 7985, 7986, 3, 2404, 1202, 0, 7986, 7987, 5, 2440, 0, 0, 7987, + 7989, 1, 0, 0, 0, 7988, 7985, 1, 0, 0, 0, 7988, 7989, 1, 0, 0, 0, 7989, + 7990, 1, 0, 0, 0, 7990, 7991, 3, 2404, 1202, 0, 7991, 741, 1, 0, 0, 0, + 7992, 7993, 3, 2404, 1202, 0, 7993, 7994, 5, 2440, 0, 0, 7994, 7996, 1, + 0, 0, 0, 7995, 7992, 1, 0, 0, 0, 7995, 7996, 1, 0, 0, 0, 7996, 7997, 1, + 0, 0, 0, 7997, 7998, 3, 2404, 1202, 0, 7998, 743, 1, 0, 0, 0, 7999, 8000, + 5, 42, 0, 0, 8000, 8070, 5, 1949, 0, 0, 8001, 8070, 5, 220, 0, 0, 8002, + 8070, 5, 296, 0, 0, 8003, 8004, 5, 350, 0, 0, 8004, 8070, 5, 861, 0, 0, + 8005, 8070, 5, 422, 0, 0, 8006, 8070, 5, 426, 0, 0, 8007, 8070, 5, 717, + 0, 0, 8008, 8009, 5, 919, 0, 0, 8009, 8070, 5, 2286, 0, 0, 8010, 8011, + 5, 1204, 0, 0, 8011, 8070, 5, 545, 0, 0, 8012, 8070, 5, 1315, 0, 0, 8013, + 8014, 4, 372, 4, 0, 8014, 8015, 5, 1409, 0, 0, 8015, 8070, 5, 350, 0, 0, + 8016, 8070, 5, 1461, 0, 0, 8017, 8070, 5, 1463, 0, 0, 8018, 8019, 5, 1473, + 0, 0, 8019, 8020, 5, 350, 0, 0, 8020, 8070, 5, 861, 0, 0, 8021, 8022, 5, + 1473, 0, 0, 8022, 8070, 5, 1796, 0, 0, 8023, 8070, 5, 1593, 0, 0, 8024, + 8025, 5, 1596, 0, 0, 8025, 8070, 5, 1645, 0, 0, 8026, 8070, 5, 1653, 0, + 0, 8027, 8070, 5, 1667, 0, 0, 8028, 8070, 5, 1796, 0, 0, 8029, 8030, 5, + 1949, 0, 0, 8030, 8070, 5, 85, 0, 0, 8031, 8032, 5, 1949, 0, 0, 8032, 8070, + 5, 647, 0, 0, 8033, 8070, 5, 2083, 0, 0, 8034, 8070, 5, 2080, 0, 0, 8035, + 8070, 5, 2157, 0, 0, 8036, 8070, 5, 2166, 0, 0, 8037, 8070, 5, 2237, 0, + 0, 8038, 8070, 5, 2286, 0, 0, 8039, 8040, 5, 42, 0, 0, 8040, 8070, 5, 1653, + 0, 0, 8041, 8042, 5, 42, 0, 0, 8042, 8070, 5, 2083, 0, 0, 8043, 8044, 5, + 241, 0, 0, 8044, 8070, 5, 2083, 0, 0, 8045, 8046, 5, 403, 0, 0, 8046, 8070, + 5, 2083, 0, 0, 8047, 8048, 5, 542, 0, 0, 8048, 8070, 5, 1461, 0, 0, 8049, + 8050, 5, 647, 0, 0, 8050, 8070, 5, 426, 0, 0, 8051, 8052, 5, 647, 0, 0, + 8052, 8070, 5, 1461, 0, 0, 8053, 8054, 5, 647, 0, 0, 8054, 8070, 5, 1653, + 0, 0, 8055, 8056, 5, 647, 0, 0, 8056, 8070, 5, 2083, 0, 0, 8057, 8058, + 5, 647, 0, 0, 8058, 8070, 5, 2166, 0, 0, 8059, 8060, 5, 756, 0, 0, 8060, + 8070, 5, 2083, 0, 0, 8061, 8062, 5, 881, 0, 0, 8062, 8070, 5, 2083, 0, + 0, 8063, 8064, 5, 1647, 0, 0, 8064, 8070, 5, 1653, 0, 0, 8065, 8066, 5, + 1647, 0, 0, 8066, 8070, 5, 2083, 0, 0, 8067, 8068, 5, 2207, 0, 0, 8068, + 8070, 5, 2083, 0, 0, 8069, 7999, 1, 0, 0, 0, 8069, 8001, 1, 0, 0, 0, 8069, + 8002, 1, 0, 0, 0, 8069, 8003, 1, 0, 0, 0, 8069, 8005, 1, 0, 0, 0, 8069, + 8006, 1, 0, 0, 0, 8069, 8007, 1, 0, 0, 0, 8069, 8008, 1, 0, 0, 0, 8069, + 8010, 1, 0, 0, 0, 8069, 8012, 1, 0, 0, 0, 8069, 8013, 1, 0, 0, 0, 8069, + 8016, 1, 0, 0, 0, 8069, 8017, 1, 0, 0, 0, 8069, 8018, 1, 0, 0, 0, 8069, + 8021, 1, 0, 0, 0, 8069, 8023, 1, 0, 0, 0, 8069, 8024, 1, 0, 0, 0, 8069, + 8026, 1, 0, 0, 0, 8069, 8027, 1, 0, 0, 0, 8069, 8028, 1, 0, 0, 0, 8069, + 8029, 1, 0, 0, 0, 8069, 8031, 1, 0, 0, 0, 8069, 8033, 1, 0, 0, 0, 8069, + 8034, 1, 0, 0, 0, 8069, 8035, 1, 0, 0, 0, 8069, 8036, 1, 0, 0, 0, 8069, + 8037, 1, 0, 0, 0, 8069, 8038, 1, 0, 0, 0, 8069, 8039, 1, 0, 0, 0, 8069, + 8041, 1, 0, 0, 0, 8069, 8043, 1, 0, 0, 0, 8069, 8045, 1, 0, 0, 0, 8069, + 8047, 1, 0, 0, 0, 8069, 8049, 1, 0, 0, 0, 8069, 8051, 1, 0, 0, 0, 8069, + 8053, 1, 0, 0, 0, 8069, 8055, 1, 0, 0, 0, 8069, 8057, 1, 0, 0, 0, 8069, + 8059, 1, 0, 0, 0, 8069, 8061, 1, 0, 0, 0, 8069, 8063, 1, 0, 0, 0, 8069, + 8065, 1, 0, 0, 0, 8069, 8067, 1, 0, 0, 0, 8070, 745, 1, 0, 0, 0, 8071, + 8072, 5, 469, 0, 0, 8072, 8073, 5, 717, 0, 0, 8073, 8076, 3, 2328, 1164, + 0, 8074, 8075, 5, 691, 0, 0, 8075, 8077, 5, 545, 0, 0, 8076, 8074, 1, 0, + 0, 0, 8076, 8077, 1, 0, 0, 0, 8077, 747, 1, 0, 0, 0, 8078, 8079, 5, 436, + 0, 0, 8079, 8080, 5, 1746, 0, 0, 8080, 8200, 5, 628, 0, 0, 8081, 8085, + 5, 238, 0, 0, 8082, 8083, 3, 2286, 1143, 0, 8083, 8084, 5, 2440, 0, 0, + 8084, 8086, 1, 0, 0, 0, 8085, 8082, 1, 0, 0, 0, 8085, 8086, 1, 0, 0, 0, + 8086, 8087, 1, 0, 0, 0, 8087, 8088, 3, 2404, 1202, 0, 8088, 8089, 5, 2440, + 0, 0, 8089, 8102, 3, 2404, 1202, 0, 8090, 8094, 5, 2453, 0, 0, 8091, 8092, + 3, 2286, 1143, 0, 8092, 8093, 5, 2440, 0, 0, 8093, 8095, 1, 0, 0, 0, 8094, + 8091, 1, 0, 0, 0, 8094, 8095, 1, 0, 0, 0, 8095, 8096, 1, 0, 0, 0, 8096, + 8097, 3, 2404, 1202, 0, 8097, 8098, 5, 2440, 0, 0, 8098, 8099, 3, 2404, + 1202, 0, 8099, 8101, 1, 0, 0, 0, 8100, 8090, 1, 0, 0, 0, 8101, 8104, 1, + 0, 0, 0, 8102, 8100, 1, 0, 0, 0, 8102, 8103, 1, 0, 0, 0, 8103, 8201, 1, + 0, 0, 0, 8104, 8102, 1, 0, 0, 0, 8105, 8109, 5, 633, 0, 0, 8106, 8107, + 3, 2286, 1143, 0, 8107, 8108, 5, 2440, 0, 0, 8108, 8110, 1, 0, 0, 0, 8109, + 8106, 1, 0, 0, 0, 8109, 8110, 1, 0, 0, 0, 8110, 8111, 1, 0, 0, 0, 8111, + 8121, 3, 2404, 1202, 0, 8112, 8116, 5, 2453, 0, 0, 8113, 8114, 3, 2286, + 1143, 0, 8114, 8115, 5, 2440, 0, 0, 8115, 8117, 1, 0, 0, 0, 8116, 8113, + 1, 0, 0, 0, 8116, 8117, 1, 0, 0, 0, 8117, 8118, 1, 0, 0, 0, 8118, 8120, + 3, 2404, 1202, 0, 8119, 8112, 1, 0, 0, 0, 8120, 8123, 1, 0, 0, 0, 8121, + 8119, 1, 0, 0, 0, 8121, 8122, 1, 0, 0, 0, 8122, 8201, 1, 0, 0, 0, 8123, + 8121, 1, 0, 0, 0, 8124, 8128, 5, 1330, 0, 0, 8125, 8126, 3, 2286, 1143, + 0, 8126, 8127, 5, 2440, 0, 0, 8127, 8129, 1, 0, 0, 0, 8128, 8125, 1, 0, + 0, 0, 8128, 8129, 1, 0, 0, 0, 8129, 8130, 1, 0, 0, 0, 8130, 8140, 3, 2404, + 1202, 0, 8131, 8135, 5, 2453, 0, 0, 8132, 8133, 3, 2286, 1143, 0, 8133, + 8134, 5, 2440, 0, 0, 8134, 8136, 1, 0, 0, 0, 8135, 8132, 1, 0, 0, 0, 8135, + 8136, 1, 0, 0, 0, 8136, 8137, 1, 0, 0, 0, 8137, 8139, 3, 2404, 1202, 0, + 8138, 8131, 1, 0, 0, 0, 8139, 8142, 1, 0, 0, 0, 8140, 8138, 1, 0, 0, 0, + 8140, 8141, 1, 0, 0, 0, 8141, 8201, 1, 0, 0, 0, 8142, 8140, 1, 0, 0, 0, + 8143, 8147, 5, 2165, 0, 0, 8144, 8145, 3, 2286, 1143, 0, 8145, 8146, 5, + 2440, 0, 0, 8146, 8148, 1, 0, 0, 0, 8147, 8144, 1, 0, 0, 0, 8147, 8148, + 1, 0, 0, 0, 8148, 8149, 1, 0, 0, 0, 8149, 8159, 3, 2404, 1202, 0, 8150, + 8154, 5, 2453, 0, 0, 8151, 8152, 3, 2286, 1143, 0, 8152, 8153, 5, 2440, + 0, 0, 8153, 8155, 1, 0, 0, 0, 8154, 8151, 1, 0, 0, 0, 8154, 8155, 1, 0, + 0, 0, 8155, 8156, 1, 0, 0, 0, 8156, 8158, 3, 2404, 1202, 0, 8157, 8150, + 1, 0, 0, 0, 8158, 8161, 1, 0, 0, 0, 8159, 8157, 1, 0, 0, 0, 8159, 8160, + 1, 0, 0, 0, 8160, 8201, 1, 0, 0, 0, 8161, 8159, 1, 0, 0, 0, 8162, 8166, + 5, 714, 0, 0, 8163, 8164, 3, 2286, 1143, 0, 8164, 8165, 5, 2440, 0, 0, + 8165, 8167, 1, 0, 0, 0, 8166, 8163, 1, 0, 0, 0, 8166, 8167, 1, 0, 0, 0, + 8167, 8168, 1, 0, 0, 0, 8168, 8178, 3, 2404, 1202, 0, 8169, 8173, 5, 2453, + 0, 0, 8170, 8171, 3, 2286, 1143, 0, 8171, 8172, 5, 2440, 0, 0, 8172, 8174, + 1, 0, 0, 0, 8173, 8170, 1, 0, 0, 0, 8173, 8174, 1, 0, 0, 0, 8174, 8175, + 1, 0, 0, 0, 8175, 8177, 3, 2404, 1202, 0, 8176, 8169, 1, 0, 0, 0, 8177, + 8180, 1, 0, 0, 0, 8178, 8176, 1, 0, 0, 0, 8178, 8179, 1, 0, 0, 0, 8179, + 8201, 1, 0, 0, 0, 8180, 8178, 1, 0, 0, 0, 8181, 8185, 5, 732, 0, 0, 8182, + 8183, 3, 2286, 1143, 0, 8183, 8184, 5, 2440, 0, 0, 8184, 8186, 1, 0, 0, + 0, 8185, 8182, 1, 0, 0, 0, 8185, 8186, 1, 0, 0, 0, 8186, 8187, 1, 0, 0, + 0, 8187, 8197, 3, 2404, 1202, 0, 8188, 8192, 5, 2453, 0, 0, 8189, 8190, + 3, 2286, 1143, 0, 8190, 8191, 5, 2440, 0, 0, 8191, 8193, 1, 0, 0, 0, 8192, + 8189, 1, 0, 0, 0, 8192, 8193, 1, 0, 0, 0, 8193, 8194, 1, 0, 0, 0, 8194, + 8196, 3, 2404, 1202, 0, 8195, 8188, 1, 0, 0, 0, 8196, 8199, 1, 0, 0, 0, + 8197, 8195, 1, 0, 0, 0, 8197, 8198, 1, 0, 0, 0, 8198, 8201, 1, 0, 0, 0, + 8199, 8197, 1, 0, 0, 0, 8200, 8081, 1, 0, 0, 0, 8200, 8105, 1, 0, 0, 0, + 8200, 8124, 1, 0, 0, 0, 8200, 8143, 1, 0, 0, 0, 8200, 8162, 1, 0, 0, 0, + 8200, 8181, 1, 0, 0, 0, 8201, 8203, 1, 0, 0, 0, 8202, 8204, 5, 616, 0, + 0, 8203, 8202, 1, 0, 0, 0, 8203, 8204, 1, 0, 0, 0, 8204, 749, 1, 0, 0, + 0, 8205, 8206, 5, 469, 0, 0, 8206, 8210, 5, 731, 0, 0, 8207, 8208, 3, 2286, + 1143, 0, 8208, 8209, 5, 2440, 0, 0, 8209, 8211, 1, 0, 0, 0, 8210, 8207, + 1, 0, 0, 0, 8210, 8211, 1, 0, 0, 0, 8211, 8212, 1, 0, 0, 0, 8212, 8214, + 3, 2404, 1202, 0, 8213, 8215, 5, 616, 0, 0, 8214, 8213, 1, 0, 0, 0, 8214, + 8215, 1, 0, 0, 0, 8215, 751, 1, 0, 0, 0, 8216, 8217, 5, 469, 0, 0, 8217, + 8218, 5, 746, 0, 0, 8218, 8219, 5, 794, 0, 0, 8219, 8223, 5, 649, 0, 0, + 8220, 8221, 3, 2286, 1143, 0, 8221, 8222, 5, 2440, 0, 0, 8222, 8224, 1, + 0, 0, 0, 8223, 8220, 1, 0, 0, 0, 8223, 8224, 1, 0, 0, 0, 8224, 8225, 1, + 0, 0, 0, 8225, 8226, 3, 2404, 1202, 0, 8226, 753, 1, 0, 0, 0, 8227, 8228, + 5, 605, 0, 0, 8228, 8229, 5, 2083, 0, 0, 8229, 8234, 3, 2342, 1171, 0, + 8230, 8231, 5, 2453, 0, 0, 8231, 8233, 3, 2342, 1171, 0, 8232, 8230, 1, + 0, 0, 0, 8233, 8236, 1, 0, 0, 0, 8234, 8232, 1, 0, 0, 0, 8234, 8235, 1, + 0, 0, 0, 8235, 8237, 1, 0, 0, 0, 8236, 8234, 1, 0, 0, 0, 8237, 8256, 5, + 2141, 0, 0, 8238, 8239, 7, 83, 0, 0, 8239, 8244, 3, 2078, 1039, 0, 8240, + 8241, 5, 1574, 0, 0, 8241, 8242, 5, 1411, 0, 0, 8242, 8244, 3, 756, 378, + 0, 8243, 8238, 1, 0, 0, 0, 8243, 8240, 1, 0, 0, 0, 8244, 8247, 1, 0, 0, + 0, 8245, 8246, 7, 17, 0, 0, 8246, 8248, 5, 2156, 0, 0, 8247, 8245, 1, 0, + 0, 0, 8247, 8248, 1, 0, 0, 0, 8248, 8257, 1, 0, 0, 0, 8249, 8250, 5, 112, + 0, 0, 8250, 8254, 5, 469, 0, 0, 8251, 8252, 5, 1559, 0, 0, 8252, 8253, + 5, 2141, 0, 0, 8253, 8255, 3, 2342, 1171, 0, 8254, 8251, 1, 0, 0, 0, 8254, + 8255, 1, 0, 0, 0, 8255, 8257, 1, 0, 0, 0, 8256, 8243, 1, 0, 0, 0, 8256, + 8249, 1, 0, 0, 0, 8257, 755, 1, 0, 0, 0, 8258, 8263, 3, 2402, 1201, 0, + 8259, 8260, 5, 2440, 0, 0, 8260, 8262, 3, 2404, 1202, 0, 8261, 8259, 1, + 0, 0, 0, 8262, 8265, 1, 0, 0, 0, 8263, 8261, 1, 0, 0, 0, 8263, 8264, 1, + 0, 0, 0, 8264, 757, 1, 0, 0, 0, 8265, 8263, 1, 0, 0, 0, 8266, 8280, 5, + 1475, 0, 0, 8267, 8268, 7, 84, 0, 0, 8268, 8281, 3, 2404, 1202, 0, 8269, + 8271, 5, 2080, 0, 0, 8270, 8272, 5, 1671, 0, 0, 8271, 8270, 1, 0, 0, 0, + 8271, 8272, 1, 0, 0, 0, 8272, 8273, 1, 0, 0, 0, 8273, 8276, 3, 2404, 1202, + 0, 8274, 8275, 5, 2237, 0, 0, 8275, 8277, 3, 2404, 1202, 0, 8276, 8274, + 1, 0, 0, 0, 8276, 8277, 1, 0, 0, 0, 8277, 8281, 1, 0, 0, 0, 8278, 8281, + 5, 1518, 0, 0, 8279, 8281, 5, 369, 0, 0, 8280, 8267, 1, 0, 0, 0, 8280, + 8269, 1, 0, 0, 0, 8280, 8278, 1, 0, 0, 0, 8280, 8279, 1, 0, 0, 0, 8281, + 759, 1, 0, 0, 0, 8282, 8294, 5, 1059, 0, 0, 8283, 8285, 3, 726, 363, 0, + 8284, 8286, 3, 728, 364, 0, 8285, 8284, 1, 0, 0, 0, 8285, 8286, 1, 0, 0, + 0, 8286, 8295, 1, 0, 0, 0, 8287, 8295, 3, 732, 366, 0, 8288, 8295, 5, 1019, + 0, 0, 8289, 8290, 5, 427, 0, 0, 8290, 8292, 5, 867, 0, 0, 8291, 8293, 3, + 728, 364, 0, 8292, 8291, 1, 0, 0, 0, 8292, 8293, 1, 0, 0, 0, 8293, 8295, + 1, 0, 0, 0, 8294, 8283, 1, 0, 0, 0, 8294, 8287, 1, 0, 0, 0, 8294, 8288, + 1, 0, 0, 0, 8294, 8289, 1, 0, 0, 0, 8295, 8301, 1, 0, 0, 0, 8296, 8298, + 5, 2299, 0, 0, 8297, 8299, 5, 1204, 0, 0, 8298, 8297, 1, 0, 0, 0, 8298, + 8299, 1, 0, 0, 0, 8299, 8300, 1, 0, 0, 0, 8300, 8302, 5, 1786, 0, 0, 8301, + 8296, 1, 0, 0, 0, 8301, 8302, 1, 0, 0, 0, 8302, 8304, 1, 0, 0, 0, 8303, + 8305, 3, 766, 383, 0, 8304, 8303, 1, 0, 0, 0, 8304, 8305, 1, 0, 0, 0, 8305, + 761, 1, 0, 0, 0, 8306, 8307, 5, 1559, 0, 0, 8307, 8308, 3, 740, 370, 0, + 8308, 8309, 5, 2141, 0, 0, 8309, 8310, 3, 740, 370, 0, 8310, 763, 1, 0, + 0, 0, 8311, 8323, 5, 647, 0, 0, 8312, 8314, 5, 2453, 0, 0, 8313, 8312, + 1, 0, 0, 0, 8313, 8314, 1, 0, 0, 0, 8314, 8321, 1, 0, 0, 0, 8315, 8322, + 3, 2308, 1154, 0, 8316, 8322, 3, 2392, 1196, 0, 8317, 8319, 3, 2390, 1195, + 0, 8318, 8320, 3, 2360, 1180, 0, 8319, 8318, 1, 0, 0, 0, 8319, 8320, 1, + 0, 0, 0, 8320, 8322, 1, 0, 0, 0, 8321, 8315, 1, 0, 0, 0, 8321, 8316, 1, + 0, 0, 0, 8321, 8317, 1, 0, 0, 0, 8322, 8324, 1, 0, 0, 0, 8323, 8313, 1, + 0, 0, 0, 8324, 8325, 1, 0, 0, 0, 8325, 8323, 1, 0, 0, 0, 8325, 8326, 1, + 0, 0, 0, 8326, 8329, 1, 0, 0, 0, 8327, 8328, 5, 1259, 0, 0, 8328, 8330, + 3, 2356, 1178, 0, 8329, 8327, 1, 0, 0, 0, 8329, 8330, 1, 0, 0, 0, 8330, + 8331, 1, 0, 0, 0, 8331, 8334, 5, 2141, 0, 0, 8332, 8335, 3, 2306, 1153, + 0, 8333, 8335, 5, 1473, 0, 0, 8334, 8332, 1, 0, 0, 0, 8334, 8333, 1, 0, + 0, 0, 8335, 8343, 1, 0, 0, 0, 8336, 8339, 5, 2453, 0, 0, 8337, 8340, 3, + 2306, 1153, 0, 8338, 8340, 5, 1473, 0, 0, 8339, 8337, 1, 0, 0, 0, 8339, + 8338, 1, 0, 0, 0, 8340, 8342, 1, 0, 0, 0, 8341, 8336, 1, 0, 0, 0, 8342, + 8345, 1, 0, 0, 0, 8343, 8341, 1, 0, 0, 0, 8343, 8344, 1, 0, 0, 0, 8344, + 8349, 1, 0, 0, 0, 8345, 8343, 1, 0, 0, 0, 8346, 8347, 5, 2308, 0, 0, 8347, + 8348, 7, 85, 0, 0, 8348, 8350, 5, 1272, 0, 0, 8349, 8346, 1, 0, 0, 0, 8349, + 8350, 1, 0, 0, 0, 8350, 8354, 1, 0, 0, 0, 8351, 8352, 5, 2308, 0, 0, 8352, + 8353, 5, 674, 0, 0, 8353, 8355, 5, 1272, 0, 0, 8354, 8351, 1, 0, 0, 0, + 8354, 8355, 1, 0, 0, 0, 8355, 8359, 1, 0, 0, 0, 8356, 8357, 5, 2308, 0, + 0, 8357, 8358, 5, 647, 0, 0, 8358, 8360, 5, 1272, 0, 0, 8359, 8356, 1, + 0, 0, 0, 8359, 8360, 1, 0, 0, 0, 8360, 8362, 1, 0, 0, 0, 8361, 8363, 3, + 766, 383, 0, 8362, 8361, 1, 0, 0, 0, 8362, 8363, 1, 0, 0, 0, 8363, 765, + 1, 0, 0, 0, 8364, 8365, 5, 289, 0, 0, 8365, 8366, 5, 2472, 0, 0, 8366, + 8367, 7, 82, 0, 0, 8367, 767, 1, 0, 0, 0, 8368, 8377, 5, 1589, 0, 0, 8369, + 8372, 3, 770, 385, 0, 8370, 8372, 3, 774, 387, 0, 8371, 8369, 1, 0, 0, + 0, 8371, 8370, 1, 0, 0, 0, 8372, 8374, 1, 0, 0, 0, 8373, 8375, 3, 766, + 383, 0, 8374, 8373, 1, 0, 0, 0, 8374, 8375, 1, 0, 0, 0, 8375, 8378, 1, + 0, 0, 0, 8376, 8378, 3, 778, 389, 0, 8377, 8371, 1, 0, 0, 0, 8377, 8376, + 1, 0, 0, 0, 8378, 769, 1, 0, 0, 0, 8379, 8384, 3, 2392, 1196, 0, 8380, + 8384, 3, 2308, 1154, 0, 8381, 8382, 5, 38, 0, 0, 8382, 8384, 5, 1459, 0, + 0, 8383, 8379, 1, 0, 0, 0, 8383, 8380, 1, 0, 0, 0, 8383, 8381, 1, 0, 0, + 0, 8384, 8385, 1, 0, 0, 0, 8385, 8386, 5, 628, 0, 0, 8386, 8387, 3, 772, + 386, 0, 8387, 771, 1, 0, 0, 0, 8388, 8391, 3, 2404, 1202, 0, 8389, 8391, + 5, 1473, 0, 0, 8390, 8388, 1, 0, 0, 0, 8390, 8389, 1, 0, 0, 0, 8391, 8399, + 1, 0, 0, 0, 8392, 8395, 5, 2453, 0, 0, 8393, 8396, 3, 2404, 1202, 0, 8394, + 8396, 5, 1473, 0, 0, 8395, 8393, 1, 0, 0, 0, 8395, 8394, 1, 0, 0, 0, 8396, + 8398, 1, 0, 0, 0, 8397, 8392, 1, 0, 0, 0, 8398, 8401, 1, 0, 0, 0, 8399, + 8397, 1, 0, 0, 0, 8399, 8400, 1, 0, 0, 0, 8400, 773, 1, 0, 0, 0, 8401, + 8399, 1, 0, 0, 0, 8402, 8408, 3, 2390, 1195, 0, 8403, 8405, 5, 38, 0, 0, + 8404, 8406, 5, 1459, 0, 0, 8405, 8404, 1, 0, 0, 0, 8405, 8406, 1, 0, 0, + 0, 8406, 8408, 1, 0, 0, 0, 8407, 8402, 1, 0, 0, 0, 8407, 8403, 1, 0, 0, + 0, 8408, 8419, 1, 0, 0, 0, 8409, 8415, 5, 2453, 0, 0, 8410, 8416, 3, 2390, + 1195, 0, 8411, 8413, 5, 38, 0, 0, 8412, 8414, 5, 1459, 0, 0, 8413, 8412, + 1, 0, 0, 0, 8413, 8414, 1, 0, 0, 0, 8414, 8416, 1, 0, 0, 0, 8415, 8410, + 1, 0, 0, 0, 8415, 8411, 1, 0, 0, 0, 8416, 8418, 1, 0, 0, 0, 8417, 8409, + 1, 0, 0, 0, 8418, 8421, 1, 0, 0, 0, 8419, 8417, 1, 0, 0, 0, 8419, 8420, + 1, 0, 0, 0, 8420, 8422, 1, 0, 0, 0, 8421, 8419, 1, 0, 0, 0, 8422, 8423, + 3, 776, 388, 0, 8423, 8424, 5, 628, 0, 0, 8424, 8428, 3, 772, 386, 0, 8425, + 8426, 5, 179, 0, 0, 8426, 8429, 5, 287, 0, 0, 8427, 8429, 5, 616, 0, 0, + 8428, 8425, 1, 0, 0, 0, 8428, 8427, 1, 0, 0, 0, 8428, 8429, 1, 0, 0, 0, + 8429, 775, 1, 0, 0, 0, 8430, 8475, 5, 1259, 0, 0, 8431, 8432, 3, 2286, + 1143, 0, 8432, 8433, 5, 2440, 0, 0, 8433, 8435, 1, 0, 0, 0, 8434, 8431, + 1, 0, 0, 0, 8434, 8435, 1, 0, 0, 0, 8435, 8436, 1, 0, 0, 0, 8436, 8476, + 3, 2404, 1202, 0, 8437, 8438, 5, 2237, 0, 0, 8438, 8443, 3, 2404, 1202, + 0, 8439, 8440, 5, 2453, 0, 0, 8440, 8442, 3, 2404, 1202, 0, 8441, 8439, + 1, 0, 0, 0, 8442, 8445, 1, 0, 0, 0, 8443, 8441, 1, 0, 0, 0, 8443, 8444, + 1, 0, 0, 0, 8444, 8476, 1, 0, 0, 0, 8445, 8443, 1, 0, 0, 0, 8446, 8447, + 5, 426, 0, 0, 8447, 8476, 3, 786, 393, 0, 8448, 8449, 5, 483, 0, 0, 8449, + 8476, 3, 1454, 727, 0, 8450, 8451, 5, 955, 0, 0, 8451, 8455, 5, 971, 0, + 0, 8452, 8453, 3, 2286, 1143, 0, 8453, 8454, 5, 2440, 0, 0, 8454, 8456, + 1, 0, 0, 0, 8455, 8452, 1, 0, 0, 0, 8455, 8456, 1, 0, 0, 0, 8456, 8457, + 1, 0, 0, 0, 8457, 8476, 3, 2404, 1202, 0, 8458, 8459, 5, 792, 0, 0, 8459, + 8463, 7, 86, 0, 0, 8460, 8461, 3, 2286, 1143, 0, 8461, 8462, 5, 2440, 0, + 0, 8462, 8464, 1, 0, 0, 0, 8463, 8460, 1, 0, 0, 0, 8463, 8464, 1, 0, 0, + 0, 8464, 8465, 1, 0, 0, 0, 8465, 8476, 3, 2404, 1202, 0, 8466, 8467, 5, + 1722, 0, 0, 8467, 8468, 5, 2154, 0, 0, 8468, 8472, 5, 1463, 0, 0, 8469, + 8470, 3, 2286, 1143, 0, 8470, 8471, 5, 2440, 0, 0, 8471, 8473, 1, 0, 0, + 0, 8472, 8469, 1, 0, 0, 0, 8472, 8473, 1, 0, 0, 0, 8473, 8474, 1, 0, 0, + 0, 8474, 8476, 3, 2404, 1202, 0, 8475, 8434, 1, 0, 0, 0, 8475, 8437, 1, + 0, 0, 0, 8475, 8446, 1, 0, 0, 0, 8475, 8448, 1, 0, 0, 0, 8475, 8450, 1, + 0, 0, 0, 8475, 8458, 1, 0, 0, 0, 8475, 8466, 1, 0, 0, 0, 8476, 777, 1, + 0, 0, 0, 8477, 8482, 3, 2308, 1154, 0, 8478, 8479, 5, 2453, 0, 0, 8479, + 8481, 3, 2308, 1154, 0, 8480, 8478, 1, 0, 0, 0, 8481, 8484, 1, 0, 0, 0, + 8482, 8480, 1, 0, 0, 0, 8482, 8483, 1, 0, 0, 0, 8483, 8487, 1, 0, 0, 0, + 8484, 8482, 1, 0, 0, 0, 8485, 8487, 5, 38, 0, 0, 8486, 8477, 1, 0, 0, 0, + 8486, 8485, 1, 0, 0, 0, 8487, 8488, 1, 0, 0, 0, 8488, 8489, 5, 628, 0, + 0, 8489, 8494, 3, 780, 390, 0, 8490, 8491, 5, 2453, 0, 0, 8491, 8493, 3, + 780, 390, 0, 8492, 8490, 1, 0, 0, 0, 8493, 8496, 1, 0, 0, 0, 8494, 8492, + 1, 0, 0, 0, 8494, 8495, 1, 0, 0, 0, 8495, 779, 1, 0, 0, 0, 8496, 8494, + 1, 0, 0, 0, 8497, 8501, 7, 87, 0, 0, 8498, 8499, 3, 2286, 1143, 0, 8499, + 8500, 5, 2440, 0, 0, 8500, 8502, 1, 0, 0, 0, 8501, 8498, 1, 0, 0, 0, 8501, + 8502, 1, 0, 0, 0, 8502, 8503, 1, 0, 0, 0, 8503, 8504, 3, 2404, 1202, 0, + 8504, 781, 1, 0, 0, 0, 8505, 8506, 5, 321, 0, 0, 8506, 8507, 5, 422, 0, + 0, 8507, 8509, 3, 2402, 1201, 0, 8508, 8510, 3, 820, 410, 0, 8509, 8508, + 1, 0, 0, 0, 8510, 8511, 1, 0, 0, 0, 8511, 8509, 1, 0, 0, 0, 8511, 8512, + 1, 0, 0, 0, 8512, 8516, 1, 0, 0, 0, 8513, 8517, 3, 822, 411, 0, 8514, 8517, + 3, 826, 413, 0, 8515, 8517, 3, 828, 414, 0, 8516, 8513, 1, 0, 0, 0, 8516, + 8514, 1, 0, 0, 0, 8516, 8515, 1, 0, 0, 0, 8517, 8518, 1, 0, 0, 0, 8518, + 8516, 1, 0, 0, 0, 8518, 8519, 1, 0, 0, 0, 8519, 783, 1, 0, 0, 0, 8520, + 8523, 5, 321, 0, 0, 8521, 8522, 5, 1307, 0, 0, 8522, 8524, 5, 1562, 0, + 0, 8523, 8521, 1, 0, 0, 0, 8523, 8524, 1, 0, 0, 0, 8524, 8525, 1, 0, 0, + 0, 8525, 8526, 5, 426, 0, 0, 8526, 8530, 3, 786, 393, 0, 8527, 8528, 5, + 1681, 0, 0, 8528, 8529, 5, 2472, 0, 0, 8529, 8531, 7, 21, 0, 0, 8530, 8527, + 1, 0, 0, 0, 8530, 8531, 1, 0, 0, 0, 8531, 8532, 1, 0, 0, 0, 8532, 8533, + 5, 69, 0, 0, 8533, 8534, 3, 788, 394, 0, 8534, 785, 1, 0, 0, 0, 8535, 8536, + 3, 2410, 1205, 0, 8536, 787, 1, 0, 0, 0, 8537, 8538, 5, 2443, 0, 0, 8538, + 789, 1, 0, 0, 0, 8539, 8540, 5, 321, 0, 0, 8540, 8541, 5, 746, 0, 0, 8541, + 8542, 5, 794, 0, 0, 8542, 8546, 5, 649, 0, 0, 8543, 8544, 3, 2286, 1143, + 0, 8544, 8545, 5, 2440, 0, 0, 8545, 8547, 1, 0, 0, 0, 8546, 8543, 1, 0, + 0, 0, 8546, 8547, 1, 0, 0, 0, 8547, 8548, 1, 0, 0, 0, 8548, 8549, 3, 2404, + 1202, 0, 8549, 8553, 5, 2447, 0, 0, 8550, 8551, 3, 2286, 1143, 0, 8551, + 8552, 5, 2440, 0, 0, 8552, 8554, 1, 0, 0, 0, 8553, 8550, 1, 0, 0, 0, 8553, + 8554, 1, 0, 0, 0, 8554, 8555, 1, 0, 0, 0, 8555, 8556, 3, 2404, 1202, 0, + 8556, 8557, 5, 2447, 0, 0, 8557, 8558, 3, 2404, 1202, 0, 8558, 8570, 5, + 2448, 0, 0, 8559, 8563, 5, 2453, 0, 0, 8560, 8561, 3, 2286, 1143, 0, 8561, + 8562, 5, 2440, 0, 0, 8562, 8564, 1, 0, 0, 0, 8563, 8560, 1, 0, 0, 0, 8563, + 8564, 1, 0, 0, 0, 8564, 8565, 1, 0, 0, 0, 8565, 8566, 3, 2404, 1202, 0, + 8566, 8567, 5, 2447, 0, 0, 8567, 8568, 3, 2404, 1202, 0, 8568, 8569, 5, + 2448, 0, 0, 8569, 8571, 1, 0, 0, 0, 8570, 8559, 1, 0, 0, 0, 8571, 8572, + 1, 0, 0, 0, 8572, 8570, 1, 0, 0, 0, 8572, 8573, 1, 0, 0, 0, 8573, 8574, + 1, 0, 0, 0, 8574, 8575, 5, 2448, 0, 0, 8575, 791, 1, 0, 0, 0, 8576, 8577, + 5, 469, 0, 0, 8577, 8581, 5, 674, 0, 0, 8578, 8579, 3, 2286, 1143, 0, 8579, + 8580, 5, 2440, 0, 0, 8580, 8582, 1, 0, 0, 0, 8581, 8578, 1, 0, 0, 0, 8581, + 8582, 1, 0, 0, 0, 8582, 8583, 1, 0, 0, 0, 8583, 8584, 3, 2404, 1202, 0, + 8584, 793, 1, 0, 0, 0, 8585, 8586, 5, 42, 0, 0, 8586, 8587, 5, 849, 0, + 0, 8587, 8603, 3, 816, 408, 0, 8588, 8590, 5, 249, 0, 0, 8589, 8591, 3, + 810, 405, 0, 8590, 8589, 1, 0, 0, 0, 8590, 8591, 1, 0, 0, 0, 8591, 8595, + 1, 0, 0, 0, 8592, 8594, 3, 812, 406, 0, 8593, 8592, 1, 0, 0, 0, 8594, 8597, + 1, 0, 0, 0, 8595, 8593, 1, 0, 0, 0, 8595, 8596, 1, 0, 0, 0, 8596, 8600, + 1, 0, 0, 0, 8597, 8595, 1, 0, 0, 0, 8598, 8599, 5, 1587, 0, 0, 8599, 8601, + 5, 1673, 0, 0, 8600, 8598, 1, 0, 0, 0, 8600, 8601, 1, 0, 0, 0, 8601, 8604, + 1, 0, 0, 0, 8602, 8604, 3, 808, 404, 0, 8603, 8588, 1, 0, 0, 0, 8603, 8602, + 1, 0, 0, 0, 8604, 795, 1, 0, 0, 0, 8605, 8606, 5, 469, 0, 0, 8606, 8607, + 5, 792, 0, 0, 8607, 8611, 7, 88, 0, 0, 8608, 8609, 3, 2286, 1143, 0, 8609, + 8610, 5, 2440, 0, 0, 8610, 8612, 1, 0, 0, 0, 8611, 8608, 1, 0, 0, 0, 8611, + 8612, 1, 0, 0, 0, 8612, 8613, 1, 0, 0, 0, 8613, 8614, 3, 2404, 1202, 0, + 8614, 797, 1, 0, 0, 0, 8615, 8616, 5, 469, 0, 0, 8616, 8617, 5, 849, 0, + 0, 8617, 8618, 3, 816, 408, 0, 8618, 799, 1, 0, 0, 0, 8619, 8622, 5, 321, + 0, 0, 8620, 8621, 5, 1307, 0, 0, 8621, 8623, 5, 1562, 0, 0, 8622, 8620, + 1, 0, 0, 0, 8622, 8623, 1, 0, 0, 0, 8623, 8626, 1, 0, 0, 0, 8624, 8625, + 5, 49, 0, 0, 8625, 8627, 7, 89, 0, 0, 8626, 8624, 1, 0, 0, 0, 8626, 8627, + 1, 0, 0, 0, 8627, 8629, 1, 0, 0, 0, 8628, 8630, 5, 1104, 0, 0, 8629, 8628, + 1, 0, 0, 0, 8629, 8630, 1, 0, 0, 0, 8630, 8631, 1, 0, 0, 0, 8631, 8645, + 5, 792, 0, 0, 8632, 8633, 7, 86, 0, 0, 8633, 8637, 5, 996, 0, 0, 8634, + 8635, 3, 2286, 1143, 0, 8635, 8636, 5, 2440, 0, 0, 8636, 8638, 1, 0, 0, + 0, 8637, 8634, 1, 0, 0, 0, 8637, 8638, 1, 0, 0, 0, 8638, 8639, 1, 0, 0, + 0, 8639, 8646, 3, 2404, 1202, 0, 8640, 8643, 5, 206, 0, 0, 8641, 8642, + 5, 1625, 0, 0, 8642, 8644, 3, 2404, 1202, 0, 8643, 8641, 1, 0, 0, 0, 8643, + 8644, 1, 0, 0, 0, 8644, 8646, 1, 0, 0, 0, 8645, 8632, 1, 0, 0, 0, 8645, + 8640, 1, 0, 0, 0, 8646, 8650, 1, 0, 0, 0, 8647, 8648, 5, 1681, 0, 0, 8648, + 8649, 5, 2472, 0, 0, 8649, 8651, 7, 21, 0, 0, 8650, 8647, 1, 0, 0, 0, 8650, + 8651, 1, 0, 0, 0, 8651, 8653, 1, 0, 0, 0, 8652, 8654, 3, 1720, 860, 0, + 8653, 8652, 1, 0, 0, 0, 8653, 8654, 1, 0, 0, 0, 8654, 8672, 1, 0, 0, 0, + 8655, 8656, 5, 1569, 0, 0, 8656, 8667, 5, 2447, 0, 0, 8657, 8658, 5, 2447, + 0, 0, 8658, 8660, 5, 2443, 0, 0, 8659, 8661, 5, 2453, 0, 0, 8660, 8659, + 1, 0, 0, 0, 8660, 8661, 1, 0, 0, 0, 8661, 8664, 1, 0, 0, 0, 8662, 8665, + 3, 2404, 1202, 0, 8663, 8665, 5, 2452, 0, 0, 8664, 8662, 1, 0, 0, 0, 8664, + 8663, 1, 0, 0, 0, 8665, 8666, 1, 0, 0, 0, 8666, 8668, 5, 2448, 0, 0, 8667, + 8657, 1, 0, 0, 0, 8668, 8669, 1, 0, 0, 0, 8669, 8667, 1, 0, 0, 0, 8669, + 8670, 1, 0, 0, 0, 8670, 8671, 1, 0, 0, 0, 8671, 8673, 5, 2448, 0, 0, 8672, + 8655, 1, 0, 0, 0, 8672, 8673, 1, 0, 0, 0, 8673, 8689, 1, 0, 0, 0, 8674, + 8685, 5, 2246, 0, 0, 8675, 8676, 5, 119, 0, 0, 8676, 8677, 5, 2447, 0, + 0, 8677, 8678, 3, 2404, 1202, 0, 8678, 8679, 5, 2453, 0, 0, 8679, 8680, + 3, 1458, 729, 0, 8680, 8681, 5, 2448, 0, 0, 8681, 8686, 1, 0, 0, 0, 8682, + 8683, 7, 90, 0, 0, 8683, 8686, 3, 1896, 948, 0, 8684, 8686, 5, 2443, 0, + 0, 8685, 8675, 1, 0, 0, 0, 8685, 8682, 1, 0, 0, 0, 8685, 8684, 1, 0, 0, + 0, 8686, 8690, 1, 0, 0, 0, 8687, 8688, 5, 69, 0, 0, 8688, 8690, 5, 2443, + 0, 0, 8689, 8674, 1, 0, 0, 0, 8689, 8687, 1, 0, 0, 0, 8690, 801, 1, 0, + 0, 0, 8691, 8694, 5, 321, 0, 0, 8692, 8693, 5, 1307, 0, 0, 8693, 8695, + 5, 1562, 0, 0, 8694, 8692, 1, 0, 0, 0, 8694, 8695, 1, 0, 0, 0, 8695, 8697, + 1, 0, 0, 0, 8696, 8698, 7, 20, 0, 0, 8697, 8696, 1, 0, 0, 0, 8697, 8698, + 1, 0, 0, 0, 8698, 8699, 1, 0, 0, 0, 8699, 8700, 5, 849, 0, 0, 8700, 8701, + 3, 804, 402, 0, 8701, 803, 1, 0, 0, 0, 8702, 8703, 3, 816, 408, 0, 8703, + 8704, 7, 22, 0, 0, 8704, 8707, 3, 2400, 1200, 0, 8705, 8706, 5, 738, 0, + 0, 8706, 8708, 3, 786, 393, 0, 8707, 8705, 1, 0, 0, 0, 8707, 8708, 1, 0, + 0, 0, 8708, 8711, 1, 0, 0, 0, 8709, 8710, 5, 34, 0, 0, 8710, 8712, 3, 2400, + 1200, 0, 8711, 8709, 1, 0, 0, 0, 8711, 8712, 1, 0, 0, 0, 8712, 8715, 1, + 0, 0, 0, 8713, 8714, 5, 325, 0, 0, 8714, 8716, 3, 806, 403, 0, 8715, 8713, + 1, 0, 0, 0, 8715, 8716, 1, 0, 0, 0, 8716, 805, 1, 0, 0, 0, 8717, 8718, + 3, 2404, 1202, 0, 8718, 8719, 5, 2440, 0, 0, 8719, 8721, 1, 0, 0, 0, 8720, + 8717, 1, 0, 0, 0, 8720, 8721, 1, 0, 0, 0, 8721, 8722, 1, 0, 0, 0, 8722, + 8723, 3, 2404, 1202, 0, 8723, 807, 1, 0, 0, 0, 8724, 8725, 4, 404, 5, 0, + 8725, 8726, 7, 20, 0, 0, 8726, 809, 1, 0, 0, 0, 8727, 8728, 4, 405, 6, + 0, 8728, 8729, 5, 378, 0, 0, 8729, 811, 1, 0, 0, 0, 8730, 8731, 3, 2294, + 1147, 0, 8731, 8732, 5, 2472, 0, 0, 8732, 8733, 3, 814, 407, 0, 8733, 813, + 1, 0, 0, 0, 8734, 8737, 3, 2410, 1205, 0, 8735, 8737, 5, 2443, 0, 0, 8736, + 8734, 1, 0, 0, 0, 8736, 8735, 1, 0, 0, 0, 8737, 815, 1, 0, 0, 0, 8738, + 8739, 3, 2410, 1205, 0, 8739, 8740, 5, 2440, 0, 0, 8740, 8742, 1, 0, 0, + 0, 8741, 8738, 1, 0, 0, 0, 8741, 8742, 1, 0, 0, 0, 8742, 8743, 1, 0, 0, + 0, 8743, 8744, 3, 2410, 1205, 0, 8744, 817, 1, 0, 0, 0, 8745, 8746, 5, + 42, 0, 0, 8746, 8747, 5, 422, 0, 0, 8747, 8792, 3, 2402, 1201, 0, 8748, + 8753, 5, 21, 0, 0, 8749, 8754, 3, 820, 410, 0, 8750, 8754, 3, 822, 411, + 0, 8751, 8754, 3, 826, 413, 0, 8752, 8754, 3, 828, 414, 0, 8753, 8749, + 1, 0, 0, 0, 8753, 8750, 1, 0, 0, 0, 8753, 8751, 1, 0, 0, 0, 8753, 8752, + 1, 0, 0, 0, 8754, 8756, 1, 0, 0, 0, 8755, 8748, 1, 0, 0, 0, 8756, 8757, + 1, 0, 0, 0, 8757, 8755, 1, 0, 0, 0, 8757, 8758, 1, 0, 0, 0, 8758, 8793, + 1, 0, 0, 0, 8759, 8785, 5, 469, 0, 0, 8760, 8761, 5, 846, 0, 0, 8761, 8763, + 3, 2402, 1201, 0, 8762, 8764, 7, 91, 0, 0, 8763, 8762, 1, 0, 0, 0, 8763, + 8764, 1, 0, 0, 0, 8764, 8786, 1, 0, 0, 0, 8765, 8766, 5, 674, 0, 0, 8766, + 8786, 3, 2402, 1201, 0, 8767, 8768, 5, 83, 0, 0, 8768, 8783, 3, 2402, 1201, + 0, 8769, 8770, 5, 846, 0, 0, 8770, 8781, 3, 2402, 1201, 0, 8771, 8772, + 5, 237, 0, 0, 8772, 8778, 3, 2340, 1170, 0, 8773, 8774, 5, 2453, 0, 0, + 8774, 8775, 5, 237, 0, 0, 8775, 8777, 3, 2340, 1170, 0, 8776, 8773, 1, + 0, 0, 0, 8777, 8780, 1, 0, 0, 0, 8778, 8776, 1, 0, 0, 0, 8778, 8779, 1, + 0, 0, 0, 8779, 8782, 1, 0, 0, 0, 8780, 8778, 1, 0, 0, 0, 8781, 8771, 1, + 0, 0, 0, 8781, 8782, 1, 0, 0, 0, 8782, 8784, 1, 0, 0, 0, 8783, 8769, 1, + 0, 0, 0, 8783, 8784, 1, 0, 0, 0, 8784, 8786, 1, 0, 0, 0, 8785, 8760, 1, + 0, 0, 0, 8785, 8765, 1, 0, 0, 0, 8785, 8767, 1, 0, 0, 0, 8786, 8788, 1, + 0, 0, 0, 8787, 8759, 1, 0, 0, 0, 8788, 8789, 1, 0, 0, 0, 8789, 8787, 1, + 0, 0, 0, 8789, 8790, 1, 0, 0, 0, 8790, 8793, 1, 0, 0, 0, 8791, 8793, 5, + 249, 0, 0, 8792, 8755, 1, 0, 0, 0, 8792, 8787, 1, 0, 0, 0, 8792, 8791, + 1, 0, 0, 0, 8793, 819, 1, 0, 0, 0, 8794, 8795, 5, 846, 0, 0, 8795, 8796, + 3, 2402, 1201, 0, 8796, 8817, 5, 785, 0, 0, 8797, 8798, 3, 1110, 555, 0, + 8798, 8799, 5, 2440, 0, 0, 8799, 8800, 3, 2340, 1170, 0, 8800, 8818, 1, + 0, 0, 0, 8801, 8802, 5, 2447, 0, 0, 8802, 8803, 3, 1110, 555, 0, 8803, + 8804, 5, 2440, 0, 0, 8804, 8812, 3, 2340, 1170, 0, 8805, 8806, 5, 2453, + 0, 0, 8806, 8807, 3, 1110, 555, 0, 8807, 8808, 5, 2440, 0, 0, 8808, 8809, + 3, 2340, 1170, 0, 8809, 8811, 1, 0, 0, 0, 8810, 8805, 1, 0, 0, 0, 8811, + 8814, 1, 0, 0, 0, 8812, 8810, 1, 0, 0, 0, 8812, 8813, 1, 0, 0, 0, 8813, + 8815, 1, 0, 0, 0, 8814, 8812, 1, 0, 0, 0, 8815, 8816, 5, 2448, 0, 0, 8816, + 8818, 1, 0, 0, 0, 8817, 8797, 1, 0, 0, 0, 8817, 8801, 1, 0, 0, 0, 8818, + 8822, 1, 0, 0, 0, 8819, 8820, 5, 1702, 0, 0, 8820, 8821, 5, 2300, 0, 0, + 8821, 8823, 5, 1228, 0, 0, 8822, 8819, 1, 0, 0, 0, 8822, 8823, 1, 0, 0, + 0, 8823, 821, 1, 0, 0, 0, 8824, 8825, 5, 674, 0, 0, 8825, 8826, 3, 2402, + 1201, 0, 8826, 8827, 5, 2447, 0, 0, 8827, 8831, 3, 2402, 1201, 0, 8828, + 8829, 5, 202, 0, 0, 8829, 8830, 5, 1246, 0, 0, 8830, 8832, 3, 2402, 1201, + 0, 8831, 8828, 1, 0, 0, 0, 8832, 8833, 1, 0, 0, 0, 8833, 8831, 1, 0, 0, + 0, 8833, 8834, 1, 0, 0, 0, 8834, 8836, 1, 0, 0, 0, 8835, 8837, 3, 824, + 412, 0, 8836, 8835, 1, 0, 0, 0, 8836, 8837, 1, 0, 0, 0, 8837, 8838, 1, + 0, 0, 0, 8838, 8839, 5, 2448, 0, 0, 8839, 823, 1, 0, 0, 0, 8840, 8841, + 5, 794, 0, 0, 8841, 8842, 5, 816, 0, 0, 8842, 8843, 3, 830, 415, 0, 8843, + 8844, 5, 1528, 0, 0, 8844, 8845, 3, 2402, 1201, 0, 8845, 8847, 1, 0, 0, + 0, 8846, 8840, 1, 0, 0, 0, 8847, 8848, 1, 0, 0, 0, 8848, 8846, 1, 0, 0, + 0, 8848, 8849, 1, 0, 0, 0, 8849, 825, 1, 0, 0, 0, 8850, 8851, 5, 83, 0, + 0, 8851, 8852, 3, 2402, 1201, 0, 8852, 8853, 5, 419, 0, 0, 8853, 8854, + 3, 830, 415, 0, 8854, 8856, 1, 0, 0, 0, 8855, 8850, 1, 0, 0, 0, 8856, 8857, + 1, 0, 0, 0, 8857, 8855, 1, 0, 0, 0, 8857, 8858, 1, 0, 0, 0, 8858, 827, + 1, 0, 0, 0, 8859, 8860, 5, 83, 0, 0, 8860, 8866, 3, 2402, 1201, 0, 8861, + 8862, 5, 846, 0, 0, 8862, 8863, 3, 2402, 1201, 0, 8863, 8864, 5, 419, 0, + 0, 8864, 8865, 3, 830, 415, 0, 8865, 8867, 1, 0, 0, 0, 8866, 8861, 1, 0, + 0, 0, 8867, 8868, 1, 0, 0, 0, 8868, 8866, 1, 0, 0, 0, 8868, 8869, 1, 0, + 0, 0, 8869, 829, 1, 0, 0, 0, 8870, 8883, 3, 2340, 1170, 0, 8871, 8872, + 5, 2447, 0, 0, 8872, 8877, 3, 2340, 1170, 0, 8873, 8874, 5, 2453, 0, 0, + 8874, 8876, 3, 2340, 1170, 0, 8875, 8873, 1, 0, 0, 0, 8876, 8879, 1, 0, + 0, 0, 8877, 8875, 1, 0, 0, 0, 8877, 8878, 1, 0, 0, 0, 8878, 8880, 1, 0, + 0, 0, 8879, 8877, 1, 0, 0, 0, 8880, 8881, 5, 2448, 0, 0, 8881, 8883, 1, + 0, 0, 0, 8882, 8870, 1, 0, 0, 0, 8882, 8871, 1, 0, 0, 0, 8883, 831, 1, + 0, 0, 0, 8884, 8885, 5, 42, 0, 0, 8885, 8886, 5, 2286, 0, 0, 8886, 8919, + 3, 2342, 1171, 0, 8887, 8888, 5, 21, 0, 0, 8888, 8920, 3, 852, 426, 0, + 8889, 8890, 5, 980, 0, 0, 8890, 8891, 5, 286, 0, 0, 8891, 8892, 3, 2310, + 1155, 0, 8892, 8893, 7, 51, 0, 0, 8893, 8920, 1, 0, 0, 0, 8894, 8911, 5, + 469, 0, 0, 8895, 8896, 5, 286, 0, 0, 8896, 8912, 3, 2310, 1155, 0, 8897, + 8898, 5, 1451, 0, 0, 8898, 8912, 5, 816, 0, 0, 8899, 8900, 5, 2183, 0, + 0, 8900, 8901, 5, 2447, 0, 0, 8901, 8906, 3, 2340, 1170, 0, 8902, 8903, + 5, 2453, 0, 0, 8903, 8905, 3, 2340, 1170, 0, 8904, 8902, 1, 0, 0, 0, 8905, + 8908, 1, 0, 0, 0, 8906, 8904, 1, 0, 0, 0, 8906, 8907, 1, 0, 0, 0, 8907, + 8909, 1, 0, 0, 0, 8908, 8906, 1, 0, 0, 0, 8909, 8910, 5, 2448, 0, 0, 8910, + 8912, 1, 0, 0, 0, 8911, 8895, 1, 0, 0, 0, 8911, 8897, 1, 0, 0, 0, 8911, + 8899, 1, 0, 0, 0, 8912, 8920, 1, 0, 0, 0, 8913, 8920, 5, 249, 0, 0, 8914, + 8915, 5, 1505, 0, 0, 8915, 8920, 7, 11, 0, 0, 8916, 8918, 3, 834, 417, + 0, 8917, 8916, 1, 0, 0, 0, 8917, 8918, 1, 0, 0, 0, 8918, 8920, 1, 0, 0, + 0, 8919, 8887, 1, 0, 0, 0, 8919, 8889, 1, 0, 0, 0, 8919, 8894, 1, 0, 0, + 0, 8919, 8913, 1, 0, 0, 0, 8919, 8914, 1, 0, 0, 0, 8919, 8917, 1, 0, 0, + 0, 8920, 833, 1, 0, 0, 0, 8921, 8922, 4, 417, 7, 0, 8922, 8923, 7, 20, + 0, 0, 8923, 835, 1, 0, 0, 0, 8924, 8927, 5, 321, 0, 0, 8925, 8926, 5, 1307, + 0, 0, 8926, 8928, 5, 1562, 0, 0, 8927, 8925, 1, 0, 0, 0, 8927, 8928, 1, + 0, 0, 0, 8928, 8933, 1, 0, 0, 0, 8929, 8931, 5, 1137, 0, 0, 8930, 8929, + 1, 0, 0, 0, 8930, 8931, 1, 0, 0, 0, 8931, 8932, 1, 0, 0, 0, 8932, 8934, + 5, 616, 0, 0, 8933, 8930, 1, 0, 0, 0, 8933, 8934, 1, 0, 0, 0, 8934, 8936, + 1, 0, 0, 0, 8935, 8937, 3, 838, 419, 0, 8936, 8935, 1, 0, 0, 0, 8936, 8937, + 1, 0, 0, 0, 8937, 8938, 1, 0, 0, 0, 8938, 8942, 5, 2286, 0, 0, 8939, 8940, + 3, 2286, 1143, 0, 8940, 8941, 5, 2440, 0, 0, 8941, 8943, 1, 0, 0, 0, 8942, + 8939, 1, 0, 0, 0, 8942, 8943, 1, 0, 0, 0, 8943, 8944, 1, 0, 0, 0, 8944, + 8948, 3, 2404, 1202, 0, 8945, 8946, 5, 691, 0, 0, 8946, 8947, 5, 1204, + 0, 0, 8947, 8949, 5, 545, 0, 0, 8948, 8945, 1, 0, 0, 0, 8948, 8949, 1, + 0, 0, 0, 8949, 8960, 1, 0, 0, 0, 8950, 8951, 5, 1681, 0, 0, 8951, 8958, + 5, 2472, 0, 0, 8952, 8959, 5, 948, 0, 0, 8953, 8955, 5, 2376, 0, 0, 8954, + 8953, 1, 0, 0, 0, 8954, 8955, 1, 0, 0, 0, 8955, 8956, 1, 0, 0, 0, 8956, + 8959, 5, 351, 0, 0, 8957, 8959, 5, 1133, 0, 0, 8958, 8952, 1, 0, 0, 0, + 8958, 8954, 1, 0, 0, 0, 8958, 8957, 1, 0, 0, 0, 8959, 8961, 1, 0, 0, 0, + 8960, 8950, 1, 0, 0, 0, 8960, 8961, 1, 0, 0, 0, 8961, 8963, 1, 0, 0, 0, + 8962, 8964, 3, 840, 420, 0, 8963, 8962, 1, 0, 0, 0, 8963, 8964, 1, 0, 0, + 0, 8964, 8968, 1, 0, 0, 0, 8965, 8966, 5, 389, 0, 0, 8966, 8967, 5, 2373, + 0, 0, 8967, 8969, 3, 2404, 1202, 0, 8968, 8965, 1, 0, 0, 0, 8968, 8969, + 1, 0, 0, 0, 8969, 8972, 1, 0, 0, 0, 8970, 8971, 5, 117, 0, 0, 8971, 8973, + 7, 92, 0, 0, 8972, 8970, 1, 0, 0, 0, 8972, 8973, 1, 0, 0, 0, 8973, 8974, + 1, 0, 0, 0, 8974, 8975, 5, 69, 0, 0, 8975, 8977, 3, 1868, 934, 0, 8976, + 8978, 3, 2068, 1034, 0, 8977, 8976, 1, 0, 0, 0, 8977, 8978, 1, 0, 0, 0, + 8978, 8980, 1, 0, 0, 0, 8979, 8981, 7, 93, 0, 0, 8980, 8979, 1, 0, 0, 0, + 8980, 8981, 1, 0, 0, 0, 8981, 837, 1, 0, 0, 0, 8982, 8989, 5, 484, 0, 0, + 8983, 8985, 5, 482, 0, 0, 8984, 8986, 5, 484, 0, 0, 8985, 8984, 1, 0, 0, + 0, 8985, 8986, 1, 0, 0, 0, 8986, 8989, 1, 0, 0, 0, 8987, 8989, 5, 1132, + 0, 0, 8988, 8982, 1, 0, 0, 0, 8988, 8983, 1, 0, 0, 0, 8988, 8987, 1, 0, + 0, 0, 8989, 839, 1, 0, 0, 0, 8990, 8994, 3, 842, 421, 0, 8991, 8994, 3, + 844, 422, 0, 8992, 8994, 3, 856, 428, 0, 8993, 8990, 1, 0, 0, 0, 8993, + 8991, 1, 0, 0, 0, 8993, 8992, 1, 0, 0, 0, 8994, 841, 1, 0, 0, 0, 8995, + 9009, 5, 2447, 0, 0, 8996, 8998, 5, 2453, 0, 0, 8997, 8996, 1, 0, 0, 0, + 8997, 8998, 1, 0, 0, 0, 8998, 9007, 1, 0, 0, 0, 8999, 9003, 3, 2270, 1135, + 0, 9000, 9002, 3, 846, 423, 0, 9001, 9000, 1, 0, 0, 0, 9002, 9005, 1, 0, + 0, 0, 9003, 9001, 1, 0, 0, 0, 9003, 9004, 1, 0, 0, 0, 9004, 9008, 1, 0, + 0, 0, 9005, 9003, 1, 0, 0, 0, 9006, 9008, 3, 852, 426, 0, 9007, 8999, 1, + 0, 0, 0, 9007, 9006, 1, 0, 0, 0, 9008, 9010, 1, 0, 0, 0, 9009, 8997, 1, + 0, 0, 0, 9010, 9011, 1, 0, 0, 0, 9011, 9009, 1, 0, 0, 0, 9011, 9012, 1, + 0, 0, 0, 9012, 9013, 1, 0, 0, 0, 9013, 9014, 5, 2448, 0, 0, 9014, 843, + 1, 0, 0, 0, 9015, 9019, 5, 1246, 0, 0, 9016, 9017, 3, 2286, 1143, 0, 9017, + 9018, 5, 2440, 0, 0, 9018, 9020, 1, 0, 0, 0, 9019, 9016, 1, 0, 0, 0, 9019, + 9020, 1, 0, 0, 0, 9020, 9021, 1, 0, 0, 0, 9021, 9045, 3, 2404, 1202, 0, + 9022, 9023, 5, 2308, 0, 0, 9023, 9024, 5, 1238, 0, 0, 9024, 9036, 7, 94, + 0, 0, 9025, 9037, 5, 389, 0, 0, 9026, 9027, 5, 2447, 0, 0, 9027, 9032, + 5, 2480, 0, 0, 9028, 9029, 5, 2453, 0, 0, 9029, 9031, 5, 2480, 0, 0, 9030, + 9028, 1, 0, 0, 0, 9031, 9034, 1, 0, 0, 0, 9032, 9030, 1, 0, 0, 0, 9032, + 9033, 1, 0, 0, 0, 9033, 9035, 1, 0, 0, 0, 9034, 9032, 1, 0, 0, 0, 9035, + 9037, 5, 2448, 0, 0, 9036, 9025, 1, 0, 0, 0, 9036, 9026, 1, 0, 0, 0, 9037, + 9046, 1, 0, 0, 0, 9038, 9042, 5, 2177, 0, 0, 9039, 9040, 3, 2286, 1143, + 0, 9040, 9041, 5, 2440, 0, 0, 9041, 9043, 1, 0, 0, 0, 9042, 9039, 1, 0, + 0, 0, 9042, 9043, 1, 0, 0, 0, 9043, 9044, 1, 0, 0, 0, 9044, 9046, 3, 2404, + 1202, 0, 9045, 9022, 1, 0, 0, 0, 9045, 9038, 1, 0, 0, 0, 9046, 9064, 1, + 0, 0, 0, 9047, 9056, 5, 2447, 0, 0, 9048, 9050, 5, 2453, 0, 0, 9049, 9048, + 1, 0, 0, 0, 9049, 9050, 1, 0, 0, 0, 9050, 9054, 1, 0, 0, 0, 9051, 9055, + 3, 852, 426, 0, 9052, 9053, 5, 2480, 0, 0, 9053, 9055, 3, 846, 423, 0, + 9054, 9051, 1, 0, 0, 0, 9054, 9052, 1, 0, 0, 0, 9055, 9057, 1, 0, 0, 0, + 9056, 9049, 1, 0, 0, 0, 9057, 9058, 1, 0, 0, 0, 9058, 9056, 1, 0, 0, 0, + 9058, 9059, 1, 0, 0, 0, 9059, 9060, 1, 0, 0, 0, 9060, 9061, 5, 2448, 0, + 0, 9061, 9063, 1, 0, 0, 0, 9062, 9047, 1, 0, 0, 0, 9063, 9066, 1, 0, 0, + 0, 9064, 9062, 1, 0, 0, 0, 9064, 9065, 1, 0, 0, 0, 9065, 845, 1, 0, 0, + 0, 9066, 9064, 1, 0, 0, 0, 9067, 9068, 5, 286, 0, 0, 9068, 9070, 3, 2310, + 1155, 0, 9069, 9067, 1, 0, 0, 0, 9069, 9070, 1, 0, 0, 0, 9070, 9080, 1, + 0, 0, 0, 9071, 9073, 5, 1204, 0, 0, 9072, 9071, 1, 0, 0, 0, 9072, 9073, + 1, 0, 0, 0, 9073, 9074, 1, 0, 0, 0, 9074, 9081, 5, 1228, 0, 0, 9075, 9081, + 5, 2183, 0, 0, 9076, 9077, 5, 1451, 0, 0, 9077, 9081, 5, 816, 0, 0, 9078, + 9081, 3, 1714, 857, 0, 9079, 9081, 3, 1710, 855, 0, 9080, 9072, 1, 0, 0, + 0, 9080, 9075, 1, 0, 0, 0, 9080, 9076, 1, 0, 0, 0, 9080, 9078, 1, 0, 0, + 0, 9080, 9079, 1, 0, 0, 0, 9081, 9083, 1, 0, 0, 0, 9082, 9084, 3, 854, + 427, 0, 9083, 9082, 1, 0, 0, 0, 9083, 9084, 1, 0, 0, 0, 9084, 847, 1, 0, + 0, 0, 9085, 9086, 5, 1628, 0, 0, 9086, 9087, 5, 785, 0, 0, 9087, 9099, + 3, 2342, 1171, 0, 9088, 9089, 5, 2308, 0, 0, 9089, 9099, 5, 1601, 0, 0, + 9090, 9091, 5, 286, 0, 0, 9091, 9093, 3, 2310, 1155, 0, 9092, 9090, 1, + 0, 0, 0, 9092, 9093, 1, 0, 0, 0, 9093, 9094, 1, 0, 0, 0, 9094, 9096, 3, + 1714, 857, 0, 9095, 9097, 3, 854, 427, 0, 9096, 9095, 1, 0, 0, 0, 9096, + 9097, 1, 0, 0, 0, 9097, 9099, 1, 0, 0, 0, 9098, 9085, 1, 0, 0, 0, 9098, + 9088, 1, 0, 0, 0, 9098, 9092, 1, 0, 0, 0, 9099, 849, 1, 0, 0, 0, 9100, + 9101, 5, 1628, 0, 0, 9101, 9102, 5, 620, 0, 0, 9102, 9103, 5, 2447, 0, + 0, 9103, 9104, 3, 2410, 1205, 0, 9104, 9105, 5, 2448, 0, 0, 9105, 9106, + 5, 785, 0, 0, 9106, 9107, 3, 2342, 1171, 0, 9107, 9136, 1, 0, 0, 0, 9108, + 9109, 5, 1530, 0, 0, 9109, 9110, 5, 2447, 0, 0, 9110, 9111, 3, 2410, 1205, + 0, 9111, 9112, 5, 2448, 0, 0, 9112, 9113, 5, 2308, 0, 0, 9113, 9114, 5, + 1601, 0, 0, 9114, 9136, 1, 0, 0, 0, 9115, 9116, 5, 286, 0, 0, 9116, 9118, + 3, 2310, 1155, 0, 9117, 9115, 1, 0, 0, 0, 9117, 9118, 1, 0, 0, 0, 9118, + 9119, 1, 0, 0, 0, 9119, 9120, 5, 618, 0, 0, 9120, 9121, 5, 816, 0, 0, 9121, + 9126, 5, 2447, 0, 0, 9122, 9124, 5, 2453, 0, 0, 9123, 9122, 1, 0, 0, 0, + 9123, 9124, 1, 0, 0, 0, 9124, 9125, 1, 0, 0, 0, 9125, 9127, 3, 2410, 1205, + 0, 9126, 9123, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, 9126, 1, 0, 0, + 0, 9128, 9129, 1, 0, 0, 0, 9129, 9130, 1, 0, 0, 0, 9130, 9131, 5, 2448, + 0, 0, 9131, 9133, 3, 1714, 857, 0, 9132, 9134, 3, 854, 427, 0, 9133, 9132, + 1, 0, 0, 0, 9133, 9134, 1, 0, 0, 0, 9134, 9136, 1, 0, 0, 0, 9135, 9100, + 1, 0, 0, 0, 9135, 9108, 1, 0, 0, 0, 9135, 9117, 1, 0, 0, 0, 9136, 851, + 1, 0, 0, 0, 9137, 9138, 7, 95, 0, 0, 9138, 9140, 3, 2310, 1155, 0, 9139, + 9137, 1, 0, 0, 0, 9139, 9140, 1, 0, 0, 0, 9140, 9172, 1, 0, 0, 0, 9141, + 9142, 5, 2183, 0, 0, 9142, 9143, 5, 2447, 0, 0, 9143, 9148, 3, 2340, 1170, + 0, 9144, 9145, 5, 2453, 0, 0, 9145, 9147, 3, 2340, 1170, 0, 9146, 9144, + 1, 0, 0, 0, 9147, 9150, 1, 0, 0, 0, 9148, 9146, 1, 0, 0, 0, 9148, 9149, + 1, 0, 0, 0, 9149, 9151, 1, 0, 0, 0, 9150, 9148, 1, 0, 0, 0, 9151, 9152, + 5, 2448, 0, 0, 9152, 9173, 1, 0, 0, 0, 9153, 9154, 5, 1451, 0, 0, 9154, + 9155, 5, 816, 0, 0, 9155, 9156, 5, 2447, 0, 0, 9156, 9161, 3, 2340, 1170, + 0, 9157, 9158, 5, 2453, 0, 0, 9158, 9160, 3, 2340, 1170, 0, 9159, 9157, + 1, 0, 0, 0, 9160, 9163, 1, 0, 0, 0, 9161, 9159, 1, 0, 0, 0, 9161, 9162, + 1, 0, 0, 0, 9162, 9164, 1, 0, 0, 0, 9163, 9161, 1, 0, 0, 0, 9164, 9165, + 5, 2448, 0, 0, 9165, 9173, 1, 0, 0, 0, 9166, 9173, 3, 1712, 856, 0, 9167, + 9168, 5, 200, 0, 0, 9168, 9169, 5, 2447, 0, 0, 9169, 9170, 3, 2074, 1037, + 0, 9170, 9171, 5, 2448, 0, 0, 9171, 9173, 1, 0, 0, 0, 9172, 9141, 1, 0, + 0, 0, 9172, 9153, 1, 0, 0, 0, 9172, 9166, 1, 0, 0, 0, 9172, 9167, 1, 0, + 0, 0, 9173, 9175, 1, 0, 0, 0, 9174, 9176, 3, 854, 427, 0, 9175, 9174, 1, + 0, 0, 0, 9175, 9176, 1, 0, 0, 0, 9176, 9178, 1, 0, 0, 0, 9177, 9179, 3, + 928, 464, 0, 9178, 9177, 1, 0, 0, 0, 9178, 9179, 1, 0, 0, 0, 9179, 853, + 1, 0, 0, 0, 9180, 9182, 5, 1204, 0, 0, 9181, 9180, 1, 0, 0, 0, 9181, 9182, + 1, 0, 0, 0, 9182, 9183, 1, 0, 0, 0, 9183, 9191, 5, 394, 0, 0, 9184, 9185, + 5, 742, 0, 0, 9185, 9191, 7, 69, 0, 0, 9186, 9191, 7, 51, 0, 0, 9187, 9191, + 7, 17, 0, 0, 9188, 9191, 7, 96, 0, 0, 9189, 9191, 3, 1586, 793, 0, 9190, + 9181, 1, 0, 0, 0, 9190, 9184, 1, 0, 0, 0, 9190, 9186, 1, 0, 0, 0, 9190, + 9187, 1, 0, 0, 0, 9190, 9188, 1, 0, 0, 0, 9190, 9189, 1, 0, 0, 0, 9191, + 9192, 1, 0, 0, 0, 9192, 9190, 1, 0, 0, 0, 9192, 9193, 1, 0, 0, 0, 9193, + 855, 1, 0, 0, 0, 9194, 9195, 5, 1246, 0, 0, 9195, 9197, 5, 2351, 0, 0, + 9196, 9198, 3, 858, 429, 0, 9197, 9196, 1, 0, 0, 0, 9197, 9198, 1, 0, 0, + 0, 9198, 9199, 1, 0, 0, 0, 9199, 9200, 5, 2308, 0, 0, 9200, 9201, 5, 1238, + 0, 0, 9201, 9214, 7, 94, 0, 0, 9202, 9215, 5, 389, 0, 0, 9203, 9204, 5, + 2447, 0, 0, 9204, 9209, 3, 2078, 1039, 0, 9205, 9206, 5, 2453, 0, 0, 9206, + 9208, 3, 2078, 1039, 0, 9207, 9205, 1, 0, 0, 0, 9208, 9211, 1, 0, 0, 0, + 9209, 9207, 1, 0, 0, 0, 9209, 9210, 1, 0, 0, 0, 9210, 9212, 1, 0, 0, 0, + 9211, 9209, 1, 0, 0, 0, 9212, 9213, 5, 2448, 0, 0, 9213, 9215, 1, 0, 0, + 0, 9214, 9202, 1, 0, 0, 0, 9214, 9203, 1, 0, 0, 0, 9215, 857, 1, 0, 0, + 0, 9216, 9217, 5, 2345, 0, 0, 9217, 9219, 3, 860, 430, 0, 9218, 9216, 1, + 0, 0, 0, 9218, 9219, 1, 0, 0, 0, 9219, 9220, 1, 0, 0, 0, 9220, 9226, 5, + 486, 0, 0, 9221, 9227, 3, 862, 431, 0, 9222, 9223, 3, 860, 430, 0, 9223, + 9224, 5, 2458, 0, 0, 9224, 9225, 3, 862, 431, 0, 9225, 9227, 1, 0, 0, 0, + 9226, 9221, 1, 0, 0, 0, 9226, 9222, 1, 0, 0, 0, 9227, 9233, 1, 0, 0, 0, + 9228, 9229, 5, 1763, 0, 0, 9229, 9230, 5, 38, 0, 0, 9230, 9231, 5, 2266, + 0, 0, 9231, 9232, 5, 69, 0, 0, 9232, 9234, 7, 97, 0, 0, 9233, 9228, 1, + 0, 0, 0, 9233, 9234, 1, 0, 0, 0, 9234, 9238, 1, 0, 0, 0, 9235, 9236, 3, + 1310, 655, 0, 9236, 9237, 5, 1138, 0, 0, 9237, 9239, 1, 0, 0, 0, 9238, + 9235, 1, 0, 0, 0, 9238, 9239, 1, 0, 0, 0, 9239, 9243, 1, 0, 0, 0, 9240, + 9241, 3, 1310, 655, 0, 9241, 9242, 5, 56, 0, 0, 9242, 9244, 1, 0, 0, 0, + 9243, 9240, 1, 0, 0, 0, 9243, 9244, 1, 0, 0, 0, 9244, 859, 1, 0, 0, 0, + 9245, 9246, 5, 2444, 0, 0, 9246, 861, 1, 0, 0, 0, 9247, 9248, 5, 2444, + 0, 0, 9248, 863, 1, 0, 0, 0, 9249, 9250, 5, 42, 0, 0, 9250, 9251, 5, 2080, + 0, 0, 9251, 9284, 3, 1656, 828, 0, 9252, 9254, 5, 389, 0, 0, 9253, 9255, + 3, 1178, 589, 0, 9254, 9253, 1, 0, 0, 0, 9254, 9255, 1, 0, 0, 0, 9255, + 9257, 1, 0, 0, 0, 9256, 9258, 3, 1196, 598, 0, 9257, 9256, 1, 0, 0, 0, + 9257, 9258, 1, 0, 0, 0, 9258, 9285, 1, 0, 0, 0, 9259, 9260, 5, 954, 0, + 0, 9260, 9261, 5, 558, 0, 0, 9261, 9285, 3, 1176, 588, 0, 9262, 9263, 5, + 1567, 0, 0, 9263, 9285, 3, 1176, 588, 0, 9264, 9285, 5, 228, 0, 0, 9265, + 9266, 5, 1684, 0, 0, 9266, 9269, 5, 1714, 0, 0, 9267, 9268, 5, 814, 0, + 0, 9268, 9270, 3, 1176, 588, 0, 9269, 9267, 1, 0, 0, 0, 9269, 9270, 1, + 0, 0, 0, 9270, 9285, 1, 0, 0, 0, 9271, 9272, 5, 1559, 0, 0, 9272, 9273, + 5, 2141, 0, 0, 9273, 9285, 3, 878, 439, 0, 9274, 9275, 3, 1380, 690, 0, + 9275, 9276, 5, 102, 0, 0, 9276, 9285, 1, 0, 0, 0, 9277, 9285, 3, 866, 433, + 0, 9278, 9285, 3, 868, 434, 0, 9279, 9285, 3, 870, 435, 0, 9280, 9285, + 3, 874, 437, 0, 9281, 9285, 3, 922, 461, 0, 9282, 9285, 3, 876, 438, 0, + 9283, 9285, 3, 896, 448, 0, 9284, 9252, 1, 0, 0, 0, 9284, 9259, 1, 0, 0, + 0, 9284, 9262, 1, 0, 0, 0, 9284, 9264, 1, 0, 0, 0, 9284, 9265, 1, 0, 0, + 0, 9284, 9271, 1, 0, 0, 0, 9284, 9274, 1, 0, 0, 0, 9284, 9277, 1, 0, 0, + 0, 9284, 9278, 1, 0, 0, 0, 9284, 9279, 1, 0, 0, 0, 9284, 9280, 1, 0, 0, + 0, 9284, 9281, 1, 0, 0, 0, 9284, 9282, 1, 0, 0, 0, 9284, 9283, 1, 0, 0, + 0, 9285, 865, 1, 0, 0, 0, 9286, 9289, 5, 21, 0, 0, 9287, 9290, 3, 914, + 457, 0, 9288, 9290, 3, 916, 458, 0, 9289, 9287, 1, 0, 0, 0, 9289, 9288, + 1, 0, 0, 0, 9290, 9333, 1, 0, 0, 0, 9291, 9292, 5, 469, 0, 0, 9292, 9295, + 7, 98, 0, 0, 9293, 9296, 3, 1458, 729, 0, 9294, 9296, 5, 2441, 0, 0, 9295, + 9293, 1, 0, 0, 0, 9295, 9294, 1, 0, 0, 0, 9296, 9299, 1, 0, 0, 0, 9297, + 9298, 5, 814, 0, 0, 9298, 9300, 3, 1176, 588, 0, 9299, 9297, 1, 0, 0, 0, + 9299, 9300, 1, 0, 0, 0, 9300, 9333, 1, 0, 0, 0, 9301, 9302, 5, 1684, 0, + 0, 9302, 9305, 5, 2089, 0, 0, 9303, 9306, 3, 1458, 729, 0, 9304, 9306, + 5, 2441, 0, 0, 9305, 9303, 1, 0, 0, 0, 9305, 9304, 1, 0, 0, 0, 9306, 9309, + 1, 0, 0, 0, 9307, 9308, 5, 814, 0, 0, 9308, 9310, 3, 1176, 588, 0, 9309, + 9307, 1, 0, 0, 0, 9309, 9310, 1, 0, 0, 0, 9310, 9333, 1, 0, 0, 0, 9311, + 9312, 5, 1559, 0, 0, 9312, 9313, 5, 352, 0, 0, 9313, 9318, 3, 1458, 729, + 0, 9314, 9315, 5, 2453, 0, 0, 9315, 9317, 3, 1458, 729, 0, 9316, 9314, + 1, 0, 0, 0, 9317, 9320, 1, 0, 0, 0, 9318, 9316, 1, 0, 0, 0, 9318, 9319, + 1, 0, 0, 0, 9319, 9321, 1, 0, 0, 0, 9320, 9318, 1, 0, 0, 0, 9321, 9322, + 5, 2141, 0, 0, 9322, 9327, 3, 1458, 729, 0, 9323, 9324, 5, 2453, 0, 0, + 9324, 9326, 3, 1458, 729, 0, 9325, 9323, 1, 0, 0, 0, 9326, 9329, 1, 0, + 0, 0, 9327, 9325, 1, 0, 0, 0, 9327, 9328, 1, 0, 0, 0, 9328, 9333, 1, 0, + 0, 0, 9329, 9327, 1, 0, 0, 0, 9330, 9331, 7, 98, 0, 0, 9331, 9333, 3, 682, + 341, 0, 9332, 9286, 1, 0, 0, 0, 9332, 9291, 1, 0, 0, 0, 9332, 9301, 1, + 0, 0, 0, 9332, 9311, 1, 0, 0, 0, 9332, 9330, 1, 0, 0, 0, 9333, 867, 1, + 0, 0, 0, 9334, 9341, 3, 886, 443, 0, 9335, 9337, 5, 1137, 0, 0, 9336, 9335, + 1, 0, 0, 0, 9336, 9337, 1, 0, 0, 0, 9337, 9338, 1, 0, 0, 0, 9338, 9339, + 5, 616, 0, 0, 9339, 9341, 5, 884, 0, 0, 9340, 9334, 1, 0, 0, 0, 9340, 9336, + 1, 0, 0, 0, 9341, 869, 1, 0, 0, 0, 9342, 9343, 5, 2080, 0, 0, 9343, 9346, + 5, 649, 0, 0, 9344, 9347, 3, 872, 436, 0, 9345, 9347, 5, 2443, 0, 0, 9346, + 9344, 1, 0, 0, 0, 9346, 9345, 1, 0, 0, 0, 9347, 871, 1, 0, 0, 0, 9348, + 9349, 3, 2410, 1205, 0, 9349, 873, 1, 0, 0, 0, 9350, 9360, 5, 1256, 0, + 0, 9351, 9353, 5, 1243, 0, 0, 9352, 9354, 7, 99, 0, 0, 9353, 9352, 1, 0, + 0, 0, 9353, 9354, 1, 0, 0, 0, 9354, 9360, 1, 0, 0, 0, 9355, 9356, 5, 1505, + 0, 0, 9356, 9360, 7, 11, 0, 0, 9357, 9360, 5, 1387, 0, 0, 9358, 9360, 5, + 2092, 0, 0, 9359, 9350, 1, 0, 0, 0, 9359, 9351, 1, 0, 0, 0, 9359, 9355, + 1, 0, 0, 0, 9359, 9357, 1, 0, 0, 0, 9359, 9358, 1, 0, 0, 0, 9360, 875, + 1, 0, 0, 0, 9361, 9362, 5, 605, 0, 0, 9362, 9363, 7, 100, 0, 0, 9363, 877, + 1, 0, 0, 0, 9364, 9365, 3, 1656, 828, 0, 9365, 879, 1, 0, 0, 0, 9366, 9368, + 5, 321, 0, 0, 9367, 9369, 7, 101, 0, 0, 9368, 9367, 1, 0, 0, 0, 9368, 9369, + 1, 0, 0, 0, 9369, 9373, 1, 0, 0, 0, 9370, 9374, 3, 882, 441, 0, 9371, 9374, + 3, 892, 446, 0, 9372, 9374, 3, 894, 447, 0, 9373, 9370, 1, 0, 0, 0, 9373, + 9371, 1, 0, 0, 0, 9373, 9372, 1, 0, 0, 0, 9374, 881, 1, 0, 0, 0, 9375, + 9376, 5, 2080, 0, 0, 9376, 9380, 3, 2404, 1202, 0, 9377, 9378, 5, 691, + 0, 0, 9378, 9379, 5, 1204, 0, 0, 9379, 9381, 5, 545, 0, 0, 9380, 9377, + 1, 0, 0, 0, 9380, 9381, 1, 0, 0, 0, 9381, 9383, 1, 0, 0, 0, 9382, 9384, + 3, 914, 457, 0, 9383, 9382, 1, 0, 0, 0, 9383, 9384, 1, 0, 0, 0, 9384, 9402, + 1, 0, 0, 0, 9385, 9386, 5, 954, 0, 0, 9386, 9387, 5, 558, 0, 0, 9387, 9401, + 3, 1176, 588, 0, 9388, 9389, 5, 146, 0, 0, 9389, 9401, 3, 1176, 588, 0, + 9390, 9401, 3, 886, 443, 0, 9391, 9392, 5, 616, 0, 0, 9392, 9401, 5, 884, + 0, 0, 9393, 9401, 7, 78, 0, 0, 9394, 9395, 5, 506, 0, 0, 9395, 9401, 3, + 884, 442, 0, 9396, 9401, 5, 389, 0, 0, 9397, 9401, 3, 888, 444, 0, 9398, + 9401, 3, 890, 445, 0, 9399, 9401, 3, 876, 438, 0, 9400, 9385, 1, 0, 0, + 0, 9400, 9388, 1, 0, 0, 0, 9400, 9390, 1, 0, 0, 0, 9400, 9391, 1, 0, 0, + 0, 9400, 9393, 1, 0, 0, 0, 9400, 9394, 1, 0, 0, 0, 9400, 9396, 1, 0, 0, + 0, 9400, 9397, 1, 0, 0, 0, 9400, 9398, 1, 0, 0, 0, 9400, 9399, 1, 0, 0, + 0, 9401, 9404, 1, 0, 0, 0, 9402, 9400, 1, 0, 0, 0, 9402, 9403, 1, 0, 0, + 0, 9403, 883, 1, 0, 0, 0, 9404, 9402, 1, 0, 0, 0, 9405, 9406, 5, 2246, + 0, 0, 9406, 9407, 5, 2443, 0, 0, 9407, 885, 1, 0, 0, 0, 9408, 9409, 7, + 102, 0, 0, 9409, 887, 1, 0, 0, 0, 9410, 9411, 5, 558, 0, 0, 9411, 9412, + 5, 906, 0, 0, 9412, 9419, 5, 873, 0, 0, 9413, 9420, 5, 90, 0, 0, 9414, + 9417, 5, 2180, 0, 0, 9415, 9416, 5, 1699, 0, 0, 9416, 9418, 3, 1176, 588, + 0, 9417, 9415, 1, 0, 0, 0, 9417, 9418, 1, 0, 0, 0, 9418, 9420, 1, 0, 0, + 0, 9419, 9413, 1, 0, 0, 0, 9419, 9414, 1, 0, 0, 0, 9419, 9420, 1, 0, 0, + 0, 9420, 889, 1, 0, 0, 0, 9421, 9422, 5, 1645, 0, 0, 9422, 9423, 5, 1714, + 0, 0, 9423, 9424, 5, 906, 0, 0, 9424, 9425, 7, 103, 0, 0, 9425, 891, 1, + 0, 0, 0, 9426, 9427, 5, 2092, 0, 0, 9427, 9428, 5, 2080, 0, 0, 9428, 9432, + 3, 2404, 1202, 0, 9429, 9430, 5, 691, 0, 0, 9430, 9431, 5, 1204, 0, 0, + 9431, 9433, 5, 545, 0, 0, 9432, 9429, 1, 0, 0, 0, 9432, 9433, 1, 0, 0, + 0, 9433, 9435, 1, 0, 0, 0, 9434, 9436, 3, 916, 458, 0, 9435, 9434, 1, 0, + 0, 0, 9435, 9436, 1, 0, 0, 0, 9436, 9438, 1, 0, 0, 0, 9437, 9439, 3, 870, + 435, 0, 9438, 9437, 1, 0, 0, 0, 9438, 9439, 1, 0, 0, 0, 9439, 9441, 1, + 0, 0, 0, 9440, 9442, 3, 888, 444, 0, 9441, 9440, 1, 0, 0, 0, 9441, 9442, + 1, 0, 0, 0, 9442, 893, 1, 0, 0, 0, 9443, 9444, 5, 2178, 0, 0, 9444, 9445, + 5, 2080, 0, 0, 9445, 9449, 3, 2404, 1202, 0, 9446, 9447, 5, 691, 0, 0, + 9447, 9448, 5, 1204, 0, 0, 9448, 9450, 5, 545, 0, 0, 9449, 9446, 1, 0, + 0, 0, 9449, 9450, 1, 0, 0, 0, 9450, 9452, 1, 0, 0, 0, 9451, 9453, 3, 914, + 457, 0, 9452, 9451, 1, 0, 0, 0, 9452, 9453, 1, 0, 0, 0, 9453, 9455, 1, + 0, 0, 0, 9454, 9456, 3, 888, 444, 0, 9455, 9454, 1, 0, 0, 0, 9455, 9456, + 1, 0, 0, 0, 9456, 9458, 1, 0, 0, 0, 9457, 9459, 3, 896, 448, 0, 9458, 9457, + 1, 0, 0, 0, 9458, 9459, 1, 0, 0, 0, 9459, 895, 1, 0, 0, 0, 9460, 9461, + 5, 1583, 0, 0, 9461, 9462, 7, 104, 0, 0, 9462, 897, 1, 0, 0, 0, 9463, 9464, + 5, 321, 0, 0, 9464, 9465, 5, 2080, 0, 0, 9465, 9466, 5, 1671, 0, 0, 9466, + 9470, 3, 2404, 1202, 0, 9467, 9468, 5, 738, 0, 0, 9468, 9469, 5, 1677, + 0, 0, 9469, 9471, 3, 2404, 1202, 0, 9470, 9467, 1, 0, 0, 0, 9470, 9471, + 1, 0, 0, 0, 9471, 9493, 1, 0, 0, 0, 9472, 9473, 5, 2246, 0, 0, 9473, 9474, + 5, 2090, 0, 0, 9474, 9484, 5, 2447, 0, 0, 9475, 9476, 5, 352, 0, 0, 9476, + 9481, 3, 436, 218, 0, 9477, 9478, 5, 2453, 0, 0, 9478, 9480, 3, 436, 218, + 0, 9479, 9477, 1, 0, 0, 0, 9480, 9483, 1, 0, 0, 0, 9481, 9479, 1, 0, 0, + 0, 9481, 9482, 1, 0, 0, 0, 9482, 9485, 1, 0, 0, 0, 9483, 9481, 1, 0, 0, + 0, 9484, 9475, 1, 0, 0, 0, 9484, 9485, 1, 0, 0, 0, 9485, 9487, 1, 0, 0, + 0, 9486, 9488, 3, 900, 450, 0, 9487, 9486, 1, 0, 0, 0, 9488, 9489, 1, 0, + 0, 0, 9489, 9487, 1, 0, 0, 0, 9489, 9490, 1, 0, 0, 0, 9490, 9491, 1, 0, + 0, 0, 9491, 9492, 5, 2448, 0, 0, 9492, 9494, 1, 0, 0, 0, 9493, 9472, 1, + 0, 0, 0, 9493, 9494, 1, 0, 0, 0, 9494, 899, 1, 0, 0, 0, 9495, 9496, 5, + 954, 0, 0, 9496, 9497, 5, 558, 0, 0, 9497, 9515, 3, 1176, 588, 0, 9498, + 9499, 5, 146, 0, 0, 9499, 9501, 3, 2396, 1198, 0, 9500, 9502, 5, 812, 0, + 0, 9501, 9500, 1, 0, 0, 0, 9501, 9502, 1, 0, 0, 0, 9502, 9515, 1, 0, 0, + 0, 9503, 9515, 3, 886, 443, 0, 9504, 9505, 5, 616, 0, 0, 9505, 9515, 5, + 884, 0, 0, 9506, 9515, 3, 902, 451, 0, 9507, 9515, 3, 904, 452, 0, 9508, + 9515, 5, 1256, 0, 0, 9509, 9515, 5, 1243, 0, 0, 9510, 9515, 3, 888, 444, + 0, 9511, 9515, 3, 890, 445, 0, 9512, 9515, 3, 876, 438, 0, 9513, 9515, + 3, 1464, 732, 0, 9514, 9495, 1, 0, 0, 0, 9514, 9498, 1, 0, 0, 0, 9514, + 9503, 1, 0, 0, 0, 9514, 9504, 1, 0, 0, 0, 9514, 9506, 1, 0, 0, 0, 9514, + 9507, 1, 0, 0, 0, 9514, 9508, 1, 0, 0, 0, 9514, 9509, 1, 0, 0, 0, 9514, + 9510, 1, 0, 0, 0, 9514, 9511, 1, 0, 0, 0, 9514, 9512, 1, 0, 0, 0, 9514, + 9513, 1, 0, 0, 0, 9515, 901, 1, 0, 0, 0, 9516, 9522, 5, 506, 0, 0, 9517, + 9519, 3, 884, 442, 0, 9518, 9517, 1, 0, 0, 0, 9518, 9519, 1, 0, 0, 0, 9519, + 9520, 1, 0, 0, 0, 9520, 9523, 5, 505, 0, 0, 9521, 9523, 5, 387, 0, 0, 9522, + 9518, 1, 0, 0, 0, 9522, 9521, 1, 0, 0, 0, 9523, 903, 1, 0, 0, 0, 9524, + 9526, 5, 389, 0, 0, 9525, 9527, 3, 906, 453, 0, 9526, 9525, 1, 0, 0, 0, + 9526, 9527, 1, 0, 0, 0, 9527, 9529, 1, 0, 0, 0, 9528, 9530, 3, 910, 455, + 0, 9529, 9528, 1, 0, 0, 0, 9529, 9530, 1, 0, 0, 0, 9530, 9532, 1, 0, 0, + 0, 9531, 9533, 3, 912, 456, 0, 9532, 9531, 1, 0, 0, 0, 9532, 9533, 1, 0, + 0, 0, 9533, 9535, 1, 0, 0, 0, 9534, 9536, 3, 1204, 602, 0, 9535, 9534, + 1, 0, 0, 0, 9535, 9536, 1, 0, 0, 0, 9536, 9538, 1, 0, 0, 0, 9537, 9539, + 3, 1196, 598, 0, 9538, 9537, 1, 0, 0, 0, 9538, 9539, 1, 0, 0, 0, 9539, + 905, 1, 0, 0, 0, 9540, 9551, 5, 2083, 0, 0, 9541, 9542, 5, 258, 0, 0, 9542, + 9548, 5, 620, 0, 0, 9543, 9549, 5, 1253, 0, 0, 9544, 9545, 5, 1484, 0, + 0, 9545, 9549, 3, 908, 454, 0, 9546, 9547, 5, 64, 0, 0, 9547, 9549, 3, + 908, 454, 0, 9548, 9543, 1, 0, 0, 0, 9548, 9544, 1, 0, 0, 0, 9548, 9546, + 1, 0, 0, 0, 9549, 9552, 1, 0, 0, 0, 9550, 9552, 5, 1074, 0, 0, 9551, 9541, + 1, 0, 0, 0, 9551, 9550, 1, 0, 0, 0, 9552, 907, 1, 0, 0, 0, 9553, 9554, + 7, 105, 0, 0, 9554, 909, 1, 0, 0, 0, 9555, 9560, 5, 717, 0, 0, 9556, 9557, + 5, 258, 0, 0, 9557, 9558, 5, 29, 0, 0, 9558, 9561, 3, 908, 454, 0, 9559, + 9561, 5, 1074, 0, 0, 9560, 9556, 1, 0, 0, 0, 9560, 9559, 1, 0, 0, 0, 9561, + 911, 1, 0, 0, 0, 9562, 9564, 5, 746, 0, 0, 9563, 9565, 3, 1182, 591, 0, + 9564, 9563, 1, 0, 0, 0, 9564, 9565, 1, 0, 0, 0, 9565, 9590, 1, 0, 0, 0, + 9566, 9588, 5, 2096, 0, 0, 9567, 9572, 3, 2340, 1170, 0, 9568, 9569, 5, + 2453, 0, 0, 9569, 9571, 3, 2340, 1170, 0, 9570, 9568, 1, 0, 0, 0, 9571, + 9574, 1, 0, 0, 0, 9572, 9570, 1, 0, 0, 0, 9572, 9573, 1, 0, 0, 0, 9573, + 9589, 1, 0, 0, 0, 9574, 9572, 1, 0, 0, 0, 9575, 9576, 3, 2340, 1170, 0, + 9576, 9577, 5, 2246, 0, 0, 9577, 9585, 3, 718, 359, 0, 9578, 9579, 5, 2453, + 0, 0, 9579, 9580, 3, 2340, 1170, 0, 9580, 9581, 5, 2246, 0, 0, 9581, 9582, + 3, 718, 359, 0, 9582, 9584, 1, 0, 0, 0, 9583, 9578, 1, 0, 0, 0, 9584, 9587, + 1, 0, 0, 0, 9585, 9583, 1, 0, 0, 0, 9585, 9586, 1, 0, 0, 0, 9586, 9589, + 1, 0, 0, 0, 9587, 9585, 1, 0, 0, 0, 9588, 9567, 1, 0, 0, 0, 9588, 9575, + 1, 0, 0, 0, 9589, 9591, 1, 0, 0, 0, 9590, 9566, 1, 0, 0, 0, 9590, 9591, + 1, 0, 0, 0, 9591, 9595, 1, 0, 0, 0, 9592, 9593, 5, 1137, 0, 0, 9593, 9595, + 5, 746, 0, 0, 9594, 9562, 1, 0, 0, 0, 9594, 9592, 1, 0, 0, 0, 9595, 913, + 1, 0, 0, 0, 9596, 9598, 5, 352, 0, 0, 9597, 9599, 5, 2453, 0, 0, 9598, + 9597, 1, 0, 0, 0, 9598, 9599, 1, 0, 0, 0, 9599, 9600, 1, 0, 0, 0, 9600, + 9601, 3, 918, 459, 0, 9601, 915, 1, 0, 0, 0, 9602, 9604, 5, 2089, 0, 0, + 9603, 9605, 5, 2453, 0, 0, 9604, 9603, 1, 0, 0, 0, 9604, 9605, 1, 0, 0, + 0, 9605, 9606, 1, 0, 0, 0, 9606, 9607, 3, 918, 459, 0, 9607, 917, 1, 0, + 0, 0, 9608, 9610, 5, 2443, 0, 0, 9609, 9608, 1, 0, 0, 0, 9609, 9610, 1, + 0, 0, 0, 9610, 9613, 1, 0, 0, 0, 9611, 9612, 5, 1699, 0, 0, 9612, 9614, + 3, 1176, 588, 0, 9613, 9611, 1, 0, 0, 0, 9613, 9614, 1, 0, 0, 0, 9614, + 9616, 1, 0, 0, 0, 9615, 9617, 5, 1587, 0, 0, 9616, 9615, 1, 0, 0, 0, 9616, + 9617, 1, 0, 0, 0, 9617, 9619, 1, 0, 0, 0, 9618, 9620, 3, 922, 461, 0, 9619, + 9618, 1, 0, 0, 0, 9619, 9620, 1, 0, 0, 0, 9620, 919, 1, 0, 0, 0, 9621, + 9634, 3, 1458, 729, 0, 9622, 9623, 5, 2447, 0, 0, 9623, 9628, 3, 1458, + 729, 0, 9624, 9625, 5, 2453, 0, 0, 9625, 9627, 3, 1458, 729, 0, 9626, 9624, + 1, 0, 0, 0, 9627, 9630, 1, 0, 0, 0, 9628, 9626, 1, 0, 0, 0, 9628, 9629, + 1, 0, 0, 0, 9629, 9631, 1, 0, 0, 0, 9630, 9628, 1, 0, 0, 0, 9631, 9632, + 5, 2448, 0, 0, 9632, 9634, 1, 0, 0, 0, 9633, 9621, 1, 0, 0, 0, 9633, 9622, + 1, 0, 0, 0, 9634, 9637, 1, 0, 0, 0, 9635, 9636, 5, 1699, 0, 0, 9636, 9638, + 3, 1176, 588, 0, 9637, 9635, 1, 0, 0, 0, 9637, 9638, 1, 0, 0, 0, 9638, + 9641, 1, 0, 0, 0, 9639, 9640, 5, 146, 0, 0, 9640, 9642, 3, 1176, 588, 0, + 9641, 9639, 1, 0, 0, 0, 9641, 9642, 1, 0, 0, 0, 9642, 9644, 1, 0, 0, 0, + 9643, 9645, 5, 1587, 0, 0, 9644, 9643, 1, 0, 0, 0, 9644, 9645, 1, 0, 0, + 0, 9645, 921, 1, 0, 0, 0, 9646, 9656, 5, 93, 0, 0, 9647, 9657, 5, 1244, + 0, 0, 9648, 9651, 5, 1259, 0, 0, 9649, 9650, 5, 1025, 0, 0, 9650, 9652, + 3, 1176, 588, 0, 9651, 9649, 1, 0, 0, 0, 9651, 9652, 1, 0, 0, 0, 9652, + 9654, 1, 0, 0, 0, 9653, 9655, 3, 924, 462, 0, 9654, 9653, 1, 0, 0, 0, 9654, + 9655, 1, 0, 0, 0, 9655, 9657, 1, 0, 0, 0, 9656, 9647, 1, 0, 0, 0, 9656, + 9648, 1, 0, 0, 0, 9657, 923, 1, 0, 0, 0, 9658, 9661, 5, 930, 0, 0, 9659, + 9662, 5, 2185, 0, 0, 9660, 9662, 3, 1176, 588, 0, 9661, 9659, 1, 0, 0, + 0, 9661, 9660, 1, 0, 0, 0, 9662, 925, 1, 0, 0, 0, 9663, 9664, 5, 158, 0, + 0, 9664, 9665, 7, 69, 0, 0, 9665, 927, 1, 0, 0, 0, 9666, 9682, 5, 1148, + 0, 0, 9667, 9679, 5, 1333, 0, 0, 9668, 9670, 5, 2441, 0, 0, 9669, 9671, + 3, 930, 465, 0, 9670, 9669, 1, 0, 0, 0, 9670, 9671, 1, 0, 0, 0, 9671, 9680, + 1, 0, 0, 0, 9672, 9673, 5, 2447, 0, 0, 9673, 9674, 5, 399, 0, 0, 9674, + 9676, 5, 2441, 0, 0, 9675, 9677, 3, 930, 465, 0, 9676, 9675, 1, 0, 0, 0, + 9676, 9677, 1, 0, 0, 0, 9677, 9678, 1, 0, 0, 0, 9678, 9680, 5, 2448, 0, + 0, 9679, 9668, 1, 0, 0, 0, 9679, 9672, 1, 0, 0, 0, 9679, 9680, 1, 0, 0, + 0, 9680, 9682, 1, 0, 0, 0, 9681, 9666, 1, 0, 0, 0, 9681, 9667, 1, 0, 0, + 0, 9682, 929, 1, 0, 0, 0, 9683, 9684, 5, 760, 0, 0, 9684, 9685, 7, 106, + 0, 0, 9685, 931, 1, 0, 0, 0, 9686, 9687, 5, 42, 0, 0, 9687, 9688, 5, 919, + 0, 0, 9688, 9689, 5, 2286, 0, 0, 9689, 9715, 3, 2342, 1171, 0, 9690, 9716, + 3, 1194, 597, 0, 9691, 9716, 3, 940, 470, 0, 9692, 9716, 3, 1178, 589, + 0, 9693, 9698, 3, 1640, 820, 0, 9694, 9695, 5, 2453, 0, 0, 9695, 9697, + 3, 1640, 820, 0, 9696, 9694, 1, 0, 0, 0, 9697, 9700, 1, 0, 0, 0, 9698, + 9696, 1, 0, 0, 0, 9698, 9699, 1, 0, 0, 0, 9699, 9716, 1, 0, 0, 0, 9700, + 9698, 1, 0, 0, 0, 9701, 9706, 3, 1642, 821, 0, 9702, 9703, 5, 2453, 0, + 0, 9703, 9705, 3, 1642, 821, 0, 9704, 9702, 1, 0, 0, 0, 9705, 9708, 1, + 0, 0, 0, 9706, 9704, 1, 0, 0, 0, 9706, 9707, 1, 0, 0, 0, 9707, 9716, 1, + 0, 0, 0, 9708, 9706, 1, 0, 0, 0, 9709, 9716, 3, 928, 464, 0, 9710, 9716, + 3, 886, 443, 0, 9711, 9716, 3, 1284, 642, 0, 9712, 9716, 3, 1286, 643, + 0, 9713, 9716, 3, 1288, 644, 0, 9714, 9716, 3, 1364, 682, 0, 9715, 9690, + 1, 0, 0, 0, 9715, 9691, 1, 0, 0, 0, 9715, 9692, 1, 0, 0, 0, 9715, 9693, + 1, 0, 0, 0, 9715, 9701, 1, 0, 0, 0, 9715, 9709, 1, 0, 0, 0, 9715, 9710, + 1, 0, 0, 0, 9715, 9711, 1, 0, 0, 0, 9715, 9712, 1, 0, 0, 0, 9715, 9713, + 1, 0, 0, 0, 9715, 9714, 1, 0, 0, 0, 9715, 9716, 1, 0, 0, 0, 9716, 9718, + 1, 0, 0, 0, 9717, 9719, 3, 1564, 782, 0, 9718, 9717, 1, 0, 0, 0, 9718, + 9719, 1, 0, 0, 0, 9719, 9723, 1, 0, 0, 0, 9720, 9721, 5, 2246, 0, 0, 9721, + 9722, 5, 717, 0, 0, 9722, 9724, 3, 1194, 597, 0, 9723, 9720, 1, 0, 0, 0, + 9723, 9724, 1, 0, 0, 0, 9724, 9726, 1, 0, 0, 0, 9725, 9727, 3, 934, 467, + 0, 9726, 9725, 1, 0, 0, 0, 9726, 9727, 1, 0, 0, 0, 9727, 9735, 1, 0, 0, + 0, 9728, 9729, 3, 1308, 654, 0, 9729, 9730, 5, 1484, 0, 0, 9730, 9731, + 5, 1591, 0, 0, 9731, 9736, 1, 0, 0, 0, 9732, 9736, 5, 249, 0, 0, 9733, + 9734, 5, 282, 0, 0, 9734, 9736, 5, 627, 0, 0, 9735, 9728, 1, 0, 0, 0, 9735, + 9732, 1, 0, 0, 0, 9735, 9733, 1, 0, 0, 0, 9735, 9736, 1, 0, 0, 0, 9736, + 933, 1, 0, 0, 0, 9737, 9738, 3, 936, 468, 0, 9738, 935, 1, 0, 0, 0, 9739, + 9766, 5, 1531, 0, 0, 9740, 9767, 5, 578, 0, 0, 9741, 9767, 5, 250, 0, 0, + 9742, 9767, 5, 616, 0, 0, 9743, 9744, 5, 1259, 0, 0, 9744, 9767, 7, 107, + 0, 0, 9745, 9746, 5, 1737, 0, 0, 9746, 9747, 5, 2308, 0, 0, 9747, 9767, + 3, 2078, 1039, 0, 9748, 9749, 5, 1025, 0, 0, 9749, 9767, 3, 2078, 1039, + 0, 9750, 9751, 5, 2308, 0, 0, 9751, 9752, 5, 1451, 0, 0, 9752, 9767, 5, + 816, 0, 0, 9753, 9755, 5, 2246, 0, 0, 9754, 9756, 5, 389, 0, 0, 9755, 9754, + 1, 0, 0, 0, 9755, 9756, 1, 0, 0, 0, 9756, 9757, 1, 0, 0, 0, 9757, 9758, + 5, 913, 0, 0, 9758, 9759, 5, 1596, 0, 0, 9759, 9761, 5, 1645, 0, 0, 9760, + 9762, 3, 938, 469, 0, 9761, 9760, 1, 0, 0, 0, 9761, 9762, 1, 0, 0, 0, 9762, + 9767, 1, 0, 0, 0, 9763, 9764, 5, 2246, 0, 0, 9764, 9765, 7, 108, 0, 0, + 9765, 9767, 5, 287, 0, 0, 9766, 9740, 1, 0, 0, 0, 9766, 9741, 1, 0, 0, + 0, 9766, 9742, 1, 0, 0, 0, 9766, 9743, 1, 0, 0, 0, 9766, 9745, 1, 0, 0, + 0, 9766, 9748, 1, 0, 0, 0, 9766, 9750, 1, 0, 0, 0, 9766, 9753, 1, 0, 0, + 0, 9766, 9763, 1, 0, 0, 0, 9767, 9768, 1, 0, 0, 0, 9768, 9766, 1, 0, 0, + 0, 9768, 9769, 1, 0, 0, 0, 9769, 937, 1, 0, 0, 0, 9770, 9771, 3, 2410, + 1205, 0, 9771, 939, 1, 0, 0, 0, 9772, 9773, 5, 980, 0, 0, 9773, 9774, 5, + 2447, 0, 0, 9774, 9778, 3, 2340, 1170, 0, 9775, 9776, 5, 505, 0, 0, 9776, + 9779, 3, 1654, 827, 0, 9777, 9779, 5, 387, 0, 0, 9778, 9775, 1, 0, 0, 0, + 9778, 9777, 1, 0, 0, 0, 9778, 9779, 1, 0, 0, 0, 9779, 9780, 1, 0, 0, 0, + 9780, 9781, 5, 2448, 0, 0, 9781, 941, 1, 0, 0, 0, 9782, 9783, 5, 42, 0, + 0, 9783, 9784, 5, 919, 0, 0, 9784, 9785, 5, 2286, 0, 0, 9785, 9787, 5, + 888, 0, 0, 9786, 9788, 5, 616, 0, 0, 9787, 9786, 1, 0, 0, 0, 9787, 9788, + 1, 0, 0, 0, 9788, 9789, 1, 0, 0, 0, 9789, 9790, 5, 1259, 0, 0, 9790, 9799, + 3, 2342, 1171, 0, 9791, 9800, 3, 1194, 597, 0, 9792, 9800, 3, 944, 472, + 0, 9793, 9800, 3, 928, 464, 0, 9794, 9800, 3, 886, 443, 0, 9795, 9800, + 3, 1284, 642, 0, 9796, 9800, 3, 1288, 644, 0, 9797, 9800, 3, 946, 473, + 0, 9798, 9800, 3, 1364, 682, 0, 9799, 9791, 1, 0, 0, 0, 9799, 9792, 1, + 0, 0, 0, 9799, 9793, 1, 0, 0, 0, 9799, 9794, 1, 0, 0, 0, 9799, 9795, 1, + 0, 0, 0, 9799, 9796, 1, 0, 0, 0, 9799, 9797, 1, 0, 0, 0, 9799, 9798, 1, + 0, 0, 0, 9799, 9800, 1, 0, 0, 0, 9800, 9802, 1, 0, 0, 0, 9801, 9803, 3, + 948, 474, 0, 9802, 9801, 1, 0, 0, 0, 9802, 9803, 1, 0, 0, 0, 9803, 9805, + 1, 0, 0, 0, 9804, 9806, 3, 954, 477, 0, 9805, 9804, 1, 0, 0, 0, 9805, 9806, + 1, 0, 0, 0, 9806, 943, 1, 0, 0, 0, 9807, 9808, 5, 21, 0, 0, 9808, 9809, + 5, 2447, 0, 0, 9809, 9810, 3, 2340, 1170, 0, 9810, 9811, 5, 2448, 0, 0, + 9811, 945, 1, 0, 0, 0, 9812, 9813, 5, 992, 0, 0, 9813, 9815, 3, 1200, 600, + 0, 9814, 9816, 3, 928, 464, 0, 9815, 9814, 1, 0, 0, 0, 9815, 9816, 1, 0, + 0, 0, 9816, 947, 1, 0, 0, 0, 9817, 9850, 5, 21, 0, 0, 9818, 9819, 5, 1238, + 0, 0, 9819, 9825, 5, 689, 0, 0, 9820, 9821, 5, 1451, 0, 0, 9821, 9825, + 5, 816, 0, 0, 9822, 9825, 5, 1601, 0, 0, 9823, 9825, 5, 1653, 0, 0, 9824, + 9818, 1, 0, 0, 0, 9824, 9820, 1, 0, 0, 0, 9824, 9822, 1, 0, 0, 0, 9824, + 9823, 1, 0, 0, 0, 9825, 9837, 1, 0, 0, 0, 9826, 9827, 5, 2447, 0, 0, 9827, + 9832, 3, 2340, 1170, 0, 9828, 9829, 5, 2453, 0, 0, 9829, 9831, 3, 2340, + 1170, 0, 9830, 9828, 1, 0, 0, 0, 9831, 9834, 1, 0, 0, 0, 9832, 9830, 1, + 0, 0, 0, 9832, 9833, 1, 0, 0, 0, 9833, 9835, 1, 0, 0, 0, 9834, 9832, 1, + 0, 0, 0, 9835, 9836, 5, 2448, 0, 0, 9836, 9838, 1, 0, 0, 0, 9837, 9826, + 1, 0, 0, 0, 9837, 9838, 1, 0, 0, 0, 9838, 9851, 1, 0, 0, 0, 9839, 9840, + 5, 2447, 0, 0, 9840, 9845, 3, 2340, 1170, 0, 9841, 9842, 5, 2453, 0, 0, + 9842, 9844, 3, 2340, 1170, 0, 9843, 9841, 1, 0, 0, 0, 9844, 9847, 1, 0, + 0, 0, 9845, 9843, 1, 0, 0, 0, 9845, 9846, 1, 0, 0, 0, 9846, 9848, 1, 0, + 0, 0, 9847, 9845, 1, 0, 0, 0, 9848, 9849, 5, 2448, 0, 0, 9849, 9851, 1, + 0, 0, 0, 9850, 9824, 1, 0, 0, 0, 9850, 9839, 1, 0, 0, 0, 9851, 9853, 1, + 0, 0, 0, 9852, 9854, 3, 952, 476, 0, 9853, 9852, 1, 0, 0, 0, 9853, 9854, + 1, 0, 0, 0, 9854, 949, 1, 0, 0, 0, 9855, 9856, 5, 321, 0, 0, 9856, 9857, + 5, 919, 0, 0, 9857, 9858, 5, 2286, 0, 0, 9858, 9859, 5, 888, 0, 0, 9859, + 9860, 5, 1259, 0, 0, 9860, 9870, 3, 2342, 1171, 0, 9861, 9867, 3, 1194, + 597, 0, 9862, 9863, 5, 2080, 0, 0, 9863, 9867, 3, 2404, 1202, 0, 9864, + 9867, 3, 886, 443, 0, 9865, 9867, 7, 109, 0, 0, 9866, 9861, 1, 0, 0, 0, + 9866, 9862, 1, 0, 0, 0, 9866, 9864, 1, 0, 0, 0, 9866, 9865, 1, 0, 0, 0, + 9867, 9868, 1, 0, 0, 0, 9868, 9866, 1, 0, 0, 0, 9868, 9869, 1, 0, 0, 0, + 9869, 9871, 1, 0, 0, 0, 9870, 9866, 1, 0, 0, 0, 9870, 9871, 1, 0, 0, 0, + 9871, 9873, 1, 0, 0, 0, 9872, 9874, 3, 928, 464, 0, 9873, 9872, 1, 0, 0, + 0, 9873, 9874, 1, 0, 0, 0, 9874, 9914, 1, 0, 0, 0, 9875, 9891, 5, 2308, + 0, 0, 9876, 9878, 5, 2453, 0, 0, 9877, 9876, 1, 0, 0, 0, 9877, 9878, 1, + 0, 0, 0, 9878, 9887, 1, 0, 0, 0, 9879, 9880, 5, 1238, 0, 0, 9880, 9888, + 5, 689, 0, 0, 9881, 9882, 5, 1451, 0, 0, 9882, 9888, 5, 816, 0, 0, 9883, + 9888, 5, 1601, 0, 0, 9884, 9888, 5, 1653, 0, 0, 9885, 9886, 5, 242, 0, + 0, 9886, 9888, 5, 1627, 0, 0, 9887, 9879, 1, 0, 0, 0, 9887, 9881, 1, 0, + 0, 0, 9887, 9883, 1, 0, 0, 0, 9887, 9884, 1, 0, 0, 0, 9887, 9885, 1, 0, + 0, 0, 9888, 9890, 1, 0, 0, 0, 9889, 9877, 1, 0, 0, 0, 9890, 9893, 1, 0, + 0, 0, 9891, 9889, 1, 0, 0, 0, 9891, 9892, 1, 0, 0, 0, 9892, 9907, 1, 0, + 0, 0, 9893, 9891, 1, 0, 0, 0, 9894, 9899, 5, 2447, 0, 0, 9895, 9897, 5, + 2453, 0, 0, 9896, 9895, 1, 0, 0, 0, 9896, 9897, 1, 0, 0, 0, 9897, 9898, + 1, 0, 0, 0, 9898, 9900, 3, 2410, 1205, 0, 9899, 9896, 1, 0, 0, 0, 9900, + 9901, 1, 0, 0, 0, 9901, 9899, 1, 0, 0, 0, 9901, 9902, 1, 0, 0, 0, 9902, + 9903, 1, 0, 0, 0, 9903, 9905, 5, 2448, 0, 0, 9904, 9906, 3, 952, 476, 0, + 9905, 9904, 1, 0, 0, 0, 9905, 9906, 1, 0, 0, 0, 9906, 9908, 1, 0, 0, 0, + 9907, 9894, 1, 0, 0, 0, 9907, 9908, 1, 0, 0, 0, 9908, 9910, 1, 0, 0, 0, + 9909, 9911, 3, 954, 477, 0, 9910, 9909, 1, 0, 0, 0, 9910, 9911, 1, 0, 0, + 0, 9911, 9913, 1, 0, 0, 0, 9912, 9875, 1, 0, 0, 0, 9913, 9916, 1, 0, 0, + 0, 9914, 9912, 1, 0, 0, 0, 9914, 9915, 1, 0, 0, 0, 9915, 951, 1, 0, 0, + 0, 9916, 9914, 1, 0, 0, 0, 9917, 9918, 7, 110, 0, 0, 9918, 9919, 5, 1021, + 0, 0, 9919, 9920, 5, 2257, 0, 0, 9920, 953, 1, 0, 0, 0, 9921, 9922, 5, + 1475, 0, 0, 9922, 9924, 5, 698, 0, 0, 9923, 9925, 7, 111, 0, 0, 9924, 9923, + 1, 0, 0, 0, 9924, 9925, 1, 0, 0, 0, 9925, 955, 1, 0, 0, 0, 9926, 9927, + 5, 321, 0, 0, 9927, 9928, 5, 919, 0, 0, 9928, 9929, 5, 2362, 0, 0, 9929, + 9934, 3, 966, 483, 0, 9930, 9931, 5, 2447, 0, 0, 9931, 9932, 3, 2358, 1179, + 0, 9932, 9933, 5, 2448, 0, 0, 9933, 9935, 1, 0, 0, 0, 9934, 9930, 1, 0, + 0, 0, 9934, 9935, 1, 0, 0, 0, 9935, 9937, 1, 0, 0, 0, 9936, 9938, 3, 964, + 482, 0, 9937, 9936, 1, 0, 0, 0, 9937, 9938, 1, 0, 0, 0, 9938, 9940, 1, + 0, 0, 0, 9939, 9941, 3, 962, 481, 0, 9940, 9939, 1, 0, 0, 0, 9940, 9941, + 1, 0, 0, 0, 9941, 9944, 1, 0, 0, 0, 9942, 9943, 7, 17, 0, 0, 9943, 9945, + 5, 1472, 0, 0, 9944, 9942, 1, 0, 0, 0, 9944, 9945, 1, 0, 0, 0, 9945, 9948, + 1, 0, 0, 0, 9946, 9949, 3, 972, 486, 0, 9947, 9949, 3, 974, 487, 0, 9948, + 9946, 1, 0, 0, 0, 9948, 9947, 1, 0, 0, 0, 9949, 957, 1, 0, 0, 0, 9950, + 9951, 5, 42, 0, 0, 9951, 9952, 5, 919, 0, 0, 9952, 9953, 5, 2362, 0, 0, + 9953, 9961, 3, 966, 483, 0, 9954, 9962, 3, 964, 482, 0, 9955, 9962, 3, + 962, 481, 0, 9956, 9957, 7, 17, 0, 0, 9957, 9962, 5, 1472, 0, 0, 9958, + 9962, 5, 249, 0, 0, 9959, 9962, 5, 1511, 0, 0, 9960, 9962, 5, 2203, 0, + 0, 9961, 9954, 1, 0, 0, 0, 9961, 9955, 1, 0, 0, 0, 9961, 9956, 1, 0, 0, + 0, 9961, 9958, 1, 0, 0, 0, 9961, 9959, 1, 0, 0, 0, 9961, 9960, 1, 0, 0, + 0, 9962, 959, 1, 0, 0, 0, 9963, 9964, 5, 469, 0, 0, 9964, 9965, 5, 919, + 0, 0, 9965, 9966, 5, 2362, 0, 0, 9966, 9967, 3, 966, 483, 0, 9967, 961, + 1, 0, 0, 0, 9968, 9970, 5, 1531, 0, 0, 9969, 9971, 7, 112, 0, 0, 9970, + 9969, 1, 0, 0, 0, 9970, 9971, 1, 0, 0, 0, 9971, 9983, 1, 0, 0, 0, 9972, + 9981, 5, 1259, 0, 0, 9973, 9982, 5, 406, 0, 0, 9974, 9982, 5, 242, 0, 0, + 9975, 9982, 5, 867, 0, 0, 9976, 9977, 5, 351, 0, 0, 9977, 9982, 5, 991, + 0, 0, 9978, 9979, 5, 867, 0, 0, 9979, 9980, 5, 351, 0, 0, 9980, 9982, 5, + 991, 0, 0, 9981, 9973, 1, 0, 0, 0, 9981, 9974, 1, 0, 0, 0, 9981, 9975, + 1, 0, 0, 0, 9981, 9976, 1, 0, 0, 0, 9981, 9978, 1, 0, 0, 0, 9982, 9984, + 1, 0, 0, 0, 9983, 9972, 1, 0, 0, 0, 9983, 9984, 1, 0, 0, 0, 9984, 963, + 1, 0, 0, 0, 9985, 9986, 5, 1369, 0, 0, 9986, 9995, 3, 2396, 1198, 0, 9987, + 9988, 5, 1372, 0, 0, 9988, 9995, 3, 2396, 1198, 0, 9989, 9990, 5, 1620, + 0, 0, 9990, 9995, 3, 2396, 1198, 0, 9991, 9992, 5, 2080, 0, 0, 9992, 9995, + 3, 1656, 828, 0, 9993, 9995, 7, 109, 0, 0, 9994, 9985, 1, 0, 0, 0, 9994, + 9987, 1, 0, 0, 0, 9994, 9989, 1, 0, 0, 0, 9994, 9991, 1, 0, 0, 0, 9994, + 9993, 1, 0, 0, 0, 9995, 9996, 1, 0, 0, 0, 9996, 9994, 1, 0, 0, 0, 9996, + 9997, 1, 0, 0, 0, 9997, 965, 1, 0, 0, 0, 9998, 10001, 3, 2402, 1201, 0, + 9999, 10000, 5, 2440, 0, 0, 10000, 10002, 3, 2404, 1202, 0, 10001, 9999, + 1, 0, 0, 0, 10001, 10002, 1, 0, 0, 0, 10002, 967, 1, 0, 0, 0, 10003, 10006, + 3, 2402, 1201, 0, 10004, 10005, 5, 2440, 0, 0, 10005, 10007, 3, 2404, 1202, + 0, 10006, 10004, 1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, 10007, 969, 1, 0, + 0, 0, 10008, 10013, 3, 2402, 1201, 0, 10009, 10010, 5, 2440, 0, 0, 10010, + 10012, 3, 2404, 1202, 0, 10011, 10009, 1, 0, 0, 0, 10012, 10015, 1, 0, + 0, 0, 10013, 10011, 1, 0, 0, 0, 10013, 10014, 1, 0, 0, 0, 10014, 971, 1, + 0, 0, 0, 10015, 10013, 1, 0, 0, 0, 10016, 10017, 5, 1259, 0, 0, 10017, + 10018, 3, 2342, 1171, 0, 10018, 10019, 5, 2447, 0, 0, 10019, 10020, 3, + 2358, 1179, 0, 10020, 10021, 5, 2448, 0, 0, 10021, 973, 1, 0, 0, 0, 10022, + 10023, 5, 69, 0, 0, 10023, 10024, 3, 1896, 948, 0, 10024, 975, 1, 0, 0, + 0, 10025, 10026, 5, 42, 0, 0, 10026, 10027, 5, 1266, 0, 0, 10027, 10031, + 3, 968, 484, 0, 10028, 10032, 3, 984, 492, 0, 10029, 10032, 3, 996, 498, + 0, 10030, 10032, 5, 249, 0, 0, 10031, 10028, 1, 0, 0, 0, 10031, 10029, + 1, 0, 0, 0, 10031, 10030, 1, 0, 0, 0, 10032, 977, 1, 0, 0, 0, 10033, 10034, + 5, 469, 0, 0, 10034, 10035, 5, 1266, 0, 0, 10035, 10037, 3, 968, 484, 0, + 10036, 10038, 5, 616, 0, 0, 10037, 10036, 1, 0, 0, 0, 10037, 10038, 1, + 0, 0, 0, 10038, 979, 1, 0, 0, 0, 10039, 10042, 5, 321, 0, 0, 10040, 10041, + 5, 1307, 0, 0, 10041, 10043, 5, 1562, 0, 0, 10042, 10040, 1, 0, 0, 0, 10042, + 10043, 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044, 10045, 5, 1266, 0, + 0, 10045, 10046, 3, 968, 484, 0, 10046, 10047, 5, 133, 0, 0, 10047, 10052, + 3, 982, 491, 0, 10048, 10049, 5, 2453, 0, 0, 10049, 10051, 3, 982, 491, + 0, 10050, 10048, 1, 0, 0, 0, 10051, 10054, 1, 0, 0, 0, 10052, 10050, 1, + 0, 0, 0, 10052, 10053, 1, 0, 0, 0, 10053, 10058, 1, 0, 0, 0, 10054, 10052, + 1, 0, 0, 0, 10055, 10056, 5, 1681, 0, 0, 10056, 10057, 5, 2472, 0, 0, 10057, + 10059, 7, 21, 0, 0, 10058, 10055, 1, 0, 0, 0, 10058, 10059, 1, 0, 0, 0, + 10059, 981, 1, 0, 0, 0, 10060, 10061, 5, 2447, 0, 0, 10061, 10066, 3, 2376, + 1188, 0, 10062, 10063, 5, 2453, 0, 0, 10063, 10065, 3, 2376, 1188, 0, 10064, + 10062, 1, 0, 0, 0, 10065, 10068, 1, 0, 0, 0, 10066, 10064, 1, 0, 0, 0, + 10066, 10067, 1, 0, 0, 0, 10067, 10069, 1, 0, 0, 0, 10068, 10066, 1, 0, + 0, 0, 10069, 10070, 5, 2448, 0, 0, 10070, 10072, 5, 1586, 0, 0, 10071, + 10073, 5, 2447, 0, 0, 10072, 10071, 1, 0, 0, 0, 10072, 10073, 1, 0, 0, + 0, 10073, 10074, 1, 0, 0, 0, 10074, 10076, 3, 2376, 1188, 0, 10075, 10077, + 5, 2448, 0, 0, 10076, 10075, 1, 0, 0, 0, 10076, 10077, 1, 0, 0, 0, 10077, + 10079, 1, 0, 0, 0, 10078, 10080, 3, 986, 493, 0, 10079, 10078, 1, 0, 0, + 0, 10079, 10080, 1, 0, 0, 0, 10080, 10081, 1, 0, 0, 0, 10081, 10082, 3, + 994, 497, 0, 10082, 983, 1, 0, 0, 0, 10083, 10084, 5, 21, 0, 0, 10084, + 10085, 5, 133, 0, 0, 10085, 10086, 3, 982, 491, 0, 10086, 985, 1, 0, 0, + 0, 10087, 10088, 5, 48, 0, 0, 10088, 10089, 5, 2141, 0, 0, 10089, 10092, + 3, 988, 494, 0, 10090, 10092, 3, 992, 496, 0, 10091, 10087, 1, 0, 0, 0, + 10091, 10090, 1, 0, 0, 0, 10092, 987, 1, 0, 0, 0, 10093, 10098, 3, 990, + 495, 0, 10094, 10095, 5, 2453, 0, 0, 10095, 10097, 3, 990, 495, 0, 10096, + 10094, 1, 0, 0, 0, 10097, 10100, 1, 0, 0, 0, 10098, 10096, 1, 0, 0, 0, + 10098, 10099, 1, 0, 0, 0, 10099, 989, 1, 0, 0, 0, 10100, 10098, 1, 0, 0, + 0, 10101, 10102, 3, 2350, 1175, 0, 10102, 10103, 5, 2447, 0, 0, 10103, + 10108, 3, 2376, 1188, 0, 10104, 10105, 5, 2453, 0, 0, 10105, 10107, 3, + 2376, 1188, 0, 10106, 10104, 1, 0, 0, 0, 10107, 10110, 1, 0, 0, 0, 10108, + 10106, 1, 0, 0, 0, 10108, 10109, 1, 0, 0, 0, 10109, 10111, 1, 0, 0, 0, + 10110, 10108, 1, 0, 0, 0, 10111, 10112, 5, 2448, 0, 0, 10112, 991, 1, 0, + 0, 0, 10113, 10114, 5, 2308, 0, 0, 10114, 10115, 5, 717, 0, 0, 10115, 10116, + 5, 296, 0, 0, 10116, 10117, 5, 2453, 0, 0, 10117, 10118, 5, 1622, 0, 0, + 10118, 10119, 5, 296, 0, 0, 10119, 10123, 3, 2292, 1146, 0, 10120, 10121, + 5, 260, 0, 0, 10121, 10122, 5, 48, 0, 0, 10122, 10124, 5, 351, 0, 0, 10123, + 10120, 1, 0, 0, 0, 10123, 10124, 1, 0, 0, 0, 10124, 10128, 1, 0, 0, 0, + 10125, 10126, 5, 2308, 0, 0, 10126, 10127, 5, 237, 0, 0, 10127, 10129, + 5, 296, 0, 0, 10128, 10125, 1, 0, 0, 0, 10128, 10129, 1, 0, 0, 0, 10129, + 993, 1, 0, 0, 0, 10130, 10131, 5, 2246, 0, 0, 10131, 10132, 3, 970, 485, + 0, 10132, 995, 1, 0, 0, 0, 10133, 10134, 5, 469, 0, 0, 10134, 10135, 5, + 133, 0, 0, 10135, 10136, 5, 2447, 0, 0, 10136, 10141, 3, 2376, 1188, 0, + 10137, 10138, 5, 2453, 0, 0, 10138, 10140, 3, 2376, 1188, 0, 10139, 10137, + 1, 0, 0, 0, 10140, 10143, 1, 0, 0, 0, 10141, 10139, 1, 0, 0, 0, 10141, + 10142, 1, 0, 0, 0, 10142, 10144, 1, 0, 0, 0, 10143, 10141, 1, 0, 0, 0, + 10144, 10146, 5, 2448, 0, 0, 10145, 10147, 5, 616, 0, 0, 10146, 10145, + 1, 0, 0, 0, 10146, 10147, 1, 0, 0, 0, 10147, 997, 1, 0, 0, 0, 10148, 10149, + 5, 321, 0, 0, 10149, 10150, 5, 919, 0, 0, 10150, 10154, 5, 2286, 0, 0, + 10151, 10152, 5, 691, 0, 0, 10152, 10153, 5, 1204, 0, 0, 10153, 10155, + 5, 545, 0, 0, 10154, 10151, 1, 0, 0, 0, 10154, 10155, 1, 0, 0, 0, 10155, + 10156, 1, 0, 0, 0, 10156, 10159, 3, 2342, 1171, 0, 10157, 10158, 5, 1246, + 0, 0, 10158, 10160, 3, 2314, 1157, 0, 10159, 10157, 1, 0, 0, 0, 10159, + 10160, 1, 0, 0, 0, 10160, 10178, 1, 0, 0, 0, 10161, 10164, 5, 2447, 0, + 0, 10162, 10165, 3, 1000, 500, 0, 10163, 10165, 3, 1002, 501, 0, 10164, + 10162, 1, 0, 0, 0, 10164, 10163, 1, 0, 0, 0, 10165, 10173, 1, 0, 0, 0, + 10166, 10169, 5, 2453, 0, 0, 10167, 10170, 3, 1000, 500, 0, 10168, 10170, + 3, 1002, 501, 0, 10169, 10167, 1, 0, 0, 0, 10169, 10168, 1, 0, 0, 0, 10170, + 10172, 1, 0, 0, 0, 10171, 10166, 1, 0, 0, 0, 10172, 10175, 1, 0, 0, 0, + 10173, 10171, 1, 0, 0, 0, 10173, 10174, 1, 0, 0, 0, 10174, 10176, 1, 0, + 0, 0, 10175, 10173, 1, 0, 0, 0, 10176, 10177, 5, 2448, 0, 0, 10177, 10179, + 1, 0, 0, 0, 10178, 10161, 1, 0, 0, 0, 10178, 10179, 1, 0, 0, 0, 10179, + 10200, 1, 0, 0, 0, 10180, 10181, 5, 1259, 0, 0, 10181, 10182, 5, 1434, + 0, 0, 10182, 10186, 5, 2083, 0, 0, 10183, 10184, 7, 2, 0, 0, 10184, 10185, + 5, 1523, 0, 0, 10185, 10187, 5, 1437, 0, 0, 10186, 10183, 1, 0, 0, 0, 10186, + 10187, 1, 0, 0, 0, 10187, 10201, 1, 0, 0, 0, 10188, 10190, 3, 1202, 601, + 0, 10189, 10188, 1, 0, 0, 0, 10189, 10190, 1, 0, 0, 0, 10190, 10192, 1, + 0, 0, 0, 10191, 10193, 7, 109, 0, 0, 10192, 10191, 1, 0, 0, 0, 10192, 10193, + 1, 0, 0, 0, 10193, 10195, 1, 0, 0, 0, 10194, 10196, 3, 928, 464, 0, 10195, + 10194, 1, 0, 0, 0, 10195, 10196, 1, 0, 0, 0, 10196, 10198, 1, 0, 0, 0, + 10197, 10199, 3, 926, 463, 0, 10198, 10197, 1, 0, 0, 0, 10198, 10199, 1, + 0, 0, 0, 10199, 10201, 1, 0, 0, 0, 10200, 10180, 1, 0, 0, 0, 10200, 10189, + 1, 0, 0, 0, 10201, 10219, 1, 0, 0, 0, 10202, 10203, 5, 2246, 0, 0, 10203, + 10213, 5, 717, 0, 0, 10204, 10208, 3, 1194, 597, 0, 10205, 10206, 5, 2080, + 0, 0, 10206, 10208, 3, 2404, 1202, 0, 10207, 10204, 1, 0, 0, 0, 10207, + 10205, 1, 0, 0, 0, 10208, 10209, 1, 0, 0, 0, 10209, 10207, 1, 0, 0, 0, + 10209, 10210, 1, 0, 0, 0, 10210, 10212, 1, 0, 0, 0, 10211, 10207, 1, 0, + 0, 0, 10212, 10215, 1, 0, 0, 0, 10213, 10211, 1, 0, 0, 0, 10213, 10214, + 1, 0, 0, 0, 10214, 10220, 1, 0, 0, 0, 10215, 10213, 1, 0, 0, 0, 10216, + 10217, 5, 2246, 0, 0, 10217, 10218, 5, 1137, 0, 0, 10218, 10220, 5, 717, + 0, 0, 10219, 10202, 1, 0, 0, 0, 10219, 10216, 1, 0, 0, 0, 10219, 10220, + 1, 0, 0, 0, 10220, 10222, 1, 0, 0, 0, 10221, 10223, 3, 1004, 502, 0, 10222, + 10221, 1, 0, 0, 0, 10222, 10223, 1, 0, 0, 0, 10223, 10225, 1, 0, 0, 0, + 10224, 10226, 3, 1688, 844, 0, 10225, 10224, 1, 0, 0, 0, 10225, 10226, + 1, 0, 0, 0, 10226, 10231, 1, 0, 0, 0, 10227, 10228, 7, 17, 0, 0, 10228, + 10229, 5, 1259, 0, 0, 10229, 10230, 5, 1484, 0, 0, 10230, 10232, 5, 261, + 0, 0, 10231, 10227, 1, 0, 0, 0, 10231, 10232, 1, 0, 0, 0, 10232, 10234, + 1, 0, 0, 0, 10233, 10235, 3, 1006, 503, 0, 10234, 10233, 1, 0, 0, 0, 10234, + 10235, 1, 0, 0, 0, 10235, 10239, 1, 0, 0, 0, 10236, 10237, 7, 17, 0, 0, + 10237, 10238, 5, 263, 0, 0, 10238, 10240, 5, 1531, 0, 0, 10239, 10236, + 1, 0, 0, 0, 10239, 10240, 1, 0, 0, 0, 10240, 10242, 1, 0, 0, 0, 10241, + 10243, 3, 2246, 1123, 0, 10242, 10241, 1, 0, 0, 0, 10242, 10243, 1, 0, + 0, 0, 10243, 10244, 1, 0, 0, 0, 10244, 10245, 5, 69, 0, 0, 10245, 10246, + 3, 1868, 934, 0, 10246, 999, 1, 0, 0, 0, 10247, 10248, 5, 1628, 0, 0, 10248, + 10249, 5, 620, 0, 0, 10249, 10250, 5, 2447, 0, 0, 10250, 10251, 3, 2402, + 1201, 0, 10251, 10252, 5, 2448, 0, 0, 10252, 10256, 5, 785, 0, 0, 10253, + 10254, 3, 2286, 1143, 0, 10254, 10255, 5, 2440, 0, 0, 10255, 10257, 1, + 0, 0, 0, 10256, 10253, 1, 0, 0, 0, 10256, 10257, 1, 0, 0, 0, 10257, 10258, + 1, 0, 0, 0, 10258, 10259, 3, 2402, 1201, 0, 10259, 1001, 1, 0, 0, 0, 10260, + 10263, 3, 2402, 1201, 0, 10261, 10263, 3, 2400, 1200, 0, 10262, 10260, + 1, 0, 0, 0, 10262, 10261, 1, 0, 0, 0, 10263, 10266, 1, 0, 0, 0, 10264, + 10265, 5, 505, 0, 0, 10265, 10267, 3, 1654, 827, 0, 10266, 10264, 1, 0, + 0, 0, 10266, 10267, 1, 0, 0, 0, 10267, 10270, 1, 0, 0, 0, 10268, 10271, + 3, 2246, 1123, 0, 10269, 10271, 3, 1000, 500, 0, 10270, 10268, 1, 0, 0, + 0, 10270, 10269, 1, 0, 0, 0, 10270, 10271, 1, 0, 0, 0, 10271, 1003, 1, + 0, 0, 0, 10272, 10273, 5, 1020, 0, 0, 10273, 10313, 5, 1531, 0, 0, 10274, + 10308, 5, 1531, 0, 0, 10275, 10309, 7, 113, 0, 0, 10276, 10277, 5, 1259, + 0, 0, 10277, 10309, 7, 114, 0, 0, 10278, 10279, 5, 1737, 0, 0, 10279, 10282, + 5, 2308, 0, 0, 10280, 10282, 5, 1025, 0, 0, 10281, 10278, 1, 0, 0, 0, 10281, + 10280, 1, 0, 0, 0, 10282, 10283, 1, 0, 0, 0, 10283, 10309, 3, 2078, 1039, + 0, 10284, 10288, 5, 2308, 0, 0, 10285, 10286, 5, 1451, 0, 0, 10286, 10289, + 5, 816, 0, 0, 10287, 10289, 5, 1601, 0, 0, 10288, 10285, 1, 0, 0, 0, 10288, + 10287, 1, 0, 0, 0, 10289, 10309, 1, 0, 0, 0, 10290, 10303, 5, 2246, 0, + 0, 10291, 10293, 5, 389, 0, 0, 10292, 10294, 7, 115, 0, 0, 10293, 10292, + 1, 0, 0, 0, 10293, 10294, 1, 0, 0, 0, 10294, 10295, 1, 0, 0, 0, 10295, + 10296, 5, 1596, 0, 0, 10296, 10304, 5, 1645, 0, 0, 10297, 10299, 7, 115, + 0, 0, 10298, 10297, 1, 0, 0, 0, 10298, 10299, 1, 0, 0, 0, 10299, 10300, + 1, 0, 0, 0, 10300, 10301, 5, 1596, 0, 0, 10301, 10302, 5, 1645, 0, 0, 10302, + 10304, 3, 2284, 1142, 0, 10303, 10291, 1, 0, 0, 0, 10303, 10298, 1, 0, + 0, 0, 10304, 10309, 1, 0, 0, 0, 10305, 10306, 5, 2246, 0, 0, 10306, 10307, + 7, 108, 0, 0, 10307, 10309, 5, 287, 0, 0, 10308, 10275, 1, 0, 0, 0, 10308, + 10276, 1, 0, 0, 0, 10308, 10281, 1, 0, 0, 0, 10308, 10284, 1, 0, 0, 0, + 10308, 10290, 1, 0, 0, 0, 10308, 10305, 1, 0, 0, 0, 10309, 10310, 1, 0, + 0, 0, 10310, 10308, 1, 0, 0, 0, 10310, 10311, 1, 0, 0, 0, 10311, 10313, + 1, 0, 0, 0, 10312, 10272, 1, 0, 0, 0, 10312, 10274, 1, 0, 0, 0, 10313, + 1005, 1, 0, 0, 0, 10314, 10315, 7, 17, 0, 0, 10315, 10316, 5, 1484, 0, + 0, 10316, 10318, 5, 1591, 0, 0, 10317, 10319, 3, 1008, 504, 0, 10318, 10317, + 1, 0, 0, 0, 10318, 10319, 1, 0, 0, 0, 10319, 1007, 1, 0, 0, 0, 10320, 10339, + 5, 2203, 0, 0, 10321, 10325, 5, 112, 0, 0, 10322, 10323, 5, 114, 0, 0, + 10323, 10325, 5, 2308, 0, 0, 10324, 10321, 1, 0, 0, 0, 10324, 10322, 1, + 0, 0, 0, 10325, 10326, 1, 0, 0, 0, 10326, 10327, 5, 336, 0, 0, 10327, 10340, + 5, 483, 0, 0, 10328, 10332, 5, 112, 0, 0, 10329, 10330, 5, 114, 0, 0, 10330, + 10332, 5, 2308, 0, 0, 10331, 10328, 1, 0, 0, 0, 10331, 10329, 1, 0, 0, + 0, 10332, 10333, 1, 0, 0, 0, 10333, 10334, 5, 483, 0, 0, 10334, 10340, + 3, 1454, 727, 0, 10335, 10336, 5, 114, 0, 0, 10336, 10337, 5, 2308, 0, + 0, 10337, 10338, 5, 1228, 0, 0, 10338, 10340, 5, 483, 0, 0, 10339, 10324, + 1, 0, 0, 0, 10339, 10331, 1, 0, 0, 0, 10339, 10335, 1, 0, 0, 0, 10340, + 1009, 1, 0, 0, 0, 10341, 10342, 5, 469, 0, 0, 10342, 10343, 5, 919, 0, + 0, 10343, 10344, 5, 2286, 0, 0, 10344, 10347, 3, 2342, 1171, 0, 10345, + 10346, 5, 1447, 0, 0, 10346, 10348, 5, 2083, 0, 0, 10347, 10345, 1, 0, + 0, 0, 10347, 10348, 1, 0, 0, 0, 10348, 1011, 1, 0, 0, 0, 10349, 10350, + 5, 469, 0, 0, 10350, 10351, 5, 919, 0, 0, 10351, 10352, 5, 2286, 0, 0, + 10352, 10355, 5, 888, 0, 0, 10353, 10354, 5, 691, 0, 0, 10354, 10356, 5, + 545, 0, 0, 10355, 10353, 1, 0, 0, 0, 10355, 10356, 1, 0, 0, 0, 10356, 10357, + 1, 0, 0, 0, 10357, 10358, 5, 1259, 0, 0, 10358, 10359, 3, 2342, 1171, 0, + 10359, 1013, 1, 0, 0, 0, 10360, 10363, 5, 321, 0, 0, 10361, 10362, 5, 1307, + 0, 0, 10362, 10364, 5, 1562, 0, 0, 10363, 10361, 1, 0, 0, 0, 10363, 10364, + 1, 0, 0, 0, 10364, 10365, 1, 0, 0, 0, 10365, 10366, 5, 296, 0, 0, 10366, + 10367, 3, 1016, 508, 0, 10367, 10371, 5, 2246, 0, 0, 10368, 10369, 3, 2350, + 1175, 0, 10369, 10370, 5, 2440, 0, 0, 10370, 10372, 1, 0, 0, 0, 10371, + 10368, 1, 0, 0, 0, 10371, 10372, 1, 0, 0, 0, 10372, 10373, 1, 0, 0, 0, + 10373, 10378, 3, 2290, 1145, 0, 10374, 10375, 5, 741, 0, 0, 10375, 10379, + 7, 73, 0, 0, 10376, 10377, 5, 5, 0, 0, 10377, 10379, 5, 643, 0, 0, 10378, + 10374, 1, 0, 0, 0, 10378, 10376, 1, 0, 0, 0, 10378, 10379, 1, 0, 0, 0, + 10379, 1015, 1, 0, 0, 0, 10380, 10381, 3, 2404, 1202, 0, 10381, 1017, 1, + 0, 0, 0, 10382, 10383, 5, 321, 0, 0, 10383, 10384, 5, 220, 0, 0, 10384, + 10385, 3, 466, 233, 0, 10385, 10386, 5, 2447, 0, 0, 10386, 10387, 3, 2340, + 1170, 0, 10387, 10389, 3, 2376, 1188, 0, 10388, 10390, 5, 1709, 0, 0, 10389, + 10388, 1, 0, 0, 0, 10389, 10390, 1, 0, 0, 0, 10390, 10399, 1, 0, 0, 0, + 10391, 10392, 5, 2453, 0, 0, 10392, 10393, 3, 2340, 1170, 0, 10393, 10395, + 3, 2376, 1188, 0, 10394, 10396, 5, 1709, 0, 0, 10395, 10394, 1, 0, 0, 0, + 10395, 10396, 1, 0, 0, 0, 10396, 10398, 1, 0, 0, 0, 10397, 10391, 1, 0, + 0, 0, 10398, 10401, 1, 0, 0, 0, 10399, 10397, 1, 0, 0, 0, 10399, 10400, + 1, 0, 0, 0, 10400, 10402, 1, 0, 0, 0, 10401, 10399, 1, 0, 0, 0, 10402, + 10422, 5, 2448, 0, 0, 10403, 10421, 3, 1194, 597, 0, 10404, 10405, 5, 1699, + 0, 0, 10405, 10421, 3, 1176, 588, 0, 10406, 10407, 5, 2080, 0, 0, 10407, + 10421, 3, 1656, 828, 0, 10408, 10421, 5, 717, 0, 0, 10409, 10410, 5, 1695, + 0, 0, 10410, 10412, 5, 2083, 0, 0, 10411, 10409, 1, 0, 0, 0, 10411, 10412, + 1, 0, 0, 0, 10412, 10413, 1, 0, 0, 0, 10413, 10414, 5, 661, 0, 0, 10414, + 10418, 5, 2441, 0, 0, 10415, 10416, 5, 660, 0, 0, 10416, 10417, 5, 785, + 0, 0, 10417, 10419, 3, 2078, 1039, 0, 10418, 10415, 1, 0, 0, 0, 10418, + 10419, 1, 0, 0, 0, 10419, 10421, 1, 0, 0, 0, 10420, 10403, 1, 0, 0, 0, + 10420, 10404, 1, 0, 0, 0, 10420, 10406, 1, 0, 0, 0, 10420, 10408, 1, 0, + 0, 0, 10420, 10411, 1, 0, 0, 0, 10421, 10424, 1, 0, 0, 0, 10422, 10420, + 1, 0, 0, 0, 10422, 10423, 1, 0, 0, 0, 10423, 10426, 1, 0, 0, 0, 10424, + 10422, 1, 0, 0, 0, 10425, 10427, 3, 928, 464, 0, 10426, 10425, 1, 0, 0, + 0, 10426, 10427, 1, 0, 0, 0, 10427, 10429, 1, 0, 0, 0, 10428, 10430, 7, + 116, 0, 0, 10429, 10428, 1, 0, 0, 0, 10429, 10430, 1, 0, 0, 0, 10430, 10432, + 1, 0, 0, 0, 10431, 10433, 7, 109, 0, 0, 10432, 10431, 1, 0, 0, 0, 10432, + 10433, 1, 0, 0, 0, 10433, 1019, 1, 0, 0, 0, 10434, 10436, 5, 321, 0, 0, + 10435, 10437, 5, 908, 0, 0, 10436, 10435, 1, 0, 0, 0, 10436, 10437, 1, + 0, 0, 0, 10437, 10438, 1, 0, 0, 0, 10438, 10439, 5, 1463, 0, 0, 10439, + 10440, 3, 2404, 1202, 0, 10440, 10443, 5, 858, 0, 0, 10441, 10444, 3, 1022, + 511, 0, 10442, 10444, 3, 1024, 512, 0, 10443, 10441, 1, 0, 0, 0, 10443, + 10442, 1, 0, 0, 0, 10444, 10445, 1, 0, 0, 0, 10445, 10443, 1, 0, 0, 0, + 10445, 10446, 1, 0, 0, 0, 10446, 10448, 1, 0, 0, 0, 10447, 10449, 3, 766, + 383, 0, 10448, 10447, 1, 0, 0, 0, 10448, 10449, 1, 0, 0, 0, 10449, 1021, + 1, 0, 0, 0, 10450, 10451, 7, 117, 0, 0, 10451, 10459, 7, 118, 0, 0, 10452, + 10456, 5, 1456, 0, 0, 10453, 10457, 3, 1176, 588, 0, 10454, 10457, 5, 2185, + 0, 0, 10455, 10457, 5, 389, 0, 0, 10456, 10453, 1, 0, 0, 0, 10456, 10454, + 1, 0, 0, 0, 10456, 10455, 1, 0, 0, 0, 10457, 10459, 1, 0, 0, 0, 10458, + 10450, 1, 0, 0, 0, 10458, 10452, 1, 0, 0, 0, 10459, 1023, 1, 0, 0, 0, 10460, + 10464, 7, 119, 0, 0, 10461, 10465, 3, 2078, 1039, 0, 10462, 10465, 5, 2185, + 0, 0, 10463, 10465, 5, 389, 0, 0, 10464, 10461, 1, 0, 0, 0, 10464, 10462, + 1, 0, 0, 0, 10464, 10463, 1, 0, 0, 0, 10465, 10478, 1, 0, 0, 0, 10466, + 10470, 5, 1360, 0, 0, 10467, 10471, 3, 2320, 1160, 0, 10468, 10471, 5, + 1228, 0, 0, 10469, 10471, 5, 389, 0, 0, 10470, 10467, 1, 0, 0, 0, 10470, + 10468, 1, 0, 0, 0, 10470, 10469, 1, 0, 0, 0, 10471, 10478, 1, 0, 0, 0, + 10472, 10475, 5, 1359, 0, 0, 10473, 10476, 3, 2078, 1039, 0, 10474, 10476, + 5, 389, 0, 0, 10475, 10473, 1, 0, 0, 0, 10475, 10474, 1, 0, 0, 0, 10476, + 10478, 1, 0, 0, 0, 10477, 10460, 1, 0, 0, 0, 10477, 10466, 1, 0, 0, 0, + 10477, 10472, 1, 0, 0, 0, 10478, 1025, 1, 0, 0, 0, 10479, 10480, 5, 321, + 0, 0, 10480, 10481, 5, 878, 0, 0, 10481, 10482, 5, 1463, 0, 0, 10482, 10485, + 3, 2404, 1202, 0, 10483, 10486, 3, 1028, 514, 0, 10484, 10486, 3, 1030, + 515, 0, 10485, 10483, 1, 0, 0, 0, 10485, 10484, 1, 0, 0, 0, 10485, 10486, + 1, 0, 0, 0, 10486, 1027, 1, 0, 0, 0, 10487, 10488, 5, 628, 0, 0, 10488, + 10489, 3, 2404, 1202, 0, 10489, 1029, 1, 0, 0, 0, 10490, 10491, 5, 705, + 0, 0, 10491, 10492, 3, 2404, 1202, 0, 10492, 1031, 1, 0, 0, 0, 10493, 10496, + 5, 321, 0, 0, 10494, 10495, 5, 1307, 0, 0, 10495, 10497, 5, 1562, 0, 0, + 10496, 10494, 1, 0, 0, 0, 10496, 10497, 1, 0, 0, 0, 10497, 10499, 1, 0, + 0, 0, 10498, 10500, 7, 28, 0, 0, 10499, 10498, 1, 0, 0, 0, 10499, 10500, + 1, 0, 0, 0, 10500, 10501, 1, 0, 0, 0, 10501, 10503, 5, 1315, 0, 0, 10502, + 10504, 3, 2404, 1202, 0, 10503, 10502, 1, 0, 0, 0, 10503, 10504, 1, 0, + 0, 0, 10504, 10510, 1, 0, 0, 0, 10505, 10507, 5, 628, 0, 0, 10506, 10508, + 7, 28, 0, 0, 10507, 10506, 1, 0, 0, 0, 10507, 10508, 1, 0, 0, 0, 10508, + 10509, 1, 0, 0, 0, 10509, 10511, 3, 2404, 1202, 0, 10510, 10505, 1, 0, + 0, 0, 10510, 10511, 1, 0, 0, 0, 10511, 10515, 1, 0, 0, 0, 10512, 10513, + 5, 620, 0, 0, 10513, 10514, 5, 183, 0, 0, 10514, 10516, 3, 2404, 1202, + 0, 10515, 10512, 1, 0, 0, 0, 10515, 10516, 1, 0, 0, 0, 10516, 10519, 1, + 0, 0, 0, 10517, 10518, 5, 1259, 0, 0, 10518, 10520, 3, 1774, 887, 0, 10519, + 10517, 1, 0, 0, 0, 10519, 10520, 1, 0, 0, 0, 10520, 1033, 1, 0, 0, 0, 10521, + 10523, 5, 321, 0, 0, 10522, 10524, 5, 210, 0, 0, 10523, 10522, 1, 0, 0, + 0, 10523, 10524, 1, 0, 0, 0, 10524, 10525, 1, 0, 0, 0, 10525, 10526, 5, + 1574, 0, 0, 10526, 10527, 5, 1411, 0, 0, 10527, 10532, 3, 2404, 1202, 0, + 10528, 10529, 5, 620, 0, 0, 10529, 10530, 5, 1409, 0, 0, 10530, 10531, + 5, 350, 0, 0, 10531, 10533, 3, 2404, 1202, 0, 10532, 10528, 1, 0, 0, 0, + 10532, 10533, 1, 0, 0, 0, 10533, 10538, 1, 0, 0, 0, 10534, 10535, 5, 69, + 0, 0, 10535, 10536, 5, 1246, 0, 0, 10536, 10537, 7, 83, 0, 0, 10537, 10539, + 3, 2078, 1039, 0, 10538, 10534, 1, 0, 0, 0, 10538, 10539, 1, 0, 0, 0, 10539, + 10544, 1, 0, 0, 0, 10540, 10545, 5, 1447, 0, 0, 10541, 10542, 5, 655, 0, + 0, 10542, 10543, 5, 605, 0, 0, 10543, 10545, 5, 350, 0, 0, 10544, 10540, + 1, 0, 0, 0, 10544, 10541, 1, 0, 0, 0, 10544, 10545, 1, 0, 0, 0, 10545, + 1035, 1, 0, 0, 0, 10546, 10547, 5, 321, 0, 0, 10547, 10548, 5, 1593, 0, + 0, 10548, 10550, 3, 2308, 1154, 0, 10549, 10551, 3, 1524, 762, 0, 10550, + 10549, 1, 0, 0, 0, 10550, 10551, 1, 0, 0, 0, 10551, 10553, 1, 0, 0, 0, + 10552, 10554, 3, 766, 383, 0, 10553, 10552, 1, 0, 0, 0, 10553, 10554, 1, + 0, 0, 0, 10554, 1037, 1, 0, 0, 0, 10555, 10565, 5, 321, 0, 0, 10556, 10557, + 7, 120, 0, 0, 10557, 10566, 5, 2092, 0, 0, 10558, 10566, 5, 2385, 0, 0, + 10559, 10566, 5, 2375, 0, 0, 10560, 10562, 5, 2379, 0, 0, 10561, 10560, + 1, 0, 0, 0, 10561, 10562, 1, 0, 0, 0, 10562, 10563, 1, 0, 0, 0, 10563, + 10566, 5, 2371, 0, 0, 10564, 10566, 5, 2379, 0, 0, 10565, 10556, 1, 0, + 0, 0, 10565, 10558, 1, 0, 0, 0, 10565, 10559, 1, 0, 0, 0, 10565, 10561, + 1, 0, 0, 0, 10565, 10564, 1, 0, 0, 0, 10565, 10566, 1, 0, 0, 0, 10566, + 10567, 1, 0, 0, 0, 10567, 10571, 5, 2083, 0, 0, 10568, 10569, 3, 2286, + 1143, 0, 10569, 10570, 5, 2440, 0, 0, 10570, 10572, 1, 0, 0, 0, 10571, + 10568, 1, 0, 0, 0, 10571, 10572, 1, 0, 0, 0, 10572, 10573, 1, 0, 0, 0, + 10573, 10577, 3, 1110, 555, 0, 10574, 10575, 5, 691, 0, 0, 10575, 10576, + 5, 1204, 0, 0, 10576, 10578, 5, 545, 0, 0, 10577, 10574, 1, 0, 0, 0, 10577, + 10578, 1, 0, 0, 0, 10578, 10589, 1, 0, 0, 0, 10579, 10580, 5, 1681, 0, + 0, 10580, 10587, 5, 2472, 0, 0, 10581, 10588, 5, 948, 0, 0, 10582, 10584, + 5, 2376, 0, 0, 10583, 10582, 1, 0, 0, 0, 10583, 10584, 1, 0, 0, 0, 10584, + 10585, 1, 0, 0, 0, 10585, 10588, 5, 351, 0, 0, 10586, 10588, 5, 1133, 0, + 0, 10587, 10581, 1, 0, 0, 0, 10587, 10583, 1, 0, 0, 0, 10587, 10586, 1, + 0, 0, 0, 10588, 10590, 1, 0, 0, 0, 10589, 10579, 1, 0, 0, 0, 10589, 10590, + 1, 0, 0, 0, 10590, 10594, 1, 0, 0, 0, 10591, 10595, 3, 1062, 531, 0, 10592, + 10595, 3, 1040, 520, 0, 10593, 10595, 3, 1050, 525, 0, 10594, 10591, 1, + 0, 0, 0, 10594, 10592, 1, 0, 0, 0, 10594, 10593, 1, 0, 0, 0, 10595, 10597, + 1, 0, 0, 0, 10596, 10598, 3, 1528, 764, 0, 10597, 10596, 1, 0, 0, 0, 10597, + 10598, 1, 0, 0, 0, 10598, 10601, 1, 0, 0, 0, 10599, 10600, 5, 1337, 0, + 0, 10600, 10602, 3, 2342, 1171, 0, 10601, 10599, 1, 0, 0, 0, 10601, 10602, + 1, 0, 0, 0, 10602, 10605, 1, 0, 0, 0, 10603, 10604, 5, 2216, 0, 0, 10604, + 10606, 5, 1486, 0, 0, 10605, 10603, 1, 0, 0, 0, 10605, 10606, 1, 0, 0, + 0, 10606, 1039, 1, 0, 0, 0, 10607, 10608, 5, 1246, 0, 0, 10608, 10613, + 5, 2351, 0, 0, 10609, 10610, 5, 2447, 0, 0, 10610, 10611, 3, 1058, 529, + 0, 10611, 10612, 5, 2448, 0, 0, 10612, 10614, 1, 0, 0, 0, 10613, 10609, + 1, 0, 0, 0, 10613, 10614, 1, 0, 0, 0, 10614, 10617, 1, 0, 0, 0, 10615, + 10616, 5, 2351, 0, 0, 10616, 10618, 3, 1046, 523, 0, 10617, 10615, 1, 0, + 0, 0, 10617, 10618, 1, 0, 0, 0, 10618, 10620, 1, 0, 0, 0, 10619, 10621, + 3, 1048, 524, 0, 10620, 10619, 1, 0, 0, 0, 10620, 10621, 1, 0, 0, 0, 10621, + 10623, 1, 0, 0, 0, 10622, 10624, 3, 1042, 521, 0, 10623, 10622, 1, 0, 0, + 0, 10623, 10624, 1, 0, 0, 0, 10624, 10629, 1, 0, 0, 0, 10625, 10626, 5, + 1259, 0, 0, 10626, 10627, 5, 242, 0, 0, 10627, 10628, 7, 121, 0, 0, 10628, + 10630, 5, 1607, 0, 0, 10629, 10625, 1, 0, 0, 0, 10629, 10630, 1, 0, 0, + 0, 10630, 10632, 1, 0, 0, 0, 10631, 10633, 3, 1056, 528, 0, 10632, 10631, + 1, 0, 0, 0, 10632, 10633, 1, 0, 0, 0, 10633, 10635, 1, 0, 0, 0, 10634, + 10636, 3, 1054, 527, 0, 10635, 10634, 1, 0, 0, 0, 10635, 10636, 1, 0, 0, + 0, 10636, 10638, 1, 0, 0, 0, 10637, 10639, 3, 1202, 601, 0, 10638, 10637, + 1, 0, 0, 0, 10638, 10639, 1, 0, 0, 0, 10639, 10641, 1, 0, 0, 0, 10640, + 10642, 3, 1084, 542, 0, 10641, 10640, 1, 0, 0, 0, 10641, 10642, 1, 0, 0, + 0, 10642, 1041, 1, 0, 0, 0, 10643, 10644, 5, 2288, 0, 0, 10644, 10645, + 5, 238, 0, 0, 10645, 10646, 5, 2447, 0, 0, 10646, 10647, 3, 2340, 1170, + 0, 10647, 10648, 5, 69, 0, 0, 10648, 10649, 5, 2447, 0, 0, 10649, 10650, + 3, 2078, 1039, 0, 10650, 10660, 5, 2448, 0, 0, 10651, 10652, 5, 2453, 0, + 0, 10652, 10653, 3, 2340, 1170, 0, 10653, 10654, 5, 69, 0, 0, 10654, 10655, + 5, 2447, 0, 0, 10655, 10656, 3, 2078, 1039, 0, 10656, 10657, 5, 2448, 0, + 0, 10657, 10659, 1, 0, 0, 0, 10658, 10651, 1, 0, 0, 0, 10659, 10662, 1, + 0, 0, 0, 10660, 10658, 1, 0, 0, 0, 10660, 10661, 1, 0, 0, 0, 10661, 10663, + 1, 0, 0, 0, 10662, 10660, 1, 0, 0, 0, 10663, 10664, 5, 2448, 0, 0, 10664, + 1043, 1, 0, 0, 0, 10665, 10667, 5, 2351, 0, 0, 10666, 10668, 5, 237, 0, + 0, 10667, 10666, 1, 0, 0, 0, 10667, 10668, 1, 0, 0, 0, 10668, 10669, 1, + 0, 0, 0, 10669, 10671, 3, 2340, 1170, 0, 10670, 10672, 3, 1046, 523, 0, + 10671, 10670, 1, 0, 0, 0, 10671, 10672, 1, 0, 0, 0, 10672, 10674, 1, 0, + 0, 0, 10673, 10675, 3, 1048, 524, 0, 10674, 10673, 1, 0, 0, 0, 10674, 10675, + 1, 0, 0, 0, 10675, 1045, 1, 0, 0, 0, 10676, 10677, 5, 1763, 0, 0, 10677, + 10701, 5, 69, 0, 0, 10678, 10679, 5, 1238, 0, 0, 10679, 10702, 5, 1551, + 0, 0, 10680, 10682, 7, 122, 0, 0, 10681, 10680, 1, 0, 0, 0, 10681, 10682, + 1, 0, 0, 0, 10682, 10686, 1, 0, 0, 0, 10683, 10687, 5, 215, 0, 0, 10684, + 10685, 5, 124, 0, 0, 10685, 10687, 5, 2352, 0, 0, 10686, 10683, 1, 0, 0, + 0, 10686, 10684, 1, 0, 0, 0, 10687, 10699, 1, 0, 0, 0, 10688, 10693, 3, + 1634, 817, 0, 10689, 10690, 5, 2447, 0, 0, 10690, 10691, 3, 1646, 823, + 0, 10691, 10692, 5, 2448, 0, 0, 10692, 10694, 1, 0, 0, 0, 10693, 10689, + 1, 0, 0, 0, 10693, 10694, 1, 0, 0, 0, 10694, 10700, 1, 0, 0, 0, 10695, + 10696, 5, 2447, 0, 0, 10696, 10697, 3, 1646, 823, 0, 10697, 10698, 5, 2448, + 0, 0, 10698, 10700, 1, 0, 0, 0, 10699, 10688, 1, 0, 0, 0, 10699, 10695, + 1, 0, 0, 0, 10699, 10700, 1, 0, 0, 0, 10700, 10702, 1, 0, 0, 0, 10701, + 10678, 1, 0, 0, 0, 10701, 10681, 1, 0, 0, 0, 10702, 10708, 1, 0, 0, 0, + 10703, 10704, 5, 1763, 0, 0, 10704, 10705, 5, 2266, 0, 0, 10705, 10706, + 5, 69, 0, 0, 10706, 10708, 7, 97, 0, 0, 10707, 10676, 1, 0, 0, 0, 10707, + 10703, 1, 0, 0, 0, 10708, 1047, 1, 0, 0, 0, 10709, 10710, 5, 2345, 0, 0, + 10710, 10712, 5, 2444, 0, 0, 10711, 10709, 1, 0, 0, 0, 10711, 10712, 1, + 0, 0, 0, 10712, 10713, 1, 0, 0, 0, 10713, 10714, 5, 486, 0, 0, 10714, 10718, + 5, 2444, 0, 0, 10715, 10716, 3, 1310, 655, 0, 10716, 10717, 5, 1138, 0, + 0, 10717, 10719, 1, 0, 0, 0, 10718, 10715, 1, 0, 0, 0, 10718, 10719, 1, + 0, 0, 0, 10719, 10723, 1, 0, 0, 0, 10720, 10721, 3, 1310, 655, 0, 10721, + 10722, 5, 56, 0, 0, 10722, 10724, 1, 0, 0, 0, 10723, 10720, 1, 0, 0, 0, + 10723, 10724, 1, 0, 0, 0, 10724, 1049, 1, 0, 0, 0, 10725, 10729, 5, 1246, + 0, 0, 10726, 10727, 3, 2286, 1143, 0, 10727, 10728, 5, 2440, 0, 0, 10728, + 10730, 1, 0, 0, 0, 10729, 10726, 1, 0, 0, 0, 10729, 10730, 1, 0, 0, 0, + 10730, 10731, 1, 0, 0, 0, 10731, 10733, 3, 1052, 526, 0, 10732, 10734, + 3, 1060, 530, 0, 10733, 10732, 1, 0, 0, 0, 10733, 10734, 1, 0, 0, 0, 10734, + 10746, 1, 0, 0, 0, 10735, 10736, 5, 2447, 0, 0, 10736, 10741, 3, 1058, + 529, 0, 10737, 10738, 5, 2453, 0, 0, 10738, 10740, 3, 1058, 529, 0, 10739, + 10737, 1, 0, 0, 0, 10740, 10743, 1, 0, 0, 0, 10741, 10739, 1, 0, 0, 0, + 10741, 10742, 1, 0, 0, 0, 10742, 10744, 1, 0, 0, 0, 10743, 10741, 1, 0, + 0, 0, 10744, 10745, 5, 2448, 0, 0, 10745, 10747, 1, 0, 0, 0, 10746, 10735, + 1, 0, 0, 0, 10746, 10747, 1, 0, 0, 0, 10747, 10752, 1, 0, 0, 0, 10748, + 10749, 5, 1259, 0, 0, 10749, 10750, 5, 242, 0, 0, 10750, 10751, 7, 121, + 0, 0, 10751, 10753, 5, 1607, 0, 0, 10752, 10748, 1, 0, 0, 0, 10752, 10753, + 1, 0, 0, 0, 10753, 10755, 1, 0, 0, 0, 10754, 10756, 3, 1056, 528, 0, 10755, + 10754, 1, 0, 0, 0, 10755, 10756, 1, 0, 0, 0, 10756, 10758, 1, 0, 0, 0, + 10757, 10759, 3, 1054, 527, 0, 10758, 10757, 1, 0, 0, 0, 10758, 10759, + 1, 0, 0, 0, 10759, 10761, 1, 0, 0, 0, 10760, 10762, 3, 1202, 601, 0, 10761, + 10760, 1, 0, 0, 0, 10761, 10762, 1, 0, 0, 0, 10762, 10764, 1, 0, 0, 0, + 10763, 10765, 3, 1084, 542, 0, 10764, 10763, 1, 0, 0, 0, 10764, 10765, + 1, 0, 0, 0, 10765, 1051, 1, 0, 0, 0, 10766, 10767, 3, 2410, 1205, 0, 10767, + 1053, 1, 0, 0, 0, 10768, 10770, 5, 1247, 0, 0, 10769, 10771, 3, 2328, 1164, + 0, 10770, 10769, 1, 0, 0, 0, 10770, 10771, 1, 0, 0, 0, 10771, 10772, 1, + 0, 0, 0, 10772, 10776, 5, 2447, 0, 0, 10773, 10777, 3, 1194, 597, 0, 10774, + 10775, 5, 2080, 0, 0, 10775, 10777, 3, 1656, 828, 0, 10776, 10773, 1, 0, + 0, 0, 10776, 10774, 1, 0, 0, 0, 10777, 10778, 1, 0, 0, 0, 10778, 10776, + 1, 0, 0, 0, 10778, 10779, 1, 0, 0, 0, 10779, 10780, 1, 0, 0, 0, 10780, + 10781, 5, 2448, 0, 0, 10781, 1055, 1, 0, 0, 0, 10782, 10783, 5, 1238, 0, + 0, 10783, 10784, 5, 686, 0, 0, 10784, 10789, 5, 785, 0, 0, 10785, 10786, + 5, 1949, 0, 0, 10786, 10790, 5, 640, 0, 0, 10787, 10788, 5, 1451, 0, 0, + 10788, 10790, 5, 816, 0, 0, 10789, 10785, 1, 0, 0, 0, 10789, 10787, 1, + 0, 0, 0, 10790, 1057, 1, 0, 0, 0, 10791, 10794, 3, 2340, 1170, 0, 10792, + 10794, 3, 2280, 1140, 0, 10793, 10791, 1, 0, 0, 0, 10793, 10792, 1, 0, + 0, 0, 10794, 10797, 1, 0, 0, 0, 10795, 10796, 5, 389, 0, 0, 10796, 10798, + 3, 2078, 1039, 0, 10797, 10795, 1, 0, 0, 0, 10797, 10798, 1, 0, 0, 0, 10798, + 10808, 1, 0, 0, 0, 10799, 10804, 3, 846, 423, 0, 10800, 10801, 5, 2453, + 0, 0, 10801, 10803, 3, 846, 423, 0, 10802, 10800, 1, 0, 0, 0, 10803, 10806, + 1, 0, 0, 0, 10804, 10802, 1, 0, 0, 0, 10804, 10805, 1, 0, 0, 0, 10805, + 10809, 1, 0, 0, 0, 10806, 10804, 1, 0, 0, 0, 10807, 10809, 3, 848, 424, + 0, 10808, 10799, 1, 0, 0, 0, 10808, 10807, 1, 0, 0, 0, 10808, 10809, 1, + 0, 0, 0, 10809, 10814, 1, 0, 0, 0, 10810, 10814, 3, 852, 426, 0, 10811, + 10814, 3, 850, 425, 0, 10812, 10814, 3, 1698, 849, 0, 10813, 10793, 1, + 0, 0, 0, 10813, 10810, 1, 0, 0, 0, 10813, 10811, 1, 0, 0, 0, 10813, 10812, + 1, 0, 0, 0, 10814, 1059, 1, 0, 0, 0, 10815, 10817, 5, 1204, 0, 0, 10816, + 10815, 1, 0, 0, 0, 10816, 10817, 1, 0, 0, 0, 10817, 10818, 1, 0, 0, 0, + 10818, 10819, 5, 1780, 0, 0, 10819, 10820, 5, 82, 0, 0, 10820, 10821, 5, + 38, 0, 0, 10821, 10822, 5, 848, 0, 0, 10822, 1061, 1, 0, 0, 0, 10823, 10824, + 5, 2447, 0, 0, 10824, 10829, 3, 1112, 556, 0, 10825, 10826, 5, 2453, 0, + 0, 10826, 10828, 3, 1112, 556, 0, 10827, 10825, 1, 0, 0, 0, 10828, 10831, + 1, 0, 0, 0, 10829, 10827, 1, 0, 0, 0, 10829, 10830, 1, 0, 0, 0, 10830, + 10832, 1, 0, 0, 0, 10831, 10829, 1, 0, 0, 0, 10832, 10833, 5, 2448, 0, + 0, 10833, 10835, 1, 0, 0, 0, 10834, 10823, 1, 0, 0, 0, 10834, 10835, 1, + 0, 0, 0, 10835, 10837, 1, 0, 0, 0, 10836, 10838, 3, 1064, 532, 0, 10837, + 10836, 1, 0, 0, 0, 10837, 10838, 1, 0, 0, 0, 10838, 1063, 1, 0, 0, 0, 10839, + 10841, 3, 1066, 533, 0, 10840, 10839, 1, 0, 0, 0, 10841, 10842, 1, 0, 0, + 0, 10842, 10840, 1, 0, 0, 0, 10842, 10843, 1, 0, 0, 0, 10843, 1065, 1, + 0, 0, 0, 10844, 10860, 3, 1068, 534, 0, 10845, 10860, 3, 1074, 537, 0, + 10846, 10847, 5, 389, 0, 0, 10847, 10848, 5, 2373, 0, 0, 10848, 10860, + 3, 1082, 541, 0, 10849, 10850, 5, 1259, 0, 0, 10850, 10855, 5, 242, 0, + 0, 10851, 10852, 7, 123, 0, 0, 10852, 10856, 5, 2374, 0, 0, 10853, 10854, + 7, 121, 0, 0, 10854, 10856, 5, 1607, 0, 0, 10855, 10851, 1, 0, 0, 0, 10855, + 10853, 1, 0, 0, 0, 10856, 10860, 1, 0, 0, 0, 10857, 10860, 3, 1202, 601, + 0, 10858, 10860, 3, 1084, 542, 0, 10859, 10844, 1, 0, 0, 0, 10859, 10845, + 1, 0, 0, 0, 10859, 10846, 1, 0, 0, 0, 10859, 10849, 1, 0, 0, 0, 10859, + 10857, 1, 0, 0, 0, 10859, 10858, 1, 0, 0, 0, 10860, 1067, 1, 0, 0, 0, 10861, + 10864, 3, 1070, 535, 0, 10862, 10864, 3, 1072, 536, 0, 10863, 10861, 1, + 0, 0, 0, 10863, 10862, 1, 0, 0, 0, 10864, 1069, 1, 0, 0, 0, 10865, 10866, + 5, 1137, 0, 0, 10866, 10872, 5, 469, 0, 0, 10867, 10868, 5, 2202, 0, 0, + 10868, 10869, 3, 2396, 1198, 0, 10869, 10870, 5, 366, 0, 0, 10870, 10871, + 5, 2378, 0, 0, 10871, 10873, 1, 0, 0, 0, 10872, 10867, 1, 0, 0, 0, 10872, + 10873, 1, 0, 0, 0, 10873, 1071, 1, 0, 0, 0, 10874, 10875, 5, 1137, 0, 0, + 10875, 10887, 5, 403, 0, 0, 10876, 10878, 5, 879, 0, 0, 10877, 10876, 1, + 0, 0, 0, 10877, 10878, 1, 0, 0, 0, 10878, 10888, 1, 0, 0, 0, 10879, 10880, + 5, 2202, 0, 0, 10880, 10881, 3, 2396, 1198, 0, 10881, 10882, 5, 366, 0, + 0, 10882, 10883, 5, 33, 0, 0, 10883, 10885, 5, 756, 0, 0, 10884, 10886, + 5, 879, 0, 0, 10885, 10884, 1, 0, 0, 0, 10885, 10886, 1, 0, 0, 0, 10886, + 10888, 1, 0, 0, 0, 10887, 10877, 1, 0, 0, 0, 10887, 10879, 1, 0, 0, 0, + 10888, 1073, 1, 0, 0, 0, 10889, 10890, 3, 1076, 538, 0, 10890, 10891, 3, + 1078, 539, 0, 10891, 10892, 3, 1080, 540, 0, 10892, 1075, 1, 0, 0, 0, 10893, + 10894, 5, 1137, 0, 0, 10894, 10900, 5, 469, 0, 0, 10895, 10896, 5, 2202, + 0, 0, 10896, 10897, 3, 2396, 1198, 0, 10897, 10898, 5, 366, 0, 0, 10898, + 10899, 5, 2378, 0, 0, 10899, 10901, 1, 0, 0, 0, 10900, 10895, 1, 0, 0, + 0, 10900, 10901, 1, 0, 0, 0, 10901, 1077, 1, 0, 0, 0, 10902, 10903, 5, + 1137, 0, 0, 10903, 10915, 5, 403, 0, 0, 10904, 10906, 5, 879, 0, 0, 10905, + 10904, 1, 0, 0, 0, 10905, 10906, 1, 0, 0, 0, 10906, 10916, 1, 0, 0, 0, + 10907, 10908, 5, 2202, 0, 0, 10908, 10909, 3, 2396, 1198, 0, 10909, 10910, + 5, 366, 0, 0, 10910, 10911, 5, 33, 0, 0, 10911, 10913, 5, 756, 0, 0, 10912, + 10914, 5, 879, 0, 0, 10913, 10912, 1, 0, 0, 0, 10913, 10914, 1, 0, 0, 0, + 10914, 10916, 1, 0, 0, 0, 10915, 10905, 1, 0, 0, 0, 10915, 10907, 1, 0, + 0, 0, 10916, 1079, 1, 0, 0, 0, 10917, 10918, 5, 2377, 0, 0, 10918, 10919, + 5, 2246, 0, 0, 10919, 10920, 5, 2384, 0, 0, 10920, 10921, 5, 2285, 0, 0, + 10921, 10922, 5, 2386, 0, 0, 10922, 1081, 1, 0, 0, 0, 10923, 10924, 3, + 2402, 1201, 0, 10924, 1083, 1, 0, 0, 0, 10925, 10956, 3, 1660, 830, 0, + 10926, 10956, 3, 1086, 543, 0, 10927, 10956, 3, 1088, 544, 0, 10928, 10956, + 3, 1114, 557, 0, 10929, 10956, 3, 1090, 545, 0, 10930, 10956, 7, 109, 0, + 0, 10931, 10956, 3, 112, 56, 0, 10932, 10956, 3, 928, 464, 0, 10933, 10956, + 3, 522, 261, 0, 10934, 10956, 7, 116, 0, 0, 10935, 10956, 3, 1584, 792, + 0, 10936, 10956, 3, 1272, 636, 0, 10937, 10956, 3, 1108, 554, 0, 10938, + 10956, 3, 1274, 637, 0, 10939, 10956, 3, 1202, 601, 0, 10940, 10941, 5, + 1606, 0, 0, 10941, 10956, 5, 63, 0, 0, 10942, 10943, 5, 69, 0, 0, 10943, + 10956, 3, 1868, 934, 0, 10944, 10945, 5, 620, 0, 0, 10945, 10946, 5, 538, + 0, 0, 10946, 10947, 5, 2308, 0, 0, 10947, 10951, 5, 2083, 0, 0, 10948, + 10949, 3, 2286, 1143, 0, 10949, 10950, 5, 2440, 0, 0, 10950, 10952, 1, + 0, 0, 0, 10951, 10948, 1, 0, 0, 0, 10951, 10952, 1, 0, 0, 0, 10952, 10953, + 1, 0, 0, 0, 10953, 10956, 3, 1110, 555, 0, 10954, 10956, 3, 2246, 1123, + 0, 10955, 10925, 1, 0, 0, 0, 10955, 10926, 1, 0, 0, 0, 10955, 10927, 1, + 0, 0, 0, 10955, 10928, 1, 0, 0, 0, 10955, 10929, 1, 0, 0, 0, 10955, 10930, + 1, 0, 0, 0, 10955, 10931, 1, 0, 0, 0, 10955, 10932, 1, 0, 0, 0, 10955, + 10933, 1, 0, 0, 0, 10955, 10934, 1, 0, 0, 0, 10955, 10935, 1, 0, 0, 0, + 10955, 10936, 1, 0, 0, 0, 10955, 10937, 1, 0, 0, 0, 10955, 10938, 1, 0, + 0, 0, 10955, 10939, 1, 0, 0, 0, 10955, 10940, 1, 0, 0, 0, 10955, 10942, + 1, 0, 0, 0, 10955, 10944, 1, 0, 0, 0, 10955, 10954, 1, 0, 0, 0, 10956, + 1085, 1, 0, 0, 0, 10957, 10958, 5, 1505, 0, 0, 10958, 10959, 7, 11, 0, + 0, 10959, 1087, 1, 0, 0, 0, 10960, 10961, 5, 718, 0, 0, 10961, 10962, 7, + 100, 0, 0, 10962, 1089, 1, 0, 0, 0, 10963, 10965, 5, 224, 0, 0, 10964, + 10966, 3, 1092, 546, 0, 10965, 10964, 1, 0, 0, 0, 10965, 10966, 1, 0, 0, + 0, 10966, 10967, 1, 0, 0, 0, 10967, 10973, 3, 1098, 549, 0, 10968, 10970, + 3, 1104, 552, 0, 10969, 10968, 1, 0, 0, 0, 10969, 10970, 1, 0, 0, 0, 10970, + 10971, 1, 0, 0, 0, 10971, 10972, 5, 1259, 0, 0, 10972, 10974, 5, 867, 0, + 0, 10973, 10969, 1, 0, 0, 0, 10973, 10974, 1, 0, 0, 0, 10974, 10981, 1, + 0, 0, 0, 10975, 10977, 3, 1104, 552, 0, 10976, 10975, 1, 0, 0, 0, 10976, + 10977, 1, 0, 0, 0, 10977, 10978, 1, 0, 0, 0, 10978, 10979, 5, 1259, 0, + 0, 10979, 10980, 5, 351, 0, 0, 10980, 10982, 5, 991, 0, 0, 10981, 10976, + 1, 0, 0, 0, 10981, 10982, 1, 0, 0, 0, 10982, 10984, 1, 0, 0, 0, 10983, + 10985, 3, 1106, 553, 0, 10984, 10983, 1, 0, 0, 0, 10984, 10985, 1, 0, 0, + 0, 10985, 1091, 1, 0, 0, 0, 10986, 10987, 3, 2286, 1143, 0, 10987, 10988, + 5, 2440, 0, 0, 10988, 10990, 1, 0, 0, 0, 10989, 10986, 1, 0, 0, 0, 10989, + 10990, 1, 0, 0, 0, 10990, 10991, 1, 0, 0, 0, 10991, 10992, 3, 1110, 555, + 0, 10992, 10997, 3, 1094, 547, 0, 10993, 10994, 5, 2453, 0, 0, 10994, 10996, + 3, 1094, 547, 0, 10995, 10993, 1, 0, 0, 0, 10996, 10999, 1, 0, 0, 0, 10997, + 10995, 1, 0, 0, 0, 10997, 10998, 1, 0, 0, 0, 10998, 1093, 1, 0, 0, 0, 10999, + 10997, 1, 0, 0, 0, 11000, 11004, 5, 794, 0, 0, 11001, 11002, 3, 2286, 1143, + 0, 11002, 11003, 5, 2440, 0, 0, 11003, 11005, 1, 0, 0, 0, 11004, 11001, + 1, 0, 0, 0, 11004, 11005, 1, 0, 0, 0, 11005, 11006, 1, 0, 0, 0, 11006, + 11007, 3, 1110, 555, 0, 11007, 11008, 5, 1259, 0, 0, 11008, 11009, 5, 2447, + 0, 0, 11009, 11010, 3, 1096, 548, 0, 11010, 11011, 5, 2448, 0, 0, 11011, + 1095, 1, 0, 0, 0, 11012, 11013, 3, 2078, 1039, 0, 11013, 1097, 1, 0, 0, + 0, 11014, 11016, 5, 160, 0, 0, 11015, 11017, 7, 124, 0, 0, 11016, 11015, + 1, 0, 0, 0, 11016, 11017, 1, 0, 0, 0, 11017, 11018, 1, 0, 0, 0, 11018, + 11019, 5, 1303, 0, 0, 11019, 11020, 3, 1100, 550, 0, 11020, 1099, 1, 0, + 0, 0, 11021, 11034, 3, 1102, 551, 0, 11022, 11023, 5, 2447, 0, 0, 11023, + 11028, 3, 1102, 551, 0, 11024, 11025, 5, 2453, 0, 0, 11025, 11027, 3, 1102, + 551, 0, 11026, 11024, 1, 0, 0, 0, 11027, 11030, 1, 0, 0, 0, 11028, 11026, + 1, 0, 0, 0, 11028, 11029, 1, 0, 0, 0, 11029, 11031, 1, 0, 0, 0, 11030, + 11028, 1, 0, 0, 0, 11031, 11032, 5, 2448, 0, 0, 11032, 11034, 1, 0, 0, + 0, 11033, 11021, 1, 0, 0, 0, 11033, 11022, 1, 0, 0, 0, 11034, 1101, 1, + 0, 0, 0, 11035, 11036, 5, 2447, 0, 0, 11036, 11041, 3, 2340, 1170, 0, 11037, + 11038, 5, 2453, 0, 0, 11038, 11040, 3, 2340, 1170, 0, 11039, 11037, 1, + 0, 0, 0, 11040, 11043, 1, 0, 0, 0, 11041, 11039, 1, 0, 0, 0, 11041, 11042, + 1, 0, 0, 0, 11042, 11044, 1, 0, 0, 0, 11043, 11041, 1, 0, 0, 0, 11044, + 11045, 5, 2448, 0, 0, 11045, 1103, 1, 0, 0, 0, 11046, 11047, 7, 125, 0, + 0, 11047, 1105, 1, 0, 0, 0, 11048, 11049, 5, 2308, 0, 0, 11049, 11050, + 5, 919, 0, 0, 11050, 11055, 5, 2362, 0, 0, 11051, 11052, 5, 2447, 0, 0, + 11052, 11053, 3, 966, 483, 0, 11053, 11054, 5, 2448, 0, 0, 11054, 11056, + 1, 0, 0, 0, 11055, 11051, 1, 0, 0, 0, 11055, 11056, 1, 0, 0, 0, 11056, + 11061, 1, 0, 0, 0, 11057, 11058, 5, 2306, 0, 0, 11058, 11059, 5, 919, 0, + 0, 11059, 11061, 5, 2362, 0, 0, 11060, 11048, 1, 0, 0, 0, 11060, 11057, + 1, 0, 0, 0, 11061, 1107, 1, 0, 0, 0, 11062, 11063, 5, 429, 0, 0, 11063, + 11064, 5, 885, 0, 0, 11064, 11082, 5, 1563, 0, 0, 11065, 11066, 5, 499, + 0, 0, 11066, 11067, 5, 885, 0, 0, 11067, 11079, 5, 1563, 0, 0, 11068, 11072, + 5, 38, 0, 0, 11069, 11070, 5, 40, 0, 0, 11070, 11072, 5, 1215, 0, 0, 11071, + 11068, 1, 0, 0, 0, 11071, 11069, 1, 0, 0, 0, 11072, 11073, 1, 0, 0, 0, + 11073, 11080, 5, 819, 0, 0, 11074, 11076, 5, 1137, 0, 0, 11075, 11074, + 1, 0, 0, 0, 11075, 11076, 1, 0, 0, 0, 11076, 11077, 1, 0, 0, 0, 11077, + 11078, 5, 1344, 0, 0, 11078, 11080, 5, 801, 0, 0, 11079, 11071, 1, 0, 0, + 0, 11079, 11075, 1, 0, 0, 0, 11079, 11080, 1, 0, 0, 0, 11080, 11082, 1, + 0, 0, 0, 11081, 11062, 1, 0, 0, 0, 11081, 11065, 1, 0, 0, 0, 11082, 1109, + 1, 0, 0, 0, 11083, 11084, 3, 2402, 1201, 0, 11084, 1111, 1, 0, 0, 0, 11085, + 11092, 3, 852, 426, 0, 11086, 11092, 3, 850, 425, 0, 11087, 11092, 3, 1670, + 835, 0, 11088, 11092, 3, 1680, 840, 0, 11089, 11092, 3, 1664, 832, 0, 11090, + 11092, 3, 1698, 849, 0, 11091, 11085, 1, 0, 0, 0, 11091, 11086, 1, 0, 0, + 0, 11091, 11087, 1, 0, 0, 0, 11091, 11088, 1, 0, 0, 0, 11091, 11089, 1, + 0, 0, 0, 11091, 11090, 1, 0, 0, 0, 11092, 1113, 1, 0, 0, 0, 11093, 11102, + 3, 1116, 558, 0, 11094, 11102, 3, 1118, 559, 0, 11095, 11102, 3, 1120, + 560, 0, 11096, 11102, 3, 1128, 564, 0, 11097, 11102, 3, 1130, 565, 0, 11098, + 11102, 3, 1132, 566, 0, 11099, 11102, 3, 1134, 567, 0, 11100, 11102, 3, + 1138, 569, 0, 11101, 11093, 1, 0, 0, 0, 11101, 11094, 1, 0, 0, 0, 11101, + 11095, 1, 0, 0, 0, 11101, 11096, 1, 0, 0, 0, 11101, 11097, 1, 0, 0, 0, + 11101, 11098, 1, 0, 0, 0, 11101, 11099, 1, 0, 0, 0, 11101, 11100, 1, 0, + 0, 0, 11102, 1115, 1, 0, 0, 0, 11103, 11104, 5, 1348, 0, 0, 11104, 11105, + 5, 160, 0, 0, 11105, 11106, 5, 1495, 0, 0, 11106, 11107, 5, 2447, 0, 0, + 11107, 11112, 3, 2340, 1170, 0, 11108, 11109, 5, 2453, 0, 0, 11109, 11111, + 3, 2340, 1170, 0, 11110, 11108, 1, 0, 0, 0, 11111, 11114, 1, 0, 0, 0, 11112, + 11110, 1, 0, 0, 0, 11112, 11113, 1, 0, 0, 0, 11113, 11115, 1, 0, 0, 0, + 11114, 11112, 1, 0, 0, 0, 11115, 11135, 5, 2448, 0, 0, 11116, 11117, 5, + 776, 0, 0, 11117, 11118, 5, 2447, 0, 0, 11118, 11119, 3, 2078, 1039, 0, + 11119, 11133, 5, 2448, 0, 0, 11120, 11121, 5, 1763, 0, 0, 11121, 11122, + 5, 738, 0, 0, 11122, 11123, 5, 2447, 0, 0, 11123, 11128, 3, 1656, 828, + 0, 11124, 11125, 5, 2453, 0, 0, 11125, 11127, 3, 1656, 828, 0, 11126, 11124, + 1, 0, 0, 0, 11127, 11130, 1, 0, 0, 0, 11128, 11126, 1, 0, 0, 0, 11128, + 11129, 1, 0, 0, 0, 11129, 11131, 1, 0, 0, 0, 11130, 11128, 1, 0, 0, 0, + 11131, 11132, 5, 2448, 0, 0, 11132, 11134, 1, 0, 0, 0, 11133, 11120, 1, + 0, 0, 0, 11133, 11134, 1, 0, 0, 0, 11134, 11136, 1, 0, 0, 0, 11135, 11116, + 1, 0, 0, 0, 11135, 11136, 1, 0, 0, 0, 11136, 11137, 1, 0, 0, 0, 11137, + 11138, 5, 2447, 0, 0, 11138, 11140, 5, 1348, 0, 0, 11139, 11141, 3, 1696, + 848, 0, 11140, 11139, 1, 0, 0, 0, 11140, 11141, 1, 0, 0, 0, 11141, 11142, + 1, 0, 0, 0, 11142, 11143, 3, 1164, 582, 0, 11143, 11154, 3, 1170, 585, + 0, 11144, 11145, 5, 2453, 0, 0, 11145, 11147, 5, 1348, 0, 0, 11146, 11148, + 3, 1696, 848, 0, 11147, 11146, 1, 0, 0, 0, 11147, 11148, 1, 0, 0, 0, 11148, + 11149, 1, 0, 0, 0, 11149, 11150, 3, 1164, 582, 0, 11150, 11151, 3, 1170, + 585, 0, 11151, 11153, 1, 0, 0, 0, 11152, 11144, 1, 0, 0, 0, 11153, 11156, + 1, 0, 0, 0, 11154, 11152, 1, 0, 0, 0, 11154, 11155, 1, 0, 0, 0, 11155, + 11157, 1, 0, 0, 0, 11156, 11154, 1, 0, 0, 0, 11157, 11158, 5, 2448, 0, + 0, 11158, 1117, 1, 0, 0, 0, 11159, 11160, 5, 1348, 0, 0, 11160, 11161, + 5, 160, 0, 0, 11161, 11162, 5, 862, 0, 0, 11162, 11163, 5, 2447, 0, 0, + 11163, 11164, 3, 2340, 1170, 0, 11164, 11181, 5, 2448, 0, 0, 11165, 11179, + 5, 95, 0, 0, 11166, 11167, 5, 1763, 0, 0, 11167, 11168, 5, 738, 0, 0, 11168, + 11169, 5, 2447, 0, 0, 11169, 11174, 3, 1656, 828, 0, 11170, 11171, 5, 2453, + 0, 0, 11171, 11173, 3, 1656, 828, 0, 11172, 11170, 1, 0, 0, 0, 11173, 11176, + 1, 0, 0, 0, 11174, 11172, 1, 0, 0, 0, 11174, 11175, 1, 0, 0, 0, 11175, + 11177, 1, 0, 0, 0, 11176, 11174, 1, 0, 0, 0, 11177, 11178, 5, 2448, 0, + 0, 11178, 11180, 1, 0, 0, 0, 11179, 11166, 1, 0, 0, 0, 11179, 11180, 1, + 0, 0, 0, 11180, 11182, 1, 0, 0, 0, 11181, 11165, 1, 0, 0, 0, 11181, 11182, + 1, 0, 0, 0, 11182, 11205, 1, 0, 0, 0, 11183, 11184, 5, 2447, 0, 0, 11184, + 11186, 5, 1348, 0, 0, 11185, 11187, 3, 1696, 848, 0, 11186, 11185, 1, 0, + 0, 0, 11186, 11187, 1, 0, 0, 0, 11187, 11188, 1, 0, 0, 0, 11188, 11189, + 3, 1168, 584, 0, 11189, 11200, 3, 1170, 585, 0, 11190, 11191, 5, 2453, + 0, 0, 11191, 11193, 5, 1348, 0, 0, 11192, 11194, 3, 1696, 848, 0, 11193, + 11192, 1, 0, 0, 0, 11193, 11194, 1, 0, 0, 0, 11194, 11195, 1, 0, 0, 0, + 11195, 11196, 3, 1168, 584, 0, 11196, 11197, 3, 1170, 585, 0, 11197, 11199, + 1, 0, 0, 0, 11198, 11190, 1, 0, 0, 0, 11199, 11202, 1, 0, 0, 0, 11200, + 11198, 1, 0, 0, 0, 11200, 11201, 1, 0, 0, 0, 11201, 11203, 1, 0, 0, 0, + 11202, 11200, 1, 0, 0, 0, 11203, 11204, 5, 2448, 0, 0, 11204, 11206, 1, + 0, 0, 0, 11205, 11183, 1, 0, 0, 0, 11205, 11206, 1, 0, 0, 0, 11206, 1119, + 1, 0, 0, 0, 11207, 11208, 5, 1348, 0, 0, 11208, 11209, 5, 160, 0, 0, 11209, + 11210, 5, 660, 0, 0, 11210, 11211, 5, 2447, 0, 0, 11211, 11216, 3, 2340, + 1170, 0, 11212, 11213, 5, 2453, 0, 0, 11213, 11215, 3, 2340, 1170, 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, 11222, 5, 2448, 0, 0, 11220, 11223, 3, 1122, 561, 0, 11221, + 11223, 3, 1124, 562, 0, 11222, 11220, 1, 0, 0, 0, 11222, 11221, 1, 0, 0, + 0, 11223, 1121, 1, 0, 0, 0, 11224, 11225, 5, 2447, 0, 0, 11225, 11227, + 5, 1348, 0, 0, 11226, 11228, 3, 1696, 848, 0, 11227, 11226, 1, 0, 0, 0, + 11227, 11228, 1, 0, 0, 0, 11228, 11230, 1, 0, 0, 0, 11229, 11231, 3, 1172, + 586, 0, 11230, 11229, 1, 0, 0, 0, 11230, 11231, 1, 0, 0, 0, 11231, 11242, + 1, 0, 0, 0, 11232, 11233, 5, 2453, 0, 0, 11233, 11235, 5, 1348, 0, 0, 11234, + 11236, 3, 1696, 848, 0, 11235, 11234, 1, 0, 0, 0, 11235, 11236, 1, 0, 0, + 0, 11236, 11238, 1, 0, 0, 0, 11237, 11239, 3, 1172, 586, 0, 11238, 11237, + 1, 0, 0, 0, 11238, 11239, 1, 0, 0, 0, 11239, 11241, 1, 0, 0, 0, 11240, + 11232, 1, 0, 0, 0, 11241, 11244, 1, 0, 0, 0, 11242, 11240, 1, 0, 0, 0, + 11242, 11243, 1, 0, 0, 0, 11243, 11245, 1, 0, 0, 0, 11244, 11242, 1, 0, + 0, 0, 11245, 11246, 5, 2448, 0, 0, 11246, 1123, 1, 0, 0, 0, 11247, 11248, + 5, 1350, 0, 0, 11248, 11262, 3, 1126, 563, 0, 11249, 11250, 5, 1763, 0, + 0, 11250, 11251, 5, 738, 0, 0, 11251, 11252, 5, 2447, 0, 0, 11252, 11257, + 3, 1656, 828, 0, 11253, 11254, 5, 2453, 0, 0, 11254, 11256, 3, 1656, 828, + 0, 11255, 11253, 1, 0, 0, 0, 11256, 11259, 1, 0, 0, 0, 11257, 11255, 1, + 0, 0, 0, 11257, 11258, 1, 0, 0, 0, 11258, 11260, 1, 0, 0, 0, 11259, 11257, + 1, 0, 0, 0, 11260, 11261, 5, 2448, 0, 0, 11261, 11263, 1, 0, 0, 0, 11262, + 11249, 1, 0, 0, 0, 11262, 11263, 1, 0, 0, 0, 11263, 11266, 1, 0, 0, 0, + 11264, 11267, 3, 1178, 589, 0, 11265, 11267, 3, 1600, 800, 0, 11266, 11264, + 1, 0, 0, 0, 11266, 11265, 1, 0, 0, 0, 11266, 11267, 1, 0, 0, 0, 11267, + 11282, 1, 0, 0, 0, 11268, 11269, 5, 1320, 0, 0, 11269, 11270, 5, 1763, + 0, 0, 11270, 11271, 5, 738, 0, 0, 11271, 11272, 5, 2447, 0, 0, 11272, 11277, + 3, 1656, 828, 0, 11273, 11274, 5, 2453, 0, 0, 11274, 11276, 3, 1656, 828, + 0, 11275, 11273, 1, 0, 0, 0, 11276, 11279, 1, 0, 0, 0, 11277, 11275, 1, + 0, 0, 0, 11277, 11278, 1, 0, 0, 0, 11278, 11280, 1, 0, 0, 0, 11279, 11277, + 1, 0, 0, 0, 11280, 11281, 5, 2448, 0, 0, 11281, 11283, 1, 0, 0, 0, 11282, + 11268, 1, 0, 0, 0, 11282, 11283, 1, 0, 0, 0, 11283, 1125, 1, 0, 0, 0, 11284, + 11285, 5, 2441, 0, 0, 11285, 1127, 1, 0, 0, 0, 11286, 11287, 5, 1348, 0, + 0, 11287, 11288, 5, 160, 0, 0, 11288, 11289, 5, 1495, 0, 0, 11289, 11290, + 5, 2447, 0, 0, 11290, 11295, 3, 2340, 1170, 0, 11291, 11292, 5, 2453, 0, + 0, 11292, 11294, 3, 2340, 1170, 0, 11293, 11291, 1, 0, 0, 0, 11294, 11297, + 1, 0, 0, 0, 11295, 11293, 1, 0, 0, 0, 11295, 11296, 1, 0, 0, 0, 11296, + 11298, 1, 0, 0, 0, 11297, 11295, 1, 0, 0, 0, 11298, 11318, 5, 2448, 0, + 0, 11299, 11300, 5, 776, 0, 0, 11300, 11301, 5, 2447, 0, 0, 11301, 11302, + 3, 2078, 1039, 0, 11302, 11316, 5, 2448, 0, 0, 11303, 11304, 5, 1763, 0, + 0, 11304, 11305, 5, 738, 0, 0, 11305, 11306, 5, 2447, 0, 0, 11306, 11311, + 3, 1656, 828, 0, 11307, 11308, 5, 2453, 0, 0, 11308, 11310, 3, 1656, 828, + 0, 11309, 11307, 1, 0, 0, 0, 11310, 11313, 1, 0, 0, 0, 11311, 11309, 1, + 0, 0, 0, 11311, 11312, 1, 0, 0, 0, 11312, 11314, 1, 0, 0, 0, 11313, 11311, + 1, 0, 0, 0, 11314, 11315, 5, 2448, 0, 0, 11315, 11317, 1, 0, 0, 0, 11316, + 11303, 1, 0, 0, 0, 11316, 11317, 1, 0, 0, 0, 11317, 11319, 1, 0, 0, 0, + 11318, 11299, 1, 0, 0, 0, 11318, 11319, 1, 0, 0, 0, 11319, 11323, 1, 0, + 0, 0, 11320, 11324, 3, 1148, 574, 0, 11321, 11324, 3, 1150, 575, 0, 11322, + 11324, 3, 1152, 576, 0, 11323, 11320, 1, 0, 0, 0, 11323, 11321, 1, 0, 0, + 0, 11323, 11322, 1, 0, 0, 0, 11324, 11325, 1, 0, 0, 0, 11325, 11326, 5, + 2447, 0, 0, 11326, 11331, 3, 1140, 570, 0, 11327, 11328, 5, 2453, 0, 0, + 11328, 11330, 3, 1140, 570, 0, 11329, 11327, 1, 0, 0, 0, 11330, 11333, + 1, 0, 0, 0, 11331, 11329, 1, 0, 0, 0, 11331, 11332, 1, 0, 0, 0, 11332, + 11334, 1, 0, 0, 0, 11333, 11331, 1, 0, 0, 0, 11334, 11335, 5, 2448, 0, + 0, 11335, 1129, 1, 0, 0, 0, 11336, 11337, 5, 1348, 0, 0, 11337, 11338, + 5, 160, 0, 0, 11338, 11339, 5, 862, 0, 0, 11339, 11340, 5, 2447, 0, 0, + 11340, 11341, 3, 2340, 1170, 0, 11341, 11345, 5, 2448, 0, 0, 11342, 11346, + 3, 1148, 574, 0, 11343, 11346, 3, 1150, 575, 0, 11344, 11346, 3, 1152, + 576, 0, 11345, 11342, 1, 0, 0, 0, 11345, 11343, 1, 0, 0, 0, 11345, 11344, + 1, 0, 0, 0, 11346, 11347, 1, 0, 0, 0, 11347, 11348, 5, 2447, 0, 0, 11348, + 11353, 3, 1142, 571, 0, 11349, 11350, 5, 2453, 0, 0, 11350, 11352, 3, 1142, + 571, 0, 11351, 11349, 1, 0, 0, 0, 11352, 11355, 1, 0, 0, 0, 11353, 11351, + 1, 0, 0, 0, 11353, 11354, 1, 0, 0, 0, 11354, 11356, 1, 0, 0, 0, 11355, + 11353, 1, 0, 0, 0, 11356, 11357, 5, 2448, 0, 0, 11357, 1131, 1, 0, 0, 0, + 11358, 11359, 5, 1348, 0, 0, 11359, 11360, 5, 160, 0, 0, 11360, 11361, + 5, 660, 0, 0, 11361, 11364, 5, 2447, 0, 0, 11362, 11363, 5, 2453, 0, 0, + 11363, 11365, 3, 2340, 1170, 0, 11364, 11362, 1, 0, 0, 0, 11365, 11366, + 1, 0, 0, 0, 11366, 11364, 1, 0, 0, 0, 11366, 11367, 1, 0, 0, 0, 11367, + 11368, 1, 0, 0, 0, 11368, 11372, 5, 2448, 0, 0, 11369, 11373, 3, 1148, + 574, 0, 11370, 11373, 3, 1150, 575, 0, 11371, 11373, 3, 1152, 576, 0, 11372, + 11369, 1, 0, 0, 0, 11372, 11370, 1, 0, 0, 0, 11372, 11371, 1, 0, 0, 0, + 11373, 11376, 1, 0, 0, 0, 11374, 11377, 3, 1122, 561, 0, 11375, 11377, + 3, 1124, 562, 0, 11376, 11374, 1, 0, 0, 0, 11376, 11375, 1, 0, 0, 0, 11377, + 1133, 1, 0, 0, 0, 11378, 11379, 5, 1348, 0, 0, 11379, 11380, 5, 160, 0, + 0, 11380, 11381, 5, 1527, 0, 0, 11381, 11382, 5, 2447, 0, 0, 11382, 11383, + 3, 2310, 1155, 0, 11383, 11395, 5, 2448, 0, 0, 11384, 11385, 5, 2447, 0, + 0, 11385, 11390, 3, 1136, 568, 0, 11386, 11387, 5, 2453, 0, 0, 11387, 11389, + 3, 1136, 568, 0, 11388, 11386, 1, 0, 0, 0, 11389, 11392, 1, 0, 0, 0, 11390, + 11388, 1, 0, 0, 0, 11390, 11391, 1, 0, 0, 0, 11391, 11393, 1, 0, 0, 0, + 11392, 11390, 1, 0, 0, 0, 11393, 11394, 5, 2448, 0, 0, 11394, 11396, 1, + 0, 0, 0, 11395, 11384, 1, 0, 0, 0, 11395, 11396, 1, 0, 0, 0, 11396, 1135, + 1, 0, 0, 0, 11397, 11399, 5, 1348, 0, 0, 11398, 11400, 3, 1696, 848, 0, + 11399, 11398, 1, 0, 0, 0, 11399, 11400, 1, 0, 0, 0, 11400, 11401, 1, 0, + 0, 0, 11401, 11402, 3, 1170, 585, 0, 11402, 1137, 1, 0, 0, 0, 11403, 11404, + 5, 1348, 0, 0, 11404, 11405, 5, 160, 0, 0, 11405, 11416, 5, 1949, 0, 0, + 11406, 11407, 5, 1350, 0, 0, 11407, 11417, 5, 2441, 0, 0, 11408, 11413, + 3, 1136, 568, 0, 11409, 11410, 5, 2453, 0, 0, 11410, 11412, 3, 1136, 568, + 0, 11411, 11409, 1, 0, 0, 0, 11412, 11415, 1, 0, 0, 0, 11413, 11411, 1, + 0, 0, 0, 11413, 11414, 1, 0, 0, 0, 11414, 11417, 1, 0, 0, 0, 11415, 11413, + 1, 0, 0, 0, 11416, 11406, 1, 0, 0, 0, 11416, 11408, 1, 0, 0, 0, 11416, + 11417, 1, 0, 0, 0, 11417, 1139, 1, 0, 0, 0, 11418, 11420, 5, 1348, 0, 0, + 11419, 11421, 3, 1696, 848, 0, 11420, 11419, 1, 0, 0, 0, 11420, 11421, + 1, 0, 0, 0, 11421, 11423, 1, 0, 0, 0, 11422, 11424, 3, 1164, 582, 0, 11423, + 11422, 1, 0, 0, 0, 11423, 11424, 1, 0, 0, 0, 11424, 11425, 1, 0, 0, 0, + 11425, 11458, 3, 1170, 585, 0, 11426, 11451, 5, 2447, 0, 0, 11427, 11432, + 3, 1156, 578, 0, 11428, 11429, 5, 2453, 0, 0, 11429, 11431, 3, 1156, 578, + 0, 11430, 11428, 1, 0, 0, 0, 11431, 11434, 1, 0, 0, 0, 11432, 11430, 1, + 0, 0, 0, 11432, 11433, 1, 0, 0, 0, 11433, 11452, 1, 0, 0, 0, 11434, 11432, + 1, 0, 0, 0, 11435, 11440, 3, 1158, 579, 0, 11436, 11437, 5, 2453, 0, 0, + 11437, 11439, 3, 1158, 579, 0, 11438, 11436, 1, 0, 0, 0, 11439, 11442, + 1, 0, 0, 0, 11440, 11438, 1, 0, 0, 0, 11440, 11441, 1, 0, 0, 0, 11441, + 11452, 1, 0, 0, 0, 11442, 11440, 1, 0, 0, 0, 11443, 11448, 3, 1160, 580, + 0, 11444, 11445, 5, 2453, 0, 0, 11445, 11447, 3, 1160, 580, 0, 11446, 11444, + 1, 0, 0, 0, 11447, 11450, 1, 0, 0, 0, 11448, 11446, 1, 0, 0, 0, 11448, + 11449, 1, 0, 0, 0, 11449, 11452, 1, 0, 0, 0, 11450, 11448, 1, 0, 0, 0, + 11451, 11427, 1, 0, 0, 0, 11451, 11435, 1, 0, 0, 0, 11451, 11443, 1, 0, + 0, 0, 11452, 11453, 1, 0, 0, 0, 11453, 11454, 5, 2448, 0, 0, 11454, 11457, + 1, 0, 0, 0, 11455, 11457, 3, 1162, 581, 0, 11456, 11426, 1, 0, 0, 0, 11456, + 11455, 1, 0, 0, 0, 11457, 11459, 1, 0, 0, 0, 11458, 11456, 1, 0, 0, 0, + 11458, 11459, 1, 0, 0, 0, 11459, 1141, 1, 0, 0, 0, 11460, 11462, 5, 1348, + 0, 0, 11461, 11463, 3, 1696, 848, 0, 11462, 11461, 1, 0, 0, 0, 11462, 11463, + 1, 0, 0, 0, 11463, 11465, 1, 0, 0, 0, 11464, 11466, 3, 1168, 584, 0, 11465, + 11464, 1, 0, 0, 0, 11465, 11466, 1, 0, 0, 0, 11466, 11467, 1, 0, 0, 0, + 11467, 11500, 3, 1170, 585, 0, 11468, 11493, 5, 2447, 0, 0, 11469, 11474, + 3, 1156, 578, 0, 11470, 11471, 5, 2453, 0, 0, 11471, 11473, 3, 1156, 578, + 0, 11472, 11470, 1, 0, 0, 0, 11473, 11476, 1, 0, 0, 0, 11474, 11472, 1, + 0, 0, 0, 11474, 11475, 1, 0, 0, 0, 11475, 11494, 1, 0, 0, 0, 11476, 11474, + 1, 0, 0, 0, 11477, 11482, 3, 1158, 579, 0, 11478, 11479, 5, 2453, 0, 0, + 11479, 11481, 3, 1158, 579, 0, 11480, 11478, 1, 0, 0, 0, 11481, 11484, + 1, 0, 0, 0, 11482, 11480, 1, 0, 0, 0, 11482, 11483, 1, 0, 0, 0, 11483, + 11494, 1, 0, 0, 0, 11484, 11482, 1, 0, 0, 0, 11485, 11490, 3, 1160, 580, + 0, 11486, 11487, 5, 2453, 0, 0, 11487, 11489, 3, 1160, 580, 0, 11488, 11486, + 1, 0, 0, 0, 11489, 11492, 1, 0, 0, 0, 11490, 11488, 1, 0, 0, 0, 11490, + 11491, 1, 0, 0, 0, 11491, 11494, 1, 0, 0, 0, 11492, 11490, 1, 0, 0, 0, + 11493, 11469, 1, 0, 0, 0, 11493, 11477, 1, 0, 0, 0, 11493, 11485, 1, 0, + 0, 0, 11494, 11495, 1, 0, 0, 0, 11495, 11496, 5, 2448, 0, 0, 11496, 11499, + 1, 0, 0, 0, 11497, 11499, 3, 1162, 581, 0, 11498, 11468, 1, 0, 0, 0, 11498, + 11497, 1, 0, 0, 0, 11499, 11501, 1, 0, 0, 0, 11500, 11498, 1, 0, 0, 0, + 11500, 11501, 1, 0, 0, 0, 11501, 1143, 1, 0, 0, 0, 11502, 11503, 5, 1775, + 0, 0, 11503, 11534, 5, 2090, 0, 0, 11504, 11529, 5, 2447, 0, 0, 11505, + 11510, 3, 1156, 578, 0, 11506, 11507, 5, 2453, 0, 0, 11507, 11509, 3, 1156, + 578, 0, 11508, 11506, 1, 0, 0, 0, 11509, 11512, 1, 0, 0, 0, 11510, 11508, + 1, 0, 0, 0, 11510, 11511, 1, 0, 0, 0, 11511, 11530, 1, 0, 0, 0, 11512, + 11510, 1, 0, 0, 0, 11513, 11518, 3, 1158, 579, 0, 11514, 11515, 5, 2453, + 0, 0, 11515, 11517, 3, 1158, 579, 0, 11516, 11514, 1, 0, 0, 0, 11517, 11520, + 1, 0, 0, 0, 11518, 11516, 1, 0, 0, 0, 11518, 11519, 1, 0, 0, 0, 11519, + 11530, 1, 0, 0, 0, 11520, 11518, 1, 0, 0, 0, 11521, 11526, 3, 1160, 580, + 0, 11522, 11523, 5, 2453, 0, 0, 11523, 11525, 3, 1160, 580, 0, 11524, 11522, + 1, 0, 0, 0, 11525, 11528, 1, 0, 0, 0, 11526, 11524, 1, 0, 0, 0, 11526, + 11527, 1, 0, 0, 0, 11527, 11530, 1, 0, 0, 0, 11528, 11526, 1, 0, 0, 0, + 11529, 11505, 1, 0, 0, 0, 11529, 11513, 1, 0, 0, 0, 11529, 11521, 1, 0, + 0, 0, 11530, 11531, 1, 0, 0, 0, 11531, 11532, 5, 2448, 0, 0, 11532, 11535, + 1, 0, 0, 0, 11533, 11535, 3, 1146, 573, 0, 11534, 11504, 1, 0, 0, 0, 11534, + 11533, 1, 0, 0, 0, 11535, 1145, 1, 0, 0, 0, 11536, 11537, 5, 2441, 0, 0, + 11537, 1147, 1, 0, 0, 0, 11538, 11539, 5, 1775, 0, 0, 11539, 11540, 5, + 160, 0, 0, 11540, 11541, 5, 1495, 0, 0, 11541, 11542, 5, 2447, 0, 0, 11542, + 11547, 3, 2340, 1170, 0, 11543, 11544, 5, 2453, 0, 0, 11544, 11546, 3, + 2340, 1170, 0, 11545, 11543, 1, 0, 0, 0, 11546, 11549, 1, 0, 0, 0, 11547, + 11545, 1, 0, 0, 0, 11547, 11548, 1, 0, 0, 0, 11548, 11550, 1, 0, 0, 0, + 11549, 11547, 1, 0, 0, 0, 11550, 11552, 5, 2448, 0, 0, 11551, 11553, 3, + 1144, 572, 0, 11552, 11551, 1, 0, 0, 0, 11552, 11553, 1, 0, 0, 0, 11553, + 1149, 1, 0, 0, 0, 11554, 11555, 5, 1775, 0, 0, 11555, 11556, 5, 160, 0, + 0, 11556, 11557, 5, 862, 0, 0, 11557, 11558, 5, 2447, 0, 0, 11558, 11559, + 3, 2340, 1170, 0, 11559, 11561, 5, 2448, 0, 0, 11560, 11562, 3, 1144, 572, + 0, 11561, 11560, 1, 0, 0, 0, 11561, 11562, 1, 0, 0, 0, 11562, 1151, 1, + 0, 0, 0, 11563, 11564, 5, 1775, 0, 0, 11564, 11565, 5, 160, 0, 0, 11565, + 11566, 5, 660, 0, 0, 11566, 11567, 5, 2447, 0, 0, 11567, 11572, 3, 2340, + 1170, 0, 11568, 11569, 5, 2453, 0, 0, 11569, 11571, 3, 2340, 1170, 0, 11570, + 11568, 1, 0, 0, 0, 11571, 11574, 1, 0, 0, 0, 11572, 11570, 1, 0, 0, 0, + 11572, 11573, 1, 0, 0, 0, 11573, 11575, 1, 0, 0, 0, 11574, 11572, 1, 0, + 0, 0, 11575, 11594, 5, 2448, 0, 0, 11576, 11577, 5, 1774, 0, 0, 11577, + 11591, 5, 2441, 0, 0, 11578, 11579, 5, 1763, 0, 0, 11579, 11580, 5, 738, + 0, 0, 11580, 11581, 5, 2447, 0, 0, 11581, 11586, 3, 1656, 828, 0, 11582, + 11583, 5, 2453, 0, 0, 11583, 11585, 3, 1656, 828, 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, 11589, 1, 0, 0, 0, 11588, 11586, 1, 0, 0, 0, 11589, + 11590, 5, 2448, 0, 0, 11590, 11592, 1, 0, 0, 0, 11591, 11578, 1, 0, 0, + 0, 11591, 11592, 1, 0, 0, 0, 11592, 11595, 1, 0, 0, 0, 11593, 11595, 3, + 1144, 572, 0, 11594, 11576, 1, 0, 0, 0, 11594, 11593, 1, 0, 0, 0, 11594, + 11595, 1, 0, 0, 0, 11595, 1153, 1, 0, 0, 0, 11596, 11597, 3, 1696, 848, + 0, 11597, 1155, 1, 0, 0, 0, 11598, 11600, 5, 1775, 0, 0, 11599, 11601, + 3, 1154, 577, 0, 11600, 11599, 1, 0, 0, 0, 11600, 11601, 1, 0, 0, 0, 11601, + 11602, 1, 0, 0, 0, 11602, 11604, 3, 1164, 582, 0, 11603, 11605, 3, 1172, + 586, 0, 11604, 11603, 1, 0, 0, 0, 11604, 11605, 1, 0, 0, 0, 11605, 1157, + 1, 0, 0, 0, 11606, 11608, 5, 1775, 0, 0, 11607, 11609, 3, 1154, 577, 0, + 11608, 11607, 1, 0, 0, 0, 11608, 11609, 1, 0, 0, 0, 11609, 11610, 1, 0, + 0, 0, 11610, 11612, 3, 1168, 584, 0, 11611, 11613, 3, 1172, 586, 0, 11612, + 11611, 1, 0, 0, 0, 11612, 11613, 1, 0, 0, 0, 11613, 1159, 1, 0, 0, 0, 11614, + 11616, 5, 1775, 0, 0, 11615, 11617, 3, 1154, 577, 0, 11616, 11615, 1, 0, + 0, 0, 11616, 11617, 1, 0, 0, 0, 11617, 11619, 1, 0, 0, 0, 11618, 11620, + 3, 1172, 586, 0, 11619, 11618, 1, 0, 0, 0, 11619, 11620, 1, 0, 0, 0, 11620, + 1161, 1, 0, 0, 0, 11621, 11622, 5, 1774, 0, 0, 11622, 11636, 5, 2441, 0, + 0, 11623, 11624, 5, 1763, 0, 0, 11624, 11625, 5, 738, 0, 0, 11625, 11626, + 5, 2447, 0, 0, 11626, 11631, 3, 1656, 828, 0, 11627, 11628, 5, 2453, 0, + 0, 11628, 11630, 3, 1656, 828, 0, 11629, 11627, 1, 0, 0, 0, 11630, 11633, + 1, 0, 0, 0, 11631, 11629, 1, 0, 0, 0, 11631, 11632, 1, 0, 0, 0, 11632, + 11634, 1, 0, 0, 0, 11633, 11631, 1, 0, 0, 0, 11634, 11635, 5, 2448, 0, + 0, 11635, 11637, 1, 0, 0, 0, 11636, 11623, 1, 0, 0, 0, 11636, 11637, 1, + 0, 0, 0, 11637, 1163, 1, 0, 0, 0, 11638, 11639, 5, 2257, 0, 0, 11639, 11640, + 5, 845, 0, 0, 11640, 11641, 5, 2098, 0, 0, 11641, 11642, 5, 2447, 0, 0, + 11642, 11643, 3, 1166, 583, 0, 11643, 11644, 5, 2448, 0, 0, 11644, 1165, + 1, 0, 0, 0, 11645, 11650, 3, 2186, 1093, 0, 11646, 11647, 5, 2453, 0, 0, + 11647, 11649, 3, 2186, 1093, 0, 11648, 11646, 1, 0, 0, 0, 11649, 11652, + 1, 0, 0, 0, 11650, 11648, 1, 0, 0, 0, 11650, 11651, 1, 0, 0, 0, 11651, + 11664, 1, 0, 0, 0, 11652, 11650, 1, 0, 0, 0, 11653, 11654, 5, 2108, 0, + 0, 11654, 11660, 3, 2186, 1093, 0, 11655, 11656, 5, 2453, 0, 0, 11656, + 11657, 5, 2108, 0, 0, 11657, 11659, 3, 2186, 1093, 0, 11658, 11655, 1, + 0, 0, 0, 11659, 11662, 1, 0, 0, 0, 11660, 11658, 1, 0, 0, 0, 11660, 11661, + 1, 0, 0, 0, 11661, 11664, 1, 0, 0, 0, 11662, 11660, 1, 0, 0, 0, 11663, + 11645, 1, 0, 0, 0, 11663, 11653, 1, 0, 0, 0, 11664, 1167, 1, 0, 0, 0, 11665, + 11666, 5, 2257, 0, 0, 11666, 11686, 5, 2447, 0, 0, 11667, 11672, 3, 2186, + 1093, 0, 11668, 11669, 5, 2453, 0, 0, 11669, 11671, 3, 2186, 1093, 0, 11670, + 11668, 1, 0, 0, 0, 11671, 11674, 1, 0, 0, 0, 11672, 11670, 1, 0, 0, 0, + 11672, 11673, 1, 0, 0, 0, 11673, 11687, 1, 0, 0, 0, 11674, 11672, 1, 0, + 0, 0, 11675, 11676, 5, 2108, 0, 0, 11676, 11682, 3, 2186, 1093, 0, 11677, + 11678, 5, 2453, 0, 0, 11678, 11679, 5, 2108, 0, 0, 11679, 11681, 3, 2186, + 1093, 0, 11680, 11677, 1, 0, 0, 0, 11681, 11684, 1, 0, 0, 0, 11682, 11680, + 1, 0, 0, 0, 11682, 11683, 1, 0, 0, 0, 11683, 11687, 1, 0, 0, 0, 11684, + 11682, 1, 0, 0, 0, 11685, 11687, 5, 389, 0, 0, 11686, 11667, 1, 0, 0, 0, + 11686, 11675, 1, 0, 0, 0, 11686, 11685, 1, 0, 0, 0, 11687, 11688, 1, 0, + 0, 0, 11688, 11689, 5, 2448, 0, 0, 11689, 1169, 1, 0, 0, 0, 11690, 11692, + 7, 126, 0, 0, 11691, 11690, 1, 0, 0, 0, 11691, 11692, 1, 0, 0, 0, 11692, + 11694, 1, 0, 0, 0, 11693, 11695, 3, 1198, 599, 0, 11694, 11693, 1, 0, 0, + 0, 11694, 11695, 1, 0, 0, 0, 11695, 11697, 1, 0, 0, 0, 11696, 11698, 3, + 1086, 543, 0, 11697, 11696, 1, 0, 0, 0, 11697, 11698, 1, 0, 0, 0, 11698, + 11700, 1, 0, 0, 0, 11699, 11701, 3, 1088, 544, 0, 11700, 11699, 1, 0, 0, + 0, 11700, 11701, 1, 0, 0, 0, 11701, 11703, 1, 0, 0, 0, 11702, 11704, 3, + 1200, 600, 0, 11703, 11702, 1, 0, 0, 0, 11703, 11704, 1, 0, 0, 0, 11704, + 11707, 1, 0, 0, 0, 11705, 11708, 3, 1178, 589, 0, 11706, 11708, 3, 1600, + 800, 0, 11707, 11705, 1, 0, 0, 0, 11707, 11706, 1, 0, 0, 0, 11707, 11708, + 1, 0, 0, 0, 11708, 11710, 1, 0, 0, 0, 11709, 11711, 3, 1180, 590, 0, 11710, + 11709, 1, 0, 0, 0, 11710, 11711, 1, 0, 0, 0, 11711, 11713, 1, 0, 0, 0, + 11712, 11714, 3, 1204, 602, 0, 11713, 11712, 1, 0, 0, 0, 11713, 11714, + 1, 0, 0, 0, 11714, 11719, 1, 0, 0, 0, 11715, 11717, 5, 1320, 0, 0, 11716, + 11718, 3, 1200, 600, 0, 11717, 11716, 1, 0, 0, 0, 11717, 11718, 1, 0, 0, + 0, 11718, 11720, 1, 0, 0, 0, 11719, 11715, 1, 0, 0, 0, 11719, 11720, 1, + 0, 0, 0, 11720, 11726, 1, 0, 0, 0, 11721, 11725, 3, 1640, 820, 0, 11722, + 11725, 3, 1630, 815, 0, 11723, 11725, 3, 1690, 845, 0, 11724, 11721, 1, + 0, 0, 0, 11724, 11722, 1, 0, 0, 0, 11724, 11723, 1, 0, 0, 0, 11725, 11728, + 1, 0, 0, 0, 11726, 11724, 1, 0, 0, 0, 11726, 11727, 1, 0, 0, 0, 11727, + 1171, 1, 0, 0, 0, 11728, 11726, 1, 0, 0, 0, 11729, 11730, 5, 2080, 0, 0, + 11730, 11751, 3, 1656, 828, 0, 11731, 11734, 5, 1320, 0, 0, 11732, 11733, + 5, 2080, 0, 0, 11733, 11735, 3, 1656, 828, 0, 11734, 11732, 1, 0, 0, 0, + 11734, 11735, 1, 0, 0, 0, 11735, 11751, 1, 0, 0, 0, 11736, 11751, 3, 1178, + 589, 0, 11737, 11751, 3, 1600, 800, 0, 11738, 11751, 3, 1180, 590, 0, 11739, + 11751, 3, 1174, 587, 0, 11740, 11741, 5, 2267, 0, 0, 11741, 11742, 3, 1658, + 829, 0, 11742, 11743, 5, 1763, 0, 0, 11743, 11745, 5, 69, 0, 0, 11744, + 11746, 7, 122, 0, 0, 11745, 11744, 1, 0, 0, 0, 11745, 11746, 1, 0, 0, 0, + 11746, 11747, 1, 0, 0, 0, 11747, 11748, 5, 868, 0, 0, 11748, 11749, 3, + 1634, 817, 0, 11749, 11751, 1, 0, 0, 0, 11750, 11729, 1, 0, 0, 0, 11750, + 11731, 1, 0, 0, 0, 11750, 11736, 1, 0, 0, 0, 11750, 11737, 1, 0, 0, 0, + 11750, 11738, 1, 0, 0, 0, 11750, 11739, 1, 0, 0, 0, 11750, 11740, 1, 0, + 0, 0, 11751, 11752, 1, 0, 0, 0, 11752, 11750, 1, 0, 0, 0, 11752, 11753, + 1, 0, 0, 0, 11753, 1173, 1, 0, 0, 0, 11754, 11755, 5, 868, 0, 0, 11755, + 11756, 5, 2447, 0, 0, 11756, 11757, 3, 1636, 818, 0, 11757, 11758, 5, 2448, + 0, 0, 11758, 11759, 5, 1763, 0, 0, 11759, 11761, 5, 69, 0, 0, 11760, 11762, + 7, 122, 0, 0, 11761, 11760, 1, 0, 0, 0, 11761, 11762, 1, 0, 0, 0, 11762, + 11776, 1, 0, 0, 0, 11763, 11769, 3, 1634, 817, 0, 11764, 11765, 5, 2447, + 0, 0, 11765, 11766, 5, 2080, 0, 0, 11766, 11767, 3, 1656, 828, 0, 11767, + 11768, 5, 2448, 0, 0, 11768, 11770, 1, 0, 0, 0, 11769, 11764, 1, 0, 0, + 0, 11769, 11770, 1, 0, 0, 0, 11770, 11777, 1, 0, 0, 0, 11771, 11772, 5, + 2447, 0, 0, 11772, 11773, 5, 2080, 0, 0, 11773, 11774, 3, 1656, 828, 0, + 11774, 11775, 5, 2448, 0, 0, 11775, 11777, 1, 0, 0, 0, 11776, 11763, 1, + 0, 0, 0, 11776, 11771, 1, 0, 0, 0, 11777, 1175, 1, 0, 0, 0, 11778, 11780, + 5, 2441, 0, 0, 11779, 11781, 7, 127, 0, 0, 11780, 11779, 1, 0, 0, 0, 11780, + 11781, 1, 0, 0, 0, 11781, 1177, 1, 0, 0, 0, 11782, 11796, 5, 258, 0, 0, + 11783, 11797, 5, 106, 0, 0, 11784, 11794, 5, 620, 0, 0, 11785, 11795, 5, + 1253, 0, 0, 11786, 11788, 7, 128, 0, 0, 11787, 11789, 7, 105, 0, 0, 11788, + 11787, 1, 0, 0, 0, 11788, 11789, 1, 0, 0, 0, 11789, 11795, 1, 0, 0, 0, + 11790, 11791, 5, 38, 0, 0, 11791, 11795, 5, 1265, 0, 0, 11792, 11793, 5, + 425, 0, 0, 11793, 11795, 5, 1265, 0, 0, 11794, 11785, 1, 0, 0, 0, 11794, + 11786, 1, 0, 0, 0, 11794, 11790, 1, 0, 0, 0, 11794, 11792, 1, 0, 0, 0, + 11795, 11797, 1, 0, 0, 0, 11796, 11783, 1, 0, 0, 0, 11796, 11784, 1, 0, + 0, 0, 11796, 11797, 1, 0, 0, 0, 11797, 11824, 1, 0, 0, 0, 11798, 11799, + 5, 1606, 0, 0, 11799, 11800, 5, 1763, 0, 0, 11800, 11802, 5, 258, 0, 0, + 11801, 11803, 7, 129, 0, 0, 11802, 11801, 1, 0, 0, 0, 11802, 11803, 1, + 0, 0, 0, 11803, 11824, 1, 0, 0, 0, 11804, 11805, 5, 237, 0, 0, 11805, 11806, + 5, 1763, 0, 0, 11806, 11812, 5, 258, 0, 0, 11807, 11808, 5, 620, 0, 0, + 11808, 11810, 7, 128, 0, 0, 11809, 11811, 7, 105, 0, 0, 11810, 11809, 1, + 0, 0, 0, 11810, 11811, 1, 0, 0, 0, 11811, 11813, 1, 0, 0, 0, 11812, 11807, + 1, 0, 0, 0, 11812, 11813, 1, 0, 0, 0, 11813, 11820, 1, 0, 0, 0, 11814, + 11816, 5, 1137, 0, 0, 11815, 11814, 1, 0, 0, 0, 11815, 11816, 1, 0, 0, + 0, 11816, 11817, 1, 0, 0, 0, 11817, 11818, 5, 1606, 0, 0, 11818, 11819, + 5, 846, 0, 0, 11819, 11821, 5, 880, 0, 0, 11820, 11815, 1, 0, 0, 0, 11820, + 11821, 1, 0, 0, 0, 11821, 11824, 1, 0, 0, 0, 11822, 11824, 5, 1074, 0, + 0, 11823, 11782, 1, 0, 0, 0, 11823, 11798, 1, 0, 0, 0, 11823, 11804, 1, + 0, 0, 0, 11823, 11822, 1, 0, 0, 0, 11824, 1179, 1, 0, 0, 0, 11825, 11827, + 3, 1192, 596, 0, 11826, 11825, 1, 0, 0, 0, 11827, 11828, 1, 0, 0, 0, 11828, + 11826, 1, 0, 0, 0, 11828, 11829, 1, 0, 0, 0, 11829, 11845, 1, 0, 0, 0, + 11830, 11832, 5, 746, 0, 0, 11831, 11833, 3, 1182, 591, 0, 11832, 11831, + 1, 0, 0, 0, 11832, 11833, 1, 0, 0, 0, 11833, 11837, 1, 0, 0, 0, 11834, + 11835, 5, 1137, 0, 0, 11835, 11837, 5, 746, 0, 0, 11836, 11830, 1, 0, 0, + 0, 11836, 11834, 1, 0, 0, 0, 11837, 11841, 1, 0, 0, 0, 11838, 11840, 3, + 1192, 596, 0, 11839, 11838, 1, 0, 0, 0, 11840, 11843, 1, 0, 0, 0, 11841, + 11839, 1, 0, 0, 0, 11841, 11842, 1, 0, 0, 0, 11842, 11845, 1, 0, 0, 0, + 11843, 11841, 1, 0, 0, 0, 11844, 11826, 1, 0, 0, 0, 11844, 11836, 1, 0, + 0, 0, 11845, 1181, 1, 0, 0, 0, 11846, 11851, 3, 1184, 592, 0, 11847, 11851, + 3, 1186, 593, 0, 11848, 11851, 3, 1188, 594, 0, 11849, 11851, 3, 1190, + 595, 0, 11850, 11846, 1, 0, 0, 0, 11850, 11847, 1, 0, 0, 0, 11850, 11848, + 1, 0, 0, 0, 11850, 11849, 1, 0, 0, 0, 11851, 11852, 1, 0, 0, 0, 11852, + 11850, 1, 0, 0, 0, 11852, 11853, 1, 0, 0, 0, 11853, 1183, 1, 0, 0, 0, 11854, + 11855, 5, 941, 0, 0, 11855, 11861, 5, 620, 0, 0, 11856, 11862, 5, 449, + 0, 0, 11857, 11859, 7, 130, 0, 0, 11858, 11860, 7, 105, 0, 0, 11859, 11858, + 1, 0, 0, 0, 11859, 11860, 1, 0, 0, 0, 11860, 11862, 1, 0, 0, 0, 11861, + 11856, 1, 0, 0, 0, 11861, 11857, 1, 0, 0, 0, 11862, 11866, 1, 0, 0, 0, + 11863, 11864, 5, 1137, 0, 0, 11864, 11866, 5, 941, 0, 0, 11865, 11854, + 1, 0, 0, 0, 11865, 11863, 1, 0, 0, 0, 11866, 1185, 1, 0, 0, 0, 11867, 11868, + 5, 1453, 0, 0, 11868, 11869, 7, 131, 0, 0, 11869, 1187, 1, 0, 0, 0, 11870, + 11879, 5, 448, 0, 0, 11871, 11880, 5, 91, 0, 0, 11872, 11877, 5, 160, 0, + 0, 11873, 11874, 5, 1601, 0, 0, 11874, 11878, 5, 1495, 0, 0, 11875, 11878, + 5, 1348, 0, 0, 11876, 11878, 5, 1775, 0, 0, 11877, 11873, 1, 0, 0, 0, 11877, + 11875, 1, 0, 0, 0, 11877, 11876, 1, 0, 0, 0, 11878, 11880, 1, 0, 0, 0, + 11879, 11871, 1, 0, 0, 0, 11879, 11872, 1, 0, 0, 0, 11879, 11880, 1, 0, + 0, 0, 11880, 11889, 1, 0, 0, 0, 11881, 11882, 5, 620, 0, 0, 11882, 11887, + 5, 1664, 0, 0, 11883, 11888, 5, 389, 0, 0, 11884, 11888, 5, 38, 0, 0, 11885, + 11888, 3, 2402, 1201, 0, 11886, 11888, 5, 1133, 0, 0, 11887, 11883, 1, + 0, 0, 0, 11887, 11884, 1, 0, 0, 0, 11887, 11885, 1, 0, 0, 0, 11887, 11886, + 1, 0, 0, 0, 11888, 11890, 1, 0, 0, 0, 11889, 11881, 1, 0, 0, 0, 11889, + 11890, 1, 0, 0, 0, 11890, 1189, 1, 0, 0, 0, 11891, 11893, 5, 475, 0, 0, + 11892, 11894, 5, 38, 0, 0, 11893, 11892, 1, 0, 0, 0, 11893, 11894, 1, 0, + 0, 0, 11894, 11898, 1, 0, 0, 0, 11895, 11896, 5, 1137, 0, 0, 11896, 11898, + 5, 475, 0, 0, 11897, 11891, 1, 0, 0, 0, 11897, 11895, 1, 0, 0, 0, 11898, + 1191, 1, 0, 0, 0, 11899, 11901, 5, 746, 0, 0, 11900, 11902, 3, 1184, 592, + 0, 11901, 11900, 1, 0, 0, 0, 11901, 11902, 1, 0, 0, 0, 11902, 11906, 1, + 0, 0, 0, 11903, 11904, 5, 1137, 0, 0, 11904, 11906, 5, 746, 0, 0, 11905, + 11899, 1, 0, 0, 0, 11905, 11903, 1, 0, 0, 0, 11906, 11907, 1, 0, 0, 0, + 11907, 11908, 5, 2447, 0, 0, 11908, 11909, 3, 2358, 1179, 0, 11909, 11910, + 5, 2448, 0, 0, 11910, 1193, 1, 0, 0, 0, 11911, 11912, 5, 1369, 0, 0, 11912, + 11922, 5, 2441, 0, 0, 11913, 11914, 5, 1372, 0, 0, 11914, 11922, 5, 2441, + 0, 0, 11915, 11916, 5, 743, 0, 0, 11916, 11922, 5, 2441, 0, 0, 11917, 11918, + 5, 931, 0, 0, 11918, 11922, 5, 2441, 0, 0, 11919, 11922, 3, 1196, 598, + 0, 11920, 11922, 3, 678, 339, 0, 11921, 11911, 1, 0, 0, 0, 11921, 11913, + 1, 0, 0, 0, 11921, 11915, 1, 0, 0, 0, 11921, 11917, 1, 0, 0, 0, 11921, + 11919, 1, 0, 0, 0, 11921, 11920, 1, 0, 0, 0, 11922, 11923, 1, 0, 0, 0, + 11923, 11921, 1, 0, 0, 0, 11923, 11924, 1, 0, 0, 0, 11924, 1195, 1, 0, + 0, 0, 11925, 11926, 5, 1762, 0, 0, 11926, 11954, 5, 2447, 0, 0, 11927, + 11928, 5, 740, 0, 0, 11928, 11955, 3, 1176, 588, 0, 11929, 11930, 5, 1025, + 0, 0, 11930, 11955, 3, 1176, 588, 0, 11931, 11932, 5, 952, 0, 0, 11932, + 11955, 7, 132, 0, 0, 11933, 11934, 5, 923, 0, 0, 11934, 11955, 7, 132, + 0, 0, 11935, 11936, 5, 1370, 0, 0, 11936, 11955, 5, 2441, 0, 0, 11937, + 11938, 5, 625, 0, 0, 11938, 11955, 5, 2441, 0, 0, 11939, 11940, 5, 624, + 0, 0, 11940, 11941, 5, 653, 0, 0, 11941, 11955, 5, 2441, 0, 0, 11942, 11945, + 5, 1268, 0, 0, 11943, 11946, 3, 1176, 588, 0, 11944, 11946, 5, 1228, 0, + 0, 11945, 11943, 1, 0, 0, 0, 11945, 11944, 1, 0, 0, 0, 11946, 11955, 1, + 0, 0, 0, 11947, 11948, 5, 157, 0, 0, 11948, 11955, 7, 133, 0, 0, 11949, + 11950, 5, 606, 0, 0, 11950, 11955, 7, 134, 0, 0, 11951, 11952, 5, 186, + 0, 0, 11952, 11955, 7, 134, 0, 0, 11953, 11955, 5, 505, 0, 0, 11954, 11927, + 1, 0, 0, 0, 11954, 11929, 1, 0, 0, 0, 11954, 11931, 1, 0, 0, 0, 11954, + 11933, 1, 0, 0, 0, 11954, 11935, 1, 0, 0, 0, 11954, 11937, 1, 0, 0, 0, + 11954, 11939, 1, 0, 0, 0, 11954, 11942, 1, 0, 0, 0, 11954, 11947, 1, 0, + 0, 0, 11954, 11949, 1, 0, 0, 0, 11954, 11951, 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, 11958, 1, 0, 0, 0, 11958, 11959, 5, 2448, 0, + 0, 11959, 1197, 1, 0, 0, 0, 11960, 11961, 5, 1645, 0, 0, 11961, 11962, + 5, 324, 0, 0, 11962, 11963, 7, 69, 0, 0, 11963, 1199, 1, 0, 0, 0, 11964, + 11976, 3, 1194, 597, 0, 11965, 11971, 5, 2080, 0, 0, 11966, 11972, 3, 2404, + 1202, 0, 11967, 11969, 5, 1671, 0, 0, 11968, 11967, 1, 0, 0, 0, 11968, + 11969, 1, 0, 0, 0, 11969, 11970, 1, 0, 0, 0, 11970, 11972, 3, 2402, 1201, + 0, 11971, 11966, 1, 0, 0, 0, 11971, 11968, 1, 0, 0, 0, 11972, 11976, 1, + 0, 0, 0, 11973, 11976, 3, 1178, 589, 0, 11974, 11976, 3, 886, 443, 0, 11975, + 11964, 1, 0, 0, 0, 11975, 11965, 1, 0, 0, 0, 11975, 11973, 1, 0, 0, 0, + 11975, 11974, 1, 0, 0, 0, 11976, 11977, 1, 0, 0, 0, 11977, 11975, 1, 0, + 0, 0, 11977, 11978, 1, 0, 0, 0, 11978, 1201, 1, 0, 0, 0, 11979, 12023, + 3, 1198, 599, 0, 11980, 12023, 3, 1200, 600, 0, 11981, 12023, 3, 1178, + 589, 0, 11982, 12023, 3, 1180, 590, 0, 11983, 12023, 3, 1204, 602, 0, 11984, + 11999, 5, 1306, 0, 0, 11985, 11987, 5, 665, 0, 0, 11986, 11988, 3, 1200, + 600, 0, 11987, 11986, 1, 0, 0, 0, 11987, 11988, 1, 0, 0, 0, 11988, 11989, + 1, 0, 0, 0, 11989, 12000, 3, 1220, 610, 0, 11990, 11992, 5, 717, 0, 0, + 11991, 11993, 3, 1200, 600, 0, 11992, 11991, 1, 0, 0, 0, 11992, 11993, + 1, 0, 0, 0, 11993, 11995, 1, 0, 0, 0, 11994, 11996, 3, 1596, 798, 0, 11995, + 11994, 1, 0, 0, 0, 11995, 11996, 1, 0, 0, 0, 11996, 12000, 1, 0, 0, 0, + 11997, 11998, 5, 560, 0, 0, 11998, 12000, 3, 1222, 611, 0, 11999, 11985, + 1, 0, 0, 0, 11999, 11990, 1, 0, 0, 0, 11999, 11997, 1, 0, 0, 0, 12000, + 12023, 1, 0, 0, 0, 12001, 12002, 5, 560, 0, 0, 12002, 12003, 5, 1348, 0, + 0, 12003, 12004, 5, 84, 0, 0, 12004, 12007, 3, 1222, 611, 0, 12005, 12006, + 5, 1549, 0, 0, 12006, 12008, 5, 858, 0, 0, 12007, 12005, 1, 0, 0, 0, 12007, + 12008, 1, 0, 0, 0, 12008, 12023, 1, 0, 0, 0, 12009, 12010, 5, 220, 0, 0, + 12010, 12011, 3, 466, 233, 0, 12011, 12012, 5, 2447, 0, 0, 12012, 12017, + 3, 2340, 1170, 0, 12013, 12014, 5, 2453, 0, 0, 12014, 12016, 3, 2340, 1170, + 0, 12015, 12013, 1, 0, 0, 0, 12016, 12019, 1, 0, 0, 0, 12017, 12015, 1, + 0, 0, 0, 12017, 12018, 1, 0, 0, 0, 12018, 12020, 1, 0, 0, 0, 12019, 12017, + 1, 0, 0, 0, 12020, 12021, 5, 2448, 0, 0, 12021, 12023, 1, 0, 0, 0, 12022, + 11979, 1, 0, 0, 0, 12022, 11980, 1, 0, 0, 0, 12022, 11981, 1, 0, 0, 0, + 12022, 11982, 1, 0, 0, 0, 12022, 11983, 1, 0, 0, 0, 12022, 11984, 1, 0, + 0, 0, 12022, 12001, 1, 0, 0, 0, 12022, 12009, 1, 0, 0, 0, 12023, 1203, + 1, 0, 0, 0, 12024, 12034, 5, 697, 0, 0, 12025, 12026, 5, 21, 0, 0, 12026, + 12027, 5, 1412, 0, 0, 12027, 12035, 3, 1206, 603, 0, 12028, 12029, 7, 135, + 0, 0, 12029, 12030, 5, 1412, 0, 0, 12030, 12035, 3, 1206, 603, 0, 12031, + 12035, 5, 402, 0, 0, 12032, 12035, 5, 498, 0, 0, 12033, 12035, 5, 428, + 0, 0, 12034, 12025, 1, 0, 0, 0, 12034, 12028, 1, 0, 0, 0, 12034, 12031, + 1, 0, 0, 0, 12034, 12032, 1, 0, 0, 0, 12034, 12033, 1, 0, 0, 0, 12035, + 1205, 1, 0, 0, 0, 12036, 12040, 3, 1208, 604, 0, 12037, 12040, 3, 1210, + 605, 0, 12038, 12040, 3, 1216, 608, 0, 12039, 12036, 1, 0, 0, 0, 12039, + 12037, 1, 0, 0, 0, 12039, 12038, 1, 0, 0, 0, 12040, 1207, 1, 0, 0, 0, 12041, + 12042, 3, 1178, 589, 0, 12042, 12043, 3, 1214, 607, 0, 12043, 12044, 3, + 1212, 606, 0, 12044, 12061, 1, 0, 0, 0, 12045, 12046, 7, 136, 0, 0, 12046, + 12047, 5, 1763, 0, 0, 12047, 12051, 5, 258, 0, 0, 12048, 12052, 5, 29, + 0, 0, 12049, 12050, 5, 620, 0, 0, 12050, 12052, 5, 1484, 0, 0, 12051, 12048, + 1, 0, 0, 0, 12051, 12049, 1, 0, 0, 0, 12052, 12053, 1, 0, 0, 0, 12053, + 12054, 5, 1606, 0, 0, 12054, 12055, 5, 33, 0, 0, 12055, 12056, 3, 1218, + 609, 0, 12056, 12057, 5, 1246, 0, 0, 12057, 12058, 5, 1137, 0, 0, 12058, + 12059, 5, 978, 0, 0, 12059, 12061, 1, 0, 0, 0, 12060, 12041, 1, 0, 0, 0, + 12060, 12045, 1, 0, 0, 0, 12061, 1209, 1, 0, 0, 0, 12062, 12063, 5, 2104, + 0, 0, 12063, 12064, 5, 2141, 0, 0, 12064, 12078, 3, 1656, 828, 0, 12065, + 12067, 3, 1214, 607, 0, 12066, 12065, 1, 0, 0, 0, 12066, 12067, 1, 0, 0, + 0, 12067, 12070, 1, 0, 0, 0, 12068, 12069, 5, 1259, 0, 0, 12069, 12071, + 3, 2320, 1160, 0, 12070, 12068, 1, 0, 0, 0, 12070, 12071, 1, 0, 0, 0, 12071, + 12079, 1, 0, 0, 0, 12072, 12073, 5, 1505, 0, 0, 12073, 12075, 5, 1258, + 0, 0, 12074, 12076, 3, 1214, 607, 0, 12075, 12074, 1, 0, 0, 0, 12075, 12076, + 1, 0, 0, 0, 12076, 12077, 1, 0, 0, 0, 12077, 12079, 3, 1212, 606, 0, 12078, + 12066, 1, 0, 0, 0, 12078, 12072, 1, 0, 0, 0, 12079, 1211, 1, 0, 0, 0, 12080, + 12081, 5, 33, 0, 0, 12081, 12082, 3, 1218, 609, 0, 12082, 12086, 5, 1246, + 0, 0, 12083, 12084, 5, 1137, 0, 0, 12084, 12087, 7, 137, 0, 0, 12085, 12087, + 5, 324, 0, 0, 12086, 12083, 1, 0, 0, 0, 12086, 12085, 1, 0, 0, 0, 12087, + 12091, 1, 0, 0, 0, 12088, 12089, 5, 1259, 0, 0, 12089, 12091, 3, 2320, + 1160, 0, 12090, 12080, 1, 0, 0, 0, 12090, 12088, 1, 0, 0, 0, 12091, 1213, + 1, 0, 0, 0, 12092, 12093, 7, 138, 0, 0, 12093, 1215, 1, 0, 0, 0, 12094, + 12095, 5, 1671, 0, 0, 12095, 12097, 5, 746, 0, 0, 12096, 12098, 3, 1182, + 591, 0, 12097, 12096, 1, 0, 0, 0, 12097, 12098, 1, 0, 0, 0, 12098, 12105, + 1, 0, 0, 0, 12099, 12100, 5, 980, 0, 0, 12100, 12101, 5, 746, 0, 0, 12101, + 12105, 3, 1184, 592, 0, 12102, 12103, 5, 1137, 0, 0, 12103, 12105, 5, 746, + 0, 0, 12104, 12094, 1, 0, 0, 0, 12104, 12099, 1, 0, 0, 0, 12104, 12102, + 1, 0, 0, 0, 12105, 12107, 1, 0, 0, 0, 12106, 12108, 5, 1645, 0, 0, 12107, + 12106, 1, 0, 0, 0, 12107, 12108, 1, 0, 0, 0, 12108, 12109, 1, 0, 0, 0, + 12109, 12110, 3, 1212, 606, 0, 12110, 1217, 1, 0, 0, 0, 12111, 12112, 3, + 2396, 1198, 0, 12112, 12113, 7, 139, 0, 0, 12113, 1219, 1, 0, 0, 0, 12114, + 12116, 3, 1178, 589, 0, 12115, 12114, 1, 0, 0, 0, 12115, 12116, 1, 0, 0, + 0, 12116, 12118, 1, 0, 0, 0, 12117, 12119, 3, 1180, 590, 0, 12118, 12117, + 1, 0, 0, 0, 12118, 12119, 1, 0, 0, 0, 12119, 12121, 1, 0, 0, 0, 12120, + 12122, 3, 1204, 602, 0, 12121, 12120, 1, 0, 0, 0, 12121, 12122, 1, 0, 0, + 0, 12122, 1221, 1, 0, 0, 0, 12123, 12126, 5, 2447, 0, 0, 12124, 12125, + 5, 2166, 0, 0, 12125, 12127, 3, 1224, 612, 0, 12126, 12124, 1, 0, 0, 0, + 12126, 12127, 1, 0, 0, 0, 12127, 12128, 1, 0, 0, 0, 12128, 12129, 3, 1226, + 613, 0, 12129, 12131, 5, 2448, 0, 0, 12130, 12132, 3, 928, 464, 0, 12131, + 12130, 1, 0, 0, 0, 12131, 12132, 1, 0, 0, 0, 12132, 12139, 1, 0, 0, 0, + 12133, 12134, 5, 1549, 0, 0, 12134, 12137, 5, 858, 0, 0, 12135, 12138, + 3, 2396, 1198, 0, 12136, 12138, 5, 2185, 0, 0, 12137, 12135, 1, 0, 0, 0, + 12137, 12136, 1, 0, 0, 0, 12138, 12140, 1, 0, 0, 0, 12139, 12133, 1, 0, + 0, 0, 12139, 12140, 1, 0, 0, 0, 12140, 12142, 1, 0, 0, 0, 12141, 12143, + 3, 1180, 590, 0, 12142, 12141, 1, 0, 0, 0, 12142, 12143, 1, 0, 0, 0, 12143, + 1223, 1, 0, 0, 0, 12144, 12145, 7, 140, 0, 0, 12145, 1225, 1, 0, 0, 0, + 12146, 12147, 5, 389, 0, 0, 12147, 12148, 5, 426, 0, 0, 12148, 12150, 3, + 1270, 635, 0, 12149, 12146, 1, 0, 0, 0, 12149, 12150, 1, 0, 0, 0, 12150, + 12169, 1, 0, 0, 0, 12151, 12152, 5, 4, 0, 0, 12152, 12167, 5, 1335, 0, + 0, 12153, 12154, 5, 2447, 0, 0, 12154, 12155, 5, 2443, 0, 0, 12155, 12168, + 5, 2448, 0, 0, 12156, 12158, 5, 2447, 0, 0, 12157, 12159, 3, 1228, 614, + 0, 12158, 12157, 1, 0, 0, 0, 12159, 12160, 1, 0, 0, 0, 12160, 12158, 1, + 0, 0, 0, 12160, 12161, 1, 0, 0, 0, 12161, 12162, 1, 0, 0, 0, 12162, 12163, + 5, 2448, 0, 0, 12163, 12168, 1, 0, 0, 0, 12164, 12165, 5, 2246, 0, 0, 12165, + 12166, 5, 215, 0, 0, 12166, 12168, 3, 1868, 934, 0, 12167, 12153, 1, 0, + 0, 0, 12167, 12156, 1, 0, 0, 0, 12167, 12164, 1, 0, 0, 0, 12168, 12170, + 1, 0, 0, 0, 12169, 12151, 1, 0, 0, 0, 12169, 12170, 1, 0, 0, 0, 12170, + 12183, 1, 0, 0, 0, 12171, 12172, 5, 876, 0, 0, 12172, 12173, 5, 2447, 0, + 0, 12173, 12178, 3, 1270, 635, 0, 12174, 12175, 5, 2453, 0, 0, 12175, 12177, + 3, 1270, 635, 0, 12176, 12174, 1, 0, 0, 0, 12177, 12180, 1, 0, 0, 0, 12178, + 12176, 1, 0, 0, 0, 12178, 12179, 1, 0, 0, 0, 12179, 12181, 1, 0, 0, 0, + 12180, 12178, 1, 0, 0, 0, 12181, 12182, 5, 2448, 0, 0, 12182, 12184, 1, + 0, 0, 0, 12183, 12171, 1, 0, 0, 0, 12183, 12184, 1, 0, 0, 0, 12184, 1227, + 1, 0, 0, 0, 12185, 12186, 5, 1513, 0, 0, 12186, 12187, 5, 405, 0, 0, 12187, + 12188, 5, 160, 0, 0, 12188, 12207, 5, 1022, 0, 0, 12189, 12190, 5, 237, + 0, 0, 12190, 12191, 5, 2149, 0, 0, 12191, 12192, 5, 2447, 0, 0, 12192, + 12197, 3, 1230, 615, 0, 12193, 12194, 5, 2453, 0, 0, 12194, 12196, 3, 1230, + 615, 0, 12195, 12193, 1, 0, 0, 0, 12196, 12199, 1, 0, 0, 0, 12197, 12195, + 1, 0, 0, 0, 12197, 12198, 1, 0, 0, 0, 12198, 12200, 1, 0, 0, 0, 12199, + 12197, 1, 0, 0, 0, 12200, 12201, 5, 2448, 0, 0, 12201, 12207, 1, 0, 0, + 0, 12202, 12207, 3, 1254, 627, 0, 12203, 12207, 3, 1260, 630, 0, 12204, + 12207, 3, 1262, 631, 0, 12205, 12207, 3, 1264, 632, 0, 12206, 12185, 1, + 0, 0, 0, 12206, 12189, 1, 0, 0, 0, 12206, 12202, 1, 0, 0, 0, 12206, 12203, + 1, 0, 0, 0, 12206, 12204, 1, 0, 0, 0, 12206, 12205, 1, 0, 0, 0, 12207, + 1229, 1, 0, 0, 0, 12208, 12209, 3, 2340, 1170, 0, 12209, 12244, 5, 628, + 0, 0, 12210, 12245, 5, 1228, 0, 0, 12211, 12212, 5, 284, 0, 0, 12212, 12245, + 3, 2400, 1200, 0, 12213, 12217, 7, 141, 0, 0, 12214, 12218, 3, 1232, 616, + 0, 12215, 12216, 5, 284, 0, 0, 12216, 12218, 3, 2400, 1200, 0, 12217, 12214, + 1, 0, 0, 0, 12217, 12215, 1, 0, 0, 0, 12218, 12245, 1, 0, 0, 0, 12219, + 12220, 5, 628, 0, 0, 12220, 12221, 5, 2447, 0, 0, 12221, 12226, 3, 1270, + 635, 0, 12222, 12223, 5, 2453, 0, 0, 12223, 12225, 3, 1270, 635, 0, 12224, + 12222, 1, 0, 0, 0, 12225, 12228, 1, 0, 0, 0, 12226, 12224, 1, 0, 0, 0, + 12226, 12227, 1, 0, 0, 0, 12227, 12229, 1, 0, 0, 0, 12228, 12226, 1, 0, + 0, 0, 12229, 12230, 5, 2448, 0, 0, 12230, 12237, 1, 0, 0, 0, 12231, 12237, + 5, 215, 0, 0, 12232, 12237, 5, 142, 0, 0, 12233, 12234, 5, 195, 0, 0, 12234, + 12235, 5, 2472, 0, 0, 12235, 12237, 3, 2346, 1173, 0, 12236, 12219, 1, + 0, 0, 0, 12236, 12231, 1, 0, 0, 0, 12236, 12232, 1, 0, 0, 0, 12236, 12233, + 1, 0, 0, 0, 12237, 12245, 1, 0, 0, 0, 12238, 12239, 5, 1738, 0, 0, 12239, + 12240, 3, 1234, 617, 0, 12240, 12241, 5, 2447, 0, 0, 12241, 12242, 5, 2441, + 0, 0, 12242, 12243, 5, 2448, 0, 0, 12243, 12245, 1, 0, 0, 0, 12244, 12210, + 1, 0, 0, 0, 12244, 12211, 1, 0, 0, 0, 12244, 12213, 1, 0, 0, 0, 12244, + 12236, 1, 0, 0, 0, 12244, 12238, 1, 0, 0, 0, 12245, 1231, 1, 0, 0, 0, 12246, + 12248, 3, 2340, 1170, 0, 12247, 12249, 3, 2314, 1157, 0, 12248, 12247, + 1, 0, 0, 0, 12248, 12249, 1, 0, 0, 0, 12249, 12252, 1, 0, 0, 0, 12250, + 12251, 5, 1204, 0, 0, 12251, 12253, 5, 1228, 0, 0, 12252, 12250, 1, 0, + 0, 0, 12252, 12253, 1, 0, 0, 0, 12253, 12255, 1, 0, 0, 0, 12254, 12256, + 3, 1738, 869, 0, 12255, 12254, 1, 0, 0, 0, 12255, 12256, 1, 0, 0, 0, 12256, + 1233, 1, 0, 0, 0, 12257, 12262, 3, 1236, 618, 0, 12258, 12259, 5, 2453, + 0, 0, 12259, 12261, 3, 1236, 618, 0, 12260, 12258, 1, 0, 0, 0, 12261, 12264, + 1, 0, 0, 0, 12262, 12260, 1, 0, 0, 0, 12262, 12263, 1, 0, 0, 0, 12263, + 1235, 1, 0, 0, 0, 12264, 12262, 1, 0, 0, 0, 12265, 12272, 3, 1232, 616, + 0, 12266, 12271, 3, 1238, 619, 0, 12267, 12271, 3, 1240, 620, 0, 12268, + 12271, 3, 1248, 624, 0, 12269, 12271, 3, 1252, 626, 0, 12270, 12266, 1, + 0, 0, 0, 12270, 12267, 1, 0, 0, 0, 12270, 12268, 1, 0, 0, 0, 12270, 12269, + 1, 0, 0, 0, 12271, 12274, 1, 0, 0, 0, 12272, 12270, 1, 0, 0, 0, 12272, + 12273, 1, 0, 0, 0, 12273, 1237, 1, 0, 0, 0, 12274, 12272, 1, 0, 0, 0, 12275, + 12277, 5, 1418, 0, 0, 12276, 12275, 1, 0, 0, 0, 12276, 12277, 1, 0, 0, + 0, 12277, 12278, 1, 0, 0, 0, 12278, 12280, 5, 2447, 0, 0, 12279, 12281, + 5, 2450, 0, 0, 12280, 12279, 1, 0, 0, 0, 12280, 12281, 1, 0, 0, 0, 12281, + 12283, 1, 0, 0, 0, 12282, 12284, 7, 142, 0, 0, 12283, 12282, 1, 0, 0, 0, + 12283, 12284, 1, 0, 0, 0, 12284, 12286, 1, 0, 0, 0, 12285, 12287, 5, 2441, + 0, 0, 12286, 12285, 1, 0, 0, 0, 12286, 12287, 1, 0, 0, 0, 12287, 12294, + 1, 0, 0, 0, 12288, 12295, 5, 2462, 0, 0, 12289, 12291, 5, 2469, 0, 0, 12290, + 12292, 7, 142, 0, 0, 12291, 12290, 1, 0, 0, 0, 12291, 12292, 1, 0, 0, 0, + 12292, 12293, 1, 0, 0, 0, 12293, 12295, 5, 2441, 0, 0, 12294, 12288, 1, + 0, 0, 0, 12294, 12289, 1, 0, 0, 0, 12295, 12296, 1, 0, 0, 0, 12296, 12297, + 5, 2448, 0, 0, 12297, 1239, 1, 0, 0, 0, 12298, 12300, 5, 2200, 0, 0, 12299, + 12298, 1, 0, 0, 0, 12299, 12300, 1, 0, 0, 0, 12300, 12301, 1, 0, 0, 0, + 12301, 12303, 5, 769, 0, 0, 12302, 12304, 5, 560, 0, 0, 12303, 12302, 1, + 0, 0, 0, 12303, 12304, 1, 0, 0, 0, 12304, 12306, 1, 0, 0, 0, 12305, 12307, + 5, 2441, 0, 0, 12306, 12305, 1, 0, 0, 0, 12306, 12307, 1, 0, 0, 0, 12307, + 12309, 1, 0, 0, 0, 12308, 12310, 3, 1242, 621, 0, 12309, 12308, 1, 0, 0, + 0, 12309, 12310, 1, 0, 0, 0, 12310, 12388, 1, 0, 0, 0, 12311, 12328, 7, + 143, 0, 0, 12312, 12313, 5, 2447, 0, 0, 12313, 12316, 5, 2441, 0, 0, 12314, + 12315, 5, 2453, 0, 0, 12315, 12317, 5, 2441, 0, 0, 12316, 12314, 1, 0, + 0, 0, 12316, 12317, 1, 0, 0, 0, 12317, 12318, 1, 0, 0, 0, 12318, 12329, + 5, 2448, 0, 0, 12319, 12323, 5, 560, 0, 0, 12320, 12321, 5, 2447, 0, 0, + 12321, 12322, 5, 2441, 0, 0, 12322, 12324, 5, 2448, 0, 0, 12323, 12320, + 1, 0, 0, 0, 12323, 12324, 1, 0, 0, 0, 12324, 12326, 1, 0, 0, 0, 12325, + 12327, 3, 1242, 621, 0, 12326, 12325, 1, 0, 0, 0, 12326, 12327, 1, 0, 0, + 0, 12327, 12329, 1, 0, 0, 0, 12328, 12312, 1, 0, 0, 0, 12328, 12319, 1, + 0, 0, 0, 12329, 12388, 1, 0, 0, 0, 12330, 12388, 5, 1281, 0, 0, 12331, + 12333, 5, 1282, 0, 0, 12332, 12334, 5, 314, 0, 0, 12333, 12332, 1, 0, 0, + 0, 12333, 12334, 1, 0, 0, 0, 12334, 12388, 1, 0, 0, 0, 12335, 12337, 5, + 607, 0, 0, 12336, 12338, 5, 560, 0, 0, 12337, 12336, 1, 0, 0, 0, 12337, + 12338, 1, 0, 0, 0, 12338, 12340, 1, 0, 0, 0, 12339, 12341, 5, 2441, 0, + 0, 12340, 12339, 1, 0, 0, 0, 12340, 12341, 1, 0, 0, 0, 12341, 12343, 1, + 0, 0, 0, 12342, 12344, 3, 1242, 621, 0, 12343, 12342, 1, 0, 0, 0, 12343, + 12344, 1, 0, 0, 0, 12344, 12388, 1, 0, 0, 0, 12345, 12388, 5, 465, 0, 0, + 12346, 12348, 5, 128, 0, 0, 12347, 12349, 5, 560, 0, 0, 12348, 12347, 1, + 0, 0, 0, 12348, 12349, 1, 0, 0, 0, 12349, 12351, 1, 0, 0, 0, 12350, 12352, + 5, 2441, 0, 0, 12351, 12350, 1, 0, 0, 0, 12351, 12352, 1, 0, 0, 0, 12352, + 12354, 1, 0, 0, 0, 12353, 12355, 3, 1242, 621, 0, 12354, 12353, 1, 0, 0, + 0, 12354, 12355, 1, 0, 0, 0, 12355, 12388, 1, 0, 0, 0, 12356, 12388, 5, + 125, 0, 0, 12357, 12359, 5, 1498, 0, 0, 12358, 12360, 5, 2441, 0, 0, 12359, + 12358, 1, 0, 0, 0, 12359, 12360, 1, 0, 0, 0, 12360, 12388, 1, 0, 0, 0, + 12361, 12363, 5, 196, 0, 0, 12362, 12364, 5, 560, 0, 0, 12363, 12362, 1, + 0, 0, 0, 12363, 12364, 1, 0, 0, 0, 12364, 12368, 1, 0, 0, 0, 12365, 12366, + 5, 2447, 0, 0, 12366, 12367, 5, 2441, 0, 0, 12367, 12369, 5, 2448, 0, 0, + 12368, 12365, 1, 0, 0, 0, 12368, 12369, 1, 0, 0, 0, 12369, 12371, 1, 0, + 0, 0, 12370, 12372, 3, 1242, 621, 0, 12371, 12370, 1, 0, 0, 0, 12371, 12372, + 1, 0, 0, 0, 12372, 12374, 1, 0, 0, 0, 12373, 12375, 3, 1244, 622, 0, 12374, + 12373, 1, 0, 0, 0, 12374, 12375, 1, 0, 0, 0, 12375, 12377, 1, 0, 0, 0, + 12376, 12378, 3, 1246, 623, 0, 12377, 12376, 1, 0, 0, 0, 12377, 12378, + 1, 0, 0, 0, 12378, 12388, 1, 0, 0, 0, 12379, 12380, 7, 144, 0, 0, 12380, + 12383, 5, 2447, 0, 0, 12381, 12382, 5, 2441, 0, 0, 12382, 12384, 5, 2453, + 0, 0, 12383, 12381, 1, 0, 0, 0, 12383, 12384, 1, 0, 0, 0, 12384, 12385, + 1, 0, 0, 0, 12385, 12386, 5, 2441, 0, 0, 12386, 12388, 5, 2448, 0, 0, 12387, + 12299, 1, 0, 0, 0, 12387, 12311, 1, 0, 0, 0, 12387, 12330, 1, 0, 0, 0, + 12387, 12331, 1, 0, 0, 0, 12387, 12335, 1, 0, 0, 0, 12387, 12345, 1, 0, + 0, 0, 12387, 12346, 1, 0, 0, 0, 12387, 12356, 1, 0, 0, 0, 12387, 12357, + 1, 0, 0, 0, 12387, 12361, 1, 0, 0, 0, 12387, 12379, 1, 0, 0, 0, 12388, + 1241, 1, 0, 0, 0, 12389, 12390, 5, 503, 0, 0, 12390, 12391, 5, 160, 0, + 0, 12391, 12394, 3, 2400, 1200, 0, 12392, 12393, 5, 49, 0, 0, 12393, 12395, + 3, 2400, 1200, 0, 12394, 12392, 1, 0, 0, 0, 12394, 12395, 1, 0, 0, 0, 12395, + 12415, 1, 0, 0, 0, 12396, 12397, 5, 2094, 0, 0, 12397, 12400, 5, 160, 0, + 0, 12398, 12401, 3, 2400, 1200, 0, 12399, 12401, 5, 2303, 0, 0, 12400, + 12398, 1, 0, 0, 0, 12400, 12399, 1, 0, 0, 0, 12401, 12412, 1, 0, 0, 0, + 12402, 12404, 5, 1273, 0, 0, 12403, 12402, 1, 0, 0, 0, 12403, 12404, 1, + 0, 0, 0, 12404, 12405, 1, 0, 0, 0, 12405, 12406, 5, 503, 0, 0, 12406, 12407, + 5, 160, 0, 0, 12407, 12410, 3, 2400, 1200, 0, 12408, 12409, 5, 49, 0, 0, + 12409, 12411, 3, 2400, 1200, 0, 12410, 12408, 1, 0, 0, 0, 12410, 12411, + 1, 0, 0, 0, 12411, 12413, 1, 0, 0, 0, 12412, 12403, 1, 0, 0, 0, 12412, + 12413, 1, 0, 0, 0, 12413, 12415, 1, 0, 0, 0, 12414, 12389, 1, 0, 0, 0, + 12414, 12396, 1, 0, 0, 0, 12415, 1243, 1, 0, 0, 0, 12416, 12417, 7, 145, + 0, 0, 12417, 1245, 1, 0, 0, 0, 12418, 12420, 5, 363, 0, 0, 12419, 12418, + 1, 0, 0, 0, 12419, 12420, 1, 0, 0, 0, 12420, 12435, 1, 0, 0, 0, 12421, + 12436, 5, 361, 0, 0, 12422, 12429, 5, 2108, 0, 0, 12423, 12425, 5, 2308, + 0, 0, 12424, 12426, 5, 873, 0, 0, 12425, 12424, 1, 0, 0, 0, 12425, 12426, + 1, 0, 0, 0, 12426, 12427, 1, 0, 0, 0, 12427, 12428, 5, 2112, 0, 0, 12428, + 12430, 5, 2363, 0, 0, 12429, 12423, 1, 0, 0, 0, 12429, 12430, 1, 0, 0, + 0, 12430, 12431, 1, 0, 0, 0, 12431, 12432, 5, 912, 0, 0, 12432, 12436, + 3, 2400, 1200, 0, 12433, 12434, 5, 776, 0, 0, 12434, 12436, 7, 146, 0, + 0, 12435, 12421, 1, 0, 0, 0, 12435, 12422, 1, 0, 0, 0, 12435, 12433, 1, + 0, 0, 0, 12436, 1247, 1, 0, 0, 0, 12437, 12438, 7, 147, 0, 0, 12438, 12439, + 3, 1250, 625, 0, 12439, 1249, 1, 0, 0, 0, 12440, 12446, 6, 625, -1, 0, + 12441, 12447, 3, 1758, 879, 0, 12442, 12443, 5, 2447, 0, 0, 12443, 12444, + 5, 2441, 0, 0, 12444, 12445, 5, 2462, 0, 0, 12445, 12447, 5, 2448, 0, 0, + 12446, 12441, 1, 0, 0, 0, 12446, 12442, 1, 0, 0, 0, 12447, 12448, 1, 0, + 0, 0, 12448, 12452, 3, 2096, 1048, 0, 12449, 12453, 3, 2400, 1200, 0, 12450, + 12453, 5, 2438, 0, 0, 12451, 12453, 5, 141, 0, 0, 12452, 12449, 1, 0, 0, + 0, 12452, 12450, 1, 0, 0, 0, 12452, 12451, 1, 0, 0, 0, 12453, 12459, 1, + 0, 0, 0, 12454, 12455, 10, 1, 0, 0, 12455, 12456, 7, 148, 0, 0, 12456, + 12458, 3, 1250, 625, 2, 12457, 12454, 1, 0, 0, 0, 12458, 12461, 1, 0, 0, + 0, 12459, 12457, 1, 0, 0, 0, 12459, 12460, 1, 0, 0, 0, 12460, 1251, 1, + 0, 0, 0, 12461, 12459, 1, 0, 0, 0, 12462, 12463, 5, 864, 0, 0, 12463, 12464, + 3, 1270, 635, 0, 12464, 1253, 1, 0, 0, 0, 12465, 12494, 5, 1513, 0, 0, + 12466, 12467, 5, 602, 0, 0, 12467, 12495, 5, 2441, 0, 0, 12468, 12469, + 5, 2262, 0, 0, 12469, 12495, 5, 2441, 0, 0, 12470, 12471, 5, 405, 0, 0, + 12471, 12477, 5, 160, 0, 0, 12472, 12474, 5, 418, 0, 0, 12473, 12472, 1, + 0, 0, 0, 12473, 12474, 1, 0, 0, 0, 12474, 12475, 1, 0, 0, 0, 12475, 12478, + 5, 1022, 0, 0, 12476, 12478, 3, 2400, 1200, 0, 12477, 12473, 1, 0, 0, 0, + 12477, 12476, 1, 0, 0, 0, 12478, 12495, 1, 0, 0, 0, 12479, 12481, 5, 2348, + 0, 0, 12480, 12482, 5, 2447, 0, 0, 12481, 12480, 1, 0, 0, 0, 12481, 12482, + 1, 0, 0, 0, 12482, 12483, 1, 0, 0, 0, 12483, 12488, 3, 2404, 1202, 0, 12484, + 12485, 5, 2453, 0, 0, 12485, 12487, 3, 2404, 1202, 0, 12486, 12484, 1, + 0, 0, 0, 12487, 12490, 1, 0, 0, 0, 12488, 12486, 1, 0, 0, 0, 12488, 12489, + 1, 0, 0, 0, 12489, 12492, 1, 0, 0, 0, 12490, 12488, 1, 0, 0, 0, 12491, + 12493, 5, 2448, 0, 0, 12492, 12491, 1, 0, 0, 0, 12492, 12493, 1, 0, 0, + 0, 12493, 12495, 1, 0, 0, 0, 12494, 12466, 1, 0, 0, 0, 12494, 12468, 1, + 0, 0, 0, 12494, 12470, 1, 0, 0, 0, 12494, 12479, 1, 0, 0, 0, 12495, 12499, + 1, 0, 0, 0, 12496, 12498, 3, 1256, 628, 0, 12497, 12496, 1, 0, 0, 0, 12498, + 12501, 1, 0, 0, 0, 12499, 12497, 1, 0, 0, 0, 12499, 12500, 1, 0, 0, 0, + 12500, 12508, 1, 0, 0, 0, 12501, 12499, 1, 0, 0, 0, 12502, 12504, 3, 1256, + 628, 0, 12503, 12502, 1, 0, 0, 0, 12504, 12505, 1, 0, 0, 0, 12505, 12503, + 1, 0, 0, 0, 12505, 12506, 1, 0, 0, 0, 12506, 12508, 1, 0, 0, 0, 12507, + 12465, 1, 0, 0, 0, 12507, 12503, 1, 0, 0, 0, 12508, 1255, 1, 0, 0, 0, 12509, + 12510, 5, 195, 0, 0, 12510, 12547, 3, 2346, 1173, 0, 12511, 12512, 5, 560, + 0, 0, 12512, 12513, 5, 2262, 0, 0, 12513, 12547, 5, 351, 0, 0, 12514, 12515, + 5, 1442, 0, 0, 12515, 12547, 3, 1270, 635, 0, 12516, 12517, 5, 351, 0, + 0, 12517, 12518, 5, 785, 0, 0, 12518, 12519, 7, 149, 0, 0, 12519, 12547, + 5, 510, 0, 0, 12520, 12521, 5, 165, 0, 0, 12521, 12547, 7, 150, 0, 0, 12522, + 12523, 5, 1767, 0, 0, 12523, 12524, 5, 1700, 0, 0, 12524, 12525, 5, 67, + 0, 0, 12525, 12526, 5, 738, 0, 0, 12526, 12547, 7, 151, 0, 0, 12527, 12528, + 5, 867, 0, 0, 12528, 12529, 5, 2300, 0, 0, 12529, 12547, 3, 1250, 625, + 0, 12530, 12547, 3, 1258, 629, 0, 12531, 12533, 5, 1507, 0, 0, 12532, 12534, + 5, 2472, 0, 0, 12533, 12532, 1, 0, 0, 0, 12533, 12534, 1, 0, 0, 0, 12534, + 12535, 1, 0, 0, 0, 12535, 12547, 5, 2441, 0, 0, 12536, 12547, 5, 431, 0, + 0, 12537, 12538, 5, 362, 0, 0, 12538, 12547, 5, 2441, 0, 0, 12539, 12540, + 5, 1702, 0, 0, 12540, 12547, 5, 2441, 0, 0, 12541, 12542, 5, 784, 0, 0, + 12542, 12547, 7, 152, 0, 0, 12543, 12547, 7, 153, 0, 0, 12544, 12545, 5, + 453, 0, 0, 12545, 12547, 5, 2441, 0, 0, 12546, 12509, 1, 0, 0, 0, 12546, + 12511, 1, 0, 0, 0, 12546, 12514, 1, 0, 0, 0, 12546, 12516, 1, 0, 0, 0, + 12546, 12520, 1, 0, 0, 0, 12546, 12522, 1, 0, 0, 0, 12546, 12527, 1, 0, + 0, 0, 12546, 12530, 1, 0, 0, 0, 12546, 12531, 1, 0, 0, 0, 12546, 12536, + 1, 0, 0, 0, 12546, 12537, 1, 0, 0, 0, 12546, 12539, 1, 0, 0, 0, 12546, + 12541, 1, 0, 0, 0, 12546, 12543, 1, 0, 0, 0, 12546, 12544, 1, 0, 0, 0, + 12547, 1257, 1, 0, 0, 0, 12548, 12555, 7, 154, 0, 0, 12549, 12551, 7, 155, + 0, 0, 12550, 12552, 3, 1270, 635, 0, 12551, 12550, 1, 0, 0, 0, 12551, 12552, + 1, 0, 0, 0, 12552, 12553, 1, 0, 0, 0, 12553, 12555, 3, 1458, 729, 0, 12554, + 12548, 1, 0, 0, 0, 12554, 12549, 1, 0, 0, 0, 12555, 1259, 1, 0, 0, 0, 12556, + 12558, 5, 588, 0, 0, 12557, 12559, 5, 693, 0, 0, 12558, 12557, 1, 0, 0, + 0, 12558, 12559, 1, 0, 0, 0, 12559, 12563, 1, 0, 0, 0, 12560, 12561, 5, + 330, 0, 0, 12561, 12562, 7, 2, 0, 0, 12562, 12564, 5, 494, 0, 0, 12563, + 12560, 1, 0, 0, 0, 12563, 12564, 1, 0, 0, 0, 12564, 12566, 1, 0, 0, 0, + 12565, 12567, 3, 1242, 621, 0, 12566, 12565, 1, 0, 0, 0, 12566, 12567, + 1, 0, 0, 0, 12567, 12569, 1, 0, 0, 0, 12568, 12570, 3, 1244, 622, 0, 12569, + 12568, 1, 0, 0, 0, 12569, 12570, 1, 0, 0, 0, 12570, 12576, 1, 0, 0, 0, + 12571, 12572, 5, 38, 0, 0, 12572, 12573, 5, 588, 0, 0, 12573, 12574, 5, + 1323, 0, 0, 12574, 12575, 5, 2101, 0, 0, 12575, 12577, 5, 588, 0, 0, 12576, + 12571, 1, 0, 0, 0, 12576, 12577, 1, 0, 0, 0, 12577, 12583, 1, 0, 0, 0, + 12578, 12579, 5, 964, 0, 0, 12579, 12580, 5, 587, 0, 0, 12580, 12581, 5, + 2257, 0, 0, 12581, 12582, 5, 67, 0, 0, 12582, 12584, 5, 1228, 0, 0, 12583, + 12578, 1, 0, 0, 0, 12583, 12584, 1, 0, 0, 0, 12584, 12591, 1, 0, 0, 0, + 12585, 12586, 5, 1549, 0, 0, 12586, 12587, 5, 1607, 0, 0, 12587, 12588, + 5, 2308, 0, 0, 12588, 12589, 5, 38, 0, 0, 12589, 12590, 5, 1228, 0, 0, + 12590, 12592, 5, 588, 0, 0, 12591, 12585, 1, 0, 0, 0, 12591, 12592, 1, + 0, 0, 0, 12592, 12597, 1, 0, 0, 0, 12593, 12594, 5, 363, 0, 0, 12594, 12595, + 7, 156, 0, 0, 12595, 12596, 5, 912, 0, 0, 12596, 12598, 3, 2400, 1200, + 0, 12597, 12593, 1, 0, 0, 0, 12597, 12598, 1, 0, 0, 0, 12598, 12607, 1, + 0, 0, 0, 12599, 12600, 5, 1227, 0, 0, 12600, 12604, 7, 157, 0, 0, 12601, + 12605, 3, 2400, 1200, 0, 12602, 12605, 5, 2438, 0, 0, 12603, 12605, 5, + 141, 0, 0, 12604, 12601, 1, 0, 0, 0, 12604, 12602, 1, 0, 0, 0, 12604, 12603, + 1, 0, 0, 0, 12605, 12608, 1, 0, 0, 0, 12606, 12608, 5, 1134, 0, 0, 12607, + 12599, 1, 0, 0, 0, 12607, 12606, 1, 0, 0, 0, 12607, 12608, 1, 0, 0, 0, + 12608, 12610, 1, 0, 0, 0, 12609, 12611, 5, 2447, 0, 0, 12610, 12609, 1, + 0, 0, 0, 12610, 12611, 1, 0, 0, 0, 12611, 12613, 1, 0, 0, 0, 12612, 12614, + 3, 1234, 617, 0, 12613, 12612, 1, 0, 0, 0, 12613, 12614, 1, 0, 0, 0, 12614, + 12616, 1, 0, 0, 0, 12615, 12617, 5, 2448, 0, 0, 12616, 12615, 1, 0, 0, + 0, 12616, 12617, 1, 0, 0, 0, 12617, 1261, 1, 0, 0, 0, 12618, 12619, 5, + 506, 0, 0, 12619, 12675, 7, 158, 0, 0, 12620, 12675, 5, 1118, 0, 0, 12621, + 12623, 5, 882, 0, 0, 12622, 12624, 3, 1270, 635, 0, 12623, 12622, 1, 0, + 0, 0, 12623, 12624, 1, 0, 0, 0, 12624, 12625, 1, 0, 0, 0, 12625, 12675, + 3, 1458, 729, 0, 12626, 12632, 5, 259, 0, 0, 12627, 12629, 5, 500, 0, 0, + 12628, 12630, 7, 159, 0, 0, 12629, 12628, 1, 0, 0, 0, 12629, 12630, 1, + 0, 0, 0, 12630, 12633, 1, 0, 0, 0, 12631, 12633, 5, 430, 0, 0, 12632, 12627, + 1, 0, 0, 0, 12632, 12631, 1, 0, 0, 0, 12632, 12633, 1, 0, 0, 0, 12633, + 12675, 1, 0, 0, 0, 12634, 12635, 5, 657, 0, 0, 12635, 12636, 7, 160, 0, + 0, 12636, 12640, 5, 2285, 0, 0, 12637, 12641, 5, 247, 0, 0, 12638, 12641, + 5, 828, 0, 0, 12639, 12641, 3, 2400, 1200, 0, 12640, 12637, 1, 0, 0, 0, + 12640, 12638, 1, 0, 0, 0, 12640, 12639, 1, 0, 0, 0, 12641, 12675, 1, 0, + 0, 0, 12642, 12675, 5, 1117, 0, 0, 12643, 12644, 5, 378, 0, 0, 12644, 12645, + 5, 2472, 0, 0, 12645, 12646, 5, 2447, 0, 0, 12646, 12647, 5, 2441, 0, 0, + 12647, 12648, 5, 2453, 0, 0, 12648, 12649, 5, 2441, 0, 0, 12649, 12675, + 5, 2448, 0, 0, 12650, 12651, 5, 359, 0, 0, 12651, 12652, 5, 778, 0, 0, + 12652, 12653, 5, 2083, 0, 0, 12653, 12675, 3, 2342, 1171, 0, 12654, 12655, + 5, 2091, 0, 0, 12655, 12675, 3, 2342, 1171, 0, 12656, 12657, 5, 793, 0, + 0, 12657, 12658, 5, 2447, 0, 0, 12658, 12659, 3, 2286, 1143, 0, 12659, + 12660, 5, 2453, 0, 0, 12660, 12661, 3, 2342, 1171, 0, 12661, 12662, 5, + 2453, 0, 0, 12662, 12663, 5, 2441, 0, 0, 12663, 12664, 5, 2448, 0, 0, 12664, + 12675, 1, 0, 0, 0, 12665, 12666, 5, 2310, 0, 0, 12666, 12675, 5, 2441, + 0, 0, 12667, 12668, 5, 1333, 0, 0, 12668, 12675, 5, 2441, 0, 0, 12669, + 12670, 5, 2285, 0, 0, 12670, 12675, 3, 2400, 1200, 0, 12671, 12675, 5, + 507, 0, 0, 12672, 12673, 5, 370, 0, 0, 12673, 12675, 3, 2400, 1200, 0, + 12674, 12618, 1, 0, 0, 0, 12674, 12620, 1, 0, 0, 0, 12674, 12621, 1, 0, + 0, 0, 12674, 12626, 1, 0, 0, 0, 12674, 12634, 1, 0, 0, 0, 12674, 12642, + 1, 0, 0, 0, 12674, 12643, 1, 0, 0, 0, 12674, 12650, 1, 0, 0, 0, 12674, + 12654, 1, 0, 0, 0, 12674, 12656, 1, 0, 0, 0, 12674, 12665, 1, 0, 0, 0, + 12674, 12667, 1, 0, 0, 0, 12674, 12669, 1, 0, 0, 0, 12674, 12671, 1, 0, + 0, 0, 12674, 12672, 1, 0, 0, 0, 12675, 1263, 1, 0, 0, 0, 12676, 12681, + 3, 2404, 1202, 0, 12677, 12678, 5, 2440, 0, 0, 12678, 12680, 3, 2404, 1202, + 0, 12679, 12677, 1, 0, 0, 0, 12680, 12683, 1, 0, 0, 0, 12681, 12679, 1, + 0, 0, 0, 12681, 12682, 1, 0, 0, 0, 12682, 12684, 1, 0, 0, 0, 12683, 12681, + 1, 0, 0, 0, 12684, 12768, 7, 161, 0, 0, 12685, 12769, 3, 2342, 1171, 0, + 12686, 12769, 3, 1266, 633, 0, 12687, 12688, 5, 2473, 0, 0, 12688, 12693, + 3, 1266, 633, 0, 12689, 12690, 5, 2453, 0, 0, 12690, 12692, 3, 1266, 633, + 0, 12691, 12689, 1, 0, 0, 0, 12692, 12695, 1, 0, 0, 0, 12693, 12691, 1, + 0, 0, 0, 12693, 12694, 1, 0, 0, 0, 12694, 12696, 1, 0, 0, 0, 12695, 12693, + 1, 0, 0, 0, 12696, 12697, 5, 2474, 0, 0, 12697, 12769, 1, 0, 0, 0, 12698, + 12699, 3, 1232, 616, 0, 12699, 12702, 3, 2376, 1188, 0, 12700, 12701, 5, + 241, 0, 0, 12701, 12703, 3, 2400, 1200, 0, 12702, 12700, 1, 0, 0, 0, 12702, + 12703, 1, 0, 0, 0, 12703, 12709, 1, 0, 0, 0, 12704, 12705, 5, 2453, 0, + 0, 12705, 12706, 5, 241, 0, 0, 12706, 12708, 3, 2400, 1200, 0, 12707, 12704, + 1, 0, 0, 0, 12708, 12711, 1, 0, 0, 0, 12709, 12707, 1, 0, 0, 0, 12709, + 12710, 1, 0, 0, 0, 12710, 12769, 1, 0, 0, 0, 12711, 12709, 1, 0, 0, 0, + 12712, 12769, 5, 1654, 0, 0, 12713, 12769, 5, 2097, 0, 0, 12714, 12769, + 5, 1503, 0, 0, 12715, 12769, 5, 1280, 0, 0, 12716, 12769, 5, 1341, 0, 0, + 12717, 12718, 5, 752, 0, 0, 12718, 12719, 3, 2400, 1200, 0, 12719, 12720, + 5, 1316, 0, 0, 12720, 12721, 3, 2400, 1200, 0, 12721, 12769, 1, 0, 0, 0, + 12722, 12769, 3, 1270, 635, 0, 12723, 12725, 5, 405, 0, 0, 12724, 12723, + 1, 0, 0, 0, 12724, 12725, 1, 0, 0, 0, 12725, 12747, 1, 0, 0, 0, 12726, + 12727, 5, 588, 0, 0, 12727, 12728, 5, 2094, 0, 0, 12728, 12729, 5, 160, + 0, 0, 12729, 12730, 5, 193, 0, 0, 12730, 12731, 5, 526, 0, 0, 12731, 12732, + 5, 160, 0, 0, 12732, 12748, 5, 193, 0, 0, 12733, 12734, 5, 234, 0, 0, 12734, + 12739, 5, 789, 0, 0, 12735, 12736, 5, 910, 0, 0, 12736, 12739, 5, 819, + 0, 0, 12737, 12739, 5, 860, 0, 0, 12738, 12733, 1, 0, 0, 0, 12738, 12735, + 1, 0, 0, 0, 12738, 12737, 1, 0, 0, 0, 12739, 12740, 1, 0, 0, 0, 12740, + 12741, 5, 2094, 0, 0, 12741, 12742, 5, 160, 0, 0, 12742, 12748, 5, 193, + 0, 0, 12743, 12744, 5, 1228, 0, 0, 12744, 12745, 5, 396, 0, 0, 12745, 12746, + 5, 69, 0, 0, 12746, 12748, 5, 193, 0, 0, 12747, 12726, 1, 0, 0, 0, 12747, + 12738, 1, 0, 0, 0, 12747, 12743, 1, 0, 0, 0, 12748, 12769, 1, 0, 0, 0, + 12749, 12750, 5, 1657, 0, 0, 12750, 12766, 3, 2400, 1200, 0, 12751, 12752, + 5, 2308, 0, 0, 12752, 12753, 5, 1658, 0, 0, 12753, 12754, 3, 2400, 1200, + 0, 12754, 12755, 5, 2472, 0, 0, 12755, 12763, 3, 2400, 1200, 0, 12756, + 12757, 5, 2453, 0, 0, 12757, 12758, 3, 2400, 1200, 0, 12758, 12759, 5, + 2472, 0, 0, 12759, 12760, 3, 2400, 1200, 0, 12760, 12762, 1, 0, 0, 0, 12761, + 12756, 1, 0, 0, 0, 12762, 12765, 1, 0, 0, 0, 12763, 12761, 1, 0, 0, 0, + 12763, 12764, 1, 0, 0, 0, 12764, 12767, 1, 0, 0, 0, 12765, 12763, 1, 0, + 0, 0, 12766, 12751, 1, 0, 0, 0, 12766, 12767, 1, 0, 0, 0, 12767, 12769, + 1, 0, 0, 0, 12768, 12685, 1, 0, 0, 0, 12768, 12686, 1, 0, 0, 0, 12768, + 12687, 1, 0, 0, 0, 12768, 12698, 1, 0, 0, 0, 12768, 12712, 1, 0, 0, 0, + 12768, 12713, 1, 0, 0, 0, 12768, 12714, 1, 0, 0, 0, 12768, 12715, 1, 0, + 0, 0, 12768, 12716, 1, 0, 0, 0, 12768, 12717, 1, 0, 0, 0, 12768, 12722, + 1, 0, 0, 0, 12768, 12724, 1, 0, 0, 0, 12768, 12749, 1, 0, 0, 0, 12769, + 12771, 1, 0, 0, 0, 12770, 12772, 3, 1264, 632, 0, 12771, 12770, 1, 0, 0, + 0, 12771, 12772, 1, 0, 0, 0, 12772, 1265, 1, 0, 0, 0, 12773, 12774, 5, + 2459, 0, 0, 12774, 12779, 3, 1268, 634, 0, 12775, 12776, 5, 2453, 0, 0, + 12776, 12778, 3, 1268, 634, 0, 12777, 12775, 1, 0, 0, 0, 12778, 12781, + 1, 0, 0, 0, 12779, 12777, 1, 0, 0, 0, 12779, 12780, 1, 0, 0, 0, 12780, + 12782, 1, 0, 0, 0, 12781, 12779, 1, 0, 0, 0, 12782, 12783, 5, 2460, 0, + 0, 12783, 1267, 1, 0, 0, 0, 12784, 12785, 3, 2404, 1202, 0, 12785, 12786, + 5, 2462, 0, 0, 12786, 12812, 1, 0, 0, 0, 12787, 12788, 3, 2404, 1202, 0, + 12788, 12789, 5, 2469, 0, 0, 12789, 12790, 5, 2473, 0, 0, 12790, 12795, + 3, 2404, 1202, 0, 12791, 12792, 5, 2453, 0, 0, 12792, 12794, 3, 2404, 1202, + 0, 12793, 12791, 1, 0, 0, 0, 12794, 12797, 1, 0, 0, 0, 12795, 12793, 1, + 0, 0, 0, 12795, 12796, 1, 0, 0, 0, 12796, 12798, 1, 0, 0, 0, 12797, 12795, + 1, 0, 0, 0, 12798, 12799, 5, 2474, 0, 0, 12799, 12812, 1, 0, 0, 0, 12800, + 12801, 5, 2473, 0, 0, 12801, 12806, 3, 2404, 1202, 0, 12802, 12803, 5, + 2453, 0, 0, 12803, 12805, 3, 2404, 1202, 0, 12804, 12802, 1, 0, 0, 0, 12805, + 12808, 1, 0, 0, 0, 12806, 12804, 1, 0, 0, 0, 12806, 12807, 1, 0, 0, 0, + 12807, 12809, 1, 0, 0, 0, 12808, 12806, 1, 0, 0, 0, 12809, 12810, 5, 2474, + 0, 0, 12810, 12812, 1, 0, 0, 0, 12811, 12784, 1, 0, 0, 0, 12811, 12787, + 1, 0, 0, 0, 12811, 12800, 1, 0, 0, 0, 12812, 1269, 1, 0, 0, 0, 12813, 12814, + 3, 786, 393, 0, 12814, 12815, 5, 2469, 0, 0, 12815, 12816, 5, 2443, 0, + 0, 12816, 12829, 1, 0, 0, 0, 12817, 12819, 3, 786, 393, 0, 12818, 12820, + 3, 740, 370, 0, 12819, 12818, 1, 0, 0, 0, 12819, 12820, 1, 0, 0, 0, 12820, + 12821, 1, 0, 0, 0, 12821, 12822, 5, 2469, 0, 0, 12822, 12824, 1, 0, 0, + 0, 12823, 12817, 1, 0, 0, 0, 12823, 12824, 1, 0, 0, 0, 12824, 12825, 1, + 0, 0, 0, 12825, 12829, 5, 2443, 0, 0, 12826, 12829, 3, 2400, 1200, 0, 12827, + 12829, 3, 2326, 1163, 0, 12828, 12813, 1, 0, 0, 0, 12828, 12823, 1, 0, + 0, 0, 12828, 12826, 1, 0, 0, 0, 12828, 12827, 1, 0, 0, 0, 12829, 1271, + 1, 0, 0, 0, 12830, 12832, 7, 17, 0, 0, 12831, 12830, 1, 0, 0, 0, 12831, + 12832, 1, 0, 0, 0, 12832, 12833, 1, 0, 0, 0, 12833, 12834, 5, 1606, 0, + 0, 12834, 12835, 5, 991, 0, 0, 12835, 1273, 1, 0, 0, 0, 12836, 12837, 5, + 605, 0, 0, 12837, 12839, 5, 64, 0, 0, 12838, 12840, 3, 2404, 1202, 0, 12839, + 12838, 1, 0, 0, 0, 12839, 12840, 1, 0, 0, 0, 12840, 12845, 1, 0, 0, 0, + 12841, 12842, 5, 1137, 0, 0, 12842, 12843, 5, 605, 0, 0, 12843, 12845, + 5, 64, 0, 0, 12844, 12836, 1, 0, 0, 0, 12844, 12841, 1, 0, 0, 0, 12845, + 1275, 1, 0, 0, 0, 12846, 12849, 5, 2441, 0, 0, 12847, 12849, 3, 2402, 1201, + 0, 12848, 12846, 1, 0, 0, 0, 12848, 12847, 1, 0, 0, 0, 12849, 1277, 1, + 0, 0, 0, 12850, 12851, 5, 21, 0, 0, 12851, 12852, 5, 1789, 0, 0, 12852, + 12855, 5, 888, 0, 0, 12853, 12856, 3, 1280, 640, 0, 12854, 12856, 3, 1282, + 641, 0, 12855, 12853, 1, 0, 0, 0, 12855, 12854, 1, 0, 0, 0, 12856, 12866, + 1, 0, 0, 0, 12857, 12858, 5, 2453, 0, 0, 12858, 12859, 5, 1789, 0, 0, 12859, + 12862, 5, 888, 0, 0, 12860, 12863, 3, 1280, 640, 0, 12861, 12863, 3, 1282, + 641, 0, 12862, 12860, 1, 0, 0, 0, 12862, 12861, 1, 0, 0, 0, 12863, 12865, + 1, 0, 0, 0, 12864, 12857, 1, 0, 0, 0, 12865, 12868, 1, 0, 0, 0, 12866, + 12864, 1, 0, 0, 0, 12866, 12867, 1, 0, 0, 0, 12867, 12891, 1, 0, 0, 0, + 12868, 12866, 1, 0, 0, 0, 12869, 12870, 5, 469, 0, 0, 12870, 12871, 5, + 1789, 0, 0, 12871, 12875, 5, 888, 0, 0, 12872, 12876, 3, 1282, 641, 0, + 12873, 12874, 5, 649, 0, 0, 12874, 12876, 3, 1276, 638, 0, 12875, 12872, + 1, 0, 0, 0, 12875, 12873, 1, 0, 0, 0, 12876, 12887, 1, 0, 0, 0, 12877, + 12878, 5, 2453, 0, 0, 12878, 12879, 5, 1789, 0, 0, 12879, 12883, 5, 888, + 0, 0, 12880, 12884, 3, 1282, 641, 0, 12881, 12882, 5, 649, 0, 0, 12882, + 12884, 3, 1276, 638, 0, 12883, 12880, 1, 0, 0, 0, 12883, 12881, 1, 0, 0, + 0, 12884, 12886, 1, 0, 0, 0, 12885, 12877, 1, 0, 0, 0, 12886, 12889, 1, + 0, 0, 0, 12887, 12885, 1, 0, 0, 0, 12887, 12888, 1, 0, 0, 0, 12888, 12891, + 1, 0, 0, 0, 12889, 12887, 1, 0, 0, 0, 12890, 12850, 1, 0, 0, 0, 12890, + 12869, 1, 0, 0, 0, 12891, 1279, 1, 0, 0, 0, 12892, 12893, 5, 649, 0, 0, + 12893, 12894, 3, 1276, 638, 0, 12894, 12895, 5, 2447, 0, 0, 12895, 12898, + 3, 2340, 1170, 0, 12896, 12897, 5, 1137, 0, 0, 12897, 12899, 5, 888, 0, + 0, 12898, 12896, 1, 0, 0, 0, 12898, 12899, 1, 0, 0, 0, 12899, 12908, 1, + 0, 0, 0, 12900, 12901, 5, 2453, 0, 0, 12901, 12904, 3, 2340, 1170, 0, 12902, + 12903, 5, 1137, 0, 0, 12903, 12905, 5, 888, 0, 0, 12904, 12902, 1, 0, 0, + 0, 12904, 12905, 1, 0, 0, 0, 12905, 12907, 1, 0, 0, 0, 12906, 12900, 1, + 0, 0, 0, 12907, 12910, 1, 0, 0, 0, 12908, 12906, 1, 0, 0, 0, 12908, 12909, + 1, 0, 0, 0, 12909, 12911, 1, 0, 0, 0, 12910, 12908, 1, 0, 0, 0, 12911, + 12913, 5, 2448, 0, 0, 12912, 12914, 5, 44, 0, 0, 12913, 12912, 1, 0, 0, + 0, 12913, 12914, 1, 0, 0, 0, 12914, 1281, 1, 0, 0, 0, 12915, 12916, 5, + 351, 0, 0, 12916, 12931, 5, 2447, 0, 0, 12917, 12919, 5, 2453, 0, 0, 12918, + 12917, 1, 0, 0, 0, 12918, 12919, 1, 0, 0, 0, 12919, 12929, 1, 0, 0, 0, + 12920, 12930, 5, 38, 0, 0, 12921, 12922, 5, 1451, 0, 0, 12922, 12930, 5, + 816, 0, 0, 12923, 12925, 5, 2183, 0, 0, 12924, 12926, 5, 717, 0, 0, 12925, + 12924, 1, 0, 0, 0, 12925, 12926, 1, 0, 0, 0, 12926, 12930, 1, 0, 0, 0, + 12927, 12928, 5, 618, 0, 0, 12928, 12930, 5, 816, 0, 0, 12929, 12920, 1, + 0, 0, 0, 12929, 12921, 1, 0, 0, 0, 12929, 12923, 1, 0, 0, 0, 12929, 12927, + 1, 0, 0, 0, 12930, 12932, 1, 0, 0, 0, 12931, 12918, 1, 0, 0, 0, 12932, + 12933, 1, 0, 0, 0, 12933, 12931, 1, 0, 0, 0, 12933, 12934, 1, 0, 0, 0, + 12934, 12935, 1, 0, 0, 0, 12935, 12936, 5, 2448, 0, 0, 12936, 12937, 5, + 238, 0, 0, 12937, 1283, 1, 0, 0, 0, 12938, 12939, 5, 39, 0, 0, 12939, 12952, + 5, 558, 0, 0, 12940, 12947, 5, 2447, 0, 0, 12941, 12942, 5, 1699, 0, 0, + 12942, 12948, 3, 1176, 588, 0, 12943, 12944, 5, 352, 0, 0, 12944, 12948, + 5, 2443, 0, 0, 12945, 12946, 5, 759, 0, 0, 12946, 12948, 5, 2441, 0, 0, + 12947, 12941, 1, 0, 0, 0, 12947, 12943, 1, 0, 0, 0, 12947, 12945, 1, 0, + 0, 0, 12948, 12949, 1, 0, 0, 0, 12949, 12947, 1, 0, 0, 0, 12949, 12950, + 1, 0, 0, 0, 12950, 12951, 1, 0, 0, 0, 12951, 12953, 5, 2448, 0, 0, 12952, + 12940, 1, 0, 0, 0, 12952, 12953, 1, 0, 0, 0, 12953, 1285, 1, 0, 0, 0, 12954, + 12955, 5, 377, 0, 0, 12955, 12958, 5, 2204, 0, 0, 12956, 12957, 5, 814, + 0, 0, 12957, 12959, 3, 1176, 588, 0, 12958, 12956, 1, 0, 0, 0, 12958, 12959, + 1, 0, 0, 0, 12959, 1287, 1, 0, 0, 0, 12960, 12961, 5, 1684, 0, 0, 12961, + 12963, 5, 1714, 0, 0, 12962, 12964, 5, 246, 0, 0, 12963, 12962, 1, 0, 0, + 0, 12963, 12964, 1, 0, 0, 0, 12964, 12966, 1, 0, 0, 0, 12965, 12967, 5, + 179, 0, 0, 12966, 12965, 1, 0, 0, 0, 12966, 12967, 1, 0, 0, 0, 12967, 12969, + 1, 0, 0, 0, 12968, 12970, 5, 200, 0, 0, 12969, 12968, 1, 0, 0, 0, 12969, + 12970, 1, 0, 0, 0, 12970, 1289, 1, 0, 0, 0, 12971, 12973, 7, 162, 0, 0, + 12972, 12971, 1, 0, 0, 0, 12972, 12973, 1, 0, 0, 0, 12973, 12974, 1, 0, + 0, 0, 12974, 12975, 5, 1514, 0, 0, 12975, 1291, 1, 0, 0, 0, 12976, 12978, + 5, 2211, 0, 0, 12977, 12979, 5, 1204, 0, 0, 12978, 12977, 1, 0, 0, 0, 12978, + 12979, 1, 0, 0, 0, 12979, 12980, 1, 0, 0, 0, 12980, 12981, 5, 705, 0, 0, + 12981, 12982, 5, 351, 0, 0, 12982, 12983, 1, 0, 0, 0, 12983, 12984, 3, + 1660, 830, 0, 12984, 1293, 1, 0, 0, 0, 12985, 12986, 5, 2159, 0, 0, 12986, + 12987, 5, 2083, 0, 0, 12987, 12994, 3, 2342, 1171, 0, 12988, 12992, 7, + 163, 0, 0, 12989, 12990, 5, 919, 0, 0, 12990, 12991, 5, 2286, 0, 0, 12991, + 12993, 5, 888, 0, 0, 12992, 12989, 1, 0, 0, 0, 12992, 12993, 1, 0, 0, 0, + 12993, 12995, 1, 0, 0, 0, 12994, 12988, 1, 0, 0, 0, 12994, 12995, 1, 0, + 0, 0, 12995, 13004, 1, 0, 0, 0, 12996, 12998, 5, 469, 0, 0, 12997, 12999, + 5, 38, 0, 0, 12998, 12997, 1, 0, 0, 0, 12998, 12999, 1, 0, 0, 0, 12999, + 13002, 1, 0, 0, 0, 13000, 13002, 5, 1587, 0, 0, 13001, 12996, 1, 0, 0, + 0, 13001, 13000, 1, 0, 0, 0, 13002, 13003, 1, 0, 0, 0, 13003, 13005, 5, + 1762, 0, 0, 13004, 13001, 1, 0, 0, 0, 13004, 13005, 1, 0, 0, 0, 13005, + 13007, 1, 0, 0, 0, 13006, 13008, 5, 179, 0, 0, 13007, 13006, 1, 0, 0, 0, + 13007, 13008, 1, 0, 0, 0, 13008, 1295, 1, 0, 0, 0, 13009, 13010, 5, 469, + 0, 0, 13010, 13011, 5, 2083, 0, 0, 13011, 13014, 3, 2342, 1171, 0, 13012, + 13013, 5, 691, 0, 0, 13013, 13015, 5, 545, 0, 0, 13014, 13012, 1, 0, 0, + 0, 13014, 13015, 1, 0, 0, 0, 13015, 13018, 1, 0, 0, 0, 13016, 13017, 5, + 69, 0, 0, 13017, 13019, 3, 2342, 1171, 0, 13018, 13016, 1, 0, 0, 0, 13018, + 13019, 1, 0, 0, 0, 13019, 13022, 1, 0, 0, 0, 13020, 13021, 5, 179, 0, 0, + 13021, 13023, 7, 95, 0, 0, 13022, 13020, 1, 0, 0, 0, 13022, 13023, 1, 0, + 0, 0, 13023, 13025, 1, 0, 0, 0, 13024, 13026, 5, 1475, 0, 0, 13025, 13024, + 1, 0, 0, 0, 13025, 13026, 1, 0, 0, 0, 13026, 13029, 1, 0, 0, 0, 13027, + 13028, 5, 69, 0, 0, 13028, 13030, 3, 2270, 1135, 0, 13029, 13027, 1, 0, + 0, 0, 13029, 13030, 1, 0, 0, 0, 13030, 13032, 1, 0, 0, 0, 13031, 13033, + 5, 616, 0, 0, 13032, 13031, 1, 0, 0, 0, 13032, 13033, 1, 0, 0, 0, 13033, + 1297, 1, 0, 0, 0, 13034, 13035, 5, 469, 0, 0, 13035, 13036, 5, 2080, 0, + 0, 13036, 13039, 3, 2404, 1202, 0, 13037, 13038, 5, 691, 0, 0, 13038, 13040, + 5, 545, 0, 0, 13039, 13037, 1, 0, 0, 0, 13039, 13040, 1, 0, 0, 0, 13040, + 13045, 1, 0, 0, 0, 13041, 13043, 7, 164, 0, 0, 13042, 13044, 5, 1490, 0, + 0, 13043, 13042, 1, 0, 0, 0, 13043, 13044, 1, 0, 0, 0, 13044, 13046, 1, + 0, 0, 0, 13045, 13041, 1, 0, 0, 0, 13045, 13046, 1, 0, 0, 0, 13046, 13048, + 1, 0, 0, 0, 13047, 13049, 3, 1302, 651, 0, 13048, 13047, 1, 0, 0, 0, 13048, + 13049, 1, 0, 0, 0, 13049, 1299, 1, 0, 0, 0, 13050, 13051, 5, 469, 0, 0, + 13051, 13052, 5, 2080, 0, 0, 13052, 13053, 5, 1671, 0, 0, 13053, 13055, + 3, 2404, 1202, 0, 13054, 13056, 3, 1302, 651, 0, 13055, 13054, 1, 0, 0, + 0, 13055, 13056, 1, 0, 0, 0, 13056, 1301, 1, 0, 0, 0, 13057, 13058, 5, + 705, 0, 0, 13058, 13061, 5, 295, 0, 0, 13059, 13060, 7, 165, 0, 0, 13060, + 13062, 5, 353, 0, 0, 13061, 13059, 1, 0, 0, 0, 13061, 13062, 1, 0, 0, 0, + 13062, 13065, 1, 0, 0, 0, 13063, 13064, 5, 179, 0, 0, 13064, 13066, 5, + 287, 0, 0, 13065, 13063, 1, 0, 0, 0, 13065, 13066, 1, 0, 0, 0, 13066, 1303, + 1, 0, 0, 0, 13067, 13068, 5, 469, 0, 0, 13068, 13069, 5, 2286, 0, 0, 13069, + 13072, 3, 2342, 1171, 0, 13070, 13071, 5, 691, 0, 0, 13071, 13073, 5, 545, + 0, 0, 13072, 13070, 1, 0, 0, 0, 13072, 13073, 1, 0, 0, 0, 13073, 13076, + 1, 0, 0, 0, 13074, 13075, 5, 179, 0, 0, 13075, 13077, 5, 286, 0, 0, 13076, + 13074, 1, 0, 0, 0, 13076, 13077, 1, 0, 0, 0, 13077, 1305, 1, 0, 0, 0, 13078, + 13079, 5, 241, 0, 0, 13079, 13080, 5, 1259, 0, 0, 13080, 13081, 5, 237, + 0, 0, 13081, 13082, 3, 2340, 1170, 0, 13082, 13083, 5, 785, 0, 0, 13083, + 13084, 3, 2400, 1200, 0, 13084, 1307, 1, 0, 0, 0, 13085, 13086, 7, 17, + 0, 0, 13086, 1309, 1, 0, 0, 0, 13087, 13088, 7, 166, 0, 0, 13088, 1311, + 1, 0, 0, 0, 13089, 13091, 5, 42, 0, 0, 13090, 13092, 5, 1473, 0, 0, 13091, + 13090, 1, 0, 0, 0, 13091, 13092, 1, 0, 0, 0, 13092, 13093, 1, 0, 0, 0, + 13093, 13097, 5, 1796, 0, 0, 13094, 13095, 3, 2286, 1143, 0, 13095, 13096, + 5, 2440, 0, 0, 13096, 13098, 1, 0, 0, 0, 13097, 13094, 1, 0, 0, 0, 13097, + 13098, 1, 0, 0, 0, 13098, 13099, 1, 0, 0, 0, 13099, 13100, 3, 2348, 1174, + 0, 13100, 13101, 7, 167, 0, 0, 13101, 1313, 1, 0, 0, 0, 13102, 13105, 5, + 321, 0, 0, 13103, 13104, 5, 1307, 0, 0, 13104, 13106, 5, 1562, 0, 0, 13105, + 13103, 1, 0, 0, 0, 13105, 13106, 1, 0, 0, 0, 13106, 13107, 1, 0, 0, 0, + 13107, 13108, 5, 1473, 0, 0, 13108, 13109, 5, 1796, 0, 0, 13109, 13110, + 3, 2348, 1174, 0, 13110, 13114, 5, 620, 0, 0, 13111, 13112, 3, 2286, 1143, + 0, 13112, 13113, 5, 2440, 0, 0, 13113, 13115, 1, 0, 0, 0, 13114, 13111, + 1, 0, 0, 0, 13114, 13115, 1, 0, 0, 0, 13115, 13116, 1, 0, 0, 0, 13116, + 13119, 3, 2350, 1175, 0, 13117, 13118, 5, 2456, 0, 0, 13118, 13120, 3, + 2334, 1167, 0, 13119, 13117, 1, 0, 0, 0, 13119, 13120, 1, 0, 0, 0, 13120, + 13150, 1, 0, 0, 0, 13121, 13124, 5, 321, 0, 0, 13122, 13123, 5, 1307, 0, + 0, 13123, 13125, 5, 1562, 0, 0, 13124, 13122, 1, 0, 0, 0, 13124, 13125, + 1, 0, 0, 0, 13125, 13126, 1, 0, 0, 0, 13126, 13130, 5, 1796, 0, 0, 13127, + 13128, 3, 2286, 1143, 0, 13128, 13129, 5, 2440, 0, 0, 13129, 13131, 1, + 0, 0, 0, 13130, 13127, 1, 0, 0, 0, 13130, 13131, 1, 0, 0, 0, 13131, 13132, + 1, 0, 0, 0, 13132, 13133, 3, 2348, 1174, 0, 13133, 13137, 5, 620, 0, 0, + 13134, 13135, 3, 2286, 1143, 0, 13135, 13136, 5, 2440, 0, 0, 13136, 13138, + 1, 0, 0, 0, 13137, 13134, 1, 0, 0, 0, 13137, 13138, 1, 0, 0, 0, 13138, + 13139, 1, 0, 0, 0, 13139, 13147, 3, 2350, 1175, 0, 13140, 13144, 5, 2456, + 0, 0, 13141, 13142, 3, 2286, 1143, 0, 13142, 13143, 5, 2440, 0, 0, 13143, + 13145, 1, 0, 0, 0, 13144, 13141, 1, 0, 0, 0, 13144, 13145, 1, 0, 0, 0, + 13145, 13146, 1, 0, 0, 0, 13146, 13148, 3, 2334, 1167, 0, 13147, 13140, + 1, 0, 0, 0, 13147, 13148, 1, 0, 0, 0, 13148, 13150, 1, 0, 0, 0, 13149, + 13102, 1, 0, 0, 0, 13149, 13121, 1, 0, 0, 0, 13150, 1315, 1, 0, 0, 0, 13151, + 13153, 5, 469, 0, 0, 13152, 13154, 5, 1473, 0, 0, 13153, 13152, 1, 0, 0, + 0, 13153, 13154, 1, 0, 0, 0, 13154, 13155, 1, 0, 0, 0, 13155, 13159, 5, + 1796, 0, 0, 13156, 13157, 3, 2286, 1143, 0, 13157, 13158, 5, 2440, 0, 0, + 13158, 13160, 1, 0, 0, 0, 13159, 13156, 1, 0, 0, 0, 13159, 13160, 1, 0, + 0, 0, 13160, 13161, 1, 0, 0, 0, 13161, 13163, 3, 2348, 1174, 0, 13162, + 13164, 5, 616, 0, 0, 13163, 13162, 1, 0, 0, 0, 13163, 13164, 1, 0, 0, 0, + 13164, 1317, 1, 0, 0, 0, 13165, 13166, 5, 321, 0, 0, 13166, 13169, 5, 1716, + 0, 0, 13167, 13168, 5, 2472, 0, 0, 13168, 13170, 3, 1320, 660, 0, 13169, + 13167, 1, 0, 0, 0, 13169, 13170, 1, 0, 0, 0, 13170, 13171, 1, 0, 0, 0, + 13171, 13182, 5, 628, 0, 0, 13172, 13175, 5, 1391, 0, 0, 13173, 13174, + 5, 2472, 0, 0, 13174, 13176, 3, 1322, 661, 0, 13175, 13173, 1, 0, 0, 0, + 13175, 13176, 1, 0, 0, 0, 13176, 13179, 1, 0, 0, 0, 13177, 13178, 5, 69, + 0, 0, 13178, 13180, 5, 303, 0, 0, 13179, 13177, 1, 0, 0, 0, 13179, 13180, + 1, 0, 0, 0, 13180, 13183, 1, 0, 0, 0, 13181, 13183, 5, 942, 0, 0, 13182, + 13172, 1, 0, 0, 0, 13182, 13181, 1, 0, 0, 0, 13183, 1319, 1, 0, 0, 0, 13184, + 13185, 5, 2443, 0, 0, 13185, 1321, 1, 0, 0, 0, 13186, 13187, 5, 2443, 0, + 0, 13187, 1323, 1, 0, 0, 0, 13188, 13189, 5, 241, 0, 0, 13189, 13190, 5, + 1259, 0, 0, 13190, 13191, 5, 2083, 0, 0, 13191, 13192, 3, 2342, 1171, 0, + 13192, 13193, 5, 785, 0, 0, 13193, 13194, 3, 2400, 1200, 0, 13194, 1325, + 1, 0, 0, 0, 13195, 13196, 5, 241, 0, 0, 13196, 13197, 5, 1259, 0, 0, 13197, + 13198, 5, 919, 0, 0, 13198, 13199, 5, 2286, 0, 0, 13199, 13200, 3, 2342, + 1171, 0, 13200, 13201, 5, 785, 0, 0, 13201, 13202, 3, 2400, 1200, 0, 13202, + 1327, 1, 0, 0, 0, 13203, 13204, 5, 42, 0, 0, 13204, 13205, 5, 45, 0, 0, + 13205, 13209, 5, 2286, 0, 0, 13206, 13207, 3, 2286, 1143, 0, 13207, 13208, + 5, 2440, 0, 0, 13208, 13210, 1, 0, 0, 0, 13209, 13206, 1, 0, 0, 0, 13209, + 13210, 1, 0, 0, 0, 13210, 13211, 1, 0, 0, 0, 13211, 13218, 3, 2404, 1202, + 0, 13212, 13213, 5, 1559, 0, 0, 13213, 13214, 5, 2141, 0, 0, 13214, 13219, + 3, 2404, 1202, 0, 13215, 13219, 5, 249, 0, 0, 13216, 13219, 3, 1330, 665, + 0, 13217, 13219, 3, 1336, 668, 0, 13218, 13212, 1, 0, 0, 0, 13218, 13215, + 1, 0, 0, 0, 13218, 13216, 1, 0, 0, 0, 13218, 13217, 1, 0, 0, 0, 13219, + 1329, 1, 0, 0, 0, 13220, 13221, 5, 21, 0, 0, 13221, 13222, 5, 166, 0, 0, + 13222, 13223, 5, 933, 0, 0, 13223, 13224, 5, 649, 0, 0, 13224, 13227, 5, + 2447, 0, 0, 13225, 13228, 5, 38, 0, 0, 13226, 13228, 3, 1334, 667, 0, 13227, + 13225, 1, 0, 0, 0, 13227, 13226, 1, 0, 0, 0, 13227, 13228, 1, 0, 0, 0, + 13228, 13229, 1, 0, 0, 0, 13229, 13230, 5, 2448, 0, 0, 13230, 13231, 5, + 848, 0, 0, 13231, 13232, 5, 2447, 0, 0, 13232, 13237, 3, 1332, 666, 0, + 13233, 13234, 5, 2453, 0, 0, 13234, 13236, 3, 1332, 666, 0, 13235, 13233, + 1, 0, 0, 0, 13236, 13239, 1, 0, 0, 0, 13237, 13235, 1, 0, 0, 0, 13237, + 13238, 1, 0, 0, 0, 13238, 13240, 1, 0, 0, 0, 13239, 13237, 1, 0, 0, 0, + 13240, 13241, 5, 2448, 0, 0, 13241, 1331, 1, 0, 0, 0, 13242, 13243, 3, + 2404, 1202, 0, 13243, 13244, 5, 2440, 0, 0, 13244, 13246, 1, 0, 0, 0, 13245, + 13242, 1, 0, 0, 0, 13245, 13246, 1, 0, 0, 0, 13246, 13247, 1, 0, 0, 0, + 13247, 13248, 3, 2404, 1202, 0, 13248, 13249, 5, 2440, 0, 0, 13249, 13251, + 1, 0, 0, 0, 13250, 13245, 1, 0, 0, 0, 13250, 13251, 1, 0, 0, 0, 13251, + 13252, 1, 0, 0, 0, 13252, 13253, 3, 2404, 1202, 0, 13253, 1333, 1, 0, 0, + 0, 13254, 13259, 3, 2404, 1202, 0, 13255, 13256, 5, 2453, 0, 0, 13256, + 13258, 3, 2404, 1202, 0, 13257, 13255, 1, 0, 0, 0, 13258, 13261, 1, 0, + 0, 0, 13259, 13257, 1, 0, 0, 0, 13259, 13260, 1, 0, 0, 0, 13260, 1335, + 1, 0, 0, 0, 13261, 13259, 1, 0, 0, 0, 13262, 13263, 5, 469, 0, 0, 13263, + 13264, 5, 166, 0, 0, 13264, 13265, 5, 933, 0, 0, 13265, 13266, 5, 649, + 0, 0, 13266, 13269, 5, 2447, 0, 0, 13267, 13270, 5, 38, 0, 0, 13268, 13270, + 3, 1334, 667, 0, 13269, 13267, 1, 0, 0, 0, 13269, 13268, 1, 0, 0, 0, 13269, + 13270, 1, 0, 0, 0, 13270, 13271, 1, 0, 0, 0, 13271, 13272, 5, 2448, 0, + 0, 13272, 13273, 5, 848, 0, 0, 13273, 13274, 5, 2447, 0, 0, 13274, 13279, + 3, 1332, 666, 0, 13275, 13276, 5, 2453, 0, 0, 13276, 13278, 3, 1332, 666, + 0, 13277, 13275, 1, 0, 0, 0, 13278, 13281, 1, 0, 0, 0, 13279, 13277, 1, + 0, 0, 0, 13279, 13280, 1, 0, 0, 0, 13280, 13282, 1, 0, 0, 0, 13281, 13279, + 1, 0, 0, 0, 13282, 13283, 5, 2448, 0, 0, 13283, 1337, 1, 0, 0, 0, 13284, + 13285, 5, 42, 0, 0, 13285, 13286, 5, 83, 0, 0, 13286, 13290, 5, 422, 0, + 0, 13287, 13288, 3, 2286, 1143, 0, 13288, 13289, 5, 2440, 0, 0, 13289, + 13291, 1, 0, 0, 0, 13290, 13287, 1, 0, 0, 0, 13290, 13291, 1, 0, 0, 0, + 13291, 13292, 1, 0, 0, 0, 13292, 13297, 3, 2404, 1202, 0, 13293, 13294, + 5, 1559, 0, 0, 13294, 13295, 5, 2141, 0, 0, 13295, 13298, 3, 2404, 1202, + 0, 13296, 13298, 5, 249, 0, 0, 13297, 13293, 1, 0, 0, 0, 13297, 13296, + 1, 0, 0, 0, 13298, 1339, 1, 0, 0, 0, 13299, 13300, 5, 42, 0, 0, 13300, + 13301, 5, 85, 0, 0, 13301, 13302, 5, 1412, 0, 0, 13302, 13304, 3, 2404, + 1202, 0, 13303, 13305, 5, 21, 0, 0, 13304, 13303, 1, 0, 0, 0, 13304, 13305, + 1, 0, 0, 0, 13305, 13319, 1, 0, 0, 0, 13306, 13308, 3, 408, 204, 0, 13307, + 13306, 1, 0, 0, 0, 13307, 13308, 1, 0, 0, 0, 13308, 13310, 1, 0, 0, 0, + 13309, 13311, 3, 410, 205, 0, 13310, 13309, 1, 0, 0, 0, 13310, 13311, 1, + 0, 0, 0, 13311, 13313, 1, 0, 0, 0, 13312, 13314, 3, 426, 213, 0, 13313, + 13312, 1, 0, 0, 0, 13313, 13314, 1, 0, 0, 0, 13314, 13320, 1, 0, 0, 0, + 13315, 13316, 5, 1258, 0, 0, 13316, 13318, 5, 2135, 0, 0, 13317, 13315, + 1, 0, 0, 0, 13317, 13318, 1, 0, 0, 0, 13318, 13320, 1, 0, 0, 0, 13319, + 13307, 1, 0, 0, 0, 13319, 13317, 1, 0, 0, 0, 13320, 13322, 1, 0, 0, 0, + 13321, 13323, 5, 469, 0, 0, 13322, 13321, 1, 0, 0, 0, 13322, 13323, 1, + 0, 0, 0, 13323, 13337, 1, 0, 0, 0, 13324, 13326, 3, 408, 204, 0, 13325, + 13324, 1, 0, 0, 0, 13325, 13326, 1, 0, 0, 0, 13326, 13328, 1, 0, 0, 0, + 13327, 13329, 3, 410, 205, 0, 13328, 13327, 1, 0, 0, 0, 13328, 13329, 1, + 0, 0, 0, 13329, 13331, 1, 0, 0, 0, 13330, 13332, 3, 426, 213, 0, 13331, + 13330, 1, 0, 0, 0, 13331, 13332, 1, 0, 0, 0, 13332, 13338, 1, 0, 0, 0, + 13333, 13334, 5, 1258, 0, 0, 13334, 13336, 5, 2135, 0, 0, 13335, 13333, + 1, 0, 0, 0, 13335, 13336, 1, 0, 0, 0, 13336, 13338, 1, 0, 0, 0, 13337, + 13325, 1, 0, 0, 0, 13337, 13335, 1, 0, 0, 0, 13338, 13347, 1, 0, 0, 0, + 13339, 13345, 5, 266, 0, 0, 13340, 13346, 5, 469, 0, 0, 13341, 13342, 5, + 2443, 0, 0, 13342, 13343, 5, 530, 0, 0, 13343, 13344, 5, 1390, 0, 0, 13344, + 13346, 7, 57, 0, 0, 13345, 13340, 1, 0, 0, 0, 13345, 13341, 1, 0, 0, 0, + 13346, 13348, 1, 0, 0, 0, 13347, 13339, 1, 0, 0, 0, 13347, 13348, 1, 0, + 0, 0, 13348, 1341, 1, 0, 0, 0, 13349, 13350, 5, 42, 0, 0, 13350, 13351, + 5, 220, 0, 0, 13351, 13358, 3, 466, 233, 0, 13352, 13359, 3, 1194, 597, + 0, 13353, 13354, 5, 1699, 0, 0, 13354, 13359, 3, 1176, 588, 0, 13355, 13359, + 3, 1284, 642, 0, 13356, 13359, 3, 1286, 643, 0, 13357, 13359, 3, 1364, + 682, 0, 13358, 13352, 1, 0, 0, 0, 13358, 13353, 1, 0, 0, 0, 13358, 13355, + 1, 0, 0, 0, 13358, 13356, 1, 0, 0, 0, 13358, 13357, 1, 0, 0, 0, 13359, + 13360, 1, 0, 0, 0, 13360, 13358, 1, 0, 0, 0, 13360, 13361, 1, 0, 0, 0, + 13361, 13363, 1, 0, 0, 0, 13362, 13364, 3, 928, 464, 0, 13363, 13362, 1, + 0, 0, 0, 13363, 13364, 1, 0, 0, 0, 13364, 1343, 1, 0, 0, 0, 13365, 13366, + 5, 469, 0, 0, 13366, 13367, 5, 45, 0, 0, 13367, 13371, 5, 2286, 0, 0, 13368, + 13369, 3, 2286, 1143, 0, 13369, 13370, 5, 2440, 0, 0, 13370, 13372, 1, + 0, 0, 0, 13371, 13368, 1, 0, 0, 0, 13371, 13372, 1, 0, 0, 0, 13372, 13373, + 1, 0, 0, 0, 13373, 13374, 3, 2404, 1202, 0, 13374, 1345, 1, 0, 0, 0, 13375, + 13376, 5, 469, 0, 0, 13376, 13377, 5, 83, 0, 0, 13377, 13381, 5, 422, 0, + 0, 13378, 13379, 3, 2286, 1143, 0, 13379, 13380, 5, 2440, 0, 0, 13380, + 13382, 1, 0, 0, 0, 13381, 13378, 1, 0, 0, 0, 13381, 13382, 1, 0, 0, 0, + 13382, 13383, 1, 0, 0, 0, 13383, 13384, 3, 2404, 1202, 0, 13384, 1347, + 1, 0, 0, 0, 13385, 13386, 5, 469, 0, 0, 13386, 13387, 5, 85, 0, 0, 13387, + 13388, 5, 1412, 0, 0, 13388, 13389, 3, 2404, 1202, 0, 13389, 1349, 1, 0, + 0, 0, 13390, 13391, 5, 469, 0, 0, 13391, 13392, 5, 605, 0, 0, 13392, 13393, + 5, 64, 0, 0, 13393, 13394, 3, 2404, 1202, 0, 13394, 1351, 1, 0, 0, 0, 13395, + 13396, 5, 469, 0, 0, 13396, 13397, 5, 220, 0, 0, 13397, 13404, 3, 466, + 233, 0, 13398, 13399, 5, 705, 0, 0, 13399, 13402, 5, 2081, 0, 0, 13400, + 13401, 5, 179, 0, 0, 13401, 13403, 5, 287, 0, 0, 13402, 13400, 1, 0, 0, + 0, 13402, 13403, 1, 0, 0, 0, 13403, 13405, 1, 0, 0, 0, 13404, 13398, 1, + 0, 0, 0, 13404, 13405, 1, 0, 0, 0, 13405, 1353, 1, 0, 0, 0, 13406, 13407, + 5, 469, 0, 0, 13407, 13408, 5, 296, 0, 0, 13408, 13409, 3, 2404, 1202, + 0, 13409, 1355, 1, 0, 0, 0, 13410, 13411, 5, 469, 0, 0, 13411, 13412, 5, + 426, 0, 0, 13412, 13413, 3, 2404, 1202, 0, 13413, 1357, 1, 0, 0, 0, 13414, + 13415, 5, 469, 0, 0, 13415, 13416, 5, 441, 0, 0, 13416, 13425, 3, 2404, + 1202, 0, 13417, 13419, 5, 616, 0, 0, 13418, 13417, 1, 0, 0, 0, 13418, 13419, + 1, 0, 0, 0, 13419, 13420, 1, 0, 0, 0, 13420, 13423, 5, 705, 0, 0, 13421, + 13423, 5, 540, 0, 0, 13422, 13418, 1, 0, 0, 0, 13422, 13421, 1, 0, 0, 0, + 13423, 13424, 1, 0, 0, 0, 13424, 13426, 5, 295, 0, 0, 13425, 13422, 1, + 0, 0, 0, 13425, 13426, 1, 0, 0, 0, 13426, 1359, 1, 0, 0, 0, 13427, 13428, + 5, 469, 0, 0, 13428, 13429, 5, 483, 0, 0, 13429, 13431, 3, 2404, 1202, + 0, 13430, 13432, 5, 179, 0, 0, 13431, 13430, 1, 0, 0, 0, 13431, 13432, + 1, 0, 0, 0, 13432, 1361, 1, 0, 0, 0, 13433, 13434, 5, 2159, 0, 0, 13434, + 13435, 5, 220, 0, 0, 13435, 13438, 3, 466, 233, 0, 13436, 13437, 7, 168, + 0, 0, 13437, 13439, 5, 1762, 0, 0, 13438, 13436, 1, 0, 0, 0, 13438, 13439, + 1, 0, 0, 0, 13439, 1363, 1, 0, 0, 0, 13440, 13441, 7, 109, 0, 0, 13441, + 1365, 1, 0, 0, 0, 13442, 13443, 3, 2404, 1202, 0, 13443, 1367, 1, 0, 0, + 0, 13444, 13445, 5, 42, 0, 0, 13445, 13461, 3, 1370, 685, 0, 13446, 13462, + 3, 1372, 686, 0, 13447, 13462, 3, 1378, 689, 0, 13448, 13462, 3, 1394, + 697, 0, 13449, 13462, 3, 1404, 702, 0, 13450, 13462, 3, 1422, 711, 0, 13451, + 13462, 3, 1426, 713, 0, 13452, 13462, 3, 1442, 721, 0, 13453, 13462, 3, + 1446, 723, 0, 13454, 13462, 3, 1448, 724, 0, 13455, 13462, 3, 1460, 730, + 0, 13456, 13462, 3, 1462, 731, 0, 13457, 13462, 3, 1464, 732, 0, 13458, + 13462, 3, 1466, 733, 0, 13459, 13462, 3, 1472, 736, 0, 13460, 13462, 3, + 1474, 737, 0, 13461, 13446, 1, 0, 0, 0, 13461, 13447, 1, 0, 0, 0, 13461, + 13448, 1, 0, 0, 0, 13461, 13449, 1, 0, 0, 0, 13461, 13450, 1, 0, 0, 0, + 13461, 13451, 1, 0, 0, 0, 13461, 13452, 1, 0, 0, 0, 13461, 13453, 1, 0, + 0, 0, 13461, 13454, 1, 0, 0, 0, 13461, 13455, 1, 0, 0, 0, 13461, 13456, + 1, 0, 0, 0, 13461, 13457, 1, 0, 0, 0, 13461, 13458, 1, 0, 0, 0, 13461, + 13459, 1, 0, 0, 0, 13461, 13460, 1, 0, 0, 0, 13462, 1369, 1, 0, 0, 0, 13463, + 13465, 5, 1409, 0, 0, 13464, 13463, 1, 0, 0, 0, 13464, 13465, 1, 0, 0, + 0, 13465, 13466, 1, 0, 0, 0, 13466, 13468, 5, 350, 0, 0, 13467, 13469, + 3, 1366, 683, 0, 13468, 13467, 1, 0, 0, 0, 13468, 13469, 1, 0, 0, 0, 13469, + 1371, 1, 0, 0, 0, 13470, 13473, 5, 988, 0, 0, 13471, 13472, 7, 169, 0, + 0, 13472, 13474, 5, 350, 0, 0, 13473, 13471, 1, 0, 0, 0, 13473, 13474, + 1, 0, 0, 0, 13474, 13490, 1, 0, 0, 0, 13475, 13478, 5, 1264, 0, 0, 13476, + 13477, 5, 1505, 0, 0, 13477, 13479, 5, 2313, 0, 0, 13478, 13476, 1, 0, + 0, 0, 13478, 13479, 1, 0, 0, 0, 13479, 13481, 1, 0, 0, 0, 13480, 13482, + 3, 1374, 687, 0, 13481, 13480, 1, 0, 0, 0, 13481, 13482, 1, 0, 0, 0, 13482, + 13484, 1, 0, 0, 0, 13483, 13485, 3, 1376, 688, 0, 13484, 13483, 1, 0, 0, + 0, 13484, 13485, 1, 0, 0, 0, 13485, 13490, 1, 0, 0, 0, 13486, 13487, 5, + 1264, 0, 0, 13487, 13488, 5, 1505, 0, 0, 13488, 13490, 5, 1258, 0, 0, 13489, + 13470, 1, 0, 0, 0, 13489, 13475, 1, 0, 0, 0, 13489, 13486, 1, 0, 0, 0, + 13490, 1373, 1, 0, 0, 0, 13491, 13492, 7, 63, 0, 0, 13492, 1375, 1, 0, + 0, 0, 13493, 13494, 7, 170, 0, 0, 13494, 1377, 1, 0, 0, 0, 13495, 13501, + 3, 1382, 691, 0, 13496, 13501, 3, 1390, 695, 0, 13497, 13498, 3, 1380, + 690, 0, 13498, 13499, 5, 102, 0, 0, 13499, 13501, 1, 0, 0, 0, 13500, 13495, + 1, 0, 0, 0, 13500, 13496, 1, 0, 0, 0, 13500, 13497, 1, 0, 0, 0, 13501, + 1379, 1, 0, 0, 0, 13502, 13503, 7, 171, 0, 0, 13503, 1381, 1, 0, 0, 0, + 13504, 13506, 5, 1516, 0, 0, 13505, 13507, 5, 95, 0, 0, 13506, 13505, 1, + 0, 0, 0, 13506, 13507, 1, 0, 0, 0, 13507, 13510, 1, 0, 0, 0, 13508, 13509, + 5, 628, 0, 0, 13509, 13511, 5, 2443, 0, 0, 13510, 13508, 1, 0, 0, 0, 13510, + 13511, 1, 0, 0, 0, 13511, 13534, 1, 0, 0, 0, 13512, 13517, 3, 1384, 692, + 0, 13513, 13517, 3, 1386, 693, 0, 13514, 13515, 5, 882, 0, 0, 13515, 13517, + 5, 2443, 0, 0, 13516, 13512, 1, 0, 0, 0, 13516, 13513, 1, 0, 0, 0, 13516, + 13514, 1, 0, 0, 0, 13516, 13517, 1, 0, 0, 0, 13517, 13527, 1, 0, 0, 0, + 13518, 13524, 5, 2095, 0, 0, 13519, 13520, 5, 40, 0, 0, 13520, 13521, 5, + 2441, 0, 0, 13521, 13524, 5, 306, 0, 0, 13522, 13524, 3, 928, 464, 0, 13523, + 13518, 1, 0, 0, 0, 13523, 13519, 1, 0, 0, 0, 13523, 13522, 1, 0, 0, 0, + 13524, 13525, 1, 0, 0, 0, 13525, 13523, 1, 0, 0, 0, 13525, 13526, 1, 0, + 0, 0, 13526, 13528, 1, 0, 0, 0, 13527, 13523, 1, 0, 0, 0, 13527, 13528, + 1, 0, 0, 0, 13528, 13535, 1, 0, 0, 0, 13529, 13531, 5, 297, 0, 0, 13530, + 13532, 5, 389, 0, 0, 13531, 13530, 1, 0, 0, 0, 13531, 13532, 1, 0, 0, 0, + 13532, 13535, 1, 0, 0, 0, 13533, 13535, 5, 174, 0, 0, 13534, 13516, 1, + 0, 0, 0, 13534, 13529, 1, 0, 0, 0, 13534, 13533, 1, 0, 0, 0, 13535, 1383, + 1, 0, 0, 0, 13536, 13538, 5, 1734, 0, 0, 13537, 13536, 1, 0, 0, 0, 13537, + 13538, 1, 0, 0, 0, 13538, 13539, 1, 0, 0, 0, 13539, 13559, 5, 350, 0, 0, + 13540, 13547, 5, 2202, 0, 0, 13541, 13548, 5, 174, 0, 0, 13542, 13543, + 5, 2112, 0, 0, 13543, 13548, 5, 2443, 0, 0, 13544, 13545, 5, 190, 0, 0, + 13545, 13548, 5, 2441, 0, 0, 13546, 13548, 5, 283, 0, 0, 13547, 13541, + 1, 0, 0, 0, 13547, 13542, 1, 0, 0, 0, 13547, 13544, 1, 0, 0, 0, 13547, + 13546, 1, 0, 0, 0, 13548, 13556, 1, 0, 0, 0, 13549, 13550, 5, 2246, 0, + 0, 13550, 13551, 5, 102, 0, 0, 13551, 13556, 5, 298, 0, 0, 13552, 13553, + 5, 1707, 0, 0, 13553, 13554, 5, 2112, 0, 0, 13554, 13556, 5, 2443, 0, 0, + 13555, 13540, 1, 0, 0, 0, 13555, 13549, 1, 0, 0, 0, 13555, 13552, 1, 0, + 0, 0, 13556, 13557, 1, 0, 0, 0, 13557, 13555, 1, 0, 0, 0, 13557, 13558, + 1, 0, 0, 0, 13558, 13560, 1, 0, 0, 0, 13559, 13555, 1, 0, 0, 0, 13559, + 13560, 1, 0, 0, 0, 13560, 1385, 1, 0, 0, 0, 13561, 13562, 5, 2080, 0, 0, + 13562, 13567, 3, 1656, 828, 0, 13563, 13564, 5, 2453, 0, 0, 13564, 13566, + 3, 1656, 828, 0, 13565, 13563, 1, 0, 0, 0, 13566, 13569, 1, 0, 0, 0, 13567, + 13565, 1, 0, 0, 0, 13567, 13568, 1, 0, 0, 0, 13568, 13583, 1, 0, 0, 0, + 13569, 13567, 1, 0, 0, 0, 13570, 13571, 5, 352, 0, 0, 13571, 13583, 5, + 2443, 0, 0, 13572, 13578, 3, 1456, 728, 0, 13573, 13574, 5, 2453, 0, 0, + 13574, 13577, 5, 2443, 0, 0, 13575, 13577, 3, 1456, 728, 0, 13576, 13573, + 1, 0, 0, 0, 13576, 13575, 1, 0, 0, 0, 13577, 13580, 1, 0, 0, 0, 13578, + 13576, 1, 0, 0, 0, 13578, 13579, 1, 0, 0, 0, 13579, 13583, 1, 0, 0, 0, + 13580, 13578, 1, 0, 0, 0, 13581, 13583, 3, 1388, 694, 0, 13582, 13561, + 1, 0, 0, 0, 13582, 13570, 1, 0, 0, 0, 13582, 13572, 1, 0, 0, 0, 13582, + 13581, 1, 0, 0, 0, 13583, 1387, 1, 0, 0, 0, 13584, 13585, 4, 694, 9, 0, + 13585, 13606, 5, 1734, 0, 0, 13586, 13587, 5, 2080, 0, 0, 13587, 13592, + 3, 1656, 828, 0, 13588, 13589, 5, 2453, 0, 0, 13589, 13591, 3, 1656, 828, + 0, 13590, 13588, 1, 0, 0, 0, 13591, 13594, 1, 0, 0, 0, 13592, 13590, 1, + 0, 0, 0, 13592, 13593, 1, 0, 0, 0, 13593, 13607, 1, 0, 0, 0, 13594, 13592, + 1, 0, 0, 0, 13595, 13596, 5, 352, 0, 0, 13596, 13607, 5, 2443, 0, 0, 13597, + 13603, 3, 1456, 728, 0, 13598, 13599, 5, 2453, 0, 0, 13599, 13602, 5, 2443, + 0, 0, 13600, 13602, 3, 1456, 728, 0, 13601, 13598, 1, 0, 0, 0, 13601, 13600, + 1, 0, 0, 0, 13602, 13605, 1, 0, 0, 0, 13603, 13601, 1, 0, 0, 0, 13603, + 13604, 1, 0, 0, 0, 13604, 13607, 1, 0, 0, 0, 13605, 13603, 1, 0, 0, 0, + 13606, 13586, 1, 0, 0, 0, 13606, 13595, 1, 0, 0, 0, 13606, 13597, 1, 0, + 0, 0, 13607, 13608, 1, 0, 0, 0, 13608, 13611, 5, 2202, 0, 0, 13609, 13610, + 5, 283, 0, 0, 13610, 13612, 5, 2308, 0, 0, 13611, 13609, 1, 0, 0, 0, 13611, + 13612, 1, 0, 0, 0, 13612, 13613, 1, 0, 0, 0, 13613, 13614, 5, 298, 0, 0, + 13614, 1389, 1, 0, 0, 0, 13615, 13650, 5, 1516, 0, 0, 13616, 13617, 5, + 904, 0, 0, 13617, 13618, 5, 1734, 0, 0, 13618, 13640, 5, 350, 0, 0, 13619, + 13620, 5, 2246, 0, 0, 13620, 13621, 5, 336, 0, 0, 13621, 13635, 5, 882, + 0, 0, 13622, 13625, 5, 439, 0, 0, 13623, 13624, 5, 628, 0, 0, 13624, 13626, + 5, 1667, 0, 0, 13625, 13623, 1, 0, 0, 0, 13625, 13626, 1, 0, 0, 0, 13626, + 13635, 1, 0, 0, 0, 13627, 13635, 5, 1087, 0, 0, 13628, 13629, 5, 2202, + 0, 0, 13629, 13630, 5, 190, 0, 0, 13630, 13635, 5, 2441, 0, 0, 13631, 13632, + 5, 2202, 0, 0, 13632, 13635, 5, 283, 0, 0, 13633, 13635, 3, 928, 464, 0, + 13634, 13619, 1, 0, 0, 0, 13634, 13622, 1, 0, 0, 0, 13634, 13627, 1, 0, + 0, 0, 13634, 13628, 1, 0, 0, 0, 13634, 13631, 1, 0, 0, 0, 13634, 13633, + 1, 0, 0, 0, 13635, 13636, 1, 0, 0, 0, 13636, 13634, 1, 0, 0, 0, 13636, + 13637, 1, 0, 0, 0, 13637, 13641, 1, 0, 0, 0, 13638, 13641, 5, 597, 0, 0, + 13639, 13641, 5, 174, 0, 0, 13640, 13634, 1, 0, 0, 0, 13640, 13638, 1, + 0, 0, 0, 13640, 13639, 1, 0, 0, 0, 13640, 13641, 1, 0, 0, 0, 13641, 13651, + 1, 0, 0, 0, 13642, 13643, 5, 2141, 0, 0, 13643, 13644, 5, 885, 0, 0, 13644, + 13648, 5, 1734, 0, 0, 13645, 13649, 3, 1392, 696, 0, 13646, 13647, 5, 814, + 0, 0, 13647, 13649, 5, 687, 0, 0, 13648, 13645, 1, 0, 0, 0, 13648, 13646, + 1, 0, 0, 0, 13649, 13651, 1, 0, 0, 0, 13650, 13616, 1, 0, 0, 0, 13650, + 13642, 1, 0, 0, 0, 13651, 1391, 1, 0, 0, 0, 13652, 13653, 3, 2410, 1205, + 0, 13653, 1393, 1, 0, 0, 0, 13654, 13655, 5, 1559, 0, 0, 13655, 13656, + 5, 589, 0, 0, 13656, 13661, 3, 1458, 729, 0, 13657, 13658, 5, 2453, 0, + 0, 13658, 13660, 3, 1458, 729, 0, 13659, 13657, 1, 0, 0, 0, 13660, 13663, + 1, 0, 0, 0, 13661, 13659, 1, 0, 0, 0, 13661, 13662, 1, 0, 0, 0, 13662, + 13664, 1, 0, 0, 0, 13663, 13661, 1, 0, 0, 0, 13664, 13665, 5, 2141, 0, + 0, 13665, 13666, 3, 1458, 729, 0, 13666, 13672, 1, 0, 0, 0, 13667, 13672, + 3, 1396, 698, 0, 13668, 13672, 3, 1398, 699, 0, 13669, 13672, 3, 1400, + 700, 0, 13670, 13672, 3, 1402, 701, 0, 13671, 13654, 1, 0, 0, 0, 13671, + 13667, 1, 0, 0, 0, 13671, 13668, 1, 0, 0, 0, 13671, 13669, 1, 0, 0, 0, + 13671, 13670, 1, 0, 0, 0, 13672, 1395, 1, 0, 0, 0, 13673, 13674, 5, 321, + 0, 0, 13674, 13677, 5, 352, 0, 0, 13675, 13678, 3, 1458, 729, 0, 13676, + 13678, 3, 1456, 728, 0, 13677, 13675, 1, 0, 0, 0, 13677, 13676, 1, 0, 0, + 0, 13678, 13686, 1, 0, 0, 0, 13679, 13682, 5, 2453, 0, 0, 13680, 13683, + 3, 1458, 729, 0, 13681, 13683, 3, 1456, 728, 0, 13682, 13680, 1, 0, 0, + 0, 13682, 13681, 1, 0, 0, 0, 13683, 13685, 1, 0, 0, 0, 13684, 13679, 1, + 0, 0, 0, 13685, 13688, 1, 0, 0, 0, 13686, 13684, 1, 0, 0, 0, 13686, 13687, + 1, 0, 0, 0, 13687, 13691, 1, 0, 0, 0, 13688, 13686, 1, 0, 0, 0, 13689, + 13690, 5, 69, 0, 0, 13690, 13692, 5, 1021, 0, 0, 13691, 13689, 1, 0, 0, + 0, 13691, 13692, 1, 0, 0, 0, 13692, 1397, 1, 0, 0, 0, 13693, 13696, 5, + 352, 0, 0, 13694, 13697, 3, 1458, 729, 0, 13695, 13697, 3, 1456, 728, 0, + 13696, 13694, 1, 0, 0, 0, 13696, 13695, 1, 0, 0, 0, 13697, 13705, 1, 0, + 0, 0, 13698, 13701, 5, 2453, 0, 0, 13699, 13702, 3, 1458, 729, 0, 13700, + 13702, 3, 1456, 728, 0, 13701, 13699, 1, 0, 0, 0, 13701, 13700, 1, 0, 0, + 0, 13702, 13704, 1, 0, 0, 0, 13703, 13698, 1, 0, 0, 0, 13704, 13707, 1, + 0, 0, 0, 13705, 13703, 1, 0, 0, 0, 13705, 13706, 1, 0, 0, 0, 13706, 13719, + 1, 0, 0, 0, 13707, 13705, 1, 0, 0, 0, 13708, 13720, 5, 1256, 0, 0, 13709, + 13712, 5, 1243, 0, 0, 13710, 13711, 5, 620, 0, 0, 13711, 13713, 5, 469, + 0, 0, 13712, 13710, 1, 0, 0, 0, 13712, 13713, 1, 0, 0, 0, 13713, 13720, + 1, 0, 0, 0, 13714, 13715, 5, 1567, 0, 0, 13715, 13720, 3, 1176, 588, 0, + 13716, 13720, 3, 922, 461, 0, 13717, 13718, 5, 508, 0, 0, 13718, 13720, + 5, 102, 0, 0, 13719, 13708, 1, 0, 0, 0, 13719, 13709, 1, 0, 0, 0, 13719, + 13714, 1, 0, 0, 0, 13719, 13716, 1, 0, 0, 0, 13719, 13717, 1, 0, 0, 0, + 13720, 1399, 1, 0, 0, 0, 13721, 13724, 5, 2089, 0, 0, 13722, 13725, 3, + 1458, 729, 0, 13723, 13725, 3, 1456, 728, 0, 13724, 13722, 1, 0, 0, 0, + 13724, 13723, 1, 0, 0, 0, 13725, 13733, 1, 0, 0, 0, 13726, 13729, 5, 2453, + 0, 0, 13727, 13730, 3, 1458, 729, 0, 13728, 13730, 3, 1456, 728, 0, 13729, + 13727, 1, 0, 0, 0, 13729, 13728, 1, 0, 0, 0, 13730, 13732, 1, 0, 0, 0, + 13731, 13726, 1, 0, 0, 0, 13732, 13735, 1, 0, 0, 0, 13733, 13731, 1, 0, + 0, 0, 13733, 13734, 1, 0, 0, 0, 13734, 13744, 1, 0, 0, 0, 13735, 13733, + 1, 0, 0, 0, 13736, 13737, 5, 1567, 0, 0, 13737, 13745, 3, 1176, 588, 0, + 13738, 13745, 3, 922, 461, 0, 13739, 13740, 5, 469, 0, 0, 13740, 13741, + 5, 705, 0, 0, 13741, 13745, 5, 353, 0, 0, 13742, 13745, 5, 1256, 0, 0, + 13743, 13745, 5, 1243, 0, 0, 13744, 13736, 1, 0, 0, 0, 13744, 13738, 1, + 0, 0, 0, 13744, 13739, 1, 0, 0, 0, 13744, 13742, 1, 0, 0, 0, 13744, 13743, + 1, 0, 0, 0, 13745, 1401, 1, 0, 0, 0, 13746, 13747, 5, 992, 0, 0, 13747, + 13750, 5, 352, 0, 0, 13748, 13751, 3, 1458, 729, 0, 13749, 13751, 3, 1456, + 728, 0, 13750, 13748, 1, 0, 0, 0, 13750, 13749, 1, 0, 0, 0, 13751, 13759, + 1, 0, 0, 0, 13752, 13755, 5, 2453, 0, 0, 13753, 13756, 3, 1458, 729, 0, + 13754, 13756, 3, 1456, 728, 0, 13755, 13753, 1, 0, 0, 0, 13755, 13754, + 1, 0, 0, 0, 13756, 13758, 1, 0, 0, 0, 13757, 13752, 1, 0, 0, 0, 13758, + 13761, 1, 0, 0, 0, 13759, 13757, 1, 0, 0, 0, 13759, 13760, 1, 0, 0, 0, + 13760, 13764, 1, 0, 0, 0, 13761, 13759, 1, 0, 0, 0, 13762, 13763, 5, 2141, + 0, 0, 13763, 13765, 3, 1458, 729, 0, 13764, 13762, 1, 0, 0, 0, 13764, 13765, + 1, 0, 0, 0, 13765, 13767, 1, 0, 0, 0, 13766, 13768, 5, 1587, 0, 0, 13767, + 13766, 1, 0, 0, 0, 13767, 13768, 1, 0, 0, 0, 13768, 13770, 1, 0, 0, 0, + 13769, 13771, 5, 814, 0, 0, 13770, 13769, 1, 0, 0, 0, 13770, 13771, 1, + 0, 0, 0, 13771, 1403, 1, 0, 0, 0, 13772, 13774, 5, 66, 0, 0, 13773, 13775, + 5, 909, 0, 0, 13774, 13773, 1, 0, 0, 0, 13774, 13775, 1, 0, 0, 0, 13775, + 13778, 1, 0, 0, 0, 13776, 13778, 5, 1058, 0, 0, 13777, 13772, 1, 0, 0, + 0, 13777, 13776, 1, 0, 0, 0, 13778, 13829, 1, 0, 0, 0, 13779, 13781, 5, + 1137, 0, 0, 13780, 13779, 1, 0, 0, 0, 13780, 13781, 1, 0, 0, 0, 13781, + 13782, 1, 0, 0, 0, 13782, 13783, 5, 616, 0, 0, 13783, 13829, 5, 884, 0, + 0, 13784, 13785, 5, 1671, 0, 0, 13785, 13786, 5, 1734, 0, 0, 13786, 13787, + 5, 1119, 0, 0, 13787, 13792, 5, 620, 0, 0, 13788, 13789, 5, 351, 0, 0, + 13789, 13793, 5, 98, 0, 0, 13790, 13791, 5, 867, 0, 0, 13791, 13793, 5, + 1385, 0, 0, 13792, 13788, 1, 0, 0, 0, 13792, 13790, 1, 0, 0, 0, 13793, + 13829, 1, 0, 0, 0, 13794, 13795, 5, 1559, 0, 0, 13795, 13796, 5, 589, 0, + 0, 13796, 13801, 3, 1458, 729, 0, 13797, 13798, 5, 2453, 0, 0, 13798, 13800, + 3, 1458, 729, 0, 13799, 13797, 1, 0, 0, 0, 13800, 13803, 1, 0, 0, 0, 13801, + 13799, 1, 0, 0, 0, 13801, 13802, 1, 0, 0, 0, 13802, 13804, 1, 0, 0, 0, + 13803, 13801, 1, 0, 0, 0, 13804, 13805, 5, 2141, 0, 0, 13805, 13806, 3, + 1458, 729, 0, 13806, 13829, 1, 0, 0, 0, 13807, 13809, 5, 212, 0, 0, 13808, + 13810, 5, 2173, 0, 0, 13809, 13808, 1, 0, 0, 0, 13809, 13810, 1, 0, 0, + 0, 13810, 13811, 1, 0, 0, 0, 13811, 13812, 5, 882, 0, 0, 13812, 13817, + 3, 1420, 710, 0, 13813, 13814, 5, 2453, 0, 0, 13814, 13816, 3, 1420, 710, + 0, 13815, 13813, 1, 0, 0, 0, 13816, 13819, 1, 0, 0, 0, 13817, 13815, 1, + 0, 0, 0, 13817, 13818, 1, 0, 0, 0, 13818, 13822, 1, 0, 0, 0, 13819, 13817, + 1, 0, 0, 0, 13820, 13821, 5, 2198, 0, 0, 13821, 13823, 5, 352, 0, 0, 13822, + 13820, 1, 0, 0, 0, 13822, 13823, 1, 0, 0, 0, 13823, 13829, 1, 0, 0, 0, + 13824, 13829, 3, 1406, 703, 0, 13825, 13829, 3, 1410, 705, 0, 13826, 13829, + 3, 1412, 706, 0, 13827, 13829, 3, 1414, 707, 0, 13828, 13777, 1, 0, 0, + 0, 13828, 13780, 1, 0, 0, 0, 13828, 13784, 1, 0, 0, 0, 13828, 13794, 1, + 0, 0, 0, 13828, 13807, 1, 0, 0, 0, 13828, 13824, 1, 0, 0, 0, 13828, 13825, + 1, 0, 0, 0, 13828, 13826, 1, 0, 0, 0, 13828, 13827, 1, 0, 0, 0, 13829, + 1405, 1, 0, 0, 0, 13830, 13832, 5, 21, 0, 0, 13831, 13833, 5, 1734, 0, + 0, 13832, 13831, 1, 0, 0, 0, 13832, 13833, 1, 0, 0, 0, 13833, 13834, 1, + 0, 0, 0, 13834, 13870, 5, 882, 0, 0, 13835, 13836, 5, 759, 0, 0, 13836, + 13840, 5, 2443, 0, 0, 13837, 13838, 5, 2102, 0, 0, 13838, 13840, 5, 2441, + 0, 0, 13839, 13835, 1, 0, 0, 0, 13839, 13837, 1, 0, 0, 0, 13839, 13840, + 1, 0, 0, 0, 13840, 13842, 1, 0, 0, 0, 13841, 13843, 3, 1408, 704, 0, 13842, + 13841, 1, 0, 0, 0, 13843, 13844, 1, 0, 0, 0, 13844, 13842, 1, 0, 0, 0, + 13844, 13845, 1, 0, 0, 0, 13845, 13871, 1, 0, 0, 0, 13846, 13847, 5, 936, + 0, 0, 13847, 13849, 3, 1458, 729, 0, 13848, 13850, 5, 1587, 0, 0, 13849, + 13848, 1, 0, 0, 0, 13849, 13850, 1, 0, 0, 0, 13850, 13858, 1, 0, 0, 0, + 13851, 13852, 5, 2453, 0, 0, 13852, 13854, 3, 1458, 729, 0, 13853, 13855, + 5, 1587, 0, 0, 13854, 13853, 1, 0, 0, 0, 13854, 13855, 1, 0, 0, 0, 13855, + 13857, 1, 0, 0, 0, 13856, 13851, 1, 0, 0, 0, 13857, 13860, 1, 0, 0, 0, + 13858, 13856, 1, 0, 0, 0, 13858, 13859, 1, 0, 0, 0, 13859, 13861, 1, 0, + 0, 0, 13860, 13858, 1, 0, 0, 0, 13861, 13862, 5, 2141, 0, 0, 13862, 13867, + 3, 1420, 710, 0, 13863, 13864, 5, 2453, 0, 0, 13864, 13866, 3, 1420, 710, + 0, 13865, 13863, 1, 0, 0, 0, 13866, 13869, 1, 0, 0, 0, 13867, 13865, 1, + 0, 0, 0, 13867, 13868, 1, 0, 0, 0, 13868, 13871, 1, 0, 0, 0, 13869, 13867, + 1, 0, 0, 0, 13870, 13839, 1, 0, 0, 0, 13870, 13846, 1, 0, 0, 0, 13871, + 1407, 1, 0, 0, 0, 13872, 13873, 5, 649, 0, 0, 13873, 13875, 5, 2441, 0, + 0, 13874, 13872, 1, 0, 0, 0, 13874, 13875, 1, 0, 0, 0, 13875, 13876, 1, + 0, 0, 0, 13876, 13877, 3, 920, 460, 0, 13877, 1409, 1, 0, 0, 0, 13878, + 13880, 5, 469, 0, 0, 13879, 13881, 5, 1734, 0, 0, 13880, 13879, 1, 0, 0, + 0, 13880, 13881, 1, 0, 0, 0, 13881, 13882, 1, 0, 0, 0, 13882, 13900, 5, + 882, 0, 0, 13883, 13888, 3, 1420, 710, 0, 13884, 13885, 5, 2453, 0, 0, + 13885, 13887, 3, 1420, 710, 0, 13886, 13884, 1, 0, 0, 0, 13887, 13890, + 1, 0, 0, 0, 13888, 13886, 1, 0, 0, 0, 13888, 13889, 1, 0, 0, 0, 13889, + 13901, 1, 0, 0, 0, 13890, 13888, 1, 0, 0, 0, 13891, 13892, 5, 936, 0, 0, + 13892, 13897, 3, 1458, 729, 0, 13893, 13894, 5, 2453, 0, 0, 13894, 13896, + 3, 1458, 729, 0, 13895, 13893, 1, 0, 0, 0, 13896, 13899, 1, 0, 0, 0, 13897, + 13895, 1, 0, 0, 0, 13897, 13898, 1, 0, 0, 0, 13898, 13901, 1, 0, 0, 0, + 13899, 13897, 1, 0, 0, 0, 13900, 13883, 1, 0, 0, 0, 13900, 13891, 1, 0, + 0, 0, 13901, 1411, 1, 0, 0, 0, 13902, 13903, 5, 1793, 0, 0, 13903, 13904, + 5, 38, 0, 0, 13904, 13905, 5, 883, 0, 0, 13905, 13906, 5, 2141, 0, 0, 13906, + 13907, 5, 146, 0, 0, 13907, 13908, 5, 2441, 0, 0, 13908, 1413, 1, 0, 0, + 0, 13909, 13910, 3, 1416, 708, 0, 13910, 13911, 5, 1789, 0, 0, 13911, 13915, + 5, 888, 0, 0, 13912, 13916, 5, 351, 0, 0, 13913, 13916, 3, 1282, 641, 0, + 13914, 13916, 3, 1418, 709, 0, 13915, 13912, 1, 0, 0, 0, 13915, 13913, + 1, 0, 0, 0, 13915, 13914, 1, 0, 0, 0, 13916, 1415, 1, 0, 0, 0, 13917, 13918, + 7, 9, 0, 0, 13918, 1417, 1, 0, 0, 0, 13919, 13920, 5, 351, 0, 0, 13920, + 13921, 5, 620, 0, 0, 13921, 13922, 5, 1460, 0, 0, 13922, 13923, 5, 1563, + 0, 0, 13923, 1419, 1, 0, 0, 0, 13924, 13925, 5, 649, 0, 0, 13925, 13939, + 5, 2441, 0, 0, 13926, 13927, 5, 2447, 0, 0, 13927, 13932, 3, 1458, 729, + 0, 13928, 13929, 5, 2453, 0, 0, 13929, 13931, 3, 1458, 729, 0, 13930, 13928, + 1, 0, 0, 0, 13931, 13934, 1, 0, 0, 0, 13932, 13930, 1, 0, 0, 0, 13932, + 13933, 1, 0, 0, 0, 13933, 13935, 1, 0, 0, 0, 13934, 13932, 1, 0, 0, 0, + 13935, 13936, 5, 2448, 0, 0, 13936, 13939, 1, 0, 0, 0, 13937, 13939, 3, + 1458, 729, 0, 13938, 13924, 1, 0, 0, 0, 13938, 13926, 1, 0, 0, 0, 13938, + 13937, 1, 0, 0, 0, 13939, 1421, 1, 0, 0, 0, 13940, 13942, 5, 321, 0, 0, + 13941, 13943, 7, 172, 0, 0, 13942, 13941, 1, 0, 0, 0, 13942, 13943, 1, + 0, 0, 0, 13943, 13944, 1, 0, 0, 0, 13944, 13945, 5, 1734, 0, 0, 13945, + 13946, 5, 298, 0, 0, 13946, 13947, 5, 69, 0, 0, 13947, 13949, 3, 1458, + 729, 0, 13948, 13950, 5, 1587, 0, 0, 13949, 13948, 1, 0, 0, 0, 13949, 13950, + 1, 0, 0, 0, 13950, 13962, 1, 0, 0, 0, 13951, 13952, 5, 102, 0, 0, 13952, + 13953, 5, 298, 0, 0, 13953, 13959, 5, 2141, 0, 0, 13954, 13956, 3, 1458, + 729, 0, 13955, 13957, 5, 1587, 0, 0, 13956, 13955, 1, 0, 0, 0, 13956, 13957, + 1, 0, 0, 0, 13957, 13960, 1, 0, 0, 0, 13958, 13960, 3, 1424, 712, 0, 13959, + 13954, 1, 0, 0, 0, 13959, 13958, 1, 0, 0, 0, 13960, 13962, 1, 0, 0, 0, + 13961, 13940, 1, 0, 0, 0, 13961, 13951, 1, 0, 0, 0, 13962, 1423, 1, 0, + 0, 0, 13963, 13969, 5, 2143, 0, 0, 13964, 13965, 5, 69, 0, 0, 13965, 13967, + 3, 1458, 729, 0, 13966, 13968, 5, 1587, 0, 0, 13967, 13966, 1, 0, 0, 0, + 13967, 13968, 1, 0, 0, 0, 13968, 13970, 1, 0, 0, 0, 13969, 13964, 1, 0, + 0, 0, 13969, 13970, 1, 0, 0, 0, 13970, 13972, 1, 0, 0, 0, 13971, 13973, + 7, 63, 0, 0, 13972, 13971, 1, 0, 0, 0, 13972, 13973, 1, 0, 0, 0, 13973, + 1425, 1, 0, 0, 0, 13974, 13982, 3, 1428, 714, 0, 13975, 13982, 3, 1430, + 715, 0, 13976, 13982, 3, 1432, 716, 0, 13977, 13982, 3, 1434, 717, 0, 13978, + 13982, 3, 1436, 718, 0, 13979, 13982, 3, 1438, 719, 0, 13980, 13982, 3, + 1440, 720, 0, 13981, 13974, 1, 0, 0, 0, 13981, 13975, 1, 0, 0, 0, 13981, + 13976, 1, 0, 0, 0, 13981, 13977, 1, 0, 0, 0, 13981, 13978, 1, 0, 0, 0, + 13981, 13979, 1, 0, 0, 0, 13981, 13980, 1, 0, 0, 0, 13982, 13984, 1, 0, + 0, 0, 13983, 13985, 3, 928, 464, 0, 13984, 13983, 1, 0, 0, 0, 13984, 13985, + 1, 0, 0, 0, 13985, 1427, 1, 0, 0, 0, 13986, 13988, 5, 13, 0, 0, 13987, + 13989, 7, 172, 0, 0, 13988, 13987, 1, 0, 0, 0, 13988, 13989, 1, 0, 0, 0, + 13989, 13990, 1, 0, 0, 0, 13990, 13991, 5, 1734, 0, 0, 13991, 13994, 5, + 350, 0, 0, 13992, 13993, 5, 597, 0, 0, 13993, 13995, 5, 61, 0, 0, 13994, + 13992, 1, 0, 0, 0, 13994, 13995, 1, 0, 0, 0, 13995, 1429, 1, 0, 0, 0, 13996, + 13997, 5, 1671, 0, 0, 13997, 13998, 5, 1734, 0, 0, 13998, 13999, 5, 350, + 0, 0, 13999, 14000, 5, 2141, 0, 0, 14000, 14001, 5, 924, 0, 0, 14001, 14002, + 7, 173, 0, 0, 14002, 1431, 1, 0, 0, 0, 14003, 14006, 5, 1538, 0, 0, 14004, + 14005, 5, 1307, 0, 0, 14005, 14007, 5, 1562, 0, 0, 14006, 14004, 1, 0, + 0, 0, 14006, 14007, 1, 0, 0, 0, 14007, 14008, 1, 0, 0, 0, 14008, 14009, + 7, 172, 0, 0, 14009, 14010, 5, 882, 0, 0, 14010, 1433, 1, 0, 0, 0, 14011, + 14012, 7, 174, 0, 0, 14012, 14013, 5, 2141, 0, 0, 14013, 14042, 5, 1792, + 0, 0, 14014, 14035, 5, 2141, 0, 0, 14015, 14017, 7, 172, 0, 0, 14016, 14015, + 1, 0, 0, 0, 14016, 14017, 1, 0, 0, 0, 14017, 14018, 1, 0, 0, 0, 14018, + 14024, 5, 1451, 0, 0, 14019, 14021, 5, 1392, 0, 0, 14020, 14019, 1, 0, + 0, 0, 14020, 14021, 1, 0, 0, 0, 14021, 14022, 1, 0, 0, 0, 14022, 14024, + 5, 1734, 0, 0, 14023, 14016, 1, 0, 0, 0, 14023, 14020, 1, 0, 0, 0, 14024, + 14031, 1, 0, 0, 0, 14025, 14027, 7, 2, 0, 0, 14026, 14025, 1, 0, 0, 0, + 14026, 14027, 1, 0, 0, 0, 14027, 14028, 1, 0, 0, 0, 14028, 14029, 5, 1667, + 0, 0, 14029, 14030, 5, 1685, 0, 0, 14030, 14032, 7, 0, 0, 0, 14031, 14026, + 1, 0, 0, 0, 14031, 14032, 1, 0, 0, 0, 14032, 14036, 1, 0, 0, 0, 14033, + 14034, 5, 885, 0, 0, 14034, 14036, 5, 1734, 0, 0, 14035, 14023, 1, 0, 0, + 0, 14035, 14033, 1, 0, 0, 0, 14036, 14040, 1, 0, 0, 0, 14037, 14038, 5, + 885, 0, 0, 14038, 14040, 5, 1734, 0, 0, 14039, 14014, 1, 0, 0, 0, 14039, + 14037, 1, 0, 0, 0, 14040, 14043, 1, 0, 0, 0, 14041, 14043, 5, 174, 0, 0, + 14042, 14039, 1, 0, 0, 0, 14042, 14041, 1, 0, 0, 0, 14042, 14043, 1, 0, + 0, 0, 14043, 1435, 1, 0, 0, 0, 14044, 14045, 5, 1737, 0, 0, 14045, 14046, + 5, 885, 0, 0, 14046, 14047, 5, 1734, 0, 0, 14047, 14049, 5, 61, 0, 0, 14048, + 14050, 5, 698, 0, 0, 14049, 14048, 1, 0, 0, 0, 14049, 14050, 1, 0, 0, 0, + 14050, 14052, 1, 0, 0, 0, 14051, 14053, 5, 1087, 0, 0, 14052, 14051, 1, + 0, 0, 0, 14052, 14053, 1, 0, 0, 0, 14053, 14065, 1, 0, 0, 0, 14054, 14055, + 5, 1021, 0, 0, 14055, 14056, 5, 1451, 0, 0, 14056, 14066, 3, 2410, 1205, + 0, 14057, 14059, 5, 740, 0, 0, 14058, 14060, 5, 2441, 0, 0, 14059, 14058, + 1, 0, 0, 0, 14059, 14060, 1, 0, 0, 0, 14060, 14066, 1, 0, 0, 0, 14061, + 14062, 5, 1702, 0, 0, 14062, 14063, 5, 570, 0, 0, 14063, 14066, 5, 2147, + 0, 0, 14064, 14066, 5, 597, 0, 0, 14065, 14054, 1, 0, 0, 0, 14065, 14057, + 1, 0, 0, 0, 14065, 14061, 1, 0, 0, 0, 14065, 14064, 1, 0, 0, 0, 14065, + 14066, 1, 0, 0, 0, 14066, 1437, 1, 0, 0, 0, 14067, 14068, 7, 175, 0, 0, + 14068, 14069, 5, 885, 0, 0, 14069, 14070, 5, 1734, 0, 0, 14070, 14071, + 5, 61, 0, 0, 14071, 1439, 1, 0, 0, 0, 14072, 14073, 5, 300, 0, 0, 14073, + 14074, 5, 2141, 0, 0, 14074, 14075, 7, 176, 0, 0, 14075, 14076, 5, 1734, + 0, 0, 14076, 1441, 1, 0, 0, 0, 14077, 14078, 5, 389, 0, 0, 14078, 14079, + 5, 483, 0, 0, 14079, 14080, 5, 2472, 0, 0, 14080, 14124, 3, 1454, 727, + 0, 14081, 14082, 5, 1671, 0, 0, 14082, 14083, 5, 389, 0, 0, 14083, 14084, + 7, 101, 0, 0, 14084, 14124, 5, 2080, 0, 0, 14085, 14086, 5, 389, 0, 0, + 14086, 14087, 5, 2080, 0, 0, 14087, 14124, 3, 1656, 828, 0, 14088, 14089, + 5, 389, 0, 0, 14089, 14090, 5, 2092, 0, 0, 14090, 14093, 5, 2080, 0, 0, + 14091, 14094, 3, 1656, 828, 0, 14092, 14094, 3, 872, 436, 0, 14093, 14091, + 1, 0, 0, 0, 14093, 14092, 1, 0, 0, 0, 14094, 14124, 1, 0, 0, 0, 14095, + 14096, 5, 1559, 0, 0, 14096, 14097, 5, 644, 0, 0, 14097, 14098, 5, 2141, + 0, 0, 14098, 14101, 3, 1452, 726, 0, 14099, 14100, 5, 2440, 0, 0, 14100, + 14102, 3, 1450, 725, 0, 14101, 14099, 1, 0, 0, 0, 14102, 14103, 1, 0, 0, + 0, 14103, 14101, 1, 0, 0, 0, 14103, 14104, 1, 0, 0, 0, 14104, 14124, 1, + 0, 0, 0, 14105, 14106, 5, 499, 0, 0, 14106, 14107, 5, 143, 0, 0, 14107, + 14108, 5, 190, 0, 0, 14108, 14115, 5, 2145, 0, 0, 14109, 14110, 5, 2246, + 0, 0, 14110, 14111, 5, 589, 0, 0, 14111, 14113, 3, 1458, 729, 0, 14112, + 14114, 5, 1587, 0, 0, 14113, 14112, 1, 0, 0, 0, 14113, 14114, 1, 0, 0, + 0, 14114, 14116, 1, 0, 0, 0, 14115, 14109, 1, 0, 0, 0, 14115, 14116, 1, + 0, 0, 0, 14116, 14124, 1, 0, 0, 0, 14117, 14118, 5, 429, 0, 0, 14118, 14119, + 5, 143, 0, 0, 14119, 14120, 5, 190, 0, 0, 14120, 14124, 5, 2145, 0, 0, + 14121, 14124, 3, 876, 438, 0, 14122, 14124, 3, 1444, 722, 0, 14123, 14077, + 1, 0, 0, 0, 14123, 14081, 1, 0, 0, 0, 14123, 14085, 1, 0, 0, 0, 14123, + 14088, 1, 0, 0, 0, 14123, 14095, 1, 0, 0, 0, 14123, 14105, 1, 0, 0, 0, + 14123, 14117, 1, 0, 0, 0, 14123, 14121, 1, 0, 0, 0, 14123, 14122, 1, 0, + 0, 0, 14124, 1443, 1, 0, 0, 0, 14125, 14126, 5, 1671, 0, 0, 14126, 14127, + 5, 2113, 0, 0, 14127, 14128, 5, 2472, 0, 0, 14128, 14129, 5, 2443, 0, 0, + 14129, 1445, 1, 0, 0, 0, 14130, 14131, 3, 1308, 654, 0, 14131, 14132, 5, + 759, 0, 0, 14132, 14133, 5, 2443, 0, 0, 14133, 1447, 1, 0, 0, 0, 14134, + 14135, 5, 656, 0, 0, 14135, 14136, 7, 177, 0, 0, 14136, 1449, 1, 0, 0, + 0, 14137, 14138, 3, 2404, 1202, 0, 14138, 1451, 1, 0, 0, 0, 14139, 14140, + 3, 2404, 1202, 0, 14140, 1453, 1, 0, 0, 0, 14141, 14142, 3, 2410, 1205, + 0, 14142, 1455, 1, 0, 0, 0, 14143, 14144, 5, 2441, 0, 0, 14144, 1457, 1, + 0, 0, 0, 14145, 14146, 5, 2443, 0, 0, 14146, 1459, 1, 0, 0, 0, 14147, 14148, + 5, 1441, 0, 0, 14148, 14149, 5, 963, 0, 0, 14149, 14150, 5, 303, 0, 0, + 14150, 14154, 3, 2404, 1202, 0, 14151, 14152, 5, 2308, 0, 0, 14152, 14153, + 7, 178, 0, 0, 14153, 14155, 5, 1524, 0, 0, 14154, 14151, 1, 0, 0, 0, 14154, + 14155, 1, 0, 0, 0, 14155, 14159, 1, 0, 0, 0, 14156, 14157, 5, 620, 0, 0, + 14157, 14158, 5, 350, 0, 0, 14158, 14160, 3, 2404, 1202, 0, 14159, 14156, + 1, 0, 0, 0, 14159, 14160, 1, 0, 0, 0, 14160, 1461, 1, 0, 0, 0, 14161, 14162, + 5, 469, 0, 0, 14162, 14163, 5, 963, 0, 0, 14163, 14164, 5, 303, 0, 0, 14164, + 14165, 3, 2404, 1202, 0, 14165, 1463, 1, 0, 0, 0, 14166, 14167, 7, 179, + 0, 0, 14167, 14168, 5, 895, 0, 0, 14168, 14169, 5, 2313, 0, 0, 14169, 14170, + 5, 1469, 0, 0, 14170, 1465, 1, 0, 0, 0, 14171, 14174, 3, 1468, 734, 0, + 14172, 14174, 3, 1470, 735, 0, 14173, 14171, 1, 0, 0, 0, 14173, 14172, + 1, 0, 0, 0, 14174, 1467, 1, 0, 0, 0, 14175, 14176, 5, 1671, 0, 0, 14176, + 14177, 5, 836, 0, 0, 14177, 14178, 5, 2472, 0, 0, 14178, 14179, 7, 180, + 0, 0, 14179, 1469, 1, 0, 0, 0, 14180, 14181, 5, 1671, 0, 0, 14181, 14182, + 5, 837, 0, 0, 14182, 14183, 5, 2472, 0, 0, 14183, 14184, 5, 2443, 0, 0, + 14184, 1471, 1, 0, 0, 0, 14185, 14186, 5, 1467, 0, 0, 14186, 14187, 7, + 181, 0, 0, 14187, 14188, 5, 393, 0, 0, 14188, 14189, 5, 2472, 0, 0, 14189, + 14190, 3, 2404, 1202, 0, 14190, 1473, 1, 0, 0, 0, 14191, 14192, 5, 2211, + 0, 0, 14192, 14193, 5, 1795, 0, 0, 14193, 14194, 7, 100, 0, 0, 14194, 1475, + 1, 0, 0, 0, 14195, 14197, 5, 42, 0, 0, 14196, 14198, 5, 1679, 0, 0, 14197, + 14196, 1, 0, 0, 0, 14197, 14198, 1, 0, 0, 0, 14198, 14200, 1, 0, 0, 0, + 14199, 14201, 5, 1473, 0, 0, 14200, 14199, 1, 0, 0, 0, 14200, 14201, 1, + 0, 0, 0, 14201, 14202, 1, 0, 0, 0, 14202, 14203, 5, 350, 0, 0, 14203, 14204, + 5, 861, 0, 0, 14204, 14215, 3, 2336, 1168, 0, 14205, 14206, 5, 280, 0, + 0, 14206, 14207, 5, 2141, 0, 0, 14207, 14208, 3, 2354, 1177, 0, 14208, + 14209, 5, 685, 0, 0, 14209, 14210, 5, 160, 0, 0, 14210, 14212, 3, 1478, + 739, 0, 14211, 14213, 3, 1480, 740, 0, 14212, 14211, 1, 0, 0, 0, 14212, + 14213, 1, 0, 0, 0, 14213, 14216, 1, 0, 0, 0, 14214, 14216, 3, 1480, 740, + 0, 14215, 14205, 1, 0, 0, 0, 14215, 14214, 1, 0, 0, 0, 14216, 1477, 1, + 0, 0, 0, 14217, 14222, 3, 2404, 1202, 0, 14218, 14222, 3, 2396, 1198, 0, + 14219, 14220, 5, 2257, 0, 0, 14220, 14222, 5, 2443, 0, 0, 14221, 14217, + 1, 0, 0, 0, 14221, 14218, 1, 0, 0, 0, 14221, 14219, 1, 0, 0, 0, 14222, + 1479, 1, 0, 0, 0, 14223, 14224, 5, 86, 0, 0, 14224, 14225, 5, 160, 0, 0, + 14225, 14226, 3, 2354, 1177, 0, 14226, 14227, 5, 685, 0, 0, 14227, 14228, + 5, 160, 0, 0, 14228, 14229, 3, 1478, 739, 0, 14229, 1481, 1, 0, 0, 0, 14230, + 14231, 5, 321, 0, 0, 14231, 14232, 5, 1625, 0, 0, 14232, 14233, 5, 89, + 0, 0, 14233, 14239, 3, 2286, 1143, 0, 14234, 14238, 3, 1038, 519, 0, 14235, + 14238, 3, 836, 418, 0, 14236, 14238, 3, 764, 382, 0, 14237, 14234, 1, 0, + 0, 0, 14237, 14235, 1, 0, 0, 0, 14237, 14236, 1, 0, 0, 0, 14238, 14241, + 1, 0, 0, 0, 14239, 14237, 1, 0, 0, 0, 14239, 14240, 1, 0, 0, 0, 14240, + 1483, 1, 0, 0, 0, 14241, 14239, 1, 0, 0, 0, 14242, 14243, 5, 321, 0, 0, + 14243, 14244, 5, 350, 0, 0, 14244, 14283, 3, 1366, 683, 0, 14245, 14246, + 5, 2237, 0, 0, 14246, 14247, 7, 182, 0, 0, 14247, 14248, 5, 685, 0, 0, + 14248, 14249, 5, 160, 0, 0, 14249, 14284, 3, 1478, 739, 0, 14250, 14251, + 5, 298, 0, 0, 14251, 14284, 5, 1587, 0, 0, 14252, 14253, 7, 183, 0, 0, + 14253, 14284, 5, 2441, 0, 0, 14254, 14256, 5, 1001, 0, 0, 14255, 14254, + 1, 0, 0, 0, 14255, 14256, 1, 0, 0, 0, 14256, 14257, 1, 0, 0, 0, 14257, + 14258, 5, 193, 0, 0, 14258, 14259, 5, 1671, 0, 0, 14259, 14284, 3, 2346, + 1173, 0, 14260, 14261, 5, 1671, 0, 0, 14261, 14262, 5, 389, 0, 0, 14262, + 14263, 7, 101, 0, 0, 14263, 14284, 5, 2080, 0, 0, 14264, 14284, 3, 1486, + 743, 0, 14265, 14284, 3, 1490, 745, 0, 14266, 14284, 3, 1444, 722, 0, 14267, + 14269, 7, 101, 0, 0, 14268, 14267, 1, 0, 0, 0, 14268, 14269, 1, 0, 0, 0, + 14269, 14270, 1, 0, 0, 0, 14270, 14271, 5, 2230, 0, 0, 14271, 14272, 5, + 2080, 0, 0, 14272, 14273, 3, 872, 436, 0, 14273, 14274, 5, 352, 0, 0, 14274, + 14279, 3, 918, 459, 0, 14275, 14276, 5, 2453, 0, 0, 14276, 14278, 3, 918, + 459, 0, 14277, 14275, 1, 0, 0, 0, 14278, 14281, 1, 0, 0, 0, 14279, 14277, + 1, 0, 0, 0, 14279, 14280, 1, 0, 0, 0, 14280, 14284, 1, 0, 0, 0, 14281, + 14279, 1, 0, 0, 0, 14282, 14284, 3, 1492, 746, 0, 14283, 14245, 1, 0, 0, + 0, 14283, 14250, 1, 0, 0, 0, 14283, 14252, 1, 0, 0, 0, 14283, 14255, 1, + 0, 0, 0, 14283, 14260, 1, 0, 0, 0, 14283, 14264, 1, 0, 0, 0, 14283, 14265, + 1, 0, 0, 0, 14283, 14266, 1, 0, 0, 0, 14283, 14268, 1, 0, 0, 0, 14283, + 14282, 1, 0, 0, 0, 14284, 14285, 1, 0, 0, 0, 14285, 14283, 1, 0, 0, 0, + 14285, 14286, 1, 0, 0, 0, 14286, 1485, 1, 0, 0, 0, 14287, 14288, 5, 882, + 0, 0, 14288, 14293, 3, 1488, 744, 0, 14289, 14290, 5, 2453, 0, 0, 14290, + 14292, 3, 1488, 744, 0, 14291, 14289, 1, 0, 0, 0, 14292, 14295, 1, 0, 0, + 0, 14293, 14291, 1, 0, 0, 0, 14293, 14294, 1, 0, 0, 0, 14294, 14303, 1, + 0, 0, 0, 14295, 14293, 1, 0, 0, 0, 14296, 14297, 7, 184, 0, 0, 14297, 14303, + 5, 2441, 0, 0, 14298, 14303, 5, 66, 0, 0, 14299, 14303, 5, 1058, 0, 0, + 14300, 14301, 5, 616, 0, 0, 14301, 14303, 5, 884, 0, 0, 14302, 14287, 1, + 0, 0, 0, 14302, 14296, 1, 0, 0, 0, 14302, 14298, 1, 0, 0, 0, 14302, 14299, + 1, 0, 0, 0, 14302, 14300, 1, 0, 0, 0, 14303, 1487, 1, 0, 0, 0, 14304, 14305, + 5, 649, 0, 0, 14305, 14307, 5, 2441, 0, 0, 14306, 14304, 1, 0, 0, 0, 14306, + 14307, 1, 0, 0, 0, 14307, 14308, 1, 0, 0, 0, 14308, 14309, 3, 436, 218, + 0, 14309, 1489, 1, 0, 0, 0, 14310, 14311, 5, 558, 0, 0, 14311, 14312, 5, + 906, 0, 0, 14312, 14329, 5, 873, 0, 0, 14313, 14315, 5, 1800, 0, 0, 14314, + 14313, 1, 0, 0, 0, 14314, 14315, 1, 0, 0, 0, 14315, 14316, 1, 0, 0, 0, + 14316, 14317, 5, 352, 0, 0, 14317, 14322, 3, 436, 218, 0, 14318, 14319, + 5, 2453, 0, 0, 14319, 14321, 3, 436, 218, 0, 14320, 14318, 1, 0, 0, 0, + 14321, 14324, 1, 0, 0, 0, 14322, 14320, 1, 0, 0, 0, 14322, 14323, 1, 0, + 0, 0, 14323, 14329, 1, 0, 0, 0, 14324, 14322, 1, 0, 0, 0, 14325, 14329, + 3, 1502, 751, 0, 14326, 14329, 3, 1504, 752, 0, 14327, 14329, 3, 1506, + 753, 0, 14328, 14310, 1, 0, 0, 0, 14328, 14314, 1, 0, 0, 0, 14328, 14325, + 1, 0, 0, 0, 14328, 14326, 1, 0, 0, 0, 14328, 14327, 1, 0, 0, 0, 14329, + 1491, 1, 0, 0, 0, 14330, 14331, 5, 499, 0, 0, 14331, 14332, 5, 1409, 0, + 0, 14332, 14345, 5, 350, 0, 0, 14333, 14335, 5, 1642, 0, 0, 14334, 14336, + 3, 1494, 747, 0, 14335, 14334, 1, 0, 0, 0, 14335, 14336, 1, 0, 0, 0, 14336, + 14339, 1, 0, 0, 0, 14337, 14338, 5, 1949, 0, 0, 14338, 14340, 3, 1498, + 749, 0, 14339, 14337, 1, 0, 0, 0, 14339, 14340, 1, 0, 0, 0, 14340, 14343, + 1, 0, 0, 0, 14341, 14342, 5, 1800, 0, 0, 14342, 14344, 3, 1498, 749, 0, + 14343, 14341, 1, 0, 0, 0, 14343, 14344, 1, 0, 0, 0, 14344, 14346, 1, 0, + 0, 0, 14345, 14333, 1, 0, 0, 0, 14345, 14346, 1, 0, 0, 0, 14346, 14348, + 1, 0, 0, 0, 14347, 14349, 3, 1500, 750, 0, 14348, 14347, 1, 0, 0, 0, 14348, + 14349, 1, 0, 0, 0, 14349, 1493, 1, 0, 0, 0, 14350, 14351, 5, 590, 0, 0, + 14351, 14364, 5, 2472, 0, 0, 14352, 14353, 5, 2447, 0, 0, 14353, 14358, + 3, 1496, 748, 0, 14354, 14355, 5, 2453, 0, 0, 14355, 14357, 3, 1496, 748, + 0, 14356, 14354, 1, 0, 0, 0, 14357, 14360, 1, 0, 0, 0, 14358, 14356, 1, + 0, 0, 0, 14358, 14359, 1, 0, 0, 0, 14359, 14361, 1, 0, 0, 0, 14360, 14358, + 1, 0, 0, 0, 14361, 14362, 5, 2448, 0, 0, 14362, 14365, 1, 0, 0, 0, 14363, + 14365, 5, 1133, 0, 0, 14364, 14352, 1, 0, 0, 0, 14364, 14363, 1, 0, 0, + 0, 14365, 1495, 1, 0, 0, 0, 14366, 14369, 5, 2443, 0, 0, 14367, 14368, + 5, 2453, 0, 0, 14368, 14370, 5, 2443, 0, 0, 14369, 14367, 1, 0, 0, 0, 14369, + 14370, 1, 0, 0, 0, 14370, 1497, 1, 0, 0, 0, 14371, 14375, 5, 353, 0, 0, + 14372, 14373, 5, 1699, 0, 0, 14373, 14376, 3, 1176, 588, 0, 14374, 14376, + 3, 922, 461, 0, 14375, 14372, 1, 0, 0, 0, 14375, 14374, 1, 0, 0, 0, 14376, + 14377, 1, 0, 0, 0, 14377, 14375, 1, 0, 0, 0, 14377, 14378, 1, 0, 0, 0, + 14378, 1499, 1, 0, 0, 0, 14379, 14380, 5, 873, 0, 0, 14380, 14381, 5, 2178, + 0, 0, 14381, 14382, 7, 100, 0, 0, 14382, 1501, 1, 0, 0, 0, 14383, 14384, + 5, 389, 0, 0, 14384, 14385, 5, 2080, 0, 0, 14385, 14388, 3, 1656, 828, + 0, 14386, 14387, 5, 352, 0, 0, 14387, 14389, 3, 918, 459, 0, 14388, 14386, + 1, 0, 0, 0, 14388, 14389, 1, 0, 0, 0, 14389, 14391, 1, 0, 0, 0, 14390, + 14392, 3, 888, 444, 0, 14391, 14390, 1, 0, 0, 0, 14391, 14392, 1, 0, 0, + 0, 14392, 1503, 1, 0, 0, 0, 14393, 14395, 7, 101, 0, 0, 14394, 14393, 1, + 0, 0, 0, 14394, 14395, 1, 0, 0, 0, 14395, 14396, 1, 0, 0, 0, 14396, 14404, + 5, 389, 0, 0, 14397, 14398, 5, 2092, 0, 0, 14398, 14405, 5, 2080, 0, 0, + 14399, 14400, 5, 873, 0, 0, 14400, 14401, 5, 2092, 0, 0, 14401, 14402, + 5, 2080, 0, 0, 14402, 14403, 5, 620, 0, 0, 14403, 14405, 7, 185, 0, 0, + 14404, 14397, 1, 0, 0, 0, 14404, 14399, 1, 0, 0, 0, 14405, 14406, 1, 0, + 0, 0, 14406, 14416, 3, 1656, 828, 0, 14407, 14408, 5, 2089, 0, 0, 14408, + 14413, 3, 436, 218, 0, 14409, 14410, 5, 2453, 0, 0, 14410, 14412, 3, 436, + 218, 0, 14411, 14409, 1, 0, 0, 0, 14412, 14415, 1, 0, 0, 0, 14413, 14411, + 1, 0, 0, 0, 14413, 14414, 1, 0, 0, 0, 14414, 14417, 1, 0, 0, 0, 14415, + 14413, 1, 0, 0, 0, 14416, 14407, 1, 0, 0, 0, 14416, 14417, 1, 0, 0, 0, + 14417, 14419, 1, 0, 0, 0, 14418, 14420, 3, 888, 444, 0, 14419, 14418, 1, + 0, 0, 0, 14419, 14420, 1, 0, 0, 0, 14420, 1505, 1, 0, 0, 0, 14421, 14423, + 7, 101, 0, 0, 14422, 14421, 1, 0, 0, 0, 14422, 14423, 1, 0, 0, 0, 14423, + 14424, 1, 0, 0, 0, 14424, 14425, 5, 2178, 0, 0, 14425, 14426, 5, 2080, + 0, 0, 14426, 14436, 3, 1656, 828, 0, 14427, 14428, 5, 352, 0, 0, 14428, + 14433, 3, 436, 218, 0, 14429, 14430, 5, 2453, 0, 0, 14430, 14432, 3, 436, + 218, 0, 14431, 14429, 1, 0, 0, 0, 14432, 14435, 1, 0, 0, 0, 14433, 14431, + 1, 0, 0, 0, 14433, 14434, 1, 0, 0, 0, 14434, 14437, 1, 0, 0, 0, 14435, + 14433, 1, 0, 0, 0, 14436, 14427, 1, 0, 0, 0, 14436, 14437, 1, 0, 0, 0, + 14437, 1507, 1, 0, 0, 0, 14438, 14439, 5, 469, 0, 0, 14439, 14442, 5, 350, + 0, 0, 14440, 14441, 5, 705, 0, 0, 14441, 14443, 5, 103, 0, 0, 14442, 14440, + 1, 0, 0, 0, 14442, 14443, 1, 0, 0, 0, 14443, 14445, 1, 0, 0, 0, 14444, + 14446, 5, 1157, 0, 0, 14445, 14444, 1, 0, 0, 0, 14445, 14446, 1, 0, 0, + 0, 14446, 1509, 1, 0, 0, 0, 14447, 14449, 5, 321, 0, 0, 14448, 14450, 5, + 1679, 0, 0, 14449, 14448, 1, 0, 0, 0, 14449, 14450, 1, 0, 0, 0, 14450, + 14452, 1, 0, 0, 0, 14451, 14453, 5, 1473, 0, 0, 14452, 14451, 1, 0, 0, + 0, 14452, 14453, 1, 0, 0, 0, 14453, 14454, 1, 0, 0, 0, 14454, 14455, 5, + 350, 0, 0, 14455, 14456, 5, 861, 0, 0, 14456, 14472, 3, 2334, 1167, 0, + 14457, 14458, 5, 280, 0, 0, 14458, 14467, 5, 2141, 0, 0, 14459, 14468, + 5, 341, 0, 0, 14460, 14461, 3, 2354, 1177, 0, 14461, 14462, 5, 685, 0, + 0, 14462, 14463, 5, 160, 0, 0, 14463, 14465, 3, 1478, 739, 0, 14464, 14466, + 3, 1480, 740, 0, 14465, 14464, 1, 0, 0, 0, 14465, 14466, 1, 0, 0, 0, 14466, + 14468, 1, 0, 0, 0, 14467, 14459, 1, 0, 0, 0, 14467, 14460, 1, 0, 0, 0, + 14468, 14471, 1, 0, 0, 0, 14469, 14471, 3, 1480, 740, 0, 14470, 14457, + 1, 0, 0, 0, 14470, 14469, 1, 0, 0, 0, 14471, 14474, 1, 0, 0, 0, 14472, + 14470, 1, 0, 0, 0, 14472, 14473, 1, 0, 0, 0, 14473, 14477, 1, 0, 0, 0, + 14474, 14472, 1, 0, 0, 0, 14475, 14476, 5, 2246, 0, 0, 14476, 14478, 5, + 2443, 0, 0, 14477, 14475, 1, 0, 0, 0, 14477, 14478, 1, 0, 0, 0, 14478, + 1511, 1, 0, 0, 0, 14479, 14481, 5, 469, 0, 0, 14480, 14482, 5, 1473, 0, + 0, 14481, 14480, 1, 0, 0, 0, 14481, 14482, 1, 0, 0, 0, 14482, 14483, 1, + 0, 0, 0, 14483, 14484, 5, 350, 0, 0, 14484, 14485, 5, 861, 0, 0, 14485, + 14486, 3, 2334, 1167, 0, 14486, 1513, 1, 0, 0, 0, 14487, 14488, 5, 42, + 0, 0, 14488, 14489, 5, 2080, 0, 0, 14489, 14490, 5, 1671, 0, 0, 14490, + 14491, 3, 2404, 1202, 0, 14491, 14492, 3, 1516, 758, 0, 14492, 1515, 1, + 0, 0, 0, 14493, 14521, 3, 904, 452, 0, 14494, 14495, 5, 954, 0, 0, 14495, + 14496, 5, 558, 0, 0, 14496, 14521, 3, 1176, 588, 0, 14497, 14498, 5, 1567, + 0, 0, 14498, 14521, 3, 1176, 588, 0, 14499, 14521, 5, 228, 0, 0, 14500, + 14501, 5, 1684, 0, 0, 14501, 14504, 5, 1714, 0, 0, 14502, 14503, 5, 814, + 0, 0, 14503, 14505, 3, 1176, 588, 0, 14504, 14502, 1, 0, 0, 0, 14504, 14505, + 1, 0, 0, 0, 14505, 14521, 1, 0, 0, 0, 14506, 14507, 5, 1559, 0, 0, 14507, + 14508, 5, 2141, 0, 0, 14508, 14521, 3, 2404, 1202, 0, 14509, 14510, 7, + 171, 0, 0, 14510, 14521, 5, 102, 0, 0, 14511, 14521, 3, 866, 433, 0, 14512, + 14521, 3, 868, 434, 0, 14513, 14521, 3, 870, 435, 0, 14514, 14521, 3, 874, + 437, 0, 14515, 14521, 3, 922, 461, 0, 14516, 14521, 3, 876, 438, 0, 14517, + 14521, 3, 896, 448, 0, 14518, 14521, 3, 1518, 759, 0, 14519, 14521, 3, + 1464, 732, 0, 14520, 14493, 1, 0, 0, 0, 14520, 14494, 1, 0, 0, 0, 14520, + 14497, 1, 0, 0, 0, 14520, 14499, 1, 0, 0, 0, 14520, 14500, 1, 0, 0, 0, + 14520, 14506, 1, 0, 0, 0, 14520, 14509, 1, 0, 0, 0, 14520, 14511, 1, 0, + 0, 0, 14520, 14512, 1, 0, 0, 0, 14520, 14513, 1, 0, 0, 0, 14520, 14514, + 1, 0, 0, 0, 14520, 14515, 1, 0, 0, 0, 14520, 14516, 1, 0, 0, 0, 14520, + 14517, 1, 0, 0, 0, 14520, 14518, 1, 0, 0, 0, 14520, 14519, 1, 0, 0, 0, + 14521, 1517, 1, 0, 0, 0, 14522, 14547, 5, 506, 0, 0, 14523, 14529, 5, 1243, + 0, 0, 14524, 14526, 3, 884, 442, 0, 14525, 14524, 1, 0, 0, 0, 14525, 14526, + 1, 0, 0, 0, 14526, 14527, 1, 0, 0, 0, 14527, 14530, 5, 505, 0, 0, 14528, + 14530, 5, 387, 0, 0, 14529, 14525, 1, 0, 0, 0, 14529, 14528, 1, 0, 0, 0, + 14530, 14548, 1, 0, 0, 0, 14531, 14537, 5, 1256, 0, 0, 14532, 14534, 3, + 884, 442, 0, 14533, 14532, 1, 0, 0, 0, 14533, 14534, 1, 0, 0, 0, 14534, + 14535, 1, 0, 0, 0, 14535, 14538, 7, 186, 0, 0, 14536, 14538, 5, 387, 0, + 0, 14537, 14533, 1, 0, 0, 0, 14537, 14536, 1, 0, 0, 0, 14538, 14540, 1, + 0, 0, 0, 14539, 14541, 3, 1520, 760, 0, 14540, 14539, 1, 0, 0, 0, 14540, + 14541, 1, 0, 0, 0, 14541, 14548, 1, 0, 0, 0, 14542, 14543, 5, 597, 0, 0, + 14543, 14545, 7, 187, 0, 0, 14544, 14546, 3, 1520, 760, 0, 14545, 14544, + 1, 0, 0, 0, 14545, 14546, 1, 0, 0, 0, 14546, 14548, 1, 0, 0, 0, 14547, + 14523, 1, 0, 0, 0, 14547, 14531, 1, 0, 0, 0, 14547, 14542, 1, 0, 0, 0, + 14548, 1519, 1, 0, 0, 0, 14549, 14550, 5, 590, 0, 0, 14550, 14551, 5, 2472, + 0, 0, 14551, 14552, 5, 2447, 0, 0, 14552, 14553, 5, 2443, 0, 0, 14553, + 14554, 5, 2453, 0, 0, 14554, 14561, 5, 2443, 0, 0, 14555, 14556, 5, 2453, + 0, 0, 14556, 14557, 5, 2443, 0, 0, 14557, 14558, 5, 2453, 0, 0, 14558, + 14560, 5, 2443, 0, 0, 14559, 14555, 1, 0, 0, 0, 14560, 14563, 1, 0, 0, + 0, 14561, 14559, 1, 0, 0, 0, 14561, 14562, 1, 0, 0, 0, 14562, 14564, 1, + 0, 0, 0, 14563, 14561, 1, 0, 0, 0, 14564, 14566, 5, 2448, 0, 0, 14565, + 14567, 5, 814, 0, 0, 14566, 14565, 1, 0, 0, 0, 14566, 14567, 1, 0, 0, 0, + 14567, 1521, 1, 0, 0, 0, 14568, 14569, 5, 42, 0, 0, 14569, 14570, 5, 1593, + 0, 0, 14570, 14571, 3, 2308, 1154, 0, 14571, 14573, 3, 1524, 762, 0, 14572, + 14574, 3, 766, 383, 0, 14573, 14572, 1, 0, 0, 0, 14573, 14574, 1, 0, 0, + 0, 14574, 1523, 1, 0, 0, 0, 14575, 14576, 5, 1204, 0, 0, 14576, 14595, + 5, 685, 0, 0, 14577, 14592, 5, 685, 0, 0, 14578, 14579, 5, 160, 0, 0, 14579, + 14593, 3, 2402, 1201, 0, 14580, 14581, 5, 2246, 0, 0, 14581, 14584, 3, + 2402, 1201, 0, 14582, 14583, 5, 2440, 0, 0, 14583, 14585, 3, 2404, 1202, + 0, 14584, 14582, 1, 0, 0, 0, 14584, 14585, 1, 0, 0, 0, 14585, 14593, 1, + 0, 0, 0, 14586, 14593, 5, 561, 0, 0, 14587, 14590, 5, 643, 0, 0, 14588, + 14589, 5, 69, 0, 0, 14589, 14591, 5, 2443, 0, 0, 14590, 14588, 1, 0, 0, + 0, 14590, 14591, 1, 0, 0, 0, 14591, 14593, 1, 0, 0, 0, 14592, 14578, 1, + 0, 0, 0, 14592, 14580, 1, 0, 0, 0, 14592, 14586, 1, 0, 0, 0, 14592, 14587, + 1, 0, 0, 0, 14593, 14595, 1, 0, 0, 0, 14594, 14575, 1, 0, 0, 0, 14594, + 14577, 1, 0, 0, 0, 14595, 1525, 1, 0, 0, 0, 14596, 14597, 5, 42, 0, 0, + 14597, 14598, 5, 2083, 0, 0, 14598, 14602, 3, 2342, 1171, 0, 14599, 14601, + 3, 1528, 764, 0, 14600, 14599, 1, 0, 0, 0, 14601, 14604, 1, 0, 0, 0, 14602, + 14600, 1, 0, 0, 0, 14602, 14603, 1, 0, 0, 0, 14603, 14611, 1, 0, 0, 0, + 14604, 14602, 1, 0, 0, 0, 14605, 14612, 1, 0, 0, 0, 14606, 14612, 3, 1530, + 765, 0, 14607, 14612, 3, 1702, 851, 0, 14608, 14612, 3, 1604, 802, 0, 14609, + 14612, 3, 1532, 766, 0, 14610, 14612, 3, 1594, 797, 0, 14611, 14605, 1, + 0, 0, 0, 14611, 14606, 1, 0, 0, 0, 14611, 14607, 1, 0, 0, 0, 14611, 14608, + 1, 0, 0, 0, 14611, 14609, 1, 0, 0, 0, 14611, 14610, 1, 0, 0, 0, 14612, + 14625, 1, 0, 0, 0, 14613, 14622, 3, 1584, 792, 0, 14614, 14619, 3, 1308, + 654, 0, 14615, 14616, 5, 2083, 0, 0, 14616, 14620, 5, 881, 0, 0, 14617, + 14618, 5, 38, 0, 0, 14618, 14620, 5, 2156, 0, 0, 14619, 14615, 1, 0, 0, + 0, 14619, 14617, 1, 0, 0, 0, 14620, 14622, 1, 0, 0, 0, 14621, 14613, 1, + 0, 0, 0, 14621, 14614, 1, 0, 0, 0, 14622, 14623, 1, 0, 0, 0, 14623, 14621, + 1, 0, 0, 0, 14623, 14624, 1, 0, 0, 0, 14624, 14626, 1, 0, 0, 0, 14625, + 14621, 1, 0, 0, 0, 14625, 14626, 1, 0, 0, 0, 14626, 1527, 1, 0, 0, 0, 14627, + 14629, 5, 1137, 0, 0, 14628, 14627, 1, 0, 0, 0, 14628, 14629, 1, 0, 0, + 0, 14629, 14630, 1, 0, 0, 0, 14630, 14631, 5, 2408, 0, 0, 14631, 14632, + 5, 620, 0, 0, 14632, 14633, 7, 188, 0, 0, 14633, 1529, 1, 0, 0, 0, 14634, + 14652, 3, 1562, 781, 0, 14635, 14636, 5, 1559, 0, 0, 14636, 14637, 5, 2141, + 0, 0, 14637, 14652, 3, 2342, 1171, 0, 14638, 14652, 3, 1288, 644, 0, 14639, + 14640, 5, 1505, 0, 0, 14640, 14652, 5, 1258, 0, 0, 14641, 14642, 5, 1505, + 0, 0, 14642, 14652, 5, 2313, 0, 0, 14643, 14644, 5, 1550, 0, 0, 14644, + 14652, 5, 2443, 0, 0, 14645, 14647, 5, 1137, 0, 0, 14646, 14645, 1, 0, + 0, 0, 14646, 14647, 1, 0, 0, 0, 14647, 14648, 1, 0, 0, 0, 14648, 14649, + 5, 1606, 0, 0, 14649, 14652, 5, 63, 0, 0, 14650, 14652, 3, 2246, 1123, + 0, 14651, 14634, 1, 0, 0, 0, 14651, 14635, 1, 0, 0, 0, 14651, 14638, 1, + 0, 0, 0, 14651, 14639, 1, 0, 0, 0, 14651, 14641, 1, 0, 0, 0, 14651, 14643, + 1, 0, 0, 0, 14651, 14646, 1, 0, 0, 0, 14651, 14650, 1, 0, 0, 0, 14652, + 1531, 1, 0, 0, 0, 14653, 14665, 3, 1534, 767, 0, 14654, 14665, 3, 1536, + 768, 0, 14655, 14665, 3, 1538, 769, 0, 14656, 14665, 3, 1540, 770, 0, 14657, + 14665, 3, 1542, 771, 0, 14658, 14665, 3, 1544, 772, 0, 14659, 14665, 3, + 1546, 773, 0, 14660, 14665, 3, 1548, 774, 0, 14661, 14665, 3, 1550, 775, + 0, 14662, 14665, 3, 1552, 776, 0, 14663, 14665, 3, 1556, 778, 0, 14664, + 14653, 1, 0, 0, 0, 14664, 14654, 1, 0, 0, 0, 14664, 14655, 1, 0, 0, 0, + 14664, 14656, 1, 0, 0, 0, 14664, 14657, 1, 0, 0, 0, 14664, 14658, 1, 0, + 0, 0, 14664, 14659, 1, 0, 0, 0, 14664, 14660, 1, 0, 0, 0, 14664, 14661, + 1, 0, 0, 0, 14664, 14662, 1, 0, 0, 0, 14664, 14663, 1, 0, 0, 0, 14665, + 1533, 1, 0, 0, 0, 14666, 14683, 5, 21, 0, 0, 14667, 14684, 3, 1140, 570, + 0, 14668, 14684, 3, 1142, 571, 0, 14669, 14671, 5, 1348, 0, 0, 14670, 14672, + 3, 1696, 848, 0, 14671, 14670, 1, 0, 0, 0, 14671, 14672, 1, 0, 0, 0, 14672, + 14675, 1, 0, 0, 0, 14673, 14674, 5, 2080, 0, 0, 14674, 14676, 3, 1656, + 828, 0, 14675, 14673, 1, 0, 0, 0, 14675, 14676, 1, 0, 0, 0, 14676, 14678, + 1, 0, 0, 0, 14677, 14679, 3, 1600, 800, 0, 14678, 14677, 1, 0, 0, 0, 14678, + 14679, 1, 0, 0, 0, 14679, 14681, 1, 0, 0, 0, 14680, 14682, 5, 2203, 0, + 0, 14681, 14680, 1, 0, 0, 0, 14681, 14682, 1, 0, 0, 0, 14682, 14684, 1, + 0, 0, 0, 14683, 14667, 1, 0, 0, 0, 14683, 14668, 1, 0, 0, 0, 14683, 14669, + 1, 0, 0, 0, 14684, 1535, 1, 0, 0, 0, 14685, 14688, 5, 469, 0, 0, 14686, + 14689, 3, 1558, 779, 0, 14687, 14689, 3, 1560, 780, 0, 14688, 14686, 1, + 0, 0, 0, 14688, 14687, 1, 0, 0, 0, 14689, 14694, 1, 0, 0, 0, 14690, 14692, + 3, 1572, 786, 0, 14691, 14693, 3, 928, 464, 0, 14692, 14691, 1, 0, 0, 0, + 14692, 14693, 1, 0, 0, 0, 14693, 14695, 1, 0, 0, 0, 14694, 14690, 1, 0, + 0, 0, 14694, 14695, 1, 0, 0, 0, 14695, 1537, 1, 0, 0, 0, 14696, 14697, + 5, 946, 0, 0, 14697, 14698, 5, 1348, 0, 0, 14698, 14699, 3, 1696, 848, + 0, 14699, 14700, 5, 49, 0, 0, 14700, 14701, 3, 1696, 848, 0, 14701, 14702, + 5, 779, 0, 0, 14702, 14703, 5, 1348, 0, 0, 14703, 14704, 3, 1696, 848, + 0, 14704, 1539, 1, 0, 0, 0, 14705, 14728, 5, 980, 0, 0, 14706, 14707, 7, + 189, 0, 0, 14707, 14710, 3, 1696, 848, 0, 14708, 14709, 7, 9, 0, 0, 14709, + 14711, 3, 1168, 584, 0, 14710, 14708, 1, 0, 0, 0, 14710, 14711, 1, 0, 0, + 0, 14711, 14714, 1, 0, 0, 0, 14712, 14713, 5, 21, 0, 0, 14713, 14715, 3, + 1156, 578, 0, 14714, 14712, 1, 0, 0, 0, 14714, 14715, 1, 0, 0, 0, 14715, + 14722, 1, 0, 0, 0, 14716, 14718, 5, 1511, 0, 0, 14717, 14716, 1, 0, 0, + 0, 14717, 14718, 1, 0, 0, 0, 14718, 14719, 1, 0, 0, 0, 14719, 14720, 5, + 2203, 0, 0, 14720, 14721, 5, 873, 0, 0, 14721, 14723, 5, 714, 0, 0, 14722, + 14717, 1, 0, 0, 0, 14722, 14723, 1, 0, 0, 0, 14723, 14725, 1, 0, 0, 0, + 14724, 14726, 3, 1288, 644, 0, 14725, 14724, 1, 0, 0, 0, 14725, 14726, + 1, 0, 0, 0, 14726, 14729, 1, 0, 0, 0, 14727, 14729, 3, 1116, 558, 0, 14728, + 14706, 1, 0, 0, 0, 14728, 14727, 1, 0, 0, 0, 14729, 1541, 1, 0, 0, 0, 14730, + 14731, 5, 1717, 0, 0, 14731, 14777, 3, 1558, 779, 0, 14732, 14733, 5, 82, + 0, 0, 14733, 14734, 5, 2447, 0, 0, 14734, 14739, 3, 2186, 1093, 0, 14735, + 14736, 5, 2453, 0, 0, 14736, 14738, 3, 2186, 1093, 0, 14737, 14735, 1, + 0, 0, 0, 14738, 14741, 1, 0, 0, 0, 14739, 14737, 1, 0, 0, 0, 14739, 14740, + 1, 0, 0, 0, 14740, 14742, 1, 0, 0, 0, 14741, 14739, 1, 0, 0, 0, 14742, + 14743, 5, 2448, 0, 0, 14743, 14744, 5, 779, 0, 0, 14744, 14745, 5, 2447, + 0, 0, 14745, 14750, 3, 1140, 570, 0, 14746, 14747, 5, 2453, 0, 0, 14747, + 14749, 3, 1140, 570, 0, 14748, 14746, 1, 0, 0, 0, 14749, 14752, 1, 0, 0, + 0, 14750, 14748, 1, 0, 0, 0, 14750, 14751, 1, 0, 0, 0, 14751, 14753, 1, + 0, 0, 0, 14752, 14750, 1, 0, 0, 0, 14753, 14754, 5, 2448, 0, 0, 14754, + 14778, 1, 0, 0, 0, 14755, 14756, 5, 779, 0, 0, 14756, 14773, 5, 2447, 0, + 0, 14757, 14762, 3, 1140, 570, 0, 14758, 14759, 5, 2453, 0, 0, 14759, 14761, + 3, 1140, 570, 0, 14760, 14758, 1, 0, 0, 0, 14761, 14764, 1, 0, 0, 0, 14762, + 14760, 1, 0, 0, 0, 14762, 14763, 1, 0, 0, 0, 14763, 14774, 1, 0, 0, 0, + 14764, 14762, 1, 0, 0, 0, 14765, 14770, 3, 1142, 571, 0, 14766, 14767, + 5, 2453, 0, 0, 14767, 14769, 3, 1142, 571, 0, 14768, 14766, 1, 0, 0, 0, + 14769, 14772, 1, 0, 0, 0, 14770, 14768, 1, 0, 0, 0, 14770, 14771, 1, 0, + 0, 0, 14771, 14774, 1, 0, 0, 0, 14772, 14770, 1, 0, 0, 0, 14773, 14757, + 1, 0, 0, 0, 14773, 14765, 1, 0, 0, 0, 14774, 14775, 1, 0, 0, 0, 14775, + 14776, 5, 2448, 0, 0, 14776, 14778, 1, 0, 0, 0, 14777, 14732, 1, 0, 0, + 0, 14777, 14755, 1, 0, 0, 0, 14778, 14782, 1, 0, 0, 0, 14779, 14783, 3, + 1574, 787, 0, 14780, 14783, 3, 1572, 786, 0, 14781, 14783, 5, 1256, 0, + 0, 14782, 14779, 1, 0, 0, 0, 14782, 14780, 1, 0, 0, 0, 14782, 14781, 1, + 0, 0, 0, 14782, 14783, 1, 0, 0, 0, 14783, 1543, 1, 0, 0, 0, 14784, 14787, + 5, 2159, 0, 0, 14785, 14788, 3, 1558, 779, 0, 14786, 14788, 3, 1560, 780, + 0, 14787, 14785, 1, 0, 0, 0, 14787, 14786, 1, 0, 0, 0, 14788, 14797, 1, + 0, 0, 0, 14789, 14791, 5, 469, 0, 0, 14790, 14792, 5, 38, 0, 0, 14791, + 14790, 1, 0, 0, 0, 14791, 14792, 1, 0, 0, 0, 14792, 14795, 1, 0, 0, 0, + 14793, 14795, 5, 1587, 0, 0, 14794, 14789, 1, 0, 0, 0, 14794, 14793, 1, + 0, 0, 0, 14794, 14795, 1, 0, 0, 0, 14795, 14796, 1, 0, 0, 0, 14796, 14798, + 5, 1762, 0, 0, 14797, 14794, 1, 0, 0, 0, 14797, 14798, 1, 0, 0, 0, 14798, + 14800, 1, 0, 0, 0, 14799, 14801, 5, 179, 0, 0, 14800, 14799, 1, 0, 0, 0, + 14800, 14801, 1, 0, 0, 0, 14801, 14806, 1, 0, 0, 0, 14802, 14804, 3, 1572, + 786, 0, 14803, 14805, 3, 928, 464, 0, 14804, 14803, 1, 0, 0, 0, 14804, + 14805, 1, 0, 0, 0, 14805, 14807, 1, 0, 0, 0, 14806, 14802, 1, 0, 0, 0, + 14806, 14807, 1, 0, 0, 0, 14807, 1545, 1, 0, 0, 0, 14808, 14809, 5, 538, + 0, 0, 14809, 14810, 5, 1348, 0, 0, 14810, 14811, 3, 1696, 848, 0, 14811, + 14812, 5, 2308, 0, 0, 14812, 14813, 5, 2083, 0, 0, 14813, 14816, 3, 2342, + 1171, 0, 14814, 14815, 7, 110, 0, 0, 14815, 14817, 5, 714, 0, 0, 14816, + 14814, 1, 0, 0, 0, 14816, 14817, 1, 0, 0, 0, 14817, 14820, 1, 0, 0, 0, + 14818, 14819, 7, 2, 0, 0, 14819, 14821, 5, 2255, 0, 0, 14820, 14818, 1, + 0, 0, 0, 14820, 14821, 1, 0, 0, 0, 14821, 1547, 1, 0, 0, 0, 14822, 14823, + 5, 228, 0, 0, 14823, 14825, 5, 1348, 0, 0, 14824, 14826, 3, 928, 464, 0, + 14825, 14824, 1, 0, 0, 0, 14825, 14826, 1, 0, 0, 0, 14826, 14830, 1, 0, + 0, 0, 14827, 14828, 3, 1310, 655, 0, 14828, 14829, 5, 224, 0, 0, 14829, + 14831, 1, 0, 0, 0, 14830, 14827, 1, 0, 0, 0, 14830, 14831, 1, 0, 0, 0, + 14831, 1549, 1, 0, 0, 0, 14832, 14833, 5, 1671, 0, 0, 14833, 14834, 5, + 776, 0, 0, 14834, 14837, 5, 2447, 0, 0, 14835, 14838, 3, 2394, 1197, 0, + 14836, 14838, 3, 2078, 1039, 0, 14837, 14835, 1, 0, 0, 0, 14837, 14836, + 1, 0, 0, 0, 14837, 14838, 1, 0, 0, 0, 14838, 14839, 1, 0, 0, 0, 14839, + 14840, 5, 2448, 0, 0, 14840, 1551, 1, 0, 0, 0, 14841, 14856, 5, 992, 0, + 0, 14842, 14845, 3, 1558, 779, 0, 14843, 14844, 5, 911, 0, 0, 14844, 14846, + 5, 2083, 0, 0, 14845, 14843, 1, 0, 0, 0, 14845, 14846, 1, 0, 0, 0, 14846, + 14847, 1, 0, 0, 0, 14847, 14848, 3, 1170, 585, 0, 14848, 14857, 1, 0, 0, + 0, 14849, 14851, 3, 1560, 780, 0, 14850, 14852, 3, 1088, 544, 0, 14851, + 14850, 1, 0, 0, 0, 14851, 14852, 1, 0, 0, 0, 14852, 14854, 1, 0, 0, 0, + 14853, 14855, 3, 1172, 586, 0, 14854, 14853, 1, 0, 0, 0, 14854, 14855, + 1, 0, 0, 0, 14855, 14857, 1, 0, 0, 0, 14856, 14842, 1, 0, 0, 0, 14856, + 14849, 1, 0, 0, 0, 14857, 14867, 1, 0, 0, 0, 14858, 14866, 3, 1554, 777, + 0, 14859, 14866, 3, 1572, 786, 0, 14860, 14866, 3, 928, 464, 0, 14861, + 14862, 3, 1310, 655, 0, 14862, 14863, 5, 224, 0, 0, 14863, 14866, 1, 0, + 0, 0, 14864, 14866, 5, 1256, 0, 0, 14865, 14858, 1, 0, 0, 0, 14865, 14859, + 1, 0, 0, 0, 14865, 14860, 1, 0, 0, 0, 14865, 14861, 1, 0, 0, 0, 14865, + 14864, 1, 0, 0, 0, 14866, 14869, 1, 0, 0, 0, 14867, 14865, 1, 0, 0, 0, + 14867, 14868, 1, 0, 0, 0, 14868, 1553, 1, 0, 0, 0, 14869, 14867, 1, 0, + 0, 0, 14870, 14871, 5, 705, 0, 0, 14871, 14872, 5, 1607, 0, 0, 14872, 14873, + 3, 2272, 1136, 0, 14873, 1555, 1, 0, 0, 0, 14874, 14877, 5, 1559, 0, 0, + 14875, 14878, 3, 1558, 779, 0, 14876, 14878, 3, 1560, 780, 0, 14877, 14875, + 1, 0, 0, 0, 14877, 14876, 1, 0, 0, 0, 14878, 14879, 1, 0, 0, 0, 14879, + 14880, 5, 2141, 0, 0, 14880, 14881, 3, 1696, 848, 0, 14881, 1557, 1, 0, + 0, 0, 14882, 14917, 7, 190, 0, 0, 14883, 14888, 3, 1696, 848, 0, 14884, + 14885, 5, 2453, 0, 0, 14885, 14887, 3, 1696, 848, 0, 14886, 14884, 1, 0, + 0, 0, 14887, 14890, 1, 0, 0, 0, 14888, 14886, 1, 0, 0, 0, 14888, 14889, + 1, 0, 0, 0, 14889, 14918, 1, 0, 0, 0, 14890, 14888, 1, 0, 0, 0, 14891, + 14892, 5, 2447, 0, 0, 14892, 14897, 3, 1696, 848, 0, 14893, 14894, 5, 2453, + 0, 0, 14894, 14896, 3, 1696, 848, 0, 14895, 14893, 1, 0, 0, 0, 14896, 14899, + 1, 0, 0, 0, 14897, 14895, 1, 0, 0, 0, 14897, 14898, 1, 0, 0, 0, 14898, + 14900, 1, 0, 0, 0, 14899, 14897, 1, 0, 0, 0, 14900, 14901, 5, 2448, 0, + 0, 14901, 14918, 1, 0, 0, 0, 14902, 14904, 5, 620, 0, 0, 14903, 14905, + 5, 2447, 0, 0, 14904, 14903, 1, 0, 0, 0, 14904, 14905, 1, 0, 0, 0, 14905, + 14906, 1, 0, 0, 0, 14906, 14911, 3, 686, 343, 0, 14907, 14908, 5, 2453, + 0, 0, 14908, 14910, 3, 686, 343, 0, 14909, 14907, 1, 0, 0, 0, 14910, 14913, + 1, 0, 0, 0, 14911, 14909, 1, 0, 0, 0, 14911, 14912, 1, 0, 0, 0, 14912, + 14915, 1, 0, 0, 0, 14913, 14911, 1, 0, 0, 0, 14914, 14916, 5, 2448, 0, + 0, 14915, 14914, 1, 0, 0, 0, 14915, 14916, 1, 0, 0, 0, 14916, 14918, 1, + 0, 0, 0, 14917, 14883, 1, 0, 0, 0, 14917, 14891, 1, 0, 0, 0, 14917, 14902, + 1, 0, 0, 0, 14918, 1559, 1, 0, 0, 0, 14919, 14951, 7, 191, 0, 0, 14920, + 14923, 3, 1696, 848, 0, 14921, 14922, 5, 2207, 0, 0, 14922, 14924, 5, 714, + 0, 0, 14923, 14921, 1, 0, 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14952, + 1, 0, 0, 0, 14925, 14926, 5, 2447, 0, 0, 14926, 14931, 3, 1696, 848, 0, + 14927, 14928, 5, 2453, 0, 0, 14928, 14930, 3, 1696, 848, 0, 14929, 14927, + 1, 0, 0, 0, 14930, 14933, 1, 0, 0, 0, 14931, 14929, 1, 0, 0, 0, 14931, + 14932, 1, 0, 0, 0, 14932, 14934, 1, 0, 0, 0, 14933, 14931, 1, 0, 0, 0, + 14934, 14935, 5, 2448, 0, 0, 14935, 14952, 1, 0, 0, 0, 14936, 14938, 5, + 620, 0, 0, 14937, 14939, 5, 2447, 0, 0, 14938, 14937, 1, 0, 0, 0, 14938, + 14939, 1, 0, 0, 0, 14939, 14940, 1, 0, 0, 0, 14940, 14945, 3, 688, 344, + 0, 14941, 14942, 5, 2453, 0, 0, 14942, 14944, 3, 688, 344, 0, 14943, 14941, + 1, 0, 0, 0, 14944, 14947, 1, 0, 0, 0, 14945, 14943, 1, 0, 0, 0, 14945, + 14946, 1, 0, 0, 0, 14946, 14949, 1, 0, 0, 0, 14947, 14945, 1, 0, 0, 0, + 14948, 14950, 5, 2448, 0, 0, 14949, 14948, 1, 0, 0, 0, 14949, 14950, 1, + 0, 0, 0, 14950, 14952, 1, 0, 0, 0, 14951, 14920, 1, 0, 0, 0, 14951, 14925, + 1, 0, 0, 0, 14951, 14936, 1, 0, 0, 0, 14952, 1561, 1, 0, 0, 0, 14953, 14973, + 3, 1194, 597, 0, 14954, 14973, 3, 886, 443, 0, 14955, 14973, 3, 1178, 589, + 0, 14956, 14973, 3, 1180, 590, 0, 14957, 14973, 3, 1278, 639, 0, 14958, + 14973, 3, 1284, 642, 0, 14959, 14973, 3, 1286, 643, 0, 14960, 14973, 7, + 109, 0, 0, 14961, 14962, 5, 1579, 0, 0, 14962, 14963, 5, 2447, 0, 0, 14963, + 14964, 5, 977, 0, 0, 14964, 14965, 7, 24, 0, 0, 14965, 14973, 5, 2448, + 0, 0, 14966, 14973, 3, 1292, 646, 0, 14967, 14973, 3, 1290, 645, 0, 14968, + 14973, 3, 928, 464, 0, 14969, 14973, 3, 1272, 636, 0, 14970, 14973, 3, + 1108, 554, 0, 14971, 14973, 3, 1274, 637, 0, 14972, 14953, 1, 0, 0, 0, + 14972, 14954, 1, 0, 0, 0, 14972, 14955, 1, 0, 0, 0, 14972, 14956, 1, 0, + 0, 0, 14972, 14957, 1, 0, 0, 0, 14972, 14958, 1, 0, 0, 0, 14972, 14959, + 1, 0, 0, 0, 14972, 14960, 1, 0, 0, 0, 14972, 14961, 1, 0, 0, 0, 14972, + 14966, 1, 0, 0, 0, 14972, 14967, 1, 0, 0, 0, 14972, 14968, 1, 0, 0, 0, + 14972, 14969, 1, 0, 0, 0, 14972, 14970, 1, 0, 0, 0, 14972, 14971, 1, 0, + 0, 0, 14973, 14974, 1, 0, 0, 0, 14974, 14972, 1, 0, 0, 0, 14974, 14975, + 1, 0, 0, 0, 14975, 14977, 1, 0, 0, 0, 14976, 14978, 3, 1564, 782, 0, 14977, + 14976, 1, 0, 0, 0, 14977, 14978, 1, 0, 0, 0, 14978, 1563, 1, 0, 0, 0, 14979, + 14984, 3, 1596, 798, 0, 14980, 14984, 3, 1568, 784, 0, 14981, 14984, 3, + 1566, 783, 0, 14982, 14984, 5, 228, 0, 0, 14983, 14979, 1, 0, 0, 0, 14983, + 14980, 1, 0, 0, 0, 14983, 14981, 1, 0, 0, 0, 14983, 14982, 1, 0, 0, 0, + 14984, 1565, 1, 0, 0, 0, 14985, 14986, 5, 911, 0, 0, 14986, 14989, 5, 2083, + 0, 0, 14987, 14990, 3, 1284, 642, 0, 14988, 14990, 3, 1286, 643, 0, 14989, + 14987, 1, 0, 0, 0, 14989, 14988, 1, 0, 0, 0, 14990, 1567, 1, 0, 0, 0, 14991, + 15002, 3, 1570, 785, 0, 14992, 14997, 5, 1320, 0, 0, 14993, 14998, 3, 1200, + 600, 0, 14994, 14998, 3, 1284, 642, 0, 14995, 14998, 3, 1288, 644, 0, 14996, + 14998, 3, 1286, 643, 0, 14997, 14993, 1, 0, 0, 0, 14997, 14994, 1, 0, 0, + 0, 14997, 14995, 1, 0, 0, 0, 14997, 14996, 1, 0, 0, 0, 14998, 14999, 1, + 0, 0, 0, 14999, 14997, 1, 0, 0, 0, 14999, 15000, 1, 0, 0, 0, 15000, 15002, + 1, 0, 0, 0, 15001, 14991, 1, 0, 0, 0, 15001, 14992, 1, 0, 0, 0, 15002, + 1569, 1, 0, 0, 0, 15003, 15004, 5, 21, 0, 0, 15004, 15006, 5, 1320, 0, + 0, 15005, 15007, 3, 1200, 600, 0, 15006, 15005, 1, 0, 0, 0, 15006, 15007, + 1, 0, 0, 0, 15007, 15024, 1, 0, 0, 0, 15008, 15009, 5, 2447, 0, 0, 15009, + 15011, 5, 1348, 0, 0, 15010, 15012, 3, 1200, 600, 0, 15011, 15010, 1, 0, + 0, 0, 15011, 15012, 1, 0, 0, 0, 15012, 15020, 1, 0, 0, 0, 15013, 15014, + 5, 2453, 0, 0, 15014, 15016, 5, 1348, 0, 0, 15015, 15017, 3, 1200, 600, + 0, 15016, 15015, 1, 0, 0, 0, 15016, 15017, 1, 0, 0, 0, 15017, 15019, 1, + 0, 0, 0, 15018, 15013, 1, 0, 0, 0, 15019, 15022, 1, 0, 0, 0, 15020, 15018, + 1, 0, 0, 0, 15020, 15021, 1, 0, 0, 0, 15021, 15023, 1, 0, 0, 0, 15022, + 15020, 1, 0, 0, 0, 15023, 15025, 5, 2448, 0, 0, 15024, 15008, 1, 0, 0, + 0, 15024, 15025, 1, 0, 0, 0, 15025, 1571, 1, 0, 0, 0, 15026, 15029, 3, + 1574, 787, 0, 15027, 15029, 3, 1576, 788, 0, 15028, 15026, 1, 0, 0, 0, + 15028, 15027, 1, 0, 0, 0, 15029, 1573, 1, 0, 0, 0, 15030, 15031, 7, 192, + 0, 0, 15031, 15032, 5, 642, 0, 0, 15032, 15033, 5, 714, 0, 0, 15033, 1575, + 1, 0, 0, 0, 15034, 15035, 5, 2207, 0, 0, 15035, 15040, 5, 714, 0, 0, 15036, + 15037, 5, 2447, 0, 0, 15037, 15038, 3, 1578, 789, 0, 15038, 15039, 5, 2448, + 0, 0, 15039, 15041, 1, 0, 0, 0, 15040, 15036, 1, 0, 0, 0, 15040, 15041, + 1, 0, 0, 0, 15041, 1577, 1, 0, 0, 0, 15042, 15043, 3, 2328, 1164, 0, 15043, + 15046, 5, 2447, 0, 0, 15044, 15047, 3, 1580, 790, 0, 15045, 15047, 3, 1582, + 791, 0, 15046, 15044, 1, 0, 0, 0, 15046, 15045, 1, 0, 0, 0, 15047, 15048, + 1, 0, 0, 0, 15048, 15053, 5, 2448, 0, 0, 15049, 15050, 5, 2453, 0, 0, 15050, + 15052, 3, 1576, 788, 0, 15051, 15049, 1, 0, 0, 0, 15052, 15055, 1, 0, 0, + 0, 15053, 15051, 1, 0, 0, 0, 15053, 15054, 1, 0, 0, 0, 15054, 1579, 1, + 0, 0, 0, 15055, 15053, 1, 0, 0, 0, 15056, 15058, 3, 544, 272, 0, 15057, + 15059, 3, 506, 253, 0, 15058, 15057, 1, 0, 0, 0, 15058, 15059, 1, 0, 0, + 0, 15059, 15064, 1, 0, 0, 0, 15060, 15061, 5, 2453, 0, 0, 15061, 15063, + 3, 1580, 790, 0, 15062, 15060, 1, 0, 0, 0, 15063, 15066, 1, 0, 0, 0, 15064, + 15062, 1, 0, 0, 0, 15064, 15065, 1, 0, 0, 0, 15065, 1581, 1, 0, 0, 0, 15066, + 15064, 1, 0, 0, 0, 15067, 15069, 5, 1775, 0, 0, 15068, 15070, 3, 1154, + 577, 0, 15069, 15068, 1, 0, 0, 0, 15069, 15070, 1, 0, 0, 0, 15070, 15073, + 1, 0, 0, 0, 15071, 15072, 5, 2080, 0, 0, 15072, 15074, 3, 1656, 828, 0, + 15073, 15071, 1, 0, 0, 0, 15073, 15074, 1, 0, 0, 0, 15074, 15079, 1, 0, + 0, 0, 15075, 15076, 5, 2453, 0, 0, 15076, 15078, 3, 1582, 791, 0, 15077, + 15075, 1, 0, 0, 0, 15078, 15081, 1, 0, 0, 0, 15079, 15077, 1, 0, 0, 0, + 15079, 15080, 1, 0, 0, 0, 15080, 1583, 1, 0, 0, 0, 15081, 15079, 1, 0, + 0, 0, 15082, 15084, 7, 17, 0, 0, 15083, 15085, 7, 96, 0, 0, 15084, 15083, + 1, 0, 0, 0, 15084, 15085, 1, 0, 0, 0, 15085, 15102, 1, 0, 0, 0, 15086, + 15087, 5, 2183, 0, 0, 15087, 15088, 5, 2447, 0, 0, 15088, 15093, 3, 2340, + 1170, 0, 15089, 15090, 5, 2453, 0, 0, 15090, 15092, 3, 2340, 1170, 0, 15091, + 15089, 1, 0, 0, 0, 15092, 15095, 1, 0, 0, 0, 15093, 15091, 1, 0, 0, 0, + 15093, 15094, 1, 0, 0, 0, 15094, 15096, 1, 0, 0, 0, 15095, 15093, 1, 0, + 0, 0, 15096, 15097, 5, 2448, 0, 0, 15097, 15103, 1, 0, 0, 0, 15098, 15099, + 5, 1451, 0, 0, 15099, 15103, 5, 816, 0, 0, 15100, 15101, 5, 286, 0, 0, + 15101, 15103, 3, 2310, 1155, 0, 15102, 15086, 1, 0, 0, 0, 15102, 15098, + 1, 0, 0, 0, 15102, 15100, 1, 0, 0, 0, 15103, 15105, 1, 0, 0, 0, 15104, + 15106, 3, 1586, 793, 0, 15105, 15104, 1, 0, 0, 0, 15105, 15106, 1, 0, 0, + 0, 15106, 15108, 1, 0, 0, 0, 15107, 15109, 3, 1592, 796, 0, 15108, 15107, + 1, 0, 0, 0, 15108, 15109, 1, 0, 0, 0, 15109, 15111, 1, 0, 0, 0, 15110, + 15112, 5, 179, 0, 0, 15111, 15110, 1, 0, 0, 0, 15111, 15112, 1, 0, 0, 0, + 15112, 15115, 1, 0, 0, 0, 15113, 15114, 7, 164, 0, 0, 15114, 15116, 5, + 717, 0, 0, 15115, 15113, 1, 0, 0, 0, 15115, 15116, 1, 0, 0, 0, 15116, 1585, + 1, 0, 0, 0, 15117, 15118, 5, 2246, 0, 0, 15118, 15125, 5, 717, 0, 0, 15119, + 15126, 3, 2328, 1164, 0, 15120, 15121, 5, 2447, 0, 0, 15121, 15122, 3, + 462, 231, 0, 15122, 15123, 5, 2448, 0, 0, 15123, 15126, 1, 0, 0, 0, 15124, + 15126, 3, 474, 237, 0, 15125, 15119, 1, 0, 0, 0, 15125, 15120, 1, 0, 0, + 0, 15125, 15124, 1, 0, 0, 0, 15126, 1587, 1, 0, 0, 0, 15127, 15140, 3, + 1194, 597, 0, 15128, 15140, 3, 886, 443, 0, 15129, 15132, 5, 2080, 0, 0, + 15130, 15133, 3, 1656, 828, 0, 15131, 15133, 5, 389, 0, 0, 15132, 15130, + 1, 0, 0, 0, 15132, 15131, 1, 0, 0, 0, 15133, 15140, 1, 0, 0, 0, 15134, + 15140, 3, 1600, 800, 0, 15135, 15140, 3, 1590, 795, 0, 15136, 15140, 5, + 1588, 0, 0, 15137, 15140, 3, 520, 260, 0, 15138, 15140, 3, 928, 464, 0, + 15139, 15127, 1, 0, 0, 0, 15139, 15128, 1, 0, 0, 0, 15139, 15129, 1, 0, + 0, 0, 15139, 15134, 1, 0, 0, 0, 15139, 15135, 1, 0, 0, 0, 15139, 15136, + 1, 0, 0, 0, 15139, 15137, 1, 0, 0, 0, 15139, 15138, 1, 0, 0, 0, 15140, + 15141, 1, 0, 0, 0, 15141, 15139, 1, 0, 0, 0, 15141, 15142, 1, 0, 0, 0, + 15142, 1589, 1, 0, 0, 0, 15143, 15144, 7, 193, 0, 0, 15144, 1591, 1, 0, + 0, 0, 15145, 15146, 5, 537, 0, 0, 15146, 15147, 5, 779, 0, 0, 15147, 15148, + 3, 2342, 1171, 0, 15148, 1593, 1, 0, 0, 0, 15149, 15151, 5, 992, 0, 0, + 15150, 15152, 5, 1256, 0, 0, 15151, 15150, 1, 0, 0, 0, 15151, 15152, 1, + 0, 0, 0, 15152, 15154, 1, 0, 0, 0, 15153, 15155, 3, 1200, 600, 0, 15154, + 15153, 1, 0, 0, 0, 15154, 15155, 1, 0, 0, 0, 15155, 15157, 1, 0, 0, 0, + 15156, 15158, 3, 1178, 589, 0, 15157, 15156, 1, 0, 0, 0, 15157, 15158, + 1, 0, 0, 0, 15158, 15160, 1, 0, 0, 0, 15159, 15161, 3, 1596, 798, 0, 15160, + 15159, 1, 0, 0, 0, 15160, 15161, 1, 0, 0, 0, 15161, 15166, 1, 0, 0, 0, + 15162, 15165, 3, 1640, 820, 0, 15163, 15165, 3, 1630, 815, 0, 15164, 15162, + 1, 0, 0, 0, 15164, 15163, 1, 0, 0, 0, 15165, 15168, 1, 0, 0, 0, 15166, + 15164, 1, 0, 0, 0, 15166, 15167, 1, 0, 0, 0, 15167, 15170, 1, 0, 0, 0, + 15168, 15166, 1, 0, 0, 0, 15169, 15171, 3, 928, 464, 0, 15170, 15169, 1, + 0, 0, 0, 15170, 15171, 1, 0, 0, 0, 15171, 1595, 1, 0, 0, 0, 15172, 15177, + 3, 1598, 799, 0, 15173, 15174, 5, 1371, 0, 0, 15174, 15177, 5, 2441, 0, + 0, 15175, 15177, 3, 1600, 800, 0, 15176, 15172, 1, 0, 0, 0, 15176, 15173, + 1, 0, 0, 0, 15176, 15175, 1, 0, 0, 0, 15177, 15178, 1, 0, 0, 0, 15178, + 15176, 1, 0, 0, 0, 15178, 15179, 1, 0, 0, 0, 15179, 15181, 1, 0, 0, 0, + 15180, 15182, 3, 1602, 801, 0, 15181, 15180, 1, 0, 0, 0, 15181, 15182, + 1, 0, 0, 0, 15182, 15185, 1, 0, 0, 0, 15183, 15185, 3, 1602, 801, 0, 15184, + 15176, 1, 0, 0, 0, 15184, 15183, 1, 0, 0, 0, 15185, 1597, 1, 0, 0, 0, 15186, + 15187, 5, 911, 0, 0, 15187, 15190, 5, 2083, 0, 0, 15188, 15190, 5, 1120, + 0, 0, 15189, 15186, 1, 0, 0, 0, 15189, 15188, 1, 0, 0, 0, 15190, 1599, + 1, 0, 0, 0, 15191, 15195, 5, 1074, 0, 0, 15192, 15193, 5, 258, 0, 0, 15193, + 15195, 5, 2441, 0, 0, 15194, 15191, 1, 0, 0, 0, 15194, 15192, 1, 0, 0, + 0, 15195, 1601, 1, 0, 0, 0, 15196, 15197, 5, 705, 0, 0, 15197, 15199, 3, + 2340, 1170, 0, 15198, 15196, 1, 0, 0, 0, 15198, 15199, 1, 0, 0, 0, 15199, + 15200, 1, 0, 0, 0, 15200, 15202, 5, 1320, 0, 0, 15201, 15203, 3, 1200, + 600, 0, 15202, 15201, 1, 0, 0, 0, 15202, 15203, 1, 0, 0, 0, 15203, 1603, + 1, 0, 0, 0, 15204, 15209, 3, 1616, 808, 0, 15205, 15209, 3, 1610, 805, + 0, 15206, 15209, 3, 1606, 803, 0, 15207, 15209, 3, 1642, 821, 0, 15208, + 15204, 1, 0, 0, 0, 15208, 15205, 1, 0, 0, 0, 15208, 15206, 1, 0, 0, 0, + 15208, 15207, 1, 0, 0, 0, 15209, 1605, 1, 0, 0, 0, 15210, 15211, 5, 980, + 0, 0, 15211, 15212, 5, 1013, 0, 0, 15212, 15213, 5, 2083, 0, 0, 15213, + 15214, 3, 1608, 804, 0, 15214, 15215, 5, 1586, 0, 0, 15215, 15216, 5, 69, + 0, 0, 15216, 15217, 7, 194, 0, 0, 15217, 1607, 1, 0, 0, 0, 15218, 15219, + 3, 2342, 1171, 0, 15219, 1609, 1, 0, 0, 0, 15220, 15221, 5, 1559, 0, 0, + 15221, 15222, 5, 237, 0, 0, 15222, 15223, 3, 1612, 806, 0, 15223, 15224, + 5, 2141, 0, 0, 15224, 15225, 3, 1614, 807, 0, 15225, 1611, 1, 0, 0, 0, + 15226, 15227, 3, 2340, 1170, 0, 15227, 1613, 1, 0, 0, 0, 15228, 15229, + 3, 2340, 1170, 0, 15229, 1615, 1, 0, 0, 0, 15230, 15235, 3, 1702, 851, + 0, 15231, 15235, 3, 1628, 814, 0, 15232, 15235, 3, 1620, 810, 0, 15233, + 15235, 3, 1618, 809, 0, 15234, 15230, 1, 0, 0, 0, 15234, 15231, 1, 0, 0, + 0, 15234, 15232, 1, 0, 0, 0, 15234, 15233, 1, 0, 0, 0, 15235, 15236, 1, + 0, 0, 0, 15236, 15234, 1, 0, 0, 0, 15236, 15237, 1, 0, 0, 0, 15237, 1617, + 1, 0, 0, 0, 15238, 15239, 5, 1671, 0, 0, 15239, 15253, 5, 2204, 0, 0, 15240, + 15241, 5, 237, 0, 0, 15241, 15254, 3, 2340, 1170, 0, 15242, 15243, 5, 2447, + 0, 0, 15243, 15248, 3, 2340, 1170, 0, 15244, 15245, 5, 2453, 0, 0, 15245, + 15247, 3, 2340, 1170, 0, 15246, 15244, 1, 0, 0, 0, 15247, 15250, 1, 0, + 0, 0, 15248, 15246, 1, 0, 0, 0, 15248, 15249, 1, 0, 0, 0, 15249, 15251, + 1, 0, 0, 0, 15250, 15248, 1, 0, 0, 0, 15251, 15252, 5, 2448, 0, 0, 15252, + 15254, 1, 0, 0, 0, 15253, 15240, 1, 0, 0, 0, 15253, 15242, 1, 0, 0, 0, + 15254, 15260, 1, 0, 0, 0, 15255, 15256, 5, 179, 0, 0, 15256, 15259, 5, + 287, 0, 0, 15257, 15259, 5, 780, 0, 0, 15258, 15255, 1, 0, 0, 0, 15258, + 15257, 1, 0, 0, 0, 15259, 15262, 1, 0, 0, 0, 15260, 15258, 1, 0, 0, 0, + 15260, 15261, 1, 0, 0, 0, 15261, 15301, 1, 0, 0, 0, 15262, 15260, 1, 0, + 0, 0, 15263, 15277, 5, 469, 0, 0, 15264, 15265, 5, 237, 0, 0, 15265, 15278, + 3, 2340, 1170, 0, 15266, 15267, 5, 2447, 0, 0, 15267, 15272, 3, 2340, 1170, + 0, 15268, 15269, 5, 2453, 0, 0, 15269, 15271, 3, 2340, 1170, 0, 15270, + 15268, 1, 0, 0, 0, 15271, 15274, 1, 0, 0, 0, 15272, 15270, 1, 0, 0, 0, + 15272, 15273, 1, 0, 0, 0, 15273, 15275, 1, 0, 0, 0, 15274, 15272, 1, 0, + 0, 0, 15275, 15276, 5, 2448, 0, 0, 15276, 15278, 1, 0, 0, 0, 15277, 15264, + 1, 0, 0, 0, 15277, 15266, 1, 0, 0, 0, 15278, 15284, 1, 0, 0, 0, 15279, + 15280, 5, 179, 0, 0, 15280, 15283, 5, 287, 0, 0, 15281, 15283, 5, 780, + 0, 0, 15282, 15279, 1, 0, 0, 0, 15282, 15281, 1, 0, 0, 0, 15283, 15286, + 1, 0, 0, 0, 15284, 15282, 1, 0, 0, 0, 15284, 15285, 1, 0, 0, 0, 15285, + 15289, 1, 0, 0, 0, 15286, 15284, 1, 0, 0, 0, 15287, 15288, 5, 201, 0, 0, + 15288, 15290, 5, 2441, 0, 0, 15289, 15287, 1, 0, 0, 0, 15289, 15290, 1, + 0, 0, 0, 15290, 15301, 1, 0, 0, 0, 15291, 15296, 5, 469, 0, 0, 15292, 15293, + 5, 2204, 0, 0, 15293, 15297, 5, 238, 0, 0, 15294, 15295, 5, 238, 0, 0, + 15295, 15297, 5, 297, 0, 0, 15296, 15292, 1, 0, 0, 0, 15296, 15294, 1, + 0, 0, 0, 15297, 15298, 1, 0, 0, 0, 15298, 15299, 5, 201, 0, 0, 15299, 15301, + 5, 2441, 0, 0, 15300, 15238, 1, 0, 0, 0, 15300, 15263, 1, 0, 0, 0, 15300, + 15291, 1, 0, 0, 0, 15301, 1619, 1, 0, 0, 0, 15302, 15328, 5, 980, 0, 0, + 15303, 15304, 5, 2447, 0, 0, 15304, 15309, 3, 1622, 811, 0, 15305, 15306, + 5, 2453, 0, 0, 15306, 15308, 3, 1622, 811, 0, 15307, 15305, 1, 0, 0, 0, + 15308, 15311, 1, 0, 0, 0, 15309, 15307, 1, 0, 0, 0, 15309, 15310, 1, 0, + 0, 0, 15310, 15312, 1, 0, 0, 0, 15311, 15309, 1, 0, 0, 0, 15312, 15313, + 5, 2448, 0, 0, 15313, 15329, 1, 0, 0, 0, 15314, 15315, 5, 2447, 0, 0, 15315, + 15320, 3, 1624, 812, 0, 15316, 15317, 5, 2453, 0, 0, 15317, 15319, 3, 1624, + 812, 0, 15318, 15316, 1, 0, 0, 0, 15319, 15322, 1, 0, 0, 0, 15320, 15318, + 1, 0, 0, 0, 15320, 15321, 1, 0, 0, 0, 15321, 15323, 1, 0, 0, 0, 15322, + 15320, 1, 0, 0, 0, 15323, 15324, 5, 2448, 0, 0, 15324, 15329, 1, 0, 0, + 0, 15325, 15329, 3, 1622, 811, 0, 15326, 15329, 3, 1624, 812, 0, 15327, + 15329, 3, 1626, 813, 0, 15328, 15303, 1, 0, 0, 0, 15328, 15314, 1, 0, 0, + 0, 15328, 15325, 1, 0, 0, 0, 15328, 15326, 1, 0, 0, 0, 15328, 15327, 1, + 0, 0, 0, 15329, 1621, 1, 0, 0, 0, 15330, 15332, 3, 2340, 1170, 0, 15331, + 15333, 3, 2376, 1188, 0, 15332, 15331, 1, 0, 0, 0, 15332, 15333, 1, 0, + 0, 0, 15333, 15340, 1, 0, 0, 0, 15334, 15337, 5, 389, 0, 0, 15335, 15336, + 5, 1259, 0, 0, 15336, 15338, 5, 1228, 0, 0, 15337, 15335, 1, 0, 0, 0, 15337, + 15338, 1, 0, 0, 0, 15338, 15339, 1, 0, 0, 0, 15339, 15341, 3, 2078, 1039, + 0, 15340, 15334, 1, 0, 0, 0, 15340, 15341, 1, 0, 0, 0, 15341, 15345, 1, + 0, 0, 0, 15342, 15343, 5, 505, 0, 0, 15343, 15346, 3, 1654, 827, 0, 15344, + 15346, 5, 387, 0, 0, 15345, 15342, 1, 0, 0, 0, 15345, 15344, 1, 0, 0, 0, + 15345, 15346, 1, 0, 0, 0, 15346, 15350, 1, 0, 0, 0, 15347, 15349, 3, 846, + 423, 0, 15348, 15347, 1, 0, 0, 0, 15349, 15352, 1, 0, 0, 0, 15350, 15348, + 1, 0, 0, 0, 15350, 15351, 1, 0, 0, 0, 15351, 15354, 1, 0, 0, 0, 15352, + 15350, 1, 0, 0, 0, 15353, 15355, 3, 1640, 820, 0, 15354, 15353, 1, 0, 0, + 0, 15354, 15355, 1, 0, 0, 0, 15355, 15357, 1, 0, 0, 0, 15356, 15358, 3, + 2246, 1123, 0, 15357, 15356, 1, 0, 0, 0, 15357, 15358, 1, 0, 0, 0, 15358, + 1623, 1, 0, 0, 0, 15359, 15360, 3, 2340, 1170, 0, 15360, 15361, 7, 70, + 0, 0, 15361, 1625, 1, 0, 0, 0, 15362, 15363, 5, 237, 0, 0, 15363, 15365, + 3, 2340, 1170, 0, 15364, 15366, 5, 1204, 0, 0, 15365, 15364, 1, 0, 0, 0, + 15365, 15366, 1, 0, 0, 0, 15366, 15367, 1, 0, 0, 0, 15367, 15368, 5, 1780, + 0, 0, 15368, 15369, 5, 82, 0, 0, 15369, 15370, 5, 38, 0, 0, 15370, 15372, + 5, 848, 0, 0, 15371, 15373, 5, 616, 0, 0, 15372, 15371, 1, 0, 0, 0, 15372, + 15373, 1, 0, 0, 0, 15373, 1627, 1, 0, 0, 0, 15374, 15396, 5, 21, 0, 0, + 15375, 15378, 5, 2447, 0, 0, 15376, 15379, 3, 1670, 835, 0, 15377, 15379, + 3, 1680, 840, 0, 15378, 15376, 1, 0, 0, 0, 15378, 15377, 1, 0, 0, 0, 15379, + 15387, 1, 0, 0, 0, 15380, 15383, 5, 2453, 0, 0, 15381, 15384, 3, 1670, + 835, 0, 15382, 15384, 3, 1680, 840, 0, 15383, 15381, 1, 0, 0, 0, 15383, + 15382, 1, 0, 0, 0, 15384, 15386, 1, 0, 0, 0, 15385, 15380, 1, 0, 0, 0, + 15386, 15389, 1, 0, 0, 0, 15387, 15385, 1, 0, 0, 0, 15387, 15388, 1, 0, + 0, 0, 15388, 15390, 1, 0, 0, 0, 15389, 15387, 1, 0, 0, 0, 15390, 15391, + 5, 2448, 0, 0, 15391, 15397, 1, 0, 0, 0, 15392, 15395, 3, 1670, 835, 0, + 15393, 15395, 3, 1680, 840, 0, 15394, 15392, 1, 0, 0, 0, 15394, 15393, + 1, 0, 0, 0, 15395, 15397, 1, 0, 0, 0, 15396, 15375, 1, 0, 0, 0, 15396, + 15394, 1, 0, 0, 0, 15397, 15399, 1, 0, 0, 0, 15398, 15400, 3, 1660, 830, + 0, 15399, 15398, 1, 0, 0, 0, 15399, 15400, 1, 0, 0, 0, 15400, 1629, 1, + 0, 0, 0, 15401, 15402, 5, 2267, 0, 0, 15402, 15408, 3, 1658, 829, 0, 15403, + 15405, 3, 1694, 847, 0, 15404, 15403, 1, 0, 0, 0, 15404, 15405, 1, 0, 0, + 0, 15405, 15406, 1, 0, 0, 0, 15406, 15409, 3, 1632, 816, 0, 15407, 15409, + 3, 1694, 847, 0, 15408, 15404, 1, 0, 0, 0, 15408, 15407, 1, 0, 0, 0, 15409, + 1631, 1, 0, 0, 0, 15410, 15411, 5, 1763, 0, 0, 15411, 15413, 5, 69, 0, + 0, 15412, 15414, 7, 122, 0, 0, 15413, 15412, 1, 0, 0, 0, 15413, 15414, + 1, 0, 0, 0, 15414, 15415, 1, 0, 0, 0, 15415, 15424, 5, 868, 0, 0, 15416, + 15418, 3, 1634, 817, 0, 15417, 15416, 1, 0, 0, 0, 15417, 15418, 1, 0, 0, + 0, 15418, 15419, 1, 0, 0, 0, 15419, 15420, 5, 2447, 0, 0, 15420, 15421, + 3, 1638, 819, 0, 15421, 15422, 5, 2448, 0, 0, 15422, 15425, 1, 0, 0, 0, + 15423, 15425, 3, 1634, 817, 0, 15424, 15417, 1, 0, 0, 0, 15424, 15423, + 1, 0, 0, 0, 15424, 15425, 1, 0, 0, 0, 15425, 1633, 1, 0, 0, 0, 15426, 15429, + 3, 2410, 1205, 0, 15427, 15429, 5, 2444, 0, 0, 15428, 15426, 1, 0, 0, 0, + 15428, 15427, 1, 0, 0, 0, 15429, 1635, 1, 0, 0, 0, 15430, 15434, 3, 2410, + 1205, 0, 15431, 15434, 3, 2400, 1200, 0, 15432, 15434, 5, 2444, 0, 0, 15433, + 15430, 1, 0, 0, 0, 15433, 15431, 1, 0, 0, 0, 15433, 15432, 1, 0, 0, 0, + 15434, 1637, 1, 0, 0, 0, 15435, 15436, 5, 2080, 0, 0, 15436, 15443, 3, + 2404, 1202, 0, 15437, 15439, 3, 1646, 823, 0, 15438, 15440, 3, 1196, 598, + 0, 15439, 15438, 1, 0, 0, 0, 15439, 15440, 1, 0, 0, 0, 15440, 15443, 1, + 0, 0, 0, 15441, 15443, 3, 1196, 598, 0, 15442, 15435, 1, 0, 0, 0, 15442, + 15437, 1, 0, 0, 0, 15442, 15441, 1, 0, 0, 0, 15443, 1639, 1, 0, 0, 0, 15444, + 15489, 5, 868, 0, 0, 15445, 15446, 5, 2447, 0, 0, 15446, 15451, 3, 1636, + 818, 0, 15447, 15448, 5, 2453, 0, 0, 15448, 15450, 3, 1636, 818, 0, 15449, + 15447, 1, 0, 0, 0, 15450, 15453, 1, 0, 0, 0, 15451, 15449, 1, 0, 0, 0, + 15451, 15452, 1, 0, 0, 0, 15452, 15454, 1, 0, 0, 0, 15453, 15451, 1, 0, + 0, 0, 15454, 15455, 5, 2448, 0, 0, 15455, 15456, 5, 1763, 0, 0, 15456, + 15466, 5, 69, 0, 0, 15457, 15467, 7, 122, 0, 0, 15458, 15462, 5, 2447, + 0, 0, 15459, 15461, 3, 1638, 819, 0, 15460, 15459, 1, 0, 0, 0, 15461, 15464, + 1, 0, 0, 0, 15462, 15460, 1, 0, 0, 0, 15462, 15463, 1, 0, 0, 0, 15463, + 15465, 1, 0, 0, 0, 15464, 15462, 1, 0, 0, 0, 15465, 15467, 5, 2448, 0, + 0, 15466, 15457, 1, 0, 0, 0, 15466, 15458, 1, 0, 0, 0, 15467, 15468, 1, + 0, 0, 0, 15468, 15466, 1, 0, 0, 0, 15468, 15469, 1, 0, 0, 0, 15469, 15490, + 1, 0, 0, 0, 15470, 15471, 5, 2447, 0, 0, 15471, 15472, 3, 1636, 818, 0, + 15472, 15473, 5, 2448, 0, 0, 15473, 15474, 5, 1763, 0, 0, 15474, 15485, + 5, 69, 0, 0, 15475, 15486, 7, 122, 0, 0, 15476, 15486, 3, 1634, 817, 0, + 15477, 15481, 5, 2447, 0, 0, 15478, 15480, 3, 1638, 819, 0, 15479, 15478, + 1, 0, 0, 0, 15480, 15483, 1, 0, 0, 0, 15481, 15479, 1, 0, 0, 0, 15481, + 15482, 1, 0, 0, 0, 15482, 15484, 1, 0, 0, 0, 15483, 15481, 1, 0, 0, 0, + 15484, 15486, 5, 2448, 0, 0, 15485, 15475, 1, 0, 0, 0, 15485, 15476, 1, + 0, 0, 0, 15485, 15477, 1, 0, 0, 0, 15486, 15487, 1, 0, 0, 0, 15487, 15485, + 1, 0, 0, 0, 15487, 15488, 1, 0, 0, 0, 15488, 15490, 1, 0, 0, 0, 15489, + 15445, 1, 0, 0, 0, 15489, 15470, 1, 0, 0, 0, 15490, 1641, 1, 0, 0, 0, 15491, + 15492, 5, 980, 0, 0, 15492, 15493, 5, 868, 0, 0, 15493, 15494, 5, 2447, + 0, 0, 15494, 15495, 3, 1636, 818, 0, 15495, 15496, 5, 2448, 0, 0, 15496, + 15497, 5, 2447, 0, 0, 15497, 15498, 3, 1644, 822, 0, 15498, 15499, 5, 2448, + 0, 0, 15499, 1643, 1, 0, 0, 0, 15500, 15525, 3, 1196, 598, 0, 15501, 15502, + 7, 195, 0, 0, 15502, 15525, 5, 2441, 0, 0, 15503, 15504, 5, 1511, 0, 0, + 15504, 15525, 5, 626, 0, 0, 15505, 15525, 3, 1652, 826, 0, 15506, 15525, + 3, 1648, 824, 0, 15507, 15525, 3, 1650, 825, 0, 15508, 15509, 5, 505, 0, + 0, 15509, 15525, 3, 1654, 827, 0, 15510, 15525, 5, 387, 0, 0, 15511, 15525, + 5, 166, 0, 0, 15512, 15517, 5, 166, 0, 0, 15513, 15517, 5, 1066, 0, 0, + 15514, 15515, 5, 166, 0, 0, 15515, 15517, 5, 1506, 0, 0, 15516, 15512, + 1, 0, 0, 0, 15516, 15513, 1, 0, 0, 0, 15516, 15514, 1, 0, 0, 0, 15517, + 15519, 1, 0, 0, 0, 15518, 15520, 3, 886, 443, 0, 15519, 15518, 1, 0, 0, + 0, 15519, 15520, 1, 0, 0, 0, 15520, 15525, 1, 0, 0, 0, 15521, 15525, 3, + 1284, 642, 0, 15522, 15525, 3, 1288, 644, 0, 15523, 15525, 3, 1286, 643, + 0, 15524, 15500, 1, 0, 0, 0, 15524, 15501, 1, 0, 0, 0, 15524, 15503, 1, + 0, 0, 0, 15524, 15505, 1, 0, 0, 0, 15524, 15506, 1, 0, 0, 0, 15524, 15507, + 1, 0, 0, 0, 15524, 15508, 1, 0, 0, 0, 15524, 15510, 1, 0, 0, 0, 15524, + 15511, 1, 0, 0, 0, 15524, 15516, 1, 0, 0, 0, 15524, 15521, 1, 0, 0, 0, + 15524, 15522, 1, 0, 0, 0, 15524, 15523, 1, 0, 0, 0, 15525, 15526, 1, 0, + 0, 0, 15526, 15524, 1, 0, 0, 0, 15526, 15527, 1, 0, 0, 0, 15527, 1645, + 1, 0, 0, 0, 15528, 15529, 7, 17, 0, 0, 15529, 15530, 5, 1762, 0, 0, 15530, + 15531, 5, 738, 0, 0, 15531, 15554, 5, 1606, 0, 0, 15532, 15533, 5, 205, + 0, 0, 15533, 15554, 5, 2441, 0, 0, 15534, 15535, 5, 1373, 0, 0, 15535, + 15554, 5, 2441, 0, 0, 15536, 15537, 5, 626, 0, 0, 15537, 15554, 5, 2441, + 0, 0, 15538, 15554, 3, 1652, 826, 0, 15539, 15554, 3, 1648, 824, 0, 15540, + 15554, 3, 1650, 825, 0, 15541, 15542, 5, 505, 0, 0, 15542, 15554, 3, 1654, + 827, 0, 15543, 15554, 5, 387, 0, 0, 15544, 15549, 5, 166, 0, 0, 15545, + 15549, 5, 1066, 0, 0, 15546, 15547, 5, 166, 0, 0, 15547, 15549, 5, 1506, + 0, 0, 15548, 15544, 1, 0, 0, 0, 15548, 15545, 1, 0, 0, 0, 15548, 15546, + 1, 0, 0, 0, 15549, 15551, 1, 0, 0, 0, 15550, 15552, 3, 886, 443, 0, 15551, + 15550, 1, 0, 0, 0, 15551, 15552, 1, 0, 0, 0, 15552, 15554, 1, 0, 0, 0, + 15553, 15528, 1, 0, 0, 0, 15553, 15532, 1, 0, 0, 0, 15553, 15534, 1, 0, + 0, 0, 15553, 15536, 1, 0, 0, 0, 15553, 15538, 1, 0, 0, 0, 15553, 15539, + 1, 0, 0, 0, 15553, 15540, 1, 0, 0, 0, 15553, 15541, 1, 0, 0, 0, 15553, + 15543, 1, 0, 0, 0, 15553, 15548, 1, 0, 0, 0, 15554, 15555, 1, 0, 0, 0, + 15555, 15553, 1, 0, 0, 0, 15555, 15556, 1, 0, 0, 0, 15556, 1647, 1, 0, + 0, 0, 15557, 15558, 7, 196, 0, 0, 15558, 1649, 1, 0, 0, 0, 15559, 15565, + 5, 1074, 0, 0, 15560, 15562, 5, 258, 0, 0, 15561, 15563, 7, 197, 0, 0, + 15562, 15561, 1, 0, 0, 0, 15562, 15563, 1, 0, 0, 0, 15563, 15565, 1, 0, + 0, 0, 15564, 15559, 1, 0, 0, 0, 15564, 15560, 1, 0, 0, 0, 15565, 1651, + 1, 0, 0, 0, 15566, 15572, 5, 1583, 0, 0, 15567, 15573, 5, 2406, 0, 0, 15568, + 15569, 5, 2409, 0, 0, 15569, 15573, 5, 2441, 0, 0, 15570, 15573, 5, 91, + 0, 0, 15571, 15573, 5, 1133, 0, 0, 15572, 15567, 1, 0, 0, 0, 15572, 15568, + 1, 0, 0, 0, 15572, 15570, 1, 0, 0, 0, 15572, 15571, 1, 0, 0, 0, 15572, + 15573, 1, 0, 0, 0, 15573, 1653, 1, 0, 0, 0, 15574, 15575, 5, 2246, 0, 0, + 15575, 15577, 5, 2443, 0, 0, 15576, 15574, 1, 0, 0, 0, 15576, 15577, 1, + 0, 0, 0, 15577, 15581, 1, 0, 0, 0, 15578, 15579, 5, 685, 0, 0, 15579, 15580, + 5, 160, 0, 0, 15580, 15582, 5, 2480, 0, 0, 15581, 15578, 1, 0, 0, 0, 15581, + 15582, 1, 0, 0, 0, 15582, 15584, 1, 0, 0, 0, 15583, 15585, 5, 2443, 0, + 0, 15584, 15583, 1, 0, 0, 0, 15584, 15585, 1, 0, 0, 0, 15585, 15590, 1, + 0, 0, 0, 15586, 15588, 5, 1137, 0, 0, 15587, 15586, 1, 0, 0, 0, 15587, + 15588, 1, 0, 0, 0, 15588, 15589, 1, 0, 0, 0, 15589, 15591, 5, 1613, 0, + 0, 15590, 15587, 1, 0, 0, 0, 15590, 15591, 1, 0, 0, 0, 15591, 1655, 1, + 0, 0, 0, 15592, 15593, 3, 2404, 1202, 0, 15593, 1657, 1, 0, 0, 0, 15594, + 15595, 3, 2404, 1202, 0, 15595, 15596, 5, 2440, 0, 0, 15596, 15598, 1, + 0, 0, 0, 15597, 15594, 1, 0, 0, 0, 15597, 15598, 1, 0, 0, 0, 15598, 15602, + 1, 0, 0, 0, 15599, 15600, 3, 2404, 1202, 0, 15600, 15601, 5, 2440, 0, 0, + 15601, 15603, 1, 0, 0, 0, 15602, 15599, 1, 0, 0, 0, 15602, 15603, 1, 0, + 0, 0, 15603, 15604, 1, 0, 0, 0, 15604, 15605, 3, 2404, 1202, 0, 15605, + 1659, 1, 0, 0, 0, 15606, 15627, 3, 1700, 850, 0, 15607, 15627, 3, 1690, + 845, 0, 15608, 15611, 3, 1630, 815, 0, 15609, 15611, 3, 1640, 820, 0, 15610, + 15608, 1, 0, 0, 0, 15610, 15609, 1, 0, 0, 0, 15611, 15623, 1, 0, 0, 0, + 15612, 15613, 5, 2447, 0, 0, 15613, 15618, 3, 1662, 831, 0, 15614, 15615, + 5, 2453, 0, 0, 15615, 15617, 3, 1662, 831, 0, 15616, 15614, 1, 0, 0, 0, + 15617, 15620, 1, 0, 0, 0, 15618, 15616, 1, 0, 0, 0, 15618, 15619, 1, 0, + 0, 0, 15619, 15621, 1, 0, 0, 0, 15620, 15618, 1, 0, 0, 0, 15621, 15622, + 5, 2448, 0, 0, 15622, 15624, 1, 0, 0, 0, 15623, 15612, 1, 0, 0, 0, 15623, + 15624, 1, 0, 0, 0, 15624, 15627, 1, 0, 0, 0, 15625, 15627, 3, 1044, 522, + 0, 15626, 15606, 1, 0, 0, 0, 15626, 15607, 1, 0, 0, 0, 15626, 15610, 1, + 0, 0, 0, 15626, 15625, 1, 0, 0, 0, 15627, 15628, 1, 0, 0, 0, 15628, 15626, + 1, 0, 0, 0, 15628, 15629, 1, 0, 0, 0, 15629, 1661, 1, 0, 0, 0, 15630, 15663, + 5, 868, 0, 0, 15631, 15632, 5, 2447, 0, 0, 15632, 15633, 3, 1636, 818, + 0, 15633, 15634, 5, 2453, 0, 0, 15634, 15635, 3, 1636, 818, 0, 15635, 15636, + 1, 0, 0, 0, 15636, 15637, 5, 2448, 0, 0, 15637, 15638, 5, 1763, 0, 0, 15638, + 15644, 5, 69, 0, 0, 15639, 15645, 7, 122, 0, 0, 15640, 15641, 5, 2447, + 0, 0, 15641, 15642, 3, 1638, 819, 0, 15642, 15643, 5, 2448, 0, 0, 15643, + 15645, 1, 0, 0, 0, 15644, 15639, 1, 0, 0, 0, 15644, 15640, 1, 0, 0, 0, + 15645, 15646, 1, 0, 0, 0, 15646, 15644, 1, 0, 0, 0, 15646, 15647, 1, 0, + 0, 0, 15647, 15664, 1, 0, 0, 0, 15648, 15649, 5, 2447, 0, 0, 15649, 15650, + 3, 1636, 818, 0, 15650, 15651, 5, 2448, 0, 0, 15651, 15652, 5, 1763, 0, + 0, 15652, 15659, 5, 69, 0, 0, 15653, 15660, 7, 122, 0, 0, 15654, 15660, + 3, 1634, 817, 0, 15655, 15656, 5, 2447, 0, 0, 15656, 15657, 3, 1638, 819, + 0, 15657, 15658, 5, 2448, 0, 0, 15658, 15660, 1, 0, 0, 0, 15659, 15653, + 1, 0, 0, 0, 15659, 15654, 1, 0, 0, 0, 15659, 15655, 1, 0, 0, 0, 15660, + 15661, 1, 0, 0, 0, 15661, 15659, 1, 0, 0, 0, 15661, 15662, 1, 0, 0, 0, + 15662, 15664, 1, 0, 0, 0, 15663, 15631, 1, 0, 0, 0, 15663, 15648, 1, 0, + 0, 0, 15664, 1663, 1, 0, 0, 0, 15665, 15666, 4, 832, 10, 0, 15666, 15667, + 5, 2440, 0, 0, 15667, 15668, 5, 620, 0, 0, 15668, 15675, 3, 2340, 1170, + 0, 15669, 15670, 5, 2447, 0, 0, 15670, 15671, 3, 1666, 833, 0, 15671, 15672, + 5, 2453, 0, 0, 15672, 15673, 3, 1668, 834, 0, 15673, 15674, 5, 2448, 0, + 0, 15674, 15676, 1, 0, 0, 0, 15675, 15669, 1, 0, 0, 0, 15675, 15676, 1, + 0, 0, 0, 15676, 1665, 1, 0, 0, 0, 15677, 15678, 3, 2340, 1170, 0, 15678, + 1667, 1, 0, 0, 0, 15679, 15680, 3, 2340, 1170, 0, 15680, 1669, 1, 0, 0, + 0, 15681, 15690, 3, 2340, 1170, 0, 15682, 15685, 3, 2376, 1188, 0, 15683, + 15685, 3, 2314, 1157, 0, 15684, 15682, 1, 0, 0, 0, 15684, 15683, 1, 0, + 0, 0, 15685, 15688, 1, 0, 0, 0, 15686, 15687, 5, 2372, 0, 0, 15687, 15689, + 3, 1672, 836, 0, 15688, 15686, 1, 0, 0, 0, 15688, 15689, 1, 0, 0, 0, 15689, + 15691, 1, 0, 0, 0, 15690, 15684, 1, 0, 0, 0, 15690, 15691, 1, 0, 0, 0, + 15691, 15693, 1, 0, 0, 0, 15692, 15694, 5, 1709, 0, 0, 15693, 15692, 1, + 0, 0, 0, 15693, 15694, 1, 0, 0, 0, 15694, 15696, 1, 0, 0, 0, 15695, 15697, + 7, 70, 0, 0, 15696, 15695, 1, 0, 0, 0, 15696, 15697, 1, 0, 0, 0, 15697, + 15705, 1, 0, 0, 0, 15698, 15701, 5, 389, 0, 0, 15699, 15700, 5, 1259, 0, + 0, 15700, 15702, 5, 1228, 0, 0, 15701, 15699, 1, 0, 0, 0, 15701, 15702, + 1, 0, 0, 0, 15702, 15703, 1, 0, 0, 0, 15703, 15706, 3, 2078, 1039, 0, 15704, + 15706, 3, 1674, 837, 0, 15705, 15698, 1, 0, 0, 0, 15705, 15704, 1, 0, 0, + 0, 15705, 15706, 1, 0, 0, 0, 15706, 15709, 1, 0, 0, 0, 15707, 15708, 5, + 505, 0, 0, 15708, 15710, 3, 1654, 827, 0, 15709, 15707, 1, 0, 0, 0, 15709, + 15710, 1, 0, 0, 0, 15710, 15717, 1, 0, 0, 0, 15711, 15713, 3, 846, 423, + 0, 15712, 15711, 1, 0, 0, 0, 15713, 15714, 1, 0, 0, 0, 15714, 15712, 1, + 0, 0, 0, 15714, 15715, 1, 0, 0, 0, 15715, 15718, 1, 0, 0, 0, 15716, 15718, + 3, 848, 424, 0, 15717, 15712, 1, 0, 0, 0, 15717, 15716, 1, 0, 0, 0, 15717, + 15718, 1, 0, 0, 0, 15718, 15720, 1, 0, 0, 0, 15719, 15721, 3, 2246, 1123, + 0, 15720, 15719, 1, 0, 0, 0, 15720, 15721, 1, 0, 0, 0, 15721, 1671, 1, + 0, 0, 0, 15722, 15723, 3, 2404, 1202, 0, 15723, 1673, 1, 0, 0, 0, 15724, + 15732, 5, 640, 0, 0, 15725, 15733, 5, 44, 0, 0, 15726, 15727, 5, 160, 0, + 0, 15727, 15730, 5, 389, 0, 0, 15728, 15729, 5, 1259, 0, 0, 15729, 15731, + 5, 1228, 0, 0, 15730, 15728, 1, 0, 0, 0, 15730, 15731, 1, 0, 0, 0, 15731, + 15733, 1, 0, 0, 0, 15732, 15725, 1, 0, 0, 0, 15732, 15726, 1, 0, 0, 0, + 15732, 15733, 1, 0, 0, 0, 15733, 15734, 1, 0, 0, 0, 15734, 15735, 5, 69, + 0, 0, 15735, 15737, 5, 687, 0, 0, 15736, 15738, 3, 1676, 838, 0, 15737, + 15736, 1, 0, 0, 0, 15737, 15738, 1, 0, 0, 0, 15738, 1675, 1, 0, 0, 0, 15739, + 15741, 3, 1678, 839, 0, 15740, 15739, 1, 0, 0, 0, 15741, 15742, 1, 0, 0, + 0, 15742, 15740, 1, 0, 0, 0, 15742, 15743, 1, 0, 0, 0, 15743, 15753, 1, + 0, 0, 0, 15744, 15746, 5, 2447, 0, 0, 15745, 15747, 3, 1678, 839, 0, 15746, + 15745, 1, 0, 0, 0, 15747, 15748, 1, 0, 0, 0, 15748, 15746, 1, 0, 0, 0, + 15748, 15749, 1, 0, 0, 0, 15749, 15750, 1, 0, 0, 0, 15750, 15751, 5, 2448, + 0, 0, 15751, 15753, 1, 0, 0, 0, 15752, 15740, 1, 0, 0, 0, 15752, 15744, + 1, 0, 0, 0, 15753, 1677, 1, 0, 0, 0, 15754, 15755, 5, 1737, 0, 0, 15755, + 15759, 5, 2308, 0, 0, 15756, 15760, 3, 2396, 1198, 0, 15757, 15758, 5, + 858, 0, 0, 15758, 15760, 5, 2258, 0, 0, 15759, 15756, 1, 0, 0, 0, 15759, + 15757, 1, 0, 0, 0, 15760, 15783, 1, 0, 0, 0, 15761, 15762, 5, 707, 0, 0, + 15762, 15763, 5, 160, 0, 0, 15763, 15783, 3, 2396, 1198, 0, 15764, 15765, + 5, 932, 0, 0, 15765, 15783, 3, 2396, 1198, 0, 15766, 15783, 5, 1121, 0, + 0, 15767, 15768, 5, 960, 0, 0, 15768, 15783, 3, 2396, 1198, 0, 15769, 15783, + 5, 1124, 0, 0, 15770, 15783, 5, 348, 0, 0, 15771, 15783, 5, 1084, 0, 0, + 15772, 15773, 5, 166, 0, 0, 15773, 15783, 3, 2396, 1198, 0, 15774, 15783, + 5, 1066, 0, 0, 15775, 15783, 5, 1303, 0, 0, 15776, 15783, 5, 1140, 0, 0, + 15777, 15778, 5, 1620, 0, 0, 15778, 15783, 7, 49, 0, 0, 15779, 15783, 5, + 1181, 0, 0, 15780, 15783, 5, 814, 0, 0, 15781, 15783, 5, 1114, 0, 0, 15782, + 15754, 1, 0, 0, 0, 15782, 15761, 1, 0, 0, 0, 15782, 15764, 1, 0, 0, 0, + 15782, 15766, 1, 0, 0, 0, 15782, 15767, 1, 0, 0, 0, 15782, 15769, 1, 0, + 0, 0, 15782, 15770, 1, 0, 0, 0, 15782, 15771, 1, 0, 0, 0, 15782, 15772, + 1, 0, 0, 0, 15782, 15774, 1, 0, 0, 0, 15782, 15775, 1, 0, 0, 0, 15782, + 15776, 1, 0, 0, 0, 15782, 15777, 1, 0, 0, 0, 15782, 15779, 1, 0, 0, 0, + 15782, 15780, 1, 0, 0, 0, 15782, 15781, 1, 0, 0, 0, 15783, 1679, 1, 0, + 0, 0, 15784, 15790, 3, 2340, 1170, 0, 15785, 15788, 3, 2376, 1188, 0, 15786, + 15787, 5, 2372, 0, 0, 15787, 15789, 3, 1672, 836, 0, 15788, 15786, 1, 0, + 0, 0, 15788, 15789, 1, 0, 0, 0, 15789, 15791, 1, 0, 0, 0, 15790, 15785, + 1, 0, 0, 0, 15790, 15791, 1, 0, 0, 0, 15791, 15793, 1, 0, 0, 0, 15792, + 15794, 7, 70, 0, 0, 15793, 15792, 1, 0, 0, 0, 15793, 15794, 1, 0, 0, 0, + 15794, 15796, 1, 0, 0, 0, 15795, 15797, 3, 1682, 841, 0, 15796, 15795, + 1, 0, 0, 0, 15796, 15797, 1, 0, 0, 0, 15797, 15799, 1, 0, 0, 0, 15798, + 15800, 5, 2288, 0, 0, 15799, 15798, 1, 0, 0, 0, 15799, 15800, 1, 0, 0, + 0, 15800, 15802, 1, 0, 0, 0, 15801, 15803, 3, 1688, 844, 0, 15802, 15801, + 1, 0, 0, 0, 15802, 15803, 1, 0, 0, 0, 15803, 15812, 1, 0, 0, 0, 15804, + 15805, 5, 2203, 0, 0, 15805, 15810, 5, 112, 0, 0, 15806, 15807, 5, 336, + 0, 0, 15807, 15811, 5, 483, 0, 0, 15808, 15809, 5, 483, 0, 0, 15809, 15811, + 3, 1454, 727, 0, 15810, 15806, 1, 0, 0, 0, 15810, 15808, 1, 0, 0, 0, 15811, + 15813, 1, 0, 0, 0, 15812, 15804, 1, 0, 0, 0, 15812, 15813, 1, 0, 0, 0, + 15813, 15823, 1, 0, 0, 0, 15814, 15815, 5, 2203, 0, 0, 15815, 15816, 5, + 114, 0, 0, 15816, 15821, 5, 2308, 0, 0, 15817, 15818, 7, 198, 0, 0, 15818, + 15822, 5, 483, 0, 0, 15819, 15820, 5, 483, 0, 0, 15820, 15822, 3, 1454, + 727, 0, 15821, 15817, 1, 0, 0, 0, 15821, 15819, 1, 0, 0, 0, 15822, 15824, + 1, 0, 0, 0, 15823, 15814, 1, 0, 0, 0, 15823, 15824, 1, 0, 0, 0, 15824, + 15828, 1, 0, 0, 0, 15825, 15827, 3, 846, 423, 0, 15826, 15825, 1, 0, 0, + 0, 15827, 15830, 1, 0, 0, 0, 15828, 15826, 1, 0, 0, 0, 15828, 15829, 1, + 0, 0, 0, 15829, 15832, 1, 0, 0, 0, 15830, 15828, 1, 0, 0, 0, 15831, 15833, + 3, 1686, 843, 0, 15832, 15831, 1, 0, 0, 0, 15832, 15833, 1, 0, 0, 0, 15833, + 1681, 1, 0, 0, 0, 15834, 15847, 3, 1684, 842, 0, 15835, 15837, 5, 640, + 0, 0, 15836, 15838, 5, 44, 0, 0, 15837, 15836, 1, 0, 0, 0, 15837, 15838, + 1, 0, 0, 0, 15838, 15840, 1, 0, 0, 0, 15839, 15835, 1, 0, 0, 0, 15839, + 15840, 1, 0, 0, 0, 15840, 15841, 1, 0, 0, 0, 15841, 15842, 5, 69, 0, 0, + 15842, 15843, 5, 2447, 0, 0, 15843, 15844, 3, 2078, 1039, 0, 15844, 15845, + 5, 2448, 0, 0, 15845, 15847, 1, 0, 0, 0, 15846, 15834, 1, 0, 0, 0, 15846, + 15839, 1, 0, 0, 0, 15847, 1683, 1, 0, 0, 0, 15848, 15856, 5, 640, 0, 0, + 15849, 15857, 5, 44, 0, 0, 15850, 15851, 5, 160, 0, 0, 15851, 15854, 5, + 389, 0, 0, 15852, 15853, 5, 1259, 0, 0, 15853, 15855, 5, 1228, 0, 0, 15854, + 15852, 1, 0, 0, 0, 15854, 15855, 1, 0, 0, 0, 15855, 15857, 1, 0, 0, 0, + 15856, 15849, 1, 0, 0, 0, 15856, 15850, 1, 0, 0, 0, 15856, 15857, 1, 0, + 0, 0, 15857, 15858, 1, 0, 0, 0, 15858, 15859, 5, 69, 0, 0, 15859, 15869, + 5, 687, 0, 0, 15860, 15865, 5, 2447, 0, 0, 15861, 15864, 3, 328, 164, 0, + 15862, 15864, 3, 326, 163, 0, 15863, 15861, 1, 0, 0, 0, 15863, 15862, 1, + 0, 0, 0, 15864, 15867, 1, 0, 0, 0, 15865, 15863, 1, 0, 0, 0, 15865, 15866, + 1, 0, 0, 0, 15866, 15868, 1, 0, 0, 0, 15867, 15865, 1, 0, 0, 0, 15868, + 15870, 5, 2448, 0, 0, 15869, 15860, 1, 0, 0, 0, 15869, 15870, 1, 0, 0, + 0, 15870, 1685, 1, 0, 0, 0, 15871, 15872, 5, 160, 0, 0, 15872, 15873, 5, + 2237, 0, 0, 15873, 15874, 5, 620, 0, 0, 15874, 15875, 5, 1746, 0, 0, 15875, + 1687, 1, 0, 0, 0, 15876, 15877, 5, 530, 0, 0, 15877, 15882, 5, 2246, 0, + 0, 15878, 15879, 7, 198, 0, 0, 15879, 15883, 5, 483, 0, 0, 15880, 15881, + 5, 483, 0, 0, 15881, 15883, 3, 1454, 727, 0, 15882, 15878, 1, 0, 0, 0, + 15882, 15880, 1, 0, 0, 0, 15883, 1689, 1, 0, 0, 0, 15884, 15885, 5, 1013, + 0, 0, 15885, 15888, 5, 2083, 0, 0, 15886, 15889, 3, 1692, 846, 0, 15887, + 15889, 5, 240, 0, 0, 15888, 15886, 1, 0, 0, 0, 15888, 15887, 1, 0, 0, 0, + 15889, 15891, 1, 0, 0, 0, 15890, 15892, 3, 1694, 847, 0, 15891, 15890, + 1, 0, 0, 0, 15891, 15892, 1, 0, 0, 0, 15892, 15894, 1, 0, 0, 0, 15893, + 15895, 7, 199, 0, 0, 15894, 15893, 1, 0, 0, 0, 15894, 15895, 1, 0, 0, 0, + 15895, 15896, 1, 0, 0, 0, 15896, 15897, 5, 1763, 0, 0, 15897, 15898, 5, + 69, 0, 0, 15898, 15912, 3, 2342, 1171, 0, 15899, 15906, 5, 2447, 0, 0, + 15900, 15901, 5, 2447, 0, 0, 15901, 15902, 3, 1058, 529, 0, 15902, 15903, + 5, 2448, 0, 0, 15903, 15907, 1, 0, 0, 0, 15904, 15907, 3, 1202, 601, 0, + 15905, 15907, 3, 1660, 830, 0, 15906, 15900, 1, 0, 0, 0, 15906, 15904, + 1, 0, 0, 0, 15906, 15905, 1, 0, 0, 0, 15907, 15908, 1, 0, 0, 0, 15908, + 15906, 1, 0, 0, 0, 15908, 15909, 1, 0, 0, 0, 15909, 15910, 1, 0, 0, 0, + 15910, 15911, 5, 2448, 0, 0, 15911, 15913, 1, 0, 0, 0, 15912, 15899, 1, + 0, 0, 0, 15912, 15913, 1, 0, 0, 0, 15913, 15919, 1, 0, 0, 0, 15914, 15916, + 5, 1586, 0, 0, 15915, 15917, 5, 69, 0, 0, 15916, 15915, 1, 0, 0, 0, 15916, + 15917, 1, 0, 0, 0, 15917, 15918, 1, 0, 0, 0, 15918, 15920, 7, 194, 0, 0, + 15919, 15914, 1, 0, 0, 0, 15919, 15920, 1, 0, 0, 0, 15920, 1691, 1, 0, + 0, 0, 15921, 15922, 3, 2410, 1205, 0, 15922, 1693, 1, 0, 0, 0, 15923, 15925, + 5, 486, 0, 0, 15924, 15923, 1, 0, 0, 0, 15924, 15925, 1, 0, 0, 0, 15925, + 15926, 1, 0, 0, 0, 15926, 15927, 5, 785, 0, 0, 15927, 15929, 5, 1246, 0, + 0, 15928, 15930, 5, 2166, 0, 0, 15929, 15928, 1, 0, 0, 0, 15929, 15930, + 1, 0, 0, 0, 15930, 15931, 1, 0, 0, 0, 15931, 15932, 5, 2447, 0, 0, 15932, + 15933, 3, 2314, 1157, 0, 15933, 15934, 5, 2448, 0, 0, 15934, 15943, 1, + 0, 0, 0, 15935, 15937, 5, 1204, 0, 0, 15936, 15935, 1, 0, 0, 0, 15936, + 15937, 1, 0, 0, 0, 15937, 15938, 1, 0, 0, 0, 15938, 15939, 5, 1780, 0, + 0, 15939, 15940, 5, 82, 0, 0, 15940, 15941, 5, 38, 0, 0, 15941, 15943, + 5, 848, 0, 0, 15942, 15924, 1, 0, 0, 0, 15942, 15936, 1, 0, 0, 0, 15943, + 1695, 1, 0, 0, 0, 15944, 15947, 3, 2410, 1205, 0, 15945, 15947, 5, 2444, + 0, 0, 15946, 15944, 1, 0, 0, 0, 15946, 15945, 1, 0, 0, 0, 15947, 1697, + 1, 0, 0, 0, 15948, 15949, 5, 1789, 0, 0, 15949, 15952, 5, 888, 0, 0, 15950, + 15953, 3, 1280, 640, 0, 15951, 15953, 3, 1282, 641, 0, 15952, 15950, 1, + 0, 0, 0, 15952, 15951, 1, 0, 0, 0, 15953, 1699, 1, 0, 0, 0, 15954, 15955, + 5, 237, 0, 0, 15955, 15956, 3, 2410, 1205, 0, 15956, 15957, 3, 1694, 847, + 0, 15957, 1701, 1, 0, 0, 0, 15958, 15959, 5, 21, 0, 0, 15959, 15969, 5, + 2447, 0, 0, 15960, 15965, 3, 852, 426, 0, 15961, 15962, 5, 2453, 0, 0, + 15962, 15964, 3, 852, 426, 0, 15963, 15961, 1, 0, 0, 0, 15964, 15967, 1, + 0, 0, 0, 15965, 15963, 1, 0, 0, 0, 15965, 15966, 1, 0, 0, 0, 15966, 15970, + 1, 0, 0, 0, 15967, 15965, 1, 0, 0, 0, 15968, 15970, 3, 850, 425, 0, 15969, + 15960, 1, 0, 0, 0, 15969, 15968, 1, 0, 0, 0, 15970, 15971, 1, 0, 0, 0, + 15971, 15972, 5, 2448, 0, 0, 15972, 16013, 1, 0, 0, 0, 15973, 15976, 5, + 21, 0, 0, 15974, 15977, 3, 852, 426, 0, 15975, 15977, 3, 850, 425, 0, 15976, + 15974, 1, 0, 0, 0, 15976, 15975, 1, 0, 0, 0, 15977, 16013, 1, 0, 0, 0, + 15978, 15995, 5, 980, 0, 0, 15979, 15980, 5, 286, 0, 0, 15980, 15996, 3, + 2310, 1155, 0, 15981, 15982, 5, 1451, 0, 0, 15982, 15996, 5, 816, 0, 0, + 15983, 15984, 5, 2183, 0, 0, 15984, 15985, 5, 2447, 0, 0, 15985, 15990, + 3, 2340, 1170, 0, 15986, 15987, 5, 2453, 0, 0, 15987, 15989, 3, 2340, 1170, + 0, 15988, 15986, 1, 0, 0, 0, 15989, 15992, 1, 0, 0, 0, 15990, 15988, 1, + 0, 0, 0, 15990, 15991, 1, 0, 0, 0, 15991, 15993, 1, 0, 0, 0, 15992, 15990, + 1, 0, 0, 0, 15993, 15994, 5, 2448, 0, 0, 15994, 15996, 1, 0, 0, 0, 15995, + 15979, 1, 0, 0, 0, 15995, 15981, 1, 0, 0, 0, 15995, 15983, 1, 0, 0, 0, + 15996, 15997, 1, 0, 0, 0, 15997, 15999, 3, 854, 427, 0, 15998, 16000, 5, + 179, 0, 0, 15999, 15998, 1, 0, 0, 0, 15999, 16000, 1, 0, 0, 0, 16000, 16013, + 1, 0, 0, 0, 16001, 16002, 5, 1559, 0, 0, 16002, 16003, 5, 286, 0, 0, 16003, + 16004, 3, 1704, 852, 0, 16004, 16005, 5, 2141, 0, 0, 16005, 16006, 3, 1706, + 853, 0, 16006, 16013, 1, 0, 0, 0, 16007, 16009, 3, 1708, 854, 0, 16008, + 16007, 1, 0, 0, 0, 16009, 16010, 1, 0, 0, 0, 16010, 16008, 1, 0, 0, 0, + 16010, 16011, 1, 0, 0, 0, 16011, 16013, 1, 0, 0, 0, 16012, 15958, 1, 0, + 0, 0, 16012, 15973, 1, 0, 0, 0, 16012, 15978, 1, 0, 0, 0, 16012, 16001, + 1, 0, 0, 0, 16012, 16008, 1, 0, 0, 0, 16013, 1703, 1, 0, 0, 0, 16014, 16015, + 3, 2310, 1155, 0, 16015, 1705, 1, 0, 0, 0, 16016, 16017, 3, 2310, 1155, + 0, 16017, 1707, 1, 0, 0, 0, 16018, 16035, 5, 469, 0, 0, 16019, 16020, 5, + 1451, 0, 0, 16020, 16036, 5, 816, 0, 0, 16021, 16022, 5, 2183, 0, 0, 16022, + 16023, 5, 2447, 0, 0, 16023, 16028, 3, 2340, 1170, 0, 16024, 16025, 5, + 2453, 0, 0, 16025, 16027, 3, 2340, 1170, 0, 16026, 16024, 1, 0, 0, 0, 16027, + 16030, 1, 0, 0, 0, 16028, 16026, 1, 0, 0, 0, 16028, 16029, 1, 0, 0, 0, + 16029, 16031, 1, 0, 0, 0, 16030, 16028, 1, 0, 0, 0, 16031, 16032, 5, 2448, + 0, 0, 16032, 16036, 1, 0, 0, 0, 16033, 16034, 5, 286, 0, 0, 16034, 16036, + 3, 2310, 1155, 0, 16035, 16019, 1, 0, 0, 0, 16035, 16021, 1, 0, 0, 0, 16035, + 16033, 1, 0, 0, 0, 16036, 16038, 1, 0, 0, 0, 16037, 16039, 5, 179, 0, 0, + 16038, 16037, 1, 0, 0, 0, 16038, 16039, 1, 0, 0, 0, 16039, 16042, 1, 0, + 0, 0, 16040, 16041, 7, 200, 0, 0, 16041, 16043, 5, 717, 0, 0, 16042, 16040, + 1, 0, 0, 0, 16042, 16043, 1, 0, 0, 0, 16043, 16045, 1, 0, 0, 0, 16044, + 16046, 5, 1256, 0, 0, 16045, 16044, 1, 0, 0, 0, 16045, 16046, 1, 0, 0, + 0, 16046, 1709, 1, 0, 0, 0, 16047, 16048, 5, 200, 0, 0, 16048, 16049, 5, + 2447, 0, 0, 16049, 16050, 3, 2074, 1037, 0, 16050, 16052, 5, 2448, 0, 0, + 16051, 16053, 5, 429, 0, 0, 16052, 16051, 1, 0, 0, 0, 16052, 16053, 1, + 0, 0, 0, 16053, 1711, 1, 0, 0, 0, 16054, 16055, 5, 618, 0, 0, 16055, 16056, + 5, 816, 0, 0, 16056, 16057, 3, 2360, 1180, 0, 16057, 16059, 3, 1714, 857, + 0, 16058, 16060, 3, 1716, 858, 0, 16059, 16058, 1, 0, 0, 0, 16059, 16060, + 1, 0, 0, 0, 16060, 1713, 1, 0, 0, 0, 16061, 16062, 5, 1528, 0, 0, 16062, + 16064, 3, 2342, 1171, 0, 16063, 16065, 3, 2360, 1180, 0, 16064, 16063, + 1, 0, 0, 0, 16064, 16065, 1, 0, 0, 0, 16065, 16073, 1, 0, 0, 0, 16066, + 16067, 5, 1259, 0, 0, 16067, 16071, 5, 403, 0, 0, 16068, 16072, 5, 179, + 0, 0, 16069, 16070, 5, 1671, 0, 0, 16070, 16072, 5, 1228, 0, 0, 16071, + 16068, 1, 0, 0, 0, 16071, 16069, 1, 0, 0, 0, 16072, 16074, 1, 0, 0, 0, + 16073, 16066, 1, 0, 0, 0, 16073, 16074, 1, 0, 0, 0, 16074, 1715, 1, 0, + 0, 0, 16075, 16076, 5, 1259, 0, 0, 16076, 16080, 5, 403, 0, 0, 16077, 16081, + 5, 179, 0, 0, 16078, 16079, 5, 1671, 0, 0, 16079, 16081, 5, 1228, 0, 0, + 16080, 16077, 1, 0, 0, 0, 16080, 16078, 1, 0, 0, 0, 16081, 1717, 1, 0, + 0, 0, 16082, 16084, 5, 382, 0, 0, 16083, 16085, 3, 1740, 870, 0, 16084, + 16083, 1, 0, 0, 0, 16084, 16085, 1, 0, 0, 0, 16085, 16087, 1, 0, 0, 0, + 16086, 16082, 1, 0, 0, 0, 16086, 16087, 1, 0, 0, 0, 16087, 16088, 1, 0, + 0, 0, 16088, 16089, 5, 113, 0, 0, 16089, 16096, 3, 1770, 885, 0, 16090, + 16092, 5, 535, 0, 0, 16091, 16093, 3, 1822, 911, 0, 16092, 16091, 1, 0, + 0, 0, 16093, 16094, 1, 0, 0, 0, 16094, 16092, 1, 0, 0, 0, 16094, 16095, + 1, 0, 0, 0, 16095, 16097, 1, 0, 0, 0, 16096, 16090, 1, 0, 0, 0, 16096, + 16097, 1, 0, 0, 0, 16097, 16098, 1, 0, 0, 0, 16098, 16099, 5, 508, 0, 0, + 16099, 1719, 1, 0, 0, 0, 16100, 16101, 5, 88, 0, 0, 16101, 16102, 7, 92, + 0, 0, 16102, 1721, 1, 0, 0, 0, 16103, 16106, 3, 1724, 862, 0, 16104, 16106, + 3, 1726, 863, 0, 16105, 16103, 1, 0, 0, 0, 16105, 16104, 1, 0, 0, 0, 16106, + 1723, 1, 0, 0, 0, 16107, 16108, 5, 823, 0, 0, 16108, 16109, 5, 792, 0, + 0, 16109, 16110, 5, 997, 0, 0, 16110, 16111, 5, 2443, 0, 0, 16111, 1725, + 1, 0, 0, 0, 16112, 16113, 5, 823, 0, 0, 16113, 16116, 5, 213, 0, 0, 16114, + 16116, 5, 560, 0, 0, 16115, 16112, 1, 0, 0, 0, 16115, 16114, 1, 0, 0, 0, + 16116, 16128, 1, 0, 0, 0, 16117, 16118, 5, 997, 0, 0, 16118, 16119, 3, + 2404, 1202, 0, 16119, 16120, 5, 849, 0, 0, 16120, 16121, 3, 2402, 1201, + 0, 16121, 16129, 1, 0, 0, 0, 16122, 16123, 5, 849, 0, 0, 16123, 16126, + 3, 2402, 1201, 0, 16124, 16125, 5, 997, 0, 0, 16125, 16127, 3, 2404, 1202, + 0, 16126, 16124, 1, 0, 0, 0, 16126, 16127, 1, 0, 0, 0, 16127, 16129, 1, + 0, 0, 0, 16128, 16117, 1, 0, 0, 0, 16128, 16122, 1, 0, 0, 0, 16129, 16131, + 1, 0, 0, 0, 16130, 16132, 3, 1728, 864, 0, 16131, 16130, 1, 0, 0, 0, 16131, + 16132, 1, 0, 0, 0, 16132, 16135, 1, 0, 0, 0, 16133, 16134, 5, 2308, 0, + 0, 16134, 16136, 5, 296, 0, 0, 16135, 16133, 1, 0, 0, 0, 16135, 16136, + 1, 0, 0, 0, 16136, 16138, 1, 0, 0, 0, 16137, 16139, 3, 1730, 865, 0, 16138, + 16137, 1, 0, 0, 0, 16138, 16139, 1, 0, 0, 0, 16139, 1727, 1, 0, 0, 0, 16140, + 16141, 5, 34, 0, 0, 16141, 16142, 5, 738, 0, 0, 16142, 16143, 5, 2447, + 0, 0, 16143, 16144, 3, 2076, 1038, 0, 16144, 16145, 5, 2448, 0, 0, 16145, + 1729, 1, 0, 0, 0, 16146, 16147, 5, 1335, 0, 0, 16147, 16148, 5, 2447, 0, + 0, 16148, 16153, 3, 1732, 866, 0, 16149, 16150, 5, 2453, 0, 0, 16150, 16152, + 3, 1732, 866, 0, 16151, 16149, 1, 0, 0, 0, 16152, 16155, 1, 0, 0, 0, 16153, + 16151, 1, 0, 0, 0, 16153, 16154, 1, 0, 0, 0, 16154, 16156, 1, 0, 0, 0, + 16155, 16153, 1, 0, 0, 0, 16156, 16157, 5, 2448, 0, 0, 16157, 1731, 1, + 0, 0, 0, 16158, 16179, 5, 296, 0, 0, 16159, 16162, 5, 1648, 0, 0, 16160, + 16163, 5, 2434, 0, 0, 16161, 16163, 3, 1734, 867, 0, 16162, 16160, 1, 0, + 0, 0, 16162, 16161, 1, 0, 0, 0, 16162, 16163, 1, 0, 0, 0, 16163, 16179, + 1, 0, 0, 0, 16164, 16167, 3, 2294, 1147, 0, 16165, 16167, 5, 1586, 0, 0, + 16166, 16164, 1, 0, 0, 0, 16166, 16165, 1, 0, 0, 0, 16167, 16169, 1, 0, + 0, 0, 16168, 16170, 3, 1734, 867, 0, 16169, 16168, 1, 0, 0, 0, 16169, 16170, + 1, 0, 0, 0, 16170, 16173, 1, 0, 0, 0, 16171, 16172, 5, 160, 0, 0, 16172, + 16174, 5, 1527, 0, 0, 16173, 16171, 1, 0, 0, 0, 16173, 16174, 1, 0, 0, + 0, 16174, 16176, 1, 0, 0, 0, 16175, 16177, 3, 2410, 1205, 0, 16176, 16175, + 1, 0, 0, 0, 16176, 16177, 1, 0, 0, 0, 16177, 16179, 1, 0, 0, 0, 16178, + 16158, 1, 0, 0, 0, 16178, 16159, 1, 0, 0, 0, 16178, 16166, 1, 0, 0, 0, + 16179, 1733, 1, 0, 0, 0, 16180, 16182, 5, 733, 0, 0, 16181, 16183, 7, 201, + 0, 0, 16182, 16181, 1, 0, 0, 0, 16182, 16183, 1, 0, 0, 0, 16183, 16190, + 1, 0, 0, 0, 16184, 16190, 5, 844, 0, 0, 16185, 16190, 5, 2428, 0, 0, 16186, + 16190, 5, 2430, 0, 0, 16187, 16190, 5, 2426, 0, 0, 16188, 16190, 5, 2427, + 0, 0, 16189, 16180, 1, 0, 0, 0, 16189, 16184, 1, 0, 0, 0, 16189, 16185, + 1, 0, 0, 0, 16189, 16186, 1, 0, 0, 0, 16189, 16187, 1, 0, 0, 0, 16189, + 16188, 1, 0, 0, 0, 16190, 1735, 1, 0, 0, 0, 16191, 16195, 3, 2294, 1147, + 0, 16192, 16194, 7, 202, 0, 0, 16193, 16192, 1, 0, 0, 0, 16194, 16197, + 1, 0, 0, 0, 16195, 16193, 1, 0, 0, 0, 16195, 16196, 1, 0, 0, 0, 16196, + 16199, 1, 0, 0, 0, 16197, 16195, 1, 0, 0, 0, 16198, 16200, 3, 2374, 1187, + 0, 16199, 16198, 1, 0, 0, 0, 16199, 16200, 1, 0, 0, 0, 16200, 16202, 1, + 0, 0, 0, 16201, 16203, 3, 1738, 869, 0, 16202, 16201, 1, 0, 0, 0, 16202, + 16203, 1, 0, 0, 0, 16203, 1737, 1, 0, 0, 0, 16204, 16205, 7, 203, 0, 0, + 16205, 16206, 3, 2078, 1039, 0, 16206, 1739, 1, 0, 0, 0, 16207, 16209, + 3, 1742, 871, 0, 16208, 16207, 1, 0, 0, 0, 16209, 16210, 1, 0, 0, 0, 16210, + 16208, 1, 0, 0, 0, 16210, 16211, 1, 0, 0, 0, 16211, 1741, 1, 0, 0, 0, 16212, + 16224, 3, 1754, 877, 0, 16213, 16224, 3, 1752, 876, 0, 16214, 16224, 3, + 162, 81, 0, 16215, 16224, 3, 164, 82, 0, 16216, 16224, 3, 1744, 872, 0, + 16217, 16224, 3, 1746, 873, 0, 16218, 16224, 3, 1748, 874, 0, 16219, 16224, + 3, 1762, 881, 0, 16220, 16224, 3, 178, 89, 0, 16221, 16224, 3, 176, 88, + 0, 16222, 16224, 3, 1814, 907, 0, 16223, 16212, 1, 0, 0, 0, 16223, 16213, + 1, 0, 0, 0, 16223, 16214, 1, 0, 0, 0, 16223, 16215, 1, 0, 0, 0, 16223, + 16216, 1, 0, 0, 0, 16223, 16217, 1, 0, 0, 0, 16223, 16218, 1, 0, 0, 0, + 16223, 16219, 1, 0, 0, 0, 16223, 16220, 1, 0, 0, 0, 16223, 16221, 1, 0, + 0, 0, 16223, 16222, 1, 0, 0, 0, 16224, 1743, 1, 0, 0, 0, 16225, 16227, + 3, 2402, 1201, 0, 16226, 16228, 5, 284, 0, 0, 16227, 16226, 1, 0, 0, 0, + 16227, 16228, 1, 0, 0, 0, 16228, 16229, 1, 0, 0, 0, 16229, 16234, 3, 2374, + 1187, 0, 16230, 16232, 5, 1204, 0, 0, 16231, 16230, 1, 0, 0, 0, 16231, + 16232, 1, 0, 0, 0, 16232, 16233, 1, 0, 0, 0, 16233, 16235, 5, 1228, 0, + 0, 16234, 16231, 1, 0, 0, 0, 16234, 16235, 1, 0, 0, 0, 16235, 16237, 1, + 0, 0, 0, 16236, 16238, 3, 1738, 869, 0, 16237, 16236, 1, 0, 0, 0, 16237, + 16238, 1, 0, 0, 0, 16238, 16239, 1, 0, 0, 0, 16239, 16240, 5, 2470, 0, + 0, 16240, 1745, 1, 0, 0, 0, 16241, 16242, 5, 1785, 0, 0, 16242, 16243, + 3, 2402, 1201, 0, 16243, 16244, 5, 785, 0, 0, 16244, 16250, 3, 2374, 1187, + 0, 16245, 16246, 5, 1495, 0, 0, 16246, 16247, 3, 2078, 1039, 0, 16247, + 16248, 5, 2439, 0, 0, 16248, 16249, 3, 2078, 1039, 0, 16249, 16251, 1, + 0, 0, 0, 16250, 16245, 1, 0, 0, 0, 16250, 16251, 1, 0, 0, 0, 16251, 16254, + 1, 0, 0, 0, 16252, 16253, 5, 1204, 0, 0, 16253, 16255, 5, 1228, 0, 0, 16254, + 16252, 1, 0, 0, 0, 16254, 16255, 1, 0, 0, 0, 16255, 16256, 1, 0, 0, 0, + 16256, 16257, 5, 2470, 0, 0, 16257, 1747, 1, 0, 0, 0, 16258, 16259, 5, + 343, 0, 0, 16259, 16271, 3, 2402, 1201, 0, 16260, 16261, 5, 2447, 0, 0, + 16261, 16266, 3, 1750, 875, 0, 16262, 16263, 5, 2453, 0, 0, 16263, 16265, + 3, 1750, 875, 0, 16264, 16262, 1, 0, 0, 0, 16265, 16268, 1, 0, 0, 0, 16266, + 16264, 1, 0, 0, 0, 16266, 16267, 1, 0, 0, 0, 16267, 16269, 1, 0, 0, 0, + 16268, 16266, 1, 0, 0, 0, 16269, 16270, 5, 2448, 0, 0, 16270, 16272, 1, + 0, 0, 0, 16271, 16260, 1, 0, 0, 0, 16271, 16272, 1, 0, 0, 0, 16272, 16275, + 1, 0, 0, 0, 16273, 16274, 5, 1586, 0, 0, 16274, 16276, 3, 2374, 1187, 0, + 16275, 16273, 1, 0, 0, 0, 16275, 16276, 1, 0, 0, 0, 16276, 16279, 1, 0, + 0, 0, 16277, 16278, 5, 785, 0, 0, 16278, 16280, 3, 1870, 935, 0, 16279, + 16277, 1, 0, 0, 0, 16279, 16280, 1, 0, 0, 0, 16280, 16281, 1, 0, 0, 0, + 16281, 16282, 5, 2470, 0, 0, 16282, 1749, 1, 0, 0, 0, 16283, 16288, 3, + 2294, 1147, 0, 16284, 16286, 5, 738, 0, 0, 16285, 16284, 1, 0, 0, 0, 16285, + 16286, 1, 0, 0, 0, 16286, 16287, 1, 0, 0, 0, 16287, 16289, 3, 2374, 1187, + 0, 16288, 16285, 1, 0, 0, 0, 16288, 16289, 1, 0, 0, 0, 16289, 16291, 1, + 0, 0, 0, 16290, 16292, 3, 1738, 869, 0, 16291, 16290, 1, 0, 0, 0, 16291, + 16292, 1, 0, 0, 0, 16292, 1751, 1, 0, 0, 0, 16293, 16294, 3, 2402, 1201, + 0, 16294, 16295, 5, 535, 0, 0, 16295, 16296, 5, 2470, 0, 0, 16296, 1753, + 1, 0, 0, 0, 16297, 16338, 5, 1433, 0, 0, 16298, 16339, 5, 1660, 0, 0, 16299, + 16339, 5, 96, 0, 0, 16300, 16301, 5, 536, 0, 0, 16301, 16302, 5, 2447, + 0, 0, 16302, 16303, 3, 2318, 1159, 0, 16303, 16304, 5, 2453, 0, 0, 16304, + 16305, 3, 2398, 1199, 0, 16305, 16306, 5, 2448, 0, 0, 16306, 16339, 1, + 0, 0, 0, 16307, 16308, 5, 744, 0, 0, 16308, 16309, 5, 2447, 0, 0, 16309, + 16310, 3, 2402, 1201, 0, 16310, 16311, 5, 2453, 0, 0, 16311, 16312, 3, + 2078, 1039, 0, 16312, 16313, 5, 2448, 0, 0, 16313, 16339, 1, 0, 0, 0, 16314, + 16315, 5, 1577, 0, 0, 16315, 16318, 5, 2447, 0, 0, 16316, 16319, 3, 2402, + 1201, 0, 16317, 16319, 5, 389, 0, 0, 16318, 16316, 1, 0, 0, 0, 16318, 16317, + 1, 0, 0, 0, 16319, 16322, 1, 0, 0, 0, 16320, 16321, 5, 2453, 0, 0, 16321, + 16323, 3, 2402, 1201, 0, 16322, 16320, 1, 0, 0, 0, 16323, 16324, 1, 0, + 0, 0, 16324, 16322, 1, 0, 0, 0, 16324, 16325, 1, 0, 0, 0, 16325, 16326, + 1, 0, 0, 0, 16326, 16327, 5, 2448, 0, 0, 16327, 16339, 1, 0, 0, 0, 16328, + 16329, 5, 409, 0, 0, 16329, 16330, 5, 2447, 0, 0, 16330, 16333, 3, 2402, + 1201, 0, 16331, 16332, 5, 2453, 0, 0, 16332, 16334, 5, 2443, 0, 0, 16333, + 16331, 1, 0, 0, 0, 16333, 16334, 1, 0, 0, 0, 16334, 16335, 1, 0, 0, 0, + 16335, 16336, 5, 2448, 0, 0, 16336, 16339, 1, 0, 0, 0, 16337, 16339, 5, + 2171, 0, 0, 16338, 16298, 1, 0, 0, 0, 16338, 16299, 1, 0, 0, 0, 16338, + 16300, 1, 0, 0, 0, 16338, 16307, 1, 0, 0, 0, 16338, 16314, 1, 0, 0, 0, + 16338, 16328, 1, 0, 0, 0, 16338, 16337, 1, 0, 0, 0, 16339, 16340, 1, 0, + 0, 0, 16340, 16341, 5, 2470, 0, 0, 16341, 1755, 1, 0, 0, 0, 16342, 16343, + 5, 1512, 0, 0, 16343, 16344, 5, 2447, 0, 0, 16344, 16349, 3, 1758, 879, + 0, 16345, 16346, 5, 2453, 0, 0, 16346, 16348, 3, 1758, 879, 0, 16347, 16345, + 1, 0, 0, 0, 16348, 16351, 1, 0, 0, 0, 16349, 16347, 1, 0, 0, 0, 16349, + 16350, 1, 0, 0, 0, 16350, 16352, 1, 0, 0, 0, 16351, 16349, 1, 0, 0, 0, + 16352, 16353, 5, 2448, 0, 0, 16353, 1757, 1, 0, 0, 0, 16354, 16356, 3, + 2340, 1170, 0, 16355, 16357, 3, 2374, 1187, 0, 16356, 16355, 1, 0, 0, 0, + 16356, 16357, 1, 0, 0, 0, 16357, 16360, 1, 0, 0, 0, 16358, 16359, 5, 1204, + 0, 0, 16359, 16361, 5, 1228, 0, 0, 16360, 16358, 1, 0, 0, 0, 16360, 16361, + 1, 0, 0, 0, 16361, 16363, 1, 0, 0, 0, 16362, 16364, 3, 1738, 869, 0, 16363, + 16362, 1, 0, 0, 0, 16363, 16364, 1, 0, 0, 0, 16364, 1759, 1, 0, 0, 0, 16365, + 16366, 5, 1530, 0, 0, 16366, 16369, 5, 343, 0, 0, 16367, 16368, 5, 1586, + 0, 0, 16368, 16370, 3, 2374, 1187, 0, 16369, 16367, 1, 0, 0, 0, 16369, + 16370, 1, 0, 0, 0, 16370, 1761, 1, 0, 0, 0, 16371, 16372, 5, 2166, 0, 0, + 16372, 16373, 3, 2402, 1201, 0, 16373, 16378, 5, 785, 0, 0, 16374, 16379, + 3, 1764, 882, 0, 16375, 16379, 3, 1768, 884, 0, 16376, 16379, 3, 1756, + 878, 0, 16377, 16379, 3, 1760, 880, 0, 16378, 16374, 1, 0, 0, 0, 16378, + 16375, 1, 0, 0, 0, 16378, 16376, 1, 0, 0, 0, 16378, 16377, 1, 0, 0, 0, + 16379, 16380, 1, 0, 0, 0, 16380, 16381, 5, 2470, 0, 0, 16381, 1763, 1, + 0, 0, 0, 16382, 16383, 5, 2083, 0, 0, 16383, 16384, 5, 1246, 0, 0, 16384, + 16387, 3, 2374, 1187, 0, 16385, 16386, 5, 1204, 0, 0, 16386, 16388, 5, + 1228, 0, 0, 16387, 16385, 1, 0, 0, 0, 16387, 16388, 1, 0, 0, 0, 16388, + 16390, 1, 0, 0, 0, 16389, 16391, 3, 1766, 883, 0, 16390, 16389, 1, 0, 0, + 0, 16390, 16391, 1, 0, 0, 0, 16391, 1765, 1, 0, 0, 0, 16392, 16395, 5, + 713, 0, 0, 16393, 16395, 5, 717, 0, 0, 16394, 16392, 1, 0, 0, 0, 16394, + 16393, 1, 0, 0, 0, 16395, 16396, 1, 0, 0, 0, 16396, 16397, 5, 160, 0, 0, + 16397, 16398, 3, 2374, 1187, 0, 16398, 1767, 1, 0, 0, 0, 16399, 16405, + 5, 2267, 0, 0, 16400, 16402, 5, 2269, 0, 0, 16401, 16400, 1, 0, 0, 0, 16401, + 16402, 1, 0, 0, 0, 16402, 16403, 1, 0, 0, 0, 16403, 16405, 5, 68, 0, 0, + 16404, 16399, 1, 0, 0, 0, 16404, 16401, 1, 0, 0, 0, 16405, 16406, 1, 0, + 0, 0, 16406, 16407, 5, 2447, 0, 0, 16407, 16408, 3, 2078, 1039, 0, 16408, + 16409, 5, 2448, 0, 0, 16409, 16410, 5, 1246, 0, 0, 16410, 16413, 3, 2374, + 1187, 0, 16411, 16412, 5, 1204, 0, 0, 16412, 16414, 5, 1228, 0, 0, 16413, + 16411, 1, 0, 0, 0, 16413, 16414, 1, 0, 0, 0, 16414, 1769, 1, 0, 0, 0, 16415, + 16417, 3, 1754, 877, 0, 16416, 16415, 1, 0, 0, 0, 16417, 16420, 1, 0, 0, + 0, 16418, 16416, 1, 0, 0, 0, 16418, 16419, 1, 0, 0, 0, 16419, 16421, 1, + 0, 0, 0, 16420, 16418, 1, 0, 0, 0, 16421, 16422, 3, 1774, 887, 0, 16422, + 16423, 7, 204, 0, 0, 16423, 16427, 1, 0, 0, 0, 16424, 16427, 3, 1772, 886, + 0, 16425, 16427, 3, 1814, 907, 0, 16426, 16418, 1, 0, 0, 0, 16426, 16424, + 1, 0, 0, 0, 16426, 16425, 1, 0, 0, 0, 16427, 16428, 1, 0, 0, 0, 16428, + 16426, 1, 0, 0, 0, 16428, 16429, 1, 0, 0, 0, 16429, 1771, 1, 0, 0, 0, 16430, + 16431, 5, 2468, 0, 0, 16431, 16432, 5, 2468, 0, 0, 16432, 16433, 3, 2312, + 1156, 0, 16433, 16434, 5, 2467, 0, 0, 16434, 16435, 5, 2467, 0, 0, 16435, + 1773, 1, 0, 0, 0, 16436, 16454, 3, 1820, 910, 0, 16437, 16454, 3, 1828, + 914, 0, 16438, 16454, 3, 1776, 888, 0, 16439, 16454, 3, 1778, 889, 0, 16440, + 16454, 3, 1780, 890, 0, 16441, 16454, 3, 1782, 891, 0, 16442, 16454, 3, + 1784, 892, 0, 16443, 16454, 3, 1790, 895, 0, 16444, 16454, 3, 1794, 897, + 0, 16445, 16454, 3, 1804, 902, 0, 16446, 16454, 3, 1806, 903, 0, 16447, + 16454, 3, 1808, 904, 0, 16448, 16454, 3, 2122, 1061, 0, 16449, 16454, 3, + 1830, 915, 0, 16450, 16454, 3, 1810, 905, 0, 16451, 16454, 3, 1812, 906, + 0, 16452, 16454, 3, 764, 382, 0, 16453, 16436, 1, 0, 0, 0, 16453, 16437, + 1, 0, 0, 0, 16453, 16438, 1, 0, 0, 0, 16453, 16439, 1, 0, 0, 0, 16453, + 16440, 1, 0, 0, 0, 16453, 16441, 1, 0, 0, 0, 16453, 16442, 1, 0, 0, 0, + 16453, 16443, 1, 0, 0, 0, 16453, 16444, 1, 0, 0, 0, 16453, 16445, 1, 0, + 0, 0, 16453, 16446, 1, 0, 0, 0, 16453, 16447, 1, 0, 0, 0, 16453, 16448, + 1, 0, 0, 0, 16453, 16449, 1, 0, 0, 0, 16453, 16450, 1, 0, 0, 0, 16453, + 16451, 1, 0, 0, 0, 16453, 16452, 1, 0, 0, 0, 16454, 1775, 1, 0, 0, 0, 16455, + 16458, 3, 2384, 1192, 0, 16456, 16458, 3, 2382, 1191, 0, 16457, 16455, + 1, 0, 0, 0, 16457, 16456, 1, 0, 0, 0, 16458, 16459, 1, 0, 0, 0, 16459, + 16460, 5, 2457, 0, 0, 16460, 16461, 3, 2078, 1039, 0, 16461, 1777, 1, 0, + 0, 0, 16462, 16464, 5, 297, 0, 0, 16463, 16465, 3, 2312, 1156, 0, 16464, + 16463, 1, 0, 0, 0, 16464, 16465, 1, 0, 0, 0, 16465, 16468, 1, 0, 0, 0, + 16466, 16467, 5, 2300, 0, 0, 16467, 16469, 3, 2074, 1037, 0, 16468, 16466, + 1, 0, 0, 0, 16468, 16469, 1, 0, 0, 0, 16469, 1779, 1, 0, 0, 0, 16470, 16472, + 5, 547, 0, 0, 16471, 16473, 3, 2312, 1156, 0, 16472, 16471, 1, 0, 0, 0, + 16472, 16473, 1, 0, 0, 0, 16473, 16476, 1, 0, 0, 0, 16474, 16475, 5, 2300, + 0, 0, 16475, 16477, 3, 2074, 1037, 0, 16476, 16474, 1, 0, 0, 0, 16476, + 16477, 1, 0, 0, 0, 16477, 1781, 1, 0, 0, 0, 16478, 16479, 5, 646, 0, 0, + 16479, 16480, 3, 2312, 1156, 0, 16480, 1783, 1, 0, 0, 0, 16481, 16482, + 5, 691, 0, 0, 16482, 16483, 3, 2074, 1037, 0, 16483, 16484, 5, 2099, 0, + 0, 16484, 16488, 3, 1770, 885, 0, 16485, 16487, 3, 1786, 893, 0, 16486, + 16485, 1, 0, 0, 0, 16487, 16490, 1, 0, 0, 0, 16488, 16486, 1, 0, 0, 0, + 16488, 16489, 1, 0, 0, 0, 16489, 16492, 1, 0, 0, 0, 16490, 16488, 1, 0, + 0, 0, 16491, 16493, 3, 1788, 894, 0, 16492, 16491, 1, 0, 0, 0, 16492, 16493, + 1, 0, 0, 0, 16493, 16494, 1, 0, 0, 0, 16494, 16495, 5, 508, 0, 0, 16495, + 16496, 5, 691, 0, 0, 16496, 1785, 1, 0, 0, 0, 16497, 16498, 5, 492, 0, + 0, 16498, 16499, 3, 2074, 1037, 0, 16499, 16500, 5, 2099, 0, 0, 16500, + 16501, 3, 1770, 885, 0, 16501, 1787, 1, 0, 0, 0, 16502, 16503, 5, 491, + 0, 0, 16503, 16504, 3, 1770, 885, 0, 16504, 1789, 1, 0, 0, 0, 16505, 16507, + 3, 1772, 886, 0, 16506, 16505, 1, 0, 0, 0, 16506, 16507, 1, 0, 0, 0, 16507, + 16512, 1, 0, 0, 0, 16508, 16509, 5, 2302, 0, 0, 16509, 16513, 3, 2074, + 1037, 0, 16510, 16511, 5, 620, 0, 0, 16511, 16513, 3, 1792, 896, 0, 16512, + 16508, 1, 0, 0, 0, 16512, 16510, 1, 0, 0, 0, 16512, 16513, 1, 0, 0, 0, + 16513, 16514, 1, 0, 0, 0, 16514, 16515, 5, 894, 0, 0, 16515, 16516, 3, + 1770, 885, 0, 16516, 16517, 5, 508, 0, 0, 16517, 16519, 5, 894, 0, 0, 16518, + 16520, 3, 2312, 1156, 0, 16519, 16518, 1, 0, 0, 0, 16519, 16520, 1, 0, + 0, 0, 16520, 1791, 1, 0, 0, 0, 16521, 16522, 3, 2328, 1164, 0, 16522, 16524, + 5, 738, 0, 0, 16523, 16525, 5, 1588, 0, 0, 16524, 16523, 1, 0, 0, 0, 16524, + 16525, 1, 0, 0, 0, 16525, 16526, 1, 0, 0, 0, 16526, 16527, 3, 1800, 900, + 0, 16527, 16528, 5, 2439, 0, 0, 16528, 16529, 3, 1802, 901, 0, 16529, 16547, + 1, 0, 0, 0, 16530, 16531, 3, 2332, 1166, 0, 16531, 16544, 5, 738, 0, 0, + 16532, 16538, 3, 2330, 1165, 0, 16533, 16535, 5, 2447, 0, 0, 16534, 16536, + 3, 2076, 1038, 0, 16535, 16534, 1, 0, 0, 0, 16535, 16536, 1, 0, 0, 0, 16536, + 16537, 1, 0, 0, 0, 16537, 16539, 5, 2448, 0, 0, 16538, 16533, 1, 0, 0, + 0, 16538, 16539, 1, 0, 0, 0, 16539, 16545, 1, 0, 0, 0, 16540, 16541, 5, + 2447, 0, 0, 16541, 16542, 3, 1870, 935, 0, 16542, 16543, 5, 2448, 0, 0, + 16543, 16545, 1, 0, 0, 0, 16544, 16532, 1, 0, 0, 0, 16544, 16540, 1, 0, + 0, 0, 16545, 16547, 1, 0, 0, 0, 16546, 16521, 1, 0, 0, 0, 16546, 16530, + 1, 0, 0, 0, 16547, 1793, 1, 0, 0, 0, 16548, 16549, 5, 615, 0, 0, 16549, + 16550, 3, 2328, 1164, 0, 16550, 16551, 5, 738, 0, 0, 16551, 16554, 3, 1796, + 898, 0, 16552, 16553, 5, 1617, 0, 0, 16553, 16555, 5, 537, 0, 0, 16554, + 16552, 1, 0, 0, 0, 16554, 16555, 1, 0, 0, 0, 16555, 16558, 1, 0, 0, 0, + 16556, 16559, 3, 1836, 918, 0, 16557, 16559, 3, 1832, 916, 0, 16558, 16556, + 1, 0, 0, 0, 16558, 16557, 1, 0, 0, 0, 16559, 1795, 1, 0, 0, 0, 16560, 16561, + 3, 1800, 900, 0, 16561, 16562, 5, 2439, 0, 0, 16562, 16563, 3, 1802, 901, + 0, 16563, 16574, 1, 0, 0, 0, 16564, 16565, 5, 734, 0, 0, 16565, 16566, + 5, 1246, 0, 0, 16566, 16568, 3, 2384, 1192, 0, 16567, 16569, 3, 1798, 899, + 0, 16568, 16567, 1, 0, 0, 0, 16568, 16569, 1, 0, 0, 0, 16569, 16574, 1, + 0, 0, 0, 16570, 16571, 5, 2257, 0, 0, 16571, 16572, 5, 1246, 0, 0, 16572, + 16574, 3, 2328, 1164, 0, 16573, 16560, 1, 0, 0, 0, 16573, 16564, 1, 0, + 0, 0, 16573, 16570, 1, 0, 0, 0, 16574, 1797, 1, 0, 0, 0, 16575, 16576, + 5, 118, 0, 0, 16576, 16577, 3, 1800, 900, 0, 16577, 16578, 5, 49, 0, 0, + 16578, 16579, 3, 1802, 901, 0, 16579, 1799, 1, 0, 0, 0, 16580, 16581, 3, + 2102, 1051, 0, 16581, 1801, 1, 0, 0, 0, 16582, 16583, 3, 2102, 1051, 0, + 16583, 1803, 1, 0, 0, 0, 16584, 16585, 5, 1228, 0, 0, 16585, 1805, 1, 0, + 0, 0, 16586, 16588, 5, 1492, 0, 0, 16587, 16589, 3, 2318, 1159, 0, 16588, + 16587, 1, 0, 0, 0, 16588, 16589, 1, 0, 0, 0, 16589, 1807, 1, 0, 0, 0, 16590, + 16592, 5, 1586, 0, 0, 16591, 16593, 3, 2078, 1039, 0, 16592, 16591, 1, + 0, 0, 0, 16592, 16593, 1, 0, 0, 0, 16593, 1809, 1, 0, 0, 0, 16594, 16596, + 5, 173, 0, 0, 16595, 16594, 1, 0, 0, 0, 16595, 16596, 1, 0, 0, 0, 16596, + 16597, 1, 0, 0, 0, 16597, 16599, 3, 2288, 1144, 0, 16598, 16600, 3, 2364, + 1182, 0, 16599, 16598, 1, 0, 0, 0, 16599, 16600, 1, 0, 0, 0, 16600, 16608, + 1, 0, 0, 0, 16601, 16602, 5, 2440, 0, 0, 16602, 16604, 3, 2288, 1144, 0, + 16603, 16605, 3, 2364, 1182, 0, 16604, 16603, 1, 0, 0, 0, 16604, 16605, + 1, 0, 0, 0, 16605, 16607, 1, 0, 0, 0, 16606, 16601, 1, 0, 0, 0, 16607, + 16610, 1, 0, 0, 0, 16608, 16606, 1, 0, 0, 0, 16608, 16609, 1, 0, 0, 0, + 16609, 16613, 1, 0, 0, 0, 16610, 16608, 1, 0, 0, 0, 16611, 16612, 5, 779, + 0, 0, 16612, 16614, 3, 2382, 1191, 0, 16613, 16611, 1, 0, 0, 0, 16613, + 16614, 1, 0, 0, 0, 16614, 1811, 1, 0, 0, 0, 16615, 16616, 5, 1395, 0, 0, + 16616, 16617, 5, 1606, 0, 0, 16617, 16618, 5, 2447, 0, 0, 16618, 16619, + 3, 2078, 1039, 0, 16619, 16620, 5, 2448, 0, 0, 16620, 1813, 1, 0, 0, 0, + 16621, 16622, 5, 460, 0, 0, 16622, 16623, 3, 2074, 1037, 0, 16623, 16624, + 5, 461, 0, 0, 16624, 16629, 3, 1818, 909, 0, 16625, 16626, 5, 457, 0, 0, + 16626, 16628, 3, 1818, 909, 0, 16627, 16625, 1, 0, 0, 0, 16628, 16631, + 1, 0, 0, 0, 16629, 16627, 1, 0, 0, 0, 16629, 16630, 1, 0, 0, 0, 16630, + 16634, 1, 0, 0, 0, 16631, 16629, 1, 0, 0, 0, 16632, 16633, 5, 456, 0, 0, + 16633, 16635, 3, 1818, 909, 0, 16634, 16632, 1, 0, 0, 0, 16634, 16635, + 1, 0, 0, 0, 16635, 16636, 1, 0, 0, 0, 16636, 16637, 5, 458, 0, 0, 16637, + 1815, 1, 0, 0, 0, 16638, 16639, 5, 459, 0, 0, 16639, 16640, 3, 2102, 1051, + 0, 16640, 16641, 5, 458, 0, 0, 16641, 1817, 1, 0, 0, 0, 16642, 16644, 3, + 1754, 877, 0, 16643, 16642, 1, 0, 0, 0, 16643, 16644, 1, 0, 0, 0, 16644, + 16645, 1, 0, 0, 0, 16645, 16646, 3, 1774, 887, 0, 16646, 16647, 5, 2470, + 0, 0, 16647, 16653, 1, 0, 0, 0, 16648, 16653, 3, 1744, 872, 0, 16649, 16653, + 3, 1816, 908, 0, 16650, 16653, 3, 176, 88, 0, 16651, 16653, 3, 178, 89, + 0, 16652, 16643, 1, 0, 0, 0, 16652, 16648, 1, 0, 0, 0, 16652, 16649, 1, + 0, 0, 0, 16652, 16650, 1, 0, 0, 0, 16652, 16651, 1, 0, 0, 0, 16653, 16654, + 1, 0, 0, 0, 16654, 16652, 1, 0, 0, 0, 16654, 16655, 1, 0, 0, 0, 16655, + 1819, 1, 0, 0, 0, 16656, 16657, 5, 113, 0, 0, 16657, 16664, 3, 1770, 885, + 0, 16658, 16660, 5, 535, 0, 0, 16659, 16661, 3, 1822, 911, 0, 16660, 16659, + 1, 0, 0, 0, 16661, 16662, 1, 0, 0, 0, 16662, 16660, 1, 0, 0, 0, 16662, + 16663, 1, 0, 0, 0, 16663, 16665, 1, 0, 0, 0, 16664, 16658, 1, 0, 0, 0, + 16664, 16665, 1, 0, 0, 0, 16665, 16666, 1, 0, 0, 0, 16666, 16668, 5, 508, + 0, 0, 16667, 16669, 3, 2312, 1156, 0, 16668, 16667, 1, 0, 0, 0, 16668, + 16669, 1, 0, 0, 0, 16669, 1821, 1, 0, 0, 0, 16670, 16671, 5, 2300, 0, 0, + 16671, 16676, 3, 2318, 1159, 0, 16672, 16673, 5, 1307, 0, 0, 16673, 16675, + 3, 2318, 1159, 0, 16674, 16672, 1, 0, 0, 0, 16675, 16678, 1, 0, 0, 0, 16676, + 16674, 1, 0, 0, 0, 16676, 16677, 1, 0, 0, 0, 16677, 16679, 1, 0, 0, 0, + 16678, 16676, 1, 0, 0, 0, 16679, 16680, 5, 2099, 0, 0, 16680, 16681, 3, + 1770, 885, 0, 16681, 1823, 1, 0, 0, 0, 16682, 16686, 5, 382, 0, 0, 16683, + 16685, 3, 1742, 871, 0, 16684, 16683, 1, 0, 0, 0, 16685, 16688, 1, 0, 0, + 0, 16686, 16684, 1, 0, 0, 0, 16686, 16687, 1, 0, 0, 0, 16687, 16690, 1, + 0, 0, 0, 16688, 16686, 1, 0, 0, 0, 16689, 16682, 1, 0, 0, 0, 16689, 16690, + 1, 0, 0, 0, 16690, 16691, 1, 0, 0, 0, 16691, 16692, 3, 1820, 910, 0, 16692, + 1825, 1, 0, 0, 0, 16693, 16695, 3, 1742, 871, 0, 16694, 16693, 1, 0, 0, + 0, 16695, 16698, 1, 0, 0, 0, 16696, 16694, 1, 0, 0, 0, 16696, 16697, 1, + 0, 0, 0, 16697, 16699, 1, 0, 0, 0, 16698, 16696, 1, 0, 0, 0, 16699, 16700, + 3, 1820, 910, 0, 16700, 1827, 1, 0, 0, 0, 16701, 16705, 5, 382, 0, 0, 16702, + 16704, 3, 1742, 871, 0, 16703, 16702, 1, 0, 0, 0, 16704, 16707, 1, 0, 0, + 0, 16705, 16703, 1, 0, 0, 0, 16705, 16706, 1, 0, 0, 0, 16706, 16709, 1, + 0, 0, 0, 16707, 16705, 1, 0, 0, 0, 16708, 16701, 1, 0, 0, 0, 16708, 16709, + 1, 0, 0, 0, 16709, 16710, 1, 0, 0, 0, 16710, 16711, 3, 1820, 910, 0, 16711, + 1829, 1, 0, 0, 0, 16712, 16718, 3, 1832, 916, 0, 16713, 16718, 3, 1836, + 918, 0, 16714, 16718, 3, 1838, 919, 0, 16715, 16718, 3, 1850, 925, 0, 16716, + 16718, 3, 1864, 932, 0, 16717, 16712, 1, 0, 0, 0, 16717, 16713, 1, 0, 0, + 0, 16717, 16714, 1, 0, 0, 0, 16717, 16715, 1, 0, 0, 0, 16717, 16716, 1, + 0, 0, 0, 16718, 1831, 1, 0, 0, 0, 16719, 16720, 5, 542, 0, 0, 16720, 16721, + 5, 698, 0, 0, 16721, 16731, 3, 2078, 1039, 0, 16722, 16724, 3, 2274, 1137, + 0, 16723, 16725, 3, 2210, 1105, 0, 16724, 16723, 1, 0, 0, 0, 16724, 16725, + 1, 0, 0, 0, 16725, 16732, 1, 0, 0, 0, 16726, 16728, 3, 2210, 1105, 0, 16727, + 16729, 3, 1834, 917, 0, 16728, 16727, 1, 0, 0, 0, 16728, 16729, 1, 0, 0, + 0, 16729, 16732, 1, 0, 0, 0, 16730, 16732, 3, 1834, 917, 0, 16731, 16722, + 1, 0, 0, 0, 16731, 16726, 1, 0, 0, 0, 16731, 16730, 1, 0, 0, 0, 16731, + 16732, 1, 0, 0, 0, 16732, 1833, 1, 0, 0, 0, 16733, 16734, 7, 205, 0, 0, + 16734, 16735, 3, 2274, 1137, 0, 16735, 1835, 1, 0, 0, 0, 16736, 16744, + 3, 2034, 1017, 0, 16737, 16744, 3, 2046, 1023, 0, 16738, 16744, 3, 1870, + 935, 0, 16739, 16744, 3, 2008, 1004, 0, 16740, 16744, 3, 2014, 1007, 0, + 16741, 16744, 3, 2016, 1008, 0, 16742, 16744, 3, 1866, 933, 0, 16743, 16736, + 1, 0, 0, 0, 16743, 16737, 1, 0, 0, 0, 16743, 16738, 1, 0, 0, 0, 16743, + 16739, 1, 0, 0, 0, 16743, 16740, 1, 0, 0, 0, 16743, 16741, 1, 0, 0, 0, + 16743, 16742, 1, 0, 0, 0, 16744, 1837, 1, 0, 0, 0, 16745, 16750, 3, 1840, + 920, 0, 16746, 16750, 3, 1842, 921, 0, 16747, 16750, 3, 1844, 922, 0, 16748, + 16750, 3, 1848, 924, 0, 16749, 16745, 1, 0, 0, 0, 16749, 16746, 1, 0, 0, + 0, 16749, 16747, 1, 0, 0, 0, 16749, 16748, 1, 0, 0, 0, 16750, 1839, 1, + 0, 0, 0, 16751, 16752, 5, 218, 0, 0, 16752, 16753, 3, 2330, 1165, 0, 16753, + 1841, 1, 0, 0, 0, 16754, 16755, 5, 1264, 0, 0, 16755, 16761, 3, 2330, 1165, + 0, 16756, 16758, 5, 2447, 0, 0, 16757, 16759, 3, 2076, 1038, 0, 16758, + 16757, 1, 0, 0, 0, 16758, 16759, 1, 0, 0, 0, 16759, 16760, 1, 0, 0, 0, + 16760, 16762, 5, 2448, 0, 0, 16761, 16756, 1, 0, 0, 0, 16761, 16762, 1, + 0, 0, 0, 16762, 1843, 1, 0, 0, 0, 16763, 16764, 5, 586, 0, 0, 16764, 16792, + 3, 2330, 1165, 0, 16765, 16766, 5, 779, 0, 0, 16766, 16771, 3, 1846, 923, + 0, 16767, 16768, 5, 2453, 0, 0, 16768, 16770, 3, 1846, 923, 0, 16769, 16767, + 1, 0, 0, 0, 16770, 16773, 1, 0, 0, 0, 16771, 16769, 1, 0, 0, 0, 16771, + 16772, 1, 0, 0, 0, 16772, 16793, 1, 0, 0, 0, 16773, 16771, 1, 0, 0, 0, + 16774, 16775, 5, 159, 0, 0, 16775, 16776, 5, 233, 0, 0, 16776, 16777, 5, + 779, 0, 0, 16777, 16782, 3, 1846, 923, 0, 16778, 16779, 5, 2453, 0, 0, + 16779, 16781, 3, 1846, 923, 0, 16780, 16778, 1, 0, 0, 0, 16781, 16784, + 1, 0, 0, 0, 16782, 16780, 1, 0, 0, 0, 16782, 16783, 1, 0, 0, 0, 16783, + 16790, 1, 0, 0, 0, 16784, 16782, 1, 0, 0, 0, 16785, 16788, 5, 858, 0, 0, + 16786, 16789, 3, 2396, 1198, 0, 16787, 16789, 3, 1846, 923, 0, 16788, 16786, + 1, 0, 0, 0, 16788, 16787, 1, 0, 0, 0, 16789, 16791, 1, 0, 0, 0, 16790, + 16785, 1, 0, 0, 0, 16790, 16791, 1, 0, 0, 0, 16791, 16793, 1, 0, 0, 0, + 16792, 16765, 1, 0, 0, 0, 16792, 16774, 1, 0, 0, 0, 16793, 1845, 1, 0, + 0, 0, 16794, 16797, 3, 2326, 1163, 0, 16795, 16797, 3, 2120, 1060, 0, 16796, + 16794, 1, 0, 0, 0, 16796, 16795, 1, 0, 0, 0, 16797, 1847, 1, 0, 0, 0, 16798, + 16799, 5, 1264, 0, 0, 16799, 16800, 3, 2326, 1163, 0, 16800, 16803, 5, + 620, 0, 0, 16801, 16804, 3, 1870, 935, 0, 16802, 16804, 3, 2078, 1039, + 0, 16803, 16801, 1, 0, 0, 0, 16803, 16802, 1, 0, 0, 0, 16804, 16806, 1, + 0, 0, 0, 16805, 16807, 3, 2210, 1105, 0, 16806, 16805, 1, 0, 0, 0, 16806, + 16807, 1, 0, 0, 0, 16807, 1849, 1, 0, 0, 0, 16808, 16814, 3, 1852, 926, + 0, 16809, 16814, 3, 1854, 927, 0, 16810, 16814, 3, 1856, 928, 0, 16811, + 16814, 3, 1860, 930, 0, 16812, 16814, 3, 1862, 931, 0, 16813, 16808, 1, + 0, 0, 0, 16813, 16809, 1, 0, 0, 0, 16813, 16810, 1, 0, 0, 0, 16813, 16811, + 1, 0, 0, 0, 16813, 16812, 1, 0, 0, 0, 16814, 1851, 1, 0, 0, 0, 16815, 16816, + 5, 1671, 0, 0, 16816, 16830, 5, 2147, 0, 0, 16817, 16818, 5, 1505, 0, 0, + 16818, 16831, 7, 11, 0, 0, 16819, 16820, 5, 787, 0, 0, 16820, 16824, 5, + 846, 0, 0, 16821, 16825, 5, 1659, 0, 0, 16822, 16823, 5, 1505, 0, 0, 16823, + 16825, 5, 243, 0, 0, 16824, 16821, 1, 0, 0, 0, 16824, 16822, 1, 0, 0, 0, + 16825, 16831, 1, 0, 0, 0, 16826, 16827, 5, 2241, 0, 0, 16827, 16828, 5, + 1596, 0, 0, 16828, 16829, 5, 1645, 0, 0, 16829, 16831, 3, 2284, 1142, 0, + 16830, 16817, 1, 0, 0, 0, 16830, 16819, 1, 0, 0, 0, 16830, 16826, 1, 0, + 0, 0, 16830, 16831, 1, 0, 0, 0, 16831, 16834, 1, 0, 0, 0, 16832, 16833, + 5, 997, 0, 0, 16833, 16835, 3, 2400, 1200, 0, 16834, 16832, 1, 0, 0, 0, + 16834, 16835, 1, 0, 0, 0, 16835, 1853, 1, 0, 0, 0, 16836, 16837, 5, 1671, + 0, 0, 16837, 16847, 7, 95, 0, 0, 16838, 16848, 5, 38, 0, 0, 16839, 16844, + 3, 2310, 1155, 0, 16840, 16841, 5, 2453, 0, 0, 16841, 16843, 3, 2310, 1155, + 0, 16842, 16840, 1, 0, 0, 0, 16843, 16846, 1, 0, 0, 0, 16844, 16842, 1, + 0, 0, 0, 16844, 16845, 1, 0, 0, 0, 16845, 16848, 1, 0, 0, 0, 16846, 16844, + 1, 0, 0, 0, 16847, 16838, 1, 0, 0, 0, 16847, 16839, 1, 0, 0, 0, 16848, + 16849, 1, 0, 0, 0, 16849, 16850, 7, 69, 0, 0, 16850, 1855, 1, 0, 0, 0, + 16851, 16853, 5, 242, 0, 0, 16852, 16854, 5, 2309, 0, 0, 16853, 16852, + 1, 0, 0, 0, 16853, 16854, 1, 0, 0, 0, 16854, 16856, 1, 0, 0, 0, 16855, + 16857, 3, 1858, 929, 0, 16856, 16855, 1, 0, 0, 0, 16856, 16857, 1, 0, 0, + 0, 16857, 16874, 1, 0, 0, 0, 16858, 16859, 5, 241, 0, 0, 16859, 16861, + 5, 2443, 0, 0, 16860, 16862, 3, 1858, 929, 0, 16861, 16860, 1, 0, 0, 0, + 16861, 16862, 1, 0, 0, 0, 16862, 16875, 1, 0, 0, 0, 16863, 16872, 5, 616, + 0, 0, 16864, 16867, 5, 2443, 0, 0, 16865, 16866, 5, 2453, 0, 0, 16866, + 16868, 3, 2396, 1198, 0, 16867, 16865, 1, 0, 0, 0, 16867, 16868, 1, 0, + 0, 0, 16868, 16873, 1, 0, 0, 0, 16869, 16870, 5, 308, 0, 0, 16870, 16873, + 5, 2443, 0, 0, 16871, 16873, 5, 307, 0, 0, 16872, 16864, 1, 0, 0, 0, 16872, + 16869, 1, 0, 0, 0, 16872, 16871, 1, 0, 0, 0, 16873, 16875, 1, 0, 0, 0, + 16874, 16858, 1, 0, 0, 0, 16874, 16863, 1, 0, 0, 0, 16874, 16875, 1, 0, + 0, 0, 16875, 1857, 1, 0, 0, 0, 16876, 16881, 5, 2313, 0, 0, 16877, 16880, + 7, 206, 0, 0, 16878, 16880, 7, 0, 0, 0, 16879, 16877, 1, 0, 0, 0, 16879, + 16878, 1, 0, 0, 0, 16880, 16883, 1, 0, 0, 0, 16881, 16879, 1, 0, 0, 0, + 16881, 16882, 1, 0, 0, 0, 16882, 1859, 1, 0, 0, 0, 16883, 16881, 1, 0, + 0, 0, 16884, 16886, 5, 1596, 0, 0, 16885, 16887, 5, 2309, 0, 0, 16886, + 16885, 1, 0, 0, 0, 16886, 16887, 1, 0, 0, 0, 16887, 16895, 1, 0, 0, 0, + 16888, 16890, 5, 2141, 0, 0, 16889, 16891, 5, 1616, 0, 0, 16890, 16889, + 1, 0, 0, 0, 16890, 16891, 1, 0, 0, 0, 16891, 16892, 1, 0, 0, 0, 16892, + 16896, 3, 2282, 1141, 0, 16893, 16894, 5, 616, 0, 0, 16894, 16896, 3, 2400, + 1200, 0, 16895, 16888, 1, 0, 0, 0, 16895, 16893, 1, 0, 0, 0, 16895, 16896, + 1, 0, 0, 0, 16896, 1861, 1, 0, 0, 0, 16897, 16898, 5, 1616, 0, 0, 16898, + 16899, 3, 2282, 1141, 0, 16899, 1863, 1, 0, 0, 0, 16900, 16901, 3, 2078, + 1039, 0, 16901, 16923, 5, 2440, 0, 0, 16902, 16914, 7, 207, 0, 0, 16903, + 16904, 5, 2447, 0, 0, 16904, 16909, 3, 2078, 1039, 0, 16905, 16906, 5, + 2453, 0, 0, 16906, 16908, 3, 2078, 1039, 0, 16907, 16905, 1, 0, 0, 0, 16908, + 16911, 1, 0, 0, 0, 16909, 16907, 1, 0, 0, 0, 16909, 16910, 1, 0, 0, 0, + 16910, 16912, 1, 0, 0, 0, 16911, 16909, 1, 0, 0, 0, 16912, 16913, 5, 2448, + 0, 0, 16913, 16915, 1, 0, 0, 0, 16914, 16903, 1, 0, 0, 0, 16914, 16915, + 1, 0, 0, 0, 16915, 16924, 1, 0, 0, 0, 16916, 16921, 5, 2418, 0, 0, 16917, + 16918, 5, 2447, 0, 0, 16918, 16919, 3, 2078, 1039, 0, 16919, 16920, 5, + 2448, 0, 0, 16920, 16922, 1, 0, 0, 0, 16921, 16917, 1, 0, 0, 0, 16921, + 16922, 1, 0, 0, 0, 16922, 16924, 1, 0, 0, 0, 16923, 16902, 1, 0, 0, 0, + 16923, 16916, 1, 0, 0, 0, 16924, 1865, 1, 0, 0, 0, 16925, 16926, 5, 552, + 0, 0, 16926, 16931, 5, 1401, 0, 0, 16927, 16928, 5, 1671, 0, 0, 16928, + 16929, 5, 1740, 0, 0, 16929, 16930, 5, 2472, 0, 0, 16930, 16932, 3, 2400, + 1200, 0, 16931, 16927, 1, 0, 0, 0, 16931, 16932, 1, 0, 0, 0, 16932, 16935, + 1, 0, 0, 0, 16933, 16934, 5, 779, 0, 0, 16934, 16936, 3, 2342, 1171, 0, + 16935, 16933, 1, 0, 0, 0, 16935, 16936, 1, 0, 0, 0, 16936, 16937, 1, 0, + 0, 0, 16937, 16943, 5, 620, 0, 0, 16938, 16944, 3, 1870, 935, 0, 16939, + 16944, 3, 2008, 1004, 0, 16940, 16944, 3, 2014, 1007, 0, 16941, 16944, + 3, 2016, 1008, 0, 16942, 16944, 3, 2034, 1017, 0, 16943, 16938, 1, 0, 0, + 0, 16943, 16939, 1, 0, 0, 0, 16943, 16940, 1, 0, 0, 0, 16943, 16941, 1, + 0, 0, 0, 16943, 16942, 1, 0, 0, 0, 16944, 1867, 1, 0, 0, 0, 16945, 16947, + 3, 1872, 936, 0, 16946, 16945, 1, 0, 0, 0, 16946, 16947, 1, 0, 0, 0, 16947, + 16948, 1, 0, 0, 0, 16948, 16949, 3, 1896, 948, 0, 16949, 1869, 1, 0, 0, + 0, 16950, 16957, 3, 1868, 934, 0, 16951, 16956, 3, 2002, 1001, 0, 16952, + 16956, 3, 1994, 997, 0, 16953, 16956, 3, 1998, 999, 0, 16954, 16956, 3, + 2000, 1000, 0, 16955, 16951, 1, 0, 0, 0, 16955, 16952, 1, 0, 0, 0, 16955, + 16953, 1, 0, 0, 0, 16955, 16954, 1, 0, 0, 0, 16956, 16959, 1, 0, 0, 0, + 16957, 16955, 1, 0, 0, 0, 16957, 16958, 1, 0, 0, 0, 16958, 1871, 1, 0, + 0, 0, 16959, 16957, 1, 0, 0, 0, 16960, 16965, 5, 2308, 0, 0, 16961, 16964, + 3, 176, 88, 0, 16962, 16964, 3, 178, 89, 0, 16963, 16961, 1, 0, 0, 0, 16963, + 16962, 1, 0, 0, 0, 16964, 16967, 1, 0, 0, 0, 16965, 16963, 1, 0, 0, 0, + 16965, 16966, 1, 0, 0, 0, 16966, 16968, 1, 0, 0, 0, 16967, 16965, 1, 0, + 0, 0, 16968, 16973, 3, 1874, 937, 0, 16969, 16970, 5, 2453, 0, 0, 16970, + 16972, 3, 1874, 937, 0, 16971, 16969, 1, 0, 0, 0, 16972, 16975, 1, 0, 0, + 0, 16973, 16971, 1, 0, 0, 0, 16973, 16974, 1, 0, 0, 0, 16974, 16994, 1, + 0, 0, 0, 16975, 16973, 1, 0, 0, 0, 16976, 16979, 5, 2308, 0, 0, 16977, + 16980, 3, 176, 88, 0, 16978, 16980, 3, 178, 89, 0, 16979, 16977, 1, 0, + 0, 0, 16979, 16978, 1, 0, 0, 0, 16980, 16981, 1, 0, 0, 0, 16981, 16979, + 1, 0, 0, 0, 16981, 16982, 1, 0, 0, 0, 16982, 16991, 1, 0, 0, 0, 16983, + 16988, 3, 1874, 937, 0, 16984, 16985, 5, 2453, 0, 0, 16985, 16987, 3, 1874, + 937, 0, 16986, 16984, 1, 0, 0, 0, 16987, 16990, 1, 0, 0, 0, 16988, 16986, + 1, 0, 0, 0, 16988, 16989, 1, 0, 0, 0, 16989, 16992, 1, 0, 0, 0, 16990, + 16988, 1, 0, 0, 0, 16991, 16983, 1, 0, 0, 0, 16991, 16992, 1, 0, 0, 0, + 16992, 16994, 1, 0, 0, 0, 16993, 16960, 1, 0, 0, 0, 16993, 16976, 1, 0, + 0, 0, 16994, 1873, 1, 0, 0, 0, 16995, 16998, 3, 1876, 938, 0, 16996, 16998, + 3, 1882, 941, 0, 16997, 16995, 1, 0, 0, 0, 16997, 16996, 1, 0, 0, 0, 16998, + 1875, 1, 0, 0, 0, 16999, 17001, 3, 2304, 1152, 0, 17000, 17002, 3, 2360, + 1180, 0, 17001, 17000, 1, 0, 0, 0, 17001, 17002, 1, 0, 0, 0, 17002, 17003, + 1, 0, 0, 0, 17003, 17004, 5, 69, 0, 0, 17004, 17005, 5, 2447, 0, 0, 17005, + 17007, 3, 1896, 948, 0, 17006, 17008, 3, 1994, 997, 0, 17007, 17006, 1, + 0, 0, 0, 17007, 17008, 1, 0, 0, 0, 17008, 17009, 1, 0, 0, 0, 17009, 17011, + 5, 2448, 0, 0, 17010, 17012, 3, 1878, 939, 0, 17011, 17010, 1, 0, 0, 0, + 17011, 17012, 1, 0, 0, 0, 17012, 17014, 1, 0, 0, 0, 17013, 17015, 3, 1880, + 940, 0, 17014, 17013, 1, 0, 0, 0, 17014, 17015, 1, 0, 0, 0, 17015, 1877, + 1, 0, 0, 0, 17016, 17017, 5, 1635, 0, 0, 17017, 17018, 7, 208, 0, 0, 17018, + 17019, 5, 598, 0, 0, 17019, 17020, 5, 160, 0, 0, 17020, 17022, 3, 2340, + 1170, 0, 17021, 17023, 5, 70, 0, 0, 17022, 17021, 1, 0, 0, 0, 17022, 17023, + 1, 0, 0, 0, 17023, 17025, 1, 0, 0, 0, 17024, 17026, 5, 414, 0, 0, 17025, + 17024, 1, 0, 0, 0, 17025, 17026, 1, 0, 0, 0, 17026, 17029, 1, 0, 0, 0, + 17027, 17028, 5, 1229, 0, 0, 17028, 17030, 5, 598, 0, 0, 17029, 17027, + 1, 0, 0, 0, 17029, 17030, 1, 0, 0, 0, 17030, 17033, 1, 0, 0, 0, 17031, + 17032, 5, 1229, 0, 0, 17032, 17034, 5, 825, 0, 0, 17033, 17031, 1, 0, 0, + 0, 17033, 17034, 1, 0, 0, 0, 17034, 17053, 1, 0, 0, 0, 17035, 17036, 5, + 2453, 0, 0, 17036, 17038, 3, 2340, 1170, 0, 17037, 17039, 5, 70, 0, 0, + 17038, 17037, 1, 0, 0, 0, 17038, 17039, 1, 0, 0, 0, 17039, 17041, 1, 0, + 0, 0, 17040, 17042, 5, 414, 0, 0, 17041, 17040, 1, 0, 0, 0, 17041, 17042, + 1, 0, 0, 0, 17042, 17045, 1, 0, 0, 0, 17043, 17044, 5, 1229, 0, 0, 17044, + 17046, 5, 598, 0, 0, 17045, 17043, 1, 0, 0, 0, 17045, 17046, 1, 0, 0, 0, + 17046, 17049, 1, 0, 0, 0, 17047, 17048, 5, 1229, 0, 0, 17048, 17050, 5, + 825, 0, 0, 17049, 17047, 1, 0, 0, 0, 17049, 17050, 1, 0, 0, 0, 17050, 17052, + 1, 0, 0, 0, 17051, 17035, 1, 0, 0, 0, 17052, 17055, 1, 0, 0, 0, 17053, + 17051, 1, 0, 0, 0, 17053, 17054, 1, 0, 0, 0, 17054, 17056, 1, 0, 0, 0, + 17055, 17053, 1, 0, 0, 0, 17056, 17057, 5, 1671, 0, 0, 17057, 17058, 3, + 2340, 1170, 0, 17058, 1879, 1, 0, 0, 0, 17059, 17060, 5, 348, 0, 0, 17060, + 17061, 3, 2358, 1179, 0, 17061, 17062, 5, 1671, 0, 0, 17062, 17063, 3, + 2340, 1170, 0, 17063, 17064, 5, 2141, 0, 0, 17064, 17065, 3, 2078, 1039, + 0, 17065, 17066, 5, 389, 0, 0, 17066, 17067, 3, 2078, 1039, 0, 17067, 1881, + 1, 0, 0, 0, 17068, 17069, 3, 2404, 1202, 0, 17069, 17070, 5, 45, 0, 0, + 17070, 17071, 5, 2286, 0, 0, 17071, 17072, 5, 69, 0, 0, 17072, 17073, 5, + 2447, 0, 0, 17073, 17074, 3, 1884, 942, 0, 17074, 17075, 5, 2448, 0, 0, + 17075, 1883, 1, 0, 0, 0, 17076, 17077, 5, 2246, 0, 0, 17077, 17079, 3, + 740, 370, 0, 17078, 17080, 3, 1886, 943, 0, 17079, 17078, 1, 0, 0, 0, 17079, + 17080, 1, 0, 0, 0, 17080, 17082, 1, 0, 0, 0, 17081, 17083, 3, 1888, 944, + 0, 17082, 17081, 1, 0, 0, 0, 17082, 17083, 1, 0, 0, 0, 17083, 17085, 1, + 0, 0, 0, 17084, 17086, 3, 1892, 946, 0, 17085, 17084, 1, 0, 0, 0, 17085, + 17086, 1, 0, 0, 0, 17086, 1885, 1, 0, 0, 0, 17087, 17088, 5, 673, 0, 0, + 17088, 17089, 5, 2447, 0, 0, 17089, 17094, 3, 740, 370, 0, 17090, 17091, + 5, 2453, 0, 0, 17091, 17093, 3, 740, 370, 0, 17092, 17090, 1, 0, 0, 0, + 17093, 17096, 1, 0, 0, 0, 17094, 17092, 1, 0, 0, 0, 17094, 17095, 1, 0, + 0, 0, 17095, 17097, 1, 0, 0, 0, 17096, 17094, 1, 0, 0, 0, 17097, 17098, + 5, 2448, 0, 0, 17098, 1887, 1, 0, 0, 0, 17099, 17100, 5, 594, 0, 0, 17100, + 17101, 5, 567, 0, 0, 17101, 17102, 5, 2447, 0, 0, 17102, 17107, 3, 1890, + 945, 0, 17103, 17104, 5, 2453, 0, 0, 17104, 17106, 3, 1890, 945, 0, 17105, + 17103, 1, 0, 0, 0, 17106, 17109, 1, 0, 0, 0, 17107, 17105, 1, 0, 0, 0, + 17107, 17108, 1, 0, 0, 0, 17108, 17110, 1, 0, 0, 0, 17109, 17107, 1, 0, + 0, 0, 17110, 17111, 5, 2448, 0, 0, 17111, 1889, 1, 0, 0, 0, 17112, 17115, + 5, 934, 0, 0, 17113, 17115, 3, 740, 370, 0, 17114, 17112, 1, 0, 0, 0, 17114, + 17113, 1, 0, 0, 0, 17115, 17116, 1, 0, 0, 0, 17116, 17117, 5, 2141, 0, + 0, 17117, 17118, 3, 2074, 1037, 0, 17118, 1891, 1, 0, 0, 0, 17119, 17120, + 5, 21, 0, 0, 17120, 17121, 5, 934, 0, 0, 17121, 17122, 5, 2447, 0, 0, 17122, + 17127, 3, 1894, 947, 0, 17123, 17124, 5, 2453, 0, 0, 17124, 17126, 3, 1894, + 947, 0, 17125, 17123, 1, 0, 0, 0, 17126, 17129, 1, 0, 0, 0, 17127, 17125, + 1, 0, 0, 0, 17127, 17128, 1, 0, 0, 0, 17128, 17130, 1, 0, 0, 0, 17129, + 17127, 1, 0, 0, 0, 17130, 17131, 5, 2448, 0, 0, 17131, 1893, 1, 0, 0, 0, + 17132, 17133, 3, 2404, 1202, 0, 17133, 17134, 5, 69, 0, 0, 17134, 17135, + 5, 2447, 0, 0, 17135, 17136, 3, 2078, 1039, 0, 17136, 17137, 5, 2448, 0, + 0, 17137, 1895, 1, 0, 0, 0, 17138, 17142, 3, 1898, 949, 0, 17139, 17141, + 3, 1900, 950, 0, 17140, 17139, 1, 0, 0, 0, 17141, 17144, 1, 0, 0, 0, 17142, + 17140, 1, 0, 0, 0, 17142, 17143, 1, 0, 0, 0, 17143, 1897, 1, 0, 0, 0, 17144, + 17142, 1, 0, 0, 0, 17145, 17151, 3, 1902, 951, 0, 17146, 17147, 5, 2447, + 0, 0, 17147, 17148, 3, 1896, 948, 0, 17148, 17149, 5, 2448, 0, 0, 17149, + 17151, 1, 0, 0, 0, 17150, 17145, 1, 0, 0, 0, 17150, 17146, 1, 0, 0, 0, + 17151, 1899, 1, 0, 0, 0, 17152, 17154, 5, 2181, 0, 0, 17153, 17155, 5, + 38, 0, 0, 17154, 17153, 1, 0, 0, 0, 17154, 17155, 1, 0, 0, 0, 17155, 17159, + 1, 0, 0, 0, 17156, 17159, 5, 775, 0, 0, 17157, 17159, 5, 956, 0, 0, 17158, + 17152, 1, 0, 0, 0, 17158, 17156, 1, 0, 0, 0, 17158, 17157, 1, 0, 0, 0, + 17159, 17160, 1, 0, 0, 0, 17160, 17161, 3, 1898, 949, 0, 17161, 1901, 1, + 0, 0, 0, 17162, 17164, 5, 1647, 0, 0, 17163, 17165, 7, 209, 0, 0, 17164, + 17163, 1, 0, 0, 0, 17164, 17165, 1, 0, 0, 0, 17165, 17166, 1, 0, 0, 0, + 17166, 17168, 3, 1904, 952, 0, 17167, 17169, 3, 2274, 1137, 0, 17168, 17167, + 1, 0, 0, 0, 17168, 17169, 1, 0, 0, 0, 17169, 17171, 1, 0, 0, 0, 17170, + 17172, 3, 1906, 953, 0, 17171, 17170, 1, 0, 0, 0, 17171, 17172, 1, 0, 0, + 0, 17172, 17174, 1, 0, 0, 0, 17173, 17175, 3, 2272, 1136, 0, 17174, 17173, + 1, 0, 0, 0, 17174, 17175, 1, 0, 0, 0, 17175, 17180, 1, 0, 0, 0, 17176, + 17179, 3, 1948, 974, 0, 17177, 17179, 3, 1952, 976, 0, 17178, 17176, 1, + 0, 0, 0, 17178, 17177, 1, 0, 0, 0, 17179, 17182, 1, 0, 0, 0, 17180, 17178, + 1, 0, 0, 0, 17180, 17181, 1, 0, 0, 0, 17181, 17184, 1, 0, 0, 0, 17182, + 17180, 1, 0, 0, 0, 17183, 17185, 3, 1964, 982, 0, 17184, 17183, 1, 0, 0, + 0, 17184, 17185, 1, 0, 0, 0, 17185, 17187, 1, 0, 0, 0, 17186, 17188, 3, + 1994, 997, 0, 17187, 17186, 1, 0, 0, 0, 17187, 17188, 1, 0, 0, 0, 17188, + 17190, 1, 0, 0, 0, 17189, 17191, 3, 1998, 999, 0, 17190, 17189, 1, 0, 0, + 0, 17190, 17191, 1, 0, 0, 0, 17191, 17193, 1, 0, 0, 0, 17192, 17194, 3, + 2000, 1000, 0, 17193, 17192, 1, 0, 0, 0, 17193, 17194, 1, 0, 0, 0, 17194, + 1903, 1, 0, 0, 0, 17195, 17205, 5, 2450, 0, 0, 17196, 17201, 3, 1908, 954, + 0, 17197, 17198, 5, 2453, 0, 0, 17198, 17200, 3, 1908, 954, 0, 17199, 17197, + 1, 0, 0, 0, 17200, 17203, 1, 0, 0, 0, 17201, 17199, 1, 0, 0, 0, 17201, + 17202, 1, 0, 0, 0, 17202, 17205, 1, 0, 0, 0, 17203, 17201, 1, 0, 0, 0, + 17204, 17195, 1, 0, 0, 0, 17204, 17196, 1, 0, 0, 0, 17205, 1905, 1, 0, + 0, 0, 17206, 17207, 5, 628, 0, 0, 17207, 17208, 3, 1910, 955, 0, 17208, + 1907, 1, 0, 0, 0, 17209, 17210, 3, 2342, 1171, 0, 17210, 17211, 5, 2440, + 0, 0, 17211, 17212, 5, 2450, 0, 0, 17212, 17218, 1, 0, 0, 0, 17213, 17215, + 3, 2078, 1039, 0, 17214, 17216, 3, 2268, 1134, 0, 17215, 17214, 1, 0, 0, + 0, 17215, 17216, 1, 0, 0, 0, 17216, 17218, 1, 0, 0, 0, 17217, 17209, 1, + 0, 0, 0, 17217, 17213, 1, 0, 0, 0, 17218, 1909, 1, 0, 0, 0, 17219, 17224, + 3, 1912, 956, 0, 17220, 17221, 5, 2453, 0, 0, 17221, 17223, 3, 1912, 956, + 0, 17222, 17220, 1, 0, 0, 0, 17223, 17226, 1, 0, 0, 0, 17224, 17222, 1, + 0, 0, 0, 17224, 17225, 1, 0, 0, 0, 17225, 1911, 1, 0, 0, 0, 17226, 17224, + 1, 0, 0, 0, 17227, 17231, 3, 1914, 957, 0, 17228, 17230, 3, 1918, 959, + 0, 17229, 17228, 1, 0, 0, 0, 17230, 17233, 1, 0, 0, 0, 17231, 17229, 1, + 0, 0, 0, 17231, 17232, 1, 0, 0, 0, 17232, 17236, 1, 0, 0, 0, 17233, 17231, + 1, 0, 0, 0, 17234, 17237, 3, 1930, 965, 0, 17235, 17237, 3, 1942, 971, + 0, 17236, 17234, 1, 0, 0, 0, 17236, 17235, 1, 0, 0, 0, 17236, 17237, 1, + 0, 0, 0, 17237, 1913, 1, 0, 0, 0, 17238, 17242, 3, 1916, 958, 0, 17239, + 17241, 3, 1928, 964, 0, 17240, 17239, 1, 0, 0, 0, 17241, 17244, 1, 0, 0, + 0, 17242, 17240, 1, 0, 0, 0, 17242, 17243, 1, 0, 0, 0, 17243, 17247, 1, + 0, 0, 0, 17244, 17242, 1, 0, 0, 0, 17245, 17246, 4, 957, 11, 0, 17246, + 17248, 3, 2270, 1135, 0, 17247, 17245, 1, 0, 0, 0, 17247, 17248, 1, 0, + 0, 0, 17248, 1915, 1, 0, 0, 0, 17249, 17252, 3, 2064, 1032, 0, 17250, 17253, + 3, 1930, 965, 0, 17251, 17253, 3, 1942, 971, 0, 17252, 17250, 1, 0, 0, + 0, 17252, 17251, 1, 0, 0, 0, 17252, 17253, 1, 0, 0, 0, 17253, 17273, 1, + 0, 0, 0, 17254, 17255, 5, 2447, 0, 0, 17255, 17259, 3, 1912, 956, 0, 17256, + 17258, 3, 1900, 950, 0, 17257, 17256, 1, 0, 0, 0, 17258, 17261, 1, 0, 0, + 0, 17259, 17257, 1, 0, 0, 0, 17259, 17260, 1, 0, 0, 0, 17260, 17262, 1, + 0, 0, 0, 17261, 17259, 1, 0, 0, 0, 17262, 17265, 5, 2448, 0, 0, 17263, + 17266, 3, 1930, 965, 0, 17264, 17266, 3, 1942, 971, 0, 17265, 17263, 1, + 0, 0, 0, 17265, 17264, 1, 0, 0, 0, 17265, 17266, 1, 0, 0, 0, 17266, 17273, + 1, 0, 0, 0, 17267, 17268, 5, 1258, 0, 0, 17268, 17269, 5, 2447, 0, 0, 17269, + 17270, 3, 2064, 1032, 0, 17270, 17271, 5, 2448, 0, 0, 17271, 17273, 1, + 0, 0, 0, 17272, 17249, 1, 0, 0, 0, 17272, 17254, 1, 0, 0, 0, 17272, 17267, + 1, 0, 0, 0, 17273, 1917, 1, 0, 0, 0, 17274, 17276, 3, 1926, 963, 0, 17275, + 17274, 1, 0, 0, 0, 17275, 17276, 1, 0, 0, 0, 17276, 17278, 1, 0, 0, 0, + 17277, 17279, 7, 210, 0, 0, 17278, 17277, 1, 0, 0, 0, 17278, 17279, 1, + 0, 0, 0, 17279, 17282, 1, 0, 0, 0, 17280, 17283, 5, 749, 0, 0, 17281, 17283, + 3, 1924, 962, 0, 17282, 17280, 1, 0, 0, 0, 17282, 17281, 1, 0, 0, 0, 17282, + 17283, 1, 0, 0, 0, 17283, 17284, 1, 0, 0, 0, 17284, 17285, 5, 794, 0, 0, + 17285, 17287, 3, 1914, 957, 0, 17286, 17288, 3, 1926, 963, 0, 17287, 17286, + 1, 0, 0, 0, 17287, 17288, 1, 0, 0, 0, 17288, 17293, 1, 0, 0, 0, 17289, + 17292, 3, 1920, 960, 0, 17290, 17292, 3, 1922, 961, 0, 17291, 17289, 1, + 0, 0, 0, 17291, 17290, 1, 0, 0, 0, 17292, 17295, 1, 0, 0, 0, 17293, 17291, + 1, 0, 0, 0, 17293, 17294, 1, 0, 0, 0, 17294, 17300, 1, 0, 0, 0, 17295, + 17293, 1, 0, 0, 0, 17296, 17297, 7, 211, 0, 0, 17297, 17298, 5, 61, 0, + 0, 17298, 17300, 3, 1914, 957, 0, 17299, 17275, 1, 0, 0, 0, 17299, 17296, + 1, 0, 0, 0, 17300, 1919, 1, 0, 0, 0, 17301, 17302, 5, 1259, 0, 0, 17302, + 17303, 3, 2074, 1037, 0, 17303, 1921, 1, 0, 0, 0, 17304, 17305, 5, 2246, + 0, 0, 17305, 17306, 3, 2360, 1180, 0, 17306, 1923, 1, 0, 0, 0, 17307, 17309, + 7, 212, 0, 0, 17308, 17310, 5, 1313, 0, 0, 17309, 17308, 1, 0, 0, 0, 17309, + 17310, 1, 0, 0, 0, 17310, 1925, 1, 0, 0, 0, 17311, 17312, 5, 1348, 0, 0, + 17312, 17320, 5, 160, 0, 0, 17313, 17316, 5, 2447, 0, 0, 17314, 17317, + 3, 1896, 948, 0, 17315, 17317, 3, 2076, 1038, 0, 17316, 17314, 1, 0, 0, + 0, 17316, 17315, 1, 0, 0, 0, 17316, 17317, 1, 0, 0, 0, 17317, 17318, 1, + 0, 0, 0, 17318, 17321, 5, 2448, 0, 0, 17319, 17321, 3, 2076, 1038, 0, 17320, + 17313, 1, 0, 0, 0, 17320, 17319, 1, 0, 0, 0, 17321, 1927, 1, 0, 0, 0, 17322, + 17330, 5, 2283, 0, 0, 17323, 17324, 5, 1386, 0, 0, 17324, 17325, 5, 620, + 0, 0, 17325, 17326, 3, 2340, 1170, 0, 17326, 17327, 5, 118, 0, 0, 17327, + 17331, 1, 0, 0, 0, 17328, 17329, 5, 118, 0, 0, 17329, 17331, 7, 83, 0, + 0, 17330, 17323, 1, 0, 0, 0, 17330, 17328, 1, 0, 0, 0, 17331, 17332, 1, + 0, 0, 0, 17332, 17333, 3, 2078, 1039, 0, 17333, 17334, 5, 49, 0, 0, 17334, + 17335, 3, 2078, 1039, 0, 17335, 17348, 1, 0, 0, 0, 17336, 17337, 5, 69, + 0, 0, 17337, 17345, 5, 1246, 0, 0, 17338, 17339, 7, 213, 0, 0, 17339, 17346, + 3, 2078, 1039, 0, 17340, 17341, 5, 1386, 0, 0, 17341, 17342, 5, 620, 0, + 0, 17342, 17343, 3, 2340, 1170, 0, 17343, 17344, 3, 2078, 1039, 0, 17344, + 17346, 1, 0, 0, 0, 17345, 17338, 1, 0, 0, 0, 17345, 17340, 1, 0, 0, 0, + 17346, 17348, 1, 0, 0, 0, 17347, 17322, 1, 0, 0, 0, 17347, 17336, 1, 0, + 0, 0, 17348, 1929, 1, 0, 0, 0, 17349, 17351, 5, 1397, 0, 0, 17350, 17352, + 5, 2352, 0, 0, 17351, 17350, 1, 0, 0, 0, 17351, 17352, 1, 0, 0, 0, 17352, + 17353, 1, 0, 0, 0, 17353, 17354, 5, 2447, 0, 0, 17354, 17359, 3, 1932, + 966, 0, 17355, 17356, 5, 2453, 0, 0, 17356, 17358, 3, 1932, 966, 0, 17357, + 17355, 1, 0, 0, 0, 17358, 17361, 1, 0, 0, 0, 17359, 17357, 1, 0, 0, 0, + 17359, 17360, 1, 0, 0, 0, 17360, 17362, 1, 0, 0, 0, 17361, 17359, 1, 0, + 0, 0, 17362, 17363, 3, 1934, 967, 0, 17363, 17364, 3, 1936, 968, 0, 17364, + 17366, 5, 2448, 0, 0, 17365, 17367, 3, 2270, 1135, 0, 17366, 17365, 1, + 0, 0, 0, 17366, 17367, 1, 0, 0, 0, 17367, 1931, 1, 0, 0, 0, 17368, 17375, + 3, 2190, 1095, 0, 17369, 17370, 3, 2302, 1151, 0, 17370, 17371, 5, 2447, + 0, 0, 17371, 17372, 3, 2078, 1039, 0, 17372, 17373, 5, 2448, 0, 0, 17373, + 17375, 1, 0, 0, 0, 17374, 17368, 1, 0, 0, 0, 17374, 17369, 1, 0, 0, 0, + 17375, 17377, 1, 0, 0, 0, 17376, 17378, 3, 2268, 1134, 0, 17377, 17376, + 1, 0, 0, 0, 17377, 17378, 1, 0, 0, 0, 17378, 1933, 1, 0, 0, 0, 17379, 17382, + 5, 620, 0, 0, 17380, 17383, 3, 2340, 1170, 0, 17381, 17383, 3, 2360, 1180, + 0, 17382, 17380, 1, 0, 0, 0, 17382, 17381, 1, 0, 0, 0, 17383, 1935, 1, + 0, 0, 0, 17384, 17385, 5, 738, 0, 0, 17385, 17403, 5, 2447, 0, 0, 17386, + 17404, 3, 1896, 948, 0, 17387, 17392, 5, 55, 0, 0, 17388, 17389, 5, 2453, + 0, 0, 17389, 17391, 5, 55, 0, 0, 17390, 17388, 1, 0, 0, 0, 17391, 17394, + 1, 0, 0, 0, 17392, 17390, 1, 0, 0, 0, 17392, 17393, 1, 0, 0, 0, 17393, + 17404, 1, 0, 0, 0, 17394, 17392, 1, 0, 0, 0, 17395, 17400, 3, 1938, 969, + 0, 17396, 17397, 5, 2453, 0, 0, 17397, 17399, 3, 1938, 969, 0, 17398, 17396, + 1, 0, 0, 0, 17399, 17402, 1, 0, 0, 0, 17400, 17398, 1, 0, 0, 0, 17400, + 17401, 1, 0, 0, 0, 17401, 17404, 1, 0, 0, 0, 17402, 17400, 1, 0, 0, 0, + 17403, 17386, 1, 0, 0, 0, 17403, 17387, 1, 0, 0, 0, 17403, 17395, 1, 0, + 0, 0, 17404, 17405, 1, 0, 0, 0, 17405, 17406, 5, 2448, 0, 0, 17406, 1937, + 1, 0, 0, 0, 17407, 17409, 3, 1940, 970, 0, 17408, 17410, 3, 2268, 1134, + 0, 17409, 17408, 1, 0, 0, 0, 17409, 17410, 1, 0, 0, 0, 17410, 1939, 1, + 0, 0, 0, 17411, 17418, 3, 2078, 1039, 0, 17412, 17414, 5, 2447, 0, 0, 17413, + 17415, 3, 2076, 1038, 0, 17414, 17413, 1, 0, 0, 0, 17414, 17415, 1, 0, + 0, 0, 17415, 17416, 1, 0, 0, 0, 17416, 17418, 5, 2448, 0, 0, 17417, 17411, + 1, 0, 0, 0, 17417, 17412, 1, 0, 0, 0, 17418, 1941, 1, 0, 0, 0, 17419, 17422, + 5, 2194, 0, 0, 17420, 17421, 7, 214, 0, 0, 17421, 17423, 5, 1229, 0, 0, + 17422, 17420, 1, 0, 0, 0, 17422, 17423, 1, 0, 0, 0, 17423, 17424, 1, 0, + 0, 0, 17424, 17427, 5, 2447, 0, 0, 17425, 17428, 3, 2340, 1170, 0, 17426, + 17428, 3, 2360, 1180, 0, 17427, 17425, 1, 0, 0, 0, 17427, 17426, 1, 0, + 0, 0, 17428, 17429, 1, 0, 0, 0, 17429, 17430, 3, 1934, 967, 0, 17430, 17431, + 3, 1944, 972, 0, 17431, 17433, 5, 2448, 0, 0, 17432, 17434, 3, 2270, 1135, + 0, 17433, 17432, 1, 0, 0, 0, 17433, 17434, 1, 0, 0, 0, 17434, 1943, 1, + 0, 0, 0, 17435, 17436, 5, 738, 0, 0, 17436, 17437, 5, 2447, 0, 0, 17437, + 17442, 3, 1946, 973, 0, 17438, 17439, 5, 2453, 0, 0, 17439, 17441, 3, 1946, + 973, 0, 17440, 17438, 1, 0, 0, 0, 17441, 17444, 1, 0, 0, 0, 17442, 17440, + 1, 0, 0, 0, 17442, 17443, 1, 0, 0, 0, 17443, 17445, 1, 0, 0, 0, 17444, + 17442, 1, 0, 0, 0, 17445, 17446, 5, 2448, 0, 0, 17446, 1945, 1, 0, 0, 0, + 17447, 17450, 3, 2340, 1170, 0, 17448, 17450, 3, 2360, 1180, 0, 17449, + 17447, 1, 0, 0, 0, 17449, 17448, 1, 0, 0, 0, 17450, 17466, 1, 0, 0, 0, + 17451, 17464, 5, 69, 0, 0, 17452, 17465, 3, 2394, 1197, 0, 17453, 17454, + 5, 2447, 0, 0, 17454, 17459, 3, 2394, 1197, 0, 17455, 17456, 5, 2453, 0, + 0, 17456, 17458, 3, 2394, 1197, 0, 17457, 17455, 1, 0, 0, 0, 17458, 17461, + 1, 0, 0, 0, 17459, 17457, 1, 0, 0, 0, 17459, 17460, 1, 0, 0, 0, 17460, + 17462, 1, 0, 0, 0, 17461, 17459, 1, 0, 0, 0, 17462, 17463, 5, 2448, 0, + 0, 17463, 17465, 1, 0, 0, 0, 17464, 17452, 1, 0, 0, 0, 17464, 17453, 1, + 0, 0, 0, 17465, 17467, 1, 0, 0, 0, 17466, 17451, 1, 0, 0, 0, 17466, 17467, + 1, 0, 0, 0, 17467, 1947, 1, 0, 0, 0, 17468, 17469, 5, 280, 0, 0, 17469, + 17471, 5, 160, 0, 0, 17470, 17472, 5, 1084, 0, 0, 17471, 17470, 1, 0, 0, + 0, 17471, 17472, 1, 0, 0, 0, 17472, 17473, 1, 0, 0, 0, 17473, 17475, 3, + 2074, 1037, 0, 17474, 17476, 3, 1950, 975, 0, 17475, 17474, 1, 0, 0, 0, + 17475, 17476, 1, 0, 0, 0, 17476, 17486, 1, 0, 0, 0, 17477, 17478, 3, 1950, + 975, 0, 17478, 17479, 5, 280, 0, 0, 17479, 17481, 5, 160, 0, 0, 17480, + 17482, 5, 1084, 0, 0, 17481, 17480, 1, 0, 0, 0, 17481, 17482, 1, 0, 0, + 0, 17482, 17483, 1, 0, 0, 0, 17483, 17484, 3, 2074, 1037, 0, 17484, 17486, + 1, 0, 0, 0, 17485, 17468, 1, 0, 0, 0, 17485, 17477, 1, 0, 0, 0, 17486, + 1949, 1, 0, 0, 0, 17487, 17488, 5, 1737, 0, 0, 17488, 17489, 5, 2308, 0, + 0, 17489, 17490, 3, 2074, 1037, 0, 17490, 1951, 1, 0, 0, 0, 17491, 17492, + 5, 649, 0, 0, 17492, 17493, 5, 160, 0, 0, 17493, 17498, 3, 1954, 977, 0, + 17494, 17495, 5, 2453, 0, 0, 17495, 17497, 3, 1954, 977, 0, 17496, 17494, + 1, 0, 0, 0, 17497, 17500, 1, 0, 0, 0, 17498, 17496, 1, 0, 0, 0, 17498, + 17499, 1, 0, 0, 0, 17499, 17502, 1, 0, 0, 0, 17500, 17498, 1, 0, 0, 0, + 17501, 17503, 3, 1962, 981, 0, 17502, 17501, 1, 0, 0, 0, 17502, 17503, + 1, 0, 0, 0, 17503, 17518, 1, 0, 0, 0, 17504, 17515, 3, 1962, 981, 0, 17505, + 17506, 5, 649, 0, 0, 17506, 17507, 5, 160, 0, 0, 17507, 17512, 3, 1954, + 977, 0, 17508, 17509, 5, 2453, 0, 0, 17509, 17511, 3, 1954, 977, 0, 17510, + 17508, 1, 0, 0, 0, 17511, 17514, 1, 0, 0, 0, 17512, 17510, 1, 0, 0, 0, + 17512, 17513, 1, 0, 0, 0, 17513, 17516, 1, 0, 0, 0, 17514, 17512, 1, 0, + 0, 0, 17515, 17505, 1, 0, 0, 0, 17515, 17516, 1, 0, 0, 0, 17516, 17518, + 1, 0, 0, 0, 17517, 17491, 1, 0, 0, 0, 17517, 17504, 1, 0, 0, 0, 17518, + 1953, 1, 0, 0, 0, 17519, 17523, 3, 1958, 979, 0, 17520, 17523, 3, 1956, + 978, 0, 17521, 17523, 3, 2078, 1039, 0, 17522, 17519, 1, 0, 0, 0, 17522, + 17520, 1, 0, 0, 0, 17522, 17521, 1, 0, 0, 0, 17523, 1955, 1, 0, 0, 0, 17524, + 17525, 7, 215, 0, 0, 17525, 17526, 5, 2447, 0, 0, 17526, 17531, 3, 1960, + 980, 0, 17527, 17528, 5, 2453, 0, 0, 17528, 17530, 3, 1960, 980, 0, 17529, + 17527, 1, 0, 0, 0, 17530, 17533, 1, 0, 0, 0, 17531, 17529, 1, 0, 0, 0, + 17531, 17532, 1, 0, 0, 0, 17532, 17534, 1, 0, 0, 0, 17533, 17531, 1, 0, + 0, 0, 17534, 17535, 5, 2448, 0, 0, 17535, 1957, 1, 0, 0, 0, 17536, 17537, + 5, 651, 0, 0, 17537, 17538, 5, 1672, 0, 0, 17538, 17539, 5, 2447, 0, 0, + 17539, 17544, 3, 1960, 980, 0, 17540, 17541, 5, 2453, 0, 0, 17541, 17543, + 3, 1960, 980, 0, 17542, 17540, 1, 0, 0, 0, 17543, 17546, 1, 0, 0, 0, 17544, + 17542, 1, 0, 0, 0, 17544, 17545, 1, 0, 0, 0, 17545, 17547, 1, 0, 0, 0, + 17546, 17544, 1, 0, 0, 0, 17547, 17548, 5, 2448, 0, 0, 17548, 1959, 1, + 0, 0, 0, 17549, 17557, 3, 1956, 978, 0, 17550, 17552, 5, 2447, 0, 0, 17551, + 17553, 3, 2076, 1038, 0, 17552, 17551, 1, 0, 0, 0, 17552, 17553, 1, 0, + 0, 0, 17553, 17554, 1, 0, 0, 0, 17554, 17557, 5, 2448, 0, 0, 17555, 17557, + 3, 2078, 1039, 0, 17556, 17549, 1, 0, 0, 0, 17556, 17550, 1, 0, 0, 0, 17556, + 17555, 1, 0, 0, 0, 17557, 1961, 1, 0, 0, 0, 17558, 17559, 5, 663, 0, 0, + 17559, 17560, 3, 2074, 1037, 0, 17560, 1963, 1, 0, 0, 0, 17561, 17565, + 5, 971, 0, 0, 17562, 17564, 3, 1966, 983, 0, 17563, 17562, 1, 0, 0, 0, + 17564, 17567, 1, 0, 0, 0, 17565, 17563, 1, 0, 0, 0, 17565, 17566, 1, 0, + 0, 0, 17566, 17569, 1, 0, 0, 0, 17567, 17565, 1, 0, 0, 0, 17568, 17570, + 3, 1968, 984, 0, 17569, 17568, 1, 0, 0, 0, 17569, 17570, 1, 0, 0, 0, 17570, + 17574, 1, 0, 0, 0, 17571, 17573, 3, 1970, 985, 0, 17572, 17571, 1, 0, 0, + 0, 17573, 17576, 1, 0, 0, 0, 17574, 17572, 1, 0, 0, 0, 17574, 17575, 1, + 0, 0, 0, 17575, 17577, 1, 0, 0, 0, 17576, 17574, 1, 0, 0, 0, 17577, 17578, + 3, 1972, 986, 0, 17578, 1965, 1, 0, 0, 0, 17579, 17580, 7, 216, 0, 0, 17580, + 17588, 5, 1006, 0, 0, 17581, 17585, 5, 2183, 0, 0, 17582, 17586, 5, 422, + 0, 0, 17583, 17584, 5, 1695, 0, 0, 17584, 17586, 5, 1527, 0, 0, 17585, + 17582, 1, 0, 0, 0, 17585, 17583, 1, 0, 0, 0, 17586, 17588, 1, 0, 0, 0, + 17587, 17579, 1, 0, 0, 0, 17587, 17581, 1, 0, 0, 0, 17588, 1967, 1, 0, + 0, 0, 17589, 17590, 5, 1586, 0, 0, 17590, 17591, 7, 217, 0, 0, 17591, 17592, + 5, 1607, 0, 0, 17592, 1969, 1, 0, 0, 0, 17593, 17594, 5, 1527, 0, 0, 17594, + 17595, 3, 2296, 1148, 0, 17595, 17596, 5, 1259, 0, 0, 17596, 17597, 5, + 2447, 0, 0, 17597, 17598, 3, 1896, 948, 0, 17598, 17599, 5, 2448, 0, 0, + 17599, 17603, 3, 1974, 987, 0, 17600, 17602, 3, 1966, 983, 0, 17601, 17600, + 1, 0, 0, 0, 17602, 17605, 1, 0, 0, 0, 17603, 17601, 1, 0, 0, 0, 17603, + 17604, 1, 0, 0, 0, 17604, 1971, 1, 0, 0, 0, 17605, 17603, 1, 0, 0, 0, 17606, + 17607, 5, 902, 0, 0, 17607, 17609, 3, 2298, 1149, 0, 17608, 17606, 1, 0, + 0, 0, 17608, 17609, 1, 0, 0, 0, 17609, 17610, 1, 0, 0, 0, 17610, 17614, + 3, 1974, 987, 0, 17611, 17613, 3, 1966, 983, 0, 17612, 17611, 1, 0, 0, + 0, 17613, 17616, 1, 0, 0, 0, 17614, 17612, 1, 0, 0, 0, 17614, 17615, 1, + 0, 0, 0, 17615, 17617, 1, 0, 0, 0, 17616, 17614, 1, 0, 0, 0, 17617, 17618, + 3, 1982, 991, 0, 17618, 1973, 1, 0, 0, 0, 17619, 17621, 3, 1976, 988, 0, + 17620, 17619, 1, 0, 0, 0, 17620, 17621, 1, 0, 0, 0, 17621, 17622, 1, 0, + 0, 0, 17622, 17623, 5, 422, 0, 0, 17623, 17624, 5, 160, 0, 0, 17624, 17625, + 3, 1978, 989, 0, 17625, 17626, 5, 934, 0, 0, 17626, 17627, 3, 1978, 989, + 0, 17627, 1975, 1, 0, 0, 0, 17628, 17629, 5, 1348, 0, 0, 17629, 17630, + 5, 160, 0, 0, 17630, 17631, 3, 1978, 989, 0, 17631, 1977, 1, 0, 0, 0, 17632, + 17633, 5, 2447, 0, 0, 17633, 17638, 3, 1980, 990, 0, 17634, 17635, 5, 2453, + 0, 0, 17635, 17637, 3, 1980, 990, 0, 17636, 17634, 1, 0, 0, 0, 17637, 17640, + 1, 0, 0, 0, 17638, 17636, 1, 0, 0, 0, 17638, 17639, 1, 0, 0, 0, 17639, + 17641, 1, 0, 0, 0, 17640, 17638, 1, 0, 0, 0, 17641, 17642, 5, 2448, 0, + 0, 17642, 1979, 1, 0, 0, 0, 17643, 17646, 3, 2078, 1039, 0, 17644, 17646, + 3, 1902, 951, 0, 17645, 17643, 1, 0, 0, 0, 17645, 17644, 1, 0, 0, 0, 17646, + 17648, 1, 0, 0, 0, 17647, 17649, 3, 2268, 1134, 0, 17648, 17647, 1, 0, + 0, 0, 17648, 17649, 1, 0, 0, 0, 17649, 1981, 1, 0, 0, 0, 17650, 17652, + 3, 1984, 992, 0, 17651, 17650, 1, 0, 0, 0, 17651, 17652, 1, 0, 0, 0, 17652, + 17653, 1, 0, 0, 0, 17653, 17662, 5, 2447, 0, 0, 17654, 17659, 3, 1986, + 993, 0, 17655, 17656, 5, 2453, 0, 0, 17656, 17658, 3, 1986, 993, 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, 17654, 1, 0, 0, 0, 17662, 17663, 1, 0, 0, 0, 17663, 17664, + 1, 0, 0, 0, 17664, 17665, 5, 2448, 0, 0, 17665, 1983, 1, 0, 0, 0, 17666, + 17672, 5, 1611, 0, 0, 17667, 17673, 5, 2207, 0, 0, 17668, 17670, 5, 2213, + 0, 0, 17669, 17671, 5, 38, 0, 0, 17670, 17669, 1, 0, 0, 0, 17670, 17671, + 1, 0, 0, 0, 17671, 17673, 1, 0, 0, 0, 17672, 17667, 1, 0, 0, 0, 17672, + 17668, 1, 0, 0, 0, 17672, 17673, 1, 0, 0, 0, 17673, 17676, 1, 0, 0, 0, + 17674, 17675, 7, 218, 0, 0, 17675, 17677, 5, 1303, 0, 0, 17676, 17674, + 1, 0, 0, 0, 17676, 17677, 1, 0, 0, 0, 17677, 17679, 1, 0, 0, 0, 17678, + 17680, 3, 1990, 995, 0, 17679, 17678, 1, 0, 0, 0, 17679, 17680, 1, 0, 0, + 0, 17680, 1985, 1, 0, 0, 0, 17681, 17687, 5, 2207, 0, 0, 17682, 17684, + 5, 2213, 0, 0, 17683, 17685, 5, 38, 0, 0, 17684, 17683, 1, 0, 0, 0, 17684, + 17685, 1, 0, 0, 0, 17685, 17687, 1, 0, 0, 0, 17686, 17681, 1, 0, 0, 0, + 17686, 17682, 1, 0, 0, 0, 17686, 17687, 1, 0, 0, 0, 17687, 17688, 1, 0, + 0, 0, 17688, 17690, 3, 1988, 994, 0, 17689, 17691, 3, 1994, 997, 0, 17690, + 17689, 1, 0, 0, 0, 17690, 17691, 1, 0, 0, 0, 17691, 17692, 1, 0, 0, 0, + 17692, 17693, 5, 2472, 0, 0, 17693, 17694, 3, 2078, 1039, 0, 17694, 1987, + 1, 0, 0, 0, 17695, 17696, 3, 2106, 1053, 0, 17696, 1989, 1, 0, 0, 0, 17697, + 17698, 5, 790, 0, 0, 17698, 17699, 5, 2447, 0, 0, 17699, 17700, 3, 2078, + 1039, 0, 17700, 17702, 5, 2448, 0, 0, 17701, 17703, 3, 1992, 996, 0, 17702, + 17701, 1, 0, 0, 0, 17702, 17703, 1, 0, 0, 0, 17703, 1991, 1, 0, 0, 0, 17704, + 17705, 5, 2202, 0, 0, 17705, 17706, 5, 2447, 0, 0, 17706, 17707, 3, 2074, + 1037, 0, 17707, 17708, 5, 2448, 0, 0, 17708, 1993, 1, 0, 0, 0, 17709, 17711, + 5, 1303, 0, 0, 17710, 17712, 5, 1686, 0, 0, 17711, 17710, 1, 0, 0, 0, 17711, + 17712, 1, 0, 0, 0, 17712, 17713, 1, 0, 0, 0, 17713, 17714, 5, 160, 0, 0, + 17714, 17719, 3, 1996, 998, 0, 17715, 17716, 5, 2453, 0, 0, 17716, 17718, + 3, 1996, 998, 0, 17717, 17715, 1, 0, 0, 0, 17718, 17721, 1, 0, 0, 0, 17719, + 17717, 1, 0, 0, 0, 17719, 17720, 1, 0, 0, 0, 17720, 1995, 1, 0, 0, 0, 17721, + 17719, 1, 0, 0, 0, 17722, 17724, 3, 2078, 1039, 0, 17723, 17725, 7, 55, + 0, 0, 17724, 17723, 1, 0, 0, 0, 17724, 17725, 1, 0, 0, 0, 17725, 17728, + 1, 0, 0, 0, 17726, 17727, 5, 1229, 0, 0, 17727, 17729, 7, 56, 0, 0, 17728, + 17726, 1, 0, 0, 0, 17728, 17729, 1, 0, 0, 0, 17729, 1997, 1, 0, 0, 0, 17730, + 17731, 5, 1245, 0, 0, 17731, 17732, 3, 2078, 1039, 0, 17732, 17733, 7, + 219, 0, 0, 17733, 1999, 1, 0, 0, 0, 17734, 17735, 5, 586, 0, 0, 17735, + 17740, 7, 220, 0, 0, 17736, 17738, 3, 2078, 1039, 0, 17737, 17739, 5, 1378, + 0, 0, 17738, 17737, 1, 0, 0, 0, 17738, 17739, 1, 0, 0, 0, 17739, 17741, + 1, 0, 0, 0, 17740, 17736, 1, 0, 0, 0, 17740, 17741, 1, 0, 0, 0, 17741, + 17742, 1, 0, 0, 0, 17742, 17746, 7, 219, 0, 0, 17743, 17747, 5, 1258, 0, + 0, 17744, 17745, 5, 2308, 0, 0, 17745, 17747, 5, 2105, 0, 0, 17746, 17743, + 1, 0, 0, 0, 17746, 17744, 1, 0, 0, 0, 17747, 2001, 1, 0, 0, 0, 17748, 17749, + 5, 620, 0, 0, 17749, 17751, 5, 2207, 0, 0, 17750, 17752, 3, 2004, 1002, + 0, 17751, 17750, 1, 0, 0, 0, 17751, 17752, 1, 0, 0, 0, 17752, 17754, 1, + 0, 0, 0, 17753, 17755, 3, 2006, 1003, 0, 17754, 17753, 1, 0, 0, 0, 17754, + 17755, 1, 0, 0, 0, 17755, 2003, 1, 0, 0, 0, 17756, 17757, 5, 1246, 0, 0, + 17757, 17758, 3, 2358, 1179, 0, 17758, 2005, 1, 0, 0, 0, 17759, 17760, + 5, 1702, 0, 0, 17760, 17765, 5, 879, 0, 0, 17761, 17765, 5, 1219, 0, 0, + 17762, 17763, 5, 2293, 0, 0, 17763, 17765, 3, 2078, 1039, 0, 17764, 17759, + 1, 0, 0, 0, 17764, 17761, 1, 0, 0, 0, 17764, 17762, 1, 0, 0, 0, 17765, + 2007, 1, 0, 0, 0, 17766, 17767, 5, 2207, 0, 0, 17767, 17768, 3, 2054, 1027, + 0, 17768, 17770, 3, 2010, 1005, 0, 17769, 17771, 3, 2272, 1136, 0, 17770, + 17769, 1, 0, 0, 0, 17770, 17771, 1, 0, 0, 0, 17771, 17773, 1, 0, 0, 0, + 17772, 17774, 3, 2056, 1028, 0, 17773, 17772, 1, 0, 0, 0, 17773, 17774, + 1, 0, 0, 0, 17774, 17776, 1, 0, 0, 0, 17775, 17777, 3, 2058, 1029, 0, 17776, + 17775, 1, 0, 0, 0, 17776, 17777, 1, 0, 0, 0, 17777, 2009, 1, 0, 0, 0, 17778, + 17794, 5, 1671, 0, 0, 17779, 17784, 3, 2012, 1006, 0, 17780, 17781, 5, + 2453, 0, 0, 17781, 17783, 3, 2012, 1006, 0, 17782, 17780, 1, 0, 0, 0, 17783, + 17786, 1, 0, 0, 0, 17784, 17782, 1, 0, 0, 0, 17784, 17785, 1, 0, 0, 0, + 17785, 17795, 1, 0, 0, 0, 17786, 17784, 1, 0, 0, 0, 17787, 17788, 5, 2258, + 0, 0, 17788, 17789, 5, 2447, 0, 0, 17789, 17790, 3, 2402, 1201, 0, 17790, + 17791, 5, 2448, 0, 0, 17791, 17792, 5, 2472, 0, 0, 17792, 17793, 3, 2078, + 1039, 0, 17793, 17795, 1, 0, 0, 0, 17794, 17779, 1, 0, 0, 0, 17794, 17787, + 1, 0, 0, 0, 17795, 2011, 1, 0, 0, 0, 17796, 17797, 3, 2340, 1170, 0, 17797, + 17798, 5, 2472, 0, 0, 17798, 17799, 3, 2078, 1039, 0, 17799, 17805, 1, + 0, 0, 0, 17800, 17801, 3, 2360, 1180, 0, 17801, 17802, 5, 2472, 0, 0, 17802, + 17803, 3, 1896, 948, 0, 17803, 17805, 1, 0, 0, 0, 17804, 17796, 1, 0, 0, + 0, 17804, 17800, 1, 0, 0, 0, 17805, 2013, 1, 0, 0, 0, 17806, 17808, 5, + 403, 0, 0, 17807, 17809, 5, 628, 0, 0, 17808, 17807, 1, 0, 0, 0, 17808, + 17809, 1, 0, 0, 0, 17809, 17810, 1, 0, 0, 0, 17810, 17812, 3, 2054, 1027, + 0, 17811, 17813, 3, 2272, 1136, 0, 17812, 17811, 1, 0, 0, 0, 17812, 17813, + 1, 0, 0, 0, 17813, 17815, 1, 0, 0, 0, 17814, 17816, 3, 2056, 1028, 0, 17815, + 17814, 1, 0, 0, 0, 17815, 17816, 1, 0, 0, 0, 17816, 17818, 1, 0, 0, 0, + 17817, 17819, 3, 2058, 1029, 0, 17818, 17817, 1, 0, 0, 0, 17818, 17819, + 1, 0, 0, 0, 17819, 2015, 1, 0, 0, 0, 17820, 17823, 5, 756, 0, 0, 17821, + 17824, 3, 2018, 1009, 0, 17822, 17824, 3, 2020, 1010, 0, 17823, 17821, + 1, 0, 0, 0, 17823, 17822, 1, 0, 0, 0, 17824, 2017, 1, 0, 0, 0, 17825, 17831, + 3, 2030, 1015, 0, 17826, 17828, 3, 2032, 1016, 0, 17827, 17829, 3, 2056, + 1028, 0, 17828, 17827, 1, 0, 0, 0, 17828, 17829, 1, 0, 0, 0, 17829, 17832, + 1, 0, 0, 0, 17830, 17832, 3, 1870, 935, 0, 17831, 17826, 1, 0, 0, 0, 17831, + 17830, 1, 0, 0, 0, 17832, 17834, 1, 0, 0, 0, 17833, 17835, 3, 2058, 1029, + 0, 17834, 17833, 1, 0, 0, 0, 17834, 17835, 1, 0, 0, 0, 17835, 2019, 1, + 0, 0, 0, 17836, 17838, 5, 38, 0, 0, 17837, 17839, 3, 2022, 1011, 0, 17838, + 17837, 1, 0, 0, 0, 17839, 17840, 1, 0, 0, 0, 17840, 17838, 1, 0, 0, 0, + 17840, 17841, 1, 0, 0, 0, 17841, 17844, 1, 0, 0, 0, 17842, 17844, 3, 2024, + 1012, 0, 17843, 17836, 1, 0, 0, 0, 17843, 17842, 1, 0, 0, 0, 17844, 17845, + 1, 0, 0, 0, 17845, 17846, 3, 1870, 935, 0, 17846, 2021, 1, 0, 0, 0, 17847, + 17849, 3, 2030, 1015, 0, 17848, 17850, 3, 2032, 1016, 0, 17849, 17848, + 1, 0, 0, 0, 17849, 17850, 1, 0, 0, 0, 17850, 17852, 1, 0, 0, 0, 17851, + 17853, 3, 2058, 1029, 0, 17852, 17851, 1, 0, 0, 0, 17852, 17853, 1, 0, + 0, 0, 17853, 2023, 1, 0, 0, 0, 17854, 17856, 7, 221, 0, 0, 17855, 17854, + 1, 0, 0, 0, 17855, 17856, 1, 0, 0, 0, 17856, 17858, 1, 0, 0, 0, 17857, + 17859, 3, 2026, 1013, 0, 17858, 17857, 1, 0, 0, 0, 17859, 17860, 1, 0, + 0, 0, 17860, 17858, 1, 0, 0, 0, 17860, 17861, 1, 0, 0, 0, 17861, 17863, + 1, 0, 0, 0, 17862, 17864, 3, 2028, 1014, 0, 17863, 17862, 1, 0, 0, 0, 17863, + 17864, 1, 0, 0, 0, 17864, 2025, 1, 0, 0, 0, 17865, 17866, 5, 2300, 0, 0, + 17866, 17867, 3, 2074, 1037, 0, 17867, 17869, 5, 2099, 0, 0, 17868, 17870, + 3, 2022, 1011, 0, 17869, 17868, 1, 0, 0, 0, 17870, 17871, 1, 0, 0, 0, 17871, + 17869, 1, 0, 0, 0, 17871, 17872, 1, 0, 0, 0, 17872, 2027, 1, 0, 0, 0, 17873, + 17875, 5, 491, 0, 0, 17874, 17876, 3, 2022, 1011, 0, 17875, 17874, 1, 0, + 0, 0, 17876, 17877, 1, 0, 0, 0, 17877, 17875, 1, 0, 0, 0, 17877, 17878, + 1, 0, 0, 0, 17878, 2029, 1, 0, 0, 0, 17879, 17880, 5, 779, 0, 0, 17880, + 17882, 3, 2054, 1027, 0, 17881, 17883, 5, 588, 0, 0, 17882, 17881, 1, 0, + 0, 0, 17882, 17883, 1, 0, 0, 0, 17883, 17885, 1, 0, 0, 0, 17884, 17886, + 3, 2360, 1180, 0, 17885, 17884, 1, 0, 0, 0, 17885, 17886, 1, 0, 0, 0, 17886, + 2031, 1, 0, 0, 0, 17887, 17894, 5, 2257, 0, 0, 17888, 17895, 5, 2480, 0, + 0, 17889, 17890, 5, 2447, 0, 0, 17890, 17891, 3, 2076, 1038, 0, 17891, + 17892, 5, 2448, 0, 0, 17892, 17895, 1, 0, 0, 0, 17893, 17895, 3, 2120, + 1060, 0, 17894, 17888, 1, 0, 0, 0, 17894, 17889, 1, 0, 0, 0, 17894, 17893, + 1, 0, 0, 0, 17895, 2033, 1, 0, 0, 0, 17896, 17897, 5, 946, 0, 0, 17897, + 17898, 5, 779, 0, 0, 17898, 17899, 3, 2044, 1022, 0, 17899, 17900, 5, 2246, + 0, 0, 17900, 17901, 3, 2044, 1022, 0, 17901, 17902, 5, 1259, 0, 0, 17902, + 17903, 5, 2447, 0, 0, 17903, 17904, 3, 2074, 1037, 0, 17904, 17913, 5, + 2448, 0, 0, 17905, 17907, 3, 2036, 1018, 0, 17906, 17908, 3, 2042, 1021, + 0, 17907, 17906, 1, 0, 0, 0, 17907, 17908, 1, 0, 0, 0, 17908, 17914, 1, + 0, 0, 0, 17909, 17911, 3, 2042, 1021, 0, 17910, 17912, 3, 2036, 1018, 0, + 17911, 17910, 1, 0, 0, 0, 17911, 17912, 1, 0, 0, 0, 17912, 17914, 1, 0, + 0, 0, 17913, 17905, 1, 0, 0, 0, 17913, 17909, 1, 0, 0, 0, 17914, 17916, + 1, 0, 0, 0, 17915, 17917, 3, 2058, 1029, 0, 17916, 17915, 1, 0, 0, 0, 17916, + 17917, 1, 0, 0, 0, 17917, 17919, 1, 0, 0, 0, 17918, 17920, 3, 2056, 1028, + 0, 17919, 17918, 1, 0, 0, 0, 17919, 17920, 1, 0, 0, 0, 17920, 2035, 1, + 0, 0, 0, 17921, 17922, 5, 2300, 0, 0, 17922, 17923, 5, 914, 0, 0, 17923, + 17924, 5, 2099, 0, 0, 17924, 17925, 5, 2207, 0, 0, 17925, 17926, 5, 1671, + 0, 0, 17926, 17931, 3, 2038, 1019, 0, 17927, 17928, 5, 2453, 0, 0, 17928, + 17930, 3, 2038, 1019, 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, 17935, + 1, 0, 0, 0, 17933, 17931, 1, 0, 0, 0, 17934, 17936, 3, 2272, 1136, 0, 17935, + 17934, 1, 0, 0, 0, 17935, 17936, 1, 0, 0, 0, 17936, 17938, 1, 0, 0, 0, + 17937, 17939, 3, 2040, 1020, 0, 17938, 17937, 1, 0, 0, 0, 17938, 17939, + 1, 0, 0, 0, 17939, 2037, 1, 0, 0, 0, 17940, 17941, 3, 2340, 1170, 0, 17941, + 17942, 5, 2472, 0, 0, 17942, 17943, 3, 2078, 1039, 0, 17943, 2039, 1, 0, + 0, 0, 17944, 17945, 5, 403, 0, 0, 17945, 17946, 3, 2272, 1136, 0, 17946, + 2041, 1, 0, 0, 0, 17947, 17948, 5, 2300, 0, 0, 17948, 17949, 5, 1204, 0, + 0, 17949, 17950, 5, 914, 0, 0, 17950, 17951, 5, 2099, 0, 0, 17951, 17953, + 5, 756, 0, 0, 17952, 17954, 3, 2360, 1180, 0, 17953, 17952, 1, 0, 0, 0, + 17953, 17954, 1, 0, 0, 0, 17954, 17955, 1, 0, 0, 0, 17955, 17957, 3, 2032, + 1016, 0, 17956, 17958, 3, 2272, 1136, 0, 17957, 17956, 1, 0, 0, 0, 17957, + 17958, 1, 0, 0, 0, 17958, 2043, 1, 0, 0, 0, 17959, 17970, 3, 2342, 1171, + 0, 17960, 17961, 5, 2447, 0, 0, 17961, 17962, 3, 1870, 935, 0, 17962, 17963, + 5, 2448, 0, 0, 17963, 17970, 1, 0, 0, 0, 17964, 17970, 3, 2066, 1033, 0, + 17965, 17966, 5, 2447, 0, 0, 17966, 17967, 3, 2066, 1033, 0, 17967, 17968, + 5, 2448, 0, 0, 17968, 17970, 1, 0, 0, 0, 17969, 17959, 1, 0, 0, 0, 17969, + 17960, 1, 0, 0, 0, 17969, 17964, 1, 0, 0, 0, 17969, 17965, 1, 0, 0, 0, + 17970, 17972, 1, 0, 0, 0, 17971, 17973, 3, 2270, 1135, 0, 17972, 17971, + 1, 0, 0, 0, 17972, 17973, 1, 0, 0, 0, 17973, 2045, 1, 0, 0, 0, 17974, 17975, + 5, 881, 0, 0, 17975, 17976, 5, 2083, 0, 0, 17976, 17981, 3, 2050, 1025, + 0, 17977, 17978, 5, 2453, 0, 0, 17978, 17980, 3, 2050, 1025, 0, 17979, + 17977, 1, 0, 0, 0, 17980, 17983, 1, 0, 0, 0, 17981, 17979, 1, 0, 0, 0, + 17981, 17982, 1, 0, 0, 0, 17982, 17984, 1, 0, 0, 0, 17983, 17981, 1, 0, + 0, 0, 17984, 17985, 5, 738, 0, 0, 17985, 17986, 3, 2052, 1026, 0, 17986, + 17988, 5, 977, 0, 0, 17987, 17989, 3, 2048, 1024, 0, 17988, 17987, 1, 0, + 0, 0, 17988, 17989, 1, 0, 0, 0, 17989, 2047, 1, 0, 0, 0, 17990, 17991, + 5, 2293, 0, 0, 17991, 17994, 3, 2078, 1039, 0, 17992, 17994, 5, 1219, 0, + 0, 17993, 17990, 1, 0, 0, 0, 17993, 17992, 1, 0, 0, 0, 17994, 2049, 1, + 0, 0, 0, 17995, 17997, 3, 2342, 1171, 0, 17996, 17998, 3, 2266, 1133, 0, + 17997, 17996, 1, 0, 0, 0, 17997, 17998, 1, 0, 0, 0, 17998, 2051, 1, 0, + 0, 0, 17999, 18000, 5, 1606, 0, 0, 18000, 18012, 5, 1680, 0, 0, 18001, + 18002, 5, 1606, 0, 0, 18002, 18012, 5, 541, 0, 0, 18003, 18005, 5, 1680, + 0, 0, 18004, 18006, 5, 2207, 0, 0, 18005, 18004, 1, 0, 0, 0, 18005, 18006, + 1, 0, 0, 0, 18006, 18012, 1, 0, 0, 0, 18007, 18008, 5, 1680, 0, 0, 18008, + 18009, 5, 1606, 0, 0, 18009, 18012, 5, 541, 0, 0, 18010, 18012, 5, 541, + 0, 0, 18011, 17999, 1, 0, 0, 0, 18011, 18001, 1, 0, 0, 0, 18011, 18003, + 1, 0, 0, 0, 18011, 18007, 1, 0, 0, 0, 18011, 18010, 1, 0, 0, 0, 18012, + 2053, 1, 0, 0, 0, 18013, 18020, 3, 2064, 1032, 0, 18014, 18015, 5, 1258, + 0, 0, 18015, 18016, 5, 2447, 0, 0, 18016, 18017, 3, 2064, 1032, 0, 18017, + 18018, 5, 2448, 0, 0, 18018, 18020, 1, 0, 0, 0, 18019, 18013, 1, 0, 0, + 0, 18019, 18014, 1, 0, 0, 0, 18020, 18022, 1, 0, 0, 0, 18021, 18023, 3, + 2270, 1135, 0, 18022, 18021, 1, 0, 0, 0, 18022, 18023, 1, 0, 0, 0, 18023, + 2055, 1, 0, 0, 0, 18024, 18025, 7, 205, 0, 0, 18025, 18026, 3, 2076, 1038, + 0, 18026, 18027, 3, 2274, 1137, 0, 18027, 2057, 1, 0, 0, 0, 18028, 18029, + 5, 888, 0, 0, 18029, 18031, 5, 522, 0, 0, 18030, 18032, 3, 2060, 1030, + 0, 18031, 18030, 1, 0, 0, 0, 18031, 18032, 1, 0, 0, 0, 18032, 18034, 1, + 0, 0, 0, 18033, 18035, 3, 2078, 1039, 0, 18034, 18033, 1, 0, 0, 0, 18034, + 18035, 1, 0, 0, 0, 18035, 18037, 1, 0, 0, 0, 18036, 18038, 3, 2062, 1031, + 0, 18037, 18036, 1, 0, 0, 0, 18037, 18038, 1, 0, 0, 0, 18038, 2059, 1, + 0, 0, 0, 18039, 18040, 5, 779, 0, 0, 18040, 18041, 3, 2342, 1171, 0, 18041, + 2061, 1, 0, 0, 0, 18042, 18043, 5, 1549, 0, 0, 18043, 18046, 5, 858, 0, + 0, 18044, 18047, 5, 2185, 0, 0, 18045, 18047, 3, 2078, 1039, 0, 18046, + 18044, 1, 0, 0, 0, 18046, 18045, 1, 0, 0, 0, 18047, 2063, 1, 0, 0, 0, 18048, + 18085, 3, 2066, 1033, 0, 18049, 18050, 5, 2447, 0, 0, 18050, 18052, 3, + 1870, 935, 0, 18051, 18053, 3, 2068, 1034, 0, 18052, 18051, 1, 0, 0, 0, + 18052, 18053, 1, 0, 0, 0, 18053, 18054, 1, 0, 0, 0, 18054, 18055, 5, 2448, + 0, 0, 18055, 18085, 1, 0, 0, 0, 18056, 18058, 3, 2342, 1171, 0, 18057, + 18059, 3, 1886, 943, 0, 18058, 18057, 1, 0, 0, 0, 18058, 18059, 1, 0, 0, + 0, 18059, 18061, 1, 0, 0, 0, 18060, 18062, 3, 2070, 1035, 0, 18061, 18060, + 1, 0, 0, 0, 18061, 18062, 1, 0, 0, 0, 18062, 18085, 1, 0, 0, 0, 18063, + 18066, 3, 2156, 1078, 0, 18064, 18065, 5, 69, 0, 0, 18065, 18067, 3, 2402, + 1201, 0, 18066, 18064, 1, 0, 0, 0, 18066, 18067, 1, 0, 0, 0, 18067, 18085, + 1, 0, 0, 0, 18068, 18069, 5, 827, 0, 0, 18069, 18070, 5, 2447, 0, 0, 18070, + 18072, 3, 1896, 948, 0, 18071, 18073, 3, 2068, 1034, 0, 18072, 18071, 1, + 0, 0, 0, 18072, 18073, 1, 0, 0, 0, 18073, 18074, 1, 0, 0, 0, 18074, 18075, + 5, 2448, 0, 0, 18075, 18085, 1, 0, 0, 0, 18076, 18077, 4, 1032, 12, 0, + 18077, 18078, 5, 1551, 0, 0, 18078, 18079, 5, 2447, 0, 0, 18079, 18080, + 3, 2342, 1171, 0, 18080, 18081, 5, 1204, 0, 0, 18081, 18082, 5, 2351, 0, + 0, 18082, 18083, 5, 2448, 0, 0, 18083, 18085, 1, 0, 0, 0, 18084, 18048, + 1, 0, 0, 0, 18084, 18049, 1, 0, 0, 0, 18084, 18056, 1, 0, 0, 0, 18084, + 18063, 1, 0, 0, 0, 18084, 18068, 1, 0, 0, 0, 18084, 18076, 1, 0, 0, 0, + 18085, 2065, 1, 0, 0, 0, 18086, 18097, 7, 222, 0, 0, 18087, 18088, 5, 2447, + 0, 0, 18088, 18089, 3, 1896, 948, 0, 18089, 18090, 5, 2448, 0, 0, 18090, + 18098, 1, 0, 0, 0, 18091, 18092, 5, 2447, 0, 0, 18092, 18093, 3, 2078, + 1039, 0, 18093, 18095, 5, 2448, 0, 0, 18094, 18096, 3, 2408, 1204, 0, 18095, + 18094, 1, 0, 0, 0, 18095, 18096, 1, 0, 0, 0, 18096, 18098, 1, 0, 0, 0, + 18097, 18087, 1, 0, 0, 0, 18097, 18091, 1, 0, 0, 0, 18098, 2067, 1, 0, + 0, 0, 18099, 18108, 5, 2308, 0, 0, 18100, 18101, 5, 1505, 0, 0, 18101, + 18109, 5, 1258, 0, 0, 18102, 18103, 5, 200, 0, 0, 18103, 18106, 5, 1272, + 0, 0, 18104, 18105, 5, 286, 0, 0, 18105, 18107, 3, 2310, 1155, 0, 18106, + 18104, 1, 0, 0, 0, 18106, 18107, 1, 0, 0, 0, 18107, 18109, 1, 0, 0, 0, + 18108, 18100, 1, 0, 0, 0, 18108, 18102, 1, 0, 0, 0, 18109, 2069, 1, 0, + 0, 0, 18110, 18112, 5, 1614, 0, 0, 18111, 18113, 5, 143, 0, 0, 18112, 18111, + 1, 0, 0, 0, 18112, 18113, 1, 0, 0, 0, 18113, 18114, 1, 0, 0, 0, 18114, + 18115, 5, 2447, 0, 0, 18115, 18118, 3, 2078, 1039, 0, 18116, 18117, 5, + 2453, 0, 0, 18117, 18119, 3, 2078, 1039, 0, 18118, 18116, 1, 0, 0, 0, 18118, + 18119, 1, 0, 0, 0, 18119, 18120, 1, 0, 0, 0, 18120, 18122, 5, 2448, 0, + 0, 18121, 18123, 3, 2072, 1036, 0, 18122, 18121, 1, 0, 0, 0, 18122, 18123, + 1, 0, 0, 0, 18123, 2071, 1, 0, 0, 0, 18124, 18125, 5, 1642, 0, 0, 18125, + 18126, 5, 2447, 0, 0, 18126, 18127, 3, 2078, 1039, 0, 18127, 18128, 5, + 2448, 0, 0, 18128, 2073, 1, 0, 0, 0, 18129, 18136, 3, 2078, 1039, 0, 18130, + 18131, 5, 797, 0, 0, 18131, 18132, 5, 2447, 0, 0, 18132, 18133, 3, 2076, + 1038, 0, 18133, 18134, 5, 2448, 0, 0, 18134, 18136, 1, 0, 0, 0, 18135, + 18129, 1, 0, 0, 0, 18135, 18130, 1, 0, 0, 0, 18136, 2075, 1, 0, 0, 0, 18137, + 18142, 3, 2078, 1039, 0, 18138, 18139, 5, 2453, 0, 0, 18139, 18141, 3, + 2078, 1039, 0, 18140, 18138, 1, 0, 0, 0, 18141, 18144, 1, 0, 0, 0, 18142, + 18140, 1, 0, 0, 0, 18142, 18143, 1, 0, 0, 0, 18143, 2077, 1, 0, 0, 0, 18144, + 18142, 1, 0, 0, 0, 18145, 18148, 3, 2080, 1040, 0, 18146, 18148, 3, 2082, + 1041, 0, 18147, 18145, 1, 0, 0, 0, 18147, 18146, 1, 0, 0, 0, 18148, 2079, + 1, 0, 0, 0, 18149, 18150, 5, 343, 0, 0, 18150, 18151, 5, 2447, 0, 0, 18151, + 18152, 3, 1896, 948, 0, 18152, 18153, 5, 2448, 0, 0, 18153, 2081, 1, 0, + 0, 0, 18154, 18155, 6, 1041, -1, 0, 18155, 18156, 3, 2084, 1042, 0, 18156, + 18165, 1, 0, 0, 0, 18157, 18158, 10, 2, 0, 0, 18158, 18159, 5, 49, 0, 0, + 18159, 18164, 3, 2082, 1041, 3, 18160, 18161, 10, 1, 0, 0, 18161, 18162, + 5, 1307, 0, 0, 18162, 18164, 3, 2082, 1041, 2, 18163, 18157, 1, 0, 0, 0, + 18163, 18160, 1, 0, 0, 0, 18164, 18167, 1, 0, 0, 0, 18165, 18163, 1, 0, + 0, 0, 18165, 18166, 1, 0, 0, 0, 18166, 2083, 1, 0, 0, 0, 18167, 18165, + 1, 0, 0, 0, 18168, 18170, 5, 1204, 0, 0, 18169, 18168, 1, 0, 0, 0, 18169, + 18170, 1, 0, 0, 0, 18170, 18171, 1, 0, 0, 0, 18171, 18173, 3, 2090, 1045, + 0, 18172, 18174, 3, 2086, 1043, 0, 18173, 18172, 1, 0, 0, 0, 18173, 18174, + 1, 0, 0, 0, 18174, 2085, 1, 0, 0, 0, 18175, 18177, 5, 785, 0, 0, 18176, + 18178, 5, 1204, 0, 0, 18177, 18176, 1, 0, 0, 0, 18177, 18178, 1, 0, 0, + 0, 18178, 18179, 1, 0, 0, 0, 18179, 18180, 3, 2088, 1044, 0, 18180, 2087, + 1, 0, 0, 0, 18181, 18220, 5, 1228, 0, 0, 18182, 18220, 5, 999, 0, 0, 18183, + 18220, 5, 1444, 0, 0, 18184, 18220, 5, 735, 0, 0, 18185, 18186, 5, 36, + 0, 0, 18186, 18220, 5, 1671, 0, 0, 18187, 18220, 5, 497, 0, 0, 18188, 18190, + 5, 1246, 0, 0, 18189, 18191, 5, 2166, 0, 0, 18190, 18189, 1, 0, 0, 0, 18190, + 18191, 1, 0, 0, 0, 18191, 18192, 1, 0, 0, 0, 18192, 18194, 5, 2447, 0, + 0, 18193, 18195, 5, 1258, 0, 0, 18194, 18193, 1, 0, 0, 0, 18194, 18195, + 1, 0, 0, 0, 18195, 18196, 1, 0, 0, 0, 18196, 18201, 3, 2374, 1187, 0, 18197, + 18198, 5, 2453, 0, 0, 18198, 18200, 3, 2374, 1187, 0, 18199, 18197, 1, + 0, 0, 0, 18200, 18203, 1, 0, 0, 0, 18201, 18199, 1, 0, 0, 0, 18201, 18202, + 1, 0, 0, 0, 18202, 18204, 1, 0, 0, 0, 18203, 18201, 1, 0, 0, 0, 18204, + 18205, 5, 2448, 0, 0, 18205, 18220, 1, 0, 0, 0, 18206, 18209, 5, 801, 0, + 0, 18207, 18208, 5, 621, 0, 0, 18208, 18210, 5, 801, 0, 0, 18209, 18207, + 1, 0, 0, 0, 18209, 18210, 1, 0, 0, 0, 18210, 18212, 1, 0, 0, 0, 18211, + 18213, 7, 223, 0, 0, 18212, 18211, 1, 0, 0, 0, 18212, 18213, 1, 0, 0, 0, + 18213, 18217, 1, 0, 0, 0, 18214, 18215, 7, 2, 0, 0, 18215, 18216, 5, 2183, + 0, 0, 18216, 18218, 5, 819, 0, 0, 18217, 18214, 1, 0, 0, 0, 18217, 18218, + 1, 0, 0, 0, 18218, 18220, 1, 0, 0, 0, 18219, 18181, 1, 0, 0, 0, 18219, + 18182, 1, 0, 0, 0, 18219, 18183, 1, 0, 0, 0, 18219, 18184, 1, 0, 0, 0, + 18219, 18185, 1, 0, 0, 0, 18219, 18187, 1, 0, 0, 0, 18219, 18188, 1, 0, + 0, 0, 18219, 18206, 1, 0, 0, 0, 18220, 2089, 1, 0, 0, 0, 18221, 18222, + 6, 1045, -1, 0, 18222, 18231, 3, 2092, 1046, 0, 18223, 18225, 5, 1204, + 0, 0, 18224, 18223, 1, 0, 0, 0, 18224, 18225, 1, 0, 0, 0, 18225, 18226, + 1, 0, 0, 0, 18226, 18228, 7, 224, 0, 0, 18227, 18229, 5, 1246, 0, 0, 18228, + 18227, 1, 0, 0, 0, 18228, 18229, 1, 0, 0, 0, 18229, 18230, 1, 0, 0, 0, + 18230, 18232, 3, 2102, 1051, 0, 18231, 18224, 1, 0, 0, 0, 18231, 18232, + 1, 0, 0, 0, 18232, 18242, 1, 0, 0, 0, 18233, 18234, 10, 1, 0, 0, 18234, + 18235, 5, 994, 0, 0, 18235, 18237, 7, 225, 0, 0, 18236, 18238, 7, 226, + 0, 0, 18237, 18236, 1, 0, 0, 0, 18237, 18238, 1, 0, 0, 0, 18238, 18239, + 1, 0, 0, 0, 18239, 18241, 3, 2092, 1046, 0, 18240, 18233, 1, 0, 0, 0, 18241, + 18244, 1, 0, 0, 0, 18242, 18240, 1, 0, 0, 0, 18242, 18243, 1, 0, 0, 0, + 18243, 2091, 1, 0, 0, 0, 18244, 18242, 1, 0, 0, 0, 18245, 18246, 6, 1046, + -1, 0, 18246, 18247, 3, 2094, 1047, 0, 18247, 18260, 1, 0, 0, 0, 18248, + 18249, 10, 3, 0, 0, 18249, 18250, 3, 2096, 1048, 0, 18250, 18251, 3, 2092, + 1046, 4, 18251, 18259, 1, 0, 0, 0, 18252, 18254, 10, 2, 0, 0, 18253, 18255, + 5, 1204, 0, 0, 18254, 18253, 1, 0, 0, 0, 18254, 18255, 1, 0, 0, 0, 18255, + 18256, 1, 0, 0, 0, 18256, 18257, 5, 738, 0, 0, 18257, 18259, 3, 2098, 1049, + 0, 18258, 18248, 1, 0, 0, 0, 18258, 18252, 1, 0, 0, 0, 18259, 18262, 1, + 0, 0, 0, 18260, 18258, 1, 0, 0, 0, 18260, 18261, 1, 0, 0, 0, 18261, 2093, + 1, 0, 0, 0, 18262, 18260, 1, 0, 0, 0, 18263, 18279, 3, 2102, 1051, 0, 18264, + 18266, 5, 1204, 0, 0, 18265, 18264, 1, 0, 0, 0, 18265, 18266, 1, 0, 0, + 0, 18266, 18277, 1, 0, 0, 0, 18267, 18268, 5, 738, 0, 0, 18268, 18278, + 3, 2098, 1049, 0, 18269, 18270, 5, 118, 0, 0, 18270, 18278, 3, 2100, 1050, + 0, 18271, 18272, 7, 227, 0, 0, 18272, 18275, 3, 2102, 1051, 0, 18273, 18274, + 5, 525, 0, 0, 18274, 18276, 3, 2102, 1051, 0, 18275, 18273, 1, 0, 0, 0, + 18275, 18276, 1, 0, 0, 0, 18276, 18278, 1, 0, 0, 0, 18277, 18267, 1, 0, + 0, 0, 18277, 18269, 1, 0, 0, 0, 18277, 18271, 1, 0, 0, 0, 18278, 18280, + 1, 0, 0, 0, 18279, 18265, 1, 0, 0, 0, 18279, 18280, 1, 0, 0, 0, 18280, + 2095, 1, 0, 0, 0, 18281, 18296, 5, 2472, 0, 0, 18282, 18290, 5, 2463, 0, + 0, 18283, 18284, 5, 2468, 0, 0, 18284, 18290, 5, 2467, 0, 0, 18285, 18286, + 5, 2466, 0, 0, 18286, 18290, 5, 2472, 0, 0, 18287, 18288, 5, 2464, 0, 0, + 18288, 18290, 5, 2472, 0, 0, 18289, 18282, 1, 0, 0, 0, 18289, 18283, 1, + 0, 0, 0, 18289, 18285, 1, 0, 0, 0, 18289, 18287, 1, 0, 0, 0, 18290, 18296, + 1, 0, 0, 0, 18291, 18293, 7, 228, 0, 0, 18292, 18294, 5, 2472, 0, 0, 18293, + 18292, 1, 0, 0, 0, 18293, 18294, 1, 0, 0, 0, 18294, 18296, 1, 0, 0, 0, + 18295, 18281, 1, 0, 0, 0, 18295, 18289, 1, 0, 0, 0, 18295, 18291, 1, 0, + 0, 0, 18296, 2097, 1, 0, 0, 0, 18297, 18298, 5, 2447, 0, 0, 18298, 18299, + 3, 1896, 948, 0, 18299, 18300, 5, 2448, 0, 0, 18300, 18316, 1, 0, 0, 0, + 18301, 18302, 5, 2447, 0, 0, 18302, 18307, 3, 2102, 1051, 0, 18303, 18304, + 5, 2453, 0, 0, 18304, 18306, 3, 2102, 1051, 0, 18305, 18303, 1, 0, 0, 0, + 18306, 18309, 1, 0, 0, 0, 18307, 18305, 1, 0, 0, 0, 18307, 18308, 1, 0, + 0, 0, 18308, 18310, 1, 0, 0, 0, 18309, 18307, 1, 0, 0, 0, 18310, 18311, + 5, 2448, 0, 0, 18311, 18316, 1, 0, 0, 0, 18312, 18316, 3, 2394, 1197, 0, + 18313, 18316, 3, 2382, 1191, 0, 18314, 18316, 3, 2384, 1192, 0, 18315, + 18297, 1, 0, 0, 0, 18315, 18301, 1, 0, 0, 0, 18315, 18312, 1, 0, 0, 0, + 18315, 18313, 1, 0, 0, 0, 18315, 18314, 1, 0, 0, 0, 18316, 2099, 1, 0, + 0, 0, 18317, 18318, 3, 2102, 1051, 0, 18318, 18319, 5, 49, 0, 0, 18319, + 18320, 3, 2102, 1051, 0, 18320, 2101, 1, 0, 0, 0, 18321, 18322, 6, 1051, + -1, 0, 18322, 18331, 3, 2106, 1053, 0, 18323, 18328, 5, 82, 0, 0, 18324, + 18329, 5, 873, 0, 0, 18325, 18326, 5, 2112, 0, 0, 18326, 18327, 5, 2363, + 0, 0, 18327, 18329, 3, 2102, 1051, 0, 18328, 18324, 1, 0, 0, 0, 18328, + 18325, 1, 0, 0, 0, 18329, 18332, 1, 0, 0, 0, 18330, 18332, 3, 2104, 1052, + 0, 18331, 18323, 1, 0, 0, 0, 18331, 18330, 1, 0, 0, 0, 18331, 18332, 1, + 0, 0, 0, 18332, 18336, 1, 0, 0, 0, 18333, 18334, 5, 1259, 0, 0, 18334, + 18335, 5, 1320, 0, 0, 18335, 18337, 7, 229, 0, 0, 18336, 18333, 1, 0, 0, + 0, 18336, 18337, 1, 0, 0, 0, 18337, 18356, 1, 0, 0, 0, 18338, 18339, 10, + 5, 0, 0, 18339, 18340, 5, 2449, 0, 0, 18340, 18355, 3, 2102, 1051, 6, 18341, + 18342, 10, 4, 0, 0, 18342, 18343, 7, 230, 0, 0, 18343, 18355, 3, 2102, + 1051, 5, 18344, 18345, 10, 3, 0, 0, 18345, 18346, 7, 142, 0, 0, 18346, + 18355, 3, 2102, 1051, 4, 18347, 18348, 10, 2, 0, 0, 18348, 18349, 5, 2471, + 0, 0, 18349, 18350, 5, 2471, 0, 0, 18350, 18355, 3, 2102, 1051, 3, 18351, + 18352, 10, 1, 0, 0, 18352, 18353, 5, 2372, 0, 0, 18353, 18355, 3, 1672, + 836, 0, 18354, 18338, 1, 0, 0, 0, 18354, 18341, 1, 0, 0, 0, 18354, 18344, + 1, 0, 0, 0, 18354, 18347, 1, 0, 0, 0, 18354, 18351, 1, 0, 0, 0, 18355, + 18358, 1, 0, 0, 0, 18356, 18354, 1, 0, 0, 0, 18356, 18357, 1, 0, 0, 0, + 18357, 2103, 1, 0, 0, 0, 18358, 18356, 1, 0, 0, 0, 18359, 18364, 5, 365, + 0, 0, 18360, 18361, 5, 2447, 0, 0, 18361, 18362, 3, 2102, 1051, 0, 18362, + 18363, 5, 2448, 0, 0, 18363, 18365, 1, 0, 0, 0, 18364, 18360, 1, 0, 0, + 0, 18364, 18365, 1, 0, 0, 0, 18365, 18366, 1, 0, 0, 0, 18366, 18367, 5, + 2141, 0, 0, 18367, 18372, 5, 1636, 0, 0, 18368, 18369, 5, 2447, 0, 0, 18369, + 18370, 3, 2102, 1051, 0, 18370, 18371, 5, 2448, 0, 0, 18371, 18373, 1, + 0, 0, 0, 18372, 18368, 1, 0, 0, 0, 18372, 18373, 1, 0, 0, 0, 18373, 18384, + 1, 0, 0, 0, 18374, 18379, 5, 2358, 0, 0, 18375, 18376, 5, 2447, 0, 0, 18376, + 18377, 3, 2102, 1051, 0, 18377, 18378, 5, 2448, 0, 0, 18378, 18380, 1, + 0, 0, 0, 18379, 18375, 1, 0, 0, 0, 18379, 18380, 1, 0, 0, 0, 18380, 18381, + 1, 0, 0, 0, 18381, 18382, 5, 2141, 0, 0, 18382, 18384, 5, 985, 0, 0, 18383, + 18359, 1, 0, 0, 0, 18383, 18374, 1, 0, 0, 0, 18384, 2105, 1, 0, 0, 0, 18385, + 18387, 7, 142, 0, 0, 18386, 18385, 1, 0, 0, 0, 18386, 18387, 1, 0, 0, 0, + 18387, 18388, 1, 0, 0, 0, 18388, 18393, 3, 2114, 1057, 0, 18389, 18390, + 5, 2473, 0, 0, 18390, 18391, 3, 2108, 1054, 0, 18391, 18392, 5, 2474, 0, + 0, 18392, 18394, 1, 0, 0, 0, 18393, 18389, 1, 0, 0, 0, 18393, 18394, 1, + 0, 0, 0, 18394, 2107, 1, 0, 0, 0, 18395, 18398, 5, 55, 0, 0, 18396, 18398, + 3, 2078, 1039, 0, 18397, 18395, 1, 0, 0, 0, 18397, 18396, 1, 0, 0, 0, 18398, + 18406, 1, 0, 0, 0, 18399, 18402, 5, 2453, 0, 0, 18400, 18403, 5, 55, 0, + 0, 18401, 18403, 3, 2078, 1039, 0, 18402, 18400, 1, 0, 0, 0, 18402, 18401, + 1, 0, 0, 0, 18403, 18405, 1, 0, 0, 0, 18404, 18399, 1, 0, 0, 0, 18405, + 18408, 1, 0, 0, 0, 18406, 18404, 1, 0, 0, 0, 18406, 18407, 1, 0, 0, 0, + 18407, 18419, 1, 0, 0, 0, 18408, 18406, 1, 0, 0, 0, 18409, 18414, 3, 2110, + 1055, 0, 18410, 18411, 5, 2453, 0, 0, 18411, 18413, 3, 2110, 1055, 0, 18412, + 18410, 1, 0, 0, 0, 18413, 18416, 1, 0, 0, 0, 18414, 18412, 1, 0, 0, 0, + 18414, 18415, 1, 0, 0, 0, 18415, 18419, 1, 0, 0, 0, 18416, 18414, 1, 0, + 0, 0, 18417, 18419, 3, 2112, 1056, 0, 18418, 18397, 1, 0, 0, 0, 18418, + 18409, 1, 0, 0, 0, 18418, 18417, 1, 0, 0, 0, 18419, 2109, 1, 0, 0, 0, 18420, + 18421, 5, 620, 0, 0, 18421, 18439, 3, 2340, 1170, 0, 18422, 18423, 5, 738, + 0, 0, 18423, 18425, 5, 2447, 0, 0, 18424, 18426, 3, 2076, 1038, 0, 18425, + 18424, 1, 0, 0, 0, 18425, 18426, 1, 0, 0, 0, 18426, 18427, 1, 0, 0, 0, + 18427, 18440, 5, 2448, 0, 0, 18428, 18429, 5, 857, 0, 0, 18429, 18431, + 3, 2078, 1039, 0, 18430, 18428, 1, 0, 0, 0, 18430, 18431, 1, 0, 0, 0, 18431, + 18432, 1, 0, 0, 0, 18432, 18433, 5, 628, 0, 0, 18433, 18434, 3, 2078, 1039, + 0, 18434, 18435, 5, 2141, 0, 0, 18435, 18436, 3, 2078, 1039, 0, 18436, + 18437, 7, 231, 0, 0, 18437, 18438, 3, 2078, 1039, 0, 18438, 18440, 1, 0, + 0, 0, 18439, 18422, 1, 0, 0, 0, 18439, 18430, 1, 0, 0, 0, 18440, 2111, + 1, 0, 0, 0, 18441, 18442, 5, 620, 0, 0, 18442, 18443, 3, 2360, 1180, 0, + 18443, 18444, 5, 738, 0, 0, 18444, 18451, 5, 2447, 0, 0, 18445, 18452, + 3, 1896, 948, 0, 18446, 18448, 5, 2447, 0, 0, 18447, 18449, 3, 2076, 1038, + 0, 18448, 18447, 1, 0, 0, 0, 18448, 18449, 1, 0, 0, 0, 18449, 18450, 1, + 0, 0, 0, 18450, 18452, 5, 2448, 0, 0, 18451, 18445, 1, 0, 0, 0, 18451, + 18446, 1, 0, 0, 0, 18452, 18453, 1, 0, 0, 0, 18453, 18454, 5, 2448, 0, + 0, 18454, 2113, 1, 0, 0, 0, 18455, 18456, 5, 1454, 0, 0, 18456, 18476, + 3, 2116, 1058, 0, 18457, 18458, 5, 279, 0, 0, 18458, 18476, 3, 2116, 1058, + 0, 18459, 18460, 5, 1021, 0, 0, 18460, 18476, 3, 2116, 1058, 0, 18461, + 18462, 5, 1250, 0, 0, 18462, 18476, 3, 2116, 1058, 0, 18463, 18473, 3, + 2116, 1058, 0, 18464, 18471, 5, 2440, 0, 0, 18465, 18472, 7, 232, 0, 0, + 18466, 18467, 7, 233, 0, 0, 18467, 18468, 5, 2447, 0, 0, 18468, 18469, + 3, 2078, 1039, 0, 18469, 18470, 5, 2448, 0, 0, 18470, 18472, 1, 0, 0, 0, + 18471, 18465, 1, 0, 0, 0, 18471, 18466, 1, 0, 0, 0, 18472, 18474, 1, 0, + 0, 0, 18473, 18464, 1, 0, 0, 0, 18473, 18474, 1, 0, 0, 0, 18474, 18476, + 1, 0, 0, 0, 18475, 18455, 1, 0, 0, 0, 18475, 18457, 1, 0, 0, 0, 18475, + 18459, 1, 0, 0, 0, 18475, 18461, 1, 0, 0, 0, 18475, 18463, 1, 0, 0, 0, + 18476, 2115, 1, 0, 0, 0, 18477, 18484, 3, 2132, 1066, 0, 18478, 18484, + 3, 2144, 1072, 0, 18479, 18484, 3, 2148, 1074, 0, 18480, 18481, 4, 1058, + 23, 0, 18481, 18484, 3, 2142, 1071, 0, 18482, 18484, 3, 2118, 1059, 0, + 18483, 18477, 1, 0, 0, 0, 18483, 18478, 1, 0, 0, 0, 18483, 18479, 1, 0, + 0, 0, 18483, 18480, 1, 0, 0, 0, 18483, 18482, 1, 0, 0, 0, 18484, 2117, + 1, 0, 0, 0, 18485, 18502, 5, 1722, 0, 0, 18486, 18487, 5, 1384, 0, 0, 18487, + 18488, 5, 2447, 0, 0, 18488, 18489, 3, 2078, 1039, 0, 18489, 18490, 5, + 2448, 0, 0, 18490, 18503, 1, 0, 0, 0, 18491, 18500, 5, 1383, 0, 0, 18492, + 18493, 5, 2440, 0, 0, 18493, 18501, 5, 313, 0, 0, 18494, 18495, 5, 2447, + 0, 0, 18495, 18496, 3, 2078, 1039, 0, 18496, 18497, 5, 2448, 0, 0, 18497, + 18498, 5, 2440, 0, 0, 18498, 18499, 7, 234, 0, 0, 18499, 18501, 1, 0, 0, + 0, 18500, 18492, 1, 0, 0, 0, 18500, 18494, 1, 0, 0, 0, 18501, 18503, 1, + 0, 0, 0, 18502, 18486, 1, 0, 0, 0, 18502, 18491, 1, 0, 0, 0, 18503, 2119, + 1, 0, 0, 0, 18504, 18505, 3, 1082, 541, 0, 18505, 18506, 5, 2447, 0, 0, + 18506, 18507, 3, 2078, 1039, 0, 18507, 18512, 5, 2448, 0, 0, 18508, 18509, + 5, 2440, 0, 0, 18509, 18511, 3, 2386, 1193, 0, 18510, 18508, 1, 0, 0, 0, + 18511, 18514, 1, 0, 0, 0, 18512, 18510, 1, 0, 0, 0, 18512, 18513, 1, 0, + 0, 0, 18513, 2121, 1, 0, 0, 0, 18514, 18512, 1, 0, 0, 0, 18515, 18518, + 3, 2126, 1063, 0, 18516, 18518, 3, 2124, 1062, 0, 18517, 18515, 1, 0, 0, + 0, 18517, 18516, 1, 0, 0, 0, 18518, 2123, 1, 0, 0, 0, 18519, 18521, 3, + 1772, 886, 0, 18520, 18519, 1, 0, 0, 0, 18520, 18521, 1, 0, 0, 0, 18521, + 18522, 1, 0, 0, 0, 18522, 18523, 5, 180, 0, 0, 18523, 18525, 3, 2078, 1039, + 0, 18524, 18526, 3, 2128, 1064, 0, 18525, 18524, 1, 0, 0, 0, 18526, 18527, + 1, 0, 0, 0, 18527, 18525, 1, 0, 0, 0, 18527, 18528, 1, 0, 0, 0, 18528, + 18530, 1, 0, 0, 0, 18529, 18531, 3, 2130, 1065, 0, 18530, 18529, 1, 0, + 0, 0, 18530, 18531, 1, 0, 0, 0, 18531, 18532, 1, 0, 0, 0, 18532, 18534, + 5, 508, 0, 0, 18533, 18535, 5, 180, 0, 0, 18534, 18533, 1, 0, 0, 0, 18534, + 18535, 1, 0, 0, 0, 18535, 18537, 1, 0, 0, 0, 18536, 18538, 3, 2312, 1156, + 0, 18537, 18536, 1, 0, 0, 0, 18537, 18538, 1, 0, 0, 0, 18538, 2125, 1, + 0, 0, 0, 18539, 18541, 3, 1772, 886, 0, 18540, 18539, 1, 0, 0, 0, 18540, + 18541, 1, 0, 0, 0, 18541, 18542, 1, 0, 0, 0, 18542, 18544, 5, 180, 0, 0, + 18543, 18545, 3, 2128, 1064, 0, 18544, 18543, 1, 0, 0, 0, 18545, 18546, + 1, 0, 0, 0, 18546, 18544, 1, 0, 0, 0, 18546, 18547, 1, 0, 0, 0, 18547, + 18549, 1, 0, 0, 0, 18548, 18550, 3, 2130, 1065, 0, 18549, 18548, 1, 0, + 0, 0, 18549, 18550, 1, 0, 0, 0, 18550, 18551, 1, 0, 0, 0, 18551, 18553, + 5, 508, 0, 0, 18552, 18554, 5, 180, 0, 0, 18553, 18552, 1, 0, 0, 0, 18553, + 18554, 1, 0, 0, 0, 18554, 18556, 1, 0, 0, 0, 18555, 18557, 3, 2312, 1156, + 0, 18556, 18555, 1, 0, 0, 0, 18556, 18557, 1, 0, 0, 0, 18557, 2127, 1, + 0, 0, 0, 18558, 18559, 5, 2300, 0, 0, 18559, 18560, 3, 2078, 1039, 0, 18560, + 18561, 5, 2099, 0, 0, 18561, 18562, 3, 1770, 885, 0, 18562, 2129, 1, 0, + 0, 0, 18563, 18564, 5, 491, 0, 0, 18564, 18565, 3, 1770, 885, 0, 18565, + 2131, 1, 0, 0, 0, 18566, 18569, 3, 2136, 1068, 0, 18567, 18569, 3, 2134, + 1067, 0, 18568, 18566, 1, 0, 0, 0, 18568, 18567, 1, 0, 0, 0, 18569, 2133, + 1, 0, 0, 0, 18570, 18571, 5, 180, 0, 0, 18571, 18573, 3, 2078, 1039, 0, + 18572, 18574, 3, 2138, 1069, 0, 18573, 18572, 1, 0, 0, 0, 18574, 18575, + 1, 0, 0, 0, 18575, 18573, 1, 0, 0, 0, 18575, 18576, 1, 0, 0, 0, 18576, + 18578, 1, 0, 0, 0, 18577, 18579, 3, 2140, 1070, 0, 18578, 18577, 1, 0, + 0, 0, 18578, 18579, 1, 0, 0, 0, 18579, 18580, 1, 0, 0, 0, 18580, 18582, + 5, 508, 0, 0, 18581, 18583, 5, 180, 0, 0, 18582, 18581, 1, 0, 0, 0, 18582, + 18583, 1, 0, 0, 0, 18583, 2135, 1, 0, 0, 0, 18584, 18586, 5, 180, 0, 0, + 18585, 18587, 3, 2138, 1069, 0, 18586, 18585, 1, 0, 0, 0, 18587, 18588, + 1, 0, 0, 0, 18588, 18586, 1, 0, 0, 0, 18588, 18589, 1, 0, 0, 0, 18589, + 18591, 1, 0, 0, 0, 18590, 18592, 3, 2140, 1070, 0, 18591, 18590, 1, 0, + 0, 0, 18591, 18592, 1, 0, 0, 0, 18592, 18593, 1, 0, 0, 0, 18593, 18595, + 5, 508, 0, 0, 18594, 18596, 5, 180, 0, 0, 18595, 18594, 1, 0, 0, 0, 18595, + 18596, 1, 0, 0, 0, 18596, 2137, 1, 0, 0, 0, 18597, 18598, 5, 2300, 0, 0, + 18598, 18599, 3, 2078, 1039, 0, 18599, 18600, 5, 2099, 0, 0, 18600, 18601, + 3, 2078, 1039, 0, 18601, 2139, 1, 0, 0, 0, 18602, 18603, 5, 491, 0, 0, + 18603, 18604, 3, 2078, 1039, 0, 18604, 2141, 1, 0, 0, 0, 18605, 18626, + 3, 2382, 1191, 0, 18606, 18626, 3, 2394, 1197, 0, 18607, 18626, 3, 2406, + 1203, 0, 18608, 18610, 3, 2384, 1192, 0, 18609, 18611, 3, 2408, 1204, 0, + 18610, 18609, 1, 0, 0, 0, 18610, 18611, 1, 0, 0, 0, 18611, 18626, 1, 0, + 0, 0, 18612, 18613, 5, 2447, 0, 0, 18613, 18614, 3, 1896, 948, 0, 18614, + 18618, 5, 2448, 0, 0, 18615, 18617, 3, 1900, 950, 0, 18616, 18615, 1, 0, + 0, 0, 18617, 18620, 1, 0, 0, 0, 18618, 18616, 1, 0, 0, 0, 18618, 18619, + 1, 0, 0, 0, 18619, 18626, 1, 0, 0, 0, 18620, 18618, 1, 0, 0, 0, 18621, + 18622, 5, 2447, 0, 0, 18622, 18623, 3, 2076, 1038, 0, 18623, 18624, 5, + 2448, 0, 0, 18624, 18626, 1, 0, 0, 0, 18625, 18605, 1, 0, 0, 0, 18625, + 18606, 1, 0, 0, 0, 18625, 18607, 1, 0, 0, 0, 18625, 18608, 1, 0, 0, 0, + 18625, 18612, 1, 0, 0, 0, 18625, 18621, 1, 0, 0, 0, 18626, 2143, 1, 0, + 0, 0, 18627, 18643, 7, 235, 0, 0, 18628, 18629, 5, 2447, 0, 0, 18629, 18630, + 3, 1868, 934, 0, 18630, 18631, 5, 2448, 0, 0, 18631, 18644, 1, 0, 0, 0, + 18632, 18633, 5, 2447, 0, 0, 18633, 18638, 3, 2078, 1039, 0, 18634, 18635, + 5, 2453, 0, 0, 18635, 18637, 3, 2078, 1039, 0, 18636, 18634, 1, 0, 0, 0, + 18637, 18640, 1, 0, 0, 0, 18638, 18636, 1, 0, 0, 0, 18638, 18639, 1, 0, + 0, 0, 18639, 18641, 1, 0, 0, 0, 18640, 18638, 1, 0, 0, 0, 18641, 18642, + 5, 2448, 0, 0, 18642, 18644, 1, 0, 0, 0, 18643, 18628, 1, 0, 0, 0, 18643, + 18632, 1, 0, 0, 0, 18644, 2145, 1, 0, 0, 0, 18645, 18646, 5, 2416, 0, 0, + 18646, 18647, 5, 2447, 0, 0, 18647, 18648, 3, 2078, 1039, 0, 18648, 18649, + 5, 2453, 0, 0, 18649, 18652, 3, 2078, 1039, 0, 18650, 18651, 5, 2453, 0, + 0, 18651, 18653, 3, 2078, 1039, 0, 18652, 18650, 1, 0, 0, 0, 18652, 18653, + 1, 0, 0, 0, 18653, 18654, 1, 0, 0, 0, 18654, 18655, 5, 2448, 0, 0, 18655, + 18732, 1, 0, 0, 0, 18656, 18657, 5, 2417, 0, 0, 18657, 18661, 5, 2447, + 0, 0, 18658, 18662, 3, 2388, 1194, 0, 18659, 18662, 3, 2148, 1074, 0, 18660, + 18662, 3, 2078, 1039, 0, 18661, 18658, 1, 0, 0, 0, 18661, 18659, 1, 0, + 0, 0, 18661, 18660, 1, 0, 0, 0, 18662, 18665, 1, 0, 0, 0, 18663, 18664, + 5, 2453, 0, 0, 18664, 18666, 3, 2400, 1200, 0, 18665, 18663, 1, 0, 0, 0, + 18665, 18666, 1, 0, 0, 0, 18666, 18669, 1, 0, 0, 0, 18667, 18668, 5, 2453, + 0, 0, 18668, 18670, 3, 2400, 1200, 0, 18669, 18667, 1, 0, 0, 0, 18669, + 18670, 1, 0, 0, 0, 18670, 18671, 1, 0, 0, 0, 18671, 18672, 5, 2448, 0, + 0, 18672, 18732, 1, 0, 0, 0, 18673, 18674, 5, 2401, 0, 0, 18674, 18675, + 5, 2447, 0, 0, 18675, 18676, 3, 2076, 1038, 0, 18676, 18677, 5, 2448, 0, + 0, 18677, 18732, 1, 0, 0, 0, 18678, 18679, 5, 204, 0, 0, 18679, 18680, + 5, 2447, 0, 0, 18680, 18681, 3, 2102, 1051, 0, 18681, 18682, 5, 2246, 0, + 0, 18682, 18683, 5, 1007, 0, 0, 18683, 18684, 5, 2448, 0, 0, 18684, 18732, + 1, 0, 0, 0, 18685, 18686, 5, 2411, 0, 0, 18686, 18687, 5, 2447, 0, 0, 18687, + 18688, 3, 2078, 1039, 0, 18688, 18689, 5, 2453, 0, 0, 18689, 18690, 3, + 2078, 1039, 0, 18690, 18691, 5, 2448, 0, 0, 18691, 18732, 1, 0, 0, 0, 18692, + 18693, 5, 2418, 0, 0, 18693, 18701, 5, 2447, 0, 0, 18694, 18696, 7, 236, + 0, 0, 18695, 18694, 1, 0, 0, 0, 18695, 18696, 1, 0, 0, 0, 18696, 18698, + 1, 0, 0, 0, 18697, 18699, 3, 2078, 1039, 0, 18698, 18697, 1, 0, 0, 0, 18698, + 18699, 1, 0, 0, 0, 18699, 18700, 1, 0, 0, 0, 18700, 18702, 5, 628, 0, 0, + 18701, 18695, 1, 0, 0, 0, 18701, 18702, 1, 0, 0, 0, 18702, 18703, 1, 0, + 0, 0, 18703, 18704, 3, 2102, 1051, 0, 18704, 18705, 5, 2448, 0, 0, 18705, + 18732, 1, 0, 0, 0, 18706, 18707, 5, 2425, 0, 0, 18707, 18711, 5, 2447, + 0, 0, 18708, 18712, 3, 2388, 1194, 0, 18709, 18712, 3, 2148, 1074, 0, 18710, + 18712, 3, 2078, 1039, 0, 18711, 18708, 1, 0, 0, 0, 18711, 18709, 1, 0, + 0, 0, 18711, 18710, 1, 0, 0, 0, 18712, 18719, 1, 0, 0, 0, 18713, 18714, + 5, 389, 0, 0, 18714, 18715, 3, 2102, 1051, 0, 18715, 18716, 5, 1259, 0, + 0, 18716, 18717, 5, 301, 0, 0, 18717, 18718, 5, 520, 0, 0, 18718, 18720, + 1, 0, 0, 0, 18719, 18713, 1, 0, 0, 0, 18719, 18720, 1, 0, 0, 0, 18720, + 18727, 1, 0, 0, 0, 18721, 18722, 5, 2453, 0, 0, 18722, 18725, 3, 2400, + 1200, 0, 18723, 18724, 5, 2453, 0, 0, 18724, 18726, 3, 2400, 1200, 0, 18725, + 18723, 1, 0, 0, 0, 18725, 18726, 1, 0, 0, 0, 18726, 18728, 1, 0, 0, 0, + 18727, 18721, 1, 0, 0, 0, 18727, 18728, 1, 0, 0, 0, 18728, 18729, 1, 0, + 0, 0, 18729, 18730, 5, 2448, 0, 0, 18730, 18732, 1, 0, 0, 0, 18731, 18645, + 1, 0, 0, 0, 18731, 18656, 1, 0, 0, 0, 18731, 18673, 1, 0, 0, 0, 18731, + 18678, 1, 0, 0, 0, 18731, 18685, 1, 0, 0, 0, 18731, 18692, 1, 0, 0, 0, + 18731, 18706, 1, 0, 0, 0, 18732, 2147, 1, 0, 0, 0, 18733, 18739, 3, 2146, + 1073, 0, 18734, 18739, 3, 2188, 1094, 0, 18735, 18739, 3, 2150, 1075, 0, + 18736, 18737, 4, 1074, 24, 0, 18737, 18739, 3, 2194, 1097, 0, 18738, 18733, + 1, 0, 0, 0, 18738, 18734, 1, 0, 0, 0, 18738, 18735, 1, 0, 0, 0, 18738, + 18736, 1, 0, 0, 0, 18739, 2149, 1, 0, 0, 0, 18740, 18741, 5, 796, 0, 0, + 18741, 18742, 5, 2447, 0, 0, 18742, 18747, 3, 2158, 1079, 0, 18743, 18744, + 5, 2453, 0, 0, 18744, 18746, 3, 2158, 1079, 0, 18745, 18743, 1, 0, 0, 0, + 18746, 18749, 1, 0, 0, 0, 18747, 18745, 1, 0, 0, 0, 18747, 18748, 1, 0, + 0, 0, 18748, 18751, 1, 0, 0, 0, 18749, 18747, 1, 0, 0, 0, 18750, 18752, + 3, 2160, 1080, 0, 18751, 18750, 1, 0, 0, 0, 18751, 18752, 1, 0, 0, 0, 18752, + 18754, 1, 0, 0, 0, 18753, 18755, 3, 2162, 1081, 0, 18754, 18753, 1, 0, + 0, 0, 18754, 18755, 1, 0, 0, 0, 18755, 18757, 1, 0, 0, 0, 18756, 18758, + 5, 1766, 0, 0, 18757, 18756, 1, 0, 0, 0, 18757, 18758, 1, 0, 0, 0, 18758, + 18759, 1, 0, 0, 0, 18759, 18760, 5, 2448, 0, 0, 18760, 18929, 1, 0, 0, + 0, 18761, 18762, 5, 795, 0, 0, 18762, 18763, 5, 2447, 0, 0, 18763, 18766, + 3, 2078, 1039, 0, 18764, 18765, 5, 621, 0, 0, 18765, 18767, 5, 801, 0, + 0, 18766, 18764, 1, 0, 0, 0, 18766, 18767, 1, 0, 0, 0, 18767, 18769, 1, + 0, 0, 0, 18768, 18770, 3, 1994, 997, 0, 18769, 18768, 1, 0, 0, 0, 18769, + 18770, 1, 0, 0, 0, 18770, 18772, 1, 0, 0, 0, 18771, 18773, 3, 2160, 1080, + 0, 18772, 18771, 1, 0, 0, 0, 18772, 18773, 1, 0, 0, 0, 18773, 18775, 1, + 0, 0, 0, 18774, 18776, 3, 2162, 1081, 0, 18775, 18774, 1, 0, 0, 0, 18775, + 18776, 1, 0, 0, 0, 18776, 18778, 1, 0, 0, 0, 18777, 18779, 5, 1766, 0, + 0, 18778, 18777, 1, 0, 0, 0, 18778, 18779, 1, 0, 0, 0, 18779, 18780, 1, + 0, 0, 0, 18780, 18781, 5, 2448, 0, 0, 18781, 18929, 1, 0, 0, 0, 18782, + 18783, 5, 803, 0, 0, 18783, 18784, 5, 2447, 0, 0, 18784, 18785, 3, 2152, + 1076, 0, 18785, 18786, 5, 2448, 0, 0, 18786, 18929, 1, 0, 0, 0, 18787, + 18788, 5, 802, 0, 0, 18788, 18790, 5, 2447, 0, 0, 18789, 18791, 5, 816, + 0, 0, 18790, 18789, 1, 0, 0, 0, 18790, 18791, 1, 0, 0, 0, 18791, 18792, + 1, 0, 0, 0, 18792, 18793, 3, 2078, 1039, 0, 18793, 18794, 5, 2258, 0, 0, + 18794, 18798, 3, 2078, 1039, 0, 18795, 18796, 7, 237, 0, 0, 18796, 18797, + 5, 1259, 0, 0, 18797, 18799, 5, 1228, 0, 0, 18798, 18795, 1, 0, 0, 0, 18798, + 18799, 1, 0, 0, 0, 18799, 18814, 1, 0, 0, 0, 18800, 18812, 5, 1585, 0, + 0, 18801, 18808, 5, 2259, 0, 0, 18802, 18803, 5, 2447, 0, 0, 18803, 18805, + 5, 2441, 0, 0, 18804, 18806, 7, 238, 0, 0, 18805, 18804, 1, 0, 0, 0, 18805, + 18806, 1, 0, 0, 0, 18806, 18807, 1, 0, 0, 0, 18807, 18809, 5, 2448, 0, + 0, 18808, 18802, 1, 0, 0, 0, 18808, 18809, 1, 0, 0, 0, 18809, 18813, 1, + 0, 0, 0, 18810, 18813, 5, 215, 0, 0, 18811, 18813, 5, 142, 0, 0, 18812, + 18801, 1, 0, 0, 0, 18812, 18810, 1, 0, 0, 0, 18812, 18811, 1, 0, 0, 0, + 18813, 18815, 1, 0, 0, 0, 18814, 18800, 1, 0, 0, 0, 18814, 18815, 1, 0, + 0, 0, 18815, 18817, 1, 0, 0, 0, 18816, 18818, 5, 1766, 0, 0, 18817, 18816, + 1, 0, 0, 0, 18817, 18818, 1, 0, 0, 0, 18818, 18822, 1, 0, 0, 0, 18819, + 18820, 5, 2308, 0, 0, 18820, 18821, 5, 2183, 0, 0, 18821, 18823, 5, 819, + 0, 0, 18822, 18819, 1, 0, 0, 0, 18822, 18823, 1, 0, 0, 0, 18823, 18824, + 1, 0, 0, 0, 18824, 18825, 5, 2448, 0, 0, 18825, 18929, 1, 0, 0, 0, 18826, + 18827, 5, 805, 0, 0, 18827, 18828, 5, 2447, 0, 0, 18828, 18831, 3, 2078, + 1039, 0, 18829, 18830, 5, 621, 0, 0, 18830, 18832, 5, 801, 0, 0, 18831, + 18829, 1, 0, 0, 0, 18831, 18832, 1, 0, 0, 0, 18832, 18833, 1, 0, 0, 0, + 18833, 18834, 5, 2453, 0, 0, 18834, 18835, 5, 2443, 0, 0, 18835, 18837, + 3, 2170, 1085, 0, 18836, 18838, 3, 2174, 1087, 0, 18837, 18836, 1, 0, 0, + 0, 18837, 18838, 1, 0, 0, 0, 18838, 18840, 1, 0, 0, 0, 18839, 18841, 3, + 2176, 1088, 0, 18840, 18839, 1, 0, 0, 0, 18840, 18841, 1, 0, 0, 0, 18841, + 18843, 1, 0, 0, 0, 18842, 18844, 3, 2178, 1089, 0, 18843, 18842, 1, 0, + 0, 0, 18843, 18844, 1, 0, 0, 0, 18844, 18845, 1, 0, 0, 0, 18845, 18846, + 5, 2448, 0, 0, 18846, 18929, 1, 0, 0, 0, 18847, 18848, 5, 806, 0, 0, 18848, + 18849, 5, 2447, 0, 0, 18849, 18852, 5, 2443, 0, 0, 18850, 18851, 5, 1585, + 0, 0, 18851, 18853, 3, 2172, 1086, 0, 18852, 18850, 1, 0, 0, 0, 18852, + 18853, 1, 0, 0, 0, 18853, 18855, 1, 0, 0, 0, 18854, 18856, 5, 1448, 0, + 0, 18855, 18854, 1, 0, 0, 0, 18855, 18856, 1, 0, 0, 0, 18856, 18858, 1, + 0, 0, 0, 18857, 18859, 5, 71, 0, 0, 18858, 18857, 1, 0, 0, 0, 18858, 18859, + 1, 0, 0, 0, 18859, 18861, 1, 0, 0, 0, 18860, 18862, 5, 2159, 0, 0, 18861, + 18860, 1, 0, 0, 0, 18861, 18862, 1, 0, 0, 0, 18862, 18871, 1, 0, 0, 0, + 18863, 18868, 5, 1228, 0, 0, 18864, 18868, 5, 520, 0, 0, 18865, 18866, + 5, 497, 0, 0, 18866, 18868, 7, 239, 0, 0, 18867, 18863, 1, 0, 0, 0, 18867, + 18864, 1, 0, 0, 0, 18867, 18865, 1, 0, 0, 0, 18868, 18869, 1, 0, 0, 0, + 18869, 18870, 5, 1259, 0, 0, 18870, 18872, 5, 520, 0, 0, 18871, 18867, + 1, 0, 0, 0, 18871, 18872, 1, 0, 0, 0, 18872, 18873, 1, 0, 0, 0, 18873, + 18929, 5, 2448, 0, 0, 18874, 18875, 5, 810, 0, 0, 18875, 18876, 5, 2447, + 0, 0, 18876, 18877, 3, 2078, 1039, 0, 18877, 18878, 5, 2453, 0, 0, 18878, + 18883, 3, 2164, 1082, 0, 18879, 18880, 5, 2453, 0, 0, 18880, 18882, 3, + 2164, 1082, 0, 18881, 18879, 1, 0, 0, 0, 18882, 18885, 1, 0, 0, 0, 18883, + 18881, 1, 0, 0, 0, 18883, 18884, 1, 0, 0, 0, 18884, 18886, 1, 0, 0, 0, + 18885, 18883, 1, 0, 0, 0, 18886, 18887, 5, 2448, 0, 0, 18887, 18929, 1, + 0, 0, 0, 18888, 18889, 5, 811, 0, 0, 18889, 18890, 5, 2447, 0, 0, 18890, + 18893, 3, 2078, 1039, 0, 18891, 18892, 5, 621, 0, 0, 18892, 18894, 5, 801, + 0, 0, 18893, 18891, 1, 0, 0, 0, 18893, 18894, 1, 0, 0, 0, 18894, 18926, + 1, 0, 0, 0, 18895, 18897, 5, 2453, 0, 0, 18896, 18898, 5, 2443, 0, 0, 18897, + 18896, 1, 0, 0, 0, 18897, 18898, 1, 0, 0, 0, 18898, 18900, 1, 0, 0, 0, + 18899, 18901, 3, 2180, 1090, 0, 18900, 18899, 1, 0, 0, 0, 18900, 18901, + 1, 0, 0, 0, 18901, 18910, 1, 0, 0, 0, 18902, 18907, 5, 520, 0, 0, 18903, + 18907, 5, 1228, 0, 0, 18904, 18905, 5, 389, 0, 0, 18905, 18907, 3, 2186, + 1093, 0, 18906, 18902, 1, 0, 0, 0, 18906, 18903, 1, 0, 0, 0, 18906, 18904, + 1, 0, 0, 0, 18906, 18907, 1, 0, 0, 0, 18907, 18908, 1, 0, 0, 0, 18908, + 18909, 5, 1259, 0, 0, 18909, 18911, 5, 520, 0, 0, 18910, 18906, 1, 0, 0, + 0, 18910, 18911, 1, 0, 0, 0, 18911, 18920, 1, 0, 0, 0, 18912, 18917, 5, + 520, 0, 0, 18913, 18917, 5, 1228, 0, 0, 18914, 18915, 5, 389, 0, 0, 18915, + 18917, 3, 2186, 1093, 0, 18916, 18912, 1, 0, 0, 0, 18916, 18913, 1, 0, + 0, 0, 18916, 18914, 1, 0, 0, 0, 18916, 18917, 1, 0, 0, 0, 18917, 18918, + 1, 0, 0, 0, 18918, 18919, 5, 1259, 0, 0, 18919, 18921, 5, 497, 0, 0, 18920, + 18916, 1, 0, 0, 0, 18920, 18921, 1, 0, 0, 0, 18921, 18923, 1, 0, 0, 0, + 18922, 18924, 3, 2184, 1092, 0, 18923, 18922, 1, 0, 0, 0, 18923, 18924, + 1, 0, 0, 0, 18924, 18925, 1, 0, 0, 0, 18925, 18927, 5, 2448, 0, 0, 18926, + 18895, 1, 0, 0, 0, 18926, 18927, 1, 0, 0, 0, 18927, 18929, 1, 0, 0, 0, + 18928, 18740, 1, 0, 0, 0, 18928, 18761, 1, 0, 0, 0, 18928, 18782, 1, 0, + 0, 0, 18928, 18787, 1, 0, 0, 0, 18928, 18826, 1, 0, 0, 0, 18928, 18847, + 1, 0, 0, 0, 18928, 18874, 1, 0, 0, 0, 18928, 18888, 1, 0, 0, 0, 18929, + 2151, 1, 0, 0, 0, 18930, 18935, 3, 2154, 1077, 0, 18931, 18932, 5, 2453, + 0, 0, 18932, 18934, 3, 2154, 1077, 0, 18933, 18931, 1, 0, 0, 0, 18934, + 18937, 1, 0, 0, 0, 18935, 18933, 1, 0, 0, 0, 18935, 18936, 1, 0, 0, 0, + 18936, 18940, 1, 0, 0, 0, 18937, 18935, 1, 0, 0, 0, 18938, 18940, 5, 2450, + 0, 0, 18939, 18930, 1, 0, 0, 0, 18939, 18938, 1, 0, 0, 0, 18940, 18942, + 1, 0, 0, 0, 18941, 18943, 3, 2160, 1080, 0, 18942, 18941, 1, 0, 0, 0, 18942, + 18943, 1, 0, 0, 0, 18943, 18945, 1, 0, 0, 0, 18944, 18946, 3, 2162, 1081, + 0, 18945, 18944, 1, 0, 0, 0, 18945, 18946, 1, 0, 0, 0, 18946, 18948, 1, + 0, 0, 0, 18947, 18949, 5, 1766, 0, 0, 18948, 18947, 1, 0, 0, 0, 18948, + 18949, 1, 0, 0, 0, 18949, 18953, 1, 0, 0, 0, 18950, 18951, 5, 2308, 0, + 0, 18951, 18952, 5, 2183, 0, 0, 18952, 18954, 5, 819, 0, 0, 18953, 18950, + 1, 0, 0, 0, 18953, 18954, 1, 0, 0, 0, 18954, 2153, 1, 0, 0, 0, 18955, 18957, + 5, 816, 0, 0, 18956, 18955, 1, 0, 0, 0, 18956, 18957, 1, 0, 0, 0, 18957, + 18958, 1, 0, 0, 0, 18958, 18960, 3, 2078, 1039, 0, 18959, 18961, 7, 240, + 0, 0, 18960, 18959, 1, 0, 0, 0, 18960, 18961, 1, 0, 0, 0, 18961, 18962, + 1, 0, 0, 0, 18962, 18963, 3, 2078, 1039, 0, 18963, 18970, 1, 0, 0, 0, 18964, + 18965, 3, 2078, 1039, 0, 18965, 18966, 5, 2469, 0, 0, 18966, 18967, 3, + 2078, 1039, 0, 18967, 18970, 1, 0, 0, 0, 18968, 18970, 3, 2402, 1201, 0, + 18969, 18956, 1, 0, 0, 0, 18969, 18964, 1, 0, 0, 0, 18969, 18968, 1, 0, + 0, 0, 18970, 18973, 1, 0, 0, 0, 18971, 18972, 5, 621, 0, 0, 18972, 18974, + 5, 801, 0, 0, 18973, 18971, 1, 0, 0, 0, 18973, 18974, 1, 0, 0, 0, 18974, + 2155, 1, 0, 0, 0, 18975, 18976, 5, 807, 0, 0, 18976, 18977, 5, 2447, 0, + 0, 18977, 18980, 3, 2078, 1039, 0, 18978, 18979, 5, 621, 0, 0, 18979, 18981, + 5, 801, 0, 0, 18980, 18978, 1, 0, 0, 0, 18980, 18981, 1, 0, 0, 0, 18981, + 18984, 1, 0, 0, 0, 18982, 18983, 5, 2453, 0, 0, 18983, 18985, 5, 2443, + 0, 0, 18984, 18982, 1, 0, 0, 0, 18984, 18985, 1, 0, 0, 0, 18985, 18989, + 1, 0, 0, 0, 18986, 18987, 7, 241, 0, 0, 18987, 18988, 5, 1259, 0, 0, 18988, + 18990, 5, 520, 0, 0, 18989, 18986, 1, 0, 0, 0, 18989, 18990, 1, 0, 0, 0, + 18990, 18994, 1, 0, 0, 0, 18991, 18992, 7, 242, 0, 0, 18992, 18993, 5, + 1259, 0, 0, 18993, 18995, 5, 497, 0, 0, 18994, 18991, 1, 0, 0, 0, 18994, + 18995, 1, 0, 0, 0, 18995, 18997, 1, 0, 0, 0, 18996, 18998, 3, 2166, 1083, + 0, 18997, 18996, 1, 0, 0, 0, 18997, 18998, 1, 0, 0, 0, 18998, 18999, 1, + 0, 0, 0, 18999, 19000, 5, 2448, 0, 0, 19000, 2157, 1, 0, 0, 0, 19001, 19007, + 3, 2078, 1039, 0, 19002, 19007, 5, 2443, 0, 0, 19003, 19007, 5, 1228, 0, + 0, 19004, 19007, 5, 2441, 0, 0, 19005, 19007, 3, 2150, 1075, 0, 19006, + 19001, 1, 0, 0, 0, 19006, 19002, 1, 0, 0, 0, 19006, 19003, 1, 0, 0, 0, + 19006, 19004, 1, 0, 0, 0, 19006, 19005, 1, 0, 0, 0, 19007, 19010, 1, 0, + 0, 0, 19008, 19009, 5, 621, 0, 0, 19009, 19011, 5, 801, 0, 0, 19010, 19008, + 1, 0, 0, 0, 19010, 19011, 1, 0, 0, 0, 19011, 2159, 1, 0, 0, 0, 19012, 19013, + 7, 237, 0, 0, 19013, 19014, 5, 1259, 0, 0, 19014, 19015, 5, 1228, 0, 0, + 19015, 2161, 1, 0, 0, 0, 19016, 19028, 5, 1585, 0, 0, 19017, 19024, 5, + 2259, 0, 0, 19018, 19019, 5, 2447, 0, 0, 19019, 19021, 5, 2441, 0, 0, 19020, + 19022, 7, 238, 0, 0, 19021, 19020, 1, 0, 0, 0, 19021, 19022, 1, 0, 0, 0, + 19022, 19023, 1, 0, 0, 0, 19023, 19025, 5, 2448, 0, 0, 19024, 19018, 1, + 0, 0, 0, 19024, 19025, 1, 0, 0, 0, 19025, 19029, 1, 0, 0, 0, 19026, 19029, + 5, 215, 0, 0, 19027, 19029, 5, 142, 0, 0, 19028, 19017, 1, 0, 0, 0, 19028, + 19026, 1, 0, 0, 0, 19028, 19027, 1, 0, 0, 0, 19029, 2163, 1, 0, 0, 0, 19030, + 19031, 5, 1558, 0, 0, 19031, 19037, 5, 2443, 0, 0, 19032, 19034, 7, 243, + 0, 0, 19033, 19032, 1, 0, 0, 0, 19033, 19034, 1, 0, 0, 0, 19034, 19035, + 1, 0, 0, 0, 19035, 19036, 5, 1259, 0, 0, 19036, 19038, 5, 964, 0, 0, 19037, + 19033, 1, 0, 0, 0, 19037, 19038, 1, 0, 0, 0, 19038, 19118, 1, 0, 0, 0, + 19039, 19040, 5, 756, 0, 0, 19040, 19041, 5, 2443, 0, 0, 19041, 19042, + 5, 2472, 0, 0, 19042, 19046, 5, 2443, 0, 0, 19043, 19044, 7, 244, 0, 0, + 19044, 19045, 5, 1259, 0, 0, 19045, 19047, 5, 544, 0, 0, 19046, 19043, + 1, 0, 0, 0, 19046, 19047, 1, 0, 0, 0, 19047, 19053, 1, 0, 0, 0, 19048, + 19050, 7, 245, 0, 0, 19049, 19048, 1, 0, 0, 0, 19049, 19050, 1, 0, 0, 0, + 19050, 19051, 1, 0, 0, 0, 19051, 19052, 5, 1259, 0, 0, 19052, 19054, 5, + 1228, 0, 0, 19053, 19049, 1, 0, 0, 0, 19053, 19054, 1, 0, 0, 0, 19054, + 19118, 1, 0, 0, 0, 19055, 19056, 5, 1562, 0, 0, 19056, 19057, 5, 2443, + 0, 0, 19057, 19058, 5, 2472, 0, 0, 19058, 19062, 5, 2443, 0, 0, 19059, + 19060, 7, 246, 0, 0, 19060, 19061, 5, 1259, 0, 0, 19061, 19063, 5, 964, + 0, 0, 19062, 19059, 1, 0, 0, 0, 19062, 19063, 1, 0, 0, 0, 19063, 19069, + 1, 0, 0, 0, 19064, 19066, 7, 247, 0, 0, 19065, 19064, 1, 0, 0, 0, 19065, + 19066, 1, 0, 0, 0, 19066, 19067, 1, 0, 0, 0, 19067, 19068, 5, 1259, 0, + 0, 19068, 19070, 5, 1228, 0, 0, 19069, 19065, 1, 0, 0, 0, 19069, 19070, + 1, 0, 0, 0, 19070, 19118, 1, 0, 0, 0, 19071, 19074, 3, 2078, 1039, 0, 19072, + 19073, 5, 621, 0, 0, 19073, 19075, 5, 801, 0, 0, 19074, 19072, 1, 0, 0, + 0, 19074, 19075, 1, 0, 0, 0, 19075, 19118, 1, 0, 0, 0, 19076, 19077, 5, + 57, 0, 0, 19077, 19078, 5, 2443, 0, 0, 19078, 19079, 5, 2472, 0, 0, 19079, + 19083, 5, 2443, 0, 0, 19080, 19081, 7, 246, 0, 0, 19081, 19082, 5, 1259, + 0, 0, 19082, 19084, 5, 964, 0, 0, 19083, 19080, 1, 0, 0, 0, 19083, 19084, + 1, 0, 0, 0, 19084, 19090, 1, 0, 0, 0, 19085, 19087, 7, 247, 0, 0, 19086, + 19085, 1, 0, 0, 0, 19086, 19087, 1, 0, 0, 0, 19087, 19088, 1, 0, 0, 0, + 19088, 19089, 5, 1259, 0, 0, 19089, 19091, 5, 1228, 0, 0, 19090, 19086, + 1, 0, 0, 0, 19090, 19091, 1, 0, 0, 0, 19091, 19118, 1, 0, 0, 0, 19092, + 19093, 5, 1671, 0, 0, 19093, 19094, 5, 2443, 0, 0, 19094, 19095, 5, 2472, + 0, 0, 19095, 19098, 3, 2078, 1039, 0, 19096, 19097, 5, 621, 0, 0, 19097, + 19099, 5, 801, 0, 0, 19098, 19096, 1, 0, 0, 0, 19098, 19099, 1, 0, 0, 0, + 19099, 19103, 1, 0, 0, 0, 19100, 19101, 7, 244, 0, 0, 19101, 19102, 5, + 1259, 0, 0, 19102, 19104, 5, 544, 0, 0, 19103, 19100, 1, 0, 0, 0, 19103, + 19104, 1, 0, 0, 0, 19104, 19108, 1, 0, 0, 0, 19105, 19106, 7, 246, 0, 0, + 19106, 19107, 5, 1259, 0, 0, 19107, 19109, 5, 964, 0, 0, 19108, 19105, + 1, 0, 0, 0, 19108, 19109, 1, 0, 0, 0, 19109, 19115, 1, 0, 0, 0, 19110, + 19112, 7, 247, 0, 0, 19111, 19110, 1, 0, 0, 0, 19111, 19112, 1, 0, 0, 0, + 19112, 19113, 1, 0, 0, 0, 19113, 19114, 5, 1259, 0, 0, 19114, 19116, 5, + 1228, 0, 0, 19115, 19111, 1, 0, 0, 0, 19115, 19116, 1, 0, 0, 0, 19116, + 19118, 1, 0, 0, 0, 19117, 19030, 1, 0, 0, 0, 19117, 19039, 1, 0, 0, 0, + 19117, 19055, 1, 0, 0, 0, 19117, 19071, 1, 0, 0, 0, 19117, 19076, 1, 0, + 0, 0, 19117, 19092, 1, 0, 0, 0, 19118, 2165, 1, 0, 0, 0, 19119, 19120, + 5, 238, 0, 0, 19120, 19121, 5, 2447, 0, 0, 19121, 19126, 3, 2168, 1084, + 0, 19122, 19123, 5, 2453, 0, 0, 19123, 19125, 3, 2168, 1084, 0, 19124, + 19122, 1, 0, 0, 0, 19125, 19128, 1, 0, 0, 0, 19126, 19124, 1, 0, 0, 0, + 19126, 19127, 1, 0, 0, 0, 19127, 19129, 1, 0, 0, 0, 19128, 19126, 1, 0, + 0, 0, 19129, 19130, 5, 2448, 0, 0, 19130, 2167, 1, 0, 0, 0, 19131, 19133, + 3, 2078, 1039, 0, 19132, 19134, 3, 2182, 1091, 0, 19133, 19132, 1, 0, 0, + 0, 19133, 19134, 1, 0, 0, 0, 19134, 19145, 1, 0, 0, 0, 19135, 19137, 5, + 545, 0, 0, 19136, 19135, 1, 0, 0, 0, 19136, 19137, 1, 0, 0, 0, 19137, 19138, + 1, 0, 0, 0, 19138, 19139, 5, 1363, 0, 0, 19139, 19146, 5, 2443, 0, 0, 19140, + 19143, 5, 2159, 0, 0, 19141, 19142, 5, 1363, 0, 0, 19142, 19144, 5, 2443, + 0, 0, 19143, 19141, 1, 0, 0, 0, 19143, 19144, 1, 0, 0, 0, 19144, 19146, + 1, 0, 0, 0, 19145, 19136, 1, 0, 0, 0, 19145, 19140, 1, 0, 0, 0, 19145, + 19146, 1, 0, 0, 0, 19146, 19148, 1, 0, 0, 0, 19147, 19149, 3, 2176, 1088, + 0, 19148, 19147, 1, 0, 0, 0, 19148, 19149, 1, 0, 0, 0, 19149, 19151, 1, + 0, 0, 0, 19150, 19152, 3, 2178, 1089, 0, 19151, 19150, 1, 0, 0, 0, 19151, + 19152, 1, 0, 0, 0, 19152, 19185, 1, 0, 0, 0, 19153, 19155, 3, 2078, 1039, + 0, 19154, 19156, 3, 2172, 1086, 0, 19155, 19154, 1, 0, 0, 0, 19155, 19156, + 1, 0, 0, 0, 19156, 19158, 1, 0, 0, 0, 19157, 19159, 5, 2159, 0, 0, 19158, + 19157, 1, 0, 0, 0, 19158, 19159, 1, 0, 0, 0, 19159, 19160, 1, 0, 0, 0, + 19160, 19161, 5, 621, 0, 0, 19161, 19163, 5, 801, 0, 0, 19162, 19164, 3, + 2174, 1087, 0, 19163, 19162, 1, 0, 0, 0, 19163, 19164, 1, 0, 0, 0, 19164, + 19165, 1, 0, 0, 0, 19165, 19166, 5, 1363, 0, 0, 19166, 19167, 5, 2443, + 0, 0, 19167, 19185, 1, 0, 0, 0, 19168, 19170, 5, 1013, 0, 0, 19169, 19171, + 5, 1363, 0, 0, 19170, 19169, 1, 0, 0, 0, 19170, 19171, 1, 0, 0, 0, 19171, + 19172, 1, 0, 0, 0, 19172, 19176, 3, 2078, 1039, 0, 19173, 19174, 5, 2473, + 0, 0, 19174, 19175, 5, 2450, 0, 0, 19175, 19177, 5, 2474, 0, 0, 19176, + 19173, 1, 0, 0, 0, 19176, 19177, 1, 0, 0, 0, 19177, 19178, 1, 0, 0, 0, + 19178, 19179, 3, 2166, 1083, 0, 19179, 19185, 1, 0, 0, 0, 19180, 19181, + 3, 2078, 1039, 0, 19181, 19182, 5, 620, 0, 0, 19182, 19183, 5, 1304, 0, + 0, 19183, 19185, 1, 0, 0, 0, 19184, 19131, 1, 0, 0, 0, 19184, 19153, 1, + 0, 0, 0, 19184, 19168, 1, 0, 0, 0, 19184, 19180, 1, 0, 0, 0, 19185, 2169, + 1, 0, 0, 0, 19186, 19187, 5, 1585, 0, 0, 19187, 19189, 3, 2172, 1086, 0, + 19188, 19186, 1, 0, 0, 0, 19188, 19189, 1, 0, 0, 0, 19189, 19191, 1, 0, + 0, 0, 19190, 19192, 5, 1448, 0, 0, 19191, 19190, 1, 0, 0, 0, 19191, 19192, + 1, 0, 0, 0, 19192, 19194, 1, 0, 0, 0, 19193, 19195, 5, 71, 0, 0, 19194, + 19193, 1, 0, 0, 0, 19194, 19195, 1, 0, 0, 0, 19195, 2171, 1, 0, 0, 0, 19196, + 19203, 5, 2259, 0, 0, 19197, 19198, 5, 2447, 0, 0, 19198, 19200, 5, 2441, + 0, 0, 19199, 19201, 7, 238, 0, 0, 19200, 19199, 1, 0, 0, 0, 19200, 19201, + 1, 0, 0, 0, 19201, 19202, 1, 0, 0, 0, 19202, 19204, 5, 2448, 0, 0, 19203, + 19197, 1, 0, 0, 0, 19203, 19204, 1, 0, 0, 0, 19204, 19208, 1, 0, 0, 0, + 19205, 19208, 5, 215, 0, 0, 19206, 19208, 5, 142, 0, 0, 19207, 19196, 1, + 0, 0, 0, 19207, 19205, 1, 0, 0, 0, 19207, 19206, 1, 0, 0, 0, 19208, 2173, + 1, 0, 0, 0, 19209, 19211, 5, 2306, 0, 0, 19210, 19212, 5, 68, 0, 0, 19211, + 19210, 1, 0, 0, 0, 19211, 19212, 1, 0, 0, 0, 19212, 19213, 1, 0, 0, 0, + 19213, 19223, 5, 2312, 0, 0, 19214, 19216, 5, 2308, 0, 0, 19215, 19217, + 7, 248, 0, 0, 19216, 19215, 1, 0, 0, 0, 19216, 19217, 1, 0, 0, 0, 19217, + 19219, 1, 0, 0, 0, 19218, 19220, 5, 68, 0, 0, 19219, 19218, 1, 0, 0, 0, + 19219, 19220, 1, 0, 0, 0, 19220, 19221, 1, 0, 0, 0, 19221, 19223, 5, 2312, + 0, 0, 19222, 19209, 1, 0, 0, 0, 19222, 19214, 1, 0, 0, 0, 19223, 2175, + 1, 0, 0, 0, 19224, 19232, 5, 520, 0, 0, 19225, 19232, 5, 1228, 0, 0, 19226, + 19232, 5, 497, 0, 0, 19227, 19228, 5, 497, 0, 0, 19228, 19232, 5, 68, 0, + 0, 19229, 19230, 5, 497, 0, 0, 19230, 19232, 5, 1238, 0, 0, 19231, 19224, + 1, 0, 0, 0, 19231, 19225, 1, 0, 0, 0, 19231, 19226, 1, 0, 0, 0, 19231, + 19227, 1, 0, 0, 0, 19231, 19229, 1, 0, 0, 0, 19231, 19232, 1, 0, 0, 0, + 19232, 19233, 1, 0, 0, 0, 19233, 19234, 5, 1259, 0, 0, 19234, 19235, 5, + 520, 0, 0, 19235, 2177, 1, 0, 0, 0, 19236, 19244, 5, 520, 0, 0, 19237, + 19244, 5, 1228, 0, 0, 19238, 19244, 5, 497, 0, 0, 19239, 19240, 5, 497, + 0, 0, 19240, 19244, 5, 68, 0, 0, 19241, 19242, 5, 497, 0, 0, 19242, 19244, + 5, 1238, 0, 0, 19243, 19236, 1, 0, 0, 0, 19243, 19237, 1, 0, 0, 0, 19243, + 19238, 1, 0, 0, 0, 19243, 19239, 1, 0, 0, 0, 19243, 19241, 1, 0, 0, 0, + 19243, 19244, 1, 0, 0, 0, 19244, 19245, 1, 0, 0, 0, 19245, 19246, 5, 1259, + 0, 0, 19246, 19247, 5, 497, 0, 0, 19247, 2179, 1, 0, 0, 0, 19248, 19250, + 5, 1585, 0, 0, 19249, 19251, 3, 2182, 1091, 0, 19250, 19249, 1, 0, 0, 0, + 19250, 19251, 1, 0, 0, 0, 19251, 19253, 1, 0, 0, 0, 19252, 19254, 5, 71, + 0, 0, 19253, 19252, 1, 0, 0, 0, 19253, 19254, 1, 0, 0, 0, 19254, 2181, + 1, 0, 0, 0, 19255, 19262, 5, 2259, 0, 0, 19256, 19257, 5, 2447, 0, 0, 19257, + 19259, 5, 2441, 0, 0, 19258, 19260, 7, 238, 0, 0, 19259, 19258, 1, 0, 0, + 0, 19259, 19260, 1, 0, 0, 0, 19260, 19261, 1, 0, 0, 0, 19261, 19263, 5, + 2448, 0, 0, 19262, 19256, 1, 0, 0, 0, 19262, 19263, 1, 0, 0, 0, 19263, + 19265, 1, 0, 0, 0, 19264, 19266, 5, 2159, 0, 0, 19265, 19264, 1, 0, 0, + 0, 19265, 19266, 1, 0, 0, 0, 19266, 19292, 1, 0, 0, 0, 19267, 19292, 5, + 215, 0, 0, 19268, 19292, 5, 361, 0, 0, 19269, 19277, 5, 1230, 0, 0, 19270, + 19271, 5, 2447, 0, 0, 19271, 19274, 5, 769, 0, 0, 19272, 19273, 5, 2453, + 0, 0, 19273, 19275, 5, 769, 0, 0, 19274, 19272, 1, 0, 0, 0, 19274, 19275, + 1, 0, 0, 0, 19275, 19276, 1, 0, 0, 0, 19276, 19278, 5, 2448, 0, 0, 19277, + 19270, 1, 0, 0, 0, 19277, 19278, 1, 0, 0, 0, 19278, 19292, 1, 0, 0, 0, + 19279, 19282, 5, 2108, 0, 0, 19280, 19281, 5, 2308, 0, 0, 19281, 19283, + 5, 2113, 0, 0, 19282, 19280, 1, 0, 0, 0, 19282, 19283, 1, 0, 0, 0, 19283, + 19292, 1, 0, 0, 0, 19284, 19292, 5, 1633, 0, 0, 19285, 19289, 3, 2078, + 1039, 0, 19286, 19287, 5, 2246, 0, 0, 19287, 19288, 5, 182, 0, 0, 19288, + 19290, 5, 911, 0, 0, 19289, 19286, 1, 0, 0, 0, 19289, 19290, 1, 0, 0, 0, + 19290, 19292, 1, 0, 0, 0, 19291, 19255, 1, 0, 0, 0, 19291, 19267, 1, 0, + 0, 0, 19291, 19268, 1, 0, 0, 0, 19291, 19269, 1, 0, 0, 0, 19291, 19279, + 1, 0, 0, 0, 19291, 19284, 1, 0, 0, 0, 19291, 19285, 1, 0, 0, 0, 19292, + 2183, 1, 0, 0, 0, 19293, 19294, 7, 247, 0, 0, 19294, 19295, 5, 1259, 0, + 0, 19295, 19304, 5, 965, 0, 0, 19296, 19297, 5, 2447, 0, 0, 19297, 19298, + 5, 964, 0, 0, 19298, 19305, 5, 351, 0, 0, 19299, 19300, 5, 565, 0, 0, 19300, + 19305, 5, 351, 0, 0, 19301, 19302, 5, 2166, 0, 0, 19302, 19303, 5, 520, + 0, 0, 19303, 19305, 5, 2448, 0, 0, 19304, 19296, 1, 0, 0, 0, 19304, 19299, + 1, 0, 0, 0, 19304, 19301, 1, 0, 0, 0, 19304, 19305, 1, 0, 0, 0, 19305, + 2185, 1, 0, 0, 0, 19306, 19312, 5, 2443, 0, 0, 19307, 19312, 3, 2146, 1073, + 0, 19308, 19312, 3, 2396, 1198, 0, 19309, 19312, 3, 2398, 1199, 0, 19310, + 19312, 5, 932, 0, 0, 19311, 19306, 1, 0, 0, 0, 19311, 19307, 1, 0, 0, 0, + 19311, 19308, 1, 0, 0, 0, 19311, 19309, 1, 0, 0, 0, 19311, 19310, 1, 0, + 0, 0, 19312, 2187, 1, 0, 0, 0, 19313, 19316, 3, 2190, 1095, 0, 19314, 19317, + 3, 2110, 1055, 0, 19315, 19317, 3, 2112, 1056, 0, 19316, 19314, 1, 0, 0, + 0, 19316, 19315, 1, 0, 0, 0, 19316, 19317, 1, 0, 0, 0, 19317, 2189, 1, + 0, 0, 0, 19318, 19319, 5, 2419, 0, 0, 19319, 19321, 5, 2447, 0, 0, 19320, + 19322, 7, 226, 0, 0, 19321, 19320, 1, 0, 0, 0, 19321, 19322, 1, 0, 0, 0, + 19322, 19323, 1, 0, 0, 0, 19323, 19324, 3, 2078, 1039, 0, 19324, 19327, + 5, 2448, 0, 0, 19325, 19328, 3, 2202, 1101, 0, 19326, 19328, 3, 2362, 1181, + 0, 19327, 19325, 1, 0, 0, 0, 19327, 19326, 1, 0, 0, 0, 19327, 19328, 1, + 0, 0, 0, 19328, 19401, 1, 0, 0, 0, 19329, 19330, 5, 313, 0, 0, 19330, 19338, + 5, 2447, 0, 0, 19331, 19339, 5, 2450, 0, 0, 19332, 19334, 7, 209, 0, 0, + 19333, 19332, 1, 0, 0, 0, 19333, 19334, 1, 0, 0, 0, 19334, 19335, 1, 0, + 0, 0, 19335, 19337, 3, 2102, 1051, 0, 19336, 19333, 1, 0, 0, 0, 19336, + 19337, 1, 0, 0, 0, 19337, 19339, 1, 0, 0, 0, 19338, 19331, 1, 0, 0, 0, + 19338, 19336, 1, 0, 0, 0, 19339, 19340, 1, 0, 0, 0, 19340, 19343, 5, 2448, + 0, 0, 19341, 19344, 3, 2202, 1101, 0, 19342, 19344, 3, 2362, 1181, 0, 19343, + 19341, 1, 0, 0, 0, 19343, 19342, 1, 0, 0, 0, 19343, 19344, 1, 0, 0, 0, + 19344, 19401, 1, 0, 0, 0, 19345, 19346, 5, 2414, 0, 0, 19346, 19347, 5, + 2447, 0, 0, 19347, 19353, 3, 2078, 1039, 0, 19348, 19351, 5, 2453, 0, 0, + 19349, 19352, 5, 2441, 0, 0, 19350, 19352, 3, 2078, 1039, 0, 19351, 19349, + 1, 0, 0, 0, 19351, 19350, 1, 0, 0, 0, 19352, 19354, 1, 0, 0, 0, 19353, + 19348, 1, 0, 0, 0, 19353, 19354, 1, 0, 0, 0, 19354, 19355, 1, 0, 0, 0, + 19355, 19356, 5, 2448, 0, 0, 19356, 19401, 1, 0, 0, 0, 19357, 19358, 5, + 2398, 0, 0, 19358, 19360, 5, 2447, 0, 0, 19359, 19361, 7, 226, 0, 0, 19360, + 19359, 1, 0, 0, 0, 19360, 19361, 1, 0, 0, 0, 19361, 19362, 1, 0, 0, 0, + 19362, 19363, 3, 2078, 1039, 0, 19363, 19366, 5, 2448, 0, 0, 19364, 19367, + 3, 2202, 1101, 0, 19365, 19367, 3, 2362, 1181, 0, 19366, 19364, 1, 0, 0, + 0, 19366, 19365, 1, 0, 0, 0, 19366, 19367, 1, 0, 0, 0, 19367, 19401, 1, + 0, 0, 0, 19368, 19369, 5, 2409, 0, 0, 19369, 19371, 5, 2447, 0, 0, 19370, + 19372, 7, 226, 0, 0, 19371, 19370, 1, 0, 0, 0, 19371, 19372, 1, 0, 0, 0, + 19372, 19373, 1, 0, 0, 0, 19373, 19374, 3, 2078, 1039, 0, 19374, 19377, + 5, 2448, 0, 0, 19375, 19378, 3, 2202, 1101, 0, 19376, 19378, 3, 2362, 1181, + 0, 19377, 19375, 1, 0, 0, 0, 19377, 19376, 1, 0, 0, 0, 19377, 19378, 1, + 0, 0, 0, 19378, 19401, 1, 0, 0, 0, 19379, 19380, 5, 2406, 0, 0, 19380, + 19382, 5, 2447, 0, 0, 19381, 19383, 7, 226, 0, 0, 19382, 19381, 1, 0, 0, + 0, 19382, 19383, 1, 0, 0, 0, 19383, 19384, 1, 0, 0, 0, 19384, 19385, 3, + 2078, 1039, 0, 19385, 19388, 5, 2448, 0, 0, 19386, 19389, 3, 2202, 1101, + 0, 19387, 19389, 3, 2362, 1181, 0, 19388, 19386, 1, 0, 0, 0, 19388, 19387, + 1, 0, 0, 0, 19388, 19389, 1, 0, 0, 0, 19389, 19401, 1, 0, 0, 0, 19390, + 19391, 5, 2423, 0, 0, 19391, 19392, 5, 2447, 0, 0, 19392, 19393, 3, 2076, + 1038, 0, 19393, 19394, 5, 2448, 0, 0, 19394, 19401, 1, 0, 0, 0, 19395, + 19396, 5, 2424, 0, 0, 19396, 19397, 5, 2447, 0, 0, 19397, 19398, 3, 2076, + 1038, 0, 19398, 19399, 5, 2448, 0, 0, 19399, 19401, 1, 0, 0, 0, 19400, + 19318, 1, 0, 0, 0, 19400, 19329, 1, 0, 0, 0, 19400, 19345, 1, 0, 0, 0, + 19400, 19357, 1, 0, 0, 0, 19400, 19368, 1, 0, 0, 0, 19400, 19379, 1, 0, + 0, 0, 19400, 19390, 1, 0, 0, 0, 19400, 19395, 1, 0, 0, 0, 19401, 2191, + 1, 0, 0, 0, 19402, 19403, 5, 1259, 0, 0, 19403, 19404, 5, 1320, 0, 0, 19404, + 19406, 7, 229, 0, 0, 19405, 19407, 5, 2443, 0, 0, 19406, 19405, 1, 0, 0, + 0, 19406, 19407, 1, 0, 0, 0, 19407, 19410, 1, 0, 0, 0, 19408, 19409, 7, + 2, 0, 0, 19409, 19411, 5, 313, 0, 0, 19410, 19408, 1, 0, 0, 0, 19410, 19411, + 1, 0, 0, 0, 19411, 2193, 1, 0, 0, 0, 19412, 19413, 3, 2196, 1098, 0, 19413, + 19415, 3, 2366, 1183, 0, 19414, 19416, 3, 2202, 1101, 0, 19415, 19414, + 1, 0, 0, 0, 19415, 19416, 1, 0, 0, 0, 19416, 19834, 1, 0, 0, 0, 19417, + 19418, 3, 2410, 1205, 0, 19418, 19420, 3, 2368, 1184, 0, 19419, 19421, + 3, 2210, 1105, 0, 19420, 19419, 1, 0, 0, 0, 19420, 19421, 1, 0, 0, 0, 19421, + 19834, 1, 0, 0, 0, 19422, 19423, 5, 313, 0, 0, 19423, 19429, 5, 2447, 0, + 0, 19424, 19430, 5, 2450, 0, 0, 19425, 19427, 7, 209, 0, 0, 19426, 19425, + 1, 0, 0, 0, 19426, 19427, 1, 0, 0, 0, 19427, 19428, 1, 0, 0, 0, 19428, + 19430, 3, 2102, 1051, 0, 19429, 19424, 1, 0, 0, 0, 19429, 19426, 1, 0, + 0, 0, 19430, 19431, 1, 0, 0, 0, 19431, 19433, 5, 2448, 0, 0, 19432, 19434, + 3, 2202, 1101, 0, 19433, 19432, 1, 0, 0, 0, 19433, 19434, 1, 0, 0, 0, 19434, + 19834, 1, 0, 0, 0, 19435, 19436, 7, 249, 0, 0, 19436, 19443, 5, 2447, 0, + 0, 19437, 19438, 5, 994, 0, 0, 19438, 19439, 5, 2447, 0, 0, 19439, 19440, + 3, 1896, 948, 0, 19440, 19441, 5, 2448, 0, 0, 19441, 19444, 1, 0, 0, 0, + 19442, 19444, 3, 2102, 1051, 0, 19443, 19437, 1, 0, 0, 0, 19443, 19442, + 1, 0, 0, 0, 19444, 19445, 1, 0, 0, 0, 19445, 19446, 5, 69, 0, 0, 19446, + 19453, 3, 2374, 1187, 0, 19447, 19448, 5, 389, 0, 0, 19448, 19449, 3, 2102, + 1051, 0, 19449, 19450, 5, 1259, 0, 0, 19450, 19451, 5, 301, 0, 0, 19451, + 19452, 5, 520, 0, 0, 19452, 19454, 1, 0, 0, 0, 19453, 19447, 1, 0, 0, 0, + 19453, 19454, 1, 0, 0, 0, 19454, 19461, 1, 0, 0, 0, 19455, 19456, 5, 2453, + 0, 0, 19456, 19459, 3, 2400, 1200, 0, 19457, 19458, 5, 2453, 0, 0, 19458, + 19460, 3, 2400, 1200, 0, 19459, 19457, 1, 0, 0, 0, 19459, 19460, 1, 0, + 0, 0, 19460, 19462, 1, 0, 0, 0, 19461, 19455, 1, 0, 0, 0, 19461, 19462, + 1, 0, 0, 0, 19462, 19463, 1, 0, 0, 0, 19463, 19464, 5, 2448, 0, 0, 19464, + 19834, 1, 0, 0, 0, 19465, 19466, 5, 228, 0, 0, 19466, 19467, 5, 2447, 0, + 0, 19467, 19473, 3, 2388, 1194, 0, 19468, 19471, 5, 2453, 0, 0, 19469, + 19472, 3, 2396, 1198, 0, 19470, 19472, 3, 2400, 1200, 0, 19471, 19469, + 1, 0, 0, 0, 19471, 19470, 1, 0, 0, 0, 19472, 19474, 1, 0, 0, 0, 19473, + 19468, 1, 0, 0, 0, 19473, 19474, 1, 0, 0, 0, 19474, 19475, 1, 0, 0, 0, + 19475, 19476, 5, 2448, 0, 0, 19476, 19834, 1, 0, 0, 0, 19477, 19478, 5, + 233, 0, 0, 19478, 19480, 5, 2447, 0, 0, 19479, 19481, 7, 250, 0, 0, 19480, + 19479, 1, 0, 0, 0, 19480, 19481, 1, 0, 0, 0, 19481, 19482, 1, 0, 0, 0, + 19482, 19484, 3, 2102, 1051, 0, 19483, 19485, 3, 2216, 1108, 0, 19484, + 19483, 1, 0, 0, 0, 19484, 19485, 1, 0, 0, 0, 19485, 19486, 1, 0, 0, 0, + 19486, 19487, 5, 2448, 0, 0, 19487, 19834, 1, 0, 0, 0, 19488, 19489, 3, + 2198, 1099, 0, 19489, 19491, 3, 2364, 1182, 0, 19490, 19492, 3, 2218, 1109, + 0, 19491, 19490, 1, 0, 0, 0, 19492, 19493, 1, 0, 0, 0, 19493, 19491, 1, + 0, 0, 0, 19493, 19494, 1, 0, 0, 0, 19494, 19834, 1, 0, 0, 0, 19495, 19496, + 5, 2393, 0, 0, 19496, 19498, 5, 2447, 0, 0, 19497, 19499, 7, 209, 0, 0, + 19498, 19497, 1, 0, 0, 0, 19498, 19499, 1, 0, 0, 0, 19499, 19500, 1, 0, + 0, 0, 19500, 19503, 3, 2372, 1186, 0, 19501, 19502, 5, 2453, 0, 0, 19502, + 19504, 3, 2078, 1039, 0, 19503, 19501, 1, 0, 0, 0, 19503, 19504, 1, 0, + 0, 0, 19504, 19506, 1, 0, 0, 0, 19505, 19507, 3, 2192, 1096, 0, 19506, + 19505, 1, 0, 0, 0, 19506, 19507, 1, 0, 0, 0, 19507, 19508, 1, 0, 0, 0, + 19508, 19515, 5, 2448, 0, 0, 19509, 19510, 5, 2305, 0, 0, 19510, 19511, + 5, 649, 0, 0, 19511, 19512, 5, 2447, 0, 0, 19512, 19513, 3, 1994, 997, + 0, 19513, 19514, 5, 2448, 0, 0, 19514, 19516, 1, 0, 0, 0, 19515, 19509, + 1, 0, 0, 0, 19515, 19516, 1, 0, 0, 0, 19516, 19518, 1, 0, 0, 0, 19517, + 19519, 3, 2202, 1101, 0, 19518, 19517, 1, 0, 0, 0, 19518, 19519, 1, 0, + 0, 0, 19519, 19834, 1, 0, 0, 0, 19520, 19521, 3, 2330, 1165, 0, 19521, + 19522, 7, 251, 0, 0, 19522, 19834, 1, 0, 0, 0, 19523, 19524, 5, 383, 0, + 0, 19524, 19525, 5, 2447, 0, 0, 19525, 19527, 3, 2102, 1051, 0, 19526, + 19528, 7, 252, 0, 0, 19527, 19526, 1, 0, 0, 0, 19527, 19528, 1, 0, 0, 0, + 19528, 19529, 1, 0, 0, 0, 19529, 19530, 5, 2448, 0, 0, 19530, 19834, 1, + 0, 0, 0, 19531, 19532, 5, 563, 0, 0, 19532, 19533, 5, 2447, 0, 0, 19533, + 19534, 3, 2410, 1205, 0, 19534, 19535, 5, 628, 0, 0, 19535, 19536, 3, 2102, + 1051, 0, 19536, 19537, 5, 2448, 0, 0, 19537, 19834, 1, 0, 0, 0, 19538, + 19539, 7, 253, 0, 0, 19539, 19541, 3, 2366, 1183, 0, 19540, 19542, 3, 2370, + 1185, 0, 19541, 19540, 1, 0, 0, 0, 19541, 19542, 1, 0, 0, 0, 19542, 19543, + 1, 0, 0, 0, 19543, 19544, 3, 2202, 1101, 0, 19544, 19834, 1, 0, 0, 0, 19545, + 19546, 7, 254, 0, 0, 19546, 19548, 3, 2366, 1183, 0, 19547, 19549, 3, 2370, + 1185, 0, 19548, 19547, 1, 0, 0, 0, 19548, 19549, 1, 0, 0, 0, 19549, 19550, + 1, 0, 0, 0, 19550, 19551, 3, 2202, 1101, 0, 19551, 19834, 1, 0, 0, 0, 19552, + 19553, 3, 2200, 1100, 0, 19553, 19554, 5, 2447, 0, 0, 19554, 19556, 3, + 2076, 1038, 0, 19555, 19557, 3, 2222, 1111, 0, 19556, 19555, 1, 0, 0, 0, + 19556, 19557, 1, 0, 0, 0, 19557, 19559, 1, 0, 0, 0, 19558, 19560, 3, 2210, + 1105, 0, 19559, 19558, 1, 0, 0, 0, 19559, 19560, 1, 0, 0, 0, 19560, 19561, + 1, 0, 0, 0, 19561, 19562, 5, 2448, 0, 0, 19562, 19834, 1, 0, 0, 0, 19563, + 19564, 7, 255, 0, 0, 19564, 19565, 5, 2447, 0, 0, 19565, 19572, 3, 2102, + 1051, 0, 19566, 19567, 5, 389, 0, 0, 19567, 19568, 3, 2102, 1051, 0, 19568, + 19569, 5, 1259, 0, 0, 19569, 19570, 5, 301, 0, 0, 19570, 19571, 5, 520, + 0, 0, 19571, 19573, 1, 0, 0, 0, 19572, 19566, 1, 0, 0, 0, 19572, 19573, + 1, 0, 0, 0, 19573, 19580, 1, 0, 0, 0, 19574, 19575, 5, 2453, 0, 0, 19575, + 19578, 3, 2400, 1200, 0, 19576, 19577, 5, 2453, 0, 0, 19577, 19579, 3, + 2400, 1200, 0, 19578, 19576, 1, 0, 0, 0, 19578, 19579, 1, 0, 0, 0, 19579, + 19581, 1, 0, 0, 0, 19580, 19574, 1, 0, 0, 0, 19580, 19581, 1, 0, 0, 0, + 19581, 19582, 1, 0, 0, 0, 19582, 19583, 5, 2448, 0, 0, 19583, 19834, 1, + 0, 0, 0, 19584, 19585, 7, 256, 0, 0, 19585, 19586, 5, 2447, 0, 0, 19586, + 19593, 3, 2102, 1051, 0, 19587, 19588, 5, 389, 0, 0, 19588, 19589, 3, 2102, + 1051, 0, 19589, 19590, 5, 1259, 0, 0, 19590, 19591, 5, 301, 0, 0, 19591, + 19592, 5, 520, 0, 0, 19592, 19594, 1, 0, 0, 0, 19593, 19587, 1, 0, 0, 0, + 19593, 19594, 1, 0, 0, 0, 19594, 19595, 1, 0, 0, 0, 19595, 19596, 5, 2448, + 0, 0, 19596, 19834, 1, 0, 0, 0, 19597, 19598, 5, 2153, 0, 0, 19598, 19599, + 5, 2447, 0, 0, 19599, 19602, 3, 2078, 1039, 0, 19600, 19601, 5, 2246, 0, + 0, 19601, 19603, 7, 257, 0, 0, 19602, 19600, 1, 0, 0, 0, 19602, 19603, + 1, 0, 0, 0, 19603, 19608, 1, 0, 0, 0, 19604, 19605, 5, 2453, 0, 0, 19605, + 19607, 3, 2078, 1039, 0, 19606, 19604, 1, 0, 0, 0, 19607, 19610, 1, 0, + 0, 0, 19608, 19606, 1, 0, 0, 0, 19608, 19609, 1, 0, 0, 0, 19609, 19611, + 1, 0, 0, 0, 19610, 19608, 1, 0, 0, 0, 19611, 19612, 5, 2448, 0, 0, 19612, + 19834, 1, 0, 0, 0, 19613, 19614, 5, 2155, 0, 0, 19614, 19615, 5, 2447, + 0, 0, 19615, 19616, 3, 2078, 1039, 0, 19616, 19618, 5, 69, 0, 0, 19617, + 19619, 5, 1530, 0, 0, 19618, 19617, 1, 0, 0, 0, 19618, 19619, 1, 0, 0, + 0, 19619, 19620, 1, 0, 0, 0, 19620, 19621, 3, 2374, 1187, 0, 19621, 19626, + 5, 2448, 0, 0, 19622, 19623, 5, 2440, 0, 0, 19623, 19625, 3, 2386, 1193, + 0, 19624, 19622, 1, 0, 0, 0, 19625, 19628, 1, 0, 0, 0, 19626, 19624, 1, + 0, 0, 0, 19626, 19627, 1, 0, 0, 0, 19627, 19834, 1, 0, 0, 0, 19628, 19626, + 1, 0, 0, 0, 19629, 19630, 5, 2418, 0, 0, 19630, 19638, 5, 2447, 0, 0, 19631, + 19633, 7, 236, 0, 0, 19632, 19631, 1, 0, 0, 0, 19632, 19633, 1, 0, 0, 0, + 19633, 19635, 1, 0, 0, 0, 19634, 19636, 3, 2400, 1200, 0, 19635, 19634, + 1, 0, 0, 0, 19635, 19636, 1, 0, 0, 0, 19636, 19637, 1, 0, 0, 0, 19637, + 19639, 5, 628, 0, 0, 19638, 19632, 1, 0, 0, 0, 19638, 19639, 1, 0, 0, 0, + 19639, 19640, 1, 0, 0, 0, 19640, 19641, 3, 2102, 1051, 0, 19641, 19642, + 5, 2448, 0, 0, 19642, 19834, 1, 0, 0, 0, 19643, 19644, 5, 2254, 0, 0, 19644, + 19645, 5, 2447, 0, 0, 19645, 19646, 3, 2102, 1051, 0, 19646, 19647, 5, + 69, 0, 0, 19647, 19654, 3, 2374, 1187, 0, 19648, 19649, 5, 2453, 0, 0, + 19649, 19652, 3, 2400, 1200, 0, 19650, 19651, 5, 2453, 0, 0, 19651, 19653, + 3, 2400, 1200, 0, 19652, 19650, 1, 0, 0, 0, 19652, 19653, 1, 0, 0, 0, 19653, + 19655, 1, 0, 0, 0, 19654, 19648, 1, 0, 0, 0, 19654, 19655, 1, 0, 0, 0, + 19655, 19656, 1, 0, 0, 0, 19656, 19657, 5, 2448, 0, 0, 19657, 19834, 1, + 0, 0, 0, 19658, 19659, 5, 2319, 0, 0, 19659, 19660, 5, 2447, 0, 0, 19660, + 19662, 3, 2078, 1039, 0, 19661, 19663, 3, 1994, 997, 0, 19662, 19661, 1, + 0, 0, 0, 19662, 19663, 1, 0, 0, 0, 19663, 19664, 1, 0, 0, 0, 19664, 19669, + 5, 2448, 0, 0, 19665, 19666, 5, 2440, 0, 0, 19666, 19668, 3, 2386, 1193, + 0, 19667, 19665, 1, 0, 0, 0, 19668, 19671, 1, 0, 0, 0, 19669, 19667, 1, + 0, 0, 0, 19669, 19670, 1, 0, 0, 0, 19670, 19834, 1, 0, 0, 0, 19671, 19669, + 1, 0, 0, 0, 19672, 19673, 7, 258, 0, 0, 19673, 19674, 5, 2447, 0, 0, 19674, + 19679, 3, 2234, 1117, 0, 19675, 19676, 5, 2453, 0, 0, 19676, 19678, 3, + 2234, 1117, 0, 19677, 19675, 1, 0, 0, 0, 19678, 19681, 1, 0, 0, 0, 19679, + 19677, 1, 0, 0, 0, 19679, 19680, 1, 0, 0, 0, 19680, 19682, 1, 0, 0, 0, + 19681, 19679, 1, 0, 0, 0, 19682, 19687, 5, 2448, 0, 0, 19683, 19684, 5, + 2440, 0, 0, 19684, 19686, 3, 2386, 1193, 0, 19685, 19683, 1, 0, 0, 0, 19686, + 19689, 1, 0, 0, 0, 19687, 19685, 1, 0, 0, 0, 19687, 19688, 1, 0, 0, 0, + 19688, 19834, 1, 0, 0, 0, 19689, 19687, 1, 0, 0, 0, 19690, 19691, 5, 2328, + 0, 0, 19691, 19693, 5, 2447, 0, 0, 19692, 19694, 7, 259, 0, 0, 19693, 19692, + 1, 0, 0, 0, 19693, 19694, 1, 0, 0, 0, 19694, 19696, 1, 0, 0, 0, 19695, + 19697, 7, 260, 0, 0, 19696, 19695, 1, 0, 0, 0, 19696, 19697, 1, 0, 0, 0, + 19697, 19698, 1, 0, 0, 0, 19698, 19701, 3, 2078, 1039, 0, 19699, 19700, + 5, 2453, 0, 0, 19700, 19702, 3, 2226, 1113, 0, 19701, 19699, 1, 0, 0, 0, + 19701, 19702, 1, 0, 0, 0, 19702, 19710, 1, 0, 0, 0, 19703, 19704, 5, 2453, + 0, 0, 19704, 19706, 3, 2078, 1039, 0, 19705, 19707, 3, 2268, 1134, 0, 19706, + 19705, 1, 0, 0, 0, 19706, 19707, 1, 0, 0, 0, 19707, 19709, 1, 0, 0, 0, + 19708, 19703, 1, 0, 0, 0, 19709, 19712, 1, 0, 0, 0, 19710, 19708, 1, 0, + 0, 0, 19710, 19711, 1, 0, 0, 0, 19711, 19713, 1, 0, 0, 0, 19712, 19710, + 1, 0, 0, 0, 19713, 19718, 5, 2448, 0, 0, 19714, 19715, 5, 2440, 0, 0, 19715, + 19717, 3, 2386, 1193, 0, 19716, 19714, 1, 0, 0, 0, 19717, 19720, 1, 0, + 0, 0, 19718, 19716, 1, 0, 0, 0, 19718, 19719, 1, 0, 0, 0, 19719, 19834, + 1, 0, 0, 0, 19720, 19718, 1, 0, 0, 0, 19721, 19722, 5, 2330, 0, 0, 19722, + 19723, 5, 2447, 0, 0, 19723, 19725, 3, 2078, 1039, 0, 19724, 19726, 3, + 2224, 1112, 0, 19725, 19724, 1, 0, 0, 0, 19725, 19726, 1, 0, 0, 0, 19726, + 19727, 1, 0, 0, 0, 19727, 19728, 5, 2448, 0, 0, 19728, 19834, 1, 0, 0, + 0, 19729, 19730, 5, 2339, 0, 0, 19730, 19731, 5, 2447, 0, 0, 19731, 19732, + 7, 261, 0, 0, 19732, 19734, 3, 2102, 1051, 0, 19733, 19735, 5, 2298, 0, + 0, 19734, 19733, 1, 0, 0, 0, 19734, 19735, 1, 0, 0, 0, 19735, 19736, 1, + 0, 0, 0, 19736, 19741, 5, 2448, 0, 0, 19737, 19738, 5, 2440, 0, 0, 19738, + 19740, 3, 2386, 1193, 0, 19739, 19737, 1, 0, 0, 0, 19740, 19743, 1, 0, + 0, 0, 19741, 19739, 1, 0, 0, 0, 19741, 19742, 1, 0, 0, 0, 19742, 19834, + 1, 0, 0, 0, 19743, 19741, 1, 0, 0, 0, 19744, 19745, 5, 2341, 0, 0, 19745, + 19750, 5, 2447, 0, 0, 19746, 19747, 5, 997, 0, 0, 19747, 19751, 3, 2402, + 1201, 0, 19748, 19749, 5, 529, 0, 0, 19749, 19751, 3, 2102, 1051, 0, 19750, + 19746, 1, 0, 0, 0, 19750, 19748, 1, 0, 0, 0, 19751, 19754, 1, 0, 0, 0, + 19752, 19753, 5, 2453, 0, 0, 19753, 19755, 3, 2102, 1051, 0, 19754, 19752, + 1, 0, 0, 0, 19754, 19755, 1, 0, 0, 0, 19755, 19756, 1, 0, 0, 0, 19756, + 19761, 5, 2448, 0, 0, 19757, 19758, 5, 2440, 0, 0, 19758, 19760, 3, 2386, + 1193, 0, 19759, 19757, 1, 0, 0, 0, 19760, 19763, 1, 0, 0, 0, 19761, 19759, + 1, 0, 0, 0, 19761, 19762, 1, 0, 0, 0, 19762, 19834, 1, 0, 0, 0, 19763, + 19761, 1, 0, 0, 0, 19764, 19765, 5, 2343, 0, 0, 19765, 19766, 5, 2447, + 0, 0, 19766, 19768, 3, 2102, 1051, 0, 19767, 19769, 3, 2224, 1112, 0, 19768, + 19767, 1, 0, 0, 0, 19768, 19769, 1, 0, 0, 0, 19769, 19770, 1, 0, 0, 0, + 19770, 19771, 5, 1585, 0, 0, 19771, 19775, 5, 294, 0, 0, 19772, 19773, + 5, 1228, 0, 0, 19773, 19774, 5, 1259, 0, 0, 19774, 19776, 5, 497, 0, 0, + 19775, 19772, 1, 0, 0, 0, 19775, 19776, 1, 0, 0, 0, 19776, 19777, 1, 0, + 0, 0, 19777, 19782, 5, 2448, 0, 0, 19778, 19779, 5, 2440, 0, 0, 19779, + 19781, 3, 2386, 1193, 0, 19780, 19778, 1, 0, 0, 0, 19781, 19784, 1, 0, + 0, 0, 19782, 19780, 1, 0, 0, 0, 19782, 19783, 1, 0, 0, 0, 19783, 19834, + 1, 0, 0, 0, 19784, 19782, 1, 0, 0, 0, 19785, 19786, 5, 2344, 0, 0, 19786, + 19787, 5, 2447, 0, 0, 19787, 19790, 3, 2102, 1051, 0, 19788, 19789, 5, + 2453, 0, 0, 19789, 19791, 3, 2236, 1118, 0, 19790, 19788, 1, 0, 0, 0, 19790, + 19791, 1, 0, 0, 0, 19791, 19794, 1, 0, 0, 0, 19792, 19793, 5, 2453, 0, + 0, 19793, 19795, 3, 2238, 1119, 0, 19794, 19792, 1, 0, 0, 0, 19794, 19795, + 1, 0, 0, 0, 19795, 19796, 1, 0, 0, 0, 19796, 19801, 5, 2448, 0, 0, 19797, + 19798, 5, 2440, 0, 0, 19798, 19800, 3, 2386, 1193, 0, 19799, 19797, 1, + 0, 0, 0, 19800, 19803, 1, 0, 0, 0, 19801, 19799, 1, 0, 0, 0, 19801, 19802, + 1, 0, 0, 0, 19802, 19834, 1, 0, 0, 0, 19803, 19801, 1, 0, 0, 0, 19804, + 19805, 5, 2346, 0, 0, 19805, 19806, 5, 2447, 0, 0, 19806, 19807, 7, 261, + 0, 0, 19807, 19810, 3, 2102, 1051, 0, 19808, 19809, 5, 69, 0, 0, 19809, + 19811, 3, 2374, 1187, 0, 19810, 19808, 1, 0, 0, 0, 19810, 19811, 1, 0, + 0, 0, 19811, 19813, 1, 0, 0, 0, 19812, 19814, 3, 2240, 1120, 0, 19813, + 19812, 1, 0, 0, 0, 19813, 19814, 1, 0, 0, 0, 19814, 19816, 1, 0, 0, 0, + 19815, 19817, 3, 2242, 1121, 0, 19816, 19815, 1, 0, 0, 0, 19816, 19817, + 1, 0, 0, 0, 19817, 19819, 1, 0, 0, 0, 19818, 19820, 3, 2244, 1122, 0, 19819, + 19818, 1, 0, 0, 0, 19819, 19820, 1, 0, 0, 0, 19820, 19823, 1, 0, 0, 0, + 19821, 19822, 7, 262, 0, 0, 19822, 19824, 5, 391, 0, 0, 19823, 19821, 1, + 0, 0, 0, 19823, 19824, 1, 0, 0, 0, 19824, 19825, 1, 0, 0, 0, 19825, 19828, + 5, 2448, 0, 0, 19826, 19827, 5, 2440, 0, 0, 19827, 19829, 3, 2386, 1193, + 0, 19828, 19826, 1, 0, 0, 0, 19828, 19829, 1, 0, 0, 0, 19829, 19834, 1, + 0, 0, 0, 19830, 19831, 5, 2112, 0, 0, 19831, 19834, 5, 2443, 0, 0, 19832, + 19834, 3, 2344, 1172, 0, 19833, 19412, 1, 0, 0, 0, 19833, 19417, 1, 0, + 0, 0, 19833, 19422, 1, 0, 0, 0, 19833, 19435, 1, 0, 0, 0, 19833, 19465, + 1, 0, 0, 0, 19833, 19477, 1, 0, 0, 0, 19833, 19488, 1, 0, 0, 0, 19833, + 19495, 1, 0, 0, 0, 19833, 19520, 1, 0, 0, 0, 19833, 19523, 1, 0, 0, 0, + 19833, 19531, 1, 0, 0, 0, 19833, 19538, 1, 0, 0, 0, 19833, 19545, 1, 0, + 0, 0, 19833, 19552, 1, 0, 0, 0, 19833, 19563, 1, 0, 0, 0, 19833, 19584, + 1, 0, 0, 0, 19833, 19597, 1, 0, 0, 0, 19833, 19613, 1, 0, 0, 0, 19833, + 19629, 1, 0, 0, 0, 19833, 19643, 1, 0, 0, 0, 19833, 19658, 1, 0, 0, 0, + 19833, 19672, 1, 0, 0, 0, 19833, 19690, 1, 0, 0, 0, 19833, 19721, 1, 0, + 0, 0, 19833, 19729, 1, 0, 0, 0, 19833, 19744, 1, 0, 0, 0, 19833, 19764, + 1, 0, 0, 0, 19833, 19785, 1, 0, 0, 0, 19833, 19804, 1, 0, 0, 0, 19833, + 19830, 1, 0, 0, 0, 19833, 19832, 1, 0, 0, 0, 19834, 2195, 1, 0, 0, 0, 19835, + 19836, 7, 263, 0, 0, 19836, 2197, 1, 0, 0, 0, 19837, 19838, 7, 264, 0, + 0, 19838, 2199, 1, 0, 0, 0, 19839, 19840, 7, 265, 0, 0, 19840, 2201, 1, + 0, 0, 0, 19841, 19842, 5, 1322, 0, 0, 19842, 19863, 5, 2447, 0, 0, 19843, + 19845, 3, 1926, 963, 0, 19844, 19843, 1, 0, 0, 0, 19844, 19845, 1, 0, 0, + 0, 19845, 19850, 1, 0, 0, 0, 19846, 19848, 3, 1994, 997, 0, 19847, 19849, + 3, 2204, 1102, 0, 19848, 19847, 1, 0, 0, 0, 19848, 19849, 1, 0, 0, 0, 19849, + 19851, 1, 0, 0, 0, 19850, 19846, 1, 0, 0, 0, 19850, 19851, 1, 0, 0, 0, + 19851, 19864, 1, 0, 0, 0, 19852, 19853, 5, 674, 0, 0, 19853, 19854, 3, + 2404, 1202, 0, 19854, 19855, 5, 1245, 0, 0, 19855, 19861, 3, 2396, 1198, + 0, 19856, 19857, 5, 10, 0, 0, 19857, 19858, 5, 47, 0, 0, 19858, 19859, + 5, 82, 0, 0, 19859, 19860, 5, 846, 0, 0, 19860, 19862, 3, 2404, 1202, 0, + 19861, 19856, 1, 0, 0, 0, 19861, 19862, 1, 0, 0, 0, 19862, 19864, 1, 0, + 0, 0, 19863, 19844, 1, 0, 0, 0, 19863, 19852, 1, 0, 0, 0, 19864, 19865, + 1, 0, 0, 0, 19865, 19866, 5, 2448, 0, 0, 19866, 2203, 1, 0, 0, 0, 19867, + 19874, 3, 2206, 1103, 0, 19868, 19869, 5, 118, 0, 0, 19869, 19870, 3, 2208, + 1104, 0, 19870, 19871, 5, 49, 0, 0, 19871, 19872, 3, 2208, 1104, 0, 19872, + 19875, 1, 0, 0, 0, 19873, 19875, 3, 2208, 1104, 0, 19874, 19868, 1, 0, + 0, 0, 19874, 19873, 1, 0, 0, 0, 19875, 2205, 1, 0, 0, 0, 19876, 19877, + 7, 266, 0, 0, 19877, 2207, 1, 0, 0, 0, 19878, 19879, 5, 2174, 0, 0, 19879, + 19886, 5, 1436, 0, 0, 19880, 19881, 5, 336, 0, 0, 19881, 19886, 5, 1606, + 0, 0, 19882, 19883, 3, 2102, 1051, 0, 19883, 19884, 7, 267, 0, 0, 19884, + 19886, 1, 0, 0, 0, 19885, 19878, 1, 0, 0, 0, 19885, 19880, 1, 0, 0, 0, + 19885, 19882, 1, 0, 0, 0, 19886, 2209, 1, 0, 0, 0, 19887, 19897, 5, 2246, + 0, 0, 19888, 19898, 5, 2450, 0, 0, 19889, 19894, 3, 2212, 1106, 0, 19890, + 19891, 5, 2453, 0, 0, 19891, 19893, 3, 2212, 1106, 0, 19892, 19890, 1, + 0, 0, 0, 19893, 19896, 1, 0, 0, 0, 19894, 19892, 1, 0, 0, 0, 19894, 19895, + 1, 0, 0, 0, 19895, 19898, 1, 0, 0, 0, 19896, 19894, 1, 0, 0, 0, 19897, + 19888, 1, 0, 0, 0, 19897, 19889, 1, 0, 0, 0, 19898, 2211, 1, 0, 0, 0, 19899, + 19900, 5, 738, 0, 0, 19900, 19908, 3, 2078, 1039, 0, 19901, 19902, 5, 738, + 0, 0, 19902, 19903, 5, 1318, 0, 0, 19903, 19908, 3, 2214, 1107, 0, 19904, + 19905, 5, 1318, 0, 0, 19905, 19908, 3, 2214, 1107, 0, 19906, 19908, 3, + 2078, 1039, 0, 19907, 19899, 1, 0, 0, 0, 19907, 19901, 1, 0, 0, 0, 19907, + 19904, 1, 0, 0, 0, 19907, 19906, 1, 0, 0, 0, 19908, 2213, 1, 0, 0, 0, 19909, + 19912, 3, 2384, 1192, 0, 19910, 19912, 3, 2382, 1191, 0, 19911, 19909, + 1, 0, 0, 0, 19911, 19910, 1, 0, 0, 0, 19912, 2215, 1, 0, 0, 0, 19913, 19914, + 5, 1303, 0, 0, 19914, 19915, 5, 160, 0, 0, 19915, 19920, 3, 2102, 1051, + 0, 19916, 19917, 5, 2453, 0, 0, 19917, 19919, 3, 2102, 1051, 0, 19918, + 19916, 1, 0, 0, 0, 19919, 19922, 1, 0, 0, 0, 19920, 19918, 1, 0, 0, 0, + 19920, 19921, 1, 0, 0, 0, 19921, 2217, 1, 0, 0, 0, 19922, 19920, 1, 0, + 0, 0, 19923, 19924, 5, 2305, 0, 0, 19924, 19925, 5, 649, 0, 0, 19925, 19926, + 5, 2447, 0, 0, 19926, 19927, 3, 1994, 997, 0, 19927, 19928, 5, 2448, 0, + 0, 19928, 19931, 1, 0, 0, 0, 19929, 19931, 3, 2202, 1101, 0, 19930, 19923, + 1, 0, 0, 0, 19930, 19929, 1, 0, 0, 0, 19931, 2219, 1, 0, 0, 0, 19932, 19933, + 6, 1110, -1, 0, 19933, 19941, 5, 2443, 0, 0, 19934, 19941, 3, 2146, 1073, + 0, 19935, 19936, 5, 2447, 0, 0, 19936, 19937, 3, 2220, 1110, 0, 19937, + 19938, 5, 2448, 0, 0, 19938, 19941, 1, 0, 0, 0, 19939, 19941, 3, 2404, + 1202, 0, 19940, 19932, 1, 0, 0, 0, 19940, 19934, 1, 0, 0, 0, 19940, 19935, + 1, 0, 0, 0, 19940, 19939, 1, 0, 0, 0, 19941, 19948, 1, 0, 0, 0, 19942, + 19943, 10, 3, 0, 0, 19943, 19944, 5, 2471, 0, 0, 19944, 19945, 5, 2471, + 0, 0, 19945, 19947, 3, 2220, 1110, 4, 19946, 19942, 1, 0, 0, 0, 19947, + 19950, 1, 0, 0, 0, 19948, 19946, 1, 0, 0, 0, 19948, 19949, 1, 0, 0, 0, + 19949, 2221, 1, 0, 0, 0, 19950, 19948, 1, 0, 0, 0, 19951, 19973, 5, 311, + 0, 0, 19952, 19954, 5, 971, 0, 0, 19953, 19955, 5, 91, 0, 0, 19954, 19953, + 1, 0, 0, 0, 19954, 19955, 1, 0, 0, 0, 19955, 19974, 1, 0, 0, 0, 19956, + 19957, 5, 2447, 0, 0, 19957, 19962, 3, 2278, 1139, 0, 19958, 19959, 5, + 2453, 0, 0, 19959, 19961, 3, 2278, 1139, 0, 19960, 19958, 1, 0, 0, 0, 19961, + 19964, 1, 0, 0, 0, 19962, 19960, 1, 0, 0, 0, 19962, 19963, 1, 0, 0, 0, + 19963, 19965, 1, 0, 0, 0, 19964, 19962, 1, 0, 0, 0, 19965, 19966, 5, 2448, + 0, 0, 19966, 19967, 5, 2257, 0, 0, 19967, 19969, 5, 2447, 0, 0, 19968, + 19970, 3, 2076, 1038, 0, 19969, 19968, 1, 0, 0, 0, 19969, 19970, 1, 0, + 0, 0, 19970, 19971, 1, 0, 0, 0, 19971, 19972, 5, 2448, 0, 0, 19972, 19974, + 1, 0, 0, 0, 19973, 19952, 1, 0, 0, 0, 19973, 19956, 1, 0, 0, 0, 19974, + 2223, 1, 0, 0, 0, 19975, 19978, 5, 1352, 0, 0, 19976, 19977, 5, 160, 0, + 0, 19977, 19979, 5, 2258, 0, 0, 19978, 19976, 1, 0, 0, 0, 19978, 19979, + 1, 0, 0, 0, 19979, 19980, 1, 0, 0, 0, 19980, 19982, 3, 2078, 1039, 0, 19981, + 19983, 3, 2268, 1134, 0, 19982, 19981, 1, 0, 0, 0, 19982, 19983, 1, 0, + 0, 0, 19983, 19991, 1, 0, 0, 0, 19984, 19985, 5, 2453, 0, 0, 19985, 19987, + 3, 2078, 1039, 0, 19986, 19988, 3, 2268, 1134, 0, 19987, 19986, 1, 0, 0, + 0, 19987, 19988, 1, 0, 0, 0, 19988, 19990, 1, 0, 0, 0, 19989, 19984, 1, + 0, 0, 0, 19990, 19993, 1, 0, 0, 0, 19991, 19989, 1, 0, 0, 0, 19991, 19992, + 1, 0, 0, 0, 19992, 2225, 1, 0, 0, 0, 19993, 19991, 1, 0, 0, 0, 19994, 19995, + 5, 2320, 0, 0, 19995, 19997, 5, 2447, 0, 0, 19996, 19998, 7, 259, 0, 0, + 19997, 19996, 1, 0, 0, 0, 19997, 19998, 1, 0, 0, 0, 19998, 20000, 1, 0, + 0, 0, 19999, 20001, 7, 268, 0, 0, 20000, 19999, 1, 0, 0, 0, 20000, 20001, + 1, 0, 0, 0, 20001, 20002, 1, 0, 0, 0, 20002, 20007, 3, 2234, 1117, 0, 20003, + 20004, 5, 2453, 0, 0, 20004, 20006, 3, 2234, 1117, 0, 20005, 20003, 1, + 0, 0, 0, 20006, 20009, 1, 0, 0, 0, 20007, 20005, 1, 0, 0, 0, 20007, 20008, + 1, 0, 0, 0, 20008, 20010, 1, 0, 0, 0, 20009, 20007, 1, 0, 0, 0, 20010, + 20011, 5, 2448, 0, 0, 20011, 2227, 1, 0, 0, 0, 20012, 20013, 5, 2338, 0, + 0, 20013, 20017, 5, 2447, 0, 0, 20014, 20015, 3, 2102, 1051, 0, 20015, + 20016, 3, 2268, 1134, 0, 20016, 20018, 1, 0, 0, 0, 20017, 20014, 1, 0, + 0, 0, 20017, 20018, 1, 0, 0, 0, 20018, 20025, 1, 0, 0, 0, 20019, 20020, + 5, 2453, 0, 0, 20020, 20021, 3, 2102, 1051, 0, 20021, 20022, 3, 2268, 1134, + 0, 20022, 20024, 1, 0, 0, 0, 20023, 20019, 1, 0, 0, 0, 20024, 20027, 1, + 0, 0, 0, 20025, 20023, 1, 0, 0, 0, 20025, 20026, 1, 0, 0, 0, 20026, 20029, + 1, 0, 0, 0, 20027, 20025, 1, 0, 0, 0, 20028, 20030, 3, 2232, 1116, 0, 20029, + 20028, 1, 0, 0, 0, 20029, 20030, 1, 0, 0, 0, 20030, 20031, 1, 0, 0, 0, + 20031, 20032, 5, 2448, 0, 0, 20032, 2229, 1, 0, 0, 0, 20033, 20044, 3, + 2276, 1138, 0, 20034, 20035, 5, 620, 0, 0, 20035, 20045, 5, 1304, 0, 0, + 20036, 20039, 3, 2374, 1187, 0, 20037, 20038, 5, 1363, 0, 0, 20038, 20040, + 3, 2102, 1051, 0, 20039, 20037, 1, 0, 0, 0, 20039, 20040, 1, 0, 0, 0, 20040, + 20042, 1, 0, 0, 0, 20041, 20043, 3, 2232, 1116, 0, 20042, 20041, 1, 0, + 0, 0, 20042, 20043, 1, 0, 0, 0, 20043, 20045, 1, 0, 0, 0, 20044, 20034, + 1, 0, 0, 0, 20044, 20036, 1, 0, 0, 0, 20045, 2231, 1, 0, 0, 0, 20046, 20047, + 5, 389, 0, 0, 20047, 20048, 3, 2102, 1051, 0, 20048, 2233, 1, 0, 0, 0, + 20049, 20057, 3, 2078, 1039, 0, 20050, 20052, 5, 69, 0, 0, 20051, 20050, + 1, 0, 0, 0, 20051, 20052, 1, 0, 0, 0, 20052, 20053, 1, 0, 0, 0, 20053, + 20058, 3, 2404, 1202, 0, 20054, 20055, 5, 69, 0, 0, 20055, 20056, 5, 529, + 0, 0, 20056, 20058, 3, 2078, 1039, 0, 20057, 20051, 1, 0, 0, 0, 20057, + 20054, 1, 0, 0, 0, 20057, 20058, 1, 0, 0, 0, 20058, 2235, 1, 0, 0, 0, 20059, + 20063, 5, 2285, 0, 0, 20060, 20061, 5, 1137, 0, 0, 20061, 20064, 5, 2258, + 0, 0, 20062, 20064, 3, 2078, 1039, 0, 20063, 20060, 1, 0, 0, 0, 20063, + 20062, 1, 0, 0, 0, 20064, 2237, 1, 0, 0, 0, 20065, 20071, 5, 1729, 0, 0, + 20066, 20072, 5, 2360, 0, 0, 20067, 20069, 5, 1137, 0, 0, 20068, 20070, + 5, 2258, 0, 0, 20069, 20068, 1, 0, 0, 0, 20069, 20070, 1, 0, 0, 0, 20070, + 20072, 1, 0, 0, 0, 20071, 20066, 1, 0, 0, 0, 20071, 20067, 1, 0, 0, 0, + 20072, 2239, 1, 0, 0, 0, 20073, 20074, 5, 504, 0, 0, 20074, 20075, 3, 2102, + 1051, 0, 20075, 2241, 1, 0, 0, 0, 20076, 20077, 5, 2285, 0, 0, 20077, 20078, + 3, 2102, 1051, 0, 20078, 2243, 1, 0, 0, 0, 20079, 20080, 5, 1137, 0, 0, + 20080, 20088, 5, 709, 0, 0, 20081, 20085, 5, 709, 0, 0, 20082, 20083, 5, + 1699, 0, 0, 20083, 20084, 5, 2472, 0, 0, 20084, 20086, 3, 2102, 1051, 0, + 20085, 20082, 1, 0, 0, 0, 20085, 20086, 1, 0, 0, 0, 20086, 20088, 1, 0, + 0, 0, 20087, 20079, 1, 0, 0, 0, 20087, 20081, 1, 0, 0, 0, 20088, 2245, + 1, 0, 0, 0, 20089, 20090, 5, 51, 0, 0, 20090, 20091, 5, 2447, 0, 0, 20091, + 20092, 3, 2248, 1124, 0, 20092, 20093, 5, 2448, 0, 0, 20093, 2247, 1, 0, + 0, 0, 20094, 20100, 5, 21, 0, 0, 20095, 20096, 5, 691, 0, 0, 20096, 20097, + 5, 1204, 0, 0, 20097, 20101, 5, 545, 0, 0, 20098, 20099, 5, 1307, 0, 0, + 20099, 20101, 5, 1562, 0, 0, 20100, 20095, 1, 0, 0, 0, 20100, 20098, 1, + 0, 0, 0, 20100, 20101, 1, 0, 0, 0, 20101, 20109, 1, 0, 0, 0, 20102, 20105, + 5, 469, 0, 0, 20103, 20104, 5, 691, 0, 0, 20104, 20106, 5, 545, 0, 0, 20105, + 20103, 1, 0, 0, 0, 20105, 20106, 1, 0, 0, 0, 20106, 20109, 1, 0, 0, 0, + 20107, 20109, 5, 1562, 0, 0, 20108, 20094, 1, 0, 0, 0, 20108, 20102, 1, + 0, 0, 0, 20108, 20107, 1, 0, 0, 0, 20108, 20109, 1, 0, 0, 0, 20109, 20110, + 1, 0, 0, 0, 20110, 20115, 3, 2250, 1125, 0, 20111, 20112, 5, 2453, 0, 0, + 20112, 20114, 3, 2248, 1124, 0, 20113, 20111, 1, 0, 0, 0, 20114, 20117, + 1, 0, 0, 0, 20115, 20113, 1, 0, 0, 0, 20115, 20116, 1, 0, 0, 0, 20116, + 2249, 1, 0, 0, 0, 20117, 20115, 1, 0, 0, 0, 20118, 20120, 3, 2402, 1201, + 0, 20119, 20121, 5, 2443, 0, 0, 20120, 20119, 1, 0, 0, 0, 20120, 20121, + 1, 0, 0, 0, 20121, 2251, 1, 0, 0, 0, 20122, 20132, 5, 547, 0, 0, 20123, + 20132, 5, 2479, 0, 0, 20124, 20125, 5, 1683, 0, 0, 20125, 20132, 7, 269, + 0, 0, 20126, 20132, 3, 2258, 1129, 0, 20127, 20132, 3, 2262, 1131, 0, 20128, + 20132, 3, 2254, 1127, 0, 20129, 20132, 3, 2260, 1130, 0, 20130, 20132, + 3, 2264, 1132, 0, 20131, 20122, 1, 0, 0, 0, 20131, 20123, 1, 0, 0, 0, 20131, + 20124, 1, 0, 0, 0, 20131, 20126, 1, 0, 0, 0, 20131, 20127, 1, 0, 0, 0, + 20131, 20128, 1, 0, 0, 0, 20131, 20129, 1, 0, 0, 0, 20131, 20130, 1, 0, + 0, 0, 20132, 2253, 1, 0, 0, 0, 20133, 20139, 5, 1737, 0, 0, 20134, 20136, + 5, 2456, 0, 0, 20135, 20137, 5, 2456, 0, 0, 20136, 20135, 1, 0, 0, 0, 20136, + 20137, 1, 0, 0, 0, 20137, 20139, 1, 0, 0, 0, 20138, 20133, 1, 0, 0, 0, + 20138, 20134, 1, 0, 0, 0, 20139, 20140, 1, 0, 0, 0, 20140, 20141, 3, 2256, + 1128, 0, 20141, 2255, 1, 0, 0, 0, 20142, 20143, 3, 2404, 1202, 0, 20143, + 20144, 5, 2469, 0, 0, 20144, 20146, 1, 0, 0, 0, 20145, 20142, 1, 0, 0, + 0, 20145, 20146, 1, 0, 0, 0, 20146, 20148, 1, 0, 0, 0, 20147, 20149, 7, + 270, 0, 0, 20148, 20147, 1, 0, 0, 0, 20148, 20149, 1, 0, 0, 0, 20149, 20155, + 1, 0, 0, 0, 20150, 20151, 3, 2404, 1202, 0, 20151, 20152, 7, 270, 0, 0, + 20152, 20154, 1, 0, 0, 0, 20153, 20150, 1, 0, 0, 0, 20154, 20157, 1, 0, + 0, 0, 20155, 20153, 1, 0, 0, 0, 20155, 20156, 1, 0, 0, 0, 20156, 20158, + 1, 0, 0, 0, 20157, 20155, 1, 0, 0, 0, 20158, 20159, 3, 2404, 1202, 0, 20159, + 20160, 5, 2440, 0, 0, 20160, 20161, 7, 271, 0, 0, 20161, 2257, 1, 0, 0, + 0, 20162, 20163, 5, 2299, 0, 0, 20163, 20179, 7, 272, 0, 0, 20164, 20170, + 5, 547, 0, 0, 20165, 20171, 5, 1787, 0, 0, 20166, 20171, 5, 574, 0, 0, + 20167, 20171, 5, 2295, 0, 0, 20168, 20171, 3, 2326, 1163, 0, 20169, 20171, + 3, 2396, 1198, 0, 20170, 20165, 1, 0, 0, 0, 20170, 20166, 1, 0, 0, 0, 20170, + 20167, 1, 0, 0, 0, 20170, 20168, 1, 0, 0, 0, 20170, 20169, 1, 0, 0, 0, + 20171, 20173, 1, 0, 0, 0, 20172, 20174, 7, 273, 0, 0, 20173, 20172, 1, + 0, 0, 0, 20173, 20174, 1, 0, 0, 0, 20174, 20180, 1, 0, 0, 0, 20175, 20177, + 5, 297, 0, 0, 20176, 20178, 7, 274, 0, 0, 20177, 20176, 1, 0, 0, 0, 20177, + 20178, 1, 0, 0, 0, 20178, 20180, 1, 0, 0, 0, 20179, 20164, 1, 0, 0, 0, + 20179, 20175, 1, 0, 0, 0, 20180, 2259, 1, 0, 0, 0, 20181, 20197, 5, 1671, + 0, 0, 20182, 20183, 3, 2410, 1205, 0, 20183, 20184, 7, 100, 0, 0, 20184, + 20186, 1, 0, 0, 0, 20185, 20182, 1, 0, 0, 0, 20186, 20187, 1, 0, 0, 0, + 20187, 20185, 1, 0, 0, 0, 20187, 20188, 1, 0, 0, 0, 20188, 20198, 1, 0, + 0, 0, 20189, 20195, 3, 2410, 1205, 0, 20190, 20196, 5, 2443, 0, 0, 20191, + 20196, 5, 1259, 0, 0, 20192, 20196, 5, 1244, 0, 0, 20193, 20196, 3, 2396, + 1198, 0, 20194, 20196, 3, 2410, 1205, 0, 20195, 20190, 1, 0, 0, 0, 20195, + 20191, 1, 0, 0, 0, 20195, 20192, 1, 0, 0, 0, 20195, 20193, 1, 0, 0, 0, + 20195, 20194, 1, 0, 0, 0, 20196, 20198, 1, 0, 0, 0, 20197, 20185, 1, 0, + 0, 0, 20197, 20189, 1, 0, 0, 0, 20198, 2261, 1, 0, 0, 0, 20199, 20209, + 5, 2120, 0, 0, 20200, 20204, 5, 1737, 0, 0, 20201, 20203, 3, 2404, 1202, + 0, 20202, 20201, 1, 0, 0, 0, 20203, 20206, 1, 0, 0, 0, 20204, 20202, 1, + 0, 0, 0, 20204, 20205, 1, 0, 0, 0, 20205, 20210, 1, 0, 0, 0, 20206, 20204, + 1, 0, 0, 0, 20207, 20210, 5, 1683, 0, 0, 20208, 20210, 5, 1761, 0, 0, 20209, + 20200, 1, 0, 0, 0, 20209, 20207, 1, 0, 0, 0, 20209, 20208, 1, 0, 0, 0, + 20209, 20210, 1, 0, 0, 0, 20210, 2263, 1, 0, 0, 0, 20211, 20213, 5, 212, + 0, 0, 20212, 20214, 5, 237, 0, 0, 20213, 20212, 1, 0, 0, 0, 20213, 20214, + 1, 0, 0, 0, 20214, 20215, 1, 0, 0, 0, 20215, 20218, 3, 2410, 1205, 0, 20216, + 20218, 5, 38, 0, 0, 20217, 20211, 1, 0, 0, 0, 20217, 20216, 1, 0, 0, 0, + 20218, 2265, 1, 0, 0, 0, 20219, 20221, 7, 189, 0, 0, 20220, 20222, 5, 620, + 0, 0, 20221, 20220, 1, 0, 0, 0, 20221, 20222, 1, 0, 0, 0, 20222, 20223, + 1, 0, 0, 0, 20223, 20225, 5, 2447, 0, 0, 20224, 20226, 3, 2076, 1038, 0, + 20225, 20224, 1, 0, 0, 0, 20225, 20226, 1, 0, 0, 0, 20226, 20227, 1, 0, + 0, 0, 20227, 20228, 5, 2448, 0, 0, 20228, 2267, 1, 0, 0, 0, 20229, 20231, + 5, 69, 0, 0, 20230, 20229, 1, 0, 0, 0, 20230, 20231, 1, 0, 0, 0, 20231, + 20234, 1, 0, 0, 0, 20232, 20235, 3, 2402, 1201, 0, 20233, 20235, 3, 2400, + 1200, 0, 20234, 20232, 1, 0, 0, 0, 20234, 20233, 1, 0, 0, 0, 20235, 20238, + 1, 0, 0, 0, 20236, 20238, 5, 69, 0, 0, 20237, 20230, 1, 0, 0, 0, 20237, + 20236, 1, 0, 0, 0, 20238, 2269, 1, 0, 0, 0, 20239, 20242, 3, 2402, 1201, + 0, 20240, 20242, 3, 2400, 1200, 0, 20241, 20239, 1, 0, 0, 0, 20241, 20240, + 1, 0, 0, 0, 20242, 2271, 1, 0, 0, 0, 20243, 20248, 5, 2301, 0, 0, 20244, + 20245, 5, 336, 0, 0, 20245, 20246, 5, 1246, 0, 0, 20246, 20249, 3, 2330, + 1165, 0, 20247, 20249, 3, 2074, 1037, 0, 20248, 20244, 1, 0, 0, 0, 20248, + 20247, 1, 0, 0, 0, 20249, 2273, 1, 0, 0, 0, 20250, 20251, 5, 159, 0, 0, + 20251, 20253, 5, 233, 0, 0, 20252, 20250, 1, 0, 0, 0, 20252, 20253, 1, + 0, 0, 0, 20253, 20254, 1, 0, 0, 0, 20254, 20257, 5, 779, 0, 0, 20255, 20258, + 3, 2384, 1192, 0, 20256, 20258, 3, 2382, 1191, 0, 20257, 20255, 1, 0, 0, + 0, 20257, 20256, 1, 0, 0, 0, 20258, 20266, 1, 0, 0, 0, 20259, 20262, 5, + 2453, 0, 0, 20260, 20263, 3, 2384, 1192, 0, 20261, 20263, 3, 2382, 1191, + 0, 20262, 20260, 1, 0, 0, 0, 20262, 20261, 1, 0, 0, 0, 20263, 20265, 1, + 0, 0, 0, 20264, 20259, 1, 0, 0, 0, 20265, 20268, 1, 0, 0, 0, 20266, 20264, + 1, 0, 0, 0, 20266, 20267, 1, 0, 0, 0, 20267, 2275, 1, 0, 0, 0, 20268, 20266, + 1, 0, 0, 0, 20269, 20272, 3, 2402, 1201, 0, 20270, 20272, 3, 2400, 1200, + 0, 20271, 20269, 1, 0, 0, 0, 20271, 20270, 1, 0, 0, 0, 20272, 2277, 1, + 0, 0, 0, 20273, 20274, 3, 2402, 1201, 0, 20274, 2279, 1, 0, 0, 0, 20275, + 20276, 3, 2402, 1201, 0, 20276, 2281, 1, 0, 0, 0, 20277, 20278, 3, 2402, + 1201, 0, 20278, 2283, 1, 0, 0, 0, 20279, 20280, 3, 2402, 1201, 0, 20280, + 2285, 1, 0, 0, 0, 20281, 20282, 3, 2402, 1201, 0, 20282, 2287, 1, 0, 0, + 0, 20283, 20288, 3, 2402, 1201, 0, 20284, 20285, 5, 2440, 0, 0, 20285, + 20287, 3, 2404, 1202, 0, 20286, 20284, 1, 0, 0, 0, 20287, 20290, 1, 0, + 0, 0, 20288, 20286, 1, 0, 0, 0, 20288, 20289, 1, 0, 0, 0, 20289, 20293, + 1, 0, 0, 0, 20290, 20288, 1, 0, 0, 0, 20291, 20292, 5, 2456, 0, 0, 20292, + 20294, 3, 2334, 1167, 0, 20293, 20291, 1, 0, 0, 0, 20293, 20294, 1, 0, + 0, 0, 20294, 2289, 1, 0, 0, 0, 20295, 20296, 3, 2402, 1201, 0, 20296, 2291, + 1, 0, 0, 0, 20297, 20300, 3, 2402, 1201, 0, 20298, 20299, 5, 2440, 0, 0, + 20299, 20301, 3, 2404, 1202, 0, 20300, 20298, 1, 0, 0, 0, 20300, 20301, + 1, 0, 0, 0, 20301, 2293, 1, 0, 0, 0, 20302, 20303, 3, 2402, 1201, 0, 20303, + 2295, 1, 0, 0, 0, 20304, 20305, 3, 2402, 1201, 0, 20305, 2297, 1, 0, 0, + 0, 20306, 20307, 3, 2402, 1201, 0, 20307, 2299, 1, 0, 0, 0, 20308, 20311, + 3, 2402, 1201, 0, 20309, 20310, 5, 2440, 0, 0, 20310, 20312, 3, 2404, 1202, + 0, 20311, 20309, 1, 0, 0, 0, 20311, 20312, 1, 0, 0, 0, 20312, 2301, 1, + 0, 0, 0, 20313, 20318, 3, 2402, 1201, 0, 20314, 20315, 5, 2440, 0, 0, 20315, + 20317, 3, 2404, 1202, 0, 20316, 20314, 1, 0, 0, 0, 20317, 20320, 1, 0, + 0, 0, 20318, 20316, 1, 0, 0, 0, 20318, 20319, 1, 0, 0, 0, 20319, 2303, + 1, 0, 0, 0, 20320, 20318, 1, 0, 0, 0, 20321, 20322, 3, 2402, 1201, 0, 20322, + 2305, 1, 0, 0, 0, 20323, 20325, 3, 2404, 1202, 0, 20324, 20326, 3, 564, + 282, 0, 20325, 20324, 1, 0, 0, 0, 20325, 20326, 1, 0, 0, 0, 20326, 2307, + 1, 0, 0, 0, 20327, 20330, 3, 2404, 1202, 0, 20328, 20330, 5, 280, 0, 0, + 20329, 20327, 1, 0, 0, 0, 20329, 20328, 1, 0, 0, 0, 20330, 2309, 1, 0, + 0, 0, 20331, 20336, 3, 2402, 1201, 0, 20332, 20333, 5, 2440, 0, 0, 20333, + 20335, 3, 2404, 1202, 0, 20334, 20332, 1, 0, 0, 0, 20335, 20338, 1, 0, + 0, 0, 20336, 20334, 1, 0, 0, 0, 20336, 20337, 1, 0, 0, 0, 20337, 20341, + 1, 0, 0, 0, 20338, 20336, 1, 0, 0, 0, 20339, 20340, 5, 2456, 0, 0, 20340, + 20342, 3, 2334, 1167, 0, 20341, 20339, 1, 0, 0, 0, 20341, 20342, 1, 0, + 0, 0, 20342, 2311, 1, 0, 0, 0, 20343, 20344, 3, 2404, 1202, 0, 20344, 2313, + 1, 0, 0, 0, 20345, 20350, 3, 2404, 1202, 0, 20346, 20347, 5, 2440, 0, 0, + 20347, 20349, 3, 2404, 1202, 0, 20348, 20346, 1, 0, 0, 0, 20349, 20352, + 1, 0, 0, 0, 20350, 20348, 1, 0, 0, 0, 20350, 20351, 1, 0, 0, 0, 20351, + 2315, 1, 0, 0, 0, 20352, 20350, 1, 0, 0, 0, 20353, 20358, 3, 2404, 1202, + 0, 20354, 20355, 5, 2440, 0, 0, 20355, 20357, 3, 2404, 1202, 0, 20356, + 20354, 1, 0, 0, 0, 20357, 20360, 1, 0, 0, 0, 20358, 20356, 1, 0, 0, 0, + 20358, 20359, 1, 0, 0, 0, 20359, 2317, 1, 0, 0, 0, 20360, 20358, 1, 0, + 0, 0, 20361, 20366, 3, 2402, 1201, 0, 20362, 20363, 5, 2440, 0, 0, 20363, + 20365, 3, 2404, 1202, 0, 20364, 20362, 1, 0, 0, 0, 20365, 20368, 1, 0, + 0, 0, 20366, 20364, 1, 0, 0, 0, 20366, 20367, 1, 0, 0, 0, 20367, 2319, + 1, 0, 0, 0, 20368, 20366, 1, 0, 0, 0, 20369, 20372, 3, 2402, 1201, 0, 20370, + 20371, 5, 2440, 0, 0, 20371, 20373, 3, 2404, 1202, 0, 20372, 20370, 1, + 0, 0, 0, 20372, 20373, 1, 0, 0, 0, 20373, 2321, 1, 0, 0, 0, 20374, 20377, + 3, 2402, 1201, 0, 20375, 20376, 5, 2440, 0, 0, 20376, 20378, 3, 2404, 1202, + 0, 20377, 20375, 1, 0, 0, 0, 20377, 20378, 1, 0, 0, 0, 20378, 2323, 1, + 0, 0, 0, 20379, 20382, 3, 2402, 1201, 0, 20380, 20381, 5, 2440, 0, 0, 20381, + 20383, 3, 2404, 1202, 0, 20382, 20380, 1, 0, 0, 0, 20382, 20383, 1, 0, + 0, 0, 20383, 2325, 1, 0, 0, 0, 20384, 20385, 5, 2475, 0, 0, 20385, 20387, + 3, 2346, 1173, 0, 20386, 20384, 1, 0, 0, 0, 20386, 20387, 1, 0, 0, 0, 20387, + 20388, 1, 0, 0, 0, 20388, 20391, 3, 2404, 1202, 0, 20389, 20390, 5, 2440, + 0, 0, 20390, 20392, 3, 2404, 1202, 0, 20391, 20389, 1, 0, 0, 0, 20391, + 20392, 1, 0, 0, 0, 20392, 20395, 1, 0, 0, 0, 20393, 20395, 3, 2382, 1191, + 0, 20394, 20386, 1, 0, 0, 0, 20394, 20393, 1, 0, 0, 0, 20395, 2327, 1, + 0, 0, 0, 20396, 20399, 3, 2402, 1201, 0, 20397, 20398, 5, 2440, 0, 0, 20398, + 20400, 3, 2404, 1202, 0, 20399, 20397, 1, 0, 0, 0, 20399, 20400, 1, 0, + 0, 0, 20400, 2329, 1, 0, 0, 0, 20401, 20404, 3, 2384, 1192, 0, 20402, 20404, + 3, 2382, 1191, 0, 20403, 20401, 1, 0, 0, 0, 20403, 20402, 1, 0, 0, 0, 20404, + 2331, 1, 0, 0, 0, 20405, 20408, 3, 2402, 1201, 0, 20406, 20408, 3, 2382, + 1191, 0, 20407, 20405, 1, 0, 0, 0, 20407, 20406, 1, 0, 0, 0, 20408, 2333, + 1, 0, 0, 0, 20409, 20414, 3, 1452, 726, 0, 20410, 20411, 5, 2440, 0, 0, + 20411, 20413, 3, 1450, 725, 0, 20412, 20410, 1, 0, 0, 0, 20413, 20416, + 1, 0, 0, 0, 20414, 20412, 1, 0, 0, 0, 20414, 20415, 1, 0, 0, 0, 20415, + 20419, 1, 0, 0, 0, 20416, 20414, 1, 0, 0, 0, 20417, 20418, 5, 2456, 0, + 0, 20418, 20420, 3, 2338, 1169, 0, 20419, 20417, 1, 0, 0, 0, 20419, 20420, + 1, 0, 0, 0, 20420, 2335, 1, 0, 0, 0, 20421, 20422, 3, 2402, 1201, 0, 20422, + 2337, 1, 0, 0, 0, 20423, 20424, 3, 2402, 1201, 0, 20424, 2339, 1, 0, 0, + 0, 20425, 20430, 3, 2402, 1201, 0, 20426, 20427, 5, 2440, 0, 0, 20427, + 20429, 3, 2404, 1202, 0, 20428, 20426, 1, 0, 0, 0, 20429, 20432, 1, 0, + 0, 0, 20430, 20428, 1, 0, 0, 0, 20430, 20431, 1, 0, 0, 0, 20431, 2341, + 1, 0, 0, 0, 20432, 20430, 1, 0, 0, 0, 20433, 20436, 3, 2402, 1201, 0, 20434, + 20435, 5, 2440, 0, 0, 20435, 20437, 3, 2404, 1202, 0, 20436, 20434, 1, + 0, 0, 0, 20436, 20437, 1, 0, 0, 0, 20437, 20441, 1, 0, 0, 0, 20438, 20439, + 5, 2456, 0, 0, 20439, 20442, 3, 2334, 1167, 0, 20440, 20442, 3, 2266, 1133, + 0, 20441, 20438, 1, 0, 0, 0, 20441, 20440, 1, 0, 0, 0, 20441, 20442, 1, + 0, 0, 0, 20442, 20448, 1, 0, 0, 0, 20443, 20445, 3, 2344, 1172, 0, 20444, + 20446, 3, 2408, 1204, 0, 20445, 20444, 1, 0, 0, 0, 20445, 20446, 1, 0, + 0, 0, 20446, 20448, 1, 0, 0, 0, 20447, 20433, 1, 0, 0, 0, 20447, 20443, + 1, 0, 0, 0, 20448, 2343, 1, 0, 0, 0, 20449, 20450, 5, 2347, 0, 0, 20450, + 20454, 5, 2447, 0, 0, 20451, 20452, 3, 2228, 1114, 0, 20452, 20453, 5, + 2453, 0, 0, 20453, 20455, 1, 0, 0, 0, 20454, 20451, 1, 0, 0, 0, 20454, + 20455, 1, 0, 0, 0, 20455, 20456, 1, 0, 0, 0, 20456, 20458, 3, 2102, 1051, + 0, 20457, 20459, 3, 2224, 1112, 0, 20458, 20457, 1, 0, 0, 0, 20458, 20459, + 1, 0, 0, 0, 20459, 20469, 1, 0, 0, 0, 20460, 20461, 5, 238, 0, 0, 20461, + 20466, 3, 2230, 1115, 0, 20462, 20463, 5, 2453, 0, 0, 20463, 20465, 3, + 2230, 1115, 0, 20464, 20462, 1, 0, 0, 0, 20465, 20468, 1, 0, 0, 0, 20466, + 20464, 1, 0, 0, 0, 20466, 20467, 1, 0, 0, 0, 20467, 20470, 1, 0, 0, 0, + 20468, 20466, 1, 0, 0, 0, 20469, 20460, 1, 0, 0, 0, 20469, 20470, 1, 0, + 0, 0, 20470, 20471, 1, 0, 0, 0, 20471, 20474, 5, 2448, 0, 0, 20472, 20473, + 5, 2440, 0, 0, 20473, 20475, 3, 2386, 1193, 0, 20474, 20472, 1, 0, 0, 0, + 20474, 20475, 1, 0, 0, 0, 20475, 2345, 1, 0, 0, 0, 20476, 20481, 3, 2404, + 1202, 0, 20477, 20478, 5, 2440, 0, 0, 20478, 20480, 3, 2404, 1202, 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, 2347, 1, 0, 0, 0, 20483, 20481, 1, 0, + 0, 0, 20484, 20485, 3, 2402, 1201, 0, 20485, 2349, 1, 0, 0, 0, 20486, 20487, + 3, 2404, 1202, 0, 20487, 2351, 1, 0, 0, 0, 20488, 20489, 3, 2404, 1202, + 0, 20489, 2353, 1, 0, 0, 0, 20490, 20491, 3, 2404, 1202, 0, 20491, 2355, + 1, 0, 0, 0, 20492, 20517, 3, 2342, 1171, 0, 20493, 20494, 5, 2237, 0, 0, + 20494, 20499, 3, 2354, 1177, 0, 20495, 20496, 5, 2453, 0, 0, 20496, 20498, + 3, 2354, 1177, 0, 20497, 20495, 1, 0, 0, 0, 20498, 20501, 1, 0, 0, 0, 20499, + 20497, 1, 0, 0, 0, 20499, 20500, 1, 0, 0, 0, 20500, 20517, 1, 0, 0, 0, + 20501, 20499, 1, 0, 0, 0, 20502, 20503, 5, 426, 0, 0, 20503, 20517, 3, + 2352, 1176, 0, 20504, 20505, 5, 483, 0, 0, 20505, 20517, 3, 2350, 1175, + 0, 20506, 20507, 5, 955, 0, 0, 20507, 20508, 5, 971, 0, 0, 20508, 20517, + 3, 2350, 1175, 0, 20509, 20510, 5, 792, 0, 0, 20510, 20511, 7, 86, 0, 0, + 20511, 20517, 3, 2350, 1175, 0, 20512, 20513, 5, 1722, 0, 0, 20513, 20514, + 5, 2154, 0, 0, 20514, 20515, 5, 1463, 0, 0, 20515, 20517, 3, 2350, 1175, + 0, 20516, 20492, 1, 0, 0, 0, 20516, 20493, 1, 0, 0, 0, 20516, 20502, 1, + 0, 0, 0, 20516, 20504, 1, 0, 0, 0, 20516, 20506, 1, 0, 0, 0, 20516, 20509, + 1, 0, 0, 0, 20516, 20512, 1, 0, 0, 0, 20517, 2357, 1, 0, 0, 0, 20518, 20523, + 3, 2340, 1170, 0, 20519, 20520, 5, 2453, 0, 0, 20520, 20522, 3, 2340, 1170, + 0, 20521, 20519, 1, 0, 0, 0, 20522, 20525, 1, 0, 0, 0, 20523, 20521, 1, + 0, 0, 0, 20523, 20524, 1, 0, 0, 0, 20524, 2359, 1, 0, 0, 0, 20525, 20523, + 1, 0, 0, 0, 20526, 20527, 5, 2447, 0, 0, 20527, 20528, 3, 2358, 1179, 0, + 20528, 20529, 5, 2448, 0, 0, 20529, 2361, 1, 0, 0, 0, 20530, 20531, 5, + 814, 0, 0, 20531, 20532, 5, 2447, 0, 0, 20532, 20533, 5, 2392, 0, 0, 20533, + 20536, 7, 56, 0, 0, 20534, 20537, 3, 1926, 963, 0, 20535, 20537, 3, 1994, + 997, 0, 20536, 20534, 1, 0, 0, 0, 20536, 20535, 1, 0, 0, 0, 20537, 20538, + 1, 0, 0, 0, 20538, 20540, 5, 2448, 0, 0, 20539, 20541, 3, 2202, 1101, 0, + 20540, 20539, 1, 0, 0, 0, 20540, 20541, 1, 0, 0, 0, 20541, 2363, 1, 0, + 0, 0, 20542, 20551, 5, 2447, 0, 0, 20543, 20548, 3, 2372, 1186, 0, 20544, + 20545, 5, 2453, 0, 0, 20545, 20547, 3, 2372, 1186, 0, 20546, 20544, 1, + 0, 0, 0, 20547, 20550, 1, 0, 0, 0, 20548, 20546, 1, 0, 0, 0, 20548, 20549, + 1, 0, 0, 0, 20549, 20552, 1, 0, 0, 0, 20550, 20548, 1, 0, 0, 0, 20551, + 20543, 1, 0, 0, 0, 20551, 20552, 1, 0, 0, 0, 20552, 20553, 1, 0, 0, 0, + 20553, 20555, 5, 2448, 0, 0, 20554, 20556, 3, 2362, 1181, 0, 20555, 20554, + 1, 0, 0, 0, 20555, 20556, 1, 0, 0, 0, 20556, 2365, 1, 0, 0, 0, 20557, 20572, + 5, 2447, 0, 0, 20558, 20560, 3, 2372, 1186, 0, 20559, 20561, 3, 2370, 1185, + 0, 20560, 20559, 1, 0, 0, 0, 20560, 20561, 1, 0, 0, 0, 20561, 20569, 1, + 0, 0, 0, 20562, 20563, 5, 2453, 0, 0, 20563, 20565, 3, 2372, 1186, 0, 20564, + 20566, 3, 2370, 1185, 0, 20565, 20564, 1, 0, 0, 0, 20565, 20566, 1, 0, + 0, 0, 20566, 20568, 1, 0, 0, 0, 20567, 20562, 1, 0, 0, 0, 20568, 20571, + 1, 0, 0, 0, 20569, 20567, 1, 0, 0, 0, 20569, 20570, 1, 0, 0, 0, 20570, + 20573, 1, 0, 0, 0, 20571, 20569, 1, 0, 0, 0, 20572, 20558, 1, 0, 0, 0, + 20572, 20573, 1, 0, 0, 0, 20573, 20574, 1, 0, 0, 0, 20574, 20576, 5, 2448, + 0, 0, 20575, 20577, 3, 2362, 1181, 0, 20576, 20575, 1, 0, 0, 0, 20576, + 20577, 1, 0, 0, 0, 20577, 2367, 1, 0, 0, 0, 20578, 20579, 5, 2447, 0, 0, + 20579, 20592, 3, 2340, 1170, 0, 20580, 20583, 5, 2453, 0, 0, 20581, 20584, + 3, 2396, 1198, 0, 20582, 20584, 5, 1228, 0, 0, 20583, 20581, 1, 0, 0, 0, + 20583, 20582, 1, 0, 0, 0, 20584, 20590, 1, 0, 0, 0, 20585, 20588, 5, 2453, + 0, 0, 20586, 20589, 3, 2396, 1198, 0, 20587, 20589, 5, 1228, 0, 0, 20588, + 20586, 1, 0, 0, 0, 20588, 20587, 1, 0, 0, 0, 20589, 20591, 1, 0, 0, 0, + 20590, 20585, 1, 0, 0, 0, 20590, 20591, 1, 0, 0, 0, 20591, 20593, 1, 0, + 0, 0, 20592, 20580, 1, 0, 0, 0, 20592, 20593, 1, 0, 0, 0, 20593, 20594, + 1, 0, 0, 0, 20594, 20614, 5, 2246, 0, 0, 20595, 20596, 3, 2342, 1171, 0, + 20596, 20597, 5, 2440, 0, 0, 20597, 20598, 5, 2450, 0, 0, 20598, 20615, + 1, 0, 0, 0, 20599, 20615, 5, 2450, 0, 0, 20600, 20602, 3, 2078, 1039, 0, + 20601, 20603, 3, 2268, 1134, 0, 20602, 20601, 1, 0, 0, 0, 20602, 20603, + 1, 0, 0, 0, 20603, 20611, 1, 0, 0, 0, 20604, 20605, 5, 2453, 0, 0, 20605, + 20607, 3, 2078, 1039, 0, 20606, 20608, 3, 2268, 1134, 0, 20607, 20606, + 1, 0, 0, 0, 20607, 20608, 1, 0, 0, 0, 20608, 20610, 1, 0, 0, 0, 20609, + 20604, 1, 0, 0, 0, 20610, 20613, 1, 0, 0, 0, 20611, 20609, 1, 0, 0, 0, + 20611, 20612, 1, 0, 0, 0, 20612, 20615, 1, 0, 0, 0, 20613, 20611, 1, 0, + 0, 0, 20614, 20595, 1, 0, 0, 0, 20614, 20599, 1, 0, 0, 0, 20614, 20600, + 1, 0, 0, 0, 20615, 20616, 1, 0, 0, 0, 20616, 20618, 5, 2448, 0, 0, 20617, + 20619, 3, 2362, 1181, 0, 20618, 20617, 1, 0, 0, 0, 20618, 20619, 1, 0, + 0, 0, 20619, 2369, 1, 0, 0, 0, 20620, 20621, 7, 275, 0, 0, 20621, 20622, + 5, 1229, 0, 0, 20622, 2371, 1, 0, 0, 0, 20623, 20624, 3, 2402, 1201, 0, + 20624, 20625, 5, 2472, 0, 0, 20625, 20626, 5, 2467, 0, 0, 20626, 20628, + 1, 0, 0, 0, 20627, 20623, 1, 0, 0, 0, 20627, 20628, 1, 0, 0, 0, 20628, + 20629, 1, 0, 0, 0, 20629, 20630, 3, 2078, 1039, 0, 20630, 2373, 1, 0, 0, + 0, 20631, 20640, 3, 2376, 1188, 0, 20632, 20634, 5, 1530, 0, 0, 20633, + 20632, 1, 0, 0, 0, 20633, 20634, 1, 0, 0, 0, 20634, 20635, 1, 0, 0, 0, + 20635, 20637, 3, 2314, 1157, 0, 20636, 20638, 7, 276, 0, 0, 20637, 20636, + 1, 0, 0, 0, 20637, 20638, 1, 0, 0, 0, 20638, 20640, 1, 0, 0, 0, 20639, + 20631, 1, 0, 0, 0, 20639, 20633, 1, 0, 0, 0, 20640, 2375, 1, 0, 0, 0, 20641, + 20643, 3, 2380, 1190, 0, 20642, 20644, 3, 2378, 1189, 0, 20643, 20642, + 1, 0, 0, 0, 20643, 20644, 1, 0, 0, 0, 20644, 20654, 1, 0, 0, 0, 20645, + 20647, 5, 2308, 0, 0, 20646, 20648, 5, 873, 0, 0, 20647, 20646, 1, 0, 0, + 0, 20647, 20648, 1, 0, 0, 0, 20648, 20649, 1, 0, 0, 0, 20649, 20650, 5, + 2112, 0, 0, 20650, 20655, 5, 2363, 0, 0, 20651, 20652, 5, 193, 0, 0, 20652, + 20653, 5, 1671, 0, 0, 20653, 20655, 3, 2346, 1173, 0, 20654, 20645, 1, + 0, 0, 0, 20654, 20651, 1, 0, 0, 0, 20654, 20655, 1, 0, 0, 0, 20655, 20673, + 1, 0, 0, 0, 20656, 20657, 5, 776, 0, 0, 20657, 20662, 7, 277, 0, 0, 20658, + 20659, 5, 2447, 0, 0, 20659, 20660, 3, 2078, 1039, 0, 20660, 20661, 5, + 2448, 0, 0, 20661, 20663, 1, 0, 0, 0, 20662, 20658, 1, 0, 0, 0, 20662, + 20663, 1, 0, 0, 0, 20663, 20664, 1, 0, 0, 0, 20664, 20665, 5, 2141, 0, + 0, 20665, 20670, 7, 278, 0, 0, 20666, 20667, 5, 2447, 0, 0, 20667, 20668, + 3, 2078, 1039, 0, 20668, 20669, 5, 2448, 0, 0, 20669, 20671, 1, 0, 0, 0, + 20670, 20666, 1, 0, 0, 0, 20670, 20671, 1, 0, 0, 0, 20671, 20673, 1, 0, + 0, 0, 20672, 20641, 1, 0, 0, 0, 20672, 20656, 1, 0, 0, 0, 20673, 2377, + 1, 0, 0, 0, 20674, 20677, 5, 2447, 0, 0, 20675, 20678, 3, 2396, 1198, 0, + 20676, 20678, 5, 2450, 0, 0, 20677, 20675, 1, 0, 0, 0, 20677, 20676, 1, + 0, 0, 0, 20678, 20684, 1, 0, 0, 0, 20679, 20682, 5, 2453, 0, 0, 20680, + 20683, 3, 2396, 1198, 0, 20681, 20683, 3, 2398, 1199, 0, 20682, 20680, + 1, 0, 0, 0, 20682, 20681, 1, 0, 0, 0, 20683, 20685, 1, 0, 0, 0, 20684, + 20679, 1, 0, 0, 0, 20684, 20685, 1, 0, 0, 0, 20685, 20687, 1, 0, 0, 0, + 20686, 20688, 7, 238, 0, 0, 20687, 20686, 1, 0, 0, 0, 20687, 20688, 1, + 0, 0, 0, 20688, 20689, 1, 0, 0, 0, 20689, 20690, 5, 2448, 0, 0, 20690, + 2379, 1, 0, 0, 0, 20691, 20757, 5, 131, 0, 0, 20692, 20757, 5, 1403, 0, + 0, 20693, 20757, 5, 1004, 0, 0, 20694, 20757, 5, 128, 0, 0, 20695, 20757, + 5, 125, 0, 0, 20696, 20757, 5, 1005, 0, 0, 20697, 20757, 5, 1420, 0, 0, + 20698, 20757, 5, 1419, 0, 0, 20699, 20757, 5, 1692, 0, 0, 20700, 20757, + 5, 1693, 0, 0, 20701, 20757, 5, 1235, 0, 0, 20702, 20757, 5, 380, 0, 0, + 20703, 20757, 5, 769, 0, 0, 20704, 20757, 5, 777, 0, 0, 20705, 20757, 5, + 1231, 0, 0, 20706, 20757, 5, 1706, 0, 0, 20707, 20757, 5, 1230, 0, 0, 20708, + 20757, 5, 381, 0, 0, 20709, 20711, 5, 465, 0, 0, 20710, 20712, 5, 1437, + 0, 0, 20711, 20710, 1, 0, 0, 0, 20711, 20712, 1, 0, 0, 0, 20712, 20757, + 1, 0, 0, 0, 20713, 20757, 5, 607, 0, 0, 20714, 20757, 5, 1509, 0, 0, 20715, + 20757, 5, 1008, 0, 0, 20716, 20718, 5, 893, 0, 0, 20717, 20719, 5, 1498, + 0, 0, 20718, 20717, 1, 0, 0, 0, 20718, 20719, 1, 0, 0, 0, 20719, 20757, + 1, 0, 0, 0, 20720, 20757, 5, 196, 0, 0, 20721, 20723, 5, 193, 0, 0, 20722, + 20724, 5, 2269, 0, 0, 20723, 20722, 1, 0, 0, 0, 20723, 20724, 1, 0, 0, + 0, 20724, 20757, 1, 0, 0, 0, 20725, 20757, 5, 2259, 0, 0, 20726, 20757, + 5, 2260, 0, 0, 20727, 20757, 5, 1767, 0, 0, 20728, 20757, 5, 1498, 0, 0, + 20729, 20757, 5, 148, 0, 0, 20730, 20757, 5, 361, 0, 0, 20731, 20757, 5, + 1601, 0, 0, 20732, 20757, 5, 2214, 0, 0, 20733, 20757, 5, 2358, 0, 0, 20734, + 20757, 5, 985, 0, 0, 20735, 20757, 5, 365, 0, 0, 20736, 20757, 5, 679, + 0, 0, 20737, 20757, 5, 958, 0, 0, 20738, 20757, 5, 1636, 0, 0, 20739, 20757, + 5, 1633, 0, 0, 20740, 20757, 5, 2115, 0, 0, 20741, 20757, 5, 2116, 0, 0, + 20742, 20757, 5, 2118, 0, 0, 20743, 20757, 5, 2114, 0, 0, 20744, 20757, + 5, 2108, 0, 0, 20745, 20757, 5, 2110, 0, 0, 20746, 20757, 5, 2109, 0, 0, + 20747, 20757, 5, 2107, 0, 0, 20748, 20757, 5, 2361, 0, 0, 20749, 20757, + 5, 471, 0, 0, 20750, 20757, 5, 119, 0, 0, 20751, 20757, 5, 142, 0, 0, 20752, + 20757, 5, 215, 0, 0, 20753, 20757, 5, 1010, 0, 0, 20754, 20757, 5, 966, + 0, 0, 20755, 20757, 5, 2351, 0, 0, 20756, 20691, 1, 0, 0, 0, 20756, 20692, + 1, 0, 0, 0, 20756, 20693, 1, 0, 0, 0, 20756, 20694, 1, 0, 0, 0, 20756, + 20695, 1, 0, 0, 0, 20756, 20696, 1, 0, 0, 0, 20756, 20697, 1, 0, 0, 0, + 20756, 20698, 1, 0, 0, 0, 20756, 20699, 1, 0, 0, 0, 20756, 20700, 1, 0, + 0, 0, 20756, 20701, 1, 0, 0, 0, 20756, 20702, 1, 0, 0, 0, 20756, 20703, + 1, 0, 0, 0, 20756, 20704, 1, 0, 0, 0, 20756, 20705, 1, 0, 0, 0, 20756, + 20706, 1, 0, 0, 0, 20756, 20707, 1, 0, 0, 0, 20756, 20708, 1, 0, 0, 0, + 20756, 20709, 1, 0, 0, 0, 20756, 20713, 1, 0, 0, 0, 20756, 20714, 1, 0, + 0, 0, 20756, 20715, 1, 0, 0, 0, 20756, 20716, 1, 0, 0, 0, 20756, 20720, + 1, 0, 0, 0, 20756, 20721, 1, 0, 0, 0, 20756, 20725, 1, 0, 0, 0, 20756, + 20726, 1, 0, 0, 0, 20756, 20727, 1, 0, 0, 0, 20756, 20728, 1, 0, 0, 0, + 20756, 20729, 1, 0, 0, 0, 20756, 20730, 1, 0, 0, 0, 20756, 20731, 1, 0, + 0, 0, 20756, 20732, 1, 0, 0, 0, 20756, 20733, 1, 0, 0, 0, 20756, 20734, + 1, 0, 0, 0, 20756, 20735, 1, 0, 0, 0, 20756, 20736, 1, 0, 0, 0, 20756, + 20737, 1, 0, 0, 0, 20756, 20738, 1, 0, 0, 0, 20756, 20739, 1, 0, 0, 0, + 20756, 20740, 1, 0, 0, 0, 20756, 20741, 1, 0, 0, 0, 20756, 20742, 1, 0, + 0, 0, 20756, 20743, 1, 0, 0, 0, 20756, 20744, 1, 0, 0, 0, 20756, 20745, + 1, 0, 0, 0, 20756, 20746, 1, 0, 0, 0, 20756, 20747, 1, 0, 0, 0, 20756, + 20748, 1, 0, 0, 0, 20756, 20749, 1, 0, 0, 0, 20756, 20750, 1, 0, 0, 0, + 20756, 20751, 1, 0, 0, 0, 20756, 20752, 1, 0, 0, 0, 20756, 20753, 1, 0, + 0, 0, 20756, 20754, 1, 0, 0, 0, 20756, 20755, 1, 0, 0, 0, 20757, 2381, + 1, 0, 0, 0, 20758, 20762, 5, 2462, 0, 0, 20759, 20760, 5, 2469, 0, 0, 20760, + 20762, 5, 2441, 0, 0, 20761, 20758, 1, 0, 0, 0, 20761, 20759, 1, 0, 0, + 0, 20762, 20771, 1, 0, 0, 0, 20763, 20765, 5, 733, 0, 0, 20764, 20763, + 1, 0, 0, 0, 20764, 20765, 1, 0, 0, 0, 20765, 20769, 1, 0, 0, 0, 20766, + 20770, 5, 2462, 0, 0, 20767, 20768, 5, 2469, 0, 0, 20768, 20770, 5, 2441, + 0, 0, 20769, 20766, 1, 0, 0, 0, 20769, 20767, 1, 0, 0, 0, 20770, 20772, + 1, 0, 0, 0, 20771, 20764, 1, 0, 0, 0, 20771, 20772, 1, 0, 0, 0, 20772, + 20777, 1, 0, 0, 0, 20773, 20774, 5, 2440, 0, 0, 20774, 20776, 3, 2386, + 1193, 0, 20775, 20773, 1, 0, 0, 0, 20776, 20779, 1, 0, 0, 0, 20777, 20775, + 1, 0, 0, 0, 20777, 20778, 1, 0, 0, 0, 20778, 2383, 1, 0, 0, 0, 20779, 20777, + 1, 0, 0, 0, 20780, 20781, 6, 1192, -1, 0, 20781, 20787, 3, 2386, 1193, + 0, 20782, 20783, 5, 2447, 0, 0, 20783, 20784, 3, 2384, 1192, 0, 20784, + 20785, 5, 2448, 0, 0, 20785, 20787, 1, 0, 0, 0, 20786, 20780, 1, 0, 0, + 0, 20786, 20782, 1, 0, 0, 0, 20787, 20797, 1, 0, 0, 0, 20788, 20791, 10, + 2, 0, 0, 20789, 20790, 5, 2440, 0, 0, 20790, 20792, 3, 2386, 1193, 0, 20791, + 20789, 1, 0, 0, 0, 20792, 20793, 1, 0, 0, 0, 20793, 20791, 1, 0, 0, 0, + 20793, 20794, 1, 0, 0, 0, 20794, 20796, 1, 0, 0, 0, 20795, 20788, 1, 0, + 0, 0, 20796, 20799, 1, 0, 0, 0, 20797, 20795, 1, 0, 0, 0, 20797, 20798, + 1, 0, 0, 0, 20798, 2385, 1, 0, 0, 0, 20799, 20797, 1, 0, 0, 0, 20800, 20801, + 5, 2475, 0, 0, 20801, 20803, 3, 2346, 1173, 0, 20802, 20800, 1, 0, 0, 0, + 20802, 20803, 1, 0, 0, 0, 20803, 20804, 1, 0, 0, 0, 20804, 20807, 3, 2404, + 1202, 0, 20805, 20806, 5, 2456, 0, 0, 20806, 20808, 3, 2334, 1167, 0, 20807, + 20805, 1, 0, 0, 0, 20807, 20808, 1, 0, 0, 0, 20808, 20812, 1, 0, 0, 0, + 20809, 20811, 3, 2364, 1182, 0, 20810, 20809, 1, 0, 0, 0, 20811, 20814, + 1, 0, 0, 0, 20812, 20810, 1, 0, 0, 0, 20812, 20813, 1, 0, 0, 0, 20813, + 2387, 1, 0, 0, 0, 20814, 20812, 1, 0, 0, 0, 20815, 20816, 5, 2475, 0, 0, + 20816, 20818, 3, 2346, 1173, 0, 20817, 20815, 1, 0, 0, 0, 20817, 20818, + 1, 0, 0, 0, 20818, 20819, 1, 0, 0, 0, 20819, 20824, 3, 2404, 1202, 0, 20820, + 20821, 5, 2440, 0, 0, 20821, 20823, 3, 2404, 1202, 0, 20822, 20820, 1, + 0, 0, 0, 20823, 20826, 1, 0, 0, 0, 20824, 20822, 1, 0, 0, 0, 20824, 20825, + 1, 0, 0, 0, 20825, 2389, 1, 0, 0, 0, 20826, 20824, 1, 0, 0, 0, 20827, 20829, + 5, 38, 0, 0, 20828, 20830, 5, 1459, 0, 0, 20829, 20828, 1, 0, 0, 0, 20829, + 20830, 1, 0, 0, 0, 20830, 20864, 1, 0, 0, 0, 20831, 20864, 5, 42, 0, 0, + 20832, 20864, 5, 378, 0, 0, 20833, 20864, 5, 403, 0, 0, 20834, 20864, 5, + 542, 0, 0, 20835, 20864, 5, 605, 0, 0, 20836, 20837, 5, 605, 0, 0, 20837, + 20864, 5, 64, 0, 0, 20838, 20864, 5, 717, 0, 0, 20839, 20840, 5, 737, 0, + 0, 20840, 20864, 5, 1459, 0, 0, 20841, 20842, 5, 737, 0, 0, 20842, 20843, + 5, 1556, 0, 0, 20843, 20864, 5, 1459, 0, 0, 20844, 20864, 5, 756, 0, 0, + 20845, 20846, 5, 814, 0, 0, 20846, 20864, 5, 1653, 0, 0, 20847, 20848, + 5, 946, 0, 0, 20848, 20864, 5, 2286, 0, 0, 20849, 20850, 5, 1259, 0, 0, + 20850, 20851, 5, 242, 0, 0, 20851, 20864, 5, 1531, 0, 0, 20852, 20853, + 5, 1484, 0, 0, 20853, 20864, 5, 1591, 0, 0, 20854, 20864, 5, 1505, 0, 0, + 20855, 20864, 5, 1528, 0, 0, 20856, 20864, 5, 1647, 0, 0, 20857, 20858, + 5, 2153, 0, 0, 20858, 20864, 5, 1722, 0, 0, 20859, 20864, 5, 2177, 0, 0, + 20860, 20864, 5, 2207, 0, 0, 20861, 20864, 5, 2241, 0, 0, 20862, 20864, + 5, 2313, 0, 0, 20863, 20827, 1, 0, 0, 0, 20863, 20831, 1, 0, 0, 0, 20863, + 20832, 1, 0, 0, 0, 20863, 20833, 1, 0, 0, 0, 20863, 20834, 1, 0, 0, 0, + 20863, 20835, 1, 0, 0, 0, 20863, 20836, 1, 0, 0, 0, 20863, 20838, 1, 0, + 0, 0, 20863, 20839, 1, 0, 0, 0, 20863, 20841, 1, 0, 0, 0, 20863, 20844, + 1, 0, 0, 0, 20863, 20845, 1, 0, 0, 0, 20863, 20847, 1, 0, 0, 0, 20863, + 20849, 1, 0, 0, 0, 20863, 20852, 1, 0, 0, 0, 20863, 20854, 1, 0, 0, 0, + 20863, 20855, 1, 0, 0, 0, 20863, 20856, 1, 0, 0, 0, 20863, 20857, 1, 0, + 0, 0, 20863, 20859, 1, 0, 0, 0, 20863, 20860, 1, 0, 0, 0, 20863, 20861, + 1, 0, 0, 0, 20863, 20862, 1, 0, 0, 0, 20864, 2391, 1, 0, 0, 0, 20865, 20866, + 5, 38, 0, 0, 20866, 21192, 5, 1459, 0, 0, 20867, 21192, 5, 31, 0, 0, 20868, + 20870, 5, 27, 0, 0, 20869, 20871, 5, 55, 0, 0, 20870, 20869, 1, 0, 0, 0, + 20870, 20871, 1, 0, 0, 0, 20871, 20872, 1, 0, 0, 0, 20872, 20873, 5, 1722, + 0, 0, 20873, 20874, 5, 2163, 0, 0, 20874, 21192, 5, 1671, 0, 0, 20875, + 20876, 7, 59, 0, 0, 20876, 20877, 5, 55, 0, 0, 20877, 20878, 5, 1722, 0, + 0, 20878, 21192, 5, 1463, 0, 0, 20879, 20880, 5, 27, 0, 0, 20880, 20881, + 5, 1722, 0, 0, 20881, 20882, 5, 906, 0, 0, 20882, 21192, 5, 1238, 0, 0, + 20883, 20885, 5, 321, 0, 0, 20884, 20886, 5, 55, 0, 0, 20885, 20884, 1, + 0, 0, 0, 20885, 20886, 1, 0, 0, 0, 20886, 20887, 1, 0, 0, 0, 20887, 21192, + 5, 220, 0, 0, 20888, 20889, 7, 279, 0, 0, 20889, 20890, 5, 55, 0, 0, 20890, + 21192, 5, 220, 0, 0, 20891, 20892, 7, 280, 0, 0, 20892, 20893, 5, 55, 0, + 0, 20893, 21192, 5, 296, 0, 0, 20894, 20895, 5, 543, 0, 0, 20895, 20896, + 5, 1520, 0, 0, 20896, 21192, 5, 1412, 0, 0, 20897, 20898, 5, 42, 0, 0, + 20898, 21192, 5, 350, 0, 0, 20899, 20901, 7, 281, 0, 0, 20900, 20902, 5, + 1473, 0, 0, 20901, 20900, 1, 0, 0, 0, 20901, 20902, 1, 0, 0, 0, 20902, + 20903, 1, 0, 0, 0, 20903, 20904, 5, 350, 0, 0, 20904, 21192, 5, 861, 0, + 0, 20905, 20906, 5, 469, 0, 0, 20906, 20907, 5, 1473, 0, 0, 20907, 20908, + 5, 350, 0, 0, 20908, 21192, 5, 861, 0, 0, 20909, 20910, 5, 378, 0, 0, 20910, + 20911, 5, 280, 0, 0, 20911, 21192, 5, 1667, 0, 0, 20912, 20913, 5, 378, + 0, 0, 20913, 20914, 5, 55, 0, 0, 20914, 21192, 5, 1461, 0, 0, 20915, 20916, + 5, 46, 0, 0, 20916, 20917, 5, 55, 0, 0, 20917, 21192, 5, 421, 0, 0, 20918, + 20920, 5, 321, 0, 0, 20919, 20921, 5, 55, 0, 0, 20920, 20919, 1, 0, 0, + 0, 20920, 20921, 1, 0, 0, 0, 20921, 20922, 1, 0, 0, 0, 20922, 21192, 5, + 422, 0, 0, 20923, 20924, 7, 279, 0, 0, 20924, 20925, 5, 55, 0, 0, 20925, + 21192, 5, 422, 0, 0, 20926, 20927, 7, 280, 0, 0, 20927, 20928, 5, 55, 0, + 0, 20928, 21192, 5, 426, 0, 0, 20929, 20930, 7, 280, 0, 0, 20930, 20931, + 5, 55, 0, 0, 20931, 21192, 5, 483, 0, 0, 20932, 20937, 5, 605, 0, 0, 20933, + 20934, 5, 64, 0, 0, 20934, 20938, 5, 27, 0, 0, 20935, 20936, 5, 55, 0, + 0, 20936, 20938, 5, 2083, 0, 0, 20937, 20933, 1, 0, 0, 0, 20937, 20935, + 1, 0, 0, 0, 20938, 21192, 1, 0, 0, 0, 20939, 20940, 7, 59, 0, 0, 20940, + 20941, 5, 55, 0, 0, 20941, 21192, 5, 717, 0, 0, 20942, 20944, 5, 321, 0, + 0, 20943, 20945, 5, 55, 0, 0, 20944, 20943, 1, 0, 0, 0, 20944, 20945, 1, + 0, 0, 0, 20945, 20946, 1, 0, 0, 0, 20946, 21192, 5, 731, 0, 0, 20947, 20948, + 7, 282, 0, 0, 20948, 20949, 5, 55, 0, 0, 20949, 21192, 5, 731, 0, 0, 20950, + 20952, 5, 321, 0, 0, 20951, 20953, 7, 283, 0, 0, 20952, 20951, 1, 0, 0, + 0, 20952, 20953, 1, 0, 0, 0, 20953, 20954, 1, 0, 0, 0, 20954, 21192, 5, + 793, 0, 0, 20955, 20956, 5, 542, 0, 0, 20956, 20957, 5, 55, 0, 0, 20957, + 21192, 7, 284, 0, 0, 20958, 20959, 5, 905, 0, 0, 20959, 21192, 5, 1623, + 0, 0, 20960, 20961, 5, 27, 0, 0, 20961, 20962, 5, 816, 0, 0, 20962, 21192, + 5, 906, 0, 0, 20963, 20965, 5, 321, 0, 0, 20964, 20966, 5, 55, 0, 0, 20965, + 20964, 1, 0, 0, 0, 20965, 20966, 1, 0, 0, 0, 20966, 20967, 1, 0, 0, 0, + 20967, 21192, 5, 849, 0, 0, 20968, 20969, 7, 282, 0, 0, 20969, 20970, 5, + 55, 0, 0, 20970, 21192, 5, 849, 0, 0, 20971, 21192, 5, 889, 0, 0, 20972, + 20974, 5, 321, 0, 0, 20973, 20975, 5, 55, 0, 0, 20974, 20973, 1, 0, 0, + 0, 20974, 20975, 1, 0, 0, 0, 20975, 20976, 1, 0, 0, 0, 20976, 20977, 5, + 919, 0, 0, 20977, 21192, 5, 2286, 0, 0, 20978, 20979, 7, 279, 0, 0, 20979, + 20980, 5, 55, 0, 0, 20980, 20981, 5, 919, 0, 0, 20981, 21192, 5, 2286, + 0, 0, 20982, 20984, 5, 642, 0, 0, 20983, 20982, 1, 0, 0, 0, 20983, 20984, + 1, 0, 0, 0, 20984, 20985, 1, 0, 0, 0, 20985, 20986, 5, 1484, 0, 0, 20986, + 21192, 5, 1591, 0, 0, 20987, 20988, 5, 1259, 0, 0, 20988, 20989, 5, 242, + 0, 0, 20989, 21192, 5, 1531, 0, 0, 20990, 20992, 5, 321, 0, 0, 20991, 20993, + 5, 55, 0, 0, 20992, 20991, 1, 0, 0, 0, 20992, 20993, 1, 0, 0, 0, 20993, + 20994, 1, 0, 0, 0, 20994, 20995, 5, 955, 0, 0, 20995, 21192, 5, 971, 0, + 0, 20996, 20997, 7, 285, 0, 0, 20997, 20998, 5, 55, 0, 0, 20998, 20999, + 5, 955, 0, 0, 20999, 21192, 5, 971, 0, 0, 21000, 21002, 5, 321, 0, 0, 21001, + 21003, 5, 55, 0, 0, 21002, 21001, 1, 0, 0, 0, 21002, 21003, 1, 0, 0, 0, + 21003, 21004, 1, 0, 0, 0, 21004, 21192, 5, 332, 0, 0, 21005, 21006, 7, + 286, 0, 0, 21006, 21007, 5, 55, 0, 0, 21007, 21192, 5, 332, 0, 0, 21008, + 21010, 5, 321, 0, 0, 21009, 21011, 5, 55, 0, 0, 21010, 21009, 1, 0, 0, + 0, 21010, 21011, 1, 0, 0, 0, 21011, 21012, 1, 0, 0, 0, 21012, 21013, 5, + 933, 0, 0, 21013, 21192, 5, 612, 0, 0, 21014, 21015, 7, 287, 0, 0, 21015, + 21016, 5, 55, 0, 0, 21016, 21017, 5, 933, 0, 0, 21017, 21192, 5, 612, 0, + 0, 21018, 21020, 5, 321, 0, 0, 21019, 21021, 5, 55, 0, 0, 21020, 21019, + 1, 0, 0, 0, 21020, 21021, 1, 0, 0, 0, 21021, 21022, 1, 0, 0, 0, 21022, + 21023, 5, 332, 0, 0, 21023, 21192, 5, 422, 0, 0, 21024, 21025, 7, 288, + 0, 0, 21025, 21026, 5, 55, 0, 0, 21026, 21027, 5, 332, 0, 0, 21027, 21192, + 5, 422, 0, 0, 21028, 21030, 5, 321, 0, 0, 21029, 21031, 5, 55, 0, 0, 21030, + 21029, 1, 0, 0, 0, 21030, 21031, 1, 0, 0, 0, 21031, 21032, 1, 0, 0, 0, + 21032, 21033, 5, 332, 0, 0, 21033, 21034, 5, 158, 0, 0, 21034, 21192, 5, + 1462, 0, 0, 21035, 21036, 7, 289, 0, 0, 21036, 21037, 5, 55, 0, 0, 21037, + 21038, 5, 332, 0, 0, 21038, 21039, 5, 158, 0, 0, 21039, 21192, 5, 1462, + 0, 0, 21040, 21042, 5, 321, 0, 0, 21041, 21043, 5, 55, 0, 0, 21042, 21041, + 1, 0, 0, 0, 21042, 21043, 1, 0, 0, 0, 21043, 21044, 1, 0, 0, 0, 21044, + 21192, 5, 1266, 0, 0, 21045, 21046, 7, 282, 0, 0, 21046, 21047, 5, 55, + 0, 0, 21047, 21192, 5, 1266, 0, 0, 21048, 21049, 7, 59, 0, 0, 21049, 21050, + 5, 55, 0, 0, 21050, 21192, 5, 1315, 0, 0, 21051, 21052, 5, 321, 0, 0, 21052, + 21053, 5, 1409, 0, 0, 21053, 21192, 5, 350, 0, 0, 21054, 21055, 5, 1671, + 0, 0, 21055, 21192, 5, 289, 0, 0, 21056, 21058, 5, 321, 0, 0, 21057, 21059, + 5, 55, 0, 0, 21058, 21057, 1, 0, 0, 0, 21058, 21059, 1, 0, 0, 0, 21059, + 21060, 1, 0, 0, 0, 21060, 21192, 5, 1461, 0, 0, 21061, 21062, 7, 282, 0, + 0, 21062, 21063, 5, 55, 0, 0, 21063, 21192, 5, 1461, 0, 0, 21064, 21065, + 7, 59, 0, 0, 21065, 21192, 5, 1463, 0, 0, 21066, 21067, 5, 321, 0, 0, 21067, + 21192, 5, 1593, 0, 0, 21068, 21069, 7, 290, 0, 0, 21069, 21070, 5, 55, + 0, 0, 21070, 21192, 5, 1593, 0, 0, 21071, 21072, 7, 59, 0, 0, 21072, 21073, + 5, 1596, 0, 0, 21073, 21192, 5, 1645, 0, 0, 21074, 21076, 5, 321, 0, 0, + 21075, 21077, 5, 55, 0, 0, 21076, 21075, 1, 0, 0, 0, 21076, 21077, 1, 0, + 0, 0, 21077, 21078, 1, 0, 0, 0, 21078, 21192, 5, 1653, 0, 0, 21079, 21080, + 7, 291, 0, 0, 21080, 21081, 5, 55, 0, 0, 21081, 21192, 5, 1653, 0, 0, 21082, + 21083, 7, 292, 0, 0, 21083, 21192, 5, 1667, 0, 0, 21084, 21085, 5, 42, + 0, 0, 21085, 21086, 5, 1570, 0, 0, 21086, 21192, 5, 311, 0, 0, 21087, 21089, + 5, 321, 0, 0, 21088, 21090, 5, 55, 0, 0, 21089, 21088, 1, 0, 0, 0, 21089, + 21090, 1, 0, 0, 0, 21090, 21091, 1, 0, 0, 0, 21091, 21092, 5, 1722, 0, + 0, 21092, 21093, 5, 2154, 0, 0, 21093, 21192, 5, 1463, 0, 0, 21094, 21095, + 7, 293, 0, 0, 21095, 21096, 5, 55, 0, 0, 21096, 21097, 5, 1722, 0, 0, 21097, + 21098, 5, 2154, 0, 0, 21098, 21192, 5, 1463, 0, 0, 21099, 21100, 5, 2153, + 0, 0, 21100, 21101, 5, 55, 0, 0, 21101, 21192, 5, 1722, 0, 0, 21102, 21104, + 5, 321, 0, 0, 21103, 21105, 5, 55, 0, 0, 21104, 21103, 1, 0, 0, 0, 21104, + 21105, 1, 0, 0, 0, 21105, 21106, 1, 0, 0, 0, 21106, 21192, 5, 1796, 0, + 0, 21107, 21108, 5, 469, 0, 0, 21108, 21109, 5, 55, 0, 0, 21109, 21192, + 5, 1796, 0, 0, 21110, 21111, 7, 280, 0, 0, 21111, 21112, 5, 1473, 0, 0, + 21112, 21192, 5, 1796, 0, 0, 21113, 21115, 5, 321, 0, 0, 21114, 21116, + 5, 55, 0, 0, 21115, 21114, 1, 0, 0, 0, 21115, 21116, 1, 0, 0, 0, 21116, + 21117, 1, 0, 0, 0, 21117, 21192, 5, 2083, 0, 0, 21118, 21119, 7, 294, 0, + 0, 21119, 21120, 5, 55, 0, 0, 21120, 21192, 5, 2083, 0, 0, 21121, 21122, + 7, 295, 0, 0, 21122, 21192, 5, 2080, 0, 0, 21123, 21125, 5, 321, 0, 0, + 21124, 21126, 5, 55, 0, 0, 21125, 21124, 1, 0, 0, 0, 21125, 21126, 1, 0, + 0, 0, 21126, 21127, 1, 0, 0, 0, 21127, 21192, 5, 2157, 0, 0, 21128, 21129, + 7, 279, 0, 0, 21129, 21130, 5, 55, 0, 0, 21130, 21192, 5, 2157, 0, 0, 21131, + 21132, 5, 27, 0, 0, 21132, 21133, 5, 350, 0, 0, 21133, 21192, 5, 2157, + 0, 0, 21134, 21136, 5, 321, 0, 0, 21135, 21137, 5, 55, 0, 0, 21136, 21135, + 1, 0, 0, 0, 21136, 21137, 1, 0, 0, 0, 21137, 21138, 1, 0, 0, 0, 21138, + 21192, 5, 2166, 0, 0, 21139, 21140, 7, 296, 0, 0, 21140, 21141, 5, 55, + 0, 0, 21141, 21192, 5, 2166, 0, 0, 21142, 21143, 7, 59, 0, 0, 21143, 21192, + 5, 2237, 0, 0, 21144, 21146, 5, 321, 0, 0, 21145, 21147, 5, 55, 0, 0, 21146, + 21145, 1, 0, 0, 0, 21146, 21147, 1, 0, 0, 0, 21147, 21148, 1, 0, 0, 0, + 21148, 21192, 5, 2286, 0, 0, 21149, 21150, 7, 297, 0, 0, 21150, 21151, + 5, 55, 0, 0, 21151, 21192, 5, 2286, 0, 0, 21152, 21153, 7, 298, 0, 0, 21153, + 21192, 5, 55, 0, 0, 21154, 21155, 5, 111, 0, 0, 21155, 21192, 5, 2237, + 0, 0, 21156, 21157, 5, 190, 0, 0, 21157, 21192, 5, 1202, 0, 0, 21158, 21159, + 5, 543, 0, 0, 21159, 21160, 5, 4, 0, 0, 21160, 21192, 5, 1412, 0, 0, 21161, + 21163, 5, 616, 0, 0, 21162, 21164, 5, 55, 0, 0, 21163, 21162, 1, 0, 0, + 0, 21163, 21164, 1, 0, 0, 0, 21164, 21165, 1, 0, 0, 0, 21165, 21192, 5, + 2147, 0, 0, 21166, 21167, 5, 647, 0, 0, 21167, 21169, 5, 55, 0, 0, 21168, + 21170, 5, 1238, 0, 0, 21169, 21168, 1, 0, 0, 0, 21169, 21170, 1, 0, 0, + 0, 21170, 21171, 1, 0, 0, 0, 21171, 21192, 5, 1458, 0, 0, 21172, 21173, + 5, 737, 0, 0, 21173, 21174, 5, 55, 0, 0, 21174, 21192, 5, 1459, 0, 0, 21175, + 21176, 5, 814, 0, 0, 21176, 21177, 5, 361, 0, 0, 21177, 21192, 5, 2112, + 0, 0, 21178, 21179, 5, 814, 0, 0, 21179, 21192, 5, 1832, 0, 0, 21180, 21181, + 5, 1475, 0, 0, 21181, 21192, 5, 369, 0, 0, 21182, 21192, 5, 1581, 0, 0, + 21183, 21184, 5, 1647, 0, 0, 21184, 21185, 5, 55, 0, 0, 21185, 21192, 7, + 299, 0, 0, 21186, 21192, 5, 1801, 0, 0, 21187, 21192, 5, 1807, 0, 0, 21188, + 21192, 5, 1809, 0, 0, 21189, 21192, 5, 1833, 0, 0, 21190, 21192, 5, 1868, + 0, 0, 21191, 20865, 1, 0, 0, 0, 21191, 20867, 1, 0, 0, 0, 21191, 20868, + 1, 0, 0, 0, 21191, 20875, 1, 0, 0, 0, 21191, 20879, 1, 0, 0, 0, 21191, + 20883, 1, 0, 0, 0, 21191, 20888, 1, 0, 0, 0, 21191, 20891, 1, 0, 0, 0, + 21191, 20894, 1, 0, 0, 0, 21191, 20897, 1, 0, 0, 0, 21191, 20899, 1, 0, + 0, 0, 21191, 20905, 1, 0, 0, 0, 21191, 20909, 1, 0, 0, 0, 21191, 20912, + 1, 0, 0, 0, 21191, 20915, 1, 0, 0, 0, 21191, 20918, 1, 0, 0, 0, 21191, + 20923, 1, 0, 0, 0, 21191, 20926, 1, 0, 0, 0, 21191, 20929, 1, 0, 0, 0, + 21191, 20932, 1, 0, 0, 0, 21191, 20939, 1, 0, 0, 0, 21191, 20942, 1, 0, + 0, 0, 21191, 20947, 1, 0, 0, 0, 21191, 20950, 1, 0, 0, 0, 21191, 20955, + 1, 0, 0, 0, 21191, 20958, 1, 0, 0, 0, 21191, 20960, 1, 0, 0, 0, 21191, + 20963, 1, 0, 0, 0, 21191, 20968, 1, 0, 0, 0, 21191, 20971, 1, 0, 0, 0, + 21191, 20972, 1, 0, 0, 0, 21191, 20978, 1, 0, 0, 0, 21191, 20983, 1, 0, + 0, 0, 21191, 20987, 1, 0, 0, 0, 21191, 20990, 1, 0, 0, 0, 21191, 20996, + 1, 0, 0, 0, 21191, 21000, 1, 0, 0, 0, 21191, 21005, 1, 0, 0, 0, 21191, + 21008, 1, 0, 0, 0, 21191, 21014, 1, 0, 0, 0, 21191, 21018, 1, 0, 0, 0, + 21191, 21024, 1, 0, 0, 0, 21191, 21028, 1, 0, 0, 0, 21191, 21035, 1, 0, + 0, 0, 21191, 21040, 1, 0, 0, 0, 21191, 21045, 1, 0, 0, 0, 21191, 21048, + 1, 0, 0, 0, 21191, 21051, 1, 0, 0, 0, 21191, 21054, 1, 0, 0, 0, 21191, + 21056, 1, 0, 0, 0, 21191, 21061, 1, 0, 0, 0, 21191, 21064, 1, 0, 0, 0, + 21191, 21066, 1, 0, 0, 0, 21191, 21068, 1, 0, 0, 0, 21191, 21071, 1, 0, + 0, 0, 21191, 21074, 1, 0, 0, 0, 21191, 21079, 1, 0, 0, 0, 21191, 21082, + 1, 0, 0, 0, 21191, 21084, 1, 0, 0, 0, 21191, 21087, 1, 0, 0, 0, 21191, + 21094, 1, 0, 0, 0, 21191, 21099, 1, 0, 0, 0, 21191, 21102, 1, 0, 0, 0, + 21191, 21107, 1, 0, 0, 0, 21191, 21110, 1, 0, 0, 0, 21191, 21113, 1, 0, + 0, 0, 21191, 21118, 1, 0, 0, 0, 21191, 21121, 1, 0, 0, 0, 21191, 21123, + 1, 0, 0, 0, 21191, 21128, 1, 0, 0, 0, 21191, 21131, 1, 0, 0, 0, 21191, + 21134, 1, 0, 0, 0, 21191, 21139, 1, 0, 0, 0, 21191, 21142, 1, 0, 0, 0, + 21191, 21144, 1, 0, 0, 0, 21191, 21149, 1, 0, 0, 0, 21191, 21152, 1, 0, + 0, 0, 21191, 21154, 1, 0, 0, 0, 21191, 21156, 1, 0, 0, 0, 21191, 21158, + 1, 0, 0, 0, 21191, 21161, 1, 0, 0, 0, 21191, 21166, 1, 0, 0, 0, 21191, + 21172, 1, 0, 0, 0, 21191, 21175, 1, 0, 0, 0, 21191, 21178, 1, 0, 0, 0, + 21191, 21180, 1, 0, 0, 0, 21191, 21182, 1, 0, 0, 0, 21191, 21183, 1, 0, + 0, 0, 21191, 21186, 1, 0, 0, 0, 21191, 21187, 1, 0, 0, 0, 21191, 21188, + 1, 0, 0, 0, 21191, 21189, 1, 0, 0, 0, 21191, 21190, 1, 0, 0, 0, 21192, + 2393, 1, 0, 0, 0, 21193, 21196, 5, 2108, 0, 0, 21194, 21197, 3, 2400, 1200, + 0, 21195, 21197, 3, 2382, 1191, 0, 21196, 21194, 1, 0, 0, 0, 21196, 21195, + 1, 0, 0, 0, 21197, 21202, 1, 0, 0, 0, 21198, 21199, 5, 82, 0, 0, 21199, + 21200, 5, 2112, 0, 0, 21200, 21201, 5, 2363, 0, 0, 21201, 21203, 3, 2400, + 1200, 0, 21202, 21198, 1, 0, 0, 0, 21202, 21203, 1, 0, 0, 0, 21203, 21257, + 1, 0, 0, 0, 21204, 21208, 5, 776, 0, 0, 21205, 21209, 3, 2400, 1200, 0, + 21206, 21209, 3, 2382, 1191, 0, 21207, 21209, 3, 2386, 1193, 0, 21208, + 21205, 1, 0, 0, 0, 21208, 21206, 1, 0, 0, 0, 21208, 21207, 1, 0, 0, 0, + 21209, 21210, 1, 0, 0, 0, 21210, 21224, 7, 300, 0, 0, 21211, 21214, 5, + 2447, 0, 0, 21212, 21215, 5, 2441, 0, 0, 21213, 21215, 3, 2382, 1191, 0, + 21214, 21212, 1, 0, 0, 0, 21214, 21213, 1, 0, 0, 0, 21215, 21221, 1, 0, + 0, 0, 21216, 21219, 5, 2453, 0, 0, 21217, 21220, 5, 2441, 0, 0, 21218, + 21220, 3, 2382, 1191, 0, 21219, 21217, 1, 0, 0, 0, 21219, 21218, 1, 0, + 0, 0, 21220, 21222, 1, 0, 0, 0, 21221, 21216, 1, 0, 0, 0, 21221, 21222, + 1, 0, 0, 0, 21222, 21223, 1, 0, 0, 0, 21223, 21225, 5, 2448, 0, 0, 21224, + 21211, 1, 0, 0, 0, 21224, 21225, 1, 0, 0, 0, 21225, 21242, 1, 0, 0, 0, + 21226, 21240, 5, 2141, 0, 0, 21227, 21241, 5, 985, 0, 0, 21228, 21241, + 5, 365, 0, 0, 21229, 21241, 5, 679, 0, 0, 21230, 21241, 5, 958, 0, 0, 21231, + 21238, 5, 1636, 0, 0, 21232, 21235, 5, 2447, 0, 0, 21233, 21236, 5, 2441, + 0, 0, 21234, 21236, 3, 2382, 1191, 0, 21235, 21233, 1, 0, 0, 0, 21235, + 21234, 1, 0, 0, 0, 21236, 21237, 1, 0, 0, 0, 21237, 21239, 5, 2448, 0, + 0, 21238, 21232, 1, 0, 0, 0, 21238, 21239, 1, 0, 0, 0, 21239, 21241, 1, + 0, 0, 0, 21240, 21227, 1, 0, 0, 0, 21240, 21228, 1, 0, 0, 0, 21240, 21229, + 1, 0, 0, 0, 21240, 21230, 1, 0, 0, 0, 21240, 21231, 1, 0, 0, 0, 21241, + 21243, 1, 0, 0, 0, 21242, 21226, 1, 0, 0, 0, 21242, 21243, 1, 0, 0, 0, + 21243, 21257, 1, 0, 0, 0, 21244, 21257, 3, 2396, 1198, 0, 21245, 21246, + 5, 361, 0, 0, 21246, 21257, 3, 2400, 1200, 0, 21247, 21257, 3, 2400, 1200, + 0, 21248, 21257, 5, 1228, 0, 0, 21249, 21257, 5, 2158, 0, 0, 21250, 21257, + 5, 575, 0, 0, 21251, 21257, 5, 373, 0, 0, 21252, 21257, 5, 1669, 0, 0, + 21253, 21257, 5, 960, 0, 0, 21254, 21257, 5, 932, 0, 0, 21255, 21257, 5, + 389, 0, 0, 21256, 21193, 1, 0, 0, 0, 21256, 21204, 1, 0, 0, 0, 21256, 21244, + 1, 0, 0, 0, 21256, 21245, 1, 0, 0, 0, 21256, 21247, 1, 0, 0, 0, 21256, + 21248, 1, 0, 0, 0, 21256, 21249, 1, 0, 0, 0, 21256, 21250, 1, 0, 0, 0, + 21256, 21251, 1, 0, 0, 0, 21256, 21252, 1, 0, 0, 0, 21256, 21253, 1, 0, + 0, 0, 21256, 21254, 1, 0, 0, 0, 21256, 21255, 1, 0, 0, 0, 21257, 2395, + 1, 0, 0, 0, 21258, 21260, 5, 2441, 0, 0, 21259, 21261, 5, 2440, 0, 0, 21260, + 21259, 1, 0, 0, 0, 21260, 21261, 1, 0, 0, 0, 21261, 21264, 1, 0, 0, 0, + 21262, 21264, 5, 2442, 0, 0, 21263, 21258, 1, 0, 0, 0, 21263, 21262, 1, + 0, 0, 0, 21264, 2397, 1, 0, 0, 0, 21265, 21266, 5, 2452, 0, 0, 21266, 21267, + 3, 2396, 1198, 0, 21267, 2399, 1, 0, 0, 0, 21268, 21269, 7, 301, 0, 0, + 21269, 2401, 1, 0, 0, 0, 21270, 21271, 5, 2475, 0, 0, 21271, 21273, 3, + 2346, 1173, 0, 21272, 21270, 1, 0, 0, 0, 21272, 21273, 1, 0, 0, 0, 21273, + 21274, 1, 0, 0, 0, 21274, 21275, 3, 2404, 1202, 0, 21275, 2403, 1, 0, 0, + 0, 21276, 21279, 3, 2410, 1205, 0, 21277, 21279, 5, 2444, 0, 0, 21278, + 21276, 1, 0, 0, 0, 21278, 21277, 1, 0, 0, 0, 21279, 2405, 1, 0, 0, 0, 21280, + 21281, 5, 2481, 0, 0, 21281, 2407, 1, 0, 0, 0, 21282, 21283, 5, 2447, 0, + 0, 21283, 21284, 5, 2451, 0, 0, 21284, 21285, 5, 2448, 0, 0, 21285, 2409, + 1, 0, 0, 0, 21286, 21409, 3, 2416, 1208, 0, 21287, 21409, 3, 2414, 1207, + 0, 21288, 21409, 3, 2412, 1206, 0, 21289, 21409, 5, 2480, 0, 0, 21290, + 21409, 5, 85, 0, 0, 21291, 21409, 5, 789, 0, 0, 21292, 21409, 5, 164, 0, + 0, 21293, 21409, 5, 860, 0, 0, 21294, 21409, 5, 1513, 0, 0, 21295, 21409, + 5, 1022, 0, 0, 21296, 21409, 5, 587, 0, 0, 21297, 21409, 5, 912, 0, 0, + 21298, 21409, 5, 3, 0, 0, 21299, 21409, 5, 36, 0, 0, 21300, 21409, 5, 34, + 0, 0, 21301, 21409, 5, 35, 0, 0, 21302, 21409, 5, 46, 0, 0, 21303, 21409, + 5, 96, 0, 0, 21304, 21409, 5, 101, 0, 0, 21305, 21409, 5, 108, 0, 0, 21306, + 21409, 5, 131, 0, 0, 21307, 21409, 5, 148, 0, 0, 21308, 21409, 5, 213, + 0, 0, 21309, 21409, 5, 196, 0, 0, 21310, 21409, 5, 2426, 0, 0, 21311, 21409, + 5, 2427, 0, 0, 21312, 21409, 5, 220, 0, 0, 21313, 21409, 5, 288, 0, 0, + 21314, 21409, 5, 346, 0, 0, 21315, 21409, 5, 182, 0, 0, 21316, 21409, 5, + 381, 0, 0, 21317, 21409, 5, 403, 0, 0, 21318, 21409, 5, 409, 0, 0, 21319, + 21409, 5, 420, 0, 0, 21320, 21409, 5, 471, 0, 0, 21321, 21409, 5, 2428, + 0, 0, 21322, 21409, 5, 480, 0, 0, 21323, 21409, 5, 500, 0, 0, 21324, 21409, + 5, 523, 0, 0, 21325, 21409, 5, 524, 0, 0, 21326, 21409, 5, 518, 0, 0, 21327, + 21409, 5, 535, 0, 0, 21328, 21409, 5, 536, 0, 0, 21329, 21409, 5, 537, + 0, 0, 21330, 21409, 5, 545, 0, 0, 21331, 21409, 5, 547, 0, 0, 21332, 21409, + 5, 2429, 0, 0, 21333, 21409, 5, 588, 0, 0, 21334, 21409, 5, 592, 0, 0, + 21335, 21409, 5, 607, 0, 0, 21336, 21409, 5, 615, 0, 0, 21337, 21409, 5, + 635, 0, 0, 21338, 21409, 5, 734, 0, 0, 21339, 21409, 5, 750, 0, 0, 21340, + 21409, 5, 769, 0, 0, 21341, 21409, 5, 778, 0, 0, 21342, 21409, 5, 810, + 0, 0, 21343, 21409, 5, 812, 0, 0, 21344, 21409, 5, 823, 0, 0, 21345, 21409, + 5, 893, 0, 0, 21346, 21409, 5, 894, 0, 0, 21347, 21409, 5, 2430, 0, 0, + 21348, 21409, 5, 990, 0, 0, 21349, 21409, 5, 901, 0, 0, 21350, 21409, 5, + 964, 0, 0, 21351, 21409, 5, 965, 0, 0, 21352, 21409, 5, 1230, 0, 0, 21353, + 21409, 5, 1279, 0, 0, 21354, 21409, 5, 1280, 0, 0, 21355, 21409, 5, 1309, + 0, 0, 21356, 21409, 5, 1318, 0, 0, 21357, 21409, 5, 1324, 0, 0, 21358, + 21409, 5, 1328, 0, 0, 21359, 21409, 5, 1331, 0, 0, 21360, 21409, 5, 1394, + 0, 0, 21361, 21409, 5, 1403, 0, 0, 21362, 21409, 5, 1410, 0, 0, 21363, + 21409, 5, 1420, 0, 0, 21364, 21409, 5, 1419, 0, 0, 21365, 21409, 5, 1433, + 0, 0, 21366, 21409, 5, 1473, 0, 0, 21367, 21409, 5, 1492, 0, 0, 21368, + 21409, 5, 1498, 0, 0, 21369, 21409, 5, 1512, 0, 0, 21370, 21409, 5, 1530, + 0, 0, 21371, 21409, 5, 1559, 0, 0, 21372, 21409, 5, 1577, 0, 0, 21373, + 21409, 5, 1580, 0, 0, 21374, 21409, 5, 1633, 0, 0, 21375, 21409, 5, 1648, + 0, 0, 21376, 21409, 5, 1660, 0, 0, 21377, 21409, 5, 1671, 0, 0, 21378, + 21409, 5, 1656, 0, 0, 21379, 21409, 5, 1677, 0, 0, 21380, 21409, 5, 1692, + 0, 0, 21381, 21409, 5, 1693, 0, 0, 21382, 21409, 5, 1706, 0, 0, 21383, + 21409, 5, 2433, 0, 0, 21384, 21409, 5, 1719, 0, 0, 21385, 21409, 5, 1720, + 0, 0, 21386, 21409, 5, 1785, 0, 0, 21387, 21409, 5, 2077, 0, 0, 21388, + 21409, 5, 2434, 0, 0, 21389, 21409, 5, 2107, 0, 0, 21390, 21409, 5, 2109, + 0, 0, 21391, 21409, 5, 2110, 0, 0, 21392, 21409, 5, 2113, 0, 0, 21393, + 21409, 5, 2157, 0, 0, 21394, 21409, 5, 2171, 0, 0, 21395, 21409, 5, 2260, + 0, 0, 21396, 21409, 5, 2259, 0, 0, 21397, 21409, 5, 2262, 0, 0, 21398, + 21409, 5, 2295, 0, 0, 21399, 21409, 5, 2302, 0, 0, 21400, 21409, 5, 2435, + 0, 0, 21401, 21409, 5, 2319, 0, 0, 21402, 21409, 5, 2361, 0, 0, 21403, + 21409, 5, 2413, 0, 0, 21404, 21409, 5, 2421, 0, 0, 21405, 21409, 5, 2258, + 0, 0, 21406, 21409, 5, 2400, 0, 0, 21407, 21409, 5, 363, 0, 0, 21408, 21286, + 1, 0, 0, 0, 21408, 21287, 1, 0, 0, 0, 21408, 21288, 1, 0, 0, 0, 21408, + 21289, 1, 0, 0, 0, 21408, 21290, 1, 0, 0, 0, 21408, 21291, 1, 0, 0, 0, + 21408, 21292, 1, 0, 0, 0, 21408, 21293, 1, 0, 0, 0, 21408, 21294, 1, 0, + 0, 0, 21408, 21295, 1, 0, 0, 0, 21408, 21296, 1, 0, 0, 0, 21408, 21297, + 1, 0, 0, 0, 21408, 21298, 1, 0, 0, 0, 21408, 21299, 1, 0, 0, 0, 21408, + 21300, 1, 0, 0, 0, 21408, 21301, 1, 0, 0, 0, 21408, 21302, 1, 0, 0, 0, + 21408, 21303, 1, 0, 0, 0, 21408, 21304, 1, 0, 0, 0, 21408, 21305, 1, 0, + 0, 0, 21408, 21306, 1, 0, 0, 0, 21408, 21307, 1, 0, 0, 0, 21408, 21308, + 1, 0, 0, 0, 21408, 21309, 1, 0, 0, 0, 21408, 21310, 1, 0, 0, 0, 21408, + 21311, 1, 0, 0, 0, 21408, 21312, 1, 0, 0, 0, 21408, 21313, 1, 0, 0, 0, + 21408, 21314, 1, 0, 0, 0, 21408, 21315, 1, 0, 0, 0, 21408, 21316, 1, 0, + 0, 0, 21408, 21317, 1, 0, 0, 0, 21408, 21318, 1, 0, 0, 0, 21408, 21319, + 1, 0, 0, 0, 21408, 21320, 1, 0, 0, 0, 21408, 21321, 1, 0, 0, 0, 21408, + 21322, 1, 0, 0, 0, 21408, 21323, 1, 0, 0, 0, 21408, 21324, 1, 0, 0, 0, + 21408, 21325, 1, 0, 0, 0, 21408, 21326, 1, 0, 0, 0, 21408, 21327, 1, 0, + 0, 0, 21408, 21328, 1, 0, 0, 0, 21408, 21329, 1, 0, 0, 0, 21408, 21330, + 1, 0, 0, 0, 21408, 21331, 1, 0, 0, 0, 21408, 21332, 1, 0, 0, 0, 21408, + 21333, 1, 0, 0, 0, 21408, 21334, 1, 0, 0, 0, 21408, 21335, 1, 0, 0, 0, + 21408, 21336, 1, 0, 0, 0, 21408, 21337, 1, 0, 0, 0, 21408, 21338, 1, 0, + 0, 0, 21408, 21339, 1, 0, 0, 0, 21408, 21340, 1, 0, 0, 0, 21408, 21341, + 1, 0, 0, 0, 21408, 21342, 1, 0, 0, 0, 21408, 21343, 1, 0, 0, 0, 21408, + 21344, 1, 0, 0, 0, 21408, 21345, 1, 0, 0, 0, 21408, 21346, 1, 0, 0, 0, + 21408, 21347, 1, 0, 0, 0, 21408, 21348, 1, 0, 0, 0, 21408, 21349, 1, 0, + 0, 0, 21408, 21350, 1, 0, 0, 0, 21408, 21351, 1, 0, 0, 0, 21408, 21352, + 1, 0, 0, 0, 21408, 21353, 1, 0, 0, 0, 21408, 21354, 1, 0, 0, 0, 21408, + 21355, 1, 0, 0, 0, 21408, 21356, 1, 0, 0, 0, 21408, 21357, 1, 0, 0, 0, + 21408, 21358, 1, 0, 0, 0, 21408, 21359, 1, 0, 0, 0, 21408, 21360, 1, 0, + 0, 0, 21408, 21361, 1, 0, 0, 0, 21408, 21362, 1, 0, 0, 0, 21408, 21363, + 1, 0, 0, 0, 21408, 21364, 1, 0, 0, 0, 21408, 21365, 1, 0, 0, 0, 21408, + 21366, 1, 0, 0, 0, 21408, 21367, 1, 0, 0, 0, 21408, 21368, 1, 0, 0, 0, + 21408, 21369, 1, 0, 0, 0, 21408, 21370, 1, 0, 0, 0, 21408, 21371, 1, 0, + 0, 0, 21408, 21372, 1, 0, 0, 0, 21408, 21373, 1, 0, 0, 0, 21408, 21374, + 1, 0, 0, 0, 21408, 21375, 1, 0, 0, 0, 21408, 21376, 1, 0, 0, 0, 21408, + 21377, 1, 0, 0, 0, 21408, 21378, 1, 0, 0, 0, 21408, 21379, 1, 0, 0, 0, + 21408, 21380, 1, 0, 0, 0, 21408, 21381, 1, 0, 0, 0, 21408, 21382, 1, 0, + 0, 0, 21408, 21383, 1, 0, 0, 0, 21408, 21384, 1, 0, 0, 0, 21408, 21385, + 1, 0, 0, 0, 21408, 21386, 1, 0, 0, 0, 21408, 21387, 1, 0, 0, 0, 21408, + 21388, 1, 0, 0, 0, 21408, 21389, 1, 0, 0, 0, 21408, 21390, 1, 0, 0, 0, + 21408, 21391, 1, 0, 0, 0, 21408, 21392, 1, 0, 0, 0, 21408, 21393, 1, 0, + 0, 0, 21408, 21394, 1, 0, 0, 0, 21408, 21395, 1, 0, 0, 0, 21408, 21396, + 1, 0, 0, 0, 21408, 21397, 1, 0, 0, 0, 21408, 21398, 1, 0, 0, 0, 21408, + 21399, 1, 0, 0, 0, 21408, 21400, 1, 0, 0, 0, 21408, 21401, 1, 0, 0, 0, + 21408, 21402, 1, 0, 0, 0, 21408, 21403, 1, 0, 0, 0, 21408, 21404, 1, 0, + 0, 0, 21408, 21405, 1, 0, 0, 0, 21408, 21406, 1, 0, 0, 0, 21408, 21407, + 1, 0, 0, 0, 21409, 2411, 1, 0, 0, 0, 21410, 21411, 7, 302, 0, 0, 21411, + 2413, 1, 0, 0, 0, 21412, 21413, 7, 303, 0, 0, 21413, 2415, 1, 0, 0, 0, + 21414, 21415, 7, 304, 0, 0, 21415, 2417, 1, 0, 0, 0, 3015, 2420, 2424, + 2429, 2433, 2437, 2441, 2445, 2448, 2593, 2600, 2602, 2605, 2608, 2630, + 2632, 2639, 2643, 2648, 2650, 2655, 2658, 2662, 2670, 2675, 2679, 2684, + 2689, 2693, 2699, 2704, 2709, 2713, 2716, 2722, 2730, 2737, 2741, 2746, + 2749, 2765, 2770, 2774, 2782, 2788, 2796, 2799, 2801, 2804, 2808, 2811, + 2815, 2823, 2829, 2837, 2840, 2843, 2855, 2857, 2863, 2868, 2870, 2876, + 2879, 2891, 2901, 2904, 2909, 2912, 2929, 2936, 2941, 2945, 2960, 2963, + 2978, 2988, 3002, 3005, 3018, 3026, 3032, 3036, 3043, 3047, 3062, 3080, + 3093, 3099, 3108, 3118, 3122, 3135, 3138, 3147, 3155, 3159, 3169, 3183, + 3193, 3201, 3204, 3208, 3211, 3214, 3217, 3227, 3246, 3256, 3264, 3269, + 3275, 3296, 3305, 3308, 3312, 3314, 3323, 3327, 3343, 3357, 3359, 3362, + 3366, 3373, 3380, 3389, 3394, 3399, 3401, 3409, 3417, 3421, 3427, 3431, + 3436, 3443, 3446, 3456, 3461, 3468, 3477, 3479, 3484, 3487, 3491, 3496, + 3508, 3517, 3520, 3526, 3532, 3542, 3558, 3573, 3586, 3592, 3604, 3613, + 3618, 3634, 3636, 3652, 3654, 3675, 3677, 3697, 3699, 3714, 3723, 3725, + 3736, 3743, 3756, 3761, 3770, 3773, 3778, 3783, 3788, 3791, 3797, 3801, + 3807, 3812, 3817, 3820, 3827, 3834, 3843, 3845, 3847, 3851, 3861, 3871, + 3876, 3881, 3883, 3888, 3900, 3905, 3914, 3916, 3921, 3936, 3948, 3952, + 3955, 3958, 3965, 3969, 3972, 3983, 3988, 3993, 4003, 4008, 4018, 4020, + 4025, 4028, 4032, 4037, 4049, 4054, 4059, 4061, 4066, 4069, 4074, 4081, + 4091, 4096, 4099, 4104, 4109, 4112, 4117, 4126, 4142, 4144, 4154, 4172, + 4179, 4184, 4190, 4198, 4200, 4216, 4221, 4226, 4228, 4233, 4240, 4243, + 4246, 4249, 4259, 4271, 4275, 4278, 4287, 4295, 4303, 4306, 4312, 4317, + 4322, 4326, 4364, 4392, 4399, 4404, 4411, 4421, 4426, 4435, 4439, 4450, + 4453, 4457, 4460, 4465, 4470, 4474, 4484, 4494, 4500, 4508, 4516, 4521, + 4524, 4526, 4529, 4538, 4541, 4546, 4551, 4554, 4557, 4560, 4564, 4567, + 4575, 4580, 4585, 4592, 4602, 4618, 4625, 4632, 4637, 4647, 4652, 4657, + 4660, 4665, 4675, 4680, 4687, 4690, 4695, 4698, 4701, 4713, 4720, 4723, + 4726, 4735, 4738, 4743, 4746, 4753, 4756, 4763, 4768, 4772, 4777, 4782, + 4790, 4800, 4805, 4812, 4815, 4819, 4822, 4825, 4828, 4838, 4843, 4848, + 4851, 4856, 4866, 4871, 4875, 4885, 4890, 4897, 4903, 4907, 4910, 4913, + 4925, 4932, 4935, 4938, 4946, 4960, 4967, 4979, 4984, 4996, 5016, 5023, + 5025, 5029, 5037, 5048, 5059, 5061, 5068, 5074, 5080, 5103, 5108, 5113, + 5122, 5125, 5133, 5138, 5142, 5145, 5148, 5151, 5154, 5157, 5160, 5163, + 5167, 5170, 5173, 5178, 5182, 5185, 5190, 5192, 5204, 5208, 5212, 5218, + 5222, 5225, 5228, 5238, 5247, 5255, 5262, 5267, 5275, 5278, 5282, 5292, + 5301, 5309, 5313, 5316, 5321, 5325, 5328, 5331, 5340, 5348, 5353, 5379, + 5391, 5400, 5403, 5412, 5422, 5427, 5438, 5441, 5443, 5449, 5454, 5459, + 5462, 5468, 5473, 5476, 5483, 5489, 5494, 5500, 5507, 5510, 5518, 5524, + 5530, 5534, 5537, 5540, 5553, 5559, 5566, 5577, 5585, 5589, 5592, 5597, + 5607, 5612, 5617, 5622, 5627, 5632, 5637, 5642, 5647, 5652, 5655, 5664, + 5669, 5679, 5684, 5691, 5695, 5704, 5711, 5715, 5722, 5725, 5728, 5736, + 5740, 5743, 5751, 5757, 5759, 5767, 5776, 5781, 5788, 5793, 5796, 5800, + 5802, 5813, 5824, 5838, 5843, 5853, 5859, 5862, 5867, 5876, 5879, 5884, + 5888, 5912, 5914, 5918, 5921, 5926, 5929, 5934, 5943, 5954, 5957, 5960, + 5963, 5967, 5975, 5980, 5992, 5995, 6000, 6004, 6007, 6016, 6022, 6028, + 6031, 6035, 6050, 6053, 6056, 6062, 6068, 6073, 6079, 6085, 6093, 6097, + 6111, 6118, 6125, 6131, 6134, 6138, 6143, 6148, 6154, 6159, 6164, 6168, + 6173, 6179, 6183, 6188, 6192, 6196, 6209, 6214, 6217, 6221, 6226, 6228, + 6234, 6236, 6240, 6243, 6250, 6261, 6271, 6275, 6280, 6284, 6288, 6291, + 6302, 6307, 6319, 6329, 6341, 6347, 6349, 6353, 6362, 6369, 6379, 6382, + 6389, 6397, 6408, 6415, 6419, 6421, 6425, 6435, 6446, 6451, 6455, 6459, + 6462, 6465, 6475, 6480, 6488, 6495, 6499, 6501, 6505, 6508, 6518, 6529, + 6534, 6538, 6542, 6545, 6548, 6555, 6564, 6572, 6574, 6597, 6610, 6624, + 6626, 6637, 6645, 6651, 6654, 6659, 6663, 6666, 6669, 6674, 6682, 6694, + 6702, 6709, 6728, 6739, 6742, 6748, 6750, 6757, 6760, 6762, 6769, 6784, + 6792, 6806, 6817, 6819, 6835, 6837, 6844, 6849, 6856, 6859, 6864, 6874, + 6883, 6896, 6906, 6911, 6914, 6920, 6938, 6941, 6944, 6952, 6965, 6967, + 6971, 6979, 6981, 6983, 6985, 6993, 7004, 7015, 7017, 7026, 7037, 7043, + 7050, 7060, 7064, 7073, 7076, 7082, 7085, 7090, 7096, 7104, 7110, 7116, + 7128, 7136, 7139, 7150, 7154, 7165, 7169, 7180, 7184, 7190, 7193, 7196, + 7199, 7202, 7206, 7209, 7213, 7219, 7222, 7225, 7228, 7231, 7235, 7238, + 7246, 7251, 7254, 7258, 7266, 7270, 7274, 7283, 7294, 7301, 7303, 7307, + 7316, 7320, 7324, 7331, 7337, 7341, 7348, 7357, 7369, 7383, 7387, 7389, + 7392, 7399, 7413, 7422, 7425, 7428, 7431, 7439, 7443, 7452, 7456, 7471, + 7479, 7491, 7508, 7511, 7516, 7522, 7526, 7531, 7537, 7541, 7544, 7558, + 7563, 7577, 7582, 7584, 7593, 7601, 7604, 7607, 7610, 7613, 7615, 7619, + 7623, 7630, 7635, 7640, 7645, 7649, 7652, 7657, 7665, 7670, 7673, 7679, + 7684, 7689, 7696, 7699, 7712, 7723, 7732, 7741, 7750, 7759, 7762, 7768, + 7773, 7775, 7782, 7824, 7827, 7831, 7834, 7845, 7854, 7857, 7859, 7869, + 7874, 7878, 7882, 7885, 7888, 7902, 7904, 7910, 7912, 7916, 7922, 7928, + 7932, 7935, 7943, 7953, 7957, 7976, 7981, 7988, 7995, 8069, 8076, 8085, + 8094, 8102, 8109, 8116, 8121, 8128, 8135, 8140, 8147, 8154, 8159, 8166, + 8173, 8178, 8185, 8192, 8197, 8200, 8203, 8210, 8214, 8223, 8234, 8243, + 8247, 8254, 8256, 8263, 8271, 8276, 8280, 8285, 8292, 8294, 8298, 8301, + 8304, 8313, 8319, 8321, 8325, 8329, 8334, 8339, 8343, 8349, 8354, 8359, + 8362, 8371, 8374, 8377, 8383, 8390, 8395, 8399, 8405, 8407, 8413, 8415, + 8419, 8428, 8434, 8443, 8455, 8463, 8472, 8475, 8482, 8486, 8494, 8501, + 8511, 8516, 8518, 8523, 8530, 8546, 8553, 8563, 8572, 8581, 8590, 8595, + 8600, 8603, 8611, 8622, 8626, 8629, 8637, 8643, 8645, 8650, 8653, 8660, + 8664, 8669, 8672, 8685, 8689, 8694, 8697, 8707, 8711, 8715, 8720, 8736, + 8741, 8753, 8757, 8763, 8778, 8781, 8783, 8785, 8789, 8792, 8812, 8817, + 8822, 8833, 8836, 8848, 8857, 8868, 8877, 8882, 8906, 8911, 8917, 8919, + 8927, 8930, 8933, 8936, 8942, 8948, 8954, 8958, 8960, 8963, 8968, 8972, + 8977, 8980, 8985, 8988, 8993, 8997, 9003, 9007, 9011, 9019, 9032, 9036, + 9042, 9045, 9049, 9054, 9058, 9064, 9069, 9072, 9080, 9083, 9092, 9096, + 9098, 9117, 9123, 9128, 9133, 9135, 9139, 9148, 9161, 9172, 9175, 9178, + 9181, 9190, 9192, 9197, 9209, 9214, 9218, 9226, 9233, 9238, 9243, 9254, + 9257, 9269, 9284, 9289, 9295, 9299, 9305, 9309, 9318, 9327, 9332, 9336, + 9340, 9346, 9353, 9359, 9368, 9373, 9380, 9383, 9400, 9402, 9417, 9419, + 9432, 9435, 9438, 9441, 9449, 9452, 9455, 9458, 9470, 9481, 9484, 9489, + 9493, 9501, 9514, 9518, 9522, 9526, 9529, 9532, 9535, 9538, 9548, 9551, + 9560, 9564, 9572, 9585, 9588, 9590, 9594, 9598, 9604, 9609, 9613, 9616, + 9619, 9628, 9633, 9637, 9641, 9644, 9651, 9654, 9656, 9661, 9670, 9676, + 9679, 9681, 9698, 9706, 9715, 9718, 9723, 9726, 9735, 9755, 9761, 9766, + 9768, 9778, 9787, 9799, 9802, 9805, 9815, 9824, 9832, 9837, 9845, 9850, + 9853, 9866, 9868, 9870, 9873, 9877, 9887, 9891, 9896, 9901, 9905, 9907, + 9910, 9914, 9924, 9934, 9937, 9940, 9944, 9948, 9961, 9970, 9981, 9983, + 9994, 9996, 10001, 10006, 10013, 10031, 10037, 10042, 10052, 10058, 10066, + 10072, 10076, 10079, 10091, 10098, 10108, 10123, 10128, 10141, 10146, 10154, + 10159, 10164, 10169, 10173, 10178, 10186, 10189, 10192, 10195, 10198, 10200, + 10207, 10209, 10213, 10219, 10222, 10225, 10231, 10234, 10239, 10242, 10256, + 10262, 10266, 10270, 10281, 10288, 10293, 10298, 10303, 10308, 10310, 10312, + 10318, 10324, 10331, 10339, 10347, 10355, 10363, 10371, 10378, 10389, 10395, + 10399, 10411, 10418, 10420, 10422, 10426, 10429, 10432, 10436, 10443, 10445, + 10448, 10456, 10458, 10464, 10470, 10475, 10477, 10485, 10496, 10499, 10503, + 10507, 10510, 10515, 10519, 10523, 10532, 10538, 10544, 10550, 10553, 10561, + 10565, 10571, 10577, 10583, 10587, 10589, 10594, 10597, 10601, 10605, 10613, + 10617, 10620, 10623, 10629, 10632, 10635, 10638, 10641, 10660, 10667, 10671, + 10674, 10681, 10686, 10693, 10699, 10701, 10707, 10711, 10718, 10723, 10729, + 10733, 10741, 10746, 10752, 10755, 10758, 10761, 10764, 10770, 10776, 10778, + 10789, 10793, 10797, 10804, 10808, 10813, 10816, 10829, 10834, 10837, 10842, + 10855, 10859, 10863, 10872, 10877, 10885, 10887, 10900, 10905, 10913, 10915, + 10951, 10955, 10965, 10969, 10973, 10976, 10981, 10984, 10989, 10997, 11004, + 11016, 11028, 11033, 11041, 11055, 11060, 11071, 11075, 11079, 11081, 11091, + 11101, 11112, 11128, 11133, 11135, 11140, 11147, 11154, 11174, 11179, 11181, + 11186, 11193, 11200, 11205, 11216, 11222, 11227, 11230, 11235, 11238, 11242, + 11257, 11262, 11266, 11277, 11282, 11295, 11311, 11316, 11318, 11323, 11331, + 11345, 11353, 11366, 11372, 11376, 11390, 11395, 11399, 11413, 11416, 11420, + 11423, 11432, 11440, 11448, 11451, 11456, 11458, 11462, 11465, 11474, 11482, + 11490, 11493, 11498, 11500, 11510, 11518, 11526, 11529, 11534, 11547, 11552, + 11561, 11572, 11586, 11591, 11594, 11600, 11604, 11608, 11612, 11616, 11619, + 11631, 11636, 11650, 11660, 11663, 11672, 11682, 11686, 11691, 11694, 11697, + 11700, 11703, 11707, 11710, 11713, 11717, 11719, 11724, 11726, 11734, 11745, + 11750, 11752, 11761, 11769, 11776, 11780, 11788, 11794, 11796, 11802, 11810, + 11812, 11815, 11820, 11823, 11828, 11832, 11836, 11841, 11844, 11850, 11852, + 11859, 11861, 11865, 11877, 11879, 11887, 11889, 11893, 11897, 11901, 11905, + 11921, 11923, 11945, 11954, 11956, 11968, 11971, 11975, 11977, 11987, 11992, + 11995, 11999, 12007, 12017, 12022, 12034, 12039, 12051, 12060, 12066, 12070, + 12075, 12078, 12086, 12090, 12097, 12104, 12107, 12115, 12118, 12121, 12126, + 12131, 12137, 12139, 12142, 12149, 12160, 12167, 12169, 12178, 12183, 12197, + 12206, 12217, 12226, 12236, 12244, 12248, 12252, 12255, 12262, 12270, 12272, + 12276, 12280, 12283, 12286, 12291, 12294, 12299, 12303, 12306, 12309, 12316, + 12323, 12326, 12328, 12333, 12337, 12340, 12343, 12348, 12351, 12354, 12359, + 12363, 12368, 12371, 12374, 12377, 12383, 12387, 12394, 12400, 12403, 12410, + 12412, 12414, 12419, 12425, 12429, 12435, 12446, 12452, 12459, 12473, 12477, + 12481, 12488, 12492, 12494, 12499, 12505, 12507, 12533, 12546, 12551, 12554, + 12558, 12563, 12566, 12569, 12576, 12583, 12591, 12597, 12604, 12607, 12610, + 12613, 12616, 12623, 12629, 12632, 12640, 12674, 12681, 12693, 12702, 12709, + 12724, 12738, 12747, 12763, 12766, 12768, 12771, 12779, 12795, 12806, 12811, + 12819, 12823, 12828, 12831, 12839, 12844, 12848, 12855, 12862, 12866, 12875, + 12883, 12887, 12890, 12898, 12904, 12908, 12913, 12918, 12925, 12929, 12933, + 12947, 12949, 12952, 12958, 12963, 12966, 12969, 12972, 12978, 12992, 12994, + 12998, 13001, 13004, 13007, 13014, 13018, 13022, 13025, 13029, 13032, 13039, + 13043, 13045, 13048, 13055, 13061, 13065, 13072, 13076, 13091, 13097, 13105, + 13114, 13119, 13124, 13130, 13137, 13144, 13147, 13149, 13153, 13159, 13163, + 13169, 13175, 13179, 13182, 13209, 13218, 13227, 13237, 13245, 13250, 13259, + 13269, 13279, 13290, 13297, 13304, 13307, 13310, 13313, 13317, 13319, 13322, + 13325, 13328, 13331, 13335, 13337, 13345, 13347, 13358, 13360, 13363, 13371, + 13381, 13402, 13404, 13418, 13422, 13425, 13431, 13438, 13461, 13464, 13468, + 13473, 13478, 13481, 13484, 13489, 13500, 13506, 13510, 13516, 13523, 13525, + 13527, 13531, 13534, 13537, 13547, 13555, 13557, 13559, 13567, 13576, 13578, + 13582, 13592, 13601, 13603, 13606, 13611, 13625, 13634, 13636, 13640, 13648, + 13650, 13661, 13671, 13677, 13682, 13686, 13691, 13696, 13701, 13705, 13712, + 13719, 13724, 13729, 13733, 13744, 13750, 13755, 13759, 13764, 13767, 13770, + 13774, 13777, 13780, 13792, 13801, 13809, 13817, 13822, 13828, 13832, 13839, + 13844, 13849, 13854, 13858, 13867, 13870, 13874, 13880, 13888, 13897, 13900, + 13915, 13932, 13938, 13942, 13949, 13956, 13959, 13961, 13967, 13969, 13972, + 13981, 13984, 13988, 13994, 14006, 14016, 14020, 14023, 14026, 14031, 14035, + 14039, 14042, 14049, 14052, 14059, 14065, 14093, 14103, 14113, 14115, 14123, + 14154, 14159, 14173, 14197, 14200, 14212, 14215, 14221, 14237, 14239, 14255, + 14268, 14279, 14283, 14285, 14293, 14302, 14306, 14314, 14322, 14328, 14335, + 14339, 14343, 14345, 14348, 14358, 14364, 14369, 14375, 14377, 14388, 14391, + 14394, 14404, 14413, 14416, 14419, 14422, 14433, 14436, 14442, 14445, 14449, + 14452, 14465, 14467, 14470, 14472, 14477, 14481, 14504, 14520, 14525, 14529, + 14533, 14537, 14540, 14545, 14547, 14561, 14566, 14573, 14584, 14590, 14592, + 14594, 14602, 14611, 14619, 14621, 14623, 14625, 14628, 14646, 14651, 14664, + 14671, 14675, 14678, 14681, 14683, 14688, 14692, 14694, 14710, 14714, 14717, + 14722, 14725, 14728, 14739, 14750, 14762, 14770, 14773, 14777, 14782, 14787, + 14791, 14794, 14797, 14800, 14804, 14806, 14816, 14820, 14825, 14830, 14837, + 14845, 14851, 14854, 14856, 14865, 14867, 14877, 14888, 14897, 14904, 14911, + 14915, 14917, 14923, 14931, 14938, 14945, 14949, 14951, 14972, 14974, 14977, + 14983, 14989, 14997, 14999, 15001, 15006, 15011, 15016, 15020, 15024, 15028, + 15040, 15046, 15053, 15058, 15064, 15069, 15073, 15079, 15084, 15093, 15102, + 15105, 15108, 15111, 15115, 15125, 15132, 15139, 15141, 15151, 15154, 15157, + 15160, 15164, 15166, 15170, 15176, 15178, 15181, 15184, 15189, 15194, 15198, + 15202, 15208, 15234, 15236, 15248, 15253, 15258, 15260, 15272, 15277, 15282, + 15284, 15289, 15296, 15300, 15309, 15320, 15328, 15332, 15337, 15340, 15345, + 15350, 15354, 15357, 15365, 15372, 15378, 15383, 15387, 15394, 15396, 15399, + 15404, 15408, 15413, 15417, 15424, 15428, 15433, 15439, 15442, 15451, 15462, + 15466, 15468, 15481, 15485, 15487, 15489, 15516, 15519, 15524, 15526, 15548, + 15551, 15553, 15555, 15562, 15564, 15572, 15576, 15581, 15584, 15587, 15590, + 15597, 15602, 15610, 15618, 15623, 15626, 15628, 15644, 15646, 15659, 15661, + 15663, 15675, 15684, 15688, 15690, 15693, 15696, 15701, 15705, 15709, 15714, + 15717, 15720, 15730, 15732, 15737, 15742, 15748, 15752, 15759, 15782, 15788, + 15790, 15793, 15796, 15799, 15802, 15810, 15812, 15821, 15823, 15828, 15832, + 15837, 15839, 15846, 15854, 15856, 15863, 15865, 15869, 15882, 15888, 15891, + 15894, 15906, 15908, 15912, 15916, 15919, 15924, 15929, 15936, 15942, 15946, + 15952, 15965, 15969, 15976, 15990, 15995, 15999, 16010, 16012, 16028, 16035, + 16038, 16042, 16045, 16052, 16059, 16064, 16071, 16073, 16080, 16084, 16086, + 16094, 16096, 16105, 16115, 16126, 16128, 16131, 16135, 16138, 16153, 16162, + 16166, 16169, 16173, 16176, 16178, 16182, 16189, 16195, 16199, 16202, 16210, + 16223, 16227, 16231, 16234, 16237, 16250, 16254, 16266, 16271, 16275, 16279, + 16285, 16288, 16291, 16318, 16324, 16333, 16338, 16349, 16356, 16360, 16363, + 16369, 16378, 16387, 16390, 16394, 16401, 16404, 16413, 16418, 16426, 16428, + 16453, 16457, 16464, 16468, 16472, 16476, 16488, 16492, 16506, 16512, 16519, + 16524, 16535, 16538, 16544, 16546, 16554, 16558, 16568, 16573, 16588, 16592, + 16595, 16599, 16604, 16608, 16613, 16629, 16634, 16643, 16652, 16654, 16662, + 16664, 16668, 16676, 16686, 16689, 16696, 16705, 16708, 16717, 16724, 16728, + 16731, 16743, 16749, 16758, 16761, 16771, 16782, 16788, 16790, 16792, 16796, + 16803, 16806, 16813, 16824, 16830, 16834, 16844, 16847, 16853, 16856, 16861, + 16867, 16872, 16874, 16879, 16881, 16886, 16890, 16895, 16909, 16914, 16921, + 16923, 16931, 16935, 16943, 16946, 16955, 16957, 16963, 16965, 16973, 16979, + 16981, 16988, 16991, 16993, 16997, 17001, 17007, 17011, 17014, 17022, 17025, + 17029, 17033, 17038, 17041, 17045, 17049, 17053, 17079, 17082, 17085, 17094, + 17107, 17114, 17127, 17142, 17150, 17154, 17158, 17164, 17168, 17171, 17174, + 17178, 17180, 17184, 17187, 17190, 17193, 17201, 17204, 17215, 17217, 17224, + 17231, 17236, 17242, 17247, 17252, 17259, 17265, 17272, 17275, 17278, 17282, + 17287, 17291, 17293, 17299, 17309, 17316, 17320, 17330, 17345, 17347, 17351, + 17359, 17366, 17374, 17377, 17382, 17392, 17400, 17403, 17409, 17414, 17417, + 17422, 17427, 17433, 17442, 17449, 17459, 17464, 17466, 17471, 17475, 17481, + 17485, 17498, 17502, 17512, 17515, 17517, 17522, 17531, 17544, 17552, 17556, + 17565, 17569, 17574, 17585, 17587, 17603, 17608, 17614, 17620, 17638, 17645, + 17648, 17651, 17659, 17662, 17670, 17672, 17676, 17679, 17684, 17686, 17690, + 17702, 17711, 17719, 17724, 17728, 17738, 17740, 17746, 17751, 17754, 17764, + 17770, 17773, 17776, 17784, 17794, 17804, 17808, 17812, 17815, 17818, 17823, + 17828, 17831, 17834, 17840, 17843, 17849, 17852, 17855, 17860, 17863, 17871, + 17877, 17882, 17885, 17894, 17907, 17911, 17913, 17916, 17919, 17931, 17935, + 17938, 17953, 17957, 17969, 17972, 17981, 17988, 17993, 17997, 18005, 18011, + 18019, 18022, 18031, 18034, 18037, 18046, 18052, 18058, 18061, 18066, 18072, + 18084, 18095, 18097, 18106, 18108, 18112, 18118, 18122, 18135, 18142, 18147, + 18163, 18165, 18169, 18173, 18177, 18190, 18194, 18201, 18209, 18212, 18217, + 18219, 18224, 18228, 18231, 18237, 18242, 18254, 18258, 18260, 18265, 18275, + 18277, 18279, 18289, 18293, 18295, 18307, 18315, 18328, 18331, 18336, 18354, + 18356, 18364, 18372, 18379, 18383, 18386, 18393, 18397, 18402, 18406, 18414, + 18418, 18425, 18430, 18439, 18448, 18451, 18471, 18473, 18475, 18483, 18500, + 18502, 18512, 18517, 18520, 18527, 18530, 18534, 18537, 18540, 18546, 18549, + 18553, 18556, 18568, 18575, 18578, 18582, 18588, 18591, 18595, 18610, 18618, + 18625, 18638, 18643, 18652, 18661, 18665, 18669, 18695, 18698, 18701, 18711, + 18719, 18725, 18727, 18731, 18738, 18747, 18751, 18754, 18757, 18766, 18769, + 18772, 18775, 18778, 18790, 18798, 18805, 18808, 18812, 18814, 18817, 18822, + 18831, 18837, 18840, 18843, 18852, 18855, 18858, 18861, 18867, 18871, 18883, + 18893, 18897, 18900, 18906, 18910, 18916, 18920, 18923, 18926, 18928, 18935, + 18939, 18942, 18945, 18948, 18953, 18956, 18960, 18969, 18973, 18980, 18984, + 18989, 18994, 18997, 19006, 19010, 19021, 19024, 19028, 19033, 19037, 19046, + 19049, 19053, 19062, 19065, 19069, 19074, 19083, 19086, 19090, 19098, 19103, + 19108, 19111, 19115, 19117, 19126, 19133, 19136, 19143, 19145, 19148, 19151, + 19155, 19158, 19163, 19170, 19176, 19184, 19188, 19191, 19194, 19200, 19203, + 19207, 19211, 19216, 19219, 19222, 19231, 19243, 19250, 19253, 19259, 19262, + 19265, 19274, 19277, 19282, 19289, 19291, 19304, 19311, 19316, 19321, 19327, + 19333, 19336, 19338, 19343, 19351, 19353, 19360, 19366, 19371, 19377, 19382, + 19388, 19400, 19406, 19410, 19415, 19420, 19426, 19429, 19433, 19443, 19453, + 19459, 19461, 19471, 19473, 19480, 19484, 19493, 19498, 19503, 19506, 19515, + 19518, 19527, 19541, 19548, 19556, 19559, 19572, 19578, 19580, 19593, 19602, + 19608, 19618, 19626, 19632, 19635, 19638, 19652, 19654, 19662, 19669, 19679, + 19687, 19693, 19696, 19701, 19706, 19710, 19718, 19725, 19734, 19741, 19750, + 19754, 19761, 19768, 19775, 19782, 19790, 19794, 19801, 19810, 19813, 19816, + 19819, 19823, 19828, 19833, 19844, 19848, 19850, 19861, 19863, 19874, 19885, + 19894, 19897, 19907, 19911, 19920, 19930, 19940, 19948, 19954, 19962, 19969, + 19973, 19978, 19982, 19987, 19991, 19997, 20000, 20007, 20017, 20025, 20029, + 20039, 20042, 20044, 20051, 20057, 20063, 20069, 20071, 20085, 20087, 20100, + 20105, 20108, 20115, 20120, 20131, 20136, 20138, 20145, 20148, 20155, 20170, + 20173, 20177, 20179, 20187, 20195, 20197, 20204, 20209, 20213, 20217, 20221, + 20225, 20230, 20234, 20237, 20241, 20248, 20252, 20257, 20262, 20266, 20271, + 20288, 20293, 20300, 20311, 20318, 20325, 20329, 20336, 20341, 20350, 20358, + 20366, 20372, 20377, 20382, 20386, 20391, 20394, 20399, 20403, 20407, 20414, + 20419, 20430, 20436, 20441, 20445, 20447, 20454, 20458, 20466, 20469, 20474, + 20481, 20499, 20516, 20523, 20536, 20540, 20548, 20551, 20555, 20560, 20565, + 20569, 20572, 20576, 20583, 20588, 20590, 20592, 20602, 20607, 20611, 20614, + 20618, 20627, 20633, 20637, 20639, 20643, 20647, 20654, 20662, 20670, 20672, + 20677, 20682, 20684, 20687, 20711, 20718, 20723, 20756, 20761, 20764, 20769, + 20771, 20777, 20786, 20793, 20797, 20802, 20807, 20812, 20817, 20824, 20829, + 20863, 20870, 20885, 20901, 20920, 20937, 20944, 20952, 20965, 20974, 20983, + 20992, 21002, 21010, 21020, 21030, 21042, 21058, 21076, 21089, 21104, 21115, + 21125, 21136, 21146, 21163, 21169, 21191, 21196, 21202, 21208, 21214, 21219, + 21221, 21224, 21235, 21238, 21240, 21242, 21256, 21260, 21263, 21272, 21278, + 21408, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// PlSqlParserInit initializes any static state used to implement PlSqlParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewPlSqlParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func PlSqlParserInit() { + staticData := &PlSqlParserParserStaticData + staticData.once.Do(plsqlparserParserInit) +} + +// NewPlSqlParser produces a new parser instance for the optional input antlr.TokenStream. +func NewPlSqlParser(input antlr.TokenStream) *PlSqlParser { + PlSqlParserInit() + this := new(PlSqlParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &PlSqlParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "PlSqlParser.g4" + + return this +} + +// PlSqlParser tokens. +const ( + PlSqlParserEOF = antlr.TokenEOF + PlSqlParserABORT = 1 + PlSqlParserABS = 2 + PlSqlParserABSENT = 3 + PlSqlParserACCESS = 4 + PlSqlParserACCESSED = 5 + PlSqlParserACCESSIBLE = 6 + PlSqlParserACCOUNT = 7 + PlSqlParserACL = 8 + PlSqlParserACOS = 9 + PlSqlParserACROSS = 10 + PlSqlParserACTION = 11 + PlSqlParserACTIONS = 12 + PlSqlParserACTIVATE = 13 + PlSqlParserACTIVE = 14 + PlSqlParserACTIVE_COMPONENT = 15 + PlSqlParserACTIVE_DATA = 16 + PlSqlParserACTIVE_FUNCTION = 17 + PlSqlParserACTIVE_TAG = 18 + PlSqlParserACTIVITY = 19 + PlSqlParserADAPTIVE_PLAN = 20 + PlSqlParserADD = 21 + PlSqlParserADD_COLUMN = 22 + PlSqlParserADD_GROUP = 23 + PlSqlParserADD_MONTHS = 24 + PlSqlParserADJ_DATE = 25 + PlSqlParserADMIN = 26 + PlSqlParserADMINISTER = 27 + PlSqlParserADMINISTRATOR = 28 + PlSqlParserADVANCED = 29 + PlSqlParserADVISE = 30 + PlSqlParserADVISOR = 31 + PlSqlParserAFD_DISKSTRING = 32 + PlSqlParserAFTER = 33 + PlSqlParserAGENT = 34 + PlSqlParserAGGREGATE = 35 + PlSqlParserA_LETTER = 36 + PlSqlParserALIAS = 37 + PlSqlParserALL = 38 + PlSqlParserALLOCATE = 39 + PlSqlParserALLOW = 40 + PlSqlParserALL_ROWS = 41 + PlSqlParserALTER = 42 + PlSqlParserALTERNATE = 43 + PlSqlParserALWAYS = 44 + PlSqlParserANALYTIC = 45 + PlSqlParserANALYZE = 46 + PlSqlParserANCESTOR = 47 + PlSqlParserANCILLARY = 48 + PlSqlParserAND = 49 + PlSqlParserAND_EQUAL = 50 + PlSqlParserANNOTATIONS = 51 + PlSqlParserANOMALY = 52 + PlSqlParserANSI_REARCH = 53 + PlSqlParserANTIJOIN = 54 + PlSqlParserANY = 55 + PlSqlParserANYSCHEMA = 56 + PlSqlParserAPPEND = 57 + PlSqlParserAPPENDCHILDXML = 58 + PlSqlParserAPPEND_VALUES = 59 + PlSqlParserAPPLICATION = 60 + PlSqlParserAPPLY = 61 + PlSqlParserAPPROX_COUNT_DISTINCT = 62 + PlSqlParserARCHIVAL = 63 + PlSqlParserARCHIVE = 64 + PlSqlParserARCHIVED = 65 + PlSqlParserARCHIVELOG = 66 + PlSqlParserARE = 67 + PlSqlParserARRAY = 68 + PlSqlParserAS = 69 + PlSqlParserASC = 70 + PlSqlParserASCII = 71 + PlSqlParserASCIISTR = 72 + PlSqlParserASIN = 73 + PlSqlParserASIS = 74 + PlSqlParserASSEMBLY = 75 + PlSqlParserASSIGN = 76 + PlSqlParserASSOCIATE = 77 + PlSqlParserASYNC = 78 + PlSqlParserASYNCHRONOUS = 79 + PlSqlParserATAN2 = 80 + PlSqlParserATAN = 81 + PlSqlParserAT = 82 + PlSqlParserATTRIBUTE = 83 + PlSqlParserATTRIBUTES = 84 + PlSqlParserAUDIT = 85 + PlSqlParserAUTHENTICATED = 86 + PlSqlParserAUTHENTICATION = 87 + PlSqlParserAUTHID = 88 + PlSqlParserAUTHORIZATION = 89 + PlSqlParserAUTOALLOCATE = 90 + PlSqlParserAUTO = 91 + PlSqlParserAUTOBACKUP = 92 + PlSqlParserAUTOEXTEND = 93 + PlSqlParserAUTO_LOGIN = 94 + PlSqlParserAUTOMATIC = 95 + PlSqlParserAUTONOMOUS_TRANSACTION = 96 + PlSqlParserAUTO_REOPTIMIZE = 97 + PlSqlParserAVAILABILITY = 98 + PlSqlParserAVRO = 99 + PlSqlParserBACKGROUND = 100 + PlSqlParserBACKINGFILE = 101 + PlSqlParserBACKUP = 102 + PlSqlParserBACKUPS = 103 + PlSqlParserBACKUPSET = 104 + PlSqlParserBADFILE = 105 + PlSqlParserBASIC = 106 + PlSqlParserBASICFILE = 107 + PlSqlParserBATCH = 108 + PlSqlParserBATCHSIZE = 109 + PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID = 110 + PlSqlParserBECOME = 111 + PlSqlParserBEFORE = 112 + PlSqlParserBEGIN = 113 + PlSqlParserBEGINNING = 114 + PlSqlParserBEGIN_OUTLINE_DATA = 115 + PlSqlParserBEHALF = 116 + PlSqlParserBEQUEATH = 117 + PlSqlParserBETWEEN = 118 + PlSqlParserBFILE = 119 + PlSqlParserBFILENAME = 120 + PlSqlParserBIG = 121 + PlSqlParserBIGFILE = 122 + PlSqlParserBIGINT = 123 + PlSqlParserBINARY = 124 + PlSqlParserBINARY_DOUBLE = 125 + PlSqlParserBINARY_DOUBLE_INFINITY = 126 + PlSqlParserBINARY_DOUBLE_NAN = 127 + PlSqlParserBINARY_FLOAT = 128 + PlSqlParserBINARY_FLOAT_INFINITY = 129 + PlSqlParserBINARY_FLOAT_NAN = 130 + PlSqlParserBINARY_INTEGER = 131 + PlSqlParserBIND_AWARE = 132 + PlSqlParserBINDING = 133 + PlSqlParserBIN_TO_NUM = 134 + PlSqlParserBITAND = 135 + PlSqlParserBITMAP_AND = 136 + PlSqlParserBITMAP = 137 + PlSqlParserBITMAPS = 138 + PlSqlParserBITMAP_TREE = 139 + PlSqlParserBITS = 140 + PlSqlParserBLANKS = 141 + PlSqlParserBLOB = 142 + PlSqlParserBLOCK = 143 + PlSqlParserBLOCK_RANGE = 144 + PlSqlParserBLOCKS = 145 + PlSqlParserBLOCKSIZE = 146 + PlSqlParserBODY = 147 + PlSqlParserBOOLEAN = 148 + PlSqlParserBOTH = 149 + PlSqlParserBOUND = 150 + PlSqlParserBRANCH = 151 + PlSqlParserBREADTH = 152 + PlSqlParserBROADCAST = 153 + PlSqlParserBSON = 154 + PlSqlParserBUFFER = 155 + PlSqlParserBUFFER_CACHE = 156 + PlSqlParserBUFFER_POOL = 157 + PlSqlParserBUILD = 158 + PlSqlParserBULK = 159 + PlSqlParserBY = 160 + PlSqlParserBYPASS_RECURSIVE_CHECK = 161 + PlSqlParserBYPASS_UJVC = 162 + PlSqlParserBYTE = 163 + PlSqlParserBYTES = 164 + PlSqlParserBYTEORDERMARK = 165 + PlSqlParserCACHE = 166 + PlSqlParserCACHE_CB = 167 + PlSqlParserCACHE_INSTANCES = 168 + PlSqlParserCACHE_TEMP_TABLE = 169 + PlSqlParserCACHING = 170 + PlSqlParserCALCULATED = 171 + PlSqlParserCALLBACK = 172 + PlSqlParserCALL = 173 + PlSqlParserCANCEL = 174 + PlSqlParserCANONICAL = 175 + PlSqlParserCAPACITY = 176 + PlSqlParserCAPTION = 177 + PlSqlParserCARDINALITY = 178 + PlSqlParserCASCADE = 179 + PlSqlParserCASE = 180 + PlSqlParserCAST = 181 + PlSqlParserCASESENSITIVE = 182 + PlSqlParserCATEGORY = 183 + PlSqlParserCDBDEFAULT = 184 + PlSqlParserCEIL = 185 + PlSqlParserCELL_FLASH_CACHE = 186 + PlSqlParserCERTIFICATE = 187 + PlSqlParserCFILE = 188 + PlSqlParserCHAINED = 189 + PlSqlParserCHANGE = 190 + PlSqlParserCHANGETRACKING = 191 + PlSqlParserCHANGE_DUPKEY_ERROR_INDEX = 192 + PlSqlParserCHARACTER = 193 + PlSqlParserCHARACTERS = 194 + PlSqlParserCHARACTERSET = 195 + PlSqlParserCHAR = 196 + PlSqlParserCHAR_CS = 197 + PlSqlParserCHARTOROWID = 198 + PlSqlParserCHECK_ACL_REWRITE = 199 + PlSqlParserCHECK = 200 + PlSqlParserCHECKPOINT = 201 + PlSqlParserCHILD = 202 + PlSqlParserCHOOSE = 203 + PlSqlParserCHR = 204 + PlSqlParserCHUNK = 205 + PlSqlParserCLASS = 206 + PlSqlParserCLASSIFICATION = 207 + PlSqlParserCLASSIFIER = 208 + PlSqlParserCLAUSE = 209 + PlSqlParserCLEAN = 210 + PlSqlParserCLEANUP = 211 + PlSqlParserCLEAR = 212 + PlSqlParserC_LETTER = 213 + PlSqlParserCLIENT = 214 + PlSqlParserCLOB = 215 + PlSqlParserCLONE = 216 + PlSqlParserCLOSE_CACHED_OPEN_CURSORS = 217 + PlSqlParserCLOSE = 218 + PlSqlParserCLUSTER_BY_ROWID = 219 + PlSqlParserCLUSTER = 220 + PlSqlParserCLUSTER_DETAILS = 221 + PlSqlParserCLUSTER_DISTANCE = 222 + PlSqlParserCLUSTER_ID = 223 + PlSqlParserCLUSTERING = 224 + PlSqlParserCLUSTERING_FACTOR = 225 + PlSqlParserCLUSTER_PROBABILITY = 226 + PlSqlParserCLUSTER_SET = 227 + PlSqlParserCOALESCE = 228 + PlSqlParserCOALESCE_SQ = 229 + PlSqlParserCOARSE = 230 + PlSqlParserCO_AUTH_IND = 231 + PlSqlParserCOLD = 232 + PlSqlParserCOLLECT = 233 + PlSqlParserCOLLECTION = 234 + PlSqlParserCOLUMNAR = 235 + PlSqlParserCOLUMN_AUTH_INDICATOR = 236 + PlSqlParserCOLUMN = 237 + PlSqlParserCOLUMNS = 238 + PlSqlParserCOLUMN_STATS = 239 + PlSqlParserCOLUMN_VALUE = 240 + PlSqlParserCOMMENT = 241 + PlSqlParserCOMMIT = 242 + PlSqlParserCOMMITTED = 243 + PlSqlParserCOMMON = 244 + PlSqlParserCOMMON_DATA = 245 + PlSqlParserCOMPACT = 246 + PlSqlParserCOMPATIBLE = 247 + PlSqlParserCOMPATIBILITY = 248 + PlSqlParserCOMPILE = 249 + PlSqlParserCOMPLETE = 250 + PlSqlParserCOMPLIANCE = 251 + PlSqlParserCOMPONENT = 252 + PlSqlParserCOMPONENTS = 253 + PlSqlParserCOMPOSE = 254 + PlSqlParserCOMPOSITE = 255 + PlSqlParserCOMPOSITE_LIMIT = 256 + PlSqlParserCOMPOUND = 257 + PlSqlParserCOMPRESS = 258 + PlSqlParserCOMPRESSION = 259 + PlSqlParserCOMPUTE = 260 + PlSqlParserCOMPUTATION = 261 + PlSqlParserCONCAT = 262 + PlSqlParserCONCURRENT = 263 + PlSqlParserCON_DBID_TO_ID = 264 + PlSqlParserCONDITIONAL = 265 + PlSqlParserCONDITION = 266 + PlSqlParserCONFIRM = 267 + PlSqlParserCONFORMING = 268 + PlSqlParserCON_GUID_TO_ID = 269 + PlSqlParserCON_ID = 270 + PlSqlParserCON_NAME_TO_ID = 271 + PlSqlParserCONNECT_BY_CB_WHR_ONLY = 272 + PlSqlParserCONNECT_BY_COMBINE_SW = 273 + PlSqlParserCONNECT_BY_COST_BASED = 274 + PlSqlParserCONNECT_BY_ELIM_DUPS = 275 + PlSqlParserCONNECT_BY_FILTERING = 276 + PlSqlParserCONNECT_BY_ISCYCLE = 277 + PlSqlParserCONNECT_BY_ISLEAF = 278 + PlSqlParserCONNECT_BY_ROOT = 279 + PlSqlParserCONNECT = 280 + PlSqlParserCONNECT_TIME = 281 + PlSqlParserCONSIDER = 282 + PlSqlParserCONSISTENT = 283 + PlSqlParserCONSTANT = 284 + PlSqlParserCONST = 285 + PlSqlParserCONSTRAINT = 286 + PlSqlParserCONSTRAINTS = 287 + PlSqlParserCONSTRUCTOR = 288 + PlSqlParserCONTAINER = 289 + PlSqlParserCONTAINERS = 290 + PlSqlParserCONTAINERS_DEFAULT = 291 + PlSqlParserCONTAINER_DATA = 292 + PlSqlParserCONTAINER_MAP = 293 + PlSqlParserCONTENT = 294 + PlSqlParserCONTENTS = 295 + PlSqlParserCONTEXT = 296 + PlSqlParserCONTINUE = 297 + PlSqlParserCONTROLFILE = 298 + PlSqlParserCON_UID_TO_ID = 299 + PlSqlParserCONVERT = 300 + PlSqlParserCONVERSION = 301 + PlSqlParserCOOKIE = 302 + PlSqlParserCOPY = 303 + PlSqlParserCORR_K = 304 + PlSqlParserCORR_S = 305 + PlSqlParserCORRUPTION = 306 + PlSqlParserCORRUPT_XID_ALL = 307 + PlSqlParserCORRUPT_XID = 308 + PlSqlParserCOS = 309 + PlSqlParserCOSH = 310 + PlSqlParserCOST = 311 + PlSqlParserCOST_XML_QUERY_REWRITE = 312 + PlSqlParserCOUNT = 313 + PlSqlParserCOUNTED = 314 + PlSqlParserCOVAR_POP = 315 + PlSqlParserCOVAR_SAMP = 316 + PlSqlParserCPU_COSTING = 317 + PlSqlParserCPU_PER_CALL = 318 + PlSqlParserCPU_PER_SESSION = 319 + PlSqlParserCRASH = 320 + PlSqlParserCREATE = 321 + PlSqlParserCREATE_FILE_DEST = 322 + PlSqlParserCREATE_STORED_OUTLINES = 323 + PlSqlParserCREATION = 324 + PlSqlParserCREDENTIAL = 325 + PlSqlParserCRITICAL = 326 + PlSqlParserCROSS = 327 + PlSqlParserCROSSEDITION = 328 + PlSqlParserCSCONVERT = 329 + PlSqlParserCSV = 330 + PlSqlParserCUBE_AJ = 331 + PlSqlParserCUBE = 332 + PlSqlParserCUBE_GB = 333 + PlSqlParserCUBE_SJ = 334 + PlSqlParserCUME_DISTM = 335 + PlSqlParserCURRENT = 336 + PlSqlParserCURRENT_DATE = 337 + PlSqlParserCURRENT_SCHEMA = 338 + PlSqlParserCURRENT_TIME = 339 + PlSqlParserCURRENT_TIMESTAMP = 340 + PlSqlParserCURRENT_USER = 341 + PlSqlParserCURRENTV = 342 + PlSqlParserCURSOR = 343 + PlSqlParserCURSOR_SHARING_EXACT = 344 + PlSqlParserCURSOR_SPECIFIC_SEGMENT = 345 + PlSqlParserCUSTOMDATUM = 346 + PlSqlParserCV = 347 + PlSqlParserCYCLE = 348 + PlSqlParserDANGLING = 349 + PlSqlParserDATABASE = 350 + PlSqlParserDATA = 351 + PlSqlParserDATAFILE = 352 + PlSqlParserDATAFILES = 353 + PlSqlParserDATAGUARDCONFIG = 354 + PlSqlParserDATAMOVEMENT = 355 + PlSqlParserDATAOBJNO = 356 + PlSqlParserDATAOBJ_TO_MAT_PARTITION = 357 + PlSqlParserDATAOBJ_TO_PARTITION = 358 + PlSqlParserDATAPUMP = 359 + PlSqlParserDATA_SECURITY_REWRITE_LIMIT = 360 + PlSqlParserDATE = 361 + PlSqlParserDATE_CACHE = 362 + PlSqlParserDATE_FORMAT = 363 + PlSqlParserDATE_MODE = 364 + PlSqlParserDAY = 365 + PlSqlParserDAYS = 366 + PlSqlParserDAY_TO_SECOND = 367 + PlSqlParserDBA = 368 + PlSqlParserDBA_RECYCLEBIN = 369 + PlSqlParserDBLINK = 370 + PlSqlParserDBMS_STATS = 371 + PlSqlParserDB_ROLE_CHANGE = 372 + PlSqlParserDBTIMEZONE = 373 + PlSqlParserDB_UNIQUE_NAME = 374 + PlSqlParserDB_VERSION = 375 + PlSqlParserDDL = 376 + PlSqlParserDEALLOCATE = 377 + PlSqlParserDEBUG = 378 + PlSqlParserDEBUGGER = 379 + PlSqlParserDEC = 380 + PlSqlParserDECIMAL = 381 + PlSqlParserDECLARE = 382 + PlSqlParserDECOMPOSE = 383 + PlSqlParserDECORRELATE = 384 + PlSqlParserDECR = 385 + PlSqlParserDECREMENT = 386 + PlSqlParserDECRYPT = 387 + PlSqlParserDEDUPLICATE = 388 + PlSqlParserDEFAULT = 389 + PlSqlParserDEFAULTIF = 390 + PlSqlParserDEFAULTS = 391 + PlSqlParserDEFAULT_COLLATION = 392 + PlSqlParserDEFAULT_CREDENTIAL = 393 + PlSqlParserDEFERRABLE = 394 + PlSqlParserDEFERRED = 395 + PlSqlParserDEFINED = 396 + PlSqlParserDEFINE = 397 + PlSqlParserDEFINER = 398 + PlSqlParserDEGREE = 399 + PlSqlParserDELAY = 400 + PlSqlParserDELEGATE = 401 + PlSqlParserDELETE_ALL = 402 + PlSqlParserDELETE = 403 + PlSqlParserDELETEXML = 404 + PlSqlParserDELIMITED = 405 + PlSqlParserDEMAND = 406 + PlSqlParserDENSE_RANKM = 407 + PlSqlParserDEPENDENT = 408 + PlSqlParserDEPRECATE = 409 + PlSqlParserDEPTH = 410 + PlSqlParserDEQUEUE = 411 + PlSqlParserDEREF = 412 + PlSqlParserDEREF_NO_REWRITE = 413 + PlSqlParserDESC = 414 + PlSqlParserDESCRIPTION = 415 + PlSqlParserDESTROY = 416 + PlSqlParserDETACHED = 417 + PlSqlParserDETECTED = 418 + PlSqlParserDETERMINES = 419 + PlSqlParserDETERMINISTIC = 420 + PlSqlParserDICTIONARY = 421 + PlSqlParserDIMENSION = 422 + PlSqlParserDIMENSIONS = 423 + PlSqlParserDIRECTIO = 424 + PlSqlParserDIRECT_LOAD = 425 + PlSqlParserDIRECTORY = 426 + PlSqlParserDIRECT_PATH = 427 + PlSqlParserDISABLE_ALL = 428 + PlSqlParserDISABLE = 429 + PlSqlParserDISABLED = 430 + PlSqlParserDISABLE_DIRECTORY_LINK_CHECK = 431 + PlSqlParserDISABLE_PARALLEL_DML = 432 + PlSqlParserDISABLE_PRESET = 433 + PlSqlParserDISABLE_RPKE = 434 + PlSqlParserDISALLOW = 435 + PlSqlParserDISASSOCIATE = 436 + PlSqlParserDISCARD = 437 + PlSqlParserDISCARDFILE = 438 + PlSqlParserDISCONNECT = 439 + PlSqlParserDISK = 440 + PlSqlParserDISKGROUP = 441 + PlSqlParserDISKGROUP_PLUS = 442 + PlSqlParserDISKS = 443 + PlSqlParserDISMOUNT = 444 + PlSqlParserDISTINCT = 445 + PlSqlParserDISTINGUISHED = 446 + PlSqlParserDISTRIBUTED = 447 + PlSqlParserDISTRIBUTE = 448 + PlSqlParserDML = 449 + PlSqlParserDML_UPDATE = 450 + PlSqlParserDNFS_DISABLE = 451 + PlSqlParserDNFS_ENABLE = 452 + PlSqlParserDNFS_READBUFFERS = 453 + PlSqlParserDOCFIDELITY = 454 + PlSqlParserDOCUMENT = 455 + PlSqlParserDOLLAR_ELSE = 456 + PlSqlParserDOLLAR_ELSIF = 457 + PlSqlParserDOLLAR_END = 458 + PlSqlParserDOLLAR_ERROR = 459 + PlSqlParserDOLLAR_IF = 460 + PlSqlParserDOLLAR_THEN = 461 + PlSqlParserDOMAIN_INDEX_FILTER = 462 + PlSqlParserDOMAIN_INDEX_NO_SORT = 463 + PlSqlParserDOMAIN_INDEX_SORT = 464 + PlSqlParserDOUBLE = 465 + PlSqlParserDOWNGRADE = 466 + PlSqlParserDRIVING_SITE = 467 + PlSqlParserDROP_COLUMN = 468 + PlSqlParserDROP = 469 + PlSqlParserDROP_GROUP = 470 + PlSqlParserDSINTERVAL_UNCONSTRAINED = 471 + PlSqlParserDST_UPGRADE_INSERT_CONV = 472 + PlSqlParserDUMP = 473 + PlSqlParserDUMPSET = 474 + PlSqlParserDUPLICATE = 475 + PlSqlParserDV = 476 + PlSqlParserDYNAMIC = 477 + PlSqlParserDYNAMIC_SAMPLING = 478 + PlSqlParserDYNAMIC_SAMPLING_EST_CDN = 479 + PlSqlParserE_LETTER = 480 + PlSqlParserEACH = 481 + PlSqlParserEDITIONABLE = 482 + PlSqlParserEDITION = 483 + PlSqlParserEDITIONING = 484 + PlSqlParserEDITIONS = 485 + PlSqlParserELEMENT = 486 + PlSqlParserELIM_GROUPBY = 487 + PlSqlParserELIMINATE_JOIN = 488 + PlSqlParserELIMINATE_OBY = 489 + PlSqlParserELIMINATE_OUTER_JOIN = 490 + PlSqlParserELSE = 491 + PlSqlParserELSIF = 492 + PlSqlParserEM = 493 + PlSqlParserEMBEDDED = 494 + PlSqlParserEMPTY_BLOB = 495 + PlSqlParserEMPTY_CLOB = 496 + PlSqlParserEMPTY_ = 497 + PlSqlParserENABLE_ALL = 498 + PlSqlParserENABLE = 499 + PlSqlParserENABLED = 500 + PlSqlParserENABLE_PARALLEL_DML = 501 + PlSqlParserENABLE_PRESET = 502 + PlSqlParserENCLOSED = 503 + PlSqlParserENCODING = 504 + PlSqlParserENCRYPT = 505 + PlSqlParserENCRYPTION = 506 + PlSqlParserENCRYPTPASSWORDISNULL = 507 + PlSqlParserEND = 508 + PlSqlParserEND_OUTLINE_DATA = 509 + PlSqlParserENDIAN = 510 + PlSqlParserENFORCED = 511 + PlSqlParserENFORCE = 512 + PlSqlParserENQUEUE = 513 + PlSqlParserENTERPRISE = 514 + PlSqlParserENTITYESCAPING = 515 + PlSqlParserENTRY = 516 + PlSqlParserEQUIPART = 517 + PlSqlParserERR = 518 + PlSqlParserERROR_ARGUMENT = 519 + PlSqlParserERROR = 520 + PlSqlParserERROR_ON_OVERLAP_TIME = 521 + PlSqlParserERRORS = 522 + PlSqlParserERROR_INDEX = 523 + PlSqlParserERROR_CODE = 524 + PlSqlParserESCAPE = 525 + PlSqlParserESCAPED = 526 + PlSqlParserESTIMATE = 527 + PlSqlParserEVAL = 528 + PlSqlParserEVALNAME = 529 + PlSqlParserEVALUATE = 530 + PlSqlParserEVALUATION = 531 + PlSqlParserEVENTS = 532 + PlSqlParserEVERY = 533 + PlSqlParserEXCEPT = 534 + PlSqlParserEXCEPTION = 535 + PlSqlParserEXCEPTION_INIT = 536 + PlSqlParserEXCEPTIONS = 537 + PlSqlParserEXCHANGE = 538 + PlSqlParserEXCLUDE = 539 + PlSqlParserEXCLUDING = 540 + PlSqlParserEXCLUSIVE = 541 + PlSqlParserEXECUTE = 542 + PlSqlParserEXEMPT = 543 + PlSqlParserEXISTING = 544 + PlSqlParserEXISTS = 545 + PlSqlParserEXISTSNODE = 546 + PlSqlParserEXIT = 547 + PlSqlParserEXPAND_GSET_TO_UNION = 548 + PlSqlParserEXPAND_TABLE = 549 + PlSqlParserEXP = 550 + PlSqlParserEXPIRE = 551 + PlSqlParserEXPLAIN = 552 + PlSqlParserEXPLOSION = 553 + PlSqlParserEXPORT = 554 + PlSqlParserEXPR_CORR_CHECK = 555 + PlSqlParserEXPRESS = 556 + PlSqlParserEXTENDS = 557 + PlSqlParserEXTENT = 558 + PlSqlParserEXTENTS = 559 + PlSqlParserEXTERNAL = 560 + PlSqlParserEXTERNALLY = 561 + PlSqlParserEXTRACTCLOBXML = 562 + PlSqlParserEXTRACT = 563 + PlSqlParserEXTRACTVALUE = 564 + PlSqlParserEXTRA = 565 + PlSqlParserFACILITY = 566 + PlSqlParserFACT = 567 + PlSqlParserFACTOR = 568 + PlSqlParserFACTORIZE_JOIN = 569 + PlSqlParserFAILED = 570 + PlSqlParserFAILED_LOGIN_ATTEMPTS = 571 + PlSqlParserFAILGROUP = 572 + PlSqlParserFAILOVER = 573 + PlSqlParserFAILURE = 574 + PlSqlParserFALSE = 575 + PlSqlParserFAMILY = 576 + PlSqlParserFAR = 577 + PlSqlParserFAST = 578 + PlSqlParserFASTSTART = 579 + PlSqlParserFBTSCAN = 580 + PlSqlParserFEATURE = 581 + PlSqlParserFEATURE_DETAILS = 582 + PlSqlParserFEATURE_ID = 583 + PlSqlParserFEATURE_SET = 584 + PlSqlParserFEATURE_VALUE = 585 + PlSqlParserFETCH = 586 + PlSqlParserFIELD = 587 + PlSqlParserFIELDS = 588 + PlSqlParserFILE = 589 + PlSqlParserFILE_NAME_CONVERT = 590 + PlSqlParserFILEGROUP = 591 + PlSqlParserFILESTORE = 592 + PlSqlParserFILESYSTEM_LIKE_LOGGING = 593 + PlSqlParserFILTER = 594 + PlSqlParserFINAL = 595 + PlSqlParserFINE = 596 + PlSqlParserFINISH = 597 + PlSqlParserFIRST = 598 + PlSqlParserFIRSTM = 599 + PlSqlParserFIRST_ROWS = 600 + PlSqlParserFIRST_VALUE = 601 + PlSqlParserFIXED = 602 + PlSqlParserFIXED_VIEW_DATA = 603 + PlSqlParserFLAGGER = 604 + PlSqlParserFLASHBACK = 605 + PlSqlParserFLASH_CACHE = 606 + PlSqlParserFLOAT = 607 + PlSqlParserFLOB = 608 + PlSqlParserFLEX = 609 + PlSqlParserFLOOR = 610 + PlSqlParserFLUSH = 611 + PlSqlParserFOLDER = 612 + PlSqlParserFOLLOWING = 613 + PlSqlParserFOLLOWS = 614 + PlSqlParserFORALL = 615 + PlSqlParserFORCE = 616 + PlSqlParserFORCE_XML_QUERY_REWRITE = 617 + PlSqlParserFOREIGN = 618 + PlSqlParserFOREVER = 619 + PlSqlParserFOR = 620 + PlSqlParserFORMAT = 621 + PlSqlParserFORWARD = 622 + PlSqlParserFRAGMENT_NUMBER = 623 + PlSqlParserFREELIST = 624 + PlSqlParserFREELISTS = 625 + PlSqlParserFREEPOOLS = 626 + PlSqlParserFRESH = 627 + PlSqlParserFROM = 628 + PlSqlParserFROM_TZ = 629 + PlSqlParserFULL = 630 + PlSqlParserFULL_OUTER_JOIN_TO_OUTER = 631 + PlSqlParserFUNCTION = 632 + PlSqlParserFUNCTIONS = 633 + PlSqlParserFTP = 634 + PlSqlParserG_LETTER = 635 + PlSqlParserGATHER_OPTIMIZER_STATISTICS = 636 + PlSqlParserGATHER_PLAN_STATISTICS = 637 + PlSqlParserGBY_CONC_ROLLUP = 638 + PlSqlParserGBY_PUSHDOWN = 639 + PlSqlParserGENERATED = 640 + PlSqlParserGET = 641 + PlSqlParserGLOBAL = 642 + PlSqlParserGLOBALLY = 643 + PlSqlParserGLOBAL_NAME = 644 + PlSqlParserGLOBAL_TOPIC_ENABLED = 645 + PlSqlParserGOTO = 646 + PlSqlParserGRANT = 647 + PlSqlParserGROUP_BY = 648 + PlSqlParserGROUP = 649 + PlSqlParserGROUP_ID = 650 + PlSqlParserGROUPING = 651 + PlSqlParserGROUPING_ID = 652 + PlSqlParserGROUPS = 653 + PlSqlParserGUARANTEED = 654 + PlSqlParserGUARANTEE = 655 + PlSqlParserGUARD = 656 + PlSqlParserHADOOP_TRAILERS = 657 + PlSqlParserHALF_YEARS = 658 + PlSqlParserHASH_AJ = 659 + PlSqlParserHASH = 660 + PlSqlParserHASHKEYS = 661 + PlSqlParserHASH_SJ = 662 + PlSqlParserHAVING = 663 + PlSqlParserHEADER = 664 + PlSqlParserHEAP = 665 + PlSqlParserHELP = 666 + PlSqlParserHEXTORAW = 667 + PlSqlParserHEXTOREF = 668 + PlSqlParserHIDDEN_KEYWORD = 669 + PlSqlParserHIDE = 670 + PlSqlParserHIER_ORDER = 671 + PlSqlParserHIERARCHICAL = 672 + PlSqlParserHIERARCHIES = 673 + PlSqlParserHIERARCHY = 674 + PlSqlParserHIGH = 675 + PlSqlParserHINTSET_BEGIN = 676 + PlSqlParserHINTSET_END = 677 + PlSqlParserHOT = 678 + PlSqlParserHOUR = 679 + PlSqlParserHOURS = 680 + PlSqlParserHTTP = 681 + PlSqlParserHWM_BROKERED = 682 + PlSqlParserHYBRID = 683 + PlSqlParserH_LETTER = 684 + PlSqlParserIDENTIFIED = 685 + PlSqlParserIDENTIFIER = 686 + PlSqlParserIDENTITY = 687 + PlSqlParserIDGENERATORS = 688 + PlSqlParserID = 689 + PlSqlParserIDLE_TIME = 690 + PlSqlParserIF = 691 + PlSqlParserIGNORE = 692 + PlSqlParserIGNORE_CHARS_AFTER_EOR = 693 + PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS = 694 + PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX = 695 + PlSqlParserIGNORE_WHERE_CLAUSE = 696 + PlSqlParserILM = 697 + PlSqlParserIMMEDIATE = 698 + PlSqlParserIMPACT = 699 + PlSqlParserIMPORT = 700 + PlSqlParserINACTIVE = 701 + PlSqlParserINACTIVE_ACCOUNT_TIME = 702 + PlSqlParserINCLUDE = 703 + PlSqlParserINCLUDE_VERSION = 704 + PlSqlParserINCLUDING = 705 + PlSqlParserINCREMENTAL = 706 + PlSqlParserINCREMENT = 707 + PlSqlParserINCR = 708 + PlSqlParserINDENT = 709 + PlSqlParserINDEX_ASC = 710 + PlSqlParserINDEX_COMBINE = 711 + PlSqlParserINDEX_DESC = 712 + PlSqlParserINDEXED = 713 + PlSqlParserINDEXES = 714 + PlSqlParserINDEX_FFS = 715 + PlSqlParserINDEX_FILTER = 716 + PlSqlParserINDEX = 717 + PlSqlParserINDEXING = 718 + PlSqlParserINDEX_JOIN = 719 + PlSqlParserINDEX_ROWS = 720 + PlSqlParserINDEX_RRS = 721 + PlSqlParserINDEX_RS_ASC = 722 + PlSqlParserINDEX_RS_DESC = 723 + PlSqlParserINDEX_RS = 724 + PlSqlParserINDEX_SCAN = 725 + PlSqlParserINDEX_SKIP_SCAN = 726 + PlSqlParserINDEX_SS_ASC = 727 + PlSqlParserINDEX_SS_DESC = 728 + PlSqlParserINDEX_SS = 729 + PlSqlParserINDEX_STATS = 730 + PlSqlParserINDEXTYPE = 731 + PlSqlParserINDEXTYPES = 732 + PlSqlParserINDICATOR = 733 + PlSqlParserINDICES = 734 + PlSqlParserINFINITE = 735 + PlSqlParserINFORMATIONAL = 736 + PlSqlParserINHERIT = 737 + PlSqlParserIN = 738 + PlSqlParserINITCAP = 739 + PlSqlParserINITIAL = 740 + PlSqlParserINITIALIZED = 741 + PlSqlParserINITIALLY = 742 + PlSqlParserINITRANS = 743 + PlSqlParserINLINE = 744 + PlSqlParserINLINE_XMLTYPE_NT = 745 + PlSqlParserINMEMORY = 746 + PlSqlParserIN_MEMORY_METADATA = 747 + PlSqlParserINMEMORY_PRUNING = 748 + PlSqlParserINNER = 749 + PlSqlParserINOUT = 750 + PlSqlParserINPLACE = 751 + PlSqlParserINPUTFORMAT = 752 + PlSqlParserINSERTCHILDXMLAFTER = 753 + PlSqlParserINSERTCHILDXMLBEFORE = 754 + PlSqlParserINSERTCHILDXML = 755 + PlSqlParserINSERT = 756 + PlSqlParserINSERTXMLAFTER = 757 + PlSqlParserINSERTXMLBEFORE = 758 + PlSqlParserINSTANCE = 759 + PlSqlParserINSTANCES = 760 + PlSqlParserINSTANTIABLE = 761 + PlSqlParserINSTANTLY = 762 + PlSqlParserINSTEAD = 763 + PlSqlParserINSTR2 = 764 + PlSqlParserINSTR4 = 765 + PlSqlParserINSTRB = 766 + PlSqlParserINSTRC = 767 + PlSqlParserINSTR = 768 + PlSqlParserINTEGER = 769 + PlSqlParserINTERLEAVED = 770 + PlSqlParserINTERMEDIATE = 771 + PlSqlParserINTERNAL_CONVERT = 772 + PlSqlParserINTERNAL_USE = 773 + PlSqlParserINTERPRETED = 774 + PlSqlParserINTERSECT = 775 + PlSqlParserINTERVAL = 776 + PlSqlParserINT = 777 + PlSqlParserINTERNAL = 778 + PlSqlParserINTO = 779 + PlSqlParserINVALIDATE = 780 + PlSqlParserINVALIDATION = 781 + PlSqlParserINVISIBLE = 782 + PlSqlParserIN_XQUERY = 783 + PlSqlParserIO_OPTIONS = 784 + PlSqlParserIS = 785 + PlSqlParserIS_LEAF = 786 + PlSqlParserISOLATION = 787 + PlSqlParserISOLATION_LEVEL = 788 + PlSqlParserITEMS = 789 + PlSqlParserITERATE = 790 + PlSqlParserITERATION_NUMBER = 791 + PlSqlParserJAVA = 792 + PlSqlParserJOB = 793 + PlSqlParserJOIN = 794 + PlSqlParserJSON_ARRAYAGG = 795 + PlSqlParserJSON_ARRAY = 796 + PlSqlParserJSON_EQUAL = 797 + PlSqlParserJSON_EXISTS2 = 798 + PlSqlParserJSON_EXISTS = 799 + PlSqlParserJSONGET = 800 + PlSqlParserJSON = 801 + PlSqlParserJSON_OBJECTAGG = 802 + PlSqlParserJSON_OBJECT = 803 + PlSqlParserJSONPARSE = 804 + PlSqlParserJSON_QUERY = 805 + PlSqlParserJSON_SERIALIZE = 806 + PlSqlParserJSON_TABLE = 807 + PlSqlParserJSON_TEXTCONTAINS2 = 808 + PlSqlParserJSON_TEXTCONTAINS = 809 + PlSqlParserJSON_TRANSFORM = 810 + PlSqlParserJSON_VALUE = 811 + PlSqlParserK_LETTER = 812 + PlSqlParserKEEP_DUPLICATES = 813 + PlSqlParserKEEP = 814 + PlSqlParserKERBEROS = 815 + PlSqlParserKEY = 816 + PlSqlParserKEY_LENGTH = 817 + PlSqlParserKEYSIZE = 818 + PlSqlParserKEYS = 819 + PlSqlParserKEYSTORE = 820 + PlSqlParserKILL = 821 + PlSqlParserLABEL = 822 + PlSqlParserLANGUAGE = 823 + PlSqlParserLAST_DAY = 824 + PlSqlParserLAST = 825 + PlSqlParserLAST_VALUE = 826 + PlSqlParserLATERAL = 827 + PlSqlParserLATEST = 828 + PlSqlParserLAX = 829 + PlSqlParserLAYER = 830 + PlSqlParserLDAP_REGISTRATION_ENABLED = 831 + PlSqlParserLDAP_REGISTRATION = 832 + PlSqlParserLDAP_REG_SYNC_INTERVAL = 833 + PlSqlParserLDRTRIM = 834 + PlSqlParserLEAF = 835 + PlSqlParserLEAD_CDB = 836 + PlSqlParserLEAD_CDB_URI = 837 + PlSqlParserLEADING = 838 + PlSqlParserLEFT = 839 + PlSqlParserLENGTH2 = 840 + PlSqlParserLENGTH4 = 841 + PlSqlParserLENGTHB = 842 + PlSqlParserLENGTHC = 843 + PlSqlParserLENGTH = 844 + PlSqlParserLESS = 845 + PlSqlParserLEVEL = 846 + PlSqlParserLEVEL_NAME = 847 + PlSqlParserLEVELS = 848 + PlSqlParserLIBRARY = 849 + PlSqlParserLIFECYCLE = 850 + PlSqlParserLIFE = 851 + PlSqlParserLIFETIME = 852 + PlSqlParserLIKE2 = 853 + PlSqlParserLIKE4 = 854 + PlSqlParserLIKEC = 855 + PlSqlParserLIKE_EXPAND = 856 + PlSqlParserLIKE = 857 + PlSqlParserLIMIT = 858 + PlSqlParserLINEAR = 859 + PlSqlParserLINES = 860 + PlSqlParserLINK = 861 + PlSqlParserLIST = 862 + PlSqlParserLITTLE = 863 + PlSqlParserLLS = 864 + PlSqlParserLN = 865 + PlSqlParserLNNVL = 866 + PlSqlParserLOAD = 867 + PlSqlParserLOB = 868 + PlSqlParserLOBFILE = 869 + PlSqlParserLOBNVL = 870 + PlSqlParserLOBS = 871 + PlSqlParserLOCAL_INDEXES = 872 + PlSqlParserLOCAL = 873 + PlSqlParserLOCALTIME = 874 + PlSqlParserLOCALTIMESTAMP = 875 + PlSqlParserLOCATION = 876 + PlSqlParserLOCATOR = 877 + PlSqlParserLOCKDOWN = 878 + PlSqlParserLOCKED = 879 + PlSqlParserLOCKING = 880 + PlSqlParserLOCK = 881 + PlSqlParserLOGFILE = 882 + PlSqlParserLOGFILES = 883 + PlSqlParserLOGGING = 884 + PlSqlParserLOGICAL = 885 + PlSqlParserLOGICAL_READS_PER_CALL = 886 + PlSqlParserLOGICAL_READS_PER_SESSION = 887 + PlSqlParserLOG = 888 + PlSqlParserLOGMINING = 889 + PlSqlParserLOGOFF = 890 + PlSqlParserLOGON = 891 + PlSqlParserLOG_READ_ONLY_VIOLATIONS = 892 + PlSqlParserLONG = 893 + PlSqlParserLOOP = 894 + PlSqlParserLOST = 895 + PlSqlParserLOWER = 896 + PlSqlParserLOW = 897 + PlSqlParserLPAD = 898 + PlSqlParserLRTRIM = 899 + PlSqlParserLTRIM = 900 + PlSqlParserM_LETTER = 901 + PlSqlParserMAIN = 902 + PlSqlParserMAKE_REF = 903 + PlSqlParserMANAGED = 904 + PlSqlParserMANAGE = 905 + PlSqlParserMANAGEMENT = 906 + PlSqlParserMANAGER = 907 + PlSqlParserMANDATORY = 908 + PlSqlParserMANUAL = 909 + PlSqlParserMAP = 910 + PlSqlParserMAPPING = 911 + PlSqlParserMASK = 912 + PlSqlParserMASTER = 913 + PlSqlParserMATCHED = 914 + PlSqlParserMATCHES = 915 + PlSqlParserMATCH = 916 + PlSqlParserMATCH_NUMBER = 917 + PlSqlParserMATCH_RECOGNIZE = 918 + PlSqlParserMATERIALIZED = 919 + PlSqlParserMATERIALIZE = 920 + PlSqlParserMAXARCHLOGS = 921 + PlSqlParserMAXDATAFILES = 922 + PlSqlParserMAXEXTENTS = 923 + PlSqlParserMAXIMIZE = 924 + PlSqlParserMAXINSTANCES = 925 + PlSqlParserMAXLOGFILES = 926 + PlSqlParserMAXLOGHISTORY = 927 + PlSqlParserMAXLOGMEMBERS = 928 + PlSqlParserMAX_SHARED_TEMP_SIZE = 929 + PlSqlParserMAXSIZE = 930 + PlSqlParserMAXTRANS = 931 + PlSqlParserMAXVALUE = 932 + PlSqlParserMEASURE = 933 + PlSqlParserMEASURES = 934 + PlSqlParserMEDIUM = 935 + PlSqlParserMEMBER = 936 + PlSqlParserMEMBER_CAPTION = 937 + PlSqlParserMEMBER_DESCRIPTION = 938 + PlSqlParserMEMBER_NAME = 939 + PlSqlParserMEMBER_UNIQUE_NAME = 940 + PlSqlParserMEMCOMPRESS = 941 + PlSqlParserMEMORY = 942 + PlSqlParserMERGEACTIONS = 943 + PlSqlParserMERGE_AJ = 944 + PlSqlParserMERGE_CONST_ON = 945 + PlSqlParserMERGE = 946 + PlSqlParserMERGE_SJ = 947 + PlSqlParserMETADATA = 948 + PlSqlParserMETHOD = 949 + PlSqlParserMIGRATE = 950 + PlSqlParserMIGRATION = 951 + PlSqlParserMINEXTENTS = 952 + PlSqlParserMINIMIZE = 953 + PlSqlParserMINIMUM = 954 + PlSqlParserMINING = 955 + PlSqlParserMINUS = 956 + PlSqlParserMINUS_NULL = 957 + PlSqlParserMINUTE = 958 + PlSqlParserMINUTES = 959 + PlSqlParserMINVALUE = 960 + PlSqlParserMIRRORCOLD = 961 + PlSqlParserMIRRORHOT = 962 + PlSqlParserMIRROR = 963 + PlSqlParserMISSING = 964 + PlSqlParserMISMATCH = 965 + PlSqlParserMLSLABEL = 966 + PlSqlParserMODEL_COMPILE_SUBQUERY = 967 + PlSqlParserMODEL_DONTVERIFY_UNIQUENESS = 968 + PlSqlParserMODEL_DYNAMIC_SUBQUERY = 969 + PlSqlParserMODEL_MIN_ANALYSIS = 970 + PlSqlParserMODEL = 971 + PlSqlParserMODEL_NB = 972 + PlSqlParserMODEL_NO_ANALYSIS = 973 + PlSqlParserMODEL_PBY = 974 + PlSqlParserMODEL_PUSH_REF = 975 + PlSqlParserMODEL_SV = 976 + PlSqlParserMODE = 977 + PlSqlParserMODIFICATION = 978 + PlSqlParserMODIFY_COLUMN_TYPE = 979 + PlSqlParserMODIFY = 980 + PlSqlParserMOD = 981 + PlSqlParserMODULE = 982 + PlSqlParserMONITORING = 983 + PlSqlParserMONITOR = 984 + PlSqlParserMONTH = 985 + PlSqlParserMONTHS_BETWEEN = 986 + PlSqlParserMONTHS = 987 + PlSqlParserMOUNT = 988 + PlSqlParserMOUNTPATH = 989 + PlSqlParserMOUNTPOINT = 990 + PlSqlParserMOVEMENT = 991 + PlSqlParserMOVE = 992 + PlSqlParserMULTIDIMENSIONAL = 993 + PlSqlParserMULTISET = 994 + PlSqlParserMV_MERGE = 995 + PlSqlParserNAMED = 996 + PlSqlParserNAME = 997 + PlSqlParserNAMESPACE = 998 + PlSqlParserNAN_ = 999 + PlSqlParserNANVL = 1000 + PlSqlParserNATIONAL = 1001 + PlSqlParserNATIVE_FULL_OUTER_JOIN = 1002 + PlSqlParserNATIVE = 1003 + PlSqlParserNATURAL = 1004 + PlSqlParserNATURALN = 1005 + PlSqlParserNAV = 1006 + PlSqlParserNCHAR_CS = 1007 + PlSqlParserNCHAR = 1008 + PlSqlParserNCHR = 1009 + PlSqlParserNCLOB = 1010 + PlSqlParserNEEDED = 1011 + PlSqlParserNEG = 1012 + PlSqlParserNESTED = 1013 + PlSqlParserNESTED_TABLE_FAST_INSERT = 1014 + PlSqlParserNESTED_TABLE_GET_REFS = 1015 + PlSqlParserNESTED_TABLE_ID = 1016 + PlSqlParserNESTED_TABLE_SET_REFS = 1017 + PlSqlParserNESTED_TABLE_SET_SETID = 1018 + PlSqlParserNETWORK = 1019 + PlSqlParserNEVER = 1020 + PlSqlParserNEW = 1021 + PlSqlParserNEWLINE_ = 1022 + PlSqlParserNEW_TIME = 1023 + PlSqlParserNEXT_DAY = 1024 + PlSqlParserNEXT = 1025 + PlSqlParserNL_AJ = 1026 + PlSqlParserNLJ_BATCHING = 1027 + PlSqlParserNLJ_INDEX_FILTER = 1028 + PlSqlParserNLJ_INDEX_SCAN = 1029 + PlSqlParserNLJ_PREFETCH = 1030 + PlSqlParserNLS_CALENDAR = 1031 + PlSqlParserNLS_CHARACTERSET = 1032 + PlSqlParserNLS_CHARSET_DECL_LEN = 1033 + PlSqlParserNLS_CHARSET_ID = 1034 + PlSqlParserNLS_CHARSET_NAME = 1035 + PlSqlParserNLS_COMP = 1036 + PlSqlParserNLS_CURRENCY = 1037 + PlSqlParserNLS_DATE_FORMAT = 1038 + PlSqlParserNLS_DATE_LANGUAGE = 1039 + PlSqlParserNLS_INITCAP = 1040 + PlSqlParserNLS_ISO_CURRENCY = 1041 + PlSqlParserNL_SJ = 1042 + PlSqlParserNLS_LANG = 1043 + PlSqlParserNLS_LANGUAGE = 1044 + PlSqlParserNLS_LENGTH_SEMANTICS = 1045 + PlSqlParserNLS_LOWER = 1046 + PlSqlParserNLS_NCHAR_CONV_EXCP = 1047 + PlSqlParserNLS_NUMERIC_CHARACTERS = 1048 + PlSqlParserNLS_SORT = 1049 + PlSqlParserNLSSORT = 1050 + PlSqlParserNLS_SPECIAL_CHARS = 1051 + PlSqlParserNLS_TERRITORY = 1052 + PlSqlParserNLS_UPPER = 1053 + PlSqlParserNO_ACCESS = 1054 + PlSqlParserNO_ADAPTIVE_PLAN = 1055 + PlSqlParserNO_ANSI_REARCH = 1056 + PlSqlParserNOAPPEND = 1057 + PlSqlParserNOARCHIVELOG = 1058 + PlSqlParserNOAUDIT = 1059 + PlSqlParserNOBADFILE = 1060 + PlSqlParserNO_AUTO_REOPTIMIZE = 1061 + PlSqlParserNO_BASETABLE_MULTIMV_REWRITE = 1062 + PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID = 1063 + PlSqlParserNO_BIND_AWARE = 1064 + PlSqlParserNO_BUFFER = 1065 + PlSqlParserNOCACHE = 1066 + PlSqlParserNOCHECK = 1067 + PlSqlParserNO_CARTESIAN = 1068 + PlSqlParserNO_CHECK_ACL_REWRITE = 1069 + PlSqlParserNO_CLUSTER_BY_ROWID = 1070 + PlSqlParserNO_CLUSTERING = 1071 + PlSqlParserNO_COALESCE_SQ = 1072 + PlSqlParserNO_COMMON_DATA = 1073 + PlSqlParserNOCOMPRESS = 1074 + PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY = 1075 + PlSqlParserNO_CONNECT_BY_COMBINE_SW = 1076 + PlSqlParserNO_CONNECT_BY_COST_BASED = 1077 + PlSqlParserNO_CONNECT_BY_ELIM_DUPS = 1078 + PlSqlParserNO_CONNECT_BY_FILTERING = 1079 + PlSqlParserNOCOPY = 1080 + PlSqlParserNO_COST_XML_QUERY_REWRITE = 1081 + PlSqlParserNO_CPU_COSTING = 1082 + PlSqlParserNOCPU_COSTING = 1083 + PlSqlParserNOCYCLE = 1084 + PlSqlParserNO_DATA_SECURITY_REWRITE = 1085 + PlSqlParserNO_DECORRELATE = 1086 + PlSqlParserNODELAY = 1087 + PlSqlParserNODIRECTIO = 1088 + PlSqlParserNODISCARDFILE = 1089 + PlSqlParserNO_DOMAIN_INDEX_FILTER = 1090 + PlSqlParserNO_DST_UPGRADE_INSERT_CONV = 1091 + PlSqlParserNO_ELIM_GROUPBY = 1092 + PlSqlParserNO_ELIMINATE_JOIN = 1093 + PlSqlParserNO_ELIMINATE_OBY = 1094 + PlSqlParserNO_ELIMINATE_OUTER_JOIN = 1095 + PlSqlParserNOENTITYESCAPING = 1096 + PlSqlParserNO_EXPAND_GSET_TO_UNION = 1097 + PlSqlParserNO_EXPAND = 1098 + PlSqlParserNO_EXPAND_TABLE = 1099 + PlSqlParserNOEXTEND = 1100 + PlSqlParserNO_FACT = 1101 + PlSqlParserNO_FACTORIZE_JOIN = 1102 + PlSqlParserNO_FILTERING = 1103 + PlSqlParserNOFORCE = 1104 + PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER = 1105 + PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS = 1106 + PlSqlParserNO_GBY_PUSHDOWN = 1107 + PlSqlParserNOGUARANTEE = 1108 + PlSqlParserNO_INDEX_FFS = 1109 + PlSqlParserNO_INDEX = 1110 + PlSqlParserNO_INDEX_SS = 1111 + PlSqlParserNO_INMEMORY = 1112 + PlSqlParserNO_INMEMORY_PRUNING = 1113 + PlSqlParserNOKEEP = 1114 + PlSqlParserNO_LOAD = 1115 + PlSqlParserNOLOCAL = 1116 + PlSqlParserNOLOG = 1117 + PlSqlParserNOLOGFILE = 1118 + PlSqlParserNOLOGGING = 1119 + PlSqlParserNOMAPPING = 1120 + PlSqlParserNOMAXVALUE = 1121 + PlSqlParserNO_MERGE = 1122 + PlSqlParserNOMINIMIZE = 1123 + PlSqlParserNOMINVALUE = 1124 + PlSqlParserNO_MODEL_PUSH_REF = 1125 + PlSqlParserNO_MONITORING = 1126 + PlSqlParserNOMONITORING = 1127 + PlSqlParserNO_MONITOR = 1128 + PlSqlParserNO_MULTIMV_REWRITE = 1129 + PlSqlParserNO_NATIVE_FULL_OUTER_JOIN = 1130 + PlSqlParserNONBLOCKING = 1131 + PlSqlParserNONEDITIONABLE = 1132 + PlSqlParserNONE = 1133 + PlSqlParserNONULLIF = 1134 + PlSqlParserNO_NLJ_BATCHING = 1135 + PlSqlParserNO_NLJ_PREFETCH = 1136 + PlSqlParserNO = 1137 + PlSqlParserNONSCHEMA = 1138 + PlSqlParserNO_OBJECT_LINK = 1139 + PlSqlParserNOORDER = 1140 + PlSqlParserNO_ORDER_ROLLUPS = 1141 + PlSqlParserNO_OUTER_JOIN_TO_ANTI = 1142 + PlSqlParserNO_OUTER_JOIN_TO_INNER = 1143 + PlSqlParserNOOVERRIDE = 1144 + PlSqlParserNO_PARALLEL_INDEX = 1145 + PlSqlParserNOPARALLEL_INDEX = 1146 + PlSqlParserNO_PARALLEL = 1147 + PlSqlParserNOPARALLEL = 1148 + PlSqlParserNO_PARTIAL_COMMIT = 1149 + PlSqlParserNO_PARTIAL_JOIN = 1150 + PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN = 1151 + PlSqlParserNOPARTITION = 1152 + PlSqlParserNO_PLACE_DISTINCT = 1153 + PlSqlParserNO_PLACE_GROUP_BY = 1154 + PlSqlParserNO_PQ_CONCURRENT_UNION = 1155 + PlSqlParserNO_PQ_MAP = 1156 + PlSqlParserNOPROMPT = 1157 + PlSqlParserNO_PQ_REPLICATE = 1158 + PlSqlParserNO_PQ_SKEW = 1159 + PlSqlParserNO_PRUNE_GSETS = 1160 + PlSqlParserNO_PULL_PRED = 1161 + PlSqlParserNO_PUSH_PRED = 1162 + PlSqlParserNO_PUSH_SUBQ = 1163 + PlSqlParserNO_PX_FAULT_TOLERANCE = 1164 + PlSqlParserNO_PX_JOIN_FILTER = 1165 + PlSqlParserNO_QKN_BUFF = 1166 + PlSqlParserNO_QUERY_TRANSFORMATION = 1167 + PlSqlParserNO_REF_CASCADE = 1168 + PlSqlParserNORELOCATE = 1169 + PlSqlParserNORELY = 1170 + PlSqlParserNOREPAIR = 1171 + PlSqlParserNOREPLAY = 1172 + PlSqlParserNORESETLOGS = 1173 + PlSqlParserNO_RESULT_CACHE = 1174 + PlSqlParserNOREVERSE = 1175 + PlSqlParserNO_REWRITE = 1176 + PlSqlParserNOREWRITE = 1177 + PlSqlParserNORMAL = 1178 + PlSqlParserNO_ROOT_SW_FOR_LOCAL = 1179 + PlSqlParserNOROWDEPENDENCIES = 1180 + PlSqlParserNOSCALE = 1181 + PlSqlParserNOSCHEMACHECK = 1182 + PlSqlParserNOSEGMENT = 1183 + PlSqlParserNO_SEMIJOIN = 1184 + PlSqlParserNO_SEMI_TO_INNER = 1185 + PlSqlParserNO_SET_TO_JOIN = 1186 + PlSqlParserNOSHARD = 1187 + PlSqlParserNOSORT = 1188 + PlSqlParserNO_SQL_TRANSLATION = 1189 + PlSqlParserNO_SQL_TUNE = 1190 + PlSqlParserNO_STAR_TRANSFORMATION = 1191 + PlSqlParserNO_STATEMENT_QUEUING = 1192 + PlSqlParserNO_STATS_GSETS = 1193 + PlSqlParserNOSTRICT = 1194 + PlSqlParserNO_SUBQUERY_PRUNING = 1195 + PlSqlParserNO_SUBSTRB_PAD = 1196 + PlSqlParserNO_SWAP_JOIN_INPUTS = 1197 + PlSqlParserNOSWITCH = 1198 + PlSqlParserNO_TABLE_LOOKUP_BY_NL = 1199 + PlSqlParserNO_TEMP_TABLE = 1200 + PlSqlParserNOTHING = 1201 + PlSqlParserNOTIFICATION = 1202 + PlSqlParserNOTRIM = 1203 + PlSqlParserNOT = 1204 + PlSqlParserNO_TRANSFORM_DISTINCT_AGG = 1205 + PlSqlParserNO_UNNEST = 1206 + PlSqlParserNO_USE_CUBE = 1207 + PlSqlParserNO_USE_HASH_AGGREGATION = 1208 + PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN = 1209 + PlSqlParserNO_USE_HASH = 1210 + PlSqlParserNO_USE_INVISIBLE_INDEXES = 1211 + PlSqlParserNO_USE_MERGE = 1212 + PlSqlParserNO_USE_NL = 1213 + PlSqlParserNO_USE_VECTOR_AGGREGATION = 1214 + PlSqlParserNOVALIDATE = 1215 + PlSqlParserNO_VECTOR_TRANSFORM_DIMS = 1216 + PlSqlParserNO_VECTOR_TRANSFORM_FACT = 1217 + PlSqlParserNO_VECTOR_TRANSFORM = 1218 + PlSqlParserNOWAIT = 1219 + PlSqlParserNO_XDB_FASTPATH_INSERT = 1220 + PlSqlParserNO_XML_DML_REWRITE = 1221 + PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT = 1222 + PlSqlParserNO_XMLINDEX_REWRITE = 1223 + PlSqlParserNO_XML_QUERY_REWRITE = 1224 + PlSqlParserNO_ZONEMAP = 1225 + PlSqlParserNTH_VALUE = 1226 + PlSqlParserNULLIF = 1227 + PlSqlParserNULL_ = 1228 + PlSqlParserNULLS = 1229 + PlSqlParserNUMBER = 1230 + PlSqlParserNUMERIC = 1231 + PlSqlParserNUM_INDEX_KEYS = 1232 + PlSqlParserNUMTODSINTERVAL = 1233 + PlSqlParserNUMTOYMINTERVAL = 1234 + PlSqlParserNVARCHAR2 = 1235 + PlSqlParserNVL2 = 1236 + PlSqlParserOBJECT2XML = 1237 + PlSqlParserOBJECT = 1238 + PlSqlParserOBJ_ID = 1239 + PlSqlParserOBJNO = 1240 + PlSqlParserOBJNO_REUSE = 1241 + PlSqlParserOCCURENCES = 1242 + PlSqlParserOFFLINE = 1243 + PlSqlParserOFF = 1244 + PlSqlParserOFFSET = 1245 + PlSqlParserOF = 1246 + PlSqlParserOIDINDEX = 1247 + PlSqlParserOID = 1248 + PlSqlParserOLAP = 1249 + PlSqlParserOLD = 1250 + PlSqlParserOLD_PUSH_PRED = 1251 + PlSqlParserOLS = 1252 + PlSqlParserOLTP = 1253 + PlSqlParserOMIT = 1254 + PlSqlParserONE = 1255 + PlSqlParserONLINE = 1256 + PlSqlParserONLINELOG = 1257 + PlSqlParserONLY = 1258 + PlSqlParserON = 1259 + PlSqlParserOPAQUE = 1260 + PlSqlParserOPAQUE_TRANSFORM = 1261 + PlSqlParserOPAQUE_XCANONICAL = 1262 + PlSqlParserOPCODE = 1263 + PlSqlParserOPEN = 1264 + PlSqlParserOPERATIONS = 1265 + PlSqlParserOPERATOR = 1266 + PlSqlParserOPT_ESTIMATE = 1267 + PlSqlParserOPTIMAL = 1268 + PlSqlParserOPTIMIZE = 1269 + PlSqlParserOPTIMIZER_FEATURES_ENABLE = 1270 + PlSqlParserOPTIMIZER_GOAL = 1271 + PlSqlParserOPTION = 1272 + PlSqlParserOPTIONALLY = 1273 + PlSqlParserOPT_PARAM = 1274 + PlSqlParserORA_BRANCH = 1275 + PlSqlParserORA_CHECK_ACL = 1276 + PlSqlParserORA_CHECK_PRIVILEGE = 1277 + PlSqlParserORA_CLUSTERING = 1278 + PlSqlParserORADATA = 1279 + PlSqlParserORC = 1280 + PlSqlParserORACLE_DATE = 1281 + PlSqlParserORACLE_NUMBER = 1282 + PlSqlParserORADEBUG = 1283 + PlSqlParserORA_DST_AFFECTED = 1284 + PlSqlParserORA_DST_CONVERT = 1285 + PlSqlParserORA_DST_ERROR = 1286 + PlSqlParserORA_GET_ACLIDS = 1287 + PlSqlParserORA_GET_PRIVILEGES = 1288 + PlSqlParserORA_HASH = 1289 + PlSqlParserORA_INVOKING_USERID = 1290 + PlSqlParserORA_INVOKING_USER = 1291 + PlSqlParserORA_INVOKING_XS_USER_GUID = 1292 + PlSqlParserORA_INVOKING_XS_USER = 1293 + PlSqlParserORA_RAWCOMPARE = 1294 + PlSqlParserORA_RAWCONCAT = 1295 + PlSqlParserORA_ROWSCN = 1296 + PlSqlParserORA_ROWSCN_RAW = 1297 + PlSqlParserORA_ROWVERSION = 1298 + PlSqlParserORA_TABVERSION = 1299 + PlSqlParserORA_WRITE_TIME = 1300 + PlSqlParserORDERED = 1301 + PlSqlParserORDERED_PREDICATES = 1302 + PlSqlParserORDER = 1303 + PlSqlParserORDINALITY = 1304 + PlSqlParserOR_EXPAND = 1305 + PlSqlParserORGANIZATION = 1306 + PlSqlParserOR = 1307 + PlSqlParserOR_PREDICATES = 1308 + PlSqlParserOSERROR = 1309 + PlSqlParserOTHER = 1310 + PlSqlParserOUTER_JOIN_TO_ANTI = 1311 + PlSqlParserOUTER_JOIN_TO_INNER = 1312 + PlSqlParserOUTER = 1313 + PlSqlParserOUTLINE_LEAF = 1314 + PlSqlParserOUTLINE = 1315 + PlSqlParserOUTPUTFORMAT = 1316 + PlSqlParserOUT_OF_LINE = 1317 + PlSqlParserOUT = 1318 + PlSqlParserOVERFLOW_NOMOVE = 1319 + PlSqlParserOVERFLOW_ = 1320 + PlSqlParserOVERLAPS = 1321 + PlSqlParserOVER = 1322 + PlSqlParserOVERRIDE = 1323 + PlSqlParserOVERRIDING = 1324 + PlSqlParserOWNER = 1325 + PlSqlParserOWNERSHIP = 1326 + PlSqlParserOWN = 1327 + PlSqlParserP_LETTER = 1328 + PlSqlParserPACKAGE = 1329 + PlSqlParserPACKAGES = 1330 + PlSqlParserPARALLEL_ENABLE = 1331 + PlSqlParserPARALLEL_INDEX = 1332 + PlSqlParserPARALLEL = 1333 + PlSqlParserPARAMETERFILE = 1334 + PlSqlParserPARAMETERS = 1335 + PlSqlParserPARAM = 1336 + PlSqlParserPARENT = 1337 + PlSqlParserPARENT_LEVEL_NAME = 1338 + PlSqlParserPARENT_UNIQUE_NAME = 1339 + PlSqlParserPARITY = 1340 + PlSqlParserPARQUET = 1341 + PlSqlParserPARTIAL_JOIN = 1342 + PlSqlParserPARTIALLY = 1343 + PlSqlParserPARTIAL = 1344 + PlSqlParserPARTIAL_ROLLUP_PUSHDOWN = 1345 + PlSqlParserPARTITION_HASH = 1346 + PlSqlParserPARTITION_LIST = 1347 + PlSqlParserPARTITION = 1348 + PlSqlParserPARTITION_RANGE = 1349 + PlSqlParserPARTITIONS = 1350 + PlSqlParserPARTNUMINST = 1351 + PlSqlParserPASSING = 1352 + PlSqlParserPASSWORD_GRACE_TIME = 1353 + PlSqlParserPASSWORD_LIFE_TIME = 1354 + PlSqlParserPASSWORD_LOCK_TIME = 1355 + PlSqlParserPASSWORD = 1356 + PlSqlParserPASSWORD_REUSE_MAX = 1357 + PlSqlParserPASSWORD_REUSE_TIME = 1358 + PlSqlParserPASSWORD_ROLLOVER_TIME = 1359 + PlSqlParserPASSWORD_VERIFY_FUNCTION = 1360 + PlSqlParserPAST = 1361 + PlSqlParserPATCH = 1362 + PlSqlParserPATH = 1363 + PlSqlParserPATH_PREFIX = 1364 + PlSqlParserPATHS = 1365 + PlSqlParserPATTERN = 1366 + PlSqlParserPBL_HS_BEGIN = 1367 + PlSqlParserPBL_HS_END = 1368 + PlSqlParserPCTFREE = 1369 + PlSqlParserPCTINCREASE = 1370 + PlSqlParserPCTTHRESHOLD = 1371 + PlSqlParserPCTUSED = 1372 + PlSqlParserPCTVERSION = 1373 + PlSqlParserPENDING = 1374 + PlSqlParserPERCENT_FOUND = 1375 + PlSqlParserPERCENT_ISOPEN = 1376 + PlSqlParserPERCENT_NOTFOUND = 1377 + PlSqlParserPERCENT_KEYWORD = 1378 + PlSqlParserPERCENT_RANKM = 1379 + PlSqlParserPERCENT_ROWCOUNT = 1380 + PlSqlParserPERCENT_ROWTYPE = 1381 + PlSqlParserPERCENT_TYPE = 1382 + PlSqlParserPERCENT_BULK_EXCEPTIONS = 1383 + PlSqlParserPERCENT_BULK_ROWCOUNT = 1384 + PlSqlParserPERFORMANCE = 1385 + PlSqlParserPERIOD_KEYWORD = 1386 + PlSqlParserPERMANENT = 1387 + PlSqlParserPERMISSION = 1388 + PlSqlParserPERMUTE = 1389 + PlSqlParserPER = 1390 + PlSqlParserPFILE = 1391 + PlSqlParserPHYSICAL = 1392 + PlSqlParserPIKEY = 1393 + PlSqlParserPIPELINED = 1394 + PlSqlParserPIPE = 1395 + PlSqlParserPIV_GB = 1396 + PlSqlParserPIVOT = 1397 + PlSqlParserPIV_SSF = 1398 + PlSqlParserPLACE_DISTINCT = 1399 + PlSqlParserPLACE_GROUP_BY = 1400 + PlSqlParserPLAN = 1401 + PlSqlParserPLSCOPE_SETTINGS = 1402 + PlSqlParserPLS_INTEGER = 1403 + PlSqlParserPLSQL_CCFLAGS = 1404 + PlSqlParserPLSQL_CODE_TYPE = 1405 + PlSqlParserPLSQL_DEBUG = 1406 + PlSqlParserPLSQL_OPTIMIZE_LEVEL = 1407 + PlSqlParserPLSQL_WARNINGS = 1408 + PlSqlParserPLUGGABLE = 1409 + PlSqlParserPMEM = 1410 + PlSqlParserPOINT = 1411 + PlSqlParserPOLICY = 1412 + PlSqlParserPOOL_16K = 1413 + PlSqlParserPOOL_2K = 1414 + PlSqlParserPOOL_32K = 1415 + PlSqlParserPOOL_4K = 1416 + PlSqlParserPOOL_8K = 1417 + PlSqlParserPOSITION = 1418 + PlSqlParserPOSITIVEN = 1419 + PlSqlParserPOSITIVE = 1420 + PlSqlParserPOST_TRANSACTION = 1421 + PlSqlParserPOWERMULTISET_BY_CARDINALITY = 1422 + PlSqlParserPOWERMULTISET = 1423 + PlSqlParserPOWER = 1424 + PlSqlParserPQ_CONCURRENT_UNION = 1425 + PlSqlParserPQ_DISTRIBUTE = 1426 + PlSqlParserPQ_DISTRIBUTE_WINDOW = 1427 + PlSqlParserPQ_FILTER = 1428 + PlSqlParserPQ_MAP = 1429 + PlSqlParserPQ_NOMAP = 1430 + PlSqlParserPQ_REPLICATE = 1431 + PlSqlParserPQ_SKEW = 1432 + PlSqlParserPRAGMA = 1433 + PlSqlParserPREBUILT = 1434 + PlSqlParserPRECEDES = 1435 + PlSqlParserPRECEDING = 1436 + PlSqlParserPRECISION = 1437 + PlSqlParserPRECOMPUTE_SUBQUERY = 1438 + PlSqlParserPREDICATE_REORDERS = 1439 + PlSqlParserPRELOAD = 1440 + PlSqlParserPREPARE = 1441 + PlSqlParserPREPROCESSOR = 1442 + PlSqlParserPRESENTNNV = 1443 + PlSqlParserPRESENT = 1444 + PlSqlParserPRESENTV = 1445 + PlSqlParserPRESERVE_OID = 1446 + PlSqlParserPRESERVE = 1447 + PlSqlParserPRETTY = 1448 + PlSqlParserPREVIOUS = 1449 + PlSqlParserPREV = 1450 + PlSqlParserPRIMARY = 1451 + PlSqlParserPRINTBLOBTOCLOB = 1452 + PlSqlParserPRIORITY = 1453 + PlSqlParserPRIOR = 1454 + PlSqlParserPRIVATE = 1455 + PlSqlParserPRIVATE_SGA = 1456 + PlSqlParserPRIVILEGED = 1457 + PlSqlParserPRIVILEGE = 1458 + PlSqlParserPRIVILEGES = 1459 + PlSqlParserPROCEDURAL = 1460 + PlSqlParserPROCEDURE = 1461 + PlSqlParserPROCESS = 1462 + PlSqlParserPROFILE = 1463 + PlSqlParserPROGRAM = 1464 + PlSqlParserPROJECT = 1465 + PlSqlParserPROPAGATE = 1466 + PlSqlParserPROPERTY = 1467 + PlSqlParserPROTECTED = 1468 + PlSqlParserPROTECTION = 1469 + PlSqlParserPROTOCOL = 1470 + PlSqlParserPROXY = 1471 + PlSqlParserPRUNING = 1472 + PlSqlParserPUBLIC = 1473 + PlSqlParserPULL_PRED = 1474 + PlSqlParserPURGE = 1475 + PlSqlParserPUSH_PRED = 1476 + PlSqlParserPUSH_SUBQ = 1477 + PlSqlParserPX_FAULT_TOLERANCE = 1478 + PlSqlParserPX_GRANULE = 1479 + PlSqlParserPX_JOIN_FILTER = 1480 + PlSqlParserQB_NAME = 1481 + PlSqlParserQUARTERS = 1482 + PlSqlParserQUERY_BLOCK = 1483 + PlSqlParserQUERY = 1484 + PlSqlParserQUEUE_CURR = 1485 + PlSqlParserQUEUE = 1486 + PlSqlParserQUEUE_ROWP = 1487 + PlSqlParserQUIESCE = 1488 + PlSqlParserQUORUM = 1489 + PlSqlParserQUOTA = 1490 + PlSqlParserQUOTAGROUP = 1491 + PlSqlParserRAISE = 1492 + PlSqlParserRANDOM_LOCAL = 1493 + PlSqlParserRANDOM = 1494 + PlSqlParserRANGE = 1495 + PlSqlParserRANKM = 1496 + PlSqlParserRAPIDLY = 1497 + PlSqlParserRAW = 1498 + PlSqlParserRAWTOHEX = 1499 + PlSqlParserRAWTONHEX = 1500 + PlSqlParserRBA = 1501 + PlSqlParserRBO_OUTLINE = 1502 + PlSqlParserRCFILE = 1503 + PlSqlParserRDBA = 1504 + PlSqlParserREAD = 1505 + PlSqlParserREADS = 1506 + PlSqlParserREADSIZE = 1507 + PlSqlParserREALM = 1508 + PlSqlParserREAL = 1509 + PlSqlParserREBALANCE = 1510 + PlSqlParserREBUILD = 1511 + PlSqlParserRECORD = 1512 + PlSqlParserRECORDS = 1513 + PlSqlParserRECORDS_PER_BLOCK = 1514 + PlSqlParserRECOVERABLE = 1515 + PlSqlParserRECOVER = 1516 + PlSqlParserRECOVERY = 1517 + PlSqlParserRECYCLEBIN = 1518 + PlSqlParserRECYCLE = 1519 + PlSqlParserREDACTION = 1520 + PlSqlParserREDEFINE = 1521 + PlSqlParserREDO = 1522 + PlSqlParserREDUCED = 1523 + PlSqlParserREDUNDANCY = 1524 + PlSqlParserREF_CASCADE_CURSOR = 1525 + PlSqlParserREFERENCED = 1526 + PlSqlParserREFERENCE = 1527 + PlSqlParserREFERENCES = 1528 + PlSqlParserREFERENCING = 1529 + PlSqlParserREF = 1530 + PlSqlParserREFRESH = 1531 + PlSqlParserREFTOHEX = 1532 + PlSqlParserREGEXP_COUNT = 1533 + PlSqlParserREGEXP_INSTR = 1534 + PlSqlParserREGEXP_LIKE = 1535 + PlSqlParserREGEXP_REPLACE = 1536 + PlSqlParserREGEXP_SUBSTR = 1537 + PlSqlParserREGISTER = 1538 + PlSqlParserREGR_AVGX = 1539 + PlSqlParserREGR_AVGY = 1540 + PlSqlParserREGR_COUNT = 1541 + PlSqlParserREGR_INTERCEPT = 1542 + PlSqlParserREGR_R2 = 1543 + PlSqlParserREGR_SLOPE = 1544 + PlSqlParserREGR_SXX = 1545 + PlSqlParserREGR_SXY = 1546 + PlSqlParserREGR_SYY = 1547 + PlSqlParserREGULAR = 1548 + PlSqlParserREJECT = 1549 + PlSqlParserREKEY = 1550 + PlSqlParserRELATIONAL = 1551 + PlSqlParserRELIES_ON = 1552 + PlSqlParserRELOCATE = 1553 + PlSqlParserRELY = 1554 + PlSqlParserREMAINDER = 1555 + PlSqlParserREMOTE = 1556 + PlSqlParserREMOTE_MAPPED = 1557 + PlSqlParserREMOVE = 1558 + PlSqlParserRENAME = 1559 + PlSqlParserREPAIR = 1560 + PlSqlParserREPEAT = 1561 + PlSqlParserREPLACE = 1562 + PlSqlParserREPLICATION = 1563 + PlSqlParserREQUIRED = 1564 + PlSqlParserRESETLOGS = 1565 + PlSqlParserRESET = 1566 + PlSqlParserRESIZE = 1567 + PlSqlParserRESOLVE = 1568 + PlSqlParserRESOLVER = 1569 + PlSqlParserRESOURCE = 1570 + PlSqlParserRESPECT = 1571 + PlSqlParserRESTART = 1572 + PlSqlParserRESTORE_AS_INTERVALS = 1573 + PlSqlParserRESTORE = 1574 + PlSqlParserRESTRICT_ALL_REF_CONS = 1575 + PlSqlParserRESTRICTED = 1576 + PlSqlParserRESTRICT_REFERENCES = 1577 + PlSqlParserRESTRICT = 1578 + PlSqlParserRESULT_CACHE = 1579 + PlSqlParserRESULT = 1580 + PlSqlParserRESUMABLE = 1581 + PlSqlParserRESUME = 1582 + PlSqlParserRETENTION = 1583 + PlSqlParserRETRY_ON_ROW_CHANGE = 1584 + PlSqlParserRETURNING = 1585 + PlSqlParserRETURN = 1586 + PlSqlParserREUSE = 1587 + PlSqlParserREVERSE = 1588 + PlSqlParserREVOKE = 1589 + PlSqlParserREWRITE_OR_ERROR = 1590 + PlSqlParserREWRITE = 1591 + PlSqlParserRIGHT = 1592 + PlSqlParserROLE = 1593 + PlSqlParserROLESET = 1594 + PlSqlParserROLES = 1595 + PlSqlParserROLLBACK = 1596 + PlSqlParserROLLING = 1597 + PlSqlParserROLLUP = 1598 + PlSqlParserROWDEPENDENCIES = 1599 + PlSqlParserROWID_MAPPING_TABLE = 1600 + PlSqlParserROWID = 1601 + PlSqlParserROWIDTOCHAR = 1602 + PlSqlParserROWIDTONCHAR = 1603 + PlSqlParserROW_LENGTH = 1604 + PlSqlParserROWNUM = 1605 + PlSqlParserROW = 1606 + PlSqlParserROWS = 1607 + PlSqlParserRPAD = 1608 + PlSqlParserRTRIM = 1609 + PlSqlParserRULE = 1610 + PlSqlParserRULES = 1611 + PlSqlParserRUNNING = 1612 + PlSqlParserSALT = 1613 + PlSqlParserSAMPLE = 1614 + PlSqlParserSAVE_AS_INTERVALS = 1615 + PlSqlParserSAVEPOINT = 1616 + PlSqlParserSAVE = 1617 + PlSqlParserSB4 = 1618 + PlSqlParserSCALE_ROWS = 1619 + PlSqlParserSCALE = 1620 + PlSqlParserSCAN_INSTANCES = 1621 + PlSqlParserSCAN = 1622 + PlSqlParserSCHEDULER = 1623 + PlSqlParserSCHEMACHECK = 1624 + PlSqlParserSCHEMA = 1625 + PlSqlParserSCN_ASCENDING = 1626 + PlSqlParserSCN = 1627 + PlSqlParserSCOPE = 1628 + PlSqlParserSCRUB = 1629 + PlSqlParserSD_ALL = 1630 + PlSqlParserSD_INHIBIT = 1631 + PlSqlParserSDO_GEOM_MBR = 1632 + PlSqlParserSDO_GEOMETRY = 1633 + PlSqlParserSD_SHOW = 1634 + PlSqlParserSEARCH = 1635 + PlSqlParserSECOND = 1636 + PlSqlParserSECONDS = 1637 + PlSqlParserSECRET = 1638 + PlSqlParserSECUREFILE_DBA = 1639 + PlSqlParserSECUREFILE = 1640 + PlSqlParserSECURITY = 1641 + PlSqlParserSEED = 1642 + PlSqlParserSEG_BLOCK = 1643 + PlSqlParserSEG_FILE = 1644 + PlSqlParserSEGMENT = 1645 + PlSqlParserSELECTIVITY = 1646 + PlSqlParserSELECT = 1647 + PlSqlParserSELF = 1648 + PlSqlParserSEMIJOIN_DRIVER = 1649 + PlSqlParserSEMIJOIN = 1650 + PlSqlParserSEMI_TO_INNER = 1651 + PlSqlParserSEQUENCED = 1652 + PlSqlParserSEQUENCE = 1653 + PlSqlParserSEQUENCEFILE = 1654 + PlSqlParserSEQUENTIAL = 1655 + PlSqlParserSEQ = 1656 + PlSqlParserSERDE = 1657 + PlSqlParserSERDEPROPERTIES = 1658 + PlSqlParserSERIALIZABLE = 1659 + PlSqlParserSERIALLY_REUSABLE = 1660 + PlSqlParserSERIAL = 1661 + PlSqlParserSERVERERROR = 1662 + PlSqlParserSERVICE_NAME_CONVERT = 1663 + PlSqlParserSERVICE = 1664 + PlSqlParserSERVICES = 1665 + PlSqlParserSESSION_CACHED_CURSORS = 1666 + PlSqlParserSESSION = 1667 + PlSqlParserSESSIONS_PER_USER = 1668 + PlSqlParserSESSIONTIMEZONE = 1669 + PlSqlParserSESSIONTZNAME = 1670 + PlSqlParserSET = 1671 + PlSqlParserSETS = 1672 + PlSqlParserSETTINGS = 1673 + PlSqlParserSET_TO_JOIN = 1674 + PlSqlParserSEVERE = 1675 + PlSqlParserSHARD = 1676 + PlSqlParserSHARDSPACE = 1677 + PlSqlParserSHARED_POOL = 1678 + PlSqlParserSHARED = 1679 + PlSqlParserSHARE = 1680 + PlSqlParserSHARING = 1681 + PlSqlParserSHELFLIFE = 1682 + PlSqlParserSHOW = 1683 + PlSqlParserSHRINK = 1684 + PlSqlParserSHUTDOWN = 1685 + PlSqlParserSIBLINGS = 1686 + PlSqlParserSID = 1687 + PlSqlParserSITE = 1688 + PlSqlParserSIGNAL_COMPONENT = 1689 + PlSqlParserSIGNAL_FUNCTION = 1690 + PlSqlParserSIGN = 1691 + PlSqlParserSIGNTYPE = 1692 + PlSqlParserSIMPLE_INTEGER = 1693 + PlSqlParserSIMPLE = 1694 + PlSqlParserSINGLE = 1695 + PlSqlParserSINGLETASK = 1696 + PlSqlParserSINH = 1697 + PlSqlParserSIN = 1698 + PlSqlParserSIZE = 1699 + PlSqlParserSIZES = 1700 + PlSqlParserSKIP_EXT_OPTIMIZER = 1701 + PlSqlParserSKIP_ = 1702 + PlSqlParserSKIP_UNQ_UNUSABLE_IDX = 1703 + PlSqlParserSKIP_UNUSABLE_INDEXES = 1704 + PlSqlParserSMALLFILE = 1705 + PlSqlParserSMALLINT = 1706 + PlSqlParserSNAPSHOT = 1707 + PlSqlParserSOME = 1708 + PlSqlParserSORT = 1709 + PlSqlParserSOUNDEX = 1710 + PlSqlParserSOURCE_FILE_DIRECTORY = 1711 + PlSqlParserSOURCE_FILE_NAME_CONVERT = 1712 + PlSqlParserSOURCE = 1713 + PlSqlParserSPACE_KEYWORD = 1714 + PlSqlParserSPECIFICATION = 1715 + PlSqlParserSPFILE = 1716 + PlSqlParserSPLIT = 1717 + PlSqlParserSPREADSHEET = 1718 + PlSqlParserSQLDATA = 1719 + PlSqlParserSQLERROR = 1720 + PlSqlParserSQLLDR = 1721 + PlSqlParserSQL = 1722 + PlSqlParserFILE_EXT = 1723 + PlSqlParserSQL_MACRO = 1724 + PlSqlParserSQL_TRACE = 1725 + PlSqlParserSQL_TRANSLATION_PROFILE = 1726 + PlSqlParserSQRT = 1727 + PlSqlParserSTALE = 1728 + PlSqlParserSTANDALONE = 1729 + PlSqlParserSTANDARD = 1730 + PlSqlParserSTANDARD_HASH = 1731 + PlSqlParserSTANDBY_MAX_DATA_DELAY = 1732 + PlSqlParserSTANDBYS = 1733 + PlSqlParserSTANDBY = 1734 + PlSqlParserSTAR = 1735 + PlSqlParserSTAR_TRANSFORMATION = 1736 + PlSqlParserSTART = 1737 + PlSqlParserSTARTOF = 1738 + PlSqlParserSTARTUP = 1739 + PlSqlParserSTATEMENT_ID = 1740 + PlSqlParserSTATEMENT_QUEUING = 1741 + PlSqlParserSTATEMENTS = 1742 + PlSqlParserSTATEMENT = 1743 + PlSqlParserSTATE = 1744 + PlSqlParserSTATIC = 1745 + PlSqlParserSTATISTICS = 1746 + PlSqlParserSTATS_BINOMIAL_TEST = 1747 + PlSqlParserSTATS_CROSSTAB = 1748 + PlSqlParserSTATS_F_TEST = 1749 + PlSqlParserSTATS_KS_TEST = 1750 + PlSqlParserSTATS_MODE = 1751 + PlSqlParserSTATS_MW_TEST = 1752 + PlSqlParserSTATS_ONE_WAY_ANOVA = 1753 + PlSqlParserSTATS_T_TEST_INDEP = 1754 + PlSqlParserSTATS_T_TEST_INDEPU = 1755 + PlSqlParserSTATS_T_TEST_ONE = 1756 + PlSqlParserSTATS_T_TEST_PAIRED = 1757 + PlSqlParserSTATS_WSR_TEST = 1758 + PlSqlParserSTDDEV_POP = 1759 + PlSqlParserSTDDEV_SAMP = 1760 + PlSqlParserSTOP = 1761 + PlSqlParserSTORAGE = 1762 + PlSqlParserSTORE = 1763 + PlSqlParserSTREAMS = 1764 + PlSqlParserSTREAM = 1765 + PlSqlParserSTRICT = 1766 + PlSqlParserSTRING = 1767 + PlSqlParserSTRIPE_COLUMNS = 1768 + PlSqlParserSTRIPE_WIDTH = 1769 + PlSqlParserSTRIP = 1770 + PlSqlParserSTRUCTURE = 1771 + PlSqlParserSUBMULTISET = 1772 + PlSqlParserSUBPARTITION_REL = 1773 + PlSqlParserSUBPARTITIONS = 1774 + PlSqlParserSUBPARTITION = 1775 + PlSqlParserSUBQUERIES = 1776 + PlSqlParserSUBQUERY_PRUNING = 1777 + PlSqlParserSUBSCRIBE = 1778 + PlSqlParserSUBSET = 1779 + PlSqlParserSUBSTITUTABLE = 1780 + PlSqlParserSUBSTR2 = 1781 + PlSqlParserSUBSTR4 = 1782 + PlSqlParserSUBSTRB = 1783 + PlSqlParserSUBSTRC = 1784 + PlSqlParserSUBTYPE = 1785 + PlSqlParserSUCCESSFUL = 1786 + PlSqlParserSUCCESS = 1787 + PlSqlParserSUMMARY = 1788 + PlSqlParserSUPPLEMENTAL = 1789 + PlSqlParserSUSPEND = 1790 + PlSqlParserSWAP_JOIN_INPUTS = 1791 + PlSqlParserSWITCHOVER = 1792 + PlSqlParserSWITCH = 1793 + PlSqlParserSYNCHRONOUS = 1794 + PlSqlParserSYNC = 1795 + PlSqlParserSYNONYM = 1796 + PlSqlParserSYS = 1797 + PlSqlParserSYSASM = 1798 + PlSqlParserSYS_AUDIT = 1799 + PlSqlParserSYSAUX = 1800 + PlSqlParserSYSBACKUP = 1801 + PlSqlParserSYS_CHECKACL = 1802 + PlSqlParserSYS_CHECK_PRIVILEGE = 1803 + PlSqlParserSYS_CONNECT_BY_PATH = 1804 + PlSqlParserSYS_CONTEXT = 1805 + PlSqlParserSYSDATE = 1806 + PlSqlParserSYSDBA = 1807 + PlSqlParserSYS_DBURIGEN = 1808 + PlSqlParserSYSDG = 1809 + PlSqlParserSYS_DL_CURSOR = 1810 + PlSqlParserSYS_DM_RXFORM_CHR = 1811 + PlSqlParserSYS_DM_RXFORM_NUM = 1812 + PlSqlParserSYS_DOM_COMPARE = 1813 + PlSqlParserSYS_DST_PRIM2SEC = 1814 + PlSqlParserSYS_DST_SEC2PRIM = 1815 + PlSqlParserSYS_ET_BFILE_TO_RAW = 1816 + PlSqlParserSYS_ET_BLOB_TO_IMAGE = 1817 + PlSqlParserSYS_ET_IMAGE_TO_BLOB = 1818 + PlSqlParserSYS_ET_RAW_TO_BFILE = 1819 + PlSqlParserSYS_EXTPDTXT = 1820 + PlSqlParserSYS_EXTRACT_UTC = 1821 + PlSqlParserSYS_FBT_INSDEL = 1822 + PlSqlParserSYS_FILTER_ACLS = 1823 + PlSqlParserSYS_FNMATCHES = 1824 + PlSqlParserSYS_FNREPLACE = 1825 + PlSqlParserSYS_GET_ACLIDS = 1826 + PlSqlParserSYS_GET_COL_ACLIDS = 1827 + PlSqlParserSYS_GET_PRIVILEGES = 1828 + PlSqlParserSYS_GETTOKENID = 1829 + PlSqlParserSYS_GETXTIVAL = 1830 + PlSqlParserSYS_GUID = 1831 + PlSqlParserSYSGUID = 1832 + PlSqlParserSYSKM = 1833 + PlSqlParserSYS_MAKE_XMLNODEID = 1834 + PlSqlParserSYS_MAKEXML = 1835 + PlSqlParserSYS_MKXMLATTR = 1836 + PlSqlParserSYS_MKXTI = 1837 + PlSqlParserSYSOBJ = 1838 + PlSqlParserSYS_OP_ADT2BIN = 1839 + PlSqlParserSYS_OP_ADTCONS = 1840 + PlSqlParserSYS_OP_ALSCRVAL = 1841 + PlSqlParserSYS_OP_ATG = 1842 + PlSqlParserSYS_OP_BIN2ADT = 1843 + PlSqlParserSYS_OP_BITVEC = 1844 + PlSqlParserSYS_OP_BL2R = 1845 + PlSqlParserSYS_OP_BLOOM_FILTER_LIST = 1846 + PlSqlParserSYS_OP_BLOOM_FILTER = 1847 + PlSqlParserSYS_OP_C2C = 1848 + PlSqlParserSYS_OP_CAST = 1849 + PlSqlParserSYS_OP_CEG = 1850 + PlSqlParserSYS_OP_CL2C = 1851 + PlSqlParserSYS_OP_COMBINED_HASH = 1852 + PlSqlParserSYS_OP_COMP = 1853 + PlSqlParserSYS_OP_CONVERT = 1854 + PlSqlParserSYS_OP_COUNTCHG = 1855 + PlSqlParserSYS_OP_CSCONV = 1856 + PlSqlParserSYS_OP_CSCONVTEST = 1857 + PlSqlParserSYS_OP_CSR = 1858 + PlSqlParserSYS_OP_CSX_PATCH = 1859 + PlSqlParserSYS_OP_CYCLED_SEQ = 1860 + PlSqlParserSYS_OP_DECOMP = 1861 + PlSqlParserSYS_OP_DESCEND = 1862 + PlSqlParserSYS_OP_DISTINCT = 1863 + PlSqlParserSYS_OP_DRA = 1864 + PlSqlParserSYS_OP_DUMP = 1865 + PlSqlParserSYS_OP_DV_CHECK = 1866 + PlSqlParserSYS_OP_ENFORCE_NOT_NULL = 1867 + PlSqlParserSYSOPER = 1868 + PlSqlParserSYS_OP_EXTRACT = 1869 + PlSqlParserSYS_OP_GROUPING = 1870 + PlSqlParserSYS_OP_GUID = 1871 + PlSqlParserSYS_OP_HASH = 1872 + PlSqlParserSYS_OP_IIX = 1873 + PlSqlParserSYS_OP_ITR = 1874 + PlSqlParserSYS_OP_KEY_VECTOR_CREATE = 1875 + PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST = 1876 + PlSqlParserSYS_OP_KEY_VECTOR_FILTER = 1877 + PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED = 1878 + PlSqlParserSYS_OP_KEY_VECTOR_USE = 1879 + PlSqlParserSYS_OP_LBID = 1880 + PlSqlParserSYS_OP_LOBLOC2BLOB = 1881 + PlSqlParserSYS_OP_LOBLOC2CLOB = 1882 + PlSqlParserSYS_OP_LOBLOC2ID = 1883 + PlSqlParserSYS_OP_LOBLOC2NCLOB = 1884 + PlSqlParserSYS_OP_LOBLOC2TYP = 1885 + PlSqlParserSYS_OP_LSVI = 1886 + PlSqlParserSYS_OP_LVL = 1887 + PlSqlParserSYS_OP_MAKEOID = 1888 + PlSqlParserSYS_OP_MAP_NONNULL = 1889 + PlSqlParserSYS_OP_MSR = 1890 + PlSqlParserSYS_OP_NICOMBINE = 1891 + PlSqlParserSYS_OP_NIEXTRACT = 1892 + PlSqlParserSYS_OP_NII = 1893 + PlSqlParserSYS_OP_NIX = 1894 + PlSqlParserSYS_OP_NOEXPAND = 1895 + PlSqlParserSYS_OP_NTCIMG = 1896 + PlSqlParserSYS_OP_NUMTORAW = 1897 + PlSqlParserSYS_OP_OIDVALUE = 1898 + PlSqlParserSYS_OP_OPNSIZE = 1899 + PlSqlParserSYS_OP_PAR_1 = 1900 + PlSqlParserSYS_OP_PARGID_1 = 1901 + PlSqlParserSYS_OP_PARGID = 1902 + PlSqlParserSYS_OP_PAR = 1903 + PlSqlParserSYS_OP_PART_ID = 1904 + PlSqlParserSYS_OP_PIVOT = 1905 + PlSqlParserSYS_OP_R2O = 1906 + PlSqlParserSYS_OP_RAWTONUM = 1907 + PlSqlParserSYS_OP_RDTM = 1908 + PlSqlParserSYS_OP_REF = 1909 + PlSqlParserSYS_OP_RMTD = 1910 + PlSqlParserSYS_OP_ROWIDTOOBJ = 1911 + PlSqlParserSYS_OP_RPB = 1912 + PlSqlParserSYS_OPTLOBPRBSC = 1913 + PlSqlParserSYS_OP_TOSETID = 1914 + PlSqlParserSYS_OP_TPR = 1915 + PlSqlParserSYS_OP_TRTB = 1916 + PlSqlParserSYS_OPTXICMP = 1917 + PlSqlParserSYS_OPTXQCASTASNQ = 1918 + PlSqlParserSYS_OP_UNDESCEND = 1919 + PlSqlParserSYS_OP_VECAND = 1920 + PlSqlParserSYS_OP_VECBIT = 1921 + PlSqlParserSYS_OP_VECOR = 1922 + PlSqlParserSYS_OP_VECXOR = 1923 + PlSqlParserSYS_OP_VERSION = 1924 + PlSqlParserSYS_OP_VREF = 1925 + PlSqlParserSYS_OP_VVD = 1926 + PlSqlParserSYS_OP_XMLCONS_FOR_CSX = 1927 + PlSqlParserSYS_OP_XPTHATG = 1928 + PlSqlParserSYS_OP_XPTHIDX = 1929 + PlSqlParserSYS_OP_XPTHOP = 1930 + PlSqlParserSYS_OP_XTXT2SQLT = 1931 + PlSqlParserSYS_OP_ZONE_ID = 1932 + PlSqlParserSYS_ORDERKEY_DEPTH = 1933 + PlSqlParserSYS_ORDERKEY_MAXCHILD = 1934 + PlSqlParserSYS_ORDERKEY_PARENT = 1935 + PlSqlParserSYS_PARALLEL_TXN = 1936 + PlSqlParserSYS_PATHID_IS_ATTR = 1937 + PlSqlParserSYS_PATHID_IS_NMSPC = 1938 + PlSqlParserSYS_PATHID_LASTNAME = 1939 + PlSqlParserSYS_PATHID_LASTNMSPC = 1940 + PlSqlParserSYS_PATH_REVERSE = 1941 + PlSqlParserSYS_PXQEXTRACT = 1942 + PlSqlParserSYS_RAW_TO_XSID = 1943 + PlSqlParserSYS_RID_ORDER = 1944 + PlSqlParserSYS_ROW_DELTA = 1945 + PlSqlParserSYS_SC_2_XMLT = 1946 + PlSqlParserSYS_SYNRCIREDO = 1947 + PlSqlParserSYSTEM_DEFINED = 1948 + PlSqlParserSYSTEM = 1949 + PlSqlParserSYSTIMESTAMP = 1950 + PlSqlParserSYS_TYPEID = 1951 + PlSqlParserSYS_UMAKEXML = 1952 + PlSqlParserSYS_XMLANALYZE = 1953 + PlSqlParserSYS_XMLCONTAINS = 1954 + PlSqlParserSYS_XMLCONV = 1955 + PlSqlParserSYS_XMLEXNSURI = 1956 + PlSqlParserSYS_XMLGEN = 1957 + PlSqlParserSYS_XMLI_LOC_ISNODE = 1958 + PlSqlParserSYS_XMLI_LOC_ISTEXT = 1959 + PlSqlParserSYS_XMLINSTR = 1960 + PlSqlParserSYS_XMLLOCATOR_GETSVAL = 1961 + PlSqlParserSYS_XMLNODEID_GETCID = 1962 + PlSqlParserSYS_XMLNODEID_GETLOCATOR = 1963 + PlSqlParserSYS_XMLNODEID_GETOKEY = 1964 + PlSqlParserSYS_XMLNODEID_GETPATHID = 1965 + PlSqlParserSYS_XMLNODEID_GETPTRID = 1966 + PlSqlParserSYS_XMLNODEID_GETRID = 1967 + PlSqlParserSYS_XMLNODEID_GETSVAL = 1968 + PlSqlParserSYS_XMLNODEID_GETTID = 1969 + PlSqlParserSYS_XMLNODEID = 1970 + PlSqlParserSYS_XMLT_2_SC = 1971 + PlSqlParserSYS_XMLTRANSLATE = 1972 + PlSqlParserSYS_XMLTYPE2SQL = 1973 + PlSqlParserSYS_XQ_ASQLCNV = 1974 + PlSqlParserSYS_XQ_ATOMCNVCHK = 1975 + PlSqlParserSYS_XQBASEURI = 1976 + PlSqlParserSYS_XQCASTABLEERRH = 1977 + PlSqlParserSYS_XQCODEP2STR = 1978 + PlSqlParserSYS_XQCODEPEQ = 1979 + PlSqlParserSYS_XQCON2SEQ = 1980 + PlSqlParserSYS_XQCONCAT = 1981 + PlSqlParserSYS_XQDELETE = 1982 + PlSqlParserSYS_XQDFLTCOLATION = 1983 + PlSqlParserSYS_XQDOC = 1984 + PlSqlParserSYS_XQDOCURI = 1985 + PlSqlParserSYS_XQDURDIV = 1986 + PlSqlParserSYS_XQED4URI = 1987 + PlSqlParserSYS_XQENDSWITH = 1988 + PlSqlParserSYS_XQERRH = 1989 + PlSqlParserSYS_XQERR = 1990 + PlSqlParserSYS_XQESHTMLURI = 1991 + PlSqlParserSYS_XQEXLOBVAL = 1992 + PlSqlParserSYS_XQEXSTWRP = 1993 + PlSqlParserSYS_XQEXTRACT = 1994 + PlSqlParserSYS_XQEXTRREF = 1995 + PlSqlParserSYS_XQEXVAL = 1996 + PlSqlParserSYS_XQFB2STR = 1997 + PlSqlParserSYS_XQFNBOOL = 1998 + PlSqlParserSYS_XQFNCMP = 1999 + PlSqlParserSYS_XQFNDATIM = 2000 + PlSqlParserSYS_XQFNLNAME = 2001 + PlSqlParserSYS_XQFNNM = 2002 + PlSqlParserSYS_XQFNNSURI = 2003 + PlSqlParserSYS_XQFNPREDTRUTH = 2004 + PlSqlParserSYS_XQFNQNM = 2005 + PlSqlParserSYS_XQFNROOT = 2006 + PlSqlParserSYS_XQFORMATNUM = 2007 + PlSqlParserSYS_XQFTCONTAIN = 2008 + PlSqlParserSYS_XQFUNCR = 2009 + PlSqlParserSYS_XQGETCONTENT = 2010 + PlSqlParserSYS_XQINDXOF = 2011 + PlSqlParserSYS_XQINSERT = 2012 + PlSqlParserSYS_XQINSPFX = 2013 + PlSqlParserSYS_XQIRI2URI = 2014 + PlSqlParserSYS_XQLANG = 2015 + PlSqlParserSYS_XQLLNMFRMQNM = 2016 + PlSqlParserSYS_XQMKNODEREF = 2017 + PlSqlParserSYS_XQNILLED = 2018 + PlSqlParserSYS_XQNODENAME = 2019 + PlSqlParserSYS_XQNORMSPACE = 2020 + PlSqlParserSYS_XQNORMUCODE = 2021 + PlSqlParserSYS_XQ_NRNG = 2022 + PlSqlParserSYS_XQNSP4PFX = 2023 + PlSqlParserSYS_XQNSPFRMQNM = 2024 + PlSqlParserSYS_XQPFXFRMQNM = 2025 + PlSqlParserSYS_XQ_PKSQL2XML = 2026 + PlSqlParserSYS_XQPOLYABS = 2027 + PlSqlParserSYS_XQPOLYADD = 2028 + PlSqlParserSYS_XQPOLYCEL = 2029 + PlSqlParserSYS_XQPOLYCSTBL = 2030 + PlSqlParserSYS_XQPOLYCST = 2031 + PlSqlParserSYS_XQPOLYDIV = 2032 + PlSqlParserSYS_XQPOLYFLR = 2033 + PlSqlParserSYS_XQPOLYMOD = 2034 + PlSqlParserSYS_XQPOLYMUL = 2035 + PlSqlParserSYS_XQPOLYRND = 2036 + PlSqlParserSYS_XQPOLYSQRT = 2037 + PlSqlParserSYS_XQPOLYSUB = 2038 + PlSqlParserSYS_XQPOLYUMUS = 2039 + PlSqlParserSYS_XQPOLYUPLS = 2040 + PlSqlParserSYS_XQPOLYVEQ = 2041 + PlSqlParserSYS_XQPOLYVGE = 2042 + PlSqlParserSYS_XQPOLYVGT = 2043 + PlSqlParserSYS_XQPOLYVLE = 2044 + PlSqlParserSYS_XQPOLYVLT = 2045 + PlSqlParserSYS_XQPOLYVNE = 2046 + PlSqlParserSYS_XQREF2VAL = 2047 + PlSqlParserSYS_XQRENAME = 2048 + PlSqlParserSYS_XQREPLACE = 2049 + PlSqlParserSYS_XQRESVURI = 2050 + PlSqlParserSYS_XQRNDHALF2EVN = 2051 + PlSqlParserSYS_XQRSLVQNM = 2052 + PlSqlParserSYS_XQRYENVPGET = 2053 + PlSqlParserSYS_XQRYVARGET = 2054 + PlSqlParserSYS_XQRYWRP = 2055 + PlSqlParserSYS_XQSEQ2CON4XC = 2056 + PlSqlParserSYS_XQSEQ2CON = 2057 + PlSqlParserSYS_XQSEQDEEPEQ = 2058 + PlSqlParserSYS_XQSEQINSB = 2059 + PlSqlParserSYS_XQSEQRM = 2060 + PlSqlParserSYS_XQSEQRVS = 2061 + PlSqlParserSYS_XQSEQSUB = 2062 + PlSqlParserSYS_XQSEQTYPMATCH = 2063 + PlSqlParserSYS_XQSTARTSWITH = 2064 + PlSqlParserSYS_XQSTATBURI = 2065 + PlSqlParserSYS_XQSTR2CODEP = 2066 + PlSqlParserSYS_XQSTRJOIN = 2067 + PlSqlParserSYS_XQSUBSTRAFT = 2068 + PlSqlParserSYS_XQSUBSTRBEF = 2069 + PlSqlParserSYS_XQTOKENIZE = 2070 + PlSqlParserSYS_XQTREATAS = 2071 + PlSqlParserSYS_XQ_UPKXML2SQL = 2072 + PlSqlParserSYS_XQXFORM = 2073 + PlSqlParserSYS_XSID_TO_RAW = 2074 + PlSqlParserSYS_ZMAP_FILTER = 2075 + PlSqlParserSYS_ZMAP_REFRESH = 2076 + PlSqlParserT_LETTER = 2077 + PlSqlParserTABLE_LOOKUP_BY_NL = 2078 + PlSqlParserTABLESPACE_NO = 2079 + PlSqlParserTABLESPACE = 2080 + PlSqlParserTABLES = 2081 + PlSqlParserTABLE_STATS = 2082 + PlSqlParserTABLE = 2083 + PlSqlParserTABNO = 2084 + PlSqlParserTAG = 2085 + PlSqlParserTANH = 2086 + PlSqlParserTAN = 2087 + PlSqlParserTBLORIDXPARTNUM = 2088 + PlSqlParserTEMPFILE = 2089 + PlSqlParserTEMPLATE = 2090 + PlSqlParserTEMPLATE_TABLE = 2091 + PlSqlParserTEMPORARY = 2092 + PlSqlParserTEMP_TABLE = 2093 + PlSqlParserTERMINATED = 2094 + PlSqlParserTEST = 2095 + PlSqlParserTEXT = 2096 + PlSqlParserTEXTFILE = 2097 + PlSqlParserTHAN = 2098 + PlSqlParserTHEN = 2099 + PlSqlParserTHE = 2100 + PlSqlParserTHESE = 2101 + PlSqlParserTHREAD = 2102 + PlSqlParserTHROUGH = 2103 + PlSqlParserTIER = 2104 + PlSqlParserTIES = 2105 + PlSqlParserTIMEOUT = 2106 + PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED = 2107 + PlSqlParserTIMESTAMP = 2108 + PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED = 2109 + PlSqlParserTIMESTAMP_UNCONSTRAINED = 2110 + PlSqlParserTIMES = 2111 + PlSqlParserTIME = 2112 + PlSqlParserTIMEZONE = 2113 + PlSqlParserTIMEZONE_ABBR = 2114 + PlSqlParserTIMEZONE_HOUR = 2115 + PlSqlParserTIMEZONE_MINUTE = 2116 + PlSqlParserTIMEZONE_OFFSET = 2117 + PlSqlParserTIMEZONE_REGION = 2118 + PlSqlParserTIME_ZONE = 2119 + PlSqlParserTIMING = 2120 + PlSqlParserTINYINT = 2121 + PlSqlParserTIV_GB = 2122 + PlSqlParserTIV_SSF = 2123 + PlSqlParserTO_ACLID = 2124 + PlSqlParserTO_BINARY_DOUBLE = 2125 + PlSqlParserTO_BINARY_FLOAT = 2126 + PlSqlParserTO_BLOB = 2127 + PlSqlParserTO_CLOB = 2128 + PlSqlParserTO_DSINTERVAL = 2129 + PlSqlParserTO_LOB = 2130 + PlSqlParserTO_MULTI_BYTE = 2131 + PlSqlParserTO_NCHAR = 2132 + PlSqlParserTO_NCLOB = 2133 + PlSqlParserTO_NUMBER = 2134 + PlSqlParserTOPLEVEL = 2135 + PlSqlParserTO_SINGLE_BYTE = 2136 + PlSqlParserTO_TIMESTAMP = 2137 + PlSqlParserTO_TIMESTAMP_TZ = 2138 + PlSqlParserTO_TIME = 2139 + PlSqlParserTO_TIME_TZ = 2140 + PlSqlParserTO = 2141 + PlSqlParserTO_YMINTERVAL = 2142 + PlSqlParserTRACE = 2143 + PlSqlParserTRACING = 2144 + PlSqlParserTRACKING = 2145 + PlSqlParserTRAILING = 2146 + PlSqlParserTRANSACTION = 2147 + PlSqlParserTRANSFORM = 2148 + PlSqlParserTRANSFORMS = 2149 + PlSqlParserTRANSFORM_DISTINCT_AGG = 2150 + PlSqlParserTRANSITIONAL = 2151 + PlSqlParserTRANSITION = 2152 + PlSqlParserTRANSLATE = 2153 + PlSqlParserTRANSLATION = 2154 + PlSqlParserTREAT = 2155 + PlSqlParserTRIGGERS = 2156 + PlSqlParserTRIGGER = 2157 + PlSqlParserTRUE = 2158 + PlSqlParserTRUNCATE = 2159 + PlSqlParserTRUNC = 2160 + PlSqlParserTRUSTED = 2161 + PlSqlParserTRUST = 2162 + PlSqlParserTUNING = 2163 + PlSqlParserTX = 2164 + PlSqlParserTYPES = 2165 + PlSqlParserTYPE = 2166 + PlSqlParserTZ_OFFSET = 2167 + PlSqlParserUB2 = 2168 + PlSqlParserUBA = 2169 + PlSqlParserUCS2 = 2170 + PlSqlParserUDF = 2171 + PlSqlParserUID = 2172 + PlSqlParserUNARCHIVED = 2173 + PlSqlParserUNBOUNDED = 2174 + PlSqlParserUNBOUND = 2175 + PlSqlParserUNCONDITIONAL = 2176 + PlSqlParserUNDER = 2177 + PlSqlParserUNDO = 2178 + PlSqlParserUNDROP = 2179 + PlSqlParserUNIFORM = 2180 + PlSqlParserUNION = 2181 + PlSqlParserUNIONTYPE = 2182 + PlSqlParserUNIQUE = 2183 + PlSqlParserUNISTR = 2184 + PlSqlParserUNLIMITED = 2185 + PlSqlParserUNLOAD = 2186 + PlSqlParserUNLOCK = 2187 + PlSqlParserUNMATCHED = 2188 + PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW = 2189 + PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW = 2190 + PlSqlParserUNNEST_SEMIJ_VIEW = 2191 + PlSqlParserUNNEST = 2192 + PlSqlParserUNPACKED = 2193 + PlSqlParserUNPIVOT = 2194 + PlSqlParserUNPLUG = 2195 + PlSqlParserUNPROTECTED = 2196 + PlSqlParserUNQUIESCE = 2197 + PlSqlParserUNRECOVERABLE = 2198 + PlSqlParserUNRESTRICTED = 2199 + PlSqlParserUNSIGNED = 2200 + PlSqlParserUNSUBSCRIBE = 2201 + PlSqlParserUNTIL = 2202 + PlSqlParserUNUSABLE = 2203 + PlSqlParserUNUSED = 2204 + PlSqlParserUPDATABLE = 2205 + PlSqlParserUPDATED = 2206 + PlSqlParserUPDATE = 2207 + PlSqlParserUPDATEXML = 2208 + PlSqlParserUPD_INDEXES = 2209 + PlSqlParserUPD_JOININDEX = 2210 + PlSqlParserUPGRADE = 2211 + PlSqlParserUPPER = 2212 + PlSqlParserUPSERT = 2213 + PlSqlParserUROWID = 2214 + PlSqlParserUSABLE = 2215 + PlSqlParserUSAGE = 2216 + PlSqlParserUSE_ANTI = 2217 + PlSqlParserUSE_CONCAT = 2218 + PlSqlParserUSE_CUBE = 2219 + PlSqlParserUSE_HASH_AGGREGATION = 2220 + PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN = 2221 + PlSqlParserUSE_HASH = 2222 + PlSqlParserUSE_HIDDEN_PARTITIONS = 2223 + PlSqlParserUSE_INVISIBLE_INDEXES = 2224 + PlSqlParserUSE_MERGE_CARTESIAN = 2225 + PlSqlParserUSE_MERGE = 2226 + PlSqlParserUSE_NL = 2227 + PlSqlParserUSE_NL_WITH_INDEX = 2228 + PlSqlParserUSE_PRIVATE_OUTLINES = 2229 + PlSqlParserUSER_DATA = 2230 + PlSqlParserUSER_DEFINED = 2231 + PlSqlParserUSERENV = 2232 + PlSqlParserUSERGROUP = 2233 + PlSqlParserUSER_RECYCLEBIN = 2234 + PlSqlParserUSERS = 2235 + PlSqlParserUSER_TABLESPACES = 2236 + PlSqlParserUSER = 2237 + PlSqlParserUSE_SEMI = 2238 + PlSqlParserUSE_STORED_OUTLINES = 2239 + PlSqlParserUSE_TTT_FOR_GSETS = 2240 + PlSqlParserUSE = 2241 + PlSqlParserUSE_VECTOR_AGGREGATION = 2242 + PlSqlParserUSE_WEAK_NAME_RESL = 2243 + PlSqlParserUSING_NO_EXPAND = 2244 + PlSqlParserUSING_NLS_COMP = 2245 + PlSqlParserUSING = 2246 + PlSqlParserUTF16BE = 2247 + PlSqlParserUTF16LE = 2248 + PlSqlParserUTF32 = 2249 + PlSqlParserUTF8 = 2250 + PlSqlParserV1 = 2251 + PlSqlParserV2 = 2252 + PlSqlParserVALIDATE = 2253 + PlSqlParserVALIDATE_CONVERSION = 2254 + PlSqlParserVALIDATION = 2255 + PlSqlParserVALID_TIME_END = 2256 + PlSqlParserVALUES = 2257 + PlSqlParserVALUE = 2258 + PlSqlParserVARCHAR2 = 2259 + PlSqlParserVARCHAR = 2260 + PlSqlParserVARCHARC = 2261 + PlSqlParserVARIABLE = 2262 + PlSqlParserVARRAW = 2263 + PlSqlParserVARRAWC = 2264 + PlSqlParserVAR_POP = 2265 + PlSqlParserVARRAYS = 2266 + PlSqlParserVARRAY = 2267 + PlSqlParserVAR_SAMP = 2268 + PlSqlParserVARYING = 2269 + PlSqlParserVECTOR_READ_TRACE = 2270 + PlSqlParserVECTOR_READ = 2271 + PlSqlParserVECTOR_TRANSFORM_DIMS = 2272 + PlSqlParserVECTOR_TRANSFORM_FACT = 2273 + PlSqlParserVECTOR_TRANSFORM = 2274 + PlSqlParserVERIFIER = 2275 + PlSqlParserVERIFY = 2276 + PlSqlParserVERSIONING = 2277 + PlSqlParserVERSIONS_ENDSCN = 2278 + PlSqlParserVERSIONS_ENDTIME = 2279 + PlSqlParserVERSIONS_OPERATION = 2280 + PlSqlParserVERSIONS_STARTSCN = 2281 + PlSqlParserVERSIONS_STARTTIME = 2282 + PlSqlParserVERSIONS = 2283 + PlSqlParserVERSIONS_XID = 2284 + PlSqlParserVERSION = 2285 + PlSqlParserVIEW = 2286 + PlSqlParserVIOLATION = 2287 + PlSqlParserVIRTUAL = 2288 + PlSqlParserVISIBILITY = 2289 + PlSqlParserVISIBLE = 2290 + PlSqlParserVOLUME = 2291 + PlSqlParserVSIZE = 2292 + PlSqlParserWAIT = 2293 + PlSqlParserWALLET = 2294 + PlSqlParserWARNING = 2295 + PlSqlParserWEEKS = 2296 + PlSqlParserWEEK = 2297 + PlSqlParserWELLFORMED = 2298 + PlSqlParserWHENEVER = 2299 + PlSqlParserWHEN = 2300 + PlSqlParserWHERE = 2301 + PlSqlParserWHILE = 2302 + PlSqlParserWHITESPACE = 2303 + PlSqlParserWIDTH_BUCKET = 2304 + PlSqlParserWITHIN = 2305 + PlSqlParserWITHOUT = 2306 + PlSqlParserWITH_PLSQL = 2307 + PlSqlParserWITH = 2308 + PlSqlParserWORK = 2309 + PlSqlParserWORKERID = 2310 + PlSqlParserWRAPPED = 2311 + PlSqlParserWRAPPER = 2312 + PlSqlParserWRITE = 2313 + PlSqlParserXDB_FASTPATH_INSERT = 2314 + PlSqlParserXDB = 2315 + PlSqlParserX_DYN_PRUNE = 2316 + PlSqlParserXID = 2317 + PlSqlParserXML2OBJECT = 2318 + PlSqlParserXMLAGG = 2319 + PlSqlParserXMLATTRIBUTES = 2320 + PlSqlParserXMLCAST = 2321 + PlSqlParserXMLCDATA = 2322 + PlSqlParserXMLCOLATTVAL = 2323 + PlSqlParserXMLCOMMENT = 2324 + PlSqlParserXMLCONCAT = 2325 + PlSqlParserXMLDIFF = 2326 + PlSqlParserXML_DML_RWT_STMT = 2327 + PlSqlParserXMLELEMENT = 2328 + PlSqlParserXMLEXISTS2 = 2329 + PlSqlParserXMLEXISTS = 2330 + PlSqlParserXMLFOREST = 2331 + PlSqlParserXMLINDEX = 2332 + PlSqlParserXMLINDEX_REWRITE_IN_SELECT = 2333 + PlSqlParserXMLINDEX_REWRITE = 2334 + PlSqlParserXMLINDEX_SEL_IDX_TBL = 2335 + PlSqlParserXMLISNODE = 2336 + PlSqlParserXMLISVALID = 2337 + PlSqlParserXMLNAMESPACES = 2338 + PlSqlParserXMLPARSE = 2339 + PlSqlParserXMLPATCH = 2340 + PlSqlParserXMLPI = 2341 + PlSqlParserXMLQUERYVAL = 2342 + PlSqlParserXMLQUERY = 2343 + PlSqlParserXMLROOT = 2344 + PlSqlParserXMLSCHEMA = 2345 + PlSqlParserXMLSERIALIZE = 2346 + PlSqlParserXMLTABLE = 2347 + PlSqlParserXMLTAG = 2348 + PlSqlParserXMLTRANSFORMBLOB = 2349 + PlSqlParserXMLTRANSFORM = 2350 + PlSqlParserXMLTYPE = 2351 + PlSqlParserXML = 2352 + PlSqlParserXPATHTABLE = 2353 + PlSqlParserXS_SYS_CONTEXT = 2354 + PlSqlParserXS = 2355 + PlSqlParserXTRANSPORT = 2356 + PlSqlParserYEARS = 2357 + PlSqlParserYEAR = 2358 + PlSqlParserYEAR_TO_MONTH = 2359 + PlSqlParserYES = 2360 + PlSqlParserYMINTERVAL_UNCONSTRAINED = 2361 + PlSqlParserZONEMAP = 2362 + PlSqlParserZONE = 2363 + PlSqlParserZONED = 2364 + PlSqlParserPREDICTION = 2365 + PlSqlParserPREDICTION_BOUNDS = 2366 + PlSqlParserPREDICTION_COST = 2367 + PlSqlParserPREDICTION_DETAILS = 2368 + PlSqlParserPREDICTION_PROBABILITY = 2369 + PlSqlParserPREDICTION_SET = 2370 + PlSqlParserBLOCKCHAIN = 2371 + PlSqlParserCOLLATE = 2372 + PlSqlParserCOLLATION = 2373 + PlSqlParserDEFINITION = 2374 + PlSqlParserDUPLICATED = 2375 + PlSqlParserEXTENDED = 2376 + PlSqlParserHASHING = 2377 + PlSqlParserIDLE = 2378 + PlSqlParserIMMUTABLE = 2379 + PlSqlParserORACLE_DATAPUMP = 2380 + PlSqlParserORACLE_HDFS = 2381 + PlSqlParserORACLE_HIVE = 2382 + PlSqlParserORACLE_LOADER = 2383 + PlSqlParserSHA2_512_Q = 2384 + PlSqlParserSHARDED = 2385 + PlSqlParserV1_Q = 2386 + PlSqlParserISOLATE = 2387 + PlSqlParserROOT = 2388 + PlSqlParserUNITE = 2389 + PlSqlParserALGORITHM = 2390 + PlSqlParserCUME_DIST = 2391 + PlSqlParserDENSE_RANK = 2392 + PlSqlParserLISTAGG = 2393 + PlSqlParserPERCENT_RANK = 2394 + PlSqlParserPERCENTILE_CONT = 2395 + PlSqlParserPERCENTILE_DISC = 2396 + PlSqlParserRANK = 2397 + PlSqlParserAVG = 2398 + PlSqlParserCORR = 2399 + PlSqlParserCOVAR_ = 2400 + PlSqlParserDECODE = 2401 + PlSqlParserLAG = 2402 + PlSqlParserLAG_DIFF = 2403 + PlSqlParserLAG_DIFF_PERCENT = 2404 + PlSqlParserLEAD = 2405 + PlSqlParserMAX = 2406 + PlSqlParserMEDIAN = 2407 + PlSqlParserMEMOPTIMIZE = 2408 + PlSqlParserMIN = 2409 + PlSqlParserNTILE = 2410 + PlSqlParserNVL = 2411 + PlSqlParserRATIO_TO_REPORT = 2412 + PlSqlParserREGR_ = 2413 + PlSqlParserROUND = 2414 + PlSqlParserROW_NUMBER = 2415 + PlSqlParserSUBSTR = 2416 + PlSqlParserTO_CHAR = 2417 + PlSqlParserTRIM = 2418 + PlSqlParserSUM = 2419 + PlSqlParserSTDDEV = 2420 + PlSqlParserVAR_ = 2421 + PlSqlParserVARIANCE = 2422 + PlSqlParserLEAST = 2423 + PlSqlParserGREATEST = 2424 + PlSqlParserTO_DATE = 2425 + PlSqlParserCHARSETID = 2426 + PlSqlParserCHARSETFORM = 2427 + PlSqlParserDURATION = 2428 + PlSqlParserEXTEND = 2429 + PlSqlParserMAXLEN = 2430 + PlSqlParserPERSISTABLE = 2431 + PlSqlParserPOLYMORPHIC = 2432 + PlSqlParserSTRUCT = 2433 + PlSqlParserTDO = 2434 + PlSqlParserWM_CONCAT = 2435 + PlSqlParserNATIONAL_CHAR_STRING_LIT = 2436 + PlSqlParserBIT_STRING_LIT = 2437 + PlSqlParserHEX_STRING_LIT = 2438 + PlSqlParserDOUBLE_PERIOD = 2439 + PlSqlParserPERIOD = 2440 + PlSqlParserUNSIGNED_INTEGER = 2441 + PlSqlParserAPPROXIMATE_NUM_LIT = 2442 + PlSqlParserCHAR_STRING = 2443 + PlSqlParserDELIMITED_ID = 2444 + PlSqlParserPERCENT = 2445 + PlSqlParserAMPERSAND = 2446 + PlSqlParserLEFT_PAREN = 2447 + PlSqlParserRIGHT_PAREN = 2448 + PlSqlParserDOUBLE_ASTERISK = 2449 + PlSqlParserASTERISK = 2450 + PlSqlParserPLUS_SIGN = 2451 + PlSqlParserMINUS_SIGN = 2452 + PlSqlParserCOMMA = 2453 + PlSqlParserSOLIDUS = 2454 + PlSqlParserRSOLIDUS = 2455 + PlSqlParserAT_SIGN = 2456 + PlSqlParserASSIGN_OP = 2457 + PlSqlParserHASH_OP = 2458 + PlSqlParserLEFT_CURLY_PAREN = 2459 + PlSqlParserRIGHT_CURLY_PAREN = 2460 + PlSqlParserSQ = 2461 + PlSqlParserBINDVAR = 2462 + PlSqlParserNOT_EQUAL_OP = 2463 + PlSqlParserCARRET_OPERATOR_PART = 2464 + PlSqlParserTILDE_OPERATOR_PART = 2465 + PlSqlParserEXCLAMATION_OPERATOR_PART = 2466 + PlSqlParserGREATER_THAN_OP = 2467 + PlSqlParserLESS_THAN_OP = 2468 + PlSqlParserCOLON = 2469 + PlSqlParserSEMICOLON = 2470 + PlSqlParserBAR = 2471 + PlSqlParserEQUALS_OP = 2472 + PlSqlParserLEFT_BRACKET = 2473 + PlSqlParserRIGHT_BRACKET = 2474 + PlSqlParserINTRODUCER = 2475 + PlSqlParserSINGLE_LINE_COMMENT = 2476 + PlSqlParserMULTI_LINE_COMMENT = 2477 + PlSqlParserREMARK_COMMENT = 2478 + PlSqlParserPROMPT_MESSAGE = 2479 + PlSqlParserREGULAR_ID = 2480 + PlSqlParserINQUIRY_DIRECTIVE = 2481 + PlSqlParserSPACES = 2482 +) + +// PlSqlParser rules. +const ( + PlSqlParserRULE_sql_script = 0 + PlSqlParserRULE_unit_statement = 1 + PlSqlParserRULE_alter_diskgroup = 2 + PlSqlParserRULE_add_disk_clause = 3 + PlSqlParserRULE_drop_disk_clause = 4 + PlSqlParserRULE_resize_disk_clause = 5 + PlSqlParserRULE_replace_disk_clause = 6 + PlSqlParserRULE_wait_nowait = 7 + PlSqlParserRULE_rename_disk_clause = 8 + PlSqlParserRULE_disk_online_clause = 9 + PlSqlParserRULE_disk_offline_clause = 10 + PlSqlParserRULE_timeout_clause = 11 + PlSqlParserRULE_rebalance_diskgroup_clause = 12 + PlSqlParserRULE_phase = 13 + PlSqlParserRULE_check_diskgroup_clause = 14 + PlSqlParserRULE_diskgroup_template_clauses = 15 + PlSqlParserRULE_qualified_template_clause = 16 + PlSqlParserRULE_redundancy_clause = 17 + PlSqlParserRULE_striping_clause = 18 + PlSqlParserRULE_force_noforce = 19 + PlSqlParserRULE_diskgroup_directory_clauses = 20 + PlSqlParserRULE_dir_name = 21 + PlSqlParserRULE_diskgroup_alias_clauses = 22 + PlSqlParserRULE_diskgroup_volume_clauses = 23 + PlSqlParserRULE_add_volume_clause = 24 + PlSqlParserRULE_modify_volume_clause = 25 + PlSqlParserRULE_diskgroup_attributes = 26 + PlSqlParserRULE_drop_diskgroup_file_clause = 27 + PlSqlParserRULE_convert_redundancy_clause = 28 + PlSqlParserRULE_usergroup_clauses = 29 + PlSqlParserRULE_user_clauses = 30 + PlSqlParserRULE_file_permissions_clause = 31 + PlSqlParserRULE_file_owner_clause = 32 + PlSqlParserRULE_scrub_clause = 33 + PlSqlParserRULE_quotagroup_clauses = 34 + PlSqlParserRULE_property_name = 35 + PlSqlParserRULE_property_value = 36 + PlSqlParserRULE_filegroup_clauses = 37 + PlSqlParserRULE_add_filegroup_clause = 38 + PlSqlParserRULE_modify_filegroup_clause = 39 + PlSqlParserRULE_move_to_filegroup_clause = 40 + PlSqlParserRULE_drop_filegroup_clause = 41 + PlSqlParserRULE_quorum_regular = 42 + PlSqlParserRULE_undrop_disk_clause = 43 + PlSqlParserRULE_diskgroup_availability = 44 + PlSqlParserRULE_enable_disable_volume = 45 + PlSqlParserRULE_drop_function = 46 + PlSqlParserRULE_alter_flashback_archive = 47 + PlSqlParserRULE_alter_hierarchy = 48 + PlSqlParserRULE_alter_function = 49 + PlSqlParserRULE_alter_java = 50 + PlSqlParserRULE_match_string = 51 + PlSqlParserRULE_create_function_body = 52 + PlSqlParserRULE_sql_macro_body = 53 + PlSqlParserRULE_parallel_enable_clause = 54 + PlSqlParserRULE_partition_by_clause = 55 + PlSqlParserRULE_result_cache_clause = 56 + PlSqlParserRULE_accessible_by_clause = 57 + PlSqlParserRULE_default_collation_clause = 58 + PlSqlParserRULE_aggregate_clause = 59 + PlSqlParserRULE_pipelined_using_clause = 60 + PlSqlParserRULE_accessor = 61 + PlSqlParserRULE_relies_on_part = 62 + PlSqlParserRULE_streaming_clause = 63 + PlSqlParserRULE_alter_outline = 64 + PlSqlParserRULE_outline_options = 65 + PlSqlParserRULE_alter_lockdown_profile = 66 + PlSqlParserRULE_lockdown_feature = 67 + PlSqlParserRULE_lockdown_options = 68 + PlSqlParserRULE_lockdown_statements = 69 + PlSqlParserRULE_statement_clauses = 70 + PlSqlParserRULE_clause_options = 71 + PlSqlParserRULE_option_values = 72 + PlSqlParserRULE_string_list = 73 + PlSqlParserRULE_disable_enable = 74 + PlSqlParserRULE_drop_lockdown_profile = 75 + PlSqlParserRULE_drop_package = 76 + PlSqlParserRULE_alter_package = 77 + PlSqlParserRULE_create_package = 78 + PlSqlParserRULE_create_package_body = 79 + PlSqlParserRULE_package_obj_spec = 80 + PlSqlParserRULE_procedure_spec = 81 + PlSqlParserRULE_function_spec = 82 + PlSqlParserRULE_package_obj_body = 83 + PlSqlParserRULE_alter_pmem_filestore = 84 + PlSqlParserRULE_drop_pmem_filestore = 85 + PlSqlParserRULE_drop_procedure = 86 + PlSqlParserRULE_alter_procedure = 87 + PlSqlParserRULE_function_body = 88 + PlSqlParserRULE_procedure_body = 89 + PlSqlParserRULE_create_procedure_body = 90 + PlSqlParserRULE_alter_resource_cost = 91 + PlSqlParserRULE_drop_outline = 92 + PlSqlParserRULE_alter_rollback_segment = 93 + PlSqlParserRULE_drop_restore_point = 94 + PlSqlParserRULE_drop_rollback_segment = 95 + PlSqlParserRULE_drop_role = 96 + PlSqlParserRULE_create_pmem_filestore = 97 + PlSqlParserRULE_pmem_filestore_options = 98 + PlSqlParserRULE_file_path = 99 + PlSqlParserRULE_create_rollback_segment = 100 + PlSqlParserRULE_drop_trigger = 101 + PlSqlParserRULE_alter_trigger = 102 + PlSqlParserRULE_create_trigger = 103 + PlSqlParserRULE_trigger_follows_clause = 104 + PlSqlParserRULE_trigger_when_clause = 105 + PlSqlParserRULE_simple_dml_trigger = 106 + PlSqlParserRULE_for_each_row = 107 + PlSqlParserRULE_compound_dml_trigger = 108 + PlSqlParserRULE_non_dml_trigger = 109 + PlSqlParserRULE_trigger_body = 110 + PlSqlParserRULE_compound_trigger_block = 111 + PlSqlParserRULE_timing_point_section = 112 + PlSqlParserRULE_non_dml_event = 113 + PlSqlParserRULE_dml_event_clause = 114 + PlSqlParserRULE_dml_event_element = 115 + PlSqlParserRULE_dml_event_nested_clause = 116 + PlSqlParserRULE_referencing_clause = 117 + PlSqlParserRULE_referencing_element = 118 + PlSqlParserRULE_drop_type = 119 + PlSqlParserRULE_alter_type = 120 + PlSqlParserRULE_compile_type_clause = 121 + PlSqlParserRULE_replace_type_clause = 122 + PlSqlParserRULE_alter_method_spec = 123 + PlSqlParserRULE_alter_method_element = 124 + PlSqlParserRULE_alter_collection_clauses = 125 + PlSqlParserRULE_dependent_handling_clause = 126 + PlSqlParserRULE_dependent_exceptions_part = 127 + PlSqlParserRULE_create_type = 128 + PlSqlParserRULE_type_definition = 129 + PlSqlParserRULE_object_type_def = 130 + PlSqlParserRULE_object_as_part = 131 + PlSqlParserRULE_object_under_part = 132 + PlSqlParserRULE_nested_table_type_def = 133 + PlSqlParserRULE_sqlj_object_type = 134 + PlSqlParserRULE_type_body = 135 + PlSqlParserRULE_type_body_elements = 136 + PlSqlParserRULE_map_order_func_declaration = 137 + PlSqlParserRULE_subprog_decl_in_type = 138 + PlSqlParserRULE_proc_decl_in_type = 139 + PlSqlParserRULE_func_decl_in_type = 140 + PlSqlParserRULE_constructor_declaration = 141 + PlSqlParserRULE_modifier_clause = 142 + PlSqlParserRULE_object_member_spec = 143 + PlSqlParserRULE_sqlj_object_type_attr = 144 + PlSqlParserRULE_element_spec = 145 + PlSqlParserRULE_element_spec_options = 146 + PlSqlParserRULE_subprogram_spec = 147 + PlSqlParserRULE_overriding_subprogram_spec = 148 + PlSqlParserRULE_overriding_function_spec = 149 + PlSqlParserRULE_overriding_procedure_spec = 150 + PlSqlParserRULE_type_procedure_spec = 151 + PlSqlParserRULE_type_function_spec = 152 + PlSqlParserRULE_constructor_spec = 153 + PlSqlParserRULE_map_order_function_spec = 154 + PlSqlParserRULE_pragma_clause = 155 + PlSqlParserRULE_pragma_elements = 156 + PlSqlParserRULE_type_elements_parameter = 157 + PlSqlParserRULE_drop_sequence = 158 + PlSqlParserRULE_alter_sequence = 159 + PlSqlParserRULE_alter_session = 160 + PlSqlParserRULE_alter_session_set_clause = 161 + PlSqlParserRULE_create_sequence = 162 + PlSqlParserRULE_sequence_spec = 163 + PlSqlParserRULE_sequence_start_clause = 164 + PlSqlParserRULE_create_analytic_view = 165 + PlSqlParserRULE_classification_clause = 166 + PlSqlParserRULE_caption_clause = 167 + PlSqlParserRULE_description_clause = 168 + PlSqlParserRULE_classification_item = 169 + PlSqlParserRULE_language = 170 + PlSqlParserRULE_cav_using_clause = 171 + PlSqlParserRULE_dim_by_clause = 172 + PlSqlParserRULE_dim_key = 173 + PlSqlParserRULE_dim_ref = 174 + PlSqlParserRULE_hier_ref = 175 + PlSqlParserRULE_measures_clause = 176 + PlSqlParserRULE_av_measure = 177 + PlSqlParserRULE_base_meas_clause = 178 + PlSqlParserRULE_meas_aggregate_clause = 179 + PlSqlParserRULE_calc_meas_clause = 180 + PlSqlParserRULE_default_measure_clause = 181 + PlSqlParserRULE_default_aggregate_clause = 182 + PlSqlParserRULE_cache_clause = 183 + PlSqlParserRULE_cache_specification = 184 + PlSqlParserRULE_levels_clause = 185 + PlSqlParserRULE_level_specification = 186 + PlSqlParserRULE_level_group_type = 187 + PlSqlParserRULE_fact_columns_clause = 188 + PlSqlParserRULE_qry_transform_clause = 189 + PlSqlParserRULE_create_attribute_dimension = 190 + PlSqlParserRULE_ad_using_clause = 191 + PlSqlParserRULE_source_clause = 192 + PlSqlParserRULE_join_path_clause = 193 + PlSqlParserRULE_join_condition = 194 + PlSqlParserRULE_join_condition_item = 195 + PlSqlParserRULE_attributes_clause = 196 + PlSqlParserRULE_ad_attributes_clause = 197 + PlSqlParserRULE_ad_level_clause = 198 + PlSqlParserRULE_key_clause = 199 + PlSqlParserRULE_alternate_key_clause = 200 + PlSqlParserRULE_dim_order_clause = 201 + PlSqlParserRULE_all_clause = 202 + PlSqlParserRULE_create_audit_policy = 203 + PlSqlParserRULE_privilege_audit_clause = 204 + PlSqlParserRULE_action_audit_clause = 205 + PlSqlParserRULE_system_actions = 206 + PlSqlParserRULE_standard_actions = 207 + PlSqlParserRULE_actions_clause = 208 + PlSqlParserRULE_object_action = 209 + PlSqlParserRULE_system_action = 210 + PlSqlParserRULE_component_actions = 211 + PlSqlParserRULE_component_action = 212 + PlSqlParserRULE_role_audit_clause = 213 + PlSqlParserRULE_create_controlfile = 214 + PlSqlParserRULE_controlfile_options = 215 + PlSqlParserRULE_logfile_clause = 216 + PlSqlParserRULE_character_set_clause = 217 + PlSqlParserRULE_file_specification = 218 + PlSqlParserRULE_create_diskgroup = 219 + PlSqlParserRULE_qualified_disk_clause = 220 + PlSqlParserRULE_create_edition = 221 + PlSqlParserRULE_create_flashback_archive = 222 + PlSqlParserRULE_flashback_archive_quota = 223 + PlSqlParserRULE_flashback_archive_retention = 224 + PlSqlParserRULE_create_hierarchy = 225 + PlSqlParserRULE_hier_using_clause = 226 + PlSqlParserRULE_level_hier_clause = 227 + PlSqlParserRULE_hier_attrs_clause = 228 + PlSqlParserRULE_hier_attr_clause = 229 + PlSqlParserRULE_hier_attr_name = 230 + PlSqlParserRULE_create_index = 231 + PlSqlParserRULE_cluster_index_clause = 232 + PlSqlParserRULE_cluster_name = 233 + PlSqlParserRULE_table_index_clause = 234 + PlSqlParserRULE_bitmap_join_index_clause = 235 + PlSqlParserRULE_index_expr = 236 + PlSqlParserRULE_index_properties = 237 + PlSqlParserRULE_domain_index_clause = 238 + PlSqlParserRULE_local_domain_index_clause = 239 + PlSqlParserRULE_xmlindex_clause = 240 + PlSqlParserRULE_local_xmlindex_clause = 241 + PlSqlParserRULE_global_partitioned_index = 242 + PlSqlParserRULE_index_partitioning_clause = 243 + PlSqlParserRULE_index_partitioning_values_list = 244 + PlSqlParserRULE_local_partitioned_index = 245 + PlSqlParserRULE_on_range_partitioned_table = 246 + PlSqlParserRULE_on_list_partitioned_table = 247 + PlSqlParserRULE_partitioned_table = 248 + PlSqlParserRULE_on_hash_partitioned_table = 249 + PlSqlParserRULE_on_hash_partitioned_clause = 250 + PlSqlParserRULE_on_comp_partitioned_table = 251 + PlSqlParserRULE_on_comp_partitioned_clause = 252 + PlSqlParserRULE_index_subpartition_clause = 253 + PlSqlParserRULE_index_subpartition_subclause = 254 + PlSqlParserRULE_odci_parameters = 255 + PlSqlParserRULE_indextype = 256 + PlSqlParserRULE_alter_index = 257 + PlSqlParserRULE_alter_index_ops_set1 = 258 + PlSqlParserRULE_alter_index_ops_set2 = 259 + PlSqlParserRULE_visible_or_invisible = 260 + PlSqlParserRULE_monitoring_nomonitoring = 261 + PlSqlParserRULE_rebuild_clause = 262 + PlSqlParserRULE_alter_index_partitioning = 263 + PlSqlParserRULE_modify_index_default_attrs = 264 + PlSqlParserRULE_add_hash_index_partition = 265 + PlSqlParserRULE_coalesce_index_partition = 266 + PlSqlParserRULE_modify_index_partition = 267 + PlSqlParserRULE_modify_index_partitions_ops = 268 + PlSqlParserRULE_rename_index_partition = 269 + PlSqlParserRULE_drop_index_partition = 270 + PlSqlParserRULE_split_index_partition = 271 + PlSqlParserRULE_index_partition_description = 272 + PlSqlParserRULE_modify_index_subpartition = 273 + PlSqlParserRULE_partition_name_old = 274 + PlSqlParserRULE_new_partition_name = 275 + PlSqlParserRULE_new_index_name = 276 + PlSqlParserRULE_alter_inmemory_join_group = 277 + PlSqlParserRULE_create_user = 278 + PlSqlParserRULE_alter_user = 279 + PlSqlParserRULE_drop_user = 280 + PlSqlParserRULE_alter_identified_by = 281 + PlSqlParserRULE_identified_by = 282 + PlSqlParserRULE_identified_other_clause = 283 + PlSqlParserRULE_user_tablespace_clause = 284 + PlSqlParserRULE_quota_clause = 285 + PlSqlParserRULE_profile_clause = 286 + PlSqlParserRULE_role_clause = 287 + PlSqlParserRULE_user_default_role_clause = 288 + PlSqlParserRULE_password_expire_clause = 289 + PlSqlParserRULE_user_lock_clause = 290 + PlSqlParserRULE_user_editions_clause = 291 + PlSqlParserRULE_alter_user_editions_clause = 292 + PlSqlParserRULE_proxy_clause = 293 + PlSqlParserRULE_container_names = 294 + PlSqlParserRULE_set_container_data = 295 + PlSqlParserRULE_add_rem_container_data = 296 + PlSqlParserRULE_container_data_clause = 297 + PlSqlParserRULE_administer_key_management = 298 + PlSqlParserRULE_keystore_management_clauses = 299 + PlSqlParserRULE_create_keystore = 300 + PlSqlParserRULE_open_keystore = 301 + PlSqlParserRULE_force_keystore = 302 + PlSqlParserRULE_close_keystore = 303 + PlSqlParserRULE_backup_keystore = 304 + PlSqlParserRULE_alter_keystore_password = 305 + PlSqlParserRULE_merge_into_new_keystore = 306 + PlSqlParserRULE_merge_into_existing_keystore = 307 + PlSqlParserRULE_isolate_keystore = 308 + PlSqlParserRULE_unite_keystore = 309 + PlSqlParserRULE_key_management_clauses = 310 + PlSqlParserRULE_set_key = 311 + PlSqlParserRULE_create_key = 312 + PlSqlParserRULE_mkid = 313 + PlSqlParserRULE_mk = 314 + PlSqlParserRULE_use_key = 315 + PlSqlParserRULE_set_key_tag = 316 + PlSqlParserRULE_export_keys = 317 + PlSqlParserRULE_import_keys = 318 + PlSqlParserRULE_migrate_keys = 319 + PlSqlParserRULE_reverse_migrate_keys = 320 + PlSqlParserRULE_move_keys = 321 + PlSqlParserRULE_identified_by_store = 322 + PlSqlParserRULE_using_algorithm_clause = 323 + PlSqlParserRULE_using_tag_clause = 324 + PlSqlParserRULE_secret_management_clauses = 325 + PlSqlParserRULE_add_update_secret = 326 + PlSqlParserRULE_delete_secret = 327 + PlSqlParserRULE_add_update_secret_seps = 328 + PlSqlParserRULE_delete_secret_seps = 329 + PlSqlParserRULE_zero_downtime_software_patching_clauses = 330 + PlSqlParserRULE_with_backup_clause = 331 + PlSqlParserRULE_identified_by_password_clause = 332 + PlSqlParserRULE_keystore_password = 333 + PlSqlParserRULE_path = 334 + PlSqlParserRULE_secret = 335 + PlSqlParserRULE_analyze = 336 + PlSqlParserRULE_partition_extention_clause = 337 + PlSqlParserRULE_validation_clauses = 338 + PlSqlParserRULE_compute_clauses = 339 + PlSqlParserRULE_for_clause = 340 + PlSqlParserRULE_online_or_offline = 341 + PlSqlParserRULE_into_clause1 = 342 + PlSqlParserRULE_partition_key_value = 343 + PlSqlParserRULE_subpartition_key_value = 344 + PlSqlParserRULE_associate_statistics = 345 + PlSqlParserRULE_column_association = 346 + PlSqlParserRULE_function_association = 347 + PlSqlParserRULE_indextype_name = 348 + PlSqlParserRULE_using_statistics_type = 349 + PlSqlParserRULE_statistics_type_name = 350 + PlSqlParserRULE_default_cost_clause = 351 + PlSqlParserRULE_cpu_cost = 352 + PlSqlParserRULE_io_cost = 353 + PlSqlParserRULE_network_cost = 354 + PlSqlParserRULE_default_selectivity_clause = 355 + PlSqlParserRULE_default_selectivity = 356 + PlSqlParserRULE_storage_table_clause = 357 + PlSqlParserRULE_unified_auditing = 358 + PlSqlParserRULE_policy_name = 359 + PlSqlParserRULE_audit_traditional = 360 + PlSqlParserRULE_audit_direct_path = 361 + PlSqlParserRULE_audit_container_clause = 362 + PlSqlParserRULE_audit_operation_clause = 363 + PlSqlParserRULE_auditing_by_clause = 364 + PlSqlParserRULE_audit_user = 365 + PlSqlParserRULE_audit_schema_object_clause = 366 + PlSqlParserRULE_sql_operation = 367 + PlSqlParserRULE_auditing_on_clause = 368 + PlSqlParserRULE_model_name = 369 + PlSqlParserRULE_object_name = 370 + PlSqlParserRULE_profile_name = 371 + PlSqlParserRULE_sql_statement_shortcut = 372 + PlSqlParserRULE_drop_index = 373 + PlSqlParserRULE_disassociate_statistics = 374 + PlSqlParserRULE_drop_indextype = 375 + PlSqlParserRULE_drop_inmemory_join_group = 376 + PlSqlParserRULE_flashback_table = 377 + PlSqlParserRULE_restore_point = 378 + PlSqlParserRULE_purge_statement = 379 + PlSqlParserRULE_noaudit_statement = 380 + PlSqlParserRULE_rename_object = 381 + PlSqlParserRULE_grant_statement = 382 + PlSqlParserRULE_container_clause = 383 + PlSqlParserRULE_revoke_statement = 384 + PlSqlParserRULE_revoke_system_privilege = 385 + PlSqlParserRULE_revokee_clause = 386 + PlSqlParserRULE_revoke_object_privileges = 387 + PlSqlParserRULE_on_object_clause = 388 + PlSqlParserRULE_revoke_roles_from_programs = 389 + PlSqlParserRULE_program_unit = 390 + PlSqlParserRULE_create_dimension = 391 + PlSqlParserRULE_create_directory = 392 + PlSqlParserRULE_directory_name = 393 + PlSqlParserRULE_directory_path = 394 + PlSqlParserRULE_create_inmemory_join_group = 395 + PlSqlParserRULE_drop_hierarchy = 396 + PlSqlParserRULE_alter_library = 397 + PlSqlParserRULE_drop_java = 398 + PlSqlParserRULE_drop_library = 399 + PlSqlParserRULE_create_java = 400 + PlSqlParserRULE_create_library = 401 + PlSqlParserRULE_plsql_library_source = 402 + PlSqlParserRULE_credential_name = 403 + PlSqlParserRULE_library_editionable = 404 + PlSqlParserRULE_library_debug = 405 + PlSqlParserRULE_compiler_parameters_clause = 406 + PlSqlParserRULE_parameter_value = 407 + PlSqlParserRULE_library_name = 408 + PlSqlParserRULE_alter_dimension = 409 + PlSqlParserRULE_level_clause = 410 + PlSqlParserRULE_hierarchy_clause = 411 + PlSqlParserRULE_dimension_join_clause = 412 + PlSqlParserRULE_attribute_clause = 413 + PlSqlParserRULE_extended_attribute_clause = 414 + PlSqlParserRULE_column_one_or_more_sub_clause = 415 + PlSqlParserRULE_alter_view = 416 + PlSqlParserRULE_alter_view_editionable = 417 + PlSqlParserRULE_create_view = 418 + PlSqlParserRULE_editioning_clause = 419 + PlSqlParserRULE_view_options = 420 + PlSqlParserRULE_view_alias_constraint = 421 + PlSqlParserRULE_object_view_clause = 422 + PlSqlParserRULE_inline_constraint = 423 + PlSqlParserRULE_inline_ref_constraint = 424 + PlSqlParserRULE_out_of_line_ref_constraint = 425 + PlSqlParserRULE_out_of_line_constraint = 426 + PlSqlParserRULE_constraint_state = 427 + PlSqlParserRULE_xmltype_view_clause = 428 + PlSqlParserRULE_xml_schema_spec = 429 + PlSqlParserRULE_xml_schema_url = 430 + PlSqlParserRULE_element = 431 + PlSqlParserRULE_alter_tablespace = 432 + PlSqlParserRULE_datafile_tempfile_clauses = 433 + PlSqlParserRULE_tablespace_logging_clauses = 434 + PlSqlParserRULE_tablespace_group_clause = 435 + PlSqlParserRULE_tablespace_group_name = 436 + PlSqlParserRULE_tablespace_state_clauses = 437 + PlSqlParserRULE_flashback_mode_clause = 438 + PlSqlParserRULE_new_tablespace_name = 439 + PlSqlParserRULE_create_tablespace = 440 + PlSqlParserRULE_permanent_tablespace_clause = 441 + PlSqlParserRULE_tablespace_encryption_spec = 442 + PlSqlParserRULE_logging_clause = 443 + PlSqlParserRULE_extent_management_clause = 444 + PlSqlParserRULE_segment_management_clause = 445 + PlSqlParserRULE_temporary_tablespace_clause = 446 + PlSqlParserRULE_undo_tablespace_clause = 447 + PlSqlParserRULE_tablespace_retention_clause = 448 + PlSqlParserRULE_create_tablespace_set = 449 + PlSqlParserRULE_permanent_tablespace_attrs = 450 + PlSqlParserRULE_tablespace_encryption_clause = 451 + PlSqlParserRULE_default_tablespace_params = 452 + PlSqlParserRULE_default_table_compression = 453 + PlSqlParserRULE_low_high = 454 + PlSqlParserRULE_default_index_compression = 455 + PlSqlParserRULE_inmmemory_clause = 456 + PlSqlParserRULE_datafile_specification = 457 + PlSqlParserRULE_tempfile_specification = 458 + PlSqlParserRULE_datafile_tempfile_spec = 459 + PlSqlParserRULE_redo_log_file_spec = 460 + PlSqlParserRULE_autoextend_clause = 461 + PlSqlParserRULE_maxsize_clause = 462 + PlSqlParserRULE_build_clause = 463 + PlSqlParserRULE_parallel_clause = 464 + PlSqlParserRULE_parallel_instances_clause = 465 + PlSqlParserRULE_alter_materialized_view = 466 + PlSqlParserRULE_alter_mv_option1 = 467 + PlSqlParserRULE_alter_mv_refresh = 468 + PlSqlParserRULE_rollback_segment = 469 + PlSqlParserRULE_modify_mv_column_clause = 470 + PlSqlParserRULE_alter_materialized_view_log = 471 + PlSqlParserRULE_add_mv_log_column_clause = 472 + PlSqlParserRULE_move_mv_log_clause = 473 + PlSqlParserRULE_mv_log_augmentation = 474 + PlSqlParserRULE_create_materialized_view_log = 475 + PlSqlParserRULE_new_values_clause = 476 + PlSqlParserRULE_mv_log_purge_clause = 477 + PlSqlParserRULE_create_materialized_zonemap = 478 + PlSqlParserRULE_alter_materialized_zonemap = 479 + PlSqlParserRULE_drop_materialized_zonemap = 480 + PlSqlParserRULE_zonemap_refresh_clause = 481 + PlSqlParserRULE_zonemap_attributes = 482 + PlSqlParserRULE_zonemap_name = 483 + PlSqlParserRULE_operator_name = 484 + PlSqlParserRULE_operator_function_name = 485 + PlSqlParserRULE_create_zonemap_on_table = 486 + PlSqlParserRULE_create_zonemap_as_subquery = 487 + PlSqlParserRULE_alter_operator = 488 + PlSqlParserRULE_drop_operator = 489 + PlSqlParserRULE_create_operator = 490 + PlSqlParserRULE_binding_clause = 491 + PlSqlParserRULE_add_binding_clause = 492 + PlSqlParserRULE_implementation_clause = 493 + PlSqlParserRULE_primary_operator_list = 494 + PlSqlParserRULE_primary_operator_item = 495 + PlSqlParserRULE_operator_context_clause = 496 + PlSqlParserRULE_using_function_clause = 497 + PlSqlParserRULE_drop_binding_clause = 498 + PlSqlParserRULE_create_materialized_view = 499 + PlSqlParserRULE_scoped_table_ref_constraint = 500 + PlSqlParserRULE_mv_column_alias = 501 + PlSqlParserRULE_create_mv_refresh = 502 + PlSqlParserRULE_query_rewrite_clause = 503 + PlSqlParserRULE_unusable_editions_clause = 504 + PlSqlParserRULE_drop_materialized_view = 505 + PlSqlParserRULE_drop_materialized_view_log = 506 + PlSqlParserRULE_create_context = 507 + PlSqlParserRULE_oracle_namespace = 508 + PlSqlParserRULE_create_cluster = 509 + PlSqlParserRULE_create_profile = 510 + PlSqlParserRULE_resource_parameters = 511 + PlSqlParserRULE_password_parameters = 512 + PlSqlParserRULE_create_lockdown_profile = 513 + PlSqlParserRULE_static_base_profile = 514 + PlSqlParserRULE_dynamic_base_profile = 515 + PlSqlParserRULE_create_outline = 516 + PlSqlParserRULE_create_restore_point = 517 + PlSqlParserRULE_create_role = 518 + PlSqlParserRULE_create_table = 519 + PlSqlParserRULE_xmltype_table = 520 + PlSqlParserRULE_xmltype_virtual_columns = 521 + PlSqlParserRULE_xmltype_column_properties = 522 + PlSqlParserRULE_xmltype_storage = 523 + PlSqlParserRULE_xmlschema_spec = 524 + PlSqlParserRULE_object_table = 525 + PlSqlParserRULE_object_type = 526 + PlSqlParserRULE_oid_index_clause = 527 + PlSqlParserRULE_oid_clause = 528 + PlSqlParserRULE_object_properties = 529 + PlSqlParserRULE_object_table_substitution = 530 + PlSqlParserRULE_relational_table = 531 + PlSqlParserRULE_relational_table_properties = 532 + PlSqlParserRULE_relational_table_property = 533 + PlSqlParserRULE_immutable_table_clauses = 534 + PlSqlParserRULE_immutable_table_no_drop_clause = 535 + PlSqlParserRULE_immutable_table_no_delete_clause = 536 + PlSqlParserRULE_blockchain_table_clauses = 537 + PlSqlParserRULE_blockchain_drop_table_clause = 538 + PlSqlParserRULE_blockchain_row_retention_clause = 539 + PlSqlParserRULE_blockchain_hash_and_data_format_clause = 540 + PlSqlParserRULE_collation_name = 541 + PlSqlParserRULE_table_properties = 542 + PlSqlParserRULE_read_only_clause = 543 + PlSqlParserRULE_indexing_clause = 544 + PlSqlParserRULE_attribute_clustering_clause = 545 + PlSqlParserRULE_clustering_join = 546 + PlSqlParserRULE_clustering_join_item = 547 + PlSqlParserRULE_equijoin_condition = 548 + PlSqlParserRULE_cluster_clause = 549 + PlSqlParserRULE_clustering_columns = 550 + PlSqlParserRULE_clustering_column_group = 551 + PlSqlParserRULE_yes_no = 552 + PlSqlParserRULE_zonemap_clause = 553 + PlSqlParserRULE_logical_replication_clause = 554 + PlSqlParserRULE_table_name = 555 + PlSqlParserRULE_relational_property = 556 + PlSqlParserRULE_table_partitioning_clauses = 557 + PlSqlParserRULE_range_partitions = 558 + PlSqlParserRULE_list_partitions = 559 + PlSqlParserRULE_hash_partitions = 560 + PlSqlParserRULE_individual_hash_partitions = 561 + PlSqlParserRULE_hash_partitions_by_quantity = 562 + PlSqlParserRULE_hash_partition_quantity = 563 + PlSqlParserRULE_composite_range_partitions = 564 + PlSqlParserRULE_composite_list_partitions = 565 + PlSqlParserRULE_composite_hash_partitions = 566 + PlSqlParserRULE_reference_partitioning = 567 + PlSqlParserRULE_reference_partition_desc = 568 + PlSqlParserRULE_system_partitioning = 569 + PlSqlParserRULE_range_partition_desc = 570 + PlSqlParserRULE_list_partition_desc = 571 + PlSqlParserRULE_subpartition_template = 572 + PlSqlParserRULE_hash_subpartition_quantity = 573 + PlSqlParserRULE_subpartition_by_range = 574 + PlSqlParserRULE_subpartition_by_list = 575 + PlSqlParserRULE_subpartition_by_hash = 576 + PlSqlParserRULE_subpartition_name = 577 + PlSqlParserRULE_range_subpartition_desc = 578 + PlSqlParserRULE_list_subpartition_desc = 579 + PlSqlParserRULE_individual_hash_subparts = 580 + PlSqlParserRULE_hash_subparts_by_quantity = 581 + PlSqlParserRULE_range_values_clause = 582 + PlSqlParserRULE_range_values_list = 583 + PlSqlParserRULE_list_values_clause = 584 + PlSqlParserRULE_table_partition_description = 585 + PlSqlParserRULE_partitioning_storage_clause = 586 + PlSqlParserRULE_lob_partitioning_storage = 587 + PlSqlParserRULE_size_clause = 588 + PlSqlParserRULE_table_compression = 589 + PlSqlParserRULE_inmemory_table_clause = 590 + PlSqlParserRULE_inmemory_attributes = 591 + PlSqlParserRULE_inmemory_memcompress = 592 + PlSqlParserRULE_inmemory_priority = 593 + PlSqlParserRULE_inmemory_distribute = 594 + PlSqlParserRULE_inmemory_duplicate = 595 + PlSqlParserRULE_inmemory_column_clause = 596 + PlSqlParserRULE_physical_attributes_clause = 597 + PlSqlParserRULE_storage_clause = 598 + PlSqlParserRULE_deferred_segment_creation = 599 + PlSqlParserRULE_segment_attributes_clause = 600 + PlSqlParserRULE_physical_properties = 601 + PlSqlParserRULE_ilm_clause = 602 + PlSqlParserRULE_ilm_policy_clause = 603 + PlSqlParserRULE_ilm_compression_policy = 604 + PlSqlParserRULE_ilm_tiering_policy = 605 + PlSqlParserRULE_ilm_after_on = 606 + PlSqlParserRULE_segment_group = 607 + PlSqlParserRULE_ilm_inmemory_policy = 608 + PlSqlParserRULE_ilm_time_period = 609 + PlSqlParserRULE_heap_org_table_clause = 610 + PlSqlParserRULE_external_table_clause = 611 + PlSqlParserRULE_access_driver_type = 612 + PlSqlParserRULE_external_table_data_props = 613 + PlSqlParserRULE_external_table_data_format = 614 + PlSqlParserRULE_external_table_transform = 615 + PlSqlParserRULE_external_table_field = 616 + PlSqlParserRULE_external_table_field_list = 617 + PlSqlParserRULE_external_table_fields_clause = 618 + PlSqlParserRULE_external_table_position_clause = 619 + PlSqlParserRULE_external_table_datatype_clause = 620 + PlSqlParserRULE_external_table_delimit_clause = 621 + PlSqlParserRULE_external_table_trim_clause = 622 + PlSqlParserRULE_external_table_date_format_clause = 623 + PlSqlParserRULE_external_table_init_clause = 624 + PlSqlParserRULE_external_table_condition_clause = 625 + PlSqlParserRULE_external_table_lls_clause = 626 + PlSqlParserRULE_external_table_records = 627 + PlSqlParserRULE_external_table_record_options_clause = 628 + PlSqlParserRULE_external_table_output_files = 629 + PlSqlParserRULE_external_table_fields = 630 + PlSqlParserRULE_external_table_datapump = 631 + PlSqlParserRULE_external_table_hive = 632 + PlSqlParserRULE_external_table_hive_parameter_map = 633 + PlSqlParserRULE_external_table_hive_parameter_map_entry = 634 + PlSqlParserRULE_external_table_directory = 635 + PlSqlParserRULE_row_movement_clause = 636 + PlSqlParserRULE_flashback_archive_clause = 637 + PlSqlParserRULE_log_grp = 638 + PlSqlParserRULE_supplemental_table_logging = 639 + PlSqlParserRULE_supplemental_log_grp_clause = 640 + PlSqlParserRULE_supplemental_id_key_clause = 641 + PlSqlParserRULE_allocate_extent_clause = 642 + PlSqlParserRULE_deallocate_unused_clause = 643 + PlSqlParserRULE_shrink_clause = 644 + PlSqlParserRULE_records_per_block_clause = 645 + PlSqlParserRULE_upgrade_table_clause = 646 + PlSqlParserRULE_truncate_table = 647 + PlSqlParserRULE_drop_table = 648 + PlSqlParserRULE_drop_tablespace = 649 + PlSqlParserRULE_drop_tablespace_set = 650 + PlSqlParserRULE_including_contents_clause = 651 + PlSqlParserRULE_drop_view = 652 + PlSqlParserRULE_comment_on_column = 653 + PlSqlParserRULE_enable_or_disable = 654 + PlSqlParserRULE_allow_or_disallow = 655 + PlSqlParserRULE_alter_synonym = 656 + PlSqlParserRULE_create_synonym = 657 + PlSqlParserRULE_drop_synonym = 658 + PlSqlParserRULE_create_spfile = 659 + PlSqlParserRULE_spfile_name = 660 + PlSqlParserRULE_pfile_name = 661 + PlSqlParserRULE_comment_on_table = 662 + PlSqlParserRULE_comment_on_materialized = 663 + PlSqlParserRULE_alter_analytic_view = 664 + PlSqlParserRULE_alter_add_cache_clause = 665 + PlSqlParserRULE_levels_item = 666 + PlSqlParserRULE_measure_list = 667 + PlSqlParserRULE_alter_drop_cache_clause = 668 + PlSqlParserRULE_alter_attribute_dimension = 669 + PlSqlParserRULE_alter_audit_policy = 670 + PlSqlParserRULE_alter_cluster = 671 + PlSqlParserRULE_drop_analytic_view = 672 + PlSqlParserRULE_drop_attribute_dimension = 673 + PlSqlParserRULE_drop_audit_policy = 674 + PlSqlParserRULE_drop_flashback_archive = 675 + PlSqlParserRULE_drop_cluster = 676 + PlSqlParserRULE_drop_context = 677 + PlSqlParserRULE_drop_directory = 678 + PlSqlParserRULE_drop_diskgroup = 679 + PlSqlParserRULE_drop_edition = 680 + PlSqlParserRULE_truncate_cluster = 681 + PlSqlParserRULE_cache_or_nocache = 682 + PlSqlParserRULE_database_name = 683 + PlSqlParserRULE_alter_database = 684 + PlSqlParserRULE_database_clause = 685 + PlSqlParserRULE_startup_clauses = 686 + PlSqlParserRULE_resetlogs_or_noresetlogs = 687 + PlSqlParserRULE_upgrade_or_downgrade = 688 + PlSqlParserRULE_recovery_clauses = 689 + PlSqlParserRULE_begin_or_end = 690 + PlSqlParserRULE_general_recovery = 691 + PlSqlParserRULE_full_database_recovery = 692 + PlSqlParserRULE_partial_database_recovery = 693 + PlSqlParserRULE_partial_database_recovery_10g = 694 + PlSqlParserRULE_managed_standby_recovery = 695 + PlSqlParserRULE_db_name = 696 + PlSqlParserRULE_database_file_clauses = 697 + PlSqlParserRULE_create_datafile_clause = 698 + PlSqlParserRULE_alter_datafile_clause = 699 + PlSqlParserRULE_alter_tempfile_clause = 700 + PlSqlParserRULE_move_datafile_clause = 701 + PlSqlParserRULE_logfile_clauses = 702 + PlSqlParserRULE_add_logfile_clauses = 703 + PlSqlParserRULE_group_redo_logfile = 704 + PlSqlParserRULE_drop_logfile_clauses = 705 + PlSqlParserRULE_switch_logfile_clause = 706 + PlSqlParserRULE_supplemental_db_logging = 707 + PlSqlParserRULE_add_or_drop = 708 + PlSqlParserRULE_supplemental_plsql_clause = 709 + PlSqlParserRULE_logfile_descriptor = 710 + PlSqlParserRULE_controlfile_clauses = 711 + PlSqlParserRULE_trace_file_clause = 712 + PlSqlParserRULE_standby_database_clauses = 713 + PlSqlParserRULE_activate_standby_db_clause = 714 + PlSqlParserRULE_maximize_standby_db_clause = 715 + PlSqlParserRULE_register_logfile_clause = 716 + PlSqlParserRULE_commit_switchover_clause = 717 + PlSqlParserRULE_start_standby_clause = 718 + PlSqlParserRULE_stop_standby_clause = 719 + PlSqlParserRULE_convert_database_clause = 720 + PlSqlParserRULE_default_settings_clause = 721 + PlSqlParserRULE_set_time_zone_clause = 722 + PlSqlParserRULE_instance_clauses = 723 + PlSqlParserRULE_security_clause = 724 + PlSqlParserRULE_domain = 725 + PlSqlParserRULE_database = 726 + PlSqlParserRULE_edition_name = 727 + PlSqlParserRULE_filenumber = 728 + PlSqlParserRULE_filename = 729 + PlSqlParserRULE_prepare_clause = 730 + PlSqlParserRULE_drop_mirror_clause = 731 + PlSqlParserRULE_lost_write_protection = 732 + PlSqlParserRULE_cdb_fleet_clauses = 733 + PlSqlParserRULE_lead_cdb_clause = 734 + PlSqlParserRULE_lead_cdb_uri_clause = 735 + PlSqlParserRULE_property_clauses = 736 + PlSqlParserRULE_replay_upgrade_clauses = 737 + PlSqlParserRULE_alter_database_link = 738 + PlSqlParserRULE_password_value = 739 + PlSqlParserRULE_link_authentication = 740 + PlSqlParserRULE_create_schema = 741 + PlSqlParserRULE_create_database = 742 + PlSqlParserRULE_database_logging_clauses = 743 + PlSqlParserRULE_database_logging_sub_clause = 744 + PlSqlParserRULE_tablespace_clauses = 745 + PlSqlParserRULE_enable_pluggable_database = 746 + PlSqlParserRULE_file_name_convert = 747 + PlSqlParserRULE_filename_convert_sub_clause = 748 + PlSqlParserRULE_tablespace_datafile_clauses = 749 + PlSqlParserRULE_undo_mode_clause = 750 + PlSqlParserRULE_default_tablespace = 751 + PlSqlParserRULE_default_temp_tablespace = 752 + PlSqlParserRULE_undo_tablespace = 753 + PlSqlParserRULE_drop_database = 754 + PlSqlParserRULE_create_database_link = 755 + PlSqlParserRULE_drop_database_link = 756 + PlSqlParserRULE_alter_tablespace_set = 757 + PlSqlParserRULE_alter_tablespace_attrs = 758 + PlSqlParserRULE_alter_tablespace_encryption = 759 + PlSqlParserRULE_ts_file_name_convert = 760 + PlSqlParserRULE_alter_role = 761 + PlSqlParserRULE_role_identified_clause = 762 + PlSqlParserRULE_alter_table = 763 + PlSqlParserRULE_memoptimize_read_write_clause = 764 + PlSqlParserRULE_alter_table_properties = 765 + PlSqlParserRULE_alter_table_partitioning = 766 + PlSqlParserRULE_add_table_partition = 767 + PlSqlParserRULE_drop_table_partition = 768 + PlSqlParserRULE_merge_table_partition = 769 + PlSqlParserRULE_modify_table_partition = 770 + PlSqlParserRULE_split_table_partition = 771 + PlSqlParserRULE_truncate_table_partition = 772 + PlSqlParserRULE_exchange_table_partition = 773 + PlSqlParserRULE_coalesce_table_partition = 774 + PlSqlParserRULE_alter_interval_partition = 775 + PlSqlParserRULE_move_table_partition = 776 + PlSqlParserRULE_filter_condition = 777 + PlSqlParserRULE_rename_table_partition = 778 + PlSqlParserRULE_partition_extended_names = 779 + PlSqlParserRULE_subpartition_extended_names = 780 + PlSqlParserRULE_alter_table_properties_1 = 781 + PlSqlParserRULE_alter_iot_clauses = 782 + PlSqlParserRULE_alter_mapping_table_clause = 783 + PlSqlParserRULE_alter_overflow_clause = 784 + PlSqlParserRULE_add_overflow_clause = 785 + PlSqlParserRULE_update_index_clauses = 786 + PlSqlParserRULE_update_global_index_clause = 787 + PlSqlParserRULE_update_all_indexes_clause = 788 + PlSqlParserRULE_update_all_indexes_index_clause = 789 + PlSqlParserRULE_update_index_partition = 790 + PlSqlParserRULE_update_index_subpartition = 791 + PlSqlParserRULE_enable_disable_clause = 792 + PlSqlParserRULE_using_index_clause = 793 + PlSqlParserRULE_index_attributes = 794 + PlSqlParserRULE_sort_or_nosort = 795 + PlSqlParserRULE_exceptions_clause = 796 + PlSqlParserRULE_move_table_clause = 797 + PlSqlParserRULE_index_org_table_clause = 798 + PlSqlParserRULE_mapping_table_clause = 799 + PlSqlParserRULE_key_compression = 800 + PlSqlParserRULE_index_org_overflow_clause = 801 + PlSqlParserRULE_column_clauses = 802 + PlSqlParserRULE_modify_collection_retrieval = 803 + PlSqlParserRULE_collection_item = 804 + PlSqlParserRULE_rename_column_clause = 805 + PlSqlParserRULE_old_column_name = 806 + PlSqlParserRULE_new_column_name = 807 + PlSqlParserRULE_add_modify_drop_column_clauses = 808 + PlSqlParserRULE_drop_column_clause = 809 + PlSqlParserRULE_modify_column_clauses = 810 + PlSqlParserRULE_modify_col_properties = 811 + PlSqlParserRULE_modify_col_visibility = 812 + PlSqlParserRULE_modify_col_substitutable = 813 + PlSqlParserRULE_add_column_clause = 814 + PlSqlParserRULE_varray_col_properties = 815 + PlSqlParserRULE_varray_storage_clause = 816 + PlSqlParserRULE_lob_segname = 817 + PlSqlParserRULE_lob_item = 818 + PlSqlParserRULE_lob_storage_parameters = 819 + PlSqlParserRULE_lob_storage_clause = 820 + PlSqlParserRULE_modify_lob_storage_clause = 821 + PlSqlParserRULE_modify_lob_parameters = 822 + PlSqlParserRULE_lob_parameters = 823 + PlSqlParserRULE_lob_deduplicate_clause = 824 + PlSqlParserRULE_lob_compression_clause = 825 + PlSqlParserRULE_lob_retention_clause = 826 + PlSqlParserRULE_encryption_spec = 827 + PlSqlParserRULE_tablespace = 828 + PlSqlParserRULE_varray_item = 829 + PlSqlParserRULE_column_properties = 830 + PlSqlParserRULE_lob_partition_storage = 831 + PlSqlParserRULE_period_definition = 832 + PlSqlParserRULE_start_time_column = 833 + PlSqlParserRULE_end_time_column = 834 + PlSqlParserRULE_column_definition = 835 + PlSqlParserRULE_column_collation_name = 836 + PlSqlParserRULE_identity_clause = 837 + PlSqlParserRULE_identity_options_parentheses = 838 + PlSqlParserRULE_identity_options = 839 + PlSqlParserRULE_virtual_column_definition = 840 + PlSqlParserRULE_virtual_column_expression = 841 + PlSqlParserRULE_autogenerated_sequence_definition = 842 + PlSqlParserRULE_by_user_for_statistics_clause = 843 + PlSqlParserRULE_evaluation_edition_clause = 844 + PlSqlParserRULE_nested_table_col_properties = 845 + PlSqlParserRULE_nested_item = 846 + PlSqlParserRULE_substitutable_column_clause = 847 + PlSqlParserRULE_partition_name = 848 + PlSqlParserRULE_supplemental_logging_props = 849 + PlSqlParserRULE_object_type_col_properties = 850 + PlSqlParserRULE_constraint_clauses = 851 + PlSqlParserRULE_old_constraint_name = 852 + PlSqlParserRULE_new_constraint_name = 853 + PlSqlParserRULE_drop_constraint_clause = 854 + PlSqlParserRULE_check_constraint = 855 + PlSqlParserRULE_foreign_key_clause = 856 + PlSqlParserRULE_references_clause = 857 + PlSqlParserRULE_on_delete_clause = 858 + PlSqlParserRULE_anonymous_block = 859 + PlSqlParserRULE_invoker_rights_clause = 860 + PlSqlParserRULE_call_spec = 861 + PlSqlParserRULE_java_spec = 862 + PlSqlParserRULE_c_spec = 863 + PlSqlParserRULE_c_agent_in_clause = 864 + PlSqlParserRULE_c_parameters_clause = 865 + PlSqlParserRULE_c_external_parameter = 866 + PlSqlParserRULE_c_property = 867 + PlSqlParserRULE_parameter = 868 + PlSqlParserRULE_default_value_part = 869 + PlSqlParserRULE_seq_of_declare_specs = 870 + PlSqlParserRULE_declare_spec = 871 + PlSqlParserRULE_variable_declaration = 872 + PlSqlParserRULE_subtype_declaration = 873 + PlSqlParserRULE_cursor_declaration = 874 + PlSqlParserRULE_parameter_spec = 875 + PlSqlParserRULE_exception_declaration = 876 + PlSqlParserRULE_pragma_declaration = 877 + PlSqlParserRULE_record_type_def = 878 + PlSqlParserRULE_field_spec = 879 + PlSqlParserRULE_ref_cursor_type_def = 880 + PlSqlParserRULE_type_declaration = 881 + PlSqlParserRULE_table_type_def = 882 + PlSqlParserRULE_table_indexed_by_part = 883 + PlSqlParserRULE_varray_type_def = 884 + PlSqlParserRULE_seq_of_statements = 885 + PlSqlParserRULE_label_declaration = 886 + PlSqlParserRULE_statement = 887 + PlSqlParserRULE_assignment_statement = 888 + PlSqlParserRULE_continue_statement = 889 + PlSqlParserRULE_exit_statement = 890 + PlSqlParserRULE_goto_statement = 891 + PlSqlParserRULE_if_statement = 892 + PlSqlParserRULE_elsif_part = 893 + PlSqlParserRULE_else_part = 894 + PlSqlParserRULE_loop_statement = 895 + PlSqlParserRULE_cursor_loop_param = 896 + PlSqlParserRULE_forall_statement = 897 + PlSqlParserRULE_bounds_clause = 898 + PlSqlParserRULE_between_bound = 899 + PlSqlParserRULE_lower_bound = 900 + PlSqlParserRULE_upper_bound = 901 + PlSqlParserRULE_null_statement = 902 + PlSqlParserRULE_raise_statement = 903 + PlSqlParserRULE_return_statement = 904 + PlSqlParserRULE_call_statement = 905 + PlSqlParserRULE_pipe_row_statement = 906 + PlSqlParserRULE_selection_directive = 907 + PlSqlParserRULE_error_directive = 908 + PlSqlParserRULE_selection_directive_body = 909 + PlSqlParserRULE_body = 910 + PlSqlParserRULE_exception_handler = 911 + PlSqlParserRULE_trigger_block = 912 + PlSqlParserRULE_tps_block = 913 + PlSqlParserRULE_block = 914 + PlSqlParserRULE_sql_statement = 915 + PlSqlParserRULE_execute_immediate = 916 + PlSqlParserRULE_dynamic_returning_clause = 917 + PlSqlParserRULE_data_manipulation_language_statements = 918 + PlSqlParserRULE_cursor_manipulation_statements = 919 + PlSqlParserRULE_close_statement = 920 + PlSqlParserRULE_open_statement = 921 + PlSqlParserRULE_fetch_statement = 922 + PlSqlParserRULE_variable_or_collection = 923 + PlSqlParserRULE_open_for_statement = 924 + PlSqlParserRULE_transaction_control_statements = 925 + PlSqlParserRULE_set_transaction_command = 926 + PlSqlParserRULE_set_constraint_command = 927 + PlSqlParserRULE_commit_statement = 928 + PlSqlParserRULE_write_clause = 929 + PlSqlParserRULE_rollback_statement = 930 + PlSqlParserRULE_savepoint_statement = 931 + PlSqlParserRULE_collection_method_call = 932 + PlSqlParserRULE_explain_statement = 933 + PlSqlParserRULE_select_only_statement = 934 + PlSqlParserRULE_select_statement = 935 + PlSqlParserRULE_with_clause = 936 + PlSqlParserRULE_with_factoring_clause = 937 + PlSqlParserRULE_subquery_factoring_clause = 938 + PlSqlParserRULE_search_clause = 939 + PlSqlParserRULE_cycle_clause = 940 + PlSqlParserRULE_subav_factoring_clause = 941 + PlSqlParserRULE_subav_clause = 942 + PlSqlParserRULE_hierarchies_clause = 943 + PlSqlParserRULE_filter_clauses = 944 + PlSqlParserRULE_filter_clause = 945 + PlSqlParserRULE_add_calcs_clause = 946 + PlSqlParserRULE_add_calc_meas_clause = 947 + PlSqlParserRULE_subquery = 948 + PlSqlParserRULE_subquery_basic_elements = 949 + PlSqlParserRULE_subquery_operation_part = 950 + PlSqlParserRULE_query_block = 951 + PlSqlParserRULE_selected_list = 952 + PlSqlParserRULE_from_clause = 953 + PlSqlParserRULE_select_list_elements = 954 + PlSqlParserRULE_table_ref_list = 955 + PlSqlParserRULE_table_ref = 956 + PlSqlParserRULE_table_ref_aux = 957 + PlSqlParserRULE_table_ref_aux_internal = 958 + PlSqlParserRULE_join_clause = 959 + PlSqlParserRULE_join_on_part = 960 + PlSqlParserRULE_join_using_part = 961 + PlSqlParserRULE_outer_join_type = 962 + PlSqlParserRULE_query_partition_clause = 963 + PlSqlParserRULE_flashback_query_clause = 964 + PlSqlParserRULE_pivot_clause = 965 + PlSqlParserRULE_pivot_element = 966 + PlSqlParserRULE_pivot_for_clause = 967 + PlSqlParserRULE_pivot_in_clause = 968 + PlSqlParserRULE_pivot_in_clause_element = 969 + PlSqlParserRULE_pivot_in_clause_elements = 970 + PlSqlParserRULE_unpivot_clause = 971 + PlSqlParserRULE_unpivot_in_clause = 972 + PlSqlParserRULE_unpivot_in_elements = 973 + PlSqlParserRULE_hierarchical_query_clause = 974 + PlSqlParserRULE_start_part = 975 + PlSqlParserRULE_group_by_clause = 976 + PlSqlParserRULE_group_by_elements = 977 + PlSqlParserRULE_rollup_cube_clause = 978 + PlSqlParserRULE_grouping_sets_clause = 979 + PlSqlParserRULE_grouping_sets_elements = 980 + PlSqlParserRULE_having_clause = 981 + PlSqlParserRULE_model_clause = 982 + PlSqlParserRULE_cell_reference_options = 983 + PlSqlParserRULE_return_rows_clause = 984 + PlSqlParserRULE_reference_model = 985 + PlSqlParserRULE_main_model = 986 + PlSqlParserRULE_model_column_clauses = 987 + PlSqlParserRULE_model_column_partition_part = 988 + PlSqlParserRULE_model_column_list = 989 + PlSqlParserRULE_model_column = 990 + PlSqlParserRULE_model_rules_clause = 991 + PlSqlParserRULE_model_rules_part = 992 + PlSqlParserRULE_model_rules_element = 993 + PlSqlParserRULE_cell_assignment = 994 + PlSqlParserRULE_model_iterate_clause = 995 + PlSqlParserRULE_until_part = 996 + PlSqlParserRULE_order_by_clause = 997 + PlSqlParserRULE_order_by_elements = 998 + PlSqlParserRULE_offset_clause = 999 + PlSqlParserRULE_fetch_clause = 1000 + PlSqlParserRULE_for_update_clause = 1001 + PlSqlParserRULE_for_update_of_part = 1002 + PlSqlParserRULE_for_update_options = 1003 + PlSqlParserRULE_update_statement = 1004 + PlSqlParserRULE_update_set_clause = 1005 + PlSqlParserRULE_column_based_update_set_clause = 1006 + PlSqlParserRULE_delete_statement = 1007 + PlSqlParserRULE_insert_statement = 1008 + PlSqlParserRULE_single_table_insert = 1009 + PlSqlParserRULE_multi_table_insert = 1010 + PlSqlParserRULE_multi_table_element = 1011 + PlSqlParserRULE_conditional_insert_clause = 1012 + PlSqlParserRULE_conditional_insert_when_part = 1013 + PlSqlParserRULE_conditional_insert_else_part = 1014 + PlSqlParserRULE_insert_into_clause = 1015 + PlSqlParserRULE_values_clause = 1016 + PlSqlParserRULE_merge_statement = 1017 + PlSqlParserRULE_merge_update_clause = 1018 + PlSqlParserRULE_merge_element = 1019 + PlSqlParserRULE_merge_update_delete_part = 1020 + PlSqlParserRULE_merge_insert_clause = 1021 + PlSqlParserRULE_selected_tableview = 1022 + PlSqlParserRULE_lock_table_statement = 1023 + PlSqlParserRULE_wait_nowait_part = 1024 + PlSqlParserRULE_lock_table_element = 1025 + PlSqlParserRULE_lock_mode = 1026 + PlSqlParserRULE_general_table_ref = 1027 + PlSqlParserRULE_static_returning_clause = 1028 + PlSqlParserRULE_error_logging_clause = 1029 + PlSqlParserRULE_error_logging_into_part = 1030 + PlSqlParserRULE_error_logging_reject_part = 1031 + PlSqlParserRULE_dml_table_expression_clause = 1032 + PlSqlParserRULE_table_collection_expression = 1033 + PlSqlParserRULE_subquery_restriction_clause = 1034 + PlSqlParserRULE_sample_clause = 1035 + PlSqlParserRULE_seed_part = 1036 + PlSqlParserRULE_condition = 1037 + PlSqlParserRULE_expressions_ = 1038 + PlSqlParserRULE_expression = 1039 + PlSqlParserRULE_cursor_expression = 1040 + PlSqlParserRULE_logical_expression = 1041 + PlSqlParserRULE_unary_logical_expression = 1042 + PlSqlParserRULE_unary_logical_operation = 1043 + PlSqlParserRULE_logical_operation = 1044 + PlSqlParserRULE_multiset_expression = 1045 + PlSqlParserRULE_relational_expression = 1046 + PlSqlParserRULE_compound_expression = 1047 + PlSqlParserRULE_relational_operator = 1048 + PlSqlParserRULE_in_elements = 1049 + PlSqlParserRULE_between_elements = 1050 + PlSqlParserRULE_concatenation = 1051 + PlSqlParserRULE_interval_expression = 1052 + PlSqlParserRULE_model_expression = 1053 + PlSqlParserRULE_model_expression_element = 1054 + PlSqlParserRULE_single_column_for_loop = 1055 + PlSqlParserRULE_multi_column_for_loop = 1056 + PlSqlParserRULE_unary_expression = 1057 + PlSqlParserRULE_unary_expression_core = 1058 + PlSqlParserRULE_implicit_cursor_expression = 1059 + PlSqlParserRULE_collection_expression = 1060 + PlSqlParserRULE_case_statement = 1061 + PlSqlParserRULE_simple_case_statement = 1062 + PlSqlParserRULE_searched_case_statement = 1063 + PlSqlParserRULE_case_when_part_statement = 1064 + PlSqlParserRULE_case_else_part_statement = 1065 + PlSqlParserRULE_case_expression = 1066 + PlSqlParserRULE_simple_case_expression = 1067 + PlSqlParserRULE_searched_case_expression = 1068 + PlSqlParserRULE_case_when_part_expression = 1069 + PlSqlParserRULE_case_else_part_expression = 1070 + PlSqlParserRULE_atom = 1071 + PlSqlParserRULE_quantified_expression = 1072 + PlSqlParserRULE_string_function = 1073 + PlSqlParserRULE_standard_function = 1074 + PlSqlParserRULE_json_function = 1075 + PlSqlParserRULE_json_object_content = 1076 + PlSqlParserRULE_json_object_entry = 1077 + PlSqlParserRULE_json_table_clause = 1078 + PlSqlParserRULE_json_array_element = 1079 + PlSqlParserRULE_json_on_null_clause = 1080 + PlSqlParserRULE_json_return_clause = 1081 + PlSqlParserRULE_json_transform_op = 1082 + PlSqlParserRULE_json_column_clause = 1083 + PlSqlParserRULE_json_column_definition = 1084 + PlSqlParserRULE_json_query_returning_clause = 1085 + PlSqlParserRULE_json_query_return_type = 1086 + PlSqlParserRULE_json_query_wrapper_clause = 1087 + PlSqlParserRULE_json_query_on_error_clause = 1088 + PlSqlParserRULE_json_query_on_empty_clause = 1089 + PlSqlParserRULE_json_value_return_clause = 1090 + PlSqlParserRULE_json_value_return_type = 1091 + PlSqlParserRULE_json_value_on_mismatch_clause = 1092 + PlSqlParserRULE_literal = 1093 + PlSqlParserRULE_numeric_function_wrapper = 1094 + PlSqlParserRULE_numeric_function = 1095 + PlSqlParserRULE_listagg_overflow_clause = 1096 + PlSqlParserRULE_other_function = 1097 + PlSqlParserRULE_over_clause_keyword = 1098 + PlSqlParserRULE_within_or_over_clause_keyword = 1099 + PlSqlParserRULE_standard_prediction_function_keyword = 1100 + PlSqlParserRULE_over_clause = 1101 + PlSqlParserRULE_windowing_clause = 1102 + PlSqlParserRULE_windowing_type = 1103 + PlSqlParserRULE_windowing_elements = 1104 + PlSqlParserRULE_using_clause = 1105 + PlSqlParserRULE_using_element = 1106 + PlSqlParserRULE_assignable_element = 1107 + PlSqlParserRULE_collect_order_by_part = 1108 + PlSqlParserRULE_within_or_over_part = 1109 + PlSqlParserRULE_string_delimiter = 1110 + PlSqlParserRULE_cost_matrix_clause = 1111 + PlSqlParserRULE_xml_passing_clause = 1112 + PlSqlParserRULE_xml_attributes_clause = 1113 + PlSqlParserRULE_xml_namespaces_clause = 1114 + PlSqlParserRULE_xml_table_column = 1115 + PlSqlParserRULE_xml_general_default_part = 1116 + PlSqlParserRULE_xml_multiuse_expression_element = 1117 + PlSqlParserRULE_xmlroot_param_version_part = 1118 + PlSqlParserRULE_xmlroot_param_standalone_part = 1119 + PlSqlParserRULE_xmlserialize_param_enconding_part = 1120 + PlSqlParserRULE_xmlserialize_param_version_part = 1121 + PlSqlParserRULE_xmlserialize_param_ident_part = 1122 + PlSqlParserRULE_annotations_clause = 1123 + PlSqlParserRULE_annotations_list = 1124 + PlSqlParserRULE_annotation = 1125 + PlSqlParserRULE_sql_plus_command = 1126 + PlSqlParserRULE_start_command = 1127 + PlSqlParserRULE_sql_plus_filepath = 1128 + PlSqlParserRULE_whenever_command = 1129 + PlSqlParserRULE_set_command = 1130 + PlSqlParserRULE_timing_command = 1131 + PlSqlParserRULE_clear_command = 1132 + PlSqlParserRULE_partition_extension_clause = 1133 + PlSqlParserRULE_column_alias = 1134 + PlSqlParserRULE_table_alias = 1135 + PlSqlParserRULE_where_clause = 1136 + PlSqlParserRULE_into_clause = 1137 + PlSqlParserRULE_xml_column_name = 1138 + PlSqlParserRULE_cost_class_name = 1139 + PlSqlParserRULE_attribute_name = 1140 + PlSqlParserRULE_savepoint_name = 1141 + PlSqlParserRULE_rollback_segment_name = 1142 + PlSqlParserRULE_schema_name = 1143 + PlSqlParserRULE_routine_name = 1144 + PlSqlParserRULE_package_name = 1145 + PlSqlParserRULE_implementation_type_name = 1146 + PlSqlParserRULE_parameter_name = 1147 + PlSqlParserRULE_reference_model_name = 1148 + PlSqlParserRULE_main_model_name = 1149 + PlSqlParserRULE_container_tableview_name = 1150 + PlSqlParserRULE_aggregate_function_name = 1151 + PlSqlParserRULE_query_name = 1152 + PlSqlParserRULE_grantee_name = 1153 + PlSqlParserRULE_role_name = 1154 + PlSqlParserRULE_constraint_name = 1155 + PlSqlParserRULE_label_name = 1156 + PlSqlParserRULE_type_name = 1157 + PlSqlParserRULE_sequence_name = 1158 + PlSqlParserRULE_exception_name = 1159 + PlSqlParserRULE_function_name = 1160 + PlSqlParserRULE_procedure_name = 1161 + PlSqlParserRULE_trigger_name = 1162 + PlSqlParserRULE_variable_name = 1163 + PlSqlParserRULE_index_name = 1164 + PlSqlParserRULE_cursor_name = 1165 + PlSqlParserRULE_record_name = 1166 + PlSqlParserRULE_link_name = 1167 + PlSqlParserRULE_local_link_name = 1168 + PlSqlParserRULE_connection_qualifier = 1169 + PlSqlParserRULE_column_name = 1170 + PlSqlParserRULE_tableview_name = 1171 + PlSqlParserRULE_xmltable = 1172 + PlSqlParserRULE_char_set_name = 1173 + PlSqlParserRULE_synonym_name = 1174 + PlSqlParserRULE_schema_object_name = 1175 + PlSqlParserRULE_dir_object_name = 1176 + PlSqlParserRULE_user_object_name = 1177 + PlSqlParserRULE_grant_object_name = 1178 + PlSqlParserRULE_column_list = 1179 + PlSqlParserRULE_paren_column_list = 1180 + PlSqlParserRULE_keep_clause = 1181 + PlSqlParserRULE_function_argument = 1182 + PlSqlParserRULE_function_argument_analytic = 1183 + PlSqlParserRULE_function_argument_modeling = 1184 + PlSqlParserRULE_respect_or_ignore_nulls = 1185 + PlSqlParserRULE_argument = 1186 + PlSqlParserRULE_type_spec = 1187 + PlSqlParserRULE_datatype = 1188 + PlSqlParserRULE_precision_part = 1189 + PlSqlParserRULE_native_datatype_element = 1190 + PlSqlParserRULE_bind_variable = 1191 + PlSqlParserRULE_general_element = 1192 + PlSqlParserRULE_general_element_part = 1193 + PlSqlParserRULE_table_element = 1194 + PlSqlParserRULE_object_privilege = 1195 + PlSqlParserRULE_system_privilege = 1196 + PlSqlParserRULE_constant = 1197 + PlSqlParserRULE_numeric = 1198 + PlSqlParserRULE_numeric_negative = 1199 + PlSqlParserRULE_quoted_string = 1200 + PlSqlParserRULE_identifier = 1201 + PlSqlParserRULE_id_expression = 1202 + PlSqlParserRULE_inquiry_directive = 1203 + PlSqlParserRULE_outer_join_sign = 1204 + PlSqlParserRULE_regular_id = 1205 + PlSqlParserRULE_non_reserved_keywords_in_18c = 1206 + PlSqlParserRULE_non_reserved_keywords_in_12c = 1207 + PlSqlParserRULE_non_reserved_keywords_pre12c = 1208 +) + +// ISql_scriptContext is an interface to support dynamic dispatch. +type ISql_scriptContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllSql_plus_command() []ISql_plus_commandContext + Sql_plus_command(i int) ISql_plus_commandContext + AllUnit_statement() []IUnit_statementContext + Unit_statement(i int) IUnit_statementContext + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllSOLIDUS() []antlr.TerminalNode + SOLIDUS(i int) antlr.TerminalNode + + // IsSql_scriptContext differentiates from other interfaces. + IsSql_scriptContext() +} + +type Sql_scriptContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_scriptContext() *Sql_scriptContext { + var p = new(Sql_scriptContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_script + return p +} + +func InitEmptySql_scriptContext(p *Sql_scriptContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_script +} + +func (*Sql_scriptContext) IsSql_scriptContext() {} + +func NewSql_scriptContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_scriptContext { + var p = new(Sql_scriptContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_script + + return p +} + +func (s *Sql_scriptContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_scriptContext) EOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserEOF, 0) +} + +func (s *Sql_scriptContext) AllSql_plus_command() []ISql_plus_commandContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_plus_commandContext); ok { + len++ + } + } + + tst := make([]ISql_plus_commandContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_plus_commandContext); ok { + tst[i] = t.(ISql_plus_commandContext) + i++ + } + } + + return tst +} + +func (s *Sql_scriptContext) Sql_plus_command(i int) ISql_plus_commandContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_plus_commandContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_plus_commandContext) +} + +func (s *Sql_scriptContext) AllUnit_statement() []IUnit_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnit_statementContext); ok { + len++ + } + } + + tst := make([]IUnit_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnit_statementContext); ok { + tst[i] = t.(IUnit_statementContext) + i++ + } + } + + return tst +} + +func (s *Sql_scriptContext) Unit_statement(i int) IUnit_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnit_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnit_statementContext) +} + +func (s *Sql_scriptContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Sql_scriptContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Sql_scriptContext) AllSOLIDUS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSOLIDUS) +} + +func (s *Sql_scriptContext) SOLIDUS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSOLIDUS, i) +} + +func (s *Sql_scriptContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_scriptContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_scriptContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_script(s) + } +} + +func (s *Sql_scriptContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_script(s) + } +} + +func (p *PlSqlParser) Sql_script() (localctx ISql_scriptContext) { + localctx = NewSql_scriptContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, PlSqlParserRULE_sql_script) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2418) + p.Sql_plus_command() + } + p.SetState(2420) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) == 1 { + { + p.SetState(2419) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(2426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + p.SetState(2429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2427) + p.Sql_plus_command() + } + + case 2: + { + p.SetState(2428) + p.Unit_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(2441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2431) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2433) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 { + { + p.SetState(2432) + p.Match(PlSqlParserSOLIDUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2435) + p.Sql_plus_command() + } + + case 2: + { + p.SetState(2436) + p.Unit_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(2443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(2445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEMICOLON { + { + p.SetState(2444) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSOLIDUS { + { + p.SetState(2447) + p.Match(PlSqlParserSOLIDUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + { + p.SetState(2450) + p.Match(PlSqlParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnit_statementContext is an interface to support dynamic dispatch. +type IUnit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_analytic_view() IAlter_analytic_viewContext + Alter_attribute_dimension() IAlter_attribute_dimensionContext + Alter_audit_policy() IAlter_audit_policyContext + Alter_cluster() IAlter_clusterContext + Alter_database() IAlter_databaseContext + Alter_database_link() IAlter_database_linkContext + Alter_dimension() IAlter_dimensionContext + Alter_diskgroup() IAlter_diskgroupContext + Alter_flashback_archive() IAlter_flashback_archiveContext + Alter_function() IAlter_functionContext + Alter_hierarchy() IAlter_hierarchyContext + Alter_index() IAlter_indexContext + Alter_inmemory_join_group() IAlter_inmemory_join_groupContext + Alter_java() IAlter_javaContext + Alter_library() IAlter_libraryContext + Alter_lockdown_profile() IAlter_lockdown_profileContext + Alter_materialized_view() IAlter_materialized_viewContext + Alter_materialized_view_log() IAlter_materialized_view_logContext + Alter_materialized_zonemap() IAlter_materialized_zonemapContext + Alter_operator() IAlter_operatorContext + Alter_outline() IAlter_outlineContext + Alter_package() IAlter_packageContext + Alter_pmem_filestore() IAlter_pmem_filestoreContext + Alter_procedure() IAlter_procedureContext + Alter_resource_cost() IAlter_resource_costContext + Alter_role() IAlter_roleContext + Alter_rollback_segment() IAlter_rollback_segmentContext + Alter_sequence() IAlter_sequenceContext + Alter_session() IAlter_sessionContext + Alter_synonym() IAlter_synonymContext + Alter_table() IAlter_tableContext + Alter_tablespace() IAlter_tablespaceContext + Alter_tablespace_set() IAlter_tablespace_setContext + Alter_trigger() IAlter_triggerContext + Alter_type() IAlter_typeContext + Alter_user() IAlter_userContext + Alter_view() IAlter_viewContext + Anonymous_block() IAnonymous_blockContext + Call_statement() ICall_statementContext + Create_analytic_view() ICreate_analytic_viewContext + Create_attribute_dimension() ICreate_attribute_dimensionContext + Create_audit_policy() ICreate_audit_policyContext + Create_cluster() ICreate_clusterContext + Create_context() ICreate_contextContext + Create_controlfile() ICreate_controlfileContext + Create_schema() ICreate_schemaContext + Create_database() ICreate_databaseContext + Create_database_link() ICreate_database_linkContext + Create_dimension() ICreate_dimensionContext + Create_directory() ICreate_directoryContext + Create_diskgroup() ICreate_diskgroupContext + Create_edition() ICreate_editionContext + Create_flashback_archive() ICreate_flashback_archiveContext + Create_function_body() ICreate_function_bodyContext + Create_hierarchy() ICreate_hierarchyContext + Create_index() ICreate_indexContext + Create_inmemory_join_group() ICreate_inmemory_join_groupContext + Create_java() ICreate_javaContext + Create_library() ICreate_libraryContext + Create_lockdown_profile() ICreate_lockdown_profileContext + Create_materialized_view() ICreate_materialized_viewContext + Create_materialized_view_log() ICreate_materialized_view_logContext + Create_materialized_zonemap() ICreate_materialized_zonemapContext + Create_operator() ICreate_operatorContext + Create_outline() ICreate_outlineContext + Create_package() ICreate_packageContext + Create_package_body() ICreate_package_bodyContext + Create_pmem_filestore() ICreate_pmem_filestoreContext + Create_procedure_body() ICreate_procedure_bodyContext + Create_profile() ICreate_profileContext + Create_restore_point() ICreate_restore_pointContext + Create_role() ICreate_roleContext + Create_rollback_segment() ICreate_rollback_segmentContext + Create_sequence() ICreate_sequenceContext + Create_spfile() ICreate_spfileContext + Create_synonym() ICreate_synonymContext + Create_table() ICreate_tableContext + Create_tablespace() ICreate_tablespaceContext + Create_tablespace_set() ICreate_tablespace_setContext + Create_trigger() ICreate_triggerContext + Create_type() ICreate_typeContext + Create_user() ICreate_userContext + Create_view() ICreate_viewContext + Drop_analytic_view() IDrop_analytic_viewContext + Drop_attribute_dimension() IDrop_attribute_dimensionContext + Drop_audit_policy() IDrop_audit_policyContext + Drop_cluster() IDrop_clusterContext + Drop_context() IDrop_contextContext + Drop_database() IDrop_databaseContext + Drop_database_link() IDrop_database_linkContext + Drop_directory() IDrop_directoryContext + Drop_diskgroup() IDrop_diskgroupContext + Drop_edition() IDrop_editionContext + Drop_flashback_archive() IDrop_flashback_archiveContext + Drop_function() IDrop_functionContext + Drop_hierarchy() IDrop_hierarchyContext + Drop_index() IDrop_indexContext + Drop_indextype() IDrop_indextypeContext + Drop_inmemory_join_group() IDrop_inmemory_join_groupContext + Drop_java() IDrop_javaContext + Drop_library() IDrop_libraryContext + Drop_lockdown_profile() IDrop_lockdown_profileContext + Drop_materialized_view() IDrop_materialized_viewContext + Drop_materialized_view_log() IDrop_materialized_view_logContext + Drop_materialized_zonemap() IDrop_materialized_zonemapContext + Drop_operator() IDrop_operatorContext + Drop_outline() IDrop_outlineContext + Drop_package() IDrop_packageContext + Drop_pmem_filestore() IDrop_pmem_filestoreContext + Drop_procedure() IDrop_procedureContext + Drop_restore_point() IDrop_restore_pointContext + Drop_role() IDrop_roleContext + Drop_rollback_segment() IDrop_rollback_segmentContext + Drop_sequence() IDrop_sequenceContext + Drop_synonym() IDrop_synonymContext + Drop_table() IDrop_tableContext + Drop_tablespace() IDrop_tablespaceContext + Drop_tablespace_set() IDrop_tablespace_setContext + Drop_trigger() IDrop_triggerContext + Drop_type() IDrop_typeContext + Drop_user() IDrop_userContext + Drop_view() IDrop_viewContext + Administer_key_management() IAdminister_key_managementContext + Analyze() IAnalyzeContext + Associate_statistics() IAssociate_statisticsContext + Audit_traditional() IAudit_traditionalContext + Comment_on_column() IComment_on_columnContext + Comment_on_materialized() IComment_on_materializedContext + Comment_on_table() IComment_on_tableContext + Data_manipulation_language_statements() IData_manipulation_language_statementsContext + Disassociate_statistics() IDisassociate_statisticsContext + Flashback_table() IFlashback_tableContext + Grant_statement() IGrant_statementContext + Noaudit_statement() INoaudit_statementContext + Purge_statement() IPurge_statementContext + Rename_object() IRename_objectContext + Revoke_statement() IRevoke_statementContext + Transaction_control_statements() ITransaction_control_statementsContext + Truncate_cluster() ITruncate_clusterContext + Truncate_table() ITruncate_tableContext + Unified_auditing() IUnified_auditingContext + + // IsUnit_statementContext differentiates from other interfaces. + IsUnit_statementContext() +} + +type Unit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnit_statementContext() *Unit_statementContext { + var p = new(Unit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unit_statement + return p +} + +func InitEmptyUnit_statementContext(p *Unit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unit_statement +} + +func (*Unit_statementContext) IsUnit_statementContext() {} + +func NewUnit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unit_statementContext { + var p = new(Unit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unit_statement + + return p +} + +func (s *Unit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unit_statementContext) Alter_analytic_view() IAlter_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_analytic_viewContext) +} + +func (s *Unit_statementContext) Alter_attribute_dimension() IAlter_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Alter_audit_policy() IAlter_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_audit_policyContext) +} + +func (s *Unit_statementContext) Alter_cluster() IAlter_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_clusterContext) +} + +func (s *Unit_statementContext) Alter_database() IAlter_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_databaseContext) +} + +func (s *Unit_statementContext) Alter_database_link() IAlter_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_database_linkContext) +} + +func (s *Unit_statementContext) Alter_dimension() IAlter_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_dimensionContext) +} + +func (s *Unit_statementContext) Alter_diskgroup() IAlter_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_diskgroupContext) +} + +func (s *Unit_statementContext) Alter_flashback_archive() IAlter_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_flashback_archiveContext) +} + +func (s *Unit_statementContext) Alter_function() IAlter_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_functionContext) +} + +func (s *Unit_statementContext) Alter_hierarchy() IAlter_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_hierarchyContext) +} + +func (s *Unit_statementContext) Alter_index() IAlter_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_indexContext) +} + +func (s *Unit_statementContext) Alter_inmemory_join_group() IAlter_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Alter_java() IAlter_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_javaContext) +} + +func (s *Unit_statementContext) Alter_library() IAlter_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_libraryContext) +} + +func (s *Unit_statementContext) Alter_lockdown_profile() IAlter_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_lockdown_profileContext) +} + +func (s *Unit_statementContext) Alter_materialized_view() IAlter_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_viewContext) +} + +func (s *Unit_statementContext) Alter_materialized_view_log() IAlter_materialized_view_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_view_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_view_logContext) +} + +func (s *Unit_statementContext) Alter_materialized_zonemap() IAlter_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Alter_operator() IAlter_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_operatorContext) +} + +func (s *Unit_statementContext) Alter_outline() IAlter_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_outlineContext) +} + +func (s *Unit_statementContext) Alter_package() IAlter_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_packageContext) +} + +func (s *Unit_statementContext) Alter_pmem_filestore() IAlter_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_pmem_filestoreContext) +} + +func (s *Unit_statementContext) Alter_procedure() IAlter_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_procedureContext) +} + +func (s *Unit_statementContext) Alter_resource_cost() IAlter_resource_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_resource_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_resource_costContext) +} + +func (s *Unit_statementContext) Alter_role() IAlter_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_roleContext) +} + +func (s *Unit_statementContext) Alter_rollback_segment() IAlter_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_rollback_segmentContext) +} + +func (s *Unit_statementContext) Alter_sequence() IAlter_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_sequenceContext) +} + +func (s *Unit_statementContext) Alter_session() IAlter_sessionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_sessionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_sessionContext) +} + +func (s *Unit_statementContext) Alter_synonym() IAlter_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_synonymContext) +} + +func (s *Unit_statementContext) Alter_table() IAlter_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tableContext) +} + +func (s *Unit_statementContext) Alter_tablespace() IAlter_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespaceContext) +} + +func (s *Unit_statementContext) Alter_tablespace_set() IAlter_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_setContext) +} + +func (s *Unit_statementContext) Alter_trigger() IAlter_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_triggerContext) +} + +func (s *Unit_statementContext) Alter_type() IAlter_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_typeContext) +} + +func (s *Unit_statementContext) Alter_user() IAlter_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_userContext) +} + +func (s *Unit_statementContext) Alter_view() IAlter_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_viewContext) +} + +func (s *Unit_statementContext) Anonymous_block() IAnonymous_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnonymous_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnonymous_blockContext) +} + +func (s *Unit_statementContext) Call_statement() ICall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_statementContext) +} + +func (s *Unit_statementContext) Create_analytic_view() ICreate_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_analytic_viewContext) +} + +func (s *Unit_statementContext) Create_attribute_dimension() ICreate_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Create_audit_policy() ICreate_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_audit_policyContext) +} + +func (s *Unit_statementContext) Create_cluster() ICreate_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_clusterContext) +} + +func (s *Unit_statementContext) Create_context() ICreate_contextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_contextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_contextContext) +} + +func (s *Unit_statementContext) Create_controlfile() ICreate_controlfileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_controlfileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_controlfileContext) +} + +func (s *Unit_statementContext) Create_schema() ICreate_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_schemaContext) +} + +func (s *Unit_statementContext) Create_database() ICreate_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_databaseContext) +} + +func (s *Unit_statementContext) Create_database_link() ICreate_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_database_linkContext) +} + +func (s *Unit_statementContext) Create_dimension() ICreate_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_dimensionContext) +} + +func (s *Unit_statementContext) Create_directory() ICreate_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_directoryContext) +} + +func (s *Unit_statementContext) Create_diskgroup() ICreate_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_diskgroupContext) +} + +func (s *Unit_statementContext) Create_edition() ICreate_editionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_editionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_editionContext) +} + +func (s *Unit_statementContext) Create_flashback_archive() ICreate_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_flashback_archiveContext) +} + +func (s *Unit_statementContext) Create_function_body() ICreate_function_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_function_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_function_bodyContext) +} + +func (s *Unit_statementContext) Create_hierarchy() ICreate_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_hierarchyContext) +} + +func (s *Unit_statementContext) Create_index() ICreate_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_indexContext) +} + +func (s *Unit_statementContext) Create_inmemory_join_group() ICreate_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Create_java() ICreate_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_javaContext) +} + +func (s *Unit_statementContext) Create_library() ICreate_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_libraryContext) +} + +func (s *Unit_statementContext) Create_lockdown_profile() ICreate_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_lockdown_profileContext) +} + +func (s *Unit_statementContext) Create_materialized_view() ICreate_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_viewContext) +} + +func (s *Unit_statementContext) Create_materialized_view_log() ICreate_materialized_view_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_view_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_view_logContext) +} + +func (s *Unit_statementContext) Create_materialized_zonemap() ICreate_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Create_operator() ICreate_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_operatorContext) +} + +func (s *Unit_statementContext) Create_outline() ICreate_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_outlineContext) +} + +func (s *Unit_statementContext) Create_package() ICreate_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_packageContext) +} + +func (s *Unit_statementContext) Create_package_body() ICreate_package_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_package_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_package_bodyContext) +} + +func (s *Unit_statementContext) Create_pmem_filestore() ICreate_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_pmem_filestoreContext) +} + +func (s *Unit_statementContext) Create_procedure_body() ICreate_procedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_procedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_procedure_bodyContext) +} + +func (s *Unit_statementContext) Create_profile() ICreate_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_profileContext) +} + +func (s *Unit_statementContext) Create_restore_point() ICreate_restore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_restore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_restore_pointContext) +} + +func (s *Unit_statementContext) Create_role() ICreate_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_roleContext) +} + +func (s *Unit_statementContext) Create_rollback_segment() ICreate_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_rollback_segmentContext) +} + +func (s *Unit_statementContext) Create_sequence() ICreate_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_sequenceContext) +} + +func (s *Unit_statementContext) Create_spfile() ICreate_spfileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_spfileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_spfileContext) +} + +func (s *Unit_statementContext) Create_synonym() ICreate_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_synonymContext) +} + +func (s *Unit_statementContext) Create_table() ICreate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tableContext) +} + +func (s *Unit_statementContext) Create_tablespace() ICreate_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tablespaceContext) +} + +func (s *Unit_statementContext) Create_tablespace_set() ICreate_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tablespace_setContext) +} + +func (s *Unit_statementContext) Create_trigger() ICreate_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_triggerContext) +} + +func (s *Unit_statementContext) Create_type() ICreate_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_typeContext) +} + +func (s *Unit_statementContext) Create_user() ICreate_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_userContext) +} + +func (s *Unit_statementContext) Create_view() ICreate_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_viewContext) +} + +func (s *Unit_statementContext) Drop_analytic_view() IDrop_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_analytic_viewContext) +} + +func (s *Unit_statementContext) Drop_attribute_dimension() IDrop_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Drop_audit_policy() IDrop_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_audit_policyContext) +} + +func (s *Unit_statementContext) Drop_cluster() IDrop_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_clusterContext) +} + +func (s *Unit_statementContext) Drop_context() IDrop_contextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_contextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_contextContext) +} + +func (s *Unit_statementContext) Drop_database() IDrop_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_databaseContext) +} + +func (s *Unit_statementContext) Drop_database_link() IDrop_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_database_linkContext) +} + +func (s *Unit_statementContext) Drop_directory() IDrop_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_directoryContext) +} + +func (s *Unit_statementContext) Drop_diskgroup() IDrop_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_diskgroupContext) +} + +func (s *Unit_statementContext) Drop_edition() IDrop_editionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_editionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_editionContext) +} + +func (s *Unit_statementContext) Drop_flashback_archive() IDrop_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_flashback_archiveContext) +} + +func (s *Unit_statementContext) Drop_function() IDrop_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_functionContext) +} + +func (s *Unit_statementContext) Drop_hierarchy() IDrop_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_hierarchyContext) +} + +func (s *Unit_statementContext) Drop_index() IDrop_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_indexContext) +} + +func (s *Unit_statementContext) Drop_indextype() IDrop_indextypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_indextypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_indextypeContext) +} + +func (s *Unit_statementContext) Drop_inmemory_join_group() IDrop_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Drop_java() IDrop_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_javaContext) +} + +func (s *Unit_statementContext) Drop_library() IDrop_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_libraryContext) +} + +func (s *Unit_statementContext) Drop_lockdown_profile() IDrop_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_lockdown_profileContext) +} + +func (s *Unit_statementContext) Drop_materialized_view() IDrop_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_materialized_viewContext) +} + +func (s *Unit_statementContext) Drop_materialized_view_log() IDrop_materialized_view_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_materialized_view_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_materialized_view_logContext) +} + +func (s *Unit_statementContext) Drop_materialized_zonemap() IDrop_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Drop_operator() IDrop_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_operatorContext) +} + +func (s *Unit_statementContext) Drop_outline() IDrop_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_outlineContext) +} + +func (s *Unit_statementContext) Drop_package() IDrop_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_packageContext) +} + +func (s *Unit_statementContext) Drop_pmem_filestore() IDrop_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_pmem_filestoreContext) +} + +func (s *Unit_statementContext) Drop_procedure() IDrop_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_procedureContext) +} + +func (s *Unit_statementContext) Drop_restore_point() IDrop_restore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_restore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_restore_pointContext) +} + +func (s *Unit_statementContext) Drop_role() IDrop_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_roleContext) +} + +func (s *Unit_statementContext) Drop_rollback_segment() IDrop_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_rollback_segmentContext) +} + +func (s *Unit_statementContext) Drop_sequence() IDrop_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_sequenceContext) +} + +func (s *Unit_statementContext) Drop_synonym() IDrop_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_synonymContext) +} + +func (s *Unit_statementContext) Drop_table() IDrop_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tableContext) +} + +func (s *Unit_statementContext) Drop_tablespace() IDrop_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tablespaceContext) +} + +func (s *Unit_statementContext) Drop_tablespace_set() IDrop_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tablespace_setContext) +} + +func (s *Unit_statementContext) Drop_trigger() IDrop_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_triggerContext) +} + +func (s *Unit_statementContext) Drop_type() IDrop_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_typeContext) +} + +func (s *Unit_statementContext) Drop_user() IDrop_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_userContext) +} + +func (s *Unit_statementContext) Drop_view() IDrop_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_viewContext) +} + +func (s *Unit_statementContext) Administer_key_management() IAdminister_key_managementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdminister_key_managementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdminister_key_managementContext) +} + +func (s *Unit_statementContext) Analyze() IAnalyzeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzeContext) +} + +func (s *Unit_statementContext) Associate_statistics() IAssociate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssociate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssociate_statisticsContext) +} + +func (s *Unit_statementContext) Audit_traditional() IAudit_traditionalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_traditionalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_traditionalContext) +} + +func (s *Unit_statementContext) Comment_on_column() IComment_on_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_columnContext) +} + +func (s *Unit_statementContext) Comment_on_materialized() IComment_on_materializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_materializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_materializedContext) +} + +func (s *Unit_statementContext) Comment_on_table() IComment_on_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_tableContext) +} + +func (s *Unit_statementContext) Data_manipulation_language_statements() IData_manipulation_language_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_manipulation_language_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_manipulation_language_statementsContext) +} + +func (s *Unit_statementContext) Disassociate_statistics() IDisassociate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisassociate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisassociate_statisticsContext) +} + +func (s *Unit_statementContext) Flashback_table() IFlashback_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_tableContext) +} + +func (s *Unit_statementContext) Grant_statement() IGrant_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_statementContext) +} + +func (s *Unit_statementContext) Noaudit_statement() INoaudit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INoaudit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INoaudit_statementContext) +} + +func (s *Unit_statementContext) Purge_statement() IPurge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPurge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPurge_statementContext) +} + +func (s *Unit_statementContext) Rename_object() IRename_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_objectContext) +} + +func (s *Unit_statementContext) Revoke_statement() IRevoke_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_statementContext) +} + +func (s *Unit_statementContext) Transaction_control_statements() ITransaction_control_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_control_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_control_statementsContext) +} + +func (s *Unit_statementContext) Truncate_cluster() ITruncate_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_clusterContext) +} + +func (s *Unit_statementContext) Truncate_table() ITruncate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_tableContext) +} + +func (s *Unit_statementContext) Unified_auditing() IUnified_auditingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnified_auditingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnified_auditingContext) +} + +func (s *Unit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnit_statement(s) + } +} + +func (s *Unit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnit_statement(s) + } +} + +func (p *PlSqlParser) Unit_statement() (localctx IUnit_statementContext) { + localctx = NewUnit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, PlSqlParserRULE_unit_statement) + p.SetState(2593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2452) + p.Alter_analytic_view() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2453) + p.Alter_attribute_dimension() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2454) + p.Alter_audit_policy() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2455) + p.Alter_cluster() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2456) + p.Alter_database() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2457) + p.Alter_database_link() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2458) + p.Alter_dimension() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2459) + p.Alter_diskgroup() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2460) + p.Alter_flashback_archive() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2461) + p.Alter_function() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2462) + p.Alter_hierarchy() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2463) + p.Alter_index() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2464) + p.Alter_inmemory_join_group() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2465) + p.Alter_java() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2466) + p.Alter_library() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2467) + p.Alter_lockdown_profile() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2468) + p.Alter_materialized_view() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2469) + p.Alter_materialized_view_log() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2470) + p.Alter_materialized_zonemap() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2471) + p.Alter_operator() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2472) + p.Alter_outline() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2473) + p.Alter_package() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2474) + p.Alter_pmem_filestore() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2475) + p.Alter_procedure() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2476) + p.Alter_resource_cost() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2477) + p.Alter_role() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2478) + p.Alter_rollback_segment() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2479) + p.Alter_sequence() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2480) + p.Alter_session() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2481) + p.Alter_synonym() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2482) + p.Alter_table() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2483) + p.Alter_tablespace() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2484) + p.Alter_tablespace_set() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2485) + p.Alter_trigger() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2486) + p.Alter_type() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2487) + p.Alter_user() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2488) + p.Alter_view() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(2489) + p.Anonymous_block() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(2490) + p.Call_statement() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(2491) + p.Create_analytic_view() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(2492) + p.Create_attribute_dimension() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(2493) + p.Create_audit_policy() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(2494) + p.Create_cluster() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(2495) + p.Create_context() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(2496) + p.Create_controlfile() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(2497) + p.Create_schema() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(2498) + p.Create_database() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(2499) + p.Create_database_link() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(2500) + p.Create_dimension() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(2501) + p.Create_directory() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(2502) + p.Create_diskgroup() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(2503) + p.Create_edition() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(2504) + p.Create_flashback_archive() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(2505) + p.Create_function_body() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(2506) + p.Create_hierarchy() + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(2507) + p.Create_index() + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(2508) + p.Create_inmemory_join_group() + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(2509) + p.Create_java() + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(2510) + p.Create_library() + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(2511) + p.Create_lockdown_profile() + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(2512) + p.Create_materialized_view() + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(2513) + p.Create_materialized_view_log() + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(2514) + p.Create_materialized_zonemap() + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(2515) + p.Create_operator() + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(2516) + p.Create_outline() + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(2517) + p.Create_package() + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(2518) + p.Create_package_body() + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(2519) + p.Create_pmem_filestore() + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(2520) + p.Create_procedure_body() + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(2521) + p.Create_profile() + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(2522) + p.Create_restore_point() + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(2523) + p.Create_role() + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(2524) + p.Create_rollback_segment() + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(2525) + p.Create_sequence() + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(2526) + p.Create_spfile() + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(2527) + p.Create_synonym() + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(2528) + p.Create_table() + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(2529) + p.Create_tablespace() + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(2530) + p.Create_tablespace_set() + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(2531) + p.Create_trigger() + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(2532) + p.Create_type() + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(2533) + p.Create_user() + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(2534) + p.Create_view() + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(2535) + p.Drop_analytic_view() + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(2536) + p.Drop_attribute_dimension() + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(2537) + p.Drop_audit_policy() + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(2538) + p.Drop_cluster() + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(2539) + p.Drop_context() + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(2540) + p.Drop_database() + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(2541) + p.Drop_database_link() + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(2542) + p.Drop_directory() + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(2543) + p.Drop_diskgroup() + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(2544) + p.Drop_edition() + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(2545) + p.Drop_flashback_archive() + } + + case 95: + p.EnterOuterAlt(localctx, 95) + { + p.SetState(2546) + p.Drop_function() + } + + case 96: + p.EnterOuterAlt(localctx, 96) + { + p.SetState(2547) + p.Drop_hierarchy() + } + + case 97: + p.EnterOuterAlt(localctx, 97) + { + p.SetState(2548) + p.Drop_index() + } + + case 98: + p.EnterOuterAlt(localctx, 98) + { + p.SetState(2549) + p.Drop_indextype() + } + + case 99: + p.EnterOuterAlt(localctx, 99) + { + p.SetState(2550) + p.Drop_inmemory_join_group() + } + + case 100: + p.EnterOuterAlt(localctx, 100) + { + p.SetState(2551) + p.Drop_java() + } + + case 101: + p.EnterOuterAlt(localctx, 101) + { + p.SetState(2552) + p.Drop_library() + } + + case 102: + p.EnterOuterAlt(localctx, 102) + { + p.SetState(2553) + p.Drop_lockdown_profile() + } + + case 103: + p.EnterOuterAlt(localctx, 103) + { + p.SetState(2554) + p.Drop_materialized_view() + } + + case 104: + p.EnterOuterAlt(localctx, 104) + { + p.SetState(2555) + p.Drop_materialized_view_log() + } + + case 105: + p.EnterOuterAlt(localctx, 105) + { + p.SetState(2556) + p.Drop_materialized_zonemap() + } + + case 106: + p.EnterOuterAlt(localctx, 106) + { + p.SetState(2557) + p.Drop_operator() + } + + case 107: + p.EnterOuterAlt(localctx, 107) + { + p.SetState(2558) + p.Drop_outline() + } + + case 108: + p.EnterOuterAlt(localctx, 108) + { + p.SetState(2559) + p.Drop_package() + } + + case 109: + p.EnterOuterAlt(localctx, 109) + { + p.SetState(2560) + p.Drop_pmem_filestore() + } + + case 110: + p.EnterOuterAlt(localctx, 110) + { + p.SetState(2561) + p.Drop_procedure() + } + + case 111: + p.EnterOuterAlt(localctx, 111) + { + p.SetState(2562) + p.Drop_restore_point() + } + + case 112: + p.EnterOuterAlt(localctx, 112) + { + p.SetState(2563) + p.Drop_role() + } + + case 113: + p.EnterOuterAlt(localctx, 113) + { + p.SetState(2564) + p.Drop_rollback_segment() + } + + case 114: + p.EnterOuterAlt(localctx, 114) + { + p.SetState(2565) + p.Drop_sequence() + } + + case 115: + p.EnterOuterAlt(localctx, 115) + { + p.SetState(2566) + p.Drop_synonym() + } + + case 116: + p.EnterOuterAlt(localctx, 116) + { + p.SetState(2567) + p.Drop_table() + } + + case 117: + p.EnterOuterAlt(localctx, 117) + { + p.SetState(2568) + p.Drop_tablespace() + } + + case 118: + p.EnterOuterAlt(localctx, 118) + { + p.SetState(2569) + p.Drop_tablespace_set() + } + + case 119: + p.EnterOuterAlt(localctx, 119) + { + p.SetState(2570) + p.Drop_trigger() + } + + case 120: + p.EnterOuterAlt(localctx, 120) + { + p.SetState(2571) + p.Drop_type() + } + + case 121: + p.EnterOuterAlt(localctx, 121) + { + p.SetState(2572) + p.Drop_user() + } + + case 122: + p.EnterOuterAlt(localctx, 122) + { + p.SetState(2573) + p.Drop_view() + } + + case 123: + p.EnterOuterAlt(localctx, 123) + { + p.SetState(2574) + p.Administer_key_management() + } + + case 124: + p.EnterOuterAlt(localctx, 124) + { + p.SetState(2575) + p.Analyze() + } + + case 125: + p.EnterOuterAlt(localctx, 125) + { + p.SetState(2576) + p.Associate_statistics() + } + + case 126: + p.EnterOuterAlt(localctx, 126) + { + p.SetState(2577) + p.Audit_traditional() + } + + case 127: + p.EnterOuterAlt(localctx, 127) + { + p.SetState(2578) + p.Comment_on_column() + } + + case 128: + p.EnterOuterAlt(localctx, 128) + { + p.SetState(2579) + p.Comment_on_materialized() + } + + case 129: + p.EnterOuterAlt(localctx, 129) + { + p.SetState(2580) + p.Comment_on_table() + } + + case 130: + p.EnterOuterAlt(localctx, 130) + { + p.SetState(2581) + p.Data_manipulation_language_statements() + } + + case 131: + p.EnterOuterAlt(localctx, 131) + { + p.SetState(2582) + p.Disassociate_statistics() + } + + case 132: + p.EnterOuterAlt(localctx, 132) + { + p.SetState(2583) + p.Flashback_table() + } + + case 133: + p.EnterOuterAlt(localctx, 133) + { + p.SetState(2584) + p.Grant_statement() + } + + case 134: + p.EnterOuterAlt(localctx, 134) + { + p.SetState(2585) + p.Noaudit_statement() + } + + case 135: + p.EnterOuterAlt(localctx, 135) + { + p.SetState(2586) + p.Purge_statement() + } + + case 136: + p.EnterOuterAlt(localctx, 136) + { + p.SetState(2587) + p.Rename_object() + } + + case 137: + p.EnterOuterAlt(localctx, 137) + { + p.SetState(2588) + p.Revoke_statement() + } + + case 138: + p.EnterOuterAlt(localctx, 138) + { + p.SetState(2589) + p.Transaction_control_statements() + } + + case 139: + p.EnterOuterAlt(localctx, 139) + { + p.SetState(2590) + p.Truncate_cluster() + } + + case 140: + p.EnterOuterAlt(localctx, 140) + { + p.SetState(2591) + p.Truncate_table() + } + + case 141: + p.EnterOuterAlt(localctx, 141) + { + p.SetState(2592) + p.Unified_auditing() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_diskgroupContext is an interface to support dynamic dispatch. +type IAlter_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ALL() antlr.TerminalNode + Undrop_disk_clause() IUndrop_disk_clauseContext + Diskgroup_availability() IDiskgroup_availabilityContext + Enable_disable_volume() IEnable_disable_volumeContext + Resize_disk_clause() IResize_disk_clauseContext + Replace_disk_clause() IReplace_disk_clauseContext + Rename_disk_clause() IRename_disk_clauseContext + Disk_online_clause() IDisk_online_clauseContext + Disk_offline_clause() IDisk_offline_clauseContext + Rebalance_diskgroup_clause() IRebalance_diskgroup_clauseContext + Check_diskgroup_clause() ICheck_diskgroup_clauseContext + Diskgroup_template_clauses() IDiskgroup_template_clausesContext + Diskgroup_directory_clauses() IDiskgroup_directory_clausesContext + Diskgroup_alias_clauses() IDiskgroup_alias_clausesContext + Diskgroup_volume_clauses() IDiskgroup_volume_clausesContext + Diskgroup_attributes() IDiskgroup_attributesContext + Drop_diskgroup_file_clause() IDrop_diskgroup_file_clauseContext + Convert_redundancy_clause() IConvert_redundancy_clauseContext + Usergroup_clauses() IUsergroup_clausesContext + User_clauses() IUser_clausesContext + File_permissions_clause() IFile_permissions_clauseContext + File_owner_clause() IFile_owner_clauseContext + Scrub_clause() IScrub_clauseContext + Quotagroup_clauses() IQuotagroup_clausesContext + Filegroup_clauses() IFilegroup_clausesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllAdd_disk_clause() []IAdd_disk_clauseContext + Add_disk_clause(i int) IAdd_disk_clauseContext + AllDrop_disk_clause() []IDrop_disk_clauseContext + Drop_disk_clause(i int) IDrop_disk_clauseContext + + // IsAlter_diskgroupContext differentiates from other interfaces. + IsAlter_diskgroupContext() +} + +type Alter_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_diskgroupContext() *Alter_diskgroupContext { + var p = new(Alter_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_diskgroup + return p +} + +func InitEmptyAlter_diskgroupContext(p *Alter_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_diskgroup +} + +func (*Alter_diskgroupContext) IsAlter_diskgroupContext() {} + +func NewAlter_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_diskgroupContext { + var p = new(Alter_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_diskgroup + + return p +} + +func (s *Alter_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_diskgroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Alter_diskgroupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_diskgroupContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_diskgroupContext) Undrop_disk_clause() IUndrop_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_availability() IDiskgroup_availabilityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_availabilityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_availabilityContext) +} + +func (s *Alter_diskgroupContext) Enable_disable_volume() IEnable_disable_volumeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_volumeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_volumeContext) +} + +func (s *Alter_diskgroupContext) Resize_disk_clause() IResize_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResize_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResize_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Replace_disk_clause() IReplace_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Rename_disk_clause() IRename_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Disk_online_clause() IDisk_online_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisk_online_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisk_online_clauseContext) +} + +func (s *Alter_diskgroupContext) Disk_offline_clause() IDisk_offline_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisk_offline_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisk_offline_clauseContext) +} + +func (s *Alter_diskgroupContext) Rebalance_diskgroup_clause() IRebalance_diskgroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebalance_diskgroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebalance_diskgroup_clauseContext) +} + +func (s *Alter_diskgroupContext) Check_diskgroup_clause() ICheck_diskgroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_diskgroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_diskgroup_clauseContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_template_clauses() IDiskgroup_template_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_template_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_template_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_directory_clauses() IDiskgroup_directory_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_directory_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_directory_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_alias_clauses() IDiskgroup_alias_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_alias_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_alias_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_volume_clauses() IDiskgroup_volume_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_volume_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_volume_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_attributes() IDiskgroup_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_attributesContext) +} + +func (s *Alter_diskgroupContext) Drop_diskgroup_file_clause() IDrop_diskgroup_file_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_diskgroup_file_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_diskgroup_file_clauseContext) +} + +func (s *Alter_diskgroupContext) Convert_redundancy_clause() IConvert_redundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvert_redundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvert_redundancy_clauseContext) +} + +func (s *Alter_diskgroupContext) Usergroup_clauses() IUsergroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsergroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsergroup_clausesContext) +} + +func (s *Alter_diskgroupContext) User_clauses() IUser_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_clausesContext) +} + +func (s *Alter_diskgroupContext) File_permissions_clause() IFile_permissions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_permissions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_permissions_clauseContext) +} + +func (s *Alter_diskgroupContext) File_owner_clause() IFile_owner_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_owner_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_owner_clauseContext) +} + +func (s *Alter_diskgroupContext) Scrub_clause() IScrub_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScrub_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScrub_clauseContext) +} + +func (s *Alter_diskgroupContext) Quotagroup_clauses() IQuotagroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuotagroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuotagroup_clausesContext) +} + +func (s *Alter_diskgroupContext) Filegroup_clauses() IFilegroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilegroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilegroup_clausesContext) +} + +func (s *Alter_diskgroupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_diskgroupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_diskgroupContext) AllAdd_disk_clause() []IAdd_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_disk_clauseContext); ok { + tst[i] = t.(IAdd_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Add_disk_clause(i int) IAdd_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) AllDrop_disk_clause() []IDrop_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_disk_clauseContext); ok { + tst[i] = t.(IDrop_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Drop_disk_clause(i int) IDrop_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_diskgroup(s) + } +} + +func (s *Alter_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_diskgroup(s) + } +} + +func (p *PlSqlParser) Alter_diskgroup() (localctx IAlter_diskgroupContext) { + localctx = NewAlter_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, PlSqlParserRULE_alter_diskgroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2595) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2596) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2597) + p.Id_expression() + } + p.SetState(2632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { + case 1: + p.SetState(2605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD, PlSqlParserDROP: + p.SetState(2600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserADD || _la == PlSqlParserDROP { + p.SetState(2600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(2598) + p.Add_disk_clause() + } + + case PlSqlParserDROP: + { + p.SetState(2599) + p.Drop_disk_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserRESIZE: + { + p.SetState(2604) + p.Resize_disk_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREBALANCE { + { + p.SetState(2607) + p.Rebalance_diskgroup_clause() + } + + } + + case 2: + p.SetState(2630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2610) + p.Replace_disk_clause() + } + + case 2: + { + p.SetState(2611) + p.Rename_disk_clause() + } + + case 3: + { + p.SetState(2612) + p.Disk_online_clause() + } + + case 4: + { + p.SetState(2613) + p.Disk_offline_clause() + } + + case 5: + { + p.SetState(2614) + p.Rebalance_diskgroup_clause() + } + + case 6: + { + p.SetState(2615) + p.Check_diskgroup_clause() + } + + case 7: + { + p.SetState(2616) + p.Diskgroup_template_clauses() + } + + case 8: + { + p.SetState(2617) + p.Diskgroup_directory_clauses() + } + + case 9: + { + p.SetState(2618) + p.Diskgroup_alias_clauses() + } + + case 10: + { + p.SetState(2619) + p.Diskgroup_volume_clauses() + } + + case 11: + { + p.SetState(2620) + p.Diskgroup_attributes() + } + + case 12: + { + p.SetState(2621) + p.Drop_diskgroup_file_clause() + } + + case 13: + { + p.SetState(2622) + p.Convert_redundancy_clause() + } + + case 14: + { + p.SetState(2623) + p.Usergroup_clauses() + } + + case 15: + { + p.SetState(2624) + p.User_clauses() + } + + case 16: + { + p.SetState(2625) + p.File_permissions_clause() + } + + case 17: + { + p.SetState(2626) + p.File_owner_clause() + } + + case 18: + { + p.SetState(2627) + p.Scrub_clause() + } + + case 19: + { + p.SetState(2628) + p.Quotagroup_clauses() + } + + case 20: + { + p.SetState(2629) + p.Filegroup_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.SetState(2643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(2634) + p.Id_expression() + } + p.SetState(2639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2635) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2636) + p.Id_expression() + } + + p.SetState(2641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(2642) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNDROP: + { + p.SetState(2645) + p.Undrop_disk_clause() + } + + case PlSqlParserDISMOUNT, PlSqlParserMOUNT: + { + p.SetState(2646) + p.Diskgroup_availability() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(2647) + p.Enable_disable_volume() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_disk_clauseContext is an interface to support dynamic dispatch. +type IAdd_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetFgn returns the fgn rule contexts. + GetFgn() IId_expressionContext + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetFgn sets the fgn rule contexts. + SetFgn(IId_expressionContext) + + // Getter signatures + ADD() antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllQualified_disk_clause() []IQualified_disk_clauseContext + Qualified_disk_clause(i int) IQualified_disk_clauseContext + AllSITE() []antlr.TerminalNode + SITE(i int) antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsAdd_disk_clauseContext differentiates from other interfaces. + IsAdd_disk_clauseContext() +} + +type Add_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + sn IId_expressionContext + fgn IId_expressionContext +} + +func NewEmptyAdd_disk_clauseContext() *Add_disk_clauseContext { + var p = new(Add_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_disk_clause + return p +} + +func InitEmptyAdd_disk_clauseContext(p *Add_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_disk_clause +} + +func (*Add_disk_clauseContext) IsAdd_disk_clauseContext() {} + +func NewAdd_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_disk_clauseContext { + var p = new(Add_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_disk_clause + + return p +} + +func (s *Add_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_disk_clauseContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Add_disk_clauseContext) GetFgn() IId_expressionContext { return s.fgn } + +func (s *Add_disk_clauseContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Add_disk_clauseContext) SetFgn(v IId_expressionContext) { s.fgn = v } + +func (s *Add_disk_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_disk_clauseContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Add_disk_clauseContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Add_disk_clauseContext) AllQualified_disk_clause() []IQualified_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_disk_clauseContext); ok { + tst[i] = t.(IQualified_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Qualified_disk_clause(i int) IQualified_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_disk_clauseContext) +} + +func (s *Add_disk_clauseContext) AllSITE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSITE) +} + +func (s *Add_disk_clauseContext) SITE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, i) +} + +func (s *Add_disk_clauseContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Add_disk_clauseContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Add_disk_clauseContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Add_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_disk_clause(s) + } +} + +func (s *Add_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_disk_clause(s) + } +} + +func (p *PlSqlParser) Add_disk_clause() (localctx IAdd_disk_clauseContext) { + localctx = NewAdd_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, PlSqlParserRULE_add_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2652) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISK || _la == PlSqlParserFAILGROUP || _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR || _la == PlSqlParserSITE { + p.SetState(2655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSITE { + { + p.SetState(2653) + p.Match(PlSqlParserSITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2654) + + var _x = p.Id_expression() + + localctx.(*Add_disk_clauseContext).sn = _x + } + + } + p.SetState(2658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2657) + p.Quorum_regular() + } + + } + p.SetState(2662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFAILGROUP { + { + p.SetState(2660) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2661) + + var _x = p.Id_expression() + + localctx.(*Add_disk_clauseContext).fgn = _x + } + + } + { + p.SetState(2664) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2665) + p.Qualified_disk_clause() + } + p.SetState(2670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2666) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2667) + p.Qualified_disk_clause() + } + + p.SetState(2672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(2675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_disk_clauseContext is an interface to support dynamic dispatch. +type IDrop_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DISKS() antlr.TerminalNode + IN() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + Quorum_regular() IQuorum_regularContext + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_disk_clauseContext differentiates from other interfaces. + IsDrop_disk_clauseContext() +} + +type Drop_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_disk_clauseContext() *Drop_disk_clauseContext { + var p = new(Drop_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_disk_clause + return p +} + +func InitEmptyDrop_disk_clauseContext(p *Drop_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_disk_clause +} + +func (*Drop_disk_clauseContext) IsDrop_disk_clauseContext() {} + +func NewDrop_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_disk_clauseContext { + var p = new(Drop_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_disk_clause + + return p +} + +func (s *Drop_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_disk_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Drop_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Drop_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Drop_disk_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Drop_disk_clauseContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Drop_disk_clauseContext) Quorum_regular() IQuorum_regularContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Drop_disk_clauseContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Drop_disk_clauseContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Drop_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_disk_clause(s) + } +} + +func (s *Drop_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_disk_clause(s) + } +} + +func (p *PlSqlParser) Drop_disk_clause() (localctx IDrop_disk_clauseContext) { + localctx = NewDrop_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, PlSqlParserRULE_drop_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2677) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2678) + p.Quorum_regular() + } + + } + { + p.SetState(2681) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2682) + p.Id_expression() + } + p.SetState(2684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2683) + p.Force_noforce() + } + + } + p.SetState(2693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2686) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2687) + p.Id_expression() + } + p.SetState(2689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2688) + p.Force_noforce() + } + + } + + p.SetState(2695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDISKS: + { + p.SetState(2696) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2697) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2698) + p.Quorum_regular() + } + + } + { + p.SetState(2701) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2702) + p.Id_expression() + } + p.SetState(2704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2703) + p.Force_noforce() + } + + } + p.SetState(2713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2706) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2707) + p.Id_expression() + } + p.SetState(2709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2708) + p.Force_noforce() + } + + } + + p.SetState(2715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResize_disk_clauseContext is an interface to support dynamic dispatch. +type IResize_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESIZE() antlr.TerminalNode + ALL() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsResize_disk_clauseContext differentiates from other interfaces. + IsResize_disk_clauseContext() +} + +type Resize_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResize_disk_clauseContext() *Resize_disk_clauseContext { + var p = new(Resize_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resize_disk_clause + return p +} + +func InitEmptyResize_disk_clauseContext(p *Resize_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resize_disk_clause +} + +func (*Resize_disk_clauseContext) IsResize_disk_clauseContext() {} + +func NewResize_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resize_disk_clauseContext { + var p = new(Resize_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resize_disk_clause + + return p +} + +func (s *Resize_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resize_disk_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Resize_disk_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Resize_disk_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Resize_disk_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Resize_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resize_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resize_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResize_disk_clause(s) + } +} + +func (s *Resize_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResize_disk_clause(s) + } +} + +func (p *PlSqlParser) Resize_disk_clause() (localctx IResize_disk_clauseContext) { + localctx = NewResize_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, PlSqlParserRULE_resize_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2718) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2719) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(2720) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2721) + p.Size_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_disk_clauseContext is an interface to support dynamic dispatch. +type IReplace_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + Wait_nowait() IWait_nowaitContext + + // IsReplace_disk_clauseContext differentiates from other interfaces. + IsReplace_disk_clauseContext() +} + +type Replace_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_disk_clauseContext() *Replace_disk_clauseContext { + var p = new(Replace_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_disk_clause + return p +} + +func InitEmptyReplace_disk_clauseContext(p *Replace_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_disk_clause +} + +func (*Replace_disk_clauseContext) IsReplace_disk_clauseContext() {} + +func NewReplace_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_disk_clauseContext { + var p = new(Replace_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replace_disk_clause + + return p +} + +func (s *Replace_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_disk_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Replace_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Replace_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Replace_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Replace_disk_clauseContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Replace_disk_clauseContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Replace_disk_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Replace_disk_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Replace_disk_clauseContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Replace_disk_clauseContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Replace_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Replace_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Replace_disk_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Replace_disk_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Replace_disk_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Replace_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplace_disk_clause(s) + } +} + +func (s *Replace_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplace_disk_clause(s) + } +} + +func (p *PlSqlParser) Replace_disk_clause() (localctx IReplace_disk_clauseContext) { + localctx = NewReplace_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, PlSqlParserRULE_replace_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2724) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2725) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2726) + p.Id_expression() + } + { + p.SetState(2727) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2728) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2729) + p.Force_noforce() + } + + } + p.SetState(2741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2732) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2733) + p.Id_expression() + } + { + p.SetState(2734) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2735) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2736) + p.Force_noforce() + } + + } + + p.SetState(2743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(2746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOWER { + { + p.SetState(2744) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2745) + p.Numeric() + } + + } + p.SetState(2749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + { + p.SetState(2748) + p.Wait_nowait() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWait_nowaitContext is an interface to support dynamic dispatch. +type IWait_nowaitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + + // IsWait_nowaitContext differentiates from other interfaces. + IsWait_nowaitContext() +} + +type Wait_nowaitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWait_nowaitContext() *Wait_nowaitContext { + var p = new(Wait_nowaitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait + return p +} + +func InitEmptyWait_nowaitContext(p *Wait_nowaitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait +} + +func (*Wait_nowaitContext) IsWait_nowaitContext() {} + +func NewWait_nowaitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wait_nowaitContext { + var p = new(Wait_nowaitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_wait_nowait + + return p +} + +func (s *Wait_nowaitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wait_nowaitContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Wait_nowaitContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Wait_nowaitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wait_nowaitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wait_nowaitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWait_nowait(s) + } +} + +func (s *Wait_nowaitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWait_nowait(s) + } +} + +func (p *PlSqlParser) Wait_nowait() (localctx IWait_nowaitContext) { + localctx = NewWait_nowaitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, PlSqlParserRULE_wait_nowait) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2751) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_disk_clauseContext is an interface to support dynamic dispatch. +type IRename_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + DISKS() antlr.TerminalNode + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRename_disk_clauseContext differentiates from other interfaces. + IsRename_disk_clauseContext() +} + +type Rename_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_disk_clauseContext() *Rename_disk_clauseContext { + var p = new(Rename_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_disk_clause + return p +} + +func InitEmptyRename_disk_clauseContext(p *Rename_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_disk_clause +} + +func (*Rename_disk_clauseContext) IsRename_disk_clauseContext() {} + +func NewRename_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_disk_clauseContext { + var p = new(Rename_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_disk_clause + + return p +} + +func (s *Rename_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_disk_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Rename_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Rename_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Rename_disk_clauseContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Rename_disk_clauseContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Rename_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Rename_disk_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Rename_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Rename_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Rename_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_disk_clause(s) + } +} + +func (s *Rename_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_disk_clause(s) + } +} + +func (p *PlSqlParser) Rename_disk_clause() (localctx IRename_disk_clauseContext) { + localctx = NewRename_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, PlSqlParserRULE_rename_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2753) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK: + { + p.SetState(2754) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2755) + p.Id_expression() + } + { + p.SetState(2756) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2757) + p.Id_expression() + } + p.SetState(2765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2758) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2759) + p.Id_expression() + } + { + p.SetState(2760) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2761) + p.Id_expression() + } + + p.SetState(2767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDISKS: + { + p.SetState(2768) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2769) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDisk_online_clauseContext is an interface to support dynamic dispatch. +type IDisk_online_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONLINE() antlr.TerminalNode + ALL() antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + Wait_nowait() IWait_nowaitContext + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllDISKS() []antlr.TerminalNode + DISKS(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisk_online_clauseContext differentiates from other interfaces. + IsDisk_online_clauseContext() +} + +type Disk_online_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisk_online_clauseContext() *Disk_online_clauseContext { + var p = new(Disk_online_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_online_clause + return p +} + +func InitEmptyDisk_online_clauseContext(p *Disk_online_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_online_clause +} + +func (*Disk_online_clauseContext) IsDisk_online_clauseContext() {} + +func NewDisk_online_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disk_online_clauseContext { + var p = new(Disk_online_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disk_online_clause + + return p +} + +func (s *Disk_online_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disk_online_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Disk_online_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Disk_online_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Disk_online_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Disk_online_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Disk_online_clauseContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Disk_online_clauseContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Disk_online_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disk_online_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disk_online_clauseContext) AllDISKS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISKS) +} + +func (s *Disk_online_clauseContext) DISKS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, i) +} + +func (s *Disk_online_clauseContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Disk_online_clauseContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Disk_online_clauseContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Disk_online_clauseContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Disk_online_clauseContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Disk_online_clauseContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Disk_online_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disk_online_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disk_online_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disk_online_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disk_online_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisk_online_clause(s) + } +} + +func (s *Disk_online_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisk_online_clause(s) + } +} + +func (p *PlSqlParser) Disk_online_clause() (localctx IDisk_online_clauseContext) { + localctx = NewDisk_online_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, PlSqlParserRULE_disk_online_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2772) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserDISKS, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISK || _la == PlSqlParserDISKS || _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + p.SetState(2799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2773) + p.Quorum_regular() + } + + } + { + p.SetState(2776) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2777) + p.Id_expression() + } + p.SetState(2782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2778) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2779) + p.Id_expression() + } + + p.SetState(2784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDISKS: + { + p.SetState(2785) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2786) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2787) + p.Quorum_regular() + } + + } + { + p.SetState(2790) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2791) + p.Id_expression() + } + p.SetState(2796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2792) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2793) + p.Id_expression() + } + + p.SetState(2798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(2803) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOWER { + { + p.SetState(2806) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2807) + p.Numeric() + } + + } + p.SetState(2811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + { + p.SetState(2810) + p.Wait_nowait() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDisk_offline_clauseContext is an interface to support dynamic dispatch. +type IDisk_offline_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFLINE() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DISKS() antlr.TerminalNode + IN() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + Timeout_clause() ITimeout_clauseContext + Quorum_regular() IQuorum_regularContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisk_offline_clauseContext differentiates from other interfaces. + IsDisk_offline_clauseContext() +} + +type Disk_offline_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisk_offline_clauseContext() *Disk_offline_clauseContext { + var p = new(Disk_offline_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_offline_clause + return p +} + +func InitEmptyDisk_offline_clauseContext(p *Disk_offline_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_offline_clause +} + +func (*Disk_offline_clauseContext) IsDisk_offline_clauseContext() {} + +func NewDisk_offline_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disk_offline_clauseContext { + var p = new(Disk_offline_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disk_offline_clause + + return p +} + +func (s *Disk_offline_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disk_offline_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Disk_offline_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Disk_offline_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disk_offline_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disk_offline_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Disk_offline_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Disk_offline_clauseContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Disk_offline_clauseContext) Timeout_clause() ITimeout_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeout_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeout_clauseContext) +} + +func (s *Disk_offline_clauseContext) Quorum_regular() IQuorum_regularContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Disk_offline_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disk_offline_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disk_offline_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disk_offline_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disk_offline_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisk_offline_clause(s) + } +} + +func (s *Disk_offline_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisk_offline_clause(s) + } +} + +func (p *PlSqlParser) Disk_offline_clause() (localctx IDisk_offline_clauseContext) { + localctx = NewDisk_offline_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, PlSqlParserRULE_disk_offline_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2813) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2814) + p.Quorum_regular() + } + + } + { + p.SetState(2817) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2818) + p.Id_expression() + } + p.SetState(2823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2819) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2820) + p.Id_expression() + } + + p.SetState(2825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDISKS: + { + p.SetState(2826) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2827) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2828) + p.Quorum_regular() + } + + } + { + p.SetState(2831) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2832) + p.Id_expression() + } + p.SetState(2837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2833) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2834) + p.Id_expression() + } + + p.SetState(2839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP { + { + p.SetState(2842) + p.Timeout_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITimeout_clauseContext is an interface to support dynamic dispatch. +type ITimeout_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + AFTER() antlr.TerminalNode + Numeric() INumericContext + M_LETTER() antlr.TerminalNode + H_LETTER() antlr.TerminalNode + + // IsTimeout_clauseContext differentiates from other interfaces. + IsTimeout_clauseContext() +} + +type Timeout_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTimeout_clauseContext() *Timeout_clauseContext { + var p = new(Timeout_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timeout_clause + return p +} + +func InitEmptyTimeout_clauseContext(p *Timeout_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timeout_clause +} + +func (*Timeout_clauseContext) IsTimeout_clauseContext() {} + +func NewTimeout_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timeout_clauseContext { + var p = new(Timeout_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timeout_clause + + return p +} + +func (s *Timeout_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timeout_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Timeout_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Timeout_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Timeout_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Timeout_clauseContext) H_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserH_LETTER, 0) +} + +func (s *Timeout_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timeout_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timeout_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTimeout_clause(s) + } +} + +func (s *Timeout_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTimeout_clause(s) + } +} + +func (p *PlSqlParser) Timeout_clause() (localctx ITimeout_clauseContext) { + localctx = NewTimeout_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, PlSqlParserRULE_timeout_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2845) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2846) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2847) + p.Numeric() + } + { + p.SetState(2848) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserH_LETTER || _la == PlSqlParserM_LETTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRebalance_diskgroup_clauseContext is an interface to support dynamic dispatch. +type IRebalance_diskgroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBALANCE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + AllPhase() []IPhaseContext + Phase(i int) IPhaseContext + + // IsRebalance_diskgroup_clauseContext differentiates from other interfaces. + IsRebalance_diskgroup_clauseContext() +} + +type Rebalance_diskgroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebalance_diskgroup_clauseContext() *Rebalance_diskgroup_clauseContext { + var p = new(Rebalance_diskgroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause + return p +} + +func InitEmptyRebalance_diskgroup_clauseContext(p *Rebalance_diskgroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause +} + +func (*Rebalance_diskgroup_clauseContext) IsRebalance_diskgroup_clauseContext() {} + +func NewRebalance_diskgroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebalance_diskgroup_clauseContext { + var p = new(Rebalance_diskgroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause + + return p +} + +func (s *Rebalance_diskgroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebalance_diskgroup_clauseContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBALANCE, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Rebalance_diskgroup_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) AllPhase() []IPhaseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhaseContext); ok { + len++ + } + } + + tst := make([]IPhaseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhaseContext); ok { + tst[i] = t.(IPhaseContext) + i++ + } + } + + return tst +} + +func (s *Rebalance_diskgroup_clauseContext) Phase(i int) IPhaseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhaseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhaseContext) +} + +func (s *Rebalance_diskgroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebalance_diskgroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebalance_diskgroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRebalance_diskgroup_clause(s) + } +} + +func (s *Rebalance_diskgroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRebalance_diskgroup_clause(s) + } +} + +func (p *PlSqlParser) Rebalance_diskgroup_clause() (localctx IRebalance_diskgroup_clauseContext) { + localctx = NewRebalance_diskgroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, PlSqlParserRULE_rebalance_diskgroup_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2850) + p.Match(PlSqlParserREBALANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPOWER, PlSqlParserWITHOUT, PlSqlParserWITH: + p.SetState(2857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(2851) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(2852) + p.Phase() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2855) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 56, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + + { + p.SetState(2859) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Numeric() + } + + p.SetState(2863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + { + p.SetState(2862) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserMODIFY: + { + p.SetState(2865) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2866) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT { + { + p.SetState(2867) + p.Numeric() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPhaseContext is an interface to support dynamic dispatch. +type IPhaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsPhaseContext differentiates from other interfaces. + IsPhaseContext() +} + +type PhaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPhaseContext() *PhaseContext { + var p = new(PhaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_phase + return p +} + +func InitEmptyPhaseContext(p *PhaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_phase +} + +func (*PhaseContext) IsPhaseContext() {} + +func NewPhaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PhaseContext { + var p = new(PhaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_phase + + return p +} + +func (s *PhaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PhaseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *PhaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PhaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PhaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhase(s) + } +} + +func (s *PhaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhase(s) + } +} + +func (p *PlSqlParser) Phase() (localctx IPhaseContext) { + localctx = NewPhaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, PlSqlParserRULE_phase) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2872) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheck_diskgroup_clauseContext is an interface to support dynamic dispatch. +type ICheck_diskgroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + ALL() antlr.TerminalNode + REPAIR() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + + // IsCheck_diskgroup_clauseContext differentiates from other interfaces. + IsCheck_diskgroup_clauseContext() +} + +type Check_diskgroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheck_diskgroup_clauseContext() *Check_diskgroup_clauseContext { + var p = new(Check_diskgroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause + return p +} + +func InitEmptyCheck_diskgroup_clauseContext(p *Check_diskgroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause +} + +func (*Check_diskgroup_clauseContext) IsCheck_diskgroup_clauseContext() {} + +func NewCheck_diskgroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Check_diskgroup_clauseContext { + var p = new(Check_diskgroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause + + return p +} + +func (s *Check_diskgroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Check_diskgroup_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Check_diskgroup_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Check_diskgroup_clauseContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Check_diskgroup_clauseContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Check_diskgroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Check_diskgroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Check_diskgroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCheck_diskgroup_clause(s) + } +} + +func (s *Check_diskgroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCheck_diskgroup_clause(s) + } +} + +func (p *PlSqlParser) Check_diskgroup_clause() (localctx ICheck_diskgroup_clauseContext) { + localctx = NewCheck_diskgroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, PlSqlParserRULE_check_diskgroup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2874) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(2875) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR { + { + p.SetState(2878) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_template_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_template_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPLATE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllQualified_template_clause() []IQualified_template_clauseContext + Qualified_template_clause(i int) IQualified_template_clauseContext + ADD() antlr.TerminalNode + MODIFY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsDiskgroup_template_clausesContext differentiates from other interfaces. + IsDiskgroup_template_clausesContext() +} + +type Diskgroup_template_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_template_clausesContext() *Diskgroup_template_clausesContext { + var p = new(Diskgroup_template_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses + return p +} + +func InitEmptyDiskgroup_template_clausesContext(p *Diskgroup_template_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses +} + +func (*Diskgroup_template_clausesContext) IsDiskgroup_template_clausesContext() {} + +func NewDiskgroup_template_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_template_clausesContext { + var p = new(Diskgroup_template_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses + + return p +} + +func (s *Diskgroup_template_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_template_clausesContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Diskgroup_template_clausesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_template_clausesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Diskgroup_template_clausesContext) AllQualified_template_clause() []IQualified_template_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_template_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_template_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_template_clauseContext); ok { + tst[i] = t.(IQualified_template_clauseContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_template_clausesContext) Qualified_template_clause(i int) IQualified_template_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_template_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_template_clauseContext) +} + +func (s *Diskgroup_template_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_template_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Diskgroup_template_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_template_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_template_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_template_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_template_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_template_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_template_clauses(s) + } +} + +func (s *Diskgroup_template_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_template_clauses(s) + } +} + +func (p *PlSqlParser) Diskgroup_template_clauses() (localctx IDiskgroup_template_clausesContext) { + localctx = NewDiskgroup_template_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, PlSqlParserRULE_diskgroup_template_clauses) + var _la int + + p.SetState(2904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD, PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2881) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserMODIFY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2882) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2883) + p.Id_expression() + } + { + p.SetState(2884) + p.Qualified_template_clause() + } + p.SetState(2891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2885) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2886) + p.Id_expression() + } + { + p.SetState(2887) + p.Qualified_template_clause() + } + + p.SetState(2893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2894) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2895) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2896) + p.Id_expression() + } + p.SetState(2901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2897) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2898) + p.Id_expression() + } + + p.SetState(2903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualified_template_clauseContext is an interface to support dynamic dispatch. +type IQualified_template_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Redundancy_clause() IRedundancy_clauseContext + Striping_clause() IStriping_clauseContext + + // IsQualified_template_clauseContext differentiates from other interfaces. + IsQualified_template_clauseContext() +} + +type Qualified_template_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualified_template_clauseContext() *Qualified_template_clauseContext { + var p = new(Qualified_template_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_template_clause + return p +} + +func InitEmptyQualified_template_clauseContext(p *Qualified_template_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_template_clause +} + +func (*Qualified_template_clauseContext) IsQualified_template_clauseContext() {} + +func NewQualified_template_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_template_clauseContext { + var p = new(Qualified_template_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qualified_template_clause + + return p +} + +func (s *Qualified_template_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_template_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Qualified_template_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Qualified_template_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Qualified_template_clauseContext) Redundancy_clause() IRedundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedundancy_clauseContext) +} + +func (s *Qualified_template_clauseContext) Striping_clause() IStriping_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStriping_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStriping_clauseContext) +} + +func (s *Qualified_template_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_template_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_template_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQualified_template_clause(s) + } +} + +func (s *Qualified_template_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQualified_template_clause(s) + } +} + +func (p *PlSqlParser) Qualified_template_clause() (localctx IQualified_template_clauseContext) { + localctx = NewQualified_template_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, PlSqlParserRULE_qualified_template_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2906) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2907) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOUBLE || _la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserPARITY || _la == PlSqlParserUNPROTECTED { + { + p.SetState(2908) + p.Redundancy_clause() + } + + } + p.SetState(2912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOARSE || _la == PlSqlParserFINE { + { + p.SetState(2911) + p.Striping_clause() + } + + } + { + p.SetState(2914) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRedundancy_clauseContext is an interface to support dynamic dispatch. +type IRedundancy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MIRROR() antlr.TerminalNode + HIGH() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + PARITY() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + + // IsRedundancy_clauseContext differentiates from other interfaces. + IsRedundancy_clauseContext() +} + +type Redundancy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedundancy_clauseContext() *Redundancy_clauseContext { + var p = new(Redundancy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redundancy_clause + return p +} + +func InitEmptyRedundancy_clauseContext(p *Redundancy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redundancy_clause +} + +func (*Redundancy_clauseContext) IsRedundancy_clauseContext() {} + +func NewRedundancy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redundancy_clauseContext { + var p = new(Redundancy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_redundancy_clause + + return p +} + +func (s *Redundancy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redundancy_clauseContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Redundancy_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Redundancy_clauseContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Redundancy_clauseContext) PARITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARITY, 0) +} + +func (s *Redundancy_clauseContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Redundancy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redundancy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redundancy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRedundancy_clause(s) + } +} + +func (s *Redundancy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRedundancy_clause(s) + } +} + +func (p *PlSqlParser) Redundancy_clause() (localctx IRedundancy_clauseContext) { + localctx = NewRedundancy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, PlSqlParserRULE_redundancy_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2916) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDOUBLE || _la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserPARITY || _la == PlSqlParserUNPROTECTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStriping_clauseContext is an interface to support dynamic dispatch. +type IStriping_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FINE() antlr.TerminalNode + COARSE() antlr.TerminalNode + + // IsStriping_clauseContext differentiates from other interfaces. + IsStriping_clauseContext() +} + +type Striping_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStriping_clauseContext() *Striping_clauseContext { + var p = new(Striping_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_striping_clause + return p +} + +func InitEmptyStriping_clauseContext(p *Striping_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_striping_clause +} + +func (*Striping_clauseContext) IsStriping_clauseContext() {} + +func NewStriping_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Striping_clauseContext { + var p = new(Striping_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_striping_clause + + return p +} + +func (s *Striping_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Striping_clauseContext) FINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINE, 0) +} + +func (s *Striping_clauseContext) COARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOARSE, 0) +} + +func (s *Striping_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Striping_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Striping_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStriping_clause(s) + } +} + +func (s *Striping_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStriping_clause(s) + } +} + +func (p *PlSqlParser) Striping_clause() (localctx IStriping_clauseContext) { + localctx = NewStriping_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, PlSqlParserRULE_striping_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2918) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOARSE || _la == PlSqlParserFINE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForce_noforceContext is an interface to support dynamic dispatch. +type IForce_noforceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORCE() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + + // IsForce_noforceContext differentiates from other interfaces. + IsForce_noforceContext() +} + +type Force_noforceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForce_noforceContext() *Force_noforceContext { + var p = new(Force_noforceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_noforce + return p +} + +func InitEmptyForce_noforceContext(p *Force_noforceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_noforce +} + +func (*Force_noforceContext) IsForce_noforceContext() {} + +func NewForce_noforceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Force_noforceContext { + var p = new(Force_noforceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_force_noforce + + return p +} + +func (s *Force_noforceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Force_noforceContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Force_noforceContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Force_noforceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Force_noforceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Force_noforceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForce_noforce(s) + } +} + +func (s *Force_noforceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForce_noforce(s) + } +} + +func (p *PlSqlParser) Force_noforce() (localctx IForce_noforceContext) { + localctx = NewForce_noforceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, PlSqlParserRULE_force_noforce) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2920) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_directory_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_directory_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + RENAME() antlr.TerminalNode + AllDir_name() []IDir_nameContext + Dir_name(i int) IDir_nameContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsDiskgroup_directory_clausesContext differentiates from other interfaces. + IsDiskgroup_directory_clausesContext() +} + +type Diskgroup_directory_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_directory_clausesContext() *Diskgroup_directory_clausesContext { + var p = new(Diskgroup_directory_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses + return p +} + +func InitEmptyDiskgroup_directory_clausesContext(p *Diskgroup_directory_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses +} + +func (*Diskgroup_directory_clausesContext) IsDiskgroup_directory_clausesContext() {} + +func NewDiskgroup_directory_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_directory_clausesContext { + var p = new(Diskgroup_directory_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses + + return p +} + +func (s *Diskgroup_directory_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_directory_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_directory_clausesContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Diskgroup_directory_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_directory_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_directory_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Diskgroup_directory_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllDir_name() []IDir_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDir_nameContext); ok { + len++ + } + } + + tst := make([]IDir_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDir_nameContext); ok { + tst[i] = t.(IDir_nameContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Dir_name(i int) IDir_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDir_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDir_nameContext) +} + +func (s *Diskgroup_directory_clausesContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Diskgroup_directory_clausesContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Diskgroup_directory_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_directory_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_directory_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_directory_clauses(s) + } +} + +func (s *Diskgroup_directory_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_directory_clauses(s) + } +} + +func (p *PlSqlParser) Diskgroup_directory_clauses() (localctx IDiskgroup_directory_clausesContext) { + localctx = NewDiskgroup_directory_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, PlSqlParserRULE_diskgroup_directory_clauses) + var _la int + + p.SetState(2963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2922) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2923) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2924) + p.Filename() + } + p.SetState(2929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2925) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2926) + p.Filename() + } + + p.SetState(2931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2932) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2933) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2934) + p.Filename() + } + p.SetState(2936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2935) + p.Force_noforce() + } + + } + p.SetState(2945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2938) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2939) + p.Filename() + } + p.SetState(2941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(2940) + p.Force_noforce() + } + + } + + p.SetState(2947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2948) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2949) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2950) + p.Dir_name() + } + { + p.SetState(2951) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2952) + p.Dir_name() + } + p.SetState(2960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2953) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2954) + p.Dir_name() + } + { + p.SetState(2955) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2956) + p.Dir_name() + } + + p.SetState(2962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDir_nameContext is an interface to support dynamic dispatch. +type IDir_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsDir_nameContext differentiates from other interfaces. + IsDir_nameContext() +} + +type Dir_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDir_nameContext() *Dir_nameContext { + var p = new(Dir_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_name + return p +} + +func InitEmptyDir_nameContext(p *Dir_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_name +} + +func (*Dir_nameContext) IsDir_nameContext() {} + +func NewDir_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dir_nameContext { + var p = new(Dir_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dir_name + + return p +} + +func (s *Dir_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dir_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Dir_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dir_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dir_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDir_name(s) + } +} + +func (s *Dir_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDir_name(s) + } +} + +func (p *PlSqlParser) Dir_name() (localctx IDir_nameContext) { + localctx = NewDir_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, PlSqlParserRULE_dir_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2965) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_alias_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_alias_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + ALIAS() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + RENAME() antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsDiskgroup_alias_clausesContext differentiates from other interfaces. + IsDiskgroup_alias_clausesContext() +} + +type Diskgroup_alias_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_alias_clausesContext() *Diskgroup_alias_clausesContext { + var p = new(Diskgroup_alias_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses + return p +} + +func InitEmptyDiskgroup_alias_clausesContext(p *Diskgroup_alias_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses +} + +func (*Diskgroup_alias_clausesContext) IsDiskgroup_alias_clausesContext() {} + +func NewDiskgroup_alias_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_alias_clausesContext { + var p = new(Diskgroup_alias_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses + + return p +} + +func (s *Diskgroup_alias_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_alias_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_alias_clausesContext) ALIAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALIAS, 0) +} + +func (s *Diskgroup_alias_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Diskgroup_alias_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Diskgroup_alias_clausesContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFOR) +} + +func (s *Diskgroup_alias_clausesContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, i) +} + +func (s *Diskgroup_alias_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_alias_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_alias_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_alias_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Diskgroup_alias_clausesContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Diskgroup_alias_clausesContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Diskgroup_alias_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_alias_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_alias_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_alias_clauses(s) + } +} + +func (s *Diskgroup_alias_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_alias_clauses(s) + } +} + +func (p *PlSqlParser) Diskgroup_alias_clauses() (localctx IDiskgroup_alias_clausesContext) { + localctx = NewDiskgroup_alias_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, PlSqlParserRULE_diskgroup_alias_clauses) + var _la int + + p.SetState(3005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2967) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2968) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2969) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2970) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2971) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2972) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2973) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2974) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2975) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2981) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2982) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2983) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2984) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2985) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2991) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2992) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2993) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2994) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2995) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2996) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2997) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2998) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2999) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_volume_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_volume_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_volume_clause() IAdd_volume_clauseContext + Modify_volume_clause() IModify_volume_clauseContext + RESIZE() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + DROP() antlr.TerminalNode + + // IsDiskgroup_volume_clausesContext differentiates from other interfaces. + IsDiskgroup_volume_clausesContext() +} + +type Diskgroup_volume_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_volume_clausesContext() *Diskgroup_volume_clausesContext { + var p = new(Diskgroup_volume_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses + return p +} + +func InitEmptyDiskgroup_volume_clausesContext(p *Diskgroup_volume_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses +} + +func (*Diskgroup_volume_clausesContext) IsDiskgroup_volume_clausesContext() {} + +func NewDiskgroup_volume_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_volume_clausesContext { + var p = new(Diskgroup_volume_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses + + return p +} + +func (s *Diskgroup_volume_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_volume_clausesContext) Add_volume_clause() IAdd_volume_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_volume_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_volume_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) Modify_volume_clause() IModify_volume_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_volume_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_volume_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Diskgroup_volume_clausesContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Diskgroup_volume_clausesContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Diskgroup_volume_clausesContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Diskgroup_volume_clausesContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_volume_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_volume_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_volume_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_volume_clauses(s) + } +} + +func (s *Diskgroup_volume_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_volume_clauses(s) + } +} + +func (p *PlSqlParser) Diskgroup_volume_clauses() (localctx IDiskgroup_volume_clausesContext) { + localctx = NewDiskgroup_volume_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, PlSqlParserRULE_diskgroup_volume_clauses) + p.SetState(3018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3007) + p.Add_volume_clause() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3008) + p.Modify_volume_clause() + } + + case PlSqlParserRESIZE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3009) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3010) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3011) + p.Id_expression() + } + { + p.SetState(3012) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3013) + p.Size_clause() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3015) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3016) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3017) + p.Id_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_volume_clauseContext is an interface to support dynamic dispatch. +type IAdd_volume_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Redundancy_clause() IRedundancy_clauseContext + STRIPE_WIDTH() antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + STRIPE_COLUMNS() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + + // IsAdd_volume_clauseContext differentiates from other interfaces. + IsAdd_volume_clauseContext() +} + +type Add_volume_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_volume_clauseContext() *Add_volume_clauseContext { + var p = new(Add_volume_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_volume_clause + return p +} + +func InitEmptyAdd_volume_clauseContext(p *Add_volume_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_volume_clause +} + +func (*Add_volume_clauseContext) IsAdd_volume_clauseContext() {} + +func NewAdd_volume_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_volume_clauseContext { + var p = new(Add_volume_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_volume_clause + + return p +} + +func (s *Add_volume_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_volume_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_volume_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Add_volume_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_volume_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Add_volume_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Add_volume_clauseContext) Redundancy_clause() IRedundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedundancy_clauseContext) +} + +func (s *Add_volume_clauseContext) STRIPE_WIDTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_WIDTH, 0) +} + +func (s *Add_volume_clauseContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Add_volume_clauseContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Add_volume_clauseContext) STRIPE_COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_COLUMNS, 0) +} + +func (s *Add_volume_clauseContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Add_volume_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Add_volume_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_volume_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_volume_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_volume_clause(s) + } +} + +func (s *Add_volume_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_volume_clause(s) + } +} + +func (p *PlSqlParser) Add_volume_clause() (localctx IAdd_volume_clauseContext) { + localctx = NewAdd_volume_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, PlSqlParserRULE_add_volume_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3020) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3021) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3022) + p.Id_expression() + } + { + p.SetState(3023) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3024) + p.Size_clause() + } + p.SetState(3026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOUBLE || _la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserPARITY || _la == PlSqlParserUNPROTECTED { + { + p.SetState(3025) + p.Redundancy_clause() + } + + } + p.SetState(3032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRIPE_WIDTH { + { + p.SetState(3028) + p.Match(PlSqlParserSTRIPE_WIDTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3029) + p.Numeric() + } + { + p.SetState(3030) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserK_LETTER || _la == PlSqlParserM_LETTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRIPE_COLUMNS { + { + p.SetState(3034) + p.Match(PlSqlParserSTRIPE_COLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3035) + p.Numeric() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_volume_clauseContext is an interface to support dynamic dispatch. +type IModify_volume_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + MOUNTPATH() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + USAGE() antlr.TerminalNode + + // IsModify_volume_clauseContext differentiates from other interfaces. + IsModify_volume_clauseContext() +} + +type Modify_volume_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_volume_clauseContext() *Modify_volume_clauseContext { + var p = new(Modify_volume_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_volume_clause + return p +} + +func InitEmptyModify_volume_clauseContext(p *Modify_volume_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_volume_clause +} + +func (*Modify_volume_clauseContext) IsModify_volume_clauseContext() {} + +func NewModify_volume_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_volume_clauseContext { + var p = new(Modify_volume_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_volume_clause + + return p +} + +func (s *Modify_volume_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_volume_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_volume_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Modify_volume_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Modify_volume_clauseContext) MOUNTPATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPATH, 0) +} + +func (s *Modify_volume_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Modify_volume_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Modify_volume_clauseContext) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Modify_volume_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_volume_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_volume_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_volume_clause(s) + } +} + +func (s *Modify_volume_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_volume_clause(s) + } +} + +func (p *PlSqlParser) Modify_volume_clause() (localctx IModify_volume_clauseContext) { + localctx = NewModify_volume_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, PlSqlParserRULE_modify_volume_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3038) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3039) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3040) + p.Id_expression() + } + p.SetState(3043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMOUNTPATH { + { + p.SetState(3041) + p.Match(PlSqlParserMOUNTPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3042) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3047) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSAGE { + { + p.SetState(3045) + p.Match(PlSqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3046) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_attributesContext is an interface to support dynamic dispatch. +type IDiskgroup_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsDiskgroup_attributesContext differentiates from other interfaces. + IsDiskgroup_attributesContext() +} + +type Diskgroup_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_attributesContext() *Diskgroup_attributesContext { + var p = new(Diskgroup_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes + return p +} + +func InitEmptyDiskgroup_attributesContext(p *Diskgroup_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes +} + +func (*Diskgroup_attributesContext) IsDiskgroup_attributesContext() {} + +func NewDiskgroup_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_attributesContext { + var p = new(Diskgroup_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes + + return p +} + +func (s *Diskgroup_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_attributesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Diskgroup_attributesContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Diskgroup_attributesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Diskgroup_attributesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Diskgroup_attributesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Diskgroup_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_attributes(s) + } +} + +func (s *Diskgroup_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_attributes(s) + } +} + +func (p *PlSqlParser) Diskgroup_attributes() (localctx IDiskgroup_attributesContext) { + localctx = NewDiskgroup_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, PlSqlParserRULE_diskgroup_attributes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3049) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3050) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3051) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3052) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3053) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_diskgroup_file_clauseContext is an interface to support dynamic dispatch. +type IDrop_diskgroup_file_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_diskgroup_file_clauseContext differentiates from other interfaces. + IsDrop_diskgroup_file_clauseContext() +} + +type Drop_diskgroup_file_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_diskgroup_file_clauseContext() *Drop_diskgroup_file_clauseContext { + var p = new(Drop_diskgroup_file_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause + return p +} + +func InitEmptyDrop_diskgroup_file_clauseContext(p *Drop_diskgroup_file_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause +} + +func (*Drop_diskgroup_file_clauseContext) IsDrop_diskgroup_file_clauseContext() {} + +func NewDrop_diskgroup_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_diskgroup_file_clauseContext { + var p = new(Drop_diskgroup_file_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause + + return p +} + +func (s *Drop_diskgroup_file_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_diskgroup_file_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_diskgroup_file_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Drop_diskgroup_file_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Drop_diskgroup_file_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Drop_diskgroup_file_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_diskgroup_file_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_diskgroup_file_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_diskgroup_file_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_diskgroup_file_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_diskgroup_file_clause(s) + } +} + +func (s *Drop_diskgroup_file_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_diskgroup_file_clause(s) + } +} + +func (p *PlSqlParser) Drop_diskgroup_file_clause() (localctx IDrop_diskgroup_file_clauseContext) { + localctx = NewDrop_diskgroup_file_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, PlSqlParserRULE_drop_diskgroup_file_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3055) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3056) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3057) + p.Filename() + } + p.SetState(3062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3058) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3059) + p.Filename() + } + + p.SetState(3064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConvert_redundancy_clauseContext is an interface to support dynamic dispatch. +type IConvert_redundancy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONVERT() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + TO() antlr.TerminalNode + FLEX() antlr.TerminalNode + + // IsConvert_redundancy_clauseContext differentiates from other interfaces. + IsConvert_redundancy_clauseContext() +} + +type Convert_redundancy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConvert_redundancy_clauseContext() *Convert_redundancy_clauseContext { + var p = new(Convert_redundancy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause + return p +} + +func InitEmptyConvert_redundancy_clauseContext(p *Convert_redundancy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause +} + +func (*Convert_redundancy_clauseContext) IsConvert_redundancy_clauseContext() {} + +func NewConvert_redundancy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Convert_redundancy_clauseContext { + var p = new(Convert_redundancy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause + + return p +} + +func (s *Convert_redundancy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Convert_redundancy_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Convert_redundancy_clauseContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Convert_redundancy_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Convert_redundancy_clauseContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Convert_redundancy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Convert_redundancy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Convert_redundancy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConvert_redundancy_clause(s) + } +} + +func (s *Convert_redundancy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConvert_redundancy_clause(s) + } +} + +func (p *PlSqlParser) Convert_redundancy_clause() (localctx IConvert_redundancy_clauseContext) { + localctx = NewConvert_redundancy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, PlSqlParserRULE_convert_redundancy_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3065) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3066) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3067) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3068) + p.Match(PlSqlParserFLEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsergroup_clausesContext is an interface to support dynamic dispatch. +type IUsergroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + USERGROUP() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + MEMBER() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MODIFY() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsUsergroup_clausesContext differentiates from other interfaces. + IsUsergroup_clausesContext() +} + +type Usergroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsergroup_clausesContext() *Usergroup_clausesContext { + var p = new(Usergroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_usergroup_clauses + return p +} + +func InitEmptyUsergroup_clausesContext(p *Usergroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_usergroup_clauses +} + +func (*Usergroup_clausesContext) IsUsergroup_clausesContext() {} + +func NewUsergroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Usergroup_clausesContext { + var p = new(Usergroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_usergroup_clauses + + return p +} + +func (s *Usergroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Usergroup_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Usergroup_clausesContext) USERGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERGROUP, 0) +} + +func (s *Usergroup_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Usergroup_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Usergroup_clausesContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Usergroup_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Usergroup_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Usergroup_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Usergroup_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Usergroup_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Usergroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Usergroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Usergroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsergroup_clauses(s) + } +} + +func (s *Usergroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsergroup_clauses(s) + } +} + +func (p *PlSqlParser) Usergroup_clauses() (localctx IUsergroup_clausesContext) { + localctx = NewUsergroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, PlSqlParserRULE_usergroup_clauses) + var _la int + + p.SetState(3099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3070) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3071) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3072) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3073) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3074) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3075) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3076) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3077) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3083) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3084) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3085) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3086) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3087) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3088) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3089) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3090) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3096) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3098) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_clausesContext is an interface to support dynamic dispatch. +type IUser_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + USER() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + CASCADE() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + + // IsUser_clausesContext differentiates from other interfaces. + IsUser_clausesContext() +} + +type User_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_clausesContext() *User_clausesContext { + var p = new(User_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_clauses + return p +} + +func InitEmptyUser_clausesContext(p *User_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_clauses +} + +func (*User_clausesContext) IsUser_clausesContext() {} + +func NewUser_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_clausesContext { + var p = new(User_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_clauses + + return p +} + +func (s *User_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *User_clausesContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *User_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *User_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *User_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *User_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *User_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *User_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *User_clausesContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *User_clausesContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *User_clausesContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *User_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_clauses(s) + } +} + +func (s *User_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_clauses(s) + } +} + +func (p *PlSqlParser) User_clauses() (localctx IUser_clausesContext) { + localctx = NewUser_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, PlSqlParserRULE_user_clauses) + var _la int + + p.SetState(3138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3101) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3102) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3103) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3104) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3105) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3111) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3112) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3113) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3114) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3115) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(3121) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserREPLACE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3124) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3125) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3126) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3127) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3128) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3129) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3130) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3131) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3132) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_permissions_clauseContext is an interface to support dynamic dispatch. +type IFile_permissions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + PERMISSION() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + FILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllOWNER() []antlr.TerminalNode + OWNER(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllOTHER() []antlr.TerminalNode + OTHER(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllREAD() []antlr.TerminalNode + READ(i int) antlr.TerminalNode + AllONLY() []antlr.TerminalNode + ONLY(i int) antlr.TerminalNode + AllWRITE() []antlr.TerminalNode + WRITE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_permissions_clauseContext differentiates from other interfaces. + IsFile_permissions_clauseContext() +} + +type File_permissions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_permissions_clauseContext() *File_permissions_clauseContext { + var p = new(File_permissions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_permissions_clause + return p +} + +func InitEmptyFile_permissions_clauseContext(p *File_permissions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_permissions_clause +} + +func (*File_permissions_clauseContext) IsFile_permissions_clauseContext() {} + +func NewFile_permissions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_permissions_clauseContext { + var p = new(File_permissions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_permissions_clause + + return p +} + +func (s *File_permissions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_permissions_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *File_permissions_clauseContext) PERMISSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMISSION, 0) +} + +func (s *File_permissions_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *File_permissions_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *File_permissions_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *File_permissions_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *File_permissions_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *File_permissions_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *File_permissions_clauseContext) AllOWNER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOWNER) +} + +func (s *File_permissions_clauseContext) OWNER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, i) +} + +func (s *File_permissions_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *File_permissions_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *File_permissions_clauseContext) AllOTHER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOTHER) +} + +func (s *File_permissions_clauseContext) OTHER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOTHER, i) +} + +func (s *File_permissions_clauseContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNONE) +} + +func (s *File_permissions_clauseContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, i) +} + +func (s *File_permissions_clauseContext) AllREAD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREAD) +} + +func (s *File_permissions_clauseContext) READ(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, i) +} + +func (s *File_permissions_clauseContext) AllONLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLY) +} + +func (s *File_permissions_clauseContext) ONLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, i) +} + +func (s *File_permissions_clauseContext) AllWRITE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWRITE) +} + +func (s *File_permissions_clauseContext) WRITE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, i) +} + +func (s *File_permissions_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_permissions_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_permissions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_permissions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_permissions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_permissions_clause(s) + } +} + +func (s *File_permissions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_permissions_clause(s) + } +} + +func (p *PlSqlParser) File_permissions_clause() (localctx IFile_permissions_clauseContext) { + localctx = NewFile_permissions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, PlSqlParserRULE_file_permissions_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3140) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3141) + p.Match(PlSqlParserPERMISSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3142) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOTHER || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3143) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNONE: + { + p.SetState(3144) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(3145) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3146) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3149) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3150) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOTHER || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3151) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNONE: + { + p.SetState(3152) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(3153) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3154) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3162) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3163) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3164) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3165) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3166) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_owner_clauseContext is an interface to support dynamic dispatch. +type IFile_owner_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + FILE() antlr.TerminalNode + AllOWNER() []antlr.TerminalNode + OWNER(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_owner_clauseContext differentiates from other interfaces. + IsFile_owner_clauseContext() +} + +type File_owner_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_owner_clauseContext() *File_owner_clauseContext { + var p = new(File_owner_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_owner_clause + return p +} + +func InitEmptyFile_owner_clauseContext(p *File_owner_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_owner_clause +} + +func (*File_owner_clauseContext) IsFile_owner_clauseContext() {} + +func NewFile_owner_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_owner_clauseContext { + var p = new(File_owner_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_owner_clause + + return p +} + +func (s *File_owner_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_owner_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *File_owner_clauseContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNERSHIP, 0) +} + +func (s *File_owner_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *File_owner_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *File_owner_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *File_owner_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *File_owner_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *File_owner_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *File_owner_clauseContext) AllOWNER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOWNER) +} + +func (s *File_owner_clauseContext) OWNER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, i) +} + +func (s *File_owner_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *File_owner_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *File_owner_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_owner_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_owner_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_owner_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_owner_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_owner_clause(s) + } +} + +func (s *File_owner_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_owner_clause(s) + } +} + +func (p *PlSqlParser) File_owner_clause() (localctx IFile_owner_clauseContext) { + localctx = NewFile_owner_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, PlSqlParserRULE_file_owner_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3172) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3173) + p.Match(PlSqlParserOWNERSHIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3174) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3175) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3176) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3177) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3178) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3179) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3180) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3186) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3187) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3188) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3189) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3190) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IScrub_clauseContext is an interface to support dynamic dispatch. +type IScrub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCRUB() antlr.TerminalNode + FILE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + DISK() antlr.TerminalNode + Id_expression() IId_expressionContext + POWER() antlr.TerminalNode + Wait_nowait() IWait_nowaitContext + Force_noforce() IForce_noforceContext + STOP() antlr.TerminalNode + REPAIR() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + AUTO() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + MAX() antlr.TerminalNode + + // IsScrub_clauseContext differentiates from other interfaces. + IsScrub_clauseContext() +} + +type Scrub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScrub_clauseContext() *Scrub_clauseContext { + var p = new(Scrub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scrub_clause + return p +} + +func InitEmptyScrub_clauseContext(p *Scrub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scrub_clause +} + +func (*Scrub_clauseContext) IsScrub_clauseContext() {} + +func NewScrub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scrub_clauseContext { + var p = new(Scrub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_scrub_clause + + return p +} + +func (s *Scrub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Scrub_clauseContext) SCRUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCRUB, 0) +} + +func (s *Scrub_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Scrub_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Scrub_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Scrub_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Scrub_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Scrub_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Scrub_clauseContext) Force_noforce() IForce_noforceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Scrub_clauseContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Scrub_clauseContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Scrub_clauseContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Scrub_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Scrub_clauseContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Scrub_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Scrub_clauseContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Scrub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Scrub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Scrub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterScrub_clause(s) + } +} + +func (s *Scrub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitScrub_clause(s) + } +} + +func (p *PlSqlParser) Scrub_clause() (localctx IScrub_clauseContext) { + localctx = NewScrub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, PlSqlParserRULE_scrub_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3196) + p.Match(PlSqlParserSCRUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserFILE: + { + p.SetState(3197) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3198) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISK: + { + p.SetState(3199) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3200) + p.Id_expression() + } + + case PlSqlParserEOF, PlSqlParserFORCE, PlSqlParserNOFORCE, PlSqlParserNOREPAIR, PlSqlParserNOWAIT, PlSqlParserPOWER, PlSqlParserREPAIR, PlSqlParserSTOP, PlSqlParserWAIT, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(3204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR { + { + p.SetState(3203) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOWER { + { + p.SetState(3206) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3207) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTO || _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMAX) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + { + p.SetState(3210) + p.Wait_nowait() + } + + } + p.SetState(3214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(3213) + p.Force_noforce() + } + + } + p.SetState(3217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTOP { + { + p.SetState(3216) + p.Match(PlSqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuotagroup_clausesContext is an interface to support dynamic dispatch. +type IQuotagroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + QUOTAGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SET() antlr.TerminalNode + Property_name() IProperty_nameContext + EQUALS_OP() antlr.TerminalNode + Property_value() IProperty_valueContext + MODIFY() antlr.TerminalNode + MOVE() antlr.TerminalNode + TO() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsQuotagroup_clausesContext differentiates from other interfaces. + IsQuotagroup_clausesContext() +} + +type Quotagroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuotagroup_clausesContext() *Quotagroup_clausesContext { + var p = new(Quotagroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses + return p +} + +func InitEmptyQuotagroup_clausesContext(p *Quotagroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses +} + +func (*Quotagroup_clausesContext) IsQuotagroup_clausesContext() {} + +func NewQuotagroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quotagroup_clausesContext { + var p = new(Quotagroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses + + return p +} + +func (s *Quotagroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quotagroup_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Quotagroup_clausesContext) QUOTAGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTAGROUP, 0) +} + +func (s *Quotagroup_clausesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Quotagroup_clausesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Quotagroup_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Quotagroup_clausesContext) Property_name() IProperty_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_nameContext) +} + +func (s *Quotagroup_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Quotagroup_clausesContext) Property_value() IProperty_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_valueContext) +} + +func (s *Quotagroup_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Quotagroup_clausesContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Quotagroup_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Quotagroup_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Quotagroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quotagroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quotagroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuotagroup_clauses(s) + } +} + +func (s *Quotagroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuotagroup_clauses(s) + } +} + +func (p *PlSqlParser) Quotagroup_clauses() (localctx IQuotagroup_clausesContext) { + localctx = NewQuotagroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, PlSqlParserRULE_quotagroup_clauses) + var _la int + + p.SetState(3246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3219) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3220) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3221) + p.Id_expression() + } + p.SetState(3227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(3222) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3223) + p.Property_name() + } + { + p.SetState(3224) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3225) + p.Property_value() + } + + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3229) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3230) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3231) + p.Id_expression() + } + { + p.SetState(3232) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3233) + p.Property_name() + } + { + p.SetState(3234) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3235) + p.Property_value() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3237) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3238) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3239) + p.Id_expression() + } + { + p.SetState(3240) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3241) + p.Id_expression() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3243) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3244) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3245) + p.Id_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperty_nameContext is an interface to support dynamic dispatch. +type IProperty_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsProperty_nameContext differentiates from other interfaces. + IsProperty_nameContext() +} + +type Property_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperty_nameContext() *Property_nameContext { + var p = new(Property_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_name + return p +} + +func InitEmptyProperty_nameContext(p *Property_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_name +} + +func (*Property_nameContext) IsProperty_nameContext() {} + +func NewProperty_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_nameContext { + var p = new(Property_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_name + + return p +} + +func (s *Property_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_name(s) + } +} + +func (s *Property_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_name(s) + } +} + +func (p *PlSqlParser) Property_name() (localctx IProperty_nameContext) { + localctx = NewProperty_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, PlSqlParserRULE_property_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3248) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperty_valueContext is an interface to support dynamic dispatch. +type IProperty_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsProperty_valueContext differentiates from other interfaces. + IsProperty_valueContext() +} + +type Property_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperty_valueContext() *Property_valueContext { + var p = new(Property_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_value + return p +} + +func InitEmptyProperty_valueContext(p *Property_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_value +} + +func (*Property_valueContext) IsProperty_valueContext() {} + +func NewProperty_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_valueContext { + var p = new(Property_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_value + + return p +} + +func (s *Property_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_valueContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_value(s) + } +} + +func (s *Property_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_value(s) + } +} + +func (p *PlSqlParser) Property_value() (localctx IProperty_valueContext) { + localctx = NewProperty_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, PlSqlParserRULE_property_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3250) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilegroup_clausesContext is an interface to support dynamic dispatch. +type IFilegroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_filegroup_clause() IAdd_filegroup_clauseContext + Modify_filegroup_clause() IModify_filegroup_clauseContext + Move_to_filegroup_clause() IMove_to_filegroup_clauseContext + Drop_filegroup_clause() IDrop_filegroup_clauseContext + + // IsFilegroup_clausesContext differentiates from other interfaces. + IsFilegroup_clausesContext() +} + +type Filegroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilegroup_clausesContext() *Filegroup_clausesContext { + var p = new(Filegroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filegroup_clauses + return p +} + +func InitEmptyFilegroup_clausesContext(p *Filegroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filegroup_clauses +} + +func (*Filegroup_clausesContext) IsFilegroup_clausesContext() {} + +func NewFilegroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filegroup_clausesContext { + var p = new(Filegroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filegroup_clauses + + return p +} + +func (s *Filegroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filegroup_clausesContext) Add_filegroup_clause() IAdd_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Modify_filegroup_clause() IModify_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Move_to_filegroup_clause() IMove_to_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_to_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_to_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Drop_filegroup_clause() IDrop_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filegroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filegroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilegroup_clauses(s) + } +} + +func (s *Filegroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilegroup_clauses(s) + } +} + +func (p *PlSqlParser) Filegroup_clauses() (localctx IFilegroup_clausesContext) { + localctx = NewFilegroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, PlSqlParserRULE_filegroup_clauses) + p.SetState(3256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3252) + p.Add_filegroup_clause() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3253) + p.Modify_filegroup_clause() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3254) + p.Move_to_filegroup_clause() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3255) + p.Drop_filegroup_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_filegroup_clauseContext is an interface to support dynamic dispatch. +type IAdd_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllTEMPLATE() []antlr.TerminalNode + TEMPLATE(i int) antlr.TerminalNode + DATABASE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + VOLUME() antlr.TerminalNode + FROM() antlr.TerminalNode + SET() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsAdd_filegroup_clauseContext differentiates from other interfaces. + IsAdd_filegroup_clauseContext() +} + +type Add_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_filegroup_clauseContext() *Add_filegroup_clauseContext { + var p = new(Add_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause + return p +} + +func InitEmptyAdd_filegroup_clauseContext(p *Add_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause +} + +func (*Add_filegroup_clauseContext) IsAdd_filegroup_clauseContext() {} + +func NewAdd_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_filegroup_clauseContext { + var p = new(Add_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause + + return p +} + +func (s *Add_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_filegroup_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Add_filegroup_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Add_filegroup_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_filegroup_clauseContext) AllTEMPLATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTEMPLATE) +} + +func (s *Add_filegroup_clauseContext) TEMPLATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, i) +} + +func (s *Add_filegroup_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Add_filegroup_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Add_filegroup_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Add_filegroup_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Add_filegroup_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Add_filegroup_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_filegroup_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_filegroup_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Add_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_filegroup_clause(s) + } +} + +func (s *Add_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_filegroup_clause(s) + } +} + +func (p *PlSqlParser) Add_filegroup_clause() (localctx IAdd_filegroup_clauseContext) { + localctx = NewAdd_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, PlSqlParserRULE_add_filegroup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3258) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3259) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3260) + p.Id_expression() + } + p.SetState(3264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCLUSTER, PlSqlParserDATABASE, PlSqlParserVOLUME: + { + p.SetState(3261) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLUSTER || _la == PlSqlParserDATABASE || _la == PlSqlParserVOLUME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3262) + p.Id_expression() + } + + case PlSqlParserTEMPLATE: + { + p.SetState(3263) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFROM { + { + p.SetState(3266) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3267) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3268) + p.Id_expression() + } + + } + p.SetState(3275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(3271) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3273) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3274) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_filegroup_clauseContext is an interface to support dynamic dispatch. +type IModify_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + SET() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsModify_filegroup_clauseContext differentiates from other interfaces. + IsModify_filegroup_clauseContext() +} + +type Modify_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_filegroup_clauseContext() *Modify_filegroup_clauseContext { + var p = new(Modify_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause + return p +} + +func InitEmptyModify_filegroup_clauseContext(p *Modify_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause +} + +func (*Modify_filegroup_clauseContext) IsModify_filegroup_clauseContext() {} + +func NewModify_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_filegroup_clauseContext { + var p = new(Modify_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause + + return p +} + +func (s *Modify_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_filegroup_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Modify_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Modify_filegroup_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Modify_filegroup_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Modify_filegroup_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Modify_filegroup_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Modify_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_filegroup_clause(s) + } +} + +func (s *Modify_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_filegroup_clause(s) + } +} + +func (p *PlSqlParser) Modify_filegroup_clause() (localctx IModify_filegroup_clauseContext) { + localctx = NewModify_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, PlSqlParserRULE_modify_filegroup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3277) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3278) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3279) + p.Id_expression() + } + { + p.SetState(3280) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3281) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3282) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3283) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_to_filegroup_clauseContext is an interface to support dynamic dispatch. +type IMove_to_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + FILE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + TO() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsMove_to_filegroup_clauseContext differentiates from other interfaces. + IsMove_to_filegroup_clauseContext() +} + +type Move_to_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_to_filegroup_clauseContext() *Move_to_filegroup_clauseContext { + var p = new(Move_to_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause + return p +} + +func InitEmptyMove_to_filegroup_clauseContext(p *Move_to_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause +} + +func (*Move_to_filegroup_clauseContext) IsMove_to_filegroup_clauseContext() {} + +func NewMove_to_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_to_filegroup_clauseContext { + var p = new(Move_to_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause + + return p +} + +func (s *Move_to_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_to_filegroup_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_to_filegroup_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Move_to_filegroup_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Move_to_filegroup_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_to_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Move_to_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Move_to_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_to_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_to_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_to_filegroup_clause(s) + } +} + +func (s *Move_to_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_to_filegroup_clause(s) + } +} + +func (p *PlSqlParser) Move_to_filegroup_clause() (localctx IMove_to_filegroup_clauseContext) { + localctx = NewMove_to_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, PlSqlParserRULE_move_to_filegroup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3285) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3286) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3287) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3288) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3289) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3290) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_filegroup_clauseContext is an interface to support dynamic dispatch. +type IDrop_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + CASCADE() antlr.TerminalNode + + // IsDrop_filegroup_clauseContext differentiates from other interfaces. + IsDrop_filegroup_clauseContext() +} + +type Drop_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_filegroup_clauseContext() *Drop_filegroup_clauseContext { + var p = new(Drop_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause + return p +} + +func InitEmptyDrop_filegroup_clauseContext(p *Drop_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause +} + +func (*Drop_filegroup_clauseContext) IsDrop_filegroup_clauseContext() {} + +func NewDrop_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_filegroup_clauseContext { + var p = new(Drop_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause + + return p +} + +func (s *Drop_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_filegroup_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Drop_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_filegroup_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_filegroup_clause(s) + } +} + +func (s *Drop_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_filegroup_clause(s) + } +} + +func (p *PlSqlParser) Drop_filegroup_clause() (localctx IDrop_filegroup_clauseContext) { + localctx = NewDrop_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, PlSqlParserRULE_drop_filegroup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3292) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3293) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3294) + p.Id_expression() + } + p.SetState(3296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(3295) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuorum_regularContext is an interface to support dynamic dispatch. +type IQuorum_regularContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUORUM() antlr.TerminalNode + REGULAR() antlr.TerminalNode + + // IsQuorum_regularContext differentiates from other interfaces. + IsQuorum_regularContext() +} + +type Quorum_regularContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuorum_regularContext() *Quorum_regularContext { + var p = new(Quorum_regularContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quorum_regular + return p +} + +func InitEmptyQuorum_regularContext(p *Quorum_regularContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quorum_regular +} + +func (*Quorum_regularContext) IsQuorum_regularContext() {} + +func NewQuorum_regularContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quorum_regularContext { + var p = new(Quorum_regularContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quorum_regular + + return p +} + +func (s *Quorum_regularContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quorum_regularContext) QUORUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUORUM, 0) +} + +func (s *Quorum_regularContext) REGULAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR, 0) +} + +func (s *Quorum_regularContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quorum_regularContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quorum_regularContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuorum_regular(s) + } +} + +func (s *Quorum_regularContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuorum_regular(s) + } +} + +func (p *PlSqlParser) Quorum_regular() (localctx IQuorum_regularContext) { + localctx = NewQuorum_regularContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, PlSqlParserRULE_quorum_regular) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3298) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndrop_disk_clauseContext is an interface to support dynamic dispatch. +type IUndrop_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + DISKS() antlr.TerminalNode + + // IsUndrop_disk_clauseContext differentiates from other interfaces. + IsUndrop_disk_clauseContext() +} + +type Undrop_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_disk_clauseContext() *Undrop_disk_clauseContext { + var p = new(Undrop_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause + return p +} + +func InitEmptyUndrop_disk_clauseContext(p *Undrop_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause +} + +func (*Undrop_disk_clauseContext) IsUndrop_disk_clauseContext() {} + +func NewUndrop_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_disk_clauseContext { + var p = new(Undrop_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause + + return p +} + +func (s *Undrop_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_disk_clauseContext) UNDROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDROP, 0) +} + +func (s *Undrop_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Undrop_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndrop_disk_clause(s) + } +} + +func (s *Undrop_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndrop_disk_clause(s) + } +} + +func (p *PlSqlParser) Undrop_disk_clause() (localctx IUndrop_disk_clauseContext) { + localctx = NewUndrop_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, PlSqlParserRULE_undrop_disk_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3300) + p.Match(PlSqlParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3301) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_availabilityContext is an interface to support dynamic dispatch. +type IDiskgroup_availabilityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNT() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + NORMAL() antlr.TerminalNode + FORCE() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + + // IsDiskgroup_availabilityContext differentiates from other interfaces. + IsDiskgroup_availabilityContext() +} + +type Diskgroup_availabilityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_availabilityContext() *Diskgroup_availabilityContext { + var p = new(Diskgroup_availabilityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_availability + return p +} + +func InitEmptyDiskgroup_availabilityContext(p *Diskgroup_availabilityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_availability +} + +func (*Diskgroup_availabilityContext) IsDiskgroup_availabilityContext() {} + +func NewDiskgroup_availabilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_availabilityContext { + var p = new(Diskgroup_availabilityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_availability + + return p +} + +func (s *Diskgroup_availabilityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_availabilityContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Diskgroup_availabilityContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *Diskgroup_availabilityContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Diskgroup_availabilityContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Diskgroup_availabilityContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Diskgroup_availabilityContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Diskgroup_availabilityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_availabilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_availabilityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_availability(s) + } +} + +func (s *Diskgroup_availabilityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_availability(s) + } +} + +func (p *PlSqlParser) Diskgroup_availability() (localctx IDiskgroup_availabilityContext) { + localctx = NewDiskgroup_availabilityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, PlSqlParserRULE_diskgroup_availability) + var _la int + + p.SetState(3314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMOUNT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3303) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORMAL || _la == PlSqlParserRESTRICTED { + { + p.SetState(3304) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORMAL || _la == PlSqlParserRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(3307) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserDISMOUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3310) + p.Match(PlSqlParserDISMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(3311) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_disable_volumeContext is an interface to support dynamic dispatch. +type IEnable_disable_volumeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VOLUME() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnable_disable_volumeContext differentiates from other interfaces. + IsEnable_disable_volumeContext() +} + +type Enable_disable_volumeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_disable_volumeContext() *Enable_disable_volumeContext { + var p = new(Enable_disable_volumeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_volume + return p +} + +func InitEmptyEnable_disable_volumeContext(p *Enable_disable_volumeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_volume +} + +func (*Enable_disable_volumeContext) IsEnable_disable_volumeContext() {} + +func NewEnable_disable_volumeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_disable_volumeContext { + var p = new(Enable_disable_volumeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_disable_volume + + return p +} + +func (s *Enable_disable_volumeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_disable_volumeContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Enable_disable_volumeContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_disable_volumeContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_disable_volumeContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Enable_disable_volumeContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Enable_disable_volumeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Enable_disable_volumeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Enable_disable_volumeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Enable_disable_volumeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_disable_volumeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_disable_volumeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_disable_volume(s) + } +} + +func (s *Enable_disable_volumeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_disable_volume(s) + } +} + +func (p *PlSqlParser) Enable_disable_volume() (localctx IEnable_disable_volumeContext) { + localctx = NewEnable_disable_volumeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, PlSqlParserRULE_enable_disable_volume) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3316) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3317) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(3318) + p.Id_expression() + } + p.SetState(3323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3319) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3320) + p.Id_expression() + } + + p.SetState(3325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(3326) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_functionContext is an interface to support dynamic dispatch. +type IDrop_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + + // IsDrop_functionContext differentiates from other interfaces. + IsDrop_functionContext() +} + +type Drop_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_functionContext() *Drop_functionContext { + var p = new(Drop_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_function + return p +} + +func InitEmptyDrop_functionContext(p *Drop_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_function +} + +func (*Drop_functionContext) IsDrop_functionContext() {} + +func NewDrop_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_functionContext { + var p = new(Drop_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_function + + return p +} + +func (s *Drop_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_functionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Drop_functionContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Drop_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_function(s) + } +} + +func (s *Drop_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_function(s) + } +} + +func (p *PlSqlParser) Drop_function() (localctx IDrop_functionContext) { + localctx = NewDrop_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, PlSqlParserRULE_drop_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3329) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3330) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3331) + p.Function_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_flashback_archiveContext is an interface to support dynamic dispatch. +type IAlter_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // GetRts returns the rts rule contexts. + GetRts() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // SetRts sets the rts rule contexts. + SetRts(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SET() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + REMOVE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + Flashback_archive_retention() IFlashback_archive_retentionContext + PURGE() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + DATA() antlr.TerminalNode + ADD() antlr.TerminalNode + ALL() antlr.TerminalNode + BEFORE() antlr.TerminalNode + Flashback_archive_quota() IFlashback_archive_quotaContext + NO() antlr.TerminalNode + SCN() antlr.TerminalNode + Expression() IExpressionContext + TIMESTAMP() antlr.TerminalNode + + // IsAlter_flashback_archiveContext differentiates from other interfaces. + IsAlter_flashback_archiveContext() +} + +type Alter_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext + ts IId_expressionContext + rts IId_expressionContext +} + +func NewEmptyAlter_flashback_archiveContext() *Alter_flashback_archiveContext { + var p = new(Alter_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive + return p +} + +func InitEmptyAlter_flashback_archiveContext(p *Alter_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive +} + +func (*Alter_flashback_archiveContext) IsAlter_flashback_archiveContext() {} + +func NewAlter_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_flashback_archiveContext { + var p = new(Alter_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive + + return p +} + +func (s *Alter_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Alter_flashback_archiveContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Alter_flashback_archiveContext) GetRts() IId_expressionContext { return s.rts } + +func (s *Alter_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Alter_flashback_archiveContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Alter_flashback_archiveContext) SetRts(v IId_expressionContext) { s.rts = v } + +func (s *Alter_flashback_archiveContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Alter_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Alter_flashback_archiveContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_flashback_archiveContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_flashback_archiveContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_flashback_archiveContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Alter_flashback_archiveContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_flashback_archiveContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Alter_flashback_archiveContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_flashback_archiveContext) Flashback_archive_retention() IFlashback_archive_retentionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_retentionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_retentionContext) +} + +func (s *Alter_flashback_archiveContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Alter_flashback_archiveContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Alter_flashback_archiveContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Alter_flashback_archiveContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_flashback_archiveContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_flashback_archiveContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Alter_flashback_archiveContext) Flashback_archive_quota() IFlashback_archive_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_quotaContext) +} + +func (s *Alter_flashback_archiveContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Alter_flashback_archiveContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Alter_flashback_archiveContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_flashback_archiveContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Alter_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_flashback_archive(s) + } +} + +func (s *Alter_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_flashback_archive(s) + } +} + +func (p *PlSqlParser) Alter_flashback_archive() (localctx IAlter_flashback_archiveContext) { + localctx = NewAlter_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, PlSqlParserRULE_alter_flashback_archive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3333) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3334) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3335) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3336) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).fa = _x + } + p.SetState(3366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3337) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3338) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3339) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserMODIFY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3340) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3341) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).ts = _x + } + p.SetState(3343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUOTA { + { + p.SetState(3342) + p.Flashback_archive_quota() + } + + } + + case 3: + { + p.SetState(3345) + p.Match(PlSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3346) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3347) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).rts = _x + } + + case 4: + { + p.SetState(3348) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3349) + p.Flashback_archive_retention() + } + + case 5: + { + p.SetState(3350) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(3351) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBEFORE: + { + p.SetState(3352) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCN: + { + p.SetState(3353) + p.Match(PlSqlParserSCN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3354) + p.Expression() + } + + case PlSqlParserTIMESTAMP: + { + p.SetState(3355) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3356) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + p.SetState(3362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(3361) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3364) + p.Match(PlSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3365) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_hierarchyContext is an interface to support dynamic dispatch. +type IAlter_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHn returns the hn rule contexts. + GetHn() IId_expressionContext + + // GetNhn returns the nhn rule contexts. + GetNhn() IId_expressionContext + + // SetHn sets the hn rule contexts. + SetHn(IId_expressionContext) + + // SetNhn sets the nhn rule contexts. + SetNhn(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_hierarchyContext differentiates from other interfaces. + IsAlter_hierarchyContext() +} + +type Alter_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hn IId_expressionContext + nhn IId_expressionContext +} + +func NewEmptyAlter_hierarchyContext() *Alter_hierarchyContext { + var p = new(Alter_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_hierarchy + return p +} + +func InitEmptyAlter_hierarchyContext(p *Alter_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_hierarchy +} + +func (*Alter_hierarchyContext) IsAlter_hierarchyContext() {} + +func NewAlter_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_hierarchyContext { + var p = new(Alter_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_hierarchy + + return p +} + +func (s *Alter_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_hierarchyContext) GetHn() IId_expressionContext { return s.hn } + +func (s *Alter_hierarchyContext) GetNhn() IId_expressionContext { return s.nhn } + +func (s *Alter_hierarchyContext) SetHn(v IId_expressionContext) { s.hn = v } + +func (s *Alter_hierarchyContext) SetNhn(v IId_expressionContext) { s.nhn = v } + +func (s *Alter_hierarchyContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Alter_hierarchyContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_hierarchyContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_hierarchyContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_hierarchyContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_hierarchyContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_hierarchyContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_hierarchy(s) + } +} + +func (s *Alter_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_hierarchy(s) + } +} + +func (p *PlSqlParser) Alter_hierarchy() (localctx IAlter_hierarchyContext) { + localctx = NewAlter_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, PlSqlParserRULE_alter_hierarchy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3368) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3369) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3373) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { + { + p.SetState(3370) + p.Schema_name() + } + { + p.SetState(3371) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3375) + + var _x = p.Id_expression() + + localctx.(*Alter_hierarchyContext).hn = _x + } + p.SetState(3380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(3376) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3377) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3378) + + var _x = p.Id_expression() + + localctx.(*Alter_hierarchyContext).nhn = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(3379) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_functionContext is an interface to support dynamic dispatch. +type IAlter_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_functionContext differentiates from other interfaces. + IsAlter_functionContext() +} + +type Alter_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_functionContext() *Alter_functionContext { + var p = new(Alter_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_function + return p +} + +func InitEmptyAlter_functionContext(p *Alter_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_function +} + +func (*Alter_functionContext) IsAlter_functionContext() {} + +func NewAlter_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_functionContext { + var p = new(Alter_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_function + + return p +} + +func (s *Alter_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_functionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Alter_functionContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Alter_functionContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Alter_functionContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Alter_functionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_functionContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_functionContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_functionContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_functionContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_functionContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_function(s) + } +} + +func (s *Alter_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_function(s) + } +} + +func (p *PlSqlParser) Alter_function() (localctx IAlter_functionContext) { + localctx = NewAlter_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, PlSqlParserRULE_alter_function) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3382) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3383) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3384) + p.Function_name() + } + p.SetState(3401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEDITIONABLE: + { + p.SetState(3385) + p.Match(PlSqlParserEDITIONABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONEDITIONABLE: + { + p.SetState(3386) + p.Match(PlSqlParserNONEDITIONABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(3387) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 { + { + p.SetState(3388) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3391) + p.Compiler_parameters_clause() + } + + } + p.SetState(3396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3397) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3398) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_javaContext is an interface to support dynamic dispatch. +type IAlter_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + JAVA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + CLASS() antlr.TerminalNode + Id_expression() IId_expressionContext + COMPILE() antlr.TerminalNode + RESOLVE() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + PERIOD() antlr.TerminalNode + RESOLVER() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllMatch_string() []IMatch_stringContext + Match_string(i int) IMatch_stringContext + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_javaContext differentiates from other interfaces. + IsAlter_javaContext() +} + +type Alter_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyAlter_javaContext() *Alter_javaContext { + var p = new(Alter_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_java + return p +} + +func InitEmptyAlter_javaContext(p *Alter_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_java +} + +func (*Alter_javaContext) IsAlter_javaContext() {} + +func NewAlter_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_javaContext { + var p = new(Alter_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_java + + return p +} + +func (s *Alter_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_javaContext) GetO() IId_expressionContext { return s.o } + +func (s *Alter_javaContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Alter_javaContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Alter_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Alter_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Alter_javaContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_javaContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_javaContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Alter_javaContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Alter_javaContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_javaContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_javaContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Alter_javaContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_javaContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_javaContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_javaContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_javaContext) AllMatch_string() []IMatch_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMatch_stringContext); ok { + len++ + } + } + + tst := make([]IMatch_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMatch_stringContext); ok { + tst[i] = t.(IMatch_stringContext) + i++ + } + } + + return tst +} + +func (s *Alter_javaContext) Match_string(i int) IMatch_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMatch_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMatch_stringContext) +} + +func (s *Alter_javaContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *Alter_javaContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *Alter_javaContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_javaContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_java(s) + } +} + +func (s *Alter_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_java(s) + } +} + +func (p *PlSqlParser) Alter_java() (localctx IAlter_javaContext) { + localctx = NewAlter_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, PlSqlParserRULE_alter_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3403) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3404) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3405) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3409) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 129, p.GetParserRuleContext()) == 1 { + { + p.SetState(3406) + p.Schema_name() + } + { + p.SetState(3407) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3411) + + var _x = p.Id_expression() + + localctx.(*Alter_javaContext).o = _x + } + p.SetState(3431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESOLVER { + { + p.SetState(3412) + p.Match(PlSqlParserRESOLVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3413) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3414) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3415) + p.Match_string() + } + p.SetState(3417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(3416) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(3419) + p.Schema_name() + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(3420) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3423) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3429) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPILE: + { + p.SetState(3433) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRESOLVE: + { + p.SetState(3434) + p.Match(PlSqlParserRESOLVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTHID: + { + p.SetState(3435) + p.Invoker_rights_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMatch_stringContext is an interface to support dynamic dispatch. +type IMatch_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + + // IsMatch_stringContext differentiates from other interfaces. + IsMatch_stringContext() +} + +type Match_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMatch_stringContext() *Match_stringContext { + var p = new(Match_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_match_string + return p +} + +func InitEmptyMatch_stringContext(p *Match_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_match_string +} + +func (*Match_stringContext) IsMatch_stringContext() {} + +func NewMatch_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Match_stringContext { + var p = new(Match_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_match_string + + return p +} + +func (s *Match_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Match_stringContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Match_stringContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Match_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Match_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Match_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMatch_string(s) + } +} + +func (s *Match_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMatch_string(s) + } +} + +func (p *PlSqlParser) Match_string() (localctx IMatch_stringContext) { + localctx = NewMatch_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, PlSqlParserRULE_match_string) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3438) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELIMITED_ID || _la == PlSqlParserASTERISK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_function_bodyContext is an interface to support dynamic dispatch. +type ICreate_function_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + Aggregate_clause() IAggregate_clauseContext + Pipelined_using_clause() IPipelined_using_clauseContext + Sql_macro_body() ISql_macro_bodyContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllInvoker_rights_clause() []IInvoker_rights_clauseContext + Invoker_rights_clause(i int) IInvoker_rights_clauseContext + AllAccessible_by_clause() []IAccessible_by_clauseContext + Accessible_by_clause(i int) IAccessible_by_clauseContext + AllDefault_collation_clause() []IDefault_collation_clauseContext + Default_collation_clause(i int) IDefault_collation_clauseContext + AllParallel_enable_clause() []IParallel_enable_clauseContext + Parallel_enable_clause(i int) IParallel_enable_clauseContext + AllResult_cache_clause() []IResult_cache_clauseContext + Result_cache_clause(i int) IResult_cache_clauseContext + AllPIPELINED() []antlr.TerminalNode + PIPELINED(i int) antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsCreate_function_bodyContext differentiates from other interfaces. + IsCreate_function_bodyContext() +} + +type Create_function_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_function_bodyContext() *Create_function_bodyContext { + var p = new(Create_function_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_function_body + return p +} + +func InitEmptyCreate_function_bodyContext(p *Create_function_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_function_body +} + +func (*Create_function_bodyContext) IsCreate_function_bodyContext() {} + +func NewCreate_function_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_function_bodyContext { + var p = new(Create_function_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_function_body + + return p +} + +func (s *Create_function_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_function_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_function_bodyContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Create_function_bodyContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Create_function_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Create_function_bodyContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Create_function_bodyContext) Aggregate_clause() IAggregate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_clauseContext) +} + +func (s *Create_function_bodyContext) Pipelined_using_clause() IPipelined_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPipelined_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPipelined_using_clauseContext) +} + +func (s *Create_function_bodyContext) Sql_macro_body() ISql_macro_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_macro_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_macro_bodyContext) +} + +func (s *Create_function_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_function_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_function_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_function_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Create_function_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_function_bodyContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_function_bodyContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_function_bodyContext) AllInvoker_rights_clause() []IInvoker_rights_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + len++ + } + } + + tst := make([]IInvoker_rights_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInvoker_rights_clauseContext); ok { + tst[i] = t.(IInvoker_rights_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Invoker_rights_clause(i int) IInvoker_rights_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_function_bodyContext) AllAccessible_by_clause() []IAccessible_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + len++ + } + } + + tst := make([]IAccessible_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccessible_by_clauseContext); ok { + tst[i] = t.(IAccessible_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Accessible_by_clause(i int) IAccessible_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccessible_by_clauseContext) +} + +func (s *Create_function_bodyContext) AllDefault_collation_clause() []IDefault_collation_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDefault_collation_clauseContext); ok { + len++ + } + } + + tst := make([]IDefault_collation_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDefault_collation_clauseContext); ok { + tst[i] = t.(IDefault_collation_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Default_collation_clause(i int) IDefault_collation_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_collation_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDefault_collation_clauseContext) +} + +func (s *Create_function_bodyContext) AllParallel_enable_clause() []IParallel_enable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_enable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_enable_clauseContext); ok { + tst[i] = t.(IParallel_enable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Parallel_enable_clause(i int) IParallel_enable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_enable_clauseContext) +} + +func (s *Create_function_bodyContext) AllResult_cache_clause() []IResult_cache_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + len++ + } + } + + tst := make([]IResult_cache_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResult_cache_clauseContext); ok { + tst[i] = t.(IResult_cache_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Result_cache_clause(i int) IResult_cache_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Create_function_bodyContext) AllPIPELINED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPIPELINED) +} + +func (s *Create_function_bodyContext) PIPELINED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, i) +} + +func (s *Create_function_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Create_function_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Create_function_bodyContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_function_bodyContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_function_bodyContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_function_bodyContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_function_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_function_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_function_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_function_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_function_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Create_function_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Create_function_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Create_function_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Create_function_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_function_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_function_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_function_body(s) + } +} + +func (s *Create_function_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_function_body(s) + } +} + +func (p *PlSqlParser) Create_function_body() (localctx ICreate_function_bodyContext) { + localctx = NewCreate_function_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, PlSqlParserRULE_create_function_body) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3440) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3441) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3442) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(3445) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3448) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3449) + p.Function_name() + } + p.SetState(3461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3450) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3451) + p.Parameter() + } + p.SetState(3456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3452) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3453) + p.Parameter() + } + + p.SetState(3458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3459) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3463) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3464) + p.Type_spec() + } + p.SetState(3468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(3465) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3466) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3467) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 141, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAUTHID: + { + p.SetState(3470) + p.Invoker_rights_clause() + } + + case PlSqlParserACCESSIBLE: + { + p.SetState(3471) + p.Accessible_by_clause() + } + + case PlSqlParserDEFAULT: + { + p.SetState(3472) + p.Default_collation_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(3473) + p.Parallel_enable_clause() + } + + case PlSqlParserRESULT_CACHE: + { + p.SetState(3474) + p.Result_cache_clause() + } + + case PlSqlParserPIPELINED: + { + p.SetState(3475) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(3476) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 141, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(3482) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 144, p.GetParserRuleContext()) { + case 1: + p.SetState(3484) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 142, p.GetParserRuleContext()) == 1 { + { + p.SetState(3483) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3487) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 143, p.GetParserRuleContext()) == 1 { + { + p.SetState(3486) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3489) + p.Body() + } + + case 2: + { + p.SetState(3490) + p.Call_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAGGREGATE: + { + p.SetState(3493) + p.Aggregate_clause() + } + + case PlSqlParserPIPELINED: + { + p.SetState(3494) + p.Pipelined_using_clause() + } + + case PlSqlParserSQL_MACRO: + { + p.SetState(3495) + p.Sql_macro_body() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_macro_bodyContext is an interface to support dynamic dispatch. +type ISql_macro_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SQL_MACRO() antlr.TerminalNode + IS() antlr.TerminalNode + BEGIN() antlr.TerminalNode + RETURN() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + SEMICOLON() antlr.TerminalNode + END() antlr.TerminalNode + + // IsSql_macro_bodyContext differentiates from other interfaces. + IsSql_macro_bodyContext() +} + +type Sql_macro_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_macro_bodyContext() *Sql_macro_bodyContext { + var p = new(Sql_macro_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_macro_body + return p +} + +func InitEmptySql_macro_bodyContext(p *Sql_macro_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_macro_body +} + +func (*Sql_macro_bodyContext) IsSql_macro_bodyContext() {} + +func NewSql_macro_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_macro_bodyContext { + var p = new(Sql_macro_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_macro_body + + return p +} + +func (s *Sql_macro_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_macro_bodyContext) SQL_MACRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_MACRO, 0) +} + +func (s *Sql_macro_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Sql_macro_bodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Sql_macro_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Sql_macro_bodyContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Sql_macro_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Sql_macro_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Sql_macro_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_macro_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_macro_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_macro_body(s) + } +} + +func (s *Sql_macro_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_macro_body(s) + } +} + +func (p *PlSqlParser) Sql_macro_body() (localctx ISql_macro_bodyContext) { + localctx = NewSql_macro_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, PlSqlParserRULE_sql_macro_body) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3498) + p.Match(PlSqlParserSQL_MACRO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3499) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3500) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3501) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3502) + p.Quoted_string() + } + { + p.SetState(3503) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3504) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParallel_enable_clauseContext is an interface to support dynamic dispatch. +type IParallel_enable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARALLEL_ENABLE() antlr.TerminalNode + Partition_by_clause() IPartition_by_clauseContext + + // IsParallel_enable_clauseContext differentiates from other interfaces. + IsParallel_enable_clauseContext() +} + +type Parallel_enable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParallel_enable_clauseContext() *Parallel_enable_clauseContext { + var p = new(Parallel_enable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause + return p +} + +func InitEmptyParallel_enable_clauseContext(p *Parallel_enable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause +} + +func (*Parallel_enable_clauseContext) IsParallel_enable_clauseContext() {} + +func NewParallel_enable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parallel_enable_clauseContext { + var p = new(Parallel_enable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause + + return p +} + +func (s *Parallel_enable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parallel_enable_clauseContext) PARALLEL_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, 0) +} + +func (s *Parallel_enable_clauseContext) Partition_by_clause() IPartition_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clauseContext) +} + +func (s *Parallel_enable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parallel_enable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parallel_enable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParallel_enable_clause(s) + } +} + +func (s *Parallel_enable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParallel_enable_clause(s) + } +} + +func (p *PlSqlParser) Parallel_enable_clause() (localctx IParallel_enable_clauseContext) { + localctx = NewParallel_enable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, PlSqlParserRULE_parallel_enable_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3506) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3507) + p.Partition_by_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_by_clauseContext is an interface to support dynamic dispatch. +type IPartition_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Expression() IExpressionContext + BY() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + ANY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + HASH() antlr.TerminalNode + RANGE() antlr.TerminalNode + LIST() antlr.TerminalNode + Streaming_clause() IStreaming_clauseContext + + // IsPartition_by_clauseContext differentiates from other interfaces. + IsPartition_by_clauseContext() +} + +type Partition_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_by_clauseContext() *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_by_clause + return p +} + +func InitEmptyPartition_by_clauseContext(p *Partition_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_by_clause +} + +func (*Partition_by_clauseContext) IsPartition_by_clauseContext() {} + +func NewPartition_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_by_clause + + return p +} + +func (s *Partition_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_by_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_by_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_by_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Partition_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Partition_by_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_by_clauseContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *Partition_by_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Partition_by_clauseContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Partition_by_clauseContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Partition_by_clauseContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Partition_by_clauseContext) Streaming_clause() IStreaming_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStreaming_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStreaming_clauseContext) +} + +func (s *Partition_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_by_clause(s) + } +} + +func (s *Partition_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_by_clause(s) + } +} + +func (p *PlSqlParser) Partition_by_clause() (localctx IPartition_by_clauseContext) { + localctx = NewPartition_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, PlSqlParserRULE_partition_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3510) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3511) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3512) + p.Expression() + } + { + p.SetState(3513) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserANY: + { + p.SetState(3514) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASH, PlSqlParserLIST, PlSqlParserRANGE: + { + p.SetState(3515) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHASH || _la == PlSqlParserLIST || _la == PlSqlParserRANGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3516) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLUSTER || _la == PlSqlParserORDER { + { + p.SetState(3519) + p.Streaming_clause() + } + + } + { + p.SetState(3522) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResult_cache_clauseContext is an interface to support dynamic dispatch. +type IResult_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESULT_CACHE() antlr.TerminalNode + Relies_on_part() IRelies_on_partContext + LEFT_PAREN() antlr.TerminalNode + MODE() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsResult_cache_clauseContext differentiates from other interfaces. + IsResult_cache_clauseContext() +} + +type Result_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResult_cache_clauseContext() *Result_cache_clauseContext { + var p = new(Result_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_result_cache_clause + return p +} + +func InitEmptyResult_cache_clauseContext(p *Result_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_result_cache_clause +} + +func (*Result_cache_clauseContext) IsResult_cache_clauseContext() {} + +func NewResult_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_cache_clauseContext { + var p = new(Result_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_result_cache_clause + + return p +} + +func (s *Result_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Result_cache_clauseContext) RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, 0) +} + +func (s *Result_cache_clauseContext) Relies_on_part() IRelies_on_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelies_on_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelies_on_partContext) +} + +func (s *Result_cache_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Result_cache_clauseContext) MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODE, 0) +} + +func (s *Result_cache_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Result_cache_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Result_cache_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Result_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Result_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Result_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResult_cache_clause(s) + } +} + +func (s *Result_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResult_cache_clause(s) + } +} + +func (p *PlSqlParser) Result_cache_clause() (localctx IResult_cache_clauseContext) { + localctx = NewResult_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, PlSqlParserRULE_result_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3524) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRELIES_ON { + { + p.SetState(3525) + p.Relies_on_part() + } + + } + p.SetState(3532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3528) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3529) + p.Match(PlSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3530) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3531) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAccessible_by_clauseContext is an interface to support dynamic dispatch. +type IAccessible_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCESSIBLE() antlr.TerminalNode + BY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAccessor() []IAccessorContext + Accessor(i int) IAccessorContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAccessible_by_clauseContext differentiates from other interfaces. + IsAccessible_by_clauseContext() +} + +type Accessible_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccessible_by_clauseContext() *Accessible_by_clauseContext { + var p = new(Accessible_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_accessible_by_clause + return p +} + +func InitEmptyAccessible_by_clauseContext(p *Accessible_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_accessible_by_clause +} + +func (*Accessible_by_clauseContext) IsAccessible_by_clauseContext() {} + +func NewAccessible_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Accessible_by_clauseContext { + var p = new(Accessible_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_accessible_by_clause + + return p +} + +func (s *Accessible_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Accessible_by_clauseContext) ACCESSIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSIBLE, 0) +} + +func (s *Accessible_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Accessible_by_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Accessible_by_clauseContext) AllAccessor() []IAccessorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccessorContext); ok { + len++ + } + } + + tst := make([]IAccessorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccessorContext); ok { + tst[i] = t.(IAccessorContext) + i++ + } + } + + return tst +} + +func (s *Accessible_by_clauseContext) Accessor(i int) IAccessorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccessorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccessorContext) +} + +func (s *Accessible_by_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Accessible_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Accessible_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Accessible_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Accessible_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Accessible_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAccessible_by_clause(s) + } +} + +func (s *Accessible_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAccessible_by_clause(s) + } +} + +func (p *PlSqlParser) Accessible_by_clause() (localctx IAccessible_by_clauseContext) { + localctx = NewAccessible_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, PlSqlParserRULE_accessible_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3534) + p.Match(PlSqlParserACCESSIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3535) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3536) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3537) + p.Accessor() + } + p.SetState(3542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3538) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3539) + p.Accessor() + } + + p.SetState(3544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3545) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_collation_clauseContext is an interface to support dynamic dispatch. +type IDefault_collation_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + COLLATION() antlr.TerminalNode + USING_NLS_COMP() antlr.TerminalNode + + // IsDefault_collation_clauseContext differentiates from other interfaces. + IsDefault_collation_clauseContext() +} + +type Default_collation_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_collation_clauseContext() *Default_collation_clauseContext { + var p = new(Default_collation_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_collation_clause + return p +} + +func InitEmptyDefault_collation_clauseContext(p *Default_collation_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_collation_clause +} + +func (*Default_collation_clauseContext) IsDefault_collation_clauseContext() {} + +func NewDefault_collation_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_collation_clauseContext { + var p = new(Default_collation_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_collation_clause + + return p +} + +func (s *Default_collation_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_collation_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_collation_clauseContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Default_collation_clauseContext) USING_NLS_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING_NLS_COMP, 0) +} + +func (s *Default_collation_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_collation_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_collation_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_collation_clause(s) + } +} + +func (s *Default_collation_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_collation_clause(s) + } +} + +func (p *PlSqlParser) Default_collation_clause() (localctx IDefault_collation_clauseContext) { + localctx = NewDefault_collation_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, PlSqlParserRULE_default_collation_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3547) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3548) + p.Match(PlSqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3549) + p.Match(PlSqlParserUSING_NLS_COMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_clauseContext is an interface to support dynamic dispatch. +type IAggregate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGGREGATE() antlr.TerminalNode + USING() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + + // IsAggregate_clauseContext differentiates from other interfaces. + IsAggregate_clauseContext() +} + +type Aggregate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_clauseContext() *Aggregate_clauseContext { + var p = new(Aggregate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_clause + return p +} + +func InitEmptyAggregate_clauseContext(p *Aggregate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_clause +} + +func (*Aggregate_clauseContext) IsAggregate_clauseContext() {} + +func NewAggregate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_clauseContext { + var p = new(Aggregate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_aggregate_clause + + return p +} + +func (s *Aggregate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_clauseContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Aggregate_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Aggregate_clauseContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Aggregate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAggregate_clause(s) + } +} + +func (s *Aggregate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAggregate_clause(s) + } +} + +func (p *PlSqlParser) Aggregate_clause() (localctx IAggregate_clauseContext) { + localctx = NewAggregate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, PlSqlParserRULE_aggregate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3551) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3552) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3553) + p.Implementation_type_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPipelined_using_clauseContext is an interface to support dynamic dispatch. +type IPipelined_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIPELINED() antlr.TerminalNode + USING() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + POLYMORPHIC() antlr.TerminalNode + ROW() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // IsPipelined_using_clauseContext differentiates from other interfaces. + IsPipelined_using_clauseContext() +} + +type Pipelined_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPipelined_using_clauseContext() *Pipelined_using_clauseContext { + var p = new(Pipelined_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipelined_using_clause + return p +} + +func InitEmptyPipelined_using_clauseContext(p *Pipelined_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipelined_using_clause +} + +func (*Pipelined_using_clauseContext) IsPipelined_using_clauseContext() {} + +func NewPipelined_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pipelined_using_clauseContext { + var p = new(Pipelined_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pipelined_using_clause + + return p +} + +func (s *Pipelined_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pipelined_using_clauseContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Pipelined_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Pipelined_using_clauseContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Pipelined_using_clauseContext) POLYMORPHIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLYMORPHIC, 0) +} + +func (s *Pipelined_using_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Pipelined_using_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Pipelined_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pipelined_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pipelined_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPipelined_using_clause(s) + } +} + +func (s *Pipelined_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPipelined_using_clause(s) + } +} + +func (p *PlSqlParser) Pipelined_using_clause() (localctx IPipelined_using_clauseContext) { + localctx = NewPipelined_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, PlSqlParserRULE_pipelined_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3555) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserROW || _la == PlSqlParserTABLE { + { + p.SetState(3556) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserROW || _la == PlSqlParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3557) + p.Match(PlSqlParserPOLYMORPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3560) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3561) + p.Implementation_type_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAccessorContext is an interface to support dynamic dispatch. +type IAccessorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUnitKind returns the unitKind token. + GetUnitKind() antlr.Token + + // SetUnitKind sets the unitKind token. + SetUnitKind(antlr.Token) + + // Getter signatures + Function_name() IFunction_nameContext + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TYPE() antlr.TerminalNode + + // IsAccessorContext differentiates from other interfaces. + IsAccessorContext() +} + +type AccessorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + unitKind antlr.Token +} + +func NewEmptyAccessorContext() *AccessorContext { + var p = new(AccessorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_accessor + return p +} + +func InitEmptyAccessorContext(p *AccessorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_accessor +} + +func (*AccessorContext) IsAccessorContext() {} + +func NewAccessorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AccessorContext { + var p = new(AccessorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_accessor + + return p +} + +func (s *AccessorContext) GetParser() antlr.Parser { return s.parser } + +func (s *AccessorContext) GetUnitKind() antlr.Token { return s.unitKind } + +func (s *AccessorContext) SetUnitKind(v antlr.Token) { s.unitKind = v } + +func (s *AccessorContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *AccessorContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *AccessorContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *AccessorContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *AccessorContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *AccessorContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *AccessorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AccessorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AccessorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAccessor(s) + } +} + +func (s *AccessorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAccessor(s) + } +} + +func (p *PlSqlParser) Accessor() (localctx IAccessorContext) { + localctx = NewAccessorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, PlSqlParserRULE_accessor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3563) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*AccessorContext).unitKind = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFUNCTION || _la == PlSqlParserPACKAGE || _la == PlSqlParserPROCEDURE || _la == PlSqlParserTRIGGER || _la == PlSqlParserTYPE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*AccessorContext).unitKind = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3564) + p.Function_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelies_on_partContext is an interface to support dynamic dispatch. +type IRelies_on_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RELIES_ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelies_on_partContext differentiates from other interfaces. + IsRelies_on_partContext() +} + +type Relies_on_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelies_on_partContext() *Relies_on_partContext { + var p = new(Relies_on_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relies_on_part + return p +} + +func InitEmptyRelies_on_partContext(p *Relies_on_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relies_on_part +} + +func (*Relies_on_partContext) IsRelies_on_partContext() {} + +func NewRelies_on_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relies_on_partContext { + var p = new(Relies_on_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relies_on_part + + return p +} + +func (s *Relies_on_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relies_on_partContext) RELIES_ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELIES_ON, 0) +} + +func (s *Relies_on_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Relies_on_partContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Relies_on_partContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Relies_on_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Relies_on_partContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Relies_on_partContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Relies_on_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relies_on_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relies_on_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelies_on_part(s) + } +} + +func (s *Relies_on_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelies_on_part(s) + } +} + +func (p *PlSqlParser) Relies_on_part() (localctx IRelies_on_partContext) { + localctx = NewRelies_on_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, PlSqlParserRULE_relies_on_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3566) + p.Match(PlSqlParserRELIES_ON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3567) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3568) + p.Tableview_name() + } + p.SetState(3573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3569) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3570) + p.Tableview_name() + } + + p.SetState(3575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3576) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStreaming_clauseContext is an interface to support dynamic dispatch. +type IStreaming_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + BY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + ORDER() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + + // IsStreaming_clauseContext differentiates from other interfaces. + IsStreaming_clauseContext() +} + +type Streaming_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStreaming_clauseContext() *Streaming_clauseContext { + var p = new(Streaming_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_streaming_clause + return p +} + +func InitEmptyStreaming_clauseContext(p *Streaming_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_streaming_clause +} + +func (*Streaming_clauseContext) IsStreaming_clauseContext() {} + +func NewStreaming_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Streaming_clauseContext { + var p = new(Streaming_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_streaming_clause + + return p +} + +func (s *Streaming_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Streaming_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Streaming_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Streaming_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Streaming_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Streaming_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Streaming_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Streaming_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Streaming_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStreaming_clause(s) + } +} + +func (s *Streaming_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStreaming_clause(s) + } +} + +func (p *PlSqlParser) Streaming_clause() (localctx IStreaming_clauseContext) { + localctx = NewStreaming_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, PlSqlParserRULE_streaming_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3578) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLUSTER || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3579) + p.Expression() + } + { + p.SetState(3580) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3581) + p.Paren_column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_outlineContext is an interface to support dynamic dispatch. +type IAlter_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + Id_expression() IId_expressionContext + AllOutline_options() []IOutline_optionsContext + Outline_options(i int) IOutline_optionsContext + PUBLIC() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + + // IsAlter_outlineContext differentiates from other interfaces. + IsAlter_outlineContext() +} + +type Alter_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyAlter_outlineContext() *Alter_outlineContext { + var p = new(Alter_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_outline + return p +} + +func InitEmptyAlter_outlineContext(p *Alter_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_outline +} + +func (*Alter_outlineContext) IsAlter_outlineContext() {} + +func NewAlter_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_outlineContext { + var p = new(Alter_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_outline + + return p +} + +func (s *Alter_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Alter_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Alter_outlineContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Alter_outlineContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_outlineContext) AllOutline_options() []IOutline_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOutline_optionsContext); ok { + len++ + } + } + + tst := make([]IOutline_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOutline_optionsContext); ok { + tst[i] = t.(IOutline_optionsContext) + i++ + } + } + + return tst +} + +func (s *Alter_outlineContext) Outline_options(i int) IOutline_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutline_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOutline_optionsContext) +} + +func (s *Alter_outlineContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_outlineContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Alter_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_outline(s) + } +} + +func (s *Alter_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_outline(s) + } +} + +func (p *PlSqlParser) Alter_outline() (localctx IAlter_outlineContext) { + localctx = NewAlter_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, PlSqlParserRULE_alter_outline) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3583) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3584) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3586) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) == 1 { + { + p.SetState(3585) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3588) + + var _x = p.Id_expression() + + localctx.(*Alter_outlineContext).o = _x + } + p.SetState(3590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHANGE || _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE || _la == PlSqlParserREBUILD || _la == PlSqlParserRENAME { + { + p.SetState(3589) + p.Outline_options() + } + + p.SetState(3592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOutline_optionsContext is an interface to support dynamic dispatch. +type IOutline_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNon returns the non rule contexts. + GetNon() IId_expressionContext + + // GetNcn returns the ncn rule contexts. + GetNcn() IId_expressionContext + + // SetNon sets the non rule contexts. + SetNon(IId_expressionContext) + + // SetNcn sets the ncn rule contexts. + SetNcn(IId_expressionContext) + + // Getter signatures + REBUILD() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Id_expression() IId_expressionContext + CHANGE() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsOutline_optionsContext differentiates from other interfaces. + IsOutline_optionsContext() +} + +type Outline_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + non IId_expressionContext + ncn IId_expressionContext +} + +func NewEmptyOutline_optionsContext() *Outline_optionsContext { + var p = new(Outline_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outline_options + return p +} + +func InitEmptyOutline_optionsContext(p *Outline_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outline_options +} + +func (*Outline_optionsContext) IsOutline_optionsContext() {} + +func NewOutline_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outline_optionsContext { + var p = new(Outline_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outline_options + + return p +} + +func (s *Outline_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outline_optionsContext) GetNon() IId_expressionContext { return s.non } + +func (s *Outline_optionsContext) GetNcn() IId_expressionContext { return s.ncn } + +func (s *Outline_optionsContext) SetNon(v IId_expressionContext) { s.non = v } + +func (s *Outline_optionsContext) SetNcn(v IId_expressionContext) { s.ncn = v } + +func (s *Outline_optionsContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Outline_optionsContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Outline_optionsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Outline_optionsContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Outline_optionsContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Outline_optionsContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Outline_optionsContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Outline_optionsContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Outline_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outline_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outline_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOutline_options(s) + } +} + +func (s *Outline_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOutline_options(s) + } +} + +func (p *PlSqlParser) Outline_options() (localctx IOutline_optionsContext) { + localctx = NewOutline_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, PlSqlParserRULE_outline_options) + p.SetState(3604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREBUILD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3594) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3595) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3596) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3597) + + var _x = p.Id_expression() + + localctx.(*Outline_optionsContext).non = _x + } + + case PlSqlParserCHANGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3598) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3599) + p.Match(PlSqlParserCATEGORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3600) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3601) + + var _x = p.Id_expression() + + localctx.(*Outline_optionsContext).ncn = _x + } + + case PlSqlParserENABLE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3602) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3603) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_lockdown_profileContext is an interface to support dynamic dispatch. +type IAlter_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + Lockdown_feature() ILockdown_featureContext + Lockdown_options() ILockdown_optionsContext + Lockdown_statements() ILockdown_statementsContext + USERS() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + ALL() antlr.TerminalNode + COMMON() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsAlter_lockdown_profileContext differentiates from other interfaces. + IsAlter_lockdown_profileContext() +} + +type Alter_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_lockdown_profileContext() *Alter_lockdown_profileContext { + var p = new(Alter_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile + return p +} + +func InitEmptyAlter_lockdown_profileContext(p *Alter_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile +} + +func (*Alter_lockdown_profileContext) IsAlter_lockdown_profileContext() {} + +func NewAlter_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_lockdown_profileContext { + var p = new(Alter_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile + + return p +} + +func (s *Alter_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_lockdown_profileContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Alter_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Alter_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_feature() ILockdown_featureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_featureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_featureContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_options() ILockdown_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_optionsContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_statements() ILockdown_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_statementsContext) +} + +func (s *Alter_lockdown_profileContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Alter_lockdown_profileContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Alter_lockdown_profileContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_lockdown_profileContext) COMMON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON, 0) +} + +func (s *Alter_lockdown_profileContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Alter_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_lockdown_profile(s) + } +} + +func (s *Alter_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_lockdown_profile(s) + } +} + +func (p *PlSqlParser) Alter_lockdown_profile() (localctx IAlter_lockdown_profileContext) { + localctx = NewAlter_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, PlSqlParserRULE_alter_lockdown_profile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3606) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3607) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3608) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3609) + p.Id_expression() + } + p.SetState(3613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 157, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3610) + p.Lockdown_feature() + } + + case 2: + { + p.SetState(3611) + p.Lockdown_options() + } + + case 3: + { + p.SetState(3612) + p.Lockdown_statements() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(3618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSERS { + { + p.SetState(3615) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3616) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3617) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCOMMON || _la == PlSqlParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockdown_featureContext is an interface to support dynamic dispatch. +type ILockdown_featureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + FEATURE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_featureContext differentiates from other interfaces. + IsLockdown_featureContext() +} + +type Lockdown_featureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_featureContext() *Lockdown_featureContext { + var p = new(Lockdown_featureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_feature + return p +} + +func InitEmptyLockdown_featureContext(p *Lockdown_featureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_feature +} + +func (*Lockdown_featureContext) IsLockdown_featureContext() {} + +func NewLockdown_featureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_featureContext { + var p = new(Lockdown_featureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_feature + + return p +} + +func (s *Lockdown_featureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_featureContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_featureContext) FEATURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE, 0) +} + +func (s *Lockdown_featureContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_featureContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_featureContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Lockdown_featureContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_featureContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_featureContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_featureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_featureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_featureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_feature(s) + } +} + +func (s *Lockdown_featureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_feature(s) + } +} + +func (p *PlSqlParser) Lockdown_feature() (localctx ILockdown_featureContext) { + localctx = NewLockdown_featureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, PlSqlParserRULE_lockdown_feature) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3620) + p.Disable_enable() + } + { + p.SetState(3621) + p.Match(PlSqlParserFEATURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEQUALS_OP: + { + p.SetState(3622) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3623) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3624) + p.String_list() + } + { + p.SetState(3625) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(3627) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPT { + { + p.SetState(3628) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3629) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3630) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3631) + p.String_list() + } + { + p.SetState(3632) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockdown_optionsContext is an interface to support dynamic dispatch. +type ILockdown_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + OPTION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_optionsContext differentiates from other interfaces. + IsLockdown_optionsContext() +} + +type Lockdown_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_optionsContext() *Lockdown_optionsContext { + var p = new(Lockdown_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_options + return p +} + +func InitEmptyLockdown_optionsContext(p *Lockdown_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_options +} + +func (*Lockdown_optionsContext) IsLockdown_optionsContext() {} + +func NewLockdown_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_optionsContext { + var p = new(Lockdown_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_options + + return p +} + +func (s *Lockdown_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_optionsContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_optionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Lockdown_optionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_optionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_optionsContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Lockdown_optionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_optionsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_optionsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_options(s) + } +} + +func (s *Lockdown_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_options(s) + } +} + +func (p *PlSqlParser) Lockdown_options() (localctx ILockdown_optionsContext) { + localctx = NewLockdown_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, PlSqlParserRULE_lockdown_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3638) + p.Disable_enable() + } + { + p.SetState(3639) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEQUALS_OP: + { + p.SetState(3640) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3641) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3642) + p.String_list() + } + { + p.SetState(3643) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(3645) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPT { + { + p.SetState(3646) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3647) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3648) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3649) + p.String_list() + } + { + p.SetState(3650) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockdown_statementsContext is an interface to support dynamic dispatch. +type ILockdown_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + STATEMENT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Statement_clauses() IStatement_clausesContext + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_statementsContext differentiates from other interfaces. + IsLockdown_statementsContext() +} + +type Lockdown_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_statementsContext() *Lockdown_statementsContext { + var p = new(Lockdown_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_statements + return p +} + +func InitEmptyLockdown_statementsContext(p *Lockdown_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_statements +} + +func (*Lockdown_statementsContext) IsLockdown_statementsContext() {} + +func NewLockdown_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_statementsContext { + var p = new(Lockdown_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_statements + + return p +} + +func (s *Lockdown_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_statementsContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_statementsContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Lockdown_statementsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_statementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_statementsContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Lockdown_statementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_statementsContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Lockdown_statementsContext) Statement_clauses() IStatement_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_clausesContext) +} + +func (s *Lockdown_statementsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_statementsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_statements(s) + } +} + +func (s *Lockdown_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_statements(s) + } +} + +func (p *PlSqlParser) Lockdown_statements() (localctx ILockdown_statementsContext) { + localctx = NewLockdown_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, PlSqlParserRULE_lockdown_statements) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3656) + p.Disable_enable() + } + { + p.SetState(3657) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 164, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3658) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3660) + p.String_list() + } + { + p.SetState(3661) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3663) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3664) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3665) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3666) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3667) + p.Statement_clauses() + } + + case 3: + { + p.SetState(3668) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPT { + { + p.SetState(3669) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3670) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3671) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3672) + p.String_list() + } + { + p.SetState(3673) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatement_clausesContext is an interface to support dynamic dispatch. +type IStatement_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLAUSE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Clause_options() IClause_optionsContext + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsStatement_clausesContext differentiates from other interfaces. + IsStatement_clausesContext() +} + +type Statement_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatement_clausesContext() *Statement_clausesContext { + var p = new(Statement_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement_clauses + return p +} + +func InitEmptyStatement_clausesContext(p *Statement_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement_clauses +} + +func (*Statement_clausesContext) IsStatement_clausesContext() {} + +func NewStatement_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statement_clausesContext { + var p = new(Statement_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statement_clauses + + return p +} + +func (s *Statement_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statement_clausesContext) CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLAUSE, 0) +} + +func (s *Statement_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Statement_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Statement_clausesContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Statement_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Statement_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Statement_clausesContext) Clause_options() IClause_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClause_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClause_optionsContext) +} + +func (s *Statement_clausesContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Statement_clausesContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Statement_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statement_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statement_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatement_clauses(s) + } +} + +func (s *Statement_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatement_clauses(s) + } +} + +func (p *PlSqlParser) Statement_clauses() (localctx IStatement_clausesContext) { + localctx = NewStatement_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, PlSqlParserRULE_statement_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3679) + p.Match(PlSqlParserCLAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 166, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3680) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3681) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3682) + p.String_list() + } + { + p.SetState(3683) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3685) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3686) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3687) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3689) + p.Clause_options() + } + + case 3: + { + p.SetState(3690) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPT { + { + p.SetState(3691) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3692) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3693) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3694) + p.String_list() + } + { + p.SetState(3695) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClause_optionsContext is an interface to support dynamic dispatch. +type IClause_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + ALL() antlr.TerminalNode + AllOption_values() []IOption_valuesContext + Option_values(i int) IOption_valuesContext + EXCEPT() antlr.TerminalNode + + // IsClause_optionsContext differentiates from other interfaces. + IsClause_optionsContext() +} + +type Clause_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClause_optionsContext() *Clause_optionsContext { + var p = new(Clause_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clause_options + return p +} + +func InitEmptyClause_optionsContext(p *Clause_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clause_options +} + +func (*Clause_optionsContext) IsClause_optionsContext() {} + +func NewClause_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clause_optionsContext { + var p = new(Clause_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clause_options + + return p +} + +func (s *Clause_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clause_optionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Clause_optionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Clause_optionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clause_optionsContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Clause_optionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clause_optionsContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Clause_optionsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Clause_optionsContext) AllOption_values() []IOption_valuesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOption_valuesContext); ok { + len++ + } + } + + tst := make([]IOption_valuesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOption_valuesContext); ok { + tst[i] = t.(IOption_valuesContext) + i++ + } + } + + return tst +} + +func (s *Clause_optionsContext) Option_values(i int) IOption_valuesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_valuesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOption_valuesContext) +} + +func (s *Clause_optionsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Clause_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clause_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clause_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClause_options(s) + } +} + +func (s *Clause_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClause_options(s) + } +} + +func (p *PlSqlParser) Clause_options() (localctx IClause_optionsContext) { + localctx = NewClause_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, PlSqlParserRULE_clause_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3701) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 169, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3702) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3703) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3704) + p.String_list() + } + { + p.SetState(3705) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3707) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3708) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3709) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3710) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || _la == PlSqlParserVALUE { + { + p.SetState(3711) + p.Option_values() + } + + p.SetState(3714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(3716) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPT { + { + p.SetState(3717) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3718) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3719) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3720) + p.String_list() + } + { + p.SetState(3721) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOption_valuesContext is an interface to support dynamic dispatch. +type IOption_valuesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + + // IsOption_valuesContext differentiates from other interfaces. + IsOption_valuesContext() +} + +type Option_valuesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOption_valuesContext() *Option_valuesContext { + var p = new(Option_valuesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_option_values + return p +} + +func InitEmptyOption_valuesContext(p *Option_valuesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_option_values +} + +func (*Option_valuesContext) IsOption_valuesContext() {} + +func NewOption_valuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_valuesContext { + var p = new(Option_valuesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_option_values + + return p +} + +func (s *Option_valuesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Option_valuesContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Option_valuesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Option_valuesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Option_valuesContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Option_valuesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Option_valuesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Option_valuesContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Option_valuesContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Option_valuesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Option_valuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Option_valuesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOption_values(s) + } +} + +func (s *Option_valuesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOption_values(s) + } +} + +func (p *PlSqlParser) Option_values() (localctx IOption_valuesContext) { + localctx = NewOption_valuesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, PlSqlParserRULE_option_values) + var _la int + + p.SetState(3736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALUE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3727) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3728) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3729) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3730) + p.String_list() + } + { + p.SetState(3731) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXVALUE, PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3733) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3734) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3735) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_listContext is an interface to support dynamic dispatch. +type IString_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsString_listContext differentiates from other interfaces. + IsString_listContext() +} + +type String_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_listContext() *String_listContext { + var p = new(String_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_list + return p +} + +func InitEmptyString_listContext(p *String_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_list +} + +func (*String_listContext) IsString_listContext() {} + +func NewString_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_listContext { + var p = new(String_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_string_list + + return p +} + +func (s *String_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_listContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *String_listContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *String_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *String_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *String_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterString_list(s) + } +} + +func (s *String_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_list(s) + } +} + +func (p *PlSqlParser) String_list() (localctx IString_listContext) { + localctx = NewString_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, PlSqlParserRULE_string_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3738) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3739) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3740) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDisable_enableContext is an interface to support dynamic dispatch. +type IDisable_enableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + + // IsDisable_enableContext differentiates from other interfaces. + IsDisable_enableContext() +} + +type Disable_enableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisable_enableContext() *Disable_enableContext { + var p = new(Disable_enableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_enable + return p +} + +func InitEmptyDisable_enableContext(p *Disable_enableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_enable +} + +func (*Disable_enableContext) IsDisable_enableContext() {} + +func NewDisable_enableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disable_enableContext { + var p = new(Disable_enableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disable_enable + + return p +} + +func (s *Disable_enableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disable_enableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Disable_enableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Disable_enableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disable_enableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disable_enableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisable_enable(s) + } +} + +func (s *Disable_enableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisable_enable(s) + } +} + +func (p *PlSqlParser) Disable_enable() (localctx IDisable_enableContext) { + localctx = NewDisable_enableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, PlSqlParserRULE_disable_enable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3746) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_lockdown_profileContext is an interface to support dynamic dispatch. +type IDrop_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_lockdown_profileContext differentiates from other interfaces. + IsDrop_lockdown_profileContext() +} + +type Drop_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyDrop_lockdown_profileContext() *Drop_lockdown_profileContext { + var p = new(Drop_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile + return p +} + +func InitEmptyDrop_lockdown_profileContext(p *Drop_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile +} + +func (*Drop_lockdown_profileContext) IsDrop_lockdown_profileContext() {} + +func NewDrop_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_lockdown_profileContext { + var p = new(Drop_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile + + return p +} + +func (s *Drop_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_lockdown_profileContext) GetP() IId_expressionContext { return s.p } + +func (s *Drop_lockdown_profileContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Drop_lockdown_profileContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Drop_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Drop_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_lockdown_profile(s) + } +} + +func (s *Drop_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_lockdown_profile(s) + } +} + +func (p *PlSqlParser) Drop_lockdown_profile() (localctx IDrop_lockdown_profileContext) { + localctx = NewDrop_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, PlSqlParserRULE_drop_lockdown_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3748) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3749) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3750) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3751) + + var _x = p.Id_expression() + + localctx.(*Drop_lockdown_profileContext).p = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_packageContext is an interface to support dynamic dispatch. +type IDrop_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + Package_name() IPackage_nameContext + BODY() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_packageContext differentiates from other interfaces. + IsDrop_packageContext() +} + +type Drop_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_packageContext() *Drop_packageContext { + var p = new(Drop_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_package + return p +} + +func InitEmptyDrop_packageContext(p *Drop_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_package +} + +func (*Drop_packageContext) IsDrop_packageContext() {} + +func NewDrop_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_packageContext { + var p = new(Drop_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_package + + return p +} + +func (s *Drop_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_packageContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_packageContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Drop_packageContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Drop_packageContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Drop_packageContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Drop_packageContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_package(s) + } +} + +func (s *Drop_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_package(s) + } +} + +func (p *PlSqlParser) Drop_package() (localctx IDrop_packageContext) { + localctx = NewDrop_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, PlSqlParserRULE_drop_package) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3753) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3754) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) == 1 { + { + p.SetState(3755) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 173, p.GetParserRuleContext()) == 1 { + { + p.SetState(3758) + p.Schema_object_name() + } + { + p.SetState(3759) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3763) + p.Package_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_packageContext is an interface to support dynamic dispatch. +type IAlter_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllPACKAGE() []antlr.TerminalNode + PACKAGE(i int) antlr.TerminalNode + Package_name() IPackage_nameContext + COMPILE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + BODY() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + + // IsAlter_packageContext differentiates from other interfaces. + IsAlter_packageContext() +} + +type Alter_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_packageContext() *Alter_packageContext { + var p = new(Alter_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_package + return p +} + +func InitEmptyAlter_packageContext(p *Alter_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_package +} + +func (*Alter_packageContext) IsAlter_packageContext() {} + +func NewAlter_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_packageContext { + var p = new(Alter_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_package + + return p +} + +func (s *Alter_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_packageContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_packageContext) AllPACKAGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPACKAGE) +} + +func (s *Alter_packageContext) PACKAGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, i) +} + +func (s *Alter_packageContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Alter_packageContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_packageContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_packageContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_packageContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_packageContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_packageContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_packageContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Alter_packageContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Alter_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_package(s) + } +} + +func (s *Alter_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_package(s) + } +} + +func (p *PlSqlParser) Alter_package() (localctx IAlter_packageContext) { + localctx = NewAlter_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, PlSqlParserRULE_alter_package) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3765) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3766) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3767) + p.Package_name() + } + { + p.SetState(3768) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3770) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 174, p.GetParserRuleContext()) == 1 { + { + p.SetState(3769) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3773) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 175, p.GetParserRuleContext()) == 1 { + { + p.SetState(3772) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBODY || _la == PlSqlParserPACKAGE || _la == PlSqlParserSPECIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 176, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3775) + p.Compiler_parameters_clause() + } + + } + p.SetState(3780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 176, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3781) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3782) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_packageContext is an interface to support dynamic dispatch. +type ICreate_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + END() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllPackage_obj_spec() []IPackage_obj_specContext + Package_obj_spec(i int) IPackage_obj_specContext + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsCreate_packageContext differentiates from other interfaces. + IsCreate_packageContext() +} + +type Create_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_packageContext() *Create_packageContext { + var p = new(Create_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package + return p +} + +func InitEmptyCreate_packageContext(p *Create_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package +} + +func (*Create_packageContext) IsCreate_packageContext() {} + +func NewCreate_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_packageContext { + var p = new(Create_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_package + + return p +} + +func (s *Create_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_packageContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_packageContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Create_packageContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_packageContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_packageContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Create_packageContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_packageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_packageContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_packageContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_packageContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_packageContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_packageContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_packageContext) AllPackage_obj_spec() []IPackage_obj_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_obj_specContext); ok { + len++ + } + } + + tst := make([]IPackage_obj_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_obj_specContext); ok { + tst[i] = t.(IPackage_obj_specContext) + i++ + } + } + + return tst +} + +func (s *Create_packageContext) Package_obj_spec(i int) IPackage_obj_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_obj_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_obj_specContext) +} + +func (s *Create_packageContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_packageContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_package(s) + } +} + +func (s *Create_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_package(s) + } +} + +func (p *PlSqlParser) Create_package() (localctx ICreate_packageContext) { + localctx = NewCreate_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, PlSqlParserRULE_create_package) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3785) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3786) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3787) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(3790) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3793) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3797) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 180, p.GetParserRuleContext()) == 1 { + { + p.SetState(3794) + p.Schema_object_name() + } + { + p.SetState(3795) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3799) + p.Package_name() + } + p.SetState(3801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(3800) + p.Invoker_rights_clause() + } + + } + { + p.SetState(3803) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(3804) + p.Package_obj_spec() + } + + p.SetState(3809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3810) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(3811) + p.Package_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_package_bodyContext is an interface to support dynamic dispatch. +type ICreate_package_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + BODY() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + END() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + AllPackage_obj_body() []IPackage_obj_bodyContext + Package_obj_body(i int) IPackage_obj_bodyContext + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + AllException_handler() []IException_handlerContext + Exception_handler(i int) IException_handlerContext + + // IsCreate_package_bodyContext differentiates from other interfaces. + IsCreate_package_bodyContext() +} + +type Create_package_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_package_bodyContext() *Create_package_bodyContext { + var p = new(Create_package_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package_body + return p +} + +func InitEmptyCreate_package_bodyContext(p *Create_package_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package_body +} + +func (*Create_package_bodyContext) IsCreate_package_bodyContext() {} + +func NewCreate_package_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_package_bodyContext { + var p = new(Create_package_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_package_body + + return p +} + +func (s *Create_package_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_package_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_package_bodyContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Create_package_bodyContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Create_package_bodyContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_package_bodyContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_package_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Create_package_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_package_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_package_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_package_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_package_bodyContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_package_bodyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_package_bodyContext) AllPackage_obj_body() []IPackage_obj_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_obj_bodyContext); ok { + len++ + } + } + + tst := make([]IPackage_obj_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_obj_bodyContext); ok { + tst[i] = t.(IPackage_obj_bodyContext) + i++ + } + } + + return tst +} + +func (s *Create_package_bodyContext) Package_obj_body(i int) IPackage_obj_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_obj_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_obj_bodyContext) +} + +func (s *Create_package_bodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Create_package_bodyContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Create_package_bodyContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_package_bodyContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_package_bodyContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Create_package_bodyContext) AllException_handler() []IException_handlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_handlerContext); ok { + len++ + } + } + + tst := make([]IException_handlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_handlerContext); ok { + tst[i] = t.(IException_handlerContext) + i++ + } + } + + return tst +} + +func (s *Create_package_bodyContext) Exception_handler(i int) IException_handlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_handlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_handlerContext) +} + +func (s *Create_package_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_package_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_package_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_package_body(s) + } +} + +func (s *Create_package_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_package_body(s) + } +} + +func (p *PlSqlParser) Create_package_body() (localctx ICreate_package_bodyContext) { + localctx = NewCreate_package_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, PlSqlParserRULE_create_package_body) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3814) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3815) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3816) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(3819) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3822) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3823) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3827) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 186, p.GetParserRuleContext()) == 1 { + { + p.SetState(3824) + p.Schema_object_name() + } + { + p.SetState(3825) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3829) + p.Package_name() + } + { + p.SetState(3830) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 187, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 1 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1+1 { + { + p.SetState(3831) + p.Package_obj_body() + } + + } + p.SetState(3836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 187, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBEGIN { + { + p.SetState(3837) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3838) + p.Seq_of_statements() + } + p.SetState(3845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTION { + { + p.SetState(3839) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(3840) + p.Exception_handler() + } + + p.SetState(3843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + } + { + p.SetState(3849) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(3850) + p.Package_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPackage_obj_specContext is an interface to support dynamic dispatch. +type IPackage_obj_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pragma_declaration() IPragma_declarationContext + Exception_declaration() IException_declarationContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + Variable_declaration() IVariable_declarationContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Type_declaration() IType_declarationContext + + // IsPackage_obj_specContext differentiates from other interfaces. + IsPackage_obj_specContext() +} + +type Package_obj_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_obj_specContext() *Package_obj_specContext { + var p = new(Package_obj_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_spec + return p +} + +func InitEmptyPackage_obj_specContext(p *Package_obj_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_spec +} + +func (*Package_obj_specContext) IsPackage_obj_specContext() {} + +func NewPackage_obj_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_obj_specContext { + var p = new(Package_obj_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_obj_spec + + return p +} + +func (s *Package_obj_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_obj_specContext) Pragma_declaration() IPragma_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Package_obj_specContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Package_obj_specContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Package_obj_specContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Package_obj_specContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Package_obj_specContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Package_obj_specContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Package_obj_specContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Package_obj_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_obj_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_obj_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_obj_spec(s) + } +} + +func (s *Package_obj_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_obj_spec(s) + } +} + +func (p *PlSqlParser) Package_obj_spec() (localctx IPackage_obj_specContext) { + localctx = NewPackage_obj_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, PlSqlParserRULE_package_obj_spec) + p.SetState(3861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 192, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3853) + p.Pragma_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3854) + p.Exception_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3855) + p.Procedure_spec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3856) + p.Function_spec() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3857) + p.Variable_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3858) + p.Subtype_declaration() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3859) + p.Cursor_declaration() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3860) + p.Type_declaration() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_specContext is an interface to support dynamic dispatch. +type IProcedure_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllAccessible_by_clause() []IAccessible_by_clauseContext + Accessible_by_clause(i int) IAccessible_by_clauseContext + AllPARALLEL_ENABLE() []antlr.TerminalNode + PARALLEL_ENABLE(i int) antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsProcedure_specContext differentiates from other interfaces. + IsProcedure_specContext() +} + +type Procedure_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_specContext() *Procedure_specContext { + var p = new(Procedure_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_spec + return p +} + +func InitEmptyProcedure_specContext(p *Procedure_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_spec +} + +func (*Procedure_specContext) IsProcedure_specContext() {} + +func NewProcedure_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_specContext { + var p = new(Procedure_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_spec + + return p +} + +func (s *Procedure_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_specContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Procedure_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Procedure_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Procedure_specContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Procedure_specContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Procedure_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Procedure_specContext) AllAccessible_by_clause() []IAccessible_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + len++ + } + } + + tst := make([]IAccessible_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccessible_by_clauseContext); ok { + tst[i] = t.(IAccessible_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Procedure_specContext) Accessible_by_clause(i int) IAccessible_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccessible_by_clauseContext) +} + +func (s *Procedure_specContext) AllPARALLEL_ENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARALLEL_ENABLE) +} + +func (s *Procedure_specContext) PARALLEL_ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, i) +} + +func (s *Procedure_specContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Procedure_specContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Procedure_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Procedure_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Procedure_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Procedure_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Procedure_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_spec(s) + } +} + +func (s *Procedure_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_spec(s) + } +} + +func (p *PlSqlParser) Procedure_spec() (localctx IProcedure_specContext) { + localctx = NewProcedure_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, PlSqlParserRULE_procedure_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3863) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3864) + p.Identifier() + } + p.SetState(3876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3865) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3866) + p.Parameter() + } + p.SetState(3871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3867) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3868) + p.Parameter() + } + + p.SetState(3873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3874) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserACCESSIBLE || _la == PlSqlParserDETERMINISTIC || _la == PlSqlParserPARALLEL_ENABLE { + p.SetState(3881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserACCESSIBLE: + { + p.SetState(3878) + p.Accessible_by_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(3879) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(3880) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(3886) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3887) + p.Call_spec() + } + + } + { + p.SetState(3890) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_specContext is an interface to support dynamic dispatch. +type IFunction_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Identifier() IIdentifierContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + AllPIPELINED() []antlr.TerminalNode + PIPELINED(i int) antlr.TerminalNode + AllParallel_enable_clause() []IParallel_enable_clauseContext + Parallel_enable_clause(i int) IParallel_enable_clauseContext + AllRESULT_CACHE() []antlr.TerminalNode + RESULT_CACHE(i int) antlr.TerminalNode + AllStreaming_clause() []IStreaming_clauseContext + Streaming_clause(i int) IStreaming_clauseContext + AS() antlr.TerminalNode + Call_spec() ICall_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_specContext differentiates from other interfaces. + IsFunction_specContext() +} + +type Function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_specContext() *Function_specContext { + var p = new(Function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_spec + return p +} + +func InitEmptyFunction_specContext(p *Function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_spec +} + +func (*Function_specContext) IsFunction_specContext() {} + +func NewFunction_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_specContext { + var p = new(Function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_spec + + return p +} + +func (s *Function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Function_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Function_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_specContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Function_specContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_specContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Function_specContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Function_specContext) AllPIPELINED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPIPELINED) +} + +func (s *Function_specContext) PIPELINED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, i) +} + +func (s *Function_specContext) AllParallel_enable_clause() []IParallel_enable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_enable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_enable_clauseContext); ok { + tst[i] = t.(IParallel_enable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_specContext) Parallel_enable_clause(i int) IParallel_enable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_enable_clauseContext) +} + +func (s *Function_specContext) AllRESULT_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRESULT_CACHE) +} + +func (s *Function_specContext) RESULT_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, i) +} + +func (s *Function_specContext) AllStreaming_clause() []IStreaming_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStreaming_clauseContext); ok { + len++ + } + } + + tst := make([]IStreaming_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStreaming_clauseContext); ok { + tst[i] = t.(IStreaming_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_specContext) Streaming_clause(i int) IStreaming_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStreaming_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStreaming_clauseContext) +} + +func (s *Function_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Function_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_spec(s) + } +} + +func (s *Function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_spec(s) + } +} + +func (p *PlSqlParser) Function_spec() (localctx IFunction_specContext) { + localctx = NewFunction_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, PlSqlParserRULE_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3892) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3893) + p.Identifier() + } + p.SetState(3905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3894) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3895) + p.Parameter() + } + p.SetState(3900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3896) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3897) + p.Parameter() + } + + p.SetState(3902) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3903) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3907) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3908) + p.Type_spec() + } + p.SetState(3916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCLUSTER || _la == PlSqlParserDETERMINISTIC || _la == PlSqlParserORDER || _la == PlSqlParserPARALLEL_ENABLE || _la == PlSqlParserPIPELINED || _la == PlSqlParserRESULT_CACHE { + p.SetState(3914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDETERMINISTIC: + { + p.SetState(3909) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPIPELINED: + { + p.SetState(3910) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(3911) + p.Parallel_enable_clause() + } + + case PlSqlParserRESULT_CACHE: + { + p.SetState(3912) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLUSTER, PlSqlParserORDER: + { + p.SetState(3913) + p.Streaming_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(3919) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3920) + p.Call_spec() + } + + } + { + p.SetState(3923) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPackage_obj_bodyContext is an interface to support dynamic dispatch. +type IPackage_obj_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pragma_declaration() IPragma_declarationContext + Exception_declaration() IException_declarationContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Variable_declaration() IVariable_declarationContext + Type_declaration() IType_declarationContext + Procedure_body() IProcedure_bodyContext + Function_body() IFunction_bodyContext + Selection_directive() ISelection_directiveContext + + // IsPackage_obj_bodyContext differentiates from other interfaces. + IsPackage_obj_bodyContext() +} + +type Package_obj_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_obj_bodyContext() *Package_obj_bodyContext { + var p = new(Package_obj_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_body + return p +} + +func InitEmptyPackage_obj_bodyContext(p *Package_obj_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_body +} + +func (*Package_obj_bodyContext) IsPackage_obj_bodyContext() {} + +func NewPackage_obj_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_obj_bodyContext { + var p = new(Package_obj_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_obj_body + + return p +} + +func (s *Package_obj_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_obj_bodyContext) Pragma_declaration() IPragma_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Package_obj_bodyContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Package_obj_bodyContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Package_obj_bodyContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Package_obj_bodyContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Package_obj_bodyContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Package_obj_bodyContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Package_obj_bodyContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Package_obj_bodyContext) Procedure_body() IProcedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *Package_obj_bodyContext) Function_body() IFunction_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *Package_obj_bodyContext) Selection_directive() ISelection_directiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelection_directiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelection_directiveContext) +} + +func (s *Package_obj_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_obj_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_obj_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_obj_body(s) + } +} + +func (s *Package_obj_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_obj_body(s) + } +} + +func (p *PlSqlParser) Package_obj_body() (localctx IPackage_obj_bodyContext) { + localctx = NewPackage_obj_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, PlSqlParserRULE_package_obj_body) + p.SetState(3936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 203, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3925) + p.Pragma_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3926) + p.Exception_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3927) + p.Procedure_spec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3928) + p.Function_spec() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3929) + p.Subtype_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3930) + p.Cursor_declaration() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3931) + p.Variable_declaration() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3932) + p.Type_declaration() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3933) + p.Procedure_body() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3934) + p.Function_body() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3935) + p.Selection_directive() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_pmem_filestoreContext is an interface to support dynamic dispatch. +type IAlter_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + MOUNT() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + MOUNTPOINT() antlr.TerminalNode + File_path() IFile_pathContext + BACKINGFILE() antlr.TerminalNode + Filename() IFilenameContext + FORCE() antlr.TerminalNode + + // IsAlter_pmem_filestoreContext differentiates from other interfaces. + IsAlter_pmem_filestoreContext() +} + +type Alter_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyAlter_pmem_filestoreContext() *Alter_pmem_filestoreContext { + var p = new(Alter_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore + return p +} + +func InitEmptyAlter_pmem_filestoreContext(p *Alter_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore +} + +func (*Alter_pmem_filestoreContext) IsAlter_pmem_filestoreContext() {} + +func NewAlter_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_pmem_filestoreContext { + var p = new(Alter_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore + + return p +} + +func (s *Alter_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Alter_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Alter_pmem_filestoreContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Alter_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Alter_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_pmem_filestoreContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_pmem_filestoreContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_pmem_filestoreContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_pmem_filestoreContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Alter_pmem_filestoreContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Alter_pmem_filestoreContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Alter_pmem_filestoreContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Alter_pmem_filestoreContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Alter_pmem_filestoreContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_pmem_filestoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_pmem_filestore(s) + } +} + +func (s *Alter_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_pmem_filestore(s) + } +} + +func (p *PlSqlParser) Alter_pmem_filestore() (localctx IAlter_pmem_filestoreContext) { + localctx = NewAlter_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, PlSqlParserRULE_alter_pmem_filestore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3938) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3939) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3940) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3941) + + var _x = p.Id_expression() + + localctx.(*Alter_pmem_filestoreContext).fsn = _x + } + p.SetState(3958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESIZE: + { + p.SetState(3942) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3943) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(3944) + p.Autoextend_clause() + } + + case PlSqlParserMOUNT: + { + p.SetState(3945) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMOUNTPOINT { + { + p.SetState(3946) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3947) + p.File_path() + } + + } + p.SetState(3952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBACKINGFILE { + { + p.SetState(3950) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3951) + p.Filename() + } + + } + p.SetState(3955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(3954) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserDISMOUNT: + { + p.SetState(3957) + p.Match(PlSqlParserDISMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_pmem_filestoreContext is an interface to support dynamic dispatch. +type IDrop_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + CONTENTS() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_pmem_filestoreContext differentiates from other interfaces. + IsDrop_pmem_filestoreContext() +} + +type Drop_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyDrop_pmem_filestoreContext() *Drop_pmem_filestoreContext { + var p = new(Drop_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore + return p +} + +func InitEmptyDrop_pmem_filestoreContext(p *Drop_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore +} + +func (*Drop_pmem_filestoreContext) IsDrop_pmem_filestoreContext() {} + +func NewDrop_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_pmem_filestoreContext { + var p = new(Drop_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore + + return p +} + +func (s *Drop_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Drop_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Drop_pmem_filestoreContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Drop_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Drop_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_pmem_filestoreContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Drop_pmem_filestoreContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_pmem_filestoreContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Drop_pmem_filestoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_pmem_filestore(s) + } +} + +func (s *Drop_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_pmem_filestore(s) + } +} + +func (p *PlSqlParser) Drop_pmem_filestore() (localctx IDrop_pmem_filestoreContext) { + localctx = NewDrop_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, PlSqlParserRULE_drop_pmem_filestore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3960) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3961) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3962) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3963) + + var _x = p.Id_expression() + + localctx.(*Drop_pmem_filestoreContext).fsn = _x + } + p.SetState(3972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserFORCE || _la == PlSqlParserINCLUDING { + p.SetState(3969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFORCE, PlSqlParserINCLUDING: + p.SetState(3965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(3964) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3967) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLUDING: + { + p.SetState(3968) + p.Match(PlSqlParserEXCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3971) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_procedureContext is an interface to support dynamic dispatch. +type IDrop_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + + // IsDrop_procedureContext differentiates from other interfaces. + IsDrop_procedureContext() +} + +type Drop_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_procedureContext() *Drop_procedureContext { + var p = new(Drop_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_procedure + return p +} + +func InitEmptyDrop_procedureContext(p *Drop_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_procedure +} + +func (*Drop_procedureContext) IsDrop_procedureContext() {} + +func NewDrop_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_procedureContext { + var p = new(Drop_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_procedure + + return p +} + +func (s *Drop_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_procedureContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Drop_procedureContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Drop_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_procedure(s) + } +} + +func (p *PlSqlParser) Drop_procedure() (localctx IDrop_procedureContext) { + localctx = NewDrop_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, PlSqlParserRULE_drop_procedure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3974) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3975) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3976) + p.Procedure_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_procedureContext is an interface to support dynamic dispatch. +type IAlter_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + COMPILE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_procedureContext differentiates from other interfaces. + IsAlter_procedureContext() +} + +type Alter_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_procedureContext() *Alter_procedureContext { + var p = new(Alter_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_procedure + return p +} + +func InitEmptyAlter_procedureContext(p *Alter_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_procedure +} + +func (*Alter_procedureContext) IsAlter_procedureContext() {} + +func NewAlter_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_procedureContext { + var p = new(Alter_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_procedure + + return p +} + +func (s *Alter_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_procedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Alter_procedureContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Alter_procedureContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_procedureContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_procedureContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_procedureContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_procedureContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_procedureContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_procedure(s) + } +} + +func (s *Alter_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_procedure(s) + } +} + +func (p *PlSqlParser) Alter_procedure() (localctx IAlter_procedureContext) { + localctx = NewAlter_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, PlSqlParserRULE_alter_procedure) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3978) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3979) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3980) + p.Procedure_name() + } + { + p.SetState(3981) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3983) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 211, p.GetParserRuleContext()) == 1 { + { + p.SetState(3982) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 212, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3985) + p.Compiler_parameters_clause() + } + + } + p.SetState(3990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 212, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3991) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3992) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_bodyContext is an interface to support dynamic dispatch. +type IFunction_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Identifier() IIdentifierContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + USING() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllPIPELINED() []antlr.TerminalNode + PIPELINED(i int) antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + AllInvoker_rights_clause() []IInvoker_rights_clauseContext + Invoker_rights_clause(i int) IInvoker_rights_clauseContext + AllParallel_enable_clause() []IParallel_enable_clauseContext + Parallel_enable_clause(i int) IParallel_enable_clauseContext + AllResult_cache_clause() []IResult_cache_clauseContext + Result_cache_clause(i int) IResult_cache_clauseContext + AllStreaming_clause() []IStreaming_clauseContext + Streaming_clause(i int) IStreaming_clauseContext + AGGREGATE() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsFunction_bodyContext differentiates from other interfaces. + IsFunction_bodyContext() +} + +type Function_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_bodyContext() *Function_bodyContext { + var p = new(Function_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_body + return p +} + +func InitEmptyFunction_bodyContext(p *Function_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_body +} + +func (*Function_bodyContext) IsFunction_bodyContext() {} + +func NewFunction_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_bodyContext { + var p = new(Function_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_body + + return p +} + +func (s *Function_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_bodyContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Function_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Function_bodyContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Function_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Function_bodyContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Function_bodyContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Function_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Function_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_bodyContext) AllPIPELINED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPIPELINED) +} + +func (s *Function_bodyContext) PIPELINED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, i) +} + +func (s *Function_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Function_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Function_bodyContext) AllInvoker_rights_clause() []IInvoker_rights_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + len++ + } + } + + tst := make([]IInvoker_rights_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInvoker_rights_clauseContext); ok { + tst[i] = t.(IInvoker_rights_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Invoker_rights_clause(i int) IInvoker_rights_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Function_bodyContext) AllParallel_enable_clause() []IParallel_enable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_enable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_enable_clauseContext); ok { + tst[i] = t.(IParallel_enable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Parallel_enable_clause(i int) IParallel_enable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_enable_clauseContext) +} + +func (s *Function_bodyContext) AllResult_cache_clause() []IResult_cache_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + len++ + } + } + + tst := make([]IResult_cache_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResult_cache_clauseContext); ok { + tst[i] = t.(IResult_cache_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Result_cache_clause(i int) IResult_cache_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Function_bodyContext) AllStreaming_clause() []IStreaming_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStreaming_clauseContext); ok { + len++ + } + } + + tst := make([]IStreaming_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStreaming_clauseContext); ok { + tst[i] = t.(IStreaming_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Streaming_clause(i int) IStreaming_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStreaming_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStreaming_clauseContext) +} + +func (s *Function_bodyContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Function_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Function_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Function_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Function_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Function_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Function_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Function_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_body(s) + } +} + +func (s *Function_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_body(s) + } +} + +func (p *PlSqlParser) Function_body() (localctx IFunction_bodyContext) { + localctx = NewFunction_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, PlSqlParserRULE_function_body) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3995) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3996) + p.Identifier() + } + p.SetState(4008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3997) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3998) + p.Parameter() + } + p.SetState(4003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3999) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4000) + p.Parameter() + } + + p.SetState(4005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4006) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4010) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4011) + p.Type_spec() + } + p.SetState(4020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(4018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPIPELINED: + { + p.SetState(4012) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(4013) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTHID: + { + p.SetState(4014) + p.Invoker_rights_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(4015) + p.Parallel_enable_clause() + } + + case PlSqlParserRESULT_CACHE: + { + p.SetState(4016) + p.Result_cache_clause() + } + + case PlSqlParserCLUSTER, PlSqlParserORDER: + { + p.SetState(4017) + p.Streaming_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(4023) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 220, p.GetParserRuleContext()) { + case 1: + p.SetState(4025) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 218, p.GetParserRuleContext()) == 1 { + { + p.SetState(4024) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4028) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) == 1 { + { + p.SetState(4027) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4030) + p.Body() + } + + case 2: + { + p.SetState(4031) + p.Call_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAGGREGATE, PlSqlParserPIPELINED: + { + p.SetState(4034) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAGGREGATE || _la == PlSqlParserPIPELINED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4035) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4036) + p.Implementation_type_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4039) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_bodyContext is an interface to support dynamic dispatch. +type IProcedure_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllAccessible_by_clause() []IAccessible_by_clauseContext + Accessible_by_clause(i int) IAccessible_by_clauseContext + AllPARALLEL_ENABLE() []antlr.TerminalNode + PARALLEL_ENABLE(i int) antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsProcedure_bodyContext differentiates from other interfaces. + IsProcedure_bodyContext() +} + +type Procedure_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_bodyContext() *Procedure_bodyContext { + var p = new(Procedure_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_body + return p +} + +func InitEmptyProcedure_bodyContext(p *Procedure_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_body +} + +func (*Procedure_bodyContext) IsProcedure_bodyContext() {} + +func NewProcedure_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_bodyContext { + var p = new(Procedure_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_body + + return p +} + +func (s *Procedure_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_bodyContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Procedure_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Procedure_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Procedure_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Procedure_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Procedure_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Procedure_bodyContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Procedure_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Procedure_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Procedure_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Procedure_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Procedure_bodyContext) AllAccessible_by_clause() []IAccessible_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + len++ + } + } + + tst := make([]IAccessible_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccessible_by_clauseContext); ok { + tst[i] = t.(IAccessible_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Procedure_bodyContext) Accessible_by_clause(i int) IAccessible_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccessible_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccessible_by_clauseContext) +} + +func (s *Procedure_bodyContext) AllPARALLEL_ENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARALLEL_ENABLE) +} + +func (s *Procedure_bodyContext) PARALLEL_ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, i) +} + +func (s *Procedure_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Procedure_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Procedure_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Procedure_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Procedure_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Procedure_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Procedure_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_body(s) + } +} + +func (s *Procedure_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_body(s) + } +} + +func (p *PlSqlParser) Procedure_body() (localctx IProcedure_bodyContext) { + localctx = NewProcedure_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, PlSqlParserRULE_procedure_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4041) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4042) + p.Identifier() + } + p.SetState(4054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4043) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4044) + p.Parameter() + } + p.SetState(4049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4045) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4046) + p.Parameter() + } + + p.SetState(4051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4052) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserACCESSIBLE || _la == PlSqlParserDETERMINISTIC || _la == PlSqlParserPARALLEL_ENABLE { + p.SetState(4059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserACCESSIBLE: + { + p.SetState(4056) + p.Accessible_by_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(4057) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(4058) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4064) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 228, p.GetParserRuleContext()) { + case 1: + p.SetState(4066) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 { + { + p.SetState(4065) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 227, p.GetParserRuleContext()) == 1 { + { + p.SetState(4068) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4071) + p.Body() + } + + case 2: + { + p.SetState(4072) + p.Call_spec() + } + + case 3: + { + p.SetState(4073) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4076) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_procedure_bodyContext is an interface to support dynamic dispatch. +type ICreate_procedure_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllPARALLEL_ENABLE() []antlr.TerminalNode + PARALLEL_ENABLE(i int) antlr.TerminalNode + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_procedure_bodyContext differentiates from other interfaces. + IsCreate_procedure_bodyContext() +} + +type Create_procedure_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_procedure_bodyContext() *Create_procedure_bodyContext { + var p = new(Create_procedure_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_procedure_body + return p +} + +func InitEmptyCreate_procedure_bodyContext(p *Create_procedure_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_procedure_body +} + +func (*Create_procedure_bodyContext) IsCreate_procedure_bodyContext() {} + +func NewCreate_procedure_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_procedure_bodyContext { + var p = new(Create_procedure_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_procedure_body + + return p +} + +func (s *Create_procedure_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_procedure_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_procedure_bodyContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Create_procedure_bodyContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Create_procedure_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_procedure_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_procedure_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Create_procedure_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Create_procedure_bodyContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Create_procedure_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_procedure_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_procedure_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_procedure_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Create_procedure_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Create_procedure_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_procedure_bodyContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_procedure_bodyContext) AllPARALLEL_ENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARALLEL_ENABLE) +} + +func (s *Create_procedure_bodyContext) PARALLEL_ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, i) +} + +func (s *Create_procedure_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Create_procedure_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Create_procedure_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Create_procedure_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Create_procedure_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_procedure_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_procedure_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_procedure_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_procedure_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_procedure_body(s) + } +} + +func (s *Create_procedure_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_procedure_body(s) + } +} + +func (p *PlSqlParser) Create_procedure_body() (localctx ICreate_procedure_bodyContext) { + localctx = NewCreate_procedure_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, PlSqlParserRULE_create_procedure_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4078) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4079) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4080) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4083) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4084) + p.Procedure_name() + } + p.SetState(4096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4085) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4086) + p.Parameter() + } + p.SetState(4091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4087) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4088) + p.Parameter() + } + + p.SetState(4093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4094) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4098) + p.Invoker_rights_clause() + } + + } + p.SetState(4104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserDETERMINISTIC || _la == PlSqlParserPARALLEL_ENABLE { + { + p.SetState(4101) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDETERMINISTIC || _la == PlSqlParserPARALLEL_ENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(4106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4107) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) { + case 1: + p.SetState(4109) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 234, p.GetParserRuleContext()) == 1 { + { + p.SetState(4108) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4112) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) == 1 { + { + p.SetState(4111) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4114) + p.Body() + } + + case 2: + { + p.SetState(4115) + p.Call_spec() + } + + case 3: + { + p.SetState(4116) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_resource_costContext is an interface to support dynamic dispatch. +type IAlter_resource_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + COST() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCPU_PER_SESSION() []antlr.TerminalNode + CPU_PER_SESSION(i int) antlr.TerminalNode + AllCONNECT_TIME() []antlr.TerminalNode + CONNECT_TIME(i int) antlr.TerminalNode + AllLOGICAL_READS_PER_SESSION() []antlr.TerminalNode + LOGICAL_READS_PER_SESSION(i int) antlr.TerminalNode + AllPRIVATE_SGA() []antlr.TerminalNode + PRIVATE_SGA(i int) antlr.TerminalNode + + // IsAlter_resource_costContext differentiates from other interfaces. + IsAlter_resource_costContext() +} + +type Alter_resource_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_resource_costContext() *Alter_resource_costContext { + var p = new(Alter_resource_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_resource_cost + return p +} + +func InitEmptyAlter_resource_costContext(p *Alter_resource_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_resource_cost +} + +func (*Alter_resource_costContext) IsAlter_resource_costContext() {} + +func NewAlter_resource_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_resource_costContext { + var p = new(Alter_resource_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_resource_cost + + return p +} + +func (s *Alter_resource_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_resource_costContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_resource_costContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Alter_resource_costContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Alter_resource_costContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Alter_resource_costContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Alter_resource_costContext) AllCPU_PER_SESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCPU_PER_SESSION) +} + +func (s *Alter_resource_costContext) CPU_PER_SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, i) +} + +func (s *Alter_resource_costContext) AllCONNECT_TIME() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONNECT_TIME) +} + +func (s *Alter_resource_costContext) CONNECT_TIME(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, i) +} + +func (s *Alter_resource_costContext) AllLOGICAL_READS_PER_SESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGICAL_READS_PER_SESSION) +} + +func (s *Alter_resource_costContext) LOGICAL_READS_PER_SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, i) +} + +func (s *Alter_resource_costContext) AllPRIVATE_SGA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVATE_SGA) +} + +func (s *Alter_resource_costContext) PRIVATE_SGA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, i) +} + +func (s *Alter_resource_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_resource_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_resource_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_resource_cost(s) + } +} + +func (s *Alter_resource_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_resource_cost(s) + } +} + +func (p *PlSqlParser) Alter_resource_cost() (localctx IAlter_resource_costContext) { + localctx = NewAlter_resource_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, PlSqlParserRULE_alter_resource_cost) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4119) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4120) + p.Match(PlSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4121) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCONNECT_TIME || _la == PlSqlParserCPU_PER_SESSION || _la == PlSqlParserLOGICAL_READS_PER_SESSION || _la == PlSqlParserPRIVATE_SGA { + { + p.SetState(4122) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONNECT_TIME || _la == PlSqlParserCPU_PER_SESSION || _la == PlSqlParserLOGICAL_READS_PER_SESSION || _la == PlSqlParserPRIVATE_SGA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4123) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(4126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_outlineContext is an interface to support dynamic dispatch. +type IDrop_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_outlineContext differentiates from other interfaces. + IsDrop_outlineContext() +} + +type Drop_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyDrop_outlineContext() *Drop_outlineContext { + var p = new(Drop_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_outline + return p +} + +func InitEmptyDrop_outlineContext(p *Drop_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_outline +} + +func (*Drop_outlineContext) IsDrop_outlineContext() {} + +func NewDrop_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_outlineContext { + var p = new(Drop_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_outline + + return p +} + +func (s *Drop_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Drop_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Drop_outlineContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Drop_outlineContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_outline(s) + } +} + +func (s *Drop_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_outline(s) + } +} + +func (p *PlSqlParser) Drop_outline() (localctx IDrop_outlineContext) { + localctx = NewDrop_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, PlSqlParserRULE_drop_outline) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4128) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4129) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4130) + + var _x = p.Id_expression() + + localctx.(*Drop_outlineContext).o = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_rollback_segmentContext is an interface to support dynamic dispatch. +type IAlter_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + Storage_clause() IStorage_clauseContext + SHRINK() antlr.TerminalNode + TO() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsAlter_rollback_segmentContext differentiates from other interfaces. + IsAlter_rollback_segmentContext() +} + +type Alter_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_rollback_segmentContext() *Alter_rollback_segmentContext { + var p = new(Alter_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment + return p +} + +func InitEmptyAlter_rollback_segmentContext(p *Alter_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment +} + +func (*Alter_rollback_segmentContext) IsAlter_rollback_segmentContext() {} + +func NewAlter_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_rollback_segmentContext { + var p = new(Alter_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment + + return p +} + +func (s *Alter_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_rollback_segmentContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Alter_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Alter_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Alter_rollback_segmentContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_rollback_segmentContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_rollback_segmentContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Alter_rollback_segmentContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_rollback_segmentContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_rollback_segmentContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_rollback_segment(s) + } +} + +func (s *Alter_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_rollback_segment(s) + } +} + +func (p *PlSqlParser) Alter_rollback_segment() (localctx IAlter_rollback_segmentContext) { + localctx = NewAlter_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, PlSqlParserRULE_alter_rollback_segment) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4132) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4133) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4134) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4135) + p.Rollback_segment_name() + } + p.SetState(4144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + { + p.SetState(4136) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(4137) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTORAGE: + { + p.SetState(4138) + p.Storage_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(4139) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(4140) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4141) + p.Size_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_restore_pointContext is an interface to support dynamic dispatch. +type IDrop_restore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRp returns the rp rule contexts. + GetRp() IId_expressionContext + + // GetPdb returns the pdb rule contexts. + GetPdb() IId_expressionContext + + // SetRp sets the rp rule contexts. + SetRp(IId_expressionContext) + + // SetPdb sets the pdb rule contexts. + SetPdb(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + FOR() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + + // IsDrop_restore_pointContext differentiates from other interfaces. + IsDrop_restore_pointContext() +} + +type Drop_restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rp IId_expressionContext + pdb IId_expressionContext +} + +func NewEmptyDrop_restore_pointContext() *Drop_restore_pointContext { + var p = new(Drop_restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_restore_point + return p +} + +func InitEmptyDrop_restore_pointContext(p *Drop_restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_restore_point +} + +func (*Drop_restore_pointContext) IsDrop_restore_pointContext() {} + +func NewDrop_restore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_restore_pointContext { + var p = new(Drop_restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_restore_point + + return p +} + +func (s *Drop_restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_restore_pointContext) GetRp() IId_expressionContext { return s.rp } + +func (s *Drop_restore_pointContext) GetPdb() IId_expressionContext { return s.pdb } + +func (s *Drop_restore_pointContext) SetRp(v IId_expressionContext) { s.rp = v } + +func (s *Drop_restore_pointContext) SetPdb(v IId_expressionContext) { s.pdb = v } + +func (s *Drop_restore_pointContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_restore_pointContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Drop_restore_pointContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Drop_restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Drop_restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_restore_pointContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Drop_restore_pointContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Drop_restore_pointContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_restore_point(s) + } +} + +func (s *Drop_restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_restore_point(s) + } +} + +func (p *PlSqlParser) Drop_restore_point() (localctx IDrop_restore_pointContext) { + localctx = NewDrop_restore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, PlSqlParserRULE_drop_restore_point) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4146) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4147) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4148) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4149) + + var _x = p.Id_expression() + + localctx.(*Drop_restore_pointContext).rp = _x + } + p.SetState(4154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(4150) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4151) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4152) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4153) + + var _x = p.Id_expression() + + localctx.(*Drop_restore_pointContext).pdb = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_rollback_segmentContext is an interface to support dynamic dispatch. +type IDrop_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + + // IsDrop_rollback_segmentContext differentiates from other interfaces. + IsDrop_rollback_segmentContext() +} + +type Drop_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_rollback_segmentContext() *Drop_rollback_segmentContext { + var p = new(Drop_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment + return p +} + +func InitEmptyDrop_rollback_segmentContext(p *Drop_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment +} + +func (*Drop_rollback_segmentContext) IsDrop_rollback_segmentContext() {} + +func NewDrop_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_rollback_segmentContext { + var p = new(Drop_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment + + return p +} + +func (s *Drop_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_rollback_segmentContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Drop_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Drop_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Drop_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_rollback_segment(s) + } +} + +func (s *Drop_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_rollback_segment(s) + } +} + +func (p *PlSqlParser) Drop_rollback_segment() (localctx IDrop_rollback_segmentContext) { + localctx = NewDrop_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, PlSqlParserRULE_drop_rollback_segment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4156) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4157) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4158) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4159) + p.Rollback_segment_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_roleContext is an interface to support dynamic dispatch. +type IDrop_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_name() IRole_nameContext + + // IsDrop_roleContext differentiates from other interfaces. + IsDrop_roleContext() +} + +type Drop_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_roleContext() *Drop_roleContext { + var p = new(Drop_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_role + return p +} + +func InitEmptyDrop_roleContext(p *Drop_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_role +} + +func (*Drop_roleContext) IsDrop_roleContext() {} + +func NewDrop_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_roleContext { + var p = new(Drop_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_role + + return p +} + +func (s *Drop_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Drop_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Drop_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_role(s) + } +} + +func (s *Drop_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_role(s) + } +} + +func (p *PlSqlParser) Drop_role() (localctx IDrop_roleContext) { + localctx = NewDrop_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, PlSqlParserRULE_drop_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4161) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4162) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4163) + p.Role_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_pmem_filestoreContext is an interface to support dynamic dispatch. +type ICreate_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + AllPmem_filestore_options() []IPmem_filestore_optionsContext + Pmem_filestore_options(i int) IPmem_filestore_optionsContext + + // IsCreate_pmem_filestoreContext differentiates from other interfaces. + IsCreate_pmem_filestoreContext() +} + +type Create_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyCreate_pmem_filestoreContext() *Create_pmem_filestoreContext { + var p = new(Create_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore + return p +} + +func InitEmptyCreate_pmem_filestoreContext(p *Create_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore +} + +func (*Create_pmem_filestoreContext) IsCreate_pmem_filestoreContext() {} + +func NewCreate_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_pmem_filestoreContext { + var p = new(Create_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore + + return p +} + +func (s *Create_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Create_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Create_pmem_filestoreContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Create_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Create_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_pmem_filestoreContext) AllPmem_filestore_options() []IPmem_filestore_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPmem_filestore_optionsContext); ok { + len++ + } + } + + tst := make([]IPmem_filestore_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPmem_filestore_optionsContext); ok { + tst[i] = t.(IPmem_filestore_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_pmem_filestoreContext) Pmem_filestore_options(i int) IPmem_filestore_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPmem_filestore_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPmem_filestore_optionsContext) +} + +func (s *Create_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_pmem_filestore(s) + } +} + +func (s *Create_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_pmem_filestore(s) + } +} + +func (p *PlSqlParser) Create_pmem_filestore() (localctx ICreate_pmem_filestoreContext) { + localctx = NewCreate_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, PlSqlParserRULE_create_pmem_filestore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4165) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4166) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4167) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4168) + + var _x = p.Id_expression() + + localctx.(*Create_pmem_filestoreContext).fsn = _x + } + p.SetState(4170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-93)) & ^0x3f) == 0 && ((int64(1)<<(_la-93))&9007199254741249) != 0) || _la == PlSqlParserMOUNTPOINT || _la == PlSqlParserSIZE { + { + p.SetState(4169) + p.Pmem_filestore_options() + } + + p.SetState(4172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPmem_filestore_optionsContext is an interface to support dynamic dispatch. +type IPmem_filestore_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNTPOINT() antlr.TerminalNode + File_path() IFile_pathContext + BACKINGFILE() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + Size_clause() ISize_clauseContext + SIZE() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + Autoextend_clause() IAutoextend_clauseContext + + // IsPmem_filestore_optionsContext differentiates from other interfaces. + IsPmem_filestore_optionsContext() +} + +type Pmem_filestore_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPmem_filestore_optionsContext() *Pmem_filestore_optionsContext { + var p = new(Pmem_filestore_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options + return p +} + +func InitEmptyPmem_filestore_optionsContext(p *Pmem_filestore_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options +} + +func (*Pmem_filestore_optionsContext) IsPmem_filestore_optionsContext() {} + +func NewPmem_filestore_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pmem_filestore_optionsContext { + var p = new(Pmem_filestore_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options + + return p +} + +func (s *Pmem_filestore_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pmem_filestore_optionsContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Pmem_filestore_optionsContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Pmem_filestore_optionsContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Pmem_filestore_optionsContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Pmem_filestore_optionsContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Pmem_filestore_optionsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Pmem_filestore_optionsContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Pmem_filestore_optionsContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Pmem_filestore_optionsContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Pmem_filestore_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pmem_filestore_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pmem_filestore_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPmem_filestore_options(s) + } +} + +func (s *Pmem_filestore_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPmem_filestore_options(s) + } +} + +func (p *PlSqlParser) Pmem_filestore_options() (localctx IPmem_filestore_optionsContext) { + localctx = NewPmem_filestore_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, PlSqlParserRULE_pmem_filestore_options) + var _la int + + p.SetState(4184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMOUNTPOINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4174) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4175) + p.File_path() + } + + case PlSqlParserBACKINGFILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4176) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4177) + p.Filename() + } + p.SetState(4179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(4178) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserBLOCKSIZE, PlSqlParserSIZE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4181) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBLOCKSIZE || _la == PlSqlParserSIZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4182) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4183) + p.Autoextend_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_pathContext is an interface to support dynamic dispatch. +type IFile_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsFile_pathContext differentiates from other interfaces. + IsFile_pathContext() +} + +type File_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_pathContext() *File_pathContext { + var p = new(File_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_path + return p +} + +func InitEmptyFile_pathContext(p *File_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_path +} + +func (*File_pathContext) IsFile_pathContext() {} + +func NewFile_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_pathContext { + var p = new(File_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_path + + return p +} + +func (s *File_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_pathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *File_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_path(s) + } +} + +func (s *File_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_path(s) + } +} + +func (p *PlSqlParser) File_path() (localctx IFile_pathContext) { + localctx = NewFile_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, PlSqlParserRULE_file_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4186) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_rollback_segmentContext is an interface to support dynamic dispatch. +type ICreate_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + PUBLIC() antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + + // IsCreate_rollback_segmentContext differentiates from other interfaces. + IsCreate_rollback_segmentContext() +} + +type Create_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_rollback_segmentContext() *Create_rollback_segmentContext { + var p = new(Create_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_rollback_segment + return p +} + +func InitEmptyCreate_rollback_segmentContext(p *Create_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_rollback_segment +} + +func (*Create_rollback_segmentContext) IsCreate_rollback_segmentContext() {} + +func NewCreate_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_rollback_segmentContext { + var p = new(Create_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_rollback_segment + + return p +} + +func (s *Create_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_rollback_segmentContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Create_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Create_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Create_rollback_segmentContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_rollback_segmentContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_rollback_segmentContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_rollback_segmentContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Create_rollback_segmentContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Create_rollback_segmentContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_rollback_segmentContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Create_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_rollback_segment(s) + } +} + +func (s *Create_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_rollback_segment(s) + } +} + +func (p *PlSqlParser) Create_rollback_segment() (localctx ICreate_rollback_segmentContext) { + localctx = NewCreate_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, PlSqlParserRULE_create_rollback_segment) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4188) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(4189) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4192) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4193) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + p.Rollback_segment_name() + } + p.SetState(4200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(4198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(4195) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4196) + p.Tablespace() + } + + case PlSqlParserSTORAGE: + { + p.SetState(4197) + p.Storage_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_triggerContext is an interface to support dynamic dispatch. +type IDrop_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Trigger_name() ITrigger_nameContext + + // IsDrop_triggerContext differentiates from other interfaces. + IsDrop_triggerContext() +} + +type Drop_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_triggerContext() *Drop_triggerContext { + var p = new(Drop_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_trigger + return p +} + +func InitEmptyDrop_triggerContext(p *Drop_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_trigger +} + +func (*Drop_triggerContext) IsDrop_triggerContext() {} + +func NewDrop_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_triggerContext { + var p = new(Drop_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_trigger + + return p +} + +func (s *Drop_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_triggerContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Drop_triggerContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Drop_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_trigger(s) + } +} + +func (s *Drop_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_trigger(s) + } +} + +func (p *PlSqlParser) Drop_trigger() (localctx IDrop_triggerContext) { + localctx = NewDrop_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, PlSqlParserRULE_drop_trigger) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4203) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4204) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4205) + p.Trigger_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_triggerContext is an interface to support dynamic dispatch. +type IAlter_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlter_trigger_name returns the alter_trigger_name rule contexts. + GetAlter_trigger_name() ITrigger_nameContext + + // GetRename_trigger_name returns the rename_trigger_name rule contexts. + GetRename_trigger_name() ITrigger_nameContext + + // SetAlter_trigger_name sets the alter_trigger_name rule contexts. + SetAlter_trigger_name(ITrigger_nameContext) + + // SetRename_trigger_name sets the rename_trigger_name rule contexts. + SetRename_trigger_name(ITrigger_nameContext) + + // Getter signatures + ALTER() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + AllTrigger_name() []ITrigger_nameContext + Trigger_name(i int) ITrigger_nameContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_triggerContext differentiates from other interfaces. + IsAlter_triggerContext() +} + +type Alter_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + alter_trigger_name ITrigger_nameContext + rename_trigger_name ITrigger_nameContext +} + +func NewEmptyAlter_triggerContext() *Alter_triggerContext { + var p = new(Alter_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_trigger + return p +} + +func InitEmptyAlter_triggerContext(p *Alter_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_trigger +} + +func (*Alter_triggerContext) IsAlter_triggerContext() {} + +func NewAlter_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_triggerContext { + var p = new(Alter_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_trigger + + return p +} + +func (s *Alter_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_triggerContext) GetAlter_trigger_name() ITrigger_nameContext { + return s.alter_trigger_name +} + +func (s *Alter_triggerContext) GetRename_trigger_name() ITrigger_nameContext { + return s.rename_trigger_name +} + +func (s *Alter_triggerContext) SetAlter_trigger_name(v ITrigger_nameContext) { + s.alter_trigger_name = v +} + +func (s *Alter_triggerContext) SetRename_trigger_name(v ITrigger_nameContext) { + s.rename_trigger_name = v +} + +func (s *Alter_triggerContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Alter_triggerContext) AllTrigger_name() []ITrigger_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrigger_nameContext); ok { + len++ + } + } + + tst := make([]ITrigger_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrigger_nameContext); ok { + tst[i] = t.(ITrigger_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_triggerContext) Trigger_name(i int) ITrigger_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Alter_triggerContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_triggerContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_triggerContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_triggerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Alter_triggerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Alter_triggerContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_triggerContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_triggerContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_triggerContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_triggerContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_trigger(s) + } +} + +func (s *Alter_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_trigger(s) + } +} + +func (p *PlSqlParser) Alter_trigger() (localctx IAlter_triggerContext) { + localctx = NewAlter_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, PlSqlParserRULE_alter_trigger) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4207) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4208) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4209) + + var _x = p.Trigger_name() + + localctx.(*Alter_triggerContext).alter_trigger_name = _x + } + p.SetState(4228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(4210) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserRENAME: + { + p.SetState(4211) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4212) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4213) + + var _x = p.Trigger_name() + + localctx.(*Alter_triggerContext).rename_trigger_name = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(4214) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4216) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 247, p.GetParserRuleContext()) == 1 { + { + p.SetState(4215) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 248, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4218) + p.Compiler_parameters_clause() + } + + } + p.SetState(4223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 248, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(4224) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4225) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_triggerContext is an interface to support dynamic dispatch. +type ICreate_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Trigger_name() ITrigger_nameContext + Trigger_body() ITrigger_bodyContext + Simple_dml_trigger() ISimple_dml_triggerContext + Compound_dml_trigger() ICompound_dml_triggerContext + Non_dml_trigger() INon_dml_triggerContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Trigger_follows_clause() ITrigger_follows_clauseContext + Trigger_when_clause() ITrigger_when_clauseContext + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCreate_triggerContext differentiates from other interfaces. + IsCreate_triggerContext() +} + +type Create_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_triggerContext() *Create_triggerContext { + var p = new(Create_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_trigger + return p +} + +func InitEmptyCreate_triggerContext(p *Create_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_trigger +} + +func (*Create_triggerContext) IsCreate_triggerContext() {} + +func NewCreate_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_triggerContext { + var p = new(Create_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_trigger + + return p +} + +func (s *Create_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_triggerContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Create_triggerContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Create_triggerContext) Trigger_body() ITrigger_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_bodyContext) +} + +func (s *Create_triggerContext) Simple_dml_trigger() ISimple_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_dml_triggerContext) +} + +func (s *Create_triggerContext) Compound_dml_trigger() ICompound_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompound_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompound_dml_triggerContext) +} + +func (s *Create_triggerContext) Non_dml_trigger() INon_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_dml_triggerContext) +} + +func (s *Create_triggerContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_triggerContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_triggerContext) Trigger_follows_clause() ITrigger_follows_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_follows_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_follows_clauseContext) +} + +func (s *Create_triggerContext) Trigger_when_clause() ITrigger_when_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_when_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_when_clauseContext) +} + +func (s *Create_triggerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Create_triggerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Create_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_trigger(s) + } +} + +func (s *Create_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_trigger(s) + } +} + +func (p *PlSqlParser) Create_trigger() (localctx ICreate_triggerContext) { + localctx = NewCreate_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, PlSqlParserRULE_create_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4230) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4231) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4232) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4235) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4236) + p.Trigger_name() + } + p.SetState(4240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 252, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4237) + p.Simple_dml_trigger() + } + + case 2: + { + p.SetState(4238) + p.Compound_dml_trigger() + } + + case 3: + { + p.SetState(4239) + p.Non_dml_trigger() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOLLOWS { + { + p.SetState(4242) + p.Trigger_follows_clause() + } + + } + p.SetState(4246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(4245) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(4248) + p.Trigger_when_clause() + } + + } + { + p.SetState(4251) + p.Trigger_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_follows_clauseContext is an interface to support dynamic dispatch. +type ITrigger_follows_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOLLOWS() antlr.TerminalNode + AllTrigger_name() []ITrigger_nameContext + Trigger_name(i int) ITrigger_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTrigger_follows_clauseContext differentiates from other interfaces. + IsTrigger_follows_clauseContext() +} + +type Trigger_follows_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_follows_clauseContext() *Trigger_follows_clauseContext { + var p = new(Trigger_follows_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause + return p +} + +func InitEmptyTrigger_follows_clauseContext(p *Trigger_follows_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause +} + +func (*Trigger_follows_clauseContext) IsTrigger_follows_clauseContext() {} + +func NewTrigger_follows_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_follows_clauseContext { + var p = new(Trigger_follows_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause + + return p +} + +func (s *Trigger_follows_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_follows_clauseContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Trigger_follows_clauseContext) AllTrigger_name() []ITrigger_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrigger_nameContext); ok { + len++ + } + } + + tst := make([]ITrigger_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrigger_nameContext); ok { + tst[i] = t.(ITrigger_nameContext) + i++ + } + } + + return tst +} + +func (s *Trigger_follows_clauseContext) Trigger_name(i int) ITrigger_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Trigger_follows_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Trigger_follows_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Trigger_follows_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_follows_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_follows_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_follows_clause(s) + } +} + +func (s *Trigger_follows_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_follows_clause(s) + } +} + +func (p *PlSqlParser) Trigger_follows_clause() (localctx ITrigger_follows_clauseContext) { + localctx = NewTrigger_follows_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, PlSqlParserRULE_trigger_follows_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4253) + p.Match(PlSqlParserFOLLOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4254) + p.Trigger_name() + } + p.SetState(4259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4255) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4256) + p.Trigger_name() + } + + p.SetState(4261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_when_clauseContext is an interface to support dynamic dispatch. +type ITrigger_when_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsTrigger_when_clauseContext differentiates from other interfaces. + IsTrigger_when_clauseContext() +} + +type Trigger_when_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_when_clauseContext() *Trigger_when_clauseContext { + var p = new(Trigger_when_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_when_clause + return p +} + +func InitEmptyTrigger_when_clauseContext(p *Trigger_when_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_when_clause +} + +func (*Trigger_when_clauseContext) IsTrigger_when_clauseContext() {} + +func NewTrigger_when_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_when_clauseContext { + var p = new(Trigger_when_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_when_clause + + return p +} + +func (s *Trigger_when_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_when_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Trigger_when_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Trigger_when_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Trigger_when_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Trigger_when_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_when_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_when_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_when_clause(s) + } +} + +func (s *Trigger_when_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_when_clause(s) + } +} + +func (p *PlSqlParser) Trigger_when_clause() (localctx ITrigger_when_clauseContext) { + localctx = NewTrigger_when_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, PlSqlParserRULE_trigger_when_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4262) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4263) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4264) + p.Condition() + } + { + p.SetState(4265) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_dml_triggerContext is an interface to support dynamic dispatch. +type ISimple_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dml_event_clause() IDml_event_clauseContext + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + OF() antlr.TerminalNode + Referencing_clause() IReferencing_clauseContext + For_each_row() IFor_each_rowContext + + // IsSimple_dml_triggerContext differentiates from other interfaces. + IsSimple_dml_triggerContext() +} + +type Simple_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_dml_triggerContext() *Simple_dml_triggerContext { + var p = new(Simple_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger + return p +} + +func InitEmptySimple_dml_triggerContext(p *Simple_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger +} + +func (*Simple_dml_triggerContext) IsSimple_dml_triggerContext() {} + +func NewSimple_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_dml_triggerContext { + var p = new(Simple_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger + + return p +} + +func (s *Simple_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_dml_triggerContext) Dml_event_clause() IDml_event_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_clauseContext) +} + +func (s *Simple_dml_triggerContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Simple_dml_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Simple_dml_triggerContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTEAD, 0) +} + +func (s *Simple_dml_triggerContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Simple_dml_triggerContext) Referencing_clause() IReferencing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_clauseContext) +} + +func (s *Simple_dml_triggerContext) For_each_row() IFor_each_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_each_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_each_rowContext) +} + +func (s *Simple_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_dml_trigger(s) + } +} + +func (s *Simple_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_dml_trigger(s) + } +} + +func (p *PlSqlParser) Simple_dml_trigger() (localctx ISimple_dml_triggerContext) { + localctx = NewSimple_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, PlSqlParserRULE_simple_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBEFORE: + { + p.SetState(4267) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAFTER: + { + p.SetState(4268) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINSTEAD: + { + p.SetState(4269) + p.Match(PlSqlParserINSTEAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4270) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4273) + p.Dml_event_clause() + } + p.SetState(4275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFERENCES || _la == PlSqlParserREFERENCING { + { + p.SetState(4274) + p.Referencing_clause() + } + + } + p.SetState(4278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(4277) + p.For_each_row() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_each_rowContext is an interface to support dynamic dispatch. +type IFor_each_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + EACH() antlr.TerminalNode + ROW() antlr.TerminalNode + + // IsFor_each_rowContext differentiates from other interfaces. + IsFor_each_rowContext() +} + +type For_each_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_each_rowContext() *For_each_rowContext { + var p = new(For_each_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_each_row + return p +} + +func InitEmptyFor_each_rowContext(p *For_each_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_each_row +} + +func (*For_each_rowContext) IsFor_each_rowContext() {} + +func NewFor_each_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_each_rowContext { + var p = new(For_each_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_each_row + + return p +} + +func (s *For_each_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_each_rowContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_each_rowContext) EACH() antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, 0) +} + +func (s *For_each_rowContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *For_each_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_each_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_each_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_each_row(s) + } +} + +func (s *For_each_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_each_row(s) + } +} + +func (p *PlSqlParser) For_each_row() (localctx IFor_each_rowContext) { + localctx = NewFor_each_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, PlSqlParserRULE_for_each_row) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4280) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4281) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4282) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompound_dml_triggerContext is an interface to support dynamic dispatch. +type ICompound_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Dml_event_clause() IDml_event_clauseContext + Referencing_clause() IReferencing_clauseContext + + // IsCompound_dml_triggerContext differentiates from other interfaces. + IsCompound_dml_triggerContext() +} + +type Compound_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompound_dml_triggerContext() *Compound_dml_triggerContext { + var p = new(Compound_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger + return p +} + +func InitEmptyCompound_dml_triggerContext(p *Compound_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger +} + +func (*Compound_dml_triggerContext) IsCompound_dml_triggerContext() {} + +func NewCompound_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_dml_triggerContext { + var p = new(Compound_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger + + return p +} + +func (s *Compound_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_dml_triggerContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Compound_dml_triggerContext) Dml_event_clause() IDml_event_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_clauseContext) +} + +func (s *Compound_dml_triggerContext) Referencing_clause() IReferencing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_clauseContext) +} + +func (s *Compound_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_dml_trigger(s) + } +} + +func (s *Compound_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_dml_trigger(s) + } +} + +func (p *PlSqlParser) Compound_dml_trigger() (localctx ICompound_dml_triggerContext) { + localctx = NewCompound_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, PlSqlParserRULE_compound_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4284) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4285) + p.Dml_event_clause() + } + p.SetState(4287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFERENCES || _la == PlSqlParserREFERENCING { + { + p.SetState(4286) + p.Referencing_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INon_dml_triggerContext is an interface to support dynamic dispatch. +type INon_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllNon_dml_event() []INon_dml_eventContext + Non_dml_event(i int) INon_dml_eventContext + ON() antlr.TerminalNode + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsNon_dml_triggerContext differentiates from other interfaces. + IsNon_dml_triggerContext() +} + +type Non_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_dml_triggerContext() *Non_dml_triggerContext { + var p = new(Non_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_trigger + return p +} + +func InitEmptyNon_dml_triggerContext(p *Non_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_trigger +} + +func (*Non_dml_triggerContext) IsNon_dml_triggerContext() {} + +func NewNon_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_dml_triggerContext { + var p = new(Non_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_dml_trigger + + return p +} + +func (s *Non_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_dml_triggerContext) AllNon_dml_event() []INon_dml_eventContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INon_dml_eventContext); ok { + len++ + } + } + + tst := make([]INon_dml_eventContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INon_dml_eventContext); ok { + tst[i] = t.(INon_dml_eventContext) + i++ + } + } + + return tst +} + +func (s *Non_dml_triggerContext) Non_dml_event(i int) INon_dml_eventContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_dml_eventContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INon_dml_eventContext) +} + +func (s *Non_dml_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Non_dml_triggerContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Non_dml_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Non_dml_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_dml_triggerContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_dml_triggerContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Non_dml_triggerContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Non_dml_triggerContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Non_dml_triggerContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Non_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_dml_trigger(s) + } +} + +func (s *Non_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_dml_trigger(s) + } +} + +func (p *PlSqlParser) Non_dml_trigger() (localctx INon_dml_triggerContext) { + localctx = NewNon_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, PlSqlParserRULE_non_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4289) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAFTER || _la == PlSqlParserBEFORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4290) + p.Non_dml_event() + } + p.SetState(4295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(4291) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4292) + p.Non_dml_event() + } + + p.SetState(4297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4298) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4299) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(4303) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 262, p.GetParserRuleContext()) == 1 { + { + p.SetState(4300) + p.Schema_name() + } + { + p.SetState(4301) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4305) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_bodyContext is an interface to support dynamic dispatch. +type ITrigger_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Compound_trigger_block() ICompound_trigger_blockContext + CALL() antlr.TerminalNode + Identifier() IIdentifierContext + Trigger_block() ITrigger_blockContext + + // IsTrigger_bodyContext differentiates from other interfaces. + IsTrigger_bodyContext() +} + +type Trigger_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_bodyContext() *Trigger_bodyContext { + var p = new(Trigger_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_body + return p +} + +func InitEmptyTrigger_bodyContext(p *Trigger_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_body +} + +func (*Trigger_bodyContext) IsTrigger_bodyContext() {} + +func NewTrigger_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_bodyContext { + var p = new(Trigger_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_body + + return p +} + +func (s *Trigger_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_bodyContext) Compound_trigger_block() ICompound_trigger_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompound_trigger_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompound_trigger_blockContext) +} + +func (s *Trigger_bodyContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Trigger_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Trigger_bodyContext) Trigger_block() ITrigger_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_blockContext) +} + +func (s *Trigger_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_body(s) + } +} + +func (s *Trigger_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_body(s) + } +} + +func (p *PlSqlParser) Trigger_body() (localctx ITrigger_bodyContext) { + localctx = NewTrigger_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, PlSqlParserRULE_trigger_body) + p.SetState(4312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOUND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4308) + p.Compound_trigger_block() + } + + case PlSqlParserCALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4309) + p.Match(PlSqlParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4310) + p.Identifier() + } + + case PlSqlParserBEGIN, PlSqlParserDECLARE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4311) + p.Trigger_block() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompound_trigger_blockContext is an interface to support dynamic dispatch. +type ICompound_trigger_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPOUND() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + END() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllTiming_point_section() []ITiming_point_sectionContext + Timing_point_section(i int) ITiming_point_sectionContext + Trigger_name() ITrigger_nameContext + + // IsCompound_trigger_blockContext differentiates from other interfaces. + IsCompound_trigger_blockContext() +} + +type Compound_trigger_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompound_trigger_blockContext() *Compound_trigger_blockContext { + var p = new(Compound_trigger_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_trigger_block + return p +} + +func InitEmptyCompound_trigger_blockContext(p *Compound_trigger_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_trigger_block +} + +func (*Compound_trigger_blockContext) IsCompound_trigger_blockContext() {} + +func NewCompound_trigger_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_trigger_blockContext { + var p = new(Compound_trigger_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_trigger_block + + return p +} + +func (s *Compound_trigger_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_trigger_blockContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOUND, 0) +} + +func (s *Compound_trigger_blockContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Compound_trigger_blockContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Compound_trigger_blockContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Compound_trigger_blockContext) AllTiming_point_section() []ITiming_point_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITiming_point_sectionContext); ok { + len++ + } + } + + tst := make([]ITiming_point_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITiming_point_sectionContext); ok { + tst[i] = t.(ITiming_point_sectionContext) + i++ + } + } + + return tst +} + +func (s *Compound_trigger_blockContext) Timing_point_section(i int) ITiming_point_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITiming_point_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITiming_point_sectionContext) +} + +func (s *Compound_trigger_blockContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Compound_trigger_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_trigger_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_trigger_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_trigger_block(s) + } +} + +func (s *Compound_trigger_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_trigger_block(s) + } +} + +func (p *PlSqlParser) Compound_trigger_block() (localctx ICompound_trigger_blockContext) { + localctx = NewCompound_trigger_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, PlSqlParserRULE_compound_trigger_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4314) + p.Match(PlSqlParserCOMPOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4315) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4317) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 265, p.GetParserRuleContext()) == 1 { + { + p.SetState(4316) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserAFTER || _la == PlSqlParserBEFORE { + { + p.SetState(4319) + p.Timing_point_section() + } + + p.SetState(4322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4324) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(4325) + p.Trigger_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITiming_point_sectionContext is an interface to support dynamic dispatch. +type ITiming_point_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBk returns the bk token. + GetBk() antlr.Token + + // GetAk returns the ak token. + GetAk() antlr.Token + + // SetBk sets the bk token. + SetBk(antlr.Token) + + // SetAk sets the ak token. + SetAk(antlr.Token) + + // Getter signatures + AllSTATEMENT() []antlr.TerminalNode + STATEMENT(i int) antlr.TerminalNode + IS() antlr.TerminalNode + Tps_block() ITps_blockContext + AllBEFORE() []antlr.TerminalNode + BEFORE(i int) antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + AllEACH() []antlr.TerminalNode + EACH(i int) antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllAFTER() []antlr.TerminalNode + AFTER(i int) antlr.TerminalNode + + // IsTiming_point_sectionContext differentiates from other interfaces. + IsTiming_point_sectionContext() +} + +type Timing_point_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bk antlr.Token + ak antlr.Token +} + +func NewEmptyTiming_point_sectionContext() *Timing_point_sectionContext { + var p = new(Timing_point_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_point_section + return p +} + +func InitEmptyTiming_point_sectionContext(p *Timing_point_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_point_section +} + +func (*Timing_point_sectionContext) IsTiming_point_sectionContext() {} + +func NewTiming_point_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timing_point_sectionContext { + var p = new(Timing_point_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timing_point_section + + return p +} + +func (s *Timing_point_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timing_point_sectionContext) GetBk() antlr.Token { return s.bk } + +func (s *Timing_point_sectionContext) GetAk() antlr.Token { return s.ak } + +func (s *Timing_point_sectionContext) SetBk(v antlr.Token) { s.bk = v } + +func (s *Timing_point_sectionContext) SetAk(v antlr.Token) { s.ak = v } + +func (s *Timing_point_sectionContext) AllSTATEMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATEMENT) +} + +func (s *Timing_point_sectionContext) STATEMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, i) +} + +func (s *Timing_point_sectionContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Timing_point_sectionContext) Tps_block() ITps_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITps_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITps_blockContext) +} + +func (s *Timing_point_sectionContext) AllBEFORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBEFORE) +} + +func (s *Timing_point_sectionContext) BEFORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, i) +} + +func (s *Timing_point_sectionContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Timing_point_sectionContext) AllEACH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEACH) +} + +func (s *Timing_point_sectionContext) EACH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, i) +} + +func (s *Timing_point_sectionContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Timing_point_sectionContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Timing_point_sectionContext) AllAFTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAFTER) +} + +func (s *Timing_point_sectionContext) AFTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, i) +} + +func (s *Timing_point_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timing_point_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timing_point_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTiming_point_section(s) + } +} + +func (s *Timing_point_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTiming_point_section(s) + } +} + +func (p *PlSqlParser) Timing_point_section() (localctx ITiming_point_sectionContext) { + localctx = NewTiming_point_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, PlSqlParserRULE_timing_point_section) + p.SetState(4364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 268, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4328) + + var _m = p.Match(PlSqlParserBEFORE) + + localctx.(*Timing_point_sectionContext).bk = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4329) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4330) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4331) + p.Tps_block() + } + { + p.SetState(4332) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4333) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4334) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4336) + + var _m = p.Match(PlSqlParserBEFORE) + + localctx.(*Timing_point_sectionContext).bk = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4337) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4338) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4339) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4340) + p.Tps_block() + } + { + p.SetState(4341) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4342) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4343) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4344) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4346) + + var _m = p.Match(PlSqlParserAFTER) + + localctx.(*Timing_point_sectionContext).ak = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4347) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4348) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4349) + p.Tps_block() + } + { + p.SetState(4350) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4351) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4352) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4354) + + var _m = p.Match(PlSqlParserAFTER) + + localctx.(*Timing_point_sectionContext).ak = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4355) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4356) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4357) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4358) + p.Tps_block() + } + { + p.SetState(4359) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4360) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4361) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4362) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INon_dml_eventContext is an interface to support dynamic dispatch. +type INon_dml_eventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + ASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + CREATE() antlr.TerminalNode + DISASSOCIATE() antlr.TerminalNode + DROP() antlr.TerminalNode + GRANT() antlr.TerminalNode + NOAUDIT() antlr.TerminalNode + RENAME() antlr.TerminalNode + REVOKE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + DDL() antlr.TerminalNode + STARTUP() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + DB_ROLE_CHANGE() antlr.TerminalNode + LOGON() antlr.TerminalNode + LOGOFF() antlr.TerminalNode + SERVERERROR() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + FOLLOWS() antlr.TerminalNode + + // IsNon_dml_eventContext differentiates from other interfaces. + IsNon_dml_eventContext() +} + +type Non_dml_eventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_dml_eventContext() *Non_dml_eventContext { + var p = new(Non_dml_eventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_event + return p +} + +func InitEmptyNon_dml_eventContext(p *Non_dml_eventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_event +} + +func (*Non_dml_eventContext) IsNon_dml_eventContext() {} + +func NewNon_dml_eventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_dml_eventContext { + var p = new(Non_dml_eventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_dml_event + + return p +} + +func (s *Non_dml_eventContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_dml_eventContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Non_dml_eventContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Non_dml_eventContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Non_dml_eventContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Non_dml_eventContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Non_dml_eventContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Non_dml_eventContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Non_dml_eventContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Non_dml_eventContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Non_dml_eventContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Non_dml_eventContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Non_dml_eventContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Non_dml_eventContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Non_dml_eventContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Non_dml_eventContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Non_dml_eventContext) STARTUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTUP, 0) +} + +func (s *Non_dml_eventContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Non_dml_eventContext) DB_ROLE_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_ROLE_CHANGE, 0) +} + +func (s *Non_dml_eventContext) LOGON() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGON, 0) +} + +func (s *Non_dml_eventContext) LOGOFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGOFF, 0) +} + +func (s *Non_dml_eventContext) SERVERERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVERERROR, 0) +} + +func (s *Non_dml_eventContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Non_dml_eventContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_dml_eventContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_dml_eventContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Non_dml_eventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_dml_eventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_dml_eventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_dml_event(s) + } +} + +func (s *Non_dml_eventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_dml_event(s) + } +} + +func (p *PlSqlParser) Non_dml_event() (localctx INon_dml_eventContext) { + localctx = NewNon_dml_eventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, PlSqlParserRULE_non_dml_event) + p.SetState(4392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4366) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserANALYZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4367) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserASSOCIATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4368) + p.Match(PlSqlParserASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4369) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUDIT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4370) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMMENT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4371) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4372) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISASSOCIATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4373) + p.Match(PlSqlParserDISASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4374) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4375) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGRANT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4376) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOAUDIT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4377) + p.Match(PlSqlParserNOAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4378) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREVOKE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4379) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUNCATE: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4380) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDDL: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(4381) + p.Match(PlSqlParserDDL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTARTUP: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(4382) + p.Match(PlSqlParserSTARTUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSHUTDOWN: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(4383) + p.Match(PlSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDB_ROLE_CHANGE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(4384) + p.Match(PlSqlParserDB_ROLE_CHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGON: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(4385) + p.Match(PlSqlParserLOGON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGOFF: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(4386) + p.Match(PlSqlParserLOGOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSERVERERROR: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(4387) + p.Match(PlSqlParserSERVERERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUSPEND: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(4388) + p.Match(PlSqlParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATABASE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(4389) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSCHEMA: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(4390) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOLLOWS: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(4391) + p.Match(PlSqlParserFOLLOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_event_clauseContext is an interface to support dynamic dispatch. +type IDml_event_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDml_event_element() []IDml_event_elementContext + Dml_event_element(i int) IDml_event_elementContext + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + Dml_event_nested_clause() IDml_event_nested_clauseContext + + // IsDml_event_clauseContext differentiates from other interfaces. + IsDml_event_clauseContext() +} + +type Dml_event_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_clauseContext() *Dml_event_clauseContext { + var p = new(Dml_event_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_clause + return p +} + +func InitEmptyDml_event_clauseContext(p *Dml_event_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_clause +} + +func (*Dml_event_clauseContext) IsDml_event_clauseContext() {} + +func NewDml_event_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_clauseContext { + var p = new(Dml_event_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_clause + + return p +} + +func (s *Dml_event_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_clauseContext) AllDml_event_element() []IDml_event_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDml_event_elementContext); ok { + len++ + } + } + + tst := make([]IDml_event_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDml_event_elementContext); ok { + tst[i] = t.(IDml_event_elementContext) + i++ + } + } + + return tst +} + +func (s *Dml_event_clauseContext) Dml_event_element(i int) IDml_event_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_elementContext) +} + +func (s *Dml_event_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Dml_event_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_event_clauseContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Dml_event_clauseContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Dml_event_clauseContext) Dml_event_nested_clause() IDml_event_nested_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_nested_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_nested_clauseContext) +} + +func (s *Dml_event_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_clause(s) + } +} + +func (s *Dml_event_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_clause(s) + } +} + +func (p *PlSqlParser) Dml_event_clause() (localctx IDml_event_clauseContext) { + localctx = NewDml_event_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, PlSqlParserRULE_dml_event_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4394) + p.Dml_event_element() + } + p.SetState(4399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(4395) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4396) + p.Dml_event_element() + } + + p.SetState(4401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4402) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4404) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 271, p.GetParserRuleContext()) == 1 { + { + p.SetState(4403) + p.Dml_event_nested_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4406) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_event_elementContext is an interface to support dynamic dispatch. +type IDml_event_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + OF() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsDml_event_elementContext differentiates from other interfaces. + IsDml_event_elementContext() +} + +type Dml_event_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_elementContext() *Dml_event_elementContext { + var p = new(Dml_event_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_element + return p +} + +func InitEmptyDml_event_elementContext(p *Dml_event_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_element +} + +func (*Dml_event_elementContext) IsDml_event_elementContext() {} + +func NewDml_event_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_elementContext { + var p = new(Dml_event_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_element + + return p +} + +func (s *Dml_event_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_elementContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Dml_event_elementContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Dml_event_elementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Dml_event_elementContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Dml_event_elementContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Dml_event_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_element(s) + } +} + +func (s *Dml_event_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_element(s) + } +} + +func (p *PlSqlParser) Dml_event_element() (localctx IDml_event_elementContext) { + localctx = NewDml_event_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, PlSqlParserRULE_dml_event_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4408) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserINSERT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(4409) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4410) + p.Column_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_event_nested_clauseContext is an interface to support dynamic dispatch. +type IDml_event_nested_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + OF() antlr.TerminalNode + + // IsDml_event_nested_clauseContext differentiates from other interfaces. + IsDml_event_nested_clauseContext() +} + +type Dml_event_nested_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_nested_clauseContext() *Dml_event_nested_clauseContext { + var p = new(Dml_event_nested_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause + return p +} + +func InitEmptyDml_event_nested_clauseContext(p *Dml_event_nested_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause +} + +func (*Dml_event_nested_clauseContext) IsDml_event_nested_clauseContext() {} + +func NewDml_event_nested_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_nested_clauseContext { + var p = new(Dml_event_nested_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause + + return p +} + +func (s *Dml_event_nested_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_nested_clauseContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Dml_event_nested_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Dml_event_nested_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_event_nested_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Dml_event_nested_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_nested_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_nested_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_nested_clause(s) + } +} + +func (s *Dml_event_nested_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_nested_clause(s) + } +} + +func (p *PlSqlParser) Dml_event_nested_clause() (localctx IDml_event_nested_clauseContext) { + localctx = NewDml_event_nested_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, PlSqlParserRULE_dml_event_nested_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4413) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4414) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4415) + p.Tableview_name() + } + { + p.SetState(4416) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferencing_clauseContext is an interface to support dynamic dispatch. +type IReferencing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCING() antlr.TerminalNode + AllReferencing_element() []IReferencing_elementContext + Referencing_element(i int) IReferencing_elementContext + REFERENCES() antlr.TerminalNode + + // IsReferencing_clauseContext differentiates from other interfaces. + IsReferencing_clauseContext() +} + +type Referencing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferencing_clauseContext() *Referencing_clauseContext { + var p = new(Referencing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_clause + return p +} + +func InitEmptyReferencing_clauseContext(p *Referencing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_clause +} + +func (*Referencing_clauseContext) IsReferencing_clauseContext() {} + +func NewReferencing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Referencing_clauseContext { + var p = new(Referencing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_referencing_clause + + return p +} + +func (s *Referencing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Referencing_clauseContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCING, 0) +} + +func (s *Referencing_clauseContext) AllReferencing_element() []IReferencing_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReferencing_elementContext); ok { + len++ + } + } + + tst := make([]IReferencing_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReferencing_elementContext); ok { + tst[i] = t.(IReferencing_elementContext) + i++ + } + } + + return tst +} + +func (s *Referencing_clauseContext) Referencing_element(i int) IReferencing_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_elementContext) +} + +func (s *Referencing_clauseContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Referencing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Referencing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Referencing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferencing_clause(s) + } +} + +func (s *Referencing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferencing_clause(s) + } +} + +func (p *PlSqlParser) Referencing_clause() (localctx IReferencing_clauseContext) { + localctx = NewReferencing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, PlSqlParserRULE_referencing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREFERENCING: + { + p.SetState(4418) + p.Match(PlSqlParserREFERENCING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4419) + p.Referencing_element() + } + + case PlSqlParserREFERENCES: + { + p.SetState(4420) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserNEW || _la == PlSqlParserOLD || _la == PlSqlParserPARENT { + { + p.SetState(4423) + p.Referencing_element() + } + + p.SetState(4428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferencing_elementContext is an interface to support dynamic dispatch. +type IReferencing_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_alias() IColumn_aliasContext + NEW() antlr.TerminalNode + OLD() antlr.TerminalNode + PARENT() antlr.TerminalNode + + // IsReferencing_elementContext differentiates from other interfaces. + IsReferencing_elementContext() +} + +type Referencing_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferencing_elementContext() *Referencing_elementContext { + var p = new(Referencing_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_element + return p +} + +func InitEmptyReferencing_elementContext(p *Referencing_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_element +} + +func (*Referencing_elementContext) IsReferencing_elementContext() {} + +func NewReferencing_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Referencing_elementContext { + var p = new(Referencing_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_referencing_element + + return p +} + +func (s *Referencing_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Referencing_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Referencing_elementContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Referencing_elementContext) OLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD, 0) +} + +func (s *Referencing_elementContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Referencing_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Referencing_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Referencing_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferencing_element(s) + } +} + +func (s *Referencing_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferencing_element(s) + } +} + +func (p *PlSqlParser) Referencing_element() (localctx IReferencing_elementContext) { + localctx = NewReferencing_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, PlSqlParserRULE_referencing_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4429) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNEW || _la == PlSqlParserOLD || _la == PlSqlParserPARENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4430) + p.Column_alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_typeContext is an interface to support dynamic dispatch. +type IDrop_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_name() IType_nameContext + BODY() antlr.TerminalNode + FORCE() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + + // IsDrop_typeContext differentiates from other interfaces. + IsDrop_typeContext() +} + +type Drop_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_typeContext() *Drop_typeContext { + var p = new(Drop_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_type + return p +} + +func InitEmptyDrop_typeContext(p *Drop_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_type +} + +func (*Drop_typeContext) IsDrop_typeContext() {} + +func NewDrop_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_typeContext { + var p = new(Drop_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_type + + return p +} + +func (s *Drop_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_typeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Drop_typeContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Drop_typeContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Drop_typeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_typeContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Drop_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_type(s) + } +} + +func (s *Drop_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_type(s) + } +} + +func (p *PlSqlParser) Drop_type() (localctx IDrop_typeContext) { + localctx = NewDrop_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, PlSqlParserRULE_drop_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4432) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4433) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4435) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 275, p.GetParserRuleContext()) == 1 { + { + p.SetState(4434) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4437) + p.Type_name() + } + p.SetState(4439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserVALIDATE { + { + p.SetState(4438) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_typeContext is an interface to support dynamic dispatch. +type IAlter_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_name() IType_nameContext + Compile_type_clause() ICompile_type_clauseContext + Replace_type_clause() IReplace_type_clauseContext + Alter_method_spec() IAlter_method_specContext + Alter_collection_clauses() IAlter_collection_clausesContext + Modifier_clause() IModifier_clauseContext + Overriding_subprogram_spec() IOverriding_subprogram_specContext + Dependent_handling_clause() IDependent_handling_clauseContext + + // IsAlter_typeContext differentiates from other interfaces. + IsAlter_typeContext() +} + +type Alter_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_typeContext() *Alter_typeContext { + var p = new(Alter_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_type + return p +} + +func InitEmptyAlter_typeContext(p *Alter_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_type +} + +func (*Alter_typeContext) IsAlter_typeContext() {} + +func NewAlter_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_typeContext { + var p = new(Alter_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_type + + return p +} + +func (s *Alter_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_typeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Alter_typeContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Alter_typeContext) Compile_type_clause() ICompile_type_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompile_type_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompile_type_clauseContext) +} + +func (s *Alter_typeContext) Replace_type_clause() IReplace_type_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_type_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_type_clauseContext) +} + +func (s *Alter_typeContext) Alter_method_spec() IAlter_method_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_method_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_method_specContext) +} + +func (s *Alter_typeContext) Alter_collection_clauses() IAlter_collection_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_collection_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_collection_clausesContext) +} + +func (s *Alter_typeContext) Modifier_clause() IModifier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Alter_typeContext) Overriding_subprogram_spec() IOverriding_subprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_subprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_subprogram_specContext) +} + +func (s *Alter_typeContext) Dependent_handling_clause() IDependent_handling_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDependent_handling_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDependent_handling_clauseContext) +} + +func (s *Alter_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_type(s) + } +} + +func (s *Alter_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_type(s) + } +} + +func (p *PlSqlParser) Alter_type() (localctx IAlter_typeContext) { + localctx = NewAlter_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, PlSqlParserRULE_alter_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4441) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4442) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4443) + p.Type_name() + } + p.SetState(4450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 277, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4444) + p.Compile_type_clause() + } + + case 2: + { + p.SetState(4445) + p.Replace_type_clause() + } + + case 3: + { + p.SetState(4446) + p.Alter_method_spec() + } + + case 4: + { + p.SetState(4447) + p.Alter_collection_clauses() + } + + case 5: + { + p.SetState(4448) + p.Modifier_clause() + } + + case 6: + { + p.SetState(4449) + p.Overriding_subprogram_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + { + p.SetState(4452) + p.Dependent_handling_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompile_type_clauseContext is an interface to support dynamic dispatch. +type ICompile_type_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPILE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + BODY() antlr.TerminalNode + + // IsCompile_type_clauseContext differentiates from other interfaces. + IsCompile_type_clauseContext() +} + +type Compile_type_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompile_type_clauseContext() *Compile_type_clauseContext { + var p = new(Compile_type_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compile_type_clause + return p +} + +func InitEmptyCompile_type_clauseContext(p *Compile_type_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compile_type_clause +} + +func (*Compile_type_clauseContext) IsCompile_type_clauseContext() {} + +func NewCompile_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compile_type_clauseContext { + var p = new(Compile_type_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compile_type_clause + + return p +} + +func (s *Compile_type_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compile_type_clauseContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Compile_type_clauseContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Compile_type_clauseContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Compile_type_clauseContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Compile_type_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Compile_type_clauseContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Compile_type_clauseContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Compile_type_clauseContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Compile_type_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compile_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compile_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompile_type_clause(s) + } +} + +func (s *Compile_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompile_type_clause(s) + } +} + +func (p *PlSqlParser) Compile_type_clause() (localctx ICompile_type_clauseContext) { + localctx = NewCompile_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, PlSqlParserRULE_compile_type_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4455) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4457) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 279, p.GetParserRuleContext()) == 1 { + { + p.SetState(4456) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4460) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) == 1 { + { + p.SetState(4459) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBODY || _la == PlSqlParserSPECIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4462) + p.Compiler_parameters_clause() + } + + } + p.SetState(4467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(4468) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4469) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_type_clauseContext is an interface to support dynamic dispatch. +type IReplace_type_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllObject_member_spec() []IObject_member_specContext + Object_member_spec(i int) IObject_member_specContext + RIGHT_PAREN() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReplace_type_clauseContext differentiates from other interfaces. + IsReplace_type_clauseContext() +} + +type Replace_type_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_type_clauseContext() *Replace_type_clauseContext { + var p = new(Replace_type_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_type_clause + return p +} + +func InitEmptyReplace_type_clauseContext(p *Replace_type_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_type_clause +} + +func (*Replace_type_clauseContext) IsReplace_type_clauseContext() {} + +func NewReplace_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_type_clauseContext { + var p = new(Replace_type_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replace_type_clause + + return p +} + +func (s *Replace_type_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_type_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Replace_type_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Replace_type_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Replace_type_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Replace_type_clauseContext) AllObject_member_spec() []IObject_member_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_member_specContext); ok { + len++ + } + } + + tst := make([]IObject_member_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_member_specContext); ok { + tst[i] = t.(IObject_member_specContext) + i++ + } + } + + return tst +} + +func (s *Replace_type_clauseContext) Object_member_spec(i int) IObject_member_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_member_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_member_specContext) +} + +func (s *Replace_type_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Replace_type_clauseContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Replace_type_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Replace_type_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Replace_type_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplace_type_clause(s) + } +} + +func (s *Replace_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplace_type_clause(s) + } +} + +func (p *PlSqlParser) Replace_type_clause() (localctx IReplace_type_clauseContext) { + localctx = NewReplace_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, PlSqlParserRULE_replace_type_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4472) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4473) + p.Invoker_rights_clause() + } + + } + { + p.SetState(4476) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4477) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4478) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4479) + p.Object_member_spec() + } + p.SetState(4484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4480) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4481) + p.Object_member_spec() + } + + p.SetState(4486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4487) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_method_specContext is an interface to support dynamic dispatch. +type IAlter_method_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_method_element() []IAlter_method_elementContext + Alter_method_element(i int) IAlter_method_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_method_specContext differentiates from other interfaces. + IsAlter_method_specContext() +} + +type Alter_method_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_method_specContext() *Alter_method_specContext { + var p = new(Alter_method_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_spec + return p +} + +func InitEmptyAlter_method_specContext(p *Alter_method_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_spec +} + +func (*Alter_method_specContext) IsAlter_method_specContext() {} + +func NewAlter_method_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_method_specContext { + var p = new(Alter_method_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_method_spec + + return p +} + +func (s *Alter_method_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_method_specContext) AllAlter_method_element() []IAlter_method_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_method_elementContext); ok { + len++ + } + } + + tst := make([]IAlter_method_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_method_elementContext); ok { + tst[i] = t.(IAlter_method_elementContext) + i++ + } + } + + return tst +} + +func (s *Alter_method_specContext) Alter_method_element(i int) IAlter_method_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_method_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_method_elementContext) +} + +func (s *Alter_method_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_method_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_method_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_method_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_method_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_method_spec(s) + } +} + +func (s *Alter_method_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_method_spec(s) + } +} + +func (p *PlSqlParser) Alter_method_spec() (localctx IAlter_method_specContext) { + localctx = NewAlter_method_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, PlSqlParserRULE_alter_method_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4489) + p.Alter_method_element() + } + p.SetState(4494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4490) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4491) + p.Alter_method_element() + } + + p.SetState(4496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_method_elementContext is an interface to support dynamic dispatch. +type IAlter_method_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + Map_order_function_spec() IMap_order_function_specContext + Subprogram_spec() ISubprogram_specContext + + // IsAlter_method_elementContext differentiates from other interfaces. + IsAlter_method_elementContext() +} + +type Alter_method_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_method_elementContext() *Alter_method_elementContext { + var p = new(Alter_method_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_element + return p +} + +func InitEmptyAlter_method_elementContext(p *Alter_method_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_element +} + +func (*Alter_method_elementContext) IsAlter_method_elementContext() {} + +func NewAlter_method_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_method_elementContext { + var p = new(Alter_method_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_method_element + + return p +} + +func (s *Alter_method_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_method_elementContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_method_elementContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_method_elementContext) Map_order_function_spec() IMap_order_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_function_specContext) +} + +func (s *Alter_method_elementContext) Subprogram_spec() ISubprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprogram_specContext) +} + +func (s *Alter_method_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_method_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_method_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_method_element(s) + } +} + +func (s *Alter_method_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_method_element(s) + } +} + +func (p *PlSqlParser) Alter_method_element() (localctx IAlter_method_elementContext) { + localctx = NewAlter_method_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, PlSqlParserRULE_alter_method_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4497) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAP, PlSqlParserORDER: + { + p.SetState(4498) + p.Map_order_function_spec() + } + + case PlSqlParserMEMBER, PlSqlParserSTATIC: + { + p.SetState(4499) + p.Subprogram_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_collection_clausesContext is an interface to support dynamic dispatch. +type IAlter_collection_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Expression() IExpressionContext + ELEMENT() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_spec() IType_specContext + + // IsAlter_collection_clausesContext differentiates from other interfaces. + IsAlter_collection_clausesContext() +} + +type Alter_collection_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_collection_clausesContext() *Alter_collection_clausesContext { + var p = new(Alter_collection_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses + return p +} + +func InitEmptyAlter_collection_clausesContext(p *Alter_collection_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses +} + +func (*Alter_collection_clausesContext) IsAlter_collection_clausesContext() {} + +func NewAlter_collection_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_collection_clausesContext { + var p = new(Alter_collection_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses + + return p +} + +func (s *Alter_collection_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_collection_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_collection_clausesContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Alter_collection_clausesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_collection_clausesContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Alter_collection_clausesContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Alter_collection_clausesContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Alter_collection_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_collection_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_collection_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_collection_clauses(s) + } +} + +func (s *Alter_collection_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_collection_clauses(s) + } +} + +func (p *PlSqlParser) Alter_collection_clauses() (localctx IAlter_collection_clausesContext) { + localctx = NewAlter_collection_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, PlSqlParserRULE_alter_collection_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4502) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLIMIT: + { + p.SetState(4503) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4504) + p.Expression() + } + + case PlSqlParserELEMENT: + { + p.SetState(4505) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4506) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4507) + p.Type_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDependent_handling_clauseContext is an interface to support dynamic dispatch. +type IDependent_handling_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INVALIDATE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONVERT() antlr.TerminalNode + TO() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + TABLE() antlr.TerminalNode + DATA() antlr.TerminalNode + Dependent_exceptions_part() IDependent_exceptions_partContext + NOT() antlr.TerminalNode + + // IsDependent_handling_clauseContext differentiates from other interfaces. + IsDependent_handling_clauseContext() +} + +type Dependent_handling_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDependent_handling_clauseContext() *Dependent_handling_clauseContext { + var p = new(Dependent_handling_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause + return p +} + +func InitEmptyDependent_handling_clauseContext(p *Dependent_handling_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause +} + +func (*Dependent_handling_clauseContext) IsDependent_handling_clauseContext() {} + +func NewDependent_handling_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dependent_handling_clauseContext { + var p = new(Dependent_handling_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause + + return p +} + +func (s *Dependent_handling_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dependent_handling_clauseContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Dependent_handling_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Dependent_handling_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Dependent_handling_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Dependent_handling_clauseContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Dependent_handling_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Dependent_handling_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Dependent_handling_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Dependent_handling_clauseContext) Dependent_exceptions_part() IDependent_exceptions_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDependent_exceptions_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDependent_exceptions_partContext) +} + +func (s *Dependent_handling_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Dependent_handling_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dependent_handling_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dependent_handling_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDependent_handling_clause(s) + } +} + +func (s *Dependent_handling_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDependent_handling_clause(s) + } +} + +func (p *PlSqlParser) Dependent_handling_clause() (localctx IDependent_handling_clauseContext) { + localctx = NewDependent_handling_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, PlSqlParserRULE_dependent_handling_clause) + var _la int + + p.SetState(4526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINVALIDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4510) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCASCADE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4511) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONVERT: + { + p.SetState(4512) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4513) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4514) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINCLUDING, PlSqlParserNOT: + p.SetState(4516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(4515) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4518) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4519) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4520) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserEXCEPTIONS, PlSqlParserFORCE, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(4524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTIONS || _la == PlSqlParserFORCE { + { + p.SetState(4523) + p.Dependent_exceptions_part() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDependent_exceptions_partContext is an interface to support dynamic dispatch. +type IDependent_exceptions_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTIONS() antlr.TerminalNode + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + FORCE() antlr.TerminalNode + + // IsDependent_exceptions_partContext differentiates from other interfaces. + IsDependent_exceptions_partContext() +} + +type Dependent_exceptions_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDependent_exceptions_partContext() *Dependent_exceptions_partContext { + var p = new(Dependent_exceptions_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part + return p +} + +func InitEmptyDependent_exceptions_partContext(p *Dependent_exceptions_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part +} + +func (*Dependent_exceptions_partContext) IsDependent_exceptions_partContext() {} + +func NewDependent_exceptions_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dependent_exceptions_partContext { + var p = new(Dependent_exceptions_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part + + return p +} + +func (s *Dependent_exceptions_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dependent_exceptions_partContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Dependent_exceptions_partContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Dependent_exceptions_partContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dependent_exceptions_partContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Dependent_exceptions_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dependent_exceptions_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dependent_exceptions_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDependent_exceptions_part(s) + } +} + +func (s *Dependent_exceptions_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDependent_exceptions_part(s) + } +} + +func (p *PlSqlParser) Dependent_exceptions_part() (localctx IDependent_exceptions_partContext) { + localctx = NewDependent_exceptions_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, PlSqlParserRULE_dependent_exceptions_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(4528) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4531) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4532) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4533) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_typeContext is an interface to support dynamic dispatch. +type ICreate_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_definition() IType_definitionContext + Type_body() IType_bodyContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsCreate_typeContext differentiates from other interfaces. + IsCreate_typeContext() +} + +type Create_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_typeContext() *Create_typeContext { + var p = new(Create_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_type + return p +} + +func InitEmptyCreate_typeContext(p *Create_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_type +} + +func (*Create_typeContext) IsCreate_typeContext() {} + +func NewCreate_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_typeContext { + var p = new(Create_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_type + + return p +} + +func (s *Create_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_typeContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Create_typeContext) Type_definition() IType_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_definitionContext) +} + +func (s *Create_typeContext) Type_body() IType_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_bodyContext) +} + +func (s *Create_typeContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_typeContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_typeContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_typeContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_type(s) + } +} + +func (s *Create_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_type(s) + } +} + +func (p *PlSqlParser) Create_type() (localctx ICreate_typeContext) { + localctx = NewCreate_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, PlSqlParserRULE_create_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4535) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4536) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4537) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(4540) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4543) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 295, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4544) + p.Type_definition() + } + + case 2: + { + p.SetState(4545) + p.Type_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_definitionContext is an interface to support dynamic dispatch. +type IType_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Type_name() IType_nameContext + OID() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + FORCE() antlr.TerminalNode + Object_type_def() IObject_type_defContext + + // IsType_definitionContext differentiates from other interfaces. + IsType_definitionContext() +} + +type Type_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_definitionContext() *Type_definitionContext { + var p = new(Type_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_definition + return p +} + +func InitEmptyType_definitionContext(p *Type_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_definition +} + +func (*Type_definitionContext) IsType_definitionContext() {} + +func NewType_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_definitionContext { + var p = new(Type_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_definition + + return p +} + +func (s *Type_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_definitionContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_definitionContext) OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOID, 0) +} + +func (s *Type_definitionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Type_definitionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Type_definitionContext) Object_type_def() IObject_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_defContext) +} + +func (s *Type_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_definition(s) + } +} + +func (s *Type_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_definition(s) + } +} + +func (p *PlSqlParser) Type_definition() (localctx IType_definitionContext) { + localctx = NewType_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, PlSqlParserRULE_type_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4548) + p.Type_name() + } + p.SetState(4551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOID { + { + p.SetState(4549) + p.Match(PlSqlParserOID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4550) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(4553) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserAUTHID || _la == PlSqlParserIS || _la == PlSqlParserUNDER { + { + p.SetState(4556) + p.Object_type_def() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_type_defContext is an interface to support dynamic dispatch. +type IObject_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_as_part() IObject_as_partContext + Object_under_part() IObject_under_partContext + Invoker_rights_clause() IInvoker_rights_clauseContext + Sqlj_object_type() ISqlj_object_typeContext + LEFT_PAREN() antlr.TerminalNode + AllObject_member_spec() []IObject_member_specContext + Object_member_spec(i int) IObject_member_specContext + RIGHT_PAREN() antlr.TerminalNode + AllModifier_clause() []IModifier_clauseContext + Modifier_clause(i int) IModifier_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsObject_type_defContext differentiates from other interfaces. + IsObject_type_defContext() +} + +type Object_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_defContext() *Object_type_defContext { + var p = new(Object_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_def + return p +} + +func InitEmptyObject_type_defContext(p *Object_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_def +} + +func (*Object_type_defContext) IsObject_type_defContext() {} + +func NewObject_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_defContext { + var p = new(Object_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_type_def + + return p +} + +func (s *Object_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_defContext) Object_as_part() IObject_as_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_as_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_as_partContext) +} + +func (s *Object_type_defContext) Object_under_part() IObject_under_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_under_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_under_partContext) +} + +func (s *Object_type_defContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Object_type_defContext) Sqlj_object_type() ISqlj_object_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlj_object_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlj_object_typeContext) +} + +func (s *Object_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Object_type_defContext) AllObject_member_spec() []IObject_member_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_member_specContext); ok { + len++ + } + } + + tst := make([]IObject_member_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_member_specContext); ok { + tst[i] = t.(IObject_member_specContext) + i++ + } + } + + return tst +} + +func (s *Object_type_defContext) Object_member_spec(i int) IObject_member_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_member_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_member_specContext) +} + +func (s *Object_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Object_type_defContext) AllModifier_clause() []IModifier_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModifier_clauseContext); ok { + len++ + } + } + + tst := make([]IModifier_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModifier_clauseContext); ok { + tst[i] = t.(IModifier_clauseContext) + i++ + } + } + + return tst +} + +func (s *Object_type_defContext) Modifier_clause(i int) IModifier_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Object_type_defContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_type_defContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_type_def(s) + } +} + +func (s *Object_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type_def(s) + } +} + +func (p *PlSqlParser) Object_type_def() (localctx IObject_type_defContext) { + localctx = NewObject_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, PlSqlParserRULE_object_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4559) + p.Invoker_rights_clause() + } + + } + p.SetState(4564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(4562) + p.Object_as_part() + } + + case PlSqlParserUNDER: + { + p.SetState(4563) + p.Object_under_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(4566) + p.Sqlj_object_type() + } + + } + p.SetState(4580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4569) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4570) + p.Object_member_spec() + } + p.SetState(4575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4571) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4572) + p.Object_member_spec() + } + + p.SetState(4577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4578) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserNOT || _la == PlSqlParserOVERRIDING { + { + p.SetState(4582) + p.Modifier_clause() + } + + p.SetState(4587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_as_partContext is an interface to support dynamic dispatch. +type IObject_as_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + Varray_type_def() IVarray_type_defContext + Nested_table_type_def() INested_table_type_defContext + + // IsObject_as_partContext differentiates from other interfaces. + IsObject_as_partContext() +} + +type Object_as_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_as_partContext() *Object_as_partContext { + var p = new(Object_as_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_as_part + return p +} + +func InitEmptyObject_as_partContext(p *Object_as_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_as_part +} + +func (*Object_as_partContext) IsObject_as_partContext() {} + +func NewObject_as_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_as_partContext { + var p = new(Object_as_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_as_part + + return p +} + +func (s *Object_as_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_as_partContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Object_as_partContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Object_as_partContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Object_as_partContext) Varray_type_def() IVarray_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_type_defContext) +} + +func (s *Object_as_partContext) Nested_table_type_def() INested_table_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INested_table_type_defContext) +} + +func (s *Object_as_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_as_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_as_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_as_part(s) + } +} + +func (s *Object_as_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_as_part(s) + } +} + +func (p *PlSqlParser) Object_as_part() (localctx IObject_as_partContext) { + localctx = NewObject_as_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, PlSqlParserRULE_object_as_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4588) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(4589) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARRAY, PlSqlParserVARRAY, PlSqlParserVARYING: + { + p.SetState(4590) + p.Varray_type_def() + } + + case PlSqlParserTABLE: + { + p.SetState(4591) + p.Nested_table_type_def() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_under_partContext is an interface to support dynamic dispatch. +type IObject_under_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDER() antlr.TerminalNode + Type_spec() IType_specContext + + // IsObject_under_partContext differentiates from other interfaces. + IsObject_under_partContext() +} + +type Object_under_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_under_partContext() *Object_under_partContext { + var p = new(Object_under_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_under_part + return p +} + +func InitEmptyObject_under_partContext(p *Object_under_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_under_part +} + +func (*Object_under_partContext) IsObject_under_partContext() {} + +func NewObject_under_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_under_partContext { + var p = new(Object_under_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_under_part + + return p +} + +func (s *Object_under_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_under_partContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_under_partContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Object_under_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_under_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_under_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_under_part(s) + } +} + +func (s *Object_under_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_under_part(s) + } +} + +func (p *PlSqlParser) Object_under_part() (localctx IObject_under_partContext) { + localctx = NewObject_under_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, PlSqlParserRULE_object_under_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4594) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4595) + p.Type_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INested_table_type_defContext is an interface to support dynamic dispatch. +type INested_table_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsNested_table_type_defContext differentiates from other interfaces. + IsNested_table_type_defContext() +} + +type Nested_table_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_table_type_defContext() *Nested_table_type_defContext { + var p = new(Nested_table_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_type_def + return p +} + +func InitEmptyNested_table_type_defContext(p *Nested_table_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_type_def +} + +func (*Nested_table_type_defContext) IsNested_table_type_defContext() {} + +func NewNested_table_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_table_type_defContext { + var p = new(Nested_table_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_table_type_def + + return p +} + +func (s *Nested_table_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_table_type_defContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Nested_table_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Nested_table_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Nested_table_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Nested_table_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Nested_table_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_table_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_table_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_table_type_def(s) + } +} + +func (s *Nested_table_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_table_type_def(s) + } +} + +func (p *PlSqlParser) Nested_table_type_def() (localctx INested_table_type_defContext) { + localctx = NewNested_table_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, PlSqlParserRULE_nested_table_type_def) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4597) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4598) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4599) + p.Type_spec() + } + p.SetState(4602) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) == 1 { + { + p.SetState(4600) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4601) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlj_object_typeContext is an interface to support dynamic dispatch. +type ISqlj_object_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + LANGUAGE() antlr.TerminalNode + JAVA() antlr.TerminalNode + USING() antlr.TerminalNode + SQLDATA() antlr.TerminalNode + CUSTOMDATUM() antlr.TerminalNode + ORADATA() antlr.TerminalNode + + // IsSqlj_object_typeContext differentiates from other interfaces. + IsSqlj_object_typeContext() +} + +type Sqlj_object_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlj_object_typeContext() *Sqlj_object_typeContext { + var p = new(Sqlj_object_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type + return p +} + +func InitEmptySqlj_object_typeContext(p *Sqlj_object_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type +} + +func (*Sqlj_object_typeContext) IsSqlj_object_typeContext() {} + +func NewSqlj_object_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sqlj_object_typeContext { + var p = new(Sqlj_object_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sqlj_object_type + + return p +} + +func (s *Sqlj_object_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sqlj_object_typeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Sqlj_object_typeContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Sqlj_object_typeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sqlj_object_typeContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Sqlj_object_typeContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Sqlj_object_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Sqlj_object_typeContext) SQLDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLDATA, 0) +} + +func (s *Sqlj_object_typeContext) CUSTOMDATUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUSTOMDATUM, 0) +} + +func (s *Sqlj_object_typeContext) ORADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADATA, 0) +} + +func (s *Sqlj_object_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sqlj_object_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sqlj_object_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSqlj_object_type(s) + } +} + +func (s *Sqlj_object_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSqlj_object_type(s) + } +} + +func (p *PlSqlParser) Sqlj_object_type() (localctx ISqlj_object_typeContext) { + localctx = NewSqlj_object_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, PlSqlParserRULE_sqlj_object_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4604) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4605) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4606) + p.Expression() + } + { + p.SetState(4607) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4608) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4609) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4610) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCUSTOMDATUM || _la == PlSqlParserORADATA || _la == PlSqlParserSQLDATA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_bodyContext is an interface to support dynamic dispatch. +type IType_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BODY() antlr.TerminalNode + Type_name() IType_nameContext + END() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllType_body_elements() []IType_body_elementsContext + Type_body_elements(i int) IType_body_elementsContext + + // IsType_bodyContext differentiates from other interfaces. + IsType_bodyContext() +} + +type Type_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_bodyContext() *Type_bodyContext { + var p = new(Type_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body + return p +} + +func InitEmptyType_bodyContext(p *Type_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body +} + +func (*Type_bodyContext) IsType_bodyContext() {} + +func NewType_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_bodyContext { + var p = new(Type_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_body + + return p +} + +func (s *Type_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_bodyContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Type_bodyContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Type_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Type_bodyContext) AllType_body_elements() []IType_body_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_body_elementsContext); ok { + len++ + } + } + + tst := make([]IType_body_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_body_elementsContext); ok { + tst[i] = t.(IType_body_elementsContext) + i++ + } + } + + return tst +} + +func (s *Type_bodyContext) Type_body_elements(i int) IType_body_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_body_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_body_elementsContext) +} + +func (s *Type_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_body(s) + } +} + +func (s *Type_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_body(s) + } +} + +func (p *PlSqlParser) Type_body() (localctx IType_bodyContext) { + localctx = NewType_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, PlSqlParserRULE_type_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4612) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4613) + p.Type_name() + } + { + p.SetState(4614) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCONSTRUCTOR || _la == PlSqlParserFINAL || _la == PlSqlParserFUNCTION || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserMAP || _la == PlSqlParserMEMBER || _la == PlSqlParserORDER || _la == PlSqlParserOVERRIDING || _la == PlSqlParserPROCEDURE || _la == PlSqlParserSTATIC { + { + p.SetState(4615) + p.Type_body_elements() + } + + p.SetState(4618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4620) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_body_elementsContext is an interface to support dynamic dispatch. +type IType_body_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Map_order_func_declaration() IMap_order_func_declarationContext + Subprog_decl_in_type() ISubprog_decl_in_typeContext + Overriding_subprogram_spec() IOverriding_subprogram_specContext + + // IsType_body_elementsContext differentiates from other interfaces. + IsType_body_elementsContext() +} + +type Type_body_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_body_elementsContext() *Type_body_elementsContext { + var p = new(Type_body_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body_elements + return p +} + +func InitEmptyType_body_elementsContext(p *Type_body_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body_elements +} + +func (*Type_body_elementsContext) IsType_body_elementsContext() {} + +func NewType_body_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_body_elementsContext { + var p = new(Type_body_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_body_elements + + return p +} + +func (s *Type_body_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_body_elementsContext) Map_order_func_declaration() IMap_order_func_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_func_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_func_declarationContext) +} + +func (s *Type_body_elementsContext) Subprog_decl_in_type() ISubprog_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprog_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprog_decl_in_typeContext) +} + +func (s *Type_body_elementsContext) Overriding_subprogram_spec() IOverriding_subprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_subprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_subprogram_specContext) +} + +func (s *Type_body_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_body_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_body_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_body_elements(s) + } +} + +func (s *Type_body_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_body_elements(s) + } +} + +func (p *PlSqlParser) Type_body_elements() (localctx IType_body_elementsContext) { + localctx = NewType_body_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, PlSqlParserRULE_type_body_elements) + p.SetState(4625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAP, PlSqlParserORDER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4622) + p.Map_order_func_declaration() + } + + case PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserFUNCTION, PlSqlParserINSTANTIABLE, PlSqlParserMEMBER, PlSqlParserPROCEDURE, PlSqlParserSTATIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4623) + p.Subprog_decl_in_type() + } + + case PlSqlParserOVERRIDING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4624) + p.Overriding_subprogram_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMap_order_func_declarationContext is an interface to support dynamic dispatch. +type IMap_order_func_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + Func_decl_in_type() IFunc_decl_in_typeContext + MAP() antlr.TerminalNode + ORDER() antlr.TerminalNode + + // IsMap_order_func_declarationContext differentiates from other interfaces. + IsMap_order_func_declarationContext() +} + +type Map_order_func_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMap_order_func_declarationContext() *Map_order_func_declarationContext { + var p = new(Map_order_func_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration + return p +} + +func InitEmptyMap_order_func_declarationContext(p *Map_order_func_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration +} + +func (*Map_order_func_declarationContext) IsMap_order_func_declarationContext() {} + +func NewMap_order_func_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_order_func_declarationContext { + var p = new(Map_order_func_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration + + return p +} + +func (s *Map_order_func_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Map_order_func_declarationContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Map_order_func_declarationContext) Func_decl_in_type() IFunc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_decl_in_typeContext) +} + +func (s *Map_order_func_declarationContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Map_order_func_declarationContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Map_order_func_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Map_order_func_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Map_order_func_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMap_order_func_declaration(s) + } +} + +func (s *Map_order_func_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMap_order_func_declaration(s) + } +} + +func (p *PlSqlParser) Map_order_func_declaration() (localctx IMap_order_func_declarationContext) { + localctx = NewMap_order_func_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, PlSqlParserRULE_map_order_func_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4627) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAP || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4628) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4629) + p.Func_decl_in_type() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubprog_decl_in_typeContext is an interface to support dynamic dispatch. +type ISubprog_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Proc_decl_in_type() IProc_decl_in_typeContext + Func_decl_in_type() IFunc_decl_in_typeContext + Constructor_declaration() IConstructor_declarationContext + MEMBER() antlr.TerminalNode + STATIC() antlr.TerminalNode + + // IsSubprog_decl_in_typeContext differentiates from other interfaces. + IsSubprog_decl_in_typeContext() +} + +type Subprog_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubprog_decl_in_typeContext() *Subprog_decl_in_typeContext { + var p = new(Subprog_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type + return p +} + +func InitEmptySubprog_decl_in_typeContext(p *Subprog_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type +} + +func (*Subprog_decl_in_typeContext) IsSubprog_decl_in_typeContext() {} + +func NewSubprog_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subprog_decl_in_typeContext { + var p = new(Subprog_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type + + return p +} + +func (s *Subprog_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subprog_decl_in_typeContext) Proc_decl_in_type() IProc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_decl_in_typeContext) +} + +func (s *Subprog_decl_in_typeContext) Func_decl_in_type() IFunc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_decl_in_typeContext) +} + +func (s *Subprog_decl_in_typeContext) Constructor_declaration() IConstructor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructor_declarationContext) +} + +func (s *Subprog_decl_in_typeContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Subprog_decl_in_typeContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Subprog_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subprog_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subprog_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubprog_decl_in_type(s) + } +} + +func (s *Subprog_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubprog_decl_in_type(s) + } +} + +func (p *PlSqlParser) Subprog_decl_in_type() (localctx ISubprog_decl_in_typeContext) { + localctx = NewSubprog_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, PlSqlParserRULE_subprog_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMBER || _la == PlSqlParserSTATIC { + { + p.SetState(4631) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSTATIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPROCEDURE: + { + p.SetState(4634) + p.Proc_decl_in_type() + } + + case PlSqlParserFUNCTION: + { + p.SetState(4635) + p.Func_decl_in_type() + } + + case PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE: + { + p.SetState(4636) + p.Constructor_declaration() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_decl_in_typeContext is an interface to support dynamic dispatch. +type IProc_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsProc_decl_in_typeContext differentiates from other interfaces. + IsProc_decl_in_typeContext() +} + +type Proc_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_decl_in_typeContext() *Proc_decl_in_typeContext { + var p = new(Proc_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type + return p +} + +func InitEmptyProc_decl_in_typeContext(p *Proc_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type +} + +func (*Proc_decl_in_typeContext) IsProc_decl_in_typeContext() {} + +func NewProc_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_decl_in_typeContext { + var p = new(Proc_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type + + return p +} + +func (s *Proc_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_decl_in_typeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Proc_decl_in_typeContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Proc_decl_in_typeContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Proc_decl_in_typeContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Proc_decl_in_typeContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Proc_decl_in_typeContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Proc_decl_in_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Proc_decl_in_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Proc_decl_in_typeContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Proc_decl_in_typeContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Proc_decl_in_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Proc_decl_in_typeContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Proc_decl_in_typeContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Proc_decl_in_typeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Proc_decl_in_typeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Proc_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProc_decl_in_type(s) + } +} + +func (s *Proc_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProc_decl_in_type(s) + } +} + +func (p *PlSqlParser) Proc_decl_in_type() (localctx IProc_decl_in_typeContext) { + localctx = NewProc_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, PlSqlParserRULE_proc_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4639) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4640) + p.Procedure_name() + } + p.SetState(4652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4641) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4642) + p.Type_elements_parameter() + } + p.SetState(4647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4643) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4644) + p.Type_elements_parameter() + } + + p.SetState(4649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4650) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4654) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 315, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4655) + p.Call_spec() + } + + case 2: + p.SetState(4657) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 313, p.GetParserRuleContext()) == 1 { + { + p.SetState(4656) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4660) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 314, p.GetParserRuleContext()) == 1 { + { + p.SetState(4659) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4662) + p.Body() + } + { + p.SetState(4663) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_decl_in_typeContext is an interface to support dynamic dispatch. +type IFunc_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_decl_in_typeContext differentiates from other interfaces. + IsFunc_decl_in_typeContext() +} + +type Func_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_decl_in_typeContext() *Func_decl_in_typeContext { + var p = new(Func_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_func_decl_in_type + return p +} + +func InitEmptyFunc_decl_in_typeContext(p *Func_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_func_decl_in_type +} + +func (*Func_decl_in_typeContext) IsFunc_decl_in_typeContext() {} + +func NewFunc_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_decl_in_typeContext { + var p = new(Func_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_func_decl_in_type + + return p +} + +func (s *Func_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_decl_in_typeContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Func_decl_in_typeContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Func_decl_in_typeContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Func_decl_in_typeContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Func_decl_in_typeContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Func_decl_in_typeContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Func_decl_in_typeContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Func_decl_in_typeContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Func_decl_in_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Func_decl_in_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Func_decl_in_typeContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Func_decl_in_typeContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Func_decl_in_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Func_decl_in_typeContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Func_decl_in_typeContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Func_decl_in_typeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Func_decl_in_typeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Func_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunc_decl_in_type(s) + } +} + +func (s *Func_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunc_decl_in_type(s) + } +} + +func (p *PlSqlParser) Func_decl_in_type() (localctx IFunc_decl_in_typeContext) { + localctx = NewFunc_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, PlSqlParserRULE_func_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4667) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4668) + p.Function_name() + } + p.SetState(4680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4669) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4670) + p.Type_elements_parameter() + } + p.SetState(4675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4671) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4672) + p.Type_elements_parameter() + } + + p.SetState(4677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4678) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4682) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4683) + p.Type_spec() + } + { + p.SetState(4684) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 320, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4685) + p.Call_spec() + } + + case 2: + p.SetState(4687) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 318, p.GetParserRuleContext()) == 1 { + { + p.SetState(4686) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) == 1 { + { + p.SetState(4689) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4692) + p.Body() + } + { + p.SetState(4693) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstructor_declarationContext is an interface to support dynamic dispatch. +type IConstructor_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRUCTOR() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + AllSELF() []antlr.TerminalNode + SELF(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + IS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + FINAL() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + Type_spec() IType_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + + // IsConstructor_declarationContext differentiates from other interfaces. + IsConstructor_declarationContext() +} + +type Constructor_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructor_declarationContext() *Constructor_declarationContext { + var p = new(Constructor_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_declaration + return p +} + +func InitEmptyConstructor_declarationContext(p *Constructor_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_declaration +} + +func (*Constructor_declarationContext) IsConstructor_declarationContext() {} + +func NewConstructor_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constructor_declarationContext { + var p = new(Constructor_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constructor_declaration + + return p +} + +func (s *Constructor_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constructor_declarationContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Constructor_declarationContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Constructor_declarationContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Constructor_declarationContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Constructor_declarationContext) AllSELF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSELF) +} + +func (s *Constructor_declarationContext) SELF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, i) +} + +func (s *Constructor_declarationContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Constructor_declarationContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Constructor_declarationContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Constructor_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Constructor_declarationContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Constructor_declarationContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Constructor_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Constructor_declarationContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Constructor_declarationContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Constructor_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constructor_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constructor_declarationContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Constructor_declarationContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Constructor_declarationContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Constructor_declarationContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Constructor_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Constructor_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constructor_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constructor_declarationContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Constructor_declarationContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Constructor_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constructor_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constructor_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstructor_declaration(s) + } +} + +func (s *Constructor_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstructor_declaration(s) + } +} + +func (p *PlSqlParser) Constructor_declaration() (localctx IConstructor_declarationContext) { + localctx = NewConstructor_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, PlSqlParserRULE_constructor_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINAL { + { + p.SetState(4697) + p.Match(PlSqlParserFINAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINSTANTIABLE { + { + p.SetState(4700) + p.Match(PlSqlParserINSTANTIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4703) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4704) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4705) + p.Function_name() + } + p.SetState(4726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4706) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4713) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 323, p.GetParserRuleContext()) == 1 { + { + p.SetState(4707) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4708) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4709) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4710) + p.Type_spec() + } + { + p.SetState(4711) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(4715) + p.Type_elements_parameter() + } + p.SetState(4720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4716) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4717) + p.Type_elements_parameter() + } + + p.SetState(4722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(4725) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4728) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4729) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4730) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4731) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4732) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 329, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4733) + p.Call_spec() + } + + case 2: + p.SetState(4735) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 327, p.GetParserRuleContext()) == 1 { + { + p.SetState(4734) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4738) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 328, p.GetParserRuleContext()) == 1 { + { + p.SetState(4737) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4740) + p.Body() + } + { + p.SetState(4741) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModifier_clauseContext is an interface to support dynamic dispatch. +type IModifier_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSTANTIABLE() antlr.TerminalNode + FINAL() antlr.TerminalNode + OVERRIDING() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsModifier_clauseContext differentiates from other interfaces. + IsModifier_clauseContext() +} + +type Modifier_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModifier_clauseContext() *Modifier_clauseContext { + var p = new(Modifier_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modifier_clause + return p +} + +func InitEmptyModifier_clauseContext(p *Modifier_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modifier_clause +} + +func (*Modifier_clauseContext) IsModifier_clauseContext() {} + +func NewModifier_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modifier_clauseContext { + var p = new(Modifier_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modifier_clause + + return p +} + +func (s *Modifier_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modifier_clauseContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Modifier_clauseContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Modifier_clauseContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Modifier_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Modifier_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modifier_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modifier_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModifier_clause(s) + } +} + +func (s *Modifier_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModifier_clause(s) + } +} + +func (p *PlSqlParser) Modifier_clause() (localctx IModifier_clauseContext) { + localctx = NewModifier_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, PlSqlParserRULE_modifier_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(4745) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4748) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserOVERRIDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_member_specContext is an interface to support dynamic dispatch. +type IObject_member_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_spec() IType_specContext + Sqlj_object_type_attr() ISqlj_object_type_attrContext + Element_spec() IElement_specContext + + // IsObject_member_specContext differentiates from other interfaces. + IsObject_member_specContext() +} + +type Object_member_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_member_specContext() *Object_member_specContext { + var p = new(Object_member_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_member_spec + return p +} + +func InitEmptyObject_member_specContext(p *Object_member_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_member_spec +} + +func (*Object_member_specContext) IsObject_member_specContext() {} + +func NewObject_member_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_member_specContext { + var p = new(Object_member_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_member_spec + + return p +} + +func (s *Object_member_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_member_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Object_member_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Object_member_specContext) Sqlj_object_type_attr() ISqlj_object_type_attrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlj_object_type_attrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlj_object_type_attrContext) +} + +func (s *Object_member_specContext) Element_spec() IElement_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElement_specContext) +} + +func (s *Object_member_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_member_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_member_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_member_spec(s) + } +} + +func (s *Object_member_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_member_spec(s) + } +} + +func (p *PlSqlParser) Object_member_spec() (localctx IObject_member_specContext) { + localctx = NewObject_member_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, PlSqlParserRULE_object_member_spec) + var _la int + + p.SetState(4756) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4750) + p.Identifier() + } + { + p.SetState(4751) + p.Type_spec() + } + p.SetState(4753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(4752) + p.Sqlj_object_type_attr() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4755) + p.Element_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlj_object_type_attrContext is an interface to support dynamic dispatch. +type ISqlj_object_type_attrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + + // IsSqlj_object_type_attrContext differentiates from other interfaces. + IsSqlj_object_type_attrContext() +} + +type Sqlj_object_type_attrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlj_object_type_attrContext() *Sqlj_object_type_attrContext { + var p = new(Sqlj_object_type_attrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr + return p +} + +func InitEmptySqlj_object_type_attrContext(p *Sqlj_object_type_attrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr +} + +func (*Sqlj_object_type_attrContext) IsSqlj_object_type_attrContext() {} + +func NewSqlj_object_type_attrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sqlj_object_type_attrContext { + var p = new(Sqlj_object_type_attrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr + + return p +} + +func (s *Sqlj_object_type_attrContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sqlj_object_type_attrContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Sqlj_object_type_attrContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Sqlj_object_type_attrContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sqlj_object_type_attrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sqlj_object_type_attrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sqlj_object_type_attrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSqlj_object_type_attr(s) + } +} + +func (s *Sqlj_object_type_attrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSqlj_object_type_attr(s) + } +} + +func (p *PlSqlParser) Sqlj_object_type_attr() (localctx ISqlj_object_type_attrContext) { + localctx = NewSqlj_object_type_attrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, PlSqlParserRULE_sqlj_object_type_attr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4758) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4759) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4760) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElement_specContext is an interface to support dynamic dispatch. +type IElement_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Modifier_clause() IModifier_clauseContext + AllElement_spec_options() []IElement_spec_optionsContext + Element_spec_options(i int) IElement_spec_optionsContext + COMMA() antlr.TerminalNode + Pragma_clause() IPragma_clauseContext + + // IsElement_specContext differentiates from other interfaces. + IsElement_specContext() +} + +type Element_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_specContext() *Element_specContext { + var p = new(Element_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec + return p +} + +func InitEmptyElement_specContext(p *Element_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec +} + +func (*Element_specContext) IsElement_specContext() {} + +func NewElement_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_specContext { + var p = new(Element_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element_spec + + return p +} + +func (s *Element_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_specContext) Modifier_clause() IModifier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Element_specContext) AllElement_spec_options() []IElement_spec_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElement_spec_optionsContext); ok { + len++ + } + } + + tst := make([]IElement_spec_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElement_spec_optionsContext); ok { + tst[i] = t.(IElement_spec_optionsContext) + i++ + } + } + + return tst +} + +func (s *Element_specContext) Element_spec_options(i int) IElement_spec_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_spec_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElement_spec_optionsContext) +} + +func (s *Element_specContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Element_specContext) Pragma_clause() IPragma_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_clauseContext) +} + +func (s *Element_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement_spec(s) + } +} + +func (s *Element_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement_spec(s) + } +} + +func (p *PlSqlParser) Element_spec() (localctx IElement_specContext) { + localctx = NewElement_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, PlSqlParserRULE_element_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4763) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 333, p.GetParserRuleContext()) == 1 { + { + p.SetState(4762) + p.Modifier_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCONSTRUCTOR || _la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserMAP || _la == PlSqlParserMEMBER || _la == PlSqlParserORDER || _la == PlSqlParserSTATIC { + { + p.SetState(4765) + p.Element_spec_options() + } + + p.SetState(4768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4772) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) == 1 { + { + p.SetState(4770) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4771) + p.Pragma_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElement_spec_optionsContext is an interface to support dynamic dispatch. +type IElement_spec_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subprogram_spec() ISubprogram_specContext + Constructor_spec() IConstructor_specContext + Map_order_function_spec() IMap_order_function_specContext + + // IsElement_spec_optionsContext differentiates from other interfaces. + IsElement_spec_optionsContext() +} + +type Element_spec_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_spec_optionsContext() *Element_spec_optionsContext { + var p = new(Element_spec_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec_options + return p +} + +func InitEmptyElement_spec_optionsContext(p *Element_spec_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec_options +} + +func (*Element_spec_optionsContext) IsElement_spec_optionsContext() {} + +func NewElement_spec_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_spec_optionsContext { + var p = new(Element_spec_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element_spec_options + + return p +} + +func (s *Element_spec_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_spec_optionsContext) Subprogram_spec() ISubprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprogram_specContext) +} + +func (s *Element_spec_optionsContext) Constructor_spec() IConstructor_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructor_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructor_specContext) +} + +func (s *Element_spec_optionsContext) Map_order_function_spec() IMap_order_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_function_specContext) +} + +func (s *Element_spec_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_spec_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_spec_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement_spec_options(s) + } +} + +func (s *Element_spec_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement_spec_options(s) + } +} + +func (p *PlSqlParser) Element_spec_options() (localctx IElement_spec_optionsContext) { + localctx = NewElement_spec_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, PlSqlParserRULE_element_spec_options) + p.SetState(4777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMEMBER, PlSqlParserSTATIC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4774) + p.Subprogram_spec() + } + + case PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4775) + p.Constructor_spec() + } + + case PlSqlParserMAP, PlSqlParserORDER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4776) + p.Map_order_function_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubprogram_specContext is an interface to support dynamic dispatch. +type ISubprogram_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + STATIC() antlr.TerminalNode + Type_procedure_spec() IType_procedure_specContext + Type_function_spec() IType_function_specContext + + // IsSubprogram_specContext differentiates from other interfaces. + IsSubprogram_specContext() +} + +type Subprogram_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubprogram_specContext() *Subprogram_specContext { + var p = new(Subprogram_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprogram_spec + return p +} + +func InitEmptySubprogram_specContext(p *Subprogram_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprogram_spec +} + +func (*Subprogram_specContext) IsSubprogram_specContext() {} + +func NewSubprogram_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subprogram_specContext { + var p = new(Subprogram_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subprogram_spec + + return p +} + +func (s *Subprogram_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subprogram_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Subprogram_specContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Subprogram_specContext) Type_procedure_spec() IType_procedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_procedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_procedure_specContext) +} + +func (s *Subprogram_specContext) Type_function_spec() IType_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_specContext) +} + +func (s *Subprogram_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subprogram_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subprogram_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubprogram_spec(s) + } +} + +func (s *Subprogram_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubprogram_spec(s) + } +} + +func (p *PlSqlParser) Subprogram_spec() (localctx ISubprogram_specContext) { + localctx = NewSubprogram_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, PlSqlParserRULE_subprogram_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4779) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSTATIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPROCEDURE: + { + p.SetState(4780) + p.Type_procedure_spec() + } + + case PlSqlParserFUNCTION: + { + p.SetState(4781) + p.Type_function_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverriding_subprogram_specContext is an interface to support dynamic dispatch. +type IOverriding_subprogram_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVERRIDING() antlr.TerminalNode + MEMBER() antlr.TerminalNode + Overriding_function_spec() IOverriding_function_specContext + Overriding_procedure_spec() IOverriding_procedure_specContext + + // IsOverriding_subprogram_specContext differentiates from other interfaces. + IsOverriding_subprogram_specContext() +} + +type Overriding_subprogram_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverriding_subprogram_specContext() *Overriding_subprogram_specContext { + var p = new(Overriding_subprogram_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec + return p +} + +func InitEmptyOverriding_subprogram_specContext(p *Overriding_subprogram_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec +} + +func (*Overriding_subprogram_specContext) IsOverriding_subprogram_specContext() {} + +func NewOverriding_subprogram_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overriding_subprogram_specContext { + var p = new(Overriding_subprogram_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec + + return p +} + +func (s *Overriding_subprogram_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overriding_subprogram_specContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Overriding_subprogram_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Overriding_subprogram_specContext) Overriding_function_spec() IOverriding_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_function_specContext) +} + +func (s *Overriding_subprogram_specContext) Overriding_procedure_spec() IOverriding_procedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_procedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_procedure_specContext) +} + +func (s *Overriding_subprogram_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overriding_subprogram_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overriding_subprogram_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOverriding_subprogram_spec(s) + } +} + +func (s *Overriding_subprogram_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOverriding_subprogram_spec(s) + } +} + +func (p *PlSqlParser) Overriding_subprogram_spec() (localctx IOverriding_subprogram_specContext) { + localctx = NewOverriding_subprogram_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, PlSqlParserRULE_overriding_subprogram_spec) + p.SetState(4790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 338, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4784) + p.Match(PlSqlParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4785) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4786) + p.Overriding_function_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4787) + p.Match(PlSqlParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4788) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4789) + p.Overriding_procedure_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverriding_function_specContext is an interface to support dynamic dispatch. +type IOverriding_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SELF() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + Body() IBodyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PIPELINED() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsOverriding_function_specContext differentiates from other interfaces. + IsOverriding_function_specContext() +} + +type Overriding_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverriding_function_specContext() *Overriding_function_specContext { + var p = new(Overriding_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_function_spec + return p +} + +func InitEmptyOverriding_function_specContext(p *Overriding_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_function_spec +} + +func (*Overriding_function_specContext) IsOverriding_function_specContext() {} + +func NewOverriding_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overriding_function_specContext { + var p = new(Overriding_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_overriding_function_spec + + return p +} + +func (s *Overriding_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overriding_function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Overriding_function_specContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Overriding_function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Overriding_function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Overriding_function_specContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Overriding_function_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Overriding_function_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Overriding_function_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Overriding_function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Overriding_function_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Overriding_function_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Overriding_function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Overriding_function_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Overriding_function_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Overriding_function_specContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Overriding_function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Overriding_function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Overriding_function_specContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Overriding_function_specContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Overriding_function_specContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Overriding_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overriding_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overriding_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOverriding_function_spec(s) + } +} + +func (s *Overriding_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOverriding_function_spec(s) + } +} + +func (p *PlSqlParser) Overriding_function_spec() (localctx IOverriding_function_specContext) { + localctx = NewOverriding_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, PlSqlParserRULE_overriding_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4792) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4793) + p.Function_name() + } + p.SetState(4805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4794) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4795) + p.Type_elements_parameter() + } + p.SetState(4800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4796) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4797) + p.Type_elements_parameter() + } + + p.SetState(4802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4803) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4807) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 341, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4808) + p.Type_spec() + } + + case 2: + { + p.SetState(4809) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4810) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4811) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS || _la == PlSqlParserPIPELINED { + p.SetState(4815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPIPELINED { + { + p.SetState(4814) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4817) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(4819) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 343, p.GetParserRuleContext()) == 1 { + { + p.SetState(4818) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4822) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) == 1 { + { + p.SetState(4821) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4824) + p.Body() + } + + } + p.SetState(4828) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 346, p.GetParserRuleContext()) == 1 { + { + p.SetState(4827) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverriding_procedure_specContext is an interface to support dynamic dispatch. +type IOverriding_procedure_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOverriding_procedure_specContext differentiates from other interfaces. + IsOverriding_procedure_specContext() +} + +type Overriding_procedure_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverriding_procedure_specContext() *Overriding_procedure_specContext { + var p = new(Overriding_procedure_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_procedure_spec + return p +} + +func InitEmptyOverriding_procedure_specContext(p *Overriding_procedure_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_procedure_spec +} + +func (*Overriding_procedure_specContext) IsOverriding_procedure_specContext() {} + +func NewOverriding_procedure_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overriding_procedure_specContext { + var p = new(Overriding_procedure_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_overriding_procedure_spec + + return p +} + +func (s *Overriding_procedure_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overriding_procedure_specContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Overriding_procedure_specContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Overriding_procedure_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Overriding_procedure_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Overriding_procedure_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Overriding_procedure_specContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Overriding_procedure_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Overriding_procedure_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Overriding_procedure_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Overriding_procedure_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Overriding_procedure_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Overriding_procedure_specContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Overriding_procedure_specContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Overriding_procedure_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Overriding_procedure_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Overriding_procedure_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overriding_procedure_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overriding_procedure_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOverriding_procedure_spec(s) + } +} + +func (s *Overriding_procedure_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOverriding_procedure_spec(s) + } +} + +func (p *PlSqlParser) Overriding_procedure_spec() (localctx IOverriding_procedure_specContext) { + localctx = NewOverriding_procedure_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, PlSqlParserRULE_overriding_procedure_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4830) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4831) + p.Procedure_name() + } + p.SetState(4843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4832) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4833) + p.Type_elements_parameter() + } + p.SetState(4838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4834) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4835) + p.Type_elements_parameter() + } + + p.SetState(4840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4841) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4845) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 351, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4846) + p.Call_spec() + } + + case 2: + p.SetState(4848) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 349, p.GetParserRuleContext()) == 1 { + { + p.SetState(4847) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4851) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 350, p.GetParserRuleContext()) == 1 { + { + p.SetState(4850) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4853) + p.Body() + } + { + p.SetState(4854) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_procedure_specContext is an interface to support dynamic dispatch. +type IType_procedure_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + Call_spec() ICall_specContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsType_procedure_specContext differentiates from other interfaces. + IsType_procedure_specContext() +} + +type Type_procedure_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_procedure_specContext() *Type_procedure_specContext { + var p = new(Type_procedure_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_procedure_spec + return p +} + +func InitEmptyType_procedure_specContext(p *Type_procedure_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_procedure_spec +} + +func (*Type_procedure_specContext) IsType_procedure_specContext() {} + +func NewType_procedure_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_procedure_specContext { + var p = new(Type_procedure_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_procedure_spec + + return p +} + +func (s *Type_procedure_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_procedure_specContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Type_procedure_specContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Type_procedure_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Type_procedure_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Type_procedure_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Type_procedure_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Type_procedure_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Type_procedure_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_procedure_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Type_procedure_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Type_procedure_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Type_procedure_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_procedure_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_procedure_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_procedure_spec(s) + } +} + +func (s *Type_procedure_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_procedure_spec(s) + } +} + +func (p *PlSqlParser) Type_procedure_spec() (localctx IType_procedure_specContext) { + localctx = NewType_procedure_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, PlSqlParserRULE_type_procedure_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4858) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Procedure_name() + } + p.SetState(4871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4860) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4861) + p.Type_elements_parameter() + } + p.SetState(4866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4862) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4863) + p.Type_elements_parameter() + } + + p.SetState(4868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4869) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS { + { + p.SetState(4873) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4874) + p.Call_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_function_specContext is an interface to support dynamic dispatch. +type IType_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SELF() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + IS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + VARIABLE() antlr.TerminalNode + + // IsType_function_specContext differentiates from other interfaces. + IsType_function_specContext() +} + +type Type_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_function_specContext() *Type_function_specContext { + var p = new(Type_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_function_spec + return p +} + +func InitEmptyType_function_specContext(p *Type_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_function_spec +} + +func (*Type_function_specContext) IsType_function_specContext() {} + +func NewType_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_function_specContext { + var p = new(Type_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_function_spec + + return p +} + +func (s *Type_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Type_function_specContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Type_function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Type_function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Type_function_specContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Type_function_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Type_function_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Type_function_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Type_function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Type_function_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Type_function_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Type_function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Type_function_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Type_function_specContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Type_function_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Type_function_specContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Type_function_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Type_function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Type_function_specContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *Type_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_function_spec(s) + } +} + +func (s *Type_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_function_spec(s) + } +} + +func (p *PlSqlParser) Type_function_spec() (localctx IType_function_specContext) { + localctx = NewType_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, PlSqlParserRULE_type_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4877) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4878) + p.Function_name() + } + p.SetState(4890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4879) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4880) + p.Type_elements_parameter() + } + p.SetState(4885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4881) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4882) + p.Type_elements_parameter() + } + + p.SetState(4887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4888) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4892) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 357, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4893) + p.Type_spec() + } + + case 2: + { + p.SetState(4894) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4895) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4896) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(4899) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4900) + p.Call_spec() + } + + case PlSqlParserEXTERNAL: + { + p.SetState(4901) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVARIABLE { + { + p.SetState(4902) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4905) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4906) + p.Expression() + } + + case PlSqlParserEOF, PlSqlParserCASCADE, PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE, PlSqlParserINVALIDATE, PlSqlParserMAP, PlSqlParserMEMBER, PlSqlParserORDER, PlSqlParserSTATIC, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstructor_specContext is an interface to support dynamic dispatch. +type IConstructor_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRUCTOR() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllType_spec() []IType_specContext + Type_spec(i int) IType_specContext + RETURN() antlr.TerminalNode + AllSELF() []antlr.TerminalNode + SELF(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + FINAL() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Call_spec() ICall_specContext + IS() antlr.TerminalNode + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + + // IsConstructor_specContext differentiates from other interfaces. + IsConstructor_specContext() +} + +type Constructor_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructor_specContext() *Constructor_specContext { + var p = new(Constructor_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_spec + return p +} + +func InitEmptyConstructor_specContext(p *Constructor_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_spec +} + +func (*Constructor_specContext) IsConstructor_specContext() {} + +func NewConstructor_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constructor_specContext { + var p = new(Constructor_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constructor_spec + + return p +} + +func (s *Constructor_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constructor_specContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Constructor_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Constructor_specContext) AllType_spec() []IType_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_specContext); ok { + len++ + } + } + + tst := make([]IType_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_specContext); ok { + tst[i] = t.(IType_specContext) + i++ + } + } + + return tst +} + +func (s *Constructor_specContext) Type_spec(i int) IType_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Constructor_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Constructor_specContext) AllSELF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSELF) +} + +func (s *Constructor_specContext) SELF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, i) +} + +func (s *Constructor_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Constructor_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Constructor_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Constructor_specContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Constructor_specContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Constructor_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constructor_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constructor_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Constructor_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Constructor_specContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Constructor_specContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Constructor_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constructor_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constructor_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Constructor_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Constructor_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constructor_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constructor_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstructor_spec(s) + } +} + +func (s *Constructor_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstructor_spec(s) + } +} + +func (p *PlSqlParser) Constructor_spec() (localctx IConstructor_specContext) { + localctx = NewConstructor_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, PlSqlParserRULE_constructor_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINAL { + { + p.SetState(4909) + p.Match(PlSqlParserFINAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINSTANTIABLE { + { + p.SetState(4912) + p.Match(PlSqlParserINSTANTIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4915) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4916) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4917) + p.Type_spec() + } + p.SetState(4938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4918) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4925) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 362, p.GetParserRuleContext()) == 1 { + { + p.SetState(4919) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4920) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4921) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4922) + p.Type_spec() + } + { + p.SetState(4923) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(4927) + p.Type_elements_parameter() + } + p.SetState(4932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4928) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4929) + p.Type_elements_parameter() + } + + p.SetState(4934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(4937) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4940) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4941) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4942) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4943) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS { + { + p.SetState(4944) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4945) + p.Call_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMap_order_function_specContext is an interface to support dynamic dispatch. +type IMap_order_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + Type_function_spec() IType_function_specContext + MAP() antlr.TerminalNode + ORDER() antlr.TerminalNode + + // IsMap_order_function_specContext differentiates from other interfaces. + IsMap_order_function_specContext() +} + +type Map_order_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMap_order_function_specContext() *Map_order_function_specContext { + var p = new(Map_order_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_function_spec + return p +} + +func InitEmptyMap_order_function_specContext(p *Map_order_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_function_spec +} + +func (*Map_order_function_specContext) IsMap_order_function_specContext() {} + +func NewMap_order_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_order_function_specContext { + var p = new(Map_order_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_map_order_function_spec + + return p +} + +func (s *Map_order_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Map_order_function_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Map_order_function_specContext) Type_function_spec() IType_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_specContext) +} + +func (s *Map_order_function_specContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Map_order_function_specContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Map_order_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Map_order_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Map_order_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMap_order_function_spec(s) + } +} + +func (s *Map_order_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMap_order_function_spec(s) + } +} + +func (p *PlSqlParser) Map_order_function_spec() (localctx IMap_order_function_specContext) { + localctx = NewMap_order_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, PlSqlParserRULE_map_order_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4948) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAP || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4949) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4950) + p.Type_function_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPragma_clauseContext is an interface to support dynamic dispatch. +type IPragma_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRAGMA() antlr.TerminalNode + RESTRICT_REFERENCES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPragma_elements() []IPragma_elementsContext + Pragma_elements(i int) IPragma_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPragma_clauseContext differentiates from other interfaces. + IsPragma_clauseContext() +} + +type Pragma_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPragma_clauseContext() *Pragma_clauseContext { + var p = new(Pragma_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_clause + return p +} + +func InitEmptyPragma_clauseContext(p *Pragma_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_clause +} + +func (*Pragma_clauseContext) IsPragma_clauseContext() {} + +func NewPragma_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_clauseContext { + var p = new(Pragma_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_clause + + return p +} + +func (s *Pragma_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_clauseContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Pragma_clauseContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Pragma_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pragma_clauseContext) AllPragma_elements() []IPragma_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPragma_elementsContext); ok { + len++ + } + } + + tst := make([]IPragma_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPragma_elementsContext); ok { + tst[i] = t.(IPragma_elementsContext) + i++ + } + } + + return tst +} + +func (s *Pragma_clauseContext) Pragma_elements(i int) IPragma_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPragma_elementsContext) +} + +func (s *Pragma_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pragma_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pragma_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pragma_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_clause(s) + } +} + +func (s *Pragma_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_clause(s) + } +} + +func (p *PlSqlParser) Pragma_clause() (localctx IPragma_clauseContext) { + localctx = NewPragma_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, PlSqlParserRULE_pragma_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4952) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4953) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4954) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4955) + p.Pragma_elements() + } + p.SetState(4960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4956) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4957) + p.Pragma_elements() + } + + p.SetState(4962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4963) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPragma_elementsContext is an interface to support dynamic dispatch. +type IPragma_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + DEFAULT() antlr.TerminalNode + + // IsPragma_elementsContext differentiates from other interfaces. + IsPragma_elementsContext() +} + +type Pragma_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPragma_elementsContext() *Pragma_elementsContext { + var p = new(Pragma_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_elements + return p +} + +func InitEmptyPragma_elementsContext(p *Pragma_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_elements +} + +func (*Pragma_elementsContext) IsPragma_elementsContext() {} + +func NewPragma_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_elementsContext { + var p = new(Pragma_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_elements + + return p +} + +func (s *Pragma_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_elementsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Pragma_elementsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Pragma_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_elements(s) + } +} + +func (s *Pragma_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_elements(s) + } +} + +func (p *PlSqlParser) Pragma_elements() (localctx IPragma_elementsContext) { + localctx = NewPragma_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, PlSqlParserRULE_pragma_elements) + p.SetState(4967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4965) + p.Identifier() + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4966) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_elements_parameterContext is an interface to support dynamic dispatch. +type IType_elements_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + NOCOPY() antlr.TerminalNode + ASSIGN_OP() antlr.TerminalNode + Constant() IConstantContext + + // IsType_elements_parameterContext differentiates from other interfaces. + IsType_elements_parameterContext() +} + +type Type_elements_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_elements_parameterContext() *Type_elements_parameterContext { + var p = new(Type_elements_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_elements_parameter + return p +} + +func InitEmptyType_elements_parameterContext(p *Type_elements_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_elements_parameter +} + +func (*Type_elements_parameterContext) IsType_elements_parameterContext() {} + +func NewType_elements_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_elements_parameterContext { + var p = new(Type_elements_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_elements_parameter + + return p +} + +func (s *Type_elements_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_elements_parameterContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Type_elements_parameterContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Type_elements_parameterContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Type_elements_parameterContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Type_elements_parameterContext) NOCOPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOPY, 0) +} + +func (s *Type_elements_parameterContext) ASSIGN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN_OP, 0) +} + +func (s *Type_elements_parameterContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Type_elements_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_elements_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_elements_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_elements_parameter(s) + } +} + +func (s *Type_elements_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_elements_parameter(s) + } +} + +func (p *PlSqlParser) Type_elements_parameter() (localctx IType_elements_parameterContext) { + localctx = NewType_elements_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, PlSqlParserRULE_type_elements_parameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4969) + p.Parameter_name() + } + p.SetState(4979) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) == 1 { + { + p.SetState(4970) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4971) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4972) + p.Match(PlSqlParserNOCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) == 2 { + { + p.SetState(4973) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4974) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) == 3 { + { + p.SetState(4975) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4976) + p.Match(PlSqlParserNOCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) == 4 { + { + p.SetState(4977) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 369, p.GetParserRuleContext()) == 5 { + { + p.SetState(4978) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4981) + p.Type_spec() + } + p.SetState(4984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASSIGN_OP { + { + p.SetState(4982) + p.Match(PlSqlParserASSIGN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4983) + p.Constant() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_sequenceContext is an interface to support dynamic dispatch. +type IDrop_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Sequence_name() ISequence_nameContext + + // IsDrop_sequenceContext differentiates from other interfaces. + IsDrop_sequenceContext() +} + +type Drop_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_sequenceContext() *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_sequence + return p +} + +func InitEmptyDrop_sequenceContext(p *Drop_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_sequence +} + +func (*Drop_sequenceContext) IsDrop_sequenceContext() {} + +func NewDrop_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_sequence + + return p +} + +func (s *Drop_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_sequenceContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Drop_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Drop_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_sequence(s) + } +} + +func (p *PlSqlParser) Drop_sequence() (localctx IDrop_sequenceContext) { + localctx = NewDrop_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, PlSqlParserRULE_drop_sequence) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4986) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4987) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4988) + p.Sequence_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_sequenceContext is an interface to support dynamic dispatch. +type IAlter_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Sequence_name() ISequence_nameContext + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + + // IsAlter_sequenceContext differentiates from other interfaces. + IsAlter_sequenceContext() +} + +type Alter_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_sequenceContext() *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_sequence + return p +} + +func InitEmptyAlter_sequenceContext(p *Alter_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_sequence +} + +func (*Alter_sequenceContext) IsAlter_sequenceContext() {} + +func NewAlter_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_sequence + + return p +} + +func (s *Alter_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sequenceContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Alter_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Alter_sequenceContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Alter_sequenceContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +func (s *Alter_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_sequence(s) + } +} + +func (p *PlSqlParser) Alter_sequence() (localctx IAlter_sequenceContext) { + localctx = NewAlter_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, PlSqlParserRULE_alter_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4990) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4991) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4992) + p.Sequence_name() + } + p.SetState(4994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserGLOBAL || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || ((int64((_la-1140)) & ^0x3f) == 0 && ((int64(1)<<(_la-1140))&142936511610881) != 0) || _la == PlSqlParserORDER || ((int64((_la-1620)) & ^0x3f) == 0 && ((int64(1)<<(_la-1620))&72198331526283265) != 0) || _la == PlSqlParserSTART { + { + p.SetState(4993) + p.Sequence_spec() + } + + p.SetState(4996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_sessionContext is an interface to support dynamic dispatch. +type IAlter_sessionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SESSION() antlr.TerminalNode + ADVISE() antlr.TerminalNode + CLOSE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Parameter_name() IParameter_nameContext + Enable_or_disable() IEnable_or_disableContext + COMMIT() antlr.TerminalNode + IN() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + GUARD() antlr.TerminalNode + AllPARALLEL() []antlr.TerminalNode + PARALLEL(i int) antlr.TerminalNode + SET() antlr.TerminalNode + Alter_session_set_clause() IAlter_session_set_clauseContext + ROLLBACK() antlr.TerminalNode + NOTHING() antlr.TerminalNode + DML() antlr.TerminalNode + DDL() antlr.TerminalNode + QUERY() antlr.TerminalNode + FORCE() antlr.TerminalNode + Literal() ILiteralContext + + // IsAlter_sessionContext differentiates from other interfaces. + IsAlter_sessionContext() +} + +type Alter_sessionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_sessionContext() *Alter_sessionContext { + var p = new(Alter_sessionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session + return p +} + +func InitEmptyAlter_sessionContext(p *Alter_sessionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session +} + +func (*Alter_sessionContext) IsAlter_sessionContext() {} + +func NewAlter_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sessionContext { + var p = new(Alter_sessionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_session + + return p +} + +func (s *Alter_sessionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sessionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_sessionContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Alter_sessionContext) ADVISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISE, 0) +} + +func (s *Alter_sessionContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Alter_sessionContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Alter_sessionContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Alter_sessionContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Alter_sessionContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_sessionContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Alter_sessionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Alter_sessionContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Alter_sessionContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Alter_sessionContext) AllPARALLEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARALLEL) +} + +func (s *Alter_sessionContext) PARALLEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, i) +} + +func (s *Alter_sessionContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_sessionContext) Alter_session_set_clause() IAlter_session_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_session_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_session_set_clauseContext) +} + +func (s *Alter_sessionContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Alter_sessionContext) NOTHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTHING, 0) +} + +func (s *Alter_sessionContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Alter_sessionContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Alter_sessionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Alter_sessionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_sessionContext) Literal() ILiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Alter_sessionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_sessionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_sessionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_session(s) + } +} + +func (s *Alter_sessionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_session(s) + } +} + +func (p *PlSqlParser) Alter_session() (localctx IAlter_sessionContext) { + localctx = NewAlter_sessionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, PlSqlParserRULE_alter_session) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4998) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4999) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 375, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5000) + p.Match(PlSqlParserADVISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5001) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserNOTHING || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(5002) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5003) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5004) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5005) + p.Parameter_name() + } + + case 3: + { + p.SetState(5006) + p.Enable_or_disable() + } + { + p.SetState(5007) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5008) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5009) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5011) + p.Enable_or_disable() + } + { + p.SetState(5012) + p.Match(PlSqlParserGUARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(5016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(5014) + p.Enable_or_disable() + } + + case PlSqlParserFORCE: + { + p.SetState(5015) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5018) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5019) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDDL || _la == PlSqlParserDML || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARALLEL { + { + p.SetState(5020) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5021) + p.Literal() + } + + case 2: + { + p.SetState(5022) + p.Parameter_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case 6: + { + p.SetState(5027) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5028) + p.Alter_session_set_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_session_set_clauseContext is an interface to support dynamic dispatch. +type IAlter_session_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEn returns the en rule contexts. + GetEn() IId_expressionContext + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetEn sets the en rule contexts. + SetEn(IId_expressionContext) + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + AllParameter_name() []IParameter_nameContext + Parameter_name(i int) IParameter_nameContext + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllParameter_value() []IParameter_valueContext + Parameter_value(i int) IParameter_valueContext + EDITION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + CONTAINER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + ROW() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ALL() antlr.TerminalNode + DEFAULT_COLLATION() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsAlter_session_set_clauseContext differentiates from other interfaces. + IsAlter_session_set_clauseContext() +} + +type Alter_session_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + en IId_expressionContext + cn IId_expressionContext + sn IId_expressionContext + c IId_expressionContext +} + +func NewEmptyAlter_session_set_clauseContext() *Alter_session_set_clauseContext { + var p = new(Alter_session_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause + return p +} + +func InitEmptyAlter_session_set_clauseContext(p *Alter_session_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause +} + +func (*Alter_session_set_clauseContext) IsAlter_session_set_clauseContext() {} + +func NewAlter_session_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_session_set_clauseContext { + var p = new(Alter_session_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause + + return p +} + +func (s *Alter_session_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_session_set_clauseContext) GetEn() IId_expressionContext { return s.en } + +func (s *Alter_session_set_clauseContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Alter_session_set_clauseContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Alter_session_set_clauseContext) GetC() IId_expressionContext { return s.c } + +func (s *Alter_session_set_clauseContext) SetEn(v IId_expressionContext) { s.en = v } + +func (s *Alter_session_set_clauseContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Alter_session_set_clauseContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Alter_session_set_clauseContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Alter_session_set_clauseContext) AllParameter_name() []IParameter_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_nameContext); ok { + len++ + } + } + + tst := make([]IParameter_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_nameContext); ok { + tst[i] = t.(IParameter_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Parameter_name(i int) IParameter_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Alter_session_set_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Alter_session_set_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Alter_session_set_clauseContext) AllParameter_value() []IParameter_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_valueContext); ok { + len++ + } + } + + tst := make([]IParameter_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_valueContext); ok { + tst[i] = t.(IParameter_valueContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Parameter_value(i int) IParameter_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_valueContext) +} + +func (s *Alter_session_set_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Alter_session_set_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_session_set_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Alter_session_set_clauseContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Alter_session_set_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Alter_session_set_clauseContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Alter_session_set_clauseContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBILITY, 0) +} + +func (s *Alter_session_set_clauseContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE, 0) +} + +func (s *Alter_session_set_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_session_set_clauseContext) DEFAULT_COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_COLLATION, 0) +} + +func (s *Alter_session_set_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Alter_session_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_session_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_session_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_session_set_clause(s) + } +} + +func (s *Alter_session_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_session_set_clause(s) + } +} + +func (p *PlSqlParser) Alter_session_set_clause() (localctx IAlter_session_set_clauseContext) { + localctx = NewAlter_session_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, PlSqlParserRULE_alter_session_set_clause) + var _la int + + p.SetState(5061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 379, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(5031) + p.Parameter_name() + } + { + p.SetState(5032) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5033) + p.Parameter_value() + } + + p.SetState(5037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5039) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5040) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5041) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).en = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5042) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5043) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5044) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).cn = _x + } + p.SetState(5048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSERVICE { + { + p.SetState(5045) + p.Match(PlSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5046) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5047) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).sn = _x + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5050) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5051) + p.Match(PlSqlParserARCHIVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5052) + p.Match(PlSqlParserVISIBILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5053) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5054) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACTIVE || _la == PlSqlParserALL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5055) + p.Match(PlSqlParserDEFAULT_COLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5056) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 378, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5057) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).c = _x + } + + case 2: + { + p.SetState(5058) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_sequenceContext is an interface to support dynamic dispatch. +type ICreate_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Sequence_name() ISequence_nameContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + METADATA() antlr.TerminalNode + DATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_sequenceContext differentiates from other interfaces. + IsCreate_sequenceContext() +} + +type Create_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_sequenceContext() *Create_sequenceContext { + var p = new(Create_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_sequence + return p +} + +func InitEmptyCreate_sequenceContext(p *Create_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_sequence +} + +func (*Create_sequenceContext) IsCreate_sequenceContext() {} + +func NewCreate_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_sequenceContext { + var p = new(Create_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_sequence + + return p +} + +func (s *Create_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_sequenceContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Create_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Create_sequenceContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_sequenceContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_sequenceContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_sequenceContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Create_sequenceContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +func (s *Create_sequenceContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_sequenceContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_sequenceContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_sequenceContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_sequenceContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_sequence(s) + } +} + +func (p *PlSqlParser) Create_sequence() (localctx ICreate_sequenceContext) { + localctx = NewCreate_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, PlSqlParserRULE_create_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5063) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5064) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5068) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 380, p.GetParserRuleContext()) == 1 { + { + p.SetState(5065) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5066) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5067) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5070) + p.Sequence_name() + } + p.SetState(5074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserGLOBAL || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || ((int64((_la-1140)) & ^0x3f) == 0 && ((int64(1)<<(_la-1140))&142936511610881) != 0) || _la == PlSqlParserORDER || ((int64((_la-1620)) & ^0x3f) == 0 && ((int64(1)<<(_la-1620))&72198331526283265) != 0) || _la == PlSqlParserSTART { + { + p.SetState(5071) + p.Sequence_spec() + } + + p.SetState(5076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(5077) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5078) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5079) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATA || _la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISequence_specContext is an interface to support dynamic dispatch. +type ISequence_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Sequence_start_clause() ISequence_start_clauseContext + MAXVALUE() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + ORDER() antlr.TerminalNode + NOORDER() antlr.TerminalNode + KEEP() antlr.TerminalNode + NOKEEP() antlr.TerminalNode + SCALE() antlr.TerminalNode + EXTEND() antlr.TerminalNode + NOEXTEND() antlr.TerminalNode + NOSCALE() antlr.TerminalNode + SHARD() antlr.TerminalNode + NOSHARD() antlr.TerminalNode + SESSION() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + + // IsSequence_specContext differentiates from other interfaces. + IsSequence_specContext() +} + +type Sequence_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_specContext() *Sequence_specContext { + var p = new(Sequence_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_spec + return p +} + +func InitEmptySequence_specContext(p *Sequence_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_spec +} + +func (*Sequence_specContext) IsSequence_specContext() {} + +func NewSequence_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_specContext { + var p = new(Sequence_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_spec + + return p +} + +func (s *Sequence_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_specContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Sequence_specContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Sequence_specContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Sequence_specContext) Sequence_start_clause() ISequence_start_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_start_clauseContext) +} + +func (s *Sequence_specContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Sequence_specContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Sequence_specContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Sequence_specContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Sequence_specContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Sequence_specContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Sequence_specContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Sequence_specContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Sequence_specContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Sequence_specContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Sequence_specContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Sequence_specContext) NOKEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOKEEP, 0) +} + +func (s *Sequence_specContext) SCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, 0) +} + +func (s *Sequence_specContext) EXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTEND, 0) +} + +func (s *Sequence_specContext) NOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOEXTEND, 0) +} + +func (s *Sequence_specContext) NOSCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCALE, 0) +} + +func (s *Sequence_specContext) SHARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARD, 0) +} + +func (s *Sequence_specContext) NOSHARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSHARD, 0) +} + +func (s *Sequence_specContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Sequence_specContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Sequence_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_spec(s) + } +} + +func (s *Sequence_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_spec(s) + } +} + +func (p *PlSqlParser) Sequence_spec() (localctx ISequence_specContext) { + localctx = NewSequence_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, PlSqlParserRULE_sequence_spec) + var _la int + + p.SetState(5113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINCREMENT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5082) + p.Match(PlSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5083) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5084) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTART: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5085) + p.Sequence_start_clause() + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5086) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5087) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMAXVALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5088) + p.Match(PlSqlParserNOMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5089) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5090) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMINVALUE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5091) + p.Match(PlSqlParserNOMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCYCLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5092) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCYCLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5093) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5094) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5095) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCACHE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5096) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORDER: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5097) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOORDER: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5098) + p.Match(PlSqlParserNOORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserKEEP: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5099) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOKEEP: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5100) + p.Match(PlSqlParserNOKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSCALE: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5101) + p.Match(PlSqlParserSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOEXTEND || _la == PlSqlParserEXTEND { + { + p.SetState(5102) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOEXTEND || _la == PlSqlParserEXTEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserNOSCALE: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5105) + p.Match(PlSqlParserNOSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSHARD: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(5106) + p.Match(PlSqlParserSHARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOEXTEND || _la == PlSqlParserEXTEND { + { + p.SetState(5107) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOEXTEND || _la == PlSqlParserEXTEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserNOSHARD: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(5110) + p.Match(PlSqlParserNOSHARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSESSION: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(5111) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGLOBAL: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(5112) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISequence_start_clauseContext is an interface to support dynamic dispatch. +type ISequence_start_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + APPROXIMATE_NUM_LIT() antlr.TerminalNode + + // IsSequence_start_clauseContext differentiates from other interfaces. + IsSequence_start_clauseContext() +} + +type Sequence_start_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_start_clauseContext() *Sequence_start_clauseContext { + var p = new(Sequence_start_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_start_clause + return p +} + +func InitEmptySequence_start_clauseContext(p *Sequence_start_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_start_clause +} + +func (*Sequence_start_clauseContext) IsSequence_start_clauseContext() {} + +func NewSequence_start_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_start_clauseContext { + var p = new(Sequence_start_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_start_clause + + return p +} + +func (s *Sequence_start_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_start_clauseContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Sequence_start_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Sequence_start_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Sequence_start_clauseContext) APPROXIMATE_NUM_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPROXIMATE_NUM_LIT, 0) +} + +func (s *Sequence_start_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_start_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_start_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_start_clause(s) + } +} + +func (s *Sequence_start_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_start_clause(s) + } +} + +func (p *PlSqlParser) Sequence_start_clause() (localctx ISequence_start_clauseContext) { + localctx = NewSequence_start_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, PlSqlParserRULE_sequence_start_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5115) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5116) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5117) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_analytic_viewContext is an interface to support dynamic dispatch. +type ICreate_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Cav_using_clause() ICav_using_clauseContext + Dim_by_clause() IDim_by_clauseContext + Measures_clause() IMeasures_clauseContext + Default_measure_clause() IDefault_measure_clauseContext + Default_aggregate_clause() IDefault_aggregate_clauseContext + Cache_clause() ICache_clauseContext + Fact_columns_clause() IFact_columns_clauseContext + Qry_transform_clause() IQry_transform_clauseContext + NOFORCE() antlr.TerminalNode + FORCE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_analytic_viewContext differentiates from other interfaces. + IsCreate_analytic_viewContext() +} + +type Create_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyCreate_analytic_viewContext() *Create_analytic_viewContext { + var p = new(Create_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_analytic_view + return p +} + +func InitEmptyCreate_analytic_viewContext(p *Create_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_analytic_view +} + +func (*Create_analytic_viewContext) IsCreate_analytic_viewContext() {} + +func NewCreate_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_analytic_viewContext { + var p = new(Create_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_analytic_view + + return p +} + +func (s *Create_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Create_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Create_analytic_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Create_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_analytic_viewContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_analytic_viewContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_analytic_viewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_analytic_viewContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_analytic_viewContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_analytic_viewContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_analytic_viewContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_analytic_viewContext) Cav_using_clause() ICav_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICav_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICav_using_clauseContext) +} + +func (s *Create_analytic_viewContext) Dim_by_clause() IDim_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDim_by_clauseContext) +} + +func (s *Create_analytic_viewContext) Measures_clause() IMeasures_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasures_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasures_clauseContext) +} + +func (s *Create_analytic_viewContext) Default_measure_clause() IDefault_measure_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_measure_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_measure_clauseContext) +} + +func (s *Create_analytic_viewContext) Default_aggregate_clause() IDefault_aggregate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_aggregate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_aggregate_clauseContext) +} + +func (s *Create_analytic_viewContext) Cache_clause() ICache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_clauseContext) +} + +func (s *Create_analytic_viewContext) Fact_columns_clause() IFact_columns_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFact_columns_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFact_columns_clauseContext) +} + +func (s *Create_analytic_viewContext) Qry_transform_clause() IQry_transform_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQry_transform_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQry_transform_clauseContext) +} + +func (s *Create_analytic_viewContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_analytic_viewContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_analytic_viewContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_analytic_viewContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_analytic_view(s) + } +} + +func (s *Create_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_analytic_view(s) + } +} + +func (p *PlSqlParser) Create_analytic_view() (localctx ICreate_analytic_viewContext) { + localctx = NewCreate_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, PlSqlParserRULE_create_analytic_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5119) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(5120) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5121) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(5124) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5127) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5128) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5129) + + var _x = p.Id_expression() + + localctx.(*Create_analytic_viewContext).av = _x + } + p.SetState(5133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(5130) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5131) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5132) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5135) + p.Classification_clause() + } + + p.SetState(5140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(5141) + p.Cav_using_clause() + } + + } + p.SetState(5145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDIMENSION { + { + p.SetState(5144) + p.Dim_by_clause() + } + + } + p.SetState(5148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEASURES { + { + p.SetState(5147) + p.Measures_clause() + } + + } + p.SetState(5151) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 393, p.GetParserRuleContext()) == 1 { + { + p.SetState(5150) + p.Default_measure_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(5153) + p.Default_aggregate_clause() + } + + } + p.SetState(5157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE { + { + p.SetState(5156) + p.Cache_clause() + } + + } + p.SetState(5160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFACT { + { + p.SetState(5159) + p.Fact_columns_clause() + } + + } + p.SetState(5163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENABLE { + { + p.SetState(5162) + p.Qry_transform_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClassification_clauseContext is an interface to support dynamic dispatch. +type IClassification_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Caption_clause() ICaption_clauseContext + Description_clause() IDescription_clauseContext + AllClassification_item() []IClassification_itemContext + Classification_item(i int) IClassification_itemContext + + // IsClassification_clauseContext differentiates from other interfaces. + IsClassification_clauseContext() +} + +type Classification_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassification_clauseContext() *Classification_clauseContext { + var p = new(Classification_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_clause + return p +} + +func InitEmptyClassification_clauseContext(p *Classification_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_clause +} + +func (*Classification_clauseContext) IsClassification_clauseContext() {} + +func NewClassification_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Classification_clauseContext { + var p = new(Classification_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_classification_clause + + return p +} + +func (s *Classification_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Classification_clauseContext) Caption_clause() ICaption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICaption_clauseContext) +} + +func (s *Classification_clauseContext) Description_clause() IDescription_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescription_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescription_clauseContext) +} + +func (s *Classification_clauseContext) AllClassification_item() []IClassification_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_itemContext); ok { + len++ + } + } + + tst := make([]IClassification_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_itemContext); ok { + tst[i] = t.(IClassification_itemContext) + i++ + } + } + + return tst +} + +func (s *Classification_clauseContext) Classification_item(i int) IClassification_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_itemContext) +} + +func (s *Classification_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Classification_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Classification_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClassification_clause(s) + } +} + +func (s *Classification_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClassification_clause(s) + } +} + +func (p *PlSqlParser) Classification_clause() (localctx IClassification_clauseContext) { + localctx = NewClassification_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, PlSqlParserRULE_classification_clause) + var _la int + + var _alt int + + p.SetState(5192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 400, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5165) + p.Caption_clause() + } + p.SetState(5167) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 { + { + p.SetState(5166) + p.Description_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(5170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCAPTION { + { + p.SetState(5169) + p.Caption_clause() + } + + } + { + p.SetState(5172) + p.Description_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 401, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5175) + p.Classification_item() + } + + } + p.SetState(5180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 401, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCAPTION { + { + p.SetState(5181) + p.Caption_clause() + } + + } + p.SetState(5185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESCRIPTION { + { + p.SetState(5184) + p.Description_clause() + } + + } + p.SetState(5188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(5187) + p.Classification_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5190) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 404, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICaption_clauseContext is an interface to support dynamic dispatch. +type ICaption_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetC returns the c rule contexts. + GetC() IQuoted_stringContext + + // SetC sets the c rule contexts. + SetC(IQuoted_stringContext) + + // Getter signatures + CAPTION() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsCaption_clauseContext differentiates from other interfaces. + IsCaption_clauseContext() +} + +type Caption_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + c IQuoted_stringContext +} + +func NewEmptyCaption_clauseContext() *Caption_clauseContext { + var p = new(Caption_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_caption_clause + return p +} + +func InitEmptyCaption_clauseContext(p *Caption_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_caption_clause +} + +func (*Caption_clauseContext) IsCaption_clauseContext() {} + +func NewCaption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Caption_clauseContext { + var p = new(Caption_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_caption_clause + + return p +} + +func (s *Caption_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Caption_clauseContext) GetC() IQuoted_stringContext { return s.c } + +func (s *Caption_clauseContext) SetC(v IQuoted_stringContext) { s.c = v } + +func (s *Caption_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Caption_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Caption_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Caption_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Caption_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCaption_clause(s) + } +} + +func (s *Caption_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCaption_clause(s) + } +} + +func (p *PlSqlParser) Caption_clause() (localctx ICaption_clauseContext) { + localctx = NewCaption_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, PlSqlParserRULE_caption_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5194) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5195) + + var _x = p.Quoted_string() + + localctx.(*Caption_clauseContext).c = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescription_clauseContext is an interface to support dynamic dispatch. +type IDescription_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IQuoted_stringContext + + // SetD sets the d rule contexts. + SetD(IQuoted_stringContext) + + // Getter signatures + DESCRIPTION() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsDescription_clauseContext differentiates from other interfaces. + IsDescription_clauseContext() +} + +type Description_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IQuoted_stringContext +} + +func NewEmptyDescription_clauseContext() *Description_clauseContext { + var p = new(Description_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_description_clause + return p +} + +func InitEmptyDescription_clauseContext(p *Description_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_description_clause +} + +func (*Description_clauseContext) IsDescription_clauseContext() {} + +func NewDescription_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Description_clauseContext { + var p = new(Description_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_description_clause + + return p +} + +func (s *Description_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Description_clauseContext) GetD() IQuoted_stringContext { return s.d } + +func (s *Description_clauseContext) SetD(v IQuoted_stringContext) { s.d = v } + +func (s *Description_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Description_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Description_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Description_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Description_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDescription_clause(s) + } +} + +func (s *Description_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDescription_clause(s) + } +} + +func (p *PlSqlParser) Description_clause() (localctx IDescription_clauseContext) { + localctx = NewDescription_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, PlSqlParserRULE_description_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5197) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5198) + + var _x = p.Quoted_string() + + localctx.(*Description_clauseContext).d = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClassification_itemContext is an interface to support dynamic dispatch. +type IClassification_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // GetCv returns the cv rule contexts. + GetCv() IQuoted_stringContext + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // SetCv sets the cv rule contexts. + SetCv(IQuoted_stringContext) + + // Getter signatures + CLASSIFICATION() antlr.TerminalNode + Id_expression() IId_expressionContext + VALUE() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + Language() ILanguageContext + Quoted_string() IQuoted_stringContext + + // IsClassification_itemContext differentiates from other interfaces. + IsClassification_itemContext() +} + +type Classification_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cn IId_expressionContext + cv IQuoted_stringContext +} + +func NewEmptyClassification_itemContext() *Classification_itemContext { + var p = new(Classification_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_item + return p +} + +func InitEmptyClassification_itemContext(p *Classification_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_item +} + +func (*Classification_itemContext) IsClassification_itemContext() {} + +func NewClassification_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Classification_itemContext { + var p = new(Classification_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_classification_item + + return p +} + +func (s *Classification_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Classification_itemContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Classification_itemContext) GetCv() IQuoted_stringContext { return s.cv } + +func (s *Classification_itemContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Classification_itemContext) SetCv(v IQuoted_stringContext) { s.cv = v } + +func (s *Classification_itemContext) CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFICATION, 0) +} + +func (s *Classification_itemContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Classification_itemContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Classification_itemContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Classification_itemContext) Language() ILanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguageContext) +} + +func (s *Classification_itemContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Classification_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Classification_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Classification_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClassification_item(s) + } +} + +func (s *Classification_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClassification_item(s) + } +} + +func (p *PlSqlParser) Classification_item() (localctx IClassification_itemContext) { + localctx = NewClassification_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, PlSqlParserRULE_classification_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5200) + p.Match(PlSqlParserCLASSIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5201) + + var _x = p.Id_expression() + + localctx.(*Classification_itemContext).cn = _x + } + p.SetState(5204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUE { + { + p.SetState(5202) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5203) + + var _x = p.Quoted_string() + + localctx.(*Classification_itemContext).cv = _x + } + + } + p.SetState(5208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLANGUAGE { + { + p.SetState(5206) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5207) + p.Language() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILanguageContext is an interface to support dynamic dispatch. +type ILanguageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNls returns the nls rule contexts. + GetNls() IId_expressionContext + + // SetNls sets the nls rule contexts. + SetNls(IId_expressionContext) + + // Getter signatures + NULL_() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsLanguageContext differentiates from other interfaces. + IsLanguageContext() +} + +type LanguageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nls IId_expressionContext +} + +func NewEmptyLanguageContext() *LanguageContext { + var p = new(LanguageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_language + return p +} + +func InitEmptyLanguageContext(p *LanguageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_language +} + +func (*LanguageContext) IsLanguageContext() {} + +func NewLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageContext { + var p = new(LanguageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_language + + return p +} + +func (s *LanguageContext) GetParser() antlr.Parser { return s.parser } + +func (s *LanguageContext) GetNls() IId_expressionContext { return s.nls } + +func (s *LanguageContext) SetNls(v IId_expressionContext) { s.nls = v } + +func (s *LanguageContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *LanguageContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *LanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLanguage(s) + } +} + +func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLanguage(s) + } +} + +func (p *PlSqlParser) Language() (localctx ILanguageContext) { + localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, PlSqlParserRULE_language) + p.SetState(5212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5210) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5211) + + var _x = p.Id_expression() + + localctx.(*LanguageContext).nls = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICav_using_clauseContext is an interface to support dynamic dispatch. +type ICav_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetTa returns the ta rule contexts. + GetTa() IId_expressionContext + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetTa sets the ta rule contexts. + SetTa(IId_expressionContext) + + // Getter signatures + USING() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + REMOTE() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsCav_using_clauseContext differentiates from other interfaces. + IsCav_using_clauseContext() +} + +type Cav_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t IId_expressionContext + ta IId_expressionContext +} + +func NewEmptyCav_using_clauseContext() *Cav_using_clauseContext { + var p = new(Cav_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cav_using_clause + return p +} + +func InitEmptyCav_using_clauseContext(p *Cav_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cav_using_clause +} + +func (*Cav_using_clauseContext) IsCav_using_clauseContext() {} + +func NewCav_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cav_using_clauseContext { + var p = new(Cav_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cav_using_clause + + return p +} + +func (s *Cav_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cav_using_clauseContext) GetT() IId_expressionContext { return s.t } + +func (s *Cav_using_clauseContext) GetTa() IId_expressionContext { return s.ta } + +func (s *Cav_using_clauseContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Cav_using_clauseContext) SetTa(v IId_expressionContext) { s.ta = v } + +func (s *Cav_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Cav_using_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cav_using_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cav_using_clauseContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Cav_using_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Cav_using_clauseContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Cav_using_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Cav_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cav_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cav_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCav_using_clause(s) + } +} + +func (s *Cav_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCav_using_clause(s) + } +} + +func (p *PlSqlParser) Cav_using_clause() (localctx ICav_using_clauseContext) { + localctx = NewCav_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, PlSqlParserRULE_cav_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5214) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5218) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 409, p.GetParserRuleContext()) == 1 { + { + p.SetState(5215) + p.Schema_name() + } + { + p.SetState(5216) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5220) + + var _x = p.Id_expression() + + localctx.(*Cav_using_clauseContext).t = _x + } + p.SetState(5222) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 410, p.GetParserRuleContext()) == 1 { + { + p.SetState(5221) + p.Match(PlSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5228) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 1 { + p.SetState(5225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5224) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5227) + + var _x = p.Id_expression() + + localctx.(*Cav_using_clauseContext).ta = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_by_clauseContext is an interface to support dynamic dispatch. +type IDim_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIMENSION() antlr.TerminalNode + BY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllDim_key() []IDim_keyContext + Dim_key(i int) IDim_keyContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDim_by_clauseContext differentiates from other interfaces. + IsDim_by_clauseContext() +} + +type Dim_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDim_by_clauseContext() *Dim_by_clauseContext { + var p = new(Dim_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_by_clause + return p +} + +func InitEmptyDim_by_clauseContext(p *Dim_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_by_clause +} + +func (*Dim_by_clauseContext) IsDim_by_clauseContext() {} + +func NewDim_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_by_clauseContext { + var p = new(Dim_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_by_clause + + return p +} + +func (s *Dim_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_by_clauseContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Dim_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Dim_by_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Dim_by_clauseContext) AllDim_key() []IDim_keyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDim_keyContext); ok { + len++ + } + } + + tst := make([]IDim_keyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDim_keyContext); ok { + tst[i] = t.(IDim_keyContext) + i++ + } + } + + return tst +} + +func (s *Dim_by_clauseContext) Dim_key(i int) IDim_keyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_keyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDim_keyContext) +} + +func (s *Dim_by_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Dim_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Dim_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Dim_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_by_clause(s) + } +} + +func (s *Dim_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_by_clause(s) + } +} + +func (p *PlSqlParser) Dim_by_clause() (localctx IDim_by_clauseContext) { + localctx = NewDim_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, PlSqlParserRULE_dim_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5230) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5231) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5232) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5233) + p.Dim_key() + } + p.SetState(5238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5234) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5235) + p.Dim_key() + } + + p.SetState(5240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5241) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_keyContext is an interface to support dynamic dispatch. +type IDim_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetF returns the f rule contexts. + GetF() IColumn_nameContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetF sets the f rule contexts. + SetF(IColumn_nameContext) + + // Getter signatures + Dim_ref() IDim_refContext + KEY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + HIERARCHIES() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllHier_ref() []IHier_refContext + Hier_ref(i int) IHier_refContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllAttribute_name() []IAttribute_nameContext + Attribute_name(i int) IAttribute_nameContext + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + DISTINCT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsDim_keyContext differentiates from other interfaces. + IsDim_keyContext() +} + +type Dim_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + f IColumn_nameContext +} + +func NewEmptyDim_keyContext() *Dim_keyContext { + var p = new(Dim_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_key + return p +} + +func InitEmptyDim_keyContext(p *Dim_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_key +} + +func (*Dim_keyContext) IsDim_keyContext() {} + +func NewDim_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_keyContext { + var p = new(Dim_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_key + + return p +} + +func (s *Dim_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_keyContext) GetA() IId_expressionContext { return s.a } + +func (s *Dim_keyContext) GetF() IColumn_nameContext { return s.f } + +func (s *Dim_keyContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Dim_keyContext) SetF(v IColumn_nameContext) { s.f = v } + +func (s *Dim_keyContext) Dim_ref() IDim_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDim_refContext) +} + +func (s *Dim_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Dim_keyContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Dim_keyContext) HIERARCHIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHIES, 0) +} + +func (s *Dim_keyContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Dim_keyContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Dim_keyContext) AllHier_ref() []IHier_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHier_refContext); ok { + len++ + } + } + + tst := make([]IHier_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHier_refContext); ok { + tst[i] = t.(IHier_refContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Hier_ref(i int) IHier_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHier_refContext) +} + +func (s *Dim_keyContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Dim_keyContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Dim_keyContext) AllAttribute_name() []IAttribute_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_nameContext); ok { + len++ + } + } + + tst := make([]IAttribute_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_nameContext); ok { + tst[i] = t.(IAttribute_nameContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Attribute_name(i int) IAttribute_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Dim_keyContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Dim_keyContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Dim_keyContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Dim_keyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Dim_keyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Dim_keyContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Dim_keyContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Dim_keyContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_key(s) + } +} + +func (s *Dim_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_key(s) + } +} + +func (p *PlSqlParser) Dim_key() (localctx IDim_keyContext) { + localctx = NewDim_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, PlSqlParserRULE_dim_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5243) + p.Dim_ref() + } + p.SetState(5247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5244) + p.Classification_clause() + } + + p.SetState(5249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5250) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(5251) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5255) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 415, p.GetParserRuleContext()) == 1 { + { + p.SetState(5252) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5253) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5257) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + p.SetState(5267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5258) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5262) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 416, p.GetParserRuleContext()) == 1 { + { + p.SetState(5259) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5260) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5264) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + + p.SetState(5269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5270) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(5275) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 1 { + { + p.SetState(5272) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5273) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5277) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5280) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISTINCT { + { + p.SetState(5281) + p.Match(PlSqlParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(5284) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5285) + p.Attribute_name() + } + + { + p.SetState(5286) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5287) + p.Attribute_name() + } + + { + p.SetState(5289) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(5291) + p.Attribute_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5294) + p.Match(PlSqlParserHIERARCHIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5295) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5296) + p.Hier_ref() + } + p.SetState(5301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5297) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5298) + p.Hier_ref() + } + + p.SetState(5303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5304) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_refContext is an interface to support dynamic dispatch. +type IDim_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // GetDa returns the da rule contexts. + GetDa() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // SetDa sets the da rule contexts. + SetDa(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsDim_refContext differentiates from other interfaces. + IsDim_refContext() +} + +type Dim_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext + da IId_expressionContext +} + +func NewEmptyDim_refContext() *Dim_refContext { + var p = new(Dim_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_ref + return p +} + +func InitEmptyDim_refContext(p *Dim_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_ref +} + +func (*Dim_refContext) IsDim_refContext() {} + +func NewDim_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_refContext { + var p = new(Dim_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_ref + + return p +} + +func (s *Dim_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_refContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Dim_refContext) GetDa() IId_expressionContext { return s.da } + +func (s *Dim_refContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Dim_refContext) SetDa(v IId_expressionContext) { s.da = v } + +func (s *Dim_refContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Dim_refContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_refContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Dim_refContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Dim_refContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Dim_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_ref(s) + } +} + +func (s *Dim_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_ref(s) + } +} + +func (p *PlSqlParser) Dim_ref() (localctx IDim_refContext) { + localctx = NewDim_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, PlSqlParserRULE_dim_ref) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5309) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 423, p.GetParserRuleContext()) == 1 { + { + p.SetState(5306) + p.Schema_name() + } + { + p.SetState(5307) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5311) + + var _x = p.Id_expression() + + localctx.(*Dim_refContext).ad = _x + } + p.SetState(5316) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 425, p.GetParserRuleContext()) == 1 { + p.SetState(5313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5312) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5315) + + var _x = p.Id_expression() + + localctx.(*Dim_refContext).da = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_refContext is an interface to support dynamic dispatch. +type IHier_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetHa returns the ha rule contexts. + GetHa() IId_expressionContext + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetHa sets the ha rule contexts. + SetHa(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsHier_refContext differentiates from other interfaces. + IsHier_refContext() +} + +type Hier_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + h IId_expressionContext + ha IId_expressionContext +} + +func NewEmptyHier_refContext() *Hier_refContext { + var p = new(Hier_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_ref + return p +} + +func InitEmptyHier_refContext(p *Hier_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_ref +} + +func (*Hier_refContext) IsHier_refContext() {} + +func NewHier_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_refContext { + var p = new(Hier_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_ref + + return p +} + +func (s *Hier_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_refContext) GetH() IId_expressionContext { return s.h } + +func (s *Hier_refContext) GetHa() IId_expressionContext { return s.ha } + +func (s *Hier_refContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Hier_refContext) SetHa(v IId_expressionContext) { s.ha = v } + +func (s *Hier_refContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Hier_refContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Hier_refContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Hier_refContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Hier_refContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Hier_refContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Hier_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_ref(s) + } +} + +func (s *Hier_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_ref(s) + } +} + +func (p *PlSqlParser) Hier_ref() (localctx IHier_refContext) { + localctx = NewHier_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, PlSqlParserRULE_hier_ref) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5321) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) == 1 { + { + p.SetState(5318) + p.Schema_name() + } + { + p.SetState(5319) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5323) + + var _x = p.Id_expression() + + localctx.(*Hier_refContext).h = _x + } + p.SetState(5328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + p.SetState(5325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5324) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5327) + + var _x = p.Id_expression() + + localctx.(*Hier_refContext).ha = _x + } + + } + p.SetState(5331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(5330) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMeasures_clauseContext is an interface to support dynamic dispatch. +type IMeasures_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEASURES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAv_measure() []IAv_measureContext + Av_measure(i int) IAv_measureContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMeasures_clauseContext differentiates from other interfaces. + IsMeasures_clauseContext() +} + +type Measures_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeasures_clauseContext() *Measures_clauseContext { + var p = new(Measures_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measures_clause + return p +} + +func InitEmptyMeasures_clauseContext(p *Measures_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measures_clause +} + +func (*Measures_clauseContext) IsMeasures_clauseContext() {} + +func NewMeasures_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Measures_clauseContext { + var p = new(Measures_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_measures_clause + + return p +} + +func (s *Measures_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Measures_clauseContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Measures_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Measures_clauseContext) AllAv_measure() []IAv_measureContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAv_measureContext); ok { + len++ + } + } + + tst := make([]IAv_measureContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAv_measureContext); ok { + tst[i] = t.(IAv_measureContext) + i++ + } + } + + return tst +} + +func (s *Measures_clauseContext) Av_measure(i int) IAv_measureContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAv_measureContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAv_measureContext) +} + +func (s *Measures_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Measures_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Measures_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Measures_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Measures_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Measures_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeasures_clause(s) + } +} + +func (s *Measures_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeasures_clause(s) + } +} + +func (p *PlSqlParser) Measures_clause() (localctx IMeasures_clauseContext) { + localctx = NewMeasures_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, PlSqlParserRULE_measures_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5333) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5334) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5335) + p.Av_measure() + } + p.SetState(5340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5336) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5337) + p.Av_measure() + } + + p.SetState(5342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5343) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAv_measureContext is an interface to support dynamic dispatch. +type IAv_measureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMn returns the mn rule contexts. + GetMn() IId_expressionContext + + // SetMn sets the mn rule contexts. + SetMn(IId_expressionContext) + + // Getter signatures + Id_expression() IId_expressionContext + Base_meas_clause() IBase_meas_clauseContext + Calc_meas_clause() ICalc_meas_clauseContext + + // IsAv_measureContext differentiates from other interfaces. + IsAv_measureContext() +} + +type Av_measureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mn IId_expressionContext +} + +func NewEmptyAv_measureContext() *Av_measureContext { + var p = new(Av_measureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_av_measure + return p +} + +func InitEmptyAv_measureContext(p *Av_measureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_av_measure +} + +func (*Av_measureContext) IsAv_measureContext() {} + +func NewAv_measureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Av_measureContext { + var p = new(Av_measureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_av_measure + + return p +} + +func (s *Av_measureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Av_measureContext) GetMn() IId_expressionContext { return s.mn } + +func (s *Av_measureContext) SetMn(v IId_expressionContext) { s.mn = v } + +func (s *Av_measureContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Av_measureContext) Base_meas_clause() IBase_meas_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBase_meas_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBase_meas_clauseContext) +} + +func (s *Av_measureContext) Calc_meas_clause() ICalc_meas_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICalc_meas_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICalc_meas_clauseContext) +} + +func (s *Av_measureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Av_measureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Av_measureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAv_measure(s) + } +} + +func (s *Av_measureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAv_measure(s) + } +} + +func (p *PlSqlParser) Av_measure() (localctx IAv_measureContext) { + localctx = NewAv_measureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, PlSqlParserRULE_av_measure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5345) + + var _x = p.Id_expression() + + localctx.(*Av_measureContext).mn = _x + } + p.SetState(5348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserFACT: + { + p.SetState(5346) + p.Base_meas_clause() + } + + case PlSqlParserAS: + { + p.SetState(5347) + p.Calc_meas_clause() + } + + case PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBase_meas_clauseContext is an interface to support dynamic dispatch. +type IBase_meas_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBm returns the bm rule contexts. + GetBm() IId_expressionContext + + // SetBm sets the bm rule contexts. + SetBm(IId_expressionContext) + + // Getter signatures + FACT() antlr.TerminalNode + Id_expression() IId_expressionContext + Meas_aggregate_clause() IMeas_aggregate_clauseContext + + // IsBase_meas_clauseContext differentiates from other interfaces. + IsBase_meas_clauseContext() +} + +type Base_meas_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bm IId_expressionContext +} + +func NewEmptyBase_meas_clauseContext() *Base_meas_clauseContext { + var p = new(Base_meas_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_base_meas_clause + return p +} + +func InitEmptyBase_meas_clauseContext(p *Base_meas_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_base_meas_clause +} + +func (*Base_meas_clauseContext) IsBase_meas_clauseContext() {} + +func NewBase_meas_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Base_meas_clauseContext { + var p = new(Base_meas_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_base_meas_clause + + return p +} + +func (s *Base_meas_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Base_meas_clauseContext) GetBm() IId_expressionContext { return s.bm } + +func (s *Base_meas_clauseContext) SetBm(v IId_expressionContext) { s.bm = v } + +func (s *Base_meas_clauseContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Base_meas_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Base_meas_clauseContext) Meas_aggregate_clause() IMeas_aggregate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeas_aggregate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeas_aggregate_clauseContext) +} + +func (s *Base_meas_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Base_meas_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Base_meas_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBase_meas_clause(s) + } +} + +func (s *Base_meas_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBase_meas_clause(s) + } +} + +func (p *PlSqlParser) Base_meas_clause() (localctx IBase_meas_clauseContext) { + localctx = NewBase_meas_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, PlSqlParserRULE_base_meas_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5350) + p.Match(PlSqlParserFACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5351) + + var _x = p.Id_expression() + + localctx.(*Base_meas_clauseContext).bm = _x + } + p.SetState(5353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAGGREGATE { + { + p.SetState(5352) + p.Meas_aggregate_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMeas_aggregate_clauseContext is an interface to support dynamic dispatch. +type IMeas_aggregate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGGREGATE() antlr.TerminalNode + BY() antlr.TerminalNode + Aggregate_function_name() IAggregate_function_nameContext + + // IsMeas_aggregate_clauseContext differentiates from other interfaces. + IsMeas_aggregate_clauseContext() +} + +type Meas_aggregate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeas_aggregate_clauseContext() *Meas_aggregate_clauseContext { + var p = new(Meas_aggregate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause + return p +} + +func InitEmptyMeas_aggregate_clauseContext(p *Meas_aggregate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause +} + +func (*Meas_aggregate_clauseContext) IsMeas_aggregate_clauseContext() {} + +func NewMeas_aggregate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meas_aggregate_clauseContext { + var p = new(Meas_aggregate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause + + return p +} + +func (s *Meas_aggregate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Meas_aggregate_clauseContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Meas_aggregate_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Meas_aggregate_clauseContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Meas_aggregate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Meas_aggregate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Meas_aggregate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeas_aggregate_clause(s) + } +} + +func (s *Meas_aggregate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeas_aggregate_clause(s) + } +} + +func (p *PlSqlParser) Meas_aggregate_clause() (localctx IMeas_aggregate_clauseContext) { + localctx = NewMeas_aggregate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, PlSqlParserRULE_meas_aggregate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5355) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5356) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5357) + p.Aggregate_function_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICalc_meas_clauseContext is an interface to support dynamic dispatch. +type ICalc_meas_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCalc_meas_clauseContext differentiates from other interfaces. + IsCalc_meas_clauseContext() +} + +type Calc_meas_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCalc_meas_clauseContext() *Calc_meas_clauseContext { + var p = new(Calc_meas_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_calc_meas_clause + return p +} + +func InitEmptyCalc_meas_clauseContext(p *Calc_meas_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_calc_meas_clause +} + +func (*Calc_meas_clauseContext) IsCalc_meas_clauseContext() {} + +func NewCalc_meas_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Calc_meas_clauseContext { + var p = new(Calc_meas_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_calc_meas_clause + + return p +} + +func (s *Calc_meas_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Calc_meas_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Calc_meas_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Calc_meas_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Calc_meas_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Calc_meas_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Calc_meas_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Calc_meas_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCalc_meas_clause(s) + } +} + +func (s *Calc_meas_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCalc_meas_clause(s) + } +} + +func (p *PlSqlParser) Calc_meas_clause() (localctx ICalc_meas_clauseContext) { + localctx = NewCalc_meas_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, PlSqlParserRULE_calc_meas_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5359) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5360) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5361) + p.Expression() + } + { + p.SetState(5362) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_measure_clauseContext is an interface to support dynamic dispatch. +type IDefault_measure_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetM returns the m rule contexts. + GetM() IId_expressionContext + + // SetM sets the m rule contexts. + SetM(IId_expressionContext) + + // Getter signatures + DEFAULT() antlr.TerminalNode + MEASURE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDefault_measure_clauseContext differentiates from other interfaces. + IsDefault_measure_clauseContext() +} + +type Default_measure_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + m IId_expressionContext +} + +func NewEmptyDefault_measure_clauseContext() *Default_measure_clauseContext { + var p = new(Default_measure_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_measure_clause + return p +} + +func InitEmptyDefault_measure_clauseContext(p *Default_measure_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_measure_clause +} + +func (*Default_measure_clauseContext) IsDefault_measure_clauseContext() {} + +func NewDefault_measure_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_measure_clauseContext { + var p = new(Default_measure_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_measure_clause + + return p +} + +func (s *Default_measure_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_measure_clauseContext) GetM() IId_expressionContext { return s.m } + +func (s *Default_measure_clauseContext) SetM(v IId_expressionContext) { s.m = v } + +func (s *Default_measure_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_measure_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Default_measure_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Default_measure_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_measure_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_measure_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_measure_clause(s) + } +} + +func (s *Default_measure_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_measure_clause(s) + } +} + +func (p *PlSqlParser) Default_measure_clause() (localctx IDefault_measure_clauseContext) { + localctx = NewDefault_measure_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, PlSqlParserRULE_default_measure_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5364) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5365) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5366) + + var _x = p.Id_expression() + + localctx.(*Default_measure_clauseContext).m = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_aggregate_clauseContext is an interface to support dynamic dispatch. +type IDefault_aggregate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + BY() antlr.TerminalNode + Aggregate_function_name() IAggregate_function_nameContext + + // IsDefault_aggregate_clauseContext differentiates from other interfaces. + IsDefault_aggregate_clauseContext() +} + +type Default_aggregate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_aggregate_clauseContext() *Default_aggregate_clauseContext { + var p = new(Default_aggregate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause + return p +} + +func InitEmptyDefault_aggregate_clauseContext(p *Default_aggregate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause +} + +func (*Default_aggregate_clauseContext) IsDefault_aggregate_clauseContext() {} + +func NewDefault_aggregate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_aggregate_clauseContext { + var p = new(Default_aggregate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause + + return p +} + +func (s *Default_aggregate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_aggregate_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_aggregate_clauseContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Default_aggregate_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Default_aggregate_clauseContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Default_aggregate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_aggregate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_aggregate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_aggregate_clause(s) + } +} + +func (s *Default_aggregate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_aggregate_clause(s) + } +} + +func (p *PlSqlParser) Default_aggregate_clause() (localctx IDefault_aggregate_clauseContext) { + localctx = NewDefault_aggregate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, PlSqlParserRULE_default_aggregate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5368) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5369) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5370) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5371) + p.Aggregate_function_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICache_clauseContext is an interface to support dynamic dispatch. +type ICache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CACHE() antlr.TerminalNode + AllCache_specification() []ICache_specificationContext + Cache_specification(i int) ICache_specificationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCache_clauseContext differentiates from other interfaces. + IsCache_clauseContext() +} + +type Cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_clauseContext() *Cache_clauseContext { + var p = new(Cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_clause + return p +} + +func InitEmptyCache_clauseContext(p *Cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_clause +} + +func (*Cache_clauseContext) IsCache_clauseContext() {} + +func NewCache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_clauseContext { + var p = new(Cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_clause + + return p +} + +func (s *Cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Cache_clauseContext) AllCache_specification() []ICache_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICache_specificationContext); ok { + len++ + } + } + + tst := make([]ICache_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICache_specificationContext); ok { + tst[i] = t.(ICache_specificationContext) + i++ + } + } + + return tst +} + +func (s *Cache_clauseContext) Cache_specification(i int) ICache_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICache_specificationContext) +} + +func (s *Cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_clause(s) + } +} + +func (s *Cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_clause(s) + } +} + +func (p *PlSqlParser) Cache_clause() (localctx ICache_clauseContext) { + localctx = NewCache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, PlSqlParserRULE_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5373) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5374) + p.Cache_specification() + } + p.SetState(5379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5375) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5376) + p.Cache_specification() + } + + p.SetState(5381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICache_specificationContext is an interface to support dynamic dispatch. +type ICache_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + ALL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllLevels_clause() []ILevels_clauseContext + Levels_clause(i int) ILevels_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCache_specificationContext differentiates from other interfaces. + IsCache_specificationContext() +} + +type Cache_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_specificationContext() *Cache_specificationContext { + var p = new(Cache_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_specification + return p +} + +func InitEmptyCache_specificationContext(p *Cache_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_specification +} + +func (*Cache_specificationContext) IsCache_specificationContext() {} + +func NewCache_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_specificationContext { + var p = new(Cache_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_specification + + return p +} + +func (s *Cache_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_specificationContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Cache_specificationContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Cache_specificationContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Cache_specificationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cache_specificationContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cache_specificationContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cache_specificationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cache_specificationContext) AllLevels_clause() []ILevels_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_clauseContext); ok { + len++ + } + } + + tst := make([]ILevels_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_clauseContext); ok { + tst[i] = t.(ILevels_clauseContext) + i++ + } + } + + return tst +} + +func (s *Cache_specificationContext) Levels_clause(i int) ILevels_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_clauseContext) +} + +func (s *Cache_specificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cache_specificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cache_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_specification(s) + } +} + +func (s *Cache_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_specification(s) + } +} + +func (p *PlSqlParser) Cache_specification() (localctx ICache_specificationContext) { + localctx = NewCache_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, PlSqlParserRULE_cache_specification) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5382) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5383) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(5384) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(5385) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5386) + p.Id_expression() + } + p.SetState(5391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5387) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5388) + p.Id_expression() + } + + p.SetState(5393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5394) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5395) + p.Levels_clause() + } + p.SetState(5400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 435, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5396) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5397) + p.Levels_clause() + } + + } + p.SetState(5402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 435, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevels_clauseContext is an interface to support dynamic dispatch. +type ILevels_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEVELS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllLevel_specification() []ILevel_specificationContext + Level_specification(i int) ILevel_specificationContext + RIGHT_PAREN() antlr.TerminalNode + Level_group_type() ILevel_group_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLevels_clauseContext differentiates from other interfaces. + IsLevels_clauseContext() +} + +type Levels_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLevels_clauseContext() *Levels_clauseContext { + var p = new(Levels_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_clause + return p +} + +func InitEmptyLevels_clauseContext(p *Levels_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_clause +} + +func (*Levels_clauseContext) IsLevels_clauseContext() {} + +func NewLevels_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Levels_clauseContext { + var p = new(Levels_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_levels_clause + + return p +} + +func (s *Levels_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Levels_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Levels_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Levels_clauseContext) AllLevel_specification() []ILevel_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_specificationContext); ok { + len++ + } + } + + tst := make([]ILevel_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_specificationContext); ok { + tst[i] = t.(ILevel_specificationContext) + i++ + } + } + + return tst +} + +func (s *Levels_clauseContext) Level_specification(i int) ILevel_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_specificationContext) +} + +func (s *Levels_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Levels_clauseContext) Level_group_type() ILevel_group_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_group_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILevel_group_typeContext) +} + +func (s *Levels_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Levels_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Levels_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Levels_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Levels_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevels_clause(s) + } +} + +func (s *Levels_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevels_clause(s) + } +} + +func (p *PlSqlParser) Levels_clause() (localctx ILevels_clauseContext) { + localctx = NewLevels_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, PlSqlParserRULE_levels_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5405) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5406) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5407) + p.Level_specification() + } + p.SetState(5412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5408) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5409) + p.Level_specification() + } + + p.SetState(5414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5415) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5416) + p.Level_group_type() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_specificationContext is an interface to support dynamic dispatch. +type ILevel_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsLevel_specificationContext differentiates from other interfaces. + IsLevel_specificationContext() +} + +type Level_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext + h IId_expressionContext + l IId_expressionContext +} + +func NewEmptyLevel_specificationContext() *Level_specificationContext { + var p = new(Level_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_specification + return p +} + +func InitEmptyLevel_specificationContext(p *Level_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_specification +} + +func (*Level_specificationContext) IsLevel_specificationContext() {} + +func NewLevel_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_specificationContext { + var p = new(Level_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_specification + + return p +} + +func (s *Level_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_specificationContext) GetD() IId_expressionContext { return s.d } + +func (s *Level_specificationContext) GetH() IId_expressionContext { return s.h } + +func (s *Level_specificationContext) GetL() IId_expressionContext { return s.l } + +func (s *Level_specificationContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Level_specificationContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Level_specificationContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Level_specificationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_specificationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_specificationContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Level_specificationContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_specificationContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Level_specificationContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Level_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_specification(s) + } +} + +func (s *Level_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_specification(s) + } +} + +func (p *PlSqlParser) Level_specification() (localctx ILevel_specificationContext) { + localctx = NewLevel_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, PlSqlParserRULE_level_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5418) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5427) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 439, p.GetParserRuleContext()) == 1 { + p.SetState(5422) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 438, p.GetParserRuleContext()) == 1 { + { + p.SetState(5419) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).d = _x + } + { + p.SetState(5420) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5424) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).h = _x + } + { + p.SetState(5425) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5429) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).l = _x + } + { + p.SetState(5430) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_group_typeContext is an interface to support dynamic dispatch. +type ILevel_group_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // Getter signatures + DYNAMIC() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + USING() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsLevel_group_typeContext differentiates from other interfaces. + IsLevel_group_typeContext() +} + +type Level_group_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t IId_expressionContext +} + +func NewEmptyLevel_group_typeContext() *Level_group_typeContext { + var p = new(Level_group_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_group_type + return p +} + +func InitEmptyLevel_group_typeContext(p *Level_group_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_group_type +} + +func (*Level_group_typeContext) IsLevel_group_typeContext() {} + +func NewLevel_group_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_group_typeContext { + var p = new(Level_group_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_group_type + + return p +} + +func (s *Level_group_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_group_typeContext) GetT() IId_expressionContext { return s.t } + +func (s *Level_group_typeContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Level_group_typeContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC, 0) +} + +func (s *Level_group_typeContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Level_group_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Level_group_typeContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_group_typeContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Level_group_typeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Level_group_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_group_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_group_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_group_type(s) + } +} + +func (s *Level_group_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_group_type(s) + } +} + +func (p *PlSqlParser) Level_group_type() (localctx ILevel_group_typeContext) { + localctx = NewLevel_group_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, PlSqlParserRULE_level_group_type) + var _la int + + p.SetState(5443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDYNAMIC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5432) + p.Match(PlSqlParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMATERIALIZED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5433) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(5434) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5438) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { + { + p.SetState(5435) + p.Schema_name() + } + { + p.SetState(5436) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5440) + + var _x = p.Id_expression() + + localctx.(*Level_group_typeContext).t = _x + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFact_columns_clauseContext is an interface to support dynamic dispatch. +type IFact_columns_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetF returns the f rule contexts. + GetF() IColumn_nameContext + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetF sets the f rule contexts. + SetF(IColumn_nameContext) + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + FACT() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFact_columns_clauseContext differentiates from other interfaces. + IsFact_columns_clauseContext() +} + +type Fact_columns_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + f IColumn_nameContext + fa IId_expressionContext +} + +func NewEmptyFact_columns_clauseContext() *Fact_columns_clauseContext { + var p = new(Fact_columns_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fact_columns_clause + return p +} + +func InitEmptyFact_columns_clauseContext(p *Fact_columns_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fact_columns_clause +} + +func (*Fact_columns_clauseContext) IsFact_columns_clauseContext() {} + +func NewFact_columns_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fact_columns_clauseContext { + var p = new(Fact_columns_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fact_columns_clause + + return p +} + +func (s *Fact_columns_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fact_columns_clauseContext) GetF() IColumn_nameContext { return s.f } + +func (s *Fact_columns_clauseContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Fact_columns_clauseContext) SetF(v IColumn_nameContext) { s.f = v } + +func (s *Fact_columns_clauseContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Fact_columns_clauseContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Fact_columns_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Fact_columns_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Fact_columns_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Fact_columns_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Fact_columns_clauseContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Fact_columns_clauseContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Fact_columns_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Fact_columns_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Fact_columns_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fact_columns_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fact_columns_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFact_columns_clause(s) + } +} + +func (s *Fact_columns_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFact_columns_clause(s) + } +} + +func (p *PlSqlParser) Fact_columns_clause() (localctx IFact_columns_clauseContext) { + localctx = NewFact_columns_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, PlSqlParserRULE_fact_columns_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5445) + p.Match(PlSqlParserFACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5446) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5447) + + var _x = p.Column_name() + + localctx.(*Fact_columns_clauseContext).f = _x + } + p.SetState(5462) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 446, p.GetParserRuleContext()) == 1 { + p.SetState(5449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5448) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5451) + + var _x = p.Id_expression() + + localctx.(*Fact_columns_clauseContext).fa = _x + } + p.SetState(5459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5452) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5453) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5456) + + var _x = p.Id_expression() + + localctx.(*Fact_columns_clauseContext).fa = _x + } + + p.SetState(5461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQry_transform_clauseContext is an interface to support dynamic dispatch. +type IQry_transform_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + QUERY() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + + // IsQry_transform_clauseContext differentiates from other interfaces. + IsQry_transform_clauseContext() +} + +type Qry_transform_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQry_transform_clauseContext() *Qry_transform_clauseContext { + var p = new(Qry_transform_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qry_transform_clause + return p +} + +func InitEmptyQry_transform_clauseContext(p *Qry_transform_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qry_transform_clause +} + +func (*Qry_transform_clauseContext) IsQry_transform_clauseContext() {} + +func NewQry_transform_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qry_transform_clauseContext { + var p = new(Qry_transform_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qry_transform_clause + + return p +} + +func (s *Qry_transform_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qry_transform_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Qry_transform_clauseContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Qry_transform_clauseContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM, 0) +} + +func (s *Qry_transform_clauseContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Qry_transform_clauseContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Qry_transform_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qry_transform_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qry_transform_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQry_transform_clause(s) + } +} + +func (s *Qry_transform_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQry_transform_clause(s) + } +} + +func (p *PlSqlParser) Qry_transform_clause() (localctx IQry_transform_clauseContext) { + localctx = NewQry_transform_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, PlSqlParserRULE_qry_transform_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5464) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5465) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5466) + p.Match(PlSqlParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORELY || _la == PlSqlParserRELY { + { + p.SetState(5467) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_attribute_dimensionContext is an interface to support dynamic dispatch. +type ICreate_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + AllDIMENSION() []antlr.TerminalNode + DIMENSION(i int) antlr.TerminalNode + Ad_using_clause() IAd_using_clauseContext + Attributes_clause() IAttributes_clauseContext + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + TYPE() antlr.TerminalNode + AllAd_level_clause() []IAd_level_clauseContext + Ad_level_clause(i int) IAd_level_clauseContext + All_clause() IAll_clauseContext + NOFORCE() antlr.TerminalNode + FORCE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + STANDARD() antlr.TerminalNode + TIME() antlr.TerminalNode + + // IsCreate_attribute_dimensionContext differentiates from other interfaces. + IsCreate_attribute_dimensionContext() +} + +type Create_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyCreate_attribute_dimensionContext() *Create_attribute_dimensionContext { + var p = new(Create_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension + return p +} + +func InitEmptyCreate_attribute_dimensionContext(p *Create_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension +} + +func (*Create_attribute_dimensionContext) IsCreate_attribute_dimensionContext() {} + +func NewCreate_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_attribute_dimensionContext { + var p = new(Create_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension + + return p +} + +func (s *Create_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Create_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Create_attribute_dimensionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Create_attribute_dimensionContext) AllDIMENSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDIMENSION) +} + +func (s *Create_attribute_dimensionContext) DIMENSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, i) +} + +func (s *Create_attribute_dimensionContext) Ad_using_clause() IAd_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAd_using_clauseContext) +} + +func (s *Create_attribute_dimensionContext) Attributes_clause() IAttributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttributes_clauseContext) +} + +func (s *Create_attribute_dimensionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_attribute_dimensionContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_attribute_dimensionContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_attribute_dimensionContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_attribute_dimensionContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_attribute_dimensionContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_attribute_dimensionContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_attribute_dimensionContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_attribute_dimensionContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Create_attribute_dimensionContext) AllAd_level_clause() []IAd_level_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAd_level_clauseContext); ok { + len++ + } + } + + tst := make([]IAd_level_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAd_level_clauseContext); ok { + tst[i] = t.(IAd_level_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_attribute_dimensionContext) Ad_level_clause(i int) IAd_level_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_level_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAd_level_clauseContext) +} + +func (s *Create_attribute_dimensionContext) All_clause() IAll_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_clauseContext) +} + +func (s *Create_attribute_dimensionContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_attribute_dimensionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_attribute_dimensionContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_attribute_dimensionContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_attribute_dimensionContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Create_attribute_dimensionContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Create_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_attribute_dimension(s) + } +} + +func (s *Create_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_attribute_dimension(s) + } +} + +func (p *PlSqlParser) Create_attribute_dimension() (localctx ICreate_attribute_dimensionContext) { + localctx = NewCreate_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, PlSqlParserRULE_create_attribute_dimension) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5470) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(5471) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5472) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(5475) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5478) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5479) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5483) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) == 1 { + { + p.SetState(5480) + p.Schema_name() + } + { + p.SetState(5481) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5485) + + var _x = p.Id_expression() + + localctx.(*Create_attribute_dimensionContext).ad = _x + } + p.SetState(5489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(5486) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5487) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5488) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5491) + p.Classification_clause() + } + + p.SetState(5496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDIMENSION { + { + p.SetState(5497) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5498) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5499) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSTANDARD || _la == PlSqlParserTIME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5502) + p.Ad_using_clause() + } + { + p.SetState(5503) + p.Attributes_clause() + } + p.SetState(5505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEVEL { + { + p.SetState(5504) + p.Ad_level_clause() + } + + p.SetState(5507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(5509) + p.All_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAd_using_clauseContext is an interface to support dynamic dispatch. +type IAd_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + AllSource_clause() []ISource_clauseContext + Source_clause(i int) ISource_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllJoin_path_clause() []IJoin_path_clauseContext + Join_path_clause(i int) IJoin_path_clauseContext + + // IsAd_using_clauseContext differentiates from other interfaces. + IsAd_using_clauseContext() +} + +type Ad_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAd_using_clauseContext() *Ad_using_clauseContext { + var p = new(Ad_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_using_clause + return p +} + +func InitEmptyAd_using_clauseContext(p *Ad_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_using_clause +} + +func (*Ad_using_clauseContext) IsAd_using_clauseContext() {} + +func NewAd_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_using_clauseContext { + var p = new(Ad_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_using_clause + + return p +} + +func (s *Ad_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Ad_using_clauseContext) AllSource_clause() []ISource_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISource_clauseContext); ok { + len++ + } + } + + tst := make([]ISource_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISource_clauseContext); ok { + tst[i] = t.(ISource_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_using_clauseContext) Source_clause(i int) ISource_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISource_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISource_clauseContext) +} + +func (s *Ad_using_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ad_using_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ad_using_clauseContext) AllJoin_path_clause() []IJoin_path_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_path_clauseContext); ok { + len++ + } + } + + tst := make([]IJoin_path_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_path_clauseContext); ok { + tst[i] = t.(IJoin_path_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_using_clauseContext) Join_path_clause(i int) IJoin_path_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_path_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_path_clauseContext) +} + +func (s *Ad_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_using_clause(s) + } +} + +func (s *Ad_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_using_clause(s) + } +} + +func (p *PlSqlParser) Ad_using_clause() (localctx IAd_using_clauseContext) { + localctx = NewAd_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, PlSqlParserRULE_ad_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5512) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5513) + p.Source_clause() + } + p.SetState(5518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5514) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5515) + p.Source_clause() + } + + p.SetState(5520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserJOIN { + { + p.SetState(5521) + p.Join_path_clause() + } + + p.SetState(5526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISource_clauseContext is an interface to support dynamic dispatch. +type ISource_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFtov returns the ftov rule contexts. + GetFtov() IId_expressionContext + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetFtov sets the ftov rule contexts. + SetFtov(IId_expressionContext) + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + REMOTE() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsSource_clauseContext differentiates from other interfaces. + IsSource_clauseContext() +} + +type Source_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ftov IId_expressionContext + a IId_expressionContext +} + +func NewEmptySource_clauseContext() *Source_clauseContext { + var p = new(Source_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_clause + return p +} + +func InitEmptySource_clauseContext(p *Source_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_clause +} + +func (*Source_clauseContext) IsSource_clauseContext() {} + +func NewSource_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Source_clauseContext { + var p = new(Source_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_source_clause + + return p +} + +func (s *Source_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Source_clauseContext) GetFtov() IId_expressionContext { return s.ftov } + +func (s *Source_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Source_clauseContext) SetFtov(v IId_expressionContext) { s.ftov = v } + +func (s *Source_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Source_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Source_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Source_clauseContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Source_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Source_clauseContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Source_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Source_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Source_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Source_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSource_clause(s) + } +} + +func (s *Source_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSource_clause(s) + } +} + +func (p *PlSqlParser) Source_clause() (localctx ISource_clauseContext) { + localctx = NewSource_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, PlSqlParserRULE_source_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5530) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) == 1 { + { + p.SetState(5527) + p.Schema_name() + } + { + p.SetState(5528) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5532) + + var _x = p.Id_expression() + + localctx.(*Source_clauseContext).ftov = _x + } + p.SetState(5534) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 459, p.GetParserRuleContext()) == 1 { + { + p.SetState(5533) + p.Match(PlSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5540) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 461, p.GetParserRuleContext()) == 1 { + p.SetState(5537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5536) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5539) + + var _x = p.Id_expression() + + localctx.(*Source_clauseContext).a = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_path_clauseContext is an interface to support dynamic dispatch. +type IJoin_path_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJpn returns the jpn rule contexts. + GetJpn() IId_expressionContext + + // SetJpn sets the jpn rule contexts. + SetJpn(IId_expressionContext) + + // Getter signatures + JOIN() antlr.TerminalNode + PATH() antlr.TerminalNode + ON() antlr.TerminalNode + Join_condition() IJoin_conditionContext + Id_expression() IId_expressionContext + + // IsJoin_path_clauseContext differentiates from other interfaces. + IsJoin_path_clauseContext() +} + +type Join_path_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jpn IId_expressionContext +} + +func NewEmptyJoin_path_clauseContext() *Join_path_clauseContext { + var p = new(Join_path_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_path_clause + return p +} + +func InitEmptyJoin_path_clauseContext(p *Join_path_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_path_clause +} + +func (*Join_path_clauseContext) IsJoin_path_clauseContext() {} + +func NewJoin_path_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_path_clauseContext { + var p = new(Join_path_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_path_clause + + return p +} + +func (s *Join_path_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_path_clauseContext) GetJpn() IId_expressionContext { return s.jpn } + +func (s *Join_path_clauseContext) SetJpn(v IId_expressionContext) { s.jpn = v } + +func (s *Join_path_clauseContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Join_path_clauseContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Join_path_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Join_path_clauseContext) Join_condition() IJoin_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_conditionContext) +} + +func (s *Join_path_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Join_path_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_path_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_path_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_path_clause(s) + } +} + +func (s *Join_path_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_path_clause(s) + } +} + +func (p *PlSqlParser) Join_path_clause() (localctx IJoin_path_clauseContext) { + localctx = NewJoin_path_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, PlSqlParserRULE_join_path_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5542) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5543) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5544) + + var _x = p.Id_expression() + + localctx.(*Join_path_clauseContext).jpn = _x + } + { + p.SetState(5545) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5546) + p.Join_condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_conditionContext is an interface to support dynamic dispatch. +type IJoin_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJoin_condition_item() []IJoin_condition_itemContext + Join_condition_item(i int) IJoin_condition_itemContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + + // IsJoin_conditionContext differentiates from other interfaces. + IsJoin_conditionContext() +} + +type Join_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_conditionContext() *Join_conditionContext { + var p = new(Join_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition + return p +} + +func InitEmptyJoin_conditionContext(p *Join_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition +} + +func (*Join_conditionContext) IsJoin_conditionContext() {} + +func NewJoin_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_conditionContext { + var p = new(Join_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_condition + + return p +} + +func (s *Join_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_conditionContext) AllJoin_condition_item() []IJoin_condition_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_condition_itemContext); ok { + len++ + } + } + + tst := make([]IJoin_condition_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_condition_itemContext); ok { + tst[i] = t.(IJoin_condition_itemContext) + i++ + } + } + + return tst +} + +func (s *Join_conditionContext) Join_condition_item(i int) IJoin_condition_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_condition_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_condition_itemContext) +} + +func (s *Join_conditionContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAND) +} + +func (s *Join_conditionContext) AND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, i) +} + +func (s *Join_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_condition(s) + } +} + +func (s *Join_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_condition(s) + } +} + +func (p *PlSqlParser) Join_condition() (localctx IJoin_conditionContext) { + localctx = NewJoin_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, PlSqlParserRULE_join_condition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5548) + p.Join_condition_item() + } + p.SetState(5553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserAND { + { + p.SetState(5549) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5550) + p.Join_condition_item() + } + + p.SetState(5555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_condition_itemContext is an interface to support dynamic dispatch. +type IJoin_condition_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetB returns the b rule contexts. + GetB() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetB sets the b rule contexts. + SetB(IId_expressionContext) + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsJoin_condition_itemContext differentiates from other interfaces. + IsJoin_condition_itemContext() +} + +type Join_condition_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + b IId_expressionContext +} + +func NewEmptyJoin_condition_itemContext() *Join_condition_itemContext { + var p = new(Join_condition_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition_item + return p +} + +func InitEmptyJoin_condition_itemContext(p *Join_condition_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition_item +} + +func (*Join_condition_itemContext) IsJoin_condition_itemContext() {} + +func NewJoin_condition_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_condition_itemContext { + var p = new(Join_condition_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_condition_item + + return p +} + +func (s *Join_condition_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_condition_itemContext) GetA() IId_expressionContext { return s.a } + +func (s *Join_condition_itemContext) GetB() IId_expressionContext { return s.b } + +func (s *Join_condition_itemContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Join_condition_itemContext) SetB(v IId_expressionContext) { s.b = v } + +func (s *Join_condition_itemContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Join_condition_itemContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Join_condition_itemContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Join_condition_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Join_condition_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Join_condition_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Join_condition_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Join_condition_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_condition_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_condition_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_condition_item(s) + } +} + +func (s *Join_condition_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_condition_item(s) + } +} + +func (p *PlSqlParser) Join_condition_item() (localctx IJoin_condition_itemContext) { + localctx = NewJoin_condition_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, PlSqlParserRULE_join_condition_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(5559) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 463, p.GetParserRuleContext()) == 1 { + { + p.SetState(5556) + + var _x = p.Id_expression() + + localctx.(*Join_condition_itemContext).a = _x + } + { + p.SetState(5557) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5561) + p.Column_name() + } + { + p.SetState(5562) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5566) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 464, p.GetParserRuleContext()) == 1 { + { + p.SetState(5563) + + var _x = p.Id_expression() + + localctx.(*Join_condition_itemContext).b = _x + } + { + p.SetState(5564) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5568) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttributes_clauseContext is an interface to support dynamic dispatch. +type IAttributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAd_attributes_clause() []IAd_attributes_clauseContext + Ad_attributes_clause(i int) IAd_attributes_clauseContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAttributes_clauseContext differentiates from other interfaces. + IsAttributes_clauseContext() +} + +type Attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttributes_clauseContext() *Attributes_clauseContext { + var p = new(Attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attributes_clause + return p +} + +func InitEmptyAttributes_clauseContext(p *Attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attributes_clause +} + +func (*Attributes_clauseContext) IsAttributes_clauseContext() {} + +func NewAttributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attributes_clauseContext { + var p = new(Attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attributes_clause + + return p +} + +func (s *Attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attributes_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Attributes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Attributes_clauseContext) AllAd_attributes_clause() []IAd_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAd_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IAd_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAd_attributes_clauseContext); ok { + tst[i] = t.(IAd_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Attributes_clauseContext) Ad_attributes_clause(i int) IAd_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAd_attributes_clauseContext) +} + +func (s *Attributes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Attributes_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Attributes_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttributes_clause(s) + } +} + +func (s *Attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttributes_clause(s) + } +} + +func (p *PlSqlParser) Attributes_clause() (localctx IAttributes_clauseContext) { + localctx = NewAttributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, PlSqlParserRULE_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5570) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5571) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5572) + p.Ad_attributes_clause() + } + p.SetState(5577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5573) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5574) + p.Ad_attributes_clause() + } + + p.SetState(5579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5580) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAd_attributes_clauseContext is an interface to support dynamic dispatch. +type IAd_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetAn returns the an rule contexts. + GetAn() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetAn sets the an rule contexts. + SetAn(IId_expressionContext) + + // Getter signatures + Column_name() IColumn_nameContext + PERIOD() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AS() antlr.TerminalNode + + // IsAd_attributes_clauseContext differentiates from other interfaces. + IsAd_attributes_clauseContext() +} + +type Ad_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + an IId_expressionContext +} + +func NewEmptyAd_attributes_clauseContext() *Ad_attributes_clauseContext { + var p = new(Ad_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause + return p +} + +func InitEmptyAd_attributes_clauseContext(p *Ad_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause +} + +func (*Ad_attributes_clauseContext) IsAd_attributes_clauseContext() {} + +func NewAd_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_attributes_clauseContext { + var p = new(Ad_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause + + return p +} + +func (s *Ad_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_attributes_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Ad_attributes_clauseContext) GetAn() IId_expressionContext { return s.an } + +func (s *Ad_attributes_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Ad_attributes_clauseContext) SetAn(v IId_expressionContext) { s.an = v } + +func (s *Ad_attributes_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Ad_attributes_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Ad_attributes_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_attributes_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Ad_attributes_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_attributes_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Ad_attributes_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Ad_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_attributes_clause(s) + } +} + +func (s *Ad_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_attributes_clause(s) + } +} + +func (p *PlSqlParser) Ad_attributes_clause() (localctx IAd_attributes_clauseContext) { + localctx = NewAd_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, PlSqlParserRULE_ad_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5585) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, p.GetParserRuleContext()) == 1 { + { + p.SetState(5582) + + var _x = p.Id_expression() + + localctx.(*Ad_attributes_clauseContext).a = _x + } + { + p.SetState(5583) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5587) + p.Column_name() + } + p.SetState(5592) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) == 1 { + p.SetState(5589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5588) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5591) + + var _x = p.Id_expression() + + localctx.(*Ad_attributes_clauseContext).an = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5594) + p.Classification_clause() + } + + p.SetState(5599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAd_level_clauseContext is an interface to support dynamic dispatch. +type IAd_level_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + Key_clause() IKey_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + SKIP_() antlr.TerminalNode + WHEN() antlr.TerminalNode + TYPE() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Alternate_key_clause() IAlternate_key_clauseContext + AllMEMBER() []antlr.TerminalNode + MEMBER(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + CAPTION() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllDim_order_clause() []IDim_order_clauseContext + Dim_order_clause(i int) IDim_order_clauseContext + DETERMINES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + STANDARD() antlr.TerminalNode + YEARS() antlr.TerminalNode + HALF_YEARS() antlr.TerminalNode + QUARTERS() antlr.TerminalNode + MONTHS() antlr.TerminalNode + WEEKS() antlr.TerminalNode + DAYS() antlr.TerminalNode + HOURS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + SECONDS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllMIN() []antlr.TerminalNode + MIN(i int) antlr.TerminalNode + AllMAX() []antlr.TerminalNode + MAX(i int) antlr.TerminalNode + + // IsAd_level_clauseContext differentiates from other interfaces. + IsAd_level_clauseContext() +} + +type Ad_level_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + l IId_expressionContext +} + +func NewEmptyAd_level_clauseContext() *Ad_level_clauseContext { + var p = new(Ad_level_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_level_clause + return p +} + +func InitEmptyAd_level_clauseContext(p *Ad_level_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_level_clause +} + +func (*Ad_level_clauseContext) IsAd_level_clauseContext() {} + +func NewAd_level_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_level_clauseContext { + var p = new(Ad_level_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_level_clause + + return p +} + +func (s *Ad_level_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_level_clauseContext) GetL() IId_expressionContext { return s.l } + +func (s *Ad_level_clauseContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Ad_level_clauseContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Ad_level_clauseContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Ad_level_clauseContext) Key_clause() IKey_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_clauseContext) +} + +func (s *Ad_level_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Ad_level_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Ad_level_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Ad_level_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Ad_level_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Ad_level_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Ad_level_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Ad_level_clauseContext) Alternate_key_clause() IAlternate_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlternate_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlternate_key_clauseContext) +} + +func (s *Ad_level_clauseContext) AllMEMBER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMEMBER) +} + +func (s *Ad_level_clauseContext) MEMBER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, i) +} + +func (s *Ad_level_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Ad_level_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Ad_level_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Ad_level_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Ad_level_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Ad_level_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Ad_level_clauseContext) AllDim_order_clause() []IDim_order_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDim_order_clauseContext); ok { + len++ + } + } + + tst := make([]IDim_order_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDim_order_clauseContext); ok { + tst[i] = t.(IDim_order_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Dim_order_clause(i int) IDim_order_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_order_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDim_order_clauseContext) +} + +func (s *Ad_level_clauseContext) DETERMINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, 0) +} + +func (s *Ad_level_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Ad_level_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Ad_level_clauseContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Ad_level_clauseContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Ad_level_clauseContext) HALF_YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHALF_YEARS, 0) +} + +func (s *Ad_level_clauseContext) QUARTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUARTERS, 0) +} + +func (s *Ad_level_clauseContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Ad_level_clauseContext) WEEKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEKS, 0) +} + +func (s *Ad_level_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Ad_level_clauseContext) HOURS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOURS, 0) +} + +func (s *Ad_level_clauseContext) MINUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTES, 0) +} + +func (s *Ad_level_clauseContext) SECONDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECONDS, 0) +} + +func (s *Ad_level_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ad_level_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ad_level_clauseContext) AllMIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMIN) +} + +func (s *Ad_level_clauseContext) MIN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, i) +} + +func (s *Ad_level_clauseContext) AllMAX() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAX) +} + +func (s *Ad_level_clauseContext) MAX(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, i) +} + +func (s *Ad_level_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_level_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_level_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_level_clause(s) + } +} + +func (s *Ad_level_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_level_clause(s) + } +} + +func (p *PlSqlParser) Ad_level_clause() (localctx IAd_level_clauseContext) { + localctx = NewAd_level_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, PlSqlParserRULE_ad_level_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5600) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5601) + + var _x = p.Id_expression() + + localctx.(*Ad_level_clauseContext).l = _x + } + p.SetState(5607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT: + { + p.SetState(5602) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5603) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSKIP_: + { + p.SetState(5604) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5605) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5606) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCAPTION, PlSqlParserCLASSIFICATION, PlSqlParserDESCRIPTION, PlSqlParserKEY, PlSqlParserLEVEL: + + default: + } + p.SetState(5612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEVEL { + { + p.SetState(5609) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5610) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5611) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAYS || _la == PlSqlParserHALF_YEARS || _la == PlSqlParserHOURS || _la == PlSqlParserMINUTES || _la == PlSqlParserMONTHS || _la == PlSqlParserQUARTERS || _la == PlSqlParserSECONDS || _la == PlSqlParserSTANDARD || _la == PlSqlParserWEEKS || _la == PlSqlParserYEARS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5614) + p.Classification_clause() + } + + p.SetState(5619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5620) + p.Key_clause() + } + p.SetState(5622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALTERNATE { + { + p.SetState(5621) + p.Alternate_key_clause() + } + + } + p.SetState(5627) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) == 1 { + { + p.SetState(5624) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5625) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5626) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5632) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) == 1 { + { + p.SetState(5629) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5630) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5631) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMBER { + { + p.SetState(5634) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5635) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5636) + p.Expression() + } + + } + p.SetState(5655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(5639) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5640) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5642) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 477, p.GetParserRuleContext()) == 1 { + { + p.SetState(5641) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAX || _la == PlSqlParserMIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5644) + p.Dim_order_clause() + } + p.SetState(5652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5645) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5647) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) == 1 { + { + p.SetState(5646) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAX || _la == PlSqlParserMIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5649) + p.Dim_order_clause() + } + + p.SetState(5654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(5669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDETERMINES { + { + p.SetState(5657) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5658) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5659) + p.Id_expression() + } + p.SetState(5664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5660) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5661) + p.Id_expression() + } + + p.SetState(5666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5667) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_clauseContext is an interface to support dynamic dispatch. +type IKey_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + KEY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsKey_clauseContext differentiates from other interfaces. + IsKey_clauseContext() +} + +type Key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext +} + +func NewEmptyKey_clauseContext() *Key_clauseContext { + var p = new(Key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_clause + return p +} + +func InitEmptyKey_clauseContext(p *Key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_clause +} + +func (*Key_clauseContext) IsKey_clauseContext() {} + +func NewKey_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_clauseContext { + var p = new(Key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_clause + + return p +} + +func (s *Key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Key_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Key_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Key_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Key_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Key_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Key_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Key_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Key_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_clause(s) + } +} + +func (s *Key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_clause(s) + } +} + +func (p *PlSqlParser) Key_clause() (localctx IKey_clauseContext) { + localctx = NewKey_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, PlSqlParserRULE_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5671) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(5672) + + var _x = p.Id_expression() + + localctx.(*Key_clauseContext).a = _x + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(5673) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5674) + p.Id_expression() + } + p.SetState(5679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5675) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5676) + p.Id_expression() + } + + p.SetState(5681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5682) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlternate_key_clauseContext is an interface to support dynamic dispatch. +type IAlternate_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTERNATE() antlr.TerminalNode + Key_clause() IKey_clauseContext + + // IsAlternate_key_clauseContext differentiates from other interfaces. + IsAlternate_key_clauseContext() +} + +type Alternate_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlternate_key_clauseContext() *Alternate_key_clauseContext { + var p = new(Alternate_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alternate_key_clause + return p +} + +func InitEmptyAlternate_key_clauseContext(p *Alternate_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alternate_key_clause +} + +func (*Alternate_key_clauseContext) IsAlternate_key_clauseContext() {} + +func NewAlternate_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alternate_key_clauseContext { + var p = new(Alternate_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alternate_key_clause + + return p +} + +func (s *Alternate_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alternate_key_clauseContext) ALTERNATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTERNATE, 0) +} + +func (s *Alternate_key_clauseContext) Key_clause() IKey_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_clauseContext) +} + +func (s *Alternate_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alternate_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alternate_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlternate_key_clause(s) + } +} + +func (s *Alternate_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlternate_key_clause(s) + } +} + +func (p *PlSqlParser) Alternate_key_clause() (localctx IAlternate_key_clauseContext) { + localctx = NewAlternate_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, PlSqlParserRULE_alternate_key_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5686) + p.Match(PlSqlParserALTERNATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5687) + p.Key_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_order_clauseContext is an interface to support dynamic dispatch. +type IDim_order_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + Id_expression() IId_expressionContext + NULLS() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsDim_order_clauseContext differentiates from other interfaces. + IsDim_order_clauseContext() +} + +type Dim_order_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext +} + +func NewEmptyDim_order_clauseContext() *Dim_order_clauseContext { + var p = new(Dim_order_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_order_clause + return p +} + +func InitEmptyDim_order_clauseContext(p *Dim_order_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_order_clause +} + +func (*Dim_order_clauseContext) IsDim_order_clauseContext() {} + +func NewDim_order_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_order_clauseContext { + var p = new(Dim_order_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_order_clause + + return p +} + +func (s *Dim_order_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_order_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Dim_order_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Dim_order_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_order_clauseContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Dim_order_clauseContext) ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, 0) +} + +func (s *Dim_order_clauseContext) DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, 0) +} + +func (s *Dim_order_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Dim_order_clauseContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Dim_order_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_order_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_order_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_order_clause(s) + } +} + +func (s *Dim_order_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_order_clause(s) + } +} + +func (p *PlSqlParser) Dim_order_clause() (localctx IDim_order_clauseContext) { + localctx = NewDim_order_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, PlSqlParserRULE_dim_order_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5689) + + var _x = p.Id_expression() + + localctx.(*Dim_order_clauseContext).a = _x + } + p.SetState(5691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(5690) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLS { + { + p.SetState(5693) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5694) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_clauseContext is an interface to support dynamic dispatch. +type IAll_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + AllMEMBER() []antlr.TerminalNode + MEMBER(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + CAPTION() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + + // IsAll_clauseContext differentiates from other interfaces. + IsAll_clauseContext() +} + +type All_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_clauseContext() *All_clauseContext { + var p = new(All_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_all_clause + return p +} + +func InitEmptyAll_clauseContext(p *All_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_all_clause +} + +func (*All_clauseContext) IsAll_clauseContext() {} + +func NewAll_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_clauseContext { + var p = new(All_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_all_clause + + return p +} + +func (s *All_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *All_clauseContext) AllMEMBER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMEMBER) +} + +func (s *All_clauseContext) MEMBER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, i) +} + +func (s *All_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *All_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *All_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *All_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *All_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *All_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAll_clause(s) + } +} + +func (s *All_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAll_clause(s) + } +} + +func (p *PlSqlParser) All_clause() (localctx IAll_clauseContext) { + localctx = NewAll_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, PlSqlParserRULE_all_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5697) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5698) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNAME: + { + p.SetState(5699) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5700) + p.Expression() + } + p.SetState(5704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMBER { + { + p.SetState(5701) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5702) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5703) + p.Expression() + } + + } + + case PlSqlParserCAPTION: + { + p.SetState(5706) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5707) + p.Expression() + } + p.SetState(5711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMBER { + { + p.SetState(5708) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5709) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5710) + p.Expression() + } + + } + + case PlSqlParserDESCRIPTION: + { + p.SetState(5713) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5714) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_audit_policyContext is an interface to support dynamic dispatch. +type ICreate_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + Privilege_audit_clause() IPrivilege_audit_clauseContext + Action_audit_clause() IAction_audit_clauseContext + Role_audit_clause() IRole_audit_clauseContext + WHEN() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + EVALUATE() antlr.TerminalNode + PER() antlr.TerminalNode + ONLY() antlr.TerminalNode + TOPLEVEL() antlr.TerminalNode + Container_clause() IContainer_clauseContext + STATEMENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + + // IsCreate_audit_policyContext differentiates from other interfaces. + IsCreate_audit_policyContext() +} + +type Create_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyCreate_audit_policyContext() *Create_audit_policyContext { + var p = new(Create_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_audit_policy + return p +} + +func InitEmptyCreate_audit_policyContext(p *Create_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_audit_policy +} + +func (*Create_audit_policyContext) IsCreate_audit_policyContext() {} + +func NewCreate_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_audit_policyContext { + var p = new(Create_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_audit_policy + + return p +} + +func (s *Create_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Create_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Create_audit_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Create_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Create_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_audit_policyContext) Privilege_audit_clause() IPrivilege_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_audit_clauseContext) +} + +func (s *Create_audit_policyContext) Action_audit_clause() IAction_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAction_audit_clauseContext) +} + +func (s *Create_audit_policyContext) Role_audit_clause() IRole_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_audit_clauseContext) +} + +func (s *Create_audit_policyContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Create_audit_policyContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Create_audit_policyContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Create_audit_policyContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Create_audit_policyContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Create_audit_policyContext) TOPLEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, 0) +} + +func (s *Create_audit_policyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_audit_policyContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Create_audit_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Create_audit_policyContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Create_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_audit_policy(s) + } +} + +func (s *Create_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_audit_policy(s) + } +} + +func (p *PlSqlParser) Create_audit_policy() (localctx ICreate_audit_policyContext) { + localctx = NewCreate_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, PlSqlParserRULE_create_audit_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5717) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5718) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5719) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5720) + + var _x = p.Id_expression() + + localctx.(*Create_audit_policyContext).p = _x + } + p.SetState(5722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(5721) + p.Privilege_audit_clause() + } + + } + p.SetState(5725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACTIONS { + { + p.SetState(5724) + p.Action_audit_clause() + } + + } + p.SetState(5728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserROLES { + { + p.SetState(5727) + p.Role_audit_clause() + } + + } + p.SetState(5736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(5730) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5731) + p.Quoted_string() + } + { + p.SetState(5732) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5733) + p.Match(PlSqlParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5734) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINSTANCE || _la == PlSqlParserSESSION || _la == PlSqlParserSTATEMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLY { + { + p.SetState(5738) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5739) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(5742) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilege_audit_clauseContext is an interface to support dynamic dispatch. +type IPrivilege_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIVILEGES() antlr.TerminalNode + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrivilege_audit_clauseContext differentiates from other interfaces. + IsPrivilege_audit_clauseContext() +} + +type Privilege_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_audit_clauseContext() *Privilege_audit_clauseContext { + var p = new(Privilege_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause + return p +} + +func InitEmptyPrivilege_audit_clauseContext(p *Privilege_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause +} + +func (*Privilege_audit_clauseContext) IsPrivilege_audit_clauseContext() {} + +func NewPrivilege_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_audit_clauseContext { + var p = new(Privilege_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause + + return p +} + +func (s *Privilege_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_audit_clauseContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Privilege_audit_clauseContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Privilege_audit_clauseContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Privilege_audit_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Privilege_audit_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Privilege_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrivilege_audit_clause(s) + } +} + +func (s *Privilege_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrivilege_audit_clause(s) + } +} + +func (p *PlSqlParser) Privilege_audit_clause() (localctx IPrivilege_audit_clauseContext) { + localctx = NewPrivilege_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, PlSqlParserRULE_privilege_audit_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5745) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5746) + p.System_privilege() + } + p.SetState(5751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5747) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5748) + p.System_privilege() + } + + p.SetState(5753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAction_audit_clauseContext is an interface to support dynamic dispatch. +type IAction_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStandard_actions() []IStandard_actionsContext + Standard_actions(i int) IStandard_actionsContext + AllComponent_actions() []IComponent_actionsContext + Component_actions(i int) IComponent_actionsContext + AllSystem_actions() []ISystem_actionsContext + System_actions(i int) ISystem_actionsContext + + // IsAction_audit_clauseContext differentiates from other interfaces. + IsAction_audit_clauseContext() +} + +type Action_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAction_audit_clauseContext() *Action_audit_clauseContext { + var p = new(Action_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_action_audit_clause + return p +} + +func InitEmptyAction_audit_clauseContext(p *Action_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_action_audit_clause +} + +func (*Action_audit_clauseContext) IsAction_audit_clauseContext() {} + +func NewAction_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Action_audit_clauseContext { + var p = new(Action_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_action_audit_clause + + return p +} + +func (s *Action_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Action_audit_clauseContext) AllStandard_actions() []IStandard_actionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStandard_actionsContext); ok { + len++ + } + } + + tst := make([]IStandard_actionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStandard_actionsContext); ok { + tst[i] = t.(IStandard_actionsContext) + i++ + } + } + + return tst +} + +func (s *Action_audit_clauseContext) Standard_actions(i int) IStandard_actionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_actionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStandard_actionsContext) +} + +func (s *Action_audit_clauseContext) AllComponent_actions() []IComponent_actionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComponent_actionsContext); ok { + len++ + } + } + + tst := make([]IComponent_actionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComponent_actionsContext); ok { + tst[i] = t.(IComponent_actionsContext) + i++ + } + } + + return tst +} + +func (s *Action_audit_clauseContext) Component_actions(i int) IComponent_actionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComponent_actionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComponent_actionsContext) +} + +func (s *Action_audit_clauseContext) AllSystem_actions() []ISystem_actionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_actionsContext); ok { + len++ + } + } + + tst := make([]ISystem_actionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_actionsContext); ok { + tst[i] = t.(ISystem_actionsContext) + i++ + } + } + + return tst +} + +func (s *Action_audit_clauseContext) System_actions(i int) ISystem_actionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_actionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_actionsContext) +} + +func (s *Action_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Action_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Action_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAction_audit_clause(s) + } +} + +func (s *Action_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAction_audit_clause(s) + } +} + +func (p *PlSqlParser) Action_audit_clause() (localctx IAction_audit_clauseContext) { + localctx = NewAction_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, PlSqlParserRULE_action_audit_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(5757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 497, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5754) + p.Standard_actions() + } + + case 2: + { + p.SetState(5755) + p.Component_actions() + } + + case 3: + { + p.SetState(5756) + p.System_actions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5759) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 498, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_actionsContext is an interface to support dynamic dispatch. +type ISystem_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSystem_actionsContext differentiates from other interfaces. + IsSystem_actionsContext() +} + +type System_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_actionsContext() *System_actionsContext { + var p = new(System_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_actions + return p +} + +func InitEmptySystem_actionsContext(p *System_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_actions +} + +func (*System_actionsContext) IsSystem_actionsContext() {} + +func NewSystem_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_actionsContext { + var p = new(System_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_actions + + return p +} + +func (s *System_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_actionsContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *System_actionsContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *System_actionsContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *System_actionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *System_actionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *System_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_actions(s) + } +} + +func (s *System_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_actions(s) + } +} + +func (p *PlSqlParser) System_actions() (localctx ISystem_actionsContext) { + localctx = NewSystem_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, PlSqlParserRULE_system_actions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5761) + p.Match(PlSqlParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5762) + p.System_privilege() + } + p.SetState(5767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5763) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5764) + p.System_privilege() + } + + p.SetState(5769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStandard_actionsContext is an interface to support dynamic dispatch. +type IStandard_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + AllActions_clause() []IActions_clauseContext + Actions_clause(i int) IActions_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsStandard_actionsContext differentiates from other interfaces. + IsStandard_actionsContext() +} + +type Standard_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_actionsContext() *Standard_actionsContext { + var p = new(Standard_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_actions + return p +} + +func InitEmptyStandard_actionsContext(p *Standard_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_actions +} + +func (*Standard_actionsContext) IsStandard_actionsContext() {} + +func NewStandard_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_actionsContext { + var p = new(Standard_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_actions + + return p +} + +func (s *Standard_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_actionsContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Standard_actionsContext) AllActions_clause() []IActions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IActions_clauseContext); ok { + len++ + } + } + + tst := make([]IActions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IActions_clauseContext); ok { + tst[i] = t.(IActions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Standard_actionsContext) Actions_clause(i int) IActions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IActions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IActions_clauseContext) +} + +func (s *Standard_actionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Standard_actionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Standard_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_actions(s) + } +} + +func (s *Standard_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_actions(s) + } +} + +func (p *PlSqlParser) Standard_actions() (localctx IStandard_actionsContext) { + localctx = NewStandard_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, PlSqlParserRULE_standard_actions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5770) + p.Match(PlSqlParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5771) + p.Actions_clause() + } + p.SetState(5776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5772) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5773) + p.Actions_clause() + } + + p.SetState(5778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IActions_clauseContext is an interface to support dynamic dispatch. +type IActions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Object_action() IObject_actionContext + ALL() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + Id_expression() IId_expressionContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + System_action() ISystem_actionContext + + // IsActions_clauseContext differentiates from other interfaces. + IsActions_clauseContext() +} + +type Actions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyActions_clauseContext() *Actions_clauseContext { + var p = new(Actions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_actions_clause + return p +} + +func InitEmptyActions_clauseContext(p *Actions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_actions_clause +} + +func (*Actions_clauseContext) IsActions_clauseContext() {} + +func NewActions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Actions_clauseContext { + var p = new(Actions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_actions_clause + + return p +} + +func (s *Actions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Actions_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Actions_clauseContext) Object_action() IObject_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_actionContext) +} + +func (s *Actions_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Actions_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Actions_clauseContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Actions_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Actions_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Actions_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Actions_clauseContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Actions_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Actions_clauseContext) System_action() ISystem_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_actionContext) +} + +func (s *Actions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Actions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Actions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterActions_clause(s) + } +} + +func (s *Actions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitActions_clause(s) + } +} + +func (p *PlSqlParser) Actions_clause() (localctx IActions_clauseContext) { + localctx = NewActions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, PlSqlParserRULE_actions_clause) + p.SetState(5802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER, PlSqlParserAUDIT, PlSqlParserCOMMENT, PlSqlParserDELETE, PlSqlParserEXECUTE, PlSqlParserFLASHBACK, PlSqlParserGRANT, PlSqlParserINDEX, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserREAD, PlSqlParserRENAME, PlSqlParserSELECT, PlSqlParserUPDATE: + { + p.SetState(5779) + p.Object_action() + } + + case PlSqlParserALL: + { + p.SetState(5780) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5783) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 504, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5784) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5785) + p.Directory_name() + } + + case 2: + p.SetState(5788) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) == 1 { + { + p.SetState(5786) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5787) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5793) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 503, p.GetParserRuleContext()) == 1 { + { + p.SetState(5790) + p.Schema_name() + } + { + p.SetState(5791) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5795) + p.Id_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTER, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOCK, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(5798) + p.System_action() + } + + case PlSqlParserALL: + { + p.SetState(5799) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_actionContext is an interface to support dynamic dispatch. +type IObject_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + GRANT() antlr.TerminalNode + READ() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + RENAME() antlr.TerminalNode + + // IsObject_actionContext differentiates from other interfaces. + IsObject_actionContext() +} + +type Object_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_actionContext() *Object_actionContext { + var p = new(Object_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_action + return p +} + +func InitEmptyObject_actionContext(p *Object_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_action +} + +func (*Object_actionContext) IsObject_actionContext() {} + +func NewObject_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_actionContext { + var p = new(Object_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_action + + return p +} + +func (s *Object_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_actionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Object_actionContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Object_actionContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Object_actionContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Object_actionContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Object_actionContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Object_actionContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_actionContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Object_actionContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Object_actionContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Object_actionContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Object_actionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Object_actionContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Object_actionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Object_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_action(s) + } +} + +func (s *Object_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_action(s) + } +} + +func (p *PlSqlParser) Object_action() (localctx IObject_actionContext) { + localctx = NewObject_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, PlSqlParserRULE_object_action) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5804) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserAUDIT || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserEXECUTE || _la == PlSqlParserFLASHBACK || _la == PlSqlParserGRANT || _la == PlSqlParserINDEX || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserRENAME || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_actionContext is an interface to support dynamic dispatch. +type ISystem_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + JAVA() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + LOCK() antlr.TerminalNode + TABLE() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + + // IsSystem_actionContext differentiates from other interfaces. + IsSystem_actionContext() +} + +type System_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_actionContext() *System_actionContext { + var p = new(System_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_action + return p +} + +func InitEmptySystem_actionContext(p *System_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_action +} + +func (*System_actionContext) IsSystem_actionContext() {} + +func NewSystem_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_actionContext { + var p = new(System_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_action + + return p +} + +func (s *System_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_actionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *System_actionContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *System_actionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *System_actionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *System_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *System_actionContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *System_actionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *System_actionContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *System_actionContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *System_actionContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *System_actionContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *System_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_action(s) + } +} + +func (s *System_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_action(s) + } +} + +func (p *PlSqlParser) System_action() (localctx ISystem_actionContext) { + localctx = NewSystem_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, PlSqlParserRULE_system_action) + var _la int + + p.SetState(5813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 507, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5806) + p.Id_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5807) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5808) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5809) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5810) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5811) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXECUTE || _la == PlSqlParserREAD || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5812) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComponent_actionsContext is an interface to support dynamic dispatch. +type IComponent_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + COMPONENT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllComponent_action() []IComponent_actionContext + Component_action(i int) IComponent_actionContext + DV() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PROTOCOL() antlr.TerminalNode + DATAPUMP() antlr.TerminalNode + DIRECT_LOAD() antlr.TerminalNode + OLS() antlr.TerminalNode + XS() antlr.TerminalNode + FTP() antlr.TerminalNode + HTTP() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsComponent_actionsContext differentiates from other interfaces. + IsComponent_actionsContext() +} + +type Component_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComponent_actionsContext() *Component_actionsContext { + var p = new(Component_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_actions + return p +} + +func InitEmptyComponent_actionsContext(p *Component_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_actions +} + +func (*Component_actionsContext) IsComponent_actionsContext() {} + +func NewComponent_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Component_actionsContext { + var p = new(Component_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_component_actions + + return p +} + +func (s *Component_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Component_actionsContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Component_actionsContext) COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENT, 0) +} + +func (s *Component_actionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Component_actionsContext) AllComponent_action() []IComponent_actionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComponent_actionContext); ok { + len++ + } + } + + tst := make([]IComponent_actionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComponent_actionContext); ok { + tst[i] = t.(IComponent_actionContext) + i++ + } + } + + return tst +} + +func (s *Component_actionsContext) Component_action(i int) IComponent_actionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComponent_actionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComponent_actionContext) +} + +func (s *Component_actionsContext) DV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDV, 0) +} + +func (s *Component_actionsContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Component_actionsContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Component_actionsContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Component_actionsContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Component_actionsContext) PROTOCOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTOCOL, 0) +} + +func (s *Component_actionsContext) DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAPUMP, 0) +} + +func (s *Component_actionsContext) DIRECT_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_LOAD, 0) +} + +func (s *Component_actionsContext) OLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLS, 0) +} + +func (s *Component_actionsContext) XS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS, 0) +} + +func (s *Component_actionsContext) FTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFTP, 0) +} + +func (s *Component_actionsContext) HTTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHTTP, 0) +} + +func (s *Component_actionsContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Component_actionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Component_actionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Component_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Component_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Component_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComponent_actions(s) + } +} + +func (s *Component_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComponent_actions(s) + } +} + +func (p *PlSqlParser) Component_actions() (localctx IComponent_actionsContext) { + localctx = NewComponent_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, PlSqlParserRULE_component_actions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5815) + p.Match(PlSqlParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5816) + p.Match(PlSqlParserCOMPONENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5817) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATAPUMP, PlSqlParserDIRECT_LOAD, PlSqlParserOLS, PlSqlParserXS: + { + p.SetState(5818) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAPUMP || _la == PlSqlParserDIRECT_LOAD || _la == PlSqlParserOLS || _la == PlSqlParserXS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5819) + p.Component_action() + } + p.SetState(5824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5820) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5821) + p.Component_action() + } + + p.SetState(5826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDV: + { + p.SetState(5827) + p.Match(PlSqlParserDV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5828) + p.Component_action() + } + { + p.SetState(5829) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5830) + p.Id_expression() + } + p.SetState(5838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5831) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5832) + p.Component_action() + } + { + p.SetState(5833) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5834) + p.Id_expression() + } + + p.SetState(5840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPROTOCOL: + { + p.SetState(5841) + p.Match(PlSqlParserPROTOCOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5842) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTHENTICATION || _la == PlSqlParserFTP || _la == PlSqlParserHTTP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComponent_actionContext is an interface to support dynamic dispatch. +type IComponent_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsComponent_actionContext differentiates from other interfaces. + IsComponent_actionContext() +} + +type Component_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComponent_actionContext() *Component_actionContext { + var p = new(Component_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_action + return p +} + +func InitEmptyComponent_actionContext(p *Component_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_action +} + +func (*Component_actionContext) IsComponent_actionContext() {} + +func NewComponent_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Component_actionContext { + var p = new(Component_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_component_action + + return p +} + +func (s *Component_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Component_actionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Component_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Component_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Component_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComponent_action(s) + } +} + +func (s *Component_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComponent_action(s) + } +} + +func (p *PlSqlParser) Component_action() (localctx IComponent_actionContext) { + localctx = NewComponent_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, PlSqlParserRULE_component_action) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5845) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_audit_clauseContext is an interface to support dynamic dispatch. +type IRole_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLES() antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRole_audit_clauseContext differentiates from other interfaces. + IsRole_audit_clauseContext() +} + +type Role_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_audit_clauseContext() *Role_audit_clauseContext { + var p = new(Role_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_audit_clause + return p +} + +func InitEmptyRole_audit_clauseContext(p *Role_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_audit_clause +} + +func (*Role_audit_clauseContext) IsRole_audit_clauseContext() {} + +func NewRole_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_audit_clauseContext { + var p = new(Role_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_audit_clause + + return p +} + +func (s *Role_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_audit_clauseContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Role_audit_clauseContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Role_audit_clauseContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Role_audit_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Role_audit_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Role_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_audit_clause(s) + } +} + +func (s *Role_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_audit_clause(s) + } +} + +func (p *PlSqlParser) Role_audit_clause() (localctx IRole_audit_clauseContext) { + localctx = NewRole_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, PlSqlParserRULE_role_audit_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5847) + p.Match(PlSqlParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5848) + p.Role_name() + } + p.SetState(5853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5849) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5850) + p.Role_name() + } + + p.SetState(5855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_controlfileContext is an interface to support dynamic dispatch. +type ICreate_controlfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_expression() IId_expressionContext + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + REUSE() antlr.TerminalNode + SET() antlr.TerminalNode + Logfile_clause() ILogfile_clauseContext + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllControlfile_options() []IControlfile_optionsContext + Controlfile_options(i int) IControlfile_optionsContext + Character_set_clause() ICharacter_set_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_controlfileContext differentiates from other interfaces. + IsCreate_controlfileContext() +} + +type Create_controlfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext +} + +func NewEmptyCreate_controlfileContext() *Create_controlfileContext { + var p = new(Create_controlfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_controlfile + return p +} + +func InitEmptyCreate_controlfileContext(p *Create_controlfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_controlfile +} + +func (*Create_controlfileContext) IsCreate_controlfileContext() {} + +func NewCreate_controlfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_controlfileContext { + var p = new(Create_controlfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_controlfile + + return p +} + +func (s *Create_controlfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_controlfileContext) GetD() IId_expressionContext { return s.d } + +func (s *Create_controlfileContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Create_controlfileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_controlfileContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Create_controlfileContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_controlfileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_controlfileContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Create_controlfileContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Create_controlfileContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Create_controlfileContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Create_controlfileContext) Logfile_clause() ILogfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_clauseContext) +} + +func (s *Create_controlfileContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_controlfileContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Create_controlfileContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Create_controlfileContext) AllControlfile_options() []IControlfile_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IControlfile_optionsContext); ok { + len++ + } + } + + tst := make([]IControlfile_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IControlfile_optionsContext); ok { + tst[i] = t.(IControlfile_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_controlfileContext) Controlfile_options(i int) IControlfile_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlfile_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IControlfile_optionsContext) +} + +func (s *Create_controlfileContext) Character_set_clause() ICharacter_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacter_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacter_set_clauseContext) +} + +func (s *Create_controlfileContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_controlfileContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_controlfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_controlfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_controlfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_controlfile(s) + } +} + +func (s *Create_controlfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_controlfile(s) + } +} + +func (p *PlSqlParser) Create_controlfile() (localctx ICreate_controlfileContext) { + localctx = NewCreate_controlfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, PlSqlParserRULE_create_controlfile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5856) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(5858) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(5861) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5864) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5865) + + var _x = p.Id_expression() + + localctx.(*Create_controlfileContext).d = _x + } + p.SetState(5867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGFILE { + { + p.SetState(5866) + p.Logfile_clause() + } + + } + { + p.SetState(5869) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(5870) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5871) + p.File_specification() + } + p.SetState(5876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5872) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5873) + p.File_specification() + } + + p.SetState(5878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(5884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserARCHIVELOG || _la == PlSqlParserFORCE || ((int64((_la-922)) & ^0x3f) == 0 && ((int64(1)<<(_la-922))&121) != 0) || _la == PlSqlParserNOARCHIVELOG || _la == PlSqlParserSET { + { + p.SetState(5881) + p.Controlfile_options() + } + + p.SetState(5886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHARACTER { + { + p.SetState(5887) + p.Character_set_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IControlfile_optionsContext is an interface to support dynamic dispatch. +type IControlfile_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXLOGFILES() antlr.TerminalNode + Numeric() INumericContext + MAXLOGMEMBERS() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + MAXDATAFILES() antlr.TerminalNode + MAXINSTANCES() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FOR() antlr.TerminalNode + DATA() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + LOAD() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + + // IsControlfile_optionsContext differentiates from other interfaces. + IsControlfile_optionsContext() +} + +type Controlfile_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyControlfile_optionsContext() *Controlfile_optionsContext { + var p = new(Controlfile_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_options + return p +} + +func InitEmptyControlfile_optionsContext(p *Controlfile_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_options +} + +func (*Controlfile_optionsContext) IsControlfile_optionsContext() {} + +func NewControlfile_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Controlfile_optionsContext { + var p = new(Controlfile_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_controlfile_options + + return p +} + +func (s *Controlfile_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Controlfile_optionsContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Controlfile_optionsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Controlfile_optionsContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Controlfile_optionsContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Controlfile_optionsContext) MAXDATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, 0) +} + +func (s *Controlfile_optionsContext) MAXINSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, 0) +} + +func (s *Controlfile_optionsContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Controlfile_optionsContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Controlfile_optionsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Controlfile_optionsContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Controlfile_optionsContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Controlfile_optionsContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Controlfile_optionsContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Controlfile_optionsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Controlfile_optionsContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Controlfile_optionsContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Controlfile_optionsContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Controlfile_optionsContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Controlfile_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Controlfile_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Controlfile_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterControlfile_options(s) + } +} + +func (s *Controlfile_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitControlfile_options(s) + } +} + +func (p *PlSqlParser) Controlfile_options() (localctx IControlfile_optionsContext) { + localctx = NewControlfile_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, PlSqlParserRULE_controlfile_options) + p.SetState(5914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAXLOGFILES: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5890) + p.Match(PlSqlParserMAXLOGFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5891) + p.Numeric() + } + + case PlSqlParserMAXLOGMEMBERS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5892) + p.Match(PlSqlParserMAXLOGMEMBERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5893) + p.Numeric() + } + + case PlSqlParserMAXLOGHISTORY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5894) + p.Match(PlSqlParserMAXLOGHISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5895) + p.Numeric() + } + + case PlSqlParserMAXDATAFILES: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5896) + p.Match(PlSqlParserMAXDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5897) + p.Numeric() + } + + case PlSqlParserMAXINSTANCES: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5898) + p.Match(PlSqlParserMAXINSTANCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5899) + p.Numeric() + } + + case PlSqlParserARCHIVELOG: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5900) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOARCHIVELOG: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5901) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5902) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5903) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5904) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5905) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5906) + p.Match(PlSqlParserNOLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5907) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(5908) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5909) + p.Match(PlSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOAD: + { + p.SetState(5910) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5911) + p.Match(PlSqlParserPERFORMANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogfile_clauseContext is an interface to support dynamic dispatch. +type ILogfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + + // IsLogfile_clauseContext differentiates from other interfaces. + IsLogfile_clauseContext() +} + +type Logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_clauseContext() *Logfile_clauseContext { + var p = new(Logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clause + return p +} + +func InitEmptyLogfile_clauseContext(p *Logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clause +} + +func (*Logfile_clauseContext) IsLogfile_clauseContext() {} + +func NewLogfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_clauseContext { + var p = new(Logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_clause + + return p +} + +func (s *Logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_clauseContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Logfile_clauseContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clauseContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Logfile_clauseContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clauseContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Logfile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *Logfile_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *Logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_clause(s) + } +} + +func (s *Logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_clause(s) + } +} + +func (p *PlSqlParser) Logfile_clause() (localctx ILogfile_clauseContext) { + localctx = NewLogfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, PlSqlParserRULE_logfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5916) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT { + p.SetState(5918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(5917) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5920) + p.Numeric() + } + + } + { + p.SetState(5923) + p.File_specification() + } + p.SetState(5934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5924) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT { + p.SetState(5926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(5925) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5928) + p.Numeric() + } + + } + { + p.SetState(5931) + p.File_specification() + } + + p.SetState(5936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICharacter_set_clauseContext is an interface to support dynamic dispatch. +type ICharacter_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCs returns the cs rule contexts. + GetCs() IId_expressionContext + + // SetCs sets the cs rule contexts. + SetCs(IId_expressionContext) + + // Getter signatures + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsCharacter_set_clauseContext differentiates from other interfaces. + IsCharacter_set_clauseContext() +} + +type Character_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cs IId_expressionContext +} + +func NewEmptyCharacter_set_clauseContext() *Character_set_clauseContext { + var p = new(Character_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_character_set_clause + return p +} + +func InitEmptyCharacter_set_clauseContext(p *Character_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_character_set_clause +} + +func (*Character_set_clauseContext) IsCharacter_set_clauseContext() {} + +func NewCharacter_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Character_set_clauseContext { + var p = new(Character_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_character_set_clause + + return p +} + +func (s *Character_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Character_set_clauseContext) GetCs() IId_expressionContext { return s.cs } + +func (s *Character_set_clauseContext) SetCs(v IId_expressionContext) { s.cs = v } + +func (s *Character_set_clauseContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Character_set_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Character_set_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Character_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Character_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Character_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCharacter_set_clause(s) + } +} + +func (s *Character_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCharacter_set_clause(s) + } +} + +func (p *PlSqlParser) Character_set_clause() (localctx ICharacter_set_clauseContext) { + localctx = NewCharacter_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, PlSqlParserRULE_character_set_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5937) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5938) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5939) + + var _x = p.Id_expression() + + localctx.(*Character_set_clauseContext).cs = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_specificationContext is an interface to support dynamic dispatch. +type IFile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datafile_tempfile_spec() IDatafile_tempfile_specContext + Redo_log_file_spec() IRedo_log_file_specContext + + // IsFile_specificationContext differentiates from other interfaces. + IsFile_specificationContext() +} + +type File_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_specificationContext() *File_specificationContext { + var p = new(File_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_specification + return p +} + +func InitEmptyFile_specificationContext(p *File_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_specification +} + +func (*File_specificationContext) IsFile_specificationContext() {} + +func NewFile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_specificationContext { + var p = new(File_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_specification + + return p +} + +func (s *File_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *File_specificationContext) Redo_log_file_spec() IRedo_log_file_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedo_log_file_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedo_log_file_specContext) +} + +func (s *File_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_specification(s) + } +} + +func (s *File_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_specification(s) + } +} + +func (p *PlSqlParser) File_specification() (localctx IFile_specificationContext) { + localctx = NewFile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, PlSqlParserRULE_file_specification) + p.SetState(5943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 526, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5941) + p.Datafile_tempfile_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5942) + p.Redo_log_file_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_diskgroupContext is an interface to support dynamic dispatch. +type ICreate_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAn returns the an token. + GetAn() antlr.Token + + // GetAv returns the av token. + GetAv() antlr.Token + + // SetAn sets the an token. + SetAn(antlr.Token) + + // SetAv sets the av token. + SetAv(antlr.Token) + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetFg returns the fg rule contexts. + GetFg() IId_expressionContext + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetFg sets the fg rule contexts. + SetFg(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + REDUNDANCY() antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllQualified_disk_clause() []IQualified_disk_clauseContext + Qualified_disk_clause(i int) IQualified_disk_clauseContext + ATTRIBUTE() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + HIGH() antlr.TerminalNode + NORMAL() antlr.TerminalNode + FLEX() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SITE() antlr.TerminalNode + + // IsCreate_diskgroupContext differentiates from other interfaces. + IsCreate_diskgroupContext() +} + +type Create_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + sn IId_expressionContext + fg IId_expressionContext + an antlr.Token + av antlr.Token +} + +func NewEmptyCreate_diskgroupContext() *Create_diskgroupContext { + var p = new(Create_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_diskgroup + return p +} + +func InitEmptyCreate_diskgroupContext(p *Create_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_diskgroup +} + +func (*Create_diskgroupContext) IsCreate_diskgroupContext() {} + +func NewCreate_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_diskgroupContext { + var p = new(Create_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_diskgroup + + return p +} + +func (s *Create_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_diskgroupContext) GetAn() antlr.Token { return s.an } + +func (s *Create_diskgroupContext) GetAv() antlr.Token { return s.av } + +func (s *Create_diskgroupContext) SetAn(v antlr.Token) { s.an = v } + +func (s *Create_diskgroupContext) SetAv(v antlr.Token) { s.av = v } + +func (s *Create_diskgroupContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Create_diskgroupContext) GetFg() IId_expressionContext { return s.fg } + +func (s *Create_diskgroupContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Create_diskgroupContext) SetFg(v IId_expressionContext) { s.fg = v } + +func (s *Create_diskgroupContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Create_diskgroupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_diskgroupContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Create_diskgroupContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Create_diskgroupContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Create_diskgroupContext) AllQualified_disk_clause() []IQualified_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_disk_clauseContext); ok { + tst[i] = t.(IQualified_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Qualified_disk_clause(i int) IQualified_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_disk_clauseContext) +} + +func (s *Create_diskgroupContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Create_diskgroupContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Create_diskgroupContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Create_diskgroupContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Create_diskgroupContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Create_diskgroupContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Create_diskgroupContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Create_diskgroupContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Create_diskgroupContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Create_diskgroupContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Create_diskgroupContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Create_diskgroupContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Create_diskgroupContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Create_diskgroupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_diskgroupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_diskgroupContext) SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, 0) +} + +func (s *Create_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_diskgroup(s) + } +} + +func (s *Create_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_diskgroup(s) + } +} + +func (p *PlSqlParser) Create_diskgroup() (localctx ICreate_diskgroupContext) { + localctx = NewCreate_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, PlSqlParserRULE_create_diskgroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5945) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5946) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5947) + p.Id_expression() + } + p.SetState(5960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL || _la == PlSqlParserFLEX || _la == PlSqlParserHIGH || _la == PlSqlParserNORMAL || _la == PlSqlParserEXTENDED { + p.SetState(5957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserHIGH: + { + p.SetState(5948) + p.Match(PlSqlParserHIGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNORMAL: + { + p.SetState(5949) + p.Match(PlSqlParserNORMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFLEX: + { + p.SetState(5950) + p.Match(PlSqlParserFLEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENDED: + { + p.SetState(5951) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSITE { + { + p.SetState(5952) + p.Match(PlSqlParserSITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5953) + + var _x = p.Id_expression() + + localctx.(*Create_diskgroupContext).sn = _x + } + + } + + case PlSqlParserEXTERNAL: + { + p.SetState(5956) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5959) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISK || _la == PlSqlParserFAILGROUP || _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + p.SetState(5963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(5962) + p.Quorum_regular() + } + + } + p.SetState(5967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFAILGROUP { + { + p.SetState(5965) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5966) + + var _x = p.Id_expression() + + localctx.(*Create_diskgroupContext).fg = _x + } + + } + { + p.SetState(5969) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5970) + p.Qualified_disk_clause() + } + p.SetState(5975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5971) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5972) + p.Qualified_disk_clause() + } + + p.SetState(5977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(5980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserATTRIBUTE { + { + p.SetState(5982) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5983) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_diskgroupContext).an = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5984) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5985) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_diskgroupContext).av = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5986) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5987) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5988) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5989) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(5994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualified_disk_clauseContext is an interface to support dynamic dispatch. +type IQualified_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSs returns the ss token. + GetSs() antlr.Token + + // SetSs sets the ss token. + SetSs(antlr.Token) + + // GetDn returns the dn rule contexts. + GetDn() IId_expressionContext + + // SetDn sets the dn rule contexts. + SetDn(IId_expressionContext) + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + NAME() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Force_noforce() IForce_noforceContext + Id_expression() IId_expressionContext + + // IsQualified_disk_clauseContext differentiates from other interfaces. + IsQualified_disk_clauseContext() +} + +type Qualified_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ss antlr.Token + dn IId_expressionContext +} + +func NewEmptyQualified_disk_clauseContext() *Qualified_disk_clauseContext { + var p = new(Qualified_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause + return p +} + +func InitEmptyQualified_disk_clauseContext(p *Qualified_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause +} + +func (*Qualified_disk_clauseContext) IsQualified_disk_clauseContext() {} + +func NewQualified_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_disk_clauseContext { + var p = new(Qualified_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause + + return p +} + +func (s *Qualified_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_disk_clauseContext) GetSs() antlr.Token { return s.ss } + +func (s *Qualified_disk_clauseContext) SetSs(v antlr.Token) { s.ss = v } + +func (s *Qualified_disk_clauseContext) GetDn() IId_expressionContext { return s.dn } + +func (s *Qualified_disk_clauseContext) SetDn(v IId_expressionContext) { s.dn = v } + +func (s *Qualified_disk_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Qualified_disk_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Qualified_disk_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Qualified_disk_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Qualified_disk_clauseContext) Force_noforce() IForce_noforceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Qualified_disk_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Qualified_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQualified_disk_clause(s) + } +} + +func (s *Qualified_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQualified_disk_clause(s) + } +} + +func (p *PlSqlParser) Qualified_disk_clause() (localctx IQualified_disk_clauseContext) { + localctx = NewQualified_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, PlSqlParserRULE_qualified_disk_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5997) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Qualified_disk_clauseContext).ss = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNAME { + { + p.SetState(5998) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5999) + + var _x = p.Id_expression() + + localctx.(*Qualified_disk_clauseContext).dn = _x + } + + } + p.SetState(6004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(6002) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6003) + p.Size_clause() + } + + } + p.SetState(6007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(6006) + p.Force_noforce() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_editionContext is an interface to support dynamic dispatch. +type ICreate_editionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetE returns the e rule contexts. + GetE() IId_expressionContext + + // GetPe returns the pe rule contexts. + GetPe() IId_expressionContext + + // SetE sets the e rule contexts. + SetE(IId_expressionContext) + + // SetPe sets the pe rule contexts. + SetPe(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + EDITION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AS() antlr.TerminalNode + CHILD() antlr.TerminalNode + OF() antlr.TerminalNode + + // IsCreate_editionContext differentiates from other interfaces. + IsCreate_editionContext() +} + +type Create_editionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + e IId_expressionContext + pe IId_expressionContext +} + +func NewEmptyCreate_editionContext() *Create_editionContext { + var p = new(Create_editionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_edition + return p +} + +func InitEmptyCreate_editionContext(p *Create_editionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_edition +} + +func (*Create_editionContext) IsCreate_editionContext() {} + +func NewCreate_editionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_editionContext { + var p = new(Create_editionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_edition + + return p +} + +func (s *Create_editionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_editionContext) GetE() IId_expressionContext { return s.e } + +func (s *Create_editionContext) GetPe() IId_expressionContext { return s.pe } + +func (s *Create_editionContext) SetE(v IId_expressionContext) { s.e = v } + +func (s *Create_editionContext) SetPe(v IId_expressionContext) { s.pe = v } + +func (s *Create_editionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_editionContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Create_editionContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_editionContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_editionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_editionContext) CHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, 0) +} + +func (s *Create_editionContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_editionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_editionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_editionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_edition(s) + } +} + +func (s *Create_editionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_edition(s) + } +} + +func (p *PlSqlParser) Create_edition() (localctx ICreate_editionContext) { + localctx = NewCreate_editionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, PlSqlParserRULE_create_edition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6009) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6010) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6011) + + var _x = p.Id_expression() + + localctx.(*Create_editionContext).e = _x + } + p.SetState(6016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(6012) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6013) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6014) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6015) + + var _x = p.Id_expression() + + localctx.(*Create_editionContext).pe = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_flashback_archiveContext is an interface to support dynamic dispatch. +type ICreate_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Flashback_archive_retention() IFlashback_archive_retentionContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DEFAULT() antlr.TerminalNode + Flashback_archive_quota() IFlashback_archive_quotaContext + OPTIMIZE() antlr.TerminalNode + DATA() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsCreate_flashback_archiveContext differentiates from other interfaces. + IsCreate_flashback_archiveContext() +} + +type Create_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext + ts IId_expressionContext +} + +func NewEmptyCreate_flashback_archiveContext() *Create_flashback_archiveContext { + var p = new(Create_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_flashback_archive + return p +} + +func InitEmptyCreate_flashback_archiveContext(p *Create_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_flashback_archive +} + +func (*Create_flashback_archiveContext) IsCreate_flashback_archiveContext() {} + +func NewCreate_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_flashback_archiveContext { + var p = new(Create_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_flashback_archive + + return p +} + +func (s *Create_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Create_flashback_archiveContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Create_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Create_flashback_archiveContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Create_flashback_archiveContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Create_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Create_flashback_archiveContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Create_flashback_archiveContext) Flashback_archive_retention() IFlashback_archive_retentionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_retentionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_retentionContext) +} + +func (s *Create_flashback_archiveContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_flashback_archiveContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_flashback_archiveContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Create_flashback_archiveContext) Flashback_archive_quota() IFlashback_archive_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_quotaContext) +} + +func (s *Create_flashback_archiveContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Create_flashback_archiveContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_flashback_archiveContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_flashback_archive(s) + } +} + +func (s *Create_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_flashback_archive(s) + } +} + +func (p *PlSqlParser) Create_flashback_archive() (localctx ICreate_flashback_archiveContext) { + localctx = NewCreate_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, PlSqlParserRULE_create_flashback_archive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6018) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6019) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6020) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(6021) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6024) + + var _x = p.Id_expression() + + localctx.(*Create_flashback_archiveContext).fa = _x + } + { + p.SetState(6025) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6026) + + var _x = p.Id_expression() + + localctx.(*Create_flashback_archiveContext).ts = _x + } + p.SetState(6028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUOTA { + { + p.SetState(6027) + p.Flashback_archive_quota() + } + + } + p.SetState(6035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserOPTIMIZE { + p.SetState(6031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(6030) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6033) + p.Match(PlSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6034) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6037) + p.Flashback_archive_retention() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_archive_quotaContext is an interface to support dynamic dispatch. +type IFlashback_archive_quotaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTA() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + + // IsFlashback_archive_quotaContext differentiates from other interfaces. + IsFlashback_archive_quotaContext() +} + +type Flashback_archive_quotaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_archive_quotaContext() *Flashback_archive_quotaContext { + var p = new(Flashback_archive_quotaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota + return p +} + +func InitEmptyFlashback_archive_quotaContext(p *Flashback_archive_quotaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota +} + +func (*Flashback_archive_quotaContext) IsFlashback_archive_quotaContext() {} + +func NewFlashback_archive_quotaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_quotaContext { + var p = new(Flashback_archive_quotaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota + + return p +} + +func (s *Flashback_archive_quotaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_quotaContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Flashback_archive_quotaContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Flashback_archive_quotaContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_quotaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_quotaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_quota(s) + } +} + +func (s *Flashback_archive_quotaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_quota(s) + } +} + +func (p *PlSqlParser) Flashback_archive_quota() (localctx IFlashback_archive_quotaContext) { + localctx = NewFlashback_archive_quotaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, PlSqlParserRULE_flashback_archive_quota) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6039) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6040) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6041) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserE_LETTER || _la == PlSqlParserG_LETTER || _la == PlSqlParserM_LETTER || _la == PlSqlParserP_LETTER || _la == PlSqlParserT_LETTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_archive_retentionContext is an interface to support dynamic dispatch. +type IFlashback_archive_retentionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + DAY() antlr.TerminalNode + + // IsFlashback_archive_retentionContext differentiates from other interfaces. + IsFlashback_archive_retentionContext() +} + +type Flashback_archive_retentionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_archive_retentionContext() *Flashback_archive_retentionContext { + var p = new(Flashback_archive_retentionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention + return p +} + +func InitEmptyFlashback_archive_retentionContext(p *Flashback_archive_retentionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention +} + +func (*Flashback_archive_retentionContext) IsFlashback_archive_retentionContext() {} + +func NewFlashback_archive_retentionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_retentionContext { + var p = new(Flashback_archive_retentionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention + + return p +} + +func (s *Flashback_archive_retentionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_retentionContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Flashback_archive_retentionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Flashback_archive_retentionContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Flashback_archive_retentionContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Flashback_archive_retentionContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Flashback_archive_retentionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_retentionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_retentionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_retention(s) + } +} + +func (s *Flashback_archive_retentionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_retention(s) + } +} + +func (p *PlSqlParser) Flashback_archive_retention() (localctx IFlashback_archive_retentionContext) { + localctx = NewFlashback_archive_retentionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, PlSqlParserRULE_flashback_archive_retention) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6043) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6044) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6045) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserMONTH || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_hierarchyContext is an interface to support dynamic dispatch. +type ICreate_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Hier_using_clause() IHier_using_clauseContext + Level_hier_clause() ILevel_hier_clauseContext + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FORCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Hier_attrs_clause() IHier_attrs_clauseContext + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsCreate_hierarchyContext differentiates from other interfaces. + IsCreate_hierarchyContext() +} + +type Create_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + h IId_expressionContext +} + +func NewEmptyCreate_hierarchyContext() *Create_hierarchyContext { + var p = new(Create_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_hierarchy + return p +} + +func InitEmptyCreate_hierarchyContext(p *Create_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_hierarchy +} + +func (*Create_hierarchyContext) IsCreate_hierarchyContext() {} + +func NewCreate_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_hierarchyContext { + var p = new(Create_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_hierarchy + + return p +} + +func (s *Create_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_hierarchyContext) GetH() IId_expressionContext { return s.h } + +func (s *Create_hierarchyContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Create_hierarchyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Create_hierarchyContext) Hier_using_clause() IHier_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_using_clauseContext) +} + +func (s *Create_hierarchyContext) Level_hier_clause() ILevel_hier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_hier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILevel_hier_clauseContext) +} + +func (s *Create_hierarchyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_hierarchyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_hierarchyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_hierarchyContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_hierarchyContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_hierarchyContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_hierarchyContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_hierarchyContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_hierarchyContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_hierarchyContext) Hier_attrs_clause() IHier_attrs_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attrs_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attrs_clauseContext) +} + +func (s *Create_hierarchyContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_hierarchyContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_hierarchyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_hierarchy(s) + } +} + +func (s *Create_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_hierarchy(s) + } +} + +func (p *PlSqlParser) Create_hierarchy() (localctx ICreate_hierarchyContext) { + localctx = NewCreate_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, PlSqlParserRULE_create_hierarchy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6047) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(6048) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6049) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNO { + p.SetState(6053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(6052) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6055) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6058) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6062) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 547, p.GetParserRuleContext()) == 1 { + { + p.SetState(6059) + p.Schema_name() + } + { + p.SetState(6060) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6064) + + var _x = p.Id_expression() + + localctx.(*Create_hierarchyContext).h = _x + } + p.SetState(6068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(6065) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6066) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6067) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(6070) + p.Classification_clause() + } + + p.SetState(6075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6076) + p.Hier_using_clause() + } + { + p.SetState(6077) + p.Level_hier_clause() + } + p.SetState(6079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIERARCHICAL { + { + p.SetState(6078) + p.Hier_attrs_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_using_clauseContext is an interface to support dynamic dispatch. +type IHier_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + USING() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsHier_using_clauseContext differentiates from other interfaces. + IsHier_using_clauseContext() +} + +type Hier_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyHier_using_clauseContext() *Hier_using_clauseContext { + var p = new(Hier_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_using_clause + return p +} + +func InitEmptyHier_using_clauseContext(p *Hier_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_using_clause +} + +func (*Hier_using_clauseContext) IsHier_using_clauseContext() {} + +func NewHier_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_using_clauseContext { + var p = new(Hier_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_using_clause + + return p +} + +func (s *Hier_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_using_clauseContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Hier_using_clauseContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Hier_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Hier_using_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Hier_using_clauseContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Hier_using_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Hier_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_using_clause(s) + } +} + +func (s *Hier_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_using_clause(s) + } +} + +func (p *PlSqlParser) Hier_using_clause() (localctx IHier_using_clauseContext) { + localctx = NewHier_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, PlSqlParserRULE_hier_using_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6081) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 551, p.GetParserRuleContext()) == 1 { + { + p.SetState(6082) + p.Schema_name() + } + { + p.SetState(6083) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6087) + + var _x = p.Id_expression() + + localctx.(*Hier_using_clauseContext).ad = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_hier_clauseContext is an interface to support dynamic dispatch. +type ILevel_hier_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCHILD() []antlr.TerminalNode + CHILD(i int) antlr.TerminalNode + AllOF() []antlr.TerminalNode + OF(i int) antlr.TerminalNode + + // IsLevel_hier_clauseContext differentiates from other interfaces. + IsLevel_hier_clauseContext() +} + +type Level_hier_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + l IId_expressionContext +} + +func NewEmptyLevel_hier_clauseContext() *Level_hier_clauseContext { + var p = new(Level_hier_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_hier_clause + return p +} + +func InitEmptyLevel_hier_clauseContext(p *Level_hier_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_hier_clause +} + +func (*Level_hier_clauseContext) IsLevel_hier_clauseContext() {} + +func NewLevel_hier_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_hier_clauseContext { + var p = new(Level_hier_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_hier_clause + + return p +} + +func (s *Level_hier_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_hier_clauseContext) GetL() IId_expressionContext { return s.l } + +func (s *Level_hier_clauseContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Level_hier_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_hier_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_hier_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Level_hier_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_hier_clauseContext) AllCHILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHILD) +} + +func (s *Level_hier_clauseContext) CHILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, i) +} + +func (s *Level_hier_clauseContext) AllOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOF) +} + +func (s *Level_hier_clauseContext) OF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, i) +} + +func (s *Level_hier_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_hier_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_hier_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_hier_clause(s) + } +} + +func (s *Level_hier_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_hier_clause(s) + } +} + +func (p *PlSqlParser) Level_hier_clause() (localctx ILevel_hier_clauseContext) { + localctx = NewLevel_hier_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, PlSqlParserRULE_level_hier_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6089) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(6090) + + var _x = p.Id_expression() + + localctx.(*Level_hier_clauseContext).l = _x + } + p.SetState(6093) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) == 1 { + { + p.SetState(6091) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6092) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.SetState(6097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6099) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_attrs_clauseContext is an interface to support dynamic dispatch. +type IHier_attrs_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HIERARCHICAL() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Hier_attr_clause() IHier_attr_clauseContext + RIGHT_PAREN() antlr.TerminalNode + + // IsHier_attrs_clauseContext differentiates from other interfaces. + IsHier_attrs_clauseContext() +} + +type Hier_attrs_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attrs_clauseContext() *Hier_attrs_clauseContext { + var p = new(Hier_attrs_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause + return p +} + +func InitEmptyHier_attrs_clauseContext(p *Hier_attrs_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause +} + +func (*Hier_attrs_clauseContext) IsHier_attrs_clauseContext() {} + +func NewHier_attrs_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attrs_clauseContext { + var p = new(Hier_attrs_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause + + return p +} + +func (s *Hier_attrs_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attrs_clauseContext) HIERARCHICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHICAL, 0) +} + +func (s *Hier_attrs_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Hier_attrs_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hier_attrs_clauseContext) Hier_attr_clause() IHier_attr_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attr_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attr_clauseContext) +} + +func (s *Hier_attrs_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hier_attrs_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attrs_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attrs_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attrs_clause(s) + } +} + +func (s *Hier_attrs_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attrs_clause(s) + } +} + +func (p *PlSqlParser) Hier_attrs_clause() (localctx IHier_attrs_clauseContext) { + localctx = NewHier_attrs_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, PlSqlParserRULE_hier_attrs_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6101) + p.Match(PlSqlParserHIERARCHICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6102) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6103) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6104) + p.Hier_attr_clause() + } + { + p.SetState(6105) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_attr_clauseContext is an interface to support dynamic dispatch. +type IHier_attr_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Hier_attr_name() IHier_attr_nameContext + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + + // IsHier_attr_clauseContext differentiates from other interfaces. + IsHier_attr_clauseContext() +} + +type Hier_attr_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attr_clauseContext() *Hier_attr_clauseContext { + var p = new(Hier_attr_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_clause + return p +} + +func InitEmptyHier_attr_clauseContext(p *Hier_attr_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_clause +} + +func (*Hier_attr_clauseContext) IsHier_attr_clauseContext() {} + +func NewHier_attr_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attr_clauseContext { + var p = new(Hier_attr_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attr_clause + + return p +} + +func (s *Hier_attr_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attr_clauseContext) Hier_attr_name() IHier_attr_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attr_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attr_nameContext) +} + +func (s *Hier_attr_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Hier_attr_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Hier_attr_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attr_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attr_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attr_clause(s) + } +} + +func (s *Hier_attr_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attr_clause(s) + } +} + +func (p *PlSqlParser) Hier_attr_clause() (localctx IHier_attr_clauseContext) { + localctx = NewHier_attr_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, PlSqlParserRULE_hier_attr_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6107) + p.Hier_attr_name() + } + p.SetState(6111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(6108) + p.Classification_clause() + } + + p.SetState(6113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_attr_nameContext is an interface to support dynamic dispatch. +type IHier_attr_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER_NAME() antlr.TerminalNode + MEMBER_UNIQUE_NAME() antlr.TerminalNode + MEMBER_CAPTION() antlr.TerminalNode + MEMBER_DESCRIPTION() antlr.TerminalNode + LEVEL_NAME() antlr.TerminalNode + HIER_ORDER() antlr.TerminalNode + DEPTH() antlr.TerminalNode + IS_LEAF() antlr.TerminalNode + PARENT_LEVEL_NAME() antlr.TerminalNode + PARENT_UNIQUE_NAME() antlr.TerminalNode + + // IsHier_attr_nameContext differentiates from other interfaces. + IsHier_attr_nameContext() +} + +type Hier_attr_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attr_nameContext() *Hier_attr_nameContext { + var p = new(Hier_attr_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_name + return p +} + +func InitEmptyHier_attr_nameContext(p *Hier_attr_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_name +} + +func (*Hier_attr_nameContext) IsHier_attr_nameContext() {} + +func NewHier_attr_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attr_nameContext { + var p = new(Hier_attr_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attr_name + + return p +} + +func (s *Hier_attr_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attr_nameContext) MEMBER_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_NAME, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_UNIQUE_NAME, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_CAPTION, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_DESCRIPTION, 0) +} + +func (s *Hier_attr_nameContext) LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL_NAME, 0) +} + +func (s *Hier_attr_nameContext) HIER_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIER_ORDER, 0) +} + +func (s *Hier_attr_nameContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Hier_attr_nameContext) IS_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS_LEAF, 0) +} + +func (s *Hier_attr_nameContext) PARENT_LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_LEVEL_NAME, 0) +} + +func (s *Hier_attr_nameContext) PARENT_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_UNIQUE_NAME, 0) +} + +func (s *Hier_attr_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attr_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attr_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attr_name(s) + } +} + +func (s *Hier_attr_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attr_name(s) + } +} + +func (p *PlSqlParser) Hier_attr_name() (localctx IHier_attr_nameContext) { + localctx = NewHier_attr_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, PlSqlParserRULE_hier_attr_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6114) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEPTH || _la == PlSqlParserHIER_ORDER || _la == PlSqlParserIS_LEAF || _la == PlSqlParserLEVEL_NAME || ((int64((_la-937)) & ^0x3f) == 0 && ((int64(1)<<(_la-937))&15) != 0) || _la == PlSqlParserPARENT_LEVEL_NAME || _la == PlSqlParserPARENT_UNIQUE_NAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_indexContext is an interface to support dynamic dispatch. +type ICreate_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + ON() antlr.TerminalNode + Cluster_index_clause() ICluster_index_clauseContext + Table_index_clause() ITable_index_clauseContext + Bitmap_join_index_clause() IBitmap_join_index_clauseContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + INVALIDATION() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + BITMAP() antlr.TerminalNode + USABLE() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + + // IsCreate_indexContext differentiates from other interfaces. + IsCreate_indexContext() +} + +type Create_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_indexContext() *Create_indexContext { + var p = new(Create_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_index + return p +} + +func InitEmptyCreate_indexContext(p *Create_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_index +} + +func (*Create_indexContext) IsCreate_indexContext() {} + +func NewCreate_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_indexContext { + var p = new(Create_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_index + + return p +} + +func (s *Create_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Create_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Create_indexContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_indexContext) Cluster_index_clause() ICluster_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_index_clauseContext) +} + +func (s *Create_indexContext) Table_index_clause() ITable_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_index_clauseContext) +} + +func (s *Create_indexContext) Bitmap_join_index_clause() IBitmap_join_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitmap_join_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitmap_join_index_clauseContext) +} + +func (s *Create_indexContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_indexContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_indexContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_indexContext) INVALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATION, 0) +} + +func (s *Create_indexContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Create_indexContext) BITMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP, 0) +} + +func (s *Create_indexContext) USABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSABLE, 0) +} + +func (s *Create_indexContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Create_indexContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Create_indexContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Create_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_index(s) + } +} + +func (s *Create_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_index(s) + } +} + +func (p *PlSqlParser) Create_index() (localctx ICreate_indexContext) { + localctx = NewCreate_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, PlSqlParserRULE_create_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6116) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBITMAP || _la == PlSqlParserUNIQUE { + { + p.SetState(6117) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBITMAP || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6120) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6121) + p.Index_name() + } + p.SetState(6125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(6122) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6123) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6124) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6127) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 557, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6128) + p.Cluster_index_clause() + } + + case 2: + { + p.SetState(6129) + p.Table_index_clause() + } + + case 3: + { + p.SetState(6130) + p.Bitmap_join_index_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE || _la == PlSqlParserUSABLE { + { + p.SetState(6133) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNUSABLE || _la == PlSqlParserUSABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE { + { + p.SetState(6136) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6137) + p.Match(PlSqlParserINVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_index_clauseContext is an interface to support dynamic dispatch. +type ICluster_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + Index_attributes() IIndex_attributesContext + + // IsCluster_index_clauseContext differentiates from other interfaces. + IsCluster_index_clauseContext() +} + +type Cluster_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_index_clauseContext() *Cluster_index_clauseContext { + var p = new(Cluster_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_index_clause + return p +} + +func InitEmptyCluster_index_clauseContext(p *Cluster_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_index_clause +} + +func (*Cluster_index_clauseContext) IsCluster_index_clauseContext() {} + +func NewCluster_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_index_clauseContext { + var p = new(Cluster_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_index_clause + + return p +} + +func (s *Cluster_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_index_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Cluster_index_clauseContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Cluster_index_clauseContext) Index_attributes() IIndex_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Cluster_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_index_clause(s) + } +} + +func (s *Cluster_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_index_clause(s) + } +} + +func (p *PlSqlParser) Cluster_index_clause() (localctx ICluster_index_clauseContext) { + localctx = NewCluster_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, PlSqlParserRULE_cluster_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6140) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6141) + p.Cluster_name() + } + p.SetState(6143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserINVISIBLE || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || ((int64((_la-1333)) & ^0x3f) == 0 && ((int64(1)<<(_la-1333))&618475290625) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(6142) + p.Index_attributes() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_nameContext is an interface to support dynamic dispatch. +type ICluster_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsCluster_nameContext differentiates from other interfaces. + IsCluster_nameContext() +} + +type Cluster_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_nameContext() *Cluster_nameContext { + var p = new(Cluster_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_name + return p +} + +func InitEmptyCluster_nameContext(p *Cluster_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_name +} + +func (*Cluster_nameContext) IsCluster_nameContext() {} + +func NewCluster_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_nameContext { + var p = new(Cluster_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_name + + return p +} + +func (s *Cluster_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cluster_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cluster_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Cluster_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_name(s) + } +} + +func (s *Cluster_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_name(s) + } +} + +func (p *PlSqlParser) Cluster_name() (localctx ICluster_nameContext) { + localctx = NewCluster_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, PlSqlParserRULE_cluster_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(6148) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 561, p.GetParserRuleContext()) == 1 { + { + p.SetState(6145) + p.Id_expression() + } + { + p.SetState(6146) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6150) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_index_clauseContext is an interface to support dynamic dispatch. +type ITable_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + AllIndex_expr() []IIndex_exprContext + Index_expr(i int) IIndex_exprContext + RIGHT_PAREN() antlr.TerminalNode + Table_alias() ITable_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Index_properties() IIndex_propertiesContext + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + + // IsTable_index_clauseContext differentiates from other interfaces. + IsTable_index_clauseContext() +} + +type Table_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_index_clauseContext() *Table_index_clauseContext { + var p = new(Table_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_index_clause + return p +} + +func InitEmptyTable_index_clauseContext(p *Table_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_index_clause +} + +func (*Table_index_clauseContext) IsTable_index_clauseContext() {} + +func NewTable_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_index_clauseContext { + var p = new(Table_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_index_clause + + return p +} + +func (s *Table_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_index_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Table_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_index_clauseContext) AllIndex_expr() []IIndex_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_exprContext); ok { + len++ + } + } + + tst := make([]IIndex_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_exprContext); ok { + tst[i] = t.(IIndex_exprContext) + i++ + } + } + + return tst +} + +func (s *Table_index_clauseContext) Index_expr(i int) IIndex_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_exprContext) +} + +func (s *Table_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_index_clauseContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Table_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Table_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Table_index_clauseContext) Index_properties() IIndex_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_propertiesContext) +} + +func (s *Table_index_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserASC) +} + +func (s *Table_index_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, i) +} + +func (s *Table_index_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDESC) +} + +func (s *Table_index_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, i) +} + +func (s *Table_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_index_clause(s) + } +} + +func (s *Table_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_index_clause(s) + } +} + +func (p *PlSqlParser) Table_index_clause() (localctx ITable_index_clauseContext) { + localctx = NewTable_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, PlSqlParserRULE_table_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6152) + p.Tableview_name() + } + p.SetState(6154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(6153) + p.Table_alias() + } + + } + { + p.SetState(6156) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6157) + p.Index_expr() + } + p.SetState(6159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6158) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6161) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6162) + p.Index_expr() + } + p.SetState(6164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6163) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + p.SetState(6170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6171) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserGLOBAL || ((int64((_la-731)) & ^0x3f) == 0 && ((int64(1)<<(_la-731))&2251799813689345) != 0) || ((int64((_la-873)) & ^0x3f) == 0 && ((int64(1)<<(_la-873))&288230376151713793) != 0) || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || ((int64((_la-1333)) & ^0x3f) == 0 && ((int64(1)<<(_la-1333))&618475290625) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(6172) + p.Index_properties() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBitmap_join_index_clauseContext is an interface to support dynamic dispatch. +type IBitmap_join_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + FROM() antlr.TerminalNode + AllTable_alias() []ITable_aliasContext + Table_alias(i int) ITable_aliasContext + Where_clause() IWhere_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Local_partitioned_index() ILocal_partitioned_indexContext + Index_attributes() IIndex_attributesContext + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + + // IsBitmap_join_index_clauseContext differentiates from other interfaces. + IsBitmap_join_index_clauseContext() +} + +type Bitmap_join_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitmap_join_index_clauseContext() *Bitmap_join_index_clauseContext { + var p = new(Bitmap_join_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause + return p +} + +func InitEmptyBitmap_join_index_clauseContext(p *Bitmap_join_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause +} + +func (*Bitmap_join_index_clauseContext) IsBitmap_join_index_clauseContext() {} + +func NewBitmap_join_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bitmap_join_index_clauseContext { + var p = new(Bitmap_join_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause + + return p +} + +func (s *Bitmap_join_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bitmap_join_index_clauseContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Bitmap_join_index_clauseContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Bitmap_join_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Bitmap_join_index_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Bitmap_join_index_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Bitmap_join_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Bitmap_join_index_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Bitmap_join_index_clauseContext) AllTable_alias() []ITable_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_aliasContext); ok { + len++ + } + } + + tst := make([]ITable_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_aliasContext); ok { + tst[i] = t.(ITable_aliasContext) + i++ + } + } + + return tst +} + +func (s *Bitmap_join_index_clauseContext) Table_alias(i int) ITable_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Bitmap_join_index_clauseContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Bitmap_join_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Bitmap_join_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Bitmap_join_index_clauseContext) Local_partitioned_index() ILocal_partitioned_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_partitioned_indexContext) +} + +func (s *Bitmap_join_index_clauseContext) Index_attributes() IIndex_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Bitmap_join_index_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserASC) +} + +func (s *Bitmap_join_index_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, i) +} + +func (s *Bitmap_join_index_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDESC) +} + +func (s *Bitmap_join_index_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, i) +} + +func (s *Bitmap_join_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bitmap_join_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bitmap_join_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBitmap_join_index_clause(s) + } +} + +func (s *Bitmap_join_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBitmap_join_index_clause(s) + } +} + +func (p *PlSqlParser) Bitmap_join_index_clause() (localctx IBitmap_join_index_clauseContext) { + localctx = NewBitmap_join_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, PlSqlParserRULE_bitmap_join_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6175) + p.Tableview_name() + } + { + p.SetState(6176) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6179) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 { + { + p.SetState(6177) + p.Tableview_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 2 { + { + p.SetState(6178) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6181) + p.Column_name() + } + p.SetState(6183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6182) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6185) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6188) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 569, p.GetParserRuleContext()) == 1 { + { + p.SetState(6186) + p.Tableview_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 569, p.GetParserRuleContext()) == 2 { + { + p.SetState(6187) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6190) + p.Column_name() + } + p.SetState(6192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6191) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + p.SetState(6198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6199) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6200) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6201) + p.Tableview_name() + } + { + p.SetState(6202) + p.Table_alias() + } + p.SetState(6209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6203) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6204) + p.Tableview_name() + } + { + p.SetState(6205) + p.Table_alias() + } + + p.SetState(6211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6212) + p.Where_clause() + } + p.SetState(6214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(6213) + p.Local_partitioned_index() + } + + } + p.SetState(6217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserINVISIBLE || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || ((int64((_la-1333)) & ^0x3f) == 0 && ((int64(1)<<(_la-1333))&618475290625) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(6216) + p.Index_attributes() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_exprContext is an interface to support dynamic dispatch. +type IIndex_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Expression() IExpressionContext + + // IsIndex_exprContext differentiates from other interfaces. + IsIndex_exprContext() +} + +type Index_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_exprContext() *Index_exprContext { + var p = new(Index_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr + return p +} + +func InitEmptyIndex_exprContext(p *Index_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr +} + +func (*Index_exprContext) IsIndex_exprContext() {} + +func NewIndex_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_exprContext { + var p = new(Index_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_expr + + return p +} + +func (s *Index_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_exprContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Index_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Index_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_expr(s) + } +} + +func (s *Index_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_expr(s) + } +} + +func (p *PlSqlParser) Index_expr() (localctx IIndex_exprContext) { + localctx = NewIndex_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, PlSqlParserRULE_index_expr) + p.SetState(6221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 575, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6219) + p.Column_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6220) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_propertiesContext is an interface to support dynamic dispatch. +type IIndex_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGlobal_partitioned_index() []IGlobal_partitioned_indexContext + Global_partitioned_index(i int) IGlobal_partitioned_indexContext + AllLocal_partitioned_index() []ILocal_partitioned_indexContext + Local_partitioned_index(i int) ILocal_partitioned_indexContext + AllIndex_attributes() []IIndex_attributesContext + Index_attributes(i int) IIndex_attributesContext + INDEXTYPE() antlr.TerminalNode + IS() antlr.TerminalNode + Domain_index_clause() IDomain_index_clauseContext + Xmlindex_clause() IXmlindex_clauseContext + + // IsIndex_propertiesContext differentiates from other interfaces. + IsIndex_propertiesContext() +} + +type Index_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_propertiesContext() *Index_propertiesContext { + var p = new(Index_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_properties + return p +} + +func InitEmptyIndex_propertiesContext(p *Index_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_properties +} + +func (*Index_propertiesContext) IsIndex_propertiesContext() {} + +func NewIndex_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_propertiesContext { + var p = new(Index_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_properties + + return p +} + +func (s *Index_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_propertiesContext) AllGlobal_partitioned_index() []IGlobal_partitioned_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGlobal_partitioned_indexContext); ok { + len++ + } + } + + tst := make([]IGlobal_partitioned_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGlobal_partitioned_indexContext); ok { + tst[i] = t.(IGlobal_partitioned_indexContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Global_partitioned_index(i int) IGlobal_partitioned_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGlobal_partitioned_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGlobal_partitioned_indexContext) +} + +func (s *Index_propertiesContext) AllLocal_partitioned_index() []ILocal_partitioned_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + len++ + } + } + + tst := make([]ILocal_partitioned_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILocal_partitioned_indexContext); ok { + tst[i] = t.(ILocal_partitioned_indexContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Local_partitioned_index(i int) ILocal_partitioned_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILocal_partitioned_indexContext) +} + +func (s *Index_propertiesContext) AllIndex_attributes() []IIndex_attributesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_attributesContext); ok { + len++ + } + } + + tst := make([]IIndex_attributesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_attributesContext); ok { + tst[i] = t.(IIndex_attributesContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Index_attributes(i int) IIndex_attributesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Index_propertiesContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Index_propertiesContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Index_propertiesContext) Domain_index_clause() IDomain_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDomain_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDomain_index_clauseContext) +} + +func (s *Index_propertiesContext) Xmlindex_clause() IXmlindex_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlindex_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlindex_clauseContext) +} + +func (s *Index_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_properties(s) + } +} + +func (s *Index_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_properties(s) + } +} + +func (p *PlSqlParser) Index_properties() (localctx IIndex_propertiesContext) { + localctx = NewIndex_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, PlSqlParserRULE_index_properties) + var _alt int + + p.SetState(6236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserGLOBAL, PlSqlParserINITRANS, PlSqlParserINVISIBLE, PlSqlParserLOCAL, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserNOSORT, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREVERSE, PlSqlParserSORT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserVISIBLE: + p.EnterOuterAlt(localctx, 1) + p.SetState(6226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(6226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGLOBAL: + { + p.SetState(6223) + p.Global_partitioned_index() + } + + case PlSqlParserLOCAL: + { + p.SetState(6224) + p.Local_partitioned_index() + } + + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserINVISIBLE, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserNOSORT, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREVERSE, PlSqlParserSORT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserVISIBLE: + { + p.SetState(6225) + p.Index_attributes() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6228) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserINDEXTYPE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6230) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6231) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(6232) + p.Domain_index_clause() + } + + case PlSqlParserXDB, PlSqlParserXMLINDEX: + { + p.SetState(6233) + p.Xmlindex_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDomain_index_clauseContext is an interface to support dynamic dispatch. +type IDomain_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Indextype() IIndextypeContext + Local_domain_index_clause() ILocal_domain_index_clauseContext + Parallel_clause() IParallel_clauseContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + + // IsDomain_index_clauseContext differentiates from other interfaces. + IsDomain_index_clauseContext() +} + +type Domain_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDomain_index_clauseContext() *Domain_index_clauseContext { + var p = new(Domain_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain_index_clause + return p +} + +func InitEmptyDomain_index_clauseContext(p *Domain_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain_index_clause +} + +func (*Domain_index_clauseContext) IsDomain_index_clauseContext() {} + +func NewDomain_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Domain_index_clauseContext { + var p = new(Domain_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_domain_index_clause + + return p +} + +func (s *Domain_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Domain_index_clauseContext) Indextype() IIndextypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndextypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndextypeContext) +} + +func (s *Domain_index_clauseContext) Local_domain_index_clause() ILocal_domain_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_domain_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_domain_index_clauseContext) +} + +func (s *Domain_index_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Domain_index_clauseContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Domain_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Domain_index_clauseContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Domain_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Domain_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Domain_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Domain_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDomain_index_clause(s) + } +} + +func (s *Domain_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDomain_index_clause(s) + } +} + +func (p *PlSqlParser) Domain_index_clause() (localctx IDomain_index_clauseContext) { + localctx = NewDomain_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, PlSqlParserRULE_domain_index_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6238) + p.Indextype() + } + p.SetState(6240) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 1 { + { + p.SetState(6239) + p.Local_domain_index_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6243) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 581, p.GetParserRuleContext()) == 1 { + { + p.SetState(6242) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) == 1 { + { + p.SetState(6245) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6246) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Odci_parameters() + } + { + p.SetState(6248) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_domain_index_clauseContext is an interface to support dynamic dispatch. +type ILocal_domain_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllPARAMETERS() []antlr.TerminalNode + PARAMETERS(i int) antlr.TerminalNode + AllOdci_parameters() []IOdci_parametersContext + Odci_parameters(i int) IOdci_parametersContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLocal_domain_index_clauseContext differentiates from other interfaces. + IsLocal_domain_index_clauseContext() +} + +type Local_domain_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_domain_index_clauseContext() *Local_domain_index_clauseContext { + var p = new(Local_domain_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause + return p +} + +func InitEmptyLocal_domain_index_clauseContext(p *Local_domain_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause +} + +func (*Local_domain_index_clauseContext) IsLocal_domain_index_clauseContext() {} + +func NewLocal_domain_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_domain_index_clauseContext { + var p = new(Local_domain_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause + + return p +} + +func (s *Local_domain_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_domain_index_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_domain_index_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Local_domain_index_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Local_domain_index_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Local_domain_index_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Local_domain_index_clauseContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Local_domain_index_clauseContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Local_domain_index_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Local_domain_index_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Local_domain_index_clauseContext) AllPARAMETERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARAMETERS) +} + +func (s *Local_domain_index_clauseContext) PARAMETERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, i) +} + +func (s *Local_domain_index_clauseContext) AllOdci_parameters() []IOdci_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOdci_parametersContext); ok { + len++ + } + } + + tst := make([]IOdci_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOdci_parametersContext); ok { + tst[i] = t.(IOdci_parametersContext) + i++ + } + } + + return tst +} + +func (s *Local_domain_index_clauseContext) Odci_parameters(i int) IOdci_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Local_domain_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Local_domain_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Local_domain_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_domain_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_domain_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_domain_index_clause(s) + } +} + +func (s *Local_domain_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_domain_index_clause(s) + } +} + +func (p *PlSqlParser) Local_domain_index_clause() (localctx ILocal_domain_index_clauseContext) { + localctx = NewLocal_domain_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, PlSqlParserRULE_local_domain_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6252) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6253) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6254) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6255) + p.Partition_name() + } + p.SetState(6261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(6256) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6257) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6258) + p.Odci_parameters() + } + { + p.SetState(6259) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6263) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6264) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6265) + p.Partition_name() + } + p.SetState(6271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(6266) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6267) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6268) + p.Odci_parameters() + } + { + p.SetState(6269) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(6277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6278) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlindex_clauseContext is an interface to support dynamic dispatch. +type IXmlindex_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLINDEX() antlr.TerminalNode + XDB() antlr.TerminalNode + PERIOD() antlr.TerminalNode + Local_xmlindex_clause() ILocal_xmlindex_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsXmlindex_clauseContext differentiates from other interfaces. + IsXmlindex_clauseContext() +} + +type Xmlindex_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlindex_clauseContext() *Xmlindex_clauseContext { + var p = new(Xmlindex_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlindex_clause + return p +} + +func InitEmptyXmlindex_clauseContext(p *Xmlindex_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlindex_clause +} + +func (*Xmlindex_clauseContext) IsXmlindex_clauseContext() {} + +func NewXmlindex_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlindex_clauseContext { + var p = new(Xmlindex_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlindex_clause + + return p +} + +func (s *Xmlindex_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlindex_clauseContext) XMLINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX, 0) +} + +func (s *Xmlindex_clauseContext) XDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserXDB, 0) +} + +func (s *Xmlindex_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Xmlindex_clauseContext) Local_xmlindex_clause() ILocal_xmlindex_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_xmlindex_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_xmlindex_clauseContext) +} + +func (s *Xmlindex_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Xmlindex_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlindex_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlindex_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlindex_clause(s) + } +} + +func (s *Xmlindex_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlindex_clause(s) + } +} + +func (p *PlSqlParser) Xmlindex_clause() (localctx IXmlindex_clauseContext) { + localctx = NewXmlindex_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, PlSqlParserRULE_xmlindex_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXDB { + { + p.SetState(6282) + p.Match(PlSqlParserXDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6283) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6286) + p.Match(PlSqlParserXMLINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6288) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + { + p.SetState(6287) + p.Local_xmlindex_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6291) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 589, p.GetParserRuleContext()) == 1 { + { + p.SetState(6290) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_xmlindex_clauseContext is an interface to support dynamic dispatch. +type ILocal_xmlindex_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLocal_xmlindex_clauseContext differentiates from other interfaces. + IsLocal_xmlindex_clauseContext() +} + +type Local_xmlindex_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_xmlindex_clauseContext() *Local_xmlindex_clauseContext { + var p = new(Local_xmlindex_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause + return p +} + +func InitEmptyLocal_xmlindex_clauseContext(p *Local_xmlindex_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause +} + +func (*Local_xmlindex_clauseContext) IsLocal_xmlindex_clauseContext() {} + +func NewLocal_xmlindex_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_xmlindex_clauseContext { + var p = new(Local_xmlindex_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause + + return p +} + +func (s *Local_xmlindex_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_xmlindex_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_xmlindex_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Local_xmlindex_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Local_xmlindex_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Local_xmlindex_clauseContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Local_xmlindex_clauseContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Local_xmlindex_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Local_xmlindex_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Local_xmlindex_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Local_xmlindex_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_xmlindex_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_xmlindex_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_xmlindex_clause(s) + } +} + +func (s *Local_xmlindex_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_xmlindex_clause(s) + } +} + +func (p *PlSqlParser) Local_xmlindex_clause() (localctx ILocal_xmlindex_clauseContext) { + localctx = NewLocal_xmlindex_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, PlSqlParserRULE_local_xmlindex_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6293) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6294) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6295) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6296) + p.Partition_name() + } + p.SetState(6302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6297) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6298) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6299) + p.Partition_name() + } + + p.SetState(6304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6305) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGlobal_partitioned_indexContext is an interface to support dynamic dispatch. +type IGlobal_partitioned_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GLOBAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllIndex_partitioning_clause() []IIndex_partitioning_clauseContext + Index_partitioning_clause(i int) IIndex_partitioning_clauseContext + HASH() antlr.TerminalNode + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGlobal_partitioned_indexContext differentiates from other interfaces. + IsGlobal_partitioned_indexContext() +} + +type Global_partitioned_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGlobal_partitioned_indexContext() *Global_partitioned_indexContext { + var p = new(Global_partitioned_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_global_partitioned_index + return p +} + +func InitEmptyGlobal_partitioned_indexContext(p *Global_partitioned_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_global_partitioned_index +} + +func (*Global_partitioned_indexContext) IsGlobal_partitioned_indexContext() {} + +func NewGlobal_partitioned_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Global_partitioned_indexContext { + var p = new(Global_partitioned_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_global_partitioned_index + + return p +} + +func (s *Global_partitioned_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Global_partitioned_indexContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Global_partitioned_indexContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Global_partitioned_indexContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Global_partitioned_indexContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Global_partitioned_indexContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Global_partitioned_indexContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Global_partitioned_indexContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Global_partitioned_indexContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Global_partitioned_indexContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Global_partitioned_indexContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Global_partitioned_indexContext) AllIndex_partitioning_clause() []IIndex_partitioning_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_partitioning_clauseContext); ok { + len++ + } + } + + tst := make([]IIndex_partitioning_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_partitioning_clauseContext); ok { + tst[i] = t.(IIndex_partitioning_clauseContext) + i++ + } + } + + return tst +} + +func (s *Global_partitioned_indexContext) Index_partitioning_clause(i int) IIndex_partitioning_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partitioning_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partitioning_clauseContext) +} + +func (s *Global_partitioned_indexContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Global_partitioned_indexContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Global_partitioned_indexContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Global_partitioned_indexContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Global_partitioned_indexContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Global_partitioned_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Global_partitioned_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Global_partitioned_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGlobal_partitioned_index(s) + } +} + +func (s *Global_partitioned_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGlobal_partitioned_index(s) + } +} + +func (p *PlSqlParser) Global_partitioned_index() (localctx IGlobal_partitioned_indexContext) { + localctx = NewGlobal_partitioned_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, PlSqlParserRULE_global_partitioned_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6309) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6310) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6311) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRANGE: + { + p.SetState(6312) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6313) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6314) + p.Column_name() + } + p.SetState(6319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6315) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6316) + p.Column_name() + } + + p.SetState(6321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6322) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6323) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6324) + p.Index_partitioning_clause() + } + p.SetState(6329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6325) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6326) + p.Index_partitioning_clause() + } + + p.SetState(6331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6332) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASH: + { + p.SetState(6334) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6335) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6336) + p.Column_name() + } + p.SetState(6341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6337) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6338) + p.Column_name() + } + + p.SetState(6343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6344) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(6345) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(6346) + p.Hash_partitions_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_partitioning_clauseContext is an interface to support dynamic dispatch. +type IIndex_partitioning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + VALUES() antlr.TerminalNode + LESS() antlr.TerminalNode + THAN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Index_partitioning_values_list() IIndex_partitioning_values_listContext + RIGHT_PAREN() antlr.TerminalNode + Partition_name() IPartition_nameContext + Segment_attributes_clause() ISegment_attributes_clauseContext + + // IsIndex_partitioning_clauseContext differentiates from other interfaces. + IsIndex_partitioning_clauseContext() +} + +type Index_partitioning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partitioning_clauseContext() *Index_partitioning_clauseContext { + var p = new(Index_partitioning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause + return p +} + +func InitEmptyIndex_partitioning_clauseContext(p *Index_partitioning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause +} + +func (*Index_partitioning_clauseContext) IsIndex_partitioning_clauseContext() {} + +func NewIndex_partitioning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partitioning_clauseContext { + var p = new(Index_partitioning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause + + return p +} + +func (s *Index_partitioning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partitioning_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Index_partitioning_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Index_partitioning_clauseContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Index_partitioning_clauseContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Index_partitioning_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_partitioning_clauseContext) Index_partitioning_values_list() IIndex_partitioning_values_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partitioning_values_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partitioning_values_listContext) +} + +func (s *Index_partitioning_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_partitioning_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Index_partitioning_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_partitioning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partitioning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partitioning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_partitioning_clause(s) + } +} + +func (s *Index_partitioning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_partitioning_clause(s) + } +} + +func (p *PlSqlParser) Index_partitioning_clause() (localctx IIndex_partitioning_clauseContext) { + localctx = NewIndex_partitioning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, PlSqlParserRULE_index_partitioning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6351) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(6352) + p.Partition_name() + } + + } + { + p.SetState(6355) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6356) + p.Match(PlSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6357) + p.Match(PlSqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6358) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6359) + p.Index_partitioning_values_list() + } + { + p.SetState(6360) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(6361) + p.Segment_attributes_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_partitioning_values_listContext is an interface to support dynamic dispatch. +type IIndex_partitioning_values_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTIMESTAMP() []antlr.TerminalNode + TIMESTAMP(i int) antlr.TerminalNode + + // IsIndex_partitioning_values_listContext differentiates from other interfaces. + IsIndex_partitioning_values_listContext() +} + +type Index_partitioning_values_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partitioning_values_listContext() *Index_partitioning_values_listContext { + var p = new(Index_partitioning_values_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_values_list + return p +} + +func InitEmptyIndex_partitioning_values_listContext(p *Index_partitioning_values_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_values_list +} + +func (*Index_partitioning_values_listContext) IsIndex_partitioning_values_listContext() {} + +func NewIndex_partitioning_values_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partitioning_values_listContext { + var p = new(Index_partitioning_values_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_partitioning_values_list + + return p +} + +func (s *Index_partitioning_values_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partitioning_values_listContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Index_partitioning_values_listContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Index_partitioning_values_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Index_partitioning_values_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Index_partitioning_values_listContext) AllTIMESTAMP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIMESTAMP) +} + +func (s *Index_partitioning_values_listContext) TIMESTAMP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, i) +} + +func (s *Index_partitioning_values_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partitioning_values_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partitioning_values_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_partitioning_values_list(s) + } +} + +func (s *Index_partitioning_values_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_partitioning_values_list(s) + } +} + +func (p *PlSqlParser) Index_partitioning_values_list() (localctx IIndex_partitioning_values_listContext) { + localctx = NewIndex_partitioning_values_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, PlSqlParserRULE_index_partitioning_values_list) + var _la int + + p.SetState(6382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserMINUS_SIGN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6364) + p.Literal() + } + p.SetState(6369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6365) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6366) + p.Literal() + } + + p.SetState(6371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6372) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6373) + p.Literal() + } + p.SetState(6379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6374) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6375) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6376) + p.Literal() + } + + p.SetState(6381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_partitioned_indexContext is an interface to support dynamic dispatch. +type ILocal_partitioned_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + On_range_partitioned_table() IOn_range_partitioned_tableContext + On_list_partitioned_table() IOn_list_partitioned_tableContext + On_hash_partitioned_table() IOn_hash_partitioned_tableContext + On_comp_partitioned_table() IOn_comp_partitioned_tableContext + + // IsLocal_partitioned_indexContext differentiates from other interfaces. + IsLocal_partitioned_indexContext() +} + +type Local_partitioned_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_partitioned_indexContext() *Local_partitioned_indexContext { + var p = new(Local_partitioned_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_partitioned_index + return p +} + +func InitEmptyLocal_partitioned_indexContext(p *Local_partitioned_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_partitioned_index +} + +func (*Local_partitioned_indexContext) IsLocal_partitioned_indexContext() {} + +func NewLocal_partitioned_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_partitioned_indexContext { + var p = new(Local_partitioned_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_partitioned_index + + return p +} + +func (s *Local_partitioned_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_partitioned_indexContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_partitioned_indexContext) On_range_partitioned_table() IOn_range_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_range_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_range_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_list_partitioned_table() IOn_list_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_list_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_list_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_hash_partitioned_table() IOn_hash_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_hash_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_hash_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_comp_partitioned_table() IOn_comp_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_comp_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_comp_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_partitioned_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_partitioned_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_partitioned_index(s) + } +} + +func (s *Local_partitioned_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_partitioned_index(s) + } +} + +func (p *PlSqlParser) Local_partitioned_index() (localctx ILocal_partitioned_indexContext) { + localctx = NewLocal_partitioned_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, PlSqlParserRULE_local_partitioned_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6384) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 1 { + { + p.SetState(6385) + p.On_range_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 2 { + { + p.SetState(6386) + p.On_list_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 3 { + { + p.SetState(6387) + p.On_hash_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 4 { + { + p.SetState(6388) + p.On_comp_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_range_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_range_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPartitioned_table() []IPartitioned_tableContext + Partitioned_table(i int) IPartitioned_tableContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_range_partitioned_tableContext differentiates from other interfaces. + IsOn_range_partitioned_tableContext() +} + +type On_range_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_range_partitioned_tableContext() *On_range_partitioned_tableContext { + var p = new(On_range_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table + return p +} + +func InitEmptyOn_range_partitioned_tableContext(p *On_range_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table +} + +func (*On_range_partitioned_tableContext) IsOn_range_partitioned_tableContext() {} + +func NewOn_range_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_range_partitioned_tableContext { + var p = new(On_range_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table + + return p +} + +func (s *On_range_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_range_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_range_partitioned_tableContext) AllPartitioned_table() []IPartitioned_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioned_tableContext); ok { + len++ + } + } + + tst := make([]IPartitioned_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioned_tableContext); ok { + tst[i] = t.(IPartitioned_tableContext) + i++ + } + } + + return tst +} + +func (s *On_range_partitioned_tableContext) Partitioned_table(i int) IPartitioned_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioned_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioned_tableContext) +} + +func (s *On_range_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_range_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_range_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_range_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_range_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_range_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_range_partitioned_table(s) + } +} + +func (s *On_range_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_range_partitioned_table(s) + } +} + +func (p *PlSqlParser) On_range_partitioned_table() (localctx IOn_range_partitioned_tableContext) { + localctx = NewOn_range_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, PlSqlParserRULE_on_range_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6391) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6392) + p.Partitioned_table() + } + p.SetState(6397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6393) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6394) + p.Partitioned_table() + } + + p.SetState(6399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6400) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_list_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_list_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPartitioned_table() []IPartitioned_tableContext + Partitioned_table(i int) IPartitioned_tableContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_list_partitioned_tableContext differentiates from other interfaces. + IsOn_list_partitioned_tableContext() +} + +type On_list_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_list_partitioned_tableContext() *On_list_partitioned_tableContext { + var p = new(On_list_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table + return p +} + +func InitEmptyOn_list_partitioned_tableContext(p *On_list_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table +} + +func (*On_list_partitioned_tableContext) IsOn_list_partitioned_tableContext() {} + +func NewOn_list_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_list_partitioned_tableContext { + var p = new(On_list_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table + + return p +} + +func (s *On_list_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_list_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_list_partitioned_tableContext) AllPartitioned_table() []IPartitioned_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioned_tableContext); ok { + len++ + } + } + + tst := make([]IPartitioned_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioned_tableContext); ok { + tst[i] = t.(IPartitioned_tableContext) + i++ + } + } + + return tst +} + +func (s *On_list_partitioned_tableContext) Partitioned_table(i int) IPartitioned_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioned_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioned_tableContext) +} + +func (s *On_list_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_list_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_list_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_list_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_list_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_list_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_list_partitioned_table(s) + } +} + +func (s *On_list_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_list_partitioned_table(s) + } +} + +func (p *PlSqlParser) On_list_partitioned_table() (localctx IOn_list_partitioned_tableContext) { + localctx = NewOn_list_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, PlSqlParserRULE_on_list_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6402) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6403) + p.Partitioned_table() + } + p.SetState(6408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6404) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6405) + p.Partitioned_table() + } + + p.SetState(6410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6411) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitioned_tableContext is an interface to support dynamic dispatch. +type IPartitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsPartitioned_tableContext differentiates from other interfaces. + IsPartitioned_tableContext() +} + +type Partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitioned_tableContext() *Partitioned_tableContext { + var p = new(Partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioned_table + return p +} + +func InitEmptyPartitioned_tableContext(p *Partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioned_table +} + +func (*Partitioned_tableContext) IsPartitioned_tableContext() {} + +func NewPartitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partitioned_tableContext { + var p = new(Partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partitioned_table + + return p +} + +func (s *Partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partitioned_tableContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partitioned_tableContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partitioned_tableContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Partitioned_tableContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Partitioned_tableContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioned_tableContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Partitioned_tableContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartitioned_table(s) + } +} + +func (s *Partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartitioned_table(s) + } +} + +func (p *PlSqlParser) Partitioned_table() (localctx IPartitioned_tableContext) { + localctx = NewPartitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, PlSqlParserRULE_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6413) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 605, p.GetParserRuleContext()) == 1 { + { + p.SetState(6414) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6417) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6418) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6424) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_hash_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_hash_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllOn_hash_partitioned_clause() []IOn_hash_partitioned_clauseContext + On_hash_partitioned_clause(i int) IOn_hash_partitioned_clauseContext + + // IsOn_hash_partitioned_tableContext differentiates from other interfaces. + IsOn_hash_partitioned_tableContext() +} + +type On_hash_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_hash_partitioned_tableContext() *On_hash_partitioned_tableContext { + var p = new(On_hash_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table + return p +} + +func InitEmptyOn_hash_partitioned_tableContext(p *On_hash_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table +} + +func (*On_hash_partitioned_tableContext) IsOn_hash_partitioned_tableContext() {} + +func NewOn_hash_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_hash_partitioned_tableContext { + var p = new(On_hash_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table + + return p +} + +func (s *On_hash_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_hash_partitioned_tableContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *On_hash_partitioned_tableContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *On_hash_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_hash_partitioned_tableContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *On_hash_partitioned_tableContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_hash_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_hash_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_hash_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_hash_partitioned_tableContext) AllOn_hash_partitioned_clause() []IOn_hash_partitioned_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + len++ + } + } + + tst := make([]IOn_hash_partitioned_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + tst[i] = t.(IOn_hash_partitioned_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_hash_partitioned_tableContext) On_hash_partitioned_clause(i int) IOn_hash_partitioned_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_hash_partitioned_clauseContext) +} + +func (s *On_hash_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_hash_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_hash_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_hash_partitioned_table(s) + } +} + +func (s *On_hash_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_hash_partitioned_table(s) + } +} + +func (p *PlSqlParser) On_hash_partitioned_table() (localctx IOn_hash_partitioned_tableContext) { + localctx = NewOn_hash_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, PlSqlParserRULE_on_hash_partitioned_table) + var _la int + + p.SetState(6451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6427) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6428) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6429) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6430) + p.Tablespace() + } + p.SetState(6435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6431) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6432) + p.Tablespace() + } + + p.SetState(6437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6438) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6440) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6441) + p.On_hash_partitioned_clause() + } + p.SetState(6446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6442) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6443) + p.On_hash_partitioned_clause() + } + + p.SetState(6448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6449) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_hash_partitioned_clauseContext is an interface to support dynamic dispatch. +type IOn_hash_partitioned_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsOn_hash_partitioned_clauseContext differentiates from other interfaces. + IsOn_hash_partitioned_clauseContext() +} + +type On_hash_partitioned_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_hash_partitioned_clauseContext() *On_hash_partitioned_clauseContext { + var p = new(On_hash_partitioned_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause + return p +} + +func InitEmptyOn_hash_partitioned_clauseContext(p *On_hash_partitioned_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause +} + +func (*On_hash_partitioned_clauseContext) IsOn_hash_partitioned_clauseContext() {} + +func NewOn_hash_partitioned_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_hash_partitioned_clauseContext { + var p = new(On_hash_partitioned_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause + + return p +} + +func (s *On_hash_partitioned_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_hash_partitioned_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *On_hash_partitioned_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *On_hash_partitioned_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *On_hash_partitioned_clauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_hash_partitioned_clauseContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *On_hash_partitioned_clauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *On_hash_partitioned_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_hash_partitioned_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_hash_partitioned_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_hash_partitioned_clause(s) + } +} + +func (s *On_hash_partitioned_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_hash_partitioned_clause(s) + } +} + +func (p *PlSqlParser) On_hash_partitioned_clause() (localctx IOn_hash_partitioned_clauseContext) { + localctx = NewOn_hash_partitioned_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, PlSqlParserRULE_on_hash_partitioned_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6453) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6455) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 612, p.GetParserRuleContext()) == 1 { + { + p.SetState(6454) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6457) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6458) + p.Tablespace() + } + + } + p.SetState(6462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6461) + p.Key_compression() + } + + } + p.SetState(6465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6464) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_comp_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_comp_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllOn_comp_partitioned_clause() []IOn_comp_partitioned_clauseContext + On_comp_partitioned_clause(i int) IOn_comp_partitioned_clauseContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_comp_partitioned_tableContext differentiates from other interfaces. + IsOn_comp_partitioned_tableContext() +} + +type On_comp_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_comp_partitioned_tableContext() *On_comp_partitioned_tableContext { + var p = new(On_comp_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table + return p +} + +func InitEmptyOn_comp_partitioned_tableContext(p *On_comp_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table +} + +func (*On_comp_partitioned_tableContext) IsOn_comp_partitioned_tableContext() {} + +func NewOn_comp_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_comp_partitioned_tableContext { + var p = new(On_comp_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table + + return p +} + +func (s *On_comp_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_comp_partitioned_tableContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *On_comp_partitioned_tableContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *On_comp_partitioned_tableContext) AllOn_comp_partitioned_clause() []IOn_comp_partitioned_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + len++ + } + } + + tst := make([]IOn_comp_partitioned_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + tst[i] = t.(IOn_comp_partitioned_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_tableContext) On_comp_partitioned_clause(i int) IOn_comp_partitioned_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_comp_partitioned_clauseContext) +} + +func (s *On_comp_partitioned_tableContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *On_comp_partitioned_tableContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *On_comp_partitioned_tableContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *On_comp_partitioned_tableContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *On_comp_partitioned_tableContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_tableContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_comp_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_comp_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_comp_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_comp_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_comp_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_comp_partitioned_table(s) + } +} + +func (s *On_comp_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_comp_partitioned_table(s) + } +} + +func (p *PlSqlParser) On_comp_partitioned_table() (localctx IOn_comp_partitioned_tableContext) { + localctx = NewOn_comp_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, PlSqlParserRULE_on_comp_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(6467) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6468) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6469) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6470) + p.Tablespace() + } + p.SetState(6475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6471) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6472) + p.Tablespace() + } + + p.SetState(6477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6478) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6482) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6483) + p.On_comp_partitioned_clause() + } + p.SetState(6488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6484) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6485) + p.On_comp_partitioned_clause() + } + + p.SetState(6490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6491) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_comp_partitioned_clauseContext is an interface to support dynamic dispatch. +type IOn_comp_partitioned_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + UNUSABLE() antlr.TerminalNode + Index_subpartition_clause() IIndex_subpartition_clauseContext + + // IsOn_comp_partitioned_clauseContext differentiates from other interfaces. + IsOn_comp_partitioned_clauseContext() +} + +type On_comp_partitioned_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_comp_partitioned_clauseContext() *On_comp_partitioned_clauseContext { + var p = new(On_comp_partitioned_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause + return p +} + +func InitEmptyOn_comp_partitioned_clauseContext(p *On_comp_partitioned_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause +} + +func (*On_comp_partitioned_clauseContext) IsOn_comp_partitioned_clauseContext() {} + +func NewOn_comp_partitioned_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_comp_partitioned_clauseContext { + var p = new(On_comp_partitioned_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause + + return p +} + +func (s *On_comp_partitioned_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_comp_partitioned_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *On_comp_partitioned_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *On_comp_partitioned_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *On_comp_partitioned_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *On_comp_partitioned_clauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *On_comp_partitioned_clauseContext) Index_subpartition_clause() IIndex_subpartition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_clauseContext) +} + +func (s *On_comp_partitioned_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_comp_partitioned_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_comp_partitioned_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_comp_partitioned_clause(s) + } +} + +func (s *On_comp_partitioned_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_comp_partitioned_clause(s) + } +} + +func (p *PlSqlParser) On_comp_partitioned_clause() (localctx IOn_comp_partitioned_clauseContext) { + localctx = NewOn_comp_partitioned_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, PlSqlParserRULE_on_comp_partitioned_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6493) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6495) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 619, p.GetParserRuleContext()) == 1 { + { + p.SetState(6494) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6497) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6498) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6504) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6507) + p.Index_subpartition_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_subpartition_clauseContext is an interface to support dynamic dispatch. +type IIndex_subpartition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllIndex_subpartition_subclause() []IIndex_subpartition_subclauseContext + Index_subpartition_subclause(i int) IIndex_subpartition_subclauseContext + + // IsIndex_subpartition_clauseContext differentiates from other interfaces. + IsIndex_subpartition_clauseContext() +} + +type Index_subpartition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_subpartition_clauseContext() *Index_subpartition_clauseContext { + var p = new(Index_subpartition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause + return p +} + +func InitEmptyIndex_subpartition_clauseContext(p *Index_subpartition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause +} + +func (*Index_subpartition_clauseContext) IsIndex_subpartition_clauseContext() {} + +func NewIndex_subpartition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_subpartition_clauseContext { + var p = new(Index_subpartition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause + + return p +} + +func (s *Index_subpartition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_subpartition_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Index_subpartition_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Index_subpartition_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_subpartition_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Index_subpartition_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_subpartition_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_subpartition_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Index_subpartition_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Index_subpartition_clauseContext) AllIndex_subpartition_subclause() []IIndex_subpartition_subclauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + len++ + } + } + + tst := make([]IIndex_subpartition_subclauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + tst[i] = t.(IIndex_subpartition_subclauseContext) + i++ + } + } + + return tst +} + +func (s *Index_subpartition_clauseContext) Index_subpartition_subclause(i int) IIndex_subpartition_subclauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_subclauseContext) +} + +func (s *Index_subpartition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_subpartition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_subpartition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_subpartition_clause(s) + } +} + +func (s *Index_subpartition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_subpartition_clause(s) + } +} + +func (p *PlSqlParser) Index_subpartition_clause() (localctx IIndex_subpartition_clauseContext) { + localctx = NewIndex_subpartition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, PlSqlParserRULE_index_subpartition_clause) + var _la int + + p.SetState(6534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6510) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6511) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6512) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6513) + p.Tablespace() + } + p.SetState(6518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6514) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6515) + p.Tablespace() + } + + p.SetState(6520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6521) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6523) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6524) + p.Index_subpartition_subclause() + } + p.SetState(6529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6525) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6526) + p.Index_subpartition_subclause() + } + + p.SetState(6531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6532) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_subpartition_subclauseContext is an interface to support dynamic dispatch. +type IIndex_subpartition_subclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsIndex_subpartition_subclauseContext differentiates from other interfaces. + IsIndex_subpartition_subclauseContext() +} + +type Index_subpartition_subclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_subpartition_subclauseContext() *Index_subpartition_subclauseContext { + var p = new(Index_subpartition_subclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause + return p +} + +func InitEmptyIndex_subpartition_subclauseContext(p *Index_subpartition_subclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause +} + +func (*Index_subpartition_subclauseContext) IsIndex_subpartition_subclauseContext() {} + +func NewIndex_subpartition_subclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_subpartition_subclauseContext { + var p = new(Index_subpartition_subclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause + + return p +} + +func (s *Index_subpartition_subclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_subpartition_subclauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Index_subpartition_subclauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Index_subpartition_subclauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Index_subpartition_subclauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_subpartition_subclauseContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_subpartition_subclauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Index_subpartition_subclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_subpartition_subclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_subpartition_subclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_subpartition_subclause(s) + } +} + +func (s *Index_subpartition_subclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_subpartition_subclause(s) + } +} + +func (p *PlSqlParser) Index_subpartition_subclause() (localctx IIndex_subpartition_subclauseContext) { + localctx = NewIndex_subpartition_subclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, PlSqlParserRULE_index_subpartition_subclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6536) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6538) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) == 1 { + { + p.SetState(6537) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6540) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6541) + p.Tablespace() + } + + } + p.SetState(6545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6544) + p.Key_compression() + } + + } + p.SetState(6548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6547) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOdci_parametersContext is an interface to support dynamic dispatch. +type IOdci_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsOdci_parametersContext differentiates from other interfaces. + IsOdci_parametersContext() +} + +type Odci_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOdci_parametersContext() *Odci_parametersContext { + var p = new(Odci_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_odci_parameters + return p +} + +func InitEmptyOdci_parametersContext(p *Odci_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_odci_parameters +} + +func (*Odci_parametersContext) IsOdci_parametersContext() {} + +func NewOdci_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Odci_parametersContext { + var p = new(Odci_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_odci_parameters + + return p +} + +func (s *Odci_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Odci_parametersContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Odci_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Odci_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Odci_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOdci_parameters(s) + } +} + +func (s *Odci_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOdci_parameters(s) + } +} + +func (p *PlSqlParser) Odci_parameters() (localctx IOdci_parametersContext) { + localctx = NewOdci_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, PlSqlParserRULE_odci_parameters) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6550) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndextypeContext is an interface to support dynamic dispatch. +type IIndextypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsIndextypeContext differentiates from other interfaces. + IsIndextypeContext() +} + +type IndextypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndextypeContext() *IndextypeContext { + var p = new(IndextypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype + return p +} + +func InitEmptyIndextypeContext(p *IndextypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype +} + +func (*IndextypeContext) IsIndextypeContext() {} + +func NewIndextypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndextypeContext { + var p = new(IndextypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indextype + + return p +} + +func (s *IndextypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndextypeContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *IndextypeContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *IndextypeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *IndextypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndextypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndextypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndextype(s) + } +} + +func (s *IndextypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndextype(s) + } +} + +func (p *PlSqlParser) Indextype() (localctx IIndextypeContext) { + localctx = NewIndextypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, PlSqlParserRULE_indextype) + p.EnterOuterAlt(localctx, 1) + p.SetState(6555) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 631, p.GetParserRuleContext()) == 1 { + { + p.SetState(6552) + p.Id_expression() + } + { + p.SetState(6553) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6557) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_indexContext is an interface to support dynamic dispatch. +type IAlter_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + Alter_index_ops_set1() IAlter_index_ops_set1Context + Alter_index_ops_set2() IAlter_index_ops_set2Context + + // IsAlter_indexContext differentiates from other interfaces. + IsAlter_indexContext() +} + +type Alter_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_indexContext() *Alter_indexContext { + var p = new(Alter_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index + return p +} + +func InitEmptyAlter_indexContext(p *Alter_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index +} + +func (*Alter_indexContext) IsAlter_indexContext() {} + +func NewAlter_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_indexContext { + var p = new(Alter_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index + + return p +} + +func (s *Alter_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_indexContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Alter_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Alter_indexContext) Alter_index_ops_set1() IAlter_index_ops_set1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_ops_set1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_ops_set1Context) +} + +func (s *Alter_indexContext) Alter_index_ops_set2() IAlter_index_ops_set2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_ops_set2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_ops_set2Context) +} + +func (s *Alter_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index(s) + } +} + +func (s *Alter_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index(s) + } +} + +func (p *PlSqlParser) Alter_index() (localctx IAlter_indexContext) { + localctx = NewAlter_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, PlSqlParserRULE_alter_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6559) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6560) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6561) + p.Index_name() + } + p.SetState(6564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE, PlSqlParserCOMPUTE, PlSqlParserDEALLOCATE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSHRINK, PlSqlParserSTORAGE: + { + p.SetState(6562) + p.Alter_index_ops_set1() + } + + case PlSqlParserADD, PlSqlParserCOALESCE, PlSqlParserCOMPILE, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserINVISIBLE, PlSqlParserMODIFY, PlSqlParserMONITORING, PlSqlParserNOMONITORING, PlSqlParserPARAMETERS, PlSqlParserREBUILD, PlSqlParserRENAME, PlSqlParserSPLIT, PlSqlParserUNUSABLE, PlSqlParserUPDATE, PlSqlParserVISIBLE: + { + p.SetState(6563) + p.Alter_index_ops_set2() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_index_ops_set1Context is an interface to support dynamic dispatch. +type IAlter_index_ops_set1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsAlter_index_ops_set1Context differentiates from other interfaces. + IsAlter_index_ops_set1Context() +} + +type Alter_index_ops_set1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_ops_set1Context() *Alter_index_ops_set1Context { + var p = new(Alter_index_ops_set1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 + return p +} + +func InitEmptyAlter_index_ops_set1Context(p *Alter_index_ops_set1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 +} + +func (*Alter_index_ops_set1Context) IsAlter_index_ops_set1Context() {} + +func NewAlter_index_ops_set1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_ops_set1Context { + var p = new(Alter_index_ops_set1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 + + return p +} + +func (s *Alter_index_ops_set1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_ops_set1Context) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_index_ops_set1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_ops_set1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_ops_set1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_ops_set1(s) + } +} + +func (s *Alter_index_ops_set1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_ops_set1(s) + } +} + +func (p *PlSqlParser) Alter_index_ops_set1() (localctx IAlter_index_ops_set1Context) { + localctx = NewAlter_index_ops_set1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, PlSqlParserRULE_alter_index_ops_set1) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || ((int64((_la-1333)) & ^0x3f) == 0 && ((int64(1)<<(_la-1333))&618475290625) != 0) || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE { + p.SetState(6572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEALLOCATE: + { + p.SetState(6566) + p.Deallocate_unused_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(6567) + p.Allocate_extent_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(6568) + p.Shrink_clause() + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(6569) + p.Parallel_clause() + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6570) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6571) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_index_ops_set2Context is an interface to support dynamic dispatch. +type IAlter_index_ops_set2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rebuild_clause() IRebuild_clauseContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Enable_or_disable() IEnable_or_disableContext + UNUSABLE() antlr.TerminalNode + Visible_or_invisible() IVisible_or_invisibleContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_index_name() INew_index_nameContext + COALESCE() antlr.TerminalNode + Monitoring_nomonitoring() IMonitoring_nomonitoringContext + USAGE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Alter_index_partitioning() IAlter_index_partitioningContext + + // IsAlter_index_ops_set2Context differentiates from other interfaces. + IsAlter_index_ops_set2Context() +} + +type Alter_index_ops_set2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_ops_set2Context() *Alter_index_ops_set2Context { + var p = new(Alter_index_ops_set2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 + return p +} + +func InitEmptyAlter_index_ops_set2Context(p *Alter_index_ops_set2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 +} + +func (*Alter_index_ops_set2Context) IsAlter_index_ops_set2Context() {} + +func NewAlter_index_ops_set2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_ops_set2Context { + var p = new(Alter_index_ops_set2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 + + return p +} + +func (s *Alter_index_ops_set2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_ops_set2Context) Rebuild_clause() IRebuild_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_clauseContext) +} + +func (s *Alter_index_ops_set2Context) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Alter_index_ops_set2Context) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_index_ops_set2Context) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Alter_index_ops_set2Context) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_index_ops_set2Context) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_index_ops_set2Context) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_index_ops_set2Context) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Alter_index_ops_set2Context) Visible_or_invisible() IVisible_or_invisibleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVisible_or_invisibleContext) +} + +func (s *Alter_index_ops_set2Context) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_index_ops_set2Context) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_index_ops_set2Context) New_index_name() INew_index_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_index_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_index_nameContext) +} + +func (s *Alter_index_ops_set2Context) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_index_ops_set2Context) Monitoring_nomonitoring() IMonitoring_nomonitoringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMonitoring_nomonitoringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMonitoring_nomonitoringContext) +} + +func (s *Alter_index_ops_set2Context) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Alter_index_ops_set2Context) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Alter_index_ops_set2Context) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Alter_index_ops_set2Context) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Alter_index_ops_set2Context) Alter_index_partitioning() IAlter_index_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_partitioningContext) +} + +func (s *Alter_index_ops_set2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_ops_set2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_ops_set2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_ops_set2(s) + } +} + +func (s *Alter_index_ops_set2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_ops_set2(s) + } +} + +func (p *PlSqlParser) Alter_index_ops_set2() (localctx IAlter_index_ops_set2Context) { + localctx = NewAlter_index_ops_set2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, PlSqlParserRULE_alter_index_ops_set2) + p.SetState(6597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 635, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6576) + p.Rebuild_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6577) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6578) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6579) + p.Odci_parameters() + } + { + p.SetState(6580) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6582) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6583) + p.Enable_or_disable() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6584) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6585) + p.Visible_or_invisible() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6586) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6587) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6588) + p.New_index_name() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6589) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6590) + p.Monitoring_nomonitoring() + } + { + p.SetState(6591) + p.Match(PlSqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6593) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6594) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6595) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6596) + p.Alter_index_partitioning() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVisible_or_invisibleContext is an interface to support dynamic dispatch. +type IVisible_or_invisibleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + + // IsVisible_or_invisibleContext differentiates from other interfaces. + IsVisible_or_invisibleContext() +} + +type Visible_or_invisibleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVisible_or_invisibleContext() *Visible_or_invisibleContext { + var p = new(Visible_or_invisibleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_visible_or_invisible + return p +} + +func InitEmptyVisible_or_invisibleContext(p *Visible_or_invisibleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_visible_or_invisible +} + +func (*Visible_or_invisibleContext) IsVisible_or_invisibleContext() {} + +func NewVisible_or_invisibleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Visible_or_invisibleContext { + var p = new(Visible_or_invisibleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_visible_or_invisible + + return p +} + +func (s *Visible_or_invisibleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Visible_or_invisibleContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Visible_or_invisibleContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Visible_or_invisibleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Visible_or_invisibleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Visible_or_invisibleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVisible_or_invisible(s) + } +} + +func (s *Visible_or_invisibleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVisible_or_invisible(s) + } +} + +func (p *PlSqlParser) Visible_or_invisible() (localctx IVisible_or_invisibleContext) { + localctx = NewVisible_or_invisibleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, PlSqlParserRULE_visible_or_invisible) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6599) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMonitoring_nomonitoringContext is an interface to support dynamic dispatch. +type IMonitoring_nomonitoringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MONITORING() antlr.TerminalNode + NOMONITORING() antlr.TerminalNode + + // IsMonitoring_nomonitoringContext differentiates from other interfaces. + IsMonitoring_nomonitoringContext() +} + +type Monitoring_nomonitoringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMonitoring_nomonitoringContext() *Monitoring_nomonitoringContext { + var p = new(Monitoring_nomonitoringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring + return p +} + +func InitEmptyMonitoring_nomonitoringContext(p *Monitoring_nomonitoringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring +} + +func (*Monitoring_nomonitoringContext) IsMonitoring_nomonitoringContext() {} + +func NewMonitoring_nomonitoringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Monitoring_nomonitoringContext { + var p = new(Monitoring_nomonitoringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring + + return p +} + +func (s *Monitoring_nomonitoringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Monitoring_nomonitoringContext) MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITORING, 0) +} + +func (s *Monitoring_nomonitoringContext) NOMONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMONITORING, 0) +} + +func (s *Monitoring_nomonitoringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Monitoring_nomonitoringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Monitoring_nomonitoringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMonitoring_nomonitoring(s) + } +} + +func (s *Monitoring_nomonitoringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMonitoring_nomonitoring(s) + } +} + +func (p *PlSqlParser) Monitoring_nomonitoring() (localctx IMonitoring_nomonitoringContext) { + localctx = NewMonitoring_nomonitoringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, PlSqlParserRULE_monitoring_nomonitoring) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6601) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMONITORING || _la == PlSqlParserNOMONITORING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRebuild_clauseContext is an interface to support dynamic dispatch. +type IRebuild_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBUILD() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + REVERSE() antlr.TerminalNode + NOREVERSE() antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllPARAMETERS() []antlr.TerminalNode + PARAMETERS(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllOdci_parameters() []IOdci_parametersContext + Odci_parameters(i int) IOdci_parametersContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsRebuild_clauseContext differentiates from other interfaces. + IsRebuild_clauseContext() +} + +type Rebuild_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebuild_clauseContext() *Rebuild_clauseContext { + var p = new(Rebuild_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebuild_clause + return p +} + +func InitEmptyRebuild_clauseContext(p *Rebuild_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebuild_clause +} + +func (*Rebuild_clauseContext) IsRebuild_clauseContext() {} + +func NewRebuild_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebuild_clauseContext { + var p = new(Rebuild_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rebuild_clause + + return p +} + +func (s *Rebuild_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebuild_clauseContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Rebuild_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Rebuild_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Rebuild_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Rebuild_clauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Rebuild_clauseContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Rebuild_clauseContext) NOREVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREVERSE, 0) +} + +func (s *Rebuild_clauseContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Rebuild_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Rebuild_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Rebuild_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Rebuild_clauseContext) AllPARAMETERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARAMETERS) +} + +func (s *Rebuild_clauseContext) PARAMETERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, i) +} + +func (s *Rebuild_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Rebuild_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Rebuild_clauseContext) AllOdci_parameters() []IOdci_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOdci_parametersContext); ok { + len++ + } + } + + tst := make([]IOdci_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOdci_parametersContext); ok { + tst[i] = t.(IOdci_parametersContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Odci_parameters(i int) IOdci_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Rebuild_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Rebuild_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Rebuild_clauseContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Rebuild_clauseContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Rebuild_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Rebuild_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Rebuild_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Rebuild_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebuild_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebuild_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRebuild_clause(s) + } +} + +func (s *Rebuild_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRebuild_clause(s) + } +} + +func (p *PlSqlParser) Rebuild_clause() (localctx IRebuild_clauseContext) { + localctx = NewRebuild_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, PlSqlParserRULE_rebuild_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6603) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(6604) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6605) + p.Partition_name() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(6606) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6607) + p.Subpartition_name() + } + + case PlSqlParserREVERSE: + { + p.SetState(6608) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOREVERSE: + { + p.SetState(6609) + p.Match(PlSqlParserNOREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserONLINE, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(6626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserONLINE || ((int64((_la-1333)) & ^0x3f) == 0 && ((int64(1)<<(_la-1333))&618475290629) != 0) || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(6612) + p.Parallel_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(6613) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6614) + p.Tablespace() + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6615) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6616) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6617) + p.Odci_parameters() + } + { + p.SetState(6618) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserONLINE: + { + p.SetState(6620) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6621) + p.Physical_attributes_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(6622) + p.Key_compression() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6623) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_index_partitioningContext is an interface to support dynamic dispatch. +type IAlter_index_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Modify_index_default_attrs() IModify_index_default_attrsContext + Add_hash_index_partition() IAdd_hash_index_partitionContext + Modify_index_partition() IModify_index_partitionContext + Rename_index_partition() IRename_index_partitionContext + Drop_index_partition() IDrop_index_partitionContext + Split_index_partition() ISplit_index_partitionContext + Coalesce_index_partition() ICoalesce_index_partitionContext + Modify_index_subpartition() IModify_index_subpartitionContext + + // IsAlter_index_partitioningContext differentiates from other interfaces. + IsAlter_index_partitioningContext() +} + +type Alter_index_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_partitioningContext() *Alter_index_partitioningContext { + var p = new(Alter_index_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning + return p +} + +func InitEmptyAlter_index_partitioningContext(p *Alter_index_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning +} + +func (*Alter_index_partitioningContext) IsAlter_index_partitioningContext() {} + +func NewAlter_index_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_partitioningContext { + var p = new(Alter_index_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning + + return p +} + +func (s *Alter_index_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_partitioningContext) Modify_index_default_attrs() IModify_index_default_attrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_default_attrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_default_attrsContext) +} + +func (s *Alter_index_partitioningContext) Add_hash_index_partition() IAdd_hash_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_hash_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_hash_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Modify_index_partition() IModify_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Rename_index_partition() IRename_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Drop_index_partition() IDrop_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Split_index_partition() ISplit_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISplit_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISplit_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Coalesce_index_partition() ICoalesce_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICoalesce_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICoalesce_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Modify_index_subpartition() IModify_index_subpartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_subpartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_subpartitionContext) +} + +func (s *Alter_index_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_partitioning(s) + } +} + +func (s *Alter_index_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_partitioning(s) + } +} + +func (p *PlSqlParser) Alter_index_partitioning() (localctx IAlter_index_partitioningContext) { + localctx = NewAlter_index_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, PlSqlParserRULE_alter_index_partitioning) + p.SetState(6637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 639, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6629) + p.Modify_index_default_attrs() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6630) + p.Add_hash_index_partition() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6631) + p.Modify_index_partition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6632) + p.Rename_index_partition() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6633) + p.Drop_index_partition() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6634) + p.Split_index_partition() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6635) + p.Coalesce_index_partition() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6636) + p.Modify_index_subpartition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_default_attrsContext is an interface to support dynamic dispatch. +type IModify_index_default_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + Physical_attributes_clause() IPhysical_attributes_clauseContext + TABLESPACE() antlr.TerminalNode + Logging_clause() ILogging_clauseContext + FOR() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + Tablespace() ITablespaceContext + + // IsModify_index_default_attrsContext differentiates from other interfaces. + IsModify_index_default_attrsContext() +} + +type Modify_index_default_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_default_attrsContext() *Modify_index_default_attrsContext { + var p = new(Modify_index_default_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs + return p +} + +func InitEmptyModify_index_default_attrsContext(p *Modify_index_default_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs +} + +func (*Modify_index_default_attrsContext) IsModify_index_default_attrsContext() {} + +func NewModify_index_default_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_default_attrsContext { + var p = new(Modify_index_default_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs + + return p +} + +func (s *Modify_index_default_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_default_attrsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_default_attrsContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Modify_index_default_attrsContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Modify_index_default_attrsContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Modify_index_default_attrsContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Modify_index_default_attrsContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Modify_index_default_attrsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_index_default_attrsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Modify_index_default_attrsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_index_default_attrsContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_index_default_attrsContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Modify_index_default_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_default_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_default_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_default_attrs(s) + } +} + +func (s *Modify_index_default_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_default_attrs(s) + } +} + +func (p *PlSqlParser) Modify_index_default_attrs() (localctx IModify_index_default_attrsContext) { + localctx = NewModify_index_default_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, PlSqlParserRULE_modify_index_default_attrs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6639) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6640) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6641) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(6642) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6643) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6644) + p.Partition_name() + } + + } + p.SetState(6654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6647) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(6648) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(6649) + p.Tablespace() + } + + case PlSqlParserDEFAULT: + { + p.SetState(6650) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6653) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_hash_index_partitionContext is an interface to support dynamic dispatch. +type IAdd_hash_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + Parallel_clause() IParallel_clauseContext + + // IsAdd_hash_index_partitionContext differentiates from other interfaces. + IsAdd_hash_index_partitionContext() +} + +type Add_hash_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_hash_index_partitionContext() *Add_hash_index_partitionContext { + var p = new(Add_hash_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition + return p +} + +func InitEmptyAdd_hash_index_partitionContext(p *Add_hash_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition +} + +func (*Add_hash_index_partitionContext) IsAdd_hash_index_partitionContext() {} + +func NewAdd_hash_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_hash_index_partitionContext { + var p = new(Add_hash_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition + + return p +} + +func (s *Add_hash_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_hash_index_partitionContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_hash_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Add_hash_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Add_hash_index_partitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Add_hash_index_partitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Add_hash_index_partitionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Add_hash_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Add_hash_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_hash_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_hash_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_hash_index_partition(s) + } +} + +func (s *Add_hash_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_hash_index_partition(s) + } +} + +func (p *PlSqlParser) Add_hash_index_partition() (localctx IAdd_hash_index_partitionContext) { + localctx = NewAdd_hash_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, PlSqlParserRULE_add_hash_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6656) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6657) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6659) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) == 1 { + { + p.SetState(6658) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6661) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6662) + p.Tablespace() + } + + } + p.SetState(6666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6665) + p.Key_compression() + } + + } + p.SetState(6669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6668) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICoalesce_index_partitionContext is an interface to support dynamic dispatch. +type ICoalesce_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COALESCE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + + // IsCoalesce_index_partitionContext differentiates from other interfaces. + IsCoalesce_index_partitionContext() +} + +type Coalesce_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCoalesce_index_partitionContext() *Coalesce_index_partitionContext { + var p = new(Coalesce_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition + return p +} + +func InitEmptyCoalesce_index_partitionContext(p *Coalesce_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition +} + +func (*Coalesce_index_partitionContext) IsCoalesce_index_partitionContext() {} + +func NewCoalesce_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Coalesce_index_partitionContext { + var p = new(Coalesce_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition + + return p +} + +func (s *Coalesce_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Coalesce_index_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Coalesce_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Coalesce_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Coalesce_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Coalesce_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Coalesce_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCoalesce_index_partition(s) + } +} + +func (s *Coalesce_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCoalesce_index_partition(s) + } +} + +func (p *PlSqlParser) Coalesce_index_partition() (localctx ICoalesce_index_partitionContext) { + localctx = NewCoalesce_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, PlSqlParserRULE_coalesce_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6671) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6672) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6673) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_partitionContext is an interface to support dynamic dispatch. +type IModify_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + COALESCE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + AllModify_index_partitions_ops() []IModify_index_partitions_opsContext + Modify_index_partitions_ops(i int) IModify_index_partitions_opsContext + + // IsModify_index_partitionContext differentiates from other interfaces. + IsModify_index_partitionContext() +} + +type Modify_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_partitionContext() *Modify_index_partitionContext { + var p = new(Modify_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partition + return p +} + +func InitEmptyModify_index_partitionContext(p *Modify_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partition +} + +func (*Modify_index_partitionContext) IsModify_index_partitionContext() {} + +func NewModify_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_partitionContext { + var p = new(Modify_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_partition + + return p +} + +func (s *Modify_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_partitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_index_partitionContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Modify_index_partitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_index_partitionContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Modify_index_partitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_index_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Modify_index_partitionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Modify_index_partitionContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Modify_index_partitionContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Modify_index_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_index_partitionContext) AllModify_index_partitions_ops() []IModify_index_partitions_opsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_index_partitions_opsContext); ok { + len++ + } + } + + tst := make([]IModify_index_partitions_opsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_index_partitions_opsContext); ok { + tst[i] = t.(IModify_index_partitions_opsContext) + i++ + } + } + + return tst +} + +func (s *Modify_index_partitionContext) Modify_index_partitions_ops(i int) IModify_index_partitions_opsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_partitions_opsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_partitions_opsContext) +} + +func (s *Modify_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_partition(s) + } +} + +func (s *Modify_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_partition(s) + } +} + +func (p *PlSqlParser) Modify_index_partition() (localctx IModify_index_partitionContext) { + localctx = NewModify_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, PlSqlParserRULE_modify_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6676) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6677) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6678) + p.Partition_name() + } + p.SetState(6694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDEALLOCATE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSHRINK, PlSqlParserSTORAGE: + p.SetState(6680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE { + { + p.SetState(6679) + p.Modify_index_partitions_ops() + } + + p.SetState(6682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6684) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6685) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6686) + p.Odci_parameters() + } + { + p.SetState(6687) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOALESCE: + { + p.SetState(6689) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUPDATE: + { + p.SetState(6690) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6691) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6692) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNUSABLE: + { + p.SetState(6693) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_partitions_opsContext is an interface to support dynamic dispatch. +type IModify_index_partitions_opsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Deallocate_unused_clause() IDeallocate_unused_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Physical_attributes_clause() IPhysical_attributes_clauseContext + Logging_clause() ILogging_clauseContext + Key_compression() IKey_compressionContext + Shrink_clause() IShrink_clauseContext + + // IsModify_index_partitions_opsContext differentiates from other interfaces. + IsModify_index_partitions_opsContext() +} + +type Modify_index_partitions_opsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_partitions_opsContext() *Modify_index_partitions_opsContext { + var p = new(Modify_index_partitions_opsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops + return p +} + +func InitEmptyModify_index_partitions_opsContext(p *Modify_index_partitions_opsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops +} + +func (*Modify_index_partitions_opsContext) IsModify_index_partitions_opsContext() {} + +func NewModify_index_partitions_opsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_partitions_opsContext { + var p = new(Modify_index_partitions_opsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops + + return p +} + +func (s *Modify_index_partitions_opsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_partitions_opsContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Modify_index_partitions_opsContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_partitions_opsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_partitions_opsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_partitions_ops(s) + } +} + +func (s *Modify_index_partitions_opsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_partitions_ops(s) + } +} + +func (p *PlSqlParser) Modify_index_partitions_ops() (localctx IModify_index_partitions_opsContext) { + localctx = NewModify_index_partitions_opsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, PlSqlParserRULE_modify_index_partitions_ops) + p.SetState(6702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEALLOCATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6696) + p.Deallocate_unused_clause() + } + + case PlSqlParserALLOCATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6697) + p.Allocate_extent_clause() + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6698) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6699) + p.Logging_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6700) + p.Key_compression() + } + + case PlSqlParserSHRINK: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6701) + p.Shrink_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_index_partitionContext is an interface to support dynamic dispatch. +type IRename_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_partition_name() INew_partition_nameContext + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + + // IsRename_index_partitionContext differentiates from other interfaces. + IsRename_index_partitionContext() +} + +type Rename_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_index_partitionContext() *Rename_index_partitionContext { + var p = new(Rename_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_index_partition + return p +} + +func InitEmptyRename_index_partitionContext(p *Rename_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_index_partition +} + +func (*Rename_index_partitionContext) IsRename_index_partitionContext() {} + +func NewRename_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_index_partitionContext { + var p = new(Rename_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_index_partition + + return p +} + +func (s *Rename_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_index_partitionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_index_partitionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_index_partitionContext) New_partition_name() INew_partition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_partition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_partition_nameContext) +} + +func (s *Rename_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Rename_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Rename_index_partitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Rename_index_partitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Rename_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_index_partition(s) + } +} + +func (s *Rename_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_index_partition(s) + } +} + +func (p *PlSqlParser) Rename_index_partition() (localctx IRename_index_partitionContext) { + localctx = NewRename_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, PlSqlParserRULE_rename_index_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6704) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(6705) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6706) + p.Partition_name() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(6707) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6708) + p.Subpartition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6711) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6712) + p.New_partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_index_partitionContext is an interface to support dynamic dispatch. +type IDrop_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + + // IsDrop_index_partitionContext differentiates from other interfaces. + IsDrop_index_partitionContext() +} + +type Drop_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_index_partitionContext() *Drop_index_partitionContext { + var p = new(Drop_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index_partition + return p +} + +func InitEmptyDrop_index_partitionContext(p *Drop_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index_partition +} + +func (*Drop_index_partitionContext) IsDrop_index_partitionContext() {} + +func NewDrop_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_index_partitionContext { + var p = new(Drop_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_index_partition + + return p +} + +func (s *Drop_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_index_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Drop_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Drop_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_index_partition(s) + } +} + +func (s *Drop_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_index_partition(s) + } +} + +func (p *PlSqlParser) Drop_index_partition() (localctx IDrop_index_partitionContext) { + localctx = NewDrop_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, PlSqlParserRULE_drop_index_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6714) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6715) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6716) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISplit_index_partitionContext is an interface to support dynamic dispatch. +type ISplit_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SPLIT() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name_old() IPartition_name_oldContext + AT() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + AllIndex_partition_description() []IIndex_partition_descriptionContext + Index_partition_description(i int) IIndex_partition_descriptionContext + Parallel_clause() IParallel_clauseContext + + // IsSplit_index_partitionContext differentiates from other interfaces. + IsSplit_index_partitionContext() +} + +type Split_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySplit_index_partitionContext() *Split_index_partitionContext { + var p = new(Split_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_index_partition + return p +} + +func InitEmptySplit_index_partitionContext(p *Split_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_index_partition +} + +func (*Split_index_partitionContext) IsSplit_index_partitionContext() {} + +func NewSplit_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Split_index_partitionContext { + var p = new(Split_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_split_index_partition + + return p +} + +func (s *Split_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Split_index_partitionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Split_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Split_index_partitionContext) Partition_name_old() IPartition_name_oldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_name_oldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_name_oldContext) +} + +func (s *Split_index_partitionContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Split_index_partitionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Split_index_partitionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Split_index_partitionContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Split_index_partitionContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Split_index_partitionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Split_index_partitionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Split_index_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Split_index_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Split_index_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Split_index_partitionContext) AllIndex_partition_description() []IIndex_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]IIndex_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_partition_descriptionContext); ok { + tst[i] = t.(IIndex_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *Split_index_partitionContext) Index_partition_description(i int) IIndex_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partition_descriptionContext) +} + +func (s *Split_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Split_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Split_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Split_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSplit_index_partition(s) + } +} + +func (s *Split_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSplit_index_partition(s) + } +} + +func (p *PlSqlParser) Split_index_partition() (localctx ISplit_index_partitionContext) { + localctx = NewSplit_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, PlSqlParserRULE_split_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6718) + p.Match(PlSqlParserSPLIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6719) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6720) + p.Partition_name_old() + } + { + p.SetState(6721) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6722) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6723) + p.Literal() + } + p.SetState(6728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6724) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6725) + p.Literal() + } + + p.SetState(6730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6731) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(6732) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6733) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6734) + p.Index_partition_description() + } + { + p.SetState(6735) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6736) + p.Index_partition_description() + } + { + p.SetState(6737) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6741) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_partition_descriptionContext is an interface to support dynamic dispatch. +type IIndex_partition_descriptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + + // IsIndex_partition_descriptionContext differentiates from other interfaces. + IsIndex_partition_descriptionContext() +} + +type Index_partition_descriptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partition_descriptionContext() *Index_partition_descriptionContext { + var p = new(Index_partition_descriptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partition_description + return p +} + +func InitEmptyIndex_partition_descriptionContext(p *Index_partition_descriptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partition_description +} + +func (*Index_partition_descriptionContext) IsIndex_partition_descriptionContext() {} + +func NewIndex_partition_descriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partition_descriptionContext { + var p = new(Index_partition_descriptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_partition_description + + return p +} + +func (s *Index_partition_descriptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partition_descriptionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Index_partition_descriptionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Index_partition_descriptionContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Index_partition_descriptionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_partition_descriptionContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Index_partition_descriptionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_partition_descriptionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Index_partition_descriptionContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_partition_descriptionContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_partition_descriptionContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_partition_descriptionContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_partition_descriptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partition_descriptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partition_descriptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_partition_description(s) + } +} + +func (s *Index_partition_descriptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_partition_description(s) + } +} + +func (p *PlSqlParser) Index_partition_description() (localctx IIndex_partition_descriptionContext) { + localctx = NewIndex_partition_descriptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, PlSqlParserRULE_index_partition_description) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6744) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6762) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 659, p.GetParserRuleContext()) == 1 { + { + p.SetState(6745) + p.Partition_name() + } + p.SetState(6757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserROW, PlSqlParserSTORAGE, PlSqlParserTABLESPACE: + p.SetState(6748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 655, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6746) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6747) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6752) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6753) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6754) + p.Odci_parameters() + } + { + p.SetState(6755) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6759) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_subpartitionContext is an interface to support dynamic dispatch. +type IModify_index_subpartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + UNUSABLE() antlr.TerminalNode + Modify_index_partitions_ops() IModify_index_partitions_opsContext + + // IsModify_index_subpartitionContext differentiates from other interfaces. + IsModify_index_subpartitionContext() +} + +type Modify_index_subpartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_subpartitionContext() *Modify_index_subpartitionContext { + var p = new(Modify_index_subpartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition + return p +} + +func InitEmptyModify_index_subpartitionContext(p *Modify_index_subpartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition +} + +func (*Modify_index_subpartitionContext) IsModify_index_subpartitionContext() {} + +func NewModify_index_subpartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_subpartitionContext { + var p = new(Modify_index_subpartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition + + return p +} + +func (s *Modify_index_subpartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_subpartitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_subpartitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Modify_index_subpartitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Modify_index_subpartitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_index_subpartitionContext) Modify_index_partitions_ops() IModify_index_partitions_opsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_partitions_opsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_partitions_opsContext) +} + +func (s *Modify_index_subpartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_subpartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_subpartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_subpartition(s) + } +} + +func (s *Modify_index_subpartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_subpartition(s) + } +} + +func (p *PlSqlParser) Modify_index_subpartition() (localctx IModify_index_subpartitionContext) { + localctx = NewModify_index_subpartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, PlSqlParserRULE_modify_index_subpartition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6764) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6765) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6766) + p.Subpartition_name() + } + p.SetState(6769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNUSABLE: + { + p.SetState(6767) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOCATE, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDEALLOCATE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSHRINK, PlSqlParserSTORAGE: + { + p.SetState(6768) + p.Modify_index_partitions_ops() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_name_oldContext is an interface to support dynamic dispatch. +type IPartition_name_oldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsPartition_name_oldContext differentiates from other interfaces. + IsPartition_name_oldContext() +} + +type Partition_name_oldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_name_oldContext() *Partition_name_oldContext { + var p = new(Partition_name_oldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name_old + return p +} + +func InitEmptyPartition_name_oldContext(p *Partition_name_oldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name_old +} + +func (*Partition_name_oldContext) IsPartition_name_oldContext() {} + +func NewPartition_name_oldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_name_oldContext { + var p = new(Partition_name_oldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_name_old + + return p +} + +func (s *Partition_name_oldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_name_oldContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_name_oldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_name_oldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_name_oldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_name_old(s) + } +} + +func (s *Partition_name_oldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_name_old(s) + } +} + +func (p *PlSqlParser) Partition_name_old() (localctx IPartition_name_oldContext) { + localctx = NewPartition_name_oldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, PlSqlParserRULE_partition_name_old) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6771) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_partition_nameContext is an interface to support dynamic dispatch. +type INew_partition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsNew_partition_nameContext differentiates from other interfaces. + IsNew_partition_nameContext() +} + +type New_partition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_partition_nameContext() *New_partition_nameContext { + var p = new(New_partition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_partition_name + return p +} + +func InitEmptyNew_partition_nameContext(p *New_partition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_partition_name +} + +func (*New_partition_nameContext) IsNew_partition_nameContext() {} + +func NewNew_partition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_partition_nameContext { + var p = new(New_partition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_partition_name + + return p +} + +func (s *New_partition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_partition_nameContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *New_partition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_partition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_partition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_partition_name(s) + } +} + +func (s *New_partition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_partition_name(s) + } +} + +func (p *PlSqlParser) New_partition_name() (localctx INew_partition_nameContext) { + localctx = NewNew_partition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, PlSqlParserRULE_new_partition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6773) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_index_nameContext is an interface to support dynamic dispatch. +type INew_index_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_name() IIndex_nameContext + + // IsNew_index_nameContext differentiates from other interfaces. + IsNew_index_nameContext() +} + +type New_index_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_index_nameContext() *New_index_nameContext { + var p = new(New_index_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_index_name + return p +} + +func InitEmptyNew_index_nameContext(p *New_index_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_index_name +} + +func (*New_index_nameContext) IsNew_index_nameContext() {} + +func NewNew_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_index_nameContext { + var p = new(New_index_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_index_name + + return p +} + +func (s *New_index_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_index_nameContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *New_index_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_index_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_index_name(s) + } +} + +func (s *New_index_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_index_name(s) + } +} + +func (p *PlSqlParser) New_index_name() (localctx INew_index_nameContext) { + localctx = NewNew_index_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, PlSqlParserRULE_new_index_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6775) + p.Index_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_inmemory_join_groupContext is an interface to support dynamic dispatch. +type IAlter_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ADD() antlr.TerminalNode + REMOVE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsAlter_inmemory_join_groupContext differentiates from other interfaces. + IsAlter_inmemory_join_groupContext() +} + +type Alter_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext + t IId_expressionContext + c IId_expressionContext +} + +func NewEmptyAlter_inmemory_join_groupContext() *Alter_inmemory_join_groupContext { + var p = new(Alter_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group + return p +} + +func InitEmptyAlter_inmemory_join_groupContext(p *Alter_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group +} + +func (*Alter_inmemory_join_groupContext) IsAlter_inmemory_join_groupContext() {} + +func NewAlter_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_inmemory_join_groupContext { + var p = new(Alter_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group + + return p +} + +func (s *Alter_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Alter_inmemory_join_groupContext) GetT() IId_expressionContext { return s.t } + +func (s *Alter_inmemory_join_groupContext) GetC() IId_expressionContext { return s.c } + +func (s *Alter_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Alter_inmemory_join_groupContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Alter_inmemory_join_groupContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Alter_inmemory_join_groupContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Alter_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Alter_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_inmemory_join_groupContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_inmemory_join_groupContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_inmemory_join_groupContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_inmemory_join_groupContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_inmemory_join_groupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_inmemory_join_groupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_inmemory_join_groupContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_inmemory_join_groupContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Alter_inmemory_join_groupContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_inmemory_join_groupContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_inmemory_join_groupContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Alter_inmemory_join_groupContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Alter_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_inmemory_join_group(s) + } +} + +func (s *Alter_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_inmemory_join_group(s) + } +} + +func (p *PlSqlParser) Alter_inmemory_join_group() (localctx IAlter_inmemory_join_groupContext) { + localctx = NewAlter_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, PlSqlParserRULE_alter_inmemory_join_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6777) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6778) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6779) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6780) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6784) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) == 1 { + { + p.SetState(6781) + p.Schema_name() + } + { + p.SetState(6782) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6786) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).jg = _x + } + { + p.SetState(6787) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6788) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6792) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 662, p.GetParserRuleContext()) == 1 { + { + p.SetState(6789) + p.Schema_name() + } + { + p.SetState(6790) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6794) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).t = _x + } + { + p.SetState(6795) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6796) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).c = _x + } + { + p.SetState(6797) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6798) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_userContext is an interface to support dynamic dispatch. +type ICreate_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + User_object_name() IUser_object_nameContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllIdentified_by() []IIdentified_byContext + Identified_by(i int) IIdentified_byContext + AllIdentified_other_clause() []IIdentified_other_clauseContext + Identified_other_clause(i int) IIdentified_other_clauseContext + AllUser_tablespace_clause() []IUser_tablespace_clauseContext + User_tablespace_clause(i int) IUser_tablespace_clauseContext + AllQuota_clause() []IQuota_clauseContext + Quota_clause(i int) IQuota_clauseContext + AllProfile_clause() []IProfile_clauseContext + Profile_clause(i int) IProfile_clauseContext + AllPassword_expire_clause() []IPassword_expire_clauseContext + Password_expire_clause(i int) IPassword_expire_clauseContext + AllUser_lock_clause() []IUser_lock_clauseContext + User_lock_clause(i int) IUser_lock_clauseContext + AllUser_editions_clause() []IUser_editions_clauseContext + User_editions_clause(i int) IUser_editions_clauseContext + AllContainer_clause() []IContainer_clauseContext + Container_clause(i int) IContainer_clauseContext + + // IsCreate_userContext differentiates from other interfaces. + IsCreate_userContext() +} + +type Create_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_userContext() *Create_userContext { + var p = new(Create_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_user + return p +} + +func InitEmptyCreate_userContext(p *Create_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_user +} + +func (*Create_userContext) IsCreate_userContext() {} + +func NewCreate_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_userContext { + var p = new(Create_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_user + + return p +} + +func (s *Create_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_userContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Create_userContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Create_userContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_userContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_userContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_userContext) AllIdentified_by() []IIdentified_byContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_byContext); ok { + len++ + } + } + + tst := make([]IIdentified_byContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_byContext); ok { + tst[i] = t.(IIdentified_byContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Identified_by(i int) IIdentified_byContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Create_userContext) AllIdentified_other_clause() []IIdentified_other_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_other_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_other_clauseContext); ok { + tst[i] = t.(IIdentified_other_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Identified_other_clause(i int) IIdentified_other_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_other_clauseContext) +} + +func (s *Create_userContext) AllUser_tablespace_clause() []IUser_tablespace_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_tablespace_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_tablespace_clauseContext); ok { + tst[i] = t.(IUser_tablespace_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_tablespace_clause(i int) IUser_tablespace_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_tablespace_clauseContext) +} + +func (s *Create_userContext) AllQuota_clause() []IQuota_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuota_clauseContext); ok { + len++ + } + } + + tst := make([]IQuota_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuota_clauseContext); ok { + tst[i] = t.(IQuota_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Quota_clause(i int) IQuota_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuota_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuota_clauseContext) +} + +func (s *Create_userContext) AllProfile_clause() []IProfile_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProfile_clauseContext); ok { + len++ + } + } + + tst := make([]IProfile_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProfile_clauseContext); ok { + tst[i] = t.(IProfile_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Profile_clause(i int) IProfile_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProfile_clauseContext) +} + +func (s *Create_userContext) AllPassword_expire_clause() []IPassword_expire_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + len++ + } + } + + tst := make([]IPassword_expire_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_expire_clauseContext); ok { + tst[i] = t.(IPassword_expire_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Password_expire_clause(i int) IPassword_expire_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_expire_clauseContext) +} + +func (s *Create_userContext) AllUser_lock_clause() []IUser_lock_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_lock_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_lock_clauseContext); ok { + tst[i] = t.(IUser_lock_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_lock_clause(i int) IUser_lock_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_lock_clauseContext) +} + +func (s *Create_userContext) AllUser_editions_clause() []IUser_editions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_editions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_editions_clauseContext); ok { + tst[i] = t.(IUser_editions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_editions_clause(i int) IUser_editions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_editions_clauseContext) +} + +func (s *Create_userContext) AllContainer_clause() []IContainer_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_clauseContext); ok { + tst[i] = t.(IContainer_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Container_clause(i int) IContainer_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_user(s) + } +} + +func (s *Create_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_user(s) + } +} + +func (p *PlSqlParser) Create_user() (localctx ICreate_userContext) { + localctx = NewCreate_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, PlSqlParserRULE_create_user) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6800) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6801) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6802) + p.User_object_name() + } + p.SetState(6806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(6803) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6804) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6805) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserACCOUNT || _la == PlSqlParserCONTAINER || _la == PlSqlParserDEFAULT || _la == PlSqlParserENABLE || _la == PlSqlParserIDENTIFIED || _la == PlSqlParserPASSWORD || _la == PlSqlParserPROFILE || _la == PlSqlParserQUOTA || _la == PlSqlParserTEMPORARY { + p.SetState(6817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6808) + p.Identified_by() + } + + case 2: + { + p.SetState(6809) + p.Identified_other_clause() + } + + case 3: + { + p.SetState(6810) + p.User_tablespace_clause() + } + + case 4: + { + p.SetState(6811) + p.Quota_clause() + } + + case 5: + { + p.SetState(6812) + p.Profile_clause() + } + + case 6: + { + p.SetState(6813) + p.Password_expire_clause() + } + + case 7: + { + p.SetState(6814) + p.User_lock_clause() + } + + case 8: + { + p.SetState(6815) + p.User_editions_clause() + } + + case 9: + { + p.SetState(6816) + p.Container_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_userContext is an interface to support dynamic dispatch. +type IAlter_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + AllAlter_identified_by() []IAlter_identified_byContext + Alter_identified_by(i int) IAlter_identified_byContext + AllIdentified_other_clause() []IIdentified_other_clauseContext + Identified_other_clause(i int) IIdentified_other_clauseContext + AllUser_tablespace_clause() []IUser_tablespace_clauseContext + User_tablespace_clause(i int) IUser_tablespace_clauseContext + AllQuota_clause() []IQuota_clauseContext + Quota_clause(i int) IQuota_clauseContext + AllProfile_clause() []IProfile_clauseContext + Profile_clause(i int) IProfile_clauseContext + AllUser_default_role_clause() []IUser_default_role_clauseContext + User_default_role_clause(i int) IUser_default_role_clauseContext + AllPassword_expire_clause() []IPassword_expire_clauseContext + Password_expire_clause(i int) IPassword_expire_clauseContext + AllUser_lock_clause() []IUser_lock_clauseContext + User_lock_clause(i int) IUser_lock_clauseContext + AllAlter_user_editions_clause() []IAlter_user_editions_clauseContext + Alter_user_editions_clause(i int) IAlter_user_editions_clauseContext + AllContainer_clause() []IContainer_clauseContext + Container_clause(i int) IContainer_clauseContext + AllContainer_data_clause() []IContainer_data_clauseContext + Container_data_clause(i int) IContainer_data_clauseContext + Proxy_clause() IProxy_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_userContext differentiates from other interfaces. + IsAlter_userContext() +} + +type Alter_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_userContext() *Alter_userContext { + var p = new(Alter_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user + return p +} + +func InitEmptyAlter_userContext(p *Alter_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user +} + +func (*Alter_userContext) IsAlter_userContext() {} + +func NewAlter_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_userContext { + var p = new(Alter_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_user + + return p +} + +func (s *Alter_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_userContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Alter_userContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Alter_userContext) AllAlter_identified_by() []IAlter_identified_byContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_identified_byContext); ok { + len++ + } + } + + tst := make([]IAlter_identified_byContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_identified_byContext); ok { + tst[i] = t.(IAlter_identified_byContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Alter_identified_by(i int) IAlter_identified_byContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_identified_byContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_identified_byContext) +} + +func (s *Alter_userContext) AllIdentified_other_clause() []IIdentified_other_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_other_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_other_clauseContext); ok { + tst[i] = t.(IIdentified_other_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Identified_other_clause(i int) IIdentified_other_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_other_clauseContext) +} + +func (s *Alter_userContext) AllUser_tablespace_clause() []IUser_tablespace_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_tablespace_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_tablespace_clauseContext); ok { + tst[i] = t.(IUser_tablespace_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_tablespace_clause(i int) IUser_tablespace_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_tablespace_clauseContext) +} + +func (s *Alter_userContext) AllQuota_clause() []IQuota_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuota_clauseContext); ok { + len++ + } + } + + tst := make([]IQuota_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuota_clauseContext); ok { + tst[i] = t.(IQuota_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Quota_clause(i int) IQuota_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuota_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuota_clauseContext) +} + +func (s *Alter_userContext) AllProfile_clause() []IProfile_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProfile_clauseContext); ok { + len++ + } + } + + tst := make([]IProfile_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProfile_clauseContext); ok { + tst[i] = t.(IProfile_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Profile_clause(i int) IProfile_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProfile_clauseContext) +} + +func (s *Alter_userContext) AllUser_default_role_clause() []IUser_default_role_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_default_role_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_default_role_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_default_role_clauseContext); ok { + tst[i] = t.(IUser_default_role_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_default_role_clause(i int) IUser_default_role_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_default_role_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_default_role_clauseContext) +} + +func (s *Alter_userContext) AllPassword_expire_clause() []IPassword_expire_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + len++ + } + } + + tst := make([]IPassword_expire_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_expire_clauseContext); ok { + tst[i] = t.(IPassword_expire_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Password_expire_clause(i int) IPassword_expire_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_expire_clauseContext) +} + +func (s *Alter_userContext) AllUser_lock_clause() []IUser_lock_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_lock_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_lock_clauseContext); ok { + tst[i] = t.(IUser_lock_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_lock_clause(i int) IUser_lock_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_lock_clauseContext) +} + +func (s *Alter_userContext) AllAlter_user_editions_clause() []IAlter_user_editions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_user_editions_clauseContext); ok { + len++ + } + } + + tst := make([]IAlter_user_editions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_user_editions_clauseContext); ok { + tst[i] = t.(IAlter_user_editions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Alter_user_editions_clause(i int) IAlter_user_editions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_user_editions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_user_editions_clauseContext) +} + +func (s *Alter_userContext) AllContainer_clause() []IContainer_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_clauseContext); ok { + tst[i] = t.(IContainer_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Container_clause(i int) IContainer_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Alter_userContext) AllContainer_data_clause() []IContainer_data_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_data_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_data_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_data_clauseContext); ok { + tst[i] = t.(IContainer_data_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Container_data_clause(i int) IContainer_data_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_data_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_data_clauseContext) +} + +func (s *Alter_userContext) Proxy_clause() IProxy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProxy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProxy_clauseContext) +} + +func (s *Alter_userContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_userContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_user(s) + } +} + +func (s *Alter_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_user(s) + } +} + +func (p *PlSqlParser) Alter_user() (localctx IAlter_userContext) { + localctx = NewAlter_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, PlSqlParserRULE_alter_user) + var _la int + + p.SetState(6849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6821) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6822) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6823) + p.User_object_name() + } + p.SetState(6835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserACCOUNT || _la == PlSqlParserADD || _la == PlSqlParserCONTAINER || _la == PlSqlParserDEFAULT || _la == PlSqlParserENABLE || _la == PlSqlParserIDENTIFIED || _la == PlSqlParserPASSWORD || _la == PlSqlParserPROFILE || _la == PlSqlParserQUOTA || _la == PlSqlParserREMOVE || _la == PlSqlParserSET || _la == PlSqlParserTEMPORARY { + p.SetState(6835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6824) + p.Alter_identified_by() + } + + case 2: + { + p.SetState(6825) + p.Identified_other_clause() + } + + case 3: + { + p.SetState(6826) + p.User_tablespace_clause() + } + + case 4: + { + p.SetState(6827) + p.Quota_clause() + } + + case 5: + { + p.SetState(6828) + p.Profile_clause() + } + + case 6: + { + p.SetState(6829) + p.User_default_role_clause() + } + + case 7: + { + p.SetState(6830) + p.Password_expire_clause() + } + + case 8: + { + p.SetState(6831) + p.User_lock_clause() + } + + case 9: + { + p.SetState(6832) + p.Alter_user_editions_clause() + } + + case 10: + { + p.SetState(6833) + p.Container_clause() + } + + case 11: + { + p.SetState(6834) + p.Container_data_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6839) + p.User_object_name() + } + p.SetState(6844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6840) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6841) + p.User_object_name() + } + + p.SetState(6846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6847) + p.Proxy_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_userContext is an interface to support dynamic dispatch. +type IDrop_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + User_object_name() IUser_object_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsDrop_userContext differentiates from other interfaces. + IsDrop_userContext() +} + +type Drop_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_userContext() *Drop_userContext { + var p = new(Drop_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_user + return p +} + +func InitEmptyDrop_userContext(p *Drop_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_user +} + +func (*Drop_userContext) IsDrop_userContext() {} + +func NewDrop_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_userContext { + var p = new(Drop_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_user + + return p +} + +func (s *Drop_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_userContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Drop_userContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Drop_userContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_userContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_userContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_user(s) + } +} + +func (s *Drop_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_user(s) + } +} + +func (p *PlSqlParser) Drop_user() (localctx IDrop_userContext) { + localctx = NewDrop_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, PlSqlParserRULE_drop_user) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6851) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6852) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6853) + p.User_object_name() + } + p.SetState(6856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(6854) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6855) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(6858) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_identified_byContext is an interface to support dynamic dispatch. +type IAlter_identified_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identified_by() IIdentified_byContext + REPLACE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsAlter_identified_byContext differentiates from other interfaces. + IsAlter_identified_byContext() +} + +type Alter_identified_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_identified_byContext() *Alter_identified_byContext { + var p = new(Alter_identified_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_identified_by + return p +} + +func InitEmptyAlter_identified_byContext(p *Alter_identified_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_identified_by +} + +func (*Alter_identified_byContext) IsAlter_identified_byContext() {} + +func NewAlter_identified_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identified_byContext { + var p = new(Alter_identified_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_identified_by + + return p +} + +func (s *Alter_identified_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_identified_byContext) Identified_by() IIdentified_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Alter_identified_byContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Alter_identified_byContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_identified_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_identified_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_identified_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_identified_by(s) + } +} + +func (s *Alter_identified_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_identified_by(s) + } +} + +func (p *PlSqlParser) Alter_identified_by() (localctx IAlter_identified_byContext) { + localctx = NewAlter_identified_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, PlSqlParserRULE_alter_identified_by) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6861) + p.Identified_by() + } + p.SetState(6864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREPLACE { + { + p.SetState(6862) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6863) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_byContext is an interface to support dynamic dispatch. +type IIdentified_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsIdentified_byContext differentiates from other interfaces. + IsIdentified_byContext() +} + +type Identified_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_byContext() *Identified_byContext { + var p = new(Identified_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by + return p +} + +func InitEmptyIdentified_byContext(p *Identified_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by +} + +func (*Identified_byContext) IsIdentified_byContext() {} + +func NewIdentified_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_byContext { + var p = new(Identified_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by + + return p +} + +func (s *Identified_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_byContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_byContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_byContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Identified_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by(s) + } +} + +func (s *Identified_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by(s) + } +} + +func (p *PlSqlParser) Identified_by() (localctx IIdentified_byContext) { + localctx = NewIdentified_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, PlSqlParserRULE_identified_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6866) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6867) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6868) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_other_clauseContext is an interface to support dynamic dispatch. +type IIdentified_other_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + AS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsIdentified_other_clauseContext differentiates from other interfaces. + IsIdentified_other_clauseContext() +} + +type Identified_other_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_other_clauseContext() *Identified_other_clauseContext { + var p = new(Identified_other_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_other_clause + return p +} + +func InitEmptyIdentified_other_clauseContext(p *Identified_other_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_other_clause +} + +func (*Identified_other_clauseContext) IsIdentified_other_clauseContext() {} + +func NewIdentified_other_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_other_clauseContext { + var p = new(Identified_other_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_other_clause + + return p +} + +func (s *Identified_other_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_other_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_other_clauseContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Identified_other_clauseContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Identified_other_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Identified_other_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Identified_other_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_other_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_other_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_other_clause(s) + } +} + +func (s *Identified_other_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_other_clause(s) + } +} + +func (p *PlSqlParser) Identified_other_clause() (localctx IIdentified_other_clauseContext) { + localctx = NewIdentified_other_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, PlSqlParserRULE_identified_other_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6870) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6871) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXTERNALLY || _la == PlSqlParserGLOBALLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(6872) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6873) + p.Quoted_string() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_tablespace_clauseContext is an interface to support dynamic dispatch. +type IUser_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + DEFAULT() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + + // IsUser_tablespace_clauseContext differentiates from other interfaces. + IsUser_tablespace_clauseContext() +} + +type User_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_tablespace_clauseContext() *User_tablespace_clauseContext { + var p = new(User_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause + return p +} + +func InitEmptyUser_tablespace_clauseContext(p *User_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause +} + +func (*User_tablespace_clauseContext) IsUser_tablespace_clauseContext() {} + +func NewUser_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_tablespace_clauseContext { + var p = new(User_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause + + return p +} + +func (s *User_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *User_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *User_tablespace_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *User_tablespace_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *User_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_tablespace_clause(s) + } +} + +func (s *User_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_tablespace_clause(s) + } +} + +func (p *PlSqlParser) User_tablespace_clause() (localctx IUser_tablespace_clauseContext) { + localctx = NewUser_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, PlSqlParserRULE_user_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6876) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6877) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6878) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuota_clauseContext is an interface to support dynamic dispatch. +type IQuota_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTA() antlr.TerminalNode + ON() antlr.TerminalNode + Id_expression() IId_expressionContext + Size_clause() ISize_clauseContext + UNLIMITED() antlr.TerminalNode + + // IsQuota_clauseContext differentiates from other interfaces. + IsQuota_clauseContext() +} + +type Quota_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuota_clauseContext() *Quota_clauseContext { + var p = new(Quota_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quota_clause + return p +} + +func InitEmptyQuota_clauseContext(p *Quota_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quota_clause +} + +func (*Quota_clauseContext) IsQuota_clauseContext() {} + +func NewQuota_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quota_clauseContext { + var p = new(Quota_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quota_clause + + return p +} + +func (s *Quota_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quota_clauseContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Quota_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Quota_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Quota_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Quota_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Quota_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quota_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quota_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuota_clause(s) + } +} + +func (s *Quota_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuota_clause(s) + } +} + +func (p *PlSqlParser) Quota_clause() (localctx IQuota_clauseContext) { + localctx = NewQuota_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, PlSqlParserRULE_quota_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6880) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(6881) + p.Size_clause() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(6882) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6885) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6886) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProfile_clauseContext is an interface to support dynamic dispatch. +type IProfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProfile_clauseContext differentiates from other interfaces. + IsProfile_clauseContext() +} + +type Profile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProfile_clauseContext() *Profile_clauseContext { + var p = new(Profile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_clause + return p +} + +func InitEmptyProfile_clauseContext(p *Profile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_clause +} + +func (*Profile_clauseContext) IsProfile_clauseContext() {} + +func NewProfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Profile_clauseContext { + var p = new(Profile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_profile_clause + + return p +} + +func (s *Profile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Profile_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Profile_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Profile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Profile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Profile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProfile_clause(s) + } +} + +func (s *Profile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProfile_clause(s) + } +} + +func (p *PlSqlParser) Profile_clause() (localctx IProfile_clauseContext) { + localctx = NewProfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, PlSqlParserRULE_profile_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6888) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6889) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_clauseContext is an interface to support dynamic dispatch. +type IRole_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + AllEXCEPT() []antlr.TerminalNode + EXCEPT(i int) antlr.TerminalNode + + // IsRole_clauseContext differentiates from other interfaces. + IsRole_clauseContext() +} + +type Role_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_clauseContext() *Role_clauseContext { + var p = new(Role_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_clause + return p +} + +func InitEmptyRole_clauseContext(p *Role_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_clause +} + +func (*Role_clauseContext) IsRole_clauseContext() {} + +func NewRole_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_clauseContext { + var p = new(Role_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_clause + + return p +} + +func (s *Role_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_clauseContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Role_clauseContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Role_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Role_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Role_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Role_clauseContext) AllEXCEPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEXCEPT) +} + +func (s *Role_clauseContext) EXCEPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, i) +} + +func (s *Role_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_clause(s) + } +} + +func (s *Role_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_clause(s) + } +} + +func (p *PlSqlParser) Role_clause() (localctx IRole_clauseContext) { + localctx = NewRole_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, PlSqlParserRULE_role_clause) + var _la int + + p.SetState(6914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6891) + p.Role_name() + } + p.SetState(6896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6892) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6893) + p.Role_name() + } + + p.SetState(6898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6899) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserEXCEPT { + { + p.SetState(6900) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6901) + p.Role_name() + } + p.SetState(6906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6902) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6903) + p.Role_name() + } + + p.SetState(6908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(6913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_default_role_clauseContext is an interface to support dynamic dispatch. +type IUser_default_role_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + ROLE() antlr.TerminalNode + NONE() antlr.TerminalNode + Role_clause() IRole_clauseContext + + // IsUser_default_role_clauseContext differentiates from other interfaces. + IsUser_default_role_clauseContext() +} + +type User_default_role_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_default_role_clauseContext() *User_default_role_clauseContext { + var p = new(User_default_role_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_default_role_clause + return p +} + +func InitEmptyUser_default_role_clauseContext(p *User_default_role_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_default_role_clause +} + +func (*User_default_role_clauseContext) IsUser_default_role_clauseContext() {} + +func NewUser_default_role_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_default_role_clauseContext { + var p = new(User_default_role_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_default_role_clause + + return p +} + +func (s *User_default_role_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_default_role_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *User_default_role_clauseContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *User_default_role_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *User_default_role_clauseContext) Role_clause() IRole_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_clauseContext) +} + +func (s *User_default_role_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_default_role_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_default_role_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_default_role_clause(s) + } +} + +func (s *User_default_role_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_default_role_clause(s) + } +} + +func (p *PlSqlParser) User_default_role_clause() (localctx IUser_default_role_clauseContext) { + localctx = NewUser_default_role_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, PlSqlParserRULE_user_default_role_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6916) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6917) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 679, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6918) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6919) + p.Role_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPassword_expire_clauseContext is an interface to support dynamic dispatch. +type IPassword_expire_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSWORD() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + + // IsPassword_expire_clauseContext differentiates from other interfaces. + IsPassword_expire_clauseContext() +} + +type Password_expire_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_expire_clauseContext() *Password_expire_clauseContext { + var p = new(Password_expire_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_expire_clause + return p +} + +func InitEmptyPassword_expire_clauseContext(p *Password_expire_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_expire_clause +} + +func (*Password_expire_clauseContext) IsPassword_expire_clauseContext() {} + +func NewPassword_expire_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_expire_clauseContext { + var p = new(Password_expire_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_expire_clause + + return p +} + +func (s *Password_expire_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_expire_clauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Password_expire_clauseContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPIRE, 0) +} + +func (s *Password_expire_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_expire_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_expire_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_expire_clause(s) + } +} + +func (s *Password_expire_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_expire_clause(s) + } +} + +func (p *PlSqlParser) Password_expire_clause() (localctx IPassword_expire_clauseContext) { + localctx = NewPassword_expire_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, PlSqlParserRULE_password_expire_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6922) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6923) + p.Match(PlSqlParserEXPIRE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_lock_clauseContext is an interface to support dynamic dispatch. +type IUser_lock_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCOUNT() antlr.TerminalNode + LOCK() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + + // IsUser_lock_clauseContext differentiates from other interfaces. + IsUser_lock_clauseContext() +} + +type User_lock_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_lock_clauseContext() *User_lock_clauseContext { + var p = new(User_lock_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_lock_clause + return p +} + +func InitEmptyUser_lock_clauseContext(p *User_lock_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_lock_clause +} + +func (*User_lock_clauseContext) IsUser_lock_clauseContext() {} + +func NewUser_lock_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_lock_clauseContext { + var p = new(User_lock_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_lock_clause + + return p +} + +func (s *User_lock_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_lock_clauseContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCOUNT, 0) +} + +func (s *User_lock_clauseContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *User_lock_clauseContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOCK, 0) +} + +func (s *User_lock_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_lock_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_lock_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_lock_clause(s) + } +} + +func (s *User_lock_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_lock_clause(s) + } +} + +func (p *PlSqlParser) User_lock_clause() (localctx IUser_lock_clauseContext) { + localctx = NewUser_lock_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, PlSqlParserRULE_user_lock_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6925) + p.Match(PlSqlParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6926) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCK || _la == PlSqlParserUNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_editions_clauseContext is an interface to support dynamic dispatch. +type IUser_editions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + EDITIONS() antlr.TerminalNode + + // IsUser_editions_clauseContext differentiates from other interfaces. + IsUser_editions_clauseContext() +} + +type User_editions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_editions_clauseContext() *User_editions_clauseContext { + var p = new(User_editions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_editions_clause + return p +} + +func InitEmptyUser_editions_clauseContext(p *User_editions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_editions_clause +} + +func (*User_editions_clauseContext) IsUser_editions_clauseContext() {} + +func NewUser_editions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_editions_clauseContext { + var p = new(User_editions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_editions_clause + + return p +} + +func (s *User_editions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_editions_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *User_editions_clauseContext) EDITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONS, 0) +} + +func (s *User_editions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_editions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_editions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_editions_clause(s) + } +} + +func (s *User_editions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_editions_clause(s) + } +} + +func (p *PlSqlParser) User_editions_clause() (localctx IUser_editions_clauseContext) { + localctx = NewUser_editions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, PlSqlParserRULE_user_editions_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6928) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6929) + p.Match(PlSqlParserEDITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_user_editions_clauseContext is an interface to support dynamic dispatch. +type IAlter_user_editions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + User_editions_clause() IUser_editions_clauseContext + FOR() antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + FORCE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_user_editions_clauseContext differentiates from other interfaces. + IsAlter_user_editions_clauseContext() +} + +type Alter_user_editions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_user_editions_clauseContext() *Alter_user_editions_clauseContext { + var p = new(Alter_user_editions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause + return p +} + +func InitEmptyAlter_user_editions_clauseContext(p *Alter_user_editions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause +} + +func (*Alter_user_editions_clauseContext) IsAlter_user_editions_clauseContext() {} + +func NewAlter_user_editions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_user_editions_clauseContext { + var p = new(Alter_user_editions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause + + return p +} + +func (s *Alter_user_editions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_user_editions_clauseContext) User_editions_clause() IUser_editions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_editions_clauseContext) +} + +func (s *Alter_user_editions_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Alter_user_editions_clauseContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Alter_user_editions_clauseContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Alter_user_editions_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_user_editions_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_user_editions_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_user_editions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_user_editions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_user_editions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_user_editions_clause(s) + } +} + +func (s *Alter_user_editions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_user_editions_clause(s) + } +} + +func (p *PlSqlParser) Alter_user_editions_clause() (localctx IAlter_user_editions_clauseContext) { + localctx = NewAlter_user_editions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, PlSqlParserRULE_alter_user_editions_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6931) + p.User_editions_clause() + } + p.SetState(6941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(6932) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6933) + p.Regular_id() + } + p.SetState(6938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6934) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6935) + p.Regular_id() + } + + p.SetState(6940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6943) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProxy_clauseContext is an interface to support dynamic dispatch. +type IProxy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + CONNECT() antlr.TerminalNode + THROUGH() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + USERS() antlr.TerminalNode + User_object_name() IUser_object_nameContext + GRANT() antlr.TerminalNode + WITH() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + AUTHENTICATED() antlr.TerminalNode + USING() antlr.TerminalNode + NO() antlr.TerminalNode + ROLES() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_clause() IRole_clauseContext + PASSWORD() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + DISTINGUISHED() antlr.TerminalNode + NAME() antlr.TerminalNode + + // IsProxy_clauseContext differentiates from other interfaces. + IsProxy_clauseContext() +} + +type Proxy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProxy_clauseContext() *Proxy_clauseContext { + var p = new(Proxy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proxy_clause + return p +} + +func InitEmptyProxy_clauseContext(p *Proxy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proxy_clause +} + +func (*Proxy_clauseContext) IsProxy_clauseContext() {} + +func NewProxy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proxy_clauseContext { + var p = new(Proxy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_proxy_clause + + return p +} + +func (s *Proxy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proxy_clauseContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Proxy_clauseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Proxy_clauseContext) THROUGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHROUGH, 0) +} + +func (s *Proxy_clauseContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTERPRISE, 0) +} + +func (s *Proxy_clauseContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Proxy_clauseContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Proxy_clauseContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Proxy_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Proxy_clauseContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Proxy_clauseContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREQUIRED, 0) +} + +func (s *Proxy_clauseContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Proxy_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Proxy_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Proxy_clauseContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Proxy_clauseContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Proxy_clauseContext) Role_clause() IRole_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_clauseContext) +} + +func (s *Proxy_clauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Proxy_clauseContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCERTIFICATE, 0) +} + +func (s *Proxy_clauseContext) DISTINGUISHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINGUISHED, 0) +} + +func (s *Proxy_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Proxy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proxy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proxy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProxy_clause(s) + } +} + +func (s *Proxy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProxy_clause(s) + } +} + +func (p *PlSqlParser) Proxy_clause() (localctx IProxy_clauseContext) { + localctx = NewProxy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, PlSqlParserRULE_proxy_clause) + var _la int + + p.SetState(6985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREVOKE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6946) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6947) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6948) + p.Match(PlSqlParserTHROUGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6949) + p.Match(PlSqlParserENTERPRISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6950) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6951) + p.User_object_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserGRANT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6954) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6955) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6956) + p.Match(PlSqlParserTHROUGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6957) + p.Match(PlSqlParserENTERPRISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6958) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6959) + p.User_object_name() + } + p.SetState(6967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6960) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + { + p.SetState(6961) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6962) + p.Match(PlSqlParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROLE: + { + p.SetState(6963) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6964) + p.Role_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(6971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHENTICATION { + { + p.SetState(6969) + p.Match(PlSqlParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6970) + p.Match(PlSqlParserREQUIRED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHENTICATED { + { + p.SetState(6973) + p.Match(PlSqlParserAUTHENTICATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6974) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPASSWORD: + { + p.SetState(6975) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCERTIFICATE: + { + p.SetState(6976) + p.Match(PlSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISTINGUISHED: + { + p.SetState(6977) + p.Match(PlSqlParserDISTINGUISHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6978) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_namesContext is an interface to support dynamic dispatch. +type IContainer_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsContainer_namesContext differentiates from other interfaces. + IsContainer_namesContext() +} + +type Container_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_namesContext() *Container_namesContext { + var p = new(Container_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_names + return p +} + +func InitEmptyContainer_namesContext(p *Container_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_names +} + +func (*Container_namesContext) IsContainer_namesContext() {} + +func NewContainer_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_namesContext { + var p = new(Container_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_names + + return p +} + +func (s *Container_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Container_namesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Container_namesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Container_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Container_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Container_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Container_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_names(s) + } +} + +func (s *Container_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_names(s) + } +} + +func (p *PlSqlParser) Container_names() (localctx IContainer_namesContext) { + localctx = NewContainer_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, PlSqlParserRULE_container_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6987) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6988) + p.Id_expression() + } + p.SetState(6993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6989) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6990) + p.Id_expression() + } + + p.SetState(6995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6996) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_container_dataContext is an interface to support dynamic dispatch. +type ISet_container_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + CONTAINER_DATA() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + ALL() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Container_names() IContainer_namesContext + + // IsSet_container_dataContext differentiates from other interfaces. + IsSet_container_dataContext() +} + +type Set_container_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_container_dataContext() *Set_container_dataContext { + var p = new(Set_container_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_container_data + return p +} + +func InitEmptySet_container_dataContext(p *Set_container_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_container_data +} + +func (*Set_container_dataContext) IsSet_container_dataContext() {} + +func NewSet_container_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_container_dataContext { + var p = new(Set_container_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_container_data + + return p +} + +func (s *Set_container_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_container_dataContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_container_dataContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Set_container_dataContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Set_container_dataContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Set_container_dataContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Set_container_dataContext) Container_names() IContainer_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_namesContext) +} + +func (s *Set_container_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_container_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_container_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_container_data(s) + } +} + +func (s *Set_container_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_container_data(s) + } +} + +func (p *PlSqlParser) Set_container_data() (localctx ISet_container_dataContext) { + localctx = NewSet_container_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, PlSqlParserRULE_set_container_data) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6998) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6999) + p.Match(PlSqlParserCONTAINER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7000) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(7001) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(7002) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(7003) + p.Container_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_rem_container_dataContext is an interface to support dynamic dispatch. +type IAdd_rem_container_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER_DATA() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Container_names() IContainer_namesContext + ADD() antlr.TerminalNode + REMOVE() antlr.TerminalNode + + // IsAdd_rem_container_dataContext differentiates from other interfaces. + IsAdd_rem_container_dataContext() +} + +type Add_rem_container_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_rem_container_dataContext() *Add_rem_container_dataContext { + var p = new(Add_rem_container_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_rem_container_data + return p +} + +func InitEmptyAdd_rem_container_dataContext(p *Add_rem_container_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_rem_container_data +} + +func (*Add_rem_container_dataContext) IsAdd_rem_container_dataContext() {} + +func NewAdd_rem_container_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_rem_container_dataContext { + var p = new(Add_rem_container_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_rem_container_data + + return p +} + +func (s *Add_rem_container_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_rem_container_dataContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Add_rem_container_dataContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Add_rem_container_dataContext) Container_names() IContainer_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_namesContext) +} + +func (s *Add_rem_container_dataContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_rem_container_dataContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Add_rem_container_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_rem_container_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_rem_container_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_rem_container_data(s) + } +} + +func (s *Add_rem_container_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_rem_container_data(s) + } +} + +func (p *PlSqlParser) Add_rem_container_data() (localctx IAdd_rem_container_dataContext) { + localctx = NewAdd_rem_container_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, PlSqlParserRULE_add_rem_container_data) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7006) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7007) + p.Match(PlSqlParserCONTAINER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7008) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7009) + p.Container_names() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_data_clauseContext is an interface to support dynamic dispatch. +type IContainer_data_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_container_data() ISet_container_dataContext + Add_rem_container_data() IAdd_rem_container_dataContext + FOR() antlr.TerminalNode + Container_tableview_name() IContainer_tableview_nameContext + + // IsContainer_data_clauseContext differentiates from other interfaces. + IsContainer_data_clauseContext() +} + +type Container_data_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_data_clauseContext() *Container_data_clauseContext { + var p = new(Container_data_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_data_clause + return p +} + +func InitEmptyContainer_data_clauseContext(p *Container_data_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_data_clause +} + +func (*Container_data_clauseContext) IsContainer_data_clauseContext() {} + +func NewContainer_data_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_data_clauseContext { + var p = new(Container_data_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_data_clause + + return p +} + +func (s *Container_data_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_data_clauseContext) Set_container_data() ISet_container_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_container_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_container_dataContext) +} + +func (s *Container_data_clauseContext) Add_rem_container_data() IAdd_rem_container_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_rem_container_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_rem_container_dataContext) +} + +func (s *Container_data_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Container_data_clauseContext) Container_tableview_name() IContainer_tableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_tableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_tableview_nameContext) +} + +func (s *Container_data_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_data_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_data_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_data_clause(s) + } +} + +func (s *Container_data_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_data_clause(s) + } +} + +func (p *PlSqlParser) Container_data_clause() (localctx IContainer_data_clauseContext) { + localctx = NewContainer_data_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, PlSqlParserRULE_container_data_clause) + var _la int + + p.SetState(7017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7011) + p.Set_container_data() + } + + case PlSqlParserADD, PlSqlParserREMOVE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7012) + p.Add_rem_container_data() + } + p.SetState(7015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(7013) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7014) + p.Container_tableview_name() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdminister_key_managementContext is an interface to support dynamic dispatch. +type IAdminister_key_managementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADMINISTER() antlr.TerminalNode + KEY() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + Keystore_management_clauses() IKeystore_management_clausesContext + Key_management_clauses() IKey_management_clausesContext + Secret_management_clauses() ISecret_management_clausesContext + Zero_downtime_software_patching_clauses() IZero_downtime_software_patching_clausesContext + + // IsAdminister_key_managementContext differentiates from other interfaces. + IsAdminister_key_managementContext() +} + +type Administer_key_managementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdminister_key_managementContext() *Administer_key_managementContext { + var p = new(Administer_key_managementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_administer_key_management + return p +} + +func InitEmptyAdminister_key_managementContext(p *Administer_key_managementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_administer_key_management +} + +func (*Administer_key_managementContext) IsAdminister_key_managementContext() {} + +func NewAdminister_key_managementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Administer_key_managementContext { + var p = new(Administer_key_managementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_administer_key_management + + return p +} + +func (s *Administer_key_managementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Administer_key_managementContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *Administer_key_managementContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Administer_key_managementContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Administer_key_managementContext) Keystore_management_clauses() IKeystore_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_management_clausesContext) +} + +func (s *Administer_key_managementContext) Key_management_clauses() IKey_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_management_clausesContext) +} + +func (s *Administer_key_managementContext) Secret_management_clauses() ISecret_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecret_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecret_management_clausesContext) +} + +func (s *Administer_key_managementContext) Zero_downtime_software_patching_clauses() IZero_downtime_software_patching_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZero_downtime_software_patching_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZero_downtime_software_patching_clausesContext) +} + +func (s *Administer_key_managementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Administer_key_managementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Administer_key_managementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdminister_key_management(s) + } +} + +func (s *Administer_key_managementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdminister_key_management(s) + } +} + +func (p *PlSqlParser) Administer_key_management() (localctx IAdminister_key_managementContext) { + localctx = NewAdminister_key_managementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, PlSqlParserRULE_administer_key_management) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7019) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7020) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7021) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 695, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7022) + p.Keystore_management_clauses() + } + + case 2: + { + p.SetState(7023) + p.Key_management_clauses() + } + + case 3: + { + p.SetState(7024) + p.Secret_management_clauses() + } + + case 4: + { + p.SetState(7025) + p.Zero_downtime_software_patching_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeystore_management_clausesContext is an interface to support dynamic dispatch. +type IKeystore_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Create_keystore() ICreate_keystoreContext + Open_keystore() IOpen_keystoreContext + Close_keystore() IClose_keystoreContext + Backup_keystore() IBackup_keystoreContext + Alter_keystore_password() IAlter_keystore_passwordContext + Merge_into_new_keystore() IMerge_into_new_keystoreContext + Merge_into_existing_keystore() IMerge_into_existing_keystoreContext + Isolate_keystore() IIsolate_keystoreContext + Unite_keystore() IUnite_keystoreContext + + // IsKeystore_management_clausesContext differentiates from other interfaces. + IsKeystore_management_clausesContext() +} + +type Keystore_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeystore_management_clausesContext() *Keystore_management_clausesContext { + var p = new(Keystore_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses + return p +} + +func InitEmptyKeystore_management_clausesContext(p *Keystore_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses +} + +func (*Keystore_management_clausesContext) IsKeystore_management_clausesContext() {} + +func NewKeystore_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keystore_management_clausesContext { + var p = new(Keystore_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses + + return p +} + +func (s *Keystore_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keystore_management_clausesContext) Create_keystore() ICreate_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Open_keystore() IOpen_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Close_keystore() IClose_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClose_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClose_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Backup_keystore() IBackup_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Alter_keystore_password() IAlter_keystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_keystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_keystore_passwordContext) +} + +func (s *Keystore_management_clausesContext) Merge_into_new_keystore() IMerge_into_new_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_into_new_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_into_new_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Merge_into_existing_keystore() IMerge_into_existing_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_into_existing_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_into_existing_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Isolate_keystore() IIsolate_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIsolate_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIsolate_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Unite_keystore() IUnite_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnite_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnite_keystoreContext) +} + +func (s *Keystore_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keystore_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keystore_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeystore_management_clauses(s) + } +} + +func (s *Keystore_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeystore_management_clauses(s) + } +} + +func (p *PlSqlParser) Keystore_management_clauses() (localctx IKeystore_management_clausesContext) { + localctx = NewKeystore_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, PlSqlParserRULE_keystore_management_clauses) + p.SetState(7037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7028) + p.Create_keystore() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7029) + p.Open_keystore() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7030) + p.Close_keystore() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7031) + p.Backup_keystore() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7032) + p.Alter_keystore_password() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7033) + p.Merge_into_new_keystore() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7034) + p.Merge_into_existing_keystore() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7035) + p.Isolate_keystore() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7036) + p.Unite_keystore() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_keystoreContext is an interface to support dynamic dispatch. +type ICreate_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl returns the ksl token. + GetKsl() antlr.Token + + // SetKsl sets the ksl token. + SetKsl(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + FROM() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsCreate_keystoreContext differentiates from other interfaces. + IsCreate_keystoreContext() +} + +type Create_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl antlr.Token +} + +func NewEmptyCreate_keystoreContext() *Create_keystoreContext { + var p = new(Create_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_keystore + return p +} + +func InitEmptyCreate_keystoreContext(p *Create_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_keystore +} + +func (*Create_keystoreContext) IsCreate_keystoreContext() {} + +func NewCreate_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keystoreContext { + var p = new(Create_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_keystore + + return p +} + +func (s *Create_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_keystoreContext) GetKsl() antlr.Token { return s.ksl } + +func (s *Create_keystoreContext) SetKsl(v antlr.Token) { s.ksl = v } + +func (s *Create_keystoreContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Create_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Create_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Create_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Create_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Create_keystoreContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Create_keystoreContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_keystoreContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Create_keystoreContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Create_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_keystore(s) + } +} + +func (s *Create_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_keystore(s) + } +} + +func (p *PlSqlParser) Create_keystore() (localctx ICreate_keystoreContext) { + localctx = NewCreate_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, PlSqlParserRULE_create_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7039) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserKEYSTORE: + { + p.SetState(7040) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7041) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_keystoreContext).ksl = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTO_LOGIN, PlSqlParserLOCAL: + p.SetState(7043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7042) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7045) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7046) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7047) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7048) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7049) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_keystoreContext).ksl = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7052) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7053) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7054) + p.Keystore_password() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_keystoreContext is an interface to support dynamic dispatch. +type IOpen_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + OPEN() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Force_keystore() IForce_keystoreContext + Container_clause() IContainer_clauseContext + + // IsOpen_keystoreContext differentiates from other interfaces. + IsOpen_keystoreContext() +} + +type Open_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_keystoreContext() *Open_keystoreContext { + var p = new(Open_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_keystore + return p +} + +func InitEmptyOpen_keystoreContext(p *Open_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_keystore +} + +func (*Open_keystoreContext) IsOpen_keystoreContext() {} + +func NewOpen_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_keystoreContext { + var p = new(Open_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_keystore + + return p +} + +func (s *Open_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_keystoreContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Open_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Open_keystoreContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Open_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Open_keystoreContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Open_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_keystore(s) + } +} + +func (s *Open_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_keystore(s) + } +} + +func (p *PlSqlParser) Open_keystore() (localctx IOpen_keystoreContext) { + localctx = NewOpen_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, PlSqlParserRULE_open_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7056) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7057) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7058) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7059) + p.Force_keystore() + } + + } + { + p.SetState(7062) + p.Identified_by_store() + } + p.SetState(7064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7063) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForce_keystoreContext is an interface to support dynamic dispatch. +type IForce_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORCE() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + + // IsForce_keystoreContext differentiates from other interfaces. + IsForce_keystoreContext() +} + +type Force_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForce_keystoreContext() *Force_keystoreContext { + var p = new(Force_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_keystore + return p +} + +func InitEmptyForce_keystoreContext(p *Force_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_keystore +} + +func (*Force_keystoreContext) IsForce_keystoreContext() {} + +func NewForce_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Force_keystoreContext { + var p = new(Force_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_force_keystore + + return p +} + +func (s *Force_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Force_keystoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Force_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Force_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Force_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Force_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForce_keystore(s) + } +} + +func (s *Force_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForce_keystore(s) + } +} + +func (p *PlSqlParser) Force_keystore() (localctx IForce_keystoreContext) { + localctx = NewForce_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, PlSqlParserRULE_force_keystore) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7066) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7067) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClose_keystoreContext is an interface to support dynamic dispatch. +type IClose_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + CLOSE() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Container_clause() IContainer_clauseContext + + // IsClose_keystoreContext differentiates from other interfaces. + IsClose_keystoreContext() +} + +type Close_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClose_keystoreContext() *Close_keystoreContext { + var p = new(Close_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_keystore + return p +} + +func InitEmptyClose_keystoreContext(p *Close_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_keystore +} + +func (*Close_keystoreContext) IsClose_keystoreContext() {} + +func NewClose_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_keystoreContext { + var p = new(Close_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_close_keystore + + return p +} + +func (s *Close_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Close_keystoreContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Close_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Close_keystoreContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Close_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Close_keystoreContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Close_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Close_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Close_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClose_keystore(s) + } +} + +func (s *Close_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClose_keystore(s) + } +} + +func (p *PlSqlParser) Close_keystore() (localctx IClose_keystoreContext) { + localctx = NewClose_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, PlSqlParserRULE_close_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7069) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7070) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7071) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7072) + p.Identified_by_store() + } + + } + p.SetState(7076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7075) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_keystoreContext is an interface to support dynamic dispatch. +type IBackup_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBi returns the bi token. + GetBi() antlr.Token + + // GetKsl returns the ksl token. + GetKsl() antlr.Token + + // SetBi sets the bi token. + SetBi(antlr.Token) + + // SetKsl sets the ksl token. + SetKsl(antlr.Token) + + // Getter signatures + BACKUP() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + USING() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + TO() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + + // IsBackup_keystoreContext differentiates from other interfaces. + IsBackup_keystoreContext() +} + +type Backup_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bi antlr.Token + ksl antlr.Token +} + +func NewEmptyBackup_keystoreContext() *Backup_keystoreContext { + var p = new(Backup_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_backup_keystore + return p +} + +func InitEmptyBackup_keystoreContext(p *Backup_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_backup_keystore +} + +func (*Backup_keystoreContext) IsBackup_keystoreContext() {} + +func NewBackup_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_keystoreContext { + var p = new(Backup_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_backup_keystore + + return p +} + +func (s *Backup_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_keystoreContext) GetBi() antlr.Token { return s.bi } + +func (s *Backup_keystoreContext) GetKsl() antlr.Token { return s.ksl } + +func (s *Backup_keystoreContext) SetBi(v antlr.Token) { s.bi = v } + +func (s *Backup_keystoreContext) SetKsl(v antlr.Token) { s.ksl = v } + +func (s *Backup_keystoreContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Backup_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Backup_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Backup_keystoreContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Backup_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Backup_keystoreContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Backup_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Backup_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Backup_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBackup_keystore(s) + } +} + +func (s *Backup_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBackup_keystore(s) + } +} + +func (p *PlSqlParser) Backup_keystore() (localctx IBackup_keystoreContext) { + localctx = NewBackup_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, PlSqlParserRULE_backup_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7078) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7079) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7080) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7081) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Backup_keystoreContext).bi = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7084) + p.Force_keystore() + } + + } + { + p.SetState(7087) + p.Identified_by_store() + } + p.SetState(7090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(7088) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7089) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Backup_keystoreContext).ksl = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_keystore_passwordContext is an interface to support dynamic dispatch. +type IAlter_keystore_passwordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IKeystore_passwordContext + + // GetN returns the n rule contexts. + GetN() IKeystore_passwordContext + + // SetO sets the o rule contexts. + SetO(IKeystore_passwordContext) + + // SetN sets the n rule contexts. + SetN(IKeystore_passwordContext) + + // Getter signatures + ALTER() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + SET() antlr.TerminalNode + AllKeystore_password() []IKeystore_passwordContext + Keystore_password(i int) IKeystore_passwordContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsAlter_keystore_passwordContext differentiates from other interfaces. + IsAlter_keystore_passwordContext() +} + +type Alter_keystore_passwordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IKeystore_passwordContext + n IKeystore_passwordContext +} + +func NewEmptyAlter_keystore_passwordContext() *Alter_keystore_passwordContext { + var p = new(Alter_keystore_passwordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_keystore_password + return p +} + +func InitEmptyAlter_keystore_passwordContext(p *Alter_keystore_passwordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_keystore_password +} + +func (*Alter_keystore_passwordContext) IsAlter_keystore_passwordContext() {} + +func NewAlter_keystore_passwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_keystore_passwordContext { + var p = new(Alter_keystore_passwordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_keystore_password + + return p +} + +func (s *Alter_keystore_passwordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_keystore_passwordContext) GetO() IKeystore_passwordContext { return s.o } + +func (s *Alter_keystore_passwordContext) GetN() IKeystore_passwordContext { return s.n } + +func (s *Alter_keystore_passwordContext) SetO(v IKeystore_passwordContext) { s.o = v } + +func (s *Alter_keystore_passwordContext) SetN(v IKeystore_passwordContext) { s.n = v } + +func (s *Alter_keystore_passwordContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_keystore_passwordContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Alter_keystore_passwordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Alter_keystore_passwordContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Alter_keystore_passwordContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Alter_keystore_passwordContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_keystore_passwordContext) AllKeystore_password() []IKeystore_passwordContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeystore_passwordContext); ok { + len++ + } + } + + tst := make([]IKeystore_passwordContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeystore_passwordContext); ok { + tst[i] = t.(IKeystore_passwordContext) + i++ + } + } + + return tst +} + +func (s *Alter_keystore_passwordContext) Keystore_password(i int) IKeystore_passwordContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Alter_keystore_passwordContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Alter_keystore_passwordContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Alter_keystore_passwordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_keystore_passwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_keystore_passwordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_keystore_password(s) + } +} + +func (s *Alter_keystore_passwordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_keystore_password(s) + } +} + +func (p *PlSqlParser) Alter_keystore_password() (localctx IAlter_keystore_passwordContext) { + localctx = NewAlter_keystore_passwordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, PlSqlParserRULE_alter_keystore_password) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7092) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7093) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7094) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7095) + p.Force_keystore() + } + + } + { + p.SetState(7098) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7099) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7100) + + var _x = p.Keystore_password() + + localctx.(*Alter_keystore_passwordContext).o = _x + } + { + p.SetState(7101) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7102) + + var _x = p.Keystore_password() + + localctx.(*Alter_keystore_passwordContext).n = _x + } + p.SetState(7104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7103) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_into_new_keystoreContext is an interface to support dynamic dispatch. +type IMerge_into_new_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // GetKsl2 returns the ksl2 token. + GetKsl2() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // SetKsl2 sets the ksl2 token. + SetKsl2(antlr.Token) + + // Getter signatures + MERGE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AND() antlr.TerminalNode + INTO() antlr.TerminalNode + NEW() antlr.TerminalNode + AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext + Identified_by_password_clause(i int) IIdentified_by_password_clauseContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + + // IsMerge_into_new_keystoreContext differentiates from other interfaces. + IsMerge_into_new_keystoreContext() +} + +type Merge_into_new_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksl2 antlr.Token +} + +func NewEmptyMerge_into_new_keystoreContext() *Merge_into_new_keystoreContext { + var p = new(Merge_into_new_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore + return p +} + +func InitEmptyMerge_into_new_keystoreContext(p *Merge_into_new_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore +} + +func (*Merge_into_new_keystoreContext) IsMerge_into_new_keystoreContext() {} + +func NewMerge_into_new_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_into_new_keystoreContext { + var p = new(Merge_into_new_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore + + return p +} + +func (s *Merge_into_new_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_into_new_keystoreContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Merge_into_new_keystoreContext) GetKsl2() antlr.Token { return s.ksl2 } + +func (s *Merge_into_new_keystoreContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Merge_into_new_keystoreContext) SetKsl2(v antlr.Token) { s.ksl2 = v } + +func (s *Merge_into_new_keystoreContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_into_new_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Merge_into_new_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Merge_into_new_keystoreContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Merge_into_new_keystoreContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_into_new_keystoreContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Merge_into_new_keystoreContext) AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_by_password_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_by_password_clauseContext); ok { + tst[i] = t.(IIdentified_by_password_clauseContext) + i++ + } + } + + return tst +} + +func (s *Merge_into_new_keystoreContext) Identified_by_password_clause(i int) IIdentified_by_password_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_password_clauseContext) +} + +func (s *Merge_into_new_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Merge_into_new_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Merge_into_new_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_into_new_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_into_new_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_into_new_keystore(s) + } +} + +func (s *Merge_into_new_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_into_new_keystore(s) + } +} + +func (p *PlSqlParser) Merge_into_new_keystore() (localctx IMerge_into_new_keystoreContext) { + localctx = NewMerge_into_new_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, PlSqlParserRULE_merge_into_new_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7106) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7107) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7108) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7109) + p.Identified_by_password_clause() + } + + } + { + p.SetState(7112) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7113) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7114) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7115) + p.Identified_by_password_clause() + } + + } + { + p.SetState(7118) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7119) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7120) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7121) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7122) + p.Identified_by_password_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_into_existing_keystoreContext is an interface to support dynamic dispatch. +type IMerge_into_existing_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // GetKsl2 returns the ksl2 token. + GetKsl2() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // SetKsl2 sets the ksl2 token. + SetKsl2(antlr.Token) + + // Getter signatures + MERGE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + EXISTING() antlr.TerminalNode + AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext + Identified_by_password_clause(i int) IIdentified_by_password_clauseContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + With_backup_clause() IWith_backup_clauseContext + + // IsMerge_into_existing_keystoreContext differentiates from other interfaces. + IsMerge_into_existing_keystoreContext() +} + +type Merge_into_existing_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksl2 antlr.Token +} + +func NewEmptyMerge_into_existing_keystoreContext() *Merge_into_existing_keystoreContext { + var p = new(Merge_into_existing_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore + return p +} + +func InitEmptyMerge_into_existing_keystoreContext(p *Merge_into_existing_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore +} + +func (*Merge_into_existing_keystoreContext) IsMerge_into_existing_keystoreContext() {} + +func NewMerge_into_existing_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_into_existing_keystoreContext { + var p = new(Merge_into_existing_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore + + return p +} + +func (s *Merge_into_existing_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_into_existing_keystoreContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Merge_into_existing_keystoreContext) GetKsl2() antlr.Token { return s.ksl2 } + +func (s *Merge_into_existing_keystoreContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Merge_into_existing_keystoreContext) SetKsl2(v antlr.Token) { s.ksl2 = v } + +func (s *Merge_into_existing_keystoreContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_into_existing_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Merge_into_existing_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Merge_into_existing_keystoreContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_into_existing_keystoreContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Merge_into_existing_keystoreContext) AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_by_password_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_by_password_clauseContext); ok { + tst[i] = t.(IIdentified_by_password_clauseContext) + i++ + } + } + + return tst +} + +func (s *Merge_into_existing_keystoreContext) Identified_by_password_clause(i int) IIdentified_by_password_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_password_clauseContext) +} + +func (s *Merge_into_existing_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Merge_into_existing_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Merge_into_existing_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Merge_into_existing_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_into_existing_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_into_existing_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_into_existing_keystore(s) + } +} + +func (s *Merge_into_existing_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_into_existing_keystore(s) + } +} + +func (p *PlSqlParser) Merge_into_existing_keystore() (localctx IMerge_into_existing_keystoreContext) { + localctx = NewMerge_into_existing_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, PlSqlParserRULE_merge_into_existing_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7124) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7125) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7126) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_existing_keystoreContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7127) + p.Identified_by_password_clause() + } + + } + { + p.SetState(7130) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7131) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7132) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7133) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_existing_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7134) + p.Identified_by_password_clause() + } + p.SetState(7136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7135) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIsolate_keystoreContext is an interface to support dynamic dispatch. +type IIsolate_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetI returns the i rule contexts. + GetI() IKeystore_passwordContext + + // SetI sets the i rule contexts. + SetI(IKeystore_passwordContext) + + // Getter signatures + ISOLATE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + FROM() antlr.TerminalNode + ROOT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Keystore_password() IKeystore_passwordContext + FORCE() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsIsolate_keystoreContext differentiates from other interfaces. + IsIsolate_keystoreContext() +} + +type Isolate_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + i IKeystore_passwordContext +} + +func NewEmptyIsolate_keystoreContext() *Isolate_keystoreContext { + var p = new(Isolate_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_isolate_keystore + return p +} + +func InitEmptyIsolate_keystoreContext(p *Isolate_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_isolate_keystore +} + +func (*Isolate_keystoreContext) IsIsolate_keystoreContext() {} + +func NewIsolate_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Isolate_keystoreContext { + var p = new(Isolate_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_isolate_keystore + + return p +} + +func (s *Isolate_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Isolate_keystoreContext) GetI() IKeystore_passwordContext { return s.i } + +func (s *Isolate_keystoreContext) SetI(v IKeystore_passwordContext) { s.i = v } + +func (s *Isolate_keystoreContext) ISOLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATE, 0) +} + +func (s *Isolate_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Isolate_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Isolate_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Isolate_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Isolate_keystoreContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Isolate_keystoreContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Isolate_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Isolate_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Isolate_keystoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Isolate_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Isolate_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Isolate_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Isolate_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Isolate_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIsolate_keystore(s) + } +} + +func (s *Isolate_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIsolate_keystore(s) + } +} + +func (p *PlSqlParser) Isolate_keystore() (localctx IIsolate_keystoreContext) { + localctx = NewIsolate_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, PlSqlParserRULE_isolate_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7138) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7141) + p.Match(PlSqlParserISOLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7142) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7143) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7144) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7145) + + var _x = p.Keystore_password() + + localctx.(*Isolate_keystoreContext).i = _x + } + { + p.SetState(7146) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7147) + p.Match(PlSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7148) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7149) + p.Force_keystore() + } + + } + { + p.SetState(7152) + p.Identified_by_store() + } + p.SetState(7154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7153) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnite_keystoreContext is an interface to support dynamic dispatch. +type IUnite_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetI returns the i rule contexts. + GetI() IKeystore_passwordContext + + // SetI sets the i rule contexts. + SetI(IKeystore_passwordContext) + + // Getter signatures + UNITE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + WITH() antlr.TerminalNode + ROOT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Keystore_password() IKeystore_passwordContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsUnite_keystoreContext differentiates from other interfaces. + IsUnite_keystoreContext() +} + +type Unite_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + i IKeystore_passwordContext +} + +func NewEmptyUnite_keystoreContext() *Unite_keystoreContext { + var p = new(Unite_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unite_keystore + return p +} + +func InitEmptyUnite_keystoreContext(p *Unite_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unite_keystore +} + +func (*Unite_keystoreContext) IsUnite_keystoreContext() {} + +func NewUnite_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unite_keystoreContext { + var p = new(Unite_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unite_keystore + + return p +} + +func (s *Unite_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unite_keystoreContext) GetI() IKeystore_passwordContext { return s.i } + +func (s *Unite_keystoreContext) SetI(v IKeystore_passwordContext) { s.i = v } + +func (s *Unite_keystoreContext) UNITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNITE, 0) +} + +func (s *Unite_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Unite_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Unite_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Unite_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Unite_keystoreContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Unite_keystoreContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Unite_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Unite_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Unite_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Unite_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Unite_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unite_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unite_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnite_keystore(s) + } +} + +func (s *Unite_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnite_keystore(s) + } +} + +func (p *PlSqlParser) Unite_keystore() (localctx IUnite_keystoreContext) { + localctx = NewUnite_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, PlSqlParserRULE_unite_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7156) + p.Match(PlSqlParserUNITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7157) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7158) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7159) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7160) + + var _x = p.Keystore_password() + + localctx.(*Unite_keystoreContext).i = _x + } + { + p.SetState(7161) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7162) + p.Match(PlSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7163) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7164) + p.Force_keystore() + } + + } + { + p.SetState(7167) + p.Identified_by_store() + } + p.SetState(7169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7168) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_management_clausesContext is an interface to support dynamic dispatch. +type IKey_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_key() ISet_keyContext + Create_key() ICreate_keyContext + Use_key() IUse_keyContext + Set_key_tag() ISet_key_tagContext + Export_keys() IExport_keysContext + Import_keys() IImport_keysContext + Migrate_keys() IMigrate_keysContext + Reverse_migrate_keys() IReverse_migrate_keysContext + Move_keys() IMove_keysContext + + // IsKey_management_clausesContext differentiates from other interfaces. + IsKey_management_clausesContext() +} + +type Key_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_management_clausesContext() *Key_management_clausesContext { + var p = new(Key_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_management_clauses + return p +} + +func InitEmptyKey_management_clausesContext(p *Key_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_management_clauses +} + +func (*Key_management_clausesContext) IsKey_management_clausesContext() {} + +func NewKey_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_management_clausesContext { + var p = new(Key_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_management_clauses + + return p +} + +func (s *Key_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_management_clausesContext) Set_key() ISet_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_keyContext) +} + +func (s *Key_management_clausesContext) Create_key() ICreate_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_keyContext) +} + +func (s *Key_management_clausesContext) Use_key() IUse_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_keyContext) +} + +func (s *Key_management_clausesContext) Set_key_tag() ISet_key_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_key_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_key_tagContext) +} + +func (s *Key_management_clausesContext) Export_keys() IExport_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_keysContext) +} + +func (s *Key_management_clausesContext) Import_keys() IImport_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_keysContext) +} + +func (s *Key_management_clausesContext) Migrate_keys() IMigrate_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMigrate_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMigrate_keysContext) +} + +func (s *Key_management_clausesContext) Reverse_migrate_keys() IReverse_migrate_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReverse_migrate_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReverse_migrate_keysContext) +} + +func (s *Key_management_clausesContext) Move_keys() IMove_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_keysContext) +} + +func (s *Key_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_management_clauses(s) + } +} + +func (s *Key_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_management_clauses(s) + } +} + +func (p *PlSqlParser) Key_management_clauses() (localctx IKey_management_clausesContext) { + localctx = NewKey_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, PlSqlParserRULE_key_management_clauses) + p.SetState(7180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7171) + p.Set_key() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7172) + p.Create_key() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7173) + p.Use_key() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7174) + p.Set_key_tag() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7175) + p.Export_keys() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7176) + p.Import_keys() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7177) + p.Migrate_keys() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7178) + p.Reverse_migrate_keys() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7179) + p.Move_keys() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_keyContext is an interface to support dynamic dispatch. +type ISet_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Mk() IMkContext + Using_tag_clause() IUsing_tag_clauseContext + Using_algorithm_clause() IUsing_algorithm_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + Container_clause() IContainer_clauseContext + Mkid() IMkidContext + COLON() antlr.TerminalNode + + // IsSet_keyContext differentiates from other interfaces. + IsSet_keyContext() +} + +type Set_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_keyContext() *Set_keyContext { + var p = new(Set_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key + return p +} + +func InitEmptySet_keyContext(p *Set_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key +} + +func (*Set_keyContext) IsSet_keyContext() {} + +func NewSet_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_keyContext { + var p = new(Set_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_key + + return p +} + +func (s *Set_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_keyContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Set_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Set_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Set_keyContext) Mk() IMkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkContext) +} + +func (s *Set_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Set_keyContext) Using_algorithm_clause() IUsing_algorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_algorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_algorithm_clauseContext) +} + +func (s *Set_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Set_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Set_keyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Set_keyContext) Mkid() IMkidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkidContext) +} + +func (s *Set_keyContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Set_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_key(s) + } +} + +func (s *Set_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_key(s) + } +} + +func (p *PlSqlParser) Set_key() (localctx ISet_keyContext) { + localctx = NewSet_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, PlSqlParserRULE_set_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7182) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7183) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7186) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + p.SetState(7190) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext()) == 1 { + { + p.SetState(7187) + p.Mkid() + } + { + p.SetState(7188) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7192) + p.Mk() + } + + } + p.SetState(7196) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 721, p.GetParserRuleContext()) == 1 { + { + p.SetState(7195) + p.Using_tag_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7198) + p.Using_algorithm_clause() + } + + } + p.SetState(7202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7201) + p.Force_keystore() + } + + } + { + p.SetState(7204) + p.Identified_by_store() + } + p.SetState(7206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7205) + p.With_backup_clause() + } + + } + p.SetState(7209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7208) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_keyContext is an interface to support dynamic dispatch. +type ICreate_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Mk() IMkContext + Using_tag_clause() IUsing_tag_clauseContext + Using_algorithm_clause() IUsing_algorithm_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + Container_clause() IContainer_clauseContext + Mkid() IMkidContext + COLON() antlr.TerminalNode + + // IsCreate_keyContext differentiates from other interfaces. + IsCreate_keyContext() +} + +type Create_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_keyContext() *Create_keyContext { + var p = new(Create_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_key + return p +} + +func InitEmptyCreate_keyContext(p *Create_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_key +} + +func (*Create_keyContext) IsCreate_keyContext() {} + +func NewCreate_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keyContext { + var p = new(Create_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_key + + return p +} + +func (s *Create_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Create_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Create_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Create_keyContext) Mk() IMkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkContext) +} + +func (s *Create_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Create_keyContext) Using_algorithm_clause() IUsing_algorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_algorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_algorithm_clauseContext) +} + +func (s *Create_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Create_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Create_keyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_keyContext) Mkid() IMkidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkidContext) +} + +func (s *Create_keyContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Create_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_key(s) + } +} + +func (s *Create_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_key(s) + } +} + +func (p *PlSqlParser) Create_key() (localctx ICreate_keyContext) { + localctx = NewCreate_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, PlSqlParserRULE_create_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7211) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7212) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7215) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + p.SetState(7219) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 1 { + { + p.SetState(7216) + p.Mkid() + } + { + p.SetState(7217) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7221) + p.Mk() + } + + } + p.SetState(7225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 729, p.GetParserRuleContext()) == 1 { + { + p.SetState(7224) + p.Using_tag_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7227) + p.Using_algorithm_clause() + } + + } + p.SetState(7231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7230) + p.Force_keystore() + } + + } + { + p.SetState(7233) + p.Identified_by_store() + } + p.SetState(7235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7234) + p.With_backup_clause() + } + + } + p.SetState(7238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7237) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMkidContext is an interface to support dynamic dispatch. +type IMkidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsMkidContext differentiates from other interfaces. + IsMkidContext() +} + +type MkidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMkidContext() *MkidContext { + var p = new(MkidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mkid + return p +} + +func InitEmptyMkidContext(p *MkidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mkid +} + +func (*MkidContext) IsMkidContext() {} + +func NewMkidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MkidContext { + var p = new(MkidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mkid + + return p +} + +func (s *MkidContext) GetParser() antlr.Parser { return s.parser } + +func (s *MkidContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *MkidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MkidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MkidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMkid(s) + } +} + +func (s *MkidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMkid(s) + } +} + +func (p *PlSqlParser) Mkid() (localctx IMkidContext) { + localctx = NewMkidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, PlSqlParserRULE_mkid) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7240) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMkContext is an interface to support dynamic dispatch. +type IMkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsMkContext differentiates from other interfaces. + IsMkContext() +} + +type MkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMkContext() *MkContext { + var p = new(MkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mk + return p +} + +func InitEmptyMkContext(p *MkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mk +} + +func (*MkContext) IsMkContext() {} + +func NewMkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MkContext { + var p = new(MkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mk + + return p +} + +func (s *MkContext) GetParser() antlr.Parser { return s.parser } + +func (s *MkContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *MkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMk(s) + } +} + +func (s *MkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMk(s) + } +} + +func (p *PlSqlParser) Mk() (localctx IMkContext) { + localctx = NewMkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, PlSqlParserRULE_mk) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7242) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_keyContext is an interface to support dynamic dispatch. +type IUse_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetK returns the k token. + GetK() antlr.Token + + // SetK sets the k token. + SetK(antlr.Token) + + // Getter signatures + USE() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + CHAR_STRING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsUse_keyContext differentiates from other interfaces. + IsUse_keyContext() +} + +type Use_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + k antlr.Token +} + +func NewEmptyUse_keyContext() *Use_keyContext { + var p = new(Use_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_use_key + return p +} + +func InitEmptyUse_keyContext(p *Use_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_use_key +} + +func (*Use_keyContext) IsUse_keyContext() {} + +func NewUse_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_keyContext { + var p = new(Use_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_use_key + + return p +} + +func (s *Use_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_keyContext) GetK() antlr.Token { return s.k } + +func (s *Use_keyContext) SetK(v antlr.Token) { s.k = v } + +func (s *Use_keyContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Use_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Use_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Use_keyContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Use_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Use_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Use_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Use_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Use_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUse_key(s) + } +} + +func (s *Use_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUse_key(s) + } +} + +func (p *PlSqlParser) Use_key() (localctx IUse_keyContext) { + localctx = NewUse_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, PlSqlParserRULE_use_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7244) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7245) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7248) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7249) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Use_keyContext).k = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7250) + p.Using_tag_clause() + } + + } + p.SetState(7254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7253) + p.Force_keystore() + } + + } + { + p.SetState(7256) + p.Identified_by_store() + } + p.SetState(7258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7257) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_key_tagContext is an interface to support dynamic dispatch. +type ISet_key_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t token. + GetT() antlr.Token + + // GetK returns the k token. + GetK() antlr.Token + + // SetT sets the t token. + SetT(antlr.Token) + + // SetK sets the k token. + SetK(antlr.Token) + + // Getter signatures + SET() antlr.TerminalNode + TAG() antlr.TerminalNode + FOR() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsSet_key_tagContext differentiates from other interfaces. + IsSet_key_tagContext() +} + +type Set_key_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t antlr.Token + k antlr.Token +} + +func NewEmptySet_key_tagContext() *Set_key_tagContext { + var p = new(Set_key_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key_tag + return p +} + +func InitEmptySet_key_tagContext(p *Set_key_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key_tag +} + +func (*Set_key_tagContext) IsSet_key_tagContext() {} + +func NewSet_key_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_key_tagContext { + var p = new(Set_key_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_key_tag + + return p +} + +func (s *Set_key_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_key_tagContext) GetT() antlr.Token { return s.t } + +func (s *Set_key_tagContext) GetK() antlr.Token { return s.k } + +func (s *Set_key_tagContext) SetT(v antlr.Token) { s.t = v } + +func (s *Set_key_tagContext) SetK(v antlr.Token) { s.k = v } + +func (s *Set_key_tagContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_key_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Set_key_tagContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Set_key_tagContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Set_key_tagContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Set_key_tagContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Set_key_tagContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Set_key_tagContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Set_key_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_key_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_key_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_key_tag(s) + } +} + +func (s *Set_key_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_key_tag(s) + } +} + +func (p *PlSqlParser) Set_key_tag() (localctx ISet_key_tagContext) { + localctx = NewSet_key_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, PlSqlParserRULE_set_key_tag) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7260) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7261) + p.Match(PlSqlParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7262) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Set_key_tagContext).t = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7263) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7264) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Set_key_tagContext).k = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7265) + p.Force_keystore() + } + + } + { + p.SetState(7268) + p.Identified_by_store() + } + p.SetState(7270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7269) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExport_keysContext is an interface to support dynamic dispatch. +type IExport_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPORT() antlr.TerminalNode + KEYS() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + SECRET() antlr.TerminalNode + Secret() ISecretContext + TO() antlr.TerminalNode + Filename() IFilenameContext + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + IDENTIFIER() antlr.TerminalNode + IN() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExport_keysContext differentiates from other interfaces. + IsExport_keysContext() +} + +type Export_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_keysContext() *Export_keysContext { + var p = new(Export_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_export_keys + return p +} + +func InitEmptyExport_keysContext(p *Export_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_export_keys +} + +func (*Export_keysContext) IsExport_keysContext() {} + +func NewExport_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_keysContext { + var p = new(Export_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_export_keys + + return p +} + +func (s *Export_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_keysContext) EXPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPORT, 0) +} + +func (s *Export_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Export_keysContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Export_keysContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Export_keysContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Export_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Export_keysContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Export_keysContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Export_keysContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Export_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Export_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Export_keysContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Export_keysContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Export_keysContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Export_keysContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Export_keysContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Export_keysContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Export_keysContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Export_keysContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Export_keysContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Export_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExport_keys(s) + } +} + +func (s *Export_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExport_keys(s) + } +} + +func (p *PlSqlParser) Export_keys() (localctx IExport_keysContext) { + localctx = NewExport_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, PlSqlParserRULE_export_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7272) + p.Match(PlSqlParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7273) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7276) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7277) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7278) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7279) + p.Secret() + } + { + p.SetState(7280) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7281) + p.Filename() + } + p.SetState(7283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7282) + p.Force_keystore() + } + + } + { + p.SetState(7285) + p.Identified_by_store() + } + p.SetState(7303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7286) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7287) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7288) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(7289) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7290) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7291) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(7296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(7297) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7298) + p.Subquery() + } + { + p.SetState(7299) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_keysContext is an interface to support dynamic dispatch. +type IImport_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IMPORT() antlr.TerminalNode + KEYS() antlr.TerminalNode + WITH() antlr.TerminalNode + SECRET() antlr.TerminalNode + Secret() ISecretContext + FROM() antlr.TerminalNode + Filename() IFilenameContext + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsImport_keysContext differentiates from other interfaces. + IsImport_keysContext() +} + +type Import_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_keysContext() *Import_keysContext { + var p = new(Import_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_import_keys + return p +} + +func InitEmptyImport_keysContext(p *Import_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_import_keys +} + +func (*Import_keysContext) IsImport_keysContext() {} + +func NewImport_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_keysContext { + var p = new(Import_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_import_keys + + return p +} + +func (s *Import_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_keysContext) IMPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPORT, 0) +} + +func (s *Import_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Import_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Import_keysContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Import_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Import_keysContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Import_keysContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Import_keysContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Import_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Import_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Import_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Import_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImport_keys(s) + } +} + +func (s *Import_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImport_keys(s) + } +} + +func (p *PlSqlParser) Import_keys() (localctx IImport_keysContext) { + localctx = NewImport_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, PlSqlParserRULE_import_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7305) + p.Match(PlSqlParserIMPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7306) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7309) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7310) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7311) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7312) + p.Secret() + } + { + p.SetState(7313) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7314) + p.Filename() + } + p.SetState(7316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7315) + p.Force_keystore() + } + + } + { + p.SetState(7318) + p.Identified_by_store() + } + p.SetState(7320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7319) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMigrate_keysContext is an interface to support dynamic dispatch. +type IMigrate_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHsm returns the hsm rule contexts. + GetHsm() ISecretContext + + // SetHsm sets the hsm rule contexts. + SetHsm(ISecretContext) + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + USING() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + Secret() ISecretContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsMigrate_keysContext differentiates from other interfaces. + IsMigrate_keysContext() +} + +type Migrate_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hsm ISecretContext +} + +func NewEmptyMigrate_keysContext() *Migrate_keysContext { + var p = new(Migrate_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_migrate_keys + return p +} + +func InitEmptyMigrate_keysContext(p *Migrate_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_migrate_keys +} + +func (*Migrate_keysContext) IsMigrate_keysContext() {} + +func NewMigrate_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Migrate_keysContext { + var p = new(Migrate_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_migrate_keys + + return p +} + +func (s *Migrate_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Migrate_keysContext) GetHsm() ISecretContext { return s.hsm } + +func (s *Migrate_keysContext) SetHsm(v ISecretContext) { s.hsm = v } + +func (s *Migrate_keysContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Migrate_keysContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Migrate_keysContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Migrate_keysContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Migrate_keysContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Migrate_keysContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Migrate_keysContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Migrate_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Migrate_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Migrate_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Migrate_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Migrate_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Migrate_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Migrate_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMigrate_keys(s) + } +} + +func (s *Migrate_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMigrate_keys(s) + } +} + +func (p *PlSqlParser) Migrate_keys() (localctx IMigrate_keysContext) { + localctx = NewMigrate_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, PlSqlParserRULE_migrate_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7322) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7323) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7326) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7327) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7328) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7329) + + var _x = p.Secret() + + localctx.(*Migrate_keysContext).hsm = _x + } + p.SetState(7331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7330) + p.Force_keystore() + } + + } + { + p.SetState(7333) + p.Match(PlSqlParserMIGRATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7334) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7335) + p.Keystore_password() + } + p.SetState(7337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7336) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReverse_migrate_keysContext is an interface to support dynamic dispatch. +type IReverse_migrate_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s rule contexts. + GetS() ISecretContext + + // GetHsm returns the hsm rule contexts. + GetHsm() ISecretContext + + // SetS sets the s rule contexts. + SetS(ISecretContext) + + // SetHsm sets the hsm rule contexts. + SetHsm(ISecretContext) + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + REVERSE() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + USING() antlr.TerminalNode + AllSecret() []ISecretContext + Secret(i int) ISecretContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + + // IsReverse_migrate_keysContext differentiates from other interfaces. + IsReverse_migrate_keysContext() +} + +type Reverse_migrate_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s ISecretContext + hsm ISecretContext +} + +func NewEmptyReverse_migrate_keysContext() *Reverse_migrate_keysContext { + var p = new(Reverse_migrate_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys + return p +} + +func InitEmptyReverse_migrate_keysContext(p *Reverse_migrate_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys +} + +func (*Reverse_migrate_keysContext) IsReverse_migrate_keysContext() {} + +func NewReverse_migrate_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reverse_migrate_keysContext { + var p = new(Reverse_migrate_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys + + return p +} + +func (s *Reverse_migrate_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reverse_migrate_keysContext) GetS() ISecretContext { return s.s } + +func (s *Reverse_migrate_keysContext) GetHsm() ISecretContext { return s.hsm } + +func (s *Reverse_migrate_keysContext) SetS(v ISecretContext) { s.s = v } + +func (s *Reverse_migrate_keysContext) SetHsm(v ISecretContext) { s.hsm = v } + +func (s *Reverse_migrate_keysContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Reverse_migrate_keysContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Reverse_migrate_keysContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Reverse_migrate_keysContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Reverse_migrate_keysContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Reverse_migrate_keysContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Reverse_migrate_keysContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Reverse_migrate_keysContext) AllSecret() []ISecretContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISecretContext); ok { + len++ + } + } + + tst := make([]ISecretContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISecretContext); ok { + tst[i] = t.(ISecretContext) + i++ + } + } + + return tst +} + +func (s *Reverse_migrate_keysContext) Secret(i int) ISecretContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Reverse_migrate_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Reverse_migrate_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Reverse_migrate_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reverse_migrate_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reverse_migrate_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReverse_migrate_keys(s) + } +} + +func (s *Reverse_migrate_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReverse_migrate_keys(s) + } +} + +func (p *PlSqlParser) Reverse_migrate_keys() (localctx IReverse_migrate_keysContext) { + localctx = NewReverse_migrate_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, PlSqlParserRULE_reverse_migrate_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7339) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7340) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7343) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7344) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7345) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7346) + + var _x = p.Secret() + + localctx.(*Reverse_migrate_keysContext).s = _x + } + p.SetState(7348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7347) + p.Force_keystore() + } + + } + { + p.SetState(7350) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7351) + p.Match(PlSqlParserMIGRATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7352) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7353) + + var _x = p.Secret() + + localctx.(*Reverse_migrate_keysContext).hsm = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_keysContext is an interface to support dynamic dispatch. +type IMove_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // GetKsp1 returns the ksp1 rule contexts. + GetKsp1() IKeystore_passwordContext + + // GetKsp returns the ksp rule contexts. + GetKsp() IKeystore_passwordContext + + // SetKsp1 sets the ksp1 rule contexts. + SetKsp1(IKeystore_passwordContext) + + // SetKsp sets the ksp rule contexts. + SetKsp(IKeystore_passwordContext) + + // Getter signatures + MOVE() antlr.TerminalNode + KEYS() antlr.TerminalNode + TO() antlr.TerminalNode + NEW() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + FROM() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllKeystore_password() []IKeystore_passwordContext + Keystore_password(i int) IKeystore_passwordContext + ENCRYPTION() antlr.TerminalNode + FORCE() antlr.TerminalNode + WITH() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IN() antlr.TerminalNode + With_backup_clause() IWith_backup_clauseContext + Subquery() ISubqueryContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMove_keysContext differentiates from other interfaces. + IsMove_keysContext() +} + +type Move_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksp1 IKeystore_passwordContext + ksp IKeystore_passwordContext +} + +func NewEmptyMove_keysContext() *Move_keysContext { + var p = new(Move_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_keys + return p +} + +func InitEmptyMove_keysContext(p *Move_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_keys +} + +func (*Move_keysContext) IsMove_keysContext() {} + +func NewMove_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_keysContext { + var p = new(Move_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_keys + + return p +} + +func (s *Move_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_keysContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Move_keysContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Move_keysContext) GetKsp1() IKeystore_passwordContext { return s.ksp1 } + +func (s *Move_keysContext) GetKsp() IKeystore_passwordContext { return s.ksp } + +func (s *Move_keysContext) SetKsp1(v IKeystore_passwordContext) { s.ksp1 = v } + +func (s *Move_keysContext) SetKsp(v IKeystore_passwordContext) { s.ksp = v } + +func (s *Move_keysContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Move_keysContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_keysContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Move_keysContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Move_keysContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Move_keysContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Move_keysContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Move_keysContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Move_keysContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Move_keysContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Move_keysContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Move_keysContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Move_keysContext) AllKeystore_password() []IKeystore_passwordContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeystore_passwordContext); ok { + len++ + } + } + + tst := make([]IKeystore_passwordContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeystore_passwordContext); ok { + tst[i] = t.(IKeystore_passwordContext) + i++ + } + } + + return tst +} + +func (s *Move_keysContext) Keystore_password(i int) IKeystore_passwordContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Move_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Move_keysContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Move_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Move_keysContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Move_keysContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Move_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Move_keysContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Move_keysContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Move_keysContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Move_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_keys(s) + } +} + +func (s *Move_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_keys(s) + } +} + +func (p *PlSqlParser) Move_keys() (localctx IMove_keysContext) { + localctx = NewMove_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, PlSqlParserRULE_move_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7355) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7356) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7359) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7360) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7361) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7362) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7363) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Move_keysContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7364) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7365) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7366) + + var _x = p.Keystore_password() + + localctx.(*Move_keysContext).ksp1 = _x + } + { + p.SetState(7367) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7368) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7371) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7372) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7373) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7374) + + var _x = p.Keystore_password() + + localctx.(*Move_keysContext).ksp = _x + } + p.SetState(7389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 757, p.GetParserRuleContext()) == 1 { + { + p.SetState(7375) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7376) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7377) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(7378) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7379) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7380) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(7385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserSELECT, PlSqlParserLEFT_PAREN: + { + p.SetState(7386) + p.Subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7391) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_by_storeContext is an interface to support dynamic dispatch. +type IIdentified_by_storeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + STORE() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + + // IsIdentified_by_storeContext differentiates from other interfaces. + IsIdentified_by_storeContext() +} + +type Identified_by_storeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_by_storeContext() *Identified_by_storeContext { + var p = new(Identified_by_storeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_store + return p +} + +func InitEmptyIdentified_by_storeContext(p *Identified_by_storeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_store +} + +func (*Identified_by_storeContext) IsIdentified_by_storeContext() {} + +func NewIdentified_by_storeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_by_storeContext { + var p = new(Identified_by_storeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by_store + + return p +} + +func (s *Identified_by_storeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_by_storeContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_by_storeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_by_storeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Identified_by_storeContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Identified_by_storeContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Identified_by_storeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_by_storeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_by_storeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by_store(s) + } +} + +func (s *Identified_by_storeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by_store(s) + } +} + +func (p *PlSqlParser) Identified_by_store() (localctx IIdentified_by_storeContext) { + localctx = NewIdentified_by_storeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, PlSqlParserRULE_identified_by_store) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7394) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7395) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXTERNAL: + { + p.SetState(7396) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7397) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDELIMITED_ID: + { + p.SetState(7398) + p.Keystore_password() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_algorithm_clauseContext is an interface to support dynamic dispatch. +type IUsing_algorithm_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEa returns the ea token. + GetEa() antlr.Token + + // SetEa sets the ea token. + SetEa(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsUsing_algorithm_clauseContext differentiates from other interfaces. + IsUsing_algorithm_clauseContext() +} + +type Using_algorithm_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ea antlr.Token +} + +func NewEmptyUsing_algorithm_clauseContext() *Using_algorithm_clauseContext { + var p = new(Using_algorithm_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause + return p +} + +func InitEmptyUsing_algorithm_clauseContext(p *Using_algorithm_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause +} + +func (*Using_algorithm_clauseContext) IsUsing_algorithm_clauseContext() {} + +func NewUsing_algorithm_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_algorithm_clauseContext { + var p = new(Using_algorithm_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause + + return p +} + +func (s *Using_algorithm_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_algorithm_clauseContext) GetEa() antlr.Token { return s.ea } + +func (s *Using_algorithm_clauseContext) SetEa(v antlr.Token) { s.ea = v } + +func (s *Using_algorithm_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_algorithm_clauseContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(PlSqlParserALGORITHM, 0) +} + +func (s *Using_algorithm_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Using_algorithm_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_algorithm_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_algorithm_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_algorithm_clause(s) + } +} + +func (s *Using_algorithm_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_algorithm_clause(s) + } +} + +func (p *PlSqlParser) Using_algorithm_clause() (localctx IUsing_algorithm_clauseContext) { + localctx = NewUsing_algorithm_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, PlSqlParserRULE_using_algorithm_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7401) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7402) + p.Match(PlSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7403) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Using_algorithm_clauseContext).ea = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_tag_clauseContext is an interface to support dynamic dispatch. +type IUsing_tag_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t token. + GetT() antlr.Token + + // SetT sets the t token. + SetT(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + TAG() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsUsing_tag_clauseContext differentiates from other interfaces. + IsUsing_tag_clauseContext() +} + +type Using_tag_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t antlr.Token +} + +func NewEmptyUsing_tag_clauseContext() *Using_tag_clauseContext { + var p = new(Using_tag_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_tag_clause + return p +} + +func InitEmptyUsing_tag_clauseContext(p *Using_tag_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_tag_clause +} + +func (*Using_tag_clauseContext) IsUsing_tag_clauseContext() {} + +func NewUsing_tag_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_tag_clauseContext { + var p = new(Using_tag_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_tag_clause + + return p +} + +func (s *Using_tag_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_tag_clauseContext) GetT() antlr.Token { return s.t } + +func (s *Using_tag_clauseContext) SetT(v antlr.Token) { s.t = v } + +func (s *Using_tag_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_tag_clauseContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Using_tag_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Using_tag_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_tag_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_tag_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_tag_clause(s) + } +} + +func (s *Using_tag_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_tag_clause(s) + } +} + +func (p *PlSqlParser) Using_tag_clause() (localctx IUsing_tag_clauseContext) { + localctx = NewUsing_tag_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, PlSqlParserRULE_using_tag_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7405) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7406) + p.Match(PlSqlParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7407) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Using_tag_clauseContext).t = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISecret_management_clausesContext is an interface to support dynamic dispatch. +type ISecret_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_update_secret() IAdd_update_secretContext + Delete_secret() IDelete_secretContext + Add_update_secret_seps() IAdd_update_secret_sepsContext + Delete_secret_seps() IDelete_secret_sepsContext + + // IsSecret_management_clausesContext differentiates from other interfaces. + IsSecret_management_clausesContext() +} + +type Secret_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecret_management_clausesContext() *Secret_management_clausesContext { + var p = new(Secret_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret_management_clauses + return p +} + +func InitEmptySecret_management_clausesContext(p *Secret_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret_management_clauses +} + +func (*Secret_management_clausesContext) IsSecret_management_clausesContext() {} + +func NewSecret_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Secret_management_clausesContext { + var p = new(Secret_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_secret_management_clauses + + return p +} + +func (s *Secret_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Secret_management_clausesContext) Add_update_secret() IAdd_update_secretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_update_secretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_update_secretContext) +} + +func (s *Secret_management_clausesContext) Delete_secret() IDelete_secretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_secretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_secretContext) +} + +func (s *Secret_management_clausesContext) Add_update_secret_seps() IAdd_update_secret_sepsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_update_secret_sepsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_update_secret_sepsContext) +} + +func (s *Secret_management_clausesContext) Delete_secret_seps() IDelete_secret_sepsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_secret_sepsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_secret_sepsContext) +} + +func (s *Secret_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Secret_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Secret_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecret_management_clauses(s) + } +} + +func (s *Secret_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecret_management_clauses(s) + } +} + +func (p *PlSqlParser) Secret_management_clauses() (localctx ISecret_management_clausesContext) { + localctx = NewSecret_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, PlSqlParserRULE_secret_management_clauses) + p.SetState(7413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 760, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7409) + p.Add_update_secret() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7410) + p.Delete_secret() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7411) + p.Add_update_secret_seps() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7412) + p.Delete_secret_seps() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_update_secretContext is an interface to support dynamic dispatch. +type IAdd_update_secretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + ADD() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + Force_keystore() IForce_keystoreContext + Identified_by_store() IIdentified_by_storeContext + With_backup_clause() IWith_backup_clauseContext + + // IsAdd_update_secretContext differentiates from other interfaces. + IsAdd_update_secretContext() +} + +type Add_update_secretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyAdd_update_secretContext() *Add_update_secretContext { + var p = new(Add_update_secretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret + return p +} + +func InitEmptyAdd_update_secretContext(p *Add_update_secretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret +} + +func (*Add_update_secretContext) IsAdd_update_secretContext() {} + +func NewAdd_update_secretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_update_secretContext { + var p = new(Add_update_secretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_update_secret + + return p +} + +func (s *Add_update_secretContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_update_secretContext) GetS() antlr.Token { return s.s } + +func (s *Add_update_secretContext) GetCi() antlr.Token { return s.ci } + +func (s *Add_update_secretContext) SetS(v antlr.Token) { s.s = v } + +func (s *Add_update_secretContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Add_update_secretContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Add_update_secretContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Add_update_secretContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Add_update_secretContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_update_secretContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Add_update_secretContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_update_secretContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_update_secretContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Add_update_secretContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Add_update_secretContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Add_update_secretContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Add_update_secretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_update_secretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_update_secretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_update_secret(s) + } +} + +func (s *Add_update_secretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_update_secret(s) + } +} + +func (p *PlSqlParser) Add_update_secret() (localctx IAdd_update_secretContext) { + localctx = NewAdd_update_secretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, PlSqlParserRULE_add_update_secret) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7415) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7416) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7417) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secretContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7418) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7419) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7420) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secretContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7421) + p.Using_tag_clause() + } + + } + p.SetState(7425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7424) + p.Force_keystore() + } + + } + p.SetState(7428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7427) + p.Identified_by_store() + } + + } + p.SetState(7431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7430) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_secretContext is an interface to support dynamic dispatch. +type IDelete_secretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + CHAR_STRING() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsDelete_secretContext differentiates from other interfaces. + IsDelete_secretContext() +} + +type Delete_secretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ci antlr.Token +} + +func NewEmptyDelete_secretContext() *Delete_secretContext { + var p = new(Delete_secretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret + return p +} + +func InitEmptyDelete_secretContext(p *Delete_secretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret +} + +func (*Delete_secretContext) IsDelete_secretContext() {} + +func NewDelete_secretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_secretContext { + var p = new(Delete_secretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delete_secret + + return p +} + +func (s *Delete_secretContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_secretContext) GetCi() antlr.Token { return s.ci } + +func (s *Delete_secretContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Delete_secretContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_secretContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Delete_secretContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Delete_secretContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Delete_secretContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Delete_secretContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Delete_secretContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Delete_secretContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Delete_secretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_secretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_secretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelete_secret(s) + } +} + +func (s *Delete_secretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_secret(s) + } +} + +func (p *PlSqlParser) Delete_secret() (localctx IDelete_secretContext) { + localctx = NewDelete_secretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, PlSqlParserRULE_delete_secret) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7433) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7434) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7435) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7436) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7437) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secretContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7438) + p.Force_keystore() + } + + } + { + p.SetState(7441) + p.Identified_by_store() + } + p.SetState(7443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7442) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_update_secret_sepsContext is an interface to support dynamic dispatch. +type IAdd_update_secret_sepsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + TO() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Directory_path() IDirectory_pathContext + ADD() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + LOCAL() antlr.TerminalNode + + // IsAdd_update_secret_sepsContext differentiates from other interfaces. + IsAdd_update_secret_sepsContext() +} + +type Add_update_secret_sepsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyAdd_update_secret_sepsContext() *Add_update_secret_sepsContext { + var p = new(Add_update_secret_sepsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps + return p +} + +func InitEmptyAdd_update_secret_sepsContext(p *Add_update_secret_sepsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps +} + +func (*Add_update_secret_sepsContext) IsAdd_update_secret_sepsContext() {} + +func NewAdd_update_secret_sepsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_update_secret_sepsContext { + var p = new(Add_update_secret_sepsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps + + return p +} + +func (s *Add_update_secret_sepsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_update_secret_sepsContext) GetS() antlr.Token { return s.s } + +func (s *Add_update_secret_sepsContext) GetCi() antlr.Token { return s.ci } + +func (s *Add_update_secret_sepsContext) SetS(v antlr.Token) { s.s = v } + +func (s *Add_update_secret_sepsContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Add_update_secret_sepsContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Add_update_secret_sepsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Add_update_secret_sepsContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Add_update_secret_sepsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Add_update_secret_sepsContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Add_update_secret_sepsContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Add_update_secret_sepsContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Add_update_secret_sepsContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_update_secret_sepsContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Add_update_secret_sepsContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_update_secret_sepsContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_update_secret_sepsContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Add_update_secret_sepsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Add_update_secret_sepsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_update_secret_sepsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_update_secret_sepsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_update_secret_seps(s) + } +} + +func (s *Add_update_secret_sepsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_update_secret_seps(s) + } +} + +func (p *PlSqlParser) Add_update_secret_seps() (localctx IAdd_update_secret_sepsContext) { + localctx = NewAdd_update_secret_sepsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, PlSqlParserRULE_add_update_secret_seps) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7445) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7446) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7447) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secret_sepsContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7448) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7449) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7450) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secret_sepsContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7451) + p.Using_tag_clause() + } + + } + { + p.SetState(7454) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7455) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7458) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7459) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7460) + p.Directory_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_secret_sepsContext is an interface to support dynamic dispatch. +type IDelete_secret_sepsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + SECRET() antlr.TerminalNode + SQ() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + FROM() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Directory_path() IDirectory_pathContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsDelete_secret_sepsContext differentiates from other interfaces. + IsDelete_secret_sepsContext() +} + +type Delete_secret_sepsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyDelete_secret_sepsContext() *Delete_secret_sepsContext { + var p = new(Delete_secret_sepsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret_seps + return p +} + +func InitEmptyDelete_secret_sepsContext(p *Delete_secret_sepsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret_seps +} + +func (*Delete_secret_sepsContext) IsDelete_secret_sepsContext() {} + +func NewDelete_secret_sepsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_secret_sepsContext { + var p = new(Delete_secret_sepsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delete_secret_seps + + return p +} + +func (s *Delete_secret_sepsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_secret_sepsContext) GetS() antlr.Token { return s.s } + +func (s *Delete_secret_sepsContext) GetCi() antlr.Token { return s.ci } + +func (s *Delete_secret_sepsContext) SetS(v antlr.Token) { s.s = v } + +func (s *Delete_secret_sepsContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Delete_secret_sepsContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_secret_sepsContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Delete_secret_sepsContext) SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQ, 0) +} + +func (s *Delete_secret_sepsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Delete_secret_sepsContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Delete_secret_sepsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Delete_secret_sepsContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Delete_secret_sepsContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Delete_secret_sepsContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Delete_secret_sepsContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Delete_secret_sepsContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Delete_secret_sepsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Delete_secret_sepsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_secret_sepsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_secret_sepsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelete_secret_seps(s) + } +} + +func (s *Delete_secret_sepsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_secret_seps(s) + } +} + +func (p *PlSqlParser) Delete_secret_seps() (localctx IDelete_secret_sepsContext) { + localctx = NewDelete_secret_sepsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, PlSqlParserRULE_delete_secret_seps) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7462) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7463) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7464) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secret_sepsContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7465) + p.Match(PlSqlParserSQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7466) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7467) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7468) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secret_sepsContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7469) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7470) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7473) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7474) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7475) + p.Directory_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZero_downtime_software_patching_clausesContext is an interface to support dynamic dispatch. +type IZero_downtime_software_patching_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SWITCHOVER() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Path() IPathContext + FOR() antlr.TerminalNode + ALL() antlr.TerminalNode + CONTAINERS() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsZero_downtime_software_patching_clausesContext differentiates from other interfaces. + IsZero_downtime_software_patching_clausesContext() +} + +type Zero_downtime_software_patching_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZero_downtime_software_patching_clausesContext() *Zero_downtime_software_patching_clausesContext { + var p = new(Zero_downtime_software_patching_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses + return p +} + +func InitEmptyZero_downtime_software_patching_clausesContext(p *Zero_downtime_software_patching_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses +} + +func (*Zero_downtime_software_patching_clausesContext) IsZero_downtime_software_patching_clausesContext() { +} + +func NewZero_downtime_software_patching_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zero_downtime_software_patching_clausesContext { + var p = new(Zero_downtime_software_patching_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses + + return p +} + +func (s *Zero_downtime_software_patching_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zero_downtime_software_patching_clausesContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) Path() IPathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPathContext) +} + +func (s *Zero_downtime_software_patching_clausesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) CONTAINERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zero_downtime_software_patching_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zero_downtime_software_patching_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZero_downtime_software_patching_clauses(s) + } +} + +func (s *Zero_downtime_software_patching_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZero_downtime_software_patching_clauses(s) + } +} + +func (p *PlSqlParser) Zero_downtime_software_patching_clauses() (localctx IZero_downtime_software_patching_clausesContext) { + localctx = NewZero_downtime_software_patching_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, PlSqlParserRULE_zero_downtime_software_patching_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7477) + p.Match(PlSqlParserSWITCHOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(7478) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7481) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7482) + p.Path() + } + { + p.SetState(7483) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7484) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7485) + p.Match(PlSqlParserCONTAINERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_backup_clauseContext is an interface to support dynamic dispatch. +type IWith_backup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBi returns the bi token. + GetBi() antlr.Token + + // SetBi sets the bi token. + SetBi(antlr.Token) + + // Getter signatures + WITH() antlr.TerminalNode + BACKUP() antlr.TerminalNode + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsWith_backup_clauseContext differentiates from other interfaces. + IsWith_backup_clauseContext() +} + +type With_backup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bi antlr.Token +} + +func NewEmptyWith_backup_clauseContext() *With_backup_clauseContext { + var p = new(With_backup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_backup_clause + return p +} + +func InitEmptyWith_backup_clauseContext(p *With_backup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_backup_clause +} + +func (*With_backup_clauseContext) IsWith_backup_clauseContext() {} + +func NewWith_backup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_backup_clauseContext { + var p = new(With_backup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_with_backup_clause + + return p +} + +func (s *With_backup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_backup_clauseContext) GetBi() antlr.Token { return s.bi } + +func (s *With_backup_clauseContext) SetBi(v antlr.Token) { s.bi = v } + +func (s *With_backup_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *With_backup_clauseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *With_backup_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *With_backup_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *With_backup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_backup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_backup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWith_backup_clause(s) + } +} + +func (s *With_backup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWith_backup_clause(s) + } +} + +func (p *PlSqlParser) With_backup_clause() (localctx IWith_backup_clauseContext) { + localctx = NewWith_backup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, PlSqlParserRULE_with_backup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7487) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7488) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7489) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7490) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*With_backup_clauseContext).bi = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_by_password_clauseContext is an interface to support dynamic dispatch. +type IIdentified_by_password_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + + // IsIdentified_by_password_clauseContext differentiates from other interfaces. + IsIdentified_by_password_clauseContext() +} + +type Identified_by_password_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_by_password_clauseContext() *Identified_by_password_clauseContext { + var p = new(Identified_by_password_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause + return p +} + +func InitEmptyIdentified_by_password_clauseContext(p *Identified_by_password_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause +} + +func (*Identified_by_password_clauseContext) IsIdentified_by_password_clauseContext() {} + +func NewIdentified_by_password_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_by_password_clauseContext { + var p = new(Identified_by_password_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause + + return p +} + +func (s *Identified_by_password_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_by_password_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_by_password_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_by_password_clauseContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Identified_by_password_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_by_password_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_by_password_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by_password_clause(s) + } +} + +func (s *Identified_by_password_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by_password_clause(s) + } +} + +func (p *PlSqlParser) Identified_by_password_clause() (localctx IIdentified_by_password_clauseContext) { + localctx = NewIdentified_by_password_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, PlSqlParserRULE_identified_by_password_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7493) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7494) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7495) + p.Keystore_password() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeystore_passwordContext is an interface to support dynamic dispatch. +type IKeystore_passwordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsKeystore_passwordContext differentiates from other interfaces. + IsKeystore_passwordContext() +} + +type Keystore_passwordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeystore_passwordContext() *Keystore_passwordContext { + var p = new(Keystore_passwordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_password + return p +} + +func InitEmptyKeystore_passwordContext(p *Keystore_passwordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_password +} + +func (*Keystore_passwordContext) IsKeystore_passwordContext() {} + +func NewKeystore_passwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keystore_passwordContext { + var p = new(Keystore_passwordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keystore_password + + return p +} + +func (s *Keystore_passwordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keystore_passwordContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Keystore_passwordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keystore_passwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keystore_passwordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeystore_password(s) + } +} + +func (s *Keystore_passwordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeystore_password(s) + } +} + +func (p *PlSqlParser) Keystore_password() (localctx IKeystore_passwordContext) { + localctx = NewKeystore_passwordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, PlSqlParserRULE_keystore_password) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7497) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPathContext is an interface to support dynamic dispatch. +type IPathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsPathContext differentiates from other interfaces. + IsPathContext() +} + +type PathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPathContext() *PathContext { + var p = new(PathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_path + return p +} + +func InitEmptyPathContext(p *PathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_path +} + +func (*PathContext) IsPathContext() {} + +func NewPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathContext { + var p = new(PathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_path + + return p +} + +func (s *PathContext) GetParser() antlr.Parser { return s.parser } + +func (s *PathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *PathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPath(s) + } +} + +func (s *PathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPath(s) + } +} + +func (p *PlSqlParser) Path() (localctx IPathContext) { + localctx = NewPathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, PlSqlParserRULE_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7499) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISecretContext is an interface to support dynamic dispatch. +type ISecretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsSecretContext differentiates from other interfaces. + IsSecretContext() +} + +type SecretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecretContext() *SecretContext { + var p = new(SecretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret + return p +} + +func InitEmptySecretContext(p *SecretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret +} + +func (*SecretContext) IsSecretContext() {} + +func NewSecretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SecretContext { + var p = new(SecretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_secret + + return p +} + +func (s *SecretContext) GetParser() antlr.Parser { return s.parser } + +func (s *SecretContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *SecretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SecretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SecretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecret(s) + } +} + +func (s *SecretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecret(s) + } +} + +func (p *PlSqlParser) Secret() (localctx ISecretContext) { + localctx = NewSecretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, PlSqlParserRULE_secret) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7501) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyzeContext is an interface to support dynamic dispatch. +type IAnalyzeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANALYZE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + Validation_clauses() IValidation_clausesContext + Compute_clauses() ICompute_clausesContext + ESTIMATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + LIST() antlr.TerminalNode + CHAINED() antlr.TerminalNode + ROWS() antlr.TerminalNode + DELETE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + Partition_extention_clause() IPartition_extention_clauseContext + SYSTEM() antlr.TerminalNode + For_clause() IFor_clauseContext + SAMPLE() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Into_clause1() IInto_clause1Context + PERCENT_KEYWORD() antlr.TerminalNode + + // IsAnalyzeContext differentiates from other interfaces. + IsAnalyzeContext() +} + +type AnalyzeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyzeContext() *AnalyzeContext { + var p = new(AnalyzeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_analyze + return p +} + +func InitEmptyAnalyzeContext(p *AnalyzeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_analyze +} + +func (*AnalyzeContext) IsAnalyzeContext() {} + +func NewAnalyzeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzeContext { + var p = new(AnalyzeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_analyze + + return p +} + +func (s *AnalyzeContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzeContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *AnalyzeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *AnalyzeContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *AnalyzeContext) Validation_clauses() IValidation_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValidation_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValidation_clausesContext) +} + +func (s *AnalyzeContext) Compute_clauses() ICompute_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompute_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompute_clausesContext) +} + +func (s *AnalyzeContext) ESTIMATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESTIMATE, 0) +} + +func (s *AnalyzeContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *AnalyzeContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *AnalyzeContext) CHAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAINED, 0) +} + +func (s *AnalyzeContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *AnalyzeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *AnalyzeContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *AnalyzeContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *AnalyzeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *AnalyzeContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *AnalyzeContext) Partition_extention_clause() IPartition_extention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extention_clauseContext) +} + +func (s *AnalyzeContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *AnalyzeContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *AnalyzeContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAMPLE, 0) +} + +func (s *AnalyzeContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *AnalyzeContext) Into_clause1() IInto_clause1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clause1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clause1Context) +} + +func (s *AnalyzeContext) PERCENT_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_KEYWORD, 0) +} + +func (s *AnalyzeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnalyze(s) + } +} + +func (s *AnalyzeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnalyze(s) + } +} + +func (p *PlSqlParser) Analyze() (localctx IAnalyzeContext) { + localctx = NewAnalyzeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, PlSqlParserRULE_analyze) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 774, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7503) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(7504) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7505) + p.Tableview_name() + } + + case PlSqlParserINDEX: + { + p.SetState(7506) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7507) + p.Index_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION { + { + p.SetState(7510) + p.Partition_extention_clause() + } + + } + + case 2: + { + p.SetState(7513) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7514) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7515) + p.Cluster_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALIDATE: + { + p.SetState(7518) + p.Validation_clauses() + } + + case PlSqlParserCOMPUTE: + { + p.SetState(7519) + p.Compute_clauses() + } + + case PlSqlParserESTIMATE: + { + p.SetState(7520) + p.Match(PlSqlParserESTIMATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(7521) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7524) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(7525) + p.For_clause() + } + + } + p.SetState(7531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSAMPLE { + { + p.SetState(7528) + p.Match(PlSqlParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7529) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7530) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPERCENT_KEYWORD || _la == PlSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserLIST: + { + p.SetState(7533) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7534) + p.Match(PlSqlParserCHAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7535) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(7536) + p.Into_clause1() + } + + } + + case PlSqlParserDELETE: + { + p.SetState(7539) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(7540) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7543) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_extention_clauseContext is an interface to support dynamic dispatch. +type IPartition_extention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Partition_name() IPartition_nameContext + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllPartition_key_value() []IPartition_key_valueContext + Partition_key_value(i int) IPartition_key_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + AllSubpartition_key_value() []ISubpartition_key_valueContext + Subpartition_key_value(i int) ISubpartition_key_valueContext + + // IsPartition_extention_clauseContext differentiates from other interfaces. + IsPartition_extention_clauseContext() +} + +type Partition_extention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extention_clauseContext() *Partition_extention_clauseContext { + var p = new(Partition_extention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extention_clause + return p +} + +func InitEmptyPartition_extention_clauseContext(p *Partition_extention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extention_clause +} + +func (*Partition_extention_clauseContext) IsPartition_extention_clauseContext() {} + +func NewPartition_extention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extention_clauseContext { + var p = new(Partition_extention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extention_clause + + return p +} + +func (s *Partition_extention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extention_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extention_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extention_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_extention_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extention_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extention_clauseContext) AllPartition_key_value() []IPartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_key_valueContext); ok { + len++ + } + } + + tst := make([]IPartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_key_valueContext); ok { + tst[i] = t.(IPartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extention_clauseContext) Partition_key_value(i int) IPartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_key_valueContext) +} + +func (s *Partition_extention_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partition_extention_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partition_extention_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Partition_extention_clauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Partition_extention_clauseContext) AllSubpartition_key_value() []ISubpartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + len++ + } + } + + tst := make([]ISubpartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartition_key_valueContext); ok { + tst[i] = t.(ISubpartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extention_clauseContext) Subpartition_key_value(i int) ISubpartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_key_valueContext) +} + +func (s *Partition_extention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extention_clause(s) + } +} + +func (s *Partition_extention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extention_clause(s) + } +} + +func (p *PlSqlParser) Partition_extention_clause() (localctx IPartition_extention_clauseContext) { + localctx = NewPartition_extention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, PlSqlParserRULE_partition_extention_clause) + var _la int + + p.SetState(7584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7546) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(7547) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7548) + p.Partition_name() + } + { + p.SetState(7549) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(7551) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7552) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7553) + p.Partition_key_value() + } + p.SetState(7558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7554) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7555) + p.Partition_key_value() + } + + p.SetState(7560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7561) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserSUBPARTITION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7565) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(7566) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7567) + p.Subpartition_name() + } + { + p.SetState(7568) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(7570) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7571) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7572) + p.Subpartition_key_value() + } + p.SetState(7577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7573) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7574) + p.Subpartition_key_value() + } + + p.SetState(7579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7580) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValidation_clausesContext is an interface to support dynamic dispatch. +type IValidation_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALIDATE() antlr.TerminalNode + REF() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + DANGLING() antlr.TerminalNode + TO() antlr.TerminalNode + NULL_() antlr.TerminalNode + STRUCTURE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + FAST() antlr.TerminalNode + AllOnline_or_offline() []IOnline_or_offlineContext + Online_or_offline(i int) IOnline_or_offlineContext + AllInto_clause() []IInto_clauseContext + Into_clause(i int) IInto_clauseContext + + // IsValidation_clausesContext differentiates from other interfaces. + IsValidation_clausesContext() +} + +type Validation_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValidation_clausesContext() *Validation_clausesContext { + var p = new(Validation_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_validation_clauses + return p +} + +func InitEmptyValidation_clausesContext(p *Validation_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_validation_clauses +} + +func (*Validation_clausesContext) IsValidation_clausesContext() {} + +func NewValidation_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Validation_clausesContext { + var p = new(Validation_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_validation_clauses + + return p +} + +func (s *Validation_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Validation_clausesContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Validation_clausesContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Validation_clausesContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Validation_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Validation_clausesContext) DANGLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDANGLING, 0) +} + +func (s *Validation_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Validation_clausesContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Validation_clausesContext) STRUCTURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCTURE, 0) +} + +func (s *Validation_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Validation_clausesContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Validation_clausesContext) AllOnline_or_offline() []IOnline_or_offlineContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + len++ + } + } + + tst := make([]IOnline_or_offlineContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOnline_or_offlineContext); ok { + tst[i] = t.(IOnline_or_offlineContext) + i++ + } + } + + return tst +} + +func (s *Validation_clausesContext) Online_or_offline(i int) IOnline_or_offlineContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOnline_or_offlineContext) +} + +func (s *Validation_clausesContext) AllInto_clause() []IInto_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInto_clauseContext); ok { + len++ + } + } + + tst := make([]IInto_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInto_clauseContext); ok { + tst[i] = t.(IInto_clauseContext) + i++ + } + } + + return tst +} + +func (s *Validation_clausesContext) Into_clause(i int) IInto_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Validation_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Validation_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Validation_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterValidation_clauses(s) + } +} + +func (s *Validation_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitValidation_clauses(s) + } +} + +func (p *PlSqlParser) Validation_clauses() (localctx IValidation_clausesContext) { + localctx = NewValidation_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, PlSqlParserRULE_validation_clauses) + var _la int + + p.SetState(7615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7586) + p.Match(PlSqlParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7587) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7588) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(7589) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7590) + p.Match(PlSqlParserDANGLING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7591) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7592) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7595) + p.Match(PlSqlParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7596) + p.Match(PlSqlParserSTRUCTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7607) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) == 1 { + { + p.SetState(7597) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7598) + p.Match(PlSqlParserFAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) == 2 { + { + p.SetState(7599) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7601) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 787, p.GetParserRuleContext()) == 1 { + { + p.SetState(7600) + p.Online_or_offline() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7604) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, p.GetParserRuleContext()) == 1 { + { + p.SetState(7603) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) == 3 { + { + p.SetState(7606) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE { + { + p.SetState(7609) + p.Online_or_offline() + } + + } + p.SetState(7613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBULK || _la == PlSqlParserINTO { + { + p.SetState(7612) + p.Into_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompute_clausesContext is an interface to support dynamic dispatch. +type ICompute_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPUTE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + For_clause() IFor_clauseContext + + // IsCompute_clausesContext differentiates from other interfaces. + IsCompute_clausesContext() +} + +type Compute_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompute_clausesContext() *Compute_clausesContext { + var p = new(Compute_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compute_clauses + return p +} + +func InitEmptyCompute_clausesContext(p *Compute_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compute_clauses +} + +func (*Compute_clausesContext) IsCompute_clausesContext() {} + +func NewCompute_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compute_clausesContext { + var p = new(Compute_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compute_clauses + + return p +} + +func (s *Compute_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compute_clausesContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Compute_clausesContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Compute_clausesContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Compute_clausesContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Compute_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compute_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compute_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompute_clauses(s) + } +} + +func (s *Compute_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompute_clauses(s) + } +} + +func (p *PlSqlParser) Compute_clauses() (localctx ICompute_clausesContext) { + localctx = NewCompute_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, PlSqlParserRULE_compute_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7617) + p.Match(PlSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(7618) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7621) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7623) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 794, p.GetParserRuleContext()) == 1 { + { + p.SetState(7622) + p.For_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_clauseContext is an interface to support dynamic dispatch. +type IFor_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + TABLE() antlr.TerminalNode + ALL() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + INDEXES() antlr.TerminalNode + AllFor_clause() []IFor_clauseContext + For_clause(i int) IFor_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + INDEXED() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsFor_clauseContext differentiates from other interfaces. + IsFor_clauseContext() +} + +type For_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_clauseContext() *For_clauseContext { + var p = new(For_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_clause + return p +} + +func InitEmptyFor_clauseContext(p *For_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_clause +} + +func (*For_clauseContext) IsFor_clauseContext() {} + +func NewFor_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_clauseContext { + var p = new(For_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_clause + + return p +} + +func (s *For_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *For_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *For_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *For_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *For_clauseContext) AllFor_clause() []IFor_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFor_clauseContext); ok { + len++ + } + } + + tst := make([]IFor_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFor_clauseContext); ok { + tst[i] = t.(IFor_clauseContext) + i++ + } + } + + return tst +} + +func (s *For_clauseContext) For_clause(i int) IFor_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *For_clauseContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *For_clauseContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *For_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *For_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *For_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *For_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *For_clauseContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *For_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *For_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_clause(s) + } +} + +func (s *For_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_clause(s) + } +} + +func (p *PlSqlParser) For_clause() (localctx IFor_clauseContext) { + localctx = NewFor_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, PlSqlParserRULE_for_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7625) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(7626) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7627) + p.For_clause() + } + + } + p.SetState(7632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(7633) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS, PlSqlParserINDEXED: + p.SetState(7635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXED { + { + p.SetState(7634) + p.Match(PlSqlParserINDEXED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7637) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7640) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) == 1 { + { + p.SetState(7638) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7639) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 798, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7642) + p.For_clause() + } + + } + p.SetState(7647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 798, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserINDEXES, PlSqlParserLOCAL: + p.SetState(7649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7648) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7651) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCOLUMNS: + { + p.SetState(7654) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(7655) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7656) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(7659) + p.Column_name() + } + { + p.SetState(7660) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7661) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(7665) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 802, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(7670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7667) + p.For_clause() + } + + } + p.SetState(7672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOnline_or_offlineContext is an interface to support dynamic dispatch. +type IOnline_or_offlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFLINE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + + // IsOnline_or_offlineContext differentiates from other interfaces. + IsOnline_or_offlineContext() +} + +type Online_or_offlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOnline_or_offlineContext() *Online_or_offlineContext { + var p = new(Online_or_offlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_online_or_offline + return p +} + +func InitEmptyOnline_or_offlineContext(p *Online_or_offlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_online_or_offline +} + +func (*Online_or_offlineContext) IsOnline_or_offlineContext() {} + +func NewOnline_or_offlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Online_or_offlineContext { + var p = new(Online_or_offlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_online_or_offline + + return p +} + +func (s *Online_or_offlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Online_or_offlineContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Online_or_offlineContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Online_or_offlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Online_or_offlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Online_or_offlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOnline_or_offline(s) + } +} + +func (s *Online_or_offlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOnline_or_offline(s) + } +} + +func (p *PlSqlParser) Online_or_offline() (localctx IOnline_or_offlineContext) { + localctx = NewOnline_or_offlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, PlSqlParserRULE_online_or_offline) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7675) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInto_clause1Context is an interface to support dynamic dispatch. +type IInto_clause1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsInto_clause1Context differentiates from other interfaces. + IsInto_clause1Context() +} + +type Into_clause1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInto_clause1Context() *Into_clause1Context { + var p = new(Into_clause1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause1 + return p +} + +func InitEmptyInto_clause1Context(p *Into_clause1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause1 +} + +func (*Into_clause1Context) IsInto_clause1Context() {} + +func NewInto_clause1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clause1Context { + var p = new(Into_clause1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_into_clause1 + + return p +} + +func (s *Into_clause1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clause1Context) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Into_clause1Context) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Into_clause1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Into_clause1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Into_clause1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInto_clause1(s) + } +} + +func (s *Into_clause1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInto_clause1(s) + } +} + +func (p *PlSqlParser) Into_clause1() (localctx IInto_clause1Context) { + localctx = NewInto_clause1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, PlSqlParserRULE_into_clause1) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7677) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(7678) + p.Tableview_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_key_valueContext is an interface to support dynamic dispatch. +type IPartition_key_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Literal() ILiteralContext + TIMESTAMP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsPartition_key_valueContext differentiates from other interfaces. + IsPartition_key_valueContext() +} + +type Partition_key_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_key_valueContext() *Partition_key_valueContext { + var p = new(Partition_key_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_key_value + return p +} + +func InitEmptyPartition_key_valueContext(p *Partition_key_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_key_value +} + +func (*Partition_key_valueContext) IsPartition_key_valueContext() {} + +func NewPartition_key_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_key_valueContext { + var p = new(Partition_key_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_key_value + + return p +} + +func (s *Partition_key_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_key_valueContext) Literal() ILiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Partition_key_valueContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Partition_key_valueContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Partition_key_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_key_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_key_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_key_value(s) + } +} + +func (s *Partition_key_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_key_value(s) + } +} + +func (p *PlSqlParser) Partition_key_value() (localctx IPartition_key_valueContext) { + localctx = NewPartition_key_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, PlSqlParserRULE_partition_key_value) + p.SetState(7684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserMINUS_SIGN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7681) + p.Literal() + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7682) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7683) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_key_valueContext is an interface to support dynamic dispatch. +type ISubpartition_key_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Literal() ILiteralContext + TIMESTAMP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsSubpartition_key_valueContext differentiates from other interfaces. + IsSubpartition_key_valueContext() +} + +type Subpartition_key_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_key_valueContext() *Subpartition_key_valueContext { + var p = new(Subpartition_key_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_key_value + return p +} + +func InitEmptySubpartition_key_valueContext(p *Subpartition_key_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_key_value +} + +func (*Subpartition_key_valueContext) IsSubpartition_key_valueContext() {} + +func NewSubpartition_key_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_key_valueContext { + var p = new(Subpartition_key_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_key_value + + return p +} + +func (s *Subpartition_key_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_key_valueContext) Literal() ILiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Subpartition_key_valueContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Subpartition_key_valueContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Subpartition_key_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_key_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_key_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_key_value(s) + } +} + +func (s *Subpartition_key_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_key_value(s) + } +} + +func (p *PlSqlParser) Subpartition_key_value() (localctx ISubpartition_key_valueContext) { + localctx = NewSubpartition_key_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, PlSqlParserRULE_subpartition_key_value) + p.SetState(7689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserMINUS_SIGN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7686) + p.Literal() + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7687) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7688) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssociate_statisticsContext is an interface to support dynamic dispatch. +type IAssociate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + WITH() antlr.TerminalNode + Column_association() IColumn_associationContext + Function_association() IFunction_associationContext + Storage_table_clause() IStorage_table_clauseContext + + // IsAssociate_statisticsContext differentiates from other interfaces. + IsAssociate_statisticsContext() +} + +type Associate_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssociate_statisticsContext() *Associate_statisticsContext { + var p = new(Associate_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_associate_statistics + return p +} + +func InitEmptyAssociate_statisticsContext(p *Associate_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_associate_statistics +} + +func (*Associate_statisticsContext) IsAssociate_statisticsContext() {} + +func NewAssociate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Associate_statisticsContext { + var p = new(Associate_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_associate_statistics + + return p +} + +func (s *Associate_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Associate_statisticsContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Associate_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Associate_statisticsContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Associate_statisticsContext) Column_association() IColumn_associationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_associationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_associationContext) +} + +func (s *Associate_statisticsContext) Function_association() IFunction_associationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_associationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_associationContext) +} + +func (s *Associate_statisticsContext) Storage_table_clause() IStorage_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_table_clauseContext) +} + +func (s *Associate_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Associate_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Associate_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAssociate_statistics(s) + } +} + +func (s *Associate_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAssociate_statistics(s) + } +} + +func (p *PlSqlParser) Associate_statistics() (localctx IAssociate_statisticsContext) { + localctx = NewAssociate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, PlSqlParserRULE_associate_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7691) + p.Match(PlSqlParserASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7692) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7693) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS: + { + p.SetState(7694) + p.Column_association() + } + + case PlSqlParserFUNCTIONS, PlSqlParserINDEXES, PlSqlParserINDEXTYPES, PlSqlParserPACKAGES, PlSqlParserTYPES: + { + p.SetState(7695) + p.Function_association() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7698) + p.Storage_table_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_associationContext is an interface to support dynamic dispatch. +type IColumn_associationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + Using_statistics_type() IUsing_statistics_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_associationContext differentiates from other interfaces. + IsColumn_associationContext() +} + +type Column_associationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_associationContext() *Column_associationContext { + var p = new(Column_associationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_association + return p +} + +func InitEmptyColumn_associationContext(p *Column_associationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_association +} + +func (*Column_associationContext) IsColumn_associationContext() {} + +func NewColumn_associationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_associationContext { + var p = new(Column_associationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_association + + return p +} + +func (s *Column_associationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_associationContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Column_associationContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_associationContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Column_associationContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Column_associationContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Column_associationContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_associationContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_associationContext) Using_statistics_type() IUsing_statistics_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_statistics_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_statistics_typeContext) +} + +func (s *Column_associationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_associationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_associationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_associationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_associationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_association(s) + } +} + +func (s *Column_associationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_association(s) + } +} + +func (p *PlSqlParser) Column_association() (localctx IColumn_associationContext) { + localctx = NewColumn_associationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, PlSqlParserRULE_column_association) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7701) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7702) + p.Tableview_name() + } + { + p.SetState(7703) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7704) + p.Column_name() + } + p.SetState(7712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7705) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7706) + p.Tableview_name() + } + { + p.SetState(7707) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7708) + p.Column_name() + } + + p.SetState(7714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7715) + p.Using_statistics_type() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_associationContext is an interface to support dynamic dispatch. +type IFunction_associationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTIONS() antlr.TerminalNode + AllFunction_name() []IFunction_nameContext + Function_name(i int) IFunction_nameContext + PACKAGES() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + TYPES() antlr.TerminalNode + AllType_name() []IType_nameContext + Type_name(i int) IType_nameContext + INDEXES() antlr.TerminalNode + AllIndex_name() []IIndex_nameContext + Index_name(i int) IIndex_nameContext + INDEXTYPES() antlr.TerminalNode + AllIndextype_name() []IIndextype_nameContext + Indextype_name(i int) IIndextype_nameContext + Using_statistics_type() IUsing_statistics_typeContext + Default_cost_clause() IDefault_cost_clauseContext + Default_selectivity_clause() IDefault_selectivity_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_associationContext differentiates from other interfaces. + IsFunction_associationContext() +} + +type Function_associationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_associationContext() *Function_associationContext { + var p = new(Function_associationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_association + return p +} + +func InitEmptyFunction_associationContext(p *Function_associationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_association +} + +func (*Function_associationContext) IsFunction_associationContext() {} + +func NewFunction_associationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_associationContext { + var p = new(Function_associationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_association + + return p +} + +func (s *Function_associationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_associationContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Function_associationContext) AllFunction_name() []IFunction_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_nameContext); ok { + len++ + } + } + + tst := make([]IFunction_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_nameContext); ok { + tst[i] = t.(IFunction_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Function_name(i int) IFunction_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Function_associationContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Function_associationContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Function_associationContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Function_associationContext) AllType_name() []IType_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_nameContext); ok { + len++ + } + } + + tst := make([]IType_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_nameContext); ok { + tst[i] = t.(IType_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Type_name(i int) IType_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Function_associationContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Function_associationContext) AllIndex_name() []IIndex_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_nameContext); ok { + len++ + } + } + + tst := make([]IIndex_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_nameContext); ok { + tst[i] = t.(IIndex_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Index_name(i int) IIndex_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Function_associationContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Function_associationContext) AllIndextype_name() []IIndextype_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndextype_nameContext); ok { + len++ + } + } + + tst := make([]IIndextype_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndextype_nameContext); ok { + tst[i] = t.(IIndextype_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Indextype_name(i int) IIndextype_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndextype_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndextype_nameContext) +} + +func (s *Function_associationContext) Using_statistics_type() IUsing_statistics_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_statistics_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_statistics_typeContext) +} + +func (s *Function_associationContext) Default_cost_clause() IDefault_cost_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_cost_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_cost_clauseContext) +} + +func (s *Function_associationContext) Default_selectivity_clause() IDefault_selectivity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_selectivity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_selectivity_clauseContext) +} + +func (s *Function_associationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_associationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_associationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_associationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_associationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_association(s) + } +} + +func (s *Function_associationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_association(s) + } +} + +func (p *PlSqlParser) Function_association() (localctx IFunction_associationContext) { + localctx = NewFunction_associationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, PlSqlParserRULE_function_association) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFUNCTIONS: + { + p.SetState(7717) + p.Match(PlSqlParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7718) + p.Function_name() + } + p.SetState(7723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7719) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7720) + p.Function_name() + } + + p.SetState(7725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPACKAGES: + { + p.SetState(7726) + p.Match(PlSqlParserPACKAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7727) + p.Package_name() + } + p.SetState(7732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7728) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7729) + p.Package_name() + } + + p.SetState(7734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTYPES: + { + p.SetState(7735) + p.Match(PlSqlParserTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7736) + p.Type_name() + } + p.SetState(7741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7737) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7738) + p.Type_name() + } + + p.SetState(7743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXES: + { + p.SetState(7744) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7745) + p.Index_name() + } + p.SetState(7750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7746) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7747) + p.Index_name() + } + + p.SetState(7752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXTYPES: + { + p.SetState(7753) + p.Match(PlSqlParserINDEXTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7754) + p.Indextype_name() + } + p.SetState(7759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7755) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7756) + p.Indextype_name() + } + + p.SetState(7761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7764) + p.Using_statistics_type() + } + + case 2: + { + p.SetState(7765) + p.Default_cost_clause() + } + p.SetState(7768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(7766) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7767) + p.Default_selectivity_clause() + } + + } + + case 3: + { + p.SetState(7770) + p.Default_selectivity_clause() + } + p.SetState(7773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(7771) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7772) + p.Default_cost_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndextype_nameContext is an interface to support dynamic dispatch. +type IIndextype_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsIndextype_nameContext differentiates from other interfaces. + IsIndextype_nameContext() +} + +type Indextype_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndextype_nameContext() *Indextype_nameContext { + var p = new(Indextype_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype_name + return p +} + +func InitEmptyIndextype_nameContext(p *Indextype_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype_name +} + +func (*Indextype_nameContext) IsIndextype_nameContext() {} + +func NewIndextype_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indextype_nameContext { + var p = new(Indextype_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indextype_name + + return p +} + +func (s *Indextype_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Indextype_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Indextype_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Indextype_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Indextype_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndextype_name(s) + } +} + +func (s *Indextype_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndextype_name(s) + } +} + +func (p *PlSqlParser) Indextype_name() (localctx IIndextype_nameContext) { + localctx = NewIndextype_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, PlSqlParserRULE_indextype_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7777) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_statistics_typeContext is an interface to support dynamic dispatch. +type IUsing_statistics_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Statistics_type_name() IStatistics_type_nameContext + NULL_() antlr.TerminalNode + + // IsUsing_statistics_typeContext differentiates from other interfaces. + IsUsing_statistics_typeContext() +} + +type Using_statistics_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_statistics_typeContext() *Using_statistics_typeContext { + var p = new(Using_statistics_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_statistics_type + return p +} + +func InitEmptyUsing_statistics_typeContext(p *Using_statistics_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_statistics_type +} + +func (*Using_statistics_typeContext) IsUsing_statistics_typeContext() {} + +func NewUsing_statistics_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_statistics_typeContext { + var p = new(Using_statistics_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_statistics_type + + return p +} + +func (s *Using_statistics_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_statistics_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_statistics_typeContext) Statistics_type_name() IStatistics_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatistics_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatistics_type_nameContext) +} + +func (s *Using_statistics_typeContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Using_statistics_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_statistics_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_statistics_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_statistics_type(s) + } +} + +func (s *Using_statistics_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_statistics_type(s) + } +} + +func (p *PlSqlParser) Using_statistics_type() (localctx IUsing_statistics_typeContext) { + localctx = NewUsing_statistics_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, PlSqlParserRULE_using_statistics_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7779) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + { + p.SetState(7780) + p.Statistics_type_name() + } + + case PlSqlParserNULL_: + { + p.SetState(7781) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatistics_type_nameContext is an interface to support dynamic dispatch. +type IStatistics_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsStatistics_type_nameContext differentiates from other interfaces. + IsStatistics_type_nameContext() +} + +type Statistics_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatistics_type_nameContext() *Statistics_type_nameContext { + var p = new(Statistics_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statistics_type_name + return p +} + +func InitEmptyStatistics_type_nameContext(p *Statistics_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statistics_type_name +} + +func (*Statistics_type_nameContext) IsStatistics_type_nameContext() {} + +func NewStatistics_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statistics_type_nameContext { + var p = new(Statistics_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statistics_type_name + + return p +} + +func (s *Statistics_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statistics_type_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Statistics_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statistics_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statistics_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatistics_type_name(s) + } +} + +func (s *Statistics_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatistics_type_name(s) + } +} + +func (p *PlSqlParser) Statistics_type_name() (localctx IStatistics_type_nameContext) { + localctx = NewStatistics_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, PlSqlParserRULE_statistics_type_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7784) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_cost_clauseContext is an interface to support dynamic dispatch. +type IDefault_cost_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + COST() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Cpu_cost() ICpu_costContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Io_cost() IIo_costContext + Network_cost() INetwork_costContext + RIGHT_PAREN() antlr.TerminalNode + + // IsDefault_cost_clauseContext differentiates from other interfaces. + IsDefault_cost_clauseContext() +} + +type Default_cost_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_cost_clauseContext() *Default_cost_clauseContext { + var p = new(Default_cost_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_cost_clause + return p +} + +func InitEmptyDefault_cost_clauseContext(p *Default_cost_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_cost_clause +} + +func (*Default_cost_clauseContext) IsDefault_cost_clauseContext() {} + +func NewDefault_cost_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_cost_clauseContext { + var p = new(Default_cost_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_cost_clause + + return p +} + +func (s *Default_cost_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_cost_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_cost_clauseContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Default_cost_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Default_cost_clauseContext) Cpu_cost() ICpu_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICpu_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICpu_costContext) +} + +func (s *Default_cost_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Default_cost_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Default_cost_clauseContext) Io_cost() IIo_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIo_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIo_costContext) +} + +func (s *Default_cost_clauseContext) Network_cost() INetwork_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_costContext) +} + +func (s *Default_cost_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Default_cost_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_cost_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_cost_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_cost_clause(s) + } +} + +func (s *Default_cost_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_cost_clause(s) + } +} + +func (p *PlSqlParser) Default_cost_clause() (localctx IDefault_cost_clauseContext) { + localctx = NewDefault_cost_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, PlSqlParserRULE_default_cost_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7786) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7787) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7788) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7789) + p.Cpu_cost() + } + { + p.SetState(7790) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7791) + p.Io_cost() + } + { + p.SetState(7792) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7793) + p.Network_cost() + } + { + p.SetState(7794) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICpu_costContext is an interface to support dynamic dispatch. +type ICpu_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsCpu_costContext differentiates from other interfaces. + IsCpu_costContext() +} + +type Cpu_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCpu_costContext() *Cpu_costContext { + var p = new(Cpu_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cpu_cost + return p +} + +func InitEmptyCpu_costContext(p *Cpu_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cpu_cost +} + +func (*Cpu_costContext) IsCpu_costContext() {} + +func NewCpu_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cpu_costContext { + var p = new(Cpu_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cpu_cost + + return p +} + +func (s *Cpu_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cpu_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Cpu_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cpu_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cpu_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCpu_cost(s) + } +} + +func (s *Cpu_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCpu_cost(s) + } +} + +func (p *PlSqlParser) Cpu_cost() (localctx ICpu_costContext) { + localctx = NewCpu_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, PlSqlParserRULE_cpu_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7796) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIo_costContext is an interface to support dynamic dispatch. +type IIo_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsIo_costContext differentiates from other interfaces. + IsIo_costContext() +} + +type Io_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIo_costContext() *Io_costContext { + var p = new(Io_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_io_cost + return p +} + +func InitEmptyIo_costContext(p *Io_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_io_cost +} + +func (*Io_costContext) IsIo_costContext() {} + +func NewIo_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Io_costContext { + var p = new(Io_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_io_cost + + return p +} + +func (s *Io_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Io_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Io_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Io_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Io_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIo_cost(s) + } +} + +func (s *Io_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIo_cost(s) + } +} + +func (p *PlSqlParser) Io_cost() (localctx IIo_costContext) { + localctx = NewIo_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, PlSqlParserRULE_io_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7798) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INetwork_costContext is an interface to support dynamic dispatch. +type INetwork_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsNetwork_costContext differentiates from other interfaces. + IsNetwork_costContext() +} + +type Network_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNetwork_costContext() *Network_costContext { + var p = new(Network_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_network_cost + return p +} + +func InitEmptyNetwork_costContext(p *Network_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_network_cost +} + +func (*Network_costContext) IsNetwork_costContext() {} + +func NewNetwork_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_costContext { + var p = new(Network_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_network_cost + + return p +} + +func (s *Network_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Network_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNetwork_cost(s) + } +} + +func (s *Network_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNetwork_cost(s) + } +} + +func (p *PlSqlParser) Network_cost() (localctx INetwork_costContext) { + localctx = NewNetwork_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, PlSqlParserRULE_network_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7800) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_selectivity_clauseContext is an interface to support dynamic dispatch. +type IDefault_selectivity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + SELECTIVITY() antlr.TerminalNode + Default_selectivity() IDefault_selectivityContext + + // IsDefault_selectivity_clauseContext differentiates from other interfaces. + IsDefault_selectivity_clauseContext() +} + +type Default_selectivity_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_selectivity_clauseContext() *Default_selectivity_clauseContext { + var p = new(Default_selectivity_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause + return p +} + +func InitEmptyDefault_selectivity_clauseContext(p *Default_selectivity_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause +} + +func (*Default_selectivity_clauseContext) IsDefault_selectivity_clauseContext() {} + +func NewDefault_selectivity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_selectivity_clauseContext { + var p = new(Default_selectivity_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause + + return p +} + +func (s *Default_selectivity_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_selectivity_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_selectivity_clauseContext) SELECTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECTIVITY, 0) +} + +func (s *Default_selectivity_clauseContext) Default_selectivity() IDefault_selectivityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_selectivityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_selectivityContext) +} + +func (s *Default_selectivity_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_selectivity_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_selectivity_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_selectivity_clause(s) + } +} + +func (s *Default_selectivity_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_selectivity_clause(s) + } +} + +func (p *PlSqlParser) Default_selectivity_clause() (localctx IDefault_selectivity_clauseContext) { + localctx = NewDefault_selectivity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, PlSqlParserRULE_default_selectivity_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7802) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7803) + p.Match(PlSqlParserSELECTIVITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7804) + p.Default_selectivity() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_selectivityContext is an interface to support dynamic dispatch. +type IDefault_selectivityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsDefault_selectivityContext differentiates from other interfaces. + IsDefault_selectivityContext() +} + +type Default_selectivityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_selectivityContext() *Default_selectivityContext { + var p = new(Default_selectivityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity + return p +} + +func InitEmptyDefault_selectivityContext(p *Default_selectivityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity +} + +func (*Default_selectivityContext) IsDefault_selectivityContext() {} + +func NewDefault_selectivityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_selectivityContext { + var p = new(Default_selectivityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_selectivity + + return p +} + +func (s *Default_selectivityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_selectivityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Default_selectivityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_selectivityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_selectivityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_selectivity(s) + } +} + +func (s *Default_selectivityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_selectivity(s) + } +} + +func (p *PlSqlParser) Default_selectivity() (localctx IDefault_selectivityContext) { + localctx = NewDefault_selectivityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, PlSqlParserRULE_default_selectivity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7806) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStorage_table_clauseContext is an interface to support dynamic dispatch. +type IStorage_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + MANAGED() antlr.TerminalNode + STORAGE() antlr.TerminalNode + TABLES() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + USER() antlr.TerminalNode + + // IsStorage_table_clauseContext differentiates from other interfaces. + IsStorage_table_clauseContext() +} + +type Storage_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStorage_table_clauseContext() *Storage_table_clauseContext { + var p = new(Storage_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_table_clause + return p +} + +func InitEmptyStorage_table_clauseContext(p *Storage_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_table_clause +} + +func (*Storage_table_clauseContext) IsStorage_table_clauseContext() {} + +func NewStorage_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Storage_table_clauseContext { + var p = new(Storage_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_storage_table_clause + + return p +} + +func (s *Storage_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Storage_table_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Storage_table_clauseContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Storage_table_clauseContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Storage_table_clauseContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Storage_table_clauseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Storage_table_clauseContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Storage_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Storage_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Storage_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStorage_table_clause(s) + } +} + +func (s *Storage_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStorage_table_clause(s) + } +} + +func (p *PlSqlParser) Storage_table_clause() (localctx IStorage_table_clauseContext) { + localctx = NewStorage_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, PlSqlParserRULE_storage_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7808) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7809) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSYSTEM || _la == PlSqlParserUSER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7810) + p.Match(PlSqlParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7811) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7812) + p.Match(PlSqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnified_auditingContext is an interface to support dynamic dispatch. +type IUnified_auditingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Policy_name() IPolicy_nameContext + CONTEXT() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + Oracle_namespace() IOracle_namespaceContext + ATTRIBUTES() antlr.TerminalNode + AllAttribute_name() []IAttribute_nameContext + Attribute_name(i int) IAttribute_nameContext + AllAudit_user() []IAudit_userContext + Audit_user(i int) IAudit_userContext + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + BY() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUnified_auditingContext differentiates from other interfaces. + IsUnified_auditingContext() +} + +type Unified_auditingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnified_auditingContext() *Unified_auditingContext { + var p = new(Unified_auditingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unified_auditing + return p +} + +func InitEmptyUnified_auditingContext(p *Unified_auditingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unified_auditing +} + +func (*Unified_auditingContext) IsUnified_auditingContext() {} + +func NewUnified_auditingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unified_auditingContext { + var p = new(Unified_auditingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unified_auditing + + return p +} + +func (s *Unified_auditingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unified_auditingContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Unified_auditingContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Unified_auditingContext) Policy_name() IPolicy_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPolicy_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPolicy_nameContext) +} + +func (s *Unified_auditingContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Unified_auditingContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMESPACE, 0) +} + +func (s *Unified_auditingContext) Oracle_namespace() IOracle_namespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOracle_namespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOracle_namespaceContext) +} + +func (s *Unified_auditingContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Unified_auditingContext) AllAttribute_name() []IAttribute_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_nameContext); ok { + len++ + } + } + + tst := make([]IAttribute_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_nameContext); ok { + tst[i] = t.(IAttribute_nameContext) + i++ + } + } + + return tst +} + +func (s *Unified_auditingContext) Attribute_name(i int) IAttribute_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Unified_auditingContext) AllAudit_user() []IAudit_userContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_userContext); ok { + len++ + } + } + + tst := make([]IAudit_userContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_userContext); ok { + tst[i] = t.(IAudit_userContext) + i++ + } + } + + return tst +} + +func (s *Unified_auditingContext) Audit_user(i int) IAudit_userContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_userContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_userContext) +} + +func (s *Unified_auditingContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Unified_auditingContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Unified_auditingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unified_auditingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unified_auditingContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Unified_auditingContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Unified_auditingContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Unified_auditingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unified_auditingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unified_auditingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnified_auditing(s) + } +} + +func (s *Unified_auditingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnified_auditing(s) + } +} + +func (p *PlSqlParser) Unified_auditing() (localctx IUnified_auditingContext) { + localctx = NewUnified_auditingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, PlSqlParserRULE_unified_auditing) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7814) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7815) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPOLICY: + { + p.SetState(7816) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7817) + p.Policy_name() + } + p.SetState(7827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY || _la == PlSqlParserEXCEPT { + { + p.SetState(7818) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBY || _la == PlSqlParserEXCEPT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7819) + p.Audit_user() + } + p.SetState(7824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7820) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7821) + p.Audit_user() + } + + p.SetState(7826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHENEVER { + { + p.SetState(7829) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(7830) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7833) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCONTEXT: + { + p.SetState(7836) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7837) + p.Match(PlSqlParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7838) + p.Oracle_namespace() + } + { + p.SetState(7839) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7840) + p.Attribute_name() + } + p.SetState(7845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7841) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7842) + p.Attribute_name() + } + + p.SetState(7847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(7848) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7849) + p.Audit_user() + } + p.SetState(7854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7850) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7851) + p.Audit_user() + } + + p.SetState(7856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPolicy_nameContext is an interface to support dynamic dispatch. +type IPolicy_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsPolicy_nameContext differentiates from other interfaces. + IsPolicy_nameContext() +} + +type Policy_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPolicy_nameContext() *Policy_nameContext { + var p = new(Policy_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_policy_name + return p +} + +func InitEmptyPolicy_nameContext(p *Policy_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_policy_name +} + +func (*Policy_nameContext) IsPolicy_nameContext() {} + +func NewPolicy_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Policy_nameContext { + var p = new(Policy_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_policy_name + + return p +} + +func (s *Policy_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Policy_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Policy_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Policy_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Policy_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPolicy_name(s) + } +} + +func (s *Policy_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPolicy_name(s) + } +} + +func (p *PlSqlParser) Policy_name() (localctx IPolicy_nameContext) { + localctx = NewPolicy_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, PlSqlParserRULE_policy_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7861) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_traditionalContext is an interface to support dynamic dispatch. +type IAudit_traditionalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUDIT() antlr.TerminalNode + Audit_operation_clause() IAudit_operation_clauseContext + Audit_schema_object_clause() IAudit_schema_object_clauseContext + NETWORK() antlr.TerminalNode + Audit_direct_path() IAudit_direct_pathContext + BY() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + Audit_container_clause() IAudit_container_clauseContext + AllSESSION() []antlr.TerminalNode + SESSION(i int) antlr.TerminalNode + ACCESS() antlr.TerminalNode + Auditing_by_clause() IAuditing_by_clauseContext + IN() antlr.TerminalNode + CURRENT() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsAudit_traditionalContext differentiates from other interfaces. + IsAudit_traditionalContext() +} + +type Audit_traditionalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_traditionalContext() *Audit_traditionalContext { + var p = new(Audit_traditionalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_traditional + return p +} + +func InitEmptyAudit_traditionalContext(p *Audit_traditionalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_traditional +} + +func (*Audit_traditionalContext) IsAudit_traditionalContext() {} + +func NewAudit_traditionalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_traditionalContext { + var p = new(Audit_traditionalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_traditional + + return p +} + +func (s *Audit_traditionalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_traditionalContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Audit_traditionalContext) Audit_operation_clause() IAudit_operation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_operation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_operation_clauseContext) +} + +func (s *Audit_traditionalContext) Audit_schema_object_clause() IAudit_schema_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_schema_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_schema_object_clauseContext) +} + +func (s *Audit_traditionalContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Audit_traditionalContext) Audit_direct_path() IAudit_direct_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_direct_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_direct_pathContext) +} + +func (s *Audit_traditionalContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Audit_traditionalContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Audit_traditionalContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Audit_traditionalContext) Audit_container_clause() IAudit_container_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_container_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_container_clauseContext) +} + +func (s *Audit_traditionalContext) AllSESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSESSION) +} + +func (s *Audit_traditionalContext) SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, i) +} + +func (s *Audit_traditionalContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Audit_traditionalContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Audit_traditionalContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Audit_traditionalContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Audit_traditionalContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Audit_traditionalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_traditionalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_traditionalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_traditional(s) + } +} + +func (s *Audit_traditionalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_traditional(s) + } +} + +func (p *PlSqlParser) Audit_traditional() (localctx IAudit_traditionalContext) { + localctx = NewAudit_traditionalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, PlSqlParserRULE_audit_traditional) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7863) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 830, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7864) + p.Audit_operation_clause() + } + p.SetState(7869) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) == 1 { + { + p.SetState(7865) + p.Auditing_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) == 2 { + { + p.SetState(7866) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7867) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7868) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(7871) + p.Audit_schema_object_clause() + } + + case 3: + { + p.SetState(7872) + p.Match(PlSqlParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(7873) + p.Audit_direct_path() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7878) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 831, p.GetParserRuleContext()) == 1 { + { + p.SetState(7876) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7877) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACCESS || _la == PlSqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7885) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 833, p.GetParserRuleContext()) == 1 { + { + p.SetState(7880) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(7881) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7884) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7888) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 834, p.GetParserRuleContext()) == 1 { + { + p.SetState(7887) + p.Audit_container_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_direct_pathContext is an interface to support dynamic dispatch. +type IAudit_direct_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIRECT_PATH() antlr.TerminalNode + Auditing_by_clause() IAuditing_by_clauseContext + + // IsAudit_direct_pathContext differentiates from other interfaces. + IsAudit_direct_pathContext() +} + +type Audit_direct_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_direct_pathContext() *Audit_direct_pathContext { + var p = new(Audit_direct_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_direct_path + return p +} + +func InitEmptyAudit_direct_pathContext(p *Audit_direct_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_direct_path +} + +func (*Audit_direct_pathContext) IsAudit_direct_pathContext() {} + +func NewAudit_direct_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_direct_pathContext { + var p = new(Audit_direct_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_direct_path + + return p +} + +func (s *Audit_direct_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_direct_pathContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Audit_direct_pathContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Audit_direct_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_direct_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_direct_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_direct_path(s) + } +} + +func (s *Audit_direct_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_direct_path(s) + } +} + +func (p *PlSqlParser) Audit_direct_path() (localctx IAudit_direct_pathContext) { + localctx = NewAudit_direct_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 722, PlSqlParserRULE_audit_direct_path) + p.EnterOuterAlt(localctx, 1) + p.SetState(7890) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7891) + p.Match(PlSqlParserDIRECT_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7892) + p.Auditing_by_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_container_clauseContext is an interface to support dynamic dispatch. +type IAudit_container_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsAudit_container_clauseContext differentiates from other interfaces. + IsAudit_container_clauseContext() +} + +type Audit_container_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_container_clauseContext() *Audit_container_clauseContext { + var p = new(Audit_container_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_container_clause + return p +} + +func InitEmptyAudit_container_clauseContext(p *Audit_container_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_container_clause +} + +func (*Audit_container_clauseContext) IsAudit_container_clauseContext() {} + +func NewAudit_container_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_container_clauseContext { + var p = new(Audit_container_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_container_clause + + return p +} + +func (s *Audit_container_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_container_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Audit_container_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Audit_container_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Audit_container_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Audit_container_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_container_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_container_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_container_clause(s) + } +} + +func (s *Audit_container_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_container_clause(s) + } +} + +func (p *PlSqlParser) Audit_container_clause() (localctx IAudit_container_clauseContext) { + localctx = NewAudit_container_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, PlSqlParserRULE_audit_container_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7894) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + + { + p.SetState(7895) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7896) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7897) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCURRENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_operation_clauseContext is an interface to support dynamic dispatch. +type IAudit_operation_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSql_statement_shortcut() []ISql_statement_shortcutContext + Sql_statement_shortcut(i int) ISql_statement_shortcutContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllPRIVILEGES() []antlr.TerminalNode + PRIVILEGES(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSTATEMENTS() []antlr.TerminalNode + STATEMENTS(i int) antlr.TerminalNode + + // IsAudit_operation_clauseContext differentiates from other interfaces. + IsAudit_operation_clauseContext() +} + +type Audit_operation_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_operation_clauseContext() *Audit_operation_clauseContext { + var p = new(Audit_operation_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_operation_clause + return p +} + +func InitEmptyAudit_operation_clauseContext(p *Audit_operation_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_operation_clause +} + +func (*Audit_operation_clauseContext) IsAudit_operation_clauseContext() {} + +func NewAudit_operation_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_operation_clauseContext { + var p = new(Audit_operation_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_operation_clause + + return p +} + +func (s *Audit_operation_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_operation_clauseContext) AllSql_statement_shortcut() []ISql_statement_shortcutContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_statement_shortcutContext); ok { + len++ + } + } + + tst := make([]ISql_statement_shortcutContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_statement_shortcutContext); ok { + tst[i] = t.(ISql_statement_shortcutContext) + i++ + } + } + + return tst +} + +func (s *Audit_operation_clauseContext) Sql_statement_shortcut(i int) ISql_statement_shortcutContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statement_shortcutContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_statement_shortcutContext) +} + +func (s *Audit_operation_clauseContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Audit_operation_clauseContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Audit_operation_clauseContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Audit_operation_clauseContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Audit_operation_clauseContext) AllPRIVILEGES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVILEGES) +} + +func (s *Audit_operation_clauseContext) PRIVILEGES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, i) +} + +func (s *Audit_operation_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Audit_operation_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Audit_operation_clauseContext) AllSTATEMENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATEMENTS) +} + +func (s *Audit_operation_clauseContext) STATEMENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENTS, i) +} + +func (s *Audit_operation_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_operation_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_operation_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_operation_clause(s) + } +} + +func (s *Audit_operation_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_operation_clause(s) + } +} + +func (p *PlSqlParser) Audit_operation_clause() (localctx IAudit_operation_clauseContext) { + localctx = NewAudit_operation_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, PlSqlParserRULE_audit_operation_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 843, p.GetParserRuleContext()) { + case 1: + p.SetState(7904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7899) + p.Sql_statement_shortcut() + } + + case 2: + { + p.SetState(7900) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7902) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 835, p.GetParserRuleContext()) == 1 { + { + p.SetState(7901) + p.Match(PlSqlParserSTATEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 839, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7906) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 838, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7907) + p.Sql_statement_shortcut() + } + + case 2: + { + p.SetState(7908) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7910) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 837, p.GetParserRuleContext()) == 1 { + { + p.SetState(7909) + p.Match(PlSqlParserSTATEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 839, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.SetState(7922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 840, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7919) + p.System_privilege() + } + + case 2: + { + p.SetState(7920) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7921) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 842, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7924) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 841, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7925) + p.System_privilege() + } + + case 2: + { + p.SetState(7926) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7927) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 842, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuditing_by_clauseContext is an interface to support dynamic dispatch. +type IAuditing_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + AllAudit_user() []IAudit_userContext + Audit_user(i int) IAudit_userContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAuditing_by_clauseContext differentiates from other interfaces. + IsAuditing_by_clauseContext() +} + +type Auditing_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuditing_by_clauseContext() *Auditing_by_clauseContext { + var p = new(Auditing_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_by_clause + return p +} + +func InitEmptyAuditing_by_clauseContext(p *Auditing_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_by_clause +} + +func (*Auditing_by_clauseContext) IsAuditing_by_clauseContext() {} + +func NewAuditing_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auditing_by_clauseContext { + var p = new(Auditing_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_auditing_by_clause + + return p +} + +func (s *Auditing_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auditing_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Auditing_by_clauseContext) AllAudit_user() []IAudit_userContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_userContext); ok { + len++ + } + } + + tst := make([]IAudit_userContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_userContext); ok { + tst[i] = t.(IAudit_userContext) + i++ + } + } + + return tst +} + +func (s *Auditing_by_clauseContext) Audit_user(i int) IAudit_userContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_userContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_userContext) +} + +func (s *Auditing_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Auditing_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Auditing_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auditing_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auditing_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAuditing_by_clause(s) + } +} + +func (s *Auditing_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAuditing_by_clause(s) + } +} + +func (p *PlSqlParser) Auditing_by_clause() (localctx IAuditing_by_clauseContext) { + localctx = NewAuditing_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, PlSqlParserRULE_auditing_by_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7937) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7938) + p.Audit_user() + } + p.SetState(7943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7939) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7940) + p.Audit_user() + } + + } + p.SetState(7945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_userContext is an interface to support dynamic dispatch. +type IAudit_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsAudit_userContext differentiates from other interfaces. + IsAudit_userContext() +} + +type Audit_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_userContext() *Audit_userContext { + var p = new(Audit_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_user + return p +} + +func InitEmptyAudit_userContext(p *Audit_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_user +} + +func (*Audit_userContext) IsAudit_userContext() {} + +func NewAudit_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_userContext { + var p = new(Audit_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_user + + return p +} + +func (s *Audit_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_userContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Audit_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_user(s) + } +} + +func (s *Audit_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_user(s) + } +} + +func (p *PlSqlParser) Audit_user() (localctx IAudit_userContext) { + localctx = NewAudit_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, PlSqlParserRULE_audit_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7946) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_schema_object_clauseContext is an interface to support dynamic dispatch. +type IAudit_schema_object_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Auditing_on_clause() IAuditing_on_clauseContext + AllSql_operation() []ISql_operationContext + Sql_operation(i int) ISql_operationContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAudit_schema_object_clauseContext differentiates from other interfaces. + IsAudit_schema_object_clauseContext() +} + +type Audit_schema_object_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_schema_object_clauseContext() *Audit_schema_object_clauseContext { + var p = new(Audit_schema_object_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause + return p +} + +func InitEmptyAudit_schema_object_clauseContext(p *Audit_schema_object_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause +} + +func (*Audit_schema_object_clauseContext) IsAudit_schema_object_clauseContext() {} + +func NewAudit_schema_object_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_schema_object_clauseContext { + var p = new(Audit_schema_object_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause + + return p +} + +func (s *Audit_schema_object_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_schema_object_clauseContext) Auditing_on_clause() IAuditing_on_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_on_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_on_clauseContext) +} + +func (s *Audit_schema_object_clauseContext) AllSql_operation() []ISql_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_operationContext); ok { + len++ + } + } + + tst := make([]ISql_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_operationContext); ok { + tst[i] = t.(ISql_operationContext) + i++ + } + } + + return tst +} + +func (s *Audit_schema_object_clauseContext) Sql_operation(i int) ISql_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_operationContext) +} + +func (s *Audit_schema_object_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Audit_schema_object_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Audit_schema_object_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Audit_schema_object_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_schema_object_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_schema_object_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_schema_object_clause(s) + } +} + +func (s *Audit_schema_object_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_schema_object_clause(s) + } +} + +func (p *PlSqlParser) Audit_schema_object_clause() (localctx IAudit_schema_object_clauseContext) { + localctx = NewAudit_schema_object_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, PlSqlParserRULE_audit_schema_object_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER, PlSqlParserAUDIT, PlSqlParserCOMMENT, PlSqlParserDELETE, PlSqlParserEXECUTE, PlSqlParserFLASHBACK, PlSqlParserGRANT, PlSqlParserINDEX, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserREAD, PlSqlParserRENAME, PlSqlParserSELECT, PlSqlParserUPDATE: + { + p.SetState(7948) + p.Sql_operation() + } + p.SetState(7953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7949) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7950) + p.Sql_operation() + } + + p.SetState(7955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(7956) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7959) + p.Auditing_on_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_operationContext is an interface to support dynamic dispatch. +type ISql_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + GRANT() antlr.TerminalNode + INDEX() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + READ() antlr.TerminalNode + RENAME() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsSql_operationContext differentiates from other interfaces. + IsSql_operationContext() +} + +type Sql_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_operationContext() *Sql_operationContext { + var p = new(Sql_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_operation + return p +} + +func InitEmptySql_operationContext(p *Sql_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_operation +} + +func (*Sql_operationContext) IsSql_operationContext() {} + +func NewSql_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_operationContext { + var p = new(Sql_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_operation + + return p +} + +func (s *Sql_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_operationContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Sql_operationContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Sql_operationContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Sql_operationContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Sql_operationContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Sql_operationContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Sql_operationContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Sql_operationContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Sql_operationContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Sql_operationContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Sql_operationContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Sql_operationContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Sql_operationContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Sql_operationContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Sql_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_operation(s) + } +} + +func (s *Sql_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_operation(s) + } +} + +func (p *PlSqlParser) Sql_operation() (localctx ISql_operationContext) { + localctx = NewSql_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, PlSqlParserRULE_sql_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7961) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserAUDIT || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserEXECUTE || _la == PlSqlParserFLASHBACK || _la == PlSqlParserGRANT || _la == PlSqlParserINDEX || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserRENAME || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuditing_on_clauseContext is an interface to support dynamic dispatch. +type IAuditing_on_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Object_name() IObject_nameContext + DIRECTORY() antlr.TerminalNode + Regular_id() IRegular_idContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + Model_name() IModel_nameContext + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Profile_name() IProfile_nameContext + DEFAULT() antlr.TerminalNode + + // IsAuditing_on_clauseContext differentiates from other interfaces. + IsAuditing_on_clauseContext() +} + +type Auditing_on_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuditing_on_clauseContext() *Auditing_on_clauseContext { + var p = new(Auditing_on_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_on_clause + return p +} + +func InitEmptyAuditing_on_clauseContext(p *Auditing_on_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_on_clause +} + +func (*Auditing_on_clauseContext) IsAuditing_on_clauseContext() {} + +func NewAuditing_on_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auditing_on_clauseContext { + var p = new(Auditing_on_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_auditing_on_clause + + return p +} + +func (s *Auditing_on_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auditing_on_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Auditing_on_clauseContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Auditing_on_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Auditing_on_clauseContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Auditing_on_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Auditing_on_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Auditing_on_clauseContext) Model_name() IModel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_nameContext) +} + +func (s *Auditing_on_clauseContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Auditing_on_clauseContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Auditing_on_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Auditing_on_clauseContext) Profile_name() IProfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProfile_nameContext) +} + +func (s *Auditing_on_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Auditing_on_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auditing_on_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auditing_on_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAuditing_on_clause(s) + } +} + +func (s *Auditing_on_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAuditing_on_clause(s) + } +} + +func (p *PlSqlParser) Auditing_on_clause() (localctx IAuditing_on_clauseContext) { + localctx = NewAuditing_on_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, PlSqlParserRULE_auditing_on_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7963) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 847, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7964) + p.Object_name() + } + + case 2: + { + p.SetState(7965) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7966) + p.Regular_id() + } + + case 3: + { + p.SetState(7967) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7968) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7969) + p.Model_name() + } + + case 4: + p.SetState(7970) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7971) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7972) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7973) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7974) + p.Profile_name() + } + + case 5: + { + p.SetState(7975) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_nameContext is an interface to support dynamic dispatch. +type IModel_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsModel_nameContext differentiates from other interfaces. + IsModel_nameContext() +} + +type Model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_nameContext() *Model_nameContext { + var p = new(Model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_name + return p +} + +func InitEmptyModel_nameContext(p *Model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_name +} + +func (*Model_nameContext) IsModel_nameContext() {} + +func NewModel_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_nameContext { + var p = new(Model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_name + + return p +} + +func (s *Model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Model_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Model_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_name(s) + } +} + +func (s *Model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_name(s) + } +} + +func (p *PlSqlParser) Model_name() (localctx IModel_nameContext) { + localctx = NewModel_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, PlSqlParserRULE_model_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7981) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 848, p.GetParserRuleContext()) == 1 { + { + p.SetState(7978) + p.Id_expression() + } + { + p.SetState(7979) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7983) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_nameContext is an interface to support dynamic dispatch. +type IObject_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsObject_nameContext differentiates from other interfaces. + IsObject_nameContext() +} + +type Object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_nameContext() *Object_nameContext { + var p = new(Object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_name + return p +} + +func InitEmptyObject_nameContext(p *Object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_name +} + +func (*Object_nameContext) IsObject_nameContext() {} + +func NewObject_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_nameContext { + var p = new(Object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_name + + return p +} + +func (s *Object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Object_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Object_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_name(s) + } +} + +func (s *Object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_name(s) + } +} + +func (p *PlSqlParser) Object_name() (localctx IObject_nameContext) { + localctx = NewObject_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, PlSqlParserRULE_object_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7988) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 849, p.GetParserRuleContext()) == 1 { + { + p.SetState(7985) + p.Id_expression() + } + { + p.SetState(7986) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7990) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProfile_nameContext is an interface to support dynamic dispatch. +type IProfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsProfile_nameContext differentiates from other interfaces. + IsProfile_nameContext() +} + +type Profile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProfile_nameContext() *Profile_nameContext { + var p = new(Profile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_name + return p +} + +func InitEmptyProfile_nameContext(p *Profile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_name +} + +func (*Profile_nameContext) IsProfile_nameContext() {} + +func NewProfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Profile_nameContext { + var p = new(Profile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_profile_name + + return p +} + +func (s *Profile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Profile_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Profile_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Profile_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Profile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Profile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Profile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProfile_name(s) + } +} + +func (s *Profile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProfile_name(s) + } +} + +func (p *PlSqlParser) Profile_name() (localctx IProfile_nameContext) { + localctx = NewProfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, PlSqlParserRULE_profile_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7995) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 850, p.GetParserRuleContext()) == 1 { + { + p.SetState(7992) + p.Id_expression() + } + { + p.SetState(7993) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7997) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_statement_shortcutContext is an interface to support dynamic dispatch. +type ISql_statement_shortcutContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + INDEX() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUDIT() antlr.TerminalNode + GRANT() antlr.TerminalNode + TABLE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TYPE() antlr.TerminalNode + USER() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsSql_statement_shortcutContext differentiates from other interfaces. + IsSql_statement_shortcutContext() +} + +type Sql_statement_shortcutContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_statement_shortcutContext() *Sql_statement_shortcutContext { + var p = new(Sql_statement_shortcutContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut + return p +} + +func InitEmptySql_statement_shortcutContext(p *Sql_statement_shortcutContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut +} + +func (*Sql_statement_shortcutContext) IsSql_statement_shortcutContext() {} + +func NewSql_statement_shortcutContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_statement_shortcutContext { + var p = new(Sql_statement_shortcutContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut + + return p +} + +func (s *Sql_statement_shortcutContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_statement_shortcutContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Sql_statement_shortcutContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Sql_statement_shortcutContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Sql_statement_shortcutContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Sql_statement_shortcutContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Sql_statement_shortcutContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Sql_statement_shortcutContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Sql_statement_shortcutContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Sql_statement_shortcutContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Sql_statement_shortcutContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Sql_statement_shortcutContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Sql_statement_shortcutContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Sql_statement_shortcutContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Sql_statement_shortcutContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Sql_statement_shortcutContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Sql_statement_shortcutContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Sql_statement_shortcutContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Sql_statement_shortcutContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Sql_statement_shortcutContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Sql_statement_shortcutContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Sql_statement_shortcutContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Sql_statement_shortcutContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Sql_statement_shortcutContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Sql_statement_shortcutContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Sql_statement_shortcutContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Sql_statement_shortcutContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Sql_statement_shortcutContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Sql_statement_shortcutContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Sql_statement_shortcutContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Sql_statement_shortcutContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Sql_statement_shortcutContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Sql_statement_shortcutContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Sql_statement_shortcutContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Sql_statement_shortcutContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Sql_statement_shortcutContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Sql_statement_shortcutContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Sql_statement_shortcutContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Sql_statement_shortcutContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Sql_statement_shortcutContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_statement_shortcutContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_statement_shortcutContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_statement_shortcut(s) + } +} + +func (s *Sql_statement_shortcutContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_statement_shortcut(s) + } +} + +func (p *PlSqlParser) Sql_statement_shortcut() (localctx ISql_statement_shortcutContext) { + localctx = NewSql_statement_shortcutContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, PlSqlParserRULE_sql_statement_shortcut) + p.SetState(8069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 851, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7999) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8000) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8001) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8002) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8003) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8004) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8005) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8006) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8007) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8008) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8009) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8010) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8011) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8012) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + p.SetState(8013) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8014) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8015) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(8016) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(8017) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(8018) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8019) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8020) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(8021) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8022) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(8023) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(8024) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8025) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(8026) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(8027) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(8028) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(8029) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8030) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(8031) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8032) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(8033) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(8034) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(8035) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(8036) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(8037) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(8038) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(8039) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8040) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(8041) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8042) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(8043) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8044) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(8045) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8046) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(8047) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8048) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(8049) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8050) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(8051) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8052) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(8053) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8054) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(8055) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8056) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(8057) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8058) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(8059) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8060) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(8061) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8062) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(8063) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8064) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(8065) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8066) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(8067) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8068) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_indexContext is an interface to support dynamic dispatch. +type IDrop_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_indexContext differentiates from other interfaces. + IsDrop_indexContext() +} + +type Drop_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_indexContext() *Drop_indexContext { + var p = new(Drop_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index + return p +} + +func InitEmptyDrop_indexContext(p *Drop_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index +} + +func (*Drop_indexContext) IsDrop_indexContext() {} + +func NewDrop_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indexContext { + var p = new(Drop_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_index + + return p +} + +func (s *Drop_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_indexContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Drop_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Drop_indexContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_indexContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_index(s) + } +} + +func (s *Drop_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_index(s) + } +} + +func (p *PlSqlParser) Drop_index() (localctx IDrop_indexContext) { + localctx = NewDrop_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, PlSqlParserRULE_drop_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8071) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8072) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8073) + p.Index_name() + } + p.SetState(8076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(8074) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8075) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDisassociate_statisticsContext is an interface to support dynamic dispatch. +type IDisassociate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTb returns the tb rule contexts. + GetTb() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // GetFn returns the fn rule contexts. + GetFn() IId_expressionContext + + // GetPkg returns the pkg rule contexts. + GetPkg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetIx returns the ix rule contexts. + GetIx() IId_expressionContext + + // GetIt returns the it rule contexts. + GetIt() IId_expressionContext + + // SetTb sets the tb rule contexts. + SetTb(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // SetFn sets the fn rule contexts. + SetFn(IId_expressionContext) + + // SetPkg sets the pkg rule contexts. + SetPkg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetIx sets the ix rule contexts. + SetIx(IId_expressionContext) + + // SetIt sets the it rule contexts. + SetIt(IId_expressionContext) + + // Getter signatures + DISASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + FROM() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + PACKAGES() antlr.TerminalNode + TYPES() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INDEXTYPES() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + FORCE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisassociate_statisticsContext differentiates from other interfaces. + IsDisassociate_statisticsContext() +} + +type Disassociate_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tb IId_expressionContext + c IId_expressionContext + fn IId_expressionContext + pkg IId_expressionContext + t IId_expressionContext + ix IId_expressionContext + it IId_expressionContext +} + +func NewEmptyDisassociate_statisticsContext() *Disassociate_statisticsContext { + var p = new(Disassociate_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disassociate_statistics + return p +} + +func InitEmptyDisassociate_statisticsContext(p *Disassociate_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disassociate_statistics +} + +func (*Disassociate_statisticsContext) IsDisassociate_statisticsContext() {} + +func NewDisassociate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disassociate_statisticsContext { + var p = new(Disassociate_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disassociate_statistics + + return p +} + +func (s *Disassociate_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disassociate_statisticsContext) GetTb() IId_expressionContext { return s.tb } + +func (s *Disassociate_statisticsContext) GetC() IId_expressionContext { return s.c } + +func (s *Disassociate_statisticsContext) GetFn() IId_expressionContext { return s.fn } + +func (s *Disassociate_statisticsContext) GetPkg() IId_expressionContext { return s.pkg } + +func (s *Disassociate_statisticsContext) GetT() IId_expressionContext { return s.t } + +func (s *Disassociate_statisticsContext) GetIx() IId_expressionContext { return s.ix } + +func (s *Disassociate_statisticsContext) GetIt() IId_expressionContext { return s.it } + +func (s *Disassociate_statisticsContext) SetTb(v IId_expressionContext) { s.tb = v } + +func (s *Disassociate_statisticsContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Disassociate_statisticsContext) SetFn(v IId_expressionContext) { s.fn = v } + +func (s *Disassociate_statisticsContext) SetPkg(v IId_expressionContext) { s.pkg = v } + +func (s *Disassociate_statisticsContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Disassociate_statisticsContext) SetIx(v IId_expressionContext) { s.ix = v } + +func (s *Disassociate_statisticsContext) SetIt(v IId_expressionContext) { s.it = v } + +func (s *Disassociate_statisticsContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Disassociate_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Disassociate_statisticsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Disassociate_statisticsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Disassociate_statisticsContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Disassociate_statisticsContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Disassociate_statisticsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Disassociate_statisticsContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Disassociate_statisticsContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Disassociate_statisticsContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Disassociate_statisticsContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Disassociate_statisticsContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disassociate_statisticsContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disassociate_statisticsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Disassociate_statisticsContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Disassociate_statisticsContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Disassociate_statisticsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disassociate_statisticsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disassociate_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disassociate_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disassociate_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisassociate_statistics(s) + } +} + +func (s *Disassociate_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisassociate_statistics(s) + } +} + +func (p *PlSqlParser) Disassociate_statistics() (localctx IDisassociate_statisticsContext) { + localctx = NewDisassociate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, PlSqlParserRULE_disassociate_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8078) + p.Match(PlSqlParserDISASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8079) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8080) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS: + { + p.SetState(8081) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 853, p.GetParserRuleContext()) == 1 { + { + p.SetState(8082) + p.Schema_name() + } + { + p.SetState(8083) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8087) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).tb = _x + } + { + p.SetState(8088) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8089) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).c = _x + } + p.SetState(8102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8090) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8094) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 854, p.GetParserRuleContext()) == 1 { + { + p.SetState(8091) + p.Schema_name() + } + { + p.SetState(8092) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8096) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).tb = _x + } + { + p.SetState(8097) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8098) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).c = _x + } + + p.SetState(8104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserFUNCTIONS: + { + p.SetState(8105) + p.Match(PlSqlParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8109) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 856, p.GetParserRuleContext()) == 1 { + { + p.SetState(8106) + p.Schema_name() + } + { + p.SetState(8107) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8111) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).fn = _x + } + p.SetState(8121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8112) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8116) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 857, p.GetParserRuleContext()) == 1 { + { + p.SetState(8113) + p.Schema_name() + } + { + p.SetState(8114) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8118) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).fn = _x + } + + p.SetState(8123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPACKAGES: + { + p.SetState(8124) + p.Match(PlSqlParserPACKAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8128) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 859, p.GetParserRuleContext()) == 1 { + { + p.SetState(8125) + p.Schema_name() + } + { + p.SetState(8126) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8130) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).pkg = _x + } + p.SetState(8140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8131) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8135) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 860, p.GetParserRuleContext()) == 1 { + { + p.SetState(8132) + p.Schema_name() + } + { + p.SetState(8133) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8137) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).pkg = _x + } + + p.SetState(8142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTYPES: + { + p.SetState(8143) + p.Match(PlSqlParserTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8147) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 862, p.GetParserRuleContext()) == 1 { + { + p.SetState(8144) + p.Schema_name() + } + { + p.SetState(8145) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8149) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).t = _x + } + p.SetState(8159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8150) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) == 1 { + { + p.SetState(8151) + p.Schema_name() + } + { + p.SetState(8152) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8156) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).t = _x + } + + p.SetState(8161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXES: + { + p.SetState(8162) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8166) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 865, p.GetParserRuleContext()) == 1 { + { + p.SetState(8163) + p.Schema_name() + } + { + p.SetState(8164) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8168) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).ix = _x + } + p.SetState(8178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8169) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8173) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 866, p.GetParserRuleContext()) == 1 { + { + p.SetState(8170) + p.Schema_name() + } + { + p.SetState(8171) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8175) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).ix = _x + } + + p.SetState(8180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXTYPES: + { + p.SetState(8181) + p.Match(PlSqlParserINDEXTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8185) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 868, p.GetParserRuleContext()) == 1 { + { + p.SetState(8182) + p.Schema_name() + } + { + p.SetState(8183) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8187) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).it = _x + } + p.SetState(8197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8188) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8192) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 869, p.GetParserRuleContext()) == 1 { + { + p.SetState(8189) + p.Schema_name() + } + { + p.SetState(8190) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8194) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).it = _x + } + + p.SetState(8199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(8202) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_indextypeContext is an interface to support dynamic dispatch. +type IDrop_indextypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIt returns the it rule contexts. + GetIt() IId_expressionContext + + // SetIt sets the it rule contexts. + SetIt(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_indextypeContext differentiates from other interfaces. + IsDrop_indextypeContext() +} + +type Drop_indextypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + it IId_expressionContext +} + +func NewEmptyDrop_indextypeContext() *Drop_indextypeContext { + var p = new(Drop_indextypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_indextype + return p +} + +func InitEmptyDrop_indextypeContext(p *Drop_indextypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_indextype +} + +func (*Drop_indextypeContext) IsDrop_indextypeContext() {} + +func NewDrop_indextypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indextypeContext { + var p = new(Drop_indextypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_indextype + + return p +} + +func (s *Drop_indextypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_indextypeContext) GetIt() IId_expressionContext { return s.it } + +func (s *Drop_indextypeContext) SetIt(v IId_expressionContext) { s.it = v } + +func (s *Drop_indextypeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_indextypeContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Drop_indextypeContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_indextypeContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_indextypeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_indextypeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_indextypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_indextypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_indextypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_indextype(s) + } +} + +func (s *Drop_indextypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_indextype(s) + } +} + +func (p *PlSqlParser) Drop_indextype() (localctx IDrop_indextypeContext) { + localctx = NewDrop_indextypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, PlSqlParserRULE_drop_indextype) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8205) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8206) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8210) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 873, p.GetParserRuleContext()) == 1 { + { + p.SetState(8207) + p.Schema_name() + } + { + p.SetState(8208) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8212) + + var _x = p.Id_expression() + + localctx.(*Drop_indextypeContext).it = _x + } + p.SetState(8214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(8213) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_inmemory_join_groupContext is an interface to support dynamic dispatch. +type IDrop_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_inmemory_join_groupContext differentiates from other interfaces. + IsDrop_inmemory_join_groupContext() +} + +type Drop_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext +} + +func NewEmptyDrop_inmemory_join_groupContext() *Drop_inmemory_join_groupContext { + var p = new(Drop_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group + return p +} + +func InitEmptyDrop_inmemory_join_groupContext(p *Drop_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group +} + +func (*Drop_inmemory_join_groupContext) IsDrop_inmemory_join_groupContext() {} + +func NewDrop_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_inmemory_join_groupContext { + var p = new(Drop_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group + + return p +} + +func (s *Drop_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Drop_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Drop_inmemory_join_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Drop_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Drop_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Drop_inmemory_join_groupContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_inmemory_join_groupContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_inmemory_join_groupContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_inmemory_join_group(s) + } +} + +func (s *Drop_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_inmemory_join_group(s) + } +} + +func (p *PlSqlParser) Drop_inmemory_join_group() (localctx IDrop_inmemory_join_groupContext) { + localctx = NewDrop_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, PlSqlParserRULE_drop_inmemory_join_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8216) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8217) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8218) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8219) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8223) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 875, p.GetParserRuleContext()) == 1 { + { + p.SetState(8220) + p.Schema_name() + } + { + p.SetState(8221) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8225) + + var _x = p.Id_expression() + + localctx.(*Drop_inmemory_join_groupContext).jg = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_tableContext is an interface to support dynamic dispatch. +type IFlashback_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLASHBACK() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + BEFORE() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Expression() IExpressionContext + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + Restore_point() IRestore_pointContext + SCN() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + RENAME() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsFlashback_tableContext differentiates from other interfaces. + IsFlashback_tableContext() +} + +type Flashback_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_tableContext() *Flashback_tableContext { + var p = new(Flashback_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_table + return p +} + +func InitEmptyFlashback_tableContext(p *Flashback_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_table +} + +func (*Flashback_tableContext) IsFlashback_tableContext() {} + +func NewFlashback_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_tableContext { + var p = new(Flashback_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_table + + return p +} + +func (s *Flashback_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_tableContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Flashback_tableContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Flashback_tableContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Flashback_tableContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Flashback_tableContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Flashback_tableContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Flashback_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Flashback_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Flashback_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Flashback_tableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Flashback_tableContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Flashback_tableContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Flashback_tableContext) Restore_point() IRestore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRestore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRestore_pointContext) +} + +func (s *Flashback_tableContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Flashback_tableContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Flashback_tableContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, 0) +} + +func (s *Flashback_tableContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Flashback_tableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Flashback_tableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Flashback_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_table(s) + } +} + +func (s *Flashback_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_table(s) + } +} + +func (p *PlSqlParser) Flashback_table() (localctx IFlashback_tableContext) { + localctx = NewFlashback_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, PlSqlParserRULE_flashback_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8227) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8228) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8229) + p.Tableview_name() + } + p.SetState(8234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8230) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8231) + p.Tableview_name() + } + + p.SetState(8236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8237) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESTORE, PlSqlParserSCN, PlSqlParserTIMESTAMP: + p.SetState(8243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCN, PlSqlParserTIMESTAMP: + { + p.SetState(8238) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8239) + p.Expression() + } + + case PlSqlParserRESTORE: + { + p.SetState(8240) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8241) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8242) + p.Restore_point() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(8245) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8246) + p.Match(PlSqlParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserBEFORE: + { + p.SetState(8249) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8250) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRENAME { + { + p.SetState(8251) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8252) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8253) + p.Tableview_name() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRestore_pointContext is an interface to support dynamic dispatch. +type IRestore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsRestore_pointContext differentiates from other interfaces. + IsRestore_pointContext() +} + +type Restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRestore_pointContext() *Restore_pointContext { + var p = new(Restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_restore_point + return p +} + +func InitEmptyRestore_pointContext(p *Restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_restore_point +} + +func (*Restore_pointContext) IsRestore_pointContext() {} + +func NewRestore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Restore_pointContext { + var p = new(Restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_restore_point + + return p +} + +func (s *Restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Restore_pointContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Restore_pointContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Restore_pointContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRestore_point(s) + } +} + +func (s *Restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRestore_point(s) + } +} + +func (p *PlSqlParser) Restore_point() (localctx IRestore_pointContext) { + localctx = NewRestore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, PlSqlParserRULE_restore_point) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8258) + p.Identifier() + } + p.SetState(8263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(8259) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8260) + p.Id_expression() + } + + p.SetState(8265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPurge_statementContext is an interface to support dynamic dispatch. +type IPurge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // GetU returns the u rule contexts. + GetU() IId_expressionContext + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // SetU sets the u rule contexts. + SetU(IId_expressionContext) + + // Getter signatures + PURGE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + TABLESPACE() antlr.TerminalNode + RECYCLEBIN() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + TABLE() antlr.TerminalNode + INDEX() antlr.TerminalNode + SET() antlr.TerminalNode + USER() antlr.TerminalNode + + // IsPurge_statementContext differentiates from other interfaces. + IsPurge_statementContext() +} + +type Purge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ts IId_expressionContext + u IId_expressionContext +} + +func NewEmptyPurge_statementContext() *Purge_statementContext { + var p = new(Purge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_purge_statement + return p +} + +func InitEmptyPurge_statementContext(p *Purge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_purge_statement +} + +func (*Purge_statementContext) IsPurge_statementContext() {} + +func NewPurge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Purge_statementContext { + var p = new(Purge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_purge_statement + + return p +} + +func (s *Purge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Purge_statementContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Purge_statementContext) GetU() IId_expressionContext { return s.u } + +func (s *Purge_statementContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Purge_statementContext) SetU(v IId_expressionContext) { s.u = v } + +func (s *Purge_statementContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Purge_statementContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Purge_statementContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Purge_statementContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Purge_statementContext) RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLEBIN, 0) +} + +func (s *Purge_statementContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *Purge_statementContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Purge_statementContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Purge_statementContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Purge_statementContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Purge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Purge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Purge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPurge_statement(s) + } +} + +func (s *Purge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPurge_statement(s) + } +} + +func (p *PlSqlParser) Purge_statement() (localctx IPurge_statementContext) { + localctx = NewPurge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, PlSqlParserRULE_purge_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8266) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINDEX, PlSqlParserTABLE: + { + p.SetState(8267) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINDEX || _la == PlSqlParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8268) + p.Id_expression() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(8269) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8271) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 882, p.GetParserRuleContext()) == 1 { + { + p.SetState(8270) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8273) + + var _x = p.Id_expression() + + localctx.(*Purge_statementContext).ts = _x + } + p.SetState(8276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSER { + { + p.SetState(8274) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8275) + + var _x = p.Id_expression() + + localctx.(*Purge_statementContext).u = _x + } + + } + + case PlSqlParserRECYCLEBIN: + { + p.SetState(8278) + p.Match(PlSqlParserRECYCLEBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDBA_RECYCLEBIN: + { + p.SetState(8279) + p.Match(PlSqlParserDBA_RECYCLEBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INoaudit_statementContext is an interface to support dynamic dispatch. +type INoaudit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOAUDIT() antlr.TerminalNode + Audit_operation_clause() IAudit_operation_clauseContext + Audit_schema_object_clause() IAudit_schema_object_clauseContext + NETWORK() antlr.TerminalNode + DIRECT_PATH() antlr.TerminalNode + LOAD() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + Container_clause() IContainer_clauseContext + Auditing_by_clause() IAuditing_by_clauseContext + NOT() antlr.TerminalNode + + // IsNoaudit_statementContext differentiates from other interfaces. + IsNoaudit_statementContext() +} + +type Noaudit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNoaudit_statementContext() *Noaudit_statementContext { + var p = new(Noaudit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_noaudit_statement + return p +} + +func InitEmptyNoaudit_statementContext(p *Noaudit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_noaudit_statement +} + +func (*Noaudit_statementContext) IsNoaudit_statementContext() {} + +func NewNoaudit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Noaudit_statementContext { + var p = new(Noaudit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_noaudit_statement + + return p +} + +func (s *Noaudit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Noaudit_statementContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Noaudit_statementContext) Audit_operation_clause() IAudit_operation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_operation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_operation_clauseContext) +} + +func (s *Noaudit_statementContext) Audit_schema_object_clause() IAudit_schema_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_schema_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_schema_object_clauseContext) +} + +func (s *Noaudit_statementContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Noaudit_statementContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Noaudit_statementContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Noaudit_statementContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Noaudit_statementContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Noaudit_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Noaudit_statementContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Noaudit_statementContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Noaudit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Noaudit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Noaudit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNoaudit_statement(s) + } +} + +func (s *Noaudit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNoaudit_statement(s) + } +} + +func (p *PlSqlParser) Noaudit_statement() (localctx INoaudit_statementContext) { + localctx = NewNoaudit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, PlSqlParserRULE_noaudit_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8282) + p.Match(PlSqlParserNOAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8283) + p.Audit_operation_clause() + } + p.SetState(8285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(8284) + p.Auditing_by_clause() + } + + } + + case 2: + { + p.SetState(8287) + p.Audit_schema_object_clause() + } + + case 3: + { + p.SetState(8288) + p.Match(PlSqlParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(8289) + p.Match(PlSqlParserDIRECT_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8290) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(8291) + p.Auditing_by_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHENEVER { + { + p.SetState(8296) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(8297) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8300) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(8303) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_objectContext is an interface to support dynamic dispatch. +type IRename_objectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + TO() antlr.TerminalNode + + // IsRename_objectContext differentiates from other interfaces. + IsRename_objectContext() +} + +type Rename_objectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_objectContext() *Rename_objectContext { + var p = new(Rename_objectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_object + return p +} + +func InitEmptyRename_objectContext(p *Rename_objectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_object +} + +func (*Rename_objectContext) IsRename_objectContext() {} + +func NewRename_objectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_objectContext { + var p = new(Rename_objectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_object + + return p +} + +func (s *Rename_objectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_objectContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_objectContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Rename_objectContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Rename_objectContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_objectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_objectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_objectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_object(s) + } +} + +func (s *Rename_objectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_object(s) + } +} + +func (p *PlSqlParser) Rename_object() (localctx IRename_objectContext) { + localctx = NewRename_objectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, PlSqlParserRULE_rename_object) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8306) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8307) + p.Object_name() + } + { + p.SetState(8308) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8309) + p.Object_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_statementContext is an interface to support dynamic dispatch. +type IGrant_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllGrantee_name() []IGrantee_nameContext + Grantee_name(i int) IGrantee_nameContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + ON() antlr.TerminalNode + Grant_object_name() IGrant_object_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllOPTION() []antlr.TerminalNode + OPTION(i int) antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Container_clause() IContainer_clauseContext + ADMIN() antlr.TerminalNode + DELEGATE() antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllObject_privilege() []IObject_privilegeContext + Object_privilege(i int) IObject_privilegeContext + AllParen_column_list() []IParen_column_listContext + Paren_column_list(i int) IParen_column_listContext + + // IsGrant_statementContext differentiates from other interfaces. + IsGrant_statementContext() +} + +type Grant_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_statementContext() *Grant_statementContext { + var p = new(Grant_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_statement + return p +} + +func InitEmptyGrant_statementContext(p *Grant_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_statement +} + +func (*Grant_statementContext) IsGrant_statementContext() {} + +func NewGrant_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_statementContext { + var p = new(Grant_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grant_statement + + return p +} + +func (s *Grant_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_statementContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGRANT) +} + +func (s *Grant_statementContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, i) +} + +func (s *Grant_statementContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Grant_statementContext) AllGrantee_name() []IGrantee_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrantee_nameContext); ok { + len++ + } + } + + tst := make([]IGrantee_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrantee_nameContext); ok { + tst[i] = t.(IGrantee_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Grantee_name(i int) IGrantee_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_nameContext) +} + +func (s *Grant_statementContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Grant_statementContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Grant_statementContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Grant_statementContext) Grant_object_name() IGrant_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_object_nameContext) +} + +func (s *Grant_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grant_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grant_statementContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Grant_statementContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Grant_statementContext) AllOPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOPTION) +} + +func (s *Grant_statementContext) OPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, i) +} + +func (s *Grant_statementContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Grant_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Grant_statementContext) ADMIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMIN, 0) +} + +func (s *Grant_statementContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELEGATE, 0) +} + +func (s *Grant_statementContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Grant_statementContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Grant_statementContext) AllObject_privilege() []IObject_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_privilegeContext); ok { + len++ + } + } + + tst := make([]IObject_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_privilegeContext); ok { + tst[i] = t.(IObject_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Object_privilege(i int) IObject_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Grant_statementContext) AllParen_column_list() []IParen_column_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParen_column_listContext); ok { + len++ + } + } + + tst := make([]IParen_column_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParen_column_listContext); ok { + tst[i] = t.(IParen_column_listContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Paren_column_list(i int) IParen_column_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Grant_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrant_statement(s) + } +} + +func (s *Grant_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrant_statement(s) + } +} + +func (p *PlSqlParser) Grant_statement() (localctx IGrant_statementContext) { + localctx = NewGrant_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, PlSqlParserRULE_grant_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8311) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8312) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 893, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8315) + p.Role_name() + } + + case 2: + { + p.SetState(8316) + p.System_privilege() + } + + case 3: + { + p.SetState(8317) + p.Object_privilege() + } + p.SetState(8319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8318) + p.Paren_column_list() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8325) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(8329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(8327) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8328) + p.Grant_object_name() + } + + } + { + p.SetState(8331) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 896, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8332) + p.Grantee_name() + } + + case 2: + { + p.SetState(8333) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8336) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 897, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8337) + p.Grantee_name() + } + + case 2: + { + p.SetState(8338) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8349) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 899, p.GetParserRuleContext()) == 1 { + { + p.SetState(8346) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8347) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADMIN || _la == PlSqlParserDELEGATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8348) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8354) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 900, p.GetParserRuleContext()) == 1 { + { + p.SetState(8351) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8352) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8353) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(8356) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8357) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8358) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(8361) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_clauseContext is an interface to support dynamic dispatch. +type IContainer_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsContainer_clauseContext differentiates from other interfaces. + IsContainer_clauseContext() +} + +type Container_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_clauseContext() *Container_clauseContext { + var p = new(Container_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_clause + return p +} + +func InitEmptyContainer_clauseContext(p *Container_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_clause +} + +func (*Container_clauseContext) IsContainer_clauseContext() {} + +func NewContainer_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_clauseContext { + var p = new(Container_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_clause + + return p +} + +func (s *Container_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Container_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Container_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Container_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Container_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_clause(s) + } +} + +func (s *Container_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_clause(s) + } +} + +func (p *PlSqlParser) Container_clause() (localctx IContainer_clauseContext) { + localctx = NewContainer_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, PlSqlParserRULE_container_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8364) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8365) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8366) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCURRENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_statementContext is an interface to support dynamic dispatch. +type IRevoke_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Revoke_roles_from_programs() IRevoke_roles_from_programsContext + Revoke_system_privilege() IRevoke_system_privilegeContext + Revoke_object_privileges() IRevoke_object_privilegesContext + Container_clause() IContainer_clauseContext + + // IsRevoke_statementContext differentiates from other interfaces. + IsRevoke_statementContext() +} + +type Revoke_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_statementContext() *Revoke_statementContext { + var p = new(Revoke_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_statement + return p +} + +func InitEmptyRevoke_statementContext(p *Revoke_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_statement +} + +func (*Revoke_statementContext) IsRevoke_statementContext() {} + +func NewRevoke_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_statementContext { + var p = new(Revoke_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_statement + + return p +} + +func (s *Revoke_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_statementContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Revoke_statementContext) Revoke_roles_from_programs() IRevoke_roles_from_programsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_roles_from_programsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_roles_from_programsContext) +} + +func (s *Revoke_statementContext) Revoke_system_privilege() IRevoke_system_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_system_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_system_privilegeContext) +} + +func (s *Revoke_statementContext) Revoke_object_privileges() IRevoke_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_object_privilegesContext) +} + +func (s *Revoke_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Revoke_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_statement(s) + } +} + +func (s *Revoke_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_statement(s) + } +} + +func (p *PlSqlParser) Revoke_statement() (localctx IRevoke_statementContext) { + localctx = NewRevoke_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, PlSqlParserRULE_revoke_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8368) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 905, p.GetParserRuleContext()) { + case 1: + p.SetState(8371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 903, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8369) + p.Revoke_system_privilege() + } + + case 2: + { + p.SetState(8370) + p.Revoke_object_privileges() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(8373) + p.Container_clause() + } + + } + + case 2: + { + p.SetState(8376) + p.Revoke_roles_from_programs() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_system_privilegeContext is an interface to support dynamic dispatch. +type IRevoke_system_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + Revokee_clause() IRevokee_clauseContext + System_privilege() ISystem_privilegeContext + Role_name() IRole_nameContext + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + + // IsRevoke_system_privilegeContext differentiates from other interfaces. + IsRevoke_system_privilegeContext() +} + +type Revoke_system_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_system_privilegeContext() *Revoke_system_privilegeContext { + var p = new(Revoke_system_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege + return p +} + +func InitEmptyRevoke_system_privilegeContext(p *Revoke_system_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege +} + +func (*Revoke_system_privilegeContext) IsRevoke_system_privilegeContext() {} + +func NewRevoke_system_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_system_privilegeContext { + var p = new(Revoke_system_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege + + return p +} + +func (s *Revoke_system_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_system_privilegeContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_system_privilegeContext) Revokee_clause() IRevokee_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokee_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokee_clauseContext) +} + +func (s *Revoke_system_privilegeContext) System_privilege() ISystem_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Revoke_system_privilegeContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Revoke_system_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Revoke_system_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Revoke_system_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_system_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_system_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_system_privilege(s) + } +} + +func (s *Revoke_system_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_system_privilege(s) + } +} + +func (p *PlSqlParser) Revoke_system_privilege() (localctx IRevoke_system_privilegeContext) { + localctx = NewRevoke_system_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, PlSqlParserRULE_revoke_system_privilege) + p.EnterOuterAlt(localctx, 1) + p.SetState(8383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 906, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8379) + p.System_privilege() + } + + case 2: + { + p.SetState(8380) + p.Role_name() + } + + case 3: + { + p.SetState(8381) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8382) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8385) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8386) + p.Revokee_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokee_clauseContext is an interface to support dynamic dispatch. +type IRevokee_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevokee_clauseContext differentiates from other interfaces. + IsRevokee_clauseContext() +} + +type Revokee_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokee_clauseContext() *Revokee_clauseContext { + var p = new(Revokee_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revokee_clause + return p +} + +func InitEmptyRevokee_clauseContext(p *Revokee_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revokee_clause +} + +func (*Revokee_clauseContext) IsRevokee_clauseContext() {} + +func NewRevokee_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revokee_clauseContext { + var p = new(Revokee_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revokee_clause + + return p +} + +func (s *Revokee_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revokee_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Revokee_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Revokee_clauseContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Revokee_clauseContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Revokee_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revokee_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revokee_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revokee_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revokee_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevokee_clause(s) + } +} + +func (s *Revokee_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevokee_clause(s) + } +} + +func (p *PlSqlParser) Revokee_clause() (localctx IRevokee_clauseContext) { + localctx = NewRevokee_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, PlSqlParserRULE_revokee_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 907, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8388) + p.Id_expression() + } + + case 2: + { + p.SetState(8389) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8392) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 908, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8393) + p.Id_expression() + } + + case 2: + { + p.SetState(8394) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_object_privilegesContext is an interface to support dynamic dispatch. +type IRevoke_object_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + On_object_clause() IOn_object_clauseContext + FROM() antlr.TerminalNode + Revokee_clause() IRevokee_clauseContext + AllObject_privilege() []IObject_privilegeContext + Object_privilege(i int) IObject_privilegeContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + FORCE() antlr.TerminalNode + AllPRIVILEGES() []antlr.TerminalNode + PRIVILEGES(i int) antlr.TerminalNode + + // IsRevoke_object_privilegesContext differentiates from other interfaces. + IsRevoke_object_privilegesContext() +} + +type Revoke_object_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_object_privilegesContext() *Revoke_object_privilegesContext { + var p = new(Revoke_object_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges + return p +} + +func InitEmptyRevoke_object_privilegesContext(p *Revoke_object_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges +} + +func (*Revoke_object_privilegesContext) IsRevoke_object_privilegesContext() {} + +func NewRevoke_object_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_object_privilegesContext { + var p = new(Revoke_object_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges + + return p +} + +func (s *Revoke_object_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_object_privilegesContext) On_object_clause() IOn_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_object_clauseContext) +} + +func (s *Revoke_object_privilegesContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_object_privilegesContext) Revokee_clause() IRevokee_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokee_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokee_clauseContext) +} + +func (s *Revoke_object_privilegesContext) AllObject_privilege() []IObject_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_privilegeContext); ok { + len++ + } + } + + tst := make([]IObject_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_privilegeContext); ok { + tst[i] = t.(IObject_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Revoke_object_privilegesContext) Object_privilege(i int) IObject_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Revoke_object_privilegesContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Revoke_object_privilegesContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Revoke_object_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revoke_object_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revoke_object_privilegesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Revoke_object_privilegesContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Revoke_object_privilegesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Revoke_object_privilegesContext) AllPRIVILEGES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVILEGES) +} + +func (s *Revoke_object_privilegesContext) PRIVILEGES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, i) +} + +func (s *Revoke_object_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_object_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_object_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_object_privileges(s) + } +} + +func (s *Revoke_object_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_object_privileges(s) + } +} + +func (p *PlSqlParser) Revoke_object_privileges() (localctx IRevoke_object_privilegesContext) { + localctx = NewRevoke_object_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, PlSqlParserRULE_revoke_object_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 911, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8402) + p.Object_privilege() + } + + case 2: + { + p.SetState(8403) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(8404) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8409) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 913, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8410) + p.Object_privilege() + } + + case 2: + { + p.SetState(8411) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(8412) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8422) + p.On_object_clause() + } + { + p.SetState(8423) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8424) + p.Revokee_clause() + } + p.SetState(8428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(8425) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8426) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFORCE: + { + p.SetState(8427) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserCONTAINER, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_object_clauseContext is an interface to support dynamic dispatch. +type IOn_object_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // GetMmn returns the mmn rule contexts. + GetMmn() IId_expressionContext + + // GetO2 returns the o2 rule contexts. + GetO2() IId_expressionContext + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // SetMmn sets the mmn rule contexts. + SetMmn(IId_expressionContext) + + // SetO2 sets the o2 rule contexts. + SetO2(IId_expressionContext) + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + ON() antlr.TerminalNode + USER() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + EDITION() antlr.TerminalNode + Edition_name() IEdition_nameContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + JAVA() antlr.TerminalNode + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_object_clauseContext differentiates from other interfaces. + IsOn_object_clauseContext() +} + +type On_object_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext + mmn IId_expressionContext + o2 IId_expressionContext + p IId_expressionContext +} + +func NewEmptyOn_object_clauseContext() *On_object_clauseContext { + var p = new(On_object_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_object_clause + return p +} + +func InitEmptyOn_object_clauseContext(p *On_object_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_object_clause +} + +func (*On_object_clauseContext) IsOn_object_clauseContext() {} + +func NewOn_object_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_object_clauseContext { + var p = new(On_object_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_object_clause + + return p +} + +func (s *On_object_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_object_clauseContext) GetO() IId_expressionContext { return s.o } + +func (s *On_object_clauseContext) GetMmn() IId_expressionContext { return s.mmn } + +func (s *On_object_clauseContext) GetO2() IId_expressionContext { return s.o2 } + +func (s *On_object_clauseContext) GetP() IId_expressionContext { return s.p } + +func (s *On_object_clauseContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *On_object_clauseContext) SetMmn(v IId_expressionContext) { s.mmn = v } + +func (s *On_object_clauseContext) SetO2(v IId_expressionContext) { s.o2 = v } + +func (s *On_object_clauseContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *On_object_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *On_object_clauseContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *On_object_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *On_object_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *On_object_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *On_object_clauseContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *On_object_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *On_object_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *On_object_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *On_object_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *On_object_clauseContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *On_object_clauseContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *On_object_clauseContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *On_object_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *On_object_clauseContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *On_object_clauseContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *On_object_clauseContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *On_object_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *On_object_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_object_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_object_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_object_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_object_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_object_clause(s) + } +} + +func (s *On_object_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_object_clause(s) + } +} + +func (p *PlSqlParser) On_object_clause() (localctx IOn_object_clauseContext) { + localctx = NewOn_object_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, PlSqlParserRULE_on_object_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8430) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) { + case 1: + p.SetState(8434) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 916, p.GetParserRuleContext()) == 1 { + { + p.SetState(8431) + p.Schema_name() + } + { + p.SetState(8432) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8436) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).o = _x + } + + case 2: + { + p.SetState(8437) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8438) + p.Id_expression() + } + p.SetState(8443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8439) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8440) + p.Id_expression() + } + + p.SetState(8445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(8446) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8447) + p.Directory_name() + } + + case 4: + { + p.SetState(8448) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8449) + p.Edition_name() + } + + case 5: + { + p.SetState(8450) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8451) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8455) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) == 1 { + { + p.SetState(8452) + p.Schema_name() + } + { + p.SetState(8453) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8457) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).mmn = _x + } + + case 6: + { + p.SetState(8458) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8459) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8463) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 919, p.GetParserRuleContext()) == 1 { + { + p.SetState(8460) + p.Schema_name() + } + { + p.SetState(8461) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8465) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).o2 = _x + } + + case 7: + { + p.SetState(8466) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8467) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8468) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8472) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 920, p.GetParserRuleContext()) == 1 { + { + p.SetState(8469) + p.Schema_name() + } + { + p.SetState(8470) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8474) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).p = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_roles_from_programsContext is an interface to support dynamic dispatch. +type IRevoke_roles_from_programsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllProgram_unit() []IProgram_unitContext + Program_unit(i int) IProgram_unitContext + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevoke_roles_from_programsContext differentiates from other interfaces. + IsRevoke_roles_from_programsContext() +} + +type Revoke_roles_from_programsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_roles_from_programsContext() *Revoke_roles_from_programsContext { + var p = new(Revoke_roles_from_programsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs + return p +} + +func InitEmptyRevoke_roles_from_programsContext(p *Revoke_roles_from_programsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs +} + +func (*Revoke_roles_from_programsContext) IsRevoke_roles_from_programsContext() {} + +func NewRevoke_roles_from_programsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_roles_from_programsContext { + var p = new(Revoke_roles_from_programsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs + + return p +} + +func (s *Revoke_roles_from_programsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_roles_from_programsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_roles_from_programsContext) AllProgram_unit() []IProgram_unitContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProgram_unitContext); ok { + len++ + } + } + + tst := make([]IProgram_unitContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProgram_unitContext); ok { + tst[i] = t.(IProgram_unitContext) + i++ + } + } + + return tst +} + +func (s *Revoke_roles_from_programsContext) Program_unit(i int) IProgram_unitContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProgram_unitContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProgram_unitContext) +} + +func (s *Revoke_roles_from_programsContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Revoke_roles_from_programsContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Revoke_roles_from_programsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Revoke_roles_from_programsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revoke_roles_from_programsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revoke_roles_from_programsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_roles_from_programsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_roles_from_programsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_roles_from_programs(s) + } +} + +func (s *Revoke_roles_from_programsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_roles_from_programs(s) + } +} + +func (p *PlSqlParser) Revoke_roles_from_programs() (localctx IRevoke_roles_from_programsContext) { + localctx = NewRevoke_roles_from_programsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, PlSqlParserRULE_revoke_roles_from_programs) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(8477) + p.Role_name() + } + p.SetState(8482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8478) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8479) + p.Role_name() + } + + p.SetState(8484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(8485) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8488) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8489) + p.Program_unit() + } + p.SetState(8494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8490) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8491) + p.Program_unit() + } + + p.SetState(8496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProgram_unitContext is an interface to support dynamic dispatch. +type IProgram_unitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsProgram_unitContext differentiates from other interfaces. + IsProgram_unitContext() +} + +type Program_unitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProgram_unitContext() *Program_unitContext { + var p = new(Program_unitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_program_unit + return p +} + +func InitEmptyProgram_unitContext(p *Program_unitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_program_unit +} + +func (*Program_unitContext) IsProgram_unitContext() {} + +func NewProgram_unitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Program_unitContext { + var p = new(Program_unitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_program_unit + + return p +} + +func (s *Program_unitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Program_unitContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Program_unitContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Program_unitContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Program_unitContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Program_unitContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Program_unitContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Program_unitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Program_unitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Program_unitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProgram_unit(s) + } +} + +func (s *Program_unitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProgram_unit(s) + } +} + +func (p *PlSqlParser) Program_unit() (localctx IProgram_unitContext) { + localctx = NewProgram_unitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, PlSqlParserRULE_program_unit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8497) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFUNCTION || _la == PlSqlParserPACKAGE || _la == PlSqlParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 925, p.GetParserRuleContext()) == 1 { + { + p.SetState(8498) + p.Schema_name() + } + { + p.SetState(8499) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8503) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_dimensionContext is an interface to support dynamic dispatch. +type ICreate_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + Identifier() IIdentifierContext + AllLevel_clause() []ILevel_clauseContext + Level_clause(i int) ILevel_clauseContext + AllHierarchy_clause() []IHierarchy_clauseContext + Hierarchy_clause(i int) IHierarchy_clauseContext + AllAttribute_clause() []IAttribute_clauseContext + Attribute_clause(i int) IAttribute_clauseContext + AllExtended_attribute_clause() []IExtended_attribute_clauseContext + Extended_attribute_clause(i int) IExtended_attribute_clauseContext + + // IsCreate_dimensionContext differentiates from other interfaces. + IsCreate_dimensionContext() +} + +type Create_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_dimensionContext() *Create_dimensionContext { + var p = new(Create_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_dimension + return p +} + +func InitEmptyCreate_dimensionContext(p *Create_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_dimension +} + +func (*Create_dimensionContext) IsCreate_dimensionContext() {} + +func NewCreate_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_dimensionContext { + var p = new(Create_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_dimension + + return p +} + +func (s *Create_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_dimensionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Create_dimensionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Create_dimensionContext) AllLevel_clause() []ILevel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_clauseContext); ok { + len++ + } + } + + tst := make([]ILevel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_clauseContext); ok { + tst[i] = t.(ILevel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Level_clause(i int) ILevel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_clauseContext) +} + +func (s *Create_dimensionContext) AllHierarchy_clause() []IHierarchy_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + len++ + } + } + + tst := make([]IHierarchy_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHierarchy_clauseContext); ok { + tst[i] = t.(IHierarchy_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Hierarchy_clause(i int) IHierarchy_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHierarchy_clauseContext) +} + +func (s *Create_dimensionContext) AllAttribute_clause() []IAttribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_clauseContext); ok { + len++ + } + } + + tst := make([]IAttribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_clauseContext); ok { + tst[i] = t.(IAttribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Attribute_clause(i int) IAttribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clauseContext) +} + +func (s *Create_dimensionContext) AllExtended_attribute_clause() []IExtended_attribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + len++ + } + } + + tst := make([]IExtended_attribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtended_attribute_clauseContext); ok { + tst[i] = t.(IExtended_attribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Extended_attribute_clause(i int) IExtended_attribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtended_attribute_clauseContext) +} + +func (s *Create_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_dimension(s) + } +} + +func (s *Create_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_dimension(s) + } +} + +func (p *PlSqlParser) Create_dimension() (localctx ICreate_dimensionContext) { + localctx = NewCreate_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, PlSqlParserRULE_create_dimension) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8505) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8506) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8507) + p.Identifier() + } + p.SetState(8509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEVEL { + { + p.SetState(8508) + p.Level_clause() + } + + p.SetState(8511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserATTRIBUTE || _la == PlSqlParserHIERARCHY { + p.SetState(8516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8513) + p.Hierarchy_clause() + } + + case 2: + { + p.SetState(8514) + p.Attribute_clause() + } + + case 3: + { + p.SetState(8515) + p.Extended_attribute_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_directoryContext is an interface to support dynamic dispatch. +type ICreate_directoryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + AS() antlr.TerminalNode + Directory_path() IDirectory_pathContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_directoryContext differentiates from other interfaces. + IsCreate_directoryContext() +} + +type Create_directoryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_directoryContext() *Create_directoryContext { + var p = new(Create_directoryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_directory + return p +} + +func InitEmptyCreate_directoryContext(p *Create_directoryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_directory +} + +func (*Create_directoryContext) IsCreate_directoryContext() {} + +func NewCreate_directoryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_directoryContext { + var p = new(Create_directoryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_directory + + return p +} + +func (s *Create_directoryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_directoryContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_directoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Create_directoryContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Create_directoryContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_directoryContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Create_directoryContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_directoryContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_directoryContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_directoryContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_directoryContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_directoryContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_directoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_directoryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_directoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_directory(s) + } +} + +func (s *Create_directoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_directory(s) + } +} + +func (p *PlSqlParser) Create_directory() (localctx ICreate_directoryContext) { + localctx = NewCreate_directoryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, PlSqlParserRULE_create_directory) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8520) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8521) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8522) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8525) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8526) + p.Directory_name() + } + p.SetState(8530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8527) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8528) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8529) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8532) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8533) + p.Directory_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDirectory_nameContext is an interface to support dynamic dispatch. +type IDirectory_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDirectory_nameContext differentiates from other interfaces. + IsDirectory_nameContext() +} + +type Directory_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_nameContext() *Directory_nameContext { + var p = new(Directory_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_name + return p +} + +func InitEmptyDirectory_nameContext(p *Directory_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_name +} + +func (*Directory_nameContext) IsDirectory_nameContext() {} + +func NewDirectory_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_nameContext { + var p = new(Directory_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_directory_name + + return p +} + +func (s *Directory_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Directory_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDirectory_name(s) + } +} + +func (s *Directory_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDirectory_name(s) + } +} + +func (p *PlSqlParser) Directory_name() (localctx IDirectory_nameContext) { + localctx = NewDirectory_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, PlSqlParserRULE_directory_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8535) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDirectory_pathContext is an interface to support dynamic dispatch. +type IDirectory_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsDirectory_pathContext differentiates from other interfaces. + IsDirectory_pathContext() +} + +type Directory_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_pathContext() *Directory_pathContext { + var p = new(Directory_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_path + return p +} + +func InitEmptyDirectory_pathContext(p *Directory_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_path +} + +func (*Directory_pathContext) IsDirectory_pathContext() {} + +func NewDirectory_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_pathContext { + var p = new(Directory_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_directory_path + + return p +} + +func (s *Directory_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_pathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Directory_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDirectory_path(s) + } +} + +func (s *Directory_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDirectory_path(s) + } +} + +func (p *PlSqlParser) Directory_path() (localctx IDirectory_pathContext) { + localctx = NewDirectory_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, PlSqlParserRULE_directory_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8537) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_inmemory_join_groupContext is an interface to support dynamic dispatch. +type ICreate_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_inmemory_join_groupContext differentiates from other interfaces. + IsCreate_inmemory_join_groupContext() +} + +type Create_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext + t IId_expressionContext + c IId_expressionContext +} + +func NewEmptyCreate_inmemory_join_groupContext() *Create_inmemory_join_groupContext { + var p = new(Create_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group + return p +} + +func InitEmptyCreate_inmemory_join_groupContext(p *Create_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group +} + +func (*Create_inmemory_join_groupContext) IsCreate_inmemory_join_groupContext() {} + +func NewCreate_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_inmemory_join_groupContext { + var p = new(Create_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group + + return p +} + +func (s *Create_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Create_inmemory_join_groupContext) GetT() IId_expressionContext { return s.t } + +func (s *Create_inmemory_join_groupContext) GetC() IId_expressionContext { return s.c } + +func (s *Create_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Create_inmemory_join_groupContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Create_inmemory_join_groupContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Create_inmemory_join_groupContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Create_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Create_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Create_inmemory_join_groupContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_inmemory_join_groupContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_inmemory_join_groupContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_inmemory_join_groupContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_inmemory_join_groupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_inmemory_join_groupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_inmemory_join_groupContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_inmemory_join_groupContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_inmemory_join_groupContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Create_inmemory_join_groupContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Create_inmemory_join_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_inmemory_join_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_inmemory_join_group(s) + } +} + +func (s *Create_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_inmemory_join_group(s) + } +} + +func (p *PlSqlParser) Create_inmemory_join_group() (localctx ICreate_inmemory_join_groupContext) { + localctx = NewCreate_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, PlSqlParserRULE_create_inmemory_join_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8539) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8540) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8541) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8542) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8546) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 931, p.GetParserRuleContext()) == 1 { + { + p.SetState(8543) + p.Schema_name() + } + { + p.SetState(8544) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8548) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).jg = _x + } + { + p.SetState(8549) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8553) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 932, p.GetParserRuleContext()) == 1 { + { + p.SetState(8550) + p.Schema_name() + } + { + p.SetState(8551) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8555) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).t = _x + } + { + p.SetState(8556) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8557) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).c = _x + } + { + p.SetState(8558) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(8559) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8563) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 933, p.GetParserRuleContext()) == 1 { + { + p.SetState(8560) + p.Schema_name() + } + { + p.SetState(8561) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8565) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).t = _x + } + { + p.SetState(8566) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8567) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).c = _x + } + { + p.SetState(8568) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8574) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_hierarchyContext is an interface to support dynamic dispatch. +type IDrop_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHn returns the hn rule contexts. + GetHn() IId_expressionContext + + // SetHn sets the hn rule contexts. + SetHn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_hierarchyContext differentiates from other interfaces. + IsDrop_hierarchyContext() +} + +type Drop_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hn IId_expressionContext +} + +func NewEmptyDrop_hierarchyContext() *Drop_hierarchyContext { + var p = new(Drop_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_hierarchy + return p +} + +func InitEmptyDrop_hierarchyContext(p *Drop_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_hierarchy +} + +func (*Drop_hierarchyContext) IsDrop_hierarchyContext() {} + +func NewDrop_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_hierarchyContext { + var p = new(Drop_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_hierarchy + + return p +} + +func (s *Drop_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_hierarchyContext) GetHn() IId_expressionContext { return s.hn } + +func (s *Drop_hierarchyContext) SetHn(v IId_expressionContext) { s.hn = v } + +func (s *Drop_hierarchyContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Drop_hierarchyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_hierarchyContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_hierarchy(s) + } +} + +func (s *Drop_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_hierarchy(s) + } +} + +func (p *PlSqlParser) Drop_hierarchy() (localctx IDrop_hierarchyContext) { + localctx = NewDrop_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, PlSqlParserRULE_drop_hierarchy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8576) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8577) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 935, p.GetParserRuleContext()) == 1 { + { + p.SetState(8578) + p.Schema_name() + } + { + p.SetState(8579) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8583) + + var _x = p.Id_expression() + + localctx.(*Drop_hierarchyContext).hn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_libraryContext is an interface to support dynamic dispatch. +type IAlter_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Library_name() ILibrary_nameContext + COMPILE() antlr.TerminalNode + Library_editionable() ILibrary_editionableContext + Library_debug() ILibrary_debugContext + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_libraryContext differentiates from other interfaces. + IsAlter_libraryContext() +} + +type Alter_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_libraryContext() *Alter_libraryContext { + var p = new(Alter_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_library + return p +} + +func InitEmptyAlter_libraryContext(p *Alter_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_library +} + +func (*Alter_libraryContext) IsAlter_libraryContext() {} + +func NewAlter_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_libraryContext { + var p = new(Alter_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_library + + return p +} + +func (s *Alter_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_libraryContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Alter_libraryContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Alter_libraryContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_libraryContext) Library_editionable() ILibrary_editionableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_editionableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_editionableContext) +} + +func (s *Alter_libraryContext) Library_debug() ILibrary_debugContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_debugContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_debugContext) +} + +func (s *Alter_libraryContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_libraryContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_libraryContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_libraryContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_library(s) + } +} + +func (s *Alter_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_library(s) + } +} + +func (p *PlSqlParser) Alter_library() (localctx IAlter_libraryContext) { + localctx = NewAlter_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 794, PlSqlParserRULE_alter_library) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8585) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8586) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8587) + p.Library_name() + } + p.SetState(8603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 939, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8588) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 936, p.GetParserRuleContext()) == 1 { + { + p.SetState(8589) + p.Library_debug() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 937, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8592) + p.Compiler_parameters_clause() + } + + } + p.SetState(8597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 937, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(8600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(8598) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8599) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + { + p.SetState(8602) + p.Library_editionable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_javaContext is an interface to support dynamic dispatch. +type IDrop_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + JAVA() antlr.TerminalNode + Id_expression() IId_expressionContext + SOURCE() antlr.TerminalNode + CLASS() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_javaContext differentiates from other interfaces. + IsDrop_javaContext() +} + +type Drop_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_javaContext() *Drop_javaContext { + var p = new(Drop_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_java + return p +} + +func InitEmptyDrop_javaContext(p *Drop_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_java +} + +func (*Drop_javaContext) IsDrop_javaContext() {} + +func NewDrop_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_javaContext { + var p = new(Drop_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_java + + return p +} + +func (s *Drop_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_javaContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Drop_javaContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Drop_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Drop_javaContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Drop_javaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_java(s) + } +} + +func (s *Drop_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_java(s) + } +} + +func (p *PlSqlParser) Drop_java() (localctx IDrop_javaContext) { + localctx = NewDrop_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, PlSqlParserRULE_drop_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8605) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8606) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8607) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8611) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 940, p.GetParserRuleContext()) == 1 { + { + p.SetState(8608) + p.Schema_name() + } + { + p.SetState(8609) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8613) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_libraryContext is an interface to support dynamic dispatch. +type IDrop_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Library_name() ILibrary_nameContext + + // IsDrop_libraryContext differentiates from other interfaces. + IsDrop_libraryContext() +} + +type Drop_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_libraryContext() *Drop_libraryContext { + var p = new(Drop_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_library + return p +} + +func InitEmptyDrop_libraryContext(p *Drop_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_library +} + +func (*Drop_libraryContext) IsDrop_libraryContext() {} + +func NewDrop_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_libraryContext { + var p = new(Drop_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_library + + return p +} + +func (s *Drop_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_libraryContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Drop_libraryContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Drop_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_library(s) + } +} + +func (s *Drop_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_library(s) + } +} + +func (p *PlSqlParser) Drop_library() (localctx IDrop_libraryContext) { + localctx = NewDrop_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, PlSqlParserRULE_drop_library) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8615) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8616) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8617) + p.Library_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_javaContext is an interface to support dynamic dispatch. +type ICreate_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPn returns the pn rule contexts. + GetPn() IId_expressionContext + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // SetPn sets the pn rule contexts. + SetPn(IId_expressionContext) + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + JAVA() antlr.TerminalNode + NAMED() antlr.TerminalNode + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + AS() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AND() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + RESOLVER() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RESOLVE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + BFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Filename() IFilenameContext + Subquery() ISubqueryContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + + // IsCreate_javaContext differentiates from other interfaces. + IsCreate_javaContext() +} + +type Create_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pn IId_expressionContext + sn IId_expressionContext + d IId_expressionContext +} + +func NewEmptyCreate_javaContext() *Create_javaContext { + var p = new(Create_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_java + return p +} + +func InitEmptyCreate_javaContext(p *Create_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_java +} + +func (*Create_javaContext) IsCreate_javaContext() {} + +func NewCreate_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_javaContext { + var p = new(Create_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_java + + return p +} + +func (s *Create_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_javaContext) GetPn() IId_expressionContext { return s.pn } + +func (s *Create_javaContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Create_javaContext) GetD() IId_expressionContext { return s.d } + +func (s *Create_javaContext) SetPn(v IId_expressionContext) { s.pn = v } + +func (s *Create_javaContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Create_javaContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Create_javaContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Create_javaContext) NAMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMED, 0) +} + +func (s *Create_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Create_javaContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_javaContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_javaContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Create_javaContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Create_javaContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_javaContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_javaContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Create_javaContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Create_javaContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Create_javaContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_javaContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_javaContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_javaContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_javaContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_javaContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Create_javaContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_javaContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_javaContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_javaContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_javaContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Create_javaContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Create_javaContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_javaContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_javaContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Create_javaContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_javaContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_javaContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Create_javaContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Create_javaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_javaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Create_javaContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Create_javaContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Create_javaContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *Create_javaContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *Create_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_java(s) + } +} + +func (s *Create_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_java(s) + } +} + +func (p *PlSqlParser) Create_java() (localctx ICreate_javaContext) { + localctx = NewCreate_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, PlSqlParserRULE_create_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8619) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8620) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8621) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(8624) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8625) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserRESOLVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(8629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOFORCE { + { + p.SetState(8628) + p.Match(PlSqlParserNOFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8631) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESOURCE, PlSqlParserSOURCE: + { + p.SetState(8632) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8633) + p.Match(PlSqlParserNAMED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8637) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 944, p.GetParserRuleContext()) == 1 { + { + p.SetState(8634) + p.Schema_name() + } + { + p.SetState(8635) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8639) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).pn = _x + } + + case PlSqlParserCLASS: + { + p.SetState(8640) + p.Match(PlSqlParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSCHEMA { + { + p.SetState(8641) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8642) + p.Id_expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8647) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8648) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8649) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(8653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(8652) + p.Invoker_rights_clause() + } + + } + p.SetState(8672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESOLVER { + { + p.SetState(8655) + p.Match(PlSqlParserRESOLVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8656) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8657) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8658) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8659) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(8662) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).sn = _x + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(8663) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8666) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8671) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUSING: + { + p.SetState(8674) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 953, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8675) + p.Match(PlSqlParserBFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8676) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8677) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).d = _x + } + { + p.SetState(8678) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8679) + p.Filename() + } + { + p.SetState(8680) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8682) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBFILE || _la == PlSqlParserBLOB || _la == PlSqlParserCLOB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8683) + p.Subquery() + } + + case 3: + { + p.SetState(8684) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAS: + { + p.SetState(8687) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8688) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_libraryContext is an interface to support dynamic dispatch. +type ICreate_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Plsql_library_source() IPlsql_library_sourceContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsCreate_libraryContext differentiates from other interfaces. + IsCreate_libraryContext() +} + +type Create_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_libraryContext() *Create_libraryContext { + var p = new(Create_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_library + return p +} + +func InitEmptyCreate_libraryContext(p *Create_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_library +} + +func (*Create_libraryContext) IsCreate_libraryContext() {} + +func NewCreate_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_libraryContext { + var p = new(Create_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_library + + return p +} + +func (s *Create_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_libraryContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Create_libraryContext) Plsql_library_source() IPlsql_library_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_library_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_library_sourceContext) +} + +func (s *Create_libraryContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_libraryContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_libraryContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_libraryContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_library(s) + } +} + +func (s *Create_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_library(s) + } +} + +func (p *PlSqlParser) Create_library() (localctx ICreate_libraryContext) { + localctx = NewCreate_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, PlSqlParserRULE_create_library) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8691) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8692) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8693) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(8696) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8699) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8700) + p.Plsql_library_source() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsql_library_sourceContext is an interface to support dynamic dispatch. +type IPlsql_library_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Library_name() ILibrary_nameContext + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + IN() antlr.TerminalNode + Directory_name() IDirectory_nameContext + AGENT() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + Credential_name() ICredential_nameContext + + // IsPlsql_library_sourceContext differentiates from other interfaces. + IsPlsql_library_sourceContext() +} + +type Plsql_library_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsql_library_sourceContext() *Plsql_library_sourceContext { + var p = new(Plsql_library_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_plsql_library_source + return p +} + +func InitEmptyPlsql_library_sourceContext(p *Plsql_library_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_plsql_library_source +} + +func (*Plsql_library_sourceContext) IsPlsql_library_sourceContext() {} + +func NewPlsql_library_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_library_sourceContext { + var p = new(Plsql_library_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_plsql_library_source + + return p +} + +func (s *Plsql_library_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Plsql_library_sourceContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Plsql_library_sourceContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *Plsql_library_sourceContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Plsql_library_sourceContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Plsql_library_sourceContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Plsql_library_sourceContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Plsql_library_sourceContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Plsql_library_sourceContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *Plsql_library_sourceContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREDENTIAL, 0) +} + +func (s *Plsql_library_sourceContext) Credential_name() ICredential_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICredential_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICredential_nameContext) +} + +func (s *Plsql_library_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Plsql_library_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Plsql_library_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPlsql_library_source(s) + } +} + +func (s *Plsql_library_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPlsql_library_source(s) + } +} + +func (p *PlSqlParser) Plsql_library_source() (localctx IPlsql_library_sourceContext) { + localctx = NewPlsql_library_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, PlSqlParserRULE_plsql_library_source) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8702) + p.Library_name() + } + { + p.SetState(8703) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8704) + p.Quoted_string() + } + p.SetState(8707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIN { + { + p.SetState(8705) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8706) + p.Directory_name() + } + + } + p.SetState(8711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAGENT { + { + p.SetState(8709) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8710) + p.Quoted_string() + } + + } + p.SetState(8715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCREDENTIAL { + { + p.SetState(8713) + p.Match(PlSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8714) + p.Credential_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICredential_nameContext is an interface to support dynamic dispatch. +type ICredential_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsCredential_nameContext differentiates from other interfaces. + IsCredential_nameContext() +} + +type Credential_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCredential_nameContext() *Credential_nameContext { + var p = new(Credential_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_credential_name + return p +} + +func InitEmptyCredential_nameContext(p *Credential_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_credential_name +} + +func (*Credential_nameContext) IsCredential_nameContext() {} + +func NewCredential_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Credential_nameContext { + var p = new(Credential_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_credential_name + + return p +} + +func (s *Credential_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Credential_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Credential_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Credential_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Credential_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Credential_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Credential_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCredential_name(s) + } +} + +func (s *Credential_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCredential_name(s) + } +} + +func (p *PlSqlParser) Credential_name() (localctx ICredential_nameContext) { + localctx = NewCredential_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, PlSqlParserRULE_credential_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(8720) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 960, p.GetParserRuleContext()) == 1 { + { + p.SetState(8717) + p.Id_expression() + } + { + p.SetState(8718) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8722) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILibrary_editionableContext is an interface to support dynamic dispatch. +type ILibrary_editionableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsLibrary_editionableContext differentiates from other interfaces. + IsLibrary_editionableContext() +} + +type Library_editionableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_editionableContext() *Library_editionableContext { + var p = new(Library_editionableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_editionable + return p +} + +func InitEmptyLibrary_editionableContext(p *Library_editionableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_editionable +} + +func (*Library_editionableContext) IsLibrary_editionableContext() {} + +func NewLibrary_editionableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_editionableContext { + var p = new(Library_editionableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_editionable + + return p +} + +func (s *Library_editionableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_editionableContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Library_editionableContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Library_editionableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_editionableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_editionableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_editionable(s) + } +} + +func (s *Library_editionableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_editionable(s) + } +} + +func (p *PlSqlParser) Library_editionable() (localctx ILibrary_editionableContext) { + localctx = NewLibrary_editionableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, PlSqlParserRULE_library_editionable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8724) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8725) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILibrary_debugContext is an interface to support dynamic dispatch. +type ILibrary_debugContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEBUG() antlr.TerminalNode + + // IsLibrary_debugContext differentiates from other interfaces. + IsLibrary_debugContext() +} + +type Library_debugContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_debugContext() *Library_debugContext { + var p = new(Library_debugContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_debug + return p +} + +func InitEmptyLibrary_debugContext(p *Library_debugContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_debug +} + +func (*Library_debugContext) IsLibrary_debugContext() {} + +func NewLibrary_debugContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_debugContext { + var p = new(Library_debugContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_debug + + return p +} + +func (s *Library_debugContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_debugContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Library_debugContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_debugContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_debugContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_debug(s) + } +} + +func (s *Library_debugContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_debug(s) + } +} + +func (p *PlSqlParser) Library_debug() (localctx ILibrary_debugContext) { + localctx = NewLibrary_debugContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, PlSqlParserRULE_library_debug) + p.EnterOuterAlt(localctx, 1) + p.SetState(8727) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8728) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompiler_parameters_clauseContext is an interface to support dynamic dispatch. +type ICompiler_parameters_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + EQUALS_OP() antlr.TerminalNode + Parameter_value() IParameter_valueContext + + // IsCompiler_parameters_clauseContext differentiates from other interfaces. + IsCompiler_parameters_clauseContext() +} + +type Compiler_parameters_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompiler_parameters_clauseContext() *Compiler_parameters_clauseContext { + var p = new(Compiler_parameters_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause + return p +} + +func InitEmptyCompiler_parameters_clauseContext(p *Compiler_parameters_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause +} + +func (*Compiler_parameters_clauseContext) IsCompiler_parameters_clauseContext() {} + +func NewCompiler_parameters_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compiler_parameters_clauseContext { + var p = new(Compiler_parameters_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause + + return p +} + +func (s *Compiler_parameters_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compiler_parameters_clauseContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Compiler_parameters_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Compiler_parameters_clauseContext) Parameter_value() IParameter_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_valueContext) +} + +func (s *Compiler_parameters_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compiler_parameters_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compiler_parameters_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompiler_parameters_clause(s) + } +} + +func (s *Compiler_parameters_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompiler_parameters_clause(s) + } +} + +func (p *PlSqlParser) Compiler_parameters_clause() (localctx ICompiler_parameters_clauseContext) { + localctx = NewCompiler_parameters_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, PlSqlParserRULE_compiler_parameters_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8730) + p.Parameter_name() + } + { + p.SetState(8731) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8732) + p.Parameter_value() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_valueContext is an interface to support dynamic dispatch. +type IParameter_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + CHAR_STRING() antlr.TerminalNode + + // IsParameter_valueContext differentiates from other interfaces. + IsParameter_valueContext() +} + +type Parameter_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_valueContext() *Parameter_valueContext { + var p = new(Parameter_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_value + return p +} + +func InitEmptyParameter_valueContext(p *Parameter_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_value +} + +func (*Parameter_valueContext) IsParameter_valueContext() {} + +func NewParameter_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_valueContext { + var p = new(Parameter_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_value + + return p +} + +func (s *Parameter_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_valueContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Parameter_valueContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Parameter_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_value(s) + } +} + +func (s *Parameter_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_value(s) + } +} + +func (p *PlSqlParser) Parameter_value() (localctx IParameter_valueContext) { + localctx = NewParameter_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, PlSqlParserRULE_parameter_value) + p.SetState(8736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8734) + p.Regular_id() + } + + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8735) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILibrary_nameContext is an interface to support dynamic dispatch. +type ILibrary_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + PERIOD() antlr.TerminalNode + + // IsLibrary_nameContext differentiates from other interfaces. + IsLibrary_nameContext() +} + +type Library_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_nameContext() *Library_nameContext { + var p = new(Library_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_name + return p +} + +func InitEmptyLibrary_nameContext(p *Library_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_name +} + +func (*Library_nameContext) IsLibrary_nameContext() {} + +func NewLibrary_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_nameContext { + var p = new(Library_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_name + + return p +} + +func (s *Library_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_nameContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Library_nameContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Library_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Library_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_name(s) + } +} + +func (s *Library_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_name(s) + } +} + +func (p *PlSqlParser) Library_name() (localctx ILibrary_nameContext) { + localctx = NewLibrary_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, PlSqlParserRULE_library_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(8741) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 962, p.GetParserRuleContext()) == 1 { + { + p.SetState(8738) + p.Regular_id() + } + { + p.SetState(8739) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8743) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_dimensionContext is an interface to support dynamic dispatch. +type IAlter_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + COMPILE() antlr.TerminalNode + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + AllLevel_clause() []ILevel_clauseContext + Level_clause(i int) ILevel_clauseContext + AllHierarchy_clause() []IHierarchy_clauseContext + Hierarchy_clause(i int) IHierarchy_clauseContext + AllAttribute_clause() []IAttribute_clauseContext + Attribute_clause(i int) IAttribute_clauseContext + AllExtended_attribute_clause() []IExtended_attribute_clauseContext + Extended_attribute_clause(i int) IExtended_attribute_clauseContext + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + AllHIERARCHY() []antlr.TerminalNode + HIERARCHY(i int) antlr.TerminalNode + AllATTRIBUTE() []antlr.TerminalNode + ATTRIBUTE(i int) antlr.TerminalNode + AllRESTRICT() []antlr.TerminalNode + RESTRICT(i int) antlr.TerminalNode + AllCASCADE() []antlr.TerminalNode + CASCADE(i int) antlr.TerminalNode + AllCOLUMN() []antlr.TerminalNode + COLUMN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_dimensionContext differentiates from other interfaces. + IsAlter_dimensionContext() +} + +type Alter_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_dimensionContext() *Alter_dimensionContext { + var p = new(Alter_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_dimension + return p +} + +func InitEmptyAlter_dimensionContext(p *Alter_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_dimension +} + +func (*Alter_dimensionContext) IsAlter_dimensionContext() {} + +func NewAlter_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_dimensionContext { + var p = new(Alter_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_dimension + + return p +} + +func (s *Alter_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_dimensionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Alter_dimensionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Alter_dimensionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_dimensionContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserADD) +} + +func (s *Alter_dimensionContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, i) +} + +func (s *Alter_dimensionContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Alter_dimensionContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Alter_dimensionContext) AllLevel_clause() []ILevel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_clauseContext); ok { + len++ + } + } + + tst := make([]ILevel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_clauseContext); ok { + tst[i] = t.(ILevel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Level_clause(i int) ILevel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_clauseContext) +} + +func (s *Alter_dimensionContext) AllHierarchy_clause() []IHierarchy_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + len++ + } + } + + tst := make([]IHierarchy_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHierarchy_clauseContext); ok { + tst[i] = t.(IHierarchy_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Hierarchy_clause(i int) IHierarchy_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHierarchy_clauseContext) +} + +func (s *Alter_dimensionContext) AllAttribute_clause() []IAttribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_clauseContext); ok { + len++ + } + } + + tst := make([]IAttribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_clauseContext); ok { + tst[i] = t.(IAttribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Attribute_clause(i int) IAttribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clauseContext) +} + +func (s *Alter_dimensionContext) AllExtended_attribute_clause() []IExtended_attribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + len++ + } + } + + tst := make([]IExtended_attribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtended_attribute_clauseContext); ok { + tst[i] = t.(IExtended_attribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Extended_attribute_clause(i int) IExtended_attribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtended_attribute_clauseContext) +} + +func (s *Alter_dimensionContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Alter_dimensionContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Alter_dimensionContext) AllHIERARCHY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHIERARCHY) +} + +func (s *Alter_dimensionContext) HIERARCHY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, i) +} + +func (s *Alter_dimensionContext) AllATTRIBUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserATTRIBUTE) +} + +func (s *Alter_dimensionContext) ATTRIBUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, i) +} + +func (s *Alter_dimensionContext) AllRESTRICT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRESTRICT) +} + +func (s *Alter_dimensionContext) RESTRICT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT, i) +} + +func (s *Alter_dimensionContext) AllCASCADE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASCADE) +} + +func (s *Alter_dimensionContext) CASCADE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, i) +} + +func (s *Alter_dimensionContext) AllCOLUMN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLUMN) +} + +func (s *Alter_dimensionContext) COLUMN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, i) +} + +func (s *Alter_dimensionContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_dimensionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_dimensionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_dimension(s) + } +} + +func (s *Alter_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_dimension(s) + } +} + +func (p *PlSqlParser) Alter_dimension() (localctx IAlter_dimensionContext) { + localctx = NewAlter_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, PlSqlParserRULE_alter_dimension) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8745) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8746) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8747) + p.Identifier() + } + p.SetState(8792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.SetState(8755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserADD { + { + p.SetState(8748) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 963, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8749) + p.Level_clause() + } + + case 2: + { + p.SetState(8750) + p.Hierarchy_clause() + } + + case 3: + { + p.SetState(8751) + p.Attribute_clause() + } + + case 4: + { + p.SetState(8752) + p.Extended_attribute_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.SetState(8787) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDROP { + { + p.SetState(8759) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEVEL: + { + p.SetState(8760) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8761) + p.Identifier() + } + p.SetState(8763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE || _la == PlSqlParserRESTRICT { + { + p.SetState(8762) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCASCADE || _la == PlSqlParserRESTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserHIERARCHY: + { + p.SetState(8765) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8766) + p.Identifier() + } + + case PlSqlParserATTRIBUTE: + { + p.SetState(8767) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8768) + p.Identifier() + } + p.SetState(8783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEVEL { + { + p.SetState(8769) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8770) + p.Identifier() + } + p.SetState(8781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN { + { + p.SetState(8771) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8772) + p.Column_name() + } + p.SetState(8778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8773) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8774) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8775) + p.Column_name() + } + + p.SetState(8780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserCOMPILE: + { + p.SetState(8791) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_clauseContext is an interface to support dynamic dispatch. +type ILevel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEVEL() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + AllTable_name() []ITable_nameContext + Table_name(i int) ITable_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SKIP_() antlr.TerminalNode + WHEN() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLevel_clauseContext differentiates from other interfaces. + IsLevel_clauseContext() +} + +type Level_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLevel_clauseContext() *Level_clauseContext { + var p = new(Level_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_clause + return p +} + +func InitEmptyLevel_clauseContext(p *Level_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_clause +} + +func (*Level_clauseContext) IsLevel_clauseContext() {} + +func NewLevel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_clauseContext { + var p = new(Level_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_clause + + return p +} + +func (s *Level_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_clauseContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Level_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Level_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Level_clauseContext) AllTable_name() []ITable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_nameContext); ok { + len++ + } + } + + tst := make([]ITable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_nameContext); ok { + tst[i] = t.(ITable_nameContext) + i++ + } + } + + return tst +} + +func (s *Level_clauseContext) Table_name(i int) ITable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Level_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Level_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Level_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Level_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Level_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Level_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Level_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Level_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Level_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Level_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_clause(s) + } +} + +func (s *Level_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_clause(s) + } +} + +func (p *PlSqlParser) Level_clause() (localctx ILevel_clauseContext) { + localctx = NewLevel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, PlSqlParserRULE_level_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8794) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8795) + p.Identifier() + } + { + p.SetState(8796) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(8797) + p.Table_name() + } + { + p.SetState(8798) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8799) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(8801) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8802) + p.Table_name() + } + { + p.SetState(8803) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8804) + p.Column_name() + } + p.SetState(8812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8805) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8806) + p.Table_name() + } + { + p.SetState(8807) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8808) + p.Column_name() + } + + p.SetState(8814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8815) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSKIP_ { + { + p.SetState(8819) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8820) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8821) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchy_clauseContext is an interface to support dynamic dispatch. +type IHierarchy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HIERARCHY() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCHILD() []antlr.TerminalNode + CHILD(i int) antlr.TerminalNode + AllOF() []antlr.TerminalNode + OF(i int) antlr.TerminalNode + Dimension_join_clause() IDimension_join_clauseContext + + // IsHierarchy_clauseContext differentiates from other interfaces. + IsHierarchy_clauseContext() +} + +type Hierarchy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHierarchy_clauseContext() *Hierarchy_clauseContext { + var p = new(Hierarchy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchy_clause + return p +} + +func InitEmptyHierarchy_clauseContext(p *Hierarchy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchy_clause +} + +func (*Hierarchy_clauseContext) IsHierarchy_clauseContext() {} + +func NewHierarchy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchy_clauseContext { + var p = new(Hierarchy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hierarchy_clause + + return p +} + +func (s *Hierarchy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchy_clauseContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Hierarchy_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Hierarchy_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Hierarchy_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hierarchy_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hierarchy_clauseContext) AllCHILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHILD) +} + +func (s *Hierarchy_clauseContext) CHILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, i) +} + +func (s *Hierarchy_clauseContext) AllOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOF) +} + +func (s *Hierarchy_clauseContext) OF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, i) +} + +func (s *Hierarchy_clauseContext) Dimension_join_clause() IDimension_join_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDimension_join_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDimension_join_clauseContext) +} + +func (s *Hierarchy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHierarchy_clause(s) + } +} + +func (s *Hierarchy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHierarchy_clause(s) + } +} + +func (p *PlSqlParser) Hierarchy_clause() (localctx IHierarchy_clauseContext) { + localctx = NewHierarchy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 822, PlSqlParserRULE_hierarchy_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8824) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8825) + p.Identifier() + } + { + p.SetState(8826) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8827) + p.Identifier() + } + p.SetState(8831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHILD { + { + p.SetState(8828) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8829) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8830) + p.Identifier() + } + + p.SetState(8833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserJOIN { + { + p.SetState(8835) + p.Dimension_join_clause() + } + + } + { + p.SetState(8838) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDimension_join_clauseContext is an interface to support dynamic dispatch. +type IDimension_join_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJOIN() []antlr.TerminalNode + JOIN(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + AllREFERENCES() []antlr.TerminalNode + REFERENCES(i int) antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsDimension_join_clauseContext differentiates from other interfaces. + IsDimension_join_clauseContext() +} + +type Dimension_join_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDimension_join_clauseContext() *Dimension_join_clauseContext { + var p = new(Dimension_join_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dimension_join_clause + return p +} + +func InitEmptyDimension_join_clauseContext(p *Dimension_join_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dimension_join_clause +} + +func (*Dimension_join_clauseContext) IsDimension_join_clauseContext() {} + +func NewDimension_join_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dimension_join_clauseContext { + var p = new(Dimension_join_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dimension_join_clause + + return p +} + +func (s *Dimension_join_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dimension_join_clauseContext) AllJOIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserJOIN) +} + +func (s *Dimension_join_clauseContext) JOIN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, i) +} + +func (s *Dimension_join_clauseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Dimension_join_clauseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Dimension_join_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Dimension_join_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Dimension_join_clauseContext) AllREFERENCES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREFERENCES) +} + +func (s *Dimension_join_clauseContext) REFERENCES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, i) +} + +func (s *Dimension_join_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Dimension_join_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dimension_join_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dimension_join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dimension_join_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDimension_join_clause(s) + } +} + +func (s *Dimension_join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDimension_join_clause(s) + } +} + +func (p *PlSqlParser) Dimension_join_clause() (localctx IDimension_join_clauseContext) { + localctx = NewDimension_join_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 824, PlSqlParserRULE_dimension_join_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserJOIN { + { + p.SetState(8840) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8841) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8842) + p.Column_one_or_more_sub_clause() + } + { + p.SetState(8843) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8844) + p.Identifier() + } + + p.SetState(8848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttribute_clauseContext is an interface to support dynamic dispatch. +type IAttribute_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllATTRIBUTE() []antlr.TerminalNode + ATTRIBUTE(i int) antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllDETERMINES() []antlr.TerminalNode + DETERMINES(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + + // IsAttribute_clauseContext differentiates from other interfaces. + IsAttribute_clauseContext() +} + +type Attribute_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_clauseContext() *Attribute_clauseContext { + var p = new(Attribute_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clause + return p +} + +func InitEmptyAttribute_clauseContext(p *Attribute_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clause +} + +func (*Attribute_clauseContext) IsAttribute_clauseContext() {} + +func NewAttribute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_clauseContext { + var p = new(Attribute_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_clause + + return p +} + +func (s *Attribute_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_clauseContext) AllATTRIBUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserATTRIBUTE) +} + +func (s *Attribute_clauseContext) ATTRIBUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, i) +} + +func (s *Attribute_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Attribute_clauseContext) AllDETERMINES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINES) +} + +func (s *Attribute_clauseContext) DETERMINES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, i) +} + +func (s *Attribute_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Attribute_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_clause(s) + } +} + +func (s *Attribute_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_clause(s) + } +} + +func (p *PlSqlParser) Attribute_clause() (localctx IAttribute_clauseContext) { + localctx = NewAttribute_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, PlSqlParserRULE_attribute_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8850) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8851) + p.Identifier() + } + { + p.SetState(8852) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8853) + p.Column_one_or_more_sub_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8857) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 978, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtended_attribute_clauseContext is an interface to support dynamic dispatch. +type IExtended_attribute_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTE() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + AllDETERMINES() []antlr.TerminalNode + DETERMINES(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + + // IsExtended_attribute_clauseContext differentiates from other interfaces. + IsExtended_attribute_clauseContext() +} + +type Extended_attribute_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtended_attribute_clauseContext() *Extended_attribute_clauseContext { + var p = new(Extended_attribute_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause + return p +} + +func InitEmptyExtended_attribute_clauseContext(p *Extended_attribute_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause +} + +func (*Extended_attribute_clauseContext) IsExtended_attribute_clauseContext() {} + +func NewExtended_attribute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extended_attribute_clauseContext { + var p = new(Extended_attribute_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause + + return p +} + +func (s *Extended_attribute_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extended_attribute_clauseContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Extended_attribute_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Extended_attribute_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Extended_attribute_clauseContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Extended_attribute_clauseContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Extended_attribute_clauseContext) AllDETERMINES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINES) +} + +func (s *Extended_attribute_clauseContext) DETERMINES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, i) +} + +func (s *Extended_attribute_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Extended_attribute_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Extended_attribute_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extended_attribute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extended_attribute_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExtended_attribute_clause(s) + } +} + +func (s *Extended_attribute_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExtended_attribute_clause(s) + } +} + +func (p *PlSqlParser) Extended_attribute_clause() (localctx IExtended_attribute_clauseContext) { + localctx = NewExtended_attribute_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, PlSqlParserRULE_extended_attribute_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8859) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8860) + p.Identifier() + } + p.SetState(8866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEVEL { + { + p.SetState(8861) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8862) + p.Identifier() + } + { + p.SetState(8863) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8864) + p.Column_one_or_more_sub_clause() + } + + p.SetState(8868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_one_or_more_sub_clauseContext is an interface to support dynamic dispatch. +type IColumn_one_or_more_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_one_or_more_sub_clauseContext differentiates from other interfaces. + IsColumn_one_or_more_sub_clauseContext() +} + +type Column_one_or_more_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_one_or_more_sub_clauseContext() *Column_one_or_more_sub_clauseContext { + var p = new(Column_one_or_more_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause + return p +} + +func InitEmptyColumn_one_or_more_sub_clauseContext(p *Column_one_or_more_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause +} + +func (*Column_one_or_more_sub_clauseContext) IsColumn_one_or_more_sub_clauseContext() {} + +func NewColumn_one_or_more_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_one_or_more_sub_clauseContext { + var p = new(Column_one_or_more_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause + + return p +} + +func (s *Column_one_or_more_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_one_or_more_sub_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_one_or_more_sub_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_one_or_more_sub_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Column_one_or_more_sub_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Column_one_or_more_sub_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_one_or_more_sub_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_one_or_more_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_one_or_more_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_one_or_more_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_one_or_more_sub_clause(s) + } +} + +func (s *Column_one_or_more_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_one_or_more_sub_clause(s) + } +} + +func (p *PlSqlParser) Column_one_or_more_sub_clause() (localctx IColumn_one_or_more_sub_clauseContext) { + localctx = NewColumn_one_or_more_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, PlSqlParserRULE_column_one_or_more_sub_clause) + var _la int + + p.SetState(8882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8870) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8871) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8872) + p.Column_name() + } + p.SetState(8877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8873) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8874) + p.Column_name() + } + + p.SetState(8879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8880) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_viewContext is an interface to support dynamic dispatch. +type IAlter_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + ADD() antlr.TerminalNode + Out_of_line_constraint() IOut_of_line_constraintContext + MODIFY() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + DROP() antlr.TerminalNode + COMPILE() antlr.TerminalNode + READ() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Alter_view_editionable() IAlter_view_editionableContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_viewContext differentiates from other interfaces. + IsAlter_viewContext() +} + +type Alter_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_viewContext() *Alter_viewContext { + var p = new(Alter_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view + return p +} + +func InitEmptyAlter_viewContext(p *Alter_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view +} + +func (*Alter_viewContext) IsAlter_viewContext() {} + +func NewAlter_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_viewContext { + var p = new(Alter_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_view + + return p +} + +func (s *Alter_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_viewContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_viewContext) Out_of_line_constraint() IOut_of_line_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Alter_viewContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_viewContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Alter_viewContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Alter_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_viewContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Alter_viewContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Alter_viewContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Alter_viewContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Alter_viewContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Alter_viewContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Alter_viewContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Alter_viewContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Alter_viewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_viewContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_viewContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_viewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_viewContext) Alter_view_editionable() IAlter_view_editionableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_view_editionableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_view_editionableContext) +} + +func (s *Alter_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_view(s) + } +} + +func (s *Alter_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_view(s) + } +} + +func (p *PlSqlParser) Alter_view() (localctx IAlter_viewContext) { + localctx = NewAlter_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, PlSqlParserRULE_alter_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8884) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8885) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8886) + p.Tableview_name() + } + p.SetState(8919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 985, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8887) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8888) + p.Out_of_line_constraint() + } + + case 2: + { + p.SetState(8889) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8890) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8891) + p.Constraint_name() + } + { + p.SetState(8892) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + { + p.SetState(8894) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONSTRAINT: + { + p.SetState(8895) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8896) + p.Constraint_name() + } + + case PlSqlParserPRIMARY: + { + p.SetState(8897) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8898) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(8899) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8900) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8901) + p.Column_name() + } + p.SetState(8906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8902) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8903) + p.Column_name() + } + + p.SetState(8908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8909) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + { + p.SetState(8913) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(8914) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8915) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 6: + p.SetState(8917) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 984, p.GetParserRuleContext()) == 1 { + { + p.SetState(8916) + p.Alter_view_editionable() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_view_editionableContext is an interface to support dynamic dispatch. +type IAlter_view_editionableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsAlter_view_editionableContext differentiates from other interfaces. + IsAlter_view_editionableContext() +} + +type Alter_view_editionableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_view_editionableContext() *Alter_view_editionableContext { + var p = new(Alter_view_editionableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view_editionable + return p +} + +func InitEmptyAlter_view_editionableContext(p *Alter_view_editionableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view_editionable +} + +func (*Alter_view_editionableContext) IsAlter_view_editionableContext() {} + +func NewAlter_view_editionableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_view_editionableContext { + var p = new(Alter_view_editionableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_view_editionable + + return p +} + +func (s *Alter_view_editionableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_view_editionableContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Alter_view_editionableContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Alter_view_editionableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_view_editionableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_view_editionableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_view_editionable(s) + } +} + +func (s *Alter_view_editionableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_view_editionable(s) + } +} + +func (p *PlSqlParser) Alter_view_editionable() (localctx IAlter_view_editionableContext) { + localctx = NewAlter_view_editionableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, PlSqlParserRULE_alter_view_editionable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8921) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8922) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_viewContext is an interface to support dynamic dispatch. +type ICreate_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetV returns the v rule contexts. + GetV() IId_expressionContext + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // SetV sets the v rule contexts. + SetV(IId_expressionContext) + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + VIEW() antlr.TerminalNode + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FORCE() antlr.TerminalNode + Editioning_clause() IEditioning_clauseContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + View_options() IView_optionsContext + DEFAULT() antlr.TerminalNode + COLLATION() antlr.TerminalNode + BEQUEATH() antlr.TerminalNode + Subquery_restriction_clause() ISubquery_restriction_clauseContext + CURRENT_USER() antlr.TerminalNode + DEFINER() antlr.TerminalNode + CONTAINER_MAP() antlr.TerminalNode + CONTAINERS_DEFAULT() antlr.TerminalNode + METADATA() antlr.TerminalNode + DATA() antlr.TerminalNode + NONE() antlr.TerminalNode + NO() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + + // IsCreate_viewContext differentiates from other interfaces. + IsCreate_viewContext() +} + +type Create_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + v IId_expressionContext + cn IId_expressionContext +} + +func NewEmptyCreate_viewContext() *Create_viewContext { + var p = new(Create_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_view + return p +} + +func InitEmptyCreate_viewContext(p *Create_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_view +} + +func (*Create_viewContext) IsCreate_viewContext() {} + +func NewCreate_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_viewContext { + var p = new(Create_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_view + + return p +} + +func (s *Create_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_viewContext) GetV() IId_expressionContext { return s.v } + +func (s *Create_viewContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Create_viewContext) SetV(v IId_expressionContext) { s.v = v } + +func (s *Create_viewContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Create_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_viewContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_viewContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Create_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_viewContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_viewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_viewContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_viewContext) Editioning_clause() IEditioning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEditioning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEditioning_clauseContext) +} + +func (s *Create_viewContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_viewContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_viewContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_viewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_viewContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_viewContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_viewContext) View_options() IView_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IView_optionsContext) +} + +func (s *Create_viewContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Create_viewContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Create_viewContext) BEQUEATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEQUEATH, 0) +} + +func (s *Create_viewContext) Subquery_restriction_clause() ISubquery_restriction_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_restriction_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_restriction_clauseContext) +} + +func (s *Create_viewContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Create_viewContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Create_viewContext) CONTAINER_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_MAP, 0) +} + +func (s *Create_viewContext) CONTAINERS_DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS_DEFAULT, 0) +} + +func (s *Create_viewContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_viewContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_viewContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_viewContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_viewContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Create_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_view(s) + } +} + +func (s *Create_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_view(s) + } +} + +func (p *PlSqlParser) Create_view() (localctx ICreate_viewContext) { + localctx = NewCreate_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, PlSqlParserRULE_create_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8924) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8925) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8926) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNO { + p.SetState(8930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(8929) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8932) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserEDITIONING || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(8935) + p.Editioning_clause() + } + + } + { + p.SetState(8938) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8942) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 990, p.GetParserRuleContext()) == 1 { + { + p.SetState(8939) + p.Schema_name() + } + { + p.SetState(8940) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8944) + + var _x = p.Id_expression() + + localctx.(*Create_viewContext).v = _x + } + p.SetState(8948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(8945) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8946) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8947) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8950) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8951) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMETADATA: + { + p.SetState(8952) + p.Match(PlSqlParserMETADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATA, PlSqlParserEXTENDED: + p.SetState(8954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENDED { + { + p.SetState(8953) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8956) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(8957) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(8963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8962) + p.View_options() + } + + } + p.SetState(8968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(8965) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8966) + p.Match(PlSqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8967) + + var _x = p.Id_expression() + + localctx.(*Create_viewContext).cn = _x + } + + } + p.SetState(8972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBEQUEATH { + { + p.SetState(8970) + p.Match(PlSqlParserBEQUEATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8971) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT_USER || _la == PlSqlParserDEFINER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8974) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8975) + p.Select_only_statement() + } + p.SetState(8977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(8976) + p.Subquery_restriction_clause() + } + + } + p.SetState(8980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINERS_DEFAULT || _la == PlSqlParserCONTAINER_MAP { + { + p.SetState(8979) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTAINERS_DEFAULT || _la == PlSqlParserCONTAINER_MAP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEditioning_clauseContext is an interface to support dynamic dispatch. +type IEditioning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONING() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsEditioning_clauseContext differentiates from other interfaces. + IsEditioning_clauseContext() +} + +type Editioning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEditioning_clauseContext() *Editioning_clauseContext { + var p = new(Editioning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_editioning_clause + return p +} + +func InitEmptyEditioning_clauseContext(p *Editioning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_editioning_clause +} + +func (*Editioning_clauseContext) IsEditioning_clauseContext() {} + +func NewEditioning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Editioning_clauseContext { + var p = new(Editioning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_editioning_clause + + return p +} + +func (s *Editioning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Editioning_clauseContext) EDITIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONING, 0) +} + +func (s *Editioning_clauseContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Editioning_clauseContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Editioning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Editioning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Editioning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEditioning_clause(s) + } +} + +func (s *Editioning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEditioning_clause(s) + } +} + +func (p *PlSqlParser) Editioning_clause() (localctx IEditioning_clauseContext) { + localctx = NewEditioning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, PlSqlParserRULE_editioning_clause) + var _la int + + p.SetState(8988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEDITIONING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8982) + p.Match(PlSqlParserEDITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITIONABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8983) + p.Match(PlSqlParserEDITIONABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONING { + { + p.SetState(8984) + p.Match(PlSqlParserEDITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNONEDITIONABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8987) + p.Match(PlSqlParserNONEDITIONABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IView_optionsContext is an interface to support dynamic dispatch. +type IView_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + View_alias_constraint() IView_alias_constraintContext + Object_view_clause() IObject_view_clauseContext + Xmltype_view_clause() IXmltype_view_clauseContext + + // IsView_optionsContext differentiates from other interfaces. + IsView_optionsContext() +} + +type View_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_optionsContext() *View_optionsContext { + var p = new(View_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_options + return p +} + +func InitEmptyView_optionsContext(p *View_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_options +} + +func (*View_optionsContext) IsView_optionsContext() {} + +func NewView_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_optionsContext { + var p = new(View_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_view_options + + return p +} + +func (s *View_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_optionsContext) View_alias_constraint() IView_alias_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_alias_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IView_alias_constraintContext) +} + +func (s *View_optionsContext) Object_view_clause() IObject_view_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_view_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_view_clauseContext) +} + +func (s *View_optionsContext) Xmltype_view_clause() IXmltype_view_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_view_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_view_clauseContext) +} + +func (s *View_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterView_options(s) + } +} + +func (s *View_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitView_options(s) + } +} + +func (p *PlSqlParser) View_options() (localctx IView_optionsContext) { + localctx = NewView_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, PlSqlParserRULE_view_options) + p.SetState(8993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1002, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8990) + p.View_alias_constraint() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8991) + p.Object_view_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8992) + p.Xmltype_view_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IView_alias_constraintContext is an interface to support dynamic dispatch. +type IView_alias_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllTable_alias() []ITable_aliasContext + Table_alias(i int) ITable_aliasContext + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsView_alias_constraintContext differentiates from other interfaces. + IsView_alias_constraintContext() +} + +type View_alias_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_alias_constraintContext() *View_alias_constraintContext { + var p = new(View_alias_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_alias_constraint + return p +} + +func InitEmptyView_alias_constraintContext(p *View_alias_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_alias_constraint +} + +func (*View_alias_constraintContext) IsView_alias_constraintContext() {} + +func NewView_alias_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_alias_constraintContext { + var p = new(View_alias_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_view_alias_constraint + + return p +} + +func (s *View_alias_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_alias_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *View_alias_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *View_alias_constraintContext) AllTable_alias() []ITable_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_aliasContext); ok { + len++ + } + } + + tst := make([]ITable_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_aliasContext); ok { + tst[i] = t.(ITable_aliasContext) + i++ + } + } + + return tst +} + +func (s *View_alias_constraintContext) Table_alias(i int) ITable_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *View_alias_constraintContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *View_alias_constraintContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *View_alias_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *View_alias_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *View_alias_constraintContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *View_alias_constraintContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *View_alias_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_alias_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_alias_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterView_alias_constraint(s) + } +} + +func (s *View_alias_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitView_alias_constraint(s) + } +} + +func (p *PlSqlParser) View_alias_constraint() (localctx IView_alias_constraintContext) { + localctx = NewView_alias_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, PlSqlParserRULE_view_alias_constraint) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8995) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475085) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532621) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883979555) != 0) { + p.SetState(8997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8996) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1005, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8999) + p.Table_alias() + } + p.SetState(9003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1004, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9000) + p.Inline_constraint() + } + + } + p.SetState(9005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1004, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(9006) + p.Out_of_line_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(9011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9013) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_view_clauseContext is an interface to support dynamic dispatch. +type IObject_view_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTn returns the tn rule contexts. + GetTn() IId_expressionContext + + // GetSv returns the sv rule contexts. + GetSv() IId_expressionContext + + // SetTn sets the tn rule contexts. + SetTn(IId_expressionContext) + + // SetSv sets the sv rule contexts. + SetSv(IId_expressionContext) + + // Getter signatures + OF() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + WITH() antlr.TerminalNode + OBJECT() antlr.TerminalNode + UNDER() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + ID() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllREGULAR_ID() []antlr.TerminalNode + REGULAR_ID(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsObject_view_clauseContext differentiates from other interfaces. + IsObject_view_clauseContext() +} + +type Object_view_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tn IId_expressionContext + sv IId_expressionContext +} + +func NewEmptyObject_view_clauseContext() *Object_view_clauseContext { + var p = new(Object_view_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_view_clause + return p +} + +func InitEmptyObject_view_clauseContext(p *Object_view_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_view_clause +} + +func (*Object_view_clauseContext) IsObject_view_clauseContext() {} + +func NewObject_view_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_view_clauseContext { + var p = new(Object_view_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_view_clause + + return p +} + +func (s *Object_view_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_view_clauseContext) GetTn() IId_expressionContext { return s.tn } + +func (s *Object_view_clauseContext) GetSv() IId_expressionContext { return s.sv } + +func (s *Object_view_clauseContext) SetTn(v IId_expressionContext) { s.tn = v } + +func (s *Object_view_clauseContext) SetSv(v IId_expressionContext) { s.sv = v } + +func (s *Object_view_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Object_view_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Object_view_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Object_view_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Object_view_clauseContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_view_clauseContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Object_view_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Object_view_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Object_view_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Object_view_clauseContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Object_view_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Object_view_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Object_view_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Object_view_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Object_view_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Object_view_clauseContext) AllREGULAR_ID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREGULAR_ID) +} + +func (s *Object_view_clauseContext) REGULAR_ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, i) +} + +func (s *Object_view_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_view_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_view_clauseContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Object_view_clauseContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Object_view_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_view_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_view_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_view_clause(s) + } +} + +func (s *Object_view_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_view_clause(s) + } +} + +func (p *PlSqlParser) Object_view_clause() (localctx IObject_view_clauseContext) { + localctx = NewObject_view_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, PlSqlParserRULE_object_view_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9015) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9019) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) == 1 { + { + p.SetState(9016) + p.Schema_name() + } + { + p.SetState(9017) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9021) + + var _x = p.Id_expression() + + localctx.(*Object_view_clauseContext).tn = _x + } + p.SetState(9045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITH: + { + p.SetState(9022) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9023) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9024) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIDENTIFIER || _la == PlSqlParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(9036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(9025) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9026) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9027) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9028) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9029) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9035) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserUNDER: + { + p.SetState(9038) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9042) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1010, p.GetParserRuleContext()) == 1 { + { + p.SetState(9039) + p.Schema_name() + } + { + p.SetState(9040) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9044) + + var _x = p.Id_expression() + + localctx.(*Object_view_clauseContext).sv = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9047) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE || _la == PlSqlParserCOMMA || _la == PlSqlParserREGULAR_ID { + p.SetState(9049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9048) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHECK, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserFOREIGN, PlSqlParserPRIMARY, PlSqlParserUNIQUE: + { + p.SetState(9051) + p.Out_of_line_constraint() + } + + case PlSqlParserREGULAR_ID: + { + p.SetState(9052) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9053) + p.Inline_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9060) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInline_constraintContext is an interface to support dynamic dispatch. +type IInline_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + References_clause() IReferences_clauseContext + Check_constraint() ICheck_constraintContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + NOT() antlr.TerminalNode + + // IsInline_constraintContext differentiates from other interfaces. + IsInline_constraintContext() +} + +type Inline_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInline_constraintContext() *Inline_constraintContext { + var p = new(Inline_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_constraint + return p +} + +func InitEmptyInline_constraintContext(p *Inline_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_constraint +} + +func (*Inline_constraintContext) IsInline_constraintContext() {} + +func NewInline_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inline_constraintContext { + var p = new(Inline_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inline_constraint + + return p +} + +func (s *Inline_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inline_constraintContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Inline_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Inline_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Inline_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Inline_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Inline_constraintContext) Check_constraint() ICheck_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_constraintContext) +} + +func (s *Inline_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Inline_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Inline_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Inline_constraintContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Inline_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inline_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inline_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInline_constraint(s) + } +} + +func (s *Inline_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInline_constraint(s) + } +} + +func (p *PlSqlParser) Inline_constraint() (localctx IInline_constraintContext) { + localctx = NewInline_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, PlSqlParserRULE_inline_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(9067) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9068) + p.Constraint_name() + } + + } + p.SetState(9080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT, PlSqlParserNULL_: + p.SetState(9072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(9071) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9074) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(9075) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9076) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9077) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREFERENCES: + { + p.SetState(9078) + p.References_clause() + } + + case PlSqlParserCHECK: + { + p.SetState(9079) + p.Check_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9083) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1019, p.GetParserRuleContext()) == 1 { + { + p.SetState(9082) + p.Constraint_state() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInline_ref_constraintContext is an interface to support dynamic dispatch. +type IInline_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCOPE() antlr.TerminalNode + IS() antlr.TerminalNode + Tableview_name() ITableview_nameContext + WITH() antlr.TerminalNode + ROWID() antlr.TerminalNode + References_clause() IReferences_clauseContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + + // IsInline_ref_constraintContext differentiates from other interfaces. + IsInline_ref_constraintContext() +} + +type Inline_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInline_ref_constraintContext() *Inline_ref_constraintContext { + var p = new(Inline_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint + return p +} + +func InitEmptyInline_ref_constraintContext(p *Inline_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint +} + +func (*Inline_ref_constraintContext) IsInline_ref_constraintContext() {} + +func NewInline_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inline_ref_constraintContext { + var p = new(Inline_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint + + return p +} + +func (s *Inline_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inline_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Inline_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Inline_ref_constraintContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Inline_ref_constraintContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Inline_ref_constraintContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Inline_ref_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Inline_ref_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Inline_ref_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Inline_ref_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Inline_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inline_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inline_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInline_ref_constraint(s) + } +} + +func (s *Inline_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInline_ref_constraint(s) + } +} + +func (p *PlSqlParser) Inline_ref_constraint() (localctx IInline_ref_constraintContext) { + localctx = NewInline_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, PlSqlParserRULE_inline_ref_constraint) + var _la int + + p.SetState(9098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCOPE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9085) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9086) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9087) + p.Tableview_name() + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9088) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9089) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT, PlSqlParserREFERENCES: + p.EnterOuterAlt(localctx, 3) + p.SetState(9092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(9090) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9091) + p.Constraint_name() + } + + } + { + p.SetState(9094) + p.References_clause() + } + p.SetState(9096) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1021, p.GetParserRuleContext()) == 1 { + { + p.SetState(9095) + p.Constraint_state() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOut_of_line_ref_constraintContext is an interface to support dynamic dispatch. +type IOut_of_line_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRef_col_or_attr returns the ref_col_or_attr rule contexts. + GetRef_col_or_attr() IRegular_idContext + + // SetRef_col_or_attr sets the ref_col_or_attr rule contexts. + SetRef_col_or_attr(IRegular_idContext) + + // Getter signatures + SCOPE() antlr.TerminalNode + FOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + IS() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + REF() antlr.TerminalNode + WITH() antlr.TerminalNode + ROWID() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + References_clause() IReferences_clauseContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOut_of_line_ref_constraintContext differentiates from other interfaces. + IsOut_of_line_ref_constraintContext() +} + +type Out_of_line_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ref_col_or_attr IRegular_idContext +} + +func NewEmptyOut_of_line_ref_constraintContext() *Out_of_line_ref_constraintContext { + var p = new(Out_of_line_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint + return p +} + +func InitEmptyOut_of_line_ref_constraintContext(p *Out_of_line_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint +} + +func (*Out_of_line_ref_constraintContext) IsOut_of_line_ref_constraintContext() {} + +func NewOut_of_line_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Out_of_line_ref_constraintContext { + var p = new(Out_of_line_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint + + return p +} + +func (s *Out_of_line_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_ref_constraintContext) GetRef_col_or_attr() IRegular_idContext { + return s.ref_col_or_attr +} + +func (s *Out_of_line_ref_constraintContext) SetRef_col_or_attr(v IRegular_idContext) { + s.ref_col_or_attr = v +} + +func (s *Out_of_line_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Out_of_line_ref_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Out_of_line_ref_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Out_of_line_ref_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Out_of_line_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Out_of_line_ref_constraintContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Out_of_line_ref_constraintContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Out_of_line_ref_constraintContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Out_of_line_ref_constraintContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Out_of_line_ref_constraintContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Out_of_line_ref_constraintContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Out_of_line_ref_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Out_of_line_ref_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Out_of_line_ref_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Out_of_line_ref_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Out_of_line_ref_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Out_of_line_ref_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Out_of_line_ref_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Out_of_line_ref_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Out_of_line_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Out_of_line_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Out_of_line_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOut_of_line_ref_constraint(s) + } +} + +func (s *Out_of_line_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOut_of_line_ref_constraint(s) + } +} + +func (p *PlSqlParser) Out_of_line_ref_constraint() (localctx IOut_of_line_ref_constraintContext) { + localctx = NewOut_of_line_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, PlSqlParserRULE_out_of_line_ref_constraint) + var _la int + + p.SetState(9135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCOPE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9100) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9101) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9102) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9103) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + { + p.SetState(9104) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9105) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9106) + p.Tableview_name() + } + + case PlSqlParserREF: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9108) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9109) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9110) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + { + p.SetState(9111) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9112) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9113) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT, PlSqlParserFOREIGN: + p.EnterOuterAlt(localctx, 3) + p.SetState(9117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(9115) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9116) + p.Constraint_name() + } + + } + { + p.SetState(9119) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9120) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9121) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372351009) != 0) { + p.SetState(9123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9122) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9125) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + + p.SetState(9128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9130) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9131) + p.References_clause() + } + p.SetState(9133) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1026, p.GetParserRuleContext()) == 1 { + { + p.SetState(9132) + p.Constraint_state() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOut_of_line_constraintContext is an interface to support dynamic dispatch. +type IOut_of_line_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constraint_state() IConstraint_stateContext + Parallel_clause() IParallel_clauseContext + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + Foreign_key_clause() IForeign_key_clauseContext + CHECK() antlr.TerminalNode + Condition() IConditionContext + Constraint_name() IConstraint_nameContext + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOut_of_line_constraintContext differentiates from other interfaces. + IsOut_of_line_constraintContext() +} + +type Out_of_line_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOut_of_line_constraintContext() *Out_of_line_constraintContext { + var p = new(Out_of_line_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_constraint + return p +} + +func InitEmptyOut_of_line_constraintContext(p *Out_of_line_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_constraint +} + +func (*Out_of_line_constraintContext) IsOut_of_line_constraintContext() {} + +func NewOut_of_line_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Out_of_line_constraintContext { + var p = new(Out_of_line_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_out_of_line_constraint + + return p +} + +func (s *Out_of_line_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Out_of_line_constraintContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Out_of_line_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Out_of_line_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Out_of_line_constraintContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Out_of_line_constraintContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Out_of_line_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Out_of_line_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Out_of_line_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Out_of_line_constraintContext) Foreign_key_clause() IForeign_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_clauseContext) +} + +func (s *Out_of_line_constraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Out_of_line_constraintContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Out_of_line_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Out_of_line_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Out_of_line_constraintContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Out_of_line_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Out_of_line_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Out_of_line_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Out_of_line_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Out_of_line_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOut_of_line_constraint(s) + } +} + +func (s *Out_of_line_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOut_of_line_constraint(s) + } +} + +func (p *PlSqlParser) Out_of_line_constraint() (localctx IOut_of_line_constraintContext) { + localctx = NewOut_of_line_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, PlSqlParserRULE_out_of_line_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS { + { + p.SetState(9137) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9138) + p.Constraint_name() + } + + } + p.SetState(9172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNIQUE: + { + p.SetState(9141) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9142) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9143) + p.Column_name() + } + p.SetState(9148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9144) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9145) + p.Column_name() + } + + p.SetState(9150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9151) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9153) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9154) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9155) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9156) + p.Column_name() + } + p.SetState(9161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9157) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9158) + p.Column_name() + } + + p.SetState(9163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9164) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOREIGN: + { + p.SetState(9166) + p.Foreign_key_clause() + } + + case PlSqlParserCHECK: + { + p.SetState(9167) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9168) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9169) + p.Condition() + } + { + p.SetState(9170) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9175) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1032, p.GetParserRuleContext()) == 1 { + { + p.SetState(9174) + p.Constraint_state() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9178) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) == 1 { + { + p.SetState(9177) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraint_stateContext is an interface to support dynamic dispatch. +type IConstraint_stateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDEFERRABLE() []antlr.TerminalNode + DEFERRABLE(i int) antlr.TerminalNode + AllINITIALLY() []antlr.TerminalNode + INITIALLY(i int) antlr.TerminalNode + AllUsing_index_clause() []IUsing_index_clauseContext + Using_index_clause(i int) IUsing_index_clauseContext + AllIMMEDIATE() []antlr.TerminalNode + IMMEDIATE(i int) antlr.TerminalNode + AllDEFERRED() []antlr.TerminalNode + DEFERRED(i int) antlr.TerminalNode + AllRELY() []antlr.TerminalNode + RELY(i int) antlr.TerminalNode + AllNORELY() []antlr.TerminalNode + NORELY(i int) antlr.TerminalNode + AllENABLE() []antlr.TerminalNode + ENABLE(i int) antlr.TerminalNode + AllDISABLE() []antlr.TerminalNode + DISABLE(i int) antlr.TerminalNode + AllVALIDATE() []antlr.TerminalNode + VALIDATE(i int) antlr.TerminalNode + AllNOVALIDATE() []antlr.TerminalNode + NOVALIDATE(i int) antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + + // IsConstraint_stateContext differentiates from other interfaces. + IsConstraint_stateContext() +} + +type Constraint_stateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_stateContext() *Constraint_stateContext { + var p = new(Constraint_stateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_state + return p +} + +func InitEmptyConstraint_stateContext(p *Constraint_stateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_state +} + +func (*Constraint_stateContext) IsConstraint_stateContext() {} + +func NewConstraint_stateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_stateContext { + var p = new(Constraint_stateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_state + + return p +} + +func (s *Constraint_stateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_stateContext) AllDEFERRABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFERRABLE) +} + +func (s *Constraint_stateContext) DEFERRABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRABLE, i) +} + +func (s *Constraint_stateContext) AllINITIALLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITIALLY) +} + +func (s *Constraint_stateContext) INITIALLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALLY, i) +} + +func (s *Constraint_stateContext) AllUsing_index_clause() []IUsing_index_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + len++ + } + } + + tst := make([]IUsing_index_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUsing_index_clauseContext); ok { + tst[i] = t.(IUsing_index_clauseContext) + i++ + } + } + + return tst +} + +func (s *Constraint_stateContext) Using_index_clause(i int) IUsing_index_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Constraint_stateContext) AllIMMEDIATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIMMEDIATE) +} + +func (s *Constraint_stateContext) IMMEDIATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, i) +} + +func (s *Constraint_stateContext) AllDEFERRED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFERRED) +} + +func (s *Constraint_stateContext) DEFERRED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, i) +} + +func (s *Constraint_stateContext) AllRELY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRELY) +} + +func (s *Constraint_stateContext) RELY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, i) +} + +func (s *Constraint_stateContext) AllNORELY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNORELY) +} + +func (s *Constraint_stateContext) NORELY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, i) +} + +func (s *Constraint_stateContext) AllENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENABLE) +} + +func (s *Constraint_stateContext) ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, i) +} + +func (s *Constraint_stateContext) AllDISABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISABLE) +} + +func (s *Constraint_stateContext) DISABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, i) +} + +func (s *Constraint_stateContext) AllVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserVALIDATE) +} + +func (s *Constraint_stateContext) VALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, i) +} + +func (s *Constraint_stateContext) AllNOVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOVALIDATE) +} + +func (s *Constraint_stateContext) NOVALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, i) +} + +func (s *Constraint_stateContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOT) +} + +func (s *Constraint_stateContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, i) +} + +func (s *Constraint_stateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_stateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_stateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_state(s) + } +} + +func (s *Constraint_stateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_state(s) + } +} + +func (p *PlSqlParser) Constraint_state() (localctx IConstraint_stateContext) { + localctx = NewConstraint_stateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, PlSqlParserRULE_constraint_state) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFERRABLE, PlSqlParserNOT: + p.SetState(9181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(9180) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9183) + p.Match(PlSqlParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINITIALLY: + { + p.SetState(9184) + p.Match(PlSqlParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9185) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNORELY, PlSqlParserRELY: + { + p.SetState(9186) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(9187) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNOVALIDATE, PlSqlParserVALIDATE: + { + p.SetState(9188) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserUSING: + { + p.SetState(9189) + p.Using_index_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9192) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1036, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_view_clauseContext is an interface to support dynamic dispatch. +type IXmltype_view_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + WITH() antlr.TerminalNode + OBJECT() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + ID() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Xml_schema_spec() IXml_schema_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXmltype_view_clauseContext differentiates from other interfaces. + IsXmltype_view_clauseContext() +} + +type Xmltype_view_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_view_clauseContext() *Xmltype_view_clauseContext { + var p = new(Xmltype_view_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause + return p +} + +func InitEmptyXmltype_view_clauseContext(p *Xmltype_view_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause +} + +func (*Xmltype_view_clauseContext) IsXmltype_view_clauseContext() {} + +func NewXmltype_view_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_view_clauseContext { + var p = new(Xmltype_view_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause + + return p +} + +func (s *Xmltype_view_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_view_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Xmltype_view_clauseContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Xmltype_view_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Xmltype_view_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Xmltype_view_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Xmltype_view_clauseContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Xmltype_view_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Xmltype_view_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_view_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xmltype_view_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmltype_view_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_view_clauseContext) Xml_schema_spec() IXml_schema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_schema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_schema_specContext) +} + +func (s *Xmltype_view_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xmltype_view_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xmltype_view_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_view_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_view_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_view_clause(s) + } +} + +func (s *Xmltype_view_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_view_clause(s) + } +} + +func (p *PlSqlParser) Xmltype_view_clause() (localctx IXmltype_view_clauseContext) { + localctx = NewXmltype_view_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, PlSqlParserRULE_xmltype_view_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9194) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9195) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(9196) + p.Xml_schema_spec() + } + + } + { + p.SetState(9199) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9200) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9201) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIDENTIFIER || _la == PlSqlParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(9214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(9202) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9203) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9204) + p.Expression() + } + p.SetState(9209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9205) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9206) + p.Expression() + } + + p.SetState(9211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9212) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_schema_specContext is an interface to support dynamic dispatch. +type IXml_schema_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELEMENT() antlr.TerminalNode + Element() IElementContext + AllXml_schema_url() []IXml_schema_urlContext + Xml_schema_url(i int) IXml_schema_urlContext + HASH_OP() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + STORE() antlr.TerminalNode + ALL() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + AS() antlr.TerminalNode + AllAllow_or_disallow() []IAllow_or_disallowContext + Allow_or_disallow(i int) IAllow_or_disallowContext + NONSCHEMA() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + LOBS() antlr.TerminalNode + TABLES() antlr.TerminalNode + + // IsXml_schema_specContext differentiates from other interfaces. + IsXml_schema_specContext() +} + +type Xml_schema_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_schema_specContext() *Xml_schema_specContext { + var p = new(Xml_schema_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_spec + return p +} + +func InitEmptyXml_schema_specContext(p *Xml_schema_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_spec +} + +func (*Xml_schema_specContext) IsXml_schema_specContext() {} + +func NewXml_schema_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_specContext { + var p = new(Xml_schema_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_schema_spec + + return p +} + +func (s *Xml_schema_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_schema_specContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Xml_schema_specContext) Element() IElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElementContext) +} + +func (s *Xml_schema_specContext) AllXml_schema_url() []IXml_schema_urlContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_schema_urlContext); ok { + len++ + } + } + + tst := make([]IXml_schema_urlContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_schema_urlContext); ok { + tst[i] = t.(IXml_schema_urlContext) + i++ + } + } + + return tst +} + +func (s *Xml_schema_specContext) Xml_schema_url(i int) IXml_schema_urlContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_schema_urlContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_schema_urlContext) +} + +func (s *Xml_schema_specContext) HASH_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_OP, 0) +} + +func (s *Xml_schema_specContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Xml_schema_specContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Xml_schema_specContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Xml_schema_specContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Xml_schema_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xml_schema_specContext) AllAllow_or_disallow() []IAllow_or_disallowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + len++ + } + } + + tst := make([]IAllow_or_disallowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllow_or_disallowContext); ok { + tst[i] = t.(IAllow_or_disallowContext) + i++ + } + } + + return tst +} + +func (s *Xml_schema_specContext) Allow_or_disallow(i int) IAllow_or_disallowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Xml_schema_specContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Xml_schema_specContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Xml_schema_specContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Xml_schema_specContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Xml_schema_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_schema_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_schema_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_schema_spec(s) + } +} + +func (s *Xml_schema_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_schema_spec(s) + } +} + +func (p *PlSqlParser) Xml_schema_spec() (localctx IXml_schema_specContext) { + localctx = NewXml_schema_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, PlSqlParserRULE_xml_schema_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXMLSCHEMA { + { + p.SetState(9216) + p.Match(PlSqlParserXMLSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9217) + p.Xml_schema_url() + } + + } + { + p.SetState(9220) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9221) + p.Element() + } + + case 2: + { + p.SetState(9222) + p.Xml_schema_url() + } + { + p.SetState(9223) + p.Match(PlSqlParserHASH_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9224) + p.Element() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(9233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(9228) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9229) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9230) + p.Match(PlSqlParserVARRAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9231) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9232) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOBS || _la == PlSqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1043, p.GetParserRuleContext()) == 1 { + { + p.SetState(9235) + p.Allow_or_disallow() + } + { + p.SetState(9236) + p.Match(PlSqlParserNONSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(9240) + p.Allow_or_disallow() + } + { + p.SetState(9241) + p.Match(PlSqlParserANYSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_schema_urlContext is an interface to support dynamic dispatch. +type IXml_schema_urlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsXml_schema_urlContext differentiates from other interfaces. + IsXml_schema_urlContext() +} + +type Xml_schema_urlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_schema_urlContext() *Xml_schema_urlContext { + var p = new(Xml_schema_urlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_url + return p +} + +func InitEmptyXml_schema_urlContext(p *Xml_schema_urlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_url +} + +func (*Xml_schema_urlContext) IsXml_schema_urlContext() {} + +func NewXml_schema_urlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_urlContext { + var p = new(Xml_schema_urlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_schema_url + + return p +} + +func (s *Xml_schema_urlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_schema_urlContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Xml_schema_urlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_schema_urlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_schema_urlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_schema_url(s) + } +} + +func (s *Xml_schema_urlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_schema_url(s) + } +} + +func (p *PlSqlParser) Xml_schema_url() (localctx IXml_schema_urlContext) { + localctx = NewXml_schema_urlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 860, PlSqlParserRULE_xml_schema_url) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9245) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElementContext is an interface to support dynamic dispatch. +type IElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsElementContext differentiates from other interfaces. + IsElementContext() +} + +type ElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElementContext() *ElementContext { + var p = new(ElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element + return p +} + +func InitEmptyElementContext(p *ElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element +} + +func (*ElementContext) IsElementContext() {} + +func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext { + var p = new(ElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element + + return p +} + +func (s *ElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ElementContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *ElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement(s) + } +} + +func (s *ElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement(s) + } +} + +func (p *PlSqlParser) Element() (localctx IElementContext) { + localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 862, PlSqlParserRULE_element) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9247) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tablespaceContext is an interface to support dynamic dispatch. +type IAlter_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + DEFAULT() antlr.TerminalNode + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + RESIZE() antlr.TerminalNode + COALESCE() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_tablespace_name() INew_tablespace_nameContext + Begin_or_end() IBegin_or_endContext + BACKUP() antlr.TerminalNode + Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext + Tablespace_logging_clauses() ITablespace_logging_clausesContext + Tablespace_group_clause() ITablespace_group_clauseContext + Tablespace_state_clauses() ITablespace_state_clausesContext + Autoextend_clause() IAutoextend_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + Table_compression() ITable_compressionContext + Storage_clause() IStorage_clauseContext + KEEP() antlr.TerminalNode + + // IsAlter_tablespaceContext differentiates from other interfaces. + IsAlter_tablespaceContext() +} + +type Alter_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tablespaceContext() *Alter_tablespaceContext { + var p = new(Alter_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace + return p +} + +func InitEmptyAlter_tablespaceContext(p *Alter_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace +} + +func (*Alter_tablespaceContext) IsAlter_tablespaceContext() {} + +func NewAlter_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespaceContext { + var p = new(Alter_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace + + return p +} + +func (s *Alter_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespaceContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Alter_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Alter_tablespaceContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Alter_tablespaceContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Alter_tablespaceContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tablespaceContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tablespaceContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_tablespaceContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_tablespaceContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Alter_tablespaceContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_tablespaceContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_tablespaceContext) New_tablespace_name() INew_tablespace_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_tablespace_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_tablespace_nameContext) +} + +func (s *Alter_tablespaceContext) Begin_or_end() IBegin_or_endContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_or_endContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_or_endContext) +} + +func (s *Alter_tablespaceContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_tablespaceContext) Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_clausesContext) +} + +func (s *Alter_tablespaceContext) Tablespace_logging_clauses() ITablespace_logging_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_logging_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_logging_clausesContext) +} + +func (s *Alter_tablespaceContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Alter_tablespaceContext) Tablespace_state_clauses() ITablespace_state_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_state_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_state_clausesContext) +} + +func (s *Alter_tablespaceContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tablespaceContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Alter_tablespaceContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Alter_tablespaceContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_tablespaceContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Alter_tablespaceContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Alter_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace(s) + } +} + +func (s *Alter_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace(s) + } +} + +func (p *PlSqlParser) Alter_tablespace() (localctx IAlter_tablespaceContext) { + localctx = NewAlter_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 864, PlSqlParserRULE_alter_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9249) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9250) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9251) + p.Tablespace() + } + p.SetState(9284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1048, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9252) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserROW { + { + p.SetState(9253) + p.Table_compression() + } + + } + p.SetState(9257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORAGE { + { + p.SetState(9256) + p.Storage_clause() + } + + } + + case 2: + { + p.SetState(9259) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9260) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9261) + p.Size_clause() + } + + case 3: + { + p.SetState(9262) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9263) + p.Size_clause() + } + + case 4: + { + p.SetState(9264) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(9265) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9266) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(9267) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9268) + p.Size_clause() + } + + } + + case 6: + { + p.SetState(9271) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9272) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9273) + p.New_tablespace_name() + } + + case 7: + { + p.SetState(9274) + p.Begin_or_end() + } + { + p.SetState(9275) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(9277) + p.Datafile_tempfile_clauses() + } + + case 9: + { + p.SetState(9278) + p.Tablespace_logging_clauses() + } + + case 10: + { + p.SetState(9279) + p.Tablespace_group_clause() + } + + case 11: + { + p.SetState(9280) + p.Tablespace_state_clauses() + } + + case 12: + { + p.SetState(9281) + p.Autoextend_clause() + } + + case 13: + { + p.SetState(9282) + p.Flashback_mode_clause() + } + + case 14: + { + p.SetState(9283) + p.Tablespace_retention_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatafile_tempfile_clausesContext is an interface to support dynamic dispatch. +type IDatafile_tempfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + Datafile_specification() IDatafile_specificationContext + Tempfile_specification() ITempfile_specificationContext + DROP() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + UNSIGNED_INTEGER() antlr.TerminalNode + KEEP() antlr.TerminalNode + Size_clause() ISize_clauseContext + SHRINK() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Online_or_offline() IOnline_or_offlineContext + + // IsDatafile_tempfile_clausesContext differentiates from other interfaces. + IsDatafile_tempfile_clausesContext() +} + +type Datafile_tempfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_tempfile_clausesContext() *Datafile_tempfile_clausesContext { + var p = new(Datafile_tempfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses + return p +} + +func InitEmptyDatafile_tempfile_clausesContext(p *Datafile_tempfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses +} + +func (*Datafile_tempfile_clausesContext) IsDatafile_tempfile_clausesContext() {} + +func NewDatafile_tempfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_tempfile_clausesContext { + var p = new(Datafile_tempfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses + + return p +} + +func (s *Datafile_tempfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_tempfile_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Datafile_tempfile_clausesContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Datafile_tempfile_clausesContext) Tempfile_specification() ITempfile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITempfile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITempfile_specificationContext) +} + +func (s *Datafile_tempfile_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Datafile_tempfile_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Datafile_tempfile_clausesContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Datafile_tempfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Datafile_tempfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Datafile_tempfile_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Datafile_tempfile_clausesContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Datafile_tempfile_clausesContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Datafile_tempfile_clausesContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Datafile_tempfile_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Datafile_tempfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Datafile_tempfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Datafile_tempfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Datafile_tempfile_clausesContext) Online_or_offline() IOnline_or_offlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOnline_or_offlineContext) +} + +func (s *Datafile_tempfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_tempfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_tempfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_tempfile_clauses(s) + } +} + +func (s *Datafile_tempfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_tempfile_clauses(s) + } +} + +func (p *PlSqlParser) Datafile_tempfile_clauses() (localctx IDatafile_tempfile_clausesContext) { + localctx = NewDatafile_tempfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, PlSqlParserRULE_datafile_tempfile_clauses) + var _la int + + p.SetState(9332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9286) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATAFILE: + { + p.SetState(9287) + p.Datafile_specification() + } + + case PlSqlParserTEMPFILE: + { + p.SetState(9288) + p.Tempfile_specification() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9291) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9292) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAFILE || _la == PlSqlParserTEMPFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(9295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9293) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9294) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(9297) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9298) + p.Size_clause() + } + + } + + case PlSqlParserSHRINK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9301) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9302) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9303) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9304) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(9307) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9308) + p.Size_clause() + } + + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9311) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9312) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9313) + p.Filename() + } + p.SetState(9318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9314) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9315) + p.Filename() + } + + p.SetState(9320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9321) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9322) + p.Filename() + } + p.SetState(9327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9323) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9324) + p.Filename() + } + + p.SetState(9329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDATAFILE, PlSqlParserTEMPFILE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9330) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAFILE || _la == PlSqlParserTEMPFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + { + p.SetState(9331) + p.Online_or_offline() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_logging_clausesContext is an interface to support dynamic dispatch. +type ITablespace_logging_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Logging_clause() ILogging_clauseContext + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsTablespace_logging_clausesContext differentiates from other interfaces. + IsTablespace_logging_clausesContext() +} + +type Tablespace_logging_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_logging_clausesContext() *Tablespace_logging_clausesContext { + var p = new(Tablespace_logging_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses + return p +} + +func InitEmptyTablespace_logging_clausesContext(p *Tablespace_logging_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses +} + +func (*Tablespace_logging_clausesContext) IsTablespace_logging_clausesContext() {} + +func NewTablespace_logging_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_logging_clausesContext { + var p = new(Tablespace_logging_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses + + return p +} + +func (s *Tablespace_logging_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_logging_clausesContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Tablespace_logging_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Tablespace_logging_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Tablespace_logging_clausesContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Tablespace_logging_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_logging_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_logging_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_logging_clauses(s) + } +} + +func (s *Tablespace_logging_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_logging_clauses(s) + } +} + +func (p *PlSqlParser) Tablespace_logging_clauses() (localctx ITablespace_logging_clausesContext) { + localctx = NewTablespace_logging_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, PlSqlParserRULE_tablespace_logging_clauses) + var _la int + + p.SetState(9340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9334) + p.Logging_clause() + } + + case PlSqlParserFORCE, PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + p.SetState(9336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(9335) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9338) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9339) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_group_clauseContext is an interface to support dynamic dispatch. +type ITablespace_group_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + GROUP() antlr.TerminalNode + Tablespace_group_name() ITablespace_group_nameContext + CHAR_STRING() antlr.TerminalNode + + // IsTablespace_group_clauseContext differentiates from other interfaces. + IsTablespace_group_clauseContext() +} + +type Tablespace_group_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_group_clauseContext() *Tablespace_group_clauseContext { + var p = new(Tablespace_group_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause + return p +} + +func InitEmptyTablespace_group_clauseContext(p *Tablespace_group_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause +} + +func (*Tablespace_group_clauseContext) IsTablespace_group_clauseContext() {} + +func NewTablespace_group_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_group_clauseContext { + var p = new(Tablespace_group_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause + + return p +} + +func (s *Tablespace_group_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_group_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Tablespace_group_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Tablespace_group_clauseContext) Tablespace_group_name() ITablespace_group_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Tablespace_group_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Tablespace_group_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_group_clause(s) + } +} + +func (s *Tablespace_group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_group_clause(s) + } +} + +func (p *PlSqlParser) Tablespace_group_clause() (localctx ITablespace_group_clauseContext) { + localctx = NewTablespace_group_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, PlSqlParserRULE_tablespace_group_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9342) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9343) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + { + p.SetState(9344) + p.Tablespace_group_name() + } + + case PlSqlParserCHAR_STRING: + { + p.SetState(9345) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_group_nameContext is an interface to support dynamic dispatch. +type ITablespace_group_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsTablespace_group_nameContext differentiates from other interfaces. + IsTablespace_group_nameContext() +} + +type Tablespace_group_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_group_nameContext() *Tablespace_group_nameContext { + var p = new(Tablespace_group_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_name + return p +} + +func InitEmptyTablespace_group_nameContext(p *Tablespace_group_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_name +} + +func (*Tablespace_group_nameContext) IsTablespace_group_nameContext() {} + +func NewTablespace_group_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_group_nameContext { + var p = new(Tablespace_group_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_group_name + + return p +} + +func (s *Tablespace_group_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_group_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Tablespace_group_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_group_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_group_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_group_name(s) + } +} + +func (s *Tablespace_group_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_group_name(s) + } +} + +func (p *PlSqlParser) Tablespace_group_name() (localctx ITablespace_group_nameContext) { + localctx = NewTablespace_group_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, PlSqlParserRULE_tablespace_group_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9348) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_state_clausesContext is an interface to support dynamic dispatch. +type ITablespace_state_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + NORMAL() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + PERMANENT() antlr.TerminalNode + + // IsTablespace_state_clausesContext differentiates from other interfaces. + IsTablespace_state_clausesContext() +} + +type Tablespace_state_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_state_clausesContext() *Tablespace_state_clausesContext { + var p = new(Tablespace_state_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses + return p +} + +func InitEmptyTablespace_state_clausesContext(p *Tablespace_state_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses +} + +func (*Tablespace_state_clausesContext) IsTablespace_state_clausesContext() {} + +func NewTablespace_state_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_state_clausesContext { + var p = new(Tablespace_state_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses + + return p +} + +func (s *Tablespace_state_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_state_clausesContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Tablespace_state_clausesContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Tablespace_state_clausesContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Tablespace_state_clausesContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Tablespace_state_clausesContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Tablespace_state_clausesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Tablespace_state_clausesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Tablespace_state_clausesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Tablespace_state_clausesContext) PERMANENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMANENT, 0) +} + +func (s *Tablespace_state_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_state_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_state_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_state_clauses(s) + } +} + +func (s *Tablespace_state_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_state_clauses(s) + } +} + +func (p *PlSqlParser) Tablespace_state_clauses() (localctx ITablespace_state_clausesContext) { + localctx = NewTablespace_state_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, PlSqlParserRULE_tablespace_state_clauses) + var _la int + + p.SetState(9359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9350) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9351) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIMMEDIATE || _la == PlSqlParserNORMAL || _la == PlSqlParserTEMPORARY { + { + p.SetState(9352) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIMMEDIATE || _la == PlSqlParserNORMAL || _la == PlSqlParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case PlSqlParserREAD: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9355) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9356) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPERMANENT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9357) + p.Match(PlSqlParserPERMANENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTEMPORARY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9358) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_mode_clauseContext is an interface to support dynamic dispatch. +type IFlashback_mode_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLASHBACK() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsFlashback_mode_clauseContext differentiates from other interfaces. + IsFlashback_mode_clauseContext() +} + +type Flashback_mode_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_mode_clauseContext() *Flashback_mode_clauseContext { + var p = new(Flashback_mode_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause + return p +} + +func InitEmptyFlashback_mode_clauseContext(p *Flashback_mode_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause +} + +func (*Flashback_mode_clauseContext) IsFlashback_mode_clauseContext() {} + +func NewFlashback_mode_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_mode_clauseContext { + var p = new(Flashback_mode_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause + + return p +} + +func (s *Flashback_mode_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_mode_clauseContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_mode_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Flashback_mode_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Flashback_mode_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_mode_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_mode_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_mode_clause(s) + } +} + +func (s *Flashback_mode_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_mode_clause(s) + } +} + +func (p *PlSqlParser) Flashback_mode_clause() (localctx IFlashback_mode_clauseContext) { + localctx = NewFlashback_mode_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, PlSqlParserRULE_flashback_mode_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9361) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9362) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_tablespace_nameContext is an interface to support dynamic dispatch. +type INew_tablespace_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tablespace() ITablespaceContext + + // IsNew_tablespace_nameContext differentiates from other interfaces. + IsNew_tablespace_nameContext() +} + +type New_tablespace_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_tablespace_nameContext() *New_tablespace_nameContext { + var p = new(New_tablespace_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_tablespace_name + return p +} + +func InitEmptyNew_tablespace_nameContext(p *New_tablespace_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_tablespace_name +} + +func (*New_tablespace_nameContext) IsNew_tablespace_nameContext() {} + +func NewNew_tablespace_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_tablespace_nameContext { + var p = new(New_tablespace_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_tablespace_name + + return p +} + +func (s *New_tablespace_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_tablespace_nameContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *New_tablespace_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_tablespace_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_tablespace_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_tablespace_name(s) + } +} + +func (s *New_tablespace_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_tablespace_name(s) + } +} + +func (p *PlSqlParser) New_tablespace_name() (localctx INew_tablespace_nameContext) { + localctx = NewNew_tablespace_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, PlSqlParserRULE_new_tablespace_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9364) + p.Tablespace() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_tablespaceContext is an interface to support dynamic dispatch. +type ICreate_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + Permanent_tablespace_clause() IPermanent_tablespace_clauseContext + Temporary_tablespace_clause() ITemporary_tablespace_clauseContext + Undo_tablespace_clause() IUndo_tablespace_clauseContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + + // IsCreate_tablespaceContext differentiates from other interfaces. + IsCreate_tablespaceContext() +} + +type Create_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tablespaceContext() *Create_tablespaceContext { + var p = new(Create_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace + return p +} + +func InitEmptyCreate_tablespaceContext(p *Create_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace +} + +func (*Create_tablespaceContext) IsCreate_tablespaceContext() {} + +func NewCreate_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tablespaceContext { + var p = new(Create_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_tablespace + + return p +} + +func (s *Create_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tablespaceContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tablespaceContext) Permanent_tablespace_clause() IPermanent_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPermanent_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPermanent_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) Temporary_tablespace_clause() ITemporary_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemporary_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemporary_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) Undo_tablespace_clause() IUndo_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Create_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Create_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_tablespace(s) + } +} + +func (s *Create_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_tablespace(s) + } +} + +func (p *PlSqlParser) Create_tablespace() (localctx ICreate_tablespaceContext) { + localctx = NewCreate_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, PlSqlParserRULE_create_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9366) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(9367) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(9370) + p.Permanent_tablespace_clause() + } + + case PlSqlParserTEMPORARY: + { + p.SetState(9371) + p.Temporary_tablespace_clause() + } + + case PlSqlParserUNDO: + { + p.SetState(9372) + p.Undo_tablespace_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPermanent_tablespace_clauseContext is an interface to support dynamic dispatch. +type IPermanent_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Datafile_specification() IDatafile_specificationContext + AllMINIMUM() []antlr.TerminalNode + MINIMUM(i int) antlr.TerminalNode + AllEXTENT() []antlr.TerminalNode + EXTENT(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllBLOCKSIZE() []antlr.TerminalNode + BLOCKSIZE(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllLOGGING() []antlr.TerminalNode + LOGGING(i int) antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllTablespace_encryption_spec() []ITablespace_encryption_specContext + Tablespace_encryption_spec(i int) ITablespace_encryption_specContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllExtent_management_clause() []IExtent_management_clauseContext + Extent_management_clause(i int) IExtent_management_clauseContext + AllSegment_management_clause() []ISegment_management_clauseContext + Segment_management_clause(i int) ISegment_management_clauseContext + AllFlashback_mode_clause() []IFlashback_mode_clauseContext + Flashback_mode_clause(i int) IFlashback_mode_clauseContext + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + AllOFFLINE() []antlr.TerminalNode + OFFLINE(i int) antlr.TerminalNode + + // IsPermanent_tablespace_clauseContext differentiates from other interfaces. + IsPermanent_tablespace_clauseContext() +} + +type Permanent_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPermanent_tablespace_clauseContext() *Permanent_tablespace_clauseContext { + var p = new(Permanent_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause + return p +} + +func InitEmptyPermanent_tablespace_clauseContext(p *Permanent_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause +} + +func (*Permanent_tablespace_clauseContext) IsPermanent_tablespace_clauseContext() {} + +func NewPermanent_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Permanent_tablespace_clauseContext { + var p = new(Permanent_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause + + return p +} + +func (s *Permanent_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Permanent_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Permanent_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Permanent_tablespace_clauseContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Permanent_tablespace_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Permanent_tablespace_clauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Permanent_tablespace_clauseContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Permanent_tablespace_clauseContext) AllMINIMUM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINIMUM) +} + +func (s *Permanent_tablespace_clauseContext) MINIMUM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, i) +} + +func (s *Permanent_tablespace_clauseContext) AllEXTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEXTENT) +} + +func (s *Permanent_tablespace_clauseContext) EXTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, i) +} + +func (s *Permanent_tablespace_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllBLOCKSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBLOCKSIZE) +} + +func (s *Permanent_tablespace_clauseContext) BLOCKSIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Permanent_tablespace_clauseContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllLOGGING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGGING) +} + +func (s *Permanent_tablespace_clauseContext) LOGGING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, i) +} + +func (s *Permanent_tablespace_clauseContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPTION) +} + +func (s *Permanent_tablespace_clauseContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, i) +} + +func (s *Permanent_tablespace_clauseContext) AllTablespace_encryption_spec() []ITablespace_encryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + len++ + } + } + + tst := make([]ITablespace_encryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_encryption_specContext); ok { + tst[i] = t.(ITablespace_encryption_specContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Tablespace_encryption_spec(i int) ITablespace_encryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Permanent_tablespace_clauseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Permanent_tablespace_clauseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Permanent_tablespace_clauseContext) AllExtent_management_clause() []IExtent_management_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + len++ + } + } + + tst := make([]IExtent_management_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtent_management_clauseContext); ok { + tst[i] = t.(IExtent_management_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Extent_management_clause(i int) IExtent_management_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllSegment_management_clause() []ISegment_management_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_management_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_management_clauseContext); ok { + tst[i] = t.(ISegment_management_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Segment_management_clause(i int) ISegment_management_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_management_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllFlashback_mode_clause() []IFlashback_mode_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_mode_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_mode_clauseContext); ok { + tst[i] = t.(IFlashback_mode_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Flashback_mode_clause(i int) IFlashback_mode_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Permanent_tablespace_clauseContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllOFFLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOFFLINE) +} + +func (s *Permanent_tablespace_clauseContext) OFFLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, i) +} + +func (s *Permanent_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Permanent_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Permanent_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPermanent_tablespace_clause(s) + } +} + +func (s *Permanent_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPermanent_tablespace_clause(s) + } +} + +func (p *PlSqlParser) Permanent_tablespace_clause() (localctx IPermanent_tablespace_clauseContext) { + localctx = NewPermanent_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, PlSqlParserRULE_permanent_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9375) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9376) + p.Id_expression() + } + p.SetState(9380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(9377) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9378) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9379) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9382) + p.Datafile_specification() + } + + } + p.SetState(9402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserBLOCKSIZE || _la == PlSqlParserDEFAULT || _la == PlSqlParserENCRYPTION || _la == PlSqlParserEXTENT || ((int64((_la-593)) & ^0x3f) == 0 && ((int64(1)<<(_la-593))&8392705) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMINIMUM || _la == PlSqlParserNOLOGGING || _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE || _la == PlSqlParserSEGMENT { + p.SetState(9400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMINIMUM: + { + p.SetState(9385) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9386) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9387) + p.Size_clause() + } + + case PlSqlParserBLOCKSIZE: + { + p.SetState(9388) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9389) + p.Size_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(9390) + p.Logging_clause() + } + + case PlSqlParserFORCE: + { + p.SetState(9391) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9392) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE, PlSqlParserONLINE: + { + p.SetState(9393) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserENCRYPTION: + { + p.SetState(9394) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9395) + p.Tablespace_encryption_spec() + } + + case PlSqlParserDEFAULT: + { + p.SetState(9396) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENT: + { + p.SetState(9397) + p.Extent_management_clause() + } + + case PlSqlParserSEGMENT: + { + p.SetState(9398) + p.Segment_management_clause() + } + + case PlSqlParserFLASHBACK: + { + p.SetState(9399) + p.Flashback_mode_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_encryption_specContext is an interface to support dynamic dispatch. +type ITablespace_encryption_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEncrypt_algorithm returns the encrypt_algorithm token. + GetEncrypt_algorithm() antlr.Token + + // SetEncrypt_algorithm sets the encrypt_algorithm token. + SetEncrypt_algorithm(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsTablespace_encryption_specContext differentiates from other interfaces. + IsTablespace_encryption_specContext() +} + +type Tablespace_encryption_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + encrypt_algorithm antlr.Token +} + +func NewEmptyTablespace_encryption_specContext() *Tablespace_encryption_specContext { + var p = new(Tablespace_encryption_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec + return p +} + +func InitEmptyTablespace_encryption_specContext(p *Tablespace_encryption_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec +} + +func (*Tablespace_encryption_specContext) IsTablespace_encryption_specContext() {} + +func NewTablespace_encryption_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_encryption_specContext { + var p = new(Tablespace_encryption_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec + + return p +} + +func (s *Tablespace_encryption_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_encryption_specContext) GetEncrypt_algorithm() antlr.Token { + return s.encrypt_algorithm +} + +func (s *Tablespace_encryption_specContext) SetEncrypt_algorithm(v antlr.Token) { + s.encrypt_algorithm = v +} + +func (s *Tablespace_encryption_specContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Tablespace_encryption_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Tablespace_encryption_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_encryption_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_encryption_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_encryption_spec(s) + } +} + +func (s *Tablespace_encryption_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_encryption_spec(s) + } +} + +func (p *PlSqlParser) Tablespace_encryption_spec() (localctx ITablespace_encryption_specContext) { + localctx = NewTablespace_encryption_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, PlSqlParserRULE_tablespace_encryption_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9405) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9406) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Tablespace_encryption_specContext).encrypt_algorithm = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogging_clauseContext is an interface to support dynamic dispatch. +type ILogging_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGGING() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode + + // IsLogging_clauseContext differentiates from other interfaces. + IsLogging_clauseContext() +} + +type Logging_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogging_clauseContext() *Logging_clauseContext { + var p = new(Logging_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logging_clause + return p +} + +func InitEmptyLogging_clauseContext(p *Logging_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logging_clause +} + +func (*Logging_clauseContext) IsLogging_clauseContext() {} + +func NewLogging_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logging_clauseContext { + var p = new(Logging_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logging_clause + + return p +} + +func (s *Logging_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logging_clauseContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Logging_clauseContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Logging_clauseContext) FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESYSTEM_LIKE_LOGGING, 0) +} + +func (s *Logging_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logging_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logging_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogging_clause(s) + } +} + +func (s *Logging_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogging_clause(s) + } +} + +func (p *PlSqlParser) Logging_clause() (localctx ILogging_clauseContext) { + localctx = NewLogging_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 886, PlSqlParserRULE_logging_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9408) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtent_management_clauseContext is an interface to support dynamic dispatch. +type IExtent_management_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTENT() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + AUTOALLOCATE() antlr.TerminalNode + UNIFORM() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsExtent_management_clauseContext differentiates from other interfaces. + IsExtent_management_clauseContext() +} + +type Extent_management_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtent_management_clauseContext() *Extent_management_clauseContext { + var p = new(Extent_management_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extent_management_clause + return p +} + +func InitEmptyExtent_management_clauseContext(p *Extent_management_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extent_management_clause +} + +func (*Extent_management_clauseContext) IsExtent_management_clauseContext() {} + +func NewExtent_management_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extent_management_clauseContext { + var p = new(Extent_management_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_extent_management_clause + + return p +} + +func (s *Extent_management_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extent_management_clauseContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Extent_management_clauseContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Extent_management_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Extent_management_clauseContext) AUTOALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOALLOCATE, 0) +} + +func (s *Extent_management_clauseContext) UNIFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIFORM, 0) +} + +func (s *Extent_management_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Extent_management_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Extent_management_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extent_management_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extent_management_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExtent_management_clause(s) + } +} + +func (s *Extent_management_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExtent_management_clause(s) + } +} + +func (p *PlSqlParser) Extent_management_clause() (localctx IExtent_management_clauseContext) { + localctx = NewExtent_management_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, PlSqlParserRULE_extent_management_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9410) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9411) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9412) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserAUTOALLOCATE: + { + p.SetState(9413) + p.Match(PlSqlParserAUTOALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIFORM: + { + p.SetState(9414) + p.Match(PlSqlParserUNIFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(9415) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9416) + p.Size_clause() + } + + } + + case PlSqlParserEOF, PlSqlParserARCHIVELOG, PlSqlParserBIGFILE, PlSqlParserBLOCKSIZE, PlSqlParserCHARACTER, PlSqlParserCONTROLFILE, PlSqlParserDATAFILE, PlSqlParserDEFAULT, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserENCRYPTION, PlSqlParserEXTENT, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFLASHBACK, PlSqlParserFORCE, PlSqlParserLOGFILE, PlSqlParserLOGGING, PlSqlParserMAXDATAFILES, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMINIMUM, PlSqlParserNATIONAL, PlSqlParserNOARCHIVELOG, PlSqlParserNOLOGGING, PlSqlParserOFFLINE, PlSqlParserONLINE, PlSqlParserREMOVE, PlSqlParserRETENTION, PlSqlParserSEGMENT, PlSqlParserSET, PlSqlParserSMALLFILE, PlSqlParserSUSPEND, PlSqlParserSYSAUX, PlSqlParserUNDO, PlSqlParserUSER_DATA, PlSqlParserUSER, PlSqlParserRIGHT_PAREN, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISegment_management_clauseContext is an interface to support dynamic dispatch. +type ISegment_management_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + AUTO() antlr.TerminalNode + MANUAL() antlr.TerminalNode + + // IsSegment_management_clauseContext differentiates from other interfaces. + IsSegment_management_clauseContext() +} + +type Segment_management_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySegment_management_clauseContext() *Segment_management_clauseContext { + var p = new(Segment_management_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_management_clause + return p +} + +func InitEmptySegment_management_clauseContext(p *Segment_management_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_management_clause +} + +func (*Segment_management_clauseContext) IsSegment_management_clauseContext() {} + +func NewSegment_management_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_management_clauseContext { + var p = new(Segment_management_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_management_clause + + return p +} + +func (s *Segment_management_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_management_clauseContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Segment_management_clauseContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Segment_management_clauseContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Segment_management_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Segment_management_clauseContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Segment_management_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_management_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_management_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_management_clause(s) + } +} + +func (s *Segment_management_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_management_clause(s) + } +} + +func (p *PlSqlParser) Segment_management_clause() (localctx ISegment_management_clauseContext) { + localctx = NewSegment_management_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, PlSqlParserRULE_segment_management_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9421) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9422) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9423) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9424) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTO || _la == PlSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITemporary_tablespace_clauseContext is an interface to support dynamic dispatch. +type ITemporary_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + TEMPORARY() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Tempfile_specification() ITempfile_specificationContext + Tablespace_group_clause() ITablespace_group_clauseContext + Extent_management_clause() IExtent_management_clauseContext + + // IsTemporary_tablespace_clauseContext differentiates from other interfaces. + IsTemporary_tablespace_clauseContext() +} + +type Temporary_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyTemporary_tablespace_clauseContext() *Temporary_tablespace_clauseContext { + var p = new(Temporary_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause + return p +} + +func InitEmptyTemporary_tablespace_clauseContext(p *Temporary_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause +} + +func (*Temporary_tablespace_clauseContext) IsTemporary_tablespace_clauseContext() {} + +func NewTemporary_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Temporary_tablespace_clauseContext { + var p = new(Temporary_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause + + return p +} + +func (s *Temporary_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Temporary_tablespace_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Temporary_tablespace_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Temporary_tablespace_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Temporary_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Temporary_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Temporary_tablespace_clauseContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Temporary_tablespace_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Temporary_tablespace_clauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Temporary_tablespace_clauseContext) Tempfile_specification() ITempfile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITempfile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITempfile_specificationContext) +} + +func (s *Temporary_tablespace_clauseContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Temporary_tablespace_clauseContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Temporary_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Temporary_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Temporary_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTemporary_tablespace_clause(s) + } +} + +func (s *Temporary_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTemporary_tablespace_clause(s) + } +} + +func (p *PlSqlParser) Temporary_tablespace_clause() (localctx ITemporary_tablespace_clauseContext) { + localctx = NewTemporary_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, PlSqlParserRULE_temporary_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9426) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9427) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9428) + + var _x = p.Id_expression() + + localctx.(*Temporary_tablespace_clauseContext).tablespace_name = _x + } + p.SetState(9432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(9429) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9430) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9431) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTEMPFILE { + { + p.SetState(9434) + p.Tempfile_specification() + } + + } + p.SetState(9438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(9437) + p.Tablespace_group_clause() + } + + } + p.SetState(9441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENT { + { + p.SetState(9440) + p.Extent_management_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndo_tablespace_clauseContext is an interface to support dynamic dispatch. +type IUndo_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + UNDO() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Datafile_specification() IDatafile_specificationContext + Extent_management_clause() IExtent_management_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + + // IsUndo_tablespace_clauseContext differentiates from other interfaces. + IsUndo_tablespace_clauseContext() +} + +type Undo_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyUndo_tablespace_clauseContext() *Undo_tablespace_clauseContext { + var p = new(Undo_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause + return p +} + +func InitEmptyUndo_tablespace_clauseContext(p *Undo_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause +} + +func (*Undo_tablespace_clauseContext) IsUndo_tablespace_clauseContext() {} + +func NewUndo_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_tablespace_clauseContext { + var p = new(Undo_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause + + return p +} + +func (s *Undo_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_tablespace_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Undo_tablespace_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Undo_tablespace_clauseContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Undo_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Undo_tablespace_clauseContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Undo_tablespace_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Undo_tablespace_clauseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Undo_tablespace_clauseContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Undo_tablespace_clauseContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Undo_tablespace_clauseContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Undo_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_tablespace_clause(s) + } +} + +func (s *Undo_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_tablespace_clause(s) + } +} + +func (p *PlSqlParser) Undo_tablespace_clause() (localctx IUndo_tablespace_clauseContext) { + localctx = NewUndo_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, PlSqlParserRULE_undo_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9443) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9444) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9445) + + var _x = p.Id_expression() + + localctx.(*Undo_tablespace_clauseContext).tablespace_name = _x + } + p.SetState(9449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(9446) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9447) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9448) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9451) + p.Datafile_specification() + } + + } + p.SetState(9455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENT { + { + p.SetState(9454) + p.Extent_management_clause() + } + + } + p.SetState(9458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETENTION { + { + p.SetState(9457) + p.Tablespace_retention_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_retention_clauseContext is an interface to support dynamic dispatch. +type ITablespace_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + NOGUARANTEE() antlr.TerminalNode + + // IsTablespace_retention_clauseContext differentiates from other interfaces. + IsTablespace_retention_clauseContext() +} + +type Tablespace_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_retention_clauseContext() *Tablespace_retention_clauseContext { + var p = new(Tablespace_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause + return p +} + +func InitEmptyTablespace_retention_clauseContext(p *Tablespace_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause +} + +func (*Tablespace_retention_clauseContext) IsTablespace_retention_clauseContext() {} + +func NewTablespace_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_retention_clauseContext { + var p = new(Tablespace_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause + + return p +} + +func (s *Tablespace_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_retention_clauseContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Tablespace_retention_clauseContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Tablespace_retention_clauseContext) NOGUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOGUARANTEE, 0) +} + +func (s *Tablespace_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_retention_clause(s) + } +} + +func (s *Tablespace_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_retention_clause(s) + } +} + +func (p *PlSqlParser) Tablespace_retention_clause() (localctx ITablespace_retention_clauseContext) { + localctx = NewTablespace_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, PlSqlParserRULE_tablespace_retention_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9460) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9461) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGUARANTEE || _la == PlSqlParserNOGUARANTEE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_tablespace_setContext is an interface to support dynamic dispatch. +type ICreate_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // GetSs returns the ss rule contexts. + GetSs() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // SetSs sets the ss rule contexts. + SetSs(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + IN() antlr.TerminalNode + SHARDSPACE() antlr.TerminalNode + USING() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllPermanent_tablespace_attrs() []IPermanent_tablespace_attrsContext + Permanent_tablespace_attrs(i int) IPermanent_tablespace_attrsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_tablespace_setContext differentiates from other interfaces. + IsCreate_tablespace_setContext() +} + +type Create_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext + ss IId_expressionContext +} + +func NewEmptyCreate_tablespace_setContext() *Create_tablespace_setContext { + var p = new(Create_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace_set + return p +} + +func InitEmptyCreate_tablespace_setContext(p *Create_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace_set +} + +func (*Create_tablespace_setContext) IsCreate_tablespace_setContext() {} + +func NewCreate_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tablespace_setContext { + var p = new(Create_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_tablespace_set + + return p +} + +func (s *Create_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Create_tablespace_setContext) GetSs() IId_expressionContext { return s.ss } + +func (s *Create_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Create_tablespace_setContext) SetSs(v IId_expressionContext) { s.ss = v } + +func (s *Create_tablespace_setContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Create_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Create_tablespace_setContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_tablespace_setContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Create_tablespace_setContext) SHARDSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDSPACE, 0) +} + +func (s *Create_tablespace_setContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_tablespace_setContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Create_tablespace_setContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_tablespace_setContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_tablespace_setContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_tablespace_setContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Create_tablespace_setContext) AllPermanent_tablespace_attrs() []IPermanent_tablespace_attrsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + len++ + } + } + + tst := make([]IPermanent_tablespace_attrsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + tst[i] = t.(IPermanent_tablespace_attrsContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) Permanent_tablespace_attrs(i int) IPermanent_tablespace_attrsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPermanent_tablespace_attrsContext) +} + +func (s *Create_tablespace_setContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_tablespace_setContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_tablespace_set(s) + } +} + +func (s *Create_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_tablespace_set(s) + } +} + +func (p *PlSqlParser) Create_tablespace_set() (localctx ICreate_tablespace_setContext) { + localctx = NewCreate_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, PlSqlParserRULE_create_tablespace_set) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9463) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9464) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9465) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9466) + + var _x = p.Id_expression() + + localctx.(*Create_tablespace_setContext).tss = _x + } + p.SetState(9470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIN { + { + p.SetState(9467) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9468) + p.Match(PlSqlParserSHARDSPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9469) + + var _x = p.Id_expression() + + localctx.(*Create_tablespace_setContext).ss = _x + } + + } + p.SetState(9493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(9472) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9473) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9474) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9475) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9476) + p.File_specification() + } + p.SetState(9481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9477) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9478) + p.File_specification() + } + + p.SetState(9483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(9487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBLOCKSIZE || _la == PlSqlParserDEFAULT || _la == PlSqlParserDISABLE || ((int64((_la-499)) & ^0x3f) == 0 && ((int64(1)<<(_la-499))&576460752303423617) != 0) || ((int64((_la-593)) & ^0x3f) == 0 && ((int64(1)<<(_la-593))&8392705) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMINIMUM || _la == PlSqlParserNOLOGGING || _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE || _la == PlSqlParserREMOVE || _la == PlSqlParserSEGMENT || _la == PlSqlParserSUSPEND { + { + p.SetState(9486) + p.Permanent_tablespace_attrs() + } + + p.SetState(9489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9491) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPermanent_tablespace_attrsContext is an interface to support dynamic dispatch. +type IPermanent_tablespace_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + BLOCKSIZE() antlr.TerminalNode + Numeric() INumericContext + K_LETTER() antlr.TerminalNode + Logging_clause() ILogging_clauseContext + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + Tablespace_encryption_clause() ITablespace_encryption_clauseContext + Default_tablespace_params() IDefault_tablespace_paramsContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + Extent_management_clause() IExtent_management_clauseContext + Segment_management_clause() ISegment_management_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Lost_write_protection() ILost_write_protectionContext + + // IsPermanent_tablespace_attrsContext differentiates from other interfaces. + IsPermanent_tablespace_attrsContext() +} + +type Permanent_tablespace_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPermanent_tablespace_attrsContext() *Permanent_tablespace_attrsContext { + var p = new(Permanent_tablespace_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs + return p +} + +func InitEmptyPermanent_tablespace_attrsContext(p *Permanent_tablespace_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs +} + +func (*Permanent_tablespace_attrsContext) IsPermanent_tablespace_attrsContext() {} + +func NewPermanent_tablespace_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Permanent_tablespace_attrsContext { + var p = new(Permanent_tablespace_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs + + return p +} + +func (s *Permanent_tablespace_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Permanent_tablespace_attrsContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Permanent_tablespace_attrsContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Permanent_tablespace_attrsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Permanent_tablespace_attrsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Permanent_tablespace_attrsContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Permanent_tablespace_attrsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Permanent_tablespace_attrsContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Permanent_tablespace_attrsContext) Tablespace_encryption_clause() ITablespace_encryption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Default_tablespace_params() IDefault_tablespace_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespace_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespace_paramsContext) +} + +func (s *Permanent_tablespace_attrsContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Permanent_tablespace_attrsContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Permanent_tablespace_attrsContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Segment_management_clause() ISegment_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_management_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Permanent_tablespace_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Permanent_tablespace_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Permanent_tablespace_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPermanent_tablespace_attrs(s) + } +} + +func (s *Permanent_tablespace_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPermanent_tablespace_attrs(s) + } +} + +func (p *PlSqlParser) Permanent_tablespace_attrs() (localctx IPermanent_tablespace_attrsContext) { + localctx = NewPermanent_tablespace_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, PlSqlParserRULE_permanent_tablespace_attrs) + var _la int + + p.SetState(9514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMINIMUM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9495) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9496) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9497) + p.Size_clause() + } + + case PlSqlParserBLOCKSIZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9498) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9499) + p.Numeric() + } + p.SetState(9501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserK_LETTER { + { + p.SetState(9500) + p.Match(PlSqlParserK_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9503) + p.Logging_clause() + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9504) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9505) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9506) + p.Tablespace_encryption_clause() + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9507) + p.Default_tablespace_params() + } + + case PlSqlParserONLINE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9508) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9509) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9510) + p.Extent_management_clause() + } + + case PlSqlParserSEGMENT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9511) + p.Segment_management_clause() + } + + case PlSqlParserFLASHBACK: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9512) + p.Flashback_mode_clause() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserREMOVE, PlSqlParserSUSPEND: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9513) + p.Lost_write_protection() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_encryption_clauseContext is an interface to support dynamic dispatch. +type ITablespace_encryption_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + Tablespace_encryption_spec() ITablespace_encryption_specContext + + // IsTablespace_encryption_clauseContext differentiates from other interfaces. + IsTablespace_encryption_clauseContext() +} + +type Tablespace_encryption_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_encryption_clauseContext() *Tablespace_encryption_clauseContext { + var p = new(Tablespace_encryption_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause + return p +} + +func InitEmptyTablespace_encryption_clauseContext(p *Tablespace_encryption_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause +} + +func (*Tablespace_encryption_clauseContext) IsTablespace_encryption_clauseContext() {} + +func NewTablespace_encryption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_encryption_clauseContext { + var p = new(Tablespace_encryption_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause + + return p +} + +func (s *Tablespace_encryption_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_encryption_clauseContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Tablespace_encryption_clauseContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Tablespace_encryption_clauseContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Tablespace_encryption_clauseContext) Tablespace_encryption_spec() ITablespace_encryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Tablespace_encryption_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_encryption_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_encryption_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_encryption_clause(s) + } +} + +func (s *Tablespace_encryption_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_encryption_clause(s) + } +} + +func (p *PlSqlParser) Tablespace_encryption_clause() (localctx ITablespace_encryption_clauseContext) { + localctx = NewTablespace_encryption_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, PlSqlParserRULE_tablespace_encryption_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9516) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserUSING: + p.SetState(9518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(9517) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(9520) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(9521) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_tablespace_paramsContext is an interface to support dynamic dispatch. +type IDefault_tablespace_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Default_table_compression() IDefault_table_compressionContext + Default_index_compression() IDefault_index_compressionContext + Inmmemory_clause() IInmmemory_clauseContext + Ilm_clause() IIlm_clauseContext + Storage_clause() IStorage_clauseContext + + // IsDefault_tablespace_paramsContext differentiates from other interfaces. + IsDefault_tablespace_paramsContext() +} + +type Default_tablespace_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_tablespace_paramsContext() *Default_tablespace_paramsContext { + var p = new(Default_tablespace_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace_params + return p +} + +func InitEmptyDefault_tablespace_paramsContext(p *Default_tablespace_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace_params +} + +func (*Default_tablespace_paramsContext) IsDefault_tablespace_paramsContext() {} + +func NewDefault_tablespace_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_tablespace_paramsContext { + var p = new(Default_tablespace_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_tablespace_params + + return p +} + +func (s *Default_tablespace_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_tablespace_paramsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_tablespace_paramsContext) Default_table_compression() IDefault_table_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_table_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_table_compressionContext) +} + +func (s *Default_tablespace_paramsContext) Default_index_compression() IDefault_index_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_index_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_index_compressionContext) +} + +func (s *Default_tablespace_paramsContext) Inmmemory_clause() IInmmemory_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmmemory_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmmemory_clauseContext) +} + +func (s *Default_tablespace_paramsContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Default_tablespace_paramsContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Default_tablespace_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_tablespace_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_tablespace_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_tablespace_params(s) + } +} + +func (s *Default_tablespace_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_tablespace_params(s) + } +} + +func (p *PlSqlParser) Default_tablespace_params() (localctx IDefault_tablespace_paramsContext) { + localctx = NewDefault_tablespace_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 904, PlSqlParserRULE_default_tablespace_params) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9524) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLE { + { + p.SetState(9525) + p.Default_table_compression() + } + + } + p.SetState(9529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEX { + { + p.SetState(9528) + p.Default_index_compression() + } + + } + p.SetState(9532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINMEMORY || _la == PlSqlParserNO { + { + p.SetState(9531) + p.Inmmemory_clause() + } + + } + p.SetState(9535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserILM { + { + p.SetState(9534) + p.Ilm_clause() + } + + } + p.SetState(9538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORAGE { + { + p.SetState(9537) + p.Storage_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_table_compressionContext is an interface to support dynamic dispatch. +type IDefault_table_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + FOR() antlr.TerminalNode + NOCOMPRESS() antlr.TerminalNode + OLTP() antlr.TerminalNode + QUERY() antlr.TerminalNode + Low_high() ILow_highContext + ARCHIVE() antlr.TerminalNode + + // IsDefault_table_compressionContext differentiates from other interfaces. + IsDefault_table_compressionContext() +} + +type Default_table_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_table_compressionContext() *Default_table_compressionContext { + var p = new(Default_table_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_table_compression + return p +} + +func InitEmptyDefault_table_compressionContext(p *Default_table_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_table_compression +} + +func (*Default_table_compressionContext) IsDefault_table_compressionContext() {} + +func NewDefault_table_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_table_compressionContext { + var p = new(Default_table_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_table_compression + + return p +} + +func (s *Default_table_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_table_compressionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Default_table_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Default_table_compressionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Default_table_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Default_table_compressionContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Default_table_compressionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Default_table_compressionContext) Low_high() ILow_highContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_highContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_highContext) +} + +func (s *Default_table_compressionContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Default_table_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_table_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_table_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_table_compression(s) + } +} + +func (s *Default_table_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_table_compression(s) + } +} + +func (p *PlSqlParser) Default_table_compression() (localctx IDefault_table_compressionContext) { + localctx = NewDefault_table_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, PlSqlParserRULE_default_table_compression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9540) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + { + p.SetState(9541) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9542) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOLTP: + { + p.SetState(9543) + p.Match(PlSqlParserOLTP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserQUERY: + { + p.SetState(9544) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9545) + p.Low_high() + } + + case PlSqlParserARCHIVE: + { + p.SetState(9546) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9547) + p.Low_high() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserNOCOMPRESS: + { + p.SetState(9550) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILow_highContext is an interface to support dynamic dispatch. +type ILow_highContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + + // IsLow_highContext differentiates from other interfaces. + IsLow_highContext() +} + +type Low_highContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLow_highContext() *Low_highContext { + var p = new(Low_highContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_low_high + return p +} + +func InitEmptyLow_highContext(p *Low_highContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_low_high +} + +func (*Low_highContext) IsLow_highContext() {} + +func NewLow_highContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Low_highContext { + var p = new(Low_highContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_low_high + + return p +} + +func (s *Low_highContext) GetParser() antlr.Parser { return s.parser } + +func (s *Low_highContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Low_highContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Low_highContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Low_highContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Low_highContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLow_high(s) + } +} + +func (s *Low_highContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLow_high(s) + } +} + +func (p *PlSqlParser) Low_high() (localctx ILow_highContext) { + localctx = NewLow_highContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, PlSqlParserRULE_low_high) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9553) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_index_compressionContext is an interface to support dynamic dispatch. +type IDefault_index_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEX() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + Low_high() ILow_highContext + NOCOMPRESS() antlr.TerminalNode + + // IsDefault_index_compressionContext differentiates from other interfaces. + IsDefault_index_compressionContext() +} + +type Default_index_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_index_compressionContext() *Default_index_compressionContext { + var p = new(Default_index_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_index_compression + return p +} + +func InitEmptyDefault_index_compressionContext(p *Default_index_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_index_compression +} + +func (*Default_index_compressionContext) IsDefault_index_compressionContext() {} + +func NewDefault_index_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_index_compressionContext { + var p = new(Default_index_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_index_compression + + return p +} + +func (s *Default_index_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_index_compressionContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Default_index_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Default_index_compressionContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Default_index_compressionContext) Low_high() ILow_highContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_highContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_highContext) +} + +func (s *Default_index_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Default_index_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_index_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_index_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_index_compression(s) + } +} + +func (s *Default_index_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_index_compression(s) + } +} + +func (p *PlSqlParser) Default_index_compression() (localctx IDefault_index_compressionContext) { + localctx = NewDefault_index_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, PlSqlParserRULE_default_index_compression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9555) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + { + p.SetState(9556) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9557) + p.Match(PlSqlParserADVANCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9558) + p.Low_high() + } + + case PlSqlParserNOCOMPRESS: + { + p.SetState(9559) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmmemory_clauseContext is an interface to support dynamic dispatch. +type IInmmemory_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INMEMORY() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + TEXT() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllPolicy_name() []IPolicy_nameContext + Policy_name(i int) IPolicy_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmmemory_clauseContext differentiates from other interfaces. + IsInmmemory_clauseContext() +} + +type Inmmemory_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmmemory_clauseContext() *Inmmemory_clauseContext { + var p = new(Inmmemory_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmmemory_clause + return p +} + +func InitEmptyInmmemory_clauseContext(p *Inmmemory_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmmemory_clause +} + +func (*Inmmemory_clauseContext) IsInmmemory_clauseContext() {} + +func NewInmmemory_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmmemory_clauseContext { + var p = new(Inmmemory_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmmemory_clause + + return p +} + +func (s *Inmmemory_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmmemory_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmmemory_clauseContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Inmmemory_clauseContext) TEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEXT, 0) +} + +func (s *Inmmemory_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Inmmemory_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Inmmemory_clauseContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Inmmemory_clauseContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Inmmemory_clauseContext) AllPolicy_name() []IPolicy_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPolicy_nameContext); ok { + len++ + } + } + + tst := make([]IPolicy_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPolicy_nameContext); ok { + tst[i] = t.(IPolicy_nameContext) + i++ + } + } + + return tst +} + +func (s *Inmmemory_clauseContext) Policy_name(i int) IPolicy_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPolicy_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPolicy_nameContext) +} + +func (s *Inmmemory_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Inmmemory_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Inmmemory_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmmemory_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmmemory_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmmemory_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmmemory_clause(s) + } +} + +func (s *Inmmemory_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmmemory_clause(s) + } +} + +func (p *PlSqlParser) Inmmemory_clause() (localctx IInmmemory_clauseContext) { + localctx = NewInmmemory_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, PlSqlParserRULE_inmmemory_clause) + var _la int + + p.SetState(9594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9562) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISTRIBUTE || _la == PlSqlParserDUPLICATE || _la == PlSqlParserMEMCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserPRIORITY { + { + p.SetState(9563) + p.Inmemory_attributes() + } + + } + p.SetState(9590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTEXT { + { + p.SetState(9566) + p.Match(PlSqlParserTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1098, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9567) + p.Column_name() + } + p.SetState(9572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9568) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9569) + p.Column_name() + } + + p.SetState(9574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(9575) + p.Column_name() + } + { + p.SetState(9576) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9577) + p.Policy_name() + } + p.SetState(9585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9578) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9579) + p.Column_name() + } + { + p.SetState(9580) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9581) + p.Policy_name() + } + + p.SetState(9587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9592) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9593) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatafile_specificationContext is an interface to support dynamic dispatch. +type IDatafile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + COMMA() antlr.TerminalNode + + // IsDatafile_specificationContext differentiates from other interfaces. + IsDatafile_specificationContext() +} + +type Datafile_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_specificationContext() *Datafile_specificationContext { + var p = new(Datafile_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_specification + return p +} + +func InitEmptyDatafile_specificationContext(p *Datafile_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_specification +} + +func (*Datafile_specificationContext) IsDatafile_specificationContext() {} + +func NewDatafile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_specificationContext { + var p = new(Datafile_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_specification + + return p +} + +func (s *Datafile_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_specificationContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Datafile_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Datafile_specificationContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Datafile_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_specification(s) + } +} + +func (s *Datafile_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_specification(s) + } +} + +func (p *PlSqlParser) Datafile_specification() (localctx IDatafile_specificationContext) { + localctx = NewDatafile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, PlSqlParserRULE_datafile_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9596) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9597) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9600) + p.Datafile_tempfile_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITempfile_specificationContext is an interface to support dynamic dispatch. +type ITempfile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + COMMA() antlr.TerminalNode + + // IsTempfile_specificationContext differentiates from other interfaces. + IsTempfile_specificationContext() +} + +type Tempfile_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTempfile_specificationContext() *Tempfile_specificationContext { + var p = new(Tempfile_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tempfile_specification + return p +} + +func InitEmptyTempfile_specificationContext(p *Tempfile_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tempfile_specification +} + +func (*Tempfile_specificationContext) IsTempfile_specificationContext() {} + +func NewTempfile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tempfile_specificationContext { + var p = new(Tempfile_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tempfile_specification + + return p +} + +func (s *Tempfile_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tempfile_specificationContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Tempfile_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Tempfile_specificationContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Tempfile_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tempfile_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tempfile_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTempfile_specification(s) + } +} + +func (s *Tempfile_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTempfile_specification(s) + } +} + +func (p *PlSqlParser) Tempfile_specification() (localctx ITempfile_specificationContext) { + localctx = NewTempfile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, PlSqlParserRULE_tempfile_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9602) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9603) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9606) + p.Datafile_tempfile_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatafile_tempfile_specContext is an interface to support dynamic dispatch. +type IDatafile_tempfile_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + REUSE() antlr.TerminalNode + Autoextend_clause() IAutoextend_clauseContext + + // IsDatafile_tempfile_specContext differentiates from other interfaces. + IsDatafile_tempfile_specContext() +} + +type Datafile_tempfile_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_tempfile_specContext() *Datafile_tempfile_specContext { + var p = new(Datafile_tempfile_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec + return p +} + +func InitEmptyDatafile_tempfile_specContext(p *Datafile_tempfile_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec +} + +func (*Datafile_tempfile_specContext) IsDatafile_tempfile_specContext() {} + +func NewDatafile_tempfile_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_tempfile_specContext { + var p = new(Datafile_tempfile_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec + + return p +} + +func (s *Datafile_tempfile_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_tempfile_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Datafile_tempfile_specContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Datafile_tempfile_specContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Datafile_tempfile_specContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Datafile_tempfile_specContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Datafile_tempfile_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_tempfile_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_tempfile_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_tempfile_spec(s) + } +} + +func (s *Datafile_tempfile_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_tempfile_spec(s) + } +} + +func (p *PlSqlParser) Datafile_tempfile_spec() (localctx IDatafile_tempfile_specContext) { + localctx = NewDatafile_tempfile_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, PlSqlParserRULE_datafile_tempfile_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(9608) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(9611) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9612) + p.Size_clause() + } + + } + p.SetState(9616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(9615) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTOEXTEND { + { + p.SetState(9618) + p.Autoextend_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRedo_log_file_specContext is an interface to support dynamic dispatch. +type IRedo_log_file_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SIZE() antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + BLOCKSIZE() antlr.TerminalNode + REUSE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRedo_log_file_specContext differentiates from other interfaces. + IsRedo_log_file_specContext() +} + +type Redo_log_file_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedo_log_file_specContext() *Redo_log_file_specContext { + var p = new(Redo_log_file_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec + return p +} + +func InitEmptyRedo_log_file_specContext(p *Redo_log_file_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec +} + +func (*Redo_log_file_specContext) IsRedo_log_file_specContext() {} + +func NewRedo_log_file_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redo_log_file_specContext { + var p = new(Redo_log_file_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec + + return p +} + +func (s *Redo_log_file_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redo_log_file_specContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Redo_log_file_specContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Redo_log_file_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Redo_log_file_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Redo_log_file_specContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Redo_log_file_specContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Redo_log_file_specContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Redo_log_file_specContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Redo_log_file_specContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Redo_log_file_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Redo_log_file_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Redo_log_file_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redo_log_file_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redo_log_file_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRedo_log_file_spec(s) + } +} + +func (s *Redo_log_file_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRedo_log_file_spec(s) + } +} + +func (p *PlSqlParser) Redo_log_file_spec() (localctx IRedo_log_file_specContext) { + localctx = NewRedo_log_file_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, PlSqlParserRULE_redo_log_file_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9621) + p.Filename() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9622) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9623) + p.Filename() + } + p.SetState(9628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9624) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9625) + p.Filename() + } + + p.SetState(9630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9631) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(9635) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9636) + p.Size_clause() + } + + } + p.SetState(9641) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1110, p.GetParserRuleContext()) == 1 { + { + p.SetState(9639) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9640) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(9643) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAutoextend_clauseContext is an interface to support dynamic dispatch. +type IAutoextend_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTOEXTEND() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + NEXT() antlr.TerminalNode + Size_clause() ISize_clauseContext + Maxsize_clause() IMaxsize_clauseContext + + // IsAutoextend_clauseContext differentiates from other interfaces. + IsAutoextend_clauseContext() +} + +type Autoextend_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAutoextend_clauseContext() *Autoextend_clauseContext { + var p = new(Autoextend_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autoextend_clause + return p +} + +func InitEmptyAutoextend_clauseContext(p *Autoextend_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autoextend_clause +} + +func (*Autoextend_clauseContext) IsAutoextend_clauseContext() {} + +func NewAutoextend_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Autoextend_clauseContext { + var p = new(Autoextend_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_autoextend_clause + + return p +} + +func (s *Autoextend_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Autoextend_clauseContext) AUTOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOEXTEND, 0) +} + +func (s *Autoextend_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Autoextend_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Autoextend_clauseContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Autoextend_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Autoextend_clauseContext) Maxsize_clause() IMaxsize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaxsize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaxsize_clauseContext) +} + +func (s *Autoextend_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Autoextend_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Autoextend_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAutoextend_clause(s) + } +} + +func (s *Autoextend_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAutoextend_clause(s) + } +} + +func (p *PlSqlParser) Autoextend_clause() (localctx IAutoextend_clauseContext) { + localctx = NewAutoextend_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, PlSqlParserRULE_autoextend_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9646) + p.Match(PlSqlParserAUTOEXTEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOFF: + { + p.SetState(9647) + p.Match(PlSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserON: + { + p.SetState(9648) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNEXT { + { + p.SetState(9649) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9650) + p.Size_clause() + } + + } + p.SetState(9654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMAXSIZE { + { + p.SetState(9653) + p.Maxsize_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaxsize_clauseContext is an interface to support dynamic dispatch. +type IMaxsize_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXSIZE() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsMaxsize_clauseContext differentiates from other interfaces. + IsMaxsize_clauseContext() +} + +type Maxsize_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaxsize_clauseContext() *Maxsize_clauseContext { + var p = new(Maxsize_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maxsize_clause + return p +} + +func InitEmptyMaxsize_clauseContext(p *Maxsize_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maxsize_clause +} + +func (*Maxsize_clauseContext) IsMaxsize_clauseContext() {} + +func NewMaxsize_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maxsize_clauseContext { + var p = new(Maxsize_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_maxsize_clause + + return p +} + +func (s *Maxsize_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maxsize_clauseContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXSIZE, 0) +} + +func (s *Maxsize_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Maxsize_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Maxsize_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maxsize_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maxsize_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMaxsize_clause(s) + } +} + +func (s *Maxsize_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMaxsize_clause(s) + } +} + +func (p *PlSqlParser) Maxsize_clause() (localctx IMaxsize_clauseContext) { + localctx = NewMaxsize_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, PlSqlParserRULE_maxsize_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9658) + p.Match(PlSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNLIMITED: + { + p.SetState(9659) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9660) + p.Size_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBuild_clauseContext is an interface to support dynamic dispatch. +type IBuild_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BUILD() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + + // IsBuild_clauseContext differentiates from other interfaces. + IsBuild_clauseContext() +} + +type Build_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuild_clauseContext() *Build_clauseContext { + var p = new(Build_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_build_clause + return p +} + +func InitEmptyBuild_clauseContext(p *Build_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_build_clause +} + +func (*Build_clauseContext) IsBuild_clauseContext() {} + +func NewBuild_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Build_clauseContext { + var p = new(Build_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_build_clause + + return p +} + +func (s *Build_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Build_clauseContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *Build_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Build_clauseContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Build_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Build_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Build_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBuild_clause(s) + } +} + +func (s *Build_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBuild_clause(s) + } +} + +func (p *PlSqlParser) Build_clause() (localctx IBuild_clauseContext) { + localctx = NewBuild_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 926, PlSqlParserRULE_build_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9663) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9664) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParallel_clauseContext is an interface to support dynamic dispatch. +type IParallel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetParallel_count returns the parallel_count token. + GetParallel_count() antlr.Token + + // SetParallel_count sets the parallel_count token. + SetParallel_count(antlr.Token) + + // Getter signatures + NOPARALLEL() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + DEGREE() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Parallel_instances_clause() IParallel_instances_clauseContext + + // IsParallel_clauseContext differentiates from other interfaces. + IsParallel_clauseContext() +} + +type Parallel_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + parallel_count antlr.Token +} + +func NewEmptyParallel_clauseContext() *Parallel_clauseContext { + var p = new(Parallel_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_clause + return p +} + +func InitEmptyParallel_clauseContext(p *Parallel_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_clause +} + +func (*Parallel_clauseContext) IsParallel_clauseContext() {} + +func NewParallel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parallel_clauseContext { + var p = new(Parallel_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parallel_clause + + return p +} + +func (s *Parallel_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parallel_clauseContext) GetParallel_count() antlr.Token { return s.parallel_count } + +func (s *Parallel_clauseContext) SetParallel_count(v antlr.Token) { s.parallel_count = v } + +func (s *Parallel_clauseContext) NOPARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL, 0) +} + +func (s *Parallel_clauseContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, 0) +} + +func (s *Parallel_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Parallel_clauseContext) DEGREE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEGREE, 0) +} + +func (s *Parallel_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Parallel_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Parallel_clauseContext) Parallel_instances_clause() IParallel_instances_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_instances_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_instances_clauseContext) +} + +func (s *Parallel_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parallel_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parallel_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParallel_clause(s) + } +} + +func (s *Parallel_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParallel_clause(s) + } +} + +func (p *PlSqlParser) Parallel_clause() (localctx IParallel_clauseContext) { + localctx = NewParallel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, PlSqlParserRULE_parallel_clause) + var _la int + + p.SetState(9681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOPARALLEL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9666) + p.Match(PlSqlParserNOPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARALLEL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9667) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9679) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, p.GetParserRuleContext()) == 1 { + { + p.SetState(9668) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Parallel_clauseContext).parallel_count = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9670) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1116, p.GetParserRuleContext()) == 1 { + { + p.SetState(9669) + p.Parallel_instances_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, p.GetParserRuleContext()) == 2 { + { + p.SetState(9672) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9673) + p.Match(PlSqlParserDEGREE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9674) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Parallel_clauseContext).parallel_count = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINSTANCES { + { + p.SetState(9675) + p.Parallel_instances_clause() + } + + } + { + p.SetState(9678) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParallel_instances_clauseContext is an interface to support dynamic dispatch. +type IParallel_instances_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSTANCES() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsParallel_instances_clauseContext differentiates from other interfaces. + IsParallel_instances_clauseContext() +} + +type Parallel_instances_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParallel_instances_clauseContext() *Parallel_instances_clauseContext { + var p = new(Parallel_instances_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_instances_clause + return p +} + +func InitEmptyParallel_instances_clauseContext(p *Parallel_instances_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_instances_clause +} + +func (*Parallel_instances_clauseContext) IsParallel_instances_clauseContext() {} + +func NewParallel_instances_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parallel_instances_clauseContext { + var p = new(Parallel_instances_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parallel_instances_clause + + return p +} + +func (s *Parallel_instances_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parallel_instances_clauseContext) INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCES, 0) +} + +func (s *Parallel_instances_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Parallel_instances_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Parallel_instances_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parallel_instances_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parallel_instances_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParallel_instances_clause(s) + } +} + +func (s *Parallel_instances_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParallel_instances_clause(s) + } +} + +func (p *PlSqlParser) Parallel_instances_clause() (localctx IParallel_instances_clauseContext) { + localctx = NewParallel_instances_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, PlSqlParserRULE_parallel_instances_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9683) + p.Match(PlSqlParserINSTANCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9684) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserUNSIGNED_INTEGER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_materialized_viewContext is an interface to support dynamic dispatch. +type IAlter_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + Modify_mv_column_clause() IModify_mv_column_clauseContext + Table_compression() ITable_compressionContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllModify_lob_storage_clause() []IModify_lob_storage_clauseContext + Modify_lob_storage_clause(i int) IModify_lob_storage_clauseContext + Parallel_clause() IParallel_clauseContext + Logging_clause() ILogging_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Deallocate_unused_clause() IDeallocate_unused_clauseContext + Shrink_clause() IShrink_clauseContext + Alter_iot_clauses() IAlter_iot_clausesContext + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Alter_mv_option1() IAlter_mv_option1Context + Enable_or_disable() IEnable_or_disableContext + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + CONSIDER() antlr.TerminalNode + FRESH() antlr.TerminalNode + Cache_or_nocache() ICache_or_nocacheContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_materialized_viewContext differentiates from other interfaces. + IsAlter_materialized_viewContext() +} + +type Alter_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_viewContext() *Alter_materialized_viewContext { + var p = new(Alter_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view + return p +} + +func InitEmptyAlter_materialized_viewContext(p *Alter_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view +} + +func (*Alter_materialized_viewContext) IsAlter_materialized_viewContext() {} + +func NewAlter_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_viewContext { + var p = new(Alter_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_materialized_view + + return p +} + +func (s *Alter_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_materialized_viewContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_materialized_viewContext) Modify_mv_column_clause() IModify_mv_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_mv_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_mv_column_clauseContext) +} + +func (s *Alter_materialized_viewContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_materialized_viewContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Alter_materialized_viewContext) AllModify_lob_storage_clause() []IModify_lob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]IModify_lob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_lob_storage_clauseContext); ok { + tst[i] = t.(IModify_lob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Modify_lob_storage_clause(i int) IModify_lob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_storage_clauseContext) +} + +func (s *Alter_materialized_viewContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_materialized_viewContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_materialized_viewContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_materialized_viewContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_materialized_viewContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_materialized_viewContext) Alter_iot_clauses() IAlter_iot_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_iot_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_iot_clausesContext) +} + +func (s *Alter_materialized_viewContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Alter_materialized_viewContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Alter_materialized_viewContext) Alter_mv_option1() IAlter_mv_option1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mv_option1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mv_option1Context) +} + +func (s *Alter_materialized_viewContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_materialized_viewContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Alter_materialized_viewContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Alter_materialized_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_materialized_viewContext) CONSIDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSIDER, 0) +} + +func (s *Alter_materialized_viewContext) FRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRESH, 0) +} + +func (s *Alter_materialized_viewContext) Cache_or_nocache() ICache_or_nocacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_materialized_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_materialized_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_view(s) + } +} + +func (s *Alter_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_view(s) + } +} + +func (p *PlSqlParser) Alter_materialized_view() (localctx IAlter_materialized_viewContext) { + localctx = NewAlter_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, PlSqlParserRULE_alter_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9686) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9687) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9688) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9689) + p.Tableview_name() + } + p.SetState(9715) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 1 { + { + p.SetState(9690) + p.Physical_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 2 { + { + p.SetState(9691) + p.Modify_mv_column_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 3 { + { + p.SetState(9692) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 4 { + { + p.SetState(9693) + p.Lob_storage_clause() + } + p.SetState(9698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9694) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9695) + p.Lob_storage_clause() + } + + p.SetState(9700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 5 { + { + p.SetState(9701) + p.Modify_lob_storage_clause() + } + p.SetState(9706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9702) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9703) + p.Modify_lob_storage_clause() + } + + p.SetState(9708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 6 { + { + p.SetState(9709) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 7 { + { + p.SetState(9710) + p.Logging_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 8 { + { + p.SetState(9711) + p.Allocate_extent_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 9 { + { + p.SetState(9712) + p.Deallocate_unused_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 10 { + { + p.SetState(9713) + p.Shrink_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 11 { + { + p.SetState(9714) + p.Cache_or_nocache() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD || _la == PlSqlParserCOALESCE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(9717) + p.Alter_iot_clauses() + } + + } + p.SetState(9723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(9720) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9721) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9722) + p.Physical_attributes_clause() + } + + } + p.SetState(9726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFRESH { + { + p.SetState(9725) + p.Alter_mv_option1() + } + + } + p.SetState(9735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(9728) + p.Enable_or_disable() + } + { + p.SetState(9729) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9730) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(9732) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSIDER: + { + p.SetState(9733) + p.Match(PlSqlParserCONSIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9734) + p.Match(PlSqlParserFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_mv_option1Context is an interface to support dynamic dispatch. +type IAlter_mv_option1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_mv_refresh() IAlter_mv_refreshContext + + // IsAlter_mv_option1Context differentiates from other interfaces. + IsAlter_mv_option1Context() +} + +type Alter_mv_option1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mv_option1Context() *Alter_mv_option1Context { + var p = new(Alter_mv_option1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 + return p +} + +func InitEmptyAlter_mv_option1Context(p *Alter_mv_option1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 +} + +func (*Alter_mv_option1Context) IsAlter_mv_option1Context() {} + +func NewAlter_mv_option1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mv_option1Context { + var p = new(Alter_mv_option1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 + + return p +} + +func (s *Alter_mv_option1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mv_option1Context) Alter_mv_refresh() IAlter_mv_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mv_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mv_refreshContext) +} + +func (s *Alter_mv_option1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mv_option1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mv_option1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mv_option1(s) + } +} + +func (s *Alter_mv_option1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mv_option1(s) + } +} + +func (p *PlSqlParser) Alter_mv_option1() (localctx IAlter_mv_option1Context) { + localctx = NewAlter_mv_option1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, PlSqlParserRULE_alter_mv_option1) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9737) + p.Alter_mv_refresh() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_mv_refreshContext is an interface to support dynamic dispatch. +type IAlter_mv_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH() antlr.TerminalNode + AllFAST() []antlr.TerminalNode + FAST(i int) antlr.TerminalNode + AllCOMPLETE() []antlr.TerminalNode + COMPLETE(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllSTART() []antlr.TerminalNode + START(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllROLLBACK() []antlr.TerminalNode + ROLLBACK(i int) antlr.TerminalNode + AllSEGMENT() []antlr.TerminalNode + SEGMENT(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllDEMAND() []antlr.TerminalNode + DEMAND(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllENFORCED() []antlr.TerminalNode + ENFORCED(i int) antlr.TerminalNode + AllTRUSTED() []antlr.TerminalNode + TRUSTED(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllRollback_segment() []IRollback_segmentContext + Rollback_segment(i int) IRollback_segmentContext + + // IsAlter_mv_refreshContext differentiates from other interfaces. + IsAlter_mv_refreshContext() +} + +type Alter_mv_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mv_refreshContext() *Alter_mv_refreshContext { + var p = new(Alter_mv_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh + return p +} + +func InitEmptyAlter_mv_refreshContext(p *Alter_mv_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh +} + +func (*Alter_mv_refreshContext) IsAlter_mv_refreshContext() {} + +func NewAlter_mv_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mv_refreshContext { + var p = new(Alter_mv_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh + + return p +} + +func (s *Alter_mv_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mv_refreshContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Alter_mv_refreshContext) AllFAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAST) +} + +func (s *Alter_mv_refreshContext) FAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, i) +} + +func (s *Alter_mv_refreshContext) AllCOMPLETE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMPLETE) +} + +func (s *Alter_mv_refreshContext) COMPLETE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, i) +} + +func (s *Alter_mv_refreshContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Alter_mv_refreshContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Alter_mv_refreshContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Alter_mv_refreshContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Alter_mv_refreshContext) AllSTART() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTART) +} + +func (s *Alter_mv_refreshContext) START(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, i) +} + +func (s *Alter_mv_refreshContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Alter_mv_refreshContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Alter_mv_refreshContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_mv_refreshContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_mv_refreshContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Alter_mv_refreshContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Alter_mv_refreshContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Alter_mv_refreshContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Alter_mv_refreshContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Alter_mv_refreshContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Alter_mv_refreshContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Alter_mv_refreshContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Alter_mv_refreshContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMASTER) +} + +func (s *Alter_mv_refreshContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, i) +} + +func (s *Alter_mv_refreshContext) AllROLLBACK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROLLBACK) +} + +func (s *Alter_mv_refreshContext) ROLLBACK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, i) +} + +func (s *Alter_mv_refreshContext) AllSEGMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEGMENT) +} + +func (s *Alter_mv_refreshContext) SEGMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, i) +} + +func (s *Alter_mv_refreshContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Alter_mv_refreshContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Alter_mv_refreshContext) AllDEMAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEMAND) +} + +func (s *Alter_mv_refreshContext) DEMAND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, i) +} + +func (s *Alter_mv_refreshContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Alter_mv_refreshContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Alter_mv_refreshContext) AllENFORCED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENFORCED) +} + +func (s *Alter_mv_refreshContext) ENFORCED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, i) +} + +func (s *Alter_mv_refreshContext) AllTRUSTED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRUSTED) +} + +func (s *Alter_mv_refreshContext) TRUSTED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, i) +} + +func (s *Alter_mv_refreshContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Alter_mv_refreshContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Alter_mv_refreshContext) AllRollback_segment() []IRollback_segmentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRollback_segmentContext); ok { + len++ + } + } + + tst := make([]IRollback_segmentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRollback_segmentContext); ok { + tst[i] = t.(IRollback_segmentContext) + i++ + } + } + + return tst +} + +func (s *Alter_mv_refreshContext) Rollback_segment(i int) IRollback_segmentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segmentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segmentContext) +} + +func (s *Alter_mv_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mv_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mv_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mv_refresh(s) + } +} + +func (s *Alter_mv_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mv_refresh(s) + } +} + +func (p *PlSqlParser) Alter_mv_refresh() (localctx IAlter_mv_refreshContext) { + localctx = NewAlter_mv_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, PlSqlParserRULE_alter_mv_refresh) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9739) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE || _la == PlSqlParserNEXT || _la == PlSqlParserON || _la == PlSqlParserSTART || _la == PlSqlParserUSING || _la == PlSqlParserWITH { + p.SetState(9766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1129, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9740) + p.Match(PlSqlParserFAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9741) + p.Match(PlSqlParserCOMPLETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(9742) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(9743) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9744) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserDEMAND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + { + p.SetState(9745) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9746) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9747) + p.Expression() + } + + case 6: + { + p.SetState(9748) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9749) + p.Expression() + } + + case 7: + { + p.SetState(9750) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9751) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9752) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(9753) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(9754) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9757) + p.Match(PlSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9758) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9759) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1128, p.GetParserRuleContext()) == 1 { + { + p.SetState(9760) + p.Rollback_segment() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + { + p.SetState(9763) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9764) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENFORCED || _la == PlSqlParserTRUSTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9765) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(9768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollback_segmentContext is an interface to support dynamic dispatch. +type IRollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsRollback_segmentContext differentiates from other interfaces. + IsRollback_segmentContext() +} + +type Rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_segmentContext() *Rollback_segmentContext { + var p = new(Rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment + return p +} + +func InitEmptyRollback_segmentContext(p *Rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment +} + +func (*Rollback_segmentContext) IsRollback_segmentContext() {} + +func NewRollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_segmentContext { + var p = new(Rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_segment + + return p +} + +func (s *Rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_segmentContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_segment(s) + } +} + +func (s *Rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_segment(s) + } +} + +func (p *PlSqlParser) Rollback_segment() (localctx IRollback_segmentContext) { + localctx = NewRollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, PlSqlParserRULE_rollback_segment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9770) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_mv_column_clauseContext is an interface to support dynamic dispatch. +type IModify_mv_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + DECRYPT() antlr.TerminalNode + + // IsModify_mv_column_clauseContext differentiates from other interfaces. + IsModify_mv_column_clauseContext() +} + +type Modify_mv_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_mv_column_clauseContext() *Modify_mv_column_clauseContext { + var p = new(Modify_mv_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause + return p +} + +func InitEmptyModify_mv_column_clauseContext(p *Modify_mv_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause +} + +func (*Modify_mv_column_clauseContext) IsModify_mv_column_clauseContext() {} + +func NewModify_mv_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_mv_column_clauseContext { + var p = new(Modify_mv_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause + + return p +} + +func (s *Modify_mv_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_mv_column_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_mv_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_mv_column_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Modify_mv_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_mv_column_clauseContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Modify_mv_column_clauseContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_mv_column_clauseContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Modify_mv_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_mv_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_mv_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_mv_column_clause(s) + } +} + +func (s *Modify_mv_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_mv_column_clause(s) + } +} + +func (p *PlSqlParser) Modify_mv_column_clause() (localctx IModify_mv_column_clauseContext) { + localctx = NewModify_mv_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, PlSqlParserRULE_modify_mv_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9772) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9773) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9774) + p.Column_name() + } + p.SetState(9778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT: + { + p.SetState(9775) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9776) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(9777) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(9780) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_materialized_view_logContext is an interface to support dynamic dispatch. +type IAlter_materialized_view_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + FORCE() antlr.TerminalNode + Physical_attributes_clause() IPhysical_attributes_clauseContext + Add_mv_log_column_clause() IAdd_mv_log_column_clauseContext + Parallel_clause() IParallel_clauseContext + Logging_clause() ILogging_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Shrink_clause() IShrink_clauseContext + Move_mv_log_clause() IMove_mv_log_clauseContext + Cache_or_nocache() ICache_or_nocacheContext + Mv_log_augmentation() IMv_log_augmentationContext + Mv_log_purge_clause() IMv_log_purge_clauseContext + + // IsAlter_materialized_view_logContext differentiates from other interfaces. + IsAlter_materialized_view_logContext() +} + +type Alter_materialized_view_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_view_logContext() *Alter_materialized_view_logContext { + var p = new(Alter_materialized_view_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log + return p +} + +func InitEmptyAlter_materialized_view_logContext(p *Alter_materialized_view_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log +} + +func (*Alter_materialized_view_logContext) IsAlter_materialized_view_logContext() {} + +func NewAlter_materialized_view_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_view_logContext { + var p = new(Alter_materialized_view_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log + + return p +} + +func (s *Alter_materialized_view_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_view_logContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_view_logContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_view_logContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_materialized_view_logContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Alter_materialized_view_logContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Alter_materialized_view_logContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_materialized_view_logContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_materialized_view_logContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Add_mv_log_column_clause() IAdd_mv_log_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_mv_log_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_mv_log_column_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Move_mv_log_clause() IMove_mv_log_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_mv_log_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_mv_log_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Cache_or_nocache() ICache_or_nocacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_materialized_view_logContext) Mv_log_augmentation() IMv_log_augmentationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_augmentationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_augmentationContext) +} + +func (s *Alter_materialized_view_logContext) Mv_log_purge_clause() IMv_log_purge_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_purge_clauseContext) +} + +func (s *Alter_materialized_view_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_view_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_view_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_view_log(s) + } +} + +func (s *Alter_materialized_view_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_view_log(s) + } +} + +func (p *PlSqlParser) Alter_materialized_view_log() (localctx IAlter_materialized_view_logContext) { + localctx = NewAlter_materialized_view_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, PlSqlParserRULE_alter_materialized_view_log) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9782) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9783) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9784) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9785) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9787) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(9786) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9789) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9790) + p.Tableview_name() + } + p.SetState(9799) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 1 { + { + p.SetState(9791) + p.Physical_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 2 { + { + p.SetState(9792) + p.Add_mv_log_column_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 3 { + { + p.SetState(9793) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 4 { + { + p.SetState(9794) + p.Logging_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 5 { + { + p.SetState(9795) + p.Allocate_extent_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 6 { + { + p.SetState(9796) + p.Shrink_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 7 { + { + p.SetState(9797) + p.Move_mv_log_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) == 8 { + { + p.SetState(9798) + p.Cache_or_nocache() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(9801) + p.Mv_log_augmentation() + } + + } + p.SetState(9805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(9804) + p.Mv_log_purge_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_mv_log_column_clauseContext is an interface to support dynamic dispatch. +type IAdd_mv_log_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + + // IsAdd_mv_log_column_clauseContext differentiates from other interfaces. + IsAdd_mv_log_column_clauseContext() +} + +type Add_mv_log_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_mv_log_column_clauseContext() *Add_mv_log_column_clauseContext { + var p = new(Add_mv_log_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause + return p +} + +func InitEmptyAdd_mv_log_column_clauseContext(p *Add_mv_log_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause +} + +func (*Add_mv_log_column_clauseContext) IsAdd_mv_log_column_clauseContext() {} + +func NewAdd_mv_log_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_mv_log_column_clauseContext { + var p = new(Add_mv_log_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause + + return p +} + +func (s *Add_mv_log_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_mv_log_column_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_mv_log_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_mv_log_column_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Add_mv_log_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_mv_log_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_mv_log_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_mv_log_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_mv_log_column_clause(s) + } +} + +func (s *Add_mv_log_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_mv_log_column_clause(s) + } +} + +func (p *PlSqlParser) Add_mv_log_column_clause() (localctx IAdd_mv_log_column_clauseContext) { + localctx = NewAdd_mv_log_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, PlSqlParserRULE_add_mv_log_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9807) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9808) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9809) + p.Column_name() + } + { + p.SetState(9810) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_mv_log_clauseContext is an interface to support dynamic dispatch. +type IMove_mv_log_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + Segment_attributes_clause() ISegment_attributes_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsMove_mv_log_clauseContext differentiates from other interfaces. + IsMove_mv_log_clauseContext() +} + +type Move_mv_log_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_mv_log_clauseContext() *Move_mv_log_clauseContext { + var p = new(Move_mv_log_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause + return p +} + +func InitEmptyMove_mv_log_clauseContext(p *Move_mv_log_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause +} + +func (*Move_mv_log_clauseContext) IsMove_mv_log_clauseContext() {} + +func NewMove_mv_log_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_mv_log_clauseContext { + var p = new(Move_mv_log_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause + + return p +} + +func (s *Move_mv_log_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_mv_log_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_mv_log_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Move_mv_log_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Move_mv_log_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_mv_log_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_mv_log_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_mv_log_clause(s) + } +} + +func (s *Move_mv_log_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_mv_log_clause(s) + } +} + +func (p *PlSqlParser) Move_mv_log_clause() (localctx IMove_mv_log_clauseContext) { + localctx = NewMove_mv_log_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, PlSqlParserRULE_move_mv_log_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9812) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9813) + p.Segment_attributes_clause() + } + p.SetState(9815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(9814) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMv_log_augmentationContext is an interface to support dynamic dispatch. +type IMv_log_augmentationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + New_values_clause() INew_values_clauseContext + OBJECT() antlr.TerminalNode + ID() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + ROWID() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMv_log_augmentationContext differentiates from other interfaces. + IsMv_log_augmentationContext() +} + +type Mv_log_augmentationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_log_augmentationContext() *Mv_log_augmentationContext { + var p = new(Mv_log_augmentationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation + return p +} + +func InitEmptyMv_log_augmentationContext(p *Mv_log_augmentationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation +} + +func (*Mv_log_augmentationContext) IsMv_log_augmentationContext() {} + +func NewMv_log_augmentationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_log_augmentationContext { + var p = new(Mv_log_augmentationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation + + return p +} + +func (s *Mv_log_augmentationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_log_augmentationContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Mv_log_augmentationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Mv_log_augmentationContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Mv_log_augmentationContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Mv_log_augmentationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Mv_log_augmentationContext) New_values_clause() INew_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_values_clauseContext) +} + +func (s *Mv_log_augmentationContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Mv_log_augmentationContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Mv_log_augmentationContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Mv_log_augmentationContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Mv_log_augmentationContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Mv_log_augmentationContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Mv_log_augmentationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Mv_log_augmentationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Mv_log_augmentationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_log_augmentationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_log_augmentationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_log_augmentation(s) + } +} + +func (s *Mv_log_augmentationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_log_augmentation(s) + } +} + +func (p *PlSqlParser) Mv_log_augmentation() (localctx IMv_log_augmentationContext) { + localctx = NewMv_log_augmentationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, PlSqlParserRULE_mv_log_augmentation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9817) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT, PlSqlParserPRIMARY, PlSqlParserROWID, PlSqlParserSEQUENCE: + p.SetState(9824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(9818) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9819) + p.Match(PlSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9820) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9821) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(9822) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEQUENCE: + { + p.SetState(9823) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9826) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9827) + p.Column_name() + } + p.SetState(9832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9828) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9829) + p.Column_name() + } + + p.SetState(9834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9835) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9839) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9840) + p.Column_name() + } + p.SetState(9845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9841) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9842) + p.Column_name() + } + + p.SetState(9847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9848) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING { + { + p.SetState(9852) + p.New_values_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_materialized_view_logContext is an interface to support dynamic dispatch. +type ICreate_materialized_view_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Parallel_clause() IParallel_clauseContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllMv_log_purge_clause() []IMv_log_purge_clauseContext + Mv_log_purge_clause(i int) IMv_log_purge_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllOBJECT() []antlr.TerminalNode + OBJECT(i int) antlr.TerminalNode + AllID() []antlr.TerminalNode + ID(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllROWID() []antlr.TerminalNode + ROWID(i int) antlr.TerminalNode + AllSEQUENCE() []antlr.TerminalNode + SEQUENCE(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllSCN() []antlr.TerminalNode + SCN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + AllNew_values_clause() []INew_values_clauseContext + New_values_clause(i int) INew_values_clauseContext + + // IsCreate_materialized_view_logContext differentiates from other interfaces. + IsCreate_materialized_view_logContext() +} + +type Create_materialized_view_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyCreate_materialized_view_logContext() *Create_materialized_view_logContext { + var p = new(Create_materialized_view_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log + return p +} + +func InitEmptyCreate_materialized_view_logContext(p *Create_materialized_view_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log +} + +func (*Create_materialized_view_logContext) IsCreate_materialized_view_logContext() {} + +func NewCreate_materialized_view_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_view_logContext { + var p = new(Create_materialized_view_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log + + return p +} + +func (s *Create_materialized_view_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_view_logContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Create_materialized_view_logContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Create_materialized_view_logContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_view_logContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_view_logContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_materialized_view_logContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Create_materialized_view_logContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_materialized_view_logContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_materialized_view_logContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Create_materialized_view_logContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Create_materialized_view_logContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_materialized_view_logContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_materialized_view_logContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_materialized_view_logContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_materialized_view_logContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_materialized_view_logContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_materialized_view_logContext) AllMv_log_purge_clause() []IMv_log_purge_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + len++ + } + } + + tst := make([]IMv_log_purge_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMv_log_purge_clauseContext); ok { + tst[i] = t.(IMv_log_purge_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Mv_log_purge_clause(i int) IMv_log_purge_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_purge_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_materialized_view_logContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Create_materialized_view_logContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Create_materialized_view_logContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Create_materialized_view_logContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Create_materialized_view_logContext) AllOBJECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOBJECT) +} + +func (s *Create_materialized_view_logContext) OBJECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, i) +} + +func (s *Create_materialized_view_logContext) AllID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserID) +} + +func (s *Create_materialized_view_logContext) ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserID, i) +} + +func (s *Create_materialized_view_logContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Create_materialized_view_logContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Create_materialized_view_logContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Create_materialized_view_logContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Create_materialized_view_logContext) AllROWID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROWID) +} + +func (s *Create_materialized_view_logContext) ROWID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, i) +} + +func (s *Create_materialized_view_logContext) AllSEQUENCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEQUENCE) +} + +func (s *Create_materialized_view_logContext) SEQUENCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, i) +} + +func (s *Create_materialized_view_logContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Create_materialized_view_logContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Create_materialized_view_logContext) AllSCN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSCN) +} + +func (s *Create_materialized_view_logContext) SCN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, i) +} + +func (s *Create_materialized_view_logContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_materialized_view_logContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_materialized_view_logContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Create_materialized_view_logContext) AllNew_values_clause() []INew_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INew_values_clauseContext); ok { + len++ + } + } + + tst := make([]INew_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INew_values_clauseContext); ok { + tst[i] = t.(INew_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) New_values_clause(i int) INew_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INew_values_clauseContext) +} + +func (s *Create_materialized_view_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_view_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_view_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_view_log(s) + } +} + +func (s *Create_materialized_view_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_view_log(s) + } +} + +func (p *PlSqlParser) Create_materialized_view_log() (localctx ICreate_materialized_view_logContext) { + localctx = NewCreate_materialized_view_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 950, PlSqlParserRULE_create_materialized_view_log) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9855) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9856) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9857) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9858) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9859) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9860) + p.Tableview_name() + } + p.SetState(9870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(9866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(9866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(9861) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(9862) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9863) + + var _x = p.Id_expression() + + localctx.(*Create_materialized_view_logContext).tablespace_name = _x + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(9864) + p.Logging_clause() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(9865) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(9873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(9872) + p.Parallel_clause() + } + + } + p.SetState(9914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserWITH { + { + p.SetState(9875) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMIT || _la == PlSqlParserOBJECT || _la == PlSqlParserPRIMARY || _la == PlSqlParserROWID || _la == PlSqlParserSEQUENCE || _la == PlSqlParserCOMMA { + p.SetState(9877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9876) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(9879) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9880) + p.Match(PlSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9881) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9882) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(9883) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEQUENCE: + { + p.SetState(9884) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMMIT: + { + p.SetState(9885) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9886) + p.Match(PlSqlParserSCN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(9907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9894) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372351009) != 0) { + p.SetState(9896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9895) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9898) + p.Regular_id() + } + + p.SetState(9901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9903) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING { + { + p.SetState(9904) + p.New_values_clause() + } + + } + + } + p.SetState(9910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(9909) + p.Mv_log_purge_clause() + } + + } + + p.SetState(9916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_values_clauseContext is an interface to support dynamic dispatch. +type INew_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEW() antlr.TerminalNode + VALUES() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + + // IsNew_values_clauseContext differentiates from other interfaces. + IsNew_values_clauseContext() +} + +type New_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_values_clauseContext() *New_values_clauseContext { + var p = new(New_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_values_clause + return p +} + +func InitEmptyNew_values_clauseContext(p *New_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_values_clause +} + +func (*New_values_clauseContext) IsNew_values_clauseContext() {} + +func NewNew_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_values_clauseContext { + var p = new(New_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_values_clause + + return p +} + +func (s *New_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_values_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *New_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *New_values_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *New_values_clauseContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *New_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_values_clause(s) + } +} + +func (s *New_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_values_clause(s) + } +} + +func (p *PlSqlParser) New_values_clause() (localctx INew_values_clauseContext) { + localctx = NewNew_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 952, PlSqlParserRULE_new_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9917) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9918) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9919) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMv_log_purge_clauseContext is an interface to support dynamic dispatch. +type IMv_log_purge_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PURGE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + SYNCHRONOUS() antlr.TerminalNode + ASYNCHRONOUS() antlr.TerminalNode + + // IsMv_log_purge_clauseContext differentiates from other interfaces. + IsMv_log_purge_clauseContext() +} + +type Mv_log_purge_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_log_purge_clauseContext() *Mv_log_purge_clauseContext { + var p = new(Mv_log_purge_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause + return p +} + +func InitEmptyMv_log_purge_clauseContext(p *Mv_log_purge_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause +} + +func (*Mv_log_purge_clauseContext) IsMv_log_purge_clauseContext() {} + +func NewMv_log_purge_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_log_purge_clauseContext { + var p = new(Mv_log_purge_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause + + return p +} + +func (s *Mv_log_purge_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_log_purge_clauseContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Mv_log_purge_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Mv_log_purge_clauseContext) SYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNCHRONOUS, 0) +} + +func (s *Mv_log_purge_clauseContext) ASYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNCHRONOUS, 0) +} + +func (s *Mv_log_purge_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_log_purge_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_log_purge_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_log_purge_clause(s) + } +} + +func (s *Mv_log_purge_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_log_purge_clause(s) + } +} + +func (p *PlSqlParser) Mv_log_purge_clause() (localctx IMv_log_purge_clauseContext) { + localctx = NewMv_log_purge_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 954, PlSqlParserRULE_mv_log_purge_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9921) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(9922) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASYNCHRONOUS || _la == PlSqlParserSYNCHRONOUS { + { + p.SetState(9923) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASYNCHRONOUS || _la == PlSqlParserSYNCHRONOUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_materialized_zonemapContext is an interface to support dynamic dispatch. +type ICreate_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + Create_zonemap_on_table() ICreate_zonemap_on_tableContext + Create_zonemap_as_subquery() ICreate_zonemap_as_subqueryContext + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + Zonemap_attributes() IZonemap_attributesContext + Zonemap_refresh_clause() IZonemap_refresh_clauseContext + PRUNING() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCreate_materialized_zonemapContext differentiates from other interfaces. + IsCreate_materialized_zonemapContext() +} + +type Create_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_materialized_zonemapContext() *Create_materialized_zonemapContext { + var p = new(Create_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap + return p +} + +func InitEmptyCreate_materialized_zonemapContext(p *Create_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap +} + +func (*Create_materialized_zonemapContext) IsCreate_materialized_zonemapContext() {} + +func NewCreate_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_zonemapContext { + var p = new(Create_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap + + return p +} + +func (s *Create_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_zonemapContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Create_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Create_materialized_zonemapContext) Create_zonemap_on_table() ICreate_zonemap_on_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_zonemap_on_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_zonemap_on_tableContext) +} + +func (s *Create_materialized_zonemapContext) Create_zonemap_as_subquery() ICreate_zonemap_as_subqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_zonemap_as_subqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_zonemap_as_subqueryContext) +} + +func (s *Create_materialized_zonemapContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_materialized_zonemapContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Create_materialized_zonemapContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_materialized_zonemapContext) Zonemap_attributes() IZonemap_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_attributesContext) +} + +func (s *Create_materialized_zonemapContext) Zonemap_refresh_clause() IZonemap_refresh_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_refresh_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_refresh_clauseContext) +} + +func (s *Create_materialized_zonemapContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Create_materialized_zonemapContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Create_materialized_zonemapContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Create_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_zonemap(s) + } +} + +func (s *Create_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_zonemap(s) + } +} + +func (p *PlSqlParser) Create_materialized_zonemap() (localctx ICreate_materialized_zonemapContext) { + localctx = NewCreate_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, PlSqlParserRULE_create_materialized_zonemap) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9926) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9927) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9928) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9929) + p.Zonemap_name() + } + p.SetState(9934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9930) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9931) + p.Column_list() + } + { + p.SetState(9932) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSCALE || _la == PlSqlParserTABLESPACE { + { + p.SetState(9936) + p.Zonemap_attributes() + } + + } + p.SetState(9940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFRESH { + { + p.SetState(9939) + p.Zonemap_refresh_clause() + } + + } + p.SetState(9944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(9942) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9943) + p.Match(PlSqlParserPRUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(9946) + p.Create_zonemap_on_table() + } + + case PlSqlParserAS: + { + p.SetState(9947) + p.Create_zonemap_as_subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_materialized_zonemapContext is an interface to support dynamic dispatch. +type IAlter_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + Zonemap_attributes() IZonemap_attributesContext + Zonemap_refresh_clause() IZonemap_refresh_clauseContext + PRUNING() antlr.TerminalNode + COMPILE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsAlter_materialized_zonemapContext differentiates from other interfaces. + IsAlter_materialized_zonemapContext() +} + +type Alter_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_zonemapContext() *Alter_materialized_zonemapContext { + var p = new(Alter_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap + return p +} + +func InitEmptyAlter_materialized_zonemapContext(p *Alter_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap +} + +func (*Alter_materialized_zonemapContext) IsAlter_materialized_zonemapContext() {} + +func NewAlter_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_zonemapContext { + var p = new(Alter_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap + + return p +} + +func (s *Alter_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_zonemapContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_attributes() IZonemap_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_attributesContext) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_refresh_clause() IZonemap_refresh_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_refresh_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_refresh_clauseContext) +} + +func (s *Alter_materialized_zonemapContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Alter_materialized_zonemapContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_materialized_zonemapContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Alter_materialized_zonemapContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_zonemap(s) + } +} + +func (s *Alter_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_zonemap(s) + } +} + +func (p *PlSqlParser) Alter_materialized_zonemap() (localctx IAlter_materialized_zonemapContext) { + localctx = NewAlter_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, PlSqlParserRULE_alter_materialized_zonemap) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9950) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9951) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9952) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9953) + p.Zonemap_name() + } + p.SetState(9961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCACHE, PlSqlParserNOCACHE, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSCALE, PlSqlParserTABLESPACE: + { + p.SetState(9954) + p.Zonemap_attributes() + } + + case PlSqlParserREFRESH: + { + p.SetState(9955) + p.Zonemap_refresh_clause() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(9956) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9957) + p.Match(PlSqlParserPRUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(9958) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREBUILD: + { + p.SetState(9959) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNUSABLE: + { + p.SetState(9960) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_materialized_zonemapContext is an interface to support dynamic dispatch. +type IDrop_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + + // IsDrop_materialized_zonemapContext differentiates from other interfaces. + IsDrop_materialized_zonemapContext() +} + +type Drop_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_materialized_zonemapContext() *Drop_materialized_zonemapContext { + var p = new(Drop_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap + return p +} + +func InitEmptyDrop_materialized_zonemapContext(p *Drop_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap +} + +func (*Drop_materialized_zonemapContext) IsDrop_materialized_zonemapContext() {} + +func NewDrop_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_materialized_zonemapContext { + var p = new(Drop_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap + + return p +} + +func (s *Drop_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_materialized_zonemapContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Drop_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Drop_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_materialized_zonemap(s) + } +} + +func (s *Drop_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_materialized_zonemap(s) + } +} + +func (p *PlSqlParser) Drop_materialized_zonemap() (localctx IDrop_materialized_zonemapContext) { + localctx = NewDrop_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, PlSqlParserRULE_drop_materialized_zonemap) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9963) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9964) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9965) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9966) + p.Zonemap_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZonemap_refresh_clauseContext is an interface to support dynamic dispatch. +type IZonemap_refresh_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH() antlr.TerminalNode + ON() antlr.TerminalNode + FAST() antlr.TerminalNode + COMPILE() antlr.TerminalNode + FORCE() antlr.TerminalNode + DEMAND() antlr.TerminalNode + COMMIT() antlr.TerminalNode + LOAD() antlr.TerminalNode + DATA() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + + // IsZonemap_refresh_clauseContext differentiates from other interfaces. + IsZonemap_refresh_clauseContext() +} + +type Zonemap_refresh_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_refresh_clauseContext() *Zonemap_refresh_clauseContext { + var p = new(Zonemap_refresh_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause + return p +} + +func InitEmptyZonemap_refresh_clauseContext(p *Zonemap_refresh_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause +} + +func (*Zonemap_refresh_clauseContext) IsZonemap_refresh_clauseContext() {} + +func NewZonemap_refresh_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_refresh_clauseContext { + var p = new(Zonemap_refresh_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause + + return p +} + +func (s *Zonemap_refresh_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_refresh_clauseContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Zonemap_refresh_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Zonemap_refresh_clauseContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Zonemap_refresh_clauseContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Zonemap_refresh_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Zonemap_refresh_clauseContext) DEMAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, 0) +} + +func (s *Zonemap_refresh_clauseContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Zonemap_refresh_clauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Zonemap_refresh_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Zonemap_refresh_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Zonemap_refresh_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_refresh_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_refresh_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_refresh_clause(s) + } +} + +func (s *Zonemap_refresh_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_refresh_clause(s) + } +} + +func (p *PlSqlParser) Zonemap_refresh_clause() (localctx IZonemap_refresh_clauseContext) { + localctx = NewZonemap_refresh_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, PlSqlParserRULE_zonemap_refresh_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9968) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPILE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE { + { + p.SetState(9969) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9983) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1165, p.GetParserRuleContext()) == 1 { + { + p.SetState(9972) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1164, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9973) + p.Match(PlSqlParserDEMAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9974) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(9975) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(9976) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9977) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(9978) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9979) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9980) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZonemap_attributesContext is an interface to support dynamic dispatch. +type IZonemap_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPCTFREE() []antlr.TerminalNode + PCTFREE(i int) antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllPCTUSED() []antlr.TerminalNode + PCTUSED(i int) antlr.TerminalNode + AllSCALE() []antlr.TerminalNode + SCALE(i int) antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + + // IsZonemap_attributesContext differentiates from other interfaces. + IsZonemap_attributesContext() +} + +type Zonemap_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_attributesContext() *Zonemap_attributesContext { + var p = new(Zonemap_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_attributes + return p +} + +func InitEmptyZonemap_attributesContext(p *Zonemap_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_attributes +} + +func (*Zonemap_attributesContext) IsZonemap_attributesContext() {} + +func NewZonemap_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_attributesContext { + var p = new(Zonemap_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_attributes + + return p +} + +func (s *Zonemap_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_attributesContext) AllPCTFREE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTFREE) +} + +func (s *Zonemap_attributesContext) PCTFREE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTFREE, i) +} + +func (s *Zonemap_attributesContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Zonemap_attributesContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Zonemap_attributesContext) AllPCTUSED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTUSED) +} + +func (s *Zonemap_attributesContext) PCTUSED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, i) +} + +func (s *Zonemap_attributesContext) AllSCALE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSCALE) +} + +func (s *Zonemap_attributesContext) SCALE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, i) +} + +func (s *Zonemap_attributesContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Zonemap_attributesContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Zonemap_attributesContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Zonemap_attributesContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Zonemap_attributesContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Zonemap_attributesContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Zonemap_attributesContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Zonemap_attributesContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Zonemap_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_attributes(s) + } +} + +func (s *Zonemap_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_attributes(s) + } +} + +func (p *PlSqlParser) Zonemap_attributes() (localctx IZonemap_attributesContext) { + localctx = NewZonemap_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, PlSqlParserRULE_zonemap_attributes) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSCALE || _la == PlSqlParserTABLESPACE { + p.SetState(9994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPCTFREE: + { + p.SetState(9985) + p.Match(PlSqlParserPCTFREE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9986) + p.Numeric() + } + + case PlSqlParserPCTUSED: + { + p.SetState(9987) + p.Match(PlSqlParserPCTUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9988) + p.Numeric() + } + + case PlSqlParserSCALE: + { + p.SetState(9989) + p.Match(PlSqlParserSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9990) + p.Numeric() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(9991) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9992) + p.Tablespace() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(9993) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZonemap_nameContext is an interface to support dynamic dispatch. +type IZonemap_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsZonemap_nameContext differentiates from other interfaces. + IsZonemap_nameContext() +} + +type Zonemap_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_nameContext() *Zonemap_nameContext { + var p = new(Zonemap_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_name + return p +} + +func InitEmptyZonemap_nameContext(p *Zonemap_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_name +} + +func (*Zonemap_nameContext) IsZonemap_nameContext() {} + +func NewZonemap_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_nameContext { + var p = new(Zonemap_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_name + + return p +} + +func (s *Zonemap_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Zonemap_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Zonemap_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Zonemap_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_name(s) + } +} + +func (s *Zonemap_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_name(s) + } +} + +func (p *PlSqlParser) Zonemap_name() (localctx IZonemap_nameContext) { + localctx = NewZonemap_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, PlSqlParserRULE_zonemap_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9998) + p.Identifier() + } + p.SetState(10001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(9999) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10000) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_nameContext is an interface to support dynamic dispatch. +type IOperator_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsOperator_nameContext differentiates from other interfaces. + IsOperator_nameContext() +} + +type Operator_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_nameContext() *Operator_nameContext { + var p = new(Operator_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_name + return p +} + +func InitEmptyOperator_nameContext(p *Operator_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_name +} + +func (*Operator_nameContext) IsOperator_nameContext() {} + +func NewOperator_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_nameContext { + var p = new(Operator_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_name + + return p +} + +func (s *Operator_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Operator_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Operator_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Operator_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_name(s) + } +} + +func (s *Operator_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_name(s) + } +} + +func (p *PlSqlParser) Operator_name() (localctx IOperator_nameContext) { + localctx = NewOperator_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, PlSqlParserRULE_operator_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10003) + p.Identifier() + } + p.SetState(10006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(10004) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10005) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_function_nameContext is an interface to support dynamic dispatch. +type IOperator_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsOperator_function_nameContext differentiates from other interfaces. + IsOperator_function_nameContext() +} + +type Operator_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_function_nameContext() *Operator_function_nameContext { + var p = new(Operator_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_function_name + return p +} + +func InitEmptyOperator_function_nameContext(p *Operator_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_function_name +} + +func (*Operator_function_nameContext) IsOperator_function_nameContext() {} + +func NewOperator_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_function_nameContext { + var p = new(Operator_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_function_name + + return p +} + +func (s *Operator_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Operator_function_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Operator_function_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Operator_function_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Operator_function_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Operator_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_function_name(s) + } +} + +func (s *Operator_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_function_name(s) + } +} + +func (p *PlSqlParser) Operator_function_name() (localctx IOperator_function_nameContext) { + localctx = NewOperator_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, PlSqlParserRULE_operator_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10008) + p.Identifier() + } + p.SetState(10013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(10009) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10010) + p.Id_expression() + } + + p.SetState(10015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_zonemap_on_tableContext is an interface to support dynamic dispatch. +type ICreate_zonemap_on_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCreate_zonemap_on_tableContext differentiates from other interfaces. + IsCreate_zonemap_on_tableContext() +} + +type Create_zonemap_on_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_zonemap_on_tableContext() *Create_zonemap_on_tableContext { + var p = new(Create_zonemap_on_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table + return p +} + +func InitEmptyCreate_zonemap_on_tableContext(p *Create_zonemap_on_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table +} + +func (*Create_zonemap_on_tableContext) IsCreate_zonemap_on_tableContext() {} + +func NewCreate_zonemap_on_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_zonemap_on_tableContext { + var p = new(Create_zonemap_on_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table + + return p +} + +func (s *Create_zonemap_on_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_zonemap_on_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_zonemap_on_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_zonemap_on_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_zonemap_on_tableContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Create_zonemap_on_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_zonemap_on_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_zonemap_on_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_zonemap_on_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_zonemap_on_table(s) + } +} + +func (s *Create_zonemap_on_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_zonemap_on_table(s) + } +} + +func (p *PlSqlParser) Create_zonemap_on_table() (localctx ICreate_zonemap_on_tableContext) { + localctx = NewCreate_zonemap_on_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, PlSqlParserRULE_create_zonemap_on_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10016) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10017) + p.Tableview_name() + } + { + p.SetState(10018) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10019) + p.Column_list() + } + { + p.SetState(10020) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_zonemap_as_subqueryContext is an interface to support dynamic dispatch. +type ICreate_zonemap_as_subqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsCreate_zonemap_as_subqueryContext differentiates from other interfaces. + IsCreate_zonemap_as_subqueryContext() +} + +type Create_zonemap_as_subqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_zonemap_as_subqueryContext() *Create_zonemap_as_subqueryContext { + var p = new(Create_zonemap_as_subqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery + return p +} + +func InitEmptyCreate_zonemap_as_subqueryContext(p *Create_zonemap_as_subqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery +} + +func (*Create_zonemap_as_subqueryContext) IsCreate_zonemap_as_subqueryContext() {} + +func NewCreate_zonemap_as_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_zonemap_as_subqueryContext { + var p = new(Create_zonemap_as_subqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery + + return p +} + +func (s *Create_zonemap_as_subqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_zonemap_as_subqueryContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_zonemap_as_subqueryContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Create_zonemap_as_subqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_zonemap_as_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_zonemap_as_subqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_zonemap_as_subquery(s) + } +} + +func (s *Create_zonemap_as_subqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_zonemap_as_subquery(s) + } +} + +func (p *PlSqlParser) Create_zonemap_as_subquery() (localctx ICreate_zonemap_as_subqueryContext) { + localctx = NewCreate_zonemap_as_subqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, PlSqlParserRULE_create_zonemap_as_subquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10022) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10023) + p.Subquery() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_operatorContext is an interface to support dynamic dispatch. +type IAlter_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + Add_binding_clause() IAdd_binding_clauseContext + Drop_binding_clause() IDrop_binding_clauseContext + COMPILE() antlr.TerminalNode + + // IsAlter_operatorContext differentiates from other interfaces. + IsAlter_operatorContext() +} + +type Alter_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_operatorContext() *Alter_operatorContext { + var p = new(Alter_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_operator + return p +} + +func InitEmptyAlter_operatorContext(p *Alter_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_operator +} + +func (*Alter_operatorContext) IsAlter_operatorContext() {} + +func NewAlter_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_operatorContext { + var p = new(Alter_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_operator + + return p +} + +func (s *Alter_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_operatorContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Alter_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Alter_operatorContext) Add_binding_clause() IAdd_binding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_binding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_binding_clauseContext) +} + +func (s *Alter_operatorContext) Drop_binding_clause() IDrop_binding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_binding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_binding_clauseContext) +} + +func (s *Alter_operatorContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_operator(s) + } +} + +func (s *Alter_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_operator(s) + } +} + +func (p *PlSqlParser) Alter_operator() (localctx IAlter_operatorContext) { + localctx = NewAlter_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, PlSqlParserRULE_alter_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10025) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10026) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10027) + p.Operator_name() + } + p.SetState(10031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(10028) + p.Add_binding_clause() + } + + case PlSqlParserDROP: + { + p.SetState(10029) + p.Drop_binding_clause() + } + + case PlSqlParserCOMPILE: + { + p.SetState(10030) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_operatorContext is an interface to support dynamic dispatch. +type IDrop_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + FORCE() antlr.TerminalNode + + // IsDrop_operatorContext differentiates from other interfaces. + IsDrop_operatorContext() +} + +type Drop_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_operatorContext() *Drop_operatorContext { + var p = new(Drop_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_operator + return p +} + +func InitEmptyDrop_operatorContext(p *Drop_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_operator +} + +func (*Drop_operatorContext) IsDrop_operatorContext() {} + +func NewDrop_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_operatorContext { + var p = new(Drop_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_operator + + return p +} + +func (s *Drop_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_operatorContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Drop_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Drop_operatorContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_operator(s) + } +} + +func (s *Drop_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_operator(s) + } +} + +func (p *PlSqlParser) Drop_operator() (localctx IDrop_operatorContext) { + localctx = NewDrop_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, PlSqlParserRULE_drop_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10033) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10034) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10035) + p.Operator_name() + } + p.SetState(10037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(10036) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_operatorContext is an interface to support dynamic dispatch. +type ICreate_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + BINDING() antlr.TerminalNode + AllBinding_clause() []IBinding_clauseContext + Binding_clause(i int) IBinding_clauseContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_operatorContext differentiates from other interfaces. + IsCreate_operatorContext() +} + +type Create_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_operatorContext() *Create_operatorContext { + var p = new(Create_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_operator + return p +} + +func InitEmptyCreate_operatorContext(p *Create_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_operator +} + +func (*Create_operatorContext) IsCreate_operatorContext() {} + +func NewCreate_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_operatorContext { + var p = new(Create_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_operator + + return p +} + +func (s *Create_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_operatorContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Create_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Create_operatorContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Create_operatorContext) AllBinding_clause() []IBinding_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBinding_clauseContext); ok { + len++ + } + } + + tst := make([]IBinding_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBinding_clauseContext); ok { + tst[i] = t.(IBinding_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_operatorContext) Binding_clause(i int) IBinding_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinding_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBinding_clauseContext) +} + +func (s *Create_operatorContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_operatorContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_operatorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_operatorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_operatorContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_operatorContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_operatorContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_operatorContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_operator(s) + } +} + +func (s *Create_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_operator(s) + } +} + +func (p *PlSqlParser) Create_operator() (localctx ICreate_operatorContext) { + localctx = NewCreate_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, PlSqlParserRULE_create_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10039) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(10040) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10041) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10044) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10045) + p.Operator_name() + } + { + p.SetState(10046) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10047) + p.Binding_clause() + } + p.SetState(10052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10048) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10049) + p.Binding_clause() + } + + p.SetState(10054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(10058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(10055) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10056) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10057) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBinding_clauseContext is an interface to support dynamic dispatch. +type IBinding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RETURN() antlr.TerminalNode + Using_function_clause() IUsing_function_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Implementation_clause() IImplementation_clauseContext + + // IsBinding_clauseContext differentiates from other interfaces. + IsBinding_clauseContext() +} + +type Binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBinding_clauseContext() *Binding_clauseContext { + var p = new(Binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_binding_clause + return p +} + +func InitEmptyBinding_clauseContext(p *Binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_binding_clause +} + +func (*Binding_clauseContext) IsBinding_clauseContext() {} + +func NewBinding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Binding_clauseContext { + var p = new(Binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_binding_clause + + return p +} + +func (s *Binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Binding_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Binding_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Binding_clauseContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Binding_clauseContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Binding_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Binding_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Binding_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Binding_clauseContext) Using_function_clause() IUsing_function_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_function_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_function_clauseContext) +} + +func (s *Binding_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Binding_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Binding_clauseContext) Implementation_clause() IImplementation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_clauseContext) +} + +func (s *Binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBinding_clause(s) + } +} + +func (s *Binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBinding_clause(s) + } +} + +func (p *PlSqlParser) Binding_clause() (localctx IBinding_clauseContext) { + localctx = NewBinding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, PlSqlParserRULE_binding_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10060) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10061) + p.Datatype() + } + p.SetState(10066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10062) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10063) + p.Datatype() + } + + p.SetState(10068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10069) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10070) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10071) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10074) + p.Datatype() + } + p.SetState(10076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(10075) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANCILLARY || _la == PlSqlParserWITH { + { + p.SetState(10078) + p.Implementation_clause() + } + + } + { + p.SetState(10081) + p.Using_function_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_binding_clauseContext is an interface to support dynamic dispatch. +type IAdd_binding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + BINDING() antlr.TerminalNode + Binding_clause() IBinding_clauseContext + + // IsAdd_binding_clauseContext differentiates from other interfaces. + IsAdd_binding_clauseContext() +} + +type Add_binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_binding_clauseContext() *Add_binding_clauseContext { + var p = new(Add_binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_binding_clause + return p +} + +func InitEmptyAdd_binding_clauseContext(p *Add_binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_binding_clause +} + +func (*Add_binding_clauseContext) IsAdd_binding_clauseContext() {} + +func NewAdd_binding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_binding_clauseContext { + var p = new(Add_binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_binding_clause + + return p +} + +func (s *Add_binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_binding_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_binding_clauseContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Add_binding_clauseContext) Binding_clause() IBinding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBinding_clauseContext) +} + +func (s *Add_binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_binding_clause(s) + } +} + +func (s *Add_binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_binding_clause(s) + } +} + +func (p *PlSqlParser) Add_binding_clause() (localctx IAdd_binding_clauseContext) { + localctx = NewAdd_binding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, PlSqlParserRULE_add_binding_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10083) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10084) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10085) + p.Binding_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImplementation_clauseContext is an interface to support dynamic dispatch. +type IImplementation_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANCILLARY() antlr.TerminalNode + TO() antlr.TerminalNode + Primary_operator_list() IPrimary_operator_listContext + Operator_context_clause() IOperator_context_clauseContext + + // IsImplementation_clauseContext differentiates from other interfaces. + IsImplementation_clauseContext() +} + +type Implementation_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplementation_clauseContext() *Implementation_clauseContext { + var p = new(Implementation_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_clause + return p +} + +func InitEmptyImplementation_clauseContext(p *Implementation_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_clause +} + +func (*Implementation_clauseContext) IsImplementation_clauseContext() {} + +func NewImplementation_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implementation_clauseContext { + var p = new(Implementation_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_implementation_clause + + return p +} + +func (s *Implementation_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implementation_clauseContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Implementation_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Implementation_clauseContext) Primary_operator_list() IPrimary_operator_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_operator_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_operator_listContext) +} + +func (s *Implementation_clauseContext) Operator_context_clause() IOperator_context_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_context_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_context_clauseContext) +} + +func (s *Implementation_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implementation_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implementation_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImplementation_clause(s) + } +} + +func (s *Implementation_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImplementation_clause(s) + } +} + +func (p *PlSqlParser) Implementation_clause() (localctx IImplementation_clauseContext) { + localctx = NewImplementation_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, PlSqlParserRULE_implementation_clause) + p.SetState(10091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserANCILLARY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10087) + p.Match(PlSqlParserANCILLARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10088) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10089) + p.Primary_operator_list() + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10090) + p.Operator_context_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_operator_listContext is an interface to support dynamic dispatch. +type IPrimary_operator_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrimary_operator_item() []IPrimary_operator_itemContext + Primary_operator_item(i int) IPrimary_operator_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrimary_operator_listContext differentiates from other interfaces. + IsPrimary_operator_listContext() +} + +type Primary_operator_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_operator_listContext() *Primary_operator_listContext { + var p = new(Primary_operator_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_list + return p +} + +func InitEmptyPrimary_operator_listContext(p *Primary_operator_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_list +} + +func (*Primary_operator_listContext) IsPrimary_operator_listContext() {} + +func NewPrimary_operator_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_operator_listContext { + var p = new(Primary_operator_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_primary_operator_list + + return p +} + +func (s *Primary_operator_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_operator_listContext) AllPrimary_operator_item() []IPrimary_operator_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrimary_operator_itemContext); ok { + len++ + } + } + + tst := make([]IPrimary_operator_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrimary_operator_itemContext); ok { + tst[i] = t.(IPrimary_operator_itemContext) + i++ + } + } + + return tst +} + +func (s *Primary_operator_listContext) Primary_operator_item(i int) IPrimary_operator_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_operator_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_operator_itemContext) +} + +func (s *Primary_operator_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Primary_operator_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Primary_operator_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_operator_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_operator_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrimary_operator_list(s) + } +} + +func (s *Primary_operator_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrimary_operator_list(s) + } +} + +func (p *PlSqlParser) Primary_operator_list() (localctx IPrimary_operator_listContext) { + localctx = NewPrimary_operator_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, PlSqlParserRULE_primary_operator_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10093) + p.Primary_operator_item() + } + p.SetState(10098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10094) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10095) + p.Primary_operator_item() + } + + p.SetState(10100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_operator_itemContext is an interface to support dynamic dispatch. +type IPrimary_operator_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Schema_object_name() ISchema_object_nameContext + LEFT_PAREN() antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrimary_operator_itemContext differentiates from other interfaces. + IsPrimary_operator_itemContext() +} + +type Primary_operator_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_operator_itemContext() *Primary_operator_itemContext { + var p = new(Primary_operator_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_item + return p +} + +func InitEmptyPrimary_operator_itemContext(p *Primary_operator_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_item +} + +func (*Primary_operator_itemContext) IsPrimary_operator_itemContext() {} + +func NewPrimary_operator_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_operator_itemContext { + var p = new(Primary_operator_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_primary_operator_item + + return p +} + +func (s *Primary_operator_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_operator_itemContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Primary_operator_itemContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Primary_operator_itemContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Primary_operator_itemContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Primary_operator_itemContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Primary_operator_itemContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Primary_operator_itemContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Primary_operator_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_operator_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_operator_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrimary_operator_item(s) + } +} + +func (s *Primary_operator_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrimary_operator_item(s) + } +} + +func (p *PlSqlParser) Primary_operator_item() (localctx IPrimary_operator_itemContext) { + localctx = NewPrimary_operator_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, PlSqlParserRULE_primary_operator_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10101) + p.Schema_object_name() + } + { + p.SetState(10102) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10103) + p.Datatype() + } + p.SetState(10108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10104) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10105) + p.Datatype() + } + + p.SetState(10110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10111) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_context_clauseContext is an interface to support dynamic dispatch. +type IOperator_context_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + INDEX() antlr.TerminalNode + AllCONTEXT() []antlr.TerminalNode + CONTEXT(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + SCAN() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + COMPUTE() antlr.TerminalNode + ANCILLARY() antlr.TerminalNode + DATA() antlr.TerminalNode + COLUMN() antlr.TerminalNode + + // IsOperator_context_clauseContext differentiates from other interfaces. + IsOperator_context_clauseContext() +} + +type Operator_context_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_context_clauseContext() *Operator_context_clauseContext { + var p = new(Operator_context_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_context_clause + return p +} + +func InitEmptyOperator_context_clauseContext(p *Operator_context_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_context_clause +} + +func (*Operator_context_clauseContext) IsOperator_context_clauseContext() {} + +func NewOperator_context_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_context_clauseContext { + var p = new(Operator_context_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_context_clause + + return p +} + +func (s *Operator_context_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_context_clauseContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Operator_context_clauseContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Operator_context_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Operator_context_clauseContext) AllCONTEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTEXT) +} + +func (s *Operator_context_clauseContext) CONTEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, i) +} + +func (s *Operator_context_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Operator_context_clauseContext) SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN, 0) +} + +func (s *Operator_context_clauseContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Operator_context_clauseContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Operator_context_clauseContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Operator_context_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Operator_context_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Operator_context_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_context_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_context_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_context_clause(s) + } +} + +func (s *Operator_context_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_context_clause(s) + } +} + +func (p *PlSqlParser) Operator_context_clause() (localctx IOperator_context_clauseContext) { + localctx = NewOperator_context_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, PlSqlParserRULE_operator_context_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10113) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10114) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10115) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10116) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10117) + p.Match(PlSqlParserSCAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10118) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10119) + p.Implementation_type_name() + } + p.SetState(10123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPUTE { + { + p.SetState(10120) + p.Match(PlSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10121) + p.Match(PlSqlParserANCILLARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10122) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(10125) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10126) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10127) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_function_clauseContext is an interface to support dynamic dispatch. +type IUsing_function_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Operator_function_name() IOperator_function_nameContext + + // IsUsing_function_clauseContext differentiates from other interfaces. + IsUsing_function_clauseContext() +} + +type Using_function_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_function_clauseContext() *Using_function_clauseContext { + var p = new(Using_function_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_function_clause + return p +} + +func InitEmptyUsing_function_clauseContext(p *Using_function_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_function_clause +} + +func (*Using_function_clauseContext) IsUsing_function_clauseContext() {} + +func NewUsing_function_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_function_clauseContext { + var p = new(Using_function_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_function_clause + + return p +} + +func (s *Using_function_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_function_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_function_clauseContext) Operator_function_name() IOperator_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_function_nameContext) +} + +func (s *Using_function_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_function_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_function_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_function_clause(s) + } +} + +func (s *Using_function_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_function_clause(s) + } +} + +func (p *PlSqlParser) Using_function_clause() (localctx IUsing_function_clauseContext) { + localctx = NewUsing_function_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, PlSqlParserRULE_using_function_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10130) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10131) + p.Operator_function_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_binding_clauseContext is an interface to support dynamic dispatch. +type IDrop_binding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + BINDING() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_binding_clauseContext differentiates from other interfaces. + IsDrop_binding_clauseContext() +} + +type Drop_binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_binding_clauseContext() *Drop_binding_clauseContext { + var p = new(Drop_binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_binding_clause + return p +} + +func InitEmptyDrop_binding_clauseContext(p *Drop_binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_binding_clause +} + +func (*Drop_binding_clauseContext) IsDrop_binding_clauseContext() {} + +func NewDrop_binding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_binding_clauseContext { + var p = new(Drop_binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_binding_clause + + return p +} + +func (s *Drop_binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_binding_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_binding_clauseContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Drop_binding_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_binding_clauseContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Drop_binding_clauseContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Drop_binding_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_binding_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_binding_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_binding_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_binding_clause(s) + } +} + +func (s *Drop_binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_binding_clause(s) + } +} + +func (p *PlSqlParser) Drop_binding_clause() (localctx IDrop_binding_clauseContext) { + localctx = NewDrop_binding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, PlSqlParserRULE_drop_binding_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10133) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10134) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10135) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10136) + p.Datatype() + } + p.SetState(10141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10137) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10138) + p.Datatype() + } + + p.SetState(10143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10144) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(10145) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_materialized_viewContext is an interface to support dynamic dispatch. +type ICreate_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMv_tablespace returns the mv_tablespace rule contexts. + GetMv_tablespace() IId_expressionContext + + // SetMv_tablespace sets the mv_tablespace rule contexts. + SetMv_tablespace(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + PREBUILT() antlr.TerminalNode + TABLE() antlr.TerminalNode + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + OF() antlr.TerminalNode + Type_name() IType_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + NO() antlr.TerminalNode + Create_mv_refresh() ICreate_mv_refreshContext + Evaluation_edition_clause() IEvaluation_edition_clauseContext + QUERY() antlr.TerminalNode + COMPUTATION() antlr.TerminalNode + Query_rewrite_clause() IQuery_rewrite_clauseContext + CONCURRENT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + Annotations_clause() IAnnotations_clauseContext + AllENABLE() []antlr.TerminalNode + ENABLE(i int) antlr.TerminalNode + AllDISABLE() []antlr.TerminalNode + DISABLE(i int) antlr.TerminalNode + AllScoped_table_ref_constraint() []IScoped_table_ref_constraintContext + Scoped_table_ref_constraint(i int) IScoped_table_ref_constraintContext + AllMv_column_alias() []IMv_column_aliasContext + Mv_column_alias(i int) IMv_column_aliasContext + REDUCED() antlr.TerminalNode + PRECISION() antlr.TerminalNode + Physical_properties() IPhysical_propertiesContext + Parallel_clause() IParallel_clauseContext + Build_clause() IBuild_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsCreate_materialized_viewContext differentiates from other interfaces. + IsCreate_materialized_viewContext() +} + +type Create_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mv_tablespace IId_expressionContext +} + +func NewEmptyCreate_materialized_viewContext() *Create_materialized_viewContext { + var p = new(Create_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view + return p +} + +func InitEmptyCreate_materialized_viewContext(p *Create_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view +} + +func (*Create_materialized_viewContext) IsCreate_materialized_viewContext() {} + +func NewCreate_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_viewContext { + var p = new(Create_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_materialized_view + + return p +} + +func (s *Create_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_viewContext) GetMv_tablespace() IId_expressionContext { + return s.mv_tablespace +} + +func (s *Create_materialized_viewContext) SetMv_tablespace(v IId_expressionContext) { + s.mv_tablespace = v +} + +func (s *Create_materialized_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_materialized_viewContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_materialized_viewContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Create_materialized_viewContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Create_materialized_viewContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Create_materialized_viewContext) PREBUILT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREBUILT, 0) +} + +func (s *Create_materialized_viewContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Create_materialized_viewContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_materialized_viewContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_materialized_viewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_materialized_viewContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_materialized_viewContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Create_materialized_viewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_materialized_viewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_materialized_viewContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_materialized_viewContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Create_materialized_viewContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_materialized_viewContext) Create_mv_refresh() ICreate_mv_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_mv_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_mv_refreshContext) +} + +func (s *Create_materialized_viewContext) Evaluation_edition_clause() IEvaluation_edition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvaluation_edition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvaluation_edition_clauseContext) +} + +func (s *Create_materialized_viewContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Create_materialized_viewContext) COMPUTATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTATION, 0) +} + +func (s *Create_materialized_viewContext) Query_rewrite_clause() IQuery_rewrite_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_rewrite_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_rewrite_clauseContext) +} + +func (s *Create_materialized_viewContext) CONCURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONCURRENT, 0) +} + +func (s *Create_materialized_viewContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Create_materialized_viewContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Create_materialized_viewContext) AllENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENABLE) +} + +func (s *Create_materialized_viewContext) ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, i) +} + +func (s *Create_materialized_viewContext) AllDISABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISABLE) +} + +func (s *Create_materialized_viewContext) DISABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, i) +} + +func (s *Create_materialized_viewContext) AllScoped_table_ref_constraint() []IScoped_table_ref_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IScoped_table_ref_constraintContext); ok { + len++ + } + } + + tst := make([]IScoped_table_ref_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IScoped_table_ref_constraintContext); ok { + tst[i] = t.(IScoped_table_ref_constraintContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Scoped_table_ref_constraint(i int) IScoped_table_ref_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScoped_table_ref_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IScoped_table_ref_constraintContext) +} + +func (s *Create_materialized_viewContext) AllMv_column_alias() []IMv_column_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMv_column_aliasContext); ok { + len++ + } + } + + tst := make([]IMv_column_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMv_column_aliasContext); ok { + tst[i] = t.(IMv_column_aliasContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Mv_column_alias(i int) IMv_column_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_column_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMv_column_aliasContext) +} + +func (s *Create_materialized_viewContext) REDUCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUCED, 0) +} + +func (s *Create_materialized_viewContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Create_materialized_viewContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Create_materialized_viewContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_materialized_viewContext) Build_clause() IBuild_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuild_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuild_clauseContext) +} + +func (s *Create_materialized_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_materialized_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_materialized_viewContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Create_materialized_viewContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Create_materialized_viewContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Create_materialized_viewContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Create_materialized_viewContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_materialized_viewContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_materialized_viewContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_materialized_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_view(s) + } +} + +func (s *Create_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_view(s) + } +} + +func (p *PlSqlParser) Create_materialized_view() (localctx ICreate_materialized_viewContext) { + localctx = NewCreate_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, PlSqlParserRULE_create_materialized_view) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10148) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10149) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10150) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1187, p.GetParserRuleContext()) == 1 { + { + p.SetState(10151) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10152) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10153) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10156) + p.Tableview_name() + } + p.SetState(10159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(10157) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10158) + p.Type_name() + } + + } + p.SetState(10178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10161) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1189, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10162) + p.Scoped_table_ref_constraint() + } + + case 2: + { + p.SetState(10163) + p.Mv_column_alias() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10166) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1190, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10167) + p.Scoped_table_ref_constraint() + } + + case 2: + { + p.SetState(10168) + p.Mv_column_alias() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(10175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10176) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(10180) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10181) + p.Match(PlSqlParserPREBUILT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10182) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(10183) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10184) + p.Match(PlSqlParserREDUCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10185) + p.Match(PlSqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserANNOTATIONS, PlSqlParserAS, PlSqlParserBUILD, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserEVALUATE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserILM, PlSqlParserINITRANS, PlSqlParserINMEMORY, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNEVER, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNO, PlSqlParserNOPARALLEL, PlSqlParserORGANIZATION, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREFRESH, PlSqlParserROW, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserUSING: + p.SetState(10189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&1374389665793) != 0) || _la == PlSqlParserEXTERNAL || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || ((int64((_la-697)) & ^0x3f) == 0 && ((int64(1)<<(_la-697))&633318697598977) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || ((int64((_la-1074)) & ^0x3f) == 0 && ((int64(1)<<(_la-1074))&-9223336852482686975) != 0) || _la == PlSqlParserORGANIZATION || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSEGMENT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(10188) + p.Physical_properties() + } + + } + p.SetState(10192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE { + { + p.SetState(10191) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(10194) + p.Parallel_clause() + } + + } + p.SetState(10198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBUILD { + { + p.SetState(10197) + p.Build_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10219) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1202, p.GetParserRuleContext()) == 1 { + { + p.SetState(10202) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10203) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPUTE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(10207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(10204) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(10205) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10206) + + var _x = p.Id_expression() + + localctx.(*Create_materialized_viewContext).mv_tablespace = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10209) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1200, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + p.SetState(10215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1202, p.GetParserRuleContext()) == 2 { + { + p.SetState(10216) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10217) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10218) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNEVER || _la == PlSqlParserREFRESH { + { + p.SetState(10221) + p.Create_mv_refresh() + } + + } + p.SetState(10225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEVALUATE { + { + p.SetState(10224) + p.Evaluation_edition_clause() + } + + } + p.SetState(10231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1205, p.GetParserRuleContext()) == 1 { + { + p.SetState(10227) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10228) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10229) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10230) + p.Match(PlSqlParserCOMPUTATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10234) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1206, p.GetParserRuleContext()) == 1 { + { + p.SetState(10233) + p.Query_rewrite_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(10236) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10237) + p.Match(PlSqlParserCONCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10238) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANNOTATIONS { + { + p.SetState(10241) + p.Annotations_clause() + } + + } + { + p.SetState(10244) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10245) + p.Select_only_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IScoped_table_ref_constraintContext is an interface to support dynamic dispatch. +type IScoped_table_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRef_column_or_attribute returns the ref_column_or_attribute rule contexts. + GetRef_column_or_attribute() IIdentifierContext + + // GetScope_table_name_or_c_alias returns the scope_table_name_or_c_alias rule contexts. + GetScope_table_name_or_c_alias() IIdentifierContext + + // SetRef_column_or_attribute sets the ref_column_or_attribute rule contexts. + SetRef_column_or_attribute(IIdentifierContext) + + // SetScope_table_name_or_c_alias sets the scope_table_name_or_c_alias rule contexts. + SetScope_table_name_or_c_alias(IIdentifierContext) + + // Getter signatures + SCOPE() antlr.TerminalNode + FOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + IS() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsScoped_table_ref_constraintContext differentiates from other interfaces. + IsScoped_table_ref_constraintContext() +} + +type Scoped_table_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ref_column_or_attribute IIdentifierContext + scope_table_name_or_c_alias IIdentifierContext +} + +func NewEmptyScoped_table_ref_constraintContext() *Scoped_table_ref_constraintContext { + var p = new(Scoped_table_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint + return p +} + +func InitEmptyScoped_table_ref_constraintContext(p *Scoped_table_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint +} + +func (*Scoped_table_ref_constraintContext) IsScoped_table_ref_constraintContext() {} + +func NewScoped_table_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scoped_table_ref_constraintContext { + var p = new(Scoped_table_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint + + return p +} + +func (s *Scoped_table_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Scoped_table_ref_constraintContext) GetRef_column_or_attribute() IIdentifierContext { + return s.ref_column_or_attribute +} + +func (s *Scoped_table_ref_constraintContext) GetScope_table_name_or_c_alias() IIdentifierContext { + return s.scope_table_name_or_c_alias +} + +func (s *Scoped_table_ref_constraintContext) SetRef_column_or_attribute(v IIdentifierContext) { + s.ref_column_or_attribute = v +} + +func (s *Scoped_table_ref_constraintContext) SetScope_table_name_or_c_alias(v IIdentifierContext) { + s.scope_table_name_or_c_alias = v +} + +func (s *Scoped_table_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Scoped_table_ref_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Scoped_table_ref_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Scoped_table_ref_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Scoped_table_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Scoped_table_ref_constraintContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Scoped_table_ref_constraintContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Scoped_table_ref_constraintContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Scoped_table_ref_constraintContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Scoped_table_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Scoped_table_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Scoped_table_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterScoped_table_ref_constraint(s) + } +} + +func (s *Scoped_table_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitScoped_table_ref_constraint(s) + } +} + +func (p *PlSqlParser) Scoped_table_ref_constraint() (localctx IScoped_table_ref_constraintContext) { + localctx = NewScoped_table_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, PlSqlParserRULE_scoped_table_ref_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10247) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10248) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10249) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10250) + + var _x = p.Identifier() + + localctx.(*Scoped_table_ref_constraintContext).ref_column_or_attribute = _x + } + { + p.SetState(10251) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10252) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10256) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1209, p.GetParserRuleContext()) == 1 { + { + p.SetState(10253) + p.Schema_name() + } + { + p.SetState(10254) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10258) + + var _x = p.Identifier() + + localctx.(*Scoped_table_ref_constraintContext).scope_table_name_or_c_alias = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMv_column_aliasContext is an interface to support dynamic dispatch. +type IMv_column_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + Annotations_clause() IAnnotations_clauseContext + Scoped_table_ref_constraint() IScoped_table_ref_constraintContext + + // IsMv_column_aliasContext differentiates from other interfaces. + IsMv_column_aliasContext() +} + +type Mv_column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_column_aliasContext() *Mv_column_aliasContext { + var p = new(Mv_column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_column_alias + return p +} + +func InitEmptyMv_column_aliasContext(p *Mv_column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_column_alias +} + +func (*Mv_column_aliasContext) IsMv_column_aliasContext() {} + +func NewMv_column_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_column_aliasContext { + var p = new(Mv_column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_column_alias + + return p +} + +func (s *Mv_column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_column_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Mv_column_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Mv_column_aliasContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Mv_column_aliasContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Mv_column_aliasContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Mv_column_aliasContext) Scoped_table_ref_constraint() IScoped_table_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScoped_table_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScoped_table_ref_constraintContext) +} + +func (s *Mv_column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_column_alias(s) + } +} + +func (s *Mv_column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_column_alias(s) + } +} + +func (p *PlSqlParser) Mv_column_alias() (localctx IMv_column_aliasContext) { + localctx = NewMv_column_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, PlSqlParserRULE_mv_column_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(10260) + p.Identifier() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(10261) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPT { + { + p.SetState(10264) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10265) + p.Encryption_spec() + } + + } + p.SetState(10270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserANNOTATIONS: + { + p.SetState(10268) + p.Annotations_clause() + } + + case PlSqlParserSCOPE: + { + p.SetState(10269) + p.Scoped_table_ref_constraint() + } + + case PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_mv_refreshContext is an interface to support dynamic dispatch. +type ICreate_mv_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEVER() antlr.TerminalNode + REFRESH() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllFAST() []antlr.TerminalNode + FAST(i int) antlr.TerminalNode + AllCOMPLETE() []antlr.TerminalNode + COMPLETE(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllDEMAND() []antlr.TerminalNode + DEMAND(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllSTATEMENT() []antlr.TerminalNode + STATEMENT(i int) antlr.TerminalNode + AllENFORCED() []antlr.TerminalNode + ENFORCED(i int) antlr.TerminalNode + AllTRUSTED() []antlr.TerminalNode + TRUSTED(i int) antlr.TerminalNode + AllSTART() []antlr.TerminalNode + START(i int) antlr.TerminalNode + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllROWID() []antlr.TerminalNode + ROWID(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllROLLBACK() []antlr.TerminalNode + ROLLBACK(i int) antlr.TerminalNode + AllSEGMENT() []antlr.TerminalNode + SEGMENT(i int) antlr.TerminalNode + AllRollback_segment_name() []IRollback_segment_nameContext + Rollback_segment_name(i int) IRollback_segment_nameContext + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllLOCAL() []antlr.TerminalNode + LOCAL(i int) antlr.TerminalNode + + // IsCreate_mv_refreshContext differentiates from other interfaces. + IsCreate_mv_refreshContext() +} + +type Create_mv_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_mv_refreshContext() *Create_mv_refreshContext { + var p = new(Create_mv_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_mv_refresh + return p +} + +func InitEmptyCreate_mv_refreshContext(p *Create_mv_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_mv_refresh +} + +func (*Create_mv_refreshContext) IsCreate_mv_refreshContext() {} + +func NewCreate_mv_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_mv_refreshContext { + var p = new(Create_mv_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_mv_refresh + + return p +} + +func (s *Create_mv_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_mv_refreshContext) NEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEVER, 0) +} + +func (s *Create_mv_refreshContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Create_mv_refreshContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Create_mv_refreshContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Create_mv_refreshContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Create_mv_refreshContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_mv_refreshContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Create_mv_refreshContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Create_mv_refreshContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Create_mv_refreshContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Create_mv_refreshContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Create_mv_refreshContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Create_mv_refreshContext) AllFAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAST) +} + +func (s *Create_mv_refreshContext) FAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, i) +} + +func (s *Create_mv_refreshContext) AllCOMPLETE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMPLETE) +} + +func (s *Create_mv_refreshContext) COMPLETE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, i) +} + +func (s *Create_mv_refreshContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Create_mv_refreshContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Create_mv_refreshContext) AllDEMAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEMAND) +} + +func (s *Create_mv_refreshContext) DEMAND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, i) +} + +func (s *Create_mv_refreshContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Create_mv_refreshContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Create_mv_refreshContext) AllSTATEMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATEMENT) +} + +func (s *Create_mv_refreshContext) STATEMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, i) +} + +func (s *Create_mv_refreshContext) AllENFORCED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENFORCED) +} + +func (s *Create_mv_refreshContext) ENFORCED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, i) +} + +func (s *Create_mv_refreshContext) AllTRUSTED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRUSTED) +} + +func (s *Create_mv_refreshContext) TRUSTED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, i) +} + +func (s *Create_mv_refreshContext) AllSTART() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTART) +} + +func (s *Create_mv_refreshContext) START(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, i) +} + +func (s *Create_mv_refreshContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Create_mv_refreshContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Create_mv_refreshContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Create_mv_refreshContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Create_mv_refreshContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Create_mv_refreshContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Create_mv_refreshContext) AllROWID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROWID) +} + +func (s *Create_mv_refreshContext) ROWID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, i) +} + +func (s *Create_mv_refreshContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Create_mv_refreshContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Create_mv_refreshContext) AllROLLBACK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROLLBACK) +} + +func (s *Create_mv_refreshContext) ROLLBACK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, i) +} + +func (s *Create_mv_refreshContext) AllSEGMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEGMENT) +} + +func (s *Create_mv_refreshContext) SEGMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, i) +} + +func (s *Create_mv_refreshContext) AllRollback_segment_name() []IRollback_segment_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + len++ + } + } + + tst := make([]IRollback_segment_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRollback_segment_nameContext); ok { + tst[i] = t.(IRollback_segment_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_mv_refreshContext) Rollback_segment_name(i int) IRollback_segment_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Create_mv_refreshContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMASTER) +} + +func (s *Create_mv_refreshContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, i) +} + +func (s *Create_mv_refreshContext) AllLOCAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOCAL) +} + +func (s *Create_mv_refreshContext) LOCAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, i) +} + +func (s *Create_mv_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_mv_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_mv_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_mv_refresh(s) + } +} + +func (s *Create_mv_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_mv_refresh(s) + } +} + +func (p *PlSqlParser) Create_mv_refresh() (localctx ICreate_mv_refreshContext) { + localctx = NewCreate_mv_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, PlSqlParserRULE_create_mv_refresh) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNEVER: + { + p.SetState(10272) + p.Match(PlSqlParserNEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10273) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREFRESH: + { + p.SetState(10274) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE || _la == PlSqlParserNEXT || _la == PlSqlParserON || _la == PlSqlParserSTART || _la == PlSqlParserUSING || _la == PlSqlParserWITH { + p.SetState(10308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1218, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10275) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(10276) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10277) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserDEMAND || _la == PlSqlParserSTATEMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.SetState(10281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + { + p.SetState(10278) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10279) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNEXT: + { + p.SetState(10280) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10283) + p.Expression() + } + + case 4: + { + p.SetState(10284) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY: + { + p.SetState(10285) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10286) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(10287) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 5: + { + p.SetState(10290) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(10291) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL || _la == PlSqlParserMASTER { + { + p.SetState(10292) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCAL || _la == PlSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10295) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10296) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOCAL, PlSqlParserMASTER, PlSqlParserROLLBACK: + p.SetState(10298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL || _la == PlSqlParserMASTER { + { + p.SetState(10297) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCAL || _la == PlSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10300) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10301) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10302) + p.Rollback_segment_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + { + p.SetState(10305) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10306) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENFORCED || _la == PlSqlParserTRUSTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10307) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(10310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_rewrite_clauseContext is an interface to support dynamic dispatch. +type IQuery_rewrite_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + Unusable_editions_clause() IUnusable_editions_clauseContext + + // IsQuery_rewrite_clauseContext differentiates from other interfaces. + IsQuery_rewrite_clauseContext() +} + +type Query_rewrite_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_rewrite_clauseContext() *Query_rewrite_clauseContext { + var p = new(Query_rewrite_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_rewrite_clause + return p +} + +func InitEmptyQuery_rewrite_clauseContext(p *Query_rewrite_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_rewrite_clause +} + +func (*Query_rewrite_clauseContext) IsQuery_rewrite_clauseContext() {} + +func NewQuery_rewrite_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_rewrite_clauseContext { + var p = new(Query_rewrite_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_rewrite_clause + + return p +} + +func (s *Query_rewrite_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_rewrite_clauseContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Query_rewrite_clauseContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Query_rewrite_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Query_rewrite_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Query_rewrite_clauseContext) Unusable_editions_clause() IUnusable_editions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnusable_editions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnusable_editions_clauseContext) +} + +func (s *Query_rewrite_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_rewrite_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_rewrite_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_rewrite_clause(s) + } +} + +func (s *Query_rewrite_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_rewrite_clause(s) + } +} + +func (p *PlSqlParser) Query_rewrite_clause() (localctx IQuery_rewrite_clauseContext) { + localctx = NewQuery_rewrite_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, PlSqlParserRULE_query_rewrite_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10314) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10315) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10316) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(10317) + p.Unusable_editions_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnusable_editions_clauseContext is an interface to support dynamic dispatch. +type IUnusable_editions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNUSABLE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + EDITION() antlr.TerminalNode + Edition_name() IEdition_nameContext + BEGINNING() antlr.TerminalNode + WITH() antlr.TerminalNode + NULL_() antlr.TerminalNode + BEFORE() antlr.TerminalNode + + // IsUnusable_editions_clauseContext differentiates from other interfaces. + IsUnusable_editions_clauseContext() +} + +type Unusable_editions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnusable_editions_clauseContext() *Unusable_editions_clauseContext { + var p = new(Unusable_editions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unusable_editions_clause + return p +} + +func InitEmptyUnusable_editions_clauseContext(p *Unusable_editions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unusable_editions_clause +} + +func (*Unusable_editions_clauseContext) IsUnusable_editions_clauseContext() {} + +func NewUnusable_editions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unusable_editions_clauseContext { + var p = new(Unusable_editions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unusable_editions_clause + + return p +} + +func (s *Unusable_editions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unusable_editions_clauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Unusable_editions_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Unusable_editions_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Unusable_editions_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Unusable_editions_clauseContext) BEGINNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGINNING, 0) +} + +func (s *Unusable_editions_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Unusable_editions_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Unusable_editions_clauseContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Unusable_editions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unusable_editions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unusable_editions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnusable_editions_clause(s) + } +} + +func (s *Unusable_editions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnusable_editions_clause(s) + } +} + +func (p *PlSqlParser) Unusable_editions_clause() (localctx IUnusable_editions_clauseContext) { + localctx = NewUnusable_editions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, PlSqlParserRULE_unusable_editions_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10320) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1224, p.GetParserRuleContext()) { + case 1: + p.SetState(10324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBEFORE: + { + p.SetState(10321) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBEGINNING: + { + p.SetState(10322) + p.Match(PlSqlParserBEGINNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10323) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10326) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10327) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(10331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBEFORE: + { + p.SetState(10328) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBEGINNING: + { + p.SetState(10329) + p.Match(PlSqlParserBEGINNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10330) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10333) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10334) + p.Edition_name() + } + + case 3: + { + p.SetState(10335) + p.Match(PlSqlParserBEGINNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10336) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10337) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10338) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_materialized_viewContext is an interface to support dynamic dispatch. +type IDrop_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + PRESERVE() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // IsDrop_materialized_viewContext differentiates from other interfaces. + IsDrop_materialized_viewContext() +} + +type Drop_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_materialized_viewContext() *Drop_materialized_viewContext { + var p = new(Drop_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_view + return p +} + +func InitEmptyDrop_materialized_viewContext(p *Drop_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_view +} + +func (*Drop_materialized_viewContext) IsDrop_materialized_viewContext() {} + +func NewDrop_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_materialized_viewContext { + var p = new(Drop_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_materialized_view + + return p +} + +func (s *Drop_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_materialized_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_materialized_viewContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Drop_materialized_viewContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Drop_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_materialized_view(s) + } +} + +func (s *Drop_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_materialized_view(s) + } +} + +func (p *PlSqlParser) Drop_materialized_view() (localctx IDrop_materialized_viewContext) { + localctx = NewDrop_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, PlSqlParserRULE_drop_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10341) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10342) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10343) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10344) + p.Tableview_name() + } + p.SetState(10347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRESERVE { + { + p.SetState(10345) + p.Match(PlSqlParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10346) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_materialized_view_logContext is an interface to support dynamic dispatch. +type IDrop_materialized_view_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_materialized_view_logContext differentiates from other interfaces. + IsDrop_materialized_view_logContext() +} + +type Drop_materialized_view_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_materialized_view_logContext() *Drop_materialized_view_logContext { + var p = new(Drop_materialized_view_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_view_log + return p +} + +func InitEmptyDrop_materialized_view_logContext(p *Drop_materialized_view_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_view_log +} + +func (*Drop_materialized_view_logContext) IsDrop_materialized_view_logContext() {} + +func NewDrop_materialized_view_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_materialized_view_logContext { + var p = new(Drop_materialized_view_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_materialized_view_log + + return p +} + +func (s *Drop_materialized_view_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_materialized_view_logContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_materialized_view_logContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_view_logContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_materialized_view_logContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Drop_materialized_view_logContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Drop_materialized_view_logContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_materialized_view_logContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_materialized_view_logContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_materialized_view_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_materialized_view_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_materialized_view_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_materialized_view_log(s) + } +} + +func (s *Drop_materialized_view_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_materialized_view_log(s) + } +} + +func (p *PlSqlParser) Drop_materialized_view_log() (localctx IDrop_materialized_view_logContext) { + localctx = NewDrop_materialized_view_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, PlSqlParserRULE_drop_materialized_view_log) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10349) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10350) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10351) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10352) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(10353) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10354) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10357) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10358) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_contextContext is an interface to support dynamic dispatch. +type ICreate_contextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + Oracle_namespace() IOracle_namespaceContext + USING() antlr.TerminalNode + Package_name() IPackage_nameContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + INITIALIZED() antlr.TerminalNode + ACCESSED() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + + // IsCreate_contextContext differentiates from other interfaces. + IsCreate_contextContext() +} + +type Create_contextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_contextContext() *Create_contextContext { + var p = new(Create_contextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_context + return p +} + +func InitEmptyCreate_contextContext(p *Create_contextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_context +} + +func (*Create_contextContext) IsCreate_contextContext() {} + +func NewCreate_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_contextContext { + var p = new(Create_contextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_context + + return p +} + +func (s *Create_contextContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_contextContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_contextContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Create_contextContext) Oracle_namespace() IOracle_namespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOracle_namespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOracle_namespaceContext) +} + +func (s *Create_contextContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_contextContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_contextContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_contextContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_contextContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_contextContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_contextContext) INITIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALIZED, 0) +} + +func (s *Create_contextContext) ACCESSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSED, 0) +} + +func (s *Create_contextContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Create_contextContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Create_contextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_contextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_context(s) + } +} + +func (s *Create_contextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_context(s) + } +} + +func (p *PlSqlParser) Create_context() (localctx ICreate_contextContext) { + localctx = NewCreate_contextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, PlSqlParserRULE_create_context) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10360) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(10361) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10362) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10365) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10366) + p.Oracle_namespace() + } + { + p.SetState(10367) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10371) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1228, p.GetParserRuleContext()) == 1 { + { + p.SetState(10368) + p.Schema_object_name() + } + { + p.SetState(10369) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10373) + p.Package_name() + } + p.SetState(10378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINITIALIZED: + { + p.SetState(10374) + p.Match(PlSqlParserINITIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10375) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXTERNALLY || _la == PlSqlParserGLOBALLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserACCESSED: + { + p.SetState(10376) + p.Match(PlSqlParserACCESSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10377) + p.Match(PlSqlParserGLOBALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOracle_namespaceContext is an interface to support dynamic dispatch. +type IOracle_namespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsOracle_namespaceContext differentiates from other interfaces. + IsOracle_namespaceContext() +} + +type Oracle_namespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOracle_namespaceContext() *Oracle_namespaceContext { + var p = new(Oracle_namespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oracle_namespace + return p +} + +func InitEmptyOracle_namespaceContext(p *Oracle_namespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oracle_namespace +} + +func (*Oracle_namespaceContext) IsOracle_namespaceContext() {} + +func NewOracle_namespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oracle_namespaceContext { + var p = new(Oracle_namespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oracle_namespace + + return p +} + +func (s *Oracle_namespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oracle_namespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Oracle_namespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oracle_namespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oracle_namespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOracle_namespace(s) + } +} + +func (s *Oracle_namespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOracle_namespace(s) + } +} + +func (p *PlSqlParser) Oracle_namespace() (localctx IOracle_namespaceContext) { + localctx = NewOracle_namespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, PlSqlParserRULE_oracle_namespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10380) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_clusterContext is an interface to support dynamic dispatch. +type ICreate_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + AllSORT() []antlr.TerminalNode + SORT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllINDEX() []antlr.TerminalNode + INDEX(i int) antlr.TerminalNode + AllHASHKEYS() []antlr.TerminalNode + HASHKEYS(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + ROWDEPENDENCIES() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + AllSINGLE() []antlr.TerminalNode + SINGLE(i int) antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + AllHASH() []antlr.TerminalNode + HASH(i int) antlr.TerminalNode + AllIS() []antlr.TerminalNode + IS(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsCreate_clusterContext differentiates from other interfaces. + IsCreate_clusterContext() +} + +type Create_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_clusterContext() *Create_clusterContext { + var p = new(Create_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_cluster + return p +} + +func InitEmptyCreate_clusterContext(p *Create_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_cluster +} + +func (*Create_clusterContext) IsCreate_clusterContext() {} + +func NewCreate_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_clusterContext { + var p = new(Create_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_cluster + + return p +} + +func (s *Create_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_clusterContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Create_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Create_clusterContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_clusterContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Create_clusterContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Create_clusterContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_clusterContext) AllSORT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSORT) +} + +func (s *Create_clusterContext) SORT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, i) +} + +func (s *Create_clusterContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_clusterContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_clusterContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_clusterContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Create_clusterContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Create_clusterContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Create_clusterContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_clusterContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_clusterContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Create_clusterContext) AllINDEX() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINDEX) +} + +func (s *Create_clusterContext) INDEX(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, i) +} + +func (s *Create_clusterContext) AllHASHKEYS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHASHKEYS) +} + +func (s *Create_clusterContext) HASHKEYS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHKEYS, i) +} + +func (s *Create_clusterContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Create_clusterContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Create_clusterContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_clusterContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Create_clusterContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Create_clusterContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Create_clusterContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Create_clusterContext) AllSINGLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSINGLE) +} + +func (s *Create_clusterContext) SINGLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, i) +} + +func (s *Create_clusterContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLE) +} + +func (s *Create_clusterContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, i) +} + +func (s *Create_clusterContext) AllHASH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHASH) +} + +func (s *Create_clusterContext) HASH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, i) +} + +func (s *Create_clusterContext) AllIS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIS) +} + +func (s *Create_clusterContext) IS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, i) +} + +func (s *Create_clusterContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_cluster(s) + } +} + +func (s *Create_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_cluster(s) + } +} + +func (p *PlSqlParser) Create_cluster() (localctx ICreate_clusterContext) { + localctx = NewCreate_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, PlSqlParserRULE_create_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10382) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10383) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10384) + p.Cluster_name() + } + { + p.SetState(10385) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10386) + p.Column_name() + } + { + p.SetState(10387) + p.Datatype() + } + p.SetState(10389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(10388) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10391) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10392) + p.Column_name() + } + { + p.SetState(10393) + p.Datatype() + } + p.SetState(10395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(10394) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(10401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10402) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPUTE || _la == PlSqlParserHASHKEYS || _la == PlSqlParserINDEX || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSINGLE || _la == PlSqlParserSIZE || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(10403) + p.Physical_attributes_clause() + } + + case PlSqlParserSIZE: + { + p.SetState(10404) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10405) + p.Size_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(10406) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10407) + p.Tablespace() + } + + case PlSqlParserINDEX: + { + p.SetState(10408) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASHKEYS, PlSqlParserSINGLE: + p.SetState(10411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSINGLE { + { + p.SetState(10409) + p.Match(PlSqlParserSINGLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10410) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10413) + p.Match(PlSqlParserHASHKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10414) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHASH { + { + p.SetState(10415) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10416) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10417) + p.Expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(10426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(10425) + p.Parallel_clause() + } + + } + p.SetState(10429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES { + { + p.SetState(10428) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE { + { + p.SetState(10431) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_profileContext is an interface to support dynamic dispatch. +type ICreate_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + PROFILE() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Id_expression() IId_expressionContext + MANDATORY() antlr.TerminalNode + AllResource_parameters() []IResource_parametersContext + Resource_parameters(i int) IResource_parametersContext + AllPassword_parameters() []IPassword_parametersContext + Password_parameters(i int) IPassword_parametersContext + Container_clause() IContainer_clauseContext + + // IsCreate_profileContext differentiates from other interfaces. + IsCreate_profileContext() +} + +type Create_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyCreate_profileContext() *Create_profileContext { + var p = new(Create_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_profile + return p +} + +func InitEmptyCreate_profileContext(p *Create_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_profile +} + +func (*Create_profileContext) IsCreate_profileContext() {} + +func NewCreate_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_profileContext { + var p = new(Create_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_profile + + return p +} + +func (s *Create_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_profileContext) GetP() IId_expressionContext { return s.p } + +func (s *Create_profileContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Create_profileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Create_profileContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Create_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_profileContext) MANDATORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANDATORY, 0) +} + +func (s *Create_profileContext) AllResource_parameters() []IResource_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResource_parametersContext); ok { + len++ + } + } + + tst := make([]IResource_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResource_parametersContext); ok { + tst[i] = t.(IResource_parametersContext) + i++ + } + } + + return tst +} + +func (s *Create_profileContext) Resource_parameters(i int) IResource_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResource_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResource_parametersContext) +} + +func (s *Create_profileContext) AllPassword_parameters() []IPassword_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_parametersContext); ok { + len++ + } + } + + tst := make([]IPassword_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_parametersContext); ok { + tst[i] = t.(IPassword_parametersContext) + i++ + } + } + + return tst +} + +func (s *Create_profileContext) Password_parameters(i int) IPassword_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_parametersContext) +} + +func (s *Create_profileContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_profile(s) + } +} + +func (s *Create_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_profile(s) + } +} + +func (p *PlSqlParser) Create_profile() (localctx ICreate_profileContext) { + localctx = NewCreate_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, PlSqlParserRULE_create_profile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10434) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMANDATORY { + { + p.SetState(10435) + p.Match(PlSqlParserMANDATORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10438) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10439) + + var _x = p.Id_expression() + + localctx.(*Create_profileContext).p = _x + } + { + p.SetState(10440) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-4611686018393833471) != 0) || _la == PlSqlParserFAILED_LOGIN_ATTEMPTS || _la == PlSqlParserIDLE_TIME || _la == PlSqlParserINACTIVE_ACCOUNT_TIME || _la == PlSqlParserLOGICAL_READS_PER_CALL || _la == PlSqlParserLOGICAL_READS_PER_SESSION || ((int64((_la-1353)) & ^0x3f) == 0 && ((int64(1)<<(_la-1353))&247) != 0) || _la == PlSqlParserPRIVATE_SGA || _la == PlSqlParserSESSIONS_PER_USER { + p.SetState(10443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCONNECT_TIME, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserIDLE_TIME, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserPRIVATE_SGA, PlSqlParserSESSIONS_PER_USER: + { + p.SetState(10441) + p.Resource_parameters() + } + + case PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION: + { + p.SetState(10442) + p.Password_parameters() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(10448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(10447) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResource_parametersContext is an interface to support dynamic dispatch. +type IResource_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SESSIONS_PER_USER() antlr.TerminalNode + CPU_PER_SESSION() antlr.TerminalNode + CPU_PER_CALL() antlr.TerminalNode + CONNECT_TIME() antlr.TerminalNode + IDLE_TIME() antlr.TerminalNode + LOGICAL_READS_PER_SESSION() antlr.TerminalNode + LOGICAL_READS_PER_CALL() antlr.TerminalNode + COMPOSITE_LIMIT() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PRIVATE_SGA() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsResource_parametersContext differentiates from other interfaces. + IsResource_parametersContext() +} + +type Resource_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResource_parametersContext() *Resource_parametersContext { + var p = new(Resource_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resource_parameters + return p +} + +func InitEmptyResource_parametersContext(p *Resource_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resource_parameters +} + +func (*Resource_parametersContext) IsResource_parametersContext() {} + +func NewResource_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resource_parametersContext { + var p = new(Resource_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resource_parameters + + return p +} + +func (s *Resource_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resource_parametersContext) SESSIONS_PER_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONS_PER_USER, 0) +} + +func (s *Resource_parametersContext) CPU_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, 0) +} + +func (s *Resource_parametersContext) CPU_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_CALL, 0) +} + +func (s *Resource_parametersContext) CONNECT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, 0) +} + +func (s *Resource_parametersContext) IDLE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE_TIME, 0) +} + +func (s *Resource_parametersContext) LOGICAL_READS_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, 0) +} + +func (s *Resource_parametersContext) LOGICAL_READS_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_CALL, 0) +} + +func (s *Resource_parametersContext) COMPOSITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE_LIMIT, 0) +} + +func (s *Resource_parametersContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Resource_parametersContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Resource_parametersContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Resource_parametersContext) PRIVATE_SGA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, 0) +} + +func (s *Resource_parametersContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Resource_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resource_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resource_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResource_parameters(s) + } +} + +func (s *Resource_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResource_parameters(s) + } +} + +func (p *PlSqlParser) Resource_parameters() (localctx IResource_parametersContext) { + localctx = NewResource_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, PlSqlParserRULE_resource_parameters) + var _la int + + p.SetState(10458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCONNECT_TIME, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserIDLE_TIME, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserSESSIONS_PER_USER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10450) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-4611686018393833471) != 0) || _la == PlSqlParserIDLE_TIME || _la == PlSqlParserLOGICAL_READS_PER_CALL || _la == PlSqlParserLOGICAL_READS_PER_SESSION || _la == PlSqlParserSESSIONS_PER_USER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10451) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPRIVATE_SGA: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10452) + p.Match(PlSqlParserPRIVATE_SGA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(10453) + p.Size_clause() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(10454) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(10455) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPassword_parametersContext is an interface to support dynamic dispatch. +type IPassword_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + PASSWORD_LIFE_TIME() antlr.TerminalNode + PASSWORD_REUSE_TIME() antlr.TerminalNode + PASSWORD_REUSE_MAX() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PASSWORD_GRACE_TIME() antlr.TerminalNode + INACTIVE_ACCOUNT_TIME() antlr.TerminalNode + Expression() IExpressionContext + UNLIMITED() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + NULL_() antlr.TerminalNode + PASSWORD_ROLLOVER_TIME() antlr.TerminalNode + + // IsPassword_parametersContext differentiates from other interfaces. + IsPassword_parametersContext() +} + +type Password_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_parametersContext() *Password_parametersContext { + var p = new(Password_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_parameters + return p +} + +func InitEmptyPassword_parametersContext(p *Password_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_parameters +} + +func (*Password_parametersContext) IsPassword_parametersContext() {} + +func NewPassword_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_parametersContext { + var p = new(Password_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_parameters + + return p +} + +func (s *Password_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_parametersContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *Password_parametersContext) PASSWORD_LIFE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LIFE_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_REUSE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_REUSE_MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_MAX, 0) +} + +func (s *Password_parametersContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_GRACE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_GRACE_TIME, 0) +} + +func (s *Password_parametersContext) INACTIVE_ACCOUNT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE_ACCOUNT_TIME, 0) +} + +func (s *Password_parametersContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Password_parametersContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Password_parametersContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Password_parametersContext) PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_VERIFY_FUNCTION, 0) +} + +func (s *Password_parametersContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Password_parametersContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Password_parametersContext) PASSWORD_ROLLOVER_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_ROLLOVER_TIME, 0) +} + +func (s *Password_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_parameters(s) + } +} + +func (s *Password_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_parameters(s) + } +} + +func (p *PlSqlParser) Password_parameters() (localctx IPassword_parametersContext) { + localctx = NewPassword_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, PlSqlParserRULE_password_parameters) + var _la int + + p.SetState(10477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10460) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFAILED_LOGIN_ATTEMPTS || _la == PlSqlParserINACTIVE_ACCOUNT_TIME || ((int64((_la-1353)) & ^0x3f) == 0 && ((int64(1)<<(_la-1353))&55) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1246, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10461) + p.Expression() + } + + case 2: + { + p.SetState(10462) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10463) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserPASSWORD_VERIFY_FUNCTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10466) + p.Match(PlSqlParserPASSWORD_VERIFY_FUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(10467) + p.Function_name() + } + + case PlSqlParserNULL_: + { + p.SetState(10468) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(10469) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserPASSWORD_ROLLOVER_TIME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10472) + p.Match(PlSqlParserPASSWORD_ROLLOVER_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1248, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10473) + p.Expression() + } + + case 2: + { + p.SetState(10474) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_lockdown_profileContext is an interface to support dynamic dispatch. +type ICreate_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + Static_base_profile() IStatic_base_profileContext + Dynamic_base_profile() IDynamic_base_profileContext + + // IsCreate_lockdown_profileContext differentiates from other interfaces. + IsCreate_lockdown_profileContext() +} + +type Create_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_lockdown_profileContext() *Create_lockdown_profileContext { + var p = new(Create_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile + return p +} + +func InitEmptyCreate_lockdown_profileContext(p *Create_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile +} + +func (*Create_lockdown_profileContext) IsCreate_lockdown_profileContext() {} + +func NewCreate_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_lockdown_profileContext { + var p = new(Create_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile + + return p +} + +func (s *Create_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_lockdown_profileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Create_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Create_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_lockdown_profileContext) Static_base_profile() IStatic_base_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_base_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_base_profileContext) +} + +func (s *Create_lockdown_profileContext) Dynamic_base_profile() IDynamic_base_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDynamic_base_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDynamic_base_profileContext) +} + +func (s *Create_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_lockdown_profile(s) + } +} + +func (s *Create_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_lockdown_profile(s) + } +} + +func (p *PlSqlParser) Create_lockdown_profile() (localctx ICreate_lockdown_profileContext) { + localctx = NewCreate_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, PlSqlParserRULE_create_lockdown_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10479) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10480) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10481) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10482) + p.Id_expression() + } + p.SetState(10485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserFROM: + { + p.SetState(10483) + p.Static_base_profile() + } + + case PlSqlParserINCLUDING: + { + p.SetState(10484) + p.Dynamic_base_profile() + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatic_base_profileContext is an interface to support dynamic dispatch. +type IStatic_base_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBp returns the bp rule contexts. + GetBp() IId_expressionContext + + // SetBp sets the bp rule contexts. + SetBp(IId_expressionContext) + + // Getter signatures + FROM() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsStatic_base_profileContext differentiates from other interfaces. + IsStatic_base_profileContext() +} + +type Static_base_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bp IId_expressionContext +} + +func NewEmptyStatic_base_profileContext() *Static_base_profileContext { + var p = new(Static_base_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_base_profile + return p +} + +func InitEmptyStatic_base_profileContext(p *Static_base_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_base_profile +} + +func (*Static_base_profileContext) IsStatic_base_profileContext() {} + +func NewStatic_base_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Static_base_profileContext { + var p = new(Static_base_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_static_base_profile + + return p +} + +func (s *Static_base_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Static_base_profileContext) GetBp() IId_expressionContext { return s.bp } + +func (s *Static_base_profileContext) SetBp(v IId_expressionContext) { s.bp = v } + +func (s *Static_base_profileContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Static_base_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Static_base_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Static_base_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Static_base_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatic_base_profile(s) + } +} + +func (s *Static_base_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatic_base_profile(s) + } +} + +func (p *PlSqlParser) Static_base_profile() (localctx IStatic_base_profileContext) { + localctx = NewStatic_base_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, PlSqlParserRULE_static_base_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10487) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10488) + + var _x = p.Id_expression() + + localctx.(*Static_base_profileContext).bp = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDynamic_base_profileContext is an interface to support dynamic dispatch. +type IDynamic_base_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBp returns the bp rule contexts. + GetBp() IId_expressionContext + + // SetBp sets the bp rule contexts. + SetBp(IId_expressionContext) + + // Getter signatures + INCLUDING() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDynamic_base_profileContext differentiates from other interfaces. + IsDynamic_base_profileContext() +} + +type Dynamic_base_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bp IId_expressionContext +} + +func NewEmptyDynamic_base_profileContext() *Dynamic_base_profileContext { + var p = new(Dynamic_base_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile + return p +} + +func InitEmptyDynamic_base_profileContext(p *Dynamic_base_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile +} + +func (*Dynamic_base_profileContext) IsDynamic_base_profileContext() {} + +func NewDynamic_base_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dynamic_base_profileContext { + var p = new(Dynamic_base_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile + + return p +} + +func (s *Dynamic_base_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dynamic_base_profileContext) GetBp() IId_expressionContext { return s.bp } + +func (s *Dynamic_base_profileContext) SetBp(v IId_expressionContext) { s.bp = v } + +func (s *Dynamic_base_profileContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Dynamic_base_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dynamic_base_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dynamic_base_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dynamic_base_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDynamic_base_profile(s) + } +} + +func (s *Dynamic_base_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDynamic_base_profile(s) + } +} + +func (p *PlSqlParser) Dynamic_base_profile() (localctx IDynamic_base_profileContext) { + localctx = NewDynamic_base_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, PlSqlParserRULE_dynamic_base_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10490) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10491) + + var _x = p.Id_expression() + + localctx.(*Dynamic_base_profileContext).bp = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_outlineContext is an interface to support dynamic dispatch. +type ICreate_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // GetSo returns the so rule contexts. + GetSo() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // SetSo sets the so rule contexts. + SetSo(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FROM() antlr.TerminalNode + FOR() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + ON() antlr.TerminalNode + Statement() IStatementContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + AllPRIVATE() []antlr.TerminalNode + PRIVATE(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsCreate_outlineContext differentiates from other interfaces. + IsCreate_outlineContext() +} + +type Create_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext + so IId_expressionContext + c IId_expressionContext +} + +func NewEmptyCreate_outlineContext() *Create_outlineContext { + var p = new(Create_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_outline + return p +} + +func InitEmptyCreate_outlineContext(p *Create_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_outline +} + +func (*Create_outlineContext) IsCreate_outlineContext() {} + +func NewCreate_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_outlineContext { + var p = new(Create_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_outline + + return p +} + +func (s *Create_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Create_outlineContext) GetSo() IId_expressionContext { return s.so } + +func (s *Create_outlineContext) GetC() IId_expressionContext { return s.c } + +func (s *Create_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Create_outlineContext) SetSo(v IId_expressionContext) { s.so = v } + +func (s *Create_outlineContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Create_outlineContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Create_outlineContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_outlineContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_outlineContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_outlineContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_outlineContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Create_outlineContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_outlineContext) Statement() IStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *Create_outlineContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Create_outlineContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Create_outlineContext) AllPRIVATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVATE) +} + +func (s *Create_outlineContext) PRIVATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, i) +} + +func (s *Create_outlineContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_outlineContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_outline(s) + } +} + +func (s *Create_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_outline(s) + } +} + +func (p *PlSqlParser) Create_outline() (localctx ICreate_outlineContext) { + localctx = NewCreate_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, PlSqlParserRULE_create_outline) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10493) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(10494) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10495) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC { + { + p.SetState(10498) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10501) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(10502) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).o = _x + } + + } + p.SetState(10510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFROM { + { + p.SetState(10505) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10507) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1254, p.GetParserRuleContext()) == 1 { + { + p.SetState(10506) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10509) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).so = _x + } + + } + p.SetState(10515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(10512) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10513) + p.Match(PlSqlParserCATEGORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10514) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).c = _x + } + + } + p.SetState(10519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10517) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10518) + p.Statement() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_restore_pointContext is an interface to support dynamic dispatch. +type ICreate_restore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRp returns the rp rule contexts. + GetRp() IId_expressionContext + + // GetPdb returns the pdb rule contexts. + GetPdb() IId_expressionContext + + // SetRp sets the rp rule contexts. + SetRp(IId_expressionContext) + + // SetPdb sets the pdb rule contexts. + SetPdb(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + CLEAN() antlr.TerminalNode + FOR() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + AllDATABASE() []antlr.TerminalNode + DATABASE(i int) antlr.TerminalNode + AS() antlr.TerminalNode + OF() antlr.TerminalNode + Expression() IExpressionContext + PRESERVE() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + SCN() antlr.TerminalNode + + // IsCreate_restore_pointContext differentiates from other interfaces. + IsCreate_restore_pointContext() +} + +type Create_restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rp IId_expressionContext + pdb IId_expressionContext +} + +func NewEmptyCreate_restore_pointContext() *Create_restore_pointContext { + var p = new(Create_restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_restore_point + return p +} + +func InitEmptyCreate_restore_pointContext(p *Create_restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_restore_point +} + +func (*Create_restore_pointContext) IsCreate_restore_pointContext() {} + +func NewCreate_restore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_restore_pointContext { + var p = new(Create_restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_restore_point + + return p +} + +func (s *Create_restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_restore_pointContext) GetRp() IId_expressionContext { return s.rp } + +func (s *Create_restore_pointContext) GetPdb() IId_expressionContext { return s.pdb } + +func (s *Create_restore_pointContext) SetRp(v IId_expressionContext) { s.rp = v } + +func (s *Create_restore_pointContext) SetPdb(v IId_expressionContext) { s.pdb = v } + +func (s *Create_restore_pointContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_restore_pointContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Create_restore_pointContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Create_restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_restore_pointContext) CLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAN, 0) +} + +func (s *Create_restore_pointContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_restore_pointContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Create_restore_pointContext) AllDATABASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATABASE) +} + +func (s *Create_restore_pointContext) DATABASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, i) +} + +func (s *Create_restore_pointContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_restore_pointContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_restore_pointContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_restore_pointContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Create_restore_pointContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Create_restore_pointContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Create_restore_pointContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Create_restore_pointContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Create_restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_restore_point(s) + } +} + +func (s *Create_restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_restore_point(s) + } +} + +func (p *PlSqlParser) Create_restore_point() (localctx ICreate_restore_pointContext) { + localctx = NewCreate_restore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, PlSqlParserRULE_create_restore_point) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10521) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLEAN { + { + p.SetState(10522) + p.Match(PlSqlParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10525) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10526) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10527) + + var _x = p.Id_expression() + + localctx.(*Create_restore_pointContext).rp = _x + } + p.SetState(10532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(10528) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10529) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10530) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10531) + + var _x = p.Id_expression() + + localctx.(*Create_restore_pointContext).pdb = _x + } + + } + p.SetState(10538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(10534) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10535) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10536) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10537) + p.Expression() + } + + } + p.SetState(10544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRESERVE: + { + p.SetState(10540) + p.Match(PlSqlParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGUARANTEE: + { + p.SetState(10541) + p.Match(PlSqlParserGUARANTEE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10542) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10543) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_roleContext is an interface to support dynamic dispatch. +type ICreate_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_name() IRole_nameContext + Role_identified_clause() IRole_identified_clauseContext + Container_clause() IContainer_clauseContext + + // IsCreate_roleContext differentiates from other interfaces. + IsCreate_roleContext() +} + +type Create_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_roleContext() *Create_roleContext { + var p = new(Create_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_role + return p +} + +func InitEmptyCreate_roleContext(p *Create_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_role +} + +func (*Create_roleContext) IsCreate_roleContext() {} + +func NewCreate_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_roleContext { + var p = new(Create_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_role + + return p +} + +func (s *Create_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Create_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Create_roleContext) Role_identified_clause() IRole_identified_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_identified_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_identified_clauseContext) +} + +func (s *Create_roleContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_role(s) + } +} + +func (s *Create_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_role(s) + } +} + +func (p *PlSqlParser) Create_role() (localctx ICreate_roleContext) { + localctx = NewCreate_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, PlSqlParserRULE_create_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10546) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10547) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10548) + p.Role_name() + } + p.SetState(10550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED || _la == PlSqlParserNOT { + { + p.SetState(10549) + p.Role_identified_clause() + } + + } + p.SetState(10553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(10552) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_tableContext is an interface to support dynamic dispatch. +type ICreate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + Relational_table() IRelational_tableContext + Xmltype_table() IXmltype_tableContext + Object_table() IObject_tableContext + TEMPORARY() antlr.TerminalNode + SHARDED() antlr.TerminalNode + DUPLICATED() antlr.TerminalNode + BLOCKCHAIN() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Memoptimize_read_write_clause() IMemoptimize_read_write_clauseContext + PARENT() antlr.TerminalNode + Tableview_name() ITableview_nameContext + USAGE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + METADATA() antlr.TerminalNode + DATA() antlr.TerminalNode + NONE() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + + // IsCreate_tableContext differentiates from other interfaces. + IsCreate_tableContext() +} + +type Create_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tableContext() *Create_tableContext { + var p = new(Create_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_table + return p +} + +func InitEmptyCreate_tableContext(p *Create_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_table +} + +func (*Create_tableContext) IsCreate_tableContext() {} + +func NewCreate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tableContext { + var p = new(Create_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_table + + return p +} + +func (s *Create_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Create_tableContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_tableContext) Relational_table() IRelational_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_tableContext) +} + +func (s *Create_tableContext) Xmltype_table() IXmltype_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_tableContext) +} + +func (s *Create_tableContext) Object_table() IObject_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_tableContext) +} + +func (s *Create_tableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Create_tableContext) SHARDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDED, 0) +} + +func (s *Create_tableContext) DUPLICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATED, 0) +} + +func (s *Create_tableContext) BLOCKCHAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKCHAIN, 0) +} + +func (s *Create_tableContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMUTABLE, 0) +} + +func (s *Create_tableContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_tableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_tableContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Create_tableContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Create_tableContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Create_tableContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_tableContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_tableContext) Memoptimize_read_write_clause() IMemoptimize_read_write_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMemoptimize_read_write_clauseContext) +} + +func (s *Create_tableContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Create_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_tableContext) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Create_tableContext) QUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE, 0) +} + +func (s *Create_tableContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Create_tableContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Create_tableContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_tableContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_tableContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_tableContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Create_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_table(s) + } +} + +func (s *Create_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_table(s) + } +} + +func (p *PlSqlParser) Create_table() (localctx ICreate_tableContext) { + localctx = NewCreate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, PlSqlParserRULE_create_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10555) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10565) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 1 { + { + p.SetState(10556) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGLOBAL || _la == PlSqlParserPRIVATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10557) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 2 { + { + p.SetState(10558) + p.Match(PlSqlParserSHARDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 3 { + { + p.SetState(10559) + p.Match(PlSqlParserDUPLICATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 4 { + p.SetState(10561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIMMUTABLE { + { + p.SetState(10560) + p.Match(PlSqlParserIMMUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10563) + p.Match(PlSqlParserBLOCKCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 5 { + { + p.SetState(10564) + p.Match(PlSqlParserIMMUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10567) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10571) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1266, p.GetParserRuleContext()) == 1 { + { + p.SetState(10568) + p.Schema_name() + } + { + p.SetState(10569) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10573) + p.Table_name() + } + p.SetState(10577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(10574) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10575) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10576) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(10579) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10580) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMETADATA: + { + p.SetState(10581) + p.Match(PlSqlParserMETADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATA, PlSqlParserEXTENDED: + p.SetState(10583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENDED { + { + p.SetState(10582) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10585) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(10586) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(10594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1271, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10591) + p.Relational_table() + } + + case 2: + { + p.SetState(10592) + p.Xmltype_table() + } + + case 3: + { + p.SetState(10593) + p.Object_table() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserMEMOPTIMIZE { + { + p.SetState(10596) + p.Memoptimize_read_write_clause() + } + + } + p.SetState(10601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARENT { + { + p.SetState(10599) + p.Match(PlSqlParserPARENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10600) + p.Tableview_name() + } + + } + p.SetState(10605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSAGE { + { + p.SetState(10603) + p.Match(PlSqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10604) + p.Match(PlSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_tableContext is an interface to support dynamic dispatch. +type IXmltype_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + AllXMLTYPE() []antlr.TerminalNode + XMLTYPE(i int) antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Object_properties() IObject_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + Xmltype_storage() IXmltype_storageContext + Xmlschema_spec() IXmlschema_specContext + Xmltype_virtual_columns() IXmltype_virtual_columnsContext + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + ROWS() antlr.TerminalNode + Oid_clause() IOid_clauseContext + Oid_index_clause() IOid_index_clauseContext + Physical_properties() IPhysical_propertiesContext + Table_properties() ITable_propertiesContext + DELETE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + + // IsXmltype_tableContext differentiates from other interfaces. + IsXmltype_tableContext() +} + +type Xmltype_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_tableContext() *Xmltype_tableContext { + var p = new(Xmltype_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_table + return p +} + +func InitEmptyXmltype_tableContext(p *Xmltype_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_table +} + +func (*Xmltype_tableContext) IsXmltype_tableContext() {} + +func NewXmltype_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_tableContext { + var p = new(Xmltype_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_table + + return p +} + +func (s *Xmltype_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_tableContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Xmltype_tableContext) AllXMLTYPE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserXMLTYPE) +} + +func (s *Xmltype_tableContext) XMLTYPE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, i) +} + +func (s *Xmltype_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_tableContext) Object_properties() IObject_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Xmltype_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_tableContext) Xmltype_storage() IXmltype_storageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_storageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_storageContext) +} + +func (s *Xmltype_tableContext) Xmlschema_spec() IXmlschema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlschema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlschema_specContext) +} + +func (s *Xmltype_tableContext) Xmltype_virtual_columns() IXmltype_virtual_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_virtual_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_virtual_columnsContext) +} + +func (s *Xmltype_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Xmltype_tableContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Xmltype_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Xmltype_tableContext) Oid_clause() IOid_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_clauseContext) +} + +func (s *Xmltype_tableContext) Oid_index_clause() IOid_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_index_clauseContext) +} + +func (s *Xmltype_tableContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Xmltype_tableContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Xmltype_tableContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Xmltype_tableContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Xmltype_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_table(s) + } +} + +func (s *Xmltype_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_table(s) + } +} + +func (p *PlSqlParser) Xmltype_table() (localctx IXmltype_tableContext) { + localctx = NewXmltype_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, PlSqlParserRULE_xmltype_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10607) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10608) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10609) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10610) + p.Object_properties() + } + { + p.SetState(10611) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10617) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1276, p.GetParserRuleContext()) == 1 { + { + p.SetState(10615) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10616) + p.Xmltype_storage() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10619) + p.Xmlschema_spec() + } + + } + p.SetState(10623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVIRTUAL { + { + p.SetState(10622) + p.Xmltype_virtual_columns() + } + + } + p.SetState(10629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10625) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10626) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10627) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10628) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(10631) + p.Oid_clause() + } + + } + p.SetState(10635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOIDINDEX { + { + p.SetState(10634) + p.Oid_index_clause() + } + + } + p.SetState(10638) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1282, p.GetParserRuleContext()) == 1 { + { + p.SetState(10637) + p.Physical_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10641) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1283, p.GetParserRuleContext()) == 1 { + { + p.SetState(10640) + p.Table_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_virtual_columnsContext is an interface to support dynamic dispatch. +type IXmltype_virtual_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VIRTUAL() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXmltype_virtual_columnsContext differentiates from other interfaces. + IsXmltype_virtual_columnsContext() +} + +type Xmltype_virtual_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_virtual_columnsContext() *Xmltype_virtual_columnsContext { + var p = new(Xmltype_virtual_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns + return p +} + +func InitEmptyXmltype_virtual_columnsContext(p *Xmltype_virtual_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns +} + +func (*Xmltype_virtual_columnsContext) IsXmltype_virtual_columnsContext() {} + +func NewXmltype_virtual_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_virtual_columnsContext { + var p = new(Xmltype_virtual_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns + + return p +} + +func (s *Xmltype_virtual_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_virtual_columnsContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Xmltype_virtual_columnsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Xmltype_virtual_columnsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Xmltype_virtual_columnsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Xmltype_virtual_columnsContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Xmltype_virtual_columnsContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Xmltype_virtual_columnsContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Xmltype_virtual_columnsContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Xmltype_virtual_columnsContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xmltype_virtual_columnsContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmltype_virtual_columnsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Xmltype_virtual_columnsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Xmltype_virtual_columnsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xmltype_virtual_columnsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xmltype_virtual_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_virtual_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_virtual_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_virtual_columns(s) + } +} + +func (s *Xmltype_virtual_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_virtual_columns(s) + } +} + +func (p *PlSqlParser) Xmltype_virtual_columns() (localctx IXmltype_virtual_columnsContext) { + localctx = NewXmltype_virtual_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, PlSqlParserRULE_xmltype_virtual_columns) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10643) + p.Match(PlSqlParserVIRTUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10644) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10645) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10646) + p.Column_name() + } + { + p.SetState(10647) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10648) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10649) + p.Expression() + } + { + p.SetState(10650) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10651) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10652) + p.Column_name() + } + { + p.SetState(10653) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10654) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10655) + p.Expression() + } + { + p.SetState(10656) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(10662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10663) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_column_propertiesContext is an interface to support dynamic dispatch. +type IXmltype_column_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLTYPE() antlr.TerminalNode + Column_name() IColumn_nameContext + COLUMN() antlr.TerminalNode + Xmltype_storage() IXmltype_storageContext + Xmlschema_spec() IXmlschema_specContext + + // IsXmltype_column_propertiesContext differentiates from other interfaces. + IsXmltype_column_propertiesContext() +} + +type Xmltype_column_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_column_propertiesContext() *Xmltype_column_propertiesContext { + var p = new(Xmltype_column_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties + return p +} + +func InitEmptyXmltype_column_propertiesContext(p *Xmltype_column_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties +} + +func (*Xmltype_column_propertiesContext) IsXmltype_column_propertiesContext() {} + +func NewXmltype_column_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_column_propertiesContext { + var p = new(Xmltype_column_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties + + return p +} + +func (s *Xmltype_column_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_column_propertiesContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Xmltype_column_propertiesContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Xmltype_column_propertiesContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Xmltype_column_propertiesContext) Xmltype_storage() IXmltype_storageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_storageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_storageContext) +} + +func (s *Xmltype_column_propertiesContext) Xmlschema_spec() IXmlschema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlschema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlschema_specContext) +} + +func (s *Xmltype_column_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_column_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_column_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_column_properties(s) + } +} + +func (s *Xmltype_column_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_column_properties(s) + } +} + +func (p *PlSqlParser) Xmltype_column_properties() (localctx IXmltype_column_propertiesContext) { + localctx = NewXmltype_column_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, PlSqlParserRULE_xmltype_column_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10665) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10667) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1285, p.GetParserRuleContext()) == 1 { + { + p.SetState(10666) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10669) + p.Column_name() + } + p.SetState(10671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(10670) + p.Xmltype_storage() + } + + } + p.SetState(10674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10673) + p.Xmlschema_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_storageContext is an interface to support dynamic dispatch. +type IXmltype_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + RELATIONAL() antlr.TerminalNode + CLOB() antlr.TerminalNode + BINARY() antlr.TerminalNode + XML() antlr.TerminalNode + Lob_segname() ILob_segnameContext + LEFT_PAREN() antlr.TerminalNode + Lob_parameters() ILob_parametersContext + RIGHT_PAREN() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + LOBS() antlr.TerminalNode + TABLES() antlr.TerminalNode + + // IsXmltype_storageContext differentiates from other interfaces. + IsXmltype_storageContext() +} + +type Xmltype_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_storageContext() *Xmltype_storageContext { + var p = new(Xmltype_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_storage + return p +} + +func InitEmptyXmltype_storageContext(p *Xmltype_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_storage +} + +func (*Xmltype_storageContext) IsXmltype_storageContext() {} + +func NewXmltype_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_storageContext { + var p = new(Xmltype_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_storage + + return p +} + +func (s *Xmltype_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Xmltype_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xmltype_storageContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Xmltype_storageContext) RELATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELATIONAL, 0) +} + +func (s *Xmltype_storageContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Xmltype_storageContext) BINARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY, 0) +} + +func (s *Xmltype_storageContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Xmltype_storageContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Xmltype_storageContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_storageContext) Lob_parameters() ILob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_parametersContext) +} + +func (s *Xmltype_storageContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_storageContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Xmltype_storageContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Xmltype_storageContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Xmltype_storageContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Xmltype_storageContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Xmltype_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_storage(s) + } +} + +func (s *Xmltype_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_storage(s) + } +} + +func (p *PlSqlParser) Xmltype_storage() (localctx IXmltype_storageContext) { + localctx = NewXmltype_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, PlSqlParserRULE_xmltype_storage) + var _la int + + p.SetState(10707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1293, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10676) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10677) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(10678) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10679) + p.Match(PlSqlParserRELATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBASICFILE, PlSqlParserBINARY, PlSqlParserCLOB, PlSqlParserSECUREFILE: + p.SetState(10681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(10680) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCLOB: + { + p.SetState(10683) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY: + { + p.SetState(10684) + p.Match(PlSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10685) + p.Match(PlSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10699) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1291, p.GetParserRuleContext()) == 1 { + { + p.SetState(10688) + p.Lob_segname() + } + p.SetState(10693) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1290, p.GetParserRuleContext()) == 1 { + { + p.SetState(10689) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10690) + p.Lob_parameters() + } + { + p.SetState(10691) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1291, p.GetParserRuleContext()) == 2 { + { + p.SetState(10695) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10696) + p.Lob_parameters() + } + { + p.SetState(10697) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10703) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10704) + p.Match(PlSqlParserVARRAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10705) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10706) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOBS || _la == PlSqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlschema_specContext is an interface to support dynamic dispatch. +type IXmlschema_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELEMENT() antlr.TerminalNode + AllDELIMITED_ID() []antlr.TerminalNode + DELIMITED_ID(i int) antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + AllAllow_or_disallow() []IAllow_or_disallowContext + Allow_or_disallow(i int) IAllow_or_disallowContext + NONSCHEMA() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + + // IsXmlschema_specContext differentiates from other interfaces. + IsXmlschema_specContext() +} + +type Xmlschema_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlschema_specContext() *Xmlschema_specContext { + var p = new(Xmlschema_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlschema_spec + return p +} + +func InitEmptyXmlschema_specContext(p *Xmlschema_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlschema_spec +} + +func (*Xmlschema_specContext) IsXmlschema_specContext() {} + +func NewXmlschema_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlschema_specContext { + var p = new(Xmlschema_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlschema_spec + + return p +} + +func (s *Xmlschema_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlschema_specContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Xmlschema_specContext) AllDELIMITED_ID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDELIMITED_ID) +} + +func (s *Xmlschema_specContext) DELIMITED_ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, i) +} + +func (s *Xmlschema_specContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Xmlschema_specContext) AllAllow_or_disallow() []IAllow_or_disallowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + len++ + } + } + + tst := make([]IAllow_or_disallowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllow_or_disallowContext); ok { + tst[i] = t.(IAllow_or_disallowContext) + i++ + } + } + + return tst +} + +func (s *Xmlschema_specContext) Allow_or_disallow(i int) IAllow_or_disallowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Xmlschema_specContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Xmlschema_specContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Xmlschema_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlschema_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlschema_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlschema_spec(s) + } +} + +func (s *Xmlschema_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlschema_spec(s) + } +} + +func (p *PlSqlParser) Xmlschema_spec() (localctx IXmlschema_specContext) { + localctx = NewXmlschema_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, PlSqlParserRULE_xmlschema_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10709) + p.Match(PlSqlParserXMLSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10710) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10713) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10714) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10718) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1295, p.GetParserRuleContext()) == 1 { + { + p.SetState(10715) + p.Allow_or_disallow() + } + { + p.SetState(10716) + p.Match(PlSqlParserNONSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(10720) + p.Allow_or_disallow() + } + { + p.SetState(10721) + p.Match(PlSqlParserANYSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_tableContext is an interface to support dynamic dispatch. +type IObject_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + Object_type() IObject_typeContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + Object_table_substitution() IObject_table_substitutionContext + LEFT_PAREN() antlr.TerminalNode + AllObject_properties() []IObject_propertiesContext + Object_properties(i int) IObject_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + ROWS() antlr.TerminalNode + Oid_clause() IOid_clauseContext + Oid_index_clause() IOid_index_clauseContext + Physical_properties() IPhysical_propertiesContext + Table_properties() ITable_propertiesContext + DELETE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsObject_tableContext differentiates from other interfaces. + IsObject_tableContext() +} + +type Object_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_tableContext() *Object_tableContext { + var p = new(Object_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table + return p +} + +func InitEmptyObject_tableContext(p *Object_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table +} + +func (*Object_tableContext) IsObject_tableContext() {} + +func NewObject_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_tableContext { + var p = new(Object_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_table + + return p +} + +func (s *Object_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_tableContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Object_tableContext) Object_type() IObject_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Object_tableContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Object_tableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Object_tableContext) Object_table_substitution() IObject_table_substitutionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_table_substitutionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_table_substitutionContext) +} + +func (s *Object_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Object_tableContext) AllObject_properties() []IObject_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_propertiesContext); ok { + tst[i] = t.(IObject_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Object_tableContext) Object_properties(i int) IObject_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Object_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Object_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Object_tableContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Object_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Object_tableContext) Oid_clause() IOid_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_clauseContext) +} + +func (s *Object_tableContext) Oid_index_clause() IOid_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_index_clauseContext) +} + +func (s *Object_tableContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Object_tableContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Object_tableContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_tableContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Object_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_table(s) + } +} + +func (s *Object_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_table(s) + } +} + +func (p *PlSqlParser) Object_table() (localctx IObject_tableContext) { + localctx = NewObject_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1050, PlSqlParserRULE_object_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10725) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10729) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1297, p.GetParserRuleContext()) == 1 { + { + p.SetState(10726) + p.Schema_name() + } + { + p.SetState(10727) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10731) + p.Object_type() + } + p.SetState(10733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(10732) + p.Object_table_substitution() + } + + } + p.SetState(10746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10735) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10736) + p.Object_properties() + } + p.SetState(10741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10737) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10738) + p.Object_properties() + } + + p.SetState(10743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10744) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10748) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10749) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10750) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10751) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(10754) + p.Oid_clause() + } + + } + p.SetState(10758) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOIDINDEX { + { + p.SetState(10757) + p.Oid_index_clause() + } + + } + p.SetState(10761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1304, p.GetParserRuleContext()) == 1 { + { + p.SetState(10760) + p.Physical_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10764) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1305, p.GetParserRuleContext()) == 1 { + { + p.SetState(10763) + p.Table_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_typeContext is an interface to support dynamic dispatch. +type IObject_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsObject_typeContext differentiates from other interfaces. + IsObject_typeContext() +} + +type Object_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_typeContext() *Object_typeContext { + var p = new(Object_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type + return p +} + +func InitEmptyObject_typeContext(p *Object_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type +} + +func (*Object_typeContext) IsObject_typeContext() {} + +func NewObject_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_typeContext { + var p = new(Object_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_type + + return p +} + +func (s *Object_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_typeContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Object_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_type(s) + } +} + +func (s *Object_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type(s) + } +} + +func (p *PlSqlParser) Object_type() (localctx IObject_typeContext) { + localctx = NewObject_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, PlSqlParserRULE_object_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10766) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOid_index_clauseContext is an interface to support dynamic dispatch. +type IOid_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OIDINDEX() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Index_name() IIndex_nameContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsOid_index_clauseContext differentiates from other interfaces. + IsOid_index_clauseContext() +} + +type Oid_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOid_index_clauseContext() *Oid_index_clauseContext { + var p = new(Oid_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_index_clause + return p +} + +func InitEmptyOid_index_clauseContext(p *Oid_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_index_clause +} + +func (*Oid_index_clauseContext) IsOid_index_clauseContext() {} + +func NewOid_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oid_index_clauseContext { + var p = new(Oid_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oid_index_clause + + return p +} + +func (s *Oid_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oid_index_clauseContext) OIDINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserOIDINDEX, 0) +} + +func (s *Oid_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Oid_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Oid_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Oid_index_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Oid_index_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Oid_index_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Oid_index_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Oid_index_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Oid_index_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Oid_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oid_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oid_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOid_index_clause(s) + } +} + +func (s *Oid_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOid_index_clause(s) + } +} + +func (p *PlSqlParser) Oid_index_clause() (localctx IOid_index_clauseContext) { + localctx = NewOid_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, PlSqlParserRULE_oid_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10768) + p.Match(PlSqlParserOIDINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(10769) + p.Index_name() + } + + } + { + p.SetState(10772) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPUTE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(10773) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(10774) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10775) + p.Tablespace() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10780) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOid_clauseContext is an interface to support dynamic dispatch. +type IOid_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IS() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + GENERATED() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsOid_clauseContext differentiates from other interfaces. + IsOid_clauseContext() +} + +type Oid_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOid_clauseContext() *Oid_clauseContext { + var p = new(Oid_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_clause + return p +} + +func InitEmptyOid_clauseContext(p *Oid_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_clause +} + +func (*Oid_clauseContext) IsOid_clauseContext() {} + +func NewOid_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oid_clauseContext { + var p = new(Oid_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oid_clause + + return p +} + +func (s *Oid_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oid_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Oid_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Oid_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Oid_clauseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Oid_clauseContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Oid_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Oid_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Oid_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oid_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oid_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOid_clause(s) + } +} + +func (s *Oid_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOid_clause(s) + } +} + +func (p *PlSqlParser) Oid_clause() (localctx IOid_clauseContext) { + localctx = NewOid_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, PlSqlParserRULE_oid_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10782) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10783) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10784) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSYSTEM: + { + p.SetState(10785) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10786) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(10787) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10788) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_propertiesContext is an interface to support dynamic dispatch. +type IObject_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Attribute_name() IAttribute_nameContext + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + Inline_ref_constraint() IInline_ref_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Out_of_line_constraint() IOut_of_line_constraintContext + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + Supplemental_logging_props() ISupplemental_logging_propsContext + + // IsObject_propertiesContext differentiates from other interfaces. + IsObject_propertiesContext() +} + +type Object_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_propertiesContext() *Object_propertiesContext { + var p = new(Object_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_properties + return p +} + +func InitEmptyObject_propertiesContext(p *Object_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_properties +} + +func (*Object_propertiesContext) IsObject_propertiesContext() {} + +func NewObject_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_propertiesContext { + var p = new(Object_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_properties + + return p +} + +func (s *Object_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_propertiesContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Object_propertiesContext) Attribute_name() IAttribute_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Object_propertiesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Object_propertiesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Object_propertiesContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Object_propertiesContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Object_propertiesContext) Inline_ref_constraint() IInline_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_ref_constraintContext) +} + +func (s *Object_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_propertiesContext) Out_of_line_constraint() IOut_of_line_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Object_propertiesContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Object_propertiesContext) Supplemental_logging_props() ISupplemental_logging_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_logging_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_logging_propsContext) +} + +func (s *Object_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_properties(s) + } +} + +func (s *Object_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_properties(s) + } +} + +func (p *PlSqlParser) Object_properties() (localctx IObject_propertiesContext) { + localctx = NewObject_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, PlSqlParserRULE_object_properties) + var _la int + + var _alt int + + p.SetState(10813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1314, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(10793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1310, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10791) + p.Column_name() + } + + case 2: + { + p.SetState(10792) + p.Attribute_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(10795) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10796) + p.Expression() + } + + } + p.SetState(10808) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1313, p.GetParserRuleContext()) == 1 { + { + p.SetState(10799) + p.Inline_constraint() + } + p.SetState(10804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1312, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(10800) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10801) + p.Inline_constraint() + } + + } + p.SetState(10806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1312, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1313, p.GetParserRuleContext()) == 2 { + { + p.SetState(10807) + p.Inline_ref_constraint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10810) + p.Out_of_line_constraint() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10811) + p.Out_of_line_ref_constraint() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10812) + p.Supplemental_logging_props() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_table_substitutionContext is an interface to support dynamic dispatch. +type IObject_table_substitutionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsObject_table_substitutionContext differentiates from other interfaces. + IsObject_table_substitutionContext() +} + +type Object_table_substitutionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_table_substitutionContext() *Object_table_substitutionContext { + var p = new(Object_table_substitutionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table_substitution + return p +} + +func InitEmptyObject_table_substitutionContext(p *Object_table_substitutionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table_substitution +} + +func (*Object_table_substitutionContext) IsObject_table_substitutionContext() {} + +func NewObject_table_substitutionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_table_substitutionContext { + var p = new(Object_table_substitutionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_table_substitution + + return p +} + +func (s *Object_table_substitutionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_table_substitutionContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Object_table_substitutionContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Object_table_substitutionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Object_table_substitutionContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Object_table_substitutionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Object_table_substitutionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_table_substitutionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_table_substitutionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_table_substitution(s) + } +} + +func (s *Object_table_substitutionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_table_substitution(s) + } +} + +func (p *PlSqlParser) Object_table_substitution() (localctx IObject_table_substitutionContext) { + localctx = NewObject_table_substitutionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, PlSqlParserRULE_object_table_substitution) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(10815) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10818) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10819) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10820) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10821) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_tableContext is an interface to support dynamic dispatch. +type IRelational_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllRelational_property() []IRelational_propertyContext + Relational_property(i int) IRelational_propertyContext + RIGHT_PAREN() antlr.TerminalNode + Relational_table_properties() IRelational_table_propertiesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelational_tableContext differentiates from other interfaces. + IsRelational_tableContext() +} + +type Relational_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_tableContext() *Relational_tableContext { + var p = new(Relational_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table + return p +} + +func InitEmptyRelational_tableContext(p *Relational_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table +} + +func (*Relational_tableContext) IsRelational_tableContext() {} + +func NewRelational_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_tableContext { + var p = new(Relational_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_table + + return p +} + +func (s *Relational_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Relational_tableContext) AllRelational_property() []IRelational_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_propertyContext); ok { + len++ + } + } + + tst := make([]IRelational_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_propertyContext); ok { + tst[i] = t.(IRelational_propertyContext) + i++ + } + } + + return tst +} + +func (s *Relational_tableContext) Relational_property(i int) IRelational_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_propertyContext) +} + +func (s *Relational_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Relational_tableContext) Relational_table_properties() IRelational_table_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_table_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_table_propertiesContext) +} + +func (s *Relational_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Relational_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Relational_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_table(s) + } +} + +func (s *Relational_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_table(s) + } +} + +func (p *PlSqlParser) Relational_table() (localctx IRelational_tableContext) { + localctx = NewRelational_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, PlSqlParserRULE_relational_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10823) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10824) + p.Relational_property() + } + p.SetState(10829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10825) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10826) + p.Relational_property() + } + + p.SetState(10831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10832) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10837) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1318, p.GetParserRuleContext()) == 1 { + { + p.SetState(10836) + p.Relational_table_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_table_propertiesContext is an interface to support dynamic dispatch. +type IRelational_table_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRelational_table_property() []IRelational_table_propertyContext + Relational_table_property(i int) IRelational_table_propertyContext + + // IsRelational_table_propertiesContext differentiates from other interfaces. + IsRelational_table_propertiesContext() +} + +type Relational_table_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_table_propertiesContext() *Relational_table_propertiesContext { + var p = new(Relational_table_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table_properties + return p +} + +func InitEmptyRelational_table_propertiesContext(p *Relational_table_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table_properties +} + +func (*Relational_table_propertiesContext) IsRelational_table_propertiesContext() {} + +func NewRelational_table_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_table_propertiesContext { + var p = new(Relational_table_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_table_properties + + return p +} + +func (s *Relational_table_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_table_propertiesContext) AllRelational_table_property() []IRelational_table_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_table_propertyContext); ok { + len++ + } + } + + tst := make([]IRelational_table_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_table_propertyContext); ok { + tst[i] = t.(IRelational_table_propertyContext) + i++ + } + } + + return tst +} + +func (s *Relational_table_propertiesContext) Relational_table_property(i int) IRelational_table_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_table_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_table_propertyContext) +} + +func (s *Relational_table_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_table_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_table_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_table_properties(s) + } +} + +func (s *Relational_table_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_table_properties(s) + } +} + +func (p *PlSqlParser) Relational_table_properties() (localctx IRelational_table_propertiesContext) { + localctx = NewRelational_table_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, PlSqlParserRULE_relational_table_properties) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(10839) + p.Relational_table_property() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10842) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1319, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_table_propertyContext is an interface to support dynamic dispatch. +type IRelational_table_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Immutable_table_clauses() IImmutable_table_clausesContext + Blockchain_table_clauses() IBlockchain_table_clausesContext + DEFAULT() antlr.TerminalNode + COLLATION() antlr.TerminalNode + Collation_name() ICollation_nameContext + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + ROWS() antlr.TerminalNode + DROP() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + DELETE() antlr.TerminalNode + Physical_properties() IPhysical_propertiesContext + Table_properties() ITable_propertiesContext + + // IsRelational_table_propertyContext differentiates from other interfaces. + IsRelational_table_propertyContext() +} + +type Relational_table_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_table_propertyContext() *Relational_table_propertyContext { + var p = new(Relational_table_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table_property + return p +} + +func InitEmptyRelational_table_propertyContext(p *Relational_table_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table_property +} + +func (*Relational_table_propertyContext) IsRelational_table_propertyContext() {} + +func NewRelational_table_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_table_propertyContext { + var p = new(Relational_table_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_table_property + + return p +} + +func (s *Relational_table_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_table_propertyContext) Immutable_table_clauses() IImmutable_table_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_clausesContext) +} + +func (s *Relational_table_propertyContext) Blockchain_table_clauses() IBlockchain_table_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_table_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_table_clausesContext) +} + +func (s *Relational_table_propertyContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Relational_table_propertyContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Relational_table_propertyContext) Collation_name() ICollation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollation_nameContext) +} + +func (s *Relational_table_propertyContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Relational_table_propertyContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Relational_table_propertyContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINITION, 0) +} + +func (s *Relational_table_propertyContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Relational_table_propertyContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Relational_table_propertyContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Relational_table_propertyContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Relational_table_propertyContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Relational_table_propertyContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Relational_table_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_table_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_table_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_table_property(s) + } +} + +func (s *Relational_table_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_table_property(s) + } +} + +func (p *PlSqlParser) Relational_table_property() (localctx IRelational_table_propertyContext) { + localctx = NewRelational_table_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, PlSqlParserRULE_relational_table_property) + var _la int + + p.SetState(10859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10844) + p.Immutable_table_clauses() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10845) + p.Blockchain_table_clauses() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10846) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10847) + p.Match(PlSqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10848) + p.Collation_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10849) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10850) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1320, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10851) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10852) + p.Match(PlSqlParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10853) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10854) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10857) + p.Physical_properties() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10858) + p.Table_properties() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImmutable_table_clausesContext is an interface to support dynamic dispatch. +type IImmutable_table_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Immutable_table_no_drop_clause() IImmutable_table_no_drop_clauseContext + Immutable_table_no_delete_clause() IImmutable_table_no_delete_clauseContext + + // IsImmutable_table_clausesContext differentiates from other interfaces. + IsImmutable_table_clausesContext() +} + +type Immutable_table_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_clausesContext() *Immutable_table_clausesContext { + var p = new(Immutable_table_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses + return p +} + +func InitEmptyImmutable_table_clausesContext(p *Immutable_table_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses +} + +func (*Immutable_table_clausesContext) IsImmutable_table_clausesContext() {} + +func NewImmutable_table_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_clausesContext { + var p = new(Immutable_table_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses + + return p +} + +func (s *Immutable_table_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_clausesContext) Immutable_table_no_drop_clause() IImmutable_table_no_drop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_no_drop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_no_drop_clauseContext) +} + +func (s *Immutable_table_clausesContext) Immutable_table_no_delete_clause() IImmutable_table_no_delete_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_no_delete_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_no_delete_clauseContext) +} + +func (s *Immutable_table_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_clauses(s) + } +} + +func (s *Immutable_table_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_clauses(s) + } +} + +func (p *PlSqlParser) Immutable_table_clauses() (localctx IImmutable_table_clausesContext) { + localctx = NewImmutable_table_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, PlSqlParserRULE_immutable_table_clauses) + p.SetState(10863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1322, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10861) + p.Immutable_table_no_drop_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10862) + p.Immutable_table_no_delete_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImmutable_table_no_drop_clauseContext is an interface to support dynamic dispatch. +type IImmutable_table_no_drop_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DROP() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + IDLE() antlr.TerminalNode + + // IsImmutable_table_no_drop_clauseContext differentiates from other interfaces. + IsImmutable_table_no_drop_clauseContext() +} + +type Immutable_table_no_drop_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_no_drop_clauseContext() *Immutable_table_no_drop_clauseContext { + var p = new(Immutable_table_no_drop_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause + return p +} + +func InitEmptyImmutable_table_no_drop_clauseContext(p *Immutable_table_no_drop_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause +} + +func (*Immutable_table_no_drop_clauseContext) IsImmutable_table_no_drop_clauseContext() {} + +func NewImmutable_table_no_drop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_no_drop_clauseContext { + var p = new(Immutable_table_no_drop_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause + + return p +} + +func (s *Immutable_table_no_drop_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_no_drop_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Immutable_table_no_drop_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_no_drop_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_no_drop_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_no_drop_clause(s) + } +} + +func (s *Immutable_table_no_drop_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_no_drop_clause(s) + } +} + +func (p *PlSqlParser) Immutable_table_no_drop_clause() (localctx IImmutable_table_no_drop_clauseContext) { + localctx = NewImmutable_table_no_drop_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, PlSqlParserRULE_immutable_table_no_drop_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10865) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10866) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(10867) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10868) + p.Numeric() + } + { + p.SetState(10869) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10870) + p.Match(PlSqlParserIDLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImmutable_table_no_delete_clauseContext is an interface to support dynamic dispatch. +type IImmutable_table_no_delete_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DELETE() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCKED() antlr.TerminalNode + + // IsImmutable_table_no_delete_clauseContext differentiates from other interfaces. + IsImmutable_table_no_delete_clauseContext() +} + +type Immutable_table_no_delete_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_no_delete_clauseContext() *Immutable_table_no_delete_clauseContext { + var p = new(Immutable_table_no_delete_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause + return p +} + +func InitEmptyImmutable_table_no_delete_clauseContext(p *Immutable_table_no_delete_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause +} + +func (*Immutable_table_no_delete_clauseContext) IsImmutable_table_no_delete_clauseContext() {} + +func NewImmutable_table_no_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_no_delete_clauseContext { + var p = new(Immutable_table_no_delete_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause + + return p +} + +func (s *Immutable_table_no_delete_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_no_delete_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Immutable_table_no_delete_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_no_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_no_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_no_delete_clause(s) + } +} + +func (s *Immutable_table_no_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_no_delete_clause(s) + } +} + +func (p *PlSqlParser) Immutable_table_no_delete_clause() (localctx IImmutable_table_no_delete_clauseContext) { + localctx = NewImmutable_table_no_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, PlSqlParserRULE_immutable_table_no_delete_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10874) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10875) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEOF, PlSqlParserANNOTATIONS, PlSqlParserAS, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCLUSTERING, PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserCREATE, PlSqlParserDEFAULT, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFLASHBACK, PlSqlParserFOR, PlSqlParserGRANT, PlSqlParserILM, PlSqlParserINDEXING, PlSqlParserINITRANS, PlSqlParserINMEMORY, PlSqlParserLOB, PlSqlParserLOCKED, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserMONITORING, PlSqlParserNESTED, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOMONITORING, PlSqlParserNO, PlSqlParserNOPARALLEL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserON, PlSqlParserORGANIZATION, PlSqlParserPARALLEL, PlSqlParserPARENT, PlSqlParserPARTITION, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREAD, PlSqlParserRESULT_CACHE, PlSqlParserROWDEPENDENCIES, PlSqlParserROW, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserUSAGE, PlSqlParserVARRAY, PlSqlParserXMLTYPE, PlSqlParserMEMOPTIMIZE, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + p.SetState(10877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10876) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserUNTIL: + { + p.SetState(10879) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10880) + p.Numeric() + } + { + p.SetState(10881) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10882) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10883) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10884) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockchain_table_clausesContext is an interface to support dynamic dispatch. +type IBlockchain_table_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Blockchain_drop_table_clause() IBlockchain_drop_table_clauseContext + Blockchain_row_retention_clause() IBlockchain_row_retention_clauseContext + Blockchain_hash_and_data_format_clause() IBlockchain_hash_and_data_format_clauseContext + + // IsBlockchain_table_clausesContext differentiates from other interfaces. + IsBlockchain_table_clausesContext() +} + +type Blockchain_table_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_table_clausesContext() *Blockchain_table_clausesContext { + var p = new(Blockchain_table_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses + return p +} + +func InitEmptyBlockchain_table_clausesContext(p *Blockchain_table_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses +} + +func (*Blockchain_table_clausesContext) IsBlockchain_table_clausesContext() {} + +func NewBlockchain_table_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_table_clausesContext { + var p = new(Blockchain_table_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses + + return p +} + +func (s *Blockchain_table_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_table_clausesContext) Blockchain_drop_table_clause() IBlockchain_drop_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_drop_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_drop_table_clauseContext) +} + +func (s *Blockchain_table_clausesContext) Blockchain_row_retention_clause() IBlockchain_row_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_row_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_row_retention_clauseContext) +} + +func (s *Blockchain_table_clausesContext) Blockchain_hash_and_data_format_clause() IBlockchain_hash_and_data_format_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_hash_and_data_format_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_hash_and_data_format_clauseContext) +} + +func (s *Blockchain_table_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_table_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_table_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_table_clauses(s) + } +} + +func (s *Blockchain_table_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_table_clauses(s) + } +} + +func (p *PlSqlParser) Blockchain_table_clauses() (localctx IBlockchain_table_clausesContext) { + localctx = NewBlockchain_table_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, PlSqlParserRULE_blockchain_table_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10889) + p.Blockchain_drop_table_clause() + } + { + p.SetState(10890) + p.Blockchain_row_retention_clause() + } + { + p.SetState(10891) + p.Blockchain_hash_and_data_format_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockchain_drop_table_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_drop_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DROP() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + IDLE() antlr.TerminalNode + + // IsBlockchain_drop_table_clauseContext differentiates from other interfaces. + IsBlockchain_drop_table_clauseContext() +} + +type Blockchain_drop_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_drop_table_clauseContext() *Blockchain_drop_table_clauseContext { + var p = new(Blockchain_drop_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause + return p +} + +func InitEmptyBlockchain_drop_table_clauseContext(p *Blockchain_drop_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause +} + +func (*Blockchain_drop_table_clauseContext) IsBlockchain_drop_table_clauseContext() {} + +func NewBlockchain_drop_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_drop_table_clauseContext { + var p = new(Blockchain_drop_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause + + return p +} + +func (s *Blockchain_drop_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_drop_table_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Blockchain_drop_table_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Blockchain_drop_table_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Blockchain_drop_table_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Blockchain_drop_table_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Blockchain_drop_table_clauseContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Blockchain_drop_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_drop_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_drop_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_drop_table_clause(s) + } +} + +func (s *Blockchain_drop_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_drop_table_clause(s) + } +} + +func (p *PlSqlParser) Blockchain_drop_table_clause() (localctx IBlockchain_drop_table_clauseContext) { + localctx = NewBlockchain_drop_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, PlSqlParserRULE_blockchain_drop_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10893) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10894) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(10895) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10896) + p.Numeric() + } + { + p.SetState(10897) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10898) + p.Match(PlSqlParserIDLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockchain_row_retention_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_row_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DELETE() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCKED() antlr.TerminalNode + + // IsBlockchain_row_retention_clauseContext differentiates from other interfaces. + IsBlockchain_row_retention_clauseContext() +} + +type Blockchain_row_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_row_retention_clauseContext() *Blockchain_row_retention_clauseContext { + var p = new(Blockchain_row_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause + return p +} + +func InitEmptyBlockchain_row_retention_clauseContext(p *Blockchain_row_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause +} + +func (*Blockchain_row_retention_clauseContext) IsBlockchain_row_retention_clauseContext() {} + +func NewBlockchain_row_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_row_retention_clauseContext { + var p = new(Blockchain_row_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause + + return p +} + +func (s *Blockchain_row_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_row_retention_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Blockchain_row_retention_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Blockchain_row_retention_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Blockchain_row_retention_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Blockchain_row_retention_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Blockchain_row_retention_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Blockchain_row_retention_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Blockchain_row_retention_clauseContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Blockchain_row_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_row_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_row_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_row_retention_clause(s) + } +} + +func (s *Blockchain_row_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_row_retention_clause(s) + } +} + +func (p *PlSqlParser) Blockchain_row_retention_clause() (localctx IBlockchain_row_retention_clauseContext) { + localctx = NewBlockchain_row_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, PlSqlParserRULE_blockchain_row_retention_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10902) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10903) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOCKED, PlSqlParserHASHING: + p.SetState(10905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10904) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserUNTIL: + { + p.SetState(10907) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10908) + p.Numeric() + } + { + p.SetState(10909) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10910) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10911) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10912) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockchain_hash_and_data_format_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_hash_and_data_format_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HASHING() antlr.TerminalNode + USING() antlr.TerminalNode + SHA2_512_Q() antlr.TerminalNode + VERSION() antlr.TerminalNode + V1_Q() antlr.TerminalNode + + // IsBlockchain_hash_and_data_format_clauseContext differentiates from other interfaces. + IsBlockchain_hash_and_data_format_clauseContext() +} + +type Blockchain_hash_and_data_format_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_hash_and_data_format_clauseContext() *Blockchain_hash_and_data_format_clauseContext { + var p = new(Blockchain_hash_and_data_format_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause + return p +} + +func InitEmptyBlockchain_hash_and_data_format_clauseContext(p *Blockchain_hash_and_data_format_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause +} + +func (*Blockchain_hash_and_data_format_clauseContext) IsBlockchain_hash_and_data_format_clauseContext() { +} + +func NewBlockchain_hash_and_data_format_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_hash_and_data_format_clauseContext { + var p = new(Blockchain_hash_and_data_format_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause + + return p +} + +func (s *Blockchain_hash_and_data_format_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_hash_and_data_format_clauseContext) HASHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHING, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) SHA2_512_Q() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHA2_512_Q, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) V1_Q() antlr.TerminalNode { + return s.GetToken(PlSqlParserV1_Q, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_hash_and_data_format_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_hash_and_data_format_clause(s) + } +} + +func (s *Blockchain_hash_and_data_format_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_hash_and_data_format_clause(s) + } +} + +func (p *PlSqlParser) Blockchain_hash_and_data_format_clause() (localctx IBlockchain_hash_and_data_format_clauseContext) { + localctx = NewBlockchain_hash_and_data_format_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, PlSqlParserRULE_blockchain_hash_and_data_format_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10917) + p.Match(PlSqlParserHASHING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10918) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10919) + p.Match(PlSqlParserSHA2_512_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10920) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10921) + p.Match(PlSqlParserV1_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollation_nameContext is an interface to support dynamic dispatch. +type ICollation_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsCollation_nameContext differentiates from other interfaces. + IsCollation_nameContext() +} + +type Collation_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollation_nameContext() *Collation_nameContext { + var p = new(Collation_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collation_name + return p +} + +func InitEmptyCollation_nameContext(p *Collation_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collation_name +} + +func (*Collation_nameContext) IsCollation_nameContext() {} + +func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext { + var p = new(Collation_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collation_name + + return p +} + +func (s *Collation_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collation_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Collation_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collation_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollation_name(s) + } +} + +func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollation_name(s) + } +} + +func (p *PlSqlParser) Collation_name() (localctx ICollation_nameContext) { + localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1082, PlSqlParserRULE_collation_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10923) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_propertiesContext is an interface to support dynamic dispatch. +type ITable_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_properties() IColumn_propertiesContext + Read_only_clause() IRead_only_clauseContext + Indexing_clause() IIndexing_clauseContext + Table_partitioning_clauses() ITable_partitioning_clausesContext + Attribute_clustering_clause() IAttribute_clustering_clauseContext + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + Result_cache_clause() IResult_cache_clauseContext + Parallel_clause() IParallel_clauseContext + Monitoring_nomonitoring() IMonitoring_nomonitoringContext + ROWDEPENDENCIES() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + Enable_disable_clause() IEnable_disable_clauseContext + Row_movement_clause() IRow_movement_clauseContext + Logical_replication_clause() ILogical_replication_clauseContext + Flashback_archive_clause() IFlashback_archive_clauseContext + Physical_properties() IPhysical_propertiesContext + ROW() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + FOR() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + WITH() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + Annotations_clause() IAnnotations_clauseContext + + // IsTable_propertiesContext differentiates from other interfaces. + IsTable_propertiesContext() +} + +type Table_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_propertiesContext() *Table_propertiesContext { + var p = new(Table_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_properties + return p +} + +func InitEmptyTable_propertiesContext(p *Table_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_properties +} + +func (*Table_propertiesContext) IsTable_propertiesContext() {} + +func NewTable_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_propertiesContext { + var p = new(Table_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_properties + + return p +} + +func (s *Table_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_propertiesContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Table_propertiesContext) Read_only_clause() IRead_only_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRead_only_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRead_only_clauseContext) +} + +func (s *Table_propertiesContext) Indexing_clause() IIndexing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexing_clauseContext) +} + +func (s *Table_propertiesContext) Table_partitioning_clauses() ITable_partitioning_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partitioning_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partitioning_clausesContext) +} + +func (s *Table_propertiesContext) Attribute_clustering_clause() IAttribute_clustering_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clustering_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clustering_clauseContext) +} + +func (s *Table_propertiesContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Table_propertiesContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Table_propertiesContext) Result_cache_clause() IResult_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Table_propertiesContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Table_propertiesContext) Monitoring_nomonitoring() IMonitoring_nomonitoringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMonitoring_nomonitoringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMonitoring_nomonitoringContext) +} + +func (s *Table_propertiesContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Table_propertiesContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Table_propertiesContext) Enable_disable_clause() IEnable_disable_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_clauseContext) +} + +func (s *Table_propertiesContext) Row_movement_clause() IRow_movement_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_movement_clauseContext) +} + +func (s *Table_propertiesContext) Logical_replication_clause() ILogical_replication_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_replication_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogical_replication_clauseContext) +} + +func (s *Table_propertiesContext) Flashback_archive_clause() IFlashback_archive_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_clauseContext) +} + +func (s *Table_propertiesContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Table_propertiesContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Table_propertiesContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Table_propertiesContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Table_propertiesContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Table_propertiesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Table_propertiesContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Table_propertiesContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Table_propertiesContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_propertiesContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Table_propertiesContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Table_propertiesContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Table_propertiesContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Table_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_properties(s) + } +} + +func (s *Table_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_properties(s) + } +} + +func (p *PlSqlParser) Table_properties() (localctx ITable_propertiesContext) { + localctx = NewTable_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1084, PlSqlParserRULE_table_properties) + var _la int + + p.SetState(10955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1332, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10925) + p.Column_properties() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10926) + p.Read_only_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10927) + p.Indexing_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10928) + p.Table_partitioning_clauses() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10929) + p.Attribute_clustering_clause() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10930) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10931) + p.Result_cache_clause() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10932) + p.Parallel_clause() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10933) + p.Monitoring_nomonitoring() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10934) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10935) + p.Enable_disable_clause() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10936) + p.Row_movement_clause() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(10937) + p.Logical_replication_clause() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(10938) + p.Flashback_archive_clause() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(10939) + p.Physical_properties() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(10940) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10941) + p.Match(PlSqlParserARCHIVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(10942) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10943) + p.Select_only_statement() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(10944) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10945) + p.Match(PlSqlParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10946) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10947) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10951) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1331, p.GetParserRuleContext()) == 1 { + { + p.SetState(10948) + p.Schema_name() + } + { + p.SetState(10949) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10953) + p.Table_name() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(10954) + p.Annotations_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRead_only_clauseContext is an interface to support dynamic dispatch. +type IRead_only_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + + // IsRead_only_clauseContext differentiates from other interfaces. + IsRead_only_clauseContext() +} + +type Read_only_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRead_only_clauseContext() *Read_only_clauseContext { + var p = new(Read_only_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_read_only_clause + return p +} + +func InitEmptyRead_only_clauseContext(p *Read_only_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_read_only_clause +} + +func (*Read_only_clauseContext) IsRead_only_clauseContext() {} + +func NewRead_only_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Read_only_clauseContext { + var p = new(Read_only_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_read_only_clause + + return p +} + +func (s *Read_only_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Read_only_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Read_only_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Read_only_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Read_only_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Read_only_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Read_only_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRead_only_clause(s) + } +} + +func (s *Read_only_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRead_only_clause(s) + } +} + +func (p *PlSqlParser) Read_only_clause() (localctx IRead_only_clauseContext) { + localctx = NewRead_only_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1086, PlSqlParserRULE_read_only_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10957) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10958) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexing_clauseContext is an interface to support dynamic dispatch. +type IIndexing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEXING() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsIndexing_clauseContext differentiates from other interfaces. + IsIndexing_clauseContext() +} + +type Indexing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexing_clauseContext() *Indexing_clauseContext { + var p = new(Indexing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indexing_clause + return p +} + +func InitEmptyIndexing_clauseContext(p *Indexing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indexing_clause +} + +func (*Indexing_clauseContext) IsIndexing_clauseContext() {} + +func NewIndexing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indexing_clauseContext { + var p = new(Indexing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indexing_clause + + return p +} + +func (s *Indexing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Indexing_clauseContext) INDEXING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXING, 0) +} + +func (s *Indexing_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Indexing_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Indexing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Indexing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Indexing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndexing_clause(s) + } +} + +func (s *Indexing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndexing_clause(s) + } +} + +func (p *PlSqlParser) Indexing_clause() (localctx IIndexing_clauseContext) { + localctx = NewIndexing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1088, PlSqlParserRULE_indexing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10960) + p.Match(PlSqlParserINDEXING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10961) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttribute_clustering_clauseContext is an interface to support dynamic dispatch. +type IAttribute_clustering_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTERING() antlr.TerminalNode + Cluster_clause() ICluster_clauseContext + Clustering_join() IClustering_joinContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + LOAD() antlr.TerminalNode + DATA() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + Zonemap_clause() IZonemap_clauseContext + AllYes_no() []IYes_noContext + Yes_no(i int) IYes_noContext + + // IsAttribute_clustering_clauseContext differentiates from other interfaces. + IsAttribute_clustering_clauseContext() +} + +type Attribute_clustering_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_clustering_clauseContext() *Attribute_clustering_clauseContext { + var p = new(Attribute_clustering_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause + return p +} + +func InitEmptyAttribute_clustering_clauseContext(p *Attribute_clustering_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause +} + +func (*Attribute_clustering_clauseContext) IsAttribute_clustering_clauseContext() {} + +func NewAttribute_clustering_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_clustering_clauseContext { + var p = new(Attribute_clustering_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause + + return p +} + +func (s *Attribute_clustering_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_clustering_clauseContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Attribute_clustering_clauseContext) Cluster_clause() ICluster_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_clauseContext) +} + +func (s *Attribute_clustering_clauseContext) Clustering_join() IClustering_joinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_joinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClustering_joinContext) +} + +func (s *Attribute_clustering_clauseContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Attribute_clustering_clauseContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Attribute_clustering_clauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Attribute_clustering_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Attribute_clustering_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Attribute_clustering_clauseContext) Zonemap_clause() IZonemap_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_clauseContext) +} + +func (s *Attribute_clustering_clauseContext) AllYes_no() []IYes_noContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IYes_noContext); ok { + len++ + } + } + + tst := make([]IYes_noContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IYes_noContext); ok { + tst[i] = t.(IYes_noContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clustering_clauseContext) Yes_no(i int) IYes_noContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IYes_noContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IYes_noContext) +} + +func (s *Attribute_clustering_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_clustering_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_clustering_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_clustering_clause(s) + } +} + +func (s *Attribute_clustering_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_clustering_clause(s) + } +} + +func (p *PlSqlParser) Attribute_clustering_clause() (localctx IAttribute_clustering_clauseContext) { + localctx = NewAttribute_clustering_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1090, PlSqlParserRULE_attribute_clustering_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10963) + p.Match(PlSqlParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(10964) + p.Clustering_join() + } + + } + { + p.SetState(10967) + p.Cluster_clause() + } + p.SetState(10973) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1335, p.GetParserRuleContext()) == 1 { + p.SetState(10969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserYES { + { + p.SetState(10968) + p.Yes_no() + } + + } + { + p.SetState(10971) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10972) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10981) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1337, p.GetParserRuleContext()) == 1 { + p.SetState(10976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserYES { + { + p.SetState(10975) + p.Yes_no() + } + + } + { + p.SetState(10978) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10979) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10980) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(10983) + p.Zonemap_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClustering_joinContext is an interface to support dynamic dispatch. +type IClustering_joinContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_name() ITable_nameContext + AllClustering_join_item() []IClustering_join_itemContext + Clustering_join_item(i int) IClustering_join_itemContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_joinContext differentiates from other interfaces. + IsClustering_joinContext() +} + +type Clustering_joinContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_joinContext() *Clustering_joinContext { + var p = new(Clustering_joinContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join + return p +} + +func InitEmptyClustering_joinContext(p *Clustering_joinContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join +} + +func (*Clustering_joinContext) IsClustering_joinContext() {} + +func NewClustering_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_joinContext { + var p = new(Clustering_joinContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_join + + return p +} + +func (s *Clustering_joinContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_joinContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Clustering_joinContext) AllClustering_join_item() []IClustering_join_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClustering_join_itemContext); ok { + len++ + } + } + + tst := make([]IClustering_join_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClustering_join_itemContext); ok { + tst[i] = t.(IClustering_join_itemContext) + i++ + } + } + + return tst +} + +func (s *Clustering_joinContext) Clustering_join_item(i int) IClustering_join_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_join_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClustering_join_itemContext) +} + +func (s *Clustering_joinContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Clustering_joinContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Clustering_joinContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_joinContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_joinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_joinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_join(s) + } +} + +func (s *Clustering_joinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_join(s) + } +} + +func (p *PlSqlParser) Clustering_join() (localctx IClustering_joinContext) { + localctx = NewClustering_joinContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1092, PlSqlParserRULE_clustering_join) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10989) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1339, p.GetParserRuleContext()) == 1 { + { + p.SetState(10986) + p.Schema_name() + } + { + p.SetState(10987) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10991) + p.Table_name() + } + { + p.SetState(10992) + p.Clustering_join_item() + } + p.SetState(10997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10993) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10994) + p.Clustering_join_item() + } + + p.SetState(10999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClustering_join_itemContext is an interface to support dynamic dispatch. +type IClustering_join_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + Table_name() ITable_nameContext + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Equijoin_condition() IEquijoin_conditionContext + RIGHT_PAREN() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsClustering_join_itemContext differentiates from other interfaces. + IsClustering_join_itemContext() +} + +type Clustering_join_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_join_itemContext() *Clustering_join_itemContext { + var p = new(Clustering_join_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join_item + return p +} + +func InitEmptyClustering_join_itemContext(p *Clustering_join_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join_item +} + +func (*Clustering_join_itemContext) IsClustering_join_itemContext() {} + +func NewClustering_join_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_join_itemContext { + var p = new(Clustering_join_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_join_item + + return p +} + +func (s *Clustering_join_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_join_itemContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Clustering_join_itemContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Clustering_join_itemContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Clustering_join_itemContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_join_itemContext) Equijoin_condition() IEquijoin_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEquijoin_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEquijoin_conditionContext) +} + +func (s *Clustering_join_itemContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_join_itemContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Clustering_join_itemContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Clustering_join_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_join_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_join_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_join_item(s) + } +} + +func (s *Clustering_join_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_join_item(s) + } +} + +func (p *PlSqlParser) Clustering_join_item() (localctx IClustering_join_itemContext) { + localctx = NewClustering_join_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1094, PlSqlParserRULE_clustering_join_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11000) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11004) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1341, p.GetParserRuleContext()) == 1 { + { + p.SetState(11001) + p.Schema_name() + } + { + p.SetState(11002) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11006) + p.Table_name() + } + { + p.SetState(11007) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11008) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11009) + p.Equijoin_condition() + } + { + p.SetState(11010) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEquijoin_conditionContext is an interface to support dynamic dispatch. +type IEquijoin_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + + // IsEquijoin_conditionContext differentiates from other interfaces. + IsEquijoin_conditionContext() +} + +type Equijoin_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEquijoin_conditionContext() *Equijoin_conditionContext { + var p = new(Equijoin_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_equijoin_condition + return p +} + +func InitEmptyEquijoin_conditionContext(p *Equijoin_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_equijoin_condition +} + +func (*Equijoin_conditionContext) IsEquijoin_conditionContext() {} + +func NewEquijoin_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Equijoin_conditionContext { + var p = new(Equijoin_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_equijoin_condition + + return p +} + +func (s *Equijoin_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Equijoin_conditionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Equijoin_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Equijoin_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Equijoin_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEquijoin_condition(s) + } +} + +func (s *Equijoin_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEquijoin_condition(s) + } +} + +func (p *PlSqlParser) Equijoin_condition() (localctx IEquijoin_conditionContext) { + localctx = NewEquijoin_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1096, PlSqlParserRULE_equijoin_condition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11012) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_clauseContext is an interface to support dynamic dispatch. +type ICluster_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + ORDER() antlr.TerminalNode + Clustering_columns() IClustering_columnsContext + LINEAR() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + + // IsCluster_clauseContext differentiates from other interfaces. + IsCluster_clauseContext() +} + +type Cluster_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_clauseContext() *Cluster_clauseContext { + var p = new(Cluster_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_clause + return p +} + +func InitEmptyCluster_clauseContext(p *Cluster_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_clause +} + +func (*Cluster_clauseContext) IsCluster_clauseContext() {} + +func NewCluster_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_clauseContext { + var p = new(Cluster_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_clause + + return p +} + +func (s *Cluster_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Cluster_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Cluster_clauseContext) Clustering_columns() IClustering_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClustering_columnsContext) +} + +func (s *Cluster_clauseContext) LINEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINEAR, 0) +} + +func (s *Cluster_clauseContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERLEAVED, 0) +} + +func (s *Cluster_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_clause(s) + } +} + +func (s *Cluster_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_clause(s) + } +} + +func (p *PlSqlParser) Cluster_clause() (localctx ICluster_clauseContext) { + localctx = NewCluster_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1098, PlSqlParserRULE_cluster_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11014) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERLEAVED || _la == PlSqlParserLINEAR { + { + p.SetState(11015) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINTERLEAVED || _la == PlSqlParserLINEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(11018) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11019) + p.Clustering_columns() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClustering_columnsContext is an interface to support dynamic dispatch. +type IClustering_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllClustering_column_group() []IClustering_column_groupContext + Clustering_column_group(i int) IClustering_column_groupContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_columnsContext differentiates from other interfaces. + IsClustering_columnsContext() +} + +type Clustering_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_columnsContext() *Clustering_columnsContext { + var p = new(Clustering_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_columns + return p +} + +func InitEmptyClustering_columnsContext(p *Clustering_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_columns +} + +func (*Clustering_columnsContext) IsClustering_columnsContext() {} + +func NewClustering_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_columnsContext { + var p = new(Clustering_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_columns + + return p +} + +func (s *Clustering_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_columnsContext) AllClustering_column_group() []IClustering_column_groupContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClustering_column_groupContext); ok { + len++ + } + } + + tst := make([]IClustering_column_groupContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClustering_column_groupContext); ok { + tst[i] = t.(IClustering_column_groupContext) + i++ + } + } + + return tst +} + +func (s *Clustering_columnsContext) Clustering_column_group(i int) IClustering_column_groupContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_column_groupContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClustering_column_groupContext) +} + +func (s *Clustering_columnsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_columnsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_columnsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_columnsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_columns(s) + } +} + +func (s *Clustering_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_columns(s) + } +} + +func (p *PlSqlParser) Clustering_columns() (localctx IClustering_columnsContext) { + localctx = NewClustering_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1100, PlSqlParserRULE_clustering_columns) + var _la int + + p.SetState(11033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1344, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11021) + p.Clustering_column_group() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11022) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11023) + p.Clustering_column_group() + } + p.SetState(11028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11024) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11025) + p.Clustering_column_group() + } + + p.SetState(11030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11031) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClustering_column_groupContext is an interface to support dynamic dispatch. +type IClustering_column_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_column_groupContext differentiates from other interfaces. + IsClustering_column_groupContext() +} + +type Clustering_column_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_column_groupContext() *Clustering_column_groupContext { + var p = new(Clustering_column_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_column_group + return p +} + +func InitEmptyClustering_column_groupContext(p *Clustering_column_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_column_group +} + +func (*Clustering_column_groupContext) IsClustering_column_groupContext() {} + +func NewClustering_column_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_column_groupContext { + var p = new(Clustering_column_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_column_group + + return p +} + +func (s *Clustering_column_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_column_groupContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_column_groupContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Clustering_column_groupContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Clustering_column_groupContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_column_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_column_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_column_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_column_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_column_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_column_group(s) + } +} + +func (s *Clustering_column_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_column_group(s) + } +} + +func (p *PlSqlParser) Clustering_column_group() (localctx IClustering_column_groupContext) { + localctx = NewClustering_column_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1102, PlSqlParserRULE_clustering_column_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11035) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11036) + p.Column_name() + } + p.SetState(11041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11037) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11038) + p.Column_name() + } + + p.SetState(11043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11044) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IYes_noContext is an interface to support dynamic dispatch. +type IYes_noContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + YES() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsYes_noContext differentiates from other interfaces. + IsYes_noContext() +} + +type Yes_noContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyYes_noContext() *Yes_noContext { + var p = new(Yes_noContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_yes_no + return p +} + +func InitEmptyYes_noContext(p *Yes_noContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_yes_no +} + +func (*Yes_noContext) IsYes_noContext() {} + +func NewYes_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Yes_noContext { + var p = new(Yes_noContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_yes_no + + return p +} + +func (s *Yes_noContext) GetParser() antlr.Parser { return s.parser } + +func (s *Yes_noContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Yes_noContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Yes_noContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Yes_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Yes_noContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterYes_no(s) + } +} + +func (s *Yes_noContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitYes_no(s) + } +} + +func (p *PlSqlParser) Yes_no() (localctx IYes_noContext) { + localctx = NewYes_noContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1104, PlSqlParserRULE_yes_no) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11046) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNO || _la == PlSqlParserYES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZonemap_clauseContext is an interface to support dynamic dispatch. +type IZonemap_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + RIGHT_PAREN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsZonemap_clauseContext differentiates from other interfaces. + IsZonemap_clauseContext() +} + +type Zonemap_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_clauseContext() *Zonemap_clauseContext { + var p = new(Zonemap_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_clause + return p +} + +func InitEmptyZonemap_clauseContext(p *Zonemap_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_clause +} + +func (*Zonemap_clauseContext) IsZonemap_clauseContext() {} + +func NewZonemap_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_clauseContext { + var p = new(Zonemap_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_clause + + return p +} + +func (s *Zonemap_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Zonemap_clauseContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Zonemap_clauseContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Zonemap_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Zonemap_clauseContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Zonemap_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Zonemap_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Zonemap_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_clause(s) + } +} + +func (s *Zonemap_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_clause(s) + } +} + +func (p *PlSqlParser) Zonemap_clause() (localctx IZonemap_clauseContext) { + localctx = NewZonemap_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1106, PlSqlParserRULE_zonemap_clause) + var _la int + + p.SetState(11060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11048) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11049) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11050) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11051) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11052) + p.Zonemap_name() + } + { + p.SetState(11053) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserWITHOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11057) + p.Match(PlSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11058) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11059) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogical_replication_clauseContext is an interface to support dynamic dispatch. +type ILogical_replication_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISABLE() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + ENABLE() antlr.TerminalNode + KEYS() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + JSON() antlr.TerminalNode + ALL() antlr.TerminalNode + ALLOW() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsLogical_replication_clauseContext differentiates from other interfaces. + IsLogical_replication_clauseContext() +} + +type Logical_replication_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_replication_clauseContext() *Logical_replication_clauseContext { + var p = new(Logical_replication_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_replication_clause + return p +} + +func InitEmptyLogical_replication_clauseContext(p *Logical_replication_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_replication_clause +} + +func (*Logical_replication_clauseContext) IsLogical_replication_clauseContext() {} + +func NewLogical_replication_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_replication_clauseContext { + var p = new(Logical_replication_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_replication_clause + + return p +} + +func (s *Logical_replication_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_replication_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Logical_replication_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Logical_replication_clauseContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Logical_replication_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Logical_replication_clauseContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Logical_replication_clauseContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL, 0) +} + +func (s *Logical_replication_clauseContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Logical_replication_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Logical_replication_clauseContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Logical_replication_clauseContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Logical_replication_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Logical_replication_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_replication_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_replication_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_replication_clause(s) + } +} + +func (s *Logical_replication_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_replication_clause(s) + } +} + +func (p *PlSqlParser) Logical_replication_clause() (localctx ILogical_replication_clauseContext) { + localctx = NewLogical_replication_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1108, PlSqlParserRULE_logical_replication_clause) + var _la int + + p.SetState(11081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11062) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11063) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11064) + p.Match(PlSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11065) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11066) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11067) + p.Match(PlSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11079) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1350, p.GetParserRuleContext()) == 1 { + p.SetState(11071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(11068) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOW: + { + p.SetState(11069) + p.Match(PlSqlParserALLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11070) + p.Match(PlSqlParserNOVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11073) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1350, p.GetParserRuleContext()) == 2 { + p.SetState(11075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(11074) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11077) + p.Match(PlSqlParserPARTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11078) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_nameContext is an interface to support dynamic dispatch. +type ITable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsTable_nameContext differentiates from other interfaces. + IsTable_nameContext() +} + +type Table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_nameContext() *Table_nameContext { + var p = new(Table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_name + return p +} + +func InitEmptyTable_nameContext(p *Table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_name +} + +func (*Table_nameContext) IsTable_nameContext() {} + +func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext { + var p = new(Table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_name + + return p +} + +func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_name(s) + } +} + +func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_name(s) + } +} + +func (p *PlSqlParser) Table_name() (localctx ITable_nameContext) { + localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1110, PlSqlParserRULE_table_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11083) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_propertyContext is an interface to support dynamic dispatch. +type IRelational_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Out_of_line_constraint() IOut_of_line_constraintContext + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + Column_definition() IColumn_definitionContext + Virtual_column_definition() IVirtual_column_definitionContext + Period_definition() IPeriod_definitionContext + Supplemental_logging_props() ISupplemental_logging_propsContext + + // IsRelational_propertyContext differentiates from other interfaces. + IsRelational_propertyContext() +} + +type Relational_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_propertyContext() *Relational_propertyContext { + var p = new(Relational_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_property + return p +} + +func InitEmptyRelational_propertyContext(p *Relational_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_property +} + +func (*Relational_propertyContext) IsRelational_propertyContext() {} + +func NewRelational_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_propertyContext { + var p = new(Relational_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_property + + return p +} + +func (s *Relational_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_propertyContext) Out_of_line_constraint() IOut_of_line_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Relational_propertyContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Relational_propertyContext) Column_definition() IColumn_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Relational_propertyContext) Virtual_column_definition() IVirtual_column_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVirtual_column_definitionContext) +} + +func (s *Relational_propertyContext) Period_definition() IPeriod_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPeriod_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPeriod_definitionContext) +} + +func (s *Relational_propertyContext) Supplemental_logging_props() ISupplemental_logging_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_logging_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_logging_propsContext) +} + +func (s *Relational_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_property(s) + } +} + +func (s *Relational_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_property(s) + } +} + +func (p *PlSqlParser) Relational_property() (localctx IRelational_propertyContext) { + localctx = NewRelational_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1112, PlSqlParserRULE_relational_property) + p.SetState(11091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1352, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11085) + p.Out_of_line_constraint() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11086) + p.Out_of_line_ref_constraint() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11087) + p.Column_definition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11088) + p.Virtual_column_definition() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11089) + p.Period_definition() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11090) + p.Supplemental_logging_props() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_partitioning_clausesContext is an interface to support dynamic dispatch. +type ITable_partitioning_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Range_partitions() IRange_partitionsContext + List_partitions() IList_partitionsContext + Hash_partitions() IHash_partitionsContext + Composite_range_partitions() IComposite_range_partitionsContext + Composite_list_partitions() IComposite_list_partitionsContext + Composite_hash_partitions() IComposite_hash_partitionsContext + Reference_partitioning() IReference_partitioningContext + System_partitioning() ISystem_partitioningContext + + // IsTable_partitioning_clausesContext differentiates from other interfaces. + IsTable_partitioning_clausesContext() +} + +type Table_partitioning_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_partitioning_clausesContext() *Table_partitioning_clausesContext { + var p = new(Table_partitioning_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses + return p +} + +func InitEmptyTable_partitioning_clausesContext(p *Table_partitioning_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses +} + +func (*Table_partitioning_clausesContext) IsTable_partitioning_clausesContext() {} + +func NewTable_partitioning_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_partitioning_clausesContext { + var p = new(Table_partitioning_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses + + return p +} + +func (s *Table_partitioning_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_partitioning_clausesContext) Range_partitions() IRange_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) List_partitions() IList_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Hash_partitions() IHash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_range_partitions() IComposite_range_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_range_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_range_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_list_partitions() IComposite_list_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_list_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_list_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_hash_partitions() IComposite_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_hash_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Reference_partitioning() IReference_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReference_partitioningContext) +} + +func (s *Table_partitioning_clausesContext) System_partitioning() ISystem_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_partitioningContext) +} + +func (s *Table_partitioning_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_partitioning_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_partitioning_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_partitioning_clauses(s) + } +} + +func (s *Table_partitioning_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_partitioning_clauses(s) + } +} + +func (p *PlSqlParser) Table_partitioning_clauses() (localctx ITable_partitioning_clausesContext) { + localctx = NewTable_partitioning_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1114, PlSqlParserRULE_table_partitioning_clauses) + p.SetState(11101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1353, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11093) + p.Range_partitions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11094) + p.List_partitions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11095) + p.Hash_partitions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11096) + p.Composite_range_partitions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11097) + p.Composite_list_partitions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11098) + p.Composite_hash_partitions() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11099) + p.Reference_partitioning() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11100) + p.System_partitioning() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_partitionsContext is an interface to support dynamic dispatch. +type IRange_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllRange_values_clause() []IRange_values_clauseContext + Range_values_clause(i int) IRange_values_clauseContext + AllTable_partition_description() []ITable_partition_descriptionContext + Table_partition_description(i int) ITable_partition_descriptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTERVAL() antlr.TerminalNode + Expression() IExpressionContext + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsRange_partitionsContext differentiates from other interfaces. + IsRange_partitionsContext() +} + +type Range_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_partitionsContext() *Range_partitionsContext { + var p = new(Range_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partitions + return p +} + +func InitEmptyRange_partitionsContext(p *Range_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partitions +} + +func (*Range_partitionsContext) IsRange_partitionsContext() {} + +func NewRange_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_partitionsContext { + var p = new(Range_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_partitions + + return p +} + +func (s *Range_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Range_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Range_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Range_partitionsContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Range_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Range_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Range_partitionsContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Range_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Range_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Range_partitionsContext) AllRange_values_clause() []IRange_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_values_clauseContext); ok { + len++ + } + } + + tst := make([]IRange_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_values_clauseContext); ok { + tst[i] = t.(IRange_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Range_values_clause(i int) IRange_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_partitionsContext) AllTable_partition_description() []ITable_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]ITable_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_partition_descriptionContext); ok { + tst[i] = t.(ITable_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Table_partition_description(i int) ITable_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Range_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_partitionsContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Range_partitionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Range_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Range_partitionsContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Range_partitionsContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Range_partitionsContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Range_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_partitions(s) + } +} + +func (s *Range_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_partitions(s) + } +} + +func (p *PlSqlParser) Range_partitions() (localctx IRange_partitionsContext) { + localctx = NewRange_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1116, PlSqlParserRULE_range_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11103) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11104) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11105) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11106) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11107) + p.Column_name() + } + p.SetState(11112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11108) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11109) + p.Column_name() + } + + p.SetState(11114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11115) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERVAL { + { + p.SetState(11116) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11117) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11118) + p.Expression() + } + { + p.SetState(11119) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11120) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11121) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11122) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11123) + p.Tablespace() + } + p.SetState(11128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11124) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11125) + p.Tablespace() + } + + p.SetState(11130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11131) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(11137) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11138) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11139) + p.Partition_name() + } + + } + { + p.SetState(11142) + p.Range_values_clause() + } + { + p.SetState(11143) + p.Table_partition_description() + } + p.SetState(11154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11144) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11145) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11146) + p.Partition_name() + } + + } + { + p.SetState(11149) + p.Range_values_clause() + } + { + p.SetState(11150) + p.Table_partition_description() + } + + p.SetState(11156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11157) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_partitionsContext is an interface to support dynamic dispatch. +type IList_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Column_name() IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + AllList_values_clause() []IList_values_clauseContext + List_values_clause(i int) IList_values_clauseContext + AllTable_partition_description() []ITable_partition_descriptionContext + Table_partition_description(i int) ITable_partition_descriptionContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_partitionsContext differentiates from other interfaces. + IsList_partitionsContext() +} + +type List_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_partitionsContext() *List_partitionsContext { + var p = new(List_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partitions + return p +} + +func InitEmptyList_partitionsContext(p *List_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partitions +} + +func (*List_partitionsContext) IsList_partitionsContext() {} + +func NewList_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_partitionsContext { + var p = new(List_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_partitions + + return p +} + +func (s *List_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *List_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *List_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *List_partitionsContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *List_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *List_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *List_partitionsContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *List_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *List_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *List_partitionsContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *List_partitionsContext) AllList_values_clause() []IList_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_values_clauseContext); ok { + len++ + } + } + + tst := make([]IList_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_values_clauseContext); ok { + tst[i] = t.(IList_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) List_values_clause(i int) IList_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_partitionsContext) AllTable_partition_description() []ITable_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]ITable_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_partition_descriptionContext); ok { + tst[i] = t.(ITable_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) Table_partition_description(i int) ITable_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *List_partitionsContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *List_partitionsContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *List_partitionsContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *List_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *List_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_partitions(s) + } +} + +func (s *List_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_partitions(s) + } +} + +func (p *PlSqlParser) List_partitions() (localctx IList_partitionsContext) { + localctx = NewList_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1118, PlSqlParserRULE_list_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11159) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11160) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11161) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11162) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11163) + p.Column_name() + } + { + p.SetState(11164) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTOMATIC { + { + p.SetState(11165) + p.Match(PlSqlParserAUTOMATIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11166) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11167) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11168) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11169) + p.Tablespace() + } + p.SetState(11174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11170) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11171) + p.Tablespace() + } + + p.SetState(11176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11177) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(11205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11183) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11184) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11185) + p.Partition_name() + } + + } + { + p.SetState(11188) + p.List_values_clause() + } + { + p.SetState(11189) + p.Table_partition_description() + } + p.SetState(11200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11190) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11191) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11192) + p.Partition_name() + } + + } + { + p.SetState(11195) + p.List_values_clause() + } + { + p.SetState(11196) + p.Table_partition_description() + } + + p.SetState(11202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11203) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partitionsContext is an interface to support dynamic dispatch. +type IHash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_partitionsContext differentiates from other interfaces. + IsHash_partitionsContext() +} + +type Hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partitionsContext() *Hash_partitionsContext { + var p = new(Hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions + return p +} + +func InitEmptyHash_partitionsContext(p *Hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions +} + +func (*Hash_partitionsContext) IsHash_partitionsContext() {} + +func NewHash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partitionsContext { + var p = new(Hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partitions + + return p +} + +func (s *Hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Hash_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Hash_partitionsContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hash_partitionsContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Hash_partitionsContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hash_partitionsContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Hash_partitionsContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partitions(s) + } +} + +func (s *Hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partitions(s) + } +} + +func (p *PlSqlParser) Hash_partitions() (localctx IHash_partitionsContext) { + localctx = NewHash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1120, PlSqlParserRULE_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11207) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11208) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11209) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11210) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11211) + p.Column_name() + } + p.SetState(11216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11212) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11213) + p.Column_name() + } + + p.SetState(11218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11219) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11220) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(11221) + p.Hash_partitions_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndividual_hash_partitionsContext is an interface to support dynamic dispatch. +type IIndividual_hash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllPartitioning_storage_clause() []IPartitioning_storage_clauseContext + Partitioning_storage_clause(i int) IPartitioning_storage_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndividual_hash_partitionsContext differentiates from other interfaces. + IsIndividual_hash_partitionsContext() +} + +type Individual_hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndividual_hash_partitionsContext() *Individual_hash_partitionsContext { + var p = new(Individual_hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions + return p +} + +func InitEmptyIndividual_hash_partitionsContext(p *Individual_hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions +} + +func (*Individual_hash_partitionsContext) IsIndividual_hash_partitionsContext() {} + +func NewIndividual_hash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Individual_hash_partitionsContext { + var p = new(Individual_hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions + + return p +} + +func (s *Individual_hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Individual_hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Individual_hash_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Individual_hash_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Individual_hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Individual_hash_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Individual_hash_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Individual_hash_partitionsContext) AllPartitioning_storage_clause() []IPartitioning_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + len++ + } + } + + tst := make([]IPartitioning_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioning_storage_clauseContext); ok { + tst[i] = t.(IPartitioning_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Individual_hash_partitionsContext) Partitioning_storage_clause(i int) IPartitioning_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Individual_hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Individual_hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Individual_hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Individual_hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Individual_hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndividual_hash_partitions(s) + } +} + +func (s *Individual_hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndividual_hash_partitions(s) + } +} + +func (p *PlSqlParser) Individual_hash_partitions() (localctx IIndividual_hash_partitionsContext) { + localctx = NewIndividual_hash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1122, PlSqlParserRULE_individual_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11224) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11225) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11227) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1370, p.GetParserRuleContext()) == 1 { + { + p.SetState(11226) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11229) + p.Partitioning_storage_clause() + } + + } + p.SetState(11242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11232) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11233) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11235) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1372, p.GetParserRuleContext()) == 1 { + { + p.SetState(11234) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11237) + p.Partitioning_storage_clause() + } + + } + + p.SetState(11244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11245) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partitions_by_quantityContext is an interface to support dynamic dispatch. +type IHash_partitions_by_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITIONS() antlr.TerminalNode + Hash_partition_quantity() IHash_partition_quantityContext + AllSTORE() []antlr.TerminalNode + STORE(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Table_compression() ITable_compressionContext + Key_compression() IKey_compressionContext + OVERFLOW_() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_partitions_by_quantityContext differentiates from other interfaces. + IsHash_partitions_by_quantityContext() +} + +type Hash_partitions_by_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partitions_by_quantityContext() *Hash_partitions_by_quantityContext { + var p = new(Hash_partitions_by_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity + return p +} + +func InitEmptyHash_partitions_by_quantityContext(p *Hash_partitions_by_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity +} + +func (*Hash_partitions_by_quantityContext) IsHash_partitions_by_quantityContext() {} + +func NewHash_partitions_by_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partitions_by_quantityContext { + var p = new(Hash_partitions_by_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity + + return p +} + +func (s *Hash_partitions_by_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partitions_by_quantityContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Hash_partitions_by_quantityContext) Hash_partition_quantity() IHash_partition_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partition_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partition_quantityContext) +} + +func (s *Hash_partitions_by_quantityContext) AllSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORE) +} + +func (s *Hash_partitions_by_quantityContext) STORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, i) +} + +func (s *Hash_partitions_by_quantityContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Hash_partitions_by_quantityContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Hash_partitions_by_quantityContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Hash_partitions_by_quantityContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Hash_partitions_by_quantityContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Hash_partitions_by_quantityContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Hash_partitions_by_quantityContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Hash_partitions_by_quantityContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Hash_partitions_by_quantityContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Hash_partitions_by_quantityContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Hash_partitions_by_quantityContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Hash_partitions_by_quantityContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_partitions_by_quantityContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_partitions_by_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partitions_by_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partitions_by_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partitions_by_quantity(s) + } +} + +func (s *Hash_partitions_by_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partitions_by_quantity(s) + } +} + +func (p *PlSqlParser) Hash_partitions_by_quantity() (localctx IHash_partitions_by_quantityContext) { + localctx = NewHash_partitions_by_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1124, PlSqlParserRULE_hash_partitions_by_quantity) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11247) + p.Match(PlSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11248) + p.Hash_partition_quantity() + } + p.SetState(11262) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1376, p.GetParserRuleContext()) == 1 { + { + p.SetState(11249) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11250) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11251) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11252) + p.Tablespace() + } + p.SetState(11257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11253) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11254) + p.Tablespace() + } + + p.SetState(11259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11260) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11266) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1377, p.GetParserRuleContext()) == 1 { + { + p.SetState(11264) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1377, p.GetParserRuleContext()) == 2 { + { + p.SetState(11265) + p.Key_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11282) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1379, p.GetParserRuleContext()) == 1 { + { + p.SetState(11268) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11269) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11270) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11271) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11272) + p.Tablespace() + } + p.SetState(11277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11273) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11274) + p.Tablespace() + } + + p.SetState(11279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11280) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partition_quantityContext is an interface to support dynamic dispatch. +type IHash_partition_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsHash_partition_quantityContext differentiates from other interfaces. + IsHash_partition_quantityContext() +} + +type Hash_partition_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partition_quantityContext() *Hash_partition_quantityContext { + var p = new(Hash_partition_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity + return p +} + +func InitEmptyHash_partition_quantityContext(p *Hash_partition_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity +} + +func (*Hash_partition_quantityContext) IsHash_partition_quantityContext() {} + +func NewHash_partition_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partition_quantityContext { + var p = new(Hash_partition_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity + + return p +} + +func (s *Hash_partition_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partition_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_partition_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partition_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partition_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partition_quantity(s) + } +} + +func (s *Hash_partition_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partition_quantity(s) + } +} + +func (p *PlSqlParser) Hash_partition_quantity() (localctx IHash_partition_quantityContext) { + localctx = NewHash_partition_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1126, PlSqlParserRULE_hash_partition_quantity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11284) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComposite_range_partitionsContext is an interface to support dynamic dispatch. +type IComposite_range_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllRange_partition_desc() []IRange_partition_descContext + Range_partition_desc(i int) IRange_partition_descContext + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTERVAL() antlr.TerminalNode + Expression() IExpressionContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsComposite_range_partitionsContext differentiates from other interfaces. + IsComposite_range_partitionsContext() +} + +type Composite_range_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_range_partitionsContext() *Composite_range_partitionsContext { + var p = new(Composite_range_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_range_partitions + return p +} + +func InitEmptyComposite_range_partitionsContext(p *Composite_range_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_range_partitions +} + +func (*Composite_range_partitionsContext) IsComposite_range_partitionsContext() {} + +func NewComposite_range_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_range_partitionsContext { + var p = new(Composite_range_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_range_partitions + + return p +} + +func (s *Composite_range_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_range_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_range_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_range_partitionsContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Composite_range_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Composite_range_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Composite_range_partitionsContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Composite_range_partitionsContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Composite_range_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Composite_range_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Composite_range_partitionsContext) AllRange_partition_desc() []IRange_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_partition_descContext); ok { + len++ + } + } + + tst := make([]IRange_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_partition_descContext); ok { + tst[i] = t.(IRange_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Composite_range_partitionsContext) Range_partition_desc(i int) IRange_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_range_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_range_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_range_partitionsContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Composite_range_partitionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Composite_range_partitionsContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Composite_range_partitionsContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Composite_range_partitionsContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Composite_range_partitionsContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Composite_range_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_range_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_range_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_range_partitions(s) + } +} + +func (s *Composite_range_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_range_partitions(s) + } +} + +func (p *PlSqlParser) Composite_range_partitions() (localctx IComposite_range_partitionsContext) { + localctx = NewComposite_range_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1128, PlSqlParserRULE_composite_range_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11286) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11287) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11288) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11289) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11290) + p.Column_name() + } + p.SetState(11295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11291) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11292) + p.Column_name() + } + + p.SetState(11297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11298) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERVAL { + { + p.SetState(11299) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11300) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11301) + p.Expression() + } + { + p.SetState(11302) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11303) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11304) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11305) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11306) + p.Tablespace() + } + p.SetState(11311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11307) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11308) + p.Tablespace() + } + + p.SetState(11313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11314) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(11323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1384, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11320) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11321) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11322) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11325) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11326) + p.Range_partition_desc() + } + p.SetState(11331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11327) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11328) + p.Range_partition_desc() + } + + p.SetState(11333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11334) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComposite_list_partitionsContext is an interface to support dynamic dispatch. +type IComposite_list_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Column_name() IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllList_partition_desc() []IList_partition_descContext + List_partition_desc(i int) IList_partition_descContext + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsComposite_list_partitionsContext differentiates from other interfaces. + IsComposite_list_partitionsContext() +} + +type Composite_list_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_list_partitionsContext() *Composite_list_partitionsContext { + var p = new(Composite_list_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_list_partitions + return p +} + +func InitEmptyComposite_list_partitionsContext(p *Composite_list_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_list_partitions +} + +func (*Composite_list_partitionsContext) IsComposite_list_partitionsContext() {} + +func NewComposite_list_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_list_partitionsContext { + var p = new(Composite_list_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_list_partitions + + return p +} + +func (s *Composite_list_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_list_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_list_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_list_partitionsContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Composite_list_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Composite_list_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Composite_list_partitionsContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Composite_list_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Composite_list_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Composite_list_partitionsContext) AllList_partition_desc() []IList_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_partition_descContext); ok { + len++ + } + } + + tst := make([]IList_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_partition_descContext); ok { + tst[i] = t.(IList_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Composite_list_partitionsContext) List_partition_desc(i int) IList_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_list_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_list_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_list_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_list_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_list_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_list_partitions(s) + } +} + +func (s *Composite_list_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_list_partitions(s) + } +} + +func (p *PlSqlParser) Composite_list_partitions() (localctx IComposite_list_partitionsContext) { + localctx = NewComposite_list_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1130, PlSqlParserRULE_composite_list_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11336) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11337) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11338) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11339) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11340) + p.Column_name() + } + { + p.SetState(11341) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1386, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11342) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11343) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11344) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11347) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11348) + p.List_partition_desc() + } + p.SetState(11353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11349) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11350) + p.List_partition_desc() + } + + p.SetState(11355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11356) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComposite_hash_partitionsContext is an interface to support dynamic dispatch. +type IComposite_hash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + + // IsComposite_hash_partitionsContext differentiates from other interfaces. + IsComposite_hash_partitionsContext() +} + +type Composite_hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_hash_partitionsContext() *Composite_hash_partitionsContext { + var p = new(Composite_hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions + return p +} + +func InitEmptyComposite_hash_partitionsContext(p *Composite_hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions +} + +func (*Composite_hash_partitionsContext) IsComposite_hash_partitionsContext() {} + +func NewComposite_hash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_hash_partitionsContext { + var p = new(Composite_hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions + + return p +} + +func (s *Composite_hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_hash_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_hash_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_hash_partitionsContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Composite_hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Composite_hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_hash_partitionsContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Composite_hash_partitionsContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Composite_hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_hash_partitionsContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Composite_hash_partitionsContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Composite_hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_hash_partitions(s) + } +} + +func (s *Composite_hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_hash_partitions(s) + } +} + +func (p *PlSqlParser) Composite_hash_partitions() (localctx IComposite_hash_partitionsContext) { + localctx = NewComposite_hash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1132, PlSqlParserRULE_composite_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11358) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11359) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11360) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11361) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(11362) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11363) + p.Column_name() + } + + p.SetState(11366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11368) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1389, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11369) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11370) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11371) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11374) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(11375) + p.Hash_partitions_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_partitioningContext is an interface to support dynamic dispatch. +type IReference_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Constraint_name() IConstraint_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllReference_partition_desc() []IReference_partition_descContext + Reference_partition_desc(i int) IReference_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReference_partitioningContext differentiates from other interfaces. + IsReference_partitioningContext() +} + +type Reference_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_partitioningContext() *Reference_partitioningContext { + var p = new(Reference_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partitioning + return p +} + +func InitEmptyReference_partitioningContext(p *Reference_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partitioning +} + +func (*Reference_partitioningContext) IsReference_partitioningContext() {} + +func NewReference_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_partitioningContext { + var p = new(Reference_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_partitioning + + return p +} + +func (s *Reference_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_partitioningContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Reference_partitioningContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Reference_partitioningContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Reference_partitioningContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Reference_partitioningContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Reference_partitioningContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Reference_partitioningContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Reference_partitioningContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Reference_partitioningContext) AllReference_partition_desc() []IReference_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_partition_descContext); ok { + len++ + } + } + + tst := make([]IReference_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_partition_descContext); ok { + tst[i] = t.(IReference_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Reference_partitioningContext) Reference_partition_desc(i int) IReference_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_partition_descContext) +} + +func (s *Reference_partitioningContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Reference_partitioningContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Reference_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_partitioning(s) + } +} + +func (s *Reference_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_partitioning(s) + } +} + +func (p *PlSqlParser) Reference_partitioning() (localctx IReference_partitioningContext) { + localctx = NewReference_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1134, PlSqlParserRULE_reference_partitioning) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11378) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11379) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11380) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11381) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11382) + p.Constraint_name() + } + { + p.SetState(11383) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11384) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11385) + p.Reference_partition_desc() + } + p.SetState(11390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11386) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11387) + p.Reference_partition_desc() + } + + p.SetState(11392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11393) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_partition_descContext is an interface to support dynamic dispatch. +type IReference_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + + // IsReference_partition_descContext differentiates from other interfaces. + IsReference_partition_descContext() +} + +type Reference_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_partition_descContext() *Reference_partition_descContext { + var p = new(Reference_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partition_desc + return p +} + +func InitEmptyReference_partition_descContext(p *Reference_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partition_desc +} + +func (*Reference_partition_descContext) IsReference_partition_descContext() {} + +func NewReference_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_partition_descContext { + var p = new(Reference_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_partition_desc + + return p +} + +func (s *Reference_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Reference_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Reference_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Reference_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_partition_desc(s) + } +} + +func (s *Reference_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_partition_desc(s) + } +} + +func (p *PlSqlParser) Reference_partition_desc() (localctx IReference_partition_descContext) { + localctx = NewReference_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1136, PlSqlParserRULE_reference_partition_desc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11397) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11399) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1393, p.GetParserRuleContext()) == 1 { + { + p.SetState(11398) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11401) + p.Table_partition_description() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_partitioningContext is an interface to support dynamic dispatch. +type ISystem_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AllReference_partition_desc() []IReference_partition_descContext + Reference_partition_desc(i int) IReference_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSystem_partitioningContext differentiates from other interfaces. + IsSystem_partitioningContext() +} + +type System_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_partitioningContext() *System_partitioningContext { + var p = new(System_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_partitioning + return p +} + +func InitEmptySystem_partitioningContext(p *System_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_partitioning +} + +func (*System_partitioningContext) IsSystem_partitioningContext() {} + +func NewSystem_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_partitioningContext { + var p = new(System_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_partitioning + + return p +} + +func (s *System_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_partitioningContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *System_partitioningContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *System_partitioningContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *System_partitioningContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *System_partitioningContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *System_partitioningContext) AllReference_partition_desc() []IReference_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_partition_descContext); ok { + len++ + } + } + + tst := make([]IReference_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_partition_descContext); ok { + tst[i] = t.(IReference_partition_descContext) + i++ + } + } + + return tst +} + +func (s *System_partitioningContext) Reference_partition_desc(i int) IReference_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_partition_descContext) +} + +func (s *System_partitioningContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *System_partitioningContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *System_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_partitioning(s) + } +} + +func (s *System_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_partitioning(s) + } +} + +func (p *PlSqlParser) System_partitioning() (localctx ISystem_partitioningContext) { + localctx = NewSystem_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1138, PlSqlParserRULE_system_partitioning) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11403) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11404) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11405) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11416) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1395, p.GetParserRuleContext()) == 1 { + { + p.SetState(11406) + p.Match(PlSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11407) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1395, p.GetParserRuleContext()) == 2 { + { + p.SetState(11408) + p.Reference_partition_desc() + } + p.SetState(11413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11409) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11410) + p.Reference_partition_desc() + } + + p.SetState(11415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_partition_descContext is an interface to support dynamic dispatch. +type IRange_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + Range_values_clause() IRange_values_clauseContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subparts_by_quantity() IHash_subparts_by_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRange_partition_descContext differentiates from other interfaces. + IsRange_partition_descContext() +} + +type Range_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_partition_descContext() *Range_partition_descContext { + var p = new(Range_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partition_desc + return p +} + +func InitEmptyRange_partition_descContext(p *Range_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partition_desc +} + +func (*Range_partition_descContext) IsRange_partition_descContext() {} + +func NewRange_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_partition_descContext { + var p = new(Range_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_partition_desc + + return p +} + +func (s *Range_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Range_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Range_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Range_partition_descContext) Range_values_clause() IRange_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_partition_descContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Range_partition_descContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Range_partition_descContext) Hash_subparts_by_quantity() IHash_subparts_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subparts_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subparts_by_quantityContext) +} + +func (s *Range_partition_descContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Range_partition_descContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *Range_partition_descContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *Range_partition_descContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_partition_descContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_partition_desc(s) + } +} + +func (s *Range_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_partition_desc(s) + } +} + +func (p *PlSqlParser) Range_partition_desc() (localctx IRange_partition_descContext) { + localctx = NewRange_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1140, PlSqlParserRULE_range_partition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11418) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11420) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1396, p.GetParserRuleContext()) == 1 { + { + p.SetState(11419) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUES { + { + p.SetState(11422) + p.Range_values_clause() + } + + } + { + p.SetState(11425) + p.Table_partition_description() + } + p.SetState(11458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserLEFT_PAREN { + p.SetState(11456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11426) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1401, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11427) + p.Range_subpartition_desc() + } + p.SetState(11432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11428) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11429) + p.Range_subpartition_desc() + } + + p.SetState(11434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11435) + p.List_subpartition_desc() + } + p.SetState(11440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11436) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11437) + p.List_subpartition_desc() + } + + p.SetState(11442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11443) + p.Individual_hash_subparts() + } + p.SetState(11448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11444) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11445) + p.Individual_hash_subparts() + } + + p.SetState(11450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11453) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11455) + p.Hash_subparts_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_partition_descContext is an interface to support dynamic dispatch. +type IList_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + List_values_clause() IList_values_clauseContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subparts_by_quantity() IHash_subparts_by_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_partition_descContext differentiates from other interfaces. + IsList_partition_descContext() +} + +type List_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_partition_descContext() *List_partition_descContext { + var p = new(List_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partition_desc + return p +} + +func InitEmptyList_partition_descContext(p *List_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partition_desc +} + +func (*List_partition_descContext) IsList_partition_descContext() {} + +func NewList_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_partition_descContext { + var p = new(List_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_partition_desc + + return p +} + +func (s *List_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *List_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *List_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *List_partition_descContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_partition_descContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *List_partition_descContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *List_partition_descContext) Hash_subparts_by_quantity() IHash_subparts_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subparts_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subparts_by_quantityContext) +} + +func (s *List_partition_descContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *List_partition_descContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *List_partition_descContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *List_partition_descContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_partition_descContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_partition_desc(s) + } +} + +func (s *List_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_partition_desc(s) + } +} + +func (p *PlSqlParser) List_partition_desc() (localctx IList_partition_descContext) { + localctx = NewList_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1142, PlSqlParserRULE_list_partition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11460) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11462) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1404, p.GetParserRuleContext()) == 1 { + { + p.SetState(11461) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUES { + { + p.SetState(11464) + p.List_values_clause() + } + + } + { + p.SetState(11467) + p.Table_partition_description() + } + p.SetState(11500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserLEFT_PAREN { + p.SetState(11498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11468) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1409, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11469) + p.Range_subpartition_desc() + } + p.SetState(11474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11470) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11471) + p.Range_subpartition_desc() + } + + p.SetState(11476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11477) + p.List_subpartition_desc() + } + p.SetState(11482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11478) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11479) + p.List_subpartition_desc() + } + + p.SetState(11484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11485) + p.Individual_hash_subparts() + } + p.SetState(11490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11486) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11487) + p.Individual_hash_subparts() + } + + p.SetState(11492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11495) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11497) + p.Hash_subparts_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_templateContext is an interface to support dynamic dispatch. +type ISubpartition_templateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subpartition_quantity() IHash_subpartition_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSubpartition_templateContext differentiates from other interfaces. + IsSubpartition_templateContext() +} + +type Subpartition_templateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_templateContext() *Subpartition_templateContext { + var p = new(Subpartition_templateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_template + return p +} + +func InitEmptySubpartition_templateContext(p *Subpartition_templateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_template +} + +func (*Subpartition_templateContext) IsSubpartition_templateContext() {} + +func NewSubpartition_templateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_templateContext { + var p = new(Subpartition_templateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_template + + return p +} + +func (s *Subpartition_templateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_templateContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_templateContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Subpartition_templateContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_templateContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_templateContext) Hash_subpartition_quantity() IHash_subpartition_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subpartition_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subpartition_quantityContext) +} + +func (s *Subpartition_templateContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Subpartition_templateContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *Subpartition_templateContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *Subpartition_templateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_templateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_templateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_templateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_templateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_template(s) + } +} + +func (s *Subpartition_templateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_template(s) + } +} + +func (p *PlSqlParser) Subpartition_template() (localctx ISubpartition_templateContext) { + localctx = NewSubpartition_templateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1144, PlSqlParserRULE_subpartition_template) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11502) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11503) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11504) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1415, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11505) + p.Range_subpartition_desc() + } + p.SetState(11510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11506) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11507) + p.Range_subpartition_desc() + } + + p.SetState(11512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11513) + p.List_subpartition_desc() + } + p.SetState(11518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11514) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11515) + p.List_subpartition_desc() + } + + p.SetState(11520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11521) + p.Individual_hash_subparts() + } + p.SetState(11526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11522) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11523) + p.Individual_hash_subparts() + } + + p.SetState(11528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11531) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(11533) + p.Hash_subpartition_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_subpartition_quantityContext is an interface to support dynamic dispatch. +type IHash_subpartition_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsHash_subpartition_quantityContext differentiates from other interfaces. + IsHash_subpartition_quantityContext() +} + +type Hash_subpartition_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_subpartition_quantityContext() *Hash_subpartition_quantityContext { + var p = new(Hash_subpartition_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity + return p +} + +func InitEmptyHash_subpartition_quantityContext(p *Hash_subpartition_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity +} + +func (*Hash_subpartition_quantityContext) IsHash_subpartition_quantityContext() {} + +func NewHash_subpartition_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_subpartition_quantityContext { + var p = new(Hash_subpartition_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity + + return p +} + +func (s *Hash_subpartition_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_subpartition_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_subpartition_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_subpartition_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_subpartition_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_subpartition_quantity(s) + } +} + +func (s *Hash_subpartition_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_subpartition_quantity(s) + } +} + +func (p *PlSqlParser) Hash_subpartition_quantity() (localctx IHash_subpartition_quantityContext) { + localctx = NewHash_subpartition_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1146, PlSqlParserRULE_hash_subpartition_quantity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11536) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_by_rangeContext is an interface to support dynamic dispatch. +type ISubpartition_by_rangeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + + // IsSubpartition_by_rangeContext differentiates from other interfaces. + IsSubpartition_by_rangeContext() +} + +type Subpartition_by_rangeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_rangeContext() *Subpartition_by_rangeContext { + var p = new(Subpartition_by_rangeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_range + return p +} + +func InitEmptySubpartition_by_rangeContext(p *Subpartition_by_rangeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_range +} + +func (*Subpartition_by_rangeContext) IsSubpartition_by_rangeContext() {} + +func NewSubpartition_by_rangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_rangeContext { + var p = new(Subpartition_by_rangeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_range + + return p +} + +func (s *Subpartition_by_rangeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_rangeContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_rangeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_rangeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Subpartition_by_rangeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_by_rangeContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_by_rangeContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Subpartition_by_rangeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_by_rangeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_by_rangeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_by_rangeContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_rangeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_rangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_rangeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_range(s) + } +} + +func (s *Subpartition_by_rangeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_range(s) + } +} + +func (p *PlSqlParser) Subpartition_by_range() (localctx ISubpartition_by_rangeContext) { + localctx = NewSubpartition_by_rangeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1148, PlSqlParserRULE_subpartition_by_range) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11538) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11539) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11540) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11541) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11542) + p.Column_name() + } + p.SetState(11547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11543) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11544) + p.Column_name() + } + + p.SetState(11549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11550) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITION { + { + p.SetState(11551) + p.Subpartition_template() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_by_listContext is an interface to support dynamic dispatch. +type ISubpartition_by_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + + // IsSubpartition_by_listContext differentiates from other interfaces. + IsSubpartition_by_listContext() +} + +type Subpartition_by_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_listContext() *Subpartition_by_listContext { + var p = new(Subpartition_by_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_list + return p +} + +func InitEmptySubpartition_by_listContext(p *Subpartition_by_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_list +} + +func (*Subpartition_by_listContext) IsSubpartition_by_listContext() {} + +func NewSubpartition_by_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_listContext { + var p = new(Subpartition_by_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_list + + return p +} + +func (s *Subpartition_by_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_listContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_listContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_listContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Subpartition_by_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_by_listContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Subpartition_by_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_by_listContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_list(s) + } +} + +func (s *Subpartition_by_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_list(s) + } +} + +func (p *PlSqlParser) Subpartition_by_list() (localctx ISubpartition_by_listContext) { + localctx = NewSubpartition_by_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1150, PlSqlParserRULE_subpartition_by_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11554) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11555) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11556) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11557) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11558) + p.Column_name() + } + { + p.SetState(11559) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITION { + { + p.SetState(11560) + p.Subpartition_template() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_by_hashContext is an interface to support dynamic dispatch. +type ISubpartition_by_hashContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsSubpartition_by_hashContext differentiates from other interfaces. + IsSubpartition_by_hashContext() +} + +type Subpartition_by_hashContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_hashContext() *Subpartition_by_hashContext { + var p = new(Subpartition_by_hashContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash + return p +} + +func InitEmptySubpartition_by_hashContext(p *Subpartition_by_hashContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash +} + +func (*Subpartition_by_hashContext) IsSubpartition_by_hashContext() {} + +func NewSubpartition_by_hashContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_hashContext { + var p = new(Subpartition_by_hashContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash + + return p +} + +func (s *Subpartition_by_hashContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_hashContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_hashContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_hashContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Subpartition_by_hashContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Subpartition_by_hashContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Subpartition_by_hashContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_by_hashContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Subpartition_by_hashContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Subpartition_by_hashContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Subpartition_by_hashContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_by_hashContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_by_hashContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Subpartition_by_hashContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Subpartition_by_hashContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_hashContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Subpartition_by_hashContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Subpartition_by_hashContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_by_hashContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Subpartition_by_hashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_hashContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_hashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_hash(s) + } +} + +func (s *Subpartition_by_hashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_hash(s) + } +} + +func (p *PlSqlParser) Subpartition_by_hash() (localctx ISubpartition_by_hashContext) { + localctx = NewSubpartition_by_hashContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1152, PlSqlParserRULE_subpartition_by_hash) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11563) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11564) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11565) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11566) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11567) + p.Column_name() + } + p.SetState(11572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11568) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11569) + p.Column_name() + } + + p.SetState(11574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11575) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11576) + p.Match(PlSqlParserSUBPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11577) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11578) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11579) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11580) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11581) + p.Tablespace() + } + p.SetState(11586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11582) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11583) + p.Tablespace() + } + + p.SetState(11588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11589) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(11593) + p.Subpartition_template() + } + + case PlSqlParserPARTITIONS, PlSqlParserLEFT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_nameContext is an interface to support dynamic dispatch. +type ISubpartition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsSubpartition_nameContext differentiates from other interfaces. + IsSubpartition_nameContext() +} + +type Subpartition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_nameContext() *Subpartition_nameContext { + var p = new(Subpartition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_name + return p +} + +func InitEmptySubpartition_nameContext(p *Subpartition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_name +} + +func (*Subpartition_nameContext) IsSubpartition_nameContext() {} + +func NewSubpartition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_nameContext { + var p = new(Subpartition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_name + + return p +} + +func (s *Subpartition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_nameContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Subpartition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_name(s) + } +} + +func (s *Subpartition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_name(s) + } +} + +func (p *PlSqlParser) Subpartition_name() (localctx ISubpartition_nameContext) { + localctx = NewSubpartition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1154, PlSqlParserRULE_subpartition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11596) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_subpartition_descContext is an interface to support dynamic dispatch. +type IRange_subpartition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Range_values_clause() IRange_values_clauseContext + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsRange_subpartition_descContext differentiates from other interfaces. + IsRange_subpartition_descContext() +} + +type Range_subpartition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_subpartition_descContext() *Range_subpartition_descContext { + var p = new(Range_subpartition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc + return p +} + +func InitEmptyRange_subpartition_descContext(p *Range_subpartition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc +} + +func (*Range_subpartition_descContext) IsRange_subpartition_descContext() {} + +func NewRange_subpartition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_subpartition_descContext { + var p = new(Range_subpartition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc + + return p +} + +func (s *Range_subpartition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_subpartition_descContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Range_subpartition_descContext) Range_values_clause() IRange_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_subpartition_descContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Range_subpartition_descContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Range_subpartition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_subpartition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_subpartition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_subpartition_desc(s) + } +} + +func (s *Range_subpartition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_subpartition_desc(s) + } +} + +func (p *PlSqlParser) Range_subpartition_desc() (localctx IRange_subpartition_descContext) { + localctx = NewRange_subpartition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1156, PlSqlParserRULE_range_subpartition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11598) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11599) + p.Subpartition_name() + } + + } + { + p.SetState(11602) + p.Range_values_clause() + } + p.SetState(11604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11603) + p.Partitioning_storage_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_subpartition_descContext is an interface to support dynamic dispatch. +type IList_subpartition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + List_values_clause() IList_values_clauseContext + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsList_subpartition_descContext differentiates from other interfaces. + IsList_subpartition_descContext() +} + +type List_subpartition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_subpartition_descContext() *List_subpartition_descContext { + var p = new(List_subpartition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc + return p +} + +func InitEmptyList_subpartition_descContext(p *List_subpartition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc +} + +func (*List_subpartition_descContext) IsList_subpartition_descContext() {} + +func NewList_subpartition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_subpartition_descContext { + var p = new(List_subpartition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc + + return p +} + +func (s *List_subpartition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_subpartition_descContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *List_subpartition_descContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_subpartition_descContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *List_subpartition_descContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *List_subpartition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_subpartition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_subpartition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_subpartition_desc(s) + } +} + +func (s *List_subpartition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_subpartition_desc(s) + } +} + +func (p *PlSqlParser) List_subpartition_desc() (localctx IList_subpartition_descContext) { + localctx = NewList_subpartition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1158, PlSqlParserRULE_list_subpartition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11606) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(11607) + p.Subpartition_name() + } + + } + { + p.SetState(11610) + p.List_values_clause() + } + p.SetState(11612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11611) + p.Partitioning_storage_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndividual_hash_subpartsContext is an interface to support dynamic dispatch. +type IIndividual_hash_subpartsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsIndividual_hash_subpartsContext differentiates from other interfaces. + IsIndividual_hash_subpartsContext() +} + +type Individual_hash_subpartsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndividual_hash_subpartsContext() *Individual_hash_subpartsContext { + var p = new(Individual_hash_subpartsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts + return p +} + +func InitEmptyIndividual_hash_subpartsContext(p *Individual_hash_subpartsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts +} + +func (*Individual_hash_subpartsContext) IsIndividual_hash_subpartsContext() {} + +func NewIndividual_hash_subpartsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Individual_hash_subpartsContext { + var p = new(Individual_hash_subpartsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts + + return p +} + +func (s *Individual_hash_subpartsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Individual_hash_subpartsContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Individual_hash_subpartsContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Individual_hash_subpartsContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Individual_hash_subpartsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Individual_hash_subpartsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Individual_hash_subpartsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndividual_hash_subparts(s) + } +} + +func (s *Individual_hash_subpartsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndividual_hash_subparts(s) + } +} + +func (p *PlSqlParser) Individual_hash_subparts() (localctx IIndividual_hash_subpartsContext) { + localctx = NewIndividual_hash_subpartsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1160, PlSqlParserRULE_individual_hash_subparts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11614) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11616) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1428, p.GetParserRuleContext()) == 1 { + { + p.SetState(11615) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11618) + p.Partitioning_storage_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_subparts_by_quantityContext is an interface to support dynamic dispatch. +type IHash_subparts_by_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_subparts_by_quantityContext differentiates from other interfaces. + IsHash_subparts_by_quantityContext() +} + +type Hash_subparts_by_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_subparts_by_quantityContext() *Hash_subparts_by_quantityContext { + var p = new(Hash_subparts_by_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity + return p +} + +func InitEmptyHash_subparts_by_quantityContext(p *Hash_subparts_by_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity +} + +func (*Hash_subparts_by_quantityContext) IsHash_subparts_by_quantityContext() {} + +func NewHash_subparts_by_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_subparts_by_quantityContext { + var p = new(Hash_subparts_by_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity + + return p +} + +func (s *Hash_subparts_by_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_subparts_by_quantityContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Hash_subparts_by_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_subparts_by_quantityContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Hash_subparts_by_quantityContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Hash_subparts_by_quantityContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hash_subparts_by_quantityContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Hash_subparts_by_quantityContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Hash_subparts_by_quantityContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hash_subparts_by_quantityContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_subparts_by_quantityContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_subparts_by_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_subparts_by_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_subparts_by_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_subparts_by_quantity(s) + } +} + +func (s *Hash_subparts_by_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_subparts_by_quantity(s) + } +} + +func (p *PlSqlParser) Hash_subparts_by_quantity() (localctx IHash_subparts_by_quantityContext) { + localctx = NewHash_subparts_by_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1162, PlSqlParserRULE_hash_subparts_by_quantity) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11621) + p.Match(PlSqlParserSUBPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11622) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11623) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11624) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11625) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11626) + p.Tablespace() + } + p.SetState(11631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11627) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11628) + p.Tablespace() + } + + p.SetState(11633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11634) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_values_clauseContext is an interface to support dynamic dispatch. +type IRange_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + LESS() antlr.TerminalNode + THAN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Range_values_list() IRange_values_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsRange_values_clauseContext differentiates from other interfaces. + IsRange_values_clauseContext() +} + +type Range_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_values_clauseContext() *Range_values_clauseContext { + var p = new(Range_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_clause + return p +} + +func InitEmptyRange_values_clauseContext(p *Range_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_clause +} + +func (*Range_values_clauseContext) IsRange_values_clauseContext() {} + +func NewRange_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_values_clauseContext { + var p = new(Range_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_values_clause + + return p +} + +func (s *Range_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Range_values_clauseContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Range_values_clauseContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Range_values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Range_values_clauseContext) Range_values_list() IRange_values_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_listContext) +} + +func (s *Range_values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Range_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_values_clause(s) + } +} + +func (s *Range_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_values_clause(s) + } +} + +func (p *PlSqlParser) Range_values_clause() (localctx IRange_values_clauseContext) { + localctx = NewRange_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1164, PlSqlParserRULE_range_values_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11638) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11639) + p.Match(PlSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11640) + p.Match(PlSqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11641) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11642) + p.Range_values_list() + } + { + p.SetState(11643) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_values_listContext is an interface to support dynamic dispatch. +type IRange_values_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTIMESTAMP() []antlr.TerminalNode + TIMESTAMP(i int) antlr.TerminalNode + + // IsRange_values_listContext differentiates from other interfaces. + IsRange_values_listContext() +} + +type Range_values_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_values_listContext() *Range_values_listContext { + var p = new(Range_values_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_list + return p +} + +func InitEmptyRange_values_listContext(p *Range_values_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_list +} + +func (*Range_values_listContext) IsRange_values_listContext() {} + +func NewRange_values_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_values_listContext { + var p = new(Range_values_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_values_list + + return p +} + +func (s *Range_values_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_values_listContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Range_values_listContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Range_values_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_values_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_values_listContext) AllTIMESTAMP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIMESTAMP) +} + +func (s *Range_values_listContext) TIMESTAMP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, i) +} + +func (s *Range_values_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_values_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_values_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_values_list(s) + } +} + +func (s *Range_values_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_values_list(s) + } +} + +func (p *PlSqlParser) Range_values_list() (localctx IRange_values_listContext) { + localctx = NewRange_values_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1166, PlSqlParserRULE_range_values_list) + var _la int + + p.SetState(11663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserMINUS_SIGN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11645) + p.Literal() + } + p.SetState(11650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11646) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11647) + p.Literal() + } + + p.SetState(11652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11653) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11654) + p.Literal() + } + p.SetState(11660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11655) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11656) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11657) + p.Literal() + } + + p.SetState(11662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_values_clauseContext is an interface to support dynamic dispatch. +type IList_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllTIMESTAMP() []antlr.TerminalNode + TIMESTAMP(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_values_clauseContext differentiates from other interfaces. + IsList_values_clauseContext() +} + +type List_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_values_clauseContext() *List_values_clauseContext { + var p = new(List_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_values_clause + return p +} + +func InitEmptyList_values_clauseContext(p *List_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_values_clause +} + +func (*List_values_clauseContext) IsList_values_clauseContext() {} + +func NewList_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_values_clauseContext { + var p = new(List_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_values_clause + + return p +} + +func (s *List_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *List_values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *List_values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *List_values_clauseContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *List_values_clauseContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *List_values_clauseContext) AllTIMESTAMP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIMESTAMP) +} + +func (s *List_values_clauseContext) TIMESTAMP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, i) +} + +func (s *List_values_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *List_values_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_values_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_values_clause(s) + } +} + +func (s *List_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_values_clause(s) + } +} + +func (p *PlSqlParser) List_values_clause() (localctx IList_values_clauseContext) { + localctx = NewList_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1168, PlSqlParserRULE_list_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11665) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11666) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserMINUS_SIGN: + { + p.SetState(11667) + p.Literal() + } + p.SetState(11672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11668) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11669) + p.Literal() + } + + p.SetState(11674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTIMESTAMP: + { + p.SetState(11675) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11676) + p.Literal() + } + p.SetState(11682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11677) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11678) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11679) + p.Literal() + } + + p.SetState(11684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDEFAULT: + { + p.SetState(11685) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11688) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_partition_descriptionContext is an interface to support dynamic dispatch. +type ITable_partition_descriptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Deferred_segment_creation() IDeferred_segment_creationContext + Read_only_clause() IRead_only_clauseContext + Indexing_clause() IIndexing_clauseContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + Table_compression() ITable_compressionContext + Key_compression() IKey_compressionContext + Inmemory_table_clause() IInmemory_table_clauseContext + Ilm_clause() IIlm_clauseContext + OVERFLOW_() antlr.TerminalNode + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + AllNested_table_col_properties() []INested_table_col_propertiesContext + Nested_table_col_properties(i int) INested_table_col_propertiesContext + INTERNAL() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + + // IsTable_partition_descriptionContext differentiates from other interfaces. + IsTable_partition_descriptionContext() +} + +type Table_partition_descriptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_partition_descriptionContext() *Table_partition_descriptionContext { + var p = new(Table_partition_descriptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partition_description + return p +} + +func InitEmptyTable_partition_descriptionContext(p *Table_partition_descriptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partition_description +} + +func (*Table_partition_descriptionContext) IsTable_partition_descriptionContext() {} + +func NewTable_partition_descriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_partition_descriptionContext { + var p = new(Table_partition_descriptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_partition_description + + return p +} + +func (s *Table_partition_descriptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_partition_descriptionContext) Deferred_segment_creation() IDeferred_segment_creationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeferred_segment_creationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeferred_segment_creationContext) +} + +func (s *Table_partition_descriptionContext) Read_only_clause() IRead_only_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRead_only_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRead_only_clauseContext) +} + +func (s *Table_partition_descriptionContext) Indexing_clause() IIndexing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexing_clauseContext) +} + +func (s *Table_partition_descriptionContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Table_partition_descriptionContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Table_partition_descriptionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Table_partition_descriptionContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Table_partition_descriptionContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Table_partition_descriptionContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Table_partition_descriptionContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Table_partition_descriptionContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Table_partition_descriptionContext) AllNested_table_col_properties() []INested_table_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + len++ + } + } + + tst := make([]INested_table_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INested_table_col_propertiesContext); ok { + tst[i] = t.(INested_table_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Nested_table_col_properties(i int) INested_table_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INested_table_col_propertiesContext) +} + +func (s *Table_partition_descriptionContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL, 0) +} + +func (s *Table_partition_descriptionContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Table_partition_descriptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_partition_descriptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_partition_descriptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_partition_description(s) + } +} + +func (s *Table_partition_descriptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_partition_description(s) + } +} + +func (p *PlSqlParser) Table_partition_description() (localctx ITable_partition_descriptionContext) { + localctx = NewTable_partition_descriptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1170, PlSqlParserRULE_table_partition_description) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11691) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1438, p.GetParserRuleContext()) == 1 { + { + p.SetState(11690) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXTERNAL || _la == PlSqlParserINTERNAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11694) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1439, p.GetParserRuleContext()) == 1 { + { + p.SetState(11693) + p.Deferred_segment_creation() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11697) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1440, p.GetParserRuleContext()) == 1 { + { + p.SetState(11696) + p.Read_only_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11700) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1441, p.GetParserRuleContext()) == 1 { + { + p.SetState(11699) + p.Indexing_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11703) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1442, p.GetParserRuleContext()) == 1 { + { + p.SetState(11702) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11707) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1443, p.GetParserRuleContext()) == 1 { + { + p.SetState(11705) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1443, p.GetParserRuleContext()) == 2 { + { + p.SetState(11706) + p.Key_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11710) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1444, p.GetParserRuleContext()) == 1 { + { + p.SetState(11709) + p.Inmemory_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11713) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1445, p.GetParserRuleContext()) == 1 { + { + p.SetState(11712) + p.Ilm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOVERFLOW_ { + { + p.SetState(11715) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11717) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1446, p.GetParserRuleContext()) == 1 { + { + p.SetState(11716) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(11726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1449, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(11724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOB: + { + p.SetState(11721) + p.Lob_storage_clause() + } + + case PlSqlParserVARRAY: + { + p.SetState(11722) + p.Varray_col_properties() + } + + case PlSqlParserNESTED: + { + p.SetState(11723) + p.Nested_table_col_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(11728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1449, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitioning_storage_clauseContext is an interface to support dynamic dispatch. +type IPartitioning_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllOVERFLOW_() []antlr.TerminalNode + OVERFLOW_(i int) antlr.TerminalNode + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllInmemory_table_clause() []IInmemory_table_clauseContext + Inmemory_table_clause(i int) IInmemory_table_clauseContext + AllLob_partitioning_storage() []ILob_partitioning_storageContext + Lob_partitioning_storage(i int) ILob_partitioning_storageContext + AllVARRAY() []antlr.TerminalNode + VARRAY(i int) antlr.TerminalNode + AllVarray_item() []IVarray_itemContext + Varray_item(i int) IVarray_itemContext + AllSTORE() []antlr.TerminalNode + STORE(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllLOB() []antlr.TerminalNode + LOB(i int) antlr.TerminalNode + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + + // IsPartitioning_storage_clauseContext differentiates from other interfaces. + IsPartitioning_storage_clauseContext() +} + +type Partitioning_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitioning_storage_clauseContext() *Partitioning_storage_clauseContext { + var p = new(Partitioning_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause + return p +} + +func InitEmptyPartitioning_storage_clauseContext(p *Partitioning_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause +} + +func (*Partitioning_storage_clauseContext) IsPartitioning_storage_clauseContext() {} + +func NewPartitioning_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partitioning_storage_clauseContext { + var p = new(Partitioning_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause + + return p +} + +func (s *Partitioning_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partitioning_storage_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Partitioning_storage_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Partitioning_storage_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partitioning_storage_clauseContext) AllOVERFLOW_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOVERFLOW_) +} + +func (s *Partitioning_storage_clauseContext) OVERFLOW_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, i) +} + +func (s *Partitioning_storage_clauseContext) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Partitioning_storage_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Partitioning_storage_clauseContext) AllInmemory_table_clause() []IInmemory_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + len++ + } + } + + tst := make([]IInmemory_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_table_clauseContext); ok { + tst[i] = t.(IInmemory_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Inmemory_table_clause(i int) IInmemory_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Partitioning_storage_clauseContext) AllLob_partitioning_storage() []ILob_partitioning_storageContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_partitioning_storageContext); ok { + len++ + } + } + + tst := make([]ILob_partitioning_storageContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_partitioning_storageContext); ok { + tst[i] = t.(ILob_partitioning_storageContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Lob_partitioning_storage(i int) ILob_partitioning_storageContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_partitioning_storageContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_partitioning_storageContext) +} + +func (s *Partitioning_storage_clauseContext) AllVARRAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserVARRAY) +} + +func (s *Partitioning_storage_clauseContext) VARRAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, i) +} + +func (s *Partitioning_storage_clauseContext) AllVarray_item() []IVarray_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_itemContext); ok { + len++ + } + } + + tst := make([]IVarray_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_itemContext); ok { + tst[i] = t.(IVarray_itemContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Varray_item(i int) IVarray_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_itemContext) +} + +func (s *Partitioning_storage_clauseContext) AllSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORE) +} + +func (s *Partitioning_storage_clauseContext) STORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, i) +} + +func (s *Partitioning_storage_clauseContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Partitioning_storage_clauseContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Partitioning_storage_clauseContext) AllLOB() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOB) +} + +func (s *Partitioning_storage_clauseContext) LOB(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, i) +} + +func (s *Partitioning_storage_clauseContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Partitioning_storage_clauseContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Partitioning_storage_clauseContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Partitioning_storage_clauseContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Partitioning_storage_clauseContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Partitioning_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partitioning_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partitioning_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartitioning_storage_clause(s) + } +} + +func (s *Partitioning_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartitioning_storage_clause(s) + } +} + +func (p *PlSqlParser) Partitioning_storage_clause() (localctx IPartitioning_storage_clauseContext) { + localctx = NewPartitioning_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1172, PlSqlParserRULE_partitioning_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + p.SetState(11750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1452, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11729) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11730) + p.Tablespace() + } + + case 2: + { + p.SetState(11731) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11734) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1450, p.GetParserRuleContext()) == 1 { + { + p.SetState(11732) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11733) + p.Tablespace() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(11736) + p.Table_compression() + } + + case 4: + { + p.SetState(11737) + p.Key_compression() + } + + case 5: + { + p.SetState(11738) + p.Inmemory_table_clause() + } + + case 6: + { + p.SetState(11739) + p.Lob_partitioning_storage() + } + + case 7: + { + p.SetState(11740) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11741) + p.Varray_item() + } + { + p.SetState(11742) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11743) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(11744) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(11747) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11748) + p.Lob_segname() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(11752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_partitioning_storageContext is an interface to support dynamic dispatch. +type ILob_partitioning_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Lob_item() ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + Lob_segname() ILob_segnameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + BASICFILE() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + + // IsLob_partitioning_storageContext differentiates from other interfaces. + IsLob_partitioning_storageContext() +} + +type Lob_partitioning_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_partitioning_storageContext() *Lob_partitioning_storageContext { + var p = new(Lob_partitioning_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage + return p +} + +func InitEmptyLob_partitioning_storageContext(p *Lob_partitioning_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage +} + +func (*Lob_partitioning_storageContext) IsLob_partitioning_storageContext() {} + +func NewLob_partitioning_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_partitioning_storageContext { + var p = new(Lob_partitioning_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage + + return p +} + +func (s *Lob_partitioning_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_partitioning_storageContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_partitioning_storageContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_partitioning_storageContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_partitioning_storageContext) Lob_item() ILob_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_partitioning_storageContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_partitioning_storageContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_partitioning_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_partitioning_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_partitioning_storageContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_partitioning_storageContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Lob_partitioning_storageContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Lob_partitioning_storageContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Lob_partitioning_storageContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Lob_partitioning_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_partitioning_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_partitioning_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_partitioning_storage(s) + } +} + +func (s *Lob_partitioning_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_partitioning_storage(s) + } +} + +func (p *PlSqlParser) Lob_partitioning_storage() (localctx ILob_partitioning_storageContext) { + localctx = NewLob_partitioning_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1174, PlSqlParserRULE_lob_partitioning_storage) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11754) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11755) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11756) + p.Lob_item() + } + { + p.SetState(11757) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11758) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11759) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1454, p.GetParserRuleContext()) == 1 { + { + p.SetState(11760) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(11763) + p.Lob_segname() + } + p.SetState(11769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11764) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11765) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11766) + p.Tablespace() + } + { + p.SetState(11767) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(11771) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11772) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11773) + p.Tablespace() + } + { + p.SetState(11774) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISize_clauseContext is an interface to support dynamic dispatch. +type ISize_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + + // IsSize_clauseContext differentiates from other interfaces. + IsSize_clauseContext() +} + +type Size_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySize_clauseContext() *Size_clauseContext { + var p = new(Size_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_size_clause + return p +} + +func InitEmptySize_clauseContext(p *Size_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_size_clause +} + +func (*Size_clauseContext) IsSize_clauseContext() {} + +func NewSize_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Size_clauseContext { + var p = new(Size_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_size_clause + + return p +} + +func (s *Size_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Size_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Size_clauseContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Size_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Size_clauseContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Size_clauseContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Size_clauseContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Size_clauseContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Size_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Size_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Size_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSize_clause(s) + } +} + +func (s *Size_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSize_clause(s) + } +} + +func (p *PlSqlParser) Size_clause() (localctx ISize_clauseContext) { + localctx = NewSize_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1176, PlSqlParserRULE_size_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11778) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserE_LETTER || _la == PlSqlParserG_LETTER || _la == PlSqlParserK_LETTER || _la == PlSqlParserM_LETTER || _la == PlSqlParserP_LETTER || _la == PlSqlParserT_LETTER { + { + p.SetState(11779) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserE_LETTER || _la == PlSqlParserG_LETTER || _la == PlSqlParserK_LETTER || _la == PlSqlParserM_LETTER || _la == PlSqlParserP_LETTER || _la == PlSqlParserT_LETTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_compressionContext is an interface to support dynamic dispatch. +type ITable_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPRESS() antlr.TerminalNode + BASIC() antlr.TerminalNode + FOR() antlr.TerminalNode + OLTP() antlr.TerminalNode + ALL() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + DIRECT_LOAD() antlr.TerminalNode + QUERY() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + ROW() antlr.TerminalNode + STORE() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + COLUMN() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LOCKING() antlr.TerminalNode + NO() antlr.TerminalNode + NOCOMPRESS() antlr.TerminalNode + + // IsTable_compressionContext differentiates from other interfaces. + IsTable_compressionContext() +} + +type Table_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_compressionContext() *Table_compressionContext { + var p = new(Table_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_compression + return p +} + +func InitEmptyTable_compressionContext(p *Table_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_compression +} + +func (*Table_compressionContext) IsTable_compressionContext() {} + +func NewTable_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_compressionContext { + var p = new(Table_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_compression + + return p +} + +func (s *Table_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Table_compressionContext) BASIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASIC, 0) +} + +func (s *Table_compressionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Table_compressionContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Table_compressionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Table_compressionContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATIONS, 0) +} + +func (s *Table_compressionContext) DIRECT_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_LOAD, 0) +} + +func (s *Table_compressionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Table_compressionContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Table_compressionContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Table_compressionContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Table_compressionContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Table_compressionContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Table_compressionContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Table_compressionContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Table_compressionContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Table_compressionContext) LOCKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKING, 0) +} + +func (s *Table_compressionContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Table_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Table_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_compression(s) + } +} + +func (s *Table_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_compression(s) + } +} + +func (p *PlSqlParser) Table_compression() (localctx ITable_compressionContext) { + localctx = NewTable_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1178, PlSqlParserRULE_table_compression) + var _la int + + p.SetState(11823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11782) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11796) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1460, p.GetParserRuleContext()) == 1 { + { + p.SetState(11783) + p.Match(PlSqlParserBASIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1460, p.GetParserRuleContext()) == 2 { + { + p.SetState(11784) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOLTP: + { + p.SetState(11785) + p.Match(PlSqlParserOLTP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARCHIVE, PlSqlParserQUERY: + { + p.SetState(11786) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserARCHIVE || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11788) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1458, p.GetParserRuleContext()) == 1 { + { + p.SetState(11787) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserALL: + { + p.SetState(11790) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11791) + p.Match(PlSqlParserOPERATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDIRECT_LOAD: + { + p.SetState(11792) + p.Match(PlSqlParserDIRECT_LOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11793) + p.Match(PlSqlParserOPERATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserROW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11798) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11799) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11800) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11802) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1461, p.GetParserRuleContext()) == 1 { + { + p.SetState(11801) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADVANCED || _la == PlSqlParserBASIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCOLUMN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11804) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11805) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11806) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11812) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1463, p.GetParserRuleContext()) == 1 { + { + p.SetState(11807) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11808) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserARCHIVE || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11810) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1462, p.GetParserRuleContext()) == 1 { + { + p.SetState(11809) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11820) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1465, p.GetParserRuleContext()) == 1 { + p.SetState(11815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(11814) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11817) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11818) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11819) + p.Match(PlSqlParserLOCKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11822) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_table_clauseContext is an interface to support dynamic dispatch. +type IInmemory_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllInmemory_column_clause() []IInmemory_column_clauseContext + Inmemory_column_clause(i int) IInmemory_column_clauseContext + INMEMORY() antlr.TerminalNode + NO() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + + // IsInmemory_table_clauseContext differentiates from other interfaces. + IsInmemory_table_clauseContext() +} + +type Inmemory_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_table_clauseContext() *Inmemory_table_clauseContext { + var p = new(Inmemory_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause + return p +} + +func InitEmptyInmemory_table_clauseContext(p *Inmemory_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause +} + +func (*Inmemory_table_clauseContext) IsInmemory_table_clauseContext() {} + +func NewInmemory_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_table_clauseContext { + var p = new(Inmemory_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause + + return p +} + +func (s *Inmemory_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_table_clauseContext) AllInmemory_column_clause() []IInmemory_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_column_clauseContext); ok { + len++ + } + } + + tst := make([]IInmemory_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_column_clauseContext); ok { + tst[i] = t.(IInmemory_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_table_clauseContext) Inmemory_column_clause(i int) IInmemory_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_column_clauseContext) +} + +func (s *Inmemory_table_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmemory_table_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_table_clauseContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Inmemory_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_table_clause(s) + } +} + +func (s *Inmemory_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_table_clause(s) + } +} + +func (p *PlSqlParser) Inmemory_table_clause() (localctx IInmemory_table_clauseContext) { + localctx = NewInmemory_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1180, PlSqlParserRULE_inmemory_table_clause) + var _alt int + + p.SetState(11844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1471, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(11825) + p.Inmemory_column_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11828) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1467, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + { + p.SetState(11830) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11832) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1468, p.GetParserRuleContext()) == 1 { + { + p.SetState(11831) + p.Inmemory_attributes() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + { + p.SetState(11834) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11835) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1470, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11838) + p.Inmemory_column_clause() + } + + } + p.SetState(11843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1470, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_attributesContext is an interface to support dynamic dispatch. +type IInmemory_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllInmemory_memcompress() []IInmemory_memcompressContext + Inmemory_memcompress(i int) IInmemory_memcompressContext + AllInmemory_priority() []IInmemory_priorityContext + Inmemory_priority(i int) IInmemory_priorityContext + AllInmemory_distribute() []IInmemory_distributeContext + Inmemory_distribute(i int) IInmemory_distributeContext + AllInmemory_duplicate() []IInmemory_duplicateContext + Inmemory_duplicate(i int) IInmemory_duplicateContext + + // IsInmemory_attributesContext differentiates from other interfaces. + IsInmemory_attributesContext() +} + +type Inmemory_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_attributesContext() *Inmemory_attributesContext { + var p = new(Inmemory_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_attributes + return p +} + +func InitEmptyInmemory_attributesContext(p *Inmemory_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_attributes +} + +func (*Inmemory_attributesContext) IsInmemory_attributesContext() {} + +func NewInmemory_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_attributesContext { + var p = new(Inmemory_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_attributes + + return p +} + +func (s *Inmemory_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_attributesContext) AllInmemory_memcompress() []IInmemory_memcompressContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + len++ + } + } + + tst := make([]IInmemory_memcompressContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_memcompressContext); ok { + tst[i] = t.(IInmemory_memcompressContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_attributesContext) Inmemory_memcompress(i int) IInmemory_memcompressContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Inmemory_attributesContext) AllInmemory_priority() []IInmemory_priorityContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_priorityContext); ok { + len++ + } + } + + tst := make([]IInmemory_priorityContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_priorityContext); ok { + tst[i] = t.(IInmemory_priorityContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_attributesContext) Inmemory_priority(i int) IInmemory_priorityContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_priorityContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_priorityContext) +} + +func (s *Inmemory_attributesContext) AllInmemory_distribute() []IInmemory_distributeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_distributeContext); ok { + len++ + } + } + + tst := make([]IInmemory_distributeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_distributeContext); ok { + tst[i] = t.(IInmemory_distributeContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_attributesContext) Inmemory_distribute(i int) IInmemory_distributeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_distributeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_distributeContext) +} + +func (s *Inmemory_attributesContext) AllInmemory_duplicate() []IInmemory_duplicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_duplicateContext); ok { + len++ + } + } + + tst := make([]IInmemory_duplicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_duplicateContext); ok { + tst[i] = t.(IInmemory_duplicateContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_attributesContext) Inmemory_duplicate(i int) IInmemory_duplicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_duplicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_duplicateContext) +} + +func (s *Inmemory_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_attributes(s) + } +} + +func (s *Inmemory_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_attributes(s) + } +} + +func (p *PlSqlParser) Inmemory_attributes() (localctx IInmemory_attributesContext) { + localctx = NewInmemory_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1182, PlSqlParserRULE_inmemory_attributes) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(11850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1472, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11846) + p.Inmemory_memcompress() + } + + case 2: + { + p.SetState(11847) + p.Inmemory_priority() + } + + case 3: + { + p.SetState(11848) + p.Inmemory_distribute() + } + + case 4: + { + p.SetState(11849) + p.Inmemory_duplicate() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11852) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_memcompressContext is an interface to support dynamic dispatch. +type IInmemory_memcompressContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMCOMPRESS() antlr.TerminalNode + FOR() antlr.TerminalNode + DML() antlr.TerminalNode + QUERY() antlr.TerminalNode + CAPACITY() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmemory_memcompressContext differentiates from other interfaces. + IsInmemory_memcompressContext() +} + +type Inmemory_memcompressContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_memcompressContext() *Inmemory_memcompressContext { + var p = new(Inmemory_memcompressContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress + return p +} + +func InitEmptyInmemory_memcompressContext(p *Inmemory_memcompressContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress +} + +func (*Inmemory_memcompressContext) IsInmemory_memcompressContext() {} + +func NewInmemory_memcompressContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_memcompressContext { + var p = new(Inmemory_memcompressContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress + + return p +} + +func (s *Inmemory_memcompressContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_memcompressContext) MEMCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMCOMPRESS, 0) +} + +func (s *Inmemory_memcompressContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Inmemory_memcompressContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Inmemory_memcompressContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Inmemory_memcompressContext) CAPACITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPACITY, 0) +} + +func (s *Inmemory_memcompressContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Inmemory_memcompressContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Inmemory_memcompressContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_memcompressContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_memcompressContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_memcompressContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_memcompress(s) + } +} + +func (s *Inmemory_memcompressContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_memcompress(s) + } +} + +func (p *PlSqlParser) Inmemory_memcompress() (localctx IInmemory_memcompressContext) { + localctx = NewInmemory_memcompressContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1184, PlSqlParserRULE_inmemory_memcompress) + var _la int + + p.SetState(11865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMEMCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11854) + p.Match(PlSqlParserMEMCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11855) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDML: + { + p.SetState(11856) + p.Match(PlSqlParserDML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCAPACITY, PlSqlParserQUERY: + { + p.SetState(11857) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCAPACITY || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIGH || _la == PlSqlParserLOW { + { + p.SetState(11858) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11863) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11864) + p.Match(PlSqlParserMEMCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_priorityContext is an interface to support dynamic dispatch. +type IInmemory_priorityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIORITY() antlr.TerminalNode + NONE() antlr.TerminalNode + LOW() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + HIGH() antlr.TerminalNode + CRITICAL() antlr.TerminalNode + + // IsInmemory_priorityContext differentiates from other interfaces. + IsInmemory_priorityContext() +} + +type Inmemory_priorityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_priorityContext() *Inmemory_priorityContext { + var p = new(Inmemory_priorityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_priority + return p +} + +func InitEmptyInmemory_priorityContext(p *Inmemory_priorityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_priority +} + +func (*Inmemory_priorityContext) IsInmemory_priorityContext() {} + +func NewInmemory_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_priorityContext { + var p = new(Inmemory_priorityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_priority + + return p +} + +func (s *Inmemory_priorityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_priorityContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIORITY, 0) +} + +func (s *Inmemory_priorityContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Inmemory_priorityContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Inmemory_priorityContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Inmemory_priorityContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Inmemory_priorityContext) CRITICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRITICAL, 0) +} + +func (s *Inmemory_priorityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_priorityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_priorityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_priority(s) + } +} + +func (s *Inmemory_priorityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_priority(s) + } +} + +func (p *PlSqlParser) Inmemory_priority() (localctx IInmemory_priorityContext) { + localctx = NewInmemory_priorityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1186, PlSqlParserRULE_inmemory_priority) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11867) + p.Match(PlSqlParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11868) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCRITICAL || _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_distributeContext is an interface to support dynamic dispatch. +type IInmemory_distributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISTRIBUTE() antlr.TerminalNode + AUTO() antlr.TerminalNode + BY() antlr.TerminalNode + FOR() antlr.TerminalNode + SERVICE() antlr.TerminalNode + ROWID() antlr.TerminalNode + RANGE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ALL() antlr.TerminalNode + Identifier() IIdentifierContext + NONE() antlr.TerminalNode + + // IsInmemory_distributeContext differentiates from other interfaces. + IsInmemory_distributeContext() +} + +type Inmemory_distributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_distributeContext() *Inmemory_distributeContext { + var p = new(Inmemory_distributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_distribute + return p +} + +func InitEmptyInmemory_distributeContext(p *Inmemory_distributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_distribute +} + +func (*Inmemory_distributeContext) IsInmemory_distributeContext() {} + +func NewInmemory_distributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_distributeContext { + var p = new(Inmemory_distributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_distribute + + return p +} + +func (s *Inmemory_distributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_distributeContext) DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTE, 0) +} + +func (s *Inmemory_distributeContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Inmemory_distributeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Inmemory_distributeContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Inmemory_distributeContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Inmemory_distributeContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Inmemory_distributeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Inmemory_distributeContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Inmemory_distributeContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Inmemory_distributeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Inmemory_distributeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Inmemory_distributeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Inmemory_distributeContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Inmemory_distributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_distributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_distributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_distribute(s) + } +} + +func (s *Inmemory_distributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_distribute(s) + } +} + +func (p *PlSqlParser) Inmemory_distribute() (localctx IInmemory_distributeContext) { + localctx = NewInmemory_distributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1188, PlSqlParserRULE_inmemory_distribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11870) + p.Match(PlSqlParserDISTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserAUTO: + { + p.SetState(11871) + p.Match(PlSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBY: + { + p.SetState(11872) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserROWID: + { + p.SetState(11873) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11874) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARTITION: + { + p.SetState(11875) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(11876) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserEOF, PlSqlParserADD, PlSqlParserAFTER, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserANNOTATIONS, PlSqlParserAS, PlSqlParserBLOCKSIZE, PlSqlParserBUILD, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCLUSTERING, PlSqlParserCOALESCE, PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserCREATE, PlSqlParserDEALLOCATE, PlSqlParserDEFAULT, PlSqlParserDISABLE, PlSqlParserDISALLOW, PlSqlParserDISTRIBUTE, PlSqlParserDROP, PlSqlParserDUPLICATE, PlSqlParserENABLE, PlSqlParserENCRYPTION, PlSqlParserEVALUATE, PlSqlParserEXTENT, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFLASHBACK, PlSqlParserFORCE, PlSqlParserFOR, PlSqlParserGRANT, PlSqlParserILM, PlSqlParserINCLUDING, PlSqlParserINDEXING, PlSqlParserINITRANS, PlSqlParserINMEMORY, PlSqlParserINVALIDATE, PlSqlParserLOB, PlSqlParserLOGGING, PlSqlParserMAPPING, PlSqlParserMAXTRANS, PlSqlParserMEMCOMPRESS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMONITORING, PlSqlParserNESTED, PlSqlParserNEVER, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMINIMIZE, PlSqlParserNOMONITORING, PlSqlParserNO, PlSqlParserNOPARALLEL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserOFFLINE, PlSqlParserONLINE, PlSqlParserON, PlSqlParserORGANIZATION, PlSqlParserOVERFLOW_, PlSqlParserPARALLEL, PlSqlParserPARENT, PlSqlParserPARTITION, PlSqlParserPCTFREE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPRIORITY, PlSqlParserREAD, PlSqlParserREBUILD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserREFRESH, PlSqlParserREJECT, PlSqlParserREMOVE, PlSqlParserRESULT_CACHE, PlSqlParserROWDEPENDENCIES, PlSqlParserROW, PlSqlParserSEGMENT, PlSqlParserSHRINK, PlSqlParserSTORAGE, PlSqlParserSUBPARTITIONS, PlSqlParserSUSPEND, PlSqlParserTABLESPACE, PlSqlParserTEXT, PlSqlParserUNUSABLE, PlSqlParserUPDATE, PlSqlParserUPGRADE, PlSqlParserUSAGE, PlSqlParserUSING, PlSqlParserVARRAY, PlSqlParserXMLTYPE, PlSqlParserMEMOPTIMIZE, PlSqlParserLEFT_PAREN, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(11889) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1480, p.GetParserRuleContext()) == 1 { + { + p.SetState(11881) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11882) + p.Match(PlSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1479, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11883) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11884) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11885) + p.Identifier() + } + + case 4: + { + p.SetState(11886) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_duplicateContext is an interface to support dynamic dispatch. +type IInmemory_duplicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DUPLICATE() antlr.TerminalNode + ALL() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmemory_duplicateContext differentiates from other interfaces. + IsInmemory_duplicateContext() +} + +type Inmemory_duplicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_duplicateContext() *Inmemory_duplicateContext { + var p = new(Inmemory_duplicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate + return p +} + +func InitEmptyInmemory_duplicateContext(p *Inmemory_duplicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate +} + +func (*Inmemory_duplicateContext) IsInmemory_duplicateContext() {} + +func NewInmemory_duplicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_duplicateContext { + var p = new(Inmemory_duplicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate + + return p +} + +func (s *Inmemory_duplicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_duplicateContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATE, 0) +} + +func (s *Inmemory_duplicateContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Inmemory_duplicateContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_duplicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_duplicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_duplicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_duplicate(s) + } +} + +func (s *Inmemory_duplicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_duplicate(s) + } +} + +func (p *PlSqlParser) Inmemory_duplicate() (localctx IInmemory_duplicateContext) { + localctx = NewInmemory_duplicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1190, PlSqlParserRULE_inmemory_duplicate) + var _la int + + p.SetState(11897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDUPLICATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11891) + p.Match(PlSqlParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(11892) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11895) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11896) + p.Match(PlSqlParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_column_clauseContext is an interface to support dynamic dispatch. +type IInmemory_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + NO() antlr.TerminalNode + Inmemory_memcompress() IInmemory_memcompressContext + + // IsInmemory_column_clauseContext differentiates from other interfaces. + IsInmemory_column_clauseContext() +} + +type Inmemory_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_column_clauseContext() *Inmemory_column_clauseContext { + var p = new(Inmemory_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause + return p +} + +func InitEmptyInmemory_column_clauseContext(p *Inmemory_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause +} + +func (*Inmemory_column_clauseContext) IsInmemory_column_clauseContext() {} + +func NewInmemory_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_column_clauseContext { + var p = new(Inmemory_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause + + return p +} + +func (s *Inmemory_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Inmemory_column_clauseContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Inmemory_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Inmemory_column_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmemory_column_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_column_clauseContext) Inmemory_memcompress() IInmemory_memcompressContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Inmemory_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_column_clause(s) + } +} + +func (s *Inmemory_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_column_clause(s) + } +} + +func (p *PlSqlParser) Inmemory_column_clause() (localctx IInmemory_column_clauseContext) { + localctx = NewInmemory_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1192, PlSqlParserRULE_inmemory_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + { + p.SetState(11899) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMCOMPRESS || _la == PlSqlParserNO { + { + p.SetState(11900) + p.Inmemory_memcompress() + } + + } + + case PlSqlParserNO: + { + p.SetState(11903) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11904) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11907) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11908) + p.Column_list() + } + { + p.SetState(11909) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPhysical_attributes_clauseContext is an interface to support dynamic dispatch. +type IPhysical_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPctfree returns the pctfree token. + GetPctfree() antlr.Token + + // GetPctused returns the pctused token. + GetPctused() antlr.Token + + // GetInittrans returns the inittrans token. + GetInittrans() antlr.Token + + // GetMaxtrans returns the maxtrans token. + GetMaxtrans() antlr.Token + + // SetPctfree sets the pctfree token. + SetPctfree(antlr.Token) + + // SetPctused sets the pctused token. + SetPctused(antlr.Token) + + // SetInittrans sets the inittrans token. + SetInittrans(antlr.Token) + + // SetMaxtrans sets the maxtrans token. + SetMaxtrans(antlr.Token) + + // Getter signatures + AllPCTFREE() []antlr.TerminalNode + PCTFREE(i int) antlr.TerminalNode + AllPCTUSED() []antlr.TerminalNode + PCTUSED(i int) antlr.TerminalNode + AllINITRANS() []antlr.TerminalNode + INITRANS(i int) antlr.TerminalNode + AllMAXTRANS() []antlr.TerminalNode + MAXTRANS(i int) antlr.TerminalNode + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + AllCompute_clauses() []ICompute_clausesContext + Compute_clauses(i int) ICompute_clausesContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + + // IsPhysical_attributes_clauseContext differentiates from other interfaces. + IsPhysical_attributes_clauseContext() +} + +type Physical_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pctfree antlr.Token + pctused antlr.Token + inittrans antlr.Token + maxtrans antlr.Token +} + +func NewEmptyPhysical_attributes_clauseContext() *Physical_attributes_clauseContext { + var p = new(Physical_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause + return p +} + +func InitEmptyPhysical_attributes_clauseContext(p *Physical_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause +} + +func (*Physical_attributes_clauseContext) IsPhysical_attributes_clauseContext() {} + +func NewPhysical_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Physical_attributes_clauseContext { + var p = new(Physical_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause + + return p +} + +func (s *Physical_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Physical_attributes_clauseContext) GetPctfree() antlr.Token { return s.pctfree } + +func (s *Physical_attributes_clauseContext) GetPctused() antlr.Token { return s.pctused } + +func (s *Physical_attributes_clauseContext) GetInittrans() antlr.Token { return s.inittrans } + +func (s *Physical_attributes_clauseContext) GetMaxtrans() antlr.Token { return s.maxtrans } + +func (s *Physical_attributes_clauseContext) SetPctfree(v antlr.Token) { s.pctfree = v } + +func (s *Physical_attributes_clauseContext) SetPctused(v antlr.Token) { s.pctused = v } + +func (s *Physical_attributes_clauseContext) SetInittrans(v antlr.Token) { s.inittrans = v } + +func (s *Physical_attributes_clauseContext) SetMaxtrans(v antlr.Token) { s.maxtrans = v } + +func (s *Physical_attributes_clauseContext) AllPCTFREE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTFREE) +} + +func (s *Physical_attributes_clauseContext) PCTFREE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTFREE, i) +} + +func (s *Physical_attributes_clauseContext) AllPCTUSED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTUSED) +} + +func (s *Physical_attributes_clauseContext) PCTUSED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, i) +} + +func (s *Physical_attributes_clauseContext) AllINITRANS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITRANS) +} + +func (s *Physical_attributes_clauseContext) INITRANS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITRANS, i) +} + +func (s *Physical_attributes_clauseContext) AllMAXTRANS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXTRANS) +} + +func (s *Physical_attributes_clauseContext) MAXTRANS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXTRANS, i) +} + +func (s *Physical_attributes_clauseContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Physical_attributes_clauseContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Physical_attributes_clauseContext) AllCompute_clauses() []ICompute_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompute_clausesContext); ok { + len++ + } + } + + tst := make([]ICompute_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompute_clausesContext); ok { + tst[i] = t.(ICompute_clausesContext) + i++ + } + } + + return tst +} + +func (s *Physical_attributes_clauseContext) Compute_clauses(i int) ICompute_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompute_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompute_clausesContext) +} + +func (s *Physical_attributes_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Physical_attributes_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Physical_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Physical_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Physical_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhysical_attributes_clause(s) + } +} + +func (s *Physical_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhysical_attributes_clause(s) + } +} + +func (p *PlSqlParser) Physical_attributes_clause() (localctx IPhysical_attributes_clauseContext) { + localctx = NewPhysical_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1194, PlSqlParserRULE_physical_attributes_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(11921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPCTFREE: + { + p.SetState(11911) + p.Match(PlSqlParserPCTFREE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11912) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).pctfree = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPCTUSED: + { + p.SetState(11913) + p.Match(PlSqlParserPCTUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11914) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).pctused = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINITRANS: + { + p.SetState(11915) + p.Match(PlSqlParserINITRANS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11916) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).inittrans = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXTRANS: + { + p.SetState(11917) + p.Match(PlSqlParserMAXTRANS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11918) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).maxtrans = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTORAGE: + { + p.SetState(11919) + p.Storage_clause() + } + + case PlSqlParserCOMPUTE: + { + p.SetState(11920) + p.Compute_clauses() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11923) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1486, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStorage_clauseContext is an interface to support dynamic dispatch. +type IStorage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMinextents returns the minextents token. + GetMinextents() antlr.Token + + // GetPctincrease returns the pctincrease token. + GetPctincrease() antlr.Token + + // GetFreelists returns the freelists token. + GetFreelists() antlr.Token + + // GetFreelist_groups returns the freelist_groups token. + GetFreelist_groups() antlr.Token + + // SetMinextents sets the minextents token. + SetMinextents(antlr.Token) + + // SetPctincrease sets the pctincrease token. + SetPctincrease(antlr.Token) + + // SetFreelists sets the freelists token. + SetFreelists(antlr.Token) + + // SetFreelist_groups sets the freelist_groups token. + SetFreelist_groups(antlr.Token) + + // GetInitial_size returns the initial_size rule contexts. + GetInitial_size() ISize_clauseContext + + // GetNext_size returns the next_size rule contexts. + GetNext_size() ISize_clauseContext + + // SetInitial_size sets the initial_size rule contexts. + SetInitial_size(ISize_clauseContext) + + // SetNext_size sets the next_size rule contexts. + SetNext_size(ISize_clauseContext) + + // Getter signatures + STORAGE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllINITIAL() []antlr.TerminalNode + INITIAL(i int) antlr.TerminalNode + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllMINEXTENTS() []antlr.TerminalNode + MINEXTENTS(i int) antlr.TerminalNode + AllMAXEXTENTS() []antlr.TerminalNode + MAXEXTENTS(i int) antlr.TerminalNode + AllPCTINCREASE() []antlr.TerminalNode + PCTINCREASE(i int) antlr.TerminalNode + AllFREELISTS() []antlr.TerminalNode + FREELISTS(i int) antlr.TerminalNode + AllFREELIST() []antlr.TerminalNode + FREELIST(i int) antlr.TerminalNode + AllGROUPS() []antlr.TerminalNode + GROUPS(i int) antlr.TerminalNode + AllOPTIMAL() []antlr.TerminalNode + OPTIMAL(i int) antlr.TerminalNode + AllBUFFER_POOL() []antlr.TerminalNode + BUFFER_POOL(i int) antlr.TerminalNode + AllFLASH_CACHE() []antlr.TerminalNode + FLASH_CACHE(i int) antlr.TerminalNode + AllCELL_FLASH_CACHE() []antlr.TerminalNode + CELL_FLASH_CACHE(i int) antlr.TerminalNode + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllKEEP() []antlr.TerminalNode + KEEP(i int) antlr.TerminalNode + AllRECYCLE() []antlr.TerminalNode + RECYCLE(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllUNLIMITED() []antlr.TerminalNode + UNLIMITED(i int) antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + + // IsStorage_clauseContext differentiates from other interfaces. + IsStorage_clauseContext() +} + +type Storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + initial_size ISize_clauseContext + next_size ISize_clauseContext + minextents antlr.Token + pctincrease antlr.Token + freelists antlr.Token + freelist_groups antlr.Token +} + +func NewEmptyStorage_clauseContext() *Storage_clauseContext { + var p = new(Storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_clause + return p +} + +func InitEmptyStorage_clauseContext(p *Storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_clause +} + +func (*Storage_clauseContext) IsStorage_clauseContext() {} + +func NewStorage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Storage_clauseContext { + var p = new(Storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_storage_clause + + return p +} + +func (s *Storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Storage_clauseContext) GetMinextents() antlr.Token { return s.minextents } + +func (s *Storage_clauseContext) GetPctincrease() antlr.Token { return s.pctincrease } + +func (s *Storage_clauseContext) GetFreelists() antlr.Token { return s.freelists } + +func (s *Storage_clauseContext) GetFreelist_groups() antlr.Token { return s.freelist_groups } + +func (s *Storage_clauseContext) SetMinextents(v antlr.Token) { s.minextents = v } + +func (s *Storage_clauseContext) SetPctincrease(v antlr.Token) { s.pctincrease = v } + +func (s *Storage_clauseContext) SetFreelists(v antlr.Token) { s.freelists = v } + +func (s *Storage_clauseContext) SetFreelist_groups(v antlr.Token) { s.freelist_groups = v } + +func (s *Storage_clauseContext) GetInitial_size() ISize_clauseContext { return s.initial_size } + +func (s *Storage_clauseContext) GetNext_size() ISize_clauseContext { return s.next_size } + +func (s *Storage_clauseContext) SetInitial_size(v ISize_clauseContext) { s.initial_size = v } + +func (s *Storage_clauseContext) SetNext_size(v ISize_clauseContext) { s.next_size = v } + +func (s *Storage_clauseContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Storage_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Storage_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Storage_clauseContext) AllINITIAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITIAL) +} + +func (s *Storage_clauseContext) INITIAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, i) +} + +func (s *Storage_clauseContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Storage_clauseContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Storage_clauseContext) AllMINEXTENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINEXTENTS) +} + +func (s *Storage_clauseContext) MINEXTENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINEXTENTS, i) +} + +func (s *Storage_clauseContext) AllMAXEXTENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXEXTENTS) +} + +func (s *Storage_clauseContext) MAXEXTENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXEXTENTS, i) +} + +func (s *Storage_clauseContext) AllPCTINCREASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTINCREASE) +} + +func (s *Storage_clauseContext) PCTINCREASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTINCREASE, i) +} + +func (s *Storage_clauseContext) AllFREELISTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREELISTS) +} + +func (s *Storage_clauseContext) FREELISTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELISTS, i) +} + +func (s *Storage_clauseContext) AllFREELIST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREELIST) +} + +func (s *Storage_clauseContext) FREELIST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELIST, i) +} + +func (s *Storage_clauseContext) AllGROUPS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUPS) +} + +func (s *Storage_clauseContext) GROUPS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPS, i) +} + +func (s *Storage_clauseContext) AllOPTIMAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOPTIMAL) +} + +func (s *Storage_clauseContext) OPTIMAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMAL, i) +} + +func (s *Storage_clauseContext) AllBUFFER_POOL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBUFFER_POOL) +} + +func (s *Storage_clauseContext) BUFFER_POOL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_POOL, i) +} + +func (s *Storage_clauseContext) AllFLASH_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFLASH_CACHE) +} + +func (s *Storage_clauseContext) FLASH_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASH_CACHE, i) +} + +func (s *Storage_clauseContext) AllCELL_FLASH_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCELL_FLASH_CACHE) +} + +func (s *Storage_clauseContext) CELL_FLASH_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCELL_FLASH_CACHE, i) +} + +func (s *Storage_clauseContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Storage_clauseContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Storage_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Storage_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Storage_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Storage_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Storage_clauseContext) AllKEEP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEEP) +} + +func (s *Storage_clauseContext) KEEP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, i) +} + +func (s *Storage_clauseContext) AllRECYCLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRECYCLE) +} + +func (s *Storage_clauseContext) RECYCLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLE, i) +} + +func (s *Storage_clauseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Storage_clauseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Storage_clauseContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNONE) +} + +func (s *Storage_clauseContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, i) +} + +func (s *Storage_clauseContext) AllUNLIMITED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNLIMITED) +} + +func (s *Storage_clauseContext) UNLIMITED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, i) +} + +func (s *Storage_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Storage_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStorage_clause(s) + } +} + +func (s *Storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStorage_clause(s) + } +} + +func (p *PlSqlParser) Storage_clause() (localctx IStorage_clauseContext) { + localctx = NewStorage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1196, PlSqlParserRULE_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11925) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11926) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBUFFER_POOL || _la == PlSqlParserCELL_FLASH_CACHE || _la == PlSqlParserENCRYPT || ((int64((_la-606)) & ^0x3f) == 0 && ((int64(1)<<(_la-606))&786433) != 0) || _la == PlSqlParserINITIAL || _la == PlSqlParserMAXEXTENTS || _la == PlSqlParserMINEXTENTS || _la == PlSqlParserNEXT || _la == PlSqlParserOPTIMAL || _la == PlSqlParserPCTINCREASE { + p.SetState(11954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINITIAL: + { + p.SetState(11927) + p.Match(PlSqlParserINITIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11928) + + var _x = p.Size_clause() + + localctx.(*Storage_clauseContext).initial_size = _x + } + + case PlSqlParserNEXT: + { + p.SetState(11929) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11930) + + var _x = p.Size_clause() + + localctx.(*Storage_clauseContext).next_size = _x + } + + case PlSqlParserMINEXTENTS: + { + p.SetState(11931) + p.Match(PlSqlParserMINEXTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11932) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Storage_clauseContext).minextents = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Storage_clauseContext).minextents = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserMAXEXTENTS: + { + p.SetState(11933) + p.Match(PlSqlParserMAXEXTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11934) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Storage_clauseContext).minextents = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Storage_clauseContext).minextents = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPCTINCREASE: + { + p.SetState(11935) + p.Match(PlSqlParserPCTINCREASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11936) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).pctincrease = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREELISTS: + { + p.SetState(11937) + p.Match(PlSqlParserFREELISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11938) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).freelists = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREELIST: + { + p.SetState(11939) + p.Match(PlSqlParserFREELIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11940) + p.Match(PlSqlParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11941) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).freelist_groups = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOPTIMAL: + { + p.SetState(11942) + p.Match(PlSqlParserOPTIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(11943) + p.Size_clause() + } + + case PlSqlParserNULL_: + { + p.SetState(11944) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserBUFFER_POOL: + { + p.SetState(11947) + p.Match(PlSqlParserBUFFER_POOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11948) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserRECYCLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserFLASH_CACHE: + { + p.SetState(11949) + p.Match(PlSqlParserFLASH_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11950) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserCELL_FLASH_CACHE: + { + p.SetState(11951) + p.Match(PlSqlParserCELL_FLASH_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11952) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserENCRYPT: + { + p.SetState(11953) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11958) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeferred_segment_creationContext is an interface to support dynamic dispatch. +type IDeferred_segment_creationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + CREATION() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + + // IsDeferred_segment_creationContext differentiates from other interfaces. + IsDeferred_segment_creationContext() +} + +type Deferred_segment_creationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeferred_segment_creationContext() *Deferred_segment_creationContext { + var p = new(Deferred_segment_creationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation + return p +} + +func InitEmptyDeferred_segment_creationContext(p *Deferred_segment_creationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation +} + +func (*Deferred_segment_creationContext) IsDeferred_segment_creationContext() {} + +func NewDeferred_segment_creationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Deferred_segment_creationContext { + var p = new(Deferred_segment_creationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation + + return p +} + +func (s *Deferred_segment_creationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Deferred_segment_creationContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Deferred_segment_creationContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Deferred_segment_creationContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Deferred_segment_creationContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Deferred_segment_creationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Deferred_segment_creationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Deferred_segment_creationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeferred_segment_creation(s) + } +} + +func (s *Deferred_segment_creationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeferred_segment_creation(s) + } +} + +func (p *PlSqlParser) Deferred_segment_creation() (localctx IDeferred_segment_creationContext) { + localctx = NewDeferred_segment_creationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1198, PlSqlParserRULE_deferred_segment_creation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11960) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11961) + p.Match(PlSqlParserCREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11962) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISegment_attributes_clauseContext is an interface to support dynamic dispatch. +type ISegment_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + + // IsSegment_attributes_clauseContext differentiates from other interfaces. + IsSegment_attributes_clauseContext() +} + +type Segment_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptySegment_attributes_clauseContext() *Segment_attributes_clauseContext { + var p = new(Segment_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause + return p +} + +func InitEmptySegment_attributes_clauseContext(p *Segment_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause +} + +func (*Segment_attributes_clauseContext) IsSegment_attributes_clauseContext() {} + +func NewSegment_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_attributes_clauseContext { + var p = new(Segment_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause + + return p +} + +func (s *Segment_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_attributes_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Segment_attributes_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Segment_attributes_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Segment_attributes_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Segment_attributes_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Segment_attributes_clauseContext) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Segment_attributes_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Segment_attributes_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Segment_attributes_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Segment_attributes_clauseContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSET) +} + +func (s *Segment_attributes_clauseContext) SET(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, i) +} + +func (s *Segment_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_attributes_clause(s) + } +} + +func (s *Segment_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_attributes_clause(s) + } +} + +func (p *PlSqlParser) Segment_attributes_clause() (localctx ISegment_attributes_clauseContext) { + localctx = NewSegment_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1200, PlSqlParserRULE_segment_attributes_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(11975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(11964) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(11965) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1491, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11966) + + var _x = p.Id_expression() + + localctx.(*Segment_attributes_clauseContext).tablespace_name = _x + } + + case 2: + p.SetState(11968) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1490, p.GetParserRuleContext()) == 1 { + { + p.SetState(11967) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11970) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS, PlSqlParserROW: + { + p.SetState(11973) + p.Table_compression() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(11974) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11977) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1493, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPhysical_propertiesContext is an interface to support dynamic dispatch. +type IPhysical_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Deferred_segment_creation() IDeferred_segment_creationContext + Segment_attributes_clause() ISegment_attributes_clauseContext + Table_compression() ITable_compressionContext + Inmemory_table_clause() IInmemory_table_clauseContext + Ilm_clause() IIlm_clauseContext + ORGANIZATION() antlr.TerminalNode + HEAP() antlr.TerminalNode + Heap_org_table_clause() IHeap_org_table_clauseContext + INDEX() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + External_table_clause() IExternal_table_clauseContext + Index_org_table_clause() IIndex_org_table_clauseContext + PARTITION() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPhysical_propertiesContext differentiates from other interfaces. + IsPhysical_propertiesContext() +} + +type Physical_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPhysical_propertiesContext() *Physical_propertiesContext { + var p = new(Physical_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_properties + return p +} + +func InitEmptyPhysical_propertiesContext(p *Physical_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_properties +} + +func (*Physical_propertiesContext) IsPhysical_propertiesContext() {} + +func NewPhysical_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Physical_propertiesContext { + var p = new(Physical_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_physical_properties + + return p +} + +func (s *Physical_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Physical_propertiesContext) Deferred_segment_creation() IDeferred_segment_creationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeferred_segment_creationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeferred_segment_creationContext) +} + +func (s *Physical_propertiesContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Physical_propertiesContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Physical_propertiesContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Physical_propertiesContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Physical_propertiesContext) ORGANIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORGANIZATION, 0) +} + +func (s *Physical_propertiesContext) HEAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEAP, 0) +} + +func (s *Physical_propertiesContext) Heap_org_table_clause() IHeap_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHeap_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHeap_org_table_clauseContext) +} + +func (s *Physical_propertiesContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Physical_propertiesContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Physical_propertiesContext) External_table_clause() IExternal_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_clauseContext) +} + +func (s *Physical_propertiesContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Physical_propertiesContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Physical_propertiesContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Physical_propertiesContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Physical_propertiesContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Physical_propertiesContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Physical_propertiesContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Physical_propertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Physical_propertiesContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Physical_propertiesContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Physical_propertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Physical_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Physical_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Physical_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Physical_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Physical_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhysical_properties(s) + } +} + +func (s *Physical_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhysical_properties(s) + } +} + +func (p *PlSqlParser) Physical_properties() (localctx IPhysical_propertiesContext) { + localctx = NewPhysical_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1202, PlSqlParserRULE_physical_properties) + var _la int + + p.SetState(12022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1500, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11979) + p.Deferred_segment_creation() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11980) + p.Segment_attributes_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11981) + p.Table_compression() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11982) + p.Inmemory_table_clause() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11983) + p.Ilm_clause() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11984) + p.Match(PlSqlParserORGANIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserHEAP: + { + p.SetState(11985) + p.Match(PlSqlParserHEAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11987) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1494, p.GetParserRuleContext()) == 1 { + { + p.SetState(11986) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11989) + p.Heap_org_table_clause() + } + + case PlSqlParserINDEX: + { + p.SetState(11990) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1495, p.GetParserRuleContext()) == 1 { + { + p.SetState(11991) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11995) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1496, p.GetParserRuleContext()) == 1 { + { + p.SetState(11994) + p.Index_org_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserEXTERNAL: + { + p.SetState(11997) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11998) + p.External_table_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12001) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12002) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12003) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12004) + p.External_table_clause() + } + p.SetState(12007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREJECT { + { + p.SetState(12005) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12006) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12009) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12010) + p.Cluster_name() + } + { + p.SetState(12011) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12012) + p.Column_name() + } + p.SetState(12017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12013) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12014) + p.Column_name() + } + + p.SetState(12019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12020) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_clauseContext is an interface to support dynamic dispatch. +type IIlm_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ILM() antlr.TerminalNode + ADD() antlr.TerminalNode + POLICY() antlr.TerminalNode + Ilm_policy_clause() IIlm_policy_clauseContext + DELETE_ALL() antlr.TerminalNode + ENABLE_ALL() antlr.TerminalNode + DISABLE_ALL() antlr.TerminalNode + DELETE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsIlm_clauseContext differentiates from other interfaces. + IsIlm_clauseContext() +} + +type Ilm_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_clauseContext() *Ilm_clauseContext { + var p = new(Ilm_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_clause + return p +} + +func InitEmptyIlm_clauseContext(p *Ilm_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_clause +} + +func (*Ilm_clauseContext) IsIlm_clauseContext() {} + +func NewIlm_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_clauseContext { + var p = new(Ilm_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_clause + + return p +} + +func (s *Ilm_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_clauseContext) ILM() antlr.TerminalNode { + return s.GetToken(PlSqlParserILM, 0) +} + +func (s *Ilm_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Ilm_clauseContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Ilm_clauseContext) Ilm_policy_clause() IIlm_policy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_policy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_policy_clauseContext) +} + +func (s *Ilm_clauseContext) DELETE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE_ALL, 0) +} + +func (s *Ilm_clauseContext) ENABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_ALL, 0) +} + +func (s *Ilm_clauseContext) DISABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_ALL, 0) +} + +func (s *Ilm_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Ilm_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Ilm_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Ilm_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_clause(s) + } +} + +func (s *Ilm_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_clause(s) + } +} + +func (p *PlSqlParser) Ilm_clause() (localctx IIlm_clauseContext) { + localctx = NewIlm_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1204, PlSqlParserRULE_ilm_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12024) + p.Match(PlSqlParserILM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(12025) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12026) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12027) + p.Ilm_policy_clause() + } + + case PlSqlParserDELETE, PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(12028) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12029) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12030) + p.Ilm_policy_clause() + } + + case PlSqlParserDELETE_ALL: + { + p.SetState(12031) + p.Match(PlSqlParserDELETE_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENABLE_ALL: + { + p.SetState(12032) + p.Match(PlSqlParserENABLE_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE_ALL: + { + p.SetState(12033) + p.Match(PlSqlParserDISABLE_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_policy_clauseContext is an interface to support dynamic dispatch. +type IIlm_policy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ilm_compression_policy() IIlm_compression_policyContext + Ilm_tiering_policy() IIlm_tiering_policyContext + Ilm_inmemory_policy() IIlm_inmemory_policyContext + + // IsIlm_policy_clauseContext differentiates from other interfaces. + IsIlm_policy_clauseContext() +} + +type Ilm_policy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_policy_clauseContext() *Ilm_policy_clauseContext { + var p = new(Ilm_policy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause + return p +} + +func InitEmptyIlm_policy_clauseContext(p *Ilm_policy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause +} + +func (*Ilm_policy_clauseContext) IsIlm_policy_clauseContext() {} + +func NewIlm_policy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_policy_clauseContext { + var p = new(Ilm_policy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause + + return p +} + +func (s *Ilm_policy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_policy_clauseContext) Ilm_compression_policy() IIlm_compression_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_compression_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_compression_policyContext) +} + +func (s *Ilm_policy_clauseContext) Ilm_tiering_policy() IIlm_tiering_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_tiering_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_tiering_policyContext) +} + +func (s *Ilm_policy_clauseContext) Ilm_inmemory_policy() IIlm_inmemory_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_inmemory_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_inmemory_policyContext) +} + +func (s *Ilm_policy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_policy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_policy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_policy_clause(s) + } +} + +func (s *Ilm_policy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_policy_clause(s) + } +} + +func (p *PlSqlParser) Ilm_policy_clause() (localctx IIlm_policy_clauseContext) { + localctx = NewIlm_policy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1206, PlSqlParserRULE_ilm_policy_clause) + p.SetState(12039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS, PlSqlParserROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12036) + p.Ilm_compression_policy() + } + + case PlSqlParserTIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12037) + p.Ilm_tiering_policy() + } + + case PlSqlParserMODIFY, PlSqlParserNO, PlSqlParserSET: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12038) + p.Ilm_inmemory_policy() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_compression_policyContext is an interface to support dynamic dispatch. +type IIlm_compression_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_compression() ITable_compressionContext + Segment_group() ISegment_groupContext + Ilm_after_on() IIlm_after_onContext + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AFTER() antlr.TerminalNode + Ilm_time_period() IIlm_time_periodContext + OF() antlr.TerminalNode + NO() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + STORE() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + FOR() antlr.TerminalNode + QUERY() antlr.TerminalNode + + // IsIlm_compression_policyContext differentiates from other interfaces. + IsIlm_compression_policyContext() +} + +type Ilm_compression_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_compression_policyContext() *Ilm_compression_policyContext { + var p = new(Ilm_compression_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy + return p +} + +func InitEmptyIlm_compression_policyContext(p *Ilm_compression_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy +} + +func (*Ilm_compression_policyContext) IsIlm_compression_policyContext() {} + +func NewIlm_compression_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_compression_policyContext { + var p = new(Ilm_compression_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy + + return p +} + +func (s *Ilm_compression_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_compression_policyContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Ilm_compression_policyContext) Segment_group() ISegment_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_groupContext) +} + +func (s *Ilm_compression_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_compression_policyContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Ilm_compression_policyContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Ilm_compression_policyContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Ilm_compression_policyContext) Ilm_time_period() IIlm_time_periodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_time_periodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_time_periodContext) +} + +func (s *Ilm_compression_policyContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Ilm_compression_policyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_compression_policyContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Ilm_compression_policyContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Ilm_compression_policyContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Ilm_compression_policyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Ilm_compression_policyContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Ilm_compression_policyContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Ilm_compression_policyContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Ilm_compression_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_compression_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_compression_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_compression_policy(s) + } +} + +func (s *Ilm_compression_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_compression_policy(s) + } +} + +func (p *PlSqlParser) Ilm_compression_policy() (localctx IIlm_compression_policyContext) { + localctx = NewIlm_compression_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1208, PlSqlParserRULE_ilm_compression_policy) + var _la int + + p.SetState(12060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1504, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12041) + p.Table_compression() + } + { + p.SetState(12042) + p.Segment_group() + } + { + p.SetState(12043) + p.Ilm_after_on() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12045) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOLUMN || _la == PlSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12046) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12047) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADVANCED: + { + p.SetState(12048) + p.Match(PlSqlParserADVANCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(12049) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12050) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + { + p.SetState(12053) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12054) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12055) + p.Ilm_time_period() + } + { + p.SetState(12056) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12057) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12058) + p.Match(PlSqlParserMODIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_tiering_policyContext is an interface to support dynamic dispatch. +type IIlm_tiering_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIER() antlr.TerminalNode + TO() antlr.TerminalNode + Tablespace() ITablespaceContext + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + Ilm_after_on() IIlm_after_onContext + Segment_group() ISegment_groupContext + ON() antlr.TerminalNode + Function_name() IFunction_nameContext + + // IsIlm_tiering_policyContext differentiates from other interfaces. + IsIlm_tiering_policyContext() +} + +type Ilm_tiering_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_tiering_policyContext() *Ilm_tiering_policyContext { + var p = new(Ilm_tiering_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy + return p +} + +func InitEmptyIlm_tiering_policyContext(p *Ilm_tiering_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy +} + +func (*Ilm_tiering_policyContext) IsIlm_tiering_policyContext() {} + +func NewIlm_tiering_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_tiering_policyContext { + var p = new(Ilm_tiering_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy + + return p +} + +func (s *Ilm_tiering_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_tiering_policyContext) TIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIER, 0) +} + +func (s *Ilm_tiering_policyContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Ilm_tiering_policyContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Ilm_tiering_policyContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Ilm_tiering_policyContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Ilm_tiering_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_tiering_policyContext) Segment_group() ISegment_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_groupContext) +} + +func (s *Ilm_tiering_policyContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Ilm_tiering_policyContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Ilm_tiering_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_tiering_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_tiering_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_tiering_policy(s) + } +} + +func (s *Ilm_tiering_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_tiering_policy(s) + } +} + +func (p *PlSqlParser) Ilm_tiering_policy() (localctx IIlm_tiering_policyContext) { + localctx = NewIlm_tiering_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1210, PlSqlParserRULE_ilm_tiering_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12062) + p.Match(PlSqlParserTIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12063) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12064) + p.Tablespace() + } + p.SetState(12078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1508, p.GetParserRuleContext()) { + case 1: + p.SetState(12066) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1505, p.GetParserRuleContext()) == 1 { + { + p.SetState(12065) + p.Segment_group() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12070) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1506, p.GetParserRuleContext()) == 1 { + { + p.SetState(12068) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12069) + p.Function_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(12072) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12073) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserSEGMENT { + { + p.SetState(12074) + p.Segment_group() + } + + } + { + p.SetState(12077) + p.Ilm_after_on() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_after_onContext is an interface to support dynamic dispatch. +type IIlm_after_onContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AFTER() antlr.TerminalNode + Ilm_time_period() IIlm_time_periodContext + OF() antlr.TerminalNode + NO() antlr.TerminalNode + CREATION() antlr.TerminalNode + ACCESS() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + ON() antlr.TerminalNode + Function_name() IFunction_nameContext + + // IsIlm_after_onContext differentiates from other interfaces. + IsIlm_after_onContext() +} + +type Ilm_after_onContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_after_onContext() *Ilm_after_onContext { + var p = new(Ilm_after_onContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_after_on + return p +} + +func InitEmptyIlm_after_onContext(p *Ilm_after_onContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_after_on +} + +func (*Ilm_after_onContext) IsIlm_after_onContext() {} + +func NewIlm_after_onContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_after_onContext { + var p = new(Ilm_after_onContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_after_on + + return p +} + +func (s *Ilm_after_onContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_after_onContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Ilm_after_onContext) Ilm_time_period() IIlm_time_periodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_time_periodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_time_periodContext) +} + +func (s *Ilm_after_onContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Ilm_after_onContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_after_onContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Ilm_after_onContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Ilm_after_onContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Ilm_after_onContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Ilm_after_onContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Ilm_after_onContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_after_onContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_after_onContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_after_on(s) + } +} + +func (s *Ilm_after_onContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_after_on(s) + } +} + +func (p *PlSqlParser) Ilm_after_on() (localctx IIlm_after_onContext) { + localctx = NewIlm_after_onContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1212, PlSqlParserRULE_ilm_after_on) + var _la int + + p.SetState(12090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAFTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12080) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12081) + p.Ilm_time_period() + } + { + p.SetState(12082) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + { + p.SetState(12083) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12084) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACCESS || _la == PlSqlParserMODIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserCREATION: + { + p.SetState(12085) + p.Match(PlSqlParserCREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12088) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12089) + p.Function_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISegment_groupContext is an interface to support dynamic dispatch. +type ISegment_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + GROUP() antlr.TerminalNode + + // IsSegment_groupContext differentiates from other interfaces. + IsSegment_groupContext() +} + +type Segment_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySegment_groupContext() *Segment_groupContext { + var p = new(Segment_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_group + return p +} + +func InitEmptySegment_groupContext(p *Segment_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_group +} + +func (*Segment_groupContext) IsSegment_groupContext() {} + +func NewSegment_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_groupContext { + var p = new(Segment_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_group + + return p +} + +func (s *Segment_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_groupContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Segment_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Segment_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_group(s) + } +} + +func (s *Segment_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_group(s) + } +} + +func (p *PlSqlParser) Segment_group() (localctx ISegment_groupContext) { + localctx = NewSegment_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1214, PlSqlParserRULE_segment_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12092) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserSEGMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_inmemory_policyContext is an interface to support dynamic dispatch. +type IIlm_inmemory_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ilm_after_on() IIlm_after_onContext + SET() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + MODIFY() antlr.TerminalNode + Inmemory_memcompress() IInmemory_memcompressContext + NO() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + + // IsIlm_inmemory_policyContext differentiates from other interfaces. + IsIlm_inmemory_policyContext() +} + +type Ilm_inmemory_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_inmemory_policyContext() *Ilm_inmemory_policyContext { + var p = new(Ilm_inmemory_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy + return p +} + +func InitEmptyIlm_inmemory_policyContext(p *Ilm_inmemory_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy +} + +func (*Ilm_inmemory_policyContext) IsIlm_inmemory_policyContext() {} + +func NewIlm_inmemory_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_inmemory_policyContext { + var p = new(Ilm_inmemory_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy + + return p +} + +func (s *Ilm_inmemory_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_inmemory_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_inmemory_policyContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Ilm_inmemory_policyContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Ilm_inmemory_policyContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Ilm_inmemory_policyContext) Inmemory_memcompress() IInmemory_memcompressContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Ilm_inmemory_policyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_inmemory_policyContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Ilm_inmemory_policyContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Ilm_inmemory_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_inmemory_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_inmemory_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_inmemory_policy(s) + } +} + +func (s *Ilm_inmemory_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_inmemory_policy(s) + } +} + +func (p *PlSqlParser) Ilm_inmemory_policy() (localctx IIlm_inmemory_policyContext) { + localctx = NewIlm_inmemory_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1216, PlSqlParserRULE_ilm_inmemory_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSET: + { + p.SetState(12094) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12095) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISTRIBUTE || _la == PlSqlParserDUPLICATE || _la == PlSqlParserMEMCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserPRIORITY { + { + p.SetState(12096) + p.Inmemory_attributes() + } + + } + + case PlSqlParserMODIFY: + { + p.SetState(12099) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12100) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12101) + p.Inmemory_memcompress() + } + + case PlSqlParserNO: + { + p.SetState(12102) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12103) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEGMENT { + { + p.SetState(12106) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12109) + p.Ilm_after_on() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_time_periodContext is an interface to support dynamic dispatch. +type IIlm_time_periodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric() INumericContext + DAY() antlr.TerminalNode + DAYS() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTHS() antlr.TerminalNode + YEAR() antlr.TerminalNode + YEARS() antlr.TerminalNode + + // IsIlm_time_periodContext differentiates from other interfaces. + IsIlm_time_periodContext() +} + +type Ilm_time_periodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_time_periodContext() *Ilm_time_periodContext { + var p = new(Ilm_time_periodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_time_period + return p +} + +func InitEmptyIlm_time_periodContext(p *Ilm_time_periodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_time_period +} + +func (*Ilm_time_periodContext) IsIlm_time_periodContext() {} + +func NewIlm_time_periodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_time_periodContext { + var p = new(Ilm_time_periodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_time_period + + return p +} + +func (s *Ilm_time_periodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_time_periodContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Ilm_time_periodContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Ilm_time_periodContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Ilm_time_periodContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Ilm_time_periodContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Ilm_time_periodContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Ilm_time_periodContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Ilm_time_periodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_time_periodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_time_periodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_time_period(s) + } +} + +func (s *Ilm_time_periodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_time_period(s) + } +} + +func (p *PlSqlParser) Ilm_time_period() (localctx IIlm_time_periodContext) { + localctx = NewIlm_time_periodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1218, PlSqlParserRULE_ilm_time_period) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12111) + p.Numeric() + } + { + p.SetState(12112) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserDAYS || _la == PlSqlParserMONTH || _la == PlSqlParserMONTHS || _la == PlSqlParserYEARS || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHeap_org_table_clauseContext is an interface to support dynamic dispatch. +type IHeap_org_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_compression() ITable_compressionContext + Inmemory_table_clause() IInmemory_table_clauseContext + Ilm_clause() IIlm_clauseContext + + // IsHeap_org_table_clauseContext differentiates from other interfaces. + IsHeap_org_table_clauseContext() +} + +type Heap_org_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHeap_org_table_clauseContext() *Heap_org_table_clauseContext { + var p = new(Heap_org_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause + return p +} + +func InitEmptyHeap_org_table_clauseContext(p *Heap_org_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause +} + +func (*Heap_org_table_clauseContext) IsHeap_org_table_clauseContext() {} + +func NewHeap_org_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Heap_org_table_clauseContext { + var p = new(Heap_org_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause + + return p +} + +func (s *Heap_org_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Heap_org_table_clauseContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Heap_org_table_clauseContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Heap_org_table_clauseContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Heap_org_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Heap_org_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Heap_org_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHeap_org_table_clause(s) + } +} + +func (s *Heap_org_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHeap_org_table_clause(s) + } +} + +func (p *PlSqlParser) Heap_org_table_clause() (localctx IHeap_org_table_clauseContext) { + localctx = NewHeap_org_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1220, PlSqlParserRULE_heap_org_table_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(12115) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1514, p.GetParserRuleContext()) == 1 { + { + p.SetState(12114) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12118) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1515, p.GetParserRuleContext()) == 1 { + { + p.SetState(12117) + p.Inmemory_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1516, p.GetParserRuleContext()) == 1 { + { + p.SetState(12120) + p.Ilm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + External_table_data_props() IExternal_table_data_propsContext + RIGHT_PAREN() antlr.TerminalNode + TYPE() antlr.TerminalNode + Access_driver_type() IAccess_driver_typeContext + Parallel_clause() IParallel_clauseContext + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Inmemory_table_clause() IInmemory_table_clauseContext + Numeric() INumericContext + UNLIMITED() antlr.TerminalNode + + // IsExternal_table_clauseContext differentiates from other interfaces. + IsExternal_table_clauseContext() +} + +type External_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_clauseContext() *External_table_clauseContext { + var p = new(External_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_clause + return p +} + +func InitEmptyExternal_table_clauseContext(p *External_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_clause +} + +func (*External_table_clauseContext) IsExternal_table_clauseContext() {} + +func NewExternal_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_clauseContext { + var p = new(External_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_clause + + return p +} + +func (s *External_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_clauseContext) External_table_data_props() IExternal_table_data_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_data_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_data_propsContext) +} + +func (s *External_table_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *External_table_clauseContext) Access_driver_type() IAccess_driver_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccess_driver_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccess_driver_typeContext) +} + +func (s *External_table_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *External_table_clauseContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *External_table_clauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *External_table_clauseContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *External_table_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *External_table_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *External_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_clause(s) + } +} + +func (s *External_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_clause(s) + } +} + +func (p *PlSqlParser) External_table_clause() (localctx IExternal_table_clauseContext) { + localctx = NewExternal_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1222, PlSqlParserRULE_external_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12123) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(12124) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12125) + p.Access_driver_type() + } + + } + { + p.SetState(12128) + p.External_table_data_props() + } + { + p.SetState(12129) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12131) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1518, p.GetParserRuleContext()) == 1 { + { + p.SetState(12130) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12139) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1520, p.GetParserRuleContext()) == 1 { + { + p.SetState(12133) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12134) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(12135) + p.Numeric() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(12136) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12142) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1521, p.GetParserRuleContext()) == 1 { + { + p.SetState(12141) + p.Inmemory_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAccess_driver_typeContext is an interface to support dynamic dispatch. +type IAccess_driver_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORACLE_LOADER() antlr.TerminalNode + ORACLE_DATAPUMP() antlr.TerminalNode + ORACLE_HDFS() antlr.TerminalNode + ORACLE_HIVE() antlr.TerminalNode + + // IsAccess_driver_typeContext differentiates from other interfaces. + IsAccess_driver_typeContext() +} + +type Access_driver_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccess_driver_typeContext() *Access_driver_typeContext { + var p = new(Access_driver_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_access_driver_type + return p +} + +func InitEmptyAccess_driver_typeContext(p *Access_driver_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_access_driver_type +} + +func (*Access_driver_typeContext) IsAccess_driver_typeContext() {} + +func NewAccess_driver_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Access_driver_typeContext { + var p = new(Access_driver_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_access_driver_type + + return p +} + +func (s *Access_driver_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Access_driver_typeContext) ORACLE_LOADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_LOADER, 0) +} + +func (s *Access_driver_typeContext) ORACLE_DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATAPUMP, 0) +} + +func (s *Access_driver_typeContext) ORACLE_HDFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HDFS, 0) +} + +func (s *Access_driver_typeContext) ORACLE_HIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HIVE, 0) +} + +func (s *Access_driver_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Access_driver_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Access_driver_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAccess_driver_type(s) + } +} + +func (s *Access_driver_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAccess_driver_type(s) + } +} + +func (p *PlSqlParser) Access_driver_type() (localctx IAccess_driver_typeContext) { + localctx = NewAccess_driver_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1224, PlSqlParserRULE_access_driver_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12144) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2380)) & ^0x3f) == 0 && ((int64(1)<<(_la-2380))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_data_propsContext is an interface to support dynamic dispatch. +type IExternal_table_data_propsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + AllExternal_table_directory() []IExternal_table_directoryContext + External_table_directory(i int) IExternal_table_directoryContext + ACCESS() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + LOCATION() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + USING() antlr.TerminalNode + CLOB() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllExternal_table_data_format() []IExternal_table_data_formatContext + External_table_data_format(i int) IExternal_table_data_formatContext + + // IsExternal_table_data_propsContext differentiates from other interfaces. + IsExternal_table_data_propsContext() +} + +type External_table_data_propsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_data_propsContext() *External_table_data_propsContext { + var p = new(External_table_data_propsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_props + return p +} + +func InitEmptyExternal_table_data_propsContext(p *External_table_data_propsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_props +} + +func (*External_table_data_propsContext) IsExternal_table_data_propsContext() {} + +func NewExternal_table_data_propsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_data_propsContext { + var p = new(External_table_data_propsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_data_props + + return p +} + +func (s *External_table_data_propsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_data_propsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *External_table_data_propsContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *External_table_data_propsContext) AllExternal_table_directory() []IExternal_table_directoryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + len++ + } + } + + tst := make([]IExternal_table_directoryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_directoryContext); ok { + tst[i] = t.(IExternal_table_directoryContext) + i++ + } + } + + return tst +} + +func (s *External_table_data_propsContext) External_table_directory(i int) IExternal_table_directoryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_data_propsContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *External_table_data_propsContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *External_table_data_propsContext) LOCATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATION, 0) +} + +func (s *External_table_data_propsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *External_table_data_propsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *External_table_data_propsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *External_table_data_propsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *External_table_data_propsContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *External_table_data_propsContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *External_table_data_propsContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *External_table_data_propsContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *External_table_data_propsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_data_propsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_data_propsContext) AllExternal_table_data_format() []IExternal_table_data_formatContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_data_formatContext); ok { + len++ + } + } + + tst := make([]IExternal_table_data_formatContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_data_formatContext); ok { + tst[i] = t.(IExternal_table_data_formatContext) + i++ + } + } + + return tst +} + +func (s *External_table_data_propsContext) External_table_data_format(i int) IExternal_table_data_formatContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_data_formatContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_data_formatContext) +} + +func (s *External_table_data_propsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_data_propsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_data_propsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_data_props(s) + } +} + +func (s *External_table_data_propsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_data_props(s) + } +} + +func (p *PlSqlParser) External_table_data_props() (localctx IExternal_table_data_propsContext) { + localctx = NewExternal_table_data_propsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1226, PlSqlParserRULE_external_table_data_props) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(12146) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12147) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12148) + p.External_table_directory() + } + + } + p.SetState(12169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACCESS { + { + p.SetState(12151) + p.Match(PlSqlParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12152) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1524, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12153) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12154) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12155) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(12156) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738591438668824681) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231295071444991) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475333) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489125) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-142953691481091) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2594144871876919393) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-5800733077145665281) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225153729) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504606980225) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134695999864833) != 0) || ((int64((_la-1089)) & ^0x3f) == 0 && ((int64(1)<<(_la-1089))&-35184372090881) != 0) || ((int64((_la-1153)) & ^0x3f) == 0 && ((int64(1)<<(_la-1153))&-3377717168832513) != 0) || ((int64((_la-1217)) & ^0x3f) == 0 && ((int64(1)<<(_la-1217))&-108091889151903749) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8796093022209) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-268435457) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457923) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(12157) + p.External_table_data_format() + } + + p.SetState(12160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12162) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(12164) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12165) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12166) + p.Select_only_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(12183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCATION { + { + p.SetState(12171) + p.Match(PlSqlParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12172) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12173) + p.External_table_directory() + } + p.SetState(12178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12174) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12175) + p.External_table_directory() + } + + p.SetState(12180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12181) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_data_formatContext is an interface to support dynamic dispatch. +type IExternal_table_data_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORDS() antlr.TerminalNode + DELIMITED() antlr.TerminalNode + BY() antlr.TerminalNode + NEWLINE_() antlr.TerminalNode + COLUMN() antlr.TerminalNode + TRANSFORMS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExternal_table_transform() []IExternal_table_transformContext + External_table_transform(i int) IExternal_table_transformContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + External_table_records() IExternal_table_recordsContext + External_table_fields() IExternal_table_fieldsContext + External_table_datapump() IExternal_table_datapumpContext + External_table_hive() IExternal_table_hiveContext + + // IsExternal_table_data_formatContext differentiates from other interfaces. + IsExternal_table_data_formatContext() +} + +type External_table_data_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_data_formatContext() *External_table_data_formatContext { + var p = new(External_table_data_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_format + return p +} + +func InitEmptyExternal_table_data_formatContext(p *External_table_data_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_format +} + +func (*External_table_data_formatContext) IsExternal_table_data_formatContext() {} + +func NewExternal_table_data_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_data_formatContext { + var p = new(External_table_data_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_data_format + + return p +} + +func (s *External_table_data_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_data_formatContext) RECORDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS, 0) +} + +func (s *External_table_data_formatContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED, 0) +} + +func (s *External_table_data_formatContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *External_table_data_formatContext) NEWLINE_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEWLINE_, 0) +} + +func (s *External_table_data_formatContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *External_table_data_formatContext) TRANSFORMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORMS, 0) +} + +func (s *External_table_data_formatContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_data_formatContext) AllExternal_table_transform() []IExternal_table_transformContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_transformContext); ok { + len++ + } + } + + tst := make([]IExternal_table_transformContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_transformContext); ok { + tst[i] = t.(IExternal_table_transformContext) + i++ + } + } + + return tst +} + +func (s *External_table_data_formatContext) External_table_transform(i int) IExternal_table_transformContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_transformContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_transformContext) +} + +func (s *External_table_data_formatContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_data_formatContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_data_formatContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_data_formatContext) External_table_records() IExternal_table_recordsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_recordsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_recordsContext) +} + +func (s *External_table_data_formatContext) External_table_fields() IExternal_table_fieldsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_fieldsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_fieldsContext) +} + +func (s *External_table_data_formatContext) External_table_datapump() IExternal_table_datapumpContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_datapumpContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_datapumpContext) +} + +func (s *External_table_data_formatContext) External_table_hive() IExternal_table_hiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_hiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_hiveContext) +} + +func (s *External_table_data_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_data_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_data_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_data_format(s) + } +} + +func (s *External_table_data_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_data_format(s) + } +} + +func (p *PlSqlParser) External_table_data_format() (localctx IExternal_table_data_formatContext) { + localctx = NewExternal_table_data_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1228, PlSqlParserRULE_external_table_data_format) + var _la int + + p.SetState(12206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1529, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12185) + p.Match(PlSqlParserRECORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12186) + p.Match(PlSqlParserDELIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12187) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12188) + p.Match(PlSqlParserNEWLINE_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12189) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12190) + p.Match(PlSqlParserTRANSFORMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12191) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12192) + p.External_table_transform() + } + p.SetState(12197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12193) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12194) + p.External_table_transform() + } + + p.SetState(12199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12200) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12202) + p.External_table_records() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12203) + p.External_table_fields() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12204) + p.External_table_datapump() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12205) + p.External_table_hive() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_transformContext is an interface to support dynamic dispatch. +type IExternal_table_transformContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + AllFROM() []antlr.TerminalNode + FROM(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + STARTOF() antlr.TerminalNode + External_table_field_list() IExternal_table_field_listContext + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + CONCAT() antlr.TerminalNode + LOBFILE() antlr.TerminalNode + External_table_field() IExternal_table_fieldContext + AllExternal_table_directory() []IExternal_table_directoryContext + External_table_directory(i int) IExternal_table_directoryContext + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + CHARACTERSET() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_transformContext differentiates from other interfaces. + IsExternal_table_transformContext() +} + +type External_table_transformContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_transformContext() *External_table_transformContext { + var p = new(External_table_transformContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_transform + return p +} + +func InitEmptyExternal_table_transformContext(p *External_table_transformContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_transform +} + +func (*External_table_transformContext) IsExternal_table_transformContext() {} + +func NewExternal_table_transformContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_transformContext { + var p = new(External_table_transformContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_transform + + return p +} + +func (s *External_table_transformContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_transformContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *External_table_transformContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFROM) +} + +func (s *External_table_transformContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, i) +} + +func (s *External_table_transformContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *External_table_transformContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *External_table_transformContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_transformContext) STARTOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTOF, 0) +} + +func (s *External_table_transformContext) External_table_field_list() IExternal_table_field_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_field_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_field_listContext) +} + +func (s *External_table_transformContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_transformContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *External_table_transformContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_transformContext) CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONCAT, 0) +} + +func (s *External_table_transformContext) LOBFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBFILE, 0) +} + +func (s *External_table_transformContext) External_table_field() IExternal_table_fieldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_fieldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_fieldContext) +} + +func (s *External_table_transformContext) AllExternal_table_directory() []IExternal_table_directoryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + len++ + } + } + + tst := make([]IExternal_table_directoryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_directoryContext); ok { + tst[i] = t.(IExternal_table_directoryContext) + i++ + } + } + + return tst +} + +func (s *External_table_transformContext) External_table_directory(i int) IExternal_table_directoryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_transformContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *External_table_transformContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *External_table_transformContext) CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERSET, 0) +} + +func (s *External_table_transformContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *External_table_transformContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *External_table_transformContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_transformContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_transformContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_transformContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_transformContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_transform(s) + } +} + +func (s *External_table_transformContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_transform(s) + } +} + +func (p *PlSqlParser) External_table_transform() (localctx IExternal_table_transformContext) { + localctx = NewExternal_table_transformContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1230, PlSqlParserRULE_external_table_transform) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12208) + p.Column_name() + } + { + p.SetState(12209) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(12210) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTANT: + { + p.SetState(12211) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12212) + p.Quoted_string() + } + + case PlSqlParserCONCAT, PlSqlParserLOBFILE: + { + p.SetState(12213) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONCAT || _la == PlSqlParserLOBFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1530, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12214) + p.External_table_field() + } + + case 2: + { + p.SetState(12215) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12216) + p.Quoted_string() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserBLOB, PlSqlParserCHARACTERSET, PlSqlParserCLOB, PlSqlParserFROM: + p.SetState(12236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFROM: + { + p.SetState(12219) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12220) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12221) + p.External_table_directory() + } + p.SetState(12226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12222) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12223) + p.External_table_directory() + } + + p.SetState(12228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12229) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLOB: + { + p.SetState(12231) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + { + p.SetState(12232) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARACTERSET: + { + p.SetState(12233) + p.Match(PlSqlParserCHARACTERSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12234) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12235) + p.Char_set_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserSTARTOF: + { + p.SetState(12238) + p.Match(PlSqlParserSTARTOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12239) + p.External_table_field_list() + } + { + p.SetState(12240) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12241) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12242) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_fieldContext is an interface to support dynamic dispatch. +type IExternal_table_fieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Type_name() IType_nameContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Default_value_part() IDefault_value_partContext + + // IsExternal_table_fieldContext differentiates from other interfaces. + IsExternal_table_fieldContext() +} + +type External_table_fieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_fieldContext() *External_table_fieldContext { + var p = new(External_table_fieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_field + return p +} + +func InitEmptyExternal_table_fieldContext(p *External_table_fieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_field +} + +func (*External_table_fieldContext) IsExternal_table_fieldContext() {} + +func NewExternal_table_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_fieldContext { + var p = new(External_table_fieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_field + + return p +} + +func (s *External_table_fieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_fieldContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *External_table_fieldContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *External_table_fieldContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *External_table_fieldContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *External_table_fieldContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *External_table_fieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_fieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_field(s) + } +} + +func (s *External_table_fieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_field(s) + } +} + +func (p *PlSqlParser) External_table_field() (localctx IExternal_table_fieldContext) { + localctx = NewExternal_table_fieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1232, PlSqlParserRULE_external_table_field) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12246) + p.Column_name() + } + p.SetState(12248) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1534, p.GetParserRuleContext()) == 1 { + { + p.SetState(12247) + p.Type_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(12250) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12251) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(12254) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_field_listContext is an interface to support dynamic dispatch. +type IExternal_table_field_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExternal_table_fields_clause() []IExternal_table_fields_clauseContext + External_table_fields_clause(i int) IExternal_table_fields_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_field_listContext differentiates from other interfaces. + IsExternal_table_field_listContext() +} + +type External_table_field_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_field_listContext() *External_table_field_listContext { + var p = new(External_table_field_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_field_list + return p +} + +func InitEmptyExternal_table_field_listContext(p *External_table_field_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_field_list +} + +func (*External_table_field_listContext) IsExternal_table_field_listContext() {} + +func NewExternal_table_field_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_field_listContext { + var p = new(External_table_field_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_field_list + + return p +} + +func (s *External_table_field_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_field_listContext) AllExternal_table_fields_clause() []IExternal_table_fields_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_fields_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_fields_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_fields_clauseContext); ok { + tst[i] = t.(IExternal_table_fields_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_field_listContext) External_table_fields_clause(i int) IExternal_table_fields_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_fields_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_fields_clauseContext) +} + +func (s *External_table_field_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_field_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_field_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_field_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_field_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_field_list(s) + } +} + +func (s *External_table_field_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_field_list(s) + } +} + +func (p *PlSqlParser) External_table_field_list() (localctx IExternal_table_field_listContext) { + localctx = NewExternal_table_field_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1234, PlSqlParserRULE_external_table_field_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12257) + p.External_table_fields_clause() + } + p.SetState(12262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12258) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12259) + p.External_table_fields_clause() + } + + p.SetState(12264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_fields_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_fields_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + External_table_field() IExternal_table_fieldContext + AllExternal_table_position_clause() []IExternal_table_position_clauseContext + External_table_position_clause(i int) IExternal_table_position_clauseContext + AllExternal_table_datatype_clause() []IExternal_table_datatype_clauseContext + External_table_datatype_clause(i int) IExternal_table_datatype_clauseContext + AllExternal_table_init_clause() []IExternal_table_init_clauseContext + External_table_init_clause(i int) IExternal_table_init_clauseContext + AllExternal_table_lls_clause() []IExternal_table_lls_clauseContext + External_table_lls_clause(i int) IExternal_table_lls_clauseContext + + // IsExternal_table_fields_clauseContext differentiates from other interfaces. + IsExternal_table_fields_clauseContext() +} + +type External_table_fields_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_fields_clauseContext() *External_table_fields_clauseContext { + var p = new(External_table_fields_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_fields_clause + return p +} + +func InitEmptyExternal_table_fields_clauseContext(p *External_table_fields_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_fields_clause +} + +func (*External_table_fields_clauseContext) IsExternal_table_fields_clauseContext() {} + +func NewExternal_table_fields_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_fields_clauseContext { + var p = new(External_table_fields_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_fields_clause + + return p +} + +func (s *External_table_fields_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_fields_clauseContext) External_table_field() IExternal_table_fieldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_fieldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_fieldContext) +} + +func (s *External_table_fields_clauseContext) AllExternal_table_position_clause() []IExternal_table_position_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_position_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_position_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_position_clauseContext); ok { + tst[i] = t.(IExternal_table_position_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_fields_clauseContext) External_table_position_clause(i int) IExternal_table_position_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_position_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_position_clauseContext) +} + +func (s *External_table_fields_clauseContext) AllExternal_table_datatype_clause() []IExternal_table_datatype_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_datatype_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_datatype_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_datatype_clauseContext); ok { + tst[i] = t.(IExternal_table_datatype_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_fields_clauseContext) External_table_datatype_clause(i int) IExternal_table_datatype_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_datatype_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_datatype_clauseContext) +} + +func (s *External_table_fields_clauseContext) AllExternal_table_init_clause() []IExternal_table_init_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_init_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_init_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_init_clauseContext); ok { + tst[i] = t.(IExternal_table_init_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_fields_clauseContext) External_table_init_clause(i int) IExternal_table_init_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_init_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_init_clauseContext) +} + +func (s *External_table_fields_clauseContext) AllExternal_table_lls_clause() []IExternal_table_lls_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_lls_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_lls_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_lls_clauseContext); ok { + tst[i] = t.(IExternal_table_lls_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_fields_clauseContext) External_table_lls_clause(i int) IExternal_table_lls_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_lls_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_lls_clauseContext) +} + +func (s *External_table_fields_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_fields_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_fields_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_fields_clause(s) + } +} + +func (s *External_table_fields_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_fields_clause(s) + } +} + +func (p *PlSqlParser) External_table_fields_clause() (localctx IExternal_table_fields_clauseContext) { + localctx = NewExternal_table_fields_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1236, PlSqlParserRULE_external_table_fields_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12265) + p.External_table_field() + } + p.SetState(12272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1539, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(12270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPOSITION, PlSqlParserLEFT_PAREN: + { + p.SetState(12266) + p.External_table_position_clause() + } + + case PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_FLOAT, PlSqlParserCHAR, PlSqlParserDECIMAL, PlSqlParserDOUBLE, PlSqlParserFLOAT, PlSqlParserINTEGER, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserRAW, PlSqlParserUNSIGNED, PlSqlParserVARCHAR, PlSqlParserVARCHARC, PlSqlParserVARRAW, PlSqlParserVARRAWC, PlSqlParserZONED: + { + p.SetState(12267) + p.External_table_datatype_clause() + } + + case PlSqlParserDEFAULTIF, PlSqlParserNULLIF: + { + p.SetState(12268) + p.External_table_init_clause() + } + + case PlSqlParserLLS: + { + p.SetState(12269) + p.External_table_lls_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(12274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1539, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_position_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_position_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + BINDVAR() antlr.TerminalNode + POSITION() antlr.TerminalNode + COLON() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllPLUS_SIGN() []antlr.TerminalNode + PLUS_SIGN(i int) antlr.TerminalNode + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + + // IsExternal_table_position_clauseContext differentiates from other interfaces. + IsExternal_table_position_clauseContext() +} + +type External_table_position_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_position_clauseContext() *External_table_position_clauseContext { + var p = new(External_table_position_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_position_clause + return p +} + +func InitEmptyExternal_table_position_clauseContext(p *External_table_position_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_position_clause +} + +func (*External_table_position_clauseContext) IsExternal_table_position_clauseContext() {} + +func NewExternal_table_position_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_position_clauseContext { + var p = new(External_table_position_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_position_clause + + return p +} + +func (s *External_table_position_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_position_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_position_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_position_clauseContext) BINDVAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDVAR, 0) +} + +func (s *External_table_position_clauseContext) POSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITION, 0) +} + +func (s *External_table_position_clauseContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *External_table_position_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *External_table_position_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *External_table_position_clauseContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *External_table_position_clauseContext) AllPLUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPLUS_SIGN) +} + +func (s *External_table_position_clauseContext) PLUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, i) +} + +func (s *External_table_position_clauseContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *External_table_position_clauseContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *External_table_position_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_position_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_position_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_position_clause(s) + } +} + +func (s *External_table_position_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_position_clause(s) + } +} + +func (p *PlSqlParser) External_table_position_clause() (localctx IExternal_table_position_clauseContext) { + localctx = NewExternal_table_position_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1238, PlSqlParserRULE_external_table_position_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOSITION { + { + p.SetState(12275) + p.Match(PlSqlParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12278) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(12280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASTERISK { + { + p.SetState(12279) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN { + { + p.SetState(12282) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(12286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(12285) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(12294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINDVAR: + { + p.SetState(12288) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLON: + { + p.SetState(12289) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN { + { + p.SetState(12290) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12293) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12296) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_datatype_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_datatype_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTEGER() antlr.TerminalNode + UNSIGNED() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + External_table_delimit_clause() IExternal_table_delimit_clauseContext + DECIMAL() antlr.TerminalNode + ZONED() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + COMMA() antlr.TerminalNode + ORACLE_DATE() antlr.TerminalNode + ORACLE_NUMBER() antlr.TerminalNode + COUNTED() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + RAW() antlr.TerminalNode + CHAR() antlr.TerminalNode + External_table_trim_clause() IExternal_table_trim_clauseContext + External_table_date_format_clause() IExternal_table_date_format_clauseContext + VARCHAR() antlr.TerminalNode + VARRAW() antlr.TerminalNode + VARCHARC() antlr.TerminalNode + VARRAWC() antlr.TerminalNode + + // IsExternal_table_datatype_clauseContext differentiates from other interfaces. + IsExternal_table_datatype_clauseContext() +} + +type External_table_datatype_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_datatype_clauseContext() *External_table_datatype_clauseContext { + var p = new(External_table_datatype_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_datatype_clause + return p +} + +func InitEmptyExternal_table_datatype_clauseContext(p *External_table_datatype_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_datatype_clause +} + +func (*External_table_datatype_clauseContext) IsExternal_table_datatype_clauseContext() {} + +func NewExternal_table_datatype_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_datatype_clauseContext { + var p = new(External_table_datatype_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_datatype_clause + + return p +} + +func (s *External_table_datatype_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_datatype_clauseContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *External_table_datatype_clauseContext) UNSIGNED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED, 0) +} + +func (s *External_table_datatype_clauseContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *External_table_datatype_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *External_table_datatype_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *External_table_datatype_clauseContext) External_table_delimit_clause() IExternal_table_delimit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_delimit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_delimit_clauseContext) +} + +func (s *External_table_datatype_clauseContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *External_table_datatype_clauseContext) ZONED() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONED, 0) +} + +func (s *External_table_datatype_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_datatype_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_datatype_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *External_table_datatype_clauseContext) ORACLE_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATE, 0) +} + +func (s *External_table_datatype_clauseContext) ORACLE_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_NUMBER, 0) +} + +func (s *External_table_datatype_clauseContext) COUNTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNTED, 0) +} + +func (s *External_table_datatype_clauseContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *External_table_datatype_clauseContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *External_table_datatype_clauseContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *External_table_datatype_clauseContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *External_table_datatype_clauseContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *External_table_datatype_clauseContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *External_table_datatype_clauseContext) External_table_trim_clause() IExternal_table_trim_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_trim_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_trim_clauseContext) +} + +func (s *External_table_datatype_clauseContext) External_table_date_format_clause() IExternal_table_date_format_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_date_format_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_date_format_clauseContext) +} + +func (s *External_table_datatype_clauseContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *External_table_datatype_clauseContext) VARRAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAW, 0) +} + +func (s *External_table_datatype_clauseContext) VARCHARC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHARC, 0) +} + +func (s *External_table_datatype_clauseContext) VARRAWC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAWC, 0) +} + +func (s *External_table_datatype_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_datatype_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_datatype_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_datatype_clause(s) + } +} + +func (s *External_table_datatype_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_datatype_clause(s) + } +} + +func (p *PlSqlParser) External_table_datatype_clause() (localctx IExternal_table_datatype_clauseContext) { + localctx = NewExternal_table_datatype_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1240, PlSqlParserRULE_external_table_datatype_clause) + var _la int + + p.SetState(12387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTEGER, PlSqlParserUNSIGNED: + p.EnterOuterAlt(localctx, 1) + p.SetState(12299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED { + { + p.SetState(12298) + p.Match(PlSqlParserUNSIGNED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12301) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12303) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1547, p.GetParserRuleContext()) == 1 { + { + p.SetState(12302) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(12305) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12308) + p.External_table_delimit_clause() + } + + } + + case PlSqlParserDECIMAL, PlSqlParserZONED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12311) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECIMAL || _la == PlSqlParserZONED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(12312) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12313) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(12314) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12315) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12318) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTERNAL: + { + p.SetState(12319) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12323) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1551, p.GetParserRuleContext()) == 1 { + { + p.SetState(12320) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12321) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12322) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12325) + p.External_table_delimit_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserORACLE_DATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12330) + p.Match(PlSqlParserORACLE_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORACLE_NUMBER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12331) + p.Match(PlSqlParserORACLE_NUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOUNTED { + { + p.SetState(12332) + p.Match(PlSqlParserCOUNTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFLOAT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12335) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12337) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1555, p.GetParserRuleContext()) == 1 { + { + p.SetState(12336) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(12339) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12342) + p.External_table_delimit_clause() + } + + } + + case PlSqlParserDOUBLE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12345) + p.Match(PlSqlParserDOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_FLOAT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12346) + p.Match(PlSqlParserBINARY_FLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12348) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1558, p.GetParserRuleContext()) == 1 { + { + p.SetState(12347) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(12350) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12353) + p.External_table_delimit_clause() + } + + } + + case PlSqlParserBINARY_DOUBLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12356) + p.Match(PlSqlParserBINARY_DOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRAW: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12357) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(12358) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCHAR: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12361) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12363) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1562, p.GetParserRuleContext()) == 1 { + { + p.SetState(12362) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12368) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1563, p.GetParserRuleContext()) == 1 { + { + p.SetState(12365) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12366) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12367) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12370) + p.External_table_delimit_clause() + } + + } + p.SetState(12374) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1565, p.GetParserRuleContext()) == 1 { + { + p.SetState(12373) + p.External_table_trim_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12377) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1566, p.GetParserRuleContext()) == 1 { + { + p.SetState(12376) + p.External_table_date_format_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserVARCHAR, PlSqlParserVARCHARC, PlSqlParserVARRAW, PlSqlParserVARRAWC: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12379) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2260)) & ^0x3f) == 0 && ((int64(1)<<(_la-2260))&27) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12380) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12383) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1567, p.GetParserRuleContext()) == 1 { + { + p.SetState(12381) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12382) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12385) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12386) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_delimit_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_delimit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCLOSED() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + AND() antlr.TerminalNode + TERMINATED() antlr.TerminalNode + WHITESPACE() antlr.TerminalNode + OPTIONALLY() antlr.TerminalNode + + // IsExternal_table_delimit_clauseContext differentiates from other interfaces. + IsExternal_table_delimit_clauseContext() +} + +type External_table_delimit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_delimit_clauseContext() *External_table_delimit_clauseContext { + var p = new(External_table_delimit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_delimit_clause + return p +} + +func InitEmptyExternal_table_delimit_clauseContext(p *External_table_delimit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_delimit_clause +} + +func (*External_table_delimit_clauseContext) IsExternal_table_delimit_clauseContext() {} + +func NewExternal_table_delimit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_delimit_clauseContext { + var p = new(External_table_delimit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_delimit_clause + + return p +} + +func (s *External_table_delimit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_delimit_clauseContext) ENCLOSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCLOSED, 0) +} + +func (s *External_table_delimit_clauseContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *External_table_delimit_clauseContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *External_table_delimit_clauseContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *External_table_delimit_clauseContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_delimit_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *External_table_delimit_clauseContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERMINATED, 0) +} + +func (s *External_table_delimit_clauseContext) WHITESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHITESPACE, 0) +} + +func (s *External_table_delimit_clauseContext) OPTIONALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIONALLY, 0) +} + +func (s *External_table_delimit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_delimit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_delimit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_delimit_clause(s) + } +} + +func (s *External_table_delimit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_delimit_clause(s) + } +} + +func (p *PlSqlParser) External_table_delimit_clause() (localctx IExternal_table_delimit_clauseContext) { + localctx = NewExternal_table_delimit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1242, PlSqlParserRULE_external_table_delimit_clause) + var _la int + + p.SetState(12414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCLOSED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12389) + p.Match(PlSqlParserENCLOSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12390) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12391) + p.Quoted_string() + } + p.SetState(12394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(12392) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12393) + p.Quoted_string() + } + + } + + case PlSqlParserTERMINATED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12396) + p.Match(PlSqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12397) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(12398) + p.Quoted_string() + } + + case PlSqlParserWHITESPACE: + { + p.SetState(12399) + p.Match(PlSqlParserWHITESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserOPTIONALLY { + p.SetState(12403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOPTIONALLY { + { + p.SetState(12402) + p.Match(PlSqlParserOPTIONALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12405) + p.Match(PlSqlParserENCLOSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12406) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12407) + p.Quoted_string() + } + p.SetState(12410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(12408) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12409) + p.Quoted_string() + } + + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_trim_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_trim_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LRTRIM() antlr.TerminalNode + NOTRIM() antlr.TerminalNode + LTRIM() antlr.TerminalNode + RTRIM() antlr.TerminalNode + LDRTRIM() antlr.TerminalNode + + // IsExternal_table_trim_clauseContext differentiates from other interfaces. + IsExternal_table_trim_clauseContext() +} + +type External_table_trim_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_trim_clauseContext() *External_table_trim_clauseContext { + var p = new(External_table_trim_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_trim_clause + return p +} + +func InitEmptyExternal_table_trim_clauseContext(p *External_table_trim_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_trim_clause +} + +func (*External_table_trim_clauseContext) IsExternal_table_trim_clauseContext() {} + +func NewExternal_table_trim_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_trim_clauseContext { + var p = new(External_table_trim_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_trim_clause + + return p +} + +func (s *External_table_trim_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_trim_clauseContext) LRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLRTRIM, 0) +} + +func (s *External_table_trim_clauseContext) NOTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTRIM, 0) +} + +func (s *External_table_trim_clauseContext) LTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLTRIM, 0) +} + +func (s *External_table_trim_clauseContext) RTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRTRIM, 0) +} + +func (s *External_table_trim_clauseContext) LDRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDRTRIM, 0) +} + +func (s *External_table_trim_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_trim_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_trim_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_trim_clause(s) + } +} + +func (s *External_table_trim_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_trim_clause(s) + } +} + +func (p *PlSqlParser) External_table_trim_clause() (localctx IExternal_table_trim_clauseContext) { + localctx = NewExternal_table_trim_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1244, PlSqlParserRULE_external_table_trim_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12416) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLDRTRIM || _la == PlSqlParserLRTRIM || _la == PlSqlParserLTRIM || _la == PlSqlParserNOTRIM || _la == PlSqlParserRTRIM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_date_format_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_date_format_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATE() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + MASK() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + INTERVAL() antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + YEAR_TO_MONTH() antlr.TerminalNode + DAY_TO_SECOND() antlr.TerminalNode + WITH() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsExternal_table_date_format_clauseContext differentiates from other interfaces. + IsExternal_table_date_format_clauseContext() +} + +type External_table_date_format_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_date_format_clauseContext() *External_table_date_format_clauseContext { + var p = new(External_table_date_format_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_date_format_clause + return p +} + +func InitEmptyExternal_table_date_format_clauseContext(p *External_table_date_format_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_date_format_clause +} + +func (*External_table_date_format_clauseContext) IsExternal_table_date_format_clauseContext() {} + +func NewExternal_table_date_format_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_date_format_clauseContext { + var p = new(External_table_date_format_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_date_format_clause + + return p +} + +func (s *External_table_date_format_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_date_format_clauseContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *External_table_date_format_clauseContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *External_table_date_format_clauseContext) MASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASK, 0) +} + +func (s *External_table_date_format_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_date_format_clauseContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *External_table_date_format_clauseContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_FORMAT, 0) +} + +func (s *External_table_date_format_clauseContext) YEAR_TO_MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR_TO_MONTH, 0) +} + +func (s *External_table_date_format_clauseContext) DAY_TO_SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY_TO_SECOND, 0) +} + +func (s *External_table_date_format_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *External_table_date_format_clauseContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *External_table_date_format_clauseContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *External_table_date_format_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *External_table_date_format_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_date_format_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_date_format_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_date_format_clause(s) + } +} + +func (s *External_table_date_format_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_date_format_clause(s) + } +} + +func (p *PlSqlParser) External_table_date_format_clause() (localctx IExternal_table_date_format_clauseContext) { + localctx = NewExternal_table_date_format_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1246, PlSqlParserRULE_external_table_date_format_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATE_FORMAT { + { + p.SetState(12418) + p.Match(PlSqlParserDATE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATE: + { + p.SetState(12421) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP: + { + p.SetState(12422) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(12423) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(12424) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12427) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12428) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12431) + p.Match(PlSqlParserMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12432) + p.Quoted_string() + } + + case PlSqlParserINTERVAL: + { + p.SetState(12433) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12434) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY_TO_SECOND || _la == PlSqlParserYEAR_TO_MONTH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_init_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_init_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + External_table_condition_clause() IExternal_table_condition_clauseContext + DEFAULTIF() antlr.TerminalNode + NULLIF() antlr.TerminalNode + + // IsExternal_table_init_clauseContext differentiates from other interfaces. + IsExternal_table_init_clauseContext() +} + +type External_table_init_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_init_clauseContext() *External_table_init_clauseContext { + var p = new(External_table_init_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_init_clause + return p +} + +func InitEmptyExternal_table_init_clauseContext(p *External_table_init_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_init_clause +} + +func (*External_table_init_clauseContext) IsExternal_table_init_clauseContext() {} + +func NewExternal_table_init_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_init_clauseContext { + var p = new(External_table_init_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_init_clause + + return p +} + +func (s *External_table_init_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_init_clauseContext) External_table_condition_clause() IExternal_table_condition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_condition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_condition_clauseContext) +} + +func (s *External_table_init_clauseContext) DEFAULTIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTIF, 0) +} + +func (s *External_table_init_clauseContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *External_table_init_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_init_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_init_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_init_clause(s) + } +} + +func (s *External_table_init_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_init_clause(s) + } +} + +func (p *PlSqlParser) External_table_init_clause() (localctx IExternal_table_init_clauseContext) { + localctx = NewExternal_table_init_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1248, PlSqlParserRULE_external_table_init_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12437) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULTIF || _la == PlSqlParserNULLIF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12438) + p.external_table_condition_clause(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_condition_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_condition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Relational_operator() IRelational_operatorContext + Field_spec() IField_specContext + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + BINDVAR() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + HEX_STRING_LIT() antlr.TerminalNode + BLANKS() antlr.TerminalNode + AllExternal_table_condition_clause() []IExternal_table_condition_clauseContext + External_table_condition_clause(i int) IExternal_table_condition_clauseContext + AND() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsExternal_table_condition_clauseContext differentiates from other interfaces. + IsExternal_table_condition_clauseContext() +} + +type External_table_condition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_condition_clauseContext() *External_table_condition_clauseContext { + var p = new(External_table_condition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_condition_clause + return p +} + +func InitEmptyExternal_table_condition_clauseContext(p *External_table_condition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_condition_clause +} + +func (*External_table_condition_clauseContext) IsExternal_table_condition_clauseContext() {} + +func NewExternal_table_condition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_condition_clauseContext { + var p = new(External_table_condition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_condition_clause + + return p +} + +func (s *External_table_condition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_condition_clauseContext) Relational_operator() IRelational_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_operatorContext) +} + +func (s *External_table_condition_clauseContext) Field_spec() IField_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_specContext) +} + +func (s *External_table_condition_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_condition_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *External_table_condition_clauseContext) BINDVAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDVAR, 0) +} + +func (s *External_table_condition_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_condition_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_condition_clauseContext) HEX_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEX_STRING_LIT, 0) +} + +func (s *External_table_condition_clauseContext) BLANKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLANKS, 0) +} + +func (s *External_table_condition_clauseContext) AllExternal_table_condition_clause() []IExternal_table_condition_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_condition_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_condition_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_condition_clauseContext); ok { + tst[i] = t.(IExternal_table_condition_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_condition_clauseContext) External_table_condition_clause(i int) IExternal_table_condition_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_condition_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_condition_clauseContext) +} + +func (s *External_table_condition_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *External_table_condition_clauseContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *External_table_condition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_condition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_condition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_condition_clause(s) + } +} + +func (s *External_table_condition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_condition_clause(s) + } +} + +func (p *PlSqlParser) External_table_condition_clause() (localctx IExternal_table_condition_clauseContext) { + return p.external_table_condition_clause(0) +} + +func (p *PlSqlParser) external_table_condition_clause(_p int) (localctx IExternal_table_condition_clauseContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExternal_table_condition_clauseContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExternal_table_condition_clauseContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1250 + p.EnterRecursionRule(localctx, 1250, PlSqlParserRULE_external_table_condition_clause, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(12441) + p.Field_spec() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(12442) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12443) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12444) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12445) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12448) + p.Relational_operator() + } + p.SetState(12452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(12449) + p.Quoted_string() + } + + case PlSqlParserHEX_STRING_LIT: + { + p.SetState(12450) + p.Match(PlSqlParserHEX_STRING_LIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLANKS: + { + p.SetState(12451) + p.Match(PlSqlParserBLANKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(12459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1581, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewExternal_table_condition_clauseContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_external_table_condition_clause) + p.SetState(12454) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(12455) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAND || _la == PlSqlParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12456) + p.external_table_condition_clause(2) + } + + } + p.SetState(12461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1581, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_lls_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_lls_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LLS() antlr.TerminalNode + External_table_directory() IExternal_table_directoryContext + + // IsExternal_table_lls_clauseContext differentiates from other interfaces. + IsExternal_table_lls_clauseContext() +} + +type External_table_lls_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_lls_clauseContext() *External_table_lls_clauseContext { + var p = new(External_table_lls_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_lls_clause + return p +} + +func InitEmptyExternal_table_lls_clauseContext(p *External_table_lls_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_lls_clause +} + +func (*External_table_lls_clauseContext) IsExternal_table_lls_clauseContext() {} + +func NewExternal_table_lls_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_lls_clauseContext { + var p = new(External_table_lls_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_lls_clause + + return p +} + +func (s *External_table_lls_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_lls_clauseContext) LLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLLS, 0) +} + +func (s *External_table_lls_clauseContext) External_table_directory() IExternal_table_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_lls_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_lls_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_lls_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_lls_clause(s) + } +} + +func (s *External_table_lls_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_lls_clause(s) + } +} + +func (p *PlSqlParser) External_table_lls_clause() (localctx IExternal_table_lls_clauseContext) { + localctx = NewExternal_table_lls_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1252, PlSqlParserRULE_external_table_lls_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12462) + p.Match(PlSqlParserLLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12463) + p.External_table_directory() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_recordsContext is an interface to support dynamic dispatch. +type IExternal_table_recordsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORDS() antlr.TerminalNode + FIXED() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + DELIMITED() antlr.TerminalNode + BY() antlr.TerminalNode + XMLTAG() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllExternal_table_record_options_clause() []IExternal_table_record_options_clauseContext + External_table_record_options_clause(i int) IExternal_table_record_options_clauseContext + NEWLINE_() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + LEFT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DETECTED() antlr.TerminalNode + + // IsExternal_table_recordsContext differentiates from other interfaces. + IsExternal_table_recordsContext() +} + +type External_table_recordsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_recordsContext() *External_table_recordsContext { + var p = new(External_table_recordsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_records + return p +} + +func InitEmptyExternal_table_recordsContext(p *External_table_recordsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_records +} + +func (*External_table_recordsContext) IsExternal_table_recordsContext() {} + +func NewExternal_table_recordsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_recordsContext { + var p = new(External_table_recordsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_records + + return p +} + +func (s *External_table_recordsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_recordsContext) RECORDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS, 0) +} + +func (s *External_table_recordsContext) FIXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIXED, 0) +} + +func (s *External_table_recordsContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *External_table_recordsContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *External_table_recordsContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED, 0) +} + +func (s *External_table_recordsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *External_table_recordsContext) XMLTAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTAG, 0) +} + +func (s *External_table_recordsContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *External_table_recordsContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *External_table_recordsContext) AllExternal_table_record_options_clause() []IExternal_table_record_options_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_record_options_clauseContext); ok { + len++ + } + } + + tst := make([]IExternal_table_record_options_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_record_options_clauseContext); ok { + tst[i] = t.(IExternal_table_record_options_clauseContext) + i++ + } + } + + return tst +} + +func (s *External_table_recordsContext) External_table_record_options_clause(i int) IExternal_table_record_options_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_record_options_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_record_options_clauseContext) +} + +func (s *External_table_recordsContext) NEWLINE_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEWLINE_, 0) +} + +func (s *External_table_recordsContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_recordsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_recordsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_recordsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_recordsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_recordsContext) DETECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETECTED, 0) +} + +func (s *External_table_recordsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_recordsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_recordsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_records(s) + } +} + +func (s *External_table_recordsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_records(s) + } +} + +func (p *PlSqlParser) External_table_records() (localctx IExternal_table_recordsContext) { + localctx = NewExternal_table_recordsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1254, PlSqlParserRULE_external_table_records) + var _la int + + var _alt int + + p.SetState(12507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRECORDS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12465) + p.Match(PlSqlParserRECORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFIXED: + { + p.SetState(12466) + p.Match(PlSqlParserFIXED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12467) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARIABLE: + { + p.SetState(12468) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12469) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDELIMITED: + { + p.SetState(12470) + p.Match(PlSqlParserDELIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12471) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDETECTED, PlSqlParserNEWLINE_: + p.SetState(12473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDETECTED { + { + p.SetState(12472) + p.Match(PlSqlParserDETECTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12475) + p.Match(PlSqlParserNEWLINE_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(12476) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserXMLTAG: + { + p.SetState(12479) + p.Match(PlSqlParserXMLTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12480) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12483) + p.Id_expression() + } + p.SetState(12488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12484) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12485) + p.Id_expression() + } + + p.SetState(12490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(12492) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1586, p.GetParserRuleContext()) == 1 { + { + p.SetState(12491) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1588, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(12496) + p.External_table_record_options_clause() + } + + } + p.SetState(12501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1588, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserBADFILE, PlSqlParserBYTEORDERMARK, PlSqlParserCHARACTERSET, PlSqlParserDATA, PlSqlParserDATE_CACHE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDISCARDFILE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserEXTERNAL, PlSqlParserIO_OPTIONS, PlSqlParserLOAD, PlSqlParserLOGFILE, PlSqlParserNOBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserPREPROCESSOR, PlSqlParserREADSIZE, PlSqlParserSKIP_, PlSqlParserSTRING: + p.EnterOuterAlt(localctx, 2) + p.SetState(12503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(12502) + p.External_table_record_options_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12505) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1589, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_record_options_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_record_options_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHARACTERSET() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + EXTERNAL() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + DATA() antlr.TerminalNode + PREPROCESSOR() antlr.TerminalNode + External_table_directory() IExternal_table_directoryContext + IS() antlr.TerminalNode + ENDIAN() antlr.TerminalNode + LITTLE() antlr.TerminalNode + BIG() antlr.TerminalNode + BYTEORDERMARK() antlr.TerminalNode + CHECK() antlr.TerminalNode + NOCHECK() antlr.TerminalNode + STRING() antlr.TerminalNode + SIZES() antlr.TerminalNode + ARE() antlr.TerminalNode + IN() antlr.TerminalNode + BYTES() antlr.TerminalNode + CHARACTERS() antlr.TerminalNode + LOAD() antlr.TerminalNode + WHEN() antlr.TerminalNode + External_table_condition_clause() IExternal_table_condition_clauseContext + External_table_output_files() IExternal_table_output_filesContext + READSIZE() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode + DATE_CACHE() antlr.TerminalNode + SKIP_() antlr.TerminalNode + IO_OPTIONS() antlr.TerminalNode + DIRECTIO() antlr.TerminalNode + NODIRECTIO() antlr.TerminalNode + DNFS_ENABLE() antlr.TerminalNode + DNFS_DISABLE() antlr.TerminalNode + DNFS_READBUFFERS() antlr.TerminalNode + + // IsExternal_table_record_options_clauseContext differentiates from other interfaces. + IsExternal_table_record_options_clauseContext() +} + +type External_table_record_options_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_record_options_clauseContext() *External_table_record_options_clauseContext { + var p = new(External_table_record_options_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_record_options_clause + return p +} + +func InitEmptyExternal_table_record_options_clauseContext(p *External_table_record_options_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_record_options_clause +} + +func (*External_table_record_options_clauseContext) IsExternal_table_record_options_clauseContext() {} + +func NewExternal_table_record_options_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_record_options_clauseContext { + var p = new(External_table_record_options_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_record_options_clause + + return p +} + +func (s *External_table_record_options_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_record_options_clauseContext) CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERSET, 0) +} + +func (s *External_table_record_options_clauseContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *External_table_record_options_clauseContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *External_table_record_options_clauseContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *External_table_record_options_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *External_table_record_options_clauseContext) PREPROCESSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPROCESSOR, 0) +} + +func (s *External_table_record_options_clauseContext) External_table_directory() IExternal_table_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_record_options_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *External_table_record_options_clauseContext) ENDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserENDIAN, 0) +} + +func (s *External_table_record_options_clauseContext) LITTLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLITTLE, 0) +} + +func (s *External_table_record_options_clauseContext) BIG() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIG, 0) +} + +func (s *External_table_record_options_clauseContext) BYTEORDERMARK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTEORDERMARK, 0) +} + +func (s *External_table_record_options_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *External_table_record_options_clauseContext) NOCHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCHECK, 0) +} + +func (s *External_table_record_options_clauseContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *External_table_record_options_clauseContext) SIZES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZES, 0) +} + +func (s *External_table_record_options_clauseContext) ARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARE, 0) +} + +func (s *External_table_record_options_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *External_table_record_options_clauseContext) BYTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTES, 0) +} + +func (s *External_table_record_options_clauseContext) CHARACTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERS, 0) +} + +func (s *External_table_record_options_clauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *External_table_record_options_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *External_table_record_options_clauseContext) External_table_condition_clause() IExternal_table_condition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_condition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_condition_clauseContext) +} + +func (s *External_table_record_options_clauseContext) External_table_output_files() IExternal_table_output_filesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_output_filesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_output_filesContext) +} + +func (s *External_table_record_options_clauseContext) READSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREADSIZE, 0) +} + +func (s *External_table_record_options_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *External_table_record_options_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *External_table_record_options_clauseContext) DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, 0) +} + +func (s *External_table_record_options_clauseContext) DATE_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_CACHE, 0) +} + +func (s *External_table_record_options_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *External_table_record_options_clauseContext) IO_OPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIO_OPTIONS, 0) +} + +func (s *External_table_record_options_clauseContext) DIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTIO, 0) +} + +func (s *External_table_record_options_clauseContext) NODIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODIRECTIO, 0) +} + +func (s *External_table_record_options_clauseContext) DNFS_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_ENABLE, 0) +} + +func (s *External_table_record_options_clauseContext) DNFS_DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_DISABLE, 0) +} + +func (s *External_table_record_options_clauseContext) DNFS_READBUFFERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_READBUFFERS, 0) +} + +func (s *External_table_record_options_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_record_options_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_record_options_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_record_options_clause(s) + } +} + +func (s *External_table_record_options_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_record_options_clause(s) + } +} + +func (p *PlSqlParser) External_table_record_options_clause() (localctx IExternal_table_record_options_clauseContext) { + localctx = NewExternal_table_record_options_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1256, PlSqlParserRULE_external_table_record_options_clause) + var _la int + + p.SetState(12546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHARACTERSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12509) + p.Match(PlSqlParserCHARACTERSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12510) + p.Char_set_name() + } + + case PlSqlParserEXTERNAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12511) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12512) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12513) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPREPROCESSOR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12514) + p.Match(PlSqlParserPREPROCESSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12515) + p.External_table_directory() + } + + case PlSqlParserDATA: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12516) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12517) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12518) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIG || _la == PlSqlParserLITTLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12519) + p.Match(PlSqlParserENDIAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBYTEORDERMARK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12520) + p.Match(PlSqlParserBYTEORDERMARK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12521) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCHECK || _la == PlSqlParserNOCHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserSTRING: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12522) + p.Match(PlSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12523) + p.Match(PlSqlParserSIZES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12524) + p.Match(PlSqlParserARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12525) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12526) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTES || _la == PlSqlParserCHARACTERS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLOAD: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12527) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12528) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12529) + p.external_table_condition_clause(0) + } + + case PlSqlParserBADFILE, PlSqlParserDISCARDFILE, PlSqlParserLOGFILE, PlSqlParserNOBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserNOLOGFILE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12530) + p.External_table_output_files() + } + + case PlSqlParserREADSIZE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12531) + p.Match(PlSqlParserREADSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEQUALS_OP { + { + p.SetState(12532) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12535) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE_DIRECTORY_LINK_CHECK: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12536) + p.Match(PlSqlParserDISABLE_DIRECTORY_LINK_CHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATE_CACHE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12537) + p.Match(PlSqlParserDATE_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12538) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSKIP_: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(12539) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12540) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserIO_OPTIONS: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(12541) + p.Match(PlSqlParserIO_OPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12542) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDIRECTIO || _la == PlSqlParserNODIRECTIO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_ENABLE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(12543) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDNFS_DISABLE || _la == PlSqlParserDNFS_ENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDNFS_READBUFFERS: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(12544) + p.Match(PlSqlParserDNFS_READBUFFERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12545) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_output_filesContext is an interface to support dynamic dispatch. +type IExternal_table_output_filesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Filename() IFilenameContext + NOBADFILE() antlr.TerminalNode + NODISCARDFILE() antlr.TerminalNode + NOLOGFILE() antlr.TerminalNode + BADFILE() antlr.TerminalNode + DISCARDFILE() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + External_table_directory() IExternal_table_directoryContext + + // IsExternal_table_output_filesContext differentiates from other interfaces. + IsExternal_table_output_filesContext() +} + +type External_table_output_filesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_output_filesContext() *External_table_output_filesContext { + var p = new(External_table_output_filesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_output_files + return p +} + +func InitEmptyExternal_table_output_filesContext(p *External_table_output_filesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_output_files +} + +func (*External_table_output_filesContext) IsExternal_table_output_filesContext() {} + +func NewExternal_table_output_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_output_filesContext { + var p = new(External_table_output_filesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_output_files + + return p +} + +func (s *External_table_output_filesContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_output_filesContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *External_table_output_filesContext) NOBADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOBADFILE, 0) +} + +func (s *External_table_output_filesContext) NODISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODISCARDFILE, 0) +} + +func (s *External_table_output_filesContext) NOLOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGFILE, 0) +} + +func (s *External_table_output_filesContext) BADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBADFILE, 0) +} + +func (s *External_table_output_filesContext) DISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCARDFILE, 0) +} + +func (s *External_table_output_filesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *External_table_output_filesContext) External_table_directory() IExternal_table_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_output_filesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_output_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_output_filesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_output_files(s) + } +} + +func (s *External_table_output_filesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_output_files(s) + } +} + +func (p *PlSqlParser) External_table_output_files() (localctx IExternal_table_output_filesContext) { + localctx = NewExternal_table_output_filesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1258, PlSqlParserRULE_external_table_output_files) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserNOLOGFILE: + { + p.SetState(12548) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1060)) & ^0x3f) == 0 && ((int64(1)<<(_la-1060))&288230376688582657) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserBADFILE, PlSqlParserDISCARDFILE, PlSqlParserLOGFILE: + { + p.SetState(12549) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBADFILE || _la == PlSqlParserDISCARDFILE || _la == PlSqlParserLOGFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12551) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1593, p.GetParserRuleContext()) == 1 { + { + p.SetState(12550) + p.External_table_directory() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12553) + p.Filename() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_fieldsContext is an interface to support dynamic dispatch. +type IExternal_table_fieldsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFIELDS() []antlr.TerminalNode + FIELDS(i int) antlr.TerminalNode + IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode + CSV() antlr.TerminalNode + EMBEDDED() antlr.TerminalNode + External_table_delimit_clause() IExternal_table_delimit_clauseContext + External_table_trim_clause() IExternal_table_trim_clauseContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + THESE() antlr.TerminalNode + MISSING() antlr.TerminalNode + FIELD() antlr.TerminalNode + VALUES() antlr.TerminalNode + ARE() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + REJECT() antlr.TerminalNode + ROWS() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + MASK() antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + NULLIF() antlr.TerminalNode + NONULLIF() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + External_table_field_list() IExternal_table_field_listContext + RIGHT_PAREN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + DATE() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + NOT_EQUAL_OP() antlr.TerminalNode + HEX_STRING_LIT() antlr.TerminalNode + BLANKS() antlr.TerminalNode + + // IsExternal_table_fieldsContext differentiates from other interfaces. + IsExternal_table_fieldsContext() +} + +type External_table_fieldsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_fieldsContext() *External_table_fieldsContext { + var p = new(External_table_fieldsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_fields + return p +} + +func InitEmptyExternal_table_fieldsContext(p *External_table_fieldsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_fields +} + +func (*External_table_fieldsContext) IsExternal_table_fieldsContext() {} + +func NewExternal_table_fieldsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_fieldsContext { + var p = new(External_table_fieldsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_fields + + return p +} + +func (s *External_table_fieldsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_fieldsContext) AllFIELDS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFIELDS) +} + +func (s *External_table_fieldsContext) FIELDS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, i) +} + +func (s *External_table_fieldsContext) IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_CHARS_AFTER_EOR, 0) +} + +func (s *External_table_fieldsContext) CSV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCSV, 0) +} + +func (s *External_table_fieldsContext) EMBEDDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMBEDDED, 0) +} + +func (s *External_table_fieldsContext) External_table_delimit_clause() IExternal_table_delimit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_delimit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_delimit_clauseContext) +} + +func (s *External_table_fieldsContext) External_table_trim_clause() IExternal_table_trim_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_trim_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_trim_clauseContext) +} + +func (s *External_table_fieldsContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *External_table_fieldsContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *External_table_fieldsContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDE, 0) +} + +func (s *External_table_fieldsContext) THESE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHESE, 0) +} + +func (s *External_table_fieldsContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *External_table_fieldsContext) FIELD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD, 0) +} + +func (s *External_table_fieldsContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *External_table_fieldsContext) ARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARE, 0) +} + +func (s *External_table_fieldsContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *External_table_fieldsContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *External_table_fieldsContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *External_table_fieldsContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *External_table_fieldsContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *External_table_fieldsContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *External_table_fieldsContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_FORMAT, 0) +} + +func (s *External_table_fieldsContext) MASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASK, 0) +} + +func (s *External_table_fieldsContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *External_table_fieldsContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_fieldsContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *External_table_fieldsContext) NONULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONULLIF, 0) +} + +func (s *External_table_fieldsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_fieldsContext) External_table_field_list() IExternal_table_field_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_field_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_field_listContext) +} + +func (s *External_table_fieldsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_fieldsContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *External_table_fieldsContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *External_table_fieldsContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *External_table_fieldsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *External_table_fieldsContext) NOT_EQUAL_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT_EQUAL_OP, 0) +} + +func (s *External_table_fieldsContext) HEX_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEX_STRING_LIT, 0) +} + +func (s *External_table_fieldsContext) BLANKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLANKS, 0) +} + +func (s *External_table_fieldsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_fieldsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_fieldsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_fields(s) + } +} + +func (s *External_table_fieldsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_fields(s) + } +} + +func (p *PlSqlParser) External_table_fields() (localctx IExternal_table_fieldsContext) { + localctx = NewExternal_table_fieldsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1260, PlSqlParserRULE_external_table_fields) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12556) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE_CHARS_AFTER_EOR { + { + p.SetState(12557) + p.Match(PlSqlParserIGNORE_CHARS_AFTER_EOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCSV { + { + p.SetState(12560) + p.Match(PlSqlParserCSV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12561) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12562) + p.Match(PlSqlParserEMBEDDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12565) + p.External_table_delimit_clause() + } + + } + p.SetState(12569) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1598, p.GetParserRuleContext()) == 1 { + { + p.SetState(12568) + p.External_table_trim_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(12571) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12572) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12573) + p.Match(PlSqlParserOVERRIDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12574) + p.Match(PlSqlParserTHESE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12575) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12583) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1600, p.GetParserRuleContext()) == 1 { + { + p.SetState(12578) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12579) + p.Match(PlSqlParserFIELD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12580) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12581) + p.Match(PlSqlParserARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12582) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12591) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1601, p.GetParserRuleContext()) == 1 { + { + p.SetState(12585) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12586) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12587) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12588) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12589) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12590) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1602, p.GetParserRuleContext()) == 1 { + { + p.SetState(12593) + p.Match(PlSqlParserDATE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12594) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATE || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12595) + p.Match(PlSqlParserMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12596) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12607) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 1 { + { + p.SetState(12599) + p.Match(PlSqlParserNULLIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12600) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOT_EQUAL_OP || _la == PlSqlParserEQUALS_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(12601) + p.Quoted_string() + } + + case PlSqlParserHEX_STRING_LIT: + { + p.SetState(12602) + p.Match(PlSqlParserHEX_STRING_LIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLANKS: + { + p.SetState(12603) + p.Match(PlSqlParserBLANKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 2 { + { + p.SetState(12606) + p.Match(PlSqlParserNONULLIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12609) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12613) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1606, p.GetParserRuleContext()) == 1 { + { + p.SetState(12612) + p.External_table_field_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12616) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1607, p.GetParserRuleContext()) == 1 { + { + p.SetState(12615) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_datapumpContext is an interface to support dynamic dispatch. +type IExternal_table_datapumpContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLED() antlr.TerminalNode + NOLOGFILE() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + Filename() IFilenameContext + External_table_directory() IExternal_table_directoryContext + COMPRESSION() antlr.TerminalNode + ENABLED() antlr.TerminalNode + BASIC() antlr.TerminalNode + LOW() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + HIGH() antlr.TerminalNode + HADOOP_TRAILERS() antlr.TerminalNode + VERSION() antlr.TerminalNode + COMPATIBLE() antlr.TerminalNode + LATEST() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + NOLOG() antlr.TerminalNode + DEBUG() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DATAPUMP() antlr.TerminalNode + INTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + TEMPLATE_TABLE() antlr.TerminalNode + JOB() antlr.TerminalNode + Schema_name() ISchema_nameContext + WORKERID() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + ENCRYPTPASSWORDISNULL() antlr.TerminalNode + DBLINK() antlr.TerminalNode + + // IsExternal_table_datapumpContext differentiates from other interfaces. + IsExternal_table_datapumpContext() +} + +type External_table_datapumpContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_datapumpContext() *External_table_datapumpContext { + var p = new(External_table_datapumpContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_datapump + return p +} + +func InitEmptyExternal_table_datapumpContext(p *External_table_datapumpContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_datapump +} + +func (*External_table_datapumpContext) IsExternal_table_datapumpContext() {} + +func NewExternal_table_datapumpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_datapumpContext { + var p = new(External_table_datapumpContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_datapump + + return p +} + +func (s *External_table_datapumpContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_datapumpContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *External_table_datapumpContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *External_table_datapumpContext) DISABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLED, 0) +} + +func (s *External_table_datapumpContext) NOLOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGFILE, 0) +} + +func (s *External_table_datapumpContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *External_table_datapumpContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *External_table_datapumpContext) External_table_directory() IExternal_table_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_datapumpContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESSION, 0) +} + +func (s *External_table_datapumpContext) ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLED, 0) +} + +func (s *External_table_datapumpContext) BASIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASIC, 0) +} + +func (s *External_table_datapumpContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *External_table_datapumpContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *External_table_datapumpContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *External_table_datapumpContext) HADOOP_TRAILERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHADOOP_TRAILERS, 0) +} + +func (s *External_table_datapumpContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *External_table_datapumpContext) COMPATIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPATIBLE, 0) +} + +func (s *External_table_datapumpContext) LATEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLATEST, 0) +} + +func (s *External_table_datapumpContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_datapumpContext) NOLOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOG, 0) +} + +func (s *External_table_datapumpContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *External_table_datapumpContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *External_table_datapumpContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_datapumpContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *External_table_datapumpContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *External_table_datapumpContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_datapumpContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_datapumpContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_datapumpContext) DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAPUMP, 0) +} + +func (s *External_table_datapumpContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL, 0) +} + +func (s *External_table_datapumpContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *External_table_datapumpContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *External_table_datapumpContext) TEMPLATE_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE_TABLE, 0) +} + +func (s *External_table_datapumpContext) JOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOB, 0) +} + +func (s *External_table_datapumpContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *External_table_datapumpContext) WORKERID() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORKERID, 0) +} + +func (s *External_table_datapumpContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, 0) +} + +func (s *External_table_datapumpContext) ENCRYPTPASSWORDISNULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTPASSWORDISNULL, 0) +} + +func (s *External_table_datapumpContext) DBLINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBLINK, 0) +} + +func (s *External_table_datapumpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_datapumpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_datapumpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_datapump(s) + } +} + +func (s *External_table_datapumpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_datapump(s) + } +} + +func (p *PlSqlParser) External_table_datapump() (localctx IExternal_table_datapumpContext) { + localctx = NewExternal_table_datapumpContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1262, PlSqlParserRULE_external_table_datapump) + var _la int + + p.SetState(12674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12618) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12619) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLED || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNOLOGFILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12620) + p.Match(PlSqlParserNOLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGFILE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12621) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12623) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1608, p.GetParserRuleContext()) == 1 { + { + p.SetState(12622) + p.External_table_directory() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12625) + p.Filename() + } + + case PlSqlParserCOMPRESSION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12626) + p.Match(PlSqlParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12632) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1610, p.GetParserRuleContext()) == 1 { + { + p.SetState(12627) + p.Match(PlSqlParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12629) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1609, p.GetParserRuleContext()) == 1 { + { + p.SetState(12628) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASIC || _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1610, p.GetParserRuleContext()) == 2 { + { + p.SetState(12631) + p.Match(PlSqlParserDISABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserHADOOP_TRAILERS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12634) + p.Match(PlSqlParserHADOOP_TRAILERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12635) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLED || _la == PlSqlParserENABLED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12636) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPATIBLE: + { + p.SetState(12637) + p.Match(PlSqlParserCOMPATIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLATEST: + { + p.SetState(12638) + p.Match(PlSqlParserLATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(12639) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserNOLOG: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12642) + p.Match(PlSqlParserNOLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEBUG: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12643) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12644) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12645) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12646) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12647) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12648) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12649) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATAPUMP: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12650) + p.Match(PlSqlParserDATAPUMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12651) + p.Match(PlSqlParserINTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12652) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12653) + p.Tableview_name() + } + + case PlSqlParserTEMPLATE_TABLE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12654) + p.Match(PlSqlParserTEMPLATE_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12655) + p.Tableview_name() + } + + case PlSqlParserJOB: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12656) + p.Match(PlSqlParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12657) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12658) + p.Schema_name() + } + { + p.SetState(12659) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12660) + p.Tableview_name() + } + { + p.SetState(12661) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12662) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12663) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWORKERID: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12665) + p.Match(PlSqlParserWORKERID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12666) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARALLEL: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(12667) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12668) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVERSION: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(12669) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12670) + p.Quoted_string() + } + + case PlSqlParserENCRYPTPASSWORDISNULL: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(12671) + p.Match(PlSqlParserENCRYPTPASSWORDISNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDBLINK: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(12672) + p.Match(PlSqlParserDBLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12673) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_hiveContext is an interface to support dynamic dispatch. +type IExternal_table_hiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + COLON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllExternal_table_hive_parameter_map() []IExternal_table_hive_parameter_mapContext + External_table_hive_parameter_map(i int) IExternal_table_hive_parameter_mapContext + LEFT_BRACKET() antlr.TerminalNode + RIGHT_BRACKET() antlr.TerminalNode + External_table_field() IExternal_table_fieldContext + Datatype() IDatatypeContext + SEQUENCEFILE() antlr.TerminalNode + TEXTFILE() antlr.TerminalNode + RCFILE() antlr.TerminalNode + ORC() antlr.TerminalNode + PARQUET() antlr.TerminalNode + INPUTFORMAT() antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + OUTPUTFORMAT() antlr.TerminalNode + External_table_directory() IExternal_table_directoryContext + SERDE() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + External_table_hive() IExternal_table_hiveContext + FIELDS() antlr.TerminalNode + TERMINATED() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllCHARACTER() []antlr.TerminalNode + CHARACTER(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + DEFINED() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllCOMMENT() []antlr.TerminalNode + COMMENT(i int) antlr.TerminalNode + DELIMITED() antlr.TerminalNode + WITH() antlr.TerminalNode + SERDEPROPERTIES() antlr.TerminalNode + ESCAPED() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + ITEMS() antlr.TerminalNode + MAP() antlr.TerminalNode + KEYS() antlr.TerminalNode + LINES() antlr.TerminalNode + + // IsExternal_table_hiveContext differentiates from other interfaces. + IsExternal_table_hiveContext() +} + +type External_table_hiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_hiveContext() *External_table_hiveContext { + var p = new(External_table_hiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive + return p +} + +func InitEmptyExternal_table_hiveContext(p *External_table_hiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive +} + +func (*External_table_hiveContext) IsExternal_table_hiveContext() {} + +func NewExternal_table_hiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_hiveContext { + var p = new(External_table_hiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_hive + + return p +} + +func (s *External_table_hiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_hiveContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *External_table_hiveContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *External_table_hiveContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *External_table_hiveContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *External_table_hiveContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *External_table_hiveContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *External_table_hiveContext) AllExternal_table_hive_parameter_map() []IExternal_table_hive_parameter_mapContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_hive_parameter_mapContext); ok { + len++ + } + } + + tst := make([]IExternal_table_hive_parameter_mapContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_hive_parameter_mapContext); ok { + tst[i] = t.(IExternal_table_hive_parameter_mapContext) + i++ + } + } + + return tst +} + +func (s *External_table_hiveContext) External_table_hive_parameter_map(i int) IExternal_table_hive_parameter_mapContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_hive_parameter_mapContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_hive_parameter_mapContext) +} + +func (s *External_table_hiveContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *External_table_hiveContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *External_table_hiveContext) External_table_field() IExternal_table_fieldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_fieldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_fieldContext) +} + +func (s *External_table_hiveContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *External_table_hiveContext) SEQUENCEFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCEFILE, 0) +} + +func (s *External_table_hiveContext) TEXTFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEXTFILE, 0) +} + +func (s *External_table_hiveContext) RCFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRCFILE, 0) +} + +func (s *External_table_hiveContext) ORC() antlr.TerminalNode { + return s.GetToken(PlSqlParserORC, 0) +} + +func (s *External_table_hiveContext) PARQUET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARQUET, 0) +} + +func (s *External_table_hiveContext) INPUTFORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINPUTFORMAT, 0) +} + +func (s *External_table_hiveContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *External_table_hiveContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_hiveContext) OUTPUTFORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTPUTFORMAT, 0) +} + +func (s *External_table_hiveContext) External_table_directory() IExternal_table_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_directoryContext) +} + +func (s *External_table_hiveContext) SERDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERDE, 0) +} + +func (s *External_table_hiveContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *External_table_hiveContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *External_table_hiveContext) External_table_hive() IExternal_table_hiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_hiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_hiveContext) +} + +func (s *External_table_hiveContext) FIELDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, 0) +} + +func (s *External_table_hiveContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERMINATED, 0) +} + +func (s *External_table_hiveContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *External_table_hiveContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *External_table_hiveContext) AllCHARACTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHARACTER) +} + +func (s *External_table_hiveContext) CHARACTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, i) +} + +func (s *External_table_hiveContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *External_table_hiveContext) DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINED, 0) +} + +func (s *External_table_hiveContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *External_table_hiveContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_hiveContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_hiveContext) AllCOMMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMENT) +} + +func (s *External_table_hiveContext) COMMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, i) +} + +func (s *External_table_hiveContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED, 0) +} + +func (s *External_table_hiveContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *External_table_hiveContext) SERDEPROPERTIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERDEPROPERTIES, 0) +} + +func (s *External_table_hiveContext) ESCAPED() antlr.TerminalNode { + return s.GetToken(PlSqlParserESCAPED, 0) +} + +func (s *External_table_hiveContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECTION, 0) +} + +func (s *External_table_hiveContext) ITEMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserITEMS, 0) +} + +func (s *External_table_hiveContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *External_table_hiveContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *External_table_hiveContext) LINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINES, 0) +} + +func (s *External_table_hiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_hiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_hiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_hive(s) + } +} + +func (s *External_table_hiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_hive(s) + } +} + +func (p *PlSqlParser) External_table_hive() (localctx IExternal_table_hiveContext) { + localctx = NewExternal_table_hiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1264, PlSqlParserRULE_external_table_hive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12676) + p.Id_expression() + } + p.SetState(12681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(12677) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12678) + p.Id_expression() + } + + p.SetState(12683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12684) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOLON || _la == PlSqlParserEQUALS_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1622, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12685) + p.Tableview_name() + } + + case 2: + { + p.SetState(12686) + p.External_table_hive_parameter_map() + } + + case 3: + { + p.SetState(12687) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12688) + p.External_table_hive_parameter_map() + } + p.SetState(12693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12689) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12690) + p.External_table_hive_parameter_map() + } + + p.SetState(12695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12696) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(12698) + p.External_table_field() + } + { + p.SetState(12699) + p.Datatype() + } + p.SetState(12702) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1615, p.GetParserRuleContext()) == 1 { + { + p.SetState(12700) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12701) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12704) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12705) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12706) + p.Quoted_string() + } + + p.SetState(12711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + { + p.SetState(12712) + p.Match(PlSqlParserSEQUENCEFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(12713) + p.Match(PlSqlParserTEXTFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(12714) + p.Match(PlSqlParserRCFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(12715) + p.Match(PlSqlParserORC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + { + p.SetState(12716) + p.Match(PlSqlParserPARQUET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + { + p.SetState(12717) + p.Match(PlSqlParserINPUTFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12718) + p.Quoted_string() + } + { + p.SetState(12719) + p.Match(PlSqlParserOUTPUTFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12720) + p.Quoted_string() + } + + case 11: + { + p.SetState(12722) + p.External_table_directory() + } + + case 12: + p.SetState(12724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDELIMITED { + { + p.SetState(12723) + p.Match(PlSqlParserDELIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFIELDS: + { + p.SetState(12726) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12727) + p.Match(PlSqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12728) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12729) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(12730) + p.Match(PlSqlParserESCAPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12731) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12732) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLLECTION, PlSqlParserLINES, PlSqlParserMAP: + p.SetState(12738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLLECTION: + { + p.SetState(12733) + p.Match(PlSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12734) + p.Match(PlSqlParserITEMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAP: + { + p.SetState(12735) + p.Match(PlSqlParserMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12736) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLINES: + { + p.SetState(12737) + p.Match(PlSqlParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12740) + p.Match(PlSqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12741) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12742) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNULL_: + { + p.SetState(12743) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12744) + p.Match(PlSqlParserDEFINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12745) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12746) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 13: + { + p.SetState(12749) + p.Match(PlSqlParserSERDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12750) + p.Quoted_string() + } + p.SetState(12766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(12751) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12752) + p.Match(PlSqlParserSERDEPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(12753) + p.Quoted_string() + } + { + p.SetState(12754) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12755) + p.Quoted_string() + } + p.SetState(12763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12756) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12757) + p.Quoted_string() + } + { + p.SetState(12758) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12759) + p.Quoted_string() + } + + p.SetState(12765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(12771) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1623, p.GetParserRuleContext()) == 1 { + { + p.SetState(12770) + p.External_table_hive() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_hive_parameter_mapContext is an interface to support dynamic dispatch. +type IExternal_table_hive_parameter_mapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_CURLY_PAREN() antlr.TerminalNode + RIGHT_CURLY_PAREN() antlr.TerminalNode + AllExternal_table_hive_parameter_map_entry() []IExternal_table_hive_parameter_map_entryContext + External_table_hive_parameter_map_entry(i int) IExternal_table_hive_parameter_map_entryContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_hive_parameter_mapContext differentiates from other interfaces. + IsExternal_table_hive_parameter_mapContext() +} + +type External_table_hive_parameter_mapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_hive_parameter_mapContext() *External_table_hive_parameter_mapContext { + var p = new(External_table_hive_parameter_mapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map + return p +} + +func InitEmptyExternal_table_hive_parameter_mapContext(p *External_table_hive_parameter_mapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map +} + +func (*External_table_hive_parameter_mapContext) IsExternal_table_hive_parameter_mapContext() {} + +func NewExternal_table_hive_parameter_mapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_hive_parameter_mapContext { + var p = new(External_table_hive_parameter_mapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map + + return p +} + +func (s *External_table_hive_parameter_mapContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_hive_parameter_mapContext) LEFT_CURLY_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_CURLY_PAREN, 0) +} + +func (s *External_table_hive_parameter_mapContext) RIGHT_CURLY_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_CURLY_PAREN, 0) +} + +func (s *External_table_hive_parameter_mapContext) AllExternal_table_hive_parameter_map_entry() []IExternal_table_hive_parameter_map_entryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_hive_parameter_map_entryContext); ok { + len++ + } + } + + tst := make([]IExternal_table_hive_parameter_map_entryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_hive_parameter_map_entryContext); ok { + tst[i] = t.(IExternal_table_hive_parameter_map_entryContext) + i++ + } + } + + return tst +} + +func (s *External_table_hive_parameter_mapContext) External_table_hive_parameter_map_entry(i int) IExternal_table_hive_parameter_map_entryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_hive_parameter_map_entryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_hive_parameter_map_entryContext) +} + +func (s *External_table_hive_parameter_mapContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_hive_parameter_mapContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_hive_parameter_mapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_hive_parameter_mapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_hive_parameter_mapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_hive_parameter_map(s) + } +} + +func (s *External_table_hive_parameter_mapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_hive_parameter_map(s) + } +} + +func (p *PlSqlParser) External_table_hive_parameter_map() (localctx IExternal_table_hive_parameter_mapContext) { + localctx = NewExternal_table_hive_parameter_mapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1266, PlSqlParserRULE_external_table_hive_parameter_map) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12773) + p.Match(PlSqlParserLEFT_CURLY_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(12774) + p.External_table_hive_parameter_map_entry() + } + p.SetState(12779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12775) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12776) + p.External_table_hive_parameter_map_entry() + } + + p.SetState(12781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(12782) + p.Match(PlSqlParserRIGHT_CURLY_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_hive_parameter_map_entryContext is an interface to support dynamic dispatch. +type IExternal_table_hive_parameter_map_entryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + BINDVAR() antlr.TerminalNode + COLON() antlr.TerminalNode + LEFT_BRACKET() antlr.TerminalNode + RIGHT_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_hive_parameter_map_entryContext differentiates from other interfaces. + IsExternal_table_hive_parameter_map_entryContext() +} + +type External_table_hive_parameter_map_entryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_hive_parameter_map_entryContext() *External_table_hive_parameter_map_entryContext { + var p = new(External_table_hive_parameter_map_entryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map_entry + return p +} + +func InitEmptyExternal_table_hive_parameter_map_entryContext(p *External_table_hive_parameter_map_entryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map_entry +} + +func (*External_table_hive_parameter_map_entryContext) IsExternal_table_hive_parameter_map_entryContext() { +} + +func NewExternal_table_hive_parameter_map_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_hive_parameter_map_entryContext { + var p = new(External_table_hive_parameter_map_entryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_hive_parameter_map_entry + + return p +} + +func (s *External_table_hive_parameter_map_entryContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_hive_parameter_map_entryContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *External_table_hive_parameter_map_entryContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *External_table_hive_parameter_map_entryContext) BINDVAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDVAR, 0) +} + +func (s *External_table_hive_parameter_map_entryContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *External_table_hive_parameter_map_entryContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *External_table_hive_parameter_map_entryContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *External_table_hive_parameter_map_entryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_hive_parameter_map_entryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_hive_parameter_map_entryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_hive_parameter_map_entryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_hive_parameter_map_entryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_hive_parameter_map_entry(s) + } +} + +func (s *External_table_hive_parameter_map_entryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_hive_parameter_map_entry(s) + } +} + +func (p *PlSqlParser) External_table_hive_parameter_map_entry() (localctx IExternal_table_hive_parameter_map_entryContext) { + localctx = NewExternal_table_hive_parameter_map_entryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1268, PlSqlParserRULE_external_table_hive_parameter_map_entry) + var _la int + + p.SetState(12811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1627, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12784) + p.Id_expression() + } + { + p.SetState(12785) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12787) + p.Id_expression() + } + { + p.SetState(12788) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12789) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12790) + p.Id_expression() + } + p.SetState(12795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12791) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12792) + p.Id_expression() + } + + p.SetState(12797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12798) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12800) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12801) + p.Id_expression() + } + p.SetState(12806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12802) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12803) + p.Id_expression() + } + + p.SetState(12808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12809) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_directoryContext is an interface to support dynamic dispatch. +type IExternal_table_directoryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Directory_name() IDirectory_nameContext + COLON() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Object_name() IObject_nameContext + Quoted_string() IQuoted_stringContext + Variable_name() IVariable_nameContext + + // IsExternal_table_directoryContext differentiates from other interfaces. + IsExternal_table_directoryContext() +} + +type External_table_directoryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_directoryContext() *External_table_directoryContext { + var p = new(External_table_directoryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_directory + return p +} + +func InitEmptyExternal_table_directoryContext(p *External_table_directoryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_directory +} + +func (*External_table_directoryContext) IsExternal_table_directoryContext() {} + +func NewExternal_table_directoryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_directoryContext { + var p = new(External_table_directoryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_directory + + return p +} + +func (s *External_table_directoryContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_directoryContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *External_table_directoryContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *External_table_directoryContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *External_table_directoryContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *External_table_directoryContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *External_table_directoryContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *External_table_directoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_directoryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_directoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_directory(s) + } +} + +func (s *External_table_directoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_directory(s) + } +} + +func (p *PlSqlParser) External_table_directory() (localctx IExternal_table_directoryContext) { + localctx = NewExternal_table_directoryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1270, PlSqlParserRULE_external_table_directory) + var _la int + + p.SetState(12828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1630, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12813) + p.Directory_name() + } + { + p.SetState(12814) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12815) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(12823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372088865) != 0) { + { + p.SetState(12817) + p.Directory_name() + } + p.SetState(12819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(12818) + p.Object_name() + } + + } + { + p.SetState(12821) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12825) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12826) + p.Quoted_string() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12827) + p.Variable_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_movement_clauseContext is an interface to support dynamic dispatch. +type IRow_movement_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsRow_movement_clauseContext differentiates from other interfaces. + IsRow_movement_clauseContext() +} + +type Row_movement_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_movement_clauseContext() *Row_movement_clauseContext { + var p = new(Row_movement_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_row_movement_clause + return p +} + +func InitEmptyRow_movement_clauseContext(p *Row_movement_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_row_movement_clause +} + +func (*Row_movement_clauseContext) IsRow_movement_clauseContext() {} + +func NewRow_movement_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_movement_clauseContext { + var p = new(Row_movement_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_row_movement_clause + + return p +} + +func (s *Row_movement_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_movement_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Row_movement_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Row_movement_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Row_movement_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Row_movement_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_movement_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_movement_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRow_movement_clause(s) + } +} + +func (s *Row_movement_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRow_movement_clause(s) + } +} + +func (p *PlSqlParser) Row_movement_clause() (localctx IRow_movement_clauseContext) { + localctx = NewRow_movement_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1272, PlSqlParserRULE_row_movement_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(12830) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12833) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12834) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_archive_clauseContext is an interface to support dynamic dispatch. +type IFlashback_archive_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + Id_expression() IId_expressionContext + NO() antlr.TerminalNode + + // IsFlashback_archive_clauseContext differentiates from other interfaces. + IsFlashback_archive_clauseContext() +} + +type Flashback_archive_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext +} + +func NewEmptyFlashback_archive_clauseContext() *Flashback_archive_clauseContext { + var p = new(Flashback_archive_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause + return p +} + +func InitEmptyFlashback_archive_clauseContext(p *Flashback_archive_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause +} + +func (*Flashback_archive_clauseContext) IsFlashback_archive_clauseContext() {} + +func NewFlashback_archive_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_clauseContext { + var p = new(Flashback_archive_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause + + return p +} + +func (s *Flashback_archive_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_clauseContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Flashback_archive_clauseContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Flashback_archive_clauseContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_archive_clauseContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Flashback_archive_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Flashback_archive_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Flashback_archive_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_clause(s) + } +} + +func (s *Flashback_archive_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_clause(s) + } +} + +func (p *PlSqlParser) Flashback_archive_clause() (localctx IFlashback_archive_clauseContext) { + localctx = NewFlashback_archive_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1274, PlSqlParserRULE_flashback_archive_clause) + p.SetState(12844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFLASHBACK: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12836) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12837) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12839) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1632, p.GetParserRuleContext()) == 1 { + { + p.SetState(12838) + + var _x = p.Id_expression() + + localctx.(*Flashback_archive_clauseContext).fa = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12841) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12842) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12843) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILog_grpContext is an interface to support dynamic dispatch. +type ILog_grpContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsLog_grpContext differentiates from other interfaces. + IsLog_grpContext() +} + +type Log_grpContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLog_grpContext() *Log_grpContext { + var p = new(Log_grpContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_log_grp + return p +} + +func InitEmptyLog_grpContext(p *Log_grpContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_log_grp +} + +func (*Log_grpContext) IsLog_grpContext() {} + +func NewLog_grpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Log_grpContext { + var p = new(Log_grpContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_log_grp + + return p +} + +func (s *Log_grpContext) GetParser() antlr.Parser { return s.parser } + +func (s *Log_grpContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Log_grpContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Log_grpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Log_grpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Log_grpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLog_grp(s) + } +} + +func (s *Log_grpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLog_grp(s) + } +} + +func (p *PlSqlParser) Log_grp() (localctx ILog_grpContext) { + localctx = NewLog_grpContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1276, PlSqlParserRULE_log_grp) + p.SetState(12848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12846) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12847) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_table_loggingContext is an interface to support dynamic dispatch. +type ISupplemental_table_loggingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + AllSUPPLEMENTAL() []antlr.TerminalNode + SUPPLEMENTAL(i int) antlr.TerminalNode + AllLOG() []antlr.TerminalNode + LOG(i int) antlr.TerminalNode + AllSupplemental_log_grp_clause() []ISupplemental_log_grp_clauseContext + Supplemental_log_grp_clause(i int) ISupplemental_log_grp_clauseContext + AllSupplemental_id_key_clause() []ISupplemental_id_key_clauseContext + Supplemental_id_key_clause(i int) ISupplemental_id_key_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllLog_grp() []ILog_grpContext + Log_grp(i int) ILog_grpContext + + // IsSupplemental_table_loggingContext differentiates from other interfaces. + IsSupplemental_table_loggingContext() +} + +type Supplemental_table_loggingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_table_loggingContext() *Supplemental_table_loggingContext { + var p = new(Supplemental_table_loggingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging + return p +} + +func InitEmptySupplemental_table_loggingContext(p *Supplemental_table_loggingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging +} + +func (*Supplemental_table_loggingContext) IsSupplemental_table_loggingContext() {} + +func NewSupplemental_table_loggingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_table_loggingContext { + var p = new(Supplemental_table_loggingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging + + return p +} + +func (s *Supplemental_table_loggingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_table_loggingContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Supplemental_table_loggingContext) AllSUPPLEMENTAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSUPPLEMENTAL) +} + +func (s *Supplemental_table_loggingContext) SUPPLEMENTAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, i) +} + +func (s *Supplemental_table_loggingContext) AllLOG() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOG) +} + +func (s *Supplemental_table_loggingContext) LOG(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, i) +} + +func (s *Supplemental_table_loggingContext) AllSupplemental_log_grp_clause() []ISupplemental_log_grp_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + len++ + } + } + + tst := make([]ISupplemental_log_grp_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + tst[i] = t.(ISupplemental_log_grp_clauseContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Supplemental_log_grp_clause(i int) ISupplemental_log_grp_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_log_grp_clauseContext) +} + +func (s *Supplemental_table_loggingContext) AllSupplemental_id_key_clause() []ISupplemental_id_key_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + len++ + } + } + + tst := make([]ISupplemental_id_key_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + tst[i] = t.(ISupplemental_id_key_clauseContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Supplemental_id_key_clause(i int) ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_table_loggingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_table_loggingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_table_loggingContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Supplemental_table_loggingContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *Supplemental_table_loggingContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *Supplemental_table_loggingContext) AllLog_grp() []ILog_grpContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILog_grpContext); ok { + len++ + } + } + + tst := make([]ILog_grpContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILog_grpContext); ok { + tst[i] = t.(ILog_grpContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Log_grp(i int) ILog_grpContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILog_grpContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILog_grpContext) +} + +func (s *Supplemental_table_loggingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_table_loggingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_table_loggingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_table_logging(s) + } +} + +func (s *Supplemental_table_loggingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_table_logging(s) + } +} + +func (p *PlSqlParser) Supplemental_table_logging() (localctx ISupplemental_table_loggingContext) { + localctx = NewSupplemental_table_loggingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1278, PlSqlParserRULE_supplemental_table_logging) + var _la int + + p.SetState(12890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12850) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12851) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12852) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(12853) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(12854) + p.Supplemental_id_key_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12857) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12858) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12859) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(12860) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(12861) + p.Supplemental_id_key_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12869) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12870) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12871) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(12872) + p.Supplemental_id_key_clause() + } + + case PlSqlParserGROUP: + { + p.SetState(12873) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12874) + p.Log_grp() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12877) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12878) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12879) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(12880) + p.Supplemental_id_key_clause() + } + + case PlSqlParserGROUP: + { + p.SetState(12881) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12882) + p.Log_grp() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_log_grp_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_log_grp_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + Log_grp() ILog_grpContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + AllLOG() []antlr.TerminalNode + LOG(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALWAYS() antlr.TerminalNode + + // IsSupplemental_log_grp_clauseContext differentiates from other interfaces. + IsSupplemental_log_grp_clauseContext() +} + +type Supplemental_log_grp_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_log_grp_clauseContext() *Supplemental_log_grp_clauseContext { + var p = new(Supplemental_log_grp_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause + return p +} + +func InitEmptySupplemental_log_grp_clauseContext(p *Supplemental_log_grp_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause +} + +func (*Supplemental_log_grp_clauseContext) IsSupplemental_log_grp_clauseContext() {} + +func NewSupplemental_log_grp_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_log_grp_clauseContext { + var p = new(Supplemental_log_grp_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause + + return p +} + +func (s *Supplemental_log_grp_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_log_grp_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Supplemental_log_grp_clauseContext) Log_grp() ILog_grpContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILog_grpContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILog_grpContext) +} + +func (s *Supplemental_log_grp_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Supplemental_log_grp_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_log_grp_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Supplemental_log_grp_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Supplemental_log_grp_clauseContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNO) +} + +func (s *Supplemental_log_grp_clauseContext) NO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, i) +} + +func (s *Supplemental_log_grp_clauseContext) AllLOG() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOG) +} + +func (s *Supplemental_log_grp_clauseContext) LOG(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, i) +} + +func (s *Supplemental_log_grp_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_log_grp_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_log_grp_clauseContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Supplemental_log_grp_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_log_grp_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_log_grp_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_log_grp_clause(s) + } +} + +func (s *Supplemental_log_grp_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_log_grp_clause(s) + } +} + +func (p *PlSqlParser) Supplemental_log_grp_clause() (localctx ISupplemental_log_grp_clauseContext) { + localctx = NewSupplemental_log_grp_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1280, PlSqlParserRULE_supplemental_log_grp_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12892) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12893) + p.Log_grp() + } + { + p.SetState(12894) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12895) + p.Column_name() + } + p.SetState(12898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(12896) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12897) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12900) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12901) + p.Column_name() + } + p.SetState(12904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(12902) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12903) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(12910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12911) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALWAYS { + { + p.SetState(12912) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_id_key_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_id_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllUNIQUE() []antlr.TerminalNode + UNIQUE(i int) antlr.TerminalNode + AllFOREIGN() []antlr.TerminalNode + FOREIGN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllINDEX() []antlr.TerminalNode + INDEX(i int) antlr.TerminalNode + + // IsSupplemental_id_key_clauseContext differentiates from other interfaces. + IsSupplemental_id_key_clauseContext() +} + +type Supplemental_id_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_id_key_clauseContext() *Supplemental_id_key_clauseContext { + var p = new(Supplemental_id_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause + return p +} + +func InitEmptySupplemental_id_key_clauseContext(p *Supplemental_id_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause +} + +func (*Supplemental_id_key_clauseContext) IsSupplemental_id_key_clauseContext() {} + +func NewSupplemental_id_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_id_key_clauseContext { + var p = new(Supplemental_id_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause + + return p +} + +func (s *Supplemental_id_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_id_key_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_id_key_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Supplemental_id_key_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Supplemental_id_key_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Supplemental_id_key_clauseContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Supplemental_id_key_clauseContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Supplemental_id_key_clauseContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Supplemental_id_key_clauseContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Supplemental_id_key_clauseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Supplemental_id_key_clauseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Supplemental_id_key_clauseContext) AllUNIQUE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNIQUE) +} + +func (s *Supplemental_id_key_clauseContext) UNIQUE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, i) +} + +func (s *Supplemental_id_key_clauseContext) AllFOREIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFOREIGN) +} + +func (s *Supplemental_id_key_clauseContext) FOREIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, i) +} + +func (s *Supplemental_id_key_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_id_key_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_id_key_clauseContext) AllINDEX() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINDEX) +} + +func (s *Supplemental_id_key_clauseContext) INDEX(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, i) +} + +func (s *Supplemental_id_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_id_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_id_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_id_key_clause(s) + } +} + +func (s *Supplemental_id_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_id_key_clause(s) + } +} + +func (p *PlSqlParser) Supplemental_id_key_clause() (localctx ISupplemental_id_key_clauseContext) { + localctx = NewSupplemental_id_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1282, PlSqlParserRULE_supplemental_id_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12915) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12916) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALL || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE || _la == PlSqlParserCOMMA { + p.SetState(12918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(12917) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(12920) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(12921) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12922) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(12923) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEX { + { + p.SetState(12924) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFOREIGN: + { + p.SetState(12927) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12928) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12935) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12936) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAllocate_extent_clauseContext is an interface to support dynamic dispatch. +type IAllocate_extent_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatafile returns the datafile token. + GetDatafile() antlr.Token + + // GetInst_num returns the inst_num token. + GetInst_num() antlr.Token + + // SetDatafile sets the datafile token. + SetDatafile(antlr.Token) + + // SetInst_num sets the inst_num token. + SetInst_num(antlr.Token) + + // Getter signatures + ALLOCATE() antlr.TerminalNode + EXTENT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllDATAFILE() []antlr.TerminalNode + DATAFILE(i int) antlr.TerminalNode + AllINSTANCE() []antlr.TerminalNode + INSTANCE(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + + // IsAllocate_extent_clauseContext differentiates from other interfaces. + IsAllocate_extent_clauseContext() +} + +type Allocate_extent_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + datafile antlr.Token + inst_num antlr.Token +} + +func NewEmptyAllocate_extent_clauseContext() *Allocate_extent_clauseContext { + var p = new(Allocate_extent_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause + return p +} + +func InitEmptyAllocate_extent_clauseContext(p *Allocate_extent_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause +} + +func (*Allocate_extent_clauseContext) IsAllocate_extent_clauseContext() {} + +func NewAllocate_extent_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Allocate_extent_clauseContext { + var p = new(Allocate_extent_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause + + return p +} + +func (s *Allocate_extent_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Allocate_extent_clauseContext) GetDatafile() antlr.Token { return s.datafile } + +func (s *Allocate_extent_clauseContext) GetInst_num() antlr.Token { return s.inst_num } + +func (s *Allocate_extent_clauseContext) SetDatafile(v antlr.Token) { s.datafile = v } + +func (s *Allocate_extent_clauseContext) SetInst_num(v antlr.Token) { s.inst_num = v } + +func (s *Allocate_extent_clauseContext) ALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOCATE, 0) +} + +func (s *Allocate_extent_clauseContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Allocate_extent_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Allocate_extent_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Allocate_extent_clauseContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Allocate_extent_clauseContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Allocate_extent_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Allocate_extent_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Allocate_extent_clauseContext) AllDATAFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATAFILE) +} + +func (s *Allocate_extent_clauseContext) DATAFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, i) +} + +func (s *Allocate_extent_clauseContext) AllINSTANCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINSTANCE) +} + +func (s *Allocate_extent_clauseContext) INSTANCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, i) +} + +func (s *Allocate_extent_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Allocate_extent_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Allocate_extent_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Allocate_extent_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Allocate_extent_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Allocate_extent_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Allocate_extent_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAllocate_extent_clause(s) + } +} + +func (s *Allocate_extent_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAllocate_extent_clause(s) + } +} + +func (p *PlSqlParser) Allocate_extent_clause() (localctx IAllocate_extent_clauseContext) { + localctx = NewAllocate_extent_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1284, PlSqlParserRULE_allocate_extent_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12938) + p.Match(PlSqlParserALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12939) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12940) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDATAFILE || _la == PlSqlParserINSTANCE || _la == PlSqlParserSIZE { + p.SetState(12947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSIZE: + { + p.SetState(12941) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12942) + p.Size_clause() + } + + case PlSqlParserDATAFILE: + { + p.SetState(12943) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12944) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Allocate_extent_clauseContext).datafile = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINSTANCE: + { + p.SetState(12945) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12946) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Allocate_extent_clauseContext).inst_num = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12951) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeallocate_unused_clauseContext is an interface to support dynamic dispatch. +type IDeallocate_unused_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEALLOCATE() antlr.TerminalNode + UNUSED() antlr.TerminalNode + KEEP() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsDeallocate_unused_clauseContext differentiates from other interfaces. + IsDeallocate_unused_clauseContext() +} + +type Deallocate_unused_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeallocate_unused_clauseContext() *Deallocate_unused_clauseContext { + var p = new(Deallocate_unused_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause + return p +} + +func InitEmptyDeallocate_unused_clauseContext(p *Deallocate_unused_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause +} + +func (*Deallocate_unused_clauseContext) IsDeallocate_unused_clauseContext() {} + +func NewDeallocate_unused_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Deallocate_unused_clauseContext { + var p = new(Deallocate_unused_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause + + return p +} + +func (s *Deallocate_unused_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Deallocate_unused_clauseContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEALLOCATE, 0) +} + +func (s *Deallocate_unused_clauseContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Deallocate_unused_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Deallocate_unused_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Deallocate_unused_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Deallocate_unused_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Deallocate_unused_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeallocate_unused_clause(s) + } +} + +func (s *Deallocate_unused_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeallocate_unused_clause(s) + } +} + +func (p *PlSqlParser) Deallocate_unused_clause() (localctx IDeallocate_unused_clauseContext) { + localctx = NewDeallocate_unused_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1286, PlSqlParserRULE_deallocate_unused_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12954) + p.Match(PlSqlParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12955) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(12956) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12957) + p.Size_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShrink_clauseContext is an interface to support dynamic dispatch. +type IShrink_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + COMPACT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CHECK() antlr.TerminalNode + + // IsShrink_clauseContext differentiates from other interfaces. + IsShrink_clauseContext() +} + +type Shrink_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShrink_clauseContext() *Shrink_clauseContext { + var p = new(Shrink_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_shrink_clause + return p +} + +func InitEmptyShrink_clauseContext(p *Shrink_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_shrink_clause +} + +func (*Shrink_clauseContext) IsShrink_clauseContext() {} + +func NewShrink_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Shrink_clauseContext { + var p = new(Shrink_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_shrink_clause + + return p +} + +func (s *Shrink_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Shrink_clauseContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Shrink_clauseContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Shrink_clauseContext) COMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPACT, 0) +} + +func (s *Shrink_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Shrink_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Shrink_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Shrink_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Shrink_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterShrink_clause(s) + } +} + +func (s *Shrink_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitShrink_clause(s) + } +} + +func (p *PlSqlParser) Shrink_clause() (localctx IShrink_clauseContext) { + localctx = NewShrink_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1288, PlSqlParserRULE_shrink_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12960) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12961) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPACT { + { + p.SetState(12962) + p.Match(PlSqlParserCOMPACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(12965) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHECK { + { + p.SetState(12968) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecords_per_block_clauseContext is an interface to support dynamic dispatch. +type IRecords_per_block_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORDS_PER_BLOCK() antlr.TerminalNode + MINIMIZE() antlr.TerminalNode + NOMINIMIZE() antlr.TerminalNode + + // IsRecords_per_block_clauseContext differentiates from other interfaces. + IsRecords_per_block_clauseContext() +} + +type Records_per_block_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecords_per_block_clauseContext() *Records_per_block_clauseContext { + var p = new(Records_per_block_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_records_per_block_clause + return p +} + +func InitEmptyRecords_per_block_clauseContext(p *Records_per_block_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_records_per_block_clause +} + +func (*Records_per_block_clauseContext) IsRecords_per_block_clauseContext() {} + +func NewRecords_per_block_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Records_per_block_clauseContext { + var p = new(Records_per_block_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_records_per_block_clause + + return p +} + +func (s *Records_per_block_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Records_per_block_clauseContext) RECORDS_PER_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS_PER_BLOCK, 0) +} + +func (s *Records_per_block_clauseContext) MINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMIZE, 0) +} + +func (s *Records_per_block_clauseContext) NOMINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINIMIZE, 0) +} + +func (s *Records_per_block_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Records_per_block_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Records_per_block_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecords_per_block_clause(s) + } +} + +func (s *Records_per_block_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecords_per_block_clause(s) + } +} + +func (p *PlSqlParser) Records_per_block_clause() (localctx IRecords_per_block_clauseContext) { + localctx = NewRecords_per_block_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1290, PlSqlParserRULE_records_per_block_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMINIMIZE || _la == PlSqlParserNOMINIMIZE { + { + p.SetState(12971) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMINIMIZE || _la == PlSqlParserNOMINIMIZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12974) + p.Match(PlSqlParserRECORDS_PER_BLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpgrade_table_clauseContext is an interface to support dynamic dispatch. +type IUpgrade_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + Column_properties() IColumn_propertiesContext + INCLUDING() antlr.TerminalNode + DATA() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUpgrade_table_clauseContext differentiates from other interfaces. + IsUpgrade_table_clauseContext() +} + +type Upgrade_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpgrade_table_clauseContext() *Upgrade_table_clauseContext { + var p = new(Upgrade_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause + return p +} + +func InitEmptyUpgrade_table_clauseContext(p *Upgrade_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause +} + +func (*Upgrade_table_clauseContext) IsUpgrade_table_clauseContext() {} + +func NewUpgrade_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upgrade_table_clauseContext { + var p = new(Upgrade_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause + + return p +} + +func (s *Upgrade_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upgrade_table_clauseContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Upgrade_table_clauseContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Upgrade_table_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Upgrade_table_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Upgrade_table_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Upgrade_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upgrade_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upgrade_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpgrade_table_clause(s) + } +} + +func (s *Upgrade_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpgrade_table_clause(s) + } +} + +func (p *PlSqlParser) Upgrade_table_clause() (localctx IUpgrade_table_clauseContext) { + localctx = NewUpgrade_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1292, PlSqlParserRULE_upgrade_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12976) + p.Match(PlSqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(12978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(12977) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12980) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12981) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(12983) + p.Column_properties() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_tableContext is an interface to support dynamic dispatch. +type ITruncate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + STORAGE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + PURGE() antlr.TerminalNode + DROP() antlr.TerminalNode + REUSE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsTruncate_tableContext differentiates from other interfaces. + IsTruncate_tableContext() +} + +type Truncate_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_tableContext() *Truncate_tableContext { + var p = new(Truncate_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table + return p +} + +func InitEmptyTruncate_tableContext(p *Truncate_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table +} + +func (*Truncate_tableContext) IsTruncate_tableContext() {} + +func NewTruncate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_tableContext { + var p = new(Truncate_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_truncate_table + + return p +} + +func (s *Truncate_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_tableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Truncate_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Truncate_tableContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Truncate_tableContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Truncate_tableContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Truncate_tableContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Truncate_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Truncate_tableContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Truncate_tableContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Truncate_tableContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Truncate_tableContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Truncate_tableContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Truncate_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTruncate_table(s) + } +} + +func (s *Truncate_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_table(s) + } +} + +func (p *PlSqlParser) Truncate_table() (localctx ITruncate_tableContext) { + localctx = NewTruncate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1294, PlSqlParserRULE_truncate_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12985) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12986) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12987) + p.Tableview_name() + } + p.SetState(12994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRESERVE || _la == PlSqlParserPURGE { + { + p.SetState(12988) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRESERVE || _la == PlSqlParserPURGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMATERIALIZED { + { + p.SetState(12989) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12990) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12991) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(13004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserREUSE { + p.SetState(13001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDROP: + { + p.SetState(12996) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(12997) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserREUSE: + { + p.SetState(13000) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13003) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13006) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_tableContext is an interface to support dynamic dispatch. +type IDrop_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + CASCADE() antlr.TerminalNode + PURGE() antlr.TerminalNode + Table_alias() ITable_aliasContext + FORCE() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + + // IsDrop_tableContext differentiates from other interfaces. + IsDrop_tableContext() +} + +type Drop_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_tableContext() *Drop_tableContext { + var p = new(Drop_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table + return p +} + +func InitEmptyDrop_tableContext(p *Drop_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table +} + +func (*Drop_tableContext) IsDrop_tableContext() {} + +func NewDrop_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tableContext { + var p = new(Drop_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_table + + return p +} + +func (s *Drop_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Drop_tableContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_tableContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_tableContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_tableContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_tableContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Drop_tableContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Drop_tableContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_tableContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Drop_tableContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Drop_tableContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_tableContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Drop_tableContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Drop_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_table(s) + } +} + +func (s *Drop_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_table(s) + } +} + +func (p *PlSqlParser) Drop_table() (localctx IDrop_tableContext) { + localctx = NewDrop_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1296, PlSqlParserRULE_drop_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13009) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13010) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13011) + p.Tableview_name() + } + p.SetState(13014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(13012) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13013) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13018) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1666, p.GetParserRuleContext()) == 1 { + { + p.SetState(13016) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13017) + p.Tableview_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13020) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13021) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(13025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(13024) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13027) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13028) + p.Table_alias() + } + + } + p.SetState(13032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(13031) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_tablespaceContext is an interface to support dynamic dispatch. +type IDrop_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // Getter signatures + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Including_contents_clause() IIncluding_contents_clauseContext + KEEP() antlr.TerminalNode + QUOTA() antlr.TerminalNode + + // IsDrop_tablespaceContext differentiates from other interfaces. + IsDrop_tablespaceContext() +} + +type Drop_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ts IId_expressionContext +} + +func NewEmptyDrop_tablespaceContext() *Drop_tablespaceContext { + var p = new(Drop_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace + return p +} + +func InitEmptyDrop_tablespaceContext(p *Drop_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace +} + +func (*Drop_tablespaceContext) IsDrop_tablespaceContext() {} + +func NewDrop_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tablespaceContext { + var p = new(Drop_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_tablespace + + return p +} + +func (s *Drop_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tablespaceContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Drop_tablespaceContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Drop_tablespaceContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Drop_tablespaceContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Drop_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Drop_tablespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_tablespaceContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_tablespaceContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_tablespaceContext) Including_contents_clause() IIncluding_contents_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncluding_contents_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncluding_contents_clauseContext) +} + +func (s *Drop_tablespaceContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Drop_tablespaceContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Drop_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_tablespace(s) + } +} + +func (s *Drop_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_tablespace(s) + } +} + +func (p *PlSqlParser) Drop_tablespace() (localctx IDrop_tablespaceContext) { + localctx = NewDrop_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1298, PlSqlParserRULE_drop_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13034) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13035) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13036) + + var _x = p.Id_expression() + + localctx.(*Drop_tablespaceContext).ts = _x + } + p.SetState(13039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(13037) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13038) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserKEEP { + { + p.SetState(13041) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(13043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUOTA { + { + p.SetState(13042) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(13048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(13047) + p.Including_contents_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_tablespace_setContext is an interface to support dynamic dispatch. +type IDrop_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + Id_expression() IId_expressionContext + Including_contents_clause() IIncluding_contents_clauseContext + + // IsDrop_tablespace_setContext differentiates from other interfaces. + IsDrop_tablespace_setContext() +} + +type Drop_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext +} + +func NewEmptyDrop_tablespace_setContext() *Drop_tablespace_setContext { + var p = new(Drop_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set + return p +} + +func InitEmptyDrop_tablespace_setContext(p *Drop_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set +} + +func (*Drop_tablespace_setContext) IsDrop_tablespace_setContext() {} + +func NewDrop_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tablespace_setContext { + var p = new(Drop_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set + + return p +} + +func (s *Drop_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Drop_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Drop_tablespace_setContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Drop_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Drop_tablespace_setContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_tablespace_setContext) Including_contents_clause() IIncluding_contents_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncluding_contents_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncluding_contents_clauseContext) +} + +func (s *Drop_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_tablespace_set(s) + } +} + +func (s *Drop_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_tablespace_set(s) + } +} + +func (p *PlSqlParser) Drop_tablespace_set() (localctx IDrop_tablespace_setContext) { + localctx = NewDrop_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1300, PlSqlParserRULE_drop_tablespace_set) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13050) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13051) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13052) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13053) + + var _x = p.Id_expression() + + localctx.(*Drop_tablespace_setContext).tss = _x + } + p.SetState(13055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(13054) + p.Including_contents_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIncluding_contents_clauseContext is an interface to support dynamic dispatch. +type IIncluding_contents_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDING() antlr.TerminalNode + CONTENTS() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + AND() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsIncluding_contents_clauseContext differentiates from other interfaces. + IsIncluding_contents_clauseContext() +} + +type Including_contents_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIncluding_contents_clauseContext() *Including_contents_clauseContext { + var p = new(Including_contents_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_contents_clause + return p +} + +func InitEmptyIncluding_contents_clauseContext(p *Including_contents_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_contents_clause +} + +func (*Including_contents_clauseContext) IsIncluding_contents_clauseContext() {} + +func NewIncluding_contents_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Including_contents_clauseContext { + var p = new(Including_contents_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_including_contents_clause + + return p +} + +func (s *Including_contents_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Including_contents_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Including_contents_clauseContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Including_contents_clauseContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Including_contents_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Including_contents_clauseContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Including_contents_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Including_contents_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Including_contents_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Including_contents_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Including_contents_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIncluding_contents_clause(s) + } +} + +func (s *Including_contents_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIncluding_contents_clause(s) + } +} + +func (p *PlSqlParser) Including_contents_clause() (localctx IIncluding_contents_clauseContext) { + localctx = NewIncluding_contents_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1302, PlSqlParserRULE_including_contents_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13057) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13058) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND || _la == PlSqlParserKEEP { + { + p.SetState(13059) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAND || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13060) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13063) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13064) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_viewContext is an interface to support dynamic dispatch. +type IDrop_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + + // IsDrop_viewContext differentiates from other interfaces. + IsDrop_viewContext() +} + +type Drop_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_viewContext() *Drop_viewContext { + var p = new(Drop_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_view + return p +} + +func InitEmptyDrop_viewContext(p *Drop_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_view +} + +func (*Drop_viewContext) IsDrop_viewContext() {} + +func NewDrop_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_viewContext { + var p = new(Drop_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_view + + return p +} + +func (s *Drop_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_viewContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Drop_viewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Drop_viewContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_viewContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Drop_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_view(s) + } +} + +func (s *Drop_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_view(s) + } +} + +func (p *PlSqlParser) Drop_view() (localctx IDrop_viewContext) { + localctx = NewDrop_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1304, PlSqlParserRULE_drop_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13067) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13068) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13069) + p.Tableview_name() + } + p.SetState(13072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIF { + { + p.SetState(13070) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13071) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13074) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13075) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComment_on_columnContext is an interface to support dynamic dispatch. +type IComment_on_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_columnContext differentiates from other interfaces. + IsComment_on_columnContext() +} + +type Comment_on_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_columnContext() *Comment_on_columnContext { + var p = new(Comment_on_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_column + return p +} + +func InitEmptyComment_on_columnContext(p *Comment_on_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_column +} + +func (*Comment_on_columnContext) IsComment_on_columnContext() {} + +func NewComment_on_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_columnContext { + var p = new(Comment_on_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_column + + return p +} + +func (s *Comment_on_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_columnContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_columnContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_columnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Comment_on_columnContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Comment_on_columnContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_columnContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_column(s) + } +} + +func (s *Comment_on_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_column(s) + } +} + +func (p *PlSqlParser) Comment_on_column() (localctx IComment_on_columnContext) { + localctx = NewComment_on_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1306, PlSqlParserRULE_comment_on_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13078) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13079) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13080) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13081) + p.Column_name() + } + { + p.SetState(13082) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13083) + p.Quoted_string() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_or_disableContext is an interface to support dynamic dispatch. +type IEnable_or_disableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsEnable_or_disableContext differentiates from other interfaces. + IsEnable_or_disableContext() +} + +type Enable_or_disableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_or_disableContext() *Enable_or_disableContext { + var p = new(Enable_or_disableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_or_disable + return p +} + +func InitEmptyEnable_or_disableContext(p *Enable_or_disableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_or_disable +} + +func (*Enable_or_disableContext) IsEnable_or_disableContext() {} + +func NewEnable_or_disableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_or_disableContext { + var p = new(Enable_or_disableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_or_disable + + return p +} + +func (s *Enable_or_disableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_or_disableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_or_disableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_or_disableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_or_disableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_or_disableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_or_disable(s) + } +} + +func (s *Enable_or_disableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_or_disable(s) + } +} + +func (p *PlSqlParser) Enable_or_disable() (localctx IEnable_or_disableContext) { + localctx = NewEnable_or_disableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1308, PlSqlParserRULE_enable_or_disable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13085) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAllow_or_disallowContext is an interface to support dynamic dispatch. +type IAllow_or_disallowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALLOW() antlr.TerminalNode + DISALLOW() antlr.TerminalNode + + // IsAllow_or_disallowContext differentiates from other interfaces. + IsAllow_or_disallowContext() +} + +type Allow_or_disallowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAllow_or_disallowContext() *Allow_or_disallowContext { + var p = new(Allow_or_disallowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allow_or_disallow + return p +} + +func InitEmptyAllow_or_disallowContext(p *Allow_or_disallowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allow_or_disallow +} + +func (*Allow_or_disallowContext) IsAllow_or_disallowContext() {} + +func NewAllow_or_disallowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Allow_or_disallowContext { + var p = new(Allow_or_disallowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_allow_or_disallow + + return p +} + +func (s *Allow_or_disallowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Allow_or_disallowContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Allow_or_disallowContext) DISALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISALLOW, 0) +} + +func (s *Allow_or_disallowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Allow_or_disallowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Allow_or_disallowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAllow_or_disallow(s) + } +} + +func (s *Allow_or_disallowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAllow_or_disallow(s) + } +} + +func (p *PlSqlParser) Allow_or_disallow() (localctx IAllow_or_disallowContext) { + localctx = NewAllow_or_disallowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1310, PlSqlParserRULE_allow_or_disallow) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13087) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_synonymContext is an interface to support dynamic dispatch. +type IAlter_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_synonymContext differentiates from other interfaces. + IsAlter_synonymContext() +} + +type Alter_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_synonymContext() *Alter_synonymContext { + var p = new(Alter_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_synonym + return p +} + +func InitEmptyAlter_synonymContext(p *Alter_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_synonym +} + +func (*Alter_synonymContext) IsAlter_synonymContext() {} + +func NewAlter_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_synonymContext { + var p = new(Alter_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_synonym + + return p +} + +func (s *Alter_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_synonymContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Alter_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Alter_synonymContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Alter_synonymContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Alter_synonymContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_synonymContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_synonymContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_synonym(s) + } +} + +func (s *Alter_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_synonym(s) + } +} + +func (p *PlSqlParser) Alter_synonym() (localctx IAlter_synonymContext) { + localctx = NewAlter_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1312, PlSqlParserRULE_alter_synonym) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13089) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(13090) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13093) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13097) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1681, p.GetParserRuleContext()) == 1 { + { + p.SetState(13094) + p.Schema_name() + } + { + p.SetState(13095) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13099) + p.Synonym_name() + } + { + p.SetState(13100) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_synonymContext is an interface to support dynamic dispatch. +type ICreate_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + FOR() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsCreate_synonymContext differentiates from other interfaces. + IsCreate_synonymContext() +} + +type Create_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_synonymContext() *Create_synonymContext { + var p = new(Create_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_synonym + return p +} + +func InitEmptyCreate_synonymContext(p *Create_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_synonym +} + +func (*Create_synonymContext) IsCreate_synonymContext() {} + +func NewCreate_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_synonymContext { + var p = new(Create_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_synonym + + return p +} + +func (s *Create_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_synonymContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Create_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Create_synonymContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_synonymContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_synonymContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_synonymContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_synonymContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_synonymContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_synonymContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Create_synonymContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Create_synonymContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Create_synonymContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Create_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_synonym(s) + } +} + +func (s *Create_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_synonym(s) + } +} + +func (p *PlSqlParser) Create_synonym() (localctx ICreate_synonymContext) { + localctx = NewCreate_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1314, PlSqlParserRULE_create_synonym) + var _la int + + p.SetState(13149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1690, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13102) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(13103) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13104) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13107) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13108) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13109) + p.Synonym_name() + } + { + p.SetState(13110) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13114) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1683, p.GetParserRuleContext()) == 1 { + { + p.SetState(13111) + p.Schema_name() + } + { + p.SetState(13112) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13116) + p.Schema_object_name() + } + p.SetState(13119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAT_SIGN { + { + p.SetState(13117) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13118) + p.Link_name() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13121) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(13122) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13123) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13126) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13130) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1686, p.GetParserRuleContext()) == 1 { + { + p.SetState(13127) + p.Schema_name() + } + { + p.SetState(13128) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13132) + p.Synonym_name() + } + { + p.SetState(13133) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13137) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1687, p.GetParserRuleContext()) == 1 { + { + p.SetState(13134) + p.Schema_name() + } + { + p.SetState(13135) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13139) + p.Schema_object_name() + } + p.SetState(13147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAT_SIGN { + { + p.SetState(13140) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13144) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1688, p.GetParserRuleContext()) == 1 { + { + p.SetState(13141) + p.Schema_name() + } + { + p.SetState(13142) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13146) + p.Link_name() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_synonymContext is an interface to support dynamic dispatch. +type IDrop_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + PUBLIC() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_synonymContext differentiates from other interfaces. + IsDrop_synonymContext() +} + +type Drop_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_synonymContext() *Drop_synonymContext { + var p = new(Drop_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_synonym + return p +} + +func InitEmptyDrop_synonymContext(p *Drop_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_synonym +} + +func (*Drop_synonymContext) IsDrop_synonymContext() {} + +func NewDrop_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_synonymContext { + var p = new(Drop_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_synonym + + return p +} + +func (s *Drop_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_synonymContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Drop_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Drop_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Drop_synonymContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_synonymContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_synonymContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_synonym(s) + } +} + +func (s *Drop_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_synonym(s) + } +} + +func (p *PlSqlParser) Drop_synonym() (localctx IDrop_synonymContext) { + localctx = NewDrop_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1316, PlSqlParserRULE_drop_synonym) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13151) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(13152) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13155) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13159) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1692, p.GetParserRuleContext()) == 1 { + { + p.SetState(13156) + p.Schema_name() + } + { + p.SetState(13157) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13161) + p.Synonym_name() + } + p.SetState(13163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(13162) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_spfileContext is an interface to support dynamic dispatch. +type ICreate_spfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SPFILE() antlr.TerminalNode + FROM() antlr.TerminalNode + PFILE() antlr.TerminalNode + MEMORY() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + Spfile_name() ISpfile_nameContext + Pfile_name() IPfile_nameContext + AS() antlr.TerminalNode + COPY() antlr.TerminalNode + + // IsCreate_spfileContext differentiates from other interfaces. + IsCreate_spfileContext() +} + +type Create_spfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_spfileContext() *Create_spfileContext { + var p = new(Create_spfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_spfile + return p +} + +func InitEmptyCreate_spfileContext(p *Create_spfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_spfile +} + +func (*Create_spfileContext) IsCreate_spfileContext() {} + +func NewCreate_spfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_spfileContext { + var p = new(Create_spfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_spfile + + return p +} + +func (s *Create_spfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_spfileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_spfileContext) SPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPFILE, 0) +} + +func (s *Create_spfileContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_spfileContext) PFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPFILE, 0) +} + +func (s *Create_spfileContext) MEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMORY, 0) +} + +func (s *Create_spfileContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Create_spfileContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Create_spfileContext) Spfile_name() ISpfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpfile_nameContext) +} + +func (s *Create_spfileContext) Pfile_name() IPfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPfile_nameContext) +} + +func (s *Create_spfileContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_spfileContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Create_spfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_spfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_spfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_spfile(s) + } +} + +func (s *Create_spfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_spfile(s) + } +} + +func (p *PlSqlParser) Create_spfile() (localctx ICreate_spfileContext) { + localctx = NewCreate_spfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1318, PlSqlParserRULE_create_spfile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13165) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13166) + p.Match(PlSqlParserSPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEQUALS_OP { + { + p.SetState(13167) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13168) + p.Spfile_name() + } + + } + { + p.SetState(13171) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPFILE: + { + p.SetState(13172) + p.Match(PlSqlParserPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEQUALS_OP { + { + p.SetState(13173) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13174) + p.Pfile_name() + } + + } + p.SetState(13179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13177) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13178) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserMEMORY: + { + p.SetState(13181) + p.Match(PlSqlParserMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpfile_nameContext is an interface to support dynamic dispatch. +type ISpfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsSpfile_nameContext differentiates from other interfaces. + IsSpfile_nameContext() +} + +type Spfile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpfile_nameContext() *Spfile_nameContext { + var p = new(Spfile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_spfile_name + return p +} + +func InitEmptySpfile_nameContext(p *Spfile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_spfile_name +} + +func (*Spfile_nameContext) IsSpfile_nameContext() {} + +func NewSpfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spfile_nameContext { + var p = new(Spfile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_spfile_name + + return p +} + +func (s *Spfile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spfile_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Spfile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spfile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spfile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSpfile_name(s) + } +} + +func (s *Spfile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSpfile_name(s) + } +} + +func (p *PlSqlParser) Spfile_name() (localctx ISpfile_nameContext) { + localctx = NewSpfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1320, PlSqlParserRULE_spfile_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13184) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPfile_nameContext is an interface to support dynamic dispatch. +type IPfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsPfile_nameContext differentiates from other interfaces. + IsPfile_nameContext() +} + +type Pfile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPfile_nameContext() *Pfile_nameContext { + var p = new(Pfile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pfile_name + return p +} + +func InitEmptyPfile_nameContext(p *Pfile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pfile_name +} + +func (*Pfile_nameContext) IsPfile_nameContext() {} + +func NewPfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pfile_nameContext { + var p = new(Pfile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pfile_name + + return p +} + +func (s *Pfile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pfile_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Pfile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pfile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pfile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPfile_name(s) + } +} + +func (s *Pfile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPfile_name(s) + } +} + +func (p *PlSqlParser) Pfile_name() (localctx IPfile_nameContext) { + localctx = NewPfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1322, PlSqlParserRULE_pfile_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13186) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComment_on_tableContext is an interface to support dynamic dispatch. +type IComment_on_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_tableContext differentiates from other interfaces. + IsComment_on_tableContext() +} + +type Comment_on_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_tableContext() *Comment_on_tableContext { + var p = new(Comment_on_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_table + return p +} + +func InitEmptyComment_on_tableContext(p *Comment_on_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_table +} + +func (*Comment_on_tableContext) IsComment_on_tableContext() {} + +func NewComment_on_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_tableContext { + var p = new(Comment_on_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_table + + return p +} + +func (s *Comment_on_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_tableContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Comment_on_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Comment_on_tableContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_tableContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_table(s) + } +} + +func (s *Comment_on_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_table(s) + } +} + +func (p *PlSqlParser) Comment_on_table() (localctx IComment_on_tableContext) { + localctx = NewComment_on_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1324, PlSqlParserRULE_comment_on_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13188) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13189) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13190) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13191) + p.Tableview_name() + } + { + p.SetState(13192) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13193) + p.Quoted_string() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComment_on_materializedContext is an interface to support dynamic dispatch. +type IComment_on_materializedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_materializedContext differentiates from other interfaces. + IsComment_on_materializedContext() +} + +type Comment_on_materializedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_materializedContext() *Comment_on_materializedContext { + var p = new(Comment_on_materializedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_materialized + return p +} + +func InitEmptyComment_on_materializedContext(p *Comment_on_materializedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_materialized +} + +func (*Comment_on_materializedContext) IsComment_on_materializedContext() {} + +func NewComment_on_materializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_materializedContext { + var p = new(Comment_on_materializedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_materialized + + return p +} + +func (s *Comment_on_materializedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_materializedContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_materializedContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_materializedContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Comment_on_materializedContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Comment_on_materializedContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Comment_on_materializedContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_materializedContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_materializedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_materializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_materializedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_materialized(s) + } +} + +func (s *Comment_on_materializedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_materialized(s) + } +} + +func (p *PlSqlParser) Comment_on_materialized() (localctx IComment_on_materializedContext) { + localctx = NewComment_on_materializedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1326, PlSqlParserRULE_comment_on_materialized) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13195) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13196) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13197) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13198) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13199) + p.Tableview_name() + } + { + p.SetState(13200) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13201) + p.Quoted_string() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_analytic_viewContext is an interface to support dynamic dispatch. +type IAlter_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Alter_add_cache_clause() IAlter_add_cache_clauseContext + Alter_drop_cache_clause() IAlter_drop_cache_clauseContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_analytic_viewContext differentiates from other interfaces. + IsAlter_analytic_viewContext() +} + +type Alter_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyAlter_analytic_viewContext() *Alter_analytic_viewContext { + var p = new(Alter_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_analytic_view + return p +} + +func InitEmptyAlter_analytic_viewContext(p *Alter_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_analytic_view +} + +func (*Alter_analytic_viewContext) IsAlter_analytic_viewContext() {} + +func NewAlter_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_analytic_viewContext { + var p = new(Alter_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_analytic_view + + return p +} + +func (s *Alter_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Alter_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Alter_analytic_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Alter_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_analytic_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_analytic_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_analytic_viewContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_analytic_viewContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_analytic_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_analytic_viewContext) Alter_add_cache_clause() IAlter_add_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_add_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_add_cache_clauseContext) +} + +func (s *Alter_analytic_viewContext) Alter_drop_cache_clause() IAlter_drop_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_drop_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_drop_cache_clauseContext) +} + +func (s *Alter_analytic_viewContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_analytic_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_analytic_view(s) + } +} + +func (s *Alter_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_analytic_view(s) + } +} + +func (p *PlSqlParser) Alter_analytic_view() (localctx IAlter_analytic_viewContext) { + localctx = NewAlter_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1328, PlSqlParserRULE_alter_analytic_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13203) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13204) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13205) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13209) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1698, p.GetParserRuleContext()) == 1 { + { + p.SetState(13206) + p.Schema_name() + } + { + p.SetState(13207) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13211) + + var _x = p.Id_expression() + + localctx.(*Alter_analytic_viewContext).av = _x + } + p.SetState(13218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(13212) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13213) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13214) + p.Id_expression() + } + + case PlSqlParserCOMPILE: + { + p.SetState(13215) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserADD: + { + p.SetState(13216) + p.Alter_add_cache_clause() + } + + case PlSqlParserDROP: + { + p.SetState(13217) + p.Alter_drop_cache_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_add_cache_clauseContext is an interface to support dynamic dispatch. +type IAlter_add_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + CACHE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + LEVELS() antlr.TerminalNode + AllLevels_item() []ILevels_itemContext + Levels_item(i int) ILevels_itemContext + ALL() antlr.TerminalNode + Measure_list() IMeasure_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_add_cache_clauseContext differentiates from other interfaces. + IsAlter_add_cache_clauseContext() +} + +type Alter_add_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_add_cache_clauseContext() *Alter_add_cache_clauseContext { + var p = new(Alter_add_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause + return p +} + +func InitEmptyAlter_add_cache_clauseContext(p *Alter_add_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause +} + +func (*Alter_add_cache_clauseContext) IsAlter_add_cache_clauseContext() {} + +func NewAlter_add_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_add_cache_clauseContext { + var p = new(Alter_add_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause + + return p +} + +func (s *Alter_add_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_add_cache_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_add_cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Alter_add_cache_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Alter_add_cache_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_add_cache_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_add_cache_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_add_cache_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_add_cache_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_add_cache_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Alter_add_cache_clauseContext) AllLevels_item() []ILevels_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_itemContext); ok { + len++ + } + } + + tst := make([]ILevels_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_itemContext); ok { + tst[i] = t.(ILevels_itemContext) + i++ + } + } + + return tst +} + +func (s *Alter_add_cache_clauseContext) Levels_item(i int) ILevels_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_itemContext) +} + +func (s *Alter_add_cache_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_add_cache_clauseContext) Measure_list() IMeasure_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasure_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasure_listContext) +} + +func (s *Alter_add_cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_add_cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_add_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_add_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_add_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_add_cache_clause(s) + } +} + +func (s *Alter_add_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_add_cache_clause(s) + } +} + +func (p *PlSqlParser) Alter_add_cache_clause() (localctx IAlter_add_cache_clauseContext) { + localctx = NewAlter_add_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1330, PlSqlParserRULE_alter_add_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13220) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13221) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13222) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13223) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13224) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(13225) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(13226) + p.Measure_list() + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(13229) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13230) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13231) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13232) + p.Levels_item() + } + p.SetState(13237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13233) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13234) + p.Levels_item() + } + + p.SetState(13239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13240) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevels_itemContext is an interface to support dynamic dispatch. +type ILevels_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsLevels_itemContext differentiates from other interfaces. + IsLevels_itemContext() +} + +type Levels_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext + h IId_expressionContext + l IId_expressionContext +} + +func NewEmptyLevels_itemContext() *Levels_itemContext { + var p = new(Levels_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_item + return p +} + +func InitEmptyLevels_itemContext(p *Levels_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_item +} + +func (*Levels_itemContext) IsLevels_itemContext() {} + +func NewLevels_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Levels_itemContext { + var p = new(Levels_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_levels_item + + return p +} + +func (s *Levels_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Levels_itemContext) GetD() IId_expressionContext { return s.d } + +func (s *Levels_itemContext) GetH() IId_expressionContext { return s.h } + +func (s *Levels_itemContext) GetL() IId_expressionContext { return s.l } + +func (s *Levels_itemContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Levels_itemContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Levels_itemContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Levels_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Levels_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Levels_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Levels_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Levels_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Levels_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Levels_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevels_item(s) + } +} + +func (s *Levels_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevels_item(s) + } +} + +func (p *PlSqlParser) Levels_item() (localctx ILevels_itemContext) { + localctx = NewLevels_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1332, PlSqlParserRULE_levels_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(13250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1703, p.GetParserRuleContext()) == 1 { + p.SetState(13245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1702, p.GetParserRuleContext()) == 1 { + { + p.SetState(13242) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).d = _x + } + { + p.SetState(13243) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13247) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).h = _x + } + { + p.SetState(13248) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13252) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).l = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMeasure_listContext is an interface to support dynamic dispatch. +type IMeasure_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMeasure_listContext differentiates from other interfaces. + IsMeasure_listContext() +} + +type Measure_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeasure_listContext() *Measure_listContext { + var p = new(Measure_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measure_list + return p +} + +func InitEmptyMeasure_listContext(p *Measure_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measure_list +} + +func (*Measure_listContext) IsMeasure_listContext() {} + +func NewMeasure_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Measure_listContext { + var p = new(Measure_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_measure_list + + return p +} + +func (s *Measure_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Measure_listContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Measure_listContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Measure_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Measure_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Measure_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Measure_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Measure_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeasure_list(s) + } +} + +func (s *Measure_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeasure_list(s) + } +} + +func (p *PlSqlParser) Measure_list() (localctx IMeasure_listContext) { + localctx = NewMeasure_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1334, PlSqlParserRULE_measure_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13254) + p.Id_expression() + } + p.SetState(13259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13255) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13256) + p.Id_expression() + } + + p.SetState(13261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_drop_cache_clauseContext is an interface to support dynamic dispatch. +type IAlter_drop_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CACHE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + LEVELS() antlr.TerminalNode + AllLevels_item() []ILevels_itemContext + Levels_item(i int) ILevels_itemContext + ALL() antlr.TerminalNode + Measure_list() IMeasure_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_drop_cache_clauseContext differentiates from other interfaces. + IsAlter_drop_cache_clauseContext() +} + +type Alter_drop_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_drop_cache_clauseContext() *Alter_drop_cache_clauseContext { + var p = new(Alter_drop_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause + return p +} + +func InitEmptyAlter_drop_cache_clauseContext(p *Alter_drop_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause +} + +func (*Alter_drop_cache_clauseContext) IsAlter_drop_cache_clauseContext() {} + +func NewAlter_drop_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_drop_cache_clauseContext { + var p = new(Alter_drop_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause + + return p +} + +func (s *Alter_drop_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_drop_cache_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_drop_cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Alter_drop_cache_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Alter_drop_cache_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_drop_cache_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_drop_cache_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_drop_cache_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_drop_cache_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_drop_cache_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Alter_drop_cache_clauseContext) AllLevels_item() []ILevels_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_itemContext); ok { + len++ + } + } + + tst := make([]ILevels_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_itemContext); ok { + tst[i] = t.(ILevels_itemContext) + i++ + } + } + + return tst +} + +func (s *Alter_drop_cache_clauseContext) Levels_item(i int) ILevels_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_itemContext) +} + +func (s *Alter_drop_cache_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_drop_cache_clauseContext) Measure_list() IMeasure_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasure_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasure_listContext) +} + +func (s *Alter_drop_cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_drop_cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_drop_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_drop_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_drop_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_drop_cache_clause(s) + } +} + +func (s *Alter_drop_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_drop_cache_clause(s) + } +} + +func (p *PlSqlParser) Alter_drop_cache_clause() (localctx IAlter_drop_cache_clauseContext) { + localctx = NewAlter_drop_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1336, PlSqlParserRULE_alter_drop_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13262) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13263) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13264) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13265) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13266) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(13267) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(13268) + p.Measure_list() + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(13271) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13272) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13273) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13274) + p.Levels_item() + } + p.SetState(13279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13275) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13276) + p.Levels_item() + } + + p.SetState(13281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13282) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_attribute_dimensionContext is an interface to support dynamic dispatch. +type IAlter_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // GetNad returns the nad rule contexts. + GetNad() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // SetNad sets the nad rule contexts. + SetNad(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_attribute_dimensionContext differentiates from other interfaces. + IsAlter_attribute_dimensionContext() +} + +type Alter_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext + nad IId_expressionContext +} + +func NewEmptyAlter_attribute_dimensionContext() *Alter_attribute_dimensionContext { + var p = new(Alter_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension + return p +} + +func InitEmptyAlter_attribute_dimensionContext(p *Alter_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension +} + +func (*Alter_attribute_dimensionContext) IsAlter_attribute_dimensionContext() {} + +func NewAlter_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_attribute_dimensionContext { + var p = new(Alter_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension + + return p +} + +func (s *Alter_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Alter_attribute_dimensionContext) GetNad() IId_expressionContext { return s.nad } + +func (s *Alter_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Alter_attribute_dimensionContext) SetNad(v IId_expressionContext) { s.nad = v } + +func (s *Alter_attribute_dimensionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Alter_attribute_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Alter_attribute_dimensionContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_attribute_dimensionContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_attribute_dimensionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_attribute_dimensionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_attribute_dimensionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_attribute_dimensionContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_attribute_dimension(s) + } +} + +func (s *Alter_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_attribute_dimension(s) + } +} + +func (p *PlSqlParser) Alter_attribute_dimension() (localctx IAlter_attribute_dimensionContext) { + localctx = NewAlter_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1338, PlSqlParserRULE_alter_attribute_dimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13284) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13285) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13286) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13290) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1707, p.GetParserRuleContext()) == 1 { + { + p.SetState(13287) + p.Schema_name() + } + { + p.SetState(13288) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13292) + + var _x = p.Id_expression() + + localctx.(*Alter_attribute_dimensionContext).ad = _x + } + p.SetState(13297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(13293) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13294) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13295) + + var _x = p.Id_expression() + + localctx.(*Alter_attribute_dimensionContext).nad = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(13296) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_audit_policyContext is an interface to support dynamic dispatch. +type IAlter_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + ADD() antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + CONDITION() antlr.TerminalNode + AllPrivilege_audit_clause() []IPrivilege_audit_clauseContext + Privilege_audit_clause(i int) IPrivilege_audit_clauseContext + AllAction_audit_clause() []IAction_audit_clauseContext + Action_audit_clause(i int) IAction_audit_clauseContext + AllRole_audit_clause() []IRole_audit_clauseContext + Role_audit_clause(i int) IRole_audit_clauseContext + AllONLY() []antlr.TerminalNode + ONLY(i int) antlr.TerminalNode + AllTOPLEVEL() []antlr.TerminalNode + TOPLEVEL(i int) antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + EVALUATE() antlr.TerminalNode + PER() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + + // IsAlter_audit_policyContext differentiates from other interfaces. + IsAlter_audit_policyContext() +} + +type Alter_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyAlter_audit_policyContext() *Alter_audit_policyContext { + var p = new(Alter_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_audit_policy + return p +} + +func InitEmptyAlter_audit_policyContext(p *Alter_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_audit_policy +} + +func (*Alter_audit_policyContext) IsAlter_audit_policyContext() {} + +func NewAlter_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_audit_policyContext { + var p = new(Alter_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_audit_policy + + return p +} + +func (s *Alter_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Alter_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Alter_audit_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Alter_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Alter_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_audit_policyContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_audit_policyContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Alter_audit_policyContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Alter_audit_policyContext) CONDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITION, 0) +} + +func (s *Alter_audit_policyContext) AllPrivilege_audit_clause() []IPrivilege_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IPrivilege_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivilege_audit_clauseContext); ok { + tst[i] = t.(IPrivilege_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Privilege_audit_clause(i int) IPrivilege_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllAction_audit_clause() []IAction_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IAction_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAction_audit_clauseContext); ok { + tst[i] = t.(IAction_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Action_audit_clause(i int) IAction_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAction_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllRole_audit_clause() []IRole_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IRole_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_audit_clauseContext); ok { + tst[i] = t.(IRole_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Role_audit_clause(i int) IRole_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllONLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLY) +} + +func (s *Alter_audit_policyContext) ONLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, i) +} + +func (s *Alter_audit_policyContext) AllTOPLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTOPLEVEL) +} + +func (s *Alter_audit_policyContext) TOPLEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, i) +} + +func (s *Alter_audit_policyContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Alter_audit_policyContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Alter_audit_policyContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Alter_audit_policyContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Alter_audit_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Alter_audit_policyContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Alter_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_audit_policy(s) + } +} + +func (s *Alter_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_audit_policy(s) + } +} + +func (p *PlSqlParser) Alter_audit_policy() (localctx IAlter_audit_policyContext) { + localctx = NewAlter_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1340, PlSqlParserRULE_alter_audit_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13299) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13300) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13301) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13302) + + var _x = p.Id_expression() + + localctx.(*Alter_audit_policyContext).p = _x + } + p.SetState(13304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(13303) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1714, p.GetParserRuleContext()) { + case 1: + p.SetState(13307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1710, p.GetParserRuleContext()) == 1 { + { + p.SetState(13306) + p.Privilege_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13310) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1711, p.GetParserRuleContext()) == 1 { + { + p.SetState(13309) + p.Action_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13313) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1712, p.GetParserRuleContext()) == 1 { + { + p.SetState(13312) + p.Role_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(13317) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1713, p.GetParserRuleContext()) == 1 { + { + p.SetState(13315) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13316) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(13322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP { + { + p.SetState(13321) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1720, p.GetParserRuleContext()) { + case 1: + p.SetState(13325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(13324) + p.Privilege_audit_clause() + } + + } + p.SetState(13328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACTIONS { + { + p.SetState(13327) + p.Action_audit_clause() + } + + } + p.SetState(13331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserROLES { + { + p.SetState(13330) + p.Role_audit_clause() + } + + } + + case 2: + p.SetState(13335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLY { + { + p.SetState(13333) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13334) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(13347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONDITION { + { + p.SetState(13339) + p.Match(PlSqlParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDROP: + { + p.SetState(13340) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHAR_STRING: + { + p.SetState(13341) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13342) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13343) + p.Match(PlSqlParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13344) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINSTANCE || _la == PlSqlParserSESSION || _la == PlSqlParserSTATEMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_clusterContext is an interface to support dynamic dispatch. +type IAlter_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllCache_or_nocache() []ICache_or_nocacheContext + Cache_or_nocache(i int) ICache_or_nocacheContext + Parallel_clause() IParallel_clauseContext + + // IsAlter_clusterContext differentiates from other interfaces. + IsAlter_clusterContext() +} + +type Alter_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_clusterContext() *Alter_clusterContext { + var p = new(Alter_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_cluster + return p +} + +func InitEmptyAlter_clusterContext(p *Alter_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_cluster +} + +func (*Alter_clusterContext) IsAlter_clusterContext() {} + +func NewAlter_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_clusterContext { + var p = new(Alter_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_cluster + + return p +} + +func (s *Alter_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_clusterContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Alter_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Alter_clusterContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_clusterContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Alter_clusterContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Alter_clusterContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_clusterContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_clusterContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_clusterContext) AllCache_or_nocache() []ICache_or_nocacheContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + len++ + } + } + + tst := make([]ICache_or_nocacheContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICache_or_nocacheContext); ok { + tst[i] = t.(ICache_or_nocacheContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Cache_or_nocache(i int) ICache_or_nocacheContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_clusterContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_cluster(s) + } +} + +func (s *Alter_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_cluster(s) + } +} + +func (p *PlSqlParser) Alter_cluster() (localctx IAlter_clusterContext) { + localctx = NewAlter_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1342, PlSqlParserRULE_alter_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13349) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13350) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13351) + p.Cluster_name() + } + p.SetState(13358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCACHE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCACHE || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSIZE || _la == PlSqlParserSTORAGE { + p.SetState(13358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(13352) + p.Physical_attributes_clause() + } + + case PlSqlParserSIZE: + { + p.SetState(13353) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13354) + p.Size_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(13355) + p.Allocate_extent_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(13356) + p.Deallocate_unused_clause() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(13357) + p.Cache_or_nocache() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(13362) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_analytic_viewContext is an interface to support dynamic dispatch. +type IDrop_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_analytic_viewContext differentiates from other interfaces. + IsDrop_analytic_viewContext() +} + +type Drop_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyDrop_analytic_viewContext() *Drop_analytic_viewContext { + var p = new(Drop_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_analytic_view + return p +} + +func InitEmptyDrop_analytic_viewContext(p *Drop_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_analytic_view +} + +func (*Drop_analytic_viewContext) IsDrop_analytic_viewContext() {} + +func NewDrop_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_analytic_viewContext { + var p = new(Drop_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_analytic_view + + return p +} + +func (s *Drop_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Drop_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Drop_analytic_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Drop_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_analytic_viewContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_analytic_viewContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_analytic_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_analytic_view(s) + } +} + +func (s *Drop_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_analytic_view(s) + } +} + +func (p *PlSqlParser) Drop_analytic_view() (localctx IDrop_analytic_viewContext) { + localctx = NewDrop_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1344, PlSqlParserRULE_drop_analytic_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13365) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13366) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13367) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13371) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1726, p.GetParserRuleContext()) == 1 { + { + p.SetState(13368) + p.Schema_name() + } + { + p.SetState(13369) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13373) + + var _x = p.Id_expression() + + localctx.(*Drop_analytic_viewContext).av = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_attribute_dimensionContext is an interface to support dynamic dispatch. +type IDrop_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_attribute_dimensionContext differentiates from other interfaces. + IsDrop_attribute_dimensionContext() +} + +type Drop_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyDrop_attribute_dimensionContext() *Drop_attribute_dimensionContext { + var p = new(Drop_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension + return p +} + +func InitEmptyDrop_attribute_dimensionContext(p *Drop_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension +} + +func (*Drop_attribute_dimensionContext) IsDrop_attribute_dimensionContext() {} + +func NewDrop_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_attribute_dimensionContext { + var p = new(Drop_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension + + return p +} + +func (s *Drop_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Drop_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Drop_attribute_dimensionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Drop_attribute_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Drop_attribute_dimensionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_attribute_dimensionContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_attribute_dimension(s) + } +} + +func (s *Drop_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_attribute_dimension(s) + } +} + +func (p *PlSqlParser) Drop_attribute_dimension() (localctx IDrop_attribute_dimensionContext) { + localctx = NewDrop_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1346, PlSqlParserRULE_drop_attribute_dimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13375) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13376) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13377) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13381) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1727, p.GetParserRuleContext()) == 1 { + { + p.SetState(13378) + p.Schema_name() + } + { + p.SetState(13379) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13383) + + var _x = p.Id_expression() + + localctx.(*Drop_attribute_dimensionContext).ad = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_audit_policyContext is an interface to support dynamic dispatch. +type IDrop_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_audit_policyContext differentiates from other interfaces. + IsDrop_audit_policyContext() +} + +type Drop_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyDrop_audit_policyContext() *Drop_audit_policyContext { + var p = new(Drop_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_audit_policy + return p +} + +func InitEmptyDrop_audit_policyContext(p *Drop_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_audit_policy +} + +func (*Drop_audit_policyContext) IsDrop_audit_policyContext() {} + +func NewDrop_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_audit_policyContext { + var p = new(Drop_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_audit_policy + + return p +} + +func (s *Drop_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Drop_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Drop_audit_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Drop_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Drop_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_audit_policy(s) + } +} + +func (s *Drop_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_audit_policy(s) + } +} + +func (p *PlSqlParser) Drop_audit_policy() (localctx IDrop_audit_policyContext) { + localctx = NewDrop_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1348, PlSqlParserRULE_drop_audit_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13385) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13386) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13387) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13388) + + var _x = p.Id_expression() + + localctx.(*Drop_audit_policyContext).p = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_flashback_archiveContext is an interface to support dynamic dispatch. +type IDrop_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_flashback_archiveContext differentiates from other interfaces. + IsDrop_flashback_archiveContext() +} + +type Drop_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext +} + +func NewEmptyDrop_flashback_archiveContext() *Drop_flashback_archiveContext { + var p = new(Drop_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive + return p +} + +func InitEmptyDrop_flashback_archiveContext(p *Drop_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive +} + +func (*Drop_flashback_archiveContext) IsDrop_flashback_archiveContext() {} + +func NewDrop_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_flashback_archiveContext { + var p = new(Drop_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive + + return p +} + +func (s *Drop_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Drop_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Drop_flashback_archiveContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Drop_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Drop_flashback_archiveContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_flashback_archive(s) + } +} + +func (s *Drop_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_flashback_archive(s) + } +} + +func (p *PlSqlParser) Drop_flashback_archive() (localctx IDrop_flashback_archiveContext) { + localctx = NewDrop_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1350, PlSqlParserRULE_drop_flashback_archive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13390) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13391) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13392) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13393) + + var _x = p.Id_expression() + + localctx.(*Drop_flashback_archiveContext).fa = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_clusterContext is an interface to support dynamic dispatch. +type IDrop_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + INCLUDING() antlr.TerminalNode + TABLES() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + + // IsDrop_clusterContext differentiates from other interfaces. + IsDrop_clusterContext() +} + +type Drop_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_clusterContext() *Drop_clusterContext { + var p = new(Drop_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_cluster + return p +} + +func InitEmptyDrop_clusterContext(p *Drop_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_cluster +} + +func (*Drop_clusterContext) IsDrop_clusterContext() {} + +func NewDrop_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_clusterContext { + var p = new(Drop_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_cluster + + return p +} + +func (s *Drop_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_clusterContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Drop_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Drop_clusterContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_clusterContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Drop_clusterContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_clusterContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Drop_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_cluster(s) + } +} + +func (s *Drop_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_cluster(s) + } +} + +func (p *PlSqlParser) Drop_cluster() (localctx IDrop_clusterContext) { + localctx = NewDrop_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1352, PlSqlParserRULE_drop_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13395) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13396) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13397) + p.Cluster_name() + } + p.SetState(13404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(13398) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13399) + p.Match(PlSqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13400) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13401) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_contextContext is an interface to support dynamic dispatch. +type IDrop_contextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNs returns the ns rule contexts. + GetNs() IId_expressionContext + + // SetNs sets the ns rule contexts. + SetNs(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_contextContext differentiates from other interfaces. + IsDrop_contextContext() +} + +type Drop_contextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ns IId_expressionContext +} + +func NewEmptyDrop_contextContext() *Drop_contextContext { + var p = new(Drop_contextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_context + return p +} + +func InitEmptyDrop_contextContext(p *Drop_contextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_context +} + +func (*Drop_contextContext) IsDrop_contextContext() {} + +func NewDrop_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_contextContext { + var p = new(Drop_contextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_context + + return p +} + +func (s *Drop_contextContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_contextContext) GetNs() IId_expressionContext { return s.ns } + +func (s *Drop_contextContext) SetNs(v IId_expressionContext) { s.ns = v } + +func (s *Drop_contextContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_contextContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Drop_contextContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_contextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_contextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_context(s) + } +} + +func (s *Drop_contextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_context(s) + } +} + +func (p *PlSqlParser) Drop_context() (localctx IDrop_contextContext) { + localctx = NewDrop_contextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1354, PlSqlParserRULE_drop_context) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13406) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13407) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13408) + + var _x = p.Id_expression() + + localctx.(*Drop_contextContext).ns = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_directoryContext is an interface to support dynamic dispatch. +type IDrop_directoryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDn returns the dn rule contexts. + GetDn() IId_expressionContext + + // SetDn sets the dn rule contexts. + SetDn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_directoryContext differentiates from other interfaces. + IsDrop_directoryContext() +} + +type Drop_directoryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dn IId_expressionContext +} + +func NewEmptyDrop_directoryContext() *Drop_directoryContext { + var p = new(Drop_directoryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_directory + return p +} + +func InitEmptyDrop_directoryContext(p *Drop_directoryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_directory +} + +func (*Drop_directoryContext) IsDrop_directoryContext() {} + +func NewDrop_directoryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_directoryContext { + var p = new(Drop_directoryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_directory + + return p +} + +func (s *Drop_directoryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_directoryContext) GetDn() IId_expressionContext { return s.dn } + +func (s *Drop_directoryContext) SetDn(v IId_expressionContext) { s.dn = v } + +func (s *Drop_directoryContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_directoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Drop_directoryContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_directoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_directoryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_directoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_directory(s) + } +} + +func (s *Drop_directoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_directory(s) + } +} + +func (p *PlSqlParser) Drop_directory() (localctx IDrop_directoryContext) { + localctx = NewDrop_directoryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1356, PlSqlParserRULE_drop_directory) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13410) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13411) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13412) + + var _x = p.Id_expression() + + localctx.(*Drop_directoryContext).dn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_diskgroupContext is an interface to support dynamic dispatch. +type IDrop_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDgn returns the dgn rule contexts. + GetDgn() IId_expressionContext + + // SetDgn sets the dgn rule contexts. + SetDgn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + CONTENTS() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_diskgroupContext differentiates from other interfaces. + IsDrop_diskgroupContext() +} + +type Drop_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dgn IId_expressionContext +} + +func NewEmptyDrop_diskgroupContext() *Drop_diskgroupContext { + var p = new(Drop_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup + return p +} + +func InitEmptyDrop_diskgroupContext(p *Drop_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup +} + +func (*Drop_diskgroupContext) IsDrop_diskgroupContext() {} + +func NewDrop_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_diskgroupContext { + var p = new(Drop_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_diskgroup + + return p +} + +func (s *Drop_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_diskgroupContext) GetDgn() IId_expressionContext { return s.dgn } + +func (s *Drop_diskgroupContext) SetDgn(v IId_expressionContext) { s.dgn = v } + +func (s *Drop_diskgroupContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Drop_diskgroupContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_diskgroupContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Drop_diskgroupContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_diskgroupContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Drop_diskgroupContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_diskgroup(s) + } +} + +func (s *Drop_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_diskgroup(s) + } +} + +func (p *PlSqlParser) Drop_diskgroup() (localctx IDrop_diskgroupContext) { + localctx = NewDrop_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1358, PlSqlParserRULE_drop_diskgroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13414) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13415) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13416) + + var _x = p.Id_expression() + + localctx.(*Drop_diskgroupContext).dgn = _x + } + p.SetState(13425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserFORCE || _la == PlSqlParserINCLUDING { + p.SetState(13422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFORCE, PlSqlParserINCLUDING: + p.SetState(13418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(13417) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13420) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLUDING: + { + p.SetState(13421) + p.Match(PlSqlParserEXCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13424) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_editionContext is an interface to support dynamic dispatch. +type IDrop_editionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetE returns the e rule contexts. + GetE() IId_expressionContext + + // SetE sets the e rule contexts. + SetE(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + EDITION() antlr.TerminalNode + Id_expression() IId_expressionContext + CASCADE() antlr.TerminalNode + + // IsDrop_editionContext differentiates from other interfaces. + IsDrop_editionContext() +} + +type Drop_editionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + e IId_expressionContext +} + +func NewEmptyDrop_editionContext() *Drop_editionContext { + var p = new(Drop_editionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_edition + return p +} + +func InitEmptyDrop_editionContext(p *Drop_editionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_edition +} + +func (*Drop_editionContext) IsDrop_editionContext() {} + +func NewDrop_editionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_editionContext { + var p = new(Drop_editionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_edition + + return p +} + +func (s *Drop_editionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_editionContext) GetE() IId_expressionContext { return s.e } + +func (s *Drop_editionContext) SetE(v IId_expressionContext) { s.e = v } + +func (s *Drop_editionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_editionContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Drop_editionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_editionContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_editionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_editionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_editionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_edition(s) + } +} + +func (s *Drop_editionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_edition(s) + } +} + +func (p *PlSqlParser) Drop_edition() (localctx IDrop_editionContext) { + localctx = NewDrop_editionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1360, PlSqlParserRULE_drop_edition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13427) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13428) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13429) + + var _x = p.Id_expression() + + localctx.(*Drop_editionContext).e = _x + } + p.SetState(13431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(13430) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_clusterContext is an interface to support dynamic dispatch. +type ITruncate_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + STORAGE() antlr.TerminalNode + DROP() antlr.TerminalNode + REUSE() antlr.TerminalNode + + // IsTruncate_clusterContext differentiates from other interfaces. + IsTruncate_clusterContext() +} + +type Truncate_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_clusterContext() *Truncate_clusterContext { + var p = new(Truncate_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_cluster + return p +} + +func InitEmptyTruncate_clusterContext(p *Truncate_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_cluster +} + +func (*Truncate_clusterContext) IsTruncate_clusterContext() {} + +func NewTruncate_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_clusterContext { + var p = new(Truncate_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_truncate_cluster + + return p +} + +func (s *Truncate_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_clusterContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Truncate_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Truncate_clusterContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Truncate_clusterContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Truncate_clusterContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Truncate_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTruncate_cluster(s) + } +} + +func (s *Truncate_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_cluster(s) + } +} + +func (p *PlSqlParser) Truncate_cluster() (localctx ITruncate_clusterContext) { + localctx = NewTruncate_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1362, PlSqlParserRULE_truncate_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13433) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13434) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13435) + p.Cluster_name() + } + p.SetState(13438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserREUSE { + { + p.SetState(13436) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserREUSE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13437) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICache_or_nocacheContext is an interface to support dynamic dispatch. +type ICache_or_nocacheContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + + // IsCache_or_nocacheContext differentiates from other interfaces. + IsCache_or_nocacheContext() +} + +type Cache_or_nocacheContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_or_nocacheContext() *Cache_or_nocacheContext { + var p = new(Cache_or_nocacheContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_or_nocache + return p +} + +func InitEmptyCache_or_nocacheContext(p *Cache_or_nocacheContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_or_nocache +} + +func (*Cache_or_nocacheContext) IsCache_or_nocacheContext() {} + +func NewCache_or_nocacheContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_or_nocacheContext { + var p = new(Cache_or_nocacheContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_or_nocache + + return p +} + +func (s *Cache_or_nocacheContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_or_nocacheContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Cache_or_nocacheContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Cache_or_nocacheContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_or_nocacheContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_or_nocacheContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_or_nocache(s) + } +} + +func (s *Cache_or_nocacheContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_or_nocache(s) + } +} + +func (p *PlSqlParser) Cache_or_nocache() (localctx ICache_or_nocacheContext) { + localctx = NewCache_or_nocacheContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1364, PlSqlParserRULE_cache_or_nocache) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13440) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_nameContext is an interface to support dynamic dispatch. +type IDatabase_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDatabase_nameContext differentiates from other interfaces. + IsDatabase_nameContext() +} + +type Database_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_nameContext() *Database_nameContext { + var p = new(Database_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_name + return p +} + +func InitEmptyDatabase_nameContext(p *Database_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_name +} + +func (*Database_nameContext) IsDatabase_nameContext() {} + +func NewDatabase_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_nameContext { + var p = new(Database_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_name + + return p +} + +func (s *Database_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Database_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_name(s) + } +} + +func (s *Database_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_name(s) + } +} + +func (p *PlSqlParser) Database_name() (localctx IDatabase_nameContext) { + localctx = NewDatabase_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1366, PlSqlParserRULE_database_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13442) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_databaseContext is an interface to support dynamic dispatch. +type IAlter_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + Database_clause() IDatabase_clauseContext + Startup_clauses() IStartup_clausesContext + Recovery_clauses() IRecovery_clausesContext + Database_file_clauses() IDatabase_file_clausesContext + Logfile_clauses() ILogfile_clausesContext + Controlfile_clauses() IControlfile_clausesContext + Standby_database_clauses() IStandby_database_clausesContext + Default_settings_clause() IDefault_settings_clauseContext + Instance_clauses() IInstance_clausesContext + Security_clause() ISecurity_clauseContext + Prepare_clause() IPrepare_clauseContext + Drop_mirror_clause() IDrop_mirror_clauseContext + Lost_write_protection() ILost_write_protectionContext + Cdb_fleet_clauses() ICdb_fleet_clausesContext + Property_clauses() IProperty_clausesContext + Replay_upgrade_clauses() IReplay_upgrade_clausesContext + + // IsAlter_databaseContext differentiates from other interfaces. + IsAlter_databaseContext() +} + +type Alter_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_databaseContext() *Alter_databaseContext { + var p = new(Alter_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database + return p +} + +func InitEmptyAlter_databaseContext(p *Alter_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database +} + +func (*Alter_databaseContext) IsAlter_databaseContext() {} + +func NewAlter_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_databaseContext { + var p = new(Alter_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_database + + return p +} + +func (s *Alter_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_databaseContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_databaseContext) Database_clause() IDatabase_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_clauseContext) +} + +func (s *Alter_databaseContext) Startup_clauses() IStartup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStartup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStartup_clausesContext) +} + +func (s *Alter_databaseContext) Recovery_clauses() IRecovery_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecovery_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecovery_clausesContext) +} + +func (s *Alter_databaseContext) Database_file_clauses() IDatabase_file_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_file_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_file_clausesContext) +} + +func (s *Alter_databaseContext) Logfile_clauses() ILogfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_clausesContext) +} + +func (s *Alter_databaseContext) Controlfile_clauses() IControlfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlfile_clausesContext) +} + +func (s *Alter_databaseContext) Standby_database_clauses() IStandby_database_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandby_database_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandby_database_clausesContext) +} + +func (s *Alter_databaseContext) Default_settings_clause() IDefault_settings_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_settings_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_settings_clauseContext) +} + +func (s *Alter_databaseContext) Instance_clauses() IInstance_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInstance_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInstance_clausesContext) +} + +func (s *Alter_databaseContext) Security_clause() ISecurity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_clauseContext) +} + +func (s *Alter_databaseContext) Prepare_clause() IPrepare_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrepare_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrepare_clauseContext) +} + +func (s *Alter_databaseContext) Drop_mirror_clause() IDrop_mirror_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_mirror_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_mirror_clauseContext) +} + +func (s *Alter_databaseContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Alter_databaseContext) Cdb_fleet_clauses() ICdb_fleet_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICdb_fleet_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICdb_fleet_clausesContext) +} + +func (s *Alter_databaseContext) Property_clauses() IProperty_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_clausesContext) +} + +func (s *Alter_databaseContext) Replay_upgrade_clauses() IReplay_upgrade_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplay_upgrade_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplay_upgrade_clausesContext) +} + +func (s *Alter_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_database(s) + } +} + +func (s *Alter_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_database(s) + } +} + +func (p *PlSqlParser) Alter_database() (localctx IAlter_databaseContext) { + localctx = NewAlter_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1368, PlSqlParserRULE_alter_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13444) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13445) + p.Database_clause() + } + p.SetState(13461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1735, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13446) + p.Startup_clauses() + } + + case 2: + { + p.SetState(13447) + p.Recovery_clauses() + } + + case 3: + { + p.SetState(13448) + p.Database_file_clauses() + } + + case 4: + { + p.SetState(13449) + p.Logfile_clauses() + } + + case 5: + { + p.SetState(13450) + p.Controlfile_clauses() + } + + case 6: + { + p.SetState(13451) + p.Standby_database_clauses() + } + + case 7: + { + p.SetState(13452) + p.Default_settings_clause() + } + + case 8: + { + p.SetState(13453) + p.Instance_clauses() + } + + case 9: + { + p.SetState(13454) + p.Security_clause() + } + + case 10: + { + p.SetState(13455) + p.Prepare_clause() + } + + case 11: + { + p.SetState(13456) + p.Drop_mirror_clause() + } + + case 12: + { + p.SetState(13457) + p.Lost_write_protection() + } + + case 13: + { + p.SetState(13458) + p.Cdb_fleet_clauses() + } + + case 14: + { + p.SetState(13459) + p.Property_clauses() + } + + case 15: + { + p.SetState(13460) + p.Replay_upgrade_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_clauseContext is an interface to support dynamic dispatch. +type IDatabase_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + Database_name() IDatabase_nameContext + + // IsDatabase_clauseContext differentiates from other interfaces. + IsDatabase_clauseContext() +} + +type Database_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_clauseContext() *Database_clauseContext { + var p = new(Database_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_clause + return p +} + +func InitEmptyDatabase_clauseContext(p *Database_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_clause +} + +func (*Database_clauseContext) IsDatabase_clauseContext() {} + +func NewDatabase_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_clauseContext { + var p = new(Database_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_clause + + return p +} + +func (s *Database_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Database_clauseContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Database_clauseContext) Database_name() IDatabase_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_nameContext) +} + +func (s *Database_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_clause(s) + } +} + +func (s *Database_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_clause(s) + } +} + +func (p *PlSqlParser) Database_clause() (localctx IDatabase_clauseContext) { + localctx = NewDatabase_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1370, PlSqlParserRULE_database_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPLUGGABLE { + { + p.SetState(13463) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13466) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13468) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1737, p.GetParserRuleContext()) == 1 { + { + p.SetState(13467) + p.Database_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStartup_clausesContext is an interface to support dynamic dispatch. +type IStartup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + CLONE() antlr.TerminalNode + OPEN() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + Resetlogs_or_noresetlogs() IResetlogs_or_noresetlogsContext + Upgrade_or_downgrade() IUpgrade_or_downgradeContext + ONLY() antlr.TerminalNode + + // IsStartup_clausesContext differentiates from other interfaces. + IsStartup_clausesContext() +} + +type Startup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStartup_clausesContext() *Startup_clausesContext { + var p = new(Startup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_startup_clauses + return p +} + +func InitEmptyStartup_clausesContext(p *Startup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_startup_clauses +} + +func (*Startup_clausesContext) IsStartup_clausesContext() {} + +func NewStartup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Startup_clausesContext { + var p = new(Startup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_startup_clauses + + return p +} + +func (s *Startup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Startup_clausesContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Startup_clausesContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Startup_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Startup_clausesContext) CLONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLONE, 0) +} + +func (s *Startup_clausesContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Startup_clausesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Startup_clausesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Startup_clausesContext) Resetlogs_or_noresetlogs() IResetlogs_or_noresetlogsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResetlogs_or_noresetlogsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResetlogs_or_noresetlogsContext) +} + +func (s *Startup_clausesContext) Upgrade_or_downgrade() IUpgrade_or_downgradeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpgrade_or_downgradeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpgrade_or_downgradeContext) +} + +func (s *Startup_clausesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Startup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Startup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Startup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStartup_clauses(s) + } +} + +func (s *Startup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStartup_clauses(s) + } +} + +func (p *PlSqlParser) Startup_clauses() (localctx IStartup_clausesContext) { + localctx = NewStartup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1372, PlSqlParserRULE_startup_clauses) + var _la int + + p.SetState(13489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1742, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13470) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLONE || _la == PlSqlParserSTANDBY { + { + p.SetState(13471) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLONE || _la == PlSqlParserSTANDBY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13472) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13475) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREAD { + { + p.SetState(13476) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13477) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS { + { + p.SetState(13480) + p.Resetlogs_or_noresetlogs() + } + + } + p.SetState(13484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOWNGRADE || _la == PlSqlParserUPGRADE { + { + p.SetState(13483) + p.Upgrade_or_downgrade() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13486) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13487) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13488) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResetlogs_or_noresetlogsContext is an interface to support dynamic dispatch. +type IResetlogs_or_noresetlogsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + + // IsResetlogs_or_noresetlogsContext differentiates from other interfaces. + IsResetlogs_or_noresetlogsContext() +} + +type Resetlogs_or_noresetlogsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResetlogs_or_noresetlogsContext() *Resetlogs_or_noresetlogsContext { + var p = new(Resetlogs_or_noresetlogsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs + return p +} + +func InitEmptyResetlogs_or_noresetlogsContext(p *Resetlogs_or_noresetlogsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs +} + +func (*Resetlogs_or_noresetlogsContext) IsResetlogs_or_noresetlogsContext() {} + +func NewResetlogs_or_noresetlogsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resetlogs_or_noresetlogsContext { + var p = new(Resetlogs_or_noresetlogsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs + + return p +} + +func (s *Resetlogs_or_noresetlogsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resetlogs_or_noresetlogsContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Resetlogs_or_noresetlogsContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Resetlogs_or_noresetlogsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resetlogs_or_noresetlogsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resetlogs_or_noresetlogsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResetlogs_or_noresetlogs(s) + } +} + +func (s *Resetlogs_or_noresetlogsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResetlogs_or_noresetlogs(s) + } +} + +func (p *PlSqlParser) Resetlogs_or_noresetlogs() (localctx IResetlogs_or_noresetlogsContext) { + localctx = NewResetlogs_or_noresetlogsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1374, PlSqlParserRULE_resetlogs_or_noresetlogs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13491) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpgrade_or_downgradeContext is an interface to support dynamic dispatch. +type IUpgrade_or_downgradeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + DOWNGRADE() antlr.TerminalNode + + // IsUpgrade_or_downgradeContext differentiates from other interfaces. + IsUpgrade_or_downgradeContext() +} + +type Upgrade_or_downgradeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpgrade_or_downgradeContext() *Upgrade_or_downgradeContext { + var p = new(Upgrade_or_downgradeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade + return p +} + +func InitEmptyUpgrade_or_downgradeContext(p *Upgrade_or_downgradeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade +} + +func (*Upgrade_or_downgradeContext) IsUpgrade_or_downgradeContext() {} + +func NewUpgrade_or_downgradeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upgrade_or_downgradeContext { + var p = new(Upgrade_or_downgradeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade + + return p +} + +func (s *Upgrade_or_downgradeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upgrade_or_downgradeContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Upgrade_or_downgradeContext) DOWNGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOWNGRADE, 0) +} + +func (s *Upgrade_or_downgradeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upgrade_or_downgradeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upgrade_or_downgradeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpgrade_or_downgrade(s) + } +} + +func (s *Upgrade_or_downgradeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpgrade_or_downgrade(s) + } +} + +func (p *PlSqlParser) Upgrade_or_downgrade() (localctx IUpgrade_or_downgradeContext) { + localctx = NewUpgrade_or_downgradeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1376, PlSqlParserRULE_upgrade_or_downgrade) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13493) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDOWNGRADE || _la == PlSqlParserUPGRADE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecovery_clausesContext is an interface to support dynamic dispatch. +type IRecovery_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + General_recovery() IGeneral_recoveryContext + Managed_standby_recovery() IManaged_standby_recoveryContext + Begin_or_end() IBegin_or_endContext + BACKUP() antlr.TerminalNode + + // IsRecovery_clausesContext differentiates from other interfaces. + IsRecovery_clausesContext() +} + +type Recovery_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecovery_clausesContext() *Recovery_clausesContext { + var p = new(Recovery_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_recovery_clauses + return p +} + +func InitEmptyRecovery_clausesContext(p *Recovery_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_recovery_clauses +} + +func (*Recovery_clausesContext) IsRecovery_clausesContext() {} + +func NewRecovery_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recovery_clausesContext { + var p = new(Recovery_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_recovery_clauses + + return p +} + +func (s *Recovery_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Recovery_clausesContext) General_recovery() IGeneral_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_recoveryContext) +} + +func (s *Recovery_clausesContext) Managed_standby_recovery() IManaged_standby_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IManaged_standby_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IManaged_standby_recoveryContext) +} + +func (s *Recovery_clausesContext) Begin_or_end() IBegin_or_endContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_or_endContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_or_endContext) +} + +func (s *Recovery_clausesContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Recovery_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Recovery_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Recovery_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecovery_clauses(s) + } +} + +func (s *Recovery_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecovery_clauses(s) + } +} + +func (p *PlSqlParser) Recovery_clauses() (localctx IRecovery_clausesContext) { + localctx = NewRecovery_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1378, PlSqlParserRULE_recovery_clauses) + p.SetState(13500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1743, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13495) + p.General_recovery() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13496) + p.Managed_standby_recovery() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13497) + p.Begin_or_end() + } + { + p.SetState(13498) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_or_endContext is an interface to support dynamic dispatch. +type IBegin_or_endContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + + // IsBegin_or_endContext differentiates from other interfaces. + IsBegin_or_endContext() +} + +type Begin_or_endContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_or_endContext() *Begin_or_endContext { + var p = new(Begin_or_endContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_begin_or_end + return p +} + +func InitEmptyBegin_or_endContext(p *Begin_or_endContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_begin_or_end +} + +func (*Begin_or_endContext) IsBegin_or_endContext() {} + +func NewBegin_or_endContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_or_endContext { + var p = new(Begin_or_endContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_begin_or_end + + return p +} + +func (s *Begin_or_endContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_or_endContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Begin_or_endContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Begin_or_endContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_or_endContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_or_endContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBegin_or_end(s) + } +} + +func (s *Begin_or_endContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBegin_or_end(s) + } +} + +func (p *PlSqlParser) Begin_or_end() (localctx IBegin_or_endContext) { + localctx = NewBegin_or_endContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1380, PlSqlParserRULE_begin_or_end) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13502) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBEGIN || _la == PlSqlParserEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneral_recoveryContext is an interface to support dynamic dispatch. +type IGeneral_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECOVER() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + CANCEL() antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + FROM() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Full_database_recovery() IFull_database_recoveryContext + Partial_database_recovery() IPartial_database_recoveryContext + LOGFILE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllTEST() []antlr.TerminalNode + TEST(i int) antlr.TerminalNode + AllALLOW() []antlr.TerminalNode + ALLOW(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCORRUPTION() []antlr.TerminalNode + CORRUPTION(i int) antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + + // IsGeneral_recoveryContext differentiates from other interfaces. + IsGeneral_recoveryContext() +} + +type General_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_recoveryContext() *General_recoveryContext { + var p = new(General_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_recovery + return p +} + +func InitEmptyGeneral_recoveryContext(p *General_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_recovery +} + +func (*General_recoveryContext) IsGeneral_recoveryContext() {} + +func NewGeneral_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_recoveryContext { + var p = new(General_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_recovery + + return p +} + +func (s *General_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_recoveryContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *General_recoveryContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *General_recoveryContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *General_recoveryContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *General_recoveryContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *General_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *General_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *General_recoveryContext) Full_database_recovery() IFull_database_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_database_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_database_recoveryContext) +} + +func (s *General_recoveryContext) Partial_database_recovery() IPartial_database_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartial_database_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartial_database_recoveryContext) +} + +func (s *General_recoveryContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *General_recoveryContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *General_recoveryContext) AllTEST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTEST) +} + +func (s *General_recoveryContext) TEST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTEST, i) +} + +func (s *General_recoveryContext) AllALLOW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALLOW) +} + +func (s *General_recoveryContext) ALLOW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, i) +} + +func (s *General_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *General_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *General_recoveryContext) AllCORRUPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCORRUPTION) +} + +func (s *General_recoveryContext) CORRUPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPTION, i) +} + +func (s *General_recoveryContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *General_recoveryContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *General_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_recovery(s) + } +} + +func (s *General_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_recovery(s) + } +} + +func (p *PlSqlParser) General_recovery() (localctx IGeneral_recoveryContext) { + localctx = NewGeneral_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1382, PlSqlParserRULE_general_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13504) + p.Match(PlSqlParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13506) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1744, p.GetParserRuleContext()) == 1 { + { + p.SetState(13505) + p.Match(PlSqlParserAUTOMATIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13510) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1745, p.GetParserRuleContext()) == 1 { + { + p.SetState(13508) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13509) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1751, p.GetParserRuleContext()) { + case 1: + p.SetState(13516) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1746, p.GetParserRuleContext()) == 1 { + { + p.SetState(13512) + p.Full_database_recovery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1746, p.GetParserRuleContext()) == 2 { + { + p.SetState(13513) + p.Partial_database_recovery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1746, p.GetParserRuleContext()) == 3 { + { + p.SetState(13514) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13515) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserTEST { + p.SetState(13523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOW || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserTEST { + p.SetState(13523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTEST: + { + p.SetState(13518) + p.Match(PlSqlParserTEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOW: + { + p.SetState(13519) + p.Match(PlSqlParserALLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13520) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13521) + p.Match(PlSqlParserCORRUPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(13522) + p.Parallel_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case 2: + { + p.SetState(13529) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(13530) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + { + p.SetState(13533) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFull_database_recoveryContext is an interface to support dynamic dispatch. +type IFull_database_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + AllUNTIL() []antlr.TerminalNode + UNTIL(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllBACKUP() []antlr.TerminalNode + BACKUP(i int) antlr.TerminalNode + AllCONTROLFILE() []antlr.TerminalNode + CONTROLFILE(i int) antlr.TerminalNode + AllSNAPSHOT() []antlr.TerminalNode + SNAPSHOT(i int) antlr.TerminalNode + AllTIME() []antlr.TerminalNode + TIME(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCANCEL() []antlr.TerminalNode + CANCEL(i int) antlr.TerminalNode + AllCHANGE() []antlr.TerminalNode + CHANGE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCONSISTENT() []antlr.TerminalNode + CONSISTENT(i int) antlr.TerminalNode + + // IsFull_database_recoveryContext differentiates from other interfaces. + IsFull_database_recoveryContext() +} + +type Full_database_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_database_recoveryContext() *Full_database_recoveryContext { + var p = new(Full_database_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_full_database_recovery + return p +} + +func InitEmptyFull_database_recoveryContext(p *Full_database_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_full_database_recovery +} + +func (*Full_database_recoveryContext) IsFull_database_recoveryContext() {} + +func NewFull_database_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_database_recoveryContext { + var p = new(Full_database_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_full_database_recovery + + return p +} + +func (s *Full_database_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_database_recoveryContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Full_database_recoveryContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Full_database_recoveryContext) AllUNTIL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNTIL) +} + +func (s *Full_database_recoveryContext) UNTIL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, i) +} + +func (s *Full_database_recoveryContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Full_database_recoveryContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Full_database_recoveryContext) AllBACKUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBACKUP) +} + +func (s *Full_database_recoveryContext) BACKUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, i) +} + +func (s *Full_database_recoveryContext) AllCONTROLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTROLFILE) +} + +func (s *Full_database_recoveryContext) CONTROLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, i) +} + +func (s *Full_database_recoveryContext) AllSNAPSHOT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSNAPSHOT) +} + +func (s *Full_database_recoveryContext) SNAPSHOT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, i) +} + +func (s *Full_database_recoveryContext) AllTIME() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIME) +} + +func (s *Full_database_recoveryContext) TIME(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, i) +} + +func (s *Full_database_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Full_database_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Full_database_recoveryContext) AllCANCEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCANCEL) +} + +func (s *Full_database_recoveryContext) CANCEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, i) +} + +func (s *Full_database_recoveryContext) AllCHANGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHANGE) +} + +func (s *Full_database_recoveryContext) CHANGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, i) +} + +func (s *Full_database_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Full_database_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Full_database_recoveryContext) AllCONSISTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSISTENT) +} + +func (s *Full_database_recoveryContext) CONSISTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, i) +} + +func (s *Full_database_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_database_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_database_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFull_database_recovery(s) + } +} + +func (s *Full_database_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFull_database_recovery(s) + } +} + +func (p *PlSqlParser) Full_database_recovery() (localctx IFull_database_recoveryContext) { + localctx = NewFull_database_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1384, PlSqlParserRULE_full_database_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13536) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13539) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSNAPSHOT || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserSNAPSHOT || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNTIL: + { + p.SetState(13540) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCANCEL: + { + p.SetState(13541) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIME: + { + p.SetState(13542) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13543) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHANGE: + { + p.SetState(13544) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13545) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSISTENT: + { + p.SetState(13546) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserUSING: + { + p.SetState(13549) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13550) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13551) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSNAPSHOT: + { + p.SetState(13552) + p.Match(PlSqlParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13553) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13554) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartial_database_recoveryContext is an interface to support dynamic dispatch. +type IPartial_database_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + Partial_database_recovery_10g() IPartial_database_recovery_10gContext + + // IsPartial_database_recoveryContext differentiates from other interfaces. + IsPartial_database_recoveryContext() +} + +type Partial_database_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartial_database_recoveryContext() *Partial_database_recoveryContext { + var p = new(Partial_database_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery + return p +} + +func InitEmptyPartial_database_recoveryContext(p *Partial_database_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery +} + +func (*Partial_database_recoveryContext) IsPartial_database_recoveryContext() {} + +func NewPartial_database_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partial_database_recoveryContext { + var p = new(Partial_database_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partial_database_recovery + + return p +} + +func (s *Partial_database_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partial_database_recoveryContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Partial_database_recoveryContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recoveryContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partial_database_recoveryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partial_database_recoveryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partial_database_recoveryContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Partial_database_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Partial_database_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Partial_database_recoveryContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recoveryContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Partial_database_recoveryContext) Partial_database_recovery_10g() IPartial_database_recovery_10gContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartial_database_recovery_10gContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartial_database_recovery_10gContext) +} + +func (s *Partial_database_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partial_database_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partial_database_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartial_database_recovery(s) + } +} + +func (s *Partial_database_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartial_database_recovery(s) + } +} + +func (p *PlSqlParser) Partial_database_recovery() (localctx IPartial_database_recoveryContext) { + localctx = NewPartial_database_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1386, PlSqlParserRULE_partial_database_recovery) + var _la int + + p.SetState(13582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1760, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13561) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13562) + p.Tablespace() + } + p.SetState(13567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13563) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13564) + p.Tablespace() + } + + p.SetState(13569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13570) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13571) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13572) + p.Filenumber() + } + p.SetState(13578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserCOMMA { + p.SetState(13576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMMA: + { + p.SetState(13573) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13574) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13575) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13581) + p.Partial_database_recovery_10g() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartial_database_recovery_10gContext is an interface to support dynamic dispatch. +type IPartial_database_recovery_10gContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STANDBY() antlr.TerminalNode + UNTIL() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + DATAFILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + CONSISTENT() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartial_database_recovery_10gContext differentiates from other interfaces. + IsPartial_database_recovery_10gContext() +} + +type Partial_database_recovery_10gContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartial_database_recovery_10gContext() *Partial_database_recovery_10gContext { + var p = new(Partial_database_recovery_10gContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g + return p +} + +func InitEmptyPartial_database_recovery_10gContext(p *Partial_database_recovery_10gContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g +} + +func (*Partial_database_recovery_10gContext) IsPartial_database_recovery_10gContext() {} + +func NewPartial_database_recovery_10gContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partial_database_recovery_10gContext { + var p = new(Partial_database_recovery_10gContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g + + return p +} + +func (s *Partial_database_recovery_10gContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partial_database_recovery_10gContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Partial_database_recovery_10gContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Partial_database_recovery_10gContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Partial_database_recovery_10gContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Partial_database_recovery_10gContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recovery_10gContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partial_database_recovery_10gContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Partial_database_recovery_10gContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Partial_database_recovery_10gContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Partial_database_recovery_10gContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recovery_10gContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Partial_database_recovery_10gContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, 0) +} + +func (s *Partial_database_recovery_10gContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Partial_database_recovery_10gContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partial_database_recovery_10gContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partial_database_recovery_10gContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partial_database_recovery_10gContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partial_database_recovery_10gContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartial_database_recovery_10g(s) + } +} + +func (s *Partial_database_recovery_10gContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartial_database_recovery_10g(s) + } +} + +func (p *PlSqlParser) Partial_database_recovery_10g() (localctx IPartial_database_recovery_10gContext) { + localctx = NewPartial_database_recovery_10gContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1388, PlSqlParserRULE_partial_database_recovery_10g) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13584) + + if !(p.isVersion10()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion10()", "")) + goto errorExit + } + { + p.SetState(13585) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(13586) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13587) + p.Tablespace() + } + p.SetState(13592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13588) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13589) + p.Tablespace() + } + + p.SetState(13594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDATAFILE: + { + p.SetState(13595) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13596) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13597) + p.Filenumber() + } + p.SetState(13603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserCOMMA { + p.SetState(13601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMMA: + { + p.SetState(13598) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13599) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13600) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13608) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSISTENT { + { + p.SetState(13609) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13610) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13613) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IManaged_standby_recoveryContext is an interface to support dynamic dispatch. +type IManaged_standby_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECOVER() antlr.TerminalNode + MANAGED() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + TO() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + Db_name() IDb_nameContext + KEEP() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + FINISH() antlr.TerminalNode + CANCEL() antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllCURRENT() []antlr.TerminalNode + CURRENT(i int) antlr.TerminalNode + AllLOGFILE() []antlr.TerminalNode + LOGFILE(i int) antlr.TerminalNode + AllDISCONNECT() []antlr.TerminalNode + DISCONNECT(i int) antlr.TerminalNode + AllNODELAY() []antlr.TerminalNode + NODELAY(i int) antlr.TerminalNode + AllUNTIL() []antlr.TerminalNode + UNTIL(i int) antlr.TerminalNode + AllCHANGE() []antlr.TerminalNode + CHANGE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCONSISTENT() []antlr.TerminalNode + CONSISTENT(i int) antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllFROM() []antlr.TerminalNode + FROM(i int) antlr.TerminalNode + AllSESSION() []antlr.TerminalNode + SESSION(i int) antlr.TerminalNode + + // IsManaged_standby_recoveryContext differentiates from other interfaces. + IsManaged_standby_recoveryContext() +} + +type Managed_standby_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyManaged_standby_recoveryContext() *Managed_standby_recoveryContext { + var p = new(Managed_standby_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery + return p +} + +func InitEmptyManaged_standby_recoveryContext(p *Managed_standby_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery +} + +func (*Managed_standby_recoveryContext) IsManaged_standby_recoveryContext() {} + +func NewManaged_standby_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Managed_standby_recoveryContext { + var p = new(Managed_standby_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery + + return p +} + +func (s *Managed_standby_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Managed_standby_recoveryContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *Managed_standby_recoveryContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Managed_standby_recoveryContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Managed_standby_recoveryContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Managed_standby_recoveryContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Managed_standby_recoveryContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Managed_standby_recoveryContext) Db_name() IDb_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_nameContext) +} + +func (s *Managed_standby_recoveryContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Managed_standby_recoveryContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Managed_standby_recoveryContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Managed_standby_recoveryContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Managed_standby_recoveryContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Managed_standby_recoveryContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Managed_standby_recoveryContext) AllCURRENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT) +} + +func (s *Managed_standby_recoveryContext) CURRENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, i) +} + +func (s *Managed_standby_recoveryContext) AllLOGFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGFILE) +} + +func (s *Managed_standby_recoveryContext) LOGFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, i) +} + +func (s *Managed_standby_recoveryContext) AllDISCONNECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISCONNECT) +} + +func (s *Managed_standby_recoveryContext) DISCONNECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCONNECT, i) +} + +func (s *Managed_standby_recoveryContext) AllNODELAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNODELAY) +} + +func (s *Managed_standby_recoveryContext) NODELAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, i) +} + +func (s *Managed_standby_recoveryContext) AllUNTIL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNTIL) +} + +func (s *Managed_standby_recoveryContext) UNTIL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, i) +} + +func (s *Managed_standby_recoveryContext) AllCHANGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHANGE) +} + +func (s *Managed_standby_recoveryContext) CHANGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, i) +} + +func (s *Managed_standby_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Managed_standby_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Managed_standby_recoveryContext) AllCONSISTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSISTENT) +} + +func (s *Managed_standby_recoveryContext) CONSISTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, i) +} + +func (s *Managed_standby_recoveryContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Managed_standby_recoveryContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Managed_standby_recoveryContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFROM) +} + +func (s *Managed_standby_recoveryContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, i) +} + +func (s *Managed_standby_recoveryContext) AllSESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSESSION) +} + +func (s *Managed_standby_recoveryContext) SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, i) +} + +func (s *Managed_standby_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Managed_standby_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Managed_standby_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterManaged_standby_recovery(s) + } +} + +func (s *Managed_standby_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitManaged_standby_recovery(s) + } +} + +func (p *PlSqlParser) Managed_standby_recovery() (localctx IManaged_standby_recoveryContext) { + localctx = NewManaged_standby_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1390, PlSqlParserRULE_managed_standby_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13615) + p.Match(PlSqlParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMANAGED: + { + p.SetState(13616) + p.Match(PlSqlParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13617) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13618) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISCONNECT, PlSqlParserNODELAY, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserUNTIL, PlSqlParserUSING: + p.SetState(13634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISCONNECT || _la == PlSqlParserNODELAY || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1767, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13619) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13620) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13621) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13622) + p.Match(PlSqlParserDISCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFROM { + { + p.SetState(13623) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13624) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + { + p.SetState(13627) + p.Match(PlSqlParserNODELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(13628) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13629) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13630) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(13631) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13632) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(13633) + p.Parallel_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(13636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserFINISH: + { + p.SetState(13638) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCANCEL: + { + p.SetState(13639) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + + case PlSqlParserTO: + { + p.SetState(13642) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13643) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13644) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1770, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13645) + p.Db_name() + } + + case 2: + { + p.SetState(13646) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13647) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_nameContext is an interface to support dynamic dispatch. +type IDb_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDb_nameContext differentiates from other interfaces. + IsDb_nameContext() +} + +type Db_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_nameContext() *Db_nameContext { + var p = new(Db_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_db_name + return p +} + +func InitEmptyDb_nameContext(p *Db_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_db_name +} + +func (*Db_nameContext) IsDb_nameContext() {} + +func NewDb_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_nameContext { + var p = new(Db_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_db_name + + return p +} + +func (s *Db_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Db_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDb_name(s) + } +} + +func (s *Db_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDb_name(s) + } +} + +func (p *PlSqlParser) Db_name() (localctx IDb_nameContext) { + localctx = NewDb_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1392, PlSqlParserRULE_db_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13652) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_file_clausesContext is an interface to support dynamic dispatch. +type IDatabase_file_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Create_datafile_clause() ICreate_datafile_clauseContext + Alter_datafile_clause() IAlter_datafile_clauseContext + Alter_tempfile_clause() IAlter_tempfile_clauseContext + Move_datafile_clause() IMove_datafile_clauseContext + + // IsDatabase_file_clausesContext differentiates from other interfaces. + IsDatabase_file_clausesContext() +} + +type Database_file_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_file_clausesContext() *Database_file_clausesContext { + var p = new(Database_file_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_file_clauses + return p +} + +func InitEmptyDatabase_file_clausesContext(p *Database_file_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_file_clauses +} + +func (*Database_file_clausesContext) IsDatabase_file_clausesContext() {} + +func NewDatabase_file_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_file_clausesContext { + var p = new(Database_file_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_file_clauses + + return p +} + +func (s *Database_file_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_file_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Database_file_clausesContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Database_file_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Database_file_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Database_file_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Database_file_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Database_file_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Database_file_clausesContext) Create_datafile_clause() ICreate_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) Alter_datafile_clause() IAlter_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) Alter_tempfile_clause() IAlter_tempfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tempfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tempfile_clauseContext) +} + +func (s *Database_file_clausesContext) Move_datafile_clause() IMove_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_file_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_file_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_file_clauses(s) + } +} + +func (s *Database_file_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_file_clauses(s) + } +} + +func (p *PlSqlParser) Database_file_clauses() (localctx IDatabase_file_clausesContext) { + localctx = NewDatabase_file_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1394, PlSqlParserRULE_database_file_clauses) + var _la int + + p.SetState(13671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13654) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13655) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13656) + p.Filename() + } + p.SetState(13661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13657) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13658) + p.Filename() + } + + p.SetState(13663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13664) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13665) + p.Filename() + } + + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13667) + p.Create_datafile_clause() + } + + case PlSqlParserDATAFILE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13668) + p.Alter_datafile_clause() + } + + case PlSqlParserTEMPFILE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13669) + p.Alter_tempfile_clause() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13670) + p.Move_datafile_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_datafile_clauseContext is an interface to support dynamic dispatch. +type ICreate_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AS() antlr.TerminalNode + NEW() antlr.TerminalNode + + // IsCreate_datafile_clauseContext differentiates from other interfaces. + IsCreate_datafile_clauseContext() +} + +type Create_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_datafile_clauseContext() *Create_datafile_clauseContext { + var p = new(Create_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_datafile_clause + return p +} + +func InitEmptyCreate_datafile_clauseContext(p *Create_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_datafile_clause +} + +func (*Create_datafile_clauseContext) IsCreate_datafile_clauseContext() {} + +func NewCreate_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_datafile_clauseContext { + var p = new(Create_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_datafile_clause + + return p +} + +func (s *Create_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_datafile_clauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Create_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Create_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Create_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Create_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_datafile_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_datafile_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Create_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_datafile_clause(s) + } +} + +func (s *Create_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_datafile_clause(s) + } +} + +func (p *PlSqlParser) Create_datafile_clause() (localctx ICreate_datafile_clauseContext) { + localctx = NewCreate_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1396, PlSqlParserRULE_create_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13673) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13674) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13675) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13676) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13679) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13680) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13681) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13689) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(13690) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_datafile_clauseContext is an interface to support dynamic dispatch. +type IAlter_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + END() antlr.TerminalNode + BACKUP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_datafile_clauseContext differentiates from other interfaces. + IsAlter_datafile_clauseContext() +} + +type Alter_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_datafile_clauseContext() *Alter_datafile_clauseContext { + var p = new(Alter_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause + return p +} + +func InitEmptyAlter_datafile_clauseContext(p *Alter_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause +} + +func (*Alter_datafile_clauseContext) IsAlter_datafile_clauseContext() {} + +func NewAlter_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_datafile_clauseContext { + var p = new(Alter_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause + + return p +} + +func (s *Alter_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Alter_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Alter_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Alter_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Alter_datafile_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_datafile_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_datafile_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_datafile_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_datafile_clauseContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_datafile_clauseContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Alter_datafile_clauseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_datafile_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Alter_datafile_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_datafile_clause(s) + } +} + +func (s *Alter_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_datafile_clause(s) + } +} + +func (p *PlSqlParser) Alter_datafile_clause() (localctx IAlter_datafile_clauseContext) { + localctx = NewAlter_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1398, PlSqlParserRULE_alter_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13693) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13694) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13695) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13698) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13699) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13700) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + { + p.SetState(13708) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(13709) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(13710) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13711) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserRESIZE: + { + p.SetState(13714) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13715) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(13716) + p.Autoextend_clause() + } + + case PlSqlParserEND: + { + p.SetState(13717) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13718) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tempfile_clauseContext is an interface to support dynamic dispatch. +type IAlter_tempfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + DROP() antlr.TerminalNode + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INCLUDING() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + + // IsAlter_tempfile_clauseContext differentiates from other interfaces. + IsAlter_tempfile_clauseContext() +} + +type Alter_tempfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tempfile_clauseContext() *Alter_tempfile_clauseContext { + var p = new(Alter_tempfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause + return p +} + +func InitEmptyAlter_tempfile_clauseContext(p *Alter_tempfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause +} + +func (*Alter_tempfile_clauseContext) IsAlter_tempfile_clauseContext() {} + +func NewAlter_tempfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tempfile_clauseContext { + var p = new(Alter_tempfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause + + return p +} + +func (s *Alter_tempfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tempfile_clauseContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Alter_tempfile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Alter_tempfile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_tempfile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Alter_tempfile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Alter_tempfile_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tempfile_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tempfile_clauseContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tempfile_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_tempfile_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_tempfile_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_tempfile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_tempfile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_tempfile_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Alter_tempfile_clauseContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Alter_tempfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tempfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tempfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tempfile_clause(s) + } +} + +func (s *Alter_tempfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tempfile_clause(s) + } +} + +func (p *PlSqlParser) Alter_tempfile_clause() (localctx IAlter_tempfile_clauseContext) { + localctx = NewAlter_tempfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1400, PlSqlParserRULE_alter_tempfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13721) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13722) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13723) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13726) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13727) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13728) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESIZE: + { + p.SetState(13736) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13737) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(13738) + p.Autoextend_clause() + } + + case PlSqlParserDROP: + { + p.SetState(13739) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(13740) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13741) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserONLINE: + { + p.SetState(13742) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(13743) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_datafile_clauseContext is an interface to support dynamic dispatch. +type IMove_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + TO() antlr.TerminalNode + REUSE() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsMove_datafile_clauseContext differentiates from other interfaces. + IsMove_datafile_clauseContext() +} + +type Move_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_datafile_clauseContext() *Move_datafile_clauseContext { + var p = new(Move_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_datafile_clause + return p +} + +func InitEmptyMove_datafile_clauseContext(p *Move_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_datafile_clause +} + +func (*Move_datafile_clauseContext) IsMove_datafile_clauseContext() {} + +func NewMove_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_datafile_clauseContext { + var p = new(Move_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_datafile_clause + + return p +} + +func (s *Move_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_datafile_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Move_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Move_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Move_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Move_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Move_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Move_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Move_datafile_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_datafile_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Move_datafile_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Move_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_datafile_clause(s) + } +} + +func (s *Move_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_datafile_clause(s) + } +} + +func (p *PlSqlParser) Move_datafile_clause() (localctx IMove_datafile_clauseContext) { + localctx = NewMove_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1402, PlSqlParserRULE_move_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13746) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13747) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13748) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13749) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13752) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13753) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13754) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(13762) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13763) + p.Filename() + } + + } + p.SetState(13767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13766) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(13769) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogfile_clausesContext is an interface to support dynamic dispatch. +type ILogfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + MANUAL() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + NO() antlr.TerminalNode + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FOR() antlr.TerminalNode + DATA() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + LOAD() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + RENAME() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CLEAR() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + UNARCHIVED() antlr.TerminalNode + UNRECOVERABLE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + Add_logfile_clauses() IAdd_logfile_clausesContext + Drop_logfile_clauses() IDrop_logfile_clausesContext + Switch_logfile_clause() ISwitch_logfile_clauseContext + Supplemental_db_logging() ISupplemental_db_loggingContext + + // IsLogfile_clausesContext differentiates from other interfaces. + IsLogfile_clausesContext() +} + +type Logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_clausesContext() *Logfile_clausesContext { + var p = new(Logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clauses + return p +} + +func InitEmptyLogfile_clausesContext(p *Logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clauses +} + +func (*Logfile_clausesContext) IsLogfile_clausesContext() {} + +func NewLogfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_clausesContext { + var p = new(Logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_clauses + + return p +} + +func (s *Logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_clausesContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Logfile_clausesContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Logfile_clausesContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Logfile_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Logfile_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Logfile_clausesContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Logfile_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Logfile_clausesContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Logfile_clausesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Logfile_clausesContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Logfile_clausesContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Logfile_clausesContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Logfile_clausesContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Logfile_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Logfile_clausesContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Logfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_clausesContext) CLEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAR, 0) +} + +func (s *Logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Logfile_clausesContext) UNARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNARCHIVED, 0) +} + +func (s *Logfile_clausesContext) UNRECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRECOVERABLE, 0) +} + +func (s *Logfile_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Logfile_clausesContext) Add_logfile_clauses() IAdd_logfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_logfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_logfile_clausesContext) +} + +func (s *Logfile_clausesContext) Drop_logfile_clauses() IDrop_logfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_logfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_logfile_clausesContext) +} + +func (s *Logfile_clausesContext) Switch_logfile_clause() ISwitch_logfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_logfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_logfile_clauseContext) +} + +func (s *Logfile_clausesContext) Supplemental_db_logging() ISupplemental_db_loggingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_db_loggingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_db_loggingContext) +} + +func (s *Logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_clauses(s) + } +} + +func (s *Logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_clauses(s) + } +} + +func (p *PlSqlParser) Logfile_clauses() (localctx ILogfile_clausesContext) { + localctx = NewLogfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1404, PlSqlParserRULE_logfile_clauses) + var _la int + + p.SetState(13828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1801, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(13777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserARCHIVELOG: + { + p.SetState(13772) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMANUAL { + { + p.SetState(13773) + p.Match(PlSqlParserMANUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNOARCHIVELOG: + { + p.SetState(13776) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(13780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(13779) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13782) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13783) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13784) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13785) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13786) + p.Match(PlSqlParserNOLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13787) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(13788) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13789) + p.Match(PlSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOAD: + { + p.SetState(13790) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13791) + p.Match(PlSqlParserPERFORMANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13794) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13795) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13796) + p.Filename() + } + p.SetState(13801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13797) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13798) + p.Filename() + } + + p.SetState(13803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13804) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13805) + p.Filename() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13807) + p.Match(PlSqlParserCLEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNARCHIVED { + { + p.SetState(13808) + p.Match(PlSqlParserUNARCHIVED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13811) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13812) + p.Logfile_descriptor() + } + p.SetState(13817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13813) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13814) + p.Logfile_descriptor() + } + + p.SetState(13819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNRECOVERABLE { + { + p.SetState(13820) + p.Match(PlSqlParserUNRECOVERABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13821) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13824) + p.Add_logfile_clauses() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13825) + p.Drop_logfile_clauses() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13826) + p.Switch_logfile_clause() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13827) + p.Supplemental_db_logging() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_logfile_clausesContext is an interface to support dynamic dispatch. +type IAdd_logfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + MEMBER() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + STANDBY() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + THREAD() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AllGroup_redo_logfile() []IGroup_redo_logfileContext + Group_redo_logfile(i int) IGroup_redo_logfileContext + AllREUSE() []antlr.TerminalNode + REUSE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_logfile_clausesContext differentiates from other interfaces. + IsAdd_logfile_clausesContext() +} + +type Add_logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_logfile_clausesContext() *Add_logfile_clausesContext { + var p = new(Add_logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses + return p +} + +func InitEmptyAdd_logfile_clausesContext(p *Add_logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses +} + +func (*Add_logfile_clausesContext) IsAdd_logfile_clausesContext() {} + +func NewAdd_logfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_logfile_clausesContext { + var p = new(Add_logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses + + return p +} + +func (s *Add_logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_logfile_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Add_logfile_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Add_logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Add_logfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Add_logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Add_logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Add_logfile_clausesContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Add_logfile_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Add_logfile_clausesContext) THREAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHREAD, 0) +} + +func (s *Add_logfile_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Add_logfile_clausesContext) AllGroup_redo_logfile() []IGroup_redo_logfileContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_redo_logfileContext); ok { + len++ + } + } + + tst := make([]IGroup_redo_logfileContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_redo_logfileContext); ok { + tst[i] = t.(IGroup_redo_logfileContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Group_redo_logfile(i int) IGroup_redo_logfileContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_redo_logfileContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_redo_logfileContext) +} + +func (s *Add_logfile_clausesContext) AllREUSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREUSE) +} + +func (s *Add_logfile_clausesContext) REUSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, i) +} + +func (s *Add_logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_logfile_clauses(s) + } +} + +func (s *Add_logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_logfile_clauses(s) + } +} + +func (p *PlSqlParser) Add_logfile_clauses() (localctx IAdd_logfile_clausesContext) { + localctx = NewAdd_logfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1406, PlSqlParserRULE_add_logfile_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13830) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13831) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13834) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP, PlSqlParserINSTANCE, PlSqlParserTHREAD, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + p.SetState(13839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINSTANCE: + { + p.SetState(13835) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13836) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTHREAD: + { + p.SetState(13837) + p.Match(PlSqlParserTHREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13838) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGROUP, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + + default: + } + p.SetState(13842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserGROUP || _la == PlSqlParserCHAR_STRING || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(13841) + p.Group_redo_logfile() + } + + p.SetState(13844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMEMBER: + { + p.SetState(13846) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13847) + p.Filename() + } + p.SetState(13849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13848) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13851) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13852) + p.Filename() + } + p.SetState(13854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13853) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(13860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13861) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13862) + p.Logfile_descriptor() + } + p.SetState(13867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13863) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13864) + p.Logfile_descriptor() + } + + p.SetState(13869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_redo_logfileContext is an interface to support dynamic dispatch. +type IGroup_redo_logfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Redo_log_file_spec() IRedo_log_file_specContext + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsGroup_redo_logfileContext differentiates from other interfaces. + IsGroup_redo_logfileContext() +} + +type Group_redo_logfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_redo_logfileContext() *Group_redo_logfileContext { + var p = new(Group_redo_logfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_redo_logfile + return p +} + +func InitEmptyGroup_redo_logfileContext(p *Group_redo_logfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_redo_logfile +} + +func (*Group_redo_logfileContext) IsGroup_redo_logfileContext() {} + +func NewGroup_redo_logfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_redo_logfileContext { + var p = new(Group_redo_logfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_group_redo_logfile + + return p +} + +func (s *Group_redo_logfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_redo_logfileContext) Redo_log_file_spec() IRedo_log_file_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedo_log_file_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedo_log_file_specContext) +} + +func (s *Group_redo_logfileContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Group_redo_logfileContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Group_redo_logfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_redo_logfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_redo_logfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGroup_redo_logfile(s) + } +} + +func (s *Group_redo_logfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_redo_logfile(s) + } +} + +func (p *PlSqlParser) Group_redo_logfile() (localctx IGroup_redo_logfileContext) { + localctx = NewGroup_redo_logfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1408, PlSqlParserRULE_group_redo_logfile) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(13872) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13873) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13876) + p.Redo_log_file_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_logfile_clausesContext is an interface to support dynamic dispatch. +type IDrop_logfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + MEMBER() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + STANDBY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_logfile_clausesContext differentiates from other interfaces. + IsDrop_logfile_clausesContext() +} + +type Drop_logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_logfile_clausesContext() *Drop_logfile_clausesContext { + var p = new(Drop_logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses + return p +} + +func InitEmptyDrop_logfile_clausesContext(p *Drop_logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses +} + +func (*Drop_logfile_clausesContext) IsDrop_logfile_clausesContext() {} + +func NewDrop_logfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_logfile_clausesContext { + var p = new(Drop_logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses + + return p +} + +func (s *Drop_logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_logfile_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Drop_logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Drop_logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Drop_logfile_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Drop_logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Drop_logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Drop_logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Drop_logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_logfile_clauses(s) + } +} + +func (s *Drop_logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_logfile_clauses(s) + } +} + +func (p *PlSqlParser) Drop_logfile_clauses() (localctx IDrop_logfile_clausesContext) { + localctx = NewDrop_logfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1410, PlSqlParserRULE_drop_logfile_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13878) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13879) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13882) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + { + p.SetState(13883) + p.Logfile_descriptor() + } + p.SetState(13888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13884) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13885) + p.Logfile_descriptor() + } + + p.SetState(13890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMEMBER: + { + p.SetState(13891) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13892) + p.Filename() + } + p.SetState(13897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13893) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13894) + p.Filename() + } + + p.SetState(13899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISwitch_logfile_clauseContext is an interface to support dynamic dispatch. +type ISwitch_logfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SWITCH() antlr.TerminalNode + ALL() antlr.TerminalNode + LOGFILES() antlr.TerminalNode + TO() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsSwitch_logfile_clauseContext differentiates from other interfaces. + IsSwitch_logfile_clauseContext() +} + +type Switch_logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_logfile_clauseContext() *Switch_logfile_clauseContext { + var p = new(Switch_logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause + return p +} + +func InitEmptySwitch_logfile_clauseContext(p *Switch_logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause +} + +func (*Switch_logfile_clauseContext) IsSwitch_logfile_clauseContext() {} + +func NewSwitch_logfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_logfile_clauseContext { + var p = new(Switch_logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause + + return p +} + +func (s *Switch_logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_logfile_clauseContext) SWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCH, 0) +} + +func (s *Switch_logfile_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Switch_logfile_clauseContext) LOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILES, 0) +} + +func (s *Switch_logfile_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Switch_logfile_clauseContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Switch_logfile_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Switch_logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSwitch_logfile_clause(s) + } +} + +func (s *Switch_logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSwitch_logfile_clause(s) + } +} + +func (p *PlSqlParser) Switch_logfile_clause() (localctx ISwitch_logfile_clauseContext) { + localctx = NewSwitch_logfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1412, PlSqlParserRULE_switch_logfile_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13902) + p.Match(PlSqlParserSWITCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13903) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13904) + p.Match(PlSqlParserLOGFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13905) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13906) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13907) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_db_loggingContext is an interface to support dynamic dispatch. +type ISupplemental_db_loggingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_or_drop() IAdd_or_dropContext + SUPPLEMENTAL() antlr.TerminalNode + LOG() antlr.TerminalNode + DATA() antlr.TerminalNode + Supplemental_id_key_clause() ISupplemental_id_key_clauseContext + Supplemental_plsql_clause() ISupplemental_plsql_clauseContext + + // IsSupplemental_db_loggingContext differentiates from other interfaces. + IsSupplemental_db_loggingContext() +} + +type Supplemental_db_loggingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_db_loggingContext() *Supplemental_db_loggingContext { + var p = new(Supplemental_db_loggingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging + return p +} + +func InitEmptySupplemental_db_loggingContext(p *Supplemental_db_loggingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging +} + +func (*Supplemental_db_loggingContext) IsSupplemental_db_loggingContext() {} + +func NewSupplemental_db_loggingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_db_loggingContext { + var p = new(Supplemental_db_loggingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging + + return p +} + +func (s *Supplemental_db_loggingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_db_loggingContext) Add_or_drop() IAdd_or_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_or_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_or_dropContext) +} + +func (s *Supplemental_db_loggingContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Supplemental_db_loggingContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Supplemental_db_loggingContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_db_loggingContext) Supplemental_id_key_clause() ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_db_loggingContext) Supplemental_plsql_clause() ISupplemental_plsql_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_plsql_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_plsql_clauseContext) +} + +func (s *Supplemental_db_loggingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_db_loggingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_db_loggingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_db_logging(s) + } +} + +func (s *Supplemental_db_loggingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_db_logging(s) + } +} + +func (p *PlSqlParser) Supplemental_db_logging() (localctx ISupplemental_db_loggingContext) { + localctx = NewSupplemental_db_loggingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1414, PlSqlParserRULE_supplemental_db_logging) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13909) + p.Add_or_drop() + } + { + p.SetState(13910) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13911) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1815, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13912) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13913) + p.Supplemental_id_key_clause() + } + + case 3: + { + p.SetState(13914) + p.Supplemental_plsql_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_or_dropContext is an interface to support dynamic dispatch. +type IAdd_or_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAdd_or_dropContext differentiates from other interfaces. + IsAdd_or_dropContext() +} + +type Add_or_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_or_dropContext() *Add_or_dropContext { + var p = new(Add_or_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_or_drop + return p +} + +func InitEmptyAdd_or_dropContext(p *Add_or_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_or_drop +} + +func (*Add_or_dropContext) IsAdd_or_dropContext() {} + +func NewAdd_or_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_or_dropContext { + var p = new(Add_or_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_or_drop + + return p +} + +func (s *Add_or_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_or_dropContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_or_dropContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Add_or_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_or_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_or_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_or_drop(s) + } +} + +func (s *Add_or_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_or_drop(s) + } +} + +func (p *PlSqlParser) Add_or_drop() (localctx IAdd_or_dropContext) { + localctx = NewAdd_or_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1416, PlSqlParserRULE_add_or_drop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13917) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_plsql_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_plsql_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA() antlr.TerminalNode + FOR() antlr.TerminalNode + PROCEDURAL() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + + // IsSupplemental_plsql_clauseContext differentiates from other interfaces. + IsSupplemental_plsql_clauseContext() +} + +type Supplemental_plsql_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_plsql_clauseContext() *Supplemental_plsql_clauseContext { + var p = new(Supplemental_plsql_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause + return p +} + +func InitEmptySupplemental_plsql_clauseContext(p *Supplemental_plsql_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause +} + +func (*Supplemental_plsql_clauseContext) IsSupplemental_plsql_clauseContext() {} + +func NewSupplemental_plsql_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_plsql_clauseContext { + var p = new(Supplemental_plsql_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause + + return p +} + +func (s *Supplemental_plsql_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_plsql_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_plsql_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Supplemental_plsql_clauseContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURAL, 0) +} + +func (s *Supplemental_plsql_clauseContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Supplemental_plsql_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_plsql_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_plsql_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_plsql_clause(s) + } +} + +func (s *Supplemental_plsql_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_plsql_clause(s) + } +} + +func (p *PlSqlParser) Supplemental_plsql_clause() (localctx ISupplemental_plsql_clauseContext) { + localctx = NewSupplemental_plsql_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1418, PlSqlParserRULE_supplemental_plsql_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13919) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13920) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13921) + p.Match(PlSqlParserPROCEDURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13922) + p.Match(PlSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogfile_descriptorContext is an interface to support dynamic dispatch. +type ILogfile_descriptorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLogfile_descriptorContext differentiates from other interfaces. + IsLogfile_descriptorContext() +} + +type Logfile_descriptorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_descriptorContext() *Logfile_descriptorContext { + var p = new(Logfile_descriptorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_descriptor + return p +} + +func InitEmptyLogfile_descriptorContext(p *Logfile_descriptorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_descriptor +} + +func (*Logfile_descriptorContext) IsLogfile_descriptorContext() {} + +func NewLogfile_descriptorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_descriptorContext { + var p = new(Logfile_descriptorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_descriptor + + return p +} + +func (s *Logfile_descriptorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_descriptorContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Logfile_descriptorContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Logfile_descriptorContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Logfile_descriptorContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Logfile_descriptorContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Logfile_descriptorContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Logfile_descriptorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_descriptorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_descriptorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_descriptorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_descriptorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_descriptor(s) + } +} + +func (s *Logfile_descriptorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_descriptor(s) + } +} + +func (p *PlSqlParser) Logfile_descriptor() (localctx ILogfile_descriptorContext) { + localctx = NewLogfile_descriptorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1420, PlSqlParserRULE_logfile_descriptor) + var _la int + + p.SetState(13938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13924) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13925) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13926) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13927) + p.Filename() + } + p.SetState(13932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13928) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13929) + p.Filename() + } + + p.SetState(13934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13935) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13937) + p.Filename() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IControlfile_clausesContext is an interface to support dynamic dispatch. +type IControlfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + AS() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + BACKUP() antlr.TerminalNode + TO() antlr.TerminalNode + Trace_file_clause() ITrace_file_clauseContext + + // IsControlfile_clausesContext differentiates from other interfaces. + IsControlfile_clausesContext() +} + +type Controlfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyControlfile_clausesContext() *Controlfile_clausesContext { + var p = new(Controlfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_clauses + return p +} + +func InitEmptyControlfile_clausesContext(p *Controlfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_clauses +} + +func (*Controlfile_clausesContext) IsControlfile_clausesContext() {} + +func NewControlfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Controlfile_clausesContext { + var p = new(Controlfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_controlfile_clauses + + return p +} + +func (s *Controlfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Controlfile_clausesContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Controlfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Controlfile_clausesContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Controlfile_clausesContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Controlfile_clausesContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Controlfile_clausesContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Controlfile_clausesContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Controlfile_clausesContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Controlfile_clausesContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Controlfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Controlfile_clausesContext) Trace_file_clause() ITrace_file_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrace_file_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrace_file_clauseContext) +} + +func (s *Controlfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Controlfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Controlfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterControlfile_clauses(s) + } +} + +func (s *Controlfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitControlfile_clauses(s) + } +} + +func (p *PlSqlParser) Controlfile_clauses() (localctx IControlfile_clausesContext) { + localctx = NewControlfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1422, PlSqlParserRULE_controlfile_clauses) + var _la int + + p.SetState(13961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13940) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(13941) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13944) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13945) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13946) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13947) + p.Filename() + } + p.SetState(13949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13948) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserBACKUP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13951) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13952) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13953) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13954) + p.Filename() + } + p.SetState(13956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13955) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserTRACE: + { + p.SetState(13958) + p.Trace_file_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrace_file_clauseContext is an interface to support dynamic dispatch. +type ITrace_file_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRACE() antlr.TerminalNode + AS() antlr.TerminalNode + Filename() IFilenameContext + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + REUSE() antlr.TerminalNode + + // IsTrace_file_clauseContext differentiates from other interfaces. + IsTrace_file_clauseContext() +} + +type Trace_file_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrace_file_clauseContext() *Trace_file_clauseContext { + var p = new(Trace_file_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trace_file_clause + return p +} + +func InitEmptyTrace_file_clauseContext(p *Trace_file_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trace_file_clause +} + +func (*Trace_file_clauseContext) IsTrace_file_clauseContext() {} + +func NewTrace_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trace_file_clauseContext { + var p = new(Trace_file_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trace_file_clause + + return p +} + +func (s *Trace_file_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trace_file_clauseContext) TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACE, 0) +} + +func (s *Trace_file_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Trace_file_clauseContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Trace_file_clauseContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Trace_file_clauseContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Trace_file_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Trace_file_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trace_file_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trace_file_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrace_file_clause(s) + } +} + +func (s *Trace_file_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrace_file_clause(s) + } +} + +func (p *PlSqlParser) Trace_file_clause() (localctx ITrace_file_clauseContext) { + localctx = NewTrace_file_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1424, PlSqlParserRULE_trace_file_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13963) + p.Match(PlSqlParserTRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13964) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13965) + p.Filename() + } + p.SetState(13967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13966) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(13972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS { + { + p.SetState(13971) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStandby_database_clausesContext is an interface to support dynamic dispatch. +type IStandby_database_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Activate_standby_db_clause() IActivate_standby_db_clauseContext + Maximize_standby_db_clause() IMaximize_standby_db_clauseContext + Register_logfile_clause() IRegister_logfile_clauseContext + Commit_switchover_clause() ICommit_switchover_clauseContext + Start_standby_clause() IStart_standby_clauseContext + Stop_standby_clause() IStop_standby_clauseContext + Convert_database_clause() IConvert_database_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsStandby_database_clausesContext differentiates from other interfaces. + IsStandby_database_clausesContext() +} + +type Standby_database_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandby_database_clausesContext() *Standby_database_clausesContext { + var p = new(Standby_database_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standby_database_clauses + return p +} + +func InitEmptyStandby_database_clausesContext(p *Standby_database_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standby_database_clauses +} + +func (*Standby_database_clausesContext) IsStandby_database_clausesContext() {} + +func NewStandby_database_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standby_database_clausesContext { + var p = new(Standby_database_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standby_database_clauses + + return p +} + +func (s *Standby_database_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standby_database_clausesContext) Activate_standby_db_clause() IActivate_standby_db_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IActivate_standby_db_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IActivate_standby_db_clauseContext) +} + +func (s *Standby_database_clausesContext) Maximize_standby_db_clause() IMaximize_standby_db_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaximize_standby_db_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaximize_standby_db_clauseContext) +} + +func (s *Standby_database_clausesContext) Register_logfile_clause() IRegister_logfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegister_logfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegister_logfile_clauseContext) +} + +func (s *Standby_database_clausesContext) Commit_switchover_clause() ICommit_switchover_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommit_switchover_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommit_switchover_clauseContext) +} + +func (s *Standby_database_clausesContext) Start_standby_clause() IStart_standby_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_standby_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_standby_clauseContext) +} + +func (s *Standby_database_clausesContext) Stop_standby_clause() IStop_standby_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStop_standby_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStop_standby_clauseContext) +} + +func (s *Standby_database_clausesContext) Convert_database_clause() IConvert_database_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvert_database_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvert_database_clauseContext) +} + +func (s *Standby_database_clausesContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Standby_database_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standby_database_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standby_database_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandby_database_clauses(s) + } +} + +func (s *Standby_database_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandby_database_clauses(s) + } +} + +func (p *PlSqlParser) Standby_database_clauses() (localctx IStandby_database_clausesContext) { + localctx = NewStandby_database_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1426, PlSqlParserRULE_standby_database_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserACTIVATE: + { + p.SetState(13974) + p.Activate_standby_db_clause() + } + + case PlSqlParserSET: + { + p.SetState(13975) + p.Maximize_standby_db_clause() + } + + case PlSqlParserREGISTER: + { + p.SetState(13976) + p.Register_logfile_clause() + } + + case PlSqlParserCOMMIT, PlSqlParserPREPARE: + { + p.SetState(13977) + p.Commit_switchover_clause() + } + + case PlSqlParserSTART: + { + p.SetState(13978) + p.Start_standby_clause() + } + + case PlSqlParserABORT, PlSqlParserSTOP: + { + p.SetState(13979) + p.Stop_standby_clause() + } + + case PlSqlParserCONVERT: + { + p.SetState(13980) + p.Convert_database_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(13983) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IActivate_standby_db_clauseContext is an interface to support dynamic dispatch. +type IActivate_standby_db_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIVATE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + FINISH() antlr.TerminalNode + APPLY() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + + // IsActivate_standby_db_clauseContext differentiates from other interfaces. + IsActivate_standby_db_clauseContext() +} + +type Activate_standby_db_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyActivate_standby_db_clauseContext() *Activate_standby_db_clauseContext { + var p = new(Activate_standby_db_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause + return p +} + +func InitEmptyActivate_standby_db_clauseContext(p *Activate_standby_db_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause +} + +func (*Activate_standby_db_clauseContext) IsActivate_standby_db_clauseContext() {} + +func NewActivate_standby_db_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Activate_standby_db_clauseContext { + var p = new(Activate_standby_db_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause + + return p +} + +func (s *Activate_standby_db_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Activate_standby_db_clauseContext) ACTIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVATE, 0) +} + +func (s *Activate_standby_db_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Activate_standby_db_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Activate_standby_db_clauseContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Activate_standby_db_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Activate_standby_db_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Activate_standby_db_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Activate_standby_db_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Activate_standby_db_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Activate_standby_db_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterActivate_standby_db_clause(s) + } +} + +func (s *Activate_standby_db_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitActivate_standby_db_clause(s) + } +} + +func (p *PlSqlParser) Activate_standby_db_clause() (localctx IActivate_standby_db_clauseContext) { + localctx = NewActivate_standby_db_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1428, PlSqlParserRULE_activate_standby_db_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13986) + p.Match(PlSqlParserACTIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(13987) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13990) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13991) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINISH { + { + p.SetState(13992) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13993) + p.Match(PlSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaximize_standby_db_clauseContext is an interface to support dynamic dispatch. +type IMaximize_standby_db_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + TO() antlr.TerminalNode + MAXIMIZE() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + + // IsMaximize_standby_db_clauseContext differentiates from other interfaces. + IsMaximize_standby_db_clauseContext() +} + +type Maximize_standby_db_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaximize_standby_db_clauseContext() *Maximize_standby_db_clauseContext { + var p = new(Maximize_standby_db_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause + return p +} + +func InitEmptyMaximize_standby_db_clauseContext(p *Maximize_standby_db_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause +} + +func (*Maximize_standby_db_clauseContext) IsMaximize_standby_db_clauseContext() {} + +func NewMaximize_standby_db_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maximize_standby_db_clauseContext { + var p = new(Maximize_standby_db_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause + + return p +} + +func (s *Maximize_standby_db_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maximize_standby_db_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Maximize_standby_db_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Maximize_standby_db_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Maximize_standby_db_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Maximize_standby_db_clauseContext) MAXIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXIMIZE, 0) +} + +func (s *Maximize_standby_db_clauseContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Maximize_standby_db_clauseContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Maximize_standby_db_clauseContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Maximize_standby_db_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maximize_standby_db_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maximize_standby_db_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMaximize_standby_db_clause(s) + } +} + +func (s *Maximize_standby_db_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMaximize_standby_db_clause(s) + } +} + +func (p *PlSqlParser) Maximize_standby_db_clause() (localctx IMaximize_standby_db_clauseContext) { + localctx = NewMaximize_standby_db_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1430, PlSqlParserRULE_maximize_standby_db_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13996) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13997) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13998) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13999) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14000) + p.Match(PlSqlParserMAXIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14001) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAVAILABILITY || _la == PlSqlParserPERFORMANCE || _la == PlSqlParserPROTECTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRegister_logfile_clauseContext is an interface to support dynamic dispatch. +type IRegister_logfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REGISTER() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsRegister_logfile_clauseContext differentiates from other interfaces. + IsRegister_logfile_clauseContext() +} + +type Register_logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegister_logfile_clauseContext() *Register_logfile_clauseContext { + var p = new(Register_logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_register_logfile_clause + return p +} + +func InitEmptyRegister_logfile_clauseContext(p *Register_logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_register_logfile_clause +} + +func (*Register_logfile_clauseContext) IsRegister_logfile_clauseContext() {} + +func NewRegister_logfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Register_logfile_clauseContext { + var p = new(Register_logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_register_logfile_clause + + return p +} + +func (s *Register_logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Register_logfile_clauseContext) REGISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGISTER, 0) +} + +func (s *Register_logfile_clauseContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Register_logfile_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Register_logfile_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Register_logfile_clauseContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Register_logfile_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Register_logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Register_logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Register_logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRegister_logfile_clause(s) + } +} + +func (s *Register_logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRegister_logfile_clause(s) + } +} + +func (p *PlSqlParser) Register_logfile_clause() (localctx IRegister_logfile_clauseContext) { + localctx = NewRegister_logfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1432, PlSqlParserRULE_register_logfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14003) + p.Match(PlSqlParserREGISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(14004) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14005) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14008) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14009) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommit_switchover_clauseContext is an interface to support dynamic dispatch. +type ICommit_switchover_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + SWITCHOVER() antlr.TerminalNode + PREPARE() antlr.TerminalNode + COMMIT() antlr.TerminalNode + CANCEL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + SESSION() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsCommit_switchover_clauseContext differentiates from other interfaces. + IsCommit_switchover_clauseContext() +} + +type Commit_switchover_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommit_switchover_clauseContext() *Commit_switchover_clauseContext { + var p = new(Commit_switchover_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause + return p +} + +func InitEmptyCommit_switchover_clauseContext(p *Commit_switchover_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause +} + +func (*Commit_switchover_clauseContext) IsCommit_switchover_clauseContext() {} + +func NewCommit_switchover_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_switchover_clauseContext { + var p = new(Commit_switchover_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause + + return p +} + +func (s *Commit_switchover_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Commit_switchover_clauseContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Commit_switchover_clauseContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Commit_switchover_clauseContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Commit_switchover_clauseContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Commit_switchover_clauseContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Commit_switchover_clauseContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Commit_switchover_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Commit_switchover_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Commit_switchover_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Commit_switchover_clauseContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Commit_switchover_clauseContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Commit_switchover_clauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Commit_switchover_clauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Commit_switchover_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Commit_switchover_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Commit_switchover_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Commit_switchover_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Commit_switchover_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Commit_switchover_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCommit_switchover_clause(s) + } +} + +func (s *Commit_switchover_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCommit_switchover_clause(s) + } +} + +func (p *PlSqlParser) Commit_switchover_clause() (localctx ICommit_switchover_clauseContext) { + localctx = NewCommit_switchover_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1434, PlSqlParserRULE_commit_switchover_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14011) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserPREPARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14012) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14013) + p.Match(PlSqlParserSWITCHOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOGICAL, PlSqlParserTO: + p.SetState(14039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTO: + { + p.SetState(14014) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1836, p.GetParserRuleContext()) { + case 1: + p.SetState(14023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1833, p.GetParserRuleContext()) { + case 1: + p.SetState(14016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(14015) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14018) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(14020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPHYSICAL { + { + p.SetState(14019) + p.Match(PlSqlParserPHYSICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14022) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSESSION || _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + p.SetState(14026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(14025) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14028) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14029) + p.Match(PlSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14030) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 2: + { + p.SetState(14033) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14034) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserLOGICAL: + { + p.SetState(14037) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14038) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCANCEL: + { + p.SetState(14041) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_standby_clauseContext is an interface to support dynamic dispatch. +type IStart_standby_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetScn_value returns the scn_value token. + GetScn_value() antlr.Token + + // SetScn_value sets the scn_value token. + SetScn_value(antlr.Token) + + // Getter signatures + START() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + APPLY() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + NODELAY() antlr.TerminalNode + NEW() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + Regular_id() IRegular_idContext + INITIAL() antlr.TerminalNode + SKIP_() antlr.TerminalNode + FAILED() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + FINISH() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsStart_standby_clauseContext differentiates from other interfaces. + IsStart_standby_clauseContext() +} + +type Start_standby_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + scn_value antlr.Token +} + +func NewEmptyStart_standby_clauseContext() *Start_standby_clauseContext { + var p = new(Start_standby_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_standby_clause + return p +} + +func InitEmptyStart_standby_clauseContext(p *Start_standby_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_standby_clause +} + +func (*Start_standby_clauseContext) IsStart_standby_clauseContext() {} + +func NewStart_standby_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_standby_clauseContext { + var p = new(Start_standby_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_standby_clause + + return p +} + +func (s *Start_standby_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_standby_clauseContext) GetScn_value() antlr.Token { return s.scn_value } + +func (s *Start_standby_clauseContext) SetScn_value(v antlr.Token) { s.scn_value = v } + +func (s *Start_standby_clauseContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Start_standby_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Start_standby_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Start_standby_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Start_standby_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Start_standby_clauseContext) NODELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, 0) +} + +func (s *Start_standby_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Start_standby_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Start_standby_clauseContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Start_standby_clauseContext) INITIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, 0) +} + +func (s *Start_standby_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Start_standby_clauseContext) FAILED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED, 0) +} + +func (s *Start_standby_clauseContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Start_standby_clauseContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Start_standby_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Start_standby_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_standby_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_standby_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_standby_clause(s) + } +} + +func (s *Start_standby_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_standby_clause(s) + } +} + +func (p *PlSqlParser) Start_standby_clause() (localctx IStart_standby_clauseContext) { + localctx = NewStart_standby_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1436, PlSqlParserRULE_start_standby_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14044) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14045) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14046) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14047) + p.Match(PlSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIMMEDIATE { + { + p.SetState(14048) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNODELAY { + { + p.SetState(14051) + p.Match(PlSqlParserNODELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserNEW: + { + p.SetState(14054) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14055) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14056) + p.Regular_id() + } + + case PlSqlParserINITIAL: + { + p.SetState(14057) + p.Match(PlSqlParserINITIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(14058) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Start_standby_clauseContext).scn_value = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserSKIP_: + { + p.SetState(14061) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14062) + p.Match(PlSqlParserFAILED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14063) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFINISH: + { + p.SetState(14064) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStop_standby_clauseContext is an interface to support dynamic dispatch. +type IStop_standby_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + APPLY() antlr.TerminalNode + STOP() antlr.TerminalNode + ABORT() antlr.TerminalNode + + // IsStop_standby_clauseContext differentiates from other interfaces. + IsStop_standby_clauseContext() +} + +type Stop_standby_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStop_standby_clauseContext() *Stop_standby_clauseContext { + var p = new(Stop_standby_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_stop_standby_clause + return p +} + +func InitEmptyStop_standby_clauseContext(p *Stop_standby_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_stop_standby_clause +} + +func (*Stop_standby_clauseContext) IsStop_standby_clauseContext() {} + +func NewStop_standby_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stop_standby_clauseContext { + var p = new(Stop_standby_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_stop_standby_clause + + return p +} + +func (s *Stop_standby_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stop_standby_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Stop_standby_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Stop_standby_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Stop_standby_clauseContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Stop_standby_clauseContext) ABORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABORT, 0) +} + +func (s *Stop_standby_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stop_standby_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stop_standby_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStop_standby_clause(s) + } +} + +func (s *Stop_standby_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStop_standby_clause(s) + } +} + +func (p *PlSqlParser) Stop_standby_clause() (localctx IStop_standby_clauseContext) { + localctx = NewStop_standby_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1438, PlSqlParserRULE_stop_standby_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14067) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABORT || _la == PlSqlParserSTOP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14068) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14069) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14070) + p.Match(PlSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConvert_database_clauseContext is an interface to support dynamic dispatch. +type IConvert_database_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONVERT() antlr.TerminalNode + TO() antlr.TerminalNode + STANDBY() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + + // IsConvert_database_clauseContext differentiates from other interfaces. + IsConvert_database_clauseContext() +} + +type Convert_database_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConvert_database_clauseContext() *Convert_database_clauseContext { + var p = new(Convert_database_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_database_clause + return p +} + +func InitEmptyConvert_database_clauseContext(p *Convert_database_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_database_clause +} + +func (*Convert_database_clauseContext) IsConvert_database_clauseContext() {} + +func NewConvert_database_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Convert_database_clauseContext { + var p = new(Convert_database_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_convert_database_clause + + return p +} + +func (s *Convert_database_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Convert_database_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Convert_database_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Convert_database_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Convert_database_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Convert_database_clauseContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Convert_database_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Convert_database_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Convert_database_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConvert_database_clause(s) + } +} + +func (s *Convert_database_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConvert_database_clause(s) + } +} + +func (p *PlSqlParser) Convert_database_clause() (localctx IConvert_database_clauseContext) { + localctx = NewConvert_database_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1440, PlSqlParserRULE_convert_database_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14072) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14073) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14074) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPHYSICAL || _la == PlSqlParserSNAPSHOT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14075) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_settings_clauseContext is an interface to support dynamic dispatch. +type IDefault_settings_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + EDITION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Edition_name() IEdition_nameContext + SET() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + Tablespace() ITablespaceContext + TEMPORARY() antlr.TerminalNode + Tablespace_group_name() ITablespace_group_nameContext + RENAME() antlr.TerminalNode + GLOBAL_NAME() antlr.TerminalNode + TO() antlr.TerminalNode + Database() IDatabaseContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllDomain() []IDomainContext + Domain(i int) IDomainContext + ENABLE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + CHANGE() antlr.TerminalNode + TRACKING() antlr.TerminalNode + USING() antlr.TerminalNode + FILE() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + Flashback_mode_clause() IFlashback_mode_clauseContext + Set_time_zone_clause() ISet_time_zone_clauseContext + + // IsDefault_settings_clauseContext differentiates from other interfaces. + IsDefault_settings_clauseContext() +} + +type Default_settings_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_settings_clauseContext() *Default_settings_clauseContext { + var p = new(Default_settings_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_settings_clause + return p +} + +func InitEmptyDefault_settings_clauseContext(p *Default_settings_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_settings_clause +} + +func (*Default_settings_clauseContext) IsDefault_settings_clauseContext() {} + +func NewDefault_settings_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_settings_clauseContext { + var p = new(Default_settings_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_settings_clause + + return p +} + +func (s *Default_settings_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_settings_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_settings_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Default_settings_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Default_settings_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Default_settings_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Default_settings_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_settings_clauseContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Default_settings_clauseContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Default_settings_clauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_settings_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Default_settings_clauseContext) Tablespace_group_name() ITablespace_group_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Default_settings_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Default_settings_clauseContext) GLOBAL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_NAME, 0) +} + +func (s *Default_settings_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Default_settings_clauseContext) Database() IDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabaseContext) +} + +func (s *Default_settings_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Default_settings_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Default_settings_clauseContext) AllDomain() []IDomainContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDomainContext); ok { + len++ + } + } + + tst := make([]IDomainContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDomainContext); ok { + tst[i] = t.(IDomainContext) + i++ + } + } + + return tst +} + +func (s *Default_settings_clauseContext) Domain(i int) IDomainContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDomainContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDomainContext) +} + +func (s *Default_settings_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Default_settings_clauseContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Default_settings_clauseContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Default_settings_clauseContext) TRACKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACKING, 0) +} + +func (s *Default_settings_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Default_settings_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Default_settings_clauseContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Default_settings_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Default_settings_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Default_settings_clauseContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Default_settings_clauseContext) Set_time_zone_clause() ISet_time_zone_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_time_zone_clauseContext) +} + +func (s *Default_settings_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_settings_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_settings_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_settings_clause(s) + } +} + +func (s *Default_settings_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_settings_clause(s) + } +} + +func (p *PlSqlParser) Default_settings_clause() (localctx IDefault_settings_clauseContext) { + localctx = NewDefault_settings_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1442, PlSqlParserRULE_default_settings_clause) + var _la int + + p.SetState(14123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1847, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14077) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14078) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14079) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14080) + p.Edition_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14081) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14082) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14083) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14084) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14085) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14086) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14087) + p.Tablespace() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14088) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14089) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14090) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1843, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14091) + p.Tablespace() + } + + case 2: + { + p.SetState(14092) + p.Tablespace_group_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14095) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14096) + p.Match(PlSqlParserGLOBAL_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14097) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14098) + p.Database() + } + p.SetState(14101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserPERIOD { + { + p.SetState(14099) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14100) + p.Domain() + } + + p.SetState(14103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14105) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14106) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14107) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14108) + p.Match(PlSqlParserTRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14109) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14110) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14111) + p.Filename() + } + p.SetState(14113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(14112) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14117) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14118) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14119) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14120) + p.Match(PlSqlParserTRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14121) + p.Flashback_mode_clause() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14122) + p.Set_time_zone_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_time_zone_clauseContext is an interface to support dynamic dispatch. +type ISet_time_zone_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsSet_time_zone_clauseContext differentiates from other interfaces. + IsSet_time_zone_clauseContext() +} + +type Set_time_zone_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_time_zone_clauseContext() *Set_time_zone_clauseContext { + var p = new(Set_time_zone_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause + return p +} + +func InitEmptySet_time_zone_clauseContext(p *Set_time_zone_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause +} + +func (*Set_time_zone_clauseContext) IsSet_time_zone_clauseContext() {} + +func NewSet_time_zone_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_time_zone_clauseContext { + var p = new(Set_time_zone_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause + + return p +} + +func (s *Set_time_zone_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_time_zone_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_time_zone_clauseContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Set_time_zone_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Set_time_zone_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Set_time_zone_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_time_zone_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_time_zone_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_time_zone_clause(s) + } +} + +func (s *Set_time_zone_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_time_zone_clause(s) + } +} + +func (p *PlSqlParser) Set_time_zone_clause() (localctx ISet_time_zone_clauseContext) { + localctx = NewSet_time_zone_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1444, PlSqlParserRULE_set_time_zone_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14125) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14126) + p.Match(PlSqlParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14127) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14128) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInstance_clausesContext is an interface to support dynamic dispatch. +type IInstance_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Enable_or_disable() IEnable_or_disableContext + INSTANCE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsInstance_clausesContext differentiates from other interfaces. + IsInstance_clausesContext() +} + +type Instance_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInstance_clausesContext() *Instance_clausesContext { + var p = new(Instance_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_instance_clauses + return p +} + +func InitEmptyInstance_clausesContext(p *Instance_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_instance_clauses +} + +func (*Instance_clausesContext) IsInstance_clausesContext() {} + +func NewInstance_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Instance_clausesContext { + var p = new(Instance_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_instance_clauses + + return p +} + +func (s *Instance_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Instance_clausesContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Instance_clausesContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Instance_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Instance_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Instance_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Instance_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInstance_clauses(s) + } +} + +func (s *Instance_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInstance_clauses(s) + } +} + +func (p *PlSqlParser) Instance_clauses() (localctx IInstance_clausesContext) { + localctx = NewInstance_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1446, PlSqlParserRULE_instance_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14130) + p.Enable_or_disable() + } + { + p.SetState(14131) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14132) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISecurity_clauseContext is an interface to support dynamic dispatch. +type ISecurity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GUARD() antlr.TerminalNode + ALL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsSecurity_clauseContext differentiates from other interfaces. + IsSecurity_clauseContext() +} + +type Security_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_clauseContext() *Security_clauseContext { + var p = new(Security_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_security_clause + return p +} + +func InitEmptySecurity_clauseContext(p *Security_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_security_clause +} + +func (*Security_clauseContext) IsSecurity_clauseContext() {} + +func NewSecurity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_clauseContext { + var p = new(Security_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_security_clause + + return p +} + +func (s *Security_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Security_clauseContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Security_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Security_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Security_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Security_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecurity_clause(s) + } +} + +func (s *Security_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecurity_clause(s) + } +} + +func (p *PlSqlParser) Security_clause() (localctx ISecurity_clauseContext) { + localctx = NewSecurity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1448, PlSqlParserRULE_security_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14134) + p.Match(PlSqlParserGUARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14135) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserNONE || _la == PlSqlParserSTANDBY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDomainContext is an interface to support dynamic dispatch. +type IDomainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDomainContext differentiates from other interfaces. + IsDomainContext() +} + +type DomainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDomainContext() *DomainContext { + var p = new(DomainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain + return p +} + +func InitEmptyDomainContext(p *DomainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain +} + +func (*DomainContext) IsDomainContext() {} + +func NewDomainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DomainContext { + var p = new(DomainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_domain + + return p +} + +func (s *DomainContext) GetParser() antlr.Parser { return s.parser } + +func (s *DomainContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *DomainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DomainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DomainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDomain(s) + } +} + +func (s *DomainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDomain(s) + } +} + +func (p *PlSqlParser) Domain() (localctx IDomainContext) { + localctx = NewDomainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1450, PlSqlParserRULE_domain) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14137) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabaseContext is an interface to support dynamic dispatch. +type IDatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDatabaseContext differentiates from other interfaces. + IsDatabaseContext() +} + +type DatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabaseContext() *DatabaseContext { + var p = new(DatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database + return p +} + +func InitEmptyDatabaseContext(p *DatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database +} + +func (*DatabaseContext) IsDatabaseContext() {} + +func NewDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatabaseContext { + var p = new(DatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database + + return p +} + +func (s *DatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatabaseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *DatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase(s) + } +} + +func (s *DatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase(s) + } +} + +func (p *PlSqlParser) Database() (localctx IDatabaseContext) { + localctx = NewDatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1452, PlSqlParserRULE_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14139) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEdition_nameContext is an interface to support dynamic dispatch. +type IEdition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsEdition_nameContext differentiates from other interfaces. + IsEdition_nameContext() +} + +type Edition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEdition_nameContext() *Edition_nameContext { + var p = new(Edition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_edition_name + return p +} + +func InitEmptyEdition_nameContext(p *Edition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_edition_name +} + +func (*Edition_nameContext) IsEdition_nameContext() {} + +func NewEdition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Edition_nameContext { + var p = new(Edition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_edition_name + + return p +} + +func (s *Edition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Edition_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Edition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Edition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Edition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEdition_name(s) + } +} + +func (s *Edition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEdition_name(s) + } +} + +func (p *PlSqlParser) Edition_name() (localctx IEdition_nameContext) { + localctx = NewEdition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1454, PlSqlParserRULE_edition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14141) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilenumberContext is an interface to support dynamic dispatch. +type IFilenumberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsFilenumberContext differentiates from other interfaces. + IsFilenumberContext() +} + +type FilenumberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilenumberContext() *FilenumberContext { + var p = new(FilenumberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filenumber + return p +} + +func InitEmptyFilenumberContext(p *FilenumberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filenumber +} + +func (*FilenumberContext) IsFilenumberContext() {} + +func NewFilenumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenumberContext { + var p = new(FilenumberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filenumber + + return p +} + +func (s *FilenumberContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilenumberContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *FilenumberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilenumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilenumberContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilenumber(s) + } +} + +func (s *FilenumberContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilenumber(s) + } +} + +func (p *PlSqlParser) Filenumber() (localctx IFilenumberContext) { + localctx = NewFilenumberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1456, PlSqlParserRULE_filenumber) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14143) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilenameContext is an interface to support dynamic dispatch. +type IFilenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsFilenameContext differentiates from other interfaces. + IsFilenameContext() +} + +type FilenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilenameContext() *FilenameContext { + var p = new(FilenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename + return p +} + +func InitEmptyFilenameContext(p *FilenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename +} + +func (*FilenameContext) IsFilenameContext() {} + +func NewFilenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenameContext { + var p = new(FilenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filename + + return p +} + +func (s *FilenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilenameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *FilenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilename(s) + } +} + +func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilename(s) + } +} + +func (p *PlSqlParser) Filename() (localctx IFilenameContext) { + localctx = NewFilenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1458, PlSqlParserRULE_filename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14145) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrepare_clauseContext is an interface to support dynamic dispatch. +type IPrepare_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + PREPARE() antlr.TerminalNode + AllMIRROR() []antlr.TerminalNode + MIRROR(i int) antlr.TerminalNode + COPY() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + WITH() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + FOR() antlr.TerminalNode + DATABASE() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + HIGH() antlr.TerminalNode + + // IsPrepare_clauseContext differentiates from other interfaces. + IsPrepare_clauseContext() +} + +type Prepare_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + c IId_expressionContext +} + +func NewEmptyPrepare_clauseContext() *Prepare_clauseContext { + var p = new(Prepare_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_prepare_clause + return p +} + +func InitEmptyPrepare_clauseContext(p *Prepare_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_prepare_clause +} + +func (*Prepare_clauseContext) IsPrepare_clauseContext() {} + +func NewPrepare_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prepare_clauseContext { + var p = new(Prepare_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_prepare_clause + + return p +} + +func (s *Prepare_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Prepare_clauseContext) GetC() IId_expressionContext { return s.c } + +func (s *Prepare_clauseContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Prepare_clauseContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Prepare_clauseContext) AllMIRROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMIRROR) +} + +func (s *Prepare_clauseContext) MIRROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, i) +} + +func (s *Prepare_clauseContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Prepare_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Prepare_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Prepare_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Prepare_clauseContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Prepare_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Prepare_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Prepare_clauseContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Prepare_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Prepare_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Prepare_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Prepare_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrepare_clause(s) + } +} + +func (s *Prepare_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrepare_clause(s) + } +} + +func (p *PlSqlParser) Prepare_clause() (localctx IPrepare_clauseContext) { + localctx = NewPrepare_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1460, PlSqlParserRULE_prepare_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14147) + p.Match(PlSqlParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14148) + p.Match(PlSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14149) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14150) + + var _x = p.Id_expression() + + localctx.(*Prepare_clauseContext).c = _x + } + p.SetState(14154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(14151) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14152) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserUNPROTECTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14153) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(14156) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14157) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14158) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_mirror_clauseContext is an interface to support dynamic dispatch. +type IDrop_mirror_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMn returns the mn rule contexts. + GetMn() IId_expressionContext + + // SetMn sets the mn rule contexts. + SetMn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + MIRROR() antlr.TerminalNode + COPY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_mirror_clauseContext differentiates from other interfaces. + IsDrop_mirror_clauseContext() +} + +type Drop_mirror_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mn IId_expressionContext +} + +func NewEmptyDrop_mirror_clauseContext() *Drop_mirror_clauseContext { + var p = new(Drop_mirror_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause + return p +} + +func InitEmptyDrop_mirror_clauseContext(p *Drop_mirror_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause +} + +func (*Drop_mirror_clauseContext) IsDrop_mirror_clauseContext() {} + +func NewDrop_mirror_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_mirror_clauseContext { + var p = new(Drop_mirror_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause + + return p +} + +func (s *Drop_mirror_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_mirror_clauseContext) GetMn() IId_expressionContext { return s.mn } + +func (s *Drop_mirror_clauseContext) SetMn(v IId_expressionContext) { s.mn = v } + +func (s *Drop_mirror_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_mirror_clauseContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Drop_mirror_clauseContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Drop_mirror_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_mirror_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_mirror_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_mirror_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_mirror_clause(s) + } +} + +func (s *Drop_mirror_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_mirror_clause(s) + } +} + +func (p *PlSqlParser) Drop_mirror_clause() (localctx IDrop_mirror_clauseContext) { + localctx = NewDrop_mirror_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1462, PlSqlParserRULE_drop_mirror_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14161) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14162) + p.Match(PlSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14163) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14164) + + var _x = p.Id_expression() + + localctx.(*Drop_mirror_clauseContext).mn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILost_write_protectionContext is an interface to support dynamic dispatch. +type ILost_write_protectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOST() antlr.TerminalNode + WRITE() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + REMOVE() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + + // IsLost_write_protectionContext differentiates from other interfaces. + IsLost_write_protectionContext() +} + +type Lost_write_protectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLost_write_protectionContext() *Lost_write_protectionContext { + var p = new(Lost_write_protectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lost_write_protection + return p +} + +func InitEmptyLost_write_protectionContext(p *Lost_write_protectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lost_write_protection +} + +func (*Lost_write_protectionContext) IsLost_write_protectionContext() {} + +func NewLost_write_protectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lost_write_protectionContext { + var p = new(Lost_write_protectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lost_write_protection + + return p +} + +func (s *Lost_write_protectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lost_write_protectionContext) LOST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOST, 0) +} + +func (s *Lost_write_protectionContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Lost_write_protectionContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Lost_write_protectionContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Lost_write_protectionContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Lost_write_protectionContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Lost_write_protectionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Lost_write_protectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lost_write_protectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lost_write_protectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLost_write_protection(s) + } +} + +func (s *Lost_write_protectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLost_write_protection(s) + } +} + +func (p *PlSqlParser) Lost_write_protection() (localctx ILost_write_protectionContext) { + localctx = NewLost_write_protectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1464, PlSqlParserRULE_lost_write_protection) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14166) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE || _la == PlSqlParserREMOVE || _la == PlSqlParserSUSPEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14167) + p.Match(PlSqlParserLOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14168) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14169) + p.Match(PlSqlParserPROTECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICdb_fleet_clausesContext is an interface to support dynamic dispatch. +type ICdb_fleet_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Lead_cdb_clause() ILead_cdb_clauseContext + Lead_cdb_uri_clause() ILead_cdb_uri_clauseContext + + // IsCdb_fleet_clausesContext differentiates from other interfaces. + IsCdb_fleet_clausesContext() +} + +type Cdb_fleet_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCdb_fleet_clausesContext() *Cdb_fleet_clausesContext { + var p = new(Cdb_fleet_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses + return p +} + +func InitEmptyCdb_fleet_clausesContext(p *Cdb_fleet_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses +} + +func (*Cdb_fleet_clausesContext) IsCdb_fleet_clausesContext() {} + +func NewCdb_fleet_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cdb_fleet_clausesContext { + var p = new(Cdb_fleet_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses + + return p +} + +func (s *Cdb_fleet_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cdb_fleet_clausesContext) Lead_cdb_clause() ILead_cdb_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILead_cdb_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILead_cdb_clauseContext) +} + +func (s *Cdb_fleet_clausesContext) Lead_cdb_uri_clause() ILead_cdb_uri_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILead_cdb_uri_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILead_cdb_uri_clauseContext) +} + +func (s *Cdb_fleet_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cdb_fleet_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cdb_fleet_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCdb_fleet_clauses(s) + } +} + +func (s *Cdb_fleet_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCdb_fleet_clauses(s) + } +} + +func (p *PlSqlParser) Cdb_fleet_clauses() (localctx ICdb_fleet_clausesContext) { + localctx = NewCdb_fleet_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1466, PlSqlParserRULE_cdb_fleet_clauses) + p.SetState(14173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1850, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14171) + p.Lead_cdb_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14172) + p.Lead_cdb_uri_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILead_cdb_clauseContext is an interface to support dynamic dispatch. +type ILead_cdb_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + LEAD_CDB() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsLead_cdb_clauseContext differentiates from other interfaces. + IsLead_cdb_clauseContext() +} + +type Lead_cdb_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLead_cdb_clauseContext() *Lead_cdb_clauseContext { + var p = new(Lead_cdb_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause + return p +} + +func InitEmptyLead_cdb_clauseContext(p *Lead_cdb_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause +} + +func (*Lead_cdb_clauseContext) IsLead_cdb_clauseContext() {} + +func NewLead_cdb_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lead_cdb_clauseContext { + var p = new(Lead_cdb_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause + + return p +} + +func (s *Lead_cdb_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lead_cdb_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Lead_cdb_clauseContext) LEAD_CDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB, 0) +} + +func (s *Lead_cdb_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lead_cdb_clauseContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *Lead_cdb_clauseContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *Lead_cdb_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lead_cdb_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lead_cdb_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLead_cdb_clause(s) + } +} + +func (s *Lead_cdb_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLead_cdb_clause(s) + } +} + +func (p *PlSqlParser) Lead_cdb_clause() (localctx ILead_cdb_clauseContext) { + localctx = NewLead_cdb_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1468, PlSqlParserRULE_lead_cdb_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14175) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14176) + p.Match(PlSqlParserLEAD_CDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14177) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14178) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFALSE || _la == PlSqlParserTRUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILead_cdb_uri_clauseContext is an interface to support dynamic dispatch. +type ILead_cdb_uri_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + LEAD_CDB_URI() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsLead_cdb_uri_clauseContext differentiates from other interfaces. + IsLead_cdb_uri_clauseContext() +} + +type Lead_cdb_uri_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLead_cdb_uri_clauseContext() *Lead_cdb_uri_clauseContext { + var p = new(Lead_cdb_uri_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause + return p +} + +func InitEmptyLead_cdb_uri_clauseContext(p *Lead_cdb_uri_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause +} + +func (*Lead_cdb_uri_clauseContext) IsLead_cdb_uri_clauseContext() {} + +func NewLead_cdb_uri_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lead_cdb_uri_clauseContext { + var p = new(Lead_cdb_uri_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause + + return p +} + +func (s *Lead_cdb_uri_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lead_cdb_uri_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Lead_cdb_uri_clauseContext) LEAD_CDB_URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB_URI, 0) +} + +func (s *Lead_cdb_uri_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lead_cdb_uri_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Lead_cdb_uri_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lead_cdb_uri_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lead_cdb_uri_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLead_cdb_uri_clause(s) + } +} + +func (s *Lead_cdb_uri_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLead_cdb_uri_clause(s) + } +} + +func (p *PlSqlParser) Lead_cdb_uri_clause() (localctx ILead_cdb_uri_clauseContext) { + localctx = NewLead_cdb_uri_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1470, PlSqlParserRULE_lead_cdb_uri_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14180) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14181) + p.Match(PlSqlParserLEAD_CDB_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14182) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14183) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperty_clausesContext is an interface to support dynamic dispatch. +type IProperty_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQcn returns the qcn rule contexts. + GetQcn() IId_expressionContext + + // SetQcn sets the qcn rule contexts. + SetQcn(IId_expressionContext) + + // Getter signatures + PROPERTY() antlr.TerminalNode + DEFAULT_CREDENTIAL() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + SET() antlr.TerminalNode + REMOVE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProperty_clausesContext differentiates from other interfaces. + IsProperty_clausesContext() +} + +type Property_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + qcn IId_expressionContext +} + +func NewEmptyProperty_clausesContext() *Property_clausesContext { + var p = new(Property_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_clauses + return p +} + +func InitEmptyProperty_clausesContext(p *Property_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_clauses +} + +func (*Property_clausesContext) IsProperty_clausesContext() {} + +func NewProperty_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_clausesContext { + var p = new(Property_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_clauses + + return p +} + +func (s *Property_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_clausesContext) GetQcn() IId_expressionContext { return s.qcn } + +func (s *Property_clausesContext) SetQcn(v IId_expressionContext) { s.qcn = v } + +func (s *Property_clausesContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPERTY, 0) +} + +func (s *Property_clausesContext) DEFAULT_CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_CREDENTIAL, 0) +} + +func (s *Property_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Property_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Property_clausesContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Property_clausesContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_clauses(s) + } +} + +func (s *Property_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_clauses(s) + } +} + +func (p *PlSqlParser) Property_clauses() (localctx IProperty_clausesContext) { + localctx = NewProperty_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1472, PlSqlParserRULE_property_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14185) + p.Match(PlSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14186) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserREMOVE || _la == PlSqlParserSET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14187) + p.Match(PlSqlParserDEFAULT_CREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14188) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14189) + + var _x = p.Id_expression() + + localctx.(*Property_clausesContext).qcn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplay_upgrade_clausesContext is an interface to support dynamic dispatch. +type IReplay_upgrade_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + SYNC() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsReplay_upgrade_clausesContext differentiates from other interfaces. + IsReplay_upgrade_clausesContext() +} + +type Replay_upgrade_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplay_upgrade_clausesContext() *Replay_upgrade_clausesContext { + var p = new(Replay_upgrade_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses + return p +} + +func InitEmptyReplay_upgrade_clausesContext(p *Replay_upgrade_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses +} + +func (*Replay_upgrade_clausesContext) IsReplay_upgrade_clausesContext() {} + +func NewReplay_upgrade_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replay_upgrade_clausesContext { + var p = new(Replay_upgrade_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses + + return p +} + +func (s *Replay_upgrade_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replay_upgrade_clausesContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Replay_upgrade_clausesContext) SYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNC, 0) +} + +func (s *Replay_upgrade_clausesContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Replay_upgrade_clausesContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Replay_upgrade_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replay_upgrade_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replay_upgrade_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplay_upgrade_clauses(s) + } +} + +func (s *Replay_upgrade_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplay_upgrade_clauses(s) + } +} + +func (p *PlSqlParser) Replay_upgrade_clauses() (localctx IReplay_upgrade_clausesContext) { + localctx = NewReplay_upgrade_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1474, PlSqlParserRULE_replay_upgrade_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14191) + p.Match(PlSqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14192) + p.Match(PlSqlParserSYNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14193) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_database_linkContext is an interface to support dynamic dispatch. +type IAlter_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Local_link_name() ILocal_link_nameContext + CONNECT() antlr.TerminalNode + TO() antlr.TerminalNode + User_object_name() IUser_object_nameContext + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Password_value() IPassword_valueContext + Link_authentication() ILink_authenticationContext + SHARED() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + + // IsAlter_database_linkContext differentiates from other interfaces. + IsAlter_database_linkContext() +} + +type Alter_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_database_linkContext() *Alter_database_linkContext { + var p = new(Alter_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database_link + return p +} + +func InitEmptyAlter_database_linkContext(p *Alter_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database_link +} + +func (*Alter_database_linkContext) IsAlter_database_linkContext() {} + +func NewAlter_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_database_linkContext { + var p = new(Alter_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_database_link + + return p +} + +func (s *Alter_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_database_linkContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Alter_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Alter_database_linkContext) Local_link_name() ILocal_link_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_link_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_link_nameContext) +} + +func (s *Alter_database_linkContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Alter_database_linkContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_database_linkContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Alter_database_linkContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Alter_database_linkContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Alter_database_linkContext) Password_value() IPassword_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Alter_database_linkContext) Link_authentication() ILink_authenticationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_authenticationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_authenticationContext) +} + +func (s *Alter_database_linkContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Alter_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_database_link(s) + } +} + +func (s *Alter_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_database_link(s) + } +} + +func (p *PlSqlParser) Alter_database_link() (localctx IAlter_database_linkContext) { + localctx = NewAlter_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1476, PlSqlParserRULE_alter_database_link) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14195) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARED { + { + p.SetState(14196) + p.Match(PlSqlParserSHARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(14199) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14202) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14203) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14204) + p.Local_link_name() + } + p.SetState(14215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + { + p.SetState(14205) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14206) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14207) + p.User_object_name() + } + { + p.SetState(14208) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14209) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14210) + p.Password_value() + } + p.SetState(14212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHENTICATED { + { + p.SetState(14211) + p.Link_authentication() + } + + } + + case PlSqlParserAUTHENTICATED: + { + p.SetState(14214) + p.Link_authentication() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPassword_valueContext is an interface to support dynamic dispatch. +type IPassword_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + Numeric() INumericContext + VALUES() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsPassword_valueContext differentiates from other interfaces. + IsPassword_valueContext() +} + +type Password_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_valueContext() *Password_valueContext { + var p = new(Password_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_value + return p +} + +func InitEmptyPassword_valueContext(p *Password_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_value +} + +func (*Password_valueContext) IsPassword_valueContext() {} + +func NewPassword_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_valueContext { + var p = new(Password_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_value + + return p +} + +func (s *Password_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_valueContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Password_valueContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Password_valueContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Password_valueContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Password_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_value(s) + } +} + +func (s *Password_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_value(s) + } +} + +func (p *PlSqlParser) Password_value() (localctx IPassword_valueContext) { + localctx = NewPassword_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1478, PlSqlParserRULE_password_value) + p.SetState(14221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14217) + p.Id_expression() + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14218) + p.Numeric() + } + + case PlSqlParserVALUES: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14219) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14220) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILink_authenticationContext is an interface to support dynamic dispatch. +type ILink_authenticationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHENTICATED() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + User_object_name() IUser_object_nameContext + IDENTIFIED() antlr.TerminalNode + Password_value() IPassword_valueContext + + // IsLink_authenticationContext differentiates from other interfaces. + IsLink_authenticationContext() +} + +type Link_authenticationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLink_authenticationContext() *Link_authenticationContext { + var p = new(Link_authenticationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_authentication + return p +} + +func InitEmptyLink_authenticationContext(p *Link_authenticationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_authentication +} + +func (*Link_authenticationContext) IsLink_authenticationContext() {} + +func NewLink_authenticationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Link_authenticationContext { + var p = new(Link_authenticationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_link_authentication + + return p +} + +func (s *Link_authenticationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Link_authenticationContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Link_authenticationContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Link_authenticationContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Link_authenticationContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Link_authenticationContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Link_authenticationContext) Password_value() IPassword_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Link_authenticationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Link_authenticationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Link_authenticationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLink_authentication(s) + } +} + +func (s *Link_authenticationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLink_authentication(s) + } +} + +func (p *PlSqlParser) Link_authentication() (localctx ILink_authenticationContext) { + localctx = NewLink_authenticationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1480, PlSqlParserRULE_link_authentication) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14223) + p.Match(PlSqlParserAUTHENTICATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14224) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14225) + p.User_object_name() + } + { + p.SetState(14226) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14227) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14228) + p.Password_value() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_schemaContext is an interface to support dynamic dispatch. +type ICreate_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + Schema_name() ISchema_nameContext + AllCreate_table() []ICreate_tableContext + Create_table(i int) ICreate_tableContext + AllCreate_view() []ICreate_viewContext + Create_view(i int) ICreate_viewContext + AllGrant_statement() []IGrant_statementContext + Grant_statement(i int) IGrant_statementContext + + // IsCreate_schemaContext differentiates from other interfaces. + IsCreate_schemaContext() +} + +type Create_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_schemaContext() *Create_schemaContext { + var p = new(Create_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_schema + return p +} + +func InitEmptyCreate_schemaContext(p *Create_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_schema +} + +func (*Create_schemaContext) IsCreate_schemaContext() {} + +func NewCreate_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schemaContext { + var p = new(Create_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_schema + + return p +} + +func (s *Create_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_schemaContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Create_schemaContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHORIZATION, 0) +} + +func (s *Create_schemaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_schemaContext) AllCreate_table() []ICreate_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_tableContext); ok { + len++ + } + } + + tst := make([]ICreate_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_tableContext); ok { + tst[i] = t.(ICreate_tableContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Create_table(i int) ICreate_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tableContext) +} + +func (s *Create_schemaContext) AllCreate_view() []ICreate_viewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_viewContext); ok { + len++ + } + } + + tst := make([]ICreate_viewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_viewContext); ok { + tst[i] = t.(ICreate_viewContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Create_view(i int) ICreate_viewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_viewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_viewContext) +} + +func (s *Create_schemaContext) AllGrant_statement() []IGrant_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrant_statementContext); ok { + len++ + } + } + + tst := make([]IGrant_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrant_statementContext); ok { + tst[i] = t.(IGrant_statementContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Grant_statement(i int) IGrant_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrant_statementContext) +} + +func (s *Create_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_schema(s) + } +} + +func (s *Create_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_schema(s) + } +} + +func (p *PlSqlParser) Create_schema() (localctx ICreate_schemaContext) { + localctx = NewCreate_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1482, PlSqlParserRULE_create_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14230) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14231) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14232) + p.Match(PlSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14233) + p.Schema_name() + } + p.SetState(14239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCREATE || _la == PlSqlParserGRANT { + p.SetState(14237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1856, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14234) + p.Create_table() + } + + case 2: + { + p.SetState(14235) + p.Create_view() + } + + case 3: + { + p.SetState(14236) + p.Grant_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_databaseContext is an interface to support dynamic dispatch. +type ICreate_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Database_name() IDatabase_nameContext + AllUSER() []antlr.TerminalNode + USER(i int) antlr.TerminalNode + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPassword_value() []IPassword_valueContext + Password_value(i int) IPassword_valueContext + AllCONTROLFILE() []antlr.TerminalNode + CONTROLFILE(i int) antlr.TerminalNode + AllREUSE() []antlr.TerminalNode + REUSE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCHARACTER() []antlr.TerminalNode + CHARACTER(i int) antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + AllChar_set_name() []IChar_set_nameContext + Char_set_name(i int) IChar_set_nameContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllDatabase_logging_clauses() []IDatabase_logging_clausesContext + Database_logging_clauses(i int) IDatabase_logging_clausesContext + AllTablespace_clauses() []ITablespace_clausesContext + Tablespace_clauses(i int) ITablespace_clausesContext + AllSet_time_zone_clause() []ISet_time_zone_clauseContext + Set_time_zone_clause(i int) ISet_time_zone_clauseContext + AllUSER_DATA() []antlr.TerminalNode + USER_DATA(i int) antlr.TerminalNode + AllTablespace_group_name() []ITablespace_group_nameContext + Tablespace_group_name(i int) ITablespace_group_nameContext + AllDATAFILE() []antlr.TerminalNode + DATAFILE(i int) antlr.TerminalNode + AllDatafile_tempfile_spec() []IDatafile_tempfile_specContext + Datafile_tempfile_spec(i int) IDatafile_tempfile_specContext + AllEnable_pluggable_database() []IEnable_pluggable_databaseContext + Enable_pluggable_database(i int) IEnable_pluggable_databaseContext + AllSYS() []antlr.TerminalNode + SYS(i int) antlr.TerminalNode + AllSYSTEM() []antlr.TerminalNode + SYSTEM(i int) antlr.TerminalNode + AllMAXDATAFILES() []antlr.TerminalNode + MAXDATAFILES(i int) antlr.TerminalNode + AllMAXINSTANCES() []antlr.TerminalNode + MAXINSTANCES(i int) antlr.TerminalNode + AllBIGFILE() []antlr.TerminalNode + BIGFILE(i int) antlr.TerminalNode + AllSMALLFILE() []antlr.TerminalNode + SMALLFILE(i int) antlr.TerminalNode + AllNATIONAL() []antlr.TerminalNode + NATIONAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_databaseContext differentiates from other interfaces. + IsCreate_databaseContext() +} + +type Create_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_databaseContext() *Create_databaseContext { + var p = new(Create_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database + return p +} + +func InitEmptyCreate_databaseContext(p *Create_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database +} + +func (*Create_databaseContext) IsCreate_databaseContext() {} + +func NewCreate_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_databaseContext { + var p = new(Create_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_database + + return p +} + +func (s *Create_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_databaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_databaseContext) Database_name() IDatabase_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_nameContext) +} + +func (s *Create_databaseContext) AllUSER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSER) +} + +func (s *Create_databaseContext) USER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, i) +} + +func (s *Create_databaseContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Create_databaseContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Create_databaseContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Create_databaseContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Create_databaseContext) AllPassword_value() []IPassword_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_valueContext); ok { + len++ + } + } + + tst := make([]IPassword_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_valueContext); ok { + tst[i] = t.(IPassword_valueContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Password_value(i int) IPassword_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Create_databaseContext) AllCONTROLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTROLFILE) +} + +func (s *Create_databaseContext) CONTROLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, i) +} + +func (s *Create_databaseContext) AllREUSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREUSE) +} + +func (s *Create_databaseContext) REUSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, i) +} + +func (s *Create_databaseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Create_databaseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Create_databaseContext) AllCHARACTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHARACTER) +} + +func (s *Create_databaseContext) CHARACTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, i) +} + +func (s *Create_databaseContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSET) +} + +func (s *Create_databaseContext) SET(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, i) +} + +func (s *Create_databaseContext) AllChar_set_name() []IChar_set_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IChar_set_nameContext); ok { + len++ + } + } + + tst := make([]IChar_set_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IChar_set_nameContext); ok { + tst[i] = t.(IChar_set_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Char_set_name(i int) IChar_set_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Create_databaseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Create_databaseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Create_databaseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_databaseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_databaseContext) AllDatabase_logging_clauses() []IDatabase_logging_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_logging_clausesContext); ok { + len++ + } + } + + tst := make([]IDatabase_logging_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_logging_clausesContext); ok { + tst[i] = t.(IDatabase_logging_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Database_logging_clauses(i int) IDatabase_logging_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_logging_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_logging_clausesContext) +} + +func (s *Create_databaseContext) AllTablespace_clauses() []ITablespace_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_clausesContext); ok { + len++ + } + } + + tst := make([]ITablespace_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_clausesContext); ok { + tst[i] = t.(ITablespace_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Tablespace_clauses(i int) ITablespace_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_clausesContext) +} + +func (s *Create_databaseContext) AllSet_time_zone_clause() []ISet_time_zone_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + len++ + } + } + + tst := make([]ISet_time_zone_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_time_zone_clauseContext); ok { + tst[i] = t.(ISet_time_zone_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Set_time_zone_clause(i int) ISet_time_zone_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_time_zone_clauseContext) +} + +func (s *Create_databaseContext) AllUSER_DATA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSER_DATA) +} + +func (s *Create_databaseContext) USER_DATA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DATA, i) +} + +func (s *Create_databaseContext) AllTablespace_group_name() []ITablespace_group_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + len++ + } + } + + tst := make([]ITablespace_group_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_group_nameContext); ok { + tst[i] = t.(ITablespace_group_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Tablespace_group_name(i int) ITablespace_group_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Create_databaseContext) AllDATAFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATAFILE) +} + +func (s *Create_databaseContext) DATAFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, i) +} + +func (s *Create_databaseContext) AllDatafile_tempfile_spec() []IDatafile_tempfile_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + len++ + } + } + + tst := make([]IDatafile_tempfile_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatafile_tempfile_specContext); ok { + tst[i] = t.(IDatafile_tempfile_specContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Datafile_tempfile_spec(i int) IDatafile_tempfile_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Create_databaseContext) AllEnable_pluggable_database() []IEnable_pluggable_databaseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_pluggable_databaseContext); ok { + len++ + } + } + + tst := make([]IEnable_pluggable_databaseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_pluggable_databaseContext); ok { + tst[i] = t.(IEnable_pluggable_databaseContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Enable_pluggable_database(i int) IEnable_pluggable_databaseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_pluggable_databaseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_pluggable_databaseContext) +} + +func (s *Create_databaseContext) AllSYS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSYS) +} + +func (s *Create_databaseContext) SYS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, i) +} + +func (s *Create_databaseContext) AllSYSTEM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSYSTEM) +} + +func (s *Create_databaseContext) SYSTEM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, i) +} + +func (s *Create_databaseContext) AllMAXDATAFILES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXDATAFILES) +} + +func (s *Create_databaseContext) MAXDATAFILES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, i) +} + +func (s *Create_databaseContext) AllMAXINSTANCES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXINSTANCES) +} + +func (s *Create_databaseContext) MAXINSTANCES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, i) +} + +func (s *Create_databaseContext) AllBIGFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBIGFILE) +} + +func (s *Create_databaseContext) BIGFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, i) +} + +func (s *Create_databaseContext) AllSMALLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSMALLFILE) +} + +func (s *Create_databaseContext) SMALLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, i) +} + +func (s *Create_databaseContext) AllNATIONAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNATIONAL) +} + +func (s *Create_databaseContext) NATIONAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL, i) +} + +func (s *Create_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_database(s) + } +} + +func (s *Create_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_database(s) + } +} + +func (p *PlSqlParser) Create_database() (localctx ICreate_databaseContext) { + localctx = NewCreate_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1484, PlSqlParserRULE_create_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14242) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14243) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14244) + p.Database_name() + } + p.SetState(14283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserARCHIVELOG || _la == PlSqlParserBIGFILE || _la == PlSqlParserCHARACTER || _la == PlSqlParserCONTROLFILE || _la == PlSqlParserDATAFILE || _la == PlSqlParserDEFAULT || _la == PlSqlParserENABLE || _la == PlSqlParserEXTENT || _la == PlSqlParserFORCE || ((int64((_la-882)) & ^0x3f) == 0 && ((int64(1)<<(_la-882))&133040906960897) != 0) || _la == PlSqlParserNATIONAL || _la == PlSqlParserNOARCHIVELOG || _la == PlSqlParserSET || _la == PlSqlParserSMALLFILE || _la == PlSqlParserSYSAUX || ((int64((_la-2178)) & ^0x3f) == 0 && ((int64(1)<<(_la-2178))&580964351930793985) != 0) { + p.SetState(14283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1861, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14245) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14246) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSYS || _la == PlSqlParserSYSTEM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14247) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14248) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14249) + p.Password_value() + } + + case 2: + { + p.SetState(14250) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14251) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(14252) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAXDATAFILES || _la == PlSqlParserMAXINSTANCES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14253) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.SetState(14255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNATIONAL { + { + p.SetState(14254) + p.Match(PlSqlParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14257) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14258) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14259) + p.Char_set_name() + } + + case 5: + { + p.SetState(14260) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14261) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14262) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14263) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(14264) + p.Database_logging_clauses() + } + + case 7: + { + p.SetState(14265) + p.Tablespace_clauses() + } + + case 8: + { + p.SetState(14266) + p.Set_time_zone_clause() + } + + case 9: + p.SetState(14268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(14267) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14270) + p.Match(PlSqlParserUSER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14271) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14272) + p.Tablespace_group_name() + } + { + p.SetState(14273) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14274) + p.Datafile_tempfile_spec() + } + p.SetState(14279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14275) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14276) + p.Datafile_tempfile_spec() + } + + p.SetState(14281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 10: + { + p.SetState(14282) + p.Enable_pluggable_database() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_logging_clausesContext is an interface to support dynamic dispatch. +type IDatabase_logging_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGFILE() antlr.TerminalNode + AllDatabase_logging_sub_clause() []IDatabase_logging_sub_clauseContext + Database_logging_sub_clause(i int) IDatabase_logging_sub_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + MAXLOGFILES() antlr.TerminalNode + MAXLOGMEMBERS() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + + // IsDatabase_logging_clausesContext differentiates from other interfaces. + IsDatabase_logging_clausesContext() +} + +type Database_logging_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_logging_clausesContext() *Database_logging_clausesContext { + var p = new(Database_logging_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_clauses + return p +} + +func InitEmptyDatabase_logging_clausesContext(p *Database_logging_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_clauses +} + +func (*Database_logging_clausesContext) IsDatabase_logging_clausesContext() {} + +func NewDatabase_logging_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_logging_clausesContext { + var p = new(Database_logging_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_logging_clauses + + return p +} + +func (s *Database_logging_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_logging_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Database_logging_clausesContext) AllDatabase_logging_sub_clause() []IDatabase_logging_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IDatabase_logging_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + tst[i] = t.(IDatabase_logging_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Database_logging_clausesContext) Database_logging_sub_clause(i int) IDatabase_logging_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_logging_sub_clauseContext) +} + +func (s *Database_logging_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Database_logging_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Database_logging_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Database_logging_clausesContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Database_logging_clausesContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Database_logging_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Database_logging_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Database_logging_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_logging_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_logging_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_logging_clauses(s) + } +} + +func (s *Database_logging_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_logging_clauses(s) + } +} + +func (p *PlSqlParser) Database_logging_clauses() (localctx IDatabase_logging_clausesContext) { + localctx = NewDatabase_logging_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1486, PlSqlParserRULE_database_logging_clauses) + var _la int + + p.SetState(14302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOGFILE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14287) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14288) + p.Database_logging_sub_clause() + } + p.SetState(14293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14289) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14290) + p.Database_logging_sub_clause() + } + + p.SetState(14295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14296) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-926)) & ^0x3f) == 0 && ((int64(1)<<(_la-926))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14297) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARCHIVELOG: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14298) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOARCHIVELOG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14299) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14300) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14301) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_logging_sub_clauseContext is an interface to support dynamic dispatch. +type IDatabase_logging_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + File_specification() IFile_specificationContext + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsDatabase_logging_sub_clauseContext differentiates from other interfaces. + IsDatabase_logging_sub_clauseContext() +} + +type Database_logging_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_logging_sub_clauseContext() *Database_logging_sub_clauseContext { + var p = new(Database_logging_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause + return p +} + +func InitEmptyDatabase_logging_sub_clauseContext(p *Database_logging_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause +} + +func (*Database_logging_sub_clauseContext) IsDatabase_logging_sub_clauseContext() {} + +func NewDatabase_logging_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_logging_sub_clauseContext { + var p = new(Database_logging_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause + + return p +} + +func (s *Database_logging_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_logging_sub_clauseContext) File_specification() IFile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Database_logging_sub_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Database_logging_sub_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Database_logging_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_logging_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_logging_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_logging_sub_clause(s) + } +} + +func (s *Database_logging_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_logging_sub_clause(s) + } +} + +func (p *PlSqlParser) Database_logging_sub_clause() (localctx IDatabase_logging_sub_clauseContext) { + localctx = NewDatabase_logging_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1488, PlSqlParserRULE_database_logging_sub_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(14304) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14305) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14308) + p.File_specification() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_clausesContext is an interface to support dynamic dispatch. +type ITablespace_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTENT() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + SYSAUX() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Default_tablespace() IDefault_tablespaceContext + Default_temp_tablespace() IDefault_temp_tablespaceContext + Undo_tablespace() IUndo_tablespaceContext + + // IsTablespace_clausesContext differentiates from other interfaces. + IsTablespace_clausesContext() +} + +type Tablespace_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_clausesContext() *Tablespace_clausesContext { + var p = new(Tablespace_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_clauses + return p +} + +func InitEmptyTablespace_clausesContext(p *Tablespace_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_clauses +} + +func (*Tablespace_clausesContext) IsTablespace_clausesContext() {} + +func NewTablespace_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_clausesContext { + var p = new(Tablespace_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_clauses + + return p +} + +func (s *Tablespace_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_clausesContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Tablespace_clausesContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Tablespace_clausesContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Tablespace_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Tablespace_clausesContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_clausesContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Tablespace_clausesContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Tablespace_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Tablespace_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Tablespace_clausesContext) Default_tablespace() IDefault_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespaceContext) +} + +func (s *Tablespace_clausesContext) Default_temp_tablespace() IDefault_temp_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_temp_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_temp_tablespaceContext) +} + +func (s *Tablespace_clausesContext) Undo_tablespace() IUndo_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_tablespaceContext) +} + +func (s *Tablespace_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_clauses(s) + } +} + +func (s *Tablespace_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_clauses(s) + } +} + +func (p *PlSqlParser) Tablespace_clauses() (localctx ITablespace_clausesContext) { + localctx = NewTablespace_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1490, PlSqlParserRULE_tablespace_clauses) + var _la int + + p.SetState(14328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1868, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14310) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14311) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14312) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(14314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSAUX { + { + p.SetState(14313) + p.Match(PlSqlParserSYSAUX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14316) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14317) + p.File_specification() + } + p.SetState(14322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14318) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14319) + p.File_specification() + } + + p.SetState(14324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14325) + p.Default_tablespace() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14326) + p.Default_temp_tablespace() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14327) + p.Undo_tablespace() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_pluggable_databaseContext is an interface to support dynamic dispatch. +type IEnable_pluggable_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SEED() antlr.TerminalNode + Undo_mode_clause() IUndo_mode_clauseContext + File_name_convert() IFile_name_convertContext + SYSTEM() antlr.TerminalNode + AllTablespace_datafile_clauses() []ITablespace_datafile_clausesContext + Tablespace_datafile_clauses(i int) ITablespace_datafile_clausesContext + SYSAUX() antlr.TerminalNode + + // IsEnable_pluggable_databaseContext differentiates from other interfaces. + IsEnable_pluggable_databaseContext() +} + +type Enable_pluggable_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_pluggable_databaseContext() *Enable_pluggable_databaseContext { + var p = new(Enable_pluggable_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database + return p +} + +func InitEmptyEnable_pluggable_databaseContext(p *Enable_pluggable_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database +} + +func (*Enable_pluggable_databaseContext) IsEnable_pluggable_databaseContext() {} + +func NewEnable_pluggable_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_pluggable_databaseContext { + var p = new(Enable_pluggable_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database + + return p +} + +func (s *Enable_pluggable_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_pluggable_databaseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_pluggable_databaseContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Enable_pluggable_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Enable_pluggable_databaseContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Enable_pluggable_databaseContext) Undo_mode_clause() IUndo_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_mode_clauseContext) +} + +func (s *Enable_pluggable_databaseContext) File_name_convert() IFile_name_convertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_name_convertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_name_convertContext) +} + +func (s *Enable_pluggable_databaseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Enable_pluggable_databaseContext) AllTablespace_datafile_clauses() []ITablespace_datafile_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_datafile_clausesContext); ok { + len++ + } + } + + tst := make([]ITablespace_datafile_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_datafile_clausesContext); ok { + tst[i] = t.(ITablespace_datafile_clausesContext) + i++ + } + } + + return tst +} + +func (s *Enable_pluggable_databaseContext) Tablespace_datafile_clauses(i int) ITablespace_datafile_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_datafile_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_datafile_clausesContext) +} + +func (s *Enable_pluggable_databaseContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Enable_pluggable_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_pluggable_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_pluggable_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_pluggable_database(s) + } +} + +func (s *Enable_pluggable_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_pluggable_database(s) + } +} + +func (p *PlSqlParser) Enable_pluggable_database() (localctx IEnable_pluggable_databaseContext) { + localctx = NewEnable_pluggable_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1492, PlSqlParserRULE_enable_pluggable_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14330) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14331) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14332) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEED { + { + p.SetState(14333) + p.Match(PlSqlParserSEED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILE_NAME_CONVERT { + { + p.SetState(14334) + p.File_name_convert() + } + + } + p.SetState(14339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(14337) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14338) + p.Tablespace_datafile_clauses() + } + + } + p.SetState(14343) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1871, p.GetParserRuleContext()) == 1 { + { + p.SetState(14341) + p.Match(PlSqlParserSYSAUX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14342) + p.Tablespace_datafile_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(14348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(14347) + p.Undo_mode_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_name_convertContext is an interface to support dynamic dispatch. +type IFile_name_convertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILE_NAME_CONVERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllFilename_convert_sub_clause() []IFilename_convert_sub_clauseContext + Filename_convert_sub_clause(i int) IFilename_convert_sub_clauseContext + RIGHT_PAREN() antlr.TerminalNode + NONE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_name_convertContext differentiates from other interfaces. + IsFile_name_convertContext() +} + +type File_name_convertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_name_convertContext() *File_name_convertContext { + var p = new(File_name_convertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_name_convert + return p +} + +func InitEmptyFile_name_convertContext(p *File_name_convertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_name_convert +} + +func (*File_name_convertContext) IsFile_name_convertContext() {} + +func NewFile_name_convertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_name_convertContext { + var p = new(File_name_convertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_name_convert + + return p +} + +func (s *File_name_convertContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_name_convertContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *File_name_convertContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *File_name_convertContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *File_name_convertContext) AllFilename_convert_sub_clause() []IFilename_convert_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IFilename_convert_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + tst[i] = t.(IFilename_convert_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *File_name_convertContext) Filename_convert_sub_clause(i int) IFilename_convert_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilename_convert_sub_clauseContext) +} + +func (s *File_name_convertContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *File_name_convertContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *File_name_convertContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_name_convertContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_name_convertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_name_convertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_name_convertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_name_convert(s) + } +} + +func (s *File_name_convertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_name_convert(s) + } +} + +func (p *PlSqlParser) File_name_convert() (localctx IFile_name_convertContext) { + localctx = NewFile_name_convertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1494, PlSqlParserRULE_file_name_convert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14350) + p.Match(PlSqlParserFILE_NAME_CONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14351) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(14352) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14353) + p.Filename_convert_sub_clause() + } + p.SetState(14358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14354) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14355) + p.Filename_convert_sub_clause() + } + + p.SetState(14360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14361) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(14363) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilename_convert_sub_clauseContext is an interface to support dynamic dispatch. +type IFilename_convert_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsFilename_convert_sub_clauseContext differentiates from other interfaces. + IsFilename_convert_sub_clauseContext() +} + +type Filename_convert_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilename_convert_sub_clauseContext() *Filename_convert_sub_clauseContext { + var p = new(Filename_convert_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause + return p +} + +func InitEmptyFilename_convert_sub_clauseContext(p *Filename_convert_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause +} + +func (*Filename_convert_sub_clauseContext) IsFilename_convert_sub_clauseContext() {} + +func NewFilename_convert_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filename_convert_sub_clauseContext { + var p = new(Filename_convert_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause + + return p +} + +func (s *Filename_convert_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filename_convert_sub_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Filename_convert_sub_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Filename_convert_sub_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Filename_convert_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filename_convert_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filename_convert_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilename_convert_sub_clause(s) + } +} + +func (s *Filename_convert_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilename_convert_sub_clause(s) + } +} + +func (p *PlSqlParser) Filename_convert_sub_clause() (localctx IFilename_convert_sub_clauseContext) { + localctx = NewFilename_convert_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1496, PlSqlParserRULE_filename_convert_sub_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14366) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14369) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1876, p.GetParserRuleContext()) == 1 { + { + p.SetState(14367) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14368) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_datafile_clausesContext is an interface to support dynamic dispatch. +type ITablespace_datafile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILES() antlr.TerminalNode + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllAutoextend_clause() []IAutoextend_clauseContext + Autoextend_clause(i int) IAutoextend_clauseContext + + // IsTablespace_datafile_clausesContext differentiates from other interfaces. + IsTablespace_datafile_clausesContext() +} + +type Tablespace_datafile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_datafile_clausesContext() *Tablespace_datafile_clausesContext { + var p = new(Tablespace_datafile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses + return p +} + +func InitEmptyTablespace_datafile_clausesContext(p *Tablespace_datafile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses +} + +func (*Tablespace_datafile_clausesContext) IsTablespace_datafile_clausesContext() {} + +func NewTablespace_datafile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_datafile_clausesContext { + var p = new(Tablespace_datafile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses + + return p +} + +func (s *Tablespace_datafile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_datafile_clausesContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Tablespace_datafile_clausesContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Tablespace_datafile_clausesContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Tablespace_datafile_clausesContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_datafile_clausesContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Tablespace_datafile_clausesContext) AllAutoextend_clause() []IAutoextend_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + len++ + } + } + + tst := make([]IAutoextend_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAutoextend_clauseContext); ok { + tst[i] = t.(IAutoextend_clauseContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_datafile_clausesContext) Autoextend_clause(i int) IAutoextend_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Tablespace_datafile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_datafile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_datafile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_datafile_clauses(s) + } +} + +func (s *Tablespace_datafile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_datafile_clauses(s) + } +} + +func (p *PlSqlParser) Tablespace_datafile_clauses() (localctx ITablespace_datafile_clausesContext) { + localctx = NewTablespace_datafile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1498, PlSqlParserRULE_tablespace_datafile_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14371) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserAUTOEXTEND || _la == PlSqlParserSIZE { + p.SetState(14375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSIZE: + { + p.SetState(14372) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14373) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(14374) + p.Autoextend_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndo_mode_clauseContext is an interface to support dynamic dispatch. +type IUndo_mode_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + UNDO() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsUndo_mode_clauseContext differentiates from other interfaces. + IsUndo_mode_clauseContext() +} + +type Undo_mode_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndo_mode_clauseContext() *Undo_mode_clauseContext { + var p = new(Undo_mode_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_mode_clause + return p +} + +func InitEmptyUndo_mode_clauseContext(p *Undo_mode_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_mode_clause +} + +func (*Undo_mode_clauseContext) IsUndo_mode_clauseContext() {} + +func NewUndo_mode_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_mode_clauseContext { + var p = new(Undo_mode_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_mode_clause + + return p +} + +func (s *Undo_mode_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_mode_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Undo_mode_clauseContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_mode_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Undo_mode_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Undo_mode_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_mode_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_mode_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_mode_clause(s) + } +} + +func (s *Undo_mode_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_mode_clause(s) + } +} + +func (p *PlSqlParser) Undo_mode_clause() (localctx IUndo_mode_clauseContext) { + localctx = NewUndo_mode_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1500, PlSqlParserRULE_undo_mode_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14379) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14380) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14381) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_tablespaceContext is an interface to support dynamic dispatch. +type IDefault_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + DATAFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + Extent_management_clause() IExtent_management_clauseContext + + // IsDefault_tablespaceContext differentiates from other interfaces. + IsDefault_tablespaceContext() +} + +type Default_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_tablespaceContext() *Default_tablespaceContext { + var p = new(Default_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace + return p +} + +func InitEmptyDefault_tablespaceContext(p *Default_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace +} + +func (*Default_tablespaceContext) IsDefault_tablespaceContext() {} + +func NewDefault_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_tablespaceContext { + var p = new(Default_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_tablespace + + return p +} + +func (s *Default_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_tablespaceContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Default_tablespaceContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Default_tablespaceContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Default_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_tablespace(s) + } +} + +func (s *Default_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_tablespace(s) + } +} + +func (p *PlSqlParser) Default_tablespace() (localctx IDefault_tablespaceContext) { + localctx = NewDefault_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1502, PlSqlParserRULE_default_tablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14383) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14384) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14385) + p.Tablespace() + } + p.SetState(14388) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1879, p.GetParserRuleContext()) == 1 { + { + p.SetState(14386) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14387) + p.Datafile_tempfile_spec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14391) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1880, p.GetParserRuleContext()) == 1 { + { + p.SetState(14390) + p.Extent_management_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_temp_tablespaceContext is an interface to support dynamic dispatch. +type IDefault_temp_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Tablespace() ITablespaceContext + TEMPORARY() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + FOR() antlr.TerminalNode + ALL() antlr.TerminalNode + LEAF() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + Extent_management_clause() IExtent_management_clauseContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDefault_temp_tablespaceContext differentiates from other interfaces. + IsDefault_temp_tablespaceContext() +} + +type Default_temp_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_temp_tablespaceContext() *Default_temp_tablespaceContext { + var p = new(Default_temp_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace + return p +} + +func InitEmptyDefault_temp_tablespaceContext(p *Default_temp_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace +} + +func (*Default_temp_tablespaceContext) IsDefault_temp_tablespaceContext() {} + +func NewDefault_temp_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_temp_tablespaceContext { + var p = new(Default_temp_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace + + return p +} + +func (s *Default_temp_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_temp_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_temp_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_temp_tablespaceContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Default_temp_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_temp_tablespaceContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Default_temp_tablespaceContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Default_temp_tablespaceContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Default_temp_tablespaceContext) LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAF, 0) +} + +func (s *Default_temp_tablespaceContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Default_temp_tablespaceContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Default_temp_tablespaceContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Default_temp_tablespaceContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Default_temp_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Default_temp_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Default_temp_tablespaceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Default_temp_tablespaceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Default_temp_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_temp_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_temp_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_temp_tablespace(s) + } +} + +func (s *Default_temp_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_temp_tablespace(s) + } +} + +func (p *PlSqlParser) Default_temp_tablespace() (localctx IDefault_temp_tablespaceContext) { + localctx = NewDefault_temp_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1504, PlSqlParserRULE_default_temp_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(14393) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14396) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTEMPORARY: + { + p.SetState(14397) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14398) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOCAL: + { + p.SetState(14399) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14400) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14401) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14402) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14403) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserLEAF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(14406) + p.Tablespace() + } + p.SetState(14416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTEMPFILE { + { + p.SetState(14407) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14408) + p.File_specification() + } + p.SetState(14413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14409) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14410) + p.File_specification() + } + + p.SetState(14415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(14419) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1885, p.GetParserRuleContext()) == 1 { + { + p.SetState(14418) + p.Extent_management_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndo_tablespaceContext is an interface to support dynamic dispatch. +type IUndo_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDO() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUndo_tablespaceContext differentiates from other interfaces. + IsUndo_tablespaceContext() +} + +type Undo_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndo_tablespaceContext() *Undo_tablespaceContext { + var p = new(Undo_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace + return p +} + +func InitEmptyUndo_tablespaceContext(p *Undo_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace +} + +func (*Undo_tablespaceContext) IsUndo_tablespaceContext() {} + +func NewUndo_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_tablespaceContext { + var p = new(Undo_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_tablespace + + return p +} + +func (s *Undo_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_tablespaceContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Undo_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Undo_tablespaceContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Undo_tablespaceContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Undo_tablespaceContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Undo_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Undo_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Undo_tablespaceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Undo_tablespaceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Undo_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_tablespace(s) + } +} + +func (s *Undo_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_tablespace(s) + } +} + +func (p *PlSqlParser) Undo_tablespace() (localctx IUndo_tablespaceContext) { + localctx = NewUndo_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1506, PlSqlParserRULE_undo_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(14421) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14424) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14425) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14426) + p.Tablespace() + } + p.SetState(14436) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1888, p.GetParserRuleContext()) == 1 { + { + p.SetState(14427) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14428) + p.File_specification() + } + p.SetState(14433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14429) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14430) + p.File_specification() + } + + p.SetState(14435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_databaseContext is an interface to support dynamic dispatch. +type IDrop_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + BACKUPS() antlr.TerminalNode + NOPROMPT() antlr.TerminalNode + + // IsDrop_databaseContext differentiates from other interfaces. + IsDrop_databaseContext() +} + +type Drop_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_databaseContext() *Drop_databaseContext { + var p = new(Drop_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database + return p +} + +func InitEmptyDrop_databaseContext(p *Drop_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database +} + +func (*Drop_databaseContext) IsDrop_databaseContext() {} + +func NewDrop_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_databaseContext { + var p = new(Drop_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_database + + return p +} + +func (s *Drop_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_databaseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_databaseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_databaseContext) BACKUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUPS, 0) +} + +func (s *Drop_databaseContext) NOPROMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPROMPT, 0) +} + +func (s *Drop_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_database(s) + } +} + +func (s *Drop_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_database(s) + } +} + +func (p *PlSqlParser) Drop_database() (localctx IDrop_databaseContext) { + localctx = NewDrop_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1508, PlSqlParserRULE_drop_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14438) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14439) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(14440) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14441) + p.Match(PlSqlParserBACKUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPROMPT { + { + p.SetState(14444) + p.Match(PlSqlParserNOPROMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_database_linkContext is an interface to support dynamic dispatch. +type ICreate_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Link_name() ILink_nameContext + SHARED() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + AllCONNECT() []antlr.TerminalNode + CONNECT(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllLink_authentication() []ILink_authenticationContext + Link_authentication(i int) ILink_authenticationContext + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + AllCURRENT_USER() []antlr.TerminalNode + CURRENT_USER(i int) antlr.TerminalNode + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPassword_value() []IPassword_valueContext + Password_value(i int) IPassword_valueContext + + // IsCreate_database_linkContext differentiates from other interfaces. + IsCreate_database_linkContext() +} + +type Create_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_database_linkContext() *Create_database_linkContext { + var p = new(Create_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database_link + return p +} + +func InitEmptyCreate_database_linkContext(p *Create_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database_link +} + +func (*Create_database_linkContext) IsCreate_database_linkContext() {} + +func NewCreate_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_linkContext { + var p = new(Create_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_database_link + + return p +} + +func (s *Create_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_database_linkContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Create_database_linkContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Create_database_linkContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Create_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_database_linkContext) AllCONNECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONNECT) +} + +func (s *Create_database_linkContext) CONNECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, i) +} + +func (s *Create_database_linkContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Create_database_linkContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Create_database_linkContext) AllLink_authentication() []ILink_authenticationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILink_authenticationContext); ok { + len++ + } + } + + tst := make([]ILink_authenticationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILink_authenticationContext); ok { + tst[i] = t.(ILink_authenticationContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) Link_authentication(i int) ILink_authenticationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_authenticationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILink_authenticationContext) +} + +func (s *Create_database_linkContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_database_linkContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Create_database_linkContext) AllCURRENT_USER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT_USER) +} + +func (s *Create_database_linkContext) CURRENT_USER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, i) +} + +func (s *Create_database_linkContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Create_database_linkContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Create_database_linkContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Create_database_linkContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Create_database_linkContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Create_database_linkContext) AllPassword_value() []IPassword_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_valueContext); ok { + len++ + } + } + + tst := make([]IPassword_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_valueContext); ok { + tst[i] = t.(IPassword_valueContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) Password_value(i int) IPassword_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Create_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_database_link(s) + } +} + +func (s *Create_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_database_link(s) + } +} + +func (p *PlSqlParser) Create_database_link() (localctx ICreate_database_linkContext) { + localctx = NewCreate_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1510, PlSqlParserRULE_create_database_link) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14447) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARED { + { + p.SetState(14448) + p.Match(PlSqlParserSHARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(14451) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14454) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14455) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14456) + p.Link_name() + } + p.SetState(14472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserAUTHENTICATED || _la == PlSqlParserCONNECT { + p.SetState(14470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + { + p.SetState(14457) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14458) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1894, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14459) + p.Match(PlSqlParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(14460) + p.User_object_name() + } + { + p.SetState(14461) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14462) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14463) + p.Password_value() + } + p.SetState(14465) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1893, p.GetParserRuleContext()) == 1 { + { + p.SetState(14464) + p.Link_authentication() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAUTHENTICATED: + { + p.SetState(14469) + p.Link_authentication() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14475) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14476) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_database_linkContext is an interface to support dynamic dispatch. +type IDrop_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Link_name() ILink_nameContext + PUBLIC() antlr.TerminalNode + + // IsDrop_database_linkContext differentiates from other interfaces. + IsDrop_database_linkContext() +} + +type Drop_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_database_linkContext() *Drop_database_linkContext { + var p = new(Drop_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database_link + return p +} + +func InitEmptyDrop_database_linkContext(p *Drop_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database_link +} + +func (*Drop_database_linkContext) IsDrop_database_linkContext() {} + +func NewDrop_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_linkContext { + var p = new(Drop_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_database_link + + return p +} + +func (s *Drop_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_database_linkContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Drop_database_linkContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Drop_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Drop_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_database_link(s) + } +} + +func (s *Drop_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_database_link(s) + } +} + +func (p *PlSqlParser) Drop_database_link() (localctx IDrop_database_linkContext) { + localctx = NewDrop_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1512, PlSqlParserRULE_drop_database_link) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14479) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(14480) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14483) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14484) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14485) + p.Link_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tablespace_setContext is an interface to support dynamic dispatch. +type IAlter_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + Alter_tablespace_attrs() IAlter_tablespace_attrsContext + Id_expression() IId_expressionContext + + // IsAlter_tablespace_setContext differentiates from other interfaces. + IsAlter_tablespace_setContext() +} + +type Alter_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext +} + +func NewEmptyAlter_tablespace_setContext() *Alter_tablespace_setContext { + var p = new(Alter_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set + return p +} + +func InitEmptyAlter_tablespace_setContext(p *Alter_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set +} + +func (*Alter_tablespace_setContext) IsAlter_tablespace_setContext() {} + +func NewAlter_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_setContext { + var p = new(Alter_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set + + return p +} + +func (s *Alter_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Alter_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Alter_tablespace_setContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_tablespace_setContext) Alter_tablespace_attrs() IAlter_tablespace_attrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_attrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_attrsContext) +} + +func (s *Alter_tablespace_setContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_set(s) + } +} + +func (s *Alter_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_set(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_set() (localctx IAlter_tablespace_setContext) { + localctx = NewAlter_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1514, PlSqlParserRULE_alter_tablespace_set) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14487) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14488) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14489) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14490) + + var _x = p.Id_expression() + + localctx.(*Alter_tablespace_setContext).tss = _x + } + { + p.SetState(14491) + p.Alter_tablespace_attrs() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tablespace_attrsContext is an interface to support dynamic dispatch. +type IAlter_tablespace_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNts returns the nts rule contexts. + GetNts() IId_expressionContext + + // SetNts sets the nts rule contexts. + SetNts(IId_expressionContext) + + // Getter signatures + Default_tablespace_params() IDefault_tablespace_paramsContext + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + RESIZE() antlr.TerminalNode + COALESCE() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + KEEP() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Id_expression() IId_expressionContext + BACKUP() antlr.TerminalNode + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext + Tablespace_logging_clauses() ITablespace_logging_clausesContext + Tablespace_group_clause() ITablespace_group_clauseContext + Tablespace_state_clauses() ITablespace_state_clausesContext + Autoextend_clause() IAutoextend_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + Alter_tablespace_encryption() IAlter_tablespace_encryptionContext + Lost_write_protection() ILost_write_protectionContext + + // IsAlter_tablespace_attrsContext differentiates from other interfaces. + IsAlter_tablespace_attrsContext() +} + +type Alter_tablespace_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nts IId_expressionContext +} + +func NewEmptyAlter_tablespace_attrsContext() *Alter_tablespace_attrsContext { + var p = new(Alter_tablespace_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs + return p +} + +func InitEmptyAlter_tablespace_attrsContext(p *Alter_tablespace_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs +} + +func (*Alter_tablespace_attrsContext) IsAlter_tablespace_attrsContext() {} + +func NewAlter_tablespace_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_attrsContext { + var p = new(Alter_tablespace_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs + + return p +} + +func (s *Alter_tablespace_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_attrsContext) GetNts() IId_expressionContext { return s.nts } + +func (s *Alter_tablespace_attrsContext) SetNts(v IId_expressionContext) { s.nts = v } + +func (s *Alter_tablespace_attrsContext) Default_tablespace_params() IDefault_tablespace_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespace_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespace_paramsContext) +} + +func (s *Alter_tablespace_attrsContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Alter_tablespace_attrsContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Alter_tablespace_attrsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tablespace_attrsContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_tablespace_attrsContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_tablespace_attrsContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Alter_tablespace_attrsContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Alter_tablespace_attrsContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_tablespace_attrsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_tablespace_attrsContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_tablespace_attrsContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_tablespace_attrsContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Alter_tablespace_attrsContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Alter_tablespace_attrsContext) Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_logging_clauses() ITablespace_logging_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_logging_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_logging_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_state_clauses() ITablespace_state_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_state_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_state_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Alter_tablespace_encryption() IAlter_tablespace_encryptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_encryptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_encryptionContext) +} + +func (s *Alter_tablespace_attrsContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Alter_tablespace_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_attrs(s) + } +} + +func (s *Alter_tablespace_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_attrs(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_attrs() (localctx IAlter_tablespace_attrsContext) { + localctx = NewAlter_tablespace_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1516, PlSqlParserRULE_alter_tablespace_attrs) + var _la int + + p.SetState(14520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1900, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14493) + p.Default_tablespace_params() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14494) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14495) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14496) + p.Size_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14497) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14498) + p.Size_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14499) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14500) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14501) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(14502) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14503) + p.Size_clause() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14506) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14507) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14508) + + var _x = p.Id_expression() + + localctx.(*Alter_tablespace_attrsContext).nts = _x + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14509) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBEGIN || _la == PlSqlParserEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14510) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14511) + p.Datafile_tempfile_clauses() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14512) + p.Tablespace_logging_clauses() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14513) + p.Tablespace_group_clause() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14514) + p.Tablespace_state_clauses() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(14515) + p.Autoextend_clause() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(14516) + p.Flashback_mode_clause() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(14517) + p.Tablespace_retention_clause() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(14518) + p.Alter_tablespace_encryption() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(14519) + p.Lost_write_protection() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tablespace_encryptionContext is an interface to support dynamic dispatch. +type IAlter_tablespace_encryptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + FINISH() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + REKEY() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + Ts_file_name_convert() ITs_file_name_convertContext + Tablespace_encryption_spec() ITablespace_encryption_specContext + + // IsAlter_tablespace_encryptionContext differentiates from other interfaces. + IsAlter_tablespace_encryptionContext() +} + +type Alter_tablespace_encryptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tablespace_encryptionContext() *Alter_tablespace_encryptionContext { + var p = new(Alter_tablespace_encryptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption + return p +} + +func InitEmptyAlter_tablespace_encryptionContext(p *Alter_tablespace_encryptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption +} + +func (*Alter_tablespace_encryptionContext) IsAlter_tablespace_encryptionContext() {} + +func NewAlter_tablespace_encryptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_encryptionContext { + var p = new(Alter_tablespace_encryptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption + + return p +} + +func (s *Alter_tablespace_encryptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_encryptionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Alter_tablespace_encryptionContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_tablespace_encryptionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_tablespace_encryptionContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Alter_tablespace_encryptionContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Alter_tablespace_encryptionContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Alter_tablespace_encryptionContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Alter_tablespace_encryptionContext) Ts_file_name_convert() ITs_file_name_convertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITs_file_name_convertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITs_file_name_convertContext) +} + +func (s *Alter_tablespace_encryptionContext) Tablespace_encryption_spec() ITablespace_encryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Alter_tablespace_encryptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_encryptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_encryptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_encryption(s) + } +} + +func (s *Alter_tablespace_encryptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_encryption(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_encryption() (localctx IAlter_tablespace_encryptionContext) { + localctx = NewAlter_tablespace_encryptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1518, PlSqlParserRULE_alter_tablespace_encryption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14522) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOFFLINE: + { + p.SetState(14523) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserUSING: + p.SetState(14525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14524) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(14527) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(14528) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserONLINE: + { + p.SetState(14531) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserREKEY, PlSqlParserUSING: + p.SetState(14533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14532) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(14535) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENCRYPT || _la == PlSqlParserREKEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(14536) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILE_NAME_CONVERT { + { + p.SetState(14539) + p.Ts_file_name_convert() + } + + } + + case PlSqlParserFINISH: + { + p.SetState(14542) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14543) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECRYPT || _la == PlSqlParserENCRYPT || _la == PlSqlParserREKEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILE_NAME_CONVERT { + { + p.SetState(14544) + p.Ts_file_name_convert() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITs_file_name_convertContext is an interface to support dynamic dispatch. +type ITs_file_name_convertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILE_NAME_CONVERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsTs_file_name_convertContext differentiates from other interfaces. + IsTs_file_name_convertContext() +} + +type Ts_file_name_convertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTs_file_name_convertContext() *Ts_file_name_convertContext { + var p = new(Ts_file_name_convertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert + return p +} + +func InitEmptyTs_file_name_convertContext(p *Ts_file_name_convertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert +} + +func (*Ts_file_name_convertContext) IsTs_file_name_convertContext() {} + +func NewTs_file_name_convertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ts_file_name_convertContext { + var p = new(Ts_file_name_convertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert + + return p +} + +func (s *Ts_file_name_convertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ts_file_name_convertContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *Ts_file_name_convertContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Ts_file_name_convertContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Ts_file_name_convertContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Ts_file_name_convertContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Ts_file_name_convertContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ts_file_name_convertContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ts_file_name_convertContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Ts_file_name_convertContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Ts_file_name_convertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ts_file_name_convertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ts_file_name_convertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTs_file_name_convert(s) + } +} + +func (s *Ts_file_name_convertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTs_file_name_convert(s) + } +} + +func (p *PlSqlParser) Ts_file_name_convert() (localctx ITs_file_name_convertContext) { + localctx = NewTs_file_name_convertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1520, PlSqlParserRULE_ts_file_name_convert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14549) + p.Match(PlSqlParserFILE_NAME_CONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14550) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14551) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14552) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14553) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14554) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14555) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14556) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14557) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14558) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(14563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14564) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(14565) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_roleContext is an interface to support dynamic dispatch. +type IAlter_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_name() IRole_nameContext + Role_identified_clause() IRole_identified_clauseContext + Container_clause() IContainer_clauseContext + + // IsAlter_roleContext differentiates from other interfaces. + IsAlter_roleContext() +} + +type Alter_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_roleContext() *Alter_roleContext { + var p = new(Alter_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_role + return p +} + +func InitEmptyAlter_roleContext(p *Alter_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_role +} + +func (*Alter_roleContext) IsAlter_roleContext() {} + +func NewAlter_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_roleContext { + var p = new(Alter_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_role + + return p +} + +func (s *Alter_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Alter_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Alter_roleContext) Role_identified_clause() IRole_identified_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_identified_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_identified_clauseContext) +} + +func (s *Alter_roleContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Alter_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_role(s) + } +} + +func (s *Alter_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_role(s) + } +} + +func (p *PlSqlParser) Alter_role() (localctx IAlter_roleContext) { + localctx = NewAlter_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1522, PlSqlParserRULE_alter_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14568) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14569) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14570) + p.Role_name() + } + { + p.SetState(14571) + p.Role_identified_clause() + } + p.SetState(14573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(14572) + p.Container_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_identified_clauseContext is an interface to support dynamic dispatch. +type IRole_identified_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Identifier() IIdentifierContext + USING() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + AS() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsRole_identified_clauseContext differentiates from other interfaces. + IsRole_identified_clauseContext() +} + +type Role_identified_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_identified_clauseContext() *Role_identified_clauseContext { + var p = new(Role_identified_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_identified_clause + return p +} + +func InitEmptyRole_identified_clauseContext(p *Role_identified_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_identified_clause +} + +func (*Role_identified_clauseContext) IsRole_identified_clauseContext() {} + +func NewRole_identified_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_identified_clauseContext { + var p = new(Role_identified_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_identified_clause + + return p +} + +func (s *Role_identified_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_identified_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Role_identified_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Role_identified_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Role_identified_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Role_identified_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Role_identified_clauseContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Role_identified_clauseContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Role_identified_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Role_identified_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Role_identified_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Role_identified_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Role_identified_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_identified_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_identified_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_identified_clause(s) + } +} + +func (s *Role_identified_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_identified_clause(s) + } +} + +func (p *PlSqlParser) Role_identified_clause() (localctx IRole_identified_clauseContext) { + localctx = NewRole_identified_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1524, PlSqlParserRULE_role_identified_clause) + var _la int + + p.SetState(14594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14575) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14576) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserIDENTIFIED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14577) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBY: + { + p.SetState(14578) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14579) + p.Identifier() + } + + case PlSqlParserUSING: + { + p.SetState(14580) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14581) + p.Identifier() + } + p.SetState(14584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(14582) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14583) + p.Id_expression() + } + + } + + case PlSqlParserEXTERNALLY: + { + p.SetState(14586) + p.Match(PlSqlParserEXTERNALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGLOBALLY: + { + p.SetState(14587) + p.Match(PlSqlParserGLOBALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(14588) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14589) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tableContext is an interface to support dynamic dispatch. +type IAlter_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + Tableview_name() ITableview_nameContext + Alter_table_properties() IAlter_table_propertiesContext + Constraint_clauses() IConstraint_clausesContext + Column_clauses() IColumn_clausesContext + Alter_table_partitioning() IAlter_table_partitioningContext + Move_table_clause() IMove_table_clauseContext + AllMemoptimize_read_write_clause() []IMemoptimize_read_write_clauseContext + Memoptimize_read_write_clause(i int) IMemoptimize_read_write_clauseContext + AllEnable_disable_clause() []IEnable_disable_clauseContext + Enable_disable_clause(i int) IEnable_disable_clauseContext + AllEnable_or_disable() []IEnable_or_disableContext + Enable_or_disable(i int) IEnable_or_disableContext + AllLOCK() []antlr.TerminalNode + LOCK(i int) antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllTRIGGERS() []antlr.TerminalNode + TRIGGERS(i int) antlr.TerminalNode + + // IsAlter_tableContext differentiates from other interfaces. + IsAlter_tableContext() +} + +type Alter_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tableContext() *Alter_tableContext { + var p = new(Alter_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table + return p +} + +func InitEmptyAlter_tableContext(p *Alter_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table +} + +func (*Alter_tableContext) IsAlter_tableContext() {} + +func NewAlter_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tableContext { + var p = new(Alter_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table + + return p +} + +func (s *Alter_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tableContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tableContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLE) +} + +func (s *Alter_tableContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, i) +} + +func (s *Alter_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_tableContext) Alter_table_properties() IAlter_table_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_propertiesContext) +} + +func (s *Alter_tableContext) Constraint_clauses() IConstraint_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_clausesContext) +} + +func (s *Alter_tableContext) Column_clauses() IColumn_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_clausesContext) +} + +func (s *Alter_tableContext) Alter_table_partitioning() IAlter_table_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_partitioningContext) +} + +func (s *Alter_tableContext) Move_table_clause() IMove_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_table_clauseContext) +} + +func (s *Alter_tableContext) AllMemoptimize_read_write_clause() []IMemoptimize_read_write_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + len++ + } + } + + tst := make([]IMemoptimize_read_write_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + tst[i] = t.(IMemoptimize_read_write_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Memoptimize_read_write_clause(i int) IMemoptimize_read_write_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMemoptimize_read_write_clauseContext) +} + +func (s *Alter_tableContext) AllEnable_disable_clause() []IEnable_disable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + len++ + } + } + + tst := make([]IEnable_disable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_disable_clauseContext); ok { + tst[i] = t.(IEnable_disable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Enable_disable_clause(i int) IEnable_disable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_clauseContext) +} + +func (s *Alter_tableContext) AllEnable_or_disable() []IEnable_or_disableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_or_disableContext); ok { + len++ + } + } + + tst := make([]IEnable_or_disableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_or_disableContext); ok { + tst[i] = t.(IEnable_or_disableContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Enable_or_disable(i int) IEnable_or_disableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_tableContext) AllLOCK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOCK) +} + +func (s *Alter_tableContext) LOCK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, i) +} + +func (s *Alter_tableContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Alter_tableContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Alter_tableContext) AllTRIGGERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRIGGERS) +} + +func (s *Alter_tableContext) TRIGGERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, i) +} + +func (s *Alter_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table(s) + } +} + +func (s *Alter_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table(s) + } +} + +func (p *PlSqlParser) Alter_table() (localctx IAlter_tableContext) { + localctx = NewAlter_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1526, PlSqlParserRULE_alter_table) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14596) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14597) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14598) + p.Tableview_name() + } + p.SetState(14602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1915, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14599) + p.Memoptimize_read_write_clause() + } + + } + p.SetState(14604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1915, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1916, p.GetParserRuleContext()) { + case 1: + + case 2: + { + p.SetState(14606) + p.Alter_table_properties() + } + + case 3: + { + p.SetState(14607) + p.Constraint_clauses() + } + + case 4: + { + p.SetState(14608) + p.Column_clauses() + } + + case 5: + { + p.SetState(14609) + p.Alter_table_partitioning() + } + + case 6: + { + p.SetState(14610) + p.Move_table_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + p.SetState(14621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + p.SetState(14621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1918, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14613) + p.Enable_disable_clause() + } + + case 2: + { + p.SetState(14614) + p.Enable_or_disable() + } + p.SetState(14619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(14615) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14616) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(14617) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14618) + p.Match(PlSqlParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMemoptimize_read_write_clauseContext is an interface to support dynamic dispatch. +type IMemoptimize_read_write_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMOPTIMIZE() antlr.TerminalNode + FOR() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsMemoptimize_read_write_clauseContext differentiates from other interfaces. + IsMemoptimize_read_write_clauseContext() +} + +type Memoptimize_read_write_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMemoptimize_read_write_clauseContext() *Memoptimize_read_write_clauseContext { + var p = new(Memoptimize_read_write_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause + return p +} + +func InitEmptyMemoptimize_read_write_clauseContext(p *Memoptimize_read_write_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause +} + +func (*Memoptimize_read_write_clauseContext) IsMemoptimize_read_write_clauseContext() {} + +func NewMemoptimize_read_write_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Memoptimize_read_write_clauseContext { + var p = new(Memoptimize_read_write_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause + + return p +} + +func (s *Memoptimize_read_write_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Memoptimize_read_write_clauseContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Memoptimize_read_write_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Memoptimize_read_write_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Memoptimize_read_write_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Memoptimize_read_write_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Memoptimize_read_write_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Memoptimize_read_write_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Memoptimize_read_write_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMemoptimize_read_write_clause(s) + } +} + +func (s *Memoptimize_read_write_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMemoptimize_read_write_clause(s) + } +} + +func (p *PlSqlParser) Memoptimize_read_write_clause() (localctx IMemoptimize_read_write_clauseContext) { + localctx = NewMemoptimize_read_write_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1528, PlSqlParserRULE_memoptimize_read_write_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(14627) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14630) + p.Match(PlSqlParserMEMOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14631) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14632) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserREAD || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_propertiesContext is an interface to support dynamic dispatch. +type IAlter_table_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_table_properties_1() IAlter_table_properties_1Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Shrink_clause() IShrink_clauseContext + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + REKEY() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + ROW() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + NO() antlr.TerminalNode + Annotations_clause() IAnnotations_clauseContext + + // IsAlter_table_propertiesContext differentiates from other interfaces. + IsAlter_table_propertiesContext() +} + +type Alter_table_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_propertiesContext() *Alter_table_propertiesContext { + var p = new(Alter_table_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties + return p +} + +func InitEmptyAlter_table_propertiesContext(p *Alter_table_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties +} + +func (*Alter_table_propertiesContext) IsAlter_table_propertiesContext() {} + +func NewAlter_table_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_propertiesContext { + var p = new(Alter_table_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_properties + + return p +} + +func (s *Alter_table_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_propertiesContext) Alter_table_properties_1() IAlter_table_properties_1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_properties_1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_properties_1Context) +} + +func (s *Alter_table_propertiesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_table_propertiesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_table_propertiesContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_table_propertiesContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_table_propertiesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Alter_table_propertiesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Alter_table_propertiesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Alter_table_propertiesContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Alter_table_propertiesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Alter_table_propertiesContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Alter_table_propertiesContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Alter_table_propertiesContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Alter_table_propertiesContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Alter_table_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_properties(s) + } +} + +func (s *Alter_table_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_properties(s) + } +} + +func (p *PlSqlParser) Alter_table_properties() (localctx IAlter_table_propertiesContext) { + localctx = NewAlter_table_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1530, PlSqlParserRULE_alter_table_properties) + var _la int + + p.SetState(14651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1923, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14634) + p.Alter_table_properties_1() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14635) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14636) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14637) + p.Tableview_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14638) + p.Shrink_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14639) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14640) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14641) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14642) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14643) + p.Match(PlSqlParserREKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14644) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + p.SetState(14646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(14645) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14648) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14649) + p.Match(PlSqlParserARCHIVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14650) + p.Annotations_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_partitioningContext is an interface to support dynamic dispatch. +type IAlter_table_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_table_partition() IAdd_table_partitionContext + Drop_table_partition() IDrop_table_partitionContext + Merge_table_partition() IMerge_table_partitionContext + Modify_table_partition() IModify_table_partitionContext + Split_table_partition() ISplit_table_partitionContext + Truncate_table_partition() ITruncate_table_partitionContext + Exchange_table_partition() IExchange_table_partitionContext + Coalesce_table_partition() ICoalesce_table_partitionContext + Alter_interval_partition() IAlter_interval_partitionContext + Move_table_partition() IMove_table_partitionContext + Rename_table_partition() IRename_table_partitionContext + + // IsAlter_table_partitioningContext differentiates from other interfaces. + IsAlter_table_partitioningContext() +} + +type Alter_table_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_partitioningContext() *Alter_table_partitioningContext { + var p = new(Alter_table_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning + return p +} + +func InitEmptyAlter_table_partitioningContext(p *Alter_table_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning +} + +func (*Alter_table_partitioningContext) IsAlter_table_partitioningContext() {} + +func NewAlter_table_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_partitioningContext { + var p = new(Alter_table_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning + + return p +} + +func (s *Alter_table_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_partitioningContext) Add_table_partition() IAdd_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Drop_table_partition() IDrop_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Merge_table_partition() IMerge_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Modify_table_partition() IModify_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Split_table_partition() ISplit_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISplit_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISplit_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Truncate_table_partition() ITruncate_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Exchange_table_partition() IExchange_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExchange_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExchange_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Coalesce_table_partition() ICoalesce_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICoalesce_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICoalesce_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Alter_interval_partition() IAlter_interval_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_interval_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_interval_partitionContext) +} + +func (s *Alter_table_partitioningContext) Move_table_partition() IMove_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Rename_table_partition() IRename_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_partitioning(s) + } +} + +func (s *Alter_table_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_partitioning(s) + } +} + +func (p *PlSqlParser) Alter_table_partitioning() (localctx IAlter_table_partitioningContext) { + localctx = NewAlter_table_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1532, PlSqlParserRULE_alter_table_partitioning) + p.SetState(14664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14653) + p.Add_table_partition() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14654) + p.Drop_table_partition() + } + + case PlSqlParserMERGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14655) + p.Merge_table_partition() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14656) + p.Modify_table_partition() + } + + case PlSqlParserSPLIT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14657) + p.Split_table_partition() + } + + case PlSqlParserTRUNCATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14658) + p.Truncate_table_partition() + } + + case PlSqlParserEXCHANGE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14659) + p.Exchange_table_partition() + } + + case PlSqlParserCOALESCE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14660) + p.Coalesce_table_partition() + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14661) + p.Alter_interval_partition() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14662) + p.Move_table_partition() + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14663) + p.Rename_table_partition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_table_partitionContext is an interface to support dynamic dispatch. +type IAdd_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + Range_partition_desc() IRange_partition_descContext + List_partition_desc() IList_partition_descContext + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsAdd_table_partitionContext differentiates from other interfaces. + IsAdd_table_partitionContext() +} + +type Add_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_table_partitionContext() *Add_table_partitionContext { + var p = new(Add_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_table_partition + return p +} + +func InitEmptyAdd_table_partitionContext(p *Add_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_table_partition +} + +func (*Add_table_partitionContext) IsAdd_table_partitionContext() {} + +func NewAdd_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_table_partitionContext { + var p = new(Add_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_table_partition + + return p +} + +func (s *Add_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_table_partitionContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_table_partitionContext) Range_partition_desc() IRange_partition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Add_table_partitionContext) List_partition_desc() IList_partition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Add_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Add_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Add_table_partitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Add_table_partitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Add_table_partitionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Add_table_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Add_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_table_partition(s) + } +} + +func (s *Add_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_table_partition(s) + } +} + +func (p *PlSqlParser) Add_table_partition() (localctx IAdd_table_partitionContext) { + localctx = NewAdd_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1534, PlSqlParserRULE_add_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14666) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1929, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14667) + p.Range_partition_desc() + } + + case 2: + { + p.SetState(14668) + p.List_partition_desc() + } + + case 3: + { + p.SetState(14669) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14671) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1925, p.GetParserRuleContext()) == 1 { + { + p.SetState(14670) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(14673) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14674) + p.Tablespace() + } + + } + p.SetState(14678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(14677) + p.Key_compression() + } + + } + p.SetState(14681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(14680) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_table_partitionContext is an interface to support dynamic dispatch. +type IDrop_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + Subpartition_extended_names() ISubpartition_extended_namesContext + Update_index_clauses() IUpdate_index_clausesContext + Parallel_clause() IParallel_clauseContext + + // IsDrop_table_partitionContext differentiates from other interfaces. + IsDrop_table_partitionContext() +} + +type Drop_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_table_partitionContext() *Drop_table_partitionContext { + var p = new(Drop_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table_partition + return p +} + +func InitEmptyDrop_table_partitionContext(p *Drop_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table_partition +} + +func (*Drop_table_partitionContext) IsDrop_table_partitionContext() {} + +func NewDrop_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_table_partitionContext { + var p = new(Drop_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_table_partition + + return p +} + +func (s *Drop_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Drop_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Drop_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Drop_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Drop_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_table_partition(s) + } +} + +func (s *Drop_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_table_partition(s) + } +} + +func (p *PlSqlParser) Drop_table_partition() (localctx IDrop_table_partitionContext) { + localctx = NewDrop_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1536, PlSqlParserRULE_drop_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14685) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14686) + p.Partition_extended_names() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14687) + p.Subpartition_extended_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE { + { + p.SetState(14690) + p.Update_index_clauses() + } + p.SetState(14692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14691) + p.Parallel_clause() + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_table_partitionContext is an interface to support dynamic dispatch. +type IMerge_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AND() antlr.TerminalNode + INTO() antlr.TerminalNode + + // IsMerge_table_partitionContext differentiates from other interfaces. + IsMerge_table_partitionContext() +} + +type Merge_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_table_partitionContext() *Merge_table_partitionContext { + var p = new(Merge_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_table_partition + return p +} + +func InitEmptyMerge_table_partitionContext(p *Merge_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_table_partition +} + +func (*Merge_table_partitionContext) IsMerge_table_partitionContext() {} + +func NewMerge_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_table_partitionContext { + var p = new(Merge_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_table_partition + + return p +} + +func (s *Merge_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_table_partitionContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_table_partitionContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Merge_table_partitionContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Merge_table_partitionContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Merge_table_partitionContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Merge_table_partitionContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Merge_table_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_table_partition(s) + } +} + +func (s *Merge_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_table_partition(s) + } +} + +func (p *PlSqlParser) Merge_table_partition() (localctx IMerge_table_partitionContext) { + localctx = NewMerge_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1538, PlSqlParserRULE_merge_table_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14696) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14697) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14698) + p.Partition_name() + } + { + p.SetState(14699) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14700) + p.Partition_name() + } + { + p.SetState(14701) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14702) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14703) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_table_partitionContext is an interface to support dynamic dispatch. +type IModify_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + Partition_name() IPartition_nameContext + Range_partitions() IRange_partitionsContext + PARTITION() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + List_values_clause() IList_values_clauseContext + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + Range_subpartition_desc() IRange_subpartition_descContext + UNUSABLE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + INDEXES() antlr.TerminalNode + Shrink_clause() IShrink_clauseContext + DROP() antlr.TerminalNode + REBUILD() antlr.TerminalNode + + // IsModify_table_partitionContext differentiates from other interfaces. + IsModify_table_partitionContext() +} + +type Modify_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_table_partitionContext() *Modify_table_partitionContext { + var p = new(Modify_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_table_partition + return p +} + +func InitEmptyModify_table_partitionContext(p *Modify_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_table_partition +} + +func (*Modify_table_partitionContext) IsModify_table_partitionContext() {} + +func NewModify_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_table_partitionContext { + var p = new(Modify_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_table_partition + + return p +} + +func (s *Modify_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_table_partitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_table_partitionContext) Range_partitions() IRange_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_partitionsContext) +} + +func (s *Modify_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_table_partitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Modify_table_partitionContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *Modify_table_partitionContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserADD) +} + +func (s *Modify_table_partitionContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, i) +} + +func (s *Modify_table_partitionContext) Range_subpartition_desc() IRange_subpartition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Modify_table_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_table_partitionContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Modify_table_partitionContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Modify_table_partitionContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Modify_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Modify_table_partitionContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Modify_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_table_partition(s) + } +} + +func (s *Modify_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_table_partition(s) + } +} + +func (p *PlSqlParser) Modify_table_partition() (localctx IModify_table_partitionContext) { + localctx = NewModify_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1540, PlSqlParserRULE_modify_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14705) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1938, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14706) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14707) + p.Partition_name() + } + p.SetState(14710) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1933, p.GetParserRuleContext()) == 1 { + { + p.SetState(14708) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14709) + p.List_values_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(14712) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14713) + p.Range_subpartition_desc() + } + + } + p.SetState(14722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREBUILD || _la == PlSqlParserUNUSABLE { + p.SetState(14717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREBUILD { + { + p.SetState(14716) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14719) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14720) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14721) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHRINK { + { + p.SetState(14724) + p.Shrink_clause() + } + + } + + case 2: + { + p.SetState(14727) + p.Range_partitions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISplit_table_partitionContext is an interface to support dynamic dispatch. +type ISplit_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SPLIT() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + AT() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + AllRange_partition_desc() []IRange_partition_descContext + Range_partition_desc(i int) IRange_partition_descContext + Update_global_index_clause() IUpdate_global_index_clauseContext + Update_index_clauses() IUpdate_index_clausesContext + ONLINE() antlr.TerminalNode + AllList_partition_desc() []IList_partition_descContext + List_partition_desc(i int) IList_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSplit_table_partitionContext differentiates from other interfaces. + IsSplit_table_partitionContext() +} + +type Split_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySplit_table_partitionContext() *Split_table_partitionContext { + var p = new(Split_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_table_partition + return p +} + +func InitEmptySplit_table_partitionContext(p *Split_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_table_partition +} + +func (*Split_table_partitionContext) IsSplit_table_partitionContext() {} + +func NewSplit_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Split_table_partitionContext { + var p = new(Split_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_split_table_partition + + return p +} + +func (s *Split_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Split_table_partitionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Split_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Split_table_partitionContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Split_table_partitionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Split_table_partitionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Split_table_partitionContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Split_table_partitionContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Split_table_partitionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Split_table_partitionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Split_table_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Split_table_partitionContext) AllRange_partition_desc() []IRange_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_partition_descContext); ok { + len++ + } + } + + tst := make([]IRange_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_partition_descContext); ok { + tst[i] = t.(IRange_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Split_table_partitionContext) Range_partition_desc(i int) IRange_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Split_table_partitionContext) Update_global_index_clause() IUpdate_global_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_global_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_global_index_clauseContext) +} + +func (s *Split_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Split_table_partitionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Split_table_partitionContext) AllList_partition_desc() []IList_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_partition_descContext); ok { + len++ + } + } + + tst := make([]IList_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_partition_descContext); ok { + tst[i] = t.(IList_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Split_table_partitionContext) List_partition_desc(i int) IList_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Split_table_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Split_table_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Split_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Split_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Split_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSplit_table_partition(s) + } +} + +func (s *Split_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSplit_table_partition(s) + } +} + +func (p *PlSqlParser) Split_table_partition() (localctx ISplit_table_partitionContext) { + localctx = NewSplit_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1542, PlSqlParserRULE_split_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14730) + p.Match(PlSqlParserSPLIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14731) + p.Partition_extended_names() + } + p.SetState(14777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAT: + { + p.SetState(14732) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14733) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14734) + p.Literal() + } + p.SetState(14739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14735) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14736) + p.Literal() + } + + p.SetState(14741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14742) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14743) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14744) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14745) + p.Range_partition_desc() + } + p.SetState(14750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14746) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14747) + p.Range_partition_desc() + } + + p.SetState(14752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14753) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINTO: + { + p.SetState(14755) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14756) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1943, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14757) + p.Range_partition_desc() + } + p.SetState(14762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14758) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14759) + p.Range_partition_desc() + } + + p.SetState(14764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(14765) + p.List_partition_desc() + } + p.SetState(14770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14766) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14767) + p.List_partition_desc() + } + + p.SetState(14772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14775) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14782) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1945, p.GetParserRuleContext()) == 1 { + { + p.SetState(14779) + p.Update_global_index_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1945, p.GetParserRuleContext()) == 2 { + { + p.SetState(14780) + p.Update_index_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1945, p.GetParserRuleContext()) == 3 { + { + p.SetState(14781) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_table_partitionContext is an interface to support dynamic dispatch. +type ITruncate_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + Subpartition_extended_names() ISubpartition_extended_namesContext + STORAGE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + Update_index_clauses() IUpdate_index_clausesContext + DROP() antlr.TerminalNode + REUSE() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + ALL() antlr.TerminalNode + + // IsTruncate_table_partitionContext differentiates from other interfaces. + IsTruncate_table_partitionContext() +} + +type Truncate_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_table_partitionContext() *Truncate_table_partitionContext { + var p = new(Truncate_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table_partition + return p +} + +func InitEmptyTruncate_table_partitionContext(p *Truncate_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table_partition +} + +func (*Truncate_table_partitionContext) IsTruncate_table_partitionContext() {} + +func NewTruncate_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_table_partitionContext { + var p = new(Truncate_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_truncate_table_partition + + return p +} + +func (s *Truncate_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_table_partitionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Truncate_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Truncate_table_partitionContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Truncate_table_partitionContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Truncate_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Truncate_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Truncate_table_partitionContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Truncate_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Truncate_table_partitionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Truncate_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTruncate_table_partition(s) + } +} + +func (s *Truncate_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_table_partition(s) + } +} + +func (p *PlSqlParser) Truncate_table_partition() (localctx ITruncate_table_partitionContext) { + localctx = NewTruncate_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1544, PlSqlParserRULE_truncate_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14784) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14787) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14785) + p.Partition_extended_names() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14786) + p.Subpartition_extended_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserREUSE || _la == PlSqlParserSTORAGE { + p.SetState(14794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDROP: + { + p.SetState(14789) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(14790) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserREUSE: + { + p.SetState(14793) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTORAGE: + + default: + } + { + p.SetState(14796) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(14799) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE { + { + p.SetState(14802) + p.Update_index_clauses() + } + p.SetState(14804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14803) + p.Parallel_clause() + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExchange_table_partitionContext is an interface to support dynamic dispatch. +type IExchange_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCHANGE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + INDEXES() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsExchange_table_partitionContext differentiates from other interfaces. + IsExchange_table_partitionContext() +} + +type Exchange_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExchange_table_partitionContext() *Exchange_table_partitionContext { + var p = new(Exchange_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exchange_table_partition + return p +} + +func InitEmptyExchange_table_partitionContext(p *Exchange_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exchange_table_partition +} + +func (*Exchange_table_partitionContext) IsExchange_table_partitionContext() {} + +func NewExchange_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exchange_table_partitionContext { + var p = new(Exchange_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exchange_table_partition + + return p +} + +func (s *Exchange_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exchange_table_partitionContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Exchange_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Exchange_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Exchange_table_partitionContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Exchange_table_partitionContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Exchange_table_partitionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Exchange_table_partitionContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Exchange_table_partitionContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Exchange_table_partitionContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATION, 0) +} + +func (s *Exchange_table_partitionContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Exchange_table_partitionContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Exchange_table_partitionContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Exchange_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exchange_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exchange_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExchange_table_partition(s) + } +} + +func (s *Exchange_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExchange_table_partition(s) + } +} + +func (p *PlSqlParser) Exchange_table_partition() (localctx IExchange_table_partitionContext) { + localctx = NewExchange_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1546, PlSqlParserRULE_exchange_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14808) + p.Match(PlSqlParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14809) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14810) + p.Partition_name() + } + { + p.SetState(14811) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14812) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14813) + p.Tableview_name() + } + p.SetState(14816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING { + { + p.SetState(14814) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14815) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(14818) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14819) + p.Match(PlSqlParserVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICoalesce_table_partitionContext is an interface to support dynamic dispatch. +type ICoalesce_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COALESCE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + Allow_or_disallow() IAllow_or_disallowContext + CLUSTERING() antlr.TerminalNode + + // IsCoalesce_table_partitionContext differentiates from other interfaces. + IsCoalesce_table_partitionContext() +} + +type Coalesce_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCoalesce_table_partitionContext() *Coalesce_table_partitionContext { + var p = new(Coalesce_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition + return p +} + +func InitEmptyCoalesce_table_partitionContext(p *Coalesce_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition +} + +func (*Coalesce_table_partitionContext) IsCoalesce_table_partitionContext() {} + +func NewCoalesce_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Coalesce_table_partitionContext { + var p = new(Coalesce_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition + + return p +} + +func (s *Coalesce_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Coalesce_table_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Coalesce_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Coalesce_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Coalesce_table_partitionContext) Allow_or_disallow() IAllow_or_disallowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Coalesce_table_partitionContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Coalesce_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Coalesce_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Coalesce_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCoalesce_table_partition(s) + } +} + +func (s *Coalesce_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCoalesce_table_partition(s) + } +} + +func (p *PlSqlParser) Coalesce_table_partition() (localctx ICoalesce_table_partitionContext) { + localctx = NewCoalesce_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1548, PlSqlParserRULE_coalesce_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14822) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14823) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14824) + p.Parallel_clause() + } + + } + p.SetState(14830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(14827) + p.Allow_or_disallow() + } + { + p.SetState(14828) + p.Match(PlSqlParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_interval_partitionContext is an interface to support dynamic dispatch. +type IAlter_interval_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Constant() IConstantContext + Expression() IExpressionContext + + // IsAlter_interval_partitionContext differentiates from other interfaces. + IsAlter_interval_partitionContext() +} + +type Alter_interval_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_interval_partitionContext() *Alter_interval_partitionContext { + var p = new(Alter_interval_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_interval_partition + return p +} + +func InitEmptyAlter_interval_partitionContext(p *Alter_interval_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_interval_partition +} + +func (*Alter_interval_partitionContext) IsAlter_interval_partitionContext() {} + +func NewAlter_interval_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_interval_partitionContext { + var p = new(Alter_interval_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_interval_partition + + return p +} + +func (s *Alter_interval_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_interval_partitionContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_interval_partitionContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Alter_interval_partitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_interval_partitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_interval_partitionContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Alter_interval_partitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_interval_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_interval_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_interval_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_interval_partition(s) + } +} + +func (s *Alter_interval_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_interval_partition(s) + } +} + +func (p *PlSqlParser) Alter_interval_partition() (localctx IAlter_interval_partitionContext) { + localctx = NewAlter_interval_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1550, PlSqlParserRULE_alter_interval_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14832) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14833) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14834) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14837) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1957, p.GetParserRuleContext()) == 1 { + { + p.SetState(14835) + p.Constant() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1957, p.GetParserRuleContext()) == 2 { + { + p.SetState(14836) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14839) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_table_partitionContext is an interface to support dynamic dispatch. +type IMove_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + Table_partition_description() ITable_partition_descriptionContext + Subpartition_extended_names() ISubpartition_extended_namesContext + AllFilter_condition() []IFilter_conditionContext + Filter_condition(i int) IFilter_conditionContext + AllUpdate_index_clauses() []IUpdate_index_clausesContext + Update_index_clauses(i int) IUpdate_index_clausesContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllAllow_or_disallow() []IAllow_or_disallowContext + Allow_or_disallow(i int) IAllow_or_disallowContext + AllCLUSTERING() []antlr.TerminalNode + CLUSTERING(i int) antlr.TerminalNode + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + MAPPING() antlr.TerminalNode + TABLE() antlr.TerminalNode + Indexing_clause() IIndexing_clauseContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsMove_table_partitionContext differentiates from other interfaces. + IsMove_table_partitionContext() +} + +type Move_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_table_partitionContext() *Move_table_partitionContext { + var p = new(Move_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_partition + return p +} + +func InitEmptyMove_table_partitionContext(p *Move_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_partition +} + +func (*Move_table_partitionContext) IsMove_table_partitionContext() {} + +func NewMove_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_table_partitionContext { + var p = new(Move_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_table_partition + + return p +} + +func (s *Move_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_table_partitionContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Move_table_partitionContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Move_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Move_table_partitionContext) AllFilter_condition() []IFilter_conditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilter_conditionContext); ok { + len++ + } + } + + tst := make([]IFilter_conditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilter_conditionContext); ok { + tst[i] = t.(IFilter_conditionContext) + i++ + } + } + + return tst +} + +func (s *Move_table_partitionContext) Filter_condition(i int) IFilter_conditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilter_conditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilter_conditionContext) +} + +func (s *Move_table_partitionContext) AllUpdate_index_clauses() []IUpdate_index_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + len++ + } + } + + tst := make([]IUpdate_index_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_index_clausesContext); ok { + tst[i] = t.(IUpdate_index_clausesContext) + i++ + } + } + + return tst +} + +func (s *Move_table_partitionContext) Update_index_clauses(i int) IUpdate_index_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Move_table_partitionContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Move_table_partitionContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Move_table_partitionContext) AllAllow_or_disallow() []IAllow_or_disallowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + len++ + } + } + + tst := make([]IAllow_or_disallowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllow_or_disallowContext); ok { + tst[i] = t.(IAllow_or_disallowContext) + i++ + } + } + + return tst +} + +func (s *Move_table_partitionContext) Allow_or_disallow(i int) IAllow_or_disallowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Move_table_partitionContext) AllCLUSTERING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCLUSTERING) +} + +func (s *Move_table_partitionContext) CLUSTERING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, i) +} + +func (s *Move_table_partitionContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Move_table_partitionContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Move_table_partitionContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Move_table_partitionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Move_table_partitionContext) Indexing_clause() IIndexing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexing_clauseContext) +} + +func (s *Move_table_partitionContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Move_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_table_partition(s) + } +} + +func (s *Move_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_table_partition(s) + } +} + +func (p *PlSqlParser) Move_table_partition() (localctx IMove_table_partitionContext) { + localctx = NewMove_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1552, PlSqlParserRULE_move_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14841) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14842) + p.Partition_extended_names() + } + p.SetState(14845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMAPPING { + { + p.SetState(14843) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14844) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14847) + p.Table_partition_description() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14849) + p.Subpartition_extended_names() + } + p.SetState(14851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXING { + { + p.SetState(14850) + p.Indexing_clause() + } + + } + p.SetState(14854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINMEMORY || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserROW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(14853) + p.Partitioning_storage_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW || _la == PlSqlParserINCLUDING || _la == PlSqlParserINVALIDATE || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserONLINE || _la == PlSqlParserPARALLEL || _la == PlSqlParserUPDATE { + p.SetState(14865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINCLUDING: + { + p.SetState(14858) + p.Filter_condition() + } + + case PlSqlParserINVALIDATE, PlSqlParserUPDATE: + { + p.SetState(14859) + p.Update_index_clauses() + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(14860) + p.Parallel_clause() + } + + case PlSqlParserALLOW, PlSqlParserDISALLOW: + { + p.SetState(14861) + p.Allow_or_disallow() + } + { + p.SetState(14862) + p.Match(PlSqlParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserONLINE: + { + p.SetState(14864) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilter_conditionContext is an interface to support dynamic dispatch. +type IFilter_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDING() antlr.TerminalNode + ROWS() antlr.TerminalNode + Where_clause() IWhere_clauseContext + + // IsFilter_conditionContext differentiates from other interfaces. + IsFilter_conditionContext() +} + +type Filter_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilter_conditionContext() *Filter_conditionContext { + var p = new(Filter_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_condition + return p +} + +func InitEmptyFilter_conditionContext(p *Filter_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_condition +} + +func (*Filter_conditionContext) IsFilter_conditionContext() {} + +func NewFilter_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_conditionContext { + var p = new(Filter_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filter_condition + + return p +} + +func (s *Filter_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filter_conditionContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Filter_conditionContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Filter_conditionContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Filter_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filter_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filter_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilter_condition(s) + } +} + +func (s *Filter_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilter_condition(s) + } +} + +func (p *PlSqlParser) Filter_condition() (localctx IFilter_conditionContext) { + localctx = NewFilter_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1554, PlSqlParserRULE_filter_condition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14870) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14871) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14872) + p.Where_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_table_partitionContext is an interface to support dynamic dispatch. +type IRename_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Partition_name() IPartition_nameContext + Partition_extended_names() IPartition_extended_namesContext + Subpartition_extended_names() ISubpartition_extended_namesContext + + // IsRename_table_partitionContext differentiates from other interfaces. + IsRename_table_partitionContext() +} + +type Rename_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_table_partitionContext() *Rename_table_partitionContext { + var p = new(Rename_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_table_partition + return p +} + +func InitEmptyRename_table_partitionContext(p *Rename_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_table_partition +} + +func (*Rename_table_partitionContext) IsRename_table_partitionContext() {} + +func NewRename_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_table_partitionContext { + var p = new(Rename_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_table_partition + + return p +} + +func (s *Rename_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_table_partitionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_table_partitionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Rename_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Rename_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Rename_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_table_partition(s) + } +} + +func (s *Rename_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_table_partition(s) + } +} + +func (p *PlSqlParser) Rename_table_partition() (localctx IRename_table_partitionContext) { + localctx = NewRename_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1556, PlSqlParserRULE_rename_table_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14874) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14875) + p.Partition_extended_names() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14876) + p.Subpartition_extended_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(14879) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14880) + p.Partition_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_extended_namesContext is an interface to support dynamic dispatch. +type IPartition_extended_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllPartition_key_value() []IPartition_key_valueContext + Partition_key_value(i int) IPartition_key_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartition_extended_namesContext differentiates from other interfaces. + IsPartition_extended_namesContext() +} + +type Partition_extended_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extended_namesContext() *Partition_extended_namesContext { + var p = new(Partition_extended_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extended_names + return p +} + +func InitEmptyPartition_extended_namesContext(p *Partition_extended_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extended_names +} + +func (*Partition_extended_namesContext) IsPartition_extended_namesContext() {} + +func NewPartition_extended_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extended_namesContext { + var p = new(Partition_extended_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extended_names + + return p +} + +func (s *Partition_extended_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extended_namesContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extended_namesContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Partition_extended_namesContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Partition_extended_namesContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_extended_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extended_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extended_namesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extended_namesContext) AllPartition_key_value() []IPartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_key_valueContext); ok { + len++ + } + } + + tst := make([]IPartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_key_valueContext); ok { + tst[i] = t.(IPartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extended_namesContext) Partition_key_value(i int) IPartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_key_valueContext) +} + +func (s *Partition_extended_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partition_extended_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partition_extended_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extended_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extended_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extended_names(s) + } +} + +func (s *Partition_extended_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extended_names(s) + } +} + +func (p *PlSqlParser) Partition_extended_names() (localctx IPartition_extended_namesContext) { + localctx = NewPartition_extended_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1558, PlSqlParserRULE_partition_extended_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14882) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPARTITION || _la == PlSqlParserPARTITIONS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(14883) + p.Partition_name() + } + p.SetState(14888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14884) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14885) + p.Partition_name() + } + + p.SetState(14890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14891) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14892) + p.Partition_name() + } + p.SetState(14897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14893) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14894) + p.Partition_name() + } + + p.SetState(14899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14900) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(14902) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14903) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14906) + p.Partition_key_value() + } + p.SetState(14911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14907) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14908) + p.Partition_key_value() + } + + p.SetState(14913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(14914) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_extended_namesContext is an interface to support dynamic dispatch. +type ISubpartition_extended_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllSubpartition_key_value() []ISubpartition_key_valueContext + Subpartition_key_value(i int) ISubpartition_key_valueContext + UPDATE() antlr.TerminalNode + INDEXES() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSubpartition_extended_namesContext differentiates from other interfaces. + IsSubpartition_extended_namesContext() +} + +type Subpartition_extended_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_extended_namesContext() *Subpartition_extended_namesContext { + var p = new(Subpartition_extended_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names + return p +} + +func InitEmptySubpartition_extended_namesContext(p *Subpartition_extended_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names +} + +func (*Subpartition_extended_namesContext) IsSubpartition_extended_namesContext() {} + +func NewSubpartition_extended_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_extended_namesContext { + var p = new(Subpartition_extended_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names + + return p +} + +func (s *Subpartition_extended_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_extended_namesContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_extended_namesContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Subpartition_extended_namesContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_extended_namesContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Subpartition_extended_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_extended_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_extended_namesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Subpartition_extended_namesContext) AllSubpartition_key_value() []ISubpartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + len++ + } + } + + tst := make([]ISubpartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartition_key_valueContext); ok { + tst[i] = t.(ISubpartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_extended_namesContext) Subpartition_key_value(i int) ISubpartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_key_valueContext) +} + +func (s *Subpartition_extended_namesContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Subpartition_extended_namesContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Subpartition_extended_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_extended_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_extended_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_extended_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_extended_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_extended_names(s) + } +} + +func (s *Subpartition_extended_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_extended_names(s) + } +} + +func (p *PlSqlParser) Subpartition_extended_names() (localctx ISubpartition_extended_namesContext) { + localctx = NewSubpartition_extended_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1560, PlSqlParserRULE_subpartition_extended_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14919) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserSUBPARTITION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(14920) + p.Partition_name() + } + p.SetState(14923) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1971, p.GetParserRuleContext()) == 1 { + { + p.SetState(14921) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14922) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14925) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14926) + p.Partition_name() + } + p.SetState(14931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14927) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14928) + p.Partition_name() + } + + p.SetState(14933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14934) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(14936) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14937) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14940) + p.Subpartition_key_value() + } + p.SetState(14945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14941) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14942) + p.Subpartition_key_value() + } + + p.SetState(14947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(14948) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_properties_1Context is an interface to support dynamic dispatch. +type IAlter_table_properties_1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllInmemory_table_clause() []IInmemory_table_clauseContext + Inmemory_table_clause(i int) IInmemory_table_clauseContext + AllSupplemental_table_logging() []ISupplemental_table_loggingContext + Supplemental_table_logging(i int) ISupplemental_table_loggingContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllRESULT_CACHE() []antlr.TerminalNode + RESULT_CACHE(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllMODE() []antlr.TerminalNode + MODE(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllUpgrade_table_clause() []IUpgrade_table_clauseContext + Upgrade_table_clause(i int) IUpgrade_table_clauseContext + AllRecords_per_block_clause() []IRecords_per_block_clauseContext + Records_per_block_clause(i int) IRecords_per_block_clauseContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllRow_movement_clause() []IRow_movement_clauseContext + Row_movement_clause(i int) IRow_movement_clauseContext + AllLogical_replication_clause() []ILogical_replication_clauseContext + Logical_replication_clause(i int) ILogical_replication_clauseContext + AllFlashback_archive_clause() []IFlashback_archive_clauseContext + Flashback_archive_clause(i int) IFlashback_archive_clauseContext + Alter_iot_clauses() IAlter_iot_clausesContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + + // IsAlter_table_properties_1Context differentiates from other interfaces. + IsAlter_table_properties_1Context() +} + +type Alter_table_properties_1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_properties_1Context() *Alter_table_properties_1Context { + var p = new(Alter_table_properties_1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 + return p +} + +func InitEmptyAlter_table_properties_1Context(p *Alter_table_properties_1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 +} + +func (*Alter_table_properties_1Context) IsAlter_table_properties_1Context() {} + +func NewAlter_table_properties_1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_properties_1Context { + var p = new(Alter_table_properties_1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 + + return p +} + +func (s *Alter_table_properties_1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_properties_1Context) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_table_properties_1Context) AllInmemory_table_clause() []IInmemory_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + len++ + } + } + + tst := make([]IInmemory_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_table_clauseContext); ok { + tst[i] = t.(IInmemory_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Inmemory_table_clause(i int) IInmemory_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllSupplemental_table_logging() []ISupplemental_table_loggingContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_table_loggingContext); ok { + len++ + } + } + + tst := make([]ISupplemental_table_loggingContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_table_loggingContext); ok { + tst[i] = t.(ISupplemental_table_loggingContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Supplemental_table_logging(i int) ISupplemental_table_loggingContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_table_loggingContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_table_loggingContext) +} + +func (s *Alter_table_properties_1Context) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRESULT_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRESULT_CACHE) +} + +func (s *Alter_table_properties_1Context) RESULT_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, i) +} + +func (s *Alter_table_properties_1Context) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_table_properties_1Context) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_table_properties_1Context) AllMODE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMODE) +} + +func (s *Alter_table_properties_1Context) MODE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMODE, i) +} + +func (s *Alter_table_properties_1Context) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_table_properties_1Context) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_table_properties_1Context) AllUpgrade_table_clause() []IUpgrade_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpgrade_table_clauseContext); ok { + len++ + } + } + + tst := make([]IUpgrade_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpgrade_table_clauseContext); ok { + tst[i] = t.(IUpgrade_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Upgrade_table_clause(i int) IUpgrade_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpgrade_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpgrade_table_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRecords_per_block_clause() []IRecords_per_block_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRecords_per_block_clauseContext); ok { + len++ + } + } + + tst := make([]IRecords_per_block_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRecords_per_block_clauseContext); ok { + tst[i] = t.(IRecords_per_block_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Records_per_block_clause(i int) IRecords_per_block_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecords_per_block_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRecords_per_block_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRow_movement_clause() []IRow_movement_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + len++ + } + } + + tst := make([]IRow_movement_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRow_movement_clauseContext); ok { + tst[i] = t.(IRow_movement_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Row_movement_clause(i int) IRow_movement_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRow_movement_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllLogical_replication_clause() []ILogical_replication_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogical_replication_clauseContext); ok { + len++ + } + } + + tst := make([]ILogical_replication_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogical_replication_clauseContext); ok { + tst[i] = t.(ILogical_replication_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Logical_replication_clause(i int) ILogical_replication_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_replication_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogical_replication_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllFlashback_archive_clause() []IFlashback_archive_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_archive_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_archive_clauseContext); ok { + tst[i] = t.(IFlashback_archive_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Flashback_archive_clause(i int) IFlashback_archive_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_clauseContext) +} + +func (s *Alter_table_properties_1Context) Alter_iot_clauses() IAlter_iot_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_iot_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_iot_clausesContext) +} + +func (s *Alter_table_properties_1Context) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Alter_table_properties_1Context) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Alter_table_properties_1Context) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Alter_table_properties_1Context) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Alter_table_properties_1Context) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Alter_table_properties_1Context) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Alter_table_properties_1Context) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Alter_table_properties_1Context) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Alter_table_properties_1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_properties_1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_properties_1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_properties_1(s) + } +} + +func (s *Alter_table_properties_1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_properties_1(s) + } +} + +func (p *PlSqlParser) Alter_table_properties_1() (localctx IAlter_table_properties_1Context) { + localctx = NewAlter_table_properties_1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1562, PlSqlParserRULE_alter_table_properties_1) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1977, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14953) + p.Physical_attributes_clause() + } + + case 2: + { + p.SetState(14954) + p.Logging_clause() + } + + case 3: + { + p.SetState(14955) + p.Table_compression() + } + + case 4: + { + p.SetState(14956) + p.Inmemory_table_clause() + } + + case 5: + { + p.SetState(14957) + p.Supplemental_table_logging() + } + + case 6: + { + p.SetState(14958) + p.Allocate_extent_clause() + } + + case 7: + { + p.SetState(14959) + p.Deallocate_unused_clause() + } + + case 8: + { + p.SetState(14960) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 9: + { + p.SetState(14961) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14962) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14963) + p.Match(PlSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14964) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14965) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + { + p.SetState(14966) + p.Upgrade_table_clause() + } + + case 11: + { + p.SetState(14967) + p.Records_per_block_clause() + } + + case 12: + { + p.SetState(14968) + p.Parallel_clause() + } + + case 13: + { + p.SetState(14969) + p.Row_movement_clause() + } + + case 14: + { + p.SetState(14970) + p.Logical_replication_clause() + } + + case 15: + { + p.SetState(14971) + p.Flashback_archive_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14974) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1978, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD || _la == PlSqlParserCOALESCE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(14976) + p.Alter_iot_clauses() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_iot_clausesContext is an interface to support dynamic dispatch. +type IAlter_iot_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_org_table_clause() IIndex_org_table_clauseContext + Alter_overflow_clause() IAlter_overflow_clauseContext + Alter_mapping_table_clause() IAlter_mapping_table_clauseContext + COALESCE() antlr.TerminalNode + + // IsAlter_iot_clausesContext differentiates from other interfaces. + IsAlter_iot_clausesContext() +} + +type Alter_iot_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_iot_clausesContext() *Alter_iot_clausesContext { + var p = new(Alter_iot_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses + return p +} + +func InitEmptyAlter_iot_clausesContext(p *Alter_iot_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses +} + +func (*Alter_iot_clausesContext) IsAlter_iot_clausesContext() {} + +func NewAlter_iot_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_iot_clausesContext { + var p = new(Alter_iot_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses + + return p +} + +func (s *Alter_iot_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_iot_clausesContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Alter_iot_clausesContext) Alter_overflow_clause() IAlter_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_overflow_clauseContext) +} + +func (s *Alter_iot_clausesContext) Alter_mapping_table_clause() IAlter_mapping_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mapping_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mapping_table_clauseContext) +} + +func (s *Alter_iot_clausesContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_iot_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_iot_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_iot_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_iot_clauses(s) + } +} + +func (s *Alter_iot_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_iot_clauses(s) + } +} + +func (p *PlSqlParser) Alter_iot_clauses() (localctx IAlter_iot_clausesContext) { + localctx = NewAlter_iot_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1564, PlSqlParserRULE_alter_iot_clauses) + p.SetState(14983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1980, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14979) + p.Index_org_table_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14980) + p.Alter_overflow_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14981) + p.Alter_mapping_table_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14982) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_mapping_table_clauseContext is an interface to support dynamic dispatch. +type IAlter_mapping_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAPPING() antlr.TerminalNode + TABLE() antlr.TerminalNode + Allocate_extent_clause() IAllocate_extent_clauseContext + Deallocate_unused_clause() IDeallocate_unused_clauseContext + + // IsAlter_mapping_table_clauseContext differentiates from other interfaces. + IsAlter_mapping_table_clauseContext() +} + +type Alter_mapping_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mapping_table_clauseContext() *Alter_mapping_table_clauseContext { + var p = new(Alter_mapping_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause + return p +} + +func InitEmptyAlter_mapping_table_clauseContext(p *Alter_mapping_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause +} + +func (*Alter_mapping_table_clauseContext) IsAlter_mapping_table_clauseContext() {} + +func NewAlter_mapping_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mapping_table_clauseContext { + var p = new(Alter_mapping_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause + + return p +} + +func (s *Alter_mapping_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mapping_table_clauseContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Alter_mapping_table_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Alter_mapping_table_clauseContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_mapping_table_clauseContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_mapping_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mapping_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mapping_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mapping_table_clause(s) + } +} + +func (s *Alter_mapping_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mapping_table_clause(s) + } +} + +func (p *PlSqlParser) Alter_mapping_table_clause() (localctx IAlter_mapping_table_clauseContext) { + localctx = NewAlter_mapping_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1566, PlSqlParserRULE_alter_mapping_table_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14985) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14986) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE: + { + p.SetState(14987) + p.Allocate_extent_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(14988) + p.Deallocate_unused_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_overflow_clauseContext is an interface to support dynamic dispatch. +type IAlter_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_overflow_clause() IAdd_overflow_clauseContext + OVERFLOW_() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + + // IsAlter_overflow_clauseContext differentiates from other interfaces. + IsAlter_overflow_clauseContext() +} + +type Alter_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_overflow_clauseContext() *Alter_overflow_clauseContext { + var p = new(Alter_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause + return p +} + +func InitEmptyAlter_overflow_clauseContext(p *Alter_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause +} + +func (*Alter_overflow_clauseContext) IsAlter_overflow_clauseContext() {} + +func NewAlter_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_overflow_clauseContext { + var p = new(Alter_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause + + return p +} + +func (s *Alter_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_overflow_clauseContext) Add_overflow_clause() IAdd_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_overflow_clauseContext) +} + +func (s *Alter_overflow_clauseContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Alter_overflow_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_overflow_clause(s) + } +} + +func (s *Alter_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_overflow_clause(s) + } +} + +func (p *PlSqlParser) Alter_overflow_clause() (localctx IAlter_overflow_clauseContext) { + localctx = NewAlter_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1568, PlSqlParserRULE_alter_overflow_clause) + var _la int + + p.SetState(15001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14991) + p.Add_overflow_clause() + } + + case PlSqlParserOVERFLOW_: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14992) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(14997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserROW, PlSqlParserSTORAGE, PlSqlParserTABLESPACE: + { + p.SetState(14993) + p.Segment_attributes_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(14994) + p.Allocate_extent_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(14995) + p.Shrink_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(14996) + p.Deallocate_unused_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_overflow_clauseContext is an interface to support dynamic dispatch. +type IAdd_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + OVERFLOW_() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_overflow_clauseContext differentiates from other interfaces. + IsAdd_overflow_clauseContext() +} + +type Add_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_overflow_clauseContext() *Add_overflow_clauseContext { + var p = new(Add_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_overflow_clause + return p +} + +func InitEmptyAdd_overflow_clauseContext(p *Add_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_overflow_clause +} + +func (*Add_overflow_clauseContext) IsAdd_overflow_clauseContext() {} + +func NewAdd_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_overflow_clauseContext { + var p = new(Add_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_overflow_clause + + return p +} + +func (s *Add_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_overflow_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_overflow_clauseContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Add_overflow_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_overflow_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Add_overflow_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_overflow_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Add_overflow_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Add_overflow_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_overflow_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_overflow_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_overflow_clause(s) + } +} + +func (s *Add_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_overflow_clause(s) + } +} + +func (p *PlSqlParser) Add_overflow_clause() (localctx IAdd_overflow_clauseContext) { + localctx = NewAdd_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1570, PlSqlParserRULE_add_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15003) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15004) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(15005) + p.Segment_attributes_clause() + } + + } + p.SetState(15024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15008) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15009) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(15010) + p.Segment_attributes_clause() + } + + } + p.SetState(15020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15013) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15014) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-237)) & ^0x3f) == 0 && ((int64(1)<<(_la-237))&10485761) != 0) || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(15015) + p.Segment_attributes_clause() + } + + } + + p.SetState(15022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15023) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_index_clausesContext is an interface to support dynamic dispatch. +type IUpdate_index_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Update_global_index_clause() IUpdate_global_index_clauseContext + Update_all_indexes_clause() IUpdate_all_indexes_clauseContext + + // IsUpdate_index_clausesContext differentiates from other interfaces. + IsUpdate_index_clausesContext() +} + +type Update_index_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_clausesContext() *Update_index_clausesContext { + var p = new(Update_index_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_clauses + return p +} + +func InitEmptyUpdate_index_clausesContext(p *Update_index_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_clauses +} + +func (*Update_index_clausesContext) IsUpdate_index_clausesContext() {} + +func NewUpdate_index_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_clausesContext { + var p = new(Update_index_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_clauses + + return p +} + +func (s *Update_index_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_clausesContext) Update_global_index_clause() IUpdate_global_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_global_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_global_index_clauseContext) +} + +func (s *Update_index_clausesContext) Update_all_indexes_clause() IUpdate_all_indexes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_clauseContext) +} + +func (s *Update_index_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_clauses(s) + } +} + +func (s *Update_index_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_clauses(s) + } +} + +func (p *PlSqlParser) Update_index_clauses() (localctx IUpdate_index_clausesContext) { + localctx = NewUpdate_index_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1572, PlSqlParserRULE_update_index_clauses) + p.SetState(15028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1990, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15026) + p.Update_global_index_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15027) + p.Update_all_indexes_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_global_index_clauseContext is an interface to support dynamic dispatch. +type IUpdate_global_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GLOBAL() antlr.TerminalNode + INDEXES() antlr.TerminalNode + UPDATE() antlr.TerminalNode + INVALIDATE() antlr.TerminalNode + + // IsUpdate_global_index_clauseContext differentiates from other interfaces. + IsUpdate_global_index_clauseContext() +} + +type Update_global_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_global_index_clauseContext() *Update_global_index_clauseContext { + var p = new(Update_global_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_global_index_clause + return p +} + +func InitEmptyUpdate_global_index_clauseContext(p *Update_global_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_global_index_clause +} + +func (*Update_global_index_clauseContext) IsUpdate_global_index_clauseContext() {} + +func NewUpdate_global_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_global_index_clauseContext { + var p = new(Update_global_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_global_index_clause + + return p +} + +func (s *Update_global_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_global_index_clauseContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Update_global_index_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Update_global_index_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_global_index_clauseContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Update_global_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_global_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_global_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_global_index_clause(s) + } +} + +func (s *Update_global_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_global_index_clause(s) + } +} + +func (p *PlSqlParser) Update_global_index_clause() (localctx IUpdate_global_index_clauseContext) { + localctx = NewUpdate_global_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1574, PlSqlParserRULE_update_global_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15030) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15031) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15032) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_all_indexes_clauseContext is an interface to support dynamic dispatch. +type IUpdate_all_indexes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + INDEXES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Update_all_indexes_index_clause() IUpdate_all_indexes_index_clauseContext + RIGHT_PAREN() antlr.TerminalNode + + // IsUpdate_all_indexes_clauseContext differentiates from other interfaces. + IsUpdate_all_indexes_clauseContext() +} + +type Update_all_indexes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_all_indexes_clauseContext() *Update_all_indexes_clauseContext { + var p = new(Update_all_indexes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause + return p +} + +func InitEmptyUpdate_all_indexes_clauseContext(p *Update_all_indexes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause +} + +func (*Update_all_indexes_clauseContext) IsUpdate_all_indexes_clauseContext() {} + +func NewUpdate_all_indexes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_all_indexes_clauseContext { + var p = new(Update_all_indexes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause + + return p +} + +func (s *Update_all_indexes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_all_indexes_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_all_indexes_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Update_all_indexes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_all_indexes_clauseContext) Update_all_indexes_index_clause() IUpdate_all_indexes_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_index_clauseContext) +} + +func (s *Update_all_indexes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_all_indexes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_all_indexes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_all_indexes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_all_indexes_clause(s) + } +} + +func (s *Update_all_indexes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_all_indexes_clause(s) + } +} + +func (p *PlSqlParser) Update_all_indexes_clause() (localctx IUpdate_all_indexes_clauseContext) { + localctx = NewUpdate_all_indexes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1576, PlSqlParserRULE_update_all_indexes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15034) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15035) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15036) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15037) + p.Update_all_indexes_index_clause() + } + { + p.SetState(15038) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_all_indexes_index_clauseContext is an interface to support dynamic dispatch. +type IUpdate_all_indexes_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_name() IIndex_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Update_index_partition() IUpdate_index_partitionContext + Update_index_subpartition() IUpdate_index_subpartitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_all_indexes_clause() []IUpdate_all_indexes_clauseContext + Update_all_indexes_clause(i int) IUpdate_all_indexes_clauseContext + + // IsUpdate_all_indexes_index_clauseContext differentiates from other interfaces. + IsUpdate_all_indexes_index_clauseContext() +} + +type Update_all_indexes_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_all_indexes_index_clauseContext() *Update_all_indexes_index_clauseContext { + var p = new(Update_all_indexes_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause + return p +} + +func InitEmptyUpdate_all_indexes_index_clauseContext(p *Update_all_indexes_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause +} + +func (*Update_all_indexes_index_clauseContext) IsUpdate_all_indexes_index_clauseContext() {} + +func NewUpdate_all_indexes_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_all_indexes_index_clauseContext { + var p = new(Update_all_indexes_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause + + return p +} + +func (s *Update_all_indexes_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_all_indexes_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Update_all_indexes_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_all_indexes_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_all_indexes_index_clauseContext) Update_index_partition() IUpdate_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_partitionContext) +} + +func (s *Update_all_indexes_index_clauseContext) Update_index_subpartition() IUpdate_index_subpartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_subpartitionContext) +} + +func (s *Update_all_indexes_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_all_indexes_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_all_indexes_index_clauseContext) AllUpdate_all_indexes_clause() []IUpdate_all_indexes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + len++ + } + } + + tst := make([]IUpdate_all_indexes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + tst[i] = t.(IUpdate_all_indexes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Update_all_indexes_index_clauseContext) Update_all_indexes_clause(i int) IUpdate_all_indexes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_clauseContext) +} + +func (s *Update_all_indexes_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_all_indexes_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_all_indexes_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_all_indexes_index_clause(s) + } +} + +func (s *Update_all_indexes_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_all_indexes_index_clause(s) + } +} + +func (p *PlSqlParser) Update_all_indexes_index_clause() (localctx IUpdate_all_indexes_index_clauseContext) { + localctx = NewUpdate_all_indexes_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1578, PlSqlParserRULE_update_all_indexes_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15042) + p.Index_name() + } + { + p.SetState(15043) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(15044) + p.Update_index_partition() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(15045) + p.Update_index_subpartition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15048) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15049) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15050) + p.Update_all_indexes_clause() + } + + p.SetState(15055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_index_partitionContext is an interface to support dynamic dispatch. +type IUpdate_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_partition_description() IIndex_partition_descriptionContext + Index_subpartition_clause() IIndex_subpartition_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_index_partition() []IUpdate_index_partitionContext + Update_index_partition(i int) IUpdate_index_partitionContext + + // IsUpdate_index_partitionContext differentiates from other interfaces. + IsUpdate_index_partitionContext() +} + +type Update_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_partitionContext() *Update_index_partitionContext { + var p = new(Update_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_partition + return p +} + +func InitEmptyUpdate_index_partitionContext(p *Update_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_partition +} + +func (*Update_index_partitionContext) IsUpdate_index_partitionContext() {} + +func NewUpdate_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_partitionContext { + var p = new(Update_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_partition + + return p +} + +func (s *Update_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_partitionContext) Index_partition_description() IIndex_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partition_descriptionContext) +} + +func (s *Update_index_partitionContext) Index_subpartition_clause() IIndex_subpartition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_clauseContext) +} + +func (s *Update_index_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_index_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_index_partitionContext) AllUpdate_index_partition() []IUpdate_index_partitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + len++ + } + } + + tst := make([]IUpdate_index_partitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_index_partitionContext); ok { + tst[i] = t.(IUpdate_index_partitionContext) + i++ + } + } + + return tst +} + +func (s *Update_index_partitionContext) Update_index_partition(i int) IUpdate_index_partitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_partitionContext) +} + +func (s *Update_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_partition(s) + } +} + +func (s *Update_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_partition(s) + } +} + +func (p *PlSqlParser) Update_index_partition() (localctx IUpdate_index_partitionContext) { + localctx = NewUpdate_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1580, PlSqlParserRULE_update_index_partition) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15056) + p.Index_partition_description() + } + p.SetState(15058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15057) + p.Index_subpartition_clause() + } + + } + p.SetState(15064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1995, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(15060) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15061) + p.Update_index_partition() + } + + } + p.SetState(15066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1995, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_index_subpartitionContext is an interface to support dynamic dispatch. +type IUpdate_index_subpartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_index_subpartition() []IUpdate_index_subpartitionContext + Update_index_subpartition(i int) IUpdate_index_subpartitionContext + + // IsUpdate_index_subpartitionContext differentiates from other interfaces. + IsUpdate_index_subpartitionContext() +} + +type Update_index_subpartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_subpartitionContext() *Update_index_subpartitionContext { + var p = new(Update_index_subpartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_subpartition + return p +} + +func InitEmptyUpdate_index_subpartitionContext(p *Update_index_subpartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_subpartition +} + +func (*Update_index_subpartitionContext) IsUpdate_index_subpartitionContext() {} + +func NewUpdate_index_subpartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_subpartitionContext { + var p = new(Update_index_subpartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_subpartition + + return p +} + +func (s *Update_index_subpartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_subpartitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Update_index_subpartitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Update_index_subpartitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Update_index_subpartitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Update_index_subpartitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_index_subpartitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_index_subpartitionContext) AllUpdate_index_subpartition() []IUpdate_index_subpartitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + len++ + } + } + + tst := make([]IUpdate_index_subpartitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_index_subpartitionContext); ok { + tst[i] = t.(IUpdate_index_subpartitionContext) + i++ + } + } + + return tst +} + +func (s *Update_index_subpartitionContext) Update_index_subpartition(i int) IUpdate_index_subpartitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_subpartitionContext) +} + +func (s *Update_index_subpartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_subpartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_subpartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_subpartition(s) + } +} + +func (s *Update_index_subpartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_subpartition(s) + } +} + +func (p *PlSqlParser) Update_index_subpartition() (localctx IUpdate_index_subpartitionContext) { + localctx = NewUpdate_index_subpartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1582, PlSqlParserRULE_update_index_subpartition) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15067) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1996, p.GetParserRuleContext()) == 1 { + { + p.SetState(15068) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(15071) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15072) + p.Tablespace() + } + + } + p.SetState(15079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1998, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(15075) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15076) + p.Update_index_subpartition() + } + + } + p.SetState(15081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1998, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_disable_clauseContext is an interface to support dynamic dispatch. +type IEnable_disable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Using_index_clause() IUsing_index_clauseContext + Exceptions_clause() IExceptions_clauseContext + CASCADE() antlr.TerminalNode + INDEX() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + KEEP() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnable_disable_clauseContext differentiates from other interfaces. + IsEnable_disable_clauseContext() +} + +type Enable_disable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_disable_clauseContext() *Enable_disable_clauseContext { + var p = new(Enable_disable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_clause + return p +} + +func InitEmptyEnable_disable_clauseContext(p *Enable_disable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_clause +} + +func (*Enable_disable_clauseContext) IsEnable_disable_clauseContext() {} + +func NewEnable_disable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_disable_clauseContext { + var p = new(Enable_disable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_disable_clause + + return p +} + +func (s *Enable_disable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_disable_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_disable_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_disable_clauseContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Enable_disable_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Enable_disable_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Enable_disable_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Enable_disable_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Enable_disable_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Enable_disable_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Enable_disable_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Enable_disable_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Enable_disable_clauseContext) Using_index_clause() IUsing_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Enable_disable_clauseContext) Exceptions_clause() IExceptions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExceptions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExceptions_clauseContext) +} + +func (s *Enable_disable_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Enable_disable_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Enable_disable_clauseContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Enable_disable_clauseContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Enable_disable_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Enable_disable_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Enable_disable_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Enable_disable_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Enable_disable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_disable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_disable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_disable_clause(s) + } +} + +func (s *Enable_disable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_disable_clause(s) + } +} + +func (p *PlSqlParser) Enable_disable_clause() (localctx IEnable_disable_clauseContext) { + localctx = NewEnable_disable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1584, PlSqlParserRULE_enable_disable_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15082) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(15084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE { + { + p.SetState(15083) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNIQUE: + { + p.SetState(15086) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15087) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15088) + p.Column_name() + } + p.SetState(15093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15089) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15090) + p.Column_name() + } + + p.SetState(15095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15096) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(15098) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15099) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT: + { + p.SetState(15100) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15101) + p.Constraint_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(15104) + p.Using_index_clause() + } + + } + p.SetState(15108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTIONS { + { + p.SetState(15107) + p.Exceptions_clause() + } + + } + p.SetState(15111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(15110) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserKEEP { + { + p.SetState(15113) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15114) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_index_clauseContext is an interface to support dynamic dispatch. +type IUsing_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + LEFT_PAREN() antlr.TerminalNode + Create_index() ICreate_indexContext + RIGHT_PAREN() antlr.TerminalNode + Index_properties() IIndex_propertiesContext + + // IsUsing_index_clauseContext differentiates from other interfaces. + IsUsing_index_clauseContext() +} + +type Using_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_index_clauseContext() *Using_index_clauseContext { + var p = new(Using_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_index_clause + return p +} + +func InitEmptyUsing_index_clauseContext(p *Using_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_index_clause +} + +func (*Using_index_clauseContext) IsUsing_index_clauseContext() {} + +func NewUsing_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_index_clauseContext { + var p = new(Using_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_index_clause + + return p +} + +func (s *Using_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_index_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_index_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Using_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Using_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Using_index_clauseContext) Create_index() ICreate_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_indexContext) +} + +func (s *Using_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Using_index_clauseContext) Index_properties() IIndex_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_propertiesContext) +} + +func (s *Using_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_index_clause(s) + } +} + +func (s *Using_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_index_clause(s) + } +} + +func (p *PlSqlParser) Using_index_clause() (localctx IUsing_index_clauseContext) { + localctx = NewUsing_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1586, PlSqlParserRULE_using_index_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15117) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15118) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2006, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15119) + p.Index_name() + } + + case 2: + { + p.SetState(15120) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15121) + p.Create_index() + } + { + p.SetState(15122) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15124) + p.Index_properties() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_attributesContext is an interface to support dynamic dispatch. +type IIndex_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllSort_or_nosort() []ISort_or_nosortContext + Sort_or_nosort(i int) ISort_or_nosortContext + AllREVERSE() []antlr.TerminalNode + REVERSE(i int) antlr.TerminalNode + AllVisible_or_invisible() []IVisible_or_invisibleContext + Visible_or_invisible(i int) IVisible_or_invisibleContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + + // IsIndex_attributesContext differentiates from other interfaces. + IsIndex_attributesContext() +} + +type Index_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_attributesContext() *Index_attributesContext { + var p = new(Index_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_attributes + return p +} + +func InitEmptyIndex_attributesContext(p *Index_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_attributes +} + +func (*Index_attributesContext) IsIndex_attributesContext() {} + +func NewIndex_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_attributesContext { + var p = new(Index_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_attributes + + return p +} + +func (s *Index_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_attributesContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Index_attributesContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Index_attributesContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Index_attributesContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Index_attributesContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_attributesContext) AllSort_or_nosort() []ISort_or_nosortContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISort_or_nosortContext); ok { + len++ + } + } + + tst := make([]ISort_or_nosortContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISort_or_nosortContext); ok { + tst[i] = t.(ISort_or_nosortContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Sort_or_nosort(i int) ISort_or_nosortContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISort_or_nosortContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISort_or_nosortContext) +} + +func (s *Index_attributesContext) AllREVERSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREVERSE) +} + +func (s *Index_attributesContext) REVERSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, i) +} + +func (s *Index_attributesContext) AllVisible_or_invisible() []IVisible_or_invisibleContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + len++ + } + } + + tst := make([]IVisible_or_invisibleContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVisible_or_invisibleContext); ok { + tst[i] = t.(IVisible_or_invisibleContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Visible_or_invisible(i int) IVisible_or_invisibleContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVisible_or_invisibleContext) +} + +func (s *Index_attributesContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Index_attributesContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_attributesContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Index_attributesContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Index_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_attributes(s) + } +} + +func (s *Index_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_attributes(s) + } +} + +func (p *PlSqlParser) Index_attributes() (localctx IIndex_attributesContext) { + localctx = NewIndex_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1588, PlSqlParserRULE_index_attributes) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(15127) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(15128) + p.Logging_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(15129) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(15130) + p.Tablespace() + } + + case PlSqlParserDEFAULT: + { + p.SetState(15131) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(15134) + p.Key_compression() + } + + case PlSqlParserNOSORT, PlSqlParserSORT: + { + p.SetState(15135) + p.Sort_or_nosort() + } + + case PlSqlParserREVERSE: + { + p.SetState(15136) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVISIBLE, PlSqlParserVISIBLE: + { + p.SetState(15137) + p.Visible_or_invisible() + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(15138) + p.Parallel_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15141) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2009, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISort_or_nosortContext is an interface to support dynamic dispatch. +type ISort_or_nosortContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SORT() antlr.TerminalNode + NOSORT() antlr.TerminalNode + + // IsSort_or_nosortContext differentiates from other interfaces. + IsSort_or_nosortContext() +} + +type Sort_or_nosortContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySort_or_nosortContext() *Sort_or_nosortContext { + var p = new(Sort_or_nosortContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sort_or_nosort + return p +} + +func InitEmptySort_or_nosortContext(p *Sort_or_nosortContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sort_or_nosort +} + +func (*Sort_or_nosortContext) IsSort_or_nosortContext() {} + +func NewSort_or_nosortContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sort_or_nosortContext { + var p = new(Sort_or_nosortContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sort_or_nosort + + return p +} + +func (s *Sort_or_nosortContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sort_or_nosortContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Sort_or_nosortContext) NOSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSORT, 0) +} + +func (s *Sort_or_nosortContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sort_or_nosortContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sort_or_nosortContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSort_or_nosort(s) + } +} + +func (s *Sort_or_nosortContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSort_or_nosort(s) + } +} + +func (p *PlSqlParser) Sort_or_nosort() (localctx ISort_or_nosortContext) { + localctx = NewSort_or_nosortContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1590, PlSqlParserRULE_sort_or_nosort) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15143) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOSORT || _la == PlSqlParserSORT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExceptions_clauseContext is an interface to support dynamic dispatch. +type IExceptions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTIONS() antlr.TerminalNode + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsExceptions_clauseContext differentiates from other interfaces. + IsExceptions_clauseContext() +} + +type Exceptions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExceptions_clauseContext() *Exceptions_clauseContext { + var p = new(Exceptions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exceptions_clause + return p +} + +func InitEmptyExceptions_clauseContext(p *Exceptions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exceptions_clause +} + +func (*Exceptions_clauseContext) IsExceptions_clauseContext() {} + +func NewExceptions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exceptions_clauseContext { + var p = new(Exceptions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exceptions_clause + + return p +} + +func (s *Exceptions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exceptions_clauseContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Exceptions_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Exceptions_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Exceptions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exceptions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exceptions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExceptions_clause(s) + } +} + +func (s *Exceptions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExceptions_clause(s) + } +} + +func (p *PlSqlParser) Exceptions_clause() (localctx IExceptions_clauseContext) { + localctx = NewExceptions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1592, PlSqlParserRULE_exceptions_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15145) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15146) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15147) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_table_clauseContext is an interface to support dynamic dispatch. +type IMove_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + Segment_attributes_clause() ISegment_attributes_clauseContext + Table_compression() ITable_compressionContext + Index_org_table_clause() IIndex_org_table_clauseContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + Parallel_clause() IParallel_clauseContext + + // IsMove_table_clauseContext differentiates from other interfaces. + IsMove_table_clauseContext() +} + +type Move_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_table_clauseContext() *Move_table_clauseContext { + var p = new(Move_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_clause + return p +} + +func InitEmptyMove_table_clauseContext(p *Move_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_clause +} + +func (*Move_table_clauseContext) IsMove_table_clauseContext() {} + +func NewMove_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_table_clauseContext { + var p = new(Move_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_table_clause + + return p +} + +func (s *Move_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_table_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_table_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Move_table_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Move_table_clauseContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Move_table_clauseContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Move_table_clauseContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Move_table_clauseContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Move_table_clauseContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Move_table_clauseContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Move_table_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Move_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_table_clause(s) + } +} + +func (s *Move_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_table_clause(s) + } +} + +func (p *PlSqlParser) Move_table_clause() (localctx IMove_table_clauseContext) { + localctx = NewMove_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1594, PlSqlParserRULE_move_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15149) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLINE { + { + p.SetState(15150) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2011, p.GetParserRuleContext()) == 1 { + { + p.SetState(15153) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2012, p.GetParserRuleContext()) == 1 { + { + p.SetState(15156) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW_ || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(15159) + p.Index_org_table_clause() + } + + } + p.SetState(15166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserLOB || _la == PlSqlParserVARRAY { + p.SetState(15164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOB: + { + p.SetState(15162) + p.Lob_storage_clause() + } + + case PlSqlParserVARRAY: + { + p.SetState(15163) + p.Varray_col_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(15170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(15169) + p.Parallel_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_org_table_clauseContext is an interface to support dynamic dispatch. +type IIndex_org_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllMapping_table_clause() []IMapping_table_clauseContext + Mapping_table_clause(i int) IMapping_table_clauseContext + AllPCTTHRESHOLD() []antlr.TerminalNode + PCTTHRESHOLD(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + Index_org_overflow_clause() IIndex_org_overflow_clauseContext + + // IsIndex_org_table_clauseContext differentiates from other interfaces. + IsIndex_org_table_clauseContext() +} + +type Index_org_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_org_table_clauseContext() *Index_org_table_clauseContext { + var p = new(Index_org_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_table_clause + return p +} + +func InitEmptyIndex_org_table_clauseContext(p *Index_org_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_table_clause +} + +func (*Index_org_table_clauseContext) IsIndex_org_table_clauseContext() {} + +func NewIndex_org_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_org_table_clauseContext { + var p = new(Index_org_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_org_table_clause + + return p +} + +func (s *Index_org_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_org_table_clauseContext) AllMapping_table_clause() []IMapping_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMapping_table_clauseContext); ok { + len++ + } + } + + tst := make([]IMapping_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMapping_table_clauseContext); ok { + tst[i] = t.(IMapping_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_org_table_clauseContext) Mapping_table_clause(i int) IMapping_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMapping_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMapping_table_clauseContext) +} + +func (s *Index_org_table_clauseContext) AllPCTTHRESHOLD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTTHRESHOLD) +} + +func (s *Index_org_table_clauseContext) PCTTHRESHOLD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTTHRESHOLD, i) +} + +func (s *Index_org_table_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Index_org_table_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Index_org_table_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_org_table_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_org_table_clauseContext) Index_org_overflow_clause() IIndex_org_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_overflow_clauseContext) +} + +func (s *Index_org_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_org_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_org_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_org_table_clause(s) + } +} + +func (s *Index_org_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_org_table_clause(s) + } +} + +func (p *PlSqlParser) Index_org_table_clause() (localctx IIndex_org_table_clauseContext) { + localctx = NewIndex_org_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1596, PlSqlParserRULE_index_org_table_clause) + var _la int + + var _alt int + + p.SetState(15184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserMAPPING, PlSqlParserNOCOMPRESS, PlSqlParserNOMAPPING, PlSqlParserPCTTHRESHOLD: + p.EnterOuterAlt(localctx, 1) + p.SetState(15176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAPPING, PlSqlParserNOMAPPING: + { + p.SetState(15172) + p.Mapping_table_clause() + } + + case PlSqlParserPCTTHRESHOLD: + { + p.SetState(15173) + p.Match(PlSqlParserPCTTHRESHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15174) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(15175) + p.Key_compression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15178) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2018, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(15181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING || _la == PlSqlParserOVERFLOW_ { + { + p.SetState(15180) + p.Index_org_overflow_clause() + } + + } + + case PlSqlParserINCLUDING, PlSqlParserOVERFLOW_: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15183) + p.Index_org_overflow_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMapping_table_clauseContext is an interface to support dynamic dispatch. +type IMapping_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAPPING() antlr.TerminalNode + TABLE() antlr.TerminalNode + NOMAPPING() antlr.TerminalNode + + // IsMapping_table_clauseContext differentiates from other interfaces. + IsMapping_table_clauseContext() +} + +type Mapping_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMapping_table_clauseContext() *Mapping_table_clauseContext { + var p = new(Mapping_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mapping_table_clause + return p +} + +func InitEmptyMapping_table_clauseContext(p *Mapping_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mapping_table_clause +} + +func (*Mapping_table_clauseContext) IsMapping_table_clauseContext() {} + +func NewMapping_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mapping_table_clauseContext { + var p = new(Mapping_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mapping_table_clause + + return p +} + +func (s *Mapping_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mapping_table_clauseContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Mapping_table_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Mapping_table_clauseContext) NOMAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAPPING, 0) +} + +func (s *Mapping_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mapping_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mapping_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMapping_table_clause(s) + } +} + +func (s *Mapping_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMapping_table_clause(s) + } +} + +func (p *PlSqlParser) Mapping_table_clause() (localctx IMapping_table_clauseContext) { + localctx = NewMapping_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1598, PlSqlParserRULE_mapping_table_clause) + p.SetState(15189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAPPING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15186) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15187) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMAPPING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15188) + p.Match(PlSqlParserNOMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_compressionContext is an interface to support dynamic dispatch. +type IKey_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOCOMPRESS() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsKey_compressionContext differentiates from other interfaces. + IsKey_compressionContext() +} + +type Key_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_compressionContext() *Key_compressionContext { + var p = new(Key_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_compression + return p +} + +func InitEmptyKey_compressionContext(p *Key_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_compression +} + +func (*Key_compressionContext) IsKey_compressionContext() {} + +func NewKey_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_compressionContext { + var p = new(Key_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_compression + + return p +} + +func (s *Key_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Key_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Key_compressionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Key_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_compression(s) + } +} + +func (s *Key_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_compression(s) + } +} + +func (p *PlSqlParser) Key_compression() (localctx IKey_compressionContext) { + localctx = NewKey_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1600, PlSqlParserRULE_key_compression) + p.SetState(15194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15191) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15192) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15193) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_org_overflow_clauseContext is an interface to support dynamic dispatch. +type IIndex_org_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVERFLOW_() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + Column_name() IColumn_nameContext + Segment_attributes_clause() ISegment_attributes_clauseContext + + // IsIndex_org_overflow_clauseContext differentiates from other interfaces. + IsIndex_org_overflow_clauseContext() +} + +type Index_org_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_org_overflow_clauseContext() *Index_org_overflow_clauseContext { + var p = new(Index_org_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause + return p +} + +func InitEmptyIndex_org_overflow_clauseContext(p *Index_org_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause +} + +func (*Index_org_overflow_clauseContext) IsIndex_org_overflow_clauseContext() {} + +func NewIndex_org_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_org_overflow_clauseContext { + var p = new(Index_org_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause + + return p +} + +func (s *Index_org_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_org_overflow_clauseContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Index_org_overflow_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Index_org_overflow_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Index_org_overflow_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_org_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_org_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_org_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_org_overflow_clause(s) + } +} + +func (s *Index_org_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_org_overflow_clause(s) + } +} + +func (p *PlSqlParser) Index_org_overflow_clause() (localctx IIndex_org_overflow_clauseContext) { + localctx = NewIndex_org_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1602, PlSqlParserRULE_index_org_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(15196) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15197) + p.Column_name() + } + + } + { + p.SetState(15200) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15202) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2024, p.GetParserRuleContext()) == 1 { + { + p.SetState(15201) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_clausesContext is an interface to support dynamic dispatch. +type IColumn_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_modify_drop_column_clauses() IAdd_modify_drop_column_clausesContext + Rename_column_clause() IRename_column_clauseContext + Modify_collection_retrieval() IModify_collection_retrievalContext + Modify_lob_storage_clause() IModify_lob_storage_clauseContext + + // IsColumn_clausesContext differentiates from other interfaces. + IsColumn_clausesContext() +} + +type Column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_clausesContext() *Column_clausesContext { + var p = new(Column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_clauses + return p +} + +func InitEmptyColumn_clausesContext(p *Column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_clauses +} + +func (*Column_clausesContext) IsColumn_clausesContext() {} + +func NewColumn_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_clausesContext { + var p = new(Column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_clauses + + return p +} + +func (s *Column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_clausesContext) Add_modify_drop_column_clauses() IAdd_modify_drop_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_modify_drop_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_modify_drop_column_clausesContext) +} + +func (s *Column_clausesContext) Rename_column_clause() IRename_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_column_clauseContext) +} + +func (s *Column_clausesContext) Modify_collection_retrieval() IModify_collection_retrievalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_collection_retrievalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_collection_retrievalContext) +} + +func (s *Column_clausesContext) Modify_lob_storage_clause() IModify_lob_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_storage_clauseContext) +} + +func (s *Column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_clauses(s) + } +} + +func (s *Column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_clauses(s) + } +} + +func (p *PlSqlParser) Column_clauses() (localctx IColumn_clausesContext) { + localctx = NewColumn_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1604, PlSqlParserRULE_column_clauses) + p.SetState(15208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2025, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15204) + p.Add_modify_drop_column_clauses() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15205) + p.Rename_column_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15206) + p.Modify_collection_retrieval() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15207) + p.Modify_lob_storage_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_collection_retrievalContext is an interface to support dynamic dispatch. +type IModify_collection_retrievalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + Collection_item() ICollection_itemContext + RETURN() antlr.TerminalNode + AS() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsModify_collection_retrievalContext differentiates from other interfaces. + IsModify_collection_retrievalContext() +} + +type Modify_collection_retrievalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_collection_retrievalContext() *Modify_collection_retrievalContext { + var p = new(Modify_collection_retrievalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval + return p +} + +func InitEmptyModify_collection_retrievalContext(p *Modify_collection_retrievalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval +} + +func (*Modify_collection_retrievalContext) IsModify_collection_retrievalContext() {} + +func NewModify_collection_retrievalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_collection_retrievalContext { + var p = new(Modify_collection_retrievalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval + + return p +} + +func (s *Modify_collection_retrievalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_collection_retrievalContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_collection_retrievalContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Modify_collection_retrievalContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Modify_collection_retrievalContext) Collection_item() ICollection_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_itemContext) +} + +func (s *Modify_collection_retrievalContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Modify_collection_retrievalContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Modify_collection_retrievalContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Modify_collection_retrievalContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Modify_collection_retrievalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_collection_retrievalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_collection_retrievalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_collection_retrieval(s) + } +} + +func (s *Modify_collection_retrievalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_collection_retrieval(s) + } +} + +func (p *PlSqlParser) Modify_collection_retrieval() (localctx IModify_collection_retrievalContext) { + localctx = NewModify_collection_retrievalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1606, PlSqlParserRULE_modify_collection_retrieval) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15210) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15211) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15212) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15213) + p.Collection_item() + } + { + p.SetState(15214) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15215) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15216) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCATOR || _la == PlSqlParserVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollection_itemContext is an interface to support dynamic dispatch. +type ICollection_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + + // IsCollection_itemContext differentiates from other interfaces. + IsCollection_itemContext() +} + +type Collection_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollection_itemContext() *Collection_itemContext { + var p = new(Collection_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_item + return p +} + +func InitEmptyCollection_itemContext(p *Collection_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_item +} + +func (*Collection_itemContext) IsCollection_itemContext() {} + +func NewCollection_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collection_itemContext { + var p = new(Collection_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collection_item + + return p +} + +func (s *Collection_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collection_itemContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Collection_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collection_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collection_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollection_item(s) + } +} + +func (s *Collection_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollection_item(s) + } +} + +func (p *PlSqlParser) Collection_item() (localctx ICollection_itemContext) { + localctx = NewCollection_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1608, PlSqlParserRULE_collection_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15218) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_column_clauseContext is an interface to support dynamic dispatch. +type IRename_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Old_column_name() IOld_column_nameContext + TO() antlr.TerminalNode + New_column_name() INew_column_nameContext + + // IsRename_column_clauseContext differentiates from other interfaces. + IsRename_column_clauseContext() +} + +type Rename_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_column_clauseContext() *Rename_column_clauseContext { + var p = new(Rename_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_column_clause + return p +} + +func InitEmptyRename_column_clauseContext(p *Rename_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_column_clause +} + +func (*Rename_column_clauseContext) IsRename_column_clauseContext() {} + +func NewRename_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_column_clauseContext { + var p = new(Rename_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_column_clause + + return p +} + +func (s *Rename_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_column_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_column_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Rename_column_clauseContext) Old_column_name() IOld_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_column_nameContext) +} + +func (s *Rename_column_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_column_clauseContext) New_column_name() INew_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_column_nameContext) +} + +func (s *Rename_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_column_clause(s) + } +} + +func (s *Rename_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_column_clause(s) + } +} + +func (p *PlSqlParser) Rename_column_clause() (localctx IRename_column_clauseContext) { + localctx = NewRename_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1610, PlSqlParserRULE_rename_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15220) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15221) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15222) + p.Old_column_name() + } + { + p.SetState(15223) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15224) + p.New_column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOld_column_nameContext is an interface to support dynamic dispatch. +type IOld_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsOld_column_nameContext differentiates from other interfaces. + IsOld_column_nameContext() +} + +type Old_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_column_nameContext() *Old_column_nameContext { + var p = new(Old_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_column_name + return p +} + +func InitEmptyOld_column_nameContext(p *Old_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_column_name +} + +func (*Old_column_nameContext) IsOld_column_nameContext() {} + +func NewOld_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_column_nameContext { + var p = new(Old_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_old_column_name + + return p +} + +func (s *Old_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_column_nameContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Old_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOld_column_name(s) + } +} + +func (s *Old_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOld_column_name(s) + } +} + +func (p *PlSqlParser) Old_column_name() (localctx IOld_column_nameContext) { + localctx = NewOld_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1612, PlSqlParserRULE_old_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15226) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_column_nameContext is an interface to support dynamic dispatch. +type INew_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsNew_column_nameContext differentiates from other interfaces. + IsNew_column_nameContext() +} + +type New_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_column_nameContext() *New_column_nameContext { + var p = new(New_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_column_name + return p +} + +func InitEmptyNew_column_nameContext(p *New_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_column_name +} + +func (*New_column_nameContext) IsNew_column_nameContext() {} + +func NewNew_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_column_nameContext { + var p = new(New_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_column_name + + return p +} + +func (s *New_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_column_nameContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *New_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_column_name(s) + } +} + +func (s *New_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_column_name(s) + } +} + +func (p *PlSqlParser) New_column_name() (localctx INew_column_nameContext) { + localctx = NewNew_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1614, PlSqlParserRULE_new_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15228) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_modify_drop_column_clausesContext is an interface to support dynamic dispatch. +type IAdd_modify_drop_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstraint_clauses() []IConstraint_clausesContext + Constraint_clauses(i int) IConstraint_clausesContext + AllAdd_column_clause() []IAdd_column_clauseContext + Add_column_clause(i int) IAdd_column_clauseContext + AllModify_column_clauses() []IModify_column_clausesContext + Modify_column_clauses(i int) IModify_column_clausesContext + AllDrop_column_clause() []IDrop_column_clauseContext + Drop_column_clause(i int) IDrop_column_clauseContext + + // IsAdd_modify_drop_column_clausesContext differentiates from other interfaces. + IsAdd_modify_drop_column_clausesContext() +} + +type Add_modify_drop_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_modify_drop_column_clausesContext() *Add_modify_drop_column_clausesContext { + var p = new(Add_modify_drop_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses + return p +} + +func InitEmptyAdd_modify_drop_column_clausesContext(p *Add_modify_drop_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses +} + +func (*Add_modify_drop_column_clausesContext) IsAdd_modify_drop_column_clausesContext() {} + +func NewAdd_modify_drop_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_modify_drop_column_clausesContext { + var p = new(Add_modify_drop_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses + + return p +} + +func (s *Add_modify_drop_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_modify_drop_column_clausesContext) AllConstraint_clauses() []IConstraint_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraint_clausesContext); ok { + len++ + } + } + + tst := make([]IConstraint_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraint_clausesContext); ok { + tst[i] = t.(IConstraint_clausesContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Constraint_clauses(i int) IConstraint_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_clausesContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllAdd_column_clause() []IAdd_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_column_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_column_clauseContext); ok { + tst[i] = t.(IAdd_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Add_column_clause(i int) IAdd_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_column_clauseContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllModify_column_clauses() []IModify_column_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_column_clausesContext); ok { + len++ + } + } + + tst := make([]IModify_column_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_column_clausesContext); ok { + tst[i] = t.(IModify_column_clausesContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Modify_column_clauses(i int) IModify_column_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_column_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_column_clausesContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllDrop_column_clause() []IDrop_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_column_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_column_clauseContext); ok { + tst[i] = t.(IDrop_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Drop_column_clause(i int) IDrop_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_column_clauseContext) +} + +func (s *Add_modify_drop_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_modify_drop_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_modify_drop_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_modify_drop_column_clauses(s) + } +} + +func (s *Add_modify_drop_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_modify_drop_column_clauses(s) + } +} + +func (p *PlSqlParser) Add_modify_drop_column_clauses() (localctx IAdd_modify_drop_column_clausesContext) { + localctx = NewAdd_modify_drop_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1616, PlSqlParserRULE_add_modify_drop_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserADD || _la == PlSqlParserDROP || _la == PlSqlParserMODIFY || _la == PlSqlParserRENAME || _la == PlSqlParserSET { + p.SetState(15234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2026, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15230) + p.Constraint_clauses() + } + + case 2: + { + p.SetState(15231) + p.Add_column_clause() + } + + case 3: + { + p.SetState(15232) + p.Modify_column_clauses() + } + + case 4: + { + p.SetState(15233) + p.Drop_column_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_column_clauseContext is an interface to support dynamic dispatch. +type IDrop_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + UNUSED() antlr.TerminalNode + COLUMN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCASCADE() []antlr.TerminalNode + CASCADE(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllINVALIDATE() []antlr.TerminalNode + INVALIDATE(i int) antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + + // IsDrop_column_clauseContext differentiates from other interfaces. + IsDrop_column_clauseContext() +} + +type Drop_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_column_clauseContext() *Drop_column_clauseContext { + var p = new(Drop_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_column_clause + return p +} + +func InitEmptyDrop_column_clauseContext(p *Drop_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_column_clause +} + +func (*Drop_column_clauseContext) IsDrop_column_clauseContext() {} + +func NewDrop_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_clauseContext { + var p = new(Drop_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_column_clause + + return p +} + +func (s *Drop_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_column_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Drop_column_clauseContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Drop_column_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Drop_column_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_column_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Drop_column_clauseContext) AllCASCADE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASCADE) +} + +func (s *Drop_column_clauseContext) CASCADE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, i) +} + +func (s *Drop_column_clauseContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Drop_column_clauseContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Drop_column_clauseContext) AllINVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINVALIDATE) +} + +func (s *Drop_column_clauseContext) INVALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, i) +} + +func (s *Drop_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_column_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_column_clauseContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECKPOINT, 0) +} + +func (s *Drop_column_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Drop_column_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Drop_column_clauseContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Drop_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_column_clause(s) + } +} + +func (s *Drop_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_column_clause(s) + } +} + +func (p *PlSqlParser) Drop_column_clause() (localctx IDrop_column_clauseContext) { + localctx = NewDrop_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1618, PlSqlParserRULE_drop_column_clause) + var _la int + + p.SetState(15300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2038, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15238) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15239) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(15240) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15241) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15242) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15243) + p.Column_name() + } + p.SetState(15248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15244) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15245) + p.Column_name() + } + + p.SetState(15250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15251) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + p.SetState(15258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(15255) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15256) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVALIDATE: + { + p.SetState(15257) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15263) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(15264) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15265) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15266) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15267) + p.Column_name() + } + p.SetState(15272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15268) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15269) + p.Column_name() + } + + p.SetState(15274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15275) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + p.SetState(15282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(15279) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15280) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVALIDATE: + { + p.SetState(15281) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(15289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHECKPOINT { + { + p.SetState(15287) + p.Match(PlSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15288) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15291) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNUSED: + { + p.SetState(15292) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15293) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLUMNS: + { + p.SetState(15294) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15295) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + { + p.SetState(15298) + p.Match(PlSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15299) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_column_clausesContext is an interface to support dynamic dispatch. +type IModify_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllModify_col_properties() []IModify_col_propertiesContext + Modify_col_properties(i int) IModify_col_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + AllModify_col_visibility() []IModify_col_visibilityContext + Modify_col_visibility(i int) IModify_col_visibilityContext + Modify_col_substitutable() IModify_col_substitutableContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModify_column_clausesContext differentiates from other interfaces. + IsModify_column_clausesContext() +} + +type Modify_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_column_clausesContext() *Modify_column_clausesContext { + var p = new(Modify_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_column_clauses + return p +} + +func InitEmptyModify_column_clausesContext(p *Modify_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_column_clauses +} + +func (*Modify_column_clausesContext) IsModify_column_clausesContext() {} + +func NewModify_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_column_clausesContext { + var p = new(Modify_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_column_clauses + + return p +} + +func (s *Modify_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_column_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_column_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_column_clausesContext) AllModify_col_properties() []IModify_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IModify_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_col_propertiesContext); ok { + tst[i] = t.(IModify_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Modify_column_clausesContext) Modify_col_properties(i int) IModify_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_propertiesContext) +} + +func (s *Modify_column_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_column_clausesContext) AllModify_col_visibility() []IModify_col_visibilityContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_col_visibilityContext); ok { + len++ + } + } + + tst := make([]IModify_col_visibilityContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_col_visibilityContext); ok { + tst[i] = t.(IModify_col_visibilityContext) + i++ + } + } + + return tst +} + +func (s *Modify_column_clausesContext) Modify_col_visibility(i int) IModify_col_visibilityContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_visibilityContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_visibilityContext) +} + +func (s *Modify_column_clausesContext) Modify_col_substitutable() IModify_col_substitutableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_substitutableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_substitutableContext) +} + +func (s *Modify_column_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Modify_column_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Modify_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_column_clauses(s) + } +} + +func (s *Modify_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_column_clauses(s) + } +} + +func (p *PlSqlParser) Modify_column_clauses() (localctx IModify_column_clausesContext) { + localctx = NewModify_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1620, PlSqlParserRULE_modify_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15302) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2041, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15303) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15304) + p.Modify_col_properties() + } + p.SetState(15309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15305) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15306) + p.Modify_col_properties() + } + + p.SetState(15311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15312) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(15314) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15315) + p.Modify_col_visibility() + } + p.SetState(15320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15316) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15317) + p.Modify_col_visibility() + } + + p.SetState(15322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15323) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15325) + p.Modify_col_properties() + } + + case 4: + { + p.SetState(15326) + p.Modify_col_visibility() + } + + case 5: + { + p.SetState(15327) + p.Modify_col_substitutable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_col_propertiesContext is an interface to support dynamic dispatch. +type IModify_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Datatype() IDatatypeContext + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + DECRYPT() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + Lob_storage_clause() ILob_storage_clauseContext + Annotations_clause() IAnnotations_clauseContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsModify_col_propertiesContext differentiates from other interfaces. + IsModify_col_propertiesContext() +} + +type Modify_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_propertiesContext() *Modify_col_propertiesContext { + var p = new(Modify_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_properties + return p +} + +func InitEmptyModify_col_propertiesContext(p *Modify_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_properties +} + +func (*Modify_col_propertiesContext) IsModify_col_propertiesContext() {} + +func NewModify_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_propertiesContext { + var p = new(Modify_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_properties + + return p +} + +func (s *Modify_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_propertiesContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Modify_col_propertiesContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Modify_col_propertiesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Modify_col_propertiesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Modify_col_propertiesContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Modify_col_propertiesContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_col_propertiesContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Modify_col_propertiesContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Modify_col_propertiesContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Modify_col_propertiesContext) Lob_storage_clause() ILob_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Modify_col_propertiesContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Modify_col_propertiesContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Modify_col_propertiesContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Modify_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_properties(s) + } +} + +func (s *Modify_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_properties(s) + } +} + +func (p *PlSqlParser) Modify_col_properties() (localctx IModify_col_propertiesContext) { + localctx = NewModify_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1622, PlSqlParserRULE_modify_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15330) + p.Column_name() + } + p.SetState(15332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-119)) & ^0x3f) == 0 && ((int64(1)<<(_la-119))&545264193) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&4194313) != 0) || ((int64((_la-361)) & ^0x3f) == 0 && ((int64(1)<<(_la-361))&1572881) != 0) || _la == PlSqlParserDOUBLE || _la == PlSqlParserDSINTERVAL_UNCONSTRAINED || _la == PlSqlParserFLOAT || _la == PlSqlParserHOUR || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&385) != 0) || _la == PlSqlParserLONG || ((int64((_la-958)) & ^0x3f) == 0 && ((int64(1)<<(_la-958))&5840605900964097) != 0) || ((int64((_la-1230)) & ^0x3f) == 0 && ((int64(1)<<(_la-1230))&35) != 0) || ((int64((_la-1403)) & ^0x3f) == 0 && ((int64(1)<<(_la-1403))&196609) != 0) || _la == PlSqlParserRAW || _la == PlSqlParserREAL || ((int64((_la-1601)) & ^0x3f) == 0 && ((int64(1)<<(_la-1601))&38654705665) != 0) || ((int64((_la-1692)) & ^0x3f) == 0 && ((int64(1)<<(_la-1692))&16387) != 0) || _la == PlSqlParserSTRING || ((int64((_la-2107)) & ^0x3f) == 0 && ((int64(1)<<(_la-2107))&2959) != 0) || ((int64((_la-2214)) & ^0x3f) == 0 && ((int64(1)<<(_la-2214))&105553116266497) != 0) || ((int64((_la-2351)) & ^0x3f) == 0 && ((int64(1)<<(_la-2351))&1153) != 0) { + { + p.SetState(15331) + p.Datatype() + } + + } + p.SetState(15340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(15334) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15337) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2043, p.GetParserRuleContext()) == 1 { + { + p.SetState(15335) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15336) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15339) + p.Expression() + } + + } + p.SetState(15345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT: + { + p.SetState(15342) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15343) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(15344) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEOF, PlSqlParserADD, PlSqlParserANNOTATIONS, PlSqlParserCHECK, PlSqlParserCONSTRAINT, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserLOB, PlSqlParserMODIFY, PlSqlParserNOT, PlSqlParserNULL_, PlSqlParserPRIMARY, PlSqlParserREFERENCES, PlSqlParserRENAME, PlSqlParserSET, PlSqlParserUNIQUE, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(15350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(15347) + p.Inline_constraint() + } + + p.SetState(15352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(15354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOB { + { + p.SetState(15353) + p.Lob_storage_clause() + } + + } + p.SetState(15357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANNOTATIONS { + { + p.SetState(15356) + p.Annotations_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_col_visibilityContext is an interface to support dynamic dispatch. +type IModify_col_visibilityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + + // IsModify_col_visibilityContext differentiates from other interfaces. + IsModify_col_visibilityContext() +} + +type Modify_col_visibilityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_visibilityContext() *Modify_col_visibilityContext { + var p = new(Modify_col_visibilityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_visibility + return p +} + +func InitEmptyModify_col_visibilityContext(p *Modify_col_visibilityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_visibility +} + +func (*Modify_col_visibilityContext) IsModify_col_visibilityContext() {} + +func NewModify_col_visibilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_visibilityContext { + var p = new(Modify_col_visibilityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_visibility + + return p +} + +func (s *Modify_col_visibilityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_visibilityContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Modify_col_visibilityContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Modify_col_visibilityContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Modify_col_visibilityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_visibilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_visibilityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_visibility(s) + } +} + +func (s *Modify_col_visibilityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_visibility(s) + } +} + +func (p *PlSqlParser) Modify_col_visibility() (localctx IModify_col_visibilityContext) { + localctx = NewModify_col_visibilityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1624, PlSqlParserRULE_modify_col_visibility) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15359) + p.Column_name() + } + { + p.SetState(15360) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_col_substitutableContext is an interface to support dynamic dispatch. +type IModify_col_substitutableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsModify_col_substitutableContext differentiates from other interfaces. + IsModify_col_substitutableContext() +} + +type Modify_col_substitutableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_substitutableContext() *Modify_col_substitutableContext { + var p = new(Modify_col_substitutableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable + return p +} + +func InitEmptyModify_col_substitutableContext(p *Modify_col_substitutableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable +} + +func (*Modify_col_substitutableContext) IsModify_col_substitutableContext() {} + +func NewModify_col_substitutableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_substitutableContext { + var p = new(Modify_col_substitutableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable + + return p +} + +func (s *Modify_col_substitutableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_substitutableContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Modify_col_substitutableContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Modify_col_substitutableContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Modify_col_substitutableContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Modify_col_substitutableContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Modify_col_substitutableContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Modify_col_substitutableContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Modify_col_substitutableContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Modify_col_substitutableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_substitutableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_substitutableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_substitutable(s) + } +} + +func (s *Modify_col_substitutableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_substitutable(s) + } +} + +func (p *PlSqlParser) Modify_col_substitutable() (localctx IModify_col_substitutableContext) { + localctx = NewModify_col_substitutableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1626, PlSqlParserRULE_modify_col_substitutable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15362) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15363) + p.Column_name() + } + p.SetState(15365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15364) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15367) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15368) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15369) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15370) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(15371) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_column_clauseContext is an interface to support dynamic dispatch. +type IAdd_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Column_properties() IColumn_propertiesContext + AllColumn_definition() []IColumn_definitionContext + Column_definition(i int) IColumn_definitionContext + AllVirtual_column_definition() []IVirtual_column_definitionContext + Virtual_column_definition(i int) IVirtual_column_definitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_column_clauseContext differentiates from other interfaces. + IsAdd_column_clauseContext() +} + +type Add_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_column_clauseContext() *Add_column_clauseContext { + var p = new(Add_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_column_clause + return p +} + +func InitEmptyAdd_column_clauseContext(p *Add_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_column_clause +} + +func (*Add_column_clauseContext) IsAdd_column_clauseContext() {} + +func NewAdd_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_column_clauseContext { + var p = new(Add_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_column_clause + + return p +} + +func (s *Add_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_column_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_column_clauseContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Add_column_clauseContext) AllColumn_definition() []IColumn_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_definitionContext); ok { + len++ + } + } + + tst := make([]IColumn_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_definitionContext); ok { + tst[i] = t.(IColumn_definitionContext) + i++ + } + } + + return tst +} + +func (s *Add_column_clauseContext) Column_definition(i int) IColumn_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Add_column_clauseContext) AllVirtual_column_definition() []IVirtual_column_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + len++ + } + } + + tst := make([]IVirtual_column_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVirtual_column_definitionContext); ok { + tst[i] = t.(IVirtual_column_definitionContext) + i++ + } + } + + return tst +} + +func (s *Add_column_clauseContext) Virtual_column_definition(i int) IVirtual_column_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVirtual_column_definitionContext) +} + +func (s *Add_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_column_clause(s) + } +} + +func (s *Add_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_column_clause(s) + } +} + +func (p *PlSqlParser) Add_column_clause() (localctx IAdd_column_clauseContext) { + localctx = NewAdd_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1628, PlSqlParserRULE_add_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15374) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(15375) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2051, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15376) + p.Column_definition() + } + + case 2: + { + p.SetState(15377) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15380) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2052, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15381) + p.Column_definition() + } + + case 2: + { + p.SetState(15382) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15390) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(15394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2054, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15392) + p.Column_definition() + } + + case 2: + { + p.SetState(15393) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserLOB || _la == PlSqlParserNESTED || _la == PlSqlParserVARRAY || _la == PlSqlParserXMLTYPE { + { + p.SetState(15398) + p.Column_properties() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_col_propertiesContext is an interface to support dynamic dispatch. +type IVarray_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARRAY() antlr.TerminalNode + Varray_item() IVarray_itemContext + Varray_storage_clause() IVarray_storage_clauseContext + Substitutable_column_clause() ISubstitutable_column_clauseContext + + // IsVarray_col_propertiesContext differentiates from other interfaces. + IsVarray_col_propertiesContext() +} + +type Varray_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_col_propertiesContext() *Varray_col_propertiesContext { + var p = new(Varray_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_col_properties + return p +} + +func InitEmptyVarray_col_propertiesContext(p *Varray_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_col_properties +} + +func (*Varray_col_propertiesContext) IsVarray_col_propertiesContext() {} + +func NewVarray_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_col_propertiesContext { + var p = new(Varray_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_col_properties + + return p +} + +func (s *Varray_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_col_propertiesContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Varray_col_propertiesContext) Varray_item() IVarray_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_itemContext) +} + +func (s *Varray_col_propertiesContext) Varray_storage_clause() IVarray_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_storage_clauseContext) +} + +func (s *Varray_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Varray_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_col_properties(s) + } +} + +func (s *Varray_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_col_properties(s) + } +} + +func (p *PlSqlParser) Varray_col_properties() (localctx IVarray_col_propertiesContext) { + localctx = NewVarray_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1630, PlSqlParserRULE_varray_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15401) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15402) + p.Varray_item() + } + p.SetState(15408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2058, p.GetParserRuleContext()) { + case 1: + p.SetState(15404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserIS || _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(15403) + p.Substitutable_column_clause() + } + + } + { + p.SetState(15406) + p.Varray_storage_clause() + } + + case 2: + { + p.SetState(15407) + p.Substitutable_column_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_storage_clauseContext is an interface to support dynamic dispatch. +type IVarray_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + LOB() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Lob_storage_parameters() ILob_storage_parametersContext + RIGHT_PAREN() antlr.TerminalNode + Lob_segname() ILob_segnameContext + SECUREFILE() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + + // IsVarray_storage_clauseContext differentiates from other interfaces. + IsVarray_storage_clauseContext() +} + +type Varray_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_storage_clauseContext() *Varray_storage_clauseContext { + var p = new(Varray_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_storage_clause + return p +} + +func InitEmptyVarray_storage_clauseContext(p *Varray_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_storage_clause +} + +func (*Varray_storage_clauseContext) IsVarray_storage_clauseContext() {} + +func NewVarray_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_storage_clauseContext { + var p = new(Varray_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_storage_clause + + return p +} + +func (s *Varray_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_storage_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Varray_storage_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Varray_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Varray_storage_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Varray_storage_clauseContext) Lob_storage_parameters() ILob_storage_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Varray_storage_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Varray_storage_clauseContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Varray_storage_clauseContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Varray_storage_clauseContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Varray_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_storage_clause(s) + } +} + +func (s *Varray_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_storage_clause(s) + } +} + +func (p *PlSqlParser) Varray_storage_clause() (localctx IVarray_storage_clauseContext) { + localctx = NewVarray_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1632, PlSqlParserRULE_varray_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15410) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15411) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(15412) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(15415) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15424) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2061, p.GetParserRuleContext()) == 1 { + p.SetState(15417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(15416) + p.Lob_segname() + } + + } + { + p.SetState(15419) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15420) + p.Lob_storage_parameters() + } + { + p.SetState(15421) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2061, p.GetParserRuleContext()) == 2 { + { + p.SetState(15423) + p.Lob_segname() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_segnameContext is an interface to support dynamic dispatch. +type ILob_segnameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + DELIMITED_ID() antlr.TerminalNode + + // IsLob_segnameContext differentiates from other interfaces. + IsLob_segnameContext() +} + +type Lob_segnameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_segnameContext() *Lob_segnameContext { + var p = new(Lob_segnameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_segname + return p +} + +func InitEmptyLob_segnameContext(p *Lob_segnameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_segname +} + +func (*Lob_segnameContext) IsLob_segnameContext() {} + +func NewLob_segnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_segnameContext { + var p = new(Lob_segnameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_segname + + return p +} + +func (s *Lob_segnameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_segnameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Lob_segnameContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Lob_segnameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_segnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_segnameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_segname(s) + } +} + +func (s *Lob_segnameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_segname(s) + } +} + +func (p *PlSqlParser) Lob_segname() (localctx ILob_segnameContext) { + localctx = NewLob_segnameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1634, PlSqlParserRULE_lob_segname) + p.SetState(15428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15426) + p.Regular_id() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15427) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_itemContext is an interface to support dynamic dispatch. +type ILob_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + Quoted_string() IQuoted_stringContext + DELIMITED_ID() antlr.TerminalNode + + // IsLob_itemContext differentiates from other interfaces. + IsLob_itemContext() +} + +type Lob_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_itemContext() *Lob_itemContext { + var p = new(Lob_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_item + return p +} + +func InitEmptyLob_itemContext(p *Lob_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_item +} + +func (*Lob_itemContext) IsLob_itemContext() {} + +func NewLob_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_itemContext { + var p = new(Lob_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_item + + return p +} + +func (s *Lob_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_itemContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Lob_itemContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Lob_itemContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Lob_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_item(s) + } +} + +func (s *Lob_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_item(s) + } +} + +func (p *PlSqlParser) Lob_item() (localctx ILob_itemContext) { + localctx = NewLob_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1636, PlSqlParserRULE_lob_item) + p.SetState(15433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15430) + p.Regular_id() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15431) + p.Quoted_string() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15432) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_storage_parametersContext is an interface to support dynamic dispatch. +type ILob_storage_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Lob_parameters() ILob_parametersContext + Storage_clause() IStorage_clauseContext + + // IsLob_storage_parametersContext differentiates from other interfaces. + IsLob_storage_parametersContext() +} + +type Lob_storage_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyLob_storage_parametersContext() *Lob_storage_parametersContext { + var p = new(Lob_storage_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters + return p +} + +func InitEmptyLob_storage_parametersContext(p *Lob_storage_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters +} + +func (*Lob_storage_parametersContext) IsLob_storage_parametersContext() {} + +func NewLob_storage_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_storage_parametersContext { + var p = new(Lob_storage_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters + + return p +} + +func (s *Lob_storage_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_storage_parametersContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Lob_storage_parametersContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Lob_storage_parametersContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Lob_storage_parametersContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Lob_storage_parametersContext) Lob_parameters() ILob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_parametersContext) +} + +func (s *Lob_storage_parametersContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Lob_storage_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_storage_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_storage_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_storage_parameters(s) + } +} + +func (s *Lob_storage_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_storage_parameters(s) + } +} + +func (p *PlSqlParser) Lob_storage_parameters() (localctx ILob_storage_parametersContext) { + localctx = NewLob_storage_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1638, PlSqlParserRULE_lob_storage_parameters) + p.SetState(15442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15435) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15436) + + var _x = p.Id_expression() + + localctx.(*Lob_storage_parametersContext).tablespace_name = _x + } + + case PlSqlParserCACHE, PlSqlParserCHUNK, PlSqlParserCOMPRESS, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserFREEPOOLS, PlSqlParserKEEP_DUPLICATES, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserPCTVERSION, PlSqlParserRETENTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15437) + p.Lob_parameters() + } + p.SetState(15439) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2064, p.GetParserRuleContext()) == 1 { + { + p.SetState(15438) + p.Storage_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSTORAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15441) + p.Storage_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_storage_clauseContext is an interface to support dynamic dispatch. +type ILob_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_item() []ILob_itemContext + Lob_item(i int) ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + AllLob_storage_parameters() []ILob_storage_parametersContext + Lob_storage_parameters(i int) ILob_storage_parametersContext + + // IsLob_storage_clauseContext differentiates from other interfaces. + IsLob_storage_clauseContext() +} + +type Lob_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_storage_clauseContext() *Lob_storage_clauseContext { + var p = new(Lob_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_clause + return p +} + +func InitEmptyLob_storage_clauseContext(p *Lob_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_clause +} + +func (*Lob_storage_clauseContext) IsLob_storage_clauseContext() {} + +func NewLob_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_storage_clauseContext { + var p = new(Lob_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_storage_clause + + return p +} + +func (s *Lob_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_storage_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_storage_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_storage_clauseContext) AllLob_item() []ILob_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_itemContext); ok { + len++ + } + } + + tst := make([]ILob_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_itemContext); ok { + tst[i] = t.(ILob_itemContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_item(i int) ILob_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_storage_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_storage_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_storage_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_storage_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_storage_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Lob_storage_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Lob_storage_clauseContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_storage_clauseContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Lob_storage_clauseContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Lob_storage_clauseContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Lob_storage_clauseContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Lob_storage_clauseContext) AllLob_storage_parameters() []ILob_storage_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + len++ + } + } + + tst := make([]ILob_storage_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_parametersContext); ok { + tst[i] = t.(ILob_storage_parametersContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_storage_parameters(i int) ILob_storage_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Lob_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_storage_clause(s) + } +} + +func (s *Lob_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_storage_clause(s) + } +} + +func (p *PlSqlParser) Lob_storage_clause() (localctx ILob_storage_clauseContext) { + localctx = NewLob_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1640, PlSqlParserRULE_lob_storage_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15444) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2073, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15445) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15446) + p.Lob_item() + } + p.SetState(15451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15447) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15448) + p.Lob_item() + } + + p.SetState(15453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15454) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15455) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15456) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBASICFILE, PlSqlParserSECUREFILE: + { + p.SetState(15457) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15458) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCHUNK || _la == PlSqlParserCOMPRESS || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&4398046511107) != 0) || _la == PlSqlParserENABLE || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserRETENTION || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(15459) + p.Lob_storage_parameters() + } + + p.SetState(15464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15465) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15468) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2069, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(15470) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15471) + p.Lob_item() + } + { + p.SetState(15472) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15473) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15474) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2071, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15475) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(15476) + p.Lob_segname() + } + + case 3: + { + p.SetState(15477) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCHUNK || _la == PlSqlParserCOMPRESS || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&4398046511107) != 0) || _la == PlSqlParserENABLE || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserRETENTION || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(15478) + p.Lob_storage_parameters() + } + + p.SetState(15483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15484) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15487) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2072, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_lob_storage_clauseContext is an interface to support dynamic dispatch. +type IModify_lob_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Lob_item() ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Modify_lob_parameters() IModify_lob_parametersContext + + // IsModify_lob_storage_clauseContext differentiates from other interfaces. + IsModify_lob_storage_clauseContext() +} + +type Modify_lob_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_lob_storage_clauseContext() *Modify_lob_storage_clauseContext { + var p = new(Modify_lob_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause + return p +} + +func InitEmptyModify_lob_storage_clauseContext(p *Modify_lob_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause +} + +func (*Modify_lob_storage_clauseContext) IsModify_lob_storage_clauseContext() {} + +func NewModify_lob_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_lob_storage_clauseContext { + var p = new(Modify_lob_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause + + return p +} + +func (s *Modify_lob_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_lob_storage_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_lob_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Modify_lob_storage_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Modify_lob_storage_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Modify_lob_storage_clauseContext) Lob_item() ILob_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Modify_lob_storage_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Modify_lob_storage_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Modify_lob_storage_clauseContext) Modify_lob_parameters() IModify_lob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_parametersContext) +} + +func (s *Modify_lob_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_lob_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_lob_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_lob_storage_clause(s) + } +} + +func (s *Modify_lob_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_lob_storage_clause(s) + } +} + +func (p *PlSqlParser) Modify_lob_storage_clause() (localctx IModify_lob_storage_clauseContext) { + localctx = NewModify_lob_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1642, PlSqlParserRULE_modify_lob_storage_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15491) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15492) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15493) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15494) + p.Lob_item() + } + { + p.SetState(15495) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15496) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15497) + p.Modify_lob_parameters() + } + { + p.SetState(15498) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_lob_parametersContext is an interface to support dynamic dispatch. +type IModify_lob_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllREBUILD() []antlr.TerminalNode + REBUILD(i int) antlr.TerminalNode + AllFREEPOOLS() []antlr.TerminalNode + FREEPOOLS(i int) antlr.TerminalNode + AllLob_retention_clause() []ILob_retention_clauseContext + Lob_retention_clause(i int) ILob_retention_clauseContext + AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext + Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext + AllLob_compression_clause() []ILob_compression_clauseContext + Lob_compression_clause(i int) ILob_compression_clauseContext + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllEncryption_spec() []IEncryption_specContext + Encryption_spec(i int) IEncryption_specContext + AllDECRYPT() []antlr.TerminalNode + DECRYPT(i int) antlr.TerminalNode + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllPCTVERSION() []antlr.TerminalNode + PCTVERSION(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllREADS() []antlr.TerminalNode + READS(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsModify_lob_parametersContext differentiates from other interfaces. + IsModify_lob_parametersContext() +} + +type Modify_lob_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_lob_parametersContext() *Modify_lob_parametersContext { + var p = new(Modify_lob_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters + return p +} + +func InitEmptyModify_lob_parametersContext(p *Modify_lob_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters +} + +func (*Modify_lob_parametersContext) IsModify_lob_parametersContext() {} + +func NewModify_lob_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_lob_parametersContext { + var p = new(Modify_lob_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters + + return p +} + +func (s *Modify_lob_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_lob_parametersContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Modify_lob_parametersContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Modify_lob_parametersContext) AllREBUILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREBUILD) +} + +func (s *Modify_lob_parametersContext) REBUILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, i) +} + +func (s *Modify_lob_parametersContext) AllFREEPOOLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREEPOOLS) +} + +func (s *Modify_lob_parametersContext) FREEPOOLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, i) +} + +func (s *Modify_lob_parametersContext) AllLob_retention_clause() []ILob_retention_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_retention_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_retention_clauseContext); ok { + tst[i] = t.(ILob_retention_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_retention_clause(i int) ILob_retention_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_retention_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_deduplicate_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_deduplicate_clauseContext); ok { + tst[i] = t.(ILob_deduplicate_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_deduplicate_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllLob_compression_clause() []ILob_compression_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_compression_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_compression_clauseContext); ok { + tst[i] = t.(ILob_compression_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_compression_clause(i int) ILob_compression_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_compression_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Modify_lob_parametersContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Modify_lob_parametersContext) AllEncryption_spec() []IEncryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEncryption_specContext); ok { + len++ + } + } + + tst := make([]IEncryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEncryption_specContext); ok { + tst[i] = t.(IEncryption_specContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Encryption_spec(i int) IEncryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_lob_parametersContext) AllDECRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDECRYPT) +} + +func (s *Modify_lob_parametersContext) DECRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, i) +} + +func (s *Modify_lob_parametersContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Modify_lob_parametersContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Modify_lob_parametersContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllPCTVERSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTVERSION) +} + +func (s *Modify_lob_parametersContext) PCTVERSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, i) +} + +func (s *Modify_lob_parametersContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Modify_lob_parametersContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Modify_lob_parametersContext) AllREADS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREADS) +} + +func (s *Modify_lob_parametersContext) READS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, i) +} + +func (s *Modify_lob_parametersContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_lob_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_lob_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_lob_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_lob_parameters(s) + } +} + +func (s *Modify_lob_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_lob_parameters(s) + } +} + +func (p *PlSqlParser) Modify_lob_parameters() (localctx IModify_lob_parametersContext) { + localctx = NewModify_lob_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1644, PlSqlParserRULE_modify_lob_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCACHE || _la == PlSqlParserCOMPRESS || ((int64((_la-377)) & ^0x3f) == 0 && ((int64(1)<<(_la-377))&3073) != 0) || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserREBUILD || _la == PlSqlParserRETENTION || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE { + p.SetState(15524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2076, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15500) + p.Storage_clause() + } + + case 2: + { + p.SetState(15501) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFREEPOOLS || _la == PlSqlParserPCTVERSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15502) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15503) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15504) + p.Match(PlSqlParserFREEPOOLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(15505) + p.Lob_retention_clause() + } + + case 5: + { + p.SetState(15506) + p.Lob_deduplicate_clause() + } + + case 6: + { + p.SetState(15507) + p.Lob_compression_clause() + } + + case 7: + { + p.SetState(15508) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15509) + p.Encryption_spec() + } + + case 8: + { + p.SetState(15510) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + { + p.SetState(15511) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.SetState(15516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2074, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15512) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(15513) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15514) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15515) + p.Match(PlSqlParserREADS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING { + { + p.SetState(15518) + p.Logging_clause() + } + + } + + case 11: + { + p.SetState(15521) + p.Allocate_extent_clause() + } + + case 12: + { + p.SetState(15522) + p.Shrink_clause() + } + + case 13: + { + p.SetState(15523) + p.Deallocate_unused_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_parametersContext is an interface to support dynamic dispatch. +type ILob_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSTORAGE() []antlr.TerminalNode + STORAGE(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllCHUNK() []antlr.TerminalNode + CHUNK(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllPCTVERSION() []antlr.TerminalNode + PCTVERSION(i int) antlr.TerminalNode + AllFREEPOOLS() []antlr.TerminalNode + FREEPOOLS(i int) antlr.TerminalNode + AllLob_retention_clause() []ILob_retention_clauseContext + Lob_retention_clause(i int) ILob_retention_clauseContext + AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext + Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext + AllLob_compression_clause() []ILob_compression_clauseContext + Lob_compression_clause(i int) ILob_compression_clauseContext + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllEncryption_spec() []IEncryption_specContext + Encryption_spec(i int) IEncryption_specContext + AllDECRYPT() []antlr.TerminalNode + DECRYPT(i int) antlr.TerminalNode + AllENABLE() []antlr.TerminalNode + ENABLE(i int) antlr.TerminalNode + AllDISABLE() []antlr.TerminalNode + DISABLE(i int) antlr.TerminalNode + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllREADS() []antlr.TerminalNode + READS(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsLob_parametersContext differentiates from other interfaces. + IsLob_parametersContext() +} + +type Lob_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_parametersContext() *Lob_parametersContext { + var p = new(Lob_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_parameters + return p +} + +func InitEmptyLob_parametersContext(p *Lob_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_parameters +} + +func (*Lob_parametersContext) IsLob_parametersContext() {} + +func NewLob_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_parametersContext { + var p = new(Lob_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_parameters + + return p +} + +func (s *Lob_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_parametersContext) AllSTORAGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORAGE) +} + +func (s *Lob_parametersContext) STORAGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, i) +} + +func (s *Lob_parametersContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Lob_parametersContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Lob_parametersContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Lob_parametersContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Lob_parametersContext) AllCHUNK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHUNK) +} + +func (s *Lob_parametersContext) CHUNK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHUNK, i) +} + +func (s *Lob_parametersContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Lob_parametersContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Lob_parametersContext) AllPCTVERSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTVERSION) +} + +func (s *Lob_parametersContext) PCTVERSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, i) +} + +func (s *Lob_parametersContext) AllFREEPOOLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREEPOOLS) +} + +func (s *Lob_parametersContext) FREEPOOLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, i) +} + +func (s *Lob_parametersContext) AllLob_retention_clause() []ILob_retention_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_retention_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_retention_clauseContext); ok { + tst[i] = t.(ILob_retention_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_retention_clause(i int) ILob_retention_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_retention_clauseContext) +} + +func (s *Lob_parametersContext) AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_deduplicate_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_deduplicate_clauseContext); ok { + tst[i] = t.(ILob_deduplicate_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_deduplicate_clauseContext) +} + +func (s *Lob_parametersContext) AllLob_compression_clause() []ILob_compression_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_compression_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_compression_clauseContext); ok { + tst[i] = t.(ILob_compression_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_compression_clause(i int) ILob_compression_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_compression_clauseContext) +} + +func (s *Lob_parametersContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Lob_parametersContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Lob_parametersContext) AllEncryption_spec() []IEncryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEncryption_specContext); ok { + len++ + } + } + + tst := make([]IEncryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEncryption_specContext); ok { + tst[i] = t.(IEncryption_specContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Encryption_spec(i int) IEncryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Lob_parametersContext) AllDECRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDECRYPT) +} + +func (s *Lob_parametersContext) DECRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, i) +} + +func (s *Lob_parametersContext) AllENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENABLE) +} + +func (s *Lob_parametersContext) ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, i) +} + +func (s *Lob_parametersContext) AllDISABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISABLE) +} + +func (s *Lob_parametersContext) DISABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, i) +} + +func (s *Lob_parametersContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Lob_parametersContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Lob_parametersContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Lob_parametersContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Lob_parametersContext) AllREADS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREADS) +} + +func (s *Lob_parametersContext) READS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, i) +} + +func (s *Lob_parametersContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Lob_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_parameters(s) + } +} + +func (s *Lob_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_parameters(s) + } +} + +func (p *PlSqlParser) Lob_parameters() (localctx ILob_parametersContext) { + localctx = NewLob_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1646, PlSqlParserRULE_lob_parameters) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(15528) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15529) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15530) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15531) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHUNK: + { + p.SetState(15532) + p.Match(PlSqlParserCHUNK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15533) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPCTVERSION: + { + p.SetState(15534) + p.Match(PlSqlParserPCTVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15535) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREEPOOLS: + { + p.SetState(15536) + p.Match(PlSqlParserFREEPOOLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15537) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRETENTION: + { + p.SetState(15538) + p.Lob_retention_clause() + } + + case PlSqlParserDEDUPLICATE, PlSqlParserKEEP_DUPLICATES: + { + p.SetState(15539) + p.Lob_deduplicate_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(15540) + p.Lob_compression_clause() + } + + case PlSqlParserENCRYPT: + { + p.SetState(15541) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15542) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(15543) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + p.SetState(15548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2078, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15544) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(15545) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15546) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15547) + p.Match(PlSqlParserREADS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING { + { + p.SetState(15550) + p.Logging_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15555) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2081, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_deduplicate_clauseContext is an interface to support dynamic dispatch. +type ILob_deduplicate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEDUPLICATE() antlr.TerminalNode + KEEP_DUPLICATES() antlr.TerminalNode + + // IsLob_deduplicate_clauseContext differentiates from other interfaces. + IsLob_deduplicate_clauseContext() +} + +type Lob_deduplicate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_deduplicate_clauseContext() *Lob_deduplicate_clauseContext { + var p = new(Lob_deduplicate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause + return p +} + +func InitEmptyLob_deduplicate_clauseContext(p *Lob_deduplicate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause +} + +func (*Lob_deduplicate_clauseContext) IsLob_deduplicate_clauseContext() {} + +func NewLob_deduplicate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_deduplicate_clauseContext { + var p = new(Lob_deduplicate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause + + return p +} + +func (s *Lob_deduplicate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_deduplicate_clauseContext) DEDUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEDUPLICATE, 0) +} + +func (s *Lob_deduplicate_clauseContext) KEEP_DUPLICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP_DUPLICATES, 0) +} + +func (s *Lob_deduplicate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_deduplicate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_deduplicate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_deduplicate_clause(s) + } +} + +func (s *Lob_deduplicate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_deduplicate_clause(s) + } +} + +func (p *PlSqlParser) Lob_deduplicate_clause() (localctx ILob_deduplicate_clauseContext) { + localctx = NewLob_deduplicate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1648, PlSqlParserRULE_lob_deduplicate_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15557) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEDUPLICATE || _la == PlSqlParserKEEP_DUPLICATES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_compression_clauseContext is an interface to support dynamic dispatch. +type ILob_compression_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOCOMPRESS() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + HIGH() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + LOW() antlr.TerminalNode + + // IsLob_compression_clauseContext differentiates from other interfaces. + IsLob_compression_clauseContext() +} + +type Lob_compression_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_compression_clauseContext() *Lob_compression_clauseContext { + var p = new(Lob_compression_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_compression_clause + return p +} + +func InitEmptyLob_compression_clauseContext(p *Lob_compression_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_compression_clause +} + +func (*Lob_compression_clauseContext) IsLob_compression_clauseContext() {} + +func NewLob_compression_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_compression_clauseContext { + var p = new(Lob_compression_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_compression_clause + + return p +} + +func (s *Lob_compression_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_compression_clauseContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Lob_compression_clauseContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Lob_compression_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Lob_compression_clauseContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Lob_compression_clauseContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Lob_compression_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_compression_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_compression_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_compression_clause(s) + } +} + +func (s *Lob_compression_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_compression_clause(s) + } +} + +func (p *PlSqlParser) Lob_compression_clause() (localctx ILob_compression_clauseContext) { + localctx = NewLob_compression_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1650, PlSqlParserRULE_lob_compression_clause) + var _la int + + p.SetState(15564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15559) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15560) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM { + { + p.SetState(15561) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_retention_clauseContext is an interface to support dynamic dispatch. +type ILob_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + MAX() antlr.TerminalNode + MIN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AUTO() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsLob_retention_clauseContext differentiates from other interfaces. + IsLob_retention_clauseContext() +} + +type Lob_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_retention_clauseContext() *Lob_retention_clauseContext { + var p = new(Lob_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_retention_clause + return p +} + +func InitEmptyLob_retention_clauseContext(p *Lob_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_retention_clause +} + +func (*Lob_retention_clauseContext) IsLob_retention_clauseContext() {} + +func NewLob_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_retention_clauseContext { + var p = new(Lob_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_retention_clause + + return p +} + +func (s *Lob_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_retention_clauseContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Lob_retention_clauseContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Lob_retention_clauseContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Lob_retention_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Lob_retention_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Lob_retention_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Lob_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_retention_clause(s) + } +} + +func (s *Lob_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_retention_clause(s) + } +} + +func (p *PlSqlParser) Lob_retention_clause() (localctx ILob_retention_clauseContext) { + localctx = NewLob_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1652, PlSqlParserRULE_lob_retention_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15566) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAX: + { + p.SetState(15567) + p.Match(PlSqlParserMAX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMIN: + { + p.SetState(15568) + p.Match(PlSqlParserMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15569) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTO: + { + p.SetState(15570) + p.Match(PlSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(15571) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOCATE, PlSqlParserCACHE, PlSqlParserCHUNK, PlSqlParserCOMPRESS, PlSqlParserDEALLOCATE, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserFREEPOOLS, PlSqlParserKEEP_DUPLICATES, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserPCTVERSION, PlSqlParserREBUILD, PlSqlParserRETENTION, PlSqlParserSHRINK, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserRIGHT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEncryption_specContext is an interface to support dynamic dispatch. +type IEncryption_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + REGULAR_ID() antlr.TerminalNode + SALT() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsEncryption_specContext differentiates from other interfaces. + IsEncryption_specContext() +} + +type Encryption_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEncryption_specContext() *Encryption_specContext { + var p = new(Encryption_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_encryption_spec + return p +} + +func InitEmptyEncryption_specContext(p *Encryption_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_encryption_spec +} + +func (*Encryption_specContext) IsEncryption_specContext() {} + +func NewEncryption_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Encryption_specContext { + var p = new(Encryption_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_encryption_spec + + return p +} + +func (s *Encryption_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Encryption_specContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Encryption_specContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Encryption_specContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Encryption_specContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Encryption_specContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Encryption_specContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Encryption_specContext) SALT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSALT, 0) +} + +func (s *Encryption_specContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Encryption_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Encryption_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Encryption_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEncryption_spec(s) + } +} + +func (s *Encryption_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEncryption_spec(s) + } +} + +func (p *PlSqlParser) Encryption_spec() (localctx IEncryption_specContext) { + localctx = NewEncryption_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1654, PlSqlParserRULE_encryption_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(15574) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15575) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(15578) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15579) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15580) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(15583) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserSALT { + p.SetState(15587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(15586) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15589) + p.Match(PlSqlParserSALT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespaceContext is an interface to support dynamic dispatch. +type ITablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsTablespaceContext differentiates from other interfaces. + IsTablespaceContext() +} + +type TablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespaceContext() *TablespaceContext { + var p = new(TablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace + return p +} + +func InitEmptyTablespaceContext(p *TablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace +} + +func (*TablespaceContext) IsTablespaceContext() {} + +func NewTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablespaceContext { + var p = new(TablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace + + return p +} + +func (s *TablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *TablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace(s) + } +} + +func (s *TablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace(s) + } +} + +func (p *PlSqlParser) Tablespace() (localctx ITablespaceContext) { + localctx = NewTablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1656, PlSqlParserRULE_tablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15592) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_itemContext is an interface to support dynamic dispatch. +type IVarray_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsVarray_itemContext differentiates from other interfaces. + IsVarray_itemContext() +} + +type Varray_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_itemContext() *Varray_itemContext { + var p = new(Varray_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_item + return p +} + +func InitEmptyVarray_itemContext(p *Varray_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_item +} + +func (*Varray_itemContext) IsVarray_itemContext() {} + +func NewVarray_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_itemContext { + var p = new(Varray_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_item + + return p +} + +func (s *Varray_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Varray_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Varray_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Varray_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Varray_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_item(s) + } +} + +func (s *Varray_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_item(s) + } +} + +func (p *PlSqlParser) Varray_item() (localctx IVarray_itemContext) { + localctx = NewVarray_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1658, PlSqlParserRULE_varray_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(15597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2090, p.GetParserRuleContext()) == 1 { + { + p.SetState(15594) + p.Id_expression() + } + { + p.SetState(15595) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15602) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2091, p.GetParserRuleContext()) == 1 { + { + p.SetState(15599) + p.Id_expression() + } + { + p.SetState(15600) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15604) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_propertiesContext is an interface to support dynamic dispatch. +type IColumn_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllObject_type_col_properties() []IObject_type_col_propertiesContext + Object_type_col_properties(i int) IObject_type_col_propertiesContext + AllNested_table_col_properties() []INested_table_col_propertiesContext + Nested_table_col_properties(i int) INested_table_col_propertiesContext + AllXmltype_column_properties() []IXmltype_column_propertiesContext + Xmltype_column_properties(i int) IXmltype_column_propertiesContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_partition_storage() []ILob_partition_storageContext + Lob_partition_storage(i int) ILob_partition_storageContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_propertiesContext differentiates from other interfaces. + IsColumn_propertiesContext() +} + +type Column_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_propertiesContext() *Column_propertiesContext { + var p = new(Column_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_properties + return p +} + +func InitEmptyColumn_propertiesContext(p *Column_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_properties +} + +func (*Column_propertiesContext) IsColumn_propertiesContext() {} + +func NewColumn_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_propertiesContext { + var p = new(Column_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_properties + + return p +} + +func (s *Column_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_propertiesContext) AllObject_type_col_properties() []IObject_type_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_type_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_type_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_type_col_propertiesContext); ok { + tst[i] = t.(IObject_type_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Object_type_col_properties(i int) IObject_type_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllNested_table_col_properties() []INested_table_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + len++ + } + } + + tst := make([]INested_table_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INested_table_col_propertiesContext); ok { + tst[i] = t.(INested_table_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Nested_table_col_properties(i int) INested_table_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INested_table_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllXmltype_column_properties() []IXmltype_column_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXmltype_column_propertiesContext); ok { + len++ + } + } + + tst := make([]IXmltype_column_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXmltype_column_propertiesContext); ok { + tst[i] = t.(IXmltype_column_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Xmltype_column_properties(i int) IXmltype_column_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_column_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_column_propertiesContext) +} + +func (s *Column_propertiesContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Column_propertiesContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Column_propertiesContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Column_propertiesContext) AllLob_partition_storage() []ILob_partition_storageContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_partition_storageContext); ok { + len++ + } + } + + tst := make([]ILob_partition_storageContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_partition_storageContext); ok { + tst[i] = t.(ILob_partition_storageContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Lob_partition_storage(i int) ILob_partition_storageContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_partition_storageContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_partition_storageContext) +} + +func (s *Column_propertiesContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Column_propertiesContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Column_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_properties(s) + } +} + +func (s *Column_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_properties(s) + } +} + +func (p *PlSqlParser) Column_properties() (localctx IColumn_propertiesContext) { + localctx = NewColumn_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1660, PlSqlParserRULE_column_properties) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(15606) + p.Object_type_col_properties() + } + + case PlSqlParserNESTED: + { + p.SetState(15607) + p.Nested_table_col_properties() + } + + case PlSqlParserLOB, PlSqlParserVARRAY: + p.SetState(15610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARRAY: + { + p.SetState(15608) + p.Varray_col_properties() + } + + case PlSqlParserLOB: + { + p.SetState(15609) + p.Lob_storage_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15623) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2094, p.GetParserRuleContext()) == 1 { + { + p.SetState(15612) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15613) + p.Lob_partition_storage() + } + p.SetState(15618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15614) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15615) + p.Lob_partition_storage() + } + + p.SetState(15620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15621) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserXMLTYPE: + { + p.SetState(15625) + p.Xmltype_column_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15628) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2096, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_partition_storageContext is an interface to support dynamic dispatch. +type ILob_partition_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_item() []ILob_itemContext + Lob_item(i int) ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + COMMA() antlr.TerminalNode + AllLob_storage_parameters() []ILob_storage_parametersContext + Lob_storage_parameters(i int) ILob_storage_parametersContext + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + + // IsLob_partition_storageContext differentiates from other interfaces. + IsLob_partition_storageContext() +} + +type Lob_partition_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_partition_storageContext() *Lob_partition_storageContext { + var p = new(Lob_partition_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partition_storage + return p +} + +func InitEmptyLob_partition_storageContext(p *Lob_partition_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partition_storage +} + +func (*Lob_partition_storageContext) IsLob_partition_storageContext() {} + +func NewLob_partition_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_partition_storageContext { + var p = new(Lob_partition_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_partition_storage + + return p +} + +func (s *Lob_partition_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_partition_storageContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_partition_storageContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_partition_storageContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_partition_storageContext) AllLob_item() []ILob_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_itemContext); ok { + len++ + } + } + + tst := make([]ILob_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_itemContext); ok { + tst[i] = t.(ILob_itemContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_item(i int) ILob_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_partition_storageContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_partition_storageContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_partition_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_partition_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_partition_storageContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Lob_partition_storageContext) AllLob_storage_parameters() []ILob_storage_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + len++ + } + } + + tst := make([]ILob_storage_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_parametersContext); ok { + tst[i] = t.(ILob_storage_parametersContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_storage_parameters(i int) ILob_storage_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Lob_partition_storageContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_partition_storageContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Lob_partition_storageContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Lob_partition_storageContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Lob_partition_storageContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Lob_partition_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_partition_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_partition_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_partition_storage(s) + } +} + +func (s *Lob_partition_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_partition_storage(s) + } +} + +func (p *PlSqlParser) Lob_partition_storage() (localctx ILob_partition_storageContext) { + localctx = NewLob_partition_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1662, PlSqlParserRULE_lob_partition_storage) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15630) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2101, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15631) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15632) + p.Lob_item() + } + + { + p.SetState(15633) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15634) + p.Lob_item() + } + + { + p.SetState(15636) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15637) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15638) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE || _la == PlSqlParserLEFT_PAREN { + p.SetState(15644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBASICFILE, PlSqlParserSECUREFILE: + { + p.SetState(15639) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15640) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15641) + p.Lob_storage_parameters() + } + { + p.SetState(15642) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(15648) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15649) + p.Lob_item() + } + { + p.SetState(15650) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15651) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15652) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372093473) != 0) { + p.SetState(15659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2099, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15653) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(15654) + p.Lob_segname() + } + + case 3: + { + p.SetState(15655) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15656) + p.Lob_storage_parameters() + } + { + p.SetState(15657) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPeriod_definitionContext is an interface to support dynamic dispatch. +type IPeriod_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PERIOD() antlr.TerminalNode + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + Start_time_column() IStart_time_columnContext + COMMA() antlr.TerminalNode + End_time_column() IEnd_time_columnContext + RIGHT_PAREN() antlr.TerminalNode + + // IsPeriod_definitionContext differentiates from other interfaces. + IsPeriod_definitionContext() +} + +type Period_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPeriod_definitionContext() *Period_definitionContext { + var p = new(Period_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_period_definition + return p +} + +func InitEmptyPeriod_definitionContext(p *Period_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_period_definition +} + +func (*Period_definitionContext) IsPeriod_definitionContext() {} + +func NewPeriod_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Period_definitionContext { + var p = new(Period_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_period_definition + + return p +} + +func (s *Period_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Period_definitionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Period_definitionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Period_definitionContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Period_definitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Period_definitionContext) Start_time_column() IStart_time_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_time_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_time_columnContext) +} + +func (s *Period_definitionContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Period_definitionContext) End_time_column() IEnd_time_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnd_time_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnd_time_columnContext) +} + +func (s *Period_definitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Period_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Period_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Period_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPeriod_definition(s) + } +} + +func (s *Period_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPeriod_definition(s) + } +} + +func (p *PlSqlParser) Period_definition() (localctx IPeriod_definitionContext) { + localctx = NewPeriod_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1664, PlSqlParserRULE_period_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15665) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(15666) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15667) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15668) + p.Column_name() + } + p.SetState(15675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15669) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15670) + p.Start_time_column() + } + { + p.SetState(15671) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15672) + p.End_time_column() + } + { + p.SetState(15673) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_time_columnContext is an interface to support dynamic dispatch. +type IStart_time_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsStart_time_columnContext differentiates from other interfaces. + IsStart_time_columnContext() +} + +type Start_time_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_time_columnContext() *Start_time_columnContext { + var p = new(Start_time_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_time_column + return p +} + +func InitEmptyStart_time_columnContext(p *Start_time_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_time_column +} + +func (*Start_time_columnContext) IsStart_time_columnContext() {} + +func NewStart_time_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_time_columnContext { + var p = new(Start_time_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_time_column + + return p +} + +func (s *Start_time_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_time_columnContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Start_time_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_time_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_time_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_time_column(s) + } +} + +func (s *Start_time_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_time_column(s) + } +} + +func (p *PlSqlParser) Start_time_column() (localctx IStart_time_columnContext) { + localctx = NewStart_time_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1666, PlSqlParserRULE_start_time_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15677) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnd_time_columnContext is an interface to support dynamic dispatch. +type IEnd_time_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsEnd_time_columnContext differentiates from other interfaces. + IsEnd_time_columnContext() +} + +type End_time_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnd_time_columnContext() *End_time_columnContext { + var p = new(End_time_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_end_time_column + return p +} + +func InitEmptyEnd_time_columnContext(p *End_time_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_end_time_column +} + +func (*End_time_columnContext) IsEnd_time_columnContext() {} + +func NewEnd_time_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *End_time_columnContext { + var p = new(End_time_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_end_time_column + + return p +} + +func (s *End_time_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *End_time_columnContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *End_time_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *End_time_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *End_time_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnd_time_column(s) + } +} + +func (s *End_time_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnd_time_column(s) + } +} + +func (p *PlSqlParser) End_time_column() (localctx IEnd_time_columnContext) { + localctx = NewEnd_time_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1668, PlSqlParserRULE_end_time_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15679) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_definitionContext is an interface to support dynamic dispatch. +type IColumn_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + SORT() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + Identity_clause() IIdentity_clauseContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + Inline_ref_constraint() IInline_ref_constraintContext + Annotations_clause() IAnnotations_clauseContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + Datatype() IDatatypeContext + Type_name() IType_nameContext + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsColumn_definitionContext differentiates from other interfaces. + IsColumn_definitionContext() +} + +type Column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_definitionContext() *Column_definitionContext { + var p = new(Column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_definition + return p +} + +func InitEmptyColumn_definitionContext(p *Column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_definition +} + +func (*Column_definitionContext) IsColumn_definitionContext() {} + +func NewColumn_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_definitionContext { + var p = new(Column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_definition + + return p +} + +func (s *Column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_definitionContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_definitionContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Column_definitionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_definitionContext) Identity_clause() IIdentity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_clauseContext) +} + +func (s *Column_definitionContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Column_definitionContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Column_definitionContext) Inline_ref_constraint() IInline_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_ref_constraintContext) +} + +func (s *Column_definitionContext) Annotations_clause() IAnnotations_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_clauseContext) +} + +func (s *Column_definitionContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Column_definitionContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Column_definitionContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Column_definitionContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Column_definitionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Column_definitionContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *Column_definitionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Column_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Column_definitionContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Column_definitionContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_definition(s) + } +} + +func (s *Column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_definition(s) + } +} + +func (p *PlSqlParser) Column_definition() (localctx IColumn_definitionContext) { + localctx = NewColumn_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1670, PlSqlParserRULE_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15681) + p.Column_name() + } + p.SetState(15690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2105, p.GetParserRuleContext()) == 1 { + p.SetState(15684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2103, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15682) + p.Datatype() + } + + case 2: + { + p.SetState(15683) + p.Type_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLLATE { + { + p.SetState(15686) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15687) + p.Column_collation_name() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(15692) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE { + { + p.SetState(15695) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(15698) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15701) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2108, p.GetParserRuleContext()) == 1 { + { + p.SetState(15699) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15700) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15703) + p.Expression() + } + + case PlSqlParserGENERATED: + { + p.SetState(15704) + p.Identity_clause() + } + + case PlSqlParserEOF, PlSqlParserADD, PlSqlParserANNOTATIONS, PlSqlParserCHECK, PlSqlParserCOLUMN, PlSqlParserCONSTRAINT, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserLOB, PlSqlParserMODIFY, PlSqlParserNESTED, PlSqlParserNOT, PlSqlParserNULL_, PlSqlParserPRIMARY, PlSqlParserREFERENCES, PlSqlParserRENAME, PlSqlParserSCOPE, PlSqlParserSET, PlSqlParserUNIQUE, PlSqlParserVARRAY, PlSqlParserWITH, PlSqlParserXMLTYPE, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(15709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPT { + { + p.SetState(15707) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15708) + p.Encryption_spec() + } + + } + p.SetState(15717) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2112, p.GetParserRuleContext()) == 1 { + p.SetState(15712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(15711) + p.Inline_constraint() + } + + p.SetState(15714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2112, p.GetParserRuleContext()) == 2 { + { + p.SetState(15716) + p.Inline_ref_constraint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANNOTATIONS { + { + p.SetState(15719) + p.Annotations_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_collation_nameContext is an interface to support dynamic dispatch. +type IColumn_collation_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsColumn_collation_nameContext differentiates from other interfaces. + IsColumn_collation_nameContext() +} + +type Column_collation_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_collation_nameContext() *Column_collation_nameContext { + var p = new(Column_collation_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_collation_name + return p +} + +func InitEmptyColumn_collation_nameContext(p *Column_collation_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_collation_name +} + +func (*Column_collation_nameContext) IsColumn_collation_nameContext() {} + +func NewColumn_collation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_collation_nameContext { + var p = new(Column_collation_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_collation_name + + return p +} + +func (s *Column_collation_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_collation_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Column_collation_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_collation_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_collation_name(s) + } +} + +func (s *Column_collation_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_collation_name(s) + } +} + +func (p *PlSqlParser) Column_collation_name() (localctx IColumn_collation_nameContext) { + localctx = NewColumn_collation_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1672, PlSqlParserRULE_column_collation_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15722) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_clauseContext is an interface to support dynamic dispatch. +type IIdentity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GENERATED() antlr.TerminalNode + AS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + BY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Identity_options_parentheses() IIdentity_options_parenthesesContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsIdentity_clauseContext differentiates from other interfaces. + IsIdentity_clauseContext() +} + +type Identity_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_clauseContext() *Identity_clauseContext { + var p = new(Identity_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_clause + return p +} + +func InitEmptyIdentity_clauseContext(p *Identity_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_clause +} + +func (*Identity_clauseContext) IsIdentity_clauseContext() {} + +func NewIdentity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_clauseContext { + var p = new(Identity_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_clause + + return p +} + +func (s *Identity_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_clauseContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Identity_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Identity_clauseContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Identity_clauseContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Identity_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identity_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Identity_clauseContext) Identity_options_parentheses() IIdentity_options_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_options_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_options_parenthesesContext) +} + +func (s *Identity_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Identity_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Identity_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_clause(s) + } +} + +func (s *Identity_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_clause(s) + } +} + +func (p *PlSqlParser) Identity_clause() (localctx IIdentity_clauseContext) { + localctx = NewIdentity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1674, PlSqlParserRULE_identity_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15724) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALWAYS: + { + p.SetState(15725) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBY: + { + p.SetState(15726) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15727) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15728) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15729) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAS: + + default: + } + { + p.SetState(15734) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15735) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserNOSCALE || _la == PlSqlParserORDER || _la == PlSqlParserSCALE || _la == PlSqlParserSTART || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15736) + p.Identity_options_parentheses() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_options_parenthesesContext is an interface to support dynamic dispatch. +type IIdentity_options_parenthesesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentity_options() []IIdentity_optionsContext + Identity_options(i int) IIdentity_optionsContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsIdentity_options_parenthesesContext differentiates from other interfaces. + IsIdentity_options_parenthesesContext() +} + +type Identity_options_parenthesesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_options_parenthesesContext() *Identity_options_parenthesesContext { + var p = new(Identity_options_parenthesesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses + return p +} + +func InitEmptyIdentity_options_parenthesesContext(p *Identity_options_parenthesesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses +} + +func (*Identity_options_parenthesesContext) IsIdentity_options_parenthesesContext() {} + +func NewIdentity_options_parenthesesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_options_parenthesesContext { + var p = new(Identity_options_parenthesesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses + + return p +} + +func (s *Identity_options_parenthesesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_options_parenthesesContext) AllIdentity_options() []IIdentity_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentity_optionsContext); ok { + len++ + } + } + + tst := make([]IIdentity_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentity_optionsContext); ok { + tst[i] = t.(IIdentity_optionsContext) + i++ + } + } + + return tst +} + +func (s *Identity_options_parenthesesContext) Identity_options(i int) IIdentity_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_optionsContext) +} + +func (s *Identity_options_parenthesesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Identity_options_parenthesesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Identity_options_parenthesesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_options_parenthesesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_options_parenthesesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_options_parentheses(s) + } +} + +func (s *Identity_options_parenthesesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_options_parentheses(s) + } +} + +func (p *PlSqlParser) Identity_options_parentheses() (localctx IIdentity_options_parenthesesContext) { + localctx = NewIdentity_options_parenthesesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1676, PlSqlParserRULE_identity_options_parentheses) + var _la int + + p.SetState(15752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCACHE, PlSqlParserCYCLE, PlSqlParserINCREMENT, PlSqlParserKEEP, PlSqlParserMAXVALUE, PlSqlParserMINVALUE, PlSqlParserNOCACHE, PlSqlParserNOCYCLE, PlSqlParserNOKEEP, PlSqlParserNOMAXVALUE, PlSqlParserNOMINVALUE, PlSqlParserNOORDER, PlSqlParserNOSCALE, PlSqlParserORDER, PlSqlParserSCALE, PlSqlParserSTART: + p.EnterOuterAlt(localctx, 1) + p.SetState(15740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserNOSCALE || _la == PlSqlParserORDER || _la == PlSqlParserSCALE || _la == PlSqlParserSTART { + { + p.SetState(15739) + p.Identity_options() + } + + p.SetState(15742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15744) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserNOSCALE || _la == PlSqlParserORDER || _la == PlSqlParserSCALE || _la == PlSqlParserSTART { + { + p.SetState(15745) + p.Identity_options() + } + + p.SetState(15748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15750) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_optionsContext is an interface to support dynamic dispatch. +type IIdentity_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + Numeric() INumericContext + LIMIT() antlr.TerminalNode + VALUE() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + ORDER() antlr.TerminalNode + NOORDER() antlr.TerminalNode + SCALE() antlr.TerminalNode + EXTEND() antlr.TerminalNode + NOEXTEND() antlr.TerminalNode + NOSCALE() antlr.TerminalNode + KEEP() antlr.TerminalNode + NOKEEP() antlr.TerminalNode + + // IsIdentity_optionsContext differentiates from other interfaces. + IsIdentity_optionsContext() +} + +type Identity_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_optionsContext() *Identity_optionsContext { + var p = new(Identity_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options + return p +} + +func InitEmptyIdentity_optionsContext(p *Identity_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options +} + +func (*Identity_optionsContext) IsIdentity_optionsContext() {} + +func NewIdentity_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_optionsContext { + var p = new(Identity_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_options + + return p +} + +func (s *Identity_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_optionsContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Identity_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Identity_optionsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Identity_optionsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Identity_optionsContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Identity_optionsContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Identity_optionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identity_optionsContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Identity_optionsContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Identity_optionsContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Identity_optionsContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Identity_optionsContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Identity_optionsContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Identity_optionsContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Identity_optionsContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Identity_optionsContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Identity_optionsContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Identity_optionsContext) SCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, 0) +} + +func (s *Identity_optionsContext) EXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTEND, 0) +} + +func (s *Identity_optionsContext) NOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOEXTEND, 0) +} + +func (s *Identity_optionsContext) NOSCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCALE, 0) +} + +func (s *Identity_optionsContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Identity_optionsContext) NOKEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOKEEP, 0) +} + +func (s *Identity_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_options(s) + } +} + +func (s *Identity_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_options(s) + } +} + +func (p *PlSqlParser) Identity_options() (localctx IIdentity_optionsContext) { + localctx = NewIdentity_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1678, PlSqlParserRULE_identity_options) + var _la int + + p.SetState(15782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15754) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15755) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(15756) + p.Numeric() + } + + case PlSqlParserLIMIT: + { + p.SetState(15757) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15758) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserINCREMENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15761) + p.Match(PlSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15762) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15763) + p.Numeric() + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15764) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15765) + p.Numeric() + } + + case PlSqlParserNOMAXVALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15766) + p.Match(PlSqlParserNOMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(15767) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15768) + p.Numeric() + } + + case PlSqlParserNOMINVALUE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(15769) + p.Match(PlSqlParserNOMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCYCLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(15770) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCYCLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(15771) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(15772) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15773) + p.Numeric() + } + + case PlSqlParserNOCACHE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(15774) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORDER: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(15775) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOORDER: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(15776) + p.Match(PlSqlParserNOORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSCALE: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(15777) + p.Match(PlSqlParserSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15778) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOEXTEND || _la == PlSqlParserEXTEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNOSCALE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(15779) + p.Match(PlSqlParserNOSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserKEEP: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(15780) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOKEEP: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(15781) + p.Match(PlSqlParserNOKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVirtual_column_definitionContext is an interface to support dynamic dispatch. +type IVirtual_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Datatype() IDatatypeContext + Virtual_column_expression() IVirtual_column_expressionContext + VIRTUAL() antlr.TerminalNode + Evaluation_edition_clause() IEvaluation_edition_clauseContext + AllUNUSABLE() []antlr.TerminalNode + UNUSABLE(i int) antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGINNING() antlr.TerminalNode + WITH() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + By_user_for_statistics_clause() IBy_user_for_statistics_clauseContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + AllCURRENT() []antlr.TerminalNode + CURRENT(i int) antlr.TerminalNode + AllEDITION() []antlr.TerminalNode + EDITION(i int) antlr.TerminalNode + AllEdition_name() []IEdition_nameContext + Edition_name(i int) IEdition_nameContext + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + NULL_() antlr.TerminalNode + + // IsVirtual_column_definitionContext differentiates from other interfaces. + IsVirtual_column_definitionContext() +} + +type Virtual_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVirtual_column_definitionContext() *Virtual_column_definitionContext { + var p = new(Virtual_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_definition + return p +} + +func InitEmptyVirtual_column_definitionContext(p *Virtual_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_definition +} + +func (*Virtual_column_definitionContext) IsVirtual_column_definitionContext() {} + +func NewVirtual_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Virtual_column_definitionContext { + var p = new(Virtual_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_virtual_column_definition + + return p +} + +func (s *Virtual_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Virtual_column_definitionContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Virtual_column_definitionContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Virtual_column_definitionContext) Virtual_column_expression() IVirtual_column_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVirtual_column_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVirtual_column_expressionContext) +} + +func (s *Virtual_column_definitionContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Virtual_column_definitionContext) Evaluation_edition_clause() IEvaluation_edition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvaluation_edition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvaluation_edition_clauseContext) +} + +func (s *Virtual_column_definitionContext) AllUNUSABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNUSABLE) +} + +func (s *Virtual_column_definitionContext) UNUSABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, i) +} + +func (s *Virtual_column_definitionContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Virtual_column_definitionContext) BEGINNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGINNING, 0) +} + +func (s *Virtual_column_definitionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Virtual_column_definitionContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Virtual_column_definitionContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Virtual_column_definitionContext) By_user_for_statistics_clause() IBy_user_for_statistics_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBy_user_for_statistics_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBy_user_for_statistics_clauseContext) +} + +func (s *Virtual_column_definitionContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Virtual_column_definitionContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Virtual_column_definitionContext) AllCURRENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT) +} + +func (s *Virtual_column_definitionContext) CURRENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, i) +} + +func (s *Virtual_column_definitionContext) AllEDITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEDITION) +} + +func (s *Virtual_column_definitionContext) EDITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, i) +} + +func (s *Virtual_column_definitionContext) AllEdition_name() []IEdition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEdition_nameContext); ok { + len++ + } + } + + tst := make([]IEdition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEdition_nameContext); ok { + tst[i] = t.(IEdition_nameContext) + i++ + } + } + + return tst +} + +func (s *Virtual_column_definitionContext) Edition_name(i int) IEdition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Virtual_column_definitionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Virtual_column_definitionContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *Virtual_column_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Virtual_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Virtual_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Virtual_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVirtual_column_definition(s) + } +} + +func (s *Virtual_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVirtual_column_definition(s) + } +} + +func (p *PlSqlParser) Virtual_column_definition() (localctx IVirtual_column_definitionContext) { + localctx = NewVirtual_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1680, PlSqlParserRULE_virtual_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15784) + p.Column_name() + } + p.SetState(15790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2123, p.GetParserRuleContext()) == 1 { + { + p.SetState(15785) + p.Datatype() + } + p.SetState(15788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLLATE { + { + p.SetState(15786) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15787) + p.Column_collation_name() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE { + { + p.SetState(15792) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserGENERATED { + { + p.SetState(15795) + p.Virtual_column_expression() + } + + } + p.SetState(15799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVIRTUAL { + { + p.SetState(15798) + p.Match(PlSqlParserVIRTUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEVALUATE { + { + p.SetState(15801) + p.Evaluation_edition_clause() + } + + } + p.SetState(15812) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2129, p.GetParserRuleContext()) == 1 { + { + p.SetState(15804) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15805) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT: + { + p.SetState(15806) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15807) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15808) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15809) + p.Edition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(15814) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15815) + p.Match(PlSqlParserBEGINNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15816) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT, PlSqlParserNULL_: + { + p.SetState(15817) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15818) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15819) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15820) + p.Edition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(15828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(15825) + p.Inline_constraint() + } + + p.SetState(15830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(15832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(15831) + p.By_user_for_statistics_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVirtual_column_expressionContext is an interface to support dynamic dispatch. +type IVirtual_column_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Autogenerated_sequence_definition() IAutogenerated_sequence_definitionContext + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + GENERATED() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + + // IsVirtual_column_expressionContext differentiates from other interfaces. + IsVirtual_column_expressionContext() +} + +type Virtual_column_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVirtual_column_expressionContext() *Virtual_column_expressionContext { + var p = new(Virtual_column_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_expression + return p +} + +func InitEmptyVirtual_column_expressionContext(p *Virtual_column_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_expression +} + +func (*Virtual_column_expressionContext) IsVirtual_column_expressionContext() {} + +func NewVirtual_column_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Virtual_column_expressionContext { + var p = new(Virtual_column_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_virtual_column_expression + + return p +} + +func (s *Virtual_column_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Virtual_column_expressionContext) Autogenerated_sequence_definition() IAutogenerated_sequence_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutogenerated_sequence_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutogenerated_sequence_definitionContext) +} + +func (s *Virtual_column_expressionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Virtual_column_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Virtual_column_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Virtual_column_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Virtual_column_expressionContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Virtual_column_expressionContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Virtual_column_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Virtual_column_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Virtual_column_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVirtual_column_expression(s) + } +} + +func (s *Virtual_column_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVirtual_column_expression(s) + } +} + +func (p *PlSqlParser) Virtual_column_expression() (localctx IVirtual_column_expressionContext) { + localctx = NewVirtual_column_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1682, PlSqlParserRULE_virtual_column_expression) + var _la int + + p.SetState(15846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2136, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15834) + p.Autogenerated_sequence_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(15839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGENERATED { + { + p.SetState(15835) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALWAYS { + { + p.SetState(15836) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(15841) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15842) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15843) + p.Expression() + } + { + p.SetState(15844) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAutogenerated_sequence_definitionContext is an interface to support dynamic dispatch. +type IAutogenerated_sequence_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GENERATED() antlr.TerminalNode + AS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + BY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllSequence_start_clause() []ISequence_start_clauseContext + Sequence_start_clause(i int) ISequence_start_clauseContext + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + + // IsAutogenerated_sequence_definitionContext differentiates from other interfaces. + IsAutogenerated_sequence_definitionContext() +} + +type Autogenerated_sequence_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAutogenerated_sequence_definitionContext() *Autogenerated_sequence_definitionContext { + var p = new(Autogenerated_sequence_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition + return p +} + +func InitEmptyAutogenerated_sequence_definitionContext(p *Autogenerated_sequence_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition +} + +func (*Autogenerated_sequence_definitionContext) IsAutogenerated_sequence_definitionContext() {} + +func NewAutogenerated_sequence_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Autogenerated_sequence_definitionContext { + var p = new(Autogenerated_sequence_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition + + return p +} + +func (s *Autogenerated_sequence_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Autogenerated_sequence_definitionContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Autogenerated_sequence_definitionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Autogenerated_sequence_definitionContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Autogenerated_sequence_definitionContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Autogenerated_sequence_definitionContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Autogenerated_sequence_definitionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Autogenerated_sequence_definitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Autogenerated_sequence_definitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Autogenerated_sequence_definitionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Autogenerated_sequence_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Autogenerated_sequence_definitionContext) AllSequence_start_clause() []ISequence_start_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + len++ + } + } + + tst := make([]ISequence_start_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_start_clauseContext); ok { + tst[i] = t.(ISequence_start_clauseContext) + i++ + } + } + + return tst +} + +func (s *Autogenerated_sequence_definitionContext) Sequence_start_clause(i int) ISequence_start_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_start_clauseContext) +} + +func (s *Autogenerated_sequence_definitionContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Autogenerated_sequence_definitionContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +func (s *Autogenerated_sequence_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Autogenerated_sequence_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Autogenerated_sequence_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAutogenerated_sequence_definition(s) + } +} + +func (s *Autogenerated_sequence_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAutogenerated_sequence_definition(s) + } +} + +func (p *PlSqlParser) Autogenerated_sequence_definition() (localctx IAutogenerated_sequence_definitionContext) { + localctx = NewAutogenerated_sequence_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1684, PlSqlParserRULE_autogenerated_sequence_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15848) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALWAYS: + { + p.SetState(15849) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBY: + { + p.SetState(15850) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15851) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15852) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15853) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAS: + + default: + } + { + p.SetState(15858) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15859) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15860) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserGLOBAL || _la == PlSqlParserINCREMENT || _la == PlSqlParserKEEP || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-1066)) & ^0x3f) == 0 && ((int64(1)<<(_la-1066))&324540648147648513) != 0) || ((int64((_la-1140)) & ^0x3f) == 0 && ((int64(1)<<(_la-1140))&142936511610881) != 0) || _la == PlSqlParserORDER || ((int64((_la-1620)) & ^0x3f) == 0 && ((int64(1)<<(_la-1620))&72198331526283265) != 0) || _la == PlSqlParserSTART { + p.SetState(15863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2139, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15861) + p.Sequence_start_clause() + } + + case 2: + { + p.SetState(15862) + p.Sequence_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15868) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBy_user_for_statistics_clauseContext is an interface to support dynamic dispatch. +type IBy_user_for_statistics_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + USER() antlr.TerminalNode + FOR() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + + // IsBy_user_for_statistics_clauseContext differentiates from other interfaces. + IsBy_user_for_statistics_clauseContext() +} + +type By_user_for_statistics_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBy_user_for_statistics_clauseContext() *By_user_for_statistics_clauseContext { + var p = new(By_user_for_statistics_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_by_user_for_statistics_clause + return p +} + +func InitEmptyBy_user_for_statistics_clauseContext(p *By_user_for_statistics_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_by_user_for_statistics_clause +} + +func (*By_user_for_statistics_clauseContext) IsBy_user_for_statistics_clauseContext() {} + +func NewBy_user_for_statistics_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *By_user_for_statistics_clauseContext { + var p = new(By_user_for_statistics_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_by_user_for_statistics_clause + + return p +} + +func (s *By_user_for_statistics_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *By_user_for_statistics_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *By_user_for_statistics_clauseContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *By_user_for_statistics_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *By_user_for_statistics_clauseContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *By_user_for_statistics_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *By_user_for_statistics_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *By_user_for_statistics_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBy_user_for_statistics_clause(s) + } +} + +func (s *By_user_for_statistics_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBy_user_for_statistics_clause(s) + } +} + +func (p *PlSqlParser) By_user_for_statistics_clause() (localctx IBy_user_for_statistics_clauseContext) { + localctx = NewBy_user_for_statistics_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1686, PlSqlParserRULE_by_user_for_statistics_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15871) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15872) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15873) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15874) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvaluation_edition_clauseContext is an interface to support dynamic dispatch. +type IEvaluation_edition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EVALUATE() antlr.TerminalNode + USING() antlr.TerminalNode + EDITION() antlr.TerminalNode + Edition_name() IEdition_nameContext + CURRENT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsEvaluation_edition_clauseContext differentiates from other interfaces. + IsEvaluation_edition_clauseContext() +} + +type Evaluation_edition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvaluation_edition_clauseContext() *Evaluation_edition_clauseContext { + var p = new(Evaluation_edition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause + return p +} + +func InitEmptyEvaluation_edition_clauseContext(p *Evaluation_edition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause +} + +func (*Evaluation_edition_clauseContext) IsEvaluation_edition_clauseContext() {} + +func NewEvaluation_edition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Evaluation_edition_clauseContext { + var p = new(Evaluation_edition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause + + return p +} + +func (s *Evaluation_edition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Evaluation_edition_clauseContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Evaluation_edition_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Evaluation_edition_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Evaluation_edition_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Evaluation_edition_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Evaluation_edition_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Evaluation_edition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Evaluation_edition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Evaluation_edition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEvaluation_edition_clause(s) + } +} + +func (s *Evaluation_edition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEvaluation_edition_clause(s) + } +} + +func (p *PlSqlParser) Evaluation_edition_clause() (localctx IEvaluation_edition_clauseContext) { + localctx = NewEvaluation_edition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1688, PlSqlParserRULE_evaluation_edition_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15876) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15877) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT, PlSqlParserNULL_: + { + p.SetState(15878) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15879) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15880) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15881) + p.Edition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INested_table_col_propertiesContext is an interface to support dynamic dispatch. +type INested_table_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + STORE() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + Tableview_name() ITableview_nameContext + Nested_item() INested_itemContext + COLUMN_VALUE() antlr.TerminalNode + Substitutable_column_clause() ISubstitutable_column_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RETURN() antlr.TerminalNode + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + VALUE() antlr.TerminalNode + AllObject_properties() []IObject_propertiesContext + Object_properties(i int) IObject_propertiesContext + AllPhysical_properties() []IPhysical_propertiesContext + Physical_properties(i int) IPhysical_propertiesContext + AllColumn_properties() []IColumn_propertiesContext + Column_properties(i int) IColumn_propertiesContext + + // IsNested_table_col_propertiesContext differentiates from other interfaces. + IsNested_table_col_propertiesContext() +} + +type Nested_table_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_table_col_propertiesContext() *Nested_table_col_propertiesContext { + var p = new(Nested_table_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties + return p +} + +func InitEmptyNested_table_col_propertiesContext(p *Nested_table_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties +} + +func (*Nested_table_col_propertiesContext) IsNested_table_col_propertiesContext() {} + +func NewNested_table_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_table_col_propertiesContext { + var p = new(Nested_table_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties + + return p +} + +func (s *Nested_table_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_table_col_propertiesContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Nested_table_col_propertiesContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Nested_table_col_propertiesContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Nested_table_col_propertiesContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Nested_table_col_propertiesContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Nested_table_col_propertiesContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Nested_table_col_propertiesContext) Nested_item() INested_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INested_itemContext) +} + +func (s *Nested_table_col_propertiesContext) COLUMN_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_VALUE, 0) +} + +func (s *Nested_table_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Nested_table_col_propertiesContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Nested_table_col_propertiesContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Nested_table_col_propertiesContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Nested_table_col_propertiesContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Nested_table_col_propertiesContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Nested_table_col_propertiesContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Nested_table_col_propertiesContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Nested_table_col_propertiesContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Nested_table_col_propertiesContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Nested_table_col_propertiesContext) AllObject_properties() []IObject_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_propertiesContext); ok { + tst[i] = t.(IObject_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Object_properties(i int) IObject_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) AllPhysical_properties() []IPhysical_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + len++ + } + } + + tst := make([]IPhysical_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_propertiesContext); ok { + tst[i] = t.(IPhysical_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Physical_properties(i int) IPhysical_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) AllColumn_properties() []IColumn_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_propertiesContext); ok { + len++ + } + } + + tst := make([]IColumn_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_propertiesContext); ok { + tst[i] = t.(IColumn_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Column_properties(i int) IColumn_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_table_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_table_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_table_col_properties(s) + } +} + +func (s *Nested_table_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_table_col_properties(s) + } +} + +func (p *PlSqlParser) Nested_table_col_properties() (localctx INested_table_col_propertiesContext) { + localctx = NewNested_table_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1690, PlSqlParserRULE_nested_table_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15884) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15885) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2143, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15886) + p.Nested_item() + } + + case 2: + { + p.SetState(15887) + p.Match(PlSqlParserCOLUMN_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserIS || _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(15890) + p.Substitutable_column_clause() + } + + } + p.SetState(15894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGLOBAL || _la == PlSqlParserLOCAL { + { + p.SetState(15893) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGLOBAL || _la == PlSqlParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(15896) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15897) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15898) + p.Tableview_name() + } + p.SetState(15912) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2148, p.GetParserRuleContext()) == 1 { + { + p.SetState(15899) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-220)) & ^0x3f) == 0 && ((int64(1)<<(_la-220))&1374389665793) != 0) || _la == PlSqlParserEXTERNAL || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || ((int64((_la-697)) & ^0x3f) == 0 && ((int64(1)<<(_la-697))&633318697598977) != 0) || ((int64((_la-868)) & ^0x3f) == 0 && ((int64(1)<<(_la-868))&-9223372036854710271) != 0) || _la == PlSqlParserNESTED || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNO || _la == PlSqlParserORGANIZATION || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserROW || _la == PlSqlParserSEGMENT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY || _la == PlSqlParserXMLTYPE || _la == PlSqlParserLEFT_PAREN { + p.SetState(15906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2146, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15900) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15901) + p.Object_properties() + } + { + p.SetState(15902) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(15904) + p.Physical_properties() + } + + case 3: + { + p.SetState(15905) + p.Column_properties() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15910) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(15914) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(15915) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15918) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCATOR || _la == PlSqlParserVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INested_itemContext is an interface to support dynamic dispatch. +type INested_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsNested_itemContext differentiates from other interfaces. + IsNested_itemContext() +} + +type Nested_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_itemContext() *Nested_itemContext { + var p = new(Nested_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_item + return p +} + +func InitEmptyNested_itemContext(p *Nested_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_item +} + +func (*Nested_itemContext) IsNested_itemContext() {} + +func NewNested_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_itemContext { + var p = new(Nested_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_item + + return p +} + +func (s *Nested_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_itemContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Nested_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_item(s) + } +} + +func (s *Nested_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_item(s) + } +} + +func (p *PlSqlParser) Nested_item() (localctx INested_itemContext) { + localctx = NewNested_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1692, PlSqlParserRULE_nested_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15921) + p.Regular_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubstitutable_column_clauseContext is an interface to support dynamic dispatch. +type ISubstitutable_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + OF() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Type_name() IType_nameContext + RIGHT_PAREN() antlr.TerminalNode + ELEMENT() antlr.TerminalNode + TYPE() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsSubstitutable_column_clauseContext differentiates from other interfaces. + IsSubstitutable_column_clauseContext() +} + +type Substitutable_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubstitutable_column_clauseContext() *Substitutable_column_clauseContext { + var p = new(Substitutable_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause + return p +} + +func InitEmptySubstitutable_column_clauseContext(p *Substitutable_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause +} + +func (*Substitutable_column_clauseContext) IsSubstitutable_column_clauseContext() {} + +func NewSubstitutable_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Substitutable_column_clauseContext { + var p = new(Substitutable_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause + + return p +} + +func (s *Substitutable_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Substitutable_column_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Substitutable_column_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Substitutable_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Substitutable_column_clauseContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Substitutable_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Substitutable_column_clauseContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Substitutable_column_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Substitutable_column_clauseContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Substitutable_column_clauseContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Substitutable_column_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Substitutable_column_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Substitutable_column_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Substitutable_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Substitutable_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Substitutable_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubstitutable_column_clause(s) + } +} + +func (s *Substitutable_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubstitutable_column_clause(s) + } +} + +func (p *PlSqlParser) Substitutable_column_clause() (localctx ISubstitutable_column_clauseContext) { + localctx = NewSubstitutable_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1694, PlSqlParserRULE_substitutable_column_clause) + var _la int + + p.SetState(15942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserELEMENT, PlSqlParserIS: + p.EnterOuterAlt(localctx, 1) + p.SetState(15924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT { + { + p.SetState(15923) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15926) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15927) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(15928) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15931) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15932) + p.Type_name() + } + { + p.SetState(15933) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOT, PlSqlParserSUBSTITUTABLE: + p.EnterOuterAlt(localctx, 2) + p.SetState(15936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15935) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15938) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15939) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15940) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15941) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_nameContext is an interface to support dynamic dispatch. +type IPartition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + DELIMITED_ID() antlr.TerminalNode + + // IsPartition_nameContext differentiates from other interfaces. + IsPartition_nameContext() +} + +type Partition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_nameContext() *Partition_nameContext { + var p = new(Partition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name + return p +} + +func InitEmptyPartition_nameContext(p *Partition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name +} + +func (*Partition_nameContext) IsPartition_nameContext() {} + +func NewPartition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_nameContext { + var p = new(Partition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_name + + return p +} + +func (s *Partition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Partition_nameContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Partition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_name(s) + } +} + +func (s *Partition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_name(s) + } +} + +func (p *PlSqlParser) Partition_name() (localctx IPartition_nameContext) { + localctx = NewPartition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1696, PlSqlParserRULE_partition_name) + p.SetState(15946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15944) + p.Regular_id() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15945) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISupplemental_logging_propsContext is an interface to support dynamic dispatch. +type ISupplemental_logging_propsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUPPLEMENTAL() antlr.TerminalNode + LOG() antlr.TerminalNode + Supplemental_log_grp_clause() ISupplemental_log_grp_clauseContext + Supplemental_id_key_clause() ISupplemental_id_key_clauseContext + + // IsSupplemental_logging_propsContext differentiates from other interfaces. + IsSupplemental_logging_propsContext() +} + +type Supplemental_logging_propsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_logging_propsContext() *Supplemental_logging_propsContext { + var p = new(Supplemental_logging_propsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props + return p +} + +func InitEmptySupplemental_logging_propsContext(p *Supplemental_logging_propsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props +} + +func (*Supplemental_logging_propsContext) IsSupplemental_logging_propsContext() {} + +func NewSupplemental_logging_propsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_logging_propsContext { + var p = new(Supplemental_logging_propsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props + + return p +} + +func (s *Supplemental_logging_propsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_logging_propsContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Supplemental_logging_propsContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Supplemental_logging_propsContext) Supplemental_log_grp_clause() ISupplemental_log_grp_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_log_grp_clauseContext) +} + +func (s *Supplemental_logging_propsContext) Supplemental_id_key_clause() ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_logging_propsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_logging_propsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_logging_propsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_logging_props(s) + } +} + +func (s *Supplemental_logging_propsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_logging_props(s) + } +} + +func (p *PlSqlParser) Supplemental_logging_props() (localctx ISupplemental_logging_propsContext) { + localctx = NewSupplemental_logging_propsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1698, PlSqlParserRULE_supplemental_logging_props) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15948) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15949) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(15950) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(15951) + p.Supplemental_id_key_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_type_col_propertiesContext is an interface to support dynamic dispatch. +type IObject_type_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumn returns the column rule contexts. + GetColumn() IRegular_idContext + + // SetColumn sets the column rule contexts. + SetColumn(IRegular_idContext) + + // Getter signatures + COLUMN() antlr.TerminalNode + Substitutable_column_clause() ISubstitutable_column_clauseContext + Regular_id() IRegular_idContext + + // IsObject_type_col_propertiesContext differentiates from other interfaces. + IsObject_type_col_propertiesContext() +} + +type Object_type_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column IRegular_idContext +} + +func NewEmptyObject_type_col_propertiesContext() *Object_type_col_propertiesContext { + var p = new(Object_type_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_col_properties + return p +} + +func InitEmptyObject_type_col_propertiesContext(p *Object_type_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_col_properties +} + +func (*Object_type_col_propertiesContext) IsObject_type_col_propertiesContext() {} + +func NewObject_type_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_col_propertiesContext { + var p = new(Object_type_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_type_col_properties + + return p +} + +func (s *Object_type_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_col_propertiesContext) GetColumn() IRegular_idContext { return s.column } + +func (s *Object_type_col_propertiesContext) SetColumn(v IRegular_idContext) { s.column = v } + +func (s *Object_type_col_propertiesContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Object_type_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Object_type_col_propertiesContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Object_type_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_type_col_properties(s) + } +} + +func (s *Object_type_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type_col_properties(s) + } +} + +func (p *PlSqlParser) Object_type_col_properties() (localctx IObject_type_col_propertiesContext) { + localctx = NewObject_type_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1700, PlSqlParserRULE_object_type_col_properties) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15954) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15955) + + var _x = p.Regular_id() + + localctx.(*Object_type_col_propertiesContext).column = _x + } + { + p.SetState(15956) + p.Substitutable_column_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraint_clausesContext is an interface to support dynamic dispatch. +type IConstraint_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MODIFY() antlr.TerminalNode + Constraint_state() IConstraint_stateContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + CASCADE() antlr.TerminalNode + RENAME() antlr.TerminalNode + Old_constraint_name() IOld_constraint_nameContext + TO() antlr.TerminalNode + New_constraint_name() INew_constraint_nameContext + AllDrop_constraint_clause() []IDrop_constraint_clauseContext + Drop_constraint_clause(i int) IDrop_constraint_clauseContext + + // IsConstraint_clausesContext differentiates from other interfaces. + IsConstraint_clausesContext() +} + +type Constraint_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_clausesContext() *Constraint_clausesContext { + var p = new(Constraint_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_clauses + return p +} + +func InitEmptyConstraint_clausesContext(p *Constraint_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_clauses +} + +func (*Constraint_clausesContext) IsConstraint_clausesContext() {} + +func NewConstraint_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_clausesContext { + var p = new(Constraint_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_clauses + + return p +} + +func (s *Constraint_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Constraint_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constraint_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constraint_clausesContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *Constraint_clausesContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Constraint_clausesContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Constraint_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constraint_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constraint_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Constraint_clausesContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Constraint_clausesContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Constraint_clausesContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Constraint_clausesContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Constraint_clausesContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Constraint_clausesContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Constraint_clausesContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Constraint_clausesContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Constraint_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Constraint_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Constraint_clausesContext) Old_constraint_name() IOld_constraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_constraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_constraint_nameContext) +} + +func (s *Constraint_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Constraint_clausesContext) New_constraint_name() INew_constraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constraint_nameContext) +} + +func (s *Constraint_clausesContext) AllDrop_constraint_clause() []IDrop_constraint_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_constraint_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_constraint_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_constraint_clauseContext); ok { + tst[i] = t.(IDrop_constraint_clauseContext) + i++ + } + } + + return tst +} + +func (s *Constraint_clausesContext) Drop_constraint_clause(i int) IDrop_constraint_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_constraint_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_constraint_clauseContext) +} + +func (s *Constraint_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_clauses(s) + } +} + +func (s *Constraint_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_clauses(s) + } +} + +func (p *PlSqlParser) Constraint_clauses() (localctx IConstraint_clausesContext) { + localctx = NewConstraint_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1702, PlSqlParserRULE_constraint_clauses) + var _la int + + var _alt int + + p.SetState(16012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2164, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15958) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15959) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2158, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15960) + p.Out_of_line_constraint() + } + p.SetState(15965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15961) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15962) + p.Out_of_line_constraint() + } + + p.SetState(15967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(15968) + p.Out_of_line_ref_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(15971) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15973) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2159, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15974) + p.Out_of_line_constraint() + } + + case 2: + { + p.SetState(15975) + p.Out_of_line_ref_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15978) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONSTRAINT: + { + p.SetState(15979) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15980) + p.Constraint_name() + } + + case PlSqlParserPRIMARY: + { + p.SetState(15981) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15982) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(15983) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15984) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15985) + p.Column_name() + } + p.SetState(15990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15986) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15987) + p.Column_name() + } + + p.SetState(15992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15993) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15997) + p.Constraint_state() + } + p.SetState(15999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(15998) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16001) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16002) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16003) + p.Old_constraint_name() + } + { + p.SetState(16004) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16005) + p.New_constraint_name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(16008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(16007) + p.Drop_constraint_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16010) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2163, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOld_constraint_nameContext is an interface to support dynamic dispatch. +type IOld_constraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constraint_name() IConstraint_nameContext + + // IsOld_constraint_nameContext differentiates from other interfaces. + IsOld_constraint_nameContext() +} + +type Old_constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_constraint_nameContext() *Old_constraint_nameContext { + var p = new(Old_constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_constraint_name + return p +} + +func InitEmptyOld_constraint_nameContext(p *Old_constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_constraint_name +} + +func (*Old_constraint_nameContext) IsOld_constraint_nameContext() {} + +func NewOld_constraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_constraint_nameContext { + var p = new(Old_constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_old_constraint_name + + return p +} + +func (s *Old_constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_constraint_nameContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Old_constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOld_constraint_name(s) + } +} + +func (s *Old_constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOld_constraint_name(s) + } +} + +func (p *PlSqlParser) Old_constraint_name() (localctx IOld_constraint_nameContext) { + localctx = NewOld_constraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1704, PlSqlParserRULE_old_constraint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16014) + p.Constraint_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INew_constraint_nameContext is an interface to support dynamic dispatch. +type INew_constraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constraint_name() IConstraint_nameContext + + // IsNew_constraint_nameContext differentiates from other interfaces. + IsNew_constraint_nameContext() +} + +type New_constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constraint_nameContext() *New_constraint_nameContext { + var p = new(New_constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_constraint_name + return p +} + +func InitEmptyNew_constraint_nameContext(p *New_constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_constraint_name +} + +func (*New_constraint_nameContext) IsNew_constraint_nameContext() {} + +func NewNew_constraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constraint_nameContext { + var p = new(New_constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_constraint_name + + return p +} + +func (s *New_constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constraint_nameContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *New_constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_constraint_name(s) + } +} + +func (s *New_constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_constraint_name(s) + } +} + +func (p *PlSqlParser) New_constraint_name() (localctx INew_constraint_nameContext) { + localctx = NewNew_constraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1706, PlSqlParserRULE_new_constraint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16016) + p.Constraint_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_constraint_clauseContext is an interface to support dynamic dispatch. +type IDrop_constraint_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + PRIMARY() antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + CASCADE() antlr.TerminalNode + INDEX() antlr.TerminalNode + ONLINE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_constraint_clauseContext differentiates from other interfaces. + IsDrop_constraint_clauseContext() +} + +type Drop_constraint_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_constraint_clauseContext() *Drop_constraint_clauseContext { + var p = new(Drop_constraint_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause + return p +} + +func InitEmptyDrop_constraint_clauseContext(p *Drop_constraint_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause +} + +func (*Drop_constraint_clauseContext) IsDrop_constraint_clauseContext() {} + +func NewDrop_constraint_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_constraint_clauseContext { + var p = new(Drop_constraint_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause + + return p +} + +func (s *Drop_constraint_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_constraint_clauseContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Drop_constraint_clauseContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Drop_constraint_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Drop_constraint_clauseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Drop_constraint_clauseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Drop_constraint_clauseContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Drop_constraint_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_constraint_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_constraint_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Drop_constraint_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_constraint_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Drop_constraint_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Drop_constraint_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_constraint_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Drop_constraint_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Drop_constraint_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_constraint_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_constraint_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_constraint_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_constraint_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_constraint_clause(s) + } +} + +func (s *Drop_constraint_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_constraint_clause(s) + } +} + +func (p *PlSqlParser) Drop_constraint_clause() (localctx IDrop_constraint_clauseContext) { + localctx = NewDrop_constraint_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1708, PlSqlParserRULE_drop_constraint_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16018) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY: + { + p.SetState(16019) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16020) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(16021) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16022) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16023) + p.Column_name() + } + p.SetState(16028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16024) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16025) + p.Column_name() + } + + p.SetState(16030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16031) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT: + { + p.SetState(16033) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16034) + p.Constraint_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(16037) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16042) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2168, p.GetParserRuleContext()) == 1 { + { + p.SetState(16040) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16041) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLINE { + { + p.SetState(16044) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheck_constraintContext is an interface to support dynamic dispatch. +type ICheck_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCheck_constraintContext differentiates from other interfaces. + IsCheck_constraintContext() +} + +type Check_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheck_constraintContext() *Check_constraintContext { + var p = new(Check_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_constraint + return p +} + +func InitEmptyCheck_constraintContext(p *Check_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_constraint +} + +func (*Check_constraintContext) IsCheck_constraintContext() {} + +func NewCheck_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Check_constraintContext { + var p = new(Check_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_check_constraint + + return p +} + +func (s *Check_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Check_constraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Check_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Check_constraintContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Check_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Check_constraintContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Check_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Check_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Check_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCheck_constraint(s) + } +} + +func (s *Check_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCheck_constraint(s) + } +} + +func (p *PlSqlParser) Check_constraint() (localctx ICheck_constraintContext) { + localctx = NewCheck_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1710, PlSqlParserRULE_check_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16047) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16048) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16049) + p.Condition() + } + { + p.SetState(16050) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16052) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2170, p.GetParserRuleContext()) == 1 { + { + p.SetState(16051) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_clauseContext is an interface to support dynamic dispatch. +type IForeign_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + References_clause() IReferences_clauseContext + On_delete_clause() IOn_delete_clauseContext + + // IsForeign_key_clauseContext differentiates from other interfaces. + IsForeign_key_clauseContext() +} + +type Foreign_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext { + var p = new(Foreign_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_foreign_key_clause + return p +} + +func InitEmptyForeign_key_clauseContext(p *Foreign_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_foreign_key_clause +} + +func (*Foreign_key_clauseContext) IsForeign_key_clauseContext() {} + +func NewForeign_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_clauseContext { + var p = new(Foreign_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_foreign_key_clause + + return p +} + +func (s *Foreign_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_clauseContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Foreign_key_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Foreign_key_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Foreign_key_clauseContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Foreign_key_clauseContext) On_delete_clause() IOn_delete_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_delete_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_delete_clauseContext) +} + +func (s *Foreign_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForeign_key_clause(s) + } +} + +func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForeign_key_clause(s) + } +} + +func (p *PlSqlParser) Foreign_key_clause() (localctx IForeign_key_clauseContext) { + localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1712, PlSqlParserRULE_foreign_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16054) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16055) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16056) + p.Paren_column_list() + } + { + p.SetState(16057) + p.References_clause() + } + p.SetState(16059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(16058) + p.On_delete_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferences_clauseContext is an interface to support dynamic dispatch. +type IReferences_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCES() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Paren_column_list() IParen_column_listContext + ON() antlr.TerminalNode + DELETE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsReferences_clauseContext differentiates from other interfaces. + IsReferences_clauseContext() +} + +type References_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferences_clauseContext() *References_clauseContext { + var p = new(References_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_references_clause + return p +} + +func InitEmptyReferences_clauseContext(p *References_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_references_clause +} + +func (*References_clauseContext) IsReferences_clauseContext() {} + +func NewReferences_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *References_clauseContext { + var p = new(References_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_references_clause + + return p +} + +func (s *References_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *References_clauseContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *References_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *References_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *References_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *References_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *References_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *References_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *References_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *References_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *References_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *References_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferences_clause(s) + } +} + +func (s *References_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferences_clause(s) + } +} + +func (p *PlSqlParser) References_clause() (localctx IReferences_clauseContext) { + localctx = NewReferences_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1714, PlSqlParserRULE_references_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16061) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16062) + p.Tableview_name() + } + p.SetState(16064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16063) + p.Paren_column_list() + } + + } + p.SetState(16073) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2174, p.GetParserRuleContext()) == 1 { + { + p.SetState(16066) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16067) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(16068) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + { + p.SetState(16069) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16070) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_delete_clauseContext is an interface to support dynamic dispatch. +type IOn_delete_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + DELETE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsOn_delete_clauseContext differentiates from other interfaces. + IsOn_delete_clauseContext() +} + +type On_delete_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_delete_clauseContext() *On_delete_clauseContext { + var p = new(On_delete_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_delete_clause + return p +} + +func InitEmptyOn_delete_clauseContext(p *On_delete_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_delete_clause +} + +func (*On_delete_clauseContext) IsOn_delete_clauseContext() {} + +func NewOn_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_delete_clauseContext { + var p = new(On_delete_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_delete_clause + + return p +} + +func (s *On_delete_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_delete_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *On_delete_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *On_delete_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *On_delete_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *On_delete_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *On_delete_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_delete_clause(s) + } +} + +func (s *On_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_delete_clause(s) + } +} + +func (p *PlSqlParser) On_delete_clause() (localctx IOn_delete_clauseContext) { + localctx = NewOn_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1716, PlSqlParserRULE_on_delete_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16075) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16076) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(16077) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + { + p.SetState(16078) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16079) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnonymous_blockContext is an interface to support dynamic dispatch. +type IAnonymous_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + DECLARE() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllException_handler() []IException_handlerContext + Exception_handler(i int) IException_handlerContext + + // IsAnonymous_blockContext differentiates from other interfaces. + IsAnonymous_blockContext() +} + +type Anonymous_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnonymous_blockContext() *Anonymous_blockContext { + var p = new(Anonymous_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_anonymous_block + return p +} + +func InitEmptyAnonymous_blockContext(p *Anonymous_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_anonymous_block +} + +func (*Anonymous_blockContext) IsAnonymous_blockContext() {} + +func NewAnonymous_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Anonymous_blockContext { + var p = new(Anonymous_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_anonymous_block + + return p +} + +func (s *Anonymous_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Anonymous_blockContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Anonymous_blockContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Anonymous_blockContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Anonymous_blockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Anonymous_blockContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Anonymous_blockContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Anonymous_blockContext) AllException_handler() []IException_handlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_handlerContext); ok { + len++ + } + } + + tst := make([]IException_handlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_handlerContext); ok { + tst[i] = t.(IException_handlerContext) + i++ + } + } + + return tst +} + +func (s *Anonymous_blockContext) Exception_handler(i int) IException_handlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_handlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_handlerContext) +} + +func (s *Anonymous_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Anonymous_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Anonymous_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnonymous_block(s) + } +} + +func (s *Anonymous_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnonymous_block(s) + } +} + +func (p *PlSqlParser) Anonymous_block() (localctx IAnonymous_blockContext) { + localctx = NewAnonymous_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1718, PlSqlParserRULE_anonymous_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(16082) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16084) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2176, p.GetParserRuleContext()) == 1 { + { + p.SetState(16083) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + { + p.SetState(16088) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16089) + p.Seq_of_statements() + } + p.SetState(16096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTION { + { + p.SetState(16090) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(16091) + p.Exception_handler() + } + + p.SetState(16094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(16098) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInvoker_rights_clauseContext is an interface to support dynamic dispatch. +type IInvoker_rights_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHID() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + DEFINER() antlr.TerminalNode + + // IsInvoker_rights_clauseContext differentiates from other interfaces. + IsInvoker_rights_clauseContext() +} + +type Invoker_rights_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInvoker_rights_clauseContext() *Invoker_rights_clauseContext { + var p = new(Invoker_rights_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause + return p +} + +func InitEmptyInvoker_rights_clauseContext(p *Invoker_rights_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause +} + +func (*Invoker_rights_clauseContext) IsInvoker_rights_clauseContext() {} + +func NewInvoker_rights_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Invoker_rights_clauseContext { + var p = new(Invoker_rights_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause + + return p +} + +func (s *Invoker_rights_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Invoker_rights_clauseContext) AUTHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHID, 0) +} + +func (s *Invoker_rights_clauseContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Invoker_rights_clauseContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Invoker_rights_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Invoker_rights_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Invoker_rights_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInvoker_rights_clause(s) + } +} + +func (s *Invoker_rights_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInvoker_rights_clause(s) + } +} + +func (p *PlSqlParser) Invoker_rights_clause() (localctx IInvoker_rights_clauseContext) { + localctx = NewInvoker_rights_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1720, PlSqlParserRULE_invoker_rights_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16100) + p.Match(PlSqlParserAUTHID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16101) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT_USER || _la == PlSqlParserDEFINER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICall_specContext is an interface to support dynamic dispatch. +type ICall_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Java_spec() IJava_specContext + C_spec() IC_specContext + + // IsCall_specContext differentiates from other interfaces. + IsCall_specContext() +} + +type Call_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCall_specContext() *Call_specContext { + var p = new(Call_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_spec + return p +} + +func InitEmptyCall_specContext(p *Call_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_spec +} + +func (*Call_specContext) IsCall_specContext() {} + +func NewCall_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Call_specContext { + var p = new(Call_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_call_spec + + return p +} + +func (s *Call_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Call_specContext) Java_spec() IJava_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJava_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJava_specContext) +} + +func (s *Call_specContext) C_spec() IC_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_specContext) +} + +func (s *Call_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Call_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Call_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCall_spec(s) + } +} + +func (s *Call_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCall_spec(s) + } +} + +func (p *PlSqlParser) Call_spec() (localctx ICall_specContext) { + localctx = NewCall_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1722, PlSqlParserRULE_call_spec) + p.SetState(16105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2180, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16103) + p.Java_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16104) + p.C_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJava_specContext is an interface to support dynamic dispatch. +type IJava_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE() antlr.TerminalNode + JAVA() antlr.TerminalNode + NAME() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsJava_specContext differentiates from other interfaces. + IsJava_specContext() +} + +type Java_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJava_specContext() *Java_specContext { + var p = new(Java_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_java_spec + return p +} + +func InitEmptyJava_specContext(p *Java_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_java_spec +} + +func (*Java_specContext) IsJava_specContext() {} + +func NewJava_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Java_specContext { + var p = new(Java_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_java_spec + + return p +} + +func (s *Java_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Java_specContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Java_specContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Java_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Java_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Java_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Java_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Java_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJava_spec(s) + } +} + +func (s *Java_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJava_spec(s) + } +} + +func (p *PlSqlParser) Java_spec() (localctx IJava_specContext) { + localctx = NewJava_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1724, PlSqlParserRULE_java_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16107) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16108) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16109) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16110) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_specContext is an interface to support dynamic dispatch. +type IC_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE() antlr.TerminalNode + C_LETTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Id_expression() IId_expressionContext + LIBRARY() antlr.TerminalNode + Identifier() IIdentifierContext + C_agent_in_clause() IC_agent_in_clauseContext + WITH() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + C_parameters_clause() IC_parameters_clauseContext + + // IsC_specContext differentiates from other interfaces. + IsC_specContext() +} + +type C_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_specContext() *C_specContext { + var p = new(C_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_spec + return p +} + +func InitEmptyC_specContext(p *C_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_spec +} + +func (*C_specContext) IsC_specContext() {} + +func NewC_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_specContext { + var p = new(C_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_spec + + return p +} + +func (s *C_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_specContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *C_specContext) C_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserC_LETTER, 0) +} + +func (s *C_specContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *C_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *C_specContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *C_specContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *C_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *C_specContext) C_agent_in_clause() IC_agent_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_agent_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_agent_in_clauseContext) +} + +func (s *C_specContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *C_specContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *C_specContext) C_parameters_clause() IC_parameters_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_parameters_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_parameters_clauseContext) +} + +func (s *C_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_spec(s) + } +} + +func (s *C_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_spec(s) + } +} + +func (p *PlSqlParser) C_spec() (localctx IC_specContext) { + localctx = NewC_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1726, PlSqlParserRULE_c_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLANGUAGE: + { + p.SetState(16112) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16113) + p.Match(PlSqlParserC_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTERNAL: + { + p.SetState(16114) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNAME: + { + p.SetState(16117) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16118) + p.Id_expression() + } + { + p.SetState(16119) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16120) + p.Identifier() + } + + case PlSqlParserLIBRARY: + { + p.SetState(16122) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16123) + p.Identifier() + } + p.SetState(16126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNAME { + { + p.SetState(16124) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16125) + p.Id_expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAGENT { + { + p.SetState(16130) + p.C_agent_in_clause() + } + + } + p.SetState(16135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(16133) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16134) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(16137) + p.C_parameters_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_agent_in_clauseContext is an interface to support dynamic dispatch. +type IC_agent_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGENT() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + RIGHT_PAREN() antlr.TerminalNode + + // IsC_agent_in_clauseContext differentiates from other interfaces. + IsC_agent_in_clauseContext() +} + +type C_agent_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_agent_in_clauseContext() *C_agent_in_clauseContext { + var p = new(C_agent_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause + return p +} + +func InitEmptyC_agent_in_clauseContext(p *C_agent_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause +} + +func (*C_agent_in_clauseContext) IsC_agent_in_clauseContext() {} + +func NewC_agent_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_agent_in_clauseContext { + var p = new(C_agent_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause + + return p +} + +func (s *C_agent_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_agent_in_clauseContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *C_agent_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *C_agent_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *C_agent_in_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *C_agent_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *C_agent_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_agent_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_agent_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_agent_in_clause(s) + } +} + +func (s *C_agent_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_agent_in_clause(s) + } +} + +func (p *PlSqlParser) C_agent_in_clause() (localctx IC_agent_in_clauseContext) { + localctx = NewC_agent_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1728, PlSqlParserRULE_c_agent_in_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16140) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16141) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16142) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16143) + p.Expressions_() + } + { + p.SetState(16144) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_parameters_clauseContext is an interface to support dynamic dispatch. +type IC_parameters_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllC_external_parameter() []IC_external_parameterContext + C_external_parameter(i int) IC_external_parameterContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsC_parameters_clauseContext differentiates from other interfaces. + IsC_parameters_clauseContext() +} + +type C_parameters_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_parameters_clauseContext() *C_parameters_clauseContext { + var p = new(C_parameters_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_parameters_clause + return p +} + +func InitEmptyC_parameters_clauseContext(p *C_parameters_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_parameters_clause +} + +func (*C_parameters_clauseContext) IsC_parameters_clauseContext() {} + +func NewC_parameters_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_parameters_clauseContext { + var p = new(C_parameters_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_parameters_clause + + return p +} + +func (s *C_parameters_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_parameters_clauseContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *C_parameters_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *C_parameters_clauseContext) AllC_external_parameter() []IC_external_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IC_external_parameterContext); ok { + len++ + } + } + + tst := make([]IC_external_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IC_external_parameterContext); ok { + tst[i] = t.(IC_external_parameterContext) + i++ + } + } + + return tst +} + +func (s *C_parameters_clauseContext) C_external_parameter(i int) IC_external_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_external_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IC_external_parameterContext) +} + +func (s *C_parameters_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *C_parameters_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *C_parameters_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *C_parameters_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_parameters_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_parameters_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_parameters_clause(s) + } +} + +func (s *C_parameters_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_parameters_clause(s) + } +} + +func (p *PlSqlParser) C_parameters_clause() (localctx IC_parameters_clauseContext) { + localctx = NewC_parameters_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1730, PlSqlParserRULE_c_parameters_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16146) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16147) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16148) + p.C_external_parameter() + } + p.SetState(16153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16149) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16150) + p.C_external_parameter() + } + + p.SetState(16155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16156) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_external_parameterContext is an interface to support dynamic dispatch. +type IC_external_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetExternal_datatype returns the external_datatype rule contexts. + GetExternal_datatype() IRegular_idContext + + // SetExternal_datatype sets the external_datatype rule contexts. + SetExternal_datatype(IRegular_idContext) + + // Getter signatures + CONTEXT() antlr.TerminalNode + SELF() antlr.TerminalNode + TDO() antlr.TerminalNode + C_property() IC_propertyContext + Parameter_name() IParameter_nameContext + RETURN() antlr.TerminalNode + BY() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + Regular_id() IRegular_idContext + + // IsC_external_parameterContext differentiates from other interfaces. + IsC_external_parameterContext() +} + +type C_external_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + external_datatype IRegular_idContext +} + +func NewEmptyC_external_parameterContext() *C_external_parameterContext { + var p = new(C_external_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_external_parameter + return p +} + +func InitEmptyC_external_parameterContext(p *C_external_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_external_parameter +} + +func (*C_external_parameterContext) IsC_external_parameterContext() {} + +func NewC_external_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_external_parameterContext { + var p = new(C_external_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_external_parameter + + return p +} + +func (s *C_external_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_external_parameterContext) GetExternal_datatype() IRegular_idContext { + return s.external_datatype +} + +func (s *C_external_parameterContext) SetExternal_datatype(v IRegular_idContext) { + s.external_datatype = v +} + +func (s *C_external_parameterContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *C_external_parameterContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *C_external_parameterContext) TDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTDO, 0) +} + +func (s *C_external_parameterContext) C_property() IC_propertyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_propertyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_propertyContext) +} + +func (s *C_external_parameterContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *C_external_parameterContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *C_external_parameterContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *C_external_parameterContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *C_external_parameterContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *C_external_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_external_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_external_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_external_parameter(s) + } +} + +func (s *C_external_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_external_parameter(s) + } +} + +func (p *PlSqlParser) C_external_parameter() (localctx IC_external_parameterContext) { + localctx = NewC_external_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1732, PlSqlParserRULE_c_external_parameter) + var _la int + + p.SetState(16178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2193, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16158) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16159) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserTDO: + { + p.SetState(16160) + p.Match(PlSqlParserTDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDICATOR, PlSqlParserLENGTH, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserMAXLEN: + { + p.SetState(16161) + p.C_property() + } + + case PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(16166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2189, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16164) + p.Parameter_name() + } + + case 2: + { + p.SetState(16165) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(16169) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2190, p.GetParserRuleContext()) == 1 { + { + p.SetState(16168) + p.C_property() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(16171) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16172) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372088865) != 0) { + { + p.SetState(16175) + + var _x = p.Regular_id() + + localctx.(*C_external_parameterContext).external_datatype = _x + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_propertyContext is an interface to support dynamic dispatch. +type IC_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDICATOR() antlr.TerminalNode + STRUCT() antlr.TerminalNode + TDO() antlr.TerminalNode + LENGTH() antlr.TerminalNode + DURATION() antlr.TerminalNode + MAXLEN() antlr.TerminalNode + CHARSETID() antlr.TerminalNode + CHARSETFORM() antlr.TerminalNode + + // IsC_propertyContext differentiates from other interfaces. + IsC_propertyContext() +} + +type C_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_propertyContext() *C_propertyContext { + var p = new(C_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_property + return p +} + +func InitEmptyC_propertyContext(p *C_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_property +} + +func (*C_propertyContext) IsC_propertyContext() {} + +func NewC_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_propertyContext { + var p = new(C_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_property + + return p +} + +func (s *C_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_propertyContext) INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICATOR, 0) +} + +func (s *C_propertyContext) STRUCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCT, 0) +} + +func (s *C_propertyContext) TDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTDO, 0) +} + +func (s *C_propertyContext) LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH, 0) +} + +func (s *C_propertyContext) DURATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDURATION, 0) +} + +func (s *C_propertyContext) MAXLEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLEN, 0) +} + +func (s *C_propertyContext) CHARSETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARSETID, 0) +} + +func (s *C_propertyContext) CHARSETFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARSETFORM, 0) +} + +func (s *C_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_property(s) + } +} + +func (s *C_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_property(s) + } +} + +func (p *PlSqlParser) C_property() (localctx IC_propertyContext) { + localctx = NewC_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1734, PlSqlParserRULE_c_property) + var _la int + + p.SetState(16189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINDICATOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16180) + p.Match(PlSqlParserINDICATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16182) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2194, p.GetParserRuleContext()) == 1 { + { + p.SetState(16181) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSTRUCT || _la == PlSqlParserTDO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserLENGTH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16184) + p.Match(PlSqlParserLENGTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDURATION: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16185) + p.Match(PlSqlParserDURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXLEN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16186) + p.Match(PlSqlParserMAXLEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARSETID: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16187) + p.Match(PlSqlParserCHARSETID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARSETFORM: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(16188) + p.Match(PlSqlParserCHARSETFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameterContext is an interface to support dynamic dispatch. +type IParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + Default_value_part() IDefault_value_partContext + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllOUT() []antlr.TerminalNode + OUT(i int) antlr.TerminalNode + AllINOUT() []antlr.TerminalNode + INOUT(i int) antlr.TerminalNode + AllNOCOPY() []antlr.TerminalNode + NOCOPY(i int) antlr.TerminalNode + + // IsParameterContext differentiates from other interfaces. + IsParameterContext() +} + +type ParameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterContext() *ParameterContext { + var p = new(ParameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter + return p +} + +func InitEmptyParameterContext(p *ParameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter +} + +func (*ParameterContext) IsParameterContext() {} + +func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext { + var p = new(ParameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter + + return p +} + +func (s *ParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *ParameterContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *ParameterContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *ParameterContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *ParameterContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *ParameterContext) AllOUT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOUT) +} + +func (s *ParameterContext) OUT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, i) +} + +func (s *ParameterContext) AllINOUT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINOUT) +} + +func (s *ParameterContext) INOUT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINOUT, i) +} + +func (s *ParameterContext) AllNOCOPY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCOPY) +} + +func (s *ParameterContext) NOCOPY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOPY, i) +} + +func (s *ParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter(s) + } +} + +func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter(s) + } +} + +func (p *PlSqlParser) Parameter() (localctx IParameterContext) { + localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1736, PlSqlParserRULE_parameter) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16191) + p.Parameter_name() + } + p.SetState(16195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2196, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16192) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIN || _la == PlSqlParserINOUT || _la == PlSqlParserNOCOPY || _la == PlSqlParserOUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(16197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2196, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-145152714736643) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-131073) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(16198) + p.Type_spec() + } + + } + p.SetState(16202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(16201) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_value_partContext is an interface to support dynamic dispatch. +type IDefault_value_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + ASSIGN_OP() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsDefault_value_partContext differentiates from other interfaces. + IsDefault_value_partContext() +} + +type Default_value_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_value_partContext() *Default_value_partContext { + var p = new(Default_value_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_value_part + return p +} + +func InitEmptyDefault_value_partContext(p *Default_value_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_value_part +} + +func (*Default_value_partContext) IsDefault_value_partContext() {} + +func NewDefault_value_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_value_partContext { + var p = new(Default_value_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_value_part + + return p +} + +func (s *Default_value_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_value_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Default_value_partContext) ASSIGN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN_OP, 0) +} + +func (s *Default_value_partContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_value_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_value_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_value_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_value_part(s) + } +} + +func (s *Default_value_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_value_part(s) + } +} + +func (p *PlSqlParser) Default_value_part() (localctx IDefault_value_partContext) { + localctx = NewDefault_value_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1738, PlSqlParserRULE_default_value_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16204) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16205) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeq_of_declare_specsContext is an interface to support dynamic dispatch. +type ISeq_of_declare_specsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsSeq_of_declare_specsContext differentiates from other interfaces. + IsSeq_of_declare_specsContext() +} + +type Seq_of_declare_specsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeq_of_declare_specsContext() *Seq_of_declare_specsContext { + var p = new(Seq_of_declare_specsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs + return p +} + +func InitEmptySeq_of_declare_specsContext(p *Seq_of_declare_specsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs +} + +func (*Seq_of_declare_specsContext) IsSeq_of_declare_specsContext() {} + +func NewSeq_of_declare_specsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seq_of_declare_specsContext { + var p = new(Seq_of_declare_specsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs + + return p +} + +func (s *Seq_of_declare_specsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seq_of_declare_specsContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_declare_specsContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *Seq_of_declare_specsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seq_of_declare_specsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seq_of_declare_specsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeq_of_declare_specs(s) + } +} + +func (s *Seq_of_declare_specsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeq_of_declare_specs(s) + } +} + +func (p *PlSqlParser) Seq_of_declare_specs() (localctx ISeq_of_declare_specsContext) { + localctx = NewSeq_of_declare_specsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1740, PlSqlParserRULE_seq_of_declare_specs) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(16207) + p.Declare_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16210) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2199, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_specContext is an interface to support dynamic dispatch. +type IDeclare_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pragma_declaration() IPragma_declarationContext + Exception_declaration() IException_declarationContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + Variable_declaration() IVariable_declarationContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Type_declaration() IType_declarationContext + Procedure_body() IProcedure_bodyContext + Function_body() IFunction_bodyContext + Selection_directive() ISelection_directiveContext + + // IsDeclare_specContext differentiates from other interfaces. + IsDeclare_specContext() +} + +type Declare_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_specContext() *Declare_specContext { + var p = new(Declare_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_declare_spec + return p +} + +func InitEmptyDeclare_specContext(p *Declare_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_declare_spec +} + +func (*Declare_specContext) IsDeclare_specContext() {} + +func NewDeclare_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_specContext { + var p = new(Declare_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_declare_spec + + return p +} + +func (s *Declare_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_specContext) Pragma_declaration() IPragma_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Declare_specContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Declare_specContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Declare_specContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Declare_specContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Declare_specContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Declare_specContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Declare_specContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Declare_specContext) Procedure_body() IProcedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *Declare_specContext) Function_body() IFunction_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *Declare_specContext) Selection_directive() ISelection_directiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelection_directiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelection_directiveContext) +} + +func (s *Declare_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeclare_spec(s) + } +} + +func (s *Declare_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeclare_spec(s) + } +} + +func (p *PlSqlParser) Declare_spec() (localctx IDeclare_specContext) { + localctx = NewDeclare_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1742, PlSqlParserRULE_declare_spec) + p.SetState(16223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2200, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16212) + p.Pragma_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16213) + p.Exception_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16214) + p.Procedure_spec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16215) + p.Function_spec() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16216) + p.Variable_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(16217) + p.Subtype_declaration() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(16218) + p.Cursor_declaration() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(16219) + p.Type_declaration() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(16220) + p.Procedure_body() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(16221) + p.Function_body() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(16222) + p.Selection_directive() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_declarationContext is an interface to support dynamic dispatch. +type IVariable_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Default_value_part() IDefault_value_partContext + NOT() antlr.TerminalNode + + // IsVariable_declarationContext differentiates from other interfaces. + IsVariable_declarationContext() +} + +type Variable_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_declarationContext() *Variable_declarationContext { + var p = new(Variable_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_declaration + return p +} + +func InitEmptyVariable_declarationContext(p *Variable_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_declaration +} + +func (*Variable_declarationContext) IsVariable_declarationContext() {} + +func NewVariable_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_declarationContext { + var p = new(Variable_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_variable_declaration + + return p +} + +func (s *Variable_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Variable_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Variable_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Variable_declarationContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Variable_declarationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Variable_declarationContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Variable_declarationContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Variable_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVariable_declaration(s) + } +} + +func (s *Variable_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVariable_declaration(s) + } +} + +func (p *PlSqlParser) Variable_declaration() (localctx IVariable_declarationContext) { + localctx = NewVariable_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1744, PlSqlParserRULE_variable_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16225) + p.Identifier() + } + p.SetState(16227) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2201, p.GetParserRuleContext()) == 1 { + { + p.SetState(16226) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16229) + p.Type_spec() + } + p.SetState(16234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT || _la == PlSqlParserNULL_ { + p.SetState(16231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(16230) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16233) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(16236) + p.Default_value_part() + } + + } + { + p.SetState(16239) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubtype_declarationContext is an interface to support dynamic dispatch. +type ISubtype_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBTYPE() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + DOUBLE_PERIOD() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsSubtype_declarationContext differentiates from other interfaces. + IsSubtype_declarationContext() +} + +type Subtype_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubtype_declarationContext() *Subtype_declarationContext { + var p = new(Subtype_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subtype_declaration + return p +} + +func InitEmptySubtype_declarationContext(p *Subtype_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subtype_declaration +} + +func (*Subtype_declarationContext) IsSubtype_declarationContext() {} + +func NewSubtype_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subtype_declarationContext { + var p = new(Subtype_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subtype_declaration + + return p +} + +func (s *Subtype_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subtype_declarationContext) SUBTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBTYPE, 0) +} + +func (s *Subtype_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Subtype_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Subtype_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Subtype_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Subtype_declarationContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Subtype_declarationContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Subtype_declarationContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Subtype_declarationContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Subtype_declarationContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Subtype_declarationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Subtype_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subtype_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subtype_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubtype_declaration(s) + } +} + +func (s *Subtype_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubtype_declaration(s) + } +} + +func (p *PlSqlParser) Subtype_declaration() (localctx ISubtype_declarationContext) { + localctx = NewSubtype_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1746, PlSqlParserRULE_subtype_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16241) + p.Match(PlSqlParserSUBTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16242) + p.Identifier() + } + { + p.SetState(16243) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16244) + p.Type_spec() + } + p.SetState(16250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRANGE { + { + p.SetState(16245) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16246) + p.Expression() + } + { + p.SetState(16247) + p.Match(PlSqlParserDOUBLE_PERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16248) + p.Expression() + } + + } + p.SetState(16254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(16252) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16253) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16256) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_declarationContext is an interface to support dynamic dispatch. +type ICursor_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURSOR() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter_spec() []IParameter_specContext + Parameter_spec(i int) IParameter_specContext + RIGHT_PAREN() antlr.TerminalNode + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + IS() antlr.TerminalNode + Select_statement() ISelect_statementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCursor_declarationContext differentiates from other interfaces. + IsCursor_declarationContext() +} + +type Cursor_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_declarationContext() *Cursor_declarationContext { + var p = new(Cursor_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_declaration + return p +} + +func InitEmptyCursor_declarationContext(p *Cursor_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_declaration +} + +func (*Cursor_declarationContext) IsCursor_declarationContext() {} + +func NewCursor_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_declarationContext { + var p = new(Cursor_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_declaration + + return p +} + +func (s *Cursor_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_declarationContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Cursor_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Cursor_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Cursor_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_declarationContext) AllParameter_spec() []IParameter_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_specContext); ok { + len++ + } + } + + tst := make([]IParameter_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_specContext); ok { + tst[i] = t.(IParameter_specContext) + i++ + } + } + + return tst +} + +func (s *Cursor_declarationContext) Parameter_spec(i int) IParameter_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_specContext) +} + +func (s *Cursor_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_declarationContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Cursor_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Cursor_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Cursor_declarationContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Cursor_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cursor_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cursor_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_declaration(s) + } +} + +func (s *Cursor_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_declaration(s) + } +} + +func (p *PlSqlParser) Cursor_declaration() (localctx ICursor_declarationContext) { + localctx = NewCursor_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1748, PlSqlParserRULE_cursor_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16258) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16259) + p.Identifier() + } + p.SetState(16271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16260) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16261) + p.Parameter_spec() + } + p.SetState(16266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16262) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16263) + p.Parameter_spec() + } + + p.SetState(16268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16269) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(16273) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16274) + p.Type_spec() + } + + } + p.SetState(16279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIS { + { + p.SetState(16277) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16278) + p.Select_statement() + } + + } + { + p.SetState(16281) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_specContext is an interface to support dynamic dispatch. +type IParameter_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + Default_value_part() IDefault_value_partContext + IN() antlr.TerminalNode + + // IsParameter_specContext differentiates from other interfaces. + IsParameter_specContext() +} + +type Parameter_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_specContext() *Parameter_specContext { + var p = new(Parameter_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_spec + return p +} + +func InitEmptyParameter_specContext(p *Parameter_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_spec +} + +func (*Parameter_specContext) IsParameter_specContext() {} + +func NewParameter_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_specContext { + var p = new(Parameter_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_spec + + return p +} + +func (s *Parameter_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_specContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Parameter_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Parameter_specContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Parameter_specContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Parameter_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_spec(s) + } +} + +func (s *Parameter_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_spec(s) + } +} + +func (p *PlSqlParser) Parameter_spec() (localctx IParameter_specContext) { + localctx = NewParameter_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1750, PlSqlParserRULE_parameter_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16283) + p.Parameter_name() + } + p.SetState(16288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-145152714736643) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785074604089345) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-131073) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + p.SetState(16285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIN { + { + p.SetState(16284) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16287) + p.Type_spec() + } + + } + p.SetState(16291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(16290) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IException_declarationContext is an interface to support dynamic dispatch. +type IException_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EXCEPTION() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + + // IsException_declarationContext differentiates from other interfaces. + IsException_declarationContext() +} + +type Exception_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_declarationContext() *Exception_declarationContext { + var p = new(Exception_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_declaration + return p +} + +func InitEmptyException_declarationContext(p *Exception_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_declaration +} + +func (*Exception_declarationContext) IsException_declarationContext() {} + +func NewException_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_declarationContext { + var p = new(Exception_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_declaration + + return p +} + +func (s *Exception_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Exception_declarationContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Exception_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Exception_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_declaration(s) + } +} + +func (s *Exception_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_declaration(s) + } +} + +func (p *PlSqlParser) Exception_declaration() (localctx IException_declarationContext) { + localctx = NewException_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1752, PlSqlParserRULE_exception_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16293) + p.Identifier() + } + { + p.SetState(16294) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16295) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPragma_declarationContext is an interface to support dynamic dispatch. +type IPragma_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetId1 returns the id1 rule contexts. + GetId1() IIdentifierContext + + // SetId1 sets the id1 rule contexts. + SetId1(IIdentifierContext) + + // Getter signatures + PRAGMA() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + SERIALLY_REUSABLE() antlr.TerminalNode + AUTONOMOUS_TRANSACTION() antlr.TerminalNode + EXCEPTION_INIT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Exception_name() IException_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Numeric_negative() INumeric_negativeContext + RIGHT_PAREN() antlr.TerminalNode + INLINE() antlr.TerminalNode + Expression() IExpressionContext + RESTRICT_REFERENCES() antlr.TerminalNode + DEPRECATE() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + UDF() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsPragma_declarationContext differentiates from other interfaces. + IsPragma_declarationContext() +} + +type Pragma_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + id1 IIdentifierContext +} + +func NewEmptyPragma_declarationContext() *Pragma_declarationContext { + var p = new(Pragma_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_declaration + return p +} + +func InitEmptyPragma_declarationContext(p *Pragma_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_declaration +} + +func (*Pragma_declarationContext) IsPragma_declarationContext() {} + +func NewPragma_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_declarationContext { + var p = new(Pragma_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_declaration + + return p +} + +func (s *Pragma_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_declarationContext) GetId1() IIdentifierContext { return s.id1 } + +func (s *Pragma_declarationContext) SetId1(v IIdentifierContext) { s.id1 = v } + +func (s *Pragma_declarationContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Pragma_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Pragma_declarationContext) SERIALLY_REUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALLY_REUSABLE, 0) +} + +func (s *Pragma_declarationContext) AUTONOMOUS_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTONOMOUS_TRANSACTION, 0) +} + +func (s *Pragma_declarationContext) EXCEPTION_INIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION_INIT, 0) +} + +func (s *Pragma_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pragma_declarationContext) Exception_name() IException_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Pragma_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pragma_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pragma_declarationContext) Numeric_negative() INumeric_negativeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_negativeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_negativeContext) +} + +func (s *Pragma_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pragma_declarationContext) INLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE, 0) +} + +func (s *Pragma_declarationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pragma_declarationContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Pragma_declarationContext) DEPRECATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPRECATE, 0) +} + +func (s *Pragma_declarationContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Pragma_declarationContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Pragma_declarationContext) UDF() antlr.TerminalNode { + return s.GetToken(PlSqlParserUDF, 0) +} + +func (s *Pragma_declarationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Pragma_declarationContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Pragma_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_declaration(s) + } +} + +func (s *Pragma_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_declaration(s) + } +} + +func (p *PlSqlParser) Pragma_declaration() (localctx IPragma_declarationContext) { + localctx = NewPragma_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1754, PlSqlParserRULE_pragma_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16297) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSERIALLY_REUSABLE: + { + p.SetState(16298) + p.Match(PlSqlParserSERIALLY_REUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTONOMOUS_TRANSACTION: + { + p.SetState(16299) + p.Match(PlSqlParserAUTONOMOUS_TRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCEPTION_INIT: + { + p.SetState(16300) + p.Match(PlSqlParserEXCEPTION_INIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16301) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16302) + p.Exception_name() + } + { + p.SetState(16303) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16304) + p.Numeric_negative() + } + { + p.SetState(16305) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINLINE: + { + p.SetState(16307) + p.Match(PlSqlParserINLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16308) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16309) + + var _x = p.Identifier() + + localctx.(*Pragma_declarationContext).id1 = _x + } + { + p.SetState(16310) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16311) + p.Expression() + } + { + p.SetState(16312) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRESTRICT_REFERENCES: + { + p.SetState(16314) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16315) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16316) + p.Identifier() + } + + case PlSqlParserDEFAULT: + { + p.SetState(16317) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(16320) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16321) + p.Identifier() + } + + p.SetState(16324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16326) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEPRECATE: + { + p.SetState(16328) + p.Match(PlSqlParserDEPRECATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16329) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16330) + p.Identifier() + } + p.SetState(16333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(16331) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16332) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16335) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUDF: + { + p.SetState(16337) + p.Match(PlSqlParserUDF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16340) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecord_type_defContext is an interface to support dynamic dispatch. +type IRecord_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllField_spec() []IField_specContext + Field_spec(i int) IField_specContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRecord_type_defContext differentiates from other interfaces. + IsRecord_type_defContext() +} + +type Record_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecord_type_defContext() *Record_type_defContext { + var p = new(Record_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_type_def + return p +} + +func InitEmptyRecord_type_defContext(p *Record_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_type_def +} + +func (*Record_type_defContext) IsRecord_type_defContext() {} + +func NewRecord_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Record_type_defContext { + var p = new(Record_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_record_type_def + + return p +} + +func (s *Record_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Record_type_defContext) RECORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORD, 0) +} + +func (s *Record_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Record_type_defContext) AllField_spec() []IField_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IField_specContext); ok { + len++ + } + } + + tst := make([]IField_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IField_specContext); ok { + tst[i] = t.(IField_specContext) + i++ + } + } + + return tst +} + +func (s *Record_type_defContext) Field_spec(i int) IField_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IField_specContext) +} + +func (s *Record_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Record_type_defContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Record_type_defContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Record_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Record_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Record_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecord_type_def(s) + } +} + +func (s *Record_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecord_type_def(s) + } +} + +func (p *PlSqlParser) Record_type_def() (localctx IRecord_type_defContext) { + localctx = NewRecord_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1756, PlSqlParserRULE_record_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16342) + p.Match(PlSqlParserRECORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16343) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16344) + p.Field_spec() + } + p.SetState(16349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16345) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16346) + p.Field_spec() + } + + p.SetState(16351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16352) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IField_specContext is an interface to support dynamic dispatch. +type IField_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Type_spec() IType_specContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Default_value_part() IDefault_value_partContext + + // IsField_specContext differentiates from other interfaces. + IsField_specContext() +} + +type Field_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_specContext() *Field_specContext { + var p = new(Field_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_spec + return p +} + +func InitEmptyField_specContext(p *Field_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_spec +} + +func (*Field_specContext) IsField_specContext() {} + +func NewField_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_specContext { + var p = new(Field_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_spec + + return p +} + +func (s *Field_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_specContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Field_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Field_specContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Field_specContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Field_specContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Field_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_spec(s) + } +} + +func (s *Field_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_spec(s) + } +} + +func (p *PlSqlParser) Field_spec() (localctx IField_specContext) { + localctx = NewField_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1758, PlSqlParserRULE_field_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16354) + p.Column_name() + } + p.SetState(16356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-145152714736643) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-131073) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(16355) + p.Type_spec() + } + + } + p.SetState(16360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(16358) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16359) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(16362) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRef_cursor_type_defContext is an interface to support dynamic dispatch. +type IRef_cursor_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REF() antlr.TerminalNode + CURSOR() antlr.TerminalNode + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + + // IsRef_cursor_type_defContext differentiates from other interfaces. + IsRef_cursor_type_defContext() +} + +type Ref_cursor_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRef_cursor_type_defContext() *Ref_cursor_type_defContext { + var p = new(Ref_cursor_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def + return p +} + +func InitEmptyRef_cursor_type_defContext(p *Ref_cursor_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def +} + +func (*Ref_cursor_type_defContext) IsRef_cursor_type_defContext() {} + +func NewRef_cursor_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ref_cursor_type_defContext { + var p = new(Ref_cursor_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def + + return p +} + +func (s *Ref_cursor_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ref_cursor_type_defContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Ref_cursor_type_defContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Ref_cursor_type_defContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Ref_cursor_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Ref_cursor_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ref_cursor_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ref_cursor_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRef_cursor_type_def(s) + } +} + +func (s *Ref_cursor_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRef_cursor_type_def(s) + } +} + +func (p *PlSqlParser) Ref_cursor_type_def() (localctx IRef_cursor_type_defContext) { + localctx = NewRef_cursor_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1760, PlSqlParserRULE_ref_cursor_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16365) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16366) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(16367) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16368) + p.Type_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_declarationContext is an interface to support dynamic dispatch. +type IType_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TYPE() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Table_type_def() ITable_type_defContext + Varray_type_def() IVarray_type_defContext + Record_type_def() IRecord_type_defContext + Ref_cursor_type_def() IRef_cursor_type_defContext + + // IsType_declarationContext differentiates from other interfaces. + IsType_declarationContext() +} + +type Type_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_declarationContext() *Type_declarationContext { + var p = new(Type_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_declaration + return p +} + +func InitEmptyType_declarationContext(p *Type_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_declaration +} + +func (*Type_declarationContext) IsType_declarationContext() {} + +func NewType_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_declarationContext { + var p = new(Type_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_declaration + + return p +} + +func (s *Type_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_declarationContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Type_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Type_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Type_declarationContext) Table_type_def() ITable_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_type_defContext) +} + +func (s *Type_declarationContext) Varray_type_def() IVarray_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_type_defContext) +} + +func (s *Type_declarationContext) Record_type_def() IRecord_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecord_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecord_type_defContext) +} + +func (s *Type_declarationContext) Ref_cursor_type_def() IRef_cursor_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRef_cursor_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRef_cursor_type_defContext) +} + +func (s *Type_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_declaration(s) + } +} + +func (s *Type_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_declaration(s) + } +} + +func (p *PlSqlParser) Type_declaration() (localctx IType_declarationContext) { + localctx = NewType_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1762, PlSqlParserRULE_type_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16371) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16372) + p.Identifier() + } + { + p.SetState(16373) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(16374) + p.Table_type_def() + } + + case PlSqlParserARRAY, PlSqlParserVARRAY, PlSqlParserVARYING: + { + p.SetState(16375) + p.Varray_type_def() + } + + case PlSqlParserRECORD: + { + p.SetState(16376) + p.Record_type_def() + } + + case PlSqlParserREF: + { + p.SetState(16377) + p.Ref_cursor_type_def() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16380) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_type_defContext is an interface to support dynamic dispatch. +type ITable_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Table_indexed_by_part() ITable_indexed_by_partContext + + // IsTable_type_defContext differentiates from other interfaces. + IsTable_type_defContext() +} + +type Table_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_type_defContext() *Table_type_defContext { + var p = new(Table_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_type_def + return p +} + +func InitEmptyTable_type_defContext(p *Table_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_type_def +} + +func (*Table_type_defContext) IsTable_type_defContext() {} + +func NewTable_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_type_defContext { + var p = new(Table_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_type_def + + return p +} + +func (s *Table_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_type_defContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Table_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Table_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Table_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Table_type_defContext) Table_indexed_by_part() ITable_indexed_by_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_indexed_by_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_indexed_by_partContext) +} + +func (s *Table_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_type_def(s) + } +} + +func (s *Table_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_type_def(s) + } +} + +func (p *PlSqlParser) Table_type_def() (localctx ITable_type_defContext) { + localctx = NewTable_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1764, PlSqlParserRULE_table_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16382) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16383) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16384) + p.Type_spec() + } + p.SetState(16387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(16385) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16386) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXED || _la == PlSqlParserINDEX { + { + p.SetState(16389) + p.Table_indexed_by_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_indexed_by_partContext is an interface to support dynamic dispatch. +type ITable_indexed_by_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIdx1 returns the idx1 token. + GetIdx1() antlr.Token + + // GetIdx2 returns the idx2 token. + GetIdx2() antlr.Token + + // SetIdx1 sets the idx1 token. + SetIdx1(antlr.Token) + + // SetIdx2 sets the idx2 token. + SetIdx2(antlr.Token) + + // Getter signatures + BY() antlr.TerminalNode + Type_spec() IType_specContext + INDEXED() antlr.TerminalNode + INDEX() antlr.TerminalNode + + // IsTable_indexed_by_partContext differentiates from other interfaces. + IsTable_indexed_by_partContext() +} + +type Table_indexed_by_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + idx1 antlr.Token + idx2 antlr.Token +} + +func NewEmptyTable_indexed_by_partContext() *Table_indexed_by_partContext { + var p = new(Table_indexed_by_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part + return p +} + +func InitEmptyTable_indexed_by_partContext(p *Table_indexed_by_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part +} + +func (*Table_indexed_by_partContext) IsTable_indexed_by_partContext() {} + +func NewTable_indexed_by_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_indexed_by_partContext { + var p = new(Table_indexed_by_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part + + return p +} + +func (s *Table_indexed_by_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_indexed_by_partContext) GetIdx1() antlr.Token { return s.idx1 } + +func (s *Table_indexed_by_partContext) GetIdx2() antlr.Token { return s.idx2 } + +func (s *Table_indexed_by_partContext) SetIdx1(v antlr.Token) { s.idx1 = v } + +func (s *Table_indexed_by_partContext) SetIdx2(v antlr.Token) { s.idx2 = v } + +func (s *Table_indexed_by_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Table_indexed_by_partContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Table_indexed_by_partContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *Table_indexed_by_partContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Table_indexed_by_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_indexed_by_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_indexed_by_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_indexed_by_part(s) + } +} + +func (s *Table_indexed_by_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_indexed_by_part(s) + } +} + +func (p *PlSqlParser) Table_indexed_by_part() (localctx ITable_indexed_by_partContext) { + localctx = NewTable_indexed_by_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1766, PlSqlParserRULE_table_indexed_by_part) + p.EnterOuterAlt(localctx, 1) + p.SetState(16394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINDEXED: + { + p.SetState(16392) + + var _m = p.Match(PlSqlParserINDEXED) + + localctx.(*Table_indexed_by_partContext).idx1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDEX: + { + p.SetState(16393) + + var _m = p.Match(PlSqlParserINDEX) + + localctx.(*Table_indexed_by_partContext).idx2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16396) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16397) + p.Type_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_type_defContext is an interface to support dynamic dispatch. +type IVarray_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + VARRAY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + VARYING() antlr.TerminalNode + + // IsVarray_type_defContext differentiates from other interfaces. + IsVarray_type_defContext() +} + +type Varray_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_type_defContext() *Varray_type_defContext { + var p = new(Varray_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_type_def + return p +} + +func InitEmptyVarray_type_defContext(p *Varray_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_type_def +} + +func (*Varray_type_defContext) IsVarray_type_defContext() {} + +func NewVarray_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_type_defContext { + var p = new(Varray_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_type_def + + return p +} + +func (s *Varray_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Varray_type_defContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Varray_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Varray_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Varray_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Varray_type_defContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Varray_type_defContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Varray_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Varray_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Varray_type_defContext) VARYING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARYING, 0) +} + +func (s *Varray_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_type_def(s) + } +} + +func (s *Varray_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_type_def(s) + } +} + +func (p *PlSqlParser) Varray_type_def() (localctx IVarray_type_defContext) { + localctx = NewVarray_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1768, PlSqlParserRULE_varray_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARRAY: + { + p.SetState(16399) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARRAY, PlSqlParserVARYING: + p.SetState(16401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVARYING { + { + p.SetState(16400) + p.Match(PlSqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16403) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16406) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16407) + p.Expression() + } + { + p.SetState(16408) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16409) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16410) + p.Type_spec() + } + p.SetState(16413) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2229, p.GetParserRuleContext()) == 1 { + { + p.SetState(16411) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16412) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeq_of_statementsContext is an interface to support dynamic dispatch. +type ISeq_of_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStatement() []IStatementContext + Statement(i int) IStatementContext + AllLabel_declaration() []ILabel_declarationContext + Label_declaration(i int) ILabel_declarationContext + AllSelection_directive() []ISelection_directiveContext + Selection_directive(i int) ISelection_directiveContext + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllEOF() []antlr.TerminalNode + EOF(i int) antlr.TerminalNode + AllPragma_declaration() []IPragma_declarationContext + Pragma_declaration(i int) IPragma_declarationContext + + // IsSeq_of_statementsContext differentiates from other interfaces. + IsSeq_of_statementsContext() +} + +type Seq_of_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeq_of_statementsContext() *Seq_of_statementsContext { + var p = new(Seq_of_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_statements + return p +} + +func InitEmptySeq_of_statementsContext(p *Seq_of_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_statements +} + +func (*Seq_of_statementsContext) IsSeq_of_statementsContext() {} + +func NewSeq_of_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seq_of_statementsContext { + var p = new(Seq_of_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seq_of_statements + + return p +} + +func (s *Seq_of_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seq_of_statementsContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *Seq_of_statementsContext) AllLabel_declaration() []ILabel_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_declarationContext); ok { + len++ + } + } + + tst := make([]ILabel_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_declarationContext); ok { + tst[i] = t.(ILabel_declarationContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Label_declaration(i int) ILabel_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Seq_of_statementsContext) AllSelection_directive() []ISelection_directiveContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelection_directiveContext); ok { + len++ + } + } + + tst := make([]ISelection_directiveContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelection_directiveContext); ok { + tst[i] = t.(ISelection_directiveContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Selection_directive(i int) ISelection_directiveContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelection_directiveContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelection_directiveContext) +} + +func (s *Seq_of_statementsContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Seq_of_statementsContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Seq_of_statementsContext) AllEOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEOF) +} + +func (s *Seq_of_statementsContext) EOF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEOF, i) +} + +func (s *Seq_of_statementsContext) AllPragma_declaration() []IPragma_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPragma_declarationContext); ok { + len++ + } + } + + tst := make([]IPragma_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPragma_declarationContext); ok { + tst[i] = t.(IPragma_declarationContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Pragma_declaration(i int) IPragma_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Seq_of_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seq_of_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seq_of_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeq_of_statements(s) + } +} + +func (s *Seq_of_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeq_of_statements(s) + } +} + +func (p *PlSqlParser) Seq_of_statements() (localctx ISeq_of_statementsContext) { + localctx = NewSeq_of_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1770, PlSqlParserRULE_seq_of_statements) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(16426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2231, p.GetParserRuleContext()) { + case 1: + p.SetState(16418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2230, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16415) + p.Pragma_declaration() + } + + } + p.SetState(16420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2230, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(16421) + p.Statement() + } + { + p.SetState(16422) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEOF || _la == PlSqlParserSEMICOLON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(16424) + p.Label_declaration() + } + + case 3: + { + p.SetState(16425) + p.Selection_directive() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16428) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2232, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_declarationContext is an interface to support dynamic dispatch. +type ILabel_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLtp1 returns the ltp1 token. + GetLtp1() antlr.Token + + // SetLtp1 sets the ltp1 token. + SetLtp1(antlr.Token) + + // Getter signatures + AllLESS_THAN_OP() []antlr.TerminalNode + LESS_THAN_OP(i int) antlr.TerminalNode + Label_name() ILabel_nameContext + AllGREATER_THAN_OP() []antlr.TerminalNode + GREATER_THAN_OP(i int) antlr.TerminalNode + + // IsLabel_declarationContext differentiates from other interfaces. + IsLabel_declarationContext() +} + +type Label_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ltp1 antlr.Token +} + +func NewEmptyLabel_declarationContext() *Label_declarationContext { + var p = new(Label_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_declaration + return p +} + +func InitEmptyLabel_declarationContext(p *Label_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_declaration +} + +func (*Label_declarationContext) IsLabel_declarationContext() {} + +func NewLabel_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_declarationContext { + var p = new(Label_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_label_declaration + + return p +} + +func (s *Label_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_declarationContext) GetLtp1() antlr.Token { return s.ltp1 } + +func (s *Label_declarationContext) SetLtp1(v antlr.Token) { s.ltp1 = v } + +func (s *Label_declarationContext) AllLESS_THAN_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLESS_THAN_OP) +} + +func (s *Label_declarationContext) LESS_THAN_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS_THAN_OP, i) +} + +func (s *Label_declarationContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Label_declarationContext) AllGREATER_THAN_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGREATER_THAN_OP) +} + +func (s *Label_declarationContext) GREATER_THAN_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, i) +} + +func (s *Label_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLabel_declaration(s) + } +} + +func (s *Label_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLabel_declaration(s) + } +} + +func (p *PlSqlParser) Label_declaration() (localctx ILabel_declarationContext) { + localctx = NewLabel_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1772, PlSqlParserRULE_label_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16430) + + var _m = p.Match(PlSqlParserLESS_THAN_OP) + + localctx.(*Label_declarationContext).ltp1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16431) + p.Match(PlSqlParserLESS_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16432) + p.Label_name() + } + { + p.SetState(16433) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16434) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatementContext is an interface to support dynamic dispatch. +type IStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + Block() IBlockContext + Assignment_statement() IAssignment_statementContext + Continue_statement() IContinue_statementContext + Exit_statement() IExit_statementContext + Goto_statement() IGoto_statementContext + If_statement() IIf_statementContext + Loop_statement() ILoop_statementContext + Forall_statement() IForall_statementContext + Null_statement() INull_statementContext + Raise_statement() IRaise_statementContext + Return_statement() IReturn_statementContext + Case_statement() ICase_statementContext + Sql_statement() ISql_statementContext + Call_statement() ICall_statementContext + Pipe_row_statement() IPipe_row_statementContext + Grant_statement() IGrant_statementContext + + // IsStatementContext differentiates from other interfaces. + IsStatementContext() +} + +type StatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementContext() *StatementContext { + var p = new(StatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement + return p +} + +func InitEmptyStatementContext(p *StatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement +} + +func (*StatementContext) IsStatementContext() {} + +func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext { + var p = new(StatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statement + + return p +} + +func (s *StatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *StatementContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *StatementContext) Assignment_statement() IAssignment_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_statementContext) +} + +func (s *StatementContext) Continue_statement() IContinue_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContinue_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContinue_statementContext) +} + +func (s *StatementContext) Exit_statement() IExit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExit_statementContext) +} + +func (s *StatementContext) Goto_statement() IGoto_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGoto_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGoto_statementContext) +} + +func (s *StatementContext) If_statement() IIf_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_statementContext) +} + +func (s *StatementContext) Loop_statement() ILoop_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_statementContext) +} + +func (s *StatementContext) Forall_statement() IForall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForall_statementContext) +} + +func (s *StatementContext) Null_statement() INull_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_statementContext) +} + +func (s *StatementContext) Raise_statement() IRaise_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaise_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaise_statementContext) +} + +func (s *StatementContext) Return_statement() IReturn_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_statementContext) +} + +func (s *StatementContext) Case_statement() ICase_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_statementContext) +} + +func (s *StatementContext) Sql_statement() ISql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_statementContext) +} + +func (s *StatementContext) Call_statement() ICall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_statementContext) +} + +func (s *StatementContext) Pipe_row_statement() IPipe_row_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPipe_row_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPipe_row_statementContext) +} + +func (s *StatementContext) Grant_statement() IGrant_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_statementContext) +} + +func (s *StatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatement(s) + } +} + +func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatement(s) + } +} + +func (p *PlSqlParser) Statement() (localctx IStatementContext) { + localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1774, PlSqlParserRULE_statement) + p.SetState(16453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2233, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16436) + p.Body() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16437) + p.Block() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16438) + p.Assignment_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16439) + p.Continue_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16440) + p.Exit_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(16441) + p.Goto_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(16442) + p.If_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(16443) + p.Loop_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(16444) + p.Forall_statement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(16445) + p.Null_statement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(16446) + p.Raise_statement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(16447) + p.Return_statement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(16448) + p.Case_statement() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(16449) + p.Sql_statement() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(16450) + p.Call_statement() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(16451) + p.Pipe_row_statement() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(16452) + p.Grant_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignment_statementContext is an interface to support dynamic dispatch. +type IAssignment_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSIGN_OP() antlr.TerminalNode + Expression() IExpressionContext + General_element() IGeneral_elementContext + Bind_variable() IBind_variableContext + + // IsAssignment_statementContext differentiates from other interfaces. + IsAssignment_statementContext() +} + +type Assignment_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignment_statementContext() *Assignment_statementContext { + var p = new(Assignment_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignment_statement + return p +} + +func InitEmptyAssignment_statementContext(p *Assignment_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignment_statement +} + +func (*Assignment_statementContext) IsAssignment_statementContext() {} + +func NewAssignment_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_statementContext { + var p = new(Assignment_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_assignment_statement + + return p +} + +func (s *Assignment_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assignment_statementContext) ASSIGN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN_OP, 0) +} + +func (s *Assignment_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Assignment_statementContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Assignment_statementContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Assignment_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assignment_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assignment_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAssignment_statement(s) + } +} + +func (s *Assignment_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAssignment_statement(s) + } +} + +func (p *PlSqlParser) Assignment_statement() (localctx IAssignment_statementContext) { + localctx = NewAssignment_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1776, PlSqlParserRULE_assignment_statement) + p.EnterOuterAlt(localctx, 1) + p.SetState(16457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16455) + p.general_element(0) + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(16456) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16459) + p.Match(PlSqlParserASSIGN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16460) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContinue_statementContext is an interface to support dynamic dispatch. +type IContinue_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTINUE() antlr.TerminalNode + Label_name() ILabel_nameContext + WHEN() antlr.TerminalNode + Condition() IConditionContext + + // IsContinue_statementContext differentiates from other interfaces. + IsContinue_statementContext() +} + +type Continue_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContinue_statementContext() *Continue_statementContext { + var p = new(Continue_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_continue_statement + return p +} + +func InitEmptyContinue_statementContext(p *Continue_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_continue_statement +} + +func (*Continue_statementContext) IsContinue_statementContext() {} + +func NewContinue_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_statementContext { + var p = new(Continue_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_continue_statement + + return p +} + +func (s *Continue_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Continue_statementContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Continue_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Continue_statementContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Continue_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Continue_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Continue_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Continue_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContinue_statement(s) + } +} + +func (s *Continue_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContinue_statement(s) + } +} + +func (p *PlSqlParser) Continue_statement() (localctx IContinue_statementContext) { + localctx = NewContinue_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1778, PlSqlParserRULE_continue_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16462) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16464) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2235, p.GetParserRuleContext()) == 1 { + { + p.SetState(16463) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(16466) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16467) + p.Condition() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExit_statementContext is an interface to support dynamic dispatch. +type IExit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXIT() antlr.TerminalNode + Label_name() ILabel_nameContext + WHEN() antlr.TerminalNode + Condition() IConditionContext + + // IsExit_statementContext differentiates from other interfaces. + IsExit_statementContext() +} + +type Exit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExit_statementContext() *Exit_statementContext { + var p = new(Exit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exit_statement + return p +} + +func InitEmptyExit_statementContext(p *Exit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exit_statement +} + +func (*Exit_statementContext) IsExit_statementContext() {} + +func NewExit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exit_statementContext { + var p = new(Exit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exit_statement + + return p +} + +func (s *Exit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exit_statementContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Exit_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Exit_statementContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Exit_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Exit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExit_statement(s) + } +} + +func (s *Exit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExit_statement(s) + } +} + +func (p *PlSqlParser) Exit_statement() (localctx IExit_statementContext) { + localctx = NewExit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1780, PlSqlParserRULE_exit_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16470) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16472) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2237, p.GetParserRuleContext()) == 1 { + { + p.SetState(16471) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(16474) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16475) + p.Condition() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGoto_statementContext is an interface to support dynamic dispatch. +type IGoto_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GOTO() antlr.TerminalNode + Label_name() ILabel_nameContext + + // IsGoto_statementContext differentiates from other interfaces. + IsGoto_statementContext() +} + +type Goto_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGoto_statementContext() *Goto_statementContext { + var p = new(Goto_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_goto_statement + return p +} + +func InitEmptyGoto_statementContext(p *Goto_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_goto_statement +} + +func (*Goto_statementContext) IsGoto_statementContext() {} + +func NewGoto_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Goto_statementContext { + var p = new(Goto_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_goto_statement + + return p +} + +func (s *Goto_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Goto_statementContext) GOTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserGOTO, 0) +} + +func (s *Goto_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Goto_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Goto_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Goto_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGoto_statement(s) + } +} + +func (s *Goto_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGoto_statement(s) + } +} + +func (p *PlSqlParser) Goto_statement() (localctx IGoto_statementContext) { + localctx = NewGoto_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1782, PlSqlParserRULE_goto_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16478) + p.Match(PlSqlParserGOTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16479) + p.Label_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIf_statementContext is an interface to support dynamic dispatch. +type IIf_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIF() []antlr.TerminalNode + IF(i int) antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + AllElsif_part() []IElsif_partContext + Elsif_part(i int) IElsif_partContext + Else_part() IElse_partContext + + // IsIf_statementContext differentiates from other interfaces. + IsIf_statementContext() +} + +type If_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_statementContext() *If_statementContext { + var p = new(If_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_if_statement + return p +} + +func InitEmptyIf_statementContext(p *If_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_if_statement +} + +func (*If_statementContext) IsIf_statementContext() {} + +func NewIf_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_statementContext { + var p = new(If_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_if_statement + + return p +} + +func (s *If_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_statementContext) AllIF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIF) +} + +func (s *If_statementContext) IF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, i) +} + +func (s *If_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *If_statementContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *If_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *If_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *If_statementContext) AllElsif_part() []IElsif_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElsif_partContext); ok { + len++ + } + } + + tst := make([]IElsif_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElsif_partContext); ok { + tst[i] = t.(IElsif_partContext) + i++ + } + } + + return tst +} + +func (s *If_statementContext) Elsif_part(i int) IElsif_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElsif_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElsif_partContext) +} + +func (s *If_statementContext) Else_part() IElse_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElse_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElse_partContext) +} + +func (s *If_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIf_statement(s) + } +} + +func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIf_statement(s) + } +} + +func (p *PlSqlParser) If_statement() (localctx IIf_statementContext) { + localctx = NewIf_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1784, PlSqlParserRULE_if_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16481) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16482) + p.Condition() + } + { + p.SetState(16483) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16484) + p.Seq_of_statements() + } + p.SetState(16488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserELSIF { + { + p.SetState(16485) + p.Elsif_part() + } + + p.SetState(16490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(16492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(16491) + p.Else_part() + } + + } + { + p.SetState(16494) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16495) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElsif_partContext is an interface to support dynamic dispatch. +type IElsif_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSIF() antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsElsif_partContext differentiates from other interfaces. + IsElsif_partContext() +} + +type Elsif_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElsif_partContext() *Elsif_partContext { + var p = new(Elsif_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_elsif_part + return p +} + +func InitEmptyElsif_partContext(p *Elsif_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_elsif_part +} + +func (*Elsif_partContext) IsElsif_partContext() {} + +func NewElsif_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Elsif_partContext { + var p = new(Elsif_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_elsif_part + + return p +} + +func (s *Elsif_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Elsif_partContext) ELSIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSIF, 0) +} + +func (s *Elsif_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Elsif_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Elsif_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Elsif_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Elsif_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Elsif_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElsif_part(s) + } +} + +func (s *Elsif_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElsif_part(s) + } +} + +func (p *PlSqlParser) Elsif_part() (localctx IElsif_partContext) { + localctx = NewElsif_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1786, PlSqlParserRULE_elsif_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16497) + p.Match(PlSqlParserELSIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16498) + p.Condition() + } + { + p.SetState(16499) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16500) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElse_partContext is an interface to support dynamic dispatch. +type IElse_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsElse_partContext differentiates from other interfaces. + IsElse_partContext() +} + +type Else_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElse_partContext() *Else_partContext { + var p = new(Else_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_else_part + return p +} + +func InitEmptyElse_partContext(p *Else_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_else_part +} + +func (*Else_partContext) IsElse_partContext() {} + +func NewElse_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Else_partContext { + var p = new(Else_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_else_part + + return p +} + +func (s *Else_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Else_partContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Else_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Else_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Else_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Else_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElse_part(s) + } +} + +func (s *Else_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElse_part(s) + } +} + +func (p *PlSqlParser) Else_part() (localctx IElse_partContext) { + localctx = NewElse_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1788, PlSqlParserRULE_else_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16502) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16503) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoop_statementContext is an interface to support dynamic dispatch. +type ILoop_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOOP() []antlr.TerminalNode + LOOP(i int) antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + Label_declaration() ILabel_declarationContext + WHILE() antlr.TerminalNode + Condition() IConditionContext + FOR() antlr.TerminalNode + Cursor_loop_param() ICursor_loop_paramContext + Label_name() ILabel_nameContext + + // IsLoop_statementContext differentiates from other interfaces. + IsLoop_statementContext() +} + +type Loop_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoop_statementContext() *Loop_statementContext { + var p = new(Loop_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_loop_statement + return p +} + +func InitEmptyLoop_statementContext(p *Loop_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_loop_statement +} + +func (*Loop_statementContext) IsLoop_statementContext() {} + +func NewLoop_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_statementContext { + var p = new(Loop_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_loop_statement + + return p +} + +func (s *Loop_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Loop_statementContext) AllLOOP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOOP) +} + +func (s *Loop_statementContext) LOOP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOOP, i) +} + +func (s *Loop_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Loop_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Loop_statementContext) Label_declaration() ILabel_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Loop_statementContext) WHILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHILE, 0) +} + +func (s *Loop_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Loop_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Loop_statementContext) Cursor_loop_param() ICursor_loop_paramContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_loop_paramContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_loop_paramContext) +} + +func (s *Loop_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Loop_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Loop_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Loop_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLoop_statement(s) + } +} + +func (s *Loop_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLoop_statement(s) + } +} + +func (p *PlSqlParser) Loop_statement() (localctx ILoop_statementContext) { + localctx = NewLoop_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1790, PlSqlParserRULE_loop_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLESS_THAN_OP { + { + p.SetState(16505) + p.Label_declaration() + } + + } + p.SetState(16512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserWHILE: + { + p.SetState(16508) + p.Match(PlSqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16509) + p.Condition() + } + + case PlSqlParserFOR: + { + p.SetState(16510) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16511) + p.Cursor_loop_param() + } + + case PlSqlParserLOOP: + + default: + } + { + p.SetState(16514) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16515) + p.Seq_of_statements() + } + { + p.SetState(16516) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16517) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(16518) + p.Label_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_loop_paramContext is an interface to support dynamic dispatch. +type ICursor_loop_paramContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRange_separator returns the range_separator token. + GetRange_separator() antlr.Token + + // SetRange_separator sets the range_separator token. + SetRange_separator(antlr.Token) + + // Getter signatures + Index_name() IIndex_nameContext + IN() antlr.TerminalNode + Lower_bound() ILower_boundContext + Upper_bound() IUpper_boundContext + DOUBLE_PERIOD() antlr.TerminalNode + REVERSE() antlr.TerminalNode + Record_name() IRecord_nameContext + Cursor_name() ICursor_nameContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + + // IsCursor_loop_paramContext differentiates from other interfaces. + IsCursor_loop_paramContext() +} + +type Cursor_loop_paramContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + range_separator antlr.Token +} + +func NewEmptyCursor_loop_paramContext() *Cursor_loop_paramContext { + var p = new(Cursor_loop_paramContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_loop_param + return p +} + +func InitEmptyCursor_loop_paramContext(p *Cursor_loop_paramContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_loop_param +} + +func (*Cursor_loop_paramContext) IsCursor_loop_paramContext() {} + +func NewCursor_loop_paramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_loop_paramContext { + var p = new(Cursor_loop_paramContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_loop_param + + return p +} + +func (s *Cursor_loop_paramContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_loop_paramContext) GetRange_separator() antlr.Token { return s.range_separator } + +func (s *Cursor_loop_paramContext) SetRange_separator(v antlr.Token) { s.range_separator = v } + +func (s *Cursor_loop_paramContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Cursor_loop_paramContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Cursor_loop_paramContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Cursor_loop_paramContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Cursor_loop_paramContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Cursor_loop_paramContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Cursor_loop_paramContext) Record_name() IRecord_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecord_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecord_nameContext) +} + +func (s *Cursor_loop_paramContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Cursor_loop_paramContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_loop_paramContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Cursor_loop_paramContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_loop_paramContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Cursor_loop_paramContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_loop_paramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_loop_paramContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_loop_param(s) + } +} + +func (s *Cursor_loop_paramContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_loop_param(s) + } +} + +func (p *PlSqlParser) Cursor_loop_param() (localctx ICursor_loop_paramContext) { + localctx = NewCursor_loop_paramContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1792, PlSqlParserRULE_cursor_loop_param) + var _la int + + p.SetState(16546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2248, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16521) + p.Index_name() + } + { + p.SetState(16522) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16524) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2244, p.GetParserRuleContext()) == 1 { + { + p.SetState(16523) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16526) + p.Lower_bound() + } + { + p.SetState(16527) + + var _m = p.Match(PlSqlParserDOUBLE_PERIOD) + + localctx.(*Cursor_loop_paramContext).range_separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16528) + p.Upper_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16530) + p.Record_name() + } + { + p.SetState(16531) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2247, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16532) + p.Cursor_name() + } + p.SetState(16538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16533) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16535) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2245, p.GetParserRuleContext()) == 1 { + { + p.SetState(16534) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16537) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + { + p.SetState(16540) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16541) + p.Select_statement() + } + { + p.SetState(16542) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForall_statementContext is an interface to support dynamic dispatch. +type IForall_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORALL() antlr.TerminalNode + Index_name() IIndex_nameContext + IN() antlr.TerminalNode + Bounds_clause() IBounds_clauseContext + Data_manipulation_language_statements() IData_manipulation_language_statementsContext + Execute_immediate() IExecute_immediateContext + SAVE() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + + // IsForall_statementContext differentiates from other interfaces. + IsForall_statementContext() +} + +type Forall_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForall_statementContext() *Forall_statementContext { + var p = new(Forall_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_forall_statement + return p +} + +func InitEmptyForall_statementContext(p *Forall_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_forall_statement +} + +func (*Forall_statementContext) IsForall_statementContext() {} + +func NewForall_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Forall_statementContext { + var p = new(Forall_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_forall_statement + + return p +} + +func (s *Forall_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Forall_statementContext) FORALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORALL, 0) +} + +func (s *Forall_statementContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Forall_statementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Forall_statementContext) Bounds_clause() IBounds_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBounds_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBounds_clauseContext) +} + +func (s *Forall_statementContext) Data_manipulation_language_statements() IData_manipulation_language_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_manipulation_language_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_manipulation_language_statementsContext) +} + +func (s *Forall_statementContext) Execute_immediate() IExecute_immediateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_immediateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_immediateContext) +} + +func (s *Forall_statementContext) SAVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE, 0) +} + +func (s *Forall_statementContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Forall_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Forall_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Forall_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForall_statement(s) + } +} + +func (s *Forall_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForall_statement(s) + } +} + +func (p *PlSqlParser) Forall_statement() (localctx IForall_statementContext) { + localctx = NewForall_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1794, PlSqlParserRULE_forall_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16548) + p.Match(PlSqlParserFORALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16549) + p.Index_name() + } + { + p.SetState(16550) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16551) + p.Bounds_clause() + } + p.SetState(16554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSAVE { + { + p.SetState(16552) + p.Match(PlSqlParserSAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16553) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDELETE, PlSqlParserEXPLAIN, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserMERGE, PlSqlParserSELECT, PlSqlParserUPDATE, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(16556) + p.Data_manipulation_language_statements() + } + + case PlSqlParserEXECUTE: + { + p.SetState(16557) + p.Execute_immediate() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBounds_clauseContext is an interface to support dynamic dispatch. +type IBounds_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Lower_bound() ILower_boundContext + DOUBLE_PERIOD() antlr.TerminalNode + Upper_bound() IUpper_boundContext + INDICES() antlr.TerminalNode + OF() antlr.TerminalNode + General_element() IGeneral_elementContext + Between_bound() IBetween_boundContext + VALUES() antlr.TerminalNode + Index_name() IIndex_nameContext + + // IsBounds_clauseContext differentiates from other interfaces. + IsBounds_clauseContext() +} + +type Bounds_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBounds_clauseContext() *Bounds_clauseContext { + var p = new(Bounds_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bounds_clause + return p +} + +func InitEmptyBounds_clauseContext(p *Bounds_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bounds_clause +} + +func (*Bounds_clauseContext) IsBounds_clauseContext() {} + +func NewBounds_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bounds_clauseContext { + var p = new(Bounds_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bounds_clause + + return p +} + +func (s *Bounds_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bounds_clauseContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Bounds_clauseContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Bounds_clauseContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Bounds_clauseContext) INDICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICES, 0) +} + +func (s *Bounds_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Bounds_clauseContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Bounds_clauseContext) Between_bound() IBetween_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_boundContext) +} + +func (s *Bounds_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Bounds_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Bounds_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bounds_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bounds_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBounds_clause(s) + } +} + +func (s *Bounds_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBounds_clause(s) + } +} + +func (p *PlSqlParser) Bounds_clause() (localctx IBounds_clauseContext) { + localctx = NewBounds_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1796, PlSqlParserRULE_bounds_clause) + var _la int + + p.SetState(16573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2252, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16560) + p.Lower_bound() + } + { + p.SetState(16561) + p.Match(PlSqlParserDOUBLE_PERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16562) + p.Upper_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16564) + p.Match(PlSqlParserINDICES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16565) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16566) + p.general_element(0) + } + p.SetState(16568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBETWEEN { + { + p.SetState(16567) + p.Between_bound() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16570) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16571) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16572) + p.Index_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBetween_boundContext is an interface to support dynamic dispatch. +type IBetween_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BETWEEN() antlr.TerminalNode + Lower_bound() ILower_boundContext + AND() antlr.TerminalNode + Upper_bound() IUpper_boundContext + + // IsBetween_boundContext differentiates from other interfaces. + IsBetween_boundContext() +} + +type Between_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBetween_boundContext() *Between_boundContext { + var p = new(Between_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_bound + return p +} + +func InitEmptyBetween_boundContext(p *Between_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_bound +} + +func (*Between_boundContext) IsBetween_boundContext() {} + +func NewBetween_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Between_boundContext { + var p = new(Between_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_between_bound + + return p +} + +func (s *Between_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Between_boundContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Between_boundContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Between_boundContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Between_boundContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Between_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Between_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Between_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBetween_bound(s) + } +} + +func (s *Between_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBetween_bound(s) + } +} + +func (p *PlSqlParser) Between_bound() (localctx IBetween_boundContext) { + localctx = NewBetween_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1798, PlSqlParserRULE_between_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16575) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16576) + p.Lower_bound() + } + { + p.SetState(16577) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16578) + p.Upper_bound() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILower_boundContext is an interface to support dynamic dispatch. +type ILower_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Concatenation() IConcatenationContext + + // IsLower_boundContext differentiates from other interfaces. + IsLower_boundContext() +} + +type Lower_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLower_boundContext() *Lower_boundContext { + var p = new(Lower_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lower_bound + return p +} + +func InitEmptyLower_boundContext(p *Lower_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lower_bound +} + +func (*Lower_boundContext) IsLower_boundContext() {} + +func NewLower_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lower_boundContext { + var p = new(Lower_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lower_bound + + return p +} + +func (s *Lower_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lower_boundContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Lower_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lower_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lower_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLower_bound(s) + } +} + +func (s *Lower_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLower_bound(s) + } +} + +func (p *PlSqlParser) Lower_bound() (localctx ILower_boundContext) { + localctx = NewLower_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1800, PlSqlParserRULE_lower_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16580) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpper_boundContext is an interface to support dynamic dispatch. +type IUpper_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Concatenation() IConcatenationContext + + // IsUpper_boundContext differentiates from other interfaces. + IsUpper_boundContext() +} + +type Upper_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpper_boundContext() *Upper_boundContext { + var p = new(Upper_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upper_bound + return p +} + +func InitEmptyUpper_boundContext(p *Upper_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upper_bound +} + +func (*Upper_boundContext) IsUpper_boundContext() {} + +func NewUpper_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upper_boundContext { + var p = new(Upper_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upper_bound + + return p +} + +func (s *Upper_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upper_boundContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Upper_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upper_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upper_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpper_bound(s) + } +} + +func (s *Upper_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpper_bound(s) + } +} + +func (p *PlSqlParser) Upper_bound() (localctx IUpper_boundContext) { + localctx = NewUpper_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1802, PlSqlParserRULE_upper_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16582) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INull_statementContext is an interface to support dynamic dispatch. +type INull_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + + // IsNull_statementContext differentiates from other interfaces. + IsNull_statementContext() +} + +type Null_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_statementContext() *Null_statementContext { + var p = new(Null_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_null_statement + return p +} + +func InitEmptyNull_statementContext(p *Null_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_null_statement +} + +func (*Null_statementContext) IsNull_statementContext() {} + +func NewNull_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_statementContext { + var p = new(Null_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_null_statement + + return p +} + +func (s *Null_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_statementContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Null_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNull_statement(s) + } +} + +func (s *Null_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNull_statement(s) + } +} + +func (p *PlSqlParser) Null_statement() (localctx INull_statementContext) { + localctx = NewNull_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1804, PlSqlParserRULE_null_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16584) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaise_statementContext is an interface to support dynamic dispatch. +type IRaise_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAISE() antlr.TerminalNode + Exception_name() IException_nameContext + + // IsRaise_statementContext differentiates from other interfaces. + IsRaise_statementContext() +} + +type Raise_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaise_statementContext() *Raise_statementContext { + var p = new(Raise_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_raise_statement + return p +} + +func InitEmptyRaise_statementContext(p *Raise_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_raise_statement +} + +func (*Raise_statementContext) IsRaise_statementContext() {} + +func NewRaise_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_statementContext { + var p = new(Raise_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_raise_statement + + return p +} + +func (s *Raise_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raise_statementContext) RAISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAISE, 0) +} + +func (s *Raise_statementContext) Exception_name() IException_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Raise_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raise_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raise_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRaise_statement(s) + } +} + +func (s *Raise_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRaise_statement(s) + } +} + +func (p *PlSqlParser) Raise_statement() (localctx IRaise_statementContext) { + localctx = NewRaise_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1806, PlSqlParserRULE_raise_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16586) + p.Match(PlSqlParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(16587) + p.Exception_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturn_statementContext is an interface to support dynamic dispatch. +type IReturn_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + Expression() IExpressionContext + + // IsReturn_statementContext differentiates from other interfaces. + IsReturn_statementContext() +} + +type Return_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_statementContext() *Return_statementContext { + var p = new(Return_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_statement + return p +} + +func InitEmptyReturn_statementContext(p *Return_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_statement +} + +func (*Return_statementContext) IsReturn_statementContext() {} + +func NewReturn_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_statementContext { + var p = new(Return_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_return_statement + + return p +} + +func (s *Return_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_statementContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Return_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Return_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReturn_statement(s) + } +} + +func (s *Return_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReturn_statement(s) + } +} + +func (p *PlSqlParser) Return_statement() (localctx IReturn_statementContext) { + localctx = NewReturn_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1808, PlSqlParserRULE_return_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16590) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16592) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2254, p.GetParserRuleContext()) == 1 { + { + p.SetState(16591) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICall_statementContext is an interface to support dynamic dispatch. +type ICall_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRoutine_name() []IRoutine_nameContext + Routine_name(i int) IRoutine_nameContext + CALL() antlr.TerminalNode + AllFunction_argument() []IFunction_argumentContext + Function_argument(i int) IFunction_argumentContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + Bind_variable() IBind_variableContext + + // IsCall_statementContext differentiates from other interfaces. + IsCall_statementContext() +} + +type Call_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCall_statementContext() *Call_statementContext { + var p = new(Call_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_statement + return p +} + +func InitEmptyCall_statementContext(p *Call_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_statement +} + +func (*Call_statementContext) IsCall_statementContext() {} + +func NewCall_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Call_statementContext { + var p = new(Call_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_call_statement + + return p +} + +func (s *Call_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Call_statementContext) AllRoutine_name() []IRoutine_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoutine_nameContext); ok { + len++ + } + } + + tst := make([]IRoutine_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoutine_nameContext); ok { + tst[i] = t.(IRoutine_nameContext) + i++ + } + } + + return tst +} + +func (s *Call_statementContext) Routine_name(i int) IRoutine_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutine_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoutine_nameContext) +} + +func (s *Call_statementContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Call_statementContext) AllFunction_argument() []IFunction_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_argumentContext); ok { + len++ + } + } + + tst := make([]IFunction_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_argumentContext); ok { + tst[i] = t.(IFunction_argumentContext) + i++ + } + } + + return tst +} + +func (s *Call_statementContext) Function_argument(i int) IFunction_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *Call_statementContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Call_statementContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Call_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Call_statementContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Call_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Call_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Call_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCall_statement(s) + } +} + +func (s *Call_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCall_statement(s) + } +} + +func (p *PlSqlParser) Call_statement() (localctx ICall_statementContext) { + localctx = NewCall_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1810, PlSqlParserRULE_call_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16595) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2255, p.GetParserRuleContext()) == 1 { + { + p.SetState(16594) + p.Match(PlSqlParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16597) + p.Routine_name() + } + p.SetState(16599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16598) + p.Function_argument() + } + + } + p.SetState(16608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(16601) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16602) + p.Routine_name() + } + p.SetState(16604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16603) + p.Function_argument() + } + + } + + p.SetState(16610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(16613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(16611) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16612) + p.Bind_variable() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPipe_row_statementContext is an interface to support dynamic dispatch. +type IPipe_row_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIPE() antlr.TerminalNode + ROW() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsPipe_row_statementContext differentiates from other interfaces. + IsPipe_row_statementContext() +} + +type Pipe_row_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPipe_row_statementContext() *Pipe_row_statementContext { + var p = new(Pipe_row_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipe_row_statement + return p +} + +func InitEmptyPipe_row_statementContext(p *Pipe_row_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipe_row_statement +} + +func (*Pipe_row_statementContext) IsPipe_row_statementContext() {} + +func NewPipe_row_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pipe_row_statementContext { + var p = new(Pipe_row_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pipe_row_statement + + return p +} + +func (s *Pipe_row_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pipe_row_statementContext) PIPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPE, 0) +} + +func (s *Pipe_row_statementContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Pipe_row_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pipe_row_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pipe_row_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pipe_row_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pipe_row_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pipe_row_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPipe_row_statement(s) + } +} + +func (s *Pipe_row_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPipe_row_statement(s) + } +} + +func (p *PlSqlParser) Pipe_row_statement() (localctx IPipe_row_statementContext) { + localctx = NewPipe_row_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1812, PlSqlParserRULE_pipe_row_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16615) + p.Match(PlSqlParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16616) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16617) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16618) + p.Expression() + } + { + p.SetState(16619) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelection_directiveContext is an interface to support dynamic dispatch. +type ISelection_directiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOLLAR_IF() antlr.TerminalNode + Condition() IConditionContext + DOLLAR_THEN() antlr.TerminalNode + AllSelection_directive_body() []ISelection_directive_bodyContext + Selection_directive_body(i int) ISelection_directive_bodyContext + DOLLAR_END() antlr.TerminalNode + AllDOLLAR_ELSIF() []antlr.TerminalNode + DOLLAR_ELSIF(i int) antlr.TerminalNode + DOLLAR_ELSE() antlr.TerminalNode + + // IsSelection_directiveContext differentiates from other interfaces. + IsSelection_directiveContext() +} + +type Selection_directiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelection_directiveContext() *Selection_directiveContext { + var p = new(Selection_directiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selection_directive + return p +} + +func InitEmptySelection_directiveContext(p *Selection_directiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selection_directive +} + +func (*Selection_directiveContext) IsSelection_directiveContext() {} + +func NewSelection_directiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selection_directiveContext { + var p = new(Selection_directiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selection_directive + + return p +} + +func (s *Selection_directiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selection_directiveContext) DOLLAR_IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_IF, 0) +} + +func (s *Selection_directiveContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Selection_directiveContext) DOLLAR_THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_THEN, 0) +} + +func (s *Selection_directiveContext) AllSelection_directive_body() []ISelection_directive_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelection_directive_bodyContext); ok { + len++ + } + } + + tst := make([]ISelection_directive_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelection_directive_bodyContext); ok { + tst[i] = t.(ISelection_directive_bodyContext) + i++ + } + } + + return tst +} + +func (s *Selection_directiveContext) Selection_directive_body(i int) ISelection_directive_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelection_directive_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelection_directive_bodyContext) +} + +func (s *Selection_directiveContext) DOLLAR_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_END, 0) +} + +func (s *Selection_directiveContext) AllDOLLAR_ELSIF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDOLLAR_ELSIF) +} + +func (s *Selection_directiveContext) DOLLAR_ELSIF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_ELSIF, i) +} + +func (s *Selection_directiveContext) DOLLAR_ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_ELSE, 0) +} + +func (s *Selection_directiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selection_directiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selection_directiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelection_directive(s) + } +} + +func (s *Selection_directiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelection_directive(s) + } +} + +func (p *PlSqlParser) Selection_directive() (localctx ISelection_directiveContext) { + localctx = NewSelection_directiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1814, PlSqlParserRULE_selection_directive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16621) + p.Match(PlSqlParserDOLLAR_IF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16622) + p.Condition() + } + { + p.SetState(16623) + p.Match(PlSqlParserDOLLAR_THEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16624) + p.Selection_directive_body() + } + p.SetState(16629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserDOLLAR_ELSIF { + { + p.SetState(16625) + p.Match(PlSqlParserDOLLAR_ELSIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16626) + p.Selection_directive_body() + } + + p.SetState(16631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(16634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOLLAR_ELSE { + { + p.SetState(16632) + p.Match(PlSqlParserDOLLAR_ELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16633) + p.Selection_directive_body() + } + + } + { + p.SetState(16636) + p.Match(PlSqlParserDOLLAR_END) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IError_directiveContext is an interface to support dynamic dispatch. +type IError_directiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOLLAR_ERROR() antlr.TerminalNode + Concatenation() IConcatenationContext + DOLLAR_END() antlr.TerminalNode + + // IsError_directiveContext differentiates from other interfaces. + IsError_directiveContext() +} + +type Error_directiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_directiveContext() *Error_directiveContext { + var p = new(Error_directiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_directive + return p +} + +func InitEmptyError_directiveContext(p *Error_directiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_directive +} + +func (*Error_directiveContext) IsError_directiveContext() {} + +func NewError_directiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_directiveContext { + var p = new(Error_directiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_directive + + return p +} + +func (s *Error_directiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_directiveContext) DOLLAR_ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_ERROR, 0) +} + +func (s *Error_directiveContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Error_directiveContext) DOLLAR_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOLLAR_END, 0) +} + +func (s *Error_directiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_directiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_directiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_directive(s) + } +} + +func (s *Error_directiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_directive(s) + } +} + +func (p *PlSqlParser) Error_directive() (localctx IError_directiveContext) { + localctx = NewError_directiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1816, PlSqlParserRULE_error_directive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16638) + p.Match(PlSqlParserDOLLAR_ERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16639) + p.concatenation(0) + } + { + p.SetState(16640) + p.Match(PlSqlParserDOLLAR_END) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelection_directive_bodyContext is an interface to support dynamic dispatch. +type ISelection_directive_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStatement() []IStatementContext + Statement(i int) IStatementContext + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllVariable_declaration() []IVariable_declarationContext + Variable_declaration(i int) IVariable_declarationContext + AllError_directive() []IError_directiveContext + Error_directive(i int) IError_directiveContext + AllFunction_body() []IFunction_bodyContext + Function_body(i int) IFunction_bodyContext + AllProcedure_body() []IProcedure_bodyContext + Procedure_body(i int) IProcedure_bodyContext + AllPragma_declaration() []IPragma_declarationContext + Pragma_declaration(i int) IPragma_declarationContext + + // IsSelection_directive_bodyContext differentiates from other interfaces. + IsSelection_directive_bodyContext() +} + +type Selection_directive_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelection_directive_bodyContext() *Selection_directive_bodyContext { + var p = new(Selection_directive_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selection_directive_body + return p +} + +func InitEmptySelection_directive_bodyContext(p *Selection_directive_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selection_directive_body +} + +func (*Selection_directive_bodyContext) IsSelection_directive_bodyContext() {} + +func NewSelection_directive_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selection_directive_bodyContext { + var p = new(Selection_directive_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selection_directive_body + + return p +} + +func (s *Selection_directive_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selection_directive_bodyContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *Selection_directive_bodyContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Selection_directive_bodyContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Selection_directive_bodyContext) AllVariable_declaration() []IVariable_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariable_declarationContext); ok { + len++ + } + } + + tst := make([]IVariable_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariable_declarationContext); ok { + tst[i] = t.(IVariable_declarationContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Variable_declaration(i int) IVariable_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Selection_directive_bodyContext) AllError_directive() []IError_directiveContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IError_directiveContext); ok { + len++ + } + } + + tst := make([]IError_directiveContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IError_directiveContext); ok { + tst[i] = t.(IError_directiveContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Error_directive(i int) IError_directiveContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_directiveContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IError_directiveContext) +} + +func (s *Selection_directive_bodyContext) AllFunction_body() []IFunction_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_bodyContext); ok { + len++ + } + } + + tst := make([]IFunction_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_bodyContext); ok { + tst[i] = t.(IFunction_bodyContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Function_body(i int) IFunction_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *Selection_directive_bodyContext) AllProcedure_body() []IProcedure_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_bodyContext); ok { + len++ + } + } + + tst := make([]IProcedure_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_bodyContext); ok { + tst[i] = t.(IProcedure_bodyContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Procedure_body(i int) IProcedure_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *Selection_directive_bodyContext) AllPragma_declaration() []IPragma_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPragma_declarationContext); ok { + len++ + } + } + + tst := make([]IPragma_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPragma_declarationContext); ok { + tst[i] = t.(IPragma_declarationContext) + i++ + } + } + + return tst +} + +func (s *Selection_directive_bodyContext) Pragma_declaration(i int) IPragma_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Selection_directive_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selection_directive_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selection_directive_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelection_directive_body(s) + } +} + +func (s *Selection_directive_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelection_directive_body(s) + } +} + +func (p *PlSqlParser) Selection_directive_body() (localctx ISelection_directive_bodyContext) { + localctx = NewSelection_directive_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1818, PlSqlParserRULE_selection_directive_body) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(16652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2263, p.GetParserRuleContext()) { + case 1: + p.SetState(16643) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2262, p.GetParserRuleContext()) == 1 { + { + p.SetState(16642) + p.Pragma_declaration() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16645) + p.Statement() + } + { + p.SetState(16646) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(16648) + p.Variable_declaration() + } + + case 3: + { + p.SetState(16649) + p.Error_directive() + } + + case 4: + { + p.SetState(16650) + p.Function_body() + } + + case 5: + { + p.SetState(16651) + p.Procedure_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16654) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2264, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBodyContext is an interface to support dynamic dispatch. +type IBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + Label_name() ILabel_nameContext + AllException_handler() []IException_handlerContext + Exception_handler(i int) IException_handlerContext + + // IsBodyContext differentiates from other interfaces. + IsBodyContext() +} + +type BodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBodyContext() *BodyContext { + var p = new(BodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_body + return p +} + +func InitEmptyBodyContext(p *BodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_body +} + +func (*BodyContext) IsBodyContext() {} + +func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext { + var p = new(BodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_body + + return p +} + +func (s *BodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *BodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *BodyContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *BodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *BodyContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *BodyContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *BodyContext) AllException_handler() []IException_handlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_handlerContext); ok { + len++ + } + } + + tst := make([]IException_handlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_handlerContext); ok { + tst[i] = t.(IException_handlerContext) + i++ + } + } + + return tst +} + +func (s *BodyContext) Exception_handler(i int) IException_handlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_handlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_handlerContext) +} + +func (s *BodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBody(s) + } +} + +func (s *BodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBody(s) + } +} + +func (p *PlSqlParser) Body() (localctx IBodyContext) { + localctx = NewBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1820, PlSqlParserRULE_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16656) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16657) + p.Seq_of_statements() + } + p.SetState(16664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTION { + { + p.SetState(16658) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(16659) + p.Exception_handler() + } + + p.SetState(16662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(16666) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16668) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2267, p.GetParserRuleContext()) == 1 { + { + p.SetState(16667) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IException_handlerContext is an interface to support dynamic dispatch. +type IException_handlerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllException_name() []IException_nameContext + Exception_name(i int) IException_nameContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsException_handlerContext differentiates from other interfaces. + IsException_handlerContext() +} + +type Exception_handlerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_handlerContext() *Exception_handlerContext { + var p = new(Exception_handlerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_handler + return p +} + +func InitEmptyException_handlerContext(p *Exception_handlerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_handler +} + +func (*Exception_handlerContext) IsException_handlerContext() {} + +func NewException_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_handlerContext { + var p = new(Exception_handlerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_handler + + return p +} + +func (s *Exception_handlerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_handlerContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Exception_handlerContext) AllException_name() []IException_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_nameContext); ok { + len++ + } + } + + tst := make([]IException_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_nameContext); ok { + tst[i] = t.(IException_nameContext) + i++ + } + } + + return tst +} + +func (s *Exception_handlerContext) Exception_name(i int) IException_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Exception_handlerContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Exception_handlerContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Exception_handlerContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Exception_handlerContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Exception_handlerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_handlerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_handler(s) + } +} + +func (s *Exception_handlerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_handler(s) + } +} + +func (p *PlSqlParser) Exception_handler() (localctx IException_handlerContext) { + localctx = NewException_handlerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1822, PlSqlParserRULE_exception_handler) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16670) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16671) + p.Exception_name() + } + p.SetState(16676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(16672) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16673) + p.Exception_name() + } + + p.SetState(16678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16679) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16680) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_blockContext is an interface to support dynamic dispatch. +type ITrigger_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + DECLARE() antlr.TerminalNode + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsTrigger_blockContext differentiates from other interfaces. + IsTrigger_blockContext() +} + +type Trigger_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_blockContext() *Trigger_blockContext { + var p = new(Trigger_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_block + return p +} + +func InitEmptyTrigger_blockContext(p *Trigger_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_block +} + +func (*Trigger_blockContext) IsTrigger_blockContext() {} + +func NewTrigger_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_blockContext { + var p = new(Trigger_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_block + + return p +} + +func (s *Trigger_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_blockContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Trigger_blockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Trigger_blockContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *Trigger_blockContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *Trigger_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_block(s) + } +} + +func (s *Trigger_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_block(s) + } +} + +func (p *PlSqlParser) Trigger_block() (localctx ITrigger_blockContext) { + localctx = NewTrigger_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1824, PlSqlParserRULE_trigger_block) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(16682) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2269, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16683) + p.Declare_spec() + } + + } + p.SetState(16688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2269, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + { + p.SetState(16691) + p.Body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITps_blockContext is an interface to support dynamic dispatch. +type ITps_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsTps_blockContext differentiates from other interfaces. + IsTps_blockContext() +} + +type Tps_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTps_blockContext() *Tps_blockContext { + var p = new(Tps_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tps_block + return p +} + +func InitEmptyTps_blockContext(p *Tps_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tps_block +} + +func (*Tps_blockContext) IsTps_blockContext() {} + +func NewTps_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tps_blockContext { + var p = new(Tps_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tps_block + + return p +} + +func (s *Tps_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tps_blockContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Tps_blockContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *Tps_blockContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *Tps_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tps_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tps_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTps_block(s) + } +} + +func (s *Tps_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTps_block(s) + } +} + +func (p *PlSqlParser) Tps_block() (localctx ITps_blockContext) { + localctx = NewTps_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1826, PlSqlParserRULE_tps_block) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2271, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16693) + p.Declare_spec() + } + + } + p.SetState(16698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2271, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(16699) + p.Body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockContext is an interface to support dynamic dispatch. +type IBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + DECLARE() antlr.TerminalNode + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsBlockContext differentiates from other interfaces. + IsBlockContext() +} + +type BlockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockContext() *BlockContext { + var p = new(BlockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_block + return p +} + +func InitEmptyBlockContext(p *BlockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_block +} + +func (*BlockContext) IsBlockContext() {} + +func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext { + var p = new(BlockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_block + + return p +} + +func (s *BlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *BlockContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *BlockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *BlockContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *BlockContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *BlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlock(s) + } +} + +func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlock(s) + } +} + +func (p *PlSqlParser) Block() (localctx IBlockContext) { + localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1828, PlSqlParserRULE_block) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(16701) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2272, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16702) + p.Declare_spec() + } + + } + p.SetState(16707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2272, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + { + p.SetState(16710) + p.Body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_statementContext is an interface to support dynamic dispatch. +type ISql_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Execute_immediate() IExecute_immediateContext + Data_manipulation_language_statements() IData_manipulation_language_statementsContext + Cursor_manipulation_statements() ICursor_manipulation_statementsContext + Transaction_control_statements() ITransaction_control_statementsContext + Collection_method_call() ICollection_method_callContext + + // IsSql_statementContext differentiates from other interfaces. + IsSql_statementContext() +} + +type Sql_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_statementContext() *Sql_statementContext { + var p = new(Sql_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement + return p +} + +func InitEmptySql_statementContext(p *Sql_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement +} + +func (*Sql_statementContext) IsSql_statementContext() {} + +func NewSql_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_statementContext { + var p = new(Sql_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_statement + + return p +} + +func (s *Sql_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_statementContext) Execute_immediate() IExecute_immediateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_immediateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_immediateContext) +} + +func (s *Sql_statementContext) Data_manipulation_language_statements() IData_manipulation_language_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_manipulation_language_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_manipulation_language_statementsContext) +} + +func (s *Sql_statementContext) Cursor_manipulation_statements() ICursor_manipulation_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_manipulation_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_manipulation_statementsContext) +} + +func (s *Sql_statementContext) Transaction_control_statements() ITransaction_control_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_control_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_control_statementsContext) +} + +func (s *Sql_statementContext) Collection_method_call() ICollection_method_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_method_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_method_callContext) +} + +func (s *Sql_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_statement(s) + } +} + +func (s *Sql_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_statement(s) + } +} + +func (p *PlSqlParser) Sql_statement() (localctx ISql_statementContext) { + localctx = NewSql_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1830, PlSqlParserRULE_sql_statement) + p.SetState(16717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2274, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16712) + p.Execute_immediate() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16713) + p.Data_manipulation_language_statements() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16714) + p.Cursor_manipulation_statements() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16715) + p.Transaction_control_statements() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16716) + p.Collection_method_call() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_immediateContext is an interface to support dynamic dispatch. +type IExecute_immediateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + Expression() IExpressionContext + Into_clause() IInto_clauseContext + Using_clause() IUsing_clauseContext + Dynamic_returning_clause() IDynamic_returning_clauseContext + + // IsExecute_immediateContext differentiates from other interfaces. + IsExecute_immediateContext() +} + +type Execute_immediateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_immediateContext() *Execute_immediateContext { + var p = new(Execute_immediateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_execute_immediate + return p +} + +func InitEmptyExecute_immediateContext(p *Execute_immediateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_execute_immediate +} + +func (*Execute_immediateContext) IsExecute_immediateContext() {} + +func NewExecute_immediateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_immediateContext { + var p = new(Execute_immediateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_execute_immediate + + return p +} + +func (s *Execute_immediateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_immediateContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Execute_immediateContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Execute_immediateContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Execute_immediateContext) Into_clause() IInto_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Execute_immediateContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Execute_immediateContext) Dynamic_returning_clause() IDynamic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDynamic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDynamic_returning_clauseContext) +} + +func (s *Execute_immediateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_immediateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_immediateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExecute_immediate(s) + } +} + +func (p *PlSqlParser) Execute_immediate() (localctx IExecute_immediateContext) { + localctx = NewExecute_immediateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1832, PlSqlParserRULE_execute_immediate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16719) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16720) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16721) + p.Expression() + } + p.SetState(16731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserBULK, PlSqlParserINTO: + { + p.SetState(16722) + p.Into_clause() + } + p.SetState(16724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(16723) + p.Using_clause() + } + + } + + case PlSqlParserUSING: + { + p.SetState(16726) + p.Using_clause() + } + p.SetState(16728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING || _la == PlSqlParserRETURN { + { + p.SetState(16727) + p.Dynamic_returning_clause() + } + + } + + case PlSqlParserRETURNING, PlSqlParserRETURN: + { + p.SetState(16730) + p.Dynamic_returning_clause() + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDynamic_returning_clauseContext is an interface to support dynamic dispatch. +type IDynamic_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Into_clause() IInto_clauseContext + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + + // IsDynamic_returning_clauseContext differentiates from other interfaces. + IsDynamic_returning_clauseContext() +} + +type Dynamic_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDynamic_returning_clauseContext() *Dynamic_returning_clauseContext { + var p = new(Dynamic_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause + return p +} + +func InitEmptyDynamic_returning_clauseContext(p *Dynamic_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause +} + +func (*Dynamic_returning_clauseContext) IsDynamic_returning_clauseContext() {} + +func NewDynamic_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dynamic_returning_clauseContext { + var p = new(Dynamic_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause + + return p +} + +func (s *Dynamic_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dynamic_returning_clauseContext) Into_clause() IInto_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Dynamic_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Dynamic_returning_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Dynamic_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dynamic_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dynamic_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDynamic_returning_clause(s) + } +} + +func (s *Dynamic_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDynamic_returning_clause(s) + } +} + +func (p *PlSqlParser) Dynamic_returning_clause() (localctx IDynamic_returning_clauseContext) { + localctx = NewDynamic_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1834, PlSqlParserRULE_dynamic_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16733) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRETURNING || _la == PlSqlParserRETURN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16734) + p.Into_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IData_manipulation_language_statementsContext is an interface to support dynamic dispatch. +type IData_manipulation_language_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Merge_statement() IMerge_statementContext + Lock_table_statement() ILock_table_statementContext + Select_statement() ISelect_statementContext + Update_statement() IUpdate_statementContext + Delete_statement() IDelete_statementContext + Insert_statement() IInsert_statementContext + Explain_statement() IExplain_statementContext + + // IsData_manipulation_language_statementsContext differentiates from other interfaces. + IsData_manipulation_language_statementsContext() +} + +type Data_manipulation_language_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyData_manipulation_language_statementsContext() *Data_manipulation_language_statementsContext { + var p = new(Data_manipulation_language_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements + return p +} + +func InitEmptyData_manipulation_language_statementsContext(p *Data_manipulation_language_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements +} + +func (*Data_manipulation_language_statementsContext) IsData_manipulation_language_statementsContext() { +} + +func NewData_manipulation_language_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_manipulation_language_statementsContext { + var p = new(Data_manipulation_language_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements + + return p +} + +func (s *Data_manipulation_language_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Data_manipulation_language_statementsContext) Merge_statement() IMerge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Lock_table_statement() ILock_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_table_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Update_statement() IUpdate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Delete_statement() IDelete_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Insert_statement() IInsert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) Explain_statement() IExplain_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Data_manipulation_language_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Data_manipulation_language_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterData_manipulation_language_statements(s) + } +} + +func (s *Data_manipulation_language_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitData_manipulation_language_statements(s) + } +} + +func (p *PlSqlParser) Data_manipulation_language_statements() (localctx IData_manipulation_language_statementsContext) { + localctx = NewData_manipulation_language_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1836, PlSqlParserRULE_data_manipulation_language_statements) + p.SetState(16743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMERGE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16736) + p.Merge_statement() + } + + case PlSqlParserLOCK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16737) + p.Lock_table_statement() + } + + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16738) + p.Select_statement() + } + + case PlSqlParserUPDATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16739) + p.Update_statement() + } + + case PlSqlParserDELETE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16740) + p.Delete_statement() + } + + case PlSqlParserINSERT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(16741) + p.Insert_statement() + } + + case PlSqlParserEXPLAIN: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(16742) + p.Explain_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_manipulation_statementsContext is an interface to support dynamic dispatch. +type ICursor_manipulation_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Close_statement() IClose_statementContext + Open_statement() IOpen_statementContext + Fetch_statement() IFetch_statementContext + Open_for_statement() IOpen_for_statementContext + + // IsCursor_manipulation_statementsContext differentiates from other interfaces. + IsCursor_manipulation_statementsContext() +} + +type Cursor_manipulation_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_manipulation_statementsContext() *Cursor_manipulation_statementsContext { + var p = new(Cursor_manipulation_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements + return p +} + +func InitEmptyCursor_manipulation_statementsContext(p *Cursor_manipulation_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements +} + +func (*Cursor_manipulation_statementsContext) IsCursor_manipulation_statementsContext() {} + +func NewCursor_manipulation_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_manipulation_statementsContext { + var p = new(Cursor_manipulation_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements + + return p +} + +func (s *Cursor_manipulation_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_manipulation_statementsContext) Close_statement() IClose_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClose_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClose_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Open_statement() IOpen_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Fetch_statement() IFetch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Open_for_statement() IOpen_for_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_for_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_for_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_manipulation_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_manipulation_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_manipulation_statements(s) + } +} + +func (s *Cursor_manipulation_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_manipulation_statements(s) + } +} + +func (p *PlSqlParser) Cursor_manipulation_statements() (localctx ICursor_manipulation_statementsContext) { + localctx = NewCursor_manipulation_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1838, PlSqlParserRULE_cursor_manipulation_statements) + p.SetState(16749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2279, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16745) + p.Close_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16746) + p.Open_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16747) + p.Fetch_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16748) + p.Open_for_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClose_statementContext is an interface to support dynamic dispatch. +type IClose_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLOSE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + + // IsClose_statementContext differentiates from other interfaces. + IsClose_statementContext() +} + +type Close_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClose_statementContext() *Close_statementContext { + var p = new(Close_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_statement + return p +} + +func InitEmptyClose_statementContext(p *Close_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_statement +} + +func (*Close_statementContext) IsClose_statementContext() {} + +func NewClose_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_statementContext { + var p = new(Close_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_close_statement + + return p +} + +func (s *Close_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Close_statementContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Close_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Close_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Close_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Close_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClose_statement(s) + } +} + +func (s *Close_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClose_statement(s) + } +} + +func (p *PlSqlParser) Close_statement() (localctx IClose_statementContext) { + localctx = NewClose_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1840, PlSqlParserRULE_close_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16751) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16752) + p.Cursor_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_statementContext is an interface to support dynamic dispatch. +type IOpen_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN() antlr.TerminalNode + Cursor_name() ICursor_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + + // IsOpen_statementContext differentiates from other interfaces. + IsOpen_statementContext() +} + +type Open_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_statementContext() *Open_statementContext { + var p = new(Open_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_statement + return p +} + +func InitEmptyOpen_statementContext(p *Open_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_statement +} + +func (*Open_statementContext) IsOpen_statementContext() {} + +func NewOpen_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_statementContext { + var p = new(Open_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_statement + + return p +} + +func (s *Open_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_statementContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Open_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Open_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Open_statementContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Open_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_statement(s) + } +} + +func (s *Open_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_statement(s) + } +} + +func (p *PlSqlParser) Open_statement() (localctx IOpen_statementContext) { + localctx = NewOpen_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1842, PlSqlParserRULE_open_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16754) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16755) + p.Cursor_name() + } + p.SetState(16761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16756) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16758) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2280, p.GetParserRuleContext()) == 1 { + { + p.SetState(16757) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16760) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetch_statementContext is an interface to support dynamic dispatch. +type IFetch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIt1 returns the it1 token. + GetIt1() antlr.Token + + // SetIt1 sets the it1 token. + SetIt1(antlr.Token) + + // Getter signatures + FETCH() antlr.TerminalNode + Cursor_name() ICursor_nameContext + AllVariable_or_collection() []IVariable_or_collectionContext + Variable_or_collection(i int) IVariable_or_collectionContext + BULK() antlr.TerminalNode + COLLECT() antlr.TerminalNode + INTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + LIMIT() antlr.TerminalNode + Numeric() INumericContext + + // IsFetch_statementContext differentiates from other interfaces. + IsFetch_statementContext() +} + +type Fetch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + it1 antlr.Token +} + +func NewEmptyFetch_statementContext() *Fetch_statementContext { + var p = new(Fetch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_statement + return p +} + +func InitEmptyFetch_statementContext(p *Fetch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_statement +} + +func (*Fetch_statementContext) IsFetch_statementContext() {} + +func NewFetch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_statementContext { + var p = new(Fetch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fetch_statement + + return p +} + +func (s *Fetch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_statementContext) GetIt1() antlr.Token { return s.it1 } + +func (s *Fetch_statementContext) SetIt1(v antlr.Token) { s.it1 = v } + +func (s *Fetch_statementContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Fetch_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Fetch_statementContext) AllVariable_or_collection() []IVariable_or_collectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariable_or_collectionContext); ok { + len++ + } + } + + tst := make([]IVariable_or_collectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariable_or_collectionContext); ok { + tst[i] = t.(IVariable_or_collectionContext) + i++ + } + } + + return tst +} + +func (s *Fetch_statementContext) Variable_or_collection(i int) IVariable_or_collectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_or_collectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariable_or_collectionContext) +} + +func (s *Fetch_statementContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Fetch_statementContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Fetch_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Fetch_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Fetch_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Fetch_statementContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Fetch_statementContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Fetch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFetch_statement(s) + } +} + +func (s *Fetch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFetch_statement(s) + } +} + +func (p *PlSqlParser) Fetch_statement() (localctx IFetch_statementContext) { + localctx = NewFetch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1844, PlSqlParserRULE_fetch_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16763) + p.Match(PlSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16764) + p.Cursor_name() + } + p.SetState(16792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTO: + { + p.SetState(16765) + + var _m = p.Match(PlSqlParserINTO) + + localctx.(*Fetch_statementContext).it1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16766) + p.Variable_or_collection() + } + p.SetState(16771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16767) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16768) + p.Variable_or_collection() + } + + p.SetState(16773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserBULK: + { + p.SetState(16774) + p.Match(PlSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16775) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16776) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16777) + p.Variable_or_collection() + } + p.SetState(16782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16778) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16779) + p.Variable_or_collection() + } + + p.SetState(16784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(16790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLIMIT { + { + p.SetState(16785) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(16786) + p.Numeric() + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16787) + p.Variable_or_collection() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_or_collectionContext is an interface to support dynamic dispatch. +type IVariable_or_collectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Variable_name() IVariable_nameContext + Collection_expression() ICollection_expressionContext + + // IsVariable_or_collectionContext differentiates from other interfaces. + IsVariable_or_collectionContext() +} + +type Variable_or_collectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_or_collectionContext() *Variable_or_collectionContext { + var p = new(Variable_or_collectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_or_collection + return p +} + +func InitEmptyVariable_or_collectionContext(p *Variable_or_collectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_or_collection +} + +func (*Variable_or_collectionContext) IsVariable_or_collectionContext() {} + +func NewVariable_or_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_or_collectionContext { + var p = new(Variable_or_collectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_variable_or_collection + + return p +} + +func (s *Variable_or_collectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_or_collectionContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Variable_or_collectionContext) Collection_expression() ICollection_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_expressionContext) +} + +func (s *Variable_or_collectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_or_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_or_collectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVariable_or_collection(s) + } +} + +func (s *Variable_or_collectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVariable_or_collection(s) + } +} + +func (p *PlSqlParser) Variable_or_collection() (localctx IVariable_or_collectionContext) { + localctx = NewVariable_or_collectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1846, PlSqlParserRULE_variable_or_collection) + p.SetState(16796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2287, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16794) + p.Variable_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16795) + p.Collection_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_for_statementContext is an interface to support dynamic dispatch. +type IOpen_for_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN() antlr.TerminalNode + Variable_name() IVariable_nameContext + FOR() antlr.TerminalNode + Select_statement() ISelect_statementContext + Expression() IExpressionContext + Using_clause() IUsing_clauseContext + + // IsOpen_for_statementContext differentiates from other interfaces. + IsOpen_for_statementContext() +} + +type Open_for_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_for_statementContext() *Open_for_statementContext { + var p = new(Open_for_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_for_statement + return p +} + +func InitEmptyOpen_for_statementContext(p *Open_for_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_for_statement +} + +func (*Open_for_statementContext) IsOpen_for_statementContext() {} + +func NewOpen_for_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_for_statementContext { + var p = new(Open_for_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_for_statement + + return p +} + +func (s *Open_for_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_for_statementContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_for_statementContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Open_for_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Open_for_statementContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Open_for_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Open_for_statementContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Open_for_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_for_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_for_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_for_statement(s) + } +} + +func (s *Open_for_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_for_statement(s) + } +} + +func (p *PlSqlParser) Open_for_statement() (localctx IOpen_for_statementContext) { + localctx = NewOpen_for_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1848, PlSqlParserRULE_open_for_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16798) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16799) + p.Variable_name() + } + { + p.SetState(16800) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2288, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16801) + p.Select_statement() + } + + case 2: + { + p.SetState(16802) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(16806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(16805) + p.Using_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_control_statementsContext is an interface to support dynamic dispatch. +type ITransaction_control_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_transaction_command() ISet_transaction_commandContext + Set_constraint_command() ISet_constraint_commandContext + Commit_statement() ICommit_statementContext + Rollback_statement() IRollback_statementContext + Savepoint_statement() ISavepoint_statementContext + + // IsTransaction_control_statementsContext differentiates from other interfaces. + IsTransaction_control_statementsContext() +} + +type Transaction_control_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_control_statementsContext() *Transaction_control_statementsContext { + var p = new(Transaction_control_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transaction_control_statements + return p +} + +func InitEmptyTransaction_control_statementsContext(p *Transaction_control_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transaction_control_statements +} + +func (*Transaction_control_statementsContext) IsTransaction_control_statementsContext() {} + +func NewTransaction_control_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_control_statementsContext { + var p = new(Transaction_control_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_transaction_control_statements + + return p +} + +func (s *Transaction_control_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_control_statementsContext) Set_transaction_command() ISet_transaction_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_transaction_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_transaction_commandContext) +} + +func (s *Transaction_control_statementsContext) Set_constraint_command() ISet_constraint_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_constraint_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_constraint_commandContext) +} + +func (s *Transaction_control_statementsContext) Commit_statement() ICommit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommit_statementContext) +} + +func (s *Transaction_control_statementsContext) Rollback_statement() IRollback_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_statementContext) +} + +func (s *Transaction_control_statementsContext) Savepoint_statement() ISavepoint_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_statementContext) +} + +func (s *Transaction_control_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_control_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_control_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTransaction_control_statements(s) + } +} + +func (s *Transaction_control_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTransaction_control_statements(s) + } +} + +func (p *PlSqlParser) Transaction_control_statements() (localctx ITransaction_control_statementsContext) { + localctx = NewTransaction_control_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1850, PlSqlParserRULE_transaction_control_statements) + p.SetState(16813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2290, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16808) + p.Set_transaction_command() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16809) + p.Set_constraint_command() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16810) + p.Commit_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16811) + p.Rollback_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16812) + p.Savepoint_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_transaction_commandContext is an interface to support dynamic dispatch. +type ISet_transaction_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + READ() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + USE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + NAME() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + + // IsSet_transaction_commandContext differentiates from other interfaces. + IsSet_transaction_commandContext() +} + +type Set_transaction_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_transaction_commandContext() *Set_transaction_commandContext { + var p = new(Set_transaction_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_transaction_command + return p +} + +func InitEmptySet_transaction_commandContext(p *Set_transaction_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_transaction_command +} + +func (*Set_transaction_commandContext) IsSet_transaction_commandContext() {} + +func NewSet_transaction_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_transaction_commandContext { + var p = new(Set_transaction_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_transaction_command + + return p +} + +func (s *Set_transaction_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_transaction_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_transaction_commandContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Set_transaction_commandContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Set_transaction_commandContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION, 0) +} + +func (s *Set_transaction_commandContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Set_transaction_commandContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Set_transaction_commandContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Set_transaction_commandContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Set_transaction_commandContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Set_transaction_commandContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Set_transaction_commandContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Set_transaction_commandContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Set_transaction_commandContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Set_transaction_commandContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALIZABLE, 0) +} + +func (s *Set_transaction_commandContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMITTED, 0) +} + +func (s *Set_transaction_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_transaction_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_transaction_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_transaction_command(s) + } +} + +func (s *Set_transaction_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_transaction_command(s) + } +} + +func (p *PlSqlParser) Set_transaction_command() (localctx ISet_transaction_commandContext) { + localctx = NewSet_transaction_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1852, PlSqlParserRULE_set_transaction_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16815) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16816) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserREAD: + { + p.SetState(16817) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16818) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserISOLATION: + { + p.SetState(16819) + p.Match(PlSqlParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16820) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSERIALIZABLE: + { + p.SetState(16821) + p.Match(PlSqlParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(16822) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16823) + p.Match(PlSqlParserCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserUSE: + { + p.SetState(16826) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16827) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16828) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16829) + p.Rollback_segment_name() + } + + case PlSqlParserEOF, PlSqlParserNAME, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + p.SetState(16834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNAME { + { + p.SetState(16832) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16833) + p.Quoted_string() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_constraint_commandContext is an interface to support dynamic dispatch. +type ISet_constraint_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + ALL() antlr.TerminalNode + AllConstraint_name() []IConstraint_nameContext + Constraint_name(i int) IConstraint_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSet_constraint_commandContext differentiates from other interfaces. + IsSet_constraint_commandContext() +} + +type Set_constraint_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_constraint_commandContext() *Set_constraint_commandContext { + var p = new(Set_constraint_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_constraint_command + return p +} + +func InitEmptySet_constraint_commandContext(p *Set_constraint_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_constraint_command +} + +func (*Set_constraint_commandContext) IsSet_constraint_commandContext() {} + +func NewSet_constraint_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_constraint_commandContext { + var p = new(Set_constraint_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_constraint_command + + return p +} + +func (s *Set_constraint_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_constraint_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_constraint_commandContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Set_constraint_commandContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Set_constraint_commandContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Set_constraint_commandContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Set_constraint_commandContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Set_constraint_commandContext) AllConstraint_name() []IConstraint_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraint_nameContext); ok { + len++ + } + } + + tst := make([]IConstraint_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraint_nameContext); ok { + tst[i] = t.(IConstraint_nameContext) + i++ + } + } + + return tst +} + +func (s *Set_constraint_commandContext) Constraint_name(i int) IConstraint_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Set_constraint_commandContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Set_constraint_commandContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Set_constraint_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_constraint_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_constraint_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_constraint_command(s) + } +} + +func (s *Set_constraint_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_constraint_command(s) + } +} + +func (p *PlSqlParser) Set_constraint_command() (localctx ISet_constraint_commandContext) { + localctx = NewSet_constraint_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1854, PlSqlParserRULE_set_constraint_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16836) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16837) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(16838) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16839) + p.Constraint_name() + } + p.SetState(16844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16840) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16841) + p.Constraint_name() + } + + p.SetState(16846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16849) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommit_statementContext is an interface to support dynamic dispatch. +type ICommit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMIT() antlr.TerminalNode + WORK() antlr.TerminalNode + AllWrite_clause() []IWrite_clauseContext + Write_clause(i int) IWrite_clauseContext + COMMENT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + FORCE() antlr.TerminalNode + CORRUPT_XID() antlr.TerminalNode + CORRUPT_XID_ALL() antlr.TerminalNode + COMMA() antlr.TerminalNode + Numeric() INumericContext + + // IsCommit_statementContext differentiates from other interfaces. + IsCommit_statementContext() +} + +type Commit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommit_statementContext() *Commit_statementContext { + var p = new(Commit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_statement + return p +} + +func InitEmptyCommit_statementContext(p *Commit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_statement +} + +func (*Commit_statementContext) IsCommit_statementContext() {} + +func NewCommit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_statementContext { + var p = new(Commit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_commit_statement + + return p +} + +func (s *Commit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Commit_statementContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Commit_statementContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Commit_statementContext) AllWrite_clause() []IWrite_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWrite_clauseContext); ok { + len++ + } + } + + tst := make([]IWrite_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWrite_clauseContext); ok { + tst[i] = t.(IWrite_clauseContext) + i++ + } + } + + return tst +} + +func (s *Commit_statementContext) Write_clause(i int) IWrite_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWrite_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWrite_clauseContext) +} + +func (s *Commit_statementContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Commit_statementContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Commit_statementContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Commit_statementContext) CORRUPT_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID, 0) +} + +func (s *Commit_statementContext) CORRUPT_XID_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID_ALL, 0) +} + +func (s *Commit_statementContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Commit_statementContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Commit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Commit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Commit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCommit_statement(s) + } +} + +func (s *Commit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCommit_statement(s) + } +} + +func (p *PlSqlParser) Commit_statement() (localctx ICommit_statementContext) { + localctx = NewCommit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1856, PlSqlParserRULE_commit_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16851) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWORK { + { + p.SetState(16852) + p.Match(PlSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWRITE { + { + p.SetState(16855) + p.Write_clause() + } + + } + p.SetState(16874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMMENT: + { + p.SetState(16858) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16859) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWRITE { + { + p.SetState(16860) + p.Write_clause() + } + + } + + case PlSqlParserFORCE: + { + p.SetState(16863) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(16864) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(16865) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16866) + p.Numeric() + } + + } + + case PlSqlParserCORRUPT_XID: + { + p.SetState(16869) + p.Match(PlSqlParserCORRUPT_XID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16870) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCORRUPT_XID_ALL: + { + p.SetState(16871) + p.Match(PlSqlParserCORRUPT_XID_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWrite_clauseContext is an interface to support dynamic dispatch. +type IWrite_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WRITE() antlr.TerminalNode + AllIMMEDIATE() []antlr.TerminalNode + IMMEDIATE(i int) antlr.TerminalNode + AllBATCH() []antlr.TerminalNode + BATCH(i int) antlr.TerminalNode + AllWAIT() []antlr.TerminalNode + WAIT(i int) antlr.TerminalNode + AllNOWAIT() []antlr.TerminalNode + NOWAIT(i int) antlr.TerminalNode + + // IsWrite_clauseContext differentiates from other interfaces. + IsWrite_clauseContext() +} + +type Write_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWrite_clauseContext() *Write_clauseContext { + var p = new(Write_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_write_clause + return p +} + +func InitEmptyWrite_clauseContext(p *Write_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_write_clause +} + +func (*Write_clauseContext) IsWrite_clauseContext() {} + +func NewWrite_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Write_clauseContext { + var p = new(Write_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_write_clause + + return p +} + +func (s *Write_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Write_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Write_clauseContext) AllIMMEDIATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIMMEDIATE) +} + +func (s *Write_clauseContext) IMMEDIATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, i) +} + +func (s *Write_clauseContext) AllBATCH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBATCH) +} + +func (s *Write_clauseContext) BATCH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, i) +} + +func (s *Write_clauseContext) AllWAIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWAIT) +} + +func (s *Write_clauseContext) WAIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, i) +} + +func (s *Write_clauseContext) AllNOWAIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOWAIT) +} + +func (s *Write_clauseContext) NOWAIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, i) +} + +func (s *Write_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Write_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Write_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWrite_clause(s) + } +} + +func (s *Write_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWrite_clause(s) + } +} + +func (p *PlSqlParser) Write_clause() (localctx IWrite_clauseContext) { + localctx = NewWrite_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1858, PlSqlParserRULE_write_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16876) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserBATCH || _la == PlSqlParserIMMEDIATE || _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + p.SetState(16879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBATCH, PlSqlParserIMMEDIATE: + { + p.SetState(16877) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBATCH || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNOWAIT, PlSqlParserWAIT: + { + p.SetState(16878) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollback_statementContext is an interface to support dynamic dispatch. +type IRollback_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK() antlr.TerminalNode + WORK() antlr.TerminalNode + TO() antlr.TerminalNode + Savepoint_name() ISavepoint_nameContext + FORCE() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + SAVEPOINT() antlr.TerminalNode + + // IsRollback_statementContext differentiates from other interfaces. + IsRollback_statementContext() +} + +type Rollback_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_statementContext() *Rollback_statementContext { + var p = new(Rollback_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_statement + return p +} + +func InitEmptyRollback_statementContext(p *Rollback_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_statement +} + +func (*Rollback_statementContext) IsRollback_statementContext() {} + +func NewRollback_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_statementContext { + var p = new(Rollback_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_statement + + return p +} + +func (s *Rollback_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_statementContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Rollback_statementContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Rollback_statementContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rollback_statementContext) Savepoint_name() ISavepoint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_nameContext) +} + +func (s *Rollback_statementContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Rollback_statementContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Rollback_statementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Rollback_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_statement(s) + } +} + +func (s *Rollback_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_statement(s) + } +} + +func (p *PlSqlParser) Rollback_statement() (localctx IRollback_statementContext) { + localctx = NewRollback_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1860, PlSqlParserRULE_rollback_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16884) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWORK { + { + p.SetState(16885) + p.Match(PlSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserTO: + { + p.SetState(16888) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16890) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2305, p.GetParserRuleContext()) == 1 { + { + p.SetState(16889) + p.Match(PlSqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16892) + p.Savepoint_name() + } + + case PlSqlParserFORCE: + { + p.SetState(16893) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16894) + p.Quoted_string() + } + + case PlSqlParserEOF, PlSqlParserSOLIDUS, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISavepoint_statementContext is an interface to support dynamic dispatch. +type ISavepoint_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SAVEPOINT() antlr.TerminalNode + Savepoint_name() ISavepoint_nameContext + + // IsSavepoint_statementContext differentiates from other interfaces. + IsSavepoint_statementContext() +} + +type Savepoint_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySavepoint_statementContext() *Savepoint_statementContext { + var p = new(Savepoint_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_statement + return p +} + +func InitEmptySavepoint_statementContext(p *Savepoint_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_statement +} + +func (*Savepoint_statementContext) IsSavepoint_statementContext() {} + +func NewSavepoint_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_statementContext { + var p = new(Savepoint_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_savepoint_statement + + return p +} + +func (s *Savepoint_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Savepoint_statementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Savepoint_statementContext) Savepoint_name() ISavepoint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_nameContext) +} + +func (s *Savepoint_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Savepoint_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Savepoint_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSavepoint_statement(s) + } +} + +func (s *Savepoint_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSavepoint_statement(s) + } +} + +func (p *PlSqlParser) Savepoint_statement() (localctx ISavepoint_statementContext) { + localctx = NewSavepoint_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1862, PlSqlParserRULE_savepoint_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16897) + p.Match(PlSqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16898) + p.Savepoint_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollection_method_callContext is an interface to support dynamic dispatch. +type ICollection_method_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_expression returns the _expression rule contexts. + Get_expression() IExpressionContext + + // Set_expression sets the _expression rule contexts. + Set_expression(IExpressionContext) + + // GetIndex returns the index rule context list. + GetIndex() []IExpressionContext + + // SetIndex sets the index rule context list. + SetIndex([]IExpressionContext) + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + PERIOD() antlr.TerminalNode + TRIM() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXTEND() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCollection_method_callContext differentiates from other interfaces. + IsCollection_method_callContext() +} + +type Collection_method_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _expression IExpressionContext + index []IExpressionContext +} + +func NewEmptyCollection_method_callContext() *Collection_method_callContext { + var p = new(Collection_method_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_method_call + return p +} + +func InitEmptyCollection_method_callContext(p *Collection_method_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_method_call +} + +func (*Collection_method_callContext) IsCollection_method_callContext() {} + +func NewCollection_method_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collection_method_callContext { + var p = new(Collection_method_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collection_method_call + + return p +} + +func (s *Collection_method_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collection_method_callContext) Get_expression() IExpressionContext { return s._expression } + +func (s *Collection_method_callContext) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *Collection_method_callContext) GetIndex() []IExpressionContext { return s.index } + +func (s *Collection_method_callContext) SetIndex(v []IExpressionContext) { s.index = v } + +func (s *Collection_method_callContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Collection_method_callContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Collection_method_callContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Collection_method_callContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *Collection_method_callContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Collection_method_callContext) EXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTEND, 0) +} + +func (s *Collection_method_callContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Collection_method_callContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Collection_method_callContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Collection_method_callContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Collection_method_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collection_method_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collection_method_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollection_method_call(s) + } +} + +func (s *Collection_method_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollection_method_call(s) + } +} + +func (p *PlSqlParser) Collection_method_call() (localctx ICollection_method_callContext) { + localctx = NewCollection_method_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1864, PlSqlParserRULE_collection_method_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16900) + p.Expression() + } + { + p.SetState(16901) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDELETE, PlSqlParserEXTEND: + { + p.SetState(16902) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserEXTEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16903) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16904) + + var _x = p.Expression() + + localctx.(*Collection_method_callContext)._expression = _x + } + localctx.(*Collection_method_callContext).index = append(localctx.(*Collection_method_callContext).index, localctx.(*Collection_method_callContext)._expression) + p.SetState(16909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16905) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16906) + + var _x = p.Expression() + + localctx.(*Collection_method_callContext)._expression = _x + } + localctx.(*Collection_method_callContext).index = append(localctx.(*Collection_method_callContext).index, localctx.(*Collection_method_callContext)._expression) + + p.SetState(16911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16912) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserTRIM: + { + p.SetState(16916) + p.Match(PlSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16917) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16918) + + var _x = p.Expression() + + localctx.(*Collection_method_callContext)._expression = _x + } + localctx.(*Collection_method_callContext).index = append(localctx.(*Collection_method_callContext).index, localctx.(*Collection_method_callContext)._expression) + { + p.SetState(16919) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_statementContext is an interface to support dynamic dispatch. +type IExplain_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN() antlr.TerminalNode + PLAN() antlr.TerminalNode + FOR() antlr.TerminalNode + Select_statement() ISelect_statementContext + Update_statement() IUpdate_statementContext + Delete_statement() IDelete_statementContext + Insert_statement() IInsert_statementContext + Merge_statement() IMerge_statementContext + SET() antlr.TerminalNode + STATEMENT_ID() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsExplain_statementContext differentiates from other interfaces. + IsExplain_statementContext() +} + +type Explain_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_statementContext() *Explain_statementContext { + var p = new(Explain_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_explain_statement + return p +} + +func InitEmptyExplain_statementContext(p *Explain_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_explain_statement +} + +func (*Explain_statementContext) IsExplain_statementContext() {} + +func NewExplain_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_statementContext { + var p = new(Explain_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_explain_statement + + return p +} + +func (s *Explain_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_statementContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLAIN, 0) +} + +func (s *Explain_statementContext) PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLAN, 0) +} + +func (s *Explain_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Explain_statementContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Explain_statementContext) Update_statement() IUpdate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statementContext) +} + +func (s *Explain_statementContext) Delete_statement() IDelete_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statementContext) +} + +func (s *Explain_statementContext) Insert_statement() IInsert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statementContext) +} + +func (s *Explain_statementContext) Merge_statement() IMerge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_statementContext) +} + +func (s *Explain_statementContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Explain_statementContext) STATEMENT_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_ID, 0) +} + +func (s *Explain_statementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Explain_statementContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Explain_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Explain_statementContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Explain_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExplain_statement(s) + } +} + +func (s *Explain_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExplain_statement(s) + } +} + +func (p *PlSqlParser) Explain_statement() (localctx IExplain_statementContext) { + localctx = NewExplain_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1866, PlSqlParserRULE_explain_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16925) + p.Match(PlSqlParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16926) + p.Match(PlSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(16927) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16928) + p.Match(PlSqlParserSTATEMENT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16929) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16930) + p.Quoted_string() + } + + } + p.SetState(16935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(16933) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16934) + p.Tableview_name() + } + + } + { + p.SetState(16937) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(16938) + p.Select_statement() + } + + case PlSqlParserUPDATE: + { + p.SetState(16939) + p.Update_statement() + } + + case PlSqlParserDELETE: + { + p.SetState(16940) + p.Delete_statement() + } + + case PlSqlParserINSERT: + { + p.SetState(16941) + p.Insert_statement() + } + + case PlSqlParserMERGE: + { + p.SetState(16942) + p.Merge_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_only_statementContext is an interface to support dynamic dispatch. +type ISelect_only_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery() ISubqueryContext + With_clause() IWith_clauseContext + + // IsSelect_only_statementContext differentiates from other interfaces. + IsSelect_only_statementContext() +} + +type Select_only_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_only_statementContext() *Select_only_statementContext { + var p = new(Select_only_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_only_statement + return p +} + +func InitEmptySelect_only_statementContext(p *Select_only_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_only_statement +} + +func (*Select_only_statementContext) IsSelect_only_statementContext() {} + +func NewSelect_only_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_only_statementContext { + var p = new(Select_only_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_select_only_statement + + return p +} + +func (s *Select_only_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_only_statementContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Select_only_statementContext) With_clause() IWith_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clauseContext) +} + +func (s *Select_only_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_only_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_only_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelect_only_statement(s) + } +} + +func (s *Select_only_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_only_statement(s) + } +} + +func (p *PlSqlParser) Select_only_statement() (localctx ISelect_only_statementContext) { + localctx = NewSelect_only_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1868, PlSqlParserRULE_select_only_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(16945) + p.With_clause() + } + + } + { + p.SetState(16948) + p.Subquery() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_statementContext is an interface to support dynamic dispatch. +type ISelect_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_only_statement() ISelect_only_statementContext + AllFor_update_clause() []IFor_update_clauseContext + For_update_clause(i int) IFor_update_clauseContext + AllOrder_by_clause() []IOrder_by_clauseContext + Order_by_clause(i int) IOrder_by_clauseContext + AllOffset_clause() []IOffset_clauseContext + Offset_clause(i int) IOffset_clauseContext + AllFetch_clause() []IFetch_clauseContext + Fetch_clause(i int) IFetch_clauseContext + + // IsSelect_statementContext differentiates from other interfaces. + IsSelect_statementContext() +} + +type Select_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_statementContext() *Select_statementContext { + var p = new(Select_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_statement + return p +} + +func InitEmptySelect_statementContext(p *Select_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_statement +} + +func (*Select_statementContext) IsSelect_statementContext() {} + +func NewSelect_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statementContext { + var p = new(Select_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_select_statement + + return p +} + +func (s *Select_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statementContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Select_statementContext) AllFor_update_clause() []IFor_update_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFor_update_clauseContext); ok { + len++ + } + } + + tst := make([]IFor_update_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFor_update_clauseContext); ok { + tst[i] = t.(IFor_update_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) For_update_clause(i int) IFor_update_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_clauseContext) +} + +func (s *Select_statementContext) AllOrder_by_clause() []IOrder_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + len++ + } + } + + tst := make([]IOrder_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_by_clauseContext); ok { + tst[i] = t.(IOrder_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Order_by_clause(i int) IOrder_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Select_statementContext) AllOffset_clause() []IOffset_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOffset_clauseContext); ok { + len++ + } + } + + tst := make([]IOffset_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOffset_clauseContext); ok { + tst[i] = t.(IOffset_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Offset_clause(i int) IOffset_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOffset_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOffset_clauseContext) +} + +func (s *Select_statementContext) AllFetch_clause() []IFetch_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFetch_clauseContext); ok { + len++ + } + } + + tst := make([]IFetch_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFetch_clauseContext); ok { + tst[i] = t.(IFetch_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Fetch_clause(i int) IFetch_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFetch_clauseContext) +} + +func (s *Select_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelect_statement(s) + } +} + +func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_statement(s) + } +} + +func (p *PlSqlParser) Select_statement() (localctx ISelect_statementContext) { + localctx = NewSelect_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1870, PlSqlParserRULE_select_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16950) + p.Select_only_statement() + } + p.SetState(16957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserFETCH || _la == PlSqlParserFOR || _la == PlSqlParserOFFSET || _la == PlSqlParserORDER { + p.SetState(16955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFOR: + { + p.SetState(16951) + p.For_update_clause() + } + + case PlSqlParserORDER: + { + p.SetState(16952) + p.Order_by_clause() + } + + case PlSqlParserOFFSET: + { + p.SetState(16953) + p.Offset_clause() + } + + case PlSqlParserFETCH: + { + p.SetState(16954) + p.Fetch_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_clauseContext is an interface to support dynamic dispatch. +type IWith_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllWith_factoring_clause() []IWith_factoring_clauseContext + With_factoring_clause(i int) IWith_factoring_clauseContext + AllFunction_body() []IFunction_bodyContext + Function_body(i int) IFunction_bodyContext + AllProcedure_body() []IProcedure_bodyContext + Procedure_body(i int) IProcedure_bodyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_clauseContext differentiates from other interfaces. + IsWith_clauseContext() +} + +type With_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_clauseContext() *With_clauseContext { + var p = new(With_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_clause + return p +} + +func InitEmptyWith_clauseContext(p *With_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_clause +} + +func (*With_clauseContext) IsWith_clauseContext() {} + +func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext { + var p = new(With_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_with_clause + + return p +} + +func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *With_clauseContext) AllWith_factoring_clause() []IWith_factoring_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWith_factoring_clauseContext); ok { + len++ + } + } + + tst := make([]IWith_factoring_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWith_factoring_clauseContext); ok { + tst[i] = t.(IWith_factoring_clauseContext) + i++ + } + } + + return tst +} + +func (s *With_clauseContext) With_factoring_clause(i int) IWith_factoring_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_factoring_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWith_factoring_clauseContext) +} + +func (s *With_clauseContext) AllFunction_body() []IFunction_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_bodyContext); ok { + len++ + } + } + + tst := make([]IFunction_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_bodyContext); ok { + tst[i] = t.(IFunction_bodyContext) + i++ + } + } + + return tst +} + +func (s *With_clauseContext) Function_body(i int) IFunction_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *With_clauseContext) AllProcedure_body() []IProcedure_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_bodyContext); ok { + len++ + } + } + + tst := make([]IProcedure_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_bodyContext); ok { + tst[i] = t.(IProcedure_bodyContext) + i++ + } + } + + return tst +} + +func (s *With_clauseContext) Procedure_body(i int) IProcedure_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *With_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWith_clause(s) + } +} + +func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWith_clause(s) + } +} + +func (p *PlSqlParser) With_clause() (localctx IWith_clauseContext) { + localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1872, PlSqlParserRULE_with_clause) + var _la int + + var _alt int + + p.SetState(16993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2324, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16960) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2318, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(16963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFUNCTION: + { + p.SetState(16961) + p.Function_body() + } + + case PlSqlParserPROCEDURE: + { + p.SetState(16962) + p.Procedure_body() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(16967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2318, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(16968) + p.With_factoring_clause() + } + p.SetState(16973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16969) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16970) + p.With_factoring_clause() + } + + p.SetState(16975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16976) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(16979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFUNCTION: + { + p.SetState(16977) + p.Function_body() + } + + case PlSqlParserPROCEDURE: + { + p.SetState(16978) + p.Procedure_body() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16981) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2321, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717153) != 0) { + { + p.SetState(16983) + p.With_factoring_clause() + } + p.SetState(16988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16984) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16985) + p.With_factoring_clause() + } + + p.SetState(16990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_factoring_clauseContext is an interface to support dynamic dispatch. +type IWith_factoring_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery_factoring_clause() ISubquery_factoring_clauseContext + Subav_factoring_clause() ISubav_factoring_clauseContext + + // IsWith_factoring_clauseContext differentiates from other interfaces. + IsWith_factoring_clauseContext() +} + +type With_factoring_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_factoring_clauseContext() *With_factoring_clauseContext { + var p = new(With_factoring_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_factoring_clause + return p +} + +func InitEmptyWith_factoring_clauseContext(p *With_factoring_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_factoring_clause +} + +func (*With_factoring_clauseContext) IsWith_factoring_clauseContext() {} + +func NewWith_factoring_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_factoring_clauseContext { + var p = new(With_factoring_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_with_factoring_clause + + return p +} + +func (s *With_factoring_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_factoring_clauseContext) Subquery_factoring_clause() ISubquery_factoring_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_factoring_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_factoring_clauseContext) +} + +func (s *With_factoring_clauseContext) Subav_factoring_clause() ISubav_factoring_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubav_factoring_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubav_factoring_clauseContext) +} + +func (s *With_factoring_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_factoring_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_factoring_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWith_factoring_clause(s) + } +} + +func (s *With_factoring_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWith_factoring_clause(s) + } +} + +func (p *PlSqlParser) With_factoring_clause() (localctx IWith_factoring_clauseContext) { + localctx = NewWith_factoring_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1874, PlSqlParserRULE_with_factoring_clause) + p.SetState(16997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2325, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16995) + p.Subquery_factoring_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16996) + p.Subav_factoring_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_factoring_clauseContext is an interface to support dynamic dispatch. +type ISubquery_factoring_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_name() IQuery_nameContext + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + Order_by_clause() IOrder_by_clauseContext + Search_clause() ISearch_clauseContext + Cycle_clause() ICycle_clauseContext + + // IsSubquery_factoring_clauseContext differentiates from other interfaces. + IsSubquery_factoring_clauseContext() +} + +type Subquery_factoring_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_factoring_clauseContext() *Subquery_factoring_clauseContext { + var p = new(Subquery_factoring_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause + return p +} + +func InitEmptySubquery_factoring_clauseContext(p *Subquery_factoring_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause +} + +func (*Subquery_factoring_clauseContext) IsSubquery_factoring_clauseContext() {} + +func NewSubquery_factoring_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_factoring_clauseContext { + var p = new(Subquery_factoring_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause + + return p +} + +func (s *Subquery_factoring_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_factoring_clauseContext) Query_name() IQuery_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_nameContext) +} + +func (s *Subquery_factoring_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Subquery_factoring_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subquery_factoring_clauseContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Subquery_factoring_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subquery_factoring_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Subquery_factoring_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Subquery_factoring_clauseContext) Search_clause() ISearch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_clauseContext) +} + +func (s *Subquery_factoring_clauseContext) Cycle_clause() ICycle_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICycle_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICycle_clauseContext) +} + +func (s *Subquery_factoring_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_factoring_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_factoring_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_factoring_clause(s) + } +} + +func (s *Subquery_factoring_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_factoring_clause(s) + } +} + +func (p *PlSqlParser) Subquery_factoring_clause() (localctx ISubquery_factoring_clauseContext) { + localctx = NewSubquery_factoring_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1876, PlSqlParserRULE_subquery_factoring_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16999) + p.Query_name() + } + p.SetState(17001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17000) + p.Paren_column_list() + } + + } + { + p.SetState(17003) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17004) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17005) + p.Subquery() + } + p.SetState(17007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(17006) + p.Order_by_clause() + } + + } + { + p.SetState(17009) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEARCH { + { + p.SetState(17010) + p.Search_clause() + } + + } + p.SetState(17014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCYCLE { + { + p.SetState(17013) + p.Cycle_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearch_clauseContext is an interface to support dynamic dispatch. +type ISearch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEARCH() antlr.TerminalNode + AllFIRST() []antlr.TerminalNode + FIRST(i int) antlr.TerminalNode + BY() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + SET() antlr.TerminalNode + DEPTH() antlr.TerminalNode + BREADTH() antlr.TerminalNode + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + AllNULLS() []antlr.TerminalNode + NULLS(i int) antlr.TerminalNode + AllLAST() []antlr.TerminalNode + LAST(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSearch_clauseContext differentiates from other interfaces. + IsSearch_clauseContext() +} + +type Search_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_clauseContext() *Search_clauseContext { + var p = new(Search_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_search_clause + return p +} + +func InitEmptySearch_clauseContext(p *Search_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_search_clause +} + +func (*Search_clauseContext) IsSearch_clauseContext() {} + +func NewSearch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_clauseContext { + var p = new(Search_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_search_clause + + return p +} + +func (s *Search_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_clauseContext) SEARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEARCH, 0) +} + +func (s *Search_clauseContext) AllFIRST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFIRST) +} + +func (s *Search_clauseContext) FIRST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, i) +} + +func (s *Search_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Search_clauseContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Search_clauseContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Search_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Search_clauseContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Search_clauseContext) BREADTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBREADTH, 0) +} + +func (s *Search_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserASC) +} + +func (s *Search_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, i) +} + +func (s *Search_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDESC) +} + +func (s *Search_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, i) +} + +func (s *Search_clauseContext) AllNULLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULLS) +} + +func (s *Search_clauseContext) NULLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, i) +} + +func (s *Search_clauseContext) AllLAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLAST) +} + +func (s *Search_clauseContext) LAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, i) +} + +func (s *Search_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Search_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Search_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearch_clause(s) + } +} + +func (s *Search_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearch_clause(s) + } +} + +func (p *PlSqlParser) Search_clause() (localctx ISearch_clauseContext) { + localctx = NewSearch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1878, PlSqlParserRULE_search_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17016) + p.Match(PlSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17017) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBREADTH || _la == PlSqlParserDEPTH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17018) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17019) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17020) + p.Column_name() + } + p.SetState(17022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC { + { + p.SetState(17021) + p.Match(PlSqlParserASC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESC { + { + p.SetState(17024) + p.Match(PlSqlParserDESC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17029) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2332, p.GetParserRuleContext()) == 1 { + { + p.SetState(17027) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17028) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLS { + { + p.SetState(17031) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17032) + p.Match(PlSqlParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17035) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17036) + p.Column_name() + } + p.SetState(17038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC { + { + p.SetState(17037) + p.Match(PlSqlParserASC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESC { + { + p.SetState(17040) + p.Match(PlSqlParserDESC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17045) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2336, p.GetParserRuleContext()) == 1 { + { + p.SetState(17043) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17044) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLS { + { + p.SetState(17047) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17048) + p.Match(PlSqlParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(17055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17056) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17057) + p.Column_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICycle_clauseContext is an interface to support dynamic dispatch. +type ICycle_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CYCLE() antlr.TerminalNode + Column_list() IColumn_listContext + SET() antlr.TerminalNode + Column_name() IColumn_nameContext + TO() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + DEFAULT() antlr.TerminalNode + + // IsCycle_clauseContext differentiates from other interfaces. + IsCycle_clauseContext() +} + +type Cycle_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCycle_clauseContext() *Cycle_clauseContext { + var p = new(Cycle_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cycle_clause + return p +} + +func InitEmptyCycle_clauseContext(p *Cycle_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cycle_clause +} + +func (*Cycle_clauseContext) IsCycle_clauseContext() {} + +func NewCycle_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cycle_clauseContext { + var p = new(Cycle_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cycle_clause + + return p +} + +func (s *Cycle_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cycle_clauseContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Cycle_clauseContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Cycle_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Cycle_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Cycle_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Cycle_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Cycle_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Cycle_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Cycle_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cycle_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cycle_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCycle_clause(s) + } +} + +func (s *Cycle_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCycle_clause(s) + } +} + +func (p *PlSqlParser) Cycle_clause() (localctx ICycle_clauseContext) { + localctx = NewCycle_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1880, PlSqlParserRULE_cycle_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17059) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17060) + p.Column_list() + } + { + p.SetState(17061) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17062) + p.Column_name() + } + { + p.SetState(17063) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17064) + p.Expression() + } + { + p.SetState(17065) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17066) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubav_factoring_clauseContext is an interface to support dynamic dispatch. +type ISubav_factoring_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSubav_name returns the subav_name rule contexts. + GetSubav_name() IId_expressionContext + + // SetSubav_name sets the subav_name rule contexts. + SetSubav_name(IId_expressionContext) + + // Getter signatures + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subav_clause() ISubav_clauseContext + RIGHT_PAREN() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsSubav_factoring_clauseContext differentiates from other interfaces. + IsSubav_factoring_clauseContext() +} + +type Subav_factoring_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + subav_name IId_expressionContext +} + +func NewEmptySubav_factoring_clauseContext() *Subav_factoring_clauseContext { + var p = new(Subav_factoring_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subav_factoring_clause + return p +} + +func InitEmptySubav_factoring_clauseContext(p *Subav_factoring_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subav_factoring_clause +} + +func (*Subav_factoring_clauseContext) IsSubav_factoring_clauseContext() {} + +func NewSubav_factoring_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subav_factoring_clauseContext { + var p = new(Subav_factoring_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subav_factoring_clause + + return p +} + +func (s *Subav_factoring_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subav_factoring_clauseContext) GetSubav_name() IId_expressionContext { return s.subav_name } + +func (s *Subav_factoring_clauseContext) SetSubav_name(v IId_expressionContext) { s.subav_name = v } + +func (s *Subav_factoring_clauseContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Subav_factoring_clauseContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Subav_factoring_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Subav_factoring_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subav_factoring_clauseContext) Subav_clause() ISubav_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubav_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubav_clauseContext) +} + +func (s *Subav_factoring_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subav_factoring_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Subav_factoring_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subav_factoring_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subav_factoring_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubav_factoring_clause(s) + } +} + +func (s *Subav_factoring_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubav_factoring_clause(s) + } +} + +func (p *PlSqlParser) Subav_factoring_clause() (localctx ISubav_factoring_clauseContext) { + localctx = NewSubav_factoring_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1882, PlSqlParserRULE_subav_factoring_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17068) + + var _x = p.Id_expression() + + localctx.(*Subav_factoring_clauseContext).subav_name = _x + } + { + p.SetState(17069) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17070) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17071) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17072) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17073) + p.Subav_clause() + } + { + p.SetState(17074) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubav_clauseContext is an interface to support dynamic dispatch. +type ISubav_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSubav_name returns the subav_name rule contexts. + GetSubav_name() IObject_nameContext + + // SetSubav_name sets the subav_name rule contexts. + SetSubav_name(IObject_nameContext) + + // Getter signatures + USING() antlr.TerminalNode + Object_name() IObject_nameContext + Hierarchies_clause() IHierarchies_clauseContext + Filter_clauses() IFilter_clausesContext + Add_calcs_clause() IAdd_calcs_clauseContext + + // IsSubav_clauseContext differentiates from other interfaces. + IsSubav_clauseContext() +} + +type Subav_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + subav_name IObject_nameContext +} + +func NewEmptySubav_clauseContext() *Subav_clauseContext { + var p = new(Subav_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subav_clause + return p +} + +func InitEmptySubav_clauseContext(p *Subav_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subav_clause +} + +func (*Subav_clauseContext) IsSubav_clauseContext() {} + +func NewSubav_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subav_clauseContext { + var p = new(Subav_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subav_clause + + return p +} + +func (s *Subav_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subav_clauseContext) GetSubav_name() IObject_nameContext { return s.subav_name } + +func (s *Subav_clauseContext) SetSubav_name(v IObject_nameContext) { s.subav_name = v } + +func (s *Subav_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Subav_clauseContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Subav_clauseContext) Hierarchies_clause() IHierarchies_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchies_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHierarchies_clauseContext) +} + +func (s *Subav_clauseContext) Filter_clauses() IFilter_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilter_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilter_clausesContext) +} + +func (s *Subav_clauseContext) Add_calcs_clause() IAdd_calcs_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_calcs_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_calcs_clauseContext) +} + +func (s *Subav_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subav_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subav_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubav_clause(s) + } +} + +func (s *Subav_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubav_clause(s) + } +} + +func (p *PlSqlParser) Subav_clause() (localctx ISubav_clauseContext) { + localctx = NewSubav_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1884, PlSqlParserRULE_subav_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17076) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17077) + + var _x = p.Object_name() + + localctx.(*Subav_clauseContext).subav_name = _x + } + p.SetState(17079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIERARCHIES { + { + p.SetState(17078) + p.Hierarchies_clause() + } + + } + p.SetState(17082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILTER { + { + p.SetState(17081) + p.Filter_clauses() + } + + } + p.SetState(17085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(17084) + p.Add_calcs_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchies_clauseContext is an interface to support dynamic dispatch. +type IHierarchies_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_object_name returns the _object_name rule contexts. + Get_object_name() IObject_nameContext + + // Set_object_name sets the _object_name rule contexts. + Set_object_name(IObject_nameContext) + + // GetHier_alias returns the hier_alias rule context list. + GetHier_alias() []IObject_nameContext + + // SetHier_alias sets the hier_alias rule context list. + SetHier_alias([]IObject_nameContext) + + // Getter signatures + HIERARCHIES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHierarchies_clauseContext differentiates from other interfaces. + IsHierarchies_clauseContext() +} + +type Hierarchies_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _object_name IObject_nameContext + hier_alias []IObject_nameContext +} + +func NewEmptyHierarchies_clauseContext() *Hierarchies_clauseContext { + var p = new(Hierarchies_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchies_clause + return p +} + +func InitEmptyHierarchies_clauseContext(p *Hierarchies_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchies_clause +} + +func (*Hierarchies_clauseContext) IsHierarchies_clauseContext() {} + +func NewHierarchies_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchies_clauseContext { + var p = new(Hierarchies_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hierarchies_clause + + return p +} + +func (s *Hierarchies_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchies_clauseContext) Get_object_name() IObject_nameContext { return s._object_name } + +func (s *Hierarchies_clauseContext) Set_object_name(v IObject_nameContext) { s._object_name = v } + +func (s *Hierarchies_clauseContext) GetHier_alias() []IObject_nameContext { return s.hier_alias } + +func (s *Hierarchies_clauseContext) SetHier_alias(v []IObject_nameContext) { s.hier_alias = v } + +func (s *Hierarchies_clauseContext) HIERARCHIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHIES, 0) +} + +func (s *Hierarchies_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hierarchies_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hierarchies_clauseContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Hierarchies_clauseContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Hierarchies_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hierarchies_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hierarchies_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchies_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchies_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHierarchies_clause(s) + } +} + +func (s *Hierarchies_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHierarchies_clause(s) + } +} + +func (p *PlSqlParser) Hierarchies_clause() (localctx IHierarchies_clauseContext) { + localctx = NewHierarchies_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1886, PlSqlParserRULE_hierarchies_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17087) + p.Match(PlSqlParserHIERARCHIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17088) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17089) + + var _x = p.Object_name() + + localctx.(*Hierarchies_clauseContext)._object_name = _x + } + localctx.(*Hierarchies_clauseContext).hier_alias = append(localctx.(*Hierarchies_clauseContext).hier_alias, localctx.(*Hierarchies_clauseContext)._object_name) + p.SetState(17094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17090) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17091) + + var _x = p.Object_name() + + localctx.(*Hierarchies_clauseContext)._object_name = _x + } + localctx.(*Hierarchies_clauseContext).hier_alias = append(localctx.(*Hierarchies_clauseContext).hier_alias, localctx.(*Hierarchies_clauseContext)._object_name) + + p.SetState(17096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17097) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilter_clausesContext is an interface to support dynamic dispatch. +type IFilter_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILTER() antlr.TerminalNode + FACT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllFilter_clause() []IFilter_clauseContext + Filter_clause(i int) IFilter_clauseContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFilter_clausesContext differentiates from other interfaces. + IsFilter_clausesContext() +} + +type Filter_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilter_clausesContext() *Filter_clausesContext { + var p = new(Filter_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_clauses + return p +} + +func InitEmptyFilter_clausesContext(p *Filter_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_clauses +} + +func (*Filter_clausesContext) IsFilter_clausesContext() {} + +func NewFilter_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clausesContext { + var p = new(Filter_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filter_clauses + + return p +} + +func (s *Filter_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filter_clausesContext) FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILTER, 0) +} + +func (s *Filter_clausesContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Filter_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Filter_clausesContext) AllFilter_clause() []IFilter_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilter_clauseContext); ok { + len++ + } + } + + tst := make([]IFilter_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilter_clauseContext); ok { + tst[i] = t.(IFilter_clauseContext) + i++ + } + } + + return tst +} + +func (s *Filter_clausesContext) Filter_clause(i int) IFilter_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilter_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilter_clauseContext) +} + +func (s *Filter_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Filter_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Filter_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Filter_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filter_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filter_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilter_clauses(s) + } +} + +func (s *Filter_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilter_clauses(s) + } +} + +func (p *PlSqlParser) Filter_clauses() (localctx IFilter_clausesContext) { + localctx = NewFilter_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1888, PlSqlParserRULE_filter_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17099) + p.Match(PlSqlParserFILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17100) + p.Match(PlSqlParserFACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17101) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17102) + p.Filter_clause() + } + p.SetState(17107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17103) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17104) + p.Filter_clause() + } + + p.SetState(17109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17110) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilter_clauseContext is an interface to support dynamic dispatch. +type IFilter_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHier_alias returns the hier_alias rule contexts. + GetHier_alias() IObject_nameContext + + // SetHier_alias sets the hier_alias rule contexts. + SetHier_alias(IObject_nameContext) + + // Getter signatures + TO() antlr.TerminalNode + Condition() IConditionContext + MEASURES() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsFilter_clauseContext differentiates from other interfaces. + IsFilter_clauseContext() +} + +type Filter_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hier_alias IObject_nameContext +} + +func NewEmptyFilter_clauseContext() *Filter_clauseContext { + var p = new(Filter_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_clause + return p +} + +func InitEmptyFilter_clauseContext(p *Filter_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filter_clause +} + +func (*Filter_clauseContext) IsFilter_clauseContext() {} + +func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clauseContext { + var p = new(Filter_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filter_clause + + return p +} + +func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filter_clauseContext) GetHier_alias() IObject_nameContext { return s.hier_alias } + +func (s *Filter_clauseContext) SetHier_alias(v IObject_nameContext) { s.hier_alias = v } + +func (s *Filter_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Filter_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Filter_clauseContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Filter_clauseContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilter_clause(s) + } +} + +func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilter_clause(s) + } +} + +func (p *PlSqlParser) Filter_clause() (localctx IFilter_clauseContext) { + localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1890, PlSqlParserRULE_filter_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(17114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2344, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17112) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17113) + + var _x = p.Object_name() + + localctx.(*Filter_clauseContext).hier_alias = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(17116) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17117) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_calcs_clauseContext is an interface to support dynamic dispatch. +type IAdd_calcs_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + MEASURES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAdd_calc_meas_clause() []IAdd_calc_meas_clauseContext + Add_calc_meas_clause(i int) IAdd_calc_meas_clauseContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_calcs_clauseContext differentiates from other interfaces. + IsAdd_calcs_clauseContext() +} + +type Add_calcs_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_calcs_clauseContext() *Add_calcs_clauseContext { + var p = new(Add_calcs_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_calcs_clause + return p +} + +func InitEmptyAdd_calcs_clauseContext(p *Add_calcs_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_calcs_clause +} + +func (*Add_calcs_clauseContext) IsAdd_calcs_clauseContext() {} + +func NewAdd_calcs_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_calcs_clauseContext { + var p = new(Add_calcs_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_calcs_clause + + return p +} + +func (s *Add_calcs_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_calcs_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_calcs_clauseContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Add_calcs_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_calcs_clauseContext) AllAdd_calc_meas_clause() []IAdd_calc_meas_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_calc_meas_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_calc_meas_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_calc_meas_clauseContext); ok { + tst[i] = t.(IAdd_calc_meas_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_calcs_clauseContext) Add_calc_meas_clause(i int) IAdd_calc_meas_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_calc_meas_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_calc_meas_clauseContext) +} + +func (s *Add_calcs_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_calcs_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_calcs_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_calcs_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_calcs_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_calcs_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_calcs_clause(s) + } +} + +func (s *Add_calcs_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_calcs_clause(s) + } +} + +func (p *PlSqlParser) Add_calcs_clause() (localctx IAdd_calcs_clauseContext) { + localctx = NewAdd_calcs_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1892, PlSqlParserRULE_add_calcs_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17119) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17120) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17121) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17122) + p.Add_calc_meas_clause() + } + p.SetState(17127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17123) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17124) + p.Add_calc_meas_clause() + } + + p.SetState(17129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17130) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_calc_meas_clauseContext is an interface to support dynamic dispatch. +type IAdd_calc_meas_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMeas_name returns the meas_name rule contexts. + GetMeas_name() IId_expressionContext + + // SetMeas_name sets the meas_name rule contexts. + SetMeas_name(IId_expressionContext) + + // Getter signatures + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsAdd_calc_meas_clauseContext differentiates from other interfaces. + IsAdd_calc_meas_clauseContext() +} + +type Add_calc_meas_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + meas_name IId_expressionContext +} + +func NewEmptyAdd_calc_meas_clauseContext() *Add_calc_meas_clauseContext { + var p = new(Add_calc_meas_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_calc_meas_clause + return p +} + +func InitEmptyAdd_calc_meas_clauseContext(p *Add_calc_meas_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_calc_meas_clause +} + +func (*Add_calc_meas_clauseContext) IsAdd_calc_meas_clauseContext() {} + +func NewAdd_calc_meas_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_calc_meas_clauseContext { + var p = new(Add_calc_meas_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_calc_meas_clause + + return p +} + +func (s *Add_calc_meas_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_calc_meas_clauseContext) GetMeas_name() IId_expressionContext { return s.meas_name } + +func (s *Add_calc_meas_clauseContext) SetMeas_name(v IId_expressionContext) { s.meas_name = v } + +func (s *Add_calc_meas_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Add_calc_meas_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_calc_meas_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Add_calc_meas_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_calc_meas_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_calc_meas_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_calc_meas_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_calc_meas_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_calc_meas_clause(s) + } +} + +func (s *Add_calc_meas_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_calc_meas_clause(s) + } +} + +func (p *PlSqlParser) Add_calc_meas_clause() (localctx IAdd_calc_meas_clauseContext) { + localctx = NewAdd_calc_meas_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1894, PlSqlParserRULE_add_calc_meas_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17132) + + var _x = p.Id_expression() + + localctx.(*Add_calc_meas_clauseContext).meas_name = _x + } + { + p.SetState(17133) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17134) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17135) + p.Expression() + } + { + p.SetState(17136) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubqueryContext is an interface to support dynamic dispatch. +type ISubqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery_basic_elements() ISubquery_basic_elementsContext + AllSubquery_operation_part() []ISubquery_operation_partContext + Subquery_operation_part(i int) ISubquery_operation_partContext + + // IsSubqueryContext differentiates from other interfaces. + IsSubqueryContext() +} + +type SubqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubqueryContext() *SubqueryContext { + var p = new(SubqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery + return p +} + +func InitEmptySubqueryContext(p *SubqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery +} + +func (*SubqueryContext) IsSubqueryContext() {} + +func NewSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryContext { + var p = new(SubqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery + + return p +} + +func (s *SubqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubqueryContext) Subquery_basic_elements() ISubquery_basic_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_basic_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_basic_elementsContext) +} + +func (s *SubqueryContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *SubqueryContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +func (s *SubqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery(s) + } +} + +func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery(s) + } +} + +func (p *PlSqlParser) Subquery() (localctx ISubqueryContext) { + localctx = NewSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1896, PlSqlParserRULE_subquery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17138) + p.Subquery_basic_elements() + } + p.SetState(17142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserINTERSECT || _la == PlSqlParserMINUS || _la == PlSqlParserUNION { + { + p.SetState(17139) + p.Subquery_operation_part() + } + + p.SetState(17144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_basic_elementsContext is an interface to support dynamic dispatch. +type ISubquery_basic_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_block() IQuery_blockContext + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + + // IsSubquery_basic_elementsContext differentiates from other interfaces. + IsSubquery_basic_elementsContext() +} + +type Subquery_basic_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_basic_elementsContext() *Subquery_basic_elementsContext { + var p = new(Subquery_basic_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements + return p +} + +func InitEmptySubquery_basic_elementsContext(p *Subquery_basic_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements +} + +func (*Subquery_basic_elementsContext) IsSubquery_basic_elementsContext() {} + +func NewSubquery_basic_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_basic_elementsContext { + var p = new(Subquery_basic_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements + + return p +} + +func (s *Subquery_basic_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_basic_elementsContext) Query_block() IQuery_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_blockContext) +} + +func (s *Subquery_basic_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subquery_basic_elementsContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Subquery_basic_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subquery_basic_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_basic_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_basic_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_basic_elements(s) + } +} + +func (s *Subquery_basic_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_basic_elements(s) + } +} + +func (p *PlSqlParser) Subquery_basic_elements() (localctx ISubquery_basic_elementsContext) { + localctx = NewSubquery_basic_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1898, PlSqlParserRULE_subquery_basic_elements) + p.SetState(17150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17145) + p.Query_block() + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17146) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17147) + p.Subquery() + } + { + p.SetState(17148) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_operation_partContext is an interface to support dynamic dispatch. +type ISubquery_operation_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery_basic_elements() ISubquery_basic_elementsContext + UNION() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + MINUS() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsSubquery_operation_partContext differentiates from other interfaces. + IsSubquery_operation_partContext() +} + +type Subquery_operation_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_operation_partContext() *Subquery_operation_partContext { + var p = new(Subquery_operation_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_operation_part + return p +} + +func InitEmptySubquery_operation_partContext(p *Subquery_operation_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_operation_part +} + +func (*Subquery_operation_partContext) IsSubquery_operation_partContext() {} + +func NewSubquery_operation_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_operation_partContext { + var p = new(Subquery_operation_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_operation_part + + return p +} + +func (s *Subquery_operation_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_operation_partContext) Subquery_basic_elements() ISubquery_basic_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_basic_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_basic_elementsContext) +} + +func (s *Subquery_operation_partContext) UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNION, 0) +} + +func (s *Subquery_operation_partContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERSECT, 0) +} + +func (s *Subquery_operation_partContext) MINUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS, 0) +} + +func (s *Subquery_operation_partContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Subquery_operation_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_operation_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_operation_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_operation_part(s) + } +} + +func (s *Subquery_operation_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_operation_part(s) + } +} + +func (p *PlSqlParser) Subquery_operation_part() (localctx ISubquery_operation_partContext) { + localctx = NewSubquery_operation_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1900, PlSqlParserRULE_subquery_operation_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNION: + { + p.SetState(17152) + p.Match(PlSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(17153) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserINTERSECT: + { + p.SetState(17156) + p.Match(PlSqlParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUS: + { + p.SetState(17157) + p.Match(PlSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(17160) + p.Subquery_basic_elements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_blockContext is an interface to support dynamic dispatch. +type IQuery_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Selected_list() ISelected_listContext + Into_clause() IInto_clauseContext + From_clause() IFrom_clauseContext + Where_clause() IWhere_clauseContext + AllHierarchical_query_clause() []IHierarchical_query_clauseContext + Hierarchical_query_clause(i int) IHierarchical_query_clauseContext + AllGroup_by_clause() []IGroup_by_clauseContext + Group_by_clause(i int) IGroup_by_clauseContext + Model_clause() IModel_clauseContext + Order_by_clause() IOrder_by_clauseContext + Offset_clause() IOffset_clauseContext + Fetch_clause() IFetch_clauseContext + DISTINCT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsQuery_blockContext differentiates from other interfaces. + IsQuery_blockContext() +} + +type Query_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_blockContext() *Query_blockContext { + var p = new(Query_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_block + return p +} + +func InitEmptyQuery_blockContext(p *Query_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_block +} + +func (*Query_blockContext) IsQuery_blockContext() {} + +func NewQuery_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_blockContext { + var p = new(Query_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_block + + return p +} + +func (s *Query_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_blockContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Query_blockContext) Selected_list() ISelected_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelected_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelected_listContext) +} + +func (s *Query_blockContext) Into_clause() IInto_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Query_blockContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *Query_blockContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Query_blockContext) AllHierarchical_query_clause() []IHierarchical_query_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHierarchical_query_clauseContext); ok { + len++ + } + } + + tst := make([]IHierarchical_query_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHierarchical_query_clauseContext); ok { + tst[i] = t.(IHierarchical_query_clauseContext) + i++ + } + } + + return tst +} + +func (s *Query_blockContext) Hierarchical_query_clause(i int) IHierarchical_query_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchical_query_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHierarchical_query_clauseContext) +} + +func (s *Query_blockContext) AllGroup_by_clause() []IGroup_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + len++ + } + } + + tst := make([]IGroup_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_clauseContext); ok { + tst[i] = t.(IGroup_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Query_blockContext) Group_by_clause(i int) IGroup_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Query_blockContext) Model_clause() IModel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_clauseContext) +} + +func (s *Query_blockContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Query_blockContext) Offset_clause() IOffset_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOffset_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOffset_clauseContext) +} + +func (s *Query_blockContext) Fetch_clause() IFetch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_clauseContext) +} + +func (s *Query_blockContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Query_blockContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Query_blockContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Query_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_block(s) + } +} + +func (s *Query_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_block(s) + } +} + +func (p *PlSqlParser) Query_block() (localctx IQuery_blockContext) { + localctx = NewQuery_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1902, PlSqlParserRULE_query_block) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17162) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17164) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2350, p.GetParserRuleContext()) == 1 { + { + p.SetState(17163) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17166) + p.Selected_list() + } + p.SetState(17168) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2351, p.GetParserRuleContext()) == 1 { + { + p.SetState(17167) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17171) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2352, p.GetParserRuleContext()) == 1 { + { + p.SetState(17170) + p.From_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2353, p.GetParserRuleContext()) == 1 { + { + p.SetState(17173) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2355, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(17178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT, PlSqlParserSTART: + { + p.SetState(17176) + p.Hierarchical_query_clause() + } + + case PlSqlParserGROUP, PlSqlParserHAVING: + { + p.SetState(17177) + p.Group_by_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(17182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2355, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(17184) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2356, p.GetParserRuleContext()) == 1 { + { + p.SetState(17183) + p.Model_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17187) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2357, p.GetParserRuleContext()) == 1 { + { + p.SetState(17186) + p.Order_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17190) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2358, p.GetParserRuleContext()) == 1 { + { + p.SetState(17189) + p.Offset_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17193) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2359, p.GetParserRuleContext()) == 1 { + { + p.SetState(17192) + p.Fetch_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelected_listContext is an interface to support dynamic dispatch. +type ISelected_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASTERISK() antlr.TerminalNode + AllSelect_list_elements() []ISelect_list_elementsContext + Select_list_elements(i int) ISelect_list_elementsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelected_listContext differentiates from other interfaces. + IsSelected_listContext() +} + +type Selected_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelected_listContext() *Selected_listContext { + var p = new(Selected_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_list + return p +} + +func InitEmptySelected_listContext(p *Selected_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_list +} + +func (*Selected_listContext) IsSelected_listContext() {} + +func NewSelected_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selected_listContext { + var p = new(Selected_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selected_list + + return p +} + +func (s *Selected_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selected_listContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Selected_listContext) AllSelect_list_elements() []ISelect_list_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_list_elementsContext); ok { + len++ + } + } + + tst := make([]ISelect_list_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_list_elementsContext); ok { + tst[i] = t.(ISelect_list_elementsContext) + i++ + } + } + + return tst +} + +func (s *Selected_listContext) Select_list_elements(i int) ISelect_list_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_elementsContext) +} + +func (s *Selected_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Selected_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Selected_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selected_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selected_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelected_list(s) + } +} + +func (s *Selected_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelected_list(s) + } +} + +func (p *PlSqlParser) Selected_list() (localctx ISelected_listContext) { + localctx = NewSelected_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1904, PlSqlParserRULE_selected_list) + var _alt int + + p.SetState(17204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2361, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17195) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17196) + p.Select_list_elements() + } + p.SetState(17201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2360, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17197) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17198) + p.Select_list_elements() + } + + } + p.SetState(17203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2360, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_clauseContext is an interface to support dynamic dispatch. +type IFrom_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + Table_ref_list() ITable_ref_listContext + + // IsFrom_clauseContext differentiates from other interfaces. + IsFrom_clauseContext() +} + +type From_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clauseContext() *From_clauseContext { + var p = new(From_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_from_clause + return p +} + +func InitEmptyFrom_clauseContext(p *From_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_from_clause +} + +func (*From_clauseContext) IsFrom_clauseContext() {} + +func NewFrom_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_clauseContext { + var p = new(From_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_from_clause + + return p +} + +func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *From_clauseContext) Table_ref_list() ITable_ref_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_listContext) +} + +func (s *From_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFrom_clause(s) + } +} + +func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFrom_clause(s) + } +} + +func (p *PlSqlParser) From_clause() (localctx IFrom_clauseContext) { + localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1906, PlSqlParserRULE_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17206) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17207) + p.Table_ref_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_list_elementsContext is an interface to support dynamic dispatch. +type ISelect_list_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + PERIOD() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + Expression() IExpressionContext + Column_alias() IColumn_aliasContext + + // IsSelect_list_elementsContext differentiates from other interfaces. + IsSelect_list_elementsContext() +} + +type Select_list_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_elementsContext() *Select_list_elementsContext { + var p = new(Select_list_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_list_elements + return p +} + +func InitEmptySelect_list_elementsContext(p *Select_list_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_list_elements +} + +func (*Select_list_elementsContext) IsSelect_list_elementsContext() {} + +func NewSelect_list_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_elementsContext { + var p = new(Select_list_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_select_list_elements + + return p +} + +func (s *Select_list_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_elementsContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Select_list_elementsContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Select_list_elementsContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Select_list_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_list_elementsContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Select_list_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelect_list_elements(s) + } +} + +func (s *Select_list_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_list_elements(s) + } +} + +func (p *PlSqlParser) Select_list_elements() (localctx ISelect_list_elementsContext) { + localctx = NewSelect_list_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1908, PlSqlParserRULE_select_list_elements) + p.SetState(17217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2363, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17209) + p.Tableview_name() + } + { + p.SetState(17210) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17211) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17213) + p.Expression() + } + p.SetState(17215) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2362, p.GetParserRuleContext()) == 1 { + { + p.SetState(17214) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_ref_listContext is an interface to support dynamic dispatch. +type ITable_ref_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_ref() []ITable_refContext + Table_ref(i int) ITable_refContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_ref_listContext differentiates from other interfaces. + IsTable_ref_listContext() +} + +type Table_ref_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_listContext() *Table_ref_listContext { + var p = new(Table_ref_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_list + return p +} + +func InitEmptyTable_ref_listContext(p *Table_ref_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_list +} + +func (*Table_ref_listContext) IsTable_ref_listContext() {} + +func NewTable_ref_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_listContext { + var p = new(Table_ref_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_list + + return p +} + +func (s *Table_ref_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_listContext) AllTable_ref() []ITable_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_refContext); ok { + len++ + } + } + + tst := make([]ITable_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_refContext); ok { + tst[i] = t.(ITable_refContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_listContext) Table_ref(i int) ITable_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *Table_ref_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Table_ref_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Table_ref_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_ref_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_list(s) + } +} + +func (s *Table_ref_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_list(s) + } +} + +func (p *PlSqlParser) Table_ref_list() (localctx ITable_ref_listContext) { + localctx = NewTable_ref_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1910, PlSqlParserRULE_table_ref_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17219) + p.Table_ref() + } + p.SetState(17224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2364, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17220) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17221) + p.Table_ref() + } + + } + p.SetState(17226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2364, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_refContext is an interface to support dynamic dispatch. +type ITable_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_ref_aux() ITable_ref_auxContext + AllJoin_clause() []IJoin_clauseContext + Join_clause(i int) IJoin_clauseContext + Pivot_clause() IPivot_clauseContext + Unpivot_clause() IUnpivot_clauseContext + + // IsTable_refContext differentiates from other interfaces. + IsTable_refContext() +} + +type Table_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_refContext() *Table_refContext { + var p = new(Table_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref + return p +} + +func InitEmptyTable_refContext(p *Table_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref +} + +func (*Table_refContext) IsTable_refContext() {} + +func NewTable_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_refContext { + var p = new(Table_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref + + return p +} + +func (s *Table_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_refContext) Table_ref_aux() ITable_ref_auxContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_auxContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_auxContext) +} + +func (s *Table_refContext) AllJoin_clause() []IJoin_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_clauseContext); ok { + len++ + } + } + + tst := make([]IJoin_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_clauseContext); ok { + tst[i] = t.(IJoin_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_refContext) Join_clause(i int) IJoin_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_clauseContext) +} + +func (s *Table_refContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_refContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref(s) + } +} + +func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref(s) + } +} + +func (p *PlSqlParser) Table_ref() (localctx ITable_refContext) { + localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1912, PlSqlParserRULE_table_ref) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17227) + p.Table_ref_aux() + } + p.SetState(17231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2365, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17228) + p.Join_clause() + } + + } + p.SetState(17233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2365, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(17236) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2366, p.GetParserRuleContext()) == 1 { + { + p.SetState(17234) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2366, p.GetParserRuleContext()) == 2 { + { + p.SetState(17235) + p.Unpivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_ref_auxContext is an interface to support dynamic dispatch. +type ITable_ref_auxContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_ref_aux_internal() ITable_ref_aux_internalContext + AllFlashback_query_clause() []IFlashback_query_clauseContext + Flashback_query_clause(i int) IFlashback_query_clauseContext + Table_alias() ITable_aliasContext + + // IsTable_ref_auxContext differentiates from other interfaces. + IsTable_ref_auxContext() +} + +type Table_ref_auxContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_auxContext() *Table_ref_auxContext { + var p = new(Table_ref_auxContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux + return p +} + +func InitEmptyTable_ref_auxContext(p *Table_ref_auxContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux +} + +func (*Table_ref_auxContext) IsTable_ref_auxContext() {} + +func NewTable_ref_auxContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_auxContext { + var p = new(Table_ref_auxContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_aux + + return p +} + +func (s *Table_ref_auxContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_auxContext) Table_ref_aux_internal() ITable_ref_aux_internalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_aux_internalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_aux_internalContext) +} + +func (s *Table_ref_auxContext) AllFlashback_query_clause() []IFlashback_query_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_query_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_query_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_query_clauseContext); ok { + tst[i] = t.(IFlashback_query_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_auxContext) Flashback_query_clause(i int) IFlashback_query_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_query_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_query_clauseContext) +} + +func (s *Table_ref_auxContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Table_ref_auxContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_auxContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_ref_auxContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux(s) + } +} + +func (s *Table_ref_auxContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux(s) + } +} + +func (p *PlSqlParser) Table_ref_aux() (localctx ITable_ref_auxContext) { + localctx = NewTable_ref_auxContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1914, PlSqlParserRULE_table_ref_aux) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17238) + p.Table_ref_aux_internal() + } + p.SetState(17242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2367, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17239) + p.Flashback_query_clause() + } + + } + p.SetState(17244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2367, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(17247) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2368, p.GetParserRuleContext()) == 1 { + p.SetState(17245) + + if !(p.isNotStartOfJoin()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isNotStartOfJoin()", "")) + goto errorExit + } + { + p.SetState(17246) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_ref_aux_internalContext is an interface to support dynamic dispatch. +type ITable_ref_aux_internalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTable_ref_aux_internalContext differentiates from other interfaces. + IsTable_ref_aux_internalContext() +} + +type Table_ref_aux_internalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_aux_internalContext() *Table_ref_aux_internalContext { + var p = new(Table_ref_aux_internalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal + return p +} + +func InitEmptyTable_ref_aux_internalContext(p *Table_ref_aux_internalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal +} + +func (*Table_ref_aux_internalContext) IsTable_ref_aux_internalContext() {} + +func NewTable_ref_aux_internalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_aux_internalContext { + var p = new(Table_ref_aux_internalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal + + return p +} + +func (s *Table_ref_aux_internalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_aux_internalContext) CopyAll(ctx *Table_ref_aux_internalContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *Table_ref_aux_internalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type Table_ref_aux_internal_oneContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_oneContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_oneContext { + var p = new(Table_ref_aux_internal_oneContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_oneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_oneContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_one(s) + } +} + +func (s *Table_ref_aux_internal_oneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_one(s) + } +} + +type Table_ref_aux_internal_threContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_threContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_threContext { + var p = new(Table_ref_aux_internal_threContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_threContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_threContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Table_ref_aux_internal_threContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_threContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *Table_ref_aux_internal_threContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_threContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_thre(s) + } +} + +func (s *Table_ref_aux_internal_threContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_thre(s) + } +} + +type Table_ref_aux_internal_twoContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_twoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_twoContext { + var p = new(Table_ref_aux_internal_twoContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_twoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_twoContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_twoContext) Table_ref() ITable_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *Table_ref_aux_internal_twoContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_twoContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_aux_internal_twoContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +func (s *Table_ref_aux_internal_twoContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_ref_aux_internal_twoContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_ref_aux_internal_twoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_two(s) + } +} + +func (s *Table_ref_aux_internal_twoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_two(s) + } +} + +func (p *PlSqlParser) Table_ref_aux_internal() (localctx ITable_ref_aux_internalContext) { + localctx = NewTable_ref_aux_internalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1916, PlSqlParserRULE_table_ref_aux_internal) + var _la int + + p.SetState(17272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2372, p.GetParserRuleContext()) { + case 1: + localctx = NewTable_ref_aux_internal_oneContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17249) + p.Dml_table_expression_clause() + } + p.SetState(17252) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2369, p.GetParserRuleContext()) == 1 { + { + p.SetState(17250) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2369, p.GetParserRuleContext()) == 2 { + { + p.SetState(17251) + p.Unpivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewTable_ref_aux_internal_twoContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17254) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17255) + p.Table_ref() + } + p.SetState(17259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserINTERSECT || _la == PlSqlParserMINUS || _la == PlSqlParserUNION { + { + p.SetState(17256) + p.Subquery_operation_part() + } + + p.SetState(17261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17262) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17265) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2371, p.GetParserRuleContext()) == 1 { + { + p.SetState(17263) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2371, p.GetParserRuleContext()) == 2 { + { + p.SetState(17264) + p.Unpivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + localctx = NewTable_ref_aux_internal_threContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17267) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17268) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17269) + p.Dml_table_expression_clause() + } + { + p.SetState(17270) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_clauseContext is an interface to support dynamic dispatch. +type IJoin_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + Table_ref_aux() ITable_ref_auxContext + AllQuery_partition_clause() []IQuery_partition_clauseContext + Query_partition_clause(i int) IQuery_partition_clauseContext + INNER() antlr.TerminalNode + Outer_join_type() IOuter_join_typeContext + AllJoin_on_part() []IJoin_on_partContext + Join_on_part(i int) IJoin_on_partContext + AllJoin_using_part() []IJoin_using_partContext + Join_using_part(i int) IJoin_using_partContext + CROSS() antlr.TerminalNode + NATURAL() antlr.TerminalNode + APPLY() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsJoin_clauseContext differentiates from other interfaces. + IsJoin_clauseContext() +} + +type Join_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_clauseContext() *Join_clauseContext { + var p = new(Join_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_clause + return p +} + +func InitEmptyJoin_clauseContext(p *Join_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_clause +} + +func (*Join_clauseContext) IsJoin_clauseContext() {} + +func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext { + var p = new(Join_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_clause + + return p +} + +func (s *Join_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_clauseContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Join_clauseContext) Table_ref_aux() ITable_ref_auxContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_auxContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_auxContext) +} + +func (s *Join_clauseContext) AllQuery_partition_clause() []IQuery_partition_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + len++ + } + } + + tst := make([]IQuery_partition_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_partition_clauseContext); ok { + tst[i] = t.(IQuery_partition_clauseContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Query_partition_clause(i int) IQuery_partition_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_partition_clauseContext) +} + +func (s *Join_clauseContext) INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINNER, 0) +} + +func (s *Join_clauseContext) Outer_join_type() IOuter_join_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_typeContext) +} + +func (s *Join_clauseContext) AllJoin_on_part() []IJoin_on_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_on_partContext); ok { + len++ + } + } + + tst := make([]IJoin_on_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_on_partContext); ok { + tst[i] = t.(IJoin_on_partContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Join_on_part(i int) IJoin_on_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_on_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_on_partContext) +} + +func (s *Join_clauseContext) AllJoin_using_part() []IJoin_using_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_using_partContext); ok { + len++ + } + } + + tst := make([]IJoin_using_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_using_partContext); ok { + tst[i] = t.(IJoin_using_partContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Join_using_part(i int) IJoin_using_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_using_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_using_partContext) +} + +func (s *Join_clauseContext) CROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSS, 0) +} + +func (s *Join_clauseContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 0) +} + +func (s *Join_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Join_clauseContext) OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER, 0) +} + +func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_clause(s) + } +} + +func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_clause(s) + } +} + +func (p *PlSqlParser) Join_clause() (localctx IJoin_clauseContext) { + localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1918, PlSqlParserRULE_join_clause) + var _la int + + var _alt int + + p.SetState(17299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2379, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(17275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(17274) + p.Query_partition_clause() + } + + } + p.SetState(17278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCROSS || _la == PlSqlParserNATURAL { + { + p.SetState(17277) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCROSS || _la == PlSqlParserNATURAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(17282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINNER: + { + p.SetState(17280) + p.Match(PlSqlParserINNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFULL, PlSqlParserLEFT, PlSqlParserRIGHT: + { + p.SetState(17281) + p.Outer_join_type() + } + + case PlSqlParserJOIN: + + default: + } + { + p.SetState(17284) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17285) + p.Table_ref_aux() + } + p.SetState(17287) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2376, p.GetParserRuleContext()) == 1 { + { + p.SetState(17286) + p.Query_partition_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2378, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(17291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(17289) + p.Join_on_part() + } + + case PlSqlParserUSING: + { + p.SetState(17290) + p.Join_using_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(17295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2378, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17296) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCROSS || _la == PlSqlParserOUTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17297) + p.Match(PlSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17298) + p.Table_ref_aux() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_on_partContext is an interface to support dynamic dispatch. +type IJoin_on_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Condition() IConditionContext + + // IsJoin_on_partContext differentiates from other interfaces. + IsJoin_on_partContext() +} + +type Join_on_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_on_partContext() *Join_on_partContext { + var p = new(Join_on_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_on_part + return p +} + +func InitEmptyJoin_on_partContext(p *Join_on_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_on_part +} + +func (*Join_on_partContext) IsJoin_on_partContext() {} + +func NewJoin_on_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_on_partContext { + var p = new(Join_on_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_on_part + + return p +} + +func (s *Join_on_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_on_partContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Join_on_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Join_on_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_on_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_on_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_on_part(s) + } +} + +func (s *Join_on_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_on_part(s) + } +} + +func (p *PlSqlParser) Join_on_part() (localctx IJoin_on_partContext) { + localctx = NewJoin_on_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1920, PlSqlParserRULE_join_on_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17301) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17302) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_using_partContext is an interface to support dynamic dispatch. +type IJoin_using_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + + // IsJoin_using_partContext differentiates from other interfaces. + IsJoin_using_partContext() +} + +type Join_using_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_using_partContext() *Join_using_partContext { + var p = new(Join_using_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_using_part + return p +} + +func InitEmptyJoin_using_partContext(p *Join_using_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_using_part +} + +func (*Join_using_partContext) IsJoin_using_partContext() {} + +func NewJoin_using_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_using_partContext { + var p = new(Join_using_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_using_part + + return p +} + +func (s *Join_using_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_using_partContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Join_using_partContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Join_using_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_using_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_using_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_using_part(s) + } +} + +func (s *Join_using_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_using_part(s) + } +} + +func (p *PlSqlParser) Join_using_part() (localctx IJoin_using_partContext) { + localctx = NewJoin_using_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1922, PlSqlParserRULE_join_using_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17304) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17305) + p.Paren_column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOuter_join_typeContext is an interface to support dynamic dispatch. +type IOuter_join_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL() antlr.TerminalNode + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsOuter_join_typeContext differentiates from other interfaces. + IsOuter_join_typeContext() +} + +type Outer_join_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOuter_join_typeContext() *Outer_join_typeContext { + var p = new(Outer_join_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_type + return p +} + +func InitEmptyOuter_join_typeContext(p *Outer_join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_type +} + +func (*Outer_join_typeContext) IsOuter_join_typeContext() {} + +func NewOuter_join_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outer_join_typeContext { + var p = new(Outer_join_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outer_join_type + + return p +} + +func (s *Outer_join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outer_join_typeContext) FULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL, 0) +} + +func (s *Outer_join_typeContext) LEFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT, 0) +} + +func (s *Outer_join_typeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT, 0) +} + +func (s *Outer_join_typeContext) OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER, 0) +} + +func (s *Outer_join_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outer_join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outer_join_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOuter_join_type(s) + } +} + +func (s *Outer_join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOuter_join_type(s) + } +} + +func (p *PlSqlParser) Outer_join_type() (localctx IOuter_join_typeContext) { + localctx = NewOuter_join_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1924, PlSqlParserRULE_outer_join_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17307) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFULL || _la == PlSqlParserLEFT || _la == PlSqlParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOUTER { + { + p.SetState(17308) + p.Match(PlSqlParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_partition_clauseContext is an interface to support dynamic dispatch. +type IQuery_partition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expressions_() IExpressions_Context + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsQuery_partition_clauseContext differentiates from other interfaces. + IsQuery_partition_clauseContext() +} + +type Query_partition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_partition_clauseContext() *Query_partition_clauseContext { + var p = new(Query_partition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_partition_clause + return p +} + +func InitEmptyQuery_partition_clauseContext(p *Query_partition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_partition_clause +} + +func (*Query_partition_clauseContext) IsQuery_partition_clauseContext() {} + +func NewQuery_partition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_partition_clauseContext { + var p = new(Query_partition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_partition_clause + + return p +} + +func (s *Query_partition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_partition_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Query_partition_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Query_partition_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Query_partition_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Query_partition_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Query_partition_clauseContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Query_partition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_partition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_partition_clause(s) + } +} + +func (s *Query_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_partition_clause(s) + } +} + +func (p *PlSqlParser) Query_partition_clause() (localctx IQuery_partition_clauseContext) { + localctx = NewQuery_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1926, PlSqlParserRULE_query_partition_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17311) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17312) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2382, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17313) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17316) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2381, p.GetParserRuleContext()) == 1 { + { + p.SetState(17314) + p.Subquery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2381, p.GetParserRuleContext()) == 2 { + { + p.SetState(17315) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17318) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17319) + p.Expressions_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_query_clauseContext is an interface to support dynamic dispatch. +type IFlashback_query_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSIONS() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AND() antlr.TerminalNode + PERIOD_KEYWORD() antlr.TerminalNode + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + BETWEEN() antlr.TerminalNode + SCN() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + AS() antlr.TerminalNode + OF() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + + // IsFlashback_query_clauseContext differentiates from other interfaces. + IsFlashback_query_clauseContext() +} + +type Flashback_query_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_query_clauseContext() *Flashback_query_clauseContext { + var p = new(Flashback_query_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_query_clause + return p +} + +func InitEmptyFlashback_query_clauseContext(p *Flashback_query_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_query_clause +} + +func (*Flashback_query_clauseContext) IsFlashback_query_clauseContext() {} + +func NewFlashback_query_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_query_clauseContext { + var p = new(Flashback_query_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_query_clause + + return p +} + +func (s *Flashback_query_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_query_clauseContext) VERSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS, 0) +} + +func (s *Flashback_query_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Flashback_query_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Flashback_query_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Flashback_query_clauseContext) PERIOD_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD_KEYWORD, 0) +} + +func (s *Flashback_query_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Flashback_query_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Flashback_query_clauseContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Flashback_query_clauseContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Flashback_query_clauseContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Flashback_query_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Flashback_query_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Flashback_query_clauseContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Flashback_query_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_query_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_query_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_query_clause(s) + } +} + +func (s *Flashback_query_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_query_clause(s) + } +} + +func (p *PlSqlParser) Flashback_query_clause() (localctx IFlashback_query_clauseContext) { + localctx = NewFlashback_query_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1928, PlSqlParserRULE_flashback_query_clause) + var _la int + + p.SetState(17347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVERSIONS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17322) + p.Match(PlSqlParserVERSIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPERIOD_KEYWORD: + { + p.SetState(17323) + p.Match(PlSqlParserPERIOD_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17324) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17325) + p.Column_name() + } + { + p.SetState(17326) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBETWEEN: + { + p.SetState(17328) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17329) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(17332) + p.Expression() + } + { + p.SetState(17333) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17334) + p.Expression() + } + + case PlSqlParserAS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17336) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17337) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCN, PlSqlParserSNAPSHOT, PlSqlParserTIMESTAMP: + { + p.SetState(17338) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserSNAPSHOT || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17339) + p.Expression() + } + + case PlSqlParserPERIOD_KEYWORD: + { + p.SetState(17340) + p.Match(PlSqlParserPERIOD_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17341) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17342) + p.Column_name() + } + { + p.SetState(17343) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_clauseContext is an interface to support dynamic dispatch. +type IPivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIVOT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPivot_element() []IPivot_elementContext + Pivot_element(i int) IPivot_elementContext + Pivot_for_clause() IPivot_for_clauseContext + Pivot_in_clause() IPivot_in_clauseContext + RIGHT_PAREN() antlr.TerminalNode + XML() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Table_alias() ITable_aliasContext + + // IsPivot_clauseContext differentiates from other interfaces. + IsPivot_clauseContext() +} + +type Pivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_clauseContext() *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_clause + return p +} + +func InitEmptyPivot_clauseContext(p *Pivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_clause +} + +func (*Pivot_clauseContext) IsPivot_clauseContext() {} + +func NewPivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_clause + + return p +} + +func (s *Pivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_clauseContext) PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIVOT, 0) +} + +func (s *Pivot_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_clauseContext) AllPivot_element() []IPivot_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_elementContext); ok { + len++ + } + } + + tst := make([]IPivot_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_elementContext); ok { + tst[i] = t.(IPivot_elementContext) + i++ + } + } + + return tst +} + +func (s *Pivot_clauseContext) Pivot_element(i int) IPivot_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_elementContext) +} + +func (s *Pivot_clauseContext) Pivot_for_clause() IPivot_for_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_for_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_for_clauseContext) +} + +func (s *Pivot_clauseContext) Pivot_in_clause() IPivot_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clauseContext) +} + +func (s *Pivot_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_clauseContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Pivot_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pivot_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pivot_clauseContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Pivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_clause(s) + } +} + +func (p *PlSqlParser) Pivot_clause() (localctx IPivot_clauseContext) { + localctx = NewPivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1930, PlSqlParserRULE_pivot_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17349) + p.Match(PlSqlParserPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXML { + { + p.SetState(17350) + p.Match(PlSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17353) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17354) + p.Pivot_element() + } + p.SetState(17359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17355) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17356) + p.Pivot_element() + } + + p.SetState(17361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17362) + p.Pivot_for_clause() + } + { + p.SetState(17363) + p.Pivot_in_clause() + } + { + p.SetState(17364) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17366) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2388, p.GetParserRuleContext()) == 1 { + { + p.SetState(17365) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_elementContext is an interface to support dynamic dispatch. +type IPivot_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric_function() INumeric_functionContext + Aggregate_function_name() IAggregate_function_nameContext + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Column_alias() IColumn_aliasContext + + // IsPivot_elementContext differentiates from other interfaces. + IsPivot_elementContext() +} + +type Pivot_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_elementContext() *Pivot_elementContext { + var p = new(Pivot_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_element + return p +} + +func InitEmptyPivot_elementContext(p *Pivot_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_element +} + +func (*Pivot_elementContext) IsPivot_elementContext() {} + +func NewPivot_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_elementContext { + var p = new(Pivot_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_element + + return p +} + +func (s *Pivot_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_elementContext) Numeric_function() INumeric_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_functionContext) +} + +func (s *Pivot_elementContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Pivot_elementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_elementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Pivot_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_element(s) + } +} + +func (s *Pivot_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_element(s) + } +} + +func (p *PlSqlParser) Pivot_element() (localctx IPivot_elementContext) { + localctx = NewPivot_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1932, PlSqlParserRULE_pivot_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2389, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17368) + p.Numeric_function() + } + + case 2: + { + p.SetState(17369) + p.Aggregate_function_name() + } + { + p.SetState(17370) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17371) + p.Expression() + } + { + p.SetState(17372) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(17376) + p.Column_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_for_clauseContext is an interface to support dynamic dispatch. +type IPivot_for_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + + // IsPivot_for_clauseContext differentiates from other interfaces. + IsPivot_for_clauseContext() +} + +type Pivot_for_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_for_clauseContext() *Pivot_for_clauseContext { + var p = new(Pivot_for_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_for_clause + return p +} + +func InitEmptyPivot_for_clauseContext(p *Pivot_for_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_for_clause +} + +func (*Pivot_for_clauseContext) IsPivot_for_clauseContext() {} + +func NewPivot_for_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_for_clauseContext { + var p = new(Pivot_for_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_for_clause + + return p +} + +func (s *Pivot_for_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_for_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Pivot_for_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Pivot_for_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Pivot_for_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_for_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_for_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_for_clause(s) + } +} + +func (s *Pivot_for_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_for_clause(s) + } +} + +func (p *PlSqlParser) Pivot_for_clause() (localctx IPivot_for_clauseContext) { + localctx = NewPivot_for_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1934, PlSqlParserRULE_pivot_for_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17379) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(17380) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(17381) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_in_clauseContext is an interface to support dynamic dispatch. +type IPivot_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + AllPivot_in_clause_element() []IPivot_in_clause_elementContext + Pivot_in_clause_element(i int) IPivot_in_clause_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPivot_in_clauseContext differentiates from other interfaces. + IsPivot_in_clauseContext() +} + +type Pivot_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clauseContext() *Pivot_in_clauseContext { + var p = new(Pivot_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause + return p +} + +func InitEmptyPivot_in_clauseContext(p *Pivot_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause +} + +func (*Pivot_in_clauseContext) IsPivot_in_clauseContext() {} + +func NewPivot_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clauseContext { + var p = new(Pivot_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause + + return p +} + +func (s *Pivot_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Pivot_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_in_clauseContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Pivot_in_clauseContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserANY) +} + +func (s *Pivot_in_clauseContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, i) +} + +func (s *Pivot_in_clauseContext) AllPivot_in_clause_element() []IPivot_in_clause_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_in_clause_elementContext); ok { + len++ + } + } + + tst := make([]IPivot_in_clause_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_in_clause_elementContext); ok { + tst[i] = t.(IPivot_in_clause_elementContext) + i++ + } + } + + return tst +} + +func (s *Pivot_in_clauseContext) Pivot_in_clause_element(i int) IPivot_in_clause_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clause_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clause_elementContext) +} + +func (s *Pivot_in_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pivot_in_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pivot_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause(s) + } +} + +func (s *Pivot_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause() (localctx IPivot_in_clauseContext) { + localctx = NewPivot_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1936, PlSqlParserRULE_pivot_in_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17384) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17385) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2394, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17386) + p.Subquery() + } + + case 2: + { + p.SetState(17387) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17388) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17389) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(17394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(17395) + p.Pivot_in_clause_element() + } + p.SetState(17400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17396) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17397) + p.Pivot_in_clause_element() + } + + p.SetState(17402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(17405) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_in_clause_elementContext is an interface to support dynamic dispatch. +type IPivot_in_clause_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pivot_in_clause_elements() IPivot_in_clause_elementsContext + Column_alias() IColumn_aliasContext + + // IsPivot_in_clause_elementContext differentiates from other interfaces. + IsPivot_in_clause_elementContext() +} + +type Pivot_in_clause_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clause_elementContext() *Pivot_in_clause_elementContext { + var p = new(Pivot_in_clause_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element + return p +} + +func InitEmptyPivot_in_clause_elementContext(p *Pivot_in_clause_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element +} + +func (*Pivot_in_clause_elementContext) IsPivot_in_clause_elementContext() {} + +func NewPivot_in_clause_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clause_elementContext { + var p = new(Pivot_in_clause_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element + + return p +} + +func (s *Pivot_in_clause_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clause_elementContext) Pivot_in_clause_elements() IPivot_in_clause_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clause_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clause_elementsContext) +} + +func (s *Pivot_in_clause_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Pivot_in_clause_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clause_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clause_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause_element(s) + } +} + +func (s *Pivot_in_clause_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause_element(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause_element() (localctx IPivot_in_clause_elementContext) { + localctx = NewPivot_in_clause_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1938, PlSqlParserRULE_pivot_in_clause_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17407) + p.Pivot_in_clause_elements() + } + p.SetState(17409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(17408) + p.Column_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_in_clause_elementsContext is an interface to support dynamic dispatch. +type IPivot_in_clause_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + + // IsPivot_in_clause_elementsContext differentiates from other interfaces. + IsPivot_in_clause_elementsContext() +} + +type Pivot_in_clause_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clause_elementsContext() *Pivot_in_clause_elementsContext { + var p = new(Pivot_in_clause_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements + return p +} + +func InitEmptyPivot_in_clause_elementsContext(p *Pivot_in_clause_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements +} + +func (*Pivot_in_clause_elementsContext) IsPivot_in_clause_elementsContext() {} + +func NewPivot_in_clause_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clause_elementsContext { + var p = new(Pivot_in_clause_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements + + return p +} + +func (s *Pivot_in_clause_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clause_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_in_clause_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_in_clause_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_in_clause_elementsContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Pivot_in_clause_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clause_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clause_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause_elements(s) + } +} + +func (s *Pivot_in_clause_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause_elements(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause_elements() (localctx IPivot_in_clause_elementsContext) { + localctx = NewPivot_in_clause_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1940, PlSqlParserRULE_pivot_in_clause_elements) + p.SetState(17417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2397, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17411) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17412) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17414) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2396, p.GetParserRuleContext()) == 1 { + { + p.SetState(17413) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17416) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNPIVOT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Pivot_for_clause() IPivot_for_clauseContext + Unpivot_in_clause() IUnpivot_in_clauseContext + RIGHT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + NULLS() antlr.TerminalNode + Table_alias() ITable_aliasContext + INCLUDE() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + + // IsUnpivot_clauseContext differentiates from other interfaces. + IsUnpivot_clauseContext() +} + +type Unpivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_clauseContext() *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_clause + return p +} + +func InitEmptyUnpivot_clauseContext(p *Unpivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_clause +} + +func (*Unpivot_clauseContext) IsUnpivot_clauseContext() {} + +func NewUnpivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_clause + + return p +} + +func (s *Unpivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_clauseContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPIVOT, 0) +} + +func (s *Unpivot_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_clauseContext) Pivot_for_clause() IPivot_for_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_for_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_for_clauseContext) +} + +func (s *Unpivot_clauseContext) Unpivot_in_clause() IUnpivot_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_clauseContext) +} + +func (s *Unpivot_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Unpivot_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Unpivot_clauseContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Unpivot_clauseContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Unpivot_clauseContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE, 0) +} + +func (s *Unpivot_clauseContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDE, 0) +} + +func (s *Unpivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_clause(s) + } +} + +func (p *PlSqlParser) Unpivot_clause() (localctx IUnpivot_clauseContext) { + localctx = NewUnpivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1942, PlSqlParserRULE_unpivot_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17419) + p.Match(PlSqlParserUNPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDE || _la == PlSqlParserINCLUDE { + { + p.SetState(17420) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDE || _la == PlSqlParserINCLUDE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17421) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17424) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(17425) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(17426) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(17429) + p.Pivot_for_clause() + } + { + p.SetState(17430) + p.Unpivot_in_clause() + } + { + p.SetState(17431) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17433) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2400, p.GetParserRuleContext()) == 1 { + { + p.SetState(17432) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllUnpivot_in_elements() []IUnpivot_in_elementsContext + Unpivot_in_elements(i int) IUnpivot_in_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnpivot_in_clauseContext differentiates from other interfaces. + IsUnpivot_in_clauseContext() +} + +type Unpivot_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_clauseContext() *Unpivot_in_clauseContext { + var p = new(Unpivot_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause + return p +} + +func InitEmptyUnpivot_in_clauseContext(p *Unpivot_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause +} + +func (*Unpivot_in_clauseContext) IsUnpivot_in_clauseContext() {} + +func NewUnpivot_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_clauseContext { + var p = new(Unpivot_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause + + return p +} + +func (s *Unpivot_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Unpivot_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_in_clauseContext) AllUnpivot_in_elements() []IUnpivot_in_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnpivot_in_elementsContext); ok { + len++ + } + } + + tst := make([]IUnpivot_in_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnpivot_in_elementsContext); ok { + tst[i] = t.(IUnpivot_in_elementsContext) + i++ + } + } + + return tst +} + +func (s *Unpivot_in_clauseContext) Unpivot_in_elements(i int) IUnpivot_in_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_elementsContext) +} + +func (s *Unpivot_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_in_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unpivot_in_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unpivot_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_in_clause(s) + } +} + +func (s *Unpivot_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_in_clause(s) + } +} + +func (p *PlSqlParser) Unpivot_in_clause() (localctx IUnpivot_in_clauseContext) { + localctx = NewUnpivot_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1944, PlSqlParserRULE_unpivot_in_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17435) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17436) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17437) + p.Unpivot_in_elements() + } + p.SetState(17442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17438) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17439) + p.Unpivot_in_elements() + } + + p.SetState(17444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17445) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_elementsContext is an interface to support dynamic dispatch. +type IUnpivot_in_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + AS() antlr.TerminalNode + AllConstant() []IConstantContext + Constant(i int) IConstantContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnpivot_in_elementsContext differentiates from other interfaces. + IsUnpivot_in_elementsContext() +} + +type Unpivot_in_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_elementsContext() *Unpivot_in_elementsContext { + var p = new(Unpivot_in_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements + return p +} + +func InitEmptyUnpivot_in_elementsContext(p *Unpivot_in_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements +} + +func (*Unpivot_in_elementsContext) IsUnpivot_in_elementsContext() {} + +func NewUnpivot_in_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_elementsContext { + var p = new(Unpivot_in_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements + + return p +} + +func (s *Unpivot_in_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_elementsContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Unpivot_in_elementsContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Unpivot_in_elementsContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Unpivot_in_elementsContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *Unpivot_in_elementsContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Unpivot_in_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_in_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_in_elementsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unpivot_in_elementsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unpivot_in_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_in_elements(s) + } +} + +func (s *Unpivot_in_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_in_elements(s) + } +} + +func (p *PlSqlParser) Unpivot_in_elements() (localctx IUnpivot_in_elementsContext) { + localctx = NewUnpivot_in_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1946, PlSqlParserRULE_unpivot_in_elements) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(17447) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(17448) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(17466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(17451) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATE, PlSqlParserDBTIMEZONE, PlSqlParserDEFAULT, PlSqlParserFALSE, PlSqlParserINTERVAL, PlSqlParserMAXVALUE, PlSqlParserMINVALUE, PlSqlParserNULL_, PlSqlParserSESSIONTIMEZONE, PlSqlParserTIMESTAMP, PlSqlParserTRUE, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(17452) + p.Constant() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(17453) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17454) + p.Constant() + } + p.SetState(17459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17455) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17456) + p.Constant() + } + + p.SetState(17461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17462) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchical_query_clauseContext is an interface to support dynamic dispatch. +type IHierarchical_query_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONNECT() antlr.TerminalNode + BY() antlr.TerminalNode + Condition() IConditionContext + NOCYCLE() antlr.TerminalNode + Start_part() IStart_partContext + + // IsHierarchical_query_clauseContext differentiates from other interfaces. + IsHierarchical_query_clauseContext() +} + +type Hierarchical_query_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHierarchical_query_clauseContext() *Hierarchical_query_clauseContext { + var p = new(Hierarchical_query_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause + return p +} + +func InitEmptyHierarchical_query_clauseContext(p *Hierarchical_query_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause +} + +func (*Hierarchical_query_clauseContext) IsHierarchical_query_clauseContext() {} + +func NewHierarchical_query_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchical_query_clauseContext { + var p = new(Hierarchical_query_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause + + return p +} + +func (s *Hierarchical_query_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchical_query_clauseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Hierarchical_query_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Hierarchical_query_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Hierarchical_query_clauseContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Hierarchical_query_clauseContext) Start_part() IStart_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_partContext) +} + +func (s *Hierarchical_query_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchical_query_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchical_query_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHierarchical_query_clause(s) + } +} + +func (s *Hierarchical_query_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHierarchical_query_clause(s) + } +} + +func (p *PlSqlParser) Hierarchical_query_clause() (localctx IHierarchical_query_clauseContext) { + localctx = NewHierarchical_query_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1948, PlSqlParserRULE_hierarchical_query_clause) + p.SetState(17485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17468) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17469) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17471) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2406, p.GetParserRuleContext()) == 1 { + { + p.SetState(17470) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17473) + p.Condition() + } + p.SetState(17475) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2407, p.GetParserRuleContext()) == 1 { + { + p.SetState(17474) + p.Start_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSTART: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17477) + p.Start_part() + } + { + p.SetState(17478) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17479) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2408, p.GetParserRuleContext()) == 1 { + { + p.SetState(17480) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17483) + p.Condition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_partContext is an interface to support dynamic dispatch. +type IStart_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + Condition() IConditionContext + + // IsStart_partContext differentiates from other interfaces. + IsStart_partContext() +} + +type Start_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_partContext() *Start_partContext { + var p = new(Start_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_part + return p +} + +func InitEmptyStart_partContext(p *Start_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_part +} + +func (*Start_partContext) IsStart_partContext() {} + +func NewStart_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_partContext { + var p = new(Start_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_part + + return p +} + +func (s *Start_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_partContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Start_partContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Start_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Start_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_part(s) + } +} + +func (s *Start_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_part(s) + } +} + +func (p *PlSqlParser) Start_part() (localctx IStart_partContext) { + localctx = NewStart_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1950, PlSqlParserRULE_start_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17487) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17488) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17489) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_clauseContext is an interface to support dynamic dispatch. +type IGroup_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + AllGroup_by_elements() []IGroup_by_elementsContext + Group_by_elements(i int) IGroup_by_elementsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Having_clause() IHaving_clauseContext + + // IsGroup_by_clauseContext differentiates from other interfaces. + IsGroup_by_clauseContext() +} + +type Group_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_clauseContext() *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_clause + return p +} + +func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_clause +} + +func (*Group_by_clauseContext) IsGroup_by_clauseContext() {} + +func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_group_by_clause + + return p +} + +func (s *Group_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Group_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Group_by_clauseContext) AllGroup_by_elements() []IGroup_by_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_elementsContext); ok { + len++ + } + } + + tst := make([]IGroup_by_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_elementsContext); ok { + tst[i] = t.(IGroup_by_elementsContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clauseContext) Group_by_elements(i int) IGroup_by_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_elementsContext) +} + +func (s *Group_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Group_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Group_by_clauseContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Group_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_by_clause(s) + } +} + +func (p *PlSqlParser) Group_by_clause() (localctx IGroup_by_clauseContext) { + localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1952, PlSqlParserRULE_group_by_clause) + var _alt int + + p.SetState(17517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17491) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17492) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17493) + p.Group_by_elements() + } + p.SetState(17498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2410, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17494) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17495) + p.Group_by_elements() + } + + } + p.SetState(17500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2410, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(17502) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2411, p.GetParserRuleContext()) == 1 { + { + p.SetState(17501) + p.Having_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserHAVING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17504) + p.Having_clause() + } + p.SetState(17515) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2413, p.GetParserRuleContext()) == 1 { + { + p.SetState(17505) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17506) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17507) + p.Group_by_elements() + } + p.SetState(17512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2412, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17508) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17509) + p.Group_by_elements() + } + + } + p.SetState(17514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2412, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_elementsContext is an interface to support dynamic dispatch. +type IGroup_by_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grouping_sets_clause() IGrouping_sets_clauseContext + Rollup_cube_clause() IRollup_cube_clauseContext + Expression() IExpressionContext + + // IsGroup_by_elementsContext differentiates from other interfaces. + IsGroup_by_elementsContext() +} + +type Group_by_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_elementsContext() *Group_by_elementsContext { + var p = new(Group_by_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_elements + return p +} + +func InitEmptyGroup_by_elementsContext(p *Group_by_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_elements +} + +func (*Group_by_elementsContext) IsGroup_by_elementsContext() {} + +func NewGroup_by_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_elementsContext { + var p = new(Group_by_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_group_by_elements + + return p +} + +func (s *Group_by_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_elementsContext) Grouping_sets_clause() IGrouping_sets_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_clauseContext) +} + +func (s *Group_by_elementsContext) Rollup_cube_clause() IRollup_cube_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_cube_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_cube_clauseContext) +} + +func (s *Group_by_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Group_by_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGroup_by_elements(s) + } +} + +func (s *Group_by_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_by_elements(s) + } +} + +func (p *PlSqlParser) Group_by_elements() (localctx IGroup_by_elementsContext) { + localctx = NewGroup_by_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1954, PlSqlParserRULE_group_by_elements) + p.SetState(17522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2415, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17519) + p.Grouping_sets_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17520) + p.Rollup_cube_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17521) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollup_cube_clauseContext is an interface to support dynamic dispatch. +type IRollup_cube_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllGrouping_sets_elements() []IGrouping_sets_elementsContext + Grouping_sets_elements(i int) IGrouping_sets_elementsContext + RIGHT_PAREN() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + CUBE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRollup_cube_clauseContext differentiates from other interfaces. + IsRollup_cube_clauseContext() +} + +type Rollup_cube_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollup_cube_clauseContext() *Rollup_cube_clauseContext { + var p = new(Rollup_cube_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause + return p +} + +func InitEmptyRollup_cube_clauseContext(p *Rollup_cube_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause +} + +func (*Rollup_cube_clauseContext) IsRollup_cube_clauseContext() {} + +func NewRollup_cube_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_cube_clauseContext { + var p = new(Rollup_cube_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause + + return p +} + +func (s *Rollup_cube_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollup_cube_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Rollup_cube_clauseContext) AllGrouping_sets_elements() []IGrouping_sets_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + len++ + } + } + + tst := make([]IGrouping_sets_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_sets_elementsContext); ok { + tst[i] = t.(IGrouping_sets_elementsContext) + i++ + } + } + + return tst +} + +func (s *Rollup_cube_clauseContext) Grouping_sets_elements(i int) IGrouping_sets_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_elementsContext) +} + +func (s *Rollup_cube_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Rollup_cube_clauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLUP, 0) +} + +func (s *Rollup_cube_clauseContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *Rollup_cube_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Rollup_cube_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Rollup_cube_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollup_cube_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollup_cube_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollup_cube_clause(s) + } +} + +func (s *Rollup_cube_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollup_cube_clause(s) + } +} + +func (p *PlSqlParser) Rollup_cube_clause() (localctx IRollup_cube_clauseContext) { + localctx = NewRollup_cube_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1956, PlSqlParserRULE_rollup_cube_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17524) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCUBE || _la == PlSqlParserROLLUP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17525) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17526) + p.Grouping_sets_elements() + } + p.SetState(17531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17527) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17528) + p.Grouping_sets_elements() + } + + p.SetState(17533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17534) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_clauseContext is an interface to support dynamic dispatch. +type IGrouping_sets_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllGrouping_sets_elements() []IGrouping_sets_elementsContext + Grouping_sets_elements(i int) IGrouping_sets_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrouping_sets_clauseContext differentiates from other interfaces. + IsGrouping_sets_clauseContext() +} + +type Grouping_sets_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_sets_clauseContext() *Grouping_sets_clauseContext { + var p = new(Grouping_sets_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause + return p +} + +func InitEmptyGrouping_sets_clauseContext(p *Grouping_sets_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause +} + +func (*Grouping_sets_clauseContext) IsGrouping_sets_clauseContext() {} + +func NewGrouping_sets_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_clauseContext { + var p = new(Grouping_sets_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause + + return p +} + +func (s *Grouping_sets_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_sets_clauseContext) GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING, 0) +} + +func (s *Grouping_sets_clauseContext) SETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETS, 0) +} + +func (s *Grouping_sets_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) AllGrouping_sets_elements() []IGrouping_sets_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + len++ + } + } + + tst := make([]IGrouping_sets_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_sets_elementsContext); ok { + tst[i] = t.(IGrouping_sets_elementsContext) + i++ + } + } + + return tst +} + +func (s *Grouping_sets_clauseContext) Grouping_sets_elements(i int) IGrouping_sets_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_elementsContext) +} + +func (s *Grouping_sets_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grouping_sets_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grouping_sets_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrouping_sets_clause(s) + } +} + +func (s *Grouping_sets_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrouping_sets_clause(s) + } +} + +func (p *PlSqlParser) Grouping_sets_clause() (localctx IGrouping_sets_clauseContext) { + localctx = NewGrouping_sets_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1958, PlSqlParserRULE_grouping_sets_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17536) + p.Match(PlSqlParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17537) + p.Match(PlSqlParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17538) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17539) + p.Grouping_sets_elements() + } + p.SetState(17544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17540) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17541) + p.Grouping_sets_elements() + } + + p.SetState(17546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17547) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_elementsContext is an interface to support dynamic dispatch. +type IGrouping_sets_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rollup_cube_clause() IRollup_cube_clauseContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + Expression() IExpressionContext + + // IsGrouping_sets_elementsContext differentiates from other interfaces. + IsGrouping_sets_elementsContext() +} + +type Grouping_sets_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_sets_elementsContext() *Grouping_sets_elementsContext { + var p = new(Grouping_sets_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements + return p +} + +func InitEmptyGrouping_sets_elementsContext(p *Grouping_sets_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements +} + +func (*Grouping_sets_elementsContext) IsGrouping_sets_elementsContext() {} + +func NewGrouping_sets_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_elementsContext { + var p = new(Grouping_sets_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements + + return p +} + +func (s *Grouping_sets_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_sets_elementsContext) Rollup_cube_clause() IRollup_cube_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_cube_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_cube_clauseContext) +} + +func (s *Grouping_sets_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Grouping_sets_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Grouping_sets_elementsContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Grouping_sets_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Grouping_sets_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrouping_sets_elements(s) + } +} + +func (s *Grouping_sets_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrouping_sets_elements(s) + } +} + +func (p *PlSqlParser) Grouping_sets_elements() (localctx IGrouping_sets_elementsContext) { + localctx = NewGrouping_sets_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1960, PlSqlParserRULE_grouping_sets_elements) + p.SetState(17556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2419, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17549) + p.Rollup_cube_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17550) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17552) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2418, p.GetParserRuleContext()) == 1 { + { + p.SetState(17551) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17554) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17555) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHaving_clauseContext is an interface to support dynamic dispatch. +type IHaving_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING() antlr.TerminalNode + Condition() IConditionContext + + // IsHaving_clauseContext differentiates from other interfaces. + IsHaving_clauseContext() +} + +type Having_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHaving_clauseContext() *Having_clauseContext { + var p = new(Having_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_having_clause +} + +func (*Having_clauseContext) IsHaving_clauseContext() {} + +func NewHaving_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_clauseContext { + var p = new(Having_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHAVING, 0) +} + +func (s *Having_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (p *PlSqlParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1962, PlSqlParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17558) + p.Match(PlSqlParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17559) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_clauseContext is an interface to support dynamic dispatch. +type IModel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODEL() antlr.TerminalNode + Main_model() IMain_modelContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + Return_rows_clause() IReturn_rows_clauseContext + AllReference_model() []IReference_modelContext + Reference_model(i int) IReference_modelContext + + // IsModel_clauseContext differentiates from other interfaces. + IsModel_clauseContext() +} + +type Model_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_clauseContext() *Model_clauseContext { + var p = new(Model_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_clause + return p +} + +func InitEmptyModel_clauseContext(p *Model_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_clause +} + +func (*Model_clauseContext) IsModel_clauseContext() {} + +func NewModel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_clauseContext { + var p = new(Model_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_clause + + return p +} + +func (s *Model_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Model_clauseContext) Main_model() IMain_modelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMain_modelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMain_modelContext) +} + +func (s *Model_clauseContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Model_clauseContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Model_clauseContext) Return_rows_clause() IReturn_rows_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_rows_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_rows_clauseContext) +} + +func (s *Model_clauseContext) AllReference_model() []IReference_modelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_modelContext); ok { + len++ + } + } + + tst := make([]IReference_modelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_modelContext); ok { + tst[i] = t.(IReference_modelContext) + i++ + } + } + + return tst +} + +func (s *Model_clauseContext) Reference_model(i int) IReference_modelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_modelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_modelContext) +} + +func (s *Model_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_clause(s) + } +} + +func (s *Model_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_clause(s) + } +} + +func (p *PlSqlParser) Model_clause() (localctx IModel_clauseContext) { + localctx = NewModel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1964, PlSqlParserRULE_model_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17561) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(17562) + p.Cell_reference_options() + } + + p.SetState(17567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(17568) + p.Return_rows_clause() + } + + } + p.SetState(17574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserREFERENCE { + { + p.SetState(17571) + p.Reference_model() + } + + p.SetState(17576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17577) + p.Main_model() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICell_reference_optionsContext is an interface to support dynamic dispatch. +type ICell_reference_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NAV() antlr.TerminalNode + IGNORE() antlr.TerminalNode + KEEP() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + SINGLE() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + + // IsCell_reference_optionsContext differentiates from other interfaces. + IsCell_reference_optionsContext() +} + +type Cell_reference_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCell_reference_optionsContext() *Cell_reference_optionsContext { + var p = new(Cell_reference_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_reference_options + return p +} + +func InitEmptyCell_reference_optionsContext(p *Cell_reference_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_reference_options +} + +func (*Cell_reference_optionsContext) IsCell_reference_optionsContext() {} + +func NewCell_reference_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cell_reference_optionsContext { + var p = new(Cell_reference_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cell_reference_options + + return p +} + +func (s *Cell_reference_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cell_reference_optionsContext) NAV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAV, 0) +} + +func (s *Cell_reference_optionsContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Cell_reference_optionsContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Cell_reference_optionsContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Cell_reference_optionsContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Cell_reference_optionsContext) SINGLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, 0) +} + +func (s *Cell_reference_optionsContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Cell_reference_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cell_reference_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cell_reference_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCell_reference_options(s) + } +} + +func (s *Cell_reference_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCell_reference_options(s) + } +} + +func (p *PlSqlParser) Cell_reference_options() (localctx ICell_reference_optionsContext) { + localctx = NewCell_reference_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1966, PlSqlParserRULE_cell_reference_options) + var _la int + + p.SetState(17587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIGNORE, PlSqlParserKEEP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17579) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIGNORE || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17580) + p.Match(PlSqlParserNAV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17581) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDIMENSION: + { + p.SetState(17582) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSINGLE: + { + p.SetState(17583) + p.Match(PlSqlParserSINGLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17584) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturn_rows_clauseContext is an interface to support dynamic dispatch. +type IReturn_rows_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + ROWS() antlr.TerminalNode + UPDATED() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsReturn_rows_clauseContext differentiates from other interfaces. + IsReturn_rows_clauseContext() +} + +type Return_rows_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_rows_clauseContext() *Return_rows_clauseContext { + var p = new(Return_rows_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_rows_clause + return p +} + +func InitEmptyReturn_rows_clauseContext(p *Return_rows_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_rows_clause +} + +func (*Return_rows_clauseContext) IsReturn_rows_clauseContext() {} + +func NewReturn_rows_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_rows_clauseContext { + var p = new(Return_rows_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_return_rows_clause + + return p +} + +func (s *Return_rows_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_rows_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Return_rows_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Return_rows_clauseContext) UPDATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATED, 0) +} + +func (s *Return_rows_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Return_rows_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_rows_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_rows_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReturn_rows_clause(s) + } +} + +func (s *Return_rows_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReturn_rows_clause(s) + } +} + +func (p *PlSqlParser) Return_rows_clause() (localctx IReturn_rows_clauseContext) { + localctx = NewReturn_rows_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1968, PlSqlParserRULE_return_rows_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17589) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17590) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserUPDATED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17591) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_modelContext is an interface to support dynamic dispatch. +type IReference_modelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCE() antlr.TerminalNode + Reference_model_name() IReference_model_nameContext + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Model_column_clauses() IModel_column_clausesContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + + // IsReference_modelContext differentiates from other interfaces. + IsReference_modelContext() +} + +type Reference_modelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_modelContext() *Reference_modelContext { + var p = new(Reference_modelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model + return p +} + +func InitEmptyReference_modelContext(p *Reference_modelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model +} + +func (*Reference_modelContext) IsReference_modelContext() {} + +func NewReference_modelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_modelContext { + var p = new(Reference_modelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_model + + return p +} + +func (s *Reference_modelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_modelContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Reference_modelContext) Reference_model_name() IReference_model_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_model_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReference_model_nameContext) +} + +func (s *Reference_modelContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Reference_modelContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Reference_modelContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Reference_modelContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Reference_modelContext) Model_column_clauses() IModel_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_clausesContext) +} + +func (s *Reference_modelContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Reference_modelContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Reference_modelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_modelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_modelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_model(s) + } +} + +func (s *Reference_modelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_model(s) + } +} + +func (p *PlSqlParser) Reference_model() (localctx IReference_modelContext) { + localctx = NewReference_modelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1970, PlSqlParserRULE_reference_model) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17593) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17594) + p.Reference_model_name() + } + { + p.SetState(17595) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17596) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17597) + p.Subquery() + } + { + p.SetState(17598) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17599) + p.Model_column_clauses() + } + p.SetState(17603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(17600) + p.Cell_reference_options() + } + + p.SetState(17605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMain_modelContext is an interface to support dynamic dispatch. +type IMain_modelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Model_column_clauses() IModel_column_clausesContext + Model_rules_clause() IModel_rules_clauseContext + MAIN() antlr.TerminalNode + Main_model_name() IMain_model_nameContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + + // IsMain_modelContext differentiates from other interfaces. + IsMain_modelContext() +} + +type Main_modelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMain_modelContext() *Main_modelContext { + var p = new(Main_modelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model + return p +} + +func InitEmptyMain_modelContext(p *Main_modelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model +} + +func (*Main_modelContext) IsMain_modelContext() {} + +func NewMain_modelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Main_modelContext { + var p = new(Main_modelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_main_model + + return p +} + +func (s *Main_modelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Main_modelContext) Model_column_clauses() IModel_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_clausesContext) +} + +func (s *Main_modelContext) Model_rules_clause() IModel_rules_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_clauseContext) +} + +func (s *Main_modelContext) MAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAIN, 0) +} + +func (s *Main_modelContext) Main_model_name() IMain_model_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMain_model_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMain_model_nameContext) +} + +func (s *Main_modelContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Main_modelContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Main_modelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Main_modelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Main_modelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMain_model(s) + } +} + +func (s *Main_modelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMain_model(s) + } +} + +func (p *PlSqlParser) Main_model() (localctx IMain_modelContext) { + localctx = NewMain_modelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1972, PlSqlParserRULE_main_model) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMAIN { + { + p.SetState(17606) + p.Match(PlSqlParserMAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17607) + p.Main_model_name() + } + + } + { + p.SetState(17610) + p.Model_column_clauses() + } + p.SetState(17614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(17611) + p.Cell_reference_options() + } + + p.SetState(17616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17617) + p.Model_rules_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_column_clausesContext is an interface to support dynamic dispatch. +type IModel_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIMENSION() antlr.TerminalNode + BY() antlr.TerminalNode + AllModel_column_list() []IModel_column_listContext + Model_column_list(i int) IModel_column_listContext + MEASURES() antlr.TerminalNode + Model_column_partition_part() IModel_column_partition_partContext + + // IsModel_column_clausesContext differentiates from other interfaces. + IsModel_column_clausesContext() +} + +type Model_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_clausesContext() *Model_column_clausesContext { + var p = new(Model_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_clauses + return p +} + +func InitEmptyModel_column_clausesContext(p *Model_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_clauses +} + +func (*Model_column_clausesContext) IsModel_column_clausesContext() {} + +func NewModel_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_clausesContext { + var p = new(Model_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_clauses + + return p +} + +func (s *Model_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_clausesContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Model_column_clausesContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Model_column_clausesContext) AllModel_column_list() []IModel_column_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_column_listContext); ok { + len++ + } + } + + tst := make([]IModel_column_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_column_listContext); ok { + tst[i] = t.(IModel_column_listContext) + i++ + } + } + + return tst +} + +func (s *Model_column_clausesContext) Model_column_list(i int) IModel_column_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_listContext) +} + +func (s *Model_column_clausesContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Model_column_clausesContext) Model_column_partition_part() IModel_column_partition_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_partition_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_partition_partContext) +} + +func (s *Model_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_clauses(s) + } +} + +func (s *Model_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_clauses(s) + } +} + +func (p *PlSqlParser) Model_column_clauses() (localctx IModel_column_clausesContext) { + localctx = NewModel_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1974, PlSqlParserRULE_model_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(17619) + p.Model_column_partition_part() + } + + } + { + p.SetState(17622) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17623) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17624) + p.Model_column_list() + } + { + p.SetState(17625) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17626) + p.Model_column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_column_partition_partContext is an interface to support dynamic dispatch. +type IModel_column_partition_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Model_column_list() IModel_column_listContext + + // IsModel_column_partition_partContext differentiates from other interfaces. + IsModel_column_partition_partContext() +} + +type Model_column_partition_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_partition_partContext() *Model_column_partition_partContext { + var p = new(Model_column_partition_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_partition_part + return p +} + +func InitEmptyModel_column_partition_partContext(p *Model_column_partition_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_partition_part +} + +func (*Model_column_partition_partContext) IsModel_column_partition_partContext() {} + +func NewModel_column_partition_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_partition_partContext { + var p = new(Model_column_partition_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_partition_part + + return p +} + +func (s *Model_column_partition_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_partition_partContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Model_column_partition_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Model_column_partition_partContext) Model_column_list() IModel_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_listContext) +} + +func (s *Model_column_partition_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_partition_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_partition_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_partition_part(s) + } +} + +func (s *Model_column_partition_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_partition_part(s) + } +} + +func (p *PlSqlParser) Model_column_partition_part() (localctx IModel_column_partition_partContext) { + localctx = NewModel_column_partition_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1976, PlSqlParserRULE_model_column_partition_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17628) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17629) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17630) + p.Model_column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_column_listContext is an interface to support dynamic dispatch. +type IModel_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllModel_column() []IModel_columnContext + Model_column(i int) IModel_columnContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModel_column_listContext differentiates from other interfaces. + IsModel_column_listContext() +} + +type Model_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_listContext() *Model_column_listContext { + var p = new(Model_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_list + return p +} + +func InitEmptyModel_column_listContext(p *Model_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_list +} + +func (*Model_column_listContext) IsModel_column_listContext() {} + +func NewModel_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_listContext { + var p = new(Model_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_list + + return p +} + +func (s *Model_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_column_listContext) AllModel_column() []IModel_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_columnContext); ok { + len++ + } + } + + tst := make([]IModel_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_columnContext); ok { + tst[i] = t.(IModel_columnContext) + i++ + } + } + + return tst +} + +func (s *Model_column_listContext) Model_column(i int) IModel_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_columnContext) +} + +func (s *Model_column_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_list(s) + } +} + +func (s *Model_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_list(s) + } +} + +func (p *PlSqlParser) Model_column_list() (localctx IModel_column_listContext) { + localctx = NewModel_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1978, PlSqlParserRULE_model_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17632) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17633) + p.Model_column() + } + p.SetState(17638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17634) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17635) + p.Model_column() + } + + p.SetState(17640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17641) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_columnContext is an interface to support dynamic dispatch. +type IModel_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Query_block() IQuery_blockContext + Column_alias() IColumn_aliasContext + + // IsModel_columnContext differentiates from other interfaces. + IsModel_columnContext() +} + +type Model_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_columnContext() *Model_columnContext { + var p = new(Model_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column + return p +} + +func InitEmptyModel_columnContext(p *Model_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column +} + +func (*Model_columnContext) IsModel_columnContext() {} + +func NewModel_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_columnContext { + var p = new(Model_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column + + return p +} + +func (s *Model_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_columnContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_columnContext) Query_block() IQuery_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_blockContext) +} + +func (s *Model_columnContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Model_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column(s) + } +} + +func (s *Model_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column(s) + } +} + +func (p *PlSqlParser) Model_column() (localctx IModel_columnContext) { + localctx = NewModel_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1980, PlSqlParserRULE_model_column) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2430, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17643) + p.Expression() + } + + case 2: + { + p.SetState(17644) + p.Query_block() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(17647) + p.Column_alias() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_rules_clauseContext is an interface to support dynamic dispatch. +type IModel_rules_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Model_rules_part() IModel_rules_partContext + AllModel_rules_element() []IModel_rules_elementContext + Model_rules_element(i int) IModel_rules_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModel_rules_clauseContext differentiates from other interfaces. + IsModel_rules_clauseContext() +} + +type Model_rules_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_clauseContext() *Model_rules_clauseContext { + var p = new(Model_rules_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_clause + return p +} + +func InitEmptyModel_rules_clauseContext(p *Model_rules_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_clause +} + +func (*Model_rules_clauseContext) IsModel_rules_clauseContext() {} + +func NewModel_rules_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_clauseContext { + var p = new(Model_rules_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_clause + + return p +} + +func (s *Model_rules_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_rules_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_rules_clauseContext) Model_rules_part() IModel_rules_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_partContext) +} + +func (s *Model_rules_clauseContext) AllModel_rules_element() []IModel_rules_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_rules_elementContext); ok { + len++ + } + } + + tst := make([]IModel_rules_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_rules_elementContext); ok { + tst[i] = t.(IModel_rules_elementContext) + i++ + } + } + + return tst +} + +func (s *Model_rules_clauseContext) Model_rules_element(i int) IModel_rules_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_elementContext) +} + +func (s *Model_rules_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_rules_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_rules_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_clause(s) + } +} + +func (s *Model_rules_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_clause(s) + } +} + +func (p *PlSqlParser) Model_rules_clause() (localctx IModel_rules_clauseContext) { + localctx = NewModel_rules_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1982, PlSqlParserRULE_model_rules_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRULES { + { + p.SetState(17650) + p.Model_rules_part() + } + + } + { + p.SetState(17653) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17662) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2434, p.GetParserRuleContext()) == 1 { + { + p.SetState(17654) + p.Model_rules_element() + } + p.SetState(17659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17655) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17656) + p.Model_rules_element() + } + + p.SetState(17661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17664) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_rules_partContext is an interface to support dynamic dispatch. +type IModel_rules_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RULES() antlr.TerminalNode + UPDATE() antlr.TerminalNode + UPSERT() antlr.TerminalNode + ORDER() antlr.TerminalNode + Model_iterate_clause() IModel_iterate_clauseContext + AUTOMATIC() antlr.TerminalNode + SEQUENTIAL() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsModel_rules_partContext differentiates from other interfaces. + IsModel_rules_partContext() +} + +type Model_rules_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_partContext() *Model_rules_partContext { + var p = new(Model_rules_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_part + return p +} + +func InitEmptyModel_rules_partContext(p *Model_rules_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_part +} + +func (*Model_rules_partContext) IsModel_rules_partContext() {} + +func NewModel_rules_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_partContext { + var p = new(Model_rules_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_part + + return p +} + +func (s *Model_rules_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_partContext) RULES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULES, 0) +} + +func (s *Model_rules_partContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Model_rules_partContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Model_rules_partContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Model_rules_partContext) Model_iterate_clause() IModel_iterate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_iterate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_iterate_clauseContext) +} + +func (s *Model_rules_partContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *Model_rules_partContext) SEQUENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENTIAL, 0) +} + +func (s *Model_rules_partContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Model_rules_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_part(s) + } +} + +func (s *Model_rules_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_part(s) + } +} + +func (p *PlSqlParser) Model_rules_part() (localctx IModel_rules_partContext) { + localctx = NewModel_rules_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1984, PlSqlParserRULE_model_rules_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17666) + p.Match(PlSqlParserRULES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserUPDATE: + { + p.SetState(17667) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUPSERT: + { + p.SetState(17668) + p.Match(PlSqlParserUPSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(17669) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAUTOMATIC, PlSqlParserITERATE, PlSqlParserSEQUENTIAL, PlSqlParserLEFT_PAREN: + + default: + } + p.SetState(17676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTOMATIC || _la == PlSqlParserSEQUENTIAL { + { + p.SetState(17674) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTOMATIC || _la == PlSqlParserSEQUENTIAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17675) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserITERATE { + { + p.SetState(17678) + p.Model_iterate_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_rules_elementContext is an interface to support dynamic dispatch. +type IModel_rules_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Cell_assignment() ICell_assignmentContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + UPDATE() antlr.TerminalNode + UPSERT() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + ALL() antlr.TerminalNode + + // IsModel_rules_elementContext differentiates from other interfaces. + IsModel_rules_elementContext() +} + +type Model_rules_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_elementContext() *Model_rules_elementContext { + var p = new(Model_rules_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_element + return p +} + +func InitEmptyModel_rules_elementContext(p *Model_rules_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_element +} + +func (*Model_rules_elementContext) IsModel_rules_elementContext() {} + +func NewModel_rules_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_elementContext { + var p = new(Model_rules_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_element + + return p +} + +func (s *Model_rules_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_elementContext) Cell_assignment() ICell_assignmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_assignmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICell_assignmentContext) +} + +func (s *Model_rules_elementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Model_rules_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_rules_elementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Model_rules_elementContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Model_rules_elementContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Model_rules_elementContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Model_rules_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_element(s) + } +} + +func (s *Model_rules_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_element(s) + } +} + +func (p *PlSqlParser) Model_rules_element() (localctx IModel_rules_elementContext) { + localctx = NewModel_rules_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1986, PlSqlParserRULE_model_rules_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2440, p.GetParserRuleContext()) == 1 { + { + p.SetState(17681) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2440, p.GetParserRuleContext()) == 2 { + { + p.SetState(17682) + p.Match(PlSqlParserUPSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17684) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2439, p.GetParserRuleContext()) == 1 { + { + p.SetState(17683) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17688) + p.Cell_assignment() + } + p.SetState(17690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(17689) + p.Order_by_clause() + } + + } + { + p.SetState(17692) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17693) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICell_assignmentContext is an interface to support dynamic dispatch. +type ICell_assignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Model_expression() IModel_expressionContext + + // IsCell_assignmentContext differentiates from other interfaces. + IsCell_assignmentContext() +} + +type Cell_assignmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCell_assignmentContext() *Cell_assignmentContext { + var p = new(Cell_assignmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_assignment + return p +} + +func InitEmptyCell_assignmentContext(p *Cell_assignmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_assignment +} + +func (*Cell_assignmentContext) IsCell_assignmentContext() {} + +func NewCell_assignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cell_assignmentContext { + var p = new(Cell_assignmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cell_assignment + + return p +} + +func (s *Cell_assignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cell_assignmentContext) Model_expression() IModel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expressionContext) +} + +func (s *Cell_assignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cell_assignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cell_assignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCell_assignment(s) + } +} + +func (s *Cell_assignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCell_assignment(s) + } +} + +func (p *PlSqlParser) Cell_assignment() (localctx ICell_assignmentContext) { + localctx = NewCell_assignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1988, PlSqlParserRULE_cell_assignment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17695) + p.Model_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_iterate_clauseContext is an interface to support dynamic dispatch. +type IModel_iterate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ITERATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Until_part() IUntil_partContext + + // IsModel_iterate_clauseContext differentiates from other interfaces. + IsModel_iterate_clauseContext() +} + +type Model_iterate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_iterate_clauseContext() *Model_iterate_clauseContext { + var p = new(Model_iterate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_iterate_clause + return p +} + +func InitEmptyModel_iterate_clauseContext(p *Model_iterate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_iterate_clause +} + +func (*Model_iterate_clauseContext) IsModel_iterate_clauseContext() {} + +func NewModel_iterate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_iterate_clauseContext { + var p = new(Model_iterate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_iterate_clause + + return p +} + +func (s *Model_iterate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_iterate_clauseContext) ITERATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATE, 0) +} + +func (s *Model_iterate_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_iterate_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_iterate_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_iterate_clauseContext) Until_part() IUntil_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUntil_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUntil_partContext) +} + +func (s *Model_iterate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_iterate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_iterate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_iterate_clause(s) + } +} + +func (s *Model_iterate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_iterate_clause(s) + } +} + +func (p *PlSqlParser) Model_iterate_clause() (localctx IModel_iterate_clauseContext) { + localctx = NewModel_iterate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1990, PlSqlParserRULE_model_iterate_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17697) + p.Match(PlSqlParserITERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17698) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17699) + p.Expression() + } + { + p.SetState(17700) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(17701) + p.Until_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUntil_partContext is an interface to support dynamic dispatch. +type IUntil_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNTIL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsUntil_partContext differentiates from other interfaces. + IsUntil_partContext() +} + +type Until_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUntil_partContext() *Until_partContext { + var p = new(Until_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_until_part + return p +} + +func InitEmptyUntil_partContext(p *Until_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_until_part +} + +func (*Until_partContext) IsUntil_partContext() {} + +func NewUntil_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Until_partContext { + var p = new(Until_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_until_part + + return p +} + +func (s *Until_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Until_partContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Until_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Until_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Until_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Until_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Until_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Until_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUntil_part(s) + } +} + +func (s *Until_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUntil_part(s) + } +} + +func (p *PlSqlParser) Until_part() (localctx IUntil_partContext) { + localctx = NewUntil_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1992, PlSqlParserRULE_until_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17704) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17705) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17706) + p.Condition() + } + { + p.SetState(17707) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_clauseContext is an interface to support dynamic dispatch. +type IOrder_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllOrder_by_elements() []IOrder_by_elementsContext + Order_by_elements(i int) IOrder_by_elementsContext + SIBLINGS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOrder_by_clauseContext differentiates from other interfaces. + IsOrder_by_clauseContext() +} + +type Order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_clause + return p +} + +func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_clause +} + +func (*Order_by_clauseContext) IsOrder_by_clauseContext() {} + +func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_order_by_clause + + return p +} + +func (s *Order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Order_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Order_by_clauseContext) AllOrder_by_elements() []IOrder_by_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_by_elementsContext); ok { + len++ + } + } + + tst := make([]IOrder_by_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_by_elementsContext); ok { + tst[i] = t.(IOrder_by_elementsContext) + i++ + } + } + + return tst +} + +func (s *Order_by_clauseContext) Order_by_elements(i int) IOrder_by_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_elementsContext) +} + +func (s *Order_by_clauseContext) SIBLINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIBLINGS, 0) +} + +func (s *Order_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Order_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOrder_by_clause(s) + } +} + +func (p *PlSqlParser) Order_by_clause() (localctx IOrder_by_clauseContext) { + localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1994, PlSqlParserRULE_order_by_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17709) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIBLINGS { + { + p.SetState(17710) + p.Match(PlSqlParserSIBLINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17713) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17714) + p.Order_by_elements() + } + p.SetState(17719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2444, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17715) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17716) + p.Order_by_elements() + } + + } + p.SetState(17721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2444, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_elementsContext is an interface to support dynamic dispatch. +type IOrder_by_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + NULLS() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsOrder_by_elementsContext differentiates from other interfaces. + IsOrder_by_elementsContext() +} + +type Order_by_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_elementsContext() *Order_by_elementsContext { + var p = new(Order_by_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_elements + return p +} + +func InitEmptyOrder_by_elementsContext(p *Order_by_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_elements +} + +func (*Order_by_elementsContext) IsOrder_by_elementsContext() {} + +func NewOrder_by_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_elementsContext { + var p = new(Order_by_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_order_by_elements + + return p +} + +func (s *Order_by_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Order_by_elementsContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Order_by_elementsContext) ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, 0) +} + +func (s *Order_by_elementsContext) DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, 0) +} + +func (s *Order_by_elementsContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Order_by_elementsContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Order_by_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOrder_by_elements(s) + } +} + +func (s *Order_by_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOrder_by_elements(s) + } +} + +func (p *PlSqlParser) Order_by_elements() (localctx IOrder_by_elementsContext) { + localctx = NewOrder_by_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1996, PlSqlParserRULE_order_by_elements) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17722) + p.Expression() + } + p.SetState(17724) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2445, p.GetParserRuleContext()) == 1 { + { + p.SetState(17723) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17728) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2446, p.GetParserRuleContext()) == 1 { + { + p.SetState(17726) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17727) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOffset_clauseContext is an interface to support dynamic dispatch. +type IOffset_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFSET() antlr.TerminalNode + Expression() IExpressionContext + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsOffset_clauseContext differentiates from other interfaces. + IsOffset_clauseContext() +} + +type Offset_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOffset_clauseContext() *Offset_clauseContext { + var p = new(Offset_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_offset_clause + return p +} + +func InitEmptyOffset_clauseContext(p *Offset_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_offset_clause +} + +func (*Offset_clauseContext) IsOffset_clauseContext() {} + +func NewOffset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Offset_clauseContext { + var p = new(Offset_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_offset_clause + + return p +} + +func (s *Offset_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Offset_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Offset_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Offset_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Offset_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Offset_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOffset_clause(s) + } +} + +func (s *Offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOffset_clause(s) + } +} + +func (p *PlSqlParser) Offset_clause() (localctx IOffset_clauseContext) { + localctx = NewOffset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1998, PlSqlParserRULE_offset_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17730) + p.Match(PlSqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17731) + p.Expression() + } + { + p.SetState(17732) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserROW || _la == PlSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetch_clauseContext is an interface to support dynamic dispatch. +type IFetch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FETCH() antlr.TerminalNode + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + ONLY() antlr.TerminalNode + WITH() antlr.TerminalNode + TIES() antlr.TerminalNode + Expression() IExpressionContext + PERCENT_KEYWORD() antlr.TerminalNode + + // IsFetch_clauseContext differentiates from other interfaces. + IsFetch_clauseContext() +} + +type Fetch_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFetch_clauseContext() *Fetch_clauseContext { + var p = new(Fetch_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_clause + return p +} + +func InitEmptyFetch_clauseContext(p *Fetch_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_clause +} + +func (*Fetch_clauseContext) IsFetch_clauseContext() {} + +func NewFetch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_clauseContext { + var p = new(Fetch_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fetch_clause + + return p +} + +func (s *Fetch_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_clauseContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Fetch_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Fetch_clauseContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Fetch_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Fetch_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Fetch_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Fetch_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Fetch_clauseContext) TIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIES, 0) +} + +func (s *Fetch_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Fetch_clauseContext) PERCENT_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_KEYWORD, 0) +} + +func (s *Fetch_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFetch_clause(s) + } +} + +func (s *Fetch_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFetch_clause(s) + } +} + +func (p *PlSqlParser) Fetch_clause() (localctx IFetch_clauseContext) { + localctx = NewFetch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2000, PlSqlParserRULE_fetch_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17734) + p.Match(PlSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17735) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserNEXT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17740) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2448, p.GetParserRuleContext()) == 1 { + { + p.SetState(17736) + p.Expression() + } + p.SetState(17738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERCENT_KEYWORD { + { + p.SetState(17737) + p.Match(PlSqlParserPERCENT_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17742) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserROW || _la == PlSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLY: + { + p.SetState(17743) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWITH: + { + p.SetState(17744) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17745) + p.Match(PlSqlParserTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_update_clauseContext is an interface to support dynamic dispatch. +type IFor_update_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + UPDATE() antlr.TerminalNode + For_update_of_part() IFor_update_of_partContext + For_update_options() IFor_update_optionsContext + + // IsFor_update_clauseContext differentiates from other interfaces. + IsFor_update_clauseContext() +} + +type For_update_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_clauseContext() *For_update_clauseContext { + var p = new(For_update_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_clause + return p +} + +func InitEmptyFor_update_clauseContext(p *For_update_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_clause +} + +func (*For_update_clauseContext) IsFor_update_clauseContext() {} + +func NewFor_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_clauseContext { + var p = new(For_update_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_clause + + return p +} + +func (s *For_update_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_update_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *For_update_clauseContext) For_update_of_part() IFor_update_of_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_of_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_of_partContext) +} + +func (s *For_update_clauseContext) For_update_options() IFor_update_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_optionsContext) +} + +func (s *For_update_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_clause(s) + } +} + +func (s *For_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_clause(s) + } +} + +func (p *PlSqlParser) For_update_clause() (localctx IFor_update_clauseContext) { + localctx = NewFor_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2002, PlSqlParserRULE_for_update_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17748) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17749) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(17750) + p.For_update_of_part() + } + + } + p.SetState(17754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserSKIP_ || _la == PlSqlParserWAIT { + { + p.SetState(17753) + p.For_update_options() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_update_of_partContext is an interface to support dynamic dispatch. +type IFor_update_of_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsFor_update_of_partContext differentiates from other interfaces. + IsFor_update_of_partContext() +} + +type For_update_of_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_of_partContext() *For_update_of_partContext { + var p = new(For_update_of_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_of_part + return p +} + +func InitEmptyFor_update_of_partContext(p *For_update_of_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_of_part +} + +func (*For_update_of_partContext) IsFor_update_of_partContext() {} + +func NewFor_update_of_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_of_partContext { + var p = new(For_update_of_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_of_part + + return p +} + +func (s *For_update_of_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_of_partContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *For_update_of_partContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *For_update_of_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_of_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_of_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_of_part(s) + } +} + +func (s *For_update_of_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_of_part(s) + } +} + +func (p *PlSqlParser) For_update_of_part() (localctx IFor_update_of_partContext) { + localctx = NewFor_update_of_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2004, PlSqlParserRULE_for_update_of_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17756) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17757) + p.Column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_update_optionsContext is an interface to support dynamic dispatch. +type IFor_update_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SKIP_() antlr.TerminalNode + LOCKED() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + WAIT() antlr.TerminalNode + Expression() IExpressionContext + + // IsFor_update_optionsContext differentiates from other interfaces. + IsFor_update_optionsContext() +} + +type For_update_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_optionsContext() *For_update_optionsContext { + var p = new(For_update_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_options + return p +} + +func InitEmptyFor_update_optionsContext(p *For_update_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_options +} + +func (*For_update_optionsContext) IsFor_update_optionsContext() {} + +func NewFor_update_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_optionsContext { + var p = new(For_update_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_options + + return p +} + +func (s *For_update_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_optionsContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *For_update_optionsContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *For_update_optionsContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *For_update_optionsContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *For_update_optionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *For_update_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_options(s) + } +} + +func (s *For_update_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_options(s) + } +} + +func (p *PlSqlParser) For_update_options() (localctx IFor_update_optionsContext) { + localctx = NewFor_update_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2006, PlSqlParserRULE_for_update_options) + p.SetState(17764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSKIP_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17759) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17760) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOWAIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17761) + p.Match(PlSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWAIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17762) + p.Match(PlSqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17763) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statementContext is an interface to support dynamic dispatch. +type IUpdate_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + General_table_ref() IGeneral_table_refContext + Update_set_clause() IUpdate_set_clauseContext + Where_clause() IWhere_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // IsUpdate_statementContext differentiates from other interfaces. + IsUpdate_statementContext() +} + +type Update_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_statementContext() *Update_statementContext { + var p = new(Update_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_statement + return p +} + +func InitEmptyUpdate_statementContext(p *Update_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_statement +} + +func (*Update_statementContext) IsUpdate_statementContext() {} + +func NewUpdate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statementContext { + var p = new(Update_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_statement + + return p +} + +func (s *Update_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_statementContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Update_statementContext) Update_set_clause() IUpdate_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_set_clauseContext) +} + +func (s *Update_statementContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Update_statementContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Update_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Update_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_statement(s) + } +} + +func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_statement(s) + } +} + +func (p *PlSqlParser) Update_statement() (localctx IUpdate_statementContext) { + localctx = NewUpdate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2008, PlSqlParserRULE_update_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17766) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17767) + p.General_table_ref() + } + { + p.SetState(17768) + p.Update_set_clause() + } + p.SetState(17770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHERE { + { + p.SetState(17769) + p.Where_clause() + } + + } + p.SetState(17773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING || _la == PlSqlParserRETURN { + { + p.SetState(17772) + p.Static_returning_clause() + } + + } + p.SetState(17776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17775) + p.Error_logging_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_set_clauseContext is an interface to support dynamic dispatch. +type IUpdate_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllColumn_based_update_set_clause() []IColumn_based_update_set_clauseContext + Column_based_update_set_clause(i int) IColumn_based_update_set_clauseContext + VALUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Identifier() IIdentifierContext + RIGHT_PAREN() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUpdate_set_clauseContext differentiates from other interfaces. + IsUpdate_set_clauseContext() +} + +type Update_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_set_clauseContext() *Update_set_clauseContext { + var p = new(Update_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_set_clause + return p +} + +func InitEmptyUpdate_set_clauseContext(p *Update_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_set_clause +} + +func (*Update_set_clauseContext) IsUpdate_set_clauseContext() {} + +func NewUpdate_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_set_clauseContext { + var p = new(Update_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_set_clause + + return p +} + +func (s *Update_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_set_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Update_set_clauseContext) AllColumn_based_update_set_clause() []IColumn_based_update_set_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_based_update_set_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + tst[i] = t.(IColumn_based_update_set_clauseContext) + i++ + } + } + + return tst +} + +func (s *Update_set_clauseContext) Column_based_update_set_clause(i int) IColumn_based_update_set_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_based_update_set_clauseContext) +} + +func (s *Update_set_clauseContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Update_set_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_set_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Update_set_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_set_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Update_set_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_set_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_set_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_set_clause(s) + } +} + +func (s *Update_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_set_clause(s) + } +} + +func (p *PlSqlParser) Update_set_clause() (localctx IUpdate_set_clauseContext) { + localctx = NewUpdate_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2010, PlSqlParserRULE_update_set_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17778) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2457, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17779) + p.Column_based_update_set_clause() + } + p.SetState(17784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17780) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17781) + p.Column_based_update_set_clause() + } + + p.SetState(17786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(17787) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17788) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17789) + p.Identifier() + } + { + p.SetState(17790) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17791) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17792) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_based_update_set_clauseContext is an interface to support dynamic dispatch. +type IColumn_based_update_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + Paren_column_list() IParen_column_listContext + Subquery() ISubqueryContext + + // IsColumn_based_update_set_clauseContext differentiates from other interfaces. + IsColumn_based_update_set_clauseContext() +} + +type Column_based_update_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_based_update_set_clauseContext() *Column_based_update_set_clauseContext { + var p = new(Column_based_update_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause + return p +} + +func InitEmptyColumn_based_update_set_clauseContext(p *Column_based_update_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause +} + +func (*Column_based_update_set_clauseContext) IsColumn_based_update_set_clauseContext() {} + +func NewColumn_based_update_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_based_update_set_clauseContext { + var p = new(Column_based_update_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause + + return p +} + +func (s *Column_based_update_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_based_update_set_clauseContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_based_update_set_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Column_based_update_set_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_based_update_set_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Column_based_update_set_clauseContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Column_based_update_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_based_update_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_based_update_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_based_update_set_clause(s) + } +} + +func (s *Column_based_update_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_based_update_set_clause(s) + } +} + +func (p *PlSqlParser) Column_based_update_set_clause() (localctx IColumn_based_update_set_clauseContext) { + localctx = NewColumn_based_update_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2012, PlSqlParserRULE_column_based_update_set_clause) + p.SetState(17804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17796) + p.Column_name() + } + { + p.SetState(17797) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17798) + p.Expression() + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17800) + p.Paren_column_list() + } + { + p.SetState(17801) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17802) + p.Subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_statementContext is an interface to support dynamic dispatch. +type IDelete_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + General_table_ref() IGeneral_table_refContext + FROM() antlr.TerminalNode + Where_clause() IWhere_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // IsDelete_statementContext differentiates from other interfaces. + IsDelete_statementContext() +} + +type Delete_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelete_statementContext() *Delete_statementContext { + var p = new(Delete_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_statement + return p +} + +func InitEmptyDelete_statementContext(p *Delete_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_statement +} + +func (*Delete_statementContext) IsDelete_statementContext() {} + +func NewDelete_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statementContext { + var p = new(Delete_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delete_statement + + return p +} + +func (s *Delete_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statementContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_statementContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Delete_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Delete_statementContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Delete_statementContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Delete_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Delete_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelete_statement(s) + } +} + +func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_statement(s) + } +} + +func (p *PlSqlParser) Delete_statement() (localctx IDelete_statementContext) { + localctx = NewDelete_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2014, PlSqlParserRULE_delete_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17806) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17808) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2459, p.GetParserRuleContext()) == 1 { + { + p.SetState(17807) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17810) + p.General_table_ref() + } + p.SetState(17812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHERE { + { + p.SetState(17811) + p.Where_clause() + } + + } + p.SetState(17815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING || _la == PlSqlParserRETURN { + { + p.SetState(17814) + p.Static_returning_clause() + } + + } + p.SetState(17818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17817) + p.Error_logging_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_statementContext is an interface to support dynamic dispatch. +type IInsert_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + Single_table_insert() ISingle_table_insertContext + Multi_table_insert() IMulti_table_insertContext + + // IsInsert_statementContext differentiates from other interfaces. + IsInsert_statementContext() +} + +type Insert_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statementContext() *Insert_statementContext { + var p = new(Insert_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_statement + return p +} + +func InitEmptyInsert_statementContext(p *Insert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_statement +} + +func (*Insert_statementContext) IsInsert_statementContext() {} + +func NewInsert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statementContext { + var p = new(Insert_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_insert_statement + + return p +} + +func (s *Insert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statementContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Insert_statementContext) Single_table_insert() ISingle_table_insertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_table_insertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingle_table_insertContext) +} + +func (s *Insert_statementContext) Multi_table_insert() IMulti_table_insertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_insertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_insertContext) +} + +func (s *Insert_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInsert_statement(s) + } +} + +func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInsert_statement(s) + } +} + +func (p *PlSqlParser) Insert_statement() (localctx IInsert_statementContext) { + localctx = NewInsert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2016, PlSqlParserRULE_insert_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17820) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTO: + { + p.SetState(17821) + p.Single_table_insert() + } + + case PlSqlParserALL, PlSqlParserFIRST, PlSqlParserWHEN: + { + p.SetState(17822) + p.Multi_table_insert() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_table_insertContext is an interface to support dynamic dispatch. +type ISingle_table_insertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_into_clause() IInsert_into_clauseContext + Values_clause() IValues_clauseContext + Select_statement() ISelect_statementContext + Error_logging_clause() IError_logging_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + + // IsSingle_table_insertContext differentiates from other interfaces. + IsSingle_table_insertContext() +} + +type Single_table_insertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySingle_table_insertContext() *Single_table_insertContext { + var p = new(Single_table_insertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_table_insert + return p +} + +func InitEmptySingle_table_insertContext(p *Single_table_insertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_table_insert +} + +func (*Single_table_insertContext) IsSingle_table_insertContext() {} + +func NewSingle_table_insertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_table_insertContext { + var p = new(Single_table_insertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_single_table_insert + + return p +} + +func (s *Single_table_insertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_table_insertContext) Insert_into_clause() IInsert_into_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_into_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_into_clauseContext) +} + +func (s *Single_table_insertContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Single_table_insertContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Single_table_insertContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Single_table_insertContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Single_table_insertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_table_insertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_table_insertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSingle_table_insert(s) + } +} + +func (s *Single_table_insertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSingle_table_insert(s) + } +} + +func (p *PlSqlParser) Single_table_insert() (localctx ISingle_table_insertContext) { + localctx = NewSingle_table_insertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2018, PlSqlParserRULE_single_table_insert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17825) + p.Insert_into_clause() + } + p.SetState(17831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALUES: + { + p.SetState(17826) + p.Values_clause() + } + p.SetState(17828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING || _la == PlSqlParserRETURN { + { + p.SetState(17827) + p.Static_returning_clause() + } + + } + + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(17830) + p.Select_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(17834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17833) + p.Error_logging_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMulti_table_insertContext is an interface to support dynamic dispatch. +type IMulti_table_insertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + ALL() antlr.TerminalNode + Conditional_insert_clause() IConditional_insert_clauseContext + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsMulti_table_insertContext differentiates from other interfaces. + IsMulti_table_insertContext() +} + +type Multi_table_insertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_table_insertContext() *Multi_table_insertContext { + var p = new(Multi_table_insertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_insert + return p +} + +func InitEmptyMulti_table_insertContext(p *Multi_table_insertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_insert +} + +func (*Multi_table_insertContext) IsMulti_table_insertContext() {} + +func NewMulti_table_insertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_table_insertContext { + var p = new(Multi_table_insertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_table_insert + + return p +} + +func (s *Multi_table_insertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_table_insertContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Multi_table_insertContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Multi_table_insertContext) Conditional_insert_clause() IConditional_insert_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_clauseContext) +} + +func (s *Multi_table_insertContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Multi_table_insertContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Multi_table_insertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_table_insertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_table_insertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_table_insert(s) + } +} + +func (s *Multi_table_insertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_table_insert(s) + } +} + +func (p *PlSqlParser) Multi_table_insert() (localctx IMulti_table_insertContext) { + localctx = NewMulti_table_insertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2020, PlSqlParserRULE_multi_table_insert) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2468, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17836) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17837) + p.Multi_table_element() + } + + p.SetState(17840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(17842) + p.Conditional_insert_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(17845) + p.Select_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMulti_table_elementContext is an interface to support dynamic dispatch. +type IMulti_table_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_into_clause() IInsert_into_clauseContext + Values_clause() IValues_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // IsMulti_table_elementContext differentiates from other interfaces. + IsMulti_table_elementContext() +} + +type Multi_table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_table_elementContext() *Multi_table_elementContext { + var p = new(Multi_table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_element + return p +} + +func InitEmptyMulti_table_elementContext(p *Multi_table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_element +} + +func (*Multi_table_elementContext) IsMulti_table_elementContext() {} + +func NewMulti_table_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_table_elementContext { + var p = new(Multi_table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_table_element + + return p +} + +func (s *Multi_table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_table_elementContext) Insert_into_clause() IInsert_into_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_into_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_into_clauseContext) +} + +func (s *Multi_table_elementContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Multi_table_elementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Multi_table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_table_element(s) + } +} + +func (s *Multi_table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_table_element(s) + } +} + +func (p *PlSqlParser) Multi_table_element() (localctx IMulti_table_elementContext) { + localctx = NewMulti_table_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2022, PlSqlParserRULE_multi_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17847) + p.Insert_into_clause() + } + p.SetState(17849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUES { + { + p.SetState(17848) + p.Values_clause() + } + + } + p.SetState(17852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17851) + p.Error_logging_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditional_insert_clauseContext is an interface to support dynamic dispatch. +type IConditional_insert_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConditional_insert_when_part() []IConditional_insert_when_partContext + Conditional_insert_when_part(i int) IConditional_insert_when_partContext + Conditional_insert_else_part() IConditional_insert_else_partContext + ALL() antlr.TerminalNode + FIRST() antlr.TerminalNode + + // IsConditional_insert_clauseContext differentiates from other interfaces. + IsConditional_insert_clauseContext() +} + +type Conditional_insert_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_clauseContext() *Conditional_insert_clauseContext { + var p = new(Conditional_insert_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause + return p +} + +func InitEmptyConditional_insert_clauseContext(p *Conditional_insert_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause +} + +func (*Conditional_insert_clauseContext) IsConditional_insert_clauseContext() {} + +func NewConditional_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_clauseContext { + var p = new(Conditional_insert_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause + + return p +} + +func (s *Conditional_insert_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_clauseContext) AllConditional_insert_when_part() []IConditional_insert_when_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConditional_insert_when_partContext); ok { + len++ + } + } + + tst := make([]IConditional_insert_when_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConditional_insert_when_partContext); ok { + tst[i] = t.(IConditional_insert_when_partContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_clauseContext) Conditional_insert_when_part(i int) IConditional_insert_when_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_when_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_when_partContext) +} + +func (s *Conditional_insert_clauseContext) Conditional_insert_else_part() IConditional_insert_else_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_else_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_else_partContext) +} + +func (s *Conditional_insert_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Conditional_insert_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Conditional_insert_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_clause(s) + } +} + +func (s *Conditional_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_clause(s) + } +} + +func (p *PlSqlParser) Conditional_insert_clause() (localctx IConditional_insert_clauseContext) { + localctx = NewConditional_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2024, PlSqlParserRULE_conditional_insert_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL || _la == PlSqlParserFIRST { + { + p.SetState(17854) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserFIRST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(17858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(17857) + p.Conditional_insert_when_part() + } + + p.SetState(17860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(17862) + p.Conditional_insert_else_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditional_insert_when_partContext is an interface to support dynamic dispatch. +type IConditional_insert_when_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsConditional_insert_when_partContext differentiates from other interfaces. + IsConditional_insert_when_partContext() +} + +type Conditional_insert_when_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_when_partContext() *Conditional_insert_when_partContext { + var p = new(Conditional_insert_when_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part + return p +} + +func InitEmptyConditional_insert_when_partContext(p *Conditional_insert_when_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part +} + +func (*Conditional_insert_when_partContext) IsConditional_insert_when_partContext() {} + +func NewConditional_insert_when_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_when_partContext { + var p = new(Conditional_insert_when_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part + + return p +} + +func (s *Conditional_insert_when_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_when_partContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Conditional_insert_when_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Conditional_insert_when_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Conditional_insert_when_partContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_when_partContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Conditional_insert_when_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_when_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_when_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_when_part(s) + } +} + +func (s *Conditional_insert_when_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_when_part(s) + } +} + +func (p *PlSqlParser) Conditional_insert_when_part() (localctx IConditional_insert_when_partContext) { + localctx = NewConditional_insert_when_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2026, PlSqlParserRULE_conditional_insert_when_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17865) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17866) + p.Condition() + } + { + p.SetState(17867) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17868) + p.Multi_table_element() + } + + p.SetState(17871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditional_insert_else_partContext is an interface to support dynamic dispatch. +type IConditional_insert_else_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsConditional_insert_else_partContext differentiates from other interfaces. + IsConditional_insert_else_partContext() +} + +type Conditional_insert_else_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_else_partContext() *Conditional_insert_else_partContext { + var p = new(Conditional_insert_else_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part + return p +} + +func InitEmptyConditional_insert_else_partContext(p *Conditional_insert_else_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part +} + +func (*Conditional_insert_else_partContext) IsConditional_insert_else_partContext() {} + +func NewConditional_insert_else_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_else_partContext { + var p = new(Conditional_insert_else_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part + + return p +} + +func (s *Conditional_insert_else_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_else_partContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Conditional_insert_else_partContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_else_partContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Conditional_insert_else_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_else_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_else_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_else_part(s) + } +} + +func (s *Conditional_insert_else_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_else_part(s) + } +} + +func (p *PlSqlParser) Conditional_insert_else_part() (localctx IConditional_insert_else_partContext) { + localctx = NewConditional_insert_else_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2028, PlSqlParserRULE_conditional_insert_else_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17873) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17874) + p.Multi_table_element() + } + + p.SetState(17877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_into_clauseContext is an interface to support dynamic dispatch. +type IInsert_into_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + General_table_ref() IGeneral_table_refContext + FIELDS() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + + // IsInsert_into_clauseContext differentiates from other interfaces. + IsInsert_into_clauseContext() +} + +type Insert_into_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_into_clauseContext() *Insert_into_clauseContext { + var p = new(Insert_into_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_into_clause + return p +} + +func InitEmptyInsert_into_clauseContext(p *Insert_into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_into_clause +} + +func (*Insert_into_clauseContext) IsInsert_into_clauseContext() {} + +func NewInsert_into_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_into_clauseContext { + var p = new(Insert_into_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_insert_into_clause + + return p +} + +func (s *Insert_into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Insert_into_clauseContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Insert_into_clauseContext) FIELDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, 0) +} + +func (s *Insert_into_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Insert_into_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_into_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInsert_into_clause(s) + } +} + +func (s *Insert_into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInsert_into_clause(s) + } +} + +func (p *PlSqlParser) Insert_into_clause() (localctx IInsert_into_clauseContext) { + localctx = NewInsert_into_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2030, PlSqlParserRULE_insert_into_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17879) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17880) + p.General_table_ref() + } + p.SetState(17882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFIELDS { + { + p.SetState(17881) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17885) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2477, p.GetParserRuleContext()) == 1 { + { + p.SetState(17884) + p.Paren_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValues_clauseContext is an interface to support dynamic dispatch. +type IValues_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + REGULAR_ID() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + RIGHT_PAREN() antlr.TerminalNode + Collection_expression() ICollection_expressionContext + + // IsValues_clauseContext differentiates from other interfaces. + IsValues_clauseContext() +} + +type Values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValues_clauseContext() *Values_clauseContext { + var p = new(Values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_values_clause + return p +} + +func InitEmptyValues_clauseContext(p *Values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_values_clause +} + +func (*Values_clauseContext) IsValues_clauseContext() {} + +func NewValues_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_clauseContext { + var p = new(Values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_values_clause + + return p +} + +func (s *Values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Values_clauseContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Values_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Values_clauseContext) Collection_expression() ICollection_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_expressionContext) +} + +func (s *Values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterValues_clause(s) + } +} + +func (s *Values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitValues_clause(s) + } +} + +func (p *PlSqlParser) Values_clause() (localctx IValues_clauseContext) { + localctx = NewValues_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2032, PlSqlParserRULE_values_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17887) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2478, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17888) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17889) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17890) + p.Expressions_() + } + { + p.SetState(17891) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(17893) + p.Collection_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_statementContext is an interface to support dynamic dispatch. +type IMerge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + INTO() antlr.TerminalNode + AllSelected_tableview() []ISelected_tableviewContext + Selected_tableview(i int) ISelected_tableviewContext + USING() antlr.TerminalNode + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + Merge_update_clause() IMerge_update_clauseContext + Merge_insert_clause() IMerge_insert_clauseContext + Error_logging_clause() IError_logging_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + + // IsMerge_statementContext differentiates from other interfaces. + IsMerge_statementContext() +} + +type Merge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_statementContext() *Merge_statementContext { + var p = new(Merge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_statement + return p +} + +func InitEmptyMerge_statementContext(p *Merge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_statement +} + +func (*Merge_statementContext) IsMerge_statementContext() {} + +func NewMerge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_statementContext { + var p = new(Merge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_statement + + return p +} + +func (s *Merge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_statementContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_statementContext) AllSelected_tableview() []ISelected_tableviewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelected_tableviewContext); ok { + len++ + } + } + + tst := make([]ISelected_tableviewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelected_tableviewContext); ok { + tst[i] = t.(ISelected_tableviewContext) + i++ + } + } + + return tst +} + +func (s *Merge_statementContext) Selected_tableview(i int) ISelected_tableviewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelected_tableviewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelected_tableviewContext) +} + +func (s *Merge_statementContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Merge_statementContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Merge_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Merge_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Merge_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Merge_statementContext) Merge_update_clause() IMerge_update_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_update_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_update_clauseContext) +} + +func (s *Merge_statementContext) Merge_insert_clause() IMerge_insert_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_insert_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_insert_clauseContext) +} + +func (s *Merge_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Merge_statementContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Merge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_statement(s) + } +} + +func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_statement(s) + } +} + +func (p *PlSqlParser) Merge_statement() (localctx IMerge_statementContext) { + localctx = NewMerge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2034, PlSqlParserRULE_merge_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17896) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17897) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17898) + p.Selected_tableview() + } + { + p.SetState(17899) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17900) + p.Selected_tableview() + } + { + p.SetState(17901) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17902) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17903) + p.Condition() + } + { + p.SetState(17904) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2481, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17905) + p.Merge_update_clause() + } + p.SetState(17907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(17906) + p.Merge_insert_clause() + } + + } + + case 2: + { + p.SetState(17909) + p.Merge_insert_clause() + } + p.SetState(17911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(17910) + p.Merge_update_clause() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17915) + p.Error_logging_clause() + } + + } + p.SetState(17919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING || _la == PlSqlParserRETURN { + { + p.SetState(17918) + p.Static_returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_update_clauseContext is an interface to support dynamic dispatch. +type IMerge_update_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + AllMerge_element() []IMerge_elementContext + Merge_element(i int) IMerge_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Where_clause() IWhere_clauseContext + Merge_update_delete_part() IMerge_update_delete_partContext + + // IsMerge_update_clauseContext differentiates from other interfaces. + IsMerge_update_clauseContext() +} + +type Merge_update_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_clauseContext() *Merge_update_clauseContext { + var p = new(Merge_update_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_clause + return p +} + +func InitEmptyMerge_update_clauseContext(p *Merge_update_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_clause +} + +func (*Merge_update_clauseContext) IsMerge_update_clauseContext() {} + +func NewMerge_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_clauseContext { + var p = new(Merge_update_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_update_clause + + return p +} + +func (s *Merge_update_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_update_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Merge_update_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Merge_update_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Merge_update_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Merge_update_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Merge_update_clauseContext) AllMerge_element() []IMerge_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMerge_elementContext); ok { + len++ + } + } + + tst := make([]IMerge_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMerge_elementContext); ok { + tst[i] = t.(IMerge_elementContext) + i++ + } + } + + return tst +} + +func (s *Merge_update_clauseContext) Merge_element(i int) IMerge_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMerge_elementContext) +} + +func (s *Merge_update_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Merge_update_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Merge_update_clauseContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Merge_update_clauseContext) Merge_update_delete_part() IMerge_update_delete_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_update_delete_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_update_delete_partContext) +} + +func (s *Merge_update_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_update_clause(s) + } +} + +func (s *Merge_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_update_clause(s) + } +} + +func (p *PlSqlParser) Merge_update_clause() (localctx IMerge_update_clauseContext) { + localctx = NewMerge_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2036, PlSqlParserRULE_merge_update_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17921) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17922) + p.Match(PlSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17923) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17924) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17925) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17926) + p.Merge_element() + } + p.SetState(17931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17927) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17928) + p.Merge_element() + } + + p.SetState(17933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHERE { + { + p.SetState(17934) + p.Where_clause() + } + + } + p.SetState(17938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDELETE { + { + p.SetState(17937) + p.Merge_update_delete_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_elementContext is an interface to support dynamic dispatch. +type IMerge_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + + // IsMerge_elementContext differentiates from other interfaces. + IsMerge_elementContext() +} + +type Merge_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_elementContext() *Merge_elementContext { + var p = new(Merge_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_element + return p +} + +func InitEmptyMerge_elementContext(p *Merge_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_element +} + +func (*Merge_elementContext) IsMerge_elementContext() {} + +func NewMerge_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_elementContext { + var p = new(Merge_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_element + + return p +} + +func (s *Merge_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_elementContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Merge_elementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Merge_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Merge_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_element(s) + } +} + +func (s *Merge_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_element(s) + } +} + +func (p *PlSqlParser) Merge_element() (localctx IMerge_elementContext) { + localctx = NewMerge_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2038, PlSqlParserRULE_merge_element) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17940) + p.Column_name() + } + { + p.SetState(17941) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17942) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_update_delete_partContext is an interface to support dynamic dispatch. +type IMerge_update_delete_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + Where_clause() IWhere_clauseContext + + // IsMerge_update_delete_partContext differentiates from other interfaces. + IsMerge_update_delete_partContext() +} + +type Merge_update_delete_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_delete_partContext() *Merge_update_delete_partContext { + var p = new(Merge_update_delete_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part + return p +} + +func InitEmptyMerge_update_delete_partContext(p *Merge_update_delete_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part +} + +func (*Merge_update_delete_partContext) IsMerge_update_delete_partContext() {} + +func NewMerge_update_delete_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_delete_partContext { + var p = new(Merge_update_delete_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part + + return p +} + +func (s *Merge_update_delete_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_update_delete_partContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Merge_update_delete_partContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Merge_update_delete_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_delete_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_delete_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_update_delete_part(s) + } +} + +func (s *Merge_update_delete_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_update_delete_part(s) + } +} + +func (p *PlSqlParser) Merge_update_delete_part() (localctx IMerge_update_delete_partContext) { + localctx = NewMerge_update_delete_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2040, PlSqlParserRULE_merge_update_delete_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17944) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17945) + p.Where_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_insert_clauseContext is an interface to support dynamic dispatch. +type IMerge_insert_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + NOT() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + INSERT() antlr.TerminalNode + Values_clause() IValues_clauseContext + Paren_column_list() IParen_column_listContext + Where_clause() IWhere_clauseContext + + // IsMerge_insert_clauseContext differentiates from other interfaces. + IsMerge_insert_clauseContext() +} + +type Merge_insert_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_insert_clauseContext() *Merge_insert_clauseContext { + var p = new(Merge_insert_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_insert_clause + return p +} + +func InitEmptyMerge_insert_clauseContext(p *Merge_insert_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_insert_clause +} + +func (*Merge_insert_clauseContext) IsMerge_insert_clauseContext() {} + +func NewMerge_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insert_clauseContext { + var p = new(Merge_insert_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_insert_clause + + return p +} + +func (s *Merge_insert_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_insert_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Merge_insert_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Merge_insert_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Merge_insert_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Merge_insert_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Merge_insert_clauseContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Merge_insert_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Merge_insert_clauseContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Merge_insert_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_insert_clause(s) + } +} + +func (s *Merge_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_insert_clause(s) + } +} + +func (p *PlSqlParser) Merge_insert_clause() (localctx IMerge_insert_clauseContext) { + localctx = NewMerge_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2042, PlSqlParserRULE_merge_insert_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17947) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17948) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17949) + p.Match(PlSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17950) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17951) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17952) + p.Paren_column_list() + } + + } + { + p.SetState(17955) + p.Values_clause() + } + p.SetState(17957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHERE { + { + p.SetState(17956) + p.Where_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelected_tableviewContext is an interface to support dynamic dispatch. +type ISelected_tableviewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Table_collection_expression() ITable_collection_expressionContext + Table_alias() ITable_aliasContext + + // IsSelected_tableviewContext differentiates from other interfaces. + IsSelected_tableviewContext() +} + +type Selected_tableviewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelected_tableviewContext() *Selected_tableviewContext { + var p = new(Selected_tableviewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_tableview + return p +} + +func InitEmptySelected_tableviewContext(p *Selected_tableviewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_tableview +} + +func (*Selected_tableviewContext) IsSelected_tableviewContext() {} + +func NewSelected_tableviewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selected_tableviewContext { + var p = new(Selected_tableviewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selected_tableview + + return p +} + +func (s *Selected_tableviewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selected_tableviewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Selected_tableviewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Selected_tableviewContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Selected_tableviewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Selected_tableviewContext) Table_collection_expression() ITable_collection_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_collection_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_collection_expressionContext) +} + +func (s *Selected_tableviewContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Selected_tableviewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selected_tableviewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selected_tableviewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelected_tableview(s) + } +} + +func (s *Selected_tableviewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelected_tableview(s) + } +} + +func (p *PlSqlParser) Selected_tableview() (localctx ISelected_tableviewContext) { + localctx = NewSelected_tableviewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2044, PlSqlParserRULE_selected_tableview) + p.EnterOuterAlt(localctx, 1) + p.SetState(17969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2489, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17959) + p.Tableview_name() + } + + case 2: + { + p.SetState(17960) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17961) + p.Select_statement() + } + { + p.SetState(17962) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(17964) + p.Table_collection_expression() + } + + case 4: + { + p.SetState(17965) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17966) + p.Table_collection_expression() + } + { + p.SetState(17967) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17972) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2490, p.GetParserRuleContext()) == 1 { + { + p.SetState(17971) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILock_table_statementContext is an interface to support dynamic dispatch. +type ILock_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCK() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllLock_table_element() []ILock_table_elementContext + Lock_table_element(i int) ILock_table_elementContext + IN() antlr.TerminalNode + Lock_mode() ILock_modeContext + MODE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Wait_nowait_part() IWait_nowait_partContext + + // IsLock_table_statementContext differentiates from other interfaces. + IsLock_table_statementContext() +} + +type Lock_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_table_statementContext() *Lock_table_statementContext { + var p = new(Lock_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_statement + return p +} + +func InitEmptyLock_table_statementContext(p *Lock_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_statement +} + +func (*Lock_table_statementContext) IsLock_table_statementContext() {} + +func NewLock_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_table_statementContext { + var p = new(Lock_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_table_statement + + return p +} + +func (s *Lock_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_table_statementContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Lock_table_statementContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Lock_table_statementContext) AllLock_table_element() []ILock_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILock_table_elementContext); ok { + len++ + } + } + + tst := make([]ILock_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILock_table_elementContext); ok { + tst[i] = t.(ILock_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Lock_table_statementContext) Lock_table_element(i int) ILock_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILock_table_elementContext) +} + +func (s *Lock_table_statementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Lock_table_statementContext) Lock_mode() ILock_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_modeContext) +} + +func (s *Lock_table_statementContext) MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODE, 0) +} + +func (s *Lock_table_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Lock_table_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Lock_table_statementContext) Wait_nowait_part() IWait_nowait_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowait_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowait_partContext) +} + +func (s *Lock_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_table_statement(s) + } +} + +func (s *Lock_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_table_statement(s) + } +} + +func (p *PlSqlParser) Lock_table_statement() (localctx ILock_table_statementContext) { + localctx = NewLock_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2046, PlSqlParserRULE_lock_table_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17974) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17975) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17976) + p.Lock_table_element() + } + p.SetState(17981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17977) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17978) + p.Lock_table_element() + } + + p.SetState(17983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17984) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17985) + p.Lock_mode() + } + { + p.SetState(17986) + p.Match(PlSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT { + { + p.SetState(17987) + p.Wait_nowait_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWait_nowait_partContext is an interface to support dynamic dispatch. +type IWait_nowait_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + Expression() IExpressionContext + NOWAIT() antlr.TerminalNode + + // IsWait_nowait_partContext differentiates from other interfaces. + IsWait_nowait_partContext() +} + +type Wait_nowait_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWait_nowait_partContext() *Wait_nowait_partContext { + var p = new(Wait_nowait_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait_part + return p +} + +func InitEmptyWait_nowait_partContext(p *Wait_nowait_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait_part +} + +func (*Wait_nowait_partContext) IsWait_nowait_partContext() {} + +func NewWait_nowait_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wait_nowait_partContext { + var p = new(Wait_nowait_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_wait_nowait_part + + return p +} + +func (s *Wait_nowait_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wait_nowait_partContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Wait_nowait_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Wait_nowait_partContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Wait_nowait_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wait_nowait_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wait_nowait_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWait_nowait_part(s) + } +} + +func (s *Wait_nowait_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWait_nowait_part(s) + } +} + +func (p *PlSqlParser) Wait_nowait_part() (localctx IWait_nowait_partContext) { + localctx = NewWait_nowait_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2048, PlSqlParserRULE_wait_nowait_part) + p.SetState(17993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWAIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17990) + p.Match(PlSqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17991) + p.Expression() + } + + case PlSqlParserNOWAIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17992) + p.Match(PlSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILock_table_elementContext is an interface to support dynamic dispatch. +type ILock_table_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + Partition_extension_clause() IPartition_extension_clauseContext + + // IsLock_table_elementContext differentiates from other interfaces. + IsLock_table_elementContext() +} + +type Lock_table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_table_elementContext() *Lock_table_elementContext { + var p = new(Lock_table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_element + return p +} + +func InitEmptyLock_table_elementContext(p *Lock_table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_element +} + +func (*Lock_table_elementContext) IsLock_table_elementContext() {} + +func NewLock_table_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_table_elementContext { + var p = new(Lock_table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_table_element + + return p +} + +func (s *Lock_table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_table_elementContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Lock_table_elementContext) Partition_extension_clause() IPartition_extension_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extension_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extension_clauseContext) +} + +func (s *Lock_table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_table_element(s) + } +} + +func (s *Lock_table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_table_element(s) + } +} + +func (p *PlSqlParser) Lock_table_element() (localctx ILock_table_elementContext) { + localctx = NewLock_table_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2050, PlSqlParserRULE_lock_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17995) + p.Tableview_name() + } + p.SetState(17997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION { + { + p.SetState(17996) + p.Partition_extension_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILock_modeContext is an interface to support dynamic dispatch. +type ILock_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + SHARE() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsLock_modeContext differentiates from other interfaces. + IsLock_modeContext() +} + +type Lock_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_modeContext() *Lock_modeContext { + var p = new(Lock_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_mode + return p +} + +func InitEmptyLock_modeContext(p *Lock_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_mode +} + +func (*Lock_modeContext) IsLock_modeContext() {} + +func NewLock_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_modeContext { + var p = new(Lock_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_mode + + return p +} + +func (s *Lock_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_modeContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Lock_modeContext) SHARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARE, 0) +} + +func (s *Lock_modeContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUSIVE, 0) +} + +func (s *Lock_modeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Lock_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_mode(s) + } +} + +func (s *Lock_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_mode(s) + } +} + +func (p *PlSqlParser) Lock_mode() (localctx ILock_modeContext) { + localctx = NewLock_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2052, PlSqlParserRULE_lock_mode) + var _la int + + p.SetState(18011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2496, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17999) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18000) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18001) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18002) + p.Match(PlSqlParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18003) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUPDATE { + { + p.SetState(18004) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18007) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18008) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18009) + p.Match(PlSqlParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18010) + p.Match(PlSqlParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneral_table_refContext is an interface to support dynamic dispatch. +type IGeneral_table_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dml_table_expression_clause() IDml_table_expression_clauseContext + ONLY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Table_alias() ITable_aliasContext + + // IsGeneral_table_refContext differentiates from other interfaces. + IsGeneral_table_refContext() +} + +type General_table_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_table_refContext() *General_table_refContext { + var p = new(General_table_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_table_ref + return p +} + +func InitEmptyGeneral_table_refContext(p *General_table_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_table_ref +} + +func (*General_table_refContext) IsGeneral_table_refContext() {} + +func NewGeneral_table_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_table_refContext { + var p = new(General_table_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_table_ref + + return p +} + +func (s *General_table_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_table_refContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *General_table_refContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *General_table_refContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *General_table_refContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *General_table_refContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *General_table_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_table_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_table_ref(s) + } +} + +func (s *General_table_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_table_ref(s) + } +} + +func (p *PlSqlParser) General_table_ref() (localctx IGeneral_table_refContext) { + localctx = NewGeneral_table_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2054, PlSqlParserRULE_general_table_ref) + p.EnterOuterAlt(localctx, 1) + p.SetState(18019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2497, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18013) + p.Dml_table_expression_clause() + } + + case 2: + { + p.SetState(18014) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18015) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18016) + p.Dml_table_expression_clause() + } + { + p.SetState(18017) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18022) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2498, p.GetParserRuleContext()) == 1 { + { + p.SetState(18021) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatic_returning_clauseContext is an interface to support dynamic dispatch. +type IStatic_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expressions_() IExpressions_Context + Into_clause() IInto_clauseContext + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + + // IsStatic_returning_clauseContext differentiates from other interfaces. + IsStatic_returning_clauseContext() +} + +type Static_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatic_returning_clauseContext() *Static_returning_clauseContext { + var p = new(Static_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_returning_clause + return p +} + +func InitEmptyStatic_returning_clauseContext(p *Static_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_returning_clause +} + +func (*Static_returning_clauseContext) IsStatic_returning_clauseContext() {} + +func NewStatic_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Static_returning_clauseContext { + var p = new(Static_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_static_returning_clause + + return p +} + +func (s *Static_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Static_returning_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Static_returning_clauseContext) Into_clause() IInto_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Static_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Static_returning_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Static_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Static_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Static_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatic_returning_clause(s) + } +} + +func (s *Static_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatic_returning_clause(s) + } +} + +func (p *PlSqlParser) Static_returning_clause() (localctx IStatic_returning_clauseContext) { + localctx = NewStatic_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2056, PlSqlParserRULE_static_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18024) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRETURNING || _la == PlSqlParserRETURN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18025) + p.Expressions_() + } + { + p.SetState(18026) + p.Into_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IError_logging_clauseContext is an interface to support dynamic dispatch. +type IError_logging_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOG() antlr.TerminalNode + ERRORS() antlr.TerminalNode + Error_logging_into_part() IError_logging_into_partContext + Expression() IExpressionContext + Error_logging_reject_part() IError_logging_reject_partContext + + // IsError_logging_clauseContext differentiates from other interfaces. + IsError_logging_clauseContext() +} + +type Error_logging_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_clauseContext() *Error_logging_clauseContext { + var p = new(Error_logging_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_clause + return p +} + +func InitEmptyError_logging_clauseContext(p *Error_logging_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_clause +} + +func (*Error_logging_clauseContext) IsError_logging_clauseContext() {} + +func NewError_logging_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_clauseContext { + var p = new(Error_logging_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_clause + + return p +} + +func (s *Error_logging_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_clauseContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Error_logging_clauseContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Error_logging_clauseContext) Error_logging_into_part() IError_logging_into_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_into_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_into_partContext) +} + +func (s *Error_logging_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Error_logging_clauseContext) Error_logging_reject_part() IError_logging_reject_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_reject_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_reject_partContext) +} + +func (s *Error_logging_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_clause(s) + } +} + +func (s *Error_logging_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_clause(s) + } +} + +func (p *PlSqlParser) Error_logging_clause() (localctx IError_logging_clauseContext) { + localctx = NewError_logging_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2058, PlSqlParserRULE_error_logging_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18028) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18029) + p.Match(PlSqlParserERRORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18031) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2499, p.GetParserRuleContext()) == 1 { + { + p.SetState(18030) + p.Error_logging_into_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18034) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2500, p.GetParserRuleContext()) == 1 { + { + p.SetState(18033) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREJECT { + { + p.SetState(18036) + p.Error_logging_reject_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IError_logging_into_partContext is an interface to support dynamic dispatch. +type IError_logging_into_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsError_logging_into_partContext differentiates from other interfaces. + IsError_logging_into_partContext() +} + +type Error_logging_into_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_into_partContext() *Error_logging_into_partContext { + var p = new(Error_logging_into_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_into_part + return p +} + +func InitEmptyError_logging_into_partContext(p *Error_logging_into_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_into_part +} + +func (*Error_logging_into_partContext) IsError_logging_into_partContext() {} + +func NewError_logging_into_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_into_partContext { + var p = new(Error_logging_into_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_into_part + + return p +} + +func (s *Error_logging_into_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_into_partContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Error_logging_into_partContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Error_logging_into_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_into_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_into_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_into_part(s) + } +} + +func (s *Error_logging_into_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_into_part(s) + } +} + +func (p *PlSqlParser) Error_logging_into_part() (localctx IError_logging_into_partContext) { + localctx = NewError_logging_into_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2060, PlSqlParserRULE_error_logging_into_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18039) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18040) + p.Tableview_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IError_logging_reject_partContext is an interface to support dynamic dispatch. +type IError_logging_reject_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Expression() IExpressionContext + + // IsError_logging_reject_partContext differentiates from other interfaces. + IsError_logging_reject_partContext() +} + +type Error_logging_reject_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_reject_partContext() *Error_logging_reject_partContext { + var p = new(Error_logging_reject_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part + return p +} + +func InitEmptyError_logging_reject_partContext(p *Error_logging_reject_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part +} + +func (*Error_logging_reject_partContext) IsError_logging_reject_partContext() {} + +func NewError_logging_reject_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_reject_partContext { + var p = new(Error_logging_reject_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part + + return p +} + +func (s *Error_logging_reject_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_reject_partContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Error_logging_reject_partContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Error_logging_reject_partContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Error_logging_reject_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Error_logging_reject_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_reject_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_reject_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_reject_part(s) + } +} + +func (s *Error_logging_reject_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_reject_part(s) + } +} + +func (p *PlSqlParser) Error_logging_reject_part() (localctx IError_logging_reject_partContext) { + localctx = NewError_logging_reject_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2062, PlSqlParserRULE_error_logging_reject_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18042) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18043) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2502, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18044) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18045) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_table_expression_clauseContext is an interface to support dynamic dispatch. +type IDml_table_expression_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_collection_expression() ITable_collection_expressionContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Subquery_restriction_clause() ISubquery_restriction_clauseContext + Tableview_name() ITableview_nameContext + Hierarchies_clause() IHierarchies_clauseContext + Sample_clause() ISample_clauseContext + Json_table_clause() IJson_table_clauseContext + AS() antlr.TerminalNode + Identifier() IIdentifierContext + LATERAL() antlr.TerminalNode + Subquery() ISubqueryContext + RELATIONAL() antlr.TerminalNode + NOT() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + + // IsDml_table_expression_clauseContext differentiates from other interfaces. + IsDml_table_expression_clauseContext() +} + +type Dml_table_expression_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_table_expression_clauseContext() *Dml_table_expression_clauseContext { + var p = new(Dml_table_expression_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause + return p +} + +func InitEmptyDml_table_expression_clauseContext(p *Dml_table_expression_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause +} + +func (*Dml_table_expression_clauseContext) IsDml_table_expression_clauseContext() {} + +func NewDml_table_expression_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_table_expression_clauseContext { + var p = new(Dml_table_expression_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause + + return p +} + +func (s *Dml_table_expression_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_table_expression_clauseContext) Table_collection_expression() ITable_collection_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_collection_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_collection_expressionContext) +} + +func (s *Dml_table_expression_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Dml_table_expression_clauseContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Dml_table_expression_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Dml_table_expression_clauseContext) Subquery_restriction_clause() ISubquery_restriction_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_restriction_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_restriction_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_table_expression_clauseContext) Hierarchies_clause() IHierarchies_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchies_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHierarchies_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) Sample_clause() ISample_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) Json_table_clause() IJson_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_table_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Dml_table_expression_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dml_table_expression_clauseContext) LATERAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLATERAL, 0) +} + +func (s *Dml_table_expression_clauseContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Dml_table_expression_clauseContext) RELATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELATIONAL, 0) +} + +func (s *Dml_table_expression_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Dml_table_expression_clauseContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Dml_table_expression_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_table_expression_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_table_expression_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_table_expression_clause(s) + } +} + +func (s *Dml_table_expression_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_table_expression_clause(s) + } +} + +func (p *PlSqlParser) Dml_table_expression_clause() (localctx IDml_table_expression_clauseContext) { + localctx = NewDml_table_expression_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2064, PlSqlParserRULE_dml_table_expression_clause) + var _la int + + p.SetState(18084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2508, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18048) + p.Table_collection_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18049) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18050) + p.Select_statement() + } + p.SetState(18052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18051) + p.Subquery_restriction_clause() + } + + } + { + p.SetState(18054) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18056) + p.Tableview_name() + } + p.SetState(18058) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2504, p.GetParserRuleContext()) == 1 { + { + p.SetState(18057) + p.Hierarchies_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18061) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2505, p.GetParserRuleContext()) == 1 { + { + p.SetState(18060) + p.Sample_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18063) + p.Json_table_clause() + } + p.SetState(18066) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2506, p.GetParserRuleContext()) == 1 { + { + p.SetState(18064) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18065) + p.Identifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18068) + p.Match(PlSqlParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18069) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18070) + p.Subquery() + } + p.SetState(18072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18071) + p.Subquery_restriction_clause() + } + + } + { + p.SetState(18074) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + p.SetState(18076) + + if !(p.isVersion11()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion11()", "")) + goto errorExit + } + + { + p.SetState(18077) + p.Match(PlSqlParserRELATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18078) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18079) + p.Tableview_name() + } + { + p.SetState(18080) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18081) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18082) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_collection_expressionContext is an interface to support dynamic dispatch. +type ITable_collection_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + THE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + Outer_join_sign() IOuter_join_signContext + + // IsTable_collection_expressionContext differentiates from other interfaces. + IsTable_collection_expressionContext() +} + +type Table_collection_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_collection_expressionContext() *Table_collection_expressionContext { + var p = new(Table_collection_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_collection_expression + return p +} + +func InitEmptyTable_collection_expressionContext(p *Table_collection_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_collection_expression +} + +func (*Table_collection_expressionContext) IsTable_collection_expressionContext() {} + +func NewTable_collection_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_collection_expressionContext { + var p = new(Table_collection_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_collection_expression + + return p +} + +func (s *Table_collection_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_collection_expressionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_collection_expressionContext) THE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHE, 0) +} + +func (s *Table_collection_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_collection_expressionContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Table_collection_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_collection_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Table_collection_expressionContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *Table_collection_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_collection_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_collection_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_collection_expression(s) + } +} + +func (s *Table_collection_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_collection_expression(s) + } +} + +func (p *PlSqlParser) Table_collection_expression() (localctx ITable_collection_expressionContext) { + localctx = NewTable_collection_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2066, PlSqlParserRULE_table_collection_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18086) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserTABLE || _la == PlSqlParserTHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2510, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18087) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18088) + p.Subquery() + } + { + p.SetState(18089) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18091) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18092) + p.Expression() + } + { + p.SetState(18093) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18095) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2509, p.GetParserRuleContext()) == 1 { + { + p.SetState(18094) + p.Outer_join_sign() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_restriction_clauseContext is an interface to support dynamic dispatch. +type ISubquery_restriction_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsSubquery_restriction_clauseContext differentiates from other interfaces. + IsSubquery_restriction_clauseContext() +} + +type Subquery_restriction_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_restriction_clauseContext() *Subquery_restriction_clauseContext { + var p = new(Subquery_restriction_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause + return p +} + +func InitEmptySubquery_restriction_clauseContext(p *Subquery_restriction_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause +} + +func (*Subquery_restriction_clauseContext) IsSubquery_restriction_clauseContext() {} + +func NewSubquery_restriction_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_restriction_clauseContext { + var p = new(Subquery_restriction_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause + + return p +} + +func (s *Subquery_restriction_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_restriction_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Subquery_restriction_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Subquery_restriction_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Subquery_restriction_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Subquery_restriction_clauseContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Subquery_restriction_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Subquery_restriction_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Subquery_restriction_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_restriction_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_restriction_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_restriction_clause(s) + } +} + +func (s *Subquery_restriction_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_restriction_clause(s) + } +} + +func (p *PlSqlParser) Subquery_restriction_clause() (localctx ISubquery_restriction_clauseContext) { + localctx = NewSubquery_restriction_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2068, PlSqlParserRULE_subquery_restriction_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18099) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREAD: + { + p.SetState(18100) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18101) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHECK: + { + p.SetState(18102) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18103) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(18104) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18105) + p.Constraint_name() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_clauseContext is an interface to support dynamic dispatch. +type ISample_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SAMPLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + BLOCK() antlr.TerminalNode + COMMA() antlr.TerminalNode + Seed_part() ISeed_partContext + + // IsSample_clauseContext differentiates from other interfaces. + IsSample_clauseContext() +} + +type Sample_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_clauseContext() *Sample_clauseContext { + var p = new(Sample_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sample_clause + return p +} + +func InitEmptySample_clauseContext(p *Sample_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sample_clause +} + +func (*Sample_clauseContext) IsSample_clauseContext() {} + +func NewSample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_clauseContext { + var p = new(Sample_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sample_clause + + return p +} + +func (s *Sample_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_clauseContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAMPLE, 0) +} + +func (s *Sample_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Sample_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Sample_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sample_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Sample_clauseContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Sample_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Sample_clauseContext) Seed_part() ISeed_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeed_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeed_partContext) +} + +func (s *Sample_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSample_clause(s) + } +} + +func (s *Sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSample_clause(s) + } +} + +func (p *PlSqlParser) Sample_clause() (localctx ISample_clauseContext) { + localctx = NewSample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2070, PlSqlParserRULE_sample_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18110) + p.Match(PlSqlParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBLOCK { + { + p.SetState(18111) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18114) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18115) + p.Expression() + } + p.SetState(18118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18116) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18117) + p.Expression() + } + + } + { + p.SetState(18120) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2515, p.GetParserRuleContext()) == 1 { + { + p.SetState(18121) + p.Seed_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeed_partContext is an interface to support dynamic dispatch. +type ISeed_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEED() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsSeed_partContext differentiates from other interfaces. + IsSeed_partContext() +} + +type Seed_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeed_partContext() *Seed_partContext { + var p = new(Seed_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seed_part + return p +} + +func InitEmptySeed_partContext(p *Seed_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seed_part +} + +func (*Seed_partContext) IsSeed_partContext() {} + +func NewSeed_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seed_partContext { + var p = new(Seed_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seed_part + + return p +} + +func (s *Seed_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seed_partContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Seed_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Seed_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Seed_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Seed_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seed_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seed_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeed_part(s) + } +} + +func (s *Seed_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeed_part(s) + } +} + +func (p *PlSqlParser) Seed_part() (localctx ISeed_partContext) { + localctx = NewSeed_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2072, PlSqlParserRULE_seed_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18124) + p.Match(PlSqlParserSEED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18125) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18126) + p.Expression() + } + { + p.SetState(18127) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditionContext is an interface to support dynamic dispatch. +type IConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + JSON_EQUAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expressions_() IExpressions_Context + RIGHT_PAREN() antlr.TerminalNode + + // IsConditionContext differentiates from other interfaces. + IsConditionContext() +} + +type ConditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditionContext() *ConditionContext { + var p = new(ConditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_condition + return p +} + +func InitEmptyConditionContext(p *ConditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_condition +} + +func (*ConditionContext) IsConditionContext() {} + +func NewConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionContext { + var p = new(ConditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_condition + + return p +} + +func (s *ConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConditionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ConditionContext) JSON_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EQUAL, 0) +} + +func (s *ConditionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *ConditionContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *ConditionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *ConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCondition(s) + } +} + +func (s *ConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCondition(s) + } +} + +func (p *PlSqlParser) Condition() (localctx IConditionContext) { + localctx = NewConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2074, PlSqlParserRULE_condition) + p.SetState(18135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2516, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18129) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18130) + p.Match(PlSqlParserJSON_EQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18131) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18132) + p.Expressions_() + } + { + p.SetState(18133) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressions_Context is an interface to support dynamic dispatch. +type IExpressions_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpressions_Context differentiates from other interfaces. + IsExpressions_Context() +} + +type Expressions_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressions_Context() *Expressions_Context { + var p = new(Expressions_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expressions_ + return p +} + +func InitEmptyExpressions_Context(p *Expressions_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expressions_ +} + +func (*Expressions_Context) IsExpressions_Context() {} + +func NewExpressions_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expressions_Context { + var p = new(Expressions_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_expressions_ + + return p +} + +func (s *Expressions_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Expressions_Context) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Expressions_Context) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expressions_Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Expressions_Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Expressions_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expressions_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expressions_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExpressions_(s) + } +} + +func (s *Expressions_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExpressions_(s) + } +} + +func (p *PlSqlParser) Expressions_() (localctx IExpressions_Context) { + localctx = NewExpressions_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2076, PlSqlParserRULE_expressions_) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18137) + p.Expression() + } + p.SetState(18142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2517, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(18138) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18139) + p.Expression() + } + + } + p.SetState(18144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2517, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Cursor_expression() ICursor_expressionContext + Logical_expression() ILogical_expressionContext + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) Cursor_expression() ICursor_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_expressionContext) +} + +func (s *ExpressionContext) Logical_expression() ILogical_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogical_expressionContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (p *PlSqlParser) Expression() (localctx IExpressionContext) { + localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2078, PlSqlParserRULE_expression) + p.SetState(18147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2518, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18145) + p.Cursor_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18146) + p.logical_expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_expressionContext is an interface to support dynamic dispatch. +type ICursor_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURSOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCursor_expressionContext differentiates from other interfaces. + IsCursor_expressionContext() +} + +type Cursor_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_expressionContext() *Cursor_expressionContext { + var p = new(Cursor_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_expression + return p +} + +func InitEmptyCursor_expressionContext(p *Cursor_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_expression +} + +func (*Cursor_expressionContext) IsCursor_expressionContext() {} + +func NewCursor_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_expressionContext { + var p = new(Cursor_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_expression + + return p +} + +func (s *Cursor_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_expressionContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Cursor_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_expressionContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Cursor_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_expression(s) + } +} + +func (s *Cursor_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_expression(s) + } +} + +func (p *PlSqlParser) Cursor_expression() (localctx ICursor_expressionContext) { + localctx = NewCursor_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2080, PlSqlParserRULE_cursor_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18149) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18150) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18151) + p.Subquery() + } + { + p.SetState(18152) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogical_expressionContext is an interface to support dynamic dispatch. +type ILogical_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unary_logical_expression() IUnary_logical_expressionContext + AllLogical_expression() []ILogical_expressionContext + Logical_expression(i int) ILogical_expressionContext + AND() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsLogical_expressionContext differentiates from other interfaces. + IsLogical_expressionContext() +} + +type Logical_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_expressionContext() *Logical_expressionContext { + var p = new(Logical_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_expression + return p +} + +func InitEmptyLogical_expressionContext(p *Logical_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_expression +} + +func (*Logical_expressionContext) IsLogical_expressionContext() {} + +func NewLogical_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_expressionContext { + var p = new(Logical_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_expression + + return p +} + +func (s *Logical_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_expressionContext) Unary_logical_expression() IUnary_logical_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_logical_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_logical_expressionContext) +} + +func (s *Logical_expressionContext) AllLogical_expression() []ILogical_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogical_expressionContext); ok { + len++ + } + } + + tst := make([]ILogical_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogical_expressionContext); ok { + tst[i] = t.(ILogical_expressionContext) + i++ + } + } + + return tst +} + +func (s *Logical_expressionContext) Logical_expression(i int) ILogical_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogical_expressionContext) +} + +func (s *Logical_expressionContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Logical_expressionContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Logical_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_expression(s) + } +} + +func (s *Logical_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_expression(s) + } +} + +func (p *PlSqlParser) Logical_expression() (localctx ILogical_expressionContext) { + return p.logical_expression(0) +} + +func (p *PlSqlParser) logical_expression(_p int) (localctx ILogical_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewLogical_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ILogical_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2082 + p.EnterRecursionRule(localctx, 2082, PlSqlParserRULE_logical_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18155) + p.Unary_logical_expression() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(18165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2520, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(18163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2519, p.GetParserRuleContext()) { + case 1: + localctx = NewLogical_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_logical_expression) + p.SetState(18157) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(18158) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18159) + p.logical_expression(3) + } + + case 2: + localctx = NewLogical_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_logical_expression) + p.SetState(18160) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(18161) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18162) + p.logical_expression(2) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(18167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2520, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_logical_expressionContext is an interface to support dynamic dispatch. +type IUnary_logical_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Multiset_expression() IMultiset_expressionContext + NOT() antlr.TerminalNode + Unary_logical_operation() IUnary_logical_operationContext + + // IsUnary_logical_expressionContext differentiates from other interfaces. + IsUnary_logical_expressionContext() +} + +type Unary_logical_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_logical_expressionContext() *Unary_logical_expressionContext { + var p = new(Unary_logical_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_expression + return p +} + +func InitEmptyUnary_logical_expressionContext(p *Unary_logical_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_expression +} + +func (*Unary_logical_expressionContext) IsUnary_logical_expressionContext() {} + +func NewUnary_logical_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_logical_expressionContext { + var p = new(Unary_logical_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_logical_expression + + return p +} + +func (s *Unary_logical_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_logical_expressionContext) Multiset_expression() IMultiset_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiset_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiset_expressionContext) +} + +func (s *Unary_logical_expressionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Unary_logical_expressionContext) Unary_logical_operation() IUnary_logical_operationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_logical_operationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_logical_operationContext) +} + +func (s *Unary_logical_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_logical_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_logical_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_logical_expression(s) + } +} + +func (s *Unary_logical_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_logical_expression(s) + } +} + +func (p *PlSqlParser) Unary_logical_expression() (localctx IUnary_logical_expressionContext) { + localctx = NewUnary_logical_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2084, PlSqlParserRULE_unary_logical_expression) + p.EnterOuterAlt(localctx, 1) + p.SetState(18169) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2521, p.GetParserRuleContext()) == 1 { + { + p.SetState(18168) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18171) + p.multiset_expression(0) + } + p.SetState(18173) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2522, p.GetParserRuleContext()) == 1 { + { + p.SetState(18172) + p.Unary_logical_operation() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_logical_operationContext is an interface to support dynamic dispatch. +type IUnary_logical_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + Logical_operation() ILogical_operationContext + NOT() antlr.TerminalNode + + // IsUnary_logical_operationContext differentiates from other interfaces. + IsUnary_logical_operationContext() +} + +type Unary_logical_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_logical_operationContext() *Unary_logical_operationContext { + var p = new(Unary_logical_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_operation + return p +} + +func InitEmptyUnary_logical_operationContext(p *Unary_logical_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_operation +} + +func (*Unary_logical_operationContext) IsUnary_logical_operationContext() {} + +func NewUnary_logical_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_logical_operationContext { + var p = new(Unary_logical_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_logical_operation + + return p +} + +func (s *Unary_logical_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_logical_operationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Unary_logical_operationContext) Logical_operation() ILogical_operationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_operationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogical_operationContext) +} + +func (s *Unary_logical_operationContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Unary_logical_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_logical_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_logical_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_logical_operation(s) + } +} + +func (s *Unary_logical_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_logical_operation(s) + } +} + +func (p *PlSqlParser) Unary_logical_operation() (localctx IUnary_logical_operationContext) { + localctx = NewUnary_logical_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2086, PlSqlParserRULE_unary_logical_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18175) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(18176) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18179) + p.Logical_operation() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogical_operationContext is an interface to support dynamic dispatch. +type ILogical_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + NAN_() antlr.TerminalNode + PRESENT() antlr.TerminalNode + INFINITE() antlr.TerminalNode + A_LETTER() antlr.TerminalNode + SET() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + OF() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_spec() []IType_specContext + Type_spec(i int) IType_specContext + RIGHT_PAREN() antlr.TerminalNode + AllJSON() []antlr.TerminalNode + JSON(i int) antlr.TerminalNode + TYPE() antlr.TerminalNode + ONLY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FORMAT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + STRICT() antlr.TerminalNode + LAX() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsLogical_operationContext differentiates from other interfaces. + IsLogical_operationContext() +} + +type Logical_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_operationContext() *Logical_operationContext { + var p = new(Logical_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_operation + return p +} + +func InitEmptyLogical_operationContext(p *Logical_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_operation +} + +func (*Logical_operationContext) IsLogical_operationContext() {} + +func NewLogical_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_operationContext { + var p = new(Logical_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_operation + + return p +} + +func (s *Logical_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_operationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Logical_operationContext) NAN_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAN_, 0) +} + +func (s *Logical_operationContext) PRESENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENT, 0) +} + +func (s *Logical_operationContext) INFINITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFINITE, 0) +} + +func (s *Logical_operationContext) A_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserA_LETTER, 0) +} + +func (s *Logical_operationContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Logical_operationContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, 0) +} + +func (s *Logical_operationContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Logical_operationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Logical_operationContext) AllType_spec() []IType_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_specContext); ok { + len++ + } + } + + tst := make([]IType_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_specContext); ok { + tst[i] = t.(IType_specContext) + i++ + } + } + + return tst +} + +func (s *Logical_operationContext) Type_spec(i int) IType_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Logical_operationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Logical_operationContext) AllJSON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserJSON) +} + +func (s *Logical_operationContext) JSON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, i) +} + +func (s *Logical_operationContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Logical_operationContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Logical_operationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logical_operationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logical_operationContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Logical_operationContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Logical_operationContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Logical_operationContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Logical_operationContext) LAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAX, 0) +} + +func (s *Logical_operationContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Logical_operationContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Logical_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_operation(s) + } +} + +func (s *Logical_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_operation(s) + } +} + +func (p *PlSqlParser) Logical_operation() (localctx ILogical_operationContext) { + localctx = NewLogical_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2088, PlSqlParserRULE_logical_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(18181) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNAN_: + { + p.SetState(18182) + p.Match(PlSqlParserNAN_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRESENT: + { + p.SetState(18183) + p.Match(PlSqlParserPRESENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINFINITE: + { + p.SetState(18184) + p.Match(PlSqlParserINFINITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserA_LETTER: + { + p.SetState(18185) + p.Match(PlSqlParserA_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18186) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEMPTY_: + { + p.SetState(18187) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOF: + { + p.SetState(18188) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(18189) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18192) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18194) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2525, p.GetParserRuleContext()) == 1 { + { + p.SetState(18193) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18196) + p.Type_spec() + } + p.SetState(18201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18197) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18198) + p.Type_spec() + } + + p.SetState(18203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18204) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON: + { + p.SetState(18206) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18209) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2527, p.GetParserRuleContext()) == 1 { + { + p.SetState(18207) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18208) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18212) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2528, p.GetParserRuleContext()) == 1 { + { + p.SetState(18211) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLAX || _la == PlSqlParserSTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18217) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2529, p.GetParserRuleContext()) == 1 { + { + p.SetState(18214) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18215) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18216) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultiset_expressionContext is an interface to support dynamic dispatch. +type IMultiset_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMultiset_type returns the multiset_type token. + GetMultiset_type() antlr.Token + + // GetMultiset_operator returns the multiset_operator token. + GetMultiset_operator() antlr.Token + + // SetMultiset_type sets the multiset_type token. + SetMultiset_type(antlr.Token) + + // SetMultiset_operator sets the multiset_operator token. + SetMultiset_operator(antlr.Token) + + // Getter signatures + Relational_expression() IRelational_expressionContext + Concatenation() IConcatenationContext + MEMBER() antlr.TerminalNode + SUBMULTISET() antlr.TerminalNode + OF() antlr.TerminalNode + NOT() antlr.TerminalNode + Multiset_expression() IMultiset_expressionContext + MULTISET() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + UNION() antlr.TerminalNode + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsMultiset_expressionContext differentiates from other interfaces. + IsMultiset_expressionContext() +} + +type Multiset_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + multiset_type antlr.Token + multiset_operator antlr.Token +} + +func NewEmptyMultiset_expressionContext() *Multiset_expressionContext { + var p = new(Multiset_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multiset_expression + return p +} + +func InitEmptyMultiset_expressionContext(p *Multiset_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multiset_expression +} + +func (*Multiset_expressionContext) IsMultiset_expressionContext() {} + +func NewMultiset_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiset_expressionContext { + var p = new(Multiset_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multiset_expression + + return p +} + +func (s *Multiset_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multiset_expressionContext) GetMultiset_type() antlr.Token { return s.multiset_type } + +func (s *Multiset_expressionContext) GetMultiset_operator() antlr.Token { return s.multiset_operator } + +func (s *Multiset_expressionContext) SetMultiset_type(v antlr.Token) { s.multiset_type = v } + +func (s *Multiset_expressionContext) SetMultiset_operator(v antlr.Token) { s.multiset_operator = v } + +func (s *Multiset_expressionContext) Relational_expression() IRelational_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_expressionContext) +} + +func (s *Multiset_expressionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Multiset_expressionContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Multiset_expressionContext) SUBMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBMULTISET, 0) +} + +func (s *Multiset_expressionContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Multiset_expressionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Multiset_expressionContext) Multiset_expression() IMultiset_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiset_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiset_expressionContext) +} + +func (s *Multiset_expressionContext) MULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTISET, 0) +} + +func (s *Multiset_expressionContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Multiset_expressionContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERSECT, 0) +} + +func (s *Multiset_expressionContext) UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNION, 0) +} + +func (s *Multiset_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Multiset_expressionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Multiset_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multiset_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multiset_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMultiset_expression(s) + } +} + +func (s *Multiset_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMultiset_expression(s) + } +} + +func (p *PlSqlParser) Multiset_expression() (localctx IMultiset_expressionContext) { + return p.multiset_expression(0) +} + +func (p *PlSqlParser) multiset_expression(_p int) (localctx IMultiset_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewMultiset_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IMultiset_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2090 + p.EnterRecursionRule(localctx, 2090, PlSqlParserRULE_multiset_expression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18222) + p.relational_expression(0) + } + p.SetState(18231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2533, p.GetParserRuleContext()) == 1 { + p.SetState(18224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(18223) + + var _m = p.Match(PlSqlParserNOT) + + localctx.(*Multiset_expressionContext).multiset_type = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18226) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSUBMULTISET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18228) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2532, p.GetParserRuleContext()) == 1 { + { + p.SetState(18227) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18230) + p.concatenation(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(18242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2535, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewMultiset_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_multiset_expression) + p.SetState(18233) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(18234) + p.Match(PlSqlParserMULTISET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18235) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Multiset_expressionContext).multiset_operator = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCEPT || _la == PlSqlParserINTERSECT || _la == PlSqlParserUNION) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Multiset_expressionContext).multiset_operator = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18237) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2534, p.GetParserRuleContext()) == 1 { + { + p.SetState(18236) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18239) + p.relational_expression(0) + } + + } + p.SetState(18244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2535, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_expressionContext is an interface to support dynamic dispatch. +type IRelational_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Compound_expression() ICompound_expressionContext + AllRelational_expression() []IRelational_expressionContext + Relational_expression(i int) IRelational_expressionContext + Relational_operator() IRelational_operatorContext + IN() antlr.TerminalNode + In_elements() IIn_elementsContext + NOT() antlr.TerminalNode + + // IsRelational_expressionContext differentiates from other interfaces. + IsRelational_expressionContext() +} + +type Relational_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_expressionContext() *Relational_expressionContext { + var p = new(Relational_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_expression + return p +} + +func InitEmptyRelational_expressionContext(p *Relational_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_expression +} + +func (*Relational_expressionContext) IsRelational_expressionContext() {} + +func NewRelational_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_expressionContext { + var p = new(Relational_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_expression + + return p +} + +func (s *Relational_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_expressionContext) Compound_expression() ICompound_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompound_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompound_expressionContext) +} + +func (s *Relational_expressionContext) AllRelational_expression() []IRelational_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_expressionContext); ok { + len++ + } + } + + tst := make([]IRelational_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_expressionContext); ok { + tst[i] = t.(IRelational_expressionContext) + i++ + } + } + + return tst +} + +func (s *Relational_expressionContext) Relational_expression(i int) IRelational_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_expressionContext) +} + +func (s *Relational_expressionContext) Relational_operator() IRelational_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_operatorContext) +} + +func (s *Relational_expressionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Relational_expressionContext) In_elements() IIn_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_elementsContext) +} + +func (s *Relational_expressionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Relational_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_expression(s) + } +} + +func (s *Relational_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_expression(s) + } +} + +func (p *PlSqlParser) Relational_expression() (localctx IRelational_expressionContext) { + return p.relational_expression(0) +} + +func (p *PlSqlParser) relational_expression(_p int) (localctx IRelational_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewRelational_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IRelational_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2092 + p.EnterRecursionRule(localctx, 2092, PlSqlParserRULE_relational_expression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18246) + p.Compound_expression() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(18260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2538, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(18258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2537, p.GetParserRuleContext()) { + case 1: + localctx = NewRelational_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_relational_expression) + p.SetState(18248) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(18249) + p.Relational_operator() + } + { + p.SetState(18250) + p.relational_expression(4) + } + + case 2: + localctx = NewRelational_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_relational_expression) + p.SetState(18252) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + p.SetState(18254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(18253) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18256) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18257) + p.In_elements() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(18262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2538, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompound_expressionContext is an interface to support dynamic dispatch. +type ICompound_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLike_type returns the like_type token. + GetLike_type() antlr.Token + + // SetLike_type sets the like_type token. + SetLike_type(antlr.Token) + + // Getter signatures + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + IN() antlr.TerminalNode + In_elements() IIn_elementsContext + BETWEEN() antlr.TerminalNode + Between_elements() IBetween_elementsContext + NOT() antlr.TerminalNode + LIKE() antlr.TerminalNode + LIKEC() antlr.TerminalNode + LIKE2() antlr.TerminalNode + LIKE4() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + + // IsCompound_expressionContext differentiates from other interfaces. + IsCompound_expressionContext() +} + +type Compound_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + like_type antlr.Token +} + +func NewEmptyCompound_expressionContext() *Compound_expressionContext { + var p = new(Compound_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_expression + return p +} + +func InitEmptyCompound_expressionContext(p *Compound_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_expression +} + +func (*Compound_expressionContext) IsCompound_expressionContext() {} + +func NewCompound_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_expressionContext { + var p = new(Compound_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_expression + + return p +} + +func (s *Compound_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_expressionContext) GetLike_type() antlr.Token { return s.like_type } + +func (s *Compound_expressionContext) SetLike_type(v antlr.Token) { s.like_type = v } + +func (s *Compound_expressionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Compound_expressionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Compound_expressionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Compound_expressionContext) In_elements() IIn_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_elementsContext) +} + +func (s *Compound_expressionContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Compound_expressionContext) Between_elements() IBetween_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_elementsContext) +} + +func (s *Compound_expressionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Compound_expressionContext) LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE, 0) +} + +func (s *Compound_expressionContext) LIKEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKEC, 0) +} + +func (s *Compound_expressionContext) LIKE2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE2, 0) +} + +func (s *Compound_expressionContext) LIKE4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE4, 0) +} + +func (s *Compound_expressionContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESCAPE, 0) +} + +func (s *Compound_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_expression(s) + } +} + +func (s *Compound_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_expression(s) + } +} + +func (p *PlSqlParser) Compound_expression() (localctx ICompound_expressionContext) { + localctx = NewCompound_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2094, PlSqlParserRULE_compound_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18263) + p.concatenation(0) + } + p.SetState(18279) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2542, p.GetParserRuleContext()) == 1 { + p.SetState(18265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(18264) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIN: + { + p.SetState(18267) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18268) + p.In_elements() + } + + case PlSqlParserBETWEEN: + { + p.SetState(18269) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18270) + p.Between_elements() + } + + case PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE: + { + p.SetState(18271) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Compound_expressionContext).like_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-853)) & ^0x3f) == 0 && ((int64(1)<<(_la-853))&23) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Compound_expressionContext).like_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18272) + p.concatenation(0) + } + p.SetState(18275) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2540, p.GetParserRuleContext()) == 1 { + { + p.SetState(18273) + p.Match(PlSqlParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18274) + p.concatenation(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_operatorContext is an interface to support dynamic dispatch. +type IRelational_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUALS_OP() antlr.TerminalNode + NOT_EQUAL_OP() antlr.TerminalNode + LESS_THAN_OP() antlr.TerminalNode + GREATER_THAN_OP() antlr.TerminalNode + EXCLAMATION_OPERATOR_PART() antlr.TerminalNode + CARRET_OPERATOR_PART() antlr.TerminalNode + + // IsRelational_operatorContext differentiates from other interfaces. + IsRelational_operatorContext() +} + +type Relational_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_operatorContext() *Relational_operatorContext { + var p = new(Relational_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_operator + return p +} + +func InitEmptyRelational_operatorContext(p *Relational_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_operator +} + +func (*Relational_operatorContext) IsRelational_operatorContext() {} + +func NewRelational_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_operatorContext { + var p = new(Relational_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_operator + + return p +} + +func (s *Relational_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_operatorContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Relational_operatorContext) NOT_EQUAL_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT_EQUAL_OP, 0) +} + +func (s *Relational_operatorContext) LESS_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS_THAN_OP, 0) +} + +func (s *Relational_operatorContext) GREATER_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, 0) +} + +func (s *Relational_operatorContext) EXCLAMATION_OPERATOR_PART() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLAMATION_OPERATOR_PART, 0) +} + +func (s *Relational_operatorContext) CARRET_OPERATOR_PART() antlr.TerminalNode { + return s.GetToken(PlSqlParserCARRET_OPERATOR_PART, 0) +} + +func (s *Relational_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_operator(s) + } +} + +func (s *Relational_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_operator(s) + } +} + +func (p *PlSqlParser) Relational_operator() (localctx IRelational_operatorContext) { + localctx = NewRelational_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2096, PlSqlParserRULE_relational_operator) + var _la int + + p.SetState(18295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2545, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18281) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(18289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT_EQUAL_OP: + { + p.SetState(18282) + p.Match(PlSqlParserNOT_EQUAL_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLESS_THAN_OP: + { + p.SetState(18283) + p.Match(PlSqlParserLESS_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18284) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLAMATION_OPERATOR_PART: + { + p.SetState(18285) + p.Match(PlSqlParserEXCLAMATION_OPERATOR_PART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18286) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCARRET_OPERATOR_PART: + { + p.SetState(18287) + p.Match(PlSqlParserCARRET_OPERATOR_PART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18288) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18291) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGREATER_THAN_OP || _la == PlSqlParserLESS_THAN_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18293) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2544, p.GetParserRuleContext()) == 1 { + { + p.SetState(18292) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIn_elementsContext is an interface to support dynamic dispatch. +type IIn_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Constant() IConstantContext + Bind_variable() IBind_variableContext + General_element() IGeneral_elementContext + + // IsIn_elementsContext differentiates from other interfaces. + IsIn_elementsContext() +} + +type In_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_elementsContext() *In_elementsContext { + var p = new(In_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_in_elements + return p +} + +func InitEmptyIn_elementsContext(p *In_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_in_elements +} + +func (*In_elementsContext) IsIn_elementsContext() {} + +func NewIn_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_elementsContext { + var p = new(In_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_in_elements + + return p +} + +func (s *In_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *In_elementsContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *In_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *In_elementsContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *In_elementsContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *In_elementsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *In_elementsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *In_elementsContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *In_elementsContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *In_elementsContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *In_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIn_elements(s) + } +} + +func (s *In_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIn_elements(s) + } +} + +func (p *PlSqlParser) In_elements() (localctx IIn_elementsContext) { + localctx = NewIn_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2098, PlSqlParserRULE_in_elements) + var _la int + + p.SetState(18315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2547, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18297) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18298) + p.Subquery() + } + { + p.SetState(18299) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18301) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18302) + p.concatenation(0) + } + p.SetState(18307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18303) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18304) + p.concatenation(0) + } + + p.SetState(18309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18310) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18312) + p.Constant() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18313) + p.Bind_variable() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18314) + p.general_element(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBetween_elementsContext is an interface to support dynamic dispatch. +type IBetween_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AND() antlr.TerminalNode + + // IsBetween_elementsContext differentiates from other interfaces. + IsBetween_elementsContext() +} + +type Between_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBetween_elementsContext() *Between_elementsContext { + var p = new(Between_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_elements + return p +} + +func InitEmptyBetween_elementsContext(p *Between_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_elements +} + +func (*Between_elementsContext) IsBetween_elementsContext() {} + +func NewBetween_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Between_elementsContext { + var p = new(Between_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_between_elements + + return p +} + +func (s *Between_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Between_elementsContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Between_elementsContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Between_elementsContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Between_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Between_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Between_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBetween_elements(s) + } +} + +func (s *Between_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBetween_elements(s) + } +} + +func (p *PlSqlParser) Between_elements() (localctx IBetween_elementsContext) { + localctx = NewBetween_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2100, PlSqlParserRULE_between_elements) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18317) + p.concatenation(0) + } + { + p.SetState(18318) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18319) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConcatenationContext is an interface to support dynamic dispatch. +type IConcatenationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOp returns the op token. + GetOp() antlr.Token + + // SetOp sets the op token. + SetOp(antlr.Token) + + // Getter signatures + Model_expression() IModel_expressionContext + AT() antlr.TerminalNode + Interval_expression() IInterval_expressionContext + ON() antlr.TerminalNode + OVERFLOW_() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + ERROR() antlr.TerminalNode + LOCAL() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + DOUBLE_ASTERISK() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + SOLIDUS() antlr.TerminalNode + MOD() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + MINUS_SIGN() antlr.TerminalNode + AllBAR() []antlr.TerminalNode + BAR(i int) antlr.TerminalNode + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + + // IsConcatenationContext differentiates from other interfaces. + IsConcatenationContext() +} + +type ConcatenationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + op antlr.Token +} + +func NewEmptyConcatenationContext() *ConcatenationContext { + var p = new(ConcatenationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concatenation + return p +} + +func InitEmptyConcatenationContext(p *ConcatenationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concatenation +} + +func (*ConcatenationContext) IsConcatenationContext() {} + +func NewConcatenationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConcatenationContext { + var p = new(ConcatenationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_concatenation + + return p +} + +func (s *ConcatenationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConcatenationContext) GetOp() antlr.Token { return s.op } + +func (s *ConcatenationContext) SetOp(v antlr.Token) { s.op = v } + +func (s *ConcatenationContext) Model_expression() IModel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expressionContext) +} + +func (s *ConcatenationContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *ConcatenationContext) Interval_expression() IInterval_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInterval_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInterval_expressionContext) +} + +func (s *ConcatenationContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *ConcatenationContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *ConcatenationContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *ConcatenationContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *ConcatenationContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *ConcatenationContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *ConcatenationContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *ConcatenationContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *ConcatenationContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *ConcatenationContext) DOUBLE_ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_ASTERISK, 0) +} + +func (s *ConcatenationContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *ConcatenationContext) SOLIDUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOLIDUS, 0) +} + +func (s *ConcatenationContext) MOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOD, 0) +} + +func (s *ConcatenationContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *ConcatenationContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *ConcatenationContext) AllBAR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBAR) +} + +func (s *ConcatenationContext) BAR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBAR, i) +} + +func (s *ConcatenationContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *ConcatenationContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *ConcatenationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConcatenationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConcatenationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConcatenation(s) + } +} + +func (s *ConcatenationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConcatenation(s) + } +} + +func (p *PlSqlParser) Concatenation() (localctx IConcatenationContext) { + return p.concatenation(0) +} + +func (p *PlSqlParser) concatenation(_p int) (localctx IConcatenationContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewConcatenationContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IConcatenationContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2102 + p.EnterRecursionRule(localctx, 2102, PlSqlParserRULE_concatenation, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18322) + p.Model_expression() + } + p.SetState(18331) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2549, p.GetParserRuleContext()) == 1 { + { + p.SetState(18323) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOCAL: + { + p.SetState(18324) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIME: + { + p.SetState(18325) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18326) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18327) + p.concatenation(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2549, p.GetParserRuleContext()) == 2 { + { + p.SetState(18330) + p.Interval_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18336) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2550, p.GetParserRuleContext()) == 1 { + { + p.SetState(18333) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18334) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18335) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserTRUNCATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(18356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2552, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(18354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2551, p.GetParserRuleContext()) { + case 1: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(18338) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(18339) + + var _m = p.Match(PlSqlParserDOUBLE_ASTERISK) + + localctx.(*ConcatenationContext).op = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18340) + p.concatenation(6) + } + + case 2: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(18341) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(18342) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConcatenationContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMOD || _la == PlSqlParserASTERISK || _la == PlSqlParserSOLIDUS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConcatenationContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18343) + p.concatenation(5) + } + + case 3: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(18344) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(18345) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConcatenationContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConcatenationContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18346) + p.concatenation(4) + } + + case 4: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(18347) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(18348) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18349) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18350) + p.concatenation(3) + } + + case 5: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(18351) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(18352) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18353) + p.Column_collation_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(18358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2552, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInterval_expressionContext is an interface to support dynamic dispatch. +type IInterval_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DAY() antlr.TerminalNode + TO() antlr.TerminalNode + SECOND() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + + // IsInterval_expressionContext differentiates from other interfaces. + IsInterval_expressionContext() +} + +type Interval_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInterval_expressionContext() *Interval_expressionContext { + var p = new(Interval_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expression + return p +} + +func InitEmptyInterval_expressionContext(p *Interval_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expression +} + +func (*Interval_expressionContext) IsInterval_expressionContext() {} + +func NewInterval_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_expressionContext { + var p = new(Interval_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_interval_expression + + return p +} + +func (s *Interval_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Interval_expressionContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Interval_expressionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Interval_expressionContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Interval_expressionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Interval_expressionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Interval_expressionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Interval_expressionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Interval_expressionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Interval_expressionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Interval_expressionContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Interval_expressionContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Interval_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Interval_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Interval_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInterval_expression(s) + } +} + +func (s *Interval_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInterval_expression(s) + } +} + +func (p *PlSqlParser) Interval_expression() (localctx IInterval_expressionContext) { + localctx = NewInterval_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2104, PlSqlParserRULE_interval_expression) + var _la int + + p.SetState(18383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDAY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18359) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18360) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18361) + p.concatenation(0) + } + { + p.SetState(18362) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18366) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18367) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18372) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2554, p.GetParserRuleContext()) == 1 { + { + p.SetState(18368) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18369) + p.concatenation(0) + } + { + p.SetState(18370) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserYEAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18374) + p.Match(PlSqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18375) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18376) + p.concatenation(0) + } + { + p.SetState(18377) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18381) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18382) + p.Match(PlSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_expressionContext is an interface to support dynamic dispatch. +type IModel_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unary_expression() IUnary_expressionContext + LEFT_BRACKET() antlr.TerminalNode + Model_expression_element() IModel_expression_elementContext + RIGHT_BRACKET() antlr.TerminalNode + MINUS_SIGN() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + + // IsModel_expressionContext differentiates from other interfaces. + IsModel_expressionContext() +} + +type Model_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_expressionContext() *Model_expressionContext { + var p = new(Model_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression + return p +} + +func InitEmptyModel_expressionContext(p *Model_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression +} + +func (*Model_expressionContext) IsModel_expressionContext() {} + +func NewModel_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_expressionContext { + var p = new(Model_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_expression + + return p +} + +func (s *Model_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_expressionContext) Unary_expression() IUnary_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_expressionContext) +} + +func (s *Model_expressionContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *Model_expressionContext) Model_expression_element() IModel_expression_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expression_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expression_elementContext) +} + +func (s *Model_expressionContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *Model_expressionContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *Model_expressionContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *Model_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_expression(s) + } +} + +func (s *Model_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_expression(s) + } +} + +func (p *PlSqlParser) Model_expression() (localctx IModel_expressionContext) { + localctx = NewModel_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2106, PlSqlParserRULE_model_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18386) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2557, p.GetParserRuleContext()) == 1 { + { + p.SetState(18385) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18388) + p.Unary_expression() + } + p.SetState(18393) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2558, p.GetParserRuleContext()) == 1 { + { + p.SetState(18389) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18390) + p.Model_expression_element() + } + { + p.SetState(18391) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_expression_elementContext is an interface to support dynamic dispatch. +type IModel_expression_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSingle_column_for_loop() []ISingle_column_for_loopContext + Single_column_for_loop(i int) ISingle_column_for_loopContext + Multi_column_for_loop() IMulti_column_for_loopContext + + // IsModel_expression_elementContext differentiates from other interfaces. + IsModel_expression_elementContext() +} + +type Model_expression_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_expression_elementContext() *Model_expression_elementContext { + var p = new(Model_expression_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression_element + return p +} + +func InitEmptyModel_expression_elementContext(p *Model_expression_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression_element +} + +func (*Model_expression_elementContext) IsModel_expression_elementContext() {} + +func NewModel_expression_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_expression_elementContext { + var p = new(Model_expression_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_expression_element + + return p +} + +func (s *Model_expression_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_expression_elementContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserANY) +} + +func (s *Model_expression_elementContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, i) +} + +func (s *Model_expression_elementContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Model_expression_elementContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_expression_elementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_expression_elementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_expression_elementContext) AllSingle_column_for_loop() []ISingle_column_for_loopContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + len++ + } + } + + tst := make([]ISingle_column_for_loopContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISingle_column_for_loopContext); ok { + tst[i] = t.(ISingle_column_for_loopContext) + i++ + } + } + + return tst +} + +func (s *Model_expression_elementContext) Single_column_for_loop(i int) ISingle_column_for_loopContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISingle_column_for_loopContext) +} + +func (s *Model_expression_elementContext) Multi_column_for_loop() IMulti_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_column_for_loopContext) +} + +func (s *Model_expression_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_expression_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_expression_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_expression_element(s) + } +} + +func (s *Model_expression_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_expression_element(s) + } +} + +func (p *PlSqlParser) Model_expression_element() (localctx IModel_expression_elementContext) { + localctx = NewModel_expression_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2108, PlSqlParserRULE_model_expression_element) + var _la int + + p.SetState(18418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2563, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(18397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2559, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18395) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18396) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18399) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2560, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18400) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18401) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(18408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18409) + p.Single_column_for_loop() + } + p.SetState(18414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18410) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18411) + p.Single_column_for_loop() + } + + p.SetState(18416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18417) + p.Multi_column_for_loop() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_column_for_loopContext is an interface to support dynamic dispatch. +type ISingle_column_for_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAction_type returns the action_type token. + GetAction_type() antlr.Token + + // SetAction_type sets the action_type token. + SetAction_type(antlr.Token) + + // GetFromExpr returns the fromExpr rule contexts. + GetFromExpr() IExpressionContext + + // GetToExpr returns the toExpr rule contexts. + GetToExpr() IExpressionContext + + // GetAction_expr returns the action_expr rule contexts. + GetAction_expr() IExpressionContext + + // SetFromExpr sets the fromExpr rule contexts. + SetFromExpr(IExpressionContext) + + // SetToExpr sets the toExpr rule contexts. + SetToExpr(IExpressionContext) + + // SetAction_expr sets the action_expr rule contexts. + SetAction_expr(IExpressionContext) + + // Getter signatures + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FROM() antlr.TerminalNode + TO() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + INCREMENT() antlr.TerminalNode + DECREMENT() antlr.TerminalNode + Expressions_() IExpressions_Context + LIKE() antlr.TerminalNode + + // IsSingle_column_for_loopContext differentiates from other interfaces. + IsSingle_column_for_loopContext() +} + +type Single_column_for_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fromExpr IExpressionContext + toExpr IExpressionContext + action_type antlr.Token + action_expr IExpressionContext +} + +func NewEmptySingle_column_for_loopContext() *Single_column_for_loopContext { + var p = new(Single_column_for_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_column_for_loop + return p +} + +func InitEmptySingle_column_for_loopContext(p *Single_column_for_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_column_for_loop +} + +func (*Single_column_for_loopContext) IsSingle_column_for_loopContext() {} + +func NewSingle_column_for_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_column_for_loopContext { + var p = new(Single_column_for_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_single_column_for_loop + + return p +} + +func (s *Single_column_for_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_column_for_loopContext) GetAction_type() antlr.Token { return s.action_type } + +func (s *Single_column_for_loopContext) SetAction_type(v antlr.Token) { s.action_type = v } + +func (s *Single_column_for_loopContext) GetFromExpr() IExpressionContext { return s.fromExpr } + +func (s *Single_column_for_loopContext) GetToExpr() IExpressionContext { return s.toExpr } + +func (s *Single_column_for_loopContext) GetAction_expr() IExpressionContext { return s.action_expr } + +func (s *Single_column_for_loopContext) SetFromExpr(v IExpressionContext) { s.fromExpr = v } + +func (s *Single_column_for_loopContext) SetToExpr(v IExpressionContext) { s.toExpr = v } + +func (s *Single_column_for_loopContext) SetAction_expr(v IExpressionContext) { s.action_expr = v } + +func (s *Single_column_for_loopContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Single_column_for_loopContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Single_column_for_loopContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Single_column_for_loopContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Single_column_for_loopContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Single_column_for_loopContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Single_column_for_loopContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Single_column_for_loopContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Single_column_for_loopContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Single_column_for_loopContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Single_column_for_loopContext) DECREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECREMENT, 0) +} + +func (s *Single_column_for_loopContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Single_column_for_loopContext) LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE, 0) +} + +func (s *Single_column_for_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_column_for_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_column_for_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSingle_column_for_loop(s) + } +} + +func (s *Single_column_for_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSingle_column_for_loop(s) + } +} + +func (p *PlSqlParser) Single_column_for_loop() (localctx ISingle_column_for_loopContext) { + localctx = NewSingle_column_for_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2110, PlSqlParserRULE_single_column_for_loop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18420) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18421) + p.Column_name() + } + p.SetState(18439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIN: + { + p.SetState(18422) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18423) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18425) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2564, p.GetParserRuleContext()) == 1 { + { + p.SetState(18424) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18427) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFROM, PlSqlParserLIKE: + p.SetState(18430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLIKE { + { + p.SetState(18428) + p.Match(PlSqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18429) + p.Expression() + } + + } + { + p.SetState(18432) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18433) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).fromExpr = _x + } + { + p.SetState(18434) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18435) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).toExpr = _x + } + { + p.SetState(18436) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Single_column_for_loopContext).action_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECREMENT || _la == PlSqlParserINCREMENT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Single_column_for_loopContext).action_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18437) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).action_expr = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMulti_column_for_loopContext is an interface to support dynamic dispatch. +type IMulti_column_for_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + IN() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Subquery() ISubqueryContext + Expressions_() IExpressions_Context + + // IsMulti_column_for_loopContext differentiates from other interfaces. + IsMulti_column_for_loopContext() +} + +type Multi_column_for_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_column_for_loopContext() *Multi_column_for_loopContext { + var p = new(Multi_column_for_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop + return p +} + +func InitEmptyMulti_column_for_loopContext(p *Multi_column_for_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop +} + +func (*Multi_column_for_loopContext) IsMulti_column_for_loopContext() {} + +func NewMulti_column_for_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_column_for_loopContext { + var p = new(Multi_column_for_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop + + return p +} + +func (s *Multi_column_for_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_column_for_loopContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Multi_column_for_loopContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Multi_column_for_loopContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Multi_column_for_loopContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Multi_column_for_loopContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Multi_column_for_loopContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Multi_column_for_loopContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Multi_column_for_loopContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Multi_column_for_loopContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Multi_column_for_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_column_for_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_column_for_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_column_for_loop(s) + } +} + +func (s *Multi_column_for_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_column_for_loop(s) + } +} + +func (p *PlSqlParser) Multi_column_for_loop() (localctx IMulti_column_for_loopContext) { + localctx = NewMulti_column_for_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2112, PlSqlParserRULE_multi_column_for_loop) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18441) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18442) + p.Paren_column_list() + } + { + p.SetState(18443) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18444) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2568, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18445) + p.Subquery() + } + + case 2: + { + p.SetState(18446) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18448) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2567, p.GetParserRuleContext()) == 1 { + { + p.SetState(18447) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18450) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(18453) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_expressionContext is an interface to support dynamic dispatch. +type IUnary_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_expression returns the _expression rule contexts. + Get_expression() IExpressionContext + + // Set_expression sets the _expression rule contexts. + Set_expression(IExpressionContext) + + // GetIndex returns the index rule context list. + GetIndex() []IExpressionContext + + // SetIndex sets the index rule context list. + SetIndex([]IExpressionContext) + + // Getter signatures + PRIOR() antlr.TerminalNode + Unary_expression_core() IUnary_expression_coreContext + CONNECT_BY_ROOT() antlr.TerminalNode + NEW() antlr.TerminalNode + OLD() antlr.TerminalNode + PERIOD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + COUNT() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + LIMIT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + NEXT() antlr.TerminalNode + Expression() IExpressionContext + + // IsUnary_expressionContext differentiates from other interfaces. + IsUnary_expressionContext() +} + +type Unary_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _expression IExpressionContext + index []IExpressionContext +} + +func NewEmptyUnary_expressionContext() *Unary_expressionContext { + var p = new(Unary_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression + return p +} + +func InitEmptyUnary_expressionContext(p *Unary_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression +} + +func (*Unary_expressionContext) IsUnary_expressionContext() {} + +func NewUnary_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_expressionContext { + var p = new(Unary_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_expression + + return p +} + +func (s *Unary_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_expressionContext) Get_expression() IExpressionContext { return s._expression } + +func (s *Unary_expressionContext) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *Unary_expressionContext) GetIndex() []IExpressionContext { return s.index } + +func (s *Unary_expressionContext) SetIndex(v []IExpressionContext) { s.index = v } + +func (s *Unary_expressionContext) PRIOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIOR, 0) +} + +func (s *Unary_expressionContext) Unary_expression_core() IUnary_expression_coreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_expression_coreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_expression_coreContext) +} + +func (s *Unary_expressionContext) CONNECT_BY_ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ROOT, 0) +} + +func (s *Unary_expressionContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Unary_expressionContext) OLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD, 0) +} + +func (s *Unary_expressionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Unary_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unary_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unary_expressionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Unary_expressionContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Unary_expressionContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Unary_expressionContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Unary_expressionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Unary_expressionContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Unary_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Unary_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_expression(s) + } +} + +func (s *Unary_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_expression(s) + } +} + +func (p *PlSqlParser) Unary_expression() (localctx IUnary_expressionContext) { + localctx = NewUnary_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2114, PlSqlParserRULE_unary_expression) + var _la int + + p.SetState(18475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2571, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18455) + p.Match(PlSqlParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18456) + p.Unary_expression_core() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18457) + p.Match(PlSqlParserCONNECT_BY_ROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18458) + p.Unary_expression_core() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18459) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18460) + p.Unary_expression_core() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18461) + p.Match(PlSqlParserOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18462) + p.Unary_expression_core() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18463) + p.Unary_expression_core() + } + p.SetState(18473) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2570, p.GetParserRuleContext()) == 1 { + { + p.SetState(18464) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOUNT, PlSqlParserFIRST, PlSqlParserLAST, PlSqlParserLIMIT: + { + p.SetState(18465) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOUNT || _la == PlSqlParserFIRST || _la == PlSqlParserLAST || _la == PlSqlParserLIMIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserEXISTS, PlSqlParserNEXT, PlSqlParserPRIOR: + { + p.SetState(18466) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXISTS || _la == PlSqlParserNEXT || _la == PlSqlParserPRIOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18467) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18468) + + var _x = p.Expression() + + localctx.(*Unary_expressionContext)._expression = _x + } + localctx.(*Unary_expressionContext).index = append(localctx.(*Unary_expressionContext).index, localctx.(*Unary_expressionContext)._expression) + { + p.SetState(18469) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_expression_coreContext is an interface to support dynamic dispatch. +type IUnary_expression_coreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Case_expression() ICase_expressionContext + Quantified_expression() IQuantified_expressionContext + Standard_function() IStandard_functionContext + Atom() IAtomContext + Implicit_cursor_expression() IImplicit_cursor_expressionContext + + // IsUnary_expression_coreContext differentiates from other interfaces. + IsUnary_expression_coreContext() +} + +type Unary_expression_coreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_expression_coreContext() *Unary_expression_coreContext { + var p = new(Unary_expression_coreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression_core + return p +} + +func InitEmptyUnary_expression_coreContext(p *Unary_expression_coreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression_core +} + +func (*Unary_expression_coreContext) IsUnary_expression_coreContext() {} + +func NewUnary_expression_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_expression_coreContext { + var p = new(Unary_expression_coreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_expression_core + + return p +} + +func (s *Unary_expression_coreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_expression_coreContext) Case_expression() ICase_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expressionContext) +} + +func (s *Unary_expression_coreContext) Quantified_expression() IQuantified_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuantified_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuantified_expressionContext) +} + +func (s *Unary_expression_coreContext) Standard_function() IStandard_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_functionContext) +} + +func (s *Unary_expression_coreContext) Atom() IAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAtomContext) +} + +func (s *Unary_expression_coreContext) Implicit_cursor_expression() IImplicit_cursor_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplicit_cursor_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplicit_cursor_expressionContext) +} + +func (s *Unary_expression_coreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_expression_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_expression_coreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_expression_core(s) + } +} + +func (s *Unary_expression_coreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_expression_core(s) + } +} + +func (p *PlSqlParser) Unary_expression_core() (localctx IUnary_expression_coreContext) { + localctx = NewUnary_expression_coreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2116, PlSqlParserRULE_unary_expression_core) + p.SetState(18483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2572, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18477) + p.Case_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18478) + p.Quantified_expression() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18479) + p.Standard_function() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(18480) + + if !(p.IsNotNumericFunction()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.IsNotNumericFunction()", "")) + goto errorExit + } + { + p.SetState(18481) + p.Atom() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18482) + p.Implicit_cursor_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImplicit_cursor_expressionContext is an interface to support dynamic dispatch. +type IImplicit_cursor_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndex returns the index rule contexts. + GetIndex() IExpressionContext + + // SetIndex sets the index rule contexts. + SetIndex(IExpressionContext) + + // Getter signatures + SQL() antlr.TerminalNode + PERCENT_BULK_ROWCOUNT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + PERCENT_BULK_EXCEPTIONS() antlr.TerminalNode + Expression() IExpressionContext + PERIOD() antlr.TerminalNode + COUNT() antlr.TerminalNode + ERROR_INDEX() antlr.TerminalNode + ERROR_CODE() antlr.TerminalNode + + // IsImplicit_cursor_expressionContext differentiates from other interfaces. + IsImplicit_cursor_expressionContext() +} + +type Implicit_cursor_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + index IExpressionContext +} + +func NewEmptyImplicit_cursor_expressionContext() *Implicit_cursor_expressionContext { + var p = new(Implicit_cursor_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implicit_cursor_expression + return p +} + +func InitEmptyImplicit_cursor_expressionContext(p *Implicit_cursor_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implicit_cursor_expression +} + +func (*Implicit_cursor_expressionContext) IsImplicit_cursor_expressionContext() {} + +func NewImplicit_cursor_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implicit_cursor_expressionContext { + var p = new(Implicit_cursor_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_implicit_cursor_expression + + return p +} + +func (s *Implicit_cursor_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implicit_cursor_expressionContext) GetIndex() IExpressionContext { return s.index } + +func (s *Implicit_cursor_expressionContext) SetIndex(v IExpressionContext) { s.index = v } + +func (s *Implicit_cursor_expressionContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Implicit_cursor_expressionContext) PERCENT_BULK_ROWCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_BULK_ROWCOUNT, 0) +} + +func (s *Implicit_cursor_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Implicit_cursor_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Implicit_cursor_expressionContext) PERCENT_BULK_EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_BULK_EXCEPTIONS, 0) +} + +func (s *Implicit_cursor_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Implicit_cursor_expressionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Implicit_cursor_expressionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Implicit_cursor_expressionContext) ERROR_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_INDEX, 0) +} + +func (s *Implicit_cursor_expressionContext) ERROR_CODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_CODE, 0) +} + +func (s *Implicit_cursor_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implicit_cursor_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implicit_cursor_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImplicit_cursor_expression(s) + } +} + +func (s *Implicit_cursor_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImplicit_cursor_expression(s) + } +} + +func (p *PlSqlParser) Implicit_cursor_expression() (localctx IImplicit_cursor_expressionContext) { + localctx = NewImplicit_cursor_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2118, PlSqlParserRULE_implicit_cursor_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18485) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPERCENT_BULK_ROWCOUNT: + { + p.SetState(18486) + p.Match(PlSqlParserPERCENT_BULK_ROWCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18487) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18488) + + var _x = p.Expression() + + localctx.(*Implicit_cursor_expressionContext).index = _x + } + { + p.SetState(18489) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPERCENT_BULK_EXCEPTIONS: + { + p.SetState(18491) + p.Match(PlSqlParserPERCENT_BULK_EXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPERIOD: + { + p.SetState(18492) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18493) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(18494) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18495) + p.Expression() + } + { + p.SetState(18496) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18497) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18498) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR_INDEX || _la == PlSqlParserERROR_CODE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollection_expressionContext is an interface to support dynamic dispatch. +type ICollection_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collation_name() ICollation_nameContext + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllGeneral_element_part() []IGeneral_element_partContext + General_element_part(i int) IGeneral_element_partContext + + // IsCollection_expressionContext differentiates from other interfaces. + IsCollection_expressionContext() +} + +type Collection_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollection_expressionContext() *Collection_expressionContext { + var p = new(Collection_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_expression + return p +} + +func InitEmptyCollection_expressionContext(p *Collection_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_expression +} + +func (*Collection_expressionContext) IsCollection_expressionContext() {} + +func NewCollection_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collection_expressionContext { + var p = new(Collection_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collection_expression + + return p +} + +func (s *Collection_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collection_expressionContext) Collation_name() ICollation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollation_nameContext) +} + +func (s *Collection_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Collection_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Collection_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Collection_expressionContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Collection_expressionContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Collection_expressionContext) AllGeneral_element_part() []IGeneral_element_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_element_partContext); ok { + len++ + } + } + + tst := make([]IGeneral_element_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_element_partContext); ok { + tst[i] = t.(IGeneral_element_partContext) + i++ + } + } + + return tst +} + +func (s *Collection_expressionContext) General_element_part(i int) IGeneral_element_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *Collection_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collection_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collection_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollection_expression(s) + } +} + +func (s *Collection_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollection_expression(s) + } +} + +func (p *PlSqlParser) Collection_expression() (localctx ICollection_expressionContext) { + localctx = NewCollection_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2120, PlSqlParserRULE_collection_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18504) + p.Collation_name() + } + { + p.SetState(18505) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18506) + p.Expression() + } + { + p.SetState(18507) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(18508) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18509) + p.General_element_part() + } + + p.SetState(18514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_statementContext is an interface to support dynamic dispatch. +type ICase_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Searched_case_statement() ISearched_case_statementContext + Simple_case_statement() ISimple_case_statementContext + + // IsCase_statementContext differentiates from other interfaces. + IsCase_statementContext() +} + +type Case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_statementContext() *Case_statementContext { + var p = new(Case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_statement + return p +} + +func InitEmptyCase_statementContext(p *Case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_statement +} + +func (*Case_statementContext) IsCase_statementContext() {} + +func NewCase_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_statementContext { + var p = new(Case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_statement + + return p +} + +func (s *Case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_statementContext) Searched_case_statement() ISearched_case_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearched_case_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearched_case_statementContext) +} + +func (s *Case_statementContext) Simple_case_statement() ISimple_case_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_case_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_case_statementContext) +} + +func (s *Case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_statement(s) + } +} + +func (s *Case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_statement(s) + } +} + +func (p *PlSqlParser) Case_statement() (localctx ICase_statementContext) { + localctx = NewCase_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2122, PlSqlParserRULE_case_statement) + p.SetState(18517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2576, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18515) + p.Searched_case_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18516) + p.Simple_case_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_case_statementContext is an interface to support dynamic dispatch. +type ISimple_case_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + Label_declaration() ILabel_declarationContext + AllCase_when_part_statement() []ICase_when_part_statementContext + Case_when_part_statement(i int) ICase_when_part_statementContext + Case_else_part_statement() ICase_else_part_statementContext + Label_name() ILabel_nameContext + + // IsSimple_case_statementContext differentiates from other interfaces. + IsSimple_case_statementContext() +} + +type Simple_case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySimple_case_statementContext() *Simple_case_statementContext { + var p = new(Simple_case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_statement + return p +} + +func InitEmptySimple_case_statementContext(p *Simple_case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_statement +} + +func (*Simple_case_statementContext) IsSimple_case_statementContext() {} + +func NewSimple_case_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_case_statementContext { + var p = new(Simple_case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_case_statement + + return p +} + +func (s *Simple_case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_case_statementContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Simple_case_statementContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Simple_case_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Simple_case_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Simple_case_statementContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Simple_case_statementContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Simple_case_statementContext) Label_declaration() ILabel_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Simple_case_statementContext) AllCase_when_part_statement() []ICase_when_part_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICase_when_part_statementContext); ok { + len++ + } + } + + tst := make([]ICase_when_part_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICase_when_part_statementContext); ok { + tst[i] = t.(ICase_when_part_statementContext) + i++ + } + } + + return tst +} + +func (s *Simple_case_statementContext) Case_when_part_statement(i int) ICase_when_part_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_when_part_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICase_when_part_statementContext) +} + +func (s *Simple_case_statementContext) Case_else_part_statement() ICase_else_part_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_part_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_part_statementContext) +} + +func (s *Simple_case_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Simple_case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_case_statement(s) + } +} + +func (s *Simple_case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_case_statement(s) + } +} + +func (p *PlSqlParser) Simple_case_statement() (localctx ISimple_case_statementContext) { + localctx = NewSimple_case_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2124, PlSqlParserRULE_simple_case_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLESS_THAN_OP { + { + p.SetState(18519) + p.Label_declaration() + } + + } + { + p.SetState(18522) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Simple_case_statementContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18523) + p.Expression() + } + p.SetState(18525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(18524) + p.Case_when_part_statement() + } + + p.SetState(18527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(18530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(18529) + p.Case_else_part_statement() + } + + } + { + p.SetState(18532) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18534) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2580, p.GetParserRuleContext()) == 1 { + { + p.SetState(18533) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(18536) + p.Label_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearched_case_statementContext is an interface to support dynamic dispatch. +type ISearched_case_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + Label_declaration() ILabel_declarationContext + AllCase_when_part_statement() []ICase_when_part_statementContext + Case_when_part_statement(i int) ICase_when_part_statementContext + Case_else_part_statement() ICase_else_part_statementContext + Label_name() ILabel_nameContext + + // IsSearched_case_statementContext differentiates from other interfaces. + IsSearched_case_statementContext() +} + +type Searched_case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySearched_case_statementContext() *Searched_case_statementContext { + var p = new(Searched_case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_statement + return p +} + +func InitEmptySearched_case_statementContext(p *Searched_case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_statement +} + +func (*Searched_case_statementContext) IsSearched_case_statementContext() {} + +func NewSearched_case_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Searched_case_statementContext { + var p = new(Searched_case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_searched_case_statement + + return p +} + +func (s *Searched_case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Searched_case_statementContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Searched_case_statementContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Searched_case_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Searched_case_statementContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Searched_case_statementContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Searched_case_statementContext) Label_declaration() ILabel_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Searched_case_statementContext) AllCase_when_part_statement() []ICase_when_part_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICase_when_part_statementContext); ok { + len++ + } + } + + tst := make([]ICase_when_part_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICase_when_part_statementContext); ok { + tst[i] = t.(ICase_when_part_statementContext) + i++ + } + } + + return tst +} + +func (s *Searched_case_statementContext) Case_when_part_statement(i int) ICase_when_part_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_when_part_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICase_when_part_statementContext) +} + +func (s *Searched_case_statementContext) Case_else_part_statement() ICase_else_part_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_part_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_part_statementContext) +} + +func (s *Searched_case_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Searched_case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Searched_case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Searched_case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearched_case_statement(s) + } +} + +func (s *Searched_case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearched_case_statement(s) + } +} + +func (p *PlSqlParser) Searched_case_statement() (localctx ISearched_case_statementContext) { + localctx = NewSearched_case_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2126, PlSqlParserRULE_searched_case_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLESS_THAN_OP { + { + p.SetState(18539) + p.Label_declaration() + } + + } + { + p.SetState(18542) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Searched_case_statementContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(18543) + p.Case_when_part_statement() + } + + p.SetState(18546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(18549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(18548) + p.Case_else_part_statement() + } + + } + { + p.SetState(18551) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18553) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2585, p.GetParserRuleContext()) == 1 { + { + p.SetState(18552) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080233) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&35184372089377) != 0) { + { + p.SetState(18555) + p.Label_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_when_part_statementContext is an interface to support dynamic dispatch. +type ICase_when_part_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Expression() IExpressionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsCase_when_part_statementContext differentiates from other interfaces. + IsCase_when_part_statementContext() +} + +type Case_when_part_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_when_part_statementContext() *Case_when_part_statementContext { + var p = new(Case_when_part_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_when_part_statement + return p +} + +func InitEmptyCase_when_part_statementContext(p *Case_when_part_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_when_part_statement +} + +func (*Case_when_part_statementContext) IsCase_when_part_statementContext() {} + +func NewCase_when_part_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_when_part_statementContext { + var p = new(Case_when_part_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_when_part_statement + + return p +} + +func (s *Case_when_part_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_when_part_statementContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Case_when_part_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_when_part_statementContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Case_when_part_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Case_when_part_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_when_part_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_when_part_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_when_part_statement(s) + } +} + +func (s *Case_when_part_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_when_part_statement(s) + } +} + +func (p *PlSqlParser) Case_when_part_statement() (localctx ICase_when_part_statementContext) { + localctx = NewCase_when_part_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2128, PlSqlParserRULE_case_when_part_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18558) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18559) + p.Expression() + } + { + p.SetState(18560) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18561) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_else_part_statementContext is an interface to support dynamic dispatch. +type ICase_else_part_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsCase_else_part_statementContext differentiates from other interfaces. + IsCase_else_part_statementContext() +} + +type Case_else_part_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_else_part_statementContext() *Case_else_part_statementContext { + var p = new(Case_else_part_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part_statement + return p +} + +func InitEmptyCase_else_part_statementContext(p *Case_else_part_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part_statement +} + +func (*Case_else_part_statementContext) IsCase_else_part_statementContext() {} + +func NewCase_else_part_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_else_part_statementContext { + var p = new(Case_else_part_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_else_part_statement + + return p +} + +func (s *Case_else_part_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_else_part_statementContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Case_else_part_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Case_else_part_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_else_part_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_else_part_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_else_part_statement(s) + } +} + +func (s *Case_else_part_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_else_part_statement(s) + } +} + +func (p *PlSqlParser) Case_else_part_statement() (localctx ICase_else_part_statementContext) { + localctx = NewCase_else_part_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2130, PlSqlParserRULE_case_else_part_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18563) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18564) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_expressionContext is an interface to support dynamic dispatch. +type ICase_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Searched_case_expression() ISearched_case_expressionContext + Simple_case_expression() ISimple_case_expressionContext + + // IsCase_expressionContext differentiates from other interfaces. + IsCase_expressionContext() +} + +type Case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_expressionContext() *Case_expressionContext { + var p = new(Case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_expression + return p +} + +func InitEmptyCase_expressionContext(p *Case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_expression +} + +func (*Case_expressionContext) IsCase_expressionContext() {} + +func NewCase_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expressionContext { + var p = new(Case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_expression + + return p +} + +func (s *Case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_expressionContext) Searched_case_expression() ISearched_case_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearched_case_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearched_case_expressionContext) +} + +func (s *Case_expressionContext) Simple_case_expression() ISimple_case_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_case_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_case_expressionContext) +} + +func (s *Case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_expression(s) + } +} + +func (s *Case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_expression(s) + } +} + +func (p *PlSqlParser) Case_expression() (localctx ICase_expressionContext) { + localctx = NewCase_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2132, PlSqlParserRULE_case_expression) + p.SetState(18568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2587, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18566) + p.Searched_case_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18567) + p.Simple_case_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_case_expressionContext is an interface to support dynamic dispatch. +type ISimple_case_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + AllCase_when_part_expression() []ICase_when_part_expressionContext + Case_when_part_expression(i int) ICase_when_part_expressionContext + Case_else_part_expression() ICase_else_part_expressionContext + + // IsSimple_case_expressionContext differentiates from other interfaces. + IsSimple_case_expressionContext() +} + +type Simple_case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySimple_case_expressionContext() *Simple_case_expressionContext { + var p = new(Simple_case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_expression + return p +} + +func InitEmptySimple_case_expressionContext(p *Simple_case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_expression +} + +func (*Simple_case_expressionContext) IsSimple_case_expressionContext() {} + +func NewSimple_case_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_case_expressionContext { + var p = new(Simple_case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_case_expression + + return p +} + +func (s *Simple_case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_case_expressionContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Simple_case_expressionContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Simple_case_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Simple_case_expressionContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Simple_case_expressionContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Simple_case_expressionContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Simple_case_expressionContext) AllCase_when_part_expression() []ICase_when_part_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICase_when_part_expressionContext); ok { + len++ + } + } + + tst := make([]ICase_when_part_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICase_when_part_expressionContext); ok { + tst[i] = t.(ICase_when_part_expressionContext) + i++ + } + } + + return tst +} + +func (s *Simple_case_expressionContext) Case_when_part_expression(i int) ICase_when_part_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_when_part_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICase_when_part_expressionContext) +} + +func (s *Simple_case_expressionContext) Case_else_part_expression() ICase_else_part_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_part_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_part_expressionContext) +} + +func (s *Simple_case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_case_expression(s) + } +} + +func (s *Simple_case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_case_expression(s) + } +} + +func (p *PlSqlParser) Simple_case_expression() (localctx ISimple_case_expressionContext) { + localctx = NewSimple_case_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2134, PlSqlParserRULE_simple_case_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18570) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Simple_case_expressionContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18571) + p.Expression() + } + p.SetState(18573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(18572) + p.Case_when_part_expression() + } + + p.SetState(18575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(18578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(18577) + p.Case_else_part_expression() + } + + } + { + p.SetState(18580) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2590, p.GetParserRuleContext()) == 1 { + { + p.SetState(18581) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearched_case_expressionContext is an interface to support dynamic dispatch. +type ISearched_case_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + AllCase_when_part_expression() []ICase_when_part_expressionContext + Case_when_part_expression(i int) ICase_when_part_expressionContext + Case_else_part_expression() ICase_else_part_expressionContext + + // IsSearched_case_expressionContext differentiates from other interfaces. + IsSearched_case_expressionContext() +} + +type Searched_case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySearched_case_expressionContext() *Searched_case_expressionContext { + var p = new(Searched_case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_expression + return p +} + +func InitEmptySearched_case_expressionContext(p *Searched_case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_expression +} + +func (*Searched_case_expressionContext) IsSearched_case_expressionContext() {} + +func NewSearched_case_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Searched_case_expressionContext { + var p = new(Searched_case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_searched_case_expression + + return p +} + +func (s *Searched_case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Searched_case_expressionContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Searched_case_expressionContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Searched_case_expressionContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Searched_case_expressionContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Searched_case_expressionContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Searched_case_expressionContext) AllCase_when_part_expression() []ICase_when_part_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICase_when_part_expressionContext); ok { + len++ + } + } + + tst := make([]ICase_when_part_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICase_when_part_expressionContext); ok { + tst[i] = t.(ICase_when_part_expressionContext) + i++ + } + } + + return tst +} + +func (s *Searched_case_expressionContext) Case_when_part_expression(i int) ICase_when_part_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_when_part_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICase_when_part_expressionContext) +} + +func (s *Searched_case_expressionContext) Case_else_part_expression() ICase_else_part_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_part_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_part_expressionContext) +} + +func (s *Searched_case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Searched_case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Searched_case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearched_case_expression(s) + } +} + +func (s *Searched_case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearched_case_expression(s) + } +} + +func (p *PlSqlParser) Searched_case_expression() (localctx ISearched_case_expressionContext) { + localctx = NewSearched_case_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2136, PlSqlParserRULE_searched_case_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18584) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Searched_case_expressionContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(18585) + p.Case_when_part_expression() + } + + p.SetState(18588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(18591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(18590) + p.Case_else_part_expression() + } + + } + { + p.SetState(18593) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18595) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2593, p.GetParserRuleContext()) == 1 { + { + p.SetState(18594) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_when_part_expressionContext is an interface to support dynamic dispatch. +type ICase_when_part_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + THEN() antlr.TerminalNode + + // IsCase_when_part_expressionContext differentiates from other interfaces. + IsCase_when_part_expressionContext() +} + +type Case_when_part_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_when_part_expressionContext() *Case_when_part_expressionContext { + var p = new(Case_when_part_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_when_part_expression + return p +} + +func InitEmptyCase_when_part_expressionContext(p *Case_when_part_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_when_part_expression +} + +func (*Case_when_part_expressionContext) IsCase_when_part_expressionContext() {} + +func NewCase_when_part_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_when_part_expressionContext { + var p = new(Case_when_part_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_when_part_expression + + return p +} + +func (s *Case_when_part_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_when_part_expressionContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Case_when_part_expressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Case_when_part_expressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_when_part_expressionContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Case_when_part_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_when_part_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_when_part_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_when_part_expression(s) + } +} + +func (s *Case_when_part_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_when_part_expression(s) + } +} + +func (p *PlSqlParser) Case_when_part_expression() (localctx ICase_when_part_expressionContext) { + localctx = NewCase_when_part_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2138, PlSqlParserRULE_case_when_part_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18597) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18598) + p.Expression() + } + { + p.SetState(18599) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18600) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_else_part_expressionContext is an interface to support dynamic dispatch. +type ICase_else_part_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Expression() IExpressionContext + + // IsCase_else_part_expressionContext differentiates from other interfaces. + IsCase_else_part_expressionContext() +} + +type Case_else_part_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_else_part_expressionContext() *Case_else_part_expressionContext { + var p = new(Case_else_part_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part_expression + return p +} + +func InitEmptyCase_else_part_expressionContext(p *Case_else_part_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part_expression +} + +func (*Case_else_part_expressionContext) IsCase_else_part_expressionContext() {} + +func NewCase_else_part_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_else_part_expressionContext { + var p = new(Case_else_part_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_else_part_expression + + return p +} + +func (s *Case_else_part_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_else_part_expressionContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Case_else_part_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_else_part_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_else_part_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_else_part_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_else_part_expression(s) + } +} + +func (s *Case_else_part_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_else_part_expression(s) + } +} + +func (p *PlSqlParser) Case_else_part_expression() (localctx ICase_else_part_expressionContext) { + localctx = NewCase_else_part_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2140, PlSqlParserRULE_case_else_part_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18602) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18603) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAtomContext is an interface to support dynamic dispatch. +type IAtomContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Bind_variable() IBind_variableContext + Constant() IConstantContext + Inquiry_directive() IInquiry_directiveContext + General_element() IGeneral_elementContext + Outer_join_sign() IOuter_join_signContext + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllSubquery_operation_part() []ISubquery_operation_partContext + Subquery_operation_part(i int) ISubquery_operation_partContext + Expressions_() IExpressions_Context + + // IsAtomContext differentiates from other interfaces. + IsAtomContext() +} + +type AtomContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAtomContext() *AtomContext { + var p = new(AtomContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_atom + return p +} + +func InitEmptyAtomContext(p *AtomContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_atom +} + +func (*AtomContext) IsAtomContext() {} + +func NewAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomContext { + var p = new(AtomContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_atom + + return p +} + +func (s *AtomContext) GetParser() antlr.Parser { return s.parser } + +func (s *AtomContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *AtomContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *AtomContext) Inquiry_directive() IInquiry_directiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInquiry_directiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInquiry_directiveContext) +} + +func (s *AtomContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *AtomContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *AtomContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *AtomContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *AtomContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *AtomContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *AtomContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +func (s *AtomContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *AtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAtom(s) + } +} + +func (s *AtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAtom(s) + } +} + +func (p *PlSqlParser) Atom() (localctx IAtomContext) { + localctx = NewAtomContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2142, PlSqlParserRULE_atom) + var _alt int + + p.SetState(18625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2596, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18605) + p.Bind_variable() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18606) + p.Constant() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18607) + p.Inquiry_directive() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18608) + p.general_element(0) + } + p.SetState(18610) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2594, p.GetParserRuleContext()) == 1 { + { + p.SetState(18609) + p.Outer_join_sign() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18612) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18613) + p.Subquery() + } + { + p.SetState(18614) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2595, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(18615) + p.Subquery_operation_part() + } + + } + p.SetState(18620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2595, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18621) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18622) + p.Expressions_() + } + { + p.SetState(18623) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuantified_expressionContext is an interface to support dynamic dispatch. +type IQuantified_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SOME() antlr.TerminalNode + EXISTS() antlr.TerminalNode + ALL() antlr.TerminalNode + ANY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + RIGHT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsQuantified_expressionContext differentiates from other interfaces. + IsQuantified_expressionContext() +} + +type Quantified_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuantified_expressionContext() *Quantified_expressionContext { + var p = new(Quantified_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantified_expression + return p +} + +func InitEmptyQuantified_expressionContext(p *Quantified_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantified_expression +} + +func (*Quantified_expressionContext) IsQuantified_expressionContext() {} + +func NewQuantified_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quantified_expressionContext { + var p = new(Quantified_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quantified_expression + + return p +} + +func (s *Quantified_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quantified_expressionContext) SOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOME, 0) +} + +func (s *Quantified_expressionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Quantified_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Quantified_expressionContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *Quantified_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Quantified_expressionContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Quantified_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Quantified_expressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Quantified_expressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Quantified_expressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Quantified_expressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Quantified_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quantified_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quantified_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuantified_expression(s) + } +} + +func (s *Quantified_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuantified_expression(s) + } +} + +func (p *PlSqlParser) Quantified_expression() (localctx IQuantified_expressionContext) { + localctx = NewQuantified_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2144, PlSqlParserRULE_quantified_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18627) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserANY || _la == PlSqlParserEXISTS || _la == PlSqlParserSOME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2598, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18628) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18629) + p.Select_only_statement() + } + { + p.SetState(18630) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18632) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18633) + p.Expression() + } + p.SetState(18638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18634) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18635) + p.Expression() + } + + p.SetState(18640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18641) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_functionContext is an interface to support dynamic dispatch. +type IString_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBSTR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + Table_element() ITable_elementContext + Standard_function() IStandard_functionContext + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + DECODE() antlr.TerminalNode + Expressions_() IExpressions_Context + CHR() antlr.TerminalNode + Concatenation() IConcatenationContext + USING() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + NVL() antlr.TerminalNode + TRIM() antlr.TerminalNode + FROM() antlr.TerminalNode + LEADING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + BOTH() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ON() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + ERROR() antlr.TerminalNode + + // IsString_functionContext differentiates from other interfaces. + IsString_functionContext() +} + +type String_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_functionContext() *String_functionContext { + var p = new(String_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function + return p +} + +func InitEmptyString_functionContext(p *String_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function +} + +func (*String_functionContext) IsString_functionContext() {} + +func NewString_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_functionContext { + var p = new(String_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_string_function + + return p +} + +func (s *String_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_functionContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR, 0) +} + +func (s *String_functionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *String_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *String_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *String_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *String_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *String_functionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *String_functionContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CHAR, 0) +} + +func (s *String_functionContext) Table_element() ITable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *String_functionContext) Standard_function() IStandard_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_functionContext) +} + +func (s *String_functionContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *String_functionContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *String_functionContext) DECODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECODE, 0) +} + +func (s *String_functionContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *String_functionContext) CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHR, 0) +} + +func (s *String_functionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *String_functionContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *String_functionContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *String_functionContext) NVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL, 0) +} + +func (s *String_functionContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *String_functionContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *String_functionContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *String_functionContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *String_functionContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *String_functionContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DATE, 0) +} + +func (s *String_functionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *String_functionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *String_functionContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *String_functionContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *String_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterString_function(s) + } +} + +func (s *String_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_function(s) + } +} + +func (p *PlSqlParser) String_function() (localctx IString_functionContext) { + localctx = NewString_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2146, PlSqlParserRULE_string_function) + var _la int + + p.SetState(18731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUBSTR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18645) + p.Match(PlSqlParserSUBSTR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18646) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18647) + p.Expression() + } + { + p.SetState(18648) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18649) + p.Expression() + } + p.SetState(18652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18650) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18651) + p.Expression() + } + + } + { + p.SetState(18654) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTO_CHAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18656) + p.Match(PlSqlParserTO_CHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18657) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2600, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18658) + p.Table_element() + } + + case 2: + { + p.SetState(18659) + p.Standard_function() + } + + case 3: + { + p.SetState(18660) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18665) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2601, p.GetParserRuleContext()) == 1 { + { + p.SetState(18663) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18664) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18667) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18668) + p.Quoted_string() + } + + } + { + p.SetState(18671) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECODE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18673) + p.Match(PlSqlParserDECODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18674) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18675) + p.Expressions_() + } + { + p.SetState(18676) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHR: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18678) + p.Match(PlSqlParserCHR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18679) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18680) + p.concatenation(0) + } + { + p.SetState(18681) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18682) + p.Match(PlSqlParserNCHAR_CS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18683) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNVL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18685) + p.Match(PlSqlParserNVL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18686) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18687) + p.Expression() + } + { + p.SetState(18688) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18689) + p.Expression() + } + { + p.SetState(18690) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRIM: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18692) + p.Match(PlSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18693) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18701) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2605, p.GetParserRuleContext()) == 1 { + p.SetState(18695) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2603, p.GetParserRuleContext()) == 1 { + { + p.SetState(18694) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBOTH || _la == PlSqlParserLEADING || _la == PlSqlParserTRAILING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18698) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2604, p.GetParserRuleContext()) == 1 { + { + p.SetState(18697) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18700) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18703) + p.concatenation(0) + } + { + p.SetState(18704) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTO_DATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(18706) + p.Match(PlSqlParserTO_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18707) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2606, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18708) + p.Table_element() + } + + case 2: + { + p.SetState(18709) + p.Standard_function() + } + + case 3: + { + p.SetState(18710) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(18713) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18714) + p.concatenation(0) + } + { + p.SetState(18715) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18716) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18717) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18721) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18722) + p.Quoted_string() + } + p.SetState(18725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18723) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18724) + p.Quoted_string() + } + + } + + } + { + p.SetState(18729) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStandard_functionContext is an interface to support dynamic dispatch. +type IStandard_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_function() IString_functionContext + Numeric_function_wrapper() INumeric_function_wrapperContext + Json_function() IJson_functionContext + Other_function() IOther_functionContext + + // IsStandard_functionContext differentiates from other interfaces. + IsStandard_functionContext() +} + +type Standard_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_functionContext() *Standard_functionContext { + var p = new(Standard_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_function + return p +} + +func InitEmptyStandard_functionContext(p *Standard_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_function +} + +func (*Standard_functionContext) IsStandard_functionContext() {} + +func NewStandard_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_functionContext { + var p = new(Standard_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_function + + return p +} + +func (s *Standard_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_functionContext) String_function() IString_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_functionContext) +} + +func (s *Standard_functionContext) Numeric_function_wrapper() INumeric_function_wrapperContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_function_wrapperContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_function_wrapperContext) +} + +func (s *Standard_functionContext) Json_function() IJson_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_functionContext) +} + +func (s *Standard_functionContext) Other_function() IOther_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOther_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOther_functionContext) +} + +func (s *Standard_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_function(s) + } +} + +func (s *Standard_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_function(s) + } +} + +func (p *PlSqlParser) Standard_function() (localctx IStandard_functionContext) { + localctx = NewStandard_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2148, PlSqlParserRULE_standard_function) + p.SetState(18738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2611, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18733) + p.String_function() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18734) + p.Numeric_function_wrapper() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18735) + p.Json_function() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(18736) + + if !(p.IsNotNumericFunction()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.IsNotNumericFunction()", "")) + goto errorExit + } + { + p.SetState(18737) + p.Other_function() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_functionContext is an interface to support dynamic dispatch. +type IJson_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_ARRAY() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllJson_array_element() []IJson_array_elementContext + Json_array_element(i int) IJson_array_elementContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Json_on_null_clause() IJson_on_null_clauseContext + Json_return_clause() IJson_return_clauseContext + STRICT() antlr.TerminalNode + JSON_ARRAYAGG() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + JSON_OBJECT() antlr.TerminalNode + Json_object_content() IJson_object_contentContext + JSON_OBJECTAGG() antlr.TerminalNode + VALUE() antlr.TerminalNode + KEY() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + RETURNING() antlr.TerminalNode + WITH() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + ABSENT() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + JSON_QUERY() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Json_query_returning_clause() IJson_query_returning_clauseContext + Json_query_wrapper_clause() IJson_query_wrapper_clauseContext + Json_query_on_error_clause() IJson_query_on_error_clauseContext + Json_query_on_empty_clause() IJson_query_on_empty_clauseContext + JSON_SERIALIZE() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + PRETTY() antlr.TerminalNode + ASCII() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + EMPTY_() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + JSON_TRANSFORM() antlr.TerminalNode + AllJson_transform_op() []IJson_transform_opContext + Json_transform_op(i int) IJson_transform_opContext + JSON_VALUE() antlr.TerminalNode + Json_value_return_clause() IJson_value_return_clauseContext + Json_value_on_mismatch_clause() IJson_value_on_mismatch_clauseContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + + // IsJson_functionContext differentiates from other interfaces. + IsJson_functionContext() +} + +type Json_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_functionContext() *Json_functionContext { + var p = new(Json_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_function + return p +} + +func InitEmptyJson_functionContext(p *Json_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_function +} + +func (*Json_functionContext) IsJson_functionContext() {} + +func NewJson_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_functionContext { + var p = new(Json_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_function + + return p +} + +func (s *Json_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_functionContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAY, 0) +} + +func (s *Json_functionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Json_functionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Json_functionContext) AllJson_array_element() []IJson_array_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_array_elementContext); ok { + len++ + } + } + + tst := make([]IJson_array_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_array_elementContext); ok { + tst[i] = t.(IJson_array_elementContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Json_array_element(i int) IJson_array_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_array_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_array_elementContext) +} + +func (s *Json_functionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Json_functionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Json_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_functionContext) Json_on_null_clause() IJson_on_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_on_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_on_null_clauseContext) +} + +func (s *Json_functionContext) Json_return_clause() IJson_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_return_clauseContext) +} + +func (s *Json_functionContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Json_functionContext) JSON_ARRAYAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAYAGG, 0) +} + +func (s *Json_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_functionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_functionContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_functionContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Json_functionContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECT, 0) +} + +func (s *Json_functionContext) Json_object_content() IJson_object_contentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_object_contentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_object_contentContext) +} + +func (s *Json_functionContext) JSON_OBJECTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECTAGG, 0) +} + +func (s *Json_functionContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Json_functionContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Json_functionContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_functionContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_functionContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_functionContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_functionContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_functionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Json_functionContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Json_functionContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Json_functionContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_functionContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_functionContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_functionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_functionContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_functionContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_functionContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_QUERY, 0) +} + +func (s *Json_functionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_functionContext) Json_query_returning_clause() IJson_query_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_returning_clauseContext) +} + +func (s *Json_functionContext) Json_query_wrapper_clause() IJson_query_wrapper_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_wrapper_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_wrapper_clauseContext) +} + +func (s *Json_functionContext) Json_query_on_error_clause() IJson_query_on_error_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_error_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_error_clauseContext) +} + +func (s *Json_functionContext) Json_query_on_empty_clause() IJson_query_on_empty_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_empty_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_empty_clauseContext) +} + +func (s *Json_functionContext) JSON_SERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_SERIALIZE, 0) +} + +func (s *Json_functionContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_functionContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Json_functionContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_functionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_functionContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_functionContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_functionContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, 0) +} + +func (s *Json_functionContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_functionContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_functionContext) JSON_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TRANSFORM, 0) +} + +func (s *Json_functionContext) AllJson_transform_op() []IJson_transform_opContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_transform_opContext); ok { + len++ + } + } + + tst := make([]IJson_transform_opContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_transform_opContext); ok { + tst[i] = t.(IJson_transform_opContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Json_transform_op(i int) IJson_transform_opContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_transform_opContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_transform_opContext) +} + +func (s *Json_functionContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_VALUE, 0) +} + +func (s *Json_functionContext) Json_value_return_clause() IJson_value_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_clauseContext) +} + +func (s *Json_functionContext) Json_value_on_mismatch_clause() IJson_value_on_mismatch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_on_mismatch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_on_mismatch_clauseContext) +} + +func (s *Json_functionContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Json_functionContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Json_functionContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Json_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_function(s) + } +} + +func (s *Json_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_function(s) + } +} + +func (p *PlSqlParser) Json_function() (localctx IJson_functionContext) { + localctx = NewJson_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2150, PlSqlParserRULE_json_function) + var _la int + + p.SetState(18928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserJSON_ARRAY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18740) + p.Match(PlSqlParserJSON_ARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18741) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18742) + p.Json_array_element() + } + p.SetState(18747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18743) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18744) + p.Json_array_element() + } + + p.SetState(18749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(18751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(18750) + p.Json_on_null_clause() + } + + } + p.SetState(18754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18753) + p.Json_return_clause() + } + + } + p.SetState(18757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(18756) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18759) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_ARRAYAGG: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18761) + p.Match(PlSqlParserJSON_ARRAYAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18762) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18763) + p.Expression() + } + p.SetState(18766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18764) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18765) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(18768) + p.Order_by_clause() + } + + } + p.SetState(18772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(18771) + p.Json_on_null_clause() + } + + } + p.SetState(18775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18774) + p.Json_return_clause() + } + + } + p.SetState(18778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(18777) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18780) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_OBJECT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18782) + p.Match(PlSqlParserJSON_OBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18783) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18784) + p.Json_object_content() + } + { + p.SetState(18785) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_OBJECTAGG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18787) + p.Match(PlSqlParserJSON_OBJECTAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18788) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2621, p.GetParserRuleContext()) == 1 { + { + p.SetState(18789) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18792) + p.Expression() + } + { + p.SetState(18793) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18794) + p.Expression() + } + p.SetState(18798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(18795) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABSENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18796) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18797) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18800) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + { + p.SetState(18801) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18802) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18803) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(18804) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18807) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + { + p.SetState(18810) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + { + p.SetState(18811) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(18817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(18816) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18819) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18820) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18821) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18824) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_QUERY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18826) + p.Match(PlSqlParserJSON_QUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18827) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18828) + p.Expression() + } + p.SetState(18831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18829) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18830) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18833) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18834) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18835) + p.Json_query_returning_clause() + } + p.SetState(18837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(18836) + p.Json_query_wrapper_clause() + } + + } + p.SetState(18840) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2631, p.GetParserRuleContext()) == 1 { + { + p.SetState(18839) + p.Json_query_on_error_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY_ || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + { + p.SetState(18842) + p.Json_query_on_empty_clause() + } + + } + { + p.SetState(18845) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_SERIALIZE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18847) + p.Match(PlSqlParserJSON_SERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18848) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18849) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18850) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18851) + p.Json_query_return_type() + } + + } + p.SetState(18855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRETTY { + { + p.SetState(18854) + p.Match(PlSqlParserPRETTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(18857) + p.Match(PlSqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTRUNCATE { + { + p.SetState(18860) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY_ || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ { + p.SetState(18867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(18863) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserERROR: + { + p.SetState(18864) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEMPTY_: + { + p.SetState(18865) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18866) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserARRAY || _la == PlSqlParserOBJECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(18869) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18870) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18873) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_TRANSFORM: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(18874) + p.Match(PlSqlParserJSON_TRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18875) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18876) + p.Expression() + } + { + p.SetState(18877) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18878) + p.Json_transform_op() + } + p.SetState(18883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18879) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18880) + p.Json_transform_op() + } + + p.SetState(18885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18886) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_VALUE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(18888) + p.Match(PlSqlParserJSON_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18889) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18890) + p.Expression() + } + p.SetState(18893) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2640, p.GetParserRuleContext()) == 1 { + { + p.SetState(18891) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18892) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18926) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2648, p.GetParserRuleContext()) == 1 { + { + p.SetState(18895) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(18896) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18899) + p.Json_value_return_clause() + } + + } + p.SetState(18910) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2644, p.GetParserRuleContext()) == 1 { + p.SetState(18906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserERROR: + { + p.SetState(18902) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNULL_: + { + p.SetState(18903) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(18904) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18905) + p.Literal() + } + + case PlSqlParserON: + + default: + } + { + p.SetState(18908) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18909) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18920) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2646, p.GetParserRuleContext()) == 1 { + p.SetState(18916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserERROR: + { + p.SetState(18912) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNULL_: + { + p.SetState(18913) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(18914) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18915) + p.Literal() + } + + case PlSqlParserON: + + default: + } + { + p.SetState(18918) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18919) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(18922) + p.Json_value_on_mismatch_clause() + } + + } + { + p.SetState(18925) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_object_contentContext is an interface to support dynamic dispatch. +type IJson_object_contentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJson_object_entry() []IJson_object_entryContext + Json_object_entry(i int) IJson_object_entryContext + ASTERISK() antlr.TerminalNode + Json_on_null_clause() IJson_on_null_clauseContext + Json_return_clause() IJson_return_clauseContext + STRICT() antlr.TerminalNode + WITH() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_object_contentContext differentiates from other interfaces. + IsJson_object_contentContext() +} + +type Json_object_contentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_object_contentContext() *Json_object_contentContext { + var p = new(Json_object_contentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_content + return p +} + +func InitEmptyJson_object_contentContext(p *Json_object_contentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_content +} + +func (*Json_object_contentContext) IsJson_object_contentContext() {} + +func NewJson_object_contentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_object_contentContext { + var p = new(Json_object_contentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_object_content + + return p +} + +func (s *Json_object_contentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_object_contentContext) AllJson_object_entry() []IJson_object_entryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_object_entryContext); ok { + len++ + } + } + + tst := make([]IJson_object_entryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_object_entryContext); ok { + tst[i] = t.(IJson_object_entryContext) + i++ + } + } + + return tst +} + +func (s *Json_object_contentContext) Json_object_entry(i int) IJson_object_entryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_object_entryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_object_entryContext) +} + +func (s *Json_object_contentContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Json_object_contentContext) Json_on_null_clause() IJson_on_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_on_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_on_null_clauseContext) +} + +func (s *Json_object_contentContext) Json_return_clause() IJson_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_return_clauseContext) +} + +func (s *Json_object_contentContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Json_object_contentContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_object_contentContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Json_object_contentContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Json_object_contentContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_object_contentContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_object_contentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_object_contentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_object_contentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_object_content(s) + } +} + +func (s *Json_object_contentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_object_content(s) + } +} + +func (p *PlSqlParser) Json_object_content() (localctx IJson_object_contentContext) { + localctx = NewJson_object_contentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2152, PlSqlParserRULE_json_object_content) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2651, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18930) + p.Json_object_entry() + } + p.SetState(18935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18931) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18932) + p.Json_object_entry() + } + + p.SetState(18937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(18938) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(18941) + p.Json_on_null_clause() + } + + } + p.SetState(18945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18944) + p.Json_return_clause() + } + + } + p.SetState(18948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(18947) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18950) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18951) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18952) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_object_entryContext is an interface to support dynamic dispatch. +type IJson_object_entryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + COLON() antlr.TerminalNode + Identifier() IIdentifierContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + KEY() antlr.TerminalNode + VALUE() antlr.TerminalNode + IS() antlr.TerminalNode + + // IsJson_object_entryContext differentiates from other interfaces. + IsJson_object_entryContext() +} + +type Json_object_entryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_object_entryContext() *Json_object_entryContext { + var p = new(Json_object_entryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_entry + return p +} + +func InitEmptyJson_object_entryContext(p *Json_object_entryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_entry +} + +func (*Json_object_entryContext) IsJson_object_entryContext() {} + +func NewJson_object_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_object_entryContext { + var p = new(Json_object_entryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_object_entry + + return p +} + +func (s *Json_object_entryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_object_entryContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Json_object_entryContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_object_entryContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Json_object_entryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Json_object_entryContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_object_entryContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_object_entryContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Json_object_entryContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Json_object_entryContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Json_object_entryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_object_entryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_object_entryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_object_entry(s) + } +} + +func (s *Json_object_entryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_object_entry(s) + } +} + +func (p *PlSqlParser) Json_object_entry() (localctx IJson_object_entryContext) { + localctx = NewJson_object_entryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2154, PlSqlParserRULE_json_object_entry) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2658, p.GetParserRuleContext()) { + case 1: + p.SetState(18956) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2656, p.GetParserRuleContext()) == 1 { + { + p.SetState(18955) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18958) + p.Expression() + } + p.SetState(18960) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2657, p.GetParserRuleContext()) == 1 { + { + p.SetState(18959) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIS || _la == PlSqlParserVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18962) + p.Expression() + } + + case 2: + { + p.SetState(18964) + p.Expression() + } + { + p.SetState(18965) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18966) + p.Expression() + } + + case 3: + { + p.SetState(18968) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18971) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18972) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_table_clauseContext is an interface to support dynamic dispatch. +type IJson_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_TABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + COMMA() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + AllEMPTY_() []antlr.TerminalNode + EMPTY_(i int) antlr.TerminalNode + Json_column_clause() IJson_column_clauseContext + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + + // IsJson_table_clauseContext differentiates from other interfaces. + IsJson_table_clauseContext() +} + +type Json_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_table_clauseContext() *Json_table_clauseContext { + var p = new(Json_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_table_clause + return p +} + +func InitEmptyJson_table_clauseContext(p *Json_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_table_clause +} + +func (*Json_table_clauseContext) IsJson_table_clauseContext() {} + +func NewJson_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_table_clauseContext { + var p = new(Json_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_table_clause + + return p +} + +func (s *Json_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_table_clauseContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TABLE, 0) +} + +func (s *Json_table_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_table_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_table_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_table_clauseContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_table_clauseContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_table_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Json_table_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_table_clauseContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_table_clauseContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_table_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_table_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_table_clauseContext) AllEMPTY_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEMPTY_) +} + +func (s *Json_table_clauseContext) EMPTY_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, i) +} + +func (s *Json_table_clauseContext) Json_column_clause() IJson_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_clauseContext) +} + +func (s *Json_table_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_table_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_table_clause(s) + } +} + +func (s *Json_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_table_clause(s) + } +} + +func (p *PlSqlParser) Json_table_clause() (localctx IJson_table_clauseContext) { + localctx = NewJson_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2156, PlSqlParserRULE_json_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18975) + p.Match(PlSqlParserJSON_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18976) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18977) + p.Expression() + } + p.SetState(18980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18978) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18979) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18982) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18983) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18989) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2662, p.GetParserRuleContext()) == 1 { + { + p.SetState(18986) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18987) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18988) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY_ || _la == PlSqlParserNULL_ { + { + p.SetState(18991) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEMPTY_ || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18992) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18993) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMNS { + { + p.SetState(18996) + p.Json_column_clause() + } + + } + { + p.SetState(18999) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_array_elementContext is an interface to support dynamic dispatch. +type IJson_array_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + CHAR_STRING() antlr.TerminalNode + NULL_() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Json_function() IJson_functionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsJson_array_elementContext differentiates from other interfaces. + IsJson_array_elementContext() +} + +type Json_array_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_array_elementContext() *Json_array_elementContext { + var p = new(Json_array_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_array_element + return p +} + +func InitEmptyJson_array_elementContext(p *Json_array_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_array_element +} + +func (*Json_array_elementContext) IsJson_array_elementContext() {} + +func NewJson_array_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_array_elementContext { + var p = new(Json_array_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_array_element + + return p +} + +func (s *Json_array_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_array_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_array_elementContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_array_elementContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_array_elementContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_array_elementContext) Json_function() IJson_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_functionContext) +} + +func (s *Json_array_elementContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_array_elementContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_array_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_array_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_array_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_array_element(s) + } +} + +func (s *Json_array_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_array_element(s) + } +} + +func (p *PlSqlParser) Json_array_element() (localctx IJson_array_elementContext) { + localctx = NewJson_array_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2158, PlSqlParserRULE_json_array_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2665, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19001) + p.Expression() + } + + case 2: + { + p.SetState(19002) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(19003) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(19004) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(19005) + p.Json_function() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(19010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(19008) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19009) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_on_null_clauseContext is an interface to support dynamic dispatch. +type IJson_on_null_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + ABSENT() antlr.TerminalNode + + // IsJson_on_null_clauseContext differentiates from other interfaces. + IsJson_on_null_clauseContext() +} + +type Json_on_null_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_on_null_clauseContext() *Json_on_null_clauseContext { + var p = new(Json_on_null_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_on_null_clause + return p +} + +func InitEmptyJson_on_null_clauseContext(p *Json_on_null_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_on_null_clause +} + +func (*Json_on_null_clauseContext) IsJson_on_null_clauseContext() {} + +func NewJson_on_null_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_on_null_clauseContext { + var p = new(Json_on_null_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_on_null_clause + + return p +} + +func (s *Json_on_null_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_on_null_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_on_null_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_on_null_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_on_null_clauseContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Json_on_null_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_on_null_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_on_null_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_on_null_clause(s) + } +} + +func (s *Json_on_null_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_on_null_clause(s) + } +} + +func (p *PlSqlParser) Json_on_null_clause() (localctx IJson_on_null_clauseContext) { + localctx = NewJson_on_null_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2160, PlSqlParserRULE_json_on_null_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19012) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABSENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19013) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19014) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_return_clauseContext is an interface to support dynamic dispatch. +type IJson_return_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + + // IsJson_return_clauseContext differentiates from other interfaces. + IsJson_return_clauseContext() +} + +type Json_return_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_return_clauseContext() *Json_return_clauseContext { + var p = new(Json_return_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_return_clause + return p +} + +func InitEmptyJson_return_clauseContext(p *Json_return_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_return_clause +} + +func (*Json_return_clauseContext) IsJson_return_clauseContext() {} + +func NewJson_return_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_return_clauseContext { + var p = new(Json_return_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_return_clause + + return p +} + +func (s *Json_return_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_return_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_return_clauseContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_return_clauseContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_return_clauseContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_return_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_return_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_return_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_return_clauseContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_return_clauseContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_return_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_return_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_return_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_return_clause(s) + } +} + +func (s *Json_return_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_return_clause(s) + } +} + +func (p *PlSqlParser) Json_return_clause() (localctx IJson_return_clauseContext) { + localctx = NewJson_return_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2162, PlSqlParserRULE_json_return_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19016) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + { + p.SetState(19017) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(19018) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19019) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(19020) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19023) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + { + p.SetState(19026) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + { + p.SetState(19027) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_transform_opContext is an interface to support dynamic dispatch. +type IJson_transform_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REMOVE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + MISSING() antlr.TerminalNode + AllIGNORE() []antlr.TerminalNode + IGNORE(i int) antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + INSERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + EXISTING() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + REPLACE() antlr.TerminalNode + CREATE() antlr.TerminalNode + Expression() IExpressionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + APPEND() antlr.TerminalNode + SET() antlr.TerminalNode + + // IsJson_transform_opContext differentiates from other interfaces. + IsJson_transform_opContext() +} + +type Json_transform_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_transform_opContext() *Json_transform_opContext { + var p = new(Json_transform_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_transform_op + return p +} + +func InitEmptyJson_transform_opContext(p *Json_transform_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_transform_op +} + +func (*Json_transform_opContext) IsJson_transform_opContext() {} + +func NewJson_transform_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_transform_opContext { + var p = new(Json_transform_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_transform_op + + return p +} + +func (s *Json_transform_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_transform_opContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Json_transform_opContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Json_transform_opContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Json_transform_opContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_transform_opContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_transform_opContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Json_transform_opContext) AllIGNORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIGNORE) +} + +func (s *Json_transform_opContext) IGNORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, i) +} + +func (s *Json_transform_opContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_transform_opContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_transform_opContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Json_transform_opContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Json_transform_opContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Json_transform_opContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_transform_opContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_transform_opContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Json_transform_opContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Json_transform_opContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_transform_opContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_transform_opContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_transform_opContext) APPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND, 0) +} + +func (s *Json_transform_opContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Json_transform_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_transform_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_transform_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_transform_op(s) + } +} + +func (s *Json_transform_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_transform_op(s) + } +} + +func (p *PlSqlParser) Json_transform_op() (localctx IJson_transform_opContext) { + localctx = NewJson_transform_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2164, PlSqlParserRULE_json_transform_op) + var _la int + + p.SetState(19117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2687, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19030) + p.Match(PlSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19031) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserON { + p.SetState(19033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE { + { + p.SetState(19032) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19035) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19036) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19039) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19040) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19041) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19042) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19046) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2672, p.GetParserRuleContext()) == 1 { + { + p.SetState(19043) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19044) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19045) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON || _la == PlSqlParserREMOVE { + p.SetState(19049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserREMOVE { + { + p.SetState(19048) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19051) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19052) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19055) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19056) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19057) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19058) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19062) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2675, p.GetParserRuleContext()) == 1 { + { + p.SetState(19059) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19060) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19061) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(19065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(19064) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19067) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19068) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19071) + p.Expression() + } + p.SetState(19074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(19072) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19073) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19076) + p.Match(PlSqlParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19077) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19078) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19079) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19083) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2679, p.GetParserRuleContext()) == 1 { + { + p.SetState(19080) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19081) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19082) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(19086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(19085) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19088) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19089) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19092) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19093) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19094) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19095) + p.Expression() + } + p.SetState(19098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(19096) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19097) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19103) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2683, p.GetParserRuleContext()) == 1 { + { + p.SetState(19100) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19101) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19102) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19108) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2684, p.GetParserRuleContext()) == 1 { + { + p.SetState(19105) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19106) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19107) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(19111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(19110) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19113) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19114) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_column_clauseContext is an interface to support dynamic dispatch. +type IJson_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllJson_column_definition() []IJson_column_definitionContext + Json_column_definition(i int) IJson_column_definitionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_column_clauseContext differentiates from other interfaces. + IsJson_column_clauseContext() +} + +type Json_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_column_clauseContext() *Json_column_clauseContext { + var p = new(Json_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_clause + return p +} + +func InitEmptyJson_column_clauseContext(p *Json_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_clause +} + +func (*Json_column_clauseContext) IsJson_column_clauseContext() {} + +func NewJson_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_column_clauseContext { + var p = new(Json_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_column_clause + + return p +} + +func (s *Json_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_column_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Json_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_column_clauseContext) AllJson_column_definition() []IJson_column_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_column_definitionContext); ok { + len++ + } + } + + tst := make([]IJson_column_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_column_definitionContext); ok { + tst[i] = t.(IJson_column_definitionContext) + i++ + } + } + + return tst +} + +func (s *Json_column_clauseContext) Json_column_definition(i int) IJson_column_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_definitionContext) +} + +func (s *Json_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_column_clause(s) + } +} + +func (s *Json_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_column_clause(s) + } +} + +func (p *PlSqlParser) Json_column_clause() (localctx IJson_column_clauseContext) { + localctx = NewJson_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2166, PlSqlParserRULE_json_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19119) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19120) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19121) + p.Json_column_definition() + } + p.SetState(19126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19122) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19123) + p.Json_column_definition() + } + + p.SetState(19128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19129) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_column_definitionContext is an interface to support dynamic dispatch. +type IJson_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Json_value_return_type() IJson_value_return_typeContext + PATH() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + Json_query_on_error_clause() IJson_query_on_error_clauseContext + Json_query_on_empty_clause() IJson_query_on_empty_clauseContext + EXISTS() antlr.TerminalNode + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + Json_query_wrapper_clause() IJson_query_wrapper_clauseContext + NESTED() antlr.TerminalNode + Json_column_clause() IJson_column_clauseContext + LEFT_BRACKET() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + RIGHT_BRACKET() antlr.TerminalNode + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + + // IsJson_column_definitionContext differentiates from other interfaces. + IsJson_column_definitionContext() +} + +type Json_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_column_definitionContext() *Json_column_definitionContext { + var p = new(Json_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_definition + return p +} + +func InitEmptyJson_column_definitionContext(p *Json_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_definition +} + +func (*Json_column_definitionContext) IsJson_column_definitionContext() {} + +func NewJson_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_column_definitionContext { + var p = new(Json_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_column_definition + + return p +} + +func (s *Json_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_column_definitionContext) Json_value_return_type() IJson_value_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_typeContext) +} + +func (s *Json_column_definitionContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Json_column_definitionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_column_definitionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_column_definitionContext) Json_query_on_error_clause() IJson_query_on_error_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_error_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_error_clauseContext) +} + +func (s *Json_column_definitionContext) Json_query_on_empty_clause() IJson_query_on_empty_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_empty_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_empty_clauseContext) +} + +func (s *Json_column_definitionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Json_column_definitionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_column_definitionContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_column_definitionContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_column_definitionContext) Json_query_wrapper_clause() IJson_query_wrapper_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_wrapper_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_wrapper_clauseContext) +} + +func (s *Json_column_definitionContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Json_column_definitionContext) Json_column_clause() IJson_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_clauseContext) +} + +func (s *Json_column_definitionContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *Json_column_definitionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Json_column_definitionContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *Json_column_definitionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Json_column_definitionContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Json_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_column_definition(s) + } +} + +func (s *Json_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_column_definition(s) + } +} + +func (p *PlSqlParser) Json_column_definition() (localctx IJson_column_definitionContext) { + localctx = NewJson_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2168, PlSqlParserRULE_json_column_definition) + var _la int + + p.SetState(19184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2700, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19131) + p.Expression() + } + p.SetState(19133) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2689, p.GetParserRuleContext()) == 1 { + { + p.SetState(19132) + p.Json_value_return_type() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXISTS, PlSqlParserPATH: + p.SetState(19136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXISTS { + { + p.SetState(19135) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19138) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19139) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUNCATE: + { + p.SetState(19140) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPATH { + { + p.SetState(19141) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19142) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserEMPTY_, PlSqlParserERROR, PlSqlParserNULL_, PlSqlParserON, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + p.SetState(19148) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2693, p.GetParserRuleContext()) == 1 { + { + p.SetState(19147) + p.Json_query_on_error_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY_ || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + { + p.SetState(19150) + p.Json_query_on_empty_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19153) + p.Expression() + } + p.SetState(19155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBLOB || _la == PlSqlParserCLOB || _la == PlSqlParserVARCHAR2 { + { + p.SetState(19154) + p.Json_query_return_type() + } + + } + p.SetState(19158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTRUNCATE { + { + p.SetState(19157) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19160) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19161) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(19162) + p.Json_query_wrapper_clause() + } + + } + { + p.SetState(19165) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19166) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19168) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19170) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2698, p.GetParserRuleContext()) == 1 { + { + p.SetState(19169) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19172) + p.Expression() + } + p.SetState(19176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_BRACKET { + { + p.SetState(19173) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19174) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19175) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19178) + p.Json_column_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19180) + p.Expression() + } + { + p.SetState(19181) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19182) + p.Match(PlSqlParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_query_returning_clauseContext is an interface to support dynamic dispatch. +type IJson_query_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + PRETTY() antlr.TerminalNode + ASCII() antlr.TerminalNode + + // IsJson_query_returning_clauseContext differentiates from other interfaces. + IsJson_query_returning_clauseContext() +} + +type Json_query_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_returning_clauseContext() *Json_query_returning_clauseContext { + var p = new(Json_query_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause + return p +} + +func InitEmptyJson_query_returning_clauseContext(p *Json_query_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause +} + +func (*Json_query_returning_clauseContext) IsJson_query_returning_clauseContext() {} + +func NewJson_query_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_returning_clauseContext { + var p = new(Json_query_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause + + return p +} + +func (s *Json_query_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_query_returning_clauseContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_query_returning_clauseContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Json_query_returning_clauseContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_query_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_returning_clause(s) + } +} + +func (s *Json_query_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_returning_clause(s) + } +} + +func (p *PlSqlParser) Json_query_returning_clause() (localctx IJson_query_returning_clauseContext) { + localctx = NewJson_query_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2170, PlSqlParserRULE_json_query_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(19186) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19187) + p.Json_query_return_type() + } + + } + p.SetState(19191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRETTY { + { + p.SetState(19190) + p.Match(PlSqlParserPRETTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(19193) + p.Match(PlSqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_query_return_typeContext is an interface to support dynamic dispatch. +type IJson_query_return_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARCHAR2() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + + // IsJson_query_return_typeContext differentiates from other interfaces. + IsJson_query_return_typeContext() +} + +type Json_query_return_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_return_typeContext() *Json_query_return_typeContext { + var p = new(Json_query_return_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_return_type + return p +} + +func InitEmptyJson_query_return_typeContext(p *Json_query_return_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_return_type +} + +func (*Json_query_return_typeContext) IsJson_query_return_typeContext() {} + +func NewJson_query_return_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_return_typeContext { + var p = new(Json_query_return_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_return_type + + return p +} + +func (s *Json_query_return_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_return_typeContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_query_return_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_query_return_typeContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_query_return_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_query_return_typeContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_query_return_typeContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_query_return_typeContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_query_return_typeContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_query_return_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_return_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_return_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_return_type(s) + } +} + +func (s *Json_query_return_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_return_type(s) + } +} + +func (p *PlSqlParser) Json_query_return_type() (localctx IJson_query_return_typeContext) { + localctx = NewJson_query_return_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2172, PlSqlParserRULE_json_query_return_type) + var _la int + + p.SetState(19207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19196) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(19197) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19198) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(19199) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19202) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19205) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19206) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_query_wrapper_clauseContext is an interface to support dynamic dispatch. +type IJson_query_wrapper_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITHOUT() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + ARRAY() antlr.TerminalNode + WITH() antlr.TerminalNode + UNCONDITIONAL() antlr.TerminalNode + CONDITIONAL() antlr.TerminalNode + + // IsJson_query_wrapper_clauseContext differentiates from other interfaces. + IsJson_query_wrapper_clauseContext() +} + +type Json_query_wrapper_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_wrapper_clauseContext() *Json_query_wrapper_clauseContext { + var p = new(Json_query_wrapper_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause + return p +} + +func InitEmptyJson_query_wrapper_clauseContext(p *Json_query_wrapper_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause +} + +func (*Json_query_wrapper_clauseContext) IsJson_query_wrapper_clauseContext() {} + +func NewJson_query_wrapper_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_wrapper_clauseContext { + var p = new(Json_query_wrapper_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause + + return p +} + +func (s *Json_query_wrapper_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_wrapper_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Json_query_wrapper_clauseContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPER, 0) +} + +func (s *Json_query_wrapper_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_wrapper_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_query_wrapper_clauseContext) UNCONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNCONDITIONAL, 0) +} + +func (s *Json_query_wrapper_clauseContext) CONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITIONAL, 0) +} + +func (s *Json_query_wrapper_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_wrapper_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_wrapper_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_wrapper_clause(s) + } +} + +func (s *Json_query_wrapper_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_wrapper_clause(s) + } +} + +func (p *PlSqlParser) Json_query_wrapper_clause() (localctx IJson_query_wrapper_clauseContext) { + localctx = NewJson_query_wrapper_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2174, PlSqlParserRULE_json_query_wrapper_clause) + var _la int + + p.SetState(19222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITHOUT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19209) + p.Match(PlSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserARRAY { + { + p.SetState(19210) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19213) + p.Match(PlSqlParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19214) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONDITIONAL || _la == PlSqlParserUNCONDITIONAL { + { + p.SetState(19215) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONDITIONAL || _la == PlSqlParserUNCONDITIONAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(19219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserARRAY { + { + p.SetState(19218) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19221) + p.Match(PlSqlParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_query_on_error_clauseContext is an interface to support dynamic dispatch. +type IJson_query_on_error_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsJson_query_on_error_clauseContext differentiates from other interfaces. + IsJson_query_on_error_clauseContext() +} + +type Json_query_on_error_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_on_error_clauseContext() *Json_query_on_error_clauseContext { + var p = new(Json_query_on_error_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause + return p +} + +func InitEmptyJson_query_on_error_clauseContext(p *Json_query_on_error_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause +} + +func (*Json_query_on_error_clauseContext) IsJson_query_on_error_clauseContext() {} + +func NewJson_query_on_error_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_on_error_clauseContext { + var p = new(Json_query_on_error_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause + + return p +} + +func (s *Json_query_on_error_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_on_error_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_query_on_error_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_query_on_error_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_query_on_error_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_query_on_error_clauseContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, 0) +} + +func (s *Json_query_on_error_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_on_error_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_query_on_error_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_on_error_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_on_error_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_on_error_clause(s) + } +} + +func (s *Json_query_on_error_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_on_error_clause(s) + } +} + +func (p *PlSqlParser) Json_query_on_error_clause() (localctx IJson_query_on_error_clauseContext) { + localctx = NewJson_query_on_error_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2176, PlSqlParserRULE_json_query_on_error_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(19231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) == 1 { + { + p.SetState(19224) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) == 2 { + { + p.SetState(19225) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) == 3 { + { + p.SetState(19226) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) == 4 { + { + p.SetState(19227) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19228) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) == 5 { + { + p.SetState(19229) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19230) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19233) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19234) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_query_on_empty_clauseContext is an interface to support dynamic dispatch. +type IJson_query_on_empty_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllEMPTY_() []antlr.TerminalNode + EMPTY_(i int) antlr.TerminalNode + ERROR() antlr.TerminalNode + NULL_() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsJson_query_on_empty_clauseContext differentiates from other interfaces. + IsJson_query_on_empty_clauseContext() +} + +type Json_query_on_empty_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_on_empty_clauseContext() *Json_query_on_empty_clauseContext { + var p = new(Json_query_on_empty_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause + return p +} + +func InitEmptyJson_query_on_empty_clauseContext(p *Json_query_on_empty_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause +} + +func (*Json_query_on_empty_clauseContext) IsJson_query_on_empty_clauseContext() {} + +func NewJson_query_on_empty_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_on_empty_clauseContext { + var p = new(Json_query_on_empty_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause + + return p +} + +func (s *Json_query_on_empty_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_on_empty_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_query_on_empty_clauseContext) AllEMPTY_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEMPTY_) +} + +func (s *Json_query_on_empty_clauseContext) EMPTY_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, i) +} + +func (s *Json_query_on_empty_clauseContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Json_query_on_empty_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_query_on_empty_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_on_empty_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_query_on_empty_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_on_empty_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_on_empty_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_on_empty_clause(s) + } +} + +func (s *Json_query_on_empty_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_on_empty_clause(s) + } +} + +func (p *PlSqlParser) Json_query_on_empty_clause() (localctx IJson_query_on_empty_clauseContext) { + localctx = NewJson_query_on_empty_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2178, PlSqlParserRULE_json_query_on_empty_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(19243) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 1 { + { + p.SetState(19236) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 2 { + { + p.SetState(19237) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 3 { + { + p.SetState(19238) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 4 { + { + p.SetState(19239) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19240) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 5 { + { + p.SetState(19241) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19242) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19245) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19246) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_value_return_clauseContext is an interface to support dynamic dispatch. +type IJson_value_return_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + Json_value_return_type() IJson_value_return_typeContext + ASCII() antlr.TerminalNode + + // IsJson_value_return_clauseContext differentiates from other interfaces. + IsJson_value_return_clauseContext() +} + +type Json_value_return_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_return_clauseContext() *Json_value_return_clauseContext { + var p = new(Json_value_return_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_clause + return p +} + +func InitEmptyJson_value_return_clauseContext(p *Json_value_return_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_clause +} + +func (*Json_value_return_clauseContext) IsJson_value_return_clauseContext() {} + +func NewJson_value_return_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_return_clauseContext { + var p = new(Json_value_return_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_return_clause + + return p +} + +func (s *Json_value_return_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_return_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_value_return_clauseContext) Json_value_return_type() IJson_value_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_typeContext) +} + +func (s *Json_value_return_clauseContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_value_return_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_return_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_return_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_return_clause(s) + } +} + +func (s *Json_value_return_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_return_clause(s) + } +} + +func (p *PlSqlParser) Json_value_return_clause() (localctx IJson_value_return_clauseContext) { + localctx = NewJson_value_return_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2180, PlSqlParserRULE_json_value_return_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19248) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2713, p.GetParserRuleContext()) == 1 { + { + p.SetState(19249) + p.Json_value_return_type() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(19252) + p.Match(PlSqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_value_return_typeContext is an interface to support dynamic dispatch. +type IJson_value_return_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARCHAR2() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + DATE() antlr.TerminalNode + NUMBER() antlr.TerminalNode + AllINTEGER() []antlr.TerminalNode + INTEGER(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + WITH() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + SDO_GEOMETRY() antlr.TerminalNode + Expression() IExpressionContext + USING() antlr.TerminalNode + CASESENSITIVE() antlr.TerminalNode + MAPPING() antlr.TerminalNode + + // IsJson_value_return_typeContext differentiates from other interfaces. + IsJson_value_return_typeContext() +} + +type Json_value_return_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_return_typeContext() *Json_value_return_typeContext { + var p = new(Json_value_return_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_type + return p +} + +func InitEmptyJson_value_return_typeContext(p *Json_value_return_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_type +} + +func (*Json_value_return_typeContext) IsJson_value_return_typeContext() {} + +func NewJson_value_return_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_return_typeContext { + var p = new(Json_value_return_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_return_type + + return p +} + +func (s *Json_value_return_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_return_typeContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_value_return_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_value_return_typeContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_value_return_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_value_return_typeContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_value_return_typeContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_value_return_typeContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_value_return_typeContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_value_return_typeContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Json_value_return_typeContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Json_value_return_typeContext) AllINTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINTEGER) +} + +func (s *Json_value_return_typeContext) INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, i) +} + +func (s *Json_value_return_typeContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Json_value_return_typeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Json_value_return_typeContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_value_return_typeContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Json_value_return_typeContext) SDO_GEOMETRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOMETRY, 0) +} + +func (s *Json_value_return_typeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_value_return_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Json_value_return_typeContext) CASESENSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASESENSITIVE, 0) +} + +func (s *Json_value_return_typeContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Json_value_return_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_return_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_return_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_return_type(s) + } +} + +func (s *Json_value_return_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_return_type(s) + } +} + +func (p *PlSqlParser) Json_value_return_type() (localctx IJson_value_return_typeContext) { + localctx = NewJson_value_return_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2182, PlSqlParserRULE_json_value_return_type) + var _la int + + p.SetState(19291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2722, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19255) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(19256) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19257) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(19258) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19261) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19265) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2717, p.GetParserRuleContext()) == 1 { + { + p.SetState(19264) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19267) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19268) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19269) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(19270) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19271) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19272) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19273) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19276) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19279) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(19280) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19281) + p.Match(PlSqlParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19284) + p.Match(PlSqlParserSDO_GEOMETRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19285) + p.Expression() + } + p.SetState(19289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(19286) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19287) + p.Match(PlSqlParserCASESENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19288) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_value_on_mismatch_clauseContext is an interface to support dynamic dispatch. +type IJson_value_on_mismatch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + MISMATCH() antlr.TerminalNode + IGNORE() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + MISSING() antlr.TerminalNode + DATA() antlr.TerminalNode + EXTRA() antlr.TerminalNode + TYPE() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsJson_value_on_mismatch_clauseContext differentiates from other interfaces. + IsJson_value_on_mismatch_clauseContext() +} + +type Json_value_on_mismatch_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_on_mismatch_clauseContext() *Json_value_on_mismatch_clauseContext { + var p = new(Json_value_on_mismatch_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause + return p +} + +func InitEmptyJson_value_on_mismatch_clauseContext(p *Json_value_on_mismatch_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause +} + +func (*Json_value_on_mismatch_clauseContext) IsJson_value_on_mismatch_clauseContext() {} + +func NewJson_value_on_mismatch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_on_mismatch_clauseContext { + var p = new(Json_value_on_mismatch_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause + + return p +} + +func (s *Json_value_on_mismatch_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_on_mismatch_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) MISMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISMATCH, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_value_on_mismatch_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_value_on_mismatch_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) EXTRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRA, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_on_mismatch_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_on_mismatch_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_on_mismatch_clause(s) + } +} + +func (s *Json_value_on_mismatch_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_on_mismatch_clause(s) + } +} + +func (p *PlSqlParser) Json_value_on_mismatch_clause() (localctx IJson_value_on_mismatch_clauseContext) { + localctx = NewJson_value_on_mismatch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2184, PlSqlParserRULE_json_value_on_mismatch_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19293) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19294) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19295) + p.Match(PlSqlParserMISMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(19296) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19297) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19298) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTRA: + { + p.SetState(19299) + p.Match(PlSqlParserEXTRA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19300) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTYPE: + { + p.SetState(19301) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19302) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19303) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILiteralContext is an interface to support dynamic dispatch. +type ILiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + String_function() IString_functionContext + Numeric() INumericContext + Numeric_negative() INumeric_negativeContext + MAXVALUE() antlr.TerminalNode + + // IsLiteralContext differentiates from other interfaces. + IsLiteralContext() +} + +type LiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLiteralContext() *LiteralContext { + var p = new(LiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_literal + return p +} + +func InitEmptyLiteralContext(p *LiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_literal +} + +func (*LiteralContext) IsLiteralContext() {} + +func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext { + var p = new(LiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_literal + + return p +} + +func (s *LiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *LiteralContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *LiteralContext) String_function() IString_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_functionContext) +} + +func (s *LiteralContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *LiteralContext) Numeric_negative() INumeric_negativeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_negativeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_negativeContext) +} + +func (s *LiteralContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *LiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLiteral(s) + } +} + +func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLiteral(s) + } +} + +func (p *PlSqlParser) Literal() (localctx ILiteralContext) { + localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2186, PlSqlParserRULE_literal) + p.SetState(19311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19306) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHR, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19307) + p.String_function() + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19308) + p.Numeric() + } + + case PlSqlParserMINUS_SIGN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19309) + p.Numeric_negative() + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19310) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumeric_function_wrapperContext is an interface to support dynamic dispatch. +type INumeric_function_wrapperContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric_function() INumeric_functionContext + Single_column_for_loop() ISingle_column_for_loopContext + Multi_column_for_loop() IMulti_column_for_loopContext + + // IsNumeric_function_wrapperContext differentiates from other interfaces. + IsNumeric_function_wrapperContext() +} + +type Numeric_function_wrapperContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_function_wrapperContext() *Numeric_function_wrapperContext { + var p = new(Numeric_function_wrapperContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper + return p +} + +func InitEmptyNumeric_function_wrapperContext(p *Numeric_function_wrapperContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper +} + +func (*Numeric_function_wrapperContext) IsNumeric_function_wrapperContext() {} + +func NewNumeric_function_wrapperContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_function_wrapperContext { + var p = new(Numeric_function_wrapperContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper + + return p +} + +func (s *Numeric_function_wrapperContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_function_wrapperContext) Numeric_function() INumeric_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_functionContext) +} + +func (s *Numeric_function_wrapperContext) Single_column_for_loop() ISingle_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingle_column_for_loopContext) +} + +func (s *Numeric_function_wrapperContext) Multi_column_for_loop() IMulti_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_column_for_loopContext) +} + +func (s *Numeric_function_wrapperContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_function_wrapperContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_function_wrapperContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_function_wrapper(s) + } +} + +func (s *Numeric_function_wrapperContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_function_wrapper(s) + } +} + +func (p *PlSqlParser) Numeric_function_wrapper() (localctx INumeric_function_wrapperContext) { + localctx = NewNumeric_function_wrapperContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2188, PlSqlParserRULE_numeric_function_wrapper) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19313) + p.Numeric_function() + } + p.SetState(19316) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2725, p.GetParserRuleContext()) == 1 { + { + p.SetState(19314) + p.Single_column_for_loop() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2725, p.GetParserRuleContext()) == 2 { + { + p.SetState(19315) + p.Multi_column_for_loop() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumeric_functionContext is an interface to support dynamic dispatch. +type INumeric_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUM() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Over_clause() IOver_clauseContext + Keep_clause() IKeep_clauseContext + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + COUNT() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + Concatenation() IConcatenationContext + UNIQUE() antlr.TerminalNode + ROUND() antlr.TerminalNode + COMMA() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AVG() antlr.TerminalNode + MIN() antlr.TerminalNode + MAX() antlr.TerminalNode + LEAST() antlr.TerminalNode + Expressions_() IExpressions_Context + GREATEST() antlr.TerminalNode + + // IsNumeric_functionContext differentiates from other interfaces. + IsNumeric_functionContext() +} + +type Numeric_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_functionContext() *Numeric_functionContext { + var p = new(Numeric_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function + return p +} + +func InitEmptyNumeric_functionContext(p *Numeric_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function +} + +func (*Numeric_functionContext) IsNumeric_functionContext() {} + +func NewNumeric_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_functionContext { + var p = new(Numeric_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_function + + return p +} + +func (s *Numeric_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_functionContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Numeric_functionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Numeric_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Numeric_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Numeric_functionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Numeric_functionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Numeric_functionContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Numeric_functionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Numeric_functionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Numeric_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Numeric_functionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Numeric_functionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Numeric_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Numeric_functionContext) ROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserROUND, 0) +} + +func (s *Numeric_functionContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Numeric_functionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Numeric_functionContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Numeric_functionContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Numeric_functionContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Numeric_functionContext) LEAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAST, 0) +} + +func (s *Numeric_functionContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Numeric_functionContext) GREATEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATEST, 0) +} + +func (s *Numeric_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_function(s) + } +} + +func (s *Numeric_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_function(s) + } +} + +func (p *PlSqlParser) Numeric_function() (localctx INumeric_functionContext) { + localctx = NewNumeric_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2190, PlSqlParserRULE_numeric_function) + var _la int + + p.SetState(19400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19318) + p.Match(PlSqlParserSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19319) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19321) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2726, p.GetParserRuleContext()) == 1 { + { + p.SetState(19320) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19323) + p.Expression() + } + { + p.SetState(19324) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19327) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2727, p.GetParserRuleContext()) == 1 { + { + p.SetState(19325) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2727, p.GetParserRuleContext()) == 2 { + { + p.SetState(19326) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCOUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19329) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19330) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2730, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19331) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(19336) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2729, p.GetParserRuleContext()) == 1 { + p.SetState(19333) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2728, p.GetParserRuleContext()) == 1 { + { + p.SetState(19332) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19335) + p.concatenation(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(19340) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19343) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2731, p.GetParserRuleContext()) == 1 { + { + p.SetState(19341) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2731, p.GetParserRuleContext()) == 2 { + { + p.SetState(19342) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserROUND: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19345) + p.Match(PlSqlParserROUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19346) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19347) + p.Expression() + } + p.SetState(19353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19348) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2732, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19349) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19350) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(19355) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAVG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19357) + p.Match(PlSqlParserAVG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19358) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19360) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2734, p.GetParserRuleContext()) == 1 { + { + p.SetState(19359) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19362) + p.Expression() + } + { + p.SetState(19363) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19366) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2735, p.GetParserRuleContext()) == 1 { + { + p.SetState(19364) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2735, p.GetParserRuleContext()) == 2 { + { + p.SetState(19365) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserMIN: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19368) + p.Match(PlSqlParserMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19369) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19371) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2736, p.GetParserRuleContext()) == 1 { + { + p.SetState(19370) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19373) + p.Expression() + } + { + p.SetState(19374) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19377) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2737, p.GetParserRuleContext()) == 1 { + { + p.SetState(19375) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2737, p.GetParserRuleContext()) == 2 { + { + p.SetState(19376) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserMAX: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19379) + p.Match(PlSqlParserMAX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19380) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19382) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2738, p.GetParserRuleContext()) == 1 { + { + p.SetState(19381) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19384) + p.Expression() + } + { + p.SetState(19385) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19388) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2739, p.GetParserRuleContext()) == 1 { + { + p.SetState(19386) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2739, p.GetParserRuleContext()) == 2 { + { + p.SetState(19387) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserLEAST: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19390) + p.Match(PlSqlParserLEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19391) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19392) + p.Expressions_() + } + { + p.SetState(19393) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGREATEST: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19395) + p.Match(PlSqlParserGREATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19396) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19397) + p.Expressions_() + } + { + p.SetState(19398) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IListagg_overflow_clauseContext is an interface to support dynamic dispatch. +type IListagg_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + OVERFLOW_() antlr.TerminalNode + ERROR() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + COUNT() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsListagg_overflow_clauseContext differentiates from other interfaces. + IsListagg_overflow_clauseContext() +} + +type Listagg_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListagg_overflow_clauseContext() *Listagg_overflow_clauseContext { + var p = new(Listagg_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause + return p +} + +func InitEmptyListagg_overflow_clauseContext(p *Listagg_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause +} + +func (*Listagg_overflow_clauseContext) IsListagg_overflow_clauseContext() {} + +func NewListagg_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Listagg_overflow_clauseContext { + var p = new(Listagg_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause + + return p +} + +func (s *Listagg_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Listagg_overflow_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Listagg_overflow_clauseContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Listagg_overflow_clauseContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Listagg_overflow_clauseContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Listagg_overflow_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Listagg_overflow_clauseContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Listagg_overflow_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Listagg_overflow_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Listagg_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Listagg_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Listagg_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterListagg_overflow_clause(s) + } +} + +func (s *Listagg_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitListagg_overflow_clause(s) + } +} + +func (p *PlSqlParser) Listagg_overflow_clause() (localctx IListagg_overflow_clauseContext) { + localctx = NewListagg_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2192, PlSqlParserRULE_listagg_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19402) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19403) + p.Match(PlSqlParserOVERFLOW_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19404) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserTRUNCATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(19405) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(19408) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19409) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOther_functionContext is an interface to support dynamic dispatch. +type IOther_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Over_clause_keyword() IOver_clause_keywordContext + Function_argument_analytic() IFunction_argument_analyticContext + Over_clause() IOver_clauseContext + Regular_id() IRegular_idContext + Function_argument_modeling() IFunction_argument_modelingContext + Using_clause() IUsing_clauseContext + COUNT() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + DISTINCT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + ALL() antlr.TerminalNode + AS() antlr.TerminalNode + Type_spec() IType_specContext + CAST() antlr.TerminalNode + XMLCAST() antlr.TerminalNode + MULTISET() antlr.TerminalNode + Subquery() ISubqueryContext + DEFAULT() antlr.TerminalNode + ON() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + ERROR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + COALESCE() antlr.TerminalNode + Table_element() ITable_elementContext + Numeric() INumericContext + COLLECT() antlr.TerminalNode + Collect_order_by_part() ICollect_order_by_partContext + Within_or_over_clause_keyword() IWithin_or_over_clause_keywordContext + Function_argument() IFunction_argumentContext + AllWithin_or_over_part() []IWithin_or_over_partContext + Within_or_over_part(i int) IWithin_or_over_partContext + LISTAGG() antlr.TerminalNode + Argument() IArgumentContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + Listagg_overflow_clause() IListagg_overflow_clauseContext + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + Cursor_name() ICursor_nameContext + PERCENT_ISOPEN() antlr.TerminalNode + PERCENT_FOUND() antlr.TerminalNode + PERCENT_NOTFOUND() antlr.TerminalNode + PERCENT_ROWCOUNT() antlr.TerminalNode + DECOMPOSE() antlr.TerminalNode + CANONICAL() antlr.TerminalNode + COMPATIBILITY() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + FROM() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + Respect_or_ignore_nulls() IRespect_or_ignore_nullsContext + LEAD() antlr.TerminalNode + LAG() antlr.TerminalNode + Standard_prediction_function_keyword() IStandard_prediction_function_keywordContext + Expressions_() IExpressions_Context + Cost_matrix_clause() ICost_matrix_clauseContext + TO_BINARY_DOUBLE() antlr.TerminalNode + TO_BINARY_FLOAT() antlr.TerminalNode + TO_NUMBER() antlr.TerminalNode + TO_TIMESTAMP() antlr.TerminalNode + TO_TIMESTAMP_TZ() antlr.TerminalNode + TO_DSINTERVAL() antlr.TerminalNode + TO_YMINTERVAL() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + USING() antlr.TerminalNode + CHAR_CS() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + TREAT() antlr.TerminalNode + REF() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllGeneral_element_part() []IGeneral_element_partContext + General_element_part(i int) IGeneral_element_partContext + TRIM() antlr.TerminalNode + LEADING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + BOTH() antlr.TerminalNode + VALIDATE_CONVERSION() antlr.TerminalNode + XMLAGG() antlr.TerminalNode + AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext + Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext + XMLCOLATTVAL() antlr.TerminalNode + XMLFOREST() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + Xml_attributes_clause() IXml_attributes_clauseContext + ENTITYESCAPING() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + NAME() antlr.TerminalNode + EVALNAME() antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + XMLEXISTS() antlr.TerminalNode + Xml_passing_clause() IXml_passing_clauseContext + XMLPARSE() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + CONTENT() antlr.TerminalNode + WELLFORMED() antlr.TerminalNode + XMLPI() antlr.TerminalNode + Identifier() IIdentifierContext + XMLQUERY() antlr.TerminalNode + RETURNING() antlr.TerminalNode + NULL_() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + Xmlroot_param_version_part() IXmlroot_param_version_partContext + Xmlroot_param_standalone_part() IXmlroot_param_standalone_partContext + XMLSERIALIZE() antlr.TerminalNode + Xmlserialize_param_enconding_part() IXmlserialize_param_enconding_partContext + Xmlserialize_param_version_part() IXmlserialize_param_version_partContext + Xmlserialize_param_ident_part() IXmlserialize_param_ident_partContext + DEFAULTS() antlr.TerminalNode + HIDE() antlr.TerminalNode + SHOW() antlr.TerminalNode + TIME() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Xmltable() IXmltableContext + + // IsOther_functionContext differentiates from other interfaces. + IsOther_functionContext() +} + +type Other_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOther_functionContext() *Other_functionContext { + var p = new(Other_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_other_function + return p +} + +func InitEmptyOther_functionContext(p *Other_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_other_function +} + +func (*Other_functionContext) IsOther_functionContext() {} + +func NewOther_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Other_functionContext { + var p = new(Other_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_other_function + + return p +} + +func (s *Other_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Other_functionContext) Over_clause_keyword() IOver_clause_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clause_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clause_keywordContext) +} + +func (s *Other_functionContext) Function_argument_analytic() IFunction_argument_analyticContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argument_analyticContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argument_analyticContext) +} + +func (s *Other_functionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Other_functionContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Other_functionContext) Function_argument_modeling() IFunction_argument_modelingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argument_modelingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argument_modelingContext) +} + +func (s *Other_functionContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Other_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Other_functionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Other_functionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Other_functionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Other_functionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Other_functionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Other_functionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Other_functionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Other_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Other_functionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Other_functionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Other_functionContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Other_functionContext) CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAST, 0) +} + +func (s *Other_functionContext) XMLCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCAST, 0) +} + +func (s *Other_functionContext) MULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTISET, 0) +} + +func (s *Other_functionContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Other_functionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Other_functionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Other_functionContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *Other_functionContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Other_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Other_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Other_functionContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Other_functionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Other_functionContext) Table_element() ITable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *Other_functionContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Other_functionContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Other_functionContext) Collect_order_by_part() ICollect_order_by_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollect_order_by_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollect_order_by_partContext) +} + +func (s *Other_functionContext) Within_or_over_clause_keyword() IWithin_or_over_clause_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithin_or_over_clause_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithin_or_over_clause_keywordContext) +} + +func (s *Other_functionContext) Function_argument() IFunction_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *Other_functionContext) AllWithin_or_over_part() []IWithin_or_over_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWithin_or_over_partContext); ok { + len++ + } + } + + tst := make([]IWithin_or_over_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWithin_or_over_partContext); ok { + tst[i] = t.(IWithin_or_over_partContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Within_or_over_part(i int) IWithin_or_over_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithin_or_over_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWithin_or_over_partContext) +} + +func (s *Other_functionContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLISTAGG, 0) +} + +func (s *Other_functionContext) Argument() IArgumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Other_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Other_functionContext) Listagg_overflow_clause() IListagg_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListagg_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListagg_overflow_clauseContext) +} + +func (s *Other_functionContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Other_functionContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Other_functionContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Other_functionContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Other_functionContext) PERCENT_ISOPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ISOPEN, 0) +} + +func (s *Other_functionContext) PERCENT_FOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_FOUND, 0) +} + +func (s *Other_functionContext) PERCENT_NOTFOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_NOTFOUND, 0) +} + +func (s *Other_functionContext) PERCENT_ROWCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ROWCOUNT, 0) +} + +func (s *Other_functionContext) DECOMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECOMPOSE, 0) +} + +func (s *Other_functionContext) CANONICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANONICAL, 0) +} + +func (s *Other_functionContext) COMPATIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPATIBILITY, 0) +} + +func (s *Other_functionContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACT, 0) +} + +func (s *Other_functionContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Other_functionContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_VALUE, 0) +} + +func (s *Other_functionContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_VALUE, 0) +} + +func (s *Other_functionContext) Respect_or_ignore_nulls() IRespect_or_ignore_nullsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRespect_or_ignore_nullsContext) +} + +func (s *Other_functionContext) LEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD, 0) +} + +func (s *Other_functionContext) LAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG, 0) +} + +func (s *Other_functionContext) Standard_prediction_function_keyword() IStandard_prediction_function_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_prediction_function_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_prediction_function_keywordContext) +} + +func (s *Other_functionContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Other_functionContext) Cost_matrix_clause() ICost_matrix_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICost_matrix_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICost_matrix_clauseContext) +} + +func (s *Other_functionContext) TO_BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_DOUBLE, 0) +} + +func (s *Other_functionContext) TO_BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_FLOAT, 0) +} + +func (s *Other_functionContext) TO_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NUMBER, 0) +} + +func (s *Other_functionContext) TO_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP, 0) +} + +func (s *Other_functionContext) TO_TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP_TZ, 0) +} + +func (s *Other_functionContext) TO_DSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DSINTERVAL, 0) +} + +func (s *Other_functionContext) TO_YMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_YMINTERVAL, 0) +} + +func (s *Other_functionContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Other_functionContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Other_functionContext) CHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_CS, 0) +} + +func (s *Other_functionContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *Other_functionContext) TREAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTREAT, 0) +} + +func (s *Other_functionContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Other_functionContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Other_functionContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Other_functionContext) AllGeneral_element_part() []IGeneral_element_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_element_partContext); ok { + len++ + } + } + + tst := make([]IGeneral_element_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_element_partContext); ok { + tst[i] = t.(IGeneral_element_partContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) General_element_part(i int) IGeneral_element_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *Other_functionContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *Other_functionContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *Other_functionContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *Other_functionContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *Other_functionContext) VALIDATE_CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE_CONVERSION, 0) +} + +func (s *Other_functionContext) XMLAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLAGG, 0) +} + +func (s *Other_functionContext) AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + len++ + } + } + + tst := make([]IXml_multiuse_expression_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + tst[i] = t.(IXml_multiuse_expression_elementContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_multiuse_expression_elementContext) +} + +func (s *Other_functionContext) XMLCOLATTVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOLATTVAL, 0) +} + +func (s *Other_functionContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLFOREST, 0) +} + +func (s *Other_functionContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLELEMENT, 0) +} + +func (s *Other_functionContext) Xml_attributes_clause() IXml_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_attributes_clauseContext) +} + +func (s *Other_functionContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Other_functionContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Other_functionContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Other_functionContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Other_functionContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Other_functionContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS, 0) +} + +func (s *Other_functionContext) Xml_passing_clause() IXml_passing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_passing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_passing_clauseContext) +} + +func (s *Other_functionContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPARSE, 0) +} + +func (s *Other_functionContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCUMENT, 0) +} + +func (s *Other_functionContext) CONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENT, 0) +} + +func (s *Other_functionContext) WELLFORMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWELLFORMED, 0) +} + +func (s *Other_functionContext) XMLPI() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPI, 0) +} + +func (s *Other_functionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Other_functionContext) XMLQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERY, 0) +} + +func (s *Other_functionContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Other_functionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Other_functionContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, 0) +} + +func (s *Other_functionContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLROOT, 0) +} + +func (s *Other_functionContext) Xmlroot_param_version_part() IXmlroot_param_version_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlroot_param_version_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlroot_param_version_partContext) +} + +func (s *Other_functionContext) Xmlroot_param_standalone_part() IXmlroot_param_standalone_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlroot_param_standalone_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlroot_param_standalone_partContext) +} + +func (s *Other_functionContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSERIALIZE, 0) +} + +func (s *Other_functionContext) Xmlserialize_param_enconding_part() IXmlserialize_param_enconding_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_enconding_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_enconding_partContext) +} + +func (s *Other_functionContext) Xmlserialize_param_version_part() IXmlserialize_param_version_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_version_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_version_partContext) +} + +func (s *Other_functionContext) Xmlserialize_param_ident_part() IXmlserialize_param_ident_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_ident_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_ident_partContext) +} + +func (s *Other_functionContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTS, 0) +} + +func (s *Other_functionContext) HIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDE, 0) +} + +func (s *Other_functionContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Other_functionContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Other_functionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Other_functionContext) Xmltable() IXmltableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltableContext) +} + +func (s *Other_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Other_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Other_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOther_function(s) + } +} + +func (s *Other_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOther_function(s) + } +} + +func (p *PlSqlParser) Other_function() (localctx IOther_functionContext) { + localctx = NewOther_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2194, PlSqlParserRULE_other_function) + var _la int + + var _alt int + + p.SetState(19833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2808, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19412) + p.Over_clause_keyword() + } + { + p.SetState(19413) + p.Function_argument_analytic() + } + p.SetState(19415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2743, p.GetParserRuleContext()) == 1 { + { + p.SetState(19414) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19417) + p.Regular_id() + } + { + p.SetState(19418) + p.Function_argument_modeling() + } + p.SetState(19420) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2744, p.GetParserRuleContext()) == 1 { + { + p.SetState(19419) + p.Using_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19422) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19423) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2746, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19424) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(19426) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2745, p.GetParserRuleContext()) == 1 { + { + p.SetState(19425) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19428) + p.concatenation(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(19431) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19433) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2747, p.GetParserRuleContext()) == 1 { + { + p.SetState(19432) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19435) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCAST || _la == PlSqlParserXMLCAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19436) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2748, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19437) + p.Match(PlSqlParserMULTISET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19438) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19439) + p.Subquery() + } + { + p.SetState(19440) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19442) + p.concatenation(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(19445) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19446) + p.Type_spec() + } + p.SetState(19453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(19447) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19448) + p.concatenation(0) + } + { + p.SetState(19449) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19450) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19451) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19455) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19456) + p.Quoted_string() + } + p.SetState(19459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19457) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19458) + p.Quoted_string() + } + + } + + } + { + p.SetState(19463) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19465) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19466) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19467) + p.Table_element() + } + p.SetState(19473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19468) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(19469) + p.Numeric() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(19470) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(19475) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19477) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19478) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19480) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2754, p.GetParserRuleContext()) == 1 { + { + p.SetState(19479) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19482) + p.concatenation(0) + } + p.SetState(19484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(19483) + p.Collect_order_by_part() + } + + } + { + p.SetState(19486) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19488) + p.Within_or_over_clause_keyword() + } + { + p.SetState(19489) + p.Function_argument() + } + p.SetState(19491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(19490) + p.Within_or_over_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(19493) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2756, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19495) + p.Match(PlSqlParserLISTAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19496) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19498) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2757, p.GetParserRuleContext()) == 1 { + { + p.SetState(19497) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19500) + p.Argument() + } + p.SetState(19503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19501) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19502) + p.Expression() + } + + } + p.SetState(19506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(19505) + p.Listagg_overflow_clause() + } + + } + { + p.SetState(19508) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19515) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2760, p.GetParserRuleContext()) == 1 { + { + p.SetState(19509) + p.Match(PlSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19510) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19511) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19512) + p.Order_by_clause() + } + { + p.SetState(19513) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19518) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2761, p.GetParserRuleContext()) == 1 { + { + p.SetState(19517) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(19520) + p.Cursor_name() + } + { + p.SetState(19521) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1375)) & ^0x3f) == 0 && ((int64(1)<<(_la-1375))&39) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(19523) + p.Match(PlSqlParserDECOMPOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19524) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19525) + p.concatenation(0) + } + p.SetState(19527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCANONICAL || _la == PlSqlParserCOMPATIBILITY { + { + p.SetState(19526) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCANONICAL || _la == PlSqlParserCOMPATIBILITY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19529) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(19531) + p.Match(PlSqlParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19532) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19533) + p.Regular_id() + } + { + p.SetState(19534) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19535) + p.concatenation(0) + } + { + p.SetState(19536) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(19538) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST_VALUE || _la == PlSqlParserLAST_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19539) + p.Function_argument_analytic() + } + p.SetState(19541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(19540) + p.Respect_or_ignore_nulls() + } + + } + { + p.SetState(19543) + p.Over_clause() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(19545) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLAG || _la == PlSqlParserLEAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19546) + p.Function_argument_analytic() + } + p.SetState(19548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(19547) + p.Respect_or_ignore_nulls() + } + + } + { + p.SetState(19550) + p.Over_clause() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(19552) + p.Standard_prediction_function_keyword() + } + { + p.SetState(19553) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19554) + p.Expressions_() + } + p.SetState(19556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOST { + { + p.SetState(19555) + p.Cost_matrix_clause() + } + + } + p.SetState(19559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(19558) + p.Using_clause() + } + + } + { + p.SetState(19561) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(19563) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2125)) & ^0x3f) == 0 && ((int64(1)<<(_la-2125))&12803) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19564) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19565) + p.concatenation(0) + } + p.SetState(19572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(19566) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19567) + p.concatenation(0) + } + { + p.SetState(19568) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19569) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19570) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19574) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19575) + p.Quoted_string() + } + p.SetState(19578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19576) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19577) + p.Quoted_string() + } + + } + + } + { + p.SetState(19582) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(19584) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserTO_DSINTERVAL || _la == PlSqlParserTO_YMINTERVAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19585) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19586) + p.concatenation(0) + } + p.SetState(19593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(19587) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19588) + p.concatenation(0) + } + { + p.SetState(19589) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19590) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19591) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19595) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(19597) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19598) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19599) + p.Expression() + } + p.SetState(19602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(19600) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19601) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCHAR_CS || _la == PlSqlParserNCHAR_CS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(19608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19604) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19605) + p.Expression() + } + + p.SetState(19610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19611) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(19613) + p.Match(PlSqlParserTREAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19614) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19615) + p.Expression() + } + { + p.SetState(19616) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19618) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2773, p.GetParserRuleContext()) == 1 { + { + p.SetState(19617) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19620) + p.Type_spec() + } + { + p.SetState(19621) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2774, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19622) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19623) + p.General_element_part() + } + + } + p.SetState(19628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2774, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(19629) + p.Match(PlSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19630) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19638) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2777, p.GetParserRuleContext()) == 1 { + p.SetState(19632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBOTH || _la == PlSqlParserLEADING || _la == PlSqlParserTRAILING { + { + p.SetState(19631) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBOTH || _la == PlSqlParserLEADING || _la == PlSqlParserTRAILING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(19635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNATIONAL_CHAR_STRING_LIT || _la == PlSqlParserCHAR_STRING { + { + p.SetState(19634) + p.Quoted_string() + } + + } + { + p.SetState(19637) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19640) + p.concatenation(0) + } + { + p.SetState(19641) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(19643) + p.Match(PlSqlParserVALIDATE_CONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19644) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19645) + p.concatenation(0) + } + { + p.SetState(19646) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19647) + p.Type_spec() + } + p.SetState(19654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19648) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19649) + p.Quoted_string() + } + p.SetState(19652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19650) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19651) + p.Quoted_string() + } + + } + + } + { + p.SetState(19656) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(19658) + p.Match(PlSqlParserXMLAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19659) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19660) + p.Expression() + } + p.SetState(19662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(19661) + p.Order_by_clause() + } + + } + { + p.SetState(19664) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2781, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19665) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19666) + p.General_element_part() + } + + } + p.SetState(19671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2781, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(19672) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserXMLCOLATTVAL || _la == PlSqlParserXMLFOREST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19673) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19674) + p.Xml_multiuse_expression_element() + } + p.SetState(19679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19675) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19676) + p.Xml_multiuse_expression_element() + } + + p.SetState(19681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19682) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2783, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19683) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19684) + p.General_element_part() + } + + } + p.SetState(19689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2783, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(19690) + p.Match(PlSqlParserXMLELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19691) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19693) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2784, p.GetParserRuleContext()) == 1 { + { + p.SetState(19692) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENTITYESCAPING || _la == PlSqlParserNOENTITYESCAPING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19696) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2785, p.GetParserRuleContext()) == 1 { + { + p.SetState(19695) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEVALNAME || _la == PlSqlParserNAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19698) + p.Expression() + } + p.SetState(19701) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2786, p.GetParserRuleContext()) == 1 { + { + p.SetState(19699) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19700) + p.Xml_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19703) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19704) + p.Expression() + } + p.SetState(19706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(19705) + p.Column_alias() + } + + } + + p.SetState(19712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19713) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2789, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19714) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19715) + p.General_element_part() + } + + } + p.SetState(19720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2789, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(19721) + p.Match(PlSqlParserXMLEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19722) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19723) + p.Expression() + } + p.SetState(19725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(19724) + p.Xml_passing_clause() + } + + } + { + p.SetState(19727) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(19729) + p.Match(PlSqlParserXMLPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19730) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19731) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTENT || _la == PlSqlParserDOCUMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19732) + p.concatenation(0) + } + p.SetState(19734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWELLFORMED { + { + p.SetState(19733) + p.Match(PlSqlParserWELLFORMED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19736) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2792, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19737) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19738) + p.General_element_part() + } + + } + p.SetState(19743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2792, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(19744) + p.Match(PlSqlParserXMLPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19745) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNAME: + { + p.SetState(19746) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19747) + p.Identifier() + } + + case PlSqlParserEVALNAME: + { + p.SetState(19748) + p.Match(PlSqlParserEVALNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19749) + p.concatenation(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(19754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19752) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19753) + p.concatenation(0) + } + + } + { + p.SetState(19756) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19757) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19758) + p.General_element_part() + } + + } + p.SetState(19763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(19764) + p.Match(PlSqlParserXMLQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19765) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19766) + p.concatenation(0) + } + p.SetState(19768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(19767) + p.Xml_passing_clause() + } + + } + { + p.SetState(19770) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19771) + p.Match(PlSqlParserCONTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULL_ { + { + p.SetState(19772) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19773) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19774) + p.Match(PlSqlParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19777) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2798, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19778) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19779) + p.General_element_part() + } + + } + p.SetState(19784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2798, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(19785) + p.Match(PlSqlParserXMLROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19786) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19787) + p.concatenation(0) + } + p.SetState(19790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2799, p.GetParserRuleContext()) == 1 { + { + p.SetState(19788) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19789) + p.Xmlroot_param_version_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19792) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19793) + p.Xmlroot_param_standalone_part() + } + + } + { + p.SetState(19796) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2801, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19797) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19798) + p.General_element_part() + } + + } + p.SetState(19803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2801, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(19804) + p.Match(PlSqlParserXMLSERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19805) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19806) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTENT || _la == PlSqlParserDOCUMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19807) + p.concatenation(0) + } + p.SetState(19810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(19808) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19809) + p.Type_spec() + } + + } + p.SetState(19813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCODING { + { + p.SetState(19812) + p.Xmlserialize_param_enconding_part() + } + + } + p.SetState(19816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVERSION { + { + p.SetState(19815) + p.Xmlserialize_param_version_part() + } + + } + p.SetState(19819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDENT || _la == PlSqlParserNO { + { + p.SetState(19818) + p.Xmlserialize_param_ident_part() + } + + } + p.SetState(19823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIDE || _la == PlSqlParserSHOW { + { + p.SetState(19821) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIDE || _la == PlSqlParserSHOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19822) + p.Match(PlSqlParserDEFAULTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19825) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19828) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2807, p.GetParserRuleContext()) == 1 { + { + p.SetState(19826) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19827) + p.General_element_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(19830) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19831) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(19832) + p.Xmltable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOver_clause_keywordContext is an interface to support dynamic dispatch. +type IOver_clause_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AVG() antlr.TerminalNode + CORR() antlr.TerminalNode + LAG_DIFF() antlr.TerminalNode + LAG_DIFF_PERCENT() antlr.TerminalNode + MAX() antlr.TerminalNode + MEDIAN() antlr.TerminalNode + MIN() antlr.TerminalNode + NTH_VALUE() antlr.TerminalNode + NTILE() antlr.TerminalNode + RATIO_TO_REPORT() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + SUM() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + REGR_() antlr.TerminalNode + STDDEV() antlr.TerminalNode + VAR_() antlr.TerminalNode + VAR_POP() antlr.TerminalNode + COVAR_() antlr.TerminalNode + WM_CONCAT() antlr.TerminalNode + + // IsOver_clause_keywordContext differentiates from other interfaces. + IsOver_clause_keywordContext() +} + +type Over_clause_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOver_clause_keywordContext() *Over_clause_keywordContext { + var p = new(Over_clause_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause_keyword + return p +} + +func InitEmptyOver_clause_keywordContext(p *Over_clause_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause_keyword +} + +func (*Over_clause_keywordContext) IsOver_clause_keywordContext() {} + +func NewOver_clause_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clause_keywordContext { + var p = new(Over_clause_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_over_clause_keyword + + return p +} + +func (s *Over_clause_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clause_keywordContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Over_clause_keywordContext) CORR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR, 0) +} + +func (s *Over_clause_keywordContext) LAG_DIFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG_DIFF, 0) +} + +func (s *Over_clause_keywordContext) LAG_DIFF_PERCENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG_DIFF_PERCENT, 0) +} + +func (s *Over_clause_keywordContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Over_clause_keywordContext) MEDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIAN, 0) +} + +func (s *Over_clause_keywordContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Over_clause_keywordContext) NTH_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTH_VALUE, 0) +} + +func (s *Over_clause_keywordContext) NTILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTILE, 0) +} + +func (s *Over_clause_keywordContext) RATIO_TO_REPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRATIO_TO_REPORT, 0) +} + +func (s *Over_clause_keywordContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_NUMBER, 0) +} + +func (s *Over_clause_keywordContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Over_clause_keywordContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIANCE, 0) +} + +func (s *Over_clause_keywordContext) REGR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_, 0) +} + +func (s *Over_clause_keywordContext) STDDEV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV, 0) +} + +func (s *Over_clause_keywordContext) VAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_, 0) +} + +func (s *Over_clause_keywordContext) VAR_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_POP, 0) +} + +func (s *Over_clause_keywordContext) COVAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_, 0) +} + +func (s *Over_clause_keywordContext) WM_CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWM_CONCAT, 0) +} + +func (s *Over_clause_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clause_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clause_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOver_clause_keyword(s) + } +} + +func (s *Over_clause_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOver_clause_keyword(s) + } +} + +func (p *PlSqlParser) Over_clause_keyword() (localctx IOver_clause_keywordContext) { + localctx = NewOver_clause_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2196, PlSqlParserRULE_over_clause_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19835) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNTH_VALUE || _la == PlSqlParserVAR_POP || ((int64((_la-2398)) & ^0x3f) == 0 && ((int64(1)<<(_la-2398))&137470597991) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithin_or_over_clause_keywordContext is an interface to support dynamic dispatch. +type IWithin_or_over_clause_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CUME_DIST() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + RANK() antlr.TerminalNode + + // IsWithin_or_over_clause_keywordContext differentiates from other interfaces. + IsWithin_or_over_clause_keywordContext() +} + +type Within_or_over_clause_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithin_or_over_clause_keywordContext() *Within_or_over_clause_keywordContext { + var p = new(Within_or_over_clause_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword + return p +} + +func InitEmptyWithin_or_over_clause_keywordContext(p *Within_or_over_clause_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword +} + +func (*Within_or_over_clause_keywordContext) IsWithin_or_over_clause_keywordContext() {} + +func NewWithin_or_over_clause_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_or_over_clause_keywordContext { + var p = new(Within_or_over_clause_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword + + return p +} + +func (s *Within_or_over_clause_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Within_or_over_clause_keywordContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DIST, 0) +} + +func (s *Within_or_over_clause_keywordContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_CONT, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_DISC, 0) +} + +func (s *Within_or_over_clause_keywordContext) RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Within_or_over_clause_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Within_or_over_clause_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWithin_or_over_clause_keyword(s) + } +} + +func (s *Within_or_over_clause_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWithin_or_over_clause_keyword(s) + } +} + +func (p *PlSqlParser) Within_or_over_clause_keyword() (localctx IWithin_or_over_clause_keywordContext) { + localctx = NewWithin_or_over_clause_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2198, PlSqlParserRULE_within_or_over_clause_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19837) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2391)) & ^0x3f) == 0 && ((int64(1)<<(_la-2391))&123) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStandard_prediction_function_keywordContext is an interface to support dynamic dispatch. +type IStandard_prediction_function_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PREDICTION() antlr.TerminalNode + PREDICTION_BOUNDS() antlr.TerminalNode + PREDICTION_COST() antlr.TerminalNode + PREDICTION_DETAILS() antlr.TerminalNode + PREDICTION_PROBABILITY() antlr.TerminalNode + PREDICTION_SET() antlr.TerminalNode + + // IsStandard_prediction_function_keywordContext differentiates from other interfaces. + IsStandard_prediction_function_keywordContext() +} + +type Standard_prediction_function_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_prediction_function_keywordContext() *Standard_prediction_function_keywordContext { + var p = new(Standard_prediction_function_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword + return p +} + +func InitEmptyStandard_prediction_function_keywordContext(p *Standard_prediction_function_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword +} + +func (*Standard_prediction_function_keywordContext) IsStandard_prediction_function_keywordContext() {} + +func NewStandard_prediction_function_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_prediction_function_keywordContext { + var p = new(Standard_prediction_function_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword + + return p +} + +func (s *Standard_prediction_function_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_prediction_function_keywordContext) PREDICTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_BOUNDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_BOUNDS, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_COST, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_DETAILS, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_PROBABILITY, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_SET, 0) +} + +func (s *Standard_prediction_function_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_prediction_function_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_prediction_function_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_prediction_function_keyword(s) + } +} + +func (s *Standard_prediction_function_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_prediction_function_keyword(s) + } +} + +func (p *PlSqlParser) Standard_prediction_function_keyword() (localctx IStandard_prediction_function_keywordContext) { + localctx = NewStandard_prediction_function_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2200, PlSqlParserRULE_standard_prediction_function_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19839) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2365)) & ^0x3f) == 0 && ((int64(1)<<(_la-2365))&63) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOver_clauseContext is an interface to support dynamic dispatch. +type IOver_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTh returns the th rule contexts. + GetTh() IId_expressionContext + + // SetTh sets the th rule contexts. + SetTh(IId_expressionContext) + + // Getter signatures + OVER() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + OFFSET() antlr.TerminalNode + Numeric() INumericContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Query_partition_clause() IQuery_partition_clauseContext + Order_by_clause() IOrder_by_clauseContext + ACROSS() antlr.TerminalNode + ANCESTOR() antlr.TerminalNode + AT() antlr.TerminalNode + LEVEL() antlr.TerminalNode + Windowing_clause() IWindowing_clauseContext + + // IsOver_clauseContext differentiates from other interfaces. + IsOver_clauseContext() +} + +type Over_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + th IId_expressionContext +} + +func NewEmptyOver_clauseContext() *Over_clauseContext { + var p = new(Over_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause +} + +func (*Over_clauseContext) IsOver_clauseContext() {} + +func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext { + var p = new(Over_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) GetTh() IId_expressionContext { return s.th } + +func (s *Over_clauseContext) SetTh(v IId_expressionContext) { s.th = v } + +func (s *Over_clauseContext) OVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVER, 0) +} + +func (s *Over_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Over_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Over_clauseContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Over_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Over_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Over_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Over_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Over_clauseContext) Query_partition_clause() IQuery_partition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_partition_clauseContext) +} + +func (s *Over_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Over_clauseContext) ACROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACROSS, 0) +} + +func (s *Over_clauseContext) ANCESTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCESTOR, 0) +} + +func (s *Over_clauseContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Over_clauseContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Over_clauseContext) Windowing_clause() IWindowing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_clauseContext) +} + +func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (p *PlSqlParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2202, PlSqlParserRULE_over_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19841) + p.Match(PlSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19842) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserORDER, PlSqlParserPARTITION, PlSqlParserRIGHT_PAREN: + p.SetState(19844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(19843) + p.Query_partition_clause() + } + + } + p.SetState(19850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(19846) + p.Order_by_clause() + } + p.SetState(19848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRANGE || _la == PlSqlParserROWS { + { + p.SetState(19847) + p.Windowing_clause() + } + + } + + } + + case PlSqlParserHIERARCHY: + { + p.SetState(19852) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19853) + + var _x = p.Id_expression() + + localctx.(*Over_clauseContext).th = _x + } + { + p.SetState(19854) + p.Match(PlSqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19855) + p.Numeric() + } + p.SetState(19861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACROSS { + { + p.SetState(19856) + p.Match(PlSqlParserACROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19857) + p.Match(PlSqlParserANCESTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19858) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19859) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19860) + p.Id_expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(19865) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowing_clauseContext is an interface to support dynamic dispatch. +type IWindowing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Windowing_type() IWindowing_typeContext + BETWEEN() antlr.TerminalNode + AllWindowing_elements() []IWindowing_elementsContext + Windowing_elements(i int) IWindowing_elementsContext + AND() antlr.TerminalNode + + // IsWindowing_clauseContext differentiates from other interfaces. + IsWindowing_clauseContext() +} + +type Windowing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_clauseContext() *Windowing_clauseContext { + var p = new(Windowing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_clause + return p +} + +func InitEmptyWindowing_clauseContext(p *Windowing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_clause +} + +func (*Windowing_clauseContext) IsWindowing_clauseContext() {} + +func NewWindowing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_clauseContext { + var p = new(Windowing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_clause + + return p +} + +func (s *Windowing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_clauseContext) Windowing_type() IWindowing_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_typeContext) +} + +func (s *Windowing_clauseContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Windowing_clauseContext) AllWindowing_elements() []IWindowing_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindowing_elementsContext); ok { + len++ + } + } + + tst := make([]IWindowing_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindowing_elementsContext); ok { + tst[i] = t.(IWindowing_elementsContext) + i++ + } + } + + return tst +} + +func (s *Windowing_clauseContext) Windowing_elements(i int) IWindowing_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_elementsContext) +} + +func (s *Windowing_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Windowing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_clause(s) + } +} + +func (s *Windowing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_clause(s) + } +} + +func (p *PlSqlParser) Windowing_clause() (localctx IWindowing_clauseContext) { + localctx = NewWindowing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2204, PlSqlParserRULE_windowing_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19867) + p.Windowing_type() + } + p.SetState(19874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2814, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19868) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19869) + p.Windowing_elements() + } + { + p.SetState(19870) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19871) + p.Windowing_elements() + } + + case 2: + { + p.SetState(19873) + p.Windowing_elements() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowing_typeContext is an interface to support dynamic dispatch. +type IWindowing_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS() antlr.TerminalNode + RANGE() antlr.TerminalNode + + // IsWindowing_typeContext differentiates from other interfaces. + IsWindowing_typeContext() +} + +type Windowing_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_typeContext() *Windowing_typeContext { + var p = new(Windowing_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_type + return p +} + +func InitEmptyWindowing_typeContext(p *Windowing_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_type +} + +func (*Windowing_typeContext) IsWindowing_typeContext() {} + +func NewWindowing_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_typeContext { + var p = new(Windowing_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_type + + return p +} + +func (s *Windowing_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_typeContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Windowing_typeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Windowing_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_type(s) + } +} + +func (s *Windowing_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_type(s) + } +} + +func (p *PlSqlParser) Windowing_type() (localctx IWindowing_typeContext) { + localctx = NewWindowing_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2206, PlSqlParserRULE_windowing_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19876) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRANGE || _la == PlSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowing_elementsContext is an interface to support dynamic dispatch. +type IWindowing_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ROW() antlr.TerminalNode + Concatenation() IConcatenationContext + FOLLOWING() antlr.TerminalNode + + // IsWindowing_elementsContext differentiates from other interfaces. + IsWindowing_elementsContext() +} + +type Windowing_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_elementsContext() *Windowing_elementsContext { + var p = new(Windowing_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_elements + return p +} + +func InitEmptyWindowing_elementsContext(p *Windowing_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_elements +} + +func (*Windowing_elementsContext) IsWindowing_elementsContext() {} + +func NewWindowing_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_elementsContext { + var p = new(Windowing_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_elements + + return p +} + +func (s *Windowing_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_elementsContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUNDED, 0) +} + +func (s *Windowing_elementsContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDING, 0) +} + +func (s *Windowing_elementsContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Windowing_elementsContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Windowing_elementsContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Windowing_elementsContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWING, 0) +} + +func (s *Windowing_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_elements(s) + } +} + +func (s *Windowing_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_elements(s) + } +} + +func (p *PlSqlParser) Windowing_elements() (localctx IWindowing_elementsContext) { + localctx = NewWindowing_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2208, PlSqlParserRULE_windowing_elements) + var _la int + + p.SetState(19885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2815, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19878) + p.Match(PlSqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19879) + p.Match(PlSqlParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19880) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19881) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19882) + p.concatenation(0) + } + { + p.SetState(19883) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFOLLOWING || _la == PlSqlParserPRECEDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_clauseContext is an interface to support dynamic dispatch. +type IUsing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllUsing_element() []IUsing_elementContext + Using_element(i int) IUsing_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUsing_clauseContext differentiates from other interfaces. + IsUsing_clauseContext() +} + +type Using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_clauseContext() *Using_clauseContext { + var p = new(Using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_clause + return p +} + +func InitEmptyUsing_clauseContext(p *Using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_clause +} + +func (*Using_clauseContext) IsUsing_clauseContext() {} + +func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext { + var p = new(Using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_clause + + return p +} + +func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_clauseContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Using_clauseContext) AllUsing_element() []IUsing_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUsing_elementContext); ok { + len++ + } + } + + tst := make([]IUsing_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUsing_elementContext); ok { + tst[i] = t.(IUsing_elementContext) + i++ + } + } + + return tst +} + +func (s *Using_clauseContext) Using_element(i int) IUsing_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUsing_elementContext) +} + +func (s *Using_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Using_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_clause(s) + } +} + +func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_clause(s) + } +} + +func (p *PlSqlParser) Using_clause() (localctx IUsing_clauseContext) { + localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2210, PlSqlParserRULE_using_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19887) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2817, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19888) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19889) + p.Using_element() + } + p.SetState(19894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2816, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19890) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19891) + p.Using_element() + } + + } + p.SetState(19896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2816, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_elementContext is an interface to support dynamic dispatch. +type IUsing_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + Expression() IExpressionContext + OUT() antlr.TerminalNode + Assignable_element() IAssignable_elementContext + + // IsUsing_elementContext differentiates from other interfaces. + IsUsing_elementContext() +} + +type Using_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_elementContext() *Using_elementContext { + var p = new(Using_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_element + return p +} + +func InitEmptyUsing_elementContext(p *Using_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_element +} + +func (*Using_elementContext) IsUsing_elementContext() {} + +func NewUsing_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_elementContext { + var p = new(Using_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_element + + return p +} + +func (s *Using_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_elementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Using_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Using_elementContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Using_elementContext) Assignable_element() IAssignable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignable_elementContext) +} + +func (s *Using_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_element(s) + } +} + +func (s *Using_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_element(s) + } +} + +func (p *PlSqlParser) Using_element() (localctx IUsing_elementContext) { + localctx = NewUsing_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2212, PlSqlParserRULE_using_element) + p.SetState(19907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2818, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19899) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19900) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19901) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19902) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19903) + p.Assignable_element() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19904) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19905) + p.Assignable_element() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19906) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignable_elementContext is an interface to support dynamic dispatch. +type IAssignable_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + General_element() IGeneral_elementContext + Bind_variable() IBind_variableContext + + // IsAssignable_elementContext differentiates from other interfaces. + IsAssignable_elementContext() +} + +type Assignable_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignable_elementContext() *Assignable_elementContext { + var p = new(Assignable_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignable_element + return p +} + +func InitEmptyAssignable_elementContext(p *Assignable_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignable_element +} + +func (*Assignable_elementContext) IsAssignable_elementContext() {} + +func NewAssignable_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignable_elementContext { + var p = new(Assignable_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_assignable_element + + return p +} + +func (s *Assignable_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assignable_elementContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Assignable_elementContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Assignable_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assignable_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assignable_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAssignable_element(s) + } +} + +func (s *Assignable_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAssignable_element(s) + } +} + +func (p *PlSqlParser) Assignable_element() (localctx IAssignable_elementContext) { + localctx = NewAssignable_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2214, PlSqlParserRULE_assignable_element) + p.SetState(19911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19909) + p.general_element(0) + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19910) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollect_order_by_partContext is an interface to support dynamic dispatch. +type ICollect_order_by_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCollect_order_by_partContext differentiates from other interfaces. + IsCollect_order_by_partContext() +} + +type Collect_order_by_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollect_order_by_partContext() *Collect_order_by_partContext { + var p = new(Collect_order_by_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collect_order_by_part + return p +} + +func InitEmptyCollect_order_by_partContext(p *Collect_order_by_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collect_order_by_part +} + +func (*Collect_order_by_partContext) IsCollect_order_by_partContext() {} + +func NewCollect_order_by_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collect_order_by_partContext { + var p = new(Collect_order_by_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collect_order_by_part + + return p +} + +func (s *Collect_order_by_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collect_order_by_partContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Collect_order_by_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Collect_order_by_partContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Collect_order_by_partContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Collect_order_by_partContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Collect_order_by_partContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Collect_order_by_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collect_order_by_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collect_order_by_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollect_order_by_part(s) + } +} + +func (s *Collect_order_by_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollect_order_by_part(s) + } +} + +func (p *PlSqlParser) Collect_order_by_part() (localctx ICollect_order_by_partContext) { + localctx = NewCollect_order_by_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2216, PlSqlParserRULE_collect_order_by_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19913) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19914) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19915) + p.concatenation(0) + } + p.SetState(19920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19916) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19917) + p.concatenation(0) + } + + p.SetState(19922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithin_or_over_partContext is an interface to support dynamic dispatch. +type IWithin_or_over_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + RIGHT_PAREN() antlr.TerminalNode + Over_clause() IOver_clauseContext + + // IsWithin_or_over_partContext differentiates from other interfaces. + IsWithin_or_over_partContext() +} + +type Within_or_over_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithin_or_over_partContext() *Within_or_over_partContext { + var p = new(Within_or_over_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_part + return p +} + +func InitEmptyWithin_or_over_partContext(p *Within_or_over_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_part +} + +func (*Within_or_over_partContext) IsWithin_or_over_partContext() {} + +func NewWithin_or_over_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_or_over_partContext { + var p = new(Within_or_over_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_within_or_over_part + + return p +} + +func (s *Within_or_over_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Within_or_over_partContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Within_or_over_partContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Within_or_over_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Within_or_over_partContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Within_or_over_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Within_or_over_partContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Within_or_over_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Within_or_over_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Within_or_over_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWithin_or_over_part(s) + } +} + +func (s *Within_or_over_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWithin_or_over_part(s) + } +} + +func (p *PlSqlParser) Within_or_over_part() (localctx IWithin_or_over_partContext) { + localctx = NewWithin_or_over_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2218, PlSqlParserRULE_within_or_over_part) + p.SetState(19930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITHIN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19923) + p.Match(PlSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19924) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19925) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19926) + p.Order_by_clause() + } + { + p.SetState(19927) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOVER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19929) + p.Over_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_delimiterContext is an interface to support dynamic dispatch. +type IString_delimiterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + String_function() IString_functionContext + LEFT_PAREN() antlr.TerminalNode + AllString_delimiter() []IString_delimiterContext + String_delimiter(i int) IString_delimiterContext + RIGHT_PAREN() antlr.TerminalNode + Id_expression() IId_expressionContext + AllBAR() []antlr.TerminalNode + BAR(i int) antlr.TerminalNode + + // IsString_delimiterContext differentiates from other interfaces. + IsString_delimiterContext() +} + +type String_delimiterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_delimiterContext() *String_delimiterContext { + var p = new(String_delimiterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_delimiter + return p +} + +func InitEmptyString_delimiterContext(p *String_delimiterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_delimiter +} + +func (*String_delimiterContext) IsString_delimiterContext() {} + +func NewString_delimiterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_delimiterContext { + var p = new(String_delimiterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_string_delimiter + + return p +} + +func (s *String_delimiterContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_delimiterContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *String_delimiterContext) String_function() IString_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_functionContext) +} + +func (s *String_delimiterContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *String_delimiterContext) AllString_delimiter() []IString_delimiterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_delimiterContext); ok { + len++ + } + } + + tst := make([]IString_delimiterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_delimiterContext); ok { + tst[i] = t.(IString_delimiterContext) + i++ + } + } + + return tst +} + +func (s *String_delimiterContext) String_delimiter(i int) IString_delimiterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_delimiterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_delimiterContext) +} + +func (s *String_delimiterContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *String_delimiterContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *String_delimiterContext) AllBAR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBAR) +} + +func (s *String_delimiterContext) BAR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBAR, i) +} + +func (s *String_delimiterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_delimiterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_delimiterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterString_delimiter(s) + } +} + +func (s *String_delimiterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_delimiter(s) + } +} + +func (p *PlSqlParser) String_delimiter() (localctx IString_delimiterContext) { + return p.string_delimiter(0) +} + +func (p *PlSqlParser) string_delimiter(_p int) (localctx IString_delimiterContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewString_delimiterContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IString_delimiterContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2220 + p.EnterRecursionRule(localctx, 2220, PlSqlParserRULE_string_delimiter, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2822, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19933) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19934) + p.String_function() + } + + case 3: + { + p.SetState(19935) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19936) + p.string_delimiter(0) + } + { + p.SetState(19937) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(19939) + p.Id_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(19948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2823, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewString_delimiterContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_string_delimiter) + p.SetState(19942) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(19943) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19944) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19945) + p.string_delimiter(4) + } + + } + p.SetState(19950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2823, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICost_matrix_clauseContext is an interface to support dynamic dispatch. +type ICost_matrix_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COST() antlr.TerminalNode + MODEL() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllCost_class_name() []ICost_class_nameContext + Cost_class_name(i int) ICost_class_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + VALUES() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Expressions_() IExpressions_Context + + // IsCost_matrix_clauseContext differentiates from other interfaces. + IsCost_matrix_clauseContext() +} + +type Cost_matrix_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCost_matrix_clauseContext() *Cost_matrix_clauseContext { + var p = new(Cost_matrix_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause + return p +} + +func InitEmptyCost_matrix_clauseContext(p *Cost_matrix_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause +} + +func (*Cost_matrix_clauseContext) IsCost_matrix_clauseContext() {} + +func NewCost_matrix_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cost_matrix_clauseContext { + var p = new(Cost_matrix_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause + + return p +} + +func (s *Cost_matrix_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cost_matrix_clauseContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Cost_matrix_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Cost_matrix_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Cost_matrix_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Cost_matrix_clauseContext) AllCost_class_name() []ICost_class_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICost_class_nameContext); ok { + len++ + } + } + + tst := make([]ICost_class_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICost_class_nameContext); ok { + tst[i] = t.(ICost_class_nameContext) + i++ + } + } + + return tst +} + +func (s *Cost_matrix_clauseContext) Cost_class_name(i int) ICost_class_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICost_class_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICost_class_nameContext) +} + +func (s *Cost_matrix_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Cost_matrix_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Cost_matrix_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Cost_matrix_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Cost_matrix_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cost_matrix_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cost_matrix_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Cost_matrix_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cost_matrix_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cost_matrix_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCost_matrix_clause(s) + } +} + +func (s *Cost_matrix_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCost_matrix_clause(s) + } +} + +func (p *PlSqlParser) Cost_matrix_clause() (localctx ICost_matrix_clauseContext) { + localctx = NewCost_matrix_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2222, PlSqlParserRULE_cost_matrix_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19951) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMODEL: + { + p.SetState(19952) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTO { + { + p.SetState(19953) + p.Match(PlSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(19956) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19957) + p.Cost_class_name() + } + p.SetState(19962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19958) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19959) + p.Cost_class_name() + } + + p.SetState(19964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19965) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19966) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19967) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19969) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2826, p.GetParserRuleContext()) == 1 { + { + p.SetState(19968) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19971) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_passing_clauseContext is an interface to support dynamic dispatch. +type IXml_passing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSING() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + BY() antlr.TerminalNode + VALUE() antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXml_passing_clauseContext differentiates from other interfaces. + IsXml_passing_clauseContext() +} + +type Xml_passing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_passing_clauseContext() *Xml_passing_clauseContext { + var p = new(Xml_passing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_passing_clause + return p +} + +func InitEmptyXml_passing_clauseContext(p *Xml_passing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_passing_clause +} + +func (*Xml_passing_clauseContext) IsXml_passing_clauseContext() {} + +func NewXml_passing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_passing_clauseContext { + var p = new(Xml_passing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_passing_clause + + return p +} + +func (s *Xml_passing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_passing_clauseContext) PASSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSING, 0) +} + +func (s *Xml_passing_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xml_passing_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xml_passing_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Xml_passing_clauseContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xml_passing_clauseContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Xml_passing_clauseContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Xml_passing_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_passing_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_passing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_passing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_passing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_passing_clause(s) + } +} + +func (s *Xml_passing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_passing_clause(s) + } +} + +func (p *PlSqlParser) Xml_passing_clause() (localctx IXml_passing_clauseContext) { + localctx = NewXml_passing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2224, PlSqlParserRULE_xml_passing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19975) + p.Match(PlSqlParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19978) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2828, p.GetParserRuleContext()) == 1 { + { + p.SetState(19976) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19977) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19980) + p.Expression() + } + p.SetState(19982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2829, p.GetParserRuleContext()) == 1 { + { + p.SetState(19981) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19984) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19985) + p.Expression() + } + p.SetState(19987) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2830, p.GetParserRuleContext()) == 1 { + { + p.SetState(19986) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.SetState(19993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_attributes_clauseContext is an interface to support dynamic dispatch. +type IXml_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext + Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ENTITYESCAPING() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + SCHEMACHECK() antlr.TerminalNode + NOSCHEMACHECK() antlr.TerminalNode + + // IsXml_attributes_clauseContext differentiates from other interfaces. + IsXml_attributes_clauseContext() +} + +type Xml_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_attributes_clauseContext() *Xml_attributes_clauseContext { + var p = new(Xml_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause + return p +} + +func InitEmptyXml_attributes_clauseContext(p *Xml_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause +} + +func (*Xml_attributes_clauseContext) IsXml_attributes_clauseContext() {} + +func NewXml_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attributes_clauseContext { + var p = new(Xml_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause + + return p +} + +func (s *Xml_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_attributes_clauseContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLATTRIBUTES, 0) +} + +func (s *Xml_attributes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xml_attributes_clauseContext) AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + len++ + } + } + + tst := make([]IXml_multiuse_expression_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + tst[i] = t.(IXml_multiuse_expression_elementContext) + i++ + } + } + + return tst +} + +func (s *Xml_attributes_clauseContext) Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_multiuse_expression_elementContext) +} + +func (s *Xml_attributes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xml_attributes_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_attributes_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_attributes_clauseContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Xml_attributes_clauseContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Xml_attributes_clauseContext) SCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMACHECK, 0) +} + +func (s *Xml_attributes_clauseContext) NOSCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCHEMACHECK, 0) +} + +func (s *Xml_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_attributes_clause(s) + } +} + +func (s *Xml_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_attributes_clause(s) + } +} + +func (p *PlSqlParser) Xml_attributes_clause() (localctx IXml_attributes_clauseContext) { + localctx = NewXml_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2226, PlSqlParserRULE_xml_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19994) + p.Match(PlSqlParserXMLATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19995) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19997) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2832, p.GetParserRuleContext()) == 1 { + { + p.SetState(19996) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENTITYESCAPING || _la == PlSqlParserNOENTITYESCAPING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20000) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2833, p.GetParserRuleContext()) == 1 { + { + p.SetState(19999) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOSCHEMACHECK || _la == PlSqlParserSCHEMACHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20002) + p.Xml_multiuse_expression_element() + } + p.SetState(20007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20003) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20004) + p.Xml_multiuse_expression_element() + } + + p.SetState(20009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(20010) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_namespaces_clauseContext is an interface to support dynamic dispatch. +type IXml_namespaces_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLNAMESPACES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Xml_general_default_part() IXml_general_default_partContext + + // IsXml_namespaces_clauseContext differentiates from other interfaces. + IsXml_namespaces_clauseContext() +} + +type Xml_namespaces_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_namespaces_clauseContext() *Xml_namespaces_clauseContext { + var p = new(Xml_namespaces_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause + return p +} + +func InitEmptyXml_namespaces_clauseContext(p *Xml_namespaces_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause +} + +func (*Xml_namespaces_clauseContext) IsXml_namespaces_clauseContext() {} + +func NewXml_namespaces_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespaces_clauseContext { + var p = new(Xml_namespaces_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause + + return p +} + +func (s *Xml_namespaces_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_namespaces_clauseContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLNAMESPACES, 0) +} + +func (s *Xml_namespaces_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xml_namespaces_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xml_namespaces_clauseContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Xml_namespaces_clauseContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_namespaces_clauseContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Xml_namespaces_clauseContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Xml_namespaces_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_namespaces_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_namespaces_clauseContext) Xml_general_default_part() IXml_general_default_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_general_default_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_general_default_partContext) +} + +func (s *Xml_namespaces_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_namespaces_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_namespaces_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_namespaces_clause(s) + } +} + +func (s *Xml_namespaces_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_namespaces_clause(s) + } +} + +func (p *PlSqlParser) Xml_namespaces_clause() (localctx IXml_namespaces_clauseContext) { + localctx = NewXml_namespaces_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2228, PlSqlParserRULE_xml_namespaces_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20012) + p.Match(PlSqlParserXMLNAMESPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20013) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20017) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2835, p.GetParserRuleContext()) == 1 { + { + p.SetState(20014) + p.concatenation(0) + } + { + p.SetState(20015) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20019) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20020) + p.concatenation(0) + } + { + p.SetState(20021) + p.Column_alias() + } + + p.SetState(20027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(20029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(20028) + p.Xml_general_default_part() + } + + } + { + p.SetState(20031) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_table_columnContext is an interface to support dynamic dispatch. +type IXml_table_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Xml_column_name() IXml_column_nameContext + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + Type_spec() IType_specContext + PATH() antlr.TerminalNode + Concatenation() IConcatenationContext + Xml_general_default_part() IXml_general_default_partContext + + // IsXml_table_columnContext differentiates from other interfaces. + IsXml_table_columnContext() +} + +type Xml_table_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_table_columnContext() *Xml_table_columnContext { + var p = new(Xml_table_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_table_column + return p +} + +func InitEmptyXml_table_columnContext(p *Xml_table_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_table_column +} + +func (*Xml_table_columnContext) IsXml_table_columnContext() {} + +func NewXml_table_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_table_columnContext { + var p = new(Xml_table_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_table_column + + return p +} + +func (s *Xml_table_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_table_columnContext) Xml_column_name() IXml_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_column_nameContext) +} + +func (s *Xml_table_columnContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Xml_table_columnContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Xml_table_columnContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Xml_table_columnContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Xml_table_columnContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_table_columnContext) Xml_general_default_part() IXml_general_default_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_general_default_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_general_default_partContext) +} + +func (s *Xml_table_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_table_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_table_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_table_column(s) + } +} + +func (s *Xml_table_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_table_column(s) + } +} + +func (p *PlSqlParser) Xml_table_column() (localctx IXml_table_columnContext) { + localctx = NewXml_table_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2230, PlSqlParserRULE_xml_table_column) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20033) + p.Xml_column_name() + } + p.SetState(20044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFOR: + { + p.SetState(20034) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20035) + p.Match(PlSqlParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNATURALN, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(20036) + p.Type_spec() + } + p.SetState(20039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPATH { + { + p.SetState(20037) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20038) + p.concatenation(0) + } + + } + p.SetState(20042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(20041) + p.Xml_general_default_part() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_general_default_partContext is an interface to support dynamic dispatch. +type IXml_general_default_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXml_general_default_partContext differentiates from other interfaces. + IsXml_general_default_partContext() +} + +type Xml_general_default_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_general_default_partContext() *Xml_general_default_partContext { + var p = new(Xml_general_default_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_general_default_part + return p +} + +func InitEmptyXml_general_default_partContext(p *Xml_general_default_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_general_default_part +} + +func (*Xml_general_default_partContext) IsXml_general_default_partContext() {} + +func NewXml_general_default_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_general_default_partContext { + var p = new(Xml_general_default_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_general_default_part + + return p +} + +func (s *Xml_general_default_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_general_default_partContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Xml_general_default_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_general_default_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_general_default_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_general_default_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_general_default_part(s) + } +} + +func (s *Xml_general_default_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_general_default_part(s) + } +} + +func (p *PlSqlParser) Xml_general_default_part() (localctx IXml_general_default_partContext) { + localctx = NewXml_general_default_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2232, PlSqlParserRULE_xml_general_default_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20046) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20047) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_multiuse_expression_elementContext is an interface to support dynamic dispatch. +type IXml_multiuse_expression_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + Id_expression() IId_expressionContext + AS() antlr.TerminalNode + EVALNAME() antlr.TerminalNode + + // IsXml_multiuse_expression_elementContext differentiates from other interfaces. + IsXml_multiuse_expression_elementContext() +} + +type Xml_multiuse_expression_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_multiuse_expression_elementContext() *Xml_multiuse_expression_elementContext { + var p = new(Xml_multiuse_expression_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element + return p +} + +func InitEmptyXml_multiuse_expression_elementContext(p *Xml_multiuse_expression_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element +} + +func (*Xml_multiuse_expression_elementContext) IsXml_multiuse_expression_elementContext() {} + +func NewXml_multiuse_expression_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_multiuse_expression_elementContext { + var p = new(Xml_multiuse_expression_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element + + return p +} + +func (s *Xml_multiuse_expression_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_multiuse_expression_elementContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xml_multiuse_expression_elementContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xml_multiuse_expression_elementContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Xml_multiuse_expression_elementContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xml_multiuse_expression_elementContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Xml_multiuse_expression_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_multiuse_expression_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_multiuse_expression_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_multiuse_expression_element(s) + } +} + +func (s *Xml_multiuse_expression_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_multiuse_expression_element(s) + } +} + +func (p *PlSqlParser) Xml_multiuse_expression_element() (localctx IXml_multiuse_expression_elementContext) { + localctx = NewXml_multiuse_expression_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2234, PlSqlParserRULE_xml_multiuse_expression_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20049) + p.Expression() + } + p.SetState(20057) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2842, p.GetParserRuleContext()) == 1 { + p.SetState(20051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(20050) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20053) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2842, p.GetParserRuleContext()) == 2 { + { + p.SetState(20054) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20055) + p.Match(PlSqlParserEVALNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20056) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlroot_param_version_partContext is an interface to support dynamic dispatch. +type IXmlroot_param_version_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION() antlr.TerminalNode + NO() antlr.TerminalNode + VALUE() antlr.TerminalNode + Expression() IExpressionContext + + // IsXmlroot_param_version_partContext differentiates from other interfaces. + IsXmlroot_param_version_partContext() +} + +type Xmlroot_param_version_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlroot_param_version_partContext() *Xmlroot_param_version_partContext { + var p = new(Xmlroot_param_version_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part + return p +} + +func InitEmptyXmlroot_param_version_partContext(p *Xmlroot_param_version_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part +} + +func (*Xmlroot_param_version_partContext) IsXmlroot_param_version_partContext() {} + +func NewXmlroot_param_version_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlroot_param_version_partContext { + var p = new(Xmlroot_param_version_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part + + return p +} + +func (s *Xmlroot_param_version_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlroot_param_version_partContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Xmlroot_param_version_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlroot_param_version_partContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xmlroot_param_version_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmlroot_param_version_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlroot_param_version_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlroot_param_version_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlroot_param_version_part(s) + } +} + +func (s *Xmlroot_param_version_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlroot_param_version_part(s) + } +} + +func (p *PlSqlParser) Xmlroot_param_version_part() (localctx IXmlroot_param_version_partContext) { + localctx = NewXmlroot_param_version_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2236, PlSqlParserRULE_xmlroot_param_version_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20059) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2843, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20060) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20061) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(20062) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlroot_param_standalone_partContext is an interface to support dynamic dispatch. +type IXmlroot_param_standalone_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STANDALONE() antlr.TerminalNode + YES() antlr.TerminalNode + NO() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsXmlroot_param_standalone_partContext differentiates from other interfaces. + IsXmlroot_param_standalone_partContext() +} + +type Xmlroot_param_standalone_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlroot_param_standalone_partContext() *Xmlroot_param_standalone_partContext { + var p = new(Xmlroot_param_standalone_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part + return p +} + +func InitEmptyXmlroot_param_standalone_partContext(p *Xmlroot_param_standalone_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part +} + +func (*Xmlroot_param_standalone_partContext) IsXmlroot_param_standalone_partContext() {} + +func NewXmlroot_param_standalone_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlroot_param_standalone_partContext { + var p = new(Xmlroot_param_standalone_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part + + return p +} + +func (s *Xmlroot_param_standalone_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlroot_param_standalone_partContext) STANDALONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDALONE, 0) +} + +func (s *Xmlroot_param_standalone_partContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Xmlroot_param_standalone_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlroot_param_standalone_partContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xmlroot_param_standalone_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlroot_param_standalone_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlroot_param_standalone_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlroot_param_standalone_part(s) + } +} + +func (s *Xmlroot_param_standalone_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlroot_param_standalone_part(s) + } +} + +func (p *PlSqlParser) Xmlroot_param_standalone_part() (localctx IXmlroot_param_standalone_partContext) { + localctx = NewXmlroot_param_standalone_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2238, PlSqlParserRULE_xmlroot_param_standalone_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20065) + p.Match(PlSqlParserSTANDALONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserYES: + { + p.SetState(20066) + p.Match(PlSqlParserYES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNO: + { + p.SetState(20067) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUE { + { + p.SetState(20068) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlserialize_param_enconding_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_enconding_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCODING() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_enconding_partContext differentiates from other interfaces. + IsXmlserialize_param_enconding_partContext() +} + +type Xmlserialize_param_enconding_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_enconding_partContext() *Xmlserialize_param_enconding_partContext { + var p = new(Xmlserialize_param_enconding_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part + return p +} + +func InitEmptyXmlserialize_param_enconding_partContext(p *Xmlserialize_param_enconding_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part +} + +func (*Xmlserialize_param_enconding_partContext) IsXmlserialize_param_enconding_partContext() {} + +func NewXmlserialize_param_enconding_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_enconding_partContext { + var p = new(Xmlserialize_param_enconding_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part + + return p +} + +func (s *Xmlserialize_param_enconding_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_enconding_partContext) ENCODING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCODING, 0) +} + +func (s *Xmlserialize_param_enconding_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_enconding_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_enconding_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_enconding_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_enconding_part(s) + } +} + +func (s *Xmlserialize_param_enconding_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_enconding_part(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_enconding_part() (localctx IXmlserialize_param_enconding_partContext) { + localctx = NewXmlserialize_param_enconding_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2240, PlSqlParserRULE_xmlserialize_param_enconding_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20073) + p.Match(PlSqlParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20074) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlserialize_param_version_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_version_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_version_partContext differentiates from other interfaces. + IsXmlserialize_param_version_partContext() +} + +type Xmlserialize_param_version_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_version_partContext() *Xmlserialize_param_version_partContext { + var p = new(Xmlserialize_param_version_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part + return p +} + +func InitEmptyXmlserialize_param_version_partContext(p *Xmlserialize_param_version_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part +} + +func (*Xmlserialize_param_version_partContext) IsXmlserialize_param_version_partContext() {} + +func NewXmlserialize_param_version_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_version_partContext { + var p = new(Xmlserialize_param_version_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part + + return p +} + +func (s *Xmlserialize_param_version_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_version_partContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Xmlserialize_param_version_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_version_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_version_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_version_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_version_part(s) + } +} + +func (s *Xmlserialize_param_version_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_version_part(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_version_part() (localctx IXmlserialize_param_version_partContext) { + localctx = NewXmlserialize_param_version_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2242, PlSqlParserRULE_xmlserialize_param_version_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20076) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20077) + p.concatenation(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlserialize_param_ident_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_ident_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + INDENT() antlr.TerminalNode + SIZE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_ident_partContext differentiates from other interfaces. + IsXmlserialize_param_ident_partContext() +} + +type Xmlserialize_param_ident_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_ident_partContext() *Xmlserialize_param_ident_partContext { + var p = new(Xmlserialize_param_ident_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part + return p +} + +func InitEmptyXmlserialize_param_ident_partContext(p *Xmlserialize_param_ident_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part +} + +func (*Xmlserialize_param_ident_partContext) IsXmlserialize_param_ident_partContext() {} + +func NewXmlserialize_param_ident_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_ident_partContext { + var p = new(Xmlserialize_param_ident_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part + + return p +} + +func (s *Xmlserialize_param_ident_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_ident_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlserialize_param_ident_partContext) INDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDENT, 0) +} + +func (s *Xmlserialize_param_ident_partContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Xmlserialize_param_ident_partContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Xmlserialize_param_ident_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_ident_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_ident_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_ident_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_ident_part(s) + } +} + +func (s *Xmlserialize_param_ident_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_ident_part(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_ident_part() (localctx IXmlserialize_param_ident_partContext) { + localctx = NewXmlserialize_param_ident_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2244, PlSqlParserRULE_xmlserialize_param_ident_part) + var _la int + + p.SetState(20087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20079) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20080) + p.Match(PlSqlParserINDENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20081) + p.Match(PlSqlParserINDENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(20082) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20083) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20084) + p.concatenation(0) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnnotations_clauseContext is an interface to support dynamic dispatch. +type IAnnotations_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANNOTATIONS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Annotations_list() IAnnotations_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsAnnotations_clauseContext differentiates from other interfaces. + IsAnnotations_clauseContext() +} + +type Annotations_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotations_clauseContext() *Annotations_clauseContext { + var p = new(Annotations_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotations_clause + return p +} + +func InitEmptyAnnotations_clauseContext(p *Annotations_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotations_clause +} + +func (*Annotations_clauseContext) IsAnnotations_clauseContext() {} + +func NewAnnotations_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Annotations_clauseContext { + var p = new(Annotations_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_annotations_clause + + return p +} + +func (s *Annotations_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Annotations_clauseContext) ANNOTATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserANNOTATIONS, 0) +} + +func (s *Annotations_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Annotations_clauseContext) Annotations_list() IAnnotations_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_listContext) +} + +func (s *Annotations_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Annotations_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Annotations_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Annotations_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnnotations_clause(s) + } +} + +func (s *Annotations_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnnotations_clause(s) + } +} + +func (p *PlSqlParser) Annotations_clause() (localctx IAnnotations_clauseContext) { + localctx = NewAnnotations_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2246, PlSqlParserRULE_annotations_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20089) + p.Match(PlSqlParserANNOTATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20090) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20091) + p.Annotations_list() + } + { + p.SetState(20092) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnnotations_listContext is an interface to support dynamic dispatch. +type IAnnotations_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Annotation() IAnnotationContext + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllAnnotations_list() []IAnnotations_listContext + Annotations_list(i int) IAnnotations_listContext + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsAnnotations_listContext differentiates from other interfaces. + IsAnnotations_listContext() +} + +type Annotations_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotations_listContext() *Annotations_listContext { + var p = new(Annotations_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotations_list + return p +} + +func InitEmptyAnnotations_listContext(p *Annotations_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotations_list +} + +func (*Annotations_listContext) IsAnnotations_listContext() {} + +func NewAnnotations_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Annotations_listContext { + var p = new(Annotations_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_annotations_list + + return p +} + +func (s *Annotations_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Annotations_listContext) Annotation() IAnnotationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnnotationContext) +} + +func (s *Annotations_listContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Annotations_listContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Annotations_listContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Annotations_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Annotations_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Annotations_listContext) AllAnnotations_list() []IAnnotations_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAnnotations_listContext); ok { + len++ + } + } + + tst := make([]IAnnotations_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAnnotations_listContext); ok { + tst[i] = t.(IAnnotations_listContext) + i++ + } + } + + return tst +} + +func (s *Annotations_listContext) Annotations_list(i int) IAnnotations_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnnotations_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAnnotations_listContext) +} + +func (s *Annotations_listContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Annotations_listContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Annotations_listContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Annotations_listContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Annotations_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Annotations_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Annotations_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnnotations_list(s) + } +} + +func (s *Annotations_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnnotations_list(s) + } +} + +func (p *PlSqlParser) Annotations_list() (localctx IAnnotations_listContext) { + localctx = NewAnnotations_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2248, PlSqlParserRULE_annotations_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20108) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2850, p.GetParserRuleContext()) == 1 { + { + p.SetState(20094) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20100) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2848, p.GetParserRuleContext()) == 1 { + { + p.SetState(20095) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20096) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20097) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2848, p.GetParserRuleContext()) == 2 { + { + p.SetState(20098) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20099) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2850, p.GetParserRuleContext()) == 2 { + { + p.SetState(20102) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2849, p.GetParserRuleContext()) == 1 { + { + p.SetState(20103) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20104) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2850, p.GetParserRuleContext()) == 3 { + { + p.SetState(20107) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20110) + p.Annotation() + } + p.SetState(20115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2851, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20111) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20112) + p.Annotations_list() + } + + } + p.SetState(20117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2851, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnnotationContext is an interface to support dynamic dispatch. +type IAnnotationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + CHAR_STRING() antlr.TerminalNode + + // IsAnnotationContext differentiates from other interfaces. + IsAnnotationContext() +} + +type AnnotationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnnotationContext() *AnnotationContext { + var p = new(AnnotationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotation + return p +} + +func InitEmptyAnnotationContext(p *AnnotationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_annotation +} + +func (*AnnotationContext) IsAnnotationContext() {} + +func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext { + var p = new(AnnotationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_annotation + + return p +} + +func (s *AnnotationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnnotationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AnnotationContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *AnnotationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnnotation(s) + } +} + +func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnnotation(s) + } +} + +func (p *PlSqlParser) Annotation() (localctx IAnnotationContext) { + localctx = NewAnnotationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2250, PlSqlParserRULE_annotation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20118) + p.Identifier() + } + p.SetState(20120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(20119) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_plus_commandContext is an interface to support dynamic dispatch. +type ISql_plus_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXIT() antlr.TerminalNode + PROMPT_MESSAGE() antlr.TerminalNode + SHOW() antlr.TerminalNode + ERR() antlr.TerminalNode + ERRORS() antlr.TerminalNode + Whenever_command() IWhenever_commandContext + Timing_command() ITiming_commandContext + Start_command() IStart_commandContext + Set_command() ISet_commandContext + Clear_command() IClear_commandContext + + // IsSql_plus_commandContext differentiates from other interfaces. + IsSql_plus_commandContext() +} + +type Sql_plus_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_plus_commandContext() *Sql_plus_commandContext { + var p = new(Sql_plus_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_command + return p +} + +func InitEmptySql_plus_commandContext(p *Sql_plus_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_command +} + +func (*Sql_plus_commandContext) IsSql_plus_commandContext() {} + +func NewSql_plus_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_plus_commandContext { + var p = new(Sql_plus_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_plus_command + + return p +} + +func (s *Sql_plus_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_plus_commandContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Sql_plus_commandContext) PROMPT_MESSAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROMPT_MESSAGE, 0) +} + +func (s *Sql_plus_commandContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Sql_plus_commandContext) ERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERR, 0) +} + +func (s *Sql_plus_commandContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Sql_plus_commandContext) Whenever_command() IWhenever_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenever_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhenever_commandContext) +} + +func (s *Sql_plus_commandContext) Timing_command() ITiming_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITiming_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITiming_commandContext) +} + +func (s *Sql_plus_commandContext) Start_command() IStart_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_commandContext) +} + +func (s *Sql_plus_commandContext) Set_command() ISet_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_commandContext) +} + +func (s *Sql_plus_commandContext) Clear_command() IClear_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClear_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClear_commandContext) +} + +func (s *Sql_plus_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_plus_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_plus_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_plus_command(s) + } +} + +func (s *Sql_plus_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_plus_command(s) + } +} + +func (p *PlSqlParser) Sql_plus_command() (localctx ISql_plus_commandContext) { + localctx = NewSql_plus_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2252, PlSqlParserRULE_sql_plus_command) + var _la int + + p.SetState(20131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20122) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPROMPT_MESSAGE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20123) + p.Match(PlSqlParserPROMPT_MESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSHOW: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20124) + p.Match(PlSqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20125) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERR || _la == PlSqlParserERRORS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserWHENEVER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20126) + p.Whenever_command() + } + + case PlSqlParserTIMING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20127) + p.Timing_command() + } + + case PlSqlParserSTART, PlSqlParserAT_SIGN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20128) + p.Start_command() + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20129) + p.Set_command() + } + + case PlSqlParserALL, PlSqlParserCLEAR: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20130) + p.Clear_command() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_commandContext is an interface to support dynamic dispatch. +type IStart_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_plus_filepath() ISql_plus_filepathContext + START() antlr.TerminalNode + AllAT_SIGN() []antlr.TerminalNode + AT_SIGN(i int) antlr.TerminalNode + + // IsStart_commandContext differentiates from other interfaces. + IsStart_commandContext() +} + +type Start_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_commandContext() *Start_commandContext { + var p = new(Start_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_command + return p +} + +func InitEmptyStart_commandContext(p *Start_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_command +} + +func (*Start_commandContext) IsStart_commandContext() {} + +func NewStart_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_commandContext { + var p = new(Start_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_command + + return p +} + +func (s *Start_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_commandContext) Sql_plus_filepath() ISql_plus_filepathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_plus_filepathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_plus_filepathContext) +} + +func (s *Start_commandContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Start_commandContext) AllAT_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAT_SIGN) +} + +func (s *Start_commandContext) AT_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, i) +} + +func (s *Start_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_command(s) + } +} + +func (s *Start_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_command(s) + } +} + +func (p *PlSqlParser) Start_command() (localctx IStart_commandContext) { + localctx = NewStart_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2254, PlSqlParserRULE_start_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + { + p.SetState(20133) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAT_SIGN: + { + p.SetState(20134) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAT_SIGN { + { + p.SetState(20135) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(20140) + p.Sql_plus_filepath() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_plus_filepathContext is an interface to support dynamic dispatch. +type ISql_plus_filepathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + SQL() antlr.TerminalNode + FILE_EXT() antlr.TerminalNode + COLON() antlr.TerminalNode + AllSOLIDUS() []antlr.TerminalNode + SOLIDUS(i int) antlr.TerminalNode + AllRSOLIDUS() []antlr.TerminalNode + RSOLIDUS(i int) antlr.TerminalNode + + // IsSql_plus_filepathContext differentiates from other interfaces. + IsSql_plus_filepathContext() +} + +type Sql_plus_filepathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_plus_filepathContext() *Sql_plus_filepathContext { + var p = new(Sql_plus_filepathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_filepath + return p +} + +func InitEmptySql_plus_filepathContext(p *Sql_plus_filepathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_filepath +} + +func (*Sql_plus_filepathContext) IsSql_plus_filepathContext() {} + +func NewSql_plus_filepathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_plus_filepathContext { + var p = new(Sql_plus_filepathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_plus_filepath + + return p +} + +func (s *Sql_plus_filepathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_plus_filepathContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Sql_plus_filepathContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Sql_plus_filepathContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Sql_plus_filepathContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Sql_plus_filepathContext) FILE_EXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_EXT, 0) +} + +func (s *Sql_plus_filepathContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Sql_plus_filepathContext) AllSOLIDUS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSOLIDUS) +} + +func (s *Sql_plus_filepathContext) SOLIDUS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSOLIDUS, i) +} + +func (s *Sql_plus_filepathContext) AllRSOLIDUS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRSOLIDUS) +} + +func (s *Sql_plus_filepathContext) RSOLIDUS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRSOLIDUS, i) +} + +func (s *Sql_plus_filepathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_plus_filepathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_plus_filepathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_plus_filepath(s) + } +} + +func (s *Sql_plus_filepathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_plus_filepath(s) + } +} + +func (p *PlSqlParser) Sql_plus_filepath() (localctx ISql_plus_filepathContext) { + localctx = NewSql_plus_filepathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2256, PlSqlParserRULE_sql_plus_filepath) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20145) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2856, p.GetParserRuleContext()) == 1 { + { + p.SetState(20142) + p.Id_expression() + } + { + p.SetState(20143) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSOLIDUS || _la == PlSqlParserRSOLIDUS { + { + p.SetState(20147) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSOLIDUS || _la == PlSqlParserRSOLIDUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(20155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2858, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20150) + p.Id_expression() + } + { + p.SetState(20151) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSOLIDUS || _la == PlSqlParserRSOLIDUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(20157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2858, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(20158) + p.Id_expression() + } + { + p.SetState(20159) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20160) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSQL || _la == PlSqlParserFILE_EXT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhenever_commandContext is an interface to support dynamic dispatch. +type IWhenever_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHENEVER() antlr.TerminalNode + SQLERROR() antlr.TerminalNode + OSERROR() antlr.TerminalNode + EXIT() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + SUCCESS() antlr.TerminalNode + FAILURE() antlr.TerminalNode + WARNING() antlr.TerminalNode + Variable_name() IVariable_nameContext + Numeric() INumericContext + COMMIT() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsWhenever_commandContext differentiates from other interfaces. + IsWhenever_commandContext() +} + +type Whenever_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenever_commandContext() *Whenever_commandContext { + var p = new(Whenever_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_whenever_command + return p +} + +func InitEmptyWhenever_commandContext(p *Whenever_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_whenever_command +} + +func (*Whenever_commandContext) IsWhenever_commandContext() {} + +func NewWhenever_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Whenever_commandContext { + var p = new(Whenever_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_whenever_command + + return p +} + +func (s *Whenever_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Whenever_commandContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Whenever_commandContext) SQLERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLERROR, 0) +} + +func (s *Whenever_commandContext) OSERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOSERROR, 0) +} + +func (s *Whenever_commandContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Whenever_commandContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Whenever_commandContext) SUCCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESS, 0) +} + +func (s *Whenever_commandContext) FAILURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILURE, 0) +} + +func (s *Whenever_commandContext) WARNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserWARNING, 0) +} + +func (s *Whenever_commandContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Whenever_commandContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Whenever_commandContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Whenever_commandContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Whenever_commandContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Whenever_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Whenever_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Whenever_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWhenever_command(s) + } +} + +func (s *Whenever_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWhenever_command(s) + } +} + +func (p *PlSqlParser) Whenever_command() (localctx IWhenever_commandContext) { + localctx = NewWhenever_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2258, PlSqlParserRULE_whenever_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20162) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20163) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOSERROR || _la == PlSqlParserSQLERROR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXIT: + { + p.SetState(20164) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2859, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20165) + p.Match(PlSqlParserSUCCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(20166) + p.Match(PlSqlParserFAILURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(20167) + p.Match(PlSqlParserWARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(20168) + p.Variable_name() + } + + case 5: + { + p.SetState(20169) + p.Numeric() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(20173) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2860, p.GetParserRuleContext()) == 1 { + { + p.SetState(20172) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCONTINUE: + { + p.SetState(20175) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20177) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2861, p.GetParserRuleContext()) == 1 { + { + p.SetState(20176) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserNONE || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_commandContext is an interface to support dynamic dispatch. +type ISet_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Numeric() INumericContext + + // IsSet_commandContext differentiates from other interfaces. + IsSet_commandContext() +} + +type Set_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_commandContext() *Set_commandContext { + var p = new(Set_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_command + return p +} + +func InitEmptySet_commandContext(p *Set_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_command +} + +func (*Set_commandContext) IsSet_commandContext() {} + +func NewSet_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_commandContext { + var p = new(Set_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_command + + return p +} + +func (s *Set_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_commandContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Set_commandContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Set_commandContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Set_commandContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Set_commandContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOFF) +} + +func (s *Set_commandContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, i) +} + +func (s *Set_commandContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Set_commandContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Set_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_command(s) + } +} + +func (s *Set_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_command(s) + } +} + +func (p *PlSqlParser) Set_command() (localctx ISet_commandContext) { + localctx = NewSet_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2260, PlSqlParserRULE_set_command) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20181) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2865, p.GetParserRuleContext()) { + case 1: + p.SetState(20185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(20182) + p.Regular_id() + } + { + p.SetState(20183) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(20187) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2863, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(20189) + p.Regular_id() + } + p.SetState(20195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2864, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20190) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(20191) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(20192) + p.Match(PlSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(20193) + p.Numeric() + } + + case 5: + { + p.SetState(20194) + p.Regular_id() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITiming_commandContext is an interface to support dynamic dispatch. +type ITiming_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTiming_text returns the timing_text rule contexts. + GetTiming_text() IId_expressionContext + + // SetTiming_text sets the timing_text rule contexts. + SetTiming_text(IId_expressionContext) + + // Getter signatures + TIMING() antlr.TerminalNode + START() antlr.TerminalNode + SHOW() antlr.TerminalNode + STOP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsTiming_commandContext differentiates from other interfaces. + IsTiming_commandContext() +} + +type Timing_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + timing_text IId_expressionContext +} + +func NewEmptyTiming_commandContext() *Timing_commandContext { + var p = new(Timing_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_command + return p +} + +func InitEmptyTiming_commandContext(p *Timing_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_command +} + +func (*Timing_commandContext) IsTiming_commandContext() {} + +func NewTiming_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timing_commandContext { + var p = new(Timing_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timing_command + + return p +} + +func (s *Timing_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timing_commandContext) GetTiming_text() IId_expressionContext { return s.timing_text } + +func (s *Timing_commandContext) SetTiming_text(v IId_expressionContext) { s.timing_text = v } + +func (s *Timing_commandContext) TIMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMING, 0) +} + +func (s *Timing_commandContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Timing_commandContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Timing_commandContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Timing_commandContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Timing_commandContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Timing_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timing_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timing_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTiming_command(s) + } +} + +func (s *Timing_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTiming_command(s) + } +} + +func (p *PlSqlParser) Timing_command() (localctx ITiming_commandContext) { + localctx = NewTiming_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2262, PlSqlParserRULE_timing_command) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20199) + p.Match(PlSqlParserTIMING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20209) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2867, p.GetParserRuleContext()) == 1 { + { + p.SetState(20200) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2866, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20201) + + var _x = p.Id_expression() + + localctx.(*Timing_commandContext).timing_text = _x + } + + } + p.SetState(20206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2866, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2867, p.GetParserRuleContext()) == 2 { + { + p.SetState(20207) + p.Match(PlSqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2867, p.GetParserRuleContext()) == 3 { + { + p.SetState(20208) + p.Match(PlSqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClear_commandContext is an interface to support dynamic dispatch. +type IClear_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLEAR() antlr.TerminalNode + Regular_id() IRegular_idContext + COLUMN() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsClear_commandContext differentiates from other interfaces. + IsClear_commandContext() +} + +type Clear_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClear_commandContext() *Clear_commandContext { + var p = new(Clear_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clear_command + return p +} + +func InitEmptyClear_commandContext(p *Clear_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clear_command +} + +func (*Clear_commandContext) IsClear_commandContext() {} + +func NewClear_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clear_commandContext { + var p = new(Clear_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clear_command + + return p +} + +func (s *Clear_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clear_commandContext) CLEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAR, 0) +} + +func (s *Clear_commandContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Clear_commandContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Clear_commandContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Clear_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clear_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clear_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClear_command(s) + } +} + +func (s *Clear_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClear_command(s) + } +} + +func (p *PlSqlParser) Clear_command() (localctx IClear_commandContext) { + localctx = NewClear_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2264, PlSqlParserRULE_clear_command) + p.SetState(20217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCLEAR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20211) + p.Match(PlSqlParserCLEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(20213) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2868, p.GetParserRuleContext()) == 1 { + { + p.SetState(20212) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20215) + p.Regular_id() + } + + case PlSqlParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20216) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_extension_clauseContext is an interface to support dynamic dispatch. +type IPartition_extension_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FOR() antlr.TerminalNode + Expressions_() IExpressions_Context + + // IsPartition_extension_clauseContext differentiates from other interfaces. + IsPartition_extension_clauseContext() +} + +type Partition_extension_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extension_clauseContext() *Partition_extension_clauseContext { + var p = new(Partition_extension_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extension_clause + return p +} + +func InitEmptyPartition_extension_clauseContext(p *Partition_extension_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extension_clause +} + +func (*Partition_extension_clauseContext) IsPartition_extension_clauseContext() {} + +func NewPartition_extension_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extension_clauseContext { + var p = new(Partition_extension_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extension_clause + + return p +} + +func (s *Partition_extension_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extension_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extension_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extension_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Partition_extension_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extension_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extension_clauseContext) Expressions_() IExpressions_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressions_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressions_Context) +} + +func (s *Partition_extension_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extension_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extension_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extension_clause(s) + } +} + +func (s *Partition_extension_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extension_clause(s) + } +} + +func (p *PlSqlParser) Partition_extension_clause() (localctx IPartition_extension_clauseContext) { + localctx = NewPartition_extension_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2266, PlSqlParserRULE_partition_extension_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20219) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(20220) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20223) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2871, p.GetParserRuleContext()) == 1 { + { + p.SetState(20224) + p.Expressions_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20227) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_aliasContext is an interface to support dynamic dispatch. +type IColumn_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + AS() antlr.TerminalNode + + // IsColumn_aliasContext differentiates from other interfaces. + IsColumn_aliasContext() +} + +type Column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_aliasContext() *Column_aliasContext { + var p = new(Column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_alias + return p +} + +func InitEmptyColumn_aliasContext(p *Column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_alias +} + +func (*Column_aliasContext) IsColumn_aliasContext() {} + +func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext { + var p = new(Column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_alias + + return p +} + +func (s *Column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Column_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_alias(s) + } +} + +func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_alias(s) + } +} + +func (p *PlSqlParser) Column_alias() (localctx IColumn_aliasContext) { + localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2268, PlSqlParserRULE_column_alias) + var _la int + + p.SetState(20237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2874, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(20230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(20229) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(20234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(20232) + p.Identifier() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(20233) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20236) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_aliasContext is an interface to support dynamic dispatch. +type ITable_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + + // IsTable_aliasContext differentiates from other interfaces. + IsTable_aliasContext() +} + +type Table_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_aliasContext() *Table_aliasContext { + var p = new(Table_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_alias + return p +} + +func InitEmptyTable_aliasContext(p *Table_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_alias +} + +func (*Table_aliasContext) IsTable_aliasContext() {} + +func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext { + var p = new(Table_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_alias + + return p +} + +func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_alias(s) + } +} + +func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_alias(s) + } +} + +func (p *PlSqlParser) Table_alias() (localctx ITable_aliasContext) { + localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2270, PlSqlParserRULE_table_alias) + p.SetState(20241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20239) + p.Identifier() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20240) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhere_clauseContext is an interface to support dynamic dispatch. +type IWhere_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + OF() antlr.TerminalNode + Cursor_name() ICursor_nameContext + Condition() IConditionContext + + // IsWhere_clauseContext differentiates from other interfaces. + IsWhere_clauseContext() +} + +type Where_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhere_clauseContext() *Where_clauseContext { + var p = new(Where_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_where_clause + return p +} + +func InitEmptyWhere_clauseContext(p *Where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_where_clause +} + +func (*Where_clauseContext) IsWhere_clauseContext() {} + +func NewWhere_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_clauseContext { + var p = new(Where_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_where_clause + + return p +} + +func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHERE, 0) +} + +func (s *Where_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Where_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Where_clauseContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Where_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Where_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Where_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWhere_clause(s) + } +} + +func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWhere_clause(s) + } +} + +func (p *PlSqlParser) Where_clause() (localctx IWhere_clauseContext) { + localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2272, PlSqlParserRULE_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20243) + p.Match(PlSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2876, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20244) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20245) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20246) + p.Cursor_name() + } + + case 2: + { + p.SetState(20247) + p.Condition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInto_clauseContext is an interface to support dynamic dispatch. +type IInto_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + AllGeneral_element() []IGeneral_elementContext + General_element(i int) IGeneral_elementContext + AllBind_variable() []IBind_variableContext + Bind_variable(i int) IBind_variableContext + BULK() antlr.TerminalNode + COLLECT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInto_clauseContext differentiates from other interfaces. + IsInto_clauseContext() +} + +type Into_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInto_clauseContext() *Into_clauseContext { + var p = new(Into_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause + return p +} + +func InitEmptyInto_clauseContext(p *Into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause +} + +func (*Into_clauseContext) IsInto_clauseContext() {} + +func NewInto_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clauseContext { + var p = new(Into_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_into_clause + + return p +} + +func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Into_clauseContext) AllGeneral_element() []IGeneral_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_elementContext); ok { + len++ + } + } + + tst := make([]IGeneral_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_elementContext); ok { + tst[i] = t.(IGeneral_elementContext) + i++ + } + } + + return tst +} + +func (s *Into_clauseContext) General_element(i int) IGeneral_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Into_clauseContext) AllBind_variable() []IBind_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBind_variableContext); ok { + len++ + } + } + + tst := make([]IBind_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBind_variableContext); ok { + tst[i] = t.(IBind_variableContext) + i++ + } + } + + return tst +} + +func (s *Into_clauseContext) Bind_variable(i int) IBind_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Into_clauseContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Into_clauseContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Into_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Into_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Into_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Into_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInto_clause(s) + } +} + +func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInto_clause(s) + } +} + +func (p *PlSqlParser) Into_clause() (localctx IInto_clauseContext) { + localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2274, PlSqlParserRULE_into_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBULK { + { + p.SetState(20250) + p.Match(PlSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20251) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20254) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(20255) + p.general_element(0) + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20256) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2880, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20259) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(20260) + p.general_element(0) + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20261) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(20268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2880, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_column_nameContext is an interface to support dynamic dispatch. +type IXml_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + + // IsXml_column_nameContext differentiates from other interfaces. + IsXml_column_nameContext() +} + +type Xml_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_column_nameContext() *Xml_column_nameContext { + var p = new(Xml_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_column_name + return p +} + +func InitEmptyXml_column_nameContext(p *Xml_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_column_name +} + +func (*Xml_column_nameContext) IsXml_column_nameContext() {} + +func NewXml_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_column_nameContext { + var p = new(Xml_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_column_name + + return p +} + +func (s *Xml_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_column_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Xml_column_nameContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Xml_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_column_name(s) + } +} + +func (s *Xml_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_column_name(s) + } +} + +func (p *PlSqlParser) Xml_column_name() (localctx IXml_column_nameContext) { + localctx = NewXml_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2276, PlSqlParserRULE_xml_column_name) + p.SetState(20271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20269) + p.Identifier() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20270) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICost_class_nameContext is an interface to support dynamic dispatch. +type ICost_class_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsCost_class_nameContext differentiates from other interfaces. + IsCost_class_nameContext() +} + +type Cost_class_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCost_class_nameContext() *Cost_class_nameContext { + var p = new(Cost_class_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_class_name + return p +} + +func InitEmptyCost_class_nameContext(p *Cost_class_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_class_name +} + +func (*Cost_class_nameContext) IsCost_class_nameContext() {} + +func NewCost_class_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cost_class_nameContext { + var p = new(Cost_class_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cost_class_name + + return p +} + +func (s *Cost_class_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cost_class_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Cost_class_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cost_class_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cost_class_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCost_class_name(s) + } +} + +func (s *Cost_class_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCost_class_name(s) + } +} + +func (p *PlSqlParser) Cost_class_name() (localctx ICost_class_nameContext) { + localctx = NewCost_class_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2278, PlSqlParserRULE_cost_class_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20273) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttribute_nameContext is an interface to support dynamic dispatch. +type IAttribute_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsAttribute_nameContext differentiates from other interfaces. + IsAttribute_nameContext() +} + +type Attribute_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_nameContext() *Attribute_nameContext { + var p = new(Attribute_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_name + return p +} + +func InitEmptyAttribute_nameContext(p *Attribute_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_name +} + +func (*Attribute_nameContext) IsAttribute_nameContext() {} + +func NewAttribute_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_nameContext { + var p = new(Attribute_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_name + + return p +} + +func (s *Attribute_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Attribute_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_name(s) + } +} + +func (s *Attribute_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_name(s) + } +} + +func (p *PlSqlParser) Attribute_name() (localctx IAttribute_nameContext) { + localctx = NewAttribute_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2280, PlSqlParserRULE_attribute_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20275) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISavepoint_nameContext is an interface to support dynamic dispatch. +type ISavepoint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsSavepoint_nameContext differentiates from other interfaces. + IsSavepoint_nameContext() +} + +type Savepoint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySavepoint_nameContext() *Savepoint_nameContext { + var p = new(Savepoint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_name + return p +} + +func InitEmptySavepoint_nameContext(p *Savepoint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_name +} + +func (*Savepoint_nameContext) IsSavepoint_nameContext() {} + +func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext { + var p = new(Savepoint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_savepoint_name + + return p +} + +func (s *Savepoint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Savepoint_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSavepoint_name(s) + } +} + +func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSavepoint_name(s) + } +} + +func (p *PlSqlParser) Savepoint_name() (localctx ISavepoint_nameContext) { + localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2282, PlSqlParserRULE_savepoint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20277) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollback_segment_nameContext is an interface to support dynamic dispatch. +type IRollback_segment_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsRollback_segment_nameContext differentiates from other interfaces. + IsRollback_segment_nameContext() +} + +type Rollback_segment_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_segment_nameContext() *Rollback_segment_nameContext { + var p = new(Rollback_segment_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment_name + return p +} + +func InitEmptyRollback_segment_nameContext(p *Rollback_segment_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment_name +} + +func (*Rollback_segment_nameContext) IsRollback_segment_nameContext() {} + +func NewRollback_segment_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_segment_nameContext { + var p = new(Rollback_segment_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_segment_name + + return p +} + +func (s *Rollback_segment_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_segment_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Rollback_segment_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_segment_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_segment_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_segment_name(s) + } +} + +func (s *Rollback_segment_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_segment_name(s) + } +} + +func (p *PlSqlParser) Rollback_segment_name() (localctx IRollback_segment_nameContext) { + localctx = NewRollback_segment_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2284, PlSqlParserRULE_rollback_segment_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20279) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_nameContext is an interface to support dynamic dispatch. +type ISchema_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsSchema_nameContext differentiates from other interfaces. + IsSchema_nameContext() +} + +type Schema_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_nameContext() *Schema_nameContext { + var p = new(Schema_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_name + return p +} + +func InitEmptySchema_nameContext(p *Schema_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_name +} + +func (*Schema_nameContext) IsSchema_nameContext() {} + +func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext { + var p = new(Schema_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_schema_name + + return p +} + +func (s *Schema_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Schema_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSchema_name(s) + } +} + +func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSchema_name(s) + } +} + +func (p *PlSqlParser) Schema_name() (localctx ISchema_nameContext) { + localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2286, PlSqlParserRULE_schema_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20281) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoutine_nameContext is an interface to support dynamic dispatch. +type IRoutine_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsRoutine_nameContext differentiates from other interfaces. + IsRoutine_nameContext() +} + +type Routine_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoutine_nameContext() *Routine_nameContext { + var p = new(Routine_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_name + return p +} + +func InitEmptyRoutine_nameContext(p *Routine_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_name +} + +func (*Routine_nameContext) IsRoutine_nameContext() {} + +func NewRoutine_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Routine_nameContext { + var p = new(Routine_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_routine_name + + return p +} + +func (s *Routine_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Routine_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Routine_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Routine_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Routine_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Routine_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Routine_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Routine_nameContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Routine_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Routine_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Routine_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRoutine_name(s) + } +} + +func (s *Routine_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRoutine_name(s) + } +} + +func (p *PlSqlParser) Routine_name() (localctx IRoutine_nameContext) { + localctx = NewRoutine_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2288, PlSqlParserRULE_routine_name) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20283) + p.Identifier() + } + p.SetState(20288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2882, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20284) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20285) + p.Id_expression() + } + + } + p.SetState(20290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2882, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(20293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAT_SIGN { + { + p.SetState(20291) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20292) + p.Link_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPackage_nameContext is an interface to support dynamic dispatch. +type IPackage_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsPackage_nameContext differentiates from other interfaces. + IsPackage_nameContext() +} + +type Package_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_nameContext() *Package_nameContext { + var p = new(Package_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_name + return p +} + +func InitEmptyPackage_nameContext(p *Package_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_name +} + +func (*Package_nameContext) IsPackage_nameContext() {} + +func NewPackage_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_nameContext { + var p = new(Package_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_name + + return p +} + +func (s *Package_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Package_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_name(s) + } +} + +func (s *Package_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_name(s) + } +} + +func (p *PlSqlParser) Package_name() (localctx IPackage_nameContext) { + localctx = NewPackage_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2290, PlSqlParserRULE_package_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20295) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImplementation_type_nameContext is an interface to support dynamic dispatch. +type IImplementation_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsImplementation_type_nameContext differentiates from other interfaces. + IsImplementation_type_nameContext() +} + +type Implementation_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplementation_type_nameContext() *Implementation_type_nameContext { + var p = new(Implementation_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_type_name + return p +} + +func InitEmptyImplementation_type_nameContext(p *Implementation_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_type_name +} + +func (*Implementation_type_nameContext) IsImplementation_type_nameContext() {} + +func NewImplementation_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implementation_type_nameContext { + var p = new(Implementation_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_implementation_type_name + + return p +} + +func (s *Implementation_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implementation_type_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Implementation_type_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Implementation_type_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Implementation_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implementation_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implementation_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImplementation_type_name(s) + } +} + +func (s *Implementation_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImplementation_type_name(s) + } +} + +func (p *PlSqlParser) Implementation_type_name() (localctx IImplementation_type_nameContext) { + localctx = NewImplementation_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2292, PlSqlParserRULE_implementation_type_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20297) + p.Identifier() + } + p.SetState(20300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(20298) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20299) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_nameContext is an interface to support dynamic dispatch. +type IParameter_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsParameter_nameContext differentiates from other interfaces. + IsParameter_nameContext() +} + +type Parameter_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_nameContext() *Parameter_nameContext { + var p = new(Parameter_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_name + return p +} + +func InitEmptyParameter_nameContext(p *Parameter_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_name +} + +func (*Parameter_nameContext) IsParameter_nameContext() {} + +func NewParameter_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_nameContext { + var p = new(Parameter_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_name + + return p +} + +func (s *Parameter_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Parameter_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_name(s) + } +} + +func (s *Parameter_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_name(s) + } +} + +func (p *PlSqlParser) Parameter_name() (localctx IParameter_nameContext) { + localctx = NewParameter_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2294, PlSqlParserRULE_parameter_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20302) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_model_nameContext is an interface to support dynamic dispatch. +type IReference_model_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsReference_model_nameContext differentiates from other interfaces. + IsReference_model_nameContext() +} + +type Reference_model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_model_nameContext() *Reference_model_nameContext { + var p = new(Reference_model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model_name + return p +} + +func InitEmptyReference_model_nameContext(p *Reference_model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model_name +} + +func (*Reference_model_nameContext) IsReference_model_nameContext() {} + +func NewReference_model_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_model_nameContext { + var p = new(Reference_model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_model_name + + return p +} + +func (s *Reference_model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_model_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Reference_model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_model_name(s) + } +} + +func (s *Reference_model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_model_name(s) + } +} + +func (p *PlSqlParser) Reference_model_name() (localctx IReference_model_nameContext) { + localctx = NewReference_model_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2296, PlSqlParserRULE_reference_model_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20304) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMain_model_nameContext is an interface to support dynamic dispatch. +type IMain_model_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsMain_model_nameContext differentiates from other interfaces. + IsMain_model_nameContext() +} + +type Main_model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMain_model_nameContext() *Main_model_nameContext { + var p = new(Main_model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model_name + return p +} + +func InitEmptyMain_model_nameContext(p *Main_model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model_name +} + +func (*Main_model_nameContext) IsMain_model_nameContext() {} + +func NewMain_model_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Main_model_nameContext { + var p = new(Main_model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_main_model_name + + return p +} + +func (s *Main_model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Main_model_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Main_model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Main_model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Main_model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMain_model_name(s) + } +} + +func (s *Main_model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMain_model_name(s) + } +} + +func (p *PlSqlParser) Main_model_name() (localctx IMain_model_nameContext) { + localctx = NewMain_model_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2298, PlSqlParserRULE_main_model_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20306) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_tableview_nameContext is an interface to support dynamic dispatch. +type IContainer_tableview_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsContainer_tableview_nameContext differentiates from other interfaces. + IsContainer_tableview_nameContext() +} + +type Container_tableview_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_tableview_nameContext() *Container_tableview_nameContext { + var p = new(Container_tableview_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_tableview_name + return p +} + +func InitEmptyContainer_tableview_nameContext(p *Container_tableview_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_tableview_name +} + +func (*Container_tableview_nameContext) IsContainer_tableview_nameContext() {} + +func NewContainer_tableview_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_tableview_nameContext { + var p = new(Container_tableview_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_tableview_name + + return p +} + +func (s *Container_tableview_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_tableview_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Container_tableview_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Container_tableview_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Container_tableview_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_tableview_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_tableview_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_tableview_name(s) + } +} + +func (s *Container_tableview_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_tableview_name(s) + } +} + +func (p *PlSqlParser) Container_tableview_name() (localctx IContainer_tableview_nameContext) { + localctx = NewContainer_tableview_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2300, PlSqlParserRULE_container_tableview_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20308) + p.Identifier() + } + p.SetState(20311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(20309) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20310) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_function_nameContext is an interface to support dynamic dispatch. +type IAggregate_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsAggregate_function_nameContext differentiates from other interfaces. + IsAggregate_function_nameContext() +} + +type Aggregate_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_function_nameContext() *Aggregate_function_nameContext { + var p = new(Aggregate_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_function_name + return p +} + +func InitEmptyAggregate_function_nameContext(p *Aggregate_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_function_name +} + +func (*Aggregate_function_nameContext) IsAggregate_function_nameContext() {} + +func NewAggregate_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_function_nameContext { + var p = new(Aggregate_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_aggregate_function_name + + return p +} + +func (s *Aggregate_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Aggregate_function_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Aggregate_function_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Aggregate_function_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Aggregate_function_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Aggregate_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAggregate_function_name(s) + } +} + +func (s *Aggregate_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAggregate_function_name(s) + } +} + +func (p *PlSqlParser) Aggregate_function_name() (localctx IAggregate_function_nameContext) { + localctx = NewAggregate_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2302, PlSqlParserRULE_aggregate_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20313) + p.Identifier() + } + p.SetState(20318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(20314) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20315) + p.Id_expression() + } + + p.SetState(20320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_nameContext is an interface to support dynamic dispatch. +type IQuery_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsQuery_nameContext differentiates from other interfaces. + IsQuery_nameContext() +} + +type Query_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_nameContext() *Query_nameContext { + var p = new(Query_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_name + return p +} + +func InitEmptyQuery_nameContext(p *Query_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_name +} + +func (*Query_nameContext) IsQuery_nameContext() {} + +func NewQuery_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_nameContext { + var p = new(Query_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_name + + return p +} + +func (s *Query_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Query_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_name(s) + } +} + +func (s *Query_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_name(s) + } +} + +func (p *PlSqlParser) Query_name() (localctx IQuery_nameContext) { + localctx = NewQuery_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2304, PlSqlParserRULE_query_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20321) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantee_nameContext is an interface to support dynamic dispatch. +type IGrantee_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + Identified_by() IIdentified_byContext + + // IsGrantee_nameContext differentiates from other interfaces. + IsGrantee_nameContext() +} + +type Grantee_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_nameContext() *Grantee_nameContext { + var p = new(Grantee_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grantee_name + return p +} + +func InitEmptyGrantee_nameContext(p *Grantee_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grantee_name +} + +func (*Grantee_nameContext) IsGrantee_nameContext() {} + +func NewGrantee_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_nameContext { + var p = new(Grantee_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grantee_name + + return p +} + +func (s *Grantee_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Grantee_nameContext) Identified_by() IIdentified_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Grantee_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrantee_name(s) + } +} + +func (s *Grantee_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrantee_name(s) + } +} + +func (p *PlSqlParser) Grantee_name() (localctx IGrantee_nameContext) { + localctx = NewGrantee_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2306, PlSqlParserRULE_grantee_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20323) + p.Id_expression() + } + p.SetState(20325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(20324) + p.Identified_by() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_nameContext is an interface to support dynamic dispatch. +type IRole_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + CONNECT() antlr.TerminalNode + + // IsRole_nameContext differentiates from other interfaces. + IsRole_nameContext() +} + +type Role_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_nameContext() *Role_nameContext { + var p = new(Role_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_name + return p +} + +func InitEmptyRole_nameContext(p *Role_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_name +} + +func (*Role_nameContext) IsRole_nameContext() {} + +func NewRole_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_nameContext { + var p = new(Role_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_name + + return p +} + +func (s *Role_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Role_nameContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Role_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_name(s) + } +} + +func (s *Role_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_name(s) + } +} + +func (p *PlSqlParser) Role_name() (localctx IRole_nameContext) { + localctx = NewRole_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2308, PlSqlParserRULE_role_name) + p.SetState(20329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20327) + p.Id_expression() + } + + case PlSqlParserCONNECT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20328) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraint_nameContext is an interface to support dynamic dispatch. +type IConstraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsConstraint_nameContext differentiates from other interfaces. + IsConstraint_nameContext() +} + +type Constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_nameContext() *Constraint_nameContext { + var p = new(Constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_name + return p +} + +func InitEmptyConstraint_nameContext(p *Constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_name +} + +func (*Constraint_nameContext) IsConstraint_nameContext() {} + +func NewConstraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_nameContext { + var p = new(Constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_name + + return p +} + +func (s *Constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Constraint_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Constraint_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Constraint_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Constraint_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Constraint_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Constraint_nameContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_name(s) + } +} + +func (s *Constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_name(s) + } +} + +func (p *PlSqlParser) Constraint_name() (localctx IConstraint_nameContext) { + localctx = NewConstraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2310, PlSqlParserRULE_constraint_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20331) + p.Identifier() + } + p.SetState(20336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(20332) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20333) + p.Id_expression() + } + + p.SetState(20338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(20341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAT_SIGN { + { + p.SetState(20339) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20340) + p.Link_name() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_nameContext is an interface to support dynamic dispatch. +type ILabel_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsLabel_nameContext differentiates from other interfaces. + IsLabel_nameContext() +} + +type Label_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_nameContext() *Label_nameContext { + var p = new(Label_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_name + return p +} + +func InitEmptyLabel_nameContext(p *Label_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_name +} + +func (*Label_nameContext) IsLabel_nameContext() {} + +func NewLabel_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_nameContext { + var p = new(Label_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_label_name + + return p +} + +func (s *Label_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Label_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLabel_name(s) + } +} + +func (s *Label_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLabel_name(s) + } +} + +func (p *PlSqlParser) Label_name() (localctx ILabel_nameContext) { + localctx = NewLabel_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2312, PlSqlParserRULE_label_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20343) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_nameContext is an interface to support dynamic dispatch. +type IType_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsType_nameContext differentiates from other interfaces. + IsType_nameContext() +} + +type Type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_nameContext() *Type_nameContext { + var p = new(Type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_name + return p +} + +func InitEmptyType_nameContext(p *Type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_name +} + +func (*Type_nameContext) IsType_nameContext() {} + +func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext { + var p = new(Type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_name + + return p +} + +func (s *Type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Type_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Type_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Type_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_name(s) + } +} + +func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_name(s) + } +} + +func (p *PlSqlParser) Type_name() (localctx IType_nameContext) { + localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2314, PlSqlParserRULE_type_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20345) + p.Id_expression() + } + p.SetState(20350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2891, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20346) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20347) + p.Id_expression() + } + + } + p.SetState(20352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2891, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISequence_nameContext is an interface to support dynamic dispatch. +type ISequence_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsSequence_nameContext differentiates from other interfaces. + IsSequence_nameContext() +} + +type Sequence_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_nameContext() *Sequence_nameContext { + var p = new(Sequence_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_name + return p +} + +func InitEmptySequence_nameContext(p *Sequence_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_name +} + +func (*Sequence_nameContext) IsSequence_nameContext() {} + +func NewSequence_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_nameContext { + var p = new(Sequence_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_name + + return p +} + +func (s *Sequence_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Sequence_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Sequence_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Sequence_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Sequence_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_name(s) + } +} + +func (s *Sequence_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_name(s) + } +} + +func (p *PlSqlParser) Sequence_name() (localctx ISequence_nameContext) { + localctx = NewSequence_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2316, PlSqlParserRULE_sequence_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20353) + p.Id_expression() + } + p.SetState(20358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(20354) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20355) + p.Id_expression() + } + + p.SetState(20360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IException_nameContext is an interface to support dynamic dispatch. +type IException_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsException_nameContext differentiates from other interfaces. + IsException_nameContext() +} + +type Exception_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_nameContext() *Exception_nameContext { + var p = new(Exception_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_name + return p +} + +func InitEmptyException_nameContext(p *Exception_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_name +} + +func (*Exception_nameContext) IsException_nameContext() {} + +func NewException_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_nameContext { + var p = new(Exception_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_name + + return p +} + +func (s *Exception_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Exception_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Exception_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Exception_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Exception_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Exception_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_name(s) + } +} + +func (s *Exception_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_name(s) + } +} + +func (p *PlSqlParser) Exception_name() (localctx IException_nameContext) { + localctx = NewException_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2318, PlSqlParserRULE_exception_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20361) + p.Identifier() + } + p.SetState(20366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(20362) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20363) + p.Id_expression() + } + + p.SetState(20368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_nameContext is an interface to support dynamic dispatch. +type IFunction_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsFunction_nameContext differentiates from other interfaces. + IsFunction_nameContext() +} + +type Function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_nameContext() *Function_nameContext { + var p = new(Function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_name + return p +} + +func InitEmptyFunction_nameContext(p *Function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_name +} + +func (*Function_nameContext) IsFunction_nameContext() {} + +func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext { + var p = new(Function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_name + + return p +} + +func (s *Function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Function_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_name(s) + } +} + +func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_name(s) + } +} + +func (p *PlSqlParser) Function_name() (localctx IFunction_nameContext) { + localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2320, PlSqlParserRULE_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20369) + p.Identifier() + } + p.SetState(20372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(20370) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20371) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_nameContext is an interface to support dynamic dispatch. +type IProcedure_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProcedure_nameContext differentiates from other interfaces. + IsProcedure_nameContext() +} + +type Procedure_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_nameContext() *Procedure_nameContext { + var p = new(Procedure_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_name + return p +} + +func InitEmptyProcedure_nameContext(p *Procedure_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_name +} + +func (*Procedure_nameContext) IsProcedure_nameContext() {} + +func NewProcedure_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_nameContext { + var p = new(Procedure_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_name + + return p +} + +func (s *Procedure_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Procedure_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Procedure_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_name(s) + } +} + +func (s *Procedure_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_name(s) + } +} + +func (p *PlSqlParser) Procedure_name() (localctx IProcedure_nameContext) { + localctx = NewProcedure_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2322, PlSqlParserRULE_procedure_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20374) + p.Identifier() + } + p.SetState(20377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(20375) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20376) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_nameContext is an interface to support dynamic dispatch. +type ITrigger_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsTrigger_nameContext differentiates from other interfaces. + IsTrigger_nameContext() +} + +type Trigger_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_nameContext() *Trigger_nameContext { + var p = new(Trigger_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_name + return p +} + +func InitEmptyTrigger_nameContext(p *Trigger_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_name +} + +func (*Trigger_nameContext) IsTrigger_nameContext() {} + +func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext { + var p = new(Trigger_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_name + + return p +} + +func (s *Trigger_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Trigger_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Trigger_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_name(s) + } +} + +func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_name(s) + } +} + +func (p *PlSqlParser) Trigger_name() (localctx ITrigger_nameContext) { + localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2324, PlSqlParserRULE_trigger_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20379) + p.Identifier() + } + p.SetState(20382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(20380) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20381) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_nameContext is an interface to support dynamic dispatch. +type IVariable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + PERIOD() antlr.TerminalNode + Bind_variable() IBind_variableContext + + // IsVariable_nameContext differentiates from other interfaces. + IsVariable_nameContext() +} + +type Variable_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_nameContext() *Variable_nameContext { + var p = new(Variable_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_name + return p +} + +func InitEmptyVariable_nameContext(p *Variable_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_name +} + +func (*Variable_nameContext) IsVariable_nameContext() {} + +func NewVariable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_nameContext { + var p = new(Variable_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_variable_name + + return p +} + +func (s *Variable_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Variable_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Variable_nameContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *Variable_nameContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Variable_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Variable_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Variable_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVariable_name(s) + } +} + +func (s *Variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVariable_name(s) + } +} + +func (p *PlSqlParser) Variable_name() (localctx IVariable_nameContext) { + localctx = NewVariable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2326, PlSqlParserRULE_variable_name) + var _la int + + p.SetState(20394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + p.SetState(20386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(20384) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20385) + p.Char_set_name() + } + + } + { + p.SetState(20388) + p.Id_expression() + } + p.SetState(20391) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2898, p.GetParserRuleContext()) == 1 { + { + p.SetState(20389) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20390) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20393) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_nameContext is an interface to support dynamic dispatch. +type IIndex_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsIndex_nameContext differentiates from other interfaces. + IsIndex_nameContext() +} + +type Index_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_nameContext() *Index_nameContext { + var p = new(Index_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_name + return p +} + +func InitEmptyIndex_nameContext(p *Index_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_name +} + +func (*Index_nameContext) IsIndex_nameContext() {} + +func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext { + var p = new(Index_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_name + + return p +} + +func (s *Index_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Index_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Index_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Index_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_name(s) + } +} + +func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_name(s) + } +} + +func (p *PlSqlParser) Index_name() (localctx IIndex_nameContext) { + localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2328, PlSqlParserRULE_index_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20396) + p.Identifier() + } + p.SetState(20399) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2900, p.GetParserRuleContext()) == 1 { + { + p.SetState(20397) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20398) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_nameContext is an interface to support dynamic dispatch. +type ICursor_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + General_element() IGeneral_elementContext + Bind_variable() IBind_variableContext + + // IsCursor_nameContext differentiates from other interfaces. + IsCursor_nameContext() +} + +type Cursor_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_nameContext() *Cursor_nameContext { + var p = new(Cursor_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_name + return p +} + +func InitEmptyCursor_nameContext(p *Cursor_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_name +} + +func (*Cursor_nameContext) IsCursor_nameContext() {} + +func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext { + var p = new(Cursor_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_name + + return p +} + +func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_nameContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Cursor_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_name(s) + } +} + +func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_name(s) + } +} + +func (p *PlSqlParser) Cursor_name() (localctx ICursor_nameContext) { + localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2330, PlSqlParserRULE_cursor_name) + p.SetState(20403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20401) + p.general_element(0) + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20402) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecord_nameContext is an interface to support dynamic dispatch. +type IRecord_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Bind_variable() IBind_variableContext + + // IsRecord_nameContext differentiates from other interfaces. + IsRecord_nameContext() +} + +type Record_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecord_nameContext() *Record_nameContext { + var p = new(Record_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_name + return p +} + +func InitEmptyRecord_nameContext(p *Record_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_name +} + +func (*Record_nameContext) IsRecord_nameContext() {} + +func NewRecord_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Record_nameContext { + var p = new(Record_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_record_name + + return p +} + +func (s *Record_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Record_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Record_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Record_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Record_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Record_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecord_name(s) + } +} + +func (s *Record_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecord_name(s) + } +} + +func (p *PlSqlParser) Record_name() (localctx IRecord_nameContext) { + localctx = NewRecord_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2332, PlSqlParserRULE_record_name) + p.SetState(20407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20405) + p.Identifier() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20406) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILink_nameContext is an interface to support dynamic dispatch. +type ILink_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Database() IDatabaseContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllDomain() []IDomainContext + Domain(i int) IDomainContext + AT_SIGN() antlr.TerminalNode + Connection_qualifier() IConnection_qualifierContext + + // IsLink_nameContext differentiates from other interfaces. + IsLink_nameContext() +} + +type Link_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLink_nameContext() *Link_nameContext { + var p = new(Link_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_name + return p +} + +func InitEmptyLink_nameContext(p *Link_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_name +} + +func (*Link_nameContext) IsLink_nameContext() {} + +func NewLink_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Link_nameContext { + var p = new(Link_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_link_name + + return p +} + +func (s *Link_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Link_nameContext) Database() IDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabaseContext) +} + +func (s *Link_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Link_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Link_nameContext) AllDomain() []IDomainContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDomainContext); ok { + len++ + } + } + + tst := make([]IDomainContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDomainContext); ok { + tst[i] = t.(IDomainContext) + i++ + } + } + + return tst +} + +func (s *Link_nameContext) Domain(i int) IDomainContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDomainContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDomainContext) +} + +func (s *Link_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Link_nameContext) Connection_qualifier() IConnection_qualifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConnection_qualifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConnection_qualifierContext) +} + +func (s *Link_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Link_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Link_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLink_name(s) + } +} + +func (s *Link_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLink_name(s) + } +} + +func (p *PlSqlParser) Link_name() (localctx ILink_nameContext) { + localctx = NewLink_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2334, PlSqlParserRULE_link_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20409) + p.Database() + } + p.SetState(20414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2903, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20410) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20411) + p.Domain() + } + + } + p.SetState(20416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2903, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(20419) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2904, p.GetParserRuleContext()) == 1 { + { + p.SetState(20417) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20418) + p.Connection_qualifier() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_link_nameContext is an interface to support dynamic dispatch. +type ILocal_link_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsLocal_link_nameContext differentiates from other interfaces. + IsLocal_link_nameContext() +} + +type Local_link_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_link_nameContext() *Local_link_nameContext { + var p = new(Local_link_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_link_name + return p +} + +func InitEmptyLocal_link_nameContext(p *Local_link_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_link_name +} + +func (*Local_link_nameContext) IsLocal_link_nameContext() {} + +func NewLocal_link_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_link_nameContext { + var p = new(Local_link_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_link_name + + return p +} + +func (s *Local_link_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_link_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Local_link_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_link_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_link_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_link_name(s) + } +} + +func (s *Local_link_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_link_name(s) + } +} + +func (p *PlSqlParser) Local_link_name() (localctx ILocal_link_nameContext) { + localctx = NewLocal_link_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2336, PlSqlParserRULE_local_link_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20421) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConnection_qualifierContext is an interface to support dynamic dispatch. +type IConnection_qualifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsConnection_qualifierContext differentiates from other interfaces. + IsConnection_qualifierContext() +} + +type Connection_qualifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConnection_qualifierContext() *Connection_qualifierContext { + var p = new(Connection_qualifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_connection_qualifier + return p +} + +func InitEmptyConnection_qualifierContext(p *Connection_qualifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_connection_qualifier +} + +func (*Connection_qualifierContext) IsConnection_qualifierContext() {} + +func NewConnection_qualifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Connection_qualifierContext { + var p = new(Connection_qualifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_connection_qualifier + + return p +} + +func (s *Connection_qualifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Connection_qualifierContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Connection_qualifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Connection_qualifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Connection_qualifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConnection_qualifier(s) + } +} + +func (s *Connection_qualifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConnection_qualifier(s) + } +} + +func (p *PlSqlParser) Connection_qualifier() (localctx IConnection_qualifierContext) { + localctx = NewConnection_qualifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2338, PlSqlParserRULE_connection_qualifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20423) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_nameContext is an interface to support dynamic dispatch. +type IColumn_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsColumn_nameContext differentiates from other interfaces. + IsColumn_nameContext() +} + +type Column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_nameContext() *Column_nameContext { + var p = new(Column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_name + return p +} + +func InitEmptyColumn_nameContext(p *Column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_name +} + +func (*Column_nameContext) IsColumn_nameContext() {} + +func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext { + var p = new(Column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_name + + return p +} + +func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Column_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Column_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Column_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_name(s) + } +} + +func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_name(s) + } +} + +func (p *PlSqlParser) Column_name() (localctx IColumn_nameContext) { + localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2340, PlSqlParserRULE_column_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20425) + p.Identifier() + } + p.SetState(20430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2905, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20426) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20427) + p.Id_expression() + } + + } + p.SetState(20432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2905, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableview_nameContext is an interface to support dynamic dispatch. +type ITableview_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + Partition_extension_clause() IPartition_extension_clauseContext + Xmltable() IXmltableContext + Outer_join_sign() IOuter_join_signContext + + // IsTableview_nameContext differentiates from other interfaces. + IsTableview_nameContext() +} + +type Tableview_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableview_nameContext() *Tableview_nameContext { + var p = new(Tableview_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tableview_name + return p +} + +func InitEmptyTableview_nameContext(p *Tableview_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tableview_name +} + +func (*Tableview_nameContext) IsTableview_nameContext() {} + +func NewTableview_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tableview_nameContext { + var p = new(Tableview_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tableview_name + + return p +} + +func (s *Tableview_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tableview_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Tableview_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Tableview_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Tableview_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Tableview_nameContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Tableview_nameContext) Partition_extension_clause() IPartition_extension_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extension_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extension_clauseContext) +} + +func (s *Tableview_nameContext) Xmltable() IXmltableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltableContext) +} + +func (s *Tableview_nameContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *Tableview_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tableview_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tableview_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTableview_name(s) + } +} + +func (s *Tableview_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTableview_name(s) + } +} + +func (p *PlSqlParser) Tableview_name() (localctx ITableview_nameContext) { + localctx = NewTableview_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2342, PlSqlParserRULE_tableview_name) + p.SetState(20447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2909, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20433) + p.Identifier() + } + p.SetState(20436) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2906, p.GetParserRuleContext()) == 1 { + { + p.SetState(20434) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20435) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20441) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2907, p.GetParserRuleContext()) == 1 { + { + p.SetState(20438) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20439) + p.Link_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2907, p.GetParserRuleContext()) == 2 { + { + p.SetState(20440) + p.Partition_extension_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20443) + p.Xmltable() + } + p.SetState(20445) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2908, p.GetParserRuleContext()) == 1 { + { + p.SetState(20444) + p.Outer_join_sign() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltableContext is an interface to support dynamic dispatch. +type IXmltableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLTABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Concatenation() IConcatenationContext + RIGHT_PAREN() antlr.TerminalNode + Xml_namespaces_clause() IXml_namespaces_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Xml_passing_clause() IXml_passing_clauseContext + COLUMNS() antlr.TerminalNode + AllXml_table_column() []IXml_table_columnContext + Xml_table_column(i int) IXml_table_columnContext + PERIOD() antlr.TerminalNode + General_element_part() IGeneral_element_partContext + + // IsXmltableContext differentiates from other interfaces. + IsXmltableContext() +} + +type XmltableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltableContext() *XmltableContext { + var p = new(XmltableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltable + return p +} + +func InitEmptyXmltableContext(p *XmltableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltable +} + +func (*XmltableContext) IsXmltableContext() {} + +func NewXmltableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XmltableContext { + var p = new(XmltableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltable + + return p +} + +func (s *XmltableContext) GetParser() antlr.Parser { return s.parser } + +func (s *XmltableContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTABLE, 0) +} + +func (s *XmltableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *XmltableContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *XmltableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *XmltableContext) Xml_namespaces_clause() IXml_namespaces_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_namespaces_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_namespaces_clauseContext) +} + +func (s *XmltableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *XmltableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *XmltableContext) Xml_passing_clause() IXml_passing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_passing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_passing_clauseContext) +} + +func (s *XmltableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *XmltableContext) AllXml_table_column() []IXml_table_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_table_columnContext); ok { + len++ + } + } + + tst := make([]IXml_table_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_table_columnContext); ok { + tst[i] = t.(IXml_table_columnContext) + i++ + } + } + + return tst +} + +func (s *XmltableContext) Xml_table_column(i int) IXml_table_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_table_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_table_columnContext) +} + +func (s *XmltableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *XmltableContext) General_element_part() IGeneral_element_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *XmltableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XmltableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XmltableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltable(s) + } +} + +func (s *XmltableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltable(s) + } +} + +func (p *PlSqlParser) Xmltable() (localctx IXmltableContext) { + localctx = NewXmltableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2344, PlSqlParserRULE_xmltable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20449) + p.Match(PlSqlParserXMLTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20450) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20454) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2910, p.GetParserRuleContext()) == 1 { + { + p.SetState(20451) + p.Xml_namespaces_clause() + } + { + p.SetState(20452) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20456) + p.concatenation(0) + } + p.SetState(20458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(20457) + p.Xml_passing_clause() + } + + } + p.SetState(20469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMNS { + { + p.SetState(20460) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20461) + p.Xml_table_column() + } + p.SetState(20466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20462) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20463) + p.Xml_table_column() + } + + p.SetState(20468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(20471) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20474) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2914, p.GetParserRuleContext()) == 1 { + { + p.SetState(20472) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20473) + p.General_element_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChar_set_nameContext is an interface to support dynamic dispatch. +type IChar_set_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsChar_set_nameContext differentiates from other interfaces. + IsChar_set_nameContext() +} + +type Char_set_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChar_set_nameContext() *Char_set_nameContext { + var p = new(Char_set_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_set_name + return p +} + +func InitEmptyChar_set_nameContext(p *Char_set_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_set_name +} + +func (*Char_set_nameContext) IsChar_set_nameContext() {} + +func NewChar_set_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Char_set_nameContext { + var p = new(Char_set_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_char_set_name + + return p +} + +func (s *Char_set_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Char_set_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Char_set_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Char_set_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Char_set_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Char_set_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Char_set_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Char_set_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterChar_set_name(s) + } +} + +func (s *Char_set_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitChar_set_name(s) + } +} + +func (p *PlSqlParser) Char_set_name() (localctx IChar_set_nameContext) { + localctx = NewChar_set_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2346, PlSqlParserRULE_char_set_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20476) + p.Id_expression() + } + p.SetState(20481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2915, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20477) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20478) + p.Id_expression() + } + + } + p.SetState(20483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2915, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISynonym_nameContext is an interface to support dynamic dispatch. +type ISynonym_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsSynonym_nameContext differentiates from other interfaces. + IsSynonym_nameContext() +} + +type Synonym_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySynonym_nameContext() *Synonym_nameContext { + var p = new(Synonym_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synonym_name + return p +} + +func InitEmptySynonym_nameContext(p *Synonym_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synonym_name +} + +func (*Synonym_nameContext) IsSynonym_nameContext() {} + +func NewSynonym_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Synonym_nameContext { + var p = new(Synonym_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_synonym_name + + return p +} + +func (s *Synonym_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Synonym_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Synonym_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Synonym_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Synonym_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSynonym_name(s) + } +} + +func (s *Synonym_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSynonym_name(s) + } +} + +func (p *PlSqlParser) Synonym_name() (localctx ISynonym_nameContext) { + localctx = NewSynonym_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2348, PlSqlParserRULE_synonym_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20484) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_object_nameContext is an interface to support dynamic dispatch. +type ISchema_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsSchema_object_nameContext differentiates from other interfaces. + IsSchema_object_nameContext() +} + +type Schema_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_object_nameContext() *Schema_object_nameContext { + var p = new(Schema_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_object_name + return p +} + +func InitEmptySchema_object_nameContext(p *Schema_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_object_name +} + +func (*Schema_object_nameContext) IsSchema_object_nameContext() {} + +func NewSchema_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_object_nameContext { + var p = new(Schema_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_schema_object_name + + return p +} + +func (s *Schema_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Schema_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSchema_object_name(s) + } +} + +func (s *Schema_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSchema_object_name(s) + } +} + +func (p *PlSqlParser) Schema_object_name() (localctx ISchema_object_nameContext) { + localctx = NewSchema_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2350, PlSqlParserRULE_schema_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20486) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDir_object_nameContext is an interface to support dynamic dispatch. +type IDir_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDir_object_nameContext differentiates from other interfaces. + IsDir_object_nameContext() +} + +type Dir_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDir_object_nameContext() *Dir_object_nameContext { + var p = new(Dir_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_object_name + return p +} + +func InitEmptyDir_object_nameContext(p *Dir_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_object_name +} + +func (*Dir_object_nameContext) IsDir_object_nameContext() {} + +func NewDir_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dir_object_nameContext { + var p = new(Dir_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dir_object_name + + return p +} + +func (s *Dir_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dir_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dir_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dir_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dir_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDir_object_name(s) + } +} + +func (s *Dir_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDir_object_name(s) + } +} + +func (p *PlSqlParser) Dir_object_name() (localctx IDir_object_nameContext) { + localctx = NewDir_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2352, PlSqlParserRULE_dir_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20488) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_object_nameContext is an interface to support dynamic dispatch. +type IUser_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsUser_object_nameContext differentiates from other interfaces. + IsUser_object_nameContext() +} + +type User_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_object_nameContext() *User_object_nameContext { + var p = new(User_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_object_name + return p +} + +func InitEmptyUser_object_nameContext(p *User_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_object_name +} + +func (*User_object_nameContext) IsUser_object_nameContext() {} + +func NewUser_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_object_nameContext { + var p = new(User_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_object_name + + return p +} + +func (s *User_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *User_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_object_name(s) + } +} + +func (s *User_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_object_name(s) + } +} + +func (p *PlSqlParser) User_object_name() (localctx IUser_object_nameContext) { + localctx = NewUser_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2354, PlSqlParserRULE_user_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20490) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_object_nameContext is an interface to support dynamic dispatch. +type IGrant_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + USER() antlr.TerminalNode + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Dir_object_name() IDir_object_nameContext + EDITION() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + JAVA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + + // IsGrant_object_nameContext differentiates from other interfaces. + IsGrant_object_nameContext() +} + +type Grant_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_object_nameContext() *Grant_object_nameContext { + var p = new(Grant_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_object_name + return p +} + +func InitEmptyGrant_object_nameContext(p *Grant_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_object_name +} + +func (*Grant_object_nameContext) IsGrant_object_nameContext() {} + +func NewGrant_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_object_nameContext { + var p = new(Grant_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grant_object_name + + return p +} + +func (s *Grant_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_object_nameContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Grant_object_nameContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Grant_object_nameContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_object_nameContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Grant_object_nameContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grant_object_nameContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grant_object_nameContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Grant_object_nameContext) Dir_object_name() IDir_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDir_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDir_object_nameContext) +} + +func (s *Grant_object_nameContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Grant_object_nameContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Grant_object_nameContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Grant_object_nameContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Grant_object_nameContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Grant_object_nameContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Grant_object_nameContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Grant_object_nameContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Grant_object_nameContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Grant_object_nameContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Grant_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrant_object_name(s) + } +} + +func (s *Grant_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrant_object_name(s) + } +} + +func (p *PlSqlParser) Grant_object_name() (localctx IGrant_object_nameContext) { + localctx = NewGrant_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2356, PlSqlParserRULE_grant_object_name) + var _la int + + p.SetState(20516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2917, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20492) + p.Tableview_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20493) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20494) + p.User_object_name() + } + p.SetState(20499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20495) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20496) + p.User_object_name() + } + + p.SetState(20501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20502) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20503) + p.Dir_object_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20504) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20505) + p.Schema_object_name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20506) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20507) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20508) + p.Schema_object_name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20509) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20510) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20511) + p.Schema_object_name() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20512) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20513) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20514) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20515) + p.Schema_object_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_listContext is an interface to support dynamic dispatch. +type IColumn_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_listContext differentiates from other interfaces. + IsColumn_listContext() +} + +type Column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_listContext() *Column_listContext { + var p = new(Column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_list + return p +} + +func InitEmptyColumn_listContext(p *Column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_list +} + +func (*Column_listContext) IsColumn_listContext() {} + +func NewColumn_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_listContext { + var p = new(Column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_list + + return p +} + +func (s *Column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_listContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_listContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_list(s) + } +} + +func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_list(s) + } +} + +func (p *PlSqlParser) Column_list() (localctx IColumn_listContext) { + localctx = NewColumn_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2358, PlSqlParserRULE_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20518) + p.Column_name() + } + p.SetState(20523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20519) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20520) + p.Column_name() + } + + p.SetState(20525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParen_column_listContext is an interface to support dynamic dispatch. +type IParen_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsParen_column_listContext differentiates from other interfaces. + IsParen_column_listContext() +} + +type Paren_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParen_column_listContext() *Paren_column_listContext { + var p = new(Paren_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_paren_column_list + return p +} + +func InitEmptyParen_column_listContext(p *Paren_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_paren_column_list +} + +func (*Paren_column_listContext) IsParen_column_listContext() {} + +func NewParen_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Paren_column_listContext { + var p = new(Paren_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_paren_column_list + + return p +} + +func (s *Paren_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Paren_column_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Paren_column_listContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Paren_column_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Paren_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Paren_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Paren_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParen_column_list(s) + } +} + +func (s *Paren_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParen_column_list(s) + } +} + +func (p *PlSqlParser) Paren_column_list() (localctx IParen_column_listContext) { + localctx = NewParen_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2360, PlSqlParserRULE_paren_column_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20526) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20527) + p.Column_list() + } + { + p.SetState(20528) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeep_clauseContext is an interface to support dynamic dispatch. +type IKeep_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KEEP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + Query_partition_clause() IQuery_partition_clauseContext + Order_by_clause() IOrder_by_clauseContext + Over_clause() IOver_clauseContext + + // IsKeep_clauseContext differentiates from other interfaces. + IsKeep_clauseContext() +} + +type Keep_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeep_clauseContext() *Keep_clauseContext { + var p = new(Keep_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keep_clause + return p +} + +func InitEmptyKeep_clauseContext(p *Keep_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keep_clause +} + +func (*Keep_clauseContext) IsKeep_clauseContext() {} + +func NewKeep_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keep_clauseContext { + var p = new(Keep_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keep_clause + + return p +} + +func (s *Keep_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keep_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Keep_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Keep_clauseContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Keep_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Keep_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Keep_clauseContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Keep_clauseContext) Query_partition_clause() IQuery_partition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_partition_clauseContext) +} + +func (s *Keep_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Keep_clauseContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Keep_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keep_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keep_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeep_clause(s) + } +} + +func (s *Keep_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeep_clause(s) + } +} + +func (p *PlSqlParser) Keep_clause() (localctx IKeep_clauseContext) { + localctx = NewKeep_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2362, PlSqlParserRULE_keep_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20530) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20531) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20532) + p.Match(PlSqlParserDENSE_RANK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20533) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(20534) + p.Query_partition_clause() + } + + case PlSqlParserORDER: + { + p.SetState(20535) + p.Order_by_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(20538) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20540) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2920, p.GetParserRuleContext()) == 1 { + { + p.SetState(20539) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_argumentContext is an interface to support dynamic dispatch. +type IFunction_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllArgument() []IArgumentContext + Argument(i int) IArgumentContext + Keep_clause() IKeep_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_argumentContext differentiates from other interfaces. + IsFunction_argumentContext() +} + +type Function_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argumentContext() *Function_argumentContext { + var p = new(Function_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument + return p +} + +func InitEmptyFunction_argumentContext(p *Function_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument +} + +func (*Function_argumentContext) IsFunction_argumentContext() {} + +func NewFunction_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argumentContext { + var p = new(Function_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument + + return p +} + +func (s *Function_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argumentContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argumentContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argumentContext) AllArgument() []IArgumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArgumentContext); ok { + len++ + } + } + + tst := make([]IArgumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArgumentContext); ok { + tst[i] = t.(IArgumentContext) + i++ + } + } + + return tst +} + +func (s *Function_argumentContext) Argument(i int) IArgumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Function_argumentContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argumentContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argumentContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument(s) + } +} + +func (s *Function_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument(s) + } +} + +func (p *PlSqlParser) Function_argument() (localctx IFunction_argumentContext) { + localctx = NewFunction_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2364, PlSqlParserRULE_function_argument) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20542) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20551) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2922, p.GetParserRuleContext()) == 1 { + { + p.SetState(20543) + p.Argument() + } + p.SetState(20548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20544) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20545) + p.Argument() + } + + p.SetState(20550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20553) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20555) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2923, p.GetParserRuleContext()) == 1 { + { + p.SetState(20554) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_argument_analyticContext is an interface to support dynamic dispatch. +type IFunction_argument_analyticContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllArgument() []IArgumentContext + Argument(i int) IArgumentContext + Keep_clause() IKeep_clauseContext + AllRespect_or_ignore_nulls() []IRespect_or_ignore_nullsContext + Respect_or_ignore_nulls(i int) IRespect_or_ignore_nullsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_argument_analyticContext differentiates from other interfaces. + IsFunction_argument_analyticContext() +} + +type Function_argument_analyticContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argument_analyticContext() *Function_argument_analyticContext { + var p = new(Function_argument_analyticContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_analytic + return p +} + +func InitEmptyFunction_argument_analyticContext(p *Function_argument_analyticContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_analytic +} + +func (*Function_argument_analyticContext) IsFunction_argument_analyticContext() {} + +func NewFunction_argument_analyticContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argument_analyticContext { + var p = new(Function_argument_analyticContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument_analytic + + return p +} + +func (s *Function_argument_analyticContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argument_analyticContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argument_analyticContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argument_analyticContext) AllArgument() []IArgumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArgumentContext); ok { + len++ + } + } + + tst := make([]IArgumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArgumentContext); ok { + tst[i] = t.(IArgumentContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_analyticContext) Argument(i int) IArgumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Function_argument_analyticContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argument_analyticContext) AllRespect_or_ignore_nulls() []IRespect_or_ignore_nullsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + len++ + } + } + + tst := make([]IRespect_or_ignore_nullsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + tst[i] = t.(IRespect_or_ignore_nullsContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_analyticContext) Respect_or_ignore_nulls(i int) IRespect_or_ignore_nullsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRespect_or_ignore_nullsContext) +} + +func (s *Function_argument_analyticContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argument_analyticContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argument_analyticContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argument_analyticContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argument_analyticContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument_analytic(s) + } +} + +func (s *Function_argument_analyticContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument_analytic(s) + } +} + +func (p *PlSqlParser) Function_argument_analytic() (localctx IFunction_argument_analyticContext) { + localctx = NewFunction_argument_analyticContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2366, PlSqlParserRULE_function_argument_analytic) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20557) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2927, p.GetParserRuleContext()) == 1 { + { + p.SetState(20558) + p.Argument() + } + p.SetState(20560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(20559) + p.Respect_or_ignore_nulls() + } + + } + p.SetState(20569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20562) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20563) + p.Argument() + } + p.SetState(20565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(20564) + p.Respect_or_ignore_nulls() + } + + } + + p.SetState(20571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20574) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20576) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2928, p.GetParserRuleContext()) == 1 { + { + p.SetState(20575) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_argument_modelingContext is an interface to support dynamic dispatch. +type IFunction_argument_modelingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + USING() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Tableview_name() ITableview_nameContext + PERIOD() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Keep_clause() IKeep_clauseContext + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + + // IsFunction_argument_modelingContext differentiates from other interfaces. + IsFunction_argument_modelingContext() +} + +type Function_argument_modelingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argument_modelingContext() *Function_argument_modelingContext { + var p = new(Function_argument_modelingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_modeling + return p +} + +func InitEmptyFunction_argument_modelingContext(p *Function_argument_modelingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_modeling +} + +func (*Function_argument_modelingContext) IsFunction_argument_modelingContext() {} + +func NewFunction_argument_modelingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argument_modelingContext { + var p = new(Function_argument_modelingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument_modeling + + return p +} + +func (s *Function_argument_modelingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argument_modelingContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argument_modelingContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Function_argument_modelingContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Function_argument_modelingContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argument_modelingContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Function_argument_modelingContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Function_argument_modelingContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Function_argument_modelingContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Function_argument_modelingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argument_modelingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argument_modelingContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argument_modelingContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Function_argument_modelingContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Function_argument_modelingContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Function_argument_modelingContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Function_argument_modelingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argument_modelingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argument_modelingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument_modeling(s) + } +} + +func (s *Function_argument_modelingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument_modeling(s) + } +} + +func (p *PlSqlParser) Function_argument_modeling() (localctx IFunction_argument_modelingContext) { + localctx = NewFunction_argument_modelingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2368, PlSqlParserRULE_function_argument_modeling) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20578) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20579) + p.Column_name() + } + p.SetState(20592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(20580) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(20581) + p.Numeric() + } + + case PlSqlParserNULL_: + { + p.SetState(20582) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(20585) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(20586) + p.Numeric() + } + + case PlSqlParserNULL_: + { + p.SetState(20587) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + } + { + p.SetState(20594) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2936, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20595) + p.Tableview_name() + } + { + p.SetState(20596) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20597) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(20599) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(20600) + p.Expression() + } + p.SetState(20602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(20601) + p.Column_alias() + } + + } + p.SetState(20611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(20604) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20605) + p.Expression() + } + p.SetState(20607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-38848219710488578) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-738593637692080201) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9223231157632491519) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-36033195065475341) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288230376168489133) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-147351737992195) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-2612300007874756705) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-6377193829449088825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-536887297) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4521191880523777) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-9042392225284801) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-4785091783958529) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1152921504607045761) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-563093868380165) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1152921504606846985) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-35184372219905) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1134764719341569) != 0) || ((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&-17592588698625) != 0) || ((int64((_la-1154)) & ^0x3f) == 0 && ((int64(1)<<(_la-1154))&-1688858584416257) != 0) || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&9169326092278823933) != 0) || ((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&-290482184573157377) != 0) || ((int64((_la-1347)) & ^0x3f) == 0 && ((int64(1)<<(_la-1347))&-281743147925505) != 0) || ((int64((_la-1411)) & ^0x3f) == 0 && ((int64(1)<<(_la-1411))&-8798240505857) != 0) || ((int64((_la-1475)) & ^0x3f) == 0 && ((int64(1)<<(_la-1475))&-4563402753) != 0) || ((int64((_la-1539)) & ^0x3f) == 0 && ((int64(1)<<(_la-1539))&-1125902054334465) != 0) || ((int64((_la-1603)) & ^0x3f) == 0 && ((int64(1)<<(_la-1603))&-56312587528175617) != 0) || ((int64((_la-1667)) & ^0x3f) == 0 && ((int64(1)<<(_la-1667))&-72057606922838529) != 0) || ((int64((_la-1731)) & ^0x3f) == 0 && ((int64(1)<<(_la-1731))&-193) != 0) || ((int64((_la-1795)) & ^0x3f) == 0 && ((int64(1)<<(_la-1795))&-3) != 0) || ((int64((_la-1859)) & ^0x3f) == 0 && ((int64(1)<<(_la-1859))&-1) != 0) || ((int64((_la-1923)) & ^0x3f) == 0 && ((int64(1)<<(_la-1923))&-1) != 0) || ((int64((_la-1987)) & ^0x3f) == 0 && ((int64(1)<<(_la-1987))&-1) != 0) || ((int64((_la-2051)) & ^0x3f) == 0 && ((int64(1)<<(_la-2051))&-1205064744042497) != 0) || ((int64((_la-2115)) & ^0x3f) == 0 && ((int64(1)<<(_la-2115))&-17246978113) != 0) || ((int64((_la-2179)) & ^0x3f) == 0 && ((int64(1)<<(_la-2179))&-270532637) != 0) || ((int64((_la-2243)) & ^0x3f) == 0 && ((int64(1)<<(_la-2243))&-288239172248158209) != 0) || ((int64((_la-2307)) & ^0x3f) == 0 && ((int64(1)<<(_la-2307))&-149183936713457931) != 0) || ((int64((_la-2371)) & ^0x3f) == 0 && ((int64(1)<<(_la-2371))&-13958684673) != 0) || ((int64((_la-2435)) & ^0x3f) == 0 && ((int64(1)<<(_la-2435))&36283883717411) != 0) { + { + p.SetState(20606) + p.Column_alias() + } + + } + + p.SetState(20613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(20616) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20618) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2937, p.GetParserRuleContext()) == 1 { + { + p.SetState(20617) + p.Keep_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRespect_or_ignore_nullsContext is an interface to support dynamic dispatch. +type IRespect_or_ignore_nullsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULLS() antlr.TerminalNode + RESPECT() antlr.TerminalNode + IGNORE() antlr.TerminalNode + + // IsRespect_or_ignore_nullsContext differentiates from other interfaces. + IsRespect_or_ignore_nullsContext() +} + +type Respect_or_ignore_nullsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRespect_or_ignore_nullsContext() *Respect_or_ignore_nullsContext { + var p = new(Respect_or_ignore_nullsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls + return p +} + +func InitEmptyRespect_or_ignore_nullsContext(p *Respect_or_ignore_nullsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls +} + +func (*Respect_or_ignore_nullsContext) IsRespect_or_ignore_nullsContext() {} + +func NewRespect_or_ignore_nullsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Respect_or_ignore_nullsContext { + var p = new(Respect_or_ignore_nullsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls + + return p +} + +func (s *Respect_or_ignore_nullsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Respect_or_ignore_nullsContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Respect_or_ignore_nullsContext) RESPECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESPECT, 0) +} + +func (s *Respect_or_ignore_nullsContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Respect_or_ignore_nullsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Respect_or_ignore_nullsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Respect_or_ignore_nullsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRespect_or_ignore_nulls(s) + } +} + +func (s *Respect_or_ignore_nullsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRespect_or_ignore_nulls(s) + } +} + +func (p *PlSqlParser) Respect_or_ignore_nulls() (localctx IRespect_or_ignore_nullsContext) { + localctx = NewRespect_or_ignore_nullsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2370, PlSqlParserRULE_respect_or_ignore_nulls) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20620) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20621) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArgumentContext is an interface to support dynamic dispatch. +type IArgumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Identifier() IIdentifierContext + EQUALS_OP() antlr.TerminalNode + GREATER_THAN_OP() antlr.TerminalNode + + // IsArgumentContext differentiates from other interfaces. + IsArgumentContext() +} + +type ArgumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArgumentContext() *ArgumentContext { + var p = new(ArgumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_argument + return p +} + +func InitEmptyArgumentContext(p *ArgumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_argument +} + +func (*ArgumentContext) IsArgumentContext() {} + +func NewArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentContext { + var p = new(ArgumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_argument + + return p +} + +func (s *ArgumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *ArgumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ArgumentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ArgumentContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *ArgumentContext) GREATER_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, 0) +} + +func (s *ArgumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ArgumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterArgument(s) + } +} + +func (s *ArgumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitArgument(s) + } +} + +func (p *PlSqlParser) Argument() (localctx IArgumentContext) { + localctx = NewArgumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2372, PlSqlParserRULE_argument) + p.EnterOuterAlt(localctx, 1) + p.SetState(20627) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2938, p.GetParserRuleContext()) == 1 { + { + p.SetState(20623) + p.Identifier() + } + { + p.SetState(20624) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20625) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20629) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_specContext is an interface to support dynamic dispatch. +type IType_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datatype() IDatatypeContext + Type_name() IType_nameContext + REF() antlr.TerminalNode + PERCENT_ROWTYPE() antlr.TerminalNode + PERCENT_TYPE() antlr.TerminalNode + + // IsType_specContext differentiates from other interfaces. + IsType_specContext() +} + +type Type_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_specContext() *Type_specContext { + var p = new(Type_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_spec + return p +} + +func InitEmptyType_specContext(p *Type_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_spec +} + +func (*Type_specContext) IsType_specContext() {} + +func NewType_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_specContext { + var p = new(Type_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_spec + + return p +} + +func (s *Type_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_specContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Type_specContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_specContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Type_specContext) PERCENT_ROWTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ROWTYPE, 0) +} + +func (s *Type_specContext) PERCENT_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_TYPE, 0) +} + +func (s *Type_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_spec(s) + } +} + +func (s *Type_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_spec(s) + } +} + +func (p *PlSqlParser) Type_spec() (localctx IType_specContext) { + localctx = NewType_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2374, PlSqlParserRULE_type_spec) + var _la int + + p.SetState(20639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2941, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20631) + p.Datatype() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(20633) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2939, p.GetParserRuleContext()) == 1 { + { + p.SetState(20632) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(20635) + p.Type_name() + } + p.SetState(20637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERCENT_ROWTYPE || _la == PlSqlParserPERCENT_TYPE { + { + p.SetState(20636) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPERCENT_ROWTYPE || _la == PlSqlParserPERCENT_TYPE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatatypeContext is an interface to support dynamic dispatch. +type IDatatypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Native_datatype_element() INative_datatype_elementContext + Precision_part() IPrecision_partContext + WITH() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + LOCAL() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + TO() antlr.TerminalNode + YEAR() antlr.TerminalNode + DAY() antlr.TerminalNode + MONTH() antlr.TerminalNode + SECOND() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + + // IsDatatypeContext differentiates from other interfaces. + IsDatatypeContext() +} + +type DatatypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatypeContext() *DatatypeContext { + var p = new(DatatypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype + return p +} + +func InitEmptyDatatypeContext(p *DatatypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype +} + +func (*DatatypeContext) IsDatatypeContext() {} + +func NewDatatypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatatypeContext { + var p = new(DatatypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datatype + + return p +} + +func (s *DatatypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatatypeContext) Native_datatype_element() INative_datatype_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INative_datatype_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INative_datatype_elementContext) +} + +func (s *DatatypeContext) Precision_part() IPrecision_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrecision_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrecision_partContext) +} + +func (s *DatatypeContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *DatatypeContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *DatatypeContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *DatatypeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *DatatypeContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *DatatypeContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *DatatypeContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *DatatypeContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *DatatypeContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *DatatypeContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *DatatypeContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *DatatypeContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *DatatypeContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *DatatypeContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *DatatypeContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *DatatypeContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DatatypeContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DatatypeContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *DatatypeContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *DatatypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DatatypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DatatypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatatype(s) + } +} + +func (s *DatatypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatatype(s) + } +} + +func (p *PlSqlParser) Datatype() (localctx IDatatypeContext) { + localctx = NewDatatypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2376, PlSqlParserRULE_datatype) + var _la int + + p.SetState(20672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBFILE, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_INTEGER, PlSqlParserBLOB, PlSqlParserBOOLEAN, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCLOB, PlSqlParserDATE, PlSqlParserDAY, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDOUBLE, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserFLOAT, PlSqlParserHOUR, PlSqlParserINTEGER, PlSqlParserINT, PlSqlParserLONG, PlSqlParserMINUTE, PlSqlParserMLSLABEL, PlSqlParserMONTH, PlSqlParserNATURAL, PlSqlParserNATURALN, PlSqlParserNCHAR, PlSqlParserNCLOB, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNVARCHAR2, PlSqlParserPLS_INTEGER, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserRAW, PlSqlParserREAL, PlSqlParserROWID, PlSqlParserSDO_GEOMETRY, PlSqlParserSECOND, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSMALLINT, PlSqlParserSTRING, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_REGION, PlSqlParserUROWID, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserXMLTYPE, PlSqlParserYEAR, PlSqlParserYMINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20641) + p.Native_datatype_element() + } + p.SetState(20643) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2942, p.GetParserRuleContext()) == 1 { + { + p.SetState(20642) + p.Precision_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20654) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2944, p.GetParserRuleContext()) == 1 { + { + p.SetState(20645) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(20646) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20649) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20650) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2944, p.GetParserRuleContext()) == 2 { + { + p.SetState(20651) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20652) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20653) + p.Char_set_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserINTERVAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20656) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20657) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(20658) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20659) + p.Expression() + } + { + p.SetState(20660) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20664) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20665) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMONTH || _la == PlSqlParserSECOND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20670) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2946, p.GetParserRuleContext()) == 1 { + { + p.SetState(20666) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20667) + p.Expression() + } + { + p.SetState(20668) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrecision_partContext is an interface to support dynamic dispatch. +type IPrecision_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + ASTERISK() antlr.TerminalNode + COMMA() antlr.TerminalNode + CHAR() antlr.TerminalNode + BYTE() antlr.TerminalNode + Numeric_negative() INumeric_negativeContext + + // IsPrecision_partContext differentiates from other interfaces. + IsPrecision_partContext() +} + +type Precision_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrecision_partContext() *Precision_partContext { + var p = new(Precision_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_precision_part + return p +} + +func InitEmptyPrecision_partContext(p *Precision_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_precision_part +} + +func (*Precision_partContext) IsPrecision_partContext() {} + +func NewPrecision_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Precision_partContext { + var p = new(Precision_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_precision_part + + return p +} + +func (s *Precision_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Precision_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Precision_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Precision_partContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Precision_partContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Precision_partContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Precision_partContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Precision_partContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Precision_partContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Precision_partContext) Numeric_negative() INumeric_negativeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_negativeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_negativeContext) +} + +func (s *Precision_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Precision_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Precision_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrecision_part(s) + } +} + +func (s *Precision_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrecision_part(s) + } +} + +func (p *PlSqlParser) Precision_part() (localctx IPrecision_partContext) { + localctx = NewPrecision_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2378, PlSqlParserRULE_precision_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20674) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(20675) + p.Numeric() + } + + case PlSqlParserASTERISK: + { + p.SetState(20676) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(20679) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(20680) + p.Numeric() + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(20681) + p.Numeric_negative() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(20687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(20686) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(20689) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INative_datatype_elementContext is an interface to support dynamic dispatch. +type INative_datatype_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINARY_INTEGER() antlr.TerminalNode + PLS_INTEGER() antlr.TerminalNode + NATURAL() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + NATURALN() antlr.TerminalNode + POSITIVE() antlr.TerminalNode + POSITIVEN() antlr.TerminalNode + SIGNTYPE() antlr.TerminalNode + SIMPLE_INTEGER() antlr.TerminalNode + NVARCHAR2() antlr.TerminalNode + DEC() antlr.TerminalNode + INTEGER() antlr.TerminalNode + INT() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + NUMBER() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + PRECISION() antlr.TerminalNode + FLOAT() antlr.TerminalNode + REAL() antlr.TerminalNode + NCHAR() antlr.TerminalNode + LONG() antlr.TerminalNode + RAW() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + VARYING() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + STRING() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + DATE() antlr.TerminalNode + ROWID() antlr.TerminalNode + UROWID() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + DAY() antlr.TerminalNode + HOUR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + SECOND() antlr.TerminalNode + SDO_GEOMETRY() antlr.TerminalNode + TIMEZONE_HOUR() antlr.TerminalNode + TIMEZONE_MINUTE() antlr.TerminalNode + TIMEZONE_REGION() antlr.TerminalNode + TIMEZONE_ABBR() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode + YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode + DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode + BFILE() antlr.TerminalNode + BLOB() antlr.TerminalNode + CLOB() antlr.TerminalNode + NCLOB() antlr.TerminalNode + MLSLABEL() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + + // IsNative_datatype_elementContext differentiates from other interfaces. + IsNative_datatype_elementContext() +} + +type Native_datatype_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNative_datatype_elementContext() *Native_datatype_elementContext { + var p = new(Native_datatype_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_native_datatype_element + return p +} + +func InitEmptyNative_datatype_elementContext(p *Native_datatype_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_native_datatype_element +} + +func (*Native_datatype_elementContext) IsNative_datatype_elementContext() {} + +func NewNative_datatype_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Native_datatype_elementContext { + var p = new(Native_datatype_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_native_datatype_element + + return p +} + +func (s *Native_datatype_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Native_datatype_elementContext) BINARY_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) PLS_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLS_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 0) +} + +func (s *Native_datatype_elementContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *Native_datatype_elementContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *Native_datatype_elementContext) NATURALN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURALN, 0) +} + +func (s *Native_datatype_elementContext) POSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVE, 0) +} + +func (s *Native_datatype_elementContext) POSITIVEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVEN, 0) +} + +func (s *Native_datatype_elementContext) SIGNTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNTYPE, 0) +} + +func (s *Native_datatype_elementContext) SIMPLE_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) NVARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVARCHAR2, 0) +} + +func (s *Native_datatype_elementContext) DEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEC, 0) +} + +func (s *Native_datatype_elementContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *Native_datatype_elementContext) INT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINT, 0) +} + +func (s *Native_datatype_elementContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMERIC, 0) +} + +func (s *Native_datatype_elementContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLINT, 0) +} + +func (s *Native_datatype_elementContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Native_datatype_elementContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *Native_datatype_elementContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Native_datatype_elementContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Native_datatype_elementContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *Native_datatype_elementContext) REAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAL, 0) +} + +func (s *Native_datatype_elementContext) NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR, 0) +} + +func (s *Native_datatype_elementContext) LONG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLONG, 0) +} + +func (s *Native_datatype_elementContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *Native_datatype_elementContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Native_datatype_elementContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Native_datatype_elementContext) VARYING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARYING, 0) +} + +func (s *Native_datatype_elementContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Native_datatype_elementContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *Native_datatype_elementContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *Native_datatype_elementContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOOLEAN, 0) +} + +func (s *Native_datatype_elementContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Native_datatype_elementContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Native_datatype_elementContext) UROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUROWID, 0) +} + +func (s *Native_datatype_elementContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Native_datatype_elementContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Native_datatype_elementContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Native_datatype_elementContext) HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, 0) +} + +func (s *Native_datatype_elementContext) MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, 0) +} + +func (s *Native_datatype_elementContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Native_datatype_elementContext) SDO_GEOMETRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOMETRY, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_HOUR, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_MINUTE, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_REGION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_REGION, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_ABBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_ABBR, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserYMINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDSINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Native_datatype_elementContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Native_datatype_elementContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Native_datatype_elementContext) NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCLOB, 0) +} + +func (s *Native_datatype_elementContext) MLSLABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMLSLABEL, 0) +} + +func (s *Native_datatype_elementContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Native_datatype_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Native_datatype_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Native_datatype_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNative_datatype_element(s) + } +} + +func (s *Native_datatype_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNative_datatype_element(s) + } +} + +func (p *PlSqlParser) Native_datatype_element() (localctx INative_datatype_elementContext) { + localctx = NewNative_datatype_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2380, PlSqlParserRULE_native_datatype_element) + p.SetState(20756) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINARY_INTEGER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20691) + p.Match(PlSqlParserBINARY_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPLS_INTEGER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20692) + p.Match(PlSqlParserPLS_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATURAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20693) + p.Match(PlSqlParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_FLOAT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20694) + p.Match(PlSqlParserBINARY_FLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_DOUBLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20695) + p.Match(PlSqlParserBINARY_DOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATURALN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20696) + p.Match(PlSqlParserNATURALN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPOSITIVE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20697) + p.Match(PlSqlParserPOSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPOSITIVEN: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20698) + p.Match(PlSqlParserPOSITIVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSIGNTYPE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20699) + p.Match(PlSqlParserSIGNTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSIMPLE_INTEGER: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20700) + p.Match(PlSqlParserSIMPLE_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNVARCHAR2: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20701) + p.Match(PlSqlParserNVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEC: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20702) + p.Match(PlSqlParserDEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINTEGER: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20703) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINT: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(20704) + p.Match(PlSqlParserINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNUMERIC: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(20705) + p.Match(PlSqlParserNUMERIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSMALLINT: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(20706) + p.Match(PlSqlParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNUMBER: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(20707) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(20708) + p.Match(PlSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDOUBLE: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(20709) + p.Match(PlSqlParserDOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20711) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2952, p.GetParserRuleContext()) == 1 { + { + p.SetState(20710) + p.Match(PlSqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserFLOAT: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(20713) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAL: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(20714) + p.Match(PlSqlParserREAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNCHAR: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(20715) + p.Match(PlSqlParserNCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLONG: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(20716) + p.Match(PlSqlParserLONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20718) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2953, p.GetParserRuleContext()) == 1 { + { + p.SetState(20717) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCHAR: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(20720) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARACTER: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(20721) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20723) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2954, p.GetParserRuleContext()) == 1 { + { + p.SetState(20722) + p.Match(PlSqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserVARCHAR2: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(20725) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARCHAR: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(20726) + p.Match(PlSqlParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTRING: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(20727) + p.Match(PlSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRAW: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(20728) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBOOLEAN: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(20729) + p.Match(PlSqlParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATE: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(20730) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(20731) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUROWID: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(20732) + p.Match(PlSqlParserUROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserYEAR: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(20733) + p.Match(PlSqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMONTH: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(20734) + p.Match(PlSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDAY: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(20735) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHOUR: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(20736) + p.Match(PlSqlParserHOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUTE: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(20737) + p.Match(PlSqlParserMINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSECOND: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(20738) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSDO_GEOMETRY: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(20739) + p.Match(PlSqlParserSDO_GEOMETRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_HOUR: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(20740) + p.Match(PlSqlParserTIMEZONE_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_MINUTE: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(20741) + p.Match(PlSqlParserTIMEZONE_MINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_REGION: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(20742) + p.Match(PlSqlParserTIMEZONE_REGION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_ABBR: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(20743) + p.Match(PlSqlParserTIMEZONE_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(20744) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(20745) + p.Match(PlSqlParserTIMESTAMP_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(20746) + p.Match(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(20747) + p.Match(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserYMINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(20748) + p.Match(PlSqlParserYMINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDSINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(20749) + p.Match(PlSqlParserDSINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBFILE: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(20750) + p.Match(PlSqlParserBFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(20751) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLOB: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(20752) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNCLOB: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(20753) + p.Match(PlSqlParserNCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMLSLABEL: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(20754) + p.Match(PlSqlParserMLSLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserXMLTYPE: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(20755) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBind_variableContext is an interface to support dynamic dispatch. +type IBind_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllBINDVAR() []antlr.TerminalNode + BINDVAR(i int) antlr.TerminalNode + AllCOLON() []antlr.TerminalNode + COLON(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllGeneral_element_part() []IGeneral_element_partContext + General_element_part(i int) IGeneral_element_partContext + INDICATOR() antlr.TerminalNode + + // IsBind_variableContext differentiates from other interfaces. + IsBind_variableContext() +} + +type Bind_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBind_variableContext() *Bind_variableContext { + var p = new(Bind_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bind_variable + return p +} + +func InitEmptyBind_variableContext(p *Bind_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bind_variable +} + +func (*Bind_variableContext) IsBind_variableContext() {} + +func NewBind_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bind_variableContext { + var p = new(Bind_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bind_variable + + return p +} + +func (s *Bind_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bind_variableContext) AllBINDVAR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBINDVAR) +} + +func (s *Bind_variableContext) BINDVAR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDVAR, i) +} + +func (s *Bind_variableContext) AllCOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLON) +} + +func (s *Bind_variableContext) COLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, i) +} + +func (s *Bind_variableContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Bind_variableContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Bind_variableContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Bind_variableContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Bind_variableContext) AllGeneral_element_part() []IGeneral_element_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_element_partContext); ok { + len++ + } + } + + tst := make([]IGeneral_element_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_element_partContext); ok { + tst[i] = t.(IGeneral_element_partContext) + i++ + } + } + + return tst +} + +func (s *Bind_variableContext) General_element_part(i int) IGeneral_element_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *Bind_variableContext) INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICATOR, 0) +} + +func (s *Bind_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bind_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bind_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBind_variable(s) + } +} + +func (s *Bind_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBind_variable(s) + } +} + +func (p *PlSqlParser) Bind_variable() (localctx IBind_variableContext) { + localctx = NewBind_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2382, PlSqlParserRULE_bind_variable) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINDVAR: + { + p.SetState(20758) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLON: + { + p.SetState(20759) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20760) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20771) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2959, p.GetParserRuleContext()) == 1 { + p.SetState(20764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDICATOR { + { + p.SetState(20763) + p.Match(PlSqlParserINDICATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(20769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINDVAR: + { + p.SetState(20766) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLON: + { + p.SetState(20767) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20768) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2960, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20773) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20774) + p.General_element_part() + } + + } + p.SetState(20779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2960, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneral_elementContext is an interface to support dynamic dispatch. +type IGeneral_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGeneral_element_part() []IGeneral_element_partContext + General_element_part(i int) IGeneral_element_partContext + LEFT_PAREN() antlr.TerminalNode + General_element() IGeneral_elementContext + RIGHT_PAREN() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsGeneral_elementContext differentiates from other interfaces. + IsGeneral_elementContext() +} + +type General_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_elementContext() *General_elementContext { + var p = new(General_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element + return p +} + +func InitEmptyGeneral_elementContext(p *General_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element +} + +func (*General_elementContext) IsGeneral_elementContext() {} + +func NewGeneral_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_elementContext { + var p = new(General_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_element + + return p +} + +func (s *General_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_elementContext) AllGeneral_element_part() []IGeneral_element_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_element_partContext); ok { + len++ + } + } + + tst := make([]IGeneral_element_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_element_partContext); ok { + tst[i] = t.(IGeneral_element_partContext) + i++ + } + } + + return tst +} + +func (s *General_elementContext) General_element_part(i int) IGeneral_element_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *General_elementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *General_elementContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *General_elementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *General_elementContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *General_elementContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *General_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_element(s) + } +} + +func (s *General_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_element(s) + } +} + +func (p *PlSqlParser) General_element() (localctx IGeneral_elementContext) { + return p.general_element(0) +} + +func (p *PlSqlParser) general_element(_p int) (localctx IGeneral_elementContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewGeneral_elementContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IGeneral_elementContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2384 + p.EnterRecursionRule(localctx, 2384, PlSqlParserRULE_general_element, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(20781) + p.General_element_part() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(20782) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20783) + p.general_element(0) + } + { + p.SetState(20784) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(20797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2963, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewGeneral_elementContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_general_element) + p.SetState(20788) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + p.SetState(20791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(20789) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20790) + p.General_element_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(20793) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2962, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + p.SetState(20799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2963, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneral_element_partContext is an interface to support dynamic dispatch. +type IGeneral_element_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + AllFunction_argument() []IFunction_argumentContext + Function_argument(i int) IFunction_argumentContext + + // IsGeneral_element_partContext differentiates from other interfaces. + IsGeneral_element_partContext() +} + +type General_element_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_element_partContext() *General_element_partContext { + var p = new(General_element_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element_part + return p +} + +func InitEmptyGeneral_element_partContext(p *General_element_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element_part +} + +func (*General_element_partContext) IsGeneral_element_partContext() {} + +func NewGeneral_element_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_element_partContext { + var p = new(General_element_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_element_part + + return p +} + +func (s *General_element_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_element_partContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *General_element_partContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *General_element_partContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *General_element_partContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *General_element_partContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *General_element_partContext) AllFunction_argument() []IFunction_argumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_argumentContext); ok { + len++ + } + } + + tst := make([]IFunction_argumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_argumentContext); ok { + tst[i] = t.(IFunction_argumentContext) + i++ + } + } + + return tst +} + +func (s *General_element_partContext) Function_argument(i int) IFunction_argumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *General_element_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_element_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_element_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_element_part(s) + } +} + +func (s *General_element_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_element_part(s) + } +} + +func (p *PlSqlParser) General_element_part() (localctx IGeneral_element_partContext) { + localctx = NewGeneral_element_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2386, PlSqlParserRULE_general_element_part) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(20800) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20801) + p.Char_set_name() + } + + } + { + p.SetState(20804) + p.Id_expression() + } + p.SetState(20807) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2965, p.GetParserRuleContext()) == 1 { + { + p.SetState(20805) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20806) + p.Link_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2966, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(20809) + p.Function_argument() + } + + } + p.SetState(20814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2966, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_elementContext is an interface to support dynamic dispatch. +type ITable_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsTable_elementContext differentiates from other interfaces. + IsTable_elementContext() +} + +type Table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_elementContext() *Table_elementContext { + var p = new(Table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_element + return p +} + +func InitEmptyTable_elementContext(p *Table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_element +} + +func (*Table_elementContext) IsTable_elementContext() {} + +func NewTable_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_elementContext { + var p = new(Table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_element + + return p +} + +func (s *Table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_elementContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Table_elementContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Table_elementContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *Table_elementContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Table_elementContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Table_elementContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_element(s) + } +} + +func (s *Table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_element(s) + } +} + +func (p *PlSqlParser) Table_element() (localctx ITable_elementContext) { + localctx = NewTable_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2388, PlSqlParserRULE_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(20815) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20816) + p.Char_set_name() + } + + } + { + p.SetState(20819) + p.Id_expression() + } + p.SetState(20824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(20820) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20821) + p.Id_expression() + } + + p.SetState(20826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_privilegeContext is an interface to support dynamic dispatch. +type IObject_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ALTER() antlr.TerminalNode + DEBUG() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INHERIT() antlr.TerminalNode + REMOTE() antlr.TerminalNode + INSERT() antlr.TerminalNode + KEEP() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + MERGE() antlr.TerminalNode + VIEW() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + READ() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + SELECT() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + SQL() antlr.TerminalNode + UNDER() antlr.TerminalNode + UPDATE() antlr.TerminalNode + USE() antlr.TerminalNode + WRITE() antlr.TerminalNode + + // IsObject_privilegeContext differentiates from other interfaces. + IsObject_privilegeContext() +} + +type Object_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_privilegeContext() *Object_privilegeContext { + var p = new(Object_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_privilege + return p +} + +func InitEmptyObject_privilegeContext(p *Object_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_privilege +} + +func (*Object_privilegeContext) IsObject_privilegeContext() {} + +func NewObject_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_privilegeContext { + var p = new(Object_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_privilege + + return p +} + +func (s *Object_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Object_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Object_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Object_privilegeContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Object_privilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Object_privilegeContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Object_privilegeContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Object_privilegeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Object_privilegeContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *Object_privilegeContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Object_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Object_privilegeContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Object_privilegeContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Object_privilegeContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Object_privilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Object_privilegeContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Object_privilegeContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Object_privilegeContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Object_privilegeContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Object_privilegeContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Object_privilegeContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Object_privilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Object_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Object_privilegeContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Object_privilegeContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Object_privilegeContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Object_privilegeContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Object_privilegeContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Object_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_privilege(s) + } +} + +func (s *Object_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_privilege(s) + } +} + +func (p *PlSqlParser) Object_privilege() (localctx IObject_privilegeContext) { + localctx = NewObject_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2390, PlSqlParserRULE_object_privilege) + p.SetState(20863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2970, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20827) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2969, p.GetParserRuleContext()) == 1 { + { + p.SetState(20828) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20831) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20832) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20833) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20834) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20835) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20836) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20837) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20838) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20839) + p.Match(PlSqlParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20840) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20841) + p.Match(PlSqlParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20842) + p.Match(PlSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20843) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20844) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20845) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20846) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20847) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20848) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(20849) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20850) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20851) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(20852) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20853) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(20854) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(20855) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(20856) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(20857) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20858) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(20859) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(20860) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(20861) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(20862) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_privilegeContext is an interface to support dynamic dispatch. +type ISystem_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ADVISOR() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + SQL() antlr.TerminalNode + TUNING() antlr.TerminalNode + SET() antlr.TerminalNode + ANY() antlr.TerminalNode + PROFILE() antlr.TerminalNode + ALTER() antlr.TerminalNode + CREATE() antlr.TerminalNode + DROP() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + OBJECT() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + EXEMPT() antlr.TerminalNode + REDACTION() antlr.TerminalNode + POLICY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + DEBUG() antlr.TerminalNode + CONNECT() antlr.TerminalNode + SESSION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + EDITION() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + TABLE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + JOB() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + CLASS() antlr.TerminalNode + PROGRAM() antlr.TerminalNode + MANAGE() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + KEY() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + LOGMINING() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + SELECT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + CUBE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + FOLDER() antlr.TerminalNode + DELETE() antlr.TerminalNode + INSERT() antlr.TerminalNode + BUILD() antlr.TerminalNode + PROCESS() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + CONTAINER() antlr.TerminalNode + ROLE() antlr.TerminalNode + GRANT() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + COST() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + USE() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + BACKUP() antlr.TerminalNode + LOCK() antlr.TerminalNode + READ() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TYPE() antlr.TerminalNode + UNDER() antlr.TerminalNode + USER() antlr.TerminalNode + MERGE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + BECOME() antlr.TerminalNode + CHANGE() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + ACCESS() antlr.TerminalNode + FORCE() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + PRIVILEGE() antlr.TerminalNode + INHERIT() antlr.TerminalNode + KEEP() antlr.TerminalNode + DATE() antlr.TerminalNode + TIME() antlr.TerminalNode + SYSGUID() antlr.TerminalNode + PURGE() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + SYSBACKUP() antlr.TerminalNode + SYSDBA() antlr.TerminalNode + SYSDG() antlr.TerminalNode + SYSKM() antlr.TerminalNode + SYSOPER() antlr.TerminalNode + + // IsSystem_privilegeContext differentiates from other interfaces. + IsSystem_privilegeContext() +} + +type System_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_privilegeContext() *System_privilegeContext { + var p = new(System_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_privilege + return p +} + +func InitEmptySystem_privilegeContext(p *System_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_privilege +} + +func (*System_privilegeContext) IsSystem_privilegeContext() {} + +func NewSystem_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_privilegeContext { + var p = new(System_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_privilege + + return p +} + +func (s *System_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *System_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *System_privilegeContext) ADVISOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISOR, 0) +} + +func (s *System_privilegeContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *System_privilegeContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *System_privilegeContext) TUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTUNING, 0) +} + +func (s *System_privilegeContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *System_privilegeContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *System_privilegeContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *System_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *System_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *System_privilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *System_privilegeContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *System_privilegeContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *System_privilegeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *System_privilegeContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *System_privilegeContext) EXEMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXEMPT, 0) +} + +func (s *System_privilegeContext) REDACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDACTION, 0) +} + +func (s *System_privilegeContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *System_privilegeContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *System_privilegeContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *System_privilegeContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *System_privilegeContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *System_privilegeContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *System_privilegeContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *System_privilegeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *System_privilegeContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *System_privilegeContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDICTIONARY, 0) +} + +func (s *System_privilegeContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *System_privilegeContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *System_privilegeContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *System_privilegeContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *System_privilegeContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *System_privilegeContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *System_privilegeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *System_privilegeContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *System_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *System_privilegeContext) JOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOB, 0) +} + +func (s *System_privilegeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *System_privilegeContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *System_privilegeContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROGRAM, 0) +} + +func (s *System_privilegeContext) MANAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGE, 0) +} + +func (s *System_privilegeContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEDULER, 0) +} + +func (s *System_privilegeContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *System_privilegeContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *System_privilegeContext) LOGMINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGMINING, 0) +} + +func (s *System_privilegeContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *System_privilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *System_privilegeContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *System_privilegeContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *System_privilegeContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *System_privilegeContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *System_privilegeContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *System_privilegeContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *System_privilegeContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *System_privilegeContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *System_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *System_privilegeContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *System_privilegeContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *System_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *System_privilegeContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *System_privilegeContext) FOLDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLDER, 0) +} + +func (s *System_privilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *System_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *System_privilegeContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *System_privilegeContext) PROCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCESS, 0) +} + +func (s *System_privilegeContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *System_privilegeContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *System_privilegeContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *System_privilegeContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *System_privilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *System_privilegeContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *System_privilegeContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *System_privilegeContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *System_privilegeContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *System_privilegeContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *System_privilegeContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *System_privilegeContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *System_privilegeContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *System_privilegeContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *System_privilegeContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *System_privilegeContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *System_privilegeContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *System_privilegeContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *System_privilegeContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *System_privilegeContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *System_privilegeContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *System_privilegeContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *System_privilegeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *System_privilegeContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *System_privilegeContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *System_privilegeContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *System_privilegeContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *System_privilegeContext) BECOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBECOME, 0) +} + +func (s *System_privilegeContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *System_privilegeContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTIFICATION, 0) +} + +func (s *System_privilegeContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *System_privilegeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *System_privilegeContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *System_privilegeContext) PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGE, 0) +} + +func (s *System_privilegeContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *System_privilegeContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *System_privilegeContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *System_privilegeContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *System_privilegeContext) SYSGUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSGUID, 0) +} + +func (s *System_privilegeContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *System_privilegeContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *System_privilegeContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUMABLE, 0) +} + +func (s *System_privilegeContext) SYSBACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSBACKUP, 0) +} + +func (s *System_privilegeContext) SYSDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDBA, 0) +} + +func (s *System_privilegeContext) SYSDG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDG, 0) +} + +func (s *System_privilegeContext) SYSKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSKM, 0) +} + +func (s *System_privilegeContext) SYSOPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOPER, 0) +} + +func (s *System_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_privilege(s) + } +} + +func (s *System_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_privilege(s) + } +} + +func (p *PlSqlParser) System_privilege() (localctx ISystem_privilegeContext) { + localctx = NewSystem_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2392, PlSqlParserRULE_system_privilege) + var _la int + + p.SetState(21191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2997, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20865) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20866) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20867) + p.Match(PlSqlParserADVISOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20868) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20869) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20872) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20873) + p.Match(PlSqlParserTUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20874) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20875) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20876) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20877) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20878) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20879) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20880) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20881) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20882) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20883) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20884) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20887) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20888) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20889) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20890) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20891) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20892) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20893) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20894) + p.Match(PlSqlParserEXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20895) + p.Match(PlSqlParserREDACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20896) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20897) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20898) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20899) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(20900) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20903) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20904) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20905) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20906) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20907) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20908) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20909) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20910) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20911) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(20912) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20913) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20914) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(20915) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20916) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20917) + p.Match(PlSqlParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(20918) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20919) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20922) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(20923) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20924) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20925) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(20926) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20927) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20928) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(20929) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20930) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20931) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(20932) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserARCHIVE: + { + p.SetState(20933) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20934) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserANY: + { + p.SetState(20935) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20936) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(20939) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20940) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20941) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(20942) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20943) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20946) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(20947) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20948) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20949) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(20950) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY || _la == PlSqlParserEXTERNAL { + { + p.SetState(20951) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserANY || _la == PlSqlParserEXTERNAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(20954) + p.Match(PlSqlParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(20955) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20956) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20957) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserPROGRAM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(20958) + p.Match(PlSqlParserMANAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20959) + p.Match(PlSqlParserSCHEDULER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(20960) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20961) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20962) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(20963) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20964) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20967) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(20968) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20969) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20970) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(20971) + p.Match(PlSqlParserLOGMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(20972) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20973) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20976) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20977) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(20978) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20979) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20980) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20981) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + p.SetState(20983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGLOBAL { + { + p.SetState(20982) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20985) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20986) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(20987) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20988) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20989) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(20990) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20991) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20994) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20995) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(20996) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCOMMENT || _la == PlSqlParserDROP || _la == PlSqlParserSELECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20997) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20998) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20999) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(21000) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21001) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21004) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(21005) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21006) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21007) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(21008) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21009) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21012) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21013) + p.Match(PlSqlParserFOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(21014) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21015) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21016) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21017) + p.Match(PlSqlParserFOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(21018) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21019) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21022) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21023) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(21024) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21025) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21026) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21027) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(21028) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21029) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21032) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21033) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21034) + p.Match(PlSqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(21035) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21036) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21037) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21038) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21039) + p.Match(PlSqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(21040) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21041) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21044) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(21045) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21046) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21047) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(21048) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21049) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21050) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(21051) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21052) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21053) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(21054) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21055) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(21056) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21057) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21060) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(21061) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21062) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21063) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(21064) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21065) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(21066) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21067) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(21068) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserGRANT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21069) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21070) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(21071) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21072) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21073) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(21074) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21075) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21078) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(21079) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserSELECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21080) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21081) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(21082) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21083) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(21084) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21085) + p.Match(PlSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21086) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(21087) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21088) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21091) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21092) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21093) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(21094) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserUSE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21095) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21096) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21097) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21098) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(21099) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21100) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21101) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(21102) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21103) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21106) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(21107) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21108) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21109) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(21110) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21111) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21112) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(21113) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21114) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21117) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(21118) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserBACKUP || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21119) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21120) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(21121) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP || _la == PlSqlParserMANAGE || _la == PlSqlParserUNLIMITED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21122) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(21123) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21124) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21127) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(21128) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21129) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21130) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(21131) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21132) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21133) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(21134) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21135) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21138) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(21139) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE || _la == PlSqlParserUNDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21140) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21141) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(21142) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21143) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(21144) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21145) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21148) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(21149) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserMERGE || _la == PlSqlParserUNDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21150) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21151) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(21152) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserANALYZE || _la == PlSqlParserAUDIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(21153) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(21154) + p.Match(PlSqlParserBECOME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21155) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(21156) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21157) + p.Match(PlSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(21158) + p.Match(PlSqlParserEXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21159) + p.Match(PlSqlParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21160) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(21161) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(21162) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21165) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(21166) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21167) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(21168) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(21171) + p.Match(PlSqlParserPRIVILEGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(21172) + p.Match(PlSqlParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21173) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21174) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(21175) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21176) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21177) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(21178) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21179) + p.Match(PlSqlParserSYSGUID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(21180) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21181) + p.Match(PlSqlParserDBA_RECYCLEBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(21182) + p.Match(PlSqlParserRESUMABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(21183) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21184) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21185) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDICTIONARY || _la == PlSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(21186) + p.Match(PlSqlParserSYSBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(21187) + p.Match(PlSqlParserSYSDBA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(21188) + p.Match(PlSqlParserSYSDG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(21189) + p.Match(PlSqlParserSYSKM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(21190) + p.Match(PlSqlParserSYSOPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIMESTAMP() antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + AllBind_variable() []IBind_variableContext + Bind_variable(i int) IBind_variableContext + AT() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + YEAR() antlr.TerminalNode + AllMONTH() []antlr.TerminalNode + MONTH(i int) antlr.TerminalNode + AllDAY() []antlr.TerminalNode + DAY(i int) antlr.TerminalNode + AllHOUR() []antlr.TerminalNode + HOUR(i int) antlr.TerminalNode + AllMINUTE() []antlr.TerminalNode + MINUTE(i int) antlr.TerminalNode + AllSECOND() []antlr.TerminalNode + SECOND(i int) antlr.TerminalNode + General_element_part() IGeneral_element_partContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + Numeric() INumericContext + DATE() antlr.TerminalNode + NULL_() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + DBTIMEZONE() antlr.TerminalNode + SESSIONTIMEZONE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *ConstantContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *ConstantContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *ConstantContext) AllBind_variable() []IBind_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBind_variableContext); ok { + len++ + } + } + + tst := make([]IBind_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBind_variableContext); ok { + tst[i] = t.(IBind_variableContext) + i++ + } + } + + return tst +} + +func (s *ConstantContext) Bind_variable(i int) IBind_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *ConstantContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *ConstantContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *ConstantContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *ConstantContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *ConstantContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *ConstantContext) AllMONTH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMONTH) +} + +func (s *ConstantContext) MONTH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, i) +} + +func (s *ConstantContext) AllDAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDAY) +} + +func (s *ConstantContext) DAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, i) +} + +func (s *ConstantContext) AllHOUR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHOUR) +} + +func (s *ConstantContext) HOUR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, i) +} + +func (s *ConstantContext) AllMINUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUTE) +} + +func (s *ConstantContext) MINUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, i) +} + +func (s *ConstantContext) AllSECOND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECOND) +} + +func (s *ConstantContext) SECOND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, i) +} + +func (s *ConstantContext) General_element_part() IGeneral_element_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *ConstantContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *ConstantContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *ConstantContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *ConstantContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *ConstantContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *ConstantContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *ConstantContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *ConstantContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *ConstantContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *ConstantContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *ConstantContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *ConstantContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *ConstantContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *ConstantContext) DBTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBTIMEZONE, 0) +} + +func (s *ConstantContext) SESSIONTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTIMEZONE, 0) +} + +func (s *ConstantContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *ConstantContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *ConstantContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstant(s) + } +} + +func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstant(s) + } +} + +func (p *PlSqlParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2394, PlSqlParserRULE_constant) + var _la int + + p.SetState(21256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21193) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(21194) + p.Quoted_string() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(21195) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(21202) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2999, p.GetParserRuleContext()) == 1 { + { + p.SetState(21198) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21199) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21200) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21201) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserINTERVAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(21204) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(21205) + p.Quoted_string() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(21206) + p.Bind_variable() + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(21207) + p.General_element_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(21210) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserHOUR || _la == PlSqlParserMINUTE || _la == PlSqlParserMONTH || _la == PlSqlParserSECOND || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(21224) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3004, p.GetParserRuleContext()) == 1 { + { + p.SetState(21211) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(21212) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(21213) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(21221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(21216) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(21217) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(21218) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(21223) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(21242) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3008, p.GetParserRuleContext()) == 1 { + { + p.SetState(21226) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMONTH: + { + p.SetState(21227) + p.Match(PlSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDAY: + { + p.SetState(21228) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHOUR: + { + p.SetState(21229) + p.Match(PlSqlParserHOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUTE: + { + p.SetState(21230) + p.Match(PlSqlParserMINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSECOND: + { + p.SetState(21231) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3006, p.GetParserRuleContext()) == 1 { + { + p.SetState(21232) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(21233) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(21234) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(21237) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(21244) + p.Numeric() + } + + case PlSqlParserDATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(21245) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21246) + p.Quoted_string() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(21247) + p.Quoted_string() + } + + case PlSqlParserNULL_: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(21248) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(21249) + p.Match(PlSqlParserTRUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFALSE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(21250) + p.Match(PlSqlParserFALSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDBTIMEZONE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(21251) + p.Match(PlSqlParserDBTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSESSIONTIMEZONE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(21252) + p.Match(PlSqlParserSESSIONTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(21253) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(21254) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(21255) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumericContext is an interface to support dynamic dispatch. +type INumericContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + PERIOD() antlr.TerminalNode + APPROXIMATE_NUM_LIT() antlr.TerminalNode + + // IsNumericContext differentiates from other interfaces. + IsNumericContext() +} + +type NumericContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumericContext() *NumericContext { + var p = new(NumericContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric + return p +} + +func InitEmptyNumericContext(p *NumericContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric +} + +func (*NumericContext) IsNumericContext() {} + +func NewNumericContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericContext { + var p = new(NumericContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric + + return p +} + +func (s *NumericContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumericContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *NumericContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *NumericContext) APPROXIMATE_NUM_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPROXIMATE_NUM_LIT, 0) +} + +func (s *NumericContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumericContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumericContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric(s) + } +} + +func (s *NumericContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric(s) + } +} + +func (p *PlSqlParser) Numeric() (localctx INumericContext) { + localctx = NewNumericContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2396, PlSqlParserRULE_numeric) + p.SetState(21263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21258) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(21260) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3010, p.GetParserRuleContext()) == 1 { + { + p.SetState(21259) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(21262) + p.Match(PlSqlParserAPPROXIMATE_NUM_LIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumeric_negativeContext is an interface to support dynamic dispatch. +type INumeric_negativeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINUS_SIGN() antlr.TerminalNode + Numeric() INumericContext + + // IsNumeric_negativeContext differentiates from other interfaces. + IsNumeric_negativeContext() +} + +type Numeric_negativeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_negativeContext() *Numeric_negativeContext { + var p = new(Numeric_negativeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_negative + return p +} + +func InitEmptyNumeric_negativeContext(p *Numeric_negativeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_negative +} + +func (*Numeric_negativeContext) IsNumeric_negativeContext() {} + +func NewNumeric_negativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_negativeContext { + var p = new(Numeric_negativeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_negative + + return p +} + +func (s *Numeric_negativeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_negativeContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *Numeric_negativeContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Numeric_negativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_negativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_negativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_negative(s) + } +} + +func (s *Numeric_negativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_negative(s) + } +} + +func (p *PlSqlParser) Numeric_negative() (localctx INumeric_negativeContext) { + localctx = NewNumeric_negativeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2398, PlSqlParserRULE_numeric_negative) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21265) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21266) + p.Numeric() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuoted_stringContext is an interface to support dynamic dispatch. +type IQuoted_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode + + // IsQuoted_stringContext differentiates from other interfaces. + IsQuoted_stringContext() +} + +type Quoted_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuoted_stringContext() *Quoted_stringContext { + var p = new(Quoted_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quoted_string + return p +} + +func InitEmptyQuoted_stringContext(p *Quoted_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quoted_string +} + +func (*Quoted_stringContext) IsQuoted_stringContext() {} + +func NewQuoted_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quoted_stringContext { + var p = new(Quoted_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quoted_string + + return p +} + +func (s *Quoted_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quoted_stringContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Quoted_stringContext) NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL_CHAR_STRING_LIT, 0) +} + +func (s *Quoted_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quoted_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quoted_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuoted_string(s) + } +} + +func (s *Quoted_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuoted_string(s) + } +} + +func (p *PlSqlParser) Quoted_string() (localctx IQuoted_stringContext) { + localctx = NewQuoted_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2400, PlSqlParserRULE_quoted_string) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21268) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNATIONAL_CHAR_STRING_LIT || _la == PlSqlParserCHAR_STRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identifier + return p +} + +func InitEmptyIdentifierContext(p *IdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identifier +} + +func (*IdentifierContext) IsIdentifierContext() {} + +func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { + var p = new(IdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *IdentifierContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *IdentifierContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (p *PlSqlParser) Identifier() (localctx IIdentifierContext) { + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2402, PlSqlParserRULE_identifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(21272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(21270) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21271) + p.Char_set_name() + } + + } + { + p.SetState(21274) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IId_expressionContext is an interface to support dynamic dispatch. +type IId_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + DELIMITED_ID() antlr.TerminalNode + + // IsId_expressionContext differentiates from other interfaces. + IsId_expressionContext() +} + +type Id_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyId_expressionContext() *Id_expressionContext { + var p = new(Id_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_id_expression + return p +} + +func InitEmptyId_expressionContext(p *Id_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_id_expression +} + +func (*Id_expressionContext) IsId_expressionContext() {} + +func NewId_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_expressionContext { + var p = new(Id_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_id_expression + + return p +} + +func (s *Id_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Id_expressionContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Id_expressionContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Id_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Id_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Id_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterId_expression(s) + } +} + +func (s *Id_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitId_expression(s) + } +} + +func (p *PlSqlParser) Id_expression() (localctx IId_expressionContext) { + localctx = NewId_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2404, PlSqlParserRULE_id_expression) + p.SetState(21278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCESSIBLE, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUDIT, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserBYTES, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_FORMAT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBLINK, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECLARE, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPRECATE, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY_, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLED, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserERROR_INDEX, PlSqlParserERROR_CODE, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFIELD, PlSqlParserFIELDS, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINTERNAL, PlSqlParserINVALIDATE, PlSqlParserINVALIDATION, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITEMS, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINES, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASK, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN_, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEWLINE_, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORC, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW_, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDE, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITION, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSEQ, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPLATE_TABLE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUDF, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING_NLS_COMP, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserCHARSETID, PlSqlParserCHARSETFORM, PlSqlParserDURATION, PlSqlParserEXTEND, PlSqlParserMAXLEN, PlSqlParserPERSISTABLE, PlSqlParserPOLYMORPHIC, PlSqlParserSTRUCT, PlSqlParserTDO, PlSqlParserWM_CONCAT, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21276) + p.Regular_id() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(21277) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInquiry_directiveContext is an interface to support dynamic dispatch. +type IInquiry_directiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INQUIRY_DIRECTIVE() antlr.TerminalNode + + // IsInquiry_directiveContext differentiates from other interfaces. + IsInquiry_directiveContext() +} + +type Inquiry_directiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInquiry_directiveContext() *Inquiry_directiveContext { + var p = new(Inquiry_directiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inquiry_directive + return p +} + +func InitEmptyInquiry_directiveContext(p *Inquiry_directiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inquiry_directive +} + +func (*Inquiry_directiveContext) IsInquiry_directiveContext() {} + +func NewInquiry_directiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inquiry_directiveContext { + var p = new(Inquiry_directiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inquiry_directive + + return p +} + +func (s *Inquiry_directiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inquiry_directiveContext) INQUIRY_DIRECTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINQUIRY_DIRECTIVE, 0) +} + +func (s *Inquiry_directiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inquiry_directiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inquiry_directiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInquiry_directive(s) + } +} + +func (s *Inquiry_directiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInquiry_directive(s) + } +} + +func (p *PlSqlParser) Inquiry_directive() (localctx IInquiry_directiveContext) { + localctx = NewInquiry_directiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2406, PlSqlParserRULE_inquiry_directive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21280) + p.Match(PlSqlParserINQUIRY_DIRECTIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOuter_join_signContext is an interface to support dynamic dispatch. +type IOuter_join_signContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsOuter_join_signContext differentiates from other interfaces. + IsOuter_join_signContext() +} + +type Outer_join_signContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOuter_join_signContext() *Outer_join_signContext { + var p = new(Outer_join_signContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_sign + return p +} + +func InitEmptyOuter_join_signContext(p *Outer_join_signContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_sign +} + +func (*Outer_join_signContext) IsOuter_join_signContext() {} + +func NewOuter_join_signContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outer_join_signContext { + var p = new(Outer_join_signContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outer_join_sign + + return p +} + +func (s *Outer_join_signContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outer_join_signContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Outer_join_signContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *Outer_join_signContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Outer_join_signContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outer_join_signContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outer_join_signContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOuter_join_sign(s) + } +} + +func (s *Outer_join_signContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOuter_join_sign(s) + } +} + +func (p *PlSqlParser) Outer_join_sign() (localctx IOuter_join_signContext) { + localctx = NewOuter_join_signContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2408, PlSqlParserRULE_outer_join_sign) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21282) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21283) + p.Match(PlSqlParserPLUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(21284) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRegular_idContext is an interface to support dynamic dispatch. +type IRegular_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Non_reserved_keywords_pre12c() INon_reserved_keywords_pre12cContext + Non_reserved_keywords_in_12c() INon_reserved_keywords_in_12cContext + Non_reserved_keywords_in_18c() INon_reserved_keywords_in_18cContext + REGULAR_ID() antlr.TerminalNode + AUDIT() antlr.TerminalNode + ITEMS() antlr.TerminalNode + BYTES() antlr.TerminalNode + LINES() antlr.TerminalNode + RECORDS() antlr.TerminalNode + NEWLINE_() antlr.TerminalNode + FIELD() antlr.TerminalNode + MASK() antlr.TerminalNode + ABSENT() antlr.TerminalNode + A_LETTER() antlr.TerminalNode + AGENT() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + AUTONOMOUS_TRANSACTION() antlr.TerminalNode + BACKINGFILE() antlr.TerminalNode + BATCH() antlr.TerminalNode + BINARY_INTEGER() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + C_LETTER() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARSETID() antlr.TerminalNode + CHARSETFORM() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONSTRUCTOR() antlr.TerminalNode + CUSTOMDATUM() antlr.TerminalNode + CASESENSITIVE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DELETE() antlr.TerminalNode + DEPRECATE() antlr.TerminalNode + DETERMINISTIC() antlr.TerminalNode + DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode + DURATION() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + ENABLED() antlr.TerminalNode + ERROR_INDEX() antlr.TerminalNode + ERROR_CODE() antlr.TerminalNode + ERR() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + EXCEPTION_INIT() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + EXISTS() antlr.TerminalNode + EXIT() antlr.TerminalNode + EXTEND() antlr.TerminalNode + FIELDS() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + FLOAT() antlr.TerminalNode + FORALL() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + INDICES() antlr.TerminalNode + INOUT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + INTERNAL() antlr.TerminalNode + JSON_TRANSFORM() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LONG() antlr.TerminalNode + LOOP() antlr.TerminalNode + MAXLEN() antlr.TerminalNode + MOUNTPOINT() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + MISSING() antlr.TerminalNode + MISMATCH() antlr.TerminalNode + NUMBER() antlr.TerminalNode + ORADATA() antlr.TerminalNode + ORC() antlr.TerminalNode + OSERROR() antlr.TerminalNode + OUT() antlr.TerminalNode + OVERRIDING() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + PARALLEL_ENABLE() antlr.TerminalNode + PIPELINED() antlr.TerminalNode + PLS_INTEGER() antlr.TerminalNode + PMEM() antlr.TerminalNode + POSITIVE() antlr.TerminalNode + POSITIVEN() antlr.TerminalNode + PRAGMA() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + RAISE() antlr.TerminalNode + RAW() antlr.TerminalNode + RECORD() antlr.TerminalNode + REF() antlr.TerminalNode + RENAME() antlr.TerminalNode + RESTRICT_REFERENCES() antlr.TerminalNode + RESULT() antlr.TerminalNode + SDO_GEOMETRY() antlr.TerminalNode + SELF() antlr.TerminalNode + SERIALLY_REUSABLE() antlr.TerminalNode + SET() antlr.TerminalNode + SEQ() antlr.TerminalNode + SHARDSPACE() antlr.TerminalNode + SIGNTYPE() antlr.TerminalNode + SIMPLE_INTEGER() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + STRUCT() antlr.TerminalNode + SQLDATA() antlr.TerminalNode + SQLERROR() antlr.TerminalNode + SUBTYPE() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + TDO() antlr.TerminalNode + TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + UDF() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + WARNING() antlr.TerminalNode + WHILE() antlr.TerminalNode + WM_CONCAT() antlr.TerminalNode + XMLAGG() antlr.TerminalNode + YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode + REGR_() antlr.TerminalNode + VAR_() antlr.TerminalNode + VALUE() antlr.TerminalNode + COVAR_() antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + + // IsRegular_idContext differentiates from other interfaces. + IsRegular_idContext() +} + +type Regular_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegular_idContext() *Regular_idContext { + var p = new(Regular_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_regular_id + return p +} + +func InitEmptyRegular_idContext(p *Regular_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_regular_id +} + +func (*Regular_idContext) IsRegular_idContext() {} + +func NewRegular_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Regular_idContext { + var p = new(Regular_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_regular_id + + return p +} + +func (s *Regular_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Regular_idContext) Non_reserved_keywords_pre12c() INon_reserved_keywords_pre12cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_keywords_pre12cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_keywords_pre12cContext) +} + +func (s *Regular_idContext) Non_reserved_keywords_in_12c() INon_reserved_keywords_in_12cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_keywords_in_12cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_keywords_in_12cContext) +} + +func (s *Regular_idContext) Non_reserved_keywords_in_18c() INon_reserved_keywords_in_18cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_keywords_in_18cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_keywords_in_18cContext) +} + +func (s *Regular_idContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Regular_idContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Regular_idContext) ITEMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserITEMS, 0) +} + +func (s *Regular_idContext) BYTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTES, 0) +} + +func (s *Regular_idContext) LINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINES, 0) +} + +func (s *Regular_idContext) RECORDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS, 0) +} + +func (s *Regular_idContext) NEWLINE_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEWLINE_, 0) +} + +func (s *Regular_idContext) FIELD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD, 0) +} + +func (s *Regular_idContext) MASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASK, 0) +} + +func (s *Regular_idContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Regular_idContext) A_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserA_LETTER, 0) +} + +func (s *Regular_idContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *Regular_idContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Regular_idContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Regular_idContext) AUTONOMOUS_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTONOMOUS_TRANSACTION, 0) +} + +func (s *Regular_idContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Regular_idContext) BATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, 0) +} + +func (s *Regular_idContext) BINARY_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_INTEGER, 0) +} + +func (s *Regular_idContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOOLEAN, 0) +} + +func (s *Regular_idContext) C_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserC_LETTER, 0) +} + +func (s *Regular_idContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Regular_idContext) CHARSETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARSETID, 0) +} + +func (s *Regular_idContext) CHARSETFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARSETFORM, 0) +} + +func (s *Regular_idContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Regular_idContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Regular_idContext) CUSTOMDATUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUSTOMDATUM, 0) +} + +func (s *Regular_idContext) CASESENSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASESENSITIVE, 0) +} + +func (s *Regular_idContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *Regular_idContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Regular_idContext) DEPRECATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPRECATE, 0) +} + +func (s *Regular_idContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, 0) +} + +func (s *Regular_idContext) DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDSINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) DURATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDURATION, 0) +} + +func (s *Regular_idContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Regular_idContext) ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLED, 0) +} + +func (s *Regular_idContext) ERROR_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_INDEX, 0) +} + +func (s *Regular_idContext) ERROR_CODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_CODE, 0) +} + +func (s *Regular_idContext) ERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERR, 0) +} + +func (s *Regular_idContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Regular_idContext) EXCEPTION_INIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION_INIT, 0) +} + +func (s *Regular_idContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Regular_idContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Regular_idContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Regular_idContext) EXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTEND, 0) +} + +func (s *Regular_idContext) FIELDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, 0) +} + +func (s *Regular_idContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Regular_idContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *Regular_idContext) FORALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORALL, 0) +} + +func (s *Regular_idContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Regular_idContext) INDICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICES, 0) +} + +func (s *Regular_idContext) INOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINOUT, 0) +} + +func (s *Regular_idContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *Regular_idContext) INTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL, 0) +} + +func (s *Regular_idContext) JSON_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TRANSFORM, 0) +} + +func (s *Regular_idContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Regular_idContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Regular_idContext) LONG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLONG, 0) +} + +func (s *Regular_idContext) LOOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOOP, 0) +} + +func (s *Regular_idContext) MAXLEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLEN, 0) +} + +func (s *Regular_idContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Regular_idContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Regular_idContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Regular_idContext) MISMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISMATCH, 0) +} + +func (s *Regular_idContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Regular_idContext) ORADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADATA, 0) +} + +func (s *Regular_idContext) ORC() antlr.TerminalNode { + return s.GetToken(PlSqlParserORC, 0) +} + +func (s *Regular_idContext) OSERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOSERROR, 0) +} + +func (s *Regular_idContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Regular_idContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Regular_idContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Regular_idContext) PARALLEL_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, 0) +} + +func (s *Regular_idContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Regular_idContext) PLS_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLS_INTEGER, 0) +} + +func (s *Regular_idContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Regular_idContext) POSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVE, 0) +} + +func (s *Regular_idContext) POSITIVEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVEN, 0) +} + +func (s *Regular_idContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Regular_idContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Regular_idContext) RAISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAISE, 0) +} + +func (s *Regular_idContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *Regular_idContext) RECORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORD, 0) +} + +func (s *Regular_idContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Regular_idContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Regular_idContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Regular_idContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Regular_idContext) SDO_GEOMETRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOMETRY, 0) +} + +func (s *Regular_idContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Regular_idContext) SERIALLY_REUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALLY_REUSABLE, 0) +} + +func (s *Regular_idContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Regular_idContext) SEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQ, 0) +} + +func (s *Regular_idContext) SHARDSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDSPACE, 0) +} + +func (s *Regular_idContext) SIGNTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNTYPE, 0) +} + +func (s *Regular_idContext) SIMPLE_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE_INTEGER, 0) +} + +func (s *Regular_idContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLINT, 0) +} + +func (s *Regular_idContext) STRUCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCT, 0) +} + +func (s *Regular_idContext) SQLDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLDATA, 0) +} + +func (s *Regular_idContext) SQLERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLERROR, 0) +} + +func (s *Regular_idContext) SUBTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBTYPE, 0) +} + +func (s *Regular_idContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Regular_idContext) TDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTDO, 0) +} + +func (s *Regular_idContext) TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Regular_idContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Regular_idContext) UDF() antlr.TerminalNode { + return s.GetToken(PlSqlParserUDF, 0) +} + +func (s *Regular_idContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *Regular_idContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Regular_idContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *Regular_idContext) WARNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserWARNING, 0) +} + +func (s *Regular_idContext) WHILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHILE, 0) +} + +func (s *Regular_idContext) WM_CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWM_CONCAT, 0) +} + +func (s *Regular_idContext) XMLAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLAGG, 0) +} + +func (s *Regular_idContext) YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserYMINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) REGR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_, 0) +} + +func (s *Regular_idContext) VAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_, 0) +} + +func (s *Regular_idContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Regular_idContext) COVAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_, 0) +} + +func (s *Regular_idContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_FORMAT, 0) +} + +func (s *Regular_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Regular_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Regular_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRegular_id(s) + } +} + +func (s *Regular_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRegular_id(s) + } +} + +func (p *PlSqlParser) Regular_id() (localctx IRegular_idContext) { + localctx = NewRegular_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2410, PlSqlParserRULE_regular_id) + p.SetState(21408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3014, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21286) + p.Non_reserved_keywords_pre12c() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(21287) + p.Non_reserved_keywords_in_12c() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(21288) + p.Non_reserved_keywords_in_18c() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(21289) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(21290) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(21291) + p.Match(PlSqlParserITEMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(21292) + p.Match(PlSqlParserBYTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(21293) + p.Match(PlSqlParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(21294) + p.Match(PlSqlParserRECORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(21295) + p.Match(PlSqlParserNEWLINE_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(21296) + p.Match(PlSqlParserFIELD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(21297) + p.Match(PlSqlParserMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(21298) + p.Match(PlSqlParserABSENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(21299) + p.Match(PlSqlParserA_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(21300) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(21301) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(21302) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(21303) + p.Match(PlSqlParserAUTONOMOUS_TRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(21304) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(21305) + p.Match(PlSqlParserBATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(21306) + p.Match(PlSqlParserBINARY_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(21307) + p.Match(PlSqlParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(21308) + p.Match(PlSqlParserC_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(21309) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(21310) + p.Match(PlSqlParserCHARSETID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(21311) + p.Match(PlSqlParserCHARSETFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(21312) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(21313) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(21314) + p.Match(PlSqlParserCUSTOMDATUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(21315) + p.Match(PlSqlParserCASESENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(21316) + p.Match(PlSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(21317) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(21318) + p.Match(PlSqlParserDEPRECATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(21319) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(21320) + p.Match(PlSqlParserDSINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(21321) + p.Match(PlSqlParserDURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(21322) + p.Match(PlSqlParserE_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(21323) + p.Match(PlSqlParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(21324) + p.Match(PlSqlParserERROR_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(21325) + p.Match(PlSqlParserERROR_CODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(21326) + p.Match(PlSqlParserERR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(21327) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(21328) + p.Match(PlSqlParserEXCEPTION_INIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(21329) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(21330) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(21331) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(21332) + p.Match(PlSqlParserEXTEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(21333) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(21334) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(21335) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(21336) + p.Match(PlSqlParserFORALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(21337) + p.Match(PlSqlParserG_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(21338) + p.Match(PlSqlParserINDICES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(21339) + p.Match(PlSqlParserINOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(21340) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(21341) + p.Match(PlSqlParserINTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(21342) + p.Match(PlSqlParserJSON_TRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(21343) + p.Match(PlSqlParserK_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(21344) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(21345) + p.Match(PlSqlParserLONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(21346) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(21347) + p.Match(PlSqlParserMAXLEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(21348) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(21349) + p.Match(PlSqlParserM_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(21350) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(21351) + p.Match(PlSqlParserMISMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(21352) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(21353) + p.Match(PlSqlParserORADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(21354) + p.Match(PlSqlParserORC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(21355) + p.Match(PlSqlParserOSERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(21356) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(21357) + p.Match(PlSqlParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(21358) + p.Match(PlSqlParserP_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(21359) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(21360) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(21361) + p.Match(PlSqlParserPLS_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(21362) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(21363) + p.Match(PlSqlParserPOSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(21364) + p.Match(PlSqlParserPOSITIVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(21365) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(21366) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(21367) + p.Match(PlSqlParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(21368) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(21369) + p.Match(PlSqlParserRECORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(21370) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(21371) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(21372) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(21373) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(21374) + p.Match(PlSqlParserSDO_GEOMETRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(21375) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(21376) + p.Match(PlSqlParserSERIALLY_REUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(21377) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(21378) + p.Match(PlSqlParserSEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(21379) + p.Match(PlSqlParserSHARDSPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 95: + p.EnterOuterAlt(localctx, 95) + { + p.SetState(21380) + p.Match(PlSqlParserSIGNTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 96: + p.EnterOuterAlt(localctx, 96) + { + p.SetState(21381) + p.Match(PlSqlParserSIMPLE_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 97: + p.EnterOuterAlt(localctx, 97) + { + p.SetState(21382) + p.Match(PlSqlParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 98: + p.EnterOuterAlt(localctx, 98) + { + p.SetState(21383) + p.Match(PlSqlParserSTRUCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 99: + p.EnterOuterAlt(localctx, 99) + { + p.SetState(21384) + p.Match(PlSqlParserSQLDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 100: + p.EnterOuterAlt(localctx, 100) + { + p.SetState(21385) + p.Match(PlSqlParserSQLERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 101: + p.EnterOuterAlt(localctx, 101) + { + p.SetState(21386) + p.Match(PlSqlParserSUBTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 102: + p.EnterOuterAlt(localctx, 102) + { + p.SetState(21387) + p.Match(PlSqlParserT_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 103: + p.EnterOuterAlt(localctx, 103) + { + p.SetState(21388) + p.Match(PlSqlParserTDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 104: + p.EnterOuterAlt(localctx, 104) + { + p.SetState(21389) + p.Match(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 105: + p.EnterOuterAlt(localctx, 105) + { + p.SetState(21390) + p.Match(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 106: + p.EnterOuterAlt(localctx, 106) + { + p.SetState(21391) + p.Match(PlSqlParserTIMESTAMP_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 107: + p.EnterOuterAlt(localctx, 107) + { + p.SetState(21392) + p.Match(PlSqlParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 108: + p.EnterOuterAlt(localctx, 108) + { + p.SetState(21393) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 109: + p.EnterOuterAlt(localctx, 109) + { + p.SetState(21394) + p.Match(PlSqlParserUDF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 110: + p.EnterOuterAlt(localctx, 110) + { + p.SetState(21395) + p.Match(PlSqlParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 111: + p.EnterOuterAlt(localctx, 111) + { + p.SetState(21396) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 112: + p.EnterOuterAlt(localctx, 112) + { + p.SetState(21397) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 113: + p.EnterOuterAlt(localctx, 113) + { + p.SetState(21398) + p.Match(PlSqlParserWARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 114: + p.EnterOuterAlt(localctx, 114) + { + p.SetState(21399) + p.Match(PlSqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 115: + p.EnterOuterAlt(localctx, 115) + { + p.SetState(21400) + p.Match(PlSqlParserWM_CONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 116: + p.EnterOuterAlt(localctx, 116) + { + p.SetState(21401) + p.Match(PlSqlParserXMLAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 117: + p.EnterOuterAlt(localctx, 117) + { + p.SetState(21402) + p.Match(PlSqlParserYMINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 118: + p.EnterOuterAlt(localctx, 118) + { + p.SetState(21403) + p.Match(PlSqlParserREGR_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 119: + p.EnterOuterAlt(localctx, 119) + { + p.SetState(21404) + p.Match(PlSqlParserVAR_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 120: + p.EnterOuterAlt(localctx, 120) + { + p.SetState(21405) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 121: + p.EnterOuterAlt(localctx, 121) + { + p.SetState(21406) + p.Match(PlSqlParserCOVAR_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 122: + p.EnterOuterAlt(localctx, 122) + { + p.SetState(21407) + p.Match(PlSqlParserDATE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INon_reserved_keywords_in_18cContext is an interface to support dynamic dispatch. +type INon_reserved_keywords_in_18cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PERSISTABLE() antlr.TerminalNode + POLYMORPHIC() antlr.TerminalNode + + // IsNon_reserved_keywords_in_18cContext differentiates from other interfaces. + IsNon_reserved_keywords_in_18cContext() +} + +type Non_reserved_keywords_in_18cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_keywords_in_18cContext() *Non_reserved_keywords_in_18cContext { + var p = new(Non_reserved_keywords_in_18cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_18c + return p +} + +func InitEmptyNon_reserved_keywords_in_18cContext(p *Non_reserved_keywords_in_18cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_18c +} + +func (*Non_reserved_keywords_in_18cContext) IsNon_reserved_keywords_in_18cContext() {} + +func NewNon_reserved_keywords_in_18cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_keywords_in_18cContext { + var p = new(Non_reserved_keywords_in_18cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_18c + + return p +} + +func (s *Non_reserved_keywords_in_18cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_keywords_in_18cContext) PERSISTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERSISTABLE, 0) +} + +func (s *Non_reserved_keywords_in_18cContext) POLYMORPHIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLYMORPHIC, 0) +} + +func (s *Non_reserved_keywords_in_18cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_keywords_in_18cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_keywords_in_18cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_reserved_keywords_in_18c(s) + } +} + +func (s *Non_reserved_keywords_in_18cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_reserved_keywords_in_18c(s) + } +} + +func (p *PlSqlParser) Non_reserved_keywords_in_18c() (localctx INon_reserved_keywords_in_18cContext) { + localctx = NewNon_reserved_keywords_in_18cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2412, PlSqlParserRULE_non_reserved_keywords_in_18c) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21410) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPERSISTABLE || _la == PlSqlParserPOLYMORPHIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INon_reserved_keywords_in_12cContext is an interface to support dynamic dispatch. +type INon_reserved_keywords_in_12cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACL() antlr.TerminalNode + ACCESSIBLE() antlr.TerminalNode + ACROSS() antlr.TerminalNode + ACTION() antlr.TerminalNode + ACTIONS() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ACTIVE_DATA() antlr.TerminalNode + ACTIVITY() antlr.TerminalNode + ADAPTIVE_PLAN() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + AFD_DISKSTRING() antlr.TerminalNode + ALTERNATE() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + ANCESTOR() antlr.TerminalNode + ANOMALY() antlr.TerminalNode + ANSI_REARCH() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + APPROX_COUNT_DISTINCT() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + ARCHIVED() antlr.TerminalNode + ASIS() antlr.TerminalNode + ASSIGN() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + AUTO_REOPTIMIZE() antlr.TerminalNode + AVRO() antlr.TerminalNode + BACKGROUND() antlr.TerminalNode + BACKUPS() antlr.TerminalNode + BATCHSIZE() antlr.TerminalNode + BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode + BEGINNING() antlr.TerminalNode + BEQUEATH() antlr.TerminalNode + BITMAP_AND() antlr.TerminalNode + BLOCKCHAIN() antlr.TerminalNode + BSON() antlr.TerminalNode + CACHING() antlr.TerminalNode + CALCULATED() antlr.TerminalNode + CALLBACK() antlr.TerminalNode + CAPACITY() antlr.TerminalNode + CAPTION() antlr.TerminalNode + CDBDEFAULT() antlr.TerminalNode + CLASSIFICATION() antlr.TerminalNode + CLASSIFIER() antlr.TerminalNode + CLAUSE() antlr.TerminalNode + CLEAN() antlr.TerminalNode + CLEANUP() antlr.TerminalNode + CLIENT() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + CLUSTER_DETAILS() antlr.TerminalNode + CLUSTER_DISTANCE() antlr.TerminalNode + COLLATE() antlr.TerminalNode + COLLATION() antlr.TerminalNode + COMMON() antlr.TerminalNode + COMMON_DATA() antlr.TerminalNode + COMPONENT() antlr.TerminalNode + COMPONENTS() antlr.TerminalNode + CONDITION() antlr.TerminalNode + CONDITIONAL() antlr.TerminalNode + CONTAINERS() antlr.TerminalNode + CONTAINERS_DEFAULT() antlr.TerminalNode + CONTAINER_DATA() antlr.TerminalNode + CONTAINER_MAP() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + CON_DBID_TO_ID() antlr.TerminalNode + CON_GUID_TO_ID() antlr.TerminalNode + CON_ID() antlr.TerminalNode + CON_NAME_TO_ID() antlr.TerminalNode + CON_UID_TO_ID() antlr.TerminalNode + COOKIE() antlr.TerminalNode + COPY() antlr.TerminalNode + CREATE_FILE_DEST() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + CRITICAL() antlr.TerminalNode + CUBE_AJ() antlr.TerminalNode + CUBE_SJ() antlr.TerminalNode + DATAMOVEMENT() antlr.TerminalNode + DATAOBJ_TO_MAT_PARTITION() antlr.TerminalNode + DATAPUMP() antlr.TerminalNode + DATA_SECURITY_REWRITE_LIMIT() antlr.TerminalNode + DAYS() antlr.TerminalNode + DB_UNIQUE_NAME() antlr.TerminalNode + DECORRELATE() antlr.TerminalNode + DEFAULT_CREDENTIAL() antlr.TerminalNode + DEFAULT_COLLATION() antlr.TerminalNode + DEFINE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + DELEGATE() antlr.TerminalNode + DELETE_ALL() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + DESTROY() antlr.TerminalNode + DIMENSIONS() antlr.TerminalNode + DISABLE_ALL() antlr.TerminalNode + DISABLE_PARALLEL_DML() antlr.TerminalNode + DISCARD() antlr.TerminalNode + DISTRIBUTE() antlr.TerminalNode + DUPLICATE() antlr.TerminalNode + DUPLICATED() antlr.TerminalNode + DV() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + ELIM_GROUPBY() antlr.TerminalNode + EM() antlr.TerminalNode + ENABLE_ALL() antlr.TerminalNode + ENABLE_PARALLEL_DML() antlr.TerminalNode + EQUIPART() antlr.TerminalNode + EVAL() antlr.TerminalNode + EVALUATE() antlr.TerminalNode + EXISTING() antlr.TerminalNode + EXPRESS() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + EXTRACTCLOBXML() antlr.TerminalNode + FACTOR() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + FAILURE() antlr.TerminalNode + FAMILY() antlr.TerminalNode + FAR() antlr.TerminalNode + FASTSTART() antlr.TerminalNode + FEATURE() antlr.TerminalNode + FEATURE_DETAILS() antlr.TerminalNode + FETCH() antlr.TerminalNode + FILE_NAME_CONVERT() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + FIXED_VIEW_DATA() antlr.TerminalNode + FLEX() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FTP() antlr.TerminalNode + GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode + GET() antlr.TerminalNode + HALF_YEARS() antlr.TerminalNode + HASHING() antlr.TerminalNode + HIER_ORDER() antlr.TerminalNode + HIERARCHICAL() antlr.TerminalNode + HOURS() antlr.TerminalNode + HTTP() antlr.TerminalNode + H_LETTER() antlr.TerminalNode + IDLE() antlr.TerminalNode + ILM() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + INACTIVE() antlr.TerminalNode + INACTIVE_ACCOUNT_TIME() antlr.TerminalNode + INDEXING() antlr.TerminalNode + INHERIT() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + INMEMORY_PRUNING() antlr.TerminalNode + INPLACE() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + INVALIDATION() antlr.TerminalNode + ISOLATE() antlr.TerminalNode + IS_LEAF() antlr.TerminalNode + JSON() antlr.TerminalNode + JSONGET() antlr.TerminalNode + JSONPARSE() antlr.TerminalNode + JSON_ARRAY() antlr.TerminalNode + JSON_ARRAYAGG() antlr.TerminalNode + JSON_EQUAL() antlr.TerminalNode + JSON_EXISTS() antlr.TerminalNode + JSON_EXISTS2() antlr.TerminalNode + JSON_OBJECT() antlr.TerminalNode + JSON_OBJECTAGG() antlr.TerminalNode + JSON_QUERY() antlr.TerminalNode + JSON_SERIALIZE() antlr.TerminalNode + JSON_TABLE() antlr.TerminalNode + JSON_TEXTCONTAINS() antlr.TerminalNode + JSON_TEXTCONTAINS2() antlr.TerminalNode + JSON_VALUE() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + LABEL() antlr.TerminalNode + LAX() antlr.TerminalNode + LEAD_CDB() antlr.TerminalNode + LEAD_CDB_URI() antlr.TerminalNode + LEVEL_NAME() antlr.TerminalNode + LIFECYCLE() antlr.TerminalNode + LINEAR() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + LOCKING() antlr.TerminalNode + LOGMINING() antlr.TerminalNode + LOST() antlr.TerminalNode + MANDATORY() antlr.TerminalNode + MAP() antlr.TerminalNode + MATCH() antlr.TerminalNode + MATCHES() antlr.TerminalNode + MATCH_NUMBER() antlr.TerminalNode + MATCH_RECOGNIZE() antlr.TerminalNode + MAX_SHARED_TEMP_SIZE() antlr.TerminalNode + MEMCOMPRESS() antlr.TerminalNode + METADATA() antlr.TerminalNode + MEMBER_CAPTION() antlr.TerminalNode + MEMBER_DESCRIPTION() antlr.TerminalNode + MEMBER_NAME() antlr.TerminalNode + MEMBER_UNIQUE_NAME() antlr.TerminalNode + MEMOPTIMIZE() antlr.TerminalNode + MINUTES() antlr.TerminalNode + MODEL_NB() antlr.TerminalNode + MODEL_SV() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + MODULE() antlr.TerminalNode + MONTHS() antlr.TerminalNode + MULTIDIMENSIONAL() antlr.TerminalNode + NEG() antlr.TerminalNode + NOCOPY() antlr.TerminalNode + NOKEEP() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + NOPARTITION() antlr.TerminalNode + NORELOCATE() antlr.TerminalNode + NOREPLAY() antlr.TerminalNode + NO_ADAPTIVE_PLAN() antlr.TerminalNode + NO_ANSI_REARCH() antlr.TerminalNode + NO_AUTO_REOPTIMIZE() antlr.TerminalNode + NO_BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode + NO_CLUSTERING() antlr.TerminalNode + NO_COMMON_DATA() antlr.TerminalNode + NO_DATA_SECURITY_REWRITE() antlr.TerminalNode + NO_DECORRELATE() antlr.TerminalNode + NO_ELIM_GROUPBY() antlr.TerminalNode + NO_GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode + NO_INMEMORY() antlr.TerminalNode + NO_INMEMORY_PRUNING() antlr.TerminalNode + NO_OBJECT_LINK() antlr.TerminalNode + NO_PARTIAL_JOIN() antlr.TerminalNode + NO_PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode + NO_PQ_CONCURRENT_UNION() antlr.TerminalNode + NO_PQ_REPLICATE() antlr.TerminalNode + NO_PQ_SKEW() antlr.TerminalNode + NOPROMPT() antlr.TerminalNode + NO_PX_FAULT_TOLERANCE() antlr.TerminalNode + NO_ROOT_SW_FOR_LOCAL() antlr.TerminalNode + NO_SQL_TRANSLATION() antlr.TerminalNode + NO_USE_CUBE() antlr.TerminalNode + NO_USE_VECTOR_AGGREGATION() antlr.TerminalNode + NO_VECTOR_TRANSFORM() antlr.TerminalNode + NO_VECTOR_TRANSFORM_DIMS() antlr.TerminalNode + NO_VECTOR_TRANSFORM_FACT() antlr.TerminalNode + NO_ZONEMAP() antlr.TerminalNode + OBJ_ID() antlr.TerminalNode + OFFSET() antlr.TerminalNode + OLS() antlr.TerminalNode + OMIT() antlr.TerminalNode + ONE() antlr.TerminalNode + ORACLE_DATAPUMP() antlr.TerminalNode + ORACLE_HDFS() antlr.TerminalNode + ORACLE_HIVE() antlr.TerminalNode + ORACLE_LOADER() antlr.TerminalNode + ORA_CHECK_ACL() antlr.TerminalNode + ORA_CHECK_PRIVILEGE() antlr.TerminalNode + ORA_CLUSTERING() antlr.TerminalNode + ORA_INVOKING_USER() antlr.TerminalNode + ORA_INVOKING_USERID() antlr.TerminalNode + ORA_INVOKING_XS_USER() antlr.TerminalNode + ORA_INVOKING_XS_USER_GUID() antlr.TerminalNode + ORA_RAWCOMPARE() antlr.TerminalNode + ORA_RAWCONCAT() antlr.TerminalNode + ORA_WRITE_TIME() antlr.TerminalNode + PARENT_LEVEL_NAME() antlr.TerminalNode + PARENT_UNIQUE_NAME() antlr.TerminalNode + PASSWORD_ROLLOVER_TIME() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PARTIAL_JOIN() antlr.TerminalNode + PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode + PAST() antlr.TerminalNode + PATCH() antlr.TerminalNode + PATH_PREFIX() antlr.TerminalNode + PATTERN() antlr.TerminalNode + PER() antlr.TerminalNode + PERIOD() antlr.TerminalNode + PERIOD_KEYWORD() antlr.TerminalNode + PERMUTE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + POOL_16K() antlr.TerminalNode + POOL_2K() antlr.TerminalNode + POOL_32K() antlr.TerminalNode + POOL_4K() antlr.TerminalNode + POOL_8K() antlr.TerminalNode + PQ_CONCURRENT_UNION() antlr.TerminalNode + PQ_DISTRIBUTE_WINDOW() antlr.TerminalNode + PQ_FILTER() antlr.TerminalNode + PQ_REPLICATE() antlr.TerminalNode + PQ_SKEW() antlr.TerminalNode + PRELOAD() antlr.TerminalNode + PRETTY() antlr.TerminalNode + PREV() antlr.TerminalNode + PRINTBLOBTOCLOB() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + PRIVILEGED() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + PROTOCOL() antlr.TerminalNode + PROXY() antlr.TerminalNode + PRUNING() antlr.TerminalNode + PX_FAULT_TOLERANCE() antlr.TerminalNode + QUARTERS() antlr.TerminalNode + QUOTAGROUP() antlr.TerminalNode + REALM() antlr.TerminalNode + REDEFINE() antlr.TerminalNode + RELOCATE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + RESTART() antlr.TerminalNode + ROLESET() antlr.TerminalNode + ROWID_MAPPING_TABLE() antlr.TerminalNode + RUNNING() antlr.TerminalNode + SAVE() antlr.TerminalNode + SCRUB() antlr.TerminalNode + SDO_GEOM_MBR() antlr.TerminalNode + SECONDS() antlr.TerminalNode + SECRET() antlr.TerminalNode + SERIAL() antlr.TerminalNode + SERVICES() antlr.TerminalNode + SERVICE_NAME_CONVERT() antlr.TerminalNode + SHARDED() antlr.TerminalNode + SHARING() antlr.TerminalNode + SHELFLIFE() antlr.TerminalNode + SITE() antlr.TerminalNode + SOURCE_FILE_DIRECTORY() antlr.TerminalNode + SOURCE_FILE_NAME_CONVERT() antlr.TerminalNode + SQL_TRANSLATION_PROFILE() antlr.TerminalNode + STANDARD() antlr.TerminalNode + STANDARD_HASH() antlr.TerminalNode + STANDBYS() antlr.TerminalNode + STATE() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + STREAM() antlr.TerminalNode + SUBSCRIBE() antlr.TerminalNode + SUBSET() antlr.TerminalNode + SUCCESS() antlr.TerminalNode + SYS() antlr.TerminalNode + SYSBACKUP() antlr.TerminalNode + SYSDG() antlr.TerminalNode + SYSGUID() antlr.TerminalNode + SYSKM() antlr.TerminalNode + SYSOBJ() antlr.TerminalNode + SYS_CHECK_PRIVILEGE() antlr.TerminalNode + SYS_GET_COL_ACLIDS() antlr.TerminalNode + SYS_MKXTI() antlr.TerminalNode + SYS_OP_CYCLED_SEQ() antlr.TerminalNode + SYS_OP_HASH() antlr.TerminalNode + SYS_OP_KEY_VECTOR_CREATE() antlr.TerminalNode + SYS_OP_KEY_VECTOR_FILTER() antlr.TerminalNode + SYS_OP_KEY_VECTOR_FILTER_LIST() antlr.TerminalNode + SYS_OP_KEY_VECTOR_SUCCEEDED() antlr.TerminalNode + SYS_OP_KEY_VECTOR_USE() antlr.TerminalNode + SYS_OP_PART_ID() antlr.TerminalNode + SYS_OP_ZONE_ID() antlr.TerminalNode + SYS_RAW_TO_XSID() antlr.TerminalNode + SYS_XSID_TO_RAW() antlr.TerminalNode + SYS_ZMAP_FILTER() antlr.TerminalNode + SYS_ZMAP_REFRESH() antlr.TerminalNode + TAG() antlr.TerminalNode + TEXT() antlr.TerminalNode + TIER() antlr.TerminalNode + TIES() antlr.TerminalNode + TO_ACLID() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + TRUST() antlr.TerminalNode + UCS2() antlr.TerminalNode + UNCONDITIONAL() antlr.TerminalNode + UNITE() antlr.TerminalNode + UNMATCHED() antlr.TerminalNode + UNPLUG() antlr.TerminalNode + UNSUBSCRIBE() antlr.TerminalNode + USABLE() antlr.TerminalNode + USER_DATA() antlr.TerminalNode + USER_TABLESPACES() antlr.TerminalNode + USE_CUBE() antlr.TerminalNode + USE_HIDDEN_PARTITIONS() antlr.TerminalNode + USE_VECTOR_AGGREGATION() antlr.TerminalNode + USING_NO_EXPAND() antlr.TerminalNode + USING_NLS_COMP() antlr.TerminalNode + UTF16BE() antlr.TerminalNode + UTF16LE() antlr.TerminalNode + UTF32() antlr.TerminalNode + UTF8() antlr.TerminalNode + V1() antlr.TerminalNode + V2() antlr.TerminalNode + VALIDATE_CONVERSION() antlr.TerminalNode + VALID_TIME_END() antlr.TerminalNode + VECTOR_TRANSFORM() antlr.TerminalNode + VECTOR_TRANSFORM_DIMS() antlr.TerminalNode + VECTOR_TRANSFORM_FACT() antlr.TerminalNode + VERIFIER() antlr.TerminalNode + VIOLATION() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + WEEK() antlr.TerminalNode + WEEKS() antlr.TerminalNode + WITH_PLSQL() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + XS() antlr.TerminalNode + YEARS() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + + // IsNon_reserved_keywords_in_12cContext differentiates from other interfaces. + IsNon_reserved_keywords_in_12cContext() +} + +type Non_reserved_keywords_in_12cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_keywords_in_12cContext() *Non_reserved_keywords_in_12cContext { + var p = new(Non_reserved_keywords_in_12cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c + return p +} + +func InitEmptyNon_reserved_keywords_in_12cContext(p *Non_reserved_keywords_in_12cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c +} + +func (*Non_reserved_keywords_in_12cContext) IsNon_reserved_keywords_in_12cContext() {} + +func NewNon_reserved_keywords_in_12cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_keywords_in_12cContext { + var p = new(Non_reserved_keywords_in_12cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c + + return p +} + +func (s *Non_reserved_keywords_in_12cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_keywords_in_12cContext) ACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserACL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACCESSIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSIBLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACROSS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ADAPTIVE_PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADAPTIVE_PLAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AFD_DISKSTRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFD_DISKSTRING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ALTERNATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTERNATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(PlSqlParserALGORITHM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANCESTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCESTOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANOMALY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANOMALY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANSI_REARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserANSI_REARCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) APPROX_COUNT_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPROX_COUNT_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ASIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASIS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ASSIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AUTO_REOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_REOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AVRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVRO, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BACKGROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKGROUND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BACKUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUPS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BATCHSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCHSIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BEGINNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGINNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BEQUEATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEQUEATH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BITMAP_AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP_AND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BLOCKCHAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKCHAIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserBSON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CACHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CALCULATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALCULATED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CALLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALLBACK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CAPACITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPACITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CDBDEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCDBDEFAULT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLASSIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLAUSE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLEANUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEANUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTER_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_DETAILS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTER_DISTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_DISTANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMMON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMMON_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMPONENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENTS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINERS_DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS_DEFAULT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINER_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_MAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_DBID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_DBID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_GUID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_GUID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_NAME_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_NAME_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_UID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_UID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COOKIE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOOKIE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CREATE_FILE_DEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE_FILE_DEST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREDENTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CRITICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRITICAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CUBE_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_AJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CUBE_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_SJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAMOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAMOVEMENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAOBJ_TO_MAT_PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJ_TO_MAT_PARTITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAPUMP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATA_SECURITY_REWRITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA_SECURITY_REWRITE_LIMIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DB_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DECORRELATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECORRELATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFAULT_CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_CREDENTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFAULT_COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_COLLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELEGATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DELETE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DESTROY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESTROY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DIMENSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISABLE_PARALLEL_DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_PARALLEL_DML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISCARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCARD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DUPLICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ELIM_GROUPBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIM_GROUPBY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EM() antlr.TerminalNode { + return s.GetToken(PlSqlParserEM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENABLE_PARALLEL_DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_PARALLEL_DML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EQUIPART() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUIPART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPRESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXTRACTCLOBXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACTCLOBXML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FACTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACTOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILOVER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAILURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILURE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAMILY() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAMILY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FASTSTART() antlr.TerminalNode { + return s.GetToken(PlSqlParserFASTSTART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FEATURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FEATURE_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_DETAILS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIXED_VIEW_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIXED_VIEW_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFTP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGATHER_OPTIMIZER_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GET() antlr.TerminalNode { + return s.GetToken(PlSqlParserGET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HALF_YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHALF_YEARS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HASHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HIER_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIER_ORDER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HIERARCHICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHICAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HOURS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOURS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HTTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHTTP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) H_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserH_LETTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ILM() antlr.TerminalNode { + return s.GetToken(PlSqlParserILM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMUTABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INACTIVE_ACCOUNT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE_ACCOUNT_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INDEXING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INMEMORY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINPLACE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERLEAVED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INVALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ISOLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IS_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS_LEAF, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSONGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSONGET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSONPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSONPARSE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_ARRAYAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAYAGG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EQUAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EXISTS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EXISTS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EXISTS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_OBJECTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECTAGG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_QUERY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_SERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_SERIALIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TEXTCONTAINS() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TEXTCONTAINS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TEXTCONTAINS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TEXTCONTAINS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_VALUE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLABEL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEAD_CDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEAD_CDB_URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB_URI, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LIFECYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFECYCLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LINEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINEAR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOCKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOGMINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGMINING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MANDATORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANDATORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCHES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH_NUMBER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH_RECOGNIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH_RECOGNIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MAX_SHARED_TEMP_SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX_SHARED_TEMP_SIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMCOMPRESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_CAPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_DESCRIPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MINUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODEL_NB() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_NB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODEL_SV() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_SV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODULE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MULTIDIMENSIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTIDIMENSIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NEG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOCOPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOPY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOKEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOKEEP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARTITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NORELOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELOCATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOREPLAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPLAY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ADAPTIVE_PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ADAPTIVE_PLAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ANSI_REARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ANSI_REARCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_AUTO_REOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_AUTO_REOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_COMMON_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COMMON_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_DATA_SECURITY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DATA_SECURITY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_DECORRELATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DECORRELATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ELIM_GROUPBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIM_GROUPBY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INMEMORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_INMEMORY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INMEMORY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_OBJECT_LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OBJECT_LINK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PARTIAL_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_JOIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_CONCURRENT_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_CONCURRENT_UNION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_REPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_REPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_SKEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_SKEW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOPROMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPROMPT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PX_FAULT_TOLERANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PX_FAULT_TOLERANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ROOT_SW_FOR_LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ROOT_SW_FOR_LOCAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_SQL_TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SQL_TRANSLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_USE_CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_CUBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_USE_VECTOR_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_VECTOR_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM_DIMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM_DIMS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM_FACT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ZONEMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OBJ_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJ_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOMIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATAPUMP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_HDFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HDFS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_HIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_LOADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_LOADER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CHECK_ACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CHECK_ACL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CHECK_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CHECK_PRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_USER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_USERID() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_USERID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_XS_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_XS_USER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_XS_USER_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_XS_USER_GUID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_RAWCOMPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_RAWCOMPARE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_RAWCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_RAWCONCAT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_WRITE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_WRITE_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARENT_LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_LEVEL_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARENT_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PASSWORD_ROLLOVER_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_ROLLOVER_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL_JOIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPAST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATH_PREFIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH_PREFIX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATTERN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATTERN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERIOD_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERMUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMUTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_16K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_16K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_2K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_2K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_32K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_32K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_4K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_4K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_8K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_8K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_CONCURRENT_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_CONCURRENT_UNION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_DISTRIBUTE_WINDOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_DISTRIBUTE_WINDOW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_REPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_REPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_SKEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_SKEW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRELOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRELOAD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PREV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRINTBLOBTOCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRINTBLOBTOCLOB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIORITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRIVILEGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPERTY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROTOCOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTOCOL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROXY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROXY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PX_FAULT_TOLERANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_FAULT_TOLERANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) QUARTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUARTERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) QUOTAGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTAGROUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REALM() antlr.TerminalNode { + return s.GetToken(PlSqlParserREALM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REDEFINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDEFINE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RELOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELOCATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RESTART() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ROLESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLESET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ROWID_MAPPING_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID_MAPPING_TABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RUNNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRUNNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SAVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SCRUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCRUB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SDO_GEOM_MBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOM_MBR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SECONDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECONDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERVICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERVICE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHARDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHELFLIFE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHELFLIFE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SOURCE_FILE_DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE_FILE_DIRECTORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SOURCE_FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE_FILE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SQL_TRANSLATION_PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_TRANSLATION_PROFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDARD_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD_HASH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDBYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STREAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTREAM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUBSCRIBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSCRIBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUBSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUCCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSBACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSBACKUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSDG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSGUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSGUID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSKM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSOBJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOBJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_CHECK_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CHECK_PRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_GET_COL_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_COL_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_MKXTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MKXTI, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_CYCLED_SEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CYCLED_SEQ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_HASH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_CREATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_FILTER_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_SUCCEEDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_USE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_PART_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PART_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_ZONE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ZONE_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_RAW_TO_XSID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_RAW_TO_XSID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_XSID_TO_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XSID_TO_RAW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_ZMAP_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ZMAP_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_ZMAP_REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ZMAP_REFRESH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEXT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TO_ACLID() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_ACLID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRUST() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UCS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserUCS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNCONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNCONDITIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNMATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNMATCHED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNPLUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPLUG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNSUBSCRIBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSUBSCRIBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USER_TABLESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_TABLESPACES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_CUBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_HIDDEN_PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HIDDEN_PARTITIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_VECTOR_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_VECTOR_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USING_NO_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING_NO_EXPAND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USING_NLS_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING_NLS_COMP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF16BE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF16BE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF16LE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF16LE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF32() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF32, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF8() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF8, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) V1() antlr.TerminalNode { + return s.GetToken(PlSqlParserV1, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) V2() antlr.TerminalNode { + return s.GetToken(PlSqlParserV2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VALIDATE_CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE_CONVERSION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VALID_TIME_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALID_TIME_END, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM_DIMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM_DIMS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM_FACT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VERIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERIFIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VIOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIOLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBILITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WEEK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WEEKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEKS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WITH_PLSQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH_PLSQL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) XS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_keywords_in_12cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_keywords_in_12cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_reserved_keywords_in_12c(s) + } +} + +func (s *Non_reserved_keywords_in_12cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_reserved_keywords_in_12c(s) + } +} + +func (p *PlSqlParser) Non_reserved_keywords_in_12c() (localctx INon_reserved_keywords_in_12cContext) { + localctx = NewNon_reserved_keywords_in_12cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2414, PlSqlParserRULE_non_reserved_keywords_in_12c) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21412) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-3445068992151462592) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&5119657388280321) != 0) || ((int64((_la-136)) & ^0x3f) == 0 && ((int64(1)<<(_la-136))&284893770940417) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&-3602773736463089505) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&-8014155529113305087) != 0) || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&3458980430953842741) != 0) || ((int64((_la-423)) & ^0x3f) == 0 && ((int64(1)<<(_la-423))&589971551219106337) != 0) || ((int64((_la-487)) & ^0x3f) == 0 && ((int64(1)<<(_la-487))&144126184265893953) != 0) || ((int64((_la-556)) & ^0x3f) == 0 && ((int64(1)<<(_la-556))&9147989469040705) != 0) || ((int64((_la-621)) & ^0x3f) == 0 && ((int64(1)<<(_la-621))&-7490611942783934463) != 0) || ((int64((_la-697)) & ^0x3f) == 0 && ((int64(1)<<(_la-697))&20830247790313521) != 0) || ((int64((_la-770)) & ^0x3f) == 0 && ((int64(1)<<(_la-770))&582093550339033089) != 0) || ((int64((_la-836)) & ^0x3f) == 0 && ((int64(1)<<(_la-836))&585489941799127043) != 0) || ((int64((_la-908)) & ^0x3f) == 0 && ((int64(1)<<(_la-908))&2252915970410373) != 0) || ((int64((_la-972)) & ^0x3f) == 0 && ((int64(1)<<(_la-972))&1099513758801) != 0) || ((int64((_la-1055)) & ^0x3f) == 0 && ((int64(1)<<(_la-1055))&1011058257038737731) != 0) || ((int64((_la-1132)) & ^0x3f) == 0 && ((int64(1)<<(_la-1132))&144257167054864513) != 0) || ((int64((_la-1207)) & ^0x3f) == 0 && ((int64(1)<<(_la-1207))&457676010294913) != 0) || ((int64((_la-1276)) & ^0x3f) == 0 && ((int64(1)<<(_la-1276))&-4611686018409578489) != 0) || ((int64((_la-1342)) & ^0x3f) == 0 && ((int64(1)<<(_la-1342))&439804673785869) != 0) || ((int64((_la-1409)) & ^0x3f) == 0 && ((int64(1)<<(_la-1409))&-2017302018866216463) != 0) || ((int64((_la-1478)) & ^0x3f) == 0 && ((int64(1)<<(_la-1478))&8797166772241) != 0) || ((int64((_la-1553)) & ^0x3f) == 0 && ((int64(1)<<(_la-1553))&576603688815558665) != 0) || ((int64((_la-1617)) & ^0x3f) == 0 && ((int64(1)<<(_la-1617))&369435910115329) != 0) || ((int64((_la-1681)) & ^0x3f) == 0 && ((int64(1)<<(_la-1681))&-4605458381346439037) != 0) || ((int64((_la-1765)) & ^0x3f) == 0 && ((int64(1)<<(_la-1765))&4611703958510002177) != 0) || ((int64((_la-1832)) & ^0x3f) == 0 && ((int64(1)<<(_la-1832))&273778663751779) != 0) || ((int64((_la-1904)) & ^0x3f) == 0 && ((int64(1)<<(_la-1904))&550024249345) != 0) || ((int64((_la-2074)) & ^0x3f) == 0 && ((int64(1)<<(_la-2074))&1125903132264455) != 0) || ((int64((_la-2148)) & ^0x3f) == 0 && ((int64(1)<<(_la-2148))&9149036527370305) != 0) || ((int64((_la-2215)) & ^0x3f) == 0 && ((int64(1)<<(_la-2215))&2161730842246807825) != 0) || ((int64((_la-2287)) & ^0x3f) == 0 && ((int64(1)<<(_la-2287))&34604549) != 0) || ((int64((_la-2355)) & ^0x3f) == 0 && ((int64(1)<<(_la-2355))&9007256699863173) != 0) || _la == PlSqlParserPERIOD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INon_reserved_keywords_pre12cContext is an interface to support dynamic dispatch. +type INon_reserved_keywords_pre12cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT() antlr.TerminalNode + ABS() antlr.TerminalNode + ACCESSED() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + ACOS() antlr.TerminalNode + ACTIVATE() antlr.TerminalNode + ACTIVE_COMPONENT() antlr.TerminalNode + ACTIVE_FUNCTION() antlr.TerminalNode + ACTIVE_TAG() antlr.TerminalNode + ADD_COLUMN() antlr.TerminalNode + ADD_GROUP() antlr.TerminalNode + ADD_MONTHS() antlr.TerminalNode + ADD() antlr.TerminalNode + ADJ_DATE() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + ADMINISTRATOR() antlr.TerminalNode + ADMIN() antlr.TerminalNode + ADVISE() antlr.TerminalNode + ADVISOR() antlr.TerminalNode + AFTER() antlr.TerminalNode + ALIAS() antlr.TerminalNode + ALLOCATE() antlr.TerminalNode + ALLOW() antlr.TerminalNode + ALL_ROWS() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + ANCILLARY() antlr.TerminalNode + AND_EQUAL() antlr.TerminalNode + ANTIJOIN() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + APPENDCHILDXML() antlr.TerminalNode + APPEND() antlr.TerminalNode + APPEND_VALUES() antlr.TerminalNode + APPLY() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + ARRAY() antlr.TerminalNode + ASCII() antlr.TerminalNode + ASCIISTR() antlr.TerminalNode + ASIN() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASSOCIATE() antlr.TerminalNode + ASYNCHRONOUS() antlr.TerminalNode + ASYNC() antlr.TerminalNode + ATAN2() antlr.TerminalNode + ATAN() antlr.TerminalNode + AT() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + AUTHENTICATED() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AUTHID() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + AUTOALLOCATE() antlr.TerminalNode + AUTOEXTEND() antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + AUTO() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + AVG() antlr.TerminalNode + BACKUP() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + BASIC() antlr.TerminalNode + BATCH() antlr.TerminalNode + BECOME() antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGIN() antlr.TerminalNode + BEGIN_OUTLINE_DATA() antlr.TerminalNode + BEHALF() antlr.TerminalNode + BFILE() antlr.TerminalNode + BFILENAME() antlr.TerminalNode + BIGFILE() antlr.TerminalNode + BINARY_DOUBLE_INFINITY() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + BINARY_DOUBLE_NAN() antlr.TerminalNode + BINARY_FLOAT_INFINITY() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_FLOAT_NAN() antlr.TerminalNode + BINARY() antlr.TerminalNode + BIND_AWARE() antlr.TerminalNode + BINDING() antlr.TerminalNode + BIN_TO_NUM() antlr.TerminalNode + BITAND() antlr.TerminalNode + BITMAP() antlr.TerminalNode + BITMAPS() antlr.TerminalNode + BITMAP_TREE() antlr.TerminalNode + BITS() antlr.TerminalNode + BLOB() antlr.TerminalNode + BLOCK() antlr.TerminalNode + BLOCK_RANGE() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + BLOCKS() antlr.TerminalNode + BODY() antlr.TerminalNode + BOTH() antlr.TerminalNode + BOUND() antlr.TerminalNode + BRANCH() antlr.TerminalNode + BREADTH() antlr.TerminalNode + BROADCAST() antlr.TerminalNode + BUFFER_CACHE() antlr.TerminalNode + BUFFER() antlr.TerminalNode + BUFFER_POOL() antlr.TerminalNode + BUILD() antlr.TerminalNode + BULK() antlr.TerminalNode + BYPASS_RECURSIVE_CHECK() antlr.TerminalNode + BYPASS_UJVC() antlr.TerminalNode + BYTE() antlr.TerminalNode + CACHE_CB() antlr.TerminalNode + CACHE_INSTANCES() antlr.TerminalNode + CACHE() antlr.TerminalNode + CACHE_TEMP_TABLE() antlr.TerminalNode + CALL() antlr.TerminalNode + CANCEL() antlr.TerminalNode + CARDINALITY() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CASE() antlr.TerminalNode + CAST() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + CEIL() antlr.TerminalNode + CELL_FLASH_CACHE() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + CFILE() antlr.TerminalNode + CHAINED() antlr.TerminalNode + CHANGE_DUPKEY_ERROR_INDEX() antlr.TerminalNode + CHANGE() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + CHAR_CS() antlr.TerminalNode + CHARTOROWID() antlr.TerminalNode + CHECK_ACL_REWRITE() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + CHILD() antlr.TerminalNode + CHOOSE() antlr.TerminalNode + CHR() antlr.TerminalNode + CHUNK() antlr.TerminalNode + CLASS() antlr.TerminalNode + CLEAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + CLONE() antlr.TerminalNode + CLOSE_CACHED_OPEN_CURSORS() antlr.TerminalNode + CLOSE() antlr.TerminalNode + CLUSTER_BY_ROWID() antlr.TerminalNode + CLUSTER_ID() antlr.TerminalNode + CLUSTERING_FACTOR() antlr.TerminalNode + CLUSTER_PROBABILITY() antlr.TerminalNode + CLUSTER_SET() antlr.TerminalNode + COALESCE() antlr.TerminalNode + COALESCE_SQ() antlr.TerminalNode + COARSE() antlr.TerminalNode + CO_AUTH_IND() antlr.TerminalNode + COLD() antlr.TerminalNode + COLLECT() antlr.TerminalNode + COLUMNAR() antlr.TerminalNode + COLUMN_AUTH_INDICATOR() antlr.TerminalNode + COLUMN() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COLUMN_STATS() antlr.TerminalNode + COLUMN_VALUE() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + COMPACT() antlr.TerminalNode + COMPATIBILITY() antlr.TerminalNode + COMPILE() antlr.TerminalNode + COMPLETE() antlr.TerminalNode + COMPLIANCE() antlr.TerminalNode + COMPOSE() antlr.TerminalNode + COMPOSITE_LIMIT() antlr.TerminalNode + COMPOSITE() antlr.TerminalNode + COMPOUND() antlr.TerminalNode + COMPUTE() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONFIRM() antlr.TerminalNode + CONFORMING() antlr.TerminalNode + CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode + CONNECT_BY_COMBINE_SW() antlr.TerminalNode + CONNECT_BY_COST_BASED() antlr.TerminalNode + CONNECT_BY_ELIM_DUPS() antlr.TerminalNode + CONNECT_BY_FILTERING() antlr.TerminalNode + CONNECT_BY_ISCYCLE() antlr.TerminalNode + CONNECT_BY_ISLEAF() antlr.TerminalNode + CONNECT_BY_ROOT() antlr.TerminalNode + CONNECT_TIME() antlr.TerminalNode + CONSIDER() antlr.TerminalNode + CONSISTENT() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + CONST() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + CONTAINER() antlr.TerminalNode + CONTENT() antlr.TerminalNode + CONTENTS() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + CONVERT() antlr.TerminalNode + CORR_K() antlr.TerminalNode + CORR() antlr.TerminalNode + CORR_S() antlr.TerminalNode + CORRUPTION() antlr.TerminalNode + CORRUPT_XID_ALL() antlr.TerminalNode + CORRUPT_XID() antlr.TerminalNode + COSH() antlr.TerminalNode + COS() antlr.TerminalNode + COST() antlr.TerminalNode + COST_XML_QUERY_REWRITE() antlr.TerminalNode + COUNT() antlr.TerminalNode + COVAR_POP() antlr.TerminalNode + COVAR_SAMP() antlr.TerminalNode + CPU_COSTING() antlr.TerminalNode + CPU_PER_CALL() antlr.TerminalNode + CPU_PER_SESSION() antlr.TerminalNode + CRASH() antlr.TerminalNode + CREATE_STORED_OUTLINES() antlr.TerminalNode + CREATION() antlr.TerminalNode + CROSSEDITION() antlr.TerminalNode + CROSS() antlr.TerminalNode + CSCONVERT() antlr.TerminalNode + CUBE_GB() antlr.TerminalNode + CUBE() antlr.TerminalNode + CUME_DISTM() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + CURRENT_SCHEMA() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + CURRENTV() antlr.TerminalNode + CURSOR() antlr.TerminalNode + CURSOR_SHARING_EXACT() antlr.TerminalNode + CURSOR_SPECIFIC_SEGMENT() antlr.TerminalNode + CV() antlr.TerminalNode + CYCLE() antlr.TerminalNode + DANGLING() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + DATA() antlr.TerminalNode + DATAOBJNO() antlr.TerminalNode + DATAOBJ_TO_PARTITION() antlr.TerminalNode + DATE_MODE() antlr.TerminalNode + DAY() antlr.TerminalNode + DBA() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + DBLINK() antlr.TerminalNode + DBMS_STATS() antlr.TerminalNode + DB_ROLE_CHANGE() antlr.TerminalNode + DBTIMEZONE() antlr.TerminalNode + DB_VERSION() antlr.TerminalNode + DDL() antlr.TerminalNode + DEALLOCATE() antlr.TerminalNode + DEBUGGER() antlr.TerminalNode + DEBUG() antlr.TerminalNode + DECLARE() antlr.TerminalNode + DEC() antlr.TerminalNode + DECOMPOSE() antlr.TerminalNode + DECREMENT() antlr.TerminalNode + DECR() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + DEDUPLICATE() antlr.TerminalNode + DEFAULTS() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + DEFINED() antlr.TerminalNode + DEFINER() antlr.TerminalNode + DEGREE() antlr.TerminalNode + DELAY() antlr.TerminalNode + DELETEXML() antlr.TerminalNode + DEMAND() antlr.TerminalNode + DENSE_RANKM() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + DEPENDENT() antlr.TerminalNode + DEPTH() antlr.TerminalNode + DEQUEUE() antlr.TerminalNode + DEREF() antlr.TerminalNode + DEREF_NO_REWRITE() antlr.TerminalNode + DETACHED() antlr.TerminalNode + DETERMINES() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECT_LOAD() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + DIRECT_PATH() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DISABLE_PRESET() antlr.TerminalNode + DISABLE_RPKE() antlr.TerminalNode + DISALLOW() antlr.TerminalNode + DISASSOCIATE() antlr.TerminalNode + DISCONNECT() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + DISK() antlr.TerminalNode + DISKS() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + DISTINGUISHED() antlr.TerminalNode + DISTRIBUTED() antlr.TerminalNode + DML() antlr.TerminalNode + DML_UPDATE() antlr.TerminalNode + DOCFIDELITY() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + DOMAIN_INDEX_FILTER() antlr.TerminalNode + DOMAIN_INDEX_NO_SORT() antlr.TerminalNode + DOMAIN_INDEX_SORT() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + DOWNGRADE() antlr.TerminalNode + DRIVING_SITE() antlr.TerminalNode + DROP_COLUMN() antlr.TerminalNode + DROP_GROUP() antlr.TerminalNode + DST_UPGRADE_INSERT_CONV() antlr.TerminalNode + DUMP() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + DYNAMIC_SAMPLING_EST_CDN() antlr.TerminalNode + DYNAMIC_SAMPLING() antlr.TerminalNode + EACH() antlr.TerminalNode + EDITIONING() antlr.TerminalNode + EDITION() antlr.TerminalNode + EDITIONS() antlr.TerminalNode + ELEMENT() antlr.TerminalNode + ELIMINATE_JOIN() antlr.TerminalNode + ELIMINATE_OBY() antlr.TerminalNode + ELIMINATE_OUTER_JOIN() antlr.TerminalNode + EMPTY_BLOB() antlr.TerminalNode + EMPTY_CLOB() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_PRESET() antlr.TerminalNode + ENCODING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + END_OUTLINE_DATA() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + ENFORCE() antlr.TerminalNode + ENQUEUE() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + ENTITYESCAPING() antlr.TerminalNode + ENTRY() antlr.TerminalNode + ERROR_ARGUMENT() antlr.TerminalNode + ERROR() antlr.TerminalNode + ERROR_ON_OVERLAP_TIME() antlr.TerminalNode + ERRORS() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + ESTIMATE() antlr.TerminalNode + EVALNAME() antlr.TerminalNode + EVALUATION() antlr.TerminalNode + EVENTS() antlr.TerminalNode + EVERY() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + EXEMPT() antlr.TerminalNode + EXISTSNODE() antlr.TerminalNode + EXPAND_GSET_TO_UNION() antlr.TerminalNode + EXPAND_TABLE() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + EXPLAIN() antlr.TerminalNode + EXPLOSION() antlr.TerminalNode + EXP() antlr.TerminalNode + EXPORT() antlr.TerminalNode + EXPR_CORR_CHECK() antlr.TerminalNode + EXTENDS() antlr.TerminalNode + EXTENT() antlr.TerminalNode + EXTENTS() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + EXTRACTVALUE() antlr.TerminalNode + EXTRA() antlr.TerminalNode + FACILITY() antlr.TerminalNode + FACT() antlr.TerminalNode + FACTORIZE_JOIN() antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + FAILED() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + FALSE() antlr.TerminalNode + FAST() antlr.TerminalNode + FBTSCAN() antlr.TerminalNode + FEATURE_ID() antlr.TerminalNode + FEATURE_SET() antlr.TerminalNode + FEATURE_VALUE() antlr.TerminalNode + FILE() antlr.TerminalNode + FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode + FILTER() antlr.TerminalNode + FINAL() antlr.TerminalNode + FINE() antlr.TerminalNode + FINISH() antlr.TerminalNode + FIRSTM() antlr.TerminalNode + FIRST() antlr.TerminalNode + FIRST_ROWS() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + FLAGGER() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + FLASH_CACHE() antlr.TerminalNode + FLOB() antlr.TerminalNode + FLOOR() antlr.TerminalNode + FLUSH() antlr.TerminalNode + FOLDER() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + FOLLOWS() antlr.TerminalNode + FORCE() antlr.TerminalNode + FORCE_XML_QUERY_REWRITE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + FOREVER() antlr.TerminalNode + FORWARD() antlr.TerminalNode + FRAGMENT_NUMBER() antlr.TerminalNode + FREELIST() antlr.TerminalNode + FREELISTS() antlr.TerminalNode + FREEPOOLS() antlr.TerminalNode + FRESH() antlr.TerminalNode + FROM_TZ() antlr.TerminalNode + FULL() antlr.TerminalNode + FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + GATHER_PLAN_STATISTICS() antlr.TerminalNode + GBY_CONC_ROLLUP() antlr.TerminalNode + GBY_PUSHDOWN() antlr.TerminalNode + GENERATED() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GLOBAL_NAME() antlr.TerminalNode + GLOBAL_TOPIC_ENABLED() antlr.TerminalNode + GREATEST() antlr.TerminalNode + GROUP_BY() antlr.TerminalNode + GROUP_ID() antlr.TerminalNode + GROUPING_ID() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPS() antlr.TerminalNode + GUARANTEED() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + GUARD() antlr.TerminalNode + HASH_AJ() antlr.TerminalNode + HASHKEYS() antlr.TerminalNode + HASH() antlr.TerminalNode + HASH_SJ() antlr.TerminalNode + HEADER() antlr.TerminalNode + HEAP() antlr.TerminalNode + HELP() antlr.TerminalNode + HEXTORAW() antlr.TerminalNode + HEXTOREF() antlr.TerminalNode + HIDDEN_KEYWORD() antlr.TerminalNode + HIDE() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + HIGH() antlr.TerminalNode + HINTSET_BEGIN() antlr.TerminalNode + HINTSET_END() antlr.TerminalNode + HOT() antlr.TerminalNode + HOUR() antlr.TerminalNode + HWM_BROKERED() antlr.TerminalNode + HYBRID() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + IDGENERATORS() antlr.TerminalNode + IDLE_TIME() antlr.TerminalNode + ID() antlr.TerminalNode + IF() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IGNORE_OPTIM_EMBEDDED_HINTS() antlr.TerminalNode + IGNORE_ROW_ON_DUPKEY_INDEX() antlr.TerminalNode + IGNORE_WHERE_CLAUSE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + IMPACT() antlr.TerminalNode + IMPORT() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + INCLUDE_VERSION() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + INCR() antlr.TerminalNode + INDENT() antlr.TerminalNode + INDEX_ASC() antlr.TerminalNode + INDEX_COMBINE() antlr.TerminalNode + INDEX_DESC() antlr.TerminalNode + INDEXED() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INDEX_FFS() antlr.TerminalNode + INDEX_FILTER() antlr.TerminalNode + INDEX_JOIN() antlr.TerminalNode + INDEX_ROWS() antlr.TerminalNode + INDEX_RRS() antlr.TerminalNode + INDEX_RS_ASC() antlr.TerminalNode + INDEX_RS_DESC() antlr.TerminalNode + INDEX_RS() antlr.TerminalNode + INDEX_SCAN() antlr.TerminalNode + INDEX_SKIP_SCAN() antlr.TerminalNode + INDEX_SS_ASC() antlr.TerminalNode + INDEX_SS_DESC() antlr.TerminalNode + INDEX_SS() antlr.TerminalNode + INDEX_STATS() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + INDEXTYPES() antlr.TerminalNode + INDICATOR() antlr.TerminalNode + INFINITE() antlr.TerminalNode + INFORMATIONAL() antlr.TerminalNode + INITCAP() antlr.TerminalNode + INITIALIZED() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + INITIAL() antlr.TerminalNode + INITRANS() antlr.TerminalNode + INLINE() antlr.TerminalNode + INLINE_XMLTYPE_NT() antlr.TerminalNode + IN_MEMORY_METADATA() antlr.TerminalNode + INNER() antlr.TerminalNode + INSERTCHILDXMLAFTER() antlr.TerminalNode + INSERTCHILDXMLBEFORE() antlr.TerminalNode + INSERTCHILDXML() antlr.TerminalNode + INSERTXMLAFTER() antlr.TerminalNode + INSERTXMLBEFORE() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + INSTANCES() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + INSTANTLY() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + INSTR2() antlr.TerminalNode + INSTR4() antlr.TerminalNode + INSTRB() antlr.TerminalNode + INSTRC() antlr.TerminalNode + INSTR() antlr.TerminalNode + INTERMEDIATE() antlr.TerminalNode + INTERNAL_CONVERT() antlr.TerminalNode + INTERNAL_USE() antlr.TerminalNode + INTERPRETED() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + INT() antlr.TerminalNode + INVALIDATE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + IN_XQUERY() antlr.TerminalNode + ISOLATION_LEVEL() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + ITERATE() antlr.TerminalNode + ITERATION_NUMBER() antlr.TerminalNode + JAVA() antlr.TerminalNode + JOB() antlr.TerminalNode + JOIN() antlr.TerminalNode + KEEP_DUPLICATES() antlr.TerminalNode + KEEP() antlr.TerminalNode + KERBEROS() antlr.TerminalNode + KEY_LENGTH() antlr.TerminalNode + KEY() antlr.TerminalNode + KEYSIZE() antlr.TerminalNode + KEYS() antlr.TerminalNode + KILL() antlr.TerminalNode + LAG() antlr.TerminalNode + LAST_DAY() antlr.TerminalNode + LAST() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LATERAL() antlr.TerminalNode + LAYER() antlr.TerminalNode + LDAP_REGISTRATION_ENABLED() antlr.TerminalNode + LDAP_REGISTRATION() antlr.TerminalNode + LDAP_REG_SYNC_INTERVAL() antlr.TerminalNode + LEADING() antlr.TerminalNode + LEAD() antlr.TerminalNode + LEAF() antlr.TerminalNode + LEAST() antlr.TerminalNode + LEFT() antlr.TerminalNode + LENGTH2() antlr.TerminalNode + LENGTH4() antlr.TerminalNode + LENGTHB() antlr.TerminalNode + LENGTHC() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LESS() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + LIFE() antlr.TerminalNode + LIFETIME() antlr.TerminalNode + LIKE2() antlr.TerminalNode + LIKE4() antlr.TerminalNode + LIKEC() antlr.TerminalNode + LIKE_EXPAND() antlr.TerminalNode + LIMIT() antlr.TerminalNode + LINK() antlr.TerminalNode + LISTAGG() antlr.TerminalNode + LIST() antlr.TerminalNode + LN() antlr.TerminalNode + LNNVL() antlr.TerminalNode + LOAD() antlr.TerminalNode + LOB() antlr.TerminalNode + LOBNVL() antlr.TerminalNode + LOBS() antlr.TerminalNode + LOCAL_INDEXES() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + LOCKED() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + LOGFILES() antlr.TerminalNode + LOGGING() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + LOGICAL_READS_PER_CALL() antlr.TerminalNode + LOGICAL_READS_PER_SESSION() antlr.TerminalNode + LOG() antlr.TerminalNode + LOGOFF() antlr.TerminalNode + LOGON() antlr.TerminalNode + LOG_READ_ONLY_VIOLATIONS() antlr.TerminalNode + LOWER() antlr.TerminalNode + LOW() antlr.TerminalNode + LPAD() antlr.TerminalNode + LTRIM() antlr.TerminalNode + MAIN() antlr.TerminalNode + MAKE_REF() antlr.TerminalNode + MANAGED() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + MANAGE() antlr.TerminalNode + MANAGER() antlr.TerminalNode + MANUAL() antlr.TerminalNode + MAPPING() antlr.TerminalNode + MASTER() antlr.TerminalNode + MATCHED() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MATERIALIZE() antlr.TerminalNode + MAXARCHLOGS() antlr.TerminalNode + MAXDATAFILES() antlr.TerminalNode + MAXEXTENTS() antlr.TerminalNode + MAXIMIZE() antlr.TerminalNode + MAXINSTANCES() antlr.TerminalNode + MAXLOGFILES() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + MAXLOGMEMBERS() antlr.TerminalNode + MAX() antlr.TerminalNode + MAXSIZE() antlr.TerminalNode + MAXTRANS() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + MEASURES() antlr.TerminalNode + MEDIAN() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + MEMBER() antlr.TerminalNode + MEMOPTIMIZE() antlr.TerminalNode + MEMORY() antlr.TerminalNode + MERGEACTIONS() antlr.TerminalNode + MERGE_AJ() antlr.TerminalNode + MERGE_CONST_ON() antlr.TerminalNode + MERGE() antlr.TerminalNode + MERGE_SJ() antlr.TerminalNode + METHOD() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + MIGRATION() antlr.TerminalNode + MINEXTENTS() antlr.TerminalNode + MINIMIZE() antlr.TerminalNode + MINIMUM() antlr.TerminalNode + MINING() antlr.TerminalNode + MIN() antlr.TerminalNode + MINUS_NULL() antlr.TerminalNode + MINUTE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MIRRORCOLD() antlr.TerminalNode + MIRRORHOT() antlr.TerminalNode + MIRROR() antlr.TerminalNode + MLSLABEL() antlr.TerminalNode + MODEL_COMPILE_SUBQUERY() antlr.TerminalNode + MODEL_DONTVERIFY_UNIQUENESS() antlr.TerminalNode + MODEL_DYNAMIC_SUBQUERY() antlr.TerminalNode + MODEL_MIN_ANALYSIS() antlr.TerminalNode + MODEL() antlr.TerminalNode + MODEL_NO_ANALYSIS() antlr.TerminalNode + MODEL_PBY() antlr.TerminalNode + MODEL_PUSH_REF() antlr.TerminalNode + MODIFY_COLUMN_TYPE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MOD() antlr.TerminalNode + MONITORING() antlr.TerminalNode + MONITOR() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTHS_BETWEEN() antlr.TerminalNode + MOUNT() antlr.TerminalNode + MOUNTPATH() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + MOVE() antlr.TerminalNode + MULTISET() antlr.TerminalNode + MV_MERGE() antlr.TerminalNode + NAMED() antlr.TerminalNode + NAME() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + NAN_() antlr.TerminalNode + NANVL() antlr.TerminalNode + NATIONAL() antlr.TerminalNode + NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode + NATIVE() antlr.TerminalNode + NATURAL() antlr.TerminalNode + NAV() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NCHR() antlr.TerminalNode + NCLOB() antlr.TerminalNode + NEEDED() antlr.TerminalNode + NESTED() antlr.TerminalNode + NESTED_TABLE_FAST_INSERT() antlr.TerminalNode + NESTED_TABLE_GET_REFS() antlr.TerminalNode + NESTED_TABLE_ID() antlr.TerminalNode + NESTED_TABLE_SET_REFS() antlr.TerminalNode + NESTED_TABLE_SET_SETID() antlr.TerminalNode + NETWORK() antlr.TerminalNode + NEVER() antlr.TerminalNode + NEW() antlr.TerminalNode + NEW_TIME() antlr.TerminalNode + NEXT_DAY() antlr.TerminalNode + NEXT() antlr.TerminalNode + NL_AJ() antlr.TerminalNode + NLJ_BATCHING() antlr.TerminalNode + NLJ_INDEX_FILTER() antlr.TerminalNode + NLJ_INDEX_SCAN() antlr.TerminalNode + NLJ_PREFETCH() antlr.TerminalNode + NLS_CALENDAR() antlr.TerminalNode + NLS_CHARACTERSET() antlr.TerminalNode + NLS_CHARSET_DECL_LEN() antlr.TerminalNode + NLS_CHARSET_ID() antlr.TerminalNode + NLS_CHARSET_NAME() antlr.TerminalNode + NLS_COMP() antlr.TerminalNode + NLS_CURRENCY() antlr.TerminalNode + NLS_DATE_FORMAT() antlr.TerminalNode + NLS_DATE_LANGUAGE() antlr.TerminalNode + NLS_INITCAP() antlr.TerminalNode + NLS_ISO_CURRENCY() antlr.TerminalNode + NL_SJ() antlr.TerminalNode + NLS_LANG() antlr.TerminalNode + NLS_LANGUAGE() antlr.TerminalNode + NLS_LENGTH_SEMANTICS() antlr.TerminalNode + NLS_LOWER() antlr.TerminalNode + NLS_NCHAR_CONV_EXCP() antlr.TerminalNode + NLS_NUMERIC_CHARACTERS() antlr.TerminalNode + NLS_SORT() antlr.TerminalNode + NLSSORT() antlr.TerminalNode + NLS_SPECIAL_CHARS() antlr.TerminalNode + NLS_TERRITORY() antlr.TerminalNode + NLS_UPPER() antlr.TerminalNode + NO_ACCESS() antlr.TerminalNode + NOAPPEND() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + NOAUDIT() antlr.TerminalNode + NO_BASETABLE_MULTIMV_REWRITE() antlr.TerminalNode + NO_BIND_AWARE() antlr.TerminalNode + NO_BUFFER() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + NO_CARTESIAN() antlr.TerminalNode + NO_CHECK_ACL_REWRITE() antlr.TerminalNode + NO_CLUSTER_BY_ROWID() antlr.TerminalNode + NO_COALESCE_SQ() antlr.TerminalNode + NO_CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode + NO_CONNECT_BY_COMBINE_SW() antlr.TerminalNode + NO_CONNECT_BY_COST_BASED() antlr.TerminalNode + NO_CONNECT_BY_ELIM_DUPS() antlr.TerminalNode + NO_CONNECT_BY_FILTERING() antlr.TerminalNode + NO_COST_XML_QUERY_REWRITE() antlr.TerminalNode + NO_CPU_COSTING() antlr.TerminalNode + NOCPU_COSTING() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + NODELAY() antlr.TerminalNode + NO_DOMAIN_INDEX_FILTER() antlr.TerminalNode + NO_DST_UPGRADE_INSERT_CONV() antlr.TerminalNode + NO_ELIMINATE_JOIN() antlr.TerminalNode + NO_ELIMINATE_OBY() antlr.TerminalNode + NO_ELIMINATE_OUTER_JOIN() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + NO_EXPAND_GSET_TO_UNION() antlr.TerminalNode + NO_EXPAND() antlr.TerminalNode + NO_EXPAND_TABLE() antlr.TerminalNode + NO_FACT() antlr.TerminalNode + NO_FACTORIZE_JOIN() antlr.TerminalNode + NO_FILTERING() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + NO_FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode + NO_GBY_PUSHDOWN() antlr.TerminalNode + NOGUARANTEE() antlr.TerminalNode + NO_INDEX_FFS() antlr.TerminalNode + NO_INDEX() antlr.TerminalNode + NO_INDEX_SS() antlr.TerminalNode + NO_LOAD() antlr.TerminalNode + NOLOCAL() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + NOMAPPING() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + NO_MERGE() antlr.TerminalNode + NOMINIMIZE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + NO_MODEL_PUSH_REF() antlr.TerminalNode + NO_MONITORING() antlr.TerminalNode + NOMONITORING() antlr.TerminalNode + NO_MONITOR() antlr.TerminalNode + NO_MULTIMV_REWRITE() antlr.TerminalNode + NO() antlr.TerminalNode + NO_NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode + NONBLOCKING() antlr.TerminalNode + NONE() antlr.TerminalNode + NO_NLJ_BATCHING() antlr.TerminalNode + NO_NLJ_PREFETCH() antlr.TerminalNode + NONSCHEMA() antlr.TerminalNode + NOORDER() antlr.TerminalNode + NO_ORDER_ROLLUPS() antlr.TerminalNode + NO_OUTER_JOIN_TO_ANTI() antlr.TerminalNode + NO_OUTER_JOIN_TO_INNER() antlr.TerminalNode + NOOVERRIDE() antlr.TerminalNode + NO_PARALLEL_INDEX() antlr.TerminalNode + NOPARALLEL_INDEX() antlr.TerminalNode + NO_PARALLEL() antlr.TerminalNode + NOPARALLEL() antlr.TerminalNode + NO_PARTIAL_COMMIT() antlr.TerminalNode + NO_PLACE_DISTINCT() antlr.TerminalNode + NO_PLACE_GROUP_BY() antlr.TerminalNode + NO_PQ_MAP() antlr.TerminalNode + NO_PRUNE_GSETS() antlr.TerminalNode + NO_PULL_PRED() antlr.TerminalNode + NO_PUSH_PRED() antlr.TerminalNode + NO_PUSH_SUBQ() antlr.TerminalNode + NO_PX_JOIN_FILTER() antlr.TerminalNode + NO_QKN_BUFF() antlr.TerminalNode + NO_QUERY_TRANSFORMATION() antlr.TerminalNode + NO_REF_CASCADE() antlr.TerminalNode + NORELY() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + NO_RESULT_CACHE() antlr.TerminalNode + NOREVERSE() antlr.TerminalNode + NO_REWRITE() antlr.TerminalNode + NOREWRITE() antlr.TerminalNode + NORMAL() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + NOSCHEMACHECK() antlr.TerminalNode + NOSEGMENT() antlr.TerminalNode + NO_SEMIJOIN() antlr.TerminalNode + NO_SEMI_TO_INNER() antlr.TerminalNode + NO_SET_TO_JOIN() antlr.TerminalNode + NOSORT() antlr.TerminalNode + NO_SQL_TUNE() antlr.TerminalNode + NO_STAR_TRANSFORMATION() antlr.TerminalNode + NO_STATEMENT_QUEUING() antlr.TerminalNode + NO_STATS_GSETS() antlr.TerminalNode + NOSTRICT() antlr.TerminalNode + NO_SUBQUERY_PRUNING() antlr.TerminalNode + NO_SUBSTRB_PAD() antlr.TerminalNode + NO_SWAP_JOIN_INPUTS() antlr.TerminalNode + NOSWITCH() antlr.TerminalNode + NO_TABLE_LOOKUP_BY_NL() antlr.TerminalNode + NO_TEMP_TABLE() antlr.TerminalNode + NOTHING() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + NO_TRANSFORM_DISTINCT_AGG() antlr.TerminalNode + NO_UNNEST() antlr.TerminalNode + NO_USE_HASH_AGGREGATION() antlr.TerminalNode + NO_USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode + NO_USE_HASH() antlr.TerminalNode + NO_USE_INVISIBLE_INDEXES() antlr.TerminalNode + NO_USE_MERGE() antlr.TerminalNode + NO_USE_NL() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + NO_XDB_FASTPATH_INSERT() antlr.TerminalNode + NO_XML_DML_REWRITE() antlr.TerminalNode + NO_XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode + NO_XMLINDEX_REWRITE() antlr.TerminalNode + NO_XML_QUERY_REWRITE() antlr.TerminalNode + NTH_VALUE() antlr.TerminalNode + NTILE() antlr.TerminalNode + NULLIF() antlr.TerminalNode + NULLS() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + NUM_INDEX_KEYS() antlr.TerminalNode + NUMTODSINTERVAL() antlr.TerminalNode + NUMTOYMINTERVAL() antlr.TerminalNode + NVARCHAR2() antlr.TerminalNode + NVL2() antlr.TerminalNode + NVL() antlr.TerminalNode + OBJECT2XML() antlr.TerminalNode + OBJECT() antlr.TerminalNode + OBJNO() antlr.TerminalNode + OBJNO_REUSE() antlr.TerminalNode + OCCURENCES() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + OFF() antlr.TerminalNode + OIDINDEX() antlr.TerminalNode + OID() antlr.TerminalNode + OLAP() antlr.TerminalNode + OLD() antlr.TerminalNode + OLD_PUSH_PRED() antlr.TerminalNode + OLTP() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPAQUE() antlr.TerminalNode + OPAQUE_TRANSFORM() antlr.TerminalNode + OPAQUE_XCANONICAL() antlr.TerminalNode + OPCODE() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OPT_ESTIMATE() antlr.TerminalNode + OPTIMAL() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + OPTIMIZER_FEATURES_ENABLE() antlr.TerminalNode + OPTIMIZER_GOAL() antlr.TerminalNode + OPT_PARAM() antlr.TerminalNode + ORA_BRANCH() antlr.TerminalNode + ORADEBUG() antlr.TerminalNode + ORA_DST_AFFECTED() antlr.TerminalNode + ORA_DST_CONVERT() antlr.TerminalNode + ORA_DST_ERROR() antlr.TerminalNode + ORA_GET_ACLIDS() antlr.TerminalNode + ORA_GET_PRIVILEGES() antlr.TerminalNode + ORA_HASH() antlr.TerminalNode + ORA_ROWSCN() antlr.TerminalNode + ORA_ROWSCN_RAW() antlr.TerminalNode + ORA_ROWVERSION() antlr.TerminalNode + ORA_TABVERSION() antlr.TerminalNode + ORDERED() antlr.TerminalNode + ORDERED_PREDICATES() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + OR_EXPAND() antlr.TerminalNode + ORGANIZATION() antlr.TerminalNode + OR_PREDICATES() antlr.TerminalNode + OTHER() antlr.TerminalNode + OUTER_JOIN_TO_ANTI() antlr.TerminalNode + OUTER_JOIN_TO_INNER() antlr.TerminalNode + OUTER() antlr.TerminalNode + OUTLINE_LEAF() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + OUT_OF_LINE() antlr.TerminalNode + OVERFLOW_() antlr.TerminalNode + OVERFLOW_NOMOVE() antlr.TerminalNode + OVERLAPS() antlr.TerminalNode + OVER() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + OWNER() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + OWN() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + PACKAGES() antlr.TerminalNode + PARALLEL_INDEX() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + PARAM() antlr.TerminalNode + PARENT() antlr.TerminalNode + PARITY() antlr.TerminalNode + PARTIALLY() antlr.TerminalNode + PARTITION_HASH() antlr.TerminalNode + PARTITION_LIST() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PARTITION_RANGE() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PARTNUMINST() antlr.TerminalNode + PASSING() antlr.TerminalNode + PASSWORD_GRACE_TIME() antlr.TerminalNode + PASSWORD_LIFE_TIME() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PASSWORD_REUSE_MAX() antlr.TerminalNode + PASSWORD_REUSE_TIME() antlr.TerminalNode + PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode + PATH() antlr.TerminalNode + PATHS() antlr.TerminalNode + PBL_HS_BEGIN() antlr.TerminalNode + PBL_HS_END() antlr.TerminalNode + PCTINCREASE() antlr.TerminalNode + PCTTHRESHOLD() antlr.TerminalNode + PCTUSED() antlr.TerminalNode + PCTVERSION() antlr.TerminalNode + PENDING() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + PERCENT_KEYWORD() antlr.TerminalNode + PERCENT_RANKM() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + PERMANENT() antlr.TerminalNode + PERMISSION() antlr.TerminalNode + PFILE() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + PIKEY() antlr.TerminalNode + PIV_GB() antlr.TerminalNode + PIVOT() antlr.TerminalNode + PIV_SSF() antlr.TerminalNode + PLACE_DISTINCT() antlr.TerminalNode + PLACE_GROUP_BY() antlr.TerminalNode + PLAN() antlr.TerminalNode + PLSCOPE_SETTINGS() antlr.TerminalNode + PLSQL_CCFLAGS() antlr.TerminalNode + PLSQL_CODE_TYPE() antlr.TerminalNode + PLSQL_DEBUG() antlr.TerminalNode + PLSQL_OPTIMIZE_LEVEL() antlr.TerminalNode + PLSQL_WARNINGS() antlr.TerminalNode + POINT() antlr.TerminalNode + POLICY() antlr.TerminalNode + POST_TRANSACTION() antlr.TerminalNode + POWERMULTISET_BY_CARDINALITY() antlr.TerminalNode + POWERMULTISET() antlr.TerminalNode + POWER() antlr.TerminalNode + POSITION() antlr.TerminalNode + PQ_DISTRIBUTE() antlr.TerminalNode + PQ_MAP() antlr.TerminalNode + PQ_NOMAP() antlr.TerminalNode + PREBUILT() antlr.TerminalNode + PRECEDES() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PRECISION() antlr.TerminalNode + PRECOMPUTE_SUBQUERY() antlr.TerminalNode + PREDICATE_REORDERS() antlr.TerminalNode + PREDICTION_BOUNDS() antlr.TerminalNode + PREDICTION_COST() antlr.TerminalNode + PREDICTION_DETAILS() antlr.TerminalNode + PREDICTION() antlr.TerminalNode + PREDICTION_PROBABILITY() antlr.TerminalNode + PREDICTION_SET() antlr.TerminalNode + PREPARE() antlr.TerminalNode + PRESENT() antlr.TerminalNode + PRESENTNNV() antlr.TerminalNode + PRESENTV() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + PRESERVE_OID() antlr.TerminalNode + PREVIOUS() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + PRIVATE_SGA() antlr.TerminalNode + PRIVILEGE() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROCEDURAL() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PROGRAM() antlr.TerminalNode + PROJECT() antlr.TerminalNode + PROPAGATE() antlr.TerminalNode + PROTECTED() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + PULL_PRED() antlr.TerminalNode + PURGE() antlr.TerminalNode + PUSH_PRED() antlr.TerminalNode + PUSH_SUBQ() antlr.TerminalNode + PX_GRANULE() antlr.TerminalNode + PX_JOIN_FILTER() antlr.TerminalNode + QB_NAME() antlr.TerminalNode + QUERY_BLOCK() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUEUE_CURR() antlr.TerminalNode + QUEUE() antlr.TerminalNode + QUEUE_ROWP() antlr.TerminalNode + QUIESCE() antlr.TerminalNode + QUORUM() antlr.TerminalNode + QUOTA() antlr.TerminalNode + RANDOM_LOCAL() antlr.TerminalNode + RANDOM() antlr.TerminalNode + RANGE() antlr.TerminalNode + RANKM() antlr.TerminalNode + RANK() antlr.TerminalNode + RAPIDLY() antlr.TerminalNode + RATIO_TO_REPORT() antlr.TerminalNode + RAWTOHEX() antlr.TerminalNode + RAWTONHEX() antlr.TerminalNode + RBA() antlr.TerminalNode + RBO_OUTLINE() antlr.TerminalNode + RDBA() antlr.TerminalNode + READ() antlr.TerminalNode + READS() antlr.TerminalNode + REAL() antlr.TerminalNode + REBALANCE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + RECORDS_PER_BLOCK() antlr.TerminalNode + RECOVERABLE() antlr.TerminalNode + RECOVER() antlr.TerminalNode + RECOVERY() antlr.TerminalNode + RECYCLEBIN() antlr.TerminalNode + RECYCLE() antlr.TerminalNode + REDACTION() antlr.TerminalNode + REDO() antlr.TerminalNode + REDUCED() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + REF_CASCADE_CURSOR() antlr.TerminalNode + REFERENCED() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + REFERENCING() antlr.TerminalNode + REF() antlr.TerminalNode + REFRESH() antlr.TerminalNode + REFTOHEX() antlr.TerminalNode + REGEXP_COUNT() antlr.TerminalNode + REGEXP_INSTR() antlr.TerminalNode + REGEXP_LIKE() antlr.TerminalNode + REGEXP_REPLACE() antlr.TerminalNode + REGEXP_SUBSTR() antlr.TerminalNode + REGISTER() antlr.TerminalNode + REGR_AVGX() antlr.TerminalNode + REGR_AVGY() antlr.TerminalNode + REGR_COUNT() antlr.TerminalNode + REGR_INTERCEPT() antlr.TerminalNode + REGR_R2() antlr.TerminalNode + REGR_SLOPE() antlr.TerminalNode + REGR_SXX() antlr.TerminalNode + REGR_SXY() antlr.TerminalNode + REGR_SYY() antlr.TerminalNode + REGULAR() antlr.TerminalNode + REJECT() antlr.TerminalNode + REKEY() antlr.TerminalNode + RELATIONAL() antlr.TerminalNode + RELY() antlr.TerminalNode + REMAINDER() antlr.TerminalNode + REMOTE_MAPPED() antlr.TerminalNode + REMOVE() antlr.TerminalNode + REPAIR() antlr.TerminalNode + REPEAT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + RESETLOGS() antlr.TerminalNode + RESET() antlr.TerminalNode + RESIZE() antlr.TerminalNode + RESOLVE() antlr.TerminalNode + RESOLVER() antlr.TerminalNode + RESPECT() antlr.TerminalNode + RESTORE_AS_INTERVALS() antlr.TerminalNode + RESTORE() antlr.TerminalNode + RESTRICT_ALL_REF_CONS() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + RESULT_CACHE() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETENTION() antlr.TerminalNode + RETRY_ON_ROW_CHANGE() antlr.TerminalNode + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + REUSE() antlr.TerminalNode + REVERSE() antlr.TerminalNode + REWRITE() antlr.TerminalNode + REWRITE_OR_ERROR() antlr.TerminalNode + RIGHT() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLES() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLING() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROOT() antlr.TerminalNode + ROUND() antlr.TerminalNode + ROWDEPENDENCIES() antlr.TerminalNode + ROWID() antlr.TerminalNode + ROWIDTOCHAR() antlr.TerminalNode + ROWIDTONCHAR() antlr.TerminalNode + ROW_LENGTH() antlr.TerminalNode + ROW() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + ROWNUM() antlr.TerminalNode + ROWS() antlr.TerminalNode + RPAD() antlr.TerminalNode + RTRIM() antlr.TerminalNode + RULE() antlr.TerminalNode + RULES() antlr.TerminalNode + SALT() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + SAVE_AS_INTERVALS() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + SB4() antlr.TerminalNode + SCALE() antlr.TerminalNode + SCALE_ROWS() antlr.TerminalNode + SCAN_INSTANCES() antlr.TerminalNode + SCAN() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + SCHEMACHECK() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SCN_ASCENDING() antlr.TerminalNode + SCN() antlr.TerminalNode + SCOPE() antlr.TerminalNode + SD_ALL() antlr.TerminalNode + SD_INHIBIT() antlr.TerminalNode + SD_SHOW() antlr.TerminalNode + SEARCH() antlr.TerminalNode + SECOND() antlr.TerminalNode + SECUREFILE_DBA() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SEED() antlr.TerminalNode + SEG_BLOCK() antlr.TerminalNode + SEG_FILE() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SELECTIVITY() antlr.TerminalNode + SEMIJOIN_DRIVER() antlr.TerminalNode + SEMIJOIN() antlr.TerminalNode + SEMI_TO_INNER() antlr.TerminalNode + SEQUENCED() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SEQUENTIAL() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SERVERERROR() antlr.TerminalNode + SERVICE() antlr.TerminalNode + SESSION_CACHED_CURSORS() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSIONS_PER_USER() antlr.TerminalNode + SESSIONTIMEZONE() antlr.TerminalNode + SESSIONTZNAME() antlr.TerminalNode + SETS() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + SET_TO_JOIN() antlr.TerminalNode + SEVERE() antlr.TerminalNode + SHARED() antlr.TerminalNode + SHARED_POOL() antlr.TerminalNode + SHOW() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + SIBLINGS() antlr.TerminalNode + SID() antlr.TerminalNode + SIGNAL_COMPONENT() antlr.TerminalNode + SIGNAL_FUNCTION() antlr.TerminalNode + SIGN() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SINGLE() antlr.TerminalNode + SINGLETASK() antlr.TerminalNode + SINH() antlr.TerminalNode + SIN() antlr.TerminalNode + SKIP_EXT_OPTIMIZER() antlr.TerminalNode + SKIP_() antlr.TerminalNode + SKIP_UNQ_UNUSABLE_IDX() antlr.TerminalNode + SKIP_UNUSABLE_INDEXES() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SOME() antlr.TerminalNode + SORT() antlr.TerminalNode + SOUNDEX() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + SPFILE() antlr.TerminalNode + SPLIT() antlr.TerminalNode + SPREADSHEET() antlr.TerminalNode + SQLLDR() antlr.TerminalNode + SQL() antlr.TerminalNode + SQL_TRACE() antlr.TerminalNode + SQL_MACRO() antlr.TerminalNode + SQRT() antlr.TerminalNode + STALE() antlr.TerminalNode + STANDALONE() antlr.TerminalNode + STANDBY_MAX_DATA_DELAY() antlr.TerminalNode + STANDBY() antlr.TerminalNode + STAR() antlr.TerminalNode + STAR_TRANSFORMATION() antlr.TerminalNode + STARTUP() antlr.TerminalNode + STATEMENT_ID() antlr.TerminalNode + STATEMENT_QUEUING() antlr.TerminalNode + STATEMENTS() antlr.TerminalNode + STATIC() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + STATS_BINOMIAL_TEST() antlr.TerminalNode + STATS_CROSSTAB() antlr.TerminalNode + STATS_F_TEST() antlr.TerminalNode + STATS_KS_TEST() antlr.TerminalNode + STATS_MODE() antlr.TerminalNode + STATS_MW_TEST() antlr.TerminalNode + STATS_ONE_WAY_ANOVA() antlr.TerminalNode + STATS_T_TEST_INDEP() antlr.TerminalNode + STATS_T_TEST_INDEPU() antlr.TerminalNode + STATS_T_TEST_ONE() antlr.TerminalNode + STATS_T_TEST_PAIRED() antlr.TerminalNode + STATS_WSR_TEST() antlr.TerminalNode + STDDEV() antlr.TerminalNode + STDDEV_POP() antlr.TerminalNode + STDDEV_SAMP() antlr.TerminalNode + STOP() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STORE() antlr.TerminalNode + STREAMS() antlr.TerminalNode + STRICT() antlr.TerminalNode + STRING() antlr.TerminalNode + STRIPE_COLUMNS() antlr.TerminalNode + STRIPE_WIDTH() antlr.TerminalNode + STRIP() antlr.TerminalNode + STRUCTURE() antlr.TerminalNode + SUBMULTISET() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + SUBPARTITION_REL() antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + SUBQUERIES() antlr.TerminalNode + SUBQUERY_PRUNING() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + SUBSTR2() antlr.TerminalNode + SUBSTR4() antlr.TerminalNode + SUBSTRB() antlr.TerminalNode + SUBSTRC() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + SUMMARY() antlr.TerminalNode + SUM() antlr.TerminalNode + SUPPLEMENTAL() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SWAP_JOIN_INPUTS() antlr.TerminalNode + SWITCH() antlr.TerminalNode + SWITCHOVER() antlr.TerminalNode + SYNCHRONOUS() antlr.TerminalNode + SYNC() antlr.TerminalNode + SYS() antlr.TerminalNode + SYSASM() antlr.TerminalNode + SYS_AUDIT() antlr.TerminalNode + SYSAUX() antlr.TerminalNode + SYS_CHECKACL() antlr.TerminalNode + SYS_CONNECT_BY_PATH() antlr.TerminalNode + SYS_CONTEXT() antlr.TerminalNode + SYSDATE() antlr.TerminalNode + SYSDBA() antlr.TerminalNode + SYS_DBURIGEN() antlr.TerminalNode + SYS_DL_CURSOR() antlr.TerminalNode + SYS_DM_RXFORM_CHR() antlr.TerminalNode + SYS_DM_RXFORM_NUM() antlr.TerminalNode + SYS_DOM_COMPARE() antlr.TerminalNode + SYS_DST_PRIM2SEC() antlr.TerminalNode + SYS_DST_SEC2PRIM() antlr.TerminalNode + SYS_ET_BFILE_TO_RAW() antlr.TerminalNode + SYS_ET_BLOB_TO_IMAGE() antlr.TerminalNode + SYS_ET_IMAGE_TO_BLOB() antlr.TerminalNode + SYS_ET_RAW_TO_BFILE() antlr.TerminalNode + SYS_EXTPDTXT() antlr.TerminalNode + SYS_EXTRACT_UTC() antlr.TerminalNode + SYS_FBT_INSDEL() antlr.TerminalNode + SYS_FILTER_ACLS() antlr.TerminalNode + SYS_FNMATCHES() antlr.TerminalNode + SYS_FNREPLACE() antlr.TerminalNode + SYS_GET_ACLIDS() antlr.TerminalNode + SYS_GET_PRIVILEGES() antlr.TerminalNode + SYS_GETTOKENID() antlr.TerminalNode + SYS_GETXTIVAL() antlr.TerminalNode + SYS_GUID() antlr.TerminalNode + SYS_MAKEXML() antlr.TerminalNode + SYS_MAKE_XMLNODEID() antlr.TerminalNode + SYS_MKXMLATTR() antlr.TerminalNode + SYS_OP_ADT2BIN() antlr.TerminalNode + SYS_OP_ADTCONS() antlr.TerminalNode + SYS_OP_ALSCRVAL() antlr.TerminalNode + SYS_OP_ATG() antlr.TerminalNode + SYS_OP_BIN2ADT() antlr.TerminalNode + SYS_OP_BITVEC() antlr.TerminalNode + SYS_OP_BL2R() antlr.TerminalNode + SYS_OP_BLOOM_FILTER_LIST() antlr.TerminalNode + SYS_OP_BLOOM_FILTER() antlr.TerminalNode + SYS_OP_C2C() antlr.TerminalNode + SYS_OP_CAST() antlr.TerminalNode + SYS_OP_CEG() antlr.TerminalNode + SYS_OP_CL2C() antlr.TerminalNode + SYS_OP_COMBINED_HASH() antlr.TerminalNode + SYS_OP_COMP() antlr.TerminalNode + SYS_OP_CONVERT() antlr.TerminalNode + SYS_OP_COUNTCHG() antlr.TerminalNode + SYS_OP_CSCONV() antlr.TerminalNode + SYS_OP_CSCONVTEST() antlr.TerminalNode + SYS_OP_CSR() antlr.TerminalNode + SYS_OP_CSX_PATCH() antlr.TerminalNode + SYS_OP_DECOMP() antlr.TerminalNode + SYS_OP_DESCEND() antlr.TerminalNode + SYS_OP_DISTINCT() antlr.TerminalNode + SYS_OP_DRA() antlr.TerminalNode + SYS_OP_DUMP() antlr.TerminalNode + SYS_OP_DV_CHECK() antlr.TerminalNode + SYS_OP_ENFORCE_NOT_NULL() antlr.TerminalNode + SYSOPER() antlr.TerminalNode + SYS_OP_EXTRACT() antlr.TerminalNode + SYS_OP_GROUPING() antlr.TerminalNode + SYS_OP_GUID() antlr.TerminalNode + SYS_OP_IIX() antlr.TerminalNode + SYS_OP_ITR() antlr.TerminalNode + SYS_OP_LBID() antlr.TerminalNode + SYS_OP_LOBLOC2BLOB() antlr.TerminalNode + SYS_OP_LOBLOC2CLOB() antlr.TerminalNode + SYS_OP_LOBLOC2ID() antlr.TerminalNode + SYS_OP_LOBLOC2NCLOB() antlr.TerminalNode + SYS_OP_LOBLOC2TYP() antlr.TerminalNode + SYS_OP_LSVI() antlr.TerminalNode + SYS_OP_LVL() antlr.TerminalNode + SYS_OP_MAKEOID() antlr.TerminalNode + SYS_OP_MAP_NONNULL() antlr.TerminalNode + SYS_OP_MSR() antlr.TerminalNode + SYS_OP_NICOMBINE() antlr.TerminalNode + SYS_OP_NIEXTRACT() antlr.TerminalNode + SYS_OP_NII() antlr.TerminalNode + SYS_OP_NIX() antlr.TerminalNode + SYS_OP_NOEXPAND() antlr.TerminalNode + SYS_OP_NTCIMG() antlr.TerminalNode + SYS_OP_NUMTORAW() antlr.TerminalNode + SYS_OP_OIDVALUE() antlr.TerminalNode + SYS_OP_OPNSIZE() antlr.TerminalNode + SYS_OP_PAR_1() antlr.TerminalNode + SYS_OP_PARGID_1() antlr.TerminalNode + SYS_OP_PARGID() antlr.TerminalNode + SYS_OP_PAR() antlr.TerminalNode + SYS_OP_PIVOT() antlr.TerminalNode + SYS_OP_R2O() antlr.TerminalNode + SYS_OP_RAWTONUM() antlr.TerminalNode + SYS_OP_RDTM() antlr.TerminalNode + SYS_OP_REF() antlr.TerminalNode + SYS_OP_RMTD() antlr.TerminalNode + SYS_OP_ROWIDTOOBJ() antlr.TerminalNode + SYS_OP_RPB() antlr.TerminalNode + SYS_OPTLOBPRBSC() antlr.TerminalNode + SYS_OP_TOSETID() antlr.TerminalNode + SYS_OP_TPR() antlr.TerminalNode + SYS_OP_TRTB() antlr.TerminalNode + SYS_OPTXICMP() antlr.TerminalNode + SYS_OPTXQCASTASNQ() antlr.TerminalNode + SYS_OP_UNDESCEND() antlr.TerminalNode + SYS_OP_VECAND() antlr.TerminalNode + SYS_OP_VECBIT() antlr.TerminalNode + SYS_OP_VECOR() antlr.TerminalNode + SYS_OP_VECXOR() antlr.TerminalNode + SYS_OP_VERSION() antlr.TerminalNode + SYS_OP_VREF() antlr.TerminalNode + SYS_OP_VVD() antlr.TerminalNode + SYS_OP_XMLCONS_FOR_CSX() antlr.TerminalNode + SYS_OP_XPTHATG() antlr.TerminalNode + SYS_OP_XPTHIDX() antlr.TerminalNode + SYS_OP_XPTHOP() antlr.TerminalNode + SYS_OP_XTXT2SQLT() antlr.TerminalNode + SYS_ORDERKEY_DEPTH() antlr.TerminalNode + SYS_ORDERKEY_MAXCHILD() antlr.TerminalNode + SYS_ORDERKEY_PARENT() antlr.TerminalNode + SYS_PARALLEL_TXN() antlr.TerminalNode + SYS_PATHID_IS_ATTR() antlr.TerminalNode + SYS_PATHID_IS_NMSPC() antlr.TerminalNode + SYS_PATHID_LASTNAME() antlr.TerminalNode + SYS_PATHID_LASTNMSPC() antlr.TerminalNode + SYS_PATH_REVERSE() antlr.TerminalNode + SYS_PXQEXTRACT() antlr.TerminalNode + SYS_RID_ORDER() antlr.TerminalNode + SYS_ROW_DELTA() antlr.TerminalNode + SYS_SC_2_XMLT() antlr.TerminalNode + SYS_SYNRCIREDO() antlr.TerminalNode + SYSTEM_DEFINED() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + SYSTIMESTAMP() antlr.TerminalNode + SYS_TYPEID() antlr.TerminalNode + SYS_UMAKEXML() antlr.TerminalNode + SYS_XMLANALYZE() antlr.TerminalNode + SYS_XMLCONTAINS() antlr.TerminalNode + SYS_XMLCONV() antlr.TerminalNode + SYS_XMLEXNSURI() antlr.TerminalNode + SYS_XMLGEN() antlr.TerminalNode + SYS_XMLI_LOC_ISNODE() antlr.TerminalNode + SYS_XMLI_LOC_ISTEXT() antlr.TerminalNode + SYS_XMLINSTR() antlr.TerminalNode + SYS_XMLLOCATOR_GETSVAL() antlr.TerminalNode + SYS_XMLNODEID_GETCID() antlr.TerminalNode + SYS_XMLNODEID_GETLOCATOR() antlr.TerminalNode + SYS_XMLNODEID_GETOKEY() antlr.TerminalNode + SYS_XMLNODEID_GETPATHID() antlr.TerminalNode + SYS_XMLNODEID_GETPTRID() antlr.TerminalNode + SYS_XMLNODEID_GETRID() antlr.TerminalNode + SYS_XMLNODEID_GETSVAL() antlr.TerminalNode + SYS_XMLNODEID_GETTID() antlr.TerminalNode + SYS_XMLNODEID() antlr.TerminalNode + SYS_XMLT_2_SC() antlr.TerminalNode + SYS_XMLTRANSLATE() antlr.TerminalNode + SYS_XMLTYPE2SQL() antlr.TerminalNode + SYS_XQ_ASQLCNV() antlr.TerminalNode + SYS_XQ_ATOMCNVCHK() antlr.TerminalNode + SYS_XQBASEURI() antlr.TerminalNode + SYS_XQCASTABLEERRH() antlr.TerminalNode + SYS_XQCODEP2STR() antlr.TerminalNode + SYS_XQCODEPEQ() antlr.TerminalNode + SYS_XQCON2SEQ() antlr.TerminalNode + SYS_XQCONCAT() antlr.TerminalNode + SYS_XQDELETE() antlr.TerminalNode + SYS_XQDFLTCOLATION() antlr.TerminalNode + SYS_XQDOC() antlr.TerminalNode + SYS_XQDOCURI() antlr.TerminalNode + SYS_XQDURDIV() antlr.TerminalNode + SYS_XQED4URI() antlr.TerminalNode + SYS_XQENDSWITH() antlr.TerminalNode + SYS_XQERRH() antlr.TerminalNode + SYS_XQERR() antlr.TerminalNode + SYS_XQESHTMLURI() antlr.TerminalNode + SYS_XQEXLOBVAL() antlr.TerminalNode + SYS_XQEXSTWRP() antlr.TerminalNode + SYS_XQEXTRACT() antlr.TerminalNode + SYS_XQEXTRREF() antlr.TerminalNode + SYS_XQEXVAL() antlr.TerminalNode + SYS_XQFB2STR() antlr.TerminalNode + SYS_XQFNBOOL() antlr.TerminalNode + SYS_XQFNCMP() antlr.TerminalNode + SYS_XQFNDATIM() antlr.TerminalNode + SYS_XQFNLNAME() antlr.TerminalNode + SYS_XQFNNM() antlr.TerminalNode + SYS_XQFNNSURI() antlr.TerminalNode + SYS_XQFNPREDTRUTH() antlr.TerminalNode + SYS_XQFNQNM() antlr.TerminalNode + SYS_XQFNROOT() antlr.TerminalNode + SYS_XQFORMATNUM() antlr.TerminalNode + SYS_XQFTCONTAIN() antlr.TerminalNode + SYS_XQFUNCR() antlr.TerminalNode + SYS_XQGETCONTENT() antlr.TerminalNode + SYS_XQINDXOF() antlr.TerminalNode + SYS_XQINSERT() antlr.TerminalNode + SYS_XQINSPFX() antlr.TerminalNode + SYS_XQIRI2URI() antlr.TerminalNode + SYS_XQLANG() antlr.TerminalNode + SYS_XQLLNMFRMQNM() antlr.TerminalNode + SYS_XQMKNODEREF() antlr.TerminalNode + SYS_XQNILLED() antlr.TerminalNode + SYS_XQNODENAME() antlr.TerminalNode + SYS_XQNORMSPACE() antlr.TerminalNode + SYS_XQNORMUCODE() antlr.TerminalNode + SYS_XQ_NRNG() antlr.TerminalNode + SYS_XQNSP4PFX() antlr.TerminalNode + SYS_XQNSPFRMQNM() antlr.TerminalNode + SYS_XQPFXFRMQNM() antlr.TerminalNode + SYS_XQ_PKSQL2XML() antlr.TerminalNode + SYS_XQPOLYABS() antlr.TerminalNode + SYS_XQPOLYADD() antlr.TerminalNode + SYS_XQPOLYCEL() antlr.TerminalNode + SYS_XQPOLYCSTBL() antlr.TerminalNode + SYS_XQPOLYCST() antlr.TerminalNode + SYS_XQPOLYDIV() antlr.TerminalNode + SYS_XQPOLYFLR() antlr.TerminalNode + SYS_XQPOLYMOD() antlr.TerminalNode + SYS_XQPOLYMUL() antlr.TerminalNode + SYS_XQPOLYRND() antlr.TerminalNode + SYS_XQPOLYSQRT() antlr.TerminalNode + SYS_XQPOLYSUB() antlr.TerminalNode + SYS_XQPOLYUMUS() antlr.TerminalNode + SYS_XQPOLYUPLS() antlr.TerminalNode + SYS_XQPOLYVEQ() antlr.TerminalNode + SYS_XQPOLYVGE() antlr.TerminalNode + SYS_XQPOLYVGT() antlr.TerminalNode + SYS_XQPOLYVLE() antlr.TerminalNode + SYS_XQPOLYVLT() antlr.TerminalNode + SYS_XQPOLYVNE() antlr.TerminalNode + SYS_XQREF2VAL() antlr.TerminalNode + SYS_XQRENAME() antlr.TerminalNode + SYS_XQREPLACE() antlr.TerminalNode + SYS_XQRESVURI() antlr.TerminalNode + SYS_XQRNDHALF2EVN() antlr.TerminalNode + SYS_XQRSLVQNM() antlr.TerminalNode + SYS_XQRYENVPGET() antlr.TerminalNode + SYS_XQRYVARGET() antlr.TerminalNode + SYS_XQRYWRP() antlr.TerminalNode + SYS_XQSEQ2CON4XC() antlr.TerminalNode + SYS_XQSEQ2CON() antlr.TerminalNode + SYS_XQSEQDEEPEQ() antlr.TerminalNode + SYS_XQSEQINSB() antlr.TerminalNode + SYS_XQSEQRM() antlr.TerminalNode + SYS_XQSEQRVS() antlr.TerminalNode + SYS_XQSEQSUB() antlr.TerminalNode + SYS_XQSEQTYPMATCH() antlr.TerminalNode + SYS_XQSTARTSWITH() antlr.TerminalNode + SYS_XQSTATBURI() antlr.TerminalNode + SYS_XQSTR2CODEP() antlr.TerminalNode + SYS_XQSTRJOIN() antlr.TerminalNode + SYS_XQSUBSTRAFT() antlr.TerminalNode + SYS_XQSUBSTRBEF() antlr.TerminalNode + SYS_XQTOKENIZE() antlr.TerminalNode + SYS_XQTREATAS() antlr.TerminalNode + SYS_XQ_UPKXML2SQL() antlr.TerminalNode + SYS_XQXFORM() antlr.TerminalNode + TABLE() antlr.TerminalNode + TABLE_LOOKUP_BY_NL() antlr.TerminalNode + TABLES() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TABLESPACE_NO() antlr.TerminalNode + TABLE_STATS() antlr.TerminalNode + TABNO() antlr.TerminalNode + TANH() antlr.TerminalNode + TAN() antlr.TerminalNode + TBLORIDXPARTNUM() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + TEMPLATE_TABLE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEMP_TABLE() antlr.TerminalNode + TEST() antlr.TerminalNode + THAN() antlr.TerminalNode + THE() antlr.TerminalNode + THEN() antlr.TerminalNode + THREAD() antlr.TerminalNode + THROUGH() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMING() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + TIMES() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + TIMEZONE_ABBR() antlr.TerminalNode + TIMEZONE_HOUR() antlr.TerminalNode + TIMEZONE_MINUTE() antlr.TerminalNode + TIME_ZONE() antlr.TerminalNode + TIMEZONE_OFFSET() antlr.TerminalNode + TIMEZONE_REGION() antlr.TerminalNode + TIV_GB() antlr.TerminalNode + TIV_SSF() antlr.TerminalNode + TO_BINARY_DOUBLE() antlr.TerminalNode + TO_BINARY_FLOAT() antlr.TerminalNode + TO_BLOB() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + TO_CLOB() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + TO_DSINTERVAL() antlr.TerminalNode + TO_LOB() antlr.TerminalNode + TO_MULTI_BYTE() antlr.TerminalNode + TO_NCHAR() antlr.TerminalNode + TO_NCLOB() antlr.TerminalNode + TO_NUMBER() antlr.TerminalNode + TOPLEVEL() antlr.TerminalNode + TO_SINGLE_BYTE() antlr.TerminalNode + TO_TIME() antlr.TerminalNode + TO_TIMESTAMP() antlr.TerminalNode + TO_TIMESTAMP_TZ() antlr.TerminalNode + TO_TIME_TZ() antlr.TerminalNode + TO_YMINTERVAL() antlr.TerminalNode + TRACE() antlr.TerminalNode + TRACING() antlr.TerminalNode + TRACKING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TRANSFORM_DISTINCT_AGG() antlr.TerminalNode + TRANSITIONAL() antlr.TerminalNode + TRANSITION() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + TREAT() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + TRIM() antlr.TerminalNode + TRUE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + TRUNC() antlr.TerminalNode + TRUSTED() antlr.TerminalNode + TUNING() antlr.TerminalNode + TX() antlr.TerminalNode + TYPE() antlr.TerminalNode + TYPES() antlr.TerminalNode + TZ_OFFSET() antlr.TerminalNode + UB2() antlr.TerminalNode + UBA() antlr.TerminalNode + UID() antlr.TerminalNode + UNARCHIVED() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNBOUND() antlr.TerminalNode + UNDER() antlr.TerminalNode + UNDO() antlr.TerminalNode + UNDROP() antlr.TerminalNode + UNIFORM() antlr.TerminalNode + UNISTR() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + UNLOAD() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + UNNEST_INNERJ_DISTINCT_VIEW() antlr.TerminalNode + UNNEST() antlr.TerminalNode + UNNEST_NOSEMIJ_NODISTINCTVIEW() antlr.TerminalNode + UNNEST_SEMIJ_VIEW() antlr.TerminalNode + UNPACKED() antlr.TerminalNode + UNPIVOT() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + UNQUIESCE() antlr.TerminalNode + UNRECOVERABLE() antlr.TerminalNode + UNRESTRICTED() antlr.TerminalNode + UNTIL() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + UNUSED() antlr.TerminalNode + UPDATABLE() antlr.TerminalNode + UPDATED() antlr.TerminalNode + UPDATEXML() antlr.TerminalNode + UPD_INDEXES() antlr.TerminalNode + UPD_JOININDEX() antlr.TerminalNode + UPGRADE() antlr.TerminalNode + UPPER() antlr.TerminalNode + UPSERT() antlr.TerminalNode + UROWID() antlr.TerminalNode + USAGE() antlr.TerminalNode + USE_ANTI() antlr.TerminalNode + USE_CONCAT() antlr.TerminalNode + USE_HASH_AGGREGATION() antlr.TerminalNode + USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode + USE_HASH() antlr.TerminalNode + USE_INVISIBLE_INDEXES() antlr.TerminalNode + USE_MERGE_CARTESIAN() antlr.TerminalNode + USE_MERGE() antlr.TerminalNode + USE() antlr.TerminalNode + USE_NL() antlr.TerminalNode + USE_NL_WITH_INDEX() antlr.TerminalNode + USE_PRIVATE_OUTLINES() antlr.TerminalNode + USER_DEFINED() antlr.TerminalNode + USERENV() antlr.TerminalNode + USERGROUP() antlr.TerminalNode + USER() antlr.TerminalNode + USER_RECYCLEBIN() antlr.TerminalNode + USERS() antlr.TerminalNode + USE_SEMI() antlr.TerminalNode + USE_STORED_OUTLINES() antlr.TerminalNode + USE_TTT_FOR_GSETS() antlr.TerminalNode + USE_WEAK_NAME_RESL() antlr.TerminalNode + USING() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + VALUE() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + VAR_POP() antlr.TerminalNode + VARRAY() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + VAR_SAMP() antlr.TerminalNode + VARYING() antlr.TerminalNode + VECTOR_READ() antlr.TerminalNode + VECTOR_READ_TRACE() antlr.TerminalNode + VERIFY() antlr.TerminalNode + VERSIONING() antlr.TerminalNode + VERSION() antlr.TerminalNode + VERSIONS_ENDSCN() antlr.TerminalNode + VERSIONS_ENDTIME() antlr.TerminalNode + VERSIONS() antlr.TerminalNode + VERSIONS_OPERATION() antlr.TerminalNode + VERSIONS_STARTSCN() antlr.TerminalNode + VERSIONS_STARTTIME() antlr.TerminalNode + VERSIONS_XID() antlr.TerminalNode + VIRTUAL() antlr.TerminalNode + VISIBLE() antlr.TerminalNode + VOLUME() antlr.TerminalNode + VSIZE() antlr.TerminalNode + WAIT() antlr.TerminalNode + WALLET() antlr.TerminalNode + WELLFORMED() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + WHEN() antlr.TerminalNode + WHITESPACE() antlr.TerminalNode + WIDTH_BUCKET() antlr.TerminalNode + WITHIN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WORK() antlr.TerminalNode + WRAPPED() antlr.TerminalNode + WRITE() antlr.TerminalNode + XDB_FASTPATH_INSERT() antlr.TerminalNode + X_DYN_PRUNE() antlr.TerminalNode + XID() antlr.TerminalNode + XML2OBJECT() antlr.TerminalNode + XMLATTRIBUTES() antlr.TerminalNode + XMLCAST() antlr.TerminalNode + XMLCDATA() antlr.TerminalNode + XMLCOLATTVAL() antlr.TerminalNode + XMLCOMMENT() antlr.TerminalNode + XMLCONCAT() antlr.TerminalNode + XMLDIFF() antlr.TerminalNode + XML_DML_RWT_STMT() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + XMLEXISTS2() antlr.TerminalNode + XMLEXISTS() antlr.TerminalNode + XMLFOREST() antlr.TerminalNode + XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode + XMLINDEX_REWRITE() antlr.TerminalNode + XMLINDEX_SEL_IDX_TBL() antlr.TerminalNode + XMLISNODE() antlr.TerminalNode + XMLISVALID() antlr.TerminalNode + XML() antlr.TerminalNode + XMLNAMESPACES() antlr.TerminalNode + XMLPARSE() antlr.TerminalNode + XMLPATCH() antlr.TerminalNode + XMLPI() antlr.TerminalNode + XMLQUERY() antlr.TerminalNode + XMLQUERYVAL() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + XMLSERIALIZE() antlr.TerminalNode + XMLTABLE() antlr.TerminalNode + XMLTRANSFORMBLOB() antlr.TerminalNode + XMLTRANSFORM() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + XPATHTABLE() antlr.TerminalNode + XS_SYS_CONTEXT() antlr.TerminalNode + YEAR() antlr.TerminalNode + YES() antlr.TerminalNode + ZONE() antlr.TerminalNode + + // IsNon_reserved_keywords_pre12cContext differentiates from other interfaces. + IsNon_reserved_keywords_pre12cContext() +} + +type Non_reserved_keywords_pre12cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_keywords_pre12cContext() *Non_reserved_keywords_pre12cContext { + var p = new(Non_reserved_keywords_pre12cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c + return p +} + +func InitEmptyNon_reserved_keywords_pre12cContext(p *Non_reserved_keywords_pre12cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c +} + +func (*Non_reserved_keywords_pre12cContext) IsNon_reserved_keywords_pre12cContext() {} + +func NewNon_reserved_keywords_pre12cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_keywords_pre12cContext { + var p = new(Non_reserved_keywords_pre12cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c + + return p +} + +func (s *Non_reserved_keywords_pre12cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_keywords_pre12cContext) ABORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ABS() antlr.TerminalNode { + return s.GetToken(PlSqlParserABS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCESSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACOS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACOS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_COMPONENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_TAG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_COLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_GROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_MONTHS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADJ_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADJ_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMINISTRATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTRATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADVISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADVISOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALIAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALIAS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALL_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AND_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND_EQUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANTIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserANTIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPENDCHILDXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPENDCHILDXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPEND_VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND_VALUES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASCIISTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCIISTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserASIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSEMBLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNCHRONOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATAN2() antlr.TerminalNode { + return s.GetToken(PlSqlParserATAN2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserATAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHORIZATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOEXTEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BASIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BECOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBECOME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEGIN_OUTLINE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN_OUTLINE_DATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEHALF() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEHALF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BFILENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE_INFINITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE_INFINITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE_NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE_NAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT_INFINITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT_INFINITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT_NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT_NAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIND_AWARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIND_AWARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIN_TO_NUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIN_TO_NUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAP_TREE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP_TREE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCK_RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK_RANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BRANCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBRANCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BREADTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBREADTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BROADCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserBROADCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER_POOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_POOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYPASS_RECURSIVE_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYPASS_RECURSIVE_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYPASS_UJVC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYPASS_UJVC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_CB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_CB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_INSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_TEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CARDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCARDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CEIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCEIL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CELL_FLASH_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCELL_FLASH_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCERTIFICATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHANGE_DUPKEY_ERROR_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_CS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHARTOROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARTOROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHECK_ACL_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK_ACL_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECKPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHOOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHOOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHUNK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHUNK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOSE_CACHED_OPEN_CURSORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE_CACHED_OPEN_CURSORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTERING_FACTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING_FACTOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_PROBABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COALESCE_SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE_SQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOARSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CO_AUTH_IND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCO_AUTH_IND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMNAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_AUTH_INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_AUTH_INDICATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMITTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPATIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPATIBILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPLETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPLIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLIANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE_LIMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONFIRM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONFIRM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONFORMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONFORMING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_CB_WHR_ONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_COMBINE_SW() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_COMBINE_SW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_COST_BASED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_COST_BASED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ELIM_DUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ELIM_DUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ISCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ISCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ISLEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ISLEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSIDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSIDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR_K() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR_K, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR_S() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR_S, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPT_XID_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID_ALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPT_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COSH() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOSH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COST_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COVAR_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COVAR_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_CALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CRASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CREATE_STORED_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE_STORED_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CROSSEDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSSEDITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CSCONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCSCONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUBE_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUME_DISTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DISTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_SCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENTV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENTV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR_SHARING_EXACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR_SHARING_EXACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR_SPECIFIC_SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR_SPECIFIC_SEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DANGLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDANGLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAOBJNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAOBJ_TO_PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJ_TO_PARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATE_MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_MODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBLINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBLINK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBMS_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBMS_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DB_ROLE_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_ROLE_CHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBTIMEZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DB_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEBUGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUGGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECOMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECOMPOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECREMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECR() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEDUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEDUPLICATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEGREE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEGREE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DELETEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEMAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DENSE_RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEPENDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPENDENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEQUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEREF_NO_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEREF_NO_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DETACHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETACHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DETERMINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDICTIONARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECT_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_LOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE_PRESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_PRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE_RPKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_RPKE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISALLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISCONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCONNECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISTINGUISHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINGUISHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DML_UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML_UPDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOCFIDELITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCFIDELITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCUMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_NO_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_NO_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOWNGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOWNGRADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DRIVING_SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDRIVING_SITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DROP_COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP_COLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DROP_GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP_GROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DST_UPGRADE_INSERT_CONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDST_UPGRADE_INSERT_CONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC_SAMPLING_EST_CDN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC_SAMPLING_EST_CDN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC_SAMPLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC_SAMPLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EACH() antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_OBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_OBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY_CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENABLE_PRESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_PRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCODING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCODING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) END_OUTLINE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND_OUTLINE_DATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENQUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTERPRISE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTRY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR_ARGUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_ARGUMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR_ON_OVERLAP_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_ON_OVERLAP_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESCAPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ESTIMATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESTIMATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVALUATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXEMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXEMPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXISTSNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTSNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPAND_GSET_TO_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPAND_GSET_TO_UNION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPAND_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPAND_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPIRE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPLOSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLOSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPR_CORR_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPR_CORR_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRACTVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACTVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACTORIZE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACTORIZE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FBTSCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFBTSCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESYSTEM_LIKE_LOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRSTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRSTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLAGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLAGGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLASH_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASH_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLOOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLUSH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLUSH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORCE_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOREVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORWARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORWARD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FRAGMENT_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRAGMENT_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREELIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREELISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELISTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREEPOOLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRESH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FROM_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL_OUTER_JOIN_TO_OUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GATHER_PLAN_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGATHER_PLAN_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GBY_CONC_ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGBY_CONC_ROLLUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GBY_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserGBY_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL_TOPIC_ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_TOPIC_ENABLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GREATEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUP_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPING_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARANTEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASHKEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHKEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEADER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HELP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHELP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEXTORAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEXTORAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEXTOREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEXTOREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIDDEN_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDDEN_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HINTSET_BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserHINTSET_BEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HINTSET_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserHINTSET_END, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HWM_BROKERED() antlr.TerminalNode { + return s.GetToken(PlSqlParserHWM_BROKERED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HYBRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserHYBRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDGENERATORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDGENERATORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDLE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_OPTIM_EMBEDDED_HINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_ROW_ON_DUPKEY_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_WHERE_CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_WHERE_CLAUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDE_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENTAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_COMBINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_COMBINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_FFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_FFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RRS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RRS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SKIP_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SKIP_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INFINITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFINITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INFORMATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFORMATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITCAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITCAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALIZED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITRANS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITRANS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INLINE_XMLTYPE_NT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE_XMLTYPE_NT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IN_MEMORY_METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN_MEMORY_METADATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXMLAFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXMLAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXMLBEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXMLBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTXMLAFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTXMLAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTXMLBEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTXMLBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANTLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTEAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR4() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTRB() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTRB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTRC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTRC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERMEDIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERNAL_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERNAL_USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL_USE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERPRETED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERPRETED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IN_XQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN_XQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ISOLATION_LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION_LEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ITERATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ITERATION_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATION_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEEP_DUPLICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP_DUPLICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KERBEROS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKERBEROS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEY_LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY_LENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEYSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KILL() antlr.TerminalNode { + return s.GetToken(PlSqlParserKILL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST_DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_DAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LATERAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLATERAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAYER() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAYER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REGISTRATION_ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REGISTRATION_ENABLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REGISTRATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REGISTRATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REG_SYNC_INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REG_SYNC_INTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTHB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTHB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTHC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTHC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIFE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIFETIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFETIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLISTAGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LNNVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLNNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOBNVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCAL_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCALTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCALTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL_READS_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_CALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL_READS_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGOFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGOFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGON() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOG_READ_ONLY_VIOLATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG_READ_ONLY_VIOLATIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LPAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLPAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAKE_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAKE_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MASTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXARCHLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXARCHLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXDATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXEXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXINSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXTRANS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXTRANS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGEACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGEACTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_CONST_ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_CONST_ON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) METHOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETHOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIGRATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINEXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINUS_NULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_NULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRRORCOLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRRORCOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRRORHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRRORHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MLSLABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMLSLABEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_COMPILE_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_COMPILE_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_DONTVERIFY_UNIQUENESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_DYNAMIC_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_DYNAMIC_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_MIN_ANALYSIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_MIN_ANALYSIS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_NO_ANALYSIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_NO_ANALYSIS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_PBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_PBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_PUSH_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_PUSH_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODIFY_COLUMN_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY_COLUMN_TYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONITOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONTHS_BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS_BETWEEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOUNTPATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MV_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMV_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAN_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAN_, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NANVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNANVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIVE_FULL_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEEDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEEDED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_FAST_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_FAST_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_GET_REFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_GET_REFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_SET_REFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_SET_REFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_SET_SETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_SET_SETID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEW_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEXT_DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT_DAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NL_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNL_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_BATCHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_BATCHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_INDEX_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_INDEX_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_PREFETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_PREFETCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CALENDAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CALENDAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARACTERSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_DECL_LEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_DECL_LEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_COMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CURRENCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CURRENCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_DATE_FORMAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_DATE_LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_DATE_LANGUAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_INITCAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_INITCAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_ISO_CURRENCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_ISO_CURRENCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NL_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNL_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LANG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LANG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LANGUAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LENGTH_SEMANTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LENGTH_SEMANTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LOWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_NCHAR_CONV_EXCP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_NCHAR_CONV_EXCP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_NUMERIC_CHARACTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_NUMERIC_CHARACTERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLSSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLSSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_SPECIAL_CHARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_SPECIAL_CHARS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_TERRITORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_TERRITORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_UPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_UPPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ACCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOAPPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAPPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BASETABLE_MULTIMV_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BIND_AWARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BIND_AWARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BUFFER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BUFFER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CARTESIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CARTESIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CHECK_ACL_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CHECK_ACL_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CLUSTER_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CLUSTER_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_COALESCE_SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COALESCE_SQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_COMBINE_SW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_COMBINE_SW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_COST_BASED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_COST_BASED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_ELIM_DUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_ELIM_DUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_COST_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COST_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NODELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_DOMAIN_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DOMAIN_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_DST_UPGRADE_INSERT_CONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DST_UPGRADE_INSERT_CONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_OBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_OBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND_GSET_TO_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND_GSET_TO_UNION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FACTORIZE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FACTORIZE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_GBY_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_GBY_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOGUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOGUARANTEE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX_FFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX_FFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX_SS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX_SS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_LOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOLOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAPPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MODEL_PUSH_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MODEL_PUSH_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MONITOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MONITOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MULTIMV_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MULTIMV_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONBLOCKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONBLOCKING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NLJ_BATCHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NLJ_BATCHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NLJ_PREFETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NLJ_PREFETCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ORDER_ROLLUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ORDER_ROLLUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_OUTER_JOIN_TO_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OUTER_JOIN_TO_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_OUTER_JOIN_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OUTER_JOIN_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOOVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOOVERRIDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOPARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOPARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARTIAL_COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_COMMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PLACE_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PLACE_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PLACE_GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PLACE_GROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PQ_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_MAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PRUNE_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PRUNE_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PULL_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PULL_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PUSH_SUBQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PUSH_SUBQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PX_JOIN_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PX_JOIN_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_QKN_BUFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_QKN_BUFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_QUERY_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_QUERY_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_REF_CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_REF_CASCADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_RESULT_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCHEMACHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SEMIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SEMIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SEMI_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SEMI_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SET_TO_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SET_TO_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SQL_TUNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SQL_TUNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STAR_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STAR_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STATEMENT_QUEUING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STATEMENT_QUEUING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STATS_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STATS_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSTRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SUBQUERY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SUBQUERY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SUBSTRB_PAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SUBSTRB_PAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SWAP_JOIN_INPUTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SWAP_JOIN_INPUTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSWITCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TABLE_LOOKUP_BY_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TABLE_LOOKUP_BY_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOTHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTIFICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TRANSFORM_DISTINCT_AGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TRANSFORM_DISTINCT_AGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_UNNEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_UNNEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_INVISIBLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_INVISIBLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XDB_FASTPATH_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XDB_FASTPATH_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XML_DML_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XML_DML_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XMLINDEX_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XMLINDEX_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NTH_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTH_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NTILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMERIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUM_INDEX_KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUM_INDEX_KEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMTODSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMTODSINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMTOYMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMTOYMINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVARCHAR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVL2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJECT2XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT2XML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJNO_REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJNO_REUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OCCURENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserOCCURENCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OIDINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserOIDINDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLD_PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD_PUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE_XCANONICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE_XCANONICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPCODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPCODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPT_ESTIMATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPT_ESTIMATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZER_FEATURES_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZER_FEATURES_ENABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZER_GOAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZER_GOAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPT_PARAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPT_PARAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_BRANCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_BRANCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORADEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_AFFECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_AFFECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_ERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_GET_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_GET_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_GET_PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_GET_PRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWSCN_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWSCN_RAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_TABVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_TABVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDERED() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDERED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDERED_PREDICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDERED_PREDICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OR_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORGANIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORGANIZATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OR_PREDICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR_PREDICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OTHER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOTHER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER_JOIN_TO_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER_JOIN_TO_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER_JOIN_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER_JOIN_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTLINE_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE_LEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUT_OF_LINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT_OF_LINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERFLOW_() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERFLOW_NOMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_NOMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERLAPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERLAPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNERSHIP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTIALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_LIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_RANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTNUMINST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTNUMINST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_GRACE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_GRACE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_LIFE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LIFE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_REUSE_MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_MAX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_REUSE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_VERIFY_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PATHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATHS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PBL_HS_BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPBL_HS_BEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PBL_HS_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserPBL_HS_END, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTINCREASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTINCREASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTTHRESHOLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTTHRESHOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PENDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPENDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_CONT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_DISC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERMANENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMANENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERMISSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMISSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIV_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIV_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIV_SSF() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIV_SSF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLACE_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLACE_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLACE_GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLACE_GROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSCOPE_SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSCOPE_SETTINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_CCFLAGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_CCFLAGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_CODE_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_CODE_TYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_DEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_OPTIMIZE_LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_OPTIMIZE_LEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_WARNINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_WARNINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POST_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOST_TRANSACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWERMULTISET_BY_CARDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWERMULTISET_BY_CARDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWERMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWERMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_DISTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_MAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_NOMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_NOMAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREBUILT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREBUILT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECEDES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECOMPUTE_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECOMPUTE_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICATE_REORDERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICATE_REORDERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_BOUNDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_BOUNDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_COST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_DETAILS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_PROBABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENTNNV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENTNNV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENTV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENTV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESERVE_OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE_OID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREVIOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREVIOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVATE_SGA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROGRAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROPAGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPAGATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PULL_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPULL_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PUSH_SUBQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUSH_SUBQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PX_GRANULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_GRANULE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PX_JOIN_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_JOIN_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QB_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserQB_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUERY_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE_CURR() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE_CURR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE_ROWP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE_ROWP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUIESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUIESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUORUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUORUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANDOM_LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANDOM_LOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANDOM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANDOM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAPIDLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAPIDLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RATIO_TO_REPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRATIO_TO_REPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAWTOHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAWTOHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAWTONHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAWTONHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserRBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RBO_OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRBO_OUTLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserRDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) READS() antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBALANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECORDS_PER_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS_PER_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVERABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDUCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REF_CASCADE_CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF_CASCADE_CURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFTOHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFTOHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_COUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_INSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_INSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_LIKE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_REPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_SUBSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGISTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_AVGX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_AVGX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_AVGY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_AVGY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_COUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_INTERCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_INTERCEPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_R2() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_R2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SLOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SLOPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SXX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SXX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SXY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SXY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SYY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SYY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGULAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RELATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMAINDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMAINDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMOTE_MAPPED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE_MAPPED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPEAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPEAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREQUIRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESPECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESPECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTORE_AS_INTERVALS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE_AS_INTERVALS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICT_ALL_REF_CONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_ALL_REF_CONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUMABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETRY_ON_ROW_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETRY_ON_ROW_CHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REWRITE_OR_ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE_OR_ERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RIGHT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserROUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWIDTOCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWIDTOCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWIDTONCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWIDTONCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW_LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_LENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RPAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRPAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RULES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SALT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSALT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAMPLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAVE_AS_INTERVALS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE_AS_INTERVALS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SB4() antlr.TerminalNode { + return s.GetToken(PlSqlParserSB4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCALE_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCAN_INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN_INSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEDULER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMACHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCN_ASCENDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN_ASCENDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_ALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_INHIBIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_INHIBIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_SHOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEARCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECUREFILE_DBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE_DBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECURITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECURITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEG_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEG_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEG_FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEG_FILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SELECTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECTIVITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMIJOIN_DRIVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMIJOIN_DRIVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMI_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMI_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENTIAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALIZABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERVERERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVERERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSION_CACHED_CURSORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION_CACHED_CURSORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONS_PER_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONS_PER_USER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTIMEZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONTZNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTZNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SET_TO_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET_TO_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEVERE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEVERE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHARED_POOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED_POOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIBLINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIBLINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGNAL_COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNAL_COMPONENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGNAL_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNAL_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINGLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINGLETASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLETASK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_EXT_OPTIMIZER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_EXT_OPTIMIZER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_UNQ_UNUSABLE_IDX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_UNQ_UNUSABLE_IDX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_UNUSABLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_UNUSABLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOUNDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPREADSHEET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPREADSHEET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQLLDR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLLDR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL_TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_TRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL_MACRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_MACRO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQRT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQRT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTALE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDALONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDALONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDBY_MAX_DATA_DELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY_MAX_DATA_DELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STAR_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTAR_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STARTUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENT_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENT_QUEUING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_QUEUING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_BINOMIAL_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_BINOMIAL_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_CROSSTAB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_CROSSTAB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_F_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_F_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_KS_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_KS_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_MODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_MW_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_MW_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_ONE_WAY_ANOVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_ONE_WAY_ANOVA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_INDEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_INDEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_INDEPU() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_INDEPU, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_ONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_ONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_PAIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_PAIRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_WSR_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_WSR_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STREAMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTREAMS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIPE_COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_COLUMNS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIPE_WIDTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_WIDTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRUCTURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCTURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITION_REL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION_REL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBQUERIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBQUERIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBQUERY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBQUERY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR4() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTRB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTRB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTRC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTRC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUMMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUMMARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWAP_JOIN_INPUTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWAP_JOIN_INPUTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNCHRONOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSASM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSASM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_AUDIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CHECKACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CHECKACL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CONNECT_BY_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CONNECT_BY_PATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DBURIGEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DBURIGEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DL_CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DL_CURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DM_RXFORM_CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DM_RXFORM_CHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DM_RXFORM_NUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DM_RXFORM_NUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DOM_COMPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DOM_COMPARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DST_PRIM2SEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DST_PRIM2SEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DST_SEC2PRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DST_SEC2PRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_BFILE_TO_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_BFILE_TO_RAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_BLOB_TO_IMAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_BLOB_TO_IMAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_IMAGE_TO_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_IMAGE_TO_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_RAW_TO_BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_RAW_TO_BFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_EXTPDTXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_EXTPDTXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_EXTRACT_UTC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_EXTRACT_UTC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FBT_INSDEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FBT_INSDEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FILTER_ACLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FILTER_ACLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FNMATCHES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FNMATCHES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FNREPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FNREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GET_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GET_PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_PRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GETTOKENID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GETTOKENID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GETXTIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GETXTIVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MAKEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MAKEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MAKE_XMLNODEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MAKE_XMLNODEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MKXMLATTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MKXMLATTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ADT2BIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ADT2BIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ADTCONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ADTCONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ALSCRVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ALSCRVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ATG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ATG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BIN2ADT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BIN2ADT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BITVEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BITVEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BL2R() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BL2R, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BLOOM_FILTER_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BLOOM_FILTER_LIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BLOOM_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BLOOM_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_C2C() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_C2C, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CEG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CEG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CL2C() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CL2C, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COMBINED_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COMBINED_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COUNTCHG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COUNTCHG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSCONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSCONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSCONVTEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSCONVTEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSX_PATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSX_PATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DECOMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DECOMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DESCEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DESCEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DRA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DUMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DV_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DV_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ENFORCE_NOT_NULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ENFORCE_NOT_NULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSOPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_EXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_GROUPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_GUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_IIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_IIX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ITR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ITR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LBID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LBID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2NCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2TYP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2TYP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LSVI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LSVI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MAKEOID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MAKEOID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MAP_NONNULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MAP_NONNULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MSR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MSR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NICOMBINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NICOMBINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NIEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NIEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NII() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NII, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NIX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NOEXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NOEXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NTCIMG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NTCIMG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NUMTORAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NUMTORAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_OIDVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_OIDVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_OPNSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_OPNSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PAR_1() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PAR_1, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PARGID_1() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PARGID_1, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PARGID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PARGID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_R2O() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_R2O, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RAWTONUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RAWTONUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RDTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RDTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RMTD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RMTD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ROWIDTOOBJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ROWIDTOOBJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RPB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RPB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTLOBPRBSC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTLOBPRBSC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TOSETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TOSETID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TPR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TPR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TRTB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TRTB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTXICMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTXICMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTXQCASTASNQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTXQCASTASNQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_UNDESCEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_UNDESCEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECBIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECBIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECXOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECXOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VVD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VVD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XMLCONS_FOR_CSX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XMLCONS_FOR_CSX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHATG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHATG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHIDX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHIDX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHOP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XTXT2SQLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XTXT2SQLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_DEPTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_MAXCHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_MAXCHILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_PARENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PARALLEL_TXN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PARALLEL_TXN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_IS_ATTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_IS_ATTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_IS_NMSPC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_IS_NMSPC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_LASTNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_LASTNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_LASTNMSPC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_LASTNMSPC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATH_REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATH_REVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PXQEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PXQEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_RID_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_RID_ORDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ROW_DELTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ROW_DELTA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_SC_2_XMLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_SC_2_XMLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_SYNRCIREDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_SYNRCIREDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTEM_DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM_DEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_TYPEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_TYPEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_UMAKEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_UMAKEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLANALYZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLCONTAINS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLCONTAINS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLCONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLCONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLEXNSURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLEXNSURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLGEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLGEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLI_LOC_ISNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLI_LOC_ISNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLI_LOC_ISTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLI_LOC_ISTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLINSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLINSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLLOCATOR_GETSVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLLOCATOR_GETSVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETCID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETCID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETLOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETLOCATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETOKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETOKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETPATHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETPATHID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETPTRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETPTRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETSVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETSVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETTID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETTID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLT_2_SC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLT_2_SC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLTRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLTRANSLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLTYPE2SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLTYPE2SQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_ASQLCNV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_ASQLCNV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_ATOMCNVCHK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_ATOMCNVCHK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQBASEURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQBASEURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCASTABLEERRH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCASTABLEERRH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCODEP2STR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCODEP2STR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCODEPEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCODEPEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCON2SEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCON2SEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDELETE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDFLTCOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDFLTCOLATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDOC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDOC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDOCURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDOCURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDURDIV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDURDIV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQED4URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQED4URI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQENDSWITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQENDSWITH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQERRH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQERRH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQERR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQESHTMLURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQESHTMLURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXLOBVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXLOBVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXSTWRP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXSTWRP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXTRREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXTRREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFB2STR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFB2STR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNBOOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNBOOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNCMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNCMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNDATIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNDATIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNLNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNLNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNNSURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNNSURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNPREDTRUTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNPREDTRUTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFORMATNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFORMATNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFTCONTAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFTCONTAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFUNCR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFUNCR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQGETCONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQGETCONTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINDXOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINDXOF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINSPFX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINSPFX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQIRI2URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQIRI2URI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQLANG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQLANG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQLLNMFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQLLNMFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQMKNODEREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQMKNODEREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNILLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNILLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNODENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNODENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNORMSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNORMSPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNORMUCODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNORMUCODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_NRNG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_NRNG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNSP4PFX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNSP4PFX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNSPFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNSPFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPFXFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPFXFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_PKSQL2XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_PKSQL2XML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYABS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYABS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYADD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCSTBL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCSTBL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYDIV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYDIV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYFLR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYFLR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYMOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYMOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYMUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYMUL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYRND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYRND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYSQRT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYSQRT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYSUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYSUB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYUMUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYUMUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYUPLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYUPLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVGT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVGT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQREF2VAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQREF2VAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQREPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRESVURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRESVURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRNDHALF2EVN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRNDHALF2EVN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRSLVQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRSLVQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYENVPGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYENVPGET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYVARGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYVARGET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYWRP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYWRP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQ2CON4XC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQ2CON4XC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQ2CON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQ2CON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQDEEPEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQDEEPEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQINSB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQINSB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQRM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQRM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQRVS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQRVS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQSUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQSUB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQTYPMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQTYPMATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTARTSWITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTARTSWITH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTATBURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTATBURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTR2CODEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTR2CODEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTRJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTRJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSUBSTRAFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSUBSTRAFT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSUBSTRBEF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSUBSTRBEF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQTOKENIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQTOKENIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQTREATAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQTREATAS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_UPKXML2SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_UPKXML2SQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQXFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQXFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE_LOOKUP_BY_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE_LOOKUP_BY_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLESPACE_NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE_NO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TANH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTANH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TBLORIDXPARTNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTBLORIDXPARTNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPLATE_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THREAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHREAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THROUGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHROUGH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEOUT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_ABBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_ABBR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_HOUR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_MINUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIME_ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME_ZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_OFFSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_REGION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_REGION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIV_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIV_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIV_SSF() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIV_SSF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_DOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_FLOAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_DSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DSINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_LOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_MULTI_BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_MULTI_BYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TOPLEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_SINGLE_BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_SINGLE_BYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIME_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIME_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_YMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_YMINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACKING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSFORM_DISTINCT_AGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM_DISTINCT_AGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSITIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TREAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTREAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUSTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TX() antlr.TerminalNode { + return s.GetToken(PlSqlParserTX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TZ_OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserTZ_OFFSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UB2() antlr.TerminalNode { + return s.GetToken(PlSqlParserUB2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserUBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNARCHIVED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUNDED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNBOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDROP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNIFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNISTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNISTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_INNERJ_DISTINCT_VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_NOSEMIJ_NODISTINCTVIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_SEMIJ_VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_SEMIJ_VIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPACKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPACKED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNQUIESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNQUIESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNRECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRECOVERABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNRESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRESTRICTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPD_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPD_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPD_JOININDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPD_JOININDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_CONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_INVISIBLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_INVISIBLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_MERGE_CARTESIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_MERGE_CARTESIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_NL_WITH_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_NL_WITH_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_PRIVATE_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_PRIVATE_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER_DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERENV() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERENV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_RECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_SEMI() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_SEMI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_STORED_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_STORED_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_TTT_FOR_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_TTT_FOR_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_WEAK_NAME_RESL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_WEAK_NAME_RESL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VAR_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VAR_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARYING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARYING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VECTOR_READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_READ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VECTOR_READ_TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_READ_TRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERIFY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_ENDSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_ENDSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_ENDTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_ENDTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_OPERATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_OPERATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_STARTSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_STARTSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_STARTTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_STARTTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_XID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WALLET() antlr.TerminalNode { + return s.GetToken(PlSqlParserWALLET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WELLFORMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWELLFORMED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHITESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHITESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WIDTH_BUCKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserWIDTH_BUCKET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WRAPPED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XDB_FASTPATH_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXDB_FASTPATH_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) X_DYN_PRUNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserX_DYN_PRUNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserXID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML2OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML2OBJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLATTRIBUTES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCDATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCOLATTVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOLATTVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCOMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOMMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLDIFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLDIFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML_DML_RWT_STMT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML_DML_RWT_STMT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLELEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLEXISTS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLFOREST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_REWRITE_IN_SELECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_SEL_IDX_TBL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_SEL_IDX_TBL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLISNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLISNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLISVALID() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLISVALID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLNAMESPACES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPARSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPI() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLQUERYVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERYVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSERIALIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTRANSFORMBLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTRANSFORMBLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTRANSFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XPATHTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXPATHTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XS_SYS_CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS_SYS_CONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_keywords_pre12cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_keywords_pre12cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_reserved_keywords_pre12c(s) + } +} + +func (s *Non_reserved_keywords_pre12cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_reserved_keywords_pre12c(s) + } +} + +func (p *PlSqlParser) Non_reserved_keywords_pre12c() (localctx INon_reserved_keywords_pre12cContext) { + localctx = NewNon_reserved_keywords_pre12cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2416, PlSqlParserRULE_non_reserved_keywords_pre12c) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(21414) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3406220652181889718) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-748833094204658795) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&9132283885041737463) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-3508308513949450525) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-288485724859197357) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-2324085745431628903) != 0) || ((int64((_la-385)) & ^0x3f) == 0 && ((int64(1)<<(_la-385))&7912568587232538191) != 0) || ((int64((_la-449)) & ^0x3f) == 0 && ((int64(1)<<(_la-449))&-3195933142125911965) != 0) || ((int64((_la-513)) & ^0x3f) == 0 && ((int64(1)<<(_la-513))&5728006956065313743) != 0) || ((int64((_la-578)) & ^0x3f) == 0 && ((int64(1)<<(_la-578))&8717829644369234149) != 0) || ((int64((_la-642)) & ^0x3f) == 0 && ((int64(1)<<(_la-642))&-1767676876276465841) != 0) || ((int64((_la-706)) & ^0x3f) == 0 && ((int64(1)<<(_la-706))&9222117487376590847) != 0) || ((int64((_la-771)) & ^0x3f) == 0 && ((int64(1)<<(_la-771))&8783703725202676335) != 0) || ((int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&-2035741398820491271) != 0) || ((int64((_la-900)) & ^0x3f) == 0 && ((int64(1)<<(_la-900))&-648804082462987523) != 0) || ((int64((_la-966)) & ^0x3f) == 0 && ((int64(1)<<(_la-966))&-72128512691084353) != 0) || ((int64((_la-1030)) & ^0x3f) == 0 && ((int64(1)<<(_la-1030))&-5585618174499356673) != 0) || ((int64((_la-1094)) & ^0x3f) == 0 && ((int64(1)<<(_la-1094))&6413089310586957759) != 0) || ((int64((_la-1160)) & ^0x3f) == 0 && ((int64(1)<<(_la-1160))&-1099045435519537681) != 0) || ((int64((_la-1224)) & ^0x3f) == 0 && ((int64(1)<<(_la-1224))&-572801624051843155) != 0) || ((int64((_la-1288)) & ^0x3f) == 0 && ((int64(1)<<(_la-1288))&-246652414011674877) != 0) || ((int64((_la-1352)) & ^0x3f) == 0 && ((int64(1)<<(_la-1352))&1871232013155805567) != 0) || ((int64((_la-1418)) & ^0x3f) == 0 && ((int64(1)<<(_la-1418))&-1221039124375463559) != 0) || ((int64((_la-1483)) & ^0x3f) == 0 && ((int64(1)<<(_la-1483))&-276539933441) != 0) || ((int64((_la-1547)) & ^0x3f) == 0 && ((int64(1)<<(_la-1547))&-9152344495231585) != 0) || ((int64((_la-1611)) & ^0x3f) == 0 && ((int64(1)<<(_la-1611))&-1177383645667917891) != 0) || ((int64((_la-1675)) & ^0x3f) == 0 && ((int64(1)<<(_la-1675))&4212782991513607961) != 0) || ((int64((_la-1739)) & ^0x3f) == 0 && ((int64(1)<<(_la-1739))&-4756154699558682673) != 0) || ((int64((_la-1804)) & ^0x3f) == 0 && ((int64(1)<<(_la-1804))&-72057620621426721) != 0) || ((int64((_la-1868)) & ^0x3f) == 0 && ((int64(1)<<(_la-1868))&-68719480721) != 0) || ((int64((_la-1933)) & ^0x3f) == 0 && ((int64(1)<<(_la-1933))&-1025) != 0) || ((int64((_la-1997)) & ^0x3f) == 0 && ((int64(1)<<(_la-1997))&-1) != 0) || ((int64((_la-2061)) & ^0x3f) == 0 && ((int64(1)<<(_la-2061))&8069508139096875007) != 0) || ((int64((_la-2125)) & ^0x3f) == 0 && ((int64(1)<<(_la-2125))&8716611383363305471) != 0) || ((int64((_la-2189)) & ^0x3f) == 0 && ((int64(1)<<(_la-2189))&170993831007479743) != 0) || ((int64((_la-2253)) & ^0x3f) == 0 && ((int64(1)<<(_la-2253))&-5387180460087971803) != 0) || ((int64((_la-2317)) & ^0x3f) == 0 && ((int64(1)<<(_la-2317))&17814560123617275) != 0) || ((int64((_la-2388)) & ^0x3f) == 0 && ((int64(1)<<(_la-2388))&266254307321) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *PlSqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 358: + var t *Unified_auditingContext = nil + if localctx != nil { + t = localctx.(*Unified_auditingContext) + } + return p.Unified_auditing_Sempred(t, predIndex) + + case 361: + var t *Audit_direct_pathContext = nil + if localctx != nil { + t = localctx.(*Audit_direct_pathContext) + } + return p.Audit_direct_path_Sempred(t, predIndex) + + case 362: + var t *Audit_container_clauseContext = nil + if localctx != nil { + t = localctx.(*Audit_container_clauseContext) + } + return p.Audit_container_clause_Sempred(t, predIndex) + + case 368: + var t *Auditing_on_clauseContext = nil + if localctx != nil { + t = localctx.(*Auditing_on_clauseContext) + } + return p.Auditing_on_clause_Sempred(t, predIndex) + + case 372: + var t *Sql_statement_shortcutContext = nil + if localctx != nil { + t = localctx.(*Sql_statement_shortcutContext) + } + return p.Sql_statement_shortcut_Sempred(t, predIndex) + + case 404: + var t *Library_editionableContext = nil + if localctx != nil { + t = localctx.(*Library_editionableContext) + } + return p.Library_editionable_Sempred(t, predIndex) + + case 405: + var t *Library_debugContext = nil + if localctx != nil { + t = localctx.(*Library_debugContext) + } + return p.Library_debug_Sempred(t, predIndex) + + case 417: + var t *Alter_view_editionableContext = nil + if localctx != nil { + t = localctx.(*Alter_view_editionableContext) + } + return p.Alter_view_editionable_Sempred(t, predIndex) + + case 625: + var t *External_table_condition_clauseContext = nil + if localctx != nil { + t = localctx.(*External_table_condition_clauseContext) + } + return p.External_table_condition_clause_Sempred(t, predIndex) + + case 694: + var t *Partial_database_recovery_10gContext = nil + if localctx != nil { + t = localctx.(*Partial_database_recovery_10gContext) + } + return p.Partial_database_recovery_10g_Sempred(t, predIndex) + + case 832: + var t *Period_definitionContext = nil + if localctx != nil { + t = localctx.(*Period_definitionContext) + } + return p.Period_definition_Sempred(t, predIndex) + + case 957: + var t *Table_ref_auxContext = nil + if localctx != nil { + t = localctx.(*Table_ref_auxContext) + } + return p.Table_ref_aux_Sempred(t, predIndex) + + case 1032: + var t *Dml_table_expression_clauseContext = nil + if localctx != nil { + t = localctx.(*Dml_table_expression_clauseContext) + } + return p.Dml_table_expression_clause_Sempred(t, predIndex) + + case 1041: + var t *Logical_expressionContext = nil + if localctx != nil { + t = localctx.(*Logical_expressionContext) + } + return p.Logical_expression_Sempred(t, predIndex) + + case 1045: + var t *Multiset_expressionContext = nil + if localctx != nil { + t = localctx.(*Multiset_expressionContext) + } + return p.Multiset_expression_Sempred(t, predIndex) + + case 1046: + var t *Relational_expressionContext = nil + if localctx != nil { + t = localctx.(*Relational_expressionContext) + } + return p.Relational_expression_Sempred(t, predIndex) + + case 1051: + var t *ConcatenationContext = nil + if localctx != nil { + t = localctx.(*ConcatenationContext) + } + return p.Concatenation_Sempred(t, predIndex) + + case 1058: + var t *Unary_expression_coreContext = nil + if localctx != nil { + t = localctx.(*Unary_expression_coreContext) + } + return p.Unary_expression_core_Sempred(t, predIndex) + + case 1074: + var t *Standard_functionContext = nil + if localctx != nil { + t = localctx.(*Standard_functionContext) + } + return p.Standard_function_Sempred(t, predIndex) + + case 1110: + var t *String_delimiterContext = nil + if localctx != nil { + t = localctx.(*String_delimiterContext) + } + return p.String_delimiter_Sempred(t, predIndex) + + case 1192: + var t *General_elementContext = nil + if localctx != nil { + t = localctx.(*General_elementContext) + } + return p.General_element_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *PlSqlParser) Unified_auditing_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Audit_direct_path_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Audit_container_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Auditing_on_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 3: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Sql_statement_shortcut_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 4: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Library_editionable_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 5: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Library_debug_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 6: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Alter_view_editionable_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 7: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) External_table_condition_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 8: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Partial_database_recovery_10g_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 9: + return p.isVersion10() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Period_definition_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 10: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Table_ref_aux_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 11: + return p.isNotStartOfJoin() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Dml_table_expression_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 12: + return p.isVersion11() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Logical_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 13: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 14: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Multiset_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 15: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Relational_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 16: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 17: + return p.Precpred(p.GetParserRuleContext(), 2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Concatenation_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 18: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 19: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 20: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 21: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 22: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Unary_expression_core_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 23: + return p.IsNotNumericFunction() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Standard_function_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 24: + return p.IsNotNumericFunction() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) String_delimiter_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 25: + return p.Precpred(p.GetParserRuleContext(), 3) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) General_element_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 26: + return p.Precpred(p.GetParserRuleContext(), 2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/internal/engine/oracle/parser/plsql_parser_base.go b/internal/engine/oracle/parser/plsql_parser_base.go new file mode 100644 index 0000000000..6186eebf0d --- /dev/null +++ b/internal/engine/oracle/parser/plsql_parser_base.go @@ -0,0 +1,81 @@ +package parser + +import ( + "github.com/antlr4-go/antlr/v4" +) + +// PlSqlParserBase implementation. +type PlSqlParserBase struct { + *antlr.BaseParser + _isVersion12 bool + _isVersion11 bool + _isVersion10 bool +} + +var StaticConfig PlSqlParserBase + +func init() { + StaticConfig = PlSqlParserBase{ + _isVersion12: true, + _isVersion11: true, + _isVersion10: true, + } +} + +func (p *PlSqlParserBase) isVersion12() bool { + return StaticConfig._isVersion12 +} + +func (p *PlSqlParserBase) setVersion12(value bool) { + StaticConfig._isVersion12 = value +} + +func (p *PlSqlParserBase) isVersion11() bool { + return StaticConfig._isVersion11 +} + +func (p *PlSqlParserBase) setVersion11(value bool) { + StaticConfig._isVersion11 = value +} + +func (p *PlSqlParserBase) isVersion10() bool { + return StaticConfig._isVersion10 +} + +func (p *PlSqlParserBase) setVersion10(value bool) { + StaticConfig._isVersion10 = value +} + +func (p *PlSqlParserBase) IsNotNumericFunction() bool { + stream := p.GetTokenStream().(*antlr.CommonTokenStream) + lt1 := stream.LT(1) + lt2 := stream.LT(2) + if (lt1.GetTokenType() == PlSqlParserSUM || + lt1.GetTokenType() == PlSqlParserCOUNT || + lt1.GetTokenType() == PlSqlParserAVG || + lt1.GetTokenType() == PlSqlParserMIN || + lt1.GetTokenType() == PlSqlParserMAX || + lt1.GetTokenType() == PlSqlParserROUND || + lt1.GetTokenType() == PlSqlParserLEAST || + lt1.GetTokenType() == PlSqlParserGREATEST) && + lt2.GetTokenType() == PlSqlParserLEFT_PAREN { + return false + } + return true +} + +func (p *PlSqlParserBase) isNotStartOfJoin() bool { + stream := p.GetTokenStream().(*antlr.CommonTokenStream) + lt1 := stream.LT(1) + if lt1.GetTokenType() == PlSqlParserINNER || + lt1.GetTokenType() == PlSqlParserCROSS || + lt1.GetTokenType() == PlSqlParserNATURAL || + lt1.GetTokenType() == PlSqlParserPARTITION || + lt1.GetTokenType() == PlSqlParserFULL || + lt1.GetTokenType() == PlSqlParserLEFT || + lt1.GetTokenType() == PlSqlParserRIGHT || + lt1.GetTokenType() == PlSqlParserOUTER { + return false + } + return true +} diff --git a/internal/engine/oracle/parser/plsqlparser_base_listener.go b/internal/engine/oracle/parser/plsqlparser_base_listener.go new file mode 100644 index 0000000000..39905ab9e4 --- /dev/null +++ b/internal/engine/oracle/parser/plsqlparser_base_listener.go @@ -0,0 +1,7765 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.1. DO NOT EDIT. + +package parser // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +// BasePlSqlParserListener is a complete listener for a parse tree produced by PlSqlParser. +type BasePlSqlParserListener struct{} + +var _ PlSqlParserListener = &BasePlSqlParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BasePlSqlParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BasePlSqlParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BasePlSqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BasePlSqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterSql_script is called when production sql_script is entered. +func (s *BasePlSqlParserListener) EnterSql_script(ctx *Sql_scriptContext) {} + +// ExitSql_script is called when production sql_script is exited. +func (s *BasePlSqlParserListener) ExitSql_script(ctx *Sql_scriptContext) {} + +// EnterUnit_statement is called when production unit_statement is entered. +func (s *BasePlSqlParserListener) EnterUnit_statement(ctx *Unit_statementContext) {} + +// ExitUnit_statement is called when production unit_statement is exited. +func (s *BasePlSqlParserListener) ExitUnit_statement(ctx *Unit_statementContext) {} + +// EnterAlter_diskgroup is called when production alter_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterAlter_diskgroup(ctx *Alter_diskgroupContext) {} + +// ExitAlter_diskgroup is called when production alter_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitAlter_diskgroup(ctx *Alter_diskgroupContext) {} + +// EnterAdd_disk_clause is called when production add_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_disk_clause(ctx *Add_disk_clauseContext) {} + +// ExitAdd_disk_clause is called when production add_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_disk_clause(ctx *Add_disk_clauseContext) {} + +// EnterDrop_disk_clause is called when production drop_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_disk_clause(ctx *Drop_disk_clauseContext) {} + +// ExitDrop_disk_clause is called when production drop_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_disk_clause(ctx *Drop_disk_clauseContext) {} + +// EnterResize_disk_clause is called when production resize_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterResize_disk_clause(ctx *Resize_disk_clauseContext) {} + +// ExitResize_disk_clause is called when production resize_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitResize_disk_clause(ctx *Resize_disk_clauseContext) {} + +// EnterReplace_disk_clause is called when production replace_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterReplace_disk_clause(ctx *Replace_disk_clauseContext) {} + +// ExitReplace_disk_clause is called when production replace_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitReplace_disk_clause(ctx *Replace_disk_clauseContext) {} + +// EnterWait_nowait is called when production wait_nowait is entered. +func (s *BasePlSqlParserListener) EnterWait_nowait(ctx *Wait_nowaitContext) {} + +// ExitWait_nowait is called when production wait_nowait is exited. +func (s *BasePlSqlParserListener) ExitWait_nowait(ctx *Wait_nowaitContext) {} + +// EnterRename_disk_clause is called when production rename_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterRename_disk_clause(ctx *Rename_disk_clauseContext) {} + +// ExitRename_disk_clause is called when production rename_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitRename_disk_clause(ctx *Rename_disk_clauseContext) {} + +// EnterDisk_online_clause is called when production disk_online_clause is entered. +func (s *BasePlSqlParserListener) EnterDisk_online_clause(ctx *Disk_online_clauseContext) {} + +// ExitDisk_online_clause is called when production disk_online_clause is exited. +func (s *BasePlSqlParserListener) ExitDisk_online_clause(ctx *Disk_online_clauseContext) {} + +// EnterDisk_offline_clause is called when production disk_offline_clause is entered. +func (s *BasePlSqlParserListener) EnterDisk_offline_clause(ctx *Disk_offline_clauseContext) {} + +// ExitDisk_offline_clause is called when production disk_offline_clause is exited. +func (s *BasePlSqlParserListener) ExitDisk_offline_clause(ctx *Disk_offline_clauseContext) {} + +// EnterTimeout_clause is called when production timeout_clause is entered. +func (s *BasePlSqlParserListener) EnterTimeout_clause(ctx *Timeout_clauseContext) {} + +// ExitTimeout_clause is called when production timeout_clause is exited. +func (s *BasePlSqlParserListener) ExitTimeout_clause(ctx *Timeout_clauseContext) {} + +// EnterRebalance_diskgroup_clause is called when production rebalance_diskgroup_clause is entered. +func (s *BasePlSqlParserListener) EnterRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) { +} + +// ExitRebalance_diskgroup_clause is called when production rebalance_diskgroup_clause is exited. +func (s *BasePlSqlParserListener) ExitRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) { +} + +// EnterPhase is called when production phase is entered. +func (s *BasePlSqlParserListener) EnterPhase(ctx *PhaseContext) {} + +// ExitPhase is called when production phase is exited. +func (s *BasePlSqlParserListener) ExitPhase(ctx *PhaseContext) {} + +// EnterCheck_diskgroup_clause is called when production check_diskgroup_clause is entered. +func (s *BasePlSqlParserListener) EnterCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) {} + +// ExitCheck_diskgroup_clause is called when production check_diskgroup_clause is exited. +func (s *BasePlSqlParserListener) ExitCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) {} + +// EnterDiskgroup_template_clauses is called when production diskgroup_template_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) { +} + +// ExitDiskgroup_template_clauses is called when production diskgroup_template_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) { +} + +// EnterQualified_template_clause is called when production qualified_template_clause is entered. +func (s *BasePlSqlParserListener) EnterQualified_template_clause(ctx *Qualified_template_clauseContext) { +} + +// ExitQualified_template_clause is called when production qualified_template_clause is exited. +func (s *BasePlSqlParserListener) ExitQualified_template_clause(ctx *Qualified_template_clauseContext) { +} + +// EnterRedundancy_clause is called when production redundancy_clause is entered. +func (s *BasePlSqlParserListener) EnterRedundancy_clause(ctx *Redundancy_clauseContext) {} + +// ExitRedundancy_clause is called when production redundancy_clause is exited. +func (s *BasePlSqlParserListener) ExitRedundancy_clause(ctx *Redundancy_clauseContext) {} + +// EnterStriping_clause is called when production striping_clause is entered. +func (s *BasePlSqlParserListener) EnterStriping_clause(ctx *Striping_clauseContext) {} + +// ExitStriping_clause is called when production striping_clause is exited. +func (s *BasePlSqlParserListener) ExitStriping_clause(ctx *Striping_clauseContext) {} + +// EnterForce_noforce is called when production force_noforce is entered. +func (s *BasePlSqlParserListener) EnterForce_noforce(ctx *Force_noforceContext) {} + +// ExitForce_noforce is called when production force_noforce is exited. +func (s *BasePlSqlParserListener) ExitForce_noforce(ctx *Force_noforceContext) {} + +// EnterDiskgroup_directory_clauses is called when production diskgroup_directory_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) { +} + +// ExitDiskgroup_directory_clauses is called when production diskgroup_directory_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) { +} + +// EnterDir_name is called when production dir_name is entered. +func (s *BasePlSqlParserListener) EnterDir_name(ctx *Dir_nameContext) {} + +// ExitDir_name is called when production dir_name is exited. +func (s *BasePlSqlParserListener) ExitDir_name(ctx *Dir_nameContext) {} + +// EnterDiskgroup_alias_clauses is called when production diskgroup_alias_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) {} + +// ExitDiskgroup_alias_clauses is called when production diskgroup_alias_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) {} + +// EnterDiskgroup_volume_clauses is called when production diskgroup_volume_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) { +} + +// ExitDiskgroup_volume_clauses is called when production diskgroup_volume_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) { +} + +// EnterAdd_volume_clause is called when production add_volume_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_volume_clause(ctx *Add_volume_clauseContext) {} + +// ExitAdd_volume_clause is called when production add_volume_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_volume_clause(ctx *Add_volume_clauseContext) {} + +// EnterModify_volume_clause is called when production modify_volume_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_volume_clause(ctx *Modify_volume_clauseContext) {} + +// ExitModify_volume_clause is called when production modify_volume_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_volume_clause(ctx *Modify_volume_clauseContext) {} + +// EnterDiskgroup_attributes is called when production diskgroup_attributes is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_attributes(ctx *Diskgroup_attributesContext) {} + +// ExitDiskgroup_attributes is called when production diskgroup_attributes is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_attributes(ctx *Diskgroup_attributesContext) {} + +// EnterDrop_diskgroup_file_clause is called when production drop_diskgroup_file_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) { +} + +// ExitDrop_diskgroup_file_clause is called when production drop_diskgroup_file_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) { +} + +// EnterConvert_redundancy_clause is called when production convert_redundancy_clause is entered. +func (s *BasePlSqlParserListener) EnterConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) { +} + +// ExitConvert_redundancy_clause is called when production convert_redundancy_clause is exited. +func (s *BasePlSqlParserListener) ExitConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) { +} + +// EnterUsergroup_clauses is called when production usergroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterUsergroup_clauses(ctx *Usergroup_clausesContext) {} + +// ExitUsergroup_clauses is called when production usergroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitUsergroup_clauses(ctx *Usergroup_clausesContext) {} + +// EnterUser_clauses is called when production user_clauses is entered. +func (s *BasePlSqlParserListener) EnterUser_clauses(ctx *User_clausesContext) {} + +// ExitUser_clauses is called when production user_clauses is exited. +func (s *BasePlSqlParserListener) ExitUser_clauses(ctx *User_clausesContext) {} + +// EnterFile_permissions_clause is called when production file_permissions_clause is entered. +func (s *BasePlSqlParserListener) EnterFile_permissions_clause(ctx *File_permissions_clauseContext) {} + +// ExitFile_permissions_clause is called when production file_permissions_clause is exited. +func (s *BasePlSqlParserListener) ExitFile_permissions_clause(ctx *File_permissions_clauseContext) {} + +// EnterFile_owner_clause is called when production file_owner_clause is entered. +func (s *BasePlSqlParserListener) EnterFile_owner_clause(ctx *File_owner_clauseContext) {} + +// ExitFile_owner_clause is called when production file_owner_clause is exited. +func (s *BasePlSqlParserListener) ExitFile_owner_clause(ctx *File_owner_clauseContext) {} + +// EnterScrub_clause is called when production scrub_clause is entered. +func (s *BasePlSqlParserListener) EnterScrub_clause(ctx *Scrub_clauseContext) {} + +// ExitScrub_clause is called when production scrub_clause is exited. +func (s *BasePlSqlParserListener) ExitScrub_clause(ctx *Scrub_clauseContext) {} + +// EnterQuotagroup_clauses is called when production quotagroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterQuotagroup_clauses(ctx *Quotagroup_clausesContext) {} + +// ExitQuotagroup_clauses is called when production quotagroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitQuotagroup_clauses(ctx *Quotagroup_clausesContext) {} + +// EnterProperty_name is called when production property_name is entered. +func (s *BasePlSqlParserListener) EnterProperty_name(ctx *Property_nameContext) {} + +// ExitProperty_name is called when production property_name is exited. +func (s *BasePlSqlParserListener) ExitProperty_name(ctx *Property_nameContext) {} + +// EnterProperty_value is called when production property_value is entered. +func (s *BasePlSqlParserListener) EnterProperty_value(ctx *Property_valueContext) {} + +// ExitProperty_value is called when production property_value is exited. +func (s *BasePlSqlParserListener) ExitProperty_value(ctx *Property_valueContext) {} + +// EnterFilegroup_clauses is called when production filegroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterFilegroup_clauses(ctx *Filegroup_clausesContext) {} + +// ExitFilegroup_clauses is called when production filegroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitFilegroup_clauses(ctx *Filegroup_clausesContext) {} + +// EnterAdd_filegroup_clause is called when production add_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) {} + +// ExitAdd_filegroup_clause is called when production add_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) {} + +// EnterModify_filegroup_clause is called when production modify_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) {} + +// ExitModify_filegroup_clause is called when production modify_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) {} + +// EnterMove_to_filegroup_clause is called when production move_to_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) { +} + +// ExitMove_to_filegroup_clause is called when production move_to_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) { +} + +// EnterDrop_filegroup_clause is called when production drop_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) {} + +// ExitDrop_filegroup_clause is called when production drop_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) {} + +// EnterQuorum_regular is called when production quorum_regular is entered. +func (s *BasePlSqlParserListener) EnterQuorum_regular(ctx *Quorum_regularContext) {} + +// ExitQuorum_regular is called when production quorum_regular is exited. +func (s *BasePlSqlParserListener) ExitQuorum_regular(ctx *Quorum_regularContext) {} + +// EnterUndrop_disk_clause is called when production undrop_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterUndrop_disk_clause(ctx *Undrop_disk_clauseContext) {} + +// ExitUndrop_disk_clause is called when production undrop_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitUndrop_disk_clause(ctx *Undrop_disk_clauseContext) {} + +// EnterDiskgroup_availability is called when production diskgroup_availability is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_availability(ctx *Diskgroup_availabilityContext) {} + +// ExitDiskgroup_availability is called when production diskgroup_availability is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_availability(ctx *Diskgroup_availabilityContext) {} + +// EnterEnable_disable_volume is called when production enable_disable_volume is entered. +func (s *BasePlSqlParserListener) EnterEnable_disable_volume(ctx *Enable_disable_volumeContext) {} + +// ExitEnable_disable_volume is called when production enable_disable_volume is exited. +func (s *BasePlSqlParserListener) ExitEnable_disable_volume(ctx *Enable_disable_volumeContext) {} + +// EnterDrop_function is called when production drop_function is entered. +func (s *BasePlSqlParserListener) EnterDrop_function(ctx *Drop_functionContext) {} + +// ExitDrop_function is called when production drop_function is exited. +func (s *BasePlSqlParserListener) ExitDrop_function(ctx *Drop_functionContext) {} + +// EnterAlter_flashback_archive is called when production alter_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterAlter_flashback_archive(ctx *Alter_flashback_archiveContext) {} + +// ExitAlter_flashback_archive is called when production alter_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitAlter_flashback_archive(ctx *Alter_flashback_archiveContext) {} + +// EnterAlter_hierarchy is called when production alter_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterAlter_hierarchy(ctx *Alter_hierarchyContext) {} + +// ExitAlter_hierarchy is called when production alter_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitAlter_hierarchy(ctx *Alter_hierarchyContext) {} + +// EnterAlter_function is called when production alter_function is entered. +func (s *BasePlSqlParserListener) EnterAlter_function(ctx *Alter_functionContext) {} + +// ExitAlter_function is called when production alter_function is exited. +func (s *BasePlSqlParserListener) ExitAlter_function(ctx *Alter_functionContext) {} + +// EnterAlter_java is called when production alter_java is entered. +func (s *BasePlSqlParserListener) EnterAlter_java(ctx *Alter_javaContext) {} + +// ExitAlter_java is called when production alter_java is exited. +func (s *BasePlSqlParserListener) ExitAlter_java(ctx *Alter_javaContext) {} + +// EnterMatch_string is called when production match_string is entered. +func (s *BasePlSqlParserListener) EnterMatch_string(ctx *Match_stringContext) {} + +// ExitMatch_string is called when production match_string is exited. +func (s *BasePlSqlParserListener) ExitMatch_string(ctx *Match_stringContext) {} + +// EnterCreate_function_body is called when production create_function_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_function_body(ctx *Create_function_bodyContext) {} + +// ExitCreate_function_body is called when production create_function_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_function_body(ctx *Create_function_bodyContext) {} + +// EnterSql_macro_body is called when production sql_macro_body is entered. +func (s *BasePlSqlParserListener) EnterSql_macro_body(ctx *Sql_macro_bodyContext) {} + +// ExitSql_macro_body is called when production sql_macro_body is exited. +func (s *BasePlSqlParserListener) ExitSql_macro_body(ctx *Sql_macro_bodyContext) {} + +// EnterParallel_enable_clause is called when production parallel_enable_clause is entered. +func (s *BasePlSqlParserListener) EnterParallel_enable_clause(ctx *Parallel_enable_clauseContext) {} + +// ExitParallel_enable_clause is called when production parallel_enable_clause is exited. +func (s *BasePlSqlParserListener) ExitParallel_enable_clause(ctx *Parallel_enable_clauseContext) {} + +// EnterPartition_by_clause is called when production partition_by_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// ExitPartition_by_clause is called when production partition_by_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// EnterResult_cache_clause is called when production result_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterResult_cache_clause(ctx *Result_cache_clauseContext) {} + +// ExitResult_cache_clause is called when production result_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitResult_cache_clause(ctx *Result_cache_clauseContext) {} + +// EnterAccessible_by_clause is called when production accessible_by_clause is entered. +func (s *BasePlSqlParserListener) EnterAccessible_by_clause(ctx *Accessible_by_clauseContext) {} + +// ExitAccessible_by_clause is called when production accessible_by_clause is exited. +func (s *BasePlSqlParserListener) ExitAccessible_by_clause(ctx *Accessible_by_clauseContext) {} + +// EnterDefault_collation_clause is called when production default_collation_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_collation_clause(ctx *Default_collation_clauseContext) { +} + +// ExitDefault_collation_clause is called when production default_collation_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_collation_clause(ctx *Default_collation_clauseContext) { +} + +// EnterAggregate_clause is called when production aggregate_clause is entered. +func (s *BasePlSqlParserListener) EnterAggregate_clause(ctx *Aggregate_clauseContext) {} + +// ExitAggregate_clause is called when production aggregate_clause is exited. +func (s *BasePlSqlParserListener) ExitAggregate_clause(ctx *Aggregate_clauseContext) {} + +// EnterPipelined_using_clause is called when production pipelined_using_clause is entered. +func (s *BasePlSqlParserListener) EnterPipelined_using_clause(ctx *Pipelined_using_clauseContext) {} + +// ExitPipelined_using_clause is called when production pipelined_using_clause is exited. +func (s *BasePlSqlParserListener) ExitPipelined_using_clause(ctx *Pipelined_using_clauseContext) {} + +// EnterAccessor is called when production accessor is entered. +func (s *BasePlSqlParserListener) EnterAccessor(ctx *AccessorContext) {} + +// ExitAccessor is called when production accessor is exited. +func (s *BasePlSqlParserListener) ExitAccessor(ctx *AccessorContext) {} + +// EnterRelies_on_part is called when production relies_on_part is entered. +func (s *BasePlSqlParserListener) EnterRelies_on_part(ctx *Relies_on_partContext) {} + +// ExitRelies_on_part is called when production relies_on_part is exited. +func (s *BasePlSqlParserListener) ExitRelies_on_part(ctx *Relies_on_partContext) {} + +// EnterStreaming_clause is called when production streaming_clause is entered. +func (s *BasePlSqlParserListener) EnterStreaming_clause(ctx *Streaming_clauseContext) {} + +// ExitStreaming_clause is called when production streaming_clause is exited. +func (s *BasePlSqlParserListener) ExitStreaming_clause(ctx *Streaming_clauseContext) {} + +// EnterAlter_outline is called when production alter_outline is entered. +func (s *BasePlSqlParserListener) EnterAlter_outline(ctx *Alter_outlineContext) {} + +// ExitAlter_outline is called when production alter_outline is exited. +func (s *BasePlSqlParserListener) ExitAlter_outline(ctx *Alter_outlineContext) {} + +// EnterOutline_options is called when production outline_options is entered. +func (s *BasePlSqlParserListener) EnterOutline_options(ctx *Outline_optionsContext) {} + +// ExitOutline_options is called when production outline_options is exited. +func (s *BasePlSqlParserListener) ExitOutline_options(ctx *Outline_optionsContext) {} + +// EnterAlter_lockdown_profile is called when production alter_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) {} + +// ExitAlter_lockdown_profile is called when production alter_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) {} + +// EnterLockdown_feature is called when production lockdown_feature is entered. +func (s *BasePlSqlParserListener) EnterLockdown_feature(ctx *Lockdown_featureContext) {} + +// ExitLockdown_feature is called when production lockdown_feature is exited. +func (s *BasePlSqlParserListener) ExitLockdown_feature(ctx *Lockdown_featureContext) {} + +// EnterLockdown_options is called when production lockdown_options is entered. +func (s *BasePlSqlParserListener) EnterLockdown_options(ctx *Lockdown_optionsContext) {} + +// ExitLockdown_options is called when production lockdown_options is exited. +func (s *BasePlSqlParserListener) ExitLockdown_options(ctx *Lockdown_optionsContext) {} + +// EnterLockdown_statements is called when production lockdown_statements is entered. +func (s *BasePlSqlParserListener) EnterLockdown_statements(ctx *Lockdown_statementsContext) {} + +// ExitLockdown_statements is called when production lockdown_statements is exited. +func (s *BasePlSqlParserListener) ExitLockdown_statements(ctx *Lockdown_statementsContext) {} + +// EnterStatement_clauses is called when production statement_clauses is entered. +func (s *BasePlSqlParserListener) EnterStatement_clauses(ctx *Statement_clausesContext) {} + +// ExitStatement_clauses is called when production statement_clauses is exited. +func (s *BasePlSqlParserListener) ExitStatement_clauses(ctx *Statement_clausesContext) {} + +// EnterClause_options is called when production clause_options is entered. +func (s *BasePlSqlParserListener) EnterClause_options(ctx *Clause_optionsContext) {} + +// ExitClause_options is called when production clause_options is exited. +func (s *BasePlSqlParserListener) ExitClause_options(ctx *Clause_optionsContext) {} + +// EnterOption_values is called when production option_values is entered. +func (s *BasePlSqlParserListener) EnterOption_values(ctx *Option_valuesContext) {} + +// ExitOption_values is called when production option_values is exited. +func (s *BasePlSqlParserListener) ExitOption_values(ctx *Option_valuesContext) {} + +// EnterString_list is called when production string_list is entered. +func (s *BasePlSqlParserListener) EnterString_list(ctx *String_listContext) {} + +// ExitString_list is called when production string_list is exited. +func (s *BasePlSqlParserListener) ExitString_list(ctx *String_listContext) {} + +// EnterDisable_enable is called when production disable_enable is entered. +func (s *BasePlSqlParserListener) EnterDisable_enable(ctx *Disable_enableContext) {} + +// ExitDisable_enable is called when production disable_enable is exited. +func (s *BasePlSqlParserListener) ExitDisable_enable(ctx *Disable_enableContext) {} + +// EnterDrop_lockdown_profile is called when production drop_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) {} + +// ExitDrop_lockdown_profile is called when production drop_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) {} + +// EnterDrop_package is called when production drop_package is entered. +func (s *BasePlSqlParserListener) EnterDrop_package(ctx *Drop_packageContext) {} + +// ExitDrop_package is called when production drop_package is exited. +func (s *BasePlSqlParserListener) ExitDrop_package(ctx *Drop_packageContext) {} + +// EnterAlter_package is called when production alter_package is entered. +func (s *BasePlSqlParserListener) EnterAlter_package(ctx *Alter_packageContext) {} + +// ExitAlter_package is called when production alter_package is exited. +func (s *BasePlSqlParserListener) ExitAlter_package(ctx *Alter_packageContext) {} + +// EnterCreate_package is called when production create_package is entered. +func (s *BasePlSqlParserListener) EnterCreate_package(ctx *Create_packageContext) {} + +// ExitCreate_package is called when production create_package is exited. +func (s *BasePlSqlParserListener) ExitCreate_package(ctx *Create_packageContext) {} + +// EnterCreate_package_body is called when production create_package_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_package_body(ctx *Create_package_bodyContext) {} + +// ExitCreate_package_body is called when production create_package_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_package_body(ctx *Create_package_bodyContext) {} + +// EnterPackage_obj_spec is called when production package_obj_spec is entered. +func (s *BasePlSqlParserListener) EnterPackage_obj_spec(ctx *Package_obj_specContext) {} + +// ExitPackage_obj_spec is called when production package_obj_spec is exited. +func (s *BasePlSqlParserListener) ExitPackage_obj_spec(ctx *Package_obj_specContext) {} + +// EnterProcedure_spec is called when production procedure_spec is entered. +func (s *BasePlSqlParserListener) EnterProcedure_spec(ctx *Procedure_specContext) {} + +// ExitProcedure_spec is called when production procedure_spec is exited. +func (s *BasePlSqlParserListener) ExitProcedure_spec(ctx *Procedure_specContext) {} + +// EnterFunction_spec is called when production function_spec is entered. +func (s *BasePlSqlParserListener) EnterFunction_spec(ctx *Function_specContext) {} + +// ExitFunction_spec is called when production function_spec is exited. +func (s *BasePlSqlParserListener) ExitFunction_spec(ctx *Function_specContext) {} + +// EnterPackage_obj_body is called when production package_obj_body is entered. +func (s *BasePlSqlParserListener) EnterPackage_obj_body(ctx *Package_obj_bodyContext) {} + +// ExitPackage_obj_body is called when production package_obj_body is exited. +func (s *BasePlSqlParserListener) ExitPackage_obj_body(ctx *Package_obj_bodyContext) {} + +// EnterAlter_pmem_filestore is called when production alter_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) {} + +// ExitAlter_pmem_filestore is called when production alter_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) {} + +// EnterDrop_pmem_filestore is called when production drop_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) {} + +// ExitDrop_pmem_filestore is called when production drop_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) {} + +// EnterDrop_procedure is called when production drop_procedure is entered. +func (s *BasePlSqlParserListener) EnterDrop_procedure(ctx *Drop_procedureContext) {} + +// ExitDrop_procedure is called when production drop_procedure is exited. +func (s *BasePlSqlParserListener) ExitDrop_procedure(ctx *Drop_procedureContext) {} + +// EnterAlter_procedure is called when production alter_procedure is entered. +func (s *BasePlSqlParserListener) EnterAlter_procedure(ctx *Alter_procedureContext) {} + +// ExitAlter_procedure is called when production alter_procedure is exited. +func (s *BasePlSqlParserListener) ExitAlter_procedure(ctx *Alter_procedureContext) {} + +// EnterFunction_body is called when production function_body is entered. +func (s *BasePlSqlParserListener) EnterFunction_body(ctx *Function_bodyContext) {} + +// ExitFunction_body is called when production function_body is exited. +func (s *BasePlSqlParserListener) ExitFunction_body(ctx *Function_bodyContext) {} + +// EnterProcedure_body is called when production procedure_body is entered. +func (s *BasePlSqlParserListener) EnterProcedure_body(ctx *Procedure_bodyContext) {} + +// ExitProcedure_body is called when production procedure_body is exited. +func (s *BasePlSqlParserListener) ExitProcedure_body(ctx *Procedure_bodyContext) {} + +// EnterCreate_procedure_body is called when production create_procedure_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_procedure_body(ctx *Create_procedure_bodyContext) {} + +// ExitCreate_procedure_body is called when production create_procedure_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_procedure_body(ctx *Create_procedure_bodyContext) {} + +// EnterAlter_resource_cost is called when production alter_resource_cost is entered. +func (s *BasePlSqlParserListener) EnterAlter_resource_cost(ctx *Alter_resource_costContext) {} + +// ExitAlter_resource_cost is called when production alter_resource_cost is exited. +func (s *BasePlSqlParserListener) ExitAlter_resource_cost(ctx *Alter_resource_costContext) {} + +// EnterDrop_outline is called when production drop_outline is entered. +func (s *BasePlSqlParserListener) EnterDrop_outline(ctx *Drop_outlineContext) {} + +// ExitDrop_outline is called when production drop_outline is exited. +func (s *BasePlSqlParserListener) ExitDrop_outline(ctx *Drop_outlineContext) {} + +// EnterAlter_rollback_segment is called when production alter_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterAlter_rollback_segment(ctx *Alter_rollback_segmentContext) {} + +// ExitAlter_rollback_segment is called when production alter_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitAlter_rollback_segment(ctx *Alter_rollback_segmentContext) {} + +// EnterDrop_restore_point is called when production drop_restore_point is entered. +func (s *BasePlSqlParserListener) EnterDrop_restore_point(ctx *Drop_restore_pointContext) {} + +// ExitDrop_restore_point is called when production drop_restore_point is exited. +func (s *BasePlSqlParserListener) ExitDrop_restore_point(ctx *Drop_restore_pointContext) {} + +// EnterDrop_rollback_segment is called when production drop_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterDrop_rollback_segment(ctx *Drop_rollback_segmentContext) {} + +// ExitDrop_rollback_segment is called when production drop_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitDrop_rollback_segment(ctx *Drop_rollback_segmentContext) {} + +// EnterDrop_role is called when production drop_role is entered. +func (s *BasePlSqlParserListener) EnterDrop_role(ctx *Drop_roleContext) {} + +// ExitDrop_role is called when production drop_role is exited. +func (s *BasePlSqlParserListener) ExitDrop_role(ctx *Drop_roleContext) {} + +// EnterCreate_pmem_filestore is called when production create_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) {} + +// ExitCreate_pmem_filestore is called when production create_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) {} + +// EnterPmem_filestore_options is called when production pmem_filestore_options is entered. +func (s *BasePlSqlParserListener) EnterPmem_filestore_options(ctx *Pmem_filestore_optionsContext) {} + +// ExitPmem_filestore_options is called when production pmem_filestore_options is exited. +func (s *BasePlSqlParserListener) ExitPmem_filestore_options(ctx *Pmem_filestore_optionsContext) {} + +// EnterFile_path is called when production file_path is entered. +func (s *BasePlSqlParserListener) EnterFile_path(ctx *File_pathContext) {} + +// ExitFile_path is called when production file_path is exited. +func (s *BasePlSqlParserListener) ExitFile_path(ctx *File_pathContext) {} + +// EnterCreate_rollback_segment is called when production create_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterCreate_rollback_segment(ctx *Create_rollback_segmentContext) {} + +// ExitCreate_rollback_segment is called when production create_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitCreate_rollback_segment(ctx *Create_rollback_segmentContext) {} + +// EnterDrop_trigger is called when production drop_trigger is entered. +func (s *BasePlSqlParserListener) EnterDrop_trigger(ctx *Drop_triggerContext) {} + +// ExitDrop_trigger is called when production drop_trigger is exited. +func (s *BasePlSqlParserListener) ExitDrop_trigger(ctx *Drop_triggerContext) {} + +// EnterAlter_trigger is called when production alter_trigger is entered. +func (s *BasePlSqlParserListener) EnterAlter_trigger(ctx *Alter_triggerContext) {} + +// ExitAlter_trigger is called when production alter_trigger is exited. +func (s *BasePlSqlParserListener) ExitAlter_trigger(ctx *Alter_triggerContext) {} + +// EnterCreate_trigger is called when production create_trigger is entered. +func (s *BasePlSqlParserListener) EnterCreate_trigger(ctx *Create_triggerContext) {} + +// ExitCreate_trigger is called when production create_trigger is exited. +func (s *BasePlSqlParserListener) ExitCreate_trigger(ctx *Create_triggerContext) {} + +// EnterTrigger_follows_clause is called when production trigger_follows_clause is entered. +func (s *BasePlSqlParserListener) EnterTrigger_follows_clause(ctx *Trigger_follows_clauseContext) {} + +// ExitTrigger_follows_clause is called when production trigger_follows_clause is exited. +func (s *BasePlSqlParserListener) ExitTrigger_follows_clause(ctx *Trigger_follows_clauseContext) {} + +// EnterTrigger_when_clause is called when production trigger_when_clause is entered. +func (s *BasePlSqlParserListener) EnterTrigger_when_clause(ctx *Trigger_when_clauseContext) {} + +// ExitTrigger_when_clause is called when production trigger_when_clause is exited. +func (s *BasePlSqlParserListener) ExitTrigger_when_clause(ctx *Trigger_when_clauseContext) {} + +// EnterSimple_dml_trigger is called when production simple_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterSimple_dml_trigger(ctx *Simple_dml_triggerContext) {} + +// ExitSimple_dml_trigger is called when production simple_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitSimple_dml_trigger(ctx *Simple_dml_triggerContext) {} + +// EnterFor_each_row is called when production for_each_row is entered. +func (s *BasePlSqlParserListener) EnterFor_each_row(ctx *For_each_rowContext) {} + +// ExitFor_each_row is called when production for_each_row is exited. +func (s *BasePlSqlParserListener) ExitFor_each_row(ctx *For_each_rowContext) {} + +// EnterCompound_dml_trigger is called when production compound_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterCompound_dml_trigger(ctx *Compound_dml_triggerContext) {} + +// ExitCompound_dml_trigger is called when production compound_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitCompound_dml_trigger(ctx *Compound_dml_triggerContext) {} + +// EnterNon_dml_trigger is called when production non_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterNon_dml_trigger(ctx *Non_dml_triggerContext) {} + +// ExitNon_dml_trigger is called when production non_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitNon_dml_trigger(ctx *Non_dml_triggerContext) {} + +// EnterTrigger_body is called when production trigger_body is entered. +func (s *BasePlSqlParserListener) EnterTrigger_body(ctx *Trigger_bodyContext) {} + +// ExitTrigger_body is called when production trigger_body is exited. +func (s *BasePlSqlParserListener) ExitTrigger_body(ctx *Trigger_bodyContext) {} + +// EnterCompound_trigger_block is called when production compound_trigger_block is entered. +func (s *BasePlSqlParserListener) EnterCompound_trigger_block(ctx *Compound_trigger_blockContext) {} + +// ExitCompound_trigger_block is called when production compound_trigger_block is exited. +func (s *BasePlSqlParserListener) ExitCompound_trigger_block(ctx *Compound_trigger_blockContext) {} + +// EnterTiming_point_section is called when production timing_point_section is entered. +func (s *BasePlSqlParserListener) EnterTiming_point_section(ctx *Timing_point_sectionContext) {} + +// ExitTiming_point_section is called when production timing_point_section is exited. +func (s *BasePlSqlParserListener) ExitTiming_point_section(ctx *Timing_point_sectionContext) {} + +// EnterNon_dml_event is called when production non_dml_event is entered. +func (s *BasePlSqlParserListener) EnterNon_dml_event(ctx *Non_dml_eventContext) {} + +// ExitNon_dml_event is called when production non_dml_event is exited. +func (s *BasePlSqlParserListener) ExitNon_dml_event(ctx *Non_dml_eventContext) {} + +// EnterDml_event_clause is called when production dml_event_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_event_clause(ctx *Dml_event_clauseContext) {} + +// ExitDml_event_clause is called when production dml_event_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_event_clause(ctx *Dml_event_clauseContext) {} + +// EnterDml_event_element is called when production dml_event_element is entered. +func (s *BasePlSqlParserListener) EnterDml_event_element(ctx *Dml_event_elementContext) {} + +// ExitDml_event_element is called when production dml_event_element is exited. +func (s *BasePlSqlParserListener) ExitDml_event_element(ctx *Dml_event_elementContext) {} + +// EnterDml_event_nested_clause is called when production dml_event_nested_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) {} + +// ExitDml_event_nested_clause is called when production dml_event_nested_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) {} + +// EnterReferencing_clause is called when production referencing_clause is entered. +func (s *BasePlSqlParserListener) EnterReferencing_clause(ctx *Referencing_clauseContext) {} + +// ExitReferencing_clause is called when production referencing_clause is exited. +func (s *BasePlSqlParserListener) ExitReferencing_clause(ctx *Referencing_clauseContext) {} + +// EnterReferencing_element is called when production referencing_element is entered. +func (s *BasePlSqlParserListener) EnterReferencing_element(ctx *Referencing_elementContext) {} + +// ExitReferencing_element is called when production referencing_element is exited. +func (s *BasePlSqlParserListener) ExitReferencing_element(ctx *Referencing_elementContext) {} + +// EnterDrop_type is called when production drop_type is entered. +func (s *BasePlSqlParserListener) EnterDrop_type(ctx *Drop_typeContext) {} + +// ExitDrop_type is called when production drop_type is exited. +func (s *BasePlSqlParserListener) ExitDrop_type(ctx *Drop_typeContext) {} + +// EnterAlter_type is called when production alter_type is entered. +func (s *BasePlSqlParserListener) EnterAlter_type(ctx *Alter_typeContext) {} + +// ExitAlter_type is called when production alter_type is exited. +func (s *BasePlSqlParserListener) ExitAlter_type(ctx *Alter_typeContext) {} + +// EnterCompile_type_clause is called when production compile_type_clause is entered. +func (s *BasePlSqlParserListener) EnterCompile_type_clause(ctx *Compile_type_clauseContext) {} + +// ExitCompile_type_clause is called when production compile_type_clause is exited. +func (s *BasePlSqlParserListener) ExitCompile_type_clause(ctx *Compile_type_clauseContext) {} + +// EnterReplace_type_clause is called when production replace_type_clause is entered. +func (s *BasePlSqlParserListener) EnterReplace_type_clause(ctx *Replace_type_clauseContext) {} + +// ExitReplace_type_clause is called when production replace_type_clause is exited. +func (s *BasePlSqlParserListener) ExitReplace_type_clause(ctx *Replace_type_clauseContext) {} + +// EnterAlter_method_spec is called when production alter_method_spec is entered. +func (s *BasePlSqlParserListener) EnterAlter_method_spec(ctx *Alter_method_specContext) {} + +// ExitAlter_method_spec is called when production alter_method_spec is exited. +func (s *BasePlSqlParserListener) ExitAlter_method_spec(ctx *Alter_method_specContext) {} + +// EnterAlter_method_element is called when production alter_method_element is entered. +func (s *BasePlSqlParserListener) EnterAlter_method_element(ctx *Alter_method_elementContext) {} + +// ExitAlter_method_element is called when production alter_method_element is exited. +func (s *BasePlSqlParserListener) ExitAlter_method_element(ctx *Alter_method_elementContext) {} + +// EnterAlter_collection_clauses is called when production alter_collection_clauses is entered. +func (s *BasePlSqlParserListener) EnterAlter_collection_clauses(ctx *Alter_collection_clausesContext) { +} + +// ExitAlter_collection_clauses is called when production alter_collection_clauses is exited. +func (s *BasePlSqlParserListener) ExitAlter_collection_clauses(ctx *Alter_collection_clausesContext) { +} + +// EnterDependent_handling_clause is called when production dependent_handling_clause is entered. +func (s *BasePlSqlParserListener) EnterDependent_handling_clause(ctx *Dependent_handling_clauseContext) { +} + +// ExitDependent_handling_clause is called when production dependent_handling_clause is exited. +func (s *BasePlSqlParserListener) ExitDependent_handling_clause(ctx *Dependent_handling_clauseContext) { +} + +// EnterDependent_exceptions_part is called when production dependent_exceptions_part is entered. +func (s *BasePlSqlParserListener) EnterDependent_exceptions_part(ctx *Dependent_exceptions_partContext) { +} + +// ExitDependent_exceptions_part is called when production dependent_exceptions_part is exited. +func (s *BasePlSqlParserListener) ExitDependent_exceptions_part(ctx *Dependent_exceptions_partContext) { +} + +// EnterCreate_type is called when production create_type is entered. +func (s *BasePlSqlParserListener) EnterCreate_type(ctx *Create_typeContext) {} + +// ExitCreate_type is called when production create_type is exited. +func (s *BasePlSqlParserListener) ExitCreate_type(ctx *Create_typeContext) {} + +// EnterType_definition is called when production type_definition is entered. +func (s *BasePlSqlParserListener) EnterType_definition(ctx *Type_definitionContext) {} + +// ExitType_definition is called when production type_definition is exited. +func (s *BasePlSqlParserListener) ExitType_definition(ctx *Type_definitionContext) {} + +// EnterObject_type_def is called when production object_type_def is entered. +func (s *BasePlSqlParserListener) EnterObject_type_def(ctx *Object_type_defContext) {} + +// ExitObject_type_def is called when production object_type_def is exited. +func (s *BasePlSqlParserListener) ExitObject_type_def(ctx *Object_type_defContext) {} + +// EnterObject_as_part is called when production object_as_part is entered. +func (s *BasePlSqlParserListener) EnterObject_as_part(ctx *Object_as_partContext) {} + +// ExitObject_as_part is called when production object_as_part is exited. +func (s *BasePlSqlParserListener) ExitObject_as_part(ctx *Object_as_partContext) {} + +// EnterObject_under_part is called when production object_under_part is entered. +func (s *BasePlSqlParserListener) EnterObject_under_part(ctx *Object_under_partContext) {} + +// ExitObject_under_part is called when production object_under_part is exited. +func (s *BasePlSqlParserListener) ExitObject_under_part(ctx *Object_under_partContext) {} + +// EnterNested_table_type_def is called when production nested_table_type_def is entered. +func (s *BasePlSqlParserListener) EnterNested_table_type_def(ctx *Nested_table_type_defContext) {} + +// ExitNested_table_type_def is called when production nested_table_type_def is exited. +func (s *BasePlSqlParserListener) ExitNested_table_type_def(ctx *Nested_table_type_defContext) {} + +// EnterSqlj_object_type is called when production sqlj_object_type is entered. +func (s *BasePlSqlParserListener) EnterSqlj_object_type(ctx *Sqlj_object_typeContext) {} + +// ExitSqlj_object_type is called when production sqlj_object_type is exited. +func (s *BasePlSqlParserListener) ExitSqlj_object_type(ctx *Sqlj_object_typeContext) {} + +// EnterType_body is called when production type_body is entered. +func (s *BasePlSqlParserListener) EnterType_body(ctx *Type_bodyContext) {} + +// ExitType_body is called when production type_body is exited. +func (s *BasePlSqlParserListener) ExitType_body(ctx *Type_bodyContext) {} + +// EnterType_body_elements is called when production type_body_elements is entered. +func (s *BasePlSqlParserListener) EnterType_body_elements(ctx *Type_body_elementsContext) {} + +// ExitType_body_elements is called when production type_body_elements is exited. +func (s *BasePlSqlParserListener) ExitType_body_elements(ctx *Type_body_elementsContext) {} + +// EnterMap_order_func_declaration is called when production map_order_func_declaration is entered. +func (s *BasePlSqlParserListener) EnterMap_order_func_declaration(ctx *Map_order_func_declarationContext) { +} + +// ExitMap_order_func_declaration is called when production map_order_func_declaration is exited. +func (s *BasePlSqlParserListener) ExitMap_order_func_declaration(ctx *Map_order_func_declarationContext) { +} + +// EnterSubprog_decl_in_type is called when production subprog_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) {} + +// ExitSubprog_decl_in_type is called when production subprog_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) {} + +// EnterProc_decl_in_type is called when production proc_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterProc_decl_in_type(ctx *Proc_decl_in_typeContext) {} + +// ExitProc_decl_in_type is called when production proc_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitProc_decl_in_type(ctx *Proc_decl_in_typeContext) {} + +// EnterFunc_decl_in_type is called when production func_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterFunc_decl_in_type(ctx *Func_decl_in_typeContext) {} + +// ExitFunc_decl_in_type is called when production func_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitFunc_decl_in_type(ctx *Func_decl_in_typeContext) {} + +// EnterConstructor_declaration is called when production constructor_declaration is entered. +func (s *BasePlSqlParserListener) EnterConstructor_declaration(ctx *Constructor_declarationContext) {} + +// ExitConstructor_declaration is called when production constructor_declaration is exited. +func (s *BasePlSqlParserListener) ExitConstructor_declaration(ctx *Constructor_declarationContext) {} + +// EnterModifier_clause is called when production modifier_clause is entered. +func (s *BasePlSqlParserListener) EnterModifier_clause(ctx *Modifier_clauseContext) {} + +// ExitModifier_clause is called when production modifier_clause is exited. +func (s *BasePlSqlParserListener) ExitModifier_clause(ctx *Modifier_clauseContext) {} + +// EnterObject_member_spec is called when production object_member_spec is entered. +func (s *BasePlSqlParserListener) EnterObject_member_spec(ctx *Object_member_specContext) {} + +// ExitObject_member_spec is called when production object_member_spec is exited. +func (s *BasePlSqlParserListener) ExitObject_member_spec(ctx *Object_member_specContext) {} + +// EnterSqlj_object_type_attr is called when production sqlj_object_type_attr is entered. +func (s *BasePlSqlParserListener) EnterSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) {} + +// ExitSqlj_object_type_attr is called when production sqlj_object_type_attr is exited. +func (s *BasePlSqlParserListener) ExitSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) {} + +// EnterElement_spec is called when production element_spec is entered. +func (s *BasePlSqlParserListener) EnterElement_spec(ctx *Element_specContext) {} + +// ExitElement_spec is called when production element_spec is exited. +func (s *BasePlSqlParserListener) ExitElement_spec(ctx *Element_specContext) {} + +// EnterElement_spec_options is called when production element_spec_options is entered. +func (s *BasePlSqlParserListener) EnterElement_spec_options(ctx *Element_spec_optionsContext) {} + +// ExitElement_spec_options is called when production element_spec_options is exited. +func (s *BasePlSqlParserListener) ExitElement_spec_options(ctx *Element_spec_optionsContext) {} + +// EnterSubprogram_spec is called when production subprogram_spec is entered. +func (s *BasePlSqlParserListener) EnterSubprogram_spec(ctx *Subprogram_specContext) {} + +// ExitSubprogram_spec is called when production subprogram_spec is exited. +func (s *BasePlSqlParserListener) ExitSubprogram_spec(ctx *Subprogram_specContext) {} + +// EnterOverriding_subprogram_spec is called when production overriding_subprogram_spec is entered. +func (s *BasePlSqlParserListener) EnterOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) { +} + +// ExitOverriding_subprogram_spec is called when production overriding_subprogram_spec is exited. +func (s *BasePlSqlParserListener) ExitOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) { +} + +// EnterOverriding_function_spec is called when production overriding_function_spec is entered. +func (s *BasePlSqlParserListener) EnterOverriding_function_spec(ctx *Overriding_function_specContext) { +} + +// ExitOverriding_function_spec is called when production overriding_function_spec is exited. +func (s *BasePlSqlParserListener) ExitOverriding_function_spec(ctx *Overriding_function_specContext) { +} + +// EnterOverriding_procedure_spec is called when production overriding_procedure_spec is entered. +func (s *BasePlSqlParserListener) EnterOverriding_procedure_spec(ctx *Overriding_procedure_specContext) { +} + +// ExitOverriding_procedure_spec is called when production overriding_procedure_spec is exited. +func (s *BasePlSqlParserListener) ExitOverriding_procedure_spec(ctx *Overriding_procedure_specContext) { +} + +// EnterType_procedure_spec is called when production type_procedure_spec is entered. +func (s *BasePlSqlParserListener) EnterType_procedure_spec(ctx *Type_procedure_specContext) {} + +// ExitType_procedure_spec is called when production type_procedure_spec is exited. +func (s *BasePlSqlParserListener) ExitType_procedure_spec(ctx *Type_procedure_specContext) {} + +// EnterType_function_spec is called when production type_function_spec is entered. +func (s *BasePlSqlParserListener) EnterType_function_spec(ctx *Type_function_specContext) {} + +// ExitType_function_spec is called when production type_function_spec is exited. +func (s *BasePlSqlParserListener) ExitType_function_spec(ctx *Type_function_specContext) {} + +// EnterConstructor_spec is called when production constructor_spec is entered. +func (s *BasePlSqlParserListener) EnterConstructor_spec(ctx *Constructor_specContext) {} + +// ExitConstructor_spec is called when production constructor_spec is exited. +func (s *BasePlSqlParserListener) ExitConstructor_spec(ctx *Constructor_specContext) {} + +// EnterMap_order_function_spec is called when production map_order_function_spec is entered. +func (s *BasePlSqlParserListener) EnterMap_order_function_spec(ctx *Map_order_function_specContext) {} + +// ExitMap_order_function_spec is called when production map_order_function_spec is exited. +func (s *BasePlSqlParserListener) ExitMap_order_function_spec(ctx *Map_order_function_specContext) {} + +// EnterPragma_clause is called when production pragma_clause is entered. +func (s *BasePlSqlParserListener) EnterPragma_clause(ctx *Pragma_clauseContext) {} + +// ExitPragma_clause is called when production pragma_clause is exited. +func (s *BasePlSqlParserListener) ExitPragma_clause(ctx *Pragma_clauseContext) {} + +// EnterPragma_elements is called when production pragma_elements is entered. +func (s *BasePlSqlParserListener) EnterPragma_elements(ctx *Pragma_elementsContext) {} + +// ExitPragma_elements is called when production pragma_elements is exited. +func (s *BasePlSqlParserListener) ExitPragma_elements(ctx *Pragma_elementsContext) {} + +// EnterType_elements_parameter is called when production type_elements_parameter is entered. +func (s *BasePlSqlParserListener) EnterType_elements_parameter(ctx *Type_elements_parameterContext) {} + +// ExitType_elements_parameter is called when production type_elements_parameter is exited. +func (s *BasePlSqlParserListener) ExitType_elements_parameter(ctx *Type_elements_parameterContext) {} + +// EnterDrop_sequence is called when production drop_sequence is entered. +func (s *BasePlSqlParserListener) EnterDrop_sequence(ctx *Drop_sequenceContext) {} + +// ExitDrop_sequence is called when production drop_sequence is exited. +func (s *BasePlSqlParserListener) ExitDrop_sequence(ctx *Drop_sequenceContext) {} + +// EnterAlter_sequence is called when production alter_sequence is entered. +func (s *BasePlSqlParserListener) EnterAlter_sequence(ctx *Alter_sequenceContext) {} + +// ExitAlter_sequence is called when production alter_sequence is exited. +func (s *BasePlSqlParserListener) ExitAlter_sequence(ctx *Alter_sequenceContext) {} + +// EnterAlter_session is called when production alter_session is entered. +func (s *BasePlSqlParserListener) EnterAlter_session(ctx *Alter_sessionContext) {} + +// ExitAlter_session is called when production alter_session is exited. +func (s *BasePlSqlParserListener) ExitAlter_session(ctx *Alter_sessionContext) {} + +// EnterAlter_session_set_clause is called when production alter_session_set_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_session_set_clause(ctx *Alter_session_set_clauseContext) { +} + +// ExitAlter_session_set_clause is called when production alter_session_set_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_session_set_clause(ctx *Alter_session_set_clauseContext) { +} + +// EnterCreate_sequence is called when production create_sequence is entered. +func (s *BasePlSqlParserListener) EnterCreate_sequence(ctx *Create_sequenceContext) {} + +// ExitCreate_sequence is called when production create_sequence is exited. +func (s *BasePlSqlParserListener) ExitCreate_sequence(ctx *Create_sequenceContext) {} + +// EnterSequence_spec is called when production sequence_spec is entered. +func (s *BasePlSqlParserListener) EnterSequence_spec(ctx *Sequence_specContext) {} + +// ExitSequence_spec is called when production sequence_spec is exited. +func (s *BasePlSqlParserListener) ExitSequence_spec(ctx *Sequence_specContext) {} + +// EnterSequence_start_clause is called when production sequence_start_clause is entered. +func (s *BasePlSqlParserListener) EnterSequence_start_clause(ctx *Sequence_start_clauseContext) {} + +// ExitSequence_start_clause is called when production sequence_start_clause is exited. +func (s *BasePlSqlParserListener) ExitSequence_start_clause(ctx *Sequence_start_clauseContext) {} + +// EnterCreate_analytic_view is called when production create_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_analytic_view(ctx *Create_analytic_viewContext) {} + +// ExitCreate_analytic_view is called when production create_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_analytic_view(ctx *Create_analytic_viewContext) {} + +// EnterClassification_clause is called when production classification_clause is entered. +func (s *BasePlSqlParserListener) EnterClassification_clause(ctx *Classification_clauseContext) {} + +// ExitClassification_clause is called when production classification_clause is exited. +func (s *BasePlSqlParserListener) ExitClassification_clause(ctx *Classification_clauseContext) {} + +// EnterCaption_clause is called when production caption_clause is entered. +func (s *BasePlSqlParserListener) EnterCaption_clause(ctx *Caption_clauseContext) {} + +// ExitCaption_clause is called when production caption_clause is exited. +func (s *BasePlSqlParserListener) ExitCaption_clause(ctx *Caption_clauseContext) {} + +// EnterDescription_clause is called when production description_clause is entered. +func (s *BasePlSqlParserListener) EnterDescription_clause(ctx *Description_clauseContext) {} + +// ExitDescription_clause is called when production description_clause is exited. +func (s *BasePlSqlParserListener) ExitDescription_clause(ctx *Description_clauseContext) {} + +// EnterClassification_item is called when production classification_item is entered. +func (s *BasePlSqlParserListener) EnterClassification_item(ctx *Classification_itemContext) {} + +// ExitClassification_item is called when production classification_item is exited. +func (s *BasePlSqlParserListener) ExitClassification_item(ctx *Classification_itemContext) {} + +// EnterLanguage is called when production language is entered. +func (s *BasePlSqlParserListener) EnterLanguage(ctx *LanguageContext) {} + +// ExitLanguage is called when production language is exited. +func (s *BasePlSqlParserListener) ExitLanguage(ctx *LanguageContext) {} + +// EnterCav_using_clause is called when production cav_using_clause is entered. +func (s *BasePlSqlParserListener) EnterCav_using_clause(ctx *Cav_using_clauseContext) {} + +// ExitCav_using_clause is called when production cav_using_clause is exited. +func (s *BasePlSqlParserListener) ExitCav_using_clause(ctx *Cav_using_clauseContext) {} + +// EnterDim_by_clause is called when production dim_by_clause is entered. +func (s *BasePlSqlParserListener) EnterDim_by_clause(ctx *Dim_by_clauseContext) {} + +// ExitDim_by_clause is called when production dim_by_clause is exited. +func (s *BasePlSqlParserListener) ExitDim_by_clause(ctx *Dim_by_clauseContext) {} + +// EnterDim_key is called when production dim_key is entered. +func (s *BasePlSqlParserListener) EnterDim_key(ctx *Dim_keyContext) {} + +// ExitDim_key is called when production dim_key is exited. +func (s *BasePlSqlParserListener) ExitDim_key(ctx *Dim_keyContext) {} + +// EnterDim_ref is called when production dim_ref is entered. +func (s *BasePlSqlParserListener) EnterDim_ref(ctx *Dim_refContext) {} + +// ExitDim_ref is called when production dim_ref is exited. +func (s *BasePlSqlParserListener) ExitDim_ref(ctx *Dim_refContext) {} + +// EnterHier_ref is called when production hier_ref is entered. +func (s *BasePlSqlParserListener) EnterHier_ref(ctx *Hier_refContext) {} + +// ExitHier_ref is called when production hier_ref is exited. +func (s *BasePlSqlParserListener) ExitHier_ref(ctx *Hier_refContext) {} + +// EnterMeasures_clause is called when production measures_clause is entered. +func (s *BasePlSqlParserListener) EnterMeasures_clause(ctx *Measures_clauseContext) {} + +// ExitMeasures_clause is called when production measures_clause is exited. +func (s *BasePlSqlParserListener) ExitMeasures_clause(ctx *Measures_clauseContext) {} + +// EnterAv_measure is called when production av_measure is entered. +func (s *BasePlSqlParserListener) EnterAv_measure(ctx *Av_measureContext) {} + +// ExitAv_measure is called when production av_measure is exited. +func (s *BasePlSqlParserListener) ExitAv_measure(ctx *Av_measureContext) {} + +// EnterBase_meas_clause is called when production base_meas_clause is entered. +func (s *BasePlSqlParserListener) EnterBase_meas_clause(ctx *Base_meas_clauseContext) {} + +// ExitBase_meas_clause is called when production base_meas_clause is exited. +func (s *BasePlSqlParserListener) ExitBase_meas_clause(ctx *Base_meas_clauseContext) {} + +// EnterMeas_aggregate_clause is called when production meas_aggregate_clause is entered. +func (s *BasePlSqlParserListener) EnterMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) {} + +// ExitMeas_aggregate_clause is called when production meas_aggregate_clause is exited. +func (s *BasePlSqlParserListener) ExitMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) {} + +// EnterCalc_meas_clause is called when production calc_meas_clause is entered. +func (s *BasePlSqlParserListener) EnterCalc_meas_clause(ctx *Calc_meas_clauseContext) {} + +// ExitCalc_meas_clause is called when production calc_meas_clause is exited. +func (s *BasePlSqlParserListener) ExitCalc_meas_clause(ctx *Calc_meas_clauseContext) {} + +// EnterDefault_measure_clause is called when production default_measure_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_measure_clause(ctx *Default_measure_clauseContext) {} + +// ExitDefault_measure_clause is called when production default_measure_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_measure_clause(ctx *Default_measure_clauseContext) {} + +// EnterDefault_aggregate_clause is called when production default_aggregate_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) { +} + +// ExitDefault_aggregate_clause is called when production default_aggregate_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) { +} + +// EnterCache_clause is called when production cache_clause is entered. +func (s *BasePlSqlParserListener) EnterCache_clause(ctx *Cache_clauseContext) {} + +// ExitCache_clause is called when production cache_clause is exited. +func (s *BasePlSqlParserListener) ExitCache_clause(ctx *Cache_clauseContext) {} + +// EnterCache_specification is called when production cache_specification is entered. +func (s *BasePlSqlParserListener) EnterCache_specification(ctx *Cache_specificationContext) {} + +// ExitCache_specification is called when production cache_specification is exited. +func (s *BasePlSqlParserListener) ExitCache_specification(ctx *Cache_specificationContext) {} + +// EnterLevels_clause is called when production levels_clause is entered. +func (s *BasePlSqlParserListener) EnterLevels_clause(ctx *Levels_clauseContext) {} + +// ExitLevels_clause is called when production levels_clause is exited. +func (s *BasePlSqlParserListener) ExitLevels_clause(ctx *Levels_clauseContext) {} + +// EnterLevel_specification is called when production level_specification is entered. +func (s *BasePlSqlParserListener) EnterLevel_specification(ctx *Level_specificationContext) {} + +// ExitLevel_specification is called when production level_specification is exited. +func (s *BasePlSqlParserListener) ExitLevel_specification(ctx *Level_specificationContext) {} + +// EnterLevel_group_type is called when production level_group_type is entered. +func (s *BasePlSqlParserListener) EnterLevel_group_type(ctx *Level_group_typeContext) {} + +// ExitLevel_group_type is called when production level_group_type is exited. +func (s *BasePlSqlParserListener) ExitLevel_group_type(ctx *Level_group_typeContext) {} + +// EnterFact_columns_clause is called when production fact_columns_clause is entered. +func (s *BasePlSqlParserListener) EnterFact_columns_clause(ctx *Fact_columns_clauseContext) {} + +// ExitFact_columns_clause is called when production fact_columns_clause is exited. +func (s *BasePlSqlParserListener) ExitFact_columns_clause(ctx *Fact_columns_clauseContext) {} + +// EnterQry_transform_clause is called when production qry_transform_clause is entered. +func (s *BasePlSqlParserListener) EnterQry_transform_clause(ctx *Qry_transform_clauseContext) {} + +// ExitQry_transform_clause is called when production qry_transform_clause is exited. +func (s *BasePlSqlParserListener) ExitQry_transform_clause(ctx *Qry_transform_clauseContext) {} + +// EnterCreate_attribute_dimension is called when production create_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) { +} + +// ExitCreate_attribute_dimension is called when production create_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) { +} + +// EnterAd_using_clause is called when production ad_using_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_using_clause(ctx *Ad_using_clauseContext) {} + +// ExitAd_using_clause is called when production ad_using_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_using_clause(ctx *Ad_using_clauseContext) {} + +// EnterSource_clause is called when production source_clause is entered. +func (s *BasePlSqlParserListener) EnterSource_clause(ctx *Source_clauseContext) {} + +// ExitSource_clause is called when production source_clause is exited. +func (s *BasePlSqlParserListener) ExitSource_clause(ctx *Source_clauseContext) {} + +// EnterJoin_path_clause is called when production join_path_clause is entered. +func (s *BasePlSqlParserListener) EnterJoin_path_clause(ctx *Join_path_clauseContext) {} + +// ExitJoin_path_clause is called when production join_path_clause is exited. +func (s *BasePlSqlParserListener) ExitJoin_path_clause(ctx *Join_path_clauseContext) {} + +// EnterJoin_condition is called when production join_condition is entered. +func (s *BasePlSqlParserListener) EnterJoin_condition(ctx *Join_conditionContext) {} + +// ExitJoin_condition is called when production join_condition is exited. +func (s *BasePlSqlParserListener) ExitJoin_condition(ctx *Join_conditionContext) {} + +// EnterJoin_condition_item is called when production join_condition_item is entered. +func (s *BasePlSqlParserListener) EnterJoin_condition_item(ctx *Join_condition_itemContext) {} + +// ExitJoin_condition_item is called when production join_condition_item is exited. +func (s *BasePlSqlParserListener) ExitJoin_condition_item(ctx *Join_condition_itemContext) {} + +// EnterAttributes_clause is called when production attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterAttributes_clause(ctx *Attributes_clauseContext) {} + +// ExitAttributes_clause is called when production attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitAttributes_clause(ctx *Attributes_clauseContext) {} + +// EnterAd_attributes_clause is called when production ad_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_attributes_clause(ctx *Ad_attributes_clauseContext) {} + +// ExitAd_attributes_clause is called when production ad_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_attributes_clause(ctx *Ad_attributes_clauseContext) {} + +// EnterAd_level_clause is called when production ad_level_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_level_clause(ctx *Ad_level_clauseContext) {} + +// ExitAd_level_clause is called when production ad_level_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_level_clause(ctx *Ad_level_clauseContext) {} + +// EnterKey_clause is called when production key_clause is entered. +func (s *BasePlSqlParserListener) EnterKey_clause(ctx *Key_clauseContext) {} + +// ExitKey_clause is called when production key_clause is exited. +func (s *BasePlSqlParserListener) ExitKey_clause(ctx *Key_clauseContext) {} + +// EnterAlternate_key_clause is called when production alternate_key_clause is entered. +func (s *BasePlSqlParserListener) EnterAlternate_key_clause(ctx *Alternate_key_clauseContext) {} + +// ExitAlternate_key_clause is called when production alternate_key_clause is exited. +func (s *BasePlSqlParserListener) ExitAlternate_key_clause(ctx *Alternate_key_clauseContext) {} + +// EnterDim_order_clause is called when production dim_order_clause is entered. +func (s *BasePlSqlParserListener) EnterDim_order_clause(ctx *Dim_order_clauseContext) {} + +// ExitDim_order_clause is called when production dim_order_clause is exited. +func (s *BasePlSqlParserListener) ExitDim_order_clause(ctx *Dim_order_clauseContext) {} + +// EnterAll_clause is called when production all_clause is entered. +func (s *BasePlSqlParserListener) EnterAll_clause(ctx *All_clauseContext) {} + +// ExitAll_clause is called when production all_clause is exited. +func (s *BasePlSqlParserListener) ExitAll_clause(ctx *All_clauseContext) {} + +// EnterCreate_audit_policy is called when production create_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterCreate_audit_policy(ctx *Create_audit_policyContext) {} + +// ExitCreate_audit_policy is called when production create_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitCreate_audit_policy(ctx *Create_audit_policyContext) {} + +// EnterPrivilege_audit_clause is called when production privilege_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) {} + +// ExitPrivilege_audit_clause is called when production privilege_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) {} + +// EnterAction_audit_clause is called when production action_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterAction_audit_clause(ctx *Action_audit_clauseContext) {} + +// ExitAction_audit_clause is called when production action_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitAction_audit_clause(ctx *Action_audit_clauseContext) {} + +// EnterSystem_actions is called when production system_actions is entered. +func (s *BasePlSqlParserListener) EnterSystem_actions(ctx *System_actionsContext) {} + +// ExitSystem_actions is called when production system_actions is exited. +func (s *BasePlSqlParserListener) ExitSystem_actions(ctx *System_actionsContext) {} + +// EnterStandard_actions is called when production standard_actions is entered. +func (s *BasePlSqlParserListener) EnterStandard_actions(ctx *Standard_actionsContext) {} + +// ExitStandard_actions is called when production standard_actions is exited. +func (s *BasePlSqlParserListener) ExitStandard_actions(ctx *Standard_actionsContext) {} + +// EnterActions_clause is called when production actions_clause is entered. +func (s *BasePlSqlParserListener) EnterActions_clause(ctx *Actions_clauseContext) {} + +// ExitActions_clause is called when production actions_clause is exited. +func (s *BasePlSqlParserListener) ExitActions_clause(ctx *Actions_clauseContext) {} + +// EnterObject_action is called when production object_action is entered. +func (s *BasePlSqlParserListener) EnterObject_action(ctx *Object_actionContext) {} + +// ExitObject_action is called when production object_action is exited. +func (s *BasePlSqlParserListener) ExitObject_action(ctx *Object_actionContext) {} + +// EnterSystem_action is called when production system_action is entered. +func (s *BasePlSqlParserListener) EnterSystem_action(ctx *System_actionContext) {} + +// ExitSystem_action is called when production system_action is exited. +func (s *BasePlSqlParserListener) ExitSystem_action(ctx *System_actionContext) {} + +// EnterComponent_actions is called when production component_actions is entered. +func (s *BasePlSqlParserListener) EnterComponent_actions(ctx *Component_actionsContext) {} + +// ExitComponent_actions is called when production component_actions is exited. +func (s *BasePlSqlParserListener) ExitComponent_actions(ctx *Component_actionsContext) {} + +// EnterComponent_action is called when production component_action is entered. +func (s *BasePlSqlParserListener) EnterComponent_action(ctx *Component_actionContext) {} + +// ExitComponent_action is called when production component_action is exited. +func (s *BasePlSqlParserListener) ExitComponent_action(ctx *Component_actionContext) {} + +// EnterRole_audit_clause is called when production role_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_audit_clause(ctx *Role_audit_clauseContext) {} + +// ExitRole_audit_clause is called when production role_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_audit_clause(ctx *Role_audit_clauseContext) {} + +// EnterCreate_controlfile is called when production create_controlfile is entered. +func (s *BasePlSqlParserListener) EnterCreate_controlfile(ctx *Create_controlfileContext) {} + +// ExitCreate_controlfile is called when production create_controlfile is exited. +func (s *BasePlSqlParserListener) ExitCreate_controlfile(ctx *Create_controlfileContext) {} + +// EnterControlfile_options is called when production controlfile_options is entered. +func (s *BasePlSqlParserListener) EnterControlfile_options(ctx *Controlfile_optionsContext) {} + +// ExitControlfile_options is called when production controlfile_options is exited. +func (s *BasePlSqlParserListener) ExitControlfile_options(ctx *Controlfile_optionsContext) {} + +// EnterLogfile_clause is called when production logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterLogfile_clause(ctx *Logfile_clauseContext) {} + +// ExitLogfile_clause is called when production logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitLogfile_clause(ctx *Logfile_clauseContext) {} + +// EnterCharacter_set_clause is called when production character_set_clause is entered. +func (s *BasePlSqlParserListener) EnterCharacter_set_clause(ctx *Character_set_clauseContext) {} + +// ExitCharacter_set_clause is called when production character_set_clause is exited. +func (s *BasePlSqlParserListener) ExitCharacter_set_clause(ctx *Character_set_clauseContext) {} + +// EnterFile_specification is called when production file_specification is entered. +func (s *BasePlSqlParserListener) EnterFile_specification(ctx *File_specificationContext) {} + +// ExitFile_specification is called when production file_specification is exited. +func (s *BasePlSqlParserListener) ExitFile_specification(ctx *File_specificationContext) {} + +// EnterCreate_diskgroup is called when production create_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterCreate_diskgroup(ctx *Create_diskgroupContext) {} + +// ExitCreate_diskgroup is called when production create_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitCreate_diskgroup(ctx *Create_diskgroupContext) {} + +// EnterQualified_disk_clause is called when production qualified_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterQualified_disk_clause(ctx *Qualified_disk_clauseContext) {} + +// ExitQualified_disk_clause is called when production qualified_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitQualified_disk_clause(ctx *Qualified_disk_clauseContext) {} + +// EnterCreate_edition is called when production create_edition is entered. +func (s *BasePlSqlParserListener) EnterCreate_edition(ctx *Create_editionContext) {} + +// ExitCreate_edition is called when production create_edition is exited. +func (s *BasePlSqlParserListener) ExitCreate_edition(ctx *Create_editionContext) {} + +// EnterCreate_flashback_archive is called when production create_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterCreate_flashback_archive(ctx *Create_flashback_archiveContext) { +} + +// ExitCreate_flashback_archive is called when production create_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitCreate_flashback_archive(ctx *Create_flashback_archiveContext) { +} + +// EnterFlashback_archive_quota is called when production flashback_archive_quota is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_quota(ctx *Flashback_archive_quotaContext) {} + +// ExitFlashback_archive_quota is called when production flashback_archive_quota is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_quota(ctx *Flashback_archive_quotaContext) {} + +// EnterFlashback_archive_retention is called when production flashback_archive_retention is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_retention(ctx *Flashback_archive_retentionContext) { +} + +// ExitFlashback_archive_retention is called when production flashback_archive_retention is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_retention(ctx *Flashback_archive_retentionContext) { +} + +// EnterCreate_hierarchy is called when production create_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterCreate_hierarchy(ctx *Create_hierarchyContext) {} + +// ExitCreate_hierarchy is called when production create_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitCreate_hierarchy(ctx *Create_hierarchyContext) {} + +// EnterHier_using_clause is called when production hier_using_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_using_clause(ctx *Hier_using_clauseContext) {} + +// ExitHier_using_clause is called when production hier_using_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_using_clause(ctx *Hier_using_clauseContext) {} + +// EnterLevel_hier_clause is called when production level_hier_clause is entered. +func (s *BasePlSqlParserListener) EnterLevel_hier_clause(ctx *Level_hier_clauseContext) {} + +// ExitLevel_hier_clause is called when production level_hier_clause is exited. +func (s *BasePlSqlParserListener) ExitLevel_hier_clause(ctx *Level_hier_clauseContext) {} + +// EnterHier_attrs_clause is called when production hier_attrs_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_attrs_clause(ctx *Hier_attrs_clauseContext) {} + +// ExitHier_attrs_clause is called when production hier_attrs_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_attrs_clause(ctx *Hier_attrs_clauseContext) {} + +// EnterHier_attr_clause is called when production hier_attr_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_attr_clause(ctx *Hier_attr_clauseContext) {} + +// ExitHier_attr_clause is called when production hier_attr_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_attr_clause(ctx *Hier_attr_clauseContext) {} + +// EnterHier_attr_name is called when production hier_attr_name is entered. +func (s *BasePlSqlParserListener) EnterHier_attr_name(ctx *Hier_attr_nameContext) {} + +// ExitHier_attr_name is called when production hier_attr_name is exited. +func (s *BasePlSqlParserListener) ExitHier_attr_name(ctx *Hier_attr_nameContext) {} + +// EnterCreate_index is called when production create_index is entered. +func (s *BasePlSqlParserListener) EnterCreate_index(ctx *Create_indexContext) {} + +// ExitCreate_index is called when production create_index is exited. +func (s *BasePlSqlParserListener) ExitCreate_index(ctx *Create_indexContext) {} + +// EnterCluster_index_clause is called when production cluster_index_clause is entered. +func (s *BasePlSqlParserListener) EnterCluster_index_clause(ctx *Cluster_index_clauseContext) {} + +// ExitCluster_index_clause is called when production cluster_index_clause is exited. +func (s *BasePlSqlParserListener) ExitCluster_index_clause(ctx *Cluster_index_clauseContext) {} + +// EnterCluster_name is called when production cluster_name is entered. +func (s *BasePlSqlParserListener) EnterCluster_name(ctx *Cluster_nameContext) {} + +// ExitCluster_name is called when production cluster_name is exited. +func (s *BasePlSqlParserListener) ExitCluster_name(ctx *Cluster_nameContext) {} + +// EnterTable_index_clause is called when production table_index_clause is entered. +func (s *BasePlSqlParserListener) EnterTable_index_clause(ctx *Table_index_clauseContext) {} + +// ExitTable_index_clause is called when production table_index_clause is exited. +func (s *BasePlSqlParserListener) ExitTable_index_clause(ctx *Table_index_clauseContext) {} + +// EnterBitmap_join_index_clause is called when production bitmap_join_index_clause is entered. +func (s *BasePlSqlParserListener) EnterBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) { +} + +// ExitBitmap_join_index_clause is called when production bitmap_join_index_clause is exited. +func (s *BasePlSqlParserListener) ExitBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) { +} + +// EnterIndex_expr is called when production index_expr is entered. +func (s *BasePlSqlParserListener) EnterIndex_expr(ctx *Index_exprContext) {} + +// ExitIndex_expr is called when production index_expr is exited. +func (s *BasePlSqlParserListener) ExitIndex_expr(ctx *Index_exprContext) {} + +// EnterIndex_properties is called when production index_properties is entered. +func (s *BasePlSqlParserListener) EnterIndex_properties(ctx *Index_propertiesContext) {} + +// ExitIndex_properties is called when production index_properties is exited. +func (s *BasePlSqlParserListener) ExitIndex_properties(ctx *Index_propertiesContext) {} + +// EnterDomain_index_clause is called when production domain_index_clause is entered. +func (s *BasePlSqlParserListener) EnterDomain_index_clause(ctx *Domain_index_clauseContext) {} + +// ExitDomain_index_clause is called when production domain_index_clause is exited. +func (s *BasePlSqlParserListener) ExitDomain_index_clause(ctx *Domain_index_clauseContext) {} + +// EnterLocal_domain_index_clause is called when production local_domain_index_clause is entered. +func (s *BasePlSqlParserListener) EnterLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) { +} + +// ExitLocal_domain_index_clause is called when production local_domain_index_clause is exited. +func (s *BasePlSqlParserListener) ExitLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) { +} + +// EnterXmlindex_clause is called when production xmlindex_clause is entered. +func (s *BasePlSqlParserListener) EnterXmlindex_clause(ctx *Xmlindex_clauseContext) {} + +// ExitXmlindex_clause is called when production xmlindex_clause is exited. +func (s *BasePlSqlParserListener) ExitXmlindex_clause(ctx *Xmlindex_clauseContext) {} + +// EnterLocal_xmlindex_clause is called when production local_xmlindex_clause is entered. +func (s *BasePlSqlParserListener) EnterLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) {} + +// ExitLocal_xmlindex_clause is called when production local_xmlindex_clause is exited. +func (s *BasePlSqlParserListener) ExitLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) {} + +// EnterGlobal_partitioned_index is called when production global_partitioned_index is entered. +func (s *BasePlSqlParserListener) EnterGlobal_partitioned_index(ctx *Global_partitioned_indexContext) { +} + +// ExitGlobal_partitioned_index is called when production global_partitioned_index is exited. +func (s *BasePlSqlParserListener) ExitGlobal_partitioned_index(ctx *Global_partitioned_indexContext) { +} + +// EnterIndex_partitioning_clause is called when production index_partitioning_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) { +} + +// ExitIndex_partitioning_clause is called when production index_partitioning_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) { +} + +// EnterIndex_partitioning_values_list is called when production index_partitioning_values_list is entered. +func (s *BasePlSqlParserListener) EnterIndex_partitioning_values_list(ctx *Index_partitioning_values_listContext) { +} + +// ExitIndex_partitioning_values_list is called when production index_partitioning_values_list is exited. +func (s *BasePlSqlParserListener) ExitIndex_partitioning_values_list(ctx *Index_partitioning_values_listContext) { +} + +// EnterLocal_partitioned_index is called when production local_partitioned_index is entered. +func (s *BasePlSqlParserListener) EnterLocal_partitioned_index(ctx *Local_partitioned_indexContext) {} + +// ExitLocal_partitioned_index is called when production local_partitioned_index is exited. +func (s *BasePlSqlParserListener) ExitLocal_partitioned_index(ctx *Local_partitioned_indexContext) {} + +// EnterOn_range_partitioned_table is called when production on_range_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) { +} + +// ExitOn_range_partitioned_table is called when production on_range_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) { +} + +// EnterOn_list_partitioned_table is called when production on_list_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) { +} + +// ExitOn_list_partitioned_table is called when production on_list_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) { +} + +// EnterPartitioned_table is called when production partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterPartitioned_table(ctx *Partitioned_tableContext) {} + +// ExitPartitioned_table is called when production partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitPartitioned_table(ctx *Partitioned_tableContext) {} + +// EnterOn_hash_partitioned_table is called when production on_hash_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) { +} + +// ExitOn_hash_partitioned_table is called when production on_hash_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) { +} + +// EnterOn_hash_partitioned_clause is called when production on_hash_partitioned_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) { +} + +// ExitOn_hash_partitioned_clause is called when production on_hash_partitioned_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) { +} + +// EnterOn_comp_partitioned_table is called when production on_comp_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) { +} + +// ExitOn_comp_partitioned_table is called when production on_comp_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) { +} + +// EnterOn_comp_partitioned_clause is called when production on_comp_partitioned_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) { +} + +// ExitOn_comp_partitioned_clause is called when production on_comp_partitioned_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) { +} + +// EnterIndex_subpartition_clause is called when production index_subpartition_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) { +} + +// ExitIndex_subpartition_clause is called when production index_subpartition_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) { +} + +// EnterIndex_subpartition_subclause is called when production index_subpartition_subclause is entered. +func (s *BasePlSqlParserListener) EnterIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) { +} + +// ExitIndex_subpartition_subclause is called when production index_subpartition_subclause is exited. +func (s *BasePlSqlParserListener) ExitIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) { +} + +// EnterOdci_parameters is called when production odci_parameters is entered. +func (s *BasePlSqlParserListener) EnterOdci_parameters(ctx *Odci_parametersContext) {} + +// ExitOdci_parameters is called when production odci_parameters is exited. +func (s *BasePlSqlParserListener) ExitOdci_parameters(ctx *Odci_parametersContext) {} + +// EnterIndextype is called when production indextype is entered. +func (s *BasePlSqlParserListener) EnterIndextype(ctx *IndextypeContext) {} + +// ExitIndextype is called when production indextype is exited. +func (s *BasePlSqlParserListener) ExitIndextype(ctx *IndextypeContext) {} + +// EnterAlter_index is called when production alter_index is entered. +func (s *BasePlSqlParserListener) EnterAlter_index(ctx *Alter_indexContext) {} + +// ExitAlter_index is called when production alter_index is exited. +func (s *BasePlSqlParserListener) ExitAlter_index(ctx *Alter_indexContext) {} + +// EnterAlter_index_ops_set1 is called when production alter_index_ops_set1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) {} + +// ExitAlter_index_ops_set1 is called when production alter_index_ops_set1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) {} + +// EnterAlter_index_ops_set2 is called when production alter_index_ops_set2 is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) {} + +// ExitAlter_index_ops_set2 is called when production alter_index_ops_set2 is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) {} + +// EnterVisible_or_invisible is called when production visible_or_invisible is entered. +func (s *BasePlSqlParserListener) EnterVisible_or_invisible(ctx *Visible_or_invisibleContext) {} + +// ExitVisible_or_invisible is called when production visible_or_invisible is exited. +func (s *BasePlSqlParserListener) ExitVisible_or_invisible(ctx *Visible_or_invisibleContext) {} + +// EnterMonitoring_nomonitoring is called when production monitoring_nomonitoring is entered. +func (s *BasePlSqlParserListener) EnterMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) {} + +// ExitMonitoring_nomonitoring is called when production monitoring_nomonitoring is exited. +func (s *BasePlSqlParserListener) ExitMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) {} + +// EnterRebuild_clause is called when production rebuild_clause is entered. +func (s *BasePlSqlParserListener) EnterRebuild_clause(ctx *Rebuild_clauseContext) {} + +// ExitRebuild_clause is called when production rebuild_clause is exited. +func (s *BasePlSqlParserListener) ExitRebuild_clause(ctx *Rebuild_clauseContext) {} + +// EnterAlter_index_partitioning is called when production alter_index_partitioning is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_partitioning(ctx *Alter_index_partitioningContext) { +} + +// ExitAlter_index_partitioning is called when production alter_index_partitioning is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_partitioning(ctx *Alter_index_partitioningContext) { +} + +// EnterModify_index_default_attrs is called when production modify_index_default_attrs is entered. +func (s *BasePlSqlParserListener) EnterModify_index_default_attrs(ctx *Modify_index_default_attrsContext) { +} + +// ExitModify_index_default_attrs is called when production modify_index_default_attrs is exited. +func (s *BasePlSqlParserListener) ExitModify_index_default_attrs(ctx *Modify_index_default_attrsContext) { +} + +// EnterAdd_hash_index_partition is called when production add_hash_index_partition is entered. +func (s *BasePlSqlParserListener) EnterAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) { +} + +// ExitAdd_hash_index_partition is called when production add_hash_index_partition is exited. +func (s *BasePlSqlParserListener) ExitAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) { +} + +// EnterCoalesce_index_partition is called when production coalesce_index_partition is entered. +func (s *BasePlSqlParserListener) EnterCoalesce_index_partition(ctx *Coalesce_index_partitionContext) { +} + +// ExitCoalesce_index_partition is called when production coalesce_index_partition is exited. +func (s *BasePlSqlParserListener) ExitCoalesce_index_partition(ctx *Coalesce_index_partitionContext) { +} + +// EnterModify_index_partition is called when production modify_index_partition is entered. +func (s *BasePlSqlParserListener) EnterModify_index_partition(ctx *Modify_index_partitionContext) {} + +// ExitModify_index_partition is called when production modify_index_partition is exited. +func (s *BasePlSqlParserListener) ExitModify_index_partition(ctx *Modify_index_partitionContext) {} + +// EnterModify_index_partitions_ops is called when production modify_index_partitions_ops is entered. +func (s *BasePlSqlParserListener) EnterModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) { +} + +// ExitModify_index_partitions_ops is called when production modify_index_partitions_ops is exited. +func (s *BasePlSqlParserListener) ExitModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) { +} + +// EnterRename_index_partition is called when production rename_index_partition is entered. +func (s *BasePlSqlParserListener) EnterRename_index_partition(ctx *Rename_index_partitionContext) {} + +// ExitRename_index_partition is called when production rename_index_partition is exited. +func (s *BasePlSqlParserListener) ExitRename_index_partition(ctx *Rename_index_partitionContext) {} + +// EnterDrop_index_partition is called when production drop_index_partition is entered. +func (s *BasePlSqlParserListener) EnterDrop_index_partition(ctx *Drop_index_partitionContext) {} + +// ExitDrop_index_partition is called when production drop_index_partition is exited. +func (s *BasePlSqlParserListener) ExitDrop_index_partition(ctx *Drop_index_partitionContext) {} + +// EnterSplit_index_partition is called when production split_index_partition is entered. +func (s *BasePlSqlParserListener) EnterSplit_index_partition(ctx *Split_index_partitionContext) {} + +// ExitSplit_index_partition is called when production split_index_partition is exited. +func (s *BasePlSqlParserListener) ExitSplit_index_partition(ctx *Split_index_partitionContext) {} + +// EnterIndex_partition_description is called when production index_partition_description is entered. +func (s *BasePlSqlParserListener) EnterIndex_partition_description(ctx *Index_partition_descriptionContext) { +} + +// ExitIndex_partition_description is called when production index_partition_description is exited. +func (s *BasePlSqlParserListener) ExitIndex_partition_description(ctx *Index_partition_descriptionContext) { +} + +// EnterModify_index_subpartition is called when production modify_index_subpartition is entered. +func (s *BasePlSqlParserListener) EnterModify_index_subpartition(ctx *Modify_index_subpartitionContext) { +} + +// ExitModify_index_subpartition is called when production modify_index_subpartition is exited. +func (s *BasePlSqlParserListener) ExitModify_index_subpartition(ctx *Modify_index_subpartitionContext) { +} + +// EnterPartition_name_old is called when production partition_name_old is entered. +func (s *BasePlSqlParserListener) EnterPartition_name_old(ctx *Partition_name_oldContext) {} + +// ExitPartition_name_old is called when production partition_name_old is exited. +func (s *BasePlSqlParserListener) ExitPartition_name_old(ctx *Partition_name_oldContext) {} + +// EnterNew_partition_name is called when production new_partition_name is entered. +func (s *BasePlSqlParserListener) EnterNew_partition_name(ctx *New_partition_nameContext) {} + +// ExitNew_partition_name is called when production new_partition_name is exited. +func (s *BasePlSqlParserListener) ExitNew_partition_name(ctx *New_partition_nameContext) {} + +// EnterNew_index_name is called when production new_index_name is entered. +func (s *BasePlSqlParserListener) EnterNew_index_name(ctx *New_index_nameContext) {} + +// ExitNew_index_name is called when production new_index_name is exited. +func (s *BasePlSqlParserListener) ExitNew_index_name(ctx *New_index_nameContext) {} + +// EnterAlter_inmemory_join_group is called when production alter_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) { +} + +// ExitAlter_inmemory_join_group is called when production alter_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) { +} + +// EnterCreate_user is called when production create_user is entered. +func (s *BasePlSqlParserListener) EnterCreate_user(ctx *Create_userContext) {} + +// ExitCreate_user is called when production create_user is exited. +func (s *BasePlSqlParserListener) ExitCreate_user(ctx *Create_userContext) {} + +// EnterAlter_user is called when production alter_user is entered. +func (s *BasePlSqlParserListener) EnterAlter_user(ctx *Alter_userContext) {} + +// ExitAlter_user is called when production alter_user is exited. +func (s *BasePlSqlParserListener) ExitAlter_user(ctx *Alter_userContext) {} + +// EnterDrop_user is called when production drop_user is entered. +func (s *BasePlSqlParserListener) EnterDrop_user(ctx *Drop_userContext) {} + +// ExitDrop_user is called when production drop_user is exited. +func (s *BasePlSqlParserListener) ExitDrop_user(ctx *Drop_userContext) {} + +// EnterAlter_identified_by is called when production alter_identified_by is entered. +func (s *BasePlSqlParserListener) EnterAlter_identified_by(ctx *Alter_identified_byContext) {} + +// ExitAlter_identified_by is called when production alter_identified_by is exited. +func (s *BasePlSqlParserListener) ExitAlter_identified_by(ctx *Alter_identified_byContext) {} + +// EnterIdentified_by is called when production identified_by is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by(ctx *Identified_byContext) {} + +// ExitIdentified_by is called when production identified_by is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by(ctx *Identified_byContext) {} + +// EnterIdentified_other_clause is called when production identified_other_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentified_other_clause(ctx *Identified_other_clauseContext) {} + +// ExitIdentified_other_clause is called when production identified_other_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentified_other_clause(ctx *Identified_other_clauseContext) {} + +// EnterUser_tablespace_clause is called when production user_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_tablespace_clause(ctx *User_tablespace_clauseContext) {} + +// ExitUser_tablespace_clause is called when production user_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_tablespace_clause(ctx *User_tablespace_clauseContext) {} + +// EnterQuota_clause is called when production quota_clause is entered. +func (s *BasePlSqlParserListener) EnterQuota_clause(ctx *Quota_clauseContext) {} + +// ExitQuota_clause is called when production quota_clause is exited. +func (s *BasePlSqlParserListener) ExitQuota_clause(ctx *Quota_clauseContext) {} + +// EnterProfile_clause is called when production profile_clause is entered. +func (s *BasePlSqlParserListener) EnterProfile_clause(ctx *Profile_clauseContext) {} + +// ExitProfile_clause is called when production profile_clause is exited. +func (s *BasePlSqlParserListener) ExitProfile_clause(ctx *Profile_clauseContext) {} + +// EnterRole_clause is called when production role_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_clause(ctx *Role_clauseContext) {} + +// ExitRole_clause is called when production role_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_clause(ctx *Role_clauseContext) {} + +// EnterUser_default_role_clause is called when production user_default_role_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_default_role_clause(ctx *User_default_role_clauseContext) { +} + +// ExitUser_default_role_clause is called when production user_default_role_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_default_role_clause(ctx *User_default_role_clauseContext) { +} + +// EnterPassword_expire_clause is called when production password_expire_clause is entered. +func (s *BasePlSqlParserListener) EnterPassword_expire_clause(ctx *Password_expire_clauseContext) {} + +// ExitPassword_expire_clause is called when production password_expire_clause is exited. +func (s *BasePlSqlParserListener) ExitPassword_expire_clause(ctx *Password_expire_clauseContext) {} + +// EnterUser_lock_clause is called when production user_lock_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_lock_clause(ctx *User_lock_clauseContext) {} + +// ExitUser_lock_clause is called when production user_lock_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_lock_clause(ctx *User_lock_clauseContext) {} + +// EnterUser_editions_clause is called when production user_editions_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_editions_clause(ctx *User_editions_clauseContext) {} + +// ExitUser_editions_clause is called when production user_editions_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_editions_clause(ctx *User_editions_clauseContext) {} + +// EnterAlter_user_editions_clause is called when production alter_user_editions_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) { +} + +// ExitAlter_user_editions_clause is called when production alter_user_editions_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) { +} + +// EnterProxy_clause is called when production proxy_clause is entered. +func (s *BasePlSqlParserListener) EnterProxy_clause(ctx *Proxy_clauseContext) {} + +// ExitProxy_clause is called when production proxy_clause is exited. +func (s *BasePlSqlParserListener) ExitProxy_clause(ctx *Proxy_clauseContext) {} + +// EnterContainer_names is called when production container_names is entered. +func (s *BasePlSqlParserListener) EnterContainer_names(ctx *Container_namesContext) {} + +// ExitContainer_names is called when production container_names is exited. +func (s *BasePlSqlParserListener) ExitContainer_names(ctx *Container_namesContext) {} + +// EnterSet_container_data is called when production set_container_data is entered. +func (s *BasePlSqlParserListener) EnterSet_container_data(ctx *Set_container_dataContext) {} + +// ExitSet_container_data is called when production set_container_data is exited. +func (s *BasePlSqlParserListener) ExitSet_container_data(ctx *Set_container_dataContext) {} + +// EnterAdd_rem_container_data is called when production add_rem_container_data is entered. +func (s *BasePlSqlParserListener) EnterAdd_rem_container_data(ctx *Add_rem_container_dataContext) {} + +// ExitAdd_rem_container_data is called when production add_rem_container_data is exited. +func (s *BasePlSqlParserListener) ExitAdd_rem_container_data(ctx *Add_rem_container_dataContext) {} + +// EnterContainer_data_clause is called when production container_data_clause is entered. +func (s *BasePlSqlParserListener) EnterContainer_data_clause(ctx *Container_data_clauseContext) {} + +// ExitContainer_data_clause is called when production container_data_clause is exited. +func (s *BasePlSqlParserListener) ExitContainer_data_clause(ctx *Container_data_clauseContext) {} + +// EnterAdminister_key_management is called when production administer_key_management is entered. +func (s *BasePlSqlParserListener) EnterAdminister_key_management(ctx *Administer_key_managementContext) { +} + +// ExitAdminister_key_management is called when production administer_key_management is exited. +func (s *BasePlSqlParserListener) ExitAdminister_key_management(ctx *Administer_key_managementContext) { +} + +// EnterKeystore_management_clauses is called when production keystore_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterKeystore_management_clauses(ctx *Keystore_management_clausesContext) { +} + +// ExitKeystore_management_clauses is called when production keystore_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitKeystore_management_clauses(ctx *Keystore_management_clausesContext) { +} + +// EnterCreate_keystore is called when production create_keystore is entered. +func (s *BasePlSqlParserListener) EnterCreate_keystore(ctx *Create_keystoreContext) {} + +// ExitCreate_keystore is called when production create_keystore is exited. +func (s *BasePlSqlParserListener) ExitCreate_keystore(ctx *Create_keystoreContext) {} + +// EnterOpen_keystore is called when production open_keystore is entered. +func (s *BasePlSqlParserListener) EnterOpen_keystore(ctx *Open_keystoreContext) {} + +// ExitOpen_keystore is called when production open_keystore is exited. +func (s *BasePlSqlParserListener) ExitOpen_keystore(ctx *Open_keystoreContext) {} + +// EnterForce_keystore is called when production force_keystore is entered. +func (s *BasePlSqlParserListener) EnterForce_keystore(ctx *Force_keystoreContext) {} + +// ExitForce_keystore is called when production force_keystore is exited. +func (s *BasePlSqlParserListener) ExitForce_keystore(ctx *Force_keystoreContext) {} + +// EnterClose_keystore is called when production close_keystore is entered. +func (s *BasePlSqlParserListener) EnterClose_keystore(ctx *Close_keystoreContext) {} + +// ExitClose_keystore is called when production close_keystore is exited. +func (s *BasePlSqlParserListener) ExitClose_keystore(ctx *Close_keystoreContext) {} + +// EnterBackup_keystore is called when production backup_keystore is entered. +func (s *BasePlSqlParserListener) EnterBackup_keystore(ctx *Backup_keystoreContext) {} + +// ExitBackup_keystore is called when production backup_keystore is exited. +func (s *BasePlSqlParserListener) ExitBackup_keystore(ctx *Backup_keystoreContext) {} + +// EnterAlter_keystore_password is called when production alter_keystore_password is entered. +func (s *BasePlSqlParserListener) EnterAlter_keystore_password(ctx *Alter_keystore_passwordContext) {} + +// ExitAlter_keystore_password is called when production alter_keystore_password is exited. +func (s *BasePlSqlParserListener) ExitAlter_keystore_password(ctx *Alter_keystore_passwordContext) {} + +// EnterMerge_into_new_keystore is called when production merge_into_new_keystore is entered. +func (s *BasePlSqlParserListener) EnterMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) {} + +// ExitMerge_into_new_keystore is called when production merge_into_new_keystore is exited. +func (s *BasePlSqlParserListener) ExitMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) {} + +// EnterMerge_into_existing_keystore is called when production merge_into_existing_keystore is entered. +func (s *BasePlSqlParserListener) EnterMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) { +} + +// ExitMerge_into_existing_keystore is called when production merge_into_existing_keystore is exited. +func (s *BasePlSqlParserListener) ExitMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) { +} + +// EnterIsolate_keystore is called when production isolate_keystore is entered. +func (s *BasePlSqlParserListener) EnterIsolate_keystore(ctx *Isolate_keystoreContext) {} + +// ExitIsolate_keystore is called when production isolate_keystore is exited. +func (s *BasePlSqlParserListener) ExitIsolate_keystore(ctx *Isolate_keystoreContext) {} + +// EnterUnite_keystore is called when production unite_keystore is entered. +func (s *BasePlSqlParserListener) EnterUnite_keystore(ctx *Unite_keystoreContext) {} + +// ExitUnite_keystore is called when production unite_keystore is exited. +func (s *BasePlSqlParserListener) ExitUnite_keystore(ctx *Unite_keystoreContext) {} + +// EnterKey_management_clauses is called when production key_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterKey_management_clauses(ctx *Key_management_clausesContext) {} + +// ExitKey_management_clauses is called when production key_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitKey_management_clauses(ctx *Key_management_clausesContext) {} + +// EnterSet_key is called when production set_key is entered. +func (s *BasePlSqlParserListener) EnterSet_key(ctx *Set_keyContext) {} + +// ExitSet_key is called when production set_key is exited. +func (s *BasePlSqlParserListener) ExitSet_key(ctx *Set_keyContext) {} + +// EnterCreate_key is called when production create_key is entered. +func (s *BasePlSqlParserListener) EnterCreate_key(ctx *Create_keyContext) {} + +// ExitCreate_key is called when production create_key is exited. +func (s *BasePlSqlParserListener) ExitCreate_key(ctx *Create_keyContext) {} + +// EnterMkid is called when production mkid is entered. +func (s *BasePlSqlParserListener) EnterMkid(ctx *MkidContext) {} + +// ExitMkid is called when production mkid is exited. +func (s *BasePlSqlParserListener) ExitMkid(ctx *MkidContext) {} + +// EnterMk is called when production mk is entered. +func (s *BasePlSqlParserListener) EnterMk(ctx *MkContext) {} + +// ExitMk is called when production mk is exited. +func (s *BasePlSqlParserListener) ExitMk(ctx *MkContext) {} + +// EnterUse_key is called when production use_key is entered. +func (s *BasePlSqlParserListener) EnterUse_key(ctx *Use_keyContext) {} + +// ExitUse_key is called when production use_key is exited. +func (s *BasePlSqlParserListener) ExitUse_key(ctx *Use_keyContext) {} + +// EnterSet_key_tag is called when production set_key_tag is entered. +func (s *BasePlSqlParserListener) EnterSet_key_tag(ctx *Set_key_tagContext) {} + +// ExitSet_key_tag is called when production set_key_tag is exited. +func (s *BasePlSqlParserListener) ExitSet_key_tag(ctx *Set_key_tagContext) {} + +// EnterExport_keys is called when production export_keys is entered. +func (s *BasePlSqlParserListener) EnterExport_keys(ctx *Export_keysContext) {} + +// ExitExport_keys is called when production export_keys is exited. +func (s *BasePlSqlParserListener) ExitExport_keys(ctx *Export_keysContext) {} + +// EnterImport_keys is called when production import_keys is entered. +func (s *BasePlSqlParserListener) EnterImport_keys(ctx *Import_keysContext) {} + +// ExitImport_keys is called when production import_keys is exited. +func (s *BasePlSqlParserListener) ExitImport_keys(ctx *Import_keysContext) {} + +// EnterMigrate_keys is called when production migrate_keys is entered. +func (s *BasePlSqlParserListener) EnterMigrate_keys(ctx *Migrate_keysContext) {} + +// ExitMigrate_keys is called when production migrate_keys is exited. +func (s *BasePlSqlParserListener) ExitMigrate_keys(ctx *Migrate_keysContext) {} + +// EnterReverse_migrate_keys is called when production reverse_migrate_keys is entered. +func (s *BasePlSqlParserListener) EnterReverse_migrate_keys(ctx *Reverse_migrate_keysContext) {} + +// ExitReverse_migrate_keys is called when production reverse_migrate_keys is exited. +func (s *BasePlSqlParserListener) ExitReverse_migrate_keys(ctx *Reverse_migrate_keysContext) {} + +// EnterMove_keys is called when production move_keys is entered. +func (s *BasePlSqlParserListener) EnterMove_keys(ctx *Move_keysContext) {} + +// ExitMove_keys is called when production move_keys is exited. +func (s *BasePlSqlParserListener) ExitMove_keys(ctx *Move_keysContext) {} + +// EnterIdentified_by_store is called when production identified_by_store is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by_store(ctx *Identified_by_storeContext) {} + +// ExitIdentified_by_store is called when production identified_by_store is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by_store(ctx *Identified_by_storeContext) {} + +// EnterUsing_algorithm_clause is called when production using_algorithm_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) {} + +// ExitUsing_algorithm_clause is called when production using_algorithm_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) {} + +// EnterUsing_tag_clause is called when production using_tag_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_tag_clause(ctx *Using_tag_clauseContext) {} + +// ExitUsing_tag_clause is called when production using_tag_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_tag_clause(ctx *Using_tag_clauseContext) {} + +// EnterSecret_management_clauses is called when production secret_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterSecret_management_clauses(ctx *Secret_management_clausesContext) { +} + +// ExitSecret_management_clauses is called when production secret_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitSecret_management_clauses(ctx *Secret_management_clausesContext) { +} + +// EnterAdd_update_secret is called when production add_update_secret is entered. +func (s *BasePlSqlParserListener) EnterAdd_update_secret(ctx *Add_update_secretContext) {} + +// ExitAdd_update_secret is called when production add_update_secret is exited. +func (s *BasePlSqlParserListener) ExitAdd_update_secret(ctx *Add_update_secretContext) {} + +// EnterDelete_secret is called when production delete_secret is entered. +func (s *BasePlSqlParserListener) EnterDelete_secret(ctx *Delete_secretContext) {} + +// ExitDelete_secret is called when production delete_secret is exited. +func (s *BasePlSqlParserListener) ExitDelete_secret(ctx *Delete_secretContext) {} + +// EnterAdd_update_secret_seps is called when production add_update_secret_seps is entered. +func (s *BasePlSqlParserListener) EnterAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) {} + +// ExitAdd_update_secret_seps is called when production add_update_secret_seps is exited. +func (s *BasePlSqlParserListener) ExitAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) {} + +// EnterDelete_secret_seps is called when production delete_secret_seps is entered. +func (s *BasePlSqlParserListener) EnterDelete_secret_seps(ctx *Delete_secret_sepsContext) {} + +// ExitDelete_secret_seps is called when production delete_secret_seps is exited. +func (s *BasePlSqlParserListener) ExitDelete_secret_seps(ctx *Delete_secret_sepsContext) {} + +// EnterZero_downtime_software_patching_clauses is called when production zero_downtime_software_patching_clauses is entered. +func (s *BasePlSqlParserListener) EnterZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) { +} + +// ExitZero_downtime_software_patching_clauses is called when production zero_downtime_software_patching_clauses is exited. +func (s *BasePlSqlParserListener) ExitZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) { +} + +// EnterWith_backup_clause is called when production with_backup_clause is entered. +func (s *BasePlSqlParserListener) EnterWith_backup_clause(ctx *With_backup_clauseContext) {} + +// ExitWith_backup_clause is called when production with_backup_clause is exited. +func (s *BasePlSqlParserListener) ExitWith_backup_clause(ctx *With_backup_clauseContext) {} + +// EnterIdentified_by_password_clause is called when production identified_by_password_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) { +} + +// ExitIdentified_by_password_clause is called when production identified_by_password_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) { +} + +// EnterKeystore_password is called when production keystore_password is entered. +func (s *BasePlSqlParserListener) EnterKeystore_password(ctx *Keystore_passwordContext) {} + +// ExitKeystore_password is called when production keystore_password is exited. +func (s *BasePlSqlParserListener) ExitKeystore_password(ctx *Keystore_passwordContext) {} + +// EnterPath is called when production path is entered. +func (s *BasePlSqlParserListener) EnterPath(ctx *PathContext) {} + +// ExitPath is called when production path is exited. +func (s *BasePlSqlParserListener) ExitPath(ctx *PathContext) {} + +// EnterSecret is called when production secret is entered. +func (s *BasePlSqlParserListener) EnterSecret(ctx *SecretContext) {} + +// ExitSecret is called when production secret is exited. +func (s *BasePlSqlParserListener) ExitSecret(ctx *SecretContext) {} + +// EnterAnalyze is called when production analyze is entered. +func (s *BasePlSqlParserListener) EnterAnalyze(ctx *AnalyzeContext) {} + +// ExitAnalyze is called when production analyze is exited. +func (s *BasePlSqlParserListener) ExitAnalyze(ctx *AnalyzeContext) {} + +// EnterPartition_extention_clause is called when production partition_extention_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_extention_clause(ctx *Partition_extention_clauseContext) { +} + +// ExitPartition_extention_clause is called when production partition_extention_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_extention_clause(ctx *Partition_extention_clauseContext) { +} + +// EnterValidation_clauses is called when production validation_clauses is entered. +func (s *BasePlSqlParserListener) EnterValidation_clauses(ctx *Validation_clausesContext) {} + +// ExitValidation_clauses is called when production validation_clauses is exited. +func (s *BasePlSqlParserListener) ExitValidation_clauses(ctx *Validation_clausesContext) {} + +// EnterCompute_clauses is called when production compute_clauses is entered. +func (s *BasePlSqlParserListener) EnterCompute_clauses(ctx *Compute_clausesContext) {} + +// ExitCompute_clauses is called when production compute_clauses is exited. +func (s *BasePlSqlParserListener) ExitCompute_clauses(ctx *Compute_clausesContext) {} + +// EnterFor_clause is called when production for_clause is entered. +func (s *BasePlSqlParserListener) EnterFor_clause(ctx *For_clauseContext) {} + +// ExitFor_clause is called when production for_clause is exited. +func (s *BasePlSqlParserListener) ExitFor_clause(ctx *For_clauseContext) {} + +// EnterOnline_or_offline is called when production online_or_offline is entered. +func (s *BasePlSqlParserListener) EnterOnline_or_offline(ctx *Online_or_offlineContext) {} + +// ExitOnline_or_offline is called when production online_or_offline is exited. +func (s *BasePlSqlParserListener) ExitOnline_or_offline(ctx *Online_or_offlineContext) {} + +// EnterInto_clause1 is called when production into_clause1 is entered. +func (s *BasePlSqlParserListener) EnterInto_clause1(ctx *Into_clause1Context) {} + +// ExitInto_clause1 is called when production into_clause1 is exited. +func (s *BasePlSqlParserListener) ExitInto_clause1(ctx *Into_clause1Context) {} + +// EnterPartition_key_value is called when production partition_key_value is entered. +func (s *BasePlSqlParserListener) EnterPartition_key_value(ctx *Partition_key_valueContext) {} + +// ExitPartition_key_value is called when production partition_key_value is exited. +func (s *BasePlSqlParserListener) ExitPartition_key_value(ctx *Partition_key_valueContext) {} + +// EnterSubpartition_key_value is called when production subpartition_key_value is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_key_value(ctx *Subpartition_key_valueContext) {} + +// ExitSubpartition_key_value is called when production subpartition_key_value is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_key_value(ctx *Subpartition_key_valueContext) {} + +// EnterAssociate_statistics is called when production associate_statistics is entered. +func (s *BasePlSqlParserListener) EnterAssociate_statistics(ctx *Associate_statisticsContext) {} + +// ExitAssociate_statistics is called when production associate_statistics is exited. +func (s *BasePlSqlParserListener) ExitAssociate_statistics(ctx *Associate_statisticsContext) {} + +// EnterColumn_association is called when production column_association is entered. +func (s *BasePlSqlParserListener) EnterColumn_association(ctx *Column_associationContext) {} + +// ExitColumn_association is called when production column_association is exited. +func (s *BasePlSqlParserListener) ExitColumn_association(ctx *Column_associationContext) {} + +// EnterFunction_association is called when production function_association is entered. +func (s *BasePlSqlParserListener) EnterFunction_association(ctx *Function_associationContext) {} + +// ExitFunction_association is called when production function_association is exited. +func (s *BasePlSqlParserListener) ExitFunction_association(ctx *Function_associationContext) {} + +// EnterIndextype_name is called when production indextype_name is entered. +func (s *BasePlSqlParserListener) EnterIndextype_name(ctx *Indextype_nameContext) {} + +// ExitIndextype_name is called when production indextype_name is exited. +func (s *BasePlSqlParserListener) ExitIndextype_name(ctx *Indextype_nameContext) {} + +// EnterUsing_statistics_type is called when production using_statistics_type is entered. +func (s *BasePlSqlParserListener) EnterUsing_statistics_type(ctx *Using_statistics_typeContext) {} + +// ExitUsing_statistics_type is called when production using_statistics_type is exited. +func (s *BasePlSqlParserListener) ExitUsing_statistics_type(ctx *Using_statistics_typeContext) {} + +// EnterStatistics_type_name is called when production statistics_type_name is entered. +func (s *BasePlSqlParserListener) EnterStatistics_type_name(ctx *Statistics_type_nameContext) {} + +// ExitStatistics_type_name is called when production statistics_type_name is exited. +func (s *BasePlSqlParserListener) ExitStatistics_type_name(ctx *Statistics_type_nameContext) {} + +// EnterDefault_cost_clause is called when production default_cost_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_cost_clause(ctx *Default_cost_clauseContext) {} + +// ExitDefault_cost_clause is called when production default_cost_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_cost_clause(ctx *Default_cost_clauseContext) {} + +// EnterCpu_cost is called when production cpu_cost is entered. +func (s *BasePlSqlParserListener) EnterCpu_cost(ctx *Cpu_costContext) {} + +// ExitCpu_cost is called when production cpu_cost is exited. +func (s *BasePlSqlParserListener) ExitCpu_cost(ctx *Cpu_costContext) {} + +// EnterIo_cost is called when production io_cost is entered. +func (s *BasePlSqlParserListener) EnterIo_cost(ctx *Io_costContext) {} + +// ExitIo_cost is called when production io_cost is exited. +func (s *BasePlSqlParserListener) ExitIo_cost(ctx *Io_costContext) {} + +// EnterNetwork_cost is called when production network_cost is entered. +func (s *BasePlSqlParserListener) EnterNetwork_cost(ctx *Network_costContext) {} + +// ExitNetwork_cost is called when production network_cost is exited. +func (s *BasePlSqlParserListener) ExitNetwork_cost(ctx *Network_costContext) {} + +// EnterDefault_selectivity_clause is called when production default_selectivity_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) { +} + +// ExitDefault_selectivity_clause is called when production default_selectivity_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) { +} + +// EnterDefault_selectivity is called when production default_selectivity is entered. +func (s *BasePlSqlParserListener) EnterDefault_selectivity(ctx *Default_selectivityContext) {} + +// ExitDefault_selectivity is called when production default_selectivity is exited. +func (s *BasePlSqlParserListener) ExitDefault_selectivity(ctx *Default_selectivityContext) {} + +// EnterStorage_table_clause is called when production storage_table_clause is entered. +func (s *BasePlSqlParserListener) EnterStorage_table_clause(ctx *Storage_table_clauseContext) {} + +// ExitStorage_table_clause is called when production storage_table_clause is exited. +func (s *BasePlSqlParserListener) ExitStorage_table_clause(ctx *Storage_table_clauseContext) {} + +// EnterUnified_auditing is called when production unified_auditing is entered. +func (s *BasePlSqlParserListener) EnterUnified_auditing(ctx *Unified_auditingContext) {} + +// ExitUnified_auditing is called when production unified_auditing is exited. +func (s *BasePlSqlParserListener) ExitUnified_auditing(ctx *Unified_auditingContext) {} + +// EnterPolicy_name is called when production policy_name is entered. +func (s *BasePlSqlParserListener) EnterPolicy_name(ctx *Policy_nameContext) {} + +// ExitPolicy_name is called when production policy_name is exited. +func (s *BasePlSqlParserListener) ExitPolicy_name(ctx *Policy_nameContext) {} + +// EnterAudit_traditional is called when production audit_traditional is entered. +func (s *BasePlSqlParserListener) EnterAudit_traditional(ctx *Audit_traditionalContext) {} + +// ExitAudit_traditional is called when production audit_traditional is exited. +func (s *BasePlSqlParserListener) ExitAudit_traditional(ctx *Audit_traditionalContext) {} + +// EnterAudit_direct_path is called when production audit_direct_path is entered. +func (s *BasePlSqlParserListener) EnterAudit_direct_path(ctx *Audit_direct_pathContext) {} + +// ExitAudit_direct_path is called when production audit_direct_path is exited. +func (s *BasePlSqlParserListener) ExitAudit_direct_path(ctx *Audit_direct_pathContext) {} + +// EnterAudit_container_clause is called when production audit_container_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_container_clause(ctx *Audit_container_clauseContext) {} + +// ExitAudit_container_clause is called when production audit_container_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_container_clause(ctx *Audit_container_clauseContext) {} + +// EnterAudit_operation_clause is called when production audit_operation_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_operation_clause(ctx *Audit_operation_clauseContext) {} + +// ExitAudit_operation_clause is called when production audit_operation_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_operation_clause(ctx *Audit_operation_clauseContext) {} + +// EnterAuditing_by_clause is called when production auditing_by_clause is entered. +func (s *BasePlSqlParserListener) EnterAuditing_by_clause(ctx *Auditing_by_clauseContext) {} + +// ExitAuditing_by_clause is called when production auditing_by_clause is exited. +func (s *BasePlSqlParserListener) ExitAuditing_by_clause(ctx *Auditing_by_clauseContext) {} + +// EnterAudit_user is called when production audit_user is entered. +func (s *BasePlSqlParserListener) EnterAudit_user(ctx *Audit_userContext) {} + +// ExitAudit_user is called when production audit_user is exited. +func (s *BasePlSqlParserListener) ExitAudit_user(ctx *Audit_userContext) {} + +// EnterAudit_schema_object_clause is called when production audit_schema_object_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) { +} + +// ExitAudit_schema_object_clause is called when production audit_schema_object_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) { +} + +// EnterSql_operation is called when production sql_operation is entered. +func (s *BasePlSqlParserListener) EnterSql_operation(ctx *Sql_operationContext) {} + +// ExitSql_operation is called when production sql_operation is exited. +func (s *BasePlSqlParserListener) ExitSql_operation(ctx *Sql_operationContext) {} + +// EnterAuditing_on_clause is called when production auditing_on_clause is entered. +func (s *BasePlSqlParserListener) EnterAuditing_on_clause(ctx *Auditing_on_clauseContext) {} + +// ExitAuditing_on_clause is called when production auditing_on_clause is exited. +func (s *BasePlSqlParserListener) ExitAuditing_on_clause(ctx *Auditing_on_clauseContext) {} + +// EnterModel_name is called when production model_name is entered. +func (s *BasePlSqlParserListener) EnterModel_name(ctx *Model_nameContext) {} + +// ExitModel_name is called when production model_name is exited. +func (s *BasePlSqlParserListener) ExitModel_name(ctx *Model_nameContext) {} + +// EnterObject_name is called when production object_name is entered. +func (s *BasePlSqlParserListener) EnterObject_name(ctx *Object_nameContext) {} + +// ExitObject_name is called when production object_name is exited. +func (s *BasePlSqlParserListener) ExitObject_name(ctx *Object_nameContext) {} + +// EnterProfile_name is called when production profile_name is entered. +func (s *BasePlSqlParserListener) EnterProfile_name(ctx *Profile_nameContext) {} + +// ExitProfile_name is called when production profile_name is exited. +func (s *BasePlSqlParserListener) ExitProfile_name(ctx *Profile_nameContext) {} + +// EnterSql_statement_shortcut is called when production sql_statement_shortcut is entered. +func (s *BasePlSqlParserListener) EnterSql_statement_shortcut(ctx *Sql_statement_shortcutContext) {} + +// ExitSql_statement_shortcut is called when production sql_statement_shortcut is exited. +func (s *BasePlSqlParserListener) ExitSql_statement_shortcut(ctx *Sql_statement_shortcutContext) {} + +// EnterDrop_index is called when production drop_index is entered. +func (s *BasePlSqlParserListener) EnterDrop_index(ctx *Drop_indexContext) {} + +// ExitDrop_index is called when production drop_index is exited. +func (s *BasePlSqlParserListener) ExitDrop_index(ctx *Drop_indexContext) {} + +// EnterDisassociate_statistics is called when production disassociate_statistics is entered. +func (s *BasePlSqlParserListener) EnterDisassociate_statistics(ctx *Disassociate_statisticsContext) {} + +// ExitDisassociate_statistics is called when production disassociate_statistics is exited. +func (s *BasePlSqlParserListener) ExitDisassociate_statistics(ctx *Disassociate_statisticsContext) {} + +// EnterDrop_indextype is called when production drop_indextype is entered. +func (s *BasePlSqlParserListener) EnterDrop_indextype(ctx *Drop_indextypeContext) {} + +// ExitDrop_indextype is called when production drop_indextype is exited. +func (s *BasePlSqlParserListener) ExitDrop_indextype(ctx *Drop_indextypeContext) {} + +// EnterDrop_inmemory_join_group is called when production drop_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) { +} + +// ExitDrop_inmemory_join_group is called when production drop_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) { +} + +// EnterFlashback_table is called when production flashback_table is entered. +func (s *BasePlSqlParserListener) EnterFlashback_table(ctx *Flashback_tableContext) {} + +// ExitFlashback_table is called when production flashback_table is exited. +func (s *BasePlSqlParserListener) ExitFlashback_table(ctx *Flashback_tableContext) {} + +// EnterRestore_point is called when production restore_point is entered. +func (s *BasePlSqlParserListener) EnterRestore_point(ctx *Restore_pointContext) {} + +// ExitRestore_point is called when production restore_point is exited. +func (s *BasePlSqlParserListener) ExitRestore_point(ctx *Restore_pointContext) {} + +// EnterPurge_statement is called when production purge_statement is entered. +func (s *BasePlSqlParserListener) EnterPurge_statement(ctx *Purge_statementContext) {} + +// ExitPurge_statement is called when production purge_statement is exited. +func (s *BasePlSqlParserListener) ExitPurge_statement(ctx *Purge_statementContext) {} + +// EnterNoaudit_statement is called when production noaudit_statement is entered. +func (s *BasePlSqlParserListener) EnterNoaudit_statement(ctx *Noaudit_statementContext) {} + +// ExitNoaudit_statement is called when production noaudit_statement is exited. +func (s *BasePlSqlParserListener) ExitNoaudit_statement(ctx *Noaudit_statementContext) {} + +// EnterRename_object is called when production rename_object is entered. +func (s *BasePlSqlParserListener) EnterRename_object(ctx *Rename_objectContext) {} + +// ExitRename_object is called when production rename_object is exited. +func (s *BasePlSqlParserListener) ExitRename_object(ctx *Rename_objectContext) {} + +// EnterGrant_statement is called when production grant_statement is entered. +func (s *BasePlSqlParserListener) EnterGrant_statement(ctx *Grant_statementContext) {} + +// ExitGrant_statement is called when production grant_statement is exited. +func (s *BasePlSqlParserListener) ExitGrant_statement(ctx *Grant_statementContext) {} + +// EnterContainer_clause is called when production container_clause is entered. +func (s *BasePlSqlParserListener) EnterContainer_clause(ctx *Container_clauseContext) {} + +// ExitContainer_clause is called when production container_clause is exited. +func (s *BasePlSqlParserListener) ExitContainer_clause(ctx *Container_clauseContext) {} + +// EnterRevoke_statement is called when production revoke_statement is entered. +func (s *BasePlSqlParserListener) EnterRevoke_statement(ctx *Revoke_statementContext) {} + +// ExitRevoke_statement is called when production revoke_statement is exited. +func (s *BasePlSqlParserListener) ExitRevoke_statement(ctx *Revoke_statementContext) {} + +// EnterRevoke_system_privilege is called when production revoke_system_privilege is entered. +func (s *BasePlSqlParserListener) EnterRevoke_system_privilege(ctx *Revoke_system_privilegeContext) {} + +// ExitRevoke_system_privilege is called when production revoke_system_privilege is exited. +func (s *BasePlSqlParserListener) ExitRevoke_system_privilege(ctx *Revoke_system_privilegeContext) {} + +// EnterRevokee_clause is called when production revokee_clause is entered. +func (s *BasePlSqlParserListener) EnterRevokee_clause(ctx *Revokee_clauseContext) {} + +// ExitRevokee_clause is called when production revokee_clause is exited. +func (s *BasePlSqlParserListener) ExitRevokee_clause(ctx *Revokee_clauseContext) {} + +// EnterRevoke_object_privileges is called when production revoke_object_privileges is entered. +func (s *BasePlSqlParserListener) EnterRevoke_object_privileges(ctx *Revoke_object_privilegesContext) { +} + +// ExitRevoke_object_privileges is called when production revoke_object_privileges is exited. +func (s *BasePlSqlParserListener) ExitRevoke_object_privileges(ctx *Revoke_object_privilegesContext) { +} + +// EnterOn_object_clause is called when production on_object_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_object_clause(ctx *On_object_clauseContext) {} + +// ExitOn_object_clause is called when production on_object_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_object_clause(ctx *On_object_clauseContext) {} + +// EnterRevoke_roles_from_programs is called when production revoke_roles_from_programs is entered. +func (s *BasePlSqlParserListener) EnterRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) { +} + +// ExitRevoke_roles_from_programs is called when production revoke_roles_from_programs is exited. +func (s *BasePlSqlParserListener) ExitRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) { +} + +// EnterProgram_unit is called when production program_unit is entered. +func (s *BasePlSqlParserListener) EnterProgram_unit(ctx *Program_unitContext) {} + +// ExitProgram_unit is called when production program_unit is exited. +func (s *BasePlSqlParserListener) ExitProgram_unit(ctx *Program_unitContext) {} + +// EnterCreate_dimension is called when production create_dimension is entered. +func (s *BasePlSqlParserListener) EnterCreate_dimension(ctx *Create_dimensionContext) {} + +// ExitCreate_dimension is called when production create_dimension is exited. +func (s *BasePlSqlParserListener) ExitCreate_dimension(ctx *Create_dimensionContext) {} + +// EnterCreate_directory is called when production create_directory is entered. +func (s *BasePlSqlParserListener) EnterCreate_directory(ctx *Create_directoryContext) {} + +// ExitCreate_directory is called when production create_directory is exited. +func (s *BasePlSqlParserListener) ExitCreate_directory(ctx *Create_directoryContext) {} + +// EnterDirectory_name is called when production directory_name is entered. +func (s *BasePlSqlParserListener) EnterDirectory_name(ctx *Directory_nameContext) {} + +// ExitDirectory_name is called when production directory_name is exited. +func (s *BasePlSqlParserListener) ExitDirectory_name(ctx *Directory_nameContext) {} + +// EnterDirectory_path is called when production directory_path is entered. +func (s *BasePlSqlParserListener) EnterDirectory_path(ctx *Directory_pathContext) {} + +// ExitDirectory_path is called when production directory_path is exited. +func (s *BasePlSqlParserListener) ExitDirectory_path(ctx *Directory_pathContext) {} + +// EnterCreate_inmemory_join_group is called when production create_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) { +} + +// ExitCreate_inmemory_join_group is called when production create_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) { +} + +// EnterDrop_hierarchy is called when production drop_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterDrop_hierarchy(ctx *Drop_hierarchyContext) {} + +// ExitDrop_hierarchy is called when production drop_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitDrop_hierarchy(ctx *Drop_hierarchyContext) {} + +// EnterAlter_library is called when production alter_library is entered. +func (s *BasePlSqlParserListener) EnterAlter_library(ctx *Alter_libraryContext) {} + +// ExitAlter_library is called when production alter_library is exited. +func (s *BasePlSqlParserListener) ExitAlter_library(ctx *Alter_libraryContext) {} + +// EnterDrop_java is called when production drop_java is entered. +func (s *BasePlSqlParserListener) EnterDrop_java(ctx *Drop_javaContext) {} + +// ExitDrop_java is called when production drop_java is exited. +func (s *BasePlSqlParserListener) ExitDrop_java(ctx *Drop_javaContext) {} + +// EnterDrop_library is called when production drop_library is entered. +func (s *BasePlSqlParserListener) EnterDrop_library(ctx *Drop_libraryContext) {} + +// ExitDrop_library is called when production drop_library is exited. +func (s *BasePlSqlParserListener) ExitDrop_library(ctx *Drop_libraryContext) {} + +// EnterCreate_java is called when production create_java is entered. +func (s *BasePlSqlParserListener) EnterCreate_java(ctx *Create_javaContext) {} + +// ExitCreate_java is called when production create_java is exited. +func (s *BasePlSqlParserListener) ExitCreate_java(ctx *Create_javaContext) {} + +// EnterCreate_library is called when production create_library is entered. +func (s *BasePlSqlParserListener) EnterCreate_library(ctx *Create_libraryContext) {} + +// ExitCreate_library is called when production create_library is exited. +func (s *BasePlSqlParserListener) ExitCreate_library(ctx *Create_libraryContext) {} + +// EnterPlsql_library_source is called when production plsql_library_source is entered. +func (s *BasePlSqlParserListener) EnterPlsql_library_source(ctx *Plsql_library_sourceContext) {} + +// ExitPlsql_library_source is called when production plsql_library_source is exited. +func (s *BasePlSqlParserListener) ExitPlsql_library_source(ctx *Plsql_library_sourceContext) {} + +// EnterCredential_name is called when production credential_name is entered. +func (s *BasePlSqlParserListener) EnterCredential_name(ctx *Credential_nameContext) {} + +// ExitCredential_name is called when production credential_name is exited. +func (s *BasePlSqlParserListener) ExitCredential_name(ctx *Credential_nameContext) {} + +// EnterLibrary_editionable is called when production library_editionable is entered. +func (s *BasePlSqlParserListener) EnterLibrary_editionable(ctx *Library_editionableContext) {} + +// ExitLibrary_editionable is called when production library_editionable is exited. +func (s *BasePlSqlParserListener) ExitLibrary_editionable(ctx *Library_editionableContext) {} + +// EnterLibrary_debug is called when production library_debug is entered. +func (s *BasePlSqlParserListener) EnterLibrary_debug(ctx *Library_debugContext) {} + +// ExitLibrary_debug is called when production library_debug is exited. +func (s *BasePlSqlParserListener) ExitLibrary_debug(ctx *Library_debugContext) {} + +// EnterCompiler_parameters_clause is called when production compiler_parameters_clause is entered. +func (s *BasePlSqlParserListener) EnterCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) { +} + +// ExitCompiler_parameters_clause is called when production compiler_parameters_clause is exited. +func (s *BasePlSqlParserListener) ExitCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) { +} + +// EnterParameter_value is called when production parameter_value is entered. +func (s *BasePlSqlParserListener) EnterParameter_value(ctx *Parameter_valueContext) {} + +// ExitParameter_value is called when production parameter_value is exited. +func (s *BasePlSqlParserListener) ExitParameter_value(ctx *Parameter_valueContext) {} + +// EnterLibrary_name is called when production library_name is entered. +func (s *BasePlSqlParserListener) EnterLibrary_name(ctx *Library_nameContext) {} + +// ExitLibrary_name is called when production library_name is exited. +func (s *BasePlSqlParserListener) ExitLibrary_name(ctx *Library_nameContext) {} + +// EnterAlter_dimension is called when production alter_dimension is entered. +func (s *BasePlSqlParserListener) EnterAlter_dimension(ctx *Alter_dimensionContext) {} + +// ExitAlter_dimension is called when production alter_dimension is exited. +func (s *BasePlSqlParserListener) ExitAlter_dimension(ctx *Alter_dimensionContext) {} + +// EnterLevel_clause is called when production level_clause is entered. +func (s *BasePlSqlParserListener) EnterLevel_clause(ctx *Level_clauseContext) {} + +// ExitLevel_clause is called when production level_clause is exited. +func (s *BasePlSqlParserListener) ExitLevel_clause(ctx *Level_clauseContext) {} + +// EnterHierarchy_clause is called when production hierarchy_clause is entered. +func (s *BasePlSqlParserListener) EnterHierarchy_clause(ctx *Hierarchy_clauseContext) {} + +// ExitHierarchy_clause is called when production hierarchy_clause is exited. +func (s *BasePlSqlParserListener) ExitHierarchy_clause(ctx *Hierarchy_clauseContext) {} + +// EnterDimension_join_clause is called when production dimension_join_clause is entered. +func (s *BasePlSqlParserListener) EnterDimension_join_clause(ctx *Dimension_join_clauseContext) {} + +// ExitDimension_join_clause is called when production dimension_join_clause is exited. +func (s *BasePlSqlParserListener) ExitDimension_join_clause(ctx *Dimension_join_clauseContext) {} + +// EnterAttribute_clause is called when production attribute_clause is entered. +func (s *BasePlSqlParserListener) EnterAttribute_clause(ctx *Attribute_clauseContext) {} + +// ExitAttribute_clause is called when production attribute_clause is exited. +func (s *BasePlSqlParserListener) ExitAttribute_clause(ctx *Attribute_clauseContext) {} + +// EnterExtended_attribute_clause is called when production extended_attribute_clause is entered. +func (s *BasePlSqlParserListener) EnterExtended_attribute_clause(ctx *Extended_attribute_clauseContext) { +} + +// ExitExtended_attribute_clause is called when production extended_attribute_clause is exited. +func (s *BasePlSqlParserListener) ExitExtended_attribute_clause(ctx *Extended_attribute_clauseContext) { +} + +// EnterColumn_one_or_more_sub_clause is called when production column_one_or_more_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) { +} + +// ExitColumn_one_or_more_sub_clause is called when production column_one_or_more_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) { +} + +// EnterAlter_view is called when production alter_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_view(ctx *Alter_viewContext) {} + +// ExitAlter_view is called when production alter_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_view(ctx *Alter_viewContext) {} + +// EnterAlter_view_editionable is called when production alter_view_editionable is entered. +func (s *BasePlSqlParserListener) EnterAlter_view_editionable(ctx *Alter_view_editionableContext) {} + +// ExitAlter_view_editionable is called when production alter_view_editionable is exited. +func (s *BasePlSqlParserListener) ExitAlter_view_editionable(ctx *Alter_view_editionableContext) {} + +// EnterCreate_view is called when production create_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_view(ctx *Create_viewContext) {} + +// ExitCreate_view is called when production create_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_view(ctx *Create_viewContext) {} + +// EnterEditioning_clause is called when production editioning_clause is entered. +func (s *BasePlSqlParserListener) EnterEditioning_clause(ctx *Editioning_clauseContext) {} + +// ExitEditioning_clause is called when production editioning_clause is exited. +func (s *BasePlSqlParserListener) ExitEditioning_clause(ctx *Editioning_clauseContext) {} + +// EnterView_options is called when production view_options is entered. +func (s *BasePlSqlParserListener) EnterView_options(ctx *View_optionsContext) {} + +// ExitView_options is called when production view_options is exited. +func (s *BasePlSqlParserListener) ExitView_options(ctx *View_optionsContext) {} + +// EnterView_alias_constraint is called when production view_alias_constraint is entered. +func (s *BasePlSqlParserListener) EnterView_alias_constraint(ctx *View_alias_constraintContext) {} + +// ExitView_alias_constraint is called when production view_alias_constraint is exited. +func (s *BasePlSqlParserListener) ExitView_alias_constraint(ctx *View_alias_constraintContext) {} + +// EnterObject_view_clause is called when production object_view_clause is entered. +func (s *BasePlSqlParserListener) EnterObject_view_clause(ctx *Object_view_clauseContext) {} + +// ExitObject_view_clause is called when production object_view_clause is exited. +func (s *BasePlSqlParserListener) ExitObject_view_clause(ctx *Object_view_clauseContext) {} + +// EnterInline_constraint is called when production inline_constraint is entered. +func (s *BasePlSqlParserListener) EnterInline_constraint(ctx *Inline_constraintContext) {} + +// ExitInline_constraint is called when production inline_constraint is exited. +func (s *BasePlSqlParserListener) ExitInline_constraint(ctx *Inline_constraintContext) {} + +// EnterInline_ref_constraint is called when production inline_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterInline_ref_constraint(ctx *Inline_ref_constraintContext) {} + +// ExitInline_ref_constraint is called when production inline_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitInline_ref_constraint(ctx *Inline_ref_constraintContext) {} + +// EnterOut_of_line_ref_constraint is called when production out_of_line_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) { +} + +// ExitOut_of_line_ref_constraint is called when production out_of_line_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) { +} + +// EnterOut_of_line_constraint is called when production out_of_line_constraint is entered. +func (s *BasePlSqlParserListener) EnterOut_of_line_constraint(ctx *Out_of_line_constraintContext) {} + +// ExitOut_of_line_constraint is called when production out_of_line_constraint is exited. +func (s *BasePlSqlParserListener) ExitOut_of_line_constraint(ctx *Out_of_line_constraintContext) {} + +// EnterConstraint_state is called when production constraint_state is entered. +func (s *BasePlSqlParserListener) EnterConstraint_state(ctx *Constraint_stateContext) {} + +// ExitConstraint_state is called when production constraint_state is exited. +func (s *BasePlSqlParserListener) ExitConstraint_state(ctx *Constraint_stateContext) {} + +// EnterXmltype_view_clause is called when production xmltype_view_clause is entered. +func (s *BasePlSqlParserListener) EnterXmltype_view_clause(ctx *Xmltype_view_clauseContext) {} + +// ExitXmltype_view_clause is called when production xmltype_view_clause is exited. +func (s *BasePlSqlParserListener) ExitXmltype_view_clause(ctx *Xmltype_view_clauseContext) {} + +// EnterXml_schema_spec is called when production xml_schema_spec is entered. +func (s *BasePlSqlParserListener) EnterXml_schema_spec(ctx *Xml_schema_specContext) {} + +// ExitXml_schema_spec is called when production xml_schema_spec is exited. +func (s *BasePlSqlParserListener) ExitXml_schema_spec(ctx *Xml_schema_specContext) {} + +// EnterXml_schema_url is called when production xml_schema_url is entered. +func (s *BasePlSqlParserListener) EnterXml_schema_url(ctx *Xml_schema_urlContext) {} + +// ExitXml_schema_url is called when production xml_schema_url is exited. +func (s *BasePlSqlParserListener) ExitXml_schema_url(ctx *Xml_schema_urlContext) {} + +// EnterElement is called when production element is entered. +func (s *BasePlSqlParserListener) EnterElement(ctx *ElementContext) {} + +// ExitElement is called when production element is exited. +func (s *BasePlSqlParserListener) ExitElement(ctx *ElementContext) {} + +// EnterAlter_tablespace is called when production alter_tablespace is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace(ctx *Alter_tablespaceContext) {} + +// ExitAlter_tablespace is called when production alter_tablespace is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace(ctx *Alter_tablespaceContext) {} + +// EnterDatafile_tempfile_clauses is called when production datafile_tempfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) { +} + +// ExitDatafile_tempfile_clauses is called when production datafile_tempfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) { +} + +// EnterTablespace_logging_clauses is called when production tablespace_logging_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) { +} + +// ExitTablespace_logging_clauses is called when production tablespace_logging_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) { +} + +// EnterTablespace_group_clause is called when production tablespace_group_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_group_clause(ctx *Tablespace_group_clauseContext) {} + +// ExitTablespace_group_clause is called when production tablespace_group_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_group_clause(ctx *Tablespace_group_clauseContext) {} + +// EnterTablespace_group_name is called when production tablespace_group_name is entered. +func (s *BasePlSqlParserListener) EnterTablespace_group_name(ctx *Tablespace_group_nameContext) {} + +// ExitTablespace_group_name is called when production tablespace_group_name is exited. +func (s *BasePlSqlParserListener) ExitTablespace_group_name(ctx *Tablespace_group_nameContext) {} + +// EnterTablespace_state_clauses is called when production tablespace_state_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_state_clauses(ctx *Tablespace_state_clausesContext) { +} + +// ExitTablespace_state_clauses is called when production tablespace_state_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_state_clauses(ctx *Tablespace_state_clausesContext) { +} + +// EnterFlashback_mode_clause is called when production flashback_mode_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_mode_clause(ctx *Flashback_mode_clauseContext) {} + +// ExitFlashback_mode_clause is called when production flashback_mode_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_mode_clause(ctx *Flashback_mode_clauseContext) {} + +// EnterNew_tablespace_name is called when production new_tablespace_name is entered. +func (s *BasePlSqlParserListener) EnterNew_tablespace_name(ctx *New_tablespace_nameContext) {} + +// ExitNew_tablespace_name is called when production new_tablespace_name is exited. +func (s *BasePlSqlParserListener) ExitNew_tablespace_name(ctx *New_tablespace_nameContext) {} + +// EnterCreate_tablespace is called when production create_tablespace is entered. +func (s *BasePlSqlParserListener) EnterCreate_tablespace(ctx *Create_tablespaceContext) {} + +// ExitCreate_tablespace is called when production create_tablespace is exited. +func (s *BasePlSqlParserListener) ExitCreate_tablespace(ctx *Create_tablespaceContext) {} + +// EnterPermanent_tablespace_clause is called when production permanent_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) { +} + +// ExitPermanent_tablespace_clause is called when production permanent_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) { +} + +// EnterTablespace_encryption_spec is called when production tablespace_encryption_spec is entered. +func (s *BasePlSqlParserListener) EnterTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) { +} + +// ExitTablespace_encryption_spec is called when production tablespace_encryption_spec is exited. +func (s *BasePlSqlParserListener) ExitTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) { +} + +// EnterLogging_clause is called when production logging_clause is entered. +func (s *BasePlSqlParserListener) EnterLogging_clause(ctx *Logging_clauseContext) {} + +// ExitLogging_clause is called when production logging_clause is exited. +func (s *BasePlSqlParserListener) ExitLogging_clause(ctx *Logging_clauseContext) {} + +// EnterExtent_management_clause is called when production extent_management_clause is entered. +func (s *BasePlSqlParserListener) EnterExtent_management_clause(ctx *Extent_management_clauseContext) { +} + +// ExitExtent_management_clause is called when production extent_management_clause is exited. +func (s *BasePlSqlParserListener) ExitExtent_management_clause(ctx *Extent_management_clauseContext) { +} + +// EnterSegment_management_clause is called when production segment_management_clause is entered. +func (s *BasePlSqlParserListener) EnterSegment_management_clause(ctx *Segment_management_clauseContext) { +} + +// ExitSegment_management_clause is called when production segment_management_clause is exited. +func (s *BasePlSqlParserListener) ExitSegment_management_clause(ctx *Segment_management_clauseContext) { +} + +// EnterTemporary_tablespace_clause is called when production temporary_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) { +} + +// ExitTemporary_tablespace_clause is called when production temporary_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) { +} + +// EnterUndo_tablespace_clause is called when production undo_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) {} + +// ExitUndo_tablespace_clause is called when production undo_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) {} + +// EnterTablespace_retention_clause is called when production tablespace_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) { +} + +// ExitTablespace_retention_clause is called when production tablespace_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) { +} + +// EnterCreate_tablespace_set is called when production create_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterCreate_tablespace_set(ctx *Create_tablespace_setContext) {} + +// ExitCreate_tablespace_set is called when production create_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitCreate_tablespace_set(ctx *Create_tablespace_setContext) {} + +// EnterPermanent_tablespace_attrs is called when production permanent_tablespace_attrs is entered. +func (s *BasePlSqlParserListener) EnterPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) { +} + +// ExitPermanent_tablespace_attrs is called when production permanent_tablespace_attrs is exited. +func (s *BasePlSqlParserListener) ExitPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) { +} + +// EnterTablespace_encryption_clause is called when production tablespace_encryption_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) { +} + +// ExitTablespace_encryption_clause is called when production tablespace_encryption_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) { +} + +// EnterDefault_tablespace_params is called when production default_tablespace_params is entered. +func (s *BasePlSqlParserListener) EnterDefault_tablespace_params(ctx *Default_tablespace_paramsContext) { +} + +// ExitDefault_tablespace_params is called when production default_tablespace_params is exited. +func (s *BasePlSqlParserListener) ExitDefault_tablespace_params(ctx *Default_tablespace_paramsContext) { +} + +// EnterDefault_table_compression is called when production default_table_compression is entered. +func (s *BasePlSqlParserListener) EnterDefault_table_compression(ctx *Default_table_compressionContext) { +} + +// ExitDefault_table_compression is called when production default_table_compression is exited. +func (s *BasePlSqlParserListener) ExitDefault_table_compression(ctx *Default_table_compressionContext) { +} + +// EnterLow_high is called when production low_high is entered. +func (s *BasePlSqlParserListener) EnterLow_high(ctx *Low_highContext) {} + +// ExitLow_high is called when production low_high is exited. +func (s *BasePlSqlParserListener) ExitLow_high(ctx *Low_highContext) {} + +// EnterDefault_index_compression is called when production default_index_compression is entered. +func (s *BasePlSqlParserListener) EnterDefault_index_compression(ctx *Default_index_compressionContext) { +} + +// ExitDefault_index_compression is called when production default_index_compression is exited. +func (s *BasePlSqlParserListener) ExitDefault_index_compression(ctx *Default_index_compressionContext) { +} + +// EnterInmmemory_clause is called when production inmmemory_clause is entered. +func (s *BasePlSqlParserListener) EnterInmmemory_clause(ctx *Inmmemory_clauseContext) {} + +// ExitInmmemory_clause is called when production inmmemory_clause is exited. +func (s *BasePlSqlParserListener) ExitInmmemory_clause(ctx *Inmmemory_clauseContext) {} + +// EnterDatafile_specification is called when production datafile_specification is entered. +func (s *BasePlSqlParserListener) EnterDatafile_specification(ctx *Datafile_specificationContext) {} + +// ExitDatafile_specification is called when production datafile_specification is exited. +func (s *BasePlSqlParserListener) ExitDatafile_specification(ctx *Datafile_specificationContext) {} + +// EnterTempfile_specification is called when production tempfile_specification is entered. +func (s *BasePlSqlParserListener) EnterTempfile_specification(ctx *Tempfile_specificationContext) {} + +// ExitTempfile_specification is called when production tempfile_specification is exited. +func (s *BasePlSqlParserListener) ExitTempfile_specification(ctx *Tempfile_specificationContext) {} + +// EnterDatafile_tempfile_spec is called when production datafile_tempfile_spec is entered. +func (s *BasePlSqlParserListener) EnterDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) {} + +// ExitDatafile_tempfile_spec is called when production datafile_tempfile_spec is exited. +func (s *BasePlSqlParserListener) ExitDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) {} + +// EnterRedo_log_file_spec is called when production redo_log_file_spec is entered. +func (s *BasePlSqlParserListener) EnterRedo_log_file_spec(ctx *Redo_log_file_specContext) {} + +// ExitRedo_log_file_spec is called when production redo_log_file_spec is exited. +func (s *BasePlSqlParserListener) ExitRedo_log_file_spec(ctx *Redo_log_file_specContext) {} + +// EnterAutoextend_clause is called when production autoextend_clause is entered. +func (s *BasePlSqlParserListener) EnterAutoextend_clause(ctx *Autoextend_clauseContext) {} + +// ExitAutoextend_clause is called when production autoextend_clause is exited. +func (s *BasePlSqlParserListener) ExitAutoextend_clause(ctx *Autoextend_clauseContext) {} + +// EnterMaxsize_clause is called when production maxsize_clause is entered. +func (s *BasePlSqlParserListener) EnterMaxsize_clause(ctx *Maxsize_clauseContext) {} + +// ExitMaxsize_clause is called when production maxsize_clause is exited. +func (s *BasePlSqlParserListener) ExitMaxsize_clause(ctx *Maxsize_clauseContext) {} + +// EnterBuild_clause is called when production build_clause is entered. +func (s *BasePlSqlParserListener) EnterBuild_clause(ctx *Build_clauseContext) {} + +// ExitBuild_clause is called when production build_clause is exited. +func (s *BasePlSqlParserListener) ExitBuild_clause(ctx *Build_clauseContext) {} + +// EnterParallel_clause is called when production parallel_clause is entered. +func (s *BasePlSqlParserListener) EnterParallel_clause(ctx *Parallel_clauseContext) {} + +// ExitParallel_clause is called when production parallel_clause is exited. +func (s *BasePlSqlParserListener) ExitParallel_clause(ctx *Parallel_clauseContext) {} + +// EnterParallel_instances_clause is called when production parallel_instances_clause is entered. +func (s *BasePlSqlParserListener) EnterParallel_instances_clause(ctx *Parallel_instances_clauseContext) { +} + +// ExitParallel_instances_clause is called when production parallel_instances_clause is exited. +func (s *BasePlSqlParserListener) ExitParallel_instances_clause(ctx *Parallel_instances_clauseContext) { +} + +// EnterAlter_materialized_view is called when production alter_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_view(ctx *Alter_materialized_viewContext) {} + +// ExitAlter_materialized_view is called when production alter_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_view(ctx *Alter_materialized_viewContext) {} + +// EnterAlter_mv_option1 is called when production alter_mv_option1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_mv_option1(ctx *Alter_mv_option1Context) {} + +// ExitAlter_mv_option1 is called when production alter_mv_option1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_mv_option1(ctx *Alter_mv_option1Context) {} + +// EnterAlter_mv_refresh is called when production alter_mv_refresh is entered. +func (s *BasePlSqlParserListener) EnterAlter_mv_refresh(ctx *Alter_mv_refreshContext) {} + +// ExitAlter_mv_refresh is called when production alter_mv_refresh is exited. +func (s *BasePlSqlParserListener) ExitAlter_mv_refresh(ctx *Alter_mv_refreshContext) {} + +// EnterRollback_segment is called when production rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterRollback_segment(ctx *Rollback_segmentContext) {} + +// ExitRollback_segment is called when production rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitRollback_segment(ctx *Rollback_segmentContext) {} + +// EnterModify_mv_column_clause is called when production modify_mv_column_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) {} + +// ExitModify_mv_column_clause is called when production modify_mv_column_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) {} + +// EnterAlter_materialized_view_log is called when production alter_materialized_view_log is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) { +} + +// ExitAlter_materialized_view_log is called when production alter_materialized_view_log is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) { +} + +// EnterAdd_mv_log_column_clause is called when production add_mv_log_column_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) { +} + +// ExitAdd_mv_log_column_clause is called when production add_mv_log_column_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) { +} + +// EnterMove_mv_log_clause is called when production move_mv_log_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_mv_log_clause(ctx *Move_mv_log_clauseContext) {} + +// ExitMove_mv_log_clause is called when production move_mv_log_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_mv_log_clause(ctx *Move_mv_log_clauseContext) {} + +// EnterMv_log_augmentation is called when production mv_log_augmentation is entered. +func (s *BasePlSqlParserListener) EnterMv_log_augmentation(ctx *Mv_log_augmentationContext) {} + +// ExitMv_log_augmentation is called when production mv_log_augmentation is exited. +func (s *BasePlSqlParserListener) ExitMv_log_augmentation(ctx *Mv_log_augmentationContext) {} + +// EnterCreate_materialized_view_log is called when production create_materialized_view_log is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_view_log(ctx *Create_materialized_view_logContext) { +} + +// ExitCreate_materialized_view_log is called when production create_materialized_view_log is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_view_log(ctx *Create_materialized_view_logContext) { +} + +// EnterNew_values_clause is called when production new_values_clause is entered. +func (s *BasePlSqlParserListener) EnterNew_values_clause(ctx *New_values_clauseContext) {} + +// ExitNew_values_clause is called when production new_values_clause is exited. +func (s *BasePlSqlParserListener) ExitNew_values_clause(ctx *New_values_clauseContext) {} + +// EnterMv_log_purge_clause is called when production mv_log_purge_clause is entered. +func (s *BasePlSqlParserListener) EnterMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) {} + +// ExitMv_log_purge_clause is called when production mv_log_purge_clause is exited. +func (s *BasePlSqlParserListener) ExitMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) {} + +// EnterCreate_materialized_zonemap is called when production create_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) { +} + +// ExitCreate_materialized_zonemap is called when production create_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) { +} + +// EnterAlter_materialized_zonemap is called when production alter_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) { +} + +// ExitAlter_materialized_zonemap is called when production alter_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) { +} + +// EnterDrop_materialized_zonemap is called when production drop_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) { +} + +// ExitDrop_materialized_zonemap is called when production drop_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) { +} + +// EnterZonemap_refresh_clause is called when production zonemap_refresh_clause is entered. +func (s *BasePlSqlParserListener) EnterZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) {} + +// ExitZonemap_refresh_clause is called when production zonemap_refresh_clause is exited. +func (s *BasePlSqlParserListener) ExitZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) {} + +// EnterZonemap_attributes is called when production zonemap_attributes is entered. +func (s *BasePlSqlParserListener) EnterZonemap_attributes(ctx *Zonemap_attributesContext) {} + +// ExitZonemap_attributes is called when production zonemap_attributes is exited. +func (s *BasePlSqlParserListener) ExitZonemap_attributes(ctx *Zonemap_attributesContext) {} + +// EnterZonemap_name is called when production zonemap_name is entered. +func (s *BasePlSqlParserListener) EnterZonemap_name(ctx *Zonemap_nameContext) {} + +// ExitZonemap_name is called when production zonemap_name is exited. +func (s *BasePlSqlParserListener) ExitZonemap_name(ctx *Zonemap_nameContext) {} + +// EnterOperator_name is called when production operator_name is entered. +func (s *BasePlSqlParserListener) EnterOperator_name(ctx *Operator_nameContext) {} + +// ExitOperator_name is called when production operator_name is exited. +func (s *BasePlSqlParserListener) ExitOperator_name(ctx *Operator_nameContext) {} + +// EnterOperator_function_name is called when production operator_function_name is entered. +func (s *BasePlSqlParserListener) EnterOperator_function_name(ctx *Operator_function_nameContext) {} + +// ExitOperator_function_name is called when production operator_function_name is exited. +func (s *BasePlSqlParserListener) ExitOperator_function_name(ctx *Operator_function_nameContext) {} + +// EnterCreate_zonemap_on_table is called when production create_zonemap_on_table is entered. +func (s *BasePlSqlParserListener) EnterCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) {} + +// ExitCreate_zonemap_on_table is called when production create_zonemap_on_table is exited. +func (s *BasePlSqlParserListener) ExitCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) {} + +// EnterCreate_zonemap_as_subquery is called when production create_zonemap_as_subquery is entered. +func (s *BasePlSqlParserListener) EnterCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) { +} + +// ExitCreate_zonemap_as_subquery is called when production create_zonemap_as_subquery is exited. +func (s *BasePlSqlParserListener) ExitCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) { +} + +// EnterAlter_operator is called when production alter_operator is entered. +func (s *BasePlSqlParserListener) EnterAlter_operator(ctx *Alter_operatorContext) {} + +// ExitAlter_operator is called when production alter_operator is exited. +func (s *BasePlSqlParserListener) ExitAlter_operator(ctx *Alter_operatorContext) {} + +// EnterDrop_operator is called when production drop_operator is entered. +func (s *BasePlSqlParserListener) EnterDrop_operator(ctx *Drop_operatorContext) {} + +// ExitDrop_operator is called when production drop_operator is exited. +func (s *BasePlSqlParserListener) ExitDrop_operator(ctx *Drop_operatorContext) {} + +// EnterCreate_operator is called when production create_operator is entered. +func (s *BasePlSqlParserListener) EnterCreate_operator(ctx *Create_operatorContext) {} + +// ExitCreate_operator is called when production create_operator is exited. +func (s *BasePlSqlParserListener) ExitCreate_operator(ctx *Create_operatorContext) {} + +// EnterBinding_clause is called when production binding_clause is entered. +func (s *BasePlSqlParserListener) EnterBinding_clause(ctx *Binding_clauseContext) {} + +// ExitBinding_clause is called when production binding_clause is exited. +func (s *BasePlSqlParserListener) ExitBinding_clause(ctx *Binding_clauseContext) {} + +// EnterAdd_binding_clause is called when production add_binding_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_binding_clause(ctx *Add_binding_clauseContext) {} + +// ExitAdd_binding_clause is called when production add_binding_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_binding_clause(ctx *Add_binding_clauseContext) {} + +// EnterImplementation_clause is called when production implementation_clause is entered. +func (s *BasePlSqlParserListener) EnterImplementation_clause(ctx *Implementation_clauseContext) {} + +// ExitImplementation_clause is called when production implementation_clause is exited. +func (s *BasePlSqlParserListener) ExitImplementation_clause(ctx *Implementation_clauseContext) {} + +// EnterPrimary_operator_list is called when production primary_operator_list is entered. +func (s *BasePlSqlParserListener) EnterPrimary_operator_list(ctx *Primary_operator_listContext) {} + +// ExitPrimary_operator_list is called when production primary_operator_list is exited. +func (s *BasePlSqlParserListener) ExitPrimary_operator_list(ctx *Primary_operator_listContext) {} + +// EnterPrimary_operator_item is called when production primary_operator_item is entered. +func (s *BasePlSqlParserListener) EnterPrimary_operator_item(ctx *Primary_operator_itemContext) {} + +// ExitPrimary_operator_item is called when production primary_operator_item is exited. +func (s *BasePlSqlParserListener) ExitPrimary_operator_item(ctx *Primary_operator_itemContext) {} + +// EnterOperator_context_clause is called when production operator_context_clause is entered. +func (s *BasePlSqlParserListener) EnterOperator_context_clause(ctx *Operator_context_clauseContext) {} + +// ExitOperator_context_clause is called when production operator_context_clause is exited. +func (s *BasePlSqlParserListener) ExitOperator_context_clause(ctx *Operator_context_clauseContext) {} + +// EnterUsing_function_clause is called when production using_function_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_function_clause(ctx *Using_function_clauseContext) {} + +// ExitUsing_function_clause is called when production using_function_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_function_clause(ctx *Using_function_clauseContext) {} + +// EnterDrop_binding_clause is called when production drop_binding_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_binding_clause(ctx *Drop_binding_clauseContext) {} + +// ExitDrop_binding_clause is called when production drop_binding_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_binding_clause(ctx *Drop_binding_clauseContext) {} + +// EnterCreate_materialized_view is called when production create_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// ExitCreate_materialized_view is called when production create_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// EnterScoped_table_ref_constraint is called when production scoped_table_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) { +} + +// ExitScoped_table_ref_constraint is called when production scoped_table_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) { +} + +// EnterMv_column_alias is called when production mv_column_alias is entered. +func (s *BasePlSqlParserListener) EnterMv_column_alias(ctx *Mv_column_aliasContext) {} + +// ExitMv_column_alias is called when production mv_column_alias is exited. +func (s *BasePlSqlParserListener) ExitMv_column_alias(ctx *Mv_column_aliasContext) {} + +// EnterCreate_mv_refresh is called when production create_mv_refresh is entered. +func (s *BasePlSqlParserListener) EnterCreate_mv_refresh(ctx *Create_mv_refreshContext) {} + +// ExitCreate_mv_refresh is called when production create_mv_refresh is exited. +func (s *BasePlSqlParserListener) ExitCreate_mv_refresh(ctx *Create_mv_refreshContext) {} + +// EnterQuery_rewrite_clause is called when production query_rewrite_clause is entered. +func (s *BasePlSqlParserListener) EnterQuery_rewrite_clause(ctx *Query_rewrite_clauseContext) {} + +// ExitQuery_rewrite_clause is called when production query_rewrite_clause is exited. +func (s *BasePlSqlParserListener) ExitQuery_rewrite_clause(ctx *Query_rewrite_clauseContext) {} + +// EnterUnusable_editions_clause is called when production unusable_editions_clause is entered. +func (s *BasePlSqlParserListener) EnterUnusable_editions_clause(ctx *Unusable_editions_clauseContext) { +} + +// ExitUnusable_editions_clause is called when production unusable_editions_clause is exited. +func (s *BasePlSqlParserListener) ExitUnusable_editions_clause(ctx *Unusable_editions_clauseContext) { +} + +// EnterDrop_materialized_view is called when production drop_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_materialized_view(ctx *Drop_materialized_viewContext) {} + +// ExitDrop_materialized_view is called when production drop_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_materialized_view(ctx *Drop_materialized_viewContext) {} + +// EnterDrop_materialized_view_log is called when production drop_materialized_view_log is entered. +func (s *BasePlSqlParserListener) EnterDrop_materialized_view_log(ctx *Drop_materialized_view_logContext) { +} + +// ExitDrop_materialized_view_log is called when production drop_materialized_view_log is exited. +func (s *BasePlSqlParserListener) ExitDrop_materialized_view_log(ctx *Drop_materialized_view_logContext) { +} + +// EnterCreate_context is called when production create_context is entered. +func (s *BasePlSqlParserListener) EnterCreate_context(ctx *Create_contextContext) {} + +// ExitCreate_context is called when production create_context is exited. +func (s *BasePlSqlParserListener) ExitCreate_context(ctx *Create_contextContext) {} + +// EnterOracle_namespace is called when production oracle_namespace is entered. +func (s *BasePlSqlParserListener) EnterOracle_namespace(ctx *Oracle_namespaceContext) {} + +// ExitOracle_namespace is called when production oracle_namespace is exited. +func (s *BasePlSqlParserListener) ExitOracle_namespace(ctx *Oracle_namespaceContext) {} + +// EnterCreate_cluster is called when production create_cluster is entered. +func (s *BasePlSqlParserListener) EnterCreate_cluster(ctx *Create_clusterContext) {} + +// ExitCreate_cluster is called when production create_cluster is exited. +func (s *BasePlSqlParserListener) ExitCreate_cluster(ctx *Create_clusterContext) {} + +// EnterCreate_profile is called when production create_profile is entered. +func (s *BasePlSqlParserListener) EnterCreate_profile(ctx *Create_profileContext) {} + +// ExitCreate_profile is called when production create_profile is exited. +func (s *BasePlSqlParserListener) ExitCreate_profile(ctx *Create_profileContext) {} + +// EnterResource_parameters is called when production resource_parameters is entered. +func (s *BasePlSqlParserListener) EnterResource_parameters(ctx *Resource_parametersContext) {} + +// ExitResource_parameters is called when production resource_parameters is exited. +func (s *BasePlSqlParserListener) ExitResource_parameters(ctx *Resource_parametersContext) {} + +// EnterPassword_parameters is called when production password_parameters is entered. +func (s *BasePlSqlParserListener) EnterPassword_parameters(ctx *Password_parametersContext) {} + +// ExitPassword_parameters is called when production password_parameters is exited. +func (s *BasePlSqlParserListener) ExitPassword_parameters(ctx *Password_parametersContext) {} + +// EnterCreate_lockdown_profile is called when production create_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterCreate_lockdown_profile(ctx *Create_lockdown_profileContext) {} + +// ExitCreate_lockdown_profile is called when production create_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitCreate_lockdown_profile(ctx *Create_lockdown_profileContext) {} + +// EnterStatic_base_profile is called when production static_base_profile is entered. +func (s *BasePlSqlParserListener) EnterStatic_base_profile(ctx *Static_base_profileContext) {} + +// ExitStatic_base_profile is called when production static_base_profile is exited. +func (s *BasePlSqlParserListener) ExitStatic_base_profile(ctx *Static_base_profileContext) {} + +// EnterDynamic_base_profile is called when production dynamic_base_profile is entered. +func (s *BasePlSqlParserListener) EnterDynamic_base_profile(ctx *Dynamic_base_profileContext) {} + +// ExitDynamic_base_profile is called when production dynamic_base_profile is exited. +func (s *BasePlSqlParserListener) ExitDynamic_base_profile(ctx *Dynamic_base_profileContext) {} + +// EnterCreate_outline is called when production create_outline is entered. +func (s *BasePlSqlParserListener) EnterCreate_outline(ctx *Create_outlineContext) {} + +// ExitCreate_outline is called when production create_outline is exited. +func (s *BasePlSqlParserListener) ExitCreate_outline(ctx *Create_outlineContext) {} + +// EnterCreate_restore_point is called when production create_restore_point is entered. +func (s *BasePlSqlParserListener) EnterCreate_restore_point(ctx *Create_restore_pointContext) {} + +// ExitCreate_restore_point is called when production create_restore_point is exited. +func (s *BasePlSqlParserListener) ExitCreate_restore_point(ctx *Create_restore_pointContext) {} + +// EnterCreate_role is called when production create_role is entered. +func (s *BasePlSqlParserListener) EnterCreate_role(ctx *Create_roleContext) {} + +// ExitCreate_role is called when production create_role is exited. +func (s *BasePlSqlParserListener) ExitCreate_role(ctx *Create_roleContext) {} + +// EnterCreate_table is called when production create_table is entered. +func (s *BasePlSqlParserListener) EnterCreate_table(ctx *Create_tableContext) {} + +// ExitCreate_table is called when production create_table is exited. +func (s *BasePlSqlParserListener) ExitCreate_table(ctx *Create_tableContext) {} + +// EnterXmltype_table is called when production xmltype_table is entered. +func (s *BasePlSqlParserListener) EnterXmltype_table(ctx *Xmltype_tableContext) {} + +// ExitXmltype_table is called when production xmltype_table is exited. +func (s *BasePlSqlParserListener) ExitXmltype_table(ctx *Xmltype_tableContext) {} + +// EnterXmltype_virtual_columns is called when production xmltype_virtual_columns is entered. +func (s *BasePlSqlParserListener) EnterXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) {} + +// ExitXmltype_virtual_columns is called when production xmltype_virtual_columns is exited. +func (s *BasePlSqlParserListener) ExitXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) {} + +// EnterXmltype_column_properties is called when production xmltype_column_properties is entered. +func (s *BasePlSqlParserListener) EnterXmltype_column_properties(ctx *Xmltype_column_propertiesContext) { +} + +// ExitXmltype_column_properties is called when production xmltype_column_properties is exited. +func (s *BasePlSqlParserListener) ExitXmltype_column_properties(ctx *Xmltype_column_propertiesContext) { +} + +// EnterXmltype_storage is called when production xmltype_storage is entered. +func (s *BasePlSqlParserListener) EnterXmltype_storage(ctx *Xmltype_storageContext) {} + +// ExitXmltype_storage is called when production xmltype_storage is exited. +func (s *BasePlSqlParserListener) ExitXmltype_storage(ctx *Xmltype_storageContext) {} + +// EnterXmlschema_spec is called when production xmlschema_spec is entered. +func (s *BasePlSqlParserListener) EnterXmlschema_spec(ctx *Xmlschema_specContext) {} + +// ExitXmlschema_spec is called when production xmlschema_spec is exited. +func (s *BasePlSqlParserListener) ExitXmlschema_spec(ctx *Xmlschema_specContext) {} + +// EnterObject_table is called when production object_table is entered. +func (s *BasePlSqlParserListener) EnterObject_table(ctx *Object_tableContext) {} + +// ExitObject_table is called when production object_table is exited. +func (s *BasePlSqlParserListener) ExitObject_table(ctx *Object_tableContext) {} + +// EnterObject_type is called when production object_type is entered. +func (s *BasePlSqlParserListener) EnterObject_type(ctx *Object_typeContext) {} + +// ExitObject_type is called when production object_type is exited. +func (s *BasePlSqlParserListener) ExitObject_type(ctx *Object_typeContext) {} + +// EnterOid_index_clause is called when production oid_index_clause is entered. +func (s *BasePlSqlParserListener) EnterOid_index_clause(ctx *Oid_index_clauseContext) {} + +// ExitOid_index_clause is called when production oid_index_clause is exited. +func (s *BasePlSqlParserListener) ExitOid_index_clause(ctx *Oid_index_clauseContext) {} + +// EnterOid_clause is called when production oid_clause is entered. +func (s *BasePlSqlParserListener) EnterOid_clause(ctx *Oid_clauseContext) {} + +// ExitOid_clause is called when production oid_clause is exited. +func (s *BasePlSqlParserListener) ExitOid_clause(ctx *Oid_clauseContext) {} + +// EnterObject_properties is called when production object_properties is entered. +func (s *BasePlSqlParserListener) EnterObject_properties(ctx *Object_propertiesContext) {} + +// ExitObject_properties is called when production object_properties is exited. +func (s *BasePlSqlParserListener) ExitObject_properties(ctx *Object_propertiesContext) {} + +// EnterObject_table_substitution is called when production object_table_substitution is entered. +func (s *BasePlSqlParserListener) EnterObject_table_substitution(ctx *Object_table_substitutionContext) { +} + +// ExitObject_table_substitution is called when production object_table_substitution is exited. +func (s *BasePlSqlParserListener) ExitObject_table_substitution(ctx *Object_table_substitutionContext) { +} + +// EnterRelational_table is called when production relational_table is entered. +func (s *BasePlSqlParserListener) EnterRelational_table(ctx *Relational_tableContext) {} + +// ExitRelational_table is called when production relational_table is exited. +func (s *BasePlSqlParserListener) ExitRelational_table(ctx *Relational_tableContext) {} + +// EnterRelational_table_properties is called when production relational_table_properties is entered. +func (s *BasePlSqlParserListener) EnterRelational_table_properties(ctx *Relational_table_propertiesContext) { +} + +// ExitRelational_table_properties is called when production relational_table_properties is exited. +func (s *BasePlSqlParserListener) ExitRelational_table_properties(ctx *Relational_table_propertiesContext) { +} + +// EnterRelational_table_property is called when production relational_table_property is entered. +func (s *BasePlSqlParserListener) EnterRelational_table_property(ctx *Relational_table_propertyContext) { +} + +// ExitRelational_table_property is called when production relational_table_property is exited. +func (s *BasePlSqlParserListener) ExitRelational_table_property(ctx *Relational_table_propertyContext) { +} + +// EnterImmutable_table_clauses is called when production immutable_table_clauses is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_clauses(ctx *Immutable_table_clausesContext) {} + +// ExitImmutable_table_clauses is called when production immutable_table_clauses is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_clauses(ctx *Immutable_table_clausesContext) {} + +// EnterImmutable_table_no_drop_clause is called when production immutable_table_no_drop_clause is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) { +} + +// ExitImmutable_table_no_drop_clause is called when production immutable_table_no_drop_clause is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) { +} + +// EnterImmutable_table_no_delete_clause is called when production immutable_table_no_delete_clause is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) { +} + +// ExitImmutable_table_no_delete_clause is called when production immutable_table_no_delete_clause is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) { +} + +// EnterBlockchain_table_clauses is called when production blockchain_table_clauses is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) { +} + +// ExitBlockchain_table_clauses is called when production blockchain_table_clauses is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) { +} + +// EnterBlockchain_drop_table_clause is called when production blockchain_drop_table_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) { +} + +// ExitBlockchain_drop_table_clause is called when production blockchain_drop_table_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) { +} + +// EnterBlockchain_row_retention_clause is called when production blockchain_row_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) { +} + +// ExitBlockchain_row_retention_clause is called when production blockchain_row_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) { +} + +// EnterBlockchain_hash_and_data_format_clause is called when production blockchain_hash_and_data_format_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) { +} + +// ExitBlockchain_hash_and_data_format_clause is called when production blockchain_hash_and_data_format_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) { +} + +// EnterCollation_name is called when production collation_name is entered. +func (s *BasePlSqlParserListener) EnterCollation_name(ctx *Collation_nameContext) {} + +// ExitCollation_name is called when production collation_name is exited. +func (s *BasePlSqlParserListener) ExitCollation_name(ctx *Collation_nameContext) {} + +// EnterTable_properties is called when production table_properties is entered. +func (s *BasePlSqlParserListener) EnterTable_properties(ctx *Table_propertiesContext) {} + +// ExitTable_properties is called when production table_properties is exited. +func (s *BasePlSqlParserListener) ExitTable_properties(ctx *Table_propertiesContext) {} + +// EnterRead_only_clause is called when production read_only_clause is entered. +func (s *BasePlSqlParserListener) EnterRead_only_clause(ctx *Read_only_clauseContext) {} + +// ExitRead_only_clause is called when production read_only_clause is exited. +func (s *BasePlSqlParserListener) ExitRead_only_clause(ctx *Read_only_clauseContext) {} + +// EnterIndexing_clause is called when production indexing_clause is entered. +func (s *BasePlSqlParserListener) EnterIndexing_clause(ctx *Indexing_clauseContext) {} + +// ExitIndexing_clause is called when production indexing_clause is exited. +func (s *BasePlSqlParserListener) ExitIndexing_clause(ctx *Indexing_clauseContext) {} + +// EnterAttribute_clustering_clause is called when production attribute_clustering_clause is entered. +func (s *BasePlSqlParserListener) EnterAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) { +} + +// ExitAttribute_clustering_clause is called when production attribute_clustering_clause is exited. +func (s *BasePlSqlParserListener) ExitAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) { +} + +// EnterClustering_join is called when production clustering_join is entered. +func (s *BasePlSqlParserListener) EnterClustering_join(ctx *Clustering_joinContext) {} + +// ExitClustering_join is called when production clustering_join is exited. +func (s *BasePlSqlParserListener) ExitClustering_join(ctx *Clustering_joinContext) {} + +// EnterClustering_join_item is called when production clustering_join_item is entered. +func (s *BasePlSqlParserListener) EnterClustering_join_item(ctx *Clustering_join_itemContext) {} + +// ExitClustering_join_item is called when production clustering_join_item is exited. +func (s *BasePlSqlParserListener) ExitClustering_join_item(ctx *Clustering_join_itemContext) {} + +// EnterEquijoin_condition is called when production equijoin_condition is entered. +func (s *BasePlSqlParserListener) EnterEquijoin_condition(ctx *Equijoin_conditionContext) {} + +// ExitEquijoin_condition is called when production equijoin_condition is exited. +func (s *BasePlSqlParserListener) ExitEquijoin_condition(ctx *Equijoin_conditionContext) {} + +// EnterCluster_clause is called when production cluster_clause is entered. +func (s *BasePlSqlParserListener) EnterCluster_clause(ctx *Cluster_clauseContext) {} + +// ExitCluster_clause is called when production cluster_clause is exited. +func (s *BasePlSqlParserListener) ExitCluster_clause(ctx *Cluster_clauseContext) {} + +// EnterClustering_columns is called when production clustering_columns is entered. +func (s *BasePlSqlParserListener) EnterClustering_columns(ctx *Clustering_columnsContext) {} + +// ExitClustering_columns is called when production clustering_columns is exited. +func (s *BasePlSqlParserListener) ExitClustering_columns(ctx *Clustering_columnsContext) {} + +// EnterClustering_column_group is called when production clustering_column_group is entered. +func (s *BasePlSqlParserListener) EnterClustering_column_group(ctx *Clustering_column_groupContext) {} + +// ExitClustering_column_group is called when production clustering_column_group is exited. +func (s *BasePlSqlParserListener) ExitClustering_column_group(ctx *Clustering_column_groupContext) {} + +// EnterYes_no is called when production yes_no is entered. +func (s *BasePlSqlParserListener) EnterYes_no(ctx *Yes_noContext) {} + +// ExitYes_no is called when production yes_no is exited. +func (s *BasePlSqlParserListener) ExitYes_no(ctx *Yes_noContext) {} + +// EnterZonemap_clause is called when production zonemap_clause is entered. +func (s *BasePlSqlParserListener) EnterZonemap_clause(ctx *Zonemap_clauseContext) {} + +// ExitZonemap_clause is called when production zonemap_clause is exited. +func (s *BasePlSqlParserListener) ExitZonemap_clause(ctx *Zonemap_clauseContext) {} + +// EnterLogical_replication_clause is called when production logical_replication_clause is entered. +func (s *BasePlSqlParserListener) EnterLogical_replication_clause(ctx *Logical_replication_clauseContext) { +} + +// ExitLogical_replication_clause is called when production logical_replication_clause is exited. +func (s *BasePlSqlParserListener) ExitLogical_replication_clause(ctx *Logical_replication_clauseContext) { +} + +// EnterTable_name is called when production table_name is entered. +func (s *BasePlSqlParserListener) EnterTable_name(ctx *Table_nameContext) {} + +// ExitTable_name is called when production table_name is exited. +func (s *BasePlSqlParserListener) ExitTable_name(ctx *Table_nameContext) {} + +// EnterRelational_property is called when production relational_property is entered. +func (s *BasePlSqlParserListener) EnterRelational_property(ctx *Relational_propertyContext) {} + +// ExitRelational_property is called when production relational_property is exited. +func (s *BasePlSqlParserListener) ExitRelational_property(ctx *Relational_propertyContext) {} + +// EnterTable_partitioning_clauses is called when production table_partitioning_clauses is entered. +func (s *BasePlSqlParserListener) EnterTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) { +} + +// ExitTable_partitioning_clauses is called when production table_partitioning_clauses is exited. +func (s *BasePlSqlParserListener) ExitTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) { +} + +// EnterRange_partitions is called when production range_partitions is entered. +func (s *BasePlSqlParserListener) EnterRange_partitions(ctx *Range_partitionsContext) {} + +// ExitRange_partitions is called when production range_partitions is exited. +func (s *BasePlSqlParserListener) ExitRange_partitions(ctx *Range_partitionsContext) {} + +// EnterList_partitions is called when production list_partitions is entered. +func (s *BasePlSqlParserListener) EnterList_partitions(ctx *List_partitionsContext) {} + +// ExitList_partitions is called when production list_partitions is exited. +func (s *BasePlSqlParserListener) ExitList_partitions(ctx *List_partitionsContext) {} + +// EnterHash_partitions is called when production hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterHash_partitions(ctx *Hash_partitionsContext) {} + +// ExitHash_partitions is called when production hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitHash_partitions(ctx *Hash_partitionsContext) {} + +// EnterIndividual_hash_partitions is called when production individual_hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) { +} + +// ExitIndividual_hash_partitions is called when production individual_hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) { +} + +// EnterHash_partitions_by_quantity is called when production hash_partitions_by_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) { +} + +// ExitHash_partitions_by_quantity is called when production hash_partitions_by_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) { +} + +// EnterHash_partition_quantity is called when production hash_partition_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_partition_quantity(ctx *Hash_partition_quantityContext) {} + +// ExitHash_partition_quantity is called when production hash_partition_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_partition_quantity(ctx *Hash_partition_quantityContext) {} + +// EnterComposite_range_partitions is called when production composite_range_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_range_partitions(ctx *Composite_range_partitionsContext) { +} + +// ExitComposite_range_partitions is called when production composite_range_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_range_partitions(ctx *Composite_range_partitionsContext) { +} + +// EnterComposite_list_partitions is called when production composite_list_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_list_partitions(ctx *Composite_list_partitionsContext) { +} + +// ExitComposite_list_partitions is called when production composite_list_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_list_partitions(ctx *Composite_list_partitionsContext) { +} + +// EnterComposite_hash_partitions is called when production composite_hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_hash_partitions(ctx *Composite_hash_partitionsContext) { +} + +// ExitComposite_hash_partitions is called when production composite_hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_hash_partitions(ctx *Composite_hash_partitionsContext) { +} + +// EnterReference_partitioning is called when production reference_partitioning is entered. +func (s *BasePlSqlParserListener) EnterReference_partitioning(ctx *Reference_partitioningContext) {} + +// ExitReference_partitioning is called when production reference_partitioning is exited. +func (s *BasePlSqlParserListener) ExitReference_partitioning(ctx *Reference_partitioningContext) {} + +// EnterReference_partition_desc is called when production reference_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterReference_partition_desc(ctx *Reference_partition_descContext) { +} + +// ExitReference_partition_desc is called when production reference_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitReference_partition_desc(ctx *Reference_partition_descContext) { +} + +// EnterSystem_partitioning is called when production system_partitioning is entered. +func (s *BasePlSqlParserListener) EnterSystem_partitioning(ctx *System_partitioningContext) {} + +// ExitSystem_partitioning is called when production system_partitioning is exited. +func (s *BasePlSqlParserListener) ExitSystem_partitioning(ctx *System_partitioningContext) {} + +// EnterRange_partition_desc is called when production range_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterRange_partition_desc(ctx *Range_partition_descContext) {} + +// ExitRange_partition_desc is called when production range_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitRange_partition_desc(ctx *Range_partition_descContext) {} + +// EnterList_partition_desc is called when production list_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterList_partition_desc(ctx *List_partition_descContext) {} + +// ExitList_partition_desc is called when production list_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitList_partition_desc(ctx *List_partition_descContext) {} + +// EnterSubpartition_template is called when production subpartition_template is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_template(ctx *Subpartition_templateContext) {} + +// ExitSubpartition_template is called when production subpartition_template is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_template(ctx *Subpartition_templateContext) {} + +// EnterHash_subpartition_quantity is called when production hash_subpartition_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) { +} + +// ExitHash_subpartition_quantity is called when production hash_subpartition_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) { +} + +// EnterSubpartition_by_range is called when production subpartition_by_range is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_range(ctx *Subpartition_by_rangeContext) {} + +// ExitSubpartition_by_range is called when production subpartition_by_range is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_range(ctx *Subpartition_by_rangeContext) {} + +// EnterSubpartition_by_list is called when production subpartition_by_list is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_list(ctx *Subpartition_by_listContext) {} + +// ExitSubpartition_by_list is called when production subpartition_by_list is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_list(ctx *Subpartition_by_listContext) {} + +// EnterSubpartition_by_hash is called when production subpartition_by_hash is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_hash(ctx *Subpartition_by_hashContext) {} + +// ExitSubpartition_by_hash is called when production subpartition_by_hash is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_hash(ctx *Subpartition_by_hashContext) {} + +// EnterSubpartition_name is called when production subpartition_name is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_name(ctx *Subpartition_nameContext) {} + +// ExitSubpartition_name is called when production subpartition_name is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_name(ctx *Subpartition_nameContext) {} + +// EnterRange_subpartition_desc is called when production range_subpartition_desc is entered. +func (s *BasePlSqlParserListener) EnterRange_subpartition_desc(ctx *Range_subpartition_descContext) {} + +// ExitRange_subpartition_desc is called when production range_subpartition_desc is exited. +func (s *BasePlSqlParserListener) ExitRange_subpartition_desc(ctx *Range_subpartition_descContext) {} + +// EnterList_subpartition_desc is called when production list_subpartition_desc is entered. +func (s *BasePlSqlParserListener) EnterList_subpartition_desc(ctx *List_subpartition_descContext) {} + +// ExitList_subpartition_desc is called when production list_subpartition_desc is exited. +func (s *BasePlSqlParserListener) ExitList_subpartition_desc(ctx *List_subpartition_descContext) {} + +// EnterIndividual_hash_subparts is called when production individual_hash_subparts is entered. +func (s *BasePlSqlParserListener) EnterIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) { +} + +// ExitIndividual_hash_subparts is called when production individual_hash_subparts is exited. +func (s *BasePlSqlParserListener) ExitIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) { +} + +// EnterHash_subparts_by_quantity is called when production hash_subparts_by_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) { +} + +// ExitHash_subparts_by_quantity is called when production hash_subparts_by_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) { +} + +// EnterRange_values_clause is called when production range_values_clause is entered. +func (s *BasePlSqlParserListener) EnterRange_values_clause(ctx *Range_values_clauseContext) {} + +// ExitRange_values_clause is called when production range_values_clause is exited. +func (s *BasePlSqlParserListener) ExitRange_values_clause(ctx *Range_values_clauseContext) {} + +// EnterRange_values_list is called when production range_values_list is entered. +func (s *BasePlSqlParserListener) EnterRange_values_list(ctx *Range_values_listContext) {} + +// ExitRange_values_list is called when production range_values_list is exited. +func (s *BasePlSqlParserListener) ExitRange_values_list(ctx *Range_values_listContext) {} + +// EnterList_values_clause is called when production list_values_clause is entered. +func (s *BasePlSqlParserListener) EnterList_values_clause(ctx *List_values_clauseContext) {} + +// ExitList_values_clause is called when production list_values_clause is exited. +func (s *BasePlSqlParserListener) ExitList_values_clause(ctx *List_values_clauseContext) {} + +// EnterTable_partition_description is called when production table_partition_description is entered. +func (s *BasePlSqlParserListener) EnterTable_partition_description(ctx *Table_partition_descriptionContext) { +} + +// ExitTable_partition_description is called when production table_partition_description is exited. +func (s *BasePlSqlParserListener) ExitTable_partition_description(ctx *Table_partition_descriptionContext) { +} + +// EnterPartitioning_storage_clause is called when production partitioning_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) { +} + +// ExitPartitioning_storage_clause is called when production partitioning_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) { +} + +// EnterLob_partitioning_storage is called when production lob_partitioning_storage is entered. +func (s *BasePlSqlParserListener) EnterLob_partitioning_storage(ctx *Lob_partitioning_storageContext) { +} + +// ExitLob_partitioning_storage is called when production lob_partitioning_storage is exited. +func (s *BasePlSqlParserListener) ExitLob_partitioning_storage(ctx *Lob_partitioning_storageContext) { +} + +// EnterSize_clause is called when production size_clause is entered. +func (s *BasePlSqlParserListener) EnterSize_clause(ctx *Size_clauseContext) {} + +// ExitSize_clause is called when production size_clause is exited. +func (s *BasePlSqlParserListener) ExitSize_clause(ctx *Size_clauseContext) {} + +// EnterTable_compression is called when production table_compression is entered. +func (s *BasePlSqlParserListener) EnterTable_compression(ctx *Table_compressionContext) {} + +// ExitTable_compression is called when production table_compression is exited. +func (s *BasePlSqlParserListener) ExitTable_compression(ctx *Table_compressionContext) {} + +// EnterInmemory_table_clause is called when production inmemory_table_clause is entered. +func (s *BasePlSqlParserListener) EnterInmemory_table_clause(ctx *Inmemory_table_clauseContext) {} + +// ExitInmemory_table_clause is called when production inmemory_table_clause is exited. +func (s *BasePlSqlParserListener) ExitInmemory_table_clause(ctx *Inmemory_table_clauseContext) {} + +// EnterInmemory_attributes is called when production inmemory_attributes is entered. +func (s *BasePlSqlParserListener) EnterInmemory_attributes(ctx *Inmemory_attributesContext) {} + +// ExitInmemory_attributes is called when production inmemory_attributes is exited. +func (s *BasePlSqlParserListener) ExitInmemory_attributes(ctx *Inmemory_attributesContext) {} + +// EnterInmemory_memcompress is called when production inmemory_memcompress is entered. +func (s *BasePlSqlParserListener) EnterInmemory_memcompress(ctx *Inmemory_memcompressContext) {} + +// ExitInmemory_memcompress is called when production inmemory_memcompress is exited. +func (s *BasePlSqlParserListener) ExitInmemory_memcompress(ctx *Inmemory_memcompressContext) {} + +// EnterInmemory_priority is called when production inmemory_priority is entered. +func (s *BasePlSqlParserListener) EnterInmemory_priority(ctx *Inmemory_priorityContext) {} + +// ExitInmemory_priority is called when production inmemory_priority is exited. +func (s *BasePlSqlParserListener) ExitInmemory_priority(ctx *Inmemory_priorityContext) {} + +// EnterInmemory_distribute is called when production inmemory_distribute is entered. +func (s *BasePlSqlParserListener) EnterInmemory_distribute(ctx *Inmemory_distributeContext) {} + +// ExitInmemory_distribute is called when production inmemory_distribute is exited. +func (s *BasePlSqlParserListener) ExitInmemory_distribute(ctx *Inmemory_distributeContext) {} + +// EnterInmemory_duplicate is called when production inmemory_duplicate is entered. +func (s *BasePlSqlParserListener) EnterInmemory_duplicate(ctx *Inmemory_duplicateContext) {} + +// ExitInmemory_duplicate is called when production inmemory_duplicate is exited. +func (s *BasePlSqlParserListener) ExitInmemory_duplicate(ctx *Inmemory_duplicateContext) {} + +// EnterInmemory_column_clause is called when production inmemory_column_clause is entered. +func (s *BasePlSqlParserListener) EnterInmemory_column_clause(ctx *Inmemory_column_clauseContext) {} + +// ExitInmemory_column_clause is called when production inmemory_column_clause is exited. +func (s *BasePlSqlParserListener) ExitInmemory_column_clause(ctx *Inmemory_column_clauseContext) {} + +// EnterPhysical_attributes_clause is called when production physical_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) { +} + +// ExitPhysical_attributes_clause is called when production physical_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) { +} + +// EnterStorage_clause is called when production storage_clause is entered. +func (s *BasePlSqlParserListener) EnterStorage_clause(ctx *Storage_clauseContext) {} + +// ExitStorage_clause is called when production storage_clause is exited. +func (s *BasePlSqlParserListener) ExitStorage_clause(ctx *Storage_clauseContext) {} + +// EnterDeferred_segment_creation is called when production deferred_segment_creation is entered. +func (s *BasePlSqlParserListener) EnterDeferred_segment_creation(ctx *Deferred_segment_creationContext) { +} + +// ExitDeferred_segment_creation is called when production deferred_segment_creation is exited. +func (s *BasePlSqlParserListener) ExitDeferred_segment_creation(ctx *Deferred_segment_creationContext) { +} + +// EnterSegment_attributes_clause is called when production segment_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterSegment_attributes_clause(ctx *Segment_attributes_clauseContext) { +} + +// ExitSegment_attributes_clause is called when production segment_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitSegment_attributes_clause(ctx *Segment_attributes_clauseContext) { +} + +// EnterPhysical_properties is called when production physical_properties is entered. +func (s *BasePlSqlParserListener) EnterPhysical_properties(ctx *Physical_propertiesContext) {} + +// ExitPhysical_properties is called when production physical_properties is exited. +func (s *BasePlSqlParserListener) ExitPhysical_properties(ctx *Physical_propertiesContext) {} + +// EnterIlm_clause is called when production ilm_clause is entered. +func (s *BasePlSqlParserListener) EnterIlm_clause(ctx *Ilm_clauseContext) {} + +// ExitIlm_clause is called when production ilm_clause is exited. +func (s *BasePlSqlParserListener) ExitIlm_clause(ctx *Ilm_clauseContext) {} + +// EnterIlm_policy_clause is called when production ilm_policy_clause is entered. +func (s *BasePlSqlParserListener) EnterIlm_policy_clause(ctx *Ilm_policy_clauseContext) {} + +// ExitIlm_policy_clause is called when production ilm_policy_clause is exited. +func (s *BasePlSqlParserListener) ExitIlm_policy_clause(ctx *Ilm_policy_clauseContext) {} + +// EnterIlm_compression_policy is called when production ilm_compression_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_compression_policy(ctx *Ilm_compression_policyContext) {} + +// ExitIlm_compression_policy is called when production ilm_compression_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_compression_policy(ctx *Ilm_compression_policyContext) {} + +// EnterIlm_tiering_policy is called when production ilm_tiering_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_tiering_policy(ctx *Ilm_tiering_policyContext) {} + +// ExitIlm_tiering_policy is called when production ilm_tiering_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_tiering_policy(ctx *Ilm_tiering_policyContext) {} + +// EnterIlm_after_on is called when production ilm_after_on is entered. +func (s *BasePlSqlParserListener) EnterIlm_after_on(ctx *Ilm_after_onContext) {} + +// ExitIlm_after_on is called when production ilm_after_on is exited. +func (s *BasePlSqlParserListener) ExitIlm_after_on(ctx *Ilm_after_onContext) {} + +// EnterSegment_group is called when production segment_group is entered. +func (s *BasePlSqlParserListener) EnterSegment_group(ctx *Segment_groupContext) {} + +// ExitSegment_group is called when production segment_group is exited. +func (s *BasePlSqlParserListener) ExitSegment_group(ctx *Segment_groupContext) {} + +// EnterIlm_inmemory_policy is called when production ilm_inmemory_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) {} + +// ExitIlm_inmemory_policy is called when production ilm_inmemory_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) {} + +// EnterIlm_time_period is called when production ilm_time_period is entered. +func (s *BasePlSqlParserListener) EnterIlm_time_period(ctx *Ilm_time_periodContext) {} + +// ExitIlm_time_period is called when production ilm_time_period is exited. +func (s *BasePlSqlParserListener) ExitIlm_time_period(ctx *Ilm_time_periodContext) {} + +// EnterHeap_org_table_clause is called when production heap_org_table_clause is entered. +func (s *BasePlSqlParserListener) EnterHeap_org_table_clause(ctx *Heap_org_table_clauseContext) {} + +// ExitHeap_org_table_clause is called when production heap_org_table_clause is exited. +func (s *BasePlSqlParserListener) ExitHeap_org_table_clause(ctx *Heap_org_table_clauseContext) {} + +// EnterExternal_table_clause is called when production external_table_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_clause(ctx *External_table_clauseContext) {} + +// ExitExternal_table_clause is called when production external_table_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_clause(ctx *External_table_clauseContext) {} + +// EnterAccess_driver_type is called when production access_driver_type is entered. +func (s *BasePlSqlParserListener) EnterAccess_driver_type(ctx *Access_driver_typeContext) {} + +// ExitAccess_driver_type is called when production access_driver_type is exited. +func (s *BasePlSqlParserListener) ExitAccess_driver_type(ctx *Access_driver_typeContext) {} + +// EnterExternal_table_data_props is called when production external_table_data_props is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_data_props(ctx *External_table_data_propsContext) { +} + +// ExitExternal_table_data_props is called when production external_table_data_props is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_data_props(ctx *External_table_data_propsContext) { +} + +// EnterExternal_table_data_format is called when production external_table_data_format is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_data_format(ctx *External_table_data_formatContext) { +} + +// ExitExternal_table_data_format is called when production external_table_data_format is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_data_format(ctx *External_table_data_formatContext) { +} + +// EnterExternal_table_transform is called when production external_table_transform is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_transform(ctx *External_table_transformContext) { +} + +// ExitExternal_table_transform is called when production external_table_transform is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_transform(ctx *External_table_transformContext) { +} + +// EnterExternal_table_field is called when production external_table_field is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_field(ctx *External_table_fieldContext) {} + +// ExitExternal_table_field is called when production external_table_field is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_field(ctx *External_table_fieldContext) {} + +// EnterExternal_table_field_list is called when production external_table_field_list is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_field_list(ctx *External_table_field_listContext) { +} + +// ExitExternal_table_field_list is called when production external_table_field_list is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_field_list(ctx *External_table_field_listContext) { +} + +// EnterExternal_table_fields_clause is called when production external_table_fields_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_fields_clause(ctx *External_table_fields_clauseContext) { +} + +// ExitExternal_table_fields_clause is called when production external_table_fields_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_fields_clause(ctx *External_table_fields_clauseContext) { +} + +// EnterExternal_table_position_clause is called when production external_table_position_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_position_clause(ctx *External_table_position_clauseContext) { +} + +// ExitExternal_table_position_clause is called when production external_table_position_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_position_clause(ctx *External_table_position_clauseContext) { +} + +// EnterExternal_table_datatype_clause is called when production external_table_datatype_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_datatype_clause(ctx *External_table_datatype_clauseContext) { +} + +// ExitExternal_table_datatype_clause is called when production external_table_datatype_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_datatype_clause(ctx *External_table_datatype_clauseContext) { +} + +// EnterExternal_table_delimit_clause is called when production external_table_delimit_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_delimit_clause(ctx *External_table_delimit_clauseContext) { +} + +// ExitExternal_table_delimit_clause is called when production external_table_delimit_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_delimit_clause(ctx *External_table_delimit_clauseContext) { +} + +// EnterExternal_table_trim_clause is called when production external_table_trim_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_trim_clause(ctx *External_table_trim_clauseContext) { +} + +// ExitExternal_table_trim_clause is called when production external_table_trim_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_trim_clause(ctx *External_table_trim_clauseContext) { +} + +// EnterExternal_table_date_format_clause is called when production external_table_date_format_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_date_format_clause(ctx *External_table_date_format_clauseContext) { +} + +// ExitExternal_table_date_format_clause is called when production external_table_date_format_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_date_format_clause(ctx *External_table_date_format_clauseContext) { +} + +// EnterExternal_table_init_clause is called when production external_table_init_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_init_clause(ctx *External_table_init_clauseContext) { +} + +// ExitExternal_table_init_clause is called when production external_table_init_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_init_clause(ctx *External_table_init_clauseContext) { +} + +// EnterExternal_table_condition_clause is called when production external_table_condition_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_condition_clause(ctx *External_table_condition_clauseContext) { +} + +// ExitExternal_table_condition_clause is called when production external_table_condition_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_condition_clause(ctx *External_table_condition_clauseContext) { +} + +// EnterExternal_table_lls_clause is called when production external_table_lls_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_lls_clause(ctx *External_table_lls_clauseContext) { +} + +// ExitExternal_table_lls_clause is called when production external_table_lls_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_lls_clause(ctx *External_table_lls_clauseContext) { +} + +// EnterExternal_table_records is called when production external_table_records is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_records(ctx *External_table_recordsContext) {} + +// ExitExternal_table_records is called when production external_table_records is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_records(ctx *External_table_recordsContext) {} + +// EnterExternal_table_record_options_clause is called when production external_table_record_options_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_record_options_clause(ctx *External_table_record_options_clauseContext) { +} + +// ExitExternal_table_record_options_clause is called when production external_table_record_options_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_record_options_clause(ctx *External_table_record_options_clauseContext) { +} + +// EnterExternal_table_output_files is called when production external_table_output_files is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_output_files(ctx *External_table_output_filesContext) { +} + +// ExitExternal_table_output_files is called when production external_table_output_files is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_output_files(ctx *External_table_output_filesContext) { +} + +// EnterExternal_table_fields is called when production external_table_fields is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_fields(ctx *External_table_fieldsContext) {} + +// ExitExternal_table_fields is called when production external_table_fields is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_fields(ctx *External_table_fieldsContext) {} + +// EnterExternal_table_datapump is called when production external_table_datapump is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_datapump(ctx *External_table_datapumpContext) {} + +// ExitExternal_table_datapump is called when production external_table_datapump is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_datapump(ctx *External_table_datapumpContext) {} + +// EnterExternal_table_hive is called when production external_table_hive is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_hive(ctx *External_table_hiveContext) {} + +// ExitExternal_table_hive is called when production external_table_hive is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_hive(ctx *External_table_hiveContext) {} + +// EnterExternal_table_hive_parameter_map is called when production external_table_hive_parameter_map is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_hive_parameter_map(ctx *External_table_hive_parameter_mapContext) { +} + +// ExitExternal_table_hive_parameter_map is called when production external_table_hive_parameter_map is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_hive_parameter_map(ctx *External_table_hive_parameter_mapContext) { +} + +// EnterExternal_table_hive_parameter_map_entry is called when production external_table_hive_parameter_map_entry is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_hive_parameter_map_entry(ctx *External_table_hive_parameter_map_entryContext) { +} + +// ExitExternal_table_hive_parameter_map_entry is called when production external_table_hive_parameter_map_entry is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_hive_parameter_map_entry(ctx *External_table_hive_parameter_map_entryContext) { +} + +// EnterExternal_table_directory is called when production external_table_directory is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_directory(ctx *External_table_directoryContext) { +} + +// ExitExternal_table_directory is called when production external_table_directory is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_directory(ctx *External_table_directoryContext) { +} + +// EnterRow_movement_clause is called when production row_movement_clause is entered. +func (s *BasePlSqlParserListener) EnterRow_movement_clause(ctx *Row_movement_clauseContext) {} + +// ExitRow_movement_clause is called when production row_movement_clause is exited. +func (s *BasePlSqlParserListener) ExitRow_movement_clause(ctx *Row_movement_clauseContext) {} + +// EnterFlashback_archive_clause is called when production flashback_archive_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_clause(ctx *Flashback_archive_clauseContext) { +} + +// ExitFlashback_archive_clause is called when production flashback_archive_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_clause(ctx *Flashback_archive_clauseContext) { +} + +// EnterLog_grp is called when production log_grp is entered. +func (s *BasePlSqlParserListener) EnterLog_grp(ctx *Log_grpContext) {} + +// ExitLog_grp is called when production log_grp is exited. +func (s *BasePlSqlParserListener) ExitLog_grp(ctx *Log_grpContext) {} + +// EnterSupplemental_table_logging is called when production supplemental_table_logging is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_table_logging(ctx *Supplemental_table_loggingContext) { +} + +// ExitSupplemental_table_logging is called when production supplemental_table_logging is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_table_logging(ctx *Supplemental_table_loggingContext) { +} + +// EnterSupplemental_log_grp_clause is called when production supplemental_log_grp_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) { +} + +// ExitSupplemental_log_grp_clause is called when production supplemental_log_grp_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) { +} + +// EnterSupplemental_id_key_clause is called when production supplemental_id_key_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) { +} + +// ExitSupplemental_id_key_clause is called when production supplemental_id_key_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) { +} + +// EnterAllocate_extent_clause is called when production allocate_extent_clause is entered. +func (s *BasePlSqlParserListener) EnterAllocate_extent_clause(ctx *Allocate_extent_clauseContext) {} + +// ExitAllocate_extent_clause is called when production allocate_extent_clause is exited. +func (s *BasePlSqlParserListener) ExitAllocate_extent_clause(ctx *Allocate_extent_clauseContext) {} + +// EnterDeallocate_unused_clause is called when production deallocate_unused_clause is entered. +func (s *BasePlSqlParserListener) EnterDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) { +} + +// ExitDeallocate_unused_clause is called when production deallocate_unused_clause is exited. +func (s *BasePlSqlParserListener) ExitDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) { +} + +// EnterShrink_clause is called when production shrink_clause is entered. +func (s *BasePlSqlParserListener) EnterShrink_clause(ctx *Shrink_clauseContext) {} + +// ExitShrink_clause is called when production shrink_clause is exited. +func (s *BasePlSqlParserListener) ExitShrink_clause(ctx *Shrink_clauseContext) {} + +// EnterRecords_per_block_clause is called when production records_per_block_clause is entered. +func (s *BasePlSqlParserListener) EnterRecords_per_block_clause(ctx *Records_per_block_clauseContext) { +} + +// ExitRecords_per_block_clause is called when production records_per_block_clause is exited. +func (s *BasePlSqlParserListener) ExitRecords_per_block_clause(ctx *Records_per_block_clauseContext) { +} + +// EnterUpgrade_table_clause is called when production upgrade_table_clause is entered. +func (s *BasePlSqlParserListener) EnterUpgrade_table_clause(ctx *Upgrade_table_clauseContext) {} + +// ExitUpgrade_table_clause is called when production upgrade_table_clause is exited. +func (s *BasePlSqlParserListener) ExitUpgrade_table_clause(ctx *Upgrade_table_clauseContext) {} + +// EnterTruncate_table is called when production truncate_table is entered. +func (s *BasePlSqlParserListener) EnterTruncate_table(ctx *Truncate_tableContext) {} + +// ExitTruncate_table is called when production truncate_table is exited. +func (s *BasePlSqlParserListener) ExitTruncate_table(ctx *Truncate_tableContext) {} + +// EnterDrop_table is called when production drop_table is entered. +func (s *BasePlSqlParserListener) EnterDrop_table(ctx *Drop_tableContext) {} + +// ExitDrop_table is called when production drop_table is exited. +func (s *BasePlSqlParserListener) ExitDrop_table(ctx *Drop_tableContext) {} + +// EnterDrop_tablespace is called when production drop_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDrop_tablespace(ctx *Drop_tablespaceContext) {} + +// ExitDrop_tablespace is called when production drop_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDrop_tablespace(ctx *Drop_tablespaceContext) {} + +// EnterDrop_tablespace_set is called when production drop_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterDrop_tablespace_set(ctx *Drop_tablespace_setContext) {} + +// ExitDrop_tablespace_set is called when production drop_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitDrop_tablespace_set(ctx *Drop_tablespace_setContext) {} + +// EnterIncluding_contents_clause is called when production including_contents_clause is entered. +func (s *BasePlSqlParserListener) EnterIncluding_contents_clause(ctx *Including_contents_clauseContext) { +} + +// ExitIncluding_contents_clause is called when production including_contents_clause is exited. +func (s *BasePlSqlParserListener) ExitIncluding_contents_clause(ctx *Including_contents_clauseContext) { +} + +// EnterDrop_view is called when production drop_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_view(ctx *Drop_viewContext) {} + +// ExitDrop_view is called when production drop_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_view(ctx *Drop_viewContext) {} + +// EnterComment_on_column is called when production comment_on_column is entered. +func (s *BasePlSqlParserListener) EnterComment_on_column(ctx *Comment_on_columnContext) {} + +// ExitComment_on_column is called when production comment_on_column is exited. +func (s *BasePlSqlParserListener) ExitComment_on_column(ctx *Comment_on_columnContext) {} + +// EnterEnable_or_disable is called when production enable_or_disable is entered. +func (s *BasePlSqlParserListener) EnterEnable_or_disable(ctx *Enable_or_disableContext) {} + +// ExitEnable_or_disable is called when production enable_or_disable is exited. +func (s *BasePlSqlParserListener) ExitEnable_or_disable(ctx *Enable_or_disableContext) {} + +// EnterAllow_or_disallow is called when production allow_or_disallow is entered. +func (s *BasePlSqlParserListener) EnterAllow_or_disallow(ctx *Allow_or_disallowContext) {} + +// ExitAllow_or_disallow is called when production allow_or_disallow is exited. +func (s *BasePlSqlParserListener) ExitAllow_or_disallow(ctx *Allow_or_disallowContext) {} + +// EnterAlter_synonym is called when production alter_synonym is entered. +func (s *BasePlSqlParserListener) EnterAlter_synonym(ctx *Alter_synonymContext) {} + +// ExitAlter_synonym is called when production alter_synonym is exited. +func (s *BasePlSqlParserListener) ExitAlter_synonym(ctx *Alter_synonymContext) {} + +// EnterCreate_synonym is called when production create_synonym is entered. +func (s *BasePlSqlParserListener) EnterCreate_synonym(ctx *Create_synonymContext) {} + +// ExitCreate_synonym is called when production create_synonym is exited. +func (s *BasePlSqlParserListener) ExitCreate_synonym(ctx *Create_synonymContext) {} + +// EnterDrop_synonym is called when production drop_synonym is entered. +func (s *BasePlSqlParserListener) EnterDrop_synonym(ctx *Drop_synonymContext) {} + +// ExitDrop_synonym is called when production drop_synonym is exited. +func (s *BasePlSqlParserListener) ExitDrop_synonym(ctx *Drop_synonymContext) {} + +// EnterCreate_spfile is called when production create_spfile is entered. +func (s *BasePlSqlParserListener) EnterCreate_spfile(ctx *Create_spfileContext) {} + +// ExitCreate_spfile is called when production create_spfile is exited. +func (s *BasePlSqlParserListener) ExitCreate_spfile(ctx *Create_spfileContext) {} + +// EnterSpfile_name is called when production spfile_name is entered. +func (s *BasePlSqlParserListener) EnterSpfile_name(ctx *Spfile_nameContext) {} + +// ExitSpfile_name is called when production spfile_name is exited. +func (s *BasePlSqlParserListener) ExitSpfile_name(ctx *Spfile_nameContext) {} + +// EnterPfile_name is called when production pfile_name is entered. +func (s *BasePlSqlParserListener) EnterPfile_name(ctx *Pfile_nameContext) {} + +// ExitPfile_name is called when production pfile_name is exited. +func (s *BasePlSqlParserListener) ExitPfile_name(ctx *Pfile_nameContext) {} + +// EnterComment_on_table is called when production comment_on_table is entered. +func (s *BasePlSqlParserListener) EnterComment_on_table(ctx *Comment_on_tableContext) {} + +// ExitComment_on_table is called when production comment_on_table is exited. +func (s *BasePlSqlParserListener) ExitComment_on_table(ctx *Comment_on_tableContext) {} + +// EnterComment_on_materialized is called when production comment_on_materialized is entered. +func (s *BasePlSqlParserListener) EnterComment_on_materialized(ctx *Comment_on_materializedContext) {} + +// ExitComment_on_materialized is called when production comment_on_materialized is exited. +func (s *BasePlSqlParserListener) ExitComment_on_materialized(ctx *Comment_on_materializedContext) {} + +// EnterAlter_analytic_view is called when production alter_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_analytic_view(ctx *Alter_analytic_viewContext) {} + +// ExitAlter_analytic_view is called when production alter_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_analytic_view(ctx *Alter_analytic_viewContext) {} + +// EnterAlter_add_cache_clause is called when production alter_add_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) {} + +// ExitAlter_add_cache_clause is called when production alter_add_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) {} + +// EnterLevels_item is called when production levels_item is entered. +func (s *BasePlSqlParserListener) EnterLevels_item(ctx *Levels_itemContext) {} + +// ExitLevels_item is called when production levels_item is exited. +func (s *BasePlSqlParserListener) ExitLevels_item(ctx *Levels_itemContext) {} + +// EnterMeasure_list is called when production measure_list is entered. +func (s *BasePlSqlParserListener) EnterMeasure_list(ctx *Measure_listContext) {} + +// ExitMeasure_list is called when production measure_list is exited. +func (s *BasePlSqlParserListener) ExitMeasure_list(ctx *Measure_listContext) {} + +// EnterAlter_drop_cache_clause is called when production alter_drop_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) {} + +// ExitAlter_drop_cache_clause is called when production alter_drop_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) {} + +// EnterAlter_attribute_dimension is called when production alter_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) { +} + +// ExitAlter_attribute_dimension is called when production alter_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) { +} + +// EnterAlter_audit_policy is called when production alter_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterAlter_audit_policy(ctx *Alter_audit_policyContext) {} + +// ExitAlter_audit_policy is called when production alter_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitAlter_audit_policy(ctx *Alter_audit_policyContext) {} + +// EnterAlter_cluster is called when production alter_cluster is entered. +func (s *BasePlSqlParserListener) EnterAlter_cluster(ctx *Alter_clusterContext) {} + +// ExitAlter_cluster is called when production alter_cluster is exited. +func (s *BasePlSqlParserListener) ExitAlter_cluster(ctx *Alter_clusterContext) {} + +// EnterDrop_analytic_view is called when production drop_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_analytic_view(ctx *Drop_analytic_viewContext) {} + +// ExitDrop_analytic_view is called when production drop_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_analytic_view(ctx *Drop_analytic_viewContext) {} + +// EnterDrop_attribute_dimension is called when production drop_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) { +} + +// ExitDrop_attribute_dimension is called when production drop_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) { +} + +// EnterDrop_audit_policy is called when production drop_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterDrop_audit_policy(ctx *Drop_audit_policyContext) {} + +// ExitDrop_audit_policy is called when production drop_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitDrop_audit_policy(ctx *Drop_audit_policyContext) {} + +// EnterDrop_flashback_archive is called when production drop_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterDrop_flashback_archive(ctx *Drop_flashback_archiveContext) {} + +// ExitDrop_flashback_archive is called when production drop_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitDrop_flashback_archive(ctx *Drop_flashback_archiveContext) {} + +// EnterDrop_cluster is called when production drop_cluster is entered. +func (s *BasePlSqlParserListener) EnterDrop_cluster(ctx *Drop_clusterContext) {} + +// ExitDrop_cluster is called when production drop_cluster is exited. +func (s *BasePlSqlParserListener) ExitDrop_cluster(ctx *Drop_clusterContext) {} + +// EnterDrop_context is called when production drop_context is entered. +func (s *BasePlSqlParserListener) EnterDrop_context(ctx *Drop_contextContext) {} + +// ExitDrop_context is called when production drop_context is exited. +func (s *BasePlSqlParserListener) ExitDrop_context(ctx *Drop_contextContext) {} + +// EnterDrop_directory is called when production drop_directory is entered. +func (s *BasePlSqlParserListener) EnterDrop_directory(ctx *Drop_directoryContext) {} + +// ExitDrop_directory is called when production drop_directory is exited. +func (s *BasePlSqlParserListener) ExitDrop_directory(ctx *Drop_directoryContext) {} + +// EnterDrop_diskgroup is called when production drop_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterDrop_diskgroup(ctx *Drop_diskgroupContext) {} + +// ExitDrop_diskgroup is called when production drop_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitDrop_diskgroup(ctx *Drop_diskgroupContext) {} + +// EnterDrop_edition is called when production drop_edition is entered. +func (s *BasePlSqlParserListener) EnterDrop_edition(ctx *Drop_editionContext) {} + +// ExitDrop_edition is called when production drop_edition is exited. +func (s *BasePlSqlParserListener) ExitDrop_edition(ctx *Drop_editionContext) {} + +// EnterTruncate_cluster is called when production truncate_cluster is entered. +func (s *BasePlSqlParserListener) EnterTruncate_cluster(ctx *Truncate_clusterContext) {} + +// ExitTruncate_cluster is called when production truncate_cluster is exited. +func (s *BasePlSqlParserListener) ExitTruncate_cluster(ctx *Truncate_clusterContext) {} + +// EnterCache_or_nocache is called when production cache_or_nocache is entered. +func (s *BasePlSqlParserListener) EnterCache_or_nocache(ctx *Cache_or_nocacheContext) {} + +// ExitCache_or_nocache is called when production cache_or_nocache is exited. +func (s *BasePlSqlParserListener) ExitCache_or_nocache(ctx *Cache_or_nocacheContext) {} + +// EnterDatabase_name is called when production database_name is entered. +func (s *BasePlSqlParserListener) EnterDatabase_name(ctx *Database_nameContext) {} + +// ExitDatabase_name is called when production database_name is exited. +func (s *BasePlSqlParserListener) ExitDatabase_name(ctx *Database_nameContext) {} + +// EnterAlter_database is called when production alter_database is entered. +func (s *BasePlSqlParserListener) EnterAlter_database(ctx *Alter_databaseContext) {} + +// ExitAlter_database is called when production alter_database is exited. +func (s *BasePlSqlParserListener) ExitAlter_database(ctx *Alter_databaseContext) {} + +// EnterDatabase_clause is called when production database_clause is entered. +func (s *BasePlSqlParserListener) EnterDatabase_clause(ctx *Database_clauseContext) {} + +// ExitDatabase_clause is called when production database_clause is exited. +func (s *BasePlSqlParserListener) ExitDatabase_clause(ctx *Database_clauseContext) {} + +// EnterStartup_clauses is called when production startup_clauses is entered. +func (s *BasePlSqlParserListener) EnterStartup_clauses(ctx *Startup_clausesContext) {} + +// ExitStartup_clauses is called when production startup_clauses is exited. +func (s *BasePlSqlParserListener) ExitStartup_clauses(ctx *Startup_clausesContext) {} + +// EnterResetlogs_or_noresetlogs is called when production resetlogs_or_noresetlogs is entered. +func (s *BasePlSqlParserListener) EnterResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) { +} + +// ExitResetlogs_or_noresetlogs is called when production resetlogs_or_noresetlogs is exited. +func (s *BasePlSqlParserListener) ExitResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) { +} + +// EnterUpgrade_or_downgrade is called when production upgrade_or_downgrade is entered. +func (s *BasePlSqlParserListener) EnterUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) {} + +// ExitUpgrade_or_downgrade is called when production upgrade_or_downgrade is exited. +func (s *BasePlSqlParserListener) ExitUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) {} + +// EnterRecovery_clauses is called when production recovery_clauses is entered. +func (s *BasePlSqlParserListener) EnterRecovery_clauses(ctx *Recovery_clausesContext) {} + +// ExitRecovery_clauses is called when production recovery_clauses is exited. +func (s *BasePlSqlParserListener) ExitRecovery_clauses(ctx *Recovery_clausesContext) {} + +// EnterBegin_or_end is called when production begin_or_end is entered. +func (s *BasePlSqlParserListener) EnterBegin_or_end(ctx *Begin_or_endContext) {} + +// ExitBegin_or_end is called when production begin_or_end is exited. +func (s *BasePlSqlParserListener) ExitBegin_or_end(ctx *Begin_or_endContext) {} + +// EnterGeneral_recovery is called when production general_recovery is entered. +func (s *BasePlSqlParserListener) EnterGeneral_recovery(ctx *General_recoveryContext) {} + +// ExitGeneral_recovery is called when production general_recovery is exited. +func (s *BasePlSqlParserListener) ExitGeneral_recovery(ctx *General_recoveryContext) {} + +// EnterFull_database_recovery is called when production full_database_recovery is entered. +func (s *BasePlSqlParserListener) EnterFull_database_recovery(ctx *Full_database_recoveryContext) {} + +// ExitFull_database_recovery is called when production full_database_recovery is exited. +func (s *BasePlSqlParserListener) ExitFull_database_recovery(ctx *Full_database_recoveryContext) {} + +// EnterPartial_database_recovery is called when production partial_database_recovery is entered. +func (s *BasePlSqlParserListener) EnterPartial_database_recovery(ctx *Partial_database_recoveryContext) { +} + +// ExitPartial_database_recovery is called when production partial_database_recovery is exited. +func (s *BasePlSqlParserListener) ExitPartial_database_recovery(ctx *Partial_database_recoveryContext) { +} + +// EnterPartial_database_recovery_10g is called when production partial_database_recovery_10g is entered. +func (s *BasePlSqlParserListener) EnterPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) { +} + +// ExitPartial_database_recovery_10g is called when production partial_database_recovery_10g is exited. +func (s *BasePlSqlParserListener) ExitPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) { +} + +// EnterManaged_standby_recovery is called when production managed_standby_recovery is entered. +func (s *BasePlSqlParserListener) EnterManaged_standby_recovery(ctx *Managed_standby_recoveryContext) { +} + +// ExitManaged_standby_recovery is called when production managed_standby_recovery is exited. +func (s *BasePlSqlParserListener) ExitManaged_standby_recovery(ctx *Managed_standby_recoveryContext) { +} + +// EnterDb_name is called when production db_name is entered. +func (s *BasePlSqlParserListener) EnterDb_name(ctx *Db_nameContext) {} + +// ExitDb_name is called when production db_name is exited. +func (s *BasePlSqlParserListener) ExitDb_name(ctx *Db_nameContext) {} + +// EnterDatabase_file_clauses is called when production database_file_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatabase_file_clauses(ctx *Database_file_clausesContext) {} + +// ExitDatabase_file_clauses is called when production database_file_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatabase_file_clauses(ctx *Database_file_clausesContext) {} + +// EnterCreate_datafile_clause is called when production create_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterCreate_datafile_clause(ctx *Create_datafile_clauseContext) {} + +// ExitCreate_datafile_clause is called when production create_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitCreate_datafile_clause(ctx *Create_datafile_clauseContext) {} + +// EnterAlter_datafile_clause is called when production alter_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_datafile_clause(ctx *Alter_datafile_clauseContext) {} + +// ExitAlter_datafile_clause is called when production alter_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_datafile_clause(ctx *Alter_datafile_clauseContext) {} + +// EnterAlter_tempfile_clause is called when production alter_tempfile_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) {} + +// ExitAlter_tempfile_clause is called when production alter_tempfile_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) {} + +// EnterMove_datafile_clause is called when production move_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_datafile_clause(ctx *Move_datafile_clauseContext) {} + +// ExitMove_datafile_clause is called when production move_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_datafile_clause(ctx *Move_datafile_clauseContext) {} + +// EnterLogfile_clauses is called when production logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterLogfile_clauses(ctx *Logfile_clausesContext) {} + +// ExitLogfile_clauses is called when production logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitLogfile_clauses(ctx *Logfile_clausesContext) {} + +// EnterAdd_logfile_clauses is called when production add_logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterAdd_logfile_clauses(ctx *Add_logfile_clausesContext) {} + +// ExitAdd_logfile_clauses is called when production add_logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitAdd_logfile_clauses(ctx *Add_logfile_clausesContext) {} + +// EnterGroup_redo_logfile is called when production group_redo_logfile is entered. +func (s *BasePlSqlParserListener) EnterGroup_redo_logfile(ctx *Group_redo_logfileContext) {} + +// ExitGroup_redo_logfile is called when production group_redo_logfile is exited. +func (s *BasePlSqlParserListener) ExitGroup_redo_logfile(ctx *Group_redo_logfileContext) {} + +// EnterDrop_logfile_clauses is called when production drop_logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) {} + +// ExitDrop_logfile_clauses is called when production drop_logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) {} + +// EnterSwitch_logfile_clause is called when production switch_logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) {} + +// ExitSwitch_logfile_clause is called when production switch_logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) {} + +// EnterSupplemental_db_logging is called when production supplemental_db_logging is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_db_logging(ctx *Supplemental_db_loggingContext) {} + +// ExitSupplemental_db_logging is called when production supplemental_db_logging is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_db_logging(ctx *Supplemental_db_loggingContext) {} + +// EnterAdd_or_drop is called when production add_or_drop is entered. +func (s *BasePlSqlParserListener) EnterAdd_or_drop(ctx *Add_or_dropContext) {} + +// ExitAdd_or_drop is called when production add_or_drop is exited. +func (s *BasePlSqlParserListener) ExitAdd_or_drop(ctx *Add_or_dropContext) {} + +// EnterSupplemental_plsql_clause is called when production supplemental_plsql_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) { +} + +// ExitSupplemental_plsql_clause is called when production supplemental_plsql_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) { +} + +// EnterLogfile_descriptor is called when production logfile_descriptor is entered. +func (s *BasePlSqlParserListener) EnterLogfile_descriptor(ctx *Logfile_descriptorContext) {} + +// ExitLogfile_descriptor is called when production logfile_descriptor is exited. +func (s *BasePlSqlParserListener) ExitLogfile_descriptor(ctx *Logfile_descriptorContext) {} + +// EnterControlfile_clauses is called when production controlfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterControlfile_clauses(ctx *Controlfile_clausesContext) {} + +// ExitControlfile_clauses is called when production controlfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitControlfile_clauses(ctx *Controlfile_clausesContext) {} + +// EnterTrace_file_clause is called when production trace_file_clause is entered. +func (s *BasePlSqlParserListener) EnterTrace_file_clause(ctx *Trace_file_clauseContext) {} + +// ExitTrace_file_clause is called when production trace_file_clause is exited. +func (s *BasePlSqlParserListener) ExitTrace_file_clause(ctx *Trace_file_clauseContext) {} + +// EnterStandby_database_clauses is called when production standby_database_clauses is entered. +func (s *BasePlSqlParserListener) EnterStandby_database_clauses(ctx *Standby_database_clausesContext) { +} + +// ExitStandby_database_clauses is called when production standby_database_clauses is exited. +func (s *BasePlSqlParserListener) ExitStandby_database_clauses(ctx *Standby_database_clausesContext) { +} + +// EnterActivate_standby_db_clause is called when production activate_standby_db_clause is entered. +func (s *BasePlSqlParserListener) EnterActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) { +} + +// ExitActivate_standby_db_clause is called when production activate_standby_db_clause is exited. +func (s *BasePlSqlParserListener) ExitActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) { +} + +// EnterMaximize_standby_db_clause is called when production maximize_standby_db_clause is entered. +func (s *BasePlSqlParserListener) EnterMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) { +} + +// ExitMaximize_standby_db_clause is called when production maximize_standby_db_clause is exited. +func (s *BasePlSqlParserListener) ExitMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) { +} + +// EnterRegister_logfile_clause is called when production register_logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterRegister_logfile_clause(ctx *Register_logfile_clauseContext) {} + +// ExitRegister_logfile_clause is called when production register_logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitRegister_logfile_clause(ctx *Register_logfile_clauseContext) {} + +// EnterCommit_switchover_clause is called when production commit_switchover_clause is entered. +func (s *BasePlSqlParserListener) EnterCommit_switchover_clause(ctx *Commit_switchover_clauseContext) { +} + +// ExitCommit_switchover_clause is called when production commit_switchover_clause is exited. +func (s *BasePlSqlParserListener) ExitCommit_switchover_clause(ctx *Commit_switchover_clauseContext) { +} + +// EnterStart_standby_clause is called when production start_standby_clause is entered. +func (s *BasePlSqlParserListener) EnterStart_standby_clause(ctx *Start_standby_clauseContext) {} + +// ExitStart_standby_clause is called when production start_standby_clause is exited. +func (s *BasePlSqlParserListener) ExitStart_standby_clause(ctx *Start_standby_clauseContext) {} + +// EnterStop_standby_clause is called when production stop_standby_clause is entered. +func (s *BasePlSqlParserListener) EnterStop_standby_clause(ctx *Stop_standby_clauseContext) {} + +// ExitStop_standby_clause is called when production stop_standby_clause is exited. +func (s *BasePlSqlParserListener) ExitStop_standby_clause(ctx *Stop_standby_clauseContext) {} + +// EnterConvert_database_clause is called when production convert_database_clause is entered. +func (s *BasePlSqlParserListener) EnterConvert_database_clause(ctx *Convert_database_clauseContext) {} + +// ExitConvert_database_clause is called when production convert_database_clause is exited. +func (s *BasePlSqlParserListener) ExitConvert_database_clause(ctx *Convert_database_clauseContext) {} + +// EnterDefault_settings_clause is called when production default_settings_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_settings_clause(ctx *Default_settings_clauseContext) {} + +// ExitDefault_settings_clause is called when production default_settings_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_settings_clause(ctx *Default_settings_clauseContext) {} + +// EnterSet_time_zone_clause is called when production set_time_zone_clause is entered. +func (s *BasePlSqlParserListener) EnterSet_time_zone_clause(ctx *Set_time_zone_clauseContext) {} + +// ExitSet_time_zone_clause is called when production set_time_zone_clause is exited. +func (s *BasePlSqlParserListener) ExitSet_time_zone_clause(ctx *Set_time_zone_clauseContext) {} + +// EnterInstance_clauses is called when production instance_clauses is entered. +func (s *BasePlSqlParserListener) EnterInstance_clauses(ctx *Instance_clausesContext) {} + +// ExitInstance_clauses is called when production instance_clauses is exited. +func (s *BasePlSqlParserListener) ExitInstance_clauses(ctx *Instance_clausesContext) {} + +// EnterSecurity_clause is called when production security_clause is entered. +func (s *BasePlSqlParserListener) EnterSecurity_clause(ctx *Security_clauseContext) {} + +// ExitSecurity_clause is called when production security_clause is exited. +func (s *BasePlSqlParserListener) ExitSecurity_clause(ctx *Security_clauseContext) {} + +// EnterDomain is called when production domain is entered. +func (s *BasePlSqlParserListener) EnterDomain(ctx *DomainContext) {} + +// ExitDomain is called when production domain is exited. +func (s *BasePlSqlParserListener) ExitDomain(ctx *DomainContext) {} + +// EnterDatabase is called when production database is entered. +func (s *BasePlSqlParserListener) EnterDatabase(ctx *DatabaseContext) {} + +// ExitDatabase is called when production database is exited. +func (s *BasePlSqlParserListener) ExitDatabase(ctx *DatabaseContext) {} + +// EnterEdition_name is called when production edition_name is entered. +func (s *BasePlSqlParserListener) EnterEdition_name(ctx *Edition_nameContext) {} + +// ExitEdition_name is called when production edition_name is exited. +func (s *BasePlSqlParserListener) ExitEdition_name(ctx *Edition_nameContext) {} + +// EnterFilenumber is called when production filenumber is entered. +func (s *BasePlSqlParserListener) EnterFilenumber(ctx *FilenumberContext) {} + +// ExitFilenumber is called when production filenumber is exited. +func (s *BasePlSqlParserListener) ExitFilenumber(ctx *FilenumberContext) {} + +// EnterFilename is called when production filename is entered. +func (s *BasePlSqlParserListener) EnterFilename(ctx *FilenameContext) {} + +// ExitFilename is called when production filename is exited. +func (s *BasePlSqlParserListener) ExitFilename(ctx *FilenameContext) {} + +// EnterPrepare_clause is called when production prepare_clause is entered. +func (s *BasePlSqlParserListener) EnterPrepare_clause(ctx *Prepare_clauseContext) {} + +// ExitPrepare_clause is called when production prepare_clause is exited. +func (s *BasePlSqlParserListener) ExitPrepare_clause(ctx *Prepare_clauseContext) {} + +// EnterDrop_mirror_clause is called when production drop_mirror_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_mirror_clause(ctx *Drop_mirror_clauseContext) {} + +// ExitDrop_mirror_clause is called when production drop_mirror_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_mirror_clause(ctx *Drop_mirror_clauseContext) {} + +// EnterLost_write_protection is called when production lost_write_protection is entered. +func (s *BasePlSqlParserListener) EnterLost_write_protection(ctx *Lost_write_protectionContext) {} + +// ExitLost_write_protection is called when production lost_write_protection is exited. +func (s *BasePlSqlParserListener) ExitLost_write_protection(ctx *Lost_write_protectionContext) {} + +// EnterCdb_fleet_clauses is called when production cdb_fleet_clauses is entered. +func (s *BasePlSqlParserListener) EnterCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) {} + +// ExitCdb_fleet_clauses is called when production cdb_fleet_clauses is exited. +func (s *BasePlSqlParserListener) ExitCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) {} + +// EnterLead_cdb_clause is called when production lead_cdb_clause is entered. +func (s *BasePlSqlParserListener) EnterLead_cdb_clause(ctx *Lead_cdb_clauseContext) {} + +// ExitLead_cdb_clause is called when production lead_cdb_clause is exited. +func (s *BasePlSqlParserListener) ExitLead_cdb_clause(ctx *Lead_cdb_clauseContext) {} + +// EnterLead_cdb_uri_clause is called when production lead_cdb_uri_clause is entered. +func (s *BasePlSqlParserListener) EnterLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) {} + +// ExitLead_cdb_uri_clause is called when production lead_cdb_uri_clause is exited. +func (s *BasePlSqlParserListener) ExitLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) {} + +// EnterProperty_clauses is called when production property_clauses is entered. +func (s *BasePlSqlParserListener) EnterProperty_clauses(ctx *Property_clausesContext) {} + +// ExitProperty_clauses is called when production property_clauses is exited. +func (s *BasePlSqlParserListener) ExitProperty_clauses(ctx *Property_clausesContext) {} + +// EnterReplay_upgrade_clauses is called when production replay_upgrade_clauses is entered. +func (s *BasePlSqlParserListener) EnterReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) {} + +// ExitReplay_upgrade_clauses is called when production replay_upgrade_clauses is exited. +func (s *BasePlSqlParserListener) ExitReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) {} + +// EnterAlter_database_link is called when production alter_database_link is entered. +func (s *BasePlSqlParserListener) EnterAlter_database_link(ctx *Alter_database_linkContext) {} + +// ExitAlter_database_link is called when production alter_database_link is exited. +func (s *BasePlSqlParserListener) ExitAlter_database_link(ctx *Alter_database_linkContext) {} + +// EnterPassword_value is called when production password_value is entered. +func (s *BasePlSqlParserListener) EnterPassword_value(ctx *Password_valueContext) {} + +// ExitPassword_value is called when production password_value is exited. +func (s *BasePlSqlParserListener) ExitPassword_value(ctx *Password_valueContext) {} + +// EnterLink_authentication is called when production link_authentication is entered. +func (s *BasePlSqlParserListener) EnterLink_authentication(ctx *Link_authenticationContext) {} + +// ExitLink_authentication is called when production link_authentication is exited. +func (s *BasePlSqlParserListener) ExitLink_authentication(ctx *Link_authenticationContext) {} + +// EnterCreate_schema is called when production create_schema is entered. +func (s *BasePlSqlParserListener) EnterCreate_schema(ctx *Create_schemaContext) {} + +// ExitCreate_schema is called when production create_schema is exited. +func (s *BasePlSqlParserListener) ExitCreate_schema(ctx *Create_schemaContext) {} + +// EnterCreate_database is called when production create_database is entered. +func (s *BasePlSqlParserListener) EnterCreate_database(ctx *Create_databaseContext) {} + +// ExitCreate_database is called when production create_database is exited. +func (s *BasePlSqlParserListener) ExitCreate_database(ctx *Create_databaseContext) {} + +// EnterDatabase_logging_clauses is called when production database_logging_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatabase_logging_clauses(ctx *Database_logging_clausesContext) { +} + +// ExitDatabase_logging_clauses is called when production database_logging_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatabase_logging_clauses(ctx *Database_logging_clausesContext) { +} + +// EnterDatabase_logging_sub_clause is called when production database_logging_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) { +} + +// ExitDatabase_logging_sub_clause is called when production database_logging_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) { +} + +// EnterTablespace_clauses is called when production tablespace_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_clauses(ctx *Tablespace_clausesContext) {} + +// ExitTablespace_clauses is called when production tablespace_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_clauses(ctx *Tablespace_clausesContext) {} + +// EnterEnable_pluggable_database is called when production enable_pluggable_database is entered. +func (s *BasePlSqlParserListener) EnterEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) { +} + +// ExitEnable_pluggable_database is called when production enable_pluggable_database is exited. +func (s *BasePlSqlParserListener) ExitEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) { +} + +// EnterFile_name_convert is called when production file_name_convert is entered. +func (s *BasePlSqlParserListener) EnterFile_name_convert(ctx *File_name_convertContext) {} + +// ExitFile_name_convert is called when production file_name_convert is exited. +func (s *BasePlSqlParserListener) ExitFile_name_convert(ctx *File_name_convertContext) {} + +// EnterFilename_convert_sub_clause is called when production filename_convert_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) { +} + +// ExitFilename_convert_sub_clause is called when production filename_convert_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) { +} + +// EnterTablespace_datafile_clauses is called when production tablespace_datafile_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) { +} + +// ExitTablespace_datafile_clauses is called when production tablespace_datafile_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) { +} + +// EnterUndo_mode_clause is called when production undo_mode_clause is entered. +func (s *BasePlSqlParserListener) EnterUndo_mode_clause(ctx *Undo_mode_clauseContext) {} + +// ExitUndo_mode_clause is called when production undo_mode_clause is exited. +func (s *BasePlSqlParserListener) ExitUndo_mode_clause(ctx *Undo_mode_clauseContext) {} + +// EnterDefault_tablespace is called when production default_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDefault_tablespace(ctx *Default_tablespaceContext) {} + +// ExitDefault_tablespace is called when production default_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDefault_tablespace(ctx *Default_tablespaceContext) {} + +// EnterDefault_temp_tablespace is called when production default_temp_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) {} + +// ExitDefault_temp_tablespace is called when production default_temp_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) {} + +// EnterUndo_tablespace is called when production undo_tablespace is entered. +func (s *BasePlSqlParserListener) EnterUndo_tablespace(ctx *Undo_tablespaceContext) {} + +// ExitUndo_tablespace is called when production undo_tablespace is exited. +func (s *BasePlSqlParserListener) ExitUndo_tablespace(ctx *Undo_tablespaceContext) {} + +// EnterDrop_database is called when production drop_database is entered. +func (s *BasePlSqlParserListener) EnterDrop_database(ctx *Drop_databaseContext) {} + +// ExitDrop_database is called when production drop_database is exited. +func (s *BasePlSqlParserListener) ExitDrop_database(ctx *Drop_databaseContext) {} + +// EnterCreate_database_link is called when production create_database_link is entered. +func (s *BasePlSqlParserListener) EnterCreate_database_link(ctx *Create_database_linkContext) {} + +// ExitCreate_database_link is called when production create_database_link is exited. +func (s *BasePlSqlParserListener) ExitCreate_database_link(ctx *Create_database_linkContext) {} + +// EnterDrop_database_link is called when production drop_database_link is entered. +func (s *BasePlSqlParserListener) EnterDrop_database_link(ctx *Drop_database_linkContext) {} + +// ExitDrop_database_link is called when production drop_database_link is exited. +func (s *BasePlSqlParserListener) ExitDrop_database_link(ctx *Drop_database_linkContext) {} + +// EnterAlter_tablespace_set is called when production alter_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_set(ctx *Alter_tablespace_setContext) {} + +// ExitAlter_tablespace_set is called when production alter_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_set(ctx *Alter_tablespace_setContext) {} + +// EnterAlter_tablespace_attrs is called when production alter_tablespace_attrs is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) {} + +// ExitAlter_tablespace_attrs is called when production alter_tablespace_attrs is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) {} + +// EnterAlter_tablespace_encryption is called when production alter_tablespace_encryption is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) { +} + +// ExitAlter_tablespace_encryption is called when production alter_tablespace_encryption is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) { +} + +// EnterTs_file_name_convert is called when production ts_file_name_convert is entered. +func (s *BasePlSqlParserListener) EnterTs_file_name_convert(ctx *Ts_file_name_convertContext) {} + +// ExitTs_file_name_convert is called when production ts_file_name_convert is exited. +func (s *BasePlSqlParserListener) ExitTs_file_name_convert(ctx *Ts_file_name_convertContext) {} + +// EnterAlter_role is called when production alter_role is entered. +func (s *BasePlSqlParserListener) EnterAlter_role(ctx *Alter_roleContext) {} + +// ExitAlter_role is called when production alter_role is exited. +func (s *BasePlSqlParserListener) ExitAlter_role(ctx *Alter_roleContext) {} + +// EnterRole_identified_clause is called when production role_identified_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_identified_clause(ctx *Role_identified_clauseContext) {} + +// ExitRole_identified_clause is called when production role_identified_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_identified_clause(ctx *Role_identified_clauseContext) {} + +// EnterAlter_table is called when production alter_table is entered. +func (s *BasePlSqlParserListener) EnterAlter_table(ctx *Alter_tableContext) {} + +// ExitAlter_table is called when production alter_table is exited. +func (s *BasePlSqlParserListener) ExitAlter_table(ctx *Alter_tableContext) {} + +// EnterMemoptimize_read_write_clause is called when production memoptimize_read_write_clause is entered. +func (s *BasePlSqlParserListener) EnterMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) { +} + +// ExitMemoptimize_read_write_clause is called when production memoptimize_read_write_clause is exited. +func (s *BasePlSqlParserListener) ExitMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) { +} + +// EnterAlter_table_properties is called when production alter_table_properties is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_properties(ctx *Alter_table_propertiesContext) {} + +// ExitAlter_table_properties is called when production alter_table_properties is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_properties(ctx *Alter_table_propertiesContext) {} + +// EnterAlter_table_partitioning is called when production alter_table_partitioning is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_partitioning(ctx *Alter_table_partitioningContext) { +} + +// ExitAlter_table_partitioning is called when production alter_table_partitioning is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_partitioning(ctx *Alter_table_partitioningContext) { +} + +// EnterAdd_table_partition is called when production add_table_partition is entered. +func (s *BasePlSqlParserListener) EnterAdd_table_partition(ctx *Add_table_partitionContext) {} + +// ExitAdd_table_partition is called when production add_table_partition is exited. +func (s *BasePlSqlParserListener) ExitAdd_table_partition(ctx *Add_table_partitionContext) {} + +// EnterDrop_table_partition is called when production drop_table_partition is entered. +func (s *BasePlSqlParserListener) EnterDrop_table_partition(ctx *Drop_table_partitionContext) {} + +// ExitDrop_table_partition is called when production drop_table_partition is exited. +func (s *BasePlSqlParserListener) ExitDrop_table_partition(ctx *Drop_table_partitionContext) {} + +// EnterMerge_table_partition is called when production merge_table_partition is entered. +func (s *BasePlSqlParserListener) EnterMerge_table_partition(ctx *Merge_table_partitionContext) {} + +// ExitMerge_table_partition is called when production merge_table_partition is exited. +func (s *BasePlSqlParserListener) ExitMerge_table_partition(ctx *Merge_table_partitionContext) {} + +// EnterModify_table_partition is called when production modify_table_partition is entered. +func (s *BasePlSqlParserListener) EnterModify_table_partition(ctx *Modify_table_partitionContext) {} + +// ExitModify_table_partition is called when production modify_table_partition is exited. +func (s *BasePlSqlParserListener) ExitModify_table_partition(ctx *Modify_table_partitionContext) {} + +// EnterSplit_table_partition is called when production split_table_partition is entered. +func (s *BasePlSqlParserListener) EnterSplit_table_partition(ctx *Split_table_partitionContext) {} + +// ExitSplit_table_partition is called when production split_table_partition is exited. +func (s *BasePlSqlParserListener) ExitSplit_table_partition(ctx *Split_table_partitionContext) {} + +// EnterTruncate_table_partition is called when production truncate_table_partition is entered. +func (s *BasePlSqlParserListener) EnterTruncate_table_partition(ctx *Truncate_table_partitionContext) { +} + +// ExitTruncate_table_partition is called when production truncate_table_partition is exited. +func (s *BasePlSqlParserListener) ExitTruncate_table_partition(ctx *Truncate_table_partitionContext) { +} + +// EnterExchange_table_partition is called when production exchange_table_partition is entered. +func (s *BasePlSqlParserListener) EnterExchange_table_partition(ctx *Exchange_table_partitionContext) { +} + +// ExitExchange_table_partition is called when production exchange_table_partition is exited. +func (s *BasePlSqlParserListener) ExitExchange_table_partition(ctx *Exchange_table_partitionContext) { +} + +// EnterCoalesce_table_partition is called when production coalesce_table_partition is entered. +func (s *BasePlSqlParserListener) EnterCoalesce_table_partition(ctx *Coalesce_table_partitionContext) { +} + +// ExitCoalesce_table_partition is called when production coalesce_table_partition is exited. +func (s *BasePlSqlParserListener) ExitCoalesce_table_partition(ctx *Coalesce_table_partitionContext) { +} + +// EnterAlter_interval_partition is called when production alter_interval_partition is entered. +func (s *BasePlSqlParserListener) EnterAlter_interval_partition(ctx *Alter_interval_partitionContext) { +} + +// ExitAlter_interval_partition is called when production alter_interval_partition is exited. +func (s *BasePlSqlParserListener) ExitAlter_interval_partition(ctx *Alter_interval_partitionContext) { +} + +// EnterMove_table_partition is called when production move_table_partition is entered. +func (s *BasePlSqlParserListener) EnterMove_table_partition(ctx *Move_table_partitionContext) {} + +// ExitMove_table_partition is called when production move_table_partition is exited. +func (s *BasePlSqlParserListener) ExitMove_table_partition(ctx *Move_table_partitionContext) {} + +// EnterFilter_condition is called when production filter_condition is entered. +func (s *BasePlSqlParserListener) EnterFilter_condition(ctx *Filter_conditionContext) {} + +// ExitFilter_condition is called when production filter_condition is exited. +func (s *BasePlSqlParserListener) ExitFilter_condition(ctx *Filter_conditionContext) {} + +// EnterRename_table_partition is called when production rename_table_partition is entered. +func (s *BasePlSqlParserListener) EnterRename_table_partition(ctx *Rename_table_partitionContext) {} + +// ExitRename_table_partition is called when production rename_table_partition is exited. +func (s *BasePlSqlParserListener) ExitRename_table_partition(ctx *Rename_table_partitionContext) {} + +// EnterPartition_extended_names is called when production partition_extended_names is entered. +func (s *BasePlSqlParserListener) EnterPartition_extended_names(ctx *Partition_extended_namesContext) { +} + +// ExitPartition_extended_names is called when production partition_extended_names is exited. +func (s *BasePlSqlParserListener) ExitPartition_extended_names(ctx *Partition_extended_namesContext) { +} + +// EnterSubpartition_extended_names is called when production subpartition_extended_names is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_extended_names(ctx *Subpartition_extended_namesContext) { +} + +// ExitSubpartition_extended_names is called when production subpartition_extended_names is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_extended_names(ctx *Subpartition_extended_namesContext) { +} + +// EnterAlter_table_properties_1 is called when production alter_table_properties_1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_properties_1(ctx *Alter_table_properties_1Context) { +} + +// ExitAlter_table_properties_1 is called when production alter_table_properties_1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_properties_1(ctx *Alter_table_properties_1Context) { +} + +// EnterAlter_iot_clauses is called when production alter_iot_clauses is entered. +func (s *BasePlSqlParserListener) EnterAlter_iot_clauses(ctx *Alter_iot_clausesContext) {} + +// ExitAlter_iot_clauses is called when production alter_iot_clauses is exited. +func (s *BasePlSqlParserListener) ExitAlter_iot_clauses(ctx *Alter_iot_clausesContext) {} + +// EnterAlter_mapping_table_clause is called when production alter_mapping_table_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) { +} + +// ExitAlter_mapping_table_clause is called when production alter_mapping_table_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) { +} + +// EnterAlter_overflow_clause is called when production alter_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_overflow_clause(ctx *Alter_overflow_clauseContext) {} + +// ExitAlter_overflow_clause is called when production alter_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_overflow_clause(ctx *Alter_overflow_clauseContext) {} + +// EnterAdd_overflow_clause is called when production add_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_overflow_clause(ctx *Add_overflow_clauseContext) {} + +// ExitAdd_overflow_clause is called when production add_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_overflow_clause(ctx *Add_overflow_clauseContext) {} + +// EnterUpdate_index_clauses is called when production update_index_clauses is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_clauses(ctx *Update_index_clausesContext) {} + +// ExitUpdate_index_clauses is called when production update_index_clauses is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_clauses(ctx *Update_index_clausesContext) {} + +// EnterUpdate_global_index_clause is called when production update_global_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_global_index_clause(ctx *Update_global_index_clauseContext) { +} + +// ExitUpdate_global_index_clause is called when production update_global_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_global_index_clause(ctx *Update_global_index_clauseContext) { +} + +// EnterUpdate_all_indexes_clause is called when production update_all_indexes_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) { +} + +// ExitUpdate_all_indexes_clause is called when production update_all_indexes_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) { +} + +// EnterUpdate_all_indexes_index_clause is called when production update_all_indexes_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) { +} + +// ExitUpdate_all_indexes_index_clause is called when production update_all_indexes_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) { +} + +// EnterUpdate_index_partition is called when production update_index_partition is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_partition(ctx *Update_index_partitionContext) {} + +// ExitUpdate_index_partition is called when production update_index_partition is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_partition(ctx *Update_index_partitionContext) {} + +// EnterUpdate_index_subpartition is called when production update_index_subpartition is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_subpartition(ctx *Update_index_subpartitionContext) { +} + +// ExitUpdate_index_subpartition is called when production update_index_subpartition is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_subpartition(ctx *Update_index_subpartitionContext) { +} + +// EnterEnable_disable_clause is called when production enable_disable_clause is entered. +func (s *BasePlSqlParserListener) EnterEnable_disable_clause(ctx *Enable_disable_clauseContext) {} + +// ExitEnable_disable_clause is called when production enable_disable_clause is exited. +func (s *BasePlSqlParserListener) ExitEnable_disable_clause(ctx *Enable_disable_clauseContext) {} + +// EnterUsing_index_clause is called when production using_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_index_clause(ctx *Using_index_clauseContext) {} + +// ExitUsing_index_clause is called when production using_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_index_clause(ctx *Using_index_clauseContext) {} + +// EnterIndex_attributes is called when production index_attributes is entered. +func (s *BasePlSqlParserListener) EnterIndex_attributes(ctx *Index_attributesContext) {} + +// ExitIndex_attributes is called when production index_attributes is exited. +func (s *BasePlSqlParserListener) ExitIndex_attributes(ctx *Index_attributesContext) {} + +// EnterSort_or_nosort is called when production sort_or_nosort is entered. +func (s *BasePlSqlParserListener) EnterSort_or_nosort(ctx *Sort_or_nosortContext) {} + +// ExitSort_or_nosort is called when production sort_or_nosort is exited. +func (s *BasePlSqlParserListener) ExitSort_or_nosort(ctx *Sort_or_nosortContext) {} + +// EnterExceptions_clause is called when production exceptions_clause is entered. +func (s *BasePlSqlParserListener) EnterExceptions_clause(ctx *Exceptions_clauseContext) {} + +// ExitExceptions_clause is called when production exceptions_clause is exited. +func (s *BasePlSqlParserListener) ExitExceptions_clause(ctx *Exceptions_clauseContext) {} + +// EnterMove_table_clause is called when production move_table_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_table_clause(ctx *Move_table_clauseContext) {} + +// ExitMove_table_clause is called when production move_table_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_table_clause(ctx *Move_table_clauseContext) {} + +// EnterIndex_org_table_clause is called when production index_org_table_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_org_table_clause(ctx *Index_org_table_clauseContext) {} + +// ExitIndex_org_table_clause is called when production index_org_table_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_org_table_clause(ctx *Index_org_table_clauseContext) {} + +// EnterMapping_table_clause is called when production mapping_table_clause is entered. +func (s *BasePlSqlParserListener) EnterMapping_table_clause(ctx *Mapping_table_clauseContext) {} + +// ExitMapping_table_clause is called when production mapping_table_clause is exited. +func (s *BasePlSqlParserListener) ExitMapping_table_clause(ctx *Mapping_table_clauseContext) {} + +// EnterKey_compression is called when production key_compression is entered. +func (s *BasePlSqlParserListener) EnterKey_compression(ctx *Key_compressionContext) {} + +// ExitKey_compression is called when production key_compression is exited. +func (s *BasePlSqlParserListener) ExitKey_compression(ctx *Key_compressionContext) {} + +// EnterIndex_org_overflow_clause is called when production index_org_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) { +} + +// ExitIndex_org_overflow_clause is called when production index_org_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) { +} + +// EnterColumn_clauses is called when production column_clauses is entered. +func (s *BasePlSqlParserListener) EnterColumn_clauses(ctx *Column_clausesContext) {} + +// ExitColumn_clauses is called when production column_clauses is exited. +func (s *BasePlSqlParserListener) ExitColumn_clauses(ctx *Column_clausesContext) {} + +// EnterModify_collection_retrieval is called when production modify_collection_retrieval is entered. +func (s *BasePlSqlParserListener) EnterModify_collection_retrieval(ctx *Modify_collection_retrievalContext) { +} + +// ExitModify_collection_retrieval is called when production modify_collection_retrieval is exited. +func (s *BasePlSqlParserListener) ExitModify_collection_retrieval(ctx *Modify_collection_retrievalContext) { +} + +// EnterCollection_item is called when production collection_item is entered. +func (s *BasePlSqlParserListener) EnterCollection_item(ctx *Collection_itemContext) {} + +// ExitCollection_item is called when production collection_item is exited. +func (s *BasePlSqlParserListener) ExitCollection_item(ctx *Collection_itemContext) {} + +// EnterRename_column_clause is called when production rename_column_clause is entered. +func (s *BasePlSqlParserListener) EnterRename_column_clause(ctx *Rename_column_clauseContext) {} + +// ExitRename_column_clause is called when production rename_column_clause is exited. +func (s *BasePlSqlParserListener) ExitRename_column_clause(ctx *Rename_column_clauseContext) {} + +// EnterOld_column_name is called when production old_column_name is entered. +func (s *BasePlSqlParserListener) EnterOld_column_name(ctx *Old_column_nameContext) {} + +// ExitOld_column_name is called when production old_column_name is exited. +func (s *BasePlSqlParserListener) ExitOld_column_name(ctx *Old_column_nameContext) {} + +// EnterNew_column_name is called when production new_column_name is entered. +func (s *BasePlSqlParserListener) EnterNew_column_name(ctx *New_column_nameContext) {} + +// ExitNew_column_name is called when production new_column_name is exited. +func (s *BasePlSqlParserListener) ExitNew_column_name(ctx *New_column_nameContext) {} + +// EnterAdd_modify_drop_column_clauses is called when production add_modify_drop_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) { +} + +// ExitAdd_modify_drop_column_clauses is called when production add_modify_drop_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) { +} + +// EnterDrop_column_clause is called when production drop_column_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_column_clause(ctx *Drop_column_clauseContext) {} + +// ExitDrop_column_clause is called when production drop_column_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_column_clause(ctx *Drop_column_clauseContext) {} + +// EnterModify_column_clauses is called when production modify_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterModify_column_clauses(ctx *Modify_column_clausesContext) {} + +// ExitModify_column_clauses is called when production modify_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitModify_column_clauses(ctx *Modify_column_clausesContext) {} + +// EnterModify_col_properties is called when production modify_col_properties is entered. +func (s *BasePlSqlParserListener) EnterModify_col_properties(ctx *Modify_col_propertiesContext) {} + +// ExitModify_col_properties is called when production modify_col_properties is exited. +func (s *BasePlSqlParserListener) ExitModify_col_properties(ctx *Modify_col_propertiesContext) {} + +// EnterModify_col_visibility is called when production modify_col_visibility is entered. +func (s *BasePlSqlParserListener) EnterModify_col_visibility(ctx *Modify_col_visibilityContext) {} + +// ExitModify_col_visibility is called when production modify_col_visibility is exited. +func (s *BasePlSqlParserListener) ExitModify_col_visibility(ctx *Modify_col_visibilityContext) {} + +// EnterModify_col_substitutable is called when production modify_col_substitutable is entered. +func (s *BasePlSqlParserListener) EnterModify_col_substitutable(ctx *Modify_col_substitutableContext) { +} + +// ExitModify_col_substitutable is called when production modify_col_substitutable is exited. +func (s *BasePlSqlParserListener) ExitModify_col_substitutable(ctx *Modify_col_substitutableContext) { +} + +// EnterAdd_column_clause is called when production add_column_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_column_clause(ctx *Add_column_clauseContext) {} + +// ExitAdd_column_clause is called when production add_column_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_column_clause(ctx *Add_column_clauseContext) {} + +// EnterVarray_col_properties is called when production varray_col_properties is entered. +func (s *BasePlSqlParserListener) EnterVarray_col_properties(ctx *Varray_col_propertiesContext) {} + +// ExitVarray_col_properties is called when production varray_col_properties is exited. +func (s *BasePlSqlParserListener) ExitVarray_col_properties(ctx *Varray_col_propertiesContext) {} + +// EnterVarray_storage_clause is called when production varray_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterVarray_storage_clause(ctx *Varray_storage_clauseContext) {} + +// ExitVarray_storage_clause is called when production varray_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitVarray_storage_clause(ctx *Varray_storage_clauseContext) {} + +// EnterLob_segname is called when production lob_segname is entered. +func (s *BasePlSqlParserListener) EnterLob_segname(ctx *Lob_segnameContext) {} + +// ExitLob_segname is called when production lob_segname is exited. +func (s *BasePlSqlParserListener) ExitLob_segname(ctx *Lob_segnameContext) {} + +// EnterLob_item is called when production lob_item is entered. +func (s *BasePlSqlParserListener) EnterLob_item(ctx *Lob_itemContext) {} + +// ExitLob_item is called when production lob_item is exited. +func (s *BasePlSqlParserListener) ExitLob_item(ctx *Lob_itemContext) {} + +// EnterLob_storage_parameters is called when production lob_storage_parameters is entered. +func (s *BasePlSqlParserListener) EnterLob_storage_parameters(ctx *Lob_storage_parametersContext) {} + +// ExitLob_storage_parameters is called when production lob_storage_parameters is exited. +func (s *BasePlSqlParserListener) ExitLob_storage_parameters(ctx *Lob_storage_parametersContext) {} + +// EnterLob_storage_clause is called when production lob_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_storage_clause(ctx *Lob_storage_clauseContext) {} + +// ExitLob_storage_clause is called when production lob_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_storage_clause(ctx *Lob_storage_clauseContext) {} + +// EnterModify_lob_storage_clause is called when production modify_lob_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) { +} + +// ExitModify_lob_storage_clause is called when production modify_lob_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) { +} + +// EnterModify_lob_parameters is called when production modify_lob_parameters is entered. +func (s *BasePlSqlParserListener) EnterModify_lob_parameters(ctx *Modify_lob_parametersContext) {} + +// ExitModify_lob_parameters is called when production modify_lob_parameters is exited. +func (s *BasePlSqlParserListener) ExitModify_lob_parameters(ctx *Modify_lob_parametersContext) {} + +// EnterLob_parameters is called when production lob_parameters is entered. +func (s *BasePlSqlParserListener) EnterLob_parameters(ctx *Lob_parametersContext) {} + +// ExitLob_parameters is called when production lob_parameters is exited. +func (s *BasePlSqlParserListener) ExitLob_parameters(ctx *Lob_parametersContext) {} + +// EnterLob_deduplicate_clause is called when production lob_deduplicate_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) {} + +// ExitLob_deduplicate_clause is called when production lob_deduplicate_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) {} + +// EnterLob_compression_clause is called when production lob_compression_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_compression_clause(ctx *Lob_compression_clauseContext) {} + +// ExitLob_compression_clause is called when production lob_compression_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_compression_clause(ctx *Lob_compression_clauseContext) {} + +// EnterLob_retention_clause is called when production lob_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_retention_clause(ctx *Lob_retention_clauseContext) {} + +// ExitLob_retention_clause is called when production lob_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_retention_clause(ctx *Lob_retention_clauseContext) {} + +// EnterEncryption_spec is called when production encryption_spec is entered. +func (s *BasePlSqlParserListener) EnterEncryption_spec(ctx *Encryption_specContext) {} + +// ExitEncryption_spec is called when production encryption_spec is exited. +func (s *BasePlSqlParserListener) ExitEncryption_spec(ctx *Encryption_specContext) {} + +// EnterTablespace is called when production tablespace is entered. +func (s *BasePlSqlParserListener) EnterTablespace(ctx *TablespaceContext) {} + +// ExitTablespace is called when production tablespace is exited. +func (s *BasePlSqlParserListener) ExitTablespace(ctx *TablespaceContext) {} + +// EnterVarray_item is called when production varray_item is entered. +func (s *BasePlSqlParserListener) EnterVarray_item(ctx *Varray_itemContext) {} + +// ExitVarray_item is called when production varray_item is exited. +func (s *BasePlSqlParserListener) ExitVarray_item(ctx *Varray_itemContext) {} + +// EnterColumn_properties is called when production column_properties is entered. +func (s *BasePlSqlParserListener) EnterColumn_properties(ctx *Column_propertiesContext) {} + +// ExitColumn_properties is called when production column_properties is exited. +func (s *BasePlSqlParserListener) ExitColumn_properties(ctx *Column_propertiesContext) {} + +// EnterLob_partition_storage is called when production lob_partition_storage is entered. +func (s *BasePlSqlParserListener) EnterLob_partition_storage(ctx *Lob_partition_storageContext) {} + +// ExitLob_partition_storage is called when production lob_partition_storage is exited. +func (s *BasePlSqlParserListener) ExitLob_partition_storage(ctx *Lob_partition_storageContext) {} + +// EnterPeriod_definition is called when production period_definition is entered. +func (s *BasePlSqlParserListener) EnterPeriod_definition(ctx *Period_definitionContext) {} + +// ExitPeriod_definition is called when production period_definition is exited. +func (s *BasePlSqlParserListener) ExitPeriod_definition(ctx *Period_definitionContext) {} + +// EnterStart_time_column is called when production start_time_column is entered. +func (s *BasePlSqlParserListener) EnterStart_time_column(ctx *Start_time_columnContext) {} + +// ExitStart_time_column is called when production start_time_column is exited. +func (s *BasePlSqlParserListener) ExitStart_time_column(ctx *Start_time_columnContext) {} + +// EnterEnd_time_column is called when production end_time_column is entered. +func (s *BasePlSqlParserListener) EnterEnd_time_column(ctx *End_time_columnContext) {} + +// ExitEnd_time_column is called when production end_time_column is exited. +func (s *BasePlSqlParserListener) ExitEnd_time_column(ctx *End_time_columnContext) {} + +// EnterColumn_definition is called when production column_definition is entered. +func (s *BasePlSqlParserListener) EnterColumn_definition(ctx *Column_definitionContext) {} + +// ExitColumn_definition is called when production column_definition is exited. +func (s *BasePlSqlParserListener) ExitColumn_definition(ctx *Column_definitionContext) {} + +// EnterColumn_collation_name is called when production column_collation_name is entered. +func (s *BasePlSqlParserListener) EnterColumn_collation_name(ctx *Column_collation_nameContext) {} + +// ExitColumn_collation_name is called when production column_collation_name is exited. +func (s *BasePlSqlParserListener) ExitColumn_collation_name(ctx *Column_collation_nameContext) {} + +// EnterIdentity_clause is called when production identity_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentity_clause(ctx *Identity_clauseContext) {} + +// ExitIdentity_clause is called when production identity_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentity_clause(ctx *Identity_clauseContext) {} + +// EnterIdentity_options_parentheses is called when production identity_options_parentheses is entered. +func (s *BasePlSqlParserListener) EnterIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) { +} + +// ExitIdentity_options_parentheses is called when production identity_options_parentheses is exited. +func (s *BasePlSqlParserListener) ExitIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) { +} + +// EnterIdentity_options is called when production identity_options is entered. +func (s *BasePlSqlParserListener) EnterIdentity_options(ctx *Identity_optionsContext) {} + +// ExitIdentity_options is called when production identity_options is exited. +func (s *BasePlSqlParserListener) ExitIdentity_options(ctx *Identity_optionsContext) {} + +// EnterVirtual_column_definition is called when production virtual_column_definition is entered. +func (s *BasePlSqlParserListener) EnterVirtual_column_definition(ctx *Virtual_column_definitionContext) { +} + +// ExitVirtual_column_definition is called when production virtual_column_definition is exited. +func (s *BasePlSqlParserListener) ExitVirtual_column_definition(ctx *Virtual_column_definitionContext) { +} + +// EnterVirtual_column_expression is called when production virtual_column_expression is entered. +func (s *BasePlSqlParserListener) EnterVirtual_column_expression(ctx *Virtual_column_expressionContext) { +} + +// ExitVirtual_column_expression is called when production virtual_column_expression is exited. +func (s *BasePlSqlParserListener) ExitVirtual_column_expression(ctx *Virtual_column_expressionContext) { +} + +// EnterAutogenerated_sequence_definition is called when production autogenerated_sequence_definition is entered. +func (s *BasePlSqlParserListener) EnterAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) { +} + +// ExitAutogenerated_sequence_definition is called when production autogenerated_sequence_definition is exited. +func (s *BasePlSqlParserListener) ExitAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) { +} + +// EnterBy_user_for_statistics_clause is called when production by_user_for_statistics_clause is entered. +func (s *BasePlSqlParserListener) EnterBy_user_for_statistics_clause(ctx *By_user_for_statistics_clauseContext) { +} + +// ExitBy_user_for_statistics_clause is called when production by_user_for_statistics_clause is exited. +func (s *BasePlSqlParserListener) ExitBy_user_for_statistics_clause(ctx *By_user_for_statistics_clauseContext) { +} + +// EnterEvaluation_edition_clause is called when production evaluation_edition_clause is entered. +func (s *BasePlSqlParserListener) EnterEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) { +} + +// ExitEvaluation_edition_clause is called when production evaluation_edition_clause is exited. +func (s *BasePlSqlParserListener) ExitEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) { +} + +// EnterNested_table_col_properties is called when production nested_table_col_properties is entered. +func (s *BasePlSqlParserListener) EnterNested_table_col_properties(ctx *Nested_table_col_propertiesContext) { +} + +// ExitNested_table_col_properties is called when production nested_table_col_properties is exited. +func (s *BasePlSqlParserListener) ExitNested_table_col_properties(ctx *Nested_table_col_propertiesContext) { +} + +// EnterNested_item is called when production nested_item is entered. +func (s *BasePlSqlParserListener) EnterNested_item(ctx *Nested_itemContext) {} + +// ExitNested_item is called when production nested_item is exited. +func (s *BasePlSqlParserListener) ExitNested_item(ctx *Nested_itemContext) {} + +// EnterSubstitutable_column_clause is called when production substitutable_column_clause is entered. +func (s *BasePlSqlParserListener) EnterSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) { +} + +// ExitSubstitutable_column_clause is called when production substitutable_column_clause is exited. +func (s *BasePlSqlParserListener) ExitSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) { +} + +// EnterPartition_name is called when production partition_name is entered. +func (s *BasePlSqlParserListener) EnterPartition_name(ctx *Partition_nameContext) {} + +// ExitPartition_name is called when production partition_name is exited. +func (s *BasePlSqlParserListener) ExitPartition_name(ctx *Partition_nameContext) {} + +// EnterSupplemental_logging_props is called when production supplemental_logging_props is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_logging_props(ctx *Supplemental_logging_propsContext) { +} + +// ExitSupplemental_logging_props is called when production supplemental_logging_props is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_logging_props(ctx *Supplemental_logging_propsContext) { +} + +// EnterObject_type_col_properties is called when production object_type_col_properties is entered. +func (s *BasePlSqlParserListener) EnterObject_type_col_properties(ctx *Object_type_col_propertiesContext) { +} + +// ExitObject_type_col_properties is called when production object_type_col_properties is exited. +func (s *BasePlSqlParserListener) ExitObject_type_col_properties(ctx *Object_type_col_propertiesContext) { +} + +// EnterConstraint_clauses is called when production constraint_clauses is entered. +func (s *BasePlSqlParserListener) EnterConstraint_clauses(ctx *Constraint_clausesContext) {} + +// ExitConstraint_clauses is called when production constraint_clauses is exited. +func (s *BasePlSqlParserListener) ExitConstraint_clauses(ctx *Constraint_clausesContext) {} + +// EnterOld_constraint_name is called when production old_constraint_name is entered. +func (s *BasePlSqlParserListener) EnterOld_constraint_name(ctx *Old_constraint_nameContext) {} + +// ExitOld_constraint_name is called when production old_constraint_name is exited. +func (s *BasePlSqlParserListener) ExitOld_constraint_name(ctx *Old_constraint_nameContext) {} + +// EnterNew_constraint_name is called when production new_constraint_name is entered. +func (s *BasePlSqlParserListener) EnterNew_constraint_name(ctx *New_constraint_nameContext) {} + +// ExitNew_constraint_name is called when production new_constraint_name is exited. +func (s *BasePlSqlParserListener) ExitNew_constraint_name(ctx *New_constraint_nameContext) {} + +// EnterDrop_constraint_clause is called when production drop_constraint_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_constraint_clause(ctx *Drop_constraint_clauseContext) {} + +// ExitDrop_constraint_clause is called when production drop_constraint_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_constraint_clause(ctx *Drop_constraint_clauseContext) {} + +// EnterCheck_constraint is called when production check_constraint is entered. +func (s *BasePlSqlParserListener) EnterCheck_constraint(ctx *Check_constraintContext) {} + +// ExitCheck_constraint is called when production check_constraint is exited. +func (s *BasePlSqlParserListener) ExitCheck_constraint(ctx *Check_constraintContext) {} + +// EnterForeign_key_clause is called when production foreign_key_clause is entered. +func (s *BasePlSqlParserListener) EnterForeign_key_clause(ctx *Foreign_key_clauseContext) {} + +// ExitForeign_key_clause is called when production foreign_key_clause is exited. +func (s *BasePlSqlParserListener) ExitForeign_key_clause(ctx *Foreign_key_clauseContext) {} + +// EnterReferences_clause is called when production references_clause is entered. +func (s *BasePlSqlParserListener) EnterReferences_clause(ctx *References_clauseContext) {} + +// ExitReferences_clause is called when production references_clause is exited. +func (s *BasePlSqlParserListener) ExitReferences_clause(ctx *References_clauseContext) {} + +// EnterOn_delete_clause is called when production on_delete_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_delete_clause(ctx *On_delete_clauseContext) {} + +// ExitOn_delete_clause is called when production on_delete_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_delete_clause(ctx *On_delete_clauseContext) {} + +// EnterAnonymous_block is called when production anonymous_block is entered. +func (s *BasePlSqlParserListener) EnterAnonymous_block(ctx *Anonymous_blockContext) {} + +// ExitAnonymous_block is called when production anonymous_block is exited. +func (s *BasePlSqlParserListener) ExitAnonymous_block(ctx *Anonymous_blockContext) {} + +// EnterInvoker_rights_clause is called when production invoker_rights_clause is entered. +func (s *BasePlSqlParserListener) EnterInvoker_rights_clause(ctx *Invoker_rights_clauseContext) {} + +// ExitInvoker_rights_clause is called when production invoker_rights_clause is exited. +func (s *BasePlSqlParserListener) ExitInvoker_rights_clause(ctx *Invoker_rights_clauseContext) {} + +// EnterCall_spec is called when production call_spec is entered. +func (s *BasePlSqlParserListener) EnterCall_spec(ctx *Call_specContext) {} + +// ExitCall_spec is called when production call_spec is exited. +func (s *BasePlSqlParserListener) ExitCall_spec(ctx *Call_specContext) {} + +// EnterJava_spec is called when production java_spec is entered. +func (s *BasePlSqlParserListener) EnterJava_spec(ctx *Java_specContext) {} + +// ExitJava_spec is called when production java_spec is exited. +func (s *BasePlSqlParserListener) ExitJava_spec(ctx *Java_specContext) {} + +// EnterC_spec is called when production c_spec is entered. +func (s *BasePlSqlParserListener) EnterC_spec(ctx *C_specContext) {} + +// ExitC_spec is called when production c_spec is exited. +func (s *BasePlSqlParserListener) ExitC_spec(ctx *C_specContext) {} + +// EnterC_agent_in_clause is called when production c_agent_in_clause is entered. +func (s *BasePlSqlParserListener) EnterC_agent_in_clause(ctx *C_agent_in_clauseContext) {} + +// ExitC_agent_in_clause is called when production c_agent_in_clause is exited. +func (s *BasePlSqlParserListener) ExitC_agent_in_clause(ctx *C_agent_in_clauseContext) {} + +// EnterC_parameters_clause is called when production c_parameters_clause is entered. +func (s *BasePlSqlParserListener) EnterC_parameters_clause(ctx *C_parameters_clauseContext) {} + +// ExitC_parameters_clause is called when production c_parameters_clause is exited. +func (s *BasePlSqlParserListener) ExitC_parameters_clause(ctx *C_parameters_clauseContext) {} + +// EnterC_external_parameter is called when production c_external_parameter is entered. +func (s *BasePlSqlParserListener) EnterC_external_parameter(ctx *C_external_parameterContext) {} + +// ExitC_external_parameter is called when production c_external_parameter is exited. +func (s *BasePlSqlParserListener) ExitC_external_parameter(ctx *C_external_parameterContext) {} + +// EnterC_property is called when production c_property is entered. +func (s *BasePlSqlParserListener) EnterC_property(ctx *C_propertyContext) {} + +// ExitC_property is called when production c_property is exited. +func (s *BasePlSqlParserListener) ExitC_property(ctx *C_propertyContext) {} + +// EnterParameter is called when production parameter is entered. +func (s *BasePlSqlParserListener) EnterParameter(ctx *ParameterContext) {} + +// ExitParameter is called when production parameter is exited. +func (s *BasePlSqlParserListener) ExitParameter(ctx *ParameterContext) {} + +// EnterDefault_value_part is called when production default_value_part is entered. +func (s *BasePlSqlParserListener) EnterDefault_value_part(ctx *Default_value_partContext) {} + +// ExitDefault_value_part is called when production default_value_part is exited. +func (s *BasePlSqlParserListener) ExitDefault_value_part(ctx *Default_value_partContext) {} + +// EnterSeq_of_declare_specs is called when production seq_of_declare_specs is entered. +func (s *BasePlSqlParserListener) EnterSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) {} + +// ExitSeq_of_declare_specs is called when production seq_of_declare_specs is exited. +func (s *BasePlSqlParserListener) ExitSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) {} + +// EnterDeclare_spec is called when production declare_spec is entered. +func (s *BasePlSqlParserListener) EnterDeclare_spec(ctx *Declare_specContext) {} + +// ExitDeclare_spec is called when production declare_spec is exited. +func (s *BasePlSqlParserListener) ExitDeclare_spec(ctx *Declare_specContext) {} + +// EnterVariable_declaration is called when production variable_declaration is entered. +func (s *BasePlSqlParserListener) EnterVariable_declaration(ctx *Variable_declarationContext) {} + +// ExitVariable_declaration is called when production variable_declaration is exited. +func (s *BasePlSqlParserListener) ExitVariable_declaration(ctx *Variable_declarationContext) {} + +// EnterSubtype_declaration is called when production subtype_declaration is entered. +func (s *BasePlSqlParserListener) EnterSubtype_declaration(ctx *Subtype_declarationContext) {} + +// ExitSubtype_declaration is called when production subtype_declaration is exited. +func (s *BasePlSqlParserListener) ExitSubtype_declaration(ctx *Subtype_declarationContext) {} + +// EnterCursor_declaration is called when production cursor_declaration is entered. +func (s *BasePlSqlParserListener) EnterCursor_declaration(ctx *Cursor_declarationContext) {} + +// ExitCursor_declaration is called when production cursor_declaration is exited. +func (s *BasePlSqlParserListener) ExitCursor_declaration(ctx *Cursor_declarationContext) {} + +// EnterParameter_spec is called when production parameter_spec is entered. +func (s *BasePlSqlParserListener) EnterParameter_spec(ctx *Parameter_specContext) {} + +// ExitParameter_spec is called when production parameter_spec is exited. +func (s *BasePlSqlParserListener) ExitParameter_spec(ctx *Parameter_specContext) {} + +// EnterException_declaration is called when production exception_declaration is entered. +func (s *BasePlSqlParserListener) EnterException_declaration(ctx *Exception_declarationContext) {} + +// ExitException_declaration is called when production exception_declaration is exited. +func (s *BasePlSqlParserListener) ExitException_declaration(ctx *Exception_declarationContext) {} + +// EnterPragma_declaration is called when production pragma_declaration is entered. +func (s *BasePlSqlParserListener) EnterPragma_declaration(ctx *Pragma_declarationContext) {} + +// ExitPragma_declaration is called when production pragma_declaration is exited. +func (s *BasePlSqlParserListener) ExitPragma_declaration(ctx *Pragma_declarationContext) {} + +// EnterRecord_type_def is called when production record_type_def is entered. +func (s *BasePlSqlParserListener) EnterRecord_type_def(ctx *Record_type_defContext) {} + +// ExitRecord_type_def is called when production record_type_def is exited. +func (s *BasePlSqlParserListener) ExitRecord_type_def(ctx *Record_type_defContext) {} + +// EnterField_spec is called when production field_spec is entered. +func (s *BasePlSqlParserListener) EnterField_spec(ctx *Field_specContext) {} + +// ExitField_spec is called when production field_spec is exited. +func (s *BasePlSqlParserListener) ExitField_spec(ctx *Field_specContext) {} + +// EnterRef_cursor_type_def is called when production ref_cursor_type_def is entered. +func (s *BasePlSqlParserListener) EnterRef_cursor_type_def(ctx *Ref_cursor_type_defContext) {} + +// ExitRef_cursor_type_def is called when production ref_cursor_type_def is exited. +func (s *BasePlSqlParserListener) ExitRef_cursor_type_def(ctx *Ref_cursor_type_defContext) {} + +// EnterType_declaration is called when production type_declaration is entered. +func (s *BasePlSqlParserListener) EnterType_declaration(ctx *Type_declarationContext) {} + +// ExitType_declaration is called when production type_declaration is exited. +func (s *BasePlSqlParserListener) ExitType_declaration(ctx *Type_declarationContext) {} + +// EnterTable_type_def is called when production table_type_def is entered. +func (s *BasePlSqlParserListener) EnterTable_type_def(ctx *Table_type_defContext) {} + +// ExitTable_type_def is called when production table_type_def is exited. +func (s *BasePlSqlParserListener) ExitTable_type_def(ctx *Table_type_defContext) {} + +// EnterTable_indexed_by_part is called when production table_indexed_by_part is entered. +func (s *BasePlSqlParserListener) EnterTable_indexed_by_part(ctx *Table_indexed_by_partContext) {} + +// ExitTable_indexed_by_part is called when production table_indexed_by_part is exited. +func (s *BasePlSqlParserListener) ExitTable_indexed_by_part(ctx *Table_indexed_by_partContext) {} + +// EnterVarray_type_def is called when production varray_type_def is entered. +func (s *BasePlSqlParserListener) EnterVarray_type_def(ctx *Varray_type_defContext) {} + +// ExitVarray_type_def is called when production varray_type_def is exited. +func (s *BasePlSqlParserListener) ExitVarray_type_def(ctx *Varray_type_defContext) {} + +// EnterSeq_of_statements is called when production seq_of_statements is entered. +func (s *BasePlSqlParserListener) EnterSeq_of_statements(ctx *Seq_of_statementsContext) {} + +// ExitSeq_of_statements is called when production seq_of_statements is exited. +func (s *BasePlSqlParserListener) ExitSeq_of_statements(ctx *Seq_of_statementsContext) {} + +// EnterLabel_declaration is called when production label_declaration is entered. +func (s *BasePlSqlParserListener) EnterLabel_declaration(ctx *Label_declarationContext) {} + +// ExitLabel_declaration is called when production label_declaration is exited. +func (s *BasePlSqlParserListener) ExitLabel_declaration(ctx *Label_declarationContext) {} + +// EnterStatement is called when production statement is entered. +func (s *BasePlSqlParserListener) EnterStatement(ctx *StatementContext) {} + +// ExitStatement is called when production statement is exited. +func (s *BasePlSqlParserListener) ExitStatement(ctx *StatementContext) {} + +// EnterAssignment_statement is called when production assignment_statement is entered. +func (s *BasePlSqlParserListener) EnterAssignment_statement(ctx *Assignment_statementContext) {} + +// ExitAssignment_statement is called when production assignment_statement is exited. +func (s *BasePlSqlParserListener) ExitAssignment_statement(ctx *Assignment_statementContext) {} + +// EnterContinue_statement is called when production continue_statement is entered. +func (s *BasePlSqlParserListener) EnterContinue_statement(ctx *Continue_statementContext) {} + +// ExitContinue_statement is called when production continue_statement is exited. +func (s *BasePlSqlParserListener) ExitContinue_statement(ctx *Continue_statementContext) {} + +// EnterExit_statement is called when production exit_statement is entered. +func (s *BasePlSqlParserListener) EnterExit_statement(ctx *Exit_statementContext) {} + +// ExitExit_statement is called when production exit_statement is exited. +func (s *BasePlSqlParserListener) ExitExit_statement(ctx *Exit_statementContext) {} + +// EnterGoto_statement is called when production goto_statement is entered. +func (s *BasePlSqlParserListener) EnterGoto_statement(ctx *Goto_statementContext) {} + +// ExitGoto_statement is called when production goto_statement is exited. +func (s *BasePlSqlParserListener) ExitGoto_statement(ctx *Goto_statementContext) {} + +// EnterIf_statement is called when production if_statement is entered. +func (s *BasePlSqlParserListener) EnterIf_statement(ctx *If_statementContext) {} + +// ExitIf_statement is called when production if_statement is exited. +func (s *BasePlSqlParserListener) ExitIf_statement(ctx *If_statementContext) {} + +// EnterElsif_part is called when production elsif_part is entered. +func (s *BasePlSqlParserListener) EnterElsif_part(ctx *Elsif_partContext) {} + +// ExitElsif_part is called when production elsif_part is exited. +func (s *BasePlSqlParserListener) ExitElsif_part(ctx *Elsif_partContext) {} + +// EnterElse_part is called when production else_part is entered. +func (s *BasePlSqlParserListener) EnterElse_part(ctx *Else_partContext) {} + +// ExitElse_part is called when production else_part is exited. +func (s *BasePlSqlParserListener) ExitElse_part(ctx *Else_partContext) {} + +// EnterLoop_statement is called when production loop_statement is entered. +func (s *BasePlSqlParserListener) EnterLoop_statement(ctx *Loop_statementContext) {} + +// ExitLoop_statement is called when production loop_statement is exited. +func (s *BasePlSqlParserListener) ExitLoop_statement(ctx *Loop_statementContext) {} + +// EnterCursor_loop_param is called when production cursor_loop_param is entered. +func (s *BasePlSqlParserListener) EnterCursor_loop_param(ctx *Cursor_loop_paramContext) {} + +// ExitCursor_loop_param is called when production cursor_loop_param is exited. +func (s *BasePlSqlParserListener) ExitCursor_loop_param(ctx *Cursor_loop_paramContext) {} + +// EnterForall_statement is called when production forall_statement is entered. +func (s *BasePlSqlParserListener) EnterForall_statement(ctx *Forall_statementContext) {} + +// ExitForall_statement is called when production forall_statement is exited. +func (s *BasePlSqlParserListener) ExitForall_statement(ctx *Forall_statementContext) {} + +// EnterBounds_clause is called when production bounds_clause is entered. +func (s *BasePlSqlParserListener) EnterBounds_clause(ctx *Bounds_clauseContext) {} + +// ExitBounds_clause is called when production bounds_clause is exited. +func (s *BasePlSqlParserListener) ExitBounds_clause(ctx *Bounds_clauseContext) {} + +// EnterBetween_bound is called when production between_bound is entered. +func (s *BasePlSqlParserListener) EnterBetween_bound(ctx *Between_boundContext) {} + +// ExitBetween_bound is called when production between_bound is exited. +func (s *BasePlSqlParserListener) ExitBetween_bound(ctx *Between_boundContext) {} + +// EnterLower_bound is called when production lower_bound is entered. +func (s *BasePlSqlParserListener) EnterLower_bound(ctx *Lower_boundContext) {} + +// ExitLower_bound is called when production lower_bound is exited. +func (s *BasePlSqlParserListener) ExitLower_bound(ctx *Lower_boundContext) {} + +// EnterUpper_bound is called when production upper_bound is entered. +func (s *BasePlSqlParserListener) EnterUpper_bound(ctx *Upper_boundContext) {} + +// ExitUpper_bound is called when production upper_bound is exited. +func (s *BasePlSqlParserListener) ExitUpper_bound(ctx *Upper_boundContext) {} + +// EnterNull_statement is called when production null_statement is entered. +func (s *BasePlSqlParserListener) EnterNull_statement(ctx *Null_statementContext) {} + +// ExitNull_statement is called when production null_statement is exited. +func (s *BasePlSqlParserListener) ExitNull_statement(ctx *Null_statementContext) {} + +// EnterRaise_statement is called when production raise_statement is entered. +func (s *BasePlSqlParserListener) EnterRaise_statement(ctx *Raise_statementContext) {} + +// ExitRaise_statement is called when production raise_statement is exited. +func (s *BasePlSqlParserListener) ExitRaise_statement(ctx *Raise_statementContext) {} + +// EnterReturn_statement is called when production return_statement is entered. +func (s *BasePlSqlParserListener) EnterReturn_statement(ctx *Return_statementContext) {} + +// ExitReturn_statement is called when production return_statement is exited. +func (s *BasePlSqlParserListener) ExitReturn_statement(ctx *Return_statementContext) {} + +// EnterCall_statement is called when production call_statement is entered. +func (s *BasePlSqlParserListener) EnterCall_statement(ctx *Call_statementContext) {} + +// ExitCall_statement is called when production call_statement is exited. +func (s *BasePlSqlParserListener) ExitCall_statement(ctx *Call_statementContext) {} + +// EnterPipe_row_statement is called when production pipe_row_statement is entered. +func (s *BasePlSqlParserListener) EnterPipe_row_statement(ctx *Pipe_row_statementContext) {} + +// ExitPipe_row_statement is called when production pipe_row_statement is exited. +func (s *BasePlSqlParserListener) ExitPipe_row_statement(ctx *Pipe_row_statementContext) {} + +// EnterSelection_directive is called when production selection_directive is entered. +func (s *BasePlSqlParserListener) EnterSelection_directive(ctx *Selection_directiveContext) {} + +// ExitSelection_directive is called when production selection_directive is exited. +func (s *BasePlSqlParserListener) ExitSelection_directive(ctx *Selection_directiveContext) {} + +// EnterError_directive is called when production error_directive is entered. +func (s *BasePlSqlParserListener) EnterError_directive(ctx *Error_directiveContext) {} + +// ExitError_directive is called when production error_directive is exited. +func (s *BasePlSqlParserListener) ExitError_directive(ctx *Error_directiveContext) {} + +// EnterSelection_directive_body is called when production selection_directive_body is entered. +func (s *BasePlSqlParserListener) EnterSelection_directive_body(ctx *Selection_directive_bodyContext) { +} + +// ExitSelection_directive_body is called when production selection_directive_body is exited. +func (s *BasePlSqlParserListener) ExitSelection_directive_body(ctx *Selection_directive_bodyContext) { +} + +// EnterBody is called when production body is entered. +func (s *BasePlSqlParserListener) EnterBody(ctx *BodyContext) {} + +// ExitBody is called when production body is exited. +func (s *BasePlSqlParserListener) ExitBody(ctx *BodyContext) {} + +// EnterException_handler is called when production exception_handler is entered. +func (s *BasePlSqlParserListener) EnterException_handler(ctx *Exception_handlerContext) {} + +// ExitException_handler is called when production exception_handler is exited. +func (s *BasePlSqlParserListener) ExitException_handler(ctx *Exception_handlerContext) {} + +// EnterTrigger_block is called when production trigger_block is entered. +func (s *BasePlSqlParserListener) EnterTrigger_block(ctx *Trigger_blockContext) {} + +// ExitTrigger_block is called when production trigger_block is exited. +func (s *BasePlSqlParserListener) ExitTrigger_block(ctx *Trigger_blockContext) {} + +// EnterTps_block is called when production tps_block is entered. +func (s *BasePlSqlParserListener) EnterTps_block(ctx *Tps_blockContext) {} + +// ExitTps_block is called when production tps_block is exited. +func (s *BasePlSqlParserListener) ExitTps_block(ctx *Tps_blockContext) {} + +// EnterBlock is called when production block is entered. +func (s *BasePlSqlParserListener) EnterBlock(ctx *BlockContext) {} + +// ExitBlock is called when production block is exited. +func (s *BasePlSqlParserListener) ExitBlock(ctx *BlockContext) {} + +// EnterSql_statement is called when production sql_statement is entered. +func (s *BasePlSqlParserListener) EnterSql_statement(ctx *Sql_statementContext) {} + +// ExitSql_statement is called when production sql_statement is exited. +func (s *BasePlSqlParserListener) ExitSql_statement(ctx *Sql_statementContext) {} + +// EnterExecute_immediate is called when production execute_immediate is entered. +func (s *BasePlSqlParserListener) EnterExecute_immediate(ctx *Execute_immediateContext) {} + +// ExitExecute_immediate is called when production execute_immediate is exited. +func (s *BasePlSqlParserListener) ExitExecute_immediate(ctx *Execute_immediateContext) {} + +// EnterDynamic_returning_clause is called when production dynamic_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) { +} + +// ExitDynamic_returning_clause is called when production dynamic_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) { +} + +// EnterData_manipulation_language_statements is called when production data_manipulation_language_statements is entered. +func (s *BasePlSqlParserListener) EnterData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) { +} + +// ExitData_manipulation_language_statements is called when production data_manipulation_language_statements is exited. +func (s *BasePlSqlParserListener) ExitData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) { +} + +// EnterCursor_manipulation_statements is called when production cursor_manipulation_statements is entered. +func (s *BasePlSqlParserListener) EnterCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) { +} + +// ExitCursor_manipulation_statements is called when production cursor_manipulation_statements is exited. +func (s *BasePlSqlParserListener) ExitCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) { +} + +// EnterClose_statement is called when production close_statement is entered. +func (s *BasePlSqlParserListener) EnterClose_statement(ctx *Close_statementContext) {} + +// ExitClose_statement is called when production close_statement is exited. +func (s *BasePlSqlParserListener) ExitClose_statement(ctx *Close_statementContext) {} + +// EnterOpen_statement is called when production open_statement is entered. +func (s *BasePlSqlParserListener) EnterOpen_statement(ctx *Open_statementContext) {} + +// ExitOpen_statement is called when production open_statement is exited. +func (s *BasePlSqlParserListener) ExitOpen_statement(ctx *Open_statementContext) {} + +// EnterFetch_statement is called when production fetch_statement is entered. +func (s *BasePlSqlParserListener) EnterFetch_statement(ctx *Fetch_statementContext) {} + +// ExitFetch_statement is called when production fetch_statement is exited. +func (s *BasePlSqlParserListener) ExitFetch_statement(ctx *Fetch_statementContext) {} + +// EnterVariable_or_collection is called when production variable_or_collection is entered. +func (s *BasePlSqlParserListener) EnterVariable_or_collection(ctx *Variable_or_collectionContext) {} + +// ExitVariable_or_collection is called when production variable_or_collection is exited. +func (s *BasePlSqlParserListener) ExitVariable_or_collection(ctx *Variable_or_collectionContext) {} + +// EnterOpen_for_statement is called when production open_for_statement is entered. +func (s *BasePlSqlParserListener) EnterOpen_for_statement(ctx *Open_for_statementContext) {} + +// ExitOpen_for_statement is called when production open_for_statement is exited. +func (s *BasePlSqlParserListener) ExitOpen_for_statement(ctx *Open_for_statementContext) {} + +// EnterTransaction_control_statements is called when production transaction_control_statements is entered. +func (s *BasePlSqlParserListener) EnterTransaction_control_statements(ctx *Transaction_control_statementsContext) { +} + +// ExitTransaction_control_statements is called when production transaction_control_statements is exited. +func (s *BasePlSqlParserListener) ExitTransaction_control_statements(ctx *Transaction_control_statementsContext) { +} + +// EnterSet_transaction_command is called when production set_transaction_command is entered. +func (s *BasePlSqlParserListener) EnterSet_transaction_command(ctx *Set_transaction_commandContext) {} + +// ExitSet_transaction_command is called when production set_transaction_command is exited. +func (s *BasePlSqlParserListener) ExitSet_transaction_command(ctx *Set_transaction_commandContext) {} + +// EnterSet_constraint_command is called when production set_constraint_command is entered. +func (s *BasePlSqlParserListener) EnterSet_constraint_command(ctx *Set_constraint_commandContext) {} + +// ExitSet_constraint_command is called when production set_constraint_command is exited. +func (s *BasePlSqlParserListener) ExitSet_constraint_command(ctx *Set_constraint_commandContext) {} + +// EnterCommit_statement is called when production commit_statement is entered. +func (s *BasePlSqlParserListener) EnterCommit_statement(ctx *Commit_statementContext) {} + +// ExitCommit_statement is called when production commit_statement is exited. +func (s *BasePlSqlParserListener) ExitCommit_statement(ctx *Commit_statementContext) {} + +// EnterWrite_clause is called when production write_clause is entered. +func (s *BasePlSqlParserListener) EnterWrite_clause(ctx *Write_clauseContext) {} + +// ExitWrite_clause is called when production write_clause is exited. +func (s *BasePlSqlParserListener) ExitWrite_clause(ctx *Write_clauseContext) {} + +// EnterRollback_statement is called when production rollback_statement is entered. +func (s *BasePlSqlParserListener) EnterRollback_statement(ctx *Rollback_statementContext) {} + +// ExitRollback_statement is called when production rollback_statement is exited. +func (s *BasePlSqlParserListener) ExitRollback_statement(ctx *Rollback_statementContext) {} + +// EnterSavepoint_statement is called when production savepoint_statement is entered. +func (s *BasePlSqlParserListener) EnterSavepoint_statement(ctx *Savepoint_statementContext) {} + +// ExitSavepoint_statement is called when production savepoint_statement is exited. +func (s *BasePlSqlParserListener) ExitSavepoint_statement(ctx *Savepoint_statementContext) {} + +// EnterCollection_method_call is called when production collection_method_call is entered. +func (s *BasePlSqlParserListener) EnterCollection_method_call(ctx *Collection_method_callContext) {} + +// ExitCollection_method_call is called when production collection_method_call is exited. +func (s *BasePlSqlParserListener) ExitCollection_method_call(ctx *Collection_method_callContext) {} + +// EnterExplain_statement is called when production explain_statement is entered. +func (s *BasePlSqlParserListener) EnterExplain_statement(ctx *Explain_statementContext) {} + +// ExitExplain_statement is called when production explain_statement is exited. +func (s *BasePlSqlParserListener) ExitExplain_statement(ctx *Explain_statementContext) {} + +// EnterSelect_only_statement is called when production select_only_statement is entered. +func (s *BasePlSqlParserListener) EnterSelect_only_statement(ctx *Select_only_statementContext) {} + +// ExitSelect_only_statement is called when production select_only_statement is exited. +func (s *BasePlSqlParserListener) ExitSelect_only_statement(ctx *Select_only_statementContext) {} + +// EnterSelect_statement is called when production select_statement is entered. +func (s *BasePlSqlParserListener) EnterSelect_statement(ctx *Select_statementContext) {} + +// ExitSelect_statement is called when production select_statement is exited. +func (s *BasePlSqlParserListener) ExitSelect_statement(ctx *Select_statementContext) {} + +// EnterWith_clause is called when production with_clause is entered. +func (s *BasePlSqlParserListener) EnterWith_clause(ctx *With_clauseContext) {} + +// ExitWith_clause is called when production with_clause is exited. +func (s *BasePlSqlParserListener) ExitWith_clause(ctx *With_clauseContext) {} + +// EnterWith_factoring_clause is called when production with_factoring_clause is entered. +func (s *BasePlSqlParserListener) EnterWith_factoring_clause(ctx *With_factoring_clauseContext) {} + +// ExitWith_factoring_clause is called when production with_factoring_clause is exited. +func (s *BasePlSqlParserListener) ExitWith_factoring_clause(ctx *With_factoring_clauseContext) {} + +// EnterSubquery_factoring_clause is called when production subquery_factoring_clause is entered. +func (s *BasePlSqlParserListener) EnterSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) { +} + +// ExitSubquery_factoring_clause is called when production subquery_factoring_clause is exited. +func (s *BasePlSqlParserListener) ExitSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) { +} + +// EnterSearch_clause is called when production search_clause is entered. +func (s *BasePlSqlParserListener) EnterSearch_clause(ctx *Search_clauseContext) {} + +// ExitSearch_clause is called when production search_clause is exited. +func (s *BasePlSqlParserListener) ExitSearch_clause(ctx *Search_clauseContext) {} + +// EnterCycle_clause is called when production cycle_clause is entered. +func (s *BasePlSqlParserListener) EnterCycle_clause(ctx *Cycle_clauseContext) {} + +// ExitCycle_clause is called when production cycle_clause is exited. +func (s *BasePlSqlParserListener) ExitCycle_clause(ctx *Cycle_clauseContext) {} + +// EnterSubav_factoring_clause is called when production subav_factoring_clause is entered. +func (s *BasePlSqlParserListener) EnterSubav_factoring_clause(ctx *Subav_factoring_clauseContext) {} + +// ExitSubav_factoring_clause is called when production subav_factoring_clause is exited. +func (s *BasePlSqlParserListener) ExitSubav_factoring_clause(ctx *Subav_factoring_clauseContext) {} + +// EnterSubav_clause is called when production subav_clause is entered. +func (s *BasePlSqlParserListener) EnterSubav_clause(ctx *Subav_clauseContext) {} + +// ExitSubav_clause is called when production subav_clause is exited. +func (s *BasePlSqlParserListener) ExitSubav_clause(ctx *Subav_clauseContext) {} + +// EnterHierarchies_clause is called when production hierarchies_clause is entered. +func (s *BasePlSqlParserListener) EnterHierarchies_clause(ctx *Hierarchies_clauseContext) {} + +// ExitHierarchies_clause is called when production hierarchies_clause is exited. +func (s *BasePlSqlParserListener) ExitHierarchies_clause(ctx *Hierarchies_clauseContext) {} + +// EnterFilter_clauses is called when production filter_clauses is entered. +func (s *BasePlSqlParserListener) EnterFilter_clauses(ctx *Filter_clausesContext) {} + +// ExitFilter_clauses is called when production filter_clauses is exited. +func (s *BasePlSqlParserListener) ExitFilter_clauses(ctx *Filter_clausesContext) {} + +// EnterFilter_clause is called when production filter_clause is entered. +func (s *BasePlSqlParserListener) EnterFilter_clause(ctx *Filter_clauseContext) {} + +// ExitFilter_clause is called when production filter_clause is exited. +func (s *BasePlSqlParserListener) ExitFilter_clause(ctx *Filter_clauseContext) {} + +// EnterAdd_calcs_clause is called when production add_calcs_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_calcs_clause(ctx *Add_calcs_clauseContext) {} + +// ExitAdd_calcs_clause is called when production add_calcs_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_calcs_clause(ctx *Add_calcs_clauseContext) {} + +// EnterAdd_calc_meas_clause is called when production add_calc_meas_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_calc_meas_clause(ctx *Add_calc_meas_clauseContext) {} + +// ExitAdd_calc_meas_clause is called when production add_calc_meas_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_calc_meas_clause(ctx *Add_calc_meas_clauseContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BasePlSqlParserListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BasePlSqlParserListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterSubquery_basic_elements is called when production subquery_basic_elements is entered. +func (s *BasePlSqlParserListener) EnterSubquery_basic_elements(ctx *Subquery_basic_elementsContext) {} + +// ExitSubquery_basic_elements is called when production subquery_basic_elements is exited. +func (s *BasePlSqlParserListener) ExitSubquery_basic_elements(ctx *Subquery_basic_elementsContext) {} + +// EnterSubquery_operation_part is called when production subquery_operation_part is entered. +func (s *BasePlSqlParserListener) EnterSubquery_operation_part(ctx *Subquery_operation_partContext) {} + +// ExitSubquery_operation_part is called when production subquery_operation_part is exited. +func (s *BasePlSqlParserListener) ExitSubquery_operation_part(ctx *Subquery_operation_partContext) {} + +// EnterQuery_block is called when production query_block is entered. +func (s *BasePlSqlParserListener) EnterQuery_block(ctx *Query_blockContext) {} + +// ExitQuery_block is called when production query_block is exited. +func (s *BasePlSqlParserListener) ExitQuery_block(ctx *Query_blockContext) {} + +// EnterSelected_list is called when production selected_list is entered. +func (s *BasePlSqlParserListener) EnterSelected_list(ctx *Selected_listContext) {} + +// ExitSelected_list is called when production selected_list is exited. +func (s *BasePlSqlParserListener) ExitSelected_list(ctx *Selected_listContext) {} + +// EnterFrom_clause is called when production from_clause is entered. +func (s *BasePlSqlParserListener) EnterFrom_clause(ctx *From_clauseContext) {} + +// ExitFrom_clause is called when production from_clause is exited. +func (s *BasePlSqlParserListener) ExitFrom_clause(ctx *From_clauseContext) {} + +// EnterSelect_list_elements is called when production select_list_elements is entered. +func (s *BasePlSqlParserListener) EnterSelect_list_elements(ctx *Select_list_elementsContext) {} + +// ExitSelect_list_elements is called when production select_list_elements is exited. +func (s *BasePlSqlParserListener) ExitSelect_list_elements(ctx *Select_list_elementsContext) {} + +// EnterTable_ref_list is called when production table_ref_list is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_list(ctx *Table_ref_listContext) {} + +// ExitTable_ref_list is called when production table_ref_list is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_list(ctx *Table_ref_listContext) {} + +// EnterTable_ref is called when production table_ref is entered. +func (s *BasePlSqlParserListener) EnterTable_ref(ctx *Table_refContext) {} + +// ExitTable_ref is called when production table_ref is exited. +func (s *BasePlSqlParserListener) ExitTable_ref(ctx *Table_refContext) {} + +// EnterTable_ref_aux is called when production table_ref_aux is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux(ctx *Table_ref_auxContext) {} + +// ExitTable_ref_aux is called when production table_ref_aux is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux(ctx *Table_ref_auxContext) {} + +// EnterTable_ref_aux_internal_one is called when production table_ref_aux_internal_one is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) { +} + +// ExitTable_ref_aux_internal_one is called when production table_ref_aux_internal_one is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) { +} + +// EnterTable_ref_aux_internal_two is called when production table_ref_aux_internal_two is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) { +} + +// ExitTable_ref_aux_internal_two is called when production table_ref_aux_internal_two is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) { +} + +// EnterTable_ref_aux_internal_thre is called when production table_ref_aux_internal_thre is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_thre(ctx *Table_ref_aux_internal_threContext) { +} + +// ExitTable_ref_aux_internal_thre is called when production table_ref_aux_internal_thre is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_thre(ctx *Table_ref_aux_internal_threContext) { +} + +// EnterJoin_clause is called when production join_clause is entered. +func (s *BasePlSqlParserListener) EnterJoin_clause(ctx *Join_clauseContext) {} + +// ExitJoin_clause is called when production join_clause is exited. +func (s *BasePlSqlParserListener) ExitJoin_clause(ctx *Join_clauseContext) {} + +// EnterJoin_on_part is called when production join_on_part is entered. +func (s *BasePlSqlParserListener) EnterJoin_on_part(ctx *Join_on_partContext) {} + +// ExitJoin_on_part is called when production join_on_part is exited. +func (s *BasePlSqlParserListener) ExitJoin_on_part(ctx *Join_on_partContext) {} + +// EnterJoin_using_part is called when production join_using_part is entered. +func (s *BasePlSqlParserListener) EnterJoin_using_part(ctx *Join_using_partContext) {} + +// ExitJoin_using_part is called when production join_using_part is exited. +func (s *BasePlSqlParserListener) ExitJoin_using_part(ctx *Join_using_partContext) {} + +// EnterOuter_join_type is called when production outer_join_type is entered. +func (s *BasePlSqlParserListener) EnterOuter_join_type(ctx *Outer_join_typeContext) {} + +// ExitOuter_join_type is called when production outer_join_type is exited. +func (s *BasePlSqlParserListener) ExitOuter_join_type(ctx *Outer_join_typeContext) {} + +// EnterQuery_partition_clause is called when production query_partition_clause is entered. +func (s *BasePlSqlParserListener) EnterQuery_partition_clause(ctx *Query_partition_clauseContext) {} + +// ExitQuery_partition_clause is called when production query_partition_clause is exited. +func (s *BasePlSqlParserListener) ExitQuery_partition_clause(ctx *Query_partition_clauseContext) {} + +// EnterFlashback_query_clause is called when production flashback_query_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_query_clause(ctx *Flashback_query_clauseContext) {} + +// ExitFlashback_query_clause is called when production flashback_query_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_query_clause(ctx *Flashback_query_clauseContext) {} + +// EnterPivot_clause is called when production pivot_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_clause(ctx *Pivot_clauseContext) {} + +// ExitPivot_clause is called when production pivot_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_clause(ctx *Pivot_clauseContext) {} + +// EnterPivot_element is called when production pivot_element is entered. +func (s *BasePlSqlParserListener) EnterPivot_element(ctx *Pivot_elementContext) {} + +// ExitPivot_element is called when production pivot_element is exited. +func (s *BasePlSqlParserListener) ExitPivot_element(ctx *Pivot_elementContext) {} + +// EnterPivot_for_clause is called when production pivot_for_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_for_clause(ctx *Pivot_for_clauseContext) {} + +// ExitPivot_for_clause is called when production pivot_for_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_for_clause(ctx *Pivot_for_clauseContext) {} + +// EnterPivot_in_clause is called when production pivot_in_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause(ctx *Pivot_in_clauseContext) {} + +// ExitPivot_in_clause is called when production pivot_in_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause(ctx *Pivot_in_clauseContext) {} + +// EnterPivot_in_clause_element is called when production pivot_in_clause_element is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) {} + +// ExitPivot_in_clause_element is called when production pivot_in_clause_element is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) {} + +// EnterPivot_in_clause_elements is called when production pivot_in_clause_elements is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) { +} + +// ExitPivot_in_clause_elements is called when production pivot_in_clause_elements is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) { +} + +// EnterUnpivot_clause is called when production unpivot_clause is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// ExitUnpivot_clause is called when production unpivot_clause is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// EnterUnpivot_in_clause is called when production unpivot_in_clause is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_in_clause(ctx *Unpivot_in_clauseContext) {} + +// ExitUnpivot_in_clause is called when production unpivot_in_clause is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_in_clause(ctx *Unpivot_in_clauseContext) {} + +// EnterUnpivot_in_elements is called when production unpivot_in_elements is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_in_elements(ctx *Unpivot_in_elementsContext) {} + +// ExitUnpivot_in_elements is called when production unpivot_in_elements is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_in_elements(ctx *Unpivot_in_elementsContext) {} + +// EnterHierarchical_query_clause is called when production hierarchical_query_clause is entered. +func (s *BasePlSqlParserListener) EnterHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) { +} + +// ExitHierarchical_query_clause is called when production hierarchical_query_clause is exited. +func (s *BasePlSqlParserListener) ExitHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) { +} + +// EnterStart_part is called when production start_part is entered. +func (s *BasePlSqlParserListener) EnterStart_part(ctx *Start_partContext) {} + +// ExitStart_part is called when production start_part is exited. +func (s *BasePlSqlParserListener) ExitStart_part(ctx *Start_partContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BasePlSqlParserListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BasePlSqlParserListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterGroup_by_elements is called when production group_by_elements is entered. +func (s *BasePlSqlParserListener) EnterGroup_by_elements(ctx *Group_by_elementsContext) {} + +// ExitGroup_by_elements is called when production group_by_elements is exited. +func (s *BasePlSqlParserListener) ExitGroup_by_elements(ctx *Group_by_elementsContext) {} + +// EnterRollup_cube_clause is called when production rollup_cube_clause is entered. +func (s *BasePlSqlParserListener) EnterRollup_cube_clause(ctx *Rollup_cube_clauseContext) {} + +// ExitRollup_cube_clause is called when production rollup_cube_clause is exited. +func (s *BasePlSqlParserListener) ExitRollup_cube_clause(ctx *Rollup_cube_clauseContext) {} + +// EnterGrouping_sets_clause is called when production grouping_sets_clause is entered. +func (s *BasePlSqlParserListener) EnterGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// ExitGrouping_sets_clause is called when production grouping_sets_clause is exited. +func (s *BasePlSqlParserListener) ExitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// EnterGrouping_sets_elements is called when production grouping_sets_elements is entered. +func (s *BasePlSqlParserListener) EnterGrouping_sets_elements(ctx *Grouping_sets_elementsContext) {} + +// ExitGrouping_sets_elements is called when production grouping_sets_elements is exited. +func (s *BasePlSqlParserListener) ExitGrouping_sets_elements(ctx *Grouping_sets_elementsContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BasePlSqlParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BasePlSqlParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterModel_clause is called when production model_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_clause(ctx *Model_clauseContext) {} + +// ExitModel_clause is called when production model_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_clause(ctx *Model_clauseContext) {} + +// EnterCell_reference_options is called when production cell_reference_options is entered. +func (s *BasePlSqlParserListener) EnterCell_reference_options(ctx *Cell_reference_optionsContext) {} + +// ExitCell_reference_options is called when production cell_reference_options is exited. +func (s *BasePlSqlParserListener) ExitCell_reference_options(ctx *Cell_reference_optionsContext) {} + +// EnterReturn_rows_clause is called when production return_rows_clause is entered. +func (s *BasePlSqlParserListener) EnterReturn_rows_clause(ctx *Return_rows_clauseContext) {} + +// ExitReturn_rows_clause is called when production return_rows_clause is exited. +func (s *BasePlSqlParserListener) ExitReturn_rows_clause(ctx *Return_rows_clauseContext) {} + +// EnterReference_model is called when production reference_model is entered. +func (s *BasePlSqlParserListener) EnterReference_model(ctx *Reference_modelContext) {} + +// ExitReference_model is called when production reference_model is exited. +func (s *BasePlSqlParserListener) ExitReference_model(ctx *Reference_modelContext) {} + +// EnterMain_model is called when production main_model is entered. +func (s *BasePlSqlParserListener) EnterMain_model(ctx *Main_modelContext) {} + +// ExitMain_model is called when production main_model is exited. +func (s *BasePlSqlParserListener) ExitMain_model(ctx *Main_modelContext) {} + +// EnterModel_column_clauses is called when production model_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterModel_column_clauses(ctx *Model_column_clausesContext) {} + +// ExitModel_column_clauses is called when production model_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitModel_column_clauses(ctx *Model_column_clausesContext) {} + +// EnterModel_column_partition_part is called when production model_column_partition_part is entered. +func (s *BasePlSqlParserListener) EnterModel_column_partition_part(ctx *Model_column_partition_partContext) { +} + +// ExitModel_column_partition_part is called when production model_column_partition_part is exited. +func (s *BasePlSqlParserListener) ExitModel_column_partition_part(ctx *Model_column_partition_partContext) { +} + +// EnterModel_column_list is called when production model_column_list is entered. +func (s *BasePlSqlParserListener) EnterModel_column_list(ctx *Model_column_listContext) {} + +// ExitModel_column_list is called when production model_column_list is exited. +func (s *BasePlSqlParserListener) ExitModel_column_list(ctx *Model_column_listContext) {} + +// EnterModel_column is called when production model_column is entered. +func (s *BasePlSqlParserListener) EnterModel_column(ctx *Model_columnContext) {} + +// ExitModel_column is called when production model_column is exited. +func (s *BasePlSqlParserListener) ExitModel_column(ctx *Model_columnContext) {} + +// EnterModel_rules_clause is called when production model_rules_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_clause(ctx *Model_rules_clauseContext) {} + +// ExitModel_rules_clause is called when production model_rules_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_clause(ctx *Model_rules_clauseContext) {} + +// EnterModel_rules_part is called when production model_rules_part is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_part(ctx *Model_rules_partContext) {} + +// ExitModel_rules_part is called when production model_rules_part is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_part(ctx *Model_rules_partContext) {} + +// EnterModel_rules_element is called when production model_rules_element is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_element(ctx *Model_rules_elementContext) {} + +// ExitModel_rules_element is called when production model_rules_element is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_element(ctx *Model_rules_elementContext) {} + +// EnterCell_assignment is called when production cell_assignment is entered. +func (s *BasePlSqlParserListener) EnterCell_assignment(ctx *Cell_assignmentContext) {} + +// ExitCell_assignment is called when production cell_assignment is exited. +func (s *BasePlSqlParserListener) ExitCell_assignment(ctx *Cell_assignmentContext) {} + +// EnterModel_iterate_clause is called when production model_iterate_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_iterate_clause(ctx *Model_iterate_clauseContext) {} + +// ExitModel_iterate_clause is called when production model_iterate_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_iterate_clause(ctx *Model_iterate_clauseContext) {} + +// EnterUntil_part is called when production until_part is entered. +func (s *BasePlSqlParserListener) EnterUntil_part(ctx *Until_partContext) {} + +// ExitUntil_part is called when production until_part is exited. +func (s *BasePlSqlParserListener) ExitUntil_part(ctx *Until_partContext) {} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BasePlSqlParserListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BasePlSqlParserListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterOrder_by_elements is called when production order_by_elements is entered. +func (s *BasePlSqlParserListener) EnterOrder_by_elements(ctx *Order_by_elementsContext) {} + +// ExitOrder_by_elements is called when production order_by_elements is exited. +func (s *BasePlSqlParserListener) ExitOrder_by_elements(ctx *Order_by_elementsContext) {} + +// EnterOffset_clause is called when production offset_clause is entered. +func (s *BasePlSqlParserListener) EnterOffset_clause(ctx *Offset_clauseContext) {} + +// ExitOffset_clause is called when production offset_clause is exited. +func (s *BasePlSqlParserListener) ExitOffset_clause(ctx *Offset_clauseContext) {} + +// EnterFetch_clause is called when production fetch_clause is entered. +func (s *BasePlSqlParserListener) EnterFetch_clause(ctx *Fetch_clauseContext) {} + +// ExitFetch_clause is called when production fetch_clause is exited. +func (s *BasePlSqlParserListener) ExitFetch_clause(ctx *Fetch_clauseContext) {} + +// EnterFor_update_clause is called when production for_update_clause is entered. +func (s *BasePlSqlParserListener) EnterFor_update_clause(ctx *For_update_clauseContext) {} + +// ExitFor_update_clause is called when production for_update_clause is exited. +func (s *BasePlSqlParserListener) ExitFor_update_clause(ctx *For_update_clauseContext) {} + +// EnterFor_update_of_part is called when production for_update_of_part is entered. +func (s *BasePlSqlParserListener) EnterFor_update_of_part(ctx *For_update_of_partContext) {} + +// ExitFor_update_of_part is called when production for_update_of_part is exited. +func (s *BasePlSqlParserListener) ExitFor_update_of_part(ctx *For_update_of_partContext) {} + +// EnterFor_update_options is called when production for_update_options is entered. +func (s *BasePlSqlParserListener) EnterFor_update_options(ctx *For_update_optionsContext) {} + +// ExitFor_update_options is called when production for_update_options is exited. +func (s *BasePlSqlParserListener) ExitFor_update_options(ctx *For_update_optionsContext) {} + +// EnterUpdate_statement is called when production update_statement is entered. +func (s *BasePlSqlParserListener) EnterUpdate_statement(ctx *Update_statementContext) {} + +// ExitUpdate_statement is called when production update_statement is exited. +func (s *BasePlSqlParserListener) ExitUpdate_statement(ctx *Update_statementContext) {} + +// EnterUpdate_set_clause is called when production update_set_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_set_clause(ctx *Update_set_clauseContext) {} + +// ExitUpdate_set_clause is called when production update_set_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_set_clause(ctx *Update_set_clauseContext) {} + +// EnterColumn_based_update_set_clause is called when production column_based_update_set_clause is entered. +func (s *BasePlSqlParserListener) EnterColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) { +} + +// ExitColumn_based_update_set_clause is called when production column_based_update_set_clause is exited. +func (s *BasePlSqlParserListener) ExitColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) { +} + +// EnterDelete_statement is called when production delete_statement is entered. +func (s *BasePlSqlParserListener) EnterDelete_statement(ctx *Delete_statementContext) {} + +// ExitDelete_statement is called when production delete_statement is exited. +func (s *BasePlSqlParserListener) ExitDelete_statement(ctx *Delete_statementContext) {} + +// EnterInsert_statement is called when production insert_statement is entered. +func (s *BasePlSqlParserListener) EnterInsert_statement(ctx *Insert_statementContext) {} + +// ExitInsert_statement is called when production insert_statement is exited. +func (s *BasePlSqlParserListener) ExitInsert_statement(ctx *Insert_statementContext) {} + +// EnterSingle_table_insert is called when production single_table_insert is entered. +func (s *BasePlSqlParserListener) EnterSingle_table_insert(ctx *Single_table_insertContext) {} + +// ExitSingle_table_insert is called when production single_table_insert is exited. +func (s *BasePlSqlParserListener) ExitSingle_table_insert(ctx *Single_table_insertContext) {} + +// EnterMulti_table_insert is called when production multi_table_insert is entered. +func (s *BasePlSqlParserListener) EnterMulti_table_insert(ctx *Multi_table_insertContext) {} + +// ExitMulti_table_insert is called when production multi_table_insert is exited. +func (s *BasePlSqlParserListener) ExitMulti_table_insert(ctx *Multi_table_insertContext) {} + +// EnterMulti_table_element is called when production multi_table_element is entered. +func (s *BasePlSqlParserListener) EnterMulti_table_element(ctx *Multi_table_elementContext) {} + +// ExitMulti_table_element is called when production multi_table_element is exited. +func (s *BasePlSqlParserListener) ExitMulti_table_element(ctx *Multi_table_elementContext) {} + +// EnterConditional_insert_clause is called when production conditional_insert_clause is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_clause(ctx *Conditional_insert_clauseContext) { +} + +// ExitConditional_insert_clause is called when production conditional_insert_clause is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_clause(ctx *Conditional_insert_clauseContext) { +} + +// EnterConditional_insert_when_part is called when production conditional_insert_when_part is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_when_part(ctx *Conditional_insert_when_partContext) { +} + +// ExitConditional_insert_when_part is called when production conditional_insert_when_part is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_when_part(ctx *Conditional_insert_when_partContext) { +} + +// EnterConditional_insert_else_part is called when production conditional_insert_else_part is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_else_part(ctx *Conditional_insert_else_partContext) { +} + +// ExitConditional_insert_else_part is called when production conditional_insert_else_part is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_else_part(ctx *Conditional_insert_else_partContext) { +} + +// EnterInsert_into_clause is called when production insert_into_clause is entered. +func (s *BasePlSqlParserListener) EnterInsert_into_clause(ctx *Insert_into_clauseContext) {} + +// ExitInsert_into_clause is called when production insert_into_clause is exited. +func (s *BasePlSqlParserListener) ExitInsert_into_clause(ctx *Insert_into_clauseContext) {} + +// EnterValues_clause is called when production values_clause is entered. +func (s *BasePlSqlParserListener) EnterValues_clause(ctx *Values_clauseContext) {} + +// ExitValues_clause is called when production values_clause is exited. +func (s *BasePlSqlParserListener) ExitValues_clause(ctx *Values_clauseContext) {} + +// EnterMerge_statement is called when production merge_statement is entered. +func (s *BasePlSqlParserListener) EnterMerge_statement(ctx *Merge_statementContext) {} + +// ExitMerge_statement is called when production merge_statement is exited. +func (s *BasePlSqlParserListener) ExitMerge_statement(ctx *Merge_statementContext) {} + +// EnterMerge_update_clause is called when production merge_update_clause is entered. +func (s *BasePlSqlParserListener) EnterMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// ExitMerge_update_clause is called when production merge_update_clause is exited. +func (s *BasePlSqlParserListener) ExitMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// EnterMerge_element is called when production merge_element is entered. +func (s *BasePlSqlParserListener) EnterMerge_element(ctx *Merge_elementContext) {} + +// ExitMerge_element is called when production merge_element is exited. +func (s *BasePlSqlParserListener) ExitMerge_element(ctx *Merge_elementContext) {} + +// EnterMerge_update_delete_part is called when production merge_update_delete_part is entered. +func (s *BasePlSqlParserListener) EnterMerge_update_delete_part(ctx *Merge_update_delete_partContext) { +} + +// ExitMerge_update_delete_part is called when production merge_update_delete_part is exited. +func (s *BasePlSqlParserListener) ExitMerge_update_delete_part(ctx *Merge_update_delete_partContext) { +} + +// EnterMerge_insert_clause is called when production merge_insert_clause is entered. +func (s *BasePlSqlParserListener) EnterMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// ExitMerge_insert_clause is called when production merge_insert_clause is exited. +func (s *BasePlSqlParserListener) ExitMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// EnterSelected_tableview is called when production selected_tableview is entered. +func (s *BasePlSqlParserListener) EnterSelected_tableview(ctx *Selected_tableviewContext) {} + +// ExitSelected_tableview is called when production selected_tableview is exited. +func (s *BasePlSqlParserListener) ExitSelected_tableview(ctx *Selected_tableviewContext) {} + +// EnterLock_table_statement is called when production lock_table_statement is entered. +func (s *BasePlSqlParserListener) EnterLock_table_statement(ctx *Lock_table_statementContext) {} + +// ExitLock_table_statement is called when production lock_table_statement is exited. +func (s *BasePlSqlParserListener) ExitLock_table_statement(ctx *Lock_table_statementContext) {} + +// EnterWait_nowait_part is called when production wait_nowait_part is entered. +func (s *BasePlSqlParserListener) EnterWait_nowait_part(ctx *Wait_nowait_partContext) {} + +// ExitWait_nowait_part is called when production wait_nowait_part is exited. +func (s *BasePlSqlParserListener) ExitWait_nowait_part(ctx *Wait_nowait_partContext) {} + +// EnterLock_table_element is called when production lock_table_element is entered. +func (s *BasePlSqlParserListener) EnterLock_table_element(ctx *Lock_table_elementContext) {} + +// ExitLock_table_element is called when production lock_table_element is exited. +func (s *BasePlSqlParserListener) ExitLock_table_element(ctx *Lock_table_elementContext) {} + +// EnterLock_mode is called when production lock_mode is entered. +func (s *BasePlSqlParserListener) EnterLock_mode(ctx *Lock_modeContext) {} + +// ExitLock_mode is called when production lock_mode is exited. +func (s *BasePlSqlParserListener) ExitLock_mode(ctx *Lock_modeContext) {} + +// EnterGeneral_table_ref is called when production general_table_ref is entered. +func (s *BasePlSqlParserListener) EnterGeneral_table_ref(ctx *General_table_refContext) {} + +// ExitGeneral_table_ref is called when production general_table_ref is exited. +func (s *BasePlSqlParserListener) ExitGeneral_table_ref(ctx *General_table_refContext) {} + +// EnterStatic_returning_clause is called when production static_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterStatic_returning_clause(ctx *Static_returning_clauseContext) {} + +// ExitStatic_returning_clause is called when production static_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitStatic_returning_clause(ctx *Static_returning_clauseContext) {} + +// EnterError_logging_clause is called when production error_logging_clause is entered. +func (s *BasePlSqlParserListener) EnterError_logging_clause(ctx *Error_logging_clauseContext) {} + +// ExitError_logging_clause is called when production error_logging_clause is exited. +func (s *BasePlSqlParserListener) ExitError_logging_clause(ctx *Error_logging_clauseContext) {} + +// EnterError_logging_into_part is called when production error_logging_into_part is entered. +func (s *BasePlSqlParserListener) EnterError_logging_into_part(ctx *Error_logging_into_partContext) {} + +// ExitError_logging_into_part is called when production error_logging_into_part is exited. +func (s *BasePlSqlParserListener) ExitError_logging_into_part(ctx *Error_logging_into_partContext) {} + +// EnterError_logging_reject_part is called when production error_logging_reject_part is entered. +func (s *BasePlSqlParserListener) EnterError_logging_reject_part(ctx *Error_logging_reject_partContext) { +} + +// ExitError_logging_reject_part is called when production error_logging_reject_part is exited. +func (s *BasePlSqlParserListener) ExitError_logging_reject_part(ctx *Error_logging_reject_partContext) { +} + +// EnterDml_table_expression_clause is called when production dml_table_expression_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) { +} + +// ExitDml_table_expression_clause is called when production dml_table_expression_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) { +} + +// EnterTable_collection_expression is called when production table_collection_expression is entered. +func (s *BasePlSqlParserListener) EnterTable_collection_expression(ctx *Table_collection_expressionContext) { +} + +// ExitTable_collection_expression is called when production table_collection_expression is exited. +func (s *BasePlSqlParserListener) ExitTable_collection_expression(ctx *Table_collection_expressionContext) { +} + +// EnterSubquery_restriction_clause is called when production subquery_restriction_clause is entered. +func (s *BasePlSqlParserListener) EnterSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) { +} + +// ExitSubquery_restriction_clause is called when production subquery_restriction_clause is exited. +func (s *BasePlSqlParserListener) ExitSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) { +} + +// EnterSample_clause is called when production sample_clause is entered. +func (s *BasePlSqlParserListener) EnterSample_clause(ctx *Sample_clauseContext) {} + +// ExitSample_clause is called when production sample_clause is exited. +func (s *BasePlSqlParserListener) ExitSample_clause(ctx *Sample_clauseContext) {} + +// EnterSeed_part is called when production seed_part is entered. +func (s *BasePlSqlParserListener) EnterSeed_part(ctx *Seed_partContext) {} + +// ExitSeed_part is called when production seed_part is exited. +func (s *BasePlSqlParserListener) ExitSeed_part(ctx *Seed_partContext) {} + +// EnterCondition is called when production condition is entered. +func (s *BasePlSqlParserListener) EnterCondition(ctx *ConditionContext) {} + +// ExitCondition is called when production condition is exited. +func (s *BasePlSqlParserListener) ExitCondition(ctx *ConditionContext) {} + +// EnterExpressions_ is called when production expressions_ is entered. +func (s *BasePlSqlParserListener) EnterExpressions_(ctx *Expressions_Context) {} + +// ExitExpressions_ is called when production expressions_ is exited. +func (s *BasePlSqlParserListener) ExitExpressions_(ctx *Expressions_Context) {} + +// EnterExpression is called when production expression is entered. +func (s *BasePlSqlParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BasePlSqlParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterCursor_expression is called when production cursor_expression is entered. +func (s *BasePlSqlParserListener) EnterCursor_expression(ctx *Cursor_expressionContext) {} + +// ExitCursor_expression is called when production cursor_expression is exited. +func (s *BasePlSqlParserListener) ExitCursor_expression(ctx *Cursor_expressionContext) {} + +// EnterLogical_expression is called when production logical_expression is entered. +func (s *BasePlSqlParserListener) EnterLogical_expression(ctx *Logical_expressionContext) {} + +// ExitLogical_expression is called when production logical_expression is exited. +func (s *BasePlSqlParserListener) ExitLogical_expression(ctx *Logical_expressionContext) {} + +// EnterUnary_logical_expression is called when production unary_logical_expression is entered. +func (s *BasePlSqlParserListener) EnterUnary_logical_expression(ctx *Unary_logical_expressionContext) { +} + +// ExitUnary_logical_expression is called when production unary_logical_expression is exited. +func (s *BasePlSqlParserListener) ExitUnary_logical_expression(ctx *Unary_logical_expressionContext) { +} + +// EnterUnary_logical_operation is called when production unary_logical_operation is entered. +func (s *BasePlSqlParserListener) EnterUnary_logical_operation(ctx *Unary_logical_operationContext) {} + +// ExitUnary_logical_operation is called when production unary_logical_operation is exited. +func (s *BasePlSqlParserListener) ExitUnary_logical_operation(ctx *Unary_logical_operationContext) {} + +// EnterLogical_operation is called when production logical_operation is entered. +func (s *BasePlSqlParserListener) EnterLogical_operation(ctx *Logical_operationContext) {} + +// ExitLogical_operation is called when production logical_operation is exited. +func (s *BasePlSqlParserListener) ExitLogical_operation(ctx *Logical_operationContext) {} + +// EnterMultiset_expression is called when production multiset_expression is entered. +func (s *BasePlSqlParserListener) EnterMultiset_expression(ctx *Multiset_expressionContext) {} + +// ExitMultiset_expression is called when production multiset_expression is exited. +func (s *BasePlSqlParserListener) ExitMultiset_expression(ctx *Multiset_expressionContext) {} + +// EnterRelational_expression is called when production relational_expression is entered. +func (s *BasePlSqlParserListener) EnterRelational_expression(ctx *Relational_expressionContext) {} + +// ExitRelational_expression is called when production relational_expression is exited. +func (s *BasePlSqlParserListener) ExitRelational_expression(ctx *Relational_expressionContext) {} + +// EnterCompound_expression is called when production compound_expression is entered. +func (s *BasePlSqlParserListener) EnterCompound_expression(ctx *Compound_expressionContext) {} + +// ExitCompound_expression is called when production compound_expression is exited. +func (s *BasePlSqlParserListener) ExitCompound_expression(ctx *Compound_expressionContext) {} + +// EnterRelational_operator is called when production relational_operator is entered. +func (s *BasePlSqlParserListener) EnterRelational_operator(ctx *Relational_operatorContext) {} + +// ExitRelational_operator is called when production relational_operator is exited. +func (s *BasePlSqlParserListener) ExitRelational_operator(ctx *Relational_operatorContext) {} + +// EnterIn_elements is called when production in_elements is entered. +func (s *BasePlSqlParserListener) EnterIn_elements(ctx *In_elementsContext) {} + +// ExitIn_elements is called when production in_elements is exited. +func (s *BasePlSqlParserListener) ExitIn_elements(ctx *In_elementsContext) {} + +// EnterBetween_elements is called when production between_elements is entered. +func (s *BasePlSqlParserListener) EnterBetween_elements(ctx *Between_elementsContext) {} + +// ExitBetween_elements is called when production between_elements is exited. +func (s *BasePlSqlParserListener) ExitBetween_elements(ctx *Between_elementsContext) {} + +// EnterConcatenation is called when production concatenation is entered. +func (s *BasePlSqlParserListener) EnterConcatenation(ctx *ConcatenationContext) {} + +// ExitConcatenation is called when production concatenation is exited. +func (s *BasePlSqlParserListener) ExitConcatenation(ctx *ConcatenationContext) {} + +// EnterInterval_expression is called when production interval_expression is entered. +func (s *BasePlSqlParserListener) EnterInterval_expression(ctx *Interval_expressionContext) {} + +// ExitInterval_expression is called when production interval_expression is exited. +func (s *BasePlSqlParserListener) ExitInterval_expression(ctx *Interval_expressionContext) {} + +// EnterModel_expression is called when production model_expression is entered. +func (s *BasePlSqlParserListener) EnterModel_expression(ctx *Model_expressionContext) {} + +// ExitModel_expression is called when production model_expression is exited. +func (s *BasePlSqlParserListener) ExitModel_expression(ctx *Model_expressionContext) {} + +// EnterModel_expression_element is called when production model_expression_element is entered. +func (s *BasePlSqlParserListener) EnterModel_expression_element(ctx *Model_expression_elementContext) { +} + +// ExitModel_expression_element is called when production model_expression_element is exited. +func (s *BasePlSqlParserListener) ExitModel_expression_element(ctx *Model_expression_elementContext) { +} + +// EnterSingle_column_for_loop is called when production single_column_for_loop is entered. +func (s *BasePlSqlParserListener) EnterSingle_column_for_loop(ctx *Single_column_for_loopContext) {} + +// ExitSingle_column_for_loop is called when production single_column_for_loop is exited. +func (s *BasePlSqlParserListener) ExitSingle_column_for_loop(ctx *Single_column_for_loopContext) {} + +// EnterMulti_column_for_loop is called when production multi_column_for_loop is entered. +func (s *BasePlSqlParserListener) EnterMulti_column_for_loop(ctx *Multi_column_for_loopContext) {} + +// ExitMulti_column_for_loop is called when production multi_column_for_loop is exited. +func (s *BasePlSqlParserListener) ExitMulti_column_for_loop(ctx *Multi_column_for_loopContext) {} + +// EnterUnary_expression is called when production unary_expression is entered. +func (s *BasePlSqlParserListener) EnterUnary_expression(ctx *Unary_expressionContext) {} + +// ExitUnary_expression is called when production unary_expression is exited. +func (s *BasePlSqlParserListener) ExitUnary_expression(ctx *Unary_expressionContext) {} + +// EnterUnary_expression_core is called when production unary_expression_core is entered. +func (s *BasePlSqlParserListener) EnterUnary_expression_core(ctx *Unary_expression_coreContext) {} + +// ExitUnary_expression_core is called when production unary_expression_core is exited. +func (s *BasePlSqlParserListener) ExitUnary_expression_core(ctx *Unary_expression_coreContext) {} + +// EnterImplicit_cursor_expression is called when production implicit_cursor_expression is entered. +func (s *BasePlSqlParserListener) EnterImplicit_cursor_expression(ctx *Implicit_cursor_expressionContext) { +} + +// ExitImplicit_cursor_expression is called when production implicit_cursor_expression is exited. +func (s *BasePlSqlParserListener) ExitImplicit_cursor_expression(ctx *Implicit_cursor_expressionContext) { +} + +// EnterCollection_expression is called when production collection_expression is entered. +func (s *BasePlSqlParserListener) EnterCollection_expression(ctx *Collection_expressionContext) {} + +// ExitCollection_expression is called when production collection_expression is exited. +func (s *BasePlSqlParserListener) ExitCollection_expression(ctx *Collection_expressionContext) {} + +// EnterCase_statement is called when production case_statement is entered. +func (s *BasePlSqlParserListener) EnterCase_statement(ctx *Case_statementContext) {} + +// ExitCase_statement is called when production case_statement is exited. +func (s *BasePlSqlParserListener) ExitCase_statement(ctx *Case_statementContext) {} + +// EnterSimple_case_statement is called when production simple_case_statement is entered. +func (s *BasePlSqlParserListener) EnterSimple_case_statement(ctx *Simple_case_statementContext) {} + +// ExitSimple_case_statement is called when production simple_case_statement is exited. +func (s *BasePlSqlParserListener) ExitSimple_case_statement(ctx *Simple_case_statementContext) {} + +// EnterSearched_case_statement is called when production searched_case_statement is entered. +func (s *BasePlSqlParserListener) EnterSearched_case_statement(ctx *Searched_case_statementContext) {} + +// ExitSearched_case_statement is called when production searched_case_statement is exited. +func (s *BasePlSqlParserListener) ExitSearched_case_statement(ctx *Searched_case_statementContext) {} + +// EnterCase_when_part_statement is called when production case_when_part_statement is entered. +func (s *BasePlSqlParserListener) EnterCase_when_part_statement(ctx *Case_when_part_statementContext) { +} + +// ExitCase_when_part_statement is called when production case_when_part_statement is exited. +func (s *BasePlSqlParserListener) ExitCase_when_part_statement(ctx *Case_when_part_statementContext) { +} + +// EnterCase_else_part_statement is called when production case_else_part_statement is entered. +func (s *BasePlSqlParserListener) EnterCase_else_part_statement(ctx *Case_else_part_statementContext) { +} + +// ExitCase_else_part_statement is called when production case_else_part_statement is exited. +func (s *BasePlSqlParserListener) ExitCase_else_part_statement(ctx *Case_else_part_statementContext) { +} + +// EnterCase_expression is called when production case_expression is entered. +func (s *BasePlSqlParserListener) EnterCase_expression(ctx *Case_expressionContext) {} + +// ExitCase_expression is called when production case_expression is exited. +func (s *BasePlSqlParserListener) ExitCase_expression(ctx *Case_expressionContext) {} + +// EnterSimple_case_expression is called when production simple_case_expression is entered. +func (s *BasePlSqlParserListener) EnterSimple_case_expression(ctx *Simple_case_expressionContext) {} + +// ExitSimple_case_expression is called when production simple_case_expression is exited. +func (s *BasePlSqlParserListener) ExitSimple_case_expression(ctx *Simple_case_expressionContext) {} + +// EnterSearched_case_expression is called when production searched_case_expression is entered. +func (s *BasePlSqlParserListener) EnterSearched_case_expression(ctx *Searched_case_expressionContext) { +} + +// ExitSearched_case_expression is called when production searched_case_expression is exited. +func (s *BasePlSqlParserListener) ExitSearched_case_expression(ctx *Searched_case_expressionContext) { +} + +// EnterCase_when_part_expression is called when production case_when_part_expression is entered. +func (s *BasePlSqlParserListener) EnterCase_when_part_expression(ctx *Case_when_part_expressionContext) { +} + +// ExitCase_when_part_expression is called when production case_when_part_expression is exited. +func (s *BasePlSqlParserListener) ExitCase_when_part_expression(ctx *Case_when_part_expressionContext) { +} + +// EnterCase_else_part_expression is called when production case_else_part_expression is entered. +func (s *BasePlSqlParserListener) EnterCase_else_part_expression(ctx *Case_else_part_expressionContext) { +} + +// ExitCase_else_part_expression is called when production case_else_part_expression is exited. +func (s *BasePlSqlParserListener) ExitCase_else_part_expression(ctx *Case_else_part_expressionContext) { +} + +// EnterAtom is called when production atom is entered. +func (s *BasePlSqlParserListener) EnterAtom(ctx *AtomContext) {} + +// ExitAtom is called when production atom is exited. +func (s *BasePlSqlParserListener) ExitAtom(ctx *AtomContext) {} + +// EnterQuantified_expression is called when production quantified_expression is entered. +func (s *BasePlSqlParserListener) EnterQuantified_expression(ctx *Quantified_expressionContext) {} + +// ExitQuantified_expression is called when production quantified_expression is exited. +func (s *BasePlSqlParserListener) ExitQuantified_expression(ctx *Quantified_expressionContext) {} + +// EnterString_function is called when production string_function is entered. +func (s *BasePlSqlParserListener) EnterString_function(ctx *String_functionContext) {} + +// ExitString_function is called when production string_function is exited. +func (s *BasePlSqlParserListener) ExitString_function(ctx *String_functionContext) {} + +// EnterStandard_function is called when production standard_function is entered. +func (s *BasePlSqlParserListener) EnterStandard_function(ctx *Standard_functionContext) {} + +// ExitStandard_function is called when production standard_function is exited. +func (s *BasePlSqlParserListener) ExitStandard_function(ctx *Standard_functionContext) {} + +// EnterJson_function is called when production json_function is entered. +func (s *BasePlSqlParserListener) EnterJson_function(ctx *Json_functionContext) {} + +// ExitJson_function is called when production json_function is exited. +func (s *BasePlSqlParserListener) ExitJson_function(ctx *Json_functionContext) {} + +// EnterJson_object_content is called when production json_object_content is entered. +func (s *BasePlSqlParserListener) EnterJson_object_content(ctx *Json_object_contentContext) {} + +// ExitJson_object_content is called when production json_object_content is exited. +func (s *BasePlSqlParserListener) ExitJson_object_content(ctx *Json_object_contentContext) {} + +// EnterJson_object_entry is called when production json_object_entry is entered. +func (s *BasePlSqlParserListener) EnterJson_object_entry(ctx *Json_object_entryContext) {} + +// ExitJson_object_entry is called when production json_object_entry is exited. +func (s *BasePlSqlParserListener) ExitJson_object_entry(ctx *Json_object_entryContext) {} + +// EnterJson_table_clause is called when production json_table_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_table_clause(ctx *Json_table_clauseContext) {} + +// ExitJson_table_clause is called when production json_table_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_table_clause(ctx *Json_table_clauseContext) {} + +// EnterJson_array_element is called when production json_array_element is entered. +func (s *BasePlSqlParserListener) EnterJson_array_element(ctx *Json_array_elementContext) {} + +// ExitJson_array_element is called when production json_array_element is exited. +func (s *BasePlSqlParserListener) ExitJson_array_element(ctx *Json_array_elementContext) {} + +// EnterJson_on_null_clause is called when production json_on_null_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_on_null_clause(ctx *Json_on_null_clauseContext) {} + +// ExitJson_on_null_clause is called when production json_on_null_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_on_null_clause(ctx *Json_on_null_clauseContext) {} + +// EnterJson_return_clause is called when production json_return_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_return_clause(ctx *Json_return_clauseContext) {} + +// ExitJson_return_clause is called when production json_return_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_return_clause(ctx *Json_return_clauseContext) {} + +// EnterJson_transform_op is called when production json_transform_op is entered. +func (s *BasePlSqlParserListener) EnterJson_transform_op(ctx *Json_transform_opContext) {} + +// ExitJson_transform_op is called when production json_transform_op is exited. +func (s *BasePlSqlParserListener) ExitJson_transform_op(ctx *Json_transform_opContext) {} + +// EnterJson_column_clause is called when production json_column_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_column_clause(ctx *Json_column_clauseContext) {} + +// ExitJson_column_clause is called when production json_column_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_column_clause(ctx *Json_column_clauseContext) {} + +// EnterJson_column_definition is called when production json_column_definition is entered. +func (s *BasePlSqlParserListener) EnterJson_column_definition(ctx *Json_column_definitionContext) {} + +// ExitJson_column_definition is called when production json_column_definition is exited. +func (s *BasePlSqlParserListener) ExitJson_column_definition(ctx *Json_column_definitionContext) {} + +// EnterJson_query_returning_clause is called when production json_query_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_returning_clause(ctx *Json_query_returning_clauseContext) { +} + +// ExitJson_query_returning_clause is called when production json_query_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_returning_clause(ctx *Json_query_returning_clauseContext) { +} + +// EnterJson_query_return_type is called when production json_query_return_type is entered. +func (s *BasePlSqlParserListener) EnterJson_query_return_type(ctx *Json_query_return_typeContext) {} + +// ExitJson_query_return_type is called when production json_query_return_type is exited. +func (s *BasePlSqlParserListener) ExitJson_query_return_type(ctx *Json_query_return_typeContext) {} + +// EnterJson_query_wrapper_clause is called when production json_query_wrapper_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) { +} + +// ExitJson_query_wrapper_clause is called when production json_query_wrapper_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) { +} + +// EnterJson_query_on_error_clause is called when production json_query_on_error_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) { +} + +// ExitJson_query_on_error_clause is called when production json_query_on_error_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) { +} + +// EnterJson_query_on_empty_clause is called when production json_query_on_empty_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) { +} + +// ExitJson_query_on_empty_clause is called when production json_query_on_empty_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) { +} + +// EnterJson_value_return_clause is called when production json_value_return_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_value_return_clause(ctx *Json_value_return_clauseContext) { +} + +// ExitJson_value_return_clause is called when production json_value_return_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_value_return_clause(ctx *Json_value_return_clauseContext) { +} + +// EnterJson_value_return_type is called when production json_value_return_type is entered. +func (s *BasePlSqlParserListener) EnterJson_value_return_type(ctx *Json_value_return_typeContext) {} + +// ExitJson_value_return_type is called when production json_value_return_type is exited. +func (s *BasePlSqlParserListener) ExitJson_value_return_type(ctx *Json_value_return_typeContext) {} + +// EnterJson_value_on_mismatch_clause is called when production json_value_on_mismatch_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) { +} + +// ExitJson_value_on_mismatch_clause is called when production json_value_on_mismatch_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) { +} + +// EnterLiteral is called when production literal is entered. +func (s *BasePlSqlParserListener) EnterLiteral(ctx *LiteralContext) {} + +// ExitLiteral is called when production literal is exited. +func (s *BasePlSqlParserListener) ExitLiteral(ctx *LiteralContext) {} + +// EnterNumeric_function_wrapper is called when production numeric_function_wrapper is entered. +func (s *BasePlSqlParserListener) EnterNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) { +} + +// ExitNumeric_function_wrapper is called when production numeric_function_wrapper is exited. +func (s *BasePlSqlParserListener) ExitNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) { +} + +// EnterNumeric_function is called when production numeric_function is entered. +func (s *BasePlSqlParserListener) EnterNumeric_function(ctx *Numeric_functionContext) {} + +// ExitNumeric_function is called when production numeric_function is exited. +func (s *BasePlSqlParserListener) ExitNumeric_function(ctx *Numeric_functionContext) {} + +// EnterListagg_overflow_clause is called when production listagg_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) {} + +// ExitListagg_overflow_clause is called when production listagg_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) {} + +// EnterOther_function is called when production other_function is entered. +func (s *BasePlSqlParserListener) EnterOther_function(ctx *Other_functionContext) {} + +// ExitOther_function is called when production other_function is exited. +func (s *BasePlSqlParserListener) ExitOther_function(ctx *Other_functionContext) {} + +// EnterOver_clause_keyword is called when production over_clause_keyword is entered. +func (s *BasePlSqlParserListener) EnterOver_clause_keyword(ctx *Over_clause_keywordContext) {} + +// ExitOver_clause_keyword is called when production over_clause_keyword is exited. +func (s *BasePlSqlParserListener) ExitOver_clause_keyword(ctx *Over_clause_keywordContext) {} + +// EnterWithin_or_over_clause_keyword is called when production within_or_over_clause_keyword is entered. +func (s *BasePlSqlParserListener) EnterWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) { +} + +// ExitWithin_or_over_clause_keyword is called when production within_or_over_clause_keyword is exited. +func (s *BasePlSqlParserListener) ExitWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) { +} + +// EnterStandard_prediction_function_keyword is called when production standard_prediction_function_keyword is entered. +func (s *BasePlSqlParserListener) EnterStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) { +} + +// ExitStandard_prediction_function_keyword is called when production standard_prediction_function_keyword is exited. +func (s *BasePlSqlParserListener) ExitStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) { +} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BasePlSqlParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BasePlSqlParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterWindowing_clause is called when production windowing_clause is entered. +func (s *BasePlSqlParserListener) EnterWindowing_clause(ctx *Windowing_clauseContext) {} + +// ExitWindowing_clause is called when production windowing_clause is exited. +func (s *BasePlSqlParserListener) ExitWindowing_clause(ctx *Windowing_clauseContext) {} + +// EnterWindowing_type is called when production windowing_type is entered. +func (s *BasePlSqlParserListener) EnterWindowing_type(ctx *Windowing_typeContext) {} + +// ExitWindowing_type is called when production windowing_type is exited. +func (s *BasePlSqlParserListener) ExitWindowing_type(ctx *Windowing_typeContext) {} + +// EnterWindowing_elements is called when production windowing_elements is entered. +func (s *BasePlSqlParserListener) EnterWindowing_elements(ctx *Windowing_elementsContext) {} + +// ExitWindowing_elements is called when production windowing_elements is exited. +func (s *BasePlSqlParserListener) ExitWindowing_elements(ctx *Windowing_elementsContext) {} + +// EnterUsing_clause is called when production using_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_clause(ctx *Using_clauseContext) {} + +// ExitUsing_clause is called when production using_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_clause(ctx *Using_clauseContext) {} + +// EnterUsing_element is called when production using_element is entered. +func (s *BasePlSqlParserListener) EnterUsing_element(ctx *Using_elementContext) {} + +// ExitUsing_element is called when production using_element is exited. +func (s *BasePlSqlParserListener) ExitUsing_element(ctx *Using_elementContext) {} + +// EnterAssignable_element is called when production assignable_element is entered. +func (s *BasePlSqlParserListener) EnterAssignable_element(ctx *Assignable_elementContext) {} + +// ExitAssignable_element is called when production assignable_element is exited. +func (s *BasePlSqlParserListener) ExitAssignable_element(ctx *Assignable_elementContext) {} + +// EnterCollect_order_by_part is called when production collect_order_by_part is entered. +func (s *BasePlSqlParserListener) EnterCollect_order_by_part(ctx *Collect_order_by_partContext) {} + +// ExitCollect_order_by_part is called when production collect_order_by_part is exited. +func (s *BasePlSqlParserListener) ExitCollect_order_by_part(ctx *Collect_order_by_partContext) {} + +// EnterWithin_or_over_part is called when production within_or_over_part is entered. +func (s *BasePlSqlParserListener) EnterWithin_or_over_part(ctx *Within_or_over_partContext) {} + +// ExitWithin_or_over_part is called when production within_or_over_part is exited. +func (s *BasePlSqlParserListener) ExitWithin_or_over_part(ctx *Within_or_over_partContext) {} + +// EnterString_delimiter is called when production string_delimiter is entered. +func (s *BasePlSqlParserListener) EnterString_delimiter(ctx *String_delimiterContext) {} + +// ExitString_delimiter is called when production string_delimiter is exited. +func (s *BasePlSqlParserListener) ExitString_delimiter(ctx *String_delimiterContext) {} + +// EnterCost_matrix_clause is called when production cost_matrix_clause is entered. +func (s *BasePlSqlParserListener) EnterCost_matrix_clause(ctx *Cost_matrix_clauseContext) {} + +// ExitCost_matrix_clause is called when production cost_matrix_clause is exited. +func (s *BasePlSqlParserListener) ExitCost_matrix_clause(ctx *Cost_matrix_clauseContext) {} + +// EnterXml_passing_clause is called when production xml_passing_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_passing_clause(ctx *Xml_passing_clauseContext) {} + +// ExitXml_passing_clause is called when production xml_passing_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_passing_clause(ctx *Xml_passing_clauseContext) {} + +// EnterXml_attributes_clause is called when production xml_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_attributes_clause(ctx *Xml_attributes_clauseContext) {} + +// ExitXml_attributes_clause is called when production xml_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_attributes_clause(ctx *Xml_attributes_clauseContext) {} + +// EnterXml_namespaces_clause is called when production xml_namespaces_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) {} + +// ExitXml_namespaces_clause is called when production xml_namespaces_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) {} + +// EnterXml_table_column is called when production xml_table_column is entered. +func (s *BasePlSqlParserListener) EnterXml_table_column(ctx *Xml_table_columnContext) {} + +// ExitXml_table_column is called when production xml_table_column is exited. +func (s *BasePlSqlParserListener) ExitXml_table_column(ctx *Xml_table_columnContext) {} + +// EnterXml_general_default_part is called when production xml_general_default_part is entered. +func (s *BasePlSqlParserListener) EnterXml_general_default_part(ctx *Xml_general_default_partContext) { +} + +// ExitXml_general_default_part is called when production xml_general_default_part is exited. +func (s *BasePlSqlParserListener) ExitXml_general_default_part(ctx *Xml_general_default_partContext) { +} + +// EnterXml_multiuse_expression_element is called when production xml_multiuse_expression_element is entered. +func (s *BasePlSqlParserListener) EnterXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) { +} + +// ExitXml_multiuse_expression_element is called when production xml_multiuse_expression_element is exited. +func (s *BasePlSqlParserListener) ExitXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) { +} + +// EnterXmlroot_param_version_part is called when production xmlroot_param_version_part is entered. +func (s *BasePlSqlParserListener) EnterXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) { +} + +// ExitXmlroot_param_version_part is called when production xmlroot_param_version_part is exited. +func (s *BasePlSqlParserListener) ExitXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) { +} + +// EnterXmlroot_param_standalone_part is called when production xmlroot_param_standalone_part is entered. +func (s *BasePlSqlParserListener) EnterXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) { +} + +// ExitXmlroot_param_standalone_part is called when production xmlroot_param_standalone_part is exited. +func (s *BasePlSqlParserListener) ExitXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) { +} + +// EnterXmlserialize_param_enconding_part is called when production xmlserialize_param_enconding_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) { +} + +// ExitXmlserialize_param_enconding_part is called when production xmlserialize_param_enconding_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) { +} + +// EnterXmlserialize_param_version_part is called when production xmlserialize_param_version_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) { +} + +// ExitXmlserialize_param_version_part is called when production xmlserialize_param_version_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) { +} + +// EnterXmlserialize_param_ident_part is called when production xmlserialize_param_ident_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) { +} + +// ExitXmlserialize_param_ident_part is called when production xmlserialize_param_ident_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) { +} + +// EnterAnnotations_clause is called when production annotations_clause is entered. +func (s *BasePlSqlParserListener) EnterAnnotations_clause(ctx *Annotations_clauseContext) {} + +// ExitAnnotations_clause is called when production annotations_clause is exited. +func (s *BasePlSqlParserListener) ExitAnnotations_clause(ctx *Annotations_clauseContext) {} + +// EnterAnnotations_list is called when production annotations_list is entered. +func (s *BasePlSqlParserListener) EnterAnnotations_list(ctx *Annotations_listContext) {} + +// ExitAnnotations_list is called when production annotations_list is exited. +func (s *BasePlSqlParserListener) ExitAnnotations_list(ctx *Annotations_listContext) {} + +// EnterAnnotation is called when production annotation is entered. +func (s *BasePlSqlParserListener) EnterAnnotation(ctx *AnnotationContext) {} + +// ExitAnnotation is called when production annotation is exited. +func (s *BasePlSqlParserListener) ExitAnnotation(ctx *AnnotationContext) {} + +// EnterSql_plus_command is called when production sql_plus_command is entered. +func (s *BasePlSqlParserListener) EnterSql_plus_command(ctx *Sql_plus_commandContext) {} + +// ExitSql_plus_command is called when production sql_plus_command is exited. +func (s *BasePlSqlParserListener) ExitSql_plus_command(ctx *Sql_plus_commandContext) {} + +// EnterStart_command is called when production start_command is entered. +func (s *BasePlSqlParserListener) EnterStart_command(ctx *Start_commandContext) {} + +// ExitStart_command is called when production start_command is exited. +func (s *BasePlSqlParserListener) ExitStart_command(ctx *Start_commandContext) {} + +// EnterSql_plus_filepath is called when production sql_plus_filepath is entered. +func (s *BasePlSqlParserListener) EnterSql_plus_filepath(ctx *Sql_plus_filepathContext) {} + +// ExitSql_plus_filepath is called when production sql_plus_filepath is exited. +func (s *BasePlSqlParserListener) ExitSql_plus_filepath(ctx *Sql_plus_filepathContext) {} + +// EnterWhenever_command is called when production whenever_command is entered. +func (s *BasePlSqlParserListener) EnterWhenever_command(ctx *Whenever_commandContext) {} + +// ExitWhenever_command is called when production whenever_command is exited. +func (s *BasePlSqlParserListener) ExitWhenever_command(ctx *Whenever_commandContext) {} + +// EnterSet_command is called when production set_command is entered. +func (s *BasePlSqlParserListener) EnterSet_command(ctx *Set_commandContext) {} + +// ExitSet_command is called when production set_command is exited. +func (s *BasePlSqlParserListener) ExitSet_command(ctx *Set_commandContext) {} + +// EnterTiming_command is called when production timing_command is entered. +func (s *BasePlSqlParserListener) EnterTiming_command(ctx *Timing_commandContext) {} + +// ExitTiming_command is called when production timing_command is exited. +func (s *BasePlSqlParserListener) ExitTiming_command(ctx *Timing_commandContext) {} + +// EnterClear_command is called when production clear_command is entered. +func (s *BasePlSqlParserListener) EnterClear_command(ctx *Clear_commandContext) {} + +// ExitClear_command is called when production clear_command is exited. +func (s *BasePlSqlParserListener) ExitClear_command(ctx *Clear_commandContext) {} + +// EnterPartition_extension_clause is called when production partition_extension_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_extension_clause(ctx *Partition_extension_clauseContext) { +} + +// ExitPartition_extension_clause is called when production partition_extension_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_extension_clause(ctx *Partition_extension_clauseContext) { +} + +// EnterColumn_alias is called when production column_alias is entered. +func (s *BasePlSqlParserListener) EnterColumn_alias(ctx *Column_aliasContext) {} + +// ExitColumn_alias is called when production column_alias is exited. +func (s *BasePlSqlParserListener) ExitColumn_alias(ctx *Column_aliasContext) {} + +// EnterTable_alias is called when production table_alias is entered. +func (s *BasePlSqlParserListener) EnterTable_alias(ctx *Table_aliasContext) {} + +// ExitTable_alias is called when production table_alias is exited. +func (s *BasePlSqlParserListener) ExitTable_alias(ctx *Table_aliasContext) {} + +// EnterWhere_clause is called when production where_clause is entered. +func (s *BasePlSqlParserListener) EnterWhere_clause(ctx *Where_clauseContext) {} + +// ExitWhere_clause is called when production where_clause is exited. +func (s *BasePlSqlParserListener) ExitWhere_clause(ctx *Where_clauseContext) {} + +// EnterInto_clause is called when production into_clause is entered. +func (s *BasePlSqlParserListener) EnterInto_clause(ctx *Into_clauseContext) {} + +// ExitInto_clause is called when production into_clause is exited. +func (s *BasePlSqlParserListener) ExitInto_clause(ctx *Into_clauseContext) {} + +// EnterXml_column_name is called when production xml_column_name is entered. +func (s *BasePlSqlParserListener) EnterXml_column_name(ctx *Xml_column_nameContext) {} + +// ExitXml_column_name is called when production xml_column_name is exited. +func (s *BasePlSqlParserListener) ExitXml_column_name(ctx *Xml_column_nameContext) {} + +// EnterCost_class_name is called when production cost_class_name is entered. +func (s *BasePlSqlParserListener) EnterCost_class_name(ctx *Cost_class_nameContext) {} + +// ExitCost_class_name is called when production cost_class_name is exited. +func (s *BasePlSqlParserListener) ExitCost_class_name(ctx *Cost_class_nameContext) {} + +// EnterAttribute_name is called when production attribute_name is entered. +func (s *BasePlSqlParserListener) EnterAttribute_name(ctx *Attribute_nameContext) {} + +// ExitAttribute_name is called when production attribute_name is exited. +func (s *BasePlSqlParserListener) ExitAttribute_name(ctx *Attribute_nameContext) {} + +// EnterSavepoint_name is called when production savepoint_name is entered. +func (s *BasePlSqlParserListener) EnterSavepoint_name(ctx *Savepoint_nameContext) {} + +// ExitSavepoint_name is called when production savepoint_name is exited. +func (s *BasePlSqlParserListener) ExitSavepoint_name(ctx *Savepoint_nameContext) {} + +// EnterRollback_segment_name is called when production rollback_segment_name is entered. +func (s *BasePlSqlParserListener) EnterRollback_segment_name(ctx *Rollback_segment_nameContext) {} + +// ExitRollback_segment_name is called when production rollback_segment_name is exited. +func (s *BasePlSqlParserListener) ExitRollback_segment_name(ctx *Rollback_segment_nameContext) {} + +// EnterSchema_name is called when production schema_name is entered. +func (s *BasePlSqlParserListener) EnterSchema_name(ctx *Schema_nameContext) {} + +// ExitSchema_name is called when production schema_name is exited. +func (s *BasePlSqlParserListener) ExitSchema_name(ctx *Schema_nameContext) {} + +// EnterRoutine_name is called when production routine_name is entered. +func (s *BasePlSqlParserListener) EnterRoutine_name(ctx *Routine_nameContext) {} + +// ExitRoutine_name is called when production routine_name is exited. +func (s *BasePlSqlParserListener) ExitRoutine_name(ctx *Routine_nameContext) {} + +// EnterPackage_name is called when production package_name is entered. +func (s *BasePlSqlParserListener) EnterPackage_name(ctx *Package_nameContext) {} + +// ExitPackage_name is called when production package_name is exited. +func (s *BasePlSqlParserListener) ExitPackage_name(ctx *Package_nameContext) {} + +// EnterImplementation_type_name is called when production implementation_type_name is entered. +func (s *BasePlSqlParserListener) EnterImplementation_type_name(ctx *Implementation_type_nameContext) { +} + +// ExitImplementation_type_name is called when production implementation_type_name is exited. +func (s *BasePlSqlParserListener) ExitImplementation_type_name(ctx *Implementation_type_nameContext) { +} + +// EnterParameter_name is called when production parameter_name is entered. +func (s *BasePlSqlParserListener) EnterParameter_name(ctx *Parameter_nameContext) {} + +// ExitParameter_name is called when production parameter_name is exited. +func (s *BasePlSqlParserListener) ExitParameter_name(ctx *Parameter_nameContext) {} + +// EnterReference_model_name is called when production reference_model_name is entered. +func (s *BasePlSqlParserListener) EnterReference_model_name(ctx *Reference_model_nameContext) {} + +// ExitReference_model_name is called when production reference_model_name is exited. +func (s *BasePlSqlParserListener) ExitReference_model_name(ctx *Reference_model_nameContext) {} + +// EnterMain_model_name is called when production main_model_name is entered. +func (s *BasePlSqlParserListener) EnterMain_model_name(ctx *Main_model_nameContext) {} + +// ExitMain_model_name is called when production main_model_name is exited. +func (s *BasePlSqlParserListener) ExitMain_model_name(ctx *Main_model_nameContext) {} + +// EnterContainer_tableview_name is called when production container_tableview_name is entered. +func (s *BasePlSqlParserListener) EnterContainer_tableview_name(ctx *Container_tableview_nameContext) { +} + +// ExitContainer_tableview_name is called when production container_tableview_name is exited. +func (s *BasePlSqlParserListener) ExitContainer_tableview_name(ctx *Container_tableview_nameContext) { +} + +// EnterAggregate_function_name is called when production aggregate_function_name is entered. +func (s *BasePlSqlParserListener) EnterAggregate_function_name(ctx *Aggregate_function_nameContext) {} + +// ExitAggregate_function_name is called when production aggregate_function_name is exited. +func (s *BasePlSqlParserListener) ExitAggregate_function_name(ctx *Aggregate_function_nameContext) {} + +// EnterQuery_name is called when production query_name is entered. +func (s *BasePlSqlParserListener) EnterQuery_name(ctx *Query_nameContext) {} + +// ExitQuery_name is called when production query_name is exited. +func (s *BasePlSqlParserListener) ExitQuery_name(ctx *Query_nameContext) {} + +// EnterGrantee_name is called when production grantee_name is entered. +func (s *BasePlSqlParserListener) EnterGrantee_name(ctx *Grantee_nameContext) {} + +// ExitGrantee_name is called when production grantee_name is exited. +func (s *BasePlSqlParserListener) ExitGrantee_name(ctx *Grantee_nameContext) {} + +// EnterRole_name is called when production role_name is entered. +func (s *BasePlSqlParserListener) EnterRole_name(ctx *Role_nameContext) {} + +// ExitRole_name is called when production role_name is exited. +func (s *BasePlSqlParserListener) ExitRole_name(ctx *Role_nameContext) {} + +// EnterConstraint_name is called when production constraint_name is entered. +func (s *BasePlSqlParserListener) EnterConstraint_name(ctx *Constraint_nameContext) {} + +// ExitConstraint_name is called when production constraint_name is exited. +func (s *BasePlSqlParserListener) ExitConstraint_name(ctx *Constraint_nameContext) {} + +// EnterLabel_name is called when production label_name is entered. +func (s *BasePlSqlParserListener) EnterLabel_name(ctx *Label_nameContext) {} + +// ExitLabel_name is called when production label_name is exited. +func (s *BasePlSqlParserListener) ExitLabel_name(ctx *Label_nameContext) {} + +// EnterType_name is called when production type_name is entered. +func (s *BasePlSqlParserListener) EnterType_name(ctx *Type_nameContext) {} + +// ExitType_name is called when production type_name is exited. +func (s *BasePlSqlParserListener) ExitType_name(ctx *Type_nameContext) {} + +// EnterSequence_name is called when production sequence_name is entered. +func (s *BasePlSqlParserListener) EnterSequence_name(ctx *Sequence_nameContext) {} + +// ExitSequence_name is called when production sequence_name is exited. +func (s *BasePlSqlParserListener) ExitSequence_name(ctx *Sequence_nameContext) {} + +// EnterException_name is called when production exception_name is entered. +func (s *BasePlSqlParserListener) EnterException_name(ctx *Exception_nameContext) {} + +// ExitException_name is called when production exception_name is exited. +func (s *BasePlSqlParserListener) ExitException_name(ctx *Exception_nameContext) {} + +// EnterFunction_name is called when production function_name is entered. +func (s *BasePlSqlParserListener) EnterFunction_name(ctx *Function_nameContext) {} + +// ExitFunction_name is called when production function_name is exited. +func (s *BasePlSqlParserListener) ExitFunction_name(ctx *Function_nameContext) {} + +// EnterProcedure_name is called when production procedure_name is entered. +func (s *BasePlSqlParserListener) EnterProcedure_name(ctx *Procedure_nameContext) {} + +// ExitProcedure_name is called when production procedure_name is exited. +func (s *BasePlSqlParserListener) ExitProcedure_name(ctx *Procedure_nameContext) {} + +// EnterTrigger_name is called when production trigger_name is entered. +func (s *BasePlSqlParserListener) EnterTrigger_name(ctx *Trigger_nameContext) {} + +// ExitTrigger_name is called when production trigger_name is exited. +func (s *BasePlSqlParserListener) ExitTrigger_name(ctx *Trigger_nameContext) {} + +// EnterVariable_name is called when production variable_name is entered. +func (s *BasePlSqlParserListener) EnterVariable_name(ctx *Variable_nameContext) {} + +// ExitVariable_name is called when production variable_name is exited. +func (s *BasePlSqlParserListener) ExitVariable_name(ctx *Variable_nameContext) {} + +// EnterIndex_name is called when production index_name is entered. +func (s *BasePlSqlParserListener) EnterIndex_name(ctx *Index_nameContext) {} + +// ExitIndex_name is called when production index_name is exited. +func (s *BasePlSqlParserListener) ExitIndex_name(ctx *Index_nameContext) {} + +// EnterCursor_name is called when production cursor_name is entered. +func (s *BasePlSqlParserListener) EnterCursor_name(ctx *Cursor_nameContext) {} + +// ExitCursor_name is called when production cursor_name is exited. +func (s *BasePlSqlParserListener) ExitCursor_name(ctx *Cursor_nameContext) {} + +// EnterRecord_name is called when production record_name is entered. +func (s *BasePlSqlParserListener) EnterRecord_name(ctx *Record_nameContext) {} + +// ExitRecord_name is called when production record_name is exited. +func (s *BasePlSqlParserListener) ExitRecord_name(ctx *Record_nameContext) {} + +// EnterLink_name is called when production link_name is entered. +func (s *BasePlSqlParserListener) EnterLink_name(ctx *Link_nameContext) {} + +// ExitLink_name is called when production link_name is exited. +func (s *BasePlSqlParserListener) ExitLink_name(ctx *Link_nameContext) {} + +// EnterLocal_link_name is called when production local_link_name is entered. +func (s *BasePlSqlParserListener) EnterLocal_link_name(ctx *Local_link_nameContext) {} + +// ExitLocal_link_name is called when production local_link_name is exited. +func (s *BasePlSqlParserListener) ExitLocal_link_name(ctx *Local_link_nameContext) {} + +// EnterConnection_qualifier is called when production connection_qualifier is entered. +func (s *BasePlSqlParserListener) EnterConnection_qualifier(ctx *Connection_qualifierContext) {} + +// ExitConnection_qualifier is called when production connection_qualifier is exited. +func (s *BasePlSqlParserListener) ExitConnection_qualifier(ctx *Connection_qualifierContext) {} + +// EnterColumn_name is called when production column_name is entered. +func (s *BasePlSqlParserListener) EnterColumn_name(ctx *Column_nameContext) {} + +// ExitColumn_name is called when production column_name is exited. +func (s *BasePlSqlParserListener) ExitColumn_name(ctx *Column_nameContext) {} + +// EnterTableview_name is called when production tableview_name is entered. +func (s *BasePlSqlParserListener) EnterTableview_name(ctx *Tableview_nameContext) {} + +// ExitTableview_name is called when production tableview_name is exited. +func (s *BasePlSqlParserListener) ExitTableview_name(ctx *Tableview_nameContext) {} + +// EnterXmltable is called when production xmltable is entered. +func (s *BasePlSqlParserListener) EnterXmltable(ctx *XmltableContext) {} + +// ExitXmltable is called when production xmltable is exited. +func (s *BasePlSqlParserListener) ExitXmltable(ctx *XmltableContext) {} + +// EnterChar_set_name is called when production char_set_name is entered. +func (s *BasePlSqlParserListener) EnterChar_set_name(ctx *Char_set_nameContext) {} + +// ExitChar_set_name is called when production char_set_name is exited. +func (s *BasePlSqlParserListener) ExitChar_set_name(ctx *Char_set_nameContext) {} + +// EnterSynonym_name is called when production synonym_name is entered. +func (s *BasePlSqlParserListener) EnterSynonym_name(ctx *Synonym_nameContext) {} + +// ExitSynonym_name is called when production synonym_name is exited. +func (s *BasePlSqlParserListener) ExitSynonym_name(ctx *Synonym_nameContext) {} + +// EnterSchema_object_name is called when production schema_object_name is entered. +func (s *BasePlSqlParserListener) EnterSchema_object_name(ctx *Schema_object_nameContext) {} + +// ExitSchema_object_name is called when production schema_object_name is exited. +func (s *BasePlSqlParserListener) ExitSchema_object_name(ctx *Schema_object_nameContext) {} + +// EnterDir_object_name is called when production dir_object_name is entered. +func (s *BasePlSqlParserListener) EnterDir_object_name(ctx *Dir_object_nameContext) {} + +// ExitDir_object_name is called when production dir_object_name is exited. +func (s *BasePlSqlParserListener) ExitDir_object_name(ctx *Dir_object_nameContext) {} + +// EnterUser_object_name is called when production user_object_name is entered. +func (s *BasePlSqlParserListener) EnterUser_object_name(ctx *User_object_nameContext) {} + +// ExitUser_object_name is called when production user_object_name is exited. +func (s *BasePlSqlParserListener) ExitUser_object_name(ctx *User_object_nameContext) {} + +// EnterGrant_object_name is called when production grant_object_name is entered. +func (s *BasePlSqlParserListener) EnterGrant_object_name(ctx *Grant_object_nameContext) {} + +// ExitGrant_object_name is called when production grant_object_name is exited. +func (s *BasePlSqlParserListener) ExitGrant_object_name(ctx *Grant_object_nameContext) {} + +// EnterColumn_list is called when production column_list is entered. +func (s *BasePlSqlParserListener) EnterColumn_list(ctx *Column_listContext) {} + +// ExitColumn_list is called when production column_list is exited. +func (s *BasePlSqlParserListener) ExitColumn_list(ctx *Column_listContext) {} + +// EnterParen_column_list is called when production paren_column_list is entered. +func (s *BasePlSqlParserListener) EnterParen_column_list(ctx *Paren_column_listContext) {} + +// ExitParen_column_list is called when production paren_column_list is exited. +func (s *BasePlSqlParserListener) ExitParen_column_list(ctx *Paren_column_listContext) {} + +// EnterKeep_clause is called when production keep_clause is entered. +func (s *BasePlSqlParserListener) EnterKeep_clause(ctx *Keep_clauseContext) {} + +// ExitKeep_clause is called when production keep_clause is exited. +func (s *BasePlSqlParserListener) ExitKeep_clause(ctx *Keep_clauseContext) {} + +// EnterFunction_argument is called when production function_argument is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument(ctx *Function_argumentContext) {} + +// ExitFunction_argument is called when production function_argument is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument(ctx *Function_argumentContext) {} + +// EnterFunction_argument_analytic is called when production function_argument_analytic is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument_analytic(ctx *Function_argument_analyticContext) { +} + +// ExitFunction_argument_analytic is called when production function_argument_analytic is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument_analytic(ctx *Function_argument_analyticContext) { +} + +// EnterFunction_argument_modeling is called when production function_argument_modeling is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument_modeling(ctx *Function_argument_modelingContext) { +} + +// ExitFunction_argument_modeling is called when production function_argument_modeling is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument_modeling(ctx *Function_argument_modelingContext) { +} + +// EnterRespect_or_ignore_nulls is called when production respect_or_ignore_nulls is entered. +func (s *BasePlSqlParserListener) EnterRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) {} + +// ExitRespect_or_ignore_nulls is called when production respect_or_ignore_nulls is exited. +func (s *BasePlSqlParserListener) ExitRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) {} + +// EnterArgument is called when production argument is entered. +func (s *BasePlSqlParserListener) EnterArgument(ctx *ArgumentContext) {} + +// ExitArgument is called when production argument is exited. +func (s *BasePlSqlParserListener) ExitArgument(ctx *ArgumentContext) {} + +// EnterType_spec is called when production type_spec is entered. +func (s *BasePlSqlParserListener) EnterType_spec(ctx *Type_specContext) {} + +// ExitType_spec is called when production type_spec is exited. +func (s *BasePlSqlParserListener) ExitType_spec(ctx *Type_specContext) {} + +// EnterDatatype is called when production datatype is entered. +func (s *BasePlSqlParserListener) EnterDatatype(ctx *DatatypeContext) {} + +// ExitDatatype is called when production datatype is exited. +func (s *BasePlSqlParserListener) ExitDatatype(ctx *DatatypeContext) {} + +// EnterPrecision_part is called when production precision_part is entered. +func (s *BasePlSqlParserListener) EnterPrecision_part(ctx *Precision_partContext) {} + +// ExitPrecision_part is called when production precision_part is exited. +func (s *BasePlSqlParserListener) ExitPrecision_part(ctx *Precision_partContext) {} + +// EnterNative_datatype_element is called when production native_datatype_element is entered. +func (s *BasePlSqlParserListener) EnterNative_datatype_element(ctx *Native_datatype_elementContext) {} + +// ExitNative_datatype_element is called when production native_datatype_element is exited. +func (s *BasePlSqlParserListener) ExitNative_datatype_element(ctx *Native_datatype_elementContext) {} + +// EnterBind_variable is called when production bind_variable is entered. +func (s *BasePlSqlParserListener) EnterBind_variable(ctx *Bind_variableContext) {} + +// ExitBind_variable is called when production bind_variable is exited. +func (s *BasePlSqlParserListener) ExitBind_variable(ctx *Bind_variableContext) {} + +// EnterGeneral_element is called when production general_element is entered. +func (s *BasePlSqlParserListener) EnterGeneral_element(ctx *General_elementContext) {} + +// ExitGeneral_element is called when production general_element is exited. +func (s *BasePlSqlParserListener) ExitGeneral_element(ctx *General_elementContext) {} + +// EnterGeneral_element_part is called when production general_element_part is entered. +func (s *BasePlSqlParserListener) EnterGeneral_element_part(ctx *General_element_partContext) {} + +// ExitGeneral_element_part is called when production general_element_part is exited. +func (s *BasePlSqlParserListener) ExitGeneral_element_part(ctx *General_element_partContext) {} + +// EnterTable_element is called when production table_element is entered. +func (s *BasePlSqlParserListener) EnterTable_element(ctx *Table_elementContext) {} + +// ExitTable_element is called when production table_element is exited. +func (s *BasePlSqlParserListener) ExitTable_element(ctx *Table_elementContext) {} + +// EnterObject_privilege is called when production object_privilege is entered. +func (s *BasePlSqlParserListener) EnterObject_privilege(ctx *Object_privilegeContext) {} + +// ExitObject_privilege is called when production object_privilege is exited. +func (s *BasePlSqlParserListener) ExitObject_privilege(ctx *Object_privilegeContext) {} + +// EnterSystem_privilege is called when production system_privilege is entered. +func (s *BasePlSqlParserListener) EnterSystem_privilege(ctx *System_privilegeContext) {} + +// ExitSystem_privilege is called when production system_privilege is exited. +func (s *BasePlSqlParserListener) ExitSystem_privilege(ctx *System_privilegeContext) {} + +// EnterConstant is called when production constant is entered. +func (s *BasePlSqlParserListener) EnterConstant(ctx *ConstantContext) {} + +// ExitConstant is called when production constant is exited. +func (s *BasePlSqlParserListener) ExitConstant(ctx *ConstantContext) {} + +// EnterNumeric is called when production numeric is entered. +func (s *BasePlSqlParserListener) EnterNumeric(ctx *NumericContext) {} + +// ExitNumeric is called when production numeric is exited. +func (s *BasePlSqlParserListener) ExitNumeric(ctx *NumericContext) {} + +// EnterNumeric_negative is called when production numeric_negative is entered. +func (s *BasePlSqlParserListener) EnterNumeric_negative(ctx *Numeric_negativeContext) {} + +// ExitNumeric_negative is called when production numeric_negative is exited. +func (s *BasePlSqlParserListener) ExitNumeric_negative(ctx *Numeric_negativeContext) {} + +// EnterQuoted_string is called when production quoted_string is entered. +func (s *BasePlSqlParserListener) EnterQuoted_string(ctx *Quoted_stringContext) {} + +// ExitQuoted_string is called when production quoted_string is exited. +func (s *BasePlSqlParserListener) ExitQuoted_string(ctx *Quoted_stringContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BasePlSqlParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BasePlSqlParserListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterId_expression is called when production id_expression is entered. +func (s *BasePlSqlParserListener) EnterId_expression(ctx *Id_expressionContext) {} + +// ExitId_expression is called when production id_expression is exited. +func (s *BasePlSqlParserListener) ExitId_expression(ctx *Id_expressionContext) {} + +// EnterInquiry_directive is called when production inquiry_directive is entered. +func (s *BasePlSqlParserListener) EnterInquiry_directive(ctx *Inquiry_directiveContext) {} + +// ExitInquiry_directive is called when production inquiry_directive is exited. +func (s *BasePlSqlParserListener) ExitInquiry_directive(ctx *Inquiry_directiveContext) {} + +// EnterOuter_join_sign is called when production outer_join_sign is entered. +func (s *BasePlSqlParserListener) EnterOuter_join_sign(ctx *Outer_join_signContext) {} + +// ExitOuter_join_sign is called when production outer_join_sign is exited. +func (s *BasePlSqlParserListener) ExitOuter_join_sign(ctx *Outer_join_signContext) {} + +// EnterRegular_id is called when production regular_id is entered. +func (s *BasePlSqlParserListener) EnterRegular_id(ctx *Regular_idContext) {} + +// ExitRegular_id is called when production regular_id is exited. +func (s *BasePlSqlParserListener) ExitRegular_id(ctx *Regular_idContext) {} + +// EnterNon_reserved_keywords_in_18c is called when production non_reserved_keywords_in_18c is entered. +func (s *BasePlSqlParserListener) EnterNon_reserved_keywords_in_18c(ctx *Non_reserved_keywords_in_18cContext) { +} + +// ExitNon_reserved_keywords_in_18c is called when production non_reserved_keywords_in_18c is exited. +func (s *BasePlSqlParserListener) ExitNon_reserved_keywords_in_18c(ctx *Non_reserved_keywords_in_18cContext) { +} + +// EnterNon_reserved_keywords_in_12c is called when production non_reserved_keywords_in_12c is entered. +func (s *BasePlSqlParserListener) EnterNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) { +} + +// ExitNon_reserved_keywords_in_12c is called when production non_reserved_keywords_in_12c is exited. +func (s *BasePlSqlParserListener) ExitNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) { +} + +// EnterNon_reserved_keywords_pre12c is called when production non_reserved_keywords_pre12c is entered. +func (s *BasePlSqlParserListener) EnterNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) { +} + +// ExitNon_reserved_keywords_pre12c is called when production non_reserved_keywords_pre12c is exited. +func (s *BasePlSqlParserListener) ExitNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) { +} diff --git a/internal/engine/oracle/parser/plsqlparser_listener.go b/internal/engine/oracle/parser/plsqlparser_listener.go new file mode 100644 index 0000000000..b67e146b41 --- /dev/null +++ b/internal/engine/oracle/parser/plsqlparser_listener.go @@ -0,0 +1,7275 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.1. DO NOT EDIT. + +package parser // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +// PlSqlParserListener is a complete listener for a parse tree produced by PlSqlParser. +type PlSqlParserListener interface { + antlr.ParseTreeListener + + // EnterSql_script is called when entering the sql_script production. + EnterSql_script(c *Sql_scriptContext) + + // EnterUnit_statement is called when entering the unit_statement production. + EnterUnit_statement(c *Unit_statementContext) + + // EnterAlter_diskgroup is called when entering the alter_diskgroup production. + EnterAlter_diskgroup(c *Alter_diskgroupContext) + + // EnterAdd_disk_clause is called when entering the add_disk_clause production. + EnterAdd_disk_clause(c *Add_disk_clauseContext) + + // EnterDrop_disk_clause is called when entering the drop_disk_clause production. + EnterDrop_disk_clause(c *Drop_disk_clauseContext) + + // EnterResize_disk_clause is called when entering the resize_disk_clause production. + EnterResize_disk_clause(c *Resize_disk_clauseContext) + + // EnterReplace_disk_clause is called when entering the replace_disk_clause production. + EnterReplace_disk_clause(c *Replace_disk_clauseContext) + + // EnterWait_nowait is called when entering the wait_nowait production. + EnterWait_nowait(c *Wait_nowaitContext) + + // EnterRename_disk_clause is called when entering the rename_disk_clause production. + EnterRename_disk_clause(c *Rename_disk_clauseContext) + + // EnterDisk_online_clause is called when entering the disk_online_clause production. + EnterDisk_online_clause(c *Disk_online_clauseContext) + + // EnterDisk_offline_clause is called when entering the disk_offline_clause production. + EnterDisk_offline_clause(c *Disk_offline_clauseContext) + + // EnterTimeout_clause is called when entering the timeout_clause production. + EnterTimeout_clause(c *Timeout_clauseContext) + + // EnterRebalance_diskgroup_clause is called when entering the rebalance_diskgroup_clause production. + EnterRebalance_diskgroup_clause(c *Rebalance_diskgroup_clauseContext) + + // EnterPhase is called when entering the phase production. + EnterPhase(c *PhaseContext) + + // EnterCheck_diskgroup_clause is called when entering the check_diskgroup_clause production. + EnterCheck_diskgroup_clause(c *Check_diskgroup_clauseContext) + + // EnterDiskgroup_template_clauses is called when entering the diskgroup_template_clauses production. + EnterDiskgroup_template_clauses(c *Diskgroup_template_clausesContext) + + // EnterQualified_template_clause is called when entering the qualified_template_clause production. + EnterQualified_template_clause(c *Qualified_template_clauseContext) + + // EnterRedundancy_clause is called when entering the redundancy_clause production. + EnterRedundancy_clause(c *Redundancy_clauseContext) + + // EnterStriping_clause is called when entering the striping_clause production. + EnterStriping_clause(c *Striping_clauseContext) + + // EnterForce_noforce is called when entering the force_noforce production. + EnterForce_noforce(c *Force_noforceContext) + + // EnterDiskgroup_directory_clauses is called when entering the diskgroup_directory_clauses production. + EnterDiskgroup_directory_clauses(c *Diskgroup_directory_clausesContext) + + // EnterDir_name is called when entering the dir_name production. + EnterDir_name(c *Dir_nameContext) + + // EnterDiskgroup_alias_clauses is called when entering the diskgroup_alias_clauses production. + EnterDiskgroup_alias_clauses(c *Diskgroup_alias_clausesContext) + + // EnterDiskgroup_volume_clauses is called when entering the diskgroup_volume_clauses production. + EnterDiskgroup_volume_clauses(c *Diskgroup_volume_clausesContext) + + // EnterAdd_volume_clause is called when entering the add_volume_clause production. + EnterAdd_volume_clause(c *Add_volume_clauseContext) + + // EnterModify_volume_clause is called when entering the modify_volume_clause production. + EnterModify_volume_clause(c *Modify_volume_clauseContext) + + // EnterDiskgroup_attributes is called when entering the diskgroup_attributes production. + EnterDiskgroup_attributes(c *Diskgroup_attributesContext) + + // EnterDrop_diskgroup_file_clause is called when entering the drop_diskgroup_file_clause production. + EnterDrop_diskgroup_file_clause(c *Drop_diskgroup_file_clauseContext) + + // EnterConvert_redundancy_clause is called when entering the convert_redundancy_clause production. + EnterConvert_redundancy_clause(c *Convert_redundancy_clauseContext) + + // EnterUsergroup_clauses is called when entering the usergroup_clauses production. + EnterUsergroup_clauses(c *Usergroup_clausesContext) + + // EnterUser_clauses is called when entering the user_clauses production. + EnterUser_clauses(c *User_clausesContext) + + // EnterFile_permissions_clause is called when entering the file_permissions_clause production. + EnterFile_permissions_clause(c *File_permissions_clauseContext) + + // EnterFile_owner_clause is called when entering the file_owner_clause production. + EnterFile_owner_clause(c *File_owner_clauseContext) + + // EnterScrub_clause is called when entering the scrub_clause production. + EnterScrub_clause(c *Scrub_clauseContext) + + // EnterQuotagroup_clauses is called when entering the quotagroup_clauses production. + EnterQuotagroup_clauses(c *Quotagroup_clausesContext) + + // EnterProperty_name is called when entering the property_name production. + EnterProperty_name(c *Property_nameContext) + + // EnterProperty_value is called when entering the property_value production. + EnterProperty_value(c *Property_valueContext) + + // EnterFilegroup_clauses is called when entering the filegroup_clauses production. + EnterFilegroup_clauses(c *Filegroup_clausesContext) + + // EnterAdd_filegroup_clause is called when entering the add_filegroup_clause production. + EnterAdd_filegroup_clause(c *Add_filegroup_clauseContext) + + // EnterModify_filegroup_clause is called when entering the modify_filegroup_clause production. + EnterModify_filegroup_clause(c *Modify_filegroup_clauseContext) + + // EnterMove_to_filegroup_clause is called when entering the move_to_filegroup_clause production. + EnterMove_to_filegroup_clause(c *Move_to_filegroup_clauseContext) + + // EnterDrop_filegroup_clause is called when entering the drop_filegroup_clause production. + EnterDrop_filegroup_clause(c *Drop_filegroup_clauseContext) + + // EnterQuorum_regular is called when entering the quorum_regular production. + EnterQuorum_regular(c *Quorum_regularContext) + + // EnterUndrop_disk_clause is called when entering the undrop_disk_clause production. + EnterUndrop_disk_clause(c *Undrop_disk_clauseContext) + + // EnterDiskgroup_availability is called when entering the diskgroup_availability production. + EnterDiskgroup_availability(c *Diskgroup_availabilityContext) + + // EnterEnable_disable_volume is called when entering the enable_disable_volume production. + EnterEnable_disable_volume(c *Enable_disable_volumeContext) + + // EnterDrop_function is called when entering the drop_function production. + EnterDrop_function(c *Drop_functionContext) + + // EnterAlter_flashback_archive is called when entering the alter_flashback_archive production. + EnterAlter_flashback_archive(c *Alter_flashback_archiveContext) + + // EnterAlter_hierarchy is called when entering the alter_hierarchy production. + EnterAlter_hierarchy(c *Alter_hierarchyContext) + + // EnterAlter_function is called when entering the alter_function production. + EnterAlter_function(c *Alter_functionContext) + + // EnterAlter_java is called when entering the alter_java production. + EnterAlter_java(c *Alter_javaContext) + + // EnterMatch_string is called when entering the match_string production. + EnterMatch_string(c *Match_stringContext) + + // EnterCreate_function_body is called when entering the create_function_body production. + EnterCreate_function_body(c *Create_function_bodyContext) + + // EnterSql_macro_body is called when entering the sql_macro_body production. + EnterSql_macro_body(c *Sql_macro_bodyContext) + + // EnterParallel_enable_clause is called when entering the parallel_enable_clause production. + EnterParallel_enable_clause(c *Parallel_enable_clauseContext) + + // EnterPartition_by_clause is called when entering the partition_by_clause production. + EnterPartition_by_clause(c *Partition_by_clauseContext) + + // EnterResult_cache_clause is called when entering the result_cache_clause production. + EnterResult_cache_clause(c *Result_cache_clauseContext) + + // EnterAccessible_by_clause is called when entering the accessible_by_clause production. + EnterAccessible_by_clause(c *Accessible_by_clauseContext) + + // EnterDefault_collation_clause is called when entering the default_collation_clause production. + EnterDefault_collation_clause(c *Default_collation_clauseContext) + + // EnterAggregate_clause is called when entering the aggregate_clause production. + EnterAggregate_clause(c *Aggregate_clauseContext) + + // EnterPipelined_using_clause is called when entering the pipelined_using_clause production. + EnterPipelined_using_clause(c *Pipelined_using_clauseContext) + + // EnterAccessor is called when entering the accessor production. + EnterAccessor(c *AccessorContext) + + // EnterRelies_on_part is called when entering the relies_on_part production. + EnterRelies_on_part(c *Relies_on_partContext) + + // EnterStreaming_clause is called when entering the streaming_clause production. + EnterStreaming_clause(c *Streaming_clauseContext) + + // EnterAlter_outline is called when entering the alter_outline production. + EnterAlter_outline(c *Alter_outlineContext) + + // EnterOutline_options is called when entering the outline_options production. + EnterOutline_options(c *Outline_optionsContext) + + // EnterAlter_lockdown_profile is called when entering the alter_lockdown_profile production. + EnterAlter_lockdown_profile(c *Alter_lockdown_profileContext) + + // EnterLockdown_feature is called when entering the lockdown_feature production. + EnterLockdown_feature(c *Lockdown_featureContext) + + // EnterLockdown_options is called when entering the lockdown_options production. + EnterLockdown_options(c *Lockdown_optionsContext) + + // EnterLockdown_statements is called when entering the lockdown_statements production. + EnterLockdown_statements(c *Lockdown_statementsContext) + + // EnterStatement_clauses is called when entering the statement_clauses production. + EnterStatement_clauses(c *Statement_clausesContext) + + // EnterClause_options is called when entering the clause_options production. + EnterClause_options(c *Clause_optionsContext) + + // EnterOption_values is called when entering the option_values production. + EnterOption_values(c *Option_valuesContext) + + // EnterString_list is called when entering the string_list production. + EnterString_list(c *String_listContext) + + // EnterDisable_enable is called when entering the disable_enable production. + EnterDisable_enable(c *Disable_enableContext) + + // EnterDrop_lockdown_profile is called when entering the drop_lockdown_profile production. + EnterDrop_lockdown_profile(c *Drop_lockdown_profileContext) + + // EnterDrop_package is called when entering the drop_package production. + EnterDrop_package(c *Drop_packageContext) + + // EnterAlter_package is called when entering the alter_package production. + EnterAlter_package(c *Alter_packageContext) + + // EnterCreate_package is called when entering the create_package production. + EnterCreate_package(c *Create_packageContext) + + // EnterCreate_package_body is called when entering the create_package_body production. + EnterCreate_package_body(c *Create_package_bodyContext) + + // EnterPackage_obj_spec is called when entering the package_obj_spec production. + EnterPackage_obj_spec(c *Package_obj_specContext) + + // EnterProcedure_spec is called when entering the procedure_spec production. + EnterProcedure_spec(c *Procedure_specContext) + + // EnterFunction_spec is called when entering the function_spec production. + EnterFunction_spec(c *Function_specContext) + + // EnterPackage_obj_body is called when entering the package_obj_body production. + EnterPackage_obj_body(c *Package_obj_bodyContext) + + // EnterAlter_pmem_filestore is called when entering the alter_pmem_filestore production. + EnterAlter_pmem_filestore(c *Alter_pmem_filestoreContext) + + // EnterDrop_pmem_filestore is called when entering the drop_pmem_filestore production. + EnterDrop_pmem_filestore(c *Drop_pmem_filestoreContext) + + // EnterDrop_procedure is called when entering the drop_procedure production. + EnterDrop_procedure(c *Drop_procedureContext) + + // EnterAlter_procedure is called when entering the alter_procedure production. + EnterAlter_procedure(c *Alter_procedureContext) + + // EnterFunction_body is called when entering the function_body production. + EnterFunction_body(c *Function_bodyContext) + + // EnterProcedure_body is called when entering the procedure_body production. + EnterProcedure_body(c *Procedure_bodyContext) + + // EnterCreate_procedure_body is called when entering the create_procedure_body production. + EnterCreate_procedure_body(c *Create_procedure_bodyContext) + + // EnterAlter_resource_cost is called when entering the alter_resource_cost production. + EnterAlter_resource_cost(c *Alter_resource_costContext) + + // EnterDrop_outline is called when entering the drop_outline production. + EnterDrop_outline(c *Drop_outlineContext) + + // EnterAlter_rollback_segment is called when entering the alter_rollback_segment production. + EnterAlter_rollback_segment(c *Alter_rollback_segmentContext) + + // EnterDrop_restore_point is called when entering the drop_restore_point production. + EnterDrop_restore_point(c *Drop_restore_pointContext) + + // EnterDrop_rollback_segment is called when entering the drop_rollback_segment production. + EnterDrop_rollback_segment(c *Drop_rollback_segmentContext) + + // EnterDrop_role is called when entering the drop_role production. + EnterDrop_role(c *Drop_roleContext) + + // EnterCreate_pmem_filestore is called when entering the create_pmem_filestore production. + EnterCreate_pmem_filestore(c *Create_pmem_filestoreContext) + + // EnterPmem_filestore_options is called when entering the pmem_filestore_options production. + EnterPmem_filestore_options(c *Pmem_filestore_optionsContext) + + // EnterFile_path is called when entering the file_path production. + EnterFile_path(c *File_pathContext) + + // EnterCreate_rollback_segment is called when entering the create_rollback_segment production. + EnterCreate_rollback_segment(c *Create_rollback_segmentContext) + + // EnterDrop_trigger is called when entering the drop_trigger production. + EnterDrop_trigger(c *Drop_triggerContext) + + // EnterAlter_trigger is called when entering the alter_trigger production. + EnterAlter_trigger(c *Alter_triggerContext) + + // EnterCreate_trigger is called when entering the create_trigger production. + EnterCreate_trigger(c *Create_triggerContext) + + // EnterTrigger_follows_clause is called when entering the trigger_follows_clause production. + EnterTrigger_follows_clause(c *Trigger_follows_clauseContext) + + // EnterTrigger_when_clause is called when entering the trigger_when_clause production. + EnterTrigger_when_clause(c *Trigger_when_clauseContext) + + // EnterSimple_dml_trigger is called when entering the simple_dml_trigger production. + EnterSimple_dml_trigger(c *Simple_dml_triggerContext) + + // EnterFor_each_row is called when entering the for_each_row production. + EnterFor_each_row(c *For_each_rowContext) + + // EnterCompound_dml_trigger is called when entering the compound_dml_trigger production. + EnterCompound_dml_trigger(c *Compound_dml_triggerContext) + + // EnterNon_dml_trigger is called when entering the non_dml_trigger production. + EnterNon_dml_trigger(c *Non_dml_triggerContext) + + // EnterTrigger_body is called when entering the trigger_body production. + EnterTrigger_body(c *Trigger_bodyContext) + + // EnterCompound_trigger_block is called when entering the compound_trigger_block production. + EnterCompound_trigger_block(c *Compound_trigger_blockContext) + + // EnterTiming_point_section is called when entering the timing_point_section production. + EnterTiming_point_section(c *Timing_point_sectionContext) + + // EnterNon_dml_event is called when entering the non_dml_event production. + EnterNon_dml_event(c *Non_dml_eventContext) + + // EnterDml_event_clause is called when entering the dml_event_clause production. + EnterDml_event_clause(c *Dml_event_clauseContext) + + // EnterDml_event_element is called when entering the dml_event_element production. + EnterDml_event_element(c *Dml_event_elementContext) + + // EnterDml_event_nested_clause is called when entering the dml_event_nested_clause production. + EnterDml_event_nested_clause(c *Dml_event_nested_clauseContext) + + // EnterReferencing_clause is called when entering the referencing_clause production. + EnterReferencing_clause(c *Referencing_clauseContext) + + // EnterReferencing_element is called when entering the referencing_element production. + EnterReferencing_element(c *Referencing_elementContext) + + // EnterDrop_type is called when entering the drop_type production. + EnterDrop_type(c *Drop_typeContext) + + // EnterAlter_type is called when entering the alter_type production. + EnterAlter_type(c *Alter_typeContext) + + // EnterCompile_type_clause is called when entering the compile_type_clause production. + EnterCompile_type_clause(c *Compile_type_clauseContext) + + // EnterReplace_type_clause is called when entering the replace_type_clause production. + EnterReplace_type_clause(c *Replace_type_clauseContext) + + // EnterAlter_method_spec is called when entering the alter_method_spec production. + EnterAlter_method_spec(c *Alter_method_specContext) + + // EnterAlter_method_element is called when entering the alter_method_element production. + EnterAlter_method_element(c *Alter_method_elementContext) + + // EnterAlter_collection_clauses is called when entering the alter_collection_clauses production. + EnterAlter_collection_clauses(c *Alter_collection_clausesContext) + + // EnterDependent_handling_clause is called when entering the dependent_handling_clause production. + EnterDependent_handling_clause(c *Dependent_handling_clauseContext) + + // EnterDependent_exceptions_part is called when entering the dependent_exceptions_part production. + EnterDependent_exceptions_part(c *Dependent_exceptions_partContext) + + // EnterCreate_type is called when entering the create_type production. + EnterCreate_type(c *Create_typeContext) + + // EnterType_definition is called when entering the type_definition production. + EnterType_definition(c *Type_definitionContext) + + // EnterObject_type_def is called when entering the object_type_def production. + EnterObject_type_def(c *Object_type_defContext) + + // EnterObject_as_part is called when entering the object_as_part production. + EnterObject_as_part(c *Object_as_partContext) + + // EnterObject_under_part is called when entering the object_under_part production. + EnterObject_under_part(c *Object_under_partContext) + + // EnterNested_table_type_def is called when entering the nested_table_type_def production. + EnterNested_table_type_def(c *Nested_table_type_defContext) + + // EnterSqlj_object_type is called when entering the sqlj_object_type production. + EnterSqlj_object_type(c *Sqlj_object_typeContext) + + // EnterType_body is called when entering the type_body production. + EnterType_body(c *Type_bodyContext) + + // EnterType_body_elements is called when entering the type_body_elements production. + EnterType_body_elements(c *Type_body_elementsContext) + + // EnterMap_order_func_declaration is called when entering the map_order_func_declaration production. + EnterMap_order_func_declaration(c *Map_order_func_declarationContext) + + // EnterSubprog_decl_in_type is called when entering the subprog_decl_in_type production. + EnterSubprog_decl_in_type(c *Subprog_decl_in_typeContext) + + // EnterProc_decl_in_type is called when entering the proc_decl_in_type production. + EnterProc_decl_in_type(c *Proc_decl_in_typeContext) + + // EnterFunc_decl_in_type is called when entering the func_decl_in_type production. + EnterFunc_decl_in_type(c *Func_decl_in_typeContext) + + // EnterConstructor_declaration is called when entering the constructor_declaration production. + EnterConstructor_declaration(c *Constructor_declarationContext) + + // EnterModifier_clause is called when entering the modifier_clause production. + EnterModifier_clause(c *Modifier_clauseContext) + + // EnterObject_member_spec is called when entering the object_member_spec production. + EnterObject_member_spec(c *Object_member_specContext) + + // EnterSqlj_object_type_attr is called when entering the sqlj_object_type_attr production. + EnterSqlj_object_type_attr(c *Sqlj_object_type_attrContext) + + // EnterElement_spec is called when entering the element_spec production. + EnterElement_spec(c *Element_specContext) + + // EnterElement_spec_options is called when entering the element_spec_options production. + EnterElement_spec_options(c *Element_spec_optionsContext) + + // EnterSubprogram_spec is called when entering the subprogram_spec production. + EnterSubprogram_spec(c *Subprogram_specContext) + + // EnterOverriding_subprogram_spec is called when entering the overriding_subprogram_spec production. + EnterOverriding_subprogram_spec(c *Overriding_subprogram_specContext) + + // EnterOverriding_function_spec is called when entering the overriding_function_spec production. + EnterOverriding_function_spec(c *Overriding_function_specContext) + + // EnterOverriding_procedure_spec is called when entering the overriding_procedure_spec production. + EnterOverriding_procedure_spec(c *Overriding_procedure_specContext) + + // EnterType_procedure_spec is called when entering the type_procedure_spec production. + EnterType_procedure_spec(c *Type_procedure_specContext) + + // EnterType_function_spec is called when entering the type_function_spec production. + EnterType_function_spec(c *Type_function_specContext) + + // EnterConstructor_spec is called when entering the constructor_spec production. + EnterConstructor_spec(c *Constructor_specContext) + + // EnterMap_order_function_spec is called when entering the map_order_function_spec production. + EnterMap_order_function_spec(c *Map_order_function_specContext) + + // EnterPragma_clause is called when entering the pragma_clause production. + EnterPragma_clause(c *Pragma_clauseContext) + + // EnterPragma_elements is called when entering the pragma_elements production. + EnterPragma_elements(c *Pragma_elementsContext) + + // EnterType_elements_parameter is called when entering the type_elements_parameter production. + EnterType_elements_parameter(c *Type_elements_parameterContext) + + // EnterDrop_sequence is called when entering the drop_sequence production. + EnterDrop_sequence(c *Drop_sequenceContext) + + // EnterAlter_sequence is called when entering the alter_sequence production. + EnterAlter_sequence(c *Alter_sequenceContext) + + // EnterAlter_session is called when entering the alter_session production. + EnterAlter_session(c *Alter_sessionContext) + + // EnterAlter_session_set_clause is called when entering the alter_session_set_clause production. + EnterAlter_session_set_clause(c *Alter_session_set_clauseContext) + + // EnterCreate_sequence is called when entering the create_sequence production. + EnterCreate_sequence(c *Create_sequenceContext) + + // EnterSequence_spec is called when entering the sequence_spec production. + EnterSequence_spec(c *Sequence_specContext) + + // EnterSequence_start_clause is called when entering the sequence_start_clause production. + EnterSequence_start_clause(c *Sequence_start_clauseContext) + + // EnterCreate_analytic_view is called when entering the create_analytic_view production. + EnterCreate_analytic_view(c *Create_analytic_viewContext) + + // EnterClassification_clause is called when entering the classification_clause production. + EnterClassification_clause(c *Classification_clauseContext) + + // EnterCaption_clause is called when entering the caption_clause production. + EnterCaption_clause(c *Caption_clauseContext) + + // EnterDescription_clause is called when entering the description_clause production. + EnterDescription_clause(c *Description_clauseContext) + + // EnterClassification_item is called when entering the classification_item production. + EnterClassification_item(c *Classification_itemContext) + + // EnterLanguage is called when entering the language production. + EnterLanguage(c *LanguageContext) + + // EnterCav_using_clause is called when entering the cav_using_clause production. + EnterCav_using_clause(c *Cav_using_clauseContext) + + // EnterDim_by_clause is called when entering the dim_by_clause production. + EnterDim_by_clause(c *Dim_by_clauseContext) + + // EnterDim_key is called when entering the dim_key production. + EnterDim_key(c *Dim_keyContext) + + // EnterDim_ref is called when entering the dim_ref production. + EnterDim_ref(c *Dim_refContext) + + // EnterHier_ref is called when entering the hier_ref production. + EnterHier_ref(c *Hier_refContext) + + // EnterMeasures_clause is called when entering the measures_clause production. + EnterMeasures_clause(c *Measures_clauseContext) + + // EnterAv_measure is called when entering the av_measure production. + EnterAv_measure(c *Av_measureContext) + + // EnterBase_meas_clause is called when entering the base_meas_clause production. + EnterBase_meas_clause(c *Base_meas_clauseContext) + + // EnterMeas_aggregate_clause is called when entering the meas_aggregate_clause production. + EnterMeas_aggregate_clause(c *Meas_aggregate_clauseContext) + + // EnterCalc_meas_clause is called when entering the calc_meas_clause production. + EnterCalc_meas_clause(c *Calc_meas_clauseContext) + + // EnterDefault_measure_clause is called when entering the default_measure_clause production. + EnterDefault_measure_clause(c *Default_measure_clauseContext) + + // EnterDefault_aggregate_clause is called when entering the default_aggregate_clause production. + EnterDefault_aggregate_clause(c *Default_aggregate_clauseContext) + + // EnterCache_clause is called when entering the cache_clause production. + EnterCache_clause(c *Cache_clauseContext) + + // EnterCache_specification is called when entering the cache_specification production. + EnterCache_specification(c *Cache_specificationContext) + + // EnterLevels_clause is called when entering the levels_clause production. + EnterLevels_clause(c *Levels_clauseContext) + + // EnterLevel_specification is called when entering the level_specification production. + EnterLevel_specification(c *Level_specificationContext) + + // EnterLevel_group_type is called when entering the level_group_type production. + EnterLevel_group_type(c *Level_group_typeContext) + + // EnterFact_columns_clause is called when entering the fact_columns_clause production. + EnterFact_columns_clause(c *Fact_columns_clauseContext) + + // EnterQry_transform_clause is called when entering the qry_transform_clause production. + EnterQry_transform_clause(c *Qry_transform_clauseContext) + + // EnterCreate_attribute_dimension is called when entering the create_attribute_dimension production. + EnterCreate_attribute_dimension(c *Create_attribute_dimensionContext) + + // EnterAd_using_clause is called when entering the ad_using_clause production. + EnterAd_using_clause(c *Ad_using_clauseContext) + + // EnterSource_clause is called when entering the source_clause production. + EnterSource_clause(c *Source_clauseContext) + + // EnterJoin_path_clause is called when entering the join_path_clause production. + EnterJoin_path_clause(c *Join_path_clauseContext) + + // EnterJoin_condition is called when entering the join_condition production. + EnterJoin_condition(c *Join_conditionContext) + + // EnterJoin_condition_item is called when entering the join_condition_item production. + EnterJoin_condition_item(c *Join_condition_itemContext) + + // EnterAttributes_clause is called when entering the attributes_clause production. + EnterAttributes_clause(c *Attributes_clauseContext) + + // EnterAd_attributes_clause is called when entering the ad_attributes_clause production. + EnterAd_attributes_clause(c *Ad_attributes_clauseContext) + + // EnterAd_level_clause is called when entering the ad_level_clause production. + EnterAd_level_clause(c *Ad_level_clauseContext) + + // EnterKey_clause is called when entering the key_clause production. + EnterKey_clause(c *Key_clauseContext) + + // EnterAlternate_key_clause is called when entering the alternate_key_clause production. + EnterAlternate_key_clause(c *Alternate_key_clauseContext) + + // EnterDim_order_clause is called when entering the dim_order_clause production. + EnterDim_order_clause(c *Dim_order_clauseContext) + + // EnterAll_clause is called when entering the all_clause production. + EnterAll_clause(c *All_clauseContext) + + // EnterCreate_audit_policy is called when entering the create_audit_policy production. + EnterCreate_audit_policy(c *Create_audit_policyContext) + + // EnterPrivilege_audit_clause is called when entering the privilege_audit_clause production. + EnterPrivilege_audit_clause(c *Privilege_audit_clauseContext) + + // EnterAction_audit_clause is called when entering the action_audit_clause production. + EnterAction_audit_clause(c *Action_audit_clauseContext) + + // EnterSystem_actions is called when entering the system_actions production. + EnterSystem_actions(c *System_actionsContext) + + // EnterStandard_actions is called when entering the standard_actions production. + EnterStandard_actions(c *Standard_actionsContext) + + // EnterActions_clause is called when entering the actions_clause production. + EnterActions_clause(c *Actions_clauseContext) + + // EnterObject_action is called when entering the object_action production. + EnterObject_action(c *Object_actionContext) + + // EnterSystem_action is called when entering the system_action production. + EnterSystem_action(c *System_actionContext) + + // EnterComponent_actions is called when entering the component_actions production. + EnterComponent_actions(c *Component_actionsContext) + + // EnterComponent_action is called when entering the component_action production. + EnterComponent_action(c *Component_actionContext) + + // EnterRole_audit_clause is called when entering the role_audit_clause production. + EnterRole_audit_clause(c *Role_audit_clauseContext) + + // EnterCreate_controlfile is called when entering the create_controlfile production. + EnterCreate_controlfile(c *Create_controlfileContext) + + // EnterControlfile_options is called when entering the controlfile_options production. + EnterControlfile_options(c *Controlfile_optionsContext) + + // EnterLogfile_clause is called when entering the logfile_clause production. + EnterLogfile_clause(c *Logfile_clauseContext) + + // EnterCharacter_set_clause is called when entering the character_set_clause production. + EnterCharacter_set_clause(c *Character_set_clauseContext) + + // EnterFile_specification is called when entering the file_specification production. + EnterFile_specification(c *File_specificationContext) + + // EnterCreate_diskgroup is called when entering the create_diskgroup production. + EnterCreate_diskgroup(c *Create_diskgroupContext) + + // EnterQualified_disk_clause is called when entering the qualified_disk_clause production. + EnterQualified_disk_clause(c *Qualified_disk_clauseContext) + + // EnterCreate_edition is called when entering the create_edition production. + EnterCreate_edition(c *Create_editionContext) + + // EnterCreate_flashback_archive is called when entering the create_flashback_archive production. + EnterCreate_flashback_archive(c *Create_flashback_archiveContext) + + // EnterFlashback_archive_quota is called when entering the flashback_archive_quota production. + EnterFlashback_archive_quota(c *Flashback_archive_quotaContext) + + // EnterFlashback_archive_retention is called when entering the flashback_archive_retention production. + EnterFlashback_archive_retention(c *Flashback_archive_retentionContext) + + // EnterCreate_hierarchy is called when entering the create_hierarchy production. + EnterCreate_hierarchy(c *Create_hierarchyContext) + + // EnterHier_using_clause is called when entering the hier_using_clause production. + EnterHier_using_clause(c *Hier_using_clauseContext) + + // EnterLevel_hier_clause is called when entering the level_hier_clause production. + EnterLevel_hier_clause(c *Level_hier_clauseContext) + + // EnterHier_attrs_clause is called when entering the hier_attrs_clause production. + EnterHier_attrs_clause(c *Hier_attrs_clauseContext) + + // EnterHier_attr_clause is called when entering the hier_attr_clause production. + EnterHier_attr_clause(c *Hier_attr_clauseContext) + + // EnterHier_attr_name is called when entering the hier_attr_name production. + EnterHier_attr_name(c *Hier_attr_nameContext) + + // EnterCreate_index is called when entering the create_index production. + EnterCreate_index(c *Create_indexContext) + + // EnterCluster_index_clause is called when entering the cluster_index_clause production. + EnterCluster_index_clause(c *Cluster_index_clauseContext) + + // EnterCluster_name is called when entering the cluster_name production. + EnterCluster_name(c *Cluster_nameContext) + + // EnterTable_index_clause is called when entering the table_index_clause production. + EnterTable_index_clause(c *Table_index_clauseContext) + + // EnterBitmap_join_index_clause is called when entering the bitmap_join_index_clause production. + EnterBitmap_join_index_clause(c *Bitmap_join_index_clauseContext) + + // EnterIndex_expr is called when entering the index_expr production. + EnterIndex_expr(c *Index_exprContext) + + // EnterIndex_properties is called when entering the index_properties production. + EnterIndex_properties(c *Index_propertiesContext) + + // EnterDomain_index_clause is called when entering the domain_index_clause production. + EnterDomain_index_clause(c *Domain_index_clauseContext) + + // EnterLocal_domain_index_clause is called when entering the local_domain_index_clause production. + EnterLocal_domain_index_clause(c *Local_domain_index_clauseContext) + + // EnterXmlindex_clause is called when entering the xmlindex_clause production. + EnterXmlindex_clause(c *Xmlindex_clauseContext) + + // EnterLocal_xmlindex_clause is called when entering the local_xmlindex_clause production. + EnterLocal_xmlindex_clause(c *Local_xmlindex_clauseContext) + + // EnterGlobal_partitioned_index is called when entering the global_partitioned_index production. + EnterGlobal_partitioned_index(c *Global_partitioned_indexContext) + + // EnterIndex_partitioning_clause is called when entering the index_partitioning_clause production. + EnterIndex_partitioning_clause(c *Index_partitioning_clauseContext) + + // EnterIndex_partitioning_values_list is called when entering the index_partitioning_values_list production. + EnterIndex_partitioning_values_list(c *Index_partitioning_values_listContext) + + // EnterLocal_partitioned_index is called when entering the local_partitioned_index production. + EnterLocal_partitioned_index(c *Local_partitioned_indexContext) + + // EnterOn_range_partitioned_table is called when entering the on_range_partitioned_table production. + EnterOn_range_partitioned_table(c *On_range_partitioned_tableContext) + + // EnterOn_list_partitioned_table is called when entering the on_list_partitioned_table production. + EnterOn_list_partitioned_table(c *On_list_partitioned_tableContext) + + // EnterPartitioned_table is called when entering the partitioned_table production. + EnterPartitioned_table(c *Partitioned_tableContext) + + // EnterOn_hash_partitioned_table is called when entering the on_hash_partitioned_table production. + EnterOn_hash_partitioned_table(c *On_hash_partitioned_tableContext) + + // EnterOn_hash_partitioned_clause is called when entering the on_hash_partitioned_clause production. + EnterOn_hash_partitioned_clause(c *On_hash_partitioned_clauseContext) + + // EnterOn_comp_partitioned_table is called when entering the on_comp_partitioned_table production. + EnterOn_comp_partitioned_table(c *On_comp_partitioned_tableContext) + + // EnterOn_comp_partitioned_clause is called when entering the on_comp_partitioned_clause production. + EnterOn_comp_partitioned_clause(c *On_comp_partitioned_clauseContext) + + // EnterIndex_subpartition_clause is called when entering the index_subpartition_clause production. + EnterIndex_subpartition_clause(c *Index_subpartition_clauseContext) + + // EnterIndex_subpartition_subclause is called when entering the index_subpartition_subclause production. + EnterIndex_subpartition_subclause(c *Index_subpartition_subclauseContext) + + // EnterOdci_parameters is called when entering the odci_parameters production. + EnterOdci_parameters(c *Odci_parametersContext) + + // EnterIndextype is called when entering the indextype production. + EnterIndextype(c *IndextypeContext) + + // EnterAlter_index is called when entering the alter_index production. + EnterAlter_index(c *Alter_indexContext) + + // EnterAlter_index_ops_set1 is called when entering the alter_index_ops_set1 production. + EnterAlter_index_ops_set1(c *Alter_index_ops_set1Context) + + // EnterAlter_index_ops_set2 is called when entering the alter_index_ops_set2 production. + EnterAlter_index_ops_set2(c *Alter_index_ops_set2Context) + + // EnterVisible_or_invisible is called when entering the visible_or_invisible production. + EnterVisible_or_invisible(c *Visible_or_invisibleContext) + + // EnterMonitoring_nomonitoring is called when entering the monitoring_nomonitoring production. + EnterMonitoring_nomonitoring(c *Monitoring_nomonitoringContext) + + // EnterRebuild_clause is called when entering the rebuild_clause production. + EnterRebuild_clause(c *Rebuild_clauseContext) + + // EnterAlter_index_partitioning is called when entering the alter_index_partitioning production. + EnterAlter_index_partitioning(c *Alter_index_partitioningContext) + + // EnterModify_index_default_attrs is called when entering the modify_index_default_attrs production. + EnterModify_index_default_attrs(c *Modify_index_default_attrsContext) + + // EnterAdd_hash_index_partition is called when entering the add_hash_index_partition production. + EnterAdd_hash_index_partition(c *Add_hash_index_partitionContext) + + // EnterCoalesce_index_partition is called when entering the coalesce_index_partition production. + EnterCoalesce_index_partition(c *Coalesce_index_partitionContext) + + // EnterModify_index_partition is called when entering the modify_index_partition production. + EnterModify_index_partition(c *Modify_index_partitionContext) + + // EnterModify_index_partitions_ops is called when entering the modify_index_partitions_ops production. + EnterModify_index_partitions_ops(c *Modify_index_partitions_opsContext) + + // EnterRename_index_partition is called when entering the rename_index_partition production. + EnterRename_index_partition(c *Rename_index_partitionContext) + + // EnterDrop_index_partition is called when entering the drop_index_partition production. + EnterDrop_index_partition(c *Drop_index_partitionContext) + + // EnterSplit_index_partition is called when entering the split_index_partition production. + EnterSplit_index_partition(c *Split_index_partitionContext) + + // EnterIndex_partition_description is called when entering the index_partition_description production. + EnterIndex_partition_description(c *Index_partition_descriptionContext) + + // EnterModify_index_subpartition is called when entering the modify_index_subpartition production. + EnterModify_index_subpartition(c *Modify_index_subpartitionContext) + + // EnterPartition_name_old is called when entering the partition_name_old production. + EnterPartition_name_old(c *Partition_name_oldContext) + + // EnterNew_partition_name is called when entering the new_partition_name production. + EnterNew_partition_name(c *New_partition_nameContext) + + // EnterNew_index_name is called when entering the new_index_name production. + EnterNew_index_name(c *New_index_nameContext) + + // EnterAlter_inmemory_join_group is called when entering the alter_inmemory_join_group production. + EnterAlter_inmemory_join_group(c *Alter_inmemory_join_groupContext) + + // EnterCreate_user is called when entering the create_user production. + EnterCreate_user(c *Create_userContext) + + // EnterAlter_user is called when entering the alter_user production. + EnterAlter_user(c *Alter_userContext) + + // EnterDrop_user is called when entering the drop_user production. + EnterDrop_user(c *Drop_userContext) + + // EnterAlter_identified_by is called when entering the alter_identified_by production. + EnterAlter_identified_by(c *Alter_identified_byContext) + + // EnterIdentified_by is called when entering the identified_by production. + EnterIdentified_by(c *Identified_byContext) + + // EnterIdentified_other_clause is called when entering the identified_other_clause production. + EnterIdentified_other_clause(c *Identified_other_clauseContext) + + // EnterUser_tablespace_clause is called when entering the user_tablespace_clause production. + EnterUser_tablespace_clause(c *User_tablespace_clauseContext) + + // EnterQuota_clause is called when entering the quota_clause production. + EnterQuota_clause(c *Quota_clauseContext) + + // EnterProfile_clause is called when entering the profile_clause production. + EnterProfile_clause(c *Profile_clauseContext) + + // EnterRole_clause is called when entering the role_clause production. + EnterRole_clause(c *Role_clauseContext) + + // EnterUser_default_role_clause is called when entering the user_default_role_clause production. + EnterUser_default_role_clause(c *User_default_role_clauseContext) + + // EnterPassword_expire_clause is called when entering the password_expire_clause production. + EnterPassword_expire_clause(c *Password_expire_clauseContext) + + // EnterUser_lock_clause is called when entering the user_lock_clause production. + EnterUser_lock_clause(c *User_lock_clauseContext) + + // EnterUser_editions_clause is called when entering the user_editions_clause production. + EnterUser_editions_clause(c *User_editions_clauseContext) + + // EnterAlter_user_editions_clause is called when entering the alter_user_editions_clause production. + EnterAlter_user_editions_clause(c *Alter_user_editions_clauseContext) + + // EnterProxy_clause is called when entering the proxy_clause production. + EnterProxy_clause(c *Proxy_clauseContext) + + // EnterContainer_names is called when entering the container_names production. + EnterContainer_names(c *Container_namesContext) + + // EnterSet_container_data is called when entering the set_container_data production. + EnterSet_container_data(c *Set_container_dataContext) + + // EnterAdd_rem_container_data is called when entering the add_rem_container_data production. + EnterAdd_rem_container_data(c *Add_rem_container_dataContext) + + // EnterContainer_data_clause is called when entering the container_data_clause production. + EnterContainer_data_clause(c *Container_data_clauseContext) + + // EnterAdminister_key_management is called when entering the administer_key_management production. + EnterAdminister_key_management(c *Administer_key_managementContext) + + // EnterKeystore_management_clauses is called when entering the keystore_management_clauses production. + EnterKeystore_management_clauses(c *Keystore_management_clausesContext) + + // EnterCreate_keystore is called when entering the create_keystore production. + EnterCreate_keystore(c *Create_keystoreContext) + + // EnterOpen_keystore is called when entering the open_keystore production. + EnterOpen_keystore(c *Open_keystoreContext) + + // EnterForce_keystore is called when entering the force_keystore production. + EnterForce_keystore(c *Force_keystoreContext) + + // EnterClose_keystore is called when entering the close_keystore production. + EnterClose_keystore(c *Close_keystoreContext) + + // EnterBackup_keystore is called when entering the backup_keystore production. + EnterBackup_keystore(c *Backup_keystoreContext) + + // EnterAlter_keystore_password is called when entering the alter_keystore_password production. + EnterAlter_keystore_password(c *Alter_keystore_passwordContext) + + // EnterMerge_into_new_keystore is called when entering the merge_into_new_keystore production. + EnterMerge_into_new_keystore(c *Merge_into_new_keystoreContext) + + // EnterMerge_into_existing_keystore is called when entering the merge_into_existing_keystore production. + EnterMerge_into_existing_keystore(c *Merge_into_existing_keystoreContext) + + // EnterIsolate_keystore is called when entering the isolate_keystore production. + EnterIsolate_keystore(c *Isolate_keystoreContext) + + // EnterUnite_keystore is called when entering the unite_keystore production. + EnterUnite_keystore(c *Unite_keystoreContext) + + // EnterKey_management_clauses is called when entering the key_management_clauses production. + EnterKey_management_clauses(c *Key_management_clausesContext) + + // EnterSet_key is called when entering the set_key production. + EnterSet_key(c *Set_keyContext) + + // EnterCreate_key is called when entering the create_key production. + EnterCreate_key(c *Create_keyContext) + + // EnterMkid is called when entering the mkid production. + EnterMkid(c *MkidContext) + + // EnterMk is called when entering the mk production. + EnterMk(c *MkContext) + + // EnterUse_key is called when entering the use_key production. + EnterUse_key(c *Use_keyContext) + + // EnterSet_key_tag is called when entering the set_key_tag production. + EnterSet_key_tag(c *Set_key_tagContext) + + // EnterExport_keys is called when entering the export_keys production. + EnterExport_keys(c *Export_keysContext) + + // EnterImport_keys is called when entering the import_keys production. + EnterImport_keys(c *Import_keysContext) + + // EnterMigrate_keys is called when entering the migrate_keys production. + EnterMigrate_keys(c *Migrate_keysContext) + + // EnterReverse_migrate_keys is called when entering the reverse_migrate_keys production. + EnterReverse_migrate_keys(c *Reverse_migrate_keysContext) + + // EnterMove_keys is called when entering the move_keys production. + EnterMove_keys(c *Move_keysContext) + + // EnterIdentified_by_store is called when entering the identified_by_store production. + EnterIdentified_by_store(c *Identified_by_storeContext) + + // EnterUsing_algorithm_clause is called when entering the using_algorithm_clause production. + EnterUsing_algorithm_clause(c *Using_algorithm_clauseContext) + + // EnterUsing_tag_clause is called when entering the using_tag_clause production. + EnterUsing_tag_clause(c *Using_tag_clauseContext) + + // EnterSecret_management_clauses is called when entering the secret_management_clauses production. + EnterSecret_management_clauses(c *Secret_management_clausesContext) + + // EnterAdd_update_secret is called when entering the add_update_secret production. + EnterAdd_update_secret(c *Add_update_secretContext) + + // EnterDelete_secret is called when entering the delete_secret production. + EnterDelete_secret(c *Delete_secretContext) + + // EnterAdd_update_secret_seps is called when entering the add_update_secret_seps production. + EnterAdd_update_secret_seps(c *Add_update_secret_sepsContext) + + // EnterDelete_secret_seps is called when entering the delete_secret_seps production. + EnterDelete_secret_seps(c *Delete_secret_sepsContext) + + // EnterZero_downtime_software_patching_clauses is called when entering the zero_downtime_software_patching_clauses production. + EnterZero_downtime_software_patching_clauses(c *Zero_downtime_software_patching_clausesContext) + + // EnterWith_backup_clause is called when entering the with_backup_clause production. + EnterWith_backup_clause(c *With_backup_clauseContext) + + // EnterIdentified_by_password_clause is called when entering the identified_by_password_clause production. + EnterIdentified_by_password_clause(c *Identified_by_password_clauseContext) + + // EnterKeystore_password is called when entering the keystore_password production. + EnterKeystore_password(c *Keystore_passwordContext) + + // EnterPath is called when entering the path production. + EnterPath(c *PathContext) + + // EnterSecret is called when entering the secret production. + EnterSecret(c *SecretContext) + + // EnterAnalyze is called when entering the analyze production. + EnterAnalyze(c *AnalyzeContext) + + // EnterPartition_extention_clause is called when entering the partition_extention_clause production. + EnterPartition_extention_clause(c *Partition_extention_clauseContext) + + // EnterValidation_clauses is called when entering the validation_clauses production. + EnterValidation_clauses(c *Validation_clausesContext) + + // EnterCompute_clauses is called when entering the compute_clauses production. + EnterCompute_clauses(c *Compute_clausesContext) + + // EnterFor_clause is called when entering the for_clause production. + EnterFor_clause(c *For_clauseContext) + + // EnterOnline_or_offline is called when entering the online_or_offline production. + EnterOnline_or_offline(c *Online_or_offlineContext) + + // EnterInto_clause1 is called when entering the into_clause1 production. + EnterInto_clause1(c *Into_clause1Context) + + // EnterPartition_key_value is called when entering the partition_key_value production. + EnterPartition_key_value(c *Partition_key_valueContext) + + // EnterSubpartition_key_value is called when entering the subpartition_key_value production. + EnterSubpartition_key_value(c *Subpartition_key_valueContext) + + // EnterAssociate_statistics is called when entering the associate_statistics production. + EnterAssociate_statistics(c *Associate_statisticsContext) + + // EnterColumn_association is called when entering the column_association production. + EnterColumn_association(c *Column_associationContext) + + // EnterFunction_association is called when entering the function_association production. + EnterFunction_association(c *Function_associationContext) + + // EnterIndextype_name is called when entering the indextype_name production. + EnterIndextype_name(c *Indextype_nameContext) + + // EnterUsing_statistics_type is called when entering the using_statistics_type production. + EnterUsing_statistics_type(c *Using_statistics_typeContext) + + // EnterStatistics_type_name is called when entering the statistics_type_name production. + EnterStatistics_type_name(c *Statistics_type_nameContext) + + // EnterDefault_cost_clause is called when entering the default_cost_clause production. + EnterDefault_cost_clause(c *Default_cost_clauseContext) + + // EnterCpu_cost is called when entering the cpu_cost production. + EnterCpu_cost(c *Cpu_costContext) + + // EnterIo_cost is called when entering the io_cost production. + EnterIo_cost(c *Io_costContext) + + // EnterNetwork_cost is called when entering the network_cost production. + EnterNetwork_cost(c *Network_costContext) + + // EnterDefault_selectivity_clause is called when entering the default_selectivity_clause production. + EnterDefault_selectivity_clause(c *Default_selectivity_clauseContext) + + // EnterDefault_selectivity is called when entering the default_selectivity production. + EnterDefault_selectivity(c *Default_selectivityContext) + + // EnterStorage_table_clause is called when entering the storage_table_clause production. + EnterStorage_table_clause(c *Storage_table_clauseContext) + + // EnterUnified_auditing is called when entering the unified_auditing production. + EnterUnified_auditing(c *Unified_auditingContext) + + // EnterPolicy_name is called when entering the policy_name production. + EnterPolicy_name(c *Policy_nameContext) + + // EnterAudit_traditional is called when entering the audit_traditional production. + EnterAudit_traditional(c *Audit_traditionalContext) + + // EnterAudit_direct_path is called when entering the audit_direct_path production. + EnterAudit_direct_path(c *Audit_direct_pathContext) + + // EnterAudit_container_clause is called when entering the audit_container_clause production. + EnterAudit_container_clause(c *Audit_container_clauseContext) + + // EnterAudit_operation_clause is called when entering the audit_operation_clause production. + EnterAudit_operation_clause(c *Audit_operation_clauseContext) + + // EnterAuditing_by_clause is called when entering the auditing_by_clause production. + EnterAuditing_by_clause(c *Auditing_by_clauseContext) + + // EnterAudit_user is called when entering the audit_user production. + EnterAudit_user(c *Audit_userContext) + + // EnterAudit_schema_object_clause is called when entering the audit_schema_object_clause production. + EnterAudit_schema_object_clause(c *Audit_schema_object_clauseContext) + + // EnterSql_operation is called when entering the sql_operation production. + EnterSql_operation(c *Sql_operationContext) + + // EnterAuditing_on_clause is called when entering the auditing_on_clause production. + EnterAuditing_on_clause(c *Auditing_on_clauseContext) + + // EnterModel_name is called when entering the model_name production. + EnterModel_name(c *Model_nameContext) + + // EnterObject_name is called when entering the object_name production. + EnterObject_name(c *Object_nameContext) + + // EnterProfile_name is called when entering the profile_name production. + EnterProfile_name(c *Profile_nameContext) + + // EnterSql_statement_shortcut is called when entering the sql_statement_shortcut production. + EnterSql_statement_shortcut(c *Sql_statement_shortcutContext) + + // EnterDrop_index is called when entering the drop_index production. + EnterDrop_index(c *Drop_indexContext) + + // EnterDisassociate_statistics is called when entering the disassociate_statistics production. + EnterDisassociate_statistics(c *Disassociate_statisticsContext) + + // EnterDrop_indextype is called when entering the drop_indextype production. + EnterDrop_indextype(c *Drop_indextypeContext) + + // EnterDrop_inmemory_join_group is called when entering the drop_inmemory_join_group production. + EnterDrop_inmemory_join_group(c *Drop_inmemory_join_groupContext) + + // EnterFlashback_table is called when entering the flashback_table production. + EnterFlashback_table(c *Flashback_tableContext) + + // EnterRestore_point is called when entering the restore_point production. + EnterRestore_point(c *Restore_pointContext) + + // EnterPurge_statement is called when entering the purge_statement production. + EnterPurge_statement(c *Purge_statementContext) + + // EnterNoaudit_statement is called when entering the noaudit_statement production. + EnterNoaudit_statement(c *Noaudit_statementContext) + + // EnterRename_object is called when entering the rename_object production. + EnterRename_object(c *Rename_objectContext) + + // EnterGrant_statement is called when entering the grant_statement production. + EnterGrant_statement(c *Grant_statementContext) + + // EnterContainer_clause is called when entering the container_clause production. + EnterContainer_clause(c *Container_clauseContext) + + // EnterRevoke_statement is called when entering the revoke_statement production. + EnterRevoke_statement(c *Revoke_statementContext) + + // EnterRevoke_system_privilege is called when entering the revoke_system_privilege production. + EnterRevoke_system_privilege(c *Revoke_system_privilegeContext) + + // EnterRevokee_clause is called when entering the revokee_clause production. + EnterRevokee_clause(c *Revokee_clauseContext) + + // EnterRevoke_object_privileges is called when entering the revoke_object_privileges production. + EnterRevoke_object_privileges(c *Revoke_object_privilegesContext) + + // EnterOn_object_clause is called when entering the on_object_clause production. + EnterOn_object_clause(c *On_object_clauseContext) + + // EnterRevoke_roles_from_programs is called when entering the revoke_roles_from_programs production. + EnterRevoke_roles_from_programs(c *Revoke_roles_from_programsContext) + + // EnterProgram_unit is called when entering the program_unit production. + EnterProgram_unit(c *Program_unitContext) + + // EnterCreate_dimension is called when entering the create_dimension production. + EnterCreate_dimension(c *Create_dimensionContext) + + // EnterCreate_directory is called when entering the create_directory production. + EnterCreate_directory(c *Create_directoryContext) + + // EnterDirectory_name is called when entering the directory_name production. + EnterDirectory_name(c *Directory_nameContext) + + // EnterDirectory_path is called when entering the directory_path production. + EnterDirectory_path(c *Directory_pathContext) + + // EnterCreate_inmemory_join_group is called when entering the create_inmemory_join_group production. + EnterCreate_inmemory_join_group(c *Create_inmemory_join_groupContext) + + // EnterDrop_hierarchy is called when entering the drop_hierarchy production. + EnterDrop_hierarchy(c *Drop_hierarchyContext) + + // EnterAlter_library is called when entering the alter_library production. + EnterAlter_library(c *Alter_libraryContext) + + // EnterDrop_java is called when entering the drop_java production. + EnterDrop_java(c *Drop_javaContext) + + // EnterDrop_library is called when entering the drop_library production. + EnterDrop_library(c *Drop_libraryContext) + + // EnterCreate_java is called when entering the create_java production. + EnterCreate_java(c *Create_javaContext) + + // EnterCreate_library is called when entering the create_library production. + EnterCreate_library(c *Create_libraryContext) + + // EnterPlsql_library_source is called when entering the plsql_library_source production. + EnterPlsql_library_source(c *Plsql_library_sourceContext) + + // EnterCredential_name is called when entering the credential_name production. + EnterCredential_name(c *Credential_nameContext) + + // EnterLibrary_editionable is called when entering the library_editionable production. + EnterLibrary_editionable(c *Library_editionableContext) + + // EnterLibrary_debug is called when entering the library_debug production. + EnterLibrary_debug(c *Library_debugContext) + + // EnterCompiler_parameters_clause is called when entering the compiler_parameters_clause production. + EnterCompiler_parameters_clause(c *Compiler_parameters_clauseContext) + + // EnterParameter_value is called when entering the parameter_value production. + EnterParameter_value(c *Parameter_valueContext) + + // EnterLibrary_name is called when entering the library_name production. + EnterLibrary_name(c *Library_nameContext) + + // EnterAlter_dimension is called when entering the alter_dimension production. + EnterAlter_dimension(c *Alter_dimensionContext) + + // EnterLevel_clause is called when entering the level_clause production. + EnterLevel_clause(c *Level_clauseContext) + + // EnterHierarchy_clause is called when entering the hierarchy_clause production. + EnterHierarchy_clause(c *Hierarchy_clauseContext) + + // EnterDimension_join_clause is called when entering the dimension_join_clause production. + EnterDimension_join_clause(c *Dimension_join_clauseContext) + + // EnterAttribute_clause is called when entering the attribute_clause production. + EnterAttribute_clause(c *Attribute_clauseContext) + + // EnterExtended_attribute_clause is called when entering the extended_attribute_clause production. + EnterExtended_attribute_clause(c *Extended_attribute_clauseContext) + + // EnterColumn_one_or_more_sub_clause is called when entering the column_one_or_more_sub_clause production. + EnterColumn_one_or_more_sub_clause(c *Column_one_or_more_sub_clauseContext) + + // EnterAlter_view is called when entering the alter_view production. + EnterAlter_view(c *Alter_viewContext) + + // EnterAlter_view_editionable is called when entering the alter_view_editionable production. + EnterAlter_view_editionable(c *Alter_view_editionableContext) + + // EnterCreate_view is called when entering the create_view production. + EnterCreate_view(c *Create_viewContext) + + // EnterEditioning_clause is called when entering the editioning_clause production. + EnterEditioning_clause(c *Editioning_clauseContext) + + // EnterView_options is called when entering the view_options production. + EnterView_options(c *View_optionsContext) + + // EnterView_alias_constraint is called when entering the view_alias_constraint production. + EnterView_alias_constraint(c *View_alias_constraintContext) + + // EnterObject_view_clause is called when entering the object_view_clause production. + EnterObject_view_clause(c *Object_view_clauseContext) + + // EnterInline_constraint is called when entering the inline_constraint production. + EnterInline_constraint(c *Inline_constraintContext) + + // EnterInline_ref_constraint is called when entering the inline_ref_constraint production. + EnterInline_ref_constraint(c *Inline_ref_constraintContext) + + // EnterOut_of_line_ref_constraint is called when entering the out_of_line_ref_constraint production. + EnterOut_of_line_ref_constraint(c *Out_of_line_ref_constraintContext) + + // EnterOut_of_line_constraint is called when entering the out_of_line_constraint production. + EnterOut_of_line_constraint(c *Out_of_line_constraintContext) + + // EnterConstraint_state is called when entering the constraint_state production. + EnterConstraint_state(c *Constraint_stateContext) + + // EnterXmltype_view_clause is called when entering the xmltype_view_clause production. + EnterXmltype_view_clause(c *Xmltype_view_clauseContext) + + // EnterXml_schema_spec is called when entering the xml_schema_spec production. + EnterXml_schema_spec(c *Xml_schema_specContext) + + // EnterXml_schema_url is called when entering the xml_schema_url production. + EnterXml_schema_url(c *Xml_schema_urlContext) + + // EnterElement is called when entering the element production. + EnterElement(c *ElementContext) + + // EnterAlter_tablespace is called when entering the alter_tablespace production. + EnterAlter_tablespace(c *Alter_tablespaceContext) + + // EnterDatafile_tempfile_clauses is called when entering the datafile_tempfile_clauses production. + EnterDatafile_tempfile_clauses(c *Datafile_tempfile_clausesContext) + + // EnterTablespace_logging_clauses is called when entering the tablespace_logging_clauses production. + EnterTablespace_logging_clauses(c *Tablespace_logging_clausesContext) + + // EnterTablespace_group_clause is called when entering the tablespace_group_clause production. + EnterTablespace_group_clause(c *Tablespace_group_clauseContext) + + // EnterTablespace_group_name is called when entering the tablespace_group_name production. + EnterTablespace_group_name(c *Tablespace_group_nameContext) + + // EnterTablespace_state_clauses is called when entering the tablespace_state_clauses production. + EnterTablespace_state_clauses(c *Tablespace_state_clausesContext) + + // EnterFlashback_mode_clause is called when entering the flashback_mode_clause production. + EnterFlashback_mode_clause(c *Flashback_mode_clauseContext) + + // EnterNew_tablespace_name is called when entering the new_tablespace_name production. + EnterNew_tablespace_name(c *New_tablespace_nameContext) + + // EnterCreate_tablespace is called when entering the create_tablespace production. + EnterCreate_tablespace(c *Create_tablespaceContext) + + // EnterPermanent_tablespace_clause is called when entering the permanent_tablespace_clause production. + EnterPermanent_tablespace_clause(c *Permanent_tablespace_clauseContext) + + // EnterTablespace_encryption_spec is called when entering the tablespace_encryption_spec production. + EnterTablespace_encryption_spec(c *Tablespace_encryption_specContext) + + // EnterLogging_clause is called when entering the logging_clause production. + EnterLogging_clause(c *Logging_clauseContext) + + // EnterExtent_management_clause is called when entering the extent_management_clause production. + EnterExtent_management_clause(c *Extent_management_clauseContext) + + // EnterSegment_management_clause is called when entering the segment_management_clause production. + EnterSegment_management_clause(c *Segment_management_clauseContext) + + // EnterTemporary_tablespace_clause is called when entering the temporary_tablespace_clause production. + EnterTemporary_tablespace_clause(c *Temporary_tablespace_clauseContext) + + // EnterUndo_tablespace_clause is called when entering the undo_tablespace_clause production. + EnterUndo_tablespace_clause(c *Undo_tablespace_clauseContext) + + // EnterTablespace_retention_clause is called when entering the tablespace_retention_clause production. + EnterTablespace_retention_clause(c *Tablespace_retention_clauseContext) + + // EnterCreate_tablespace_set is called when entering the create_tablespace_set production. + EnterCreate_tablespace_set(c *Create_tablespace_setContext) + + // EnterPermanent_tablespace_attrs is called when entering the permanent_tablespace_attrs production. + EnterPermanent_tablespace_attrs(c *Permanent_tablespace_attrsContext) + + // EnterTablespace_encryption_clause is called when entering the tablespace_encryption_clause production. + EnterTablespace_encryption_clause(c *Tablespace_encryption_clauseContext) + + // EnterDefault_tablespace_params is called when entering the default_tablespace_params production. + EnterDefault_tablespace_params(c *Default_tablespace_paramsContext) + + // EnterDefault_table_compression is called when entering the default_table_compression production. + EnterDefault_table_compression(c *Default_table_compressionContext) + + // EnterLow_high is called when entering the low_high production. + EnterLow_high(c *Low_highContext) + + // EnterDefault_index_compression is called when entering the default_index_compression production. + EnterDefault_index_compression(c *Default_index_compressionContext) + + // EnterInmmemory_clause is called when entering the inmmemory_clause production. + EnterInmmemory_clause(c *Inmmemory_clauseContext) + + // EnterDatafile_specification is called when entering the datafile_specification production. + EnterDatafile_specification(c *Datafile_specificationContext) + + // EnterTempfile_specification is called when entering the tempfile_specification production. + EnterTempfile_specification(c *Tempfile_specificationContext) + + // EnterDatafile_tempfile_spec is called when entering the datafile_tempfile_spec production. + EnterDatafile_tempfile_spec(c *Datafile_tempfile_specContext) + + // EnterRedo_log_file_spec is called when entering the redo_log_file_spec production. + EnterRedo_log_file_spec(c *Redo_log_file_specContext) + + // EnterAutoextend_clause is called when entering the autoextend_clause production. + EnterAutoextend_clause(c *Autoextend_clauseContext) + + // EnterMaxsize_clause is called when entering the maxsize_clause production. + EnterMaxsize_clause(c *Maxsize_clauseContext) + + // EnterBuild_clause is called when entering the build_clause production. + EnterBuild_clause(c *Build_clauseContext) + + // EnterParallel_clause is called when entering the parallel_clause production. + EnterParallel_clause(c *Parallel_clauseContext) + + // EnterParallel_instances_clause is called when entering the parallel_instances_clause production. + EnterParallel_instances_clause(c *Parallel_instances_clauseContext) + + // EnterAlter_materialized_view is called when entering the alter_materialized_view production. + EnterAlter_materialized_view(c *Alter_materialized_viewContext) + + // EnterAlter_mv_option1 is called when entering the alter_mv_option1 production. + EnterAlter_mv_option1(c *Alter_mv_option1Context) + + // EnterAlter_mv_refresh is called when entering the alter_mv_refresh production. + EnterAlter_mv_refresh(c *Alter_mv_refreshContext) + + // EnterRollback_segment is called when entering the rollback_segment production. + EnterRollback_segment(c *Rollback_segmentContext) + + // EnterModify_mv_column_clause is called when entering the modify_mv_column_clause production. + EnterModify_mv_column_clause(c *Modify_mv_column_clauseContext) + + // EnterAlter_materialized_view_log is called when entering the alter_materialized_view_log production. + EnterAlter_materialized_view_log(c *Alter_materialized_view_logContext) + + // EnterAdd_mv_log_column_clause is called when entering the add_mv_log_column_clause production. + EnterAdd_mv_log_column_clause(c *Add_mv_log_column_clauseContext) + + // EnterMove_mv_log_clause is called when entering the move_mv_log_clause production. + EnterMove_mv_log_clause(c *Move_mv_log_clauseContext) + + // EnterMv_log_augmentation is called when entering the mv_log_augmentation production. + EnterMv_log_augmentation(c *Mv_log_augmentationContext) + + // EnterCreate_materialized_view_log is called when entering the create_materialized_view_log production. + EnterCreate_materialized_view_log(c *Create_materialized_view_logContext) + + // EnterNew_values_clause is called when entering the new_values_clause production. + EnterNew_values_clause(c *New_values_clauseContext) + + // EnterMv_log_purge_clause is called when entering the mv_log_purge_clause production. + EnterMv_log_purge_clause(c *Mv_log_purge_clauseContext) + + // EnterCreate_materialized_zonemap is called when entering the create_materialized_zonemap production. + EnterCreate_materialized_zonemap(c *Create_materialized_zonemapContext) + + // EnterAlter_materialized_zonemap is called when entering the alter_materialized_zonemap production. + EnterAlter_materialized_zonemap(c *Alter_materialized_zonemapContext) + + // EnterDrop_materialized_zonemap is called when entering the drop_materialized_zonemap production. + EnterDrop_materialized_zonemap(c *Drop_materialized_zonemapContext) + + // EnterZonemap_refresh_clause is called when entering the zonemap_refresh_clause production. + EnterZonemap_refresh_clause(c *Zonemap_refresh_clauseContext) + + // EnterZonemap_attributes is called when entering the zonemap_attributes production. + EnterZonemap_attributes(c *Zonemap_attributesContext) + + // EnterZonemap_name is called when entering the zonemap_name production. + EnterZonemap_name(c *Zonemap_nameContext) + + // EnterOperator_name is called when entering the operator_name production. + EnterOperator_name(c *Operator_nameContext) + + // EnterOperator_function_name is called when entering the operator_function_name production. + EnterOperator_function_name(c *Operator_function_nameContext) + + // EnterCreate_zonemap_on_table is called when entering the create_zonemap_on_table production. + EnterCreate_zonemap_on_table(c *Create_zonemap_on_tableContext) + + // EnterCreate_zonemap_as_subquery is called when entering the create_zonemap_as_subquery production. + EnterCreate_zonemap_as_subquery(c *Create_zonemap_as_subqueryContext) + + // EnterAlter_operator is called when entering the alter_operator production. + EnterAlter_operator(c *Alter_operatorContext) + + // EnterDrop_operator is called when entering the drop_operator production. + EnterDrop_operator(c *Drop_operatorContext) + + // EnterCreate_operator is called when entering the create_operator production. + EnterCreate_operator(c *Create_operatorContext) + + // EnterBinding_clause is called when entering the binding_clause production. + EnterBinding_clause(c *Binding_clauseContext) + + // EnterAdd_binding_clause is called when entering the add_binding_clause production. + EnterAdd_binding_clause(c *Add_binding_clauseContext) + + // EnterImplementation_clause is called when entering the implementation_clause production. + EnterImplementation_clause(c *Implementation_clauseContext) + + // EnterPrimary_operator_list is called when entering the primary_operator_list production. + EnterPrimary_operator_list(c *Primary_operator_listContext) + + // EnterPrimary_operator_item is called when entering the primary_operator_item production. + EnterPrimary_operator_item(c *Primary_operator_itemContext) + + // EnterOperator_context_clause is called when entering the operator_context_clause production. + EnterOperator_context_clause(c *Operator_context_clauseContext) + + // EnterUsing_function_clause is called when entering the using_function_clause production. + EnterUsing_function_clause(c *Using_function_clauseContext) + + // EnterDrop_binding_clause is called when entering the drop_binding_clause production. + EnterDrop_binding_clause(c *Drop_binding_clauseContext) + + // EnterCreate_materialized_view is called when entering the create_materialized_view production. + EnterCreate_materialized_view(c *Create_materialized_viewContext) + + // EnterScoped_table_ref_constraint is called when entering the scoped_table_ref_constraint production. + EnterScoped_table_ref_constraint(c *Scoped_table_ref_constraintContext) + + // EnterMv_column_alias is called when entering the mv_column_alias production. + EnterMv_column_alias(c *Mv_column_aliasContext) + + // EnterCreate_mv_refresh is called when entering the create_mv_refresh production. + EnterCreate_mv_refresh(c *Create_mv_refreshContext) + + // EnterQuery_rewrite_clause is called when entering the query_rewrite_clause production. + EnterQuery_rewrite_clause(c *Query_rewrite_clauseContext) + + // EnterUnusable_editions_clause is called when entering the unusable_editions_clause production. + EnterUnusable_editions_clause(c *Unusable_editions_clauseContext) + + // EnterDrop_materialized_view is called when entering the drop_materialized_view production. + EnterDrop_materialized_view(c *Drop_materialized_viewContext) + + // EnterDrop_materialized_view_log is called when entering the drop_materialized_view_log production. + EnterDrop_materialized_view_log(c *Drop_materialized_view_logContext) + + // EnterCreate_context is called when entering the create_context production. + EnterCreate_context(c *Create_contextContext) + + // EnterOracle_namespace is called when entering the oracle_namespace production. + EnterOracle_namespace(c *Oracle_namespaceContext) + + // EnterCreate_cluster is called when entering the create_cluster production. + EnterCreate_cluster(c *Create_clusterContext) + + // EnterCreate_profile is called when entering the create_profile production. + EnterCreate_profile(c *Create_profileContext) + + // EnterResource_parameters is called when entering the resource_parameters production. + EnterResource_parameters(c *Resource_parametersContext) + + // EnterPassword_parameters is called when entering the password_parameters production. + EnterPassword_parameters(c *Password_parametersContext) + + // EnterCreate_lockdown_profile is called when entering the create_lockdown_profile production. + EnterCreate_lockdown_profile(c *Create_lockdown_profileContext) + + // EnterStatic_base_profile is called when entering the static_base_profile production. + EnterStatic_base_profile(c *Static_base_profileContext) + + // EnterDynamic_base_profile is called when entering the dynamic_base_profile production. + EnterDynamic_base_profile(c *Dynamic_base_profileContext) + + // EnterCreate_outline is called when entering the create_outline production. + EnterCreate_outline(c *Create_outlineContext) + + // EnterCreate_restore_point is called when entering the create_restore_point production. + EnterCreate_restore_point(c *Create_restore_pointContext) + + // EnterCreate_role is called when entering the create_role production. + EnterCreate_role(c *Create_roleContext) + + // EnterCreate_table is called when entering the create_table production. + EnterCreate_table(c *Create_tableContext) + + // EnterXmltype_table is called when entering the xmltype_table production. + EnterXmltype_table(c *Xmltype_tableContext) + + // EnterXmltype_virtual_columns is called when entering the xmltype_virtual_columns production. + EnterXmltype_virtual_columns(c *Xmltype_virtual_columnsContext) + + // EnterXmltype_column_properties is called when entering the xmltype_column_properties production. + EnterXmltype_column_properties(c *Xmltype_column_propertiesContext) + + // EnterXmltype_storage is called when entering the xmltype_storage production. + EnterXmltype_storage(c *Xmltype_storageContext) + + // EnterXmlschema_spec is called when entering the xmlschema_spec production. + EnterXmlschema_spec(c *Xmlschema_specContext) + + // EnterObject_table is called when entering the object_table production. + EnterObject_table(c *Object_tableContext) + + // EnterObject_type is called when entering the object_type production. + EnterObject_type(c *Object_typeContext) + + // EnterOid_index_clause is called when entering the oid_index_clause production. + EnterOid_index_clause(c *Oid_index_clauseContext) + + // EnterOid_clause is called when entering the oid_clause production. + EnterOid_clause(c *Oid_clauseContext) + + // EnterObject_properties is called when entering the object_properties production. + EnterObject_properties(c *Object_propertiesContext) + + // EnterObject_table_substitution is called when entering the object_table_substitution production. + EnterObject_table_substitution(c *Object_table_substitutionContext) + + // EnterRelational_table is called when entering the relational_table production. + EnterRelational_table(c *Relational_tableContext) + + // EnterRelational_table_properties is called when entering the relational_table_properties production. + EnterRelational_table_properties(c *Relational_table_propertiesContext) + + // EnterRelational_table_property is called when entering the relational_table_property production. + EnterRelational_table_property(c *Relational_table_propertyContext) + + // EnterImmutable_table_clauses is called when entering the immutable_table_clauses production. + EnterImmutable_table_clauses(c *Immutable_table_clausesContext) + + // EnterImmutable_table_no_drop_clause is called when entering the immutable_table_no_drop_clause production. + EnterImmutable_table_no_drop_clause(c *Immutable_table_no_drop_clauseContext) + + // EnterImmutable_table_no_delete_clause is called when entering the immutable_table_no_delete_clause production. + EnterImmutable_table_no_delete_clause(c *Immutable_table_no_delete_clauseContext) + + // EnterBlockchain_table_clauses is called when entering the blockchain_table_clauses production. + EnterBlockchain_table_clauses(c *Blockchain_table_clausesContext) + + // EnterBlockchain_drop_table_clause is called when entering the blockchain_drop_table_clause production. + EnterBlockchain_drop_table_clause(c *Blockchain_drop_table_clauseContext) + + // EnterBlockchain_row_retention_clause is called when entering the blockchain_row_retention_clause production. + EnterBlockchain_row_retention_clause(c *Blockchain_row_retention_clauseContext) + + // EnterBlockchain_hash_and_data_format_clause is called when entering the blockchain_hash_and_data_format_clause production. + EnterBlockchain_hash_and_data_format_clause(c *Blockchain_hash_and_data_format_clauseContext) + + // EnterCollation_name is called when entering the collation_name production. + EnterCollation_name(c *Collation_nameContext) + + // EnterTable_properties is called when entering the table_properties production. + EnterTable_properties(c *Table_propertiesContext) + + // EnterRead_only_clause is called when entering the read_only_clause production. + EnterRead_only_clause(c *Read_only_clauseContext) + + // EnterIndexing_clause is called when entering the indexing_clause production. + EnterIndexing_clause(c *Indexing_clauseContext) + + // EnterAttribute_clustering_clause is called when entering the attribute_clustering_clause production. + EnterAttribute_clustering_clause(c *Attribute_clustering_clauseContext) + + // EnterClustering_join is called when entering the clustering_join production. + EnterClustering_join(c *Clustering_joinContext) + + // EnterClustering_join_item is called when entering the clustering_join_item production. + EnterClustering_join_item(c *Clustering_join_itemContext) + + // EnterEquijoin_condition is called when entering the equijoin_condition production. + EnterEquijoin_condition(c *Equijoin_conditionContext) + + // EnterCluster_clause is called when entering the cluster_clause production. + EnterCluster_clause(c *Cluster_clauseContext) + + // EnterClustering_columns is called when entering the clustering_columns production. + EnterClustering_columns(c *Clustering_columnsContext) + + // EnterClustering_column_group is called when entering the clustering_column_group production. + EnterClustering_column_group(c *Clustering_column_groupContext) + + // EnterYes_no is called when entering the yes_no production. + EnterYes_no(c *Yes_noContext) + + // EnterZonemap_clause is called when entering the zonemap_clause production. + EnterZonemap_clause(c *Zonemap_clauseContext) + + // EnterLogical_replication_clause is called when entering the logical_replication_clause production. + EnterLogical_replication_clause(c *Logical_replication_clauseContext) + + // EnterTable_name is called when entering the table_name production. + EnterTable_name(c *Table_nameContext) + + // EnterRelational_property is called when entering the relational_property production. + EnterRelational_property(c *Relational_propertyContext) + + // EnterTable_partitioning_clauses is called when entering the table_partitioning_clauses production. + EnterTable_partitioning_clauses(c *Table_partitioning_clausesContext) + + // EnterRange_partitions is called when entering the range_partitions production. + EnterRange_partitions(c *Range_partitionsContext) + + // EnterList_partitions is called when entering the list_partitions production. + EnterList_partitions(c *List_partitionsContext) + + // EnterHash_partitions is called when entering the hash_partitions production. + EnterHash_partitions(c *Hash_partitionsContext) + + // EnterIndividual_hash_partitions is called when entering the individual_hash_partitions production. + EnterIndividual_hash_partitions(c *Individual_hash_partitionsContext) + + // EnterHash_partitions_by_quantity is called when entering the hash_partitions_by_quantity production. + EnterHash_partitions_by_quantity(c *Hash_partitions_by_quantityContext) + + // EnterHash_partition_quantity is called when entering the hash_partition_quantity production. + EnterHash_partition_quantity(c *Hash_partition_quantityContext) + + // EnterComposite_range_partitions is called when entering the composite_range_partitions production. + EnterComposite_range_partitions(c *Composite_range_partitionsContext) + + // EnterComposite_list_partitions is called when entering the composite_list_partitions production. + EnterComposite_list_partitions(c *Composite_list_partitionsContext) + + // EnterComposite_hash_partitions is called when entering the composite_hash_partitions production. + EnterComposite_hash_partitions(c *Composite_hash_partitionsContext) + + // EnterReference_partitioning is called when entering the reference_partitioning production. + EnterReference_partitioning(c *Reference_partitioningContext) + + // EnterReference_partition_desc is called when entering the reference_partition_desc production. + EnterReference_partition_desc(c *Reference_partition_descContext) + + // EnterSystem_partitioning is called when entering the system_partitioning production. + EnterSystem_partitioning(c *System_partitioningContext) + + // EnterRange_partition_desc is called when entering the range_partition_desc production. + EnterRange_partition_desc(c *Range_partition_descContext) + + // EnterList_partition_desc is called when entering the list_partition_desc production. + EnterList_partition_desc(c *List_partition_descContext) + + // EnterSubpartition_template is called when entering the subpartition_template production. + EnterSubpartition_template(c *Subpartition_templateContext) + + // EnterHash_subpartition_quantity is called when entering the hash_subpartition_quantity production. + EnterHash_subpartition_quantity(c *Hash_subpartition_quantityContext) + + // EnterSubpartition_by_range is called when entering the subpartition_by_range production. + EnterSubpartition_by_range(c *Subpartition_by_rangeContext) + + // EnterSubpartition_by_list is called when entering the subpartition_by_list production. + EnterSubpartition_by_list(c *Subpartition_by_listContext) + + // EnterSubpartition_by_hash is called when entering the subpartition_by_hash production. + EnterSubpartition_by_hash(c *Subpartition_by_hashContext) + + // EnterSubpartition_name is called when entering the subpartition_name production. + EnterSubpartition_name(c *Subpartition_nameContext) + + // EnterRange_subpartition_desc is called when entering the range_subpartition_desc production. + EnterRange_subpartition_desc(c *Range_subpartition_descContext) + + // EnterList_subpartition_desc is called when entering the list_subpartition_desc production. + EnterList_subpartition_desc(c *List_subpartition_descContext) + + // EnterIndividual_hash_subparts is called when entering the individual_hash_subparts production. + EnterIndividual_hash_subparts(c *Individual_hash_subpartsContext) + + // EnterHash_subparts_by_quantity is called when entering the hash_subparts_by_quantity production. + EnterHash_subparts_by_quantity(c *Hash_subparts_by_quantityContext) + + // EnterRange_values_clause is called when entering the range_values_clause production. + EnterRange_values_clause(c *Range_values_clauseContext) + + // EnterRange_values_list is called when entering the range_values_list production. + EnterRange_values_list(c *Range_values_listContext) + + // EnterList_values_clause is called when entering the list_values_clause production. + EnterList_values_clause(c *List_values_clauseContext) + + // EnterTable_partition_description is called when entering the table_partition_description production. + EnterTable_partition_description(c *Table_partition_descriptionContext) + + // EnterPartitioning_storage_clause is called when entering the partitioning_storage_clause production. + EnterPartitioning_storage_clause(c *Partitioning_storage_clauseContext) + + // EnterLob_partitioning_storage is called when entering the lob_partitioning_storage production. + EnterLob_partitioning_storage(c *Lob_partitioning_storageContext) + + // EnterSize_clause is called when entering the size_clause production. + EnterSize_clause(c *Size_clauseContext) + + // EnterTable_compression is called when entering the table_compression production. + EnterTable_compression(c *Table_compressionContext) + + // EnterInmemory_table_clause is called when entering the inmemory_table_clause production. + EnterInmemory_table_clause(c *Inmemory_table_clauseContext) + + // EnterInmemory_attributes is called when entering the inmemory_attributes production. + EnterInmemory_attributes(c *Inmemory_attributesContext) + + // EnterInmemory_memcompress is called when entering the inmemory_memcompress production. + EnterInmemory_memcompress(c *Inmemory_memcompressContext) + + // EnterInmemory_priority is called when entering the inmemory_priority production. + EnterInmemory_priority(c *Inmemory_priorityContext) + + // EnterInmemory_distribute is called when entering the inmemory_distribute production. + EnterInmemory_distribute(c *Inmemory_distributeContext) + + // EnterInmemory_duplicate is called when entering the inmemory_duplicate production. + EnterInmemory_duplicate(c *Inmemory_duplicateContext) + + // EnterInmemory_column_clause is called when entering the inmemory_column_clause production. + EnterInmemory_column_clause(c *Inmemory_column_clauseContext) + + // EnterPhysical_attributes_clause is called when entering the physical_attributes_clause production. + EnterPhysical_attributes_clause(c *Physical_attributes_clauseContext) + + // EnterStorage_clause is called when entering the storage_clause production. + EnterStorage_clause(c *Storage_clauseContext) + + // EnterDeferred_segment_creation is called when entering the deferred_segment_creation production. + EnterDeferred_segment_creation(c *Deferred_segment_creationContext) + + // EnterSegment_attributes_clause is called when entering the segment_attributes_clause production. + EnterSegment_attributes_clause(c *Segment_attributes_clauseContext) + + // EnterPhysical_properties is called when entering the physical_properties production. + EnterPhysical_properties(c *Physical_propertiesContext) + + // EnterIlm_clause is called when entering the ilm_clause production. + EnterIlm_clause(c *Ilm_clauseContext) + + // EnterIlm_policy_clause is called when entering the ilm_policy_clause production. + EnterIlm_policy_clause(c *Ilm_policy_clauseContext) + + // EnterIlm_compression_policy is called when entering the ilm_compression_policy production. + EnterIlm_compression_policy(c *Ilm_compression_policyContext) + + // EnterIlm_tiering_policy is called when entering the ilm_tiering_policy production. + EnterIlm_tiering_policy(c *Ilm_tiering_policyContext) + + // EnterIlm_after_on is called when entering the ilm_after_on production. + EnterIlm_after_on(c *Ilm_after_onContext) + + // EnterSegment_group is called when entering the segment_group production. + EnterSegment_group(c *Segment_groupContext) + + // EnterIlm_inmemory_policy is called when entering the ilm_inmemory_policy production. + EnterIlm_inmemory_policy(c *Ilm_inmemory_policyContext) + + // EnterIlm_time_period is called when entering the ilm_time_period production. + EnterIlm_time_period(c *Ilm_time_periodContext) + + // EnterHeap_org_table_clause is called when entering the heap_org_table_clause production. + EnterHeap_org_table_clause(c *Heap_org_table_clauseContext) + + // EnterExternal_table_clause is called when entering the external_table_clause production. + EnterExternal_table_clause(c *External_table_clauseContext) + + // EnterAccess_driver_type is called when entering the access_driver_type production. + EnterAccess_driver_type(c *Access_driver_typeContext) + + // EnterExternal_table_data_props is called when entering the external_table_data_props production. + EnterExternal_table_data_props(c *External_table_data_propsContext) + + // EnterExternal_table_data_format is called when entering the external_table_data_format production. + EnterExternal_table_data_format(c *External_table_data_formatContext) + + // EnterExternal_table_transform is called when entering the external_table_transform production. + EnterExternal_table_transform(c *External_table_transformContext) + + // EnterExternal_table_field is called when entering the external_table_field production. + EnterExternal_table_field(c *External_table_fieldContext) + + // EnterExternal_table_field_list is called when entering the external_table_field_list production. + EnterExternal_table_field_list(c *External_table_field_listContext) + + // EnterExternal_table_fields_clause is called when entering the external_table_fields_clause production. + EnterExternal_table_fields_clause(c *External_table_fields_clauseContext) + + // EnterExternal_table_position_clause is called when entering the external_table_position_clause production. + EnterExternal_table_position_clause(c *External_table_position_clauseContext) + + // EnterExternal_table_datatype_clause is called when entering the external_table_datatype_clause production. + EnterExternal_table_datatype_clause(c *External_table_datatype_clauseContext) + + // EnterExternal_table_delimit_clause is called when entering the external_table_delimit_clause production. + EnterExternal_table_delimit_clause(c *External_table_delimit_clauseContext) + + // EnterExternal_table_trim_clause is called when entering the external_table_trim_clause production. + EnterExternal_table_trim_clause(c *External_table_trim_clauseContext) + + // EnterExternal_table_date_format_clause is called when entering the external_table_date_format_clause production. + EnterExternal_table_date_format_clause(c *External_table_date_format_clauseContext) + + // EnterExternal_table_init_clause is called when entering the external_table_init_clause production. + EnterExternal_table_init_clause(c *External_table_init_clauseContext) + + // EnterExternal_table_condition_clause is called when entering the external_table_condition_clause production. + EnterExternal_table_condition_clause(c *External_table_condition_clauseContext) + + // EnterExternal_table_lls_clause is called when entering the external_table_lls_clause production. + EnterExternal_table_lls_clause(c *External_table_lls_clauseContext) + + // EnterExternal_table_records is called when entering the external_table_records production. + EnterExternal_table_records(c *External_table_recordsContext) + + // EnterExternal_table_record_options_clause is called when entering the external_table_record_options_clause production. + EnterExternal_table_record_options_clause(c *External_table_record_options_clauseContext) + + // EnterExternal_table_output_files is called when entering the external_table_output_files production. + EnterExternal_table_output_files(c *External_table_output_filesContext) + + // EnterExternal_table_fields is called when entering the external_table_fields production. + EnterExternal_table_fields(c *External_table_fieldsContext) + + // EnterExternal_table_datapump is called when entering the external_table_datapump production. + EnterExternal_table_datapump(c *External_table_datapumpContext) + + // EnterExternal_table_hive is called when entering the external_table_hive production. + EnterExternal_table_hive(c *External_table_hiveContext) + + // EnterExternal_table_hive_parameter_map is called when entering the external_table_hive_parameter_map production. + EnterExternal_table_hive_parameter_map(c *External_table_hive_parameter_mapContext) + + // EnterExternal_table_hive_parameter_map_entry is called when entering the external_table_hive_parameter_map_entry production. + EnterExternal_table_hive_parameter_map_entry(c *External_table_hive_parameter_map_entryContext) + + // EnterExternal_table_directory is called when entering the external_table_directory production. + EnterExternal_table_directory(c *External_table_directoryContext) + + // EnterRow_movement_clause is called when entering the row_movement_clause production. + EnterRow_movement_clause(c *Row_movement_clauseContext) + + // EnterFlashback_archive_clause is called when entering the flashback_archive_clause production. + EnterFlashback_archive_clause(c *Flashback_archive_clauseContext) + + // EnterLog_grp is called when entering the log_grp production. + EnterLog_grp(c *Log_grpContext) + + // EnterSupplemental_table_logging is called when entering the supplemental_table_logging production. + EnterSupplemental_table_logging(c *Supplemental_table_loggingContext) + + // EnterSupplemental_log_grp_clause is called when entering the supplemental_log_grp_clause production. + EnterSupplemental_log_grp_clause(c *Supplemental_log_grp_clauseContext) + + // EnterSupplemental_id_key_clause is called when entering the supplemental_id_key_clause production. + EnterSupplemental_id_key_clause(c *Supplemental_id_key_clauseContext) + + // EnterAllocate_extent_clause is called when entering the allocate_extent_clause production. + EnterAllocate_extent_clause(c *Allocate_extent_clauseContext) + + // EnterDeallocate_unused_clause is called when entering the deallocate_unused_clause production. + EnterDeallocate_unused_clause(c *Deallocate_unused_clauseContext) + + // EnterShrink_clause is called when entering the shrink_clause production. + EnterShrink_clause(c *Shrink_clauseContext) + + // EnterRecords_per_block_clause is called when entering the records_per_block_clause production. + EnterRecords_per_block_clause(c *Records_per_block_clauseContext) + + // EnterUpgrade_table_clause is called when entering the upgrade_table_clause production. + EnterUpgrade_table_clause(c *Upgrade_table_clauseContext) + + // EnterTruncate_table is called when entering the truncate_table production. + EnterTruncate_table(c *Truncate_tableContext) + + // EnterDrop_table is called when entering the drop_table production. + EnterDrop_table(c *Drop_tableContext) + + // EnterDrop_tablespace is called when entering the drop_tablespace production. + EnterDrop_tablespace(c *Drop_tablespaceContext) + + // EnterDrop_tablespace_set is called when entering the drop_tablespace_set production. + EnterDrop_tablespace_set(c *Drop_tablespace_setContext) + + // EnterIncluding_contents_clause is called when entering the including_contents_clause production. + EnterIncluding_contents_clause(c *Including_contents_clauseContext) + + // EnterDrop_view is called when entering the drop_view production. + EnterDrop_view(c *Drop_viewContext) + + // EnterComment_on_column is called when entering the comment_on_column production. + EnterComment_on_column(c *Comment_on_columnContext) + + // EnterEnable_or_disable is called when entering the enable_or_disable production. + EnterEnable_or_disable(c *Enable_or_disableContext) + + // EnterAllow_or_disallow is called when entering the allow_or_disallow production. + EnterAllow_or_disallow(c *Allow_or_disallowContext) + + // EnterAlter_synonym is called when entering the alter_synonym production. + EnterAlter_synonym(c *Alter_synonymContext) + + // EnterCreate_synonym is called when entering the create_synonym production. + EnterCreate_synonym(c *Create_synonymContext) + + // EnterDrop_synonym is called when entering the drop_synonym production. + EnterDrop_synonym(c *Drop_synonymContext) + + // EnterCreate_spfile is called when entering the create_spfile production. + EnterCreate_spfile(c *Create_spfileContext) + + // EnterSpfile_name is called when entering the spfile_name production. + EnterSpfile_name(c *Spfile_nameContext) + + // EnterPfile_name is called when entering the pfile_name production. + EnterPfile_name(c *Pfile_nameContext) + + // EnterComment_on_table is called when entering the comment_on_table production. + EnterComment_on_table(c *Comment_on_tableContext) + + // EnterComment_on_materialized is called when entering the comment_on_materialized production. + EnterComment_on_materialized(c *Comment_on_materializedContext) + + // EnterAlter_analytic_view is called when entering the alter_analytic_view production. + EnterAlter_analytic_view(c *Alter_analytic_viewContext) + + // EnterAlter_add_cache_clause is called when entering the alter_add_cache_clause production. + EnterAlter_add_cache_clause(c *Alter_add_cache_clauseContext) + + // EnterLevels_item is called when entering the levels_item production. + EnterLevels_item(c *Levels_itemContext) + + // EnterMeasure_list is called when entering the measure_list production. + EnterMeasure_list(c *Measure_listContext) + + // EnterAlter_drop_cache_clause is called when entering the alter_drop_cache_clause production. + EnterAlter_drop_cache_clause(c *Alter_drop_cache_clauseContext) + + // EnterAlter_attribute_dimension is called when entering the alter_attribute_dimension production. + EnterAlter_attribute_dimension(c *Alter_attribute_dimensionContext) + + // EnterAlter_audit_policy is called when entering the alter_audit_policy production. + EnterAlter_audit_policy(c *Alter_audit_policyContext) + + // EnterAlter_cluster is called when entering the alter_cluster production. + EnterAlter_cluster(c *Alter_clusterContext) + + // EnterDrop_analytic_view is called when entering the drop_analytic_view production. + EnterDrop_analytic_view(c *Drop_analytic_viewContext) + + // EnterDrop_attribute_dimension is called when entering the drop_attribute_dimension production. + EnterDrop_attribute_dimension(c *Drop_attribute_dimensionContext) + + // EnterDrop_audit_policy is called when entering the drop_audit_policy production. + EnterDrop_audit_policy(c *Drop_audit_policyContext) + + // EnterDrop_flashback_archive is called when entering the drop_flashback_archive production. + EnterDrop_flashback_archive(c *Drop_flashback_archiveContext) + + // EnterDrop_cluster is called when entering the drop_cluster production. + EnterDrop_cluster(c *Drop_clusterContext) + + // EnterDrop_context is called when entering the drop_context production. + EnterDrop_context(c *Drop_contextContext) + + // EnterDrop_directory is called when entering the drop_directory production. + EnterDrop_directory(c *Drop_directoryContext) + + // EnterDrop_diskgroup is called when entering the drop_diskgroup production. + EnterDrop_diskgroup(c *Drop_diskgroupContext) + + // EnterDrop_edition is called when entering the drop_edition production. + EnterDrop_edition(c *Drop_editionContext) + + // EnterTruncate_cluster is called when entering the truncate_cluster production. + EnterTruncate_cluster(c *Truncate_clusterContext) + + // EnterCache_or_nocache is called when entering the cache_or_nocache production. + EnterCache_or_nocache(c *Cache_or_nocacheContext) + + // EnterDatabase_name is called when entering the database_name production. + EnterDatabase_name(c *Database_nameContext) + + // EnterAlter_database is called when entering the alter_database production. + EnterAlter_database(c *Alter_databaseContext) + + // EnterDatabase_clause is called when entering the database_clause production. + EnterDatabase_clause(c *Database_clauseContext) + + // EnterStartup_clauses is called when entering the startup_clauses production. + EnterStartup_clauses(c *Startup_clausesContext) + + // EnterResetlogs_or_noresetlogs is called when entering the resetlogs_or_noresetlogs production. + EnterResetlogs_or_noresetlogs(c *Resetlogs_or_noresetlogsContext) + + // EnterUpgrade_or_downgrade is called when entering the upgrade_or_downgrade production. + EnterUpgrade_or_downgrade(c *Upgrade_or_downgradeContext) + + // EnterRecovery_clauses is called when entering the recovery_clauses production. + EnterRecovery_clauses(c *Recovery_clausesContext) + + // EnterBegin_or_end is called when entering the begin_or_end production. + EnterBegin_or_end(c *Begin_or_endContext) + + // EnterGeneral_recovery is called when entering the general_recovery production. + EnterGeneral_recovery(c *General_recoveryContext) + + // EnterFull_database_recovery is called when entering the full_database_recovery production. + EnterFull_database_recovery(c *Full_database_recoveryContext) + + // EnterPartial_database_recovery is called when entering the partial_database_recovery production. + EnterPartial_database_recovery(c *Partial_database_recoveryContext) + + // EnterPartial_database_recovery_10g is called when entering the partial_database_recovery_10g production. + EnterPartial_database_recovery_10g(c *Partial_database_recovery_10gContext) + + // EnterManaged_standby_recovery is called when entering the managed_standby_recovery production. + EnterManaged_standby_recovery(c *Managed_standby_recoveryContext) + + // EnterDb_name is called when entering the db_name production. + EnterDb_name(c *Db_nameContext) + + // EnterDatabase_file_clauses is called when entering the database_file_clauses production. + EnterDatabase_file_clauses(c *Database_file_clausesContext) + + // EnterCreate_datafile_clause is called when entering the create_datafile_clause production. + EnterCreate_datafile_clause(c *Create_datafile_clauseContext) + + // EnterAlter_datafile_clause is called when entering the alter_datafile_clause production. + EnterAlter_datafile_clause(c *Alter_datafile_clauseContext) + + // EnterAlter_tempfile_clause is called when entering the alter_tempfile_clause production. + EnterAlter_tempfile_clause(c *Alter_tempfile_clauseContext) + + // EnterMove_datafile_clause is called when entering the move_datafile_clause production. + EnterMove_datafile_clause(c *Move_datafile_clauseContext) + + // EnterLogfile_clauses is called when entering the logfile_clauses production. + EnterLogfile_clauses(c *Logfile_clausesContext) + + // EnterAdd_logfile_clauses is called when entering the add_logfile_clauses production. + EnterAdd_logfile_clauses(c *Add_logfile_clausesContext) + + // EnterGroup_redo_logfile is called when entering the group_redo_logfile production. + EnterGroup_redo_logfile(c *Group_redo_logfileContext) + + // EnterDrop_logfile_clauses is called when entering the drop_logfile_clauses production. + EnterDrop_logfile_clauses(c *Drop_logfile_clausesContext) + + // EnterSwitch_logfile_clause is called when entering the switch_logfile_clause production. + EnterSwitch_logfile_clause(c *Switch_logfile_clauseContext) + + // EnterSupplemental_db_logging is called when entering the supplemental_db_logging production. + EnterSupplemental_db_logging(c *Supplemental_db_loggingContext) + + // EnterAdd_or_drop is called when entering the add_or_drop production. + EnterAdd_or_drop(c *Add_or_dropContext) + + // EnterSupplemental_plsql_clause is called when entering the supplemental_plsql_clause production. + EnterSupplemental_plsql_clause(c *Supplemental_plsql_clauseContext) + + // EnterLogfile_descriptor is called when entering the logfile_descriptor production. + EnterLogfile_descriptor(c *Logfile_descriptorContext) + + // EnterControlfile_clauses is called when entering the controlfile_clauses production. + EnterControlfile_clauses(c *Controlfile_clausesContext) + + // EnterTrace_file_clause is called when entering the trace_file_clause production. + EnterTrace_file_clause(c *Trace_file_clauseContext) + + // EnterStandby_database_clauses is called when entering the standby_database_clauses production. + EnterStandby_database_clauses(c *Standby_database_clausesContext) + + // EnterActivate_standby_db_clause is called when entering the activate_standby_db_clause production. + EnterActivate_standby_db_clause(c *Activate_standby_db_clauseContext) + + // EnterMaximize_standby_db_clause is called when entering the maximize_standby_db_clause production. + EnterMaximize_standby_db_clause(c *Maximize_standby_db_clauseContext) + + // EnterRegister_logfile_clause is called when entering the register_logfile_clause production. + EnterRegister_logfile_clause(c *Register_logfile_clauseContext) + + // EnterCommit_switchover_clause is called when entering the commit_switchover_clause production. + EnterCommit_switchover_clause(c *Commit_switchover_clauseContext) + + // EnterStart_standby_clause is called when entering the start_standby_clause production. + EnterStart_standby_clause(c *Start_standby_clauseContext) + + // EnterStop_standby_clause is called when entering the stop_standby_clause production. + EnterStop_standby_clause(c *Stop_standby_clauseContext) + + // EnterConvert_database_clause is called when entering the convert_database_clause production. + EnterConvert_database_clause(c *Convert_database_clauseContext) + + // EnterDefault_settings_clause is called when entering the default_settings_clause production. + EnterDefault_settings_clause(c *Default_settings_clauseContext) + + // EnterSet_time_zone_clause is called when entering the set_time_zone_clause production. + EnterSet_time_zone_clause(c *Set_time_zone_clauseContext) + + // EnterInstance_clauses is called when entering the instance_clauses production. + EnterInstance_clauses(c *Instance_clausesContext) + + // EnterSecurity_clause is called when entering the security_clause production. + EnterSecurity_clause(c *Security_clauseContext) + + // EnterDomain is called when entering the domain production. + EnterDomain(c *DomainContext) + + // EnterDatabase is called when entering the database production. + EnterDatabase(c *DatabaseContext) + + // EnterEdition_name is called when entering the edition_name production. + EnterEdition_name(c *Edition_nameContext) + + // EnterFilenumber is called when entering the filenumber production. + EnterFilenumber(c *FilenumberContext) + + // EnterFilename is called when entering the filename production. + EnterFilename(c *FilenameContext) + + // EnterPrepare_clause is called when entering the prepare_clause production. + EnterPrepare_clause(c *Prepare_clauseContext) + + // EnterDrop_mirror_clause is called when entering the drop_mirror_clause production. + EnterDrop_mirror_clause(c *Drop_mirror_clauseContext) + + // EnterLost_write_protection is called when entering the lost_write_protection production. + EnterLost_write_protection(c *Lost_write_protectionContext) + + // EnterCdb_fleet_clauses is called when entering the cdb_fleet_clauses production. + EnterCdb_fleet_clauses(c *Cdb_fleet_clausesContext) + + // EnterLead_cdb_clause is called when entering the lead_cdb_clause production. + EnterLead_cdb_clause(c *Lead_cdb_clauseContext) + + // EnterLead_cdb_uri_clause is called when entering the lead_cdb_uri_clause production. + EnterLead_cdb_uri_clause(c *Lead_cdb_uri_clauseContext) + + // EnterProperty_clauses is called when entering the property_clauses production. + EnterProperty_clauses(c *Property_clausesContext) + + // EnterReplay_upgrade_clauses is called when entering the replay_upgrade_clauses production. + EnterReplay_upgrade_clauses(c *Replay_upgrade_clausesContext) + + // EnterAlter_database_link is called when entering the alter_database_link production. + EnterAlter_database_link(c *Alter_database_linkContext) + + // EnterPassword_value is called when entering the password_value production. + EnterPassword_value(c *Password_valueContext) + + // EnterLink_authentication is called when entering the link_authentication production. + EnterLink_authentication(c *Link_authenticationContext) + + // EnterCreate_schema is called when entering the create_schema production. + EnterCreate_schema(c *Create_schemaContext) + + // EnterCreate_database is called when entering the create_database production. + EnterCreate_database(c *Create_databaseContext) + + // EnterDatabase_logging_clauses is called when entering the database_logging_clauses production. + EnterDatabase_logging_clauses(c *Database_logging_clausesContext) + + // EnterDatabase_logging_sub_clause is called when entering the database_logging_sub_clause production. + EnterDatabase_logging_sub_clause(c *Database_logging_sub_clauseContext) + + // EnterTablespace_clauses is called when entering the tablespace_clauses production. + EnterTablespace_clauses(c *Tablespace_clausesContext) + + // EnterEnable_pluggable_database is called when entering the enable_pluggable_database production. + EnterEnable_pluggable_database(c *Enable_pluggable_databaseContext) + + // EnterFile_name_convert is called when entering the file_name_convert production. + EnterFile_name_convert(c *File_name_convertContext) + + // EnterFilename_convert_sub_clause is called when entering the filename_convert_sub_clause production. + EnterFilename_convert_sub_clause(c *Filename_convert_sub_clauseContext) + + // EnterTablespace_datafile_clauses is called when entering the tablespace_datafile_clauses production. + EnterTablespace_datafile_clauses(c *Tablespace_datafile_clausesContext) + + // EnterUndo_mode_clause is called when entering the undo_mode_clause production. + EnterUndo_mode_clause(c *Undo_mode_clauseContext) + + // EnterDefault_tablespace is called when entering the default_tablespace production. + EnterDefault_tablespace(c *Default_tablespaceContext) + + // EnterDefault_temp_tablespace is called when entering the default_temp_tablespace production. + EnterDefault_temp_tablespace(c *Default_temp_tablespaceContext) + + // EnterUndo_tablespace is called when entering the undo_tablespace production. + EnterUndo_tablespace(c *Undo_tablespaceContext) + + // EnterDrop_database is called when entering the drop_database production. + EnterDrop_database(c *Drop_databaseContext) + + // EnterCreate_database_link is called when entering the create_database_link production. + EnterCreate_database_link(c *Create_database_linkContext) + + // EnterDrop_database_link is called when entering the drop_database_link production. + EnterDrop_database_link(c *Drop_database_linkContext) + + // EnterAlter_tablespace_set is called when entering the alter_tablespace_set production. + EnterAlter_tablespace_set(c *Alter_tablespace_setContext) + + // EnterAlter_tablespace_attrs is called when entering the alter_tablespace_attrs production. + EnterAlter_tablespace_attrs(c *Alter_tablespace_attrsContext) + + // EnterAlter_tablespace_encryption is called when entering the alter_tablespace_encryption production. + EnterAlter_tablespace_encryption(c *Alter_tablespace_encryptionContext) + + // EnterTs_file_name_convert is called when entering the ts_file_name_convert production. + EnterTs_file_name_convert(c *Ts_file_name_convertContext) + + // EnterAlter_role is called when entering the alter_role production. + EnterAlter_role(c *Alter_roleContext) + + // EnterRole_identified_clause is called when entering the role_identified_clause production. + EnterRole_identified_clause(c *Role_identified_clauseContext) + + // EnterAlter_table is called when entering the alter_table production. + EnterAlter_table(c *Alter_tableContext) + + // EnterMemoptimize_read_write_clause is called when entering the memoptimize_read_write_clause production. + EnterMemoptimize_read_write_clause(c *Memoptimize_read_write_clauseContext) + + // EnterAlter_table_properties is called when entering the alter_table_properties production. + EnterAlter_table_properties(c *Alter_table_propertiesContext) + + // EnterAlter_table_partitioning is called when entering the alter_table_partitioning production. + EnterAlter_table_partitioning(c *Alter_table_partitioningContext) + + // EnterAdd_table_partition is called when entering the add_table_partition production. + EnterAdd_table_partition(c *Add_table_partitionContext) + + // EnterDrop_table_partition is called when entering the drop_table_partition production. + EnterDrop_table_partition(c *Drop_table_partitionContext) + + // EnterMerge_table_partition is called when entering the merge_table_partition production. + EnterMerge_table_partition(c *Merge_table_partitionContext) + + // EnterModify_table_partition is called when entering the modify_table_partition production. + EnterModify_table_partition(c *Modify_table_partitionContext) + + // EnterSplit_table_partition is called when entering the split_table_partition production. + EnterSplit_table_partition(c *Split_table_partitionContext) + + // EnterTruncate_table_partition is called when entering the truncate_table_partition production. + EnterTruncate_table_partition(c *Truncate_table_partitionContext) + + // EnterExchange_table_partition is called when entering the exchange_table_partition production. + EnterExchange_table_partition(c *Exchange_table_partitionContext) + + // EnterCoalesce_table_partition is called when entering the coalesce_table_partition production. + EnterCoalesce_table_partition(c *Coalesce_table_partitionContext) + + // EnterAlter_interval_partition is called when entering the alter_interval_partition production. + EnterAlter_interval_partition(c *Alter_interval_partitionContext) + + // EnterMove_table_partition is called when entering the move_table_partition production. + EnterMove_table_partition(c *Move_table_partitionContext) + + // EnterFilter_condition is called when entering the filter_condition production. + EnterFilter_condition(c *Filter_conditionContext) + + // EnterRename_table_partition is called when entering the rename_table_partition production. + EnterRename_table_partition(c *Rename_table_partitionContext) + + // EnterPartition_extended_names is called when entering the partition_extended_names production. + EnterPartition_extended_names(c *Partition_extended_namesContext) + + // EnterSubpartition_extended_names is called when entering the subpartition_extended_names production. + EnterSubpartition_extended_names(c *Subpartition_extended_namesContext) + + // EnterAlter_table_properties_1 is called when entering the alter_table_properties_1 production. + EnterAlter_table_properties_1(c *Alter_table_properties_1Context) + + // EnterAlter_iot_clauses is called when entering the alter_iot_clauses production. + EnterAlter_iot_clauses(c *Alter_iot_clausesContext) + + // EnterAlter_mapping_table_clause is called when entering the alter_mapping_table_clause production. + EnterAlter_mapping_table_clause(c *Alter_mapping_table_clauseContext) + + // EnterAlter_overflow_clause is called when entering the alter_overflow_clause production. + EnterAlter_overflow_clause(c *Alter_overflow_clauseContext) + + // EnterAdd_overflow_clause is called when entering the add_overflow_clause production. + EnterAdd_overflow_clause(c *Add_overflow_clauseContext) + + // EnterUpdate_index_clauses is called when entering the update_index_clauses production. + EnterUpdate_index_clauses(c *Update_index_clausesContext) + + // EnterUpdate_global_index_clause is called when entering the update_global_index_clause production. + EnterUpdate_global_index_clause(c *Update_global_index_clauseContext) + + // EnterUpdate_all_indexes_clause is called when entering the update_all_indexes_clause production. + EnterUpdate_all_indexes_clause(c *Update_all_indexes_clauseContext) + + // EnterUpdate_all_indexes_index_clause is called when entering the update_all_indexes_index_clause production. + EnterUpdate_all_indexes_index_clause(c *Update_all_indexes_index_clauseContext) + + // EnterUpdate_index_partition is called when entering the update_index_partition production. + EnterUpdate_index_partition(c *Update_index_partitionContext) + + // EnterUpdate_index_subpartition is called when entering the update_index_subpartition production. + EnterUpdate_index_subpartition(c *Update_index_subpartitionContext) + + // EnterEnable_disable_clause is called when entering the enable_disable_clause production. + EnterEnable_disable_clause(c *Enable_disable_clauseContext) + + // EnterUsing_index_clause is called when entering the using_index_clause production. + EnterUsing_index_clause(c *Using_index_clauseContext) + + // EnterIndex_attributes is called when entering the index_attributes production. + EnterIndex_attributes(c *Index_attributesContext) + + // EnterSort_or_nosort is called when entering the sort_or_nosort production. + EnterSort_or_nosort(c *Sort_or_nosortContext) + + // EnterExceptions_clause is called when entering the exceptions_clause production. + EnterExceptions_clause(c *Exceptions_clauseContext) + + // EnterMove_table_clause is called when entering the move_table_clause production. + EnterMove_table_clause(c *Move_table_clauseContext) + + // EnterIndex_org_table_clause is called when entering the index_org_table_clause production. + EnterIndex_org_table_clause(c *Index_org_table_clauseContext) + + // EnterMapping_table_clause is called when entering the mapping_table_clause production. + EnterMapping_table_clause(c *Mapping_table_clauseContext) + + // EnterKey_compression is called when entering the key_compression production. + EnterKey_compression(c *Key_compressionContext) + + // EnterIndex_org_overflow_clause is called when entering the index_org_overflow_clause production. + EnterIndex_org_overflow_clause(c *Index_org_overflow_clauseContext) + + // EnterColumn_clauses is called when entering the column_clauses production. + EnterColumn_clauses(c *Column_clausesContext) + + // EnterModify_collection_retrieval is called when entering the modify_collection_retrieval production. + EnterModify_collection_retrieval(c *Modify_collection_retrievalContext) + + // EnterCollection_item is called when entering the collection_item production. + EnterCollection_item(c *Collection_itemContext) + + // EnterRename_column_clause is called when entering the rename_column_clause production. + EnterRename_column_clause(c *Rename_column_clauseContext) + + // EnterOld_column_name is called when entering the old_column_name production. + EnterOld_column_name(c *Old_column_nameContext) + + // EnterNew_column_name is called when entering the new_column_name production. + EnterNew_column_name(c *New_column_nameContext) + + // EnterAdd_modify_drop_column_clauses is called when entering the add_modify_drop_column_clauses production. + EnterAdd_modify_drop_column_clauses(c *Add_modify_drop_column_clausesContext) + + // EnterDrop_column_clause is called when entering the drop_column_clause production. + EnterDrop_column_clause(c *Drop_column_clauseContext) + + // EnterModify_column_clauses is called when entering the modify_column_clauses production. + EnterModify_column_clauses(c *Modify_column_clausesContext) + + // EnterModify_col_properties is called when entering the modify_col_properties production. + EnterModify_col_properties(c *Modify_col_propertiesContext) + + // EnterModify_col_visibility is called when entering the modify_col_visibility production. + EnterModify_col_visibility(c *Modify_col_visibilityContext) + + // EnterModify_col_substitutable is called when entering the modify_col_substitutable production. + EnterModify_col_substitutable(c *Modify_col_substitutableContext) + + // EnterAdd_column_clause is called when entering the add_column_clause production. + EnterAdd_column_clause(c *Add_column_clauseContext) + + // EnterVarray_col_properties is called when entering the varray_col_properties production. + EnterVarray_col_properties(c *Varray_col_propertiesContext) + + // EnterVarray_storage_clause is called when entering the varray_storage_clause production. + EnterVarray_storage_clause(c *Varray_storage_clauseContext) + + // EnterLob_segname is called when entering the lob_segname production. + EnterLob_segname(c *Lob_segnameContext) + + // EnterLob_item is called when entering the lob_item production. + EnterLob_item(c *Lob_itemContext) + + // EnterLob_storage_parameters is called when entering the lob_storage_parameters production. + EnterLob_storage_parameters(c *Lob_storage_parametersContext) + + // EnterLob_storage_clause is called when entering the lob_storage_clause production. + EnterLob_storage_clause(c *Lob_storage_clauseContext) + + // EnterModify_lob_storage_clause is called when entering the modify_lob_storage_clause production. + EnterModify_lob_storage_clause(c *Modify_lob_storage_clauseContext) + + // EnterModify_lob_parameters is called when entering the modify_lob_parameters production. + EnterModify_lob_parameters(c *Modify_lob_parametersContext) + + // EnterLob_parameters is called when entering the lob_parameters production. + EnterLob_parameters(c *Lob_parametersContext) + + // EnterLob_deduplicate_clause is called when entering the lob_deduplicate_clause production. + EnterLob_deduplicate_clause(c *Lob_deduplicate_clauseContext) + + // EnterLob_compression_clause is called when entering the lob_compression_clause production. + EnterLob_compression_clause(c *Lob_compression_clauseContext) + + // EnterLob_retention_clause is called when entering the lob_retention_clause production. + EnterLob_retention_clause(c *Lob_retention_clauseContext) + + // EnterEncryption_spec is called when entering the encryption_spec production. + EnterEncryption_spec(c *Encryption_specContext) + + // EnterTablespace is called when entering the tablespace production. + EnterTablespace(c *TablespaceContext) + + // EnterVarray_item is called when entering the varray_item production. + EnterVarray_item(c *Varray_itemContext) + + // EnterColumn_properties is called when entering the column_properties production. + EnterColumn_properties(c *Column_propertiesContext) + + // EnterLob_partition_storage is called when entering the lob_partition_storage production. + EnterLob_partition_storage(c *Lob_partition_storageContext) + + // EnterPeriod_definition is called when entering the period_definition production. + EnterPeriod_definition(c *Period_definitionContext) + + // EnterStart_time_column is called when entering the start_time_column production. + EnterStart_time_column(c *Start_time_columnContext) + + // EnterEnd_time_column is called when entering the end_time_column production. + EnterEnd_time_column(c *End_time_columnContext) + + // EnterColumn_definition is called when entering the column_definition production. + EnterColumn_definition(c *Column_definitionContext) + + // EnterColumn_collation_name is called when entering the column_collation_name production. + EnterColumn_collation_name(c *Column_collation_nameContext) + + // EnterIdentity_clause is called when entering the identity_clause production. + EnterIdentity_clause(c *Identity_clauseContext) + + // EnterIdentity_options_parentheses is called when entering the identity_options_parentheses production. + EnterIdentity_options_parentheses(c *Identity_options_parenthesesContext) + + // EnterIdentity_options is called when entering the identity_options production. + EnterIdentity_options(c *Identity_optionsContext) + + // EnterVirtual_column_definition is called when entering the virtual_column_definition production. + EnterVirtual_column_definition(c *Virtual_column_definitionContext) + + // EnterVirtual_column_expression is called when entering the virtual_column_expression production. + EnterVirtual_column_expression(c *Virtual_column_expressionContext) + + // EnterAutogenerated_sequence_definition is called when entering the autogenerated_sequence_definition production. + EnterAutogenerated_sequence_definition(c *Autogenerated_sequence_definitionContext) + + // EnterBy_user_for_statistics_clause is called when entering the by_user_for_statistics_clause production. + EnterBy_user_for_statistics_clause(c *By_user_for_statistics_clauseContext) + + // EnterEvaluation_edition_clause is called when entering the evaluation_edition_clause production. + EnterEvaluation_edition_clause(c *Evaluation_edition_clauseContext) + + // EnterNested_table_col_properties is called when entering the nested_table_col_properties production. + EnterNested_table_col_properties(c *Nested_table_col_propertiesContext) + + // EnterNested_item is called when entering the nested_item production. + EnterNested_item(c *Nested_itemContext) + + // EnterSubstitutable_column_clause is called when entering the substitutable_column_clause production. + EnterSubstitutable_column_clause(c *Substitutable_column_clauseContext) + + // EnterPartition_name is called when entering the partition_name production. + EnterPartition_name(c *Partition_nameContext) + + // EnterSupplemental_logging_props is called when entering the supplemental_logging_props production. + EnterSupplemental_logging_props(c *Supplemental_logging_propsContext) + + // EnterObject_type_col_properties is called when entering the object_type_col_properties production. + EnterObject_type_col_properties(c *Object_type_col_propertiesContext) + + // EnterConstraint_clauses is called when entering the constraint_clauses production. + EnterConstraint_clauses(c *Constraint_clausesContext) + + // EnterOld_constraint_name is called when entering the old_constraint_name production. + EnterOld_constraint_name(c *Old_constraint_nameContext) + + // EnterNew_constraint_name is called when entering the new_constraint_name production. + EnterNew_constraint_name(c *New_constraint_nameContext) + + // EnterDrop_constraint_clause is called when entering the drop_constraint_clause production. + EnterDrop_constraint_clause(c *Drop_constraint_clauseContext) + + // EnterCheck_constraint is called when entering the check_constraint production. + EnterCheck_constraint(c *Check_constraintContext) + + // EnterForeign_key_clause is called when entering the foreign_key_clause production. + EnterForeign_key_clause(c *Foreign_key_clauseContext) + + // EnterReferences_clause is called when entering the references_clause production. + EnterReferences_clause(c *References_clauseContext) + + // EnterOn_delete_clause is called when entering the on_delete_clause production. + EnterOn_delete_clause(c *On_delete_clauseContext) + + // EnterAnonymous_block is called when entering the anonymous_block production. + EnterAnonymous_block(c *Anonymous_blockContext) + + // EnterInvoker_rights_clause is called when entering the invoker_rights_clause production. + EnterInvoker_rights_clause(c *Invoker_rights_clauseContext) + + // EnterCall_spec is called when entering the call_spec production. + EnterCall_spec(c *Call_specContext) + + // EnterJava_spec is called when entering the java_spec production. + EnterJava_spec(c *Java_specContext) + + // EnterC_spec is called when entering the c_spec production. + EnterC_spec(c *C_specContext) + + // EnterC_agent_in_clause is called when entering the c_agent_in_clause production. + EnterC_agent_in_clause(c *C_agent_in_clauseContext) + + // EnterC_parameters_clause is called when entering the c_parameters_clause production. + EnterC_parameters_clause(c *C_parameters_clauseContext) + + // EnterC_external_parameter is called when entering the c_external_parameter production. + EnterC_external_parameter(c *C_external_parameterContext) + + // EnterC_property is called when entering the c_property production. + EnterC_property(c *C_propertyContext) + + // EnterParameter is called when entering the parameter production. + EnterParameter(c *ParameterContext) + + // EnterDefault_value_part is called when entering the default_value_part production. + EnterDefault_value_part(c *Default_value_partContext) + + // EnterSeq_of_declare_specs is called when entering the seq_of_declare_specs production. + EnterSeq_of_declare_specs(c *Seq_of_declare_specsContext) + + // EnterDeclare_spec is called when entering the declare_spec production. + EnterDeclare_spec(c *Declare_specContext) + + // EnterVariable_declaration is called when entering the variable_declaration production. + EnterVariable_declaration(c *Variable_declarationContext) + + // EnterSubtype_declaration is called when entering the subtype_declaration production. + EnterSubtype_declaration(c *Subtype_declarationContext) + + // EnterCursor_declaration is called when entering the cursor_declaration production. + EnterCursor_declaration(c *Cursor_declarationContext) + + // EnterParameter_spec is called when entering the parameter_spec production. + EnterParameter_spec(c *Parameter_specContext) + + // EnterException_declaration is called when entering the exception_declaration production. + EnterException_declaration(c *Exception_declarationContext) + + // EnterPragma_declaration is called when entering the pragma_declaration production. + EnterPragma_declaration(c *Pragma_declarationContext) + + // EnterRecord_type_def is called when entering the record_type_def production. + EnterRecord_type_def(c *Record_type_defContext) + + // EnterField_spec is called when entering the field_spec production. + EnterField_spec(c *Field_specContext) + + // EnterRef_cursor_type_def is called when entering the ref_cursor_type_def production. + EnterRef_cursor_type_def(c *Ref_cursor_type_defContext) + + // EnterType_declaration is called when entering the type_declaration production. + EnterType_declaration(c *Type_declarationContext) + + // EnterTable_type_def is called when entering the table_type_def production. + EnterTable_type_def(c *Table_type_defContext) + + // EnterTable_indexed_by_part is called when entering the table_indexed_by_part production. + EnterTable_indexed_by_part(c *Table_indexed_by_partContext) + + // EnterVarray_type_def is called when entering the varray_type_def production. + EnterVarray_type_def(c *Varray_type_defContext) + + // EnterSeq_of_statements is called when entering the seq_of_statements production. + EnterSeq_of_statements(c *Seq_of_statementsContext) + + // EnterLabel_declaration is called when entering the label_declaration production. + EnterLabel_declaration(c *Label_declarationContext) + + // EnterStatement is called when entering the statement production. + EnterStatement(c *StatementContext) + + // EnterAssignment_statement is called when entering the assignment_statement production. + EnterAssignment_statement(c *Assignment_statementContext) + + // EnterContinue_statement is called when entering the continue_statement production. + EnterContinue_statement(c *Continue_statementContext) + + // EnterExit_statement is called when entering the exit_statement production. + EnterExit_statement(c *Exit_statementContext) + + // EnterGoto_statement is called when entering the goto_statement production. + EnterGoto_statement(c *Goto_statementContext) + + // EnterIf_statement is called when entering the if_statement production. + EnterIf_statement(c *If_statementContext) + + // EnterElsif_part is called when entering the elsif_part production. + EnterElsif_part(c *Elsif_partContext) + + // EnterElse_part is called when entering the else_part production. + EnterElse_part(c *Else_partContext) + + // EnterLoop_statement is called when entering the loop_statement production. + EnterLoop_statement(c *Loop_statementContext) + + // EnterCursor_loop_param is called when entering the cursor_loop_param production. + EnterCursor_loop_param(c *Cursor_loop_paramContext) + + // EnterForall_statement is called when entering the forall_statement production. + EnterForall_statement(c *Forall_statementContext) + + // EnterBounds_clause is called when entering the bounds_clause production. + EnterBounds_clause(c *Bounds_clauseContext) + + // EnterBetween_bound is called when entering the between_bound production. + EnterBetween_bound(c *Between_boundContext) + + // EnterLower_bound is called when entering the lower_bound production. + EnterLower_bound(c *Lower_boundContext) + + // EnterUpper_bound is called when entering the upper_bound production. + EnterUpper_bound(c *Upper_boundContext) + + // EnterNull_statement is called when entering the null_statement production. + EnterNull_statement(c *Null_statementContext) + + // EnterRaise_statement is called when entering the raise_statement production. + EnterRaise_statement(c *Raise_statementContext) + + // EnterReturn_statement is called when entering the return_statement production. + EnterReturn_statement(c *Return_statementContext) + + // EnterCall_statement is called when entering the call_statement production. + EnterCall_statement(c *Call_statementContext) + + // EnterPipe_row_statement is called when entering the pipe_row_statement production. + EnterPipe_row_statement(c *Pipe_row_statementContext) + + // EnterSelection_directive is called when entering the selection_directive production. + EnterSelection_directive(c *Selection_directiveContext) + + // EnterError_directive is called when entering the error_directive production. + EnterError_directive(c *Error_directiveContext) + + // EnterSelection_directive_body is called when entering the selection_directive_body production. + EnterSelection_directive_body(c *Selection_directive_bodyContext) + + // EnterBody is called when entering the body production. + EnterBody(c *BodyContext) + + // EnterException_handler is called when entering the exception_handler production. + EnterException_handler(c *Exception_handlerContext) + + // EnterTrigger_block is called when entering the trigger_block production. + EnterTrigger_block(c *Trigger_blockContext) + + // EnterTps_block is called when entering the tps_block production. + EnterTps_block(c *Tps_blockContext) + + // EnterBlock is called when entering the block production. + EnterBlock(c *BlockContext) + + // EnterSql_statement is called when entering the sql_statement production. + EnterSql_statement(c *Sql_statementContext) + + // EnterExecute_immediate is called when entering the execute_immediate production. + EnterExecute_immediate(c *Execute_immediateContext) + + // EnterDynamic_returning_clause is called when entering the dynamic_returning_clause production. + EnterDynamic_returning_clause(c *Dynamic_returning_clauseContext) + + // EnterData_manipulation_language_statements is called when entering the data_manipulation_language_statements production. + EnterData_manipulation_language_statements(c *Data_manipulation_language_statementsContext) + + // EnterCursor_manipulation_statements is called when entering the cursor_manipulation_statements production. + EnterCursor_manipulation_statements(c *Cursor_manipulation_statementsContext) + + // EnterClose_statement is called when entering the close_statement production. + EnterClose_statement(c *Close_statementContext) + + // EnterOpen_statement is called when entering the open_statement production. + EnterOpen_statement(c *Open_statementContext) + + // EnterFetch_statement is called when entering the fetch_statement production. + EnterFetch_statement(c *Fetch_statementContext) + + // EnterVariable_or_collection is called when entering the variable_or_collection production. + EnterVariable_or_collection(c *Variable_or_collectionContext) + + // EnterOpen_for_statement is called when entering the open_for_statement production. + EnterOpen_for_statement(c *Open_for_statementContext) + + // EnterTransaction_control_statements is called when entering the transaction_control_statements production. + EnterTransaction_control_statements(c *Transaction_control_statementsContext) + + // EnterSet_transaction_command is called when entering the set_transaction_command production. + EnterSet_transaction_command(c *Set_transaction_commandContext) + + // EnterSet_constraint_command is called when entering the set_constraint_command production. + EnterSet_constraint_command(c *Set_constraint_commandContext) + + // EnterCommit_statement is called when entering the commit_statement production. + EnterCommit_statement(c *Commit_statementContext) + + // EnterWrite_clause is called when entering the write_clause production. + EnterWrite_clause(c *Write_clauseContext) + + // EnterRollback_statement is called when entering the rollback_statement production. + EnterRollback_statement(c *Rollback_statementContext) + + // EnterSavepoint_statement is called when entering the savepoint_statement production. + EnterSavepoint_statement(c *Savepoint_statementContext) + + // EnterCollection_method_call is called when entering the collection_method_call production. + EnterCollection_method_call(c *Collection_method_callContext) + + // EnterExplain_statement is called when entering the explain_statement production. + EnterExplain_statement(c *Explain_statementContext) + + // EnterSelect_only_statement is called when entering the select_only_statement production. + EnterSelect_only_statement(c *Select_only_statementContext) + + // EnterSelect_statement is called when entering the select_statement production. + EnterSelect_statement(c *Select_statementContext) + + // EnterWith_clause is called when entering the with_clause production. + EnterWith_clause(c *With_clauseContext) + + // EnterWith_factoring_clause is called when entering the with_factoring_clause production. + EnterWith_factoring_clause(c *With_factoring_clauseContext) + + // EnterSubquery_factoring_clause is called when entering the subquery_factoring_clause production. + EnterSubquery_factoring_clause(c *Subquery_factoring_clauseContext) + + // EnterSearch_clause is called when entering the search_clause production. + EnterSearch_clause(c *Search_clauseContext) + + // EnterCycle_clause is called when entering the cycle_clause production. + EnterCycle_clause(c *Cycle_clauseContext) + + // EnterSubav_factoring_clause is called when entering the subav_factoring_clause production. + EnterSubav_factoring_clause(c *Subav_factoring_clauseContext) + + // EnterSubav_clause is called when entering the subav_clause production. + EnterSubav_clause(c *Subav_clauseContext) + + // EnterHierarchies_clause is called when entering the hierarchies_clause production. + EnterHierarchies_clause(c *Hierarchies_clauseContext) + + // EnterFilter_clauses is called when entering the filter_clauses production. + EnterFilter_clauses(c *Filter_clausesContext) + + // EnterFilter_clause is called when entering the filter_clause production. + EnterFilter_clause(c *Filter_clauseContext) + + // EnterAdd_calcs_clause is called when entering the add_calcs_clause production. + EnterAdd_calcs_clause(c *Add_calcs_clauseContext) + + // EnterAdd_calc_meas_clause is called when entering the add_calc_meas_clause production. + EnterAdd_calc_meas_clause(c *Add_calc_meas_clauseContext) + + // EnterSubquery is called when entering the subquery production. + EnterSubquery(c *SubqueryContext) + + // EnterSubquery_basic_elements is called when entering the subquery_basic_elements production. + EnterSubquery_basic_elements(c *Subquery_basic_elementsContext) + + // EnterSubquery_operation_part is called when entering the subquery_operation_part production. + EnterSubquery_operation_part(c *Subquery_operation_partContext) + + // EnterQuery_block is called when entering the query_block production. + EnterQuery_block(c *Query_blockContext) + + // EnterSelected_list is called when entering the selected_list production. + EnterSelected_list(c *Selected_listContext) + + // EnterFrom_clause is called when entering the from_clause production. + EnterFrom_clause(c *From_clauseContext) + + // EnterSelect_list_elements is called when entering the select_list_elements production. + EnterSelect_list_elements(c *Select_list_elementsContext) + + // EnterTable_ref_list is called when entering the table_ref_list production. + EnterTable_ref_list(c *Table_ref_listContext) + + // EnterTable_ref is called when entering the table_ref production. + EnterTable_ref(c *Table_refContext) + + // EnterTable_ref_aux is called when entering the table_ref_aux production. + EnterTable_ref_aux(c *Table_ref_auxContext) + + // EnterTable_ref_aux_internal_one is called when entering the table_ref_aux_internal_one production. + EnterTable_ref_aux_internal_one(c *Table_ref_aux_internal_oneContext) + + // EnterTable_ref_aux_internal_two is called when entering the table_ref_aux_internal_two production. + EnterTable_ref_aux_internal_two(c *Table_ref_aux_internal_twoContext) + + // EnterTable_ref_aux_internal_thre is called when entering the table_ref_aux_internal_thre production. + EnterTable_ref_aux_internal_thre(c *Table_ref_aux_internal_threContext) + + // EnterJoin_clause is called when entering the join_clause production. + EnterJoin_clause(c *Join_clauseContext) + + // EnterJoin_on_part is called when entering the join_on_part production. + EnterJoin_on_part(c *Join_on_partContext) + + // EnterJoin_using_part is called when entering the join_using_part production. + EnterJoin_using_part(c *Join_using_partContext) + + // EnterOuter_join_type is called when entering the outer_join_type production. + EnterOuter_join_type(c *Outer_join_typeContext) + + // EnterQuery_partition_clause is called when entering the query_partition_clause production. + EnterQuery_partition_clause(c *Query_partition_clauseContext) + + // EnterFlashback_query_clause is called when entering the flashback_query_clause production. + EnterFlashback_query_clause(c *Flashback_query_clauseContext) + + // EnterPivot_clause is called when entering the pivot_clause production. + EnterPivot_clause(c *Pivot_clauseContext) + + // EnterPivot_element is called when entering the pivot_element production. + EnterPivot_element(c *Pivot_elementContext) + + // EnterPivot_for_clause is called when entering the pivot_for_clause production. + EnterPivot_for_clause(c *Pivot_for_clauseContext) + + // EnterPivot_in_clause is called when entering the pivot_in_clause production. + EnterPivot_in_clause(c *Pivot_in_clauseContext) + + // EnterPivot_in_clause_element is called when entering the pivot_in_clause_element production. + EnterPivot_in_clause_element(c *Pivot_in_clause_elementContext) + + // EnterPivot_in_clause_elements is called when entering the pivot_in_clause_elements production. + EnterPivot_in_clause_elements(c *Pivot_in_clause_elementsContext) + + // EnterUnpivot_clause is called when entering the unpivot_clause production. + EnterUnpivot_clause(c *Unpivot_clauseContext) + + // EnterUnpivot_in_clause is called when entering the unpivot_in_clause production. + EnterUnpivot_in_clause(c *Unpivot_in_clauseContext) + + // EnterUnpivot_in_elements is called when entering the unpivot_in_elements production. + EnterUnpivot_in_elements(c *Unpivot_in_elementsContext) + + // EnterHierarchical_query_clause is called when entering the hierarchical_query_clause production. + EnterHierarchical_query_clause(c *Hierarchical_query_clauseContext) + + // EnterStart_part is called when entering the start_part production. + EnterStart_part(c *Start_partContext) + + // EnterGroup_by_clause is called when entering the group_by_clause production. + EnterGroup_by_clause(c *Group_by_clauseContext) + + // EnterGroup_by_elements is called when entering the group_by_elements production. + EnterGroup_by_elements(c *Group_by_elementsContext) + + // EnterRollup_cube_clause is called when entering the rollup_cube_clause production. + EnterRollup_cube_clause(c *Rollup_cube_clauseContext) + + // EnterGrouping_sets_clause is called when entering the grouping_sets_clause production. + EnterGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // EnterGrouping_sets_elements is called when entering the grouping_sets_elements production. + EnterGrouping_sets_elements(c *Grouping_sets_elementsContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterModel_clause is called when entering the model_clause production. + EnterModel_clause(c *Model_clauseContext) + + // EnterCell_reference_options is called when entering the cell_reference_options production. + EnterCell_reference_options(c *Cell_reference_optionsContext) + + // EnterReturn_rows_clause is called when entering the return_rows_clause production. + EnterReturn_rows_clause(c *Return_rows_clauseContext) + + // EnterReference_model is called when entering the reference_model production. + EnterReference_model(c *Reference_modelContext) + + // EnterMain_model is called when entering the main_model production. + EnterMain_model(c *Main_modelContext) + + // EnterModel_column_clauses is called when entering the model_column_clauses production. + EnterModel_column_clauses(c *Model_column_clausesContext) + + // EnterModel_column_partition_part is called when entering the model_column_partition_part production. + EnterModel_column_partition_part(c *Model_column_partition_partContext) + + // EnterModel_column_list is called when entering the model_column_list production. + EnterModel_column_list(c *Model_column_listContext) + + // EnterModel_column is called when entering the model_column production. + EnterModel_column(c *Model_columnContext) + + // EnterModel_rules_clause is called when entering the model_rules_clause production. + EnterModel_rules_clause(c *Model_rules_clauseContext) + + // EnterModel_rules_part is called when entering the model_rules_part production. + EnterModel_rules_part(c *Model_rules_partContext) + + // EnterModel_rules_element is called when entering the model_rules_element production. + EnterModel_rules_element(c *Model_rules_elementContext) + + // EnterCell_assignment is called when entering the cell_assignment production. + EnterCell_assignment(c *Cell_assignmentContext) + + // EnterModel_iterate_clause is called when entering the model_iterate_clause production. + EnterModel_iterate_clause(c *Model_iterate_clauseContext) + + // EnterUntil_part is called when entering the until_part production. + EnterUntil_part(c *Until_partContext) + + // EnterOrder_by_clause is called when entering the order_by_clause production. + EnterOrder_by_clause(c *Order_by_clauseContext) + + // EnterOrder_by_elements is called when entering the order_by_elements production. + EnterOrder_by_elements(c *Order_by_elementsContext) + + // EnterOffset_clause is called when entering the offset_clause production. + EnterOffset_clause(c *Offset_clauseContext) + + // EnterFetch_clause is called when entering the fetch_clause production. + EnterFetch_clause(c *Fetch_clauseContext) + + // EnterFor_update_clause is called when entering the for_update_clause production. + EnterFor_update_clause(c *For_update_clauseContext) + + // EnterFor_update_of_part is called when entering the for_update_of_part production. + EnterFor_update_of_part(c *For_update_of_partContext) + + // EnterFor_update_options is called when entering the for_update_options production. + EnterFor_update_options(c *For_update_optionsContext) + + // EnterUpdate_statement is called when entering the update_statement production. + EnterUpdate_statement(c *Update_statementContext) + + // EnterUpdate_set_clause is called when entering the update_set_clause production. + EnterUpdate_set_clause(c *Update_set_clauseContext) + + // EnterColumn_based_update_set_clause is called when entering the column_based_update_set_clause production. + EnterColumn_based_update_set_clause(c *Column_based_update_set_clauseContext) + + // EnterDelete_statement is called when entering the delete_statement production. + EnterDelete_statement(c *Delete_statementContext) + + // EnterInsert_statement is called when entering the insert_statement production. + EnterInsert_statement(c *Insert_statementContext) + + // EnterSingle_table_insert is called when entering the single_table_insert production. + EnterSingle_table_insert(c *Single_table_insertContext) + + // EnterMulti_table_insert is called when entering the multi_table_insert production. + EnterMulti_table_insert(c *Multi_table_insertContext) + + // EnterMulti_table_element is called when entering the multi_table_element production. + EnterMulti_table_element(c *Multi_table_elementContext) + + // EnterConditional_insert_clause is called when entering the conditional_insert_clause production. + EnterConditional_insert_clause(c *Conditional_insert_clauseContext) + + // EnterConditional_insert_when_part is called when entering the conditional_insert_when_part production. + EnterConditional_insert_when_part(c *Conditional_insert_when_partContext) + + // EnterConditional_insert_else_part is called when entering the conditional_insert_else_part production. + EnterConditional_insert_else_part(c *Conditional_insert_else_partContext) + + // EnterInsert_into_clause is called when entering the insert_into_clause production. + EnterInsert_into_clause(c *Insert_into_clauseContext) + + // EnterValues_clause is called when entering the values_clause production. + EnterValues_clause(c *Values_clauseContext) + + // EnterMerge_statement is called when entering the merge_statement production. + EnterMerge_statement(c *Merge_statementContext) + + // EnterMerge_update_clause is called when entering the merge_update_clause production. + EnterMerge_update_clause(c *Merge_update_clauseContext) + + // EnterMerge_element is called when entering the merge_element production. + EnterMerge_element(c *Merge_elementContext) + + // EnterMerge_update_delete_part is called when entering the merge_update_delete_part production. + EnterMerge_update_delete_part(c *Merge_update_delete_partContext) + + // EnterMerge_insert_clause is called when entering the merge_insert_clause production. + EnterMerge_insert_clause(c *Merge_insert_clauseContext) + + // EnterSelected_tableview is called when entering the selected_tableview production. + EnterSelected_tableview(c *Selected_tableviewContext) + + // EnterLock_table_statement is called when entering the lock_table_statement production. + EnterLock_table_statement(c *Lock_table_statementContext) + + // EnterWait_nowait_part is called when entering the wait_nowait_part production. + EnterWait_nowait_part(c *Wait_nowait_partContext) + + // EnterLock_table_element is called when entering the lock_table_element production. + EnterLock_table_element(c *Lock_table_elementContext) + + // EnterLock_mode is called when entering the lock_mode production. + EnterLock_mode(c *Lock_modeContext) + + // EnterGeneral_table_ref is called when entering the general_table_ref production. + EnterGeneral_table_ref(c *General_table_refContext) + + // EnterStatic_returning_clause is called when entering the static_returning_clause production. + EnterStatic_returning_clause(c *Static_returning_clauseContext) + + // EnterError_logging_clause is called when entering the error_logging_clause production. + EnterError_logging_clause(c *Error_logging_clauseContext) + + // EnterError_logging_into_part is called when entering the error_logging_into_part production. + EnterError_logging_into_part(c *Error_logging_into_partContext) + + // EnterError_logging_reject_part is called when entering the error_logging_reject_part production. + EnterError_logging_reject_part(c *Error_logging_reject_partContext) + + // EnterDml_table_expression_clause is called when entering the dml_table_expression_clause production. + EnterDml_table_expression_clause(c *Dml_table_expression_clauseContext) + + // EnterTable_collection_expression is called when entering the table_collection_expression production. + EnterTable_collection_expression(c *Table_collection_expressionContext) + + // EnterSubquery_restriction_clause is called when entering the subquery_restriction_clause production. + EnterSubquery_restriction_clause(c *Subquery_restriction_clauseContext) + + // EnterSample_clause is called when entering the sample_clause production. + EnterSample_clause(c *Sample_clauseContext) + + // EnterSeed_part is called when entering the seed_part production. + EnterSeed_part(c *Seed_partContext) + + // EnterCondition is called when entering the condition production. + EnterCondition(c *ConditionContext) + + // EnterExpressions_ is called when entering the expressions_ production. + EnterExpressions_(c *Expressions_Context) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterCursor_expression is called when entering the cursor_expression production. + EnterCursor_expression(c *Cursor_expressionContext) + + // EnterLogical_expression is called when entering the logical_expression production. + EnterLogical_expression(c *Logical_expressionContext) + + // EnterUnary_logical_expression is called when entering the unary_logical_expression production. + EnterUnary_logical_expression(c *Unary_logical_expressionContext) + + // EnterUnary_logical_operation is called when entering the unary_logical_operation production. + EnterUnary_logical_operation(c *Unary_logical_operationContext) + + // EnterLogical_operation is called when entering the logical_operation production. + EnterLogical_operation(c *Logical_operationContext) + + // EnterMultiset_expression is called when entering the multiset_expression production. + EnterMultiset_expression(c *Multiset_expressionContext) + + // EnterRelational_expression is called when entering the relational_expression production. + EnterRelational_expression(c *Relational_expressionContext) + + // EnterCompound_expression is called when entering the compound_expression production. + EnterCompound_expression(c *Compound_expressionContext) + + // EnterRelational_operator is called when entering the relational_operator production. + EnterRelational_operator(c *Relational_operatorContext) + + // EnterIn_elements is called when entering the in_elements production. + EnterIn_elements(c *In_elementsContext) + + // EnterBetween_elements is called when entering the between_elements production. + EnterBetween_elements(c *Between_elementsContext) + + // EnterConcatenation is called when entering the concatenation production. + EnterConcatenation(c *ConcatenationContext) + + // EnterInterval_expression is called when entering the interval_expression production. + EnterInterval_expression(c *Interval_expressionContext) + + // EnterModel_expression is called when entering the model_expression production. + EnterModel_expression(c *Model_expressionContext) + + // EnterModel_expression_element is called when entering the model_expression_element production. + EnterModel_expression_element(c *Model_expression_elementContext) + + // EnterSingle_column_for_loop is called when entering the single_column_for_loop production. + EnterSingle_column_for_loop(c *Single_column_for_loopContext) + + // EnterMulti_column_for_loop is called when entering the multi_column_for_loop production. + EnterMulti_column_for_loop(c *Multi_column_for_loopContext) + + // EnterUnary_expression is called when entering the unary_expression production. + EnterUnary_expression(c *Unary_expressionContext) + + // EnterUnary_expression_core is called when entering the unary_expression_core production. + EnterUnary_expression_core(c *Unary_expression_coreContext) + + // EnterImplicit_cursor_expression is called when entering the implicit_cursor_expression production. + EnterImplicit_cursor_expression(c *Implicit_cursor_expressionContext) + + // EnterCollection_expression is called when entering the collection_expression production. + EnterCollection_expression(c *Collection_expressionContext) + + // EnterCase_statement is called when entering the case_statement production. + EnterCase_statement(c *Case_statementContext) + + // EnterSimple_case_statement is called when entering the simple_case_statement production. + EnterSimple_case_statement(c *Simple_case_statementContext) + + // EnterSearched_case_statement is called when entering the searched_case_statement production. + EnterSearched_case_statement(c *Searched_case_statementContext) + + // EnterCase_when_part_statement is called when entering the case_when_part_statement production. + EnterCase_when_part_statement(c *Case_when_part_statementContext) + + // EnterCase_else_part_statement is called when entering the case_else_part_statement production. + EnterCase_else_part_statement(c *Case_else_part_statementContext) + + // EnterCase_expression is called when entering the case_expression production. + EnterCase_expression(c *Case_expressionContext) + + // EnterSimple_case_expression is called when entering the simple_case_expression production. + EnterSimple_case_expression(c *Simple_case_expressionContext) + + // EnterSearched_case_expression is called when entering the searched_case_expression production. + EnterSearched_case_expression(c *Searched_case_expressionContext) + + // EnterCase_when_part_expression is called when entering the case_when_part_expression production. + EnterCase_when_part_expression(c *Case_when_part_expressionContext) + + // EnterCase_else_part_expression is called when entering the case_else_part_expression production. + EnterCase_else_part_expression(c *Case_else_part_expressionContext) + + // EnterAtom is called when entering the atom production. + EnterAtom(c *AtomContext) + + // EnterQuantified_expression is called when entering the quantified_expression production. + EnterQuantified_expression(c *Quantified_expressionContext) + + // EnterString_function is called when entering the string_function production. + EnterString_function(c *String_functionContext) + + // EnterStandard_function is called when entering the standard_function production. + EnterStandard_function(c *Standard_functionContext) + + // EnterJson_function is called when entering the json_function production. + EnterJson_function(c *Json_functionContext) + + // EnterJson_object_content is called when entering the json_object_content production. + EnterJson_object_content(c *Json_object_contentContext) + + // EnterJson_object_entry is called when entering the json_object_entry production. + EnterJson_object_entry(c *Json_object_entryContext) + + // EnterJson_table_clause is called when entering the json_table_clause production. + EnterJson_table_clause(c *Json_table_clauseContext) + + // EnterJson_array_element is called when entering the json_array_element production. + EnterJson_array_element(c *Json_array_elementContext) + + // EnterJson_on_null_clause is called when entering the json_on_null_clause production. + EnterJson_on_null_clause(c *Json_on_null_clauseContext) + + // EnterJson_return_clause is called when entering the json_return_clause production. + EnterJson_return_clause(c *Json_return_clauseContext) + + // EnterJson_transform_op is called when entering the json_transform_op production. + EnterJson_transform_op(c *Json_transform_opContext) + + // EnterJson_column_clause is called when entering the json_column_clause production. + EnterJson_column_clause(c *Json_column_clauseContext) + + // EnterJson_column_definition is called when entering the json_column_definition production. + EnterJson_column_definition(c *Json_column_definitionContext) + + // EnterJson_query_returning_clause is called when entering the json_query_returning_clause production. + EnterJson_query_returning_clause(c *Json_query_returning_clauseContext) + + // EnterJson_query_return_type is called when entering the json_query_return_type production. + EnterJson_query_return_type(c *Json_query_return_typeContext) + + // EnterJson_query_wrapper_clause is called when entering the json_query_wrapper_clause production. + EnterJson_query_wrapper_clause(c *Json_query_wrapper_clauseContext) + + // EnterJson_query_on_error_clause is called when entering the json_query_on_error_clause production. + EnterJson_query_on_error_clause(c *Json_query_on_error_clauseContext) + + // EnterJson_query_on_empty_clause is called when entering the json_query_on_empty_clause production. + EnterJson_query_on_empty_clause(c *Json_query_on_empty_clauseContext) + + // EnterJson_value_return_clause is called when entering the json_value_return_clause production. + EnterJson_value_return_clause(c *Json_value_return_clauseContext) + + // EnterJson_value_return_type is called when entering the json_value_return_type production. + EnterJson_value_return_type(c *Json_value_return_typeContext) + + // EnterJson_value_on_mismatch_clause is called when entering the json_value_on_mismatch_clause production. + EnterJson_value_on_mismatch_clause(c *Json_value_on_mismatch_clauseContext) + + // EnterLiteral is called when entering the literal production. + EnterLiteral(c *LiteralContext) + + // EnterNumeric_function_wrapper is called when entering the numeric_function_wrapper production. + EnterNumeric_function_wrapper(c *Numeric_function_wrapperContext) + + // EnterNumeric_function is called when entering the numeric_function production. + EnterNumeric_function(c *Numeric_functionContext) + + // EnterListagg_overflow_clause is called when entering the listagg_overflow_clause production. + EnterListagg_overflow_clause(c *Listagg_overflow_clauseContext) + + // EnterOther_function is called when entering the other_function production. + EnterOther_function(c *Other_functionContext) + + // EnterOver_clause_keyword is called when entering the over_clause_keyword production. + EnterOver_clause_keyword(c *Over_clause_keywordContext) + + // EnterWithin_or_over_clause_keyword is called when entering the within_or_over_clause_keyword production. + EnterWithin_or_over_clause_keyword(c *Within_or_over_clause_keywordContext) + + // EnterStandard_prediction_function_keyword is called when entering the standard_prediction_function_keyword production. + EnterStandard_prediction_function_keyword(c *Standard_prediction_function_keywordContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterWindowing_clause is called when entering the windowing_clause production. + EnterWindowing_clause(c *Windowing_clauseContext) + + // EnterWindowing_type is called when entering the windowing_type production. + EnterWindowing_type(c *Windowing_typeContext) + + // EnterWindowing_elements is called when entering the windowing_elements production. + EnterWindowing_elements(c *Windowing_elementsContext) + + // EnterUsing_clause is called when entering the using_clause production. + EnterUsing_clause(c *Using_clauseContext) + + // EnterUsing_element is called when entering the using_element production. + EnterUsing_element(c *Using_elementContext) + + // EnterAssignable_element is called when entering the assignable_element production. + EnterAssignable_element(c *Assignable_elementContext) + + // EnterCollect_order_by_part is called when entering the collect_order_by_part production. + EnterCollect_order_by_part(c *Collect_order_by_partContext) + + // EnterWithin_or_over_part is called when entering the within_or_over_part production. + EnterWithin_or_over_part(c *Within_or_over_partContext) + + // EnterString_delimiter is called when entering the string_delimiter production. + EnterString_delimiter(c *String_delimiterContext) + + // EnterCost_matrix_clause is called when entering the cost_matrix_clause production. + EnterCost_matrix_clause(c *Cost_matrix_clauseContext) + + // EnterXml_passing_clause is called when entering the xml_passing_clause production. + EnterXml_passing_clause(c *Xml_passing_clauseContext) + + // EnterXml_attributes_clause is called when entering the xml_attributes_clause production. + EnterXml_attributes_clause(c *Xml_attributes_clauseContext) + + // EnterXml_namespaces_clause is called when entering the xml_namespaces_clause production. + EnterXml_namespaces_clause(c *Xml_namespaces_clauseContext) + + // EnterXml_table_column is called when entering the xml_table_column production. + EnterXml_table_column(c *Xml_table_columnContext) + + // EnterXml_general_default_part is called when entering the xml_general_default_part production. + EnterXml_general_default_part(c *Xml_general_default_partContext) + + // EnterXml_multiuse_expression_element is called when entering the xml_multiuse_expression_element production. + EnterXml_multiuse_expression_element(c *Xml_multiuse_expression_elementContext) + + // EnterXmlroot_param_version_part is called when entering the xmlroot_param_version_part production. + EnterXmlroot_param_version_part(c *Xmlroot_param_version_partContext) + + // EnterXmlroot_param_standalone_part is called when entering the xmlroot_param_standalone_part production. + EnterXmlroot_param_standalone_part(c *Xmlroot_param_standalone_partContext) + + // EnterXmlserialize_param_enconding_part is called when entering the xmlserialize_param_enconding_part production. + EnterXmlserialize_param_enconding_part(c *Xmlserialize_param_enconding_partContext) + + // EnterXmlserialize_param_version_part is called when entering the xmlserialize_param_version_part production. + EnterXmlserialize_param_version_part(c *Xmlserialize_param_version_partContext) + + // EnterXmlserialize_param_ident_part is called when entering the xmlserialize_param_ident_part production. + EnterXmlserialize_param_ident_part(c *Xmlserialize_param_ident_partContext) + + // EnterAnnotations_clause is called when entering the annotations_clause production. + EnterAnnotations_clause(c *Annotations_clauseContext) + + // EnterAnnotations_list is called when entering the annotations_list production. + EnterAnnotations_list(c *Annotations_listContext) + + // EnterAnnotation is called when entering the annotation production. + EnterAnnotation(c *AnnotationContext) + + // EnterSql_plus_command is called when entering the sql_plus_command production. + EnterSql_plus_command(c *Sql_plus_commandContext) + + // EnterStart_command is called when entering the start_command production. + EnterStart_command(c *Start_commandContext) + + // EnterSql_plus_filepath is called when entering the sql_plus_filepath production. + EnterSql_plus_filepath(c *Sql_plus_filepathContext) + + // EnterWhenever_command is called when entering the whenever_command production. + EnterWhenever_command(c *Whenever_commandContext) + + // EnterSet_command is called when entering the set_command production. + EnterSet_command(c *Set_commandContext) + + // EnterTiming_command is called when entering the timing_command production. + EnterTiming_command(c *Timing_commandContext) + + // EnterClear_command is called when entering the clear_command production. + EnterClear_command(c *Clear_commandContext) + + // EnterPartition_extension_clause is called when entering the partition_extension_clause production. + EnterPartition_extension_clause(c *Partition_extension_clauseContext) + + // EnterColumn_alias is called when entering the column_alias production. + EnterColumn_alias(c *Column_aliasContext) + + // EnterTable_alias is called when entering the table_alias production. + EnterTable_alias(c *Table_aliasContext) + + // EnterWhere_clause is called when entering the where_clause production. + EnterWhere_clause(c *Where_clauseContext) + + // EnterInto_clause is called when entering the into_clause production. + EnterInto_clause(c *Into_clauseContext) + + // EnterXml_column_name is called when entering the xml_column_name production. + EnterXml_column_name(c *Xml_column_nameContext) + + // EnterCost_class_name is called when entering the cost_class_name production. + EnterCost_class_name(c *Cost_class_nameContext) + + // EnterAttribute_name is called when entering the attribute_name production. + EnterAttribute_name(c *Attribute_nameContext) + + // EnterSavepoint_name is called when entering the savepoint_name production. + EnterSavepoint_name(c *Savepoint_nameContext) + + // EnterRollback_segment_name is called when entering the rollback_segment_name production. + EnterRollback_segment_name(c *Rollback_segment_nameContext) + + // EnterSchema_name is called when entering the schema_name production. + EnterSchema_name(c *Schema_nameContext) + + // EnterRoutine_name is called when entering the routine_name production. + EnterRoutine_name(c *Routine_nameContext) + + // EnterPackage_name is called when entering the package_name production. + EnterPackage_name(c *Package_nameContext) + + // EnterImplementation_type_name is called when entering the implementation_type_name production. + EnterImplementation_type_name(c *Implementation_type_nameContext) + + // EnterParameter_name is called when entering the parameter_name production. + EnterParameter_name(c *Parameter_nameContext) + + // EnterReference_model_name is called when entering the reference_model_name production. + EnterReference_model_name(c *Reference_model_nameContext) + + // EnterMain_model_name is called when entering the main_model_name production. + EnterMain_model_name(c *Main_model_nameContext) + + // EnterContainer_tableview_name is called when entering the container_tableview_name production. + EnterContainer_tableview_name(c *Container_tableview_nameContext) + + // EnterAggregate_function_name is called when entering the aggregate_function_name production. + EnterAggregate_function_name(c *Aggregate_function_nameContext) + + // EnterQuery_name is called when entering the query_name production. + EnterQuery_name(c *Query_nameContext) + + // EnterGrantee_name is called when entering the grantee_name production. + EnterGrantee_name(c *Grantee_nameContext) + + // EnterRole_name is called when entering the role_name production. + EnterRole_name(c *Role_nameContext) + + // EnterConstraint_name is called when entering the constraint_name production. + EnterConstraint_name(c *Constraint_nameContext) + + // EnterLabel_name is called when entering the label_name production. + EnterLabel_name(c *Label_nameContext) + + // EnterType_name is called when entering the type_name production. + EnterType_name(c *Type_nameContext) + + // EnterSequence_name is called when entering the sequence_name production. + EnterSequence_name(c *Sequence_nameContext) + + // EnterException_name is called when entering the exception_name production. + EnterException_name(c *Exception_nameContext) + + // EnterFunction_name is called when entering the function_name production. + EnterFunction_name(c *Function_nameContext) + + // EnterProcedure_name is called when entering the procedure_name production. + EnterProcedure_name(c *Procedure_nameContext) + + // EnterTrigger_name is called when entering the trigger_name production. + EnterTrigger_name(c *Trigger_nameContext) + + // EnterVariable_name is called when entering the variable_name production. + EnterVariable_name(c *Variable_nameContext) + + // EnterIndex_name is called when entering the index_name production. + EnterIndex_name(c *Index_nameContext) + + // EnterCursor_name is called when entering the cursor_name production. + EnterCursor_name(c *Cursor_nameContext) + + // EnterRecord_name is called when entering the record_name production. + EnterRecord_name(c *Record_nameContext) + + // EnterLink_name is called when entering the link_name production. + EnterLink_name(c *Link_nameContext) + + // EnterLocal_link_name is called when entering the local_link_name production. + EnterLocal_link_name(c *Local_link_nameContext) + + // EnterConnection_qualifier is called when entering the connection_qualifier production. + EnterConnection_qualifier(c *Connection_qualifierContext) + + // EnterColumn_name is called when entering the column_name production. + EnterColumn_name(c *Column_nameContext) + + // EnterTableview_name is called when entering the tableview_name production. + EnterTableview_name(c *Tableview_nameContext) + + // EnterXmltable is called when entering the xmltable production. + EnterXmltable(c *XmltableContext) + + // EnterChar_set_name is called when entering the char_set_name production. + EnterChar_set_name(c *Char_set_nameContext) + + // EnterSynonym_name is called when entering the synonym_name production. + EnterSynonym_name(c *Synonym_nameContext) + + // EnterSchema_object_name is called when entering the schema_object_name production. + EnterSchema_object_name(c *Schema_object_nameContext) + + // EnterDir_object_name is called when entering the dir_object_name production. + EnterDir_object_name(c *Dir_object_nameContext) + + // EnterUser_object_name is called when entering the user_object_name production. + EnterUser_object_name(c *User_object_nameContext) + + // EnterGrant_object_name is called when entering the grant_object_name production. + EnterGrant_object_name(c *Grant_object_nameContext) + + // EnterColumn_list is called when entering the column_list production. + EnterColumn_list(c *Column_listContext) + + // EnterParen_column_list is called when entering the paren_column_list production. + EnterParen_column_list(c *Paren_column_listContext) + + // EnterKeep_clause is called when entering the keep_clause production. + EnterKeep_clause(c *Keep_clauseContext) + + // EnterFunction_argument is called when entering the function_argument production. + EnterFunction_argument(c *Function_argumentContext) + + // EnterFunction_argument_analytic is called when entering the function_argument_analytic production. + EnterFunction_argument_analytic(c *Function_argument_analyticContext) + + // EnterFunction_argument_modeling is called when entering the function_argument_modeling production. + EnterFunction_argument_modeling(c *Function_argument_modelingContext) + + // EnterRespect_or_ignore_nulls is called when entering the respect_or_ignore_nulls production. + EnterRespect_or_ignore_nulls(c *Respect_or_ignore_nullsContext) + + // EnterArgument is called when entering the argument production. + EnterArgument(c *ArgumentContext) + + // EnterType_spec is called when entering the type_spec production. + EnterType_spec(c *Type_specContext) + + // EnterDatatype is called when entering the datatype production. + EnterDatatype(c *DatatypeContext) + + // EnterPrecision_part is called when entering the precision_part production. + EnterPrecision_part(c *Precision_partContext) + + // EnterNative_datatype_element is called when entering the native_datatype_element production. + EnterNative_datatype_element(c *Native_datatype_elementContext) + + // EnterBind_variable is called when entering the bind_variable production. + EnterBind_variable(c *Bind_variableContext) + + // EnterGeneral_element is called when entering the general_element production. + EnterGeneral_element(c *General_elementContext) + + // EnterGeneral_element_part is called when entering the general_element_part production. + EnterGeneral_element_part(c *General_element_partContext) + + // EnterTable_element is called when entering the table_element production. + EnterTable_element(c *Table_elementContext) + + // EnterObject_privilege is called when entering the object_privilege production. + EnterObject_privilege(c *Object_privilegeContext) + + // EnterSystem_privilege is called when entering the system_privilege production. + EnterSystem_privilege(c *System_privilegeContext) + + // EnterConstant is called when entering the constant production. + EnterConstant(c *ConstantContext) + + // EnterNumeric is called when entering the numeric production. + EnterNumeric(c *NumericContext) + + // EnterNumeric_negative is called when entering the numeric_negative production. + EnterNumeric_negative(c *Numeric_negativeContext) + + // EnterQuoted_string is called when entering the quoted_string production. + EnterQuoted_string(c *Quoted_stringContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // EnterId_expression is called when entering the id_expression production. + EnterId_expression(c *Id_expressionContext) + + // EnterInquiry_directive is called when entering the inquiry_directive production. + EnterInquiry_directive(c *Inquiry_directiveContext) + + // EnterOuter_join_sign is called when entering the outer_join_sign production. + EnterOuter_join_sign(c *Outer_join_signContext) + + // EnterRegular_id is called when entering the regular_id production. + EnterRegular_id(c *Regular_idContext) + + // EnterNon_reserved_keywords_in_18c is called when entering the non_reserved_keywords_in_18c production. + EnterNon_reserved_keywords_in_18c(c *Non_reserved_keywords_in_18cContext) + + // EnterNon_reserved_keywords_in_12c is called when entering the non_reserved_keywords_in_12c production. + EnterNon_reserved_keywords_in_12c(c *Non_reserved_keywords_in_12cContext) + + // EnterNon_reserved_keywords_pre12c is called when entering the non_reserved_keywords_pre12c production. + EnterNon_reserved_keywords_pre12c(c *Non_reserved_keywords_pre12cContext) + + // ExitSql_script is called when exiting the sql_script production. + ExitSql_script(c *Sql_scriptContext) + + // ExitUnit_statement is called when exiting the unit_statement production. + ExitUnit_statement(c *Unit_statementContext) + + // ExitAlter_diskgroup is called when exiting the alter_diskgroup production. + ExitAlter_diskgroup(c *Alter_diskgroupContext) + + // ExitAdd_disk_clause is called when exiting the add_disk_clause production. + ExitAdd_disk_clause(c *Add_disk_clauseContext) + + // ExitDrop_disk_clause is called when exiting the drop_disk_clause production. + ExitDrop_disk_clause(c *Drop_disk_clauseContext) + + // ExitResize_disk_clause is called when exiting the resize_disk_clause production. + ExitResize_disk_clause(c *Resize_disk_clauseContext) + + // ExitReplace_disk_clause is called when exiting the replace_disk_clause production. + ExitReplace_disk_clause(c *Replace_disk_clauseContext) + + // ExitWait_nowait is called when exiting the wait_nowait production. + ExitWait_nowait(c *Wait_nowaitContext) + + // ExitRename_disk_clause is called when exiting the rename_disk_clause production. + ExitRename_disk_clause(c *Rename_disk_clauseContext) + + // ExitDisk_online_clause is called when exiting the disk_online_clause production. + ExitDisk_online_clause(c *Disk_online_clauseContext) + + // ExitDisk_offline_clause is called when exiting the disk_offline_clause production. + ExitDisk_offline_clause(c *Disk_offline_clauseContext) + + // ExitTimeout_clause is called when exiting the timeout_clause production. + ExitTimeout_clause(c *Timeout_clauseContext) + + // ExitRebalance_diskgroup_clause is called when exiting the rebalance_diskgroup_clause production. + ExitRebalance_diskgroup_clause(c *Rebalance_diskgroup_clauseContext) + + // ExitPhase is called when exiting the phase production. + ExitPhase(c *PhaseContext) + + // ExitCheck_diskgroup_clause is called when exiting the check_diskgroup_clause production. + ExitCheck_diskgroup_clause(c *Check_diskgroup_clauseContext) + + // ExitDiskgroup_template_clauses is called when exiting the diskgroup_template_clauses production. + ExitDiskgroup_template_clauses(c *Diskgroup_template_clausesContext) + + // ExitQualified_template_clause is called when exiting the qualified_template_clause production. + ExitQualified_template_clause(c *Qualified_template_clauseContext) + + // ExitRedundancy_clause is called when exiting the redundancy_clause production. + ExitRedundancy_clause(c *Redundancy_clauseContext) + + // ExitStriping_clause is called when exiting the striping_clause production. + ExitStriping_clause(c *Striping_clauseContext) + + // ExitForce_noforce is called when exiting the force_noforce production. + ExitForce_noforce(c *Force_noforceContext) + + // ExitDiskgroup_directory_clauses is called when exiting the diskgroup_directory_clauses production. + ExitDiskgroup_directory_clauses(c *Diskgroup_directory_clausesContext) + + // ExitDir_name is called when exiting the dir_name production. + ExitDir_name(c *Dir_nameContext) + + // ExitDiskgroup_alias_clauses is called when exiting the diskgroup_alias_clauses production. + ExitDiskgroup_alias_clauses(c *Diskgroup_alias_clausesContext) + + // ExitDiskgroup_volume_clauses is called when exiting the diskgroup_volume_clauses production. + ExitDiskgroup_volume_clauses(c *Diskgroup_volume_clausesContext) + + // ExitAdd_volume_clause is called when exiting the add_volume_clause production. + ExitAdd_volume_clause(c *Add_volume_clauseContext) + + // ExitModify_volume_clause is called when exiting the modify_volume_clause production. + ExitModify_volume_clause(c *Modify_volume_clauseContext) + + // ExitDiskgroup_attributes is called when exiting the diskgroup_attributes production. + ExitDiskgroup_attributes(c *Diskgroup_attributesContext) + + // ExitDrop_diskgroup_file_clause is called when exiting the drop_diskgroup_file_clause production. + ExitDrop_diskgroup_file_clause(c *Drop_diskgroup_file_clauseContext) + + // ExitConvert_redundancy_clause is called when exiting the convert_redundancy_clause production. + ExitConvert_redundancy_clause(c *Convert_redundancy_clauseContext) + + // ExitUsergroup_clauses is called when exiting the usergroup_clauses production. + ExitUsergroup_clauses(c *Usergroup_clausesContext) + + // ExitUser_clauses is called when exiting the user_clauses production. + ExitUser_clauses(c *User_clausesContext) + + // ExitFile_permissions_clause is called when exiting the file_permissions_clause production. + ExitFile_permissions_clause(c *File_permissions_clauseContext) + + // ExitFile_owner_clause is called when exiting the file_owner_clause production. + ExitFile_owner_clause(c *File_owner_clauseContext) + + // ExitScrub_clause is called when exiting the scrub_clause production. + ExitScrub_clause(c *Scrub_clauseContext) + + // ExitQuotagroup_clauses is called when exiting the quotagroup_clauses production. + ExitQuotagroup_clauses(c *Quotagroup_clausesContext) + + // ExitProperty_name is called when exiting the property_name production. + ExitProperty_name(c *Property_nameContext) + + // ExitProperty_value is called when exiting the property_value production. + ExitProperty_value(c *Property_valueContext) + + // ExitFilegroup_clauses is called when exiting the filegroup_clauses production. + ExitFilegroup_clauses(c *Filegroup_clausesContext) + + // ExitAdd_filegroup_clause is called when exiting the add_filegroup_clause production. + ExitAdd_filegroup_clause(c *Add_filegroup_clauseContext) + + // ExitModify_filegroup_clause is called when exiting the modify_filegroup_clause production. + ExitModify_filegroup_clause(c *Modify_filegroup_clauseContext) + + // ExitMove_to_filegroup_clause is called when exiting the move_to_filegroup_clause production. + ExitMove_to_filegroup_clause(c *Move_to_filegroup_clauseContext) + + // ExitDrop_filegroup_clause is called when exiting the drop_filegroup_clause production. + ExitDrop_filegroup_clause(c *Drop_filegroup_clauseContext) + + // ExitQuorum_regular is called when exiting the quorum_regular production. + ExitQuorum_regular(c *Quorum_regularContext) + + // ExitUndrop_disk_clause is called when exiting the undrop_disk_clause production. + ExitUndrop_disk_clause(c *Undrop_disk_clauseContext) + + // ExitDiskgroup_availability is called when exiting the diskgroup_availability production. + ExitDiskgroup_availability(c *Diskgroup_availabilityContext) + + // ExitEnable_disable_volume is called when exiting the enable_disable_volume production. + ExitEnable_disable_volume(c *Enable_disable_volumeContext) + + // ExitDrop_function is called when exiting the drop_function production. + ExitDrop_function(c *Drop_functionContext) + + // ExitAlter_flashback_archive is called when exiting the alter_flashback_archive production. + ExitAlter_flashback_archive(c *Alter_flashback_archiveContext) + + // ExitAlter_hierarchy is called when exiting the alter_hierarchy production. + ExitAlter_hierarchy(c *Alter_hierarchyContext) + + // ExitAlter_function is called when exiting the alter_function production. + ExitAlter_function(c *Alter_functionContext) + + // ExitAlter_java is called when exiting the alter_java production. + ExitAlter_java(c *Alter_javaContext) + + // ExitMatch_string is called when exiting the match_string production. + ExitMatch_string(c *Match_stringContext) + + // ExitCreate_function_body is called when exiting the create_function_body production. + ExitCreate_function_body(c *Create_function_bodyContext) + + // ExitSql_macro_body is called when exiting the sql_macro_body production. + ExitSql_macro_body(c *Sql_macro_bodyContext) + + // ExitParallel_enable_clause is called when exiting the parallel_enable_clause production. + ExitParallel_enable_clause(c *Parallel_enable_clauseContext) + + // ExitPartition_by_clause is called when exiting the partition_by_clause production. + ExitPartition_by_clause(c *Partition_by_clauseContext) + + // ExitResult_cache_clause is called when exiting the result_cache_clause production. + ExitResult_cache_clause(c *Result_cache_clauseContext) + + // ExitAccessible_by_clause is called when exiting the accessible_by_clause production. + ExitAccessible_by_clause(c *Accessible_by_clauseContext) + + // ExitDefault_collation_clause is called when exiting the default_collation_clause production. + ExitDefault_collation_clause(c *Default_collation_clauseContext) + + // ExitAggregate_clause is called when exiting the aggregate_clause production. + ExitAggregate_clause(c *Aggregate_clauseContext) + + // ExitPipelined_using_clause is called when exiting the pipelined_using_clause production. + ExitPipelined_using_clause(c *Pipelined_using_clauseContext) + + // ExitAccessor is called when exiting the accessor production. + ExitAccessor(c *AccessorContext) + + // ExitRelies_on_part is called when exiting the relies_on_part production. + ExitRelies_on_part(c *Relies_on_partContext) + + // ExitStreaming_clause is called when exiting the streaming_clause production. + ExitStreaming_clause(c *Streaming_clauseContext) + + // ExitAlter_outline is called when exiting the alter_outline production. + ExitAlter_outline(c *Alter_outlineContext) + + // ExitOutline_options is called when exiting the outline_options production. + ExitOutline_options(c *Outline_optionsContext) + + // ExitAlter_lockdown_profile is called when exiting the alter_lockdown_profile production. + ExitAlter_lockdown_profile(c *Alter_lockdown_profileContext) + + // ExitLockdown_feature is called when exiting the lockdown_feature production. + ExitLockdown_feature(c *Lockdown_featureContext) + + // ExitLockdown_options is called when exiting the lockdown_options production. + ExitLockdown_options(c *Lockdown_optionsContext) + + // ExitLockdown_statements is called when exiting the lockdown_statements production. + ExitLockdown_statements(c *Lockdown_statementsContext) + + // ExitStatement_clauses is called when exiting the statement_clauses production. + ExitStatement_clauses(c *Statement_clausesContext) + + // ExitClause_options is called when exiting the clause_options production. + ExitClause_options(c *Clause_optionsContext) + + // ExitOption_values is called when exiting the option_values production. + ExitOption_values(c *Option_valuesContext) + + // ExitString_list is called when exiting the string_list production. + ExitString_list(c *String_listContext) + + // ExitDisable_enable is called when exiting the disable_enable production. + ExitDisable_enable(c *Disable_enableContext) + + // ExitDrop_lockdown_profile is called when exiting the drop_lockdown_profile production. + ExitDrop_lockdown_profile(c *Drop_lockdown_profileContext) + + // ExitDrop_package is called when exiting the drop_package production. + ExitDrop_package(c *Drop_packageContext) + + // ExitAlter_package is called when exiting the alter_package production. + ExitAlter_package(c *Alter_packageContext) + + // ExitCreate_package is called when exiting the create_package production. + ExitCreate_package(c *Create_packageContext) + + // ExitCreate_package_body is called when exiting the create_package_body production. + ExitCreate_package_body(c *Create_package_bodyContext) + + // ExitPackage_obj_spec is called when exiting the package_obj_spec production. + ExitPackage_obj_spec(c *Package_obj_specContext) + + // ExitProcedure_spec is called when exiting the procedure_spec production. + ExitProcedure_spec(c *Procedure_specContext) + + // ExitFunction_spec is called when exiting the function_spec production. + ExitFunction_spec(c *Function_specContext) + + // ExitPackage_obj_body is called when exiting the package_obj_body production. + ExitPackage_obj_body(c *Package_obj_bodyContext) + + // ExitAlter_pmem_filestore is called when exiting the alter_pmem_filestore production. + ExitAlter_pmem_filestore(c *Alter_pmem_filestoreContext) + + // ExitDrop_pmem_filestore is called when exiting the drop_pmem_filestore production. + ExitDrop_pmem_filestore(c *Drop_pmem_filestoreContext) + + // ExitDrop_procedure is called when exiting the drop_procedure production. + ExitDrop_procedure(c *Drop_procedureContext) + + // ExitAlter_procedure is called when exiting the alter_procedure production. + ExitAlter_procedure(c *Alter_procedureContext) + + // ExitFunction_body is called when exiting the function_body production. + ExitFunction_body(c *Function_bodyContext) + + // ExitProcedure_body is called when exiting the procedure_body production. + ExitProcedure_body(c *Procedure_bodyContext) + + // ExitCreate_procedure_body is called when exiting the create_procedure_body production. + ExitCreate_procedure_body(c *Create_procedure_bodyContext) + + // ExitAlter_resource_cost is called when exiting the alter_resource_cost production. + ExitAlter_resource_cost(c *Alter_resource_costContext) + + // ExitDrop_outline is called when exiting the drop_outline production. + ExitDrop_outline(c *Drop_outlineContext) + + // ExitAlter_rollback_segment is called when exiting the alter_rollback_segment production. + ExitAlter_rollback_segment(c *Alter_rollback_segmentContext) + + // ExitDrop_restore_point is called when exiting the drop_restore_point production. + ExitDrop_restore_point(c *Drop_restore_pointContext) + + // ExitDrop_rollback_segment is called when exiting the drop_rollback_segment production. + ExitDrop_rollback_segment(c *Drop_rollback_segmentContext) + + // ExitDrop_role is called when exiting the drop_role production. + ExitDrop_role(c *Drop_roleContext) + + // ExitCreate_pmem_filestore is called when exiting the create_pmem_filestore production. + ExitCreate_pmem_filestore(c *Create_pmem_filestoreContext) + + // ExitPmem_filestore_options is called when exiting the pmem_filestore_options production. + ExitPmem_filestore_options(c *Pmem_filestore_optionsContext) + + // ExitFile_path is called when exiting the file_path production. + ExitFile_path(c *File_pathContext) + + // ExitCreate_rollback_segment is called when exiting the create_rollback_segment production. + ExitCreate_rollback_segment(c *Create_rollback_segmentContext) + + // ExitDrop_trigger is called when exiting the drop_trigger production. + ExitDrop_trigger(c *Drop_triggerContext) + + // ExitAlter_trigger is called when exiting the alter_trigger production. + ExitAlter_trigger(c *Alter_triggerContext) + + // ExitCreate_trigger is called when exiting the create_trigger production. + ExitCreate_trigger(c *Create_triggerContext) + + // ExitTrigger_follows_clause is called when exiting the trigger_follows_clause production. + ExitTrigger_follows_clause(c *Trigger_follows_clauseContext) + + // ExitTrigger_when_clause is called when exiting the trigger_when_clause production. + ExitTrigger_when_clause(c *Trigger_when_clauseContext) + + // ExitSimple_dml_trigger is called when exiting the simple_dml_trigger production. + ExitSimple_dml_trigger(c *Simple_dml_triggerContext) + + // ExitFor_each_row is called when exiting the for_each_row production. + ExitFor_each_row(c *For_each_rowContext) + + // ExitCompound_dml_trigger is called when exiting the compound_dml_trigger production. + ExitCompound_dml_trigger(c *Compound_dml_triggerContext) + + // ExitNon_dml_trigger is called when exiting the non_dml_trigger production. + ExitNon_dml_trigger(c *Non_dml_triggerContext) + + // ExitTrigger_body is called when exiting the trigger_body production. + ExitTrigger_body(c *Trigger_bodyContext) + + // ExitCompound_trigger_block is called when exiting the compound_trigger_block production. + ExitCompound_trigger_block(c *Compound_trigger_blockContext) + + // ExitTiming_point_section is called when exiting the timing_point_section production. + ExitTiming_point_section(c *Timing_point_sectionContext) + + // ExitNon_dml_event is called when exiting the non_dml_event production. + ExitNon_dml_event(c *Non_dml_eventContext) + + // ExitDml_event_clause is called when exiting the dml_event_clause production. + ExitDml_event_clause(c *Dml_event_clauseContext) + + // ExitDml_event_element is called when exiting the dml_event_element production. + ExitDml_event_element(c *Dml_event_elementContext) + + // ExitDml_event_nested_clause is called when exiting the dml_event_nested_clause production. + ExitDml_event_nested_clause(c *Dml_event_nested_clauseContext) + + // ExitReferencing_clause is called when exiting the referencing_clause production. + ExitReferencing_clause(c *Referencing_clauseContext) + + // ExitReferencing_element is called when exiting the referencing_element production. + ExitReferencing_element(c *Referencing_elementContext) + + // ExitDrop_type is called when exiting the drop_type production. + ExitDrop_type(c *Drop_typeContext) + + // ExitAlter_type is called when exiting the alter_type production. + ExitAlter_type(c *Alter_typeContext) + + // ExitCompile_type_clause is called when exiting the compile_type_clause production. + ExitCompile_type_clause(c *Compile_type_clauseContext) + + // ExitReplace_type_clause is called when exiting the replace_type_clause production. + ExitReplace_type_clause(c *Replace_type_clauseContext) + + // ExitAlter_method_spec is called when exiting the alter_method_spec production. + ExitAlter_method_spec(c *Alter_method_specContext) + + // ExitAlter_method_element is called when exiting the alter_method_element production. + ExitAlter_method_element(c *Alter_method_elementContext) + + // ExitAlter_collection_clauses is called when exiting the alter_collection_clauses production. + ExitAlter_collection_clauses(c *Alter_collection_clausesContext) + + // ExitDependent_handling_clause is called when exiting the dependent_handling_clause production. + ExitDependent_handling_clause(c *Dependent_handling_clauseContext) + + // ExitDependent_exceptions_part is called when exiting the dependent_exceptions_part production. + ExitDependent_exceptions_part(c *Dependent_exceptions_partContext) + + // ExitCreate_type is called when exiting the create_type production. + ExitCreate_type(c *Create_typeContext) + + // ExitType_definition is called when exiting the type_definition production. + ExitType_definition(c *Type_definitionContext) + + // ExitObject_type_def is called when exiting the object_type_def production. + ExitObject_type_def(c *Object_type_defContext) + + // ExitObject_as_part is called when exiting the object_as_part production. + ExitObject_as_part(c *Object_as_partContext) + + // ExitObject_under_part is called when exiting the object_under_part production. + ExitObject_under_part(c *Object_under_partContext) + + // ExitNested_table_type_def is called when exiting the nested_table_type_def production. + ExitNested_table_type_def(c *Nested_table_type_defContext) + + // ExitSqlj_object_type is called when exiting the sqlj_object_type production. + ExitSqlj_object_type(c *Sqlj_object_typeContext) + + // ExitType_body is called when exiting the type_body production. + ExitType_body(c *Type_bodyContext) + + // ExitType_body_elements is called when exiting the type_body_elements production. + ExitType_body_elements(c *Type_body_elementsContext) + + // ExitMap_order_func_declaration is called when exiting the map_order_func_declaration production. + ExitMap_order_func_declaration(c *Map_order_func_declarationContext) + + // ExitSubprog_decl_in_type is called when exiting the subprog_decl_in_type production. + ExitSubprog_decl_in_type(c *Subprog_decl_in_typeContext) + + // ExitProc_decl_in_type is called when exiting the proc_decl_in_type production. + ExitProc_decl_in_type(c *Proc_decl_in_typeContext) + + // ExitFunc_decl_in_type is called when exiting the func_decl_in_type production. + ExitFunc_decl_in_type(c *Func_decl_in_typeContext) + + // ExitConstructor_declaration is called when exiting the constructor_declaration production. + ExitConstructor_declaration(c *Constructor_declarationContext) + + // ExitModifier_clause is called when exiting the modifier_clause production. + ExitModifier_clause(c *Modifier_clauseContext) + + // ExitObject_member_spec is called when exiting the object_member_spec production. + ExitObject_member_spec(c *Object_member_specContext) + + // ExitSqlj_object_type_attr is called when exiting the sqlj_object_type_attr production. + ExitSqlj_object_type_attr(c *Sqlj_object_type_attrContext) + + // ExitElement_spec is called when exiting the element_spec production. + ExitElement_spec(c *Element_specContext) + + // ExitElement_spec_options is called when exiting the element_spec_options production. + ExitElement_spec_options(c *Element_spec_optionsContext) + + // ExitSubprogram_spec is called when exiting the subprogram_spec production. + ExitSubprogram_spec(c *Subprogram_specContext) + + // ExitOverriding_subprogram_spec is called when exiting the overriding_subprogram_spec production. + ExitOverriding_subprogram_spec(c *Overriding_subprogram_specContext) + + // ExitOverriding_function_spec is called when exiting the overriding_function_spec production. + ExitOverriding_function_spec(c *Overriding_function_specContext) + + // ExitOverriding_procedure_spec is called when exiting the overriding_procedure_spec production. + ExitOverriding_procedure_spec(c *Overriding_procedure_specContext) + + // ExitType_procedure_spec is called when exiting the type_procedure_spec production. + ExitType_procedure_spec(c *Type_procedure_specContext) + + // ExitType_function_spec is called when exiting the type_function_spec production. + ExitType_function_spec(c *Type_function_specContext) + + // ExitConstructor_spec is called when exiting the constructor_spec production. + ExitConstructor_spec(c *Constructor_specContext) + + // ExitMap_order_function_spec is called when exiting the map_order_function_spec production. + ExitMap_order_function_spec(c *Map_order_function_specContext) + + // ExitPragma_clause is called when exiting the pragma_clause production. + ExitPragma_clause(c *Pragma_clauseContext) + + // ExitPragma_elements is called when exiting the pragma_elements production. + ExitPragma_elements(c *Pragma_elementsContext) + + // ExitType_elements_parameter is called when exiting the type_elements_parameter production. + ExitType_elements_parameter(c *Type_elements_parameterContext) + + // ExitDrop_sequence is called when exiting the drop_sequence production. + ExitDrop_sequence(c *Drop_sequenceContext) + + // ExitAlter_sequence is called when exiting the alter_sequence production. + ExitAlter_sequence(c *Alter_sequenceContext) + + // ExitAlter_session is called when exiting the alter_session production. + ExitAlter_session(c *Alter_sessionContext) + + // ExitAlter_session_set_clause is called when exiting the alter_session_set_clause production. + ExitAlter_session_set_clause(c *Alter_session_set_clauseContext) + + // ExitCreate_sequence is called when exiting the create_sequence production. + ExitCreate_sequence(c *Create_sequenceContext) + + // ExitSequence_spec is called when exiting the sequence_spec production. + ExitSequence_spec(c *Sequence_specContext) + + // ExitSequence_start_clause is called when exiting the sequence_start_clause production. + ExitSequence_start_clause(c *Sequence_start_clauseContext) + + // ExitCreate_analytic_view is called when exiting the create_analytic_view production. + ExitCreate_analytic_view(c *Create_analytic_viewContext) + + // ExitClassification_clause is called when exiting the classification_clause production. + ExitClassification_clause(c *Classification_clauseContext) + + // ExitCaption_clause is called when exiting the caption_clause production. + ExitCaption_clause(c *Caption_clauseContext) + + // ExitDescription_clause is called when exiting the description_clause production. + ExitDescription_clause(c *Description_clauseContext) + + // ExitClassification_item is called when exiting the classification_item production. + ExitClassification_item(c *Classification_itemContext) + + // ExitLanguage is called when exiting the language production. + ExitLanguage(c *LanguageContext) + + // ExitCav_using_clause is called when exiting the cav_using_clause production. + ExitCav_using_clause(c *Cav_using_clauseContext) + + // ExitDim_by_clause is called when exiting the dim_by_clause production. + ExitDim_by_clause(c *Dim_by_clauseContext) + + // ExitDim_key is called when exiting the dim_key production. + ExitDim_key(c *Dim_keyContext) + + // ExitDim_ref is called when exiting the dim_ref production. + ExitDim_ref(c *Dim_refContext) + + // ExitHier_ref is called when exiting the hier_ref production. + ExitHier_ref(c *Hier_refContext) + + // ExitMeasures_clause is called when exiting the measures_clause production. + ExitMeasures_clause(c *Measures_clauseContext) + + // ExitAv_measure is called when exiting the av_measure production. + ExitAv_measure(c *Av_measureContext) + + // ExitBase_meas_clause is called when exiting the base_meas_clause production. + ExitBase_meas_clause(c *Base_meas_clauseContext) + + // ExitMeas_aggregate_clause is called when exiting the meas_aggregate_clause production. + ExitMeas_aggregate_clause(c *Meas_aggregate_clauseContext) + + // ExitCalc_meas_clause is called when exiting the calc_meas_clause production. + ExitCalc_meas_clause(c *Calc_meas_clauseContext) + + // ExitDefault_measure_clause is called when exiting the default_measure_clause production. + ExitDefault_measure_clause(c *Default_measure_clauseContext) + + // ExitDefault_aggregate_clause is called when exiting the default_aggregate_clause production. + ExitDefault_aggregate_clause(c *Default_aggregate_clauseContext) + + // ExitCache_clause is called when exiting the cache_clause production. + ExitCache_clause(c *Cache_clauseContext) + + // ExitCache_specification is called when exiting the cache_specification production. + ExitCache_specification(c *Cache_specificationContext) + + // ExitLevels_clause is called when exiting the levels_clause production. + ExitLevels_clause(c *Levels_clauseContext) + + // ExitLevel_specification is called when exiting the level_specification production. + ExitLevel_specification(c *Level_specificationContext) + + // ExitLevel_group_type is called when exiting the level_group_type production. + ExitLevel_group_type(c *Level_group_typeContext) + + // ExitFact_columns_clause is called when exiting the fact_columns_clause production. + ExitFact_columns_clause(c *Fact_columns_clauseContext) + + // ExitQry_transform_clause is called when exiting the qry_transform_clause production. + ExitQry_transform_clause(c *Qry_transform_clauseContext) + + // ExitCreate_attribute_dimension is called when exiting the create_attribute_dimension production. + ExitCreate_attribute_dimension(c *Create_attribute_dimensionContext) + + // ExitAd_using_clause is called when exiting the ad_using_clause production. + ExitAd_using_clause(c *Ad_using_clauseContext) + + // ExitSource_clause is called when exiting the source_clause production. + ExitSource_clause(c *Source_clauseContext) + + // ExitJoin_path_clause is called when exiting the join_path_clause production. + ExitJoin_path_clause(c *Join_path_clauseContext) + + // ExitJoin_condition is called when exiting the join_condition production. + ExitJoin_condition(c *Join_conditionContext) + + // ExitJoin_condition_item is called when exiting the join_condition_item production. + ExitJoin_condition_item(c *Join_condition_itemContext) + + // ExitAttributes_clause is called when exiting the attributes_clause production. + ExitAttributes_clause(c *Attributes_clauseContext) + + // ExitAd_attributes_clause is called when exiting the ad_attributes_clause production. + ExitAd_attributes_clause(c *Ad_attributes_clauseContext) + + // ExitAd_level_clause is called when exiting the ad_level_clause production. + ExitAd_level_clause(c *Ad_level_clauseContext) + + // ExitKey_clause is called when exiting the key_clause production. + ExitKey_clause(c *Key_clauseContext) + + // ExitAlternate_key_clause is called when exiting the alternate_key_clause production. + ExitAlternate_key_clause(c *Alternate_key_clauseContext) + + // ExitDim_order_clause is called when exiting the dim_order_clause production. + ExitDim_order_clause(c *Dim_order_clauseContext) + + // ExitAll_clause is called when exiting the all_clause production. + ExitAll_clause(c *All_clauseContext) + + // ExitCreate_audit_policy is called when exiting the create_audit_policy production. + ExitCreate_audit_policy(c *Create_audit_policyContext) + + // ExitPrivilege_audit_clause is called when exiting the privilege_audit_clause production. + ExitPrivilege_audit_clause(c *Privilege_audit_clauseContext) + + // ExitAction_audit_clause is called when exiting the action_audit_clause production. + ExitAction_audit_clause(c *Action_audit_clauseContext) + + // ExitSystem_actions is called when exiting the system_actions production. + ExitSystem_actions(c *System_actionsContext) + + // ExitStandard_actions is called when exiting the standard_actions production. + ExitStandard_actions(c *Standard_actionsContext) + + // ExitActions_clause is called when exiting the actions_clause production. + ExitActions_clause(c *Actions_clauseContext) + + // ExitObject_action is called when exiting the object_action production. + ExitObject_action(c *Object_actionContext) + + // ExitSystem_action is called when exiting the system_action production. + ExitSystem_action(c *System_actionContext) + + // ExitComponent_actions is called when exiting the component_actions production. + ExitComponent_actions(c *Component_actionsContext) + + // ExitComponent_action is called when exiting the component_action production. + ExitComponent_action(c *Component_actionContext) + + // ExitRole_audit_clause is called when exiting the role_audit_clause production. + ExitRole_audit_clause(c *Role_audit_clauseContext) + + // ExitCreate_controlfile is called when exiting the create_controlfile production. + ExitCreate_controlfile(c *Create_controlfileContext) + + // ExitControlfile_options is called when exiting the controlfile_options production. + ExitControlfile_options(c *Controlfile_optionsContext) + + // ExitLogfile_clause is called when exiting the logfile_clause production. + ExitLogfile_clause(c *Logfile_clauseContext) + + // ExitCharacter_set_clause is called when exiting the character_set_clause production. + ExitCharacter_set_clause(c *Character_set_clauseContext) + + // ExitFile_specification is called when exiting the file_specification production. + ExitFile_specification(c *File_specificationContext) + + // ExitCreate_diskgroup is called when exiting the create_diskgroup production. + ExitCreate_diskgroup(c *Create_diskgroupContext) + + // ExitQualified_disk_clause is called when exiting the qualified_disk_clause production. + ExitQualified_disk_clause(c *Qualified_disk_clauseContext) + + // ExitCreate_edition is called when exiting the create_edition production. + ExitCreate_edition(c *Create_editionContext) + + // ExitCreate_flashback_archive is called when exiting the create_flashback_archive production. + ExitCreate_flashback_archive(c *Create_flashback_archiveContext) + + // ExitFlashback_archive_quota is called when exiting the flashback_archive_quota production. + ExitFlashback_archive_quota(c *Flashback_archive_quotaContext) + + // ExitFlashback_archive_retention is called when exiting the flashback_archive_retention production. + ExitFlashback_archive_retention(c *Flashback_archive_retentionContext) + + // ExitCreate_hierarchy is called when exiting the create_hierarchy production. + ExitCreate_hierarchy(c *Create_hierarchyContext) + + // ExitHier_using_clause is called when exiting the hier_using_clause production. + ExitHier_using_clause(c *Hier_using_clauseContext) + + // ExitLevel_hier_clause is called when exiting the level_hier_clause production. + ExitLevel_hier_clause(c *Level_hier_clauseContext) + + // ExitHier_attrs_clause is called when exiting the hier_attrs_clause production. + ExitHier_attrs_clause(c *Hier_attrs_clauseContext) + + // ExitHier_attr_clause is called when exiting the hier_attr_clause production. + ExitHier_attr_clause(c *Hier_attr_clauseContext) + + // ExitHier_attr_name is called when exiting the hier_attr_name production. + ExitHier_attr_name(c *Hier_attr_nameContext) + + // ExitCreate_index is called when exiting the create_index production. + ExitCreate_index(c *Create_indexContext) + + // ExitCluster_index_clause is called when exiting the cluster_index_clause production. + ExitCluster_index_clause(c *Cluster_index_clauseContext) + + // ExitCluster_name is called when exiting the cluster_name production. + ExitCluster_name(c *Cluster_nameContext) + + // ExitTable_index_clause is called when exiting the table_index_clause production. + ExitTable_index_clause(c *Table_index_clauseContext) + + // ExitBitmap_join_index_clause is called when exiting the bitmap_join_index_clause production. + ExitBitmap_join_index_clause(c *Bitmap_join_index_clauseContext) + + // ExitIndex_expr is called when exiting the index_expr production. + ExitIndex_expr(c *Index_exprContext) + + // ExitIndex_properties is called when exiting the index_properties production. + ExitIndex_properties(c *Index_propertiesContext) + + // ExitDomain_index_clause is called when exiting the domain_index_clause production. + ExitDomain_index_clause(c *Domain_index_clauseContext) + + // ExitLocal_domain_index_clause is called when exiting the local_domain_index_clause production. + ExitLocal_domain_index_clause(c *Local_domain_index_clauseContext) + + // ExitXmlindex_clause is called when exiting the xmlindex_clause production. + ExitXmlindex_clause(c *Xmlindex_clauseContext) + + // ExitLocal_xmlindex_clause is called when exiting the local_xmlindex_clause production. + ExitLocal_xmlindex_clause(c *Local_xmlindex_clauseContext) + + // ExitGlobal_partitioned_index is called when exiting the global_partitioned_index production. + ExitGlobal_partitioned_index(c *Global_partitioned_indexContext) + + // ExitIndex_partitioning_clause is called when exiting the index_partitioning_clause production. + ExitIndex_partitioning_clause(c *Index_partitioning_clauseContext) + + // ExitIndex_partitioning_values_list is called when exiting the index_partitioning_values_list production. + ExitIndex_partitioning_values_list(c *Index_partitioning_values_listContext) + + // ExitLocal_partitioned_index is called when exiting the local_partitioned_index production. + ExitLocal_partitioned_index(c *Local_partitioned_indexContext) + + // ExitOn_range_partitioned_table is called when exiting the on_range_partitioned_table production. + ExitOn_range_partitioned_table(c *On_range_partitioned_tableContext) + + // ExitOn_list_partitioned_table is called when exiting the on_list_partitioned_table production. + ExitOn_list_partitioned_table(c *On_list_partitioned_tableContext) + + // ExitPartitioned_table is called when exiting the partitioned_table production. + ExitPartitioned_table(c *Partitioned_tableContext) + + // ExitOn_hash_partitioned_table is called when exiting the on_hash_partitioned_table production. + ExitOn_hash_partitioned_table(c *On_hash_partitioned_tableContext) + + // ExitOn_hash_partitioned_clause is called when exiting the on_hash_partitioned_clause production. + ExitOn_hash_partitioned_clause(c *On_hash_partitioned_clauseContext) + + // ExitOn_comp_partitioned_table is called when exiting the on_comp_partitioned_table production. + ExitOn_comp_partitioned_table(c *On_comp_partitioned_tableContext) + + // ExitOn_comp_partitioned_clause is called when exiting the on_comp_partitioned_clause production. + ExitOn_comp_partitioned_clause(c *On_comp_partitioned_clauseContext) + + // ExitIndex_subpartition_clause is called when exiting the index_subpartition_clause production. + ExitIndex_subpartition_clause(c *Index_subpartition_clauseContext) + + // ExitIndex_subpartition_subclause is called when exiting the index_subpartition_subclause production. + ExitIndex_subpartition_subclause(c *Index_subpartition_subclauseContext) + + // ExitOdci_parameters is called when exiting the odci_parameters production. + ExitOdci_parameters(c *Odci_parametersContext) + + // ExitIndextype is called when exiting the indextype production. + ExitIndextype(c *IndextypeContext) + + // ExitAlter_index is called when exiting the alter_index production. + ExitAlter_index(c *Alter_indexContext) + + // ExitAlter_index_ops_set1 is called when exiting the alter_index_ops_set1 production. + ExitAlter_index_ops_set1(c *Alter_index_ops_set1Context) + + // ExitAlter_index_ops_set2 is called when exiting the alter_index_ops_set2 production. + ExitAlter_index_ops_set2(c *Alter_index_ops_set2Context) + + // ExitVisible_or_invisible is called when exiting the visible_or_invisible production. + ExitVisible_or_invisible(c *Visible_or_invisibleContext) + + // ExitMonitoring_nomonitoring is called when exiting the monitoring_nomonitoring production. + ExitMonitoring_nomonitoring(c *Monitoring_nomonitoringContext) + + // ExitRebuild_clause is called when exiting the rebuild_clause production. + ExitRebuild_clause(c *Rebuild_clauseContext) + + // ExitAlter_index_partitioning is called when exiting the alter_index_partitioning production. + ExitAlter_index_partitioning(c *Alter_index_partitioningContext) + + // ExitModify_index_default_attrs is called when exiting the modify_index_default_attrs production. + ExitModify_index_default_attrs(c *Modify_index_default_attrsContext) + + // ExitAdd_hash_index_partition is called when exiting the add_hash_index_partition production. + ExitAdd_hash_index_partition(c *Add_hash_index_partitionContext) + + // ExitCoalesce_index_partition is called when exiting the coalesce_index_partition production. + ExitCoalesce_index_partition(c *Coalesce_index_partitionContext) + + // ExitModify_index_partition is called when exiting the modify_index_partition production. + ExitModify_index_partition(c *Modify_index_partitionContext) + + // ExitModify_index_partitions_ops is called when exiting the modify_index_partitions_ops production. + ExitModify_index_partitions_ops(c *Modify_index_partitions_opsContext) + + // ExitRename_index_partition is called when exiting the rename_index_partition production. + ExitRename_index_partition(c *Rename_index_partitionContext) + + // ExitDrop_index_partition is called when exiting the drop_index_partition production. + ExitDrop_index_partition(c *Drop_index_partitionContext) + + // ExitSplit_index_partition is called when exiting the split_index_partition production. + ExitSplit_index_partition(c *Split_index_partitionContext) + + // ExitIndex_partition_description is called when exiting the index_partition_description production. + ExitIndex_partition_description(c *Index_partition_descriptionContext) + + // ExitModify_index_subpartition is called when exiting the modify_index_subpartition production. + ExitModify_index_subpartition(c *Modify_index_subpartitionContext) + + // ExitPartition_name_old is called when exiting the partition_name_old production. + ExitPartition_name_old(c *Partition_name_oldContext) + + // ExitNew_partition_name is called when exiting the new_partition_name production. + ExitNew_partition_name(c *New_partition_nameContext) + + // ExitNew_index_name is called when exiting the new_index_name production. + ExitNew_index_name(c *New_index_nameContext) + + // ExitAlter_inmemory_join_group is called when exiting the alter_inmemory_join_group production. + ExitAlter_inmemory_join_group(c *Alter_inmemory_join_groupContext) + + // ExitCreate_user is called when exiting the create_user production. + ExitCreate_user(c *Create_userContext) + + // ExitAlter_user is called when exiting the alter_user production. + ExitAlter_user(c *Alter_userContext) + + // ExitDrop_user is called when exiting the drop_user production. + ExitDrop_user(c *Drop_userContext) + + // ExitAlter_identified_by is called when exiting the alter_identified_by production. + ExitAlter_identified_by(c *Alter_identified_byContext) + + // ExitIdentified_by is called when exiting the identified_by production. + ExitIdentified_by(c *Identified_byContext) + + // ExitIdentified_other_clause is called when exiting the identified_other_clause production. + ExitIdentified_other_clause(c *Identified_other_clauseContext) + + // ExitUser_tablespace_clause is called when exiting the user_tablespace_clause production. + ExitUser_tablespace_clause(c *User_tablespace_clauseContext) + + // ExitQuota_clause is called when exiting the quota_clause production. + ExitQuota_clause(c *Quota_clauseContext) + + // ExitProfile_clause is called when exiting the profile_clause production. + ExitProfile_clause(c *Profile_clauseContext) + + // ExitRole_clause is called when exiting the role_clause production. + ExitRole_clause(c *Role_clauseContext) + + // ExitUser_default_role_clause is called when exiting the user_default_role_clause production. + ExitUser_default_role_clause(c *User_default_role_clauseContext) + + // ExitPassword_expire_clause is called when exiting the password_expire_clause production. + ExitPassword_expire_clause(c *Password_expire_clauseContext) + + // ExitUser_lock_clause is called when exiting the user_lock_clause production. + ExitUser_lock_clause(c *User_lock_clauseContext) + + // ExitUser_editions_clause is called when exiting the user_editions_clause production. + ExitUser_editions_clause(c *User_editions_clauseContext) + + // ExitAlter_user_editions_clause is called when exiting the alter_user_editions_clause production. + ExitAlter_user_editions_clause(c *Alter_user_editions_clauseContext) + + // ExitProxy_clause is called when exiting the proxy_clause production. + ExitProxy_clause(c *Proxy_clauseContext) + + // ExitContainer_names is called when exiting the container_names production. + ExitContainer_names(c *Container_namesContext) + + // ExitSet_container_data is called when exiting the set_container_data production. + ExitSet_container_data(c *Set_container_dataContext) + + // ExitAdd_rem_container_data is called when exiting the add_rem_container_data production. + ExitAdd_rem_container_data(c *Add_rem_container_dataContext) + + // ExitContainer_data_clause is called when exiting the container_data_clause production. + ExitContainer_data_clause(c *Container_data_clauseContext) + + // ExitAdminister_key_management is called when exiting the administer_key_management production. + ExitAdminister_key_management(c *Administer_key_managementContext) + + // ExitKeystore_management_clauses is called when exiting the keystore_management_clauses production. + ExitKeystore_management_clauses(c *Keystore_management_clausesContext) + + // ExitCreate_keystore is called when exiting the create_keystore production. + ExitCreate_keystore(c *Create_keystoreContext) + + // ExitOpen_keystore is called when exiting the open_keystore production. + ExitOpen_keystore(c *Open_keystoreContext) + + // ExitForce_keystore is called when exiting the force_keystore production. + ExitForce_keystore(c *Force_keystoreContext) + + // ExitClose_keystore is called when exiting the close_keystore production. + ExitClose_keystore(c *Close_keystoreContext) + + // ExitBackup_keystore is called when exiting the backup_keystore production. + ExitBackup_keystore(c *Backup_keystoreContext) + + // ExitAlter_keystore_password is called when exiting the alter_keystore_password production. + ExitAlter_keystore_password(c *Alter_keystore_passwordContext) + + // ExitMerge_into_new_keystore is called when exiting the merge_into_new_keystore production. + ExitMerge_into_new_keystore(c *Merge_into_new_keystoreContext) + + // ExitMerge_into_existing_keystore is called when exiting the merge_into_existing_keystore production. + ExitMerge_into_existing_keystore(c *Merge_into_existing_keystoreContext) + + // ExitIsolate_keystore is called when exiting the isolate_keystore production. + ExitIsolate_keystore(c *Isolate_keystoreContext) + + // ExitUnite_keystore is called when exiting the unite_keystore production. + ExitUnite_keystore(c *Unite_keystoreContext) + + // ExitKey_management_clauses is called when exiting the key_management_clauses production. + ExitKey_management_clauses(c *Key_management_clausesContext) + + // ExitSet_key is called when exiting the set_key production. + ExitSet_key(c *Set_keyContext) + + // ExitCreate_key is called when exiting the create_key production. + ExitCreate_key(c *Create_keyContext) + + // ExitMkid is called when exiting the mkid production. + ExitMkid(c *MkidContext) + + // ExitMk is called when exiting the mk production. + ExitMk(c *MkContext) + + // ExitUse_key is called when exiting the use_key production. + ExitUse_key(c *Use_keyContext) + + // ExitSet_key_tag is called when exiting the set_key_tag production. + ExitSet_key_tag(c *Set_key_tagContext) + + // ExitExport_keys is called when exiting the export_keys production. + ExitExport_keys(c *Export_keysContext) + + // ExitImport_keys is called when exiting the import_keys production. + ExitImport_keys(c *Import_keysContext) + + // ExitMigrate_keys is called when exiting the migrate_keys production. + ExitMigrate_keys(c *Migrate_keysContext) + + // ExitReverse_migrate_keys is called when exiting the reverse_migrate_keys production. + ExitReverse_migrate_keys(c *Reverse_migrate_keysContext) + + // ExitMove_keys is called when exiting the move_keys production. + ExitMove_keys(c *Move_keysContext) + + // ExitIdentified_by_store is called when exiting the identified_by_store production. + ExitIdentified_by_store(c *Identified_by_storeContext) + + // ExitUsing_algorithm_clause is called when exiting the using_algorithm_clause production. + ExitUsing_algorithm_clause(c *Using_algorithm_clauseContext) + + // ExitUsing_tag_clause is called when exiting the using_tag_clause production. + ExitUsing_tag_clause(c *Using_tag_clauseContext) + + // ExitSecret_management_clauses is called when exiting the secret_management_clauses production. + ExitSecret_management_clauses(c *Secret_management_clausesContext) + + // ExitAdd_update_secret is called when exiting the add_update_secret production. + ExitAdd_update_secret(c *Add_update_secretContext) + + // ExitDelete_secret is called when exiting the delete_secret production. + ExitDelete_secret(c *Delete_secretContext) + + // ExitAdd_update_secret_seps is called when exiting the add_update_secret_seps production. + ExitAdd_update_secret_seps(c *Add_update_secret_sepsContext) + + // ExitDelete_secret_seps is called when exiting the delete_secret_seps production. + ExitDelete_secret_seps(c *Delete_secret_sepsContext) + + // ExitZero_downtime_software_patching_clauses is called when exiting the zero_downtime_software_patching_clauses production. + ExitZero_downtime_software_patching_clauses(c *Zero_downtime_software_patching_clausesContext) + + // ExitWith_backup_clause is called when exiting the with_backup_clause production. + ExitWith_backup_clause(c *With_backup_clauseContext) + + // ExitIdentified_by_password_clause is called when exiting the identified_by_password_clause production. + ExitIdentified_by_password_clause(c *Identified_by_password_clauseContext) + + // ExitKeystore_password is called when exiting the keystore_password production. + ExitKeystore_password(c *Keystore_passwordContext) + + // ExitPath is called when exiting the path production. + ExitPath(c *PathContext) + + // ExitSecret is called when exiting the secret production. + ExitSecret(c *SecretContext) + + // ExitAnalyze is called when exiting the analyze production. + ExitAnalyze(c *AnalyzeContext) + + // ExitPartition_extention_clause is called when exiting the partition_extention_clause production. + ExitPartition_extention_clause(c *Partition_extention_clauseContext) + + // ExitValidation_clauses is called when exiting the validation_clauses production. + ExitValidation_clauses(c *Validation_clausesContext) + + // ExitCompute_clauses is called when exiting the compute_clauses production. + ExitCompute_clauses(c *Compute_clausesContext) + + // ExitFor_clause is called when exiting the for_clause production. + ExitFor_clause(c *For_clauseContext) + + // ExitOnline_or_offline is called when exiting the online_or_offline production. + ExitOnline_or_offline(c *Online_or_offlineContext) + + // ExitInto_clause1 is called when exiting the into_clause1 production. + ExitInto_clause1(c *Into_clause1Context) + + // ExitPartition_key_value is called when exiting the partition_key_value production. + ExitPartition_key_value(c *Partition_key_valueContext) + + // ExitSubpartition_key_value is called when exiting the subpartition_key_value production. + ExitSubpartition_key_value(c *Subpartition_key_valueContext) + + // ExitAssociate_statistics is called when exiting the associate_statistics production. + ExitAssociate_statistics(c *Associate_statisticsContext) + + // ExitColumn_association is called when exiting the column_association production. + ExitColumn_association(c *Column_associationContext) + + // ExitFunction_association is called when exiting the function_association production. + ExitFunction_association(c *Function_associationContext) + + // ExitIndextype_name is called when exiting the indextype_name production. + ExitIndextype_name(c *Indextype_nameContext) + + // ExitUsing_statistics_type is called when exiting the using_statistics_type production. + ExitUsing_statistics_type(c *Using_statistics_typeContext) + + // ExitStatistics_type_name is called when exiting the statistics_type_name production. + ExitStatistics_type_name(c *Statistics_type_nameContext) + + // ExitDefault_cost_clause is called when exiting the default_cost_clause production. + ExitDefault_cost_clause(c *Default_cost_clauseContext) + + // ExitCpu_cost is called when exiting the cpu_cost production. + ExitCpu_cost(c *Cpu_costContext) + + // ExitIo_cost is called when exiting the io_cost production. + ExitIo_cost(c *Io_costContext) + + // ExitNetwork_cost is called when exiting the network_cost production. + ExitNetwork_cost(c *Network_costContext) + + // ExitDefault_selectivity_clause is called when exiting the default_selectivity_clause production. + ExitDefault_selectivity_clause(c *Default_selectivity_clauseContext) + + // ExitDefault_selectivity is called when exiting the default_selectivity production. + ExitDefault_selectivity(c *Default_selectivityContext) + + // ExitStorage_table_clause is called when exiting the storage_table_clause production. + ExitStorage_table_clause(c *Storage_table_clauseContext) + + // ExitUnified_auditing is called when exiting the unified_auditing production. + ExitUnified_auditing(c *Unified_auditingContext) + + // ExitPolicy_name is called when exiting the policy_name production. + ExitPolicy_name(c *Policy_nameContext) + + // ExitAudit_traditional is called when exiting the audit_traditional production. + ExitAudit_traditional(c *Audit_traditionalContext) + + // ExitAudit_direct_path is called when exiting the audit_direct_path production. + ExitAudit_direct_path(c *Audit_direct_pathContext) + + // ExitAudit_container_clause is called when exiting the audit_container_clause production. + ExitAudit_container_clause(c *Audit_container_clauseContext) + + // ExitAudit_operation_clause is called when exiting the audit_operation_clause production. + ExitAudit_operation_clause(c *Audit_operation_clauseContext) + + // ExitAuditing_by_clause is called when exiting the auditing_by_clause production. + ExitAuditing_by_clause(c *Auditing_by_clauseContext) + + // ExitAudit_user is called when exiting the audit_user production. + ExitAudit_user(c *Audit_userContext) + + // ExitAudit_schema_object_clause is called when exiting the audit_schema_object_clause production. + ExitAudit_schema_object_clause(c *Audit_schema_object_clauseContext) + + // ExitSql_operation is called when exiting the sql_operation production. + ExitSql_operation(c *Sql_operationContext) + + // ExitAuditing_on_clause is called when exiting the auditing_on_clause production. + ExitAuditing_on_clause(c *Auditing_on_clauseContext) + + // ExitModel_name is called when exiting the model_name production. + ExitModel_name(c *Model_nameContext) + + // ExitObject_name is called when exiting the object_name production. + ExitObject_name(c *Object_nameContext) + + // ExitProfile_name is called when exiting the profile_name production. + ExitProfile_name(c *Profile_nameContext) + + // ExitSql_statement_shortcut is called when exiting the sql_statement_shortcut production. + ExitSql_statement_shortcut(c *Sql_statement_shortcutContext) + + // ExitDrop_index is called when exiting the drop_index production. + ExitDrop_index(c *Drop_indexContext) + + // ExitDisassociate_statistics is called when exiting the disassociate_statistics production. + ExitDisassociate_statistics(c *Disassociate_statisticsContext) + + // ExitDrop_indextype is called when exiting the drop_indextype production. + ExitDrop_indextype(c *Drop_indextypeContext) + + // ExitDrop_inmemory_join_group is called when exiting the drop_inmemory_join_group production. + ExitDrop_inmemory_join_group(c *Drop_inmemory_join_groupContext) + + // ExitFlashback_table is called when exiting the flashback_table production. + ExitFlashback_table(c *Flashback_tableContext) + + // ExitRestore_point is called when exiting the restore_point production. + ExitRestore_point(c *Restore_pointContext) + + // ExitPurge_statement is called when exiting the purge_statement production. + ExitPurge_statement(c *Purge_statementContext) + + // ExitNoaudit_statement is called when exiting the noaudit_statement production. + ExitNoaudit_statement(c *Noaudit_statementContext) + + // ExitRename_object is called when exiting the rename_object production. + ExitRename_object(c *Rename_objectContext) + + // ExitGrant_statement is called when exiting the grant_statement production. + ExitGrant_statement(c *Grant_statementContext) + + // ExitContainer_clause is called when exiting the container_clause production. + ExitContainer_clause(c *Container_clauseContext) + + // ExitRevoke_statement is called when exiting the revoke_statement production. + ExitRevoke_statement(c *Revoke_statementContext) + + // ExitRevoke_system_privilege is called when exiting the revoke_system_privilege production. + ExitRevoke_system_privilege(c *Revoke_system_privilegeContext) + + // ExitRevokee_clause is called when exiting the revokee_clause production. + ExitRevokee_clause(c *Revokee_clauseContext) + + // ExitRevoke_object_privileges is called when exiting the revoke_object_privileges production. + ExitRevoke_object_privileges(c *Revoke_object_privilegesContext) + + // ExitOn_object_clause is called when exiting the on_object_clause production. + ExitOn_object_clause(c *On_object_clauseContext) + + // ExitRevoke_roles_from_programs is called when exiting the revoke_roles_from_programs production. + ExitRevoke_roles_from_programs(c *Revoke_roles_from_programsContext) + + // ExitProgram_unit is called when exiting the program_unit production. + ExitProgram_unit(c *Program_unitContext) + + // ExitCreate_dimension is called when exiting the create_dimension production. + ExitCreate_dimension(c *Create_dimensionContext) + + // ExitCreate_directory is called when exiting the create_directory production. + ExitCreate_directory(c *Create_directoryContext) + + // ExitDirectory_name is called when exiting the directory_name production. + ExitDirectory_name(c *Directory_nameContext) + + // ExitDirectory_path is called when exiting the directory_path production. + ExitDirectory_path(c *Directory_pathContext) + + // ExitCreate_inmemory_join_group is called when exiting the create_inmemory_join_group production. + ExitCreate_inmemory_join_group(c *Create_inmemory_join_groupContext) + + // ExitDrop_hierarchy is called when exiting the drop_hierarchy production. + ExitDrop_hierarchy(c *Drop_hierarchyContext) + + // ExitAlter_library is called when exiting the alter_library production. + ExitAlter_library(c *Alter_libraryContext) + + // ExitDrop_java is called when exiting the drop_java production. + ExitDrop_java(c *Drop_javaContext) + + // ExitDrop_library is called when exiting the drop_library production. + ExitDrop_library(c *Drop_libraryContext) + + // ExitCreate_java is called when exiting the create_java production. + ExitCreate_java(c *Create_javaContext) + + // ExitCreate_library is called when exiting the create_library production. + ExitCreate_library(c *Create_libraryContext) + + // ExitPlsql_library_source is called when exiting the plsql_library_source production. + ExitPlsql_library_source(c *Plsql_library_sourceContext) + + // ExitCredential_name is called when exiting the credential_name production. + ExitCredential_name(c *Credential_nameContext) + + // ExitLibrary_editionable is called when exiting the library_editionable production. + ExitLibrary_editionable(c *Library_editionableContext) + + // ExitLibrary_debug is called when exiting the library_debug production. + ExitLibrary_debug(c *Library_debugContext) + + // ExitCompiler_parameters_clause is called when exiting the compiler_parameters_clause production. + ExitCompiler_parameters_clause(c *Compiler_parameters_clauseContext) + + // ExitParameter_value is called when exiting the parameter_value production. + ExitParameter_value(c *Parameter_valueContext) + + // ExitLibrary_name is called when exiting the library_name production. + ExitLibrary_name(c *Library_nameContext) + + // ExitAlter_dimension is called when exiting the alter_dimension production. + ExitAlter_dimension(c *Alter_dimensionContext) + + // ExitLevel_clause is called when exiting the level_clause production. + ExitLevel_clause(c *Level_clauseContext) + + // ExitHierarchy_clause is called when exiting the hierarchy_clause production. + ExitHierarchy_clause(c *Hierarchy_clauseContext) + + // ExitDimension_join_clause is called when exiting the dimension_join_clause production. + ExitDimension_join_clause(c *Dimension_join_clauseContext) + + // ExitAttribute_clause is called when exiting the attribute_clause production. + ExitAttribute_clause(c *Attribute_clauseContext) + + // ExitExtended_attribute_clause is called when exiting the extended_attribute_clause production. + ExitExtended_attribute_clause(c *Extended_attribute_clauseContext) + + // ExitColumn_one_or_more_sub_clause is called when exiting the column_one_or_more_sub_clause production. + ExitColumn_one_or_more_sub_clause(c *Column_one_or_more_sub_clauseContext) + + // ExitAlter_view is called when exiting the alter_view production. + ExitAlter_view(c *Alter_viewContext) + + // ExitAlter_view_editionable is called when exiting the alter_view_editionable production. + ExitAlter_view_editionable(c *Alter_view_editionableContext) + + // ExitCreate_view is called when exiting the create_view production. + ExitCreate_view(c *Create_viewContext) + + // ExitEditioning_clause is called when exiting the editioning_clause production. + ExitEditioning_clause(c *Editioning_clauseContext) + + // ExitView_options is called when exiting the view_options production. + ExitView_options(c *View_optionsContext) + + // ExitView_alias_constraint is called when exiting the view_alias_constraint production. + ExitView_alias_constraint(c *View_alias_constraintContext) + + // ExitObject_view_clause is called when exiting the object_view_clause production. + ExitObject_view_clause(c *Object_view_clauseContext) + + // ExitInline_constraint is called when exiting the inline_constraint production. + ExitInline_constraint(c *Inline_constraintContext) + + // ExitInline_ref_constraint is called when exiting the inline_ref_constraint production. + ExitInline_ref_constraint(c *Inline_ref_constraintContext) + + // ExitOut_of_line_ref_constraint is called when exiting the out_of_line_ref_constraint production. + ExitOut_of_line_ref_constraint(c *Out_of_line_ref_constraintContext) + + // ExitOut_of_line_constraint is called when exiting the out_of_line_constraint production. + ExitOut_of_line_constraint(c *Out_of_line_constraintContext) + + // ExitConstraint_state is called when exiting the constraint_state production. + ExitConstraint_state(c *Constraint_stateContext) + + // ExitXmltype_view_clause is called when exiting the xmltype_view_clause production. + ExitXmltype_view_clause(c *Xmltype_view_clauseContext) + + // ExitXml_schema_spec is called when exiting the xml_schema_spec production. + ExitXml_schema_spec(c *Xml_schema_specContext) + + // ExitXml_schema_url is called when exiting the xml_schema_url production. + ExitXml_schema_url(c *Xml_schema_urlContext) + + // ExitElement is called when exiting the element production. + ExitElement(c *ElementContext) + + // ExitAlter_tablespace is called when exiting the alter_tablespace production. + ExitAlter_tablespace(c *Alter_tablespaceContext) + + // ExitDatafile_tempfile_clauses is called when exiting the datafile_tempfile_clauses production. + ExitDatafile_tempfile_clauses(c *Datafile_tempfile_clausesContext) + + // ExitTablespace_logging_clauses is called when exiting the tablespace_logging_clauses production. + ExitTablespace_logging_clauses(c *Tablespace_logging_clausesContext) + + // ExitTablespace_group_clause is called when exiting the tablespace_group_clause production. + ExitTablespace_group_clause(c *Tablespace_group_clauseContext) + + // ExitTablespace_group_name is called when exiting the tablespace_group_name production. + ExitTablespace_group_name(c *Tablespace_group_nameContext) + + // ExitTablespace_state_clauses is called when exiting the tablespace_state_clauses production. + ExitTablespace_state_clauses(c *Tablespace_state_clausesContext) + + // ExitFlashback_mode_clause is called when exiting the flashback_mode_clause production. + ExitFlashback_mode_clause(c *Flashback_mode_clauseContext) + + // ExitNew_tablespace_name is called when exiting the new_tablespace_name production. + ExitNew_tablespace_name(c *New_tablespace_nameContext) + + // ExitCreate_tablespace is called when exiting the create_tablespace production. + ExitCreate_tablespace(c *Create_tablespaceContext) + + // ExitPermanent_tablespace_clause is called when exiting the permanent_tablespace_clause production. + ExitPermanent_tablespace_clause(c *Permanent_tablespace_clauseContext) + + // ExitTablespace_encryption_spec is called when exiting the tablespace_encryption_spec production. + ExitTablespace_encryption_spec(c *Tablespace_encryption_specContext) + + // ExitLogging_clause is called when exiting the logging_clause production. + ExitLogging_clause(c *Logging_clauseContext) + + // ExitExtent_management_clause is called when exiting the extent_management_clause production. + ExitExtent_management_clause(c *Extent_management_clauseContext) + + // ExitSegment_management_clause is called when exiting the segment_management_clause production. + ExitSegment_management_clause(c *Segment_management_clauseContext) + + // ExitTemporary_tablespace_clause is called when exiting the temporary_tablespace_clause production. + ExitTemporary_tablespace_clause(c *Temporary_tablespace_clauseContext) + + // ExitUndo_tablespace_clause is called when exiting the undo_tablespace_clause production. + ExitUndo_tablespace_clause(c *Undo_tablespace_clauseContext) + + // ExitTablespace_retention_clause is called when exiting the tablespace_retention_clause production. + ExitTablespace_retention_clause(c *Tablespace_retention_clauseContext) + + // ExitCreate_tablespace_set is called when exiting the create_tablespace_set production. + ExitCreate_tablespace_set(c *Create_tablespace_setContext) + + // ExitPermanent_tablespace_attrs is called when exiting the permanent_tablespace_attrs production. + ExitPermanent_tablespace_attrs(c *Permanent_tablespace_attrsContext) + + // ExitTablespace_encryption_clause is called when exiting the tablespace_encryption_clause production. + ExitTablespace_encryption_clause(c *Tablespace_encryption_clauseContext) + + // ExitDefault_tablespace_params is called when exiting the default_tablespace_params production. + ExitDefault_tablespace_params(c *Default_tablespace_paramsContext) + + // ExitDefault_table_compression is called when exiting the default_table_compression production. + ExitDefault_table_compression(c *Default_table_compressionContext) + + // ExitLow_high is called when exiting the low_high production. + ExitLow_high(c *Low_highContext) + + // ExitDefault_index_compression is called when exiting the default_index_compression production. + ExitDefault_index_compression(c *Default_index_compressionContext) + + // ExitInmmemory_clause is called when exiting the inmmemory_clause production. + ExitInmmemory_clause(c *Inmmemory_clauseContext) + + // ExitDatafile_specification is called when exiting the datafile_specification production. + ExitDatafile_specification(c *Datafile_specificationContext) + + // ExitTempfile_specification is called when exiting the tempfile_specification production. + ExitTempfile_specification(c *Tempfile_specificationContext) + + // ExitDatafile_tempfile_spec is called when exiting the datafile_tempfile_spec production. + ExitDatafile_tempfile_spec(c *Datafile_tempfile_specContext) + + // ExitRedo_log_file_spec is called when exiting the redo_log_file_spec production. + ExitRedo_log_file_spec(c *Redo_log_file_specContext) + + // ExitAutoextend_clause is called when exiting the autoextend_clause production. + ExitAutoextend_clause(c *Autoextend_clauseContext) + + // ExitMaxsize_clause is called when exiting the maxsize_clause production. + ExitMaxsize_clause(c *Maxsize_clauseContext) + + // ExitBuild_clause is called when exiting the build_clause production. + ExitBuild_clause(c *Build_clauseContext) + + // ExitParallel_clause is called when exiting the parallel_clause production. + ExitParallel_clause(c *Parallel_clauseContext) + + // ExitParallel_instances_clause is called when exiting the parallel_instances_clause production. + ExitParallel_instances_clause(c *Parallel_instances_clauseContext) + + // ExitAlter_materialized_view is called when exiting the alter_materialized_view production. + ExitAlter_materialized_view(c *Alter_materialized_viewContext) + + // ExitAlter_mv_option1 is called when exiting the alter_mv_option1 production. + ExitAlter_mv_option1(c *Alter_mv_option1Context) + + // ExitAlter_mv_refresh is called when exiting the alter_mv_refresh production. + ExitAlter_mv_refresh(c *Alter_mv_refreshContext) + + // ExitRollback_segment is called when exiting the rollback_segment production. + ExitRollback_segment(c *Rollback_segmentContext) + + // ExitModify_mv_column_clause is called when exiting the modify_mv_column_clause production. + ExitModify_mv_column_clause(c *Modify_mv_column_clauseContext) + + // ExitAlter_materialized_view_log is called when exiting the alter_materialized_view_log production. + ExitAlter_materialized_view_log(c *Alter_materialized_view_logContext) + + // ExitAdd_mv_log_column_clause is called when exiting the add_mv_log_column_clause production. + ExitAdd_mv_log_column_clause(c *Add_mv_log_column_clauseContext) + + // ExitMove_mv_log_clause is called when exiting the move_mv_log_clause production. + ExitMove_mv_log_clause(c *Move_mv_log_clauseContext) + + // ExitMv_log_augmentation is called when exiting the mv_log_augmentation production. + ExitMv_log_augmentation(c *Mv_log_augmentationContext) + + // ExitCreate_materialized_view_log is called when exiting the create_materialized_view_log production. + ExitCreate_materialized_view_log(c *Create_materialized_view_logContext) + + // ExitNew_values_clause is called when exiting the new_values_clause production. + ExitNew_values_clause(c *New_values_clauseContext) + + // ExitMv_log_purge_clause is called when exiting the mv_log_purge_clause production. + ExitMv_log_purge_clause(c *Mv_log_purge_clauseContext) + + // ExitCreate_materialized_zonemap is called when exiting the create_materialized_zonemap production. + ExitCreate_materialized_zonemap(c *Create_materialized_zonemapContext) + + // ExitAlter_materialized_zonemap is called when exiting the alter_materialized_zonemap production. + ExitAlter_materialized_zonemap(c *Alter_materialized_zonemapContext) + + // ExitDrop_materialized_zonemap is called when exiting the drop_materialized_zonemap production. + ExitDrop_materialized_zonemap(c *Drop_materialized_zonemapContext) + + // ExitZonemap_refresh_clause is called when exiting the zonemap_refresh_clause production. + ExitZonemap_refresh_clause(c *Zonemap_refresh_clauseContext) + + // ExitZonemap_attributes is called when exiting the zonemap_attributes production. + ExitZonemap_attributes(c *Zonemap_attributesContext) + + // ExitZonemap_name is called when exiting the zonemap_name production. + ExitZonemap_name(c *Zonemap_nameContext) + + // ExitOperator_name is called when exiting the operator_name production. + ExitOperator_name(c *Operator_nameContext) + + // ExitOperator_function_name is called when exiting the operator_function_name production. + ExitOperator_function_name(c *Operator_function_nameContext) + + // ExitCreate_zonemap_on_table is called when exiting the create_zonemap_on_table production. + ExitCreate_zonemap_on_table(c *Create_zonemap_on_tableContext) + + // ExitCreate_zonemap_as_subquery is called when exiting the create_zonemap_as_subquery production. + ExitCreate_zonemap_as_subquery(c *Create_zonemap_as_subqueryContext) + + // ExitAlter_operator is called when exiting the alter_operator production. + ExitAlter_operator(c *Alter_operatorContext) + + // ExitDrop_operator is called when exiting the drop_operator production. + ExitDrop_operator(c *Drop_operatorContext) + + // ExitCreate_operator is called when exiting the create_operator production. + ExitCreate_operator(c *Create_operatorContext) + + // ExitBinding_clause is called when exiting the binding_clause production. + ExitBinding_clause(c *Binding_clauseContext) + + // ExitAdd_binding_clause is called when exiting the add_binding_clause production. + ExitAdd_binding_clause(c *Add_binding_clauseContext) + + // ExitImplementation_clause is called when exiting the implementation_clause production. + ExitImplementation_clause(c *Implementation_clauseContext) + + // ExitPrimary_operator_list is called when exiting the primary_operator_list production. + ExitPrimary_operator_list(c *Primary_operator_listContext) + + // ExitPrimary_operator_item is called when exiting the primary_operator_item production. + ExitPrimary_operator_item(c *Primary_operator_itemContext) + + // ExitOperator_context_clause is called when exiting the operator_context_clause production. + ExitOperator_context_clause(c *Operator_context_clauseContext) + + // ExitUsing_function_clause is called when exiting the using_function_clause production. + ExitUsing_function_clause(c *Using_function_clauseContext) + + // ExitDrop_binding_clause is called when exiting the drop_binding_clause production. + ExitDrop_binding_clause(c *Drop_binding_clauseContext) + + // ExitCreate_materialized_view is called when exiting the create_materialized_view production. + ExitCreate_materialized_view(c *Create_materialized_viewContext) + + // ExitScoped_table_ref_constraint is called when exiting the scoped_table_ref_constraint production. + ExitScoped_table_ref_constraint(c *Scoped_table_ref_constraintContext) + + // ExitMv_column_alias is called when exiting the mv_column_alias production. + ExitMv_column_alias(c *Mv_column_aliasContext) + + // ExitCreate_mv_refresh is called when exiting the create_mv_refresh production. + ExitCreate_mv_refresh(c *Create_mv_refreshContext) + + // ExitQuery_rewrite_clause is called when exiting the query_rewrite_clause production. + ExitQuery_rewrite_clause(c *Query_rewrite_clauseContext) + + // ExitUnusable_editions_clause is called when exiting the unusable_editions_clause production. + ExitUnusable_editions_clause(c *Unusable_editions_clauseContext) + + // ExitDrop_materialized_view is called when exiting the drop_materialized_view production. + ExitDrop_materialized_view(c *Drop_materialized_viewContext) + + // ExitDrop_materialized_view_log is called when exiting the drop_materialized_view_log production. + ExitDrop_materialized_view_log(c *Drop_materialized_view_logContext) + + // ExitCreate_context is called when exiting the create_context production. + ExitCreate_context(c *Create_contextContext) + + // ExitOracle_namespace is called when exiting the oracle_namespace production. + ExitOracle_namespace(c *Oracle_namespaceContext) + + // ExitCreate_cluster is called when exiting the create_cluster production. + ExitCreate_cluster(c *Create_clusterContext) + + // ExitCreate_profile is called when exiting the create_profile production. + ExitCreate_profile(c *Create_profileContext) + + // ExitResource_parameters is called when exiting the resource_parameters production. + ExitResource_parameters(c *Resource_parametersContext) + + // ExitPassword_parameters is called when exiting the password_parameters production. + ExitPassword_parameters(c *Password_parametersContext) + + // ExitCreate_lockdown_profile is called when exiting the create_lockdown_profile production. + ExitCreate_lockdown_profile(c *Create_lockdown_profileContext) + + // ExitStatic_base_profile is called when exiting the static_base_profile production. + ExitStatic_base_profile(c *Static_base_profileContext) + + // ExitDynamic_base_profile is called when exiting the dynamic_base_profile production. + ExitDynamic_base_profile(c *Dynamic_base_profileContext) + + // ExitCreate_outline is called when exiting the create_outline production. + ExitCreate_outline(c *Create_outlineContext) + + // ExitCreate_restore_point is called when exiting the create_restore_point production. + ExitCreate_restore_point(c *Create_restore_pointContext) + + // ExitCreate_role is called when exiting the create_role production. + ExitCreate_role(c *Create_roleContext) + + // ExitCreate_table is called when exiting the create_table production. + ExitCreate_table(c *Create_tableContext) + + // ExitXmltype_table is called when exiting the xmltype_table production. + ExitXmltype_table(c *Xmltype_tableContext) + + // ExitXmltype_virtual_columns is called when exiting the xmltype_virtual_columns production. + ExitXmltype_virtual_columns(c *Xmltype_virtual_columnsContext) + + // ExitXmltype_column_properties is called when exiting the xmltype_column_properties production. + ExitXmltype_column_properties(c *Xmltype_column_propertiesContext) + + // ExitXmltype_storage is called when exiting the xmltype_storage production. + ExitXmltype_storage(c *Xmltype_storageContext) + + // ExitXmlschema_spec is called when exiting the xmlschema_spec production. + ExitXmlschema_spec(c *Xmlschema_specContext) + + // ExitObject_table is called when exiting the object_table production. + ExitObject_table(c *Object_tableContext) + + // ExitObject_type is called when exiting the object_type production. + ExitObject_type(c *Object_typeContext) + + // ExitOid_index_clause is called when exiting the oid_index_clause production. + ExitOid_index_clause(c *Oid_index_clauseContext) + + // ExitOid_clause is called when exiting the oid_clause production. + ExitOid_clause(c *Oid_clauseContext) + + // ExitObject_properties is called when exiting the object_properties production. + ExitObject_properties(c *Object_propertiesContext) + + // ExitObject_table_substitution is called when exiting the object_table_substitution production. + ExitObject_table_substitution(c *Object_table_substitutionContext) + + // ExitRelational_table is called when exiting the relational_table production. + ExitRelational_table(c *Relational_tableContext) + + // ExitRelational_table_properties is called when exiting the relational_table_properties production. + ExitRelational_table_properties(c *Relational_table_propertiesContext) + + // ExitRelational_table_property is called when exiting the relational_table_property production. + ExitRelational_table_property(c *Relational_table_propertyContext) + + // ExitImmutable_table_clauses is called when exiting the immutable_table_clauses production. + ExitImmutable_table_clauses(c *Immutable_table_clausesContext) + + // ExitImmutable_table_no_drop_clause is called when exiting the immutable_table_no_drop_clause production. + ExitImmutable_table_no_drop_clause(c *Immutable_table_no_drop_clauseContext) + + // ExitImmutable_table_no_delete_clause is called when exiting the immutable_table_no_delete_clause production. + ExitImmutable_table_no_delete_clause(c *Immutable_table_no_delete_clauseContext) + + // ExitBlockchain_table_clauses is called when exiting the blockchain_table_clauses production. + ExitBlockchain_table_clauses(c *Blockchain_table_clausesContext) + + // ExitBlockchain_drop_table_clause is called when exiting the blockchain_drop_table_clause production. + ExitBlockchain_drop_table_clause(c *Blockchain_drop_table_clauseContext) + + // ExitBlockchain_row_retention_clause is called when exiting the blockchain_row_retention_clause production. + ExitBlockchain_row_retention_clause(c *Blockchain_row_retention_clauseContext) + + // ExitBlockchain_hash_and_data_format_clause is called when exiting the blockchain_hash_and_data_format_clause production. + ExitBlockchain_hash_and_data_format_clause(c *Blockchain_hash_and_data_format_clauseContext) + + // ExitCollation_name is called when exiting the collation_name production. + ExitCollation_name(c *Collation_nameContext) + + // ExitTable_properties is called when exiting the table_properties production. + ExitTable_properties(c *Table_propertiesContext) + + // ExitRead_only_clause is called when exiting the read_only_clause production. + ExitRead_only_clause(c *Read_only_clauseContext) + + // ExitIndexing_clause is called when exiting the indexing_clause production. + ExitIndexing_clause(c *Indexing_clauseContext) + + // ExitAttribute_clustering_clause is called when exiting the attribute_clustering_clause production. + ExitAttribute_clustering_clause(c *Attribute_clustering_clauseContext) + + // ExitClustering_join is called when exiting the clustering_join production. + ExitClustering_join(c *Clustering_joinContext) + + // ExitClustering_join_item is called when exiting the clustering_join_item production. + ExitClustering_join_item(c *Clustering_join_itemContext) + + // ExitEquijoin_condition is called when exiting the equijoin_condition production. + ExitEquijoin_condition(c *Equijoin_conditionContext) + + // ExitCluster_clause is called when exiting the cluster_clause production. + ExitCluster_clause(c *Cluster_clauseContext) + + // ExitClustering_columns is called when exiting the clustering_columns production. + ExitClustering_columns(c *Clustering_columnsContext) + + // ExitClustering_column_group is called when exiting the clustering_column_group production. + ExitClustering_column_group(c *Clustering_column_groupContext) + + // ExitYes_no is called when exiting the yes_no production. + ExitYes_no(c *Yes_noContext) + + // ExitZonemap_clause is called when exiting the zonemap_clause production. + ExitZonemap_clause(c *Zonemap_clauseContext) + + // ExitLogical_replication_clause is called when exiting the logical_replication_clause production. + ExitLogical_replication_clause(c *Logical_replication_clauseContext) + + // ExitTable_name is called when exiting the table_name production. + ExitTable_name(c *Table_nameContext) + + // ExitRelational_property is called when exiting the relational_property production. + ExitRelational_property(c *Relational_propertyContext) + + // ExitTable_partitioning_clauses is called when exiting the table_partitioning_clauses production. + ExitTable_partitioning_clauses(c *Table_partitioning_clausesContext) + + // ExitRange_partitions is called when exiting the range_partitions production. + ExitRange_partitions(c *Range_partitionsContext) + + // ExitList_partitions is called when exiting the list_partitions production. + ExitList_partitions(c *List_partitionsContext) + + // ExitHash_partitions is called when exiting the hash_partitions production. + ExitHash_partitions(c *Hash_partitionsContext) + + // ExitIndividual_hash_partitions is called when exiting the individual_hash_partitions production. + ExitIndividual_hash_partitions(c *Individual_hash_partitionsContext) + + // ExitHash_partitions_by_quantity is called when exiting the hash_partitions_by_quantity production. + ExitHash_partitions_by_quantity(c *Hash_partitions_by_quantityContext) + + // ExitHash_partition_quantity is called when exiting the hash_partition_quantity production. + ExitHash_partition_quantity(c *Hash_partition_quantityContext) + + // ExitComposite_range_partitions is called when exiting the composite_range_partitions production. + ExitComposite_range_partitions(c *Composite_range_partitionsContext) + + // ExitComposite_list_partitions is called when exiting the composite_list_partitions production. + ExitComposite_list_partitions(c *Composite_list_partitionsContext) + + // ExitComposite_hash_partitions is called when exiting the composite_hash_partitions production. + ExitComposite_hash_partitions(c *Composite_hash_partitionsContext) + + // ExitReference_partitioning is called when exiting the reference_partitioning production. + ExitReference_partitioning(c *Reference_partitioningContext) + + // ExitReference_partition_desc is called when exiting the reference_partition_desc production. + ExitReference_partition_desc(c *Reference_partition_descContext) + + // ExitSystem_partitioning is called when exiting the system_partitioning production. + ExitSystem_partitioning(c *System_partitioningContext) + + // ExitRange_partition_desc is called when exiting the range_partition_desc production. + ExitRange_partition_desc(c *Range_partition_descContext) + + // ExitList_partition_desc is called when exiting the list_partition_desc production. + ExitList_partition_desc(c *List_partition_descContext) + + // ExitSubpartition_template is called when exiting the subpartition_template production. + ExitSubpartition_template(c *Subpartition_templateContext) + + // ExitHash_subpartition_quantity is called when exiting the hash_subpartition_quantity production. + ExitHash_subpartition_quantity(c *Hash_subpartition_quantityContext) + + // ExitSubpartition_by_range is called when exiting the subpartition_by_range production. + ExitSubpartition_by_range(c *Subpartition_by_rangeContext) + + // ExitSubpartition_by_list is called when exiting the subpartition_by_list production. + ExitSubpartition_by_list(c *Subpartition_by_listContext) + + // ExitSubpartition_by_hash is called when exiting the subpartition_by_hash production. + ExitSubpartition_by_hash(c *Subpartition_by_hashContext) + + // ExitSubpartition_name is called when exiting the subpartition_name production. + ExitSubpartition_name(c *Subpartition_nameContext) + + // ExitRange_subpartition_desc is called when exiting the range_subpartition_desc production. + ExitRange_subpartition_desc(c *Range_subpartition_descContext) + + // ExitList_subpartition_desc is called when exiting the list_subpartition_desc production. + ExitList_subpartition_desc(c *List_subpartition_descContext) + + // ExitIndividual_hash_subparts is called when exiting the individual_hash_subparts production. + ExitIndividual_hash_subparts(c *Individual_hash_subpartsContext) + + // ExitHash_subparts_by_quantity is called when exiting the hash_subparts_by_quantity production. + ExitHash_subparts_by_quantity(c *Hash_subparts_by_quantityContext) + + // ExitRange_values_clause is called when exiting the range_values_clause production. + ExitRange_values_clause(c *Range_values_clauseContext) + + // ExitRange_values_list is called when exiting the range_values_list production. + ExitRange_values_list(c *Range_values_listContext) + + // ExitList_values_clause is called when exiting the list_values_clause production. + ExitList_values_clause(c *List_values_clauseContext) + + // ExitTable_partition_description is called when exiting the table_partition_description production. + ExitTable_partition_description(c *Table_partition_descriptionContext) + + // ExitPartitioning_storage_clause is called when exiting the partitioning_storage_clause production. + ExitPartitioning_storage_clause(c *Partitioning_storage_clauseContext) + + // ExitLob_partitioning_storage is called when exiting the lob_partitioning_storage production. + ExitLob_partitioning_storage(c *Lob_partitioning_storageContext) + + // ExitSize_clause is called when exiting the size_clause production. + ExitSize_clause(c *Size_clauseContext) + + // ExitTable_compression is called when exiting the table_compression production. + ExitTable_compression(c *Table_compressionContext) + + // ExitInmemory_table_clause is called when exiting the inmemory_table_clause production. + ExitInmemory_table_clause(c *Inmemory_table_clauseContext) + + // ExitInmemory_attributes is called when exiting the inmemory_attributes production. + ExitInmemory_attributes(c *Inmemory_attributesContext) + + // ExitInmemory_memcompress is called when exiting the inmemory_memcompress production. + ExitInmemory_memcompress(c *Inmemory_memcompressContext) + + // ExitInmemory_priority is called when exiting the inmemory_priority production. + ExitInmemory_priority(c *Inmemory_priorityContext) + + // ExitInmemory_distribute is called when exiting the inmemory_distribute production. + ExitInmemory_distribute(c *Inmemory_distributeContext) + + // ExitInmemory_duplicate is called when exiting the inmemory_duplicate production. + ExitInmemory_duplicate(c *Inmemory_duplicateContext) + + // ExitInmemory_column_clause is called when exiting the inmemory_column_clause production. + ExitInmemory_column_clause(c *Inmemory_column_clauseContext) + + // ExitPhysical_attributes_clause is called when exiting the physical_attributes_clause production. + ExitPhysical_attributes_clause(c *Physical_attributes_clauseContext) + + // ExitStorage_clause is called when exiting the storage_clause production. + ExitStorage_clause(c *Storage_clauseContext) + + // ExitDeferred_segment_creation is called when exiting the deferred_segment_creation production. + ExitDeferred_segment_creation(c *Deferred_segment_creationContext) + + // ExitSegment_attributes_clause is called when exiting the segment_attributes_clause production. + ExitSegment_attributes_clause(c *Segment_attributes_clauseContext) + + // ExitPhysical_properties is called when exiting the physical_properties production. + ExitPhysical_properties(c *Physical_propertiesContext) + + // ExitIlm_clause is called when exiting the ilm_clause production. + ExitIlm_clause(c *Ilm_clauseContext) + + // ExitIlm_policy_clause is called when exiting the ilm_policy_clause production. + ExitIlm_policy_clause(c *Ilm_policy_clauseContext) + + // ExitIlm_compression_policy is called when exiting the ilm_compression_policy production. + ExitIlm_compression_policy(c *Ilm_compression_policyContext) + + // ExitIlm_tiering_policy is called when exiting the ilm_tiering_policy production. + ExitIlm_tiering_policy(c *Ilm_tiering_policyContext) + + // ExitIlm_after_on is called when exiting the ilm_after_on production. + ExitIlm_after_on(c *Ilm_after_onContext) + + // ExitSegment_group is called when exiting the segment_group production. + ExitSegment_group(c *Segment_groupContext) + + // ExitIlm_inmemory_policy is called when exiting the ilm_inmemory_policy production. + ExitIlm_inmemory_policy(c *Ilm_inmemory_policyContext) + + // ExitIlm_time_period is called when exiting the ilm_time_period production. + ExitIlm_time_period(c *Ilm_time_periodContext) + + // ExitHeap_org_table_clause is called when exiting the heap_org_table_clause production. + ExitHeap_org_table_clause(c *Heap_org_table_clauseContext) + + // ExitExternal_table_clause is called when exiting the external_table_clause production. + ExitExternal_table_clause(c *External_table_clauseContext) + + // ExitAccess_driver_type is called when exiting the access_driver_type production. + ExitAccess_driver_type(c *Access_driver_typeContext) + + // ExitExternal_table_data_props is called when exiting the external_table_data_props production. + ExitExternal_table_data_props(c *External_table_data_propsContext) + + // ExitExternal_table_data_format is called when exiting the external_table_data_format production. + ExitExternal_table_data_format(c *External_table_data_formatContext) + + // ExitExternal_table_transform is called when exiting the external_table_transform production. + ExitExternal_table_transform(c *External_table_transformContext) + + // ExitExternal_table_field is called when exiting the external_table_field production. + ExitExternal_table_field(c *External_table_fieldContext) + + // ExitExternal_table_field_list is called when exiting the external_table_field_list production. + ExitExternal_table_field_list(c *External_table_field_listContext) + + // ExitExternal_table_fields_clause is called when exiting the external_table_fields_clause production. + ExitExternal_table_fields_clause(c *External_table_fields_clauseContext) + + // ExitExternal_table_position_clause is called when exiting the external_table_position_clause production. + ExitExternal_table_position_clause(c *External_table_position_clauseContext) + + // ExitExternal_table_datatype_clause is called when exiting the external_table_datatype_clause production. + ExitExternal_table_datatype_clause(c *External_table_datatype_clauseContext) + + // ExitExternal_table_delimit_clause is called when exiting the external_table_delimit_clause production. + ExitExternal_table_delimit_clause(c *External_table_delimit_clauseContext) + + // ExitExternal_table_trim_clause is called when exiting the external_table_trim_clause production. + ExitExternal_table_trim_clause(c *External_table_trim_clauseContext) + + // ExitExternal_table_date_format_clause is called when exiting the external_table_date_format_clause production. + ExitExternal_table_date_format_clause(c *External_table_date_format_clauseContext) + + // ExitExternal_table_init_clause is called when exiting the external_table_init_clause production. + ExitExternal_table_init_clause(c *External_table_init_clauseContext) + + // ExitExternal_table_condition_clause is called when exiting the external_table_condition_clause production. + ExitExternal_table_condition_clause(c *External_table_condition_clauseContext) + + // ExitExternal_table_lls_clause is called when exiting the external_table_lls_clause production. + ExitExternal_table_lls_clause(c *External_table_lls_clauseContext) + + // ExitExternal_table_records is called when exiting the external_table_records production. + ExitExternal_table_records(c *External_table_recordsContext) + + // ExitExternal_table_record_options_clause is called when exiting the external_table_record_options_clause production. + ExitExternal_table_record_options_clause(c *External_table_record_options_clauseContext) + + // ExitExternal_table_output_files is called when exiting the external_table_output_files production. + ExitExternal_table_output_files(c *External_table_output_filesContext) + + // ExitExternal_table_fields is called when exiting the external_table_fields production. + ExitExternal_table_fields(c *External_table_fieldsContext) + + // ExitExternal_table_datapump is called when exiting the external_table_datapump production. + ExitExternal_table_datapump(c *External_table_datapumpContext) + + // ExitExternal_table_hive is called when exiting the external_table_hive production. + ExitExternal_table_hive(c *External_table_hiveContext) + + // ExitExternal_table_hive_parameter_map is called when exiting the external_table_hive_parameter_map production. + ExitExternal_table_hive_parameter_map(c *External_table_hive_parameter_mapContext) + + // ExitExternal_table_hive_parameter_map_entry is called when exiting the external_table_hive_parameter_map_entry production. + ExitExternal_table_hive_parameter_map_entry(c *External_table_hive_parameter_map_entryContext) + + // ExitExternal_table_directory is called when exiting the external_table_directory production. + ExitExternal_table_directory(c *External_table_directoryContext) + + // ExitRow_movement_clause is called when exiting the row_movement_clause production. + ExitRow_movement_clause(c *Row_movement_clauseContext) + + // ExitFlashback_archive_clause is called when exiting the flashback_archive_clause production. + ExitFlashback_archive_clause(c *Flashback_archive_clauseContext) + + // ExitLog_grp is called when exiting the log_grp production. + ExitLog_grp(c *Log_grpContext) + + // ExitSupplemental_table_logging is called when exiting the supplemental_table_logging production. + ExitSupplemental_table_logging(c *Supplemental_table_loggingContext) + + // ExitSupplemental_log_grp_clause is called when exiting the supplemental_log_grp_clause production. + ExitSupplemental_log_grp_clause(c *Supplemental_log_grp_clauseContext) + + // ExitSupplemental_id_key_clause is called when exiting the supplemental_id_key_clause production. + ExitSupplemental_id_key_clause(c *Supplemental_id_key_clauseContext) + + // ExitAllocate_extent_clause is called when exiting the allocate_extent_clause production. + ExitAllocate_extent_clause(c *Allocate_extent_clauseContext) + + // ExitDeallocate_unused_clause is called when exiting the deallocate_unused_clause production. + ExitDeallocate_unused_clause(c *Deallocate_unused_clauseContext) + + // ExitShrink_clause is called when exiting the shrink_clause production. + ExitShrink_clause(c *Shrink_clauseContext) + + // ExitRecords_per_block_clause is called when exiting the records_per_block_clause production. + ExitRecords_per_block_clause(c *Records_per_block_clauseContext) + + // ExitUpgrade_table_clause is called when exiting the upgrade_table_clause production. + ExitUpgrade_table_clause(c *Upgrade_table_clauseContext) + + // ExitTruncate_table is called when exiting the truncate_table production. + ExitTruncate_table(c *Truncate_tableContext) + + // ExitDrop_table is called when exiting the drop_table production. + ExitDrop_table(c *Drop_tableContext) + + // ExitDrop_tablespace is called when exiting the drop_tablespace production. + ExitDrop_tablespace(c *Drop_tablespaceContext) + + // ExitDrop_tablespace_set is called when exiting the drop_tablespace_set production. + ExitDrop_tablespace_set(c *Drop_tablespace_setContext) + + // ExitIncluding_contents_clause is called when exiting the including_contents_clause production. + ExitIncluding_contents_clause(c *Including_contents_clauseContext) + + // ExitDrop_view is called when exiting the drop_view production. + ExitDrop_view(c *Drop_viewContext) + + // ExitComment_on_column is called when exiting the comment_on_column production. + ExitComment_on_column(c *Comment_on_columnContext) + + // ExitEnable_or_disable is called when exiting the enable_or_disable production. + ExitEnable_or_disable(c *Enable_or_disableContext) + + // ExitAllow_or_disallow is called when exiting the allow_or_disallow production. + ExitAllow_or_disallow(c *Allow_or_disallowContext) + + // ExitAlter_synonym is called when exiting the alter_synonym production. + ExitAlter_synonym(c *Alter_synonymContext) + + // ExitCreate_synonym is called when exiting the create_synonym production. + ExitCreate_synonym(c *Create_synonymContext) + + // ExitDrop_synonym is called when exiting the drop_synonym production. + ExitDrop_synonym(c *Drop_synonymContext) + + // ExitCreate_spfile is called when exiting the create_spfile production. + ExitCreate_spfile(c *Create_spfileContext) + + // ExitSpfile_name is called when exiting the spfile_name production. + ExitSpfile_name(c *Spfile_nameContext) + + // ExitPfile_name is called when exiting the pfile_name production. + ExitPfile_name(c *Pfile_nameContext) + + // ExitComment_on_table is called when exiting the comment_on_table production. + ExitComment_on_table(c *Comment_on_tableContext) + + // ExitComment_on_materialized is called when exiting the comment_on_materialized production. + ExitComment_on_materialized(c *Comment_on_materializedContext) + + // ExitAlter_analytic_view is called when exiting the alter_analytic_view production. + ExitAlter_analytic_view(c *Alter_analytic_viewContext) + + // ExitAlter_add_cache_clause is called when exiting the alter_add_cache_clause production. + ExitAlter_add_cache_clause(c *Alter_add_cache_clauseContext) + + // ExitLevels_item is called when exiting the levels_item production. + ExitLevels_item(c *Levels_itemContext) + + // ExitMeasure_list is called when exiting the measure_list production. + ExitMeasure_list(c *Measure_listContext) + + // ExitAlter_drop_cache_clause is called when exiting the alter_drop_cache_clause production. + ExitAlter_drop_cache_clause(c *Alter_drop_cache_clauseContext) + + // ExitAlter_attribute_dimension is called when exiting the alter_attribute_dimension production. + ExitAlter_attribute_dimension(c *Alter_attribute_dimensionContext) + + // ExitAlter_audit_policy is called when exiting the alter_audit_policy production. + ExitAlter_audit_policy(c *Alter_audit_policyContext) + + // ExitAlter_cluster is called when exiting the alter_cluster production. + ExitAlter_cluster(c *Alter_clusterContext) + + // ExitDrop_analytic_view is called when exiting the drop_analytic_view production. + ExitDrop_analytic_view(c *Drop_analytic_viewContext) + + // ExitDrop_attribute_dimension is called when exiting the drop_attribute_dimension production. + ExitDrop_attribute_dimension(c *Drop_attribute_dimensionContext) + + // ExitDrop_audit_policy is called when exiting the drop_audit_policy production. + ExitDrop_audit_policy(c *Drop_audit_policyContext) + + // ExitDrop_flashback_archive is called when exiting the drop_flashback_archive production. + ExitDrop_flashback_archive(c *Drop_flashback_archiveContext) + + // ExitDrop_cluster is called when exiting the drop_cluster production. + ExitDrop_cluster(c *Drop_clusterContext) + + // ExitDrop_context is called when exiting the drop_context production. + ExitDrop_context(c *Drop_contextContext) + + // ExitDrop_directory is called when exiting the drop_directory production. + ExitDrop_directory(c *Drop_directoryContext) + + // ExitDrop_diskgroup is called when exiting the drop_diskgroup production. + ExitDrop_diskgroup(c *Drop_diskgroupContext) + + // ExitDrop_edition is called when exiting the drop_edition production. + ExitDrop_edition(c *Drop_editionContext) + + // ExitTruncate_cluster is called when exiting the truncate_cluster production. + ExitTruncate_cluster(c *Truncate_clusterContext) + + // ExitCache_or_nocache is called when exiting the cache_or_nocache production. + ExitCache_or_nocache(c *Cache_or_nocacheContext) + + // ExitDatabase_name is called when exiting the database_name production. + ExitDatabase_name(c *Database_nameContext) + + // ExitAlter_database is called when exiting the alter_database production. + ExitAlter_database(c *Alter_databaseContext) + + // ExitDatabase_clause is called when exiting the database_clause production. + ExitDatabase_clause(c *Database_clauseContext) + + // ExitStartup_clauses is called when exiting the startup_clauses production. + ExitStartup_clauses(c *Startup_clausesContext) + + // ExitResetlogs_or_noresetlogs is called when exiting the resetlogs_or_noresetlogs production. + ExitResetlogs_or_noresetlogs(c *Resetlogs_or_noresetlogsContext) + + // ExitUpgrade_or_downgrade is called when exiting the upgrade_or_downgrade production. + ExitUpgrade_or_downgrade(c *Upgrade_or_downgradeContext) + + // ExitRecovery_clauses is called when exiting the recovery_clauses production. + ExitRecovery_clauses(c *Recovery_clausesContext) + + // ExitBegin_or_end is called when exiting the begin_or_end production. + ExitBegin_or_end(c *Begin_or_endContext) + + // ExitGeneral_recovery is called when exiting the general_recovery production. + ExitGeneral_recovery(c *General_recoveryContext) + + // ExitFull_database_recovery is called when exiting the full_database_recovery production. + ExitFull_database_recovery(c *Full_database_recoveryContext) + + // ExitPartial_database_recovery is called when exiting the partial_database_recovery production. + ExitPartial_database_recovery(c *Partial_database_recoveryContext) + + // ExitPartial_database_recovery_10g is called when exiting the partial_database_recovery_10g production. + ExitPartial_database_recovery_10g(c *Partial_database_recovery_10gContext) + + // ExitManaged_standby_recovery is called when exiting the managed_standby_recovery production. + ExitManaged_standby_recovery(c *Managed_standby_recoveryContext) + + // ExitDb_name is called when exiting the db_name production. + ExitDb_name(c *Db_nameContext) + + // ExitDatabase_file_clauses is called when exiting the database_file_clauses production. + ExitDatabase_file_clauses(c *Database_file_clausesContext) + + // ExitCreate_datafile_clause is called when exiting the create_datafile_clause production. + ExitCreate_datafile_clause(c *Create_datafile_clauseContext) + + // ExitAlter_datafile_clause is called when exiting the alter_datafile_clause production. + ExitAlter_datafile_clause(c *Alter_datafile_clauseContext) + + // ExitAlter_tempfile_clause is called when exiting the alter_tempfile_clause production. + ExitAlter_tempfile_clause(c *Alter_tempfile_clauseContext) + + // ExitMove_datafile_clause is called when exiting the move_datafile_clause production. + ExitMove_datafile_clause(c *Move_datafile_clauseContext) + + // ExitLogfile_clauses is called when exiting the logfile_clauses production. + ExitLogfile_clauses(c *Logfile_clausesContext) + + // ExitAdd_logfile_clauses is called when exiting the add_logfile_clauses production. + ExitAdd_logfile_clauses(c *Add_logfile_clausesContext) + + // ExitGroup_redo_logfile is called when exiting the group_redo_logfile production. + ExitGroup_redo_logfile(c *Group_redo_logfileContext) + + // ExitDrop_logfile_clauses is called when exiting the drop_logfile_clauses production. + ExitDrop_logfile_clauses(c *Drop_logfile_clausesContext) + + // ExitSwitch_logfile_clause is called when exiting the switch_logfile_clause production. + ExitSwitch_logfile_clause(c *Switch_logfile_clauseContext) + + // ExitSupplemental_db_logging is called when exiting the supplemental_db_logging production. + ExitSupplemental_db_logging(c *Supplemental_db_loggingContext) + + // ExitAdd_or_drop is called when exiting the add_or_drop production. + ExitAdd_or_drop(c *Add_or_dropContext) + + // ExitSupplemental_plsql_clause is called when exiting the supplemental_plsql_clause production. + ExitSupplemental_plsql_clause(c *Supplemental_plsql_clauseContext) + + // ExitLogfile_descriptor is called when exiting the logfile_descriptor production. + ExitLogfile_descriptor(c *Logfile_descriptorContext) + + // ExitControlfile_clauses is called when exiting the controlfile_clauses production. + ExitControlfile_clauses(c *Controlfile_clausesContext) + + // ExitTrace_file_clause is called when exiting the trace_file_clause production. + ExitTrace_file_clause(c *Trace_file_clauseContext) + + // ExitStandby_database_clauses is called when exiting the standby_database_clauses production. + ExitStandby_database_clauses(c *Standby_database_clausesContext) + + // ExitActivate_standby_db_clause is called when exiting the activate_standby_db_clause production. + ExitActivate_standby_db_clause(c *Activate_standby_db_clauseContext) + + // ExitMaximize_standby_db_clause is called when exiting the maximize_standby_db_clause production. + ExitMaximize_standby_db_clause(c *Maximize_standby_db_clauseContext) + + // ExitRegister_logfile_clause is called when exiting the register_logfile_clause production. + ExitRegister_logfile_clause(c *Register_logfile_clauseContext) + + // ExitCommit_switchover_clause is called when exiting the commit_switchover_clause production. + ExitCommit_switchover_clause(c *Commit_switchover_clauseContext) + + // ExitStart_standby_clause is called when exiting the start_standby_clause production. + ExitStart_standby_clause(c *Start_standby_clauseContext) + + // ExitStop_standby_clause is called when exiting the stop_standby_clause production. + ExitStop_standby_clause(c *Stop_standby_clauseContext) + + // ExitConvert_database_clause is called when exiting the convert_database_clause production. + ExitConvert_database_clause(c *Convert_database_clauseContext) + + // ExitDefault_settings_clause is called when exiting the default_settings_clause production. + ExitDefault_settings_clause(c *Default_settings_clauseContext) + + // ExitSet_time_zone_clause is called when exiting the set_time_zone_clause production. + ExitSet_time_zone_clause(c *Set_time_zone_clauseContext) + + // ExitInstance_clauses is called when exiting the instance_clauses production. + ExitInstance_clauses(c *Instance_clausesContext) + + // ExitSecurity_clause is called when exiting the security_clause production. + ExitSecurity_clause(c *Security_clauseContext) + + // ExitDomain is called when exiting the domain production. + ExitDomain(c *DomainContext) + + // ExitDatabase is called when exiting the database production. + ExitDatabase(c *DatabaseContext) + + // ExitEdition_name is called when exiting the edition_name production. + ExitEdition_name(c *Edition_nameContext) + + // ExitFilenumber is called when exiting the filenumber production. + ExitFilenumber(c *FilenumberContext) + + // ExitFilename is called when exiting the filename production. + ExitFilename(c *FilenameContext) + + // ExitPrepare_clause is called when exiting the prepare_clause production. + ExitPrepare_clause(c *Prepare_clauseContext) + + // ExitDrop_mirror_clause is called when exiting the drop_mirror_clause production. + ExitDrop_mirror_clause(c *Drop_mirror_clauseContext) + + // ExitLost_write_protection is called when exiting the lost_write_protection production. + ExitLost_write_protection(c *Lost_write_protectionContext) + + // ExitCdb_fleet_clauses is called when exiting the cdb_fleet_clauses production. + ExitCdb_fleet_clauses(c *Cdb_fleet_clausesContext) + + // ExitLead_cdb_clause is called when exiting the lead_cdb_clause production. + ExitLead_cdb_clause(c *Lead_cdb_clauseContext) + + // ExitLead_cdb_uri_clause is called when exiting the lead_cdb_uri_clause production. + ExitLead_cdb_uri_clause(c *Lead_cdb_uri_clauseContext) + + // ExitProperty_clauses is called when exiting the property_clauses production. + ExitProperty_clauses(c *Property_clausesContext) + + // ExitReplay_upgrade_clauses is called when exiting the replay_upgrade_clauses production. + ExitReplay_upgrade_clauses(c *Replay_upgrade_clausesContext) + + // ExitAlter_database_link is called when exiting the alter_database_link production. + ExitAlter_database_link(c *Alter_database_linkContext) + + // ExitPassword_value is called when exiting the password_value production. + ExitPassword_value(c *Password_valueContext) + + // ExitLink_authentication is called when exiting the link_authentication production. + ExitLink_authentication(c *Link_authenticationContext) + + // ExitCreate_schema is called when exiting the create_schema production. + ExitCreate_schema(c *Create_schemaContext) + + // ExitCreate_database is called when exiting the create_database production. + ExitCreate_database(c *Create_databaseContext) + + // ExitDatabase_logging_clauses is called when exiting the database_logging_clauses production. + ExitDatabase_logging_clauses(c *Database_logging_clausesContext) + + // ExitDatabase_logging_sub_clause is called when exiting the database_logging_sub_clause production. + ExitDatabase_logging_sub_clause(c *Database_logging_sub_clauseContext) + + // ExitTablespace_clauses is called when exiting the tablespace_clauses production. + ExitTablespace_clauses(c *Tablespace_clausesContext) + + // ExitEnable_pluggable_database is called when exiting the enable_pluggable_database production. + ExitEnable_pluggable_database(c *Enable_pluggable_databaseContext) + + // ExitFile_name_convert is called when exiting the file_name_convert production. + ExitFile_name_convert(c *File_name_convertContext) + + // ExitFilename_convert_sub_clause is called when exiting the filename_convert_sub_clause production. + ExitFilename_convert_sub_clause(c *Filename_convert_sub_clauseContext) + + // ExitTablespace_datafile_clauses is called when exiting the tablespace_datafile_clauses production. + ExitTablespace_datafile_clauses(c *Tablespace_datafile_clausesContext) + + // ExitUndo_mode_clause is called when exiting the undo_mode_clause production. + ExitUndo_mode_clause(c *Undo_mode_clauseContext) + + // ExitDefault_tablespace is called when exiting the default_tablespace production. + ExitDefault_tablespace(c *Default_tablespaceContext) + + // ExitDefault_temp_tablespace is called when exiting the default_temp_tablespace production. + ExitDefault_temp_tablespace(c *Default_temp_tablespaceContext) + + // ExitUndo_tablespace is called when exiting the undo_tablespace production. + ExitUndo_tablespace(c *Undo_tablespaceContext) + + // ExitDrop_database is called when exiting the drop_database production. + ExitDrop_database(c *Drop_databaseContext) + + // ExitCreate_database_link is called when exiting the create_database_link production. + ExitCreate_database_link(c *Create_database_linkContext) + + // ExitDrop_database_link is called when exiting the drop_database_link production. + ExitDrop_database_link(c *Drop_database_linkContext) + + // ExitAlter_tablespace_set is called when exiting the alter_tablespace_set production. + ExitAlter_tablespace_set(c *Alter_tablespace_setContext) + + // ExitAlter_tablespace_attrs is called when exiting the alter_tablespace_attrs production. + ExitAlter_tablespace_attrs(c *Alter_tablespace_attrsContext) + + // ExitAlter_tablespace_encryption is called when exiting the alter_tablespace_encryption production. + ExitAlter_tablespace_encryption(c *Alter_tablespace_encryptionContext) + + // ExitTs_file_name_convert is called when exiting the ts_file_name_convert production. + ExitTs_file_name_convert(c *Ts_file_name_convertContext) + + // ExitAlter_role is called when exiting the alter_role production. + ExitAlter_role(c *Alter_roleContext) + + // ExitRole_identified_clause is called when exiting the role_identified_clause production. + ExitRole_identified_clause(c *Role_identified_clauseContext) + + // ExitAlter_table is called when exiting the alter_table production. + ExitAlter_table(c *Alter_tableContext) + + // ExitMemoptimize_read_write_clause is called when exiting the memoptimize_read_write_clause production. + ExitMemoptimize_read_write_clause(c *Memoptimize_read_write_clauseContext) + + // ExitAlter_table_properties is called when exiting the alter_table_properties production. + ExitAlter_table_properties(c *Alter_table_propertiesContext) + + // ExitAlter_table_partitioning is called when exiting the alter_table_partitioning production. + ExitAlter_table_partitioning(c *Alter_table_partitioningContext) + + // ExitAdd_table_partition is called when exiting the add_table_partition production. + ExitAdd_table_partition(c *Add_table_partitionContext) + + // ExitDrop_table_partition is called when exiting the drop_table_partition production. + ExitDrop_table_partition(c *Drop_table_partitionContext) + + // ExitMerge_table_partition is called when exiting the merge_table_partition production. + ExitMerge_table_partition(c *Merge_table_partitionContext) + + // ExitModify_table_partition is called when exiting the modify_table_partition production. + ExitModify_table_partition(c *Modify_table_partitionContext) + + // ExitSplit_table_partition is called when exiting the split_table_partition production. + ExitSplit_table_partition(c *Split_table_partitionContext) + + // ExitTruncate_table_partition is called when exiting the truncate_table_partition production. + ExitTruncate_table_partition(c *Truncate_table_partitionContext) + + // ExitExchange_table_partition is called when exiting the exchange_table_partition production. + ExitExchange_table_partition(c *Exchange_table_partitionContext) + + // ExitCoalesce_table_partition is called when exiting the coalesce_table_partition production. + ExitCoalesce_table_partition(c *Coalesce_table_partitionContext) + + // ExitAlter_interval_partition is called when exiting the alter_interval_partition production. + ExitAlter_interval_partition(c *Alter_interval_partitionContext) + + // ExitMove_table_partition is called when exiting the move_table_partition production. + ExitMove_table_partition(c *Move_table_partitionContext) + + // ExitFilter_condition is called when exiting the filter_condition production. + ExitFilter_condition(c *Filter_conditionContext) + + // ExitRename_table_partition is called when exiting the rename_table_partition production. + ExitRename_table_partition(c *Rename_table_partitionContext) + + // ExitPartition_extended_names is called when exiting the partition_extended_names production. + ExitPartition_extended_names(c *Partition_extended_namesContext) + + // ExitSubpartition_extended_names is called when exiting the subpartition_extended_names production. + ExitSubpartition_extended_names(c *Subpartition_extended_namesContext) + + // ExitAlter_table_properties_1 is called when exiting the alter_table_properties_1 production. + ExitAlter_table_properties_1(c *Alter_table_properties_1Context) + + // ExitAlter_iot_clauses is called when exiting the alter_iot_clauses production. + ExitAlter_iot_clauses(c *Alter_iot_clausesContext) + + // ExitAlter_mapping_table_clause is called when exiting the alter_mapping_table_clause production. + ExitAlter_mapping_table_clause(c *Alter_mapping_table_clauseContext) + + // ExitAlter_overflow_clause is called when exiting the alter_overflow_clause production. + ExitAlter_overflow_clause(c *Alter_overflow_clauseContext) + + // ExitAdd_overflow_clause is called when exiting the add_overflow_clause production. + ExitAdd_overflow_clause(c *Add_overflow_clauseContext) + + // ExitUpdate_index_clauses is called when exiting the update_index_clauses production. + ExitUpdate_index_clauses(c *Update_index_clausesContext) + + // ExitUpdate_global_index_clause is called when exiting the update_global_index_clause production. + ExitUpdate_global_index_clause(c *Update_global_index_clauseContext) + + // ExitUpdate_all_indexes_clause is called when exiting the update_all_indexes_clause production. + ExitUpdate_all_indexes_clause(c *Update_all_indexes_clauseContext) + + // ExitUpdate_all_indexes_index_clause is called when exiting the update_all_indexes_index_clause production. + ExitUpdate_all_indexes_index_clause(c *Update_all_indexes_index_clauseContext) + + // ExitUpdate_index_partition is called when exiting the update_index_partition production. + ExitUpdate_index_partition(c *Update_index_partitionContext) + + // ExitUpdate_index_subpartition is called when exiting the update_index_subpartition production. + ExitUpdate_index_subpartition(c *Update_index_subpartitionContext) + + // ExitEnable_disable_clause is called when exiting the enable_disable_clause production. + ExitEnable_disable_clause(c *Enable_disable_clauseContext) + + // ExitUsing_index_clause is called when exiting the using_index_clause production. + ExitUsing_index_clause(c *Using_index_clauseContext) + + // ExitIndex_attributes is called when exiting the index_attributes production. + ExitIndex_attributes(c *Index_attributesContext) + + // ExitSort_or_nosort is called when exiting the sort_or_nosort production. + ExitSort_or_nosort(c *Sort_or_nosortContext) + + // ExitExceptions_clause is called when exiting the exceptions_clause production. + ExitExceptions_clause(c *Exceptions_clauseContext) + + // ExitMove_table_clause is called when exiting the move_table_clause production. + ExitMove_table_clause(c *Move_table_clauseContext) + + // ExitIndex_org_table_clause is called when exiting the index_org_table_clause production. + ExitIndex_org_table_clause(c *Index_org_table_clauseContext) + + // ExitMapping_table_clause is called when exiting the mapping_table_clause production. + ExitMapping_table_clause(c *Mapping_table_clauseContext) + + // ExitKey_compression is called when exiting the key_compression production. + ExitKey_compression(c *Key_compressionContext) + + // ExitIndex_org_overflow_clause is called when exiting the index_org_overflow_clause production. + ExitIndex_org_overflow_clause(c *Index_org_overflow_clauseContext) + + // ExitColumn_clauses is called when exiting the column_clauses production. + ExitColumn_clauses(c *Column_clausesContext) + + // ExitModify_collection_retrieval is called when exiting the modify_collection_retrieval production. + ExitModify_collection_retrieval(c *Modify_collection_retrievalContext) + + // ExitCollection_item is called when exiting the collection_item production. + ExitCollection_item(c *Collection_itemContext) + + // ExitRename_column_clause is called when exiting the rename_column_clause production. + ExitRename_column_clause(c *Rename_column_clauseContext) + + // ExitOld_column_name is called when exiting the old_column_name production. + ExitOld_column_name(c *Old_column_nameContext) + + // ExitNew_column_name is called when exiting the new_column_name production. + ExitNew_column_name(c *New_column_nameContext) + + // ExitAdd_modify_drop_column_clauses is called when exiting the add_modify_drop_column_clauses production. + ExitAdd_modify_drop_column_clauses(c *Add_modify_drop_column_clausesContext) + + // ExitDrop_column_clause is called when exiting the drop_column_clause production. + ExitDrop_column_clause(c *Drop_column_clauseContext) + + // ExitModify_column_clauses is called when exiting the modify_column_clauses production. + ExitModify_column_clauses(c *Modify_column_clausesContext) + + // ExitModify_col_properties is called when exiting the modify_col_properties production. + ExitModify_col_properties(c *Modify_col_propertiesContext) + + // ExitModify_col_visibility is called when exiting the modify_col_visibility production. + ExitModify_col_visibility(c *Modify_col_visibilityContext) + + // ExitModify_col_substitutable is called when exiting the modify_col_substitutable production. + ExitModify_col_substitutable(c *Modify_col_substitutableContext) + + // ExitAdd_column_clause is called when exiting the add_column_clause production. + ExitAdd_column_clause(c *Add_column_clauseContext) + + // ExitVarray_col_properties is called when exiting the varray_col_properties production. + ExitVarray_col_properties(c *Varray_col_propertiesContext) + + // ExitVarray_storage_clause is called when exiting the varray_storage_clause production. + ExitVarray_storage_clause(c *Varray_storage_clauseContext) + + // ExitLob_segname is called when exiting the lob_segname production. + ExitLob_segname(c *Lob_segnameContext) + + // ExitLob_item is called when exiting the lob_item production. + ExitLob_item(c *Lob_itemContext) + + // ExitLob_storage_parameters is called when exiting the lob_storage_parameters production. + ExitLob_storage_parameters(c *Lob_storage_parametersContext) + + // ExitLob_storage_clause is called when exiting the lob_storage_clause production. + ExitLob_storage_clause(c *Lob_storage_clauseContext) + + // ExitModify_lob_storage_clause is called when exiting the modify_lob_storage_clause production. + ExitModify_lob_storage_clause(c *Modify_lob_storage_clauseContext) + + // ExitModify_lob_parameters is called when exiting the modify_lob_parameters production. + ExitModify_lob_parameters(c *Modify_lob_parametersContext) + + // ExitLob_parameters is called when exiting the lob_parameters production. + ExitLob_parameters(c *Lob_parametersContext) + + // ExitLob_deduplicate_clause is called when exiting the lob_deduplicate_clause production. + ExitLob_deduplicate_clause(c *Lob_deduplicate_clauseContext) + + // ExitLob_compression_clause is called when exiting the lob_compression_clause production. + ExitLob_compression_clause(c *Lob_compression_clauseContext) + + // ExitLob_retention_clause is called when exiting the lob_retention_clause production. + ExitLob_retention_clause(c *Lob_retention_clauseContext) + + // ExitEncryption_spec is called when exiting the encryption_spec production. + ExitEncryption_spec(c *Encryption_specContext) + + // ExitTablespace is called when exiting the tablespace production. + ExitTablespace(c *TablespaceContext) + + // ExitVarray_item is called when exiting the varray_item production. + ExitVarray_item(c *Varray_itemContext) + + // ExitColumn_properties is called when exiting the column_properties production. + ExitColumn_properties(c *Column_propertiesContext) + + // ExitLob_partition_storage is called when exiting the lob_partition_storage production. + ExitLob_partition_storage(c *Lob_partition_storageContext) + + // ExitPeriod_definition is called when exiting the period_definition production. + ExitPeriod_definition(c *Period_definitionContext) + + // ExitStart_time_column is called when exiting the start_time_column production. + ExitStart_time_column(c *Start_time_columnContext) + + // ExitEnd_time_column is called when exiting the end_time_column production. + ExitEnd_time_column(c *End_time_columnContext) + + // ExitColumn_definition is called when exiting the column_definition production. + ExitColumn_definition(c *Column_definitionContext) + + // ExitColumn_collation_name is called when exiting the column_collation_name production. + ExitColumn_collation_name(c *Column_collation_nameContext) + + // ExitIdentity_clause is called when exiting the identity_clause production. + ExitIdentity_clause(c *Identity_clauseContext) + + // ExitIdentity_options_parentheses is called when exiting the identity_options_parentheses production. + ExitIdentity_options_parentheses(c *Identity_options_parenthesesContext) + + // ExitIdentity_options is called when exiting the identity_options production. + ExitIdentity_options(c *Identity_optionsContext) + + // ExitVirtual_column_definition is called when exiting the virtual_column_definition production. + ExitVirtual_column_definition(c *Virtual_column_definitionContext) + + // ExitVirtual_column_expression is called when exiting the virtual_column_expression production. + ExitVirtual_column_expression(c *Virtual_column_expressionContext) + + // ExitAutogenerated_sequence_definition is called when exiting the autogenerated_sequence_definition production. + ExitAutogenerated_sequence_definition(c *Autogenerated_sequence_definitionContext) + + // ExitBy_user_for_statistics_clause is called when exiting the by_user_for_statistics_clause production. + ExitBy_user_for_statistics_clause(c *By_user_for_statistics_clauseContext) + + // ExitEvaluation_edition_clause is called when exiting the evaluation_edition_clause production. + ExitEvaluation_edition_clause(c *Evaluation_edition_clauseContext) + + // ExitNested_table_col_properties is called when exiting the nested_table_col_properties production. + ExitNested_table_col_properties(c *Nested_table_col_propertiesContext) + + // ExitNested_item is called when exiting the nested_item production. + ExitNested_item(c *Nested_itemContext) + + // ExitSubstitutable_column_clause is called when exiting the substitutable_column_clause production. + ExitSubstitutable_column_clause(c *Substitutable_column_clauseContext) + + // ExitPartition_name is called when exiting the partition_name production. + ExitPartition_name(c *Partition_nameContext) + + // ExitSupplemental_logging_props is called when exiting the supplemental_logging_props production. + ExitSupplemental_logging_props(c *Supplemental_logging_propsContext) + + // ExitObject_type_col_properties is called when exiting the object_type_col_properties production. + ExitObject_type_col_properties(c *Object_type_col_propertiesContext) + + // ExitConstraint_clauses is called when exiting the constraint_clauses production. + ExitConstraint_clauses(c *Constraint_clausesContext) + + // ExitOld_constraint_name is called when exiting the old_constraint_name production. + ExitOld_constraint_name(c *Old_constraint_nameContext) + + // ExitNew_constraint_name is called when exiting the new_constraint_name production. + ExitNew_constraint_name(c *New_constraint_nameContext) + + // ExitDrop_constraint_clause is called when exiting the drop_constraint_clause production. + ExitDrop_constraint_clause(c *Drop_constraint_clauseContext) + + // ExitCheck_constraint is called when exiting the check_constraint production. + ExitCheck_constraint(c *Check_constraintContext) + + // ExitForeign_key_clause is called when exiting the foreign_key_clause production. + ExitForeign_key_clause(c *Foreign_key_clauseContext) + + // ExitReferences_clause is called when exiting the references_clause production. + ExitReferences_clause(c *References_clauseContext) + + // ExitOn_delete_clause is called when exiting the on_delete_clause production. + ExitOn_delete_clause(c *On_delete_clauseContext) + + // ExitAnonymous_block is called when exiting the anonymous_block production. + ExitAnonymous_block(c *Anonymous_blockContext) + + // ExitInvoker_rights_clause is called when exiting the invoker_rights_clause production. + ExitInvoker_rights_clause(c *Invoker_rights_clauseContext) + + // ExitCall_spec is called when exiting the call_spec production. + ExitCall_spec(c *Call_specContext) + + // ExitJava_spec is called when exiting the java_spec production. + ExitJava_spec(c *Java_specContext) + + // ExitC_spec is called when exiting the c_spec production. + ExitC_spec(c *C_specContext) + + // ExitC_agent_in_clause is called when exiting the c_agent_in_clause production. + ExitC_agent_in_clause(c *C_agent_in_clauseContext) + + // ExitC_parameters_clause is called when exiting the c_parameters_clause production. + ExitC_parameters_clause(c *C_parameters_clauseContext) + + // ExitC_external_parameter is called when exiting the c_external_parameter production. + ExitC_external_parameter(c *C_external_parameterContext) + + // ExitC_property is called when exiting the c_property production. + ExitC_property(c *C_propertyContext) + + // ExitParameter is called when exiting the parameter production. + ExitParameter(c *ParameterContext) + + // ExitDefault_value_part is called when exiting the default_value_part production. + ExitDefault_value_part(c *Default_value_partContext) + + // ExitSeq_of_declare_specs is called when exiting the seq_of_declare_specs production. + ExitSeq_of_declare_specs(c *Seq_of_declare_specsContext) + + // ExitDeclare_spec is called when exiting the declare_spec production. + ExitDeclare_spec(c *Declare_specContext) + + // ExitVariable_declaration is called when exiting the variable_declaration production. + ExitVariable_declaration(c *Variable_declarationContext) + + // ExitSubtype_declaration is called when exiting the subtype_declaration production. + ExitSubtype_declaration(c *Subtype_declarationContext) + + // ExitCursor_declaration is called when exiting the cursor_declaration production. + ExitCursor_declaration(c *Cursor_declarationContext) + + // ExitParameter_spec is called when exiting the parameter_spec production. + ExitParameter_spec(c *Parameter_specContext) + + // ExitException_declaration is called when exiting the exception_declaration production. + ExitException_declaration(c *Exception_declarationContext) + + // ExitPragma_declaration is called when exiting the pragma_declaration production. + ExitPragma_declaration(c *Pragma_declarationContext) + + // ExitRecord_type_def is called when exiting the record_type_def production. + ExitRecord_type_def(c *Record_type_defContext) + + // ExitField_spec is called when exiting the field_spec production. + ExitField_spec(c *Field_specContext) + + // ExitRef_cursor_type_def is called when exiting the ref_cursor_type_def production. + ExitRef_cursor_type_def(c *Ref_cursor_type_defContext) + + // ExitType_declaration is called when exiting the type_declaration production. + ExitType_declaration(c *Type_declarationContext) + + // ExitTable_type_def is called when exiting the table_type_def production. + ExitTable_type_def(c *Table_type_defContext) + + // ExitTable_indexed_by_part is called when exiting the table_indexed_by_part production. + ExitTable_indexed_by_part(c *Table_indexed_by_partContext) + + // ExitVarray_type_def is called when exiting the varray_type_def production. + ExitVarray_type_def(c *Varray_type_defContext) + + // ExitSeq_of_statements is called when exiting the seq_of_statements production. + ExitSeq_of_statements(c *Seq_of_statementsContext) + + // ExitLabel_declaration is called when exiting the label_declaration production. + ExitLabel_declaration(c *Label_declarationContext) + + // ExitStatement is called when exiting the statement production. + ExitStatement(c *StatementContext) + + // ExitAssignment_statement is called when exiting the assignment_statement production. + ExitAssignment_statement(c *Assignment_statementContext) + + // ExitContinue_statement is called when exiting the continue_statement production. + ExitContinue_statement(c *Continue_statementContext) + + // ExitExit_statement is called when exiting the exit_statement production. + ExitExit_statement(c *Exit_statementContext) + + // ExitGoto_statement is called when exiting the goto_statement production. + ExitGoto_statement(c *Goto_statementContext) + + // ExitIf_statement is called when exiting the if_statement production. + ExitIf_statement(c *If_statementContext) + + // ExitElsif_part is called when exiting the elsif_part production. + ExitElsif_part(c *Elsif_partContext) + + // ExitElse_part is called when exiting the else_part production. + ExitElse_part(c *Else_partContext) + + // ExitLoop_statement is called when exiting the loop_statement production. + ExitLoop_statement(c *Loop_statementContext) + + // ExitCursor_loop_param is called when exiting the cursor_loop_param production. + ExitCursor_loop_param(c *Cursor_loop_paramContext) + + // ExitForall_statement is called when exiting the forall_statement production. + ExitForall_statement(c *Forall_statementContext) + + // ExitBounds_clause is called when exiting the bounds_clause production. + ExitBounds_clause(c *Bounds_clauseContext) + + // ExitBetween_bound is called when exiting the between_bound production. + ExitBetween_bound(c *Between_boundContext) + + // ExitLower_bound is called when exiting the lower_bound production. + ExitLower_bound(c *Lower_boundContext) + + // ExitUpper_bound is called when exiting the upper_bound production. + ExitUpper_bound(c *Upper_boundContext) + + // ExitNull_statement is called when exiting the null_statement production. + ExitNull_statement(c *Null_statementContext) + + // ExitRaise_statement is called when exiting the raise_statement production. + ExitRaise_statement(c *Raise_statementContext) + + // ExitReturn_statement is called when exiting the return_statement production. + ExitReturn_statement(c *Return_statementContext) + + // ExitCall_statement is called when exiting the call_statement production. + ExitCall_statement(c *Call_statementContext) + + // ExitPipe_row_statement is called when exiting the pipe_row_statement production. + ExitPipe_row_statement(c *Pipe_row_statementContext) + + // ExitSelection_directive is called when exiting the selection_directive production. + ExitSelection_directive(c *Selection_directiveContext) + + // ExitError_directive is called when exiting the error_directive production. + ExitError_directive(c *Error_directiveContext) + + // ExitSelection_directive_body is called when exiting the selection_directive_body production. + ExitSelection_directive_body(c *Selection_directive_bodyContext) + + // ExitBody is called when exiting the body production. + ExitBody(c *BodyContext) + + // ExitException_handler is called when exiting the exception_handler production. + ExitException_handler(c *Exception_handlerContext) + + // ExitTrigger_block is called when exiting the trigger_block production. + ExitTrigger_block(c *Trigger_blockContext) + + // ExitTps_block is called when exiting the tps_block production. + ExitTps_block(c *Tps_blockContext) + + // ExitBlock is called when exiting the block production. + ExitBlock(c *BlockContext) + + // ExitSql_statement is called when exiting the sql_statement production. + ExitSql_statement(c *Sql_statementContext) + + // ExitExecute_immediate is called when exiting the execute_immediate production. + ExitExecute_immediate(c *Execute_immediateContext) + + // ExitDynamic_returning_clause is called when exiting the dynamic_returning_clause production. + ExitDynamic_returning_clause(c *Dynamic_returning_clauseContext) + + // ExitData_manipulation_language_statements is called when exiting the data_manipulation_language_statements production. + ExitData_manipulation_language_statements(c *Data_manipulation_language_statementsContext) + + // ExitCursor_manipulation_statements is called when exiting the cursor_manipulation_statements production. + ExitCursor_manipulation_statements(c *Cursor_manipulation_statementsContext) + + // ExitClose_statement is called when exiting the close_statement production. + ExitClose_statement(c *Close_statementContext) + + // ExitOpen_statement is called when exiting the open_statement production. + ExitOpen_statement(c *Open_statementContext) + + // ExitFetch_statement is called when exiting the fetch_statement production. + ExitFetch_statement(c *Fetch_statementContext) + + // ExitVariable_or_collection is called when exiting the variable_or_collection production. + ExitVariable_or_collection(c *Variable_or_collectionContext) + + // ExitOpen_for_statement is called when exiting the open_for_statement production. + ExitOpen_for_statement(c *Open_for_statementContext) + + // ExitTransaction_control_statements is called when exiting the transaction_control_statements production. + ExitTransaction_control_statements(c *Transaction_control_statementsContext) + + // ExitSet_transaction_command is called when exiting the set_transaction_command production. + ExitSet_transaction_command(c *Set_transaction_commandContext) + + // ExitSet_constraint_command is called when exiting the set_constraint_command production. + ExitSet_constraint_command(c *Set_constraint_commandContext) + + // ExitCommit_statement is called when exiting the commit_statement production. + ExitCommit_statement(c *Commit_statementContext) + + // ExitWrite_clause is called when exiting the write_clause production. + ExitWrite_clause(c *Write_clauseContext) + + // ExitRollback_statement is called when exiting the rollback_statement production. + ExitRollback_statement(c *Rollback_statementContext) + + // ExitSavepoint_statement is called when exiting the savepoint_statement production. + ExitSavepoint_statement(c *Savepoint_statementContext) + + // ExitCollection_method_call is called when exiting the collection_method_call production. + ExitCollection_method_call(c *Collection_method_callContext) + + // ExitExplain_statement is called when exiting the explain_statement production. + ExitExplain_statement(c *Explain_statementContext) + + // ExitSelect_only_statement is called when exiting the select_only_statement production. + ExitSelect_only_statement(c *Select_only_statementContext) + + // ExitSelect_statement is called when exiting the select_statement production. + ExitSelect_statement(c *Select_statementContext) + + // ExitWith_clause is called when exiting the with_clause production. + ExitWith_clause(c *With_clauseContext) + + // ExitWith_factoring_clause is called when exiting the with_factoring_clause production. + ExitWith_factoring_clause(c *With_factoring_clauseContext) + + // ExitSubquery_factoring_clause is called when exiting the subquery_factoring_clause production. + ExitSubquery_factoring_clause(c *Subquery_factoring_clauseContext) + + // ExitSearch_clause is called when exiting the search_clause production. + ExitSearch_clause(c *Search_clauseContext) + + // ExitCycle_clause is called when exiting the cycle_clause production. + ExitCycle_clause(c *Cycle_clauseContext) + + // ExitSubav_factoring_clause is called when exiting the subav_factoring_clause production. + ExitSubav_factoring_clause(c *Subav_factoring_clauseContext) + + // ExitSubav_clause is called when exiting the subav_clause production. + ExitSubav_clause(c *Subav_clauseContext) + + // ExitHierarchies_clause is called when exiting the hierarchies_clause production. + ExitHierarchies_clause(c *Hierarchies_clauseContext) + + // ExitFilter_clauses is called when exiting the filter_clauses production. + ExitFilter_clauses(c *Filter_clausesContext) + + // ExitFilter_clause is called when exiting the filter_clause production. + ExitFilter_clause(c *Filter_clauseContext) + + // ExitAdd_calcs_clause is called when exiting the add_calcs_clause production. + ExitAdd_calcs_clause(c *Add_calcs_clauseContext) + + // ExitAdd_calc_meas_clause is called when exiting the add_calc_meas_clause production. + ExitAdd_calc_meas_clause(c *Add_calc_meas_clauseContext) + + // ExitSubquery is called when exiting the subquery production. + ExitSubquery(c *SubqueryContext) + + // ExitSubquery_basic_elements is called when exiting the subquery_basic_elements production. + ExitSubquery_basic_elements(c *Subquery_basic_elementsContext) + + // ExitSubquery_operation_part is called when exiting the subquery_operation_part production. + ExitSubquery_operation_part(c *Subquery_operation_partContext) + + // ExitQuery_block is called when exiting the query_block production. + ExitQuery_block(c *Query_blockContext) + + // ExitSelected_list is called when exiting the selected_list production. + ExitSelected_list(c *Selected_listContext) + + // ExitFrom_clause is called when exiting the from_clause production. + ExitFrom_clause(c *From_clauseContext) + + // ExitSelect_list_elements is called when exiting the select_list_elements production. + ExitSelect_list_elements(c *Select_list_elementsContext) + + // ExitTable_ref_list is called when exiting the table_ref_list production. + ExitTable_ref_list(c *Table_ref_listContext) + + // ExitTable_ref is called when exiting the table_ref production. + ExitTable_ref(c *Table_refContext) + + // ExitTable_ref_aux is called when exiting the table_ref_aux production. + ExitTable_ref_aux(c *Table_ref_auxContext) + + // ExitTable_ref_aux_internal_one is called when exiting the table_ref_aux_internal_one production. + ExitTable_ref_aux_internal_one(c *Table_ref_aux_internal_oneContext) + + // ExitTable_ref_aux_internal_two is called when exiting the table_ref_aux_internal_two production. + ExitTable_ref_aux_internal_two(c *Table_ref_aux_internal_twoContext) + + // ExitTable_ref_aux_internal_thre is called when exiting the table_ref_aux_internal_thre production. + ExitTable_ref_aux_internal_thre(c *Table_ref_aux_internal_threContext) + + // ExitJoin_clause is called when exiting the join_clause production. + ExitJoin_clause(c *Join_clauseContext) + + // ExitJoin_on_part is called when exiting the join_on_part production. + ExitJoin_on_part(c *Join_on_partContext) + + // ExitJoin_using_part is called when exiting the join_using_part production. + ExitJoin_using_part(c *Join_using_partContext) + + // ExitOuter_join_type is called when exiting the outer_join_type production. + ExitOuter_join_type(c *Outer_join_typeContext) + + // ExitQuery_partition_clause is called when exiting the query_partition_clause production. + ExitQuery_partition_clause(c *Query_partition_clauseContext) + + // ExitFlashback_query_clause is called when exiting the flashback_query_clause production. + ExitFlashback_query_clause(c *Flashback_query_clauseContext) + + // ExitPivot_clause is called when exiting the pivot_clause production. + ExitPivot_clause(c *Pivot_clauseContext) + + // ExitPivot_element is called when exiting the pivot_element production. + ExitPivot_element(c *Pivot_elementContext) + + // ExitPivot_for_clause is called when exiting the pivot_for_clause production. + ExitPivot_for_clause(c *Pivot_for_clauseContext) + + // ExitPivot_in_clause is called when exiting the pivot_in_clause production. + ExitPivot_in_clause(c *Pivot_in_clauseContext) + + // ExitPivot_in_clause_element is called when exiting the pivot_in_clause_element production. + ExitPivot_in_clause_element(c *Pivot_in_clause_elementContext) + + // ExitPivot_in_clause_elements is called when exiting the pivot_in_clause_elements production. + ExitPivot_in_clause_elements(c *Pivot_in_clause_elementsContext) + + // ExitUnpivot_clause is called when exiting the unpivot_clause production. + ExitUnpivot_clause(c *Unpivot_clauseContext) + + // ExitUnpivot_in_clause is called when exiting the unpivot_in_clause production. + ExitUnpivot_in_clause(c *Unpivot_in_clauseContext) + + // ExitUnpivot_in_elements is called when exiting the unpivot_in_elements production. + ExitUnpivot_in_elements(c *Unpivot_in_elementsContext) + + // ExitHierarchical_query_clause is called when exiting the hierarchical_query_clause production. + ExitHierarchical_query_clause(c *Hierarchical_query_clauseContext) + + // ExitStart_part is called when exiting the start_part production. + ExitStart_part(c *Start_partContext) + + // ExitGroup_by_clause is called when exiting the group_by_clause production. + ExitGroup_by_clause(c *Group_by_clauseContext) + + // ExitGroup_by_elements is called when exiting the group_by_elements production. + ExitGroup_by_elements(c *Group_by_elementsContext) + + // ExitRollup_cube_clause is called when exiting the rollup_cube_clause production. + ExitRollup_cube_clause(c *Rollup_cube_clauseContext) + + // ExitGrouping_sets_clause is called when exiting the grouping_sets_clause production. + ExitGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // ExitGrouping_sets_elements is called when exiting the grouping_sets_elements production. + ExitGrouping_sets_elements(c *Grouping_sets_elementsContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitModel_clause is called when exiting the model_clause production. + ExitModel_clause(c *Model_clauseContext) + + // ExitCell_reference_options is called when exiting the cell_reference_options production. + ExitCell_reference_options(c *Cell_reference_optionsContext) + + // ExitReturn_rows_clause is called when exiting the return_rows_clause production. + ExitReturn_rows_clause(c *Return_rows_clauseContext) + + // ExitReference_model is called when exiting the reference_model production. + ExitReference_model(c *Reference_modelContext) + + // ExitMain_model is called when exiting the main_model production. + ExitMain_model(c *Main_modelContext) + + // ExitModel_column_clauses is called when exiting the model_column_clauses production. + ExitModel_column_clauses(c *Model_column_clausesContext) + + // ExitModel_column_partition_part is called when exiting the model_column_partition_part production. + ExitModel_column_partition_part(c *Model_column_partition_partContext) + + // ExitModel_column_list is called when exiting the model_column_list production. + ExitModel_column_list(c *Model_column_listContext) + + // ExitModel_column is called when exiting the model_column production. + ExitModel_column(c *Model_columnContext) + + // ExitModel_rules_clause is called when exiting the model_rules_clause production. + ExitModel_rules_clause(c *Model_rules_clauseContext) + + // ExitModel_rules_part is called when exiting the model_rules_part production. + ExitModel_rules_part(c *Model_rules_partContext) + + // ExitModel_rules_element is called when exiting the model_rules_element production. + ExitModel_rules_element(c *Model_rules_elementContext) + + // ExitCell_assignment is called when exiting the cell_assignment production. + ExitCell_assignment(c *Cell_assignmentContext) + + // ExitModel_iterate_clause is called when exiting the model_iterate_clause production. + ExitModel_iterate_clause(c *Model_iterate_clauseContext) + + // ExitUntil_part is called when exiting the until_part production. + ExitUntil_part(c *Until_partContext) + + // ExitOrder_by_clause is called when exiting the order_by_clause production. + ExitOrder_by_clause(c *Order_by_clauseContext) + + // ExitOrder_by_elements is called when exiting the order_by_elements production. + ExitOrder_by_elements(c *Order_by_elementsContext) + + // ExitOffset_clause is called when exiting the offset_clause production. + ExitOffset_clause(c *Offset_clauseContext) + + // ExitFetch_clause is called when exiting the fetch_clause production. + ExitFetch_clause(c *Fetch_clauseContext) + + // ExitFor_update_clause is called when exiting the for_update_clause production. + ExitFor_update_clause(c *For_update_clauseContext) + + // ExitFor_update_of_part is called when exiting the for_update_of_part production. + ExitFor_update_of_part(c *For_update_of_partContext) + + // ExitFor_update_options is called when exiting the for_update_options production. + ExitFor_update_options(c *For_update_optionsContext) + + // ExitUpdate_statement is called when exiting the update_statement production. + ExitUpdate_statement(c *Update_statementContext) + + // ExitUpdate_set_clause is called when exiting the update_set_clause production. + ExitUpdate_set_clause(c *Update_set_clauseContext) + + // ExitColumn_based_update_set_clause is called when exiting the column_based_update_set_clause production. + ExitColumn_based_update_set_clause(c *Column_based_update_set_clauseContext) + + // ExitDelete_statement is called when exiting the delete_statement production. + ExitDelete_statement(c *Delete_statementContext) + + // ExitInsert_statement is called when exiting the insert_statement production. + ExitInsert_statement(c *Insert_statementContext) + + // ExitSingle_table_insert is called when exiting the single_table_insert production. + ExitSingle_table_insert(c *Single_table_insertContext) + + // ExitMulti_table_insert is called when exiting the multi_table_insert production. + ExitMulti_table_insert(c *Multi_table_insertContext) + + // ExitMulti_table_element is called when exiting the multi_table_element production. + ExitMulti_table_element(c *Multi_table_elementContext) + + // ExitConditional_insert_clause is called when exiting the conditional_insert_clause production. + ExitConditional_insert_clause(c *Conditional_insert_clauseContext) + + // ExitConditional_insert_when_part is called when exiting the conditional_insert_when_part production. + ExitConditional_insert_when_part(c *Conditional_insert_when_partContext) + + // ExitConditional_insert_else_part is called when exiting the conditional_insert_else_part production. + ExitConditional_insert_else_part(c *Conditional_insert_else_partContext) + + // ExitInsert_into_clause is called when exiting the insert_into_clause production. + ExitInsert_into_clause(c *Insert_into_clauseContext) + + // ExitValues_clause is called when exiting the values_clause production. + ExitValues_clause(c *Values_clauseContext) + + // ExitMerge_statement is called when exiting the merge_statement production. + ExitMerge_statement(c *Merge_statementContext) + + // ExitMerge_update_clause is called when exiting the merge_update_clause production. + ExitMerge_update_clause(c *Merge_update_clauseContext) + + // ExitMerge_element is called when exiting the merge_element production. + ExitMerge_element(c *Merge_elementContext) + + // ExitMerge_update_delete_part is called when exiting the merge_update_delete_part production. + ExitMerge_update_delete_part(c *Merge_update_delete_partContext) + + // ExitMerge_insert_clause is called when exiting the merge_insert_clause production. + ExitMerge_insert_clause(c *Merge_insert_clauseContext) + + // ExitSelected_tableview is called when exiting the selected_tableview production. + ExitSelected_tableview(c *Selected_tableviewContext) + + // ExitLock_table_statement is called when exiting the lock_table_statement production. + ExitLock_table_statement(c *Lock_table_statementContext) + + // ExitWait_nowait_part is called when exiting the wait_nowait_part production. + ExitWait_nowait_part(c *Wait_nowait_partContext) + + // ExitLock_table_element is called when exiting the lock_table_element production. + ExitLock_table_element(c *Lock_table_elementContext) + + // ExitLock_mode is called when exiting the lock_mode production. + ExitLock_mode(c *Lock_modeContext) + + // ExitGeneral_table_ref is called when exiting the general_table_ref production. + ExitGeneral_table_ref(c *General_table_refContext) + + // ExitStatic_returning_clause is called when exiting the static_returning_clause production. + ExitStatic_returning_clause(c *Static_returning_clauseContext) + + // ExitError_logging_clause is called when exiting the error_logging_clause production. + ExitError_logging_clause(c *Error_logging_clauseContext) + + // ExitError_logging_into_part is called when exiting the error_logging_into_part production. + ExitError_logging_into_part(c *Error_logging_into_partContext) + + // ExitError_logging_reject_part is called when exiting the error_logging_reject_part production. + ExitError_logging_reject_part(c *Error_logging_reject_partContext) + + // ExitDml_table_expression_clause is called when exiting the dml_table_expression_clause production. + ExitDml_table_expression_clause(c *Dml_table_expression_clauseContext) + + // ExitTable_collection_expression is called when exiting the table_collection_expression production. + ExitTable_collection_expression(c *Table_collection_expressionContext) + + // ExitSubquery_restriction_clause is called when exiting the subquery_restriction_clause production. + ExitSubquery_restriction_clause(c *Subquery_restriction_clauseContext) + + // ExitSample_clause is called when exiting the sample_clause production. + ExitSample_clause(c *Sample_clauseContext) + + // ExitSeed_part is called when exiting the seed_part production. + ExitSeed_part(c *Seed_partContext) + + // ExitCondition is called when exiting the condition production. + ExitCondition(c *ConditionContext) + + // ExitExpressions_ is called when exiting the expressions_ production. + ExitExpressions_(c *Expressions_Context) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitCursor_expression is called when exiting the cursor_expression production. + ExitCursor_expression(c *Cursor_expressionContext) + + // ExitLogical_expression is called when exiting the logical_expression production. + ExitLogical_expression(c *Logical_expressionContext) + + // ExitUnary_logical_expression is called when exiting the unary_logical_expression production. + ExitUnary_logical_expression(c *Unary_logical_expressionContext) + + // ExitUnary_logical_operation is called when exiting the unary_logical_operation production. + ExitUnary_logical_operation(c *Unary_logical_operationContext) + + // ExitLogical_operation is called when exiting the logical_operation production. + ExitLogical_operation(c *Logical_operationContext) + + // ExitMultiset_expression is called when exiting the multiset_expression production. + ExitMultiset_expression(c *Multiset_expressionContext) + + // ExitRelational_expression is called when exiting the relational_expression production. + ExitRelational_expression(c *Relational_expressionContext) + + // ExitCompound_expression is called when exiting the compound_expression production. + ExitCompound_expression(c *Compound_expressionContext) + + // ExitRelational_operator is called when exiting the relational_operator production. + ExitRelational_operator(c *Relational_operatorContext) + + // ExitIn_elements is called when exiting the in_elements production. + ExitIn_elements(c *In_elementsContext) + + // ExitBetween_elements is called when exiting the between_elements production. + ExitBetween_elements(c *Between_elementsContext) + + // ExitConcatenation is called when exiting the concatenation production. + ExitConcatenation(c *ConcatenationContext) + + // ExitInterval_expression is called when exiting the interval_expression production. + ExitInterval_expression(c *Interval_expressionContext) + + // ExitModel_expression is called when exiting the model_expression production. + ExitModel_expression(c *Model_expressionContext) + + // ExitModel_expression_element is called when exiting the model_expression_element production. + ExitModel_expression_element(c *Model_expression_elementContext) + + // ExitSingle_column_for_loop is called when exiting the single_column_for_loop production. + ExitSingle_column_for_loop(c *Single_column_for_loopContext) + + // ExitMulti_column_for_loop is called when exiting the multi_column_for_loop production. + ExitMulti_column_for_loop(c *Multi_column_for_loopContext) + + // ExitUnary_expression is called when exiting the unary_expression production. + ExitUnary_expression(c *Unary_expressionContext) + + // ExitUnary_expression_core is called when exiting the unary_expression_core production. + ExitUnary_expression_core(c *Unary_expression_coreContext) + + // ExitImplicit_cursor_expression is called when exiting the implicit_cursor_expression production. + ExitImplicit_cursor_expression(c *Implicit_cursor_expressionContext) + + // ExitCollection_expression is called when exiting the collection_expression production. + ExitCollection_expression(c *Collection_expressionContext) + + // ExitCase_statement is called when exiting the case_statement production. + ExitCase_statement(c *Case_statementContext) + + // ExitSimple_case_statement is called when exiting the simple_case_statement production. + ExitSimple_case_statement(c *Simple_case_statementContext) + + // ExitSearched_case_statement is called when exiting the searched_case_statement production. + ExitSearched_case_statement(c *Searched_case_statementContext) + + // ExitCase_when_part_statement is called when exiting the case_when_part_statement production. + ExitCase_when_part_statement(c *Case_when_part_statementContext) + + // ExitCase_else_part_statement is called when exiting the case_else_part_statement production. + ExitCase_else_part_statement(c *Case_else_part_statementContext) + + // ExitCase_expression is called when exiting the case_expression production. + ExitCase_expression(c *Case_expressionContext) + + // ExitSimple_case_expression is called when exiting the simple_case_expression production. + ExitSimple_case_expression(c *Simple_case_expressionContext) + + // ExitSearched_case_expression is called when exiting the searched_case_expression production. + ExitSearched_case_expression(c *Searched_case_expressionContext) + + // ExitCase_when_part_expression is called when exiting the case_when_part_expression production. + ExitCase_when_part_expression(c *Case_when_part_expressionContext) + + // ExitCase_else_part_expression is called when exiting the case_else_part_expression production. + ExitCase_else_part_expression(c *Case_else_part_expressionContext) + + // ExitAtom is called when exiting the atom production. + ExitAtom(c *AtomContext) + + // ExitQuantified_expression is called when exiting the quantified_expression production. + ExitQuantified_expression(c *Quantified_expressionContext) + + // ExitString_function is called when exiting the string_function production. + ExitString_function(c *String_functionContext) + + // ExitStandard_function is called when exiting the standard_function production. + ExitStandard_function(c *Standard_functionContext) + + // ExitJson_function is called when exiting the json_function production. + ExitJson_function(c *Json_functionContext) + + // ExitJson_object_content is called when exiting the json_object_content production. + ExitJson_object_content(c *Json_object_contentContext) + + // ExitJson_object_entry is called when exiting the json_object_entry production. + ExitJson_object_entry(c *Json_object_entryContext) + + // ExitJson_table_clause is called when exiting the json_table_clause production. + ExitJson_table_clause(c *Json_table_clauseContext) + + // ExitJson_array_element is called when exiting the json_array_element production. + ExitJson_array_element(c *Json_array_elementContext) + + // ExitJson_on_null_clause is called when exiting the json_on_null_clause production. + ExitJson_on_null_clause(c *Json_on_null_clauseContext) + + // ExitJson_return_clause is called when exiting the json_return_clause production. + ExitJson_return_clause(c *Json_return_clauseContext) + + // ExitJson_transform_op is called when exiting the json_transform_op production. + ExitJson_transform_op(c *Json_transform_opContext) + + // ExitJson_column_clause is called when exiting the json_column_clause production. + ExitJson_column_clause(c *Json_column_clauseContext) + + // ExitJson_column_definition is called when exiting the json_column_definition production. + ExitJson_column_definition(c *Json_column_definitionContext) + + // ExitJson_query_returning_clause is called when exiting the json_query_returning_clause production. + ExitJson_query_returning_clause(c *Json_query_returning_clauseContext) + + // ExitJson_query_return_type is called when exiting the json_query_return_type production. + ExitJson_query_return_type(c *Json_query_return_typeContext) + + // ExitJson_query_wrapper_clause is called when exiting the json_query_wrapper_clause production. + ExitJson_query_wrapper_clause(c *Json_query_wrapper_clauseContext) + + // ExitJson_query_on_error_clause is called when exiting the json_query_on_error_clause production. + ExitJson_query_on_error_clause(c *Json_query_on_error_clauseContext) + + // ExitJson_query_on_empty_clause is called when exiting the json_query_on_empty_clause production. + ExitJson_query_on_empty_clause(c *Json_query_on_empty_clauseContext) + + // ExitJson_value_return_clause is called when exiting the json_value_return_clause production. + ExitJson_value_return_clause(c *Json_value_return_clauseContext) + + // ExitJson_value_return_type is called when exiting the json_value_return_type production. + ExitJson_value_return_type(c *Json_value_return_typeContext) + + // ExitJson_value_on_mismatch_clause is called when exiting the json_value_on_mismatch_clause production. + ExitJson_value_on_mismatch_clause(c *Json_value_on_mismatch_clauseContext) + + // ExitLiteral is called when exiting the literal production. + ExitLiteral(c *LiteralContext) + + // ExitNumeric_function_wrapper is called when exiting the numeric_function_wrapper production. + ExitNumeric_function_wrapper(c *Numeric_function_wrapperContext) + + // ExitNumeric_function is called when exiting the numeric_function production. + ExitNumeric_function(c *Numeric_functionContext) + + // ExitListagg_overflow_clause is called when exiting the listagg_overflow_clause production. + ExitListagg_overflow_clause(c *Listagg_overflow_clauseContext) + + // ExitOther_function is called when exiting the other_function production. + ExitOther_function(c *Other_functionContext) + + // ExitOver_clause_keyword is called when exiting the over_clause_keyword production. + ExitOver_clause_keyword(c *Over_clause_keywordContext) + + // ExitWithin_or_over_clause_keyword is called when exiting the within_or_over_clause_keyword production. + ExitWithin_or_over_clause_keyword(c *Within_or_over_clause_keywordContext) + + // ExitStandard_prediction_function_keyword is called when exiting the standard_prediction_function_keyword production. + ExitStandard_prediction_function_keyword(c *Standard_prediction_function_keywordContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitWindowing_clause is called when exiting the windowing_clause production. + ExitWindowing_clause(c *Windowing_clauseContext) + + // ExitWindowing_type is called when exiting the windowing_type production. + ExitWindowing_type(c *Windowing_typeContext) + + // ExitWindowing_elements is called when exiting the windowing_elements production. + ExitWindowing_elements(c *Windowing_elementsContext) + + // ExitUsing_clause is called when exiting the using_clause production. + ExitUsing_clause(c *Using_clauseContext) + + // ExitUsing_element is called when exiting the using_element production. + ExitUsing_element(c *Using_elementContext) + + // ExitAssignable_element is called when exiting the assignable_element production. + ExitAssignable_element(c *Assignable_elementContext) + + // ExitCollect_order_by_part is called when exiting the collect_order_by_part production. + ExitCollect_order_by_part(c *Collect_order_by_partContext) + + // ExitWithin_or_over_part is called when exiting the within_or_over_part production. + ExitWithin_or_over_part(c *Within_or_over_partContext) + + // ExitString_delimiter is called when exiting the string_delimiter production. + ExitString_delimiter(c *String_delimiterContext) + + // ExitCost_matrix_clause is called when exiting the cost_matrix_clause production. + ExitCost_matrix_clause(c *Cost_matrix_clauseContext) + + // ExitXml_passing_clause is called when exiting the xml_passing_clause production. + ExitXml_passing_clause(c *Xml_passing_clauseContext) + + // ExitXml_attributes_clause is called when exiting the xml_attributes_clause production. + ExitXml_attributes_clause(c *Xml_attributes_clauseContext) + + // ExitXml_namespaces_clause is called when exiting the xml_namespaces_clause production. + ExitXml_namespaces_clause(c *Xml_namespaces_clauseContext) + + // ExitXml_table_column is called when exiting the xml_table_column production. + ExitXml_table_column(c *Xml_table_columnContext) + + // ExitXml_general_default_part is called when exiting the xml_general_default_part production. + ExitXml_general_default_part(c *Xml_general_default_partContext) + + // ExitXml_multiuse_expression_element is called when exiting the xml_multiuse_expression_element production. + ExitXml_multiuse_expression_element(c *Xml_multiuse_expression_elementContext) + + // ExitXmlroot_param_version_part is called when exiting the xmlroot_param_version_part production. + ExitXmlroot_param_version_part(c *Xmlroot_param_version_partContext) + + // ExitXmlroot_param_standalone_part is called when exiting the xmlroot_param_standalone_part production. + ExitXmlroot_param_standalone_part(c *Xmlroot_param_standalone_partContext) + + // ExitXmlserialize_param_enconding_part is called when exiting the xmlserialize_param_enconding_part production. + ExitXmlserialize_param_enconding_part(c *Xmlserialize_param_enconding_partContext) + + // ExitXmlserialize_param_version_part is called when exiting the xmlserialize_param_version_part production. + ExitXmlserialize_param_version_part(c *Xmlserialize_param_version_partContext) + + // ExitXmlserialize_param_ident_part is called when exiting the xmlserialize_param_ident_part production. + ExitXmlserialize_param_ident_part(c *Xmlserialize_param_ident_partContext) + + // ExitAnnotations_clause is called when exiting the annotations_clause production. + ExitAnnotations_clause(c *Annotations_clauseContext) + + // ExitAnnotations_list is called when exiting the annotations_list production. + ExitAnnotations_list(c *Annotations_listContext) + + // ExitAnnotation is called when exiting the annotation production. + ExitAnnotation(c *AnnotationContext) + + // ExitSql_plus_command is called when exiting the sql_plus_command production. + ExitSql_plus_command(c *Sql_plus_commandContext) + + // ExitStart_command is called when exiting the start_command production. + ExitStart_command(c *Start_commandContext) + + // ExitSql_plus_filepath is called when exiting the sql_plus_filepath production. + ExitSql_plus_filepath(c *Sql_plus_filepathContext) + + // ExitWhenever_command is called when exiting the whenever_command production. + ExitWhenever_command(c *Whenever_commandContext) + + // ExitSet_command is called when exiting the set_command production. + ExitSet_command(c *Set_commandContext) + + // ExitTiming_command is called when exiting the timing_command production. + ExitTiming_command(c *Timing_commandContext) + + // ExitClear_command is called when exiting the clear_command production. + ExitClear_command(c *Clear_commandContext) + + // ExitPartition_extension_clause is called when exiting the partition_extension_clause production. + ExitPartition_extension_clause(c *Partition_extension_clauseContext) + + // ExitColumn_alias is called when exiting the column_alias production. + ExitColumn_alias(c *Column_aliasContext) + + // ExitTable_alias is called when exiting the table_alias production. + ExitTable_alias(c *Table_aliasContext) + + // ExitWhere_clause is called when exiting the where_clause production. + ExitWhere_clause(c *Where_clauseContext) + + // ExitInto_clause is called when exiting the into_clause production. + ExitInto_clause(c *Into_clauseContext) + + // ExitXml_column_name is called when exiting the xml_column_name production. + ExitXml_column_name(c *Xml_column_nameContext) + + // ExitCost_class_name is called when exiting the cost_class_name production. + ExitCost_class_name(c *Cost_class_nameContext) + + // ExitAttribute_name is called when exiting the attribute_name production. + ExitAttribute_name(c *Attribute_nameContext) + + // ExitSavepoint_name is called when exiting the savepoint_name production. + ExitSavepoint_name(c *Savepoint_nameContext) + + // ExitRollback_segment_name is called when exiting the rollback_segment_name production. + ExitRollback_segment_name(c *Rollback_segment_nameContext) + + // ExitSchema_name is called when exiting the schema_name production. + ExitSchema_name(c *Schema_nameContext) + + // ExitRoutine_name is called when exiting the routine_name production. + ExitRoutine_name(c *Routine_nameContext) + + // ExitPackage_name is called when exiting the package_name production. + ExitPackage_name(c *Package_nameContext) + + // ExitImplementation_type_name is called when exiting the implementation_type_name production. + ExitImplementation_type_name(c *Implementation_type_nameContext) + + // ExitParameter_name is called when exiting the parameter_name production. + ExitParameter_name(c *Parameter_nameContext) + + // ExitReference_model_name is called when exiting the reference_model_name production. + ExitReference_model_name(c *Reference_model_nameContext) + + // ExitMain_model_name is called when exiting the main_model_name production. + ExitMain_model_name(c *Main_model_nameContext) + + // ExitContainer_tableview_name is called when exiting the container_tableview_name production. + ExitContainer_tableview_name(c *Container_tableview_nameContext) + + // ExitAggregate_function_name is called when exiting the aggregate_function_name production. + ExitAggregate_function_name(c *Aggregate_function_nameContext) + + // ExitQuery_name is called when exiting the query_name production. + ExitQuery_name(c *Query_nameContext) + + // ExitGrantee_name is called when exiting the grantee_name production. + ExitGrantee_name(c *Grantee_nameContext) + + // ExitRole_name is called when exiting the role_name production. + ExitRole_name(c *Role_nameContext) + + // ExitConstraint_name is called when exiting the constraint_name production. + ExitConstraint_name(c *Constraint_nameContext) + + // ExitLabel_name is called when exiting the label_name production. + ExitLabel_name(c *Label_nameContext) + + // ExitType_name is called when exiting the type_name production. + ExitType_name(c *Type_nameContext) + + // ExitSequence_name is called when exiting the sequence_name production. + ExitSequence_name(c *Sequence_nameContext) + + // ExitException_name is called when exiting the exception_name production. + ExitException_name(c *Exception_nameContext) + + // ExitFunction_name is called when exiting the function_name production. + ExitFunction_name(c *Function_nameContext) + + // ExitProcedure_name is called when exiting the procedure_name production. + ExitProcedure_name(c *Procedure_nameContext) + + // ExitTrigger_name is called when exiting the trigger_name production. + ExitTrigger_name(c *Trigger_nameContext) + + // ExitVariable_name is called when exiting the variable_name production. + ExitVariable_name(c *Variable_nameContext) + + // ExitIndex_name is called when exiting the index_name production. + ExitIndex_name(c *Index_nameContext) + + // ExitCursor_name is called when exiting the cursor_name production. + ExitCursor_name(c *Cursor_nameContext) + + // ExitRecord_name is called when exiting the record_name production. + ExitRecord_name(c *Record_nameContext) + + // ExitLink_name is called when exiting the link_name production. + ExitLink_name(c *Link_nameContext) + + // ExitLocal_link_name is called when exiting the local_link_name production. + ExitLocal_link_name(c *Local_link_nameContext) + + // ExitConnection_qualifier is called when exiting the connection_qualifier production. + ExitConnection_qualifier(c *Connection_qualifierContext) + + // ExitColumn_name is called when exiting the column_name production. + ExitColumn_name(c *Column_nameContext) + + // ExitTableview_name is called when exiting the tableview_name production. + ExitTableview_name(c *Tableview_nameContext) + + // ExitXmltable is called when exiting the xmltable production. + ExitXmltable(c *XmltableContext) + + // ExitChar_set_name is called when exiting the char_set_name production. + ExitChar_set_name(c *Char_set_nameContext) + + // ExitSynonym_name is called when exiting the synonym_name production. + ExitSynonym_name(c *Synonym_nameContext) + + // ExitSchema_object_name is called when exiting the schema_object_name production. + ExitSchema_object_name(c *Schema_object_nameContext) + + // ExitDir_object_name is called when exiting the dir_object_name production. + ExitDir_object_name(c *Dir_object_nameContext) + + // ExitUser_object_name is called when exiting the user_object_name production. + ExitUser_object_name(c *User_object_nameContext) + + // ExitGrant_object_name is called when exiting the grant_object_name production. + ExitGrant_object_name(c *Grant_object_nameContext) + + // ExitColumn_list is called when exiting the column_list production. + ExitColumn_list(c *Column_listContext) + + // ExitParen_column_list is called when exiting the paren_column_list production. + ExitParen_column_list(c *Paren_column_listContext) + + // ExitKeep_clause is called when exiting the keep_clause production. + ExitKeep_clause(c *Keep_clauseContext) + + // ExitFunction_argument is called when exiting the function_argument production. + ExitFunction_argument(c *Function_argumentContext) + + // ExitFunction_argument_analytic is called when exiting the function_argument_analytic production. + ExitFunction_argument_analytic(c *Function_argument_analyticContext) + + // ExitFunction_argument_modeling is called when exiting the function_argument_modeling production. + ExitFunction_argument_modeling(c *Function_argument_modelingContext) + + // ExitRespect_or_ignore_nulls is called when exiting the respect_or_ignore_nulls production. + ExitRespect_or_ignore_nulls(c *Respect_or_ignore_nullsContext) + + // ExitArgument is called when exiting the argument production. + ExitArgument(c *ArgumentContext) + + // ExitType_spec is called when exiting the type_spec production. + ExitType_spec(c *Type_specContext) + + // ExitDatatype is called when exiting the datatype production. + ExitDatatype(c *DatatypeContext) + + // ExitPrecision_part is called when exiting the precision_part production. + ExitPrecision_part(c *Precision_partContext) + + // ExitNative_datatype_element is called when exiting the native_datatype_element production. + ExitNative_datatype_element(c *Native_datatype_elementContext) + + // ExitBind_variable is called when exiting the bind_variable production. + ExitBind_variable(c *Bind_variableContext) + + // ExitGeneral_element is called when exiting the general_element production. + ExitGeneral_element(c *General_elementContext) + + // ExitGeneral_element_part is called when exiting the general_element_part production. + ExitGeneral_element_part(c *General_element_partContext) + + // ExitTable_element is called when exiting the table_element production. + ExitTable_element(c *Table_elementContext) + + // ExitObject_privilege is called when exiting the object_privilege production. + ExitObject_privilege(c *Object_privilegeContext) + + // ExitSystem_privilege is called when exiting the system_privilege production. + ExitSystem_privilege(c *System_privilegeContext) + + // ExitConstant is called when exiting the constant production. + ExitConstant(c *ConstantContext) + + // ExitNumeric is called when exiting the numeric production. + ExitNumeric(c *NumericContext) + + // ExitNumeric_negative is called when exiting the numeric_negative production. + ExitNumeric_negative(c *Numeric_negativeContext) + + // ExitQuoted_string is called when exiting the quoted_string production. + ExitQuoted_string(c *Quoted_stringContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) + + // ExitId_expression is called when exiting the id_expression production. + ExitId_expression(c *Id_expressionContext) + + // ExitInquiry_directive is called when exiting the inquiry_directive production. + ExitInquiry_directive(c *Inquiry_directiveContext) + + // ExitOuter_join_sign is called when exiting the outer_join_sign production. + ExitOuter_join_sign(c *Outer_join_signContext) + + // ExitRegular_id is called when exiting the regular_id production. + ExitRegular_id(c *Regular_idContext) + + // ExitNon_reserved_keywords_in_18c is called when exiting the non_reserved_keywords_in_18c production. + ExitNon_reserved_keywords_in_18c(c *Non_reserved_keywords_in_18cContext) + + // ExitNon_reserved_keywords_in_12c is called when exiting the non_reserved_keywords_in_12c production. + ExitNon_reserved_keywords_in_12c(c *Non_reserved_keywords_in_12cContext) + + // ExitNon_reserved_keywords_pre12c is called when exiting the non_reserved_keywords_pre12c production. + ExitNon_reserved_keywords_pre12c(c *Non_reserved_keywords_pre12cContext) +} diff --git a/internal/engine/oracle/parser/transformGrammar.py b/internal/engine/oracle/parser/transformGrammar.py new file mode 100644 index 0000000000..e33021d1f7 --- /dev/null +++ b/internal/engine/oracle/parser/transformGrammar.py @@ -0,0 +1,56 @@ +import sys, os, re, shutil +from glob import glob +from pathlib import Path + +def main(argv): + for file in glob("./parser/*Lexer.g4"): + fix_lexer(file) + for file in glob("./parser/*Parser.g4"): + fix_parser(file) + +def fix_lexer(file_path): + print("Altering " + file_path) + if not os.path.exists(file_path): + print(f"Could not find file: {file_path}") + sys.exit(1) + parts = os.path.split(file_path) + file_name = parts[-1] + + shutil.move(file_path, file_path + ".bak") + input_file = open(file_path + ".bak",'r') + output_file = open(file_path, 'w') + for x in input_file: + if 'this.' in x and '}?' in x: + x = x.replace('this.', 'p.') + elif 'this.' in x: + x = x.replace('this.', 'l.') + output_file.write(x) + output_file.flush() + + print("Writing ...") + input_file.close() + output_file.close() + +def fix_parser(file_path): + print("Altering " + file_path) + if not os.path.exists(file_path): + print(f"Could not find file: {file_path}") + sys.exit(1) + parts = os.path.split(file_path) + file_name = parts[-1] + + shutil.move(file_path, file_path + ".bak") + input_file = open(file_path + ".bak",'r') + output_file = open(file_path, 'w') + for x in input_file: + if 'this.' in x: + x = x.replace('this.', 'p.') + output_file.write(x) + output_file.flush() + + print("Writing ...") + input_file.close() + output_file.close() + +if __name__ == '__main__': + main(sys.argv) diff --git a/internal/engine/oracle/reserved.go b/internal/engine/oracle/reserved.go new file mode 100644 index 0000000000..7819714acb --- /dev/null +++ b/internal/engine/oracle/reserved.go @@ -0,0 +1,125 @@ +package oracle + +import "strings" + +// oracleReservedKeywords is the set of Oracle SQL reserved words. +// +// Reference: https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Oracle-SQL-Reserved-Words.html +var oracleReservedKeywords = map[string]struct{}{ + "access": {}, + "add": {}, + "all": {}, + "alter": {}, + "and": {}, + "any": {}, + "as": {}, + "asc": {}, + "audit": {}, + "between": {}, + "by": {}, + "char": {}, + "check": {}, + "cluster": {}, + "column": {}, + "comment": {}, + "compress": {}, + "connect": {}, + "create": {}, + "current": {}, + "date": {}, + "decimal": {}, + "default": {}, + "delete": {}, + "desc": {}, + "distinct": {}, + "drop": {}, + "else": {}, + "exclusive": {}, + "exists": {}, + "file": {}, + "float": {}, + "for": {}, + "from": {}, + "grant": {}, + "group": {}, + "having": {}, + "identified": {}, + "immediate": {}, + "in": {}, + "increment": {}, + "index": {}, + "initial": {}, + "insert": {}, + "integer": {}, + "intersect": {}, + "into": {}, + "is": {}, + "level": {}, + "like": {}, + "lock": {}, + "long": {}, + "maxextents": {}, + "minus": {}, + "mlslabel": {}, + "mode": {}, + "modify": {}, + "noaudit": {}, + "nocompress": {}, + "not": {}, + "nowait": {}, + "null": {}, + "number": {}, + "of": {}, + "offline": {}, + "on": {}, + "online": {}, + "option": {}, + "or": {}, + "order": {}, + "pctfree": {}, + "prior": {}, + "privileges": {}, + "public": {}, + "raw": {}, + "rename": {}, + "resource": {}, + "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": {}, + "where": {}, + "with": {}, +} + +// IsReservedKeyword reports whether s (case-insensitive) is an Oracle reserved +// SQL keyword. It satisfies the compiler.Parser interface. +func (p *Parser) IsReservedKeyword(s string) bool { + _, ok := oracleReservedKeywords[strings.ToLower(s)] + return ok +} diff --git a/internal/engine/oracle/stdlib.go b/internal/engine/oracle/stdlib.go new file mode 100644 index 0000000000..f401ff9fcb --- /dev/null +++ b/internal/engine/oracle/stdlib.go @@ -0,0 +1,155 @@ +package oracle + +import ( + "github.com/sqlc-dev/sqlc/internal/sql/ast" + "github.com/sqlc-dev/sqlc/internal/sql/catalog" +) + +// Oracle built-in functions and datatypes. +// +// References: +// - Datatypes: https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html +// - Functions: https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Single-Row-Functions.html +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Aggregate-Functions.html +// +// The type names here are stored lower-cased to match the normalization applied +// by the converter (see identifier / normalizeDatatype in convert.go). + +// OracleTypes is the set of Oracle built-in scalar type names the engine +// recognizes (lower-cased to match the converter's normalization). It is used by +// the code generator (Phase 5) to map Oracle column types to Go types. +var OracleTypes = []string{ + "number", + "numeric", + "dec", + "decimal", + "integer", + "int", + "smallint", + "float", + "real", + "double precision", + "binary_float", + "binary_double", + "varchar2", + "nvarchar2", + "varchar", + "char", + "nchar", + "clob", + "nclob", + "long", + "blob", + "bfile", + "raw", + "long raw", + "date", + "timestamp", + "rowid", + "urowid", + "xmltype", + "boolean", +} + +// IsBuiltinType reports whether name (case-insensitive) is a known Oracle +// built-in scalar type. +func IsBuiltinType(name string) bool { + lower := toLowerASCII(name) + for _, t := range OracleTypes { + if t == lower { + return true + } + } + return false +} + +func toLowerASCII(s string) string { + b := []byte(s) + for i := range b { + if b[i] >= 'A' && b[i] <= 'Z' { + b[i] += 'a' - 'A' + } + } + return string(b) +} + +func defaultSchema(name string) *catalog.Schema { + s := &catalog.Schema{Name: name} + s.Funcs = stdFunctions() + return s +} + +// arg is a small helper for declaring a positional function argument. +func arg(typeName string) *catalog.Argument { + return &catalog.Argument{Type: &ast.TypeName{Name: typeName}} +} + +// ret is a small helper for declaring a function return type. +func ret(typeName string) *ast.TypeName { + return &ast.TypeName{Name: typeName} +} + +// stdFunctions returns Oracle's most common built-in functions. This is a +// starter set covering aggregates, string, numeric, date and conversion +// functions; more can be added incrementally. +func stdFunctions() []*catalog.Function { + return []*catalog.Function{ + // --- Aggregate functions --- + {Name: "COUNT", Args: []*catalog.Argument{}, ReturnType: ret("number")}, + {Name: "COUNT", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("number")}, + {Name: "SUM", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number"), ReturnTypeNullable: true}, + {Name: "AVG", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number"), ReturnTypeNullable: true}, + {Name: "MIN", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("any"), ReturnTypeNullable: true}, + {Name: "MAX", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("any"), ReturnTypeNullable: true}, + + // --- String functions --- + {Name: "LENGTH", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("number")}, + {Name: "SUBSTR", Args: []*catalog.Argument{arg("varchar2"), arg("number")}, ReturnType: ret("varchar2")}, + {Name: "SUBSTR", Args: []*catalog.Argument{arg("varchar2"), arg("number"), arg("number")}, ReturnType: ret("varchar2")}, + {Name: "UPPER", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "LOWER", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "TRIM", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "LTRIM", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "RTRIM", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "REPLACE", Args: []*catalog.Argument{arg("varchar2"), arg("varchar2"), arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "CONCAT", Args: []*catalog.Argument{arg("varchar2"), arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "INSTR", Args: []*catalog.Argument{arg("varchar2"), arg("varchar2")}, ReturnType: ret("number")}, + + // --- Numeric functions --- + {Name: "ABS", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + {Name: "CEIL", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + {Name: "FLOOR", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + {Name: "ROUND", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + {Name: "ROUND", Args: []*catalog.Argument{arg("number"), arg("number")}, ReturnType: ret("number")}, + {Name: "TRUNC", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + {Name: "MOD", Args: []*catalog.Argument{arg("number"), arg("number")}, ReturnType: ret("number")}, + {Name: "POWER", Args: []*catalog.Argument{arg("number"), arg("number")}, ReturnType: ret("number")}, + {Name: "SQRT", Args: []*catalog.Argument{arg("number")}, ReturnType: ret("number")}, + + // --- Date/time functions --- + {Name: "SYSDATE", Args: []*catalog.Argument{}, ReturnType: ret("date")}, + {Name: "SYSTIMESTAMP", Args: []*catalog.Argument{}, ReturnType: ret("timestamp")}, + {Name: "CURRENT_DATE", Args: []*catalog.Argument{}, ReturnType: ret("date")}, + {Name: "CURRENT_TIMESTAMP", Args: []*catalog.Argument{}, ReturnType: ret("timestamp")}, + {Name: "ADD_MONTHS", Args: []*catalog.Argument{arg("date"), arg("number")}, ReturnType: ret("date")}, + {Name: "MONTHS_BETWEEN", Args: []*catalog.Argument{arg("date"), arg("date")}, ReturnType: ret("number")}, + {Name: "EXTRACT", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("number")}, + + // --- Conversion functions --- + {Name: "TO_CHAR", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("varchar2")}, + {Name: "TO_CHAR", Args: []*catalog.Argument{arg("any"), arg("varchar2")}, ReturnType: ret("varchar2")}, + {Name: "TO_NUMBER", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("number")}, + {Name: "TO_DATE", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("date")}, + {Name: "TO_DATE", Args: []*catalog.Argument{arg("varchar2"), arg("varchar2")}, ReturnType: ret("date")}, + {Name: "TO_TIMESTAMP", Args: []*catalog.Argument{arg("varchar2")}, ReturnType: ret("timestamp")}, + {Name: "CAST", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("any")}, + + // --- NULL-handling / general functions --- + {Name: "NVL", Args: []*catalog.Argument{arg("any"), arg("any")}, ReturnType: ret("any")}, + {Name: "NVL2", Args: []*catalog.Argument{arg("any"), arg("any"), arg("any")}, ReturnType: ret("any")}, + {Name: "COALESCE", Args: []*catalog.Argument{arg("any"), arg("any")}, ReturnType: ret("any"), ReturnTypeNullable: true}, + {Name: "DECODE", Args: []*catalog.Argument{arg("any"), arg("any"), arg("any")}, ReturnType: ret("any"), ReturnTypeNullable: true}, + {Name: "GREATEST", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("any")}, + {Name: "LEAST", Args: []*catalog.Argument{arg("any")}, ReturnType: ret("any")}, + } +}